pointeur constant vs pointeur sur une valeur constante

Quelle est la différence entre les déclarations suivantes?

char * const a; const char * a; 

Pour comprendre la différence, j’ai écrit ce petit programme:

 #include  #include  int main (int argc, char **argv) { char a = 'x'; char b = 'y'; char * const pc1 = &a; const char * pc2 = &a; printf ("Before\n"); printf ("pc1=%p\n", pc1); printf ("*pc1=%c\n", *pc1); printf ("pc2=%p\n", pc2); printf ("*pc2=%c\n", *pc2); *pc1 = b; /* pc1 = &b; */ /* *pc2 = b; */ pc2 = &b; printf ("\n\n"); printf ("After\n"); printf ("pc1=%p\n", pc1); printf ("*pc1=%c\n", *pc1); printf ("pc2=%p\n", pc2); printf ("*pc2=%c\n", *pc2); return EXIT_SUCCESS; } 

J’ai compilé le programme (avec gcc 3.4) et l’ai exécuté. La sortie met plutôt en évidence la différence:

 Before pc1=ffbfd7e7 *pc1=x pc2=ffbfd7e7 *pc2=x After pc1=ffbfd7e7 *pc1=y pc2=ffbfd7e6 *pc2=x 

Cependant, j’ai dû écrire le petit programme pour obtenir la réponse. Au cas où je serais loin de la machine (lors d’une interview par exemple), je ne serais pas en mesure de répondre à la question.

Quelqu’un peut-il s’il vous plaît expliquer, en commentant l’exemple ci-dessus, comment fonctionne le mot clé const ?

 char * const a; 

signifie que le pointeur est constant et immuable, mais que les données pointées ne le sont pas.
Vous pouvez utiliser const_cast (en C ++) ou c-style cast pour éliminer la constance dans ce cas car les données elles-mêmes ne sont pas constantes.

 const char * a; 

signifie que les données pointées ne peuvent pas être écrites en utilisant le pointeur a. L’utilisation d’un const_cast (C ++) ou d’un const_cast C pour éliminer la constance provoque dans ce cas un comportement indéfini .

Pour parsingr des types compliqués, vous commencez à la variable, allez à gauche et allez en spirale vers l’extérieur. S’il n’y a pas de tableaux ou de fonctions à prendre en compte (parce qu’ils se trouvent à droite du nom de la variable), cela devient un cas de lecture de droite à gauche.

Donc, avec char *const a; vous avez a , qui est un pointeur const ( * ) à un caractère. En d’autres termes, vous pouvez modifier le caractère sur lequel pointe un object, mais vous ne pouvez pas faire de différence.

Inversement avec const char* b; vous avez b , qui est un pointeur ( * ) à un caractère const . Vous pouvez créer un point b à n’importe quel caractère que vous aimez, mais vous ne pouvez pas modifier la valeur de ce caractère en utilisant *b = ...; .

Vous pouvez bien sûr aussi avoir les deux types de constance à la fois: const char *const c; .

 char * const a; 

*a est accessible en écriture, mais a n’est pas; En d’autres termes, vous pouvez modifier la valeur indiquée par a , mais vous ne pouvez pas modifier lui a même. a est un pointeur constant sur char .

 const char * a; 

a est accessible en écriture, mais *a n’est pas; En d’autres termes, vous pouvez modifier a (en le pointant vers un nouvel emplacement), mais vous ne pouvez pas modifier la valeur indiquée par a .

Notez que ceci est identique à

 char const * a; 

Dans ce cas, a est un pointeur sur un caractère const char .

Maintenant que vous connaissez la différence entre char * const a et const char * a . Plusieurs fois, nous sums confus si c’est un pointeur ou un pointeur constant sur une variable constante.

Comment le lire? Suivez la simple étape ci-dessous pour identifier les deux premiers.

Permet de voir comment lire ci-dessous la déclaration

 char * const a; 

Lire de droite à gauche

Maintenant, commencez par a ,

1 . adjacent à a il y a const .

char * (const a) ;

—> Alors a est une constant (????) .

2. Maintenant, allez-y, vous obtenez *

char (* (const a)) ;

—> Donc, a est un pointer constant à (????) .

3. Allez-y et il y a du char

(char (* (const a))) ;

—> a est un pointer constant à la variable character

 a is constant pointer to character variable. 

N’est-ce pas facile à lire?

De même pour la deuxième déclaration

 const char * a; 

Maintenant, recommencez avec a ,

1 . Adjacent à a il y a *

—> Donc a est un pointer vers (????)

2. Maintenant il y a du char

—> donc a character pointer ,

Eh bien ça n’a aucun sens !!! Alors mélangez le pointer et le character

—> donc a est le pointer character à (?????)

3. Maintenant vous avez constant

—> donc a est a pointer character à constant variable

Mais, bien que vous puissiez déterminer ce que signifie une déclaration, laissez-la paraître plus sensible.

 a is pointer to constant character variable 

La manière la plus simple de comprendre la différence est de penser aux différentes possibilités. Il y a deux objects à prendre en compte, le pointeur et l’object pointés (dans ce cas, ‘a’ est le nom du pointeur, l’object pointé est nommé, de type char). Les possibilités sont les suivantes:

  1. rien n’est const
  2. le pointeur est const
  3. l’object désigné est const
  4. le pointeur et l’object pointé sont const.

Ces différentes possibilités peuvent être exprimées en C comme suit:

  1. char * a;
  2. char * const a;
  3. const char * a;
  4. const char * const a;

J’espère que cela illustre les différences possibles

Le premier est un pointeur constant sur un caractère et le second est un pointeur sur un caractère constant. Vous n’avez pas touché tous les cas dans votre code:

 char * const pc1 = &a; /* You can't make pc1 point to anything else */ const char * pc2 = &a; /* You can't dereference pc2 to write. */ *pc1 = 'c' /* Legal. */ *pc2 = 'c' /* Illegal. */ pc1 = &b; /* Illegal, pc1 is a constant pointer. */ pc2 = &b; /* Legal, pc2 itself is not constant. */ 

Je vais d’abord l’expliquer verbalement et ensuite avec un exemple:

Un object pointeur peut être déclaré en tant que pointeur const ou pointeur sur un object const (ou les deux):

Un pointeur const ne peut pas être réaffecté pour pointer vers un object différent de celui auquel il est initialement affecté, mais il peut être utilisé pour modifier l’object vers lequel il pointe (appelé “pointee”).
Les variables de référence sont donc une syntaxe alternative pour les constpointers.

En revanche, un pointeur sur un object const peut être réaffecté pour pointer vers un autre object du même type ou d’un type convertible, mais il ne peut être utilisé pour modifier aucun object.

Un pointeur const vers un object const peut également être déclaré et ne peut ni être utilisé pour modifier la pointe, ni être réaffecté pour pointer vers un autre object.

Exemple:

 void Foo( int * ptr, int const * ptrToConst, int * const constPtr, int const * const constPtrToConst ) { *ptr = 0; // OK: modifies the "pointee" data ptr = 0; // OK: modifies the pointer *ptrToConst = 0; // Error! Cannot modify the "pointee" data ptrToConst = 0; // OK: modifies the pointer *constPtr = 0; // OK: modifies the "pointee" data constPtr = 0; // Error! Cannot modify the pointer *constPtrToConst = 0; // Error! Cannot modify the "pointee" data constPtrToConst = 0; // Error! Cannot modify the pointer } 

Heureux d’aider! Bonne chance!

Ci-dessus sont de bonnes réponses. Voici un moyen facile de s’en souvenir:

a est un pointeur

* a est la valeur

Maintenant, si vous dites “const a” alors le pointeur est const. (ie char * const a;)

Si vous dites “const * a” alors la valeur est const. (c’est à dire const char * a;)

Vous pouvez utiliser l’utilitaire cdecl ou ses versions en ligne, comme https://cdecl.org/

Par exemple:

void (* x)(int (*[])()); est un declare x as pointer to function (array of pointer to function returning int) returning void

Essayer de répondre de manière simple:

 char * const a; => a is (const) constant (*) pointer of type char {L < - R}. =>( Constant Pointer ) const char * a; => a is (*) pointer to char constant {L < - R}. =>( Pointer to Constant) 

Pointeur constant:

le pointeur est constant !!. Par exemple, l’adresse qu’il détient ne peut pas être modifiée. Il sera stocké dans la mémoire morte.

Essayons de changer l’adresse du pointeur pour mieux comprendre:

 char * const a = &b; char c; a = &c; // illegal , you can't change the address. `a` is const at L-value, so can't change. `a` is read-only variable. 

Cela signifie qu’une fois le pointeur constant pointe quelque chose, il est pour toujours.

pointeur a points seulement b .

Cependant, vous pouvez modifier la valeur de b par exemple:

 char b='a'; char * const a =&b; printf("\n print a : [%c]\n",*a); *a = 'c'; printf("\n now print a : [%c]\n",*a); 

Pointeur sur Constant:

La valeur pointée par le pointeur ne peut pas être modifiée.

 const char *a; char b = 'b'; const char * a =&b; char c; a=&c; //legal *a = 'c'; // illegal , *a is pointer to constant can't change!. 
 const char * a; 

Ceci indique un pointeur sur un caractère constant. Par exemple

 char b='s'; const char *a = &b; 

Ici, a point pointe vers un caractère constant (‘s’, dans ce cas). Vous ne pouvez pas utiliser a pour changer cette valeur. Mais cette déclaration ne signifie pas que la valeur vers laquelle elle pointe est vraiment une constante . est une constante en ce qui concerne Vous pouvez modifier la valeur de b directement en modifiant la valeur de b , mais vous ne pouvez pas modifier la valeur indirectement via le pointeur a.

*a='t'; //INVALID b='t' ; //VALID

 char * const a=&b 

Ceci indique un pointeur constant sur char. Cela contraint a de ne pointer que sur b mais cela vous permet de modifier la valeur de b .

J’espère que cela aide!!! 🙂