Notion d’adresse

La mémoire centrale utilisée par les programmes, est découpée en

octets. Chacun de ces octets est identifié par un numéro séquentiel
appelé adresse. Par convention, une adresse est notée en hexadécimal et
précédée par 0x

1
Déclarer une variable, c'est attribuer un nom (l'identificateur) à une zone de
la mémoire centrale.
Cette zone est définie par :

•sa position c'est-à-dire l’adresse de son premier octet

•sa taille c'est-à-dire le nombre d’octets

2
Pour accéder à la valeur contenue dans une variable, on utilise
tout simplement son nom.
Mais il peut arriver qu'on veuille accéder à l'adresse d'une variable.
Dans ce cas, on utilise l'opérateur d'adresse & (notation C++)
suivi du nom de la variable.

&var1 vaut 0x3fffd14 (adresse du premier octet de var1)

3
Notion de pointeur

Un pointeur est une variable qui contient l'adresse d'une autre variable.
L'adresse contenue dans un pointeur est celle d'une variable qu'on appelle
variable pointée. On dit que le pointeur pointe sur la variable dont il
contient l'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.

4
•Un pointeur est lui-même une variable et à ce titre il possède une adresse.
•Š
Il convient de ne pas confondre l'adresse de la variable pointeur et l'adresse
contenue dans le pointeur (adresse de la variable pointée)

5
Petites révisions...

Pourquoi le pointeur pvar1 est-il représenté sur 4 octets??

Pour pouvoir coder un hexa il faut ½ octet donc pour en coder 7 il faut 4 octets
7 valeurs hexadécimales ont une puissance lexicographique de 167 soit 256Méga.
Cela veut dire que la mémoire possèdent 256Mo.

6
Déclaration d’un pointeur

Par convention, les pointeurs commencent par la lettre p. Il faut déclarer le type
de la variable pointée.

7
 En algorithmique en C

nom : pointeur sur type pointé type * nom;

Exemple : Exemple :
pvar: pointeur sur entier
int * pvar;

// * est appelé opérateur de

déréférencement

8
Utilisation d’un pointeur

On utilise un pointeur pour mémoriser l'emplacement d'une autre variable.

Il est très rare d'affecter directement une adresse à un pointeur.

On affecte en général l'adresse d'une variable existante.
Pour cela, en algorithmique, on utilise l'expression "adresse de" alors qu'en C,
on utilise l'opérateur d'adresse &

9
10
Soit v une variable de type réel et p un pointeur sur réel. Quelle instruction écrire pour que
p pointe sur v?
(en algorithmique et en C/C++)

11
12
 Il est possible d'extraire la valeur d'une variable pointée.

Déréférencer un pointeur consiste à extraire la valeur de la variable

sur laquelle il pointe.

On peut aussi modifier la valeur d'une variable pointée à travers un pointeur

déréférencé (accès en écriture)

13
14
15
16
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.

Si on veut que le pointeur pointe nul part, il faut l'initialiser à NIL (not identified link)
ou NULL en C/C++.
C'est l'équivalent de 0 pour les pointeurs. Mais attention, il ne faut jamais déréférencer un
pointeur nul.
Avant de déréférencer un pointeur, il faut toujours s'assurer qu'il n'est pas nul.

p: pointeur sur entier int *p = NULL;

p  NIL //p pointe nul part

17
18
Lors du travail avec des pointeurs, nous avons besoin
- d'un opérateur 'adresse de': &
pour obtenir l'adresse d'une variable.
- d'un opérateur 'contenu de': *
pour accéder au contenu d'une adresse.
- d'une syntaxe de déclaration
pour pouvoir déclarer un pointeur.
L'opérateur 'adresse de' : &
&<NomVariable> fournit l'adresse de la variable <NomVariable>

19
L'opérateur & nous est déjà familier par la fonction scanf, qui a besoin
de l'adresse de ses arguments pour pouvoir leur attribuer de nouvelles
valeurs.
Exemple
int N;
printf("Entrez un nombre entier : ");
scanf("%d", &N);
Attention !
L'opérateur & peut seulement être appliqué à des objets qui se trouvent
dans la mémoire interne, c.-à-d. à des variables et des tableaux. Il ne
peut pas être appliqué à des constantes ou des expressions.

20
21
22
23
24
25
Remarque

Lors de la déclaration d'un pointeur en C, ce pointeur est lié

explicitement à un type de données. Ainsi, la variable PNUM déclarée
comme pointeur sur int ne peut pas recevoir l'adresse d'une variable d'un
autre type que int.
La limitation d'un pointeur à un type de variables n'élimine pas
seulement un grand nombre de sources d'erreurs très désagréables, mais
permet une série d'opérations très pratiques sur les pointeurs

26
Quelques opérations élémentaires sur les pointeurs

Nous devons observer les règles suivantes:

Priorité de * et &
* Les opérateurs * et & ont la même priorité que les autres opérateurs
unaires (la négation !, l'incrémentation ++, la décrémentation --). Dans
une même expression, les opérateurs unaires *, &, !, ++, -- sont évalués
de droite à gauche.
* Si un pointeur P pointe sur une variable X, alors *P peut être utilisé
partout où on peut écrire X.

27
28
Dans le dernier cas, les parenthèses sont nécessaires:
Comme les opérateurs unaires * et ++ sont évalués de droite à
gauche, sans les parenthèses le pointeur P serait incrémenté,
non pas l'objet sur lequel P pointe.
On peut uniquement affecter des adresses à un pointeur.

29
Le fait qu'un pointeur pointe sur une variable s'appelle indirection
(comme accès indirect). Quand un pointeur pointe sur un autre pointeur, il y a double
indirection.

30
On peut accéder à var par ppvar en utilisant deux fois l'opérateur de déréférencement *
* *ppvar est équivalent à 18 et à *pvar
On pourrait imaginer de la même façon des indirections triples voire quadruples.

31
Transmission de paramètres par adresse
Pour pouvoir modifier la valeur d'un paramètre dans un sous-programme, il fallait passer ce
paramètre non pas "par valeur" "par variable" (ou par référence en C++).
Il existe une autre manière de passer un paramètre permettant de modifier
sa valeur dans un sous-programme:
il s'agit du passage par adresse, (avec le langage C++)
Le passage par adresse consiste à passer, non pas la valeur ni une référence de
la variable paramètre, mais de passer l'adresse de cette variable. Pour cela, lors de l'appel,
l'adresse du paramètre effectif est passée grâce à l'opérateur &.
Dans l'en- tête de la fonction, le paramètre formel est donc un pointeur, déclaré grâce à
l'opérateur *.
Et dans le corps de la fonction, lorsqu'on veut manipuler la valeur de la variable pointée
(le paramètre effectif), on déréférence le paramètre formel grâce à l'opérateur *;

32
Utilisation d'une fonction void qui permet d'échanger les valeurs
de deux paramètres entiers.

33
Lors de l'appel, la valeur pointée par a est x et la valeur pointée par b est
y.

œRemarque:

La transmission des paramètres se fait toujours par valeur

(la valeur des adresses !) On passe la valeur des expressions &x et &y.
Les paramètres effectifs sont ici des adresses, qui sont passées par
valeur.

34
Adressage des composantes d'un tableau

Le nom d'un tableau représente l'adresse de son premier élément. En

d'autre termes:
&tableau[0] et tableau
sont une seule et même adresse.
En simplifiant, nous pouvons retenir que le nom d'un tableau est un
pointeur constant sur le premier élément du tableau.
Exemple
En déclarant un tableau A de type int et un pointeur P sur int,
int A[10]; int *P;
l'instruction:P = A; est équivalente à P = &A[0];

35
Si P pointe sur une composante quelconque d'un tableau,
alors P+1 pointe sur la composante suivante.

Plus généralement:
P+i pointe sur la i-ième composante derrière P et

P-i pointe sur la i-ième composante devant P.

36
Après l'instruction,
P = A;

le pointeur P pointe sur A[0], et

*(P+1) désigne le contenu de A[1]

*(P+2) désigne le contenu de A[2]
... ...
*(P+i) désigne le contenu de A[i]

37
Comme A représente l'adresse de A[0],

*(A+1) désigne le contenu de A[1]

*(A+2) désigne le contenu de A[2]

...

*(A+i) désigne le contenu de A[i]

38
Attention !
Il existe toujours une différence essentielle entre un pointeur et le nom
d'un tableau:

-Un pointeur est une variable,

donc des opérations comme P = A ou P++ sont permises

-Le nom d'un tableau est une constante,

donc des opérations comme A = P ou A++ sont impossibles.

39
Résumons
Soit un tableau A d'un type quelconque et i un indice pour les
composantes de A, alors:

A désigne l'adresse de A[0]

A+i désigne l'adresse de A[i]

*(A+i) désigne le contenu de A[i]

Si P = A, alors P pointe sur l'élément A[0]

P+i pointe sur l'élément A[i]

*(P+i) désigne le contenu de A[i]

40
Exemple
Formalisme Tableau
Int main()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS[10];
int I,J; // i indice courant dans T et j dans POS
for (J=0,I=0 ; I<10 ; I++)
if (T[I]>0)
{
POS[J] = T[I];
J++;
}
return 0;
}

41
Formalisme Pointeur
Int main()
{
int T[10] = {-3, 4, 0, -7, 3, 8, 0, -1, 4, -9};
int POS[10];
int I,J; // i indice courant dans T et j dans POS
for (J=0,I=0 ; I<10 ; I++)
if (*(T+I)>0)
{
*(POS+J) = *(T+I);
J++;
}
return 0;
}

42
Sources d'erreurs

Un bon nombre d'erreurs lors de l'utilisation de C provient de la

confusion entre soit contenu et adresse, soit pointeur et variable
Les variables et leur utilisation int A;
déclare une variable simple du type int
A désigne le contenu de A
&A désigne l'adresse de A

int B[];
déclare un tableau d'éléments du type int
B désigne l'adresse de la première composante de B.
(Cette adresse est toujours constante)
B[i] désigne le contenu de la composante i du tableau
&B[i] désigne l'adresse de la composante i du tableau

43
en utilisant le formalisme pointeur:
B+i désigne l'adresse de la composante i du tableau
*(B+i) désigne le contenu de la composante i du tableau

int *P;
déclare un pointeur sur des éléments du type int.
P peut pointer sur des variables simples du type int
ou sur les composantes d'un tableau du type int.

P désigne l'adresse contenue dans P (Cette adresse est variable)

*P désigne le contenu de l'adresse dans P

Si P pointe dans un tableau, alors

P désigne l'adresse de la première composante

P+i désigne l'adresse de la i-ième composante derrière P
*(P+i) désigne le contenu de la i-ième composante derrière P
44
45
46
47
48
49
50
51
52
53
54
55
56
57
En notation algorithmique

pointeur sur l'enregistrement -> champ est équivalent à enregistrement . champ

58
59
60
 Pointeur vers un enregistrement
Il est très courant d'utiliser un pointeur pour mémoriser l'adresse d'un enregistrement
Avec un pointeur sur un enregistrement,
on peut accéder aux champs de l'enregistrement pointé en utilisant
l'opérateur « ->" (moins et supérieur)

61
Lien entre enregistrements grâce à un pointeur
Dans un enregistrement, un des champs peut très bien être un pointeur, par exemple sur
un autre enregistrement

62
63
64
A partir d'un élève, on peut connaître les caractéristiques de son
instituteur grâce au pointeur contenu dans l'enregistrement de l'élève.
Le pointeur réalise un lien entre un élève et son instituteur.
Mais l'enregistrement instituteur ne possède pas de pointeur vers la liste
de ses élèves. A partir de l'instituteur, on ne peut pas accéder aux champs
des élèves.
Un pointeur est donc un lien univoque (dans un seul sens)
Plusieurs pointeurs peuvent pointer sur un même enregistrement (ici,
deux élèves ont le même instituteur), mais un pointeur ne peut pointer
que sur une seule variable (enregistrement) à la fois.

65
Comment représenteriez-vous le lien réalisé par le pointeur grâce au modèle entité-
association ?

Un pointeur réalise une association (1,n) mais dans un seul sens. On peut naviguer du
1 vers le n mais pas dans le sens inverse.
66
Allocation dynamique de la mémoire
Il y a deux façons d’allouer un emplacement mémoire pour une variable :
Soit par une déclaration, telle qu’on l’a vu jusqu’à présent
Soit par une allocation dynamique explicite, ce que nous allons voir maintenant

La déclaration permet d’allouer un emplacement dans une partie de la mémoire appelée

pile . Les variables déclarées dans la pile possèdent un nom. Leur portée (c’est-à-dire là
où elles peuvent être utilisées) est déterminée par l’endroit où elles sont déclarées. Elles
sont crées dès l’entrée dans la portée et détruites dès la sortie de leur portée.

L’allocation dynamique permet d’allouer un emplacement dans une autre partie de la

mémoire appelé tas . Les variables du tas ne sont pas déclarées, elles sont créées par
une instruction spécifique. Elles ne portent pas de nom mais on peut y accéder par leur
adresse. Elles peuvent être utilisées partout et jusqu’à leur destruction (il n’y a pas de
portée pour les variables du tas).

67
68
69
Désallouer la mémoire

On peut déclarer le pointeur et lui affecter l’adresse d’un emplacement

du tas en une seule instruction :
float* p = new float ;

En C++, il est nécessaire de désallouer explicitement la mémoire allouée

dans le tas. Si la mémoire n’est pas désallouée, il peut arriver qu’elle
sature et fasse planter le programme et même l’ordinateur tout entier. En
effet, quand plus aucun pointeur ne pointe sur un emplacement alloué du
tas, cet emplacement n’est plus accessible pour le système. (En
algorithmique, nous supposons qu’il existe un mécanisme permettant de
désallouer automatiquement les emplacements qui ne sont plus pointés,
comme en Java)

70
Pour éviter la saturation de la mémoire, il est donc nécessaire de désallo uer les
emplacements alloués dans le tas. Pour cela, on utilise l’opérateur delete en C++ ou
désallouer en algo, suivi du pointeur qui pointe sur l’emplacement à désallouer.

71
72
73
74
75
76
77
78
79
80
81