Comment parcourir une liste de nombres en c++

Contrairement à beaucoup de langues modernes du C++ tableaux n'ont pas .size() fonction. Vous avez un certain nombre d'options pour parcourir une liste en fonction du type de stockage.

Des options communes pour le stockage comprennent:

//used for fixed size storage. Requires #include <array>
std::array<type, size> collection;

//used for dynamic sized storage. Requires #include <vector>
std::vector<type> collection;

//Dynamic storage. In general: slower iteration, faster insert
//Requires #include <list>     
std::list<type> collection;  

//Old style C arrays
int myarray[size]; 

Vos options pour l'itération dépend du type que vous utilisez. Si vous êtes en utilisant un simple vieux C tableau, vous pouvez stocker la taille de quelque part ou de calculer la taille de la matrice basée sur la taille de ce types. Le calcul de la taille d'un tableau a un certain nombre d'inconvénients décrits dans cette réponse par DevSolar

//Store the value as a constant
int oldschool[10];
for(int i = 0; i < 10; ++i) {
    oldschool[i]; //Get
    oldschool[i] = 5; //Set
} 

//Calculate the size of the array
int size = sizeof(oldschool)/sizeof(int);
for(int i = 0; i < size; ++i) {
    oldschool[i]; //Get
    oldschool[i] = 5; //Set
}

Si vous utilisez tout type qui fournit un .begin() et .end() fonction, vous pouvez les utiliser pour obtenir un itérateur qui est considéré comme bon style en C++ par rapport à l'indice de l'itération:

//Could also be an array, list, or anything with begin()/end()
std::vector<int> newschool;     

//Regular iterator, non-C++11
for(std::vector<int>::iterator num = newschool.begin(); num != newschool.end(); ++num) {
    int current = *num; //* gets the number out of the iterator
    *num = 5; //Sets the number.
}

//Better syntax, use auto! automatically gets the right iterator type (C++11)
for(auto num = newschool.begin(); num != newschool.end(); ++num) {
    int current = *num; //As above
    *num = 5;
}

//std::for_each also available
std::for_each(newschool.begin(), newschool.end(), function_taking_int);

//std::for_each with lambdas (C++11)
std::for_each(newschool.begin(), newschool.end(), [](int i) {
    //Just use i, can't modify though.
});

Vecteurs sont spéciaux parce qu'ils sont conçus pour être à la baisse-dans le remplacement pour les tableaux. Vous pouvez effectuer une itération sur un vecteur exactement comment vous le feriez sur un tableau avec un .size() fonction. Toutefois, cela est considéré comme une mauvaise pratique en C++ et vous devriez préférer utiliser des itérateurs si possible:

std::vector<int> badpractice;
for(int i = 0; i < badpractice.size(); ++i) {
    badpractice[i]; //Get
    badpractice[i] = 5; //Set
}

C++11 (la nouvelle norme) apporte également de la nouvelle et de la fantaisie de la gamme en fonction de qui devrait fonctionner sur n'importe quel type qui fournit un .begin() et .end(). Cependant: prise en charge du Compilateur peuvent varier pour cette fonction. Vous pouvez également utiliser begin(type) et end(type) comme une alternative.

std::array<int, 10> fancy;
for(int i : fancy) {
    //Just use i, can't modify though.
}

//begin/end requires #include <iterator> also included in most container headers.
for(auto num = std::begin(fancy); num != std::end(fancy); ++num) {
    int current = *num; //Get
    *num = 131; //Set
}

std::begin a aussi une autre propriété intéressante: il travaille sur des tableaux. Cela signifie que vous pouvez utiliser la même itération sémantique entre les tableaux et les non-tableaux (vous devez toujours préférer les types standard brut tableaux):

int raw[10];
for(auto num = std::begin(raw); num != std::end(raw); ++num) {
    int current = *num; //Get
    *num = 131; //Set
}

Vous devez également être très prudent si vous voulez supprimer des éléments d'une collection, tandis que dans une boucle car l'appel de container.erase() rend tous les itérateurs invalide:

std::vector<int> numbers;
for(auto num = numbers.begin(); num != numbers.end(); /* Intentionally empty */) {
    ...

    if(someDeleteCondition) {
        num = numbers.erase(num);
    } else {
        //No deletition, no problem
        ++num;
    }
}

Cette liste est loin d'être exhaustif, mais comme vous pouvez le voir il ya beaucoup de façons d'itération sur une collection. En général, préfèrent les itérateurs, sauf si vous avez une bonne raison de faire autrement.

Si vous faites en sorte qu'il est list<int> numbers = {1,2,3,4}:

Itération à travers l'utilisation des itérateurs:

#include <iterator>

for(auto it = std::begin(numbers); it != std::end(numbers); ++it) { ... }

Itération à travers l'utilisation de std::for_each:

#include <algorithm>
#include <iterator>

std::for_each(numbers.begin(), numbers.end(), some_func);

En utilisant une boucle for-each (C++11):

for(int i : numbers) { ... }

Vous pouvez également utiliser le bon vieux C conteneurs et utiliser l'itérateur syntaxe de la boucle:

#include <iostream>

int main()
{
    int numbers[] = {2, 4, 6, 8};
    int *numbers_end = numbers + sizeof(numbers)/sizeof(numbers[0]);
    for (int *it = numbers; it != numbers_end; ++it)
        std::cout << "the current number is " << *it << std::endl;

    return 0;
}

La façon la plus simple de le faire, à mon avis, serait d'utiliser un span.

#include <cstdlib>
#include <iostream>
#include <gsl/span>

int main() {
    int numbers[] = {2, 4, 6, 8};
    for(auto& num : gsl::span(numbers)) {
            cout << "the current number is " << num;
    }

    system("pause");
}

Notes:

• Travées sont une partie de la GSL de la bibliothèque. Pour les utiliser, télécharger la bibliothèque de ici, et ajouter le chemin de téléchargement pour la compilation de commande, par exemple g++ -o foo foo.cpp -I/path/to/gsl
• En C++20, span fera partie de la norme, de sorte que vous suffit d'utiliser std::span et #include <span>.