Cours

Programmation Impérative
HLIN202
V. Boudet P. Giorgi M. Joab
Université de Montpellier
notes de cours préparées par V. Boudet, P. Giorgi et M. Joab

Présentation du module
Volume horaire
Volume horaire :
9 Cours
12 TDs
12 TPs
Le TD et le TP se font sur 3h en salle informatisée.
Les TDs/TPs commencent la semaine prochaine.

Évaluation du cours
1 note de contrôle continu (assiduité, participation, contrôle

TD/TP)
1 examen terminal
La note finale sera :
max (Exam, 0.6 × Exam + 0.4 × CC )

Objectifs
L’objectif n’est pas de faire de vous des spécialistes d’un

langage impératif en particulier
Objectifs :
Apprendre les fondements de la programmation impérative
Apprendre à les mettre en oeuvre en C/C++
Vous devez être capables de vous adapter à un autre langage
impératif : la syntaxe change, mais les principes restent les
mêmes.
Introduction
Plan
1 Introduction
2 Bases du langage C++
3 Structures de contrôle
4 Fonctions
5 Pointeurs
6 Tableaux
7 Structures de données
Introduction
Langage de programmation
Plan
1 Introduction
Programmation impérative
Les langages C/C++
Les erreurs
Introduction
Definition
Un langage de programmation est un système de notation
permettant de décrire de manière simple une suite d’actions
ordonnée qu’un ordinateur pourra exécuter.
Différents niveaux de langage :

langage machine :
codage binaire propre à chaque processeur
langage assembleur :
codage alphanumérique du langage machine
,→ traduit en langage machine par un assembleur
langage haut niveau :
codage alphanumérique proche du langage naturel
,→ traduit en langage assembleur par un compilateur
Introduction
Langage assembleur
Langage procédurale proche de l’architecture de la machine.
Syntaxe différente d’un processeur à l’autre.
. section __TEXT, __text , r e g u l a r , p u r e _ i n s t r u c t i o n s
. globl _main
. align 4 , 0 x90
_main : ## @main
. cfi_startproc
## BB#0:
push rbp
Ltmp2 :
. c f i _ d e f _ c f a _ o f f s e t 16
Ltmp3 :
. c f i _ o f f s e t rbp , −16
mov rbp , r s p
Ltmp4 :
. c f i _ d e f _ c f a _ r e g i s t e r rbp
mov eax , 0
mov dword p t r [ r b p − 4 ] , 0
mov dword p t r [ r b p − 8 ] , 10
pop rbp
ret
. cfi_endproc
. subsections_via_symbols
Introduction
Langage assembleur
Il est propre à chaque famille de processeurs.

Il est loin de la notion d’algorithme.
Le code d’un même programme change d’un processeur à
l’autre.
,→ langage peu adapté à l’écriture simple de programmes.
Remarque
On dit que du code en langage assembleur n’est pas portable car il
n’est pas garanti de fonctionner sur n’importe quel ordinateur.
Introduction
Langage haut niveau
Syntaxe indépendante des processeurs.

Système d’écriture plus proche de la langue naturelle
Il s’appuie sur des concepts facilitant la programmation.
exemple : notion d’algorithme, notion d’objet, etc.
Le même code que précédemment mais écrit en C/C++.

1 i n t main ( )
2 {
3 int a ;
4 a =10;
5 return 0;
6 }
Introduction
Langage haut niveau
Ce langage n’est pas exécutable directement par un ordinateur.

Deux solutions possibles :
le traduire complètement en langage machine :
,→ notion de langage compilé
l’exécuter par un programme qui le traduit à la volée :
,→ notion de langage interprété
Remarque
Certains langages interprétés utilisent une compilation vers un lan-
gage intermédiaire pour améliorer les performances, ex. JAVA.
Introduction
Langage haut niveau
Il existe plusieurs types de langages haut niveau, chacun proposant

des notions (paradigmes) de programmation différentes.
langages fonctionnels : CAML
langages impératifs : C, Pascal, Fortran
langages à objets : JAVA
langages logiques : Prolog
langage multi-paradigme : C++, python, Scala
Remarque
Un paradigme peut être mieux adapté qu’un autre pour certaines tâches.
Deux programmes peuvent produire les mêmes résultats tout en étant écrit
avec des langages différents.
Introduction
Plan
1 Introduction
Les langages C/C++
Les erreurs
Introduction
Définition
La programmation impérative procédurale correspond à la notion

de changement d’état d’un programme à partir :
d’instructions simples,
d’appel d’algorithmes (i.e. procédure/fonction).
Changement d’état d’un programme

Cela correspond à la modification d’une donnée utilisée par le
programme (une variable).
Remarque
Ce modèle de programmation est au plus proche des architectures
de nos ordinateurs actuels.
Introduction
Modélisation d’un ordinateur actuel

Personal_computer,_exploded_5,_unlabeled.svg 07/11/08 10:31
de la mémoire
des unités de calcul sur des nombres
(entiers/réels)
des unités de contrôle
Un langage impératif s’appuie essentiellement sur 3 notions :

file:///Users/vincentboudet/Enseignement/2008/FLIN202/Personal_computer,_exploded_5,_unlabeled.svg Page 1 sur 1
mémoire, calcul, contrôle

Introduction
!"#"$%"&'()%**%+'
Mémoire d’un ordinateur !"#$%&'()#*+,-,.(/%(0%1$%*#(/%(+2"1/,&*'%#13(+%(41"0%55%#1(4%16%'(/%(6*&,4#+%1(
%'(/%('1*,'%1(+%5(/"&&.%5()#,(+#,(5"&'(-"#1&,%57(!*(4#,55*&0%(*(#&%(,&-+#%&0%(5#1(+*(
$,'%55%(/2%8.0#',"&(/%($"5(+"9,0,%+5(%'(/%5("4.1*',"&5()#%($"#5(%--%0'#%:7
,"#"$-"./.(0'%"101%
;*1'%&*,1%(/%('1*$*,+(/#(
41"0%55%#13(+*(6.6",1%($,$%(
<*44%+.%(*#55,(234=(5'"0>%(
'%64"1*,1%6%&'(+%5(/"&&.%5(?(
'1*,'%1(4*1(+%(41"0%55%#17(@,&5,3(
4+#5(,+(A(*(/%(6.6",1%(/%(
/,54"&,B+%3(4+#5(,+(%5'(4"55,B+%(
/2A(0"&5%1$%1(/%5(/"&&.%5(
'%64"1*,1%6%&'(<0%()#,(.$,'%(
/2*00./%1(*#(/,5)#%(/#1()#,(%5'(
4+#5(+%&'=7
Mémoire divisée en case C*(6.6",1%($,$%(%5'($,/.%(?(0D*)#%(*11E'("#(1%/.6*11*9%(/%($"'1%("1/,&*'%#17
,→ une case est un bit (soit 5"#"$%"60*7+%"6+'

0, soit 1)
F"&'1*,1%6%&'(?(+*(6.6",1%($,$%3(
Case identifiée par un numéro (adresse)
+%5(/"&&.%5(5'"0>.%5(5#1(#&(
/,5)#%(/#1(5"&'(4%16*&%&'%5(%'(&%(
5"&'(4*5(%--*0.%5(?(+2*11E'(/%($"'1%(
On peut donc voir la mémoire"1/,&*'%#17(F2%5'(/"&0(5#1(#&(
d’un ordinateur comme un tableau
/,5)#%(/#1()#%($"'1%(5A5'G6%(
contenant des 0 et des 1. /2%84+",'*',"&(<$08+93(4-):*("#(
;086(<*=3($"5(+"9,0,%+5(%'($"5(
/"0#6%&'5(5"&'(0"&5%1$.57(F2%5'(
/"&0(#&(%54*0%(/%(5'"0>*9%(
...4%16*&%&'3("H($"#5(4"#$%:(0"4,%1(
%'(5#441,6%1(/%5(/"&&.%5(?(
$"+"&'.7
Introduction
Contenu de la mémoire
Toutes les données dans un programme sont traduits en 0 et en 1

des plus simples (booléens, entiers)
aux plus complexes (une carte routière, un film)
On parle de codage binaire des données.
Exemple
La représentation en mémoire de 63576473 est
00000011110010100001100110011001
celle de Π peut-être
11001001000011111101101010100010001000010110100011000
Introduction
Contenu de la mémoire
Les données étant de diverse nature (taille et contenu du codage),

on utilisera la notion de type pour les différencier.
On aura :
des types de base fournis par le langage, e.g. float, int.
un mécanisme d’extension des types, e.g. codage d’une image.
Introduction
Écrire un programmation impératif
Le programmeur décrit de manière ordonnée chacune des

instructions composant son programme.
Instructions possibles :
de calcul : 3+5
de contrôle : si ... alors ... sinon, pour, tant que
de mémoire :
nommer une zone mémoire : variable
accéder directement à une case mémoire : pointeur
modifier une zone mémoire : affectation
Introduction
Les langages C/C++
Plan
1 Introduction
Les langages C/C++
Les erreurs
Introduction
Les langages C/C++
Historique
Le langage C
est un langage purement impératif

est créé en 1972 par D. Ritchie et K. Thompson pour
développer UNIX
normalisation ANSI (1989) et ISO (1990,1991,2011)
Le langage C++
est une évolution de C ajoutant le paradigme objet

est inventé en 1983 par B. Stroustrup
normalisation ISO (1998,2003,2011)
Introduction
Les langages C/C++
Caractéristiques importantes
Noyau de langage impératif procédural
faiblement typé (conversion implicite des types)

langage compilé
arithmétique sur les adresses mémoires et sur les bits
Remarque
permet de rester très proche de l’architecture des ordinateurs,
utile pour avoir les meilleures performances possibles
Introduction
Les langages C/C++
Le noyau impératif de C++ pouvant être considéré comme une

équivalence du langage C, nous ne parlerons que C++ dans la
suite de ce cours.
Attention
les concepts généraux présentés en C++ restent valables en C,
la mise en oeuvre et la syntaxe restent parfois différentes.
Introduction
Les langages C/C++
Concevoir un programme en C++
Trois étapes ordonnées :

1 écrire dans un fichier texte le code du programme en C++
2 compiler le programme
3 exécuter le programme
Introduction
Les langages C/C++
Écrire un programme C++
Il suffit d’écrire avec un éditeur de texte simple (sans formatage)

quelques lignes de code.
exemple.cpp
1 #i n c l u d e 
2
3 i n t main ( ) {
4 int a ,b , c ;
5 s t d : : c i n >>a>>b ;
6 c=a+b ;
7 s t d : : cout <<a<<"+"<<b<<"="<<c<<s t d : : e n d l ;
8
9 return 0;
10 }
Introduction
Les langages C/C++
Compilation d’un programme C++
Objectif
Traduire un programme décrit en C++ dans un programme décrit
en langage machine.
Attention
Les programmes écrits en C++ ne sont pas exécutables, seules leurs
traductions en langage machine le sont.
L’outil permettant la traduction d’un texte écrit en C++ en

langage machine s’appelle un compilateur.
Introduction
Les langages C/C++
Compilation d’un programme C++
Il existe plusieurs compilateurs C++ en fonction du système

d’exploitation et de l’architecture.
Dans un environnement GNU/Linux,
la suite de compilation standard est appelé GCC (the GNU

Compiler Collection).
le compilateur C++ de GCC est : g++
Introduction
Les langages C/C++
Un exemple de compilation
Pour compiler l’exemple (exemple.cpp), on tape dans un terminal :
g++ -Wall exemple.cpp -o Exemple
ce qui permet de créer un programme exécutable nommé Exemple.
Syntaxe générale
g++ -Wall source.cpp -o execu
source.cpp est le fichier du programme en C++.
execu est le programme traduit exécutable sur la machine.
-o ... indique que ... est le nom du programme.
Introduction
Les langages C/C++
Un exemple de compilation
Pour compiler l’exemple (exemple.cpp), on tape dans un terminal :
g++ -Wall exemple.cpp -o Exemple
ce qui permet de créer un programme exécutable nommé Exemple.
Syntaxe générale
g++ -Wall source.cpp -o execu
source.cpp est le fichier du programme en C++.
execu est le programme traduit exécutable sur la machine.
-o ... indique que ... est le nom du programme.
Introduction
Les langages C/C++
Notion de programme en C++
Un programme est constitué de plusieurs fonctions/procédures qui

peuvent s’appeler les unes les autres.
La première fonction appelée par un programme est :
le point d’entrée du programme
Point d’entrée d’un programme C++
Il correspond à une fonction appelée main qui est spécifique :
1 i n t main ( ) {
2 // d é b u t du programme
3 ...
4 // f i n du programme
5 return 0;
6 }
Introduction
Les langages C/C++
Principe d’un programme C++

Écriture du programme :
fonction A!
!
! 1 On définit un ensemble de fonctions
!
! A,B,C.
fonction B! 2 On définit un programme avec main
!
!
!
!
Quand on lance le programme :
fonction C!
! il exécute main
qui exécute B
appel de A
!
!
qui exécute C
fonction main!
! qui lui même exécute A
appel de B
appel de C qui exécute encore B
appel de B
Attention
la fonction main n’est définie qu’une seule fois par programme.
Introduction
Les erreurs
Plan
1 Introduction
Les langages C/C++
Les erreurs
Introduction
Les erreurs
Les erreurs
Trois types d’erreurs

Erreur de syntaxe
Erreur de conception
Erreur d’exécution
Introduction
Les erreurs
Erreurs de syntaxe
Les langages de programmation sont définis à partir de règles

strictes. La violation d’une seule règle implique une erreur de
syntaxe.
Remarque
Les langages de programmation ne peuvent être ambigus. Chaque
mot clé du langage a un sens et il faut les utiliser correctement.
Correction des erreurs de syntaxe

Le compilateur affiche les éventuelles erreurs de syntaxe en
décrivant le type d’erreur et la ligne du programme incriminée.
Introduction
Les erreurs
Erreurs de syntaxe
syntax-error.cpp
1 i n t main ( )
2 {
3 int a
4 return 0;
5 }
Compilation
g++ -Wall syntax-error.cpp -o syntax-error
s y n t a x−e r r o r . cpp : I n f u n c t i o n ‘ i n t main ( ) ’ :
s y n t a x−e r r o r . cpp : 3 : 3 : e r r o r : e x p e c t e d i n i t i a l i z e r before ‘ return ’
il y a une erreur ligne 3 avant le mot clé return ,→ il manque un ;

Introduction
Les erreurs
Erreurs de conception
Vous vous êtes trompé dans la conception du programme.
Exemple
1 faire chauffer une poêle avec de l’huile.
2 battre les oeufs.

3 verser les oeufs battus dans la poêle.
4 casser les oeufs.
bien que syntaxiquement correct ce programme ne fera pas une
bonne omelette.
Introduction
Les erreurs
Erreurs de conception
Attention
Un ordinateur exécute strictement les ordres qu’on lui donne ! ! !
Attention
Le compilateur ne peut pas détecter les erreurs de conception ! ! !
Introduction
Les erreurs
Erreurs d’exécution
Souvent liées à des erreurs d’écriture (bug) ou à des erreurs de

conception.
non détectées à la compilation
dépendantes de l’état du programme et de son environnement
d’exécution
Remarque
Un programme peut fonctionner correctement très longtemps et pro-
duire soudainement une erreur.
un cas classique : une division par 0

Introduction
Les erreurs
Erreurs d’exécution
execution-error.cpp
2 i n t main ( )
3 {
4 int a ,b , c ;
5 s t d : : c i n >>a>>b ;
6 c=a /b ;
7
8 return 0;
9 }
La compilation ne détecte aucune erreur, mais si on exécute le

programme en saisissant b = 0, on obtient le message suivant :
Floating point exception
Bases du langage C++
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
Rappel : programme minimal
Un programme C++ se compose d’une fonction main, dont la

version la plus simple est :
1 i n t main ( ) {
2 d é c l a r a t i o n de v a r i a b l e s
3 i n s t r u c t i o n s du programme
4 return 0;
5 }
Rappel : programme minimal
Comme dans le langage algorithmique :

les variables ont un type (ex : entier, flottant)
les instructions sont :
des instructions simples (ex : affectation)
des expressions (ex : a+b×c)
des structures de contrôle (ex : tant que)
Les composants de base d’un programme C++
Un programme C++ est constitué des composants élémentaires

suivants :
les types de données,
les constantes,
les variables,
les opérateurs,
les structures de contrôle,
les appels de fonctions
Les type de données
Plan

Les constantes
Les variables
Opérateurs
Les conversions de type
Les entrées-sorties
Instructions
Les types de données
des nombres : entiers, approximations flottantes des réels

des lettres : caractères
des booléens : vrai, faux
type type en C++ valeurs

entiers int [−231 , 231− 1]
réels (simple précision) float ≈ 7 chiffres significatifs
réels (double précision) double ≈ 15 chiffres significatifs
caractère char
booléen bool { true, false}
Le codage binaire des entiers
Les entiers sont exprimés sous format binaire

103 = 64 + 32 + 4 + 2 + 1 = 26 + 25 + 22 + 21 + 20
1 1 0 0 1 1 1
Le nombre de bit (case) fixe l’ensemble des entiers représentables.

Sur 7 bits on représente les entiers positifs dans [0, 127]
le plus grand : 127 = 27 − 1

1 1 1 1 1 1 1
le plus petit : 0
0 0 0 0 0 0 0
Le codage binaire des entiers
Les entiers négatifs sont également représentés par un codage

binaire : le codage en complément à deux
Complément à deux
−103 = −128 + 25 = −128 + 16 + 8 + 1 = −27 + 24 + 23 + 20
1 0 0 1 1 0 0 1 sur 8 bits
−103 = −256 + 128 + 16 + 8 + 1 = −28 + 27 + 24 + 23 + 20
1 1 0 0 1 1 0 0 1 sur 9 bits
On dit que le bit de poids fort (le plus à gauche) est le bit de signe.
,→ il a un poids négatif si non nul.
Les types de données entiers
Plusieurs variantes (complément à deux) qui utilisent plus ou moins

d’octets et qui ont différentes plages de valeurs : norme C++11.
type entier type en C++ nbr octets valeurs
court short int ≥2 [−215 , 215 − 1]
standard int ≥2 [−216 , 216 − 1]
long long int ≥4 [−231 , 231 − 1]
très long long long int ≥8 [−263 , 263 − 1]
Exemple
short int a= 103;
0 0 0 0 0 0 0 0 0 1 1 0 0 1 1 1
| {z }
a
Les types de données entiers
On peut étendre la valeur maximum des entiers en utilisant des

entiers positifs (versions non signées = pas de complément à deux)
type en C++ nbr octets valeurs

unsigned short int ≥2 [0, 216 − 1]
unsigned int ≥2 [0, 216 − 1]
unsigned long int ≥4 [0, 232 − 1]
unsigned long long int ≥8 [0, 264 − 1]
Remarque
Sur une machine Unix 64-bits, on admet communément que
taille int = 4 octets ; taille long int = 8 octets ;
Les types de données réels

Les réels ne sont pas représentables en codage binaire. On
représente un réel x par une approximation rationnelle particulière :
m
x ≈ (−1)s ×
2e
exemple : 0.75 = (−1)0 × 232
Le codage de x correspond au codage binaire de s,m et e.
s m e
0 0 0 1 1 0 1 0
Les types de données réels

Les réels ne sont pas représentables en codage binaire. On
représente un réel x par une approximation rationnelle particulière :
m
x ≈ (−1)s ×
2e
exemple : 0.75 = (−1)0 × 232
Le codage de x correspond au codage binaire de s,m et e.
s m e
0 0 0 1 1 0 1 0
Norme IEEE754 :
float (32 bits) : 1 bit pour s, 23 bits pour m, 8 bits pour e

double (64 bits) : 1 bit pour s, 52 bits pour m, 11 bits pour e
Le type de données caractère

Le mot clé char désigne un caractère codé sur un octet basé sur
une extension du code ASCII (les caractères accentués en plus) :
Les constantes
Plan

Les constantes
Les variables
Opérateurs
Instructions
Les constantes
Les constantes
Chaque type de données possède des constantes pouvant être

utilisées dans un programme pour :
affecter une valeur à une variable,
effectuer un calcul,
former une expression booléenne.
Exemple
int a=10;
1+2+3+4+5;
1<2;
Les constantes
Les constantes entières
Elles sont définies en accord avec le type natif des entiers (int) et
appartiennent donc à l’intervalle [−231 , 231 − 1] (en général).
1 int a ;
2 a= 2 1 4 7 4 8 3 6 4 7 ; ( affectation valide −> a=2^31 −1)
3 a= 2 1 4 7 4 8 3 6 4 8 ; ( c o n s t a n t e e r r o n é e −> a= −2^31)
4 long i n t b ;
5 b= 2147483648 L ; ( a f f e c t a t i o n v a l i d e −> b= 2^31)
Remarque
Le compilateur provoquera une alerte si la constante est supérieure
à la capacité du type affecté. short int a=2147483647;
Les constantes
Les constantes entières
On peut étendre leur plage en les suffixant par

U (unsigned)
L (long)
LL (long long)
ex : 264 − 1 ⇒18446744073709551615ULL
Plusieurs écriture possibles :

décimal (en base 10) - ex : 1234
octal (en base 8) - ex : 0477
hexadécimal (en base 16) - ex : 0xA123F
Les constantes
Les constantes réelles (flottantes)
Elles sont définies en accord avec le type double. On peut forcer le

codage en suffixant par F (float) et L (double).
Codage scientifique
représentation par mantisse et exposant

l’exposant est introduit par la lettre e
ex : 2.34e4 représente 2.34 × 104
Les constantes
Les constantes caractères
Elles sont formées par l’expression utilisant les guillemets simples :

’...’ ou les ... sont remplacés par :
un caractère alphanumérique :
abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ
1234567890;,.?!@*()+-[]:;<> ETC.
un caractère spécial :
\n → retour à la ligne
\t → tabulation
\b → backspace
...
Les variables
Plan

Les constantes
Les variables
Opérateurs
Instructions
Les variables
Manipulation de la mémoire
Rappel :
la mémoire est binaire (un grand tableau de 0 et de 1)
un langage impératif manipule directement la mémoire
Comment savoir ou se trouvent les données en mémoire ?
0 1 1 0 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 0
Les variables
Rappel :
Comment savoir ou se trouvent les données en mémoire ? les

variables
0 1 1 0 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 0
↑ ↑
début de la variable x fin de la variable x
Les variables
Rappel :
Comment savoir ou se trouvent les données en mémoire ? les

variables
0 1 1 0 1 0 0 1 1 1 1 0 1 0 1 1 1 1 1 0
↑ ↑
début de la variable x fin de la variable x
On identifie une variable par :

une adresse de début dans l’espace mémoire
une taille indiquant l’espace mémoire occupé par la variable
Les variables
Les variables en C++
Definition
On appelle variable une zone mémoire de l’ordinateur à laquelle on
a donné un nom, ainsi qu’un type de données.
le nom de la variable, appelé identificateur1 , permet de

manipuler facilement les données stockées en mémoire.
le type de données permet au compilateur de réserver l’espace
mémoire suffisant pour stocker les valeurs.
(1) on utilise un identificateur plutôt que l’adresse mémoire mais

l’on peut facilement récupérer l’adresse d’une variable à partir de
son identificateur.
Les variables
Exemple
int a;
a est une variable de type entier :
le compilateur lui réservera 4 octets en mémoire pour stocker

ses valeurs
on utilisera le nom « a » pour travailler avec l’espace mémoire
attribué à la variable a.
Les variables
Exemple
double f;
f est une variable de type réel :
le compilateur lui réservera 8 octets en mémoire pour stocker

ses valeurs
on utilisera le nom « f » pour travailler avec l’espace mémoire
attribué à la variable f.
Opérateurs
Plan

Les constantes
Les variables
Opérateurs
Instructions
Opérateurs
Les opérateurs arithmétiques

les opérateurs classiques
addition : +
soustraction : −
division : /
multiplication : *
opposé : −
modulo : %
Attention : les opérateurs utilisent des opérandes du même type et
renvoie un résultat du même type que les opérandes
int + int = int ;
float * float = float ;
int + float = ???
Opérateurs
Priorité des opérateurs arithmétiques
Les règles de priorités mathématiques sont conservées :

a + b × c sera interprété a + (b × c)
(a + b) × c sera interprété correctement car les parenthèses
fixent l’ordre de priorité
nb : les opérations entre parenthèses sont prioritaires et seront

toujours évaluées en premier
Opérateurs
Opérateurs de comparaisons
les opérateurs classiques sur les types numériques :
égalité ==
différent !=
supérieur >
inférieur <
supérieur ou égal >=
inférieur ou égal 1 <=
Attention : le langage C++ dispose d’un type booléen en standard,

le résultat d’une expression booléenne est un booléen :
false si l’expression est fausse (ex : 3 < 2)
true si l’expression est vraie (ex : 3 > 2)
Opérateurs
Opérateurs logiques
les opérateurs logiques en C :

et : &&
ou : ||
non : !
les opérandes sont de type booléen.
Exemple
(2.5 > 3.5) && (1 < 3) est égale à false
true || (1 >= 3) est égale à true
Opérateurs
Opérateur d’affectation
Cette opérateur permet d’affecter la valeur d’une expression à une

variable. L’affectation se fait avec =
var = exp
exp : expression du même type que var
var : nom d’une variable déclarée
la variable var prend la valeur de l’expression exp
ex : a=2+3; a prend la valeur de l’expression 2+3 donc 5
comme en algorithmique, l’opérande de gauche ne peut être

qu’une variable : l’affectation a+b=3; n’est pas correcte
syntaxiquement.
Opérateurs
Autres opérateurs
incrémentation/décrémentation d’une variable entière a :

a + + incrémente la valeur de a par 1
a − − décrémente la valeur de a par 1
affectations élargies : +=, -=, *=, /=

a+=3; correspond à l’expression a=a+3;
taille mémoire des variables : sizeof

sizeof(a) renvoie la taille en octets de la variable a.
et beaucoup d’autres ...
Opérateurs
Opérateur d’adresse mémoire
Chaque variable est stockée en mémoire à une adresse précise.

L’opérateur d’adresse & permet de récupérer l’adresse associée à
une variable
si a est une variable définie :
&a renvoie la valeur de l’adresse de a
Attention
l’adresse des variables n’est pas choisie par le programmeur :
&a=... est interdit ! ! !
l’adresse des variables peut être stockée dans une variable :
b=&a si b a le bon type
Opérateurs
Priorités des opérateurs : récapitulatif

Opération associative (?) :
à droite : a ? b ? c ⇒ a ? (b ? c)
à gauche : a ? b ? c ⇒ (a ? b) ? c
Catégorie Opérateurs Associativité

Unaire +, −, ++, −−, !, ∗, &, sizeof, cast Droite
Binaire ∗, /, % Gauche
Binaire +, − Gauche
Comparaison <, <=, >, >= Gauche
Comparaison ==, ! = Gauche
Logique && Gauche
Logique || Gauche
Affectation =, + =, − =, ∗ =, / =, % = Droite
Le tableau est classé par ordre de priorité décroissante.
Opérateurs
Priorités des opérateurs : exemples
Expression Expression parenthésée Valeur

2+3*7 2+(3*7) 23
15*3%7/2 ((15*3)%7)/2 1
x=y=2 x=(y=2) x :2, y :2
1<4==7<5 !=9<4 ((1<4)==(7<5)) !=(9<4) false (ou 0)
Plan

Les constantes
Les variables
Opérateurs
Instructions
Conversions de types
Attention
Le langage C++ est faiblement typé.
⇒ écriture d’expressions avec des types différents
par exemple : 1+2.5+true
Résolution d’expression de types mixtes

Le compilateur convertit implicitement les données pour satisfaire
un typage unique dans les expressions. L’ordre des conversions est
le suivant :
char -> int -> float -> double

bool -> int
signed -> unsigned
lors de l’évaluation d’une expression :

ex : 3.5+1 sera calculé comme 3.5+1.0
,→ pas de perte d’information
lors d’une affectation :

int a = 3.5; sera effectué comme int a= 3;
,→ perte d’information possible
Le cas des booléens

Les booléens sont vus comme des nombres :
la valeurs numérique 0 → false
toute valeur numérique 6= 0 → true
Exemple
1 && true ⇒ true
1.5 && true ⇒ true
0 || false ⇒ false
int a=true; ⇒ a=1
Conversions de types explicite
On peut forcer le changement de type en effectuant un cast.

Conversion de type par cast
L’expression : (type1) exp;
permet de convertir l’évaluation de exp dans le type type1.
Exemple
1 i n t a =3 ,b =4;
2 dou bl e c= a /b ; // c =0.0
3 dou bl e d= ( d o u b l e ) a / ( double ) b // d =0.75
Plan

Les constantes
Les variables
Opérateurs
Instructions
Comme pour tout langage de programmation il est souhaitable de

pouvoir interagir avec le programme :
saisir des valeurs au clavier
afficher des valeurs à l’écran
En C++, les fonctionnalités d’entrée-sortie standards sont définies

dans le fichier iostream.
2 i n t main ( ) {
3 ...
4 return 0;
5 }
Instruction d’affichage
Definition
std::cout << exp;
exp est une expression quelconque

cout est le nom de la sortie standard (l’écran par défaut)
l’opérateur d’écriture << indique ici d’envoyer la valeur de
l’expression exp sur le flux de sortie standard cout
2 i n t main ( ) {
3 s t d : : c o u t << 1 ;
4 return 0;
5 }
Instruction d’affichage
Definition
std::cout << exp;
exp peut être :

expression arithmétique
expression booléenne
une constante ou une variable de type standard
std::endl → instruction de retour à la ligne
On peut enchaîner les affichages :

cout << exp1 << exp2 << exp3 << · · · << expn;
Instruction d’affichage : exemple
2 i n t main ( ) {
3 int a = 18;
4 float b = 2.3;
5 s t d : : c o u t << " l ’ e n t i e r a = " << a << s t d : : e n d l ;
6 s t d : : c o u t << " l e f l o t t a n t b = " <> var;
var est un identificateur de variable valide

std::cin est le nom de l’entrée standard (le clavier)
l’opérateur de lecture >> indique ici d’affecter la valeur du
flux d’entrée standard dans la variable var
2
3 i n t main ( ) {
4 int a ;
5 s t d : : c i n >> a ;
6 return 0;
7 }
Instruction de saisie clavier
Definition
std::cin >> var;
Attention
var est un identificateur de variable valide
Une saisie clavier est l’action d’écriture d’une donnée en mémoire.
Pour savoir où écrire en mémoire, on le spécifie par l’identificateur
d’une variable (dualité mémoire/variable)
var doit être une variable existante dans la mémoire ! ! !
On peut enchaîner les saisies clavier :

std::cin >> var1 >> var2 >> · · · >> varn;
Instruction de saisie clavier : exemple
2
3 i n t main ( ) {
4 int a ;
5 float b;
6 c o u t << " E n t r e z un e n t i e r p u i s un f l o t t a n t : " ;
7 s t d : : c i n >> a >> b ;
8 return 0;
9 }
ce programme affichera à l’écran :

Entrez un entier puis un flottant
et attendra la saisie au clavier d’un entier et d’un réel qu’il
affectera respectivement à la variable a et b.
Instruction de saisie clavier : séparateurs
Si plusieurs valeurs sont saisies au clavier les affectations se font

dans l’ordre des saisies.
Pour séparer 2 valeurs à saisir, on peut utiliser :

une tabulation
un retour à la ligne
un espace
Instruction d’affichage : gabarit
Un gabarit d’affichage
permet de spécifier un nombre minimum de caractère à afficher.
,→ des espaces sont ajoutés implicitement si nécessaire
En C++
On utilise des manipulateurs pour formatter l’affichage avec un
gabarit. Les manipulateurs disponibles dans <iomanip> sont :
std::left → aligne l’affichage à gauche du gabarit

std::right → aligne l’affichage à droite du gabarit
std::setw(i) → i est le nombre de caractères du gabarit
,→ actif uniquement sur l’affichage suivant.
Exemple : affichage avec gabarit

2 #i n c l u d e 
3 i n t main ( ) {
4 int a = 2;
5 s t d : : c o u t <<" d é f : a= "<<a<<s t d : : e n d l ;
6 s t d : : c o u t <<" gab 1 : a= "<<s t d : : s e t w (1)<<a<<s t d : : e n d l ;
9 s t d : : c o u t <<" gab 4 : a= "<<s t d : : s e t w (3)<< s t d : : r i g h t <<a
10 <<s t d : : e n d l ;
11 return 0;
12 }
Ce code affiche à l’écran :

déf : a = 2
gab 1 : a = 2
gab 2 : a = 2
gab 3 : a = 2
gab 4 : a = 2
Affichage : format des entiers
On peut contrôler le format d’affichage des entiers par un

manipulateur.
Les manipulateurs disponibles sont :
std::hex → affichage en hexadécimal
std::dec → affichage en décimal
std::octal → affichage en octal
Remarque
Par défaut c’est le manipulateur std::dec (décimal) qui est actif.
Un manipulateur de format reste actif tant qu’on en active pas un
autre.
Exemple : affichage avec format des entiers
2 i n t main ( ) {
3 i n t a = 1 2 ; i n t b =8;
4 s t d : : c o u t << " a = "<<a<< " ( d é f a u t ) "<<s t d : : e n d l ;
5 s t d : : c o u t <<s t d : : o c t
6 << " a = "<<a<< " ( o c t a l ) "<<s t d : : e n d l ;
7 s t d : : c o u t << " b = "<<b<<s t d : : e n d l ;
8 s t d : : c o u t <<s t d : : h e x
9 << " a = "<<a<< " ( h e x a d é c i m a l ) "<<s t d : : e n d l ;
10 return 0;
11 }

a = 12 (défaut)
a = 14 (octal)
b = 10
a = c (hexadécimal)
Affichage des booléens
On peut contrôler le format d’affichage des booléens par un

manipulateur : affichage true,false ou 1,0.
Les manipulateurs disponibles sont :

std::boolalpha → affichage true ou false
std::noboolalpha → affichage 1 ou 0
Remarque
Par défaut c’est std::noboolalpha qui est actif.
Ce manipulateur reste actif tant qu’on en active pas un autre.
Exemple : affichage des booléens
2
3 i n t main ( ) {
4 b o o l a = t r u e ; b o o l b=f a l s e ;
5 s t d : : c o u t << " a = "<<a<<" ( d e f a u t ) "<<s t d : : e n d l ;
6 s t d : : c o u t <<s t d : : b o o l a l p h a
7 <<" a = "<<a<<" ( b o o l a l p h a ) "<<s t d : : e n d l ;
8 s t d : : c o u t <<s t d : : n o b o o l a l p h a
9 << " a = "<<a<<" ( n o b o o l a l p h a ) "<<s t d : : e n d l ;
10 s t d : : c o u t << " b = "<<b<<s t d : : e n d l ;
11 return 0;
12 }

a = 1 (defaut)
a = true (boolalpha)
a = 1 (noboolalpha)
b=0
Affichage : format des réels

On peut contrôler le format d’affichage des réels par des
manipulateurs.
Manipulateurs de format
std::fixed → notation décimale

std::scientific → notation scientifique
Manipulateur de la précision
std::setprecision(i) où i est le nombre de chiffres

significatifs choisis.
besoin de #include <iomanip>
std::setprecision n’agit que sur l’affichage et non sur la valeur
stockée en mémoire.
Exemple : format des réels
2
3 i n t main ( ) {
4 f l o a t x = 89.786543;
5
6 s t d : : c o u t <<" x= "<<x<<" ( d e f a u t ) "<<s t d : : e n d l ;
7 s t d : : c o u t <<s t d : : f i x e d
8 <<" x= "<<x<<" ( f i x e d ) "<<s t d : : e n d l ;
9 s t d : : c o u t <<s t d : : s c i e n t i f i c
10 <<" x= "<<x<<" ( s c i e n t i f i c ) "<<s t d : : e n d l ;
11 return 0;
12 }

x= 89.7865 (defaut)
x= 89.786545 (fixed)
x= 8.978654e+01 (scientific)
Exemple : précisions d’affichage des réels
3 i n t main ( ) {
4 f l o a t x = 89.786543;
5
6 s t d : : c o u t <<" x= "<<x<<" ( d e f a u t ) "<<s t d : : e n d l ;
7 s t d : : c o u t <<s t d : : s e t p r e c i s i o n ( 2 )
8 <<" x= "<<x<<" ( p r e c i s i o n 2 ) "<<s t d : : e n d l ;
9 s t d : : c o u t <<s t d : : s e t p r e c i s i o n ( 1 2 )
10 <<" x= "<<x<<" ( p r e c i s i o n 1 2 ) "<<s t d : : e n d l ;
11 return 0;
12 }

x= 89.7865 (defaut)
x= 90 (precision 2)
x= 89.7865447998 (precision 12)
Instructions
Plan

Les constantes
Les variables
Opérateurs
Instructions
Instructions
Instructions
Un programme impératif est constitué d’une succession

d’instructions exécutées les unes après les autres.
Definition
Une instruction correspond à une étape atomique dans le
programme.
,→ toute instruction s’exécute complètement.
En C++, une instruction est terminée par un point-virgule.
Exemple
int a=3,c ;
c=a+10 ;
Instructions
Bloc d’instructions
Definition
Un bloc d’instruction est constitué par un ensemble d’instructions
délimitées par des accolades
{ instr1; instr2; ...; instrn;}
Les blocs d’instruction peuvent être :

imbriqués : { instr1; { instr2; instr3;} }
disjoints : { instr1; instr2; } { instr3;instr4;} }
Remarque
La fonction main en C++ correspond au bloc d’instructions définis-
sant le programme.
Structures de contrôle
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
Intérêt des structures de contrôle
Contrôler l’exécution des instructions du programme :

,→ notion d’algorithmes
exécution conditionnelle (si alors sinon)
exécuter plusieurs fois les mêmes instructions (boucle pour)
exécuter des instructions tant que (boucle tant que)
Conditionnelles
Plan
Conditionnelles
La boucle ’Pour’
La boucle ’Tant que’
La boucle ’do while’
Erreurs classiques
Conditionnelles
if ... else
Definition
if (exp)
instr1
else
instr2
exp est une expression booléenne

instr1 et instr2 sont :
une instruction
un bloc d’instructions
Conditionnelles
Exemple: if ... else
Exemple
Déterminer si un entier est pair ou impair
2
3 i n t main ( ) {
4 int a ;
5 a= 1 7 ;
6 i f ( a%2 == 0 )
7 s t d : : c o u t << a << " e s t p a i r "<< s t d : : e n d l ;
8 else
9 s t d : : c o u t << a << " e s t i m p a i r "<< s t d : : e n d l ;
10 return 0;
11 }
Conditionnelles
Exemple: if ... else

Exemple
Déterminer le plus grand et le plus petit entre deux entiers
2 u s i n g namespace s t d ;
3
4 i n t main ( ) {
5 int a =17 , b =13 , min , max ;
6 i f ( a > b ){
7 max=a ;
8 min=b ;
9 }
10 else {
11 max=b ;
12 min=a ;
13 }
14 s t d : : c o u t << " l e min e s t "<<min
15 <<" l e max e s t " << max<<e n d l ;
16 return 0;
17 }
Conditionnelles
Conditionnelle à choix multiple : switch

Lorsqu’on a besoin de faire un choix parmi plus de 2 possibilités,
on peut
imbriquer des conditionnelles if .. else
1 unsigned i n t a ;
2 s t d : : c i n >>a ;
3 i f ( a==1)
4 s t d : : cout <<" a=1"<<s t d : : endl ;
5 e l s e i f ( a==2)
7 e l s e i f ( a==3)
9 else
10 s t d : : cout <<" a>3"<<s t d : : endl ;
faire une conditionnelle à choix multiple

Conditionnelles
Conditionnelle à choix multiple : switch
Choix multiple switch

exp est une expression à valeur
switch (exp) {
entière
case cst1:
instr1; break; cst1, ..., cstn sont des constantes
... entières
case cstn: instr1, ..., instrn, instrdefault
instrn; break; sont des suites d’instructions
default: Les instructions sont exécutées en
instrdefault; fonction de la valeur exp
}
Si la valeur de exp est une des constantes cst1,...,cstn on exécute

la suite d’intructions correspondante sinon on exécute instrdefault.
Conditionnelles
Exemple : switch
1 unsigned i n t a ;
2 s t d : : c i n >>a ;
3 switch ( a ){
4 case 1:
5 s t d : : c o u t <<" a=1"<<s t d : : endl ; break ;
6 case 2:
8 case 3:
10 default :
11 s t d : : c o u t <<" a>3"<<s t d : : endl ;
12 }
L’affichage sera
a=1 si la valeur de a est 1
a>3 si la valeur de a est différent de 1,2 ou 3
Plan
Conditionnelles
Erreurs classiques
Répétition d’instructions : la boucle pour
Intérêt : répéter un nombre de fois donné une même suite

d’instructions.
Exemple
calculer la somme des entiers entre 1 et 10
s :=0 ;
pour i de 1 à 10 faire
s :=s+i ;
fin pour ;
En C++, les boucles pour sont effectuées avec l’instruction for
L’instruction for
Definition
for (exp1; exp2; exp3)
instr
exp1 est une expression quelconque évaluée une seule fois au

début de la boucle
exp2 est une expression booléenne qui permet d’arrêter la
boucle
exp3 est une expression quelconque évaluée à chaque tour de
boucle (en dernier).
instr est une instruction ou un bloc d’instructions

L’instruction for
Definition
instr
exp1 est une expression quelconque évaluée une seule fois au

début de la boucle
On se sert de exp1 pour initialiser la variable de boucle.
Exemple
exp1 est remplacée par int i=1 ou i=1 si i est déjà déclaré.
L’instruction for
Definition
instr
exp2 est une expression booléenne

Si exp2 est :
vrai : la boucle for continue et on exécute instr
faux : on sort de la boucle for sans exécuter instr
Exemple
exp2 est remplacée par i<11
L’instruction for
Definition
instr
exp3 est une expression quelconque évaluée à chaque tour de

boucle (en dernier).
On sert de exp3 pour modifier la variable de boucle
(incrémentation ou décrémentation) :
Exemple
exp3 est remplacée par i=i+1 ou i++
L’instruction for : schéma d’exécution
Definition
instr
1 exp1
...
2 exp2 → on continue car exp2=true
3 instr
4 exp3
...
5 exp2 → sort de la boucle car exp2=false
L’instruction for : exemple 1

Exemple
2 u s i n g namespace s t d ;
3
4 i n t main ( ) {
5
6 int i , s ;
7 s =0;
8 f o r ( i =1; i <11; i ++) // i++ e s t é q u i v a l e n t à i=i +1
9 s=s+i ;
10
11 s t d : : c o u t <<" l a somme e s t "<<s<<s t d : : e n d l ;
12 return 0;
13 }
ce programme affiche : la somme est 55

L’instruction for : exemple 2
Exemple
afficher les entiers entre 1 et 10 qui sont multiples de 2 ou de 3
2
3 i n t main ( ) {
4 int i ;
5 f o r ( i =1; i <11; i ++){
6 i f ( i %2==0 | | i %3==0)
7 s t d : : c o u t << i << " " ;
8 }
9 s t d : : c o u t << s t d : : e n d l ;
10 return 0;
11 }
ce programme affiche : 2 3 4 6 8 9 10
L’instruction for : ce qu’il ne faut pas faire
Attention aux boucles qui ne se terminent jamais ! ! !

les boucles infinies ...
1 int i , s ;
2 s =0;
3 f o r ( i =1 ; i <11 ; s=s+i )
4 ...
→ la variable de boucle n’est pas incrémentée
1 int i , s ;
2 f o r ( i =1 ; i !=10 ; i +=2)
3 ...
→ la condition d’arrêt de la boucle n’est jamais atteinte

Plan
Conditionnelles
Erreurs classiques
Répétition d’instructions : la boucle tant que
Intérêt : répéter une instruction tant qu’une condition est vérifiée
Exemple
s :=0 ;
i :=1 ;
tant que i<11 faire
s :=s+i ;
i :=i+1 ;
fin tant que ;
En C++, les boucles tant que se font avec l’instruction while

L’instruction while
Definition
while (exp)
instr
exp est une expression booléenne permettant de contrôler la

boucle
instr est une instruction ou un bloc d’instructions
L’instruction while
Definition
while (exp)
instr
exp est une expression booléenne permettant de contrôler la

boucle
Si exp est :
vrai : la boucle while continue et on exécute instr
faux : on sort de la boucle while sans exécuter instr
ex : exp est remplacée par i<11

L’instruction while : schéma d’exécution
Definition
while (exp)
instr;
1 exp → on rentre dans la boucle car exp=true

2 instr
...
3 exp → on continue car exp=true
4 instr
...
5 exp → on sort de la boucle car exp=false
...
L’instruction while : exemple 1

Exemple
2
3 i n t main ( ) {
4 int i , s ;
5 s =0;
6 i =1;
7 w h i l e ( i <11){
8 s=s+i ;
9 i ++; // on p e u t a u s s i é c r i r e i=i +1
10 }
11 s t d : : c o u t << " l a somme e s t "<< s<< s t d : : e n d l ;
12 return 0;
13 }
ce programme affiche : la somme est 55


Exemple
afficher les entiers entre 1 et 10 qui sont multiples de 2 ou de 3
2
3 i n t main ( ) {
4 int i ;
5 i =1;
6 w h i l e ( i <11){
7 i f ( i %2==0 | | i %3==0)
8 s t d : : c o u t << i << " " ;
9 i ++;
10 }
11 s t d : : c o u t << s t d : : e n d l ;
12 return 0;
13 }
ce programme affiche : 2 3 4 6 8 9 10
Exemple
calcul de la plus petite puissance de 2 supérieure à un entier
2
3 i n t main ( ) {
4 int a ,p;
5 a =27;
6 p =1;
7 w h i l e ( p<a ) {
8 p=2∗p ;
9 }
10 s t d : : c o u t << p << " e s t s u p é r i e u r à "<< a<<s t d : : e n d l ;
11 return 0;
12 }
ce programme affiche : 32 est supérieur à 27

Plan
Conditionnelles
Erreurs classiques
L’instruction do while
Parfois, il est souhaitable d’exécuter le corps de boucle avant la

condition de boucle (instr avant exp).
Dans ce cas, on peut utiliser l’instruction do {} while;
Definition
do {
instr;
} while (exp);
instr et exp sont identiques à ceux utilisés dans la boucle

while classique
RAPPEL : schéma d’exécution du while
Definition
while (exp)
instr
1 exp → sort de la boucle si exp=false

2 instr
...
4 instr
...
6 instr
...
L’instruction do{} while : schéma d’exécution

Definition
do {
instr;
}
while (exp);
1 instr
...
3 instr
...
5 instr
...
L’instruction do{} while : exemple

calculer le plus grand entier tel que son carré est inférieur à un
entier x.
2
3 i n t main ( ) {
4 int i , s , x ;
5 x =1000;
6 i =0;
7 do {
8 i ++;
9 s=i ∗ i ;
10 } w h i l e ( s <= x ) ;
11 i=i −1;
12 s t d : : c o u t << " l ’ e n t i e r e s t "<<i <<s t d : : e n d l ;
13 return 0;
14 }
ce programme affiche : l’entier est 31

Erreurs classiques
Plan
Conditionnelles
Erreurs classiques
Erreurs classiques
Structures de contrôle : erreur classique
L’erreur classique avec les structures de contrôle est l’oubli

d’accolade pour définir un bloc d’instructions :
1 ...
2 i f ( a > b ){
3 max=a ;
4 min=b ;
5 }
6 else
7 max=b ;
8 min=a ; // ATTENTION : n ’ a p p a r t i e n t p a s au e l s e
9
11 <<" l e max e s t " << max<<s t d : : e n d l ;
12 ...
Erreurs classiques

d’accolade pour définir un bloc d’instructions :
1 ...
2 i f (a > b)
3 max=a ;
4 min=b ;
5 else {
6 max=b ;
7 min=a ; // g r â c e aux a c c o l a d e s a p p a r t i e n t au e l s e
8 }
10 <<" l e max e s t " << max<<s t d : : e n d l ;
11 ...
L’oubli des accolades sur le bloc du if génère une erreur de

compilation car le else se retrouve isolé.
Erreurs classiques

d’accolade pour définir un bloc d’instruction :
1 ...
2 int i , s ;
3 s =0;
4 i =1;
5 w h i l e ( i <11)
6 s=s+i ;
7 i ++; // n ’ a p p a r t i e n t p a s à l a b o u c l e
8
9 s t d : : c o u t << " l a somme e s t "<< s<<s t d : : e n d l ;
10 ...
Erreurs classiques

d’accolade pour définir un bloc d’instruction :
1 ...
2 int i , s ;
3 s =0;
4 i =1;
5 w h i l e ( i <11){
6 s=s+i ;
7 i ++; // g r â c e aux a c c o l a d e s a p p a r t i e n t à l a b o u c l e
8 }
9 s t d : : c o u t << " l a somme e s t "<< s<<s t d : : e n d l ;
10 ...
Les bases du C++
Récapitulatif
les variables ont un type (ex : int, float, bool)
on peut calculer grâce aux opérateurs (+,*,%,...)
on modifie un programme par des affectations (ex : a=6 )
faiblement typé → conversions de type implicite
on affiche les valeurs à l’écran avec std::cout«
on saisit les valeurs au clavier avec std::cin»
on peut écrire des algorithmes avec les structures de contrôle

classiques : if else, for, while, switch
Fonctions
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
Fonctions
Introduction
Plan
4 Fonctions
Introduction
Définition
Appel d’une fonction
Portée des variables
Définir des constantes
Où placer les fonctions
Récursivité
Fonctions
Introduction
A quoi sert une fonction
Les fonctions servent à partitionner les gros traitements en

traitements plus petits.
Elle permettent de définir des briques de calcul qui sont :

identifiables facilement,
conçues pour faire un traitement précis,
réutilisables.
Remarque
Les programmes sont plus lisibles et donc plus faciles à maintenir.
Fonctions
Introduction
Fonction : une brique de calcul paramétrée

On veut écrire un programme qui affiche la décomposition en
facteurs premiers d’un nombre entier.
1 i n t main ( ) {
2 int x ,y , i , k ;
3 s t d : : c o u t <<" d o n n e z une e n t i e r "<<s t d : : e n d l ;
4 s t d : : c i n >>x ;
5 y=x ; i =2;
6 w h i l e ( x>=i ) {
7 i f ( i e s t p r e m i e r && ( x%i ==0)){
8 // c a l c u l p l u s g r a n d e p u i s s a n c e k de i divisant x
9 s t d : : c o u t <<i <<" p u i s s a n c e "<<k<<
10 <<" d i v i s e "<<y<<s t d : : e n d l ;
11 // on c a l c u l e d= i ^ k
12 x= x /d ;
13 }
14 i ++;
15 }
16 return 0;
17 }
Fonctions
Introduction
Deux solutions :
7 on complète le code directement par les instructions de calcul

correspondantes.
3 on complète le code par l’appel à trois briques de calcul
paramétrées.
1 bool p r emie r ( unsigned i n t n ){

2 i f ( n ==0|| n==1) r e t u r n f a l s e ;
3 e l s e i f ( n==2) return true ;
4 else {
5 f o r ( u n s i g n e d i n t i =2; i ∗ i <=n ; i ++)
6 i f ( n%i ==0) r e t u r n f a l s e ;
7 }
8 return true ;
9 }
Fonctions
Introduction
1 i n t p u i s s a n c e I n f ( i n t i , i n t x ){
2 i n t j =1; i n t p=i ;
3 w h i l e ( p<=x && ( x%p==0)){
4 j ++;
5 p∗= i ;
6 }
7 r e t u r n j −1;
8 }
1 i n t p u i s s a n c e ( i n t x , i n t n ){
2 int j ; int p = 1;
3 f o r ( j =1; j <=n ; j ++)
4 p∗=x ;
5 return p ;
6 }
Fonctions
Introduction
Le programme s’écrit donc :

1 i n t main ( ) {
2 int x ,y , i , k ;
3 s t d : : c o u t <<" d o n n e z une e n t i e r "<<s t d : : e n d l ;
4 s t d : : c i n >>x ;
5 y=x ; i =2;
6 w h i l e ( x>=i ) {
7 i f ( p r e m i e r ( i ) && ( x%i ==0)){
8 k=p u i s s a n c e I n f ( i , x ) ;
9 s t d : : c o u t <<i <<" p u i s s a n c e "<<k<<
10 <<" d i v i s e "<<y<<s t d : : e n d l ;
11 x= x / p u i s s a n c e ( i , k ) ;
12 }
13 i ++;
14 }
15 return 0;
16 }
Fonctions
Introduction
Qu’est-ce qu’une fonction
Definition
Une fonction est une description formelle d’un calcul en fonction
de ses arguments
Exemple
Si on vous donne deux variables entières a et b décrivez les
instructions du langage nécessaire pour calculer ab .
→ cela rejoint la notion d’algorithme

Fonctions
Introduction
Qu’est-ce qu’une fonction
Comme en algorithmique, une fonction comportera :

un nom (l’identifiant de manière non-ambigu),
des paramètres d’entrées,
des paramètres de sortie,
des variables locales,
une description dans le langage de ce que fait la fonction.
Fonctions
Définition
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Définition
Définition de fonctions
Definition
type_retour nom(liste_param_formel){
corps
}
nom correspond au nom donné à la fonction
type_retour est le type du résultat de la fonction
liste_param_formel est la liste des variables d’entrée de la

fonction
corps correspondant aux instructions effectuées par la

fonction en fonction des paramètres formels.
Fonctions
Définition
Fonctions : nom
Definition
Le nom d’une fonction correspond à un identifiant unique
permettant d’effectuer l’appel sans aucune ambiguïté
Attention
Une fonction ne peut être assimilée à une variable et vice-versa. On
les différencie par la présence de parenthèse après l’identifiant d’une
fonction.
1 int a ();
2 a =3; // ERREUR ’ a ’ n ’ e s t p a s une v a r i a b l e
3 int b;
4 b ( ) ; // ERREUR ’ b ’ n ’ e s t p a s une f o n c t i o n
Fonctions
Définition
Fonctions : nom
Attention
Une variable et une fonction ne peuvent pas partager le même nom
au sein d’un même bloc.
1 {
2 i n t a ( ) ; // d é c l a r a t i o n f o n c t i o n
3 i n t a ; // d é c l a r a t i o n v a r i a b l e
4 }
Le compilateur générera l’erreur suivante :

erreur : int a redeclared as different kind of symbol
erreur : previous declaration of int a()
Fonctions
Définition
Fonctions : type de retour
Les fonctions ne possèdent qu’un seul paramètre de sortie.

Ce paramètre :
n’est pas identifié par une variable particulière
est spécifié uniquement par son type
1 int f (); // f r e n v o i e un r é s u l t a t e n t i e r
2 double g ( ) ; // g r e n v o i e un r é s u l t a t f l o t t a n t
Si la fonction ne renvoie rien, on utilise le type void.

ex : void h();
Fonctions
Définition
Fonctions : paramètres formels
La liste des paramètres formels d’une fonction est :

vide si la fonction n’a aucun paramètre
de la forme : type1 p1 , ... , typen pn
La déclaration des variables formelles (typei pi ) est de la forme :

type p pour une variable p simple
... (à voir plus loin dans le cours)
où type est un type de base et p est le nom de la variable formelle

manipulable dans la fonction.
Fonctions
Définition
Fonctions : paramètres formels
Les paramètres formels d’une fonction permettent :

de définir le code de la fonction à partir de données inconnues.
de transmettre (lors de l’appel) les données réelles sur
lesquelles doit agir la fonction.
Ils ne sont connus que dans le bloc associé à la fonction.

1 int f ( int a , int b ){...}
2 void g ( double a ) { . . . }
3 a =12; // e r r e u r a n ’ e s t p a s d é c l a r é
Fonctions
Définition
Fonctions : corps
Definition
Le corps d’une fonction est le bloc défini juste après la déclaration
de l’interface de la fonction :
type_retour nom(liste_param_formel)
{ corps }
Le corps d’une fonction est composé :

de la déclaration des variables locales
de la description du code qui sera exécuté par la fonction
1 i n t p l u s ( i n t x , i n t y ){
2 int z ;
3 z=x+y ;
4 return z ;
5 }
Fonctions
Définition
Fonction : le mot clé return
Definition
Dans une fonction, le mot clé return exp permet :
d’arrêter l’exécution du corps
de renvoyer la valeur de l’expression exp au bloc appelant
Attention
La valeur de exp doit être du même type que le type de retour de la
fonction (sinon conversion implicite)
1 dou bl e i n v e r s e ( i n t x ) {
2 r e t u r n 1/ x ;
3 }
Fonctions
Définition
Le mot clé return peut apparaître plusieurs fois dans une même
fonction. C’est le premier return rencontré qui stoppera le corps
de la fonction (ex : conditionnelle).
1 i n t i m p a i r ( i n t x ){
2 i f ( x%2 == 0 )
3 return 0;
4 else
5 return 1;
6 }
Fonctions
Définition
Le mot clé return n’est pas obligatoire lorsque le retour de la

fonction est void. La fonction s’arrête dès qu’elle atteint la fin du
bloc.
1 void bonjour (){

2 s t d : : cout <<" B o n j o u r "<<s t d : : e n d l ;
3 }
Fonctions
Définition
On peut toutefois forcer l’arrêt en appelant return sans

expression.
1 void bonjour ( i n t heure ){
2 i f ( h e u r e > 8 && h e u r e < 2 0 ) {
4 return ;
5 }
6 s t d : : cout <<" B o n s o i r "<<s t d : : e n d l ;
7 }
Fonctions
Définition
Fonctions : pas d’amalgame
ATTENTION
La déclaration d’une fonction est une description formelle d’un cal-
cul, elle n’exécute rien toute seule : il faut appeler la fonction pour
que les instructions du corps soient exécutées.
1 void bonjour (){

3 }
Ce code ne fait que déclarer une fonction, il n’affichera rien à

l’écran.
,→ c’est l’instruction bonjour(); dans le programme qui
exécutera ce code.
Fonctions
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Appel de fonction
Definition
var = nom(liste des paramètres effectifs);
ou
nom(liste des paramètres effectifs);
la liste des paramètres effectifs correspond à l’ensemble des

variables et des constantes que l’on souhaite donner comme
argument à la fonction. ex : max(2,3).
Attention : le passage des arguments se fait par copie.

la valeur des paramètres effectifs est copiée dans les variables
formelles correspondantes.
Fonctions
Appel de fonction : exemple
2
3 i n t max ( i n t a , i n t b ) {
4 i f ( a>b ) r e t u r n a ;
5 else return b ;
6 }
7 i n t main ( ) {
8 int x , y ;
9 x =3;
10 y =5;
11 s t d : : cout <<" l e max e s t : "<<max ( x , y)<< s t d : : e n d l ;
12 return 0;
13 }
Fonctions
Fonction : passage de paramètres par valeur
Les paramètres d’une fonction sont toujours initialisés par une

copie des valeurs des paramètres réels.
Modifier la valeur des paramètres formels dans le corps de la
fonction ne change en aucun cas la valeur des paramètres réels.
1 v oi d ech ( i n t x , i n t y ){
2 int r ;
3 r=x ; x=y ; y=r ;
4 }
5 i n t main ( ) {
6 int a ,b;
7 a =17; b =13;
8 s t d <<c o u t <<" a = "<<a<<" b = "<<b<<s t d : : e n d l ;
9 e c h ( a , b ) ; // ne c h a n g e p a s l a v a l e u r de a e t de b
10 s t d <<c o u t <<" a = "<<a<<" b = "<<b<<s t d : : e n d l ;
11 }
Fonctions

main() ech()
a 17
b 13
appel de la fonction ech(a,b)
a = 17 b = 13
Fonctions

main() ech()
a 17 x 17
b 13 y 13
a = 17 b = 13 x= 17 y= 13
Fonctions

main() ech()
a 17 x 13
b 13 y 17
appel de la fonction ech(a,b) exécution du code
a = 17 b = 13 x= 13 y= 17
Fonctions

main() ech()
a 17
b 13
fin de la fonction et retour au bloc appelant
a = 17 b = 13
Fonctions
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Où utiliser une variable ?
Question
Quand on déclare une variable, où est-elle connue ?
où peut-on l’utiliser ?
Réponse
Dans tout le bloc où elle a été déclarée et à partir de sa déclaration.
Fonctions
Portée d’une variable
Definition
On appelle Portée d’une variable, la portion du code où cette
variable est connue et utilisable.
Fonctions
Exemple 1
Quelles sont les portées de a et de x ?

1 i n t main ( )
2 {
3 int a ;
4 float x ;
5 ...
6 ...
7 return 0;
8 }
Fonctions
Exemple 1
Quelles sont les portées de a et de x ?

1 i n t main ( )
2 { <−− d é b u t du b l o c
3 int a ; <−− d é b u t de l a p o r t é e de a
4 float x ; <−− d é b u t de l a p o r t é e de x
5 ...
6 ... <−− u t i l i s a t i o n p o s s i b l e de a e t x
7 return 0;
8 } <−− f i n de b l o c e t de p o r t é e de a e t x
Fonctions
Exemple 2
Est-ce que l’utilisation de a et de x est conforme à leur portée ?

1 i n t main ( )
2 {
3 i n t a =3;
4 x =2./ a ;
5 float x ;
6 s t d : : cout <<" a = "<<a<<" x = "<<x<<s t d : : e n d l ;
7 return 0;
8 }
Fonctions
Exemple 2
Est-ce que l’utilisation de a et de x est conforme à leur portée ?

1 i n t main ( )
2 {
3 i n t a =3; <−− d é b u t p o r t é e de a
4 x =2./ a ; <−− on p e u t u t i l i s e r a m a i s p a s x
5 float x ; <−− d é b u t p o r t é e de x
7 return 0;
8 }
Fonctions
Exemple 2
2 i n t main ( )
3 {
4 i n t a =3;
5 x =2./ a ;
6 float x ;
8 return 0;
9 }
Le compilateur vous affiche alors le message suivant :

exemple2.c :4 error : x was not declared in this scope )
Fonctions
Portée d’une variable
Definition
On appelle Portée d’une variable, la portion du code où cette
variable est connue et utilisable.
Remarque
Dans le cas de blocs imbriqués, une variable est utilisable dans tout
le bloc où elle a été déclarée, à partir de sa déclaration et également
dans les blocs internes au bloc de la déclaration.
Fonctions
Exemple
1 i n t main ( ) {
2 int i ;
3 f o r ( i =0; i <10; i ++){
4 int S;
5 S=2∗ i ∗ i −1;
6 s t d : : cout <<" S="<<S<<s t d : : e n d l ;
7 }
8 return 0;
9 }
Fonctions
Exemple
1 i n t main ( ) {
2 int i ; <−− d é b u t p o r t é e de i
3 f o r ( i =0; i <10; i ++){
4 int S; <−− d é b u t p o r t é e de S
5 S=2∗ i ∗ i −1;
7 } <−− f i n p o r t é e S
8 return 0;
9 } <−− f i n p o r t é e i
Fonctions
Exemple
1 i n t main ( ) {
2 int i ;
3 f o r ( i =0; i <10; i ++){
4 int S;
5 S=2∗ i ∗ i −1;
7 }
8 s t d : : cout <<" S="<<S<<s t d : : e n d l ; <−− i m p o s s i b l e
9 return 0;
10 }
Fonctions
Plusieurs variables ?
Question
Que se passe-t-il si on a plusieurs variables de même nom ?
Réponse
7 Impossible si les variables sont définies dans le même bloc
3 Possible si les variables sont définies dans des blocs différents
,→ même si ils sont imbriqués
Fonctions
Exemple
Qu’affiche le code suivant ?

1 i n t main ( ) {
2 i n t a =3;
3 {
4 i n t a =5;
5 s t d : : cout <<" a="<<a<<s t d : : e n d l ;
6 }
7 return 0;
8 }
Fonctions
Exemple
Qu’affiche le code suivant ?

1 i n t main ( ) {
2 i n t a =3;
3 {
4 i n t a =5;
6 }
7 return 0;
8 }
Le programme affiche :
a=5
Fonctions
Question
Que se passe-t-il si on a plusieurs variables de même nom ?
Réponse
La variable utilisée est celle du bloc englobant le plus proche (au
sens de l’inclusion).
Fonctions
Question
Et dans le cas de fonctions ?
1 f l o a t cube ( f l o a t x ) {
2 f l o a t c=x ∗ x ∗ x ;
3 return c ;
4 }
5 i n t main ( ) {
6 float c ;
7 c=cube ( 2 ) ;
8 s t d : : cout <<" l e cube de 2 e s t "<<c<<s t d : : e n d l ;
9 return 0;
10 }
Fonctions
Question
Et dans le cas de fonctions ?
Il n’y a pas de problème : la portée d’une variable étant le bloc où

elle a été déclarée, la variable n’existe qu’à l’intérieur de la fonction.
Réponse
Tout ce qui a été dit précédemment s’applique pour les fonctions.
Fonctions
Plusieurs variables : continuons
Question
Comment fait-on si on veut tout de même utiliser la même variable
dans plusieurs fonctions ?"
Réponse
Rien de plus facile, on passe la variable en paramètre ! ! !
Fonctions
Plusieurs variables : continuons
Remarque
Il peut être parfois embêtant de rajouter une variable à toutes les
fonctions, si celles-ci doivent partager une variable commune.
Une solution :
Il est possible de définir des variables communes à tout le monde :
les variables globales.
Fonctions
Variables globales
Definition
Une variable est globale si elle est définie en dehors de tout bloc
(et donc de toute fonction).
Question
La portée d’une variable étant son bloc, quelle est la portée d’une
variable globale ?
Fonctions
Variables globales
Une variable globale est connue dans toute la partie du fichier qui
suit sa déclaration.
1 void u n e a u t r e f o n c t i o n (){
2 // ne p e u t p a s u t i l i s e r a
3 }
4
5 int a ;
6
7 void mafonction (){
8 // p e u t u t i l i s e r l a v a r i a b l e a
9 }
10
11 i n t main ( ) {
12 // p e u t u t i l i s e r la variable a
13 return 0;
14 }
Fonctions
Variables globales : c’est dangereux !
Qu’affiche le code suivant :

1 int i ;
2
3 v o i d cou co u ( ) {
4 f o r ( i =0; i <3; i ++)
5 s t d : : cout <<" coucou "<<i <<" f o i s "<<s t d : : e n d l ;
6 }
7
8 i n t main ( ) {
9 f o r ( i =0; i <3; i ++)
10 c ou co u ( ) ;
11 return 0;
12 }
Fonctions
Variables globales : c’est dangereux !
On a 3 appels à la fonction coucou(). Chaque exécution de cette

fonction devrait afficher 3 messages. On s’attend donc à 9
messages. Au lieu de cela, nous obtenons :
coucou 0 fois
coucou 1 fois
coucou 2 fois
Fonctions
Pourquoi c’est dangereux !
Voilà l’exécution du programme :

main : i=0
main : appel de coucou()
coucou : i=0
coucou : affiche "coucou 0 fois"
coucou : i=1
coucou : i=2
coucou : i=3
coucou : i<3 ? faux, on sort de la fonction
main : retour dans le main, i est toujours égal à 3
main : i<3 ? faux on quitte le programme
Fonctions
Pourquoi c’est dangereux !
Conclusion :
C’est une très mauvaise idée de modifier une variable globale.
Mais alors quoi ? les variables globales restent constantes ?
Pire que ça ! On oublie les variables globales et on définit des
constantes.
Fonctions
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Définir une constante
Pour définir une constante, il est possible de définir une macro en

tête du programme.
Syntaxe
#define NOM valeur
Exemple
#define MAX 1000
#define PI 3.1415
Remarque : par convention, les macros sont notées en majuscules.
Fonctions
Exemple
3
4 #d e f i n e MAX 10
5 void p r o d u i t ( i n t a ){
6 int i ;
7 f o r ( i =1; i <=MAX; i ++)
8 s t d : : cout <<s t d : : s e t w (4)<<a ∗ i ;
9 }
10 i n t main ( ) {
11 int i ;
12 f o r ( i =1; i <=MAX; i ++){
13 produit ( i );
14 s t d : : cout <<s t d : : e n d l ;
15 }
16 return 0;
17 }
Fonctions
Exemple
On obtient alors :
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Fonctions
Définir une constante
Pour définir une constante, il est aussi possible de définir des

variables globales constantes.
Syntaxe
const type nom=valeur;
Exemple
const int max=10;
const double pi=3.1415;
Fonctions
Exemple
2 c o n s t i n t max=10;
3 void p r o d u i t ( i n t a ){
4 int i ;
5 f o r ( i =1; i <=max ; i ++)
6 s t d : : cout <<s t d : : s e t w (4)<<a ∗ i ;
7 }
8 i n t main ( ) {
9 int i ;
10 f o r ( i =1; i <=max ; i ++){
11 produit ( i );
12 s t d : : cout <<s t d : : e n d l ;
13 }
14 return 0;
15 }
Fonctions
Exemple
On obtient alors :
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
Fonctions
Peut-on modifier une constante ?
1 c o n s t i n t max=10;
2 i n t main ( ) {
3 max=11;
4 return 0;
5 }
Le compilateur affiche l’erreur suivante :

exemple.c :3 : error : assignment of read-only variable ’max’
Fonctions
Différence entre MACRO et variables constantes
Variable constante
C’est une vraie variable, avec un espace mémoire réservé. Le
compilateur interdit juste de la modifier.
Macro
Ce n’est pas une variable. Il n’y a pas d’espace mémoire allouée
pour. Au moment de la compilation, le compilateur commence par
remplacer toutes les occurrences des macros par leurs valeurs, puis
compile le nouveau fichier obtenu.
Fonctions
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Portée des fonctions
Question
Quand on déclare une fonction, à quel endroit peut-on l’utiliser ?
Réponse
Partout après sa déclaration !
Autrement dit, si une fonction f1 appelle une fonction f2, la

déclaration de f2 doit se situer avant la fonction f1.
Fonctions
Exemple
1 void f1 (){
2 s t d : : cout <<" j e s u i s f 1 "<<s t d : : e n d l ;
3 }
4 void f2 (){
5 s t d : : cout <<" j e s u i s f 2 e t j e peux me s e r v i r de f 1 "
6 <<s t d : : e n d l ;
7 f1 ( ) ;
8 }
9 i n t main ( ) {
10 f 1 ( ) ; // j e peux me s e r v i r de f 1
11 f 2 ( ) ; // j e peux me s e r v i r de f 2
12 }
Il faut donc déclarer les fonctions par rapport à l’ordre dans lequel
elles seront utilisées.
Fonctions
Problème
On souhaite définir ces deux fonctions :
si n = 0
(
vrai
pair (n) =
impair (n − 1) sinon
et
si n = 0
(
faux
impair (n) =
pair (n − 1) sinon
Quelle est la fonction qui se place avant l’autre ?
Fonctions
Problème
On souhaite définir ces deux fonctions :
si n = 0
(
vrai
pair (n) =
impair (n − 1) sinon
et
si n = 0
(
faux
impair (n) =
pair (n − 1) sinon
Quelle est la fonction qui se place avant l’autre ?
Aucune, elles sont inter-dépendantes ! ! !

Fonctions
Comment faire ?
Solution
On peut séparer la déclaration de la définition d’une fonction.
Dans le corps de la définition d’une fonction, je peux utiliser

n’importe quelle fonction qui aura été déclarée précédemment
(mais pas forcément définie).
Remarque
Rappelez-vous, on avait dit qu’il était possible d’utiliser une fonction
n’importe où après sa déclaration...
Fonctions
Comment faire ?
La déclaration de la fonction consiste à donner la signature de la

fonction, c’est-à-dire son type de retour et le type de chacun de ses
paramètres.
Syntaxe
type nom(type,type,...,type);
Exemple
bool pair(int);
bool impair(int);
Fonctions
Exemple
1 bool p a i r ( i n t ) ;
2 bool i m p a i r ( i n t ) ;
3
4 bool p a i r ( i n t n ){
5 i f ( n==0) r e t u r n t r u e ;
6 else r e t u r n i m p a i r ( n −1);
7 }
8
9 bool i m p a i r ( i n t n ){
10 i f ( n==0) r e t u r n f a l s e ;
11 else r e t u r n p a i r ( n −1);
12 }
Fonctions
Structure d’un fichier
1 /∗ Début d é c l a r a t i o n s d e s f o n c t i o n s ∗/
3 ...
4 ...
5 /∗ F i n d é c l a r a t i o n s d e s f o n c t i o n s ∗/
6
7 /∗ Début d é f i n i t i o n s d e s f o n c t i o n s ∗/
9 i f ( n==0) r e t u r n t r u e ;
10 e l s e r e t u r n i m p a i r ( n −1);
11 }
12 ...
13 ...
14 /∗ F i n d é f i n i t i o n s d e s f o n c t i o n s ∗/
15
16 i n t main ( ) {
17 ....
18 return 0;
19 }
Fonctions
Programmation modulaire
Remarque
Il est possible de scinder son programme (toutes les fonctions qui le
composent) en plusieurs fichiers. On parle alors de programmation
modulaire.
Dans les faits, il s’agit de mettre dans un fichier les signatures des
fonctions et dans un autre les définitions. Tout programme qui
voudra utiliser une des ces fonctions devra seulement inclure le
fichier des signatures.
Fonctions
Fichier d’en-tête
Definition
Un fichier d’en-tête (ex : fonction.h) contient des déclarations
de fonctions.
Exemple
4 ...
Fonctions
Fichier de définition
Definition
Un fichier de définition (ex : fonction.cpp) contient les
définitions des fonctions déclarées dans fonction.h.
Remarque
Les deux noms de fichiers doivent être les mêmes (toto.h et
toto.cpp).
Fonctions
Mise en oeuvre
Dans le fichier de définition, il faut inclure le fichier de déclarations.
Syntaxe
#include "fonction.h"
1 #i n c l u d e " f o n c t i o n . h "
2 /∗ Début d é f i n i t i o n s d e s f o n c t i o n s ∗/
4 i f ( n==0) r e t u r n t r u e ;
5 e l s e r e t u r n i m p a i r ( n −1);
6 }
7
8 bool i m p a i r ( i n t n ){
9 i f ( n==0) r e t u r n f a l s e ;
10 e l s e r e t u r n p a i r ( n −1);
11 }
12 ...
13 /∗ F i n d é f i n i t i o n s d e s f o n c t i o n s ∗/
Fonctions
Problème d’inclusion multiple
Si le fichier d’en-tête est inclus plusieurs fois, cela va provoquer

une erreur (redéclaration de fonction). Pour éviter cela, il existe
des directives pour n’inclure dans un projet qu’une seule fois un
ensemble de déclarations.
1 #i f n d e f FONCTIONS_H
2 #d e f i n e FONCTIONS_H
3
7 ...
9 #e n d i f
Fonctions
Récursivité
Plan
4 Fonctions
Introduction
Définition
Récursivité
Fonctions
Récursivité
Fonction récursive
Definition
Une fonction est récursive si elle s’appelle elle-même.
Mise en oeuvre implicite

Rendu possible car une fonction est utilisable dès qu’on a spécifié
sa signature, ce qui est le cas dans le blocs de définition d’une
fonction.
Fonctions
Récursivité
Étude d’un cas simple
Considérons le problème suivant :

On veut calculer la somme des carrés des entiers compris dans
un intervalle (entre m et n).
Par exemple,
SommeCarres(5,10)=52 + 62 + 72 + 82 + 92 + 102 .
Fonctions
Récursivité
Première solution
2 i n t SommeCarres ( i n t m, i n t n ) {
3 i n t i , som=0;
4 f o r ( i=m; i <=n ; i ++)
5 som=som+i ∗ i ;
6 r e t u r n som ;
7 }
8 i n t main ( ) {
9 i n t m=5 , n =10;
10 i n t s c=SommeCarres ( 5 , 1 0 ) ;
11 s t d : : cout <<" C a r r e s e n t r e 5 e t 10 : "<< sc<<s t d : : e n d l ;
12 return 0;
13 }
Fonctions
Récursivité
Vision récursive du problème
S’il y a plus d’un nombre dans [m..n], on ajoute le carré de m

à la somme des carrés de [m+1..n]
S’il n’y a qu’un nombre (m=n), le résultat est le carré de m
Mathématiquement,
m ∗ m + SommeCarres(m + 1, n) si m 6= n
(
SommeCarres(m, n) =
m∗m sinon
Fonctions
Récursivité
Solution récursive
2 i n t SommeCarres ( i n t m, i n t n ) {
3 i f (m==n )
4 r e t u r n m∗m;
5 else
6 r e t u r n (m∗m+SommeCarres (m+1,n ) ) ;
7 }
8 i n t main ( ) {
9 i n t s c=SommeCarres ( 5 , 9 ) ;
10 s t d : : cout <<"somme d e s c a r r e s e n t r e 5 e t 9 : "
11 << sc <<s t d : : e n d l ;
12 return 0;
13 }
Fonctions
Récursivité
Trace des appels
SommeCarres(5, 9) = 25 + SommeCarres(6, 9)
= 25 + (36 + SommeCarres(7, 9))
= 25 + (36 + (49 + SommeCarres(8, 9)))
= 25 + (36 + (49 + (64 + SommeCarres(9, 9))))
= 25 + (36 + (49 + (64 + 81)))
= 25 + (36 + (49 + 145))
= 25 + (36 + 194)
= 255
Fonctions
Récursivité
Principe de construction
Des instructions résolvant les cas particuliers,

Des instructions décomposant le problème en sous-problèmes,
Des appels récursifs résolvant les sous-problèmes,
Des instructions pour résoudre le problème à partir des
solutions des sous-problèmes.
Fonctions
Récursivité
Un autre problème
La suite de Fibonacci :
 F (0) = 1


F (1) = 1
 F (n + 2) = F (n + 1) + F (n)

Très facile à mettre en oeuvre !

Fonctions
Récursivité
Solution récursive
La version récursive est très proche de l’écriture mathématique :
1 i n t Fibo ( i n t n ){
2 i f ( n==0) l l ( n==1)
3 return 1;
4 else
5 r e t u r n F i b o ( n−1)+ F i b o ( n −2);
6 }
Fonctions
Récursivité
Exécution
89*%+&'#$
Certains termes sont calculés plusieurs fois :
"/21
53
"/01 "/!1
7 0
"/!1 "/31 "/31 "/41

0 3 3 4
"/31 "/41 "/41 "/51 "/41 "/51 "/51 "/61

3 4 4 5 4 5 5 5
"/41 "/51 "/51 "/61 "/51 "/61 "/51 "/61

4 5 5 5 5 5 5 5
"/51 "/61
5 5
Fonctions
Récursivité
Solution itérative
La solution itérative est moins intuitive :
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){
7 F=a+b ;
8 a=b ;
9 b=F ;
10 n−−;
11 }
12 return F ;
13 }
Fonctions
Récursivité
Solution itérative
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){ 2 1 2 5
7 F=a+b ;
8 a=b ;
9 b=F ;
10 n−−;
11 }
12 return F ;
13 }
Fonctions
Récursivité
Solution itérative
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){ 2 1 2 5
7 F=a+b ; 3 2 3 4
8 a=b ;
9 b=F ;
10 n−−;
11 }
12 return F ;
13 }
Fonctions
Récursivité
Solution itérative
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){ 2 1 2 5
7 F=a+b ; 3 2 3 4
a=b ;
5 3 5 3
8
9 b=F ;
10 n−−;
11 }
12 return F ;
13 }
Fonctions
Récursivité
Solution itérative
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){ 2 1 2 5
7 F=a+b ; 3 2 3 4
a=b ;
5 3 5 3
8
9 b=F ;
10 n−−; 8 5 8 2
11 }
12 return F ;
13 }
Fonctions
Récursivité
Solution itérative
2 int a ,b ,F;
F a b n
3
4 F=a=b =1;
5 1 1 1 6
6 w h i l e ( n >1){ 2 1 2 5
7 F=a+b ; 3 2 3 4
a=b ;
5 3 5 3
8
9 b=F ;
10 n−−; 8 5 8 2
11 } 13 8 13 1
12 return F ;
13 }
Fonctions
Récursivité
Récursivité ! ! !
Attention
La récursivité n’est pas toujours efficace, même si elle est plus facile
à exprimer.
Pointeurs
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
Pointeurs
Introduction
Plan
5 Pointeurs
Introduction
Les pointeurs en C++
Fonction avec paramètre de type pointeur
Pointeurs
Introduction
Variables et fonctions : une entente peu cordiale
Exemple
void echange(int a, int b){
int c;
c=a;
a=b;
b=c;
}
l’appel à la fonction echange sur des variables x et y n’effectue

pas l’effet attendu (échanger les valeurs).
→ paramètres toujours passés par copie dans les fonctions ! ! !
Pointeurs
Introduction
Passage des paramètres par copie
x 3 a 3 a 12
y 12 b 12 b 3
Appel à ech Exécution de ech
int x,y;
x=3;y=12;
echange(x,y);
Pointeurs
Introduction
x 3
y 12
x=3 y = 12
0xFF2246 0xFF2252
Pointeurs
Introduction
x 3 a 3
y 12 b 12
Appel à ech
x=3 y = 12 a= 3 b= 12
0xFF2246 0xFF2252
Pointeurs
Introduction
x 3 a 3 a 12
y 12 b 12 b 3
x=3 y = 12 a= 12 b= 3
0xFF2246 0xFF2252
Pointeurs
Introduction
x 3
y 12
Retour de ech
x=3 y = 12
0xFF2246 0xFF2252
Pointeurs
Introduction
Limitations des variables : telles qu’on les connait
Les variables :
ne peuvent pas être modifiées par les fonctions
sont limitées au bloc dans lequel elles ont été définies
Remarque
Ces limitations proviennent de la manipulation des variables par leur
identificateur.
Solution : manipuler les variables par leur adresse (pointeur)
,→ dire où se trouve la donnée plutôt que de donnez sa valeur !
Pointeurs
Plan
5 Pointeurs
Introduction
Pointeurs
Les pointeurs
Definition
Un pointeur est une variable qui contient l’adresse mémoire d’une
donnée (une autre variable).
Une variable dite pointeur est définie par

un identificateur : le nom du pointeur
un type de donnée : pour la donnée pointée
Remarque
Les pointeurs permettent de manipuler des données par leur adresse
plutôt que par leur identificateur.
Pointeurs
Les variables de type pointeur
Definition
type *var;
var est l’identificateur (le nom) du pointeur

type est le type de donnée de la donnée pointée
var doit contenir une adresse mémoire valide (pas une valeur)
Exemple
int *ptr;
définit la variable ptr comme une pointeur sur un entier.
→ ptr devra donc contenir l’adresse d’une donnée de type int.
Pointeurs
Les variables de type pointeur : Exemple

Déclaration de pointeurs :
1 i n t ∗ Aptr ;
2 double ∗ B p t r ;
3 i n t ∗ Cptr ;
Affectation de pointeurs :
1 i n t a ; double b ;
2
3 A p t r= &a ; // OK
4 B p t r= &b ; // OK
5 A p t r= &b ; // ERREUR
6 B p t r= &a ; // ERREUR
7
8 A p t r= B p t r ; // ERREUR
9 A p t r= C p t r ; // OK
Pointeurs
Les variables de type pointeur : Vue mémoire
int a = 8 float b = 3.2 int c =12
MÉMOIRE EN OCTETS
&a=0x22FF20 &b=0x22FF26 &c=0x22FF41

int* p = &a
a,b,c sont des variables normales (elles stockent des valeurs).

p est une variable dite pointeur (elle stocke une adresse).
p est de type int* et doit stocker l’adresse d’un entier (ici a).
Pointeurs
Les variables de type pointeur : Affectation
On peut affecter une variable pointeur avec :

l’adresse d’une variable existante compatible,
avec la valeur d’une autre pointeur compatible,
avec le pointeur vide (NULL ou nullptr en C++11),
Exemple
int a, *p, *q
p=&a;
q=NULL;
q=p;
NULL est défini dans <iostream> alors que nullptr nécessite

uniquement l’option de compilation -std=c++11
Pointeurs
Les variables de type pointeur : Accès aux données
Pour accéder à la zone mémoire pointée par un pointeur, il faut

utiliser l’opérateur prefixe de déréférencement *.
Definition
Soit var une variable de type pointeur, le déréférencement *var
permet d’accèder à la donnée qui est stockée à l’adresse mémoire
contenue dans var ,→ on parle de donnée pointée.
1 int a ;
2 int ∗ ptr ;
3 p t r=&a ; // a f f e c t e p t r a v e c l ’ a d r e s s e de a
4 ∗ p t r =3; // a f f e c t e l a z o n e mémoire d ’ a d r e s s e p t r
5 // a v e c l a v a l e u r 3 ( i c i a=3)
Pointeurs
Manipulation des données avec les pointeurs
Lorsqu’on déréférence une variable pointeur, on peut :

utiliser la valeur stockée dans la donnée pointée
modifier la valeur stockée dans la donnée pointée
Exemple
int a, *p;
a=10;p=&a;
a=*p+1;
*p=13;
Pointeurs
Les pointeurs : Exemple 1

2 i n t main ( ) {
3 i n t A, ∗ Aptr ;
4 A=150;
5 A p t r=&A ;
6 s t d : : c o u t <<" v a l = "<<A
7 <<" a d d r= "<<&A<<s t d : : e n d l ;
8 s t d : : c o u t <<" v a l = "<<A p t r
9 <<" a d d r= "<<&A p t r
10 <<" v a l p= "<<∗ A p t r<<s t d : : e n d l ;
11 A=99;
12 s t d : : c o u t <<" v a l = "<<A p t r
13 <<" a d d r= "<<&A p t r
15 ∗ A p t r =45;
16 s t d : : c o u t <<" v a l = "<<A p t r
17 <<" a d d r= "<<&A p t r
19 return 0;
20 }
Pointeurs
Les pointeurs : Exemple 2
Attention
Les pointeurs sont dangereux et cause des erreurs dites
de segmentation dans l’exécution des programmes.
1 i n t main ( ) {
2
3 i n t A, ∗ Aptr ;
4 A=100;
5 ∗ A p t r =17; // c e t t e l i g n e c o m p i l e c o r r e c t e m e n t
6 // m a i s c a u s e une e r r e u r a l ’ e x e c u t i o n
7 return 0;
8 }
Pointeurs
Plan
5 Pointeurs
Introduction
Pointeurs
Fonctions avec pointeurs
Definition
type_retour mafonction(type_param * ptr){...}
Dans la fonction, c’est une copie du pointeur qui est manipulée et

non pas le pointeur.
A l’intérieur de la fonction :
on peut récupérer la donnée pointée : *ptr
on peut modifier la valeur de la donnée pointée : *ptr=...
on ne peut pas modifier le pointeur : ptr=...

Pointeurs
Fonctions avec pointeurs : Exemple 1
2
3 v o i d p l u s U n ( i n t ∗p ) {
4 ∗p= ∗p +1;
5 }
6
7 i n t main ( ) {
8 int a ; int ∗ ptr ;
9 a =3; p t r=&a ;
10
11 plusUn ( p t r ) ;
13 p l u s U n (&a ) ;
15
16 return 0;
17 }
Pointeurs
a=3
ptr
Main( ) plusUn( )
Pointeurs
a=3
ptr p
Appel à plusUn(ptr)
Main( ) plusUn( )
Pointeurs
a=4
ptr p
Appel à plusUn(ptr) Exécution du code
Main( ) plusUn( )
Pointeurs

Retour de plusUn
a=4
ptr
Main( ) plusUn( )
Pointeurs
2
3 v o i d e c h ( i n t ∗a , i n t ∗b ) {
4 int r ;
5 r =∗a ;
6 ∗ a=∗b ;
7 ∗b=r ;
8 }
9 i n t main ( ) {
10 int x , y ;
11 x =2; y =3;
12 e c h (&x ,& y ) ;
13 s t d : : cout <<" x="<<x<<s t d : : e n d l ;
14 s t d : : cout <<" y="<<y<<s t d : : e n d l ;
15 return 0;
16 }
Pointeurs
Fonction avec pointeur : paramètres résultats
En utilisant les pointeurs, on peut donc interagir dans les deux sens
avec une fonction :
donner des valeurs en entrée dans une fonction
récupérer plusieurs valeurs en sortie d’une fonction
Exemple
void minmax(int a, int b, int *min, int *max){
if (a>b)
{*min=b; *max=a;}
else
{*min=a; *max=b;}
}
Pointeurs
Fonction avec pointeur : Exemple 3
2
3 v o i d minmax ( i n t a , i n t b , i n t ∗ min , i n t ∗max ) {
4 i f ( a>b )
5 { ∗ min=b ; ∗max=a ; }
6 else
7 { ∗ min=a ; ∗max=b ; }
8 }
9
10 i n t main ( ) {
11 i n t a , b , min , max ;
12 a =10; b =15;
13 minmax ( a , b ,& min ,&max ) ;
14 s t d : : cout <<" min="<<min<<s t d : : e n d l
15 <<"max="<<max<<s t d : : e n d l ;
16 return 0;
17 }
Pointeurs
Fonctions avec pointeurs
L’utilisation classique des pointeurs dans une fonction ne permet

pas de modifier la valeur des pointeurs.
Exemple
void echPtr(int *p1, int *p2){
int *p;
p=p1;
p1=p2;
p2=p;
}
Bien que syntaxiquement correcte, cette fonction n’échangera pas

la valeur de p1 et de p2.
Pointeurs
Passage de pointeur par copie
Le code suivant n’effectue aucun échange entre a et b car le

passage des paramètres se fait toujours par copie ! ! !
1 v o i d e c h P t r ( i n t ∗p1 , i n t ∗ p2 ) {
2 i n t ∗p ;
3 p=p1 ; p1=p2 ; p2=p ;
4 }
5 i n t main ( ) {
6 i n t ∗a , ∗ b ;
7 int c , d ;
8 c =1; d =3;
9 a=&c ; b=&d ;
10 e c h P t r ( a , b ) ; // p a s d ’ e c h a n g e e n t r e a e t b
11 return 0;
12 }
Pointeurs
main() echPtr()
a 0xFF2246
b 0xFF2252
c=1 d=3 a= 0xFF2246 b= 0xFF2252
0xFF2246 0xFF2252
Pointeurs
main() echPtr()
a 0xFF2246 p1 0xFF2246
b 0xFF2252 p2 0xFF2252
Appel à echPtr(...)
c=1 d=3 a= 0xFF2246 b= 0xFF2252 p1=0xFF2246 p2=0xFF2252
0xFF2246 0xFF2252
Pointeurs
main() echPtr()
a 0xFF2246 p1 0xFF2252
b 0xFF2252 p2 0xFF2246
Appel à echPtr(...) Exécution du code
c=1 d=3 a= 0xFF2246 b= 0xFF2252 p1=0xFF2252 p2=0xFF2246
0xFF2246 0xFF2252
Pointeurs
main() echPtr()
a 0xFF2246
b 0xFF2252
Appel à echPtr(...) Exécution du code
Retour de echPtr(...)
c=1 d=3 a= 0xFF2246 b= 0xFF2252
0xFF2246 0xFF2252
Pointeurs
Fonctions avec pointeurs modifiables
Un pointeur étant une variable comme une autre, on peut

également utiliser un pointeur pour le manipuler par son adresse.
Definition
type **ptr_ptr ;
La variable ptr_ptr est donc une variable qui stocke l’adresse

d’un pointeur sur un donnée de type type.
,→ on parle de pointeur de pointeur.
Exemple
int *p;
int **pp;
pp=&p;
Pointeurs
Definition
type_retour mafonction(type_param **ptr){...}
A l’intérieur de la fonction :
on peut récupérer le pointeur : *ptr
on peut modifier le pointeur : *ptr=...
et bien évidemment récupérer/modifier la donnée pointée par

le pointeur : *(*ptr)
Pointeurs
Il faut donc réécrire la fonction echPtr comme suit :
Exemple
void echPtr(int **p1, int **p2){
int *p;
p=*p1;
*p1=*p2;
*p2=p;
}
Pointeurs
Fonctions avec pointeurs modifiables : Exemple 1
1 v o i d e c h P t r ( i n t ∗∗ p1 , i n t ∗∗ p2 ) {
2 i n t ∗p ;
3 p=∗p1 ; ∗ p1=∗p2 ; ∗ p2=p ;
4 }
5 i n t main ( ) {
6 i n t ∗a , ∗ b ;
7 int c , d ;
8 c =1; d =3;
9 a=&c ; b=&d ;
10 e c h P t r (&a ,&b ) ;
11 return 0;
12 }
Pointeurs
Pointeur de pointeur de ... de pointeur
De manière plus générale, l’imbrication de plusieurs niveaux de

pointeurs n’est pas limitée.
Definition
int |*...*{z } a;
n fois
définit la variable a comme n imbrications de pointeur sur un int.
On peut donc stocker dans a l’adresse d’une variable étant définie

comme imbrication de n-1 niveaux de pointeur sur un int.
Tableaux
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
Tableaux
Tableaux statiques
Plan
6 Tableaux
Tableaux statiques
Fonction et tableaux statiques
Tableaux et pointeurs
Tableaux dynamiques
Fonction et tableaux dynamiques
Tableaux
Tableaux statiques
Manipulation des données
Une seule donnée à la fois (données scalaires) :

une variable : int a;
un pointeur : int *p;
Comment faire pour regrouper des données et les manipuler de

manière uniforme ?
Tableaux
Tableaux statiques
Manipulation des données
Une seule donnée à la fois (données scalaires) :

une variable : int a;
un pointeur : int *p;
Comment faire pour regrouper des données et les manipuler de

manière uniforme ?
utiliser une structure de tableau

Tableaux
Tableaux statiques
La structure de donnée tableau

Definition
Un tableau est un ensemble de données de même type qui sont
stockées de manière contiguë en mémoire
1er
élément
Un tableau à 6 éléments
un tableau est identifiable par son 1er élément et sa taille

les éléments sont accessibles en parcourant la mémoire à
partir du 1er élément
Tableaux
Tableaux statiques
Les tableaux en C++
Definition
Un tableau permet de définir avec une seule variable un ensemble
de variables de même type de donnée.
Un tableau en C++ est caractérisé par :

son identificateur (son nom)
sa taille (le nombre de données)
Tableaux
Tableaux statiques
Les tableaux en C++
Déclaration
type T[n];
T est l’identificateur du tableau

type est le type de donnée des éléments du tableau
n est une constante entière représentant la taille du tableau
Exemple
int T[3];
définit la variable T comme un tableau de trois entiers.
Tableaux
Tableaux statiques
Les tableaux en C++ : vue mémoire
1er Elt 2ème Elt 3ème Elt

un entier un entier un entier
Mémoire en octet
Un tableau de 3 entiers (int)
Un tableau de n éléments occupe n×sizeof(type) octets en

mémoire où type est le type de donnée des éléments du tableau.
Ici, un tableau de 3 int occupe 12 octets en mémoire.
Tableaux
Tableaux statiques
Les tableaux en C++
Déclaration
type T[n];
Cette déclaration de tableau

crée une variable T de type tableau sur type
alloue un espace contigu en mémoire de taille suffisant pour
stocker n données
n’initialise pas les éléments du tableau
Attention
Il est préférable que la taille n du tableau soit une constante connue
à la compilation.
Tableaux
Tableaux statiques
Les tableaux en C++ : accès aux éléments
L’accès aux éléments d’un tableau se fait par un calcul d’adresse

mémoire à partir du 1er élément : l’opérateur [ ] facilite le calcul.
Definition
Soit la déclaration : type T[n];
L’instruction T[i] accède à la i+1-ème case du tableau T
Attention :
les indices du tableau T commence à 0 et se termine à n-1
aucune vérification numérique est faite pour la valeur de i
T[i] est un identificateur valide (une variable)
,→ accès en lecture/écriture
Tableaux
Tableaux statiques
Les tableaux en C++ : vue mémoire
T[0] T[1] T[2]
Mémoire en octet
Int T[3];
T[3] valide
mais n'appartient
pas au tableau
Erreur de
segmentation
Tableaux
Tableaux statiques
Les tableaux en C++ : initialisation des éléments
Deux possibilités :
lors de la déclaration du tableau
par initialisation successive des éléments du tableau
Tableaux
Tableaux statiques
Déclaration d’un tableau avec initialisation des éléments :
Déclaration
type T[n] = {v0 ,v1 ,...,vn−1 };
Cette déclaration permet de déclarer un tableau T de n variables et

d’initialiser les éléments du tableau tels que T [i] = vi .
Exemple
int T[3]={4,17,3};
Tableaux
Tableaux statiques
Déclaration
type T[n] = {v0 ,v1 ,...,vn−1 };
Cette déclaration permet de déclarer un tableau T de n variables et

d’initialiser les éléments du tableau tels que T [i] = vi .
Exemple
int T[3]={4,17,3};
Remarque : la taille n ou toutes les valeurs ne sont pas obligatoires.

Tableaux
Tableaux statiques
Plusieurs possibilités :
int T[]={1,2,3,4,5};
,→ tableau de 5 éléments initialisé avec les valeurs données
int T[5]={12,13};
,→ tableau de 5 éléments initialisé avec les valeurs données,
le reste est initialisé à 0
Tableaux
Tableaux statiques
On peut initialiser les éléments d’un tableau dans une boucle par
affectation successive :
Déclaration
int T[10], i;
for(i=0;i<10;i++)
T[i]=...; ← affectation avec la valeur souhaitée
Tableaux
Tableaux statiques
On peut initialiser les éléments d’un tableau dans une boucle par
affectation successive :
Déclaration
int T[10], i;
for(i=0;i<10;i++)
T[i]=...; ← affectation avec la valeur souhaitée
Remarque : on peut remplacer l’affectation par une saisie

std::cin»T[i];
Tableaux
Tableaux statiques
Les tableaux en C++ : parcours des données
Pour parcourir les données d’un tableau, il suffit d’accéder aux

éléments de manière itérative.
Exemple
int T[10],i;
...
for (i=0;i<10;i++){
instructions avec T[i]
}
Attention avec T[i]

il faut toujours garantir que 0 ≤ i <taille du tableau
le compilateur ne le fait pas pour vous ! ! !
Tableaux
Tableaux statiques
Les tableaux en C++ : exemple 1
Affichage d’un tableau

2
3 i n t main ( ) {
4 i n t T[ 5 ] = { 4 , 3 , 1 , 8 , 6 } ;
5 int i ;
6 f o r ( i =0; i <5; i ++){
7 s t d : : cout <<T [ i ]<<" " ;
8 }
9 s t d : : cout <<s t d : : e n d l ;
10 return 0;
11 }
Tableaux
Tableaux statiques
Calcul du plus petit élément d’un tableau

2 i n t main ( ) {
3 i n t T[ 5 ] = { 4 , 3 , 1 , 8 , 6 } ;
4 i n t i , min ;
5
6 min=T [ 0 ] ;
7 f o r ( i =1; i <5; i ++){
8 i f (T [ i ]<min )
9 min=T [ i ] ;
10 }
11 s t d : : cout <<" l e min e s t : "<<min<<s t d : : e n d l ;
12 return 0;
13 }
Tableaux
Tableaux statiques

Renverser l’ordre des éléments d’un tableau
2 #d e f i n e TAILLE 5
3
4 i n t main ( ) {
5 i n t T [ TAILLE ] = { 4 , 3 , 1 , 8 , 6 } ;
6 i n t i , tmp , m i l i e u=TAILLE / 2 ;
7
8 f o r ( i =0; i <m i l i e u ; i ++){
9 tmp=T [ i ] ;
10 T [ i ]=T [ TAILLE−1− i ] ;
11 T [ TAILLE−1− i ]=tmp ;
12 }
13
14 f o r ( i =0; i <TAILLE ; i ++){
15 s t d : : c o u t <<T [ i ]<<" " ;
16 }
17 s t d : : c o u t <<s t d : : e n d l ;
18 return 0;
19 }
Tableaux
Tableaux statiques
Copie de tableau
Considérons le programme suivant :

1 i n t main ( )
2 {
3 i n t t1 [5]={1 ,2 ,3 ,4 ,5};
4 i n t t2 [ 5 ] ;
5 t 2=t 1 ;
6 return 0;
7 }
A la compilation, nous avons le message suivant :

error : invalid array assignment
Tableaux
Tableaux statiques
Copie de tableau
Pour recopier un tableau dans un autre, il est obligatoire de passer

par des affectations successives :
1 i n t main ( )
2 {
3 i n t t1 [5]={1 ,2 ,3 ,4 ,5};
4 i n t t2 [ 5 ] ;
5 int i ;
6 f o r ( i =0; i <5; i ++)
7 t 2 [ i ]= t 1 [ i ] ;
8 return 0;
9 }
Tableaux
Tableaux statiques
Les tableaux multidimensionnels en C++
Il est possible en C++ de déclarer des tableaux de tableaux. On les

appelle des tableaux multidimensionnels.
Exemple
int T[3][2];
T est un tableau à 3 éléments où chaque élément est un tableau de
2 entiers.
 
∗ ∗
On peut voir T comme une matrice : T = ∗ ∗
 
∗ ∗
Tableaux
Tableaux statiques
L’enchaînement des opérateurs [ ] permet de récupérer les

éléments d’un tableau multidimensionnels
Déclaration
Soit la déclaration int T[m][n];
T[i][j] donne accès au j-ème élément du i-ème tableau de T
Dans une vue matricielle, cela donne :

 
T[0][0] T[0][1]
int T[3][2] = T[1][0] T[1][1]
 
T[2][0] T[2][1]
Tableaux
Tableaux statiques

Comme pour les tableaux unidimensionnels, il est possible
d’initialiser les éléments du tableau lors de la déclaration.
Déclaration
int T[3][2] = {{1,2},{3,4},{5,6}} ;
Ce qui donne matriciellement :
1 2
 
int T = 3 4
 
5 6
Remarque
La notion de tableau multidimensionnel s’étend à plus de dimensions.
Tableaux
Tableaux statiques
Les tableaux multidimensionnels : Exemple
Calcul du déterminant de matrices 2 × 2

2
3 i n t main ( ) {
4 i n t A[ 2 ] [ 2 ] = { { 4 , 3 } , { 5 , 1 } } ;
5 int det ;
6
7 det = A [ 0 ] [ 0 ] ∗ A[ 1 ] [ 1 ] −A [ 0 ] [ 1 ] ∗ A [ 1 ] [ 0 ] ;
8
9 s t d : : cout <<" l e d é t e r m i n a n t e s t : "<<det <<s t d : : e n d l ;
10
11 return 0;
12 }
Tableaux
Plan
6 Tableaux
Tableaux statiques
Tableaux dynamiques
Tableaux
Tableau en paramètre d’entrée
Definition
type_retour mafonction(type ident[taille])
type_retour peut-être void, int, float,...

type est le type commun à tous les éléments du tableau,
ident est le nom du tableau,
taille est une constante entière précisant la taille du tableau.
Tableaux
Definition
type_retour mafonction(type ident[taille])
Exemple
void AfficheTab(int tab[10])
double Somme(double A[20])
double Moyenne(int t[15])
Tableaux
Afin d’écrire des fonctions pour des tableaux de taille quelconques,

il faut
enlever la taille dans le type du tableau : type ident[]
ajouter un paramètre à la fonction : int taille
Definition
type_retour mafonction(type ident[], int taille)
Attention : Il faut spécifier la taille du tableau car on ne peut pas

la récupérer à partir de ident.
Tableaux
Exemple
void AfficheTab(int tab[], int taille)
double Somme(double A[], int taille)
double Moyenne(int t[], int taille)
Remarque : Le paramètre taille doit être inférieur ou égal à la

taille réelle du tableau :
si égal : tout est normal,
si inférieur : seul les taille premiers éléments sont traités,
si supérieur : une erreur de segmentation se produira.
Tableaux
Accès aux éléments du tableau

On utilise naturellement l’opérateur [ ].
L’accès en lecture du (i+1)-ème élément d’un tableau tab passé

en paramètre s’écrit tab[i].
1 void AfficheTab ( i n t tab [ ] , i n t taille )

2 {
3 f o r ( i n t i =0; i < t a i l l e ; i ++){
4 s t d : : cout <<t a b [ i ]<<" " ;
5 }
6 s t d : : cout <<s t d : : e n d l ;
7 }
Tableaux
Exemple : indice du plus petit élément
On cherche le minimum d’un tableau de 10 entiers, mais on

renvoie sa position et non sa valeur.
1 i n t MinTab ( i n t t [ 1 0 ] )
2 {
3 i n t i , m=0;
4 f o r ( i =1; i <10; i ++)
5 i f ( t [ i ]< t [m] )
6 m=i ;
7 r e t u r n m;
8 }
Tableaux
Exemple : indice du plus petit élément
On cherche maintenant le plus petit élément d’un tableau de taille

quelconque.
1 i n t MinTab ( i n t t [ ] , i n t t a i l l e )
2 {
3 i n t i , m=0;
4 f o r ( i =1; i < t a i l l e ; i ++)
5 i f ( t [ i ]< t [m] )
6 m=i ;
7 r e t u r n m;
8 }
Tableaux
Tableau en retour de fonction
Attention
Les fonctions ne peuvent retourner qu’une seule donnée (entiers,
réels, pointeurs...), il est donc impossible de retourner comme résul-
tat un tableau statique.
Nous verrons dans la suite que par les pointeurs nous pourrons
renvoyer des tableaux.
Tableaux
Accès en écriture dans un paramètre tableau
Les paramètres tableaux sont modifiables

L’accès en écriture d’un tableau passé en paramètre d’une fonction
se fait avec l’opérateur [ ].
,→ cela marche comme l’accès en lecture.
1 v o i d MaZ( i n t t [ 1 0 ] )
2 {
3 int i ;
4 f o r ( i =0; i <10; i ++)
5 t [ i ]=0;
6 }
Tableaux
Que se passe-t-il ?
2 i n t main ( )
3 {
4 i n t t [10]={3 ,5 ,7 ,2 , −5 , −7 ,4 , −2 ,2 ,1};
5 AfficheTab ( t ) ;
6 MaZ( t ) ;
8 }
Tableaux
Ques se passe-t-il ?
1 i n t main ( )
2 {
3 i n t t [10]={3 ,5 ,7 ,2 , −5 , −7 ,4 , −2 ,2 ,1};
5 MaZ( t ) ;
7 }
Le tableau t a été modifié. Pourquoi ?

Tableaux
Plan
6 Tableaux
Tableaux statiques
Tableaux dynamiques
Tableaux
Tableau et pointeurs
Comment peut-on modifier un paramètre d’une fonction ?

En utilisant un pointeur sur la variable qu’on veut modifier.
Fonctions et tableaux
Tout se passe donc comme si le paramètre de la fonction n’était
pas le tableau, mais un pointeur sur le tableau.
Tableaux
Les tableaux et la mémoire :

Quand on déclare un tableau de 10 entiers :
int tab[10];
on alloue une zone contigue en mémoire de 10 entiers qui sont
accessibles via la variable tab par les instructions suivantes :
tab[0]; tab[1];...,tab[9];
Mais que contient la variable tab ?

Tableaux
Les tableaux et la mémoire :

Quand on déclare un tableau de 10 entiers :
int tab[10];
on alloue une zone contigue en mémoire de 10 entiers qui sont
accessibles via la variable tab par les instructions suivantes :
tab[0]; tab[1];...,tab[9];
Mais que contient la variable tab ?
Les tableaux sont des pointeurs :

La variable tab est en fait un pointeur sur la première case du
tableau.
Tableaux
Structure d’un tableau
T T[0] T[1] T[2]
0x47FF30 0x47FF34 0x47FF38

=T =T+1 =T+2
T contient l’adresse du premier élément du tableau (&T[0])

les adresses des autres éléments du tableau se déduisent
Tableaux
Arithmétique de pointeurs
Caractéristique des tableaux en mémoire
chaque case occupe la même taille,

les cases sont contiguës.
À partir de l’adresse du premier élément on en déduit les suivantes
en y ajoutant le bon nombre d’octets.
Soit la déclaration int tab[10]; on a :

adresse(tab[i]) = adresse(tab[0])+i*sizeof(int)
Remarque : La manipulation de tableau n’existe pas, le compilateur

se charge de tout convertir en pointeurs.
Tableaux
On peut manipuler explicitement les tableaux comme des

pointeurs.
Si tab est l’adresse du premier élément, alors l’adresse du i-ème
élément est
tab+i
et on peut accéder à un élément en faisant :
*(tab+i)
Remarque
Quand le compilateur rencontre tab[i], il le réécrit en *(tab+i)
Tableaux
1 void AfficheTab ( i n t tab [ 1 0 ] )

2 {
3 int i ;
4 f o r ( i =0; i <10; i ++)
5 s t d : : cout <<∗( t a b+i )<<" "
6 s t d : : cout <<s t d : : e n d l ;
7 }
Ou encore, en n’utilisant que des pointeurs :

1 void AfficheTab ( i n t tab [ 1 0 ] )
2 {
3 i n t ∗p ;
4 f o r ( p=t a b ; p<t a b +10; p++)
5 s t d : : cout <<∗p<<" "
6 s t d : : cout <<s t d : : e n d l ;
7 }
Tableaux
Exemple complet : Tri d’un tableau généré aléatoirement
Une fonction qui modifie un tableau en le remplissant de valeurs

aléatoires comprises entre 0 et 20.
1 void InitTab ( i n t tab [ 1 0 ] )
2 {
3 int i ;
4 f o r ( i =0; i <10; i ++)
5 t a b [ i ]= r a n d ( ) % 2 1 ;
6 }
Tableaux
Exemple complet
Une fonction qui trie un tableau de taille quelconque.

1 int Tri ( int t [ ] , int t a i l l e )
2 {
3 i n t i , j ,m;
4 f o r ( i =0; i < t a i l l e −1; i ++)
5 {
6 m=i ;
7 f o r ( j=i ; j < t a i l l e ; j ++)
8 i f ( t [ j ]< t [m] )
9 m=j ;
10 e c h a n g e ( t+i , t+m) ;
11 }
12 }
La fonction echange étant celle du cours précédent.

Tableaux
Exemple complet
L’utilisation de tableau aléatoire permet de tester facilement son
algorithme sur de nombreux cas différents.
2 #i n c l u d e <c t i m e >
3 #i n c l u d e < c s t d l i b >
4
5 i n t main ( )
6 {
7 int t [10];
8 s r a n d ( t i m e (NULL ) ) ;
9 InitTab ( t );
11 Tri ( t , 5 ) ;
13 Tri ( t , 1 0 ) ;
15 return 0;
16 }
Tableaux
Exemple complet
A la première exécution, on obtient (par exemple) :

1 7 15 8 12 12 5 6 17 2 1
2 7 8 12 12 15 5 6 17 2 1
3 1 2 5 6 7 8 12 12 15 17
A la seconde, on a :
1 7 5 4 20 14 11 17 1 7 7
2 4 5 7 14 20 11 17 1 7 7
3 1 4 5 7 7 7 11 14 17 20
Tableaux
Tableaux dynamiques
Plan
6 Tableaux
Tableaux statiques
Tableaux dynamiques
Tableaux
Tableaux dynamiques
Modèle mémoire
Données statiques :
On connaît à l’avance (lors de l’écriture du programme) la
taille des données,
La mémoire peut donc être réservée dès le début du
programme.
Données dynamiques :
On connaît la taille des données lors de l’exécution du
programme
La réservation de la mémoire doit donc se faire
dynamiquement au cours de l’exécution.
Tableaux
Tableaux dynamiques
Remarques
Sur les tableaux statiques :

ils sont alloués dans un espace mémoire particulier (la pile)
cette pile est très limitée
on ne peut pas allouer beaucoup de tableaux ou de grands
tableaux
Sur les tableaux dynamiques

ils sont alloués dans une autre zone mémoire (le tas)
cet espace mémoire est très vaste
on peut y allouer beaucoup de grands tableaux
Tableaux
Tableaux dynamiques
Outils de gestion de mémoire en C++
En C++, la gestion de la mémoire liée aux données

statiques est gérée automatiquement par le compilateur.
dynamiques est déléguée à l’utilisateur.
Gestion de le mémoire dynamique :
réservation de l’espace mémoire en fonction d’une taille et

d’un type
libération de l’espace mémoire
manipulation de la mémoire uniquement par pointeur
Tableaux
Tableaux dynamiques
Réservation de la mémoire
On parle plus généralement d’allocation mémoire.

Allocation mémoire en C++
On utilise l’instruction
type *p = new type[n]
new est l’opérateur de réservation de mémoire

type correspond au type de données qu’on va stocker
[n] indique que l’on veut stocker n données
p correspond au pointeur permettant l’accès à la mémoire
Tableaux
Tableaux dynamiques
Allocation mémoire en C++

Plus généralement, l’instruction new type[n] réclame au système
de réserver un espace mémoire permettant de stocker n données de
type type.
si l’allocation est possible, l’évaluation de cette instruction
retournera l’adresse de la mémoire allouée,
sinon, le programme s’arrêtera en levant une exception.
Exemple
new int[3] demande au système de réserver une espace mémoire
permettant de stocker 3 int.
Tableaux
Tableaux dynamiques
Attention
Pour accéder à la mémoire réservée, il est obligatoire qu’une
variable pointeur contienne son adresse, ce sera le seul accès
possible.
int *T = new int[3];
Tableaux
Tableaux dynamiques
Représentation en mémoire
L’opérateur new renvoie l’adresse de la 1ère case de la
mémoire dynamique qui a été allouée
Le pointeur T permet d’accéder aux cases de la mémoire
(comme un tableau).
int *T = new int[3];
T T[0] T[1] T[2]
0x47FF30 0x47FF34 0x47FF38

=T =T+1 =T+2
Tableaux
Tableaux dynamiques
Utilisation
Une fois qu’une zone mémoire est allouée dynamiquement, on peut

la parcourir comme un tableau en utilisant l’opérateur [ ] ou avec
l’arithmétique des pointeurs.
2 i n t main ( )
3 {
4 f l o a t ∗ T;
5 T = new f l o a t [ 4 0 ] ;
6 f o r ( i n t i =0; i <40; i ++)
7 { T [ i ]=1./(1+ i ) ; }
8
9 f o r ( i n t i =0; i <40; i ++)
10 { s t d : : cout <<T [ i ]<<" " ; }
11 return 0;
12 }
Tableaux
Tableaux dynamiques
Exemple
On veut qu’un utilisateur rentre des valeurs numériques dans un

tableau de taille N.
2 i n t main ( )
3 {
4 i n t ∗ adr , N ;
5 s t d : : cout <<" E n t r e z l e nombre de v a l e u r s : " ;
6 s t d : : c i n >>N ;
7 a d r= new i n t [ N ] ;
8 f o r ( i n t i =0; i <N ; i ++){
9 s t d : : cout <<" E n t r e z l a v a l e u r "<>a d r [ i ] ;
11 }
12 return 0;
13 }
Tableaux
Tableaux dynamiques
Libération de la mémoire
Nous sommes capables de réserver de la mémoire. Comme celle-ci

est limitée et partagée, il faut donc la libérer.
Libération de mémoire en C++

delete[] p;
delete[] indique que l’on veut libérer de la mémoire.

p est obligatoirement un pointeur contenant l’adresse de la
mémoire à libérer.
Tableaux
Tableaux dynamiques
Nous sommes capables de réserver de la mémoire. Comme celle-ci

est limitée et partagée, il faut donc la libérer.

delete[] p;
delete[] indique que l’on veut libérer de la mémoire.

p est obligatoirement un pointeur contenant l’adresse de la
mémoire à libérer.
Attention
On ne peut libérer que de la mémoire qui a été allouée dynamique-
ment par new.
Tableaux
Tableaux dynamiques

L’évaluation de l’instruction delete[] p; libére la mémoire
commencant à l’adresse mémoire stockée dans le pointeur p.
Remarque
Le pointeur p reste utilisable :
1 i n t ∗p ;
2 p= new i n t [ 5 ] ;
3 delete [ ] p ;
4 p= new i n t [ 1 0 ] ;
Tableaux
Tableaux dynamiques
Bonne utilisation de la mémoire dynamique
2 i n t main ( )
3 {
4 i n t ∗ tab ;
5 t a b = new i n t [ 1 0 ] ; // a l l o c a t i o n dynamique
6 ...
7 d e l e t e [ ] t a b ; // p l u s b e s o i n du c o n t e n u de t a b
8 ... // s u i t e du programme s a n s l e c o n t e n u de t a b
9 return 0;
10 }
Tableaux
Tableaux dynamiques
Initialisation des tableaux dynamiques
On ne peut pas le faire en même temps que l’allocation à l’inverse

des tableaux statiques. On le fait donc en deux étapes :
1 allocation du tableau
2 affectation d’une valeur à chaque case
L’initialisation se fait après le new par des affectations successives.

1 i n t ∗ tab , N ;
2 s t d : : c i n >>N ;
3 t a b = new i n t [ N ] ; // a l l o c a t i o n
4
5 f o r ( i n t i =0; i <N ; i ++) // i n i t i a l i s a t i o n s
6 t a b [ i ]= i ;
Tableaux
Tableaux dynamiques
Exemple : extraire les éléments pairs d’un tableau

On veut mettre dans un tableau tous les éléments pairs d’un autre
tableau.
1 i n t main ( ) {
2 int T[40];
3 ...
4 i n t c =0 ,
5 f o r ( i n t i =0; i <40; i ++){
6 i f (T [ i ]%2==0) { c++; }
7 }
8 i n t ∗ t a b = new i n t [ c ] ;
9 i n t j =0;
10 f o r ( i n t i =0; i <40; i ++){
11 i f (T [ i ]%2==0){
12 t a b [ j ]=T [ i ] ;
13 j ++;
14 }
15 ...
16 d e l e t e [ ] tab ;
17 }
Tableaux
Tableaux dynamiques
Comment copier des tableaux dynamiques
2 i n t main ( )
3 {
4 i n t i , ∗ t1 , ∗ t 2 ;
5 t 1=new i n t [ 2 0 ] ;
6 t 2=new i n t [ 2 0 ] ;
7 f o r ( i =0; i <20; i ++)
8 { t 1 [ i ]= i ; }
9 t 2=t 1 ;
10 f o r ( i =0; i <20; i ++)
11 { s t d : : cout <<t 2 [ i ]<<" " ; }
12 return 0;
13 }
A l’exécution, c’est bien les valeurs de 0 à 19 qui s’affichent mais

pourtant le tableau n’a pas été copié.
Tableaux
Tableaux dynamiques
Copie de tableau
Copie virtuelle
C’est quand deux tableaux partagent la même zone mémoire
,→ t2=t1 comme dans notre cas.
Attention : la modification d’un élément de t1 implique que celui
dans t2 l’est aussi.
Copie profonde
On souhaite que les tableaux aient leur propre zone mémoire pour
éviter les effets de bords.
,→ il faut allouer une nouvelle zone mémoire et copier les données.
Tableaux
Tableaux dynamiques
Copie de tableau
La bonne solution pour recopier t1 dans t2 est donc une copie en
profondeur.
2 i n t main ( )
3 {
4 i n t i , ∗ t1 , ∗ t 2 ;
5 t 1= new i n t [ 2 0 ] ;
6 f o r ( i =0; i <20; i ++)
7 t 1 [ i ]= i ;
8 t 2= new i n t [ 2 0 ] ;
9 f o r ( i =0; i <20; i ++)
10 t 2 [ i ]= t 1 [ i ] ;
11
12 delete [ ] t1 ;
13 delete [ ] t2 ;
14 }
Tableaux
Tableaux dynamiques
Tableaux dynamiques bi-dimensionnels
On veut utiliser un tableau de taille N × M entiers
N et M ne seront connus qu’à l’exécution.
Comment faire ?
Tableaux
Tableaux dynamiques
Tableau dynamique 7 × 8
Un pointeur sur un tableau

de 7 cases
Chaque case contient un
pointeur
Chacun de ses pointeurs
indiquent une zone de 8
cases
Tableaux
Tableaux dynamiques
Mise en oeuvre
1 i n t main {
2 i n t ∗∗ t a b l e a u ;
3 int i , j ;
4
5 t a b l e a u= new i n t ∗ [N ] ;
6 f o r ( i =0; i <N ; i ++)
7 { t a b l e a u [ i ]=new i n t [M] ; }
8
9 f o r ( i =0; i <N ; i ++)
10 f o r ( j =0; j <M; j ++)
11 { t a b l e a u [ i ] [ j ]=0; }
12 return 0;
13 }
Tableaux
Tableaux dynamiques
Pour libérer la mémoire, il faut libérer chacune des zones

précédemment allouées :
1 f o r ( i =0; i <N ; i ++)
2 delete [ ] tableau [ i ] ;
3
4 delete [ ] tableau ;
Tableaux
Plan
6 Tableaux
Tableaux statiques
Tableaux dynamiques
Tableaux
Pour passer un tableau dynamique en paramètre, on doit passer en

argument :
le pointeur sur la zone mémoire correspondante
la taille du tableau
Tableaux
Definition
type_retour mafonction(type *ident, int taille)
type_retour peut-être void, int, float,...

ident est le nom du tableau,
taille est un paramètre précisant la taille du tableau.
Tout exactement comme pour les tableaux statiques ! ! !

Tableaux
L’accès en lecture/écriture du i-ème élément d’un tableau

dynamique tab passé en paramètre se fait par l’opérateur [].
1 v o i d A f f i c h e T a b ( i n t ∗ tab , i n t n ) {
2 f o r ( i n t i =0; i <n ; i ++)
3 s t d : : cout <<t a b [ i ]<<s t d : : e n d l ;
4 }
5
6 v o i d MaZ( i n t ∗ tab , i n t n ) {
7 f o r ( i n t i =0; i <n ; i ++)
8 tab [ i ]=0;
9 }
Tableaux
Remarque
On peut également utiliser l’arithmétique des pointeurs.
1 v o i d A f f i c h e T a b ( i n t ∗ tab , i n t n ) {
2 f o r ( i n t i =0; i <n ; i ++)
3 s t d : : cout << ∗ ( t a b+i )<<s t d : : e n d l ;
4 }
5
6 v o i d MaZ( i n t ∗ tab , i n t n ) {
7 f o r ( i n t i =0; i <n ; i ++)
8 ∗ ( t a b+i )=0;
9 }
Tableaux
Tableau en paramètre de sortie
Remarque
Les tableaux étant essentiellement une abstraction de la mémoire, il
n’existe pas de type tableau que l’on pourrait renvoyer.
,→ par contre, il est possible de renvoyer l’adresse de la première
case du tableau via un pointeur ! ! !
Fonction permettant de renvoyer un tableau

type* mafonction(...) {
type *tab=new int[10];
...
return tab;
}
Tableaux
Fonction permettant de renvoyer un tableau

type* mafonction(...) {
type *tab=new int[10];
...
return tab;
}
Attention
On ne renvoie que l’adresse de la 1ère case du tableau, on ne renvoie
pas sa taille.
,→ on doit s’assurer de connaître la taille du tableau, ou de la récu-
pérer par un paramètre.
Tableaux
1 int ∗ creeTableau ( int n)

2 {
3 int i ;
4 i n t ∗ t=new i n t [ n ] ;
5 f o r ( i =0; i <n ; i ++)
6 { t [ i ]=0; }
7 return t ;
8 }
9 i n t main ( )
10 {
11 i n t t a i l l e =20;
12 i n t ∗ tab = creeTableau ( t a i l l e ) ;
13 ...
14 d e l e t e [ ] t a b ; // ATTENTION, on l i b è r e l a mémoire
15 return 0;
16 }
Tableaux
Exemple : extraire les nombres premiers d’un tableau
Exercice
On suppose avoir la fonction premier?(int) qui renvoie true

si n est premier et false sinon.
On souhaite écrire une fonction qui, à partir d’un tableau T,
va renvoyer un tableau ne contenant que les éléments de T
qui sont des nombres premiers.
Tableaux
Exemple : extraire les nombres premiers d’un tableau

T : un tableau de dimension n
nbprime : l’adresse d’un int pour la taille du tableau en sortie
1 i n t ∗ t a b P r e m i e r ( i n t ∗T , i n t n , i n t ∗ n b p r i m e ) {
2 ∗ n b p r i m e =0;
3 i n t ∗ t a b p=new i n t [ n ] ;
4 f o r ( i n t i =0; i <n ; i ++){
5 i f ( premier ?( t [ i ] ) ) {
6 t a b p [ ∗ n b p r i m e ]= t [ i ] ;
7 ( ∗ n b p r i m e )++;
8 }
9 }
10 i n t ∗ p r i m e=new i n t [ ∗ n b p r i m e ] ;
11 f o r ( i n t i =0; i <∗n b p r i m e ; i ++)
12 p r i m e [ i ]= t a b p [ i ] ;
13
14 d e l e t e [ ] tabp ;
15 return prime ;
16 }
Tableaux
Cas de la dimension 2
On suppose avoir choisi comme représentation celle-ci :
Un pointeur sur un tableau

de N cases
Chaque case contient un
pointeur
Chacun de ses pointeurs
indiquent une zone de M
cases
Tableaux
Cas de la dimension 2
Pour passer un tableau bi-dimensionnel en paramètre d’une

fonction, on utilise un pointeur de pointeur et deux dimensions.
fonction avec tableau bi-dimensionnel

type_retour mafonction(type **T, int N, int M)
type_retour peut-être void, int, float *,...

T est le nom du tableau dynamique,
N est un entier représentant la première dimension.
M est un entier représentant la seconde dimension.
Tableaux
Exemple : pluviométrie
Exercice
Nous allons nous intéresser à l’écriture de différentes fonctions sur
des relevés de précipitations.
Ceux-ci seront stockés dans un tableau 2D (mois, jours) où les
dimensions pourront ne pas être identiques.
Pour commencer, nous allons commencer par créer un tableau

mois qui contiendra le nombre de jours du mois correspondant :
int mois[12]={31,28,31,30,31,30,31,31,30,31,30,31};
Tableaux
Question :
Comment créer un tableau 2D nommé pluie tel que la ligne i
contienne mois[i] cases ?
Tableaux
Question :
Comment créer un tableau 2D nommé pluie tel que la ligne i
contienne mois[i] cases ?
1 i n t ∗∗ p l u i e ;
2 i n t mo is [ 1 2 ] = { 3 1 , 2 8 , 3 1 , 3 0 , 3 1 , 3 0 , 3 1 , 3 1 , 3 0 , 3 1 , 3 0 , 3 1 } ;
3 p l u i e=new i n t ∗ [ 1 2 ] ;
4 f o r ( i n t i =0; i <12; i ++)
5 p l u i e [ i ]=new i n t [ mois [ i ] ] ;
Tableaux
Question :
Calculer le total de précipitations par mois et renvoyer le résultat
dans un tableau
Tableaux
Question :
Calculer le total de précipitations par mois et renvoyer le résultat
dans un tableau
1 i n t ∗ p l u i e M o i s ( i n t ∗∗ p l u i e , i n t mois [ 1 2 ] )
2 {
3 i n t ∗ t=new i n t [ 1 2 ] ;
4 f o r ( i n t i =0; i <12; i ++){
5 t [ i ]=0;
6 f o r ( i n t j =0; j <mois [ i ] ; j ++){
7 t [ i ]+= p l u i e [ i ] [ j ] ;
8 }
9 }
10 return t ;
11 }
Tableaux
Question
Afficher le jour de l’année où il pleut le plus
Tableaux
Question
Afficher le jour de l’année où il pleut le plus
1 v o i d p l u i e M a x ( i n t ∗∗ p l u i e , i n t mois [ 1 2 ] ) {
2 i n t mi =0 ,mj =0;
3 f o r ( i n t i =0; i <12; i ++)
4 f o r ( i n t j =0; j <mois [ i ] ; j ++){
5 i f ( p l u i e [ i ] [ j ]> p l u i e [ mi ] [ mj ] ) {
6 mi=i ;
7 mj=j ;
8 }
9 }
10 s t d : : cout <<" i l p l e u t l e p l u s l e : "
11 <<mj+1<<" / "<<mi+1<<s t d : : e n d l ;
12 }
Tableaux
Question
Calculer le cumulé de la pluviométrie sur l’année
Tableaux
Question
Calculer le cumulé de la pluviométrie sur l’année
1 i n t p l u i e A n n u e l l e ( i n t ∗∗ p l u i e , i n t mois [ 1 2 ] )
2 {
3 i n t s =0;
4 i n t ∗ t=p l u i e M o i s ( p l u i e , mois ) ;
5 f o r ( i n t i =0; i <12; i ++)
6 {
7 s=s+t [ i ] ;
8 }
9 return s ;
10 }
Structures de données
Plan
1 Introduction
4 Fonctions
5 Pointeurs
6 Tableaux
A quoi sert une structure de données
Les types scalaires :

type de base : entier (int, double,...)
type pointeur : type *
Les types composés :

données homogènes (les tableaux) : type[]
A quoi sert une structure de données
Les types scalaires :

type de base : entier (int, double,...)
type pointeur : type *
Les types composés :

données homogènes (les tableaux) : type[]
données hétérogènes : les structures
Les structures de données
étendent les types du langage pour une problématique

donnée :
nombre complexe, matrices, compte bancaire, voiture, ...
regroupent des données dans une seule variable :

(hétérogène) un compte bancaire= no banque,no compte, solde
(homogène) un nbr complexe= partie imaginaire, partie réelle
Les structures de données
étendent les types du langage pour une problématique

donnée :
nombre complexe, matrices, compte bancaire, voiture, ...
regroupent des données dans une seule variable :

(hétérogène) un compte bancaire= no banque,no compte, solde
(homogène) un nbr complexe= partie imaginaire, partie réelle
Remarque
Cela facilite la manipulation des données et la structuration des
programmes
Spécifications
Une structure de données est composée d’un nombre fixé de

champs :
nommés (banque, compte, solde)
typés (int pour banque, compte et float pour solde
Une variable structurée peut être manipulée :

champ par champ (lecture, mise à jour)
globalement (initialisation, copie, paramètre fonction)
Déclaration d’une structure en C++
Syntaxe
struct NomStruct{
type1 champ1;
type2 champ2;
...
typeN champN;
};
Cela déclare un nouveau type de données

de nom NomStruct
composé des champs champ1, ..., champN
ayant respectivement pour type type1,...,typeN
Déclaration d’une structure en C++
Syntaxe
struct NomStruct{
type1 champ1;
type2 champ2;
...
typeN champN;
};
Attention
NomStruct est un identificateur pas encore utilisé (ex. 6= int)
type1,...,typeN sont des types connus dont on connaît la
taille mémoire (ex. 6= NomStruct)
Déclaration d’une structure en C++ : Exemple
1 s t r u c t compteB {
2 int banque ;
3 int compte ;
4 float solde
5 };
Attention
Le ; est obligatoire après la déclaration de la structure ! ! !
Déclaration d’une variable structurée
Syntaxe
NomStruct var;
var est une variable de type NomStruct.
Exemple
compteB CB;
Une structure en mémoire ? ? ?
Syntaxe
NomStruct var;
champ1 ... champN

mémoire en octets
NomStruct var;
Remarque
Chaque donnée dans la variable est identifiée par l’identificateur du
champ correspondant.
Exemple
compteB CB;
banque compte solde

mémoire en octets
compteB CB;
Remarque
Les champs sont ordonnés en mémoire dans l’ordre de leur déclara-
tion dans la structure.
Attention
Les champs des structures sont alignés suivant l’alignement des types
de base en mémoire (32 ou 64 bits).
struct mystruct { c1 c2 c3
padding
int c1; mémoire en octets
short int c2;
float c3;
}; mystruct var;
on peut obtenir l’occupation mémoire en utilisation sizeof

exemple : sizeof(mystruct) ou sizeof(var)
les règles de padding sont complexes (au delà de ce cours)
Accès aux champs d’une donnée structurée
On utilise la notation pointée :

Syntaxe
var.champ
Cela permet de récupérer la partie champ de la variable var.

On utilise la notation pointée :

Syntaxe
var.champ
Cela permet de récupérer la partie champ de la variable var.
Remarque
Cela définit un identificateur sur la donnée concernée
possédant une adresse : &(var.champ)
accessible en lecture/écriture : var.champ=...
2
4 i n t banque ;
5 i n t compte ;
6 float solde ;
7 };
8
9 i n t main ( ) {
10 compteB c ;
11 c . solde = 900;
12 s t d : : cout << " s o l d e : "<<c . s o l d e <<" \n " ;
13 return 0;
14 }
Initialisation d’une structure
Initialisation lors de la déclaration (comme les tableaux statiques)

Syntaxe
NomStruct var= {exp1,...,expN} ;
équivalent à :
var.champ1=exp1;
...
var.champN=expN;
Initialisation d’une structure
Initialisation lors de la déclaration (comme les tableaux statiques)

Syntaxe
NomStruct var= {exp1,...,expN} ;
Remarque
l’ordre des expressions est identique à celui des champs
les champs manquants sont initialisés à 0 ou NULL
on peut imbriquer les initialisations {..} (e.g. struct, tableau)
Initialisation d’une structure : Exemple
2
4 i n t banque ;
5 i n t compte ;
6 float solde ;
7 };
8
9 i n t main ( ) {
10 compteB c = { 1 2 3 , 4 5 6 , 9 0 0 } ;
11 s t d : : cout <<" l e compte : "<<c . compte ;
12 s t d : : cout <<" de l a banque : "<< c . banque ;
13 s t d : : cout <<" a p o u r s o l d e : "<<c . s o l d e <<" \n " ;
14 return 0;
15 }
Copie des structures
A l’inverse des tableaux statiques la copie de structure

fonctionne via l’opérateur =
Remarque
la copie se fait champ par champ
Exemple
compteB cb1, cb2;
cb1=cb2;
est équivalent à
cb1.banque=cb2.banque;
cb1.compte=cb2.compte;
cb1.solde=cb2.solde
Copie des structures
Remarque
L’initialisation par recopie fonctionne également
Exemple
compteB cb1;
...
compteB cb2=cb1;
Variable structurée : généralités
Bien que comprenant plusieurs données, une variable

structurée est considérée comme une seule donnée au sens des
variables.
copie/initialisation possible
paramètre/retour de fonctions
Variable structurée : généralités
Bien que comprenant plusieurs données, une variable

structurée est considérée comme une seule donnée au sens des
variables.
copie/initialisation possible
paramètre/retour de fonctions
A l’inverse des variables tableaux qui correspondent à une

adresse mémoire référençant les données.
Structures et fonctions
Plan
Structures et tableaux
Structure et pointeur
Structure et allocation dynamique
Passage des structures comme paramètre
Comme tous les paramètres de fonction, les variables structurées

sont passées par copie/valeur.
Syntaxe
type_r mafonction(nomStruct var,...) {...}
var est un paramètre de type nomStruct

lors de l’appel, une copie du paramètre structuré sera utilisée.
Passage des structures comme paramètre

Exemple :
3 i n t banque ;
4 i n t compte ;
5 float solde ;
6 };
7
8 v o i d i n t e r e t ( compteB cb , f l o a t t a u x ) {
9 cb . s o l d e ∗= (1.0+ t a u x ) ;
10 }
11 i n t main ( ) {
12 compteB c = { 1 2 3 , 4 5 6 , 9 0 0 } ;
14 i n t e r e t ( c , 0 . 0 2 5 ) ; //NE MODIFIE PAS c
16 return 0;
17 }
Retour d’une structure
Comme toutes les variables scalaires, une structure peut être

retournée par une fonction.
Syntaxe
nomStruct mafonction(...) {
...
return exp;
}
exp doit être une variable ou une constante de type

nomStruct
c’est une copie de exp qui est renvoyée
Retour d’une structure : exemple
1 compteB c r e a t i o n C o m p t e ( i n t banque ) {
2 compteB c = { banque , r a n d ( ) % 1 0 0 0 , 0 . 0 } ;
3 return c ;
4 }
init. : compteB c = creationCompte(1234);

copie : cb = creationCompte(4321);
Attention
Dans ce cas d’utilisation, le nombre de copies de la structure est de
deux → (coût mémoire potentiellement prohibitif)
Passage de structures par adresse
On utilise un pointeur sur la structure

Syntaxe
type_r mafonction(nomStruct *var,...) {...}
var contient l’adresse mémoire d’une variable de type

nomStruct
aucune copie mémoire lors de l’appel de la fonction
Passage de structures par adresse : Exemple
1 v o i d i n t e r e t ( compteB ∗ cb , f l o a t t a u x ) {
2 ( ∗ cb ) . s o l d e ∗=(1.0+ t a u x ) ;
3 }
4 i n t main ( ) {
5 compteB CB ;
6 i n t e r e t (&CB , 0 . 0 2 5 ) ; //MODIFIE BIEN CB
7 return 0;
8 }
Attention
La priorité des opérateurs est très importante :
*var.champ correspond à *(var.champ) et non à (*var).champ
Simplification d’accès aux champs via pointeur
Comme on a souvent besoin de la construction (*var).champ le

langage C++ propose un opérateur spécial : ->
Syntaxe
nomStruct *var= ...;
var->champ=...;
strictement équivalent à (*var).champ=...;

les champs sont accessibles en lecture et en écriture (bien sûr)
Exemple
L’affichage d’une structure nécessite souvent une fonction

particulière
1 v o i d a f f i c h e ( compteB ∗CB) {
2 s t d : : cout <<" banque : "<<c−>banque
3 <<" compte : "<<c−>compte
4 << " s o l d e : "<<c−>s o l d e <<" \n " ;
5 }
6 i n t main ( ) {
7 compteB cb = { 1 2 3 4 , 0 4 8 2 6 7 1 2 3 4 , 1 2 7 0 . 5 0 } ;
8 a f f i c h e (& cb ) ; // p a s s a g e p a r a d r e s s e −> e v i t e l a c o p i e
9 return 0;
10 }
Plan
Champ de type tableau dans une structure
Les champs d’une structure peuvent être des tableaux statiques

Syntaxe
struct nomStruct{
type1 champ1[10];
type2 champ2;
};
champ1 contient un tableau de 10 type1
Attention
La structure ne contient pas que l’adresse du 1er élément du tableau
mais bien l’ensemble des éléments du tableau.
Exemple
1 struct Etudiant {
2 c h a r nom [ 3 2 ] ;
3 i n t numero ;
4 int naissance [ 3 ] ;
5 };
tous les éléments du tableau sont intégrés dans la structure

taille de la structure Etudiant : 48 octets = 32 char + 4 int
ils sont accessibles par l’accès au champ puis au tableau
Exemple : Etudiant etud; etud.naissance[2]=1984;
Exemple
On peut imbriquer les initialisations lors de la construction d’une

donnée structurée :
1 struct Etudiant {
2 c h a r nom [ 3 2 ] ;
3 i n t numero ;
4 int naissance [ 3 ] ;
5 };
6 ...
7 E t u d i a n t e={" B e r i " , 2 0 1 0 0 0 3 1 1 1 , { 1 2 , 4 , 1 9 8 7 } } ;
8 ...
Tableau dans les structures
Remarque
L’affectation, l’initialisation, le passage en argument et le retour de
fonction d’une structure copie récursivement chacun des champs ...
Tous les tableaux statiques dans les structures seront donc copié
élément par élément lors
de l’affectation de la structure
du passage en argument d’une fonction
du retour de la structure par une fonction
Tableau dans les structures : Exemple
1 void a n n i v e r s a i r e ( Et u d i a n t e ){
2 s t d : : cout <<e . nom<<" e s t né l e "
3 << e . n a i s s a n c e [0]<< " / "
4 << e . n a i s s a n c e [1]<< " / "
5 << e . n a i s s a n c e [2]<< " \n " ;
6 }
7
8 i n t main ( ) {
9 E t u d i a n t e1 , e2={" B e r i " , 2 0 1 0 0 0 3 1 1 1 , { 1 2 , 4 , 1 9 8 7 } } ;
10 e1=e2 ; // c o p i e d e s t a b l e a u x
11 a n n i v e r s a i r e ( e1 ) ; // c o p i e d e s t a b l e a u x
12 return 0;
13 }
Champs de type structure dans une structure

Les champs d’une structure peuvent être des structures
Syntaxe
struct nomStruct{
otherStruct champ1;
type2 champ2;
};
champ1 est un type structuré de type otherStruct

le comportement est similaire aux tableaux statiques (copie)
Champs de type structure dans une structure

Les champs d’une structure peuvent être des structures
Syntaxe
struct nomStruct{
otherStruct champ1;
type2 champ2;
};
champ1 est un type structuré de type otherStruct

le comportement est similaire aux tableaux statiques (copie)
Attention
La taille de la structure imbriquée doit être connue ...
→ les structures récursives sont impossibles
Exemple
1 struct Date {
2 int j j ,mm, aaaa ;
3 };
4 struct Etudiant {
5 char nom [ 3 2 ] ;
6 int numero ;
7 Date naissance ;
8 };
tous les champs des structures sont intégrés

taille de la structure Etudiant : 48 octets = 32 char + 4 int
ils sont accessibles par les appels imbriqués des champs
Exemple : Etudiant e; e.naissance.aaaa=1984;
Exemple
On peut imbriquer les initialisations lors de la construction d’une

structure imbriquée :
1 s t r u c t Date {
3 };
4
5 struct Etudiant {
6 c h a r nom [ 3 2 ] ;
7 i n t numero ;
8 Date n a i s s a n c e ;
9 };
10 ...
11 E t u d i a n t e={" B e r i " , 2 0 1 0 0 0 3 1 1 1 , { 1 2 , 4 , 1 9 8 7 } } ;
Structure dans les structures
Remarque
L’affectation, l’initialisation, le passage en argument et le retour de
fonction d’une structure copie récursivement chacun des champs ...
Comme avec les tableaux statiques, les structures imbriquées

seront donc copiées champ par champ lors
de l’affectation de la structure
du passage en argument d’une fonction
du retour de la structure par une fonction
Structure dans les structures : Exemple
1 void a n n i v e r s a i r e ( Et u d i a n t e ){
2 s t d : : cout <<e . nom<<" e s t né l e "
3 << e . n a i s s a n c e . j j <<" / "
4 << e . n a i s s a n c e .mm<<" / "
5 << e . n a i s s a n c e . aa<<" \n " ;
6 }
7
8 i n t main ( ) {
9 E t u d i a n t e1 , e2={" B e r i " , 2 0 1 0 0 0 3 1 1 1 , { 1 2 , 4 , 1 9 8 7 } } ;
10 e1=e2 ; // c o p i e t a b l e a u e t s t r u c t u r e
11 a n n i v e r s a i r e ( e2 ) ; // c o p i e t a b l e a u e t s t r u c t u r e
12 return 0;
13 }
Tableau statique de structures
Les structures étant un type de données, on peut les mettre dans

un tableau
Syntaxe
nomStruct var[N];
var est un tableau contenant N données structurées

N doit être une constante connue
Attention
var reste un tableau et contient l’adresse mémoire où se trouvent
les N données structurées.
Exemple
On peut imbriquer les initialisations lors de la construction d’un

tableau statique de structure :
3 };
4 ...
5 Date D[ 3 ] = { { 2 , 1 , 1 9 2 3 } , { 2 3 , 1 2 , 2 0 0 4 } , { 1 3 , 0 1 , 2 0 1 1 } } ;
on ne peut pas copier le tableau par l’opérateur d’affectation :

Date T[3]=D; (INTERDIT)
Exemple
On peut imbriquer les initialisations lors de la construction d’un

tableau statique de structure :
3 };
4 ...
5 Date D[ 3 ] = { { 2 , 1 , 1 9 2 3 } , { 2 3 , 1 2 , 2 0 0 4 } , { 1 3 , 0 1 , 2 0 1 1 } } ;
on ne peut pas copier le tableau par l’opérateur d’affectation :

Date T[3]=D; (INTERDIT)
lors de passage du tableau en paramètre d’une fonction, les
données structurées ne sont pas copiées
Tableaux de structures
3 };
4 ...
5 Date D[ 3 ] = { { 2 , 1 , 1 9 2 3 } , { 2 3 , 1 2 , 2 0 0 4 } , { 1 3 , 0 1 , 2 0 1 1 } } ;
comment accéder au mois de la 2ème date ?

D[2] est-il passé par copie d’adresse ou par copie de données ?
D est-il passé par copie d’adresse ou par copie de données ?
Tableaux de structures
3 };
4 ...
5 Date D[ 3 ] = { { 2 , 1 , 1 9 2 3 } , { 2 3 , 1 2 , 2 0 0 4 } , { 1 3 , 0 1 , 2 0 1 1 } } ;
comment accéder au mois de la 2ème date ? D[1].mm

D[2] est-il passé par copie d’adresse ou par copie de données ?
D est-il passé par copie d’adresse ou par copie de données ?
Plan
Champs pointeur dans une structure
Les champs pointeurs dans une structure permettent de stocker

l’adresse de n’importe quelle donnée (scalaire, tableau, structure)
Syntaxe
struct nomStruct {
type1 *champ1;
type2 champ2;
};
champ1 contient l’adresse d’une donnée de type type1

type1 est n’importe quel type connu (nomStruct compris)
Exemple
1 struct Etudiant {
2 c h a r ∗nom ;
3 Date a n n i v e r s a i r e ;
4 E t u d i a n t ∗ binome ;
5 };
6 ...
7 E t u d i a n t e1={" b e r i o " , { 1 . 3 . 1 9 8 7 } }
8 E t u d i a n t e2={" l e f o r t " , { 1 2 , 1 , 1 9 8 8 } } ;
9 e1 . binome=&e2 ;
10 e2 . binome=&e1 ;
Plan
Allocation dynamique de structure
Comme pour les types de base (int, double, ...) il est possible de
faire de l’allocation dynamique de données structurées.
Remarque
Il suffit d’utiliser l’allocation avec new et la libération avec delete.
Allocation dynamique de structure
Comme pour les types de base (int, double, ...) il est possible de
faire de l’allocation dynamique de données structurées.
Remarque
Il suffit d’utiliser l’allocation avec new et la libération avec delete.
Exemple
struct Date {int jj,mm,aaaa;};
Date *T= new Date[3];
...
delete [] T;
Un exemple plus complexe
En cuisine, un plat a un nom. Il est composé d’un nombre

quelconque d’ingrédients. On fixera le nombre maximum
d’ingrédients à 100. Chaque ingrédient a un nom et un prix. On
définit les structures plat et ingrédient.
1 struct ingredient {
2 c h a r nom [ 3 2 ] ;
3 float prix ;
4 };
5 struct plat {
6 c h a r nom [ 3 2 ] ;
7 i n t nb ; // l e nombre d ’ i n g r é d i e n t s c o n n u s du p l a t
8 i n g r e d i e n t l i s t e [ 1 0 0 ] ; // l e t a b l e a u d e s i n g r é d i e n t s
9
10 };

On définit les fonctions suivantes pour les ingrédients :
creerIngredient pour permettre à l’utilisateur de saisir les
caractéristiques d’un ingrédient afficheIngredient pour afficher à
l’écran les caractéristiques d’un ingrédient
1 void c r e e r I n g r e d i e n t ( i n g r e d i e n t ∗ i n g ){
2 std : : cout <<" donnez l e nom de l ’ i n g r e d i e n t \n " ;
3 std : : c i n >> ( ∗ i n g ) . nom ;
4 std : : cout <<" donnez l e p r i x de l ’ i n g r e d i e n t \n " ;
5 std : : c i n >>(∗ i n g ) . p r i x ;
6 }
7
8 void a f f i c h e I n g r e d i e n t ( i n g r e d i e n t ∗ i n g ){
9 std : : cout <<"nom de l ’ i n g r e d i e n t : " ;
10 std : : cout <nom<<" \n " ;
11 std : : cout <<" p r i x de l ’ i n g r e d i e n t : " ;
12 std : : cout <p r i x <<" \n " ;
13 }

On définit les fonctions suivantes pour les plats : creerPlat pour
permettre à l’utilisateur de saisir les caractéristiques d’un plat
affichePlat pour afficher à l’écran les caractéristiques d’un plat
1 void c r e e r P l a t ( p l a t ∗ p ){
2 s t d : : cout <<" donnez l e nom du p l a t \n " ;
3 s t d : : c i n >> ( ∗ p ) . nom ;
4 ( ∗ p ) . nb = 0 ;
5 }
6 v o i d a f f i c h e P l a t ( p l a t ∗p ) {
7 s t d : : cout <<"nom du p l a t : " ;
8 s t d : : cout << p−>nom<<" \n " ;
9 i n t n =p−>nb ; i n t i ;
10 s t d : : cout <<" nb d ’ i n g r é d i e n t s : "<<n<<" \n " ;
11 f o r ( i =0; i <n ; i ++)
12 a f f i c h e I n g r e d i e n t (&(p−> l i s t e ) [ i ] ) ;
13 }
ajouteIngredient pour ajouter un ingrédient à un plat

1 void a j o u t e I n g r e d i e n t ( i n g r e d i e n t ∗ ing , p l a t ∗ p ){
2 i f ( p−> nb < 1 0 0 ) {
3 ( p−>nb)++;
4 // on a j o u t e i n g
5 ( p−> l i s t e ) [ p−>nb −1]=∗ i n g ;
6 }
7 }
et enfin le programme :
1 i n t main ( ) {
2 i n g r e d i e n t i 1 ={ " f a r i n e " , 3 4 } , i 2= { " o e u f s " , 5 } ;
3 plat p;
4 c r e e r P l a t (&p ) ;
5 a j o u t e I n g r e d i e n t (& i 1 ,&p ) ;
6 a j o u t e I n g r e d i e n t (& i 2 ,&p ) ;
7 a f f i c h e P l a t (&p ) ;
8 return 0;
9 }

Cours

Transféré par

Droits d'auteur :

Formats disponibles

Cours

Transféré par

Informations du document

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

Cours

Transféré par

Droits d'auteur :

Formats disponibles

Programmation Impérative

V. Boudet P. Giorgi M. Joab

notes de cours préparées par V. Boudet, P. Giorgi et M. Joab

Les TDs/TPs commencent la semaine prochaine.

1 note de contrôle continu (assiduité, participation, contrôle

La note finale sera :

max (Exam, 0.6 × Exam + 0.4 × CC )

L’objectif n’est pas de faire de vous des spécialistes d’un

2 Bases du langage C++

Différents niveaux de langage :

Il est propre à chaque famille de processeurs.

Langage haut niveau

Syntaxe indépendante des processeurs.

Le même code que précédemment mais écrit en C/C++.

Langage haut niveau

Ce langage n’est pas exécutable directement par un ordinateur.

Langage haut niveau

Il existe plusieurs types de langages haut niveau, chacun proposant

La programmation impérative procédurale correspond à la notion

Changement d’état d’un programme

Modélisation d’un ordinateur actuel

Un langage impératif s’appuie essentiellement sur 3 notions :

mémoire, calcul, contrôle

Mémoire divisée en case C*(6.6",1%($,$%(%5'($,/.%(?(0D*)#%(*11E'("#(1%/.6*11*9%(/%($"'1%("1/,&*'%#17

,→ une case est un bit (soit 5"#"$%"60*7+%"6+'

Toutes les données dans un programme sont traduits en 0 et en 1

Les données étant de diverse nature (taille et contenu du codage),

Écrire un programmation impératif

Le programmeur décrit de manière ordonnée chacune des

est un langage purement impératif

est une évolution de C ajoutant le paradigme objet

Noyau de langage impératif procédural

faiblement typé (conversion implicite des types)

Le noyau impératif de C++ pouvant être considéré comme une

Concevoir un programme en C++

Trois étapes ordonnées :

Écrire un programme C++

Il suffit d’écrire avec un éditeur de texte simple (sans formatage)

Compilation d’un programme C++

L’outil permettant la traduction d’un texte écrit en C++ en

Compilation d’un programme C++

Il existe plusieurs compilateurs C++ en fonction du système

Dans un environnement GNU/Linux,

la suite de compilation standard est appelé GCC (the GNU

Pour compiler l’exemple (exemple.cpp), on tape dans un terminal :

g++ -Wall exemple.cpp -o Exemple

ce qui permet de créer un programme exécutable nommé Exemple.

Pour compiler l’exemple (exemple.cpp), on tape dans un terminal :

g++ -Wall exemple.cpp -o Exemple

ce qui permet de créer un programme exécutable nommé Exemple.

Notion de programme en C++

Un programme est constitué de plusieurs fonctions/procédures qui

Principe d’un programme C++

Trois types d’erreurs

Les langages de programmation sont définis à partir de règles

Correction des erreurs de syntaxe

il y a une erreur ligne 3 avant le mot clé return ,→ il manque un ;

Vous vous êtes trompé dans la conception du programme.

2 battre les oeufs.

Souvent liées à des erreurs d’écriture (bug) ou à des erreurs de

Mémoire divisée en case C(6.6",1%($,$%(%5'($,/.%(?(0D)#%(11E'("#(1%/.6119%(/%($"'1%("1/,&'%#17