Boucles for dans C++ : explications simples

Les boucles for correspondent à un concept fondamental dans la plupart des langages de programmation. Elles permettent d’exécuter des blocs de code de manière répétée. Il existe plusieurs variantes de boucles for dans C++, mais elles fonctionnent toutes plus ou moins de la même manière.

Comment fonctionnent les boucles for dans C++ ?

Les boucles for comptent parmi les structures de contrôle les plus importantes du domaine de la programmation. Elles permettent aux développeurs d’exécuter plusieurs fois des blocs de code spécifiques. Les constructions de boucles sont tout bonnement indispensables aux langages de programmation itératifs. Il existe par exemple des boucles for dans Java et des boucles for dans Python. D’autres langages de programmation, fonctionnels pour la plupart, préfèrent aux boucles le concept de récurrence.

Boucles for dans C++

Dans C++, les boucles for les plus répandues comportent trois éléments essentiels :

• La partie d’initialisation : elle permet d’initialiser la variable de la boucle, c’est-à-dire de lui attribuer une valeur de départ.
• La partie conditionnelle: elle permet de vérifier une condition spécifiée. Si celle-ci est remplie, le « corps » de la boucle peut s’exécuter.
• La partie d’instruction : elle permet de formuler n’importe quelle instruction. Généralement, la variable de la boucle est décrémentée ou incrémentée.

Tous ces éléments sont séparés par des points-virgules en tête de la boucle, et sont donc exécutés avant le corps de la boucle en lui-même. Par conséquent, les boucles for dans C++ sont également désignées comme des boucles contrôlées par l’en-tête.

Nous allons maintenant vous présenter un exemple simple de boucle for dans C++, qui affiche à l’écran les chiffres de 0 à 5 :

for (int i = 0; i <= 5; i++) {
	std:cout << i << std:endl;
}

Dans l’exemple de code ci-dessus, la première ligne contient l’en-tête de la boucle. Elle nous permet, une nouvelle fois, de voir clairement les éléments dont se compose une boucle for dans C++ :

• La partie d’initialisation : avec l’instruction « int i = 0 », une variable nommée « i » est créée, et la valeur 0 lui est attribuée.
• La partie conditionnelle : la spécification de la condition « i <= 5 » indique que le corps de la boucle doit être exécuté jusqu’à ce que la valeur de la variable i dépasse le chiffre 5.
• La partie d’instruction : à chaque exécution de la boucle (qualifiée d’« itération »), la valeur de la variable i augmente de 1.

Notez qu’il est possible de laisser de côté la partie conditionnelle de la boucle for. Si tel est le cas, la condition est supposée s’appliquer de façon perpétuelle, ce qui permet de créer une boucle infinie. Ces boucles infinies peuvent parfois s’avérer utiles, mais les débutants qui apprennent à maîtriser le langage C++ les créent souvent par erreur, ce qui entraîne des erreurs de la part du programme.

Boucles foreach dans C++

En plus des boucles for que nous vous avons déjà présentées, il existe dans le langage C++, et ce, depuis la version C++11, une autre forme de boucle également introduite par le mot-clé « for ». Dans d’autres langages de programmation tels que PHP ou C++++, ces constructions sont également appelées des « boucles foreach ». Celles-ci permettent d’accéder facilement à chaque élément d’une structure de données, sans avoir à utiliser l’indexation. Nous avons également choisi un exemple permettant d’afficher les chiffres de 0 à 5 :

int intArr[] = {0, 1, 2, 3, 4, 5};
for (int element: intArr) {
	std:cout << element << std:endl;
}

Comme vous pouvez le voir, la structure de l’en-tête de la boucle n’est pas la même que celle du premier exemple de code. Deux parties seulement sont utilisées, en lieu et place de l’initialisation, de la condition et de l’instruction :

• Élément : cette partie contient le type de données et le nom de la variable.
• Conteneur : cette partie précise le conteneur sur lequel l’itération doit avoir lieu.

Nous avons commencé par créer un tableau contenant les chiffres allant de 0 à 5. Au sein de la boucle for dans C++, chaque partie du tableau a ensuite été visualisée à l’aide de la variable « element », puis affichée à l’écran dans le corps de la boucle.

À quoi servent les boucles for dans C++ ?

En principe, les boucles for sont toujours utilisées lorsque le nombre d’itérations de la boucle est connu au préalable. Si vous souhaitez par exemple afficher tous les multiples du nombre 2 jusqu’à 100, votre boucle for dans C++ pourrait se présenter comme suit :

for (int i = 2; i <= 100; i+=2) {
	std:cout << i << std:endl;
}

De nombreux algorithmes de tri notoires ont également recours à des boucles for. Par rapport aux boucles while, leur principal avantage est leur écriture, bien plus compacte. En réalité, vous avez toujours la possibilité de remplacer les boucles for par des boucles while.

L’instruction break : pour mettre un terme aux boucles

Il peut vous arriver de vouloir abandonner plus tôt que prévu votre boucle for dans C++, notamment si vous souhaitez créer une boucle infinie pour afficher des nombres entiers à l’écran jusqu’à ce que le nombre spécifié par l’utilisateur soit atteint. L’exemple de code ci-dessous illustre d’ailleurs cette situation :

int i = 0;
int entrée utilisateur = 0;
// L’utilisateur renseigne un nombre qui sera affecté à la variable « entrée utilisateur »
std::cin >> entrée utilisateur
for (;;) {
	std:cout << i << std:endl;
	++i;
	// La boucle est interrompue si la variable est supérieure au nombre renseigné par l’utilisateur
	if (i > entrée utilisateur) {
		break;
}
}

Dans l’exemple de code ci-dessus, « break » est le mot-clé qui permet de mettre un terme à la boucle. Avec ce mot-clé, chaque boucle for dans C++ est immédiatement interrompue, et l’exécution du programme se poursuit tout simplement après la boucle.

L’instruction continue : ignorer des itérations de la boucle

Naturellement, il est possible que vous ne souhaitiez pas mettre un terme à toute la boucle directement, mais plutôt ignorer simplement certaines de ses itérations. Si votre but est, par exemple, d’afficher tous les nombres pairs jusqu’à atteindre 100, vous pouvez l’atteindre en utilisant la construction de boucle ci-dessous :

for (int i = 0; i <= 100; i++) {
// Permet de passer à l’itération suivante en cas de nombre impair
if (i % 2 == 1) {
		continue;
}
std:cout << i << std:endl;
}

Vous avez peut-être repéré le mot-clé « continue » dans l’exemple de code ; celui-ci veille à ce que l’itération en cours soit annulée et à ce que le programme passe à l’itération suivante de la boucle. Si cette instruction est avantageuse, c’est surtout parce qu’elle permet d’éviter les calculs inutiles, ce qui améliore l’efficacité de vos programmes.