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