ELy-Cours-C++ - 01 - 2 - 2021-2022 Moodle

16/10/2021
Université Ibn Zohr Agadir Année universitaire: 2021-2022

Ecole Nationale des Sciences Appliqué Section: G-Ind1
Département: Génie Informatique Module: Programmation C++
Responsable: Prof. A. Elyousfi
Abderrahmane ELYOUSFI Département

elyousfiabdo@yahoo.fr Génie Informatique
Langage
C++
Elyousfi Abderrahmane ENSA-3 2
1
16/10/2021
Plan
1. Présentation du langage C++.
2. Généralités sur le langage C++
3. Les types de base de C++
4. Opérateurs et expressions
5. Les entrées-sorties conversationnelles de C++
6. Les instructions de contrôle
7. Les tableaux et les pointeurs
8. Les types structure, union et énumération
9. Les fonctions
Plan
1. Classes et objets.
2. Les propriétés des fonctions membres
3. Construction, destruction et initialisation des objets
4. Les fonctions amies
5. La surdéfinition d’opérateurs
6. Les patrons de fonctions et de classes
7. L’héritage simple et multiple
8. Les fonctions virtuelles et le polymorphisme
9. Les flots
10. La gestion des exceptions
11. Généralités sur la bibliothèque standard
2
16/10/2021
Présentation du
langage C++.
Qu’est-ce que le C++ ?

 Le langage C++ a été conçu à partir de 1982 par Bjarne
Stroustrup (AT&T Bell Laboratories).
 C++ a connu plusieurs versions, jusqu’à sa normalisation par
l’ANSI en 1998.
 D’après Bjarne Stroustrup, conception du langage C++ pour :
 Être meilleur que C,
 Permettre les abstractions de données
 Permettre la programmation orientée-objet
 Compatibilité C/C++ :
 C++ = sur-ensemble de C,
 C++ ⇒ ajout en particulier de l’orienté-objet (classes, héritage,
polymorphisme),
 Cohabitation possible du procédural et de l‘orienté-objet en C++
3
16/10/2021
C et C++
Certaines des extensions du C++ pourraient en fait être

ajoutées au langage C, sans qu’il soit pour autant « orienté
objet ».
C++ a introduit de nouvelles possibilités d’entrées-sorties

(basées sur la notion de flot) qui rendent superflues les
fonctions standards de C telles que printf ou scanf.
C++ dispose d’opérateurs de gestion dynamique (new et delete)

qui remplacent avantageusement les fonctions malloc, calloc et
free du C.
C++ et la bibliothèque standard
Comme tout langage, C++ dispose d’une bibliothèque standard,

c’est-à-dire de fonctions et de classes prédéfinies.
Elle comporte notamment de nombreux patrons de classes et de

fonctions permettant de mettre en œuvre les structures de
données les plus importantes (vecteurs dynamiques, listes
chaînées, chaînes...).
4
16/10/2021
Généralités sur le langage C++
Elyousfi Abderrahmane ENSA-3
5
16/10/2021
Pour écrire des informations : utiliser le flot cout
cout << "Bonjour\n" ;

cout est un « flot de sortie »
<< est un opérateur permettant d’envoyer de l’information sur un

flot de sortie.
Pour l’instant, admettons que cout désigne la fenêtre dans laquelle
s’affichent les résultats.
cout << "Je vais vous calculer " << NFOIS << " racines carrees\n" ;
L’instruction suivante ressemble à la précédente avec cette différence

qu’ici on envoie aussi la valeur de la constante à l’écran.
Pour lire des informations : utiliser le flot cin
cin >> x ;
cin est un « flot d’entrée » associé au clavier
>> est un opérateur permettant d’extraire (de lire ) de

l’information à partir du flot d’entrée.
Pour l’instant, admettons que cette instruction peut être interprétée
ainsi : lire des valeurs des variables à partir du clavier
cout >> NFOIS ;
6
16/10/2021
Les directives à destination du préprocesseur
Les deux premières lignes de notre programme :
iostream contient des déclarations relatives aux flots donc, en

particulier, à cin et cout, ainsi qu’aux opérateurs << et
>> (dont on verra plus tard qu’ils sont en fait considérés
comme des fonctions particulières) ;
cmath contient des déclarations relatives aux fonctions

mathématiques (héritées de C), donc en particulièr
à sqrt.
L’instruction using
La norme de C++ a introduit la notion d’« espaces de noms »

(namespace).
Cette notion d’espace de noms sera étudiée par la suite.
Pour l’instant, retenez que les symboles déclarés dans le fichier

iostream appartiennent à l’espace de noms std.
L’instruction using sert précisément à indiquer que l’on se place «
dans cet espace de noms std »
Remarque:
si vous placez l’instruction using avant l’incorporation des
fichiers en-tête, vous obtiendrez une erreur car vous ferez référence
à un espace de noms qui n’a pas encore été défini !).
7
16/10/2021
Quelques règles d’écriture
Les identificateurs
Les identificateurs servent à désigner les différentes « choses »
manipulées par le programme, telles:
les variables, les fonctions, objets, structures, unions ou

énumérations, membres de classe, de structure ou d’union,
types, étiquettes d’instruction goto, macros...
Comme dans la plupart des langages, ils sont formés d’une suite
de caractères choisis parmi les lettres ou les chiffres, le
premier d’entre eux étant nécessairement une lettre.
Le caractère souligné (_) est considéré comme une lettre. Il peut

donc apparaître au début d’un identificateur.
Les majuscules et les minuscules sont autorisées mais ne sont pas

équivalentes.
8
16/10/2021
Les mots-clés
Certains « mots-clés » sont réservés par le langage à un usage
bien défini et ne peuvent pas être utilisés comme identificateurs.
Les mots-clés de C++
Les commentaires
Comme tout langage évolué, C++ autorise la présence de

commentaires dans vos programmes source.
Il existe deux types de commentaires :
les commentaires « libres », hérités du langage C ;
les commentaires de fin de ligne (introduits par C++).
9
16/10/2021
Les commentaires
 Le langage C++ offre une nouvelle façon d'ajouter des commentaires.
 En plus des symboles /* et */ utilisés en C, le langage C++ offre

les symboles // qui permettent d'ignorer tout jusqu'à la fin de la
ligne.
Exemple :
/* commentaire traditionnel
sur plusieurs lignes
valide en C et C++
*/
void main() { // commentaire de fin de ligne valide en C++

// une partie d'un programme en C ou C++ peut toujours
// être ignorée par les directives au préprocesseur
// #if .... #endif
}
Création d’un programme en C++

Les grandes étapes de la création d’un programme, sont :
 édition du programme,
 compilation
 et édition de liens.
10
16/10/2021

édition du programme,
L’édition du programme (on dit aussi parfois « saisie »)

consiste à créer, à partir d’un clavier, tout ou partie du
texte d’un programme qu’on nomme « programme source ».
En général, ce texte sera conservé dans un fichier que

l’on nommera « fichier source ».
La plupart du temps, en C++, les fichiers source porteront

l’extension cpp.

La compilation
Elle consiste à traduire le programme source (ou le contenu
d’un fichier source) en langage machine, en faisant appel à
un programme nommé compilateur.
L’opération de compilation comporte en fait deux étapes :

Traitement par le préprocesseur:
Il exécute les directives qui le concernent (commencent par un
caractère #).
Il produit, en résultat, un programme source en C++ pur.
Compilation: C’est la traduction en langage machine du texte

C++ fourni par le préprocesseur.
Le résultat de la compilation porte le nom de module objet.

11
16/10/2021

L’édition de liens
En général, un module objet créé ainsi par le compilateur

n’est pas directement exécutable.
Il lui manquera, en effet, au moins les fonctions de la

bibliothèque standard dont il a besoin.
La bibliothèque est une collection de modules objets organisée,

suivant l’implémentation concernée, en un ou plusieurs fichiers.
Le rôle de l’éditeur de liens que d’aller rechercher dans la

bibliothèque standard les modules objets nécessaires.
Le résultat de l’édition de liens est ce que l’on nomme un

programme exécutable, c’est-à-dire un ensemble autonome
d’instructions en langage machine.
Les types de base de C++
12
16/10/2021
Les types de base de C++

Un type définit l’ensemble des valeurs que peut prendre une
variable, le nombre d’octets à réserver en mémoire et les
opérateurs que l’on peut appliquer dessus.
Les types de base du langage C++ se répartissent en quatre

catégories en fonction de la nature des informations qu’ils
permettent de représenter :
 nombres entiers (mot-clé int) ;

 nombres flottants (mot-clé float ou double) ;
 caractères (mot-clé char) ;
 valeurs booléennes, c’est-à-dire dont la valeur est

soit vrai, soit faux (mot-clé bool).
Les types entiers et les types flottants
C++ prévoit que, sur une machine donnée, on puisse trouver

jusqu’à trois tailles différentes d’entiers, désignées par
les mots-clés suivants :
 int;
 short int (qu’on peut abréger en short) ;
 long int (qu’on peut abréger en long).
Pour les types réels, C++ prévoit trois types de flottants

correspondant à des tailles différentes :
float, double et long double.
13
16/10/2021
 Pas de type booleen en C.
 En C on utilise le type int
 0 représente faux.
 Toute valeur non nulle représente vrai.
 En C++, le type booleen est bool
 Il peut valoir true ou false.
Tableau
14
16/10/2021
Les types caractères

Comme la plupart des langages, C++ permet de manipuler des
caractères codés en mémoire sur un octet.
Notation des constantes caractères

Les constantes de type « caractère », lorsqu’elles
correspondent à des caractères imprimables, se notent de
façon classique, en écrivant entre apostrophes.
Exemples : 'a‘ 'Y‘ '+' '$'
Il est possible d’utiliser directement le code du caractère

en l’exprimant, à la suite du caractère « antislash » :
'A' '\x41' '\101‘
'\x0d' '\15' '\015’
Les types caractères

En plus des caractères imprimable, il existe des caractères
de contrôle (caractères de changement de ligne, de
tabulation, d’activation d’une alarme sonore...).
15
16/10/2021
Le type bool
Ce type est tout naturellement formé de deux valeurs notées

true et false.
Il peut intervenir dans des constructions telles que :
bool ok = false ;
.....
if (.....) ok = true ;
.....
if (ok) .....
Opérateurs et expressions
16
16/10/2021
Opérateurs arithmétiques
+ - * / %
L’opérateur % permet d’obtenir le reste de la division entière.
L’opérateur / retourne un quotient entier si les deux opérandes

sont entiers.
Opérateurs de comparaison
= = : l’opérateur égal à.
!= : l’opérateur différent de.
<, <=, >, >= : plus petit, plus petit ou égal,

plus grand, plus grand ou égal.
Ces opérateurs retournent une valeur booléenne.
17
16/10/2021
Opérateurs de logique:
&& : ET logique (and)
|| : OU logique (or)
! : négation logique (not)
ET retourne la valeur 1 si les deux opérandes sont non nuls,

et 0 sinon.
OU retourne la valeur 1 si au moins un des opérandes est non
nul, et 0 sinon.
Opérateurs d’affectation
Opérateur d’affectation = variable = <expression> ;
L’expression est évaluée puis affectée à la variable.
expr1 = (expr1) OP (expr2) expr1 OP = (expr2)
Opérateurs d’affectation utilisables :
+= -= *= /= %=
18
16/10/2021
Opérateurs d’affectation
Exemples:
a = a + b a += b
a = a / b a /= b
a = a * b a *= b
Opérateurs d’incrémentation
L’ opérateur de postincrémentation
var ++ var = var + 1
var -- var = var - 1
Exemple: a=b++; a=b;

b++;
L’ opérateur de préincrémentation
++var var = var + 1
--var var = var - 1

b++;
Exemple: a=++b;
a=b;
19
16/10/2021
Opérateurs conditionnels: (?:)
expr1 ? expr2 : expr3
expr1 est évaluée.

Si sa valeur est non nulle, alors la valeur de expr2 est
retournée.
Sinon, c’est la valeur de expr3 qui est renvoyée.
Exemple:
z= ( a>b ? a : b );
a>b ? i++ : j++;
L’opérateur sizeof
L’opérateur sizeof, dont l’emploi ressemble à celui d’une

fonction, fournit la taille en octets
Exemple:
double z ;
l’expression sizeof(z) vaudra 8.
20
16/10/2021
Les entrées-sorties
conversationnelles de C++
Les entrées/sorties en langage C s’effectue par les fonctions

scanf et printf de la librairie standard du langage C.
Il est possible d’utiliser ces fonctions pour effectuer les

entrées/sorties de vos programmes, mais cependant les programmeurs
C++ préfèrent les entrées/sorties par flux (ou flot ou stream).
L’opérateur (surchargé) << permet d’envoyer des valeurs dans un

flot de sortie, tandis que >> permet d’extraire des valeurs
d’un flot d’entrée.
21
16/10/2021
cout et cin
Entrées/sorties fournies à travers la librairie iostream
cout << expr1 << … << exprn
 Instruction affichant expr1 puis expr2, etc.

 cout : « flot de sortie » associé à la sortie standard (stdout)
 << : opérateur binaire associatif à gauche, de première opérande
cout et de 2ème l’expression à afficher, et de résultat le flot
de sortie
 << : opérateur surchargé (ou sur-défini) utilisé aussi bien
pour les chaînes de caractères, que les entiers, les réels etc.
cout et cin
Entrées/sorties fournies à travers la librairie iostream
cin >> var1 >> … >> varn
 Instruction affectant aux variables var1, var2, etc. les valeurs

lues (au clavier).
 cin : « flot d’entrée » associée à l’entrée standard (stdin)
 >> : opérateur similaire à <<
22
16/10/2021
INTERET DE cin, cout ET cerr

Vitesse d’exécution plus rapide :
 la fonction printf doit analyser à l’exécution la chaîne de formatage,
 tandis qu’avec les flots, la traduction est faite à la compilation.
Vérification de type : pas d’affichage erroné

#include <stdio.h>
#include <iostream.h>
void main() {
int i=1234;
double d=567.89;
printf("i= %d d= %d !!!!!\n", i, d);// érreur: %lf normalement
cout << "i= " << i << " d= " << d << "\n";
}
/* Résultat de l’exécution ************
i= 1234 d= −5243 !!!!!!!
i= 1234 d= 567.89
*******************************/
LES MANIPULATEURS
Les manipulateurs sont des éléments qui modifient la façon
dont les éléments sont lus ou écrits dans le flot.
Les principaux manipulateurs sont :
23
16/10/2021
Exemple
Les instructions de contrôle
24
16/10/2021
Condition : if(…) … else if(….) … else…
49
Condition : if(…) … else if(….) … else…
25
16/10/2021
Choix multiple à liste de cas : switch
26
16/10/2021
27
16/10/2021
Tant que... et Faire ... tant que :

while(...) {...} et do {...} while(...);
Tant que... et Faire ... tant que :

while(...) {...} et do {...} while(...);
28
16/10/2021
Boucle for(...;...;...) ...
Boucle for(...;...;...) ...
29
16/10/2021
Instructions: break, continue et goto
L’instruction break pour les boucles interrompre le déroulement

de la boucle, en passant à l’instruction qui suit cette boucle.

L’instruction continue, permet de passer au tour suivant de la boucle.
30
16/10/2021

L’instruction continue, permet de passer au tour suivant de la boucle.

L’instruction goto permet le branchement en un emplacement quelconque du
programme.
31
16/10/2021
Tableaux
Tableau
 Un tableau est une variable qui contient un ensemble de

variable de même type.
 Les éléments du tableau sont repérés, respectivement par un

ensemble d’indices.
 Les éléments de ce tableau sont rangés, respectivement en

des positions mémoire successives.
32
16/10/2021
Déclaration
La déclaration du tableau se fait de la façon suivante:
Type nomtableau[Taille]
 Type: Le type des éléments du tableau

 Nomtableau: c’est le nom du tableau (identificateur).
 Taille: C’est le nombre d’éléments qui contient ce tableau.
Exemple:
char car[10];
int nomb[9];
Initialisation
La déclaration et l’initialisation du tableau se fait de la façon

suivante:
Type nomtableau[Taille]={C1, C2, …., CN}
Où C1, C2, …., CN sont des constantes.
 Si le nombre de ces constantes est inférieur à la taille du

tableau, alors les autres éléments sont initialisés par zéros.
 Si le nombre de ces constantes est supérieur à la taille du

tableau, alors le compilateur affiche erreur.
33
16/10/2021
initialisation
Exemple:
int A[5] = {15, 23, 34, 45, 56};// correcte
int A[5] = {15, 23, 34}; //correcte
int A[5] = {15, 23, 34, 50, 33, 2}; // erreur
Initialisation et réservation automatique.
Si la taille n'est pas indiquée explicitement lors de

l'initialisation, alors l'ordinateur réserve
automatiquement le nombre d'octets nécessaires.
Exemple:
short A[] = {1200, 2300, 3400, 4500, 5600};
réservation de 5*sizeof(short) octets

(dans notre cas : 10 octets)
34
16/10/2021
Initialisation et réservation automatique.

Exemple:
Accès aux composantes
Pour accéder à un élément du tableau, il suffit de donner le nom du

tableau, suivi de l’indice de l’élément entre crochets:
Nom_du_Tableau[indice]
 Où indice est une expression entière positive ou nulle.

 L’indice du premier élément du tableau est O.
 L’indice du dernier élément du tableau est la dimension de ce
tableau –1.
35
16/10/2021
Exemple:
Nom_du_Tableau[indice]
Affichage:
for(i=0; i<5; i++)

cout<< A[i];
lecture:
for(i=0; i<5; i++)

cin >> A[i];
36
16/10/2021
TD
Trie de bulle
 On parcourt la suite t[0] ... t[N-1] en échangeant les
éléments consécutifs t[j-1] > t[j]
 On parcourt la suite t[0] ... t[N-2] en échangeant les

éléments consécutifs t[j-1] > t[j], etc.
37
16/10/2021
Trie de bulle
L=N-1 ;
While(L>0){
FIN=0;
for (j=0; j<L; j++)
if (A[j]>A[j+1]){
AIDE=A[j];
A[j]=A[j+1];
A[j+1]=AIDE;
FIN=j;
}
L=FIN;
}
Tri par sélection

 On recherche le plus petit élément t[i] de la suite
t[0] ... t[N-1] et on l'échange avec t[0]

t[1] ... t[N-1] et on l'échange avec t[1], etc
38
16/10/2021
Tri par sélection

t[1] ... t[N-1] et on l'échange avec t[1], etc
int i, j, min;
for (i = 0; i < N - 1; i++)
{
min = i;
for (j = i +1; j < N; j++)
if (t[j] < t[min])
min = j;
Echanger(i, min);
}
Tri par insertion

 On suppose les i-1 premiers éléments triés et on insère le
i-ème à sa place parmi les i premiers
39
16/10/2021
Tri par insertion

 On suppose les i-1 premiers éléments triés et on insère le
i-ème à sa place parmi les i premiers
int i, j, v;
for (i = 1; i < N; i++)
{
v = t[i];
j = i;
while ((j > 0) && (t[j-1] > v))
{
t[j] = t[j-1];
--j;
}
t[j] = v;
}
Tableau à plusieurs dimensions
Définition:
 En C++, un tableau à deux dimensions A est à
interpréter comme un tableau (unidimensionnel) de
taille L dont chaque composante est un tableau
(unidimensionnel) de taille C.
 On appelle L le nombre de lignes du tableau et C le

nombre de colonnes du tableau.
 Un tableau à deux dimensions contient donc L*C

composantes.
40
16/10/2021
Initialisation
 Lors de la déclaration d'un tableau, on peut

initialiser les composantes du tableau.
 Les valeurs sont affectées ligne par ligne.
Exemple:
int A[3][5]={{0, 1, 2, 3, 4},
{10, 11, 12, 13, 14},
{20, 21, 22, 23, 24}};
Initialisation
Exemple:
41
16/10/2021
Initialisation
Exemple:
Ces déclarations sont correctes mais ne sont pas équivalentes.
Initialisation
Exemple:
42
16/10/2021
Accès aux éléments du tableau
Les éléments d'un tableau de taille L et C se présentent de la

façon suivante :
Pour accéder à un élément du tableau,
NomTableau[Ligne][Colonne]
Lecture
Lecture des éléments du tableau

#include<iostream>
using namespace sdt;
main()
{
int i, j;
int Tab[15][15];
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
cin >> Tab[i][j] ;
}
}
return 0;
}
43
16/10/2021
Affichage
Affichage des éléments du tableau:
#include<iostream>
using namespace std;
int main()
{
int i, j;
int Tab[15][15];
for(i=0; i<15; i++)
{
for(j=0; j<15; j++)
{
cout << Tab[i][j]) ;
}
}
return 0;
}
Ex: 1
Soient T1 et T2 deux tableaux de deux dimensions de même taille 8x8.
Ecrire un programme en C++ qui lit les valeurs des éléments du premier
tableau T1 à partir du clavier et qui calcule les valeurs des éléments du
deuxième tableau T2 par la formule suivante:
avec, pour k= i ou j:
44
16/10/2021
Ex: 2
La Somme des Différences Absolues (SAD) de deux tableaux de deux
dimensions T1 et T2 de même taille est donnée par la formule suivante:
N et M représentent respectivement le nombre de lignes et le nombre de colonnes.

T1(i,j) et T2(i,j) représentent respectivement les valeurs des éléments (d'indices i et j) du
tableau T1 et T2.
1-Ecrire un programme en C qui calcule la valeur SAD de deux tableaux de taille 4x4
(nombre de lignes égal le nombre de colonnes égal à 4).
Soit T1 un tableau de taille 4x4 et T2 un tableau de taille 144x176.
2-Ecrire un programme en C qui calcule les valeurs SAD du tableau T1 avec

tous les tableaux de taille 4x4 du tableau T2. On note que T2 contient
((144/4)*(176/4)) tableaux de taille 4x4.
Pointeurs && Références
45
16/10/2021
Abderrahmane ELYOUSFI 91
Introdudction
 Toute variable manipulée dans un programme est stockée quelque part
en mémoire centrale.
 Cette mémoire est constituée d'octets qui sont identifiés de manière

univoque par un numéro qu'on appelle adresse.
 Pour retrouver une variable, il suffit donc de connaître l'adresse de

l'octet où elle est stockée (ou, s'il s'agit d'une variable qui recouvre
plusieurs octets contigus, l'adresse du premier de ces octets).
 Pour des raisons évidentes de lisibilité, on désigne souvent les variables

par des identificateurs, et non par leur adresse.
92
Abderrahm
ane
92 ELYOUSFI
46
16/10/2021
La mémoire
Organisation
Adresse Contenu
0123456 0
0123457 17
0123458 0
0123459 129 Valeur entre 0 et 255
0123460 14
Case mémoire
0123461 82
0123462 53
0123463 60
0123464 0
Mémoire
Abderrahm
ane
94 ELYOUSFI
47
16/10/2021
Organisation
Adresse Nom Contenu

0123456 zone 1 0
0123457 zone 2 17
0123458 0
0123459 zone 3 129
0123460 zone 4 14
0123461 82
0123462 53
0123463 60
0123464 zone 5 0
Mémoire
Abderrahm
ane
95 ELYOUSFI
Variables
Instructions du programme Mémoire
int a; Adresse Nom Contenu

0123456 ?
int b;
0123457 ?
0123458 ?
0123459 ?
0123460 ?
0123461 ?
0123462 ?
0123463 ?
0123464 ?
Abderrahm
ane
96 ELYOUSFI
48
16/10/2021
Variables

0123456 a ?
int b; 0123457 ?
0123458 ?
0123459 ?
0123460 b ?
0123461 ?
0123462 ?
0123463 ?
0123464 ?
Abderrahm
ane
97 ELYOUSFI
Variables

0123456 a ?
int b; 0123457 ?
0123458 ?
0123459 ?
0123460 b ?
0123461 ?
0123462 ?
0123463 ?
0123464 ?
Abderrahm
ane
98 ELYOUSFI
49
16/10/2021
Variables

0123456 a ?
int b; 0123457 ?
0123458 ?
a=1; 0123459 ?
b=255; 0123460 b ?
0123461 ?
0123462 ?
0123463 ?
0123464 ?
Abderrahm
ane
99 ELYOUSFI
Variables

0123456 a 1
int b; 0123457 0
0123458 0
a=1; 0123459 0
b=255; 0123460 b 255
0123461 0
b+=a; 0123462 0
0123463 0
0123464 ?
Abderrahm
ane
100 ELYOUSFI
50
16/10/2021
Variables

0123456 a 1
int b; 0123457 0
0123458 0
a=1; 0123459 0
b=255; 0123460 b 0
0123461 1
b+=a; 0123462 0
0123463 0
0123464 ?
Abderrahm
ane
101 ELYOUSFI
Variables
char a = 1; Adresse Nom Contenu

0123456 a 1
short int b = 32000;
0123457 b
32000
0123458
long int c = 65536; 0123459 c
0123460
65536
0123461
0123462
0123463 ?
0123464 ?
Abderrahm
ane
102 ELYOUSFI
51
16/10/2021
Tableaux
short int tab[4]; Adresse Nom Contenu

0123456 tab [0]
?
0123457
0123458 [1]
?
0123459
0123460 [2]
?
0123461
0123462 [3]
?
0123463
0123464 ?
Abderrahm
ane
103 ELYOUSFI
Les pointeurs
52
16/10/2021
Notion de pointeur
 Un pointeur est une variable permettant de
stocker une adresse-mémoire
 Déclaration :
type *pointeur ;
 le type est celui des variables auxquelles permet d’accéder le
pointeur Abderrahm
ane
105 ELYOUSFI
Affectation d’un pointeur

 Affectation de l’adresse d’une variable :
int x, *px ;
px = &x ;
 Affectation de l’adresse d’un tableau :

int tb1[10], *p ;
p = tb1; /* p pointe sur la première case de tb1 */
ou
p = &(tb1[0]) ;
Abderrahm
ane
106 ELYOUSFI
53
16/10/2021
Affectation d’un pointeur

Zéro
 Zéro est une constante intégral, virgule flottante,

ou pointeur.
 Aucun objet n’est alloué avec l’adresse 0.
 Par conséquent, 0 pour un pointeur indique que ce

pointeur ne fait pas référence à un objet.
Abderrahm
ane
107 ELYOUSFI
Arithmétique de pointeurs
 L’addition et la soustraction fonctionnent comme
avec les adresses…
int tb1[10], *p1, *p2 ;
p1 = tb1 + 3 ; /* p1 pointe sur tb1[3] */
p2 = p1 – 1 ; /* p2 pointe sur tb1[2] */
Abderrahm
ane
108 ELYOUSFI
54
16/10/2021
Opérateur *
 Permet d’accéder au contenu d’une variable par un
pointeur :
int x, y, *p ;
x = 10 ;
p = &x ;
y = *p ; /* y doit contenir 10 */
 Fonctionne aussi avec les adresses :

*(tab + 3) est équivalent à tab[3]
Abderrahm
ane
109 ELYOUSFI
Variables
int *ptr; Adresse Nom Contenu

0123456 ptr
int b; 0123457
?
0123458
ptr = &b;
0123459
*ptr = 1; 0123460 b
0123461
?
b = 2; 0123462
0123463
b = b + *ptr; 0123464 0
Abderrahm
ane
110 ELYOUSFI
55
16/10/2021
Variables

0123456 ptr
int b; 0123457
0123460
0123458
ptr = &b; 0123459
*ptr = 1; 0123460 b
0123461
?
b = 2; 0123462
0123463
b = b + *ptr; 0123464 0
Abderrahm
ane
111 ELYOUSFI
Variables

0123456 ptr
int b; 0123457
0123460
0123458
ptr = &b; 0123459
*ptr = 1; 0123460 b
0123461
1
b = 2; 0123462
0123463
b = b + *ptr; 0123464 0
Abderrahm
ane
112 ELYOUSFI
56
16/10/2021
Variables

0123456 ptr
int b; 0123457
0123460
0123458
ptr = &b; 0123459
*ptr = 1; 0123460 b
0123461
2
b = 2; 0123462
0123463
b = b + *ptr; 0123464 0
Abderrahm
ane
113 ELYOUSFI
Variables

0123456 ptr
int b; 0123457
0123460
0123458
ptr = &b; 0123459
*ptr = 1; 0123460 b
0123461
4
b = 2; 0123462
0123463
b = b + *ptr; 0123464 0
Abderrahm
ane
114 ELYOUSFI
57
16/10/2021
Tableaux
Adresse Nom Contenu

short int *ptr; 0123456 ptr
short int tab[4]; 0123457
?
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab
?
ptr+=2; 0123461
0123462
*ptr = 512; ?
0123463
0123464
?
0123465
0123466
?
0123467
Abderrahm
ane
115 ELYOUSFI
Tableaux
Adresse Nom Contenu

0123460
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab [0]
?
ptr+=2; 0123461
0123462 [1]
*ptr = 512; ?
0123463
0123464 [2]
?
0123465
0123466 [3]
?
0123467
Abderrahm
ane
116 ELYOUSFI
58
16/10/2021
Tableaux
Adresse Nom Contenu

0123460
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab [0]
3141
ptr+=2; 0123461
0123462 [1]
*ptr = 512; ?
0123463
0123464 [2]
?
0123465
0123466 [3]
?
0123467
Abderrahm
ane
117 ELYOUSFI
Tableaux
Adresse Nom Contenu

0123464
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab [0]
3141
ptr+=2; 0123461
0123462 [1]
*ptr = 512; ?
0123463
0123464 [2]
?
0123465
0123466 [3]
?
0123467
Abderrahm
ane
118 ELYOUSFI
59
16/10/2021
Tableaux
Adresse Nom Contenu

0123464
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab [0]
3141
ptr+=2; 0123461
0123462 [1]
*ptr = 512; ?
0123463
0123464 [2]
512
0123465
0123466 [3]
?
0123467
Abderrahm
ane
119 ELYOUSFI
Tableaux
Adresse Nom Contenu

0123464
0123458
ptr = tab;
0123459
*ptr = 3141; 0123460 tab [0]
3141
ptr+=2; 0123461
0123462 [1]
*ptr = 512; ?
0123463
0123464 [2]
512
0123465
0123466 [3]
?
0123467
Abderrahm
ane
120 ELYOUSFI
60
16/10/2021
Pointeur et constante
Constante
Les habitués du C ont l’habitude d’utiliser la directive du
préprocesseur #define pour définir des constantes.
Il est reconnu que l’utilisation du préprocesseur est une source
d’erreurs difficiles à détecter.
En C++, l’utilisation du préprocesseur se limite aux cas les
plus sûrs : inclusion de fichiers
 Le mot réservé const permet de définir une constante.

 Il est possible d’ajouter le mot clé const à la déclaration
d’un objet afin de le rendre constant.
 Une valeur ne pouvant pas être attribuée à une constante,
celle-ci doit être initialisée.
const int N = 10; // N est un entier constant.
61
16/10/2021
Constante
const int N = 10; // N est un entier constant.
const int t[]={1, 2, 3, 4, 5}; // t[i] est une constante.
const int x; // erreur: pas d’initialisateur
Les pointeurs et les constantes
62
16/10/2021

L’utilisation d’un pointeur implique deux objets:
Le pointeur lui-même et l’objet pointé.
int y=20;
int x = 10;
const int *px = &x; // pointeur de constante
*px = 6; // erreur: pc pointe sur une constante
px = &y; // ok, pointeur pc n’est pas constant
--------------------------------------------------------------------------------------------------
int *const py = &y; // pointeur constant.
*py = 9; // ok
py = px; // erreur: cp n’est pas constant
--------------------------------------------------------------------------------------------------
const int *const pz = &z; // pointeur const de const
pz = 7; // erreur: cpc pointe sur une constante
pz = px; // erreur: cpc est une constante

 En préfixant la déclaration d’un pointeur avec const, l’objet

devient une constante.
 Pour déclarer le pointeur comme une constante, nous utilisons la

déclaration *const plutôt que simplement *.
63
16/10/2021

char s[ ] = “Gorm”;
const char* pc = s; // pointeur de constante
pc[3] = ‘g’; // erreur: pc pointe sur une constante
pc = p; // ok, pointeur pc n’est pas constant
char *const cp = s; // pointeur constant.

cp[3] = ‘a’; // ok
cp = p; // erreur: cp n’est pas constant
const char *const cpc = s; // pointeur const de const

cpc[3] = ‘a’; // erreur: cpc pointe sur une constante
cpc = p; // erreur: cpc est une constante

Vous pouvez attribuer l’adresse d’une variable à un pointeur constant.
L’adresse d’une constante ne peut être attribuée que à un pointeur

constant.
int a=1;
const int c=2;
const int* p1=&c; //ok
const int* p2=&a; //ok
int* p3=&c; // erreur: initialisation de int* avec const int*
*p3 = 7; // tente de modifier la valeur de c
64
16/10/2021
La gestion dynamique :
les opérateurs new et delete
Allocation Mémoire
Le C++ met à la disposition du programmeur deux opérateurs
new et delete pour remplacer respectivement les fonctions
malloc et free .
(bien qu’il soit toujours possible de les utiliser).
 L’opérateur new
 L’opérateur delete
130
65
16/10/2021
La gestion dynamique
L’opérateur new
L’opérateur new réserve l’espace mémoire qu’on lui
demande et l’initialise.
Il retourne:
soit l’adresse de début de la zone mémoire allouée,
soit 0 si l’opération à échouée.
131
L’opérateur new:
int *ptr1, *ptr2, *ptr3;
// allocation dynamique d’un entier

ptr1 = new int;
// allocation d’un tableau de 10 entiers

ptr2 = new int [10];
// allocation d’un entier avec initialisation

ptr3 = new int(10);
132
66
16/10/2021
L’opérateur delete:
L’opérateur delete libère l’espace mémoire alloué par new à
un seul objet, tandis que l’opérateur delete[] libère
l’espace mémoire alloué à un tableau d’objets.
// libération d’un entier

delete ptr1;
// libération d’un tableau d’entier
delete[] ptr2;
 A chaque instruction new doit correspondre une instruction delete.
 Il est important de libérer l’espace mémoire dès que celui ci n’est plus
nécessaire.
 La mémoire allouée en cours de programme sera libérée automatiquement à la
fin du programme.
133
Deux opérateurs : new et delete
float *PointeurSurReel = new float; // Équivalent en C :

//PointeurSurReel = (float *) malloc(sizeof(float));
int *PointeurSurEntier = new int[20]; // Équivalent en C :

//PointeurSurEntier = (int *) malloc(20 * sizeof(int));
delete PointeurSurReel; // Équivalent en C : free(pf);

delete [] PointeurSurEntier; // Équivalent en C : free(pi);
67
16/10/2021
Références
Variables références
En plus des variables normales et des
pointeurs, le C++ offre les variables
références.
Une variable référence permet de créer une

variable qui est un "synonyme" d'une autre.
Dès lors, une modification de l'une

affectera le contenu de l'autre.
68
16/10/2021
int x;
int & y = x; // y est une référence à x
int *ptr;
x=1;
cout << "x= " << x << " y= " << y << endl;
// affichage de : x= 1 y= 1
y=2;
cout << "x= " << x << " y= " << y << endl;
ptr = &y;
*ptr = 3;
cout << "x= " << x << " y= " << y << endl;
69
16/10/2021
 Une variable référence doit obligatoirement être
initialisée et le type de l'objet initial doit être
le même que l'objet référence.
 Intérêt :
 passage des paramètres par référence
Pointeurs et tableaux à une

dimension
70
16/10/2021
POINTEURS ET TABLEAUX
 L'usage des pointeurs en C++ est, en grande
partie, orienté vers la manipulation des tableaux.
141
Abderrahm
ane
141 ELYOUSFI
POINTEURS ET TABLEAUX À UNE DIMENSION
 Tout tableau en C++ est en fait un pointeur

constant.
 Dans la déclaration int tab[10];
 tab est un pointeur constant (non modifiable)
dont la valeur est l'adresse du premier élément du
tableau.
 Autrement dit, tab a pour valeur &tab[0].
142
Abderrahm
ane
142 ELYOUSFI
71
16/10/2021
 On peut utiliser le nom du tableau tab comme

pointeur pour parcourir les éléments du
tableau.
*(tab+i) équivalent à tab[i]
(tab+i) équivalent à &tab[i]
const N=5;
int tab[5] = {1, 2, 6, 0, 7};
main()
{
int i;
for (i = 0; i < N; i++)
{
cout << *(tab+i); 143
} Abderrahm
ane
} 143 ELYOUSFI
 On peut utiliser un pointeur initialisé à tab pour

parcourir les éléments du tableau.
const int N=5;

int tab[5] = {1, 2, 6, 0, 7};
main()
{
int i;
int *p;
p = tab;
for (i = 0; i < N; i++)
{
cout <<*p;
p++;
} 144
} Abderrahm
ane
144 ELYOUSFI
72
16/10/2021

#include<stdio.h>
#include<iostream>
main()
{
int i;
int *p;
p= new int [5];
//p= (int*)malloc(5*sizeof(int));
for (i = 0; i < 5; i++)
{
cout <<"entrer une valeur”;
cin >> (p+i);
}
for (i = 0; i < 5; i++)
{
cout << (*(p+i));
}
145
system("pause");
Abderrahm
} ane
145 ELYOUSFI

 Pointeurs et tableaux se manipulent donc exactement de
même manière.
p[i] équivalent à *(p + i)
 Le programme précédent peut aussi s'écrire
const N=5;
int tab[5] = {1, 2, 6, 0, 7};
main()
{
int i;
int *p;
p = tab;
for (i = 0; i < N; i++)
{
cout << p[i];
} 146
} Abderrahm
ane
146 ELYOUSFI
73
16/10/2021
Pointeurs et tableaux à
plusieurs dimensions
Pointeurs et tableaux à plusieurs

dimensions
Un tableau à deux dimensions
type tab[N][M]
réserve N*M variables, dans l'ordre
T[0][0], T[0][1], …T[0][M-1], T[1][0],…,T[N-1][M-1]
Abderrahm
ane
148 ELYOUSFI
74
16/10/2021
Pointeurs et tableaux à plusieurs dimensions

#include <stdio.h>
#include <iostream>
int main()
{
int i, j;
int tab[3][4]= {{1, 2, 3, 4},
{11, 12, 13, 14},
{21, 22, 23, 24}};
for (i = 0; i < 3; i++)
for (j = 0; j < 4; j++)
cout <<tab[i][j]<<"\t tab["<<i<<"]["<<j<<"]\t"<<&tab[i][j];
system("pause");
return 0;
}
149 Abderrahmane ELYOUSFI
 tab[i], pour i entre 0 et N-1,

pointe vers le premier élément de
la ligne d'indice i;
 tab[i] a la valeur &tab[i][0]
Abderrahm
ane
150 ELYOUSFI
75
16/10/2021

#include <stdio.h>
#include <iostream>
int main()
{
int i, j;
int tab[3][4]= {{1, 2, 3, 4},
{11, 12, 13, 14},
{21, 22, 23, 24}};
for (i = 0; i < 3; i++)
cout<<"*(tab["<<i<<"])= " <<*(tab[i])<<"\t tab["<<i<<"]= "<<tab[i]<<"\t &tab["<<i<<"][0]="<< &tab[i][0]);
system("pause");
return 0;
}
Abderrahm
ane
151 ELYOUSFI

#include <stdio.h>
#include <iostream>
int main()
{
int i, j;
int tab[3][4]= {{1, 2, 3, 4},
{11, 12, 13, 14},
{21, 22, 23, 24}};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
cout << *(tab[i]+j);
cout << endl;
}
system("pause");
return 0;
}
76
16/10/2021

#include <stdio.h>
#include <iostream>
int main()
{
int i, j;
int tab[3][4]= {{1, 2, 3, 4},
{11, 12, 13, 14},
{21, 22, 23, 24}};
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
cout << *(*(tab+i)+j);
cout << endl;
}
system("pause");
return 0;
Abderrahm
}
ane
153 ELYOUSFI

Adresse Nom Contenu
tab 0123440
0123440 tab [0]

0123457
0123441
0123442 [1]
0123463
0123443
0123444 ?
….
0123457 tab [0][0]
0123458
1
0123459 [0][1]
0123460
2
0123461 [0][2]
0123462
3
0123463 [1][0]
0123464
11
0123465 [1][1]
0123466
12
0123467 [1][2] Abderrahm
0123468
13 ane
154 ELYOUSFI
77
16/10/2021
type **T= new type*[N];
for(i=0; i<N;i++)
{
T[i] = new type[M];
}

int **tableau;
int i, j;
tableau = new int*[N];

for(i=0; i<N; i++)
tableau[i]= new int [M];
for(i=0; i<N; i++)

for(j=0; j<M; j++)
tableau[0][0]=0;
78
16/10/2021
Abderrahm
ane
157 ELYOUSFI
Abderrahm
ane
158 ELYOUSFI
79
16/10/2021

dimensions
int **tableau;
int *le_tableau;
int i;
tableau = new int*[N] ;

le_tableau= new int[N*M];
for(i=0; i<N; i++)

tableau[i]=(le_tableau+i*M);
Abderrahm
ane
159 ELYOUSFI

dimensions
Abderrahm
ane
160 ELYOUSFI
80
16/10/2021
Tableaux de pointeurs
 On peut avoir des tableaux d'objets de n'importe
quel type, donc de pointeurs.
type *tp[10];
Abderrahm
ane
161 ELYOUSFI
#include <stdio.h>
#include <iostream>
main()
{
char *jour[ ]={"lundi", "Mardi", "Mercredi", "Jeudi",
"Vendredi", "Samedi", "Dimanche"};
for (i = 0; i < 2; i++)
cout << **(jour+i);
system("pause");
return 0;
}
Abderrahm
ane
162 ELYOUSFI
81
16/10/2021
#include <stdio.h>
#include <iostream>
main()
{
char *jour[ ]={"lundi", "Mardi", "Mercredi", "Jeudi",
"Vendredi", "Samedi", "Dimanche"};
for (i = 0; i < 2; i++)
printf("%s\n",*(jour+i));
system("pause");
return 0;
}
Abderrahm
ane
163 ELYOUSFI
Pointeurs et les chaines de caractère
82
16/10/2021
Chaine de caractère
Lecture et écriture de chaînes
83
16/10/2021
Chaine de caractère
 Il n’est donc pas possible de lire une chaîne renfermant

un espace.
 Dans la suite, nous verrons comment contourner cette

difficulté en recourant à la méthode getline.
 Nous aurions pu également allouer dynamiquement des

emplacements.
Initialisation de tableaux par des chaînes
84
16/10/2021
Initialisation de tableaux par des chaînes
Cette affectation revient à modifier la valeur du pointeur

ch, sans modifier le contenu de la zone alloué par new.
Initialisation de tableaux de pointeurs sur des chaînes
85
16/10/2021
Pointeur de void
Pointeur générique
Pointeur de void
Le pointeur de tout type d’objet peut être attribué à une variable de

type void*
Il est possible de comparer l’égalité et l’inégalité de ces void*.
un void*, peut être explicitement converti vers un autre type.
86
16/10/2021
Pointeur de void
Le pointeur de tout type d’objet peut être attribué à une variable de
type void*
char c='A';
int i=1;
char *P1=&c;
int *P2=&i;
void *p=P1;
void *q=P2;
------------------------------------------------------
*p; //erreur: l’indirection implicite ne s’applique pas à un type void*
p++; //erreur: on ne peut incrémenter un type void* (la taille de
l’objet pointé est inconnue)
Pointeur de void
Il est possible de comparer l’égalité et l’inégalité de ces void*.
87
16/10/2021
Pointeur de void
char c='A';
int i=14;
char *P1=&c;
int *P2=&i;
int *s=(int *)q;
Fin
BTS IRIS 1ère année POO 176
88

ELy-Cours-C++ - 01 - 2 - 2021-2022 Moodle

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

ELy-Cours-C++ - 01 - 2 - 2021-2022 Moodle

Transféré par

Droits d'auteur :

Formats disponibles

16/10/2021

Université Ibn Zohr Agadir Année universitaire: 2021-2022

Abderrahmane ELYOUSFI Département

Elyousfi Abderrahmane ENSA-3 2

Elyousfi Abderrahmane ENSA-3 3

Elyousfi Abderrahmane ENSA-3 4

Elyousfi Abderrahmane ENSA-3 5

Qu’est-ce que le C++ ?

Certaines des extensions du C++ pourraient en fait être

C++ a introduit de nouvelles possibilités d’entrées-sorties

C++ dispose d’opérateurs de gestion dynamique (new et delete)

Elyousfi Abderrahmane ENSA-3 7

C++ et la bibliothèque standard

Comme tout langage, C++ dispose d’une bibliothèque standard,

Elle comporte notamment de nombreux patrons de classes et de

Elyousfi Abderrahmane ENSA-3 8

Généralités sur le langage C++

Elyousfi Abderrahmane ENSA-3 9

Elyousfi Abderrahmane ENSA-3

Pour écrire des informations : utiliser le flot cout

cout << "Bonjour\n" ;

<< est un opérateur permettant d’envoyer de l’information sur un

L’instruction suivante ressemble à la précédente avec cette différence

Elyousfi Abderrahmane ENSA-3

Pour lire des informations : utiliser le flot cin

>> est un opérateur permettant d’extraire (de lire ) de

cout >> NFOIS ;

Elyousfi Abderrahmane ENSA-3

Les directives à destination du préprocesseur

Les deux premières lignes de notre programme :

iostream contient des déclarations relatives aux flots donc, en

cmath contient des déclarations relatives aux fonctions

Elyousfi Abderrahmane ENSA-3

La norme de C++ a introduit la notion d’« espaces de noms »

Cette notion d’espace de noms sera étudiée par la suite.

Pour l’instant, retenez que les symboles déclarés dans le fichier

Elyousfi Abderrahmane ENSA-3

Quelques règles d’écriture

Elyousfi Abderrahmane ENSA-3 15

les variables, les fonctions, objets, structures, unions ou

Le caractère souligné (_) est considéré comme une lettre. Il peut

Les majuscules et les minuscules sont autorisées mais ne sont pas

Elyousfi Abderrahmane ENSA-3 16

Les mots-clés de C++

Elyousfi Abderrahmane ENSA-3 17

Comme tout langage évolué, C++ autorise la présence de

Il existe deux types de commentaires :

les commentaires « libres », hérités du langage C ;

les commentaires de fin de ligne (introduits par C++).

Elyousfi Abderrahmane ENSA-3 18

 En plus des symboles /* et */ utilisés en C, le langage C++ offre

void main() { // commentaire de fin de ligne valide en C++

Elyousfi Abderrahmane ENSA-3 19

Création d’un programme en C++

Elyousfi Abderrahmane ENSA-3 20

Création d’un programme en C++

L’édition du programme (on dit aussi parfois « saisie »)

En général, ce texte sera conservé dans un fichier que

La plupart du temps, en C++, les fichiers source porteront

Elyousfi Abderrahmane ENSA-3 21

Création d’un programme en C++

L’opération de compilation comporte en fait deux étapes :

Compilation: C’est la traduction en langage machine du texte