Algorithmique et Programmation

Chapitre 3:
Les pointeurs

DR. HANEN GRICHI

1
LES POINTEURS

o Un pointeur est une variable dont le contenu a pour valeur une adresse en mémoire.

o Le type du pointeur correspond au type de la variable pointée.

 LES POINTEURS

 Une variable est définie par :

Mémoire
 Un nom Pointeur p
 Un type
 Un emplacement mémoire réservé à une adresse précise

 Un pointeur sur un type T est une variable qui contient

l’adresse mémoire d’une variable de type T Variable x
 LES POINTEURS

 Accès à la valeur pointée :^p Mémoire Pointeur p

 le pointeur doit contenir une adresse valide @x

 L’adresse d’une variable est récupérée par : @x

 ^p
 @ est l’opérateur d’adressage
Variable x
 OPÉRATIONS SUR LES POINTEURS

 Initialisation d’un pointeur : p  Nil

 Indique que le pointeur pointe sur rien
Mémoire
 Avant toute utilisation, il faut vérifier la valeur du pointeur Pointeur p
 Dès qu’un pointeur n’est plus utilisé, il faut le remettre à Nil 
@x
 Affectation : p  @x
 Place l’adresse de x dans p
Variable x
 OPÉRATIONS SUR LES POINTEURS
Mémoire
 Copie d’un pointeur : q  p Pointeur p
@x
 Les deux pointeurs p et q pointent
sur le même emplacement Pointeur q  ^p
 ^q
mémoire @x
 Variable x

 Copie d’une valeur pointée : ^q 

^p Mémoire
Pointeur p 10
 Les valeurs pointées sont
@x
identiques mais les pointeurs Variable x
restent différents Pointeur q
10
15
@y
Variable y
ALLOCATION DYNAMIQUE

 Réserver un emplacement mémoire dynamiquement :

 Créer un tableau de taille donnée pendant l’exécution de l’algorithme
 Besoin: nombre et du type des éléments que l’on veut stocker

 Fonction d’allocation:
fonction alloue (in nb : entier, in typeElem : Type) : ret pointeur sur typeElem

 Retourne Nil si l’allocation n’est pas possible

 Exemple : p  alloue(10,entier) // alloue un tableau de 10 entiers

Mémoire
Pointeur p 
@
DÉSALLOCATION

 Lorsque un emplacement dynamique n’est plus utile, il faut le désallouer de façon à économiser la mémoire

 Fonction de désallocation : fonction libère(in ptr : pointeur) : vide

 Exemple :

 libère(p) // libère l’emplacement mémoire pointée par p mais ne modifie pas p

 p  Nil // permet de détecter que p ne pointe plus sur un emplacement valide

Mémoire
Pointeur p 
EXEMPLE

nb  lire
si nb > 0 alors
tab  alloue(nb,entier)
si tab  Nil alors
… tab[ind] …// utilisation de tab comme un tableau classique à nb
//éléments
libère(tab) // libération du tableau dynamique après son utilisation
tab  Nil // réinitialisation du pointeur pour la suite de l’algo
fsi
fsi
…
 Chapitre 3:
Les pointeurs avec le langage C
 LES POINTEURS

o Attention à l’opérateur * puisqu’il est le seul élément syntaxique du langage C à avoir 3

sens différents selon le contexte :

o La multiplication dans une expression mathématique

o La déclaration d’un pointeur dans une déclaration de variable
o La déréférence d’un pointeur pour accéder au contenu de l’adresse mémoire référencée
 LES POINTEURS

• Que pensez-vous de ce petit programme?

void main(void)
{
int V1, *P1; /* 01 */
int *P2, V2; /* 02 */
/* 03 */
P1 = &V1; /* 04 */
P2 = &V2; /* 05 */
/* 06 */
V1 = 100; /* 07 */
V2 = *P1 + 5; /* 08 */
printf(“V1=%d et V2=%d", V1, V2 );
}
 LES POINTEURS

 La déclaration Opérateurs d’adressage et de déréférence

 On utilise & pour obtenir l’adresse d’une variable ou
type * identificateur ;
d’une fonction préalablement allouée

int *PtrData;  On utiliser * (la déréférence) pour accéder au contenu

« pointé » par une adresse
int Nombre1, Nombre2;
int *PtrNbr;

Nombre1 = 666;
PtrNbr = &Nombre1; //adresse

Nombre2 = *PtrNbr; //contenu

LES POINTEURS

o Accès aux membres des types composés struct

o On utilise l’opérateur d’indirection . (point) pour accéder à un membre particulier

o Pour les accès via un pointeur, on peut utiliser

o une combinaison du point et de la déréférence

o l’opérateur d’indirection  typedef struct { char Nom[256]; int Age; float

Taille; } Individu;

Individu Employe1, Employe2, *RefEmp1, *RefEmp2;

Ref1Emp = &Employe1;
Ref2Emp = &Employe2

RefEmp1->Age = 2 * (*RefEmp2).Age;
 GESTION STATIQUE ET DYNAMIQUE DE LA
MÉMOIRE
 Avec les fonctions malloc et free, il est possible de faire soi même la gestion de la mémoire au moment opportun –
c’est ce qu’on appel la gestion dynamique de la mémoire.

void * malloc(int taille-en-octet);

void free(void * bloc-memoire);

 Il est essentiel de libérer soi même la mémoire réservée

int *VariableQuelconque = (int*)

malloc(sizeof(int));
...
*VariableQuelconque = 10;
...
free(VariableQuelconque);
 GESTION STATIQUE ET DYNAMIQUE DE LA MÉMOIRE

 On se sert souvent des allocations dynamiques pour allouer des

tableaux dont la taille est indéfinie au moment de la compilation.

int TableauStatique[3] = { 0, 1, 2 };
int *TableauDynamique = (int*) malloc(sizeof(int) * 3);

- 0x30CA
const int* int*
TableauStatique TableauDynamique
0x1000 0x2000

0x1000 0x1004 0x1008 0x2000 0x2004 0x2008

int int int int int int
- - - - - -
1 2 3 ? ? ?
EXERCICE

 Copiez le tableau suivant et complétez-le pour chaque instruction du programme ci-dessus.