Le mot-clé const joue un rôle crucial en C++. Bien qu'il soit souvent compris comme signifiant "constante", son utilité dépasse largement cette définition. Dans cet article, nous explorerons les différentes façons d'utiliser const en C++.

Concepts de base

const est appelé qualificateur de constance. Il limite une variable spécifique et informe le compilateur que cette variable ne peut pas être modifiée. L'utilisation systématique de const permet d'éviter des modifications accidentelles dans les fonctions.

Utilisation avec des types de données simples

Avec les types de données simples, const peut être placé avant ou après le type de données, avec le même effet.

int const a = 100; const int b = 100; // Équivalent à la ligne précédente int const tab[3] = {1, 2, 3}; const int tab2[3] = {1, 2, 3}; // Équivalent également

</details>Utilisation avec des pointeurs
------------------------------

Il existe plusieurs façons d'utiliser `const` avec des pointeurs :

<details><summary>Voir le code</summary>```

char *p = "bonjour"; // Pointeur non-const vers des données non-const
const char *q = "bonjour"; // Pointeur non-const vers des données const
char * const r = "bonjour"; // Pointeur const vers des données non-const
const char * const s = "bonjour"; // Pointeur const vers des données const

Lorsque const est placé avant l'étoile (*), il signifie que la valeur pointée est constante.

int x = 5; const int *p = &x; *p = 20; // Erreur : on ne peut pas modifier la valeur pointée int y = 20; p = &y; // Correct : on peut changer où pointe le pointeur

</details>### Constante de pointeur

Lorsque `const` est placé après l'étoile (`*`), il signifie que le pointeur lui-même est constant.

<details><summary>Voir le code</summary>```

int x = 5;
int * const p = &x;
*p = 20; // Correct : on peut modifier la valeur pointée
int y = 10;
p = &y; // Erreur : on ne peut pas changer où pointe le pointeur

#include using namespace std;

int main() { int a = 10, b = 20; int* ptr1 = &a; // Modifiable en valeur et en direction *ptr1 = 100; ptr1 = &b;

const int* ptr2 = &a; // Direction modifiable, mais pas la valeur
cout << "ptr2=" << *ptr2 << endl;

int const* ptr3 = &a; // Même comportement que ptr2
ptr3 = &b;
cout << "ptr3=" << *ptr3 << endl;

int* const ptr4 = &a; // Direction fixe, mais valeur modifiable
*ptr4 = 100;
cout << "*ptr4=" << *ptr4 << endl;

system("pause");

}

</details>Utilisation avec des paramètres de fonction
-------------------------------------------

Lorsque `const` est utilisé pour les paramètres de fonction, cela empêche la modification du paramètre dans le corps de la fonction.

### Paramètres pointeurs

L'utilisation de `const` sur un paramètre pointeur protège la mémoire pointée contre toute modification.

### Paramètres par référence

L'utilisation de `const` avec des références améliore à la fois la sécurité et l'efficacité du programme.

Utilisation avec les valeurs de retour
--------------------------------------

Appliquer `const` aux valeurs de retour empêche leur modification après leur retour.

Membres de classe constants
---------------------------

Les fonctions membres marquées comme `const` ne peuvent pas modifier les variables membres de la classe.

<details><summary>Voir le code</summary>```

class MaClasse {
public:
    void methode(int x) const;
};

Plusieurs méthodes existent pour définir des constantes dans une classe, telles que l'utilisation de enum, const ou static.

class Test { public: enum { A = 10, B = 20 }; int tableau1[A]; int tableau2[B]; };

class TestC11 { public: static const int a = 3; // Valable en C++11 static int b; const int c = 5; // Valable en C++11 int d = 6; public: TestC11() : c(0) {} };

</details>Avantages de l'utilisation de const
-----------------------------------

- Prévient les erreurs dues à des modifications accidentelles.
- Fournit des vérifications de type plus rigoureuses.
- Permet le surchargement de fonctions.
- Optimise l'utilisation de la mémoire.

Compréhension de la déclaration void WriteToFile(const string&amp; filename) const;
-----------------------------------------------------------------------------------

La première occurrence de `const` indique que le paramètre `filename` ne sera pas modifié dans la fonction. La seconde indique que la fonction elle-même ne modifie aucun membre de la classe.

<details><summary>Voir le code</summary>```

#include <iostream>
#include <fstream>
using namespace std;

class Résultat {
public:
    Résultat(int val) : résultat_val(val) {}
    void ÉcrireFichier(const string& nom_fichier) const {
        ofstream fichier(nom_fichier);
        if (fichier.is_open()) {
            fichier << "Résultat : " << résultat_val << endl;
            fichier.close();
        }
    }
    void MettreAJour(int nouvelle_valeur) {
        résultat_val = nouvelle_valeur;
    }
private:
    int résultat_val;
};

int main() {
    Résultat res(99);
    res.ÉcrireFichier("résultat.txt");
    res.MettreAJour(100);

    const Résultat const_res(88);
    const_res.ÉcrireFichier("résultat_const.txt");
    return 0;
}