Comme en langage C, le langage C++ permet d'utiliser des pointeurs pour manipuler des données, mais il introduit aussi le concept de référence, très pratique pour permettre la modification d'une donnée passée en paramètre d'une fonction.
Définition d'un pointeur
Un pointeur est une variable contenant l'adresse d'une autre variable d'un type donné. La notion de pointeur fait souvent peur car il s'agit d'une technique de programmation très puissante, permettant de définir des structures dynamiques, c'est-à-dire qui évolue au cours du temps (par opposition aux tableaux par exemple qui sont des structures de données statiques, dont la taille est figée à la définition).
Comprendre la notion d'adresse
Comme nous l'avons vu, un pointeur est une variable qui permet de stocker une adresse, il est donc nécessaire de comprendre ce qu'est une adresse.
Lorsque l'on exécute un programme, celui-ci est stocké en mémoire, cela signifie que d'une part le code à exécuter est stocké, mais aussi que chaque variable que l'on a défini à une zone de mémoire qui lui est réservée, et la taille de cette zone correspond au type de variable que l'on a déclaré.
En réalité la mémoire est constituée de plein de petites cases de 8 bits (un octet). Une variable, selon son type (donc sa taille), va ainsi occuper une ou plusieurs de ces cases (une variable de type char occupera une seule case, tandis qu'une variable de type long occupera 4 cases consécutives).
Chacune de ces « cases » (appelées blocs) est identifiée par un numéro. Ce numéro s'appelle adresse.
On peut donc accéder à une variable de 2 façons :
- grâce à son nom
- grâce à l'adresse du premier bloc alloué à la variable
Il suffit donc de stocker l'adresse de la variable dans un pointeur (il est prévu pour cela) afin de pouvoir accéder à celle-ci (on dit que l'on « pointe vers la variable »).
Le schéma ci-dessus montre par exemple par quel mécanisme il est possible de faire pointer une variable (de type pointeur) vers une autre. Ici le pointeur stocké à l'adresse 24 pointe vers une variable stockée à l'adresse 253 (les valeurs sont bien évidemment arbitraires).
Comment connaît-on l'adresse d'une variable ?
En réalité vous n'aurez jamais à écrire l'adresse d'une variable, d'autant plus qu'elle change à chaque lancement de programme étant donné que le système d'exploitation alloue les blocs de mémoire qui sont libres, et ceux-ci ne sont pas les mêmes à chaque exécution.
Ainsi, il existe une syntaxe permettant de connaître l'adresse d'une variable, connaissant son nom :
il suffit de faire précéder le nom de la variable par le caractère & (« ET commercial ») pour désigner l'adresse de cette variable :
&Nom_de_la_variable
Intérêt des pointeurs
Les pointeurs ont un grand nombre d'intérêts :
- Ils permettent de manipuler de façon simple des données pouvant être importantes (au lieu de passer à une fonction un élément très grand (en taille) on pourra par exemple lui fournir un pointeur vers cet élément...)
- Les tableaux ne permettent de stocker qu'un nombre fixé d'éléments de même type. En stockant des pointeurs dans les cases d'un tableau, il sera possible de stocker des éléments de taille diverse, et même de rajouter des éléments au tableau en cours d'utilisation (c'est la notion de tableau dynamique qui est très étroitement liée à celle de pointeur)
- Il est possible de créer des structures chaînées, c'est-à-dire comportant des maillons
Déclaration d'un pointeur
Un pointeur est une variable qui doit être définie en précisant le type de variable pointée, de la façon suivante :
type * Nom_du_pointeur
Le type de variable pointée peut être aussi bien un type primaire (tel que int, char...) qu'un type complexe (tel que struct...).
Un pointeur doit OBLIGATOIREMENT être typé !
Grâce au symbole '*' le compilateur sait qu'il s'agit d'une variable de type pointeur et non d'une variable ordinaire, de plus, étant donné que vous précisez (obligatoirement) le type de variable, le compilateur saura combien de blocs suivent le bloc situé à l'adresse pointée.
Initialisation d'un pointeur
Après avoir déclaré un pointeur il faut l'intialiser. Cette démarche est très importante car lorsque vous déclarez un pointeur, celui-ci contient ce que la case où il est stocké contenait avant, c'est-à-dire n'importe quel nombre. Autrement dit, si vous n'initialisez pas votre pointeur, celui-ci risque de pointer vers une zone hasardeuse de votre mémoire, ce qui peut être un morceau de votre programme ou... de votre système d'exploitation !
Un pointeur non initialisé représente un danger !
Pour initialiser un pointeur, il faut utiliser l'opérateur d'affectation '=' suivi de l'opérateur d'adresse '&' auquel est accollé un nom de variable (celle-ci doit bien sûr avoir été définie avant...) :
Nom_du_pointeur = &nom_de_la_variable_pointee;
Par exemple :
int a = 2;
char b;
int *p1;
char *p2;
p1 = &a;
p2 = &b;
Pointeur thisxe "this (pointeur)"xe "pointeur:this"
Pour que les fonctions membres (non statiques) puissent accéder aux données membres d’un objet spécifique, c’est-à-dire d’une instance de leur classe, le compilateur leur transmet implicitement comme premier argument un pointeur sur ces données : il s’agit du pointeur this. Cela signifie que *this représente l’objet lui-même. Le pointeur this est accessible à l’intérieur de la fonction membre et c’est un pointeur constant (vous ne pouvez pas le modifier). Le type du pointeur this d’un objet de classe Date est Date *const.
Pour illustrer ce concept, nous allons ajouter la fonction AugmenteAnnee() à notre classe Date.
Code 4.6 : prototype et définition de la fonction AugmenteAnnee()
Date& AugmenteAnnee()(int n); //prototype à inclure dans la
//déclaration de classe
/******Définition de AugmenteAnnee()******/
Date& Date::AugmenteAnnee(int n)
{
if(jour==29 && mois==2 && !leapyear(annee+n){
//s’il s’agit du 29 février et que annee+n n’est
// pas bissextile
jour=1; //on modifie aussi le jour et le mois
mois=3;
}
annee+=n; //forme abrégée de annee=annee+n
return *this; //on retourne une référence de l’objet
]
Cette fonction permettra d’ajouter n année à l’objet Date concerné.
L’intérêt de retourner une référence de l’objet mis à jour est que si vous ajoutez d’autres fonctions de mise à jour en relation avec celle-ci (pour ajouter des jours ou des mois à la date, par exemple), vous aurez la possibilité d’enchaîner les opérations de la façon suivante :
void fonction(Date& d)
{
d.AugmenteJour(1).AugmenteMois(1).AugmenteAnnee(1);
}
Accéder à une variable pointée
Après (et seulement après) avoir déclaré et initialisé un pointeur, il est possible d'accéder au contenu de l'adresse mémoire pointée par le pointeur grâce à l'opérateur '*'. La syntaxe est la suivante :
*pointeur
Par exemple :
int a = 2;
Après ces deux instructions, le contenu des variables p1 et p2 sera respectivement 10 et 97 (61 en hexadécimal, le code ASCII associé au caractère 'a').
Si vous désirez utiliser cette notation dans une expression plus complexe, il sera nécessaire d'employer des parenthèses :
Par exemple :
a = (*p) + 2;
Passage d'argument à une fonction par adresse
Lorsque l'on passe une variable en paramètre d'une fonction, cette dernière utilise une copie de la variable lorsqu'elle effectue des opérations sensées la modifier, c'est-à-dire qu'en sortie de la fonction, une variable passée en paramètre n'est pas modifiée. Cela provient du fait que les variables utilisées dans la fonction ont comme portée la portée de la fonction. Or une variable ne peut être manipulée que dans la portée dans laquelle elle est définie...
Une première solution consiste à retourner la valeur de la variable modifiée et de la stocker par affectation dans la variable :
Par exemple :
int Ajout2(int a){
a +=2;
return a;
}
int b = 3;
b = Ajout2(b);
Toutefois, il se peut que l'on destine le retour de valeur à une autre opération, auquel cas l'astuce ci-dessus n'est plus suffisante.
Une solution consiste à utiliser un pointeur vers la variable en paramètre, on parle alors de passage de paramètres par pointeur ou passage de paramètres par adresse. De cette façon la fonction est à même d'accéder directement à la variable, donc de la modifier. Pour cela, il s'agit de déclarer un paramètre de type pointeur, et passer l'adresse de la variable au lieu de passer la variable elle-même comme dans le cas du passage de paramètre par valeur.
L'exemple précédent ressemblerait alors à ceci :
int Ajout2(int * a){
}
int b = 3;
Ajout2(&b);
Passage d'argument par référence
Le langage C++ apporte les avantages du passage par pointeur avec la simplicité du passage par valeur grâce au concept novateur de référence. Une référence (n'ayant aucun sens en langage C) permet de faire « référence » à des variables existant dans une autre portée, par exemple manipuler une variable située dans une fonction à partir d'une autre fonction.
La déclaration d'une référence se fait simplement en intercalant une esperluette (le caractère &, appelé aussi ET commercial) entre le type de la variable et son nom :
type & Nom_de_la_variable = valeur;
- Une référence doit obligatoirement être initialisée lors de sa déclaration !
- Le concept de référence ne doit en aucun cas être confondu avec celui d'adresse même si les deux notions utilisent le caractère &
Le passage par référence consiste tout simplement à définir une référence pour une variable et de la passer en paramètre d'une fonction.
Voici l'exemple précédent mettant en œuvre l'utilisation de référence :
int Ajout2(int &);
int Ajout2(int & a){
a +=2;
}
int b = 3;
Ajout2(b);
|
