====== Les qualificateurs ======

===== Le qualificateur ''const'' =====

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. 

<code cpp>
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é. 
</code>

Plus spécifiquement,

<code cpp>

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.
}
</code>

==== Promotion d'un type modifiable en type non modifiable ====

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 :

<code cpp>

#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;
}

</code>

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

==== Conversion d'un type non-modifiable en type modifiable ====

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''.

<code cpp>
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;
}


</code>