Come posso creare e utilizzare un operatore di classe arrow?

Question

Così, dopo la ricerca in tutto il mondo per questo, non posso sembrare trovare come creare una classe di operatore di freccia, vale a dire,

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

Ho solo bisogno di sapere come lavorare con esso e usarlo in modo appropriato. - quali sono i suoi input? - cosa restituisce? - Come si dichiara/prototipo correttamente?

Answer 1

L'operatore -> viene utilizzato per sovraccaricare member . Un piccolo esempio:

#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(); 
} 

Questo uscite:

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

L'operatore "freccia" può essere sovraccaricato:

a->b 

sarà tradotto per

return_type my_class::operator->() 

Answer 4

L'operatore freccia ha ingressi. Tecnicamente, può restituire quello che vuoi, ma dovrebbe restituire qualcosa che sia un puntatore o che possa diventare un puntatore through chained -> operators.

L'operatore -> dereferenziazioni automaticamente il suo valore di ritorno prima di chiamare il suo argomento utilizzando il built-in puntatore dereference, non operator*, quindi si potrebbe avere la seguente classe:

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; 
    } 
}; 

utilizzarlo come:

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

che viene convertito dal compilatore in:

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

(con ben .operator->() se necessario per restituire un vero e proprio puntatore) e dovrebbe uscita

arrow dereference 
indirect dereference 
dereference 

Si noti, tuttavia, che è possibile effettuare le seguenti operazioni:

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

Da Stroupstrup:

La trasformazione dell'oggetto p nel puntatore p.operator->() non dipende dal membro m indicato. Questo è il senso in cui operator->() è un operatore postfisso unario. Tuttavia, non è stata introdotta una nuova sintassi, quindi è necessario un nome membro dopo lo ->