Quoi de plus rapide, itérer un vecteur STL avec vector :: iterator ou avec at ()?

Question

En termes de performances, qu'est-ce qui fonctionnerait plus vite? Y a-t-il une différence? Est-ce que cela dépend de la plateforme?

 //1. Using vector<string>::iterator:
vector<string> vs = GetVector();

for(vector<string>::iterator it = vs.begin(); it != vs.end(); ++it)
{
   *it = "Am I faster?";
}

//2. Using size_t index:
for(size_t i = 0; i < vs.size(); ++i)
{
   //One option:
   vs.at(i) = "Am I faster?";
   //Another option:
   vs[i] = "Am I faster?";
}
 

Answer 1

À l'aide d'un itérateur résultats dans l'incrémentation d'un pointeur (par incrémentation) et de déréférencement dans un déréférencement d'un pointeur.
Avec un index, l'incrémentation doit être aussi rapide, mais à la recherche d'un élément consiste en une addition (pointeur de données+index) et de déréférencement du pointeur, mais la différence devrait être marginal.

Les résultats d'un Benchmark pour 500 M itérations, vecteur de taille 10, avec gcc 4.3.3 (-O3), linux 2.6.29.1 x86_64:
à(): 9158
l'opérateur[]: 4269
itérateur: 3914ms

YMMV, mais si l'utilisation d'un index rend le code plus lisible/compréhensible, il faut le faire.

Answer 2

Puisque vous cherchez efficacité, vous devez savoir que les variantes suivantes sont potentiellement plus efficaces:

 //1. Using vector<string>::iterator:

vector<string> vs = GetVector();
for(vector<string>::iterator it = vs.begin(), end = vs.end(); it != end; ++it)
{
   //...
}

//2. Using size_t index:

vector<string> vs = GetVector();
for(size_t i = 0, size = vs.size(); i != size; ++i)
{
   //...
}
 

puisque la fonction end / size n’est appelée qu’une fois plutôt que chaque fois dans la boucle. Il est probable que le compilateur incorporera ces fonctions de toute façon, mais de cette façon, vous en êtes sûr.

Answer 3

Si vous n'avez pas besoin d'indexation, ne l'utilisez pas. L'itérateur concept est là pour votre meilleur. Les itérateurs sont très facile à optimiser, tandis que l'accès direct besoin de quelques connaissances supplémentaires.

L'indexation est conçu pour un accès direct. Les crochets et l' at méthode de le faire. at sera, contrairement aux [], vérifier les limites de l'indexation, de sorte qu'il sera plus lent.

Le credo est: ne demandez pas ce que vous n'avez pas besoin. Ensuite, le compilateur ne sera pas vous facturer pour ce que vous n'utilisez pas.

Answer 4

Comme tout le monde le dit ici, faites des repères.

Cela dit, je dirais que l'itérateur est plus rapide, car at () vérifie également la plage, c'est-à-dire qu'il lève une exception out_of_range si l'index est hors limites. Ce contrôle lui-même engendre probablement des frais généraux.