usar - ¿Cuál es la diferencia entre char*const y const char*?

punteros a cadenas

Question

Cuál es la diferencia entre:

char * const 

y

const char *

Answer 1

1. Puntero constante : un puntero constante puede apuntar solo a una única 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 momento de la declaración.

Sintaxis:

datatype *const var;

char *const viene en 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 punto, un puntero puede apuntar a cualquier número de variables del tipo respectivo, pero no podemos cambiar el valor del objeto apuntado por el puntero en ese momento específico.

Sintaxis:

const datatype *var o datatype const *var

const char* viene en 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;
    }

Answer 2

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

2) char * const x se refiere al puntero de carácter que es constante, pero la ubicación a la que apunta puede cambiarse.

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

4) const * char x causará un error de compilación. No puede ser declarado.

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

la regla de oro es si const es con el nombre var, entonces el puntero será constante, pero la ubicación señaladora 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 señalada no se puede cambiar .

Answer 3

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

Answer 4

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.

Answer 5

El modificador const 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 un char constante":

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

Answer 6

El primero es un error de sintaxis. Tal vez te refieres a la diferencia entre

const char * mychar

y

char * const mychar

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

Answer 7

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

El primero, el valor al que se apunta no se puede cambiar, pero el puntero puede ser. El segundo, el valor al 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 de C ++, pero es importante tener en cuenta y evitar la confusión. Conozco varios estándares de codificación que prefieren:

char const

terminado

const char

(con o sin puntero) para que la colocación del elemento const sea ​​la misma que para un const .

Answer 8

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

Por ejemplo:

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

El código anterior compila perfectamente bien. _p apunta a una variable const , aunque var sí no es constante.

Answer 9

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

Regla de las agujas del reloj / espiral

UNA)

const char *a;

De acuerdo con la regla de las agujas del reloj / espiral a es a puntero al carácter que es constante. Lo que significa que el carácter es constante pero el puntero puede cambiar. es decir, a = "other string"; está bien pero a[2] = ''c''; fallará en compilar

SEGUNDO)

char * const a;

Según la regla, a es a puntero constante a un carácter. Es decir, puedes hacer a[2] = ''c''; pero no puedes hacer a = "other string";

Answer 10

Otra regla del pulgar es verificar donde const es :

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

Answer 11

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;

Answer 12

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í es mutable.

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

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

Answer 13

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

Ver también:

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

Answer 14

const char* es un puntero a un caracter constante
char* const es un puntero constante a un personaje
const char* const es un puntero constante a un carácter constante

Answer 15

const siempre modifica lo que viene antes (a la izquierda de él), EXCEPTO cuando es lo primero en una declaración de tipo, donde modifica lo que viene después (a la derecha).

Así que estos dos son los mismos:

int const *i1;
const int *i2;

Definen punteros a una const int . Puede cambiar los puntos de i1 e i2 , pero no puede cambiar el valor al que apuntan.

Esta:

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

define un puntero const a un entero y lo inicializa para que apunte a la ubicación de memoria 12345678. Puede cambiar el valor int en la dirección 12345678, pero no puede cambiar la dirección a la que apunta i3 .

Answer 16

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

const int *foo;

Significa "puntos foo ( * ) a un int que no puede cambiar ( const )".
Para el programador, esto significa "No cambiaré el valor de lo que foo apunta a".

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

int *const foo;

Significa que " foo no puede cambiar ( const ) y apunta ( * ) a un int ".
Para el programador, esto significa "No cambiaré la dirección de memoria a la que se refiere foo ".

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

const int *const foo;

Significa que " foo no puede cambiar ( const ) y apunta ( * ) a un int que no puede cambiar ( const )".
Para el programador, esto significa "No cambiaré el valor de lo que foo apunta, ni cambiaré la dirección a la que se refiere foo ".

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

Answer 17

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 pueden ser cambiados.

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