Est-ce que la condition de terminaison d'un rafraîchissement « boucle » en VC ++ 6?

StackOverflow https://stackoverflow.com/questions/542028

Question 

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

La partie terminaison état "stlVector.size ()" prendre "stlVector.erase (...)" en considération? En d'autres termes ne stlVector.size () refresh pour chaque itération de la boucle? Je ne peux pas le tester en ce moment, donc je posté une question ici.

Thx à l'avance!

Cordialement,

zhengtonic

Était-ce utile?

La solution

Pour être clair, ne pas penser en termes de la boucle quoi que ce soit rafraîchissant. Chaque fois que la condition est vérifiée (au début de chaque passage dans la boucle), la méthode size () est appelée sur la variable de stlVector, et la taille actuelle du vecteur est retourné.

La méthode d'effacement () réduit la taille du vecteur, de sorte que la taille prochaine fois () est appelée, la valeur retournée sera plus petite.

Autres conseils

Oui, il le fait! 

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

Ainsi, pour chaque boucle, vous aurez le test "i

Oui, le test est effectué, avec des effets secondaires, pour chaque boucle.

Une boucle est simplement une convention agréable - une boucle est facilement décomposées comme une boucle while: 

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

Devient: 

int i = 0 ;

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

-Adam

Oui, il le fait, mais ne pas le faire! Si vous voulez supprimer des éléments d'un vecteur, le faire dans une autre boucle. Vous supprimez des éléments après l'indice i dans ce cas: rien ne garantit que l'élément stlVector [i + 5] existe. Si vous supprimez l'élément i-ième du vecteur, votre compte est brisé parce que vous pouvez sauter des éléments sans les vérifier.

La façon la plus sûre de le faire est de stocker des références pour les éléments du stlVector que vous souhaitez supprimer sur un autre vecteur, et itérer ensuite sur ce vecteur de Auxiliar faire stlVector.erase (auxVector [i]).

Je pense que le code fourni est juste « code fantastique » (comme un intervenant a mis) pour donner un exemple concret du genre de chose que vous essayez de le faire.

Mais juste au cas où ce n'est pas: la boucle que vous avez donné sautera le 12 élément (par exemple l'élément à l'origine dans stlVector[11]) parce que lors de l'examen stlVector[10] vous supprimez un élément plus tôt, ce qui provoque tous les éléments plus tard à shunt en avant une position, mais vous incrémenter encore i à la fin de la boucle. Donc, la prochaine itération se penchera sur stlVector[11] qui est en fait l'élément qui était à l'origine stlVector[12]. Pour y remédier, vous devez --i après l'appel à erase().

Toujours réévaluer sûr!

En outre, pour clarifier un peu, puisque vous avez demandé si cela se fait de cette façon « dans VC ++ 6 ».

Le "continuer condition" est réévaluer sur chaque boucle dans chaque version de C, C ++, C # et Java.

Si complier ne génère pas de code qui fait cela, il est brisé, et doivent être évités.

Comme d'autres l'ont dit, oui la condition est réévalué chaque fois dans la boucle. Voilà pourquoi une optimisation de la performance commune est: 

int saveSize = someExpensiveComputation();

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

où la boucle conditionnelle est tout coûteux à calculer, au lieu de 

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

Si le calcul coûteux est inutilement fait chaque itération dans la boucle.

Oui, il réduit la taille. Plus d'informations est

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top