Vous êtes sur la page 1sur 10

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

COURS
ALGORITHMIQUE

ET

PROGRAMMATION C

CHAPITRE :
LES POINTEURS

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

1 Introduction

Les variables utilises jusqu'alors sont toujours dsignes par leur nom
et ont pour porte le bloc dans lequel elles sont dfinies. Ces
proprits sont suffisantes et commodes pour les besoins les plus
courants.
A cause de cela, le nombre et le type des variables sont fixs
l'criture du programme. On dit souvent qu'elles sont statiquement
dfinies. Il arrive que le nombre d'objets traiter par un programme
puisse varier sans que l'on puisse fixer de limites.
Les pointeurs vont nous permettre de crer de nouveaux objets au fur
et mesure des besoins et d'tablir des relations complexes entre eux.
Pour supporter cette gestion complexe, le systme utilise une zone de
mmoire appele le tas (heap). Chaque variable nouvellement cre
occupe une place dans ce tas et un pointeur sert dsigner cette place
(adresse).
La notion de pointeur fait souvent peur car il s'agit d'une technique de
programmation trs puissante, permettant de dfinir des structures
dynamiques, c'est--dire qui volue au cours du temps (par opposition
aux tableaux par exemple qui sont des structures de donnes
statiques, dont la taille est fixe la dfinition).

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

2 Notion dadressage
Lorsque l'on excute un programme, celui-ci est stock en mmoire,
cela signifie que d'une part le code excuter est stock, mais aussi
que chaque variable que l'on a dfini a une zone de mmoire qui lui
est rserve, et la taille de cette zone correspond au type de variable
que l'on a dclar.
Chacune de ces zones (appeles blocs) est identifie par un numro.
Ce numro s'appelle adresse. On peut donc accder une variable de
2 faons:
grce son nom
grce l'adresse du premier bloc allou la variable
2.1 Adressage direct
Accs au contenu dune variable par le nom dune variable.
Exemple:
short A ; A = 10;
A
10
Adresse:

24

...
26

28

2.2 Adressage indirect


Accs au contenu dune variable, en passant par une autre variable
spciale qui contient ladresse de la variable.
Exemple:
P

26
Adresse:

06

...
08

10
26

28
3

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

3 Notion de pointeur
3.1 Dfinition
Un pointeur est une variable spciale contenant l'adresse d'une autre
variable d'un type donn.
Si un pointeur P contient ladresse dune variable A, on dit que P
pointe sur A .

3.2 Intrts des pointeurs

Les pointeurs ont un grand nombre d'intrts:


Ils permettent de manipuler de faon simple des donnes pouvant
tre importantes (au lieu de passer une fonction un lment trs
grand (en taille) on pourra par exemple lui fournir un pointeur vers
cet lment...
En stockant des pointeurs dans les cases d'un tableau, il sera
possible de stocker des lments de taille diverses, et mme de
rajouter

des

lments

au

tableau

(dynamique)

en

cours

d'utilisation
Il est possible de crer des structures chanes, c'est--dire
comportant des maillons.

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

4 Pointeurs en C
4.1 Dclaration
Pour dclarer un pointeur en langage C, on doit crire le type de la
variable sur laquelle il pointera suivi du caractre * pour prciser que
c'est un pointeur puis enfin son nom.
<Type> *<Nom_Pointeur> ;
Le type de la variable pointe peut tre aussi bien un type primaire
(int, char, ...) qu'un type complexe (struct, ...).
Exemples:
short *p; /* p est dfini comme un pointeur sur un short */
int * *q; /* q est dfini comme un pointeur sur un pointeur sur entier */
REMARQUES:
chaque pointeur est limit un type de donnes
le caractre * est rattach au nom qui le suit et non pas au
type.
Exemple:
char *P, C; /* P est bien un pointeur sur char et C est
simplement une variable de type char */

Les pointeurs et les noms de variables donnent accs un


emplacement en Mmoire Centrale

un pointeur est une variable qui peut pointer sur diffrentes


adresses, par contre,

le nom dune variable reste toujours li la mme adresse

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

4.2 Les oprateurs de base


4.2.1 L'oprateur adresse de : &
Pour

avoir

l'adresse

mmoire

dune

variable,

il

faudrait

la

variable

utiliser l'oprateur adresse de : &


Ainsi

&<Nom_Variable> :

fournit

ladresse

de

<Nom_Variable>
Exemples:
int A = 2;
char B;
int *p1;
char *p2;
p1 = &A; /* p1 pointe sur A */
p2 = &B; /* p2 pointe sur B */

4.2.2 L'oprateur contenu de : *


Pour accder au contenu de l'adresse mmoire pointe par un
pointeur, il faudrait utiliser l'oprateur contenu de : *
Ainsi

*<Nom_Pointeur> :

dsigne

le

contenu

de

ladresse

rfrence par le pointeur <Nom_Pointeur>


Exemples:
int A=10, B=50;
int *P;
P = &A;

/* P pointe sur A */

B = *P;

/* B contient 10 */

*P = 20;

/* A contient 20 */
6

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

5 Pointeurs et Tableaux
En langage C, le nom dun tableau reprsente ladresse de son premier
lment, cest donc un pointeur constant sur le 1er lment du
tableau.
Soit T un tableau dun type donn, et i un indice pour les composantes
de T:
T

dsigne ladresse de T[0]

(T <--> &T[0])

T+i

dsigne ladresse de T[i]

(T+i <--> &T[i])

*(T+i)

dsigne le contenu de T[i]

(*(T+i) <--> T[i])

Soit P un pointeur sur le type du tableau T, si on fait P = T alors :


P

pointe sur T[0]

(P <--> &T[0])

P+i

pointe sur T[i]

(P+i <--> &T[i])

*(P+i)

dsigne le contenu de T[i]

(*(P+i) <--> T[i])

REMARQUES:
Un pointeur est une variable (P = T ou P++ sont permises)
Le nom dun tableau est une constante (T = P ou T++ ne sont
pas permises)

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

6 Oprations sur pointeurs


6.1 Arithmtique des pointeurs
On peut essentiellement dplacer un pointeur dans un plan mmoire
l'aide des oprateurs d'addition, de soustraction, d'incrmentation,
de dcrmentation.
On ne peut donc dplacer un pointeur que d'un nombre de cases
mmoire multiple du nombre de cases rserves en mmoire pour la
variable sur laquelle il pointe.
Exemples:
int *pi;

/* pi pointe sur un objet de type entier */

float *pr;

/* pr pointe sur un objet de type rel */

char *pc;

/* pc pointe sur un objet de type caractre */

*pi = 421;

/* 421 est le contenu de la case mmoire pointe


par pi et des 3 suivantes */

*(pi+1) = 53;

/* on range 53 4 cases mmoire plus loin

*pr = 45.7;

/* 45.7 est rang dans la case mmoire pointe


par pr et les 3 suivantes */

pr++;

/* incrmente la valeur du pointeur pr (de 4 cases


mmoire) */

*pc = 'j';

/* le contenu de la case mmoire pc est le code


ASCII de 'j' */

pc--;

/* dcrmente la valeur du pointeur c (d'une case


mmoire) */

*/

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

REMARQUES:
La valeur numrique 0 indique quun pointeur ne pointe nulle
part.
Exemple:

int *p;
p = 0;

Affectation dun pointeur par un pointeur veut dire que les deux
pointeurs pointent sur le mme objet.
Exemple:

int *p, *q;


q = p; /* p et q pointent sur le mme objet */

6.2 Autres oprations


Toutes les oprations avec les pointeurs tiennent compte de la taille
du type des objets points.
Addition et soustraction dun nombre entier :
Si P pointe sur T[i] alors :
P+n pointe sur T[i+n] et P-n pointe sur T[i-n]
Incrmentation et dcrmentation dun pointeur :
Si P pointe sur T[i] alors :
P++; Pointe sur T[i+1] et P--; Pointe sur T[i-1]
P +=n; Pointe sur T[i+n] et P-=n; Pointe sur T[i-n]
Soustraction de deux pointeurs :
Si P1 et P2 pointent dans un mme tableau alors :
P1 - P2 donne le nombre de composantes entre P1 et P2 (cest
quivalent la soustraction des indices correspondants)
Comparaison de deux pointeurs: (<, >, <=, >=, ==, !=) :

Cours : Algorithmique & Programmation C

Chapitre : Les Pointeurs

Si P1 et P2 pointent dans un mme tableau alors : leur


comparaison

est

quivalente

la

comparaison

des

indices

correspondants

7 Rcapitulation
7.1 Les variables
int A;
A:

/* dclare une variable simple de type int */

dsigne le contenu de A

&A: dsigne ladresse de A


7.2 Les tableaux
int B[100];

/* dclare un tableau de type int de taille 100 */

B: dsigne ladresse (constante) du 1er lment de B

Formalisme tableau :
B[i]: dsigne le contenu de la composante i
&B[i]: dsigne ladresse de la composante i

Formalisme pointeur :
*(B+i) : dsigne le contenu de la composante i
B+i : dsigne ladresse de la composante i

7.3 Les pointeurs dans un tableau


int *P;

/* dclare un pointeur sur une variable du type int */

P = B;

/* P point sur B[0] */

P : dsigne ladresse du 1er lment de B


*(P+i) : dsigne le contenu de la composante i
P+i : dsigne ladresse de la composante i
10