sencillos - sobrecarga de operadores relacionales en c++

Operador de sobrecarga->

Question

Aquí está mi ejemplo de código:

class X
{
public:
void f() {}
};
class Y : public X
{
public:
X& operator->() { return *this; }
void f() {}
};
int main()
{
Y t;
t.operator->().f(); // OK
t->f(); // error C2819: type ''X'' does not have an overloaded member ''operator ->''
// error C2232: ''->Y::f'' : left operand has ''class'' type, use ''.''
}

¿Por qué el compilador está tratando de "mover la responsabilidad" para el operador-> de Y a X? Cuando implemento X :: op-> entonces no puedo devolver X allí - el error de compilación dice "recursión infinita", mientras que al devolver algo de Z desde X :: op-> nuevamente dice que Z no tiene operador->, por lo tanto, va más alto y Superior en jerarquía.

¿Alguien puede explicar este comportamiento interesante? :)

Answer 1

El problema es que el operator -> debe devolver un puntero , no una referencia . La idea es que el operator -> debe devolver un puntero al objeto real que debe tener el puntero aplicado. Por ejemplo, para una clase con un operator -> sobrecargado operator -> , el código

myClass->myValue;

se traduce como

(myClass.operator-> ())->myValue;

El problema con su código es que el operator -> devuelve una referencia, por lo que escribir

myClass.operator->().f();

es perfectamente legal porque está invocando explícitamente al operador, pero escribiendo

myClass->f();

es ilegal, porque el compilador está tratando de expandirlo a

myClass.operator->()->f();

y el tipo de retorno de operator-> no es un puntero.

Para solucionar esto, cambie su código para que devuelva un puntero en operator -> . Si desea sobrecargar a un operador para devolver una referencia, sobrecargue al operator * ; Las referencias de punteros deberían producir referencias.

Answer 2

La sintaxis es incorrecta, debe ser:

T-> T2

T2* T::operator ->();​

Mira el artículo de wikipedia: Operadores en C y C ++.

Si desea sobrecargar, debe usar la sintaxis correcta para el operador sobrecargado

Answer 3

Porque así es como sobrecargado -> funciona en C ++.

Cuando utiliza sobrecargado -> , la expresión a->b se traduce en a.operator->()->b . Esto significa que su operador sobrecargado -> debe devolver algo que apoyará otra aplicación de operador -> . Por esta razón, una sola invocación de sobrecargado -> podría convertirse en una larga cadena de invocaciones de sobrecargado -> s hasta que finalmente llegue a una aplicación de - -> incorporada, que termina la cadena.

En su caso, necesita devolver X* de su sobrecargado -> , no X& .

Answer 4

Probablemente quieras:

class Y : public X
{
public:
X* operator->() { return this; }
void f() {}
};