Boucle for basée sur un intervalle en C++ : syntaxe, auto et références

« Pour chaque élément, fais ceci »

La boucle for à compteur classique est parfaite quand vous avez un indice à piloter. Mais la plupart du temps, l'indice ne vous intéresse pas vraiment : vous voulez juste toucher chaque élément d'un conteneur. Écrire for (int i = 0; i < v.size(); i++) pour cela est bruyant, et i n'est qu'à une erreur d'écart d'un dépassement de bornes.

C++11 a ajouté la boucle for basée sur un intervalle précisément pour cela. Vous nommez une variable, pointez vers un conteneur, et la boucle parcourt chaque élément à votre place :

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> scores = {90, 75, 100, 60};

    for (int s : scores) {
        cout << s << "\n";
    }
}

Pas d'indice, pas de .size(), pas de bornes à se tromper. Lisez-la comme « pour chaque s dans scores ». Elle fonctionne sur les tableaux bruts, std::vector, std::string, std::map et tout ce qui expose begin() et end().

Laissez auto choisir le type

Écrire explicitement le type de l'élément fonctionne, mais c'est fragile : changez le type du conteneur et toutes les boucles doivent changer aussi. Associez le for basé sur un intervalle à auto et le compilateur déduira le type de l'élément à votre place :

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Linus", "Grace"};

    for (auto name : names) {
        cout << "Hello, " << name << "!\n";
    }
}

Il y a pourtant un coût caché ici. Le simple auto name déduit string et copie chaque élément dans name à chaque passage. Pour un int c'est gratuit ; pour un string ou une grosse struct, c'est une allocation gaspillée à chaque itération. La solution, ce sont les références, ce qui est la prochaine chose à comprendre.

Modifier sur place avec auto&

Si vous écrivez auto x, vous obtenez une copie : assigner à x change donc la copie, pas le conteneur. Attention à ce piège :

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto n : nums) {   // copie ! les modifications sont jetées
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // toujours 1 2 3
}

La multiplication ne fait silencieusement rien parce que n est une copie jetable. Pour réellement modifier les éléments, prenez-les par référence avec auto& :

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {   // référence - modifie le véritable élément
        n *= 10;
    }

    for (int n : nums) cout << n << " ";   // 10 20 30
}

Le simple & fait toute la différence entre « regarder sans toucher » et « modifier sur place ». Si vous vous demandez un jour pourquoi vos modifications disparaissent, c'est presque toujours la raison.

Lire sans copier : const auto&

Quand vous devez seulement lire des éléments mais qu'ils sont coûteux à copier, utilisez const auto&. La référence évite la copie, et const documente (et impose) que vous ne modifierez rien :

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main() {
    vector<string> words = {"refactor", "compile", "deploy"};

    size_t total = 0;
    for (const auto& w : words) {   // pas de copie, impossible de changer w par accident
        total += w.size();
    }

    cout << "Total characters: " << total << "\n";
}

Une bonne règle empirique :

for (auto x : c)         // copie    - types peu coûteux (int, char, pointeurs)
for (auto& x : c)        // modifier - vous voulez changer les éléments
for (const auto& x : c)  // lire     - types lourds que vous inspectez seulement

Par défaut, utilisez const auto& pour lire et auto& pour écrire. Ne recourez au simple auto que pour des types vraiment petits et peu coûteux à copier.

Parcourir les maps et les pairs

Un for basé sur un intervalle sur un std::map vous fournit un std::pair pour chaque entrée, avec .first (la clé) et .second (la valeur). Depuis C++17, les structured bindings permettent de décomposer ce pair en deux variables nommées directement dans l'en-tête de la boucle :

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> ages = {{"Ada", 36}, {"Grace", 85}};

    for (const auto& [name, age] : ages) {
        cout << name << " is " << age << "\n";
    }
}

[name, age] est bien plus clair que répéter entry.first et entry.second partout. Gardez aussi const auto& ici : la clé d'une entrée de map est un string, donc copier chaque pair serait du gaspillage.

Le piège : ne redimensionnez pas pendant la boucle

Le plus gros piège est de changer la taille du conteneur pendant qu'un for basé sur un intervalle le parcourt. Appeler push_back, erase, insert ou clear peut réallouer le stockage sous-jacent et invalider les itérateurs internes de la boucle : le résultat est un comportement indéfini, c'est-à-dire des plantages ou des données corrompues, pas une erreur conviviale :

vector<int> v = {1, 2, 3};
for (int x : v) {
    v.push_back(x);   // COMPORTEMENT INDÉFINI - la réallocation invalide l'intervalle
}

Si vous devez ajouter ou supprimer des éléments pendant le traitement, passez à une boucle for basée sur un indice ou un itérateur et gérez les bornes vous-même, ou construisez un conteneur de résultats séparé et échangez-le ensuite. Deux pièges plus petits de la même famille : ne liez jamais un for basé sur un intervalle à un temporaire qui meurt immédiatement (for (auto x : makeVector()) est correct, mais for (auto& x : someObj.getTempVector()) peut pendre), et rappelez-vous que for (auto& c : myString) vous permet de modifier les caractères individuels sur place.

Suite : les fonctions

La boucle for basée sur un intervalle range l'itération, et les choix auto / auto& / const auto& que vous venez d'apprendre se transposent directement à l'un des outils les plus importants de C++. Ensuite, nous emballerons la logique dans des fonctions réutilisables : en donnant au code un nom, des paramètres et une valeur de retour, afin de pouvoir l'appeler de n'importe où au lieu de vous répéter.