Module: ALGORITHMIQUE 1

Chapitre 9: Les pointeurs

Niveaux: 1A
Equipe ALGO

Année universitaire:
2022/2023

1
Objectifs Spécifiques
A la fin de ce chapitre, l’étudiant sera capable de :

 Comprendre le type pointeur

 Manipuler une variable à partir de son adresse
 Utiliser un pointeur en paramètre d’une fonction
 Utiliser un pointeur dans l’allocation dynamique.

2
 Problématique 1

 Supposons que votre enseignant a corrigé votre copie d’examen et a

sauvegardé la note sous drive. S’il te rend la copie et tu modifies la note est
ce que la note originale change ?
 Solution

Pour changer la valeur nous devons accéder à l’adresse ou se

trouve les notes au lieu d’avoir une copie sur cette valeur

Pareil si vous souhaitez changer la valeur d’une variable

à travers une fonction, vous devez passez son adresse au
lieu de sa valeur!

Cette adresse sera stockée dans une

variable de type pointeur.
 Problématique 2

 Supposons que je veux allouer un tableau d’entier en mémoire sachant que

je ne connais pas sa taille à l’avance  allouer avec une taille maximale

 Il se peut que pendant l’exécution, l’utilisateur choisit une taille qui dépasse
cette taille maximale. Que devons nous faire ?
 Solution

Selon le besoin de l’utilisateur en utilisant l’allocation

dynamique!

Ceci en utilisant un pointeur.

 PARTIE I
Définition et manipulation d’un pointeur

7
 Définition

 Un pointeur est une variable qui peut contenir l’adresse d’un espace mémoire
alloué ou l’adresse d’une autre variable.

 Chaque pointeur est limité à un type de donnée

 Si un pointeur P contient l’adresse d’une variable A , on dit que P pointe vers A.

 Adressage Directe
L’adressage directe consiste à accéder à la valeur d’une variable à travers son nom
(identificateur)
x
Exemple:

x: entier 0
x← 0
…. H004 H008 H016 ….
 Adressage Indirecte
L’adressage indirecte consiste à accéder à la valeur d’une variable en passant par un pointeur
contenant l’adresse de la variable.
X P

Exemple:
0 H008
X: entier
X← 0 …. H004 H008 H016 H020

P: pointeur sur un entier contenant

l’adresse de X
 Syntaxe de déclaration
Il existe 2 conventions pour déclarer une variable de type pointeur:

• 1ère convention: <nom_pointeur>: pointeur sur <type>

-Exemple: P: pointeur sur entier

• 2ème convention: <nom_pointeur>: * <type>

-Exemple: P: *entier

Remarque:
Un pointeur qui ne contient aucune adresse doit être initialisé à NULL( Not Identified
Link), sinon il va pointer n’importe ou!
 Opérateurs de base
 Opérateur « adresse de »: &

L’opérateur & permet de récupérer l’adresse d’une variable

• Syntaxe: &<nom_variable>: fournit l’adresse de la variable <nom_variable>

Exemple: X P
VARIABLE
P: pointeur sur entier
X:entier
0 H008

P ← &X …. H004 H008 H016 H020

Adresse de X
 Opérateurs de base
 Opérateur « contenu de »: *
Avant d’accéder au contenu,
L’opérateur * permet de récupérer le contenu d’une variable il faut s’assurer que le
pointeur est différent de
NULL!
• Syntaxe: *<nom_pointeur>: fournit le contenu du pointeur <nom_pointeur>
X P
Exemple:
VARIABLE
P: pointeur sur entier
X:entier 0 H008

…. H004 H008 H016 H020

P ← &X
(*P) est le contenu de la variable sur laquelle pointe p: 0
Adresse de X
 Opérateurs de base
Etat initial des variables
Algorithme Exemple1
Variables
A,B: entier
p:*entier
Debut
(*Etat initial des variables*)
A ← 10 Après modification des variables
B ← 50
(*Modification des variables*)
p ←&A
B ←*p
*p←20
Fin
 PARTIE I
Pointeurs et Tableaux

15
 Pointeur et Tableau
Un tableau est un pointeur statique contenant l’adresse d’un espace mémoire
contiguë qui est aussi l’adresse du premier élément du tableau.
C’est à dire les 2 écritures suivantes sont équivalentes:
T=&T[1]

Remarque:
Vous n’avez pas le droit de changer la valeur d’un tableau statique: T ←T2
T T[1] T[2]
Exemple:
T: tableau de 2 entiers
T[1] ← 0
T[2] ← 1 H008 0 1

…. H004 H008 H016 H020

 Pointeur et Tableau
Etant donné que les éléments d’un tableau sont allouées de manière contigüe :

• Les adresses des éléments sont identifiées par : T, T+1, T+2, … T+N-1

• Les valeurs des éléments sont identifiées par : *T, *(T+1), *(T+2), ..., *(T+N-1)

T T[1] T[2]

H008 0 1

…. H004 H008 H012 H016

 Exercice d’application 1
Utiliser l’opérateur (*) pour remplir un tableau d’entiers comme le montre l’exemple
suivant:
1 2 3 4 5

Algorithme 1 Algorithme 2
T: tableau [1..50] d’entier T: tableau [1..50] d’entier

n , i: entier n , i: entier
p: pointeur sur entier
Pour i de 1 à n Faire i ←1
*(T+i-1) ← i Pour p de T à T+n-1 Faire
Fin Pour *p ← i
i ←i+1
Fin Pour
 Exercice d’application 2

Afficher la valeur de chaque expression sachant que T est un tableau de 3 entiers

T H004

T+1 H008

*T 2 2 0 1 … H004

*(T+1) 0
…. H004 H008 H016 H020
&T[2] H008

T+2 H016
PARTIE I: Pointeurs et
Fonctions/Procédures

20
 Quelques contraintes
 Une fonction est un sous programme permettant de faire un traitement et de retourner
un résultat unique.  Comment faire pour retourner plusieurs résultats ?

Il n’y a qu’une solution pour retourner plusieurs résultats: passer en paramètre 

l’adresse des variables où seront stockés les résultats.

 Supposons que nous souhaitons modifier la valeur d’une variable passée en paramètre
à une fonction. Comment faire?

Le passage par adresse est utilisé pour modifier  le contenu des variables  déclarées
dans d’autres fonctions.
 Passage de paramètre par valeur

Ecrire la procédure permute permettant de permuter 2 entiers:

 Passage de paramètre par valeur

 Lors de l’appel, les valeurs de x et y sont copiées dans les paramètres u et v de

la procédure « permute »

 « permute » échange bien le contenu des variables locales u et v, mais les

valeurs de x et y restent les mêmes

 Pour changer la valeur d’une variable de la fonction appelante, nous allons

procéder comme suit :
a. Le programme appelant doit fournir l’adresse de la variable
b. La fonction appelée doit déclarer le paramètre comme pointeur.
 Passage de paramètre par adresse

Ecrire la procédure permute permettant de permuter 2 entiers:

 Passage de paramètre par adresse

 Lors de l’appel, les adresses de x et y sont copiées dans les pointeurs

de u et v, respectivement

 « permute » échange ensuite le contenu des adresses indiquées par les

pointeurs u et v

 A partir du moment où une variable est considérée comme un

pointeur, toute affectation de cette variable se traduit
automatiquement par la modification de la variable sur laquelle elle
pointe
 Exercice d’application 3

Ecrire une procédure MaxMin permettant de retourner le minimum et le

maximum dans un tableau d’entiers:
Algorithme Metrique Pour i de 2 à n Faire
Constante Nmax=50 Si (T[i]>(*max)) alors (*max) ← T[i]
Type Sinon si (T[i]<(*min)) alors (*min) ← T[i]
Tab:tableau [1.. Nmax]d’entiers Fin si
Variable Fin Pour
n,max,min:entier Fin
T:Tab
Procédure MaxMin(max,min:pointeur sur entier, Début
n:entier, T:Tab) Lire(n)
Variable Remplir(T,n)
i:entier MaxMin(&max, &min,n,T)
Début Ecrire(‘’Le Max et le Min sont: ’’,max,min)
(*min) ← T[1]
(*max) ← T[1] Fin
PARTIE II: Pointeurs et
Enregistrement

27
 Pointeur et enregistrement
 Un pointeur peut aussi contenir l’adresse d’un enregistrement

 Pour accéder à un élément de l’enregistrement à travers

un pointeur, on utilise une des syntaxes suivantes:
 (*nomPointeur).champ
 nomPointeur →champ
 Exercice d’application 4
Ecrire une procédure saisir permettant de saisir les informations d’un étudiant:
Algorithme Etudiant
Type
Etudiant=Enregistrement
NumeroIncription: entier
Nom, Prenom: chaine[10]
FinEnregistrement
Variable
Et : Etudiant
Procédure saisir(p:pointeur sur étudiant)
Début
Lire(p→NumeroInscription)
Lire(p→Nom)
Lire(p→Prénom)
Fin

Début
Saisir(&ET)
Ecrire(ET)
Fin
PARTIE II: Allocation
Dynamique

30
 Allocation statique
 Les variables créées de manière statique sont allouées et libérées
automatiquement par le système d'exploitation. L'espace à allouer est connu
durant la phase de compilation.
 Exemple 1: supposons qu’on a déclaré un tableau de 20 Etudiants, Comment
faire pour ajouter l’étudiant numéro 21?

 Exemple 2: pour une application qui permet de gérer 20 employés, le

développeur a déclaré un tableau d’employés de taille 100

Pas d’optimisation Allocation dynamique

de la mémoire  selon le besoin 
 Allocation dynamique

 L’allocation dynamique permet de réserver un espace mémoire de taille

variable en milieu d’exécution d’un programme

 Ainsi, la taille de l’espace n’est pas connue à l’avance.

 La libération d’un espace mémoire alloué dynamiquement n’est pas

automatique comme dans l’allocation statique.

 L’allocation dynamique ne se fait qu’à travers des pointeurs.

 Allocation dynamique
 Allouer(nbOctets): <type*> : permet d’allouer dynamiquement nb octets.
Cette fonction retourne:
- NULL: S’il n’y a pas assez d’espace mémoire
- l’adresse de l’espace allouée, sinon

Remarque: pour connaitre le nombre d’octets d’un type donné, utilisez la

fonction: taille(<type>): entier

Exemple:
Variable
P: *entier
Début
P ← allouer(taille(entier))
Fin
 Allocation dynamique et libération

 Libérer(<type> *) : permet de libérer un espace mémoire allouée

dynamiquement avec la fonction « allouer »

 Exemple:
libérer(P)

 Attention: Si on ne libère pas la mémoire, elle risque d’être saturée et le

programme peut se planter.
 Exercice d’application 5
Ecrire un algorithme permettant de réserver et saisir n entiers alloués dynamiquement
Algorithme Exemple
Variable
T:pointeur sur entier
n,i:entier
Début
Lire(n)
T ← allouer(n*taille(entier))
Si (T=NULL) alors Ecrire(‘’ espace mémoire insuffisant ’’)
Sinon
Pour i de 1 à n faire
Lire(T[i])
FinPour
(* Si vous n’avez plus besoin de l’espace réservé il faut le libérer *)
Libérer(T)
FinSI
Fin
 Exercice d’application 6
Ecrire une fonction qui permet de remplir un tableau de n étudiants alloué dynamiquement et le retourne.
Fonction RemplirEtudiant (n : entier) : *Etudiant
Variable
i :entier
T : *Etudiant
Début
T ← allouer (n*taille(Etudiant))
Si (T<>NUUL) alors
Pour i allant de 1 à n faire
lire(T[i].CIN, T[i]. nom, T[i].prenom)
Fin pour
Sinon
Ecrire(‘’ espace mémoire insuffisant ’’)
FinSi
RemplirEtudiant ← T
Fin
 Récapitulons
 Un pointeur est utilisé pour:
- Stocker l’adresse d’une variable
- Modifier la valeur d’une variable à travers une fonction
- Allouer une variable dynamiquement

 Un pointeur peut être initialisé de 3 différentes manière à:

- La constante NULL: s’il ne pointe vers rien
- L’adresse d’une variable
- L’adresse d’un espace mémoire allouée dynamiquement avec la fonction
allouer