सी ++ ओवरलोडिंग रूपांतरण ऑपरेटर कस्टम प्रकार से std :: स्ट्रिंग

Question

मुझे उम्मीद है कि कोई जवाब दे सकता है कि निम्नलिखित क्यों काम नहीं करता है। हालांकि मेरे साथ सहन, मैं बहुत ज्यादा एक noob अभी भी हूँ ... मैं सिर्फ क्यों निम्नलिखित

using namespace std; 
#include <string> 
#include <iostream> 

class testClass 
{ 
public: 
operator char*() {return (char*)"hi";}; 
operator int() {return 77;}; 
operator std::string () {return "hello";}; 
}; 

int main() 
{ 
char* c; 
int i; 
std::string s = "goodday"; 

testClass t; 

c = t; 
i = t; 
s = t; 

cout<< "char: " << c << " int: " << i << " string: "<<s<<endl; 

return 0; 
} 

मुझे एक संकलन समय त्रुटि देता है की तह तक पहुंचने नहीं कर सकते हैं:

myMain.cpp: In function ‘int main()’: 
myMain.cpp:23: error: ambiguous overload for ‘operator=’ in ‘s = t’ 
/usr/include/c++/4.2.1/bits/basic_string.h:500: note: candidates are: std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 
/usr/include/c++/4.2.1/bits/basic_string.h:508: note:     std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(const _CharT*) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 
/usr/include/c++/4.2.1/bits/basic_string.h:519: note:     std::basic_string<_CharT, _Traits, _Alloc>& std::basic_string<_CharT, _Traits, _Alloc>::operator=(_CharT) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

मैं तो असाइनमेंट

s = t; 

यह काम करता है।

मैं त्रुटि संदेश को समझने के लिए घंटों तक कोशिश कर रहा हूं, लेकिन मुझे सबसे ज्यादा परेशान करने वाला यह है कि यह char * के लिए काम करता है।

मैं किसी भी संकेत के लिए आभारी हूं। धन्यवाद! मार्कस

Answer 1

असल में, ऐसा इसलिए है क्योंकि std::string एक असाइनमेंट ऑपरेटर प्रदान करता है जो const char* लेता है।

Answer 2

क्या त्रुटि समझाने की कोशिश कर रहा है कि अपने काम "s = t", जहाँ s एक std::string है, तभी मान्य है t एक std::string भी थे, या अगर t एक [const] char* थे होगा। इसलिए संकलक, जिस पर एक दूसरे के ऊपर का चयन करने के कोई आधार नहीं है आपकी रूपांतरण ऑपरेटरों, या तो में एक t परिवर्तित कर सकते हैं .... रूपांतरण का चयन करके

आप इस स्पष्ट को स्पष्ट कर सकते हैं आप चाहते हैं:

s = t.operator std::string(); 
s = static_cast<std::string>(t); 

या आप केवल एक रूपांतरण प्रदान कर सकते हैं और जब आवश्यक हो तो उपयोगकर्ता को आगे रूपांतरण करने दें।

हालांकि आप अंत में पाएंगे - कि किसी भी रूपांतरण ऑपरेटर के मुकाबले ज्यादा परेशानी है ... यह बता रहा है कि std::string स्वयं एक रूपांतरण ऑपरेटर const char* पर प्रदान नहीं करता है।

Answer 3

कोई सटीक std :: string :: ऑपरेटर = नहीं है। उम्मीदवारों सम्मान, व्याख्या कर रहे हैं,

s = (const std::string)(std::string)t; 
s = (const char*)t; 
s = (char)(int)t; 

मुझे लगता है कि अगर आप स्थिरांक std :: स्ट्रिंग लौटाने के लिए इसे बदल बातें काम करेंगे। (संपादित करें: मैं गलत हूं।) यह भी ध्यान रखें कि पहले फ़ंक्शन को कॉन्स char * वापस करना चाहिए। यदि आपको char * के लिए एक स्ट्रिंग अक्षरशः डालना है, तो आप कुछ गलत कर रहे हैं; स्ट्रिंग अक्षर लिखने योग्य नहीं हैं।

Answer 4

$13.3.1.5/2 states- "The conversion functions of S and its base classes are considered. Those that are not hidden within S and yield type T or a type that can be converted to type T via a standard conversion sequence (13.3.3.1.1) are candidate functions. Conversion functions that return a cv-qualified type are considered to yield the cv-unqualified version of that type for this process of selecting candidate functions. Conversion functions that return “reference to cv2 X” return lvalues of type “cv2 X” and are therefore considered to yield X for this process of selecting candidate functions."

काम एस = इस प्रकार टी काम करता है:

क) 'टी' (testClass) के प्रकार के विचार कर रहे हैं के सभी सदस्यों को जो 'टी' के लिए परिवर्तित कर सकते हैं 'एस'।

Candidate 1: operator string(); // s created using member string::operator=(string const&) 
Candidate 2: operator char *() // s created using member string::operator=(char const*) 
Candidate 3: operator char *() // s created using member string::operator=(char *) 

ख) के ऊपर उम्मीदवारों के सभी व्यवहार्य (कि अन्य उम्मीदवारों के अभाव में, है, संकलक सफलतापूर्वक सबसे अच्छा उनमें से या तो करने के लिए समारोह कॉल)

ग हल कर सकते हैं) हालांकि, अब व्यवहार्य उम्मीदवार को निर्धारित करना होगा। रूपांतरण शामिल दृश्यों हैं:

Candidate 1: U1 : operator string() 
Candidate 2: U2 : operator char*()->const qualification to match string::operator=(char const*) 
Candidate 3: U3 : operator char*() 

$13.3.3.1.1/3 states - "The rank of a conversion sequence is determined by considering the rank of each conversion in the sequence and the rank of any reference binding (13.3.3.1.4). If any of those has Conversion rank, the sequence has Conversion rank;"

इसका मतलब है कि U1, U2 और U3 सब होने रूपांतरण रैंक कर रहे हैं और एक प्रथम स्तर पर न तो अन्य की तुलना में बेहतर है। हालांकि, मानक भी

User-defined conversion sequence U1 is a better conversion sequence than another user-defined conversion sequence U2 if they contain the same user-defined conversion function or constructor and if the second standard conversion sequence of U1 is better than the second standard conversion sequence of U2.

तो, देखते हैं इसका क्या अर्थ है।

U1 और U2 के बीच

, वे शामिल है, अलग-अलग रूपांतरण कार्य करता है और इसलिए कोई भी अन्य

U1 और U3 के बीच तुलना में बेहतर है, वे शामिल विभिन्न रूपांतरण कार्यों और इसलिए कोई भी अन्य की तुलना में

बेहतर है तो यू 1 और यू 2 के बारे में क्या। उनमें एक ही रूपांतरण फ़ंक्शन शामिल है, जो

से अधिक "और" स्थिति के पहले भाग को संतुष्ट करता है तो भाग के बारे में क्या है "और यदि यू 2 का दूसरा मानक रूपांतरण अनुक्रम यू 2 के दूसरे मानक रूपांतरण अनुक्रम से बेहतर है।"

यू 2 में, दूसरे मानक रूपांतरण अनुक्रम के लिए एक कॉन्स योग्यता की आवश्यकता होती है, जहां यू 3 में इसकी आवश्यकता नहीं होती है। यू 3 का दूसरा मानक रूपांतरण अनुक्रम एक सटीक मैच है।

लेकिन मानक राज्यों में तालिका 9 के रूप में, सीवी योग्यता को एक सटीक मैच भी माना जाता है।

इसलिए यू 2 और यू 3 वास्तव में अतिसंवेदनशील भी हैं जहां तक ​​ओवरलोड रिज़ॉल्यूशन माना जाता है।

इसका मतलब यह है U1, U2 और U3 हैं सब वास्तव में के रूप में अच्छा एक दूसरे को और संकलक के रूप में अस्पष्ट रूप में (काम के बयान का हिस्सा है) कॉल को हल करने पाता है, के रूप में वहाँ कोई स्पष्ट सबसे अच्छा व्यवहार्य समारोह है

Answer 5

ठीक है, बहुत पहले से ही बहुत धन्यवाद। मुझे लगता है कि मैं इसे लटकाना शुरू कर रहा हूं, ...

सबसे पहले मुझे इस तथ्य से अवगत नहीं था कि char सिर्फ 8-बिट int है। उस स्पष्टीकरण के लिए धन्यवाद।

तो मुझे लगता है कि समझते हैं, क्योंकि वहाँ तीन असाइनमेंट ऑपरेटरों std :: स्ट्रिंग, अलग तर्क (स्ट्रिंग, चार *, स्थिरांक चार *) मेरी अभिव्यक्ति के दाएँ हाथ की ओर के साथ प्रत्येक के लिए परिभाषित कर रहे हैं

s=t 

पता नहीं है, किस प्रकार का है में परिवर्तित करने की है, के बाद से वहाँ कई हैं, संभावित मिलान (के लिए यह काम करने के लिए std :: स्ट्रिंग) के साथ निर्धारित रूपांतरण या तो

operator int() {return 77;}; 
operator std::string () {return "hello";}; 

(के बाद से चार: 8 बिट पूर्णांक)

या

operator char*() {return (char*)"hi";}; 
operator std::string () {return "hello";}; 

यह सही है? तो बेवकूफ शब्दों में, असाइनमेंट का बाएं हाथ की ओर दाएं हाथ की तरफ नहीं बता रहा है, जिसकी अपेक्षा है, इसलिए rhs को अपने विकल्पों में से चुनना है, जहां कोई दूसरे के जैसा अच्छा है? std :: स्ट्रिंग ऑपरेटर = मेरे इरादे के लिए सहिष्णु होने वाला है?

अब तक इतना अच्छा है, मैंने सोचा कि मुझे यह मिला - लेकिन फिर, निम्नलिखित अस्पष्टता क्यों बनाते हैं?

using namespace std; 
#include <string> 
#include <iostream> 

class testClass 
    { 
    public: 
    operator float() {return float(77.333);}; 
    operator std::string () {return "hello";}; 
    }; 

    int main() 
    { 
    std::string s = "goodday"; 
    testClass t; 

    s = t; 

    cout<< " string: "<<s <<endl; 

    return 0; 
    } 

अब मेरे द्वारा परिभाषित केवल एक मिलान रूपांतरण ऑपरेटर है, है ना? std :: स्ट्रिंग ऑपरेटर = फ्लोट नहीं ले सकता है, या यह कर सकता है? या किसी भी तरह से फिर से चार प्रकार के बराबर के रूप में तैरता है?

मैं कोड को समझने के रूप में की = 'आरएचएस कह: "मुझे एक स्ट्रिंग, चार * या स्थिरांक चार * देना"

Rhs की जाँच करता है क्या यह testClass का एक उदाहरण दिया प्रदान कर सकते हैं, और केवल मैच testClass :: ऑपरेटर std :: स्ट्रिंग

फिर से, आपके धैर्य, विशेषज्ञता और समय के लोगों के लिए धन्यवाद - मैं वास्तव में इसकी सराहना करता हूं।