Il ciclo C++ 11 consente nuove o migliori ottimizzazioni?

Question

in C++ 11 ora possiamo fare:

void dosomething(std::vector<Thing>& things) 
{ 
    for(Thing& thing : things) 
    { 
     dofoo(thing); 
     wiizzz(thing); 
     tadaa(thing); 
    } 

} 

So che l'aggiunta e l'uso di lambda è zucchero sintattico ma offrire interessanti opportunità di ottimizzazione.

E il ciclo for? È solo lo zucchero sintattico o il compilatore può ottimizzare alcuni casi che non potrebbero o sarebbero troppo difficili da fare con il loop scritto a mano?

Answer 1

E 'solo una zucchero sintattico in quanto la norma dice che è equivalente ad un ciclo con iteratori [Modifica: questo significa che non fornisce ulteriori informazioni al compilatore rispetto all'equivalente ciclo for — fine modificare ]. Si può ottenere una migliore performance anche se dal momento che è equivalente a:

for(auto iter = con.begin(), end = con.end(); iter != end; ++iter) 
{ 
    auto& ref = *iter; 
    // ... 
} 

mentre la maggior parte delle persone possono scrivere:

for(auto iter = con.begin(); iter != con.end(); iter++) 
{ 
    // use *iter directly 
    // ... 
} 

che può essere più lenta se il con.end(), ++ iter o * iter non sono banale.

[Edit:

lambda è zucchero sintattico

Non

davvero. A differenza del ciclo, consente al compilatore di catturare direttamente il puntatore di base dello stack frame, per le variabili catturate per riferimento questo salva un indirizzo indiretto per ogni utilizzo, rispetto a un oggetto funzione artigianale. — fine modifica]

Answer 2

Forse, ma probabilmente no. Elimina la possibile creazione di una variabile indice/contatore che non verrà utilizzata. Quello non è richiesto per un normale ciclo for, ma è molto più probabile che accada solo perché è ciò che alcune persone sono abituate a fare.

Realisticamente, è improbabile che possa fare alcuna differenza anche da quello. Io, almeno, trovo difficile immaginare un team di compilatori così sofisticato da avere anche la minima aspirazione a supportare C++ 0x, che non ha già gestito il punto relativamente banale di rilevare ed eliminare la creazione e l'incremento di un indice di loop che è mai usato.