Différence entre Const Int et Int Const en C++

1. Différence entre const int et int const en C++
2. Mot-clé const C++
3. const int et int const avec variables
4. const int et int const avec des pointeurs
5. Utiliser int * const en C++
6. Utiliser const int * en C++
7. Conclusion

Les questions les plus appréciées et les plus délicates de tout langage de programmation sont celles où de petits changements font une grande différence dans la façon dont le programme fonctionnera et la sortie qu’il donnera.

Dans cet article, nous verrons si const int est identique à int const en C++ ou non.

Différence entre const int et int const en C++

Code:

int const a = 1000;
const int a = 1000;

Voici deux lignes de code qui se ressemblent presque. Maintenant, ces deux lignes de code sont-elles identiques ?

Avant de répondre à cette question, revenons sur les bases du mot-clé const de C++.

Mot-clé const C++

Le mot-clé const de C++ permet de garder certaines choses constantes. Cela signifie que si vous mettez le mot-clé const avant toute variable, pointeur ou méthode, la valeur des éléments de données de ces variables, pointeurs et méthodes ne peut pas être modifiée pendant l’exécution du programme.

Supposons que nous essayons de changer la valeur de n’importe quelle variable, pointeur ou méthode qui est initialisée avec un mot-clé const, ce qui nous donne une erreur.

Code:

#include <iostream>
using namespace std;

int main() {
  const int demo = 1;  // constant variable
  cout << demo;
  demo = 2  // changing the value of constant variable
         cout
         << demo;
  return 0;
}

Production:

In function 'int main()': error: assignment of read-only variable 'demo'
    9 |     demo = 2
    |     ~~~~~^~~

Dans l’exemple ci-dessus, nous déclarons une variable const demo et lui attribuons la valeur 1. Ensuite, nous attribuons une valeur différente, 2, à la même variable constante.

Cela entraîne une erreur, comme vous pouvez le voir dans la sortie.

Code:

#include <iostream>
using namespace std;

int main() {
  int demo = 1;
  cout << "The initial value is: " << demo << endl;

  // changing the value of the variable
  demo = 2;

  cout << "The changed value is: " << demo << endl;
  return 0;
}

Production:

The initial value is: 1
The changed value is: 2

Cette fois-ci, nous n’initialisons pas la variable demo avec le mot-clé const. Par conséquent, nous pouvons modifier la valeur de cette variable sans aucune erreur.

C’est essentiellement ainsi que fonctionne le mot-clé const. Reportez-vous à ce lien pour en savoir plus sur le mot-clé const.

Revenons à la question à laquelle nous devions répondre.

const int et int const avec variables

La manière standard d’attacher const à une variable en C++ est de placer ce mot-clé avant le type de données de la variable. Cependant, si nous le plaçons avant la variable elle-même, il sert le même objectif et fonctionne de manière similaire.

Cela signifie que les lignes de code suivantes sont équivalentes et correctes.

const int demo = 1000;

int const demo = 1000;

Lorsque vous lisez de telles déclarations, l’astuce consiste à aller de droite à gauche. Par conséquent, la première ligne de code serait lue comme - demo est un entier constant.

Alors que la deuxième ligne est lue comme - demo est un entier constant. Sans aucun doute, pour dire que ces deux déclarations signifient la même chose.

Nous pouvons le vérifier à travers un exemple concret. Dans cet exemple suivant, nous plaçons le mot-clé const avant le type de données, c’est-à-dire int, puis imprimons la variable demo.

Code:

#include <iostream>
using namespace std;

int main() {
  const int demo = 1000;  // const keyword before the data type
  cout << demo;
}

Production:

1000

Essayons la même chose avec le mot-clé const placé avant la variable demo elle-même.

#include <iostream>
using namespace std;

int main() {
  int const demo = 1000;  // const keyword before the variable itself
  cout << demo;
}

Production:

1000

Voyez comment ces instructions fonctionnent de la même manière sans entraîner aucune sorte d’erreur. Nous pouvons utiliser l’une ou l’autre de ces instructions lorsque nous devons déclarer une variable constante.

Ainsi, nous pouvons conclure que int const est identique à const int, mais il y a un hic. Cela est vrai pour les variables jusqu’à ce que les pointeurs n’entrent pas.

Pour les pointeurs, la signification du mot clé const change selon sa position. Voyons comment le mot-clé const fonctionne avec les pointeurs.

const int et int const avec des pointeurs

Utiliser le mot clé const avec des pointeurs est très simple. Soit nous pouvons rendre le pointeur immuable, soit le contenu pointant vers immuable.

Regardez la ligne de code ci-dessous. Le pointeur demo est un pointeur constant dont la valeur ne peut pas être modifiée.

Cela signifie qu’il ne peut pas être modifié pour pointer vers une autre valeur ou variable. Nous lisons ceci de droite à gauche car - demo est un pointeur constant vers un entier.

int* const demo = &anyvalue;

Cependant, dans ce deuxième morceau de code donné ci-dessous, les données vers lesquelles pointe le pointeur demo ne peuvent pas être modifiées. Nous lisons ceci comme - demo est un pointeur vers un entier qui est constant.

const int *demo = &anyvalue;

Comprenons ces deux lignes de code avec des exemples.

Utiliser int * const en C++

Comme mentionné ci-dessus, placer le mot-clé const avant la variable de pointeur signifie que nous ne pouvons pas changer le pointeur pour pointer vers une valeur ou une variable différente. Cela peut être vu plus profondément à travers un exemple.

Les points suivants résument ce qui se passe dans le code ci-dessous.

1. Ici, nous attribuons d’abord la valeur de la variable one à la variable pointeur *demo. Cela signifie que le pointeur *demo pointe sur la variable one.
2. En imprimant la valeur de la variable one, nous obtenons la sortie comme 1, tandis qu’en imprimant démo, nous obtenons l’adresse vers laquelle elle pointe. C’est l’adresse de la variable one.
3. Plus tard, nous attribuons une autre variable, two, à la même variable de pointeur, demo et imprimons les valeurs. Cette fois, le pointeur renvoie une adresse différente.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  int two = 2;
  int *demo = &one;  // demo pointer points to variable one

  cout << one << endl;
  cout << demo << endl;

  demo = &two;  // assigning the variable two to demo variable

  cout << two << endl;
  cout << demo << endl;

  return 0;
}

Production:

1
0x7ffc22e802a8
2
0x7ffc22e802ac

Vous pouvez voir comment nous pouvons affecter différentes variables à la même variable de pointeur. Ce changement est impossible si vous attachez le mot-clé const avant la variable de pointeur.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  int two = 2;
  int* const demo = &one;  // attach const keyword before the pointer variable

  cout << one << endl;
  cout << demo << endl;

  demo = &two;  // this assignment will now give an error

  cout << two << endl;
  cout << demo << endl;

  return 0;
}

Production:

In function 'int main()': error: assignment of read-only variable 'demo'
   13 |     demo = &two;
      |     ~~~~~^~~~~~

Notez que cette fois, puisque le pointeur déclaré est constant, nous ne pouvons pas lui affecter une autre variable. Ainsi, nous obtenons une erreur.

C’est ce que signifie int const lorsqu’il est utilisé avec un pointeur.

Utiliser const int * en C++

Nous savons déjà que nous pouvons utiliser un pointeur pour modifier la valeur d’une variable. Ceci est illustré dans l’exemple ci-dessous.

Les points suivants résument ce qui se passe dans ce code.

1. Nous attribuons d’abord la valeur 1 à la variable one, et le pointeur *demo pointe sur la variable one.
2. Ensuite, on imprime les valeurs de la variable one et du pointeur *demo. Les deux donnent la sortie comme 1.
3. Plus tard, nous attribuons la valeur 2 à la variable de pointeur, *demo.
4. Enfin, nous imprimons les valeurs de la variable one et du pointeur demo, mais cette fois, ils donnent tous les deux la sortie 2.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;  // variable one holds the value 1
  int *demo = &one;

  cout << one << endl;
  cout << *demo << endl;

  *demo = 2;  // assign the value 2 to variable demo

  cout << one << endl;
  cout << *demo << endl;
}

Production:

1 1 2 2

Voyez comment la valeur de la variable change à l’aide du pointeur auquel la variable a été affectée. Maintenant, si vous utilisez le mot-clé const avant le type de données du pointeur, ce type de mutabilité ne sera pas possible.

Code:

#include <iostream>
using namespace std;

int main() {
  int one = 1;
  const int *demo = &one;  // attach const keyword before data type

  cout << one << endl;
  cout << *demo << endl;

  *demo = 2;  // this assignment will give an error now

  cout << one << endl;
  cout << *demo << endl;
}

Production:

In function 'int main()': error: assignment of read-only location '* demo'
   12 |     *demo = 2;
      |     ~~~~~~^~~

Notez que nous obtenons une erreur si nous essayons de changer la valeur de la variable vers laquelle pointe le pointeur. C’est ce que signifie const int lorsqu’il est utilisé avec un pointeur.

Conclusion

Dans cet article, nous avons appris en quoi const int et int const sont différents l’un de l’autre. De plus, nous avons vu comment ils fonctionnent dans le contexte des variables et des pointeurs.

Nous avons également appris que ces deux formats signifient la même chose pour les variables simples, mais que la signification des pointeurs change de manière significative. Nous l’avons compris à travers divers exemples de travail et avons également passé en revue les bases du mot-clé const de C++.