Puntero constante frente a puntero a constante [duplicado]

Quiero saber la diferencia entre

const int* ptr;

y

int * const ptr; 

y como funciona.

Es bastante difícil para mí entender o recordar esto. Por favor ayuda.

const int* ptr; 

declara ptrun puntero para const intescribir. Puede modificarse a ptrsí mismo, pero el objeto al que apunta ptrno se modificará.

const int a = 10;
const int* ptr = &a;  
*ptr = 5; // wrong
ptr++;    // right  

Mientras

int * const ptr;  

declara ptrun constpuntero para intescribir. No se le permite modificar, ptrpero el objeto al que apunta ptrse puede modificar.

int a = 10;
int *const ptr = &a;  
*ptr = 5; // right
ptr++;    // wrong

En general, preferiría una declaración como esta, que hace que sea fácil de leer y comprender (leer de derecha a izquierda):

int const  *ptr; // ptr is a pointer to constant int 
int *const ptr;  // ptr is a constant pointer to int

const int * ptr;

significa que los datos señalados son constantes e inmutables, pero el puntero no lo es.

int * const ptr;

significa que el puntero es constante e inmutable, pero los datos señalados no lo son.

1) Punteros constantes: este tipo de punteros son los que no pueden cambiar la dirección a la que apuntan. Esto significa que supongamos que hay un puntero que apunta a una variable (o almacena la dirección de esa variable). Ahora bien, si intentamos apuntar el puntero a alguna otra variable (o intentamos hacer que el puntero almacene la dirección de alguna otra variable), entonces los punteros constantes son incapaces de hacerlo.

Un puntero constante se declara como: int *const ptr(la ubicación de 'const' hace que el puntero 'ptr' sea un puntero constante)

2) Puntero a constante: este tipo de punteros son los que no pueden cambiar el valor al que apuntan. Esto significa que no pueden cambiar el valor de la variable cuya dirección tienen.

Un puntero a una constante se declara como: const int *ptr(la ubicación de 'const' hace que el puntero 'ptr' sea un puntero a constante.

Ejemplo

Puntero constante

#include<stdio.h>

int main(void)
{
    int a[] = {10,11};
    int* const ptr = a;

    *ptr = 11;

    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    ptr++;
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    return 0;
}

Ahora, cuando compilamos el código anterior, el compilador se queja:

practice # gcc -Wall constant_pointer.c -o constant_pointer
constant_pointer.c: In function ‘main’:
constant_pointer.c:13: error: increment of read-only variable ‘ptr’

Por lo tanto, vemos muy claramente arriba que el compilador se queja de que no podemos cambiar la dirección mantenida por un puntero constante.

Puntero a constantes

#include<stdio.h>

int main(void)
{
    int a = 10;
    const int* ptr = &a;


    printf("\n value at ptr is  : [%d]\n",*ptr);
    printf("\n Address pointed by ptr  : [%p]\n",(unsigned int*)ptr);

    *ptr = 11;

    return 0;
}

Ahora, cuando se compila el código anterior, el compilador se queja:

practice # gcc -Wall pointer_to_constant.c -o pointer_to_constant
pointer_to_constant.c: In function ‘main’:
pointer_to_constant.c:12: error: assignment of read-only location ‘*ptr’

Por tanto, aquí también vemos que el compilador no permite que el puntero a una constante cambie el valor de la variable a la que se apunta.

Cotización

Haciendo referencia a This Thread

Punteros constantes

Primero entendamos qué es un puntero constante. Un puntero constante es un puntero que no puede cambiar la dirección que contiene. En otras palabras, podemos decir que una vez que un puntero constante apunta a una variable, no puede apuntar a ninguna otra variable.

Un puntero constante se declara de la siguiente manera:
<type of pointer> * const <name of pointer>
Una declaración de ejemplo se vería así:
int * const ptr;
Tomemos un pequeño código para ilustrar este tipo de punteros:

#include<stdio.h>

int main(void)
{
    int var1 = 0, var2 = 0;
    int *const ptr = &var1;
    ptr = &var2;
    printf("%d\n", *ptr);

    return 0;
} 

En el ejemplo anterior:

• Declaramos dos variables var1 y var2
  
• Se declaró un puntero constante 'ptr' y se hizo al punto var1
  
• A continuación, ptr se hace apuntar a var2.
  
• Finalmente, intentamos imprimir el valor al que apunta ptr.
  

Puntero a constante

Como es evidente por el nombre, un puntero a través del cual no se puede cambiar el valor de la variable que apunta se conoce como puntero a constante. Este tipo de punteros pueden cambiar la dirección a la que apuntan, pero no pueden cambiar el valor guardado en esas direcciones.

Un puntero a constante se define como: const <type of pointer>* <name of pointer> Un ejemplo de definición podría ser: const int* ptr; Tomemos un pequeño código para ilustrar un puntero a una constante:

 #include<stdio.h>

int main(void)
{
    int var1 = 0;
    const int* ptr = &var1;
    *ptr = 1;
    printf("%d\n", *ptr);

    return 0;
} 

En el código anterior:

• Definimos una variable var1 con valor 0
• definimos un puntero a una constante que apunta a la variable var1
• Ahora, a través de este puntero intentamos cambiar el valor de var1
• Se utilizó printf para imprimir el nuevo valor.

const int* ptr;

es un puntero a constante (contenido). Se le permite modificar el puntero. ej ptr = NULL. ptr++, pero no es posible modificar el contenido .

int * const ptr;

Es un puntero constante. Es posible lo contrario. No se le permite modificar el puntero, pero se le permite modificar a qué apunta, por ejemplo *ptr += 5.

int i;
int j;

int * const ptr1 = &i;

El compilador evitará que cambies ptr1.

const int * ptr2 = &i;

El compilador evitará que cambies *ptr2.

ptr1 = &j; // error
*ptr1 = 7; // ok

ptr2 = &j; // ok
*ptr2 = 7; // error

Tenga en cuenta que aún puede cambiar *ptr2, pero no escribiendo literalmente *ptr2:

i = 4;
printf("before: %d\n", *ptr2); // prints 4
i = 5;
printf("after: %d\n", *ptr2); // prints 5
*ptr2 = 6; // still an error

También puede tener un puntero con ambas funciones:

const int * const ptr3 = &i;

ptr3 = &j; // error
*ptr3 = 7; // error

Consulte el siguiente enlace para comprender mejor la diferencia entre el puntero constante y el puntero en un valor constante.

puntero constante vs puntero en un valor constante

const int* ptr; aquí piense que * ptr es constante y * ptr no se puede cambiar de nuevo

int * const ptr; mientras aquí piense como ptr como una constante y eso no se puede cambiar de nuevo