Je suis nouveau dans le langage C ++. J'ai commencé à utiliser des vecteurs, et j'ai remarqué que dans tout le code que je vois pour itérer à travers un vecteur via des indices, le premier paramètre de la forboucle est toujours quelque chose basé sur le vecteur. En Java, je pourrais faire quelque chose comme ça avec une ArrayList:

for(int i=0; i < vector.size(); i++){
   vector[i].doSomething();
}

Y a-t-il une raison pour laquelle je ne vois pas cela en C ++? Est-ce une mauvaise pratique?

Y a-t-il une raison pour laquelle je ne vois pas cela en C ++? Est-ce une mauvaise pratique?

Non. Ce n'est pas une mauvaise pratique, mais l'approche suivante rend votre code une certaine flexibilité .

Habituellement, pré-C ++ 11, le code d'itération sur les éléments de conteneur utilise des itérateurs, quelque chose comme:

std::vector<int>::iterator it = vector.begin();

C'est parce que cela rend le code plus flexible.

Tous les conteneurs de bibliothèque standard prennent en charge et fournissent des itérateurs. Si, à un stade ultérieur du développement, vous devez basculer vers un autre conteneur, ce code n'a pas besoin d'être modifié.

Remarque: L'écriture de code qui fonctionne avec tous les conteneurs de bibliothèques standard possibles n'est pas aussi facile que cela puisse paraître.

La raison pour laquelle vous ne voyez pas une telle pratique est assez subjective et ne peut pas avoir de réponse définitive, car j'ai vu de nombreux codes qui utilisent la méthode que vous avez mentionnée plutôt que le iteratorcode de style.

Voici quelques raisons pour lesquelles les gens ne considèrent pas la vector.size()manière de boucler:

1. Être paranoïaque à propos de l'appel à size()chaque fois dans la condition de boucle. Cependant, soit c'est un non-problème, soit cela peut être résolu de manière triviale
2. Préférer std::for_each()à la forboucle elle-même
3. Changement ultérieur du conteneur std::vectorà un autre (par exemple map,list ) , il faudra aussi le changement du mécanisme en boucle, car pas tout le soutien récipient size()style de boucle

C ++ 11 fournit une bonne facilité pour se déplacer dans les conteneurs. Cela s'appelle «boucle basée sur la plage pour» (ou «boucle for améliorée» en Java).

Avec peu de code, vous pouvez parcourir le plein (obligatoire!) std::vector:

vector<int> vi;
...
for(int i : vi) 
  cout << "i = " << i << endl;

La manière la plus propre d'itérer à travers un vecteur est via les itérateurs:

for (auto it = begin (vector); it != end (vector); ++it) {
    it->doSomething ();
}

ou (équivalent à ce qui précède)

for (auto & element : vector) {
    element.doSomething ();
}

Avant C ++ 0x, vous devez remplacer auto par le type d'itérateur et utiliser des fonctions membres au lieu des fonctions globales de début et de fin.

C'est probablement ce que vous avez vu. Par rapport à l'approche que vous évoquez, l'avantage est que vous ne dépendez pas beaucoup du type de vector. Si vous passez vectorà une autre classe de «type collection», votre code fonctionnera probablement toujours. Cependant, vous pouvez également faire quelque chose de similaire en Java. Il n'y a pas beaucoup de différence conceptuellement; C ++, cependant, utilise des modèles pour implémenter cela (par rapport aux génériques en Java); par conséquent, l'approche fonctionnera pour tous les types pour lesquels beginet des endfonctions sont définies, même pour les types non-classe tels que les tableaux statiques. Voir ici: Comment fonctionne la fonction basée sur la plage pour les tableaux simples?

La bonne façon de faire est de:

for(std::vector<T>::iterator it = v.begin(); it != v.end(); ++it) {
    it->doSomething();
 }

Où T est le type de la classe à l'intérieur du vecteur. Par exemple, si la classe était CActivity, écrivez simplement CActivity au lieu de T.

Ce type de méthode fonctionnera sur chaque STL (pas seulement les vecteurs, ce qui est un peu mieux).

Si vous souhaitez toujours utiliser des index, la méthode est la suivante:

for(std::vector<T>::size_type i = 0; i != v.size(); i++) {
    v[i].doSomething();
}

Il y a quelques bonnes raisons d'utiliser des itérateurs, dont certaines sont mentionnées ici:

Changer de conteneur ultérieurement n'invalide pas votre code.

c'est-à-dire que si vous passez d'un std :: vector à un std :: list, ou std :: set, vous ne pouvez pas utiliser d'indices numériques pour obtenir votre valeur contenue. L'utilisation d'un itérateur est toujours valide.

Interception à l'exécution d'une itération non valide

Si vous modifiez votre conteneur au milieu de votre boucle, la prochaine fois que vous utiliserez votre itérateur, il lèvera une exception d'itérateur non valide.

J'ai été surpris que personne n'ait mentionné que l'itération dans un tableau avec un index entier vous permet d'écrire facilement du code défectueux en indiquant un tableau avec le mauvais index. Par exemple, si vous avez des boucles imbriquées utilisant iet jcomme index, vous pouvez indiquer de manière incorrecte un tableau avec jplutôt quei et ainsi introduire une erreur dans le programme.

En revanche, les autres formes répertoriées ici, à savoir la forboucle basée sur la plage et les itérateurs, sont beaucoup moins sujettes aux erreurs. La sémantique du langage et le mécanisme de vérification de type du compilateur vous empêcheront d'accéder accidentellement à un tableau en utilisant le mauvais index.

Avec STL, les programmeurs utilisent iteratorspour traverser les conteneurs, car l'itérateur est un concept abstrait, implémenté dans tous les conteneurs standard. Par exemple, std::listn'a pas operator []du tout.

L'utilisation de l'opérateur automatique le rend vraiment facile à utiliser car on n'a pas à se soucier du type de données et de la taille du vecteur ou de toute autre structure de données

Vecteur d'itération utilisant la boucle automatique et for

vector<int> vec = {1,2,3,4,5}

for(auto itr : vec)
    cout << itr << " ";

Production:

1 2 3 4 5

Vous pouvez également utiliser cette méthode pour itérer des ensembles et des listes. L'utilisation de auto détecte automatiquement le type de données utilisé dans le modèle et vous permet de l'utiliser. Donc, même si nous avions un vectordes stringou charla même syntaxe fonctionnera bien

La manière correcte d'itérer la boucle et d'imprimer ses valeurs est la suivante:

#include<vector>

//declare the vector of type int
vector<int> v;

//insert the 5 element in the vector
for ( unsigned int i = 0; i < 5; i++){
    v.push_back(i);
}

//print those element
for (auto it = 0; it < v.end(); i++){
    std::cout << *it << std::endl;
}

Voici un moyen plus simple d'itérer et d'imprimer des valeurs en vecteur.

for(int x: A) // for integer x in vector A
    cout<< x <<" "; 

 //different declaration type
    vector<int>v;  
    vector<int>v2(5,30); //size is 5 and fill up with 30
    vector<int>v3={10,20,30};
    
    //From C++11 and onwards
    for(auto itr:v2)
        cout<<"\n"<<itr;
     
     //(pre c++11)   
    for(auto itr=v3.begin(); itr !=v3.end(); itr++)
        cout<<"\n"<<*itr;