applicazione ricorsiva di operatore->

Question

Si dice che l'operatore di freccia sia applicato in modo ricorsivo. Ma quando provo ad eseguire il codice seguente, esso stampa senza senso quando si suppone che la stampa 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

Che Stanley intende per “ricorsiva” è solo che l'operatore è applicato a ogni oggetto restituito fino la il tipo restituito è un puntatore.

Che succede qui al primo tentativo: screen::operator -> restituisce un puntatore. Quindi questa è l'ultima chiamata a un operator -> che il compilatore tenta. Risolve quindi il sorso destro dell'operatore (p) cercando un membro nel tipo di punta restituito (dummy) con quel nome.

In sostanza, quando il compilatore trova la sintassi aᵢ->b in codice, vale essenzialmente il seguente algoritmo:

1. È aᵢ di tipo puntatore? In tal caso, risolvere il membro b di *aᵢ e chiamare (*aᵢ).b.
2. Else, cercare di risolvere aᵢ::operator ->
   1. In caso di successo, insieme aᵢ₊₁ = aᵢ::operator ->(). Goto 1.
   2. In caso di errore, emettere un errore di compilazione.

Sono difficoltà a venire con una breve, significativo esempio dove un catena di operator -> invocazioni rende ancora senso. Probabilmente l'unico vero uso è quando scrivi una classe puntatore intelligente.

Tuttavia, il seguente esempio di giocattolo almeno compila e produce un numero. Ma non consiglierei davvero di scrivere questo codice. Rompe l'incapsulamento e fa piangere i gattini.

#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

L'operazione è volta screen::operator->() restituisce un puntatore (dummy*) la ricorsione si ferma perché built-in (default) -> in utilizzati in quel puntatore. Se si desidera che la ricorsione è necessario restituire dummy o dummy& da screen::operator->()

Answer 3

C++ Primer (5a edizione) formula come segue a pagina 570:

L'operatore freccia mai non perde il suo significato fondamentale di accesso utente. Quando sovraccarichiamo la freccia, cambiamo l'oggetto da cui la freccia recupera il membro specificato. Non possiamo cambiare il fatto che la freccia recupera un membro.