pointeur constant vs pointeur sur une valeur constante [dupliquer]

pour analyser les types compliqués, vous commencez par la variable, allez à gauche, et spiralez vers l'extérieur. S'il n'y a pas de tableaux ou de fonctions à surveiller (parce que ceux-ci se trouvent à droite du nom de la variable) cela devient un cas de lecture de droite à gauche.

ainsi avec char *const a; vous avez a , qui est un const pointeur ( * ) à un char . En d'autres termes, vous pouvez changer le caractère que a pointe, mais vous ne pouvez pas faire a indique tout ce qui est différent.

à L'inverse avec const char* b; vous avez b , qui est un pointeur ( * ) à un char qui est const . Vous pouvez faire b point à n'importe quel char que vous aimez, mais vous ne pouvez pas changer la valeur de ce char en utilisant *b = ...; .

vous pouvez bien sûr avoir les deux saveurs de const-ness en même temps: const char *const c; .

char * const a;

*a est inscriptible, mais a ne l'est pas; en d'autres termes, vous pouvez modifier la valeur pointée sur par a , mais vous ne pouvez pas modifier a elle-même. a est un pointeur constant vers char .

const char * a; 

a est accessible en écriture, mais *a ne l'est pas; en d'autres termes, vous pouvez modifier a (pointant vers un nouvel emplacement), mais vous ne pouvez pas modifier la valeur pointée sur par a .

notez que c'est identique à

char const * a;

Dans ce cas, a est un pointeur vers un const char .

Maintenant que vous connaissez la différence entre char * const a et const char * a . Plusieurs fois nous nous trompons si c'est un pointeur constant ou pointeur vers une variable constante.

comment le lire? Suivez l'étape simple ci-dessous pour identifier entre les deux premiers.

voyons comment lire ci-dessous la déclaration

char * const a;

lire de droite à gauche

commence maintenant par a ,

1 . à côté de a il y a const .

char * (const a) ;

- - - > ainsi a est un constant (????) .

2 . Maintenant, allez le long vous obtenez *

char (* (const a)) ;

- - - > ainsi a est un constant 1519170920" à (????) .

3 . Aller le long et il y a char

(char (* (const a))) ;

---> a est une constant pointer à character variable

a is constant pointer to character variable. 

N'est-il pas facile à lire?

de la Même manière pour la deuxième déclaration

const char * a;

recommencez avec a ,

1 . À côté de a il y a *

- - - > Donc a est un pointer pour (????)

2 . Maintenant il y a char

---> donc a est pointer character ,

ça n'a aucun sens!!! So shuffle pointer et character

---> donc a est character pointer à (?????)

3 . Maintenant vous avez constant

---> donc a est character pointer à constant variable

mais même si vous pouvez comprendre ce que signifie déclaration, permet de le faire sonner plus raisonnable.

a is pointer to constant character variable

La meilleure façon de comprendre la différence est de réfléchir aux différentes possibilités. Il y a deux objets à considérer, le pointeur et l'objet pointé vers (dans ce cas 'a' est le nom du pointeur, l'objet pointé vers est sans nom, de type char). Les possibilités sont:

1. rien n'est const
2. le pointeur const
3. l'objet pointé est const
4. à la fois le pointeur et les objets pointus sont const.

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

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

j'espère que cela illustre les différences possibles

Le premier est un pointeur constant sur un char, et le second est un pointeur vers une constante char. Vous n'avez pas touché à tous les cas de 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 l'expliquer verbalement d'abord et ensuite avec un exemple:

un objet pointeur peut être déclaré comme un pointeur const ou un pointeur vers un objet const (ou les deux):

A const pointer ne peut pas être réassigné pour pointer vers un objet différent de celui qui lui est initialement assigné, mais il peut être utilisé pour modifier l'objet qu'il pointe vers (appelé le"pointé").

Référence les variables sont donc une syntaxe alternative pour les constapointers.

Un pointeur const objet , d'autre part, peuvent être réaffectées à point à un autre objet du même type ou d'un cabriolet de type, mais il ne peut pas être utilisé pour modifier n'importe quel objet.

Un const pointeur const objet peuvent également être déclarées et ne peut pas être utilisé pour modifier les pointee ni être réaffectés à point à un autre objet.

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 grandes réponses. Voici une façon facile de s'en souvenir:

est un pointeur

*a est la valeur

Maintenant, si vous dites "const" alors que le pointeur est const. (c'est à dire char * const;)

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

en Essayant 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:

est constant !!. I. e, l'adresse qu'il contient ne peut pas être changée. Il sera stocké dans la mémoire en lecture seule.

essayons de changer l'adresse de pointer pour en comprendre plus:

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.

signifie une fois que 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 vers constante:

pointée par le pointeur ne peut pas être changé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;

indique pointeur à caractère constant. Pour eg.

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

ici a indique une constante char ('s', dans ce cas).Vous ne pouvez pas utiliser a pour changer cette valeur.Mais cette Déclaration ne signifie pas que la valeur qu'elle indique est réellement une constante ,elle signifie simplement que la valeur est une constante en ce qui concerne a . Vous pouvez changer la valeur de b directement en changeant la valeur de b , mais vous ne pouvez pas changer la valeur indirectement via le pointeur a .

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

char * const a=&b

indique un pointeur constant vers char. C'contraintes a à point b cependant il vous permet de modifier la valeur de b .

Espère que cela aide!!! :)