Programmation C++/Les structures de contrôles

Un livre de Wikilivres.
Aller à : navigation, rechercher


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[modifier | modifier le wikitexte]

Cette structure de contrôle permet d'exécuter une instruction ou une suite d'instructions seulement si une condition est vraie.

Syntaxe :[modifier | modifier le wikitexte]

if (condition) instruction
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.

Sémantique :[modifier | modifier le wikitexte]

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 :[modifier | modifier le wikitexte]

#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[modifier | modifier le wikitexte]

Tapez la valeur de a : 12
a est plus grand que 10

Exécution 2[modifier | modifier le wikitexte]

Tapez la valeur de a : 8

Le if...else[modifier | modifier le wikitexte]

Cette structure de contrôle permet d'exécuter une instruction si une condition est vraire, ou une autre instruction si elle est fausse.

Syntaxe[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

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.

Exemple :[modifier | modifier le wikitexte]

#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[modifier | modifier le wikitexte]

Tapez la valeur de a : 12
a est plus grand que 10

Exécution 2[modifier | modifier le wikitexte]

Tapez la valeur de a : 8
a est inférieur ou égal à 10

Le switch[modifier | modifier le wikitexte]

L'instruction switch permet de tester plusieurs valeurs pour une expression.

Syntaxe[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

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.


Exemple 1[modifier | modifier le wikitexte]

#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[modifier | modifier le wikitexte]

#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"[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

for(instruction_init ; condition ; instruction_suivant)
    instruction_repeté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_repetée
Une instruction ou un bloc d'instruction répété à chaque itération de la boucle.

Sémantique[modifier | modifier le wikitexte]

  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[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

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 suis, 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[modifier | modifier le wikitexte]

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"[modifier | modifier le wikitexte]

Le dernier standard C++ (surnommé C++11) à 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[modifier | modifier le wikitexte]

for(variable : collection) instruction

Sémantique[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

Appliqué au dernier exemple, voici le résultat:

typedef std::list<int> MaListe;
MaListe maListe;
for(MaListe::iterator it: maListe)
{
}
 
int tableau[]={0,1,2,3,4};
for(int i: tableau)
{
}

Beaucoup plus clair, non?

Le while[modifier | modifier le wikitexte]

Syntaxe[modifier | modifier le wikitexte]

while (condition) instruction;

Sémantique[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

#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[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

La variable i est initialisée à 0.
A 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[modifier | modifier le wikitexte]

Syntaxe[modifier | modifier le wikitexte]

do { ...instructions... } while( condition );

Sémantique[modifier | modifier le wikitexte]

  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[modifier | modifier le wikitexte]

#include <iostream>
using namesapce std;
 
int main()
{
    int i = 0;
 
    do
    {
        cout << "La valeur de i vaut : " << i << endl;
        i = i + 1;
    }
    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[modifier | modifier le wikitexte]

Le goto est une structure de contrôle obsolète et ne doit plus être utilisé.

Le break[modifier | modifier le wikitexte]

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

Syntaxe[modifier | modifier le wikitexte]

break;

Sémantique[modifier | modifier le wikitexte]

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

Exemple[modifier | modifier le wikitexte]

#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[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

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[modifier | modifier le wikitexte]

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

Syntaxe[modifier | modifier le wikitexte]

continue;

Sémantique[modifier | modifier le wikitexte]

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

Exemple[modifier | modifier le wikitexte]

#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:[modifier | modifier le wikitexte]

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