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

Ce laboratoire présente les structures alternatives et répétitives en langage C. Il permet d'apprendre à utiliser les instructions conditionnelles (if..else, switch) et les boucles (while, do..while, for) pour contrôler le flux d'exécution d'un programme. Pour réaliser ce TP, il est nécessaire d'avoir un environnement de programmation C avec un compilateur standard (comme gcc) et des connaissances de base en programmation C.

Objectifs

• Comprendre et utiliser les structures alternatives if..else et switch..case.
• Maîtriser les différentes boucles : while, do..while et for.
• Savoir choisir la structure répétitive adaptée selon le contexte.
• Utiliser les instructions break et continue pour contrôler les boucles.

Prérequis et installation

• Un compilateur C (gcc, clang, ou autre).
• Un éditeur de texte pour écrire les programmes.
• Connaissances de base en langage C : variables, types, entrées/sorties.
• Compréhension des expressions booléennes et des opérateurs relationnels.

Structures alternatives : if..else

La structure if..else permet d'exécuter un bloc d'instructions selon une condition. La syntaxe est :

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

Si l'expression est différente de zéro, le bloc 1 est exécuté, sinon le bloc 2. Les blocs peuvent être une seule instruction ou plusieurs instructions entre accolades.

Exemple : Programme qui lit un entier et affiche s'il 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");
    }
}

Les accolades sont facultatives si le bloc contient une seule instruction.

Exemple : Programme qui affiche 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 : Programme qui affiche 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");
}

Structure alternative : switch..case

La structure switch permet de choisir entre plusieurs cas selon la valeur d'une expression entière.

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];
}

L'expression est évaluée, puis on exécute le bloc correspondant à la constante trouvée. L'instruction break permet de sortir du switch.

Exemple : Réécriture du programme d'affichage ZERO, UN, DEUX ou AUTRE 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");
}

Attention : sans break, tous les cas suivants sont exécutés.

Exemple : Affichage du jour de la semaine selon un entier (1 à 7) 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");
    }
}

Structures répétitives : la boucle while

La boucle while répète un bloc tant que la condition est vraie (différente de zéro). La condition est testée avant chaque itération.

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

Le bloc peut être une instruction simple ou un bloc entre accolades. Si la condition est fausse dès le départ, le bloc n'est pas exécuté.

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

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\n", som);
}

Structure répétitive : la boucle do..while

La boucle do..while exécute le bloc au moins une fois, puis teste la condition après chaque itération.

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

Exemple : Lire 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 : 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", 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", n, div, (float)n / div);
}

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

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

Structure répétitive : la boucle for

La boucle for est une forme compacte de boucle avec initialisation, condition et mise à jour.

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

Elle est équivalente à :

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

Les parties expr1 et expr3 peuvent contenir plusieurs expressions 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\n", i);
}

Sortie attendue :

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

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

Les accolades sont facultatives si la boucle contient une seule instruction.

Choix de la structure répétitive

• Utiliser while ou for si le bloc peut ne pas être exécuté (condition testée avant).
• Utiliser do..while si le bloc doit être exécuté au moins une fois (condition testée après).

Instruction break

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

Exemple : Afficher "bonjour" jusqu'à i = 3, puis sortir de la boucle.

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

bonjour
bonjour
bonjour
fin du travail

Résultats attendus

• Compréhension claire de la syntaxe et du fonctionnement des structures if..else, switch..case, while, do..while, for.
• Capacité à écrire des programmes simples utilisant ces structures pour contrôler le flux.
• Exécution correcte des programmes exemples avec les sorties attendues.
• Maîtrise de l'usage de break pour interrompre une boucle.

Pièges courants

• Oublier les accolades pour un bloc multiple dans if..else ou dans une boucle.
• Ne pas mettre les break dans switch, entraînant l'exécution en cascade des cas.
• Mettre un point-virgule après la condition while (…); ce qui crée une boucle vide.
• Ne pas initialiser les variables utilisées dans la condition de boucle (while, for).
• Confondre la condition testée avant (while, for) et après (do..while).
• Utiliser break hors d'une boucle ou d'un switch provoque une erreur de compilation.