Hoe u meerdere waarden kunt retourneren in C++

Hoe U Meerdere Waarden Kunt Retourneren In C



De taal C++ biedt ons veel functies en maakt ons programmeren veel eenvoudiger. Maar soms moeten we meerdere waarden retourneren tijdens het werken met C++-programmering. Helaas faciliteert C++ ons niet met deze functie. Om meerdere waarden in C++ te retourneren, moeten we de verschillende technieken gebruiken. We kunnen meerdere waarden retourneren in C++ met behulp van tupels/paren, pointers en arrays. We zullen al deze technieken in deze gids grondig bestuderen, samen met codes en uitleg.

Voorbeeld 1: gebruik maken van de tupels/paren

Laten we een praktische demonstratie geven om meerdere waarden in C++ te retourneren. Hier gebruiken we de tuples/pairs-technieken om meerdere waarden in onze code te retourneren. C++ biedt verschillende headerbestanden die we in onze code moeten opnemen. We nemen hier “bits/stdc++.h” op omdat het alle bibliotheken van de C++-programmering bevat. Vervolgens wordt hier de naamruimte toegevoegd die “std” is. Hierna gebruiken we het trefwoord ‘tuple’ waarin we drie gegevenstypen plaatsen, twee zwevende gegevenstypen en het resterende gegevenstype ‘char’. Daaronder gebruiken we het trefwoord ‘return’ om de waarden in te pakken om een ​​tupel te retourneren.

Nu gebruiken we de ‘paar’-methode om meerdere waarden te retourneren. In deze ‘paar’-methode plaatsen we de gegevenstypen van twee variabelen, en beide zijn hier’ zwevend. De variabelen heten “float_1” en “float_2”. Vervolgens pakken we twee waarden in om terug te keren naar de “paren”. Hierna roepen we hier de “main()” aan en declareren we vervolgens twee “float”-variabelen met de naam “f_1, f_2”. De variabele “char” wordt hier ook gedeclareerd als “myChar”. Vervolgens pakken we de waarden uit die worden geretourneerd door de functie 'My_Tuple()'.







Daaronder slaan we de geretourneerde waarden in paren op. We slaan ”4.99, 8.98” op in de functie “My_Tuple” en “6.86, 3.22” in de functie “My_Pair”. Vervolgens gebruiken we de “cout” die alle informatie afdrukt die erin is geschreven.



Code1:



#include
gebruik makend van naamruimte soa ;
tupel < vlot , vlot , verkoold > Mijn_Tupel ( vlot f_1, vlot f_2 ) {
opbrengst make_tuple ( f_2, f_1, '$' ) ;
}
paar < vlot , vlot > Mijn_paar ( vlot fa, vlot f_b ) {
opbrengst maak_paar ( f_b, f_a ) ;
}
int voornaamst ( ) {
vlot f_1,f_2 ;
verkoold mijnChar ;
stropdas ( f_1, f_2, mijnChar ) = Mijn_Tuple ( 4,99 , 8,98 ) ;
paar nieuw_p = Mijn_paar ( 6,86 , 3.22 ) ;
uit << 'Waarden die we krijgen door tupels: ' ;
uit << f_1 << ' ' << f_2 << ' ' << mijnChar << eindl ;
uit << 'Waarden die we per paar krijgen: ' ;
uit << nieuwe P. Eerst << ' ' << nieuwe P. seconde ;
opbrengst 0 ;
}

Uitvoer :





De waarden die we hier verkrijgen door gebruik te maken van de “tuples” en de “pair” methode worden hieronder weergegeven. Houd er rekening mee dat hier meerdere waarden worden geretourneerd.



Voorbeeld 2: Gebruik van de aanwijzers

We geven de parameters samen met hun adressen door in de functie “vergelijken” hier. We voegen “value_1” en “value_2” toe van het type “int” en het “int* g_Address, int* s_Address”. Hierna gebruiken we de “if”-voorwaarde waarin we een voorwaarde toevoegen dat de “waarde_1” groter is dan “waarde_2”. Als hieraan is voldaan, wordt de volgende instructie uitgevoerd. Als dit niet het geval is, negeert het de verklaring die eronder is toegevoegd en gaat het naar het “else” gedeelte. Nu, na het aanroepen van de “main()”, declareren we vier nieuwe variabelen met de namen “g_value”, “s_value”, “newValue1” en “newValue2”.

Hierna drukken we een bericht af om de cijfers in te voeren en plaatsen we vervolgens “cin”, dat twee waarden van de gebruiker krijgt. De waarden die de gebruiker invoert, worden respectievelijk opgeslagen in de variabelen “newValue1” en “newValue2”. Hierna roepen we de functie “compare()” aan die we eerder hebben gemaakt en geven we er vier parameters aan door. Vervolgens geven we het resultaat weer na het uitvoeren van de functie 'vergelijken' en worden het grotere getal en het kleinere getal weergegeven van de getallen die de gebruiker invoert.

Code2:

#include
gebruik makend van naamruimte soa ;
leegte vergelijken ( int waarde_1, int waarde_2, int * g_Adres, int * s_Adres )
{
als ( waarde_1 > waarde_2 ) {
* g_Adres = waarde_1 ;
* s_Adres = waarde_2 ;
}
anders {
* g_Adres = waarde_2 ;
* s_Adres = waarde_1 ;
}
}
int voornaamst ( )
{
int g_waarde, s_waarde, nieuweWaarde_1, nieuweWaarde_2 ;
uit << 'Voer twee cijfers in: ' <> nieuweWaarde_1 >> nieuweWaarde_2 ;
vergelijken ( nieuweWaarde_1, nieuweWaarde_2, & g_waarde, & s_waarde ) ;
uit << ' \N Het grotere getal is ' << g_waarde << ' en het kleinere getal is '
<< s_waarde ;
opbrengst 0 ;
}

Uitvoer :
De gebruiker voert hier “86” en “23” in. Nadat u op 'Enter' hebt gedrukt, wordt het resultaat weergegeven. Op deze manier krijgen we meerdere waarden.

Voorbeeld 3: Gebruik van de array

We maken hier de functie “ComputeComparison()” waarin we twee variabelen invoegen, “num_1” en “num_2”, als het “int”-type en ook een array met de naam “my_arr[]”. Hierna hebben we de “if”-voorwaarde die controleert of “num_1” groter is dan “num_2” of niet. Als dit waar is, wordt “num_1” toegewezen aan “my_arr[0]” en “num_2” aan “my_arr[1]”. Maar als de voorwaarde niet waar is, worden de uitspraken na “else” uitgevoerd, waarbij we “num_2” toewijzen aan “my_arr[0]” en “num_1” aan “my_arr[1]”.

Hierna roepen we hier de “main()” aan en declareren vervolgens nog twee int-variabelen: “newNum_1” en “newNum_2”. Hierna wordt een array met grootte “2” gedeclareerd. Hierna krijgen we twee getallen van de gebruiker met behulp van “cin” en roepen vervolgens de functie “ComputeComparison()” aan en geven het volgende resultaat weer. Het retourneert hier dus meerdere waarden.

Code 3:

#include
gebruik makend van naamruimte soa ;
leegte Bereken vergelijking ( int num_1, int num_2, int mijn_arr [ ] )
{

als ( getal_1 > getal_2 ) {
mijn_arr [ 0 ] = getal_1 ;
mijn_arr [ 1 ] = getal_2 ;
}
anders {
mijn_arr [ 0 ] = getal_2 ;
mijn_arr [ 1 ] = getal_1 ;
}
}

int voornaamst ( )
{
int nieuwNum_1, nieuwNum_2 ;
int mijn_arr [ 2 ] ;

uit << 'Voer twee cijfers in ter vergelijking' <> nieuwNum_1 >> nieuwNum_2 ;
Bereken vergelijking ( nieuwNum_1, nieuwNum_2, mijn_arr ) ;
uit << ' \N Het grotere getal is ' << mijn_arr [ 0 ] << ' en de '
'kleiner aantal is' << mijn_arr [ 1 ] ;

opbrengst 0 ;
}

Uitvoer :
We typen hier zowel “54” als “98” en drukken vervolgens op “Enter” om het resultaat weer te geven. Het toont zowel de grotere als de kleinere getallen van de getallen die we hebben ingevoerd.

Voorbeeld 4: Gebruik maken van de Tupels

Hier zijn twee headerbestanden opgenomen: 'tuple' en 'iostream'. Vervolgens wordt hier de naamruimte “std” geplaatst. Vervolgens gebruiken we het trefwoord ‘tuple’ en voegen we twee gegevenstypen in die ‘int’ zijn. Hierna maken we een functie met de naam “findingValues()” en geven we “intValue_1” en “intValue2” door als parameters.

Vervolgens wordt de “if” geplaatst waar we de voorwaarde “intValue_1 < intValue_2” typen. Daaronder gebruiken we het trefwoord “return” en plaatsen we de functie “make_tuple()” waarin beide variabelen worden toegevoegd als de parameter “intValue_1, intValue2_”. Dan hebben we het gedeelte “else” waarin we “return” opnieuw plaatsen, samen met de functie “make_tuple()”. Maar hier plaatsen we eerst de “intValue_2” en vervolgens de “intValue1”. Nu roepen we de “main()” aan en initialiseren we de “new_value1” met “5” en “new_value2” met “28”.

Hieronder declareren we nog twee variabelen van het type “int” met de namen “groter” en “kleiner”. Vervolgens plaatsen we de functie “tie()” en geven we de “kleinere, grotere” variabelen door als parameter en roepen hier ook de functie “findingValues()” aan. Hierna drukken we beide waarden af: de grotere en de kleinere getallen.

Code 4:

#include
#include
gebruik makend van naamruimte soa ;
tuple  findingValues ( int intWaarde_1, int intWaarde_2 )
{
als ( intWaarde_1 < intWaarde_2 ) {
opbrengst make_tuple ( intWaarde_1 , intWaarde_2 ) ;
}
anders {
opbrengst make_tuple ( intWaarde_2 , intWaarde_1 ) ;
}
}
int voornaamst ( )
{
int nieuwe_waarde1 = 5 , nieuwe_waarde2 = 28 ;
int groter, kleiner ;
stropdas ( kleiner, groter ) = Waarden vinden ( nieuwe_waarde1, nieuwe_waarde2 ) ;
afdrukkenf ( 'Het grootste getal is %d en de '
'kleiner getal is %d' ,
groter, kleiner ) ;
opbrengst 0 ;
}

Uitvoer :

De getallen die we aan onze code toevoegen, geven tegelijkertijd de grotere en kleinere waarden weer. Op deze manier kunnen we eenvoudig meerdere waarden in onze code retourneren.

Conclusie

Deze handleiding gaat over het “retourneren van meerdere waarden” in C++-codes. We hebben dit idee in deze handleiding grondig onderzocht en drie technieken besproken die helpen bij het retourneren van meerdere waarden in de C++-programmering. We hebben uitgelegd dat meerdere waarden worden geretourneerd door gebruik te maken van de tupels, paren, pointers en array-technieken. Al deze technieken worden hier uitgebreid beschreven.