कॉलर के दायरे में पारदर्शी रूप से अस्थायी रूप से डालें

Question

सी ++ में, operator-> में विशेष अर्थशास्त्र है, यदि लौटाया गया प्रकार सूचक नहीं है, तो वह उस प्रकार पर operator-> पर कॉल करेगा। लेकिन, मध्यवर्ती मूल्य को कॉलिंग अभिव्यक्ति द्वारा अस्थायी के रूप में रखा जाता है। इस कोड को दिए गए मान में परिवर्तन का पता लगाने के लिए अनुमति देता है:

template<class T> 
class wrapper 
{ 
    // ... 
    T val; 

    struct arrow_helper 
    { 
     arrow_helper(const T& temp) 
      : temp(temp){} 
     T temp; 
     T* operator->() { return &temp; } 
     ~arrow_helper() { std::cout << "modified to " << temp << '\n'; } 
    }; 

    arrow_helper operator->() { return{ val }; } 
    //return const value to prevent mistakes 
    const T operator*() const { return val; } 
} 

और फिर T के सदस्यों पारदर्शी रूप से पहुँचा जा सकता है:

wrapper<Foo> f(/*...*/); 
f->bar = 6; 

क्या ऐसा करने से गलत हो सकता है कि है? साथ ही, operator-> के अलावा अन्य कार्यों के साथ इस प्रभाव को पाने का कोई तरीका है?

संपादित करें: एक और मुद्दा मैं का सामना करना पड़ा क्योंकि जब arrow_helper दूसरा operator-> से विलुप्त है यह मूल्य वापस मूल करने के लिए फिर से अधिलेखित कर देता है जैसे

f->bar = f->bar + 6; 

भाव में है। मेरा अर्ध-सुरुचिपूर्ण समाधान arrow_helper के लिए T orig है जो छुपा हुआ है, और assert(orig == *owner) विनाशक में है।

Answer 1

कोई गारंटी नहीं कि सभी परिवर्तनों को पकड़ा हो जाएगा नहीं है:

Foo &x = f->bar; 
x = 6; /* undetected change */ 

Answer 2

अगर वहाँ T के इंटरफेस के माध्यम से T के भीतर किसी भी डेटा के लिए एक संदर्भ या अन्यथा हड़पने के लिए कोई रास्ता नहीं है, मुझे लगता है कि यह सुरक्षित होना चाहिए । यदि इस तरह के पॉइंटर या संदर्भ को पकड़ने का कोई तरीका है, तो आप ऐसा करते हैं और जैसे ही कोई इस तरह के संदर्भ को बचाता है और बाद में इसका उपयोग करता है, अपरिभाषित व्यवहार में किया जाता है।