Dominar los punteros constantes y los punteros a constantes en C

En C, un puntero es una variable que almacena la dirección de memoria de otra variable y la palabra clave const se utiliza para definir una variable o puntero cuyo valor no se puede cambiar una vez inicializado. Cuando combinamos punteros con constante palabra clave, podemos controlar dos cosas:

• Si la dirección almacenada en el puntero puede cambiar.
• Si el valor almacenado en esa dirección puede cambiar.

En este capítulo, veremos las tres variaciones principales de punteros constantes:

• Puntero constante
• Puntero a constante
• Puntero constante a constante

Puntero constante

Un puntero constante significa que el puntero en sí es constante. Una vez que se inicializa para que apunte a una ubicación de memoria, no puede apuntar a una ubicación diferente, pero el valor almacenado en esa ubicación aún se puede cambiar.

La siguiente es la sintaxis de un puntero constante −

data_type *const pointer_name = &variable;

En esta sintaxis, tipo_datos es el tipo de datos al que apunta el puntero, *const hace que el puntero sea constante, pointer_name es el nombre del puntero y &variable le asigna la dirección de memoria de una variable.

Ejemplo de puntero constante

En este ejemplo, declaramos un puntero constante ptr e inicialícelo con la dirección de la variable x . Luego, cambiamos el valor de x usando ptr e imprimimos su valor.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 *ptr = 15; // can change the value at address
 printf("Modified value of x: %d\n", *ptr);
 // ptr = &y; // changing pointer address is not allowed
 return 0;
}

A continuación se muestra la salida del programa anterior, que muestra que el puntero permanece fijo en x , pero el valor de x se puede actualizar.

Value of x: 10
Modified value of x: 15

Ejemplo de error de puntero constante

Aquí hay un ejemplo donde declaramos un puntero constante ptr e inicialícelo con la dirección de la variable x . Luego, intentamos que apunte a la dirección de la variable y . Esto dará un error porque un puntero constante no puede apuntar a otra ubicación de memoria una vez que se ha inicializado.

#include <stdio.h>
int main() {
 int x = 10;
 int y = 20;
 int *const ptr = &x; // constant pointer to int
 printf("Value of x: %d\n", *ptr);
 // Attempting to change the pointer to point to y
 ptr = &y; // cannot change the address of a constant pointer
 return 0;
}

Puedes ver el error a continuación , indicando que no podemos cambiar la dirección de un puntero constante.

error: assignment of read-only variable 'ptr'

Puntero a constante

Un puntero a constante significa que el valor al que apunta no se puede cambiar, pero el puntero en sí puede apuntar a diferentes direcciones de memoria (o variables).

La siguiente es la sintaxis del puntero a constante −

const data_type *pointer_name = &variable;
data_type const *pointer = &variable;

En esta sintaxis, const data_type o tipo_datos constante significa que el puntero apunta a un valor constante, pointer_name es el nombre del puntero y &variable le asigna la dirección de una variable.

Ejemplo de puntero a constante

En este ejemplo, declaramos un puntero ptr que apunta a un valor constante y asignarle la dirección de la variable a . Luego, hacemos que el puntero apunte a una dirección diferente de la variable b e imprima su valor.

#include <stdio.h>
int main() {
 int a = 5;
 int b = 30;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // *ptr = 10; //we cannot modify value through pointer
 ptr = &b; // canging pointer address
 printf("Now pointing to b: %d\n", *ptr);
 return 0;
}

A continuación se muestra el resultado del programa anterior, que muestra el mismo puntero apuntando a diferentes variables.

Value of a: 5
Now pointing to b: 30

Ejemplo de un puntero a error constante

Aquí hay un ejemplo donde declaramos un puntero a la constante ptr e inicializarlo con la dirección de la variablea . Luego, intentamos cambiar el valor de a a través del puntero. Esto dará un error porque un puntero a constante no permite modificar el valor al que apunta.

#include <stdio.h>
int main() {
 int a = 5;
 const int *ptr = &a; // pointer to constant int
 printf("Value of a: %d\n", *ptr);
 // we cnnot modify value through pointer to constant
 *ptr = 10; 
 return 0;
}

A continuación puede ver el resultado , que muestra un error indicando que no podemos modificar el valor mediante un puntero a constante.

error: assignment of read-only location '*ptr'

Puntero constante a constante

Un puntero constante a una constante es un puntero que no puede cambiar su dirección de memoria y el valor almacenado en esa dirección de memoria tampoco se puede cambiar. Ambas acciones están restringidas, por lo que sólo podemos leer el valor, nada más.

A continuación se muestra la sintaxis de un puntero constante a una constante −

const data_type *const pointer_name = &variable;

En esta sintaxis −

• tipo_datos constante indica que el valor en la ubicación de la memoria no se puede cambiar mediante el puntero.
• *const nombre_puntero significa que el puntero en sí no puede apuntar a ninguna otra dirección de memoria después de la inicialización.
• &variable asigna el puntero a la dirección de memoria de la variable.

Ejemplo de puntero constante a constante

En este ejemplo, declaramos un puntero constante a la constante ptr y asignarle la dirección de memoria de la variable a . Luego imprimimos el valor de a usando el puntero.

#include <stdio.h>
int main() {
 int a = 10;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cannot modify value
 // ptr = &b; // we annot change pointer location
 return 0;
}

A continuación se muestra el resultado del programa anterior −

Value of a: 10

Ejemplo de puntero constante a error constante

En este ejemplo, declaramos un puntero constante a constanteptr e inicializarlo con una variable a . Luego, intentamos modificar el valor a través del puntero y también intentamos que el puntero apunte a otra variable. Ambas operaciones no están permitidas y provocarán un error del compilador. .

#include <stdio.h>
int main() {
 int a = 10;
 int b = 20;
 const int *const ptr = &a; // constant pointer to constant
 printf("Value of a: %d\n", *ptr);
 // *ptr = 15; // we cnnot modify value
 // ptr = &b; // we cannot change pointer address
 return 0;
}

A continuación puede ver el resultado mostrando los errores −

Value of a: 10

Diferencia entre tipos de puntero constante

La siguiente tabla muestra las diferencias entre un puntero constante, un puntero a constante y un puntero constante a constante.

Variación Definición ¿Puede cambiar la dirección? ¿Se puede cambiar el valor? Ejemplo de sintaxis Puntero constanteUn puntero cuya dirección es fija, pero el valor en esa dirección se puede modificar.NoSí

int *const p = &x;

Puntero a constanteUn puntero que puede apuntar a diferentes direcciones, pero no puede modificar el valor en la ubicación señalada.SíNo

const int *p = &x;

Puntero constante a constanteUn puntero cuya dirección es fija y el valor en esa dirección no se puede modificar.NoNo

const int *const p = &x;

Conclusión

En este capítulo, cubrimos punteros constantes y punteros a constantes en C. Punteros constantes corrige la dirección pero permite cambiar el valor, punteros a constante permitir cambiar la dirección pero no el valor, y punteros constantes a constante restringir ambos.