postfix e l'operatore prefisso incremento in un ciclo for

Question

Eventuali duplicati:
Difference between i++ and ++i in a loop?

qualcuno può spiegare qual è la differenza tra chi:

for(unsigned col = 0; col < n; ++col, num_to_fill >>= 1U) 
{ 

    for(unsigned row = num_to_fill; row < (1U << n); row += (num_to_fill * 2)) 
    { 
     std::fill_n(&output[col][row], num_to_fill, 1); 
    } 
} 

e

for(unsigned col = 0; col < n; col++, num_to_fill >>= 1U) 
{ 

    for(unsigned row = num_to_fill; row < (1U << n); row += (num_to_fill * 2)) 
    { 
     std::fill_n(&output[col][row], num_to_fill, 1); 
    } 
} 

Quando col=0, In Es.1 Output[col][row] saranno output[1][row] e In Es.2 Output[col][row] sarà output[0][row]. Ho ragione ?

Domanda 2: Utilizzare anziché /= 2 fare alcuna differenza?

Answer 1

Non fa alcuna differenza per il valore di col all'interno del ciclo - supponendo che col sia un valore primitivo. Se col fosse una classe, gli operatori di prefisso e postfix '++' potrebbero essere sovraccaricati per fare due cose diverse, anche se lo considererei una cattiva pratica. Si consideri il seguente esempio:

#include <iostream> 

using namespace std; 

int main() { 
    for(int i = 0; i < 10; i++) { 
     cout << i << endl; 
    } 

    cout << endl; 

    for(int i = 0; i < 10; ++i) { 
     cout << i << endl; 
    } 

} 

Entrambi questi Basta stampare fuori 0-9, nonostante il fatto che si pre-incremento in uno, e post-incremento nell'altra. L'incremento di i si verifica alla fine di ogni ciclo del ciclo indipendentemente dal fatto che si utilizzi o meno l'incremento pre o post. Credo che il pre-incremento sia più efficiente, dal momento che - e potrei sbagliarlo - il compilatore non ha quindi bisogno di usare una variabile temporanea ^1., ma ciò sarebbe evidente solo se si esegue il looping per un tempo molto lungo (e, naturalmente, 'More computing sins are committed in the name of efficiency than for any other single reason')

per quanto riguarda la domanda 2:.

domanda 2: Sarebbe utilizzando >> = 1U invece di =/2 fa alcuna differenza?

Improbabile. Lo spostamento dei bit sarebbe più veloce se il compilatore non ottimizzasse, ma è probabile che il compilatore ottimizzerà questo in un piccolo cambiamento.

Come nota a margine, io in genere trovano a fare unsigned variableName (vale a dire, lasciando cadere il int) cattiva pratica - anche se C++ sarà spingere in un int ovunque uno è mancante, è meno leggibile per me.

1.: Stephen nei commenti (un diversa Stefano;)) nota che - "Pre-incremento è più efficiente per iteratori contenitore libreria standard, ma non è diverso per i tipi primitivi, dal momento che la copia di un intero è più economico rispetto alla copia di un iteratore più grande (in particolare std :: set e std :: map iterators). "

Answer 2

Non c'è differenza per unsigned. Tuttavia, ci sarebbe una differenza per le classi con sovraccarico operator++, perché chiamerebbe i suoi diversi overload (di solito, l'operatore postfissa crea una copia della classe, il che significa che potrebbe essere più lento).

L'utilizzo di >> = 1U invece di/= 2 fa alcuna differenza?

Probabilmente no. La sua semantica è la stessa per i non firmati, e i compilatori di solito li trattano allo stesso modo e possono cambiarli in un altro se è più veloce.