Quelle est la différence entre char * const et const char *?
18 réponses
La différence est que const char *
est un pointeur vers une const char
, tandis que char * const
est un pointeur constant vers un char
.
la première, la valeur étant pointée vers ne peut pas être changée mais le pointeur peut l'être. La seconde, la valeur pointée peut changer mais pas le pointeur (semblable à une référence).
il y a aussi un
const char * const
qui est un pointeur constant vers un char constant (so rien ne peut être changé).
Note:
les deux formes suivantes sont équivalentes:
const char *
et
char const *
la raison exacte est décrite dans la norme C++, mais il est important de noter et d'éviter la confusion. Je connais plusieurs normes de codage qui préfèrent:
char const
plus de
const char
(avec ou sans pointeur) de sorte que la position de l'élément const
est la même que celle d'un pointeur const
.
pour éviter toute confusion, toujours ajouter le qualificatif const.
int * mutable_pointer_to_mutable_int;
int const * mutable_pointer_to_constant_int;
int *const constant_pointer_to_mutable_int;
int const *const constant_pointer_to_constant_int;
const
toujours modifie la chose qui vient avant (à gauche), SAUF quand c'est la première chose dans une déclaration de type, où il modifie la chose qui vient après (à droite).
donc ces deux - là sont les mêmes:
int const *i1;
const int *i2;
ils définissent des pointeurs vers un const int
. Vous pouvez changer où i1
et i2
points, mais vous ne pouvez pas changer la valeur qu'ils pointent.
Ceci:
int *const i3 = (int*) 0x12345678;
définit un pointeur const
vers un entier et l'initialise pour pointer à l'emplacement de mémoire 12345678. Vous pouvez changer la valeur int
à l'adresse 12345678, mais vous ne pouvez pas changer l'adresse à laquelle i3
pointe.
const * char
est un code C invalide et dénué de sens. Peut-être vous demander la différence entre un const char *
et un char const *
, ou, éventuellement, la différence entre un const char *
et un char * const
?
voir aussi:
const char*
est un pointeur vers une constante caractère
char* const
est un pointeur constant sur un caractère
const char* const
est un pointeur constant sur une constante caractère
1) const char* x ici X est essentiellement un pointeur de caractère qui pointe vers une valeur constante
2) char* const x se réfère au pointeur de caractère qui est constant, mais l'emplacement qu'il pointe peut être changer.
3) const char* const x est une combinaison de 1 et 2, signifie que c'est un pointeur de caractère constant qui pointe vers la valeur constante.
4) const *char x causera une erreur de compilation. il ne peut pas être déclarée.
5) char const * x est égal au point 1.
la règle de base est que si const est avec le nom de var alors le pointeur sera constant mais l'emplacement de pointage peut être changé , sinon le pointeur pointera vers un emplacement constant et le pointeur peut pointer vers un autre emplacement mais le contenu de l'emplacement de pointage ne peut pas être changé .
règle empirique: lisez la définition de droite à gauche!
const int *foo;
signifie " foo
points ( *
) à un int
qui ne peut pas changer ( const
)".
Pour le programmeur cela signifie "Je ne changerai pas la" valeur 1519410920 "de ce que foo
pointe à".
-
*foo = 123;
oufoo[0] = 123;
seraient invalides. -
foo = &bar;
est autorisé.
int *const foo;
signifie foo
ne peut pas changer ( const
) et les points ( *
) en int
".
Pour le programmeur cela signifie "Je ne changerai pas la adresse mémoire que foo
se réfère à".
-
*foo = 123;
oufoo[0] = 123;
est autorisé. -
foo = &bar;
serait invalide.
const int *const foo;
signifie foo
ne peut pas changer ( const
) et les points ( *
) en int
qui ne peut pas changer ( const
)".
Pour le programmeur cela signifie "Je ne changerai pas la" valeur 1519410920 " de ce que foo
indique, et je ne changerai pas l '" adresse 1519400920 à laquelle foo
fait référence.
-
*foo = 123;
oufoo[0] = 123;
serait invalide. -
foo = &bar;
serait invalide.
la Première est une erreur de syntaxe. Peut-être que vous vouliez dire la différence entre
const char * mychar
et
char * const mychar
Dans ce cas, le premier est un pointeur vers les données qui ne peuvent pas changer, et le second est un pointeur qui pointe toujours à la même adresse.
une autre règle empirique est de vérifier où const est :
- avant * => valeur stockée est constante
- après * => pointeur lui-même est constante
Beaucoup de réponse de fournir des techniques spécifiques, d'une règle de pouce, etc afin de comprendre cette instance particulière de la déclaration de la variable. Mais il y a une technique générique de comprendre n'importe quelle déclaration:
A)
const char *a;
selon la règle "dans le sens des aiguilles d'une montre/spirale a
est pointeur de caractère qui est constante. Ce qui signifie personnage est constante, mais le pointeur peut changer. c'est à dire a = "other string";
c'est bien, mais a[2] = 'c';
échoue à compiler
B)
char * const a;
selon la règle, a
est un pointeur de const à un caractère. i.e. vous pouvez faire a[2] = 'c';
mais vous ne pouvez pas faire a = "other string";
je suppose que vous voulez dire const char * et char * const .
le premier, const char *, est un pointeur vers un caractère constant. Le pointeur lui-même est mutable.
le second, char * const est un pointeur constant vers un personnage. Le pointeur ne peut pas changer, le caractère qu'il pointe peut.
et puis il y a const char * const où le pointeur et le caractère ne peuvent pas changer.
Voici une explication détaillée avec le code
/*const char * p;
char * const p;
const char * const p;*/ // these are the three conditions,
// const char *p;const char * const p; pointer value cannot be changed
// char * const p; pointer address cannot be changed
// const char * const p; both cannot be changed.
#include<stdio.h>
/*int main()
{
const char * p; // value cannot be changed
char z;
//*p = 'c'; // this will not work
p = &z;
printf(" %c\n",*p);
return 0;
}*/
/*int main()
{
char * const p; // address cannot be changed
char z;
*p = 'c';
//p = &z; // this will not work
printf(" %c\n",*p);
return 0;
}*/
/*int main()
{
const char * const p; // both address and value cannot be changed
char z;
*p = 'c'; // this will not work
p = &z; // this will not work
printf(" %c\n",*p);
return 0;
}*/
- pointeur Constant : un pointeur constant ne peut pointer qu'une seule variable du type de données respectif pendant toute la durée du programme.on peut changer la valeur de la variable pointée par le pointeur. L'initialisation devrait se faire au moment de la déclaration elle-même.
syntaxe:
datatype *const var;
char *const
fait partie de cette affaire.
/*program to illustrate the behaviour of constant pointer */
#include<stdio.h>
int main(){
int a=10;
int *const ptr=&a;
*ptr=100;/* we can change the value of object but we cannot point it to another variable.suppose another variable int b=20; and ptr=&b; gives you error*/
printf("%d",*ptr);
return 0;
}
- Pointeur const valeur : un pointeur peut pointer n'importe quel nombre de variables du type, mais nous ne pouvons pas changer la valeur de l'objet pointé par le pointeur à un moment donné.
syntaxe:
const datatype *var
ou datatype const *var
const char*
fait partie de cette affaire.
/* program to illustrate the behavior of pointer to a constant*/
#include<stdio.h>
int main(){
int a=10,b=20;
int const *ptr=&a;
printf("%d\n",*ptr);
/* *ptr=100 is not possible i.e we cannot change the value of the object pointed by the pointer*/
ptr=&b;
printf("%d",*ptr);
/*we can point it to another object*/
return 0;
}
char * const et const char *?
- pointant vers une valeur constante
const char * p;
// la valeur ne peut pas être changée
- pointeur Constant vers une valeur
char * const p;
// l'adresse ne peut pas être changée
- pointeur Constant à valeur constante
const char * const p;
// les deux ne peuvent être changés.
le modificateur const
est appliqué au terme immédiatement à sa gauche. La seule exception à cela est quand il n'y a rien à sa gauche, alors il s'applique à ce qui est immédiatement à sa droite.
ce sont toutes les façons équivalentes de dire "pointeur constant vers une constante char
":
-
const char * const
-
const char const *
-
char const * const
-
char const const *
deux règles
-
If const is between char and *, it will affect the left one.
-
If const is not between char and *, it will affect the nearest one.
p.ex.
-
char const *. This is a pointer points to a constant char.
-
char * const. This is a constant pointer points to a char.
je voudrais souligner que l'utilisation de int const *
(ou const int *
) n'est pas au sujet d'un pointeur pointant vers une variable const int
, mais que cette variable est const
pour ce pointeur spécifique.
par exemple:
int var = 10;
int const * _p = &var;
le code ci-dessus se compile parfaitement bien. _p
indique une variable const
, bien que var
lui-même ne soit pas constant.
// Some more complex constant variable/pointer declaration.
// Observing cases when we get error and warning would help
// understanding it better.
int main(void)
{
char ca1[10]= "aaaa"; // char array 1
char ca2[10]= "bbbb"; // char array 2
char *pca1= ca1;
char *pca2= ca2;
char const *ccs= pca1;
char * const csc= pca2;
ccs[1]='m'; // Bad - error: assignment of read-only location ‘*(ccs + 1u)’
ccs= csc; // Good
csc[1]='n'; // Good
csc= ccs; // Bad - error: assignment of read-only variable ‘csc’
char const **ccss= &ccs; // Good
char const **ccss1= &csc; // Bad - warning: initialization from incompatible pointer type
char * const *cscs= &csc; // Good
char * const *cscs1= &ccs; // Bad - warning: initialization from incompatible pointer type
char ** const cssc= &pca1; // Good
char ** const cssc1= &ccs; // Bad - warning: initialization from incompatible pointer type
char ** const cssc2= &csc; // Bad - warning: initialization discards ‘const’
// qualifier from pointer target type
*ccss[1]= 'x'; // Bad - error: assignment of read-only location ‘**(ccss + 8u)’
*ccss= ccs; // Good
*ccss= csc; // Good
ccss= ccss1; // Good
ccss= cscs; // Bad - warning: assignment from incompatible pointer type
*cscs[1]= 'y'; // Good
*cscs= ccs; // Bad - error: assignment of read-only location ‘*cscs’
*cscs= csc; // Bad - error: assignment of read-only location ‘*cscs’
cscs= cscs1; // Good
cscs= cssc; // Good
*cssc[1]= 'z'; // Good
*cssc= ccs; // Bad - warning: assignment discards ‘const’
// qualifier from pointer target type
*cssc= csc; // Good
*cssc= pca2; // Good
cssc= ccss; // Bad - error: assignment of read-only variable ‘cssc’
cssc= cscs; // Bad - error: assignment of read-only variable ‘cssc’
cssc= cssc1; // Bad - error: assignment of read-only variable ‘cssc’
}