मैं कक्षा तीर ऑपरेटर कैसे बना और उपयोग करूं?

Question

तो, इसके लिए हर जगह खोजबीन के बाद, मैं एक वर्ग तीर ऑपरेटर बनाने का तरीका खोजने के लिए, नहीं कर पा रहे, यानी,

class Someclass 
{ 
    operator->() /* ? */ 
    { 
    } 
}; 

मैं सिर्फ पता है कि कैसे इसके साथ काम करके उससे उचित उपयोग करने के लिए की जरूरत है। - इसके इनपुट क्या हैं? - यह क्या लौटता है? - मैं इसे सही तरीके से घोषित/प्रोटोटाइप कैसे करूं?

Answer 1

ऑपरेटर के लिए अनुवाद किया जाएगा -> सदस्य पहुँच ओवरलोड प्रयोग किया जाता है । एक छोटा सा उदाहरण:

#include <iostream> 
struct A 
{ 
    void foo() {std::cout << "Hi" << std::endl;} 
}; 

struct B 
{ 
    A a; 
    A* operator->() { 
     return &a; 
    } 
}; 

int main() { 
    B b; 
    b->foo(); 
} 

यह आउटपुट:

Hi 

Answer 2

class T { 
    public: 
     const memberFunction() const; 
}; 

// forward declaration 
class DullSmartReference; 

class DullSmartPointer { 
    private: 
     T *m_ptr; 
    public: 
     DullSmartPointer(T *rhs) : m_ptr(rhs) {}; 
     DullSmartReference operator*() const { 
      return DullSmartReference(*m_ptr); 
     } 
     T *operator->() const { 
      return m_ptr; 
     } 
}; 

http://en.wikibooks.org/wiki/C++_Programming/Operators/Operator_Overloading#Address_of.2C_Reference.2C_and_Pointer_operators

Answer 3

"तीर" ऑपरेटर द्वारा अतिभारित किया जा सकता:

a->b 

return_type my_class::operator->() 

Answer 4

तीर ऑपरेटर कोई आदानों है। तकनीकी रूप से, यह जो कुछ भी आप चाहते हैं उसे वापस कर सकते हैं, लेकिन इसे कुछ ऐसा वापस करना चाहिए जो या तो सूचक है या एक सूचक through chained -> operators बन सकता है।

-> ऑपरेटर स्वचालित रूप से निर्मित संकेतक भिन्नता, नहीं operator* का उपयोग कर अपने तर्क कॉल करने से पहले अपनी वापसी मान dereferences ताकि आप निम्नलिखित वर्ग हो सकता है:

class PointerToString 
{ 
    string a; 

    public: 
    class PtPtS 
    { 
     public: 
     PtPtS(PointerToString &s) : r(s) {} 
     string* operator->() 
     { 
      std::cout << "indirect arrow"; 
      return &*r; 
     } 
     private: 
     PointerToString &r; 
    }; 

    PointerToString(const string &s) : a(s) {} 
    PtPts operator->() const 
    { 
     std::cout << "arrow dereference\n"; 
     return *this; 
    } 
    string &operator*() const 
    { 
     std::cout << "dereference\n"; 
     return a; 
    } 
}; 

इसे पसंद का प्रयोग करें:

PointerToString ptr(string("hello")); 
string::size_type size = ptr->size(); 

जिसमें संकलक द्वारा परिवर्तित किया जाता है:

string::size_type size = (*ptr.operator->().operator->()).size(); 

(साथ के रूप में कई .operator->() के रूप में एक वास्तविक सूचक वापस जाने के लिए आवश्यक) और आउटपुट

arrow dereference 
indirect dereference 
dereference 

ध्यान दें, तथापि, आप निम्न कर सकते हैं कि होना चाहिए:

PointerToString::PtPtS ptr2 = ptr.operator->(); 

Stroupstrup से:

ऑब्जेक्ट का परिवर्तन पी सूचक में p.operator->() सदस्य एम पर निर्भर नहीं है। यही वह अर्थ है जिसमें operator->() एक यूनरी पोस्टफिक्स ऑपरेटर है। हालांकि, कोई नया वाक्यविन्यास पेश नहीं किया गया है, इसलिए ->