Les Pointeurs en C – C++
Rappel
Pointeurs
&
Allocation de mémoire
DERENDINGER
1
Eric – 2013
Une variable est destinée à contenir une valeur du
yp avec lequel
q
elle est déclarée.
type
Physiquement cette valeur se situe à une adresse de
la mémoire vive RAM (Random Access Memory).
Exemple : un entier nommé x
int x;
// Réserve un emplacement pour un entier en mémoire
mémoire.
Rappel
◦ Les variables en mémoire
◦ Adressage des variables
Notion de pointeurs
Pointeurs & Tableaux
Allocation dynamique de la mémoire
DERENDINGER
2
Eric – 2013
Espace Mémoire (8 bits de données)
Adresse mémoire
[0 - Taille de la RAM]
Contenu d’un octet en mémoire
int x;
x (réservation de 4 octets pour un int)
x = 10;
x (4 octets)
x = 10; // Écrit la valeur 10 dans l'emplacement réservé.
DERENDINGER
3
Eric – 2013
DERENDINGER Eric - 2013
DERENDINGER
4
Eric – 2013
1
Les Pointeurs en C – C++
Espace Mémoire (8 bits de données)
Adresse mémoire
[0 - Taille de la RAM]
Tab : adresse du tableau
unsigned char Tab[3];
Ad
Adressage
di
direct : Accès
A è au contenu d'
d'une variable
i bl
Adressage indirect : Accès au contenu d'une variable
Contenu d’un octet en mémoire
Tab (réservation d’un tableau 3 octets non signés)
Variable Tab [[0]]
Tab[0] = 10;
En C – C++ , on dispose de deux mode d’adressage :
Tab (3 octets)
par le nom de la variable.
par le biais de l'adresse de cette variable -> pointeur.
L’opérateur & permet de récupérer l’adresse d’une
variable :
&x est l’adresse de x ( 62 ).
x (réservation de 4 octets)
DERENDINGER
5
Eric – 2013
Définition : "Un pointeur est une variable spéciale
qui contient l'adresse d'une autre variable. "
Chaque
pointeur
estt définit
Ch
i t
défi it à un ttype de
d données.
d
é
Déclaration : <type> * nom_pointeur ;
!!! Il faut toujours initiliser le pointeur avec l’adresse
d’une variable ou réserver un emplacement mémoire
vide !!!
DERENDINGER
6
Eric – 2013
int *px; // Réserve un emplacement pour
stocker l’adresse mémoire d’un entier
px = &x; // affecte la valeur du pointeur
avec l'adresse mémoire de la variable x.
*px = 25; // affecte la valeur 25 à l'adresse
mémoire contenue dans px.
int *px;
px;
DERENDINGER
7
Eric – 2013
DERENDINGER Eric - 2013
DERENDINGER
8
Eric – 2013
2
Les Pointeurs en C – C++
int *px;
L’opérateur * permet d’accéder au contenu de la
variable pointée :
*px = 20; // Maintenant x est égal à 20.
px = &x;
20
px pointe sur x
DERENDINGER
9
Eric – 2013
Après les instructions: <type> a;
yp *p;
p;
<type>
p = &a;
p : pointe sur a
p : désigne &a (adresse de a)
*p : désigne a (valeur ou contenu de a)
DERENDINGER
10
Eric – 2013
La déclaration d’un pointeur (adresse d’une variable)
ne permet pas de connaître la taille de la variable
(exemple les variables de type tableaux ou les objets
en C++)
Allocation dynamique de taille mémoire pour la
variable
La réservation de la mémoire doit absolument se faire
pendant l'exécution du programme !
DERENDINGER
11
Eric – 2013
DERENDINGER Eric - 2013
DERENDINGER
12
Eric – 2013
3
Les Pointeurs en C – C++
La fonction malloc ()
( #include<stdlib.h> )
void malloc( <N> ) fournit l'adresse d'un bloc en mémoire de
<N> octets libres ou la valeur zéro (NULL) s'il
s il n
n'yy a pas
assez de mémoire.
La fonction sizeof ()
sizeof (<type>) fournit la taille en octets pour une variable ou
un objet du type <type>
L’opérateur en C++ new
nomClasse *nomObjet ; // déclare un pointeur
nomObjet du type de la classe nomClasse.
nomObjet
Obj = new monClasse()
Cl
() ; // réserve
é
l’
l’espace
mémoire pour cet objet de la taille de la classe nomClasse()
en octets.
DERENDINGER
13
Eric – 2013
La fonction free()
(Casting)
Taille en octets
p = (int *) malloc(25*sizeof(int)); // réservation
d’un espace mémoire de 25 entiers
p = nbr // affectation de l’adresse du tableau
d’entier nbr à p
Il est toujours utile de tester si l’allocation a eu lieu :
if (p == NULL) printf ("Impossible d’alloué l’espace mémoire ");
DERENDINGER
14
Eric – 2013
(<stdlib.h> )
free(( Pointeur ) ;
libère le bloc de mémoire (déjà alloué) désigné par
le Pointeur .
int nbr[25];
Type de pointeur
int *p;
Si nous ne libérons pas explicitement la mémoire à
l'aide free(), alors elle est libérée automatiquement
à la fin du programme.
Adressage Direct
Adressage Indirect
#include <stdio.h>
#include <stdlib.h>
main()
{
// Variables à adressage
direct
int i;
int tab[10] ;
// affectation des valeurs au
tableau
for(i=0; i<10; i++)
tab[i]=i;
// Affichage des valeurs du
tableau
for(i=0; i<10; i++)
printf("%d\n",tab[i]);
}
#include <stdio.h>
#include <stdlib.h>
main()
{
int i, nbr[10];
// Variables pointeur à adressage
indirecte
int * p;
p=(int*)malloc(10*sizeof(int));
p = nbr;
// affectation des valeurs au
tableau
for(i=0; i<10; i++)
nbr[i]=i;
// Affichage des valeurs du tableau
for(i=0; i<10; i++)
printf("%d\n",p[i]);
free(p);
DERENDINGER
15
Eric – 2013
DERENDINGER Eric - 2013
DERENDINGER
16
Eric – 2013
}
4
