C++ itérateurs & optimisation en boucle

Les deux versions ne sont pas le même. Dans la deuxième version, il compare l'itérateur contre list.end() à chaque fois, et ce list.end() donne pourrait changer au cours de la boucle. Maintenant, bien sûr, vous ne pouvez pas modifier list par le biais de la const_iterator it; mais rien n'empêche de code à l'intérieur de la boucle juste des appels de méthodes sur list directement et de mutation, ce qui pourrait (selon le type de structure de données list est) changement de la fin de l'itérateur. Il pourrait donc être incorrecte dans certaines circonstances, pour stocker la fin de l'itérateur d'avance, parce que peut-être plus la bonne fin de l'itérateur par le temps que vous obtenez pour elle.

Je choisirais l'option qui est la plus concise et lisible. N'essayez pas de deuxième deviner le compilateur et les optimisations qu'il pourrait effectuer. Rappelez-vous que la grande majorité de votre code aura absolument aucun effet sur la performance globale, de sorte que si c'est dans une critique pour les performances de la section de code devrait vous passez l'heure de profil et de choisir une bonne source efficace de la représentation.

Avec une référence spécifique à votre exemple, la première version fait un copie de la end() itérateur, en invoquant n'importe quel code s'exécute pour le constructeur de copie de l'itérateur de l'objet. STL en général, les conteneurs contiennent en ligne end() fonctions, de sorte que le compilateur a beaucoup de chances pour optimiser la deuxième version, même si vous n'êtes pas d'essayer de l'aider à sortir. Laquelle est la meilleure? Les mesurer.

Considérons cet exemple:

for (const_iterator it = list.begin(); it != list.end(); ++list)
{
    if (moonFull())
        it = insert_stuff(list);
    else
        it = erase_stuff(list);
}

dans ce cas, vous avez BESOIN de la liste d'appels.fin() dans la boucle, et le compilateur ne va pas optimiser tout ça.

D'autres cas où le compilateur peut prouver que la fin() est retourne toujours la même valeur, l'optimisation peut prendre place.

Si nous parlons des conteneurs STL, que je pense que tout bon compilateur peut optimiser loin multiples end() appels lorsque plusieurs end() appels n'est pas nécessaire pour la programmation logique. Toutefois, si vous avez un conteneur personnalisé et la mise en œuvre de end() n'est pas dans la même unité de traduction, que l'optimisation devront avoir lieu au moment de la liaison. Je sais très peu de choses sur le lien à l'optimisation du temps, mais je parie que la plupart des linkers ne fera pas une telle optimisation.

Le compilateur pourrait être en mesure d'optimiser la deuxième à la première, mais qui suppose que les deux sont équivalents, c'est à dire fin() est en fait constante. Un peu plus problématique, c'est que le compilateur peut être impossible d'en déduire que la fin de l'itérateur est constante en raison d'une possible aliasing. Cependant, en supposant que l'appel à la fin() est incorporé, la différence est juste une mémoire de charge.

Noter que cela suppose que l'optimiseur est activé. Si l'optimiseur n'est pas activé, comme souvent dans les versions de débogage, puis la seconde formulation impliquera N-1 plus d'appels de fonction. Dans les versions actuelles de Visual C++, versions de débogage sera également entraîner des hits en raison de la fonction du prologue/épilogue vérifications et plus lourd de débogage des itérateurs. Par conséquent, dans la STL lourd code, par défaut le premier cas peut empêcher le code de manière disproportionnée lente dans les versions debug.

D'Insertion et de retrait à l'intérieur de la boucle sont une possibilité, comme d'autres l'ont souligné, mais avec ce style de boucle je trouve que peu probable. Pour une chose, nœud à base de conteneurs -- list, set, map -- n'invalident pas la fin() sur chaque opération. Deuxièmement, l'itérateur incrément fréquemment doit être déplacé dans la boucle afin d'éviter l'invalidation des problèmes:

 //en supposant que la liste -- ne cache end() pour vecteur 
iterator it c.begin ()) à la fin(c.end()); 
while(it != fin) { 
si (should_remove(*it)) 
c' = c.erase(it); 
d'autre 
++c'; 
}

Ainsi, je considère une boucle qui prétend fin d'appel() pour muter-cours-boucle raisons et encore a ++dans la boucle d'en-tête pour être suspect.

J'ai toujours préféré le premier. Mais avec les fonctions inline, les optimisations du compilateur et relativement plus petite de la taille du conteneur ( dans mon cas, c'est normalement max de 20 à 25 points) il ne veut vraiment pas faire de grande différence par rapport à la performance.

const_iterator it = list.begin();
const_iterator endIt = list.end();

for(; it != endIt ; ++it)
{//do something
}

Mais récemment, je suis en utilisant plus de std::for_each partout où c'est possible. Son optimisé en boucle qui permet de rendre le code plus lisible que les deux autres.

std::for_each(list.begin(), list.end(), Functor());

Je vais utiliser la boucle uniquement lorsque std::for_each ne peut pas être utilisé. (par ex: std::for_each ne vous permet pas de briser la boucle, sauf si une exception est levée).