const (C++)

  • Article

Lorsqu’elle modifie une déclaration de données, la const mot clé 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-idattribute-specifier-seqopt
 noptr-declarator parameters-and-qualifiers
 noptr-declarator[constant-expressionopt]attribute-specifier-seqopt
 ( ptr-declarator )
parameters-and-qualifiers:
 (parameter-declaration-clause)cv-qualifier-seqopt
 ref-qualifieroptnoexcept-specifieroptattribute-specifier-seqopt
trailing-return-type:
 -> type-id
ptr-operator:
 *attribute-specifier-seqoptcv-qualifier-seqopt
 &attribute-specifier-seqopt
 &&attribute-specifier-seqopt
 nested-name-specifier*attribute-specifier-seqoptcv-qualifier-seqopt
cv-qualifier-seq:
 cv-qualifiercv-qualifier-seqopt
cv-qualifier:
 const
 volatile
ref-qualifier:
 &
 &&
declarator-id:
 ...optid-expression

const valeurs

La const mot clé spécifie que la valeur d’une variable est constante et indique au compilateur d’empêcher le programmeur de le modifier.

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

En C++, vous pouvez utiliser la const mot clé au lieu de la #define directive de préprocesseur pour définir des valeurs constantes. Les valeurs définies avec const sont soumises au type case activée ing et peuvent être utilisées à la place d’expressions constantes. En C++, vous pouvez spécifier la taille d’un tableau avec une const variable 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 const mot clé 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 ne peut être affecté qu’à un pointeur qui est également déclaré en tant que 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 en tant que const, vous ne pouvez appeler que des fonctions membres constantes. Le compilateur garantit que l’objet constant n’est jamais modifié.

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

Vous pouvez appeler des fonctions membres constantes ou non constantes pour un objet non constant. Vous pouvez également surcharger une fonction membre à l’aide de la const mot clé ; cette fonctionnalité permet à une autre version de la fonction d’être appelée pour des objets constants et non constants.

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

const fonctions membres

La déclaration d’une fonction membre avec l’mot clé const spécifie que la fonction est une fonction « en lecture seule » qui ne modifie pas l’objet pour lequel elle est appelée. Une fonction membre constante ne peut pas modifier les membres de données non statiques ni appeler les fonctions membres qui ne sont pas constantes. Pour déclarer une fonction membre constante, placez la const mot clé après la parenthèse fermante de la liste d’arguments. La const mot clé est requise à la fois 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 C et C++ const

Lorsque vous définissez une const variable 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;

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

extern const int i = 2;

À l’instar de C, vous pouvez ensuite utiliser cette variable dans un autre module comme suit :

extern const int i;

Si vous souhaitez définir une extern variable dans un fichier de code source C++ à 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

Lorsque vous suivez la liste des paramètres d’une fonction membre, l’mot clé const spécifie 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