for instruction (C++)

Exécute une instruction à plusieurs reprises jusqu'à ce que la condition soit 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

Notes

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	Description
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 alors à cond-expression.	Souvent employé pour initialiser des index de boucle. Elle 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 cond-expression a la valeur true (valeur différente de zéro).	Expression qui correspond à un type intégral ou à un type de classe avec une conversion non ambiguë en type intégral. Normalement utilisée pour déterminer les critères d'arrêts de boucles.
loop-expression	À la fin de chaque itération de statement. loop-expression est évalué après l'exécution de cond-expression.	Normalement utilisée 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 peuvent 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 autrement modifié.

#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 affiche 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
Instruction while (C++)
Instruction do-while (C++)
Instruction basée sur for une plage (C++)