Une série d'instructions dans une fonction s'exécute séquentiellement par défaut.
Cependant, il est nécessaire que certaines parties du code ne s'exécutent que sous certaines conditions, ou s'exécutent plusieurs fois dans une boucle pour par exemple traiter tous les éléments d'un tableau.
Le if.
Cette structure de contrôle permet d'exécuter une instruction ou une suite d'instructions seulement si une condition est vraie.
Syntaxe :.
 if ("condition") "instruction"
Lorsqu'il n'y a qu'une ligne d'instructions conditionnelles, la paire d'accolades est conditionnelle, mais les omettre est dangereux.
Sémantique :.
On évalue la condition :
L’instruction peut être remplacée par une suite d’instructions entre accolades.
Exemple :.
using namespace std;
int main()
 int a;
 cout « "Tapez la valeur de a : "; cin » a;
 if (a > 10)
 cout « "a est plus grand que 10" « endl;
 cout « "Le programme est fini." « endl;
 return 0;
Ce programme demande à l'utilisateur de taper un entier a.
Si a est strictement plus grand que 10, il affiche codice_1.
Dans le cas contraire, il n'affiche rien.
Exécution 1.
 Tapez la valeur de a : 12
 a est plus grand que 10
Exécution 2.
 Tapez la valeur de a : 8
Condition multiple contenant des opérateurs logiques.
Si la condition a évaluer est complexe et contient des opérateurs logiques, chaque condition doit être écrite entre parenthèse. 
Par exemple, si la condition condition1 et la condition condition2 doivent être vérifiée en même temps, on écrira
 if ( ("condition1) && (condition2)" ) "instruction"
où l'opérateur logique && peut être remplacé par tout autre opérateur logique.
Ajouter des opérateurs logiques se fait selon le même principe, en prenant en compte les règles de préséance de ces opérateurs pour adapter la place des parenthèses.
Le if...else.
Cette structure de contrôle permet d'exécuter une instruction si une condition est vraie, ou une autre instruction si elle est fausse.
Syntaxe.
 if ("condition") "instruction1"
 else "instruction2"
Sémantique.
On évalue la condition :
L'codice_2 ou l'codice_3 peuvent être remplacées par une suite d'instructions entre accolades.
Lorsqu'il n'y a qu'une ligne d'instructions conditionnelles, la paire d'accolades est conditionnelle, mais les omettre est dangereux.
Exemple :.
using namespace std;
int main()
 int a;
 cout « "Tapez la valeur de a : "; cin » a;
 if (a > 10)
 cout « "a est plus grand que 10" « endl;
 else
 cout « "a est inférieur ou égal à 10" « endl;
 return 0;
Ce programme demande à l'utilisateur de taper un entier codice_6. Si a est strictement plus grand que 10, il affiche codice_7. Dans le cas contraire, il affiche codice_8.
Exécution 1.
 Tapez la valeur de a : 12
 a est plus grand que 10
Exécution 2.
 Tapez la valeur de a : 8
 a est inférieur ou égal à 10
Plusieurs instructions par condition.
Si plusieurs actions doivent s'enchaîner lorsqu'une condition est vraie, on met obligatoirement ces actions entre accolades. L'accolade fermante ne doit pas être suivie d'un point virgule dans ce cas. Ainsi, on écrira
 if ("condition1") 
 "instruction1.1 ;" 
 instruction1.2 ;
 } // pas de point virgule ici
 else if (condition2)
 "instruction2.1 ;"
qui exécute les instructions instruction1.1 et instruction1.2, ... si la condition condition1 est vraie, et les instructions instruction2.1, ... si la condition condition2 est vraie.
Lorsqu'il n'y a qu'une ligne d'instructions conditionnelles, la paire d'accolades est conditionnelle, mais les omettre est dangereux.
Le switch.
L'instruction codice_9 permet de tester plusieurs valeurs pour une expression.
Syntaxe.
 switch("expression")
 case "constante1":
 "instruction1_1"
 "instruction1_2..."
 case "constante2":
 "instruction2_1"
 "instruction2_2..."
 default:
 "instruction_1"
 "instruction_2..."
Sémantique.
On teste la valeur de l'expression spécifiée.
On la compare successivement aux constantes codice_10, codice_11, etc.
Si la valeur de l'expression correspond à l'une des constantes, l'exécution débute à l'instruction correspondante.
Si aucune constante ne correspond, l'exécution débute à l'instruction correspondant à codice_12.
L'exécution se termine à l'accolade fermante du codice_9 ou avant si l'instruction codice_14 est utilisée.
En général, l'instruction codice_15 sépare les différents cas. Il n'est pas utilisé quand plusieurs cas sont traités par les mêmes instructions.
En C++, l'expression n'est jamais une chaine de caractères, ni un tableau, ni un objet, ni une structure.
Exemple 1.
using namespace std;
int main()
 int a;
 cout « "Tapez la valeur de a : "; cin » a;
 switch(a)
 case 1 :
 cout « "a vaut 1" « endl;
 break;
 case 2 :
 cout « "a vaut 2" « endl;
 break;
 case 3 :
 cout « "a vaut 3" « endl;
 break;
 default :
 cout « "a ne vaut ni 1, ni 2, ni 3" « endl;
 break;
 return 0;
Ce programme demande à l'utilisateur de taper une valeur entière et la stocke dans la variable a. On teste ensuite la valeur de a : en fonction de cette valeur on affiche respectivement les messages codice_16, codice_17, codice_18, ou codice_19.
Exécution 1 :
 Tapez la valeur de a : 1
 a vaut 1
Exécution 2 :
 Tapez la valeur de a : 2
 a vaut 2
Exécution 3 :
 Tapez la valeur de a : 3
 a vaut 3
Exécution 4 :
 Tapez la valeur de a : 11
 a vaut ne vaut ni 1, ni 2, ni 3
Exemple 2.
using namespace std;
int main()
 int a;
 cout « "Tapez la valeur de a : "; cin » a;
 switch(a)
 case 1 :
 cout « "a vaut 1" « endl;
 break;
 case 2 :
 case 4 :
 cout « "a vaut 2 ou 4" « endl;
 break;
 case 3 :
 case 7 :
 case 8 :
 cout « "a vaut 3, 7 ou 8" « endl;
 break;
 default :
 cout « "valeur autre" « endl;
 break;
 return 0;
Ce programme demande à l'utilisateur de taper une valeur entière et la stocke dans la variable a. On teste ensuite la valeur de a : en fonction de cette valeur on affiche respectivement les messages codice_16, codice_21, codice_22, ou codice_23.
Exécution 1 :
 Tapez la valeur de a : 1
 a vaut 1
Exécution 2 :
 Tapez la valeur de a : 4
 a vaut 2 ou 4
Exécution 3 :
 Tapez la valeur de a : 7
 a vaut 3, 7 ou 8
Exécution 4 :
 Tapez la valeur de a : 11
 valeur autre
L'instruction codice_9 de cet exemple regroupe le traitement des valeurs 2 et 4, et des valeurs 3, 7 et 8.
Le for "classique".
Le for est une structure de contrôle qui permet de répéter un certain nombre de fois une partie d'un programme.
Syntaxe.
 for("instruction_init" ; "condition" ; "instruction_suivant")
 "instruction_répétée"
Exemples.
Premier cas simple :
using namespace std;
int main()
 int i;
 for(i=0 ; i<10 ; i++)
 cout « "BONJOUR" « endl;
 return 0;
Second cas où deux index dans un tableau sont utilisés pour le parcourir à partir des deux bouts : le début et la fin.
int main()
 // 10 entiers indexés de 0 à 9 inclus :
 int elements[10] = { 3, 14, 15, 9, 26, 5, 35, 8 };
 int i, j;
 for (i=0, j=9; i <= j; i++, j--)
 cout « "Elements"
 « " [" « i « "]=" « elements[i]
 « " [" « j « "]=" « elements[j]
 « endl;
 return 0;
Instructions multiples.
Il existe également une pratique répandue qui consiste à initialiser plusieurs variables, évaluer plusieurs conditions ou, plus fréquemment, modifier plusieurs variables.
Exemple :
float c=10;
for(int a=2, b=a; a<2, b*=a; a++, c/=b)
Ceci compilera parfaitement, mais est également parfaitement illisible. Dans la plupart des cas, il vaut mieux n'utiliser la boucle for elle-même que pour traiter le ou les compteurs, afin de conserver un code compréhensible.
Cela compile parce qu'en C++, la virgule ',' est un opérateur comme les autres, qui évalue l'expression qui la précède et celle qui la suit, et renvoie le résultat de la dernière. Pour donner un exemple plus clair :
int b = 2,10; // b=10. Vous pouvez compiler pour vérifier.
Boucle infinie.
Quand aucune condition n'est spécifiée, celle-ci vaut codice_30 par défaut, ce qui créé donc une boucle infinie.
Une boucle infinie est parfois nécessaire quand on ne connait pas l'instant où la boucle doit être arrêtée, et que la condition d'arrêt est évaluée au cœur de la boucle (gestion de messages, écoute de connexions réseau, ...).
for(;;)
 // ...
le for "moderne".
Le dernier standard C++ (surnommé C++11) a ajouté une nouvelle syntaxe pour la boucle for.
En effet, on s'est aperçu que l'on utilise le plus souvent la boucle for pour parcourir une collection (une collection est un tableau classique ou un conteneur comme ceux de la stl.) en entier, et que donc le même code revenait très souvent (à la langue des commentaires près ;) ).
Voici des exemples de code fréquents :
typedef std::list<int> MaListe;
MaListe maListe;
for(MaListe::iterator it=maListe.begin();it!=maListe.end();++it)
int tableau[]={0,1,2,3,4};
const int tableauMax=5;//il y a 5 cases dans tableau
for(int i=0; i<tableauMax; ++i)
Très répétitif, non (surtout le 1er exemple d'ailleurs) ?
Donc, une nouvelle syntaxe a été créée qui permet de s'affranchir d'une grande partie de ces frappes et donc de prolonger la durée de vie de nos claviers ;)
Syntaxe.
for("variable" : "collection") "instruction"
Sémantique.
"variable" indique la variable qui recevra les valeurs issues de "collection", en commençant par la première jusqu'à la dernière.
Si "variable" n'existe pas, il est possible de la déclarer dans la même ligne, de la même façon que pour l'écriture classique.
Un bémol de cette syntaxe est que le compteur est perdu : si vous avez besoin du compteur dans le bloc d'instruction (ou plus tard) cette syntaxe est inutilisable.
Exemple.
Appliqué au dernier exemple, voici le résultat :
typedef std::list<int> MaListe;
MaListe maListe;
for(int i : maListe)
int tableau[]={0,1,2,3,4};
for(int i: tableau)
Beaucoup plus clair, non ?
Le while.
Syntaxe.
 while ("condition") "instruction;"
Sémantique.
On teste la condition :
L'instruction peut être une suite d'instructions entre accolades.
Exemple de programme.
using namespace std;
int main()
 int i = 0;
 while (i < 10)
 cout « "La valeur de i est : " « i « endl;
 i++;
 cout « "La valeur finale de i est : " « i « endl;
 return 0;
Exécution.
 La valeur de i est : 0
 La valeur de i est : 1
 La valeur de i est : 2
 La valeur de i est : 3
 La valeur de i est : 4
 La valeur de i est : 5
 La valeur de i est : 6
 La valeur de i est : 7
 La valeur de i est : 8
 La valeur de i est : 9
 La valeur finale de i est : 10
Explications.
La variable i est initialisée à 0.
À chaque étape, à la fin du corps du while, on incrémente i de 1.
On exécute donc le corps du while la première fois avec i valant 0, la dernière fois avec i valant 9.
Lorsqu’on sort du while, i vaut 10.
Le do ... while.
Syntaxe.
 do { "...instructions..." } while( "condition" );
Exemple.
using namespace std;
int main()
 int i = 0;
 do
 cout « "La valeur de i vaut : " « i « endl;
 i++;
 while (i < 10);
 cout « "La valeur finale de i est " « i « endl;
 return 0;
Exécution : 
 La valeur de i vaut : 0
 La valeur de i vaut : 1
 La valeur de i vaut : 2
 La valeur de i vaut : 3
 La valeur de i vaut : 4
 La valeur de i vaut : 5
 La valeur de i vaut : 6
 La valeur de i vaut : 7
 La valeur de i vaut : 8
 La valeur de i vaut : 9
 La valeur finale de i est : 10
Le goto.
Le codice_31 est une structure de contrôle obsolète et ne doit plus être utilisé.
Le break.
L'instruction codice_15 sert à "casser" ou interrompre une boucle (codice_33, codice_34 et codice_35), ou un codice_9.
Syntaxe.
break;
Exemple.
using namespace std;
int main()
 for (int i = 0; i < 10; i++)
 cout « "La variable i vaut : " « i « endl;
 if (i == 5)
 break;
 return 0;
Ce programme interrompt sa boucle lors de la sixième itération.
Exécution.
 La variable i vaut : 0
 La variable i vaut : 1
 La variable i vaut : 2
 La variable i vaut : 3
 La variable i vaut : 4
 La variable i vaut : 5
Note importante.
L'instruction codice_15 interrompt le cours normal de l'exécution et doit être utilisée avec parcimonie.
Elle ne doit servir que pour éviter une complexification de la condition ; une condition complexe pouvant entraîner des erreurs de code et une moindre lisibilité.
L'exemple ci-dessous montre un cas où il n'est pas pertinent d'utiliser l'instruction codice_15.
for (int i=0 ; i<10 ; i++)
 cout « "La variable i vaut : " « i « endl;
 if (i == 5) break;
L'arrêt par l'instruction est notamment non pertinent dans ce cas car l'arrêt est prévisible à l'avance.
Il suffit pour cet exemple de corriger la condition d'arrêt de la boucle :
for (int i=0 ; i<=5 ; i++)
 cout « "La variable i vaut : " « i « endl;
Par contre, dans le cas de l'exemple suivant, où un arrêt prématuré de la boucle est effectué lorsqu'un item de tableau est trouvé et qu'un traitement complexe détermine qu'il faut interrompre la boucle, l'utilisation de l'instruction codice_15 est pertinent.
L'équivalent avec une condition de boucle serait complexe, ou nécessiterait l'utilisation d'une variable dédiée au stockage de la condition.
for (int i=0 ; i<10 ; i++)
 cout « "ITEM " « i « endl;
 if (item[i]->getType() == type_a_trouver)
 cout « " Trouvé à l'index " « i « endl;
 if (item[i]->analyseContenuFichier() == TYPE_WIKICODE)
 cout « " Page wiki trouvée." « endl;
 break;
 cout « " Fausse alerte, on continue..." « endl;
 cout « " Item suivant !" « endl;
L'équivalent avec une variable stockant l'état de la condition de sortie impliquerait de tester cet état dans la condition de boucle, déterminer une valeur initiale pertinente pour que la boucle fasse la première itération, de tester cet état aussi avant chaque instruction ou bloc à chaque niveau d'accolade.
Cela produit un code beaucoup moins explicite, et réduit la maintenabilité du code (répétition de code) :
int trouve = 0;
for (int i=0 ; i<10 && trouve==0 ; i++)
 cout « "ITEM " « i « endl;
 if (item[i]->getType() == type_a_trouver)
 cout « " Trouvé à l'index " « i « endl;
 if (item[i]->analyseContenuFichier() == TYPE_WIKICODE)
 cout « " Page wiki trouvée." « endl;
 trouve = 1;
 if (trouve == 0)
 cout « " Fausse alerte, on continue..." « endl;
 if (trouve == 0)
 cout « " Item suivant !" « endl;
Le continue.
L'instruction continue sert à "continuer" une boucle (codice_33, codice_34 et codice_35) avec la prochaine itération.
Syntaxe.
continue;
Sémantique.
Passe à l'itération suivante de la boucle la plus imbriquée.
Exemple.
using namespace std;
int main()
 for (int i = 0; i < 10; i++)
 if (i == 5) continue;
 cout « "La variable i vaut : " « i « endl;
 return 0;
Ce programme saute l'affichage de la sixième itération.
Exécution.
 La variable i vaut : 0
 La variable i vaut : 1
 La variable i vaut : 2
 La variable i vaut : 3
 La variable i vaut : 4
 La variable i vaut : 6
 La variable i vaut : 7
 La variable i vaut : 8
 La variable i vaut : 9