Como retornar vários valores em C++

Como Retornar Varios Valores Em C



A linguagem C++ nos oferece muitos recursos e torna nossa programação muito mais fácil. Mas às vezes precisamos retornar vários valores ao trabalhar com programação C++. Infelizmente, C++ não nos facilita esse recurso. Para retornar vários valores em C++, devemos utilizar diferentes técnicas. Podemos retornar vários valores em C++ usando tuplas/pares, ponteiros e arrays. Estudaremos minuciosamente todas essas técnicas neste guia, juntamente com códigos e explicações.

Exemplo 1: Utilizando Tuplas/Pares

Vamos fazer uma demonstração prática para retornar vários valores em C++. Aqui, utilizamos as técnicas de tuplas/pares para ajudar a retornar vários valores em nosso código. C++ fornece vários arquivos de cabeçalho que devemos incluir em nosso código. Incluímos “bits/stdc++.h” aqui porque contém todas as bibliotecas da programação C++. Em seguida, o namespace é adicionado aqui, que é “std”. Depois disso, utilizamos a palavra-chave “tuple” na qual colocamos três tipos de dados, dois tipos de dados float e o restante tipo de dados “char”. Abaixo dela, utilizamos a palavra-chave “return” para empacotar os valores e retornar uma tupla.

Agora, utilizamos o método “par” para retornar vários valores. Neste método “par”, colocamos dois tipos de dados de variáveis, e ambos são “flutuantes” aqui. As variáveis ​​​​são denominadas “float_1” e “float_2”. Em seguida, empacotamos dois valores para retornar aos “pares”. Depois disso, invocamos “main()” aqui e então declaramos duas variáveis ​​“float” com o nome “f_1, f_2”. A variável “char” também é declarada aqui como “myChar”. Em seguida, descompactamos os valores que são retornados pela função “My_Tuple()”.







Abaixo disso, armazenamos os valores retornados em pares. Armazenamos “4,99, 8,98” na função “My_Tuple” e “6,86, 3,22” na função “My_Pair”. Em seguida, utilizamos o “cout” que imprime todas as informações que estão escritas dentro dele.



Código 1:



#incluir
usando espaço para nome padrão ;
tupla < flutuador , flutuador , Caracteres > Minha_Tupla ( flutuador f_1, flutuador f_2 ) {
retornar make_tuple ( f_2, f_1, '$' ) ;
}
par < flutuador , flutuador > Meu_Par ( flutuador f_a, flutuador f_b ) {
retornar fazer_par ( f_b, f_a ) ;
}
interno principal ( ) {
flutuador f_1,f_2 ;
Caracteres meuChar ;
gravata ( f_1, f_2, meuChar ) = Minha_Tupla ( 4,99 , 8,98 ) ;
par novo_p = Meu_Par ( 6,86 , 3.22 ) ;
corte << 'Valores que obtemos por tuplas:' ;
corte << f_1 << ' ' << f_2 << ' ' << meuChar << fim ;
corte << 'Valores que obtemos por par:' ;
corte << novo p. primeiro << ' ' << novo p. segundo ;
retornar 0 ;
}

Saída :





Os valores que obtemos aqui utilizando os métodos “tuplas” e “par” são exibidos a seguir. Observe que ele retorna vários valores aqui.



Exemplo 2: Utilizando os Ponteiros

Passamos os parâmetros junto com seus endereços na função “comparar” aqui. Adicionamos “valor_1” e “valor_2” do tipo “int” e o “int* g_Address, int* s_Address”. Depois disso, utilizamos a condição “se” na qual adicionamos uma condição de que “valor_1” seja maior que “valor_2”. Se isso for satisfeito, a instrução a seguir será executada. Caso contrário, ele ignora a instrução adicionada abaixo e segue para a parte “else”. Agora, após invocar “main()”, declaramos quatro novas variáveis ​​​​com os nomes “g_value”, “s_value”, “newValue1” e “newValue2”.

Após isso, imprimimos uma mensagem para inserir os números e depois colocamos “cin” que obtém dois valores do usuário. Os valores que o usuário insere são salvos nas variáveis ​​“newValue1” e “newValue2”, respectivamente. Depois disso, chamamos a função “compare()” que criamos anteriormente e passamos quatro parâmetros para ela. Em seguida, exibimos o resultado após realizar a função “comparar” e mostra o maior número e o menor número desses números que o usuário digita.

Código 2:

#include
usando espaço para nome padrão ;
vazio comparar ( interno valor_1, interno valor_2, interno * g_Endereço, interno * s_Endereço )
{
se ( valor_1 > valor_2 ) {
* g_Endereço = valor_1 ;
* s_Endereço = valor_2 ;
}
outro {
* g_Endereço = valor_2 ;
* s_Endereço = valor_1 ;
}
}
interno principal ( )
{
interno g_valor, s_valor, novoValor_1, novoValor_2 ;
corte << 'Por favor, insira dois números:' <> novoValor_1 >> novoValor_2 ;
comparar ( novoValor_1, novoValor_2, & g_valor, & s_valor ) ;
corte << ' \n O maior número é ' << valor_g << 'e o número menor é'
<< s_valor ;
retornar 0 ;
}

Saída :
O usuário insere “86” e “23” aqui. Após pressionar “Enter”, exibe o resultado. Dessa forma, obtemos vários valores.

Exemplo 3: Utilizando o Array

Criamos aqui a função “ComputeComparison()” na qual inserimos duas variáveis, “num_1” e “num_2”, como o tipo “int” e também um array chamado “my_arr[]”. Depois disso, temos a condição “if” que verifica se “num_1” é maior que “num_2” ou não. Se for verdade, “num_1” é atribuído a “my_arr[0]” e “num_2” é atribuído a “my_arr[1]”. Mas se a condição não for verdadeira, as instruções após “else” são executadas nas quais atribuímos “num_2” a “my_arr[0]” e “num_1” a “my_arr[1]”.

Depois disso, chamamos “main()” aqui e então declaramos mais duas variáveis ​​​​int: “newNum_1” e “newNum_2”. Depois disso, um array de tamanho “2” é declarado. Depois disso, obtemos dois números do usuário com a ajuda de “cin” e depois chamamos a função “ComputeComparison()” e exibimos o seguinte resultado. Então, ele retorna vários valores aqui.

Código 3:

#include
usando espaço para nome padrão ;
vazio ComputeComparação ( interno num_1, interno num_2, interno meu_arr [ ] )
{

se ( num_1 > num_2 ) {
meu_arr [ 0 ] = num_1 ;
meu_arr [ 1 ] = num_2 ;
}
outro {
meu_arr [ 0 ] = num_2 ;
meu_arr [ 1 ] = num_1 ;
}
}

interno principal ( )
{
interno novoNum_1, novoNum_2 ;
interno meu_arr [ 2 ] ;

corte << 'Insira dois números para comparação' <> novoNum_1 >> novoNum_2 ;
ComputeComparação ( novoNum_1, novoNum_2, minha_arr ) ;
corte << ' \n O maior número é ' << meu_arr [ 0 ] << ' e a '
'número menor é' << meu_arr [ 1 ] ;

retornar 0 ;
}

Saída :
Digitamos “54” e “98” aqui e pressionamos “Enter” para exibir o resultado. Ele mostra os números maiores e menores dos números que inserimos.

Exemplo 4: Utilizando as Tuplas

Dois arquivos de cabeçalho estão incluídos aqui: “tuple” e “iostream”. A seguir, o namespace “std” é colocado aqui. A seguir, usamos a palavra-chave “tuple” e inserimos dois tipos de dados que são “int”. Depois disso, criamos uma função com o nome “findingValues()” e passamos “intValue_1” e “intValue2” como seus parâmetros.

Em seguida, é colocado o “if” onde digitamos a condição “intValue_1 < intValue_2”. Abaixo dela, utilizamos a palavra-chave “return” e colocamos a função “make_tuple()” na qual ambas as variáveis ​​​​são adicionadas como parâmetro “intValue_1, intValue2_”. Depois, temos a parte “else” na qual colocamos “return” novamente junto com a função “make_tuple()”. Mas aqui colocamos primeiro o “intValue_2” e depois o “intValue1”. Agora, chamamos “main()” e inicializamos “new_value1” com “5” e “new_value2” com “28”.

A seguir, declaramos mais duas variáveis ​​do tipo “int” com os nomes “maior” e “menor”. Em seguida, colocamos a função “tie()” e passamos as variáveis ​​“menor, maior” como parâmetro e também chamamos a função “findingValues()” aqui. Depois disso, imprimimos os dois valores: o número maior e o menor.

Código 4:

#include
#include
usando espaço para nome padrão ;
tupla  encontrandoValores ( interno intValor_1, interno intValor_2 )
{
se ( intValor_1 < intValor_2 ) {
retornar make_tuple ( intValue_1, intValue_2 ) ;
}
outro {
retornar make_tuple ( intValue_2, intValue_1 ) ;
}
}
interno principal ( )
{
interno novo_valor1 = 5 , novo_valor2 = 28 ;
interno maior, menor ;
gravata ( menor, maior ) = encontrando Valores ( novo_valor1, novo_valor2 ) ;
imprimir ( 'O maior número é %d e o'
'o número menor é %d' ,
maior, menor ) ;
retornar 0 ;
}

Saída :

Os números que adicionamos ao nosso código exibem simultaneamente os valores maiores e menores. Dessa forma, podemos retornar facilmente vários valores em nosso código.

Conclusão

Este guia é sobre “retornar vários valores” em códigos C++. Exploramos minuciosamente essa noção neste guia e discutimos três técnicas que auxiliam no retorno de vários valores na programação C++. Explicamos que vários valores são retornados utilizando tuplas, pares, ponteiros e técnicas de array. Todas essas técnicas são descritas detalhadamente aqui.