Fa la condizione di terminazione di un 'ciclo for' aggiornamento in VC ++ 6?

Question

for (int i = 0 ; i < stlVector.size() ; i++)
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
}

La cessazione condizione di parte "stlVector.size ()" prendere "stlVector.erase (...)" in considerazione? In altre parole non stlVector.size () di aggiornamento per ogni iterazione del ciclo? Non posso provarlo in questo momento, così ho postato una domanda qui.

Thx in anticipo!

Con i migliori saluti,

zhengtonic

Answer 1

Giusto per essere chiari, non pensare di esso in termini di ciclo rinfrescante nulla. Ogni volta che la condizione è verificata (all'inizio di ogni iterazione del ciclo), il metodo size () viene chiamato sulla variabile stlVector, e la dimensione corrente del vettore viene restituito.

L'erase () metodo riduce la dimensione del vettore, quindi la dimensione prossima volta () viene chiamata, il valore restituito sarà minore.

Answer 2

Sì lo fa!

stlVector.size () // is called for evey iteration

In questo modo per ogni ciclo avrai la prova "i

Answer 3

Sì, il test viene eseguito, con effetti collaterali, per ogni ciclo.

Un ciclo for è semplicemente una bella convention - un ciclo for viene facilmente decomposto come un ciclo while:

for (int i = 0 ; i < stlVector.size() ; i++)
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
}

diventa:

int i = 0 ;

while(i < stlVector.size())
{ 
    if (i == 10)
    { 
        stlVector.erase(stlVector.begin() + 5 )
    }
    i++;
}

-Adam

Answer 4

Sì, lo fa, ma non farlo! Se si desidera rimuovere gli elementi da un vettore, farlo all'interno di un altro ciclo. Si elimina elementi dopo l'indice i in questo caso: nulla garantisce che l'elemento stlVector [i + 5] esiste. Se si rimuove l'elemento i-esimo dal vettore, il valore è rotto perché si può saltare elementi senza di loro il controllo.

Il modo più sicuro di fare questo sta immagazzinando i riferimenti per gli elementi della stlVector che si desidera eliminare su un altro vettore, e poi iterare su questo auxiliar vettore facendo stlVector.erase (auxVector [i]).

Answer 5

Mi aspetto che il codice che hai fornito è solo "codice di fantasia" (come un commentatore ha messo) per dare un esempio concreto del tipo di cosa che stai cercando di fare.

Tuttavia nel caso in cui non è: l'anello che hai dato salta sopra l'elemento 12 (vale a dire l'elemento originariamente nel stlVector[11]), perché in sede di esame stlVector[10] si elimina un elemento in precedenza, causando tutti gli elementi successivi a shunt avanti di una posizione, ma è ancora incrementa i alla fine del ciclo. Così la prossima iterazione guarderà stlVector[11] che in realtà è l'elemento che era originariamente in stlVector[12]. Per ovviare a questo, è necessario --i dopo la chiamata a erase().

Answer 6

rivalutare sempre sicuro!

Answer 7

Inoltre, per chiarire un po ', dal momento che lei ha chiesto se è fatto in questo modo "in VC ++ 6".

Il "continua condizione" è rivalutare su ogni circuito in ogni versione di C, C ++, C # e Java.

Se una qualsiasi compilatore non genera il codice che lo fa, si è rotto, e deve essere evitato.

Answer 8

Come altri hanno detto, sì, la condizione si rivaluta ogni volta attraverso il ciclo. Ecco perché un'ottimizzazione delle prestazioni comune è:

int saveSize = someExpensiveComputation();

for (int i = 0 ; i < saveSize ; i++)
{ 
    foo(i);
}

dove il ciclo condizionale è affatto costoso da calcolare, anziché

for (int i = 0 ; i < someExpensiveComputation(); i++)
{ 
    foo(i);
}

Se il calcolo è costoso inutilmente fatto ogni iterazione del ciclo.

Answer 9

Si riduce la dimensione. Ulteriori informazioni sono qui