Université Cadi Ayyad

Ecole Supérieure de Technologie – Safi

Programmation Orientée Objet

(C++)

Pr. SAID EL ABDELLAOUI

Elabdellaoui.said@yahoo.fr

Cours 1

S. El Abdellaoui
Mohamed
El Nabil
Abdellaoui SaïdSaidi 2020/ 2021
 Planification
Bases du langage
C++
S? S1

Programmation
P.O.O
graphique
S7 S2

C++

Surcharge des S6 S3
Héritage
opérateurs

S5 S4
Héritage multiple Polymorphisme
&
Collection

Mohamed
El Nabil
Abdellaoui SaïdSaidi 2
Partie I

INTRODUCTION

Mohamed
El Nabil
Abdellaoui SaïdSaidi 3
 Introduction

 Dans la programmation, on trouve deux grands mode :

 Procédurale
 Orienté Objet ( O.O )

 Procédurale : Les notions de variables/types de données et de traitement de ces données étaient

séparées :

Opèrent sur O.O

Traitement Données

Objet Influencent

Mohamed
El Nabil
Abdellaoui SaïdSaidi 4
 Introduction
 Les deux pilier de la programmation orientée objet sont

 Encapsulation désigne le principe de regrouper des données avec les méthodes dans
une seule entité, et aussi et limitant l'accès à certains composants de l'objet.

Données
de
Fonctionnalités l’objet

Question

Réponse

Objet 2 Objet 1

Mohamed
El Nabil
Abdellaoui SaïdSaidi 5
 Introduction
 Les deux pilier de la programmation orientée objet sont

 Abstraction est le processus qui consiste à représenter des objets qui appartiennent au
monde réel dans le monde du programmation. Il s'agit aussi du processus consistant à
cacher les détails de mise en œuvre internes à l'utilisateur et à ne fournir que les
fonctionnalités nécessaires aux utilisateurs.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 6
Partie II

GÉNÉRALITÉS

Mohamed
El Nabil
Abdellaoui SaïdSaidi 7
 Introduction

Figure 1 : Les langages de programmation classés par ‘niveau’.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 8
 Introduction

 Dans la programmation, on trouve deux grands mode :

 Procédurale  Orienté Objet ( O.O )

#include <iostream>
using namespace std;
// Méthodes!! Géométrie
double surface (double largeur, double hauteur){
return (largeur × hauteur); }
main () { + largeur : double
// Déclarations!! + hauteur : double
double largeur = 3.0;
double hauteur = 4.0 ;
// Affichage !! +surface (): double
cout << " Surface du rectangle :"<< surface (largeur, hauteur);
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 9
 Introduction & Historique

 Créé en 1980
 Langage évolué et structuré :

 Programme séparé en fichier

 Fichier séparé en fonctions

 Fonction séparée en blocs

 Possède les fonctionnalités de la programmation orienté objet (P.O.O)
 Caractéristique du langage C++

 Normalisé par la norme ANSI/ISO en 1998

 Portable (de nombreux environnement/compilateurs disponibles)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 10
 Structure d’un programme C++

 Les étapes permettant l’édition, la mise au point, l’exécution d'un programme C++

Fichier C++ Code objet

(*.cpp) (*.obj)
Fichier C++ Compilateur Code objet
(*.cpp) (*.obj)
Fichier C++ Code objet
(*.cpp) (*.obj)

Programme
Bibliothèque Exécutable
Editeur de liens
(*.exe)
Bibliothèque

Figure 2 : C++ est un langage compilé.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 11
 Avantages
 Le langage C++ prétendre être un langage C amélioré.
 Il possède des fonctionnalités supplémentaires, et notamment

 la surcharge de fonctions

 le passage par référence

 l'emplacement des déclarations

 l'allocation dynamique
 Les apports spécifiques de C++ sont

 l'aide à l'abstraction de données: définition de types de données, et de leur implémentation

concrète.

 l'aide à la programmation objet: hiérarchie de classes et héritage.

 l'aide à la programmation générique: classes patron et algorithmes génériques.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 12
 1er programme
 Exemples :

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;

main () {
Bonjour tout le monde
//Affichage à l’écran --------------------------------
cout << "Bonjour tout le monde"; Process exited with return value 0
} Press any key to continue . . .

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;

main () {
Bonjour tout le monde !
//Affichage à l’écran Aurevoir !
cout << " Bonjour tout le monde ! " <<endl; --------------------------------
cout << " Aurevoir ! "; Process exited with return value 0
} Press any key to continue . . .

Mohamed
El Nabil
Abdellaoui SaïdSaidi 13
 2éme programme
 Exemple :

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;

main () {
//Déclaration des variables
int annee_creation;
int NousSommesEn;
int difference;

// Affectation des variables

annee_creation (2013); // équivalant à ‘=’
NousSommesEn (2020);

difference = NousSommesEn - annee_creation;

//Affichage à l’écran des résultats

cout << "La filière GI de Safi";
cout << "a ete cree depuis "<< annee_creation;
cout << "Ce qui fait : " << difference << "ans !";
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 14
Syntaxe : Saisie et affichage des données
 Entrées/sorties fournies à travers la librairie iostream :
 attaché à l'entrée standard : cin (Saisir)
 attaché à la sortie erreur standard cerr (erreur)
 attaché à la sortie standard; : cout (affichage)
 Deux opérateurs sont surchargés de manière appropriée pour les flots:
 l'opérateur d' insertion << (écriture)
 l'opérateur d' extraction >> (lecture)
 Exemple :

#include <iostream>
using namespace std;
int i;
main() {
cout << "Un entier : ";
N’oubliez cin >> i;
pas d’inclure cout << "Le carre de " << i <<" est " << i*i << endl;
la bibliothèque }
iostream

 Exercice 1 de TD 1:

Mohamed
El Nabil
Abdellaoui SaïdSaidi 15
 Exercice applicatif de TD

 Écrivez un programme age.cc qui :

a) demande à l'utilisateur son âge ;

b) lit la réponse de l'utilisateur et l'enregistre dans une variable age de type

entier ;

c) calcule l'année de naissance (à un an près) de l'utilisateur et l'enregistre dans

la variable annee de type entier ;

d) affiche l'année de naissance ainsi calculée.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 16
 Solution ordinaire

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;

main () {
//Déclaration des variables
int age;
int NousSommesEn (2020);
int difference;

// Demande de l’age
cout << "Entrez votre age:" ;
cin>> age;

difference = NousSommesEn - age;

//Affichage à l’écran des résultats

cout << " Votre annee de naissance est: " << difference;

Mohamed
El Nabil
Abdellaoui SaïdSaidi 17
 Solution parfaite

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;

main () {
//Déclaration des variables Récupération
int age; de l’année
int NousSommesEn (…………); actuelle du système
int difference;

// Demande de l’age
cout << "Entrez votre age:" ;
cin>> age;

difference = NousSommesEn - age;

//Affichage à l’écran des résultats

cout << " Votre annee de naissance est: " << difference;

Mohamed
El Nabil
Abdellaoui SaïdSaidi 18
Partie III

BASES DU LANGAGE
C++

Mohamed
El Nabil
Abdellaoui SaïdSaidi 19
 Syntaxe

 Chaque déclaration/instruction se termine par un point-virgule

 Différence entre le majuscule et le minuscule,
 Les commentaires:

\* Ceci est un commentaire sur plusieurs lignes

...
Fin du commentaire*/

// Ceci est un commentaire sur une ligne

 Vous devez commenter votre code ! Cela aide les lecteurs a comprendre le
code.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 20
 Variables et Fonctions

Opèrent sur

Traitement Données
( Fonctions ) ( Variables )

Influencent

Mohamed
El Nabil
Abdellaoui SaïdSaidi 21
 Variables
 Définition d’une variable :

 Nom :
 Unique pour chaque variable
 Commence toujours par une lettre
 Différenciation minuscule-majuscule
 Type :
 Conditionne le format de la variable en mémoire
 Peut être soit un type standard ou un type utilisateur
 Valeur :
 Peut évoluer pendant l'exécution
 Initialisation grâce à l'opérateur d'affectation

Mohamed
El Nabil
Abdellaoui SaïdSaidi 22
 Variables
 Les types élémentaires :

Mohamed
El Nabil
Abdellaoui SaïdSaidi 23
 Variables

#include <iostream>
using namespace std;  Variables globales :

 Définies hors de toutes fonctions

const float PI = 3.14159;
 Vues par toutes les fonctions du fichier
main ()
source
{
float rayon = 5.458;  Persistante pendant toute la durée de
float perimetre;
vie du programme
// calcul périmètre
perimetre = PI * 2* rayon;
 Variables locales:
cout << "perimetre p = " << perimetre << endl;
 Déclarées à l’intérieur d’une fonction
}  Détruites en sortie de fonction

Mohamed
El Nabil
Abdellaoui SaïdSaidi 24
 Méthodes

 Déclaration d’une méthode (dans l’ordre)

1. Modificateurs (optionnels)

2. Type de retour

3. Nom

4. Liste de paramètres typés entre parenthèses

5. Liste d’exceptions (optionnel, expliqué plus tard)

6. Corps de déclaration entouré par { et }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 25
 Méthodes

 Une fonction pour le but d’effectuer une certaine tâche.

 Elle rends un ensemble des instructions réutilisables dans d'autres contextes.

 Une fonction pourra appeler d'autres fonctions et ainsi de suite et elle peut même appeler
elle-même ( fonctions récursives )

 Syntaxe :

type identificateur(paramètres);

 Exemple :

double f (double x, double y);

Mohamed
El Nabil
Abdellaoui SaïdSaidi 26
 Méthodes
Problématique :
Nb
#include <iostream> a

using namespace std; 4

64
// méthode
int ajouteDeux(int a) { a+=2;
return a; }
Res
main () {
// calcul périmètre 6?
int Nb(4), res;
res = ajouteDeux(Nb);
cout << " Le nombre original vaut : "<< Nb << endl;
cout << " Le resultat vaut : " << Res << endl;
Le nombre original vaut : 4
} Le resultat vaut : 6 :

Mohamed
El Nabil
Abdellaoui SaïdSaidi 27
 Méthodes

Passage par référence :

 Enfin le passage par référence qui manque au C.

 Un paramètre dont le nom est suivi de & est transmis par référence, donc

 pas de copie de l'argument à l'appel;

 possibilité de modifier l'argument.

 Déclaration
void echange(float&, float&) ;

 Définition
void echange(float& a, float& b) {
float t = a; a = b; b = t;
}

 Exemple :

float x = 2, y = 3;
echange (x, y);
cout << x <<","<< y; //Affiche 3,2

Mohamed
El Nabil
Abdellaoui SaïdSaidi 28
 Méthodes
Problématique :
a Nb
#include <iostream>
using namespace std; 4
// méthode
int ajouteDeux(int& a) { a+=2;
Res
return a; }
main () { 6
// calcul périmètre
int Nb(4), Res;
res = ajouteDeux(Nb);
cout << " Le nombre original vaut : "<< Nb << endl;
cout << " Le resultat vaut : " << Res << endl;
Le nombre original vaut : 4
} Le resultat vaut : 6 :

Mohamed
El Nabil
Abdellaoui SaïdSaidi 29
 Méthodes

Passage par référence constante :

 Passage par référence constante pour

 ne pas copier l'argument à l'appel;

 ne pas modifier l'argument :

 Passage par référence constante permet d'assurer l'encapsulation en évitant la copie sur la pile
de structures trop grande.

void afficher(const objet&);

Mohamed
El Nabil
Abdellaoui SaïdSaidi 30
 Méthodes
Arguments par défaut :

 Les derniers arguments d'une fonction/méthode peuvent prendre des "valeurs par défaut''.
 Déclaration
float f(char, int = 10, char* = "Tout");

 Appels

f(c, n, "rien")
f(c, n) // <-> f(c, n, "Tout")
f(c) // <-> f(c,10, "Tout")
f() // erreur

 Seuls les derniers arguments peuvent avoir des valeurs par défaut.

float f(char = 'a', int, char* = "Tout"); // erreur

Mohamed
El Nabil
Abdellaoui SaïdSaidi 31
 Méthodes
Surcharge :
 Un même identificateur peut désigner plusieurs fonctions, si elles diffèrent par la liste
des types de leurs arguments.

float max(float a, float b) { return (a > b) ? a : b;}

float max(float a, float b, float c) {

return max(a, max(b, c));}

float max(int n, float t[]) {

if (!n) return 0;
float m = t[1]; for (int i = 2 ; i < n; i++)
m = max(m, t[i]);
return m;
}

void main() {
float x, y, z;
float T[] ={11.1, 22.2, 33.3, 44.4, 7.7, 8.8 };
x = max (1.86, 3.14);
y = max (1.86, 3.14, 37.2);
z = max (6, T);
cout << x <<" "<< y <<" "<< z;

Mohamed
El Nabil
Abdellaoui SaïdSaidi 32
 Les opérateurs
 Affectation : =
 Opérateurs arithmétiques
 Addition: + Soustraction: -
 Multiplication: * Division: / (division entière dans le cas de int)
 Modulo: % (reste de la division entière)
 Opérateurs arithmétiques unaires (un seul opérande)
 Moins unaire: - Incrémentation: ++ Decrémentation: --
 Opérateurs logiques
 Négation: !
 ET logique: &&
 OU logique: ||
 Opérateurs de relation ( ils rendent 1 si la condition est vrai et 0 sinon)
 < , > , <= , >= , == , !=

Mohamed
El Nabil
Abdellaoui SaïdSaidi 33
 Instructions de contrôle (1/5)
 Contrôler le déroulement de l’enchaînement des instructions à l’intérieur d’un
programme, ces instructions peuvent être des instructions conditionnelles ou
itératives
 Instructions conditionnelles : if ….else
 Prototype:

if ( condition 1 ) {
instruction 1
} Expression
else if ( condition 2) { logique
instruction 2
}
else {
instruction 3
}
Vrai (!=0) Faux (==0)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 34
 Instructions de contrôle (2/5)
 Instructions de branchement : Switch

switch (expression)
{
case constante_1 : [ suite_d'instructions_1 ]; break;
case constante_2 : [ suite_d'instructions_2 ]; break;
..............
case constante_n : [ suite_d'instructions_n ]; break;
default : suite_d'instructions ;
}
 Exemple :

int a;
switch (a)
{
case 7 : a=2; break;
//si a égal à 7 j’affecte 2 à a
case 4 : a=3; break;
default : a=0; //si a égal à 4 j’affecte 3 à a
} //sinon j’affecte 0 à a

Mohamed
El Nabil
Abdellaoui SaïdSaidi 35
 Instructions de contrôle (3/5)
 Instructions itératives

 while tant que (condition) …. faire instruction

 Effectue l’instruction tant que la condition est vérifiée

while ( condition )
{
instruction
}

o si condition est évalué à faux dés le début alors la suite

d’instruction n’est jamais exécuté.
o si condition est toujours évalué à vrai, on a un bouclage infini.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 36
 Instructions de contrôle (4/5)

 do … while faire instruction …..tant que (condition)

 La condition est évaluée à la fin de la boucle.
 L’instruction est exécutée au moins 1 fois.

do {

instructions

} while( condition ) ;

Point virgule à la fin!

Attention

Mohamed
El Nabil
Abdellaoui SaïdSaidi 37
 Initialisation d’un tableau

• Valeur par valeur (bof…!!!) • Utilisation d’une boucle (mieux!)

int Toto[10]; //déclaration
int Toto[10]; //déclaration
for (auto& elm : Toto )
//Initialisation {cin >> elm; }
Toto[0]=8;
Toto[1]=32; int Toto[10]; //déclaration
//etc… int Indice; //var locale

for (Indice = 0; Indice < 10; Indice++)

{ cin >> Toto[Indice] ; }

• A la déclaration
int Toto[10] = {1, 2, 6, 5, 2, 1, 9, 8, 1, 5};
// toutes les éléments ont une valeur

int Toto[10] = {1, 2, 6, 5}; // les éléments non définit sont initialisé à 0
// au moins un élément doit être définit

Mohamed
El Nabil
Abdellaoui SaïdSaidi 38
 Restriction
 On ne peut pas affecter une série de valeurs en dehors de la déclaration.

int t[3] = {4, 5, 8}; // OK

int t[3] ;
t = {1, 2, 6, 5}; // ERREUR

 On ne peut pas affecter un tableau à un autre.

int x[3] ,int y[3] ; // déclaration de deux tableaux d’entier

…
x = y; // ERREUR

 On ne peut pas comparer deux tableaux.

int x[3] ,int y[3] ; // déclaration de deux tableaux d’entier

…
if(x == y) // ERREUR

Mohamed
El Nabil
Abdellaoui SaïdSaidi 39
 Exercice récapitulatif

Ecrire un programme qui gère un tableau d'entiers grâce au menu suivant :

1. Ajouter un entier au tableau

2. Afficher la liste des entiers
3. Supprimer le dernier entier de la liste.
4. Chercher le max du tableau
5. Chercher le min
6. Quitter

Il y aura au maximum 10 entiers. Lorsqu'on rajoute un entier, il sera rajouté à la fin de la liste.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 40
 Exercice récapitulatif (Solution)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 41
 Exercice récapitulatif (Solution)

Mohamed
El Nabil
Abdellaoui SaïdSaidi 42
 Les chaines du caractères
 Une chaines du caractères peut être constituer en deux façons :

char chaine[20] = "BONJOUR"; string chaine = "BONJOUR";

 Attaché à l'entrée standard :  Attaché à l'entrée standard :

cin.ignore(0); cin
cin.getline (Ts,taille);

 il prends en considération les  il prends pas en considération

mots après l’espace les mots après l’espace
main(){ char T[50]; main(){
cout <<"Entrer votre chaine de caractères :"<<endl; string S;
cin.ignore(0); cout <<"Entrer votre chaine de caractères :"<<endl;
cin.getline (T,50); cin >> S;
cout <<"votre chaine de caractères est :"<<T<<endl; cout <<"votre chaine de caractères est :"<<S<<endl;
} }

Mohamed
El Nabil
Abdellaoui SaïdSaidi 43
 Les tableaux des caractères
 Un tableau de caractères constitue une chaîne de caractères. Exemple avec des caractères de bits:

char chaine[20] = "BONJOUR";

 La variable chaine peut stocker jusqu'à 20 caractères, et contient les caractères suivants :

'B','O','N','J','O','U','R','\0'

char chaine[20] ={'B','O','N','J','O','U','R','\0'};

 Le dernier caractère est nul pour indiquer la fin de la chaîne de caractères. Il est donc important
de prévoir son stockage dans le tableau. Dans cet exemple, 8 caractères sont donc nécessaires.

 Si la chaîne est initialisée à la déclaration, on peut également laisser le compilateur détecter le

nombre de caractères nécessaires, en omettant la dimension :

char chaine[] = "BONJOUR"; // tableau de 8 caractères

 Dans ce cas, la variable ne pourra stocker que des chaînes de taille inférieure ou égale à celle
d'initialisation.

Mohamed
El Nabil
Abdellaoui SaïdSaidi 44
Exercice

45
 Allocation dynamique

 Deux Opérateurs Intégrés au langage.

 Les opérateurs new et delete gèrent la mémoire dynamiquement.
 alloue la place pour éléments de type Type et retourne l'adresse du premier
élément;

new Type [n]

 libère la place allouée par new.

delete Type

 Exemple :
int* a = new int;
// malloc(sizeof(int))

double* d = new double[100];

// malloc(100*sizeof(double))

Mohamed
El Nabil
Abdellaoui SaïdSaidi 46
 Les pointeurs

 Enormément utilisé en C/C++ !

 Pourquoi? A quoi ça sert?

 Manipuler directement la mémoire de l’ordinateur.

 Déclarer des tableaux de taille variable.

 Copier directement des tableaux ou des chaînes de caractères.

 Utile pour le passage de paramètres.

 …

Mohamed
El Nabil
Abdellaoui SaïdSaidi 47
 La notion d’adresse

 La mémoire de l’ordinateur peut être vu comme une série de cases.

 Ces cases sont repérées par des adresses.
 Dans ces cases sont stockées les valeurs des variables (ou des instructions).

Adresses valeurs
@65775417 123
@65775416 3.2132
@65775415 ‘M’

@65775414 ‘i’

@65775413 ‘a

@65775412 ‘m’

Mohamed
El Nabil
Abdellaoui SaïdSaidi 48
 Qu’est ce qu’un pointeur ?

 Un pointeur est une variable qui contient l’adresse d’une variable.

A
Pointeur = @A;
. Pointeur ?

 On dit que le pointeur pointe sur l’objet pointé.

 Le type du pointeur est construit à partir du type de l’objet pointé.

A
Int *Pointeur = @A;
Pointeur 2

 Exemple

int * Var ; Nom de pointeur

Type de l’objet pointé

Mohamed
El Nabil
Abdellaoui SaïdSaidi 49
 Opérateur concernant les pointeurs
 Comment accéder à la variable contenue dans un pointeur ?
 Comment récupérer l’adresse d’une variable ?
 Soit a une variable et p un pointeur:

&a désigne l’adresse de la variable a

*p désigne la variable pointée par p (le contenu)

Utilisons a Utilisons pA

Mohamed
El Nabil
Abdellaoui SaïdSaidi 50
Exemple de déclaration et d’utilisation

int i=0; /* Déclare une variable entière. */

int *pi;
/* Déclare un pointeur sur un entier. */

pi=&i;
/* Initialise le pointeur avec l’adresse de cette variable
*pi = *pi+1;
/* Effectue un calcul sur la variable pointée par pi,
c’est-à-dire sur i lui-même, puisque pi contient
l’adresse de i. */
/* À ce stade, i ne vaut plus 0, mais 1. */

// px est un pointeur sur entier

int *px, y, z;
// y et z sont des entiers

Mohamed
El Nabil
Abdellaoui SaïdSaidi 51
 Exemples applicatifs
#include <iostream>
using namespace std;

int main() {
int a, b, c;
int *x, *y;

a = 98;
x = &a;
c = *x + 5;
y = &b;
*y = a + 10;

cout << "La variable b vaut : " << b << endl;

cout << "La variable c vaut : " << c << endl;

return 0;
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 52
 Initialisation des pointeurs (1/5)

 Il faut s’assurer que les pointeur que l’on manipule sont bien initialisé!

 Il doivent contenir l’adresse d’une variable valide.

 Accéder à la variable d’un pointeur non initialisé revient à:

 Ecrire ou lire, dans la mémoire à un endroit aléatoire.

 Plantage à l’exécution du programme.

 En général on initialise les pointeurs à la déclaration.

 On peut les initialisé comme pointeur NULL.

int * Var; // pour le compilateur Var pointe sur quelque chose (n’importe quoi)

int * Var = NULL; // le compilateur sait que Var ne pointe sur rien

Mohamed
El Nabil
Abdellaoui SaïdSaidi 53
 Initialisation des pointeurs (2/5)
 Affectation à une variable existante.

int i = 2;
int * P; @65775417
P = &i;
@65775416

@65775415 2 i = *P

@65775414 ?

@65775413 XXXXX
65775415 P

@65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 54
 Initialisation des pointeurs (3/5)
int i,j; // i, j variables de type int
int * pi, *pj; // pi et pj, variables de type « pointeurs vers int »
pi=&i; // le pointeur est initialisé à &i, il pointe à l’adresse &i, donc sur i
*pi=2; // accès à l’élément pointé, i est mis à 2
(*pi)++; // incrémente i qui passe à 3

int t[10]; // tableau de 10 int

pi = &t[2]; // pi pointe sur la case qui contient la valeur T[2]
*(pi + 1) = 0; // T[3] est mis à 0 (les éléments d’un tableau se suivent en mémoire)

int i=2, j , k ;
int * p1, * p2;
p1 = &i; // p1 contient l’adresse de i
*p1 = i; // inutile! Car pi=&i donc automatiquement *pi=i
p2 = k; // attention l’adresse p2 prend une valeur non défini(p2 pointe n’importe ou)
*p2 = 3; // on écrit quelque chose à un endroit inconnu ! Plantage!

Mohamed
El Nabil
Abdellaoui SaïdSaidi 55
 Initialisation des pointeurs (3/5)
int i,j; // i, j variables de type int
int * pi, *pj; // pi et pj, variables de type « pointeurs vers int »
pi=&i; // le pointeur est initialisé à &i, il pointe à l’adresse &i, donc sur i
*pi=2; // accès à l’élément pointé, i est mis à 2
(*pi)++; // incrémente i qui passe à 3

int t[10]; // tableau de 10 int

pi = &t[2]; // pi pointe sur la case qui contient la valeur T[2]
*(pi + 1) = 0; // T[3] est mis à 0 (les éléments d’un tableau se suivent en mémoire)

int i=2, j , k ;
int * p1, * p2;
p1 = &i; // p1 contient l’adresse de i
*p1 = i; // inutile! Car pi=&i donc automatiquement *pi=i
p2 = k; // attention l’adresse p2 prend une valeur non défini(p2 pointe n’importe ou)
*p2 = 3; // on écrit quelque chose à un endroit inconnu ! Plantage!

Mohamed
El Nabil
Abdellaoui SaïdSaidi 56
 Initialisation des pointeurs (4/5)
 Allocation dynamique.
 On réserve la place pour la variable pointée.
 Syntaxe: Nom_Variable = new type ;

int * P;
@65775417
P = new int ;

@65775416

@65775415 *P

@65775414
?
@65775413 XXXXX
65775415 P

@65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 57
 Initialisation des pointeurs (5/5)

 Allocation dynamique
 Il faut penser à libérer la mémoire après utilisation !
 Syntaxe: delete Nom_Variable ;
 Même si on déclare un pointeur dans une fonction (local), il doit être libéré !

char * C; // C est un pointeur qui pointe sur n’importe quoi

C = new char ; // Allocation d’un espace pouvant stocker un caractère
// C pointe sur cet espace

double * D;
D = new double ;
*D = 12.34;
delete D ; // libération de l’espace occupé par le double

Mohamed
El Nabil
Abdellaoui SaïdSaidi 58
 Arithmétique des pointeurs
 Les opérateur ++, --, +, = ….. Sont définis pour les pointeurs, mais attention, ils
s’appliquent aux adresses.

int * P;
…. //allocation
@65775417 123
P ++ ;
P = P – 2 ; @65775416 12
int * Q = P + 3; @65775415 156
Q
@65775414 3
@65775413 9
@65775412 456
P

Mohamed
El Nabil
Abdellaoui SaïdSaidi 59
 Initialisation des pointeurs (5/5)

#include <iostream>
//Inclusion de la bibliothèque standard pour les E/S
using namespace std;
main () {
int premiers[] = {2,3,5,7,11,13,17};
int* ptr = premiers; // pointe le premier élément du tableau

cout << hex << ptr << endl; // affiche l'adresse pointée (Exp. 01C23004)
cout << *ptr << endl; // affiche "2"
cout << *(ptr+5) << endl; // affiche "13"

ptr=&premiers[3]; // pointe le 4ème élément (index 3)

cout << hex << ptr << endl; // affiche l'adresse pointée (exp. 01C23018)
cout << *ptr << endl; // affiche "7"
cout << *(ptr-2) << endl; // affiche "5"
}

Mohamed
El Nabil
Abdellaoui SaïdSaidi 60
 Les tableaux dynamiques (1/3)
 Un tableau est en fait un pointeur!

int tableau[3];
int * P = tableau ;
tableau [2] = 5 ;
*(tableau+1) = 4;
P[0]=1; // *(P+0) = 1 @65775417

@65775416

@65775415 5
P @65775414 4
@65775413 1
tableau
@65775412

Mohamed
El Nabil
Abdellaoui SaïdSaidi 61
 Les tableaux dynamiques (2/3)
int tab[3];
int * Ptab, x; // Ptab pointeur sur un int
Ptab = & tab [0]; // Ptab pointe sur le début du tableau
// équivalent à Ptab = tab
x = *Ptab; // équivalent à x = tab[0]
*(Ptab+ i) = 3; // équivalent à tab[i]=3,
*(tab + i) = 3 ,
Ptab[i]=3

 Les allocation dynamique

 Possibilité de créer un tableau de taille non constante !
 Syntaxe: Type * NomTab;
NomTab = new Type [Taille]; // allocation
delete [ ] NomTab; // destruction

int n = 3;
int tab[n]; // INTERDIT
int * Ptab = new int [n]; // OK
….
delete [ ] Ptab; // désallocation du pointeur

Mohamed
El Nabil
Abdellaoui SaïdSaidi 62
 Les tableaux dynamiques (3/3)
 Un tableau est un pointeur constant !

int tab[3]; // déclaration d’un tableau de 3 éléments

int * Ptab = new int [3]; //déclaration d’un pointeur avec allocation pour 3 éléments
Ptab ++; // OK
tab++; // ERREUR tab est constant
Ptab = tab; // ok les deux pointeur Ptab et tab pointe au même endroit (sur tab[0])
Tab = Ptab ; // ERREUR tab est constant

 On peut donc transtyper un pointeur en tableau mais pas l’inverse!

 L’affectation est possible entre pointeur.

int * tab1 = new int [3]; //déclaration d’un pointeur avec allocation pour 3 éléments
int * tab2 = new int [3]; ;
Tab2 = tab1 ; //attention Tab2 pointe maintenant au même endroit que Tab1
char * chaine;
chaine = "coucou";

Mohamed
El Nabil
Abdellaoui SaïdSaidi 63
 Affectation de pointeur

int * tab1 = new int [3];

@65775417
int * tab2 = new int [3]; 12
// remplissage @65775416
3
tab2 = tab1;
delete [] tab2; @65775415 65
tab2
delete [] tab1;
@65775414
789
Erreur @65775413
31
@65775412 756
tab2 =tab1

Mohamed
El Nabil
Abdellaoui SaïdSaidi 64