« Programmation C++/Les structures de contrôles » : différence entre les versions

Un livre de Wikilivres.
Contenu supprimé Contenu ajouté
m Orth, accolades (voir discussion).
Ligne 10 : Ligne 10 :
if (''condition'') ''instruction''
if (''condition'') ''instruction''


;''condition'':Expression booléenne de la condition d'exécution.
;''condition'': Expression booléenne de la condition d'exécution.
;''instruction'':Une instruction ou un bloc d'instructions exécuté si la condition est vraie.
;''instruction'': Une instruction ou un bloc d'instructions entre accolades exécuté si la condition est vraie.
Lorsqu'il n'y a qu'une ligne d'instructions conditionnelles, la paire d'accolades est conditionnelle, mais les omettre est dangereux.


=== Sémantique : ===
=== Sémantique : ===
Ligne 31 : Ligne 32 :


if (a > 10)
if (a > 10)
cout << "a est plus grand que 10" << endl;
{
cout << "a est plus grand que 10" << endl;
}

cout << "Le programme est fini" << endl;
cout << "Le programme est fini." << endl;
return 0;
return 0;
}
}
Ligne 39 : Ligne 41 :


Ce programme demande à l'utilisateur de taper un entier a.
Ce programme demande à l'utilisateur de taper un entier a.
Si a est strictement plus grand que 10, il affiche <code>"a est plus grand que 10"</code>.
Si a est strictement plus grand que 10, il affiche <code>"a est plus grand que 10."</code>.
Dans le cas contraire, il n'affiche rien.
Dans le cas contraire, il n'affiche rien.


Ligne 64 : Ligne 66 :
else ''instruction2''
else ''instruction2''


;''condition'':Expression booléenne de la condition d'exécution.
;''condition'': Expression booléenne de la condition d'exécution.
;''instruction1'':Une instruction ou un bloc d'instructions exécuté si la condition est vraie.
;''instruction1'': Une instruction ou un bloc d'instructions exécuté si la condition est vraie.
;''instruction2'':Une instruction ou un bloc d'instructions exécuté si la condition est fausse.
;''instruction2'': Une instruction ou un bloc d'instructions exécuté si la condition est fausse.


=== Sémantique ===
=== Sémantique ===
Ligne 74 : Ligne 76 :


L'<code>''instruction1''</code> ou l'<code>''instruction2''</code> peuvent être remplacées par une suite d'instructions entre accolades.
L'<code>''instruction1''</code> ou l'<code>''instruction2''</code> 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 : ===
=== Exemple : ===
Ligne 86 : Ligne 89 :


if (a > 10)
if (a > 10)
{
cout << "a est plus grand que 10" << endl;
cout << "a est plus grand que 10" << endl;
}
else
else
{
cout << "a est inférieur ou égal à 10" << endl;
cout << "a est inférieur ou égal à 10" << endl;
}

return 0;
return 0;
}
}
Ligne 103 : Ligne 109 :
a est inférieur ou égal à 10
a est inférieur ou égal à 10
=== Plusieurs instructions par condition ===
=== Plusieurs instructions par condition ===
Si plusieurs actions doivent s'enchaîner lorsqu'une condition est vraie, on met ces actions entre accolades. L'accolade fermante ne doit pas être suivies d'un point virgule dans ce cas. Ainsi, on écrira
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'')
if (''condition1'')
''{''
''{''
Ligne 118 : Ligne 124 :
....
....
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.
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 ==
== Le switch ==
Ligne 137 : Ligne 144 :


;''expression'':Expression de type scalaire (entier, caractère, énumération, booléen).
;''expression'':Expression de type scalaire (entier, caractère, énumération, booléen).
;case ''constante1''<nowiki>:</nowiki> ''instruction1_...'':Une série d'instructions ou de blocs d'instructions exécutés si ''expression'' vaut ''constante1''.
;case ''constante1''<nowiki>:</nowiki> ''instruction1_...'': Une série d'instructions ou de blocs d'instructions exécutés si ''expression'' vaut ''constante1''.
;case ''constante2''<nowiki>:</nowiki> ''instruction2_...'':Une série d'instructions ou de blocs d'instructions exécutés si ''expression'' vaut ''constante2''.
;case ''constante2''<nowiki>:</nowiki> ''instruction2_...'': Une série d'instructions ou de blocs d'instructions exécutés si ''expression'' vaut ''constante2''.
;default<nowiki>:</nowiki> ''instruction_...'':Une série d'instructions ou de blocs d'instructions exécutés quand aucun des cas précédent ne correspond.
;default<nowiki>:</nowiki> ''instruction_...'': Une série d'instructions ou de blocs d'instructions exécutés quand aucun des cas précédent ne correspond.


=== Sémantique ===
=== Sémantique ===
Ligne 154 : Ligne 161 :
Si l'expression vaut <code>constante1</code> alors on exécute l’instruction1 et on passe à l’instruction suivante. Si elle vaut c2, on exécute l'instruction2 et on passe à l’instruction suivante. Idem s'il vaut c3. Si elle ne vaut ni c1, ni c2, ni c3 alors on exécute l'instruction après default et on passe à l’instruction suivante. Le default est facultatif. On peut remplacer les instructions instruction1, instruction2, instruction3 par des suites d'instructions sans mettre d'accolades. Les valeurs c1, c2,c3 .. sont obligatoirement des constantes.
Si l'expression vaut <code>constante1</code> alors on exécute l’instruction1 et on passe à l’instruction suivante. Si elle vaut c2, on exécute l'instruction2 et on passe à l’instruction suivante. Idem s'il vaut c3. Si elle ne vaut ni c1, ni c2, ni c3 alors on exécute l'instruction après default et on passe à l’instruction suivante. Le default est facultatif. On peut remplacer les instructions instruction1, instruction2, instruction3 par des suites d'instructions sans mettre d'accolades. Les valeurs c1, c2,c3 .. sont obligatoirement des constantes.
-->
-->
En C++, l'expression n'est jamais une chaine de caractères, ni un tableau, ni un objet, ni une structure !

=== Exemple 1 ===
=== Exemple 1 ===
<source lang="cpp">
<source lang="cpp">
Ligne 259 : Ligne 266 :
=== Syntaxe ===
=== Syntaxe ===
for(''instruction_init'' ; ''condition'' ; ''instruction_suivant'')
for(''instruction_init'' ; ''condition'' ; ''instruction_suivant'')
''instruction_repetée''
''instruction_répétée''


;''instruction_init'':Une instruction (ou une série d'instruction séparées par une virgule) d'initialisation de la boucle (initialiser un compteur à 0, pointer le premier élément d'une liste, ...).
;''instruction_init'': Une instruction (ou une série d'instruction séparées par une virgule) d'initialisation de la boucle (initialiser un compteur à 0, pointer le premier élément d'une liste, ...).
;''condition'':Expression booléenne de la condition de répétition de la boucle.
;''condition'': Expression booléenne de la condition de répétition de la boucle.
;''instruction_suivant'':Une instruction (ou une série d'instruction séparées par une virgule) pour passer à l'itération suivante (incrémenter un index, passer à l'élément suivant, ...)
;''instruction_suivant'': Une instruction (ou une série d'instruction séparées par une virgule) pour passer à l'itération suivante (incrémenter un index, passer à l'élément suivant, ...)
;''instruction_repetée'':Une instruction ou un bloc d'instruction répété à chaque itération de la boucle.
;''instruction_répétée'': Une instruction ou un bloc d'instruction répété à chaque itération de la boucle.


=== Sémantique ===
=== Sémantique ===
Ligne 312 : Ligne 319 :
=== Instructions multiples ===
=== Instructions multiples ===
Il existe également une pratique répandue qui consiste à initialiser plusieurs variables, évaluer plusieurs conditions ou, plus fréquemment, modifier plusieurs variables.
Il existe également une pratique répandue qui consiste à initialiser plusieurs variables, évaluer plusieurs conditions ou, plus fréquemment, modifier plusieurs variables.
Exemple:
Exemple :
<source lang=cpp>
<source lang=cpp>
float c=10;
float c=10;
Ligne 320 : Ligne 327 :
</source>
</source>
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.
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:
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 :
<source lang=cpp>
<source lang=cpp>
int b= 2,10; // b=10. Vous pouvez compiler pour vérifier.
int b = 2,10; // b=10. Vous pouvez compiler pour vérifier.
</source>
</source>


Ligne 339 : Ligne 346 :
Le dernier standard C++ (surnommé C++11) a ajouté une nouvelle syntaxe pour la boucle for.
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 ;) ).
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:
Voici des exemples de code fréquents :
<source lang=cpp>
<source lang=cpp>
typedef std::list<int> MaListe;
typedef std::list<int> MaListe;
Ligne 353 : Ligne 360 :
}
}
</source>
</source>
Très répétitif, non (surtout le 1er exemple d'ailleurs)?
Très répétitif, non (surtout le 1er exemple d'ailleurs) ?
Donc, une nouvelle syntaxe à é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 ;)
Donc, une nouvelle syntaxe à é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 ===
=== Syntaxe ===
Ligne 362 : Ligne 369 :




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.
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 ===
=== Exemple ===
Appliqué au dernier exemple, voici le résultat :
Appliqué au dernier exemple, voici le résultat :
Ligne 426 : Ligne 433 :
À chaque étape, à la fin du corps du while, on incrémente i de 1.<br/>
À chaque étape, à la fin du corps du while, on incrémente i de 1.<br/>
On exécute donc le corps du while la première fois avec i valant 0, la dernière fois avec i valant 9.<br/>
On exécute donc le corps du while la première fois avec i valant 0, la dernière fois avec i valant 9.<br/>
Lorsqu’on sort du while i vaut 10.<br/>
Lorsqu’on sort du while, i vaut 10.<br/>


== Le do ... while ==
== Le do ... while ==
Ligne 496 : Ligne 503 :
for (int i = 0; i < 10; i++)
for (int i = 0; i < 10; i++)
{
{
cout << "La variable i vaut: " << i << endl;
cout << "La variable i vaut : " << i << endl;
if (i == 5)
if (i == 5)
break;
break;
Ligne 508 : Ligne 515 :


==== Exécution ====
==== Exécution ====
La variable i vaut: 0
La variable i vaut : 0
La variable i vaut: 1
La variable i vaut : 1
La variable i vaut: 2
La variable i vaut : 2
La variable i vaut: 3
La variable i vaut : 3
La variable i vaut: 4
La variable i vaut : 4
La variable i vaut: 5
La variable i vaut : 5


=== Note importante ===
=== Note importante ===
Ligne 539 : Ligne 546 :
{
{
if (i == 5) continue;
if (i == 5) continue;
cout << "La variable i vaut: " << i << endl;
cout << "La variable i vaut : " << i << endl;
}
}


Ligne 549 : Ligne 556 :


==== Exécution ====
==== Exécution ====
La variable i vaut: 0
La variable i vaut : 0
La variable i vaut: 1
La variable i vaut : 1
La variable i vaut: 2
La variable i vaut : 2
La variable i vaut: 3
La variable i vaut : 3
La variable i vaut: 4
La variable i vaut : 4
La variable i vaut: 6
La variable i vaut : 6
La variable i vaut: 7
La variable i vaut : 7
La variable i vaut: 8
La variable i vaut : 8
La variable i vaut: 9
La variable i vaut : 9


== Voir aussi ==
== Voir aussi ==

Version du 21 avril 2019 à 21:30

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
condition
Expression booléenne de la condition d'exécution.
instruction
Une instruction ou un bloc d'instructions entre accolades exécuté si la condition est vraie.

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 :

  • si elle est vraie on exécute l’instruction et on passe à l’instruction suivante.
  • si elle est fausse on passe directement à l’instruction suivante.

L’instruction peut être remplacée par une suite d’instructions entre accolades.

Exemple :

#include <iostream>
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 "a est plus grand que 10.". 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
condition
Expression booléenne de la condition d'exécution.
instruction1
Une instruction ou un bloc d'instructions exécuté si la condition est vraie.
instruction2
Une instruction ou un bloc d'instructions exécuté si la condition est fausse.

Sémantique

On évalue la condition :

  • si elle est vraie, on exécute l'instruction1 et on passe à l'instruction suivante
  • si elle est fausse, on exécute l'instruction2 et on passe à l'instruction suivante

L'instruction1 ou l'instruction2 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 :

#include <iostream>
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 a. Si a est strictement plus grand que 10, il affiche "a est plus grand que 10". Dans le cas contraire, il affiche "a est inférieur ou égal à 10".

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 switch 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...
} 
expression
Expression de type scalaire (entier, caractère, énumération, booléen).
case constante1: instruction1_...
Une série d'instructions ou de blocs d'instructions exécutés si expression vaut constante1.
case constante2: instruction2_...
Une série d'instructions ou de blocs d'instructions exécutés si expression vaut constante2.
default: instruction_...
Une série d'instructions ou de blocs d'instructions exécutés quand aucun des cas précédent ne correspond.

Sémantique

On teste la valeur de l'expression spécifiée. On la compare successivement aux constantes constante1, constante2, 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 à default:. L'exécution se termine à l'accolade fermante du switch ou avant si l'instruction break; est utilisée.

En général, l'instruction break 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

#include <iostream>
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 "a vaut 1", "a vaut 2", "a vaut 3", ou "a ne vaut ni 1, ni 2, ni 3".

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

#include <iostream>
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 "a vaut 1", "a vaut 2 ou 4", "a vaut 3, 7 ou 8", ou "valeur autre".

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 switch 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
instruction_init
Une instruction (ou une série d'instruction séparées par une virgule) d'initialisation de la boucle (initialiser un compteur à 0, pointer le premier élément d'une liste, ...).
condition
Expression booléenne de la condition de répétition de la boucle.
instruction_suivant
Une instruction (ou une série d'instruction séparées par une virgule) pour passer à l'itération suivante (incrémenter un index, passer à l'élément suivant, ...)
instruction_répétée
Une instruction ou un bloc d'instruction répété à chaque itération de la boucle.

Sémantique

  1. on exécute l'instruction_init.
  2. On teste la condition :
    • tant qu'elle est vraie, on exécute l'instruction_repetée, puis l'instruction_suivant puis on revient au 2.
    • si elle est fausse, la boucle est terminée et on passe à l'instruction suivante.
  3. L'instruction_repetée peut être une suite d'instructions entre accolades.

Exemples

Premier cas simple :

#include <iostream>
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 true 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 à é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 :

  • si elle est vraie, on exécute l'instruction et on recommence.
  • si elle est fausse, la boucle est terminée, on passe à l'instruction suivante.

L'instruction peut être une suite d'instructions entre accolades.

Exemple de programme

#include <iostream>
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 );

Sémantique

  1. on exécute les instructions ;
  2. on évalue la condition ;
  3. si elle est vraie, on recommence au 1 ;
  4. si elle est fausse, la boucle est terminée, on passe à l ’instruction suivante.

Exemple

#include <iostream>
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 goto est une structure de contrôle obsolète et ne doit plus être utilisé.

Le break

L'instruction break sert à "casser" ou interrompre une boucle (for, while et do), ou un switch.

Syntaxe

break;

Sémantique

  • Sort de la boucle ou de l'instruction switch la plus imbriquée.

Exemple

#include <iostream>
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

Le break rend le code difficile à lire, à l'exception de son utilisation dans un switch, il ne doit pas être utilisé (au même titre que le goto).

Le continue

L'instruction continue sert à "continuer" une boucle (for, while et do) avec la prochaine itération.

Syntaxe

continue;

Sémantique

Passe à l'itération suivante de la boucle la plus imbriquée.

Exemple

#include <iostream>
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

Voir aussi