Is (* i) .Membro meno efficienti rispetto i-> membro

Question

Avere

struct Person { 
    string name; 
}; 

Person* p = ... 

Si supponga che non gli operatori sono sovraccarichi.

---

Quale è più efficiente (se presente)?

(*p).namevs.p->name

Da qualche parte nella parte posteriore della mia testa ho sentito alcune campane, che l'operatore * dereferenziazione può creare una copia temporanea di un oggetto; è vero?

---

Lo sfondo di questa domanda sono casi come questo:

Person& Person::someFunction(){ 
    ... 
    return *this; 
} 

e ho cominciato a chiedermi, se cambia il risultato al Person* e l'ultima riga semplicemente return this avrebbe fatto alcuna differenza (in termini di prestazioni)?

Answer 1

Quando si restituisce un riferimento, equivale esattamente a passare un puntatore, semantica del puntatore esclusa.
Si restituisce un elemento sizeof(void*), non uno sizeof(yourClass).

Quindi, quando si farlo:

Person& Person::someFunction(){ 
    ... 
    return *this; 
} 

Si ritorna un riferimento, e che di riferimento ha la stessa dimensione intrinseca di un puntatore, quindi non c'è alcuna differenza di runtime.

Lo stesso vale per l'uso di (*i).name, ma in quel caso si crea un l-value, che ha poi la stessa semantica come riferimento (vedi anche here)

Answer 2

Non c'è differenza. Anche lo standard dice che i due sono equivalenti, e se c'è qualche compilatore là fuori che non genera lo stesso binario per entrambe le versioni, è uno cattivo.

Answer 3

Qualsiasi buon compilatore produrrà gli stessi risultati. Puoi rispondere da solo, compilare entrambi i codici per l'assemblatore e controllare il codice prodotto.

Answer 4

Sì, è molto più difficile da leggere e tipo, in modo da stai molto meglio usando x->y rispetto a (*x).y - ma a parte l'efficienza di digitazione, non c'è assolutamente alcuna differenza. Il compilatore ha ancora bisogno di leggere il valore di x e quindi aggiungere l'offset y, se si utilizza una forma o l'altra [assumendo non ci sono divertenti oggetti/classi coinvolte che hanno la priorità sulle operator-> e operator*, rispettivamente, ovviamente]

Non è stato creato alcun oggetto aggiuntivo quando si fa riferimento a (*x). Il valore del puntatore viene caricato in un registro nel processore [1]. Questo è tutto.

Il ritorno di un riferimento è in genere più efficiente, in quanto restituisce un puntatore (in incognito) all'oggetto, anziché creare una copia dell'oggetto. Per oggetti più grandi delle dimensioni di un puntatore, in genere si tratta di una vittoria.

[1] Sì, possiamo avere un compilatore C++ per un processore che non ha registri. Conosco almeno un processore di Rank-Xerox che ho visto nel 1984 circa, che non ha registri, era un processore LiSP dedicato, e ha solo uno stack per gli oggetti LiSP ... Ma sono lontani dal comune nel mondo di oggi. Se qualcuno sta lavorando su un processore che non dispone di registri, si prega di non svitare la mia risposta semplicemente perché non copro quell'opzione. Sto cercando di mantenere la risposta semplice.