Ejemplo 1:
Comencemos nuestro primer código C++ agregando un archivo de encabezado. «iostream» es el archivo de encabezado incluido aquí. Esto nos permite usar fácilmente funciones como «cin» o «cout» en nuestro código, ya que estas funciones se declaran en este archivo de encabezado. También agregamos aquí el espacio de nombres «std» y luego llamamos al método «main()».
A continuación, creamos la variable indicadora «p» juntando las variables «*» y «p», e inicializamos la variable «x» con el valor «10». Ambos son tipos de datos «int». Luego, asignamos la dirección de la variable «x» a «p». Después de eso, coloque la declaración «cout», que representa la dirección de «x» porque agregamos «p» aquí. Luego aplicamos la desreferenciación y accedemos al valor de «x» almacenado en el puntero «p». También usamos «cout» para imprimir el valor obtenido al desreferenciar el indicador.
Código 1:
usar espacio de nombres estándar;
entero principal()
{
entero *X = 10;
pag = &X;
kut < «La dirección de x es» < pag < endel;
kut < «El valor de x obtenido al desreferenciar el puntero es» < *pag < endel;
devolver 0;
}
Producción:
Primero se muestra la dirección del valor «x». Luego, se muestra el valor de «x», que obtuvimos usando el indicador «*p» o desreferenciando el indicador.
Ejemplo 2:
Aquí aplicamos la técnica de desreferenciación a variables de tipo de datos de punto flotante. Por lo tanto, llamamos a «main()» después de agregar el archivo de encabezado «iostream» y el espacio de nombres «std». A continuación, inicializamos «f_1», que es el nombre de la variable del tipo de datos «flotante». Asignamos «4.987» a la variable «f_1». Luego, inicializamos el puntero «f_ptr», que es un puntero al tipo de datos de punto flotante. Usamos el símbolo «&» para guardar la dirección de la variable «f_1» en el indicador «f_ptr».
Después de eso, usamos «cout» y le ponemos «f_ptr», devolviendo la dirección de «f_1». Luego, aplicamos la desreferenciación, que utiliza «*f_ptr» para obtener el valor almacenado en la variable «f_1».
Código 2:
#incluir
usar espacio de nombres estándar;
entero principal() {
flotar f_1 = 4.987;
flotar* f_ptr = &f_1;
kut < «Dirección de f_1:» < f_ptr < endel;
kut < «Valor de f_1:» < *f_ptr < endel;
devolver 0;
}
Producción:
Después de mostrar la dirección con el valor 'f_1', se muestra el valor 'f_1' obtenido al desreferenciar el indicador usando '*f_ptr'.
Ejemplo 3:
Ahora, realizamos tecnología de desreferenciación en datos de tipo «cadena». Después de llamar a «main()» en este código, colocamos el tipo de datos «cadena» e inicializamos la variable «newName». Guardamos el nombre «Jack» en esta variable «newName». También inicializamos un puntero llamado «name_ptr» a continuación y asignamos la dirección de la variable «newName» al puntero.
Ahora queremos imprimir la dirección del indicador y el valor al que apunta el indicador. «name_ptr» contiene la dirección del valor señalado por el puntero, y «*name_ptr» se utiliza aquí como un puntero de desreferencia. Luego devuelve el valor de la variable señalada por «name_ptr». Los ponemos a ambos en «cout» para que se muestren como resultados.
Código 3:
#incluir
#incluir
usar espacio de nombres estándar;
entero principal() {
Cadena de nuevo nombre = «Jacobo»;
Cadena* puntero_nombre = &nuevo nombre;
kut < «La dirección del nombre es:» < puntero_nombre < endel;
kut < «Nombre desreferenciado:»< *puntero_nombre < endel;
devolver 0;
}
Producción:
La dirección donde almacenamos el nombre está impresa aquí. Luego, muestra el nombre en sí, que es la cadena que almacenamos en la variable. Usamos la técnica del indicador de desreferencia aquí para obtenerlo.
Ejemplo 4:
Ahora cambiamos el valor hacia donde apunta el indicador y vemos que no cambia el valor de la variable. Primero inicialice el indicador con el nombre «my_pntr» colocando el símbolo «*». «val_1» y «val_2» se inicializan con los valores «56» y «21» respectivamente. Su tipo de datos es «int». La dirección «val_1» está asignada a «my_pntr». Luego mostramos la dirección y el valor usando «cout» y colocando «my_pntr» y «*my_pntr» dentro de él. «my_ptr» devuelve la dirección y «*my_ptr» devuelve el valor de la variable señalada por el puntero.
Ahora nos referimos a la dirección del mismo indicador «my_pntr» y asignamos la dirección de «val_2» al indicador «my_pntr». Ahora, el puntero apunta a la dirección de otra variable, mientras que el valor de la variable anterior sigue siendo el mismo. Ahora imprimimos la dirección de la nueva variable y el valor del indicador colocando «my_pntr» y luego desreferenciando el indicador con ayuda de «*my_pntr». Después de eso, también imprimimos el valor de «val_1».
Código 4:
#incluir
usar espacio de nombres estándar;
entero principal()
{
entero *mi_pntr;
entero valor_1 = 56;
entero valor_2 = veintiuno;
mi_pntr = &valor_1;
kut < «La dirección de val_1 es» < mi_pntr < endel;
kut < «El valor de val_1 es» < *mi_pntr < endel;
mi_pntr = &valor_2;
kut < «Ahora cambiamos la posición del puntero, es decir.» < mi_pntr < endel;
kut < «El nuevo valor del indicador es» < *mi_pntr < endel;
kut < «El valor de val_1 sigue siendo» < valor_1;
devolver 0;
}
Producción:
Primero, se muestran la dirección de «val_1» y el valor de «val_1». Luego cambiamos la posición del indicador, el nuevo valor y la dirección de la nueva variable. Después de esto, se mostrará el valor «val_1». Podemos notar que después de cambiar la posición señalada por el puntero, el valor de la primera variable no se ve afectado; el puntero simplemente se mueve a otra posición.
Ejemplo 5:
«n_1» y «n_2» se inicializan en «33» y «98» como variables «int». Entonces, el indicador creado aquí es «*puntero». Después de eso, colocamos la dirección «n_1» en este «puntero». Por lo tanto, el indicador ahora apunta al valor de la variable «n_1».
A continuación, usamos la función «cout» para mostrar la dirección y el valor insertando «puntero» y «*puntero». La dirección se devuelve mediante «puntero» y el valor de la variable señalada por el puntero se devuelve como un puntero de desreferencia mediante «*puntero». Ahora, asignamos la dirección de «n_2» al puntero haciendo referencia al mismo puntero como «puntero». El indicador ahora pasa a una posición de variable diferente, mientras que el valor de la variable anterior permanece sin cambios.
Usando «cout», insertando «puntero» y usando «*puntero» para representar el valor de la variable, ahora podemos generar la dirección de la nueva variable y su valor.
Código 5:
#incluir
usar espacio de nombres estándar;
entero principal()
{
entero n_1 = 33;
entero n_2 = 98;
entero* puntero;
puntero = &n_1;
kut < «La dirección de n_1 es:» < puntero
< endel;
kut < «Al desreferenciar el puntero, el valor de n_1 es:»
< *puntero < endel;
puntero = &n_2;
kut < «El puntero cambia a:» < puntero < endel;
kut < «El nuevo valor para el mismo indicador es:»
< *puntero < endel;
devolver 0;
}
Producción:
Primero, muestre la dirección y el valor de «n_1». A continuación, ajuste la posición del indicador. El nuevo valor y la dirección de la nueva variable son los siguientes. Este ejemplo muestra claramente la dirección del indicador referenciado y luego desreferenciado del indicador para mostrar el valor.
en conclusión
Este artículo proporciona un estudio exhaustivo de las métricas de desreferencia en C++. Exploramos la desreferenciación como una técnica para obtener el valor de una variable señalada por un puntero. Exploramos cinco ejemplos diferentes en los que utilizamos indicadores de desreferencia en programación C++. También mostramos los resultados y el código de todos los ejemplos aquí.
