Institut de Science et Responsabilité *Rigueur* Réussite

Techniques Professionnelles **************

<<ISTP>>
Département des Sciences et
Technologies

Enseignant(e) :
Mme Niangui Mona Nély Espérance
PLAN DU COURS
OBJECTIFS
 Acquérir les concepts de base de l'algorithmique et de la
programmation.
 Définir les types de données de base
 Se familiariser à un langage de programmation structuré et à son
environnement de développement
 Utiliser des structures de contrôles.
 Manipuler des sous programmes et des types structurés (tableaux,
intervalles et ensembles, …).
CONTENU
I. INTRODUCTION A L’ALGORITHMIQUE
II. LES CONCEPTS DE BASE
III. LES STRUCTURES DE CONTROLE
IV. IV. LES TABLEAUX

REFERENCES BIBLIOGRAPHIQUES
1. Jacques Courtin, Initiation à l'algorithmique et aux structures de données,
Edition DUNOD, 1998
2. Michel Divay, Algorithmes et structures de données génériques - 2ème
édition, Edition Dunod
3. Thabet Slimani, Programmation et structures de données avancées en
langage C, cours et exercices corrigés, 2014,
4. Damien Berthet, Vincent Labatut, Algorithmique & programmation en
langage C vol.1
5. Pierre-Antoine Champin, Bonnes pratiques de programmation.
Université Claude Bernard Lyon 1, 2017
6. Kyle LOUDON, traduction d’Éric JACOBONI, ALGORITHMES EN C,
O’ Reilly & Associates, Paris 2000,2001, 2002
7. Granet. VMini manuel d’algorithmique et de programmation, 2010,
8. Haro Eni C., Algorithmique-Raisonner pour concevoir, Dunod, 2009.
9. Flasque N., Kassel H., Velikson B, Lepoivre F., 2010, Exercices et
problèmes d’algorithmique, Dunod.
CHAPITRE I : INTRODUCTION A L’ALGORITHMIQUE
I.1 Définitions
 Le terme informatique : l’informatique est une science qui permet de traiter
automatiquement les informations.

 Le terme système informatique : un système informatique est un ensemble

de moyens matériel et logiciels permettant de satisfaire les besoins
informatiques de l’utilisateur :

 Le Matériel informatique : Il s’agit des ressources matérielles qui sont

exploitées pour exécuter les différents logiciels destinés à satisfaire les
besoins des utilisateurs : micro-ordinateurs, imprimantes, scanners, etc.

 Les logiciels : Un logiciel est un ensemble de programmes qui répond aux

besoins fréquents de l’utilisateur dans un domaine d’activités bien
déterminé. On distingue plusieurs types de logiciels : les logiciels de base
comme le système d'exploitation ou les programmes d'application
(Traitement de texte, comptabilité ...).

 Le terme utilisateur : un utilisateur est une personne initiée à

l’informatique et autorisée à exploiter et à manipuler les ressources du
système informatique.

I.2 Notion d’algorithmique et de programmation

I.2.1 Notion d’Algorithme : Origine et définition
Le mot algorithme vient du nom d’un grand mathématicien
Person : Muhammad Ibn Mūsā al-Khuwārizmī, généralement
simplifié en Al-Khwarizmi, né dans les années 780, originaire
de Khiva dans la région du Khwarezm qui lui a donné son
nom, dans l'actuel Ouzbékistan, mort vers 850 à Bagdad. Il est
également le père l’algèbre. Un algorithme est une suite finie
d’instructions que l’on applique à un nombre fini de données dans un ordre précis
pour arriver à un résultat.

I.2.2 Notion d’algorithmique et programmation

 L’algorithmique est la science qui étudie les algorithmes. En d’autres
termes, c’est la logique d’écrire des algorithmes. Elle s’intéresse à l’art de
construire des algorithmes ainsi qu’à caractériser leur validité, leur robustesse,
leur réutilisabilité, leur complexité ou leur efficacité.
Pourquoi apprendre l’algorithmique pour apprendre à programmer ? En
quoi a-t-on besoin d’un langage spécial, distinct des langages de programmation
compréhensibles par les ordinateurs ?
Parce que l’algorithmique exprime les instructions résolvant un problème
donné indépendamment des particularités de tel ou tel langage.
Pour prendre une image,
 Si un programme était une dissertation, l’algorithme serait le plan, une fois
mis de côté la rédaction et l’orthographe. Or, vous savez qu’il vaut mieux
faire d’abord le plan et rédiger ensuite que l’inverse…
 Si la crêpe est un programme, la recette de cuisine serai l’algorithme
Apprendre l’algorithmique, c’est apprendre à manier la structure logique d’un
programme informatique. Cette dimension est présente quelle que soit le langage
de programmation ; mais lorsqu’on programme dans un langage (en C, en Visual
Basic, etc.) on doit en plus se colleter les problèmes de syntaxe, ou de types
d’instructions, propres à ce langage.
•Le Programme : est la traduction d’un algorithme dans un langage de
programmation. C’est une liste d’instructions qu’il faut exécuter pour atteindre un
objectif donné. Selon les définitions précédentes, on voit qu’il existe une grande
similitude entre les termes « programme » et « algorithme ». Les deux désignent
une méthode pour résoudre un problème donné. On emploie le terme « algorithme
» lorsque la séquence d’instructions est écrite en langage algorithmique et fait
abstraction d’un ensemble de détail. On emploie le terme « programme » lorsque
la séquence d’instructions est écrite dans un langage compréhensible par la
machine.

I.3 Cycle de vie d’un programme

Un programme informatique est une suite d’instructions exécutable par
l’ordinateur pour résoudre un problème donné. Il représente une solution à un
problème donné (Figure I.1).

Figure I.1: Etapes de création d’un programme

L'analyse d'un problème posé consiste à définir les différentes étapes de sa
résolution. Elle permet identifier les données d'entrée et le(s) résultat(s) que l'on
souhaiterait obtenir ainsi que les actions. L'ensemble de ces spécifications nous
donne une première solution au problème : l’algorithme.
La phase suivante consiste à traduire l’algorithme dans un langage de
programmation donné. Ce travail, quoiqu’il semble facile, exige le respect strict
de la syntaxe du langage. Lors de l’étape d’exécution, soit des erreurs syntaxiques
sont signalées, ce qui entraîne des corrections en général simples à effectuer, soit
des erreurs sémantiques plus difficiles à découvrir. Dans le cas d’erreur
syntaxique, les retours vers le programme peuvent être fréquents. Dans le cas
d’erreur sémantique, le programme produit des résultats qui ne correspondent pas
à ceux souhaités : les retours vers l’analyse (algorithme) sont alors inévitables.
Exemple explicatif :
Problème : ensemble de familles qui demandent un logement.
Solution : immeuble pour regrouper ces familles

FigureI.2 : Etapes de construction d’un immeuble

Le cycle de vie d’un programme est similaire à un cycle de construction d’un
immeuble, le tableau suivant contient les différentes analogies entre ces deux
cycles : Tableau I.1 : Analogie entre cycle de construction d’un immeuble
I.4 Démarche pour la résolution d’un problème
Pour résoudre un problème à l’aide d’un ordinateur, il est vite apparu
indispensable d’ajouter des niveaux de description et d’abstraction entre
l’homme, qui pose le problème, et la machine, qui est chargée de le résoudre. En
effet, l’homme définit le problème en langue naturelle, de façon formelle et
souvent ambigüe et incomplet. A l’autre extrémité du processus, un ordinateur
n’est capable d’exécuter que des instructions de très bas niveau, où l’information
est codée sous la forme d’une suite de 0 et de 1.
I.4.1 Du problème à la spécification formelle
A partir de la description informelle, ambigüe et incomplet du problème, l’analyse
élabore une spécification formelle, qui décrit de façon non ambigüe et (si possible)
complète et correcte ce que doit faire le programme, c’est-à-dire le « quoi ». Cette
description est faite indépendamment d’une solution. Il s’agit notamment de
préciser :
• les paramètres en entrée, c’est-à-dire la nature des questions ou données du
problème ;
• les paramètres en sortie, c’est-à-dire la nature des solutions ou des résultats du
problème ;
 • les préconditions, c’est - à dire les conditions portant sur les paramètres en
entrée sous lesquelles le problème est défini ;
• la relation entre les paramètres en entrée et les paramètres en sortie, c’est-
à-dire la valeur des paramètres en sortie en fonction de celle des paramètres en
entrée ;
• les contraintes à respecter pour la résolution du problème.

I.4.2 .Vérification de l’algorithme

Une fois conçu, un algorithme doit être validé. Il s’agit de vérifier que
l’algorithme répond effectivement au problème spécifié, et plus particulièrement
qu’il est : • Claire : l’algorithme ne doit pas présenter des ambiguïtés (instruction
interprétable de plusieurs manières) et facile à lire et à comprendre. • Correct : Il
faut que l’algorithme exécute correctement les tâches pour lesquelles il a été
conçu, c’est-à-dire que les valeurs des paramètres de sortie calculées par
l’algorithme sont effectivement celles que l’on souhaite calculer. • Complet :
Ilfaut que l’algorithme considère tous les cas possibles et donne un résultat dans
chaque cas. • Fini : l’algorithme doit se terminer quelle que soit la machine ainsi
que le temps et la date d’exécution. • Efficacité : l’algorithme doit effectuer le
travail demandé avec l’utilisation du minimum de ressources.

I.4.3 Conventions d’écriture d’un algorithme

Historiquement, plusieurs types de notations ont représenté des algorithmes. Il y
a eu notamment une représentation graphique, avec des carrés, des losanges, etc.
qu’on appelait des organigrammes, quasiment abandonnée. C’est pourquoi on
utilise généralement une série de conventions appelée « pseudo-code », qui
ressemble à un langage de programmation authentique.
CHAPITRE II : LES CONCEPTS DE BASES

II.1. Structures et commentaires

Un algorithme comprend essentiellement trois parties :
 La première partie c’est l’entête : elle contient le nom de l’algorithme
précédé par le mot « Algorithme » et de « : » ;
 La deuxième partie est dédiée à la déclaration des constantes et des
variables
 La troisième partie, ce sont les traitements, elle est délimitée par les mots
« DEBUT » et « FIN » qui définissent respectivement le début et la fin des
traitements ou de l’algorithme proprement dit.

STRUCTURE D’UN PROGRAMME EN C++

La structure d’un programme en C++ est la suivante :

#include <iostream> iostream est la librairie qui contient
using namespace std; les outils nécessaires pour afficher du
int main() texte dans la console et récupérer la
{ saisie au clavier.

// instructions //commentaires contenus sur une

seule ligne
 return 0 ;
} . Nous écrirons nos programme dans
la fonction main() qui est un entier.

Les commentaires
L’ajout de commentaires dans les algorithmes et les programmes peut s’avérer
fort utile. En effet, outre le fait de pouvoir retrouver plus facilement les blocs
d’instructions que vous venez de créer, les commentaires pourront vous être d’un
immense secours le jour où vous devrez reprendre votre code.
La lisibilité du code est, d’ailleurs, un des principaux critères de détermination
d’un algorithme. Les commentaires sont invisibles après l’exécution du
programme : ils ne sont pas pris en charge par le programme.
Pour ajouter les commentaires dans une instruction, on utilise les symboles % au
début et à la fin du commentaire.
Exemple : % ceci est un commentaire%
L’ajout de commentaires dans un bloc de code C++ s’effectue de manière mono
ligne ou multi lignes. Les commentaires contenus sur une seule ligne seront
précédés du double slash //. Les commentaires ne pouvant pas être contenus sur
une seule ligne seront précédés de /* et devront se terminer par */.
Exemple :
//Ceci est un commentaire monoligne
/* Ceci est un commentaire sur plusieurs lignes */

II.2. Les variables et les constantes

En programmation tout comme en algorithmique, deux genres de données sont
utilisés : les données dynamiques appelées variables et les données statiques
appelées constantes.

Un ordinateur ou une calculatrice qui exécute un algorithme doit stocker les

données entrées par l’utilisateur et les résultats de ses calculs dans un endroit de
sa mémoire. C’est ce que l’on appellera une Variable. Une variable est un espace
(case, boite) dans la mémoire (RAM) de l’ordinateur destiné à stocker
provisoirement de l’information.
  Elle associe un nom à une valeur qui peut éventuellement varier au cours
du temps.

 La première chose à faire avant de pouvoir utiliser une variable est de

créer la boîte et de lui coller une étiquette. Ceci se fait tout au début de
l’algorithme, avant même les instructions proprement dites. C’est ce
qu’on appelle la déclaration des variables.

II .2.1. Les types de base

Il existe plusieurs types de variables, mais nous considérons cinq types de
base :
II .2.2. La Déclaration d’une variable

Déclaration d’une variable reviens à :

 1- Réserver un espace en mémoire (Type de la donnée ou créer la
boîte )
 2- Attribuer un nom (Identificateur ou étiquette)
 Le nom de la variable obéit à des règles suivantes:
• Il comporter des lettres (a…z, A…Z) et des chiffres (0..9),
• Il doit toujours commence par une lettre,
• Il ne doit pas contenir d’espace, des caractères accentués, des signes de
ponctuation et des caractères spéciaux ( $, €, &, @, #, +,*, -, ?) etc.
• Seule le caractère _ (underscore) est accepté.
• La casse est significative : les caractères majuscules et minuscules sont
distingués.

 Pour déclarer une variable on utilise le mot clé Variables ou Var

Une constante est une variable dont la valeur associée ne varie pas au cours du
programme. Nous pourrons l’écrire entièrement en majuscule,
par exemple PI = 3.14

 Pour déclarer une constante on utilise le mot clé Constantes ou Const

Exemple : Désigner les noms de variables corrects
 DECLARATION DES VARIABLE EN C++

En langage C++, la déclaration d’une variable se fait en indiquant dans l'ordre :

1. Le type de la variable que l'on veut Exemple :
créer ; long ma_variable ;
2. Tapez espace ; int nombre_1 ;
3. Indiquez le nom que vous voulez int nombre_1, nombre_2, nombre_ 3 ;
donner à la variable.
4. saisir le point-virgule.

II.2.2.1. Affectation des variables

L’affectation est l’opération qui consiste à attribuer une valeur à une variable.
Cette valeur peut elle-même être une variable, le résultat d’une expression
arithmétique ou logique ou une constante
Important : une variable ne peut contenir qu'une seule valeur à la fois.

On peut sans aucun problème attribuer à une variable la valeur d’une autre
variable, à condition qu’ils soient de même type.

En C++ l’affectation se fait avec l’opérateur « = ».

Syntaxe :
type nom_de_la_variable = Exemple :
valeur_affectée ; ou
type nom_de_la_variable ; int nbre_1= 20 ;
nom_de_la_variable = int nbre ; nbre=20 ;
valeur_affectée ;

II.2.3. Expressions et opérateurs

  Les expressions

Si on fait le point, on s’aperçoit que dans une instruction d’affectation, on

trouve :
• à gauche de la flèche, un nom de variable, et uniquement cela. En ce monde
rempli de doutes qu’est celui de l’algorithmique, c’est une des rares règles d’or
qui marche à tous les coups : si on voit à gauche d’une flèche d’affectation autre
chose qu’un nom de variable, on peut être certain à 100% qu’il s’agit d’une erreur.
• à droite de la flèche, ce qu’on appelle une expression. Voilà encore un mot qui
est trompeur ; en effet, ce mot existe dans le langage courant, où il revêt bien des
significations. Mais en informatique, le terme d’expression ne désigne qu’une
seule chose, et qui plus est une chose très précise :
Une expression est un ensemble de valeurs, reliées par des opérateurs, et
équivalent à une seule valeur

Exemple: a  b² + c²
chiffre 364+2*3
note  chiffre *0,75 / 100
moyenne  note * 5 - chiffre
L’expression située à droite de la flèche doit être du même type que la variable
située à gauche.
 Les opérateurs
Un opérateur est un signe qui relie deux valeurs, pour produire un résultat.
1- Opérateurs sur les entiers et les réels
2- Opérateurs sur les entiers et les booléens

3.Opérateurs sur les caractères et les chaîne de caractères

Les Operateurs en C++

 et and ou &&
ou or ou ||
non !

II.2.4. Les opérations d’Entrée/Sortie

Dans n’importe quel programme (Algorithme), des échanges d’information ont
lieu entre l’utilisateur et la machine. Ces échanges d’informations sont appelés
opération d’entrée/sortie.
De nombreux algorithmes ont pour but de communiquer avec un utilisateur, cela
se fait dans les deux sens, les sorties sont des envois de messages à l'utilisateur,
les entrées sont des informations fournies par l'utilisateur.

 Les instructions de lecture et écriture

 Opération d’Entrée :
Cette opération est encore appelée Lecture ou Saisie, elle consiste à entrer les
données dans la machine, elle s’effectue généralement par la saisie au clavier.
Syntaxe: Lire (NomVariable) ; Saisie (NomVariable) ;
Lire (NomVariable1, NomVariable2,… NomVariable1)
La saisie interrompt le programme jusqu'a ce que l'utilisateur ait saisi une valeur
au clavier. Une fois cela fait, la valeur saisie est placée dans la variable
NomVariable. Il est possible de saisir plusieurs variables a la suite.

 Opération de Sortie:
Cette opération est encore appelée Ecriture ou Affichage, elle consiste à afficher
les messages et les résultats des traitements de données à l’écran.
Syntaxe: Ecrire (NomVariable) ; Affiche (NomVariable)
Exemple 1: Affiche les valeurs des variables A, age à l’écran.
 Ecrire (A)
Ecrire (age)
Exemple 2:
Ecrire ("Bonjour le Monde")
Ecrire ("Vous avez", age)

Lorsque l'on combine messages et variables dans les instruction d'affichage,

on les sépare par des virgules. Notez bien que ce qui est délimité par les doubles
cotes est affiché tel quel, alors tout ce qui n'est pas délimité par les doubles cotes
est considéré comme des variables.
En C++
 Opération d’entrée est effectuée par le mot clé
cin>>instruction ;
 Opération de sortie est effectuée par le mot clé
cout <<instruction<< endl ;
Exemple :
cout<< "texte à afficher"<< endl ;
cout<< une_variable<< endl ;
cout<< "texte à afficher"<< variable<< endl ;
cin >> variable ;
cout << " Saissisez votre âge " << endl;
cin >> age;

II.5. Construction d’un algorithme simple et traduction en C++

Exemple: calcul de l’aire d’un cercle

Algorithme Calcul_AireCercle Programme C++
Constantes : #include<iostream>
PI = 3,14; using namespace std ;
 Variables : int main()
En entrées : rayon : {
réel; const PI= 3,14 ;
En sortie : surface : float R,S ;
réel; cout<<‘‘Entrez la valeur du
Début rayon :’’<<endl ;
Ecrire (‘‘Entrez la valeur du cin>> R ;
rayon :’’); S=PI*R*R ;
Lire (rayon); cout<<‘‘la surface
surface  PI * est :’’<<S<<endl ;
(rayon*rayon);
Ecrire (surface); return 0 ;
Fin }
Fin de l’algorithme

Exemple :
Créer un algorithme qui calcule et affiche l’aire d’un rectangle après que
l’utilisateur est entré les dimensions du rectangle.
Algorithme Calcul_Aire_rectangle Programme C++
Variables : #include<iostream>
longueur, largeur : using namespace std ;
entier int main()
aire : entier {
DEBUT int longueur, largeur ,aire;
Ecrire ("Entrer la longueur") cout<< ‘‘Entrez la
Lire (longueur) longeur’’<<endl ;
Ecrire ("Entrer la largueur") cin>>longueur ;
Lire (largeur)
aire  longueur * largeur cout<< ‘‘Entrez la
Ecrire (aire) largeur’’<<endl ;
FIN cin>>largeur ;
Fin de l’algorithme aire=longeur*largeur ;

cin>>aire ;

return 0 ;

}
CHAPITRE III : LES STRUCTURES DE CONTROLE

Les structures de contrôle sont présentent dans les langages de programmation et

permettent de gérer le déroulement d’un algorithme, c’est pour cette raison
qu’elles sont aussi appelées structures algorithmiques.
Il existe deux principaux groupes de structures algorithmiques :
 Les structures conditionnelles ou conditions ou encore tests
 Les structures de répétition (interactives) ou boucles

III.1. Les structures conditionnelles

Une condition est une affirmation : l’algorithme et le programme ensuite

détermineront si celle ci est vraie, ou fausse. Une condition retournant VRAI ou
FAUX, a comme résultat un booléen. En règle générale, une condition est une
comparaison même si en programmation une condition peut être décrite par une
simple variable (ou même une affectation)
par exemple. une comparaison est une expression composée de trois éléments :
 une première valeur : variable ou scalaire ;
 un opérateur de comparaison ;
 une seconde valeur : variable ou scalaire.
Il existe deux types de structures de conditions. La première est fondée sur la
combinaison d’instructions si, sinon (en C++ if, else if et else ) et la deuxième
basée sur la combinaison d’instructions tant que(en C++ Switch, case et
default).

III.1.1. LE TEST SI
Encore appelée structure conditionnelle, un test permet d’exécuter une séquence
d’instructions si une condition est vérifiée.
Syntaxe d’une structure de test simple
Si (condition) Alors if(condition)
{
<Séquence d’instructions> <Séquence d’instructions>
 FinSi }

L’exemple suivant illustre ce test.

PROGRAMME TRANCHE D’AGE
VAR age :entier int age ;
DEBUT cout<<("Saisir votre age")<<endl ;
afficher("Saisir votre age") cin>>age ;
Lire(age) if (age >= 18)
Si age ≥ 18 Alors {
afficher("Vous etes majeur !") cout <<("Vous etes majeur !")<<
FinSi endl;
FIN }

La structure simple d’un test est relativement claire, arrivé à la première ligne
(Si… Alors) la machine examine la valeur de la condition. Si la cette valeur est
VRAI, elle exécute la séquence d’instructions.
Cette séquence d’instructions peut être très brève comme très longue, cela n’a
aucune importance. En revanche, dans le cas où la condition est FAUX,
l'ordinateur saute directement aux instructions situées après le FinSi.
Une condition s’exprime sous forme d’une expression logique (Booléenne).
Elle peut être:
• simple (condition simple): VRAI , FAUX
• ou combinée (plusieurs conditions composées) avec des opérateurs
logiques ET, OU, NON, et des opérateurs de comparaison.

Syntaxe d’une structure de test composée

Si (condition) Alors if (condition)
{
<bloc d’instructions > <bloc d’instructions >
}
Sinon else
<blocd’instructions 2> {
FinSi <bloc d’instructions >
}
  Tests imbriqués
Graphiquement, on peut très facilement représenter un SI comme un aiguillage
de chemin de fer. Un SI ouvre donc deux voies, correspondant à deux
traitements différents. Mais il y a des tas de situations où deux voies ne suffisent
pas. Vous pouvez en effet parfaitement imbriquer vos tests en plaçant des Si en
cascade dans les blocs d’instructions situés après les Alors et les Sinon suivant
la syntaxe :
Si (condition) Alors if (condition)
{
<bloc d’instructions > bloc d’instructions
}
Sinon Si (condition) Alors else if (condition)
{
<blocd’instructions 2> bloc d’instruction
Sinon }
<blocd’instructions 2> else
{
FinSi bloc d’instructions
FinSi }

III.1.2. Le test à choix multiple ou Structure conditionnelle multiple (le

choix) << Selon Faire >>en C++<< switch case>>
Lorsque que l'on souhaite conditionner l'exécution de plusieurs ensembles
d'instructions par la valeur que prend une variable, plutôt que de faire des
imbrications de Si a outrance, on préférera la structure conditionnelle
multiple. Elle se présente sous la forme suivante :
selon <valeur ou expression> faire switch( variable )
Valeur 1: <Séquence {
d’instructions 1> case valeur_1: instructions
Valeur 2: <Séquence break;
d’instructions 2>
………….. case valeur_2: instructions
Valeur n: <Séquence break;
d’instructions n> ……………….
 Sinon <Séquence par default: instructions
défaut> }
Finselon

Dans cette structure, on peut comparer un objet (variable ou expression) à

toute une série de valeurs, et d’exécuter , en fonction de la valeurs effective de
l’objet, différentes séquence d’instructions. Une séquence par défaut peut être
prévu dans le cas où l’objet n’est égale à aucune des valeurs énumérées.

III.2. Les structures de répétition ou boucles

Les boucles permettent de réaliser des blocs d’instructions à plusieurs reprises,
appelées instructions d’itération. On peut dire en fait que les boucles constituent
la seule vraie structure logique caractéristique de la programmation. Si vous
avez utilisé un tableur comme Excel, par exemple, vous avez sans doute pu
manier des choses équivalentes aux variables (les cellules, les formules) et aux
tests (la fonction SI…). Mais les boucles, ça, ça n'a aucun équivalent. Cela
n'existe que dans les langages de programmation proprement dits.
Prenons le cas d’une saisie au clavier (une lecture), où par exemple, le
programme pose une question à laquelle l’utilisateur doit répondre par O (Oui)
ou N (Non). Mais tôt ou tard, l’utilisateur, facétieux ou maladroit, risque de
taper autre chose que la réponse attendue. Dès lors, le programme peut planter
soit par une erreur d’exécution (parce que le type de réponse ne correspond pas
au type de la variable attendu) soit par une erreur fonctionnelle (il se déroule
normalement jusqu’au bout, mais en produisant des résultats fantaisistes).
Alors, dans tout programme un tant soit peu sérieux, on met en place ce qu’on
appelle un contrôle de saisie, afin de vérifier que les données entrées au clavier
correspondent bien à celles attendues par l’algorithme
A vue de nez, on pourrait essayer avec un Si. Voyons voir ce que ça donne :
 C’est impeccable. Du moins
tant que l’utilisateur a le bon
goût de ne se tromper qu’une
seule fois, et d’entrer une
valeur correcte à la deuxième
demande. Si l’on veut
également bétonner en cas de
deuxième erreur, il faudrait
rajouter un Si. Et ainsi de
suite, on peut rajouter des
centaines de Si, et écrire un algorithme aussi lourd qu’une blague des Grosses
Têtes, on n’en sortira pas, il y aura toujours moyen qu’un acharné flanque le
programme par terre.
La solution consistant à aligner des Si … en pagaille est donc une impasse.

La seule issue possible est donc d’utiliser une structure de boucle.

Une boucle permet d'exécuter plusieurs fois de suite une même séquence
d'instructions.
Cette ensemble d'instructions s'appelle le corps de la boucle.
Chaque exécution du corps d'une boucle s'appelle une itération, ou encore un
passage dans la boucle. Il existe trois types de boucle :
 tant que … faire
 répéter ... jusqu’à
 pour … faire

III.2.1. La boucle Tant que…….faire

Le principe est simple : le programme arrive sur la ligne du tant que. Il examine
alors la valeur de la condition (qui, je le rappelle, peut être une variable
booléenne ou une expression). Si cette valeur est VRAI, le programme exécute
les instructions qui suivent, jusqu’à ce qu’il rencontre la ligne fin tant que. Il
retourne ensuite sur la ligne du tant que, procède au même examen, et ainsi de
suite. Le manège enchanté ne s’arrête que lorsque la condition n’est plus vérifier
(le booléen prend la valeur FAUX).

Sa syntaxe est la suivante :

Langage algorithmique Implantation C++
TANTQUE condition FAIRE while (condition)
instruction 1 {
... instruction 1;
instruction n ...
instruction n;
fin tantque }

instructions suivantes instructions suivantes;

Le principe est simple : le programme arrive sur la ligne du tant que. Il examine
alors la valeur de la condition (qui, je le rappelle, peut être une variable
booléenne ou une expression). Si cette valeur est VRAI, le programme exécute
les instructions qui suivent, jusqu’à ce qu’il rencontre la ligne fin tant que. Il
retourne ensuite sur la ligne du tant que, procède au même examen, et ainsi de
suite. Le manège enchanté ne s’arrête que lorsque la condition n’est plus vérifier
(le booléen prend la valeur FAUX).

Illustration avec notre problème de contrôle de saisie. Une première

approximation de la solution consiste à écrire :
NOTE : Une boucle tant que … faire n’est exécuter que si la condition est
vérifiée dès le départ.

III.2.2. La boucle répéter … jusqu’à

Sa syntaxe est la suivante :
Langage algorithmique Implantation C++
Faire do
instruction 1 {
... instruction 1;
instruction n ...
instruction n;
Jusqu’à(condition) } while (condition) ;
Fin
instructions suivantes instructions suivantes;

Le fonctionnement est analogue à celui de la boucle tant que à quelques

détails près :
• la condition est évaluée après chaque passage dans la boucle.
• on exécute le corps de la boucle jusqu’à ce que la condition soit
vérifiée, donc tant que la condition est fausse.
NOTE : Une boucle répéter ... jusqu'a s’exécutée donc au moins une fois
avant de tester la condition .

Reprenons l'exemple précédent avec une boucle répéter ... jusqu'a :

La boucle pour … faire

III.2.3 La boucle pour … faire

Sa syntaxe est la suivante :

Langage algorithmique
Pour ( compteur : = valeur initiale à valeur finale) pas de < incrément>
faire
<Séquence d’instructions>
Fin pour

Implantation C++
for(compteur= valeur_initiale ; compteur<= valeur _finale ; compteur++)
{
<Séquence d’instructions>
}
Cette structure permet de répéter une séquence un nombre connu de fois.
Le compteur est une variable de type entier. La valeur initiale et la valeur finale
sont des constantes ou des variables de type entier. L’incrément (pas) est la
valeur d’augmentation progressive du compteur. La valeur par défaut du pas est
de 1 (dans le cas où on ne le précise pas).
Si la valeur initiale est égale à la valeur finale, la séquence d’instruction définie
est exécutée une seule fois.
Par contre, la séquence d’instruction n’est pas exécutée dans deux cas:
• Si la valeur initiale est strictement supérieure à la valeur finale alors que
l’incrément est positif, ou bien
• Si la valeur initiale est strictement inférieure à la valeur finale alors que
l’incrément est négatif.
La structure pour … faire est une simplification de la structure suivante:

compteur  valeur initiale

Tant que (compteur < = valeur finale ) faire
<Séquence d’instructions>
compteur  compteur + incrément
Fin tant que

III.2.3 Les boucles imbriquées

Les boucles peuvent être imbriquées les unes dans les autres. Une boucle
« tant que …faire » peut contenir une autre boucle « tant que … faire », ou
une boucle « répéter… jusqu’à », ou une autre boucle « pour … faire », et
vice versa.
De plus une boucle peut contenir une autre boucle qui elle-même peut
contenir une autre boucle et ainsi de suite.

NOTE : Une boucle peut contenir un test et vice versa.

Exemple:
Ecrire un algorithme permettant d’effectuer et d’afficher toutes les tables
de multiplication par 1 jusqu’à 12.

Algorithme Tables_Multiplication
Variables :
i , j : entier
Début nnnn,,,,
Ecrire (" Tables de multiplication : ")
Pour ( i := 1 à 12 ) faire
Pour ( j := 1 à 12 ) faire
Ecrire ( j, " * ", i , " = " , j * i )
Fin pour
Fin pour
Fin
Fin Algorithme