इस सी ++ कॉन्स संदर्भ एक्सेसर इंटरफ़ेस idiom के साथ कोई समस्या है?

Question

मैं एक वर्ग में एक संरचना को परिवर्तित कर रहा था ताकि मैं अपने चर के लिए एक सेटर इंटरफेस को लागू कर सकूं।
मैं उन सभी उदाहरणों को बदलना नहीं चाहता था जहां चर पढ़ा गया था, हालांकि।

struct foo_t { 
    int x; 
    float y; 
}; 

इस के लिए

: तो मैं इस परिवर्तित

class foo_t { 
    int _x; 
    float _y; 
public: 
    foot_t() : x(_x), y(_y) { set(0, 0.0); } 

    const int &x; 
    const float &y; 

    set(int x, float y) { _x = x; _y = y; } 
}; 

मैं इस में दिलचस्पी रखता हूँ, क्योंकि यह सी # के सार्वजनिक केवल पढ़ने के लिए गुण के विचार मॉडल करने के लिए लगता है।
ठीक संकलित करता है, और मैंने अभी तक कोई समस्या नहीं देखी है।

कन्स्ट्रक्टर में कॉन्स्ट संदर्भों को जोड़ने के बॉयलरप्लेट के अलावा, इस विधि के डाउनसाइड्स क्या हैं?
कोई अजीब एलियासिंग मुद्दे?
मैंने इस मुहावरे को पहले क्यों नहीं देखा है?

Answer 1

इसमें एक एलियासिंग समस्या है क्योंकि आप foo_t के आंतरिक डेटा के संदर्भ का पर्दाफाश करते हैं, तो foo_t ऑब्जेक्ट के बाहर कोड के लिए ऑब्जेक्ट के जीवनकाल से परे अपने डेटा में संदर्भों को संदर्भित करना संभव है। पर विचार करें:

foo_t* f = new foo_t(); 
const int& x2 = f->x; 
delete f; 
std::cout << x2; // Undefined behavior; x2 refers into a foo_t object that was deleted 

या, और भी आसान:

const int& x2 = foo_t().x; 
std::cout << x2; // Undefined behvior; x2 refers into a foo_t object that no longer exists 

ये विशेष रूप से यथार्थवादी उदाहरण नहीं हैं, लेकिन जब भी एक वस्तु को उजागर करता है या (अपने डेटा के लिए एक संदर्भ सार्वजनिक या निजी रिटर्न इस में कोई समस्या है)। बेशक, foo_t के संदर्भ में अपने जीवनकाल से परे ऑब्जेक्ट को पकड़ना संभव है, लेकिन दुर्घटना से चूकना या करना मुश्किल हो सकता है।

यह नहीं कि आप जो कर रहे हैं उसके खिलाफ यह एक तर्क है। असल में मैंने इस पैटर्न का इस्तेमाल पहले (एक अलग कारण से) किया है और मुझे नहीं लगता कि इसमें कुछ भी गलत है, इसके अलावा encapsulation की कमी से, जिसे आप पहचानते हैं। उपर्युक्त मुद्दा केवल कुछ पता होना चाहिए।

Answer 2

आपका दृष्टिकोण लचीला नहीं है। जब आपके पास प्रत्येक चर के लिए getter/setter है तो इसका मतलब है कि यदि आप अपनी कक्षा में कुछ जोड़ते हैं तो आपको अपने set विधि को फिर से लिखना नहीं है।

यह अच्छा नहीं है क्योंकि आपके पास const और non-const गेटर्स (जो शायद ही कभी उपयोग किए जाते हैं, लेकिन कभी-कभी उपयोगी हो सकते हैं)।

आप संदर्भों की प्रतिलिपि नहीं बना सकते हैं, इसलिए, आपकी कक्षा गैर-प्रतिलिपि बन जाती है।

इसके अलावा, अपने वर्ग में प्रारंभ संदर्भित अतिरिक्त स्मृति का मतलब है और हम, के बारे में बात कर रहे हैं होने उदाहरण के लिए, शीर्ष वर्ग (हालांकि मुझे लगता है कि एक वर्ग वास्तव में नहीं होना चाहिए), यह एक आपदा बन सकता है।

---

[सब कुछ है कि इस प्रकार पूरी तरह से व्यक्तिपरक है]

getters और setters का उद्देश्य है, मेरे मन को, के बारे में साधारण संशोधन नहीं है, बल्कि गतिविधियों का क्रम है कि मूल्य संशोधन में परिणाम encapsulating के बारे में या मान देता है (जिसे हम दृश्यमान परिणाम के रूप में देखते हैं)।

आपके उदाहरण के मामले में व्यक्तिगत रूप से संरचना अधिक प्रभावी होगी, क्योंकि यह पीओडी डेटा को लपेटती है और तर्कसंगत रूप से "संरचना" करती है।

Answer 3

एक समस्या यह है कि आपकी कक्षा अब कॉपी करने योग्य या असाइन करने योग्य नहीं है, और इसलिए वेक्टरों जैसे सी ++ कंटेनर में संग्रहीत नहीं किया जा सकता है। दूसरा यह है कि आपके कोड को बनाए रखने वाले अनुभवी सी ++ प्रोग्रामर इसे देखेंगे और "डब्ल्यूटीएफ !!" बहुत जोर से, जो कभी अच्छी बात नहीं है।

Answer 4

तुम भी कुछ इस तरह है, जिसके लिए काम करता है कर सकता है प्रकार में बनाया गया: (क्षमा करें यह कोड स्निपेट त्रुटियाँ हैं, लेकिन आप विचार प्राप्त करता है, तो)

template <typename T, typename F> 
class read_only{ 
    typedef read_only<T, F> my_type; 
    friend F; 

public: 
    operator T() const {return mVal;} 

private: 
    my_type operator=(const T& val) {mVal = val; return *this;} 
    T mVal; 
}; 


class MyClass { 
public: 
    read_only <int, MyClass> mInt; 
    void MyFunc() { 
     mInt = 7; //Works 
    } 
}; 

AnyFunction(){ 
    MyClass myClass; 
    int x = myClass.mVal; // Works (okay it hasnt been initalized yet so you might get a warning =) 
    myClass.mVal = 7; // Error 
}