¿Cuál es la diferencia entre const int, const int const e int const *?

Question 1

Siempre me lío cómo usar const int*, const int * consty int const * correctamente. ¿Existe un conjunto de reglas que definan lo que puede y no puede hacer?

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

Question 2

Léalo al revés (como impulsado por Regla en el sentido de las agujas del reloj/espiral):

int* – puntero a int
int const * – puntero a const int
int * const – const puntero a int
int const * const – const puntero a const int

ahora el primero const puede estar a ambos lados del tipo, por lo que:

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

Si quieres volverte realmente loco, puedes hacer cosas como esta:

int ** – puntero a puntero a int
int ** const – un puntero const a un puntero a un int
int * const * – un puntero a una const puntero a un int
int const ** – un puntero a un puntero a una const int
int * const * const – un puntero const a un puntero const 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.

foo es un puntero variable a un entero constante. Esto le permite cambiar lo que apunta, pero no el valor 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 la cadena a la que apunta, pero no puede cambiar el contenido de estas cadenas. Esto es importante cuando la propia cadena está en el segmento de datos de un programa y no debe cambiarse.

bar es 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, generalmente usaría una referencia donde usaría un T* const puntero a menos que necesite permitir NULL punteros

Question 3

Para aquellos que no saben acerca de la regla de las agujas del reloj/espiral: Comience desde el nombre de la variable, muévase en el sentido de las agujas del reloj (en este caso, muévase hacia atrás) a la siguiente puntero o escribe. Repita hasta que termine la expresión.

Aquí hay una demostración:

Question 4

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

Por ejemplo:

typedef char *ASTRING;
const ASTRING astring;

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

Question 5

Como casi todos señalaron:

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

Tienes que 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 en sí, 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í mismo, ni puede cambiar el objeto X a través de p.

Question 6

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 que el valor real, pero hay un efecto secundario y es que es como un alias de la variable real. Es posible que cambiemos 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
```
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
```
Puntero a constante

Un puntero a través del cual no se puede cambiar el valor de una variable a la que apunta se conoce como puntero a constante.
```
int const * ptr3 = &var2;
*ptr3 = 4; // Error
```
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 ni 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
```

Question 7

La regla general es que el const palabra clave se aplica a lo que le precede inmediatamente. Excepción, un comienzo const se aplica a lo que sigue.

const int* es lo mismo que int const* y medios “puntero a int constante”.
const int* const es lo mismo que int const* const y medios “puntero constante a int constante”.

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

Question 8

Esta pregunta muestra precisamente ¿Por qué me gusta hacer las cosas de la manera que mencioné en mi pregunta es constante después de la identificación del tipo aceptable?

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

Si alguien decide ponerlo al principio (p. ej.: “const int *”), como excepción especial en ese caso, se aplica a lo que sigue.

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.

¿Ha sido útil esta solución?