INTRODUCTION AUX POINTEURS ET

AUX REFERENCES

1. Qu’est-ce qu’un pointeur ?

Un pointeur est une variable qui contient l’adresse d’une variable. Une variable contient une

valeur spécifique. Un pointeur comme toute autre variable doit être défini avant d’être

utilisé.

La forme générale de déclaration :

type *nom-de-variable;

Exemple :

//cmptPtr peut être utilisé pour pointer sur une variable de type int

int * cmptPtr, cmpt;

// xPtr et yPtr peuvent être utilisés pour pointer sur des variables de type float

float *xPtr, *yPtr;

Dans une déclaration, quand une variable est précédée de *, cette variable devient un

pointeur

Un pointeur peut être initialisé lors de sa déclaration ou lors de l’opération d’affectation. Un

pointeur peut être initialisé à zéro, à NULL ou une adresse. Un pointeur qui ne pointe à rien

pointe à zéro ou à NULL.

Th. K. DAGBA, ENEAM 2019

Page 1
Deux opérateurs spéciaux sont utilisés avec les pointeurs : * et &

L’opérateur * s’appelle l’opérateur de déréférencement

Exemple :

ptr = &total;

ptr prend l’adresse mémoire de la variable total. Par exemple, si total a la valeur 5 et

placée à l’adresse 100, alors après l’affectation, ptr prend la valeur 100

val = *ptr;

val va recevoir la valeur de total

Exemple

#include <iostream>
using namespace std;
int main()
{
int total;
int *ptr;
int val;
total = 3200;
ptr = &total;
cout<<"L’adresse de total : "<<ptr ;
cout<<"L’adresse de prt+1 :"
val = *ptr;
cout<<"Le total est:"<<val<<endl;
cout<<(*ptr+1) ;// ?
cout<<*(ptr+1) ;// ?
return 0 ;
}

Th. K. DAGBA, ENEAM 2019

Page 2
 2. Pointeur de type void:

D’ordinaire, un pointeur doit pointer sur une variable qui est de même type que le type du

pointeur.

Ex :
float floatvar = 98.6 ;
int* intPtr = &floatvar ; // Erreur

Mais il existe une exception à la règle : il s’agit de l’utilisation du pointeur de type void :

Ex :
// ptr peut pointer sur n’importe quel type de donnée
//void * ptr ;
#include <iostream>
using namespace std ;
int main()
{
int intvar;
float flotvar;
int * intptr;
float* floatptr;
void * voidptr;
intptr = &intvar; //OK
//intPtr = &floatvar;// erreur
//floatPtr= &floatvar;//OK
voidPtr = &intvar;
voidPtr = &floatvar;
return 0;
}

Th. K. DAGBA, ENEAM 2019

Page 3
 3. Constantes pointeurs et pointeurs sur constante

3.1. Constante pointeur

L’adresse placée dans le pointeur ne peut pas changer mais l’objet pointé peut
changer.

Ex :

int x = 0;
int *const cp = &x; //cp est une constante pointeur sur x

3.2. Pointeur sur une constante

L’objet pointé ne peut pas être modifié, mais le pointeur peut être modifié pour
pointer sur quelque chose d’autre.

Ex :

int x=0;
const int *pc = &x;// pc est pointeur sur une constante

3.3. Constante pointeur sur une constante

Le pointeur et l’objet pointé sont tous deux des constantes et par conséquent, aucun
des deux ne peut changer

Ex :
int x=0;
//cpc est une constante qui pointe sur une constante
const int *const cpc = &x;

Il est plus simple de lire la définition d’un pointeur par la fin :

Ex :

Th. K. DAGBA, ENEAM 2019

Page 4
 const int * const p

p est Une constante qui pointe sur Un objet de type int qui est une constante

4. Pointeur sur un pointeur

L’objet pointé par un pointeur peut lui-même être un pointeur.

Ex :

int x = 0;

int *px = &x;

int **pp = &px;

5. Lien entre pointeurs et tableaux

Il existe un lien étroit entre pointeurs et tableaux

Ex : accès aux éléments d’un tableau par leur indice

#include <iostream>
using namespace std;
int main()
{
int intTab[5]={31, 54, 77, 52, 93};
for(int j=0; j<5;j++)
cout<<intTab[j]<<endl;
return 0;
}

Ex: accès aux éléments d’un tableau par pointeurs

#include <iostream>

using namespace std;

int main()

Th. K. DAGBA, ENEAM 2019

Page 5
 int intTab[5]={31, 54, 77, 52, 93};

for(int j=0; j<5;j++)

cout<<*(intTab+j)<<endl;

return 0;

Le nom du tableau représente son adresse donc l’expression *(intTab+j) a exactement le

même effet que intTab[j] et les 2 programmes affichent le même résultat.

Ex : Tableau de pointeurs aux chaînes de caractères

#include<iostream>

using namespace std ;

constintjours = 7;

intmain()

char* arrptrs[jours] = {"Dimanche", "Lundi", "Mardi",

"Mercredi", "Jeudi", "Vendredi", "Samedi"} ;

for(int j=0 ; j<jours ; j++)

cout<<arrptrs[j]<<endl ;

6. Les références
A côté des pointeurs, les références sont une autre manière de manipuler les adresses des

objets placés dans la mémoire. Une référence est un pointeur géré de manière interne par la

machine. Une valeur de type référence est une adresse mais, hormis lors de son

Th. K. DAGBA, ENEAM 2019

Page 6
initialisation, toute opération effectuée sur la référence agit sur l'objet référencé, non sur

l'adresse. Il en découle qu'il est obligatoire d'initialiser une référence lors de sa création.

La syntaxe pour définir une référence :

Type &nomRef = variableAReferencer

Exemple :

int i;

int &r = i; // r est une référence sur i

Les références permettent de bénéficier d'un mécanisme d'alias sur les variables.

Exemple : utilisation des références

int main()
{
int val =10 ;
int i ;
int *pval = &val ; // Pointeur sur val
int &refVal = val ; // référence sur val
//int &refAutre ; // Erreur
*pval =12 ;
cout<< val ;
refVal++ ;
cout<<val ;
i = refVal ; // ‘i’ vaut 13, valeur de ‘val’
cout<< i ;
}

7. Allocation dynamique de la mémoire

L'allocation dynamique de mémoire permet au programmeur de gérer la RAM comme bon

lui semble en créant ou en détruisant de nouvelles structures.
Jusque là, nous avons autant de mémoire que déclarée pour les variables, étant donné que
la taille de ces variables est déterminée dans le code source avant l’exécution du

Th. K. DAGBA, ENEAM 2019

Page 7
programme. Mais que faire si nous avons besoin d’une quantité de mémoire pendant
l’exécution du programme ? La réponse se trouve dans l’allocation dynamique de mémoire.
Un programme en C++ est capable de demander au système d'exploitation, de la mémoire
pour y stocker des données et de libérer ces zones mémoire au cours de l'exécution du
programme : on appelle cela l'allocation dynamique de mémoire. En C++ on utilise à cet effet
les instructions new et delete

Les opérateurs new and new[ ]

Pour solliciter la mémoire dynamique, on utilise l’opérateur new.

Syntaxe:
//pour allouer de la mémoire afin de contenir une variable de type t
p = new t
//allouer un tableau d’éléments de type t
p = new t [nombre_d_element]

Exemple:
int* bobby;
bobby = new int[5];

Dans ce cas, le système alloue dynamiquement de l’espace pour 5 éléments de type int et
retourne un pointeur sur le premier élément de type int.

On peut accéder au premier élément pointé par bobby en utilisant l’expression bobby[0] ou
l’expression *bobby.
Ces deux expressions sont équivalentes.
On peut accéder au deuxième élément par bobby[1] ou *(bobby+1), ainsi de suite.

Operateurs delete et delete[ ]

Si la mémoire allouée n’est plus nécessaire, alors on peut la libérer. On utilise à cet effet les
instructions delete ou delete[]
delete p;//Pour le cas d’un élément singulier
delete[] p;//Pour les cas d’un tableau

Th. K. DAGBA, ENEAM 2019

Page 8
 EXERCICE :

1) Etant donné les déclarations suivantes :

int i = 3 ;
int & j= i ;
int* pi ;
int array[10];

Quel est le type des expressions suivantes:

a) i
b) j
c) &i
d) *pi
e) array
f) *array
g) pi[3]
h) pi + 3

2) Etant donné le code suivant :

char c[] = "Salut les copains !" ;

char* pc = &c[2] ;

Quel sera le résultat des instructions suivantes :

a) cout << c ;
b) cout <<c[3] ;
c) cout << pc ;
d) cout << *(pc – 2) ;
e) cout << *pc – 2 ;

Th. K. DAGBA, ENEAM 2019

Page 9