Příklad 1: Využití n-tic/párů
Udělejme nějakou praktickou ukázku vrácení více hodnot v C++. Zde využíváme techniky n-tic/párů, abychom pomohli vrátit více hodnot v našem kódu. C++ poskytuje různé hlavičkové soubory, které musíme zahrnout do našeho kódu. Zde uvádíme „bits/stdc++.h“, protože obsahuje všechny knihovny programování C++. Poté se sem přidá jmenný prostor, který je „std“. Poté použijeme klíčové slovo „tuple“, do kterého umístíme tři datové typy, dva datové typy float a zbývající jeden datový typ „char“. Pod ním používáme klíčové slovo „return“ ke sbalení hodnot, aby se vrátila n-tice.
Nyní používáme metodu „pair“ k vrácení více hodnot. V této „párové“ metodě vložíme dva datové typy proměnných a oba jsou zde „plovoucí“. Proměnné se jmenují „float_1“ a „float_2“. Poté sbalíme dvě hodnoty, abychom se vrátili k „párům“. Poté zde vyvoláme „main()“ a poté deklarujeme dvě „float“ proměnné se jménem „f_1, f_2“. Proměnná „char“ je zde také deklarována jako „myChar“. Poté rozbalíme hodnoty, které vrací funkce „My_Tuple()“.
Pod tím ukládáme vrácené hodnoty ve dvojicích. Uložíme „4,99, 8,98“ ve funkci „My_Tuple“ a „6,86, 3,22“ ve funkci „My_Pair“. Poté použijeme „cout“, který vytiskne všechny informace, které jsou v něm zapsány.
Kód 1:
#include
použitím jmenný prostor std ;
tuple < plovák , plovák , char > My_Tuple ( plovák f_1, plovák f_2 ) {
vrátit se make_tuple ( f_2, f_1, '$' ) ;
}
pár < plovák , plovák > Můj_pár ( plovák f_a, plovák f_b ) {
vrátit se make_pair ( f_b, f_a ) ;
}
int hlavní ( ) {
plovák f_1, f_2 ;
char myChar ;
kravata ( f_1, f_2, myChar ) = My_Tuple ( 4,99 , 8,98 ) ;
pár nový_p = Můj_pár ( 6,86 , 3.22 ) ;
cout << 'Hodnoty, které získáme pomocí n-tic:' ;
cout << f_1 << '' << f_2 << '' << myChar << endl ;
cout << 'Hodnoty, které získáme párem:' ;
cout << nový_p. První << '' << nový_p. druhý ;
vrátit se 0 ;
}
Výstup :
Hodnoty, které zde získáme použitím metody „n-tice“ a „páru“, jsou zobrazeny níže. Všimněte si, že zde vrací více hodnot.
Příklad 2: Využití ukazatelů
Zde předáme parametry spolu s jejich adresami ve funkci „porovnat“. Přidáme „hodnota_1“ a „hodnota_2“ typu „int“ a „int* g_Address, int* s_Address“. Poté použijeme podmínku „if“, ve které přidáme podmínku, že „hodnota_1“ je větší než „hodnota_2“. Pokud je splněno, provede se následující příkaz. Pokud tomu tak není, ignoruje prohlášení, které je přidáno pod toto, a přesune se k části „jinak“. Nyní, po vyvolání „main()“, deklarujeme čtyři nové proměnné s názvy „g_value“, „s_value“, „newValue1“ a „newValue2“.
Poté vytiskneme zprávu pro zadání čísel a poté umístíme „cin“, který dostane od uživatele dvě hodnoty. Hodnoty, které uživatel zadá, se uloží do proměnných „newValue1“ a „newValue2“. Poté zavoláme funkci „compare()“, kterou jsme dříve vytvořili, a předáme jí čtyři parametry. Poté po provedení funkce „porovnat“ zobrazíme výsledek a zobrazí větší a menší číslo z čísel, která uživatel zadá.
Kód 2:
#includepoužitím jmenný prostor std ;
prázdnota porovnat ( int hodnota_1, int hodnota_2, int * g_Address, int * s_Adresa )
{
-li ( hodnota_1 > hodnota_2 ) {
* g_Adresa = hodnota_1 ;
* s_Adresa = hodnota_2 ;
}
jiný {
* g_Adresa = hodnota_2 ;
* s_Adresa = hodnota_1 ;
}
}
int hlavní ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << 'Zadejte prosím dvě čísla: ' <> newValue_1 >> newValue_2 ;
porovnat ( newValue_1, newValue_2, & g_value, & s_hodnota ) ;
cout << ' \n Větší číslo je ' << g_value << 'a menší číslo je'
<< s_hodnota ;
vrátit se 0 ;
}
Výstup :
Uživatel zde zadá „86“ a „23“. Po stisknutí „Enter“ se zobrazí výsledek. Tímto způsobem získáme více hodnot.
Příklad 3: Využití pole
Vytvoříme zde funkci „ComputeComparison()“, do které vložíme dvě proměnné „num_1“ a „num_2“ jako typ „int“ a také pole s názvem „my_arr[]. Poté máme podmínku „if“, která kontroluje, zda je „číslo_1“ větší než „číslo_2“ nebo ne. Pokud je to pravda, „num_1“ je přiřazeno „my_arr[0]“ a „num_2“ je přiřazeno „my_arr[1]“. Ale pokud podmínka není pravdivá, provedou se příkazy za „else“, ve kterých přiřadíme „num_2“ k „my_arr[0]“ a „num_1“ k „my_arr[1]“.
Poté zde zavoláme „main()“ a deklarujeme další dvě proměnné int: „newNum_1“ a „newNum_2“. Poté je deklarováno pole velikosti „2“. Poté získáme od uživatele dvě čísla pomocí „cin“ a poté zavoláme funkci „ComputeComparison()“ a zobrazíme následující výsledek. Takže zde vrací více hodnot.
Kód 3:
#includepoužitím jmenný prostor std ;
prázdnota ComputeComparison ( int číslo_1, int číslo_2, int můj_arr [ ] )
{
-li ( číslo_1 > číslo_2 ) {
můj_arr [ 0 ] = číslo_1 ;
můj_arr [ 1 ] = číslo_2 ;
}
jiný {
můj_arr [ 0 ] = číslo_2 ;
můj_arr [ 1 ] = číslo_1 ;
}
}
int hlavní ( )
{
int newNum_1, newNum_2 ;
int můj_arr [ 2 ] ;
cout << 'Zadejte prosím dvě čísla pro srovnání' <> newNum_1 >> newNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \n Větší číslo je ' << můj_arr [ 0 ] << 'a'
'menší číslo je' << můj_arr [ 1 ] ;
vrátit se 0 ;
}
Výstup :
Zde zadáme „54“ i „98“ a poté stiskneme „Enter“ pro zobrazení výsledku. Zobrazuje větší i menší čísla z čísel, která jsme zadali.
Příklad 4: Využití n-tic
Jsou zde zahrnuty dva soubory záhlaví: „tuple“ a „iostream“. Dále je zde umístěn jmenný prostor „std“. Dále použijeme klíčové slovo „tuple“ a vložíme dva datové typy, které jsou „int“. Poté vytvoříme funkci s názvem „findingValues()“ a jako její parametry předáme „intValue_1“ a „intValue2“.
Potom se „if“ umístí tam, kde zadáme podmínku „intValue_1 < intValue_2“. Pod ním použijeme klíčové slovo „return“ a umístíme funkci „make_tuple()“, do které jsou obě proměnné přidány jako parametr „intValue_1, intValue2_“. Pak máme část „else“, do které znovu umístíme „return“ spolu s funkcí „make_tuple()“. Zde však nejprve umístíme „intValue_2“ a poté „intValue1“. Nyní zavoláme „main()“ a inicializujeme „new_value1“ s „5“ a „new_value2“ s „28“.
V následujícím textu deklarujeme další dvě proměnné typu „int“ s názvy „větší“ a „menší“. Poté umístíme funkci „tie()“ a předáme proměnné „menší, větší“ jako parametr a také zde zavoláme funkci „findingValues()“. Poté vytiskneme obě hodnoty: větší a menší číslo.
Kód 4:
#include#include
použitím jmenný prostor std ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
-li ( intValue_1 < intValue_2 ) {
vrátit se make_tuple ( intValue_1 , intValue_2 ) ;
}
jiný {
vrátit se make_tuple ( intValue_2 , intValue_1 ) ;
}
}
int hlavní ( )
{
int nová_hodnota1 = 5 , nová_hodnota2 = 28 ;
int větší, menší ;
kravata ( menší, větší ) = findValues ( nová_hodnota1, nová_hodnota2 ) ;
printf ( 'Větší číslo je %d a '
'menší číslo je %d' ,
větší, menší ) ;
vrátit se 0 ;
}
Výstup :
Čísla, která přidáme do našeho kódu, současně zobrazují větší a menší hodnoty. Tímto způsobem můžeme snadno vrátit více hodnot v našem kódu.
Závěr
Tato příručka je o „vracení více hodnot“ v kódech C++. Tento pojem jsme důkladně prozkoumali v této příručce a diskutovali jsme o třech technikách, které pomáhají při vracení více hodnot v programování v C++. Vysvětlili jsme, že více hodnot se vrací pomocí technik n-tic, párů, ukazatelů a polí. Všechny tyto techniky jsou zde podrobně popsány.