जब कॉल एक ही गैर-कॉन्स संस्करण अधिभारित सदस्य फ़ंक्शन से होता है तो कॉन्स्ट क्वालीफायर को निकालना ठीक है?

Question

उदाहरण के लिए:

struct B{}; 

struct A { 

const B& findB() const { /* some non trivial code */ } 

// B& findB() { /* the same non trivial code */ } 

B& findB() { 
     const A& a = *this; 
     const B& b = a.findB(); 
     return const_cast<B&>(b); 
    } 
}; 

बात मैं लगातार findB और गैर निरंतर findB सदस्य समारोह के अंदर एक ही तर्क दोहराने से बचें करना चाहते हैं।

return const_cast<B&>(static_cast<const A*>(this)->findB()); 

दूर कास्टिंग const सुरक्षित है केवल जब प्रश्न में वस्तु मूल रूप से घोषित नहीं किया गया था:

Answer 1

हाँ, आप const करने के लिए वस्तु डाल सकता, const संस्करण कहते हैं, तो const गैर करने के लिए परिणाम डाली const। चूंकि आप गैर-const सदस्य फ़ंक्शन में हैं, इसलिए आप इसे केस के रूप में जान सकते हैं, लेकिन यह कार्यान्वयन पर निर्भर करता है। विचार करें:

class A { 
public: 

    A(int value) : value(value) {} 

    // Safe: const int -> const int& 
    const int& get() const { 
     return value; 
    } 

    // Clearly unsafe: const int -> int& 
    int& get() { 
     return const_cast<int&>(static_cast<const A*>(this)->get()); 
    } 

private: 
    const int value; 
}; 

आम तौर पर, मेरे सदस्य कार्य कम होते हैं, इसलिए पुनरावृत्ति सहनशील होती है। आप कभी-कभी किसी निजी टेम्पलेट सदस्य फ़ंक्शन में कार्यान्वयन को कारक बना सकते हैं और दोनों संस्करणों से कॉल कर सकते हैं।

Answer 2

मुझे लगता है, कि यहां डाली का उपयोग ठीक है, लेकिन अगर आप निश्चित रूप से इसे से बचना चाहते हैं, तो आपको कुछ टेम्पलेट जादू का उपयोग कर सकते हैं:

struct B 
{ 
    B(const B&) 
    { 
     std::cout << "oops I copied"; 
    } 
    B(){} 
}; 

struct A { 
public: 
    A(){} 
    A(const A&){ std::cout << "a is copied:(\n";} 
    const B& findB() const { return getter(*this); }  
    B& findB() { return getter(*this); } 

private: 
    template <typename T, typename V> 
    struct same_const 
    { 
     typedef V& type; 
    }; 

    template <typename T, typename V> 
    struct same_const<const T, V> 
    { 
     typedef const V& type; 
    }; 

    template <typename T> 
    static typename same_const<T,B>::type getter(T& t) { return t.b;} 

    B b; 

}; 

int main() 
{ 
    A a; 
    const A a_const; 
    const B& b1 = a.findB(); 
    B& b2 = a.findB(); 

    const B& b3 = a_const.findB(); 
    //B& b4 = a_const.findB(); 
}