Puntero constante vs Puntero a constante

Quiero saber la diferencia entre

const int* ptr; 

y

 int * const ptr; 

y cómo funciona

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

 const int* ptr; 

declara ptr un puntero al tipo const int . Puede modificar ptr sí mismo, pero el objeto apuntado por ptr no se modificará.

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

Mientras

 int * const ptr; 

declara ptr un puntero const al tipo int . No está permitido modificar ptr pero el objeto apuntado por ptr .

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

En general, preferiría una statement como esta que lo haga fácil de leer y entender (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 apuntados son constantes e inmutables, pero el puntero no.

 int * const ptr; 

significa que el puntero es constante e inmutable, pero los datos apuntados 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 tratamos de 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 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 están reteniendo.

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 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 comstackmos el código anterior, el comstackdor 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 comstackdor se queja de que no podemos cambiar la dirección mantenida por un puntero constante.

Puntero a Constantes

 #include 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 comstack el código anterior, el comstackdor 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 lo tanto, aquí también vemos que el comstackdor no permite que el puntero a una constante cambie el valor de la variable apuntada.

Cotización

Referencia de este hilo

Punteros constantes

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

Un puntero constante se declara de la siguiente manera:
* const
Una statement de ejemplo se vería así:
int * const ptr;
Tomemos un pequeño código para ilustrar este tipo de punteros:

 #include 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
  • Un puntero constante ‘ptr’ fue declarado y hecho para apuntar var1
  • Luego, ptr está hecho para apuntar var2.
  • Finalmente, tratamos de imprimir el valor al que apunta ptr.

Puntero a constante

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

Un puntero a constante se define como: const * 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 int main(void) { int var1 = 0; const int* ptr = &var1; *ptr = 1; printf("%d\n", *ptr); return 0; } 

En el código de arriba:

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

es un puntero a constante (contenido). Puedes modificar el puntero. por ejemplo ptr = NULL , ptr++ , pero la modificación del contenido no es posible.

 int * const ptr; 

Es un puntero constante. Lo opuesto es posible. No tiene permitido modificar el puntero, pero puede modificar lo que señala, p *ptr += 5 Ej., *ptr += 5 .

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

El comstackdor le ptr1 cambiar ptr1 .

 const int * ptr2 = &i; 

El comstackdor lo detendrá cambiando *ptr2 .

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

Tenga en cuenta que todavía puede cambiar *ptr2 , simplemente 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 de Const y el puntero en un valor constante.

puntero constante vs puntero en un valor constante

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

int * const ptr; mientras que aquí piensas como ptr como una constante y eso no puede ser cambiado de nuevo