ternarios sobrecarga sencillos relacionales que operadores operador metodos llama flujo ejemplos c++ overloading operator-keyword

sencillos - sobrecarga de operadores relacionales en c++



Operador de sobrecarga-> (4)

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.

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? :)


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


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& .


Probablemente quieras:

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