Dans cet article, les différentes fonctions du mot-clé const que l'on retrouve dans C++ sont discutés. Chaque fois que mot-clé const est attaché à n'importe quelle méthode(), variable, variable de pointeur , et avec l'objet d'une classe, cela empêche ce spécifique objet/méthode()/variable pour modifier la valeur de ses éléments de données.

Variables constantes:

Il existe un certain ensemble de règles pour la déclaration et l'initialisation des variables constantes :

• Le variable constante ne peut pas être laissé non initialisé au moment de l’affectation.
• On ne peut lui attribuer de valeur nulle part dans le programme.
• Une valeur explicite devait être fournie à la variable constante au moment de la déclaration de la variable constante.

Vous trouverez ci-dessous le programme C++ pour démontrer le concept ci-dessus :

// C++ program to demonstrate the // the above concept #include  using namespace std; // Driver Code int main() {  // const int x; CTE error  // x = 9; CTE error  const int y = 10;  cout << y;  return 0; }>

10>

L'erreur rencontrée pour une déclaration erronée : Si vous essayez d'initialiser la variable const sans attribuer de valeur explicite, une erreur de compilation (CTE) est générée.

touches de modification

Mot-clé Const avec variables de pointeur:

Les pointeurs peuvent être déclarés avec un mot clé const. Il existe donc trois manières possibles d'utiliser un mot-clé const avec un pointeur, qui sont les suivantes :

Quand le variable de pointeur pointe vers une valeur const :

Syntaxe:

  const data_type* var_name;>

Vous trouverez ci-dessous le programme C++ pour implémenter le concept ci-dessus :

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  int x{ 10 };  char y{ 'M' };  const int* i = &x;  const char* j = &y;  // Value of x and y can be altered,  // they are not constant variables  x = 9;  y = 'A';  // Change of constant values because,  // i and j are pointing to const-int  // & const-char type value  // *i = 6;  // *j = 7;  cout << *i << ' ' << *j; }>

9 A>

Explication: Ici, dans le cas ci-dessus, i et j sont deux variables de pointeur qui pointent vers un emplacement mémoire const int-type et char-type, mais la valeur stockée à ces emplacements correspondants peut être modifiée comme nous l'avons fait ci-dessus.

Sinon , le l'erreur suivante apparaîtra : Si nous essayons de modifier la valeur de la variable const.

table de hachage contre hashmap

Lorsque la variable de pointeur const pointe vers la valeur :

Syntaxe:

  data_type* const     var_name;>

Vous trouverez ci-dessous l'exemple pour démontrer le concept ci-dessus :

// C++ program to demonstrate the // above concept #include  using namespace std; // Driver Code int main() {  // x and z non-const var  int x = 5;  int z = 6;  // y and p non-const var  char y = 'A';  char p = 'C';  // const pointer(i) pointing  // to the var x's location  int* const i = &x;  // const pointer(j) pointing  // to the var y's location  char* const j = &y;  // The values that is stored at the memory location can  // modified even if we modify it through the pointer  // itself No CTE error  *i = 10;  *j = 'D';  // CTE because pointer variable  // is const type so the address  // pointed by the pointer variables  // can't be changed  // i = &z;  // j = &p;  cout << *i << ' and ' << *j << endl;  cout << i << ' and ' << j;  return 0; }>

10 and D 0x7ffe21db72b4 and D>

Explication: Les valeurs stockées dans les variables de pointeur correspondantes i et j sont modifiables, mais les emplacements indiqués par les variables de pointeur const où les valeurs correspondantes de x et y sont stockées ne sont pas modifiables.

Sinon, l'erreur suivante apparaîtra : Les variables de pointeur sont const et pointent vers les emplacements où x et y sont stockés si nous essayons de changer l'emplacement de l'adresse, nous serons confrontés à l'erreur.

Lorsque le pointeur const pointe vers une variable const :

Syntaxe:

  const data_type* const var_name;>

Vous trouverez ci-dessous le programme C++ pour démontrer le concept ci-dessus :

// C++ program to demonstrate // the above concept #include  using namespace std; // Driver code int main() {  int x{ 9 };  const int* const i = &x;  // *i=10;  // The above statement will give CTE  // Once Ptr(*i) value is  // assigned, later it can't  // be modified(Error)  char y{ 'A' };  const char* const j = &y;  // *j='B';  // The above statement will give CTE  // Once Ptr(*j) value is  // assigned, later it can't  // be modified(Error)  cout << *i << ' and ' << *j;  return 0; }>

9 and A>

Explication: Ici, la variable pointeur const pointe vers la variable const. Donc, vous n'êtes pas non plus autorisé à modifier la const variable de pointeur (*P) ni la valeur stockée à l'emplacement indiqué par celui-ci variable de pointeur (*P).

Sinon, l'erreur suivante apparaîtra : Ici, la variable de pointeur et les emplacements pointés par la variable de pointeur sont constants, donc si l'un d'entre eux est modifié, l'erreur suivante apparaîtra :

mot-clé volatile java

Passer la valeur de l'argument const à un paramètre non const d'une fonction provoque une erreur : Passer la valeur de l'argument const à un paramètre non const d'une fonction n'est pas valide, cela vous donne une erreur de compilation.

Vous trouverez ci-dessous le programme C++ pour démontrer le concept ci-dessus :

// C++ program to demonstrate // the above concept #include  using namespace std; int foo(int* y) { return *y; } // Driver code int main() {  int z = 8;  const int* x = &z;  cout << foo(x);  return 0; }>

Sortir: L'erreur de compilation qui apparaîtra comme si la valeur const était transmise à tout argument non const de la fonction, alors l'erreur de compilation suivante apparaîtra :

De plus, le passage du pointeur const n'entraînera aucune erreur car un autre pointeur est créé qui pointe également vers le même emplacement mémoire.

//C++ program to demonstrate the above concept #include  using namespace std; void printfunc(int* ptr) {  cout << 'Value :' << *ptr << endl;  cout << 'Address of ptr :' << &ptr << endl; } //Driver Code int main() {  int x = 10;  int* const i = &x;  printfunc(i);  cout << 'Address of i :' << &i << endl; }>

Value :10 Address of ptr :0x7ffff0189b48 Address of i :0x7ffff0189b70>

Le code est exécuté sans erreur et les deux pointeurs ont des adresses différentes.

En résumé, la discussion ci-dessus peut être conclue comme suit :

1. valeur int = 5 ; // valeur non constante

2. const int *ptr_1 = &valeur; // ptr_1 pointe vers une valeur const int, c'est donc un pointeur vers une valeur const.

3. int *const ptr_2 = &valeur; // ptr_2 pointe vers un int, c'est donc un pointeur const vers une valeur non const.

4. const int *const ptr_3 = &value; // ptr_3 pointe vers une valeur const int, c'est donc un pointeur const vers une valeur const.

Méthodes constantes:

Comme les fonctions membres et les arguments de fonctions membres, les objets d'une classe peuvent également être déclarés comme const . Un objet déclaré comme const ne peut pas être modifié et ne peut donc invoquer que les fonctions membres const car ces fonctions garantissent de ne pas modifier l'objet.

Syntaxe:

États-Unis combien de villes

const Class_Name Object_name;>

• Lorsqu'une fonction est déclarée comme const, elle peut être appelée sur n'importe quel type d'objet, objet const ainsi que des objets non const.
• Chaque fois qu'un objet est déclaré comme const, il doit être initialisé au moment de la déclaration. Cependant, l'initialisation de l'objet lors de la déclaration n'est possible qu'à l'aide de constructeurs.

Il existe deux manières de procéder fonction constante déclaration:

Déclaration de fonction const ordinaire :

  const void foo()    {     //void foo() const Not valid    }          int main()    {     foo();    }>

Une fonction membre const de la classe :

  class    {     void foo() const     {     //.....     }    }>

Ci-dessous l'exemple d'une fonction constante :

// C++ program to demonstrate the // constant function #include  using namespace std; // Class Test class Test {  int value; public:  // Constructor  Test(int v = 0) { value = v; }  // We get compiler error if we  // add a line like 'value = 100;'  // in this function.  int getValue() const { return value; }  // a nonconst function trying to modify value  void setValue(int val) { value = val; } }; // Driver Code int main() {  // Object of the class T  Test t(20);  // non-const object invoking const function, no error  cout << t.getValue() << endl;  // const object  const Test t_const(10);  // const object invoking const function, no error  cout << t_const.getValue() << endl;  // const object invoking non-const function, CTE  // t_const.setValue(15);  // non-const object invoking non-const function, no  // error  t.setValue(12);  cout << t.getValue() << endl;  return 0; }>

20 10 12>

L'erreur suivante apparaîtra si vous essayez d'appeler la fonction non-const à partir d'un objet const

Paramètres de fonction constante et type de retour :

Un paramètre function() et Le type de retour de function() peut être déclaré comme constant. Les valeurs constantes ne peuvent pas être modifiées car une telle tentative générerait une erreur de compilation.

Vous trouverez ci-dessous le programme C++ pour implémenter l'approche ci-dessus :

// C++ program to demonstrate the // above approach #include  using namespace std; // Function foo() with variable // const int void foo(const int y) {  // y = 6; const value  // can't be change  cout << y; } // Function foo() with variable int void foo1(int y) {  // Non-const value can be change  y = 5;  cout << '
' << y; } // Driver Code int main() {  int x = 9;  const int z = 10;  foo(z);  foo1(x);  return 0; }>

10 5>

Explication: L'erreur suivante s'affichera si l'instruction y = 6 est utilisée dans la fonction foo() :

• // y = 6 ; une valeur const ne peut pas être changée ou modifiée.

Java convertit le caractère en chaîne

Pour le type de retour const : Le type de retour de la fonction() est const et elle nous renvoie donc une valeur entière const. Vous trouverez ci-dessous le programme C++ pour implémenter l'approche ci-dessus :

// C++ program for the above approach #include  using namespace std; const int foo(int y) {  y--;  return y; } int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

8 9>

La valeur renvoyée sera une valeur constante.

De plus, il n'y a aucun problème substantiel pour transmettre une variable const ou non const à la fonction tant que nous la transmettons par valeur car une nouvelle copie est créée. Le problème se pose lorsque l'on essaie de passer la variable constante par référence à la fonction dont le paramètre est non constant. Cela ne tient pas compte du qualificatif const, ce qui conduit à l'erreur suivante :

Pour le type de retour const et le paramètre const : Ici, le type de retour et le paramètre de la fonction sont de type const. Vous trouverez ci-dessous le programme C++ pour implémenter l'approche ci-dessus :

// C++ program for the above approach #include  using namespace std; const int foo(const int y) {  // y = 9; it'll give CTE error as  // y is const var its value can't  // be change  return y; } // Driver code int main() {  int x = 9;  const int z = 10;  cout << foo(x) << '
' << foo(z);  return 0; }>

9 10>

Explication: Ici, les valeurs const et non const peuvent être transmises en tant que paramètre const à la fonction, mais nous ne sommes pas autorisés à modifier ensuite la valeur d'une variable transmise car le paramètre est const. Sinon, nous serons confrontés à l’erreur ci-dessous :

// y=9 ; cela donnera l'erreur de compilation car y est const var, sa valeur ne peut pas être modifiée.