Cours Programmation en Langage C : Structures Alternatives et Répétitives

Ce cours couvre les structures alternatives et répétitives en langage C, destinées aux étudiants de première année en informatique appliquée. Il présente les instructions conditionnelles (if..else, switch) et les boucles (while, do..while, for), ainsi que les instructions de branchement inconditionnel (goto, break, continue).

Les structures alternatives

Les structures alternatives permettent d'exécuter différents blocs d'instructions selon le résultat d'une condition. En langage C, les principales instructions de choix sont if..else et switch.

L'instruction if..else

L'instruction if..else évalue une expression numérique pour déterminer quel bloc d'instructions exécuter.

if ( <expression> )
    <bloc d'instructions 1>
else
    <bloc d'instructions 2>

Si l'expression est différente de zéro (vraie), le bloc 1 est exécuté, sinon le bloc 2 est exécuté. L'expression peut être une variable numérique ou une expression numérique. Les blocs peuvent être une seule instruction ou un ensemble d'instructions entre accolades. Si un bloc contient une seule instruction, les accolades sont facultatives.

Exemples d'utilisation de if..else

Exemple 1 : Afficher si un entier est positif ou négatif.

#include <stdio.h>
void main()
{
    int x;
    printf("saisir un entier");
    scanf("%d", &x);
    if (x >= 0)
        printf("entier positif");
    else
        printf("entier négatif");
}

Exemple 2 : Afficher le maximum de deux entiers.

#include <stdio.h>
void main()
{
    int x, y;
    printf("saisir deux entiers");
    scanf("%d%d", &x, &y);
    if (x > y)
        printf("le maximum est %d", x);
    else
        printf("le maximum est %d", y);
}

Exemple 3 : Afficher si un entier est positif, négatif ou nul.

#include <stdio.h>
void main()
{
    int x;
    printf("saisir un entier");
    scanf("%d", &x);
    if (x > 0)
        printf("entier positif");
    else if (x < 0)
        printf("entier négatif");
    else
        printf("entier nul");
}

Exemple 4 : Afficher ZERO, UN, DEUX ou AUTRE selon la valeur d'un entier.

#include <stdio.h>
void main()
{
    int x;
    printf("saisir un entier");
    scanf("%d", &x);
    if (x == 0)
        printf("ZERO");
    else if (x == 1)
        printf("UN");
    else if (x == 2)
        printf("DEUX");
    else
        printf("AUTRE");
}

Exemple 5 : Afficher le jour de la semaine selon un entier de 1 à 7, ou "Autre".

#include <stdio.h>
void main()
{
    int x;
    printf("saisir un entier");
    scanf("%d", &x);
    if (x == 1) printf("Lundi");
    else if (x == 2) printf("Mardi");
    else if (x == 3) printf("Mercredi");
    else if (x == 4) printf("Jeudi");
    else if (x == 5) printf("Vendredi");
    else if (x == 6) printf("Samedi");
    else if (x == 7) printf("Dimanche");
    else printf("Autre");
}

L'instruction switch...case

L'instruction switch permet de réaliser un branchement sélectif parmi plusieurs cas possibles en fonction de la valeur d'une expression.

switch (expression)
{
    case constante_1: [suite_inst_1]; break;
    case constante_2: [suite_inst_2]; break;
    case constante_3: [suite_inst_3]; break;
    [default: suite_inst];
}

Fonctionnement :

• L'expression est évaluée.
• On cherche une étiquette case correspondant à la valeur obtenue.
• Si elle est trouvée, on exécute les instructions à partir de cette étiquette.
• Sans l'instruction break, l'exécution se poursuit dans les cas suivants (effet de cascade ou "fall-through").
• Si aucune case ne correspond, l'instruction default est exécutée si elle est présente.

Exemples d'utilisation de switch

Reprise de l'exemple 4 avec la structure switch :

#include <stdio.h>
void main()
{
    int x;
    printf("donner un entier");
    scanf("%d", &x);

    switch (x)
    {
        case 0: printf("ZERO"); break;
        case 1: printf("UN"); break;
        case 2: printf("DEUX"); break;
        default: printf("AUTRE"); break;  // break facultatif ici
    }
    printf("fin du travail");
}

Sans l'utilisation de break, toutes les instructions des cas suivants sont exécutées :

switch (x)
{
    case 0: printf("ZERO");
    case 1: printf("UN");
    case 2: printf("DEUX");
    default: printf("AUTRE");
}

Si la valeur saisie est 0, l'affichage sera : ZERO UN DEUX AUTRE fin du travail.

Reprise de l'exemple 5 avec la structure switch :

#include <stdio.h>
void main()
{
    int x;
    printf("saisir un entier");
    scanf("%d", &x);

    switch (x)
    {
        case 1: printf("Lundi"); break;
        case 2: printf("Mardi"); break;
        case 3: printf("Mercredi"); break;
        case 4: printf("Jeudi"); break;
        case 5: printf("Vendredi"); break;
        case 6: printf("Samedi"); break;
        case 7: printf("Dimanche"); break;
        default: printf("Autre");
    }
}

Les structures répétitives

Les boucles permettent de répéter un bloc d'instructions tant qu'une condition reste vérifiée. Le langage C propose trois structures répétitives principales.

1. while
2. do..while
3. for

La boucle while

La boucle while évalue la condition de poursuite avant chaque itération.

while (<expression>)
    <bloc d'instructions>

Tant que l'expression est différente de zéro (vraie), le bloc est exécuté. La condition est évaluée avant chaque tour, y compris le premier. Le bloc peut comporter une seule instruction ou plusieurs instructions entre accolades. Aucun point-virgule ne doit être placé après la parenthèse fermante du while.

Exemples d'utilisation de while

Exemple 1 : Afficher les entiers de 1 à 3.

#include <stdio.h>
void main()
{
    int i = 1;
    while (i <= 3)
    {
        printf("l’entier est %d\n", i);
        i++;
    }
    printf("%d\n", i);
    printf("fin du travail\n");
}

Sortie du programme :

l’entier est 1
l’entier est 2
l’entier est 3
4
fin du travail

À la sortie de la boucle, la variable i prend la valeur 4.

Exemple 2 : Lire des entiers jusqu'à ce que leur somme dépasse 100.

#include <stdio.h>
void main()
{
    int n, som = 0;
    while (som < 100)
    {
        printf("donner un nombre");
        scanf("%d", &n);
        som += n;
    }
    printf("la somme obtenue %d\n", som);
}

La boucle do..while

La boucle do..while évalue la condition après l'exécution du bloc d'instructions, garantissant au moins une exécution.

do
    <bloc d'instructions>
while (<expression>);

Contrairement à la boucle while, l'évaluation se fait après le bloc. Ce dernier est donc exécuté au moins une fois, quelle que soit la valeur initiale de la condition.

Exemples d'utilisation de do..while

Exemple 1 : Saisir et valider un entier strictement positif.

#include <stdio.h>
void main()
{
    int n;
    do
    {
        printf("donner un nombre strictement positif");
        scanf("%d", &n);
    }
    while (n <= 0);
    printf("l’entier lu est %d\n", n);
}

Exemple 2 : Lire et valider un entier compris entre 1 et 10.

#include <stdio.h>
void main()
{
    int n;
    do
    {
        printf("saisir un nombre entre 1 et 10 ");
        scanf("%d", &n);
    }
    while (n < 1 || n > 10);
    printf("l’entier lu est %d\n", n);
}

Exemple 3 : Diviser deux entiers en s'assurant que le diviseur soit non nul.

#include <stdio.h>
void main()
{
    int n, div;
    printf("Entrez le nombre à diviser : ");
    scanf("%d", &n);
    do
    {
        printf("Entrez le diviseur (différent de 0) : ");
        scanf("%d", &div);
    }
    while (!div);  // équivalent à while (div == 0)
    printf("%d / %d = %f\n", n, div, (float)n / div);
}

Exemple 4 : Saisir un nombre positif et calculer sa racine carrée.

#include <stdio.h>
#include <math.h>
void main()
{
    float n;
    do
    {
        printf("Entrer un nombre positif : ");
        scanf("%f", &n);
    }
    while (n < 0);
    printf("La racine carrée de %.2f est %.2f\n", n, sqrt(n));
}

L'instruction for

L'instruction for regroupe l'initialisation, la condition de poursuite et la réinitialisation au sein d'une même ligne d'en-tête.

for ([<expr1>]; [<expr2>]; [<expr3>])
    <bloc d'instructions>

Cette structure est strictement équivalente à :

<expr1>;
while (<expr2>)
{
    <bloc d'instructions>
    <expr3>;
}

Rôle des expressions :

• <expr1> : initialisation exécutée une seule fois avant le début de la boucle.
• <expr2> : condition évaluée avant chaque itération pour autoriser ou non le passage dans la boucle.
• <expr3> : étape de mise à jour exécutée à la fin de chaque itération.

Exemples d'utilisation de for

Affichage répété de messages avec comptage :

void main()
{
    int i;
    for (i = 1; i <= 5; i++)
    {
        printf("bonjour ");
        printf("%d fois\n", i);
    }
    printf("la valeur de i est %d\n", i);
}

Sortie du programme :

bonjour 1 fois
bonjour 2 fois
bonjour 3 fois
bonjour 4 fois
bonjour 5 fois
la valeur de i est 6

Remarques synthétiques :

• Plusieurs variables peuvent être initialisées dans expr1 en séparant les instructions par des virgules (ex : for (i=0, j=0; ...; ...)).
• Les accolades sont facultatives si le bloc ne comporte qu'une instruction unique.

Calcul de la somme des entiers de 1 à 100 :

#include <stdio.h>
void main()
{
    int n, som;
    for (som = 0, n = 1; n < 101; n++)
        som += n;
    printf("La somme des nombres de 1 à 100 est %d\n", som);
}

Choix de la structure répétitive

Le choix de la boucle dépend du besoin d'exécuter ou non le bloc avant le test de condition.

• Si le bloc ne doit pas s'exécuter lorsque la condition est fausse dès le départ, privilégiez while ou for.
• Si le bloc doit être exécuté au moins une fois impérativement, utilisez do..while.

L'instruction break

L'instruction break provoque la sortie immédiate d'une boucle ou d'une structure switch, en passant directement à l'instruction suivante.

Exemple d'utilisation de break

#include <stdio.h>
void main()
{
    int i;
    for (i = 1; i < 10; i++)
    {
        printf("bonjour\n");
        if (i == 3) break;
    }
    printf("fin du travail\n");
}

Sortie du programme :

bonjour
bonjour
bonjour
fin du travail

Glossaire des termes clés

• Bloc d'instructions : Ensemble d'instructions délimité par des accolades { }.
• if..else : Structure conditionnelle effectuant un choix binaire selon la valeur d'une condition.
• switch...case : Structure de choix multiple aiguillant le programme selon une valeur constante.
• while : Boucle conditionnelle évaluant sa condition de poursuite avant l'exécution du bloc.
• do..while : Boucle conditionnelle évaluant sa condition après l'exécution du bloc.
• for : Boucle regroupant initialisation, condition et incrémentation dans son en-tête.
• break : Instruction de branchement interrompant brutalement une boucle ou un switch.
• expression : Combinaison de variables et d'opérateurs fournissant une valeur numérique.

Points clés à retenir

• Les structures alternatives permettent de contrôler le flux d'exécution selon des tests logiques.
• Les accolades sont obligatoires pour regrouper plusieurs instructions au sein d'un même bloc.
• La structure switch facilite l'écriture de choix multiples sur des valeurs entières ou caractères.
• Les boucles while et for conviennent pour 0 à N itérations, tandis que do..while effectue de 1 à N itérations.
• L'instruction break stoppe prématurément le déroulement des boucles.