त्वरित और गंदे ऑपरेटर =

Question

मेरी कक्षाओं में मैं अक्सर एक त्वरित operator!=!(*this == rhs) वापस लौट कर लिखते हैं, उदाहरण के लिए:

class Foo 
{ 
private: 
    int n_; 
    std::string str_; 
public: 
    ... 
    bool operator==(const Foo& rhs) const 
    { 
     return n_ == rhs.n_ && str_ == rhs.str_; 
    } 

    bool operator!=(const Foo& rhs) const 
    { 
     return !(*this == rhs); 
    } 
}; 

मैं यह कर के साथ किसी भी स्पष्ट समस्याओं को नहीं देख सकते, लेकिन सोचा था कि मैं अगर कोई पूछने चाहते हैं किसी के बारे में जानता है।

Answer 1

मेरा मानना ​​है कि operator!= को लागू करने की पसंदीदा विधि है ताकि आप स्वयं को दोहराएं, और आपके पास operator== के साथ गारंटीकृत सही संबंध हैं।

Answer 2

नहीं, यह बिल्कुल ठीक है - मैं बिल्कुल वही करता हूं।

Answer 3

operator!=!operator== के रूप में परिभाषित करना ठीक

इन तुच्छ बराबर ऑपरेटरों आसानी से परिभाषित हो रही के लिए है, मैं हमेशा Boost.Operators का उपयोग करें।
केवल operator== और operator!= (यानी equality_comparable<> का उपयोग करके) बहुत अधिक लाभ नहीं मिलता है।

लेकिन जब आपको भी कम और अधिक की आवश्यकता होती है, या operator+, operator* आदि का कुछ संयोजन यह बहुत सुविधाजनक हो जाता है।

अपने मामले के लिए एक उदाहरण अभी भी ऑपरेटर ओवरलोडिंग को पसंद करने और नहीं IsEqual (ObjA, ObjB) के लिए

class Foo : private boost::equality_comparable<Foo> 
{ 
    private: 
    int n_; 
    std::string str_; 
    public: 
    ... 
    bool operator==(const Foo& rhs) const 
    { 
     return n_ == rhs.n_ && str_ == rhs.str_; 
    } 

};