Cours de C/C++
Précédent		Suivant

Chapitre 2. Le C/C++ un peu plus loin

Table des matières
2.1. Les structures de contrôle
2.2. Retour sur les types
2.3. Les classes de stockage

Dans cette partie nous allons aborder d'autres aspects du langage indispensable à la programmation. Il s'agit des structures de contrôle (if, while, goto, etc.), et des types de donnés complexes (array, struct, union). Des précisions seront également données sur les différentes classes de variables utilisables en C/C++.

2.1. Les structures de contrôle

Le C/C++ dispose de toutes les structures de contrôle nécessaire à la programmation. Leur syntaxe est donné ci-dessous.

2.1.1. La structure conditionnelle if

Syntaxe :

if (test) opération;

test est une expression dont la valeur est booléenne ou entière. Toute valeur non nulle est considérée comme vraie. Si le test est vrai, opération est exécuté. Ce peut être une instruction ou un bloc d'instructions. Une variante permet de spécifier l'action à exécuter en cas de test faux :

if (test) opération1;
else opération2;

Note : Attention ! Les parenthèses autour de test sont nécessaires !

Les opérateurs de comparaison sont les suivants :

Tableau 2-1. Opérateurs de comparaison

==	égalité
!=	inégalité
<	infériorité
>	supériorité
<=	infériorité ou égalité
>=	supériorité ou égalité

Les opérateurs logiques applicables aux expressions booléennes sont les suivants :

Tableau 2-2. Opérateurs logiques

&&	et logique
\|\|	ou logique
!	négation logique

Il n'y a pas d'opérateur ou exclusif logique.

Exemple 2-1. Test conditionnel if

if (a<b && a!=0)
{
    min=a;
    nouveau_min=1;
}

2.1.2. La boucle for

Syntaxe :

for (initialisation ; test ; itération) opération;

initialisation est une instruction (ou un bloc d'instructions) exécutée avant le premier parcours de la boucle du for. test est une expression dont la valeur déterminera la fin de la boucle. itération est l'opération à effectuer en fin de boucle, et opération constitue le traitement de la boucle. Chacune de ces parties est facultative.

La séquence d'exécution est la suivante :

initialisation
test : saut en fin du for ou suite
    opération
    itération
    retour au test
fin du for.

Exemple 2-2. Boucle for

somme = 0;
for (i=0; i<=10; i=i+1) somme = somme + i;

Note : En C++, il est possible que la partie initialisation déclare une variable. Dans ce cas, la variable déclarée n'est définie qu'à l'intérieur de l'instruction for. Par exemple,
for (int i=0; i<10; i++);
est strictement équivalent à :
{
    int i;
    for (i=0; i<10; i++);
}
Cela signifie que l'on ne peut pas utiliser la variable i après l'instruction for, puisqu'elle n'est définie que dans cette instruction. Cela permet de réaliser des variables muettes, qui ne servent qu'à l'instruction for dans laquelle elles sont définies.

Note : Cette règle n'est pas celle utilisée par la plupart des compilateurs C++. La règle qu'ils utilisent spécifie que la variable déclarée dans la partie initialisation de l'instruction for reste déclarée après cette instruction. La différence est subtile, mais importante. Cela pose assurément des problèmes de compatibilité avec les programmes C++ écrits pour ces compilateurs, puisque dans un cas la variable doit être redéclarée et dans l'autre cas elle ne le doit pas. Il est donc recommandé de ne pas déclarer de variables dans la partie initialisation des instructions for pour assurer une portabilité maximale.

2.1.3. Le while

Syntaxe :

while (test) opération;

opération est effectuée tant que test est vérifié. Comme pour le if, les parenthèses autour du test sont nécessaires. L'ordre d'exécution est :

test
opération

Exemple 2-3. Boucle while

somme = i = 0;
while (somme<1000)
{
    somme = somme + 2 * i / (5 + i);
    i = i + 1;
}

2.1.4. Le do

Syntaxe :

do opération;
while (test);

opération est effectuée jusqu'à ce que test ne soit plus vérifié. L'ordre d'exécution est :

opération
test

Exemple 2-4. Boucle do

p = i = 1;
do
{
    p = p * i;
    i = i +1;
} while (i!=10);

2.1.5. Le branchement conditionnel

Syntaxe :

switch (valeur)
{
case cas1:
   [instruction;
    [break;]
   ]
case cas2:
   [instruction;
    [break;]
   ]
   ⋮
case casN:
   [instruction;
    [break;]
   ]
[default:
   [instruction;
    [break;]
   ]
]
}

valeur est évalué en premier. Son type doit être entier. Selon le résultat de l'évaluation, l'exécution du programme se poursuit au cas de même valeur. Si aucun des cas ne correspond et si default est présent, l'exécution se poursuit après default. Si en revanche default n'est pas présent, on sort du switch.

Les instructions qui suivent le case approprié ou default sont exécutées. Puis, les isntructions du cas suivant sont également exécutées (on ne sort donc pas du switch). Pour forcer la sortie du switch, on doit utiliser le mot-clé break.

Exemple 2-5. Branchement conditionnel switch

i= 2;
switch (i)
{
case 1:
case 2:    /* Si i=1 ou 2, la ligne suivante sera exécutée. */
    i=2-i;
    break;
case 3:
    i=0;   /* Cette ligne ne sera jamais exécutée. */
default:
    break;
}

Note : Il est interdit d'effectuer une déclaration de variable dans un des case d'un switch.

2.1.6. Le saut

Syntaxe :

goto étiquette;

étiquette:

étiquette est le point d'arrivée du saut goto. Elle peut avoir n'importe quel nom d'identificateur, et est toujours suivi de deux points (:).

Il n'est pas possible d'effectuer des sauts en dehors d'une fonction. En revanche, il est possible d'effectuer des sauts en dehors et à l'intérieur des blocs d'instructions sous certaines conditions. Si la destination du saut se trouve après une déclaration, cette déclaration ne doit pas comporter d'initialisations. De plus, ce doit être la déclaration d'un type simple (c'est-à-dire une déclaration qui ne demande pas l'exécution de code) comme les variables, les structures ou les tableaux. Enfin, si, au cours d'un saut, le contrôle d'exécution sort de la portée d'une variable, celle-ci est détruite.

Note : Ces dernières règles sont particulièrement importantes en C++ si la variable est un objet dont la classe a un constructeur ou un destructeur non trivial. Voir le Chapitre 7 pour plus de détails à ce sujet.
Autre règle spécifique au C++ : il est impossible d'effectuer un saut à l'intérieur d'un bloc de code en exécution protégée try {}. Voir aussi le Chapitre 8 concernant les exceptions.

2.1.7. Les commandes de rupture de séquence

Syntaxe :

continue;

break;

return [valeur];

goto étiquette;

À part le goto, qui a déjà été vu, il y a d'autres commandes de rupture de séquence (c'est-à-dire de changement de la suite des instructions à exécuter).

return permet de quitter immédiatement la fonction en cours. break permet de passer à l'instruction suivant l'instruction while, do, for ou switch la plus imbriquée (celle dans laquelle on se trouve).

continue saute directement à la dernière ligne de l'instruction while, do ou for la plus imbriquée. Cette ligne est l'accolade fermante. C'est à ce niveau que les tests de continuation sont faits pour for et do, ou que le saut au début du while est effectué (suivi immédiatement du test). On reste donc dans la structure dans laquelle on se trouvait au moment de l'exécution de continue, contrairement à ce qui se passe avec le break.

Exemple 2-6. Rupture de séquence par continue

/* Calcule la somme des 1000 premiers entiers pairs : */
somme_pairs=0;
for (i=0; i<1000; i=i+1)
{
    if (i % 2 == 1) continue;
    somme_pairs=somme_pairs + i;
}

Précédent	Sommaire	Suivant
Exemple de programme complet	Niveau supérieur	Retour sur les types