J'ai toujours gâcher la façon d'utiliser const int*, const int * constet int const *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 passer aux fonctions, etc.

Lisez-le à l'envers (comme conduit par Clockwise / Spiral Rule ):

• int* - pointeur vers int
• int const * - pointeur vers const int
• int * const - pointeur const vers int
• int const * const - pointeur const vers const int

Maintenant, le premier constpeut être de chaque côté du type:

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

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

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

Et pour nous assurer que nous comprenons clairement la signification de const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



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

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

fooest un pointeur variable vers un entier constant. Cela vous permet de modifier ce que vous pointez mais pas la valeur que vous pointez. Le plus souvent, cela se voit avec des chaînes de style C où vous avez un pointeur sur a const char. Vous pouvez modifier la chaîne vers laquelle vous pointez, mais vous ne pouvez pas modifier le contenu de ces chaînes. 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.

barest un pointeur constant ou fixe vers une valeur qui peut être modifiée. C'est comme une référence sans le sucre syntaxique supplémentaire. En raison de ce fait, vous utilisez généralement une référence où vous utilisez un T* constpointeur, sauf si vous devez autoriser les NULLpointeurs.

Pour ceux qui ne connaissent pas la règle horaire / spirale: commencez par le nom de la variable, déplacez-vous dans le sens horaire (dans ce cas, reculez) vers le pointeur ou le type suivant . Répétez jusqu'à la fin de l'expression.

Voici une démo:

Je pense que tout est déjà répondu ici, mais je veux juste ajouter que vous devez vous méfier de typedefs! Ce ne sont PAS seulement des remplacements de texte.

Par exemple:

typedef char *ASTRING;
const ASTRING astring;

Le type astringn'est char * constpas const char *. C'est une des raisons pour lesquelles j'ai toujours tendance à mettre constà droite du type, et jamais au début.

Comme à peu près tout le monde l'a souligné:

Quelle est la différence entre const X* p, X* const pet const X* const p?

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

• const X* p signifie "p pointe vers un X qui est const": l'objet X ne peut pas être modifié via p.

• X* const p signifie "p est un pointeur const vers un X qui n'est pas const": vous ne pouvez pas changer le pointeur p lui-même, mais vous pouvez changer l'objet X via p.

• const X* const p signifie "p est un pointeur const vers un X qui est const": vous ne pouvez pas changer le pointeur p lui-même, ni changer l'objet X via p.

1. Référence constante:

   Une référence à une variable (ici int), qui est constante. Nous transmettons la variable comme référence principalement, car les références sont plus petites que la valeur réelle, mais il y a un effet secondaire et c'est parce qu'elle ressemble à un alias de la variable réelle. Nous pouvons accidentellement modifier la variable principale grâce à notre accès complet à l'alias, nous le rendons donc constant 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 pointer vers aucune autre variable.

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

3. Pointeur sur constant

   Un pointeur à travers lequel on ne peut pas changer la valeur d'une variable qu'il pointe est connu comme un pointeur sur constant.

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

4. Pointeur constant vers une constante

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

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

La règle générale est que le constmot - clé s'applique à ce qui le précède immédiatement. Exception, un départ consts'applique à ce qui suit.

• const int*est le même que int const*et signifie "pointeur vers int constant" .
• const int* constest le même que int const* constet signifie "pointeur constant vers int constant" .

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

Cette question montre précisément pourquoi j'aime faire les choses comme je l'ai mentionné dans ma question est const après type id acceptable?

En bref, je trouve que le moyen le plus simple de se souvenir de la règle est que le "const" va après la chose à laquelle il s'applique. Donc, dans votre question, "int const *" signifie que l'int est constant, tandis que "int * const" signifierait que le pointeur est constant.

Si quelqu'un décide de le mettre au premier plan (par exemple: "const int *"), à titre d'exception spéciale dans ce cas, il s'applique à la chose suivante.

Beaucoup de gens aiment utiliser cette exception spéciale parce qu'ils pensent que c'est plus joli. Je n'aime pas ça, car c'est une exception, et donc confond les choses.

Utilisation simple de const .

L'utilisation la plus simple consiste à déclarer une constante nommée. Pour ce faire, on déclare une constante comme si c'était une variable mais on l'ajoute constavant. Il faut l'initialiser immédiatement dans le constructeur car, bien sûr, on ne peut pas définir la valeur plus tard car cela la modifierait. Par exemple:

const int Constant1=96; 

créera une constante entière, appelée sans imagination Constant1, avec la valeur 96.

De telles constantes sont utiles pour les paramètres qui sont utilisés dans le programme mais n'ont pas besoin d'être modifiées après la compilation du programme. Elle présente un avantage pour les programmeurs par rapport à la #definecommande du préprocesseur C dans la mesure où elle est comprise et utilisée par le compilateur lui-même, et pas seulement substituée dans le texte du programme par le préprocesseur avant d'atteindre le compilateur principal, les messages d'erreur sont donc beaucoup plus utiles.

Il fonctionne également avec des pointeurs mais il faut faire attention où constdéterminer si le pointeur ou vers quoi il pointe est constant ou les deux. Par exemple:

const int * Constant2 

déclare qu'il Constant2s'agit d'un pointeur variable vers un entier constant et:

int const * Constant2

est une syntaxe alternative qui fait de même, alors que

int * const Constant3

déclare qu'il Constant3s'agit d'un pointeur constant vers un entier variable et

int const * const Constant4

déclare que Constant4 s'agit d'un pointeur constant vers un entier constant. Fondamentalement, «const» s'applique à tout ce qui se trouve à sa gauche immédiate (sauf s'il n'y a rien dans ce cas, il s'applique à tout ce qui est à sa droite immédiate).

ref: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

J'avais le même doute que vous jusqu'à ce que je tombe sur ce livre du C ++ Guru Scott Meyers. Reportez-vous au troisième élément de ce livre où il parle en détail de l'utilisation const.

Suivez simplement ce conseil

1. Si le mot constapparaît à gauche de l'astérisque, ce qui est indiqué est constant
2. Si le mot constapparaît à droite de l'astérisque, le pointeur lui-même est constant
3. Si constapparaît des deux côtés, les deux sont constants

C'est simple mais délicat. S'il vous plaît noter que nous pouvons échanger le constqualificatif avec tout type de données ( int, char,float , etc.).

Voyons les exemples ci-dessous.

const int *p==> *pest en lecture seule [ pest un pointeur sur un entier constant]

int const *p==> *pest en lecture seule [ pest un pointeur sur un entier constant]

int *p const==> Mauvaise déclaration. Le compilateur renvoie une erreur de syntaxe.

int *const p==> pest en lecture seule [ pest un pointeur constant vers un entier]. Comme le pointeur pici est en lecture seule, la déclaration et la définition doivent être au même endroit.

const int *p const ==> Mauvaise déclaration. Le compilateur renvoie une erreur de syntaxe.

const int const *p ==> *pest en lecture seule

const int *const p1 ==> *pet psont en lecture seule [ pest un pointeur constant vers un entier constant]. Comme le pointeur pici est en lecture seule, la déclaration et la définition doivent être au même endroit.

int const *p const ==> Mauvaise déclaration. Le compilateur renvoie une erreur de syntaxe.

int const int *p ==> Mauvaise déclaration. Le compilateur renvoie une erreur de syntaxe.

int const const *p ==> *pest en lecture seule et équivaut àint const *p

int const *const p ==> *pet psont en lecture seule [ pest un pointeur constant vers un entier constant]. Comme le pointeur pici est en lecture seule, la déclaration et la définition doivent être au même endroit.

Il existe de nombreux autres points subtils entourant l'exactitude de const en C ++. Je suppose que la question ici a simplement porté sur C, mais je vais donner quelques exemples connexes puisque la balise est C ++:

• Vous passez souvent de gros arguments comme des chaînes, TYPE const &ce qui empêche la modification ou la copie de l'objet. Exemple :

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Mais TYPE & const n'a pas de sens car les références sont toujours const.

• Vous devez toujours étiqueter les méthodes de classe qui ne modifient pas la classe comme const, sinon vous ne pouvez pas appeler la méthode à partir d'une TYPE const &référence. Exemple :

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Il existe des situations courantes où la valeur de retour et la méthode doivent être const. Exemple :

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  En fait, les méthodes const ne doivent pas renvoyer les données de classe internes en tant que référence à non-const.

• Par conséquent, il faut souvent créer à la fois une méthode const et une méthode non-const en utilisant une surcharge const. Par exemple, si vous définissez T const& operator[] (unsigned i) const;, vous voudrez probablement aussi la version non-const donnée par:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik, il n'y a pas de fonctions const en C, les fonctions non membres ne peuvent pas elles-mêmes être const en C ++, les méthodes const peuvent avoir des effets secondaires et le compilateur ne peut pas utiliser les fonctions const pour éviter les appels de fonctions en double. En fait, même une simple int const &référence pourrait témoigner que la valeur à laquelle elle se réfère pourrait être modifiée ailleurs.

La syntaxe de déclaration C et C ++ a été décrite à plusieurs reprises comme une expérience ratée par les concepteurs originaux.

Au lieu de cela, nous allons nommer le « pointeur type Type»; Je l'appellerai Ptr_:

template< class Type >
using Ptr_ = Type*;

Ptr_<char>Est maintenant un pointeur vers char.

Ptr_<const char>est un pointeur vers const char.

Et const Ptr_<const char>est un constpointeur vers const char.

Là.

Pour moi, la position de constsavoir si elle apparaît à GAUCHE ou à DROITE ou à la fois à GAUCHE et à DROITE par rapport à la *m'aide à comprendre la signification réelle.

1. Un constà gauche *indique que l'objet pointé par le pointeur est un constobjet.

2. Un constà DROITE *indique que le pointeur est un constpointeur.

Le tableau suivant est extrait du lecteur de cours de laboratoire de programmation standard C ++ Stanford CS106L.

Cela concerne principalement la deuxième ligne: meilleures pratiques, affectations, paramètres de fonction, etc.

Pratique générale. Essayez de faire tout ce constque vous pouvez. Ou pour dire les choses autrement, faites tout constpour commencer, puis supprimez exactement l'ensemble minimal deconst s nécessaire pour permettre au programme de fonctionner. Ce sera une grande aide pour atteindre la const-correct, et aidera à éviter que des bogues subtils ne soient introduits lorsque les gens essaient de les affecter à des choses qu'ils ne sont pas censés modifier.

Évitez const_cast <> comme la peste. Il existe un ou deux cas d'utilisation légitimes, mais ils sont très rares. Si vous essayez de changer unconst objet, vous ferez beaucoup mieux pour trouver celui qui l'a déclaré constau premier rythme et en discuter avec eux pour parvenir à un consensus sur ce qui devrait arriver.

Ce qui mène très bien aux missions. Vous ne pouvez attribuer quelque chose que s'il n'est pas constant. Si vous souhaitez attribuer à quelque chose qui est const, voir ci-dessus. N'oubliez pas que dans les déclarations int const *foo;etint * const bar; différentes choses sont const- d'autres réponses ici ont admirablement couvert cette question, donc je ne vais pas y entrer.

Paramètres de fonction:

Passez par valeur: par exemple, void func(int param)vous ne vous souciez pas d'une manière ou d'une autre sur le site appelant. L'argument peut être avancé qu'il existe des cas d'utilisation pour déclarer la fonction commevoid func(int const param) mais cela n'a aucun effet sur l'appelant, uniquement sur la fonction elle-même, en ce que la valeur transmise ne peut pas être modifiée par la fonction pendant l'appel.

Passez par référence: par exemple void func(int &param), cela fait maintenant une différence. Comme il vient d'être déclaré, il funcest autorisé de changer param, et tout site appelant doit être prêt à faire face aux conséquences. Changer la déclaration pour void func(int const &param)changer le contrat et les garanties qui funcne peuvent plus changerparam , ce qui signifie que ce qui est transmis est ce qui en ressortira. Comme d'autres l'ont noté, cela est très utile pour passer à bon marché un grand objet que vous ne voulez pas changer. Passer une référence est beaucoup moins cher que de passer un gros objet en valeur.

Passer par pointeur: par exemple , void func(int *param)et void func(int const *param)Ces deux sont à peu près synonyme de leurs homologues de référence, avec la mise en garde que la fonction appelée doit maintenant vérifier à nullptrmoins que d'autres assure la garantie contractuelle funcqu'il ne recevra jamais nullptrdansparam .

Article d'opinion sur ce sujet. Il est extrêmement difficile de prouver l'exactitude dans un cas comme celui-ci, il est tout simplement trop facile de faire une erreur. Alors ne prenez pas de risques et vérifiez toujours les paramètres du pointeur nullptr. Vous vous épargnerez la douleur et la souffrance et vous aurez du mal à trouver des bogues à long terme. Et en ce qui concerne le coût de la vérification, c'est très bon marché, et dans les cas où l'analyse statique intégrée au compilateur peut le gérer, l'optimiseur l'élidera de toute façon. Activez Link Time Code Generation pour MSVC, ou WOPR (je pense) pour GCC, et vous obtiendrez tout le programme, c'est-à-dire même dans les appels de fonction qui traversent une limite de module de code source.

À la fin de la journée, tout ce qui précède constitue un cas très solide pour toujours préférer les références aux pointeurs. Ils sont tout simplement plus sûrs.

La constante avec l'int de chaque côté fera pointer vers la constante int :

const int *ptr=&i;

ou:

int const *ptr=&i;

constafter *fera un pointeur constant vers int :

int *const ptr=&i;

Dans ce cas, tous ces éléments sont un pointeur vers un entier constant , mais aucun d'entre eux n'est un pointeur constant:

 const int *ptr1=&i, *ptr2=&j;

Dans ce cas, tous sont pointeur sur un entier constant et ptr2 est pointeur constant sur un entier constant . Mais ptr1 n'est pas un pointeur constant:

int const *ptr1=&i, *const ptr2=&j;

• si constest à gauche de *, il fait référence à la valeur (peu importe si c'est const intou int const)
• si constest à droite de *, il fait référence au pointeur lui-même
• ça peut être les deux en même temps

Un point important: const int *p ne signifie pas que la valeur à laquelle vous faites référence est constante !! . Cela signifie que vous ne pouvez pas le modifier via ce pointeur (ce qui signifie que vous ne pouvez pas affecter $ * p = ... `). La valeur elle-même peut être modifiée par d'autres moyens. Par exemple

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

Ceci est destiné à être utilisé principalement dans les signatures de fonction, pour garantir que la fonction ne peut pas modifier accidentellement les arguments passés.

Juste par souci d'exhaustivité pour C en suivant les autres explications, pas sûr pour C ++.

• pp - pointeur vers pointeur
• p - pointeur
• données - la chose pointée, dans des exemples x
• bold - variable en lecture seule

Aiguille

• p données - int *p;
• p données -int const *p;
• p données -int * const p;
• p données -int const * const p;

Pointeur vers pointeur

1. pp p données - int **pp;
2. pp p données -int ** const pp;
3. pp p données -int * const *pp;
4. pp p données -int const **pp;
5. pp p données -int * const * const pp;
6. pp p données -int const ** const pp;
7. pp p données -int const * const *pp;
8. pp p données -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N-niveaux de déférence

Continuez, mais que l'humanité vous excommunie.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*- pointeur vers un intobjet constant .

Vous pouvez modifier la valeur du pointeur; vous ne pouvez pas modifier la valeur de l' intobjet, le pointeur pointe vers.

2. const int * const- pointeur constant vers un intobjet constant .

Vous ne pouvez pas modifier la valeur du pointeur ni la valeur de l' intobjet vers lequel pointe le pointeur.

3. int const *- pointeur vers un intobjet constant .

Cette instruction équivaut à 1. const int*- Vous pouvez modifier la valeur du pointeur mais vous ne pouvez pas modifier la valeur de l' intobjet, le pointeur pointe vers.

En fait, il y a une 4ème option:

4. int * const- pointeur constant vers l' intobjet.

Vous pouvez modifier la valeur de l'objet vers lequel pointe le pointeur, mais vous ne pouvez pas modifier la valeur du pointeur lui-même. Le pointeur pointera toujours vers le même intobjet mais cette valeur de cet intobjet peut être modifiée.

Si vous voulez déterminer un certain type de construction C ou C ++, vous pouvez utiliser la règle Clockwise / Spiral Rule faite par David Anderson; mais ne pas confondre avec la règle d'Anderson faite par Ross J. Anderson, qui est quelque chose de tout à fait distinct.