सी ++ में परिणामों में ओवरलोडिंग तुलना ऑपरेटर "अवैध ऑपरेटर <"

Question

वर्तमान में वस्तु का एक वेक्टर सॉर्ट करने के लिए, स्ट्रिंग वाली प्रयास कर प्रत्येक वस्तु के साथ, C++

तार अक्षरों या संख्याओं (एक डिजाइन बाधा की वजह से शामिल कर सकते हैं , यह आवश्यक है, क्योंकि तुलनित्र बदला जा सकता है)।

इस समय, वस्तु का वर्ग अधिभारित हो गया है, ताकि जब दो वस्तुओं की तुलना की जा सके, तो उनके तारों की तुलना की जाती है। यह एक बिंदु पर काम करता है - हालांकि, जब मैं वस्तुओं को व्यवस्थित करने के लिए एक प्रकार के ऑपरेशन (जैसे एसटीएल सॉर्ट) का उपयोग करता हूं, तो यह ऑर्डर में "1", "4", "12" जैसे तीन तारों को सॉर्ट करेगा "1", "12", "4"। 4 12 से अधिक है, लेकिन क्योंकि यह सबसे बाएं अंक से तुलना करना शुरू करता है, यह 'गलत' प्रकार होता है।

मेरी प्रारंभिक प्रतिक्रिया यह बदलना था कि मैं तुलना ऑपरेशन को ओवरलोड कर रहा था। मैं सबसे पहले स्ट्रिंग की लंबाई की जांच करूँगा जो मैं तुलना कर रहा था - यदि स्ट्रिंग की सामग्री बड़ी या छोटी थी तो एक बताना संकेत होगा।

// overloaded comparision operators 
friend bool operator<(const nodeRecord & record1, const nodeRecord & record2){ 
    // we need to deal with strings of different lengths... 
    if(record1.comparator.length() < record2.comparator.length()) 
     return true; 
    else 
     return (record1.comparator < record2.comparator); 
} 

एक में इस आपरेशन के परिणाम "अभिव्यक्ति: अवैध ऑपरेटर <" रनटाइम के दौरान संदेश।

कोई विचार है कि मैं कहां गलती कर रहा हूं? ऐसा लगता है कि मैं ऑपरेशन को निर्देशित करने में सक्षम होना चाहिए कि मैं सॉर्टिंग ऑपरेशन कैसे करना चाहता हूं - भले ही यह अमान्य है, क्योंकि मैं वर्तमान में ऑब्जेक्ट्स रखने के लिए वेक्टर का उपयोग कर रहा हूं। nodeRecord वस्तु के प्रारंभ के दौरान

तुलनाकारी:

nodeRecord(int fromNode, int toNode, int connectionCost, bool compareByCost = false){ 
    // take the provided stock information and insert it into the object 
    stringstream fromNodeSS; 
    fromNodeSS << fromNode; 
    this->fromNode = fromNodeSS.str(); 
    stringstream toNodeSS; 
    toNodeSS << toNode; 
    this->toNode = toNodeSS.str(); 
    this->connectionCost = connectionCost; 

    // set the comparator to our chosen comparision term 
    if (!compareByCost){ 
     this->comparator = this->fromNode; // we use from node in this case, since we build the tree outwards 
    } 
    else{ 
     stringstream ss; 
     ss << this->connectionCost; 
     this->comparator = ss.str(); // we use the connection cost in this case, to allow us to sort new connections 
    } 

    // set this as a non-null (active) record 
    this->nullRecord = false; 
} 

Answer 1

आप ऑपरेटर प्रभावी रूप से अमान्य है।

ऑपरेटर < में कई गणितीय गुण होने चाहिए यदि आप इसे सॉर्ट करने के लिए उपयोग करने योग्य बनाना चाहते हैं।

x < y => !(y < x)

के x = "b" और y = "aa" को परिभाषित करते हैं: एक AntiSymmetry संपत्ति है।

• x < y क्योंकि "b" की लंबाई "aa"
• y < x क्योंकि "aa" की लंबाई से हीन है "b"

हम करने के लिए अवर है?

यह भी ध्यान दें कि 0 एस द्वारा उपसर्ग किए जाने पर आपकी परिभाषा संख्याओं के लिए अजीब है।

ओह, और स्ट्रिंग की तुलना संख्याओं की तुलना करने से धीमी है।

मेरा लेना? तुलना जानकारी के साथ नोड को बदलने बंद करो। वास्तविक तुलना मोड में नोड के भीतर कुछ भी नहीं है।

फिर आप केवल दो तुलनात्मक तरीकों को लिखेंगे, जो लागत से तुलना करते हैं और दूसरे मूल रूप से तुलना करते हैं।

---

और वापस मूल मुद्दे पर आने के लिए, कैसे एक तुलनित्र कि पर विचार ["a", "b", "aa"] अनुसार क्रमबद्ध लिखने के लिए?

आप लगभग वहां थे, लेकिन "लंबाई" तुलना अपूर्ण है। लंबाई की भिन्नता के मामले में आपको वास्तविक शब्दावली तुलना में वापस गिरने की आवश्यकता है, इस प्रकार आप उस मामले को भूल गए हैं जहां दाएं हाथ की ओर तर्क की लंबाई बाएं हाथ की ओर से कम है।

इस प्रकार सही रूप दो स्ट्रिंग मान, है:

bool compare(std::string const& lhs, std::string const& rhs) { 
    if (lhs.length() < rhs.length()) { return true; } 
    if (rhs.length() < lhs.length()) { return false; } // don't forget this 
    return lhs < rhs; 
} 

Answer 2

क्यों आप एक ही तुलनित्र का उपयोग नहीं करते और उस समारोह एक छोटे से होशियार बनाने? शुरुआत में संख्यात्मक वर्णों की जांच करें, यदि हां, तो strtol() या atoi() की एक जोड़ी करें और परिणामों की तुलना करें।

अन्यथा अपनी गैर-संख्यात्मक आवश्यकताओं के अनुसार स्ट्रिंग और वर्णों की लंबाई की तुलना करें।

Answer 3

त्रुटि कोड फेंकने वाला निम्न कोड सेगमेंट मिला, फिर सोचा कि मेरा ओवरलोडेड ऑपरेशन कैसे काम कर रहा था।

template<class _Ty1, class _Ty2> inline 
    bool _Debug_lt(_Ty1& _Left, _Ty2& _Right, 
     _Dbfile_t _File, _Dbline_t _Line) 
    { // test if _Left < _Right and operator< is strict weak ordering 
    if (!(_Left < _Right)) 
     return (false); 
    else if (_Right < _Left) 
     _DEBUG_ERROR2("invalid operator<", _File, _Line); 
    return (true); 
    } 

कार्य समाधान इस

// overloaded comparision operators 
friend bool operator<(const nodeRecord & record1, const nodeRecord & record2){ 
    // we need to deal with strings of different lengths... 
    if(record1.comparator.length() > record2.comparator.length() 
     && (record1.comparator.length() !=0 && record2.comparator.length() != 0)) 
     return false; 
    else if(record1.comparator.length() < record2.comparator.length() 
     && (record1.comparator.length() !=0 && record2.comparator.length() != 0)) 
     return true; 
    else 
     return (record1.comparator < record2.comparator); 
} 

हर किसी को जो मदद के लिए धन्यवाद (टिप्पणी माथीउ एम द्वारा छोड़ा करने के लिए धन्यवाद फिर से संशोधित) है!