Itération sur std::vector : variable d'index non signée vs signée

Question

Quelle est la manière correcte d'itérer sur un vecteur en C++ ?

Considérez ces deux fragments de code, celui-ci fonctionne bien :

for (unsigned i=0; i < polygon.size(); i++) {
    sum += polygon[i];
}

et celui-ci :

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

qui génère warning: comparison between signed and unsigned integer expressions .

Je suis novice dans le monde du C++, donc les unsigned unsigned les variables peuvent être dangereuses si elles ne sont pas utilisées correctement, donc - est-ce correct ?

Answer 1

Pour l'itération en arrière, voir cette réponse .

L'itération vers l'avant est presque identique. Il suffit de changer les itérateurs / de remplacer le décrément par l'incrément. Vous devriez préférer les itérateurs. Certaines personnes vous disent d'utiliser std::size_t comme type de variable d'index. Cependant, cela n'est pas portable. Il faut toujours utiliser la variable size_type du conteneur (alors que vous pourriez vous en tirer avec une simple conversion dans le cas d'une itération vers l'avant, vous pourriez vous tromper complètement dans le cas d'une itération vers l'arrière si vous utilisez std::size_t au cas où std::size_t est plus large que ce qu'est le typedef de size_type ) :

---

Utilisation de std::vector

Utilisation des itérateurs

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

L'important est de toujours utiliser la forme préfixe d'incrémentation pour les itérateurs dont vous ne connaissez pas la définition. Cela garantira que votre code s'exécute de manière aussi générique que possible.

Utilisation de Range C++11

for(auto const& value: a) {
     /* std::cout << value; ... */

Utilisation des indices

for(std::vector<int>::size_type i = 0; i != v.size(); i++) {
    /* std::cout << v[i]; ... */
}

---

Utilisation des tableaux

Utilisation des itérateurs

for(element_type* it = a; it != (a + (sizeof a / sizeof *a)); it++) {
    /* std::cout << *it; ... */
}

Utilisation de Range C++11

for(auto const& value: a) {
     /* std::cout << value; ... */

Utilisation des indices

for(std::size_t i = 0; i != (sizeof a / sizeof *a); i++) {
    /* std::cout << a[i]; ... */
}

Lire dans la réponse itérative en arrière quel problème le sizeof approche peut céder à, cependant.

Answer 2

Quatre ans ont passé, Google m'a donné cette réponse. Avec le standard C++11 (alias C++0x ), il existe en fait une nouvelle façon agréable de le faire (au prix d'une rupture de la rétrocompatibilité) : la nouvelle fonction auto mot-clé. Il vous évite d'avoir à spécifier explicitement le type de l'itérateur à utiliser (en répétant à nouveau le type de vecteur), alors qu'il est évident (pour le compilateur), quel type utiliser. Avec v étant votre vector vous pouvez faire quelque chose comme ça :

for ( auto i = v.begin(); i != v.end(); i++ ) {
    std::cout << *i << std::endl;
}

C++11 va encore plus loin et vous donne une syntaxe spéciale pour itérer sur des collections comme les vecteurs. Elle supprime la nécessité d'écrire des choses qui sont toujours les mêmes :

for ( auto &i : v ) {
    std::cout << i << std::endl;
}

Pour le voir dans un programme fonctionnel, construisez un fichier auto.cpp :

#include <vector>
#include <iostream>

int main(void) {
    std::vector<int> v = std::vector<int>();
    v.push_back(17);
    v.push_back(12);
    v.push_back(23);
    v.push_back(42);
    for ( auto &i : v ) {
        std::cout << i << std::endl;
    }
    return 0;
}

Au moment où j'écris ces lignes, quand vous compilez ceci avec g++ vous devez normalement le configurer pour qu'il fonctionne avec la nouvelle norme en fournissant un drapeau supplémentaire :

g++ -std=c++0x -o auto auto.cpp

Vous pouvez maintenant exécuter l'exemple :

$ ./auto
17
12
23
42

Veuillez noter que les instructions sur la compilation et l'exécution sont spécifiques à gnu c++ compilateur sur Linux le programme doit être indépendant de la plate-forme (et du compilateur).

Answer 3

Dans le cas précis de votre exemple, j'utiliserais les algorithmes STL pour y parvenir.

#include <numeric> 

sum = std::accumulate( polygon.begin(), polygon.end(), 0 );

Pour un cas plus général, mais encore assez simple, je choisirais :

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>

using namespace boost::lambda;
std::for_each( polygon.begin(), polygon.end(), sum += _1 );

Answer 4

Concernant la réponse de Johannes Schaub :

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

Cela peut fonctionner avec certains compilateurs mais pas avec gcc. Le problème ici est la question de savoir si std::vector::iterator est un type, une variable (membre) ou une fonction (méthode). Nous obtenons l'erreur suivante avec gcc :

In member function ‘void MyClass<T>::myMethod()’:
error: expected `;' before ‘it’
error: ‘it’ was not declared in this scope
In member function ‘void MyClass<T>::sort() [with T = MyClass]’:
instantiated from ‘void MyClass<T>::run() [with T = MyClass]’
instantiated from here
dependent-name ‘std::vector<T*,std::allocator<T*> >::iterator’ is parsed as a non-type, but instantiation yields a type
note: say ‘typename std::vector<T*,std::allocator<T*> >::iterator’ if a type is meant

La solution consiste à utiliser le mot clé "typename" comme indiqué :

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

Answer 5

Un appel à vector<T>::size() renvoie une valeur de type std::vector<T>::size_type et non pas int, unsigned int ou autre.

De même, en général, l'itération sur un conteneur en C++ se fait à l'aide de itérateurs comme ceci.

std::vector<T>::iterator i = polygon.begin();
std::vector<T>::iterator end = polygon.end();

for(; i != end; i++){
    sum += *i;
}

Où T est le type de données que vous stockez dans le vecteur.

Ou en utilisant les différents algorithmes d'itération ( std::transform , std::copy , std::fill , std::for_each et cetera).