Referência de retorno em C++

Referencia De Retorno Em C



C++ fornece um recurso para retornar um valor ou endereço por sua referência em vez de ponteiros. Usar referências em vez de ponteiros pode tornar um programa C++ mais simples de ler e gerenciar. Em C++, referências e ponteiros estão intimamente relacionados entre si. A principal distinção é que, embora as referências sejam apenas um nome alternativo, “alias” para outra variável, os ponteiros podem ser usados ​​em operações como adição de valores. Uma referência é um nome alternativo ou duplicado do valor original e é indicada pelo símbolo “&”.

Exemplo 1:

Importamos o arquivo de cabeçalho “iostream” e então utilizamos o namespace “std”. Os arquivos de cabeçalho são importados em códigos C++ à medida que muitas funções são definidas. Em seguida, criamos uma função de referência de retorno colocando o símbolo “&” com o nome da função, “returnTheValue”.







Aqui, a referência “valor” é inserida agora. Abaixo disso, imprimimos o valor e o endereço com a referência “&valor”. Depois, colocamos a referência de retorno e colocamos o “valor”. Agora, “main()” é invocado aqui, e inicializamos “n1” com o valor “44”. Abaixo disso, “int& n2” é inicializado com “returnTheValue(n1)”. Agora, imprimimos o valor de “n1” bem como seu endereço. Em seguida, imprimimos o valor de “n2” bem como o endereço de “n2” utilizando o “cout”.



Código 1:



#include
usando namespace std;
interno & retornarOValor ( interno & valor )
{
corte << 'Valor =' << valor << fim
<< 'O endereço do valor é'
<< & valor << fim;
retornar valor;
}
principal interno ( )
{
você n1 = 44 ;
interno & n2 = retornarOValor ( n1 ) ;
corte << 'n1 =' << n1 << fim
<< 'O endereço de n1 é'
<< & n1 << fim;
corte << 'n2=' << n2 << fim
<< 'O endereço de n2 é'
<< & n2 << fim;
retornar 0 ;
}


Saída:





Aqui, podemos observar que uma referência é apenas um nome alternativo de outra variável, conforme mostrado a seguir. Como endereço do valor, “n1” e “n2” nunca mudam.



Exemplo 2:

Usamos o namespace “std” após importar o arquivo de cabeçalho “iostream”. A seguir, usamos o nome da função “MyReturnValueFunc” e o símbolo “&” para construir uma função de referência de retorno. A referência à variável “v1” é colocada aqui. Imprimimos o valor e o endereço com a referência “&v1” abaixo dele. A seguir, inserimos a “referência de retorno” utilizando “return” e “v1” neste local. Aqui, “main()” é chamado e “num_1” é inicializado com o valor “19”. A inicialização de “int& num_2” é feita com “MyReturnValueFunc(num_1)”.

Atualmente imprimimos o valor e endereço de “num_1” e, usando “cout”, imprimimos o valor e endereço de “num_2”. Agora alteramos o valor de “num_1” utilizando o endereço retornado aqui por “MyReturnValueFunc”. Esta função retorna o nome alternativo de “v1”, que também é o nome alternativo de “num_1”. Então, alteramos seu valor e definimos como “91”. Atribuímos “91” a “MyReturnValueFunc(num_1)”, que atua como alias aqui. Em seguida, imprimimos o valor novamente e o endereço “num_1”.

Código 2:

#include
usando namespace std;
interno & MeuReturnValueFunc ( interno & v1 )
{
corte << 'O valor de v1 =' << v1 << fim
<< 'O endereço da variável v1 é'
<< & v1 << fim;
retornar v1;
}
principal interno ( )
{
int num_1 = 19 ;
interno & num_2 = MeuReturnValueFunc ( num_1 ) ;
corte << 'O valor de num_1 =' << num_1 << fim
<< 'O endereço de num_1 é'
<< & num_1 << fim;
corte << 'O valor de num_2 =' << num_2 << fim
<< 'O endereço de num_2 é'
<< & num_2 << fim;
MeuReturnValueFunc ( num_1 ) = 91 ;
corte << 'Agora, o valor de num_1 =' << num_1 << fim
<< 'O endereço de num_1 é'
<< & num_1 << fim;
retornar 0 ;
}


Saída:

Conforme demonstrado a seguir, podemos ver que uma referência é apenas um nome alternativo para outra variável, uma vez que o endereço dos valores “v1”, “num_1” e “num_2” permaneceu constante:

Exemplo 3:

O arquivo de cabeçalho “iostream” é importado e o namespace “std” é usado. Como inúmeras funções são especificadas nos arquivos de cabeçalho, nós as importamos para os códigos C++. Aqui, criamos uma função “ReturnRefFun()” na qual colocamos “int& my_ref” que retorna a referência. O “int& ReturnRefFun” é declarado aqui como a função de referência. Depois disso, incrementamos o valor da variável “my_ref”. Abaixo disso colocamos “return” que retorna a referência de “my_ref”.

Depois disso, o método “main()” é invocado aqui. Em seguida, inicializamos a variável “first_value” com “21”. Abaixo disso, retornamos a cópia da referência colocando “first_value” na função “ReturnRefFun” e salvando na variável “copied_value”. Em seguida, imprimimos tanto o “primeiro_valor” quanto o “valor_copiado” utilizando o “cout”. Abaixo disso, incrementamos a variável “copiado_valor” colocando o “copiado_valor++”. Em seguida, imprimimos o “valor_copiado” após incrementá-lo e o “primeiro_valor” usando “cout”. Depois disso, retornamos a referência com a ajuda da inicialização da variável “int& ref_value” com “ReturnRefFun(first_value)”.

Depois disso, imprimimos o valor da variável “my_ref” que copiamos. Em seguida, imprimimos o valor da variável “first_value”. Abaixo disso, incrementamos o valor de “ref_value” colocando “ref_value++”. Abaixo disso, imprimimos o valor incrementado de “ref_value” e também a variável “first_value” com o auxílio de “cout”. Quando o “ref_value” é alterado, o “first_value” também será alterado.

Código 3:

#include
usando namespace std;
interno & RetornoRefFun ( interno & minha_ref ) {
minha_ref++;
retornar minha_ref;
}
principal interno ( ) {
interno primeiro_valor = vinte e um ;
interno valor_copiado =ReturnRefFun ( primeiro_valor ) ;
corte << 'O primeiro valor é:' << primeiro_valor << fim;
corte << 'O valor copiado é:' << valor_copiado << fim;
valor_copiado++;
corte << 'O copy_value é incrementado:' << valor_copiado << fim;
corte << 'O primeiro valor:' << primeiro_valor << fim;
interno & valor_ref =ReturnRefFun ( primeiro_valor ) ;
corte << 'O valor copiado de referência:' << valor_ref << fim;
corte << 'O primeiro valor:' << primeiro_valor << fim;
ref_valor++;
corte << 'O valor de referência é incrementado:' << valor_ref << fim;
corte << 'O primeiro valor:' << primeiro_valor << fim;
retornar 0 ;
}


Saída:

Aqui está o resultado do código anterior onde utilizamos a técnica de “referência de retorno”. O exemplo mostra a distinção entre retornar uma duplicata da variável de referência e retornar a própria variável de referência.

Exemplo 4:

Aqui, “int& rByRef” é declarado como a função de referência que retorna a variável de referência. Passamos o “int& data” para esta função “int& rByref()”. Aqui, imprimimos o endereço da variável “dados” e então utilizamos a referência de retorno abaixo dela. Agora, inicializamos a variável “x_var” após invocar o método “main()”. Então, imprimimos o endereço de “x_var” aqui colocando “&x_var” em “cout”.

Abaixo disso, utilizamos a variável de referência atribuindo “rByref (x_var)” a “int& y_var”. Em seguida, também imprimimos o endereço dessa variável de referência “&y_var”. Abaixo disso, copiamos a variável “x_var” para a variável “z_var” e também imprimimos o endereço desta variável copiada que é “&z_var”. Depois disso, chamamos a função “rByref()”, passamos a variável “x_var” como parâmetro dentro dela e atribuímos “93” a esta variável. Também renderizamos o endereço de “x_var” novamente colocando “&x_var” em “cout”.

Código 4:

#include
usando namespace std;
interno & rByref ( interno & dados )
{
corte << 'Endereço dos dados:' << & dados << fim;
retornar dados;
}
principal interno ( )
{
int x_var = 42 ;
corte << 'Endereço de x_var:' << & x_var << fim;
interno & y_var = rByref ( x_var ) ;
corte << 'Endereço de y_var:' << & y_var << fim;
int z_var = rByref ( x_var ) ;
corte << 'Endereço de z_var:' << & z_var << fim;
rByref ( x_var ) = 93 ;
corte << 'Endereço de x_var:' << & x_var << fim;
retornar 0 ;
}


Saída:

O resultado deixa claro que o endereço da variável clonada, “z_var”, difere de todos os outros locais aos quais a variável original, “x_var”, faz referência.

Conclusão

O conceito de “referência de retorno” é explorado detalhadamente neste tutorial. Aprendemos que a “referência de retorno” é semelhante aos “ponteiros” na programação C++. Discutimos que para indicar qual função retorna uma referência, o símbolo “&” precisa ser utilizado com o tipo de retorno da função. Ilustramos alguns exemplos e seus resultados e entendemos esse conceito neste tutorial.