सी ++ ऑपरेटर परिभाषा के बिना विफल

Question

मैं वर्तमान में थोड़ा प्रतिबंधित वातावरण में एक सी ++ एप्लिकेशन पोर्ट कर रहा हूं। एप्लिकेशन एसटीएल, स्ट्रिंग और स्ट्रीम कक्षाओं का उपयोग करता है। मैं इनके सरलीकृत संस्करणों को फिर से लिख रहा हूं जो मेरे पर्यावरण में अच्छी तरह से खेलेंगे।

मुझे इस बारे में चिंता है कि मेरा आवेदन सभी आवश्यक ऑपरेटर परिभाषाओं के बिना भी संकलित हो रहा है। उदाहरण के लिए, मेरी स्ट्रिंग कक्षाओं के लिए मैंने परिभाषित किया:

string operator+ (const string& lhs, const string& rhs); 

और यह पर्याप्त था। हालांकि, मैंने देखा कि अक्सर ऐसे मामले थे जिनमें Mystring + "कुछ स्थिर स्ट्रिंग" थी और यह कहीं भी मेरे कोड में परिभाषित नहीं है। जब मैंने स्पष्ट रूप से इसे जोड़ा तो इसका उपयोग किया गया:

string operator+ (const string& lhs, const char* rhs); 

इससे पहले क्या चल रहा था? इससे पहले कि मैंने दूसरा फ़ंक्शन जोड़ा, इसे सफलतापूर्वक संकलित किया गया। निश्चित रूप से संकलक यह समझने में सक्षम नहीं होगा कि मेरी स्ट्रिंग क्लास में सी-स्टाइल स्ट्रिंग को कैसे जोड़ा जाए।

मुझे अब मेरे कार्यक्रम में अजीब व्यवहार हो रहा है और मुझे आश्चर्य है कि यह अन्य ऑपरेटरों के कारण अनिर्धारित है। क्या प्रोग्राम द्वारा इसकी आवश्यकता होने पर ऐसी ऑपरेटर परिभाषाओं की आवश्यकता के लिए कंपाइलर को लागू करने का कोई तरीका है?

पीएस मेरी स्ट्रिंग क्लास एक अद्वितीय नामस्थान में है और std ::

Answer 1

अपने शेष कोड को देखे बिना निश्चित होना असंभव है, लेकिन इस मामले में शायद यह अनुमान लगाने में बहुत मुश्किल नहीं है। आपके पास लगभग string के लिए निश्चित रूप से एक कन्स्ट्रक्टर है जो char const * को इसके पैरामीटर के रूप में लेता है, इसलिए क्या हो रहा है यह है कि संकलक char const * को string में परिवर्तित करने के लिए उस ctor का उपयोग कर रहा है, फिर string operator+ (const string& lhs, const string& rhs); का उपयोग करके इसे संयोजित करने के लिए।

यह होने की अनुमति देना (यदि नहीं है) सदस्य ऑपरेटरों के बजाय इन ऑपरेटरों को ग्लोबल्स के साथ ओवरलोड करने का प्राथमिक कारण है। सदस्य कार्य के रूप में वे दाएं ऑपरेंड को परिवर्तित कर सकते हैं, लेकिन बाएं नहीं।

Answer 2

जब आप const char* पास करते हैं, तो एक स्ट्रिंग ऑब्जेक्ट शायद बनाया गया था और ऑपरेटर + को पास कर दिया गया था। यदि आप डीबगर में कोड के माध्यम से कदम उठाते हैं तो आप शायद कन्स्ट्रक्टर को सत्यापित करने में सक्षम होंगे।

Answer 3

शायद आपके पास कक्षा में एक निर्माता है जो इनपुट पैरामीटर के रूप में const char * लेता है, अधिकतर इस कन्स्ट्रक्टर का उपयोग अंतर्निहित कवरेज और अजीब व्यवहार के लिए किया जाता है।

अपने निर्माता जो जहां आप इसे इस्तेमाल किया जा करने का इरादा नहीं लेता const char *explicit के रूप में, यह अंतर्निहित रूपांतरण के लिए इसके उपयोग को अक्षम हैं घोषित।

Answer 4

क्या आपकी 'स्ट्रिंग' कक्षा में एक तर्क निर्माता है जो एक कॉन्स्ट char * लेता है? क्या वह एकल तर्क निर्माता 'स्पष्ट' के रूप में चिह्नित है?

यदि यह स्पष्ट नहीं है, तो सबसे संभावित उत्तर यह है कि कंपाइलर आपके कनवर्टिंग कन्स्ट्रक्टर के माध्यम से char * से अस्थायी स्ट्रिंग ऑब्जेक्ट का निर्माण कर रहा है, और उसके बाद अपने दो तर्क अतिरिक्त ऑपरेटर को कॉल करने के लिए उस अस्थायी स्ट्रिंग का उपयोग कर रहा है।

Answer 5

संकलक यह नहीं जानता कि आपकी स्ट्रिंग को std::string या char* तक कैसे परिवर्तित किया जाए, जब तक कि आप निर्दिष्ट न करें।

अपनी कक्षा घोषणा में रूपांतरण कन्स्ट्रक्टर या कास्ट ऑपरेटरों की तलाश करें।

class MyString 
{ 
    MyString(char*); 
    MyString(std::string); 

    operator std::string(); 
    operator char*(); 
}; 

इन्हें पूरी तरह से बुलाया जाएगा।

आप इसे रोकने से रोकने के लिए अपने निर्माता के लिए explicit कीवर्ड निर्दिष्ट कर सकते हैं।

यदि यह समस्या का समाधान नहीं करता है, तो आपके पास ऑपरेटरों को कहीं अधिक अधिभारित होना चाहिए, सर्वोत्तम रूप से उन्हें डीबगर के साथ कोड के माध्यम से कदम उठाना चाहिए।