Qual è più veloce, accesso puntatore o accesso di riferimento?

Question

Nell'esempio di codice seguente alloco alcune istanze della struct Chunk. Nei cicli for, quindi, eseguo l'iterazione nel blocco di memoria e accedo alle diverse istanze utilizzando il puntatore oi riferimenti e assegna loro alcuni dati casuali.

Ma quale ciclo eseguirà il più veloce? A mia conoscenza, direi che il ciclo di riferimento sarà il più veloce perché non richiede il dereferenziamento e ha accesso diretto all'istanza in memoria. Quanto errato/giusto sono?

struct Chunk { 
    unsigned int a; 
    float b; 
    const char* c; 
}; 

int main() { 
    Chunk* pData = new Chunk[8]; 

    for(unsigned int i = 0; i < 8; ++i) { 
     Chunk* p = &pData[i]; 
     p->a = 1; 
     p->b = 1.0f; 
     p->c = "POINTERS"; 
    } 

    for(unsigned int i = 0; i < 8; ++i) { 
     Chunk& r = pData[i]; 
     r.a = 1; 
     r.b = 1.0f; 
     r.c = "REFERENCES"; 
    } 

    delete [] pData; 
    return 0; 
} 

Answer 1

Dovrebbero essere gli stessi (non circa la stessa, ma esattamente lo stesso) con qualsiasi compilatore non idiota. Sotto il cofano, i riferimenti sono puntatori (sul 99% dei compilatori). Non c'è motivo di alcuna differenza.

Pedantic: il secondo ciclo potrebbe essere essere più veloce (probabilmente no) perché i dati sono già nella cache, ma il gioco è fatto. :)

Answer 2

Non ci dovrebbero essere differenze nel codice prodotto da qualsiasi compilatore decente.

Answer 3

Quando esiti tra due versioni del codice come quelle del tuo esempio, dovresti scegliere quella più leggibile. Possibile ottimizzazione del tipo che si propone dovrebbe essere fatta dal compilatore.

Il più leggibile nel tuo caso è piuttosto la versione con riferimenti (in realtà, forse non molto più leggibile, ma il consenso è preferire l'uso dei riferimenti perché i puntatori sono più "pericolosi").

Ma torniamo all'effeciency: (per favore se qualcuno conosce l'assemblatore, meglio smettere di leggere o rischi di ridere un attacco ...) A mio parere, dato che il pData è posizionato nell'heap, il compilatore dovrà compilarlo usando comunque i puntatori. Penso che il tuo ragionamento potrebbe essere corretto se la tua struttura è stata allocata nello stack solo con "Chunk data [8];". Ma al più tardi quando le ottimizzazioni del compilatore sono sulla differenza dovrebbe essere cancellato comunque.

Answer 4

Sono tentato di dire: a chi importa? Qualsiasi differenza di velocità sarà trascurabile e dovresti scegliere il più leggibile. In questo particolare caso , mi aspetto di vedere esattamente lo stesso codice generato nel caso . Nei casi più complicati, il compilatore potrebbe non essere in grado di determinare in un secondo momento nel ciclo che il puntatore non è stato riposizionato, e potrebbe doverlo rileggere. Ma perché così sia, dovresti essere facendo abbastanza altre cose che la differenza non sarebbe misurabile.