Halimbawa 1: Paggamit ng Tuples/Pairs
Gumawa tayo ng ilang praktikal na demonstrasyon upang maibalik ang maramihang mga halaga sa C++. Dito, ginagamit namin ang mga diskarte sa tuple/pairs para makatulong na maibalik ang maraming value sa aming code. Nagbibigay ang C++ ng iba't ibang mga file ng header na kailangan naming isama sa aming code. Isinama namin ang 'bits/stdc++.h' dito dahil naglalaman ito ng lahat ng library ng C++ programming. Pagkatapos, ang namespace ay idinagdag dito na 'std'. Pagkatapos nito, ginagamit namin ang keyword na 'tuple' kung saan inilalagay namin ang tatlong uri ng data, dalawang uri ng float ng data, at ang natitirang isang uri ng data na 'char'. Sa ibaba nito, ginagamit namin ang keyword na 'return' para i-pack ang mga value para magbalik ng tuple.
Ngayon, ginagamit namin ang 'pair' na paraan upang magbalik ng maraming halaga. Sa paraang 'pair' na ito, naglalagay kami ng dalawang uri ng data ng variable, at pareho silang 'float' dito. Ang mga variable ay pinangalanang 'float_1' at 'float_2'. Pagkatapos, nag-pack kami ng dalawang halaga upang bumalik sa 'mga pares'. Pagkatapos nito, ginagamit namin ang 'pangunahing ()' dito at pagkatapos ay ipahayag ang dalawang variable na 'float' na may pangalan na 'f_1, f_2'. Ang variable na 'char' ay idineklara din dito bilang 'myChar'. Pagkatapos, i-unpack namin ang mga value na ibinalik ng function na 'My_Tuple()'.
Sa ibaba nito, iniimbak namin ang mga ibinalik na halaga nang pares. Iniimbak namin ang ”4.99, 8.98” sa function na “My_Tuple” at “6.86, 3.22” sa function na “My_Pair”. Pagkatapos, ginagamit namin ang 'cout' na nagpi-print ng lahat ng impormasyon na nakasulat sa loob nito.
Code 1:
#include
gamit namespace std ;
tuple < lumutang , lumutang , char > Aking_Tuple ( lumutang f_1, lumutang f_2 ) {
bumalik gumawa_tuple ( f_2, f_1, '$' ) ;
}
pares < lumutang , lumutang > Aking_Pares ( lumutang f_a, lumutang f_b ) {
bumalik gumawa_pares ( f_b, f_a ) ;
}
int pangunahing ( ) {
lumutang f_1,f_2 ;
char myChar ;
itali ( f_1, f_2, myChar ) = Aking_Tuple ( 4.99 , 8.98 ) ;
pares new_p = Aking_Pares ( 6.86 , 3.22 ) ;
cout << 'Mga halagang nakukuha natin sa pamamagitan ng mga tuple : ' ;
cout << f_1 << '' << f_2 << '' << myChar << endl ;
cout << 'Mga halagang nakukuha natin sa Pares: ' ;
cout << bagong_p. una << '' << bagong_p. pangalawa ;
bumalik 0 ;
}
Output :
Ang mga halaga na nakukuha namin dito sa pamamagitan ng paggamit ng 'tuples' at ang 'pair' na paraan ay ipinapakita sa sumusunod. Tandaan na nagbabalik ito ng maraming halaga dito.
Halimbawa 2: Paggamit ng mga Pointer
Ipinapasa namin ang mga parameter kasama ang kanilang mga address sa function na 'ihambing' dito. Nagdagdag kami ng 'value_1' at 'value_2' ng uri ng 'int' at ang 'int* g_Address, int* s_Address'. Pagkatapos nito, ginagamit namin ang kundisyon na 'kung' kung saan nagdaragdag kami ng kundisyon na ang 'value_1' ay mas malaki kaysa sa 'value_2'. Kung ito ay nasiyahan, ang sumusunod na pahayag ay isasagawa. Kung hindi, binabalewala nito ang pahayag na idinagdag sa ibaba nito at lumipat patungo sa 'ibang' bahagi. Ngayon, pagkatapos gamitin ang 'main()', idedeklara namin ang apat na bagong variable na may mga pangalang 'g_value', 's_value', 'newValue1', at 'newValue2'.
Pagkatapos nito, nag-print kami ng mensahe upang ipasok ang mga numero at pagkatapos ay ilagay ang 'cin' na nakakakuha ng dalawang halaga mula sa gumagamit. Ang mga value na ipinasok ng user ay naka-save sa mga variable na 'newValue1' at 'newValue2', ayon sa pagkakabanggit. Pagkatapos nito, tinawag namin ang function na 'compare()' na dati naming nilikha at ipinapasa ang apat na parameter dito. Pagkatapos, ipinapakita namin ang resulta pagkatapos isagawa ang function na 'ihambing' at ipinapakita nito ang mas malaking bilang at mas maliit na numero mula sa mga numerong iyon na ipinasok ng user.
Code 2:
#includegamit namespace std ;
walang bisa ihambing ( int halaga_1, int halaga_2, int * g_Address, int * s_Address )
{
kung ( halaga_1 > halaga_2 ) {
* g_Address = halaga_1 ;
* s_Address = halaga_2 ;
}
iba pa {
* g_Address = halaga_2 ;
* s_Address = halaga_1 ;
}
}
int pangunahing ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
cout << 'Pakilagay ang dalawang numero: ' <> newValue_1 >> newValue_2 ;
ihambing ( newValue_1, newValue_2, at g_value, at s_value ) ;
cout << ' \n Ang mas malaking bilang ay ' << g_value << 'at ang mas maliit na bilang ay'
<< s_value ;
bumalik 0 ;
}
Output :
Ilalagay ng user ang '86' at '23' dito. Pagkatapos ng pagpindot sa 'Enter', ipinapakita nito ang resulta. Sa ganitong paraan, nakakakuha tayo ng maraming halaga.
Halimbawa 3: Paggamit ng Array
Lumilikha kami ng function na 'ComputeComparison()' dito kung saan naglalagay kami ng dalawang variable, 'num_1' at 'num_2', bilang uri ng 'int' at isang array din na pinangalanang 'my_arr[]'. Pagkatapos nito, mayroon kaming kundisyon na 'kung' na nagsusuri kung ang 'num_1' ay mas malaki kaysa sa 'num_2' o hindi. Kung ito ay totoo, ang 'num_1' ay itinalaga sa 'my_arr[0]' at 'num_2' ay itinalaga sa 'my_arr[1]'. Ngunit kung hindi totoo ang kundisyon, ang mga pahayag pagkatapos ng 'iba' ay isinasagawa kung saan itinatalaga namin ang 'num_2' sa 'my_arr[0]' at 'num_1' sa 'my_arr[1]'.
Pagkatapos nito, tinatawag namin ang 'main()' dito at pagkatapos ay magdeklara ng dalawa pang int variable: 'newNum_1' at 'newNum_2'. Pagkatapos nito, idineklara ang isang hanay ng laki na '2'. Pagkatapos nito, nakakakuha kami ng dalawang numero mula sa user sa tulong ng 'cin' at pagkatapos ay tawagan ang function na 'ComputeComparison()' at ipakita ang sumusunod na resulta. Kaya, nagbabalik ito ng maraming halaga dito.
Code 3:
#includegamit namespace std ;
walang bisa ComputeComparison ( int num_1, int num_2, int my_arr [ ] )
{
kung ( num_1 > num_2 ) {
my_arr [ 0 ] = num_1 ;
my_arr [ 1 ] = num_2 ;
}
iba pa {
my_arr [ 0 ] = num_2 ;
my_arr [ 1 ] = num_1 ;
}
}
int pangunahing ( )
{
int newNum_1, newNum_2 ;
int my_arr [ 2 ] ;
cout << 'Mangyaring Magpasok ng dalawang numero para sa paghahambing ' <> bagongNum_1 >> bagongNum_2 ;
ComputeComparison ( newNum_1, newNum_2, my_arr ) ;
cout << ' \n Ang mas malaking bilang ay ' << my_arr [ 0 ] << ' at ang '
'mas maliit na numero ay' << my_arr [ 1 ] ;
bumalik 0 ;
}
Output :
Tina-type namin ang parehong '54' at '98' dito at pagkatapos ay pindutin ang 'Enter' upang ipakita ang resulta. Ipinapakita nito ang mas malaki gayundin ang mas maliliit na numero mula sa mga numerong ipinasok namin.
Halimbawa 4: Paggamit ng Tuples
Dalawang header file ang kasama dito: 'tuple' at 'iostream'. Susunod, ang 'std' namespace ay inilalagay dito. Susunod, ginagamit namin ang keyword na 'tuple' at nagpasok ng dalawang uri ng data na 'int'. Pagkatapos nito, gumawa kami ng function na may pangalang 'findingValues()' at ipinapasa ang 'intValue_1' at 'intValue2' bilang mga parameter nito.
Pagkatapos, inilalagay ang 'if' kung saan tina-type namin ang kundisyon na 'intValue_1 < intValue_2'. Sa ibaba nito, ginagamit namin ang keyword na 'return' at inilalagay ang function na 'make_tuple()' kung saan idinaragdag ang parehong variable bilang parameter na 'intValue_1, intValue2_'. Pagkatapos, mayroon kaming 'ibang' bahagi kung saan inilalagay namin muli ang 'return' kasama ang function na 'make_tuple()'. Ngunit dito, inilalagay muna namin ang 'intValue_2' at pagkatapos ay ang 'intValue1'. Ngayon, tinatawag namin ang 'pangunahing()' at sinisimulan ang 'new_value1' na may '5' at 'new_value2' na may '28'.
Sa mga sumusunod, nagdedeklara kami ng dalawa pang variable ng uri na 'int' na may mga pangalang 'greater' at 'smaller'. Pagkatapos, inilalagay namin ang function na 'tie()' at ipinapasa ang mga variable na 'mas maliit, mas malaki' bilang parameter at tinatawag din ang function na 'findingValues()' dito. Pagkatapos nito, i-print namin ang parehong mga halaga: ang mas malaki at ang mas maliit na mga numero.
Code 4:
#include#include
gamit namespace std ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
kung ( intValue_1 < intValue_2 ) {
bumalik gumawa_tuple ( intValue_1 , intValue_2 ) ;
}
iba pa {
bumalik gumawa_tuple ( intValue_2 , intValue_1 ) ;
}
}
int pangunahing ( )
{
int new_value1 = 5 , new_value2 = 28 ;
int mas malaki, mas maliit ;
itali ( mas maliit, mas malaki ) = findingValues ( new_value1, new_value2 ) ;
printf ( 'Ang mas malaking bilang ay %d at ang '
'mas maliit na numero ay %d' ,
mas malaki, mas maliit ) ;
bumalik 0 ;
}
Output :
Ang mga numero na idinaragdag namin sa aming code ay sabay-sabay na nagpapakita ng mas malaki at mas maliit na mga halaga. Sa ganitong paraan, madali naming maibabalik ang maraming halaga sa aming code.
Konklusyon
Ang gabay na ito ay tungkol sa 'nagbabalik ng maraming halaga' sa mga C++ code. Lubusan naming ginalugad ang ideyang ito sa gabay na ito at tinalakay ang tatlong pamamaraan na tumutulong sa pagbabalik ng maraming halaga sa C++ programming. Ipinaliwanag namin na maraming value ang ibinabalik sa pamamagitan ng paggamit ng mga tuple, pares, pointer, at mga diskarte sa array. Ang lahat ng mga pamamaraan na ito ay lubusang inilarawan dito.