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

Quelle est la différence entre:

char * const 

et

const char *
231
demandé sur amiregelz 2009-05-21 02:16:22

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 .

303
répondu workmad3 2014-02-28 12:02:14

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;
86
répondu diapir 2009-05-21 00:08:42

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.

31
répondu Don McCaughey 2009-05-20 22:36:58

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:

21
répondu Adam Rosenfield 2017-05-23 12:03:09

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

13
répondu Andrew Coleson 2012-01-13 15:19:43

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é .

8
répondu AAnkit 2013-11-30 15:38:44

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; ou foo[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; ou foo[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; ou foo[0] = 123; serait invalide.
  • foo = &bar; serait invalide.
5
répondu Mr. Llama 2016-07-08 00:59:44

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.

3
répondu Javier 2009-05-20 22:21:59

une autre règle empirique est de vérifier où const est :

  1. avant * => valeur stockée est constante
  2. après * => pointeur lui-même est constante
3
répondu Aadishri 2013-01-25 09:43:17

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:

Règle En Spirale Dans Le Sens Des Aiguilles D'Une Montre

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";

2
répondu PnotNP 2017-04-14 18:01:04

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.

1
répondu Michael 2009-05-20 22:21:15

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;
}*/
1
répondu Megharaj 2013-04-12 21:49:42
  1. 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;
}
  1. 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;
    }
1
répondu Goutham Gundapu 2015-10-23 14:23:23

char * const et const char *?

  1. pointant vers une valeur constante

const char * p; // la valeur ne peut pas être changée

  1. pointeur Constant vers une valeur

char * const p; // l'adresse ne peut pas être changée

  1. pointeur Constant à valeur constante

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

1
répondu Yogeesh H T 2015-11-27 11:03:51

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 *
1
répondu galois 2016-07-21 04:31:55

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.

p.ex.

  1. char const *. This is a pointer points to a constant char.
  2. char * const. This is a constant pointer points to a char.
1
répondu Xinpei Zhai 2016-11-17 07:11:37

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.

1
répondu SteliosKts 2018-01-20 23:00:16
// 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’
}
0
répondu gopalshankar 2015-04-23 17:38:27