C++ proporciona una función para devolver un valor o una dirección por su referencia en lugar de punteros. El uso de referencias en lugar de punteros puede hacer que un programa C++ sea más sencillo de leer y administrar. En C++, las referencias y los punteros están estrechamente relacionados entre sí. La distinción principal es que, aunque las referencias son simplemente un nombre alternativo, un 'alias' para otra variable, los punteros se pueden usar en operaciones como la suma de valores. Una referencia es un nombre alternativo o un duplicado del valor original y se indica con el símbolo '&'.
Ejemplo 1:
Importamos el archivo de encabezado 'iostream' y luego utilizamos el espacio de nombres 'std'. Los archivos de encabezado se importan en códigos C++ ya que se definen muchas funciones. Luego, creamos una función de referencia de retorno colocando el símbolo '&' con el nombre de la función, 'returnTheValue'.
Aquí, ahora se inserta la referencia al 'valor'. Debajo de esto, imprimimos el valor y la dirección con la referencia “&valor”. Luego, colocamos la referencia de devolución y colocamos el “valor”. Ahora, aquí se invoca 'main()' e inicializamos 'n1' con el valor de '44'. Debajo de esto, 'int& n2' se inicializa con 'returnTheValue(n1)'. Ahora imprimimos el valor de “n1” así como su dirección. Luego, imprimimos el valor de 'n2' así como la dirección de 'n2' utilizando 'cout'.
Código 1:
#incluir
usando el espacio de nombres estándar;
En t & devolverelvalor ( En t & valor )
{
corte << 'Valor = ' << valor << fin
<< 'La dirección del valor es'
<< & valor << fin;
devolver valor;
}
ent principal ( )
{
tu n1 = 44 ;
En t & n2 = devolverElValor ( n1 ) ;
corte << 'n1 = ' << n1 << fin
<< 'La dirección de n1 es'
<< & n1 << fin;
corte << 'n2 = ' << n2 << fin
<< 'La dirección de n2 es'
<< & n2 << fin;
devolver 0 ;
}
Producción:
Aquí, podemos observar que una referencia es solo un nombre alternativo de otra variable, como se muestra a continuación. Como dirección de valor, 'n1' y 'n2' nunca cambian.
Ejemplo 2:
Usamos el espacio de nombres 'std' después de importar el archivo de encabezado 'iostream'. A continuación, utilizamos el nombre de la función 'MyReturnValueFunc' y el símbolo '&' para crear una función de referencia de retorno. La referencia a la variable “v1” se coloca aquí. Imprimimos el valor y la dirección con la referencia “&v1” debajo de esto. A continuación, insertamos la 'referencia de retorno' utilizando 'retorno' y 'v1' en esta ubicación. Aquí, se llama a 'main()' y se inicializa 'num_1' con el valor de '19'. La inicialización de “int& num_2” se realiza con “MyReturnValueFunc(num_1)”.
Actualmente imprimimos el valor y la dirección de “num_1” y, usando “cout”, imprimimos el valor y la dirección de “num_2”. Ahora cambiamos el valor de 'num_1' utilizando la dirección que devuelve aquí 'MyReturnValueFunc'. Esta función devuelve el nombre alternativo de 'v1', que también es el nombre alternativo de 'num_1'. Entonces, cambiamos su valor y lo configuramos en '91'. Asignamos '91' a 'MyReturnValueFunc(num_1)', que actúa como alias aquí. Luego, imprimimos nuevamente el valor y la dirección de “num_1”.
Código 2:
#incluirusando el espacio de nombres estándar;
En t & MiFunciónValorDeRetorno ( En t & v1 )
{
corte << 'El valor de v1 = ' << v1 << fin
<< 'La dirección de la variable v1 es'
<< & v1 << fin;
devolver v1;
}
ent principal ( )
{
int núm_1 = 19 ;
En t & num_2 = MiReturnValueFunc ( número_1 ) ;
corte << 'El valor de num_1 = ' << número_1 << fin
<< 'La dirección de num_1 es'
<< & número_1 << fin;
corte << 'El valor de num_2 = ' << número_2 << fin
<< 'La dirección de num_2 es'
<< & número_2 << fin;
MiFunciónValorDeRetorno ( número_1 ) = 91 ;
corte << 'Ahora, el valor de num_1 = ' << número_1 << fin
<< 'La dirección de num_1 es '
<< & número_1 << fin;
devolver 0 ;
}
Producción:
Como se demuestra a continuación, podemos ver que una referencia es simplemente un nombre alternativo para otra variable ya que la dirección de los valores “v1”, “num_1” y “num_2” permaneció constante:
Ejemplo 3:
Se importa el archivo de encabezado 'iostream' y se utiliza el espacio de nombres 'std'. Dado que se especifican numerosas funciones en los archivos de encabezado, las importamos a los códigos C++. Aquí, creamos una función 'ReturnRefFun()' en la que colocamos 'int& my_ref' que devuelve la referencia. Aquí se declara 'int& ReturnRefFun' como función de referencia. Después de esto, incrementamos el valor de la variable 'my_ref'. Debajo de esto, ponemos 'return' que devuelve la referencia de 'my_ref'.
Después de esto, aquí se invoca el método “main()”. Luego, inicializamos la variable 'primer_valor' con '21'. Debajo de esto, devolvemos la copia de la referencia colocando 'first_value' en la función 'ReturnRefFun' y la guardamos en la variable 'copied_value'. Luego, imprimimos tanto el 'primer_valor' como el 'valor_copiado' utilizando el 'cout'. Debajo de esto, incrementamos la variable 'valor_copiado' colocando el 'valor_copiado++'. Luego, imprimimos el “valor_copiado” después de incrementarlo y el “primer_valor” usando “cout”. Después de esto, devolvemos la referencia con la ayuda de inicializar la variable 'int& ref_value' con 'ReturnRefFun(first_value)'.
Después de esto, imprimimos el valor de la variable “my_ref” que copiamos. Luego, imprimimos el valor de la variable 'primer_valor'. Debajo de esto, incrementamos el valor de 'ref_value' poniendo 'ref_value++'. Debajo de esto, imprimimos el valor incrementado de 'ref_value' y también la variable 'first_value' con la ayuda de 'cout'. Cuando se cambia el 'valor_ref', el 'primer_valor' también cambiará.
Código 3:
#incluirusando el espacio de nombres estándar;
En t & RegresarRefFun ( En t & mi_ref ) {
mi_ref++;
devolver mi_ref;
}
ent principal ( ) {
En t primer_valor = 21 ;
En t valor_copiado =RetornoRefFun ( primer_valor ) ;
corte << 'El primer valor es: ' << primer_valor << fin;
corte << 'El valor copiado es: ' << valor_copiado << fin;
valor_copiado++;
corte << 'El valor_copiado se incrementa: ' << valor_copiado << fin;
corte << 'El primer valor: ' << primer_valor << fin;
En t & valor_ref =RetornoRefFun ( primer_valor ) ;
corte << 'El valor copiado de referencia: ' << valor_ref << fin;
corte << 'El primer valor: ' << primer_valor << fin;
valor_ref++;
corte << 'El valor de referencia se incrementa: ' << valor_ref << fin;
corte << 'El primer valor: ' << primer_valor << fin;
devolver 0 ;
}
Producción:
Aquí está el resultado del código anterior donde utilizamos la técnica de 'devolver referencia'. El ejemplo muestra la distinción entre devolver un duplicado de la variable de referencia y devolver la variable de referencia misma.
Ejemplo 4:
Aquí, 'int& rByRef' se declara como la función de referencia que devuelve la variable de referencia. Pasamos “int& data” a esta función “int& rByref()”. Aquí, imprimimos la dirección de la variable 'datos' y luego utilizamos la referencia de retorno debajo de esta. Ahora, inicializamos la variable 'x_var' después de invocar el método 'main()'. Luego, imprimimos la dirección de 'x_var' aquí poniendo '&x_var' en 'cout'.
Debajo de esto, utilizamos la variable de referencia asignando 'rByref(x_var)' a 'int& y_var'. Luego, también imprimimos la dirección de esa variable de referencia '&y_var'. Debajo de esto, copiamos la variable 'x_var' en la variable 'z_var' y también imprimimos la dirección de esta variable copiada que es '&z_var'. Después de esto, llamamos a la función 'rByref()', pasamos la variable 'x_var' como parámetro dentro de ella y asignamos '93' a esta variable. También volvemos a representar la dirección de “x_var” poniendo “&x_var” en “cout”.
Código 4:
#incluirusando el espacio de nombres estándar;
En t & rByref ( En t & datos )
{
corte << 'Dirección de datos: ' << & datos << fin;
devolver datos;
}
ent principal ( )
{
int x_var = 42 ;
corte << 'Dirección de x_var: ' << & x_var << fin;
En t & y_var = rByref ( x_var ) ;
corte << 'Dirección de y_var: ' << & y_var << fin;
int z_var = rByref ( x_var ) ;
corte << 'Dirección de z_var: ' << & z_var << fin;
rByref ( x_var ) = 93 ;
corte << 'Dirección de x_var: ' << & x_var << fin;
devolver 0 ;
}
Producción:
El resultado deja claro que la dirección de la variable clonada, 'z_var', difiere de todas las demás ubicaciones a las que hace referencia la variable original, 'x_var'.
Conclusión
El concepto de 'referencia de retorno' se explora en detalle en este tutorial. Aprendimos que la 'referencia de retorno' es similar a los 'punteros' en la programación en C++. Discutimos que para indicar qué función devuelve una referencia, es necesario utilizar el símbolo '&' con el tipo de retorno de la función. Ilustramos algunos ejemplos y sus resultados y entendimos este concepto en este tutorial.