Tutoriales

Devolver una referencia en C++

C++ proporciona una función para devolver un valor o dirección a través de una referencia en lugar de un puntero. El uso de referencias en lugar de punteros hace que los programas C++ sean más fáciles de leer y administrar. En C++, las referencias y los punteros están estrechamente relacionados entre sí. La principal diferencia es que, si bien una referencia es solo un nombre alternativo, un «alias» para otra variable, un indicador se puede usar para cosas como agregar un valor. Una referencia es un nombre alternativo o una copia del valor original y está representada por el símbolo «&».

Ejemplo 1:

Importamos el archivo de encabezado «iostream» y luego usamos el espacio de nombres «std». El archivo de encabezado se importa como código C++ porque se definen muchas funciones. Luego creamos una función de referencia de retorno colocando el símbolo «&» junto con el nombre de la función «returnTheValue».

Aquí, ahora inserte la referencia del «valor». Debajo de eso, usamos «&value» para referirnos al valor de impresión y la dirección. Luego ponemos la referencia de retorno y ponemos el «valor». Ahora, aquí se llama a «main()» e inicializamos «n1» con el valor «44». Debajo de esto, «int& n2» se inicializa usando «returnTheValue(n1)». Ahora imprimimos el valor de «n1» y su dirección. Luego, usamos «cout» para imprimir el valor de «n2» y la dirección de «n2».

Código 1:

#incluir
Utilice el espacio de nombres estándar;
entero& valor de retorno(entero& valor)
{
kut < «valor=» < valor < endel
< «La dirección del valor es»
< &valor < Finalizar;
devolver valor;
}
maestro de enteros()
{
Entero n1 = 44;
entero& n2 = valor de retorno(n1);
kut < «n1=» < n1 < endel
< «La dirección de n1 es»
< &n1 < Finalizar;
kut < «n2=» < n2 < endel
< «La dirección de n2 es»
< &n2 < Finalizar;
devolver ;
}

Producción:

Aquí podemos notar que una referencia es solo un nombre alternativo para otra variable como se muestra a continuación. Como direcciones de valores, «n1» y «n2» nunca cambian.

Ejemplo 2:

Después de importar el archivo de encabezado «iostream», utilizamos el espacio de nombres «std». A continuación, creamos una función de referencia de retorno utilizando el nombre de función «MyReturnValueFunc» y el símbolo «&». Aquí se coloca una referencia a la variable «v1». Imprimimos el valor y la dirección con una referencia «&v1» debajo. A continuación, insertamos una «referencia de retorno» usando «retorno» y «v1» en esta ubicación. Aquí, se llama a «main()» y se inicializa «num_1» con el valor «19». La inicialización de «int& num_2» se completa a través de «MyReturnValueFunc(num_1)».

Actualmente, imprimimos el valor y la dirección de «num_1» y usamos «cout» para imprimir el valor y la dirección de «num_2». Ahora, usamos la dirección devuelta por «MyReturnValueFunc» para cambiar el valor de «num_1». Esta función devuelve el nombre alternativo de «v1», que también es el nombre alternativo de «num_1». Por tanto, 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:

#incluir
Utilice el espacio de nombres estándar;
entero& Mi función de valor de retorno(entero& v1)
{
kut < «valor de v1=» < v1 < endel
< «La dirección de la variable v1 es»
< &v1 < Finalizar;
devolver v1;
}
maestro de enteros()
{
Número entero_1 = No 19;
entero& num_2 = MiReturnValueFunc(No._1);
kut < «núm_1 valor=» < No._1 < endel
< «La dirección de num_1 es»
< &No._1 < Finalizar;
kut < «núm_2 valor=» < No._2 < endel
< «La dirección de num_2 es ​​»
< &No._2 < Finalizar;
Mi función de valor de retorno(No._1) = 91;
kut < «Ahora, valor de num_1=» < No._1 < endel
< «La dirección de num_1 es»
< &No._1 < Finalizar;
devolver ;
}

Producción:

Como se muestra a continuación, podemos ver que la referencia es solo un nombre alternativo para otra variable, porque las direcciones de los valores «v1», «num_1» y «num_2» siguen siendo las mismas:

Ejemplo 3:

Importe el archivo de encabezado «iostream» y utilice el espacio de nombres «std». Dado que muchas funciones se especifican en el archivo de encabezado, las importamos al código C++. Aquí, creamos una función «ReturnRefFun()» y colocamos el «int& my_ref» que devuelve la referencia. Aquí «int& ReturnRefFun» se declara como función de referencia. Después de eso, incrementamos el valor de la variable «my_ref». Debajo de esto, colocamos «return», que devuelve una referencia a «my_ref».

Después de eso, aquí se llama al método «main()». Luego, inicializamos la variable «first_value» con «21». A continuación, devolvemos una copia de la referencia colocando «first_value» en la función «ReturnRefFun» y la guardamos en la variable «copied_value». Luego, usamos «cout» para imprimir «primer_valor» y «valor_copiado». Debajo de esto, agregamos la variable «valor_copiado» colocando «valor_copiado++». Luego imprimimos «valor_copiado» después de incrementarlo y usamos «cout» para imprimir «primer_valor». Después de eso, devolvemos la referencia inicializando la variable «int& ref_value» usando «ReturnRefFun(first_value)».

Después de eso, imprimimos el valor copiado de la variable «my_ref». Luego, imprimimos el valor de la variable «primer_valor». Debajo de esto, aumentamos el valor de «ref_value» colocando «ref_value++». A continuación, usamos «cout» para imprimir el valor incremental de «ref_value» y la variable «first_value». Cuando «ref_value» cambia, «first_value» también cambia.

Código 3:

#incluir
Utilice el espacio de nombres estándar;
entero& Función de referencia de retorno(entero& mi_referencia){
mi_referencia++;
devolver mi_referencia;
}
maestro de enteros() {
entero primer valor= veintiuno;
entero valor de copia=Regresar RefFun(primer valor);
kut < «El primer valor es:» < primer valor < Finalizar;
kut< «El valor copiado es:» < valor de copia < Finalizar;
valor de copia++;
kut< «El valor copiado se incrementa:» < valor de copia < Finalizar;
kut < «Primer valor:» < primer valor < Finalizar;
entero& Referencia=Regresar RefFun(primer valor);
kut < «Valor de copia de referencia:» < Referencia < Finalizar;
kut < «Primer valor:» < primer valor < Finalizar;
valor de referencia++;
kut < «Valor de referencia aumentado:» < Referencia < Finalizar;
kut < «Primer valor:» < primer valor < Finalizar;
devolver ;
}

Producción:

Este es el resultado de nuestro código anterior utilizando la técnica de «devolver referencia». Este ejemplo muestra la diferencia entre devolver una copia de una variable de referencia y devolver la variable de referencia misma.

Ejemplo 4:

Aquí, «int&rByRef» se declara como una función de referencia que devuelve una variable de referencia. Pasamos «int& data» a esta función «int& rByref()». Aquí imprimimos la dirección de la variable «datos» y luego usamos la referencia de retorno a continuación. Ahora, inicializamos la variable «x_var» después de llamar al método «main()». Luego imprimimos la dirección de «x_var» poniendo «&x_var» en «cout».

Debajo de esto, utilizamos variables de referencia asignando «rByref(x_var)» a «int& y_var». Luego, también imprimimos la dirección de la variable a la que hace referencia «&y_var». A continuación, copiamos la variable «x_var» a la variable «z_var» e imprimimos la dirección de esta variable copiada, que es «&z_var». Después de eso, llamamos a la función «rByref()», pasándole la variable «x_var» como parámetro y asignando «93» a la variable. También volvemos a representar la dirección de «x_var» poniendo «&x_var» en «cout».

Código 4:

#incluir
Utilice el espacio de nombres estándar;
entero& referencias(entero& datos)
{
kut< «Dirección de datos:»< &datos < Finalizar;
devolver datos;
}
maestro de enteros()
{
int x_var = 42;
kut< «Dirección de x_var:»< &x_var < Finalizar;
entero& y_var = rByref(x_var);
kut < «Dirección de y_var:»< &y_var < Finalizar;
int z_var = rByref(x_var);
kut < «Dirección de z_var:»< &z_var < Finalizar;
referencias(x_var) = 93;
kut< «Dirección de x_var:»< &x_var < Finalizar;
devolver ;
}

Producción:

Los resultados muestran claramente que la dirección de la variable clonada «z_var» es diferente de todas las demás ubicaciones a las que hace referencia la variable original «x_var».

en conclusión

Este tutorial explora en detalle el concepto de «referencias devueltas». Aprendimos que la «referencia de retorno» es similar al «puntero» en la programación de C++. Discutimos que para indicar qué función devuelve una referencia, es necesario usar el símbolo «&» con el tipo de retorno de la función. Ilustramos algunos ejemplos y sus resultados en este tutorial para comprender el concepto.

LEER  Debug Bash script-OSTechNix

Publicaciones relacionadas

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Botón volver arriba