for instruction (C++)

Exécute une instruction à plusieurs reprises jusqu’à ce que la condition devienne false. Pour plus d’informations sur l’instruction basée sur la plage, consultez l’instruction basée sur forfor la plage (C++) . Pour plus d’informations sur l’instruction C++/CLI for each , consultez for each, in.

Syntaxe

for ( init-expression ; cond-expression ; loop-expression )
 statement

Remarques

Utilisez l’instruction for pour construire des boucles qui doivent exécuter un nombre spécifié de fois.

L’instruction for se compose de trois parties facultatives, comme indiqué dans le tableau suivant.

pour les éléments de boucle

Nom de la syntaxe	En cas d’exécution	Descriptif
init-expression	Avant tout autre élément de l’instruction for , init-expression n’est exécuté qu’une seule fois. Le contrôle passe ensuite à cond-expression.	Souvent utilisé pour initialiser des index de boucle. Il peut contenir des expressions ou des déclarations.
cond-expression	Avant l’exécution de chaque itération de statement, y compris la première itération. statement est exécuté uniquement si la cond-expression valeur est true (différente de zéro).	Expression qui prend la valeur d’un type intégral ou d’un type de classe qui a une conversion non ambiguë en type intégral. Normalement utilisé pour tester les critères d’arrêt de boucle.
loop-expression	À la fin de chaque itération de statement. Une fois loop-expression l’exécution terminée, cond-expression elle est évaluée.	Normalement utilisé pour incrémenter les index de boucle.

Les exemples suivants montrent différentes façons d’utiliser l’instruction for .

#include <iostream>
using namespace std;

int main() {
    // The counter variable can be declared in the init-expression.
    for (int i = 0; i < 2; i++ ){
       cout << i;
    }
    // Output: 01
    // The counter variable can be declared outside the for loop.
    int i;
    for (i = 0; i < 2; i++){
        cout << i;
    }
    // Output: 01
    // These for loops are the equivalent of a while loop.
    i = 0;
    while (i < 2){
        cout << i++;
    }
    // Output: 01
}

init-expression et loop-expression peut contenir plusieurs instructions séparées par des virgules. Par exemple:

#include <iostream>
using namespace std;

int main(){
    int i, j;
    for ( i = 5, j = 10 ; i + j < 20; i++, j++ ) {
        cout << "i + j = " << (i + j) << '\n';
    }
}
/* Output:
    i + j = 15
    i + j = 17
    i + j = 19
*/

loop-expression peut être incrémenté ou décrémenté, ou modifié d’une autre manière.

#include <iostream>
using namespace std;

int main(){
for (int i = 10; i > 0; i--) {
        cout << i << ' ';
    }
    // Output: 10 9 8 7 6 5 4 3 2 1
    for (int i = 10; i < 20; i = i+2) {
        cout << i << ' ';
    }
}
// Output: 10 12 14 16 18

Une for boucle se termine lorsqu’une breakinstruction , retour ou goto (à une instruction étiquetée en dehors de la for boucle) est statement exécutée. Une continue instruction d’une for boucle met fin uniquement à l’itération actuelle.

Si cond-expression elle est omise, elle est considérée true, et la for boucle ne se termine pas sans un break, returnou goto dans statement.

Bien que les trois champs de l’instruction for soient normalement utilisés pour l’initialisation, le test de l’arrêt et l’incrémentation, ils ne sont pas limités à ces utilisations. Par exemple, le code suivant imprime les nombres 0 à 4. Dans ce cas, statement est l’instruction Null :

#include <iostream>
using namespace std;

int main()
{
    int i;
    for( i = 0; i < 5; cout << i << '\n', i++){
        ;
    }
}

for boucles et C++ Standard

La norme C++ indique qu’une variable déclarée dans une for boucle doit sortir de portée après la fin de la for boucle. Par exemple:

for (int i = 0 ; i < 5 ; i++) {
   // do something
}
// i is now out of scope under /Za or /Zc:forScope

Par défaut, sous /Ze, une variable déclarée dans une boucle reste dans l’étendue for jusqu’à ce que l’étendue englobante de la for boucle se termine.

/Zc:forScope active le comportement standard des variables déclarées dans les boucles for sans avoir à spécifier /Za.

Il est également possible d’utiliser les différences d’étendue de la for boucle pour redéclarer les variables sous /Ze la forme suivante :

// for_statement5.cpp
int main(){
   int i = 0;   // hidden by var with same name declared in for loop
   for ( int i = 0 ; i < 3; i++ ) {}

   for ( int i = 0 ; i < 3; i++ ) {}
}

Ce comportement imite plus étroitement le comportement standard d’une variable déclarée dans une for boucle, ce qui nécessite que les variables déclarées dans une for boucle sortent de l’étendue une fois la boucle terminée. Lorsqu’une variable est déclarée dans une for boucle, le compilateur le promeut en interne en une variable locale dans l’étendue englobante de la for boucle. Il est promu même s’il existe déjà une variable locale portant le même nom.

Voir aussi

Instructions d’itération
Mots clés
while instruction (C++)
do-while instruction (C++)
Instruction basée sur for une plage (C++)