सी ++ ओवरलोड ऑपरेटर दो बार, एक रिटर्न गैर-कॉन्स्ट संदर्भ और अन्य कॉन्स्ट संदर्भ, वरीयता क्या है?

Question

मैं एक ही पैरामीटर सूची के साथ दो बार एक ऑपरेटर अधिभारित करता हूं। लेकिन अलग वापसी प्रकार के साथ:

T& operator()(par_list){blablabla}  
const T& operator()(par_list){blablabla} 

तो जब मैं() ऑपरेटर, जो समारोह क्या वरीयता या स्थिति के आधार पर कहा जा सकता है फोन कर रहा हूँ? मुझे पता है कि यदि मैं कॉन्स्ट फ़ंक्शन के तहत कॉल() को कॉल करता हूं तो इसे टी & एक होना चाहिए।

मैं उत्सुक हूं कि सी ++ ऐसी स्थिति से कैसे निपटता है और डिफ़ॉल्ट वरीयता कैसे काम करती है।

धन्यवाद

Answer 1

ये फ़ंक्शन एक दूसरे को अधिभारित नहीं करते हैं; उनके पास समान हस्ताक्षर हैं, और इसलिए एक ही फ़ंक्शन को फिर से परिभाषित करने का प्रयास, जो एक त्रुटि है। वापसी का प्रकार किसी फ़ंक्शन के हस्ताक्षर का हिस्सा नहीं है। फ़ंक्शन को अधिभारित करने के लिए, आपको एक ही नाम के साथ एक दूसरा फ़ंक्शन घोषित करना होगा, लेकिन विभिन्न पैरामीटर या const/volatile क्वालीफायर - यानी, फ़ंक्शन पर क्वालीफायर, रिटर्न प्रकार नहीं।

(वे एक दूसरे को ओवरराइड नहीं करते हैं; ओवरराइडिंग कक्षाओं को उनके मूल वर्गों के आभासी कार्यों में क्या किया जाता है)।

एक सदस्य फ़ंक्शन के const और गैर-const ओवरलोड को परिभाषित करना आम बात है;

T& operator()(par_list){blablabla} 
const T& operator()(par_list) const {blablabla} 
           ^^^^^ 

अब पहले बुलाया जाएगा यदि आप एक गैर const वस्तु को () लागू होते हैं, और एक const वस्तु पर दूसरा: const अधिभार, न सिर्फ वापसी प्रकार समारोह const घोषित करना चाहिए। उदाहरण के लिए:

Thingy nc; 
Thingy const c; 

nc(); // calls the first (non-const) overload 
c(); // calls the second (const) overload 

Answer 2

आप वापसी प्रकार के आधार पर एक समारोह/विधि ओवरलोड नहीं कर सकते। मैं संकलक से यहां एक त्रुटि फेंकने की उम्मीद करता हूं। आप क्या कर सकते विधि ही निर्दिष्ट एक const पद्धति के रूप में,

const T& operator()(par_list) const {blahblah} 

का उपयोग कर const क्वालीफायर न केवल इसका मतलब है कि यह एक const रिसीवर पर कहा जा सकता है, लेकिन यह भी अधिभार संकल्प में प्रयोग किया जाता है। ऐसा इसलिए होता है क्योंकि यह विधि को पारित होने वाले अंतर्निहित *this पैरामीटर को प्रभावित करता है; const विधि पर const क्वालीफायर का उपयोग करती है, और const क्वालीफायर ओवरलोड रिज़ॉल्यूशन के दौरान खाते में लिया जाता है।

Answer 3

तरह से आप अपने ऑपरेटरों को परिभाषित, कोई रास्ता नहीं संकलक तय कर सकते हैं जो ऑपरेटर() कॉल करने के लिए। कार्यों (और ऑपरेटरों) का अधिभार केवल तर्कों के प्रकार पर किया जा सकता है, कभी भी रिटर्न प्रकार पर नहीं। और वास्तव में, जैसे ही आप दूसरे को परिभाषित करते हैं, संकलन में आपको एक त्रुटि होगी, संकलक यह मानते हुए कि आप एक ही फ़ंक्शन/ऑपरेटर को फिर से परिभाषित कर रहे हैं।

हालांकि, निम्नलिखित सामान्य (और शायद तुम्हारे पास क्या है) है:

T& operator()(par_list){blablabla} 
const T& operator()(par_list) const {blablabla} 

इस अतिरिक्त तर्क सूची के बाद "स्थिरांक" मौजूद है क्योंकि आप को परिभाषित कर रहे गैर स्थिर सदस्य कार्य करता है और सदस्य कार्यों एक अंतर्निहित है छुपा तर्क: वर्ग के उदाहरण के लिए "यह" सूचक। वहां "कॉन्स" कीवर्ड इंगित करता है कि क्या यह छुपा सूचक एक कॉन्स उदाहरण है या नहीं।यह तर्क ओवरलोडिंग रिज़ॉल्यूशन में भाग लेता है और यह इस मामले में है कि संकलक का उपयोग करने के लिए ऑपरेटर का कौन सा संस्करण चुनने के लिए उपयोग किया जाता है।

तो:

class A { 
    T& operator()() { ... } 
    const T& operator()() const { .... } 
}; 

A a; 
const A& ca(a); 
a(); -> returns a T& 
ca(); -> returns a const T&