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 typefloat

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 20147

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 totala 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 20147

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 :
floatfloatvar = 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()
{
intintvar;
floatflotvar;
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 20147

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;

Th. K. DAGBA, ENEAM 20147

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

Ex :

const int * const p

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

Exemples d’utilisation

//tableau de pointeurs : on met l’adresse d’un tableau constant dans un pointeur non
//constant
char* pstr[] ={
"James",
"Sossa",
"Cakpo",
"Abdoulaye",
"Mamadou",
"Bineta",
};

*pstr[0] = ‘X’ ; //Cette instruction va provoquer l’arrêt du programme

Une meilleure manière d’écrire cette déclaration est la suivante

//tableau de pointeurs sur constantes

//

const char* pstr[] ={

"James",
"Sossa",
"Cakpo",
"Abdoulaye",
"Mamadou",
"Bineta",
};

On peut néanmoins écrire une instruction de la forme :

Th. K. DAGBA, ENEAM 20147

Page 5
 pstr[0] = pstr[1] ;

Pour interdire une instruction comme ci-dessus avec la déclaration suivante

//tableau constantes pointeurs sur des constantes

const char* const pstr[] ={

"James",
"Sossa",
"Cakpo",
"Abdoulaye",
"Mamadou",
"Bineta",
};

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()
{
intintTab[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>
Th. K. DAGBA, ENEAM 20147
Page 6
using namespace std;

int main()

intintTab[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 ;

Th. K. DAGBA, ENEAM 20147

Page 7
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

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

intmain()
{
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 ;
}

Th. K. DAGBA, ENEAM 20147

Page 8
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
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 pour contenir une variable de type t
pointeur = new t
//allouer un tableau d’éléments de type t
pointeur = 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.

Th. K. DAGBA, ENEAM 20147

Page 9
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 pointeur;//Pour le cas d’un élément singulier
delete[] pointeur;//Pour les cas d’un tableau

Th. K. DAGBA, ENEAM 20147

Page 10
 EXERCICE :

1) Etant donné les déclarations suivantes :

inti = 3 ;
int& j= i ;
int* pi ;
intarray[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 20147

Page 11