Fiche de TP N° 2 Enseignant : Cédric BERE

TP N°2 : Structures de contrôle et boucles

Objectifs d'apprentissage :

§ Savoir utiliser des opérateurs logiques et de comparaison.

§ Utiliser les structures de contrôle (if, if-else, else-if, switch) pour prendre
des décisions.
§ Utiliser des boucles (for, while, do-while) pour répéter des instructions.
§ Utiliser des instructions de contrôle (break, continue) pour gérer
l'exécution d'une boucle.

Partie 1 : opérateurs logiques de comparaison

En langage C, les opérateurs logiques de comparaison permettent de comparer des valeurs et

de produire un résultat booléen (vrai ou faux) en fonction du résultat de la comparaison. Voici
les principaux opérateurs logiques de comparaison :

Opérateur d'égalité (==) : Vérifie si deux valeurs sont égales.

Exemple : (a == b) renvoie vrai si a est égal à b.

Opérateur de différence (!=) : Vérifie si deux valeurs sont différentes.

Exemple : (a != b) renvoie vrai si a est différent de b.

Opérateur de supériorité (>) : Vérifie si une valeur est strictement supérieure à une autre.
Exemple : (a > b) renvoie vrai si a est strictement supérieur à b.

Opérateur de supériorité ou égalité (>=) : Vérifie si une valeur est supérieure ou égale à
une autre.
Exemple : (a >= b) renvoie vrai si a est supérieur ou égal à b.

Opérateur d'infériorité (<) : Vérifie si une valeur est strictement inférieure à une autre.
Exemple : (a < b) renvoie vrai si a est strictement inférieur à b.

Opérateur d'infériorité ou égalité (<=) : Vérifie si une valeur est inférieure ou égale à une
autre.
Exemple : (a <= b) renvoie vrai si a est inférieur ou égal à b.

Ces opérateurs peuvent être utilisés dans des expressions conditionnelles, des boucles et
d'autres situations où la comparaison de valeurs est nécessaire pour prendre des décisions
ou contrôler le flux d'exécution du programme.

Il est important de noter que les résultats des opérations de comparaison sont de type booléen,
où la valeur 0 représente faux et toute autre valeur représente vrai.

Algorithmique et programmation – Travaux pratiques Page 1 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

Exemple d’inégalité mathématique :

Soit A ≤ B ≤ C, correspond (A ≤ B) ET (B ≤ C).
Comment traduire cette inégalité mathématique en expressions conditionnelles en langage
C?

Donc en langage C : (A <= B) && (B<= C)

(A ≤ B ) OU (B≤ C) se traduit en langage C par :

(A <= B) | | (B<= C)

Partie 2 : Structures de contrôle conditionnelles

Les structures de contrôle conditionnelles sont des éléments essentiels de la

programmation qui permettent de prendre des décisions et d'exécuter des blocs de code en
fonction de certaines conditions. Elles permettent de diriger le flux d'exécution d'un
programme en fonction de différentes situations.

Voici les différents types de structures de contrôle conditionnelles :

Structure if (if simple):

La structure if est utilisée pour exécuter un bloc de code si une condition spécifiée est
évaluée comme vraie. Voici sa syntaxe :

/* structure du if simple*/
if (condition)
// instruction à exécuter si la condition est vraie

/* structure du if simple*/
if (condition){
// BLOC DE CODE à exécuter si la condition est
vraie
}
Exemple :
if (a<0){
a = -a;
}

Exemple : Écrire un programme (majeur.c) qui demande à l’utilisateur son age. Et ensuite
verifie si l’âge entré est superieur ou egal à 18. Si c’est le cas le programme affiche vous
êtes majeur

Algorithmique et programmation – Travaux pratiques Page 2 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

#include <stdio.h>

int main() {
int age;

printf("Entrez votre âge : ");

scanf("%d", &age);

if (age >= 18){

printf("Vous êtes majeur.\n");
}
return 0;
}

Structure if-else (if complet):

La structure if-else est considérée comme étant la structure if complète pour exécuter un
bloc de code si toutes les conditions précédentes sont évaluées comme fausses. Elle
fournit une alternative lorsque toutes les autres conditions échouent. Voici sa syntaxe :

if (condition) {
// code à exécuter si la condition est vraie
}
else {
// code à exécuter si la condition est fausse
}

Exemple : ecrire un programme (majeur2.c) qui demande à l’utilisateur son age. Et ensuite
verifie si l’âge entré est superieur ou egal à 18. Si c’est le cas le programme affiche vous
êtes majeur, sinon le programme affiche vous n’êtes pas majeur.

Algorithmique et programmation – Travaux pratiques Page 3 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

Exemple : ecrire un programme (majeur2.c) qui demande à l’utilisateur son age. Et ensuite
verifie si l’âge entré est superieur ou egal à 18. Si c’est le cas le programme affiche vous
êtes majeur, sinon le programme affiche vous n’êtes pas majeur.

Exercice (campagneAgricole.c)
En utilisant la structure if – else, écrivez un programme qui permet de calculer et d’afficher
l’Excédent ou le Déficit effectué lors d’une campagne agricole. Pour ce faire on
demandera à l’utilisateur de saisir la valeur des prévisions ainsi que la valeur des
réalisations.
Le tableau suivant illustre les calculs à éffectuer

#include <stdio.h>

int main() {
int age;
const int age_legal = 18 ;

printf("Entrez votre âge : ");

scanf("%d", &age);

if (age >= age_legal) {

printf("Vous êtes majeur.\n");
}
else {
printf("Vous n’êtes pas majeur.\n");
}

return 0;
}

Exercice (campagneAgricole.c)
En utilisant la structure if – else, écrivez un programme qui permet de calculer et d’afficher
l’Excédent ou le Déficit effectué lors d’une campagne agricole. Pour ce faire on
demandera à l’utilisateur de saisir la valeur des prévisions ainsi que la valeur des
réalisations.
Le tableau suivant illustre les calculs à éffectuer

Algorithmique et programmation – Travaux pratiques Page 4 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

CampagneAgricole.c
#include <stdio.h>

int main() {
float previsions, realisations;

// Saisie des prévisions

printf("Veuillez saisir la valeur des prévisions : ");
scanf("%f", &previsions);

// Saisie des réalisations

printf("Veuillez saisir la valeur des réalisations : ");
scanf("%f", &realisations);

// Vérification de l'excédent ou du déficit

if (realisations > previsions) {
printf("Excédent : %.2f\n", realisations - previsions);
} else {
printf("Déficit : %.2f\n", previsions - realisations);
}

return 0;
}

Algorithmique et programmation – Travaux pratiques Page 5 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

Structure else if :
La structure else if est utilisée pour spécifier une condition supplémentaire à vérifier si la
condition précédente est évaluée comme fausse. Elle permet d'effectuer des alternatives
conditionnelles. Voici sa syntaxe :

/* structure du else if */
if (condition1) {
// code à exécuter si la condition1 est vraie
} else if (condition2) {
// code à exécuter si la condition1 est fausse et la
condition2 est vraie
} else if (condition3) {
// code à exécuter si la condition2 est fausse et la
condition3 est vraie
} else {
// code à exécuter si toutes les conditions sont fausses
}

Exercice : Écrire un programme (mention.c) en utilisant la structure else if qui permet de

déterminer la mention, lorsque l’utilisateur saisit la moyenne de l’étudiant
• Ajournée (moyenne strictement inférieure à 10)

• Admis, mention passable !! (moyenne comprise en 10 et strictement inférieure

à 12)
• Admis, mention Assez bien !! (moyenne comprise en 12 et strictement
inférieure à 14)
• Admis, mention Bien !! (moyenne comprise en 14 et strictement inférieure à
16)
• Admis, mention Très bien !! (moyenne comprise en 16 et strictement
inférieure à 18)

Algorithmique et programmation – Travaux pratiques Page 6 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

mention.c
#include <stdio.h>

int main() {
float moyenne;

// Saisie de la moyenne
printf("Veuillez saisir la moyenne de l'etudiant : ");
scanf("%f", &moyenne);

// Vérification de la mention
if (moyenne >= 0 && moyenne < 10) {
printf("Ajournee\n");
} else if (moyenne >= 10 && moyenne < 12) {
printf("Admis, mention passable !!\n");
} else if (moyenne >= 12 && moyenne < 14) {
printf("Admis, mention Assez bien !!\n");
} else if (moyenne >= 14 && moyenne < 16) {
printf("Admis, mention Bien !!\n");
} else if (moyenne >= 16 && moyenne < 18) {
printf("Admis, mention Tres bien !!\n");
} else if (moyenne >= 18 && moyenne <= 20) {
printf("Admis, mention Excellent !!\n");
} else {
printf("Moyenne invalide\n");
}

return 0;
}

Algorithmique et programmation – Travaux pratiques Page 7 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

Structure switch :
La structure switch permet de choisir parmi plusieurs alternatives en fonction de la valeur
d'une expression. Elle permet une sélection conditionnelle. Voici sa syntaxe :

/* structure du switch */

switch (expression) {
case valeur1:
// code à exécuter si l'expression correspond à valeur1
break;
case valeur2:
// code à exécuter si l'expression correspond à valeur2
break;
case valeur3:
// code à exécuter si l'expression correspond à valeur3
break;
...
default:
// code à exécuter si l'expression ne correspond à aucune des
valeurs
}
Exemple :

#include <stdio.h>

int main() {

int couleur_feu;
printf("Entrer le code de couleur du feu 0 : rouge ; 1 : vert ; 2 : orange ") ;
scanf("%d", &couleur_feu) ;

switch (couleur_feu) {

// 0 pour le rouge
case 0 :
printf("STOP !!") ;
break;

// 1 pour le vert:
case 1 :
printf("Roulez !!") ;
break;

// 2 pour l’orange
case 2 :
printf("freinez, préparez-vous à vous arrêter !!") ;
break;

default:
printf(" Couleur incorrecte !! ") ;
}

Algorithmique et programmation – Travaux pratiques Page 8 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

return 0 ;
}

La structure switch compare la valeur de l'expression avec les différentes valeurs des
cases. L'exécution démarre au cas correspondant à la valeur et continue jusqu'à la fin du
bloc switch ou jusqu'à ce que la clause break soit rencontrée.
Nous ne pouvons pas afficher lʼimage.

Les structures de contrôle conditionnelles offrent une grande flexibilité dans la prise de
décisions dans un programme. Elles permettent de contrôler le flux d'exécution en fonction
des conditions spécifiées, ce qui permet de rendre les programmes plus interactifs et
d'adapter leur comportement en fonction de différentes situations.

Exercice (Calculatrice.c)

Ecrivez un programme en langage C qui permet à l'utilisateur d'effectuer des opérations

basiques (addition, soustraction, multiplication et division) sur deux nombres entiers.

Voici les étapes à suivre :

- Demandez à l'utilisateur d'entrer deux nombres entiers et l'opération souhaitée.
- Utilisez la structure switch pour effectuer l'opération appropriée en fonction de
l'opérateur choisi.
- Affichez le résultat de l'opération à l'écran.
Nous ne pouvons pas afficher lʼimage.

Algorithmique et programmation – Travaux pratiques Page 9 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

#include<stdio.h>

int main(){
int a, b;
char operateur;

printf("***** Bienvenue dans la calculatrice basique ! *******\n\n");

//Récuperer les différentes valeurs

printf("Veuillez entrer le premier nombre : ");
scanf("%d", &a);

printf("Veuillez entrer le deuxième nombre : ");

scanf("%d", &b);

// Récuperer le choix de l'opérateur

printf("Quelle opération souhaitez-vous effectuer ? (+, -, *, /)
: ");
scanf(" %c", &operateur);

//
switch (operateur) {
case '+':
printf("\nLe résultat de %d + %d est : %d\n", a, b, a + b);
break;

case '-':
printf("\nLe résultat de %d - %d est : %d\n", a, b, a - b);
break;

case '*':
printf("\nLe résultat de %d * %d est : %d\n", a, b, a * b);
break;

case '/':
printf("\nLe résultat de %d / %d est : %d\n", a, b, a/b);
break;

default:
printf("\n Opérateur incorrect !!!");
}

Algorithmique et programmation – Travaux pratiques Page 10 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

return 0;
}

Dans cette partie, nous allons aborder les boucles en programmation C. Les boucles
permettent de répéter des instructions plusieurs fois jusqu'à ce qu'une condition
spécifique soit satisfaite. Elles sont utiles pour automatiser des tâches répétitives et
pour traiter des ensembles de données.

Les boucles les plus couramment utilisées en langage C sont :

Boucle for : Cette boucle est utilisée lorsque vous connaissez à l'avance le nombre
d'itérations que vous souhaitez effectuer.

La syntaxe générale de la boucle for est la suivante :

for (initialisation; condition; incrémentation) {

// Instructions à répéter
}

L'initialisation est utilisée pour définir une variable de contrôle et l'initialiser à une
valeur de départ. (instruction d’affectation i=0)
La condition est une expression booléenne qui est évaluée à chaque itération de la
boucle. Si la condition est vraie, les instructions à l'intérieur de la boucle sont
exécutées. Sinon, la boucle se termine.
L'incrémentation est utilisée pour mettre à jour la valeur de la variable de contrôle
après chaque itération.

Exemple 1 : Compter de 1 à 5 compter.c

#include <stdio.h>

int main() {
int i;

printf("Comptage de 1 à 5 :\n");
for (i = 1; i <= 5; i++) {
printf("%d ", i);
}
// i vaut combien 5 ou 6
printf("La valeur de i après le for est : %d", i) ;
return 0 ;
}

i passe à 1
vérifie si i <= 5 ? OUI
exécute printf
incrémente i, donc i passe à 2

Algorithmique et programmation – Travaux pratiques Page 11 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

vérifie si 2 <= 5 ? OUI

exécute printf
incrémente i, donc i passe à 3
vérifie si 3 <= 5 ? OUI
exécute printf
incrémente i, donc i passe à 4
vérifie si 4 <= 5 ? OUI
exécute printf
incrémente i, donc i passe à 5
vérifie si 5<= 5 ? OUI
exécute printf
incrémente i, donc i passe à 6
vérifie si 6<= 5 ? NON
Quitte la boucle for

Dans cet exemple, nous utilisons la boucle for pour effectuer différentes
tâches :

Comptage de 1 à 5 : La boucle for est utilisée pour itérer de 1 à 5. À chaque

itération, la valeur de i est affichée.

Exemple 2 : Décompter de 10 à 1 par ordre décroissant

#include <stdio.h>

int main() {
int i;

printf("Comptage de 10 à 1 en ordre décroissant:\n");

for (i = 10; i >= 1; i--) {
printf("%d ", i);
}

return 0 ;
}

Exemple 3 : Afficher les nombres pairs de 100 à 0 par ordre décroissant

#include <stdio.h>

Algorithmique et programmation – Travaux pratiques Page 12 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

int main() {
int i, k;

for(i=100; i>=0; i=i-2){

printf("\t %d", i);

//Affichage en 4 colonnes
k++;
if(k%4 == 0){
printf("\n");
k=0;
}

return 0;
}
Dans cet exemple, nous utilisons la boucle for pour effectuer différentes
tâches :

Comptage de 10 à 1 (en ordre décroissant) : La boucle for est utilisée pour

itérer de 10 à 1 en décroissant. À chaque itération, la valeur de i est affichée.

Exercice (tableMultiplication.c) :
Table de multiplication de 5 avec la boucle for. À chaque itération, la multiplication de
5 par i est affichée. (i va de 0 à 20).

#include <stdio.h>

int main() {
int i;

printf("\n\nTable de multiplication de 5 :\n");

for (i = 0; i <= 20; i++) {
printf("5 x %d = %d\n", i, 5 * i);
}

return 0 ;
}

Algorithmique et programmation – Travaux pratiques Page 13 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

Boucle while : Cette boucle est utilisée lorsque vous ne connaissez pas à l'avance le
nombre exact d'itérations. La syntaxe générale de la boucle while est la suivante :

while (condition) {
// Instructions à répéter
}
La condition est évaluée avant chaque itération de la boucle. Si la condition est vraie,
les instructions à l'intérieur de la boucle sont exécutées. Sinon, la boucle se termine.
Bouclewhile.c
#include <stdio.h>

int main() {
int i = 1;

printf("Comptage de 1 à 5 :\n");
while (i <= 5) {
printf("%d ", i);
i++;
}
return 0;
}

Exercice 1 : Décompter de 10 à 1 avec la boucle while

#include <stdio.h>

int main() {
int i;
printf("\n\n Décompte de 10 à 1 (en ordre décroissant) :\n");
i = 10;
while (i >= 1) {
printf("%d ", i);
i--; //i = i-1 ;
}
return 0;
}

Exercice controleSaisie1.c:

Ecrire un programme qui demande à

Nous ne pouvons pas afficher lʼimage.

l’utilisateur de saisir un nombre compris en

1 et 10. Si l’utilisateur entre un nombre qui
n’est pas compris entre 1 et 10, le
programme lui demande de saisir de
nouveau jusqu’à ce qu’il entre un nombre
compris entre 1 et 10. On utilisera la boucle
while.
Algorithmique et programmation – Travaux pratiques Page 14 sur 17
Fiche de TP N° 2 Enseignant : Cédric BERE

#include <stdio.h>

int main() {
int i ;

printf(" Entrer un nombre \n");

scanf("%d", &i);

while ((i < 1)|| (i > 10)) {

printf(" Entrer un nombre compris entre 1 et 10 \n");
scanf("%d", &i);
}

return 0;
}

Boucle do-while
Boucle do-while : La boucle do-while est similaire à la boucle while,
mais la condition est vérifiée après chaque itération. Cela signifie
que le bloc de code est exécuté au moins une fois, puis la condition
est évaluée. Si la condition est vraie, la boucle continue à
s'exécuter.

do {
// Instructions à répéter
}while (condition) ;

#include <stdio.h>

int main() {
int i ;

do {
printf(" Entrer un nombre \n");
scanf("%d", &i);
} while ((i < 1)|| (i > 10));

return 0;
}

Algorithmique et programmation – Travaux pratiques Page 15 sur 17

 Fiche de TP N° 2 Enseignant : Cédric BERE

BoucleDowhile.c
#include <stdio.h>

int main() {
int i ;
printf("\n\nComptage de 10 à 1 (en ordre décroissant) :\n");
i = 10;
do{
printf("%d ", i);
i--; //i = i-1 ;
}while (i >= 1);

return 0;
}

Exercice controleSaisie2.c:
Ecrire un programme qui demande à l’utilisateur de saisir un nombre compris en 1 et
10. Si l’utilisateur entre un nombre qui n’est pas compris entre 1 et 10, le programme
lui demande de saisir de nouveau. On utilisera la boucle do-while.

Exercice 2 :

Écrivez un programme en langage C qui demande à l'utilisateur de deviner un nombre

secret compris entre 1 et 100. Le programme génère un nombre secret aléatoire et
demande à l'utilisateur d'entrer des propositions jusqu'à ce qu'il trouve le nombre
secret. Le programme doit afficher un message indiquant si la proposition de
l'utilisateur est trop grande, trop petite ou correcte. Une fois que l'utilisateur a trouvé le
nombre secret, le programme doit afficher le nombre total de tentatives nécessaires.

Inclure les bibliothèques time.h et stdlib.h et utilisez les fonctions time() et srand()

Algorithmique et programmation – Travaux pratiques Page 16 sur 17

Fiche de TP N° 2 Enseignant : Cédric BERE

Nous ne pouvons pas afficher lʼimage.

Algorithmique et programmation – Travaux pratiques Page 17 sur 17