Cuál es la diferencia entre:

char * const 

y

const char *

La diferencia es que const char *es un puntero a a const char, mientras que char * constes un puntero constante a a char.

El primero, el valor al que se apunta no se puede cambiar, pero se puede cambiar el puntero. El segundo, el valor que se apunta puede cambiar pero el puntero no puede (similar a una referencia).

También hay una

const char * const

que es un puntero constante a un carácter constante (por lo que no se puede cambiar nada al respecto).

Nota:

Las siguientes dos formas son equivalentes:

const char *

y

char const *

La razón exacta de esto se describe en el estándar C ++, pero es importante tener en cuenta y evitar la confusión. Conozco varios estándares de codificación que prefieren:

char const

encima

const char

(con o sin puntero) para que la ubicación del constelemento sea la misma que con un puntero const.

Para evitar confusiones, siempre agregue el calificador 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 siempre modifica lo que viene antes (a la izquierda), EXCEPTO cuando es lo primero en una declaración de tipo, donde modifica lo que viene después (a la derecha).

Entonces estos dos son iguales:

int const *i1;
const int *i2;

definen punteros a a const int. Puede cambiar dónde i1y i2puntos, pero no puede cambiar el valor al que apuntan.

Esta:

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

define un constpuntero a un entero y lo inicializa para apuntar a la ubicación de memoria 12345678. Puede cambiar el intvalor en la dirección 12345678, pero no puede cambiar la dirección a la que i3apunta.

const * chares un código C no válido y no tiene sentido. ¿Quizás quiso preguntar la diferencia entre a const char *y a char const *, o posiblemente la diferencia entre a const char *y a char * const?

Ver también:

• ¿Qué son los punteros constantes (en oposición a los punteros a objetos constantes)?
• Const en C
• Diferencia entre declaraciones constantes en C ++
• Pregunta const de C ++
• ¿Por qué puedo cambiar los valores de una variable const char *?

const char*es un puntero a un caracter constante
char* constes un puntero constante a un caracter
const char* constes un puntero constante a un caracter constante

Regla de oro: ¡ lea la definición de derecha a izquierda!

const int *foo;

Significa " foopuntos ( *) a un intque no puede cambiar ( const)".
Para el programador esto significa "no cambiaré el valor de lo que fooapunta".

• *foo = 123;o foo[0] = 123;sería inválido
• foo = &bar; esta permitido.

int *const foo;

Significa " foono puede cambiar ( const) y puntos ( *) a int".
Para el programador esto significa "No cambiaré la dirección de memoria que se foorefiere".

• *foo = 123;o foo[0] = 123;está permitido.
• foo = &bar; Sería inválido.

const int *const foo;

Significa " foono puede cambiar ( const) y apunta ( *) a un intque no puede cambiar ( const)".
Para el programador esto significa "no cambiaré el valor de lo que fooapunta, ni cambiaré la dirección a la que se foorefiere".

• *foo = 123;o foo[0] = 123;sería inválido
• foo = &bar; Sería inválido.

1. const char * x Aquí X es básicamente un puntero de caracteres que apunta a un valor constante

2. char * const x se refiere al puntero de caracteres que es constante, pero la ubicación a la que apunta puede cambiar.

3. const char * const x es una combinación de 1 y 2, significa que es un puntero de caracteres constante que apunta a un valor constante.

4. const * char x causará un error del compilador. No se puede declarar.

5. char const * x es igual al punto 1.

la regla general es que si const tiene el nombre var, entonces el puntero será constante pero la ubicación de apuntado se puede cambiar ; de lo contrario, el puntero apuntará a una ubicación constante y el puntero puede apuntar a otra ubicación, pero el contenido de la ubicación de apuntado no se puede cambiar .

El primero es un error de sintaxis. Tal vez quisiste decir la diferencia entre

const char * mychar

y

char * const mychar

En ese caso, el primero es un puntero a datos que no pueden cambiar, y el segundo es un puntero que siempre apuntará a la misma dirección.

Otra regla general es verificar dónde está const :

1. antes de * => el valor almacenado es constante
2. después de * => el puntero en sí mismo es constante

Muchas respuestas proporcionan técnicas específicas, reglas generales, etc. para comprender esta instancia particular de declaración de variables. Pero hay una técnica genérica para entender cualquier declaración:

En sentido horario / regla espiral

UNA)

const char *a;

Según la regla en sentido horario / espiral, el apuntero al carácter es constante. Lo que significa que el carácter es constante pero el puntero puede cambiar. a = "other string";es decir, está bien pero a[2] = 'c';no se compilará

SI)

char * const a;

Según la regla, aes un puntero constante a un personaje. es decir, puedes hacer a[2] = 'c';pero no puedes hacera = "other string";

Supongo que te refieres a const char * y char * const.

El primero, const char *, es un puntero a un carácter constante. El puntero en sí mismo es mutable.

El segundo, char * const es un puntero constante a un personaje. El puntero no puede cambiar, el personaje al que apunta puede.

Y luego está const char * const donde el puntero y el carácter no pueden cambiar.

Aquí hay una explicación detallada con código

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

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

1. Puntero constante : un puntero constante puede apuntar solo a una sola variable del tipo de datos respectivo durante todo el programa. Podemos cambiar el valor de la variable apuntada por el puntero. La inicialización debe hacerse durante el tiempo de la declaración misma.

Sintaxis:

datatype *const var;

char *const viene bajo este caso.

/*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. Puntero a un valor constante : en este, un puntero puede apuntar cualquier número de variables del tipo respectivo, pero no podemos cambiar el valor del objeto señalado por el puntero en ese momento específico.

Sintaxis:

const datatype *varo datatype const *var

const char* viene bajo este caso.

/* 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 y const char *?

1. Apuntando a un valor constante

const char * p; // el valor no se puede cambiar

2. Puntero constante a un valor

char * const p; // la dirección no se puede cambiar

3. Puntero constante a un valor constante

const char * const p; // ambos no se pueden cambiar.

El constmodificador se aplica al término inmediatamente a su izquierda. La única excepción a esto es cuando no hay nada a su izquierda, entonces se aplica a lo que está inmediatamente a su derecha.

Estas son todas formas equivalentes de decir "puntero constante a una constante char":

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

Dos reglas

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

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

Me gustaría señalar que usar int const *(o const int *) no se trata de un puntero que apunta a una const intvariable, sino que esta variable es constpara este puntero específico.

Por ejemplo:

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

El código anterior se compila perfectamente bien. _papunta a una constvariable, aunque en varsí misma no es constante.

Recuerdo del libro checo sobre C: lea la declaración de que comienza con la variable y vaya a la izquierda. Entonces para

char * const a;

puede leer como: " aes una variable de tipo puntero constante a char",

char const * a;

puede leer como: " aes un puntero a una variable constante de tipo char. Espero que esto ayude.

Prima:

const char * const a;

Leerá como aes un puntero constante a una variable constante de tipo char.