Cours programmation en langage C : Structures alternatives et répétitives

Ce cours s'adresse aux étudiants de première année en informatique et couvre les structures alternatives et répétitives en langage C. Il présente les instructions conditionnelles (if..else, switch) ainsi que les boucles (while, do..while, for), indispensables pour contrôler le flux d'exécution d'un programme.

Les structures alternatives

En langage C, les structures alternatives permettent de faire des choix dans l'exécution du programme selon une condition donnée.

L'instruction if..else

Syntaxe :

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é. Le bloc peut être une seule instruction ou un ensemble d'instructions entre accolades. Les accolades sont facultatives si le bloc ne contient qu'une seule instruction.

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");
}

Remarque : ici, les accolades sont facultatives car chaque bloc contient une seule instruction.

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 : Trois cas avec if..else if..else

#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 : Affichage 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 : Affichage du jour de la semaine selon un entier

#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

Syntaxe :

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 trouvée, on exécute les instructions associées jusqu'à un break ou la fin du switch.
• Sinon, on exécute l'instruction default si elle existe.
• L'instruction break permet de sortir du switch.

Exemple : Réécriture de l'exemple 4 avec 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 break, toutes les instructions suivantes sont exécutées (effet "fall-through") :

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

Si x vaut 0, on affiche : ZERO UN DEUX AUTRE

Exemple : Réécriture de l'exemple 5 avec 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 plusieurs fois selon une condition.

La boucle while

Syntaxe :

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

Le bloc est exécuté tant que l'expression est vraie (différente de zéro). La condition est testée avant chaque itération, y compris la première. Le bloc peut être une instruction simple ou un bloc entre accolades.

Exemple : Afficher les entiers de 1 à 3 avec while

#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 :

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

Exemple : 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", som);
}

La boucle do...while

Syntaxe :

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

La condition est testée après l'exécution du bloc, ce qui garantit que le bloc est exécuté au moins une fois.

Exemple : Saisir 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);
}

Exemple : Lire un entier 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);
}

Exemple : Lire deux entiers et diviser le premier par le second (diviseur 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, div, (float)n / div);
}

Exemple : Calculer la racine carrée d'un nombre positif

#include <stdio.h>
#include <math.h>
int 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, sqrt(n));
}

La boucle for

Syntaxe :

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

Cette structure est équivalente à :

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

Explications :

• expr1 : initialisation, exécutée une seule fois avant la boucle.
• expr2 : condition, évaluée avant chaque itération.
• expr3 : mise à jour, exécutée à la fin de chaque itération.

Les expressions peuvent contenir plusieurs instructions séparées par des virgules.

Exemple : Afficher 5 fois "bonjour"

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

Sortie :

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

Remarques sur for

• for (i=0, j=0, k=0; ...; ...) initialise plusieurs variables.
• for (; i <= 5; i++) est valide si l'initialisation est faite avant.
• Les accolades sont facultatives si le bloc contient une seule instruction.

Exemple : Calculer la somme des entiers de 1 à 100

#include <stdio.h>
void main()
{
    int n, som;
    for (som = 0, n = 1; n <= 100; n++)
        som += n;

    printf("La somme des nombres de 1 à 100 est %d\n", som);
}

Choix de la structure répétitive

• Si le bloc ne doit pas s'exécuter si la condition est fausse dès le départ, utiliser while ou for.
• Si le bloc doit s'exécuter au moins une fois, utiliser do...while.

Instructions de branchement inconditionnel

Break

L'instruction break permet d'interrompre immédiatement une boucle et de passer à l'instruction suivant la boucle.

Exemple : Utilisation de break dans une boucle for

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

Sortie :

bonjour
bonjour
bonjour
fin du travail

Glossaire des termes clés

• Bloc d'instructions : Ensemble d'instructions regroupées entre accolades { }.
• if..else : Structure conditionnelle permettant d'exécuter un bloc selon une condition.
• switch...case : Structure conditionnelle multi-branches basée sur la valeur d'une expression.
• while : Boucle conditionnelle testant la condition avant chaque itération.
• do...while : Boucle conditionnelle testant la condition après chaque itération, garantissant au moins une exécution.
• for : Boucle avec initialisation, condition et mise à jour intégrées dans la syntaxe.
• break : Instruction permettant de sortir immédiatement d'une boucle ou d'un switch.
• expression : Une valeur ou un calcul numérique utilisé pour tester une condition.

Points clés à retenir

• Les structures alternatives permettent de contrôler le flux selon des conditions (if..else, switch).
• Les boucles while et for testent la condition avant d'exécuter le bloc, do..while après.
• La boucle do..while garantit au moins une exécution du bloc.
• La structure for est une forme compacte de la boucle while avec initialisation et mise à jour.
• L'instruction break interrompt immédiatement une boucle ou un switch.
• Les accolades sont facultatives pour un bloc contenant une seule instruction.
• Sans break dans un switch, les instructions "tombent" à travers les cases suivantes.