Exempel 1: Användning av tupler/par
Låt oss göra en praktisk demonstration för att returnera flera värden i C++. Här använder vi tupler/par-teknikerna för att hjälpa till att returnera flera värden i vår kod. C++ tillhandahåller olika rubrikfiler som vi måste inkludera i vår kod. Vi inkluderar 'bits/stdc++.h' här eftersom det innehåller alla bibliotek i C++-programmeringen. Sedan läggs namnutrymmet till här som är 'std'. Efter detta använder vi nyckelordet 'tuple' där vi placerar tre datatyper, två flytdatatyper och den återstående 'char' datatypen. Under den använder vi nyckelordet 'return' för att packa värdena för att returnera en tuppel.
Nu använder vi 'par'-metoden för att returnera flera värden. I denna 'par'-metod lägger vi två variablers datatyper, och båda är 'flytande' här. Variablerna heter 'float_1' och 'float_2'. Sedan packar vi två värden för att återgå till 'paren'. Efter detta anropar vi 'main()' här och deklarerar sedan två 'float'-variabler med namnet 'f_1, f_2'. Variabeln 'char' deklareras här också som 'myChar'. Sedan packar vi upp värdena som returneras av funktionen 'My_Tuple()'.
Under detta lagrar vi de returnerade värdena i par. Vi lagrar ”4.99, 8.98” i funktionen ”My_Tuple” och ”6.86, 3.22” i funktionen ”My_Pair”. Sedan använder vi 'cout' som skriver ut all information som är skriven inuti den.
Kod 1:
#include
använder sig av namnutrymme std ;
tupel < flyta , flyta , röding > My_Tuple ( flyta f_1, flyta f_2 ) {
lämna tillbaka make_tuple ( f_2, f_1, '$' ) ;
}
par < flyta , flyta > Mitt_par ( flyta fa, flyta f_b ) {
lämna tillbaka make_pair ( f_b, f_a ) ;
}
int huvud ( ) {
flyta f_1,f_2 ;
röding myChar ;
slips ( f_1, f_2, myChar ) = My_Tuple ( 4,99 , 8,98 ) ;
par ny_s = Mitt_par ( 6,86 , 3.22 ) ;
cout << 'Värden vi får av tuplar:' ;
cout << f_1 << ' ' << f_2 << ' ' << myChar << endl ;
cout << 'Värden vi får av par:' ;
cout << ny_s. först << ' ' << ny_s. andra ;
lämna tillbaka 0 ;
}
Produktion :
Värdena som vi får här genom att använda 'tupler' och 'par'-metoden visas i det följande. Observera att det returnerar flera värden här.
Exempel 2: Använda pekarna
Vi skickar parametrarna tillsammans med deras adresser i funktionen 'jämför' här. Vi lägger till 'value_1' och 'value_2' av typen 'int' och 'int* g_Address, int* s_Address'. Efter detta använder vi villkoret 'om' där vi lägger till ett villkor att 'värde_1' är större än 'värde_2'. Om detta är uppfyllt exekveras följande uttalande. Om den inte är det, ignorerar den påståendet som läggs till under detta och går mot 'annat'-delen. Nu, efter att ha anropat 'main()', deklarerar vi fyra nya variabler med namnen 'g_value', 's_value', 'newValue1' och 'newValue2'.
Efter detta skriver vi ut ett meddelande för att ange siffrorna och placerar sedan 'cin' som får två värden från användaren. Värdena som användaren anger sparas i variablerna 'newValue1' respektive 'newValue2'. Efter detta anropar vi funktionen 'compare()' som vi tidigare skapat och skickar fyra parametrar till den. Sedan visar vi resultatet efter att ha utfört funktionen 'jämför' och det visar det större antalet och det mindre antalet från de siffror som användaren anger.
Kod 2:
#includeanvänder sig av namnutrymme std ;
tomhet jämföra ( int värde_1, int värde_2, int * g_Adress, int * s_Adress )
{
om ( värde_1 > värde_2 ) {
* g_Adress = värde_1 ;
* s_Adress = värde_2 ;
}
annan {
* g_Adress = värde_2 ;
* s_Adress = värde_1 ;
}
}
int huvud ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << 'Vänligen ange två siffror: ' <> nyttVärde_1 >> nyttVärde_2 ;
jämföra ( newValue_1, newValue_2, & g_värde, & s_värde ) ;
cout << ' \n Det större antalet är ' << g_värde << 'och det mindre antalet är'
<< s_värde ;
lämna tillbaka 0 ;
}
Produktion :
Användaren anger '86' och '23' här. Efter att ha tryckt på 'Enter' visas resultatet. På så sätt får vi flera värden.
Exempel 3: Använda Arrayen
Vi skapar funktionen 'ComputeComparison()' här där vi infogar två variabler, 'num_1' och 'num_2', som typen 'int' och även en array med namnet 'my_arr[]'. Efter detta har vi 'om'-villkoret som kontrollerar om 'num_1' är större än 'num_2' eller inte. Om det är sant tilldelas 'num_1' till 'my_arr[0]' och 'num_2' tilldelas 'my_arr[1]'. Men om villkoret inte är sant, exekveras satserna efter 'else' där vi tilldelar 'num_2' till 'my_arr[0]' och 'num_1' till 'my_arr[1]'.
Efter detta anropar vi 'main()' här och deklarerar sedan ytterligare två int-variabler: 'newNum_1' och 'newNum_2'. Efter detta deklareras en array av storleken '2'. Efter detta får vi två nummer från användaren med hjälp av ”cin” och anropar sedan funktionen ”ComputeComparison()” och visar följande resultat. Så det returnerar flera värden här.
Kod 3:
#includeanvänder sig av namnutrymme std ;
tomhet ComputeComparison ( int num_1, int num_2, int min_arr [ ] )
{
om ( num_1 > num_2 ) {
min_arr [ 0 ] = num_1 ;
min_arr [ 1 ] = num_2 ;
}
annan {
min_arr [ 0 ] = num_2 ;
min_arr [ 1 ] = num_1 ;
}
}
int huvud ( )
{
int newNum_1, newNum_2 ;
int min_arr [ 2 ] ;
cout << 'Ange två siffror för jämförelse' <> nyttNum_1 >> nyttNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \n Det större antalet är ' << min_arr [ 0 ] << ' och den '
'mindre nummer är' << min_arr [ 1 ] ;
lämna tillbaka 0 ;
}
Produktion :
Vi skriver både '54' och '98' här och trycker sedan på 'Enter' för att visa resultatet. Den visar de större såväl som de mindre siffrorna från siffrorna som vi angav.
Exempel 4: Använda Tuples
Två rubrikfiler ingår här: 'tuple' och 'iostream'. Därefter läggs 'std'-namnrymden här. Därefter använder vi nyckelordet 'tuple' och infogar två datatyper som är 'int'. Efter detta skapar vi en funktion med namnet 'findingValues()' och skickar 'intValue_1' och 'intValue2' som parametrar.
Sedan placeras 'om' där vi skriver villkoret 'intValue_1 < intValue_2'. Under det använder vi nyckelordet 'return' och placerar funktionen 'make_tuple()' där båda variablerna läggs till som parametern 'intValue_1, intValue2_'. Sedan har vi 'annat'-delen där vi placerar 'retur' igen tillsammans med funktionen 'make_tuple()'. Men här placerar vi 'intValue_2' först och sedan 'intValue1'. Nu anropar vi 'main()' och initialiserar 'new_value1' med '5' och 'new_value2' med '28'.
I det följande deklarerar vi ytterligare två variabler av typen 'int' med namnen 'större' och 'mindre'. Sedan placerar vi 'tie()'-funktionen och skickar 'mindre, större'-variablerna som parameter och anropar även 'findingValues()'-funktionen här. Efter detta skriver vi ut båda värdena: de större och de mindre talen.
Kod 4:
#inkludera#inkludera
använder sig av namnutrymme std ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
om ( intValue_1 < intValue_2 ) {
lämna tillbaka make_tuple ( intValue_1 , intValue_2 ) ;
}
annan {
lämna tillbaka make_tuple ( intValue_2 , intValue_1 ) ;
}
}
int huvud ( )
{
int nytt_värde1 = 5 , nytt_värde2 = 28 ;
int större, mindre ;
slips ( mindre, större ) = hitta värden ( nytt_värde1, nytt_värde2 ) ;
printf ( 'Det större antalet är %d och '
'mindre nummer är %d' ,
större, mindre ) ;
lämna tillbaka 0 ;
}
Produktion :
Siffrorna som vi lägger till i vår kod visar samtidigt de större och mindre värdena. På så sätt kan vi enkelt returnera flera värden i vår kod.
Slutsats
Den här guiden handlar om 'returnerande multipla värden' i C++-koder. Vi undersökte detta begrepp grundligt i den här guiden och diskuterade tre tekniker som hjälper till att returnera flera värden i C++-programmeringen. Vi förklarade att flera värden returneras genom att använda tupler, par, pekare och arraytekniker. Alla dessa tekniker beskrivs noggrant här.