Algorithmique Et Programmation C++ AHMADI 2021 - 2022 - V27

Algorithmique et
Programmation C++
A. AHMADI
ENSAM-Meknès
2021-2022
1
Algorithmique et Programmation C++
2
A.AHMADI
_________________
ENSAM-Meknès
2021/2022
Plan du cours
3
1. Algorithmique
2. Présentation du langage C++ et de l’environnement de développement
intégré
3. Eléments de base du langage C++
Types de base
Opérateurs et expressions
Entrées/Sorties standard
Instructions de contrôle
4. Fonctions
5. Types structurés
Tableaux et Pointeurs
Chaînes de styles
Types structurés
6. Gestion des Fichiers
A. AHMADI Algorithmique et Programmation en C++

Chapitre 1
4
Algorithmique

Chap. 1 Algorithmique
I- Introduction
5
 Algorithmique : néologisme introduit en 1957. Il prend sa racine de l’ancien mot « Algorisme » qui
définit le processus de faire l’arithmétique en utilisant les chiffres arabes ;
 Le mot "Algorisme " provient du nom du célèbre mathématicien Perse Al-Khawarismi, auteur du
livre "Hissab Al jabr wa Al Mokabala" ;
 Algorithme : description du schéma de réalisation d’un événement à l’aide d’un répertoire fini
d ’actions élémentaires, réalisables à durée limitée dans le temps ;
 Un algorithme est destiné à un processeur qui peut l’exécuter, c’est à dire, réaliser l’enchaînement
des opérations que l’algorithme lui décrit ;
 Pour qu’un algorithme soit exécutable par un processeur, il doit être écrit dans un Langage
compréhensible par ce processeur ;
 Si le processeur est un ordinateur, l’algorithme s’appelle un programme ;
 La notion d’algorithme n’est pas spécifique à l’informatique (voir exemples ci-dessus).

I- Introduction
6
 Dans les années 50, le mot algorithme était associé à "l’algorithme d’Euclide", c’est à dire, le
processus de trouver le plus grand diviseur commun de deux entiers :
principe : 𝒂 = 𝒃 ∗ 𝒒 + 𝒓 , 𝟎 ≤ 𝒓 < 𝒃 (Division Euclidienne de 𝑎 par 𝑏).
On a 𝑷𝑮𝑪𝑫(𝒂, 𝒃) = 𝑷𝑮𝑪𝑫(𝒃, 𝒓). Donc, on cherche le dernier reste non nul. On affine
cette méthode comme suit :
Etape 1 : trouver le reste 𝑟 de la division euclidienne de 𝑎 par 𝑏 ;

Etape 2 : Si 𝑟 = 0, FIN de l’algorithme et 𝑃𝐺𝐶𝐷(𝑎, 𝑏) = 𝑏.
Sinon Faire la permutation suivante : 𝑎 ← 𝑏 et 𝑏 ← 𝑟 et retourner à
l’étape 1.
Etape 3 : FIN de l ’algorithme.
L’étape 3 sert à dire explicitement qu’on a bien terminé l’écriture de l’algorithme.

II- Etapes de résolution informatique d’un problème
7
1- Définition du problème
Il s’agit de bien définir le problème, de manière à éviter toute ambiguïté, et souligner toutes ses
spécifications et les conditions nécessaires à sa réalisation. Il s’agit de répondre aux questions
suivantes :
- Quelles sont les données du problème? comment devront être introduites?

- Quelles sont les erreurs susceptibles de se produire ? et quelle est l’action à prendre dans chaque
cas ?
- Quels sont les résultats à fournir ? et comment les présenter ?
- Quels sont les traitements (et les techniques) à effectuer?
2- Structure générale
Dans cette étape, on pose les grandes lignes de l’algorithme et on procède à une décomposition du
problème en une suite de sous-problèmes plus simples à résoudre. C’est le principe de "diviser pour
régner".

II- Etapes de résolution informatique d’un problème
8
3- Développement
Il s’agit d’élaborer l’algorithme correspondant à chaque sous-problème de l’étape précédente et
l’algorithme global du problème.
4- Validation de l’algorithme
Dans cette étape, on vérifie si l’algorithme répond bien à toutes les spécifications du problème définies
à l’étape 1. Une erreur ou un cas non traité pourra remettre en cause la solution proposée.
5- Codage
On traduit l’algorithme, validé, en un programme dans un langage de programmation adéquat,
disponible et maîtrisé, pour le rendre exécutable par la machine
6- Mise au point
On corrige les erreurs commises à l’étape précédente et signalées par le compilateur .
Le compilateur est un programme qui, ayant reçu un autre programme écrit dans un langage évolué,
l’analyse(détermine les erreurs de syntaxe, mais pas de conception et de logique) et le traduit en un
langage machine; il traduit donc le source en un exécutable.

III- Actions de base dans un algorithme
9
1- Variable
 C’est un objet qui peut prendre une ou plusieurs valeurs durant son existence dans un programme
donné. Elle est caractérisée par les trois éléments suivants :
- Son nom (identification ou désignation de l’emplacement mémoire de la variable) qui la
différencie des autres et permet l’accès à sa valeur.
- Son type, qui spécifie le domaine de valeurs que peut prendre la variable.
- sa valeur (c’est le contenu actuel de l’emplacement mémoire de la variable).
 Le type de variable spécifie implicitement le genre d’opérations permises. Par exemple sur les
entiers on utilise l’addition , la multiplication, etc.
2-Affectation
 C’est l’attribution d’une valeur à une variable. Notation :  ou = .
 On affecte une variable par une expression du même type. Il faut noter qu’une expression du
style : 𝑥 = 𝑒𝑥𝑝𝑟𝑒𝑠𝑠𝑖𝑜𝑛, ne se lit que dans un seul sens : la variable 𝑥 prend la valeur de
l’expression à droite

10
Exemples d’affectation :
- 𝑋 − 2.56 (ou 𝑋 = −2.56), signifie que la variable X reçoit la valeur −2.56 (sa valeur actuelle).
Son type est réel ;
- 𝑦 = 𝑉𝑅𝐴𝐼. Son type est booléen {vrai, faux} ;
- 𝑍 = ‘𝐵𝑜𝑛𝑗𝑜𝑢𝑟’. Son type est chaîne de caractères.
 Il existe trois formes d’affectation :

- variable  constante. (voir les 3 exemples précités) ;
- variable  variable (ex. 𝑇 = 𝑍 et donc la valeur de la variable 𝑇 est ‘Bonjour’) ;
- Variable  expression composée, arithmétique ou logique (ex. 𝑀 = (𝑥2 + 1)/2).
NB : Faire attention à la concordance des types de variables pendant l’affectation. Supposons que 𝑥 est
de type 𝑟é𝑒𝑙 et que 𝑛 est de type 𝑒𝑛𝑡𝑖𝑒𝑟. L’affectation 𝑥 = 𝑛 est valide alors que 𝑛 = 𝑥 ne l’est
pas.

11
3-Lecture
 C’est une opération qui consiste à attribuer une valeur de l’extérieur, par une unité d’entrée (ex.
clavier, capteur de grandeurs physique, etc.), à une variable ;
Notation : 𝐿𝐼𝑅𝐸(𝑥) ou 𝐿𝐼𝑅𝐸(𝑥, 𝑦, … ).
 A la différence de l’affectation qui se passe au niveau de la mémoire (interne), la lecture utilise un
périphérique d’entrée (externe) ;
4- Ecriture
 Son rôle est de faire sortir l’information à l’extérieur par un périphérique de sortie (ex. imprimante,
écran, fichier, etc.) ;
 Cette information peut être numérique, chaîne de caractères, ...
Notation : 𝐸𝐶𝑅𝐼𝑅𝐸(𝑖𝑛𝑓𝑜𝑟𝑚𝑎𝑡𝑖𝑜𝑛1, 𝑖𝑛𝑓𝑜𝑟𝑚𝑎𝑡𝑖𝑜𝑛2, … ).
- 𝐸𝐶𝑅𝐼𝑅𝐸(𝑥) : affiche la valeur de la variable 𝑥 ;
- 𝐸𝐶𝑅𝐼𝑅𝐸(′𝑆𝑎𝑙𝑢𝑡′) : affiche ou écrit le message : 𝑆𝑎𝑙𝑢𝑡 (le texte doit être toujours entre deux
apostrophes).
Exemple : si la variable 𝑥 est de type 𝑒𝑛𝑡𝑖𝑒𝑟 et qu’elle contient la valeur 13, alors l’instruction
𝐸𝐶𝑅𝐼𝑅𝐸(′𝑥 = ′, 𝑥) a pour effet d’afficher 𝑥 = 13.
IV- Instructions de contrôle
12
Dans la programmation classique (structurée), on distingue trois structures :

- La séquence;
- La sélection;
- La répétition.
1- La séquence
On dit aussi instruction composée : c’est une suite d’instructions (arithmétiques ou autres), délimitée
par les mots-clés, DEBUT et FIN, qui s’exécutent séquentiellement (c.à.d., l’une après l’autre).
Exemple : L’algorithme suivant lit les variables 𝑥 et 𝑦, en fait la somme 𝑧 et affiche le résultat :
𝑥 , 𝑦 , 𝑧 ∶ 𝑒𝑛𝑡𝑖𝑒𝑟 ;
𝑫𝑬𝑩𝑼𝑻
𝑙𝑖𝑟𝑒 𝑥 ;
𝑙𝑖𝑟𝑒 𝑦 ;
𝑧 ← 𝑥 + 𝑦;
é𝑐𝑟𝑖𝑟𝑒 ′𝑧 =′ , 𝑧 ;
𝑭𝑰𝑵

13
2- La sélection
 Elle comporte les instructions conditionnelles : c’est à dire qu’une instruction (simple ou composée)
ne sera exécutée qu’après remplissage (satisfaction) de certaines conditions ;
 Dans ce qui suit <condition> a comme type les booléens {𝒗𝒓𝒂𝒊, 𝒇𝒂𝒖𝒙}; c’est une expression
construite à partir des variables booléennes et des connecteurs (opérateurs) logiques « et »,
« ou », « non ».
SI <condition> ALORS
Forme 1 : instructions
FSI
 Si la condition <condition> est vraie, alors exécuter les instructions; sinon on ne fait rien. On passe
à l’exécution de l’instruction suivante (qui est juste après FSI).
𝑥: entier ;
DEBUT
Exemple : lire(𝑥);
SI (𝑥 ≥ 0) ALORS
écrire(‘la valeur de x est positive’ );
FSI
FIN

14
SI <condition> ALORS
Forme 2 : instructions 1
SINON
Instructions 2
FSI
Si la condition <condition> est vraie, alors exécuter les instructions 1; sinon exécuter les instructions 2 ;
Exemple : L’algorithme suivant compare les variables 𝑥 et 𝑦. La variable 𝑧 contient la différence 𝑥 − 𝑦
si 𝑥 est supérieure ou égale à 𝑦, sinon 𝑧 contient 𝑦 − 𝑥. Ensuite affiche la valeur absolue de
𝑥 − 𝑦.
𝑥, 𝑦, 𝑧 : entier ;
DEBUT
lire(𝑥, 𝑦) ;
SI (𝑥 ≥ 𝑦) ALORS
𝑧 = 𝑥– 𝑦;
SINON
𝑧 = 𝑦– 𝑥 ;
FSI
écrire(‘la valeur absolue de x-y est : ‘, 𝑧) ;
FIN

15
Remarque :
- L’instruction après ALORS ou SINON est quelconque et peut être une instruction SI. Dans ce cas, on
dit qu’on a des SI imbriqués.
Exemple : l’instruction ci-dessous affecte à la variable réelle x sa moitié si a et b sont nulles. si a ≠ 0, x

est doublée.
SI (a = 0) ALORS
SI (b = 0) ALORS
x = x/2 ;
FSI
SINON
x = 2*x ;
FSI

16
3- La répétition
 Permet de répéter (ré-exécuter) une ou plusieurs instructions (quelconques) tant qu’une condition
est vérifiée ;
 Elle est réalisée par des boucles de trois formes.
TANT QUE <condition> FAIRE

Forme1 : instructions
FTANT QUE
 On évalue d’abord la condition < condition> ; si elle est vraie on exécute les instructions
«instructions » et on retourne pour réévaluer la condition. Dès que la condition est fausse on
exécute l’instruction qui suit la boucle TANT QUE ... FAIRE…

17
Exemple :
𝑥, 𝑠, 𝑛 :entier ;
DEBUT
lire (𝑛) ;
𝑥 = 0; 𝑠 = 0;
TANT QUE (𝑥 < 𝑛) FAIRE
𝑥 = 𝑥 + 1;
𝑠 = 𝑠 + 𝑥;
FTANT
écrire(𝑠) ;
FIN
 L’algorithme ci-dessus calcule la somme des entiers de 1 à n. On observe qu’il faut initialiser les
variables x et s à 0 ( au début du programme les variables contiennent des valeurs quelconques) ;
 La variable x servant de compteur, alors que la variable s contiendra à la fin du programme la

somme cherchée.
Remarque :
La condition peut ne pas être remplie dès le départ. Dans ce cas aucune instruction, à l’intérieur de la
boucle, ne sera exécutée.

18
Exemple : Dans l’algorithme suivant la boucle n’a pas d’effet sur la variable entière y vu que la condition
de la boucle est toujours fausse. Donc 𝑦 gardera à la fin la valeur 0.
NB : Il faut faire attention aux boucles ouvertes :

condition d’arrêt toujours vraie !
Exemple :
L’instruction "écrire(𝑦)" ne sera jamais exécutée.

19
Exemple : Ecrire un algorithme permet de lire des valeurs entières strictement positives à partir du
clavier et d’en afficher la somme et la moyenne. La condition d’arrêt étant la saisie d’une valeur
négative.
cpt,x,s : entiers ;
DEBUT
s=0;
cpt=0;
Ecrire ('Donner un entire >0 :’);
Lire(x);
TANT QUE (x>0) FAIRE
s=s+x;
cpt= cpt+1;
Ecrire ('Donner un entire >0 :’);
Lire(x);
FINTQ
Ecrire ('Somme=',s,);
Si (cpt>0) ALORS
Ecrire ('Moyenne=',s/cpt);
SINON
Ecrire ('Moyenne indéfinie');
FSI
FIN

20
Forme2 :
 On répète le traitement (instructions) jusqu’à ce que la condition <condittion> soit vraie.
Exemple : Une autre version pour calculer la somme des entiers de 1 à 𝑛.
- A la différence de la première forme, les instructions dans la 2ème

forme seront exécutées au moins une seule fois, même si la condition
d’arrêt est vérifiée dès le départ.
- Faire attention à l’ordre des instructions :
(𝑖 = 𝑖 + 1; 𝑠 = 𝑠 + 𝑖;) est différente de (𝑠 = 𝑠 + 𝑖; 𝑖 = 𝑖 + 1;). la
première séquence donne comme résultat 𝑠 = 1 + 2 + ⋯ + 𝑛 et la
2ème calcule 1 + 2 + ⋯ + 𝑛 − 1.
Exercice : Réécrire l’algorithme de l’exemple précédent, en utilisant REPETER à la place de TANT QUE.

21
Forme3 :
 On exécute les instructions spécifiées (N-M+1) fois, la variable i sert de compteur.
 On utilise cette forme lorsqu’on connaît le nombre de fois qu’on exécutera les instructions en
question.
Exemple : La version suivante, calculant la somme des entiers

de 1 à n, est meilleure que les précédentes vu qu‘on
connaît à priori le nombre d’étapes de l’exécution de
l’itération.

22
Remarque :
L’exemple de la somme des entiers de 1 à 𝑛 ayant servi pour illustration. Bien entendu l’algorithme
suivant fait le même travail :

IV- Tableaux
23
Problématique : lire 100 notes et calculer leur moyenne ??
- déclaration de 100 variables 𝑁1, 𝑁2, … , 𝑁100 ?!!!!!
- Lecture de 100 variables !!!!!
- 𝑀𝑜𝑦𝑒𝑛𝑛𝑒 = (𝑁1 + 𝑁2 + ⋯ + 𝑁100)/100 ?!!!!
Solution : utilisation d’une seule variable complexe (composée) au lieu de 100 variables scalaires 
tableau
 Un tableau est un ensemble d'éléments de même type avec un seul nom de variable, et dont la
taille est fixe. Les éléments du tableau sont stockés dans des cases successives dans la mémoire.
 Chaque élément est accessible par son indice (ou par ses indices) :
Indice 1 2 3 100
Valeur 12.25 14 16.5 …. … 08.25
 Les indices commencent par 𝟎 dans certains langages (C, C++, Java, etc.) et le dernier indice dans ce
cas, est 99.
 Un tableau peut avoir une ou plusieurs dimensions.

IV- Tableaux
24
1- Tableau unidimensionnel
Déclaration :
𝑽𝒂𝒓𝒊𝒂𝒃𝒍𝒆 𝑻 ∶ 𝑻𝒚𝒑𝒆 𝑵 ; ou 𝑽𝒂𝒓 𝑻: 𝑻𝒂𝒃𝒍𝒆𝒂𝒖 𝟏. . 𝑵 𝒅𝒆 𝑻𝒚𝒑𝒆 ; ou
𝑽𝒂𝒓 𝑻: 𝑻𝒂𝒃𝒍𝒆𝒂𝒖,𝑴. . 𝑵- 𝒅𝒆 𝑻𝒚𝒑𝒆 ; (𝑀 et 𝑁 sont les bornes de l’intervalle d’entiers 𝑀, 𝑁 )
 Type : le type commun des éléments du tableau T. Il peut être scalaire ou non.
 N : la taille (nb d’éléments) du tableau T. Pour le cas Var T: Type[M..N], le nb d’éléments est (M-
N+1)
 T[1]: le 1er élément du tableau T (pour certains langage c’est T[0]).
 T[i] correspond à l’élément d’indice i. Var
i: entiers;
Moy : reel;
Notes:réel[1..10];
DEBUT
Exemple : Moyenne de 10 notes Moy=0;
Pour i=1 à 10 faire
Ecrire ('Donner l’element :', i);
Lire(T[i]);
Moy=Moy+T[i]/10;
FinPour
Ecrire ('La Moyenne est :', Moy);
FIN
IV- Tableaux
25
2- Tableau à 2 dimensions
Déclaration :
𝑽𝒂𝒓 𝑻 ∶ 𝑻𝒚𝒑𝒆 𝟏. . 𝑴, 𝟏. . 𝑵 ou 𝑽𝒂𝒓 𝑻 ∶ 𝑻𝒚𝒑𝒆 𝑴 ,𝑵- ;
 M et N sont respectivement le nombre de lignes et le nombre de colonnes du tableau T.
 T[i,j] ou T[i][j]: l’élément qui se trouve à la 𝑖è𝑚𝑒 ligne et à la 𝑗ème colonne du tableau T .
Var
i,tr : Entier;
Notes : Entier[4,4];
DEBUT
tr=0;
Pour i=1 à 4 faire
 Exemple: Trace d’une matrice Pour j=1 à 4 faire
Ecrire ('Donner l’element : (', i,',',j,')');
Lire(T[i,j]);
Si (i=j) Alors
tr=tr+T[i,i];
FinSi
FinPour
FinPour
Ecrire ('La trace de la matrice est :', tr);
FIN

IV- Tableaux
26
3- Tableau à plusieurs dimensions

Déclaration :
𝑽𝒂𝒓 𝑻 ∶ 𝑻𝒚𝒑𝒆 𝟏. . 𝑴, 𝟏. . 𝑵, … , 𝟏. . 𝑷 𝑜𝑢 𝑽𝒂𝒓 𝑻 ∶ 𝑻𝒚𝒑𝒆 𝑴- 𝑵 … ,𝑷 ;
 M, N,…,P : les tailles des différentes dimensions du tableau T.
 T[i,j,…,r] ou T[i][j]…[r]: l’élément qui se trouve à la 𝒊è𝑚𝑒 position de la première
dimension, à la 𝒋ème position de la deuxième dimension, … et à la 𝒓ième position de la dernière
dimension du tableau T .
Remarque :
T[1,1]
Les éléments d’un tableau multidimensionnel sont stockés dimension après T[1,2]
dimension en fonction de l’ordre des boucles (imbriquées) de lecture du tableau. T[1,3]
Exemple 1 : T[2,1]
Pour i=1 à 4 faire T[2,2]
Pour j=1 à 3 faire …
Ecrire ('Donner l’element : (', i,',',j,')');
T[4,1]
Lire(T[i,j]);
FinPour T[4,2]
FinPour T[4,3]

IV- Tableaux
27
3- Tableau à plusieurs dimensions

 Les éléments du tableau à 2 dimensions (matrice) sont stockés ligne par ligne.
 Si les boucles sont inversées, les éléments du tableau seront stockés colonne par colonne
Exemple 2 :
T[1,1]
Pour j=1 à 3 faire T[2,1]

Pour i=1 à 4 faire T[3,1]
Ecrire ('Donner l’element : (', i,',',j,')'); T[4,1]
Lire(T[i,j]);
T[1,2]
FinPour
FinPour T[2,2]
T[3,2]
T[4,2]
T[1,3]
T[2,3]
T[3,3]
T[4,3]

V- Fonctions et procédures
28
Problématique :
 Un algorithme très important/complexe ⟹
- vision difficile sur son fonctionnement ;

- détection fastidieuse des erreurs ;
- Maintenance (mise à jour) difficile.
 Réutilisabilité :
- un même traitement peut être répété plusieurs fois dans un d’un même algorithme.
Solution :
 Séparer ce traitement (répété) du corps de l’algorithme et regrouper ses instructions dans un
module (sous-algorithme) isolé et en un seul exemplaire.
 Ce module peut avoir ou non des paramètres/arguments (formels) d’entrée et une valeur de retour.
 Un module peut à être appelé plusieurs fois et à des endroits différents d’un même algorithme ou
dans d’autres modules, en spécifiant éventuellement les paramètres effectifs lors de chaque appel.
 Procédure : module avec d’éventuels paramètres réalisant un traitement sans rien retourner.
 Fonction : module avec d’éventuels paramètres réalisant un traitement et retournant une seule
valeur.

29
Syntaxe (Fonction) :
FONCTION <nom_fonction> (<paramètres avec leurs types> ) : <type de résultat>

<déclaration des objets locaux à la fonction>
DEBUT
instructions (corps de la fonction)
RETOURNER(résultat)
FIN
Exemple :
FONCTION SurfaceRectangle(long,larg : Entier) : Entier
DEBUT
RETOURNER(long*larg);
FIN
ALGORITHME geometrie;
Var a,b,s : Entier;
DEBUT
Lire(a,b);
s= SurfaceRectangle(a,b);
Ecrire('La surface est : ',s);
FIN

30
Syntaxe (Procédure) :
PROCEDURE <nom_fonction> (<paramètres avec leurs types>)

<déclaration des objets locaux à la procédure>
DEBUT
instructions (corps de la procédure)
FIN
Exemple PROCEDURE Permuter (a,b:Entier)

Var temp: Entier;
DEBUT
temp=a;
a=b;
b=temp;
FIN
ALGORITHME geometrie;
Var m,n : Entier;
DEBUT
m=3; n=7;
Permuter(m,n);
FIN
31
Modes de passage des paramètres :

Les arguments d’un module (fonction ou procédure) peuvent être passés selon 2 modes : par valeur ou
par adresse.
 Passage par valeur : On copie les valeurs des paramètres effectifs dans les paramètres formels. i.e.,
le contenu des paramètres effectifs ne peut pas être modifié par les instructions de la fonction ou
de la procédure, car elles travaillent juste sur des copies.
 Passage par adresse : les paramètres formels se substituent aux paramètres effectifs et le contenu
des paramètres effectifs peut être modifié par les instructions de la fonction ou de la procédure.
Pour ce faire, on fait précéder le paramètre en question par le mot clé Var.
Exemple :
PROCEDURE PermuterVal(a,b:Entier) PROCEDURE PermuterAdr(Var a,b:Entier)

Var temp: Entier; Var temp: Entier;
DEBUT DEBUT
temp=a; temp=a;
a=b; a=b;
b=temp; b=temp;
FIN FIN
a et b sont passés par valeurs a et b sont passés par adresses

32
Modes de passage des paramètres :
Algorithme Essai;
Var x,y: Entier;
DEBUT
x=10 ;
y=20 ;
PermuterVal(x,y);
Ecrire('x=',x,’ et y= ',y); Affichera x=10 et y=20
PermuterAdr(x,y);
Ecrire('x=',x,' et y= ',y); Affichera x=20 et y=10
FIN

VI- Organigrammes
33
 Un organigramme est une représentation graphique d’un algorithme. Il permet de donner, à priori,
une idée claire sur l’enchaînement, la logique et le déroulement d’un algorithme.
Formalisme :
- L’ellipse représente le DEBUT et la FIN d’un algorithme :
- Une opération ou un traitement est représenté par un rectangle :
- Une condition est mise dans un losange :
- La flèche désigne le sens de l’exécution de l’algorithme :
Ainsi les trois structures peuvent être représentées comme suit :

VI- Organigrammes
34
1- La séquence
2- La sélection
Forme 1 : Forme 2 :
VRAI
FAUX

VI- Organigrammes
35
3- La répétition
Forme 1 :
Forme 3 :
Forme 2 :

VII- Complexité des algorithmes
36
 La complexité est une notion qui permet d’évaluer les ressources nécessaires à l’exécution d’un
algorithme.
 La complexité s’intéresse essentiellement à l’espace mémoire et au temps d’exécution requis par

l’algorithme.
 La complexité d’un algorithme (spatiale et/ou temporelle) dépend de la taille des données
manipulées par l’algorithme.
 La complexité ne donne pas des valeurs exactes de ces 2 ressources mais juste des ordres de
grandeurs : les valeurs de ces dernières dépendent aussi, des paramètres matériels de la machine.
 La complexité permet de choisir, parmi plusieurs algorithmes résolvant le même problème,

celui le plus efficace.
 On s’intéressera, ici, à une machine monoprocesseur, où les instructions sont exécutées

séquentiellement (une instruction par un cycle d’horloge). Pour les machines parallèles
(multiprocesseurs), certaines instructions du programme, peuvent être exécutées simultanément
(en parallèle).

37
1. Complexité spatiale
 C’est la quantité de mémoire dont un programme a besoin pour s'exécuter jusqu'à la fin. Elle est la
somme des éléments suivants :
- Une partie fixe qui comprend un espace pour le code, un espace pour les variables simples et les
variables composées de tailles fixes, un espace pour les constantes, etc.
- Une partie variable qui se compose de l'espace nécessaire pour les variables composées dont la
taille dépend du problème à résoudre et l'espace de pile, utilisé par les fonctions récursives.
2. Complexité temporelle
 La complexité temporelle d'un programme est le temps qu’il lui faut pour s'exécuter jusqu'à son
terme. Elle est de deux types : Temps de compilation et Temps d'exécution.
 Pendant le temps de compilation, on ne calcule pas les instructions exécutables, mais on calcule
uniquement les instructions de déclaration et on vérifie les éventuelles erreurs de syntaxe et de
sémantique.
 Le temps d'exécution dépend de la taille des instructions exécutables. i.e., du nombre de ses
instructions, et de la taille de ses données d’entrée. Il est calculé pour les instructions exécutables
et non pour les instructions de déclaration.
 Si l’on fixe l’espace mémoire et considère uniquement le temps d’exécution, on distinguera 3 types
de complexités temporelles: meilleurs cas, pire cas et moyenne.
38
2. Complexité temporelle
 Dans certains cas, les algorithmes ne dépendent pas seulement de la taille des données, mais aussi
des données elles-mêmes. On peut distinguer alors 3 types de complexités temporelles :
– complexité dans le pire des cas (la plus utilisée): c’est un majorant du temps d’exécution possible
pour toutes les données d’entrées possibles d’une même taille. Elle est exprimée l’aide de la
notation O (grand O).
– complexité dans le meilleur des cas (rarement utilisée): c’est un minorant du temps d’exécution
pour toutes les entrées possibles d’une même taille. Elle est exprimée l’aide de la notation Ω .
– complexité en moyenne : c’est le temps d’exécution moyen pour toutes les entrées possibles (de
même taille et équiprobables).
Exemples :
Considérons un algorithme de recherche séquentielle d’un élément dans un tableau à 𝒏 éléments :
– si l’élément se trouve à la 1ère position du tableau (meilleurs cas), on aura une seule comparaison
 complexité= Ω(1).
– si l’élément recherché ne se trouve pas dans le tableau (pire cas), on aura fait 𝒏 comparaisons
 complexité= 𝑂(𝑛).
39
 Pire cas "Grand O" : 𝑓 𝑛 =𝑶 𝑔 𝑛 ⇔ ∋ 𝐴 > 0/ 𝑓 𝑛 ≤ 𝐴𝑔(𝑛)

 Meilleurs cas "Ω" : 𝑓 𝑛 = 𝜴 𝑔 𝑛 ⇔ ∋ 𝐴 > 0 / 𝑓 𝑛 ≥ 𝐴𝑔 𝑛
Complexité Nom
𝑂(1) Constante
𝑂(ln(𝑛)) Logarithmique
𝑂(𝑛) Linéaire
𝑂(𝑛𝑙𝑛(𝑛)) Quasi-linéaire
𝑂(𝑛2 ) Quadratique
𝑂 𝑛𝑘 , 𝑘 > 2) Polynomiale
𝑂 𝑘 𝑛 , 𝑘 > 1) Exponentielle

40
Quelques ordres de grandeur de la complexité temporelle :
Taille 𝐥𝐧(𝒏) 𝒏 𝒏𝒍𝒏(𝒏) 𝒏𝟐 𝒏𝟑 𝟐𝒏

(n)
102 7 𝑛𝑠 100 𝑛𝑠 0,7 𝜇𝑠 10 𝜇𝑠 1 𝑚𝑠 4.106 années !!
103 10 𝑛𝑠 1 𝜇𝑠 10 𝜇𝑠 1 𝑚𝑠 1𝑠 10292 Années !!!
104 13 𝑛𝑠 10 𝜇𝑠 133 𝜇𝑠 100 𝑚𝑠 17 𝑠
105 17 𝑛𝑠 100 𝜇𝑠 2 𝑚𝑠 10 𝑠 11,6 𝑗𝑜𝑢𝑟𝑠
106 20 𝑛𝑠 1 𝑚𝑠 20 𝑚𝑠 17 𝑚𝑠 32 𝑎𝑛𝑛é𝑒𝑠

41
Exemple 1 :
Instruction 1; Si toutes les instructions (en nombre fini) sont élémentaires

… (lecture, écriture, affectation, etc.), alors sa complexité sera :
Instruction k ;
𝑶 𝟏 + 𝑶 𝟏 + ⋯ + 𝑶(𝟏) ≤ 𝜶𝟏 + 𝜶𝟐 + ⋯ + 𝜶𝒌 = 𝑶(𝟏)
Exemple 2 :
Si (condition)Alors
Instructions 1; sa complexité sera :
Sinon 𝑴𝒂𝒙 (𝒄𝒐𝒎𝒑𝒍𝒆𝒙𝒊𝒕é(𝑰𝒏𝒔𝒕𝒓𝒖𝒄𝒕𝒊𝒐𝒏𝒔 𝟏), 𝑪𝒐𝒎𝒑𝒍𝒆𝒙𝒊𝒕é (𝑰𝒏𝒔𝒕𝒓𝒖𝒄𝒕𝒊𝒐𝒏𝒔 𝟐))
Instructions 2 ;
FinSi
Exemple 3 :
Pour i=1 à n faire Si Instructions (en nombre fini) sont élémentaires (lecture,
Instructions ; écriture, affectation, etc.), alors sa complexité sera :
FinPour 𝒏. 𝑶 𝟏 = 𝑶(𝒏)

42
Exemple 4 :
Pour i=1 à n faire Si Instructions (en nombre fini) sont élémentaires (lecture,
Pour j=1 à m faire écriture, affectation, etc.), alors sa complexité sera :
Instructions ;
FinPour
𝒏. 𝒎. 𝑶 𝟏 = 𝑶(𝒏𝒎)
FinPour Cas particulier : si n=m alors on aura une complexité de 𝑶(𝒏𝟐 )
Exemple 5 : Les 2 portions d’algorithme ci-dessous, calculent tous les deux le nombre de diviseurs d’un
entier 𝑛, mais de complexités différentes.
d = 0 ;
d = 0 ; k = 1 ;
k = 1 ; TANT QUE (k∗k < n) FAIRE
TANT QUE(k <= n)FAIRE SI (n mod k = 0) ALORS
SI(n mod k)=0 ALORS d = d + 2 ;
d=d+ 1 ; 𝑶(𝒏) 𝑶( 𝒏)
FINSI
FINSI k = k + 1 ;
k=k+ 1 ; FINTQ
FINTQ SI (k∗k= n) ALORS
d = d + 1 ;
FINSI

43
Opérations basiques (élémentaires) ayant une complexité constante :

– opérations arithmétiques : addition, soustraction, multiplication, division, modulo,partie entière, …
– comparaisons de données (relation d’égalité, d’infériorité, . . .)
– transferts de données (lecture et écriture dans un emplacement mémoire)
– instructions de contrôle (branchement conditionnel et inconditionnel, appel d’une fonction, …)
Remarque :
L’appel d’une fonction est une instruction basique (élémentaire), mais la fonction appelée a une
complexité qu’il faut tenir en compte.

Chapitre 2
44
Présentation du langage C++ et de

l’environnement de développement
intégré

Chap 2 : Présentation du langage C++ et de l’environnement de
développement intégré
I- Introduction
45
 Un langage de programmation est ………………………
 C++ est un langage de programmation développé, au milieu des années 80, par le jeune ingénieur
Bjarne Stroustrup, au sein des laboratoires AT & T de Bell.
 C’est une extension du langage de programmation C précédemment développé par AT & T Labs
au début des années 1970.
 À l'origine, AT & T ont développé le langage de programmation C pour écrire des systèmes
d'exploitation UNIX, des logiciels de niveau système et le développement de systèmes
embarqués.
 Les concepts de la programmation orientée objet (un autre type de la programmation) en abrégé
P.O.O.) ont donné naissance à de nouveaux langages dits "orientés objets" (Smalltalk, Simula,
Eiffel).
 Bjarne Stroustrup, a cherché à ajouter à un langage structuré existant (le C), un certain nombre
de spécificités lui permettant d’appliquer les concepts de P.O.O. : permettre aux programmeurs C
d’effectuer une transition en douceur de la programmation structurée vers la P.O.O.

I- Introduction
46
 Initialement, C++, offrait des fonctionnalités de programmation orientées objet, et plus tard, des
capacités de programmation génériques ont été ajoutées.
 C++ est un langage compilé. c.à.d, que le programme est traduit dans le langage binaire (langage
machine) avant qu’il ne soit exécuté.
 Les fichiers C++ (et un projet typique en contient plusieurs) sont appelés fichiers source. Ces
derniers sont saisis dans éditeur de texte.
 La traduction des fichiers sources dans un programme se déroule en deux phases :
i. Les fichiers sources individuels sont d’abord traduits par le compilateur (programme spécial)
en fichiers objets. Ensuite, un deuxième programme, appelé
ii. Ensuite, l’éditeur de liens (un autre programme), appelé aussi chargeur, combine les fichiers
objets individuels dans un fichier exécutable.
 La compilation, l’édition des liens et l’exécution peuvent être réalisées à l’aide des commandes ou
en utilisant des environnements intégrés (IDE) : CodeBlocks, Dev cpp, etc.
 Dans ce cours, nous étudierons la programmation structurée à l’aide du langage C++. La P.O.O.
sera étudiée en 3ème année.
II- Création et exécution d’un programme C++
47
 Un programme C++ créé et exécuté dans plusieurs systèmes d’exploitation : Unix, Linux,
Windows, Mac OS, etc.
 Un programme C++ est un écrit dans un éditeur de texte disponible pour un SE :
 Un projet C++ peut contenir plusieurs fichiers qui peuvent être compilés séparément et liés pour
générer un seul fichier exécutable.
 Par exemple sous Ubuntu (une distribution LINUX) :
• on peut utiliser un éditeur de texte basique (vi, emacs, etc.) ou plus élaboré (gedit, …)
• pour la compilation, l’édition des liens et l’exécution, on peut utiliser des commandes Linux
dans un Terminal (fenêtre de commandes).
• on peut aussi, utiliser des environnement de développement intégré (IDE comme Codeblocks)
pour écrire les fichiers d’un projet, le compiler et l’exécuter plus facilement (sans utilisation
directe des commandes).

48
 Lancer un terminal sous Linux (Ubuntu par exemple), puis lancer l’éditeur de texte basique vi
installé par défaut, en tapanr la commande vi :
 On peut y écrire maintenant les instructions de notre programme C++. Toutes les opérations
(copier, coller, insérer, retour à la ligne, enregistrer, …) sont faites à l’aide des combinaisons de
touches. "vi" est un éditeur basique et la souris ne peut y être utilisée.
 Enregistrer le fichier saisi en lui donnant un nom et une extension cpp (exemple: ensam1.cpp)
 Le fichier ensam1.cpp sera sauvegardé dans le répertoire courant (sinon spécifier le chemin
complet lors de l’enregistrement)
 Vi était utilisé dans le temps, avant le développement des éditeurs graphiques et conviviaux.
 Actuellement, il es recommandé d’utiliser des éditeurs graphiques plus élaborés comme "gedit" .
49
 L’éditeur gedit est installé par défaut dans plusieurs distributions Linux (comme ubuntu). S’il n’est
pas installé, il suffit de taper, dans un terminal, la commande suivante :
sudo apt install gedit
le mot de passe de l’administrateur (root), sera demandé avant le téléchargement et
l’installation du package.
 Une fois, installé, on peut le lancer en utlisant le lanceur d’application (gfraphique) ou en tapant
daans un terminal la commande : gedit
 Ensuite, on saisit les instructions de notre programme avant de l’enregistrer sous le nom :
ensam1.cpp :
#include <iostream>
using namespace std;
int main (){
cout << "Hello World !\n";
return 0;
}
 Maintenant, il faut compiler notre programme par un compilateur (pour chaque langage, il peut y
en avoir plusieurs). Pour C++, on utilisera le compilateur GNU GCC. S’il n’est pas déjà installé, on
pourra procéder comme suit :
50
1. Taper la commande sudo apt update suivie d'une pression sur la touche Entrée pour
mettre à jour la liste des paquets des dépôts de la distribution Linux.
2. Taper la commande sudo apt install build-essential suivie de la touche
Entrée pour installer les compilateurs GCC, G++, les dépendances requises ainsi que le
gestionnaire de compilation Make.
3. Taper sudo apt install manpages-dev suivie de la touche Entrée pour installer
les pages des manuels de ces outils de compilation, que l’on pourra consulter en cas de
besoin au moyen de la commande man nom_de_l'outil.
4. Se placer dans le répertoire où se trouve le programme (code source). Taper la commande cd
pour naviguer entre les dossiers. Exemple :
cd /home/[nom_d'utilisateur]/Mes_programmes ou bien :
cd ~/Mes_programmes
5. compiler le programme à l’aide de la commande :
g++ [nom_prgme].cpp –o [nom_exécutable].
Exemple: g++ ensam1.cpp –o ensam1
6. Exécuter le fichier exécutable généré en tapant la commande : ./ensam1
III- Environnement de développement intégré (IDE)
51
 IDE (Integrated Development Environment) : un ensemble d’outils permettant, au

programmeur/développeur, d’automatiser certaines tâches et améliorant ainsi sa productivité :
• Un éditeur de texte et de code source ;
• Un compilateur ;
• Un éditeur de liens ;
• Un débogueur ;
• Un créateur d’interface graphique ;
• Un moteur de recherches compatible avec différents langages de programmation ;
• Un modélisateur ;
• Etc.
 Pour créer des projets, on peut s’en passer des IDEs, en faisant tout à la main, en utilisant des
commandes basiques qui seront exécutées par le système d’exploitation (SE). Ce qui sera une
tâche fastidieuse !
 Les outils de l’IDE (en général graphiques) ne font que traduire les actions, réalisées par le
programmeur, en des commandes basiques avant de les passer au SE.

III- Environnements de développement intégrés (IDE)
52
 Exemples d’IDEs pour créer des projets C++ :
• Visual Studio
• Code:: Blocks
• CLion
• Eclipse CDT
• CodeLite
• Apache NetBeans
• Dev C++
• …
 Certains IDEs peuvent être disponibles sur plusieurs SE. Exple : Codeblocks propose 3 versions
(Linux, Windows et MAC).
 Certains IDEs permettent de choisir entre plusieurs langage de programmation. Exple :
Codeblocks : C, C++ et Fortran.
A. AHMADI F Algorithmique et Programmation en C++
IV- CodeBlocks
53
 Lien de téléchargement (gratuit) : https://www.codeblocks.org/downloads/
1 2
 Installer CodeBlocks en cliquant 2 fois sur le fichier téléchargé.

IV- CodeBlocks
54
Cette version téléchargée contient un compilateur C++ par défaut qui est le "GNU GCC compiler". S’il
n’est pas détecté automatiquement, allez dans le menu Settings, puis Compiler :
Sélectionnez le compilateur "GNU GCC Compiler". Puis , cliquez sur l’onglet "Toolchain executables"
et enfin sur le bouton "Auto-detect".

Chapitre 3
55
Eléments de base du
langage C++

Chap 3 : Eléments de base du langage C++
I- Premier programme C++
56
Exécution :

57
 #include <iostream> et #include <cmath> directives exécutées par le
préprocesseur avant la compilation du programme.
 #include <iostream> : introduit,en particulier, les déclarations nécessaires à l’utilisation
des fonctions cin (lecture)et cout (écriture).
 #include <cmath> : introduit les déclarations nécessaires à l’utilisation des fonctions
mathématiques prédéfinies (log,exp,sqrt, …).
 Un espace de noms permet de regrouper plusieurs déclarations de variables, fonctions et classes
dans un groupe nommé.
 Un même nom (de variable, de fonction, …) peut être utilisé dans plusieurs espaces de noms.
 On peut faire appel, par exemple, à une fonction test()définie dans l’espace de nom
monEspace comme suit : monEspace::test(); ou bien :
using namespace monEspace ;
test();
 using namespace std : permet de se placer dans l’espace de nom
std (contenant entre les focntions cin et cout).

58
 main() {…} : programme principal considéré aussi comme fonction. L’exécution de tout
projet C++ commence par cette fonction principale.
 On peut définir de nouvelles fonctions au sein de main et/ou appeler d’autres fonctions
appartenant à des bibliothèques.
 Const int Nb=6 : permet de déclarer la constante Nb avec comme valeur 6. Lors de
l’exécution, chaque occurrence de cette constante sera remplacée par sa valeur (6).
Contrairement à une variable, une constante ne peut changer de valeur au cours d’une
exécution.
 int x, cpt=0 : permet de déclarer 2 variables x et cpt de type entier et d’initialiser en
plus la variable cpt par 0.
 Les 2 slash "//" : permettent d’écrire un commentaire. Ce dernier ne sera pas interprété par le
compilateur.
 Un commentaire sert à expliquer le rôle d’un bloc d’instructions ou à désactiver provisoirement
une partie du code.
 cout et cin permettent, respectivement, d’écrire et d’afficher des informations sur les flots de
sortie et d’entrée.

II- Types de base
59
 Un programme est composé de deux éléments : les données et les opérations sur ces données,
i.e., un programme reçoit, à son entrée, des données et les traite avant de fournir des résultats
(autres données) à sa sortie.
 Chaque donnée a un type (entier, flottant, caractère, …), et est stockée dans la RAM, sous forme
de séquences binaires.
 Un type de données indique le domaine des valeurs qu'une variable ou expression peut prendre
et les opérations qu'on peut lui appliquer.
 Le type permet de :
- définir la représentation interne d’une donnée dans la mémoire ;
- connaître l’espace mémoire (nb d’octets) nécessaire au stockage de cette donnée.
 Par exemple le nombre entier -350 peut être stocké sur 2 ou 4 octets. Lors de l'accès à la
mémoire, il est important :
- de lire le bon nombre d'octets.
- que la séquence de bits en cours de lecture, soit interprétée correctement comme un entier
signé.

II- Types de base
60
 Le compilateur ou l’interpréteur a aussi besoin de connaître les types de données pour définir les
opérations qu’il peut réaliser sur ces dernières.
Exple : l’addition de 2 entiers et celle de 2 flottants ne sont pas réalisées (implémentées) en
langage machine, de la même manière.
 Les types de base du langage C++ peuvent se grouper en 4 catégories :
⁻ nombres entiers (mot-clé int)
⁻ nombres flottants (mot-clé float ou double) ;
⁻ caractères (mot-clé char) ;
⁻ valeurs booléennes, i.e., la valeur est soit vrai, soit faux (mot-clé bool).
 Le compilateur C++ reconnaît les types fondamentaux (intégrés), ci-dessus, sur lesquels sont
basés tous les autres types (vecteurs, structures, pointeurs, classes, ...).

II- Types de base
61
1- Type bool
 En C++, une variable déclarée du type bool ne peut prendre que l’une des 2 valeurs true ou
false.
 En C++, la valeur interne de true est représentée par l’entier 1 et celle de false par 0.
 Le résultat d’une comparaison ou d’une condition faisant intervenir les opérateurs logiques (OU,
ET, NON) est une valeur booléenne. i.e., sa valeur est soit true (vrai), soit false (FAUX).
 Une condition peut être une expression arithmétique ou logique. Si la valeur d’une expression
arithmétique (dans une condition) est différente de 0; alors la condition est vrai (sa valeur=true),
sinon elle est fausse.
Exemples :
Exécution :

II- Types de base
62
2- Types char et wchar_t

 Un code entier est associé à chaque caractère manipulé en informatique (lettres Maj et Min,
chiffres, caractères spéciaux, caractères de contrôle, …) selon un code donné (ASCII, EBCDIC,
etc.). Exple 'A' <--> 65 ; '!' <--> 33
 Le type char code un caractère sur 1 octet : maximum 256 caractères ⟹ insuffisant !!!
 Le type wchar_t (wide character type) comprend au moins 2 octets (16 bits) et est donc
capable de stocker des caractères Unicode modernes.
 Unicode est un code 16 bits contient des codes pour environ 35 000 caractères dans 24
langues.
 Certains caractères (non imprimables) sont représentés conventionnellement à l’aide de
l’antislash "\".

II- Types de base
63
2- Types char et wchar_t
Notation C++ Code ACII Signification
(base 10)
\a 7 Bip sonore (Bell)
\b 8 Retour arrière (Backspace)
\f 12 Saut de page (Form feed)
\n 10 Saut de ligne (Line feed)
\r 13 Retour chariot (Carriage return)
\t 9 Tabulation horizontale (Horizontal tab)
\v 11 Tabulation verticale (Vertical tab)
\\ 92
\' 44
\" 34
\? 63
 Il est aussi possible d’utiliser un caractère en faisant appel à son code et à "\".
 'A' ⟺ '\x41' ⟺ '\101' ; '\r' ⟺'\x0d' ⟺ ’\15’ ⟺’\015’; ’\a’ ⟺ ’\x07’ ⟺ ’\x7’ ⟺ ’\07’ ⟺’\007’
A
II- Types de base
64
3- Types entiers
Type Taille Intervalle de valeurs
char 1 octet -128 à +127 ou 0 à 255
unsigned char 1 octet 0 à 255
signed char 1 octet -128 à +127
int ≥2
2 octets -32768 à +32767
4 octets -2147483648 à +2147483647
unsigned int ≥2
2 octets 0 à 65535
4 octets 0 à 4294967295
≥2
short 2 octets -32768 à +32767
unsigned short 2 octets 0 à 65535
≥4
long 4 octets -2147483648 à +2147483647
unsigned long 4 octets 0 à 4294967295
long long ≥8
8 octets -9223372036854775808 à 9223372036854775807
Remarque : En C++ (ANSI), la taille des types entiers n’est pas prédéfinie. Toutefois, on a :
𝑡𝑎𝑖𝑙𝑙𝑒 (𝑠𝑕𝑜𝑟𝑡) ≥ 2, 𝑡𝑎𝑖𝑙𝑙𝑒 (𝑙𝑜𝑛𝑔) ≥ 4 et : taille(𝑐𝑕𝑎𝑟) ≤ taille(𝑐𝑜𝑢𝑟𝑡) ≤ taille(𝑖𝑛𝑡) ≤ taille(𝑙𝑜𝑛𝑔)
II- Types de base
65
3- Types entiers
Programme de vérification :
Exécution :

II- Types de base
66
4- Types à virgule flottante
 Les types flottants permettent de représenter, de manière approchée, une partie de
l’ensemble IR.
 Un nombre réel est représenté en flottant sous forme : 𝑴. 𝑩𝑬 , avec M : mantisse, B : base
(2, 10, en 16) et E: exposant (entier). On peut utiliser la notation décimale ou
exponentielle.
 En C++, il y a 3 types de flottant : float, double et long double.
 La précision indique le nombre de chiffres significatifs qu’un type peut représenter après
troncature d’un nombre décimal. On a aura alors une erreur de troncature !
Type longueur Plage de valeurs Plus petite Précision
valeur positive
float ≥4 6 chiffres
4 octets -3.4E+38 à 3.4E+38 0.17549E-38
double ≥8 15 chiffres
4 octets -1.79769E+308 à +1.79769E+308 2.225073E-308
Long double ≥8 19 chiffres

10 octets -1.18E+4932à +1.18E+4932 3.36E-4932

II- Types de base
67
4- Types à virgule flottante

Programme de vérification :
Exécution :

III- Constantes
68
 Les constantes sont des valeurs qui peuvent être :

- booléennes ;
- numériques (entières/flottantes) ;
- caractères ;
- chaînes de caractères.
 Chaque constante représente une valeur et donc, un type en fonction de la manière dont elle a
été écrite.
 Une constante booléenne est représentée par l’un des 2 mots clés : true ou false.
 Une constante entière peut être représentée par un simple nombre décimal, octal ou
hexadécimal :
- une constante décimale (base 10) commence par un nombre décimal différent de zéro
(comme : 312, 54687, etc.).
- une constante octale (base 8) commence par un 0 non significatif (ex. : 045 ; 0958764).
- une constante hexadécimale (base 16) commence par la paire de caractères 0x ou 0X (ex. :
0x3B1 ; 0X7e1C).
 Les constantes entières sont de type int. Si la valeur de la constante est trop grande pour le type
int, un type capable de représenter des valeurs plus grandes sera appliqué.
III- Constantes
69
 Le classement des constantes décimales est le suivant : int, long, unsigned long
 Le type de la constante entière peut être indiqué en ajoutant la lettre L ou l (pour long), U ou
u (pour unsigned int) ou bien UL/ul ( pour unsigned long).
Exemples : 35L ou 35l ; 35U ou 35u ; 35UL ou 35ul.
Remarque : Un type supérieur permet de définir des valeurs très grandes, mais gaspille de l’espace
mémoire.
 Les nombres à virgule flottante sont toujours représentés sous forme de décimales et une virgule
décimale est utilisée pour distinguer la partie fractionnaire de la partie entière. Cependant, la
notation exponentielle est également autorisée.
Exemples : 85.25 3.4E-2 (ou 3.4e-3). Notons que 2.5E2 = 2.5*102.
 Un point décimal ou E (e) doit toujours être utilisé pour distinguer les constantes à virgule
flottantes des constantes entières.
 Les constantes à virgule flottante sont de type double par défaut. Cependant, on peut ajouter F
ou f pour désigner le type flottant, ou ajouter L ou l pour le type long double.

III- Constantes
70
 Une constante caractère est un caractère entouré de quotes simples. Les
constantes de caractères sont de type char.
Exemples : 'a' '!'
 La valeur numérique est le code de caractère représentant le caractère. La constante 'A' a donc
une valeur de 65 en code ASCII.
 Une constante chaîne se compose d'une séquence de caractères entre guillemets
doubles.
Exemple : "Bonjour tout le monde"
 Une constante de chaîne est stockée en interne sans les guillemets mais se termine par un
caractère nul, \0, représenté par un octet avec une valeur numérique de 0.
 Ainsi, une chaîne en occupe donc, un octet de plus en mémoire que le nombre de caractères qu'il
contient.
 Le caractère nul de fin \0 n'est pas le même que le nombre zéro et a un code de caractère
différent de zéro.

IV- Identificateurs
71
 Un identificateur (nom) est utilisé pour désigner une entité (variable, constante, type, structure,
fonction, …). Il doit être choisi en respectant les contraintes suivantes :
i. un nom contient une série de lettres, de chiffres ou de caractères de soulignement ( _ ). Les
caractères spéciaux et les lettres accentuées ne sont pas valides. C++ est sensible à la casse ;
c.à.d, que les lettres majuscules et minuscules sont différentes.
ii. le premier caractère doit être une lettre ou un trait de soulignement.
iii. il n'y a aucune restriction sur la longueur d'un nom et tous les caractères du nom sont
significatifs.
iv. les mots-clés C++ (int,if,for,while,…) sont réservés et ne peuvent pas être utilisés
comme noms.
Exemples de noms valides :
a ; US; us ; VOID ; _var ; val_Max2.
Exemples de noms invalides :

if ; 3emetest ; essai$ ; true ; température ; val-min.

V- Variables
72
 Les données telles que les nombres, les caractères ou les enregistrements complets sont stockées
dans des variables pour permettre leur traitement par un programme.
 Une variable doit être définie avant de pouvoir l'utiliser dans un programme.
 Lorsqu’une une variable est déclarée d’un type, une quantité de mémoire appropriée est
réservée. Cet espace mémoire est adressé par référence au nom de la variable.
Exemples de déclarations : int i,j,n;
char c1;
float x, temp1;
 Une variable peut être déclarée dans une fonction (variable locale) et elle sera reconnue et
utilisée uniquement au sein de cette dernière.
 Si une variable est définie en dehors des fonctions (variable globale), elle sera reconnue et
utilisée dans n’importe quelle fonction.
 Une variable locale est habituellement déclarée au début du corps de la fonction, mais on
peut la déclarer là où il est permis et avant son utilisation pour la 1ère fois.
 Une variable peut être initialisée au moment de sa déclaration : int S=0; float pi(3.14);
 Une variable globale non initialisée prend par défaut la valeur zéro. Contrairement une
variable locale qui prendra, une valeur aléatoire.
VI- Expressions et opérateurs
1- Expression
73
 Une expression en C++ est une collection d'ordres d'opérateurs et d'opérandes qui spécifie un
calcul.
 En C++, toute expression retourne une valeur et un type et peut réaliser une action. Ainsi, les
notions d’instruction et d’expression sont étroitement liées.
 Une expression peut contenir zéro ou plusieurs opérateurs et un ou plusieurs opérandes, les
opérandes peuvent être des constantes ou des variables.
 De plus, une expression peut également contenir des appels de fonctions qui renvoient des
valeurs constantes.
 Le résultat obtenu après l'expression d'évaluation est affecté à la variable à l'aide de l'opérateur
d'affectation.
Exemples d'expressions :
x = y+5 ; a % (2*b); z = 3.14 * 2 ; ok == true ; z=y=x ; j=++i;
Remarques :
- Dans l’instruction z=y=x, on a "y=x" qui est une instruction d’affectation (y reçoit la valeur de
x), mais en plus, elle est considérée comme une expression dont la valeur est celle de y. Donc
z=y=x a bien un sens : z reçoit la valeur de l’expression "y=x".
- De même, "j=++i", signifie que j reçoit la valeur de l’expression "++i" qui sera celle de i
incrémentée de 1.
2- Opérateurs arithmétiques
74
 Les opérateurs arithmétiques sont utilisés pour réaliser des opérations (calculs) sur les données
du programme.
 On distingue 2 types d’opérateurs, unaires et binaires. Un opérateur unaire a un seul opérande,
et un opérateur binaire en a 2.
Opérateur Signification Opérateur Signification
+ addition + et - Opérateurs de signe
- soustraction ++ Opérateur d’incrémentation
* multiplication -- Opérateur de décrémentation
/ division
% Reste (modulo) Opérateurs unaires
Opérateurs binaires
 Une division effectuée avec des opérandes entiers produira un résultat entier (Ex., 25/2 donne
12). Si au moins un des opérandes est un flottant, le résultat sera également un flottant (Ex. par
exemple, la division 25.0/2 produit un résultat exact de 12.5.
 Le reste de la division (modulo) ne s'applique qu'aux opérandes entiers et renvoie un entier (Ex.,
17%3 retournera à 2.

75
 Si les 2 opérandes sont de même type, le résultat de l’opération sera aussi de ce type. Sinon, il y
aura conversion implicite (ajustement/promotion) de l’un des opérandes selon cet ordre :
short-> int -> long -> float -> double -> long double
char -> int
bool -> int
Exemples :
bool b1=true ;
b1+3 ;
int (=4)

76
 Lors d’une affectation, toutes les conversions d’un type numérique vers un autre type numérique
sont acceptées par le compilateur mais le résultat peut ne pas être satisfaisant.
Exemple :
int n; float x; double y;
…
n=x+y;
• il y a d’abord conversion implicite de la valeur de x en double, puis évaluation de l’addition qui aura
comme résultat une valeur double, et enfin cette valeur sera convertie en int (on prendra sa valeur
entière) pour être affectée à la variable n (de type int).
• Si cette valeur est très grande (n’est pas représentable sur int), n prendra une valeur erronée ou une
erreur d’exécution se produira (en fonction de l’environnement utilisé).
 lors d’une affectation, On peut aussi faire une conversion forcée à l’aide de l’opérateur CAST.
Exemple :
double x;
x=(double)20/6 ; // x=3.33… L’opérateur cast a une priorité très élevée. Il faut
donc, mettre son opérande entre parenthèses.
x=(double)(20/6) ; // x=3

77
Opérateurs d’incrémentation et de décrémentation :
 ++ est dit opérateur de pré-incrémentation s’il est placé à gauche et post-incrémentation s’il est
placé à droite de l’opérande.
 -- est dit opérateur de pré-décrémentation s’il est placé à gauche et post-décrémentation s’il est
placé à droite de l’opérande.
• ++i : incrémente de 1 i et la valeur de l’expression (++i) est celle de i après incrémentation.
• i++ : incrémente de 1 i et la valeur de l’expression (i++) est celle de i avant incrémentation.
• --i : décrémente de 1 i et la valeur de l’expression (--i) est celle de i après décrémentation.
• i-- : décrémente de 1 i et la valeur de l’expression (i--) est celle de i avant décrémentation.
Exemples :
y = 4 ;
x = ++y – 2 ; ⇒ x = 3 et y = 5
y = 4 ;
x = y-- - 2 ⇒ x = 2 et y = 3

78
 Priorités des opérateurs arithmétiques :
Priorité Opérateurs Associativité
++ -- (postfix) De gauche à droite
Plus élevée ++ -- (prefix) De droite à gauche
+ - (signe)
* / % De gauche à droite
Plus basse + - (addition et soustraction) De gauche à droite
Exemples :
• A+B*C ⇔ A+(B*C)
• A*B+C%D ⇔ (A*B)+(C%D)
• -A/B ⇔ (-A)/B
• ++i+j-- ⇔ (++i)+j;j=j-1;

3- Opérateurs relationnels
79
 Chaque comparaison en C++ est une expression logique ayant comme valeur true ou false. Elle
utilise l’un des opérateurs relationnels suivants :
Opérateur Signification Priorité a<b==c<d sera interprétée comme :
< inférieur à (a<b)== (c< d)
<= inférieur ou égal à
Priorité élevée
> supérieur à Les opérateurs relationnels sont moins
>= supérieur ou égal à prioritaires que les opérateurs arithmétiques.
Exemple :
== égal à x+y<z+2 ⇔ (x+y)<(z+2)
!= Priorité basse
Différent de
 Les expressions comparées sont toujours des valeurs numériques quelles que soient les types des
variables qu’elles utilisent (short, int, long, float, …, bool, char).
 Pour le type bool : true=1 et false=0. On a bien true>false.
 Pour le type char, on peut comparer 2 caractères en comparant leurs codes. Ces derniers
dépendent du codage utilisé. Mais, on a toujours l’ordre alphabétique qui est respecté pour les
minuscules d’une part, pour les majuscules d’autre part. Les chiffres sont aussi classés par ordre
naturel.

4- Opérateurs logiques
80
 Les opérateurs logiques sont : && (ET), || (Ou) et ! (Non).
 Ils peuvent être utilisés pour créer des conditions composées (expressions) de plusieurs
comparaisons et effectuer l'exécution conditionnelle d'un programme.
 Une expression logique donne une valeur false ou true, selon que l'expression logique est
correcte ou incorrecte, tout comme une expression relationnelle.
• Exemples :
• (5 < 3) && (30 >20) prendra la valeur 0
• (5 < 3) || (30 >20) prendra la valeur 1
• !(5 < 3) prendra la valeur 1
• if (a==0) i++; ⇔ if (!a) i++;

4- Opérateurs logiques
81
Remarque s:
- L’opérateur || est moins prioritaire que l’opérateur &&. Tous les deux sont de priorité inférieure à
celle des opérateurs arithmétiques et relationnels.
- L’opérateur ! a une priorité supérieure à celle de tous les opérateurs arithmétiques binaires et les
opérateurs relationnels.
Exemples :
a<b && c<d ⇔ (a<b)&&(c<d)
a<b || c<d ⇔ (a<b)||(c<d)
NON (a == b) → !(a == b) !a==b
5- Opérateur d’affectation élargie
 i+= k; ⇔ i = i+k ;
 a* = b; ⇔ a = a*b;
Cas général :
Variable = Variable Opérateur Expression ; ⇔ Variable Opérateur = Expression ;
Liste des opérateurs d’affectation élargie :
+= -= *= /= %= |= ^= &= <<= >>=
Opérateurs de manipulation des bits
6- Opérateur Conditionnel
82
 L’opérateur conditionnel permet de simplifier les instructions de sélection.
Exemple 1:
𝑚𝑎𝑥 = 𝑥 > 𝑦 ? 𝑥 ∶ 𝑦 ; ⟺ 𝑖𝑓 (𝑥 > 𝑦) 𝑚𝑎𝑥 = 𝑥 ;
𝑒𝑙𝑠𝑒 𝑚𝑎𝑥 = 𝑦;
- Les 3 expressions : x>y, x et y sont les opérandes de l’opérateur conditionnel.
- L’opérateur conditionnel est matérialisé par deux symboles séparés "?" et ":"
- La priorité de l’opérateur conditionnel est faible (juste après celle de l’affectation).
Exemple 2 (cas ou les parenthèses sont indispensables) :

• 𝑧 = 𝑥 = 𝑦 ?𝑎 ∶ 𝑏 ; ⇔ 𝑥 =𝑦;
𝑖𝑓 𝑥 ! = 0 𝑧 = 𝑎 ;
𝑒𝑙𝑠𝑒 𝑧 = 𝑏;
• 𝑧 = 𝑥 = 𝑦 ?𝑎 ∶ 𝑏 ; ⇔ 𝑧 = 𝑥 = 𝑦 ?𝑎 ∶ 𝑏 ;

7- Opérateur séquentiel
83
 L’opérateur séquentiel permet d’exprimer plusieurs calculs successifs au sein d’une même
expression. La valeur de cette dernière est le résultat du dernier calcul.
Exemple 1:
• i++, j=i+k ; ⇔ i++; j=i+k ;
 L’opérateur séquentiel est utile dans les instructions de sélection et de boucle.
Exemple 2:
• if (i++, >0) a=0 ; ⇔ i++; if (k>0) a=0;
• for (i=0,j=10; i<j ; i++,j--)
…

VII- Entrées-Sorties
84
 En C ++, les entrées/sorties sont effectuées sous la forme d'une séquence d'octets appelée flux.
 Fichiers d'en-tête de bibliothèque d'E/S :
- <iostream> : définit les objets cin,cout, cerr et clog, qui correspondent resp. au flux
d'entrée standard, au flux de sortie standard, au flux d'erreur
standard non mis en mémoire tampon et au flux d'erreur
standard mis en mémoire tampon.
- <iomanip> : déclare des services utiles pour effectuer des E/S formatées avec des
manipulateurs de flux paramétrés, tels que setw et setprecision.
- <fstream> : déclare les services pour le traitement de fichiers contrôlés par l'utilisateur.
1- Le flux de sortie standard - cout :
 cout est utilisée pour produire une sortie sur le périphérique standard de sortie (qui est
généralement l’écran).
 Les données de sortie (à afficher) sont insérées dans le flux se sortie cout à l’aide de l’opérateur
d’insertion << (surdéfini).
 L'opérateur << permet d’afficher les données des types intégrés : char, bool, entier, flottant,,
chaînes de caractères et pointeurs.

85
 L'opérateur d'insertion << peut être utilisé plusieurs fois dans une même instruction.
Exemple : cout<<"n="<<n;
le flot cout reçoit la chaîne "n=" puis, le flot cout<<"n=" (c.à.d le flot cout
augmenté de "n=") reçoit la valeur de n.
2- Flux d’entrée standard - cin
 De même, le flux d’entée cin est utilisé pour lire les données du périphérique d'entrée standard
(généralement le clavier).
 L'opérateur d'extraction >> est utilisé avec cin pour lire les entrées. Il extrait les données de
l’objet cin, saisies à l’aide du clavier.
 Le compilateur C ++ détermine également le type de données de la valeur entrée et sélectionne
l'opérateur d'extraction de flux approprié pour extraire la valeur et la stocker dans la variable
fournie. Pour le type bool, seuls 0 et 1 sont permis lors de la lecture.
 L'opérateur d'extraction de flux >> peut être utilisé plusieurs fois dans une même instruction de
lecture cin.
Exemple :
int n; float x;
cout<<"donner n et x: ";
cin>>n>>x;
86
Tampon de lecture:
 Les caractères saisis (aussi le caractère de validation <Entrée>) au clavier sont stockés
provisoirement dans une mémoire tampon avant d’être explorés par l’opérateur >> en fonction
du besoin.
 Les caractères non explorés pour la lecture courante peuvent être explorés et affectés aux
variables des prochaines lectures.
 L’exploration d’une valeur du tampon est faite caractère par caractère jusqu’à la rencontre d’un
séparateur (espace, tabulations horizontale et verticale, saut de page, fin de ligne) ou d’un
caractère invalide.
Exemples :
On utilise ici, les 2 séparateurs suivants qu’on note :

- ^ : caractère blanc (espace).
- @ : le caractère Entrée.
int n,p;
Char c

87
1. cin >> n >> p ; 2. cin >> n >> c ;
3. cin >> c >> n ;
Si on tape :
a12@ ⟹ c = ’a’ n = 12
a^^12@ ⟹ c = ’a’ n = 12
^a12@ ⟹ c = ’a’ n = 12
 Si dans une lecture, un ou plusieurs caractères ont été explorés avant de rencontrer un caractère
invalide, la lecture suivante commencera l’exploration à partir de ce caractère invalide.
Exemple : cin >> n >> c ; Si on tape :
12a@ ⟹ n = 12 et c = 'a'

88
 Si dans une lecture, on n’a pas pu extraire un caractère acceptable pour une variable, toutes les
lectures suivantes seront bloquées. (Notons qu’il y a possibilité de débloquer cette situation).
Exemple : cin >> n >> c ;
Si on tape :
!a@ ⟹ n = 0 et c =
 Parfois, on risque d’avoir une boucle infinie sur un caractère invalide.
Exemple : Essayer de donner un caractère invalide à partir de la 3ème lecture.
#𝑖𝑛𝑐𝑙𝑢𝑑𝑒 < 𝑖𝑜𝑠𝑡𝑟𝑒𝑎𝑚 >
𝑢𝑠𝑖𝑛𝑔 𝑛𝑎𝑚𝑒𝑠𝑝𝑎𝑐𝑒 𝑠𝑡𝑑 ;
𝑚𝑎𝑖𝑛( )
* 𝑖𝑛𝑡 𝑛;
𝑑𝑜
* 𝑐𝑜𝑢𝑡 << "donne𝑟 un nombre entier ∶ " ;
𝑐𝑖𝑛 >> 𝑛 ; // Essayer de donner un caractère invalide à partir de la 3ème lecture
𝑐𝑜𝑢𝑡 << "Merci pour " << 𝑛 << 𝑒𝑛𝑑𝑙 ;
+
𝑤𝑕𝑖𝑙𝑒 (𝑛 < 100) ;
𝑐𝑜𝑢𝑡 << "Au revoir" << 𝑒𝑛𝑑𝑙;
+

3- Formatage des données
89
 Il existe plusieurs manipulateurs qui agissent sur le format d’affichage des données. Pour pouvoir
les utiliser, on doit utiliser l’instruction #include <iomanip>.
 On peut utiliser les manipulateurs dec, oct, et hex) pour afficher une valeur entière dans les
bases décimale, octale et hexadécimale.
 On peut aussi utiliser les manipulateurs noboolalpha et boolalpha pour afficher la valeur
d’une expression booléenne sous forme de 0 et 1 ou sous la forme de false et true.
 Le manipulateur setw permet d’agir sur la largeur sur laquelle la donnée sera affichée. On
complétera par des espaces au début si la longueur (gabarit) de la donnée est inférieure à celle
spécifiée.
 Le manipulateur setprecision permet de définir le nombre de chiffres significatifs
voulus pour une donnée flottante.
 Les manipulateurs fixed et scientific permettent de choir entre l’affichage décimal ou
scientifique. Ils peuvent être combinés avec le manipulateur setprecision.
 Lorsqu’un manipulateur est appliqué, il restera valable pour les prochains affichage jusqu’à sa
modification explicite.

3- Formatage des données (Sortie)
90
Exemple 1:
// Lire un entier et l'afficher en octal, decimal, et hexadecimal.
#include <iostream>
int main(){
int N;
cout << "Entrer un entier: ";
cin >> N;
cout << uppercase // pour mettre en maj. les lettres de base 16
<< "En octal, N="<< oct << N << "\n"
<< "En décimal, N="<< dec << N << "\n"
<< "En héxadécimal, N="<< hex << N << "\n";
}
Exécution

91
Exemple 2:
#include <iostream>
main(){
double x = 25.123456,y=10;
cout.precision(3); // Precision 3
cout << "Par default: x=" << x << endl;
cout << "Par default: y=" << y << endl;
cout << "showpoint: x=" << showpoint << x << endl;
cout << "showpoint y=" << y << endl; //showpoint précédent valable pour y
cout << "fixed: x=" << fixed << x << endl;
cout << "scientific: x=" << scientific << x << endl;
}
Exécution
On pourra désactiver showpoint en utilisant le
manipulateur noshowpoint, ou uppercase
en utilisant nouppercase

92
Exemple 3:
#include <iostream>
#include <iomanip>
main(){
cout << '|' << setw(6) << 'X' << '|'<<endl;
cout << fixed << setprecision(2)
<< setw(12) << 123.4 << endl // on peut aussi utiliser : cout.width(10);
<< "1234567890123" << endl;
cout << setfill('*') << setw(5) << 12<<endl;
cout << setw(6)<< -123<<endl;
cout.width(6); cout.fill('0');
cout << internal << -123<<endl;
cout << setw(6)<<right<< -123<<endl;
}
Exécution :

93
Exemple 4:
#include <iostream>
#include <iomanip>
main(){
…
for (i=0; i<=n; i++) { //Affichge du traingle de Pascal
cout<<" n= : "<<setw(3)<< i<<" ";
for (j=0; j<=i; j++)
//cout<<P[i][j]<<" ";
cout<<setw(4)<<P[i][j]<<" ";
cout<<"\n";
}
}
Exécution :
Avec cout<<P[i][j]<<" "; Avec cout<<setw(4)<<P[i][j]<<" ";
Décalage des colonnes Alignement des colonnes

3- Formatage des données (Entrée)
94
 L'opérateur >> prend en compte la base numérique actuelle et les indicateurs de largeur de champ
lors de la lecture de l'entrée :
- la base numérique spécifie si un entier sera lu comme un nombre décimal, octal ou hexadécimal
- la largeur du champ spécifie le nombre maximum de caractères à lire pour une chaîne.
 Lors de la lecture à partir de l'entrée standard, cin est tamponné par des lignes. La saisie au clavier
n'est donc lue qu'après confirmation par appui sur la touche <Entrée>. Cela permet d’appuyer sur
la touche <retour arrière> et de corriger toute erreur de saisie.
 L'opérateur >> lit le champ d'entrée suivant, convertit l'entrée par référence au type de la variable
spécifiée et écrit le résultat dans la variable. Tous les espaces blancs (comme les espaces,
tabulations et les nouvelles lignes) sont ignorés par défaut.
 Lors de la lecture d’un caractère, >> ignore tous les séparateurs jusqu’à un caractère valide. On
peut utiliser la fonction cin.get() pour lire n’importe quel caractère (y compris un séparateur).
 Lors de la lecture d’une chaîne à l’aide de l’opérateur >>, un seul mot est lu puisque le premier
caractère d'espacement commencera un nouveau champ de saisie.
 On peut lire un texte contenant plusieurs mots à l’aide de la fonction getline : getline(cin, ch);
 Le nombre de caractères à lire peut également être limité en spécifiant la largeur de la chaîne.
Pour une largeur donnée de n, un maximum de n–1 caractères sera lu, car un octet est requis
pour le caractère nul. Tout espace blanc initial sera ignoré.
95
Exemple 1 :
#include <iostream>
#include <iomanip>
int main(){
int n = 0;
cout << "Donner un entier en hexadecimal: ";
cin >> hex >> n; // Entrer un entier en hexadécimal
cout << "La valeur de n en decimal: " << n << endl;
// si une entrée est invalide
cin.sync(); // Vider le tampon
cin.clear(); // Réinitialiser les indicateurs d'erreurs
double x1 = 0.0, x2 = 0.0;
cout << "Donner x1: "; cin >> x1;
cout << "Donner x2: "; cin >> x2;
cout << fixed << setprecision(2)<< "La somme des 2 nombres: "
<< setw(10) << x1 + x2 << endl;
cout << "Le produit des 2 nombres: "<< setw(10) << x1 * x2 << endl;
}
 On peut aussi saisir une valeur en octal ou en décimal : cin>>oct>>n; ou cin>>dec>>n;

 La lecture d’une valeur flottante peut être saisie en notation scientifique.

96
Exemple 2 :
#include <iostream>
#include <string>
int main(){
char c1;
string ch1;
cout <<"donner un caractere : ";
cin>>c1; cout<<"Voici votre caractere"<<c1<<endl;cin.sync();
cout <<"donner un autre caractere : "<<endl;
cin.get(c1); cout<<"Voici votre nouveau caractere"<<c1<<endl;cin.sync();
cout <<"donner un text : ";
getline(cin, ch1);
cout<<"Voici votre text : "<<ch1<<endl;
cout <<"donner un autre text : ";
getline(cin, ch1,'.');
cout<<"Voici votre nouveau text : "<<ch1<<endl;
}

VIII- Instructions de contrôle
97
Le langage C++ dispose des instructions de contrôle suivantes :
• Séquence (bloc d’instructions).
• Instructions de sélection : if…else… et switch…
• Instructions de répétition (boucle) : do…while, while… et for…
• Instructions de branchement inconditionnel : goto, break et continue.
1- Bloc d’instructions
Un bloc d’instructions est une suite d’instructions simples ou composées placées entre "{" et "}".
Exemples :
• Les variables d’un bloc cachent la
visibilité des variables appartenant
aux blocs supérieurs.
• Une variable peut être utilisée
dans n’importe quel bloc qui suit sa
déclaration.
• Une variable déclarée au sein d’un
bloc ne peut pas être utilisée en
dehors de celui-ci.

98
2- Instruction if
Forme1 : Forme2 :
Syntaxe : if <expression> { if <expression> {
Traitement Traitement1
} }
else {
Traitement2
}
- expression : expression quelconque.
- Traitement1, Traitement1 et Traitement2 : instructions quelconques (simples, blocs,
instructions structurées). S’ils contiennent une seule instruction, alors les accolades sont
optionnelles.
#include<iostream>
Exemple 1 : Valeur absolue de x-y using namespace std;
main(){
int x,y;
cout<<"Donner x et y : " ; cin>>x>>y ;
if (x>y) cout<<"Valeur absolue= "<<x-y<<endl ;
else cout<<"Valeur absolue= "<<y-x<<endl ;
}

2- Instruction if
99
Exemple 2 : Minimum de 2 flottants (Si imbriqués)
#include <iostream>
int main(){
float x, y, min;
cout << "Donner 2 flottants: \n";
if(cin >> x && cin >> y) { // si les 2 valeurs sont valides
if( x < y )
min = x;
else
min = y;
cout << "Le minimum est: " << min << endl;
}
else
cout << "Entree(s) invalide(s)" << endl;
}
Remarque :
Dans cet exemple, la condition est une expression constituée de deux instructions de lecture.

2- Instruction if
100
 Un else se rapporte toujours au dernier if rencontré auquel un else n’a pas encore été attribué.
Exemple 3 : if (x<=y)
if (y<=z)
cout<<"x, y et z ordonnés" ;
else
cout<<"x, y et z ne sont pas ordonnés" ;
Syntaxe:
3- instruction switch
 switch est une instruction de
sélection multiple qui généralise la
sélection simple. Elle permet d’éviter
l’emboîtement (l’imbrication) de
plusieurs sélections simples, en
permettant de spécifier les différents
cas sans la contrainte d’utiliser les
structures if … else.

101
 Un else se rapporte toujours au dernier if rencontré auquel un else n’a pas encore été attribué.
Exemple 3 : if (x<=y)
if (y<=z)
cout<<"x, y et z ordonnés" ;
else
cout<<"x, y et z ne sont pas ordonnés" ;
Syntaxe:
 switch est une instruction de sélection
multiple qui généralise la sélection
simple. Elle permet d’éviter
l’emboîtement (l’imbrication) de
plusieurs sélections simples, en
permettant de spécifier les différents cas
sans la contrainte d’utiliser les structures
if … else.

102
- Expression : expression entière quelconque.
- Constante : expression constante d’un type entier quelconque. char est accepté car il sera
converti en int (on ne peut pas utiliser une variable initialisée à une constante).
- Instructions1, Instructions2,…, Instructionsn, Instructions : Séquence
d’instructions quelconques.
- break : permet de sortir du bloc de switch. Si l’instruction "break ;" n’est pas mentionnée, on
exécutera aussi, instructions suivantes.
- default : si aucune valeur n’est satisfaisante, on branchera dans l’instruction default.
Remarque : Tout ce qui se trouve entre [ et ] est optionnel.
#include <iostream>
main(){
int annee ;
cout<<"Donner l'annee : " ; cin>>annee ;
Exemple : switch (annee){
case 1 : cout<<"Premiere annee \n" ; break ;
case 2 : cout<<"Deuxieme annee \n" ; break ;
case 3 : cout<<"Troisième annee \n" ; break ;
default : cout<<"Annee inconnue\n" ;
}
cout<<"Fin du programme\n";
}
103
Exécution :

4- instruction do … while
104
 L’instruction do… while permet de répéter un traitement tant qu’une condition (expression) est
vraie. La condition/expression est testée après l’exécution du traitement.
Syntaxe : do
instruction : simple, bloc d’instruction, instructions
de contrôle.
instruction
expression peut être quelconque (constante,
while (expression);
arithmétique, booléenne).
Exemple1:
Exemple2:
#include<iostream>
using namespace std; #include<iostream>
main() using namespace std;
{ int i=1, max, y ; main(){
cout<<"Donner le premier entier : " ; int n;
cin>>max ; do{
do cout << "donnez un entier >0 : " ;
{ cout<<"Donner l'entier suivant : " ; }
cin>>y ; while (cin >> n, n <= 0) ;
if (y>max) max=y ; cout << "Bien. Vous avez donné un
i++ ; entier >0 : "<<endl;
}while (i<10) ; }
cout<<"Max="<<max<<endl ;
}
5- instruction while …
105
 L’instruction while … permet de répéter un traitement tant qu’une condition (expression) est
vraie. Mais, la condition est examinée avant le traitement (c’est la traduction de Tant que … Faire ...)
Syntaxe : while (expression) expression peut être quelconque (constante, arithmétique,
booléenne).
instruction
instruction : simple, bloc d’instructions, instruction de contrôle.
Exemple1: Exemple2:
#include<iostream> // calcule la moyenne d'un certain nombre
using namespace std; d'entiers
main() { #include <iostream>
int i=1, s=0, n ; using namespace std;
cout<<"Donner n : " ; cin>>n ; int main(){
while (i<=n){ int x, cpt = 0;
s+=i ; float s = 0.0;
i++ ; cout << "Saisissez des entiers\n"
} "(pour arreter tapez une lettre):"<< endl;
cout<<"Somme="<<s<<endl ; while(cin >> x ){
} s += x;
++cpt;
}
cout << "La maoyenne des nombres saisis est: "
<< s/cpt << endl;
}
5- instruction for…
106
 Syntaxe : expression1;
while (expression2){
for ([expression1] ; [expression2] ; [expression3]) instruction
instruction expression3;
}
 Les expressions expression1, expression2 et expression3 peuvent être omises.

 Si instruction est composée de plusieurs instructions élémentaires, ces dernières doivent être
délimitées par des accolades.
Exemple1: Exemple2:
//Somme des n premiers entiers positifs #include <iostream>
#include <iostream> #include <iomanip>
using namespace std; using namespace std;
main(){ main(){
int i=1, s=0, n ; int x, i, limit;
cout<<"Donner n : " ; for( i=0, limit=8; i < limit; i += 2)
cin>>n ; x = i * i, cout << setw(10) << x<<endl;
for (i=1 ; i<=n ; i++) }
s+=i ;
cout<<"Somme = "<<s<<endl;
}

6- instructions de branchement inconditionnel
107
 L’instruction break sert à interrompe le déroulement d’une boucle et à passer à l’exécution des
for(… ;… ; …){
instructions qui viennent après la boucle. …
if (n==1)
Exemple1 : break ;
…
Exemple2 : }
#include <iostream>
#include <iomanip>
int main(){
char reponse; int fin, i = 32; // On n'affichera pas les caractères de contôle (0 à
31)
while(true){
cout << "\nCaractere Decimal Hexadecimal\n\n";
for(fin =i+20; i<fin && i<256; ++i) // On affichera les lignes 20 par 20
cout << " " << (char)i // convertir en caractere
<< setw(12) << dec << i<< setw(12) << hex << i << endl;
if( fin >= 256) break;
cout <<"\nPour continuer taper <Entree>,pour quitter taper <q>+<Entree>";
cin.get(reponse); //cin>>n: n ne peut pas recevoir <Entrée> (c'est séparateur)
if( reponse == 'q' || reponse == 'Q' )
break;
}
}
108
 L’instruction Continue permet de passer prématurément au tour suivant de boucle.
Boucle
{ …
…
continue ;
…
}
Exemple :
#include <iostream>
main() Exécution :
{
int i ;
for (i=1 ; i<=5 ;i++)
{
cout<<"Tour "<<i<<endl ;
if (i<3)
continue ;
cout<<"Bonjour\n" ;
}
cout << "Au revoir" << endl ;
}

109
 L’instruction goto permet de sauter à n'importe quel
emplacement du programme, marqué par une étiquette
dans une fonction.
Exemple :
#include <iostream>
main(){ Exécution :
int i ;
while (1){
cout<<"Donner le numero du jour : " ;
cin>>i ;
if ((i<1) || (i>7)) goto sortie //(sortie:une étiquette)
switch (i){
case 1 : cout<<"Lundi\n" ; break ;
case 2 : cout<<"Mardi\n" ; break ;
case 3 : cout<<"Mercredi\n" ; break ;
case 4 : cout<<"Jeudi\n" ; break ;
case 5 : cout<<"Vendredi\n" ; break ;
case 6 : cout<<"Samedi\n" ; break ;
case 7 : cout<<"Dimanche\n" ; break ;
}
sortie : if ((i<1) || (i>7))cout<<"Numero incorrect\n" ;
}
}

Algorithmique Et Programmation C++ AHMADI 2021 - 2022 - V27

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Algorithmique Et Programmation C++ AHMADI 2021 - 2022 - V27

Transféré par

Droits d'auteur :

Formats disponibles

Algorithmique et

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

 Si le processeur est un ordinateur, l’algorithme s’appelle un programme ;

 La notion d’algorithme n’est pas spécifique à l’informatique (voir exemples ci-dessus).

A. AHMADI Algorithmique et Programmation en C++

Etape 1 : trouver le reste 𝑟 de la division euclidienne de 𝑎 par 𝑏 ;

A. AHMADI Algorithmique et Programmation en C++

- Quelles sont les données du problème? comment devront être introduites?

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

 Il existe trois formes d’affectation :

A. AHMADI Algorithmique et Programmation en C++

Dans la programmation classique (structurée), on distingue trois structures :

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

Exemple : l’instruction ci-dessous affecte à la variable réelle x sa moitié si a et b sont nulles. si a ≠ 0, x

A. AHMADI Algorithmique et Programmation en C++

TANT QUE <condition> FAIRE

A. AHMADI Algorithmique et Programmation en C++

 La variable x servant de compteur, alors que la variable s contiendra à la fin du programme la

A. AHMADI Algorithmique et Programmation en C++

NB : Il faut faire attention aux boucles ouvertes :

L’instruction "écrire(𝑦)" ne sera jamais exécutée.

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

 On répète le traitement (instructions) jusqu’à ce que la condition <condittion> soit vraie.

Exemple : Une autre version pour calculer la somme des entiers de 1 à 𝑛.

- A la différence de la première forme, les instructions dans la 2ème

A. AHMADI Algorithmique et Programmation en C++

 On exécute les instructions spécifiées (N-M+1) fois, la variable i sert de compteur.

Exemple : La version suivante, calculant la somme des entiers

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

3- Tableau à plusieurs dimensions

A. AHMADI Algorithmique et Programmation en C++

3- Tableau à plusieurs dimensions

Pour j=1 à 3 faire T[2,1]

A. AHMADI Algorithmique et Programmation en C++

- vision difficile sur son fonctionnement ;

A. AHMADI Algorithmique et Programmation en C++

FONCTION <nom_fonction> (<paramètres avec leurs types> ) : <type de résultat>

A. AHMADI Algorithmique et Programmation en C++

PROCEDURE <nom_fonction> (<paramètres avec leurs types>)

Exemple PROCEDURE Permuter (a,b:Entier)

Modes de passage des paramètres :

PROCEDURE PermuterVal(a,b:Entier) PROCEDURE PermuterAdr(Var a,b:Entier)

A. AHMADI Algorithmique et Programmation en C++

Modes de passage des paramètres :

A. AHMADI Algorithmique et Programmation en C++

- L’ellipse représente le DEBUT et la FIN d’un algorithme :

- Une opération ou un traitement est représenté par un rectangle :

- Une condition est mise dans un losange :

- La flèche désigne le sens de l’exécution de l’algorithme :

Ainsi les trois structures peuvent être représentées comme suit :

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

A. AHMADI Algorithmique et Programmation en C++

 La complexité s’intéresse essentiellement à l’espace mémoire et au temps d’exécution requis par