Les qualificateurs

C++ propose un nouveau qualificateur de type qui est introduit par le mot-clé const. Ce qualification est utilisée pour indiquer qu’un type est constant.

const int x = 3;    // Introduit une variable de type int qui ne peut pas être     
                    // modifiée. 
 
int z = 4; 
const int* y = &z;   // Introduit un pointeur sur une variable de type entier qui    
                     // ne pourra pas être modifiée. 
int * const m  = &z ;  // Introduit un pointeur constant. C’est le pointeur qui ne                  
                     // peut pas être modifié et qui fera toujours référence à z.     
                     // Par contre le contenu de z peut être modifié. 

Plus spécifiquement,

int z = 4;
const int* y = &z;
int* const m = &z;
 
const int v = 3;
int const w = 4;
 
int main()
{
 
    int u = 3;
    y = &u;         // Ok, c'est la valeur pointée qui est constante, 
                    // pas le pointeur.
    *y = 3;         // Erreur à la compilation, le contenu de la mémoire 
                    // vers lequel le pointeur pointe ne peut-être modifié.
                    // ne peut-être modifiée.
    *m=3;           // Ok, le pointeur est constant, pas le contenu de 
                    // la mémoire vers laquelle le pointeur pointe.
    m = &u;         // Erreur à la compilation, l'adresse définissant la mémoire
                    // vers laquelle le pointeur pointe ne peut pas être modifiée.
}

Une valeur ou un objet ayant un type n'étant pas qualifié par const peut-être automatiquement promu en valeur ou un objet ayant le même type mais qualifié par const.

Ainsi si nous considérons une fonction de recherche de la position d'un élément dans une séquence :

#include<iostream>
 
int findIndex(int theValue, const int* anArray, int theArrayLength)
{
    for(int i = 0; i < theArrayLength; i++)
    {
        if(anArray[i] == theValue)
            return i;
    }
    return -1;      
}
 
int main()
{
    int array[7] = {2, 3, 2, 4, 7, 3, 8 };
    std::cout << "Index du premier 3 dans le tableau " << findIndex(3, array, 7) << std::endl;
}

le tableau'array' qui avait pour type int* est automatiquement promu en tableau ayant comme type const int*.

Dans certains cas, il peut-être nécessaire de transformer une référence sur une valeur non modifiable en référence sur une valeur modifiable. Cette opération qui est normalement à éviter peut-être cependant effectuer par l'opérateur const_cast.

int buggyFindIndex(int theValue, const int* anArray, int theArrayLength)
{
    for(int i = 0; i < theArrayLength; i++)
    {
        if(anArray[i] == theValue)
        {
            const_cast<int*>(anArray)[i] = 0;
            // converti anArray en int*, permettant de modifier les valeurs 
            // pointées par anArray. 
            return i;
        }
    }
    return -1;      
}
 
void main()
{
    int array[7] = {2, 3, 2, 4, 7, 3, 8 };
    std::cout << "Index du premier 3 dans le tableau " << buggyFindIndex(3, array, 7) << std::endl;
    std::cout << "Liste des éléments du tableau après exécution" << std::endl;
    std::cout << "[";
    int i = 0;
    for(;i < 6; i++)
        std::cout << array[i] << ", ";
    std::cout << array[i] << "]" << std::endl;
}