quelle est la différence entre const int*, const int * const, int const *

Question

Je ne sais jamais comment l'utiliser correctement. Existe-t-il un ensemble de règles définissant ce que vous pouvez et ne pouvez pas faire ?

Je veux connaître toutes les choses à faire et à ne pas faire en termes d'affectations, de passage aux fonctions, etc.

Answer 1

Lisez-le à l'envers...

• int* - pointeur vers int
• int const * - pointeur vers const int
• int * const - pointeur constant sur int
• int const * const - pointeur constant sur const int

Maintenant le premier const peut être de chaque côté du type donc :

• const int * == int const *
• const int * const == int const * const

Si vous voulez être vraiment fou, vous pouvez faire des choses comme ça :

• int ** - pointeur vers pointeur vers int
• int ** const - un pointeur constant sur un pointeur sur un int
• int * const * - un pointeur sur un pointeur constant sur un int
• int const ** - un pointeur sur un pointeur sur un const int
• int * const * const - un pointeur const. sur un pointeur const. sur un int.
• ...

Et pour s'assurer que nous sommes clairs sur la signification de const

const int* foo;
int *const bar; //note, you actually need to set the pointer 
                //here because you can't change it later ;)

foo est un pointeur de variable vers une constante int. C'est-à-dire que vous changez ce que vous pointez mais pas la valeur que vous pointez. Le plus souvent, cela se produit avec les chaînes de caractères où l'on a un pointeur sur un fichier const char . Vous pouvez changer la chaîne vers laquelle vous pointez mais vous ne pouvez pas changer le contenu de la chaîne. Ceci est important lorsque la chaîne elle-même se trouve dans le segment de données d'un programme et ne doit pas être modifiée.

bar est un pointeur constant ou fixe vers une valeur qui peut être modifiée. C'est comme une référence, mais sans le sucre syntaxique supplémentaire. Pour cette raison, vous utilisez généralement une référence là où vous utiliseriez une balise T* const sauf si vous devez autoriser les pointeurs nuls.

Answer 2

Je pense que tout est déjà répondu ici, mais je veux juste ajouter que vous devriez vous méfier des typedefs ! Ils ne sont pas seulement des remplacements de texte. Par exemple :

typedef char *ASTRING;
const ASTRING astring;

Le type de astring est char * const pas const char * . C'est l'une des raisons pour lesquelles j'ai toujours tendance à mettre la constante à droite du type, et jamais au début.

Answer 3

Comme presque tout le monde l'a souligné :

[18.5] Quelle est la différence entre "const Fred* p", "Fred* const p" et "const Fred* const p" ?](http://www.parashift.com/c++-faq-lite/const-correctness.html#faq-18.5)

Vous devez lire les déclarations de pointeurs de droite à gauche.

• const Fred* p signifie "p pointe vers un Fred qui est const" - c'est-à-dire que l'objet Fred ne peut pas être modifié par p. l'objet Fred ne peut pas être modifié par p.
• Fred* const p signifie "p est un pointeur constant vers un Fred" - c'est-à-dire que vous pouvez changer l'objet Fred via p, mais vous ne mais vous ne pouvez pas changer le pointeur p lui-même.
• const Fred* const p signifie "p est un pointeur constant vers un const Fred" - c'est-à-dire que c'est-à-dire que vous ne pouvez pas changer le pointeur p lui-même, et vous ne pouvez pas non plus modifier l'objet Fred via p.

Answer 4

1. Référence constante :

   Une référence à une variable (ici int), qui est constante. Nous passons la variable en tant que référence principalement parce que la référence est plus petite en taille que la valeur réelle, mais il y a un effet secondaire et c'est parce que c'est comme un alias de la variable réelle que nous pouvons accidentellement changer la variable principale par notre accès complet à l'alias, donc nous la rendons constante pour éviter cet effet secondaire.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK

2. Pointeurs constants

   Une fois qu'un pointeur constant pointe vers une variable, il ne peut plus pointer vers aucune autre variable.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error

3. Pointeur sur la constante

   Un pointeur par lequel on ne peut pas changer la valeur de la variable qu'il pointe est connu comme un pointeur sur une constante.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error

4. Constant Pointeur vers une constante

   Un pointeur constant vers une constante est un pointeur qui ne peut ni changer l'adresse vers laquelle il pointe, ni changer la valeur conservée à cette adresse.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error

Answer 5

La règle est que les "const" s'appliquent à ce qui les précède immédiatement. Exception, une const de départ s'applique à ce qui la suit.

• const int* est identique à int const* et signifie "pointeur vers un int constant".

• const int* const est identique à int const* const et signifie "pointeur constant vers int constant".

Edit : pour les choses à faire et à ne pas faire, si cette réponse n'est pas suffisant, pourriez-vous être plus précis sur ce que vous voulez ?