aplicación recursiva de operador->

Question

Se dice que el operador de flecha se aplica recursivamente. Pero cuando trato de ejecutar el código siguiente, se imprime un galimatías cuando se supone para imprimir 4.

class dummy 
{ 
public: 
    int *p; 

    int operator->() 
    { 
     return 4; 
    } 
}; 

class screen 
{ 
public: 
    dummy *p; 

    screen(dummy *pp): p(pp){} 
    dummy* operator->() 
    { 
     return p; 
    } 
}; 

int main() 
{ 
    dummy *d = new dummy; 
    screen s(d); 
    cout<<s->p; 
    delete d; 
} 

Answer 1

lo que Stanley entiende por “recursivo” es sólo que el operador se aplica a cada objeto devuelto hasta el el tipo devuelto es un puntero.

Lo que sucede aquí en el primer intento: screen::operator -> devuelve un puntero. Por lo tanto, esta es la última llamada a un operator -> que intenta el compilador. A continuación, resuelve el lado derecho del operador (p) buscando un miembro en el tipo de puntaje devuelto (dummy) con ese nombre.

Esencialmente, cada vez que el compilador encuentra la sintaxis aᵢ->b en el código, que, esencialmente, se aplica el siguiente algoritmo:

1. Es aᵢ del tipo de puntero? De ser así, resuelva el miembro b de *aᵢ y llame al (*aᵢ).b.
2. lo demás, tratar de resolver aᵢ::operator ->
   1. En caso de éxito, establecer aᵢ₊₁ = aᵢ::operator ->(). Ir a 1.
   2. En caso de error, emita un error de compilación.

estoy en apuros para llegar a un pequeño ejemplo, donde un significativo cadena de invocaciones operator -> siquiera tiene sentido. Probablemente, el único uso real sea cuando escribe una clase de puntero inteligente.

Sin embargo, el siguiente ejemplo de juguete al menos compila y arroja un número. Pero no aconsejaría realmente escribir dicho código. Rompe la encapsulación y hace llorar a los gatitos.

#include <iostream> 

struct size { 
    int width; 
    int height; 
    size() : width(640), height(480) { } 
}; 

struct metrics { 
    size s; 
    size const* operator ->() const { 
     return &s; 
    } 
}; 

struct screen { 
    metrics m; 
    metrics operator ->() const { 
     return m; 
    } 
}; 

int main() { 
    screen s; 
    std::cout << s->width << "\n"; 
} 

Answer 2

El acuerdo es una vez screen::operator->() devuelve un puntero (dummy*) la recursividad se detiene porque incorporado (por defecto) en -> utilizados en ese puntero. Si quieres recursividad debe volver dummy o dummy& de screen::operator->()

Answer 3

C++ Primer (5ª edición) la formula de la siguiente manera en la página 570:

El operador flecha nunca pierde su significado fundamental de acceso miembro. Cuando sobrecargamos la flecha, cambiamos el objeto desde el cual la flecha obtiene el miembro especificado. No podemos cambiar el hecho de que la flecha atrapa a un miembro.