Introduction à C++, Section 4.A

Constantes

Il est possible en C++ de définir des données constantes. Ces données ne peuvent être modifiées.

Il s’agit généralement de valeurs universelles :

const double Pi = 3.141592;

Il est conventionnel en C++ (quoique non obligatoire) d’écrire les constantes en majuscules (PI) ou en commençant par une majuscule (Pi). Rappelons que le langage différencie les majuscules des minuscules dans les identificateurs, de sorte que PI, Pi, et pi sont trois identificateurs distincts.

Toute tentative d’écriture se soldera par un refus très net du compilateur :

Pi += 1;      // refusé  !!

donnera le message Error : Lvalue required (car une constante n’est pas une lvalue) ; dans d’autres cas, on obtiendrait plus clairement Error : Cannot modify a const object, on ne peut pas modifier un objet constant.

Si l’on tente d’utiliser des pointeurs :

double *dp = &Pi;

on obtient Error : Cannot initialize 'double near*' with 'const double near*'. Il faut en effet écrire :

const double *dp = &Pi;

ou de manière équivalente :

double const *dp = &Pi;

Cette déclaration signifie que *dp est constant. En conséquence, toute occurrence de *dp dans le programme est remplacée par la constante, même si l’on modifie dp. En effet, le pointeur lui-même n’est pas constant, on peut l’incrémenter :

dp++;
double z = *dp;

dans ce cas, z prend la valeur de Pi, comme si dp n’avait pas été modifié ; surprenant, non ?

Quant aux références, on peut parfaitement les utiliser :

double &d = Pi;    // valable
d++;               // ok, d == 4.14 maintenant

En fait, on a initialisé la référence sur une constante, ce qui provoque la création d’une variable provisoire, comme on l’a expliqué au chapitre précédent.

La variable Pi est donc tout à fait blindée, il est réellement impossible de la changer ; et pour cause : elle n’existe pas ! Aucune place en mémoire n’est allouée à Pi, de sorte qu’il n’est pas possible de prendre son adresse (ni même d’en connaître la valeur en cours de débogage). La valeur réelle est simplement substituée à l’écriture Pi, ainsi qu’à dp, dans tout le programme, ce qui constitue un raccourci pratique.

On peut parfaitement définir des tableaux constants :

const int table[3] = { 1, 2, 3 };

et des pointeurs constants (ne pas confondre avec les pointeurs sur des constantes) :

double *const dc = &d;

Dans ce cas, l’opération ++dc par exemple est interdite, puisqu’il s’agit d’un pointeur constant. Par contre, on peut écrire :

(*dc)++;    // équivaut  à d++;

On ne peut donc pas initialiser dc avec &Pi.

Il existe aussi des pointeurs constants pointant sur des constantes :

const double *const dcc = &Pi;

Dans ce cas, on ne peut modifier ni dcc ni *dcc.

Précédent

Sommaire

Suivant