Cómo desreferencia un puntero c++?

Derferencing es una técnica para obtener datos de una dirección de memoria apuntada por un puntero mutable y manipulándolo. Un mutable que contiene la dirección de algún otro mutable se conoce como puntero. El signo (*) se utilizará como operador de deserencia. Dereferenceing Un puntero ocurre cada vez que el operador (*) se está lanzando en el puntero mutable. Cada vez que se desactiva un puntero, el valor de lo mutable representado por el puntero se vuelve. Por lo tanto, discutiremos el concepto de desferenciar un puntero en C ++ mientras utiliza el Ubuntu 20.04 sistema. Hagamos un nuevo comienzo con la creación de un archivo en Ubuntu usando el comando Terminal "Touch". El archivo se creará dentro del directorio de "inicio" root de su máquina. Se puede abrir en cualquiera de los editores que tiene en su sistema. Preferimos que el editor "nano" abra el archivo vacío dentro de la consola terminal.

$ touch lreerference.CC
$ nano desreferencia.CC

Ejemplo 01:

Tenemos que comenzar con la inclusión de una biblioteca "iostream" para el uso de la secuencia de entrada-salida en c++. La palabra clave #include se utiliza para hacerlo. Luego, un espacio de nombres estándar "STD" llegó a permitirnos usar las declaraciones estándar de Cout y CIN. Todo el trabajo se ha realizado dentro del método Main (). Hemos inicializado una variable entera "n" con el valor 1. Se utiliza un puntero de tipo entero "P" para referencia a la dirección "n" variable a través del operador "&". La primera declaración de cout se está utilizando para mostrar el valor de la variable "n" en el shell a través del puntero "P."La siguiente instrucción Cout se utiliza para mostrar el valor de una variable" n "en el shell.

#incluir
usando el espacio de nombres STD;
int main ();
int n = 1;
int* p = & n;
cout<<"Address of n: "<cout<<"Value of n: "<<*p<

Tienes que compilar el nuevo código con el compilador G ++ recién instalado de Ubuntu para el lenguaje C ++. A partir de ahora, no se han reconocido errores. Después de esto, hemos ejecutado el código con el "./a.Out "Out" y obtuvo la dirección y el valor de la variable "n" usando el puntero de la referencia.

$ G ++ LEERFERENCIA.CC
ps ./a.afuera

Ejemplo 02:

Tengamos otro ejemplo un poco diferente del ejemplo anterior. Por lo tanto, el ejemplo se ha iniciado con el mismo encabezado de la biblioteca de transmisión de entrada-salida y el espacio de nombres estándar "STD" con la palabra clave "usando". Ahora, la función Main () se inicia con la declaración e inicialización de una variable de cadena "V" con el valor de cadena "Linux."Después de esto, hemos declarado un puntero de tipo de cadena para realizar la deserencia y relacionarlo con la variable" V "a través del operador" & ". La deserencia se utiliza aquí para obtener el valor de una variable a través del puntero. El único cambio es el valor de una variable, yo.mi., cadena en lugar de un entero. La primera cláusula de Cout se utiliza para mostrar la dirección de una variable "V", y la otra declaración de Cout se utiliza para mostrar el valor de la variable "V."Guardemos el script y ejecutemos nuestro código.

#incluir
usando el espacio de nombres STD;
int main ();
String V = "Linux";
cadena *p = & v;
cout<<"Address of v: "<cout<<"Value of v: "<<*p<

El código ha sido compilado. Después de esto, hemos ejecutado el código simple y obtuvimos la dirección y el valor de una variable "V" al usar el método Derferencing a través del puntero.

$ G ++ LEERFERENCIA.CC
ps ./a.afuera

Ejemplo 03:

Tengamos nuestro último, pero no menos, el código comenzó con el encabezado de la biblioteca, yo.mi., iOStream, y el espacio de nombres estándar "STD" una vez más. Hemos declarado dos variables enteros dentro de la función principal (), V1 y V2. Mientras que V1 se inicializa con el valor "5". Las dos primeras declaraciones de Cout muestran los valores actuales de V1 y V2 en el shell, y el tercero muestra la dirección "P" del puntero. La próxima declaración de Cout nos dice que vamos a realizar Derferencing ahora. Entonces, hemos utilizado la instrucción "P = & V1" para asignar la dirección de una variable V1 a Pointer P. Esto se llama desreferencing. El puntero "P" se usa para mostrar la dirección y el valor de la variable V1 en el shell a través de las cláusulas de cout. Ahora, estamos asignando el valor del puntero "P" (que es V1) a la variable V2. La instrucción Cout mostrará el valor de V2, y el puntero "P" se asigna con un nuevo valor de 10. Las últimas 4 declaraciones muestran los valores nuevos o actuales de V1, V2 y Pointer "P."

#incluir
usando el espacio de nombres STD;
int main ();
int v1 = 5, v2;
cout<<"Value of v1: "<cout<<"Value of v2: "<int *p;
cout<<"Value of pointer p: "<cout<<"************* After using p=&v1 ************** "<P =&v1;
cout<<"Address of v1: "<cout<<"Value of v1: "<<*p<v2 =*p;
cout<<"************* After using v2=*p ************** "<cout<<"Address of v2: "<*p = 10;
cout<<"************* After using *p=10 ************** "<cout<<"Address of p: "<cout<<"Value of p: "<<*p<cout<<"Value of v1: "<cout<<"Value of v2: "<

Los valores de inicio de V1 y V2 se han mostrado junto con la dirección del puntero. Después de "P = y V1", la dirección de "P" se reemplaza con la de V1. Después de "V2 =*P", A "P" El valor de referencia se asigna a V2. Usando "*P = 10", el valor del puntero "P" se convierte en 10, y debido a la deserencia, V1 también se convierte en 10. Mientras que V2 y la dirección del puntero son la misma.

$ G ++ LEERFERENCIA.CC
ps ./a.afuera

Conclusión:

Entonces, todo esto se trataba de cómo desreferencia un puntero en C++. Hemos utilizado este concepto para obtener los valores de una variable y cambiar o actualizar el valor. Esperamos que le proporcionemos con éxito contenido simple y fácil de entender.