¿Cómo creo y uso un operador de flecha de clase?

Question

Así, después de investigar todas partes por ella, me parece que no puede encontrar la forma de crear un operador de flecha de la clase, es decir,

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

sólo hay que saber cómo trabajar con él y utilizar de manera apropiada. - ¿Cuáles son sus entradas? - ¿Qué devuelve? - ¿cómo lo declaro/prototipo?

Answer 1

El operador -> se utiliza para sobrecargar el acceso de miembros . Un pequeño ejemplo:

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

Este salidas:

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

La "flecha" operador puede sobrecargarse por:

a->b 

se traducirán a

return_type my_class::operator->() 

Answer 4

El operador flecha no tiene entradas. Técnicamente, puede devolver lo que quieras, pero debería devolver algo que sea un puntero o bien un puntero through chained -> operators.

El operador -> desreferencias automáticamente su valor de retorno antes de llamar a su argumento utilizando el incorporado en referencia a un puntero, no operator*, lo que podría tener la clase siguiente:

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

usarlo como:

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

que es convertida por el compilador en:

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

(con el mayor número .operator->() como sea necesario para devolver un puntero real) y debe de salida

arrow dereference 
indirect dereference 
dereference 

Nótese, sin embargo, que usted puede hacer lo siguiente:

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

De Stroupstrup:

La transformación del objeto p en el puntero p.operator->() no depende del miembro m apuntado a. Ese es el sentido en el que operator->() es un operador de un solo sufijo. Sin embargo, no se ha introducido una nueva sintaxis, por lo que aún se requiere un nombre de miembro después de ->