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

Question

मैं निम्नलिखित है वर्ग: -

class myclass 
{ 
    size_t st; 

    myclass(size_t pst) 
    { 
     st=pst; 
    } 

    operator int() 
    { 
     return (int)st; 
    } 

    int operator+(int intojb) 
    { 
     return int(st) + intobj; 
    } 

}; 

इस रूप में लंबे समय मैं इसका इस्तेमाल के रूप में ठीक काम करता है इस तरह: -

char* src="This is test string"; 
int i= myclass(strlen(src)) + 100; 

लेकिन मैं ऐसा करने में असमर्थ हूँ यह: -

int i= 100+ myclass(strlen(src)); 

कोई विचार, मैं इसे कैसे प्राप्त कर सकता हूं ??

Answer 1

वर्ग के ऑपरेटर ओवरलोडिंग के बाहर लागू:

class Num 
{ 
public: 
    Num(int i) 
    { 
     this->i = i; 
    } 

    int i; 
}; 

int operator+(int i, const Num& n) 
{ 
    return i + n.i; 
} 

Answer 2

आप एक वैश्विक समारोह ऑपरेटर + (पूर्णांक, MyClass) की जरूरत है ऐसा करने के लिए:

int operator+(int intobj, myclass myobj) 
{ return intobj + int(myobj); } 

Answer 3

आप एक के रूप में ऑपरेटर को लागू करना गैर-सदस्य फ़ंक्शन बाईं ओर एक प्राचीन int को अनुमति देने के लिए।

int operator+(int lhs, const myclass& rhs) { 
    return lhs + (int)rhs; 
} 

Answer 4

अन्य उत्तर यहाँ समस्या का समाधान होगा, लेकिन निम्नलिखित पैटर्न का उपयोग मैं जब मैं यह कर रहा हूँ है:

class Num 
{ 
public: 
    Num(int i)  // Not explicit, allows implicit conversion to Num 
    : i_ (i) 
    { 
    } 

    Num (Num const & rhs) 
    : i_ (rhs.i_) 
    { 
    } 

    Num & operator+= (Num const & rhs) // Implement += 
    { 
    i_ += rhs.i_; 
    return *this; 
    } 

private: 
    int i_; 
}; 

// 
// Because of Num(int), any number on the LHS or RHS will implicitly 
// convert to Num - so no need to have lots of overloads 
Num operator+(Num const & lhs, Num const & rhs) 
{ 
    // 
    // Implement '+' using '+=' 
    Num tmp (lhs); 
    tmp+=rhs; 
    return tmp; 
} 

इस दृष्टिकोण के प्रमुख लाभों में से एक है कि अपने कार्यों एक दूसरे के संदर्भ में लागू किया जा सकता है जो आपको आवश्यक समग्र कोड की मात्रा को कम करता है।

अद्यतन:

बे पर प्रदर्शन चिंताओं रखने के लिए, मैं शायद की तरह एक इनलाइन समारोह कुछ के रूप में गैर सदस्य ऑपरेटर + निर्धारित करना होगा:

inline Num operator+(Num lhs, Num const & rhs) 
{ 
    lhs+=rhs; 
    return lhs; 
} 

सदस्य आपरेशन भी इनलाइन हैं (के रूप में वे 'वर्ग निकाय में घोषित किया गया है) और इसलिए सभी कोड में दो कच्चे int वस्तुओं को जोड़ने की लागत के बहुत करीब होना चाहिए।

अंत में, जैसा कि आधे से इंगित किया गया है, सामान्य रूप से अंतर्निहित रूपांतरणों को अनुमति देने के परिणामों पर विचार किया जाना चाहिए। उपर्युक्त उदाहरण मानता है कि एक अभिन्न प्रकार से 'न्यू' में परिवर्तित करना समझदारी है।