Les pointeurs
Licence 2 D2A et SRT
Dr Youssou KASSE
Université Alioune Diop de
Bambey
[Link]@[Link]
Notion de pointeur
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).
Dr KASSE 2
Notion de pointeur
Nous avons vu que pour accéder à la valeur contenue
dans une variable, on utilise tout simplement son nom.
Toutefois, il est parfois très pratique de manipuler une
variable par son adresse.
Une variable dont le contenu est une adresse est
appelée un pointeur
Un pointeur est une variable dont la valeur est
l'adresse d'une autre variable.
On dit que le pointeur pointe sur la variable dont il
contient l'adresse.
Dr KASSE 3
Notion de pointeur
En langage C, pour désigner l’adresse d’une variable,
on utilise on utilise l'opérateur d'adresse &
Un pointeur est associé à un type de variable sur
lequel il peut pointer.
Par exemple, un pointeur sur entier ne peut pointer
que sur des variables entières.
Représentation p
pointeur
18 n
variable pointée
Dr KASSE 4
Déclaration d’un pointeur
En langage C, pour déclarer une variable
pointeur vers un type de base :
• partir de la déclaration d'une variable ayant un type de
base ;
• ajouter le signe * devant le nom de la variable.
En C
type * nom_pointeur;
Exemple :
int * p;
Dr KASSE 5
Déclaration d’un pointeur
Même si la valeur d’un pointeur est toujours un entier
(éventuellement un entier long), le type d’un pointeur
dépend du type de l’objet vers lequel il pointe.
Dans l’exemple suivant, on définit un pointeur p qui
pointe vers un entier i : int i = 3;
int *p;
p = &i;
On se trouve dans la configuration
Objet Adresse Valeur
i 4831836000 3
p 4831836004 4831836000
Dr KASSE 6
Déclaration d’un pointeur
L’opérateur unaire d’indirection * permet d’accéder
directement à la valeur de l’objet pointé.
Ainsi, si p est un pointeur vers un entier i, *p désigne
la valeur de i. main()
{
Par exemple, le programme int i = 3;
int *p;
p = &i;
printf("*p = %d \n",*p);
}
imprime *p = 3.
Dr KASSE 7
Manipulation d’un pointeur
Dans ce programme, les objets i et *p sont identiques : ils ont
mêmes adresse et valeur.
Nous sommes dans la configuration :
Objet Adresse Valeur
i 4831836000 3
p 4831836004 4831836000
*p 4831836000 3
Cela signifie en particulier que toute modification de *p modifie i.
Ainsi, si l’on ajoute l’instruction *p = 0; à la fin du programme
précédent, la valeur de i devient nulle.
Dr KASSE 8
Manipulation d’un pointeur
On peut donc dans un programme manipuler à la fois
les objets p et *p.
Ces deux manipulations sont très différentes.
Comparons par exemple les deux programmes suivants :
Programme 1 Programme 2
main() main()
{ {
int i = 3, j = 6; int i = 3, j = 6;
int *p1, *p2; int *p1, *p2;
p1 = &i; p1 = &i;
p2 = &j; p2 = &j;
*p1 = *p2; p1 = p2;
} }
Dr KASSE 9
Manipulation d’un pointeur
Avant la dernière affectation de chacun de ces
programmes, on est dans une configuration du type :
Objet Adresse Valeur
i 4831836000 3
j 4831836004 6
p1 4831835984 4831836000
p2 4831835992 4831836004
Dr KASSE 10
Manipulation d’un pointeur
Après l’affectation *p1 = *p2; du premier
programme, on a
Objet Adresse Valeur
i 4831836000 6
j 4831836004 6
p1 4831835984 4831836000
p2 4831835992 4831836004
Dr KASSE 11
Manipulation d’un pointeur
Par contre, l’affectation p1 = p2 du second
programme, conduit à la situation :
Objet Adresse Valeur
i 4831836000 3
j 4831836004 6
p1 4831835984 4831836004
p2 4831835992 4831836004
Dr KASSE 12
Manipulation d'un pointeur
L'opérateur & (adresse de) appliqué à une variable délivre
l'adresse de celle-ci ;
cette adresse pourra être affectée à une variable de type
pointeur.
On peut écrire par exemple void main()
{
int n;
int * p;
n=18;
p = &n;
…
}
Dr KASSE 13
Manipulation d'un pointeur
Il est possible d’accéder à la zone mémoire pointée en
utilisant l‘opérateur *.
Ainsi, *p désigne la zone mémoire (la variable) pointée
par le pointeur p. void main()
{
int n = 33;
int *p; //déclaration du pointeur p
p = &n; // p pointe sur n
printf("%d", *p) ; //affiche 33 à l'écran, la valeur de n
*p = 34 ; // n vaut maintenant 34
Dr KASSE 14
Quelques remarques
Attention à toujours initialiser un pointeur. Un
pointeur qui n'est pas initialisé s'appelle un pointeur
pendant.
Un pointeur pendant ne pointe pas nul part mais
n'importe où.
Si l'on déréférence ce pointeur et qu'on affecte une
nouvelle valeur,
on va écraser un emplacement mémoire quelconque
et on risque de faire planter le programme.
Dr KASSE 15
Quelques remarques
Si on veut que le pointeur pointe nul part, il faut
l'initialiser à NULL. C'est l'équivalent de 0 pour les
pointeurs.
int * p = NULL ;
Dr KASSE 16
Allocation dynamique en C :
En C, l’allocation dynamique de mémoire peut se faire avec les
fonctions malloc et calloc de la bibliothèque standard stdlib.h:
La fonction malloc prend comme paramètre la taille de la zone
qu’on veut allouer et retourne, en cas de succès, l’adresse de la
zone allouée.
Le type de l’adresse retournée par malloc est void*. Il faut alors
le convertir au type du pointeur auquel on va l‘affecter.
• Par exemple, si on veut réserver un nouvel emplacement pour un caractère,
on peut faire:
• char *pcar;
• pcar = (char *)malloc(sizeof(char ));
• En cas d’échec, la fonction malloc retourne NULL.
Dr KASSE 17
Allocation dynamique en C :
La fonction calloc prend en paramètre un nombre d’éléments
nb et la taille t d’un élément et permet d’allouer une zone
contiguë de nb éléments de taille t octets.
Elle retourne, en cas de succès, l’adresse de la zone allouée.
Le type de l’adresse retournée par calloc est void*. Il faut
alors le convertir au type du pointeur auquel on va l‘affecter.
• Par exemple, si on veut allouer un emplacement pour 10 éléments de
type int, on peut faire:
• int * p;
• p = (int *)calloc(10, sizeof(int));
• En cas d’échec, la fonction calloc retourne NULL.
Dr KASSE 18
Allocation dynamique en C :
La libération d’une zone mémoire allouée de manière
dynamique n’est pas automatique en C.
Une telle zone continue à occuper de l’espace mémoire
jusqu’à la fin de l’exécution du programme si on ne la libère
pas de manière explicite.
Pour ce faire, il faut utiliser la fonction free de la bibliothèque
standard stdio.h selon la syntaxe suivante:
free(nom_pointeur);
Exemple:
• free(p);
• permet de libérer la zone mémoire pointée par p.
Dr KASSE 19
Pointeurs et structures
Il est très courant d'utiliser un pointeur pour mémoriser
l'adresse d'une variable structure.
Si p est un pointeur sur une structure, *p désigne la structure
pointée.
On peut donc accéder à un champ de la structure pointée par
l'expression : (*p).champ
L'usage de parenthèses est ici indispensable car l'opérateur * a
une priorité moins élevée que l'opérateur point (.)
Cette notation peut être simplifiée grâce à l'opérateur: ->
L'expression précédente est strictement équivalente à :
• p->champ
Dr KASSE 20
Pointeurs et structures
struct date
{
int jour;
int mois;
int annee;
};
struct date d; // d est une variable structure
struct date * p; //p est un pointeur sur une structure
p = &d // p pointe sur la structure d
Alors [Link] est équivalent à p->jour.
Dr KASSE 21
Arithmétique des pointeurs en C
Si i est un entier et p un pointeur sur un objet de type unType,
l'expression p + i désigne un pointeur sur un objet de type
unType dont la valeur est égale à la valeur de p incrémentée
de i*sizeof(unType).
Il en va de même pour la soustraction d'un entier à un
pointeur, et pour les opérateurs d'incrémentation et de
décrémentation ++ et --.
Ainsi, pour un pointeur sur un char, l’incrémentation de ce
pointeur correspond à un décalage de 1 octet de la zone
mémoire pointée, alors que pour un pointeur sur un float, la
même incrémentation correspondra à un décalage de 4 octets.
Dr KASSE 22
Arithmétique des pointeurs en C
Soient p1 et p2 deux pointeurs de même
type. L’instruction
p1 = p2;
signifie qu’on copie dans p1 l’adresse
contenue dans p2 et, donc, que p1 va
pointer au même endroit que p2
Dr KASSE 23
Arithmétique des pointeurs en C
Par exemple, le programme Par contre, le même programme avec
des pointeurs sur des objets de type
main() double :
{
main()
int i = 3;
{
int *p1, *p2;
double i = 3;
p1 = &i;
double *p1, *p2;
p2 = p1 + 1;
p1 = &i;
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
p2 = p1 + 1;
}
printf("p1 = %ld \t p2 = %ld\n",p1,p2);
}
affiche p1 = 4831835984 p2 = 4831835988.
affiche p1 = 4831835984 p2 = 4831835992.
Dr KASSE 24
Pointeurs et tableaux en C
En C, le nom d’un tableau est en fait un pointeur sur le
premier élément du tableau.
Par exemple, dans la déclaration
int tab[10];
tab est un pointeur constant dont la valeur est l'adresse du
premier élément du tableau. Autrement dit, tab a pour
valeur &tab[0].
Cette valeur n’est pas modifiable, néanmoins elle peut être
utilisée pour initialiser un pointeur sur le premier élément
du tableau.
Dr KASSE 25
Exemple
int tab[5]={1,2,3,4,5};
int * p;
p= tab;
p pointe au même endroit que tab c’est à dire sur le
premier élément du tableau
tab étant un pointeur sur le premier élément (élément
d’indice 0) du tableau, tab+i donne le pointeur vers
l’élément d’indice i du tableau.
On peut donc utiliser un pointeur pour accéder aux
différents éléments d’un tableau.
Dr KASSE 26
Exemple: Programme qui affiche un
tableau d’entiers
Programme qui affiche un tableau d’entiers
#include <stdio.h>
#define N 5
void main()
{
int tab[5] = {1, 2, 6, 0, 7};
int *p;
for (p=tab; p<=tab+N-1; p++)
printf(" %d \n",*p);
}
Dr KASSE 27
Exemple: Programme qui affiche un tableau
d’entiers
programme suivant imprime les éléments du tableau tab dans l’ordre
croissant puis décroissant des indices.
#define N 5
int tab[5] = {1, 2, 6, 0, 7};
main()
{
int *p;
printf("\n ordre croissant:\n");
for (p = &tab[0]; p <= &tab[N-1]; p++)
printf(" %d \n",*p);
printf("\n ordre decroissant:\n");
for (p = &tab[N-1]; p >= &tab[0]; p--)
printf(" %d \n",*p);
}
Dr KASSE 28
FIN
Dr KASSE 29