Quelle est la différence entre char * const et const char *?

Question

Quelle est la différence entre:

char * const 

et

const char *

Answer 1

La différence est que const char * est un pointeur sur un const char, tandis que char * const est un pointeur constant sur un char.

La première, la valeur pointée vers ne peut pas être modifiée, mais le pointeur peut l'être. La seconde, la valeur pointée sur peut changer mais le pointeur ne peut pas (semblable à une référence).

Il y a aussi

const char * const

qui est un pointeur constant sur un caractère constant (rien ne peut donc en être changé).

Remarque:

Les deux formes suivantes sont équivalentes:

const char *

et

char const *

La raison exacte de ceci 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) afin que le placement de l'élément const soit identique à celui d'un pointeur const.

Answer 2

Pour éviter toute confusion, toujours append 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;

Answer 3

const modifie toujours la chose qui la précède (à gauche de celle-ci), SAUF quand c'est la première chose dans une déclaration de type, où elle modifie la chose qui vient après (à sa droite).

Donc, ces deux sont les mêmes:

int const *i1;
const int *i2;

ils définissent des pointeurs vers un const int. Vous pouvez modifier les points i1 et i2, mais vous ne pouvez pas modifier la valeur indiquée.

Cette:

int *const i3 = (int*) 0x12345678;

définit un pointeur const sur un entier et l'initialise pour pointer sur l'emplacement de mémoire 12345678. Vous pouvez modifier la valeur int à l'adresse 12345678, mais vous ne pouvez pas modifier l'adresse indiquée par i3. à.

Answer 4

const * char est un code C invalide et n'a pas de sens. Vous vouliez peut-être demander la différence entre un const char * et un char const * ou peut-être la différence entre un const char * et un char * const?

Voir également:

• Que sont les pointeurs const (par opposition aux pointeurs d'objets const)?
• Const dans C
• Différence entre les déclarations const en C++
• question constante C++
• Pourquoi puis-je changer les valeurs d'une variable const char *?

Answer 5

const char* est un pointeur sur un caractère constant
char* const est un pointeur constant sur un caractère
const char* const est un pointeur constant sur un caractère constant

Answer 6

règle générale: lisez la définition de droite à gauche!

---

const int *foo;

Signifie "foo points (*) vers un int qui ne peut pas changer (const)".
Pour le programmeur, cela signifie "je ne changerai pas la valeur de ce que foo pointe sur".

• *foo = 123; ou foo[0] = 123; ne serait pas valide.
• foo = &bar; est autorisé.

---

int *const foo;

Signifie "foo ne peut pas changer (const) et pointe (*) sur un int".
Pour le programmeur, cela signifie "Je ne changerai pas l'adresse de mémoire à laquelle foo fait référence".

• *foo = 123; ou foo[0] = 123; est autorisé.
• foo = &bar; serait invalide.

---

const int *const foo;

Signifie "foo ne peut pas changer (const) et pointe (*) vers un int qui ne peut pas changer (const)".
Pour le programmeur, cela signifie "je ne changerai pas la valeur de ce que foo, ni le changement de adresse à laquelle foo fait référence à ".

• *foo = 123; ou foo[0] = 123; ne serait pas valide.
• foo = &bar; serait invalide.

Answer 7

1. const char * x Ici, X est fondamentalement un pointeur de caractère qui pointe vers une valeur constante

2. char * const x fait référence au pointeur de caractère qui est constant, mais l'emplacement qu'il pointe peut être modifié.

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 une valeur constante.

4. const * char x provoquera une erreur du compilateur. il ne peut pas être déclaré.

5. char const * x est égal au point 1.

la règle de base est si const est de nom var alors le pointeur sera constant mais l'emplacement de pointage peut être modifié , else le pointeur pointe 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 modifié .

Answer 8

Une autre règle consiste à vérifier où const is:

1. avant * => valeur est stocké constant
2. après * => pointeur lui-même est constant

Answer 9

Le premier 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 sur des données qui ne peuvent pas changer et le second est un pointeur qui pointe toujours vers la même adresse.

Answer 10

Beaucoup de réponses fournissent des techniques spécifiques, règles de base, etc. pour comprendre cet exemple particulier de déclaration de variable. Mais il existe une technique générique pour comprendre toute déclaration:

règle horaire/spirale

UNE)

const char *a;

Selon la règle horaire/spirale, a est un pointeur sur un caractère constant. Ce qui signifie que le caractère est constant mais que le pointeur peut changer. c'est-à-dire que a = "other string"; va bien, mais a[2] = 'c'; échouera à la compilation

B)

char * const a;

Conformément à la règle, a est un pointeur constant sur un caractère. vous pouvez faire a[2] = 'c'; mais vous ne pouvez pas faire a = "other string";

Answer 11

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;
}*/

Answer 12

1. Pointeur constant: Un pointeur constant ne peut pointer que sur une seule variable du type de données correspondant pendant tout le programme. Nous pouvons modifier la valeur de la variable pointée par le pointeur. L'initialisation doit être faite pendant la période de déclaration elle-même.

Syntaxe:

datatype *const var;

char *const entre dans ce cas.

/*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;
}

2. Pointeur sur une valeur constante: Dans ce cas, un pointeur peut désigner un nombre quelconque de variables du type respectif, mais nous ne pouvons pas modifier la valeur de l'objet pointé par le pointeur à ce moment précis.

Syntaxe:

const datatype *varou datatype const *var

const char* entre dans ce cas.

/* 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;
    }

Answer 13

J'aimerais souligner que l'utilisation de int const * (ou const int *) ne concerne pas un pointeur pointant sur une variable const int, mais que cette variable est const pour cette caractéristique aiguille.

Par exemple:

int var = 10;
int const * _p = &var;

Le code ci-dessus compile parfaitement bien. _p pointe vers une variable const, bien que var lui-même ne soit pas constant.

Answer 14

char * const et const char *?

1. Pointant sur une valeur constante

const char * p; // valeur non modifiable

2. Pointeur constant sur une valeur

char * const p; // adresse non modifiable

3. Pointeur constant sur une valeur constante

const char * const p; // les deux ne peuvent pas être modifiés.

Answer 15

Le modificateur const est appliqué au terme situé immédiatement à sa gauche. La seule exception à cela est quand il n'y a rien à sa gauche, alors cela s'applique à ce qui est immédiatement à sa droite.

Ce sont toutes des manières équivalentes de dire "pointeur constant sur une constante char":

• const char * const
• const char const *
• char const * const
• char const const *

Answer 16

Je suppose que vous voulez dire const char * et char * const.

Le premier, const char *, est un pointeur sur un caractère constant. Le pointeur lui-même est mutable.

Le second, char * const est un pointeur constant sur un caractère. Le pointeur ne peut pas changer, le caractère sur lequel il pointe peut.

Et puis il y a const char * const où le pointeur et le caractère ne peuvent pas changer.

Answer 17

Deux règles

1. If const is between char and *, it will affect the left one.
2. If const is not between char and *, it will affect the nearest one.

par exemple.

1. char const *. This is a pointer points to a constant char.
2. char * const. This is a constant pointer points to a char.

Answer 18

// 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’
}