`const` (C++)

2024-07-15

Lorsqu’il modifie une déclaration de données, le mot clé const spécifie que l’objet ou la variable n’est pas modifiable.

Syntaxe

declarator:
ptr-declarator
noptr-declarator parameters-and-qualifiers trailing-return-type
ptr-declarator:
noptr-declarator
ptr-operator ptr-declarator
noptr-declarator:
declarator-id attribute-specifier-seq_opt
noptr-declarator parameters-and-qualifiers
noptr-declarator [ constant-expression_opt ] attribute-specifier-seq_opt
( ptr-declarator )
parameters-and-qualifiers:
( parameter-declaration-clause ) cv-qualifier-seq_opt
ref-qualifier_opt noexcept-specifier_opt attribute-specifier-seq_opt
trailing-return-type:
-> type-id
ptr-operator:
* attribute-specifier-seq_opt cv-qualifier-seq_opt
& attribute-specifier-seq_opt
&& attribute-specifier-seq_opt
nested-name-specifier * attribute-specifier-seq_opt cv-qualifier-seq_opt
cv-qualifier-seq:
cv-qualifier cv-qualifier-seq_opt
cv-qualifier:
const
volatile
ref-qualifier:
&
&&
declarator-id:
..._opt id-expression

`const` valeurs

Le mot clé const indique que la valeur d'une variable est constante et fait en sorte que compilateur empêche le programmeur de la modifier.

// constant_values1.cpp
int main() {
   const int i = 5;
   i = 10;   // C3892
   i++;   // C2105
}

En C++, vous pouvez utiliser le mot clé const au lieu de la directive de préprocesseur #define pour définir des valeurs constantes. Les valeurs définies avec const sont soumises à la vérification du type et peuvent être utilisées à la place des expressions constantes. En C++, vous pouvez spécifier la taille d'un tableau avec une variable const comme suit :

// constant_values2.cpp
// compile with: /c
const int maxarray = 255;
char store_char[maxarray];  // allowed in C++; not allowed in C

En C, les valeurs de constante utilisent par défaut la liaison externe. Elles ne peuvent donc apparaître que dans des fichiers sources. En C++, les valeurs de constante utilisent par défaut la liaison interne, ce qui leur permet d'apparaître dans les fichiers d'en-tête.

Le mot clé const peut également être utilisé dans les déclarations de pointeur.

// constant_values3.cpp
int main() {
   char this_char{'a'}, that_char{'b'};
   char *mybuf = &this_char, *yourbuf = &that_char;
   char *const aptr = mybuf;
   *aptr = 'c';   // OK
   aptr = yourbuf;   // C3892
}

Un pointeur vers une variable déclarée comme const peut être assigné uniquement à un pointeur qui est également déclaré comme const.

// constant_values4.cpp
#include <stdio.h>
int main() {
   const char *mybuf = "test";
   char *yourbuf = "test2";
   printf_s("%s\n", mybuf);

   const char *bptr = mybuf;   // Pointer to constant data
   printf_s("%s\n", bptr);

   // *bptr = 'a';   // Error
}

Vous pouvez utiliser des pointeurs vers des données constantes comme paramètres de fonction pour empêcher la fonction de modifier un paramètre passé par l'intermédiaire d'un pointeur.

Pour les objets déclarés comme const, vous ne pouvez appeler que des fonctions membres de constantes. Ce compilateur garantit que l'objet constant n'est jamais modifié.

birthday.getMonth();    // Okay
birthday.setMonth( 4 ); // Error

Vous pouvez appeler des fonctions membres de constante ou non-constante pour un objet non-constant. Vous pouvez aussi surcharger une fonction membre avec le mot clé const ; cela permet d'appeler une version différente de la fonction pour les objets constants et non constants.

Vous ne pouvez pas déclarer de constructeurs ou de destructeurs avec le mot clé const.

Fonctions membres `const`

La déclaration d'une fonction membre avec le mot clé const indique que la fonction est une fonction « Lecture seule » qui ne modifie pas l'objet pour lequel elle est appelée. Une fonction membre constante ne peut pas modifier les données membres non static ou appeler des fonctions membres qui ne sont pas constantes. Pour déclarer une fonction membre constante, placez le mot clé const après la parenthèse fermante de la liste d'arguments. Le mot clé const est requis dans la déclaration et la définition.

// constant_member_function.cpp
class Date
{
public:
   Date( int mn, int dy, int yr );
   int getMonth() const;     // A read-only function
   void setMonth( int mn );   // A write function; can't be const
private:
   int month;
};

int Date::getMonth() const
{
   return month;        // Doesn't modify anything
}
void Date::setMonth( int mn )
{
   month = mn;          // Modifies data member
}
int main()
{
   Date MyDate( 7, 4, 1998 );
   const Date BirthDate( 1, 18, 1953 );
   MyDate.setMonth( 4 );    // Okay
   BirthDate.getMonth();    // Okay
   BirthDate.setMonth( 4 ); // C2662 Error
}

Différences de `const` C et C++

Lorsque vous définissez une variable const dans un fichier de code source C, vous procédez comme suit :

const int i = 2;

Vous pouvez ensuite utiliser cette variable dans un autre module comme suit :

extern const int i;

En revanche, pour obtenir le même comportement en C++, vous devez définir votre variable const comme suit :

extern const int i = 2;

De manière similaire à C, vous pouvez ensuite utiliser cette variable dans un autre module comme suit :

extern const int i;

Si vous souhaitez définir une variable extern dans un fichier de code source C++ pour l'utiliser dans un fichier de code source C, utilisez :

extern "C" const int x=10;

pour empêcher que le compilateur C++ altère les noms.

Notes

En suivant la liste des paramètres d'une fonction membre, le mot clé const indique que la fonction ne modifie pas l'objet pour lequel elle est appelée.

Pour plus d’informations sur const, consultez les articles suivants :

Voir aussi

Mots clés

Partager via

const (C++)

Syntaxe

const valeurs

Fonctions membres const

Différences de const C et C++