Siempre desordenar cómo utilizar const int*, const int * consty int const *correctamente. ¿Existe un conjunto de reglas que definan lo que puedes y no puedes hacer?

Quiero saber todo lo que se debe y no se debe hacer en términos de tareas, pasar a las funciones, etc.

Léalo al revés (según lo manejado en sentido horario / regla espiral ):

• int* - puntero a int
• int const * - puntero a const int
• int * const - puntero constante a int
• int const * const - puntero const a const int

Ahora el primero constpuede estar a cada lado del tipo, así que:

• const int * == int const *
• const int * const == int const * const

Si quieres volverte loco, puedes hacer cosas como esta:

• int ** - puntero a puntero a int
• int ** const - un puntero constante a un puntero a un int
• int * const * - un puntero a un puntero constante a un int
• int const ** - un puntero a un puntero a una constante int
• int * const * const - un puntero constante a un puntero constante a un int
• ...

Y para asegurarnos de que tenemos claro el significado de const:

int a = 5, b = 10, c = 15;

const int* foo;     // pointer to constant int.
foo = &a;           // assignment to where foo points to.

/* dummy statement*/
*foo = 6;           // the value of a can´t get changed through the pointer.

foo = &b;           // the pointer foo can be changed.



int *const bar = &c;  // constant pointer to int 
                      // note, you actually need to set the pointer 
                      // here because you can't change it later ;)

*bar = 16;            // the value of c can be changed through the pointer.    

/* dummy statement*/
bar = &a;             // not possible because bar is a constant pointer.           

fooes un puntero variable a un entero constante. Esto le permite cambiar lo que señala pero no el valor al que apunta. La mayoría de las veces esto se ve con cadenas de estilo C donde tiene un puntero a un const char. Puede cambiar a qué cadena apunta pero no puede cambiar el contenido de estas cadenas. Esto es importante cuando la cadena en sí está en el segmento de datos de un programa y no debe cambiarse.

bares un puntero constante o fijo a un valor que se puede cambiar. Esto es como una referencia sin el azúcar sintáctico adicional. Debido a este hecho, usualmente usaría una referencia donde usaría un T* constpuntero a menos que necesite permitir NULLpunteros.

Para aquellos que no conocen la regla de sentido horario / espiral: comience desde el nombre de la variable, muévase sabiamente (en este caso, retroceda) al siguiente puntero o tipo . Repita hasta que termine la expresión.

Aquí hay una demostración:

Creo que todo ya está respondido aquí, pero solo quiero agregar que debes tener cuidado con typedefs! NO son solo reemplazos de texto.

Por ejemplo:

typedef char *ASTRING;
const ASTRING astring;

El tipo de astringes char * const, no const char *. Esta es una razón por la que siempre tiendo a poner consta la derecha del tipo, y nunca al principio.

Como casi todo el mundo señaló:

¿Cuál es la diferencia entre const X* p, X* const py const X* const p?

Debe leer las declaraciones de puntero de derecha a izquierda.

• const X* p significa "p apunta a una X que es constante": el objeto X no se puede cambiar a través de p.

• X* const p significa "p es un puntero constante a una X que no es constante": no puede cambiar el puntero p, pero puede cambiar el objeto X a través de p.

• const X* const p significa "p es un puntero constante a una X que es constante": no puede cambiar el puntero p en sí, ni puede cambiar el objeto X a través de p.

1. Referencia constante:

   Una referencia a una variable (aquí int), que es constante. Pasamos la variable como referencia principalmente, porque las referencias son más pequeñas en tamaño que el valor real, pero hay un efecto secundario y eso es porque es como un alias de la variable real. Podemos cambiar accidentalmente la variable principal a través de nuestro acceso completo al alias, por lo que lo hacemos constante para evitar este efecto secundario.

   int var0 = 0;
   const int &ptr1 = var0;
   ptr1 = 8; // Error
   var0 = 6; // OK
   

2. Punteros constantes

   Una vez que un puntero constante apunta a una variable, no puede apuntar a ninguna otra variable.

   int var1 = 1;
   int var2 = 0;
   
   int *const ptr2 = &var1;
   ptr2 = &var2; // Error
   

3. Puntero a constante

   Un puntero a través del cual no se puede cambiar el valor de una variable que señala se conoce como puntero a constante.

   int const * ptr3 = &var2;
   *ptr3 = 4; // Error
   

4. Puntero constante a una constante

   Un puntero constante a una constante es un puntero que no puede cambiar la dirección a la que apunta y tampoco puede cambiar el valor guardado en esa dirección.

   int var3 = 0;
   int var4 = 0;
   const int * const ptr4 = &var3;
   *ptr4 = 1;     // Error
    ptr4 = &var4; // Error
   

La regla general es que la constpalabra clave se aplica a lo que la precede inmediatamente. Excepción, un comienzo se constaplica a lo que sigue.

• const int*es lo mismo int const*y significa "puntero a int constante" .
• const int* constes lo mismo int const* consty significa "puntero constante a int constante" .

Editar: Para lo que se debe y no se debe hacer, si esta respuesta no es suficiente, ¿podría ser más preciso sobre lo que quiere?

¿Esta pregunta muestra precisamente por qué me gusta hacer las cosas de la manera que mencioné en mi pregunta ?

En resumen, creo que la forma más fácil de recordar la regla es que el "const" va después de lo que se aplica. Entonces, en su pregunta, "int const *" significa que int es constante, mientras que "int * const" significa que el puntero es constante.

Si alguien decide ponerlo al frente (por ejemplo: "const int *"), como una excepción especial en ese caso, se aplica a la cosa que está después.

A muchas personas les gusta usar esa excepción especial porque piensan que se ve mejor. No me gusta, porque es una excepción y, por lo tanto, confunde las cosas.

Uso simple de const.

El uso más simple es declarar una constante con nombre. Para hacer esto, se declara una constante como si fuera una variable pero se agrega constantes. Hay que inicializarlo inmediatamente en el constructor porque, por supuesto, no se puede establecer el valor más tarde, ya que eso lo alteraría. Por ejemplo:

const int Constant1=96; 

creará una constante entera, llamada inimaginablemente Constant1, con el valor 96.

Dichas constantes son útiles para los parámetros que se usan en el programa pero que no necesitan cambiarse después de compilar el programa. Tiene una ventaja para los programadores sobre el #definecomando del preprocesador C, ya que el compilador lo comprende y lo utiliza, no solo sustituye el texto del programa por el preprocesador antes de llegar al compilador principal, por lo que los mensajes de error son mucho más útiles.

También funciona con punteros, pero hay que tener cuidado constde determinar si el puntero o lo que apunta es constante o ambos. Por ejemplo:

const int * Constant2 

declara que Constant2es un puntero variable a un entero constante y:

int const * Constant2

es una sintaxis alternativa que hace lo mismo, mientras que

int * const Constant3

declara que Constant3es un puntero constante a un entero variable y

int const * const Constant4

declara que Constant4es un puntero constante a un entero constante. Básicamente, 'const' se aplica a lo que esté a su izquierda inmediata (excepto si no hay nada allí, en cuyo caso se aplica a lo que sea su derecha inmediata).

ref: http://duramecho.com/ComputerInformation/WhyHowCppConst.html

Tenía la misma duda que tú hasta que encontré este libro del C ++ Guru Scott Meyers. Consulte el tercer elemento en este libro donde habla en detalles sobre el uso const.

Solo sigue este consejo

1. Si la palabra constaparece a la izquierda del asterisco, lo que se señala es constante
2. Si la palabra constaparece a la derecha del asterisco, el puntero en sí es constante
3. Si constaparece en ambos lados, ambos son constantes

Es simple pero complicado. Tenga en cuenta que puede cambiar la constclasificación con cualquier tipo de datos ( int, char, float, etc.).

Veamos los siguientes ejemplos.

const int *p==> *pes de solo lectura [ pes un puntero a un entero constante]

int const *p==> *pes de solo lectura [ pes un puntero a un entero constante]

int *p const==> Declaración incorrecta . El compilador arroja un error de sintaxis.

int *const p==> pes de solo lectura [ pes un puntero constante a un entero]. Como el puntero paquí es de solo lectura, la declaración y la definición deben estar en el mismo lugar.

const int *p const ==> Declaración incorrecta . El compilador arroja un error de sintaxis.

const int const *p ==> *pes de solo lectura

const int *const p1 ==> *py pson de solo lectura [ pes un puntero constante a un entero constante]. Como el puntero paquí es de solo lectura, la declaración y la definición deben estar en el mismo lugar.

int const *p const ==> Declaración incorrecta . El compilador arroja un error de sintaxis.

int const int *p ==> Declaración incorrecta . El compilador arroja un error de sintaxis.

int const const *p ==> *pes de solo lectura y es equivalente aint const *p

int const *const p ==> *py pson de solo lectura [ pes un puntero constante a un entero constante]. Como el puntero paquí es de solo lectura, la declaración y la definición deben estar en el mismo lugar.

Hay muchos otros puntos sutiles que rodean la corrección constante en C ++. Supongo que la pregunta aquí ha sido simplemente sobre C, pero daré algunos ejemplos relacionados ya que la etiqueta es C ++:

• A menudo pasa argumentos grandes como cadenas TYPE const &que evitan que el objeto sea modificado o copiado. Ejemplo:

  TYPE& TYPE::operator=(const TYPE &rhs) { ... return *this; }

  Pero no TYPE & consttiene sentido porque las referencias son siempre constantes.

• Siempre debe etiquetar los métodos de clase que no modifican la clase como const, de lo contrario no puede llamar al método desde una TYPE const &referencia. Ejemplo:

  bool TYPE::operator==(const TYPE &rhs) const { ... }

• Hay situaciones comunes en las que tanto el valor de retorno como el método deben ser constantes. Ejemplo:

  const TYPE TYPE::operator+(const TYPE &rhs) const { ... }

  De hecho, los métodos const no deben devolver datos de clase internos como una referencia a no const.

• Como resultado, a menudo se debe crear un método const y un método no const utilizando la sobrecarga const. Por ejemplo, si define T const& operator[] (unsigned i) const;, entonces probablemente también desee la versión no constante dada por:

  inline T& operator[] (unsigned i) { return const_cast<char&>( static_cast<const TYPE&>(*this)[](i) ); }

Afaik, no hay funciones const en C, las funciones que no son miembros no pueden ser const en C ++, los métodos const pueden tener efectos secundarios y el compilador no puede usar funciones const para evitar llamadas de funciones duplicadas. De hecho, incluso una simple int const &referencia podría ser testigo del cambio al valor al que se refiere en otro lugar.

La sintaxis de la declaración C y C ++ ha sido repetidamente descrita como un experimento fallido por los diseñadores originales.

En su lugar, vamos a nombrar el tipo “puntero a Type”; Lo llamaré Ptr_:

template< class Type >
using Ptr_ = Type*;

Ahora Ptr_<char>es un puntero a char.

Ptr_<const char>es un puntero a const char.

Y const Ptr_<const char>es un constpuntero a const char.

Allí.

Para mí, la posición de, constes decir, si aparece a la IZQUIERDA o DERECHA o tanto a la IZQUIERDA como a la DERECHA en relación con el *me ayuda a descubrir el significado real.

1. A consta la IZQUIERDA de *indica que el objeto señalado por el puntero es un constobjeto.

2. A consta la DERECHA de *indica que el puntero es un constpuntero.

La siguiente tabla está tomada del Stanford CS106L Standard C ++ Programming Laboratory Course Reader.

Esto aborda principalmente la segunda línea: mejores prácticas, tareas, parámetros de función, etc.

Práctica general. Intenta hacer todo lo constque puedas. O para decirlo de otra manera, haga todo constpara comenzar, y luego elimine exactamente el conjunto mínimo de consts necesarios para permitir que el programa funcione. Esto será de gran ayuda para lograr la corrección constante y ayudará a garantizar que no se introduzcan errores sutiles cuando las personas intentan y asignan cosas que no deben modificar.

Evite const_cast <> como la plaga. Hay uno o dos casos de uso legítimo para ello, pero son muy pocos y distantes. Si está tratando de cambiar un constobjeto, será mucho mejor encontrar a quien lo declaró consten el primer paso y discutir el asunto con ellos para llegar a un consenso sobre lo que debería suceder.

Lo que lleva muy bien a las tareas. Puede asignar a algo solo si no es constante. Si desea asignar algo que sea constante, vea más arriba. Recuerde que en las declaraciones int const *foo;y int * const bar;diferentes cosas hay constotras respuestas aquí que han cubierto ese tema admirablemente, por lo que no voy a entrar en él.

Parámetros de la función:

Pase por valor: por ejemplo void func(int param), no le importa de una forma u otra en el sitio de llamadas. Se puede argumentar que existen casos de uso para declarar la función como, void func(int const param)pero que no tiene ningún efecto en la persona que llama, solo en la función en sí misma, ya que cualquier valor que se pase no puede ser cambiado por la función durante la llamada.

Pase por referencia: por ejemplo, void func(int &param)ahora sí hace la diferencia. Como se acaba de declarar, funcestá permitido cambiar param, y cualquier sitio de llamadas debe estar listo para lidiar con las consecuencias. Cambiar la declaración a void func(int const &param)cambios en el contrato y garantiza que funcahora no puede cambiar param, lo que significa que lo que se pasa es lo que volverá a salir. Como otros han señalado, esto es muy útil para pasar de manera económica un objeto grande que no desea cambiar. Pasar una referencia es mucho más barato que pasar un objeto grande por valor.

Pasaremos por el puntero: por ejemplo, void func(int *param)y void func(int const *param)estos dos son más o menos sinónimo de sus homólogos de referencia, con la salvedad de que la función llamada ahora necesita para comprobar si hay nullptrmenos que alguna otra garantía contractual asegura funcque nunca va a recibir una nullptren param.

Artículo de opinión sobre ese tema. Probar la corrección en un caso como este es terriblemente difícil, es demasiado fácil cometer un error. Así que no se arriesgue, y siempre verifique los parámetros del puntero nullptr. Se ahorrará dolor y sufrimiento y será difícil encontrar errores a largo plazo. Y en cuanto al costo del cheque, es muy barato, y en los casos en que el análisis estático integrado en el compilador puede administrarlo, el optimizador lo eludirá de todos modos. Active la Generación de código de tiempo de enlace para MSVC, o WOPR (creo) para GCC, y obtendrá todo el programa, es decir, incluso en llamadas de función que cruzan el límite del módulo de código fuente.

Al final del día, todo lo anterior hace un caso muy sólido para preferir siempre referencias a punteros. Son más seguros en todos los aspectos.

La constante con int en ambos lados hará que el puntero a int constante :

const int *ptr=&i;

o:

int const *ptr=&i;

constafter *hará un puntero constante a int :

int *const ptr=&i;

En este caso, todos estos son punteros a enteros constantes , pero ninguno de estos son punteros constantes:

 const int *ptr1=&i, *ptr2=&j;

En este caso, todos son punteros a enteros constantes y ptr2 es puntero constante a enteros constantes . Pero ptr1 no es un puntero constante:

int const *ptr1=&i, *const ptr2=&j;

• si constestá a la izquierda de *, se refiere al valor (no importa si es const into int const)
• si constestá a la derecha de *, se refiere al puntero mismo
• puede ser ambos al mismo tiempo

Un punto importante: ¡ const int *p no significa que el valor al que se refiere es constante! . Significa que no puede cambiarlo a través de ese puntero (es decir, no puede asignar $ * p = ... `). El valor en sí mismo puede cambiarse de otras maneras. P.ej

int x = 5;
const int *p = &x;
x = 6; //legal
printf("%d", *p) // prints 6
*p = 7; //error 

Está destinado a ser utilizado principalmente en firmas de funciones, para garantizar que la función no pueda cambiar accidentalmente los argumentos pasados.

Solo por completo para C siguiendo las otras explicaciones, no estoy seguro de C ++.

• pp - puntero a puntero
• p - puntero
• datos - lo señalado, en ejemplos x
• negrita - variable de solo lectura

Puntero

• p datos - int *p;
• p datos -int const *p;
• p datos -int * const p;
• p datos -int const * const p;

Puntero a puntero

1. pp p data - int **pp;
2. pp p data -int ** const pp;
3. pp p data -int * const *pp;
4. pp p data -int const **pp;
5. pp p data -int * const * const pp;
6. pp p data -int const ** const pp;
7. pp p data -int const * const *pp;
8. pp p data -int const * const * const pp;

// Example 1
int x;
x = 10;
int *p = NULL;
p = &x;
int **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 2
int x;
x = 10;
int *p = NULL;
p = &x;
int ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 3
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 4
int const x = 10; // Definition must happen during declaration
int const * p = NULL;
p = &x;
int const **pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 5
int x;
x = 10;
int * const p = &x; // Definition must happen during declaration
int * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 6
int const x = 10; // Definition must happen during declaration
int const *p = NULL;
p = &x;
int const ** const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

// Example 7
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const *pp = NULL;
pp = &p;
printf("%d\n", **pp);

// Example 8
int const x = 10; // Definition must happen during declaration
int const * const p = &x; // Definition must happen during declaration
int const * const * const pp = &p; // Definition must happen during declaration
printf("%d\n", **pp);

N niveles de desreferencia

Solo sigue adelante, pero que la humanidad te excomulgue.

int x = 10;
int *p = &x;
int **pp = &p;
int ***ppp = &pp;
int ****pppp = &ppp;

printf("%d \n", ****pppp);

1. const int*- puntero al intobjeto constante .

Puede cambiar el valor del puntero; no puede cambiar el valor del intobjeto, apunta el puntero.

2. const int * const- puntero constante al intobjeto constante .

No puede cambiar el valor del puntero ni el valor del intobjeto al que apunta el puntero.

3. int const *- puntero al intobjeto constante .

Esta declaración es equivalente a 1. const int*- Puede cambiar el valor del puntero pero no puede cambiar el valor del intobjeto al que apunta el puntero.

En realidad, hay una cuarta opción:

4. int * const- puntero constante al intobjeto.

Puede cambiar el valor del objeto al que apunta el puntero, pero no puede cambiar el valor del puntero en sí. El puntero siempre apuntará al mismo intobjeto, pero este valor de este intobjeto se puede cambiar.

Si desea determinar un determinado tipo de construcción C o C ++, puede usar la regla en sentido horario / espiral hecha por David Anderson; pero no confundir con la Regla de Anderson hecha por Ross J. Anderson, que es algo bastante distinto.