Sabemos que la variable de puntero puede almacenar la dirección de memoria en lenguaje C y en este artículo aprenderemos cómo usar ese puntero para acceder a los datos almacenados en la ubicación de memoria señalada por el puntero.
¿Qué es un puntero?
En primer lugar, repasemos qué es un puntero. Un puntero es una variable que almacena la dirección de memoria de otra variable. El puntero nos ayuda a manipular los datos en la dirección de memoria a la que apunta el puntero. Además, varios punteros pueden apuntar a la misma memoria.
Considere el siguiente ejemplo,
int num = 10; int *ptr; ptr = #>
Hemos almacenado la dirección del en uno variables en el ptr puntero, pero ahora, cómo acceder al valor almacenado en la memoria en la dirección señalada por ptr ? Aquí entra en juego la desreferenciación.
Puntero de desreferencia en C
Acceder o manipular el contenido almacenado en la dirección de memoria señalada por el puntero mediante el operador de desreferenciación o de indirección (*) se denomina desreferenciación del puntero.
Puntero de desreferenciación en C
Sintaxis para desreferenciar un puntero
Usamos el operador de indirección (*) como prefijo para desreferenciar un puntero:
* ( pointer_name )>
Para modificar los datos almacenados en la memoria utilizamos
* ( pointer_name ) = new_value;>
Cabe señalar que el nuevo_valor debe ser del mismo tipo que el anterior.
Considere los ejemplos anteriores donde ptr puntos a si, t El operador de desreferenciación * puede acceder al contenido de la dirección de memoria. Ahora, *ptr recuperará el contenido almacenado en la dirección 10.
La dirección y los valores de memoria num y ptr se verán así.
| Variable | Dirección de memoria | Valor |
|---|---|---|
| número = 10 | 202020 | 10 |
| 202021 | ||
| 202022 | ||
| 202023 | ||
| ptr = &núm | 202024 – 202032 | 202020 |
Nota: Hemos asumido que la arquitectura en el ejemplo anterior es direccionable por bytes, es decir, la unidad mínima que tiene una dirección separada es un byte.
Ejemplos de desreferenciación de punteros
Ejemplo 1:
Usar un puntero para acceder y modificar el valor de una variable entera.
C
// C Program to illustrate the dereferencing of pointer> #include> int> main()> {> >// Declare integer variable number> >int> num = 10;> >// Declare pointer to store address of number> >int>* ptr = #> >// Print the value of number> >printf>(>'Value of num = %d
'>, num);> >// Print Address of the number using & operator> >printf>(>'Address of num = %d
'>, &num);> >// Print Address stored in the pointer> >printf>(>'Address stored in the ptr = %p
'>, ptr);> >printf>(>'Dereference content in ptr using *ptr
'>);> >// Access the content using * operator> >printf>(>'Value of *ptr = %d
'>, *ptr);> >printf>(>'Now, *ptr is same as number
'>);> >printf>(>'Modify the value using pointer to 6
'>);> >// Modify the content in the address to 6 using pointer> >*ptr = 6;> >// Print the modified value using pointer> >printf>(>'Value of *ptr = %d
'>, *ptr);> >// Print the modified value using variable> >printf>(>'Value of number = %d
'>, num);> >return> 0;> }> |
java leer csv
>
>
Producción
Value of num = 10 Address of num = 0x7ffe47d51b4c Address stored in the ptr = 0x7ffe47d51b4c Dereference content in ptr using *ptr Value of *ptr = 10 Now, *ptr is same as number Modify the value using pointer to 6 Value of *ptr = 6 Value of number = 6>
Ejemplo 2: desreferenciación de doble puntero
Los punteros dobles también se pueden desreferenciar usando la misma lógica, pero tendrá que usar el operador de indirección dos veces: una para moverse al puntero al que apunta el puntero doble y la otra para acceder al valor real.
C
java concatenar cadenas
// C program to dereference double pointer> #include> int> main()> {> >int> var = 10;> >int>* ptr = &var;> >// double pointer> >int>** dptr = &ptr;> >// dereferencing the double pointer> >printf>(>'Accesing value from double pointer using '> >'**dptr: %d'>,> >**dptr);> >return> 0;> }> |
>
>Producción
Accesing value from double pointer using **dptr: 10>
Así, podemos desreferenciar punteros de cualquier nivel.
¿Cómo funciona la desreferenciación?
Siempre que le pedimos al compilador que elimine la referencia a un puntero, hace tres cosas:
- Primero busca la dirección almacenada en el puntero.
- Luego busca el tipo de puntero para poder deducir la cantidad de memoria a leer. Por ejemplo, 4 bytes para int, 1 byte para char, etc. También es la razón principal por la que necesitamos especificar el tipo de puntero en la declaración aunque el tamaño de todos los punteros en un sistema sea el mismo.
- Finalmente, lee la memoria y devuelve los datos almacenados.
Nota: Del razonamiento anterior, también podemos inferir que no podemos desreferenciar el puntero vacío porque se desconoce el tamaño de los datos a los que apunta. Entonces necesitamos encasillar el puntero void para desreferenciarlo.