ఉదాహరణ 1: టుపుల్స్/పెయిర్‌లను ఉపయోగించడం
C++లో బహుళ విలువలను అందించడానికి కొన్ని ఆచరణాత్మక ప్రదర్శన చేద్దాం. ఇక్కడ, మా కోడ్‌లో బహుళ విలువలను అందించడంలో సహాయపడటానికి మేము టుపుల్స్/పెయిర్స్ టెక్నిక్‌లను ఉపయోగిస్తాము. C++ మేము మా కోడ్‌లో చేర్చాల్సిన వివిధ హెడర్ ఫైల్‌లను అందిస్తుంది. C++ ప్రోగ్రామింగ్‌లోని అన్ని లైబ్రరీలను కలిగి ఉన్నందున మేము ఇక్కడ “bits/stdc++.h”ని చేర్చుతాము. అప్పుడు, నేమ్‌స్పేస్ ఇక్కడ జోడించబడింది, అది “std”. దీని తర్వాత, మేము మూడు డేటా రకాలు, రెండు ఫ్లోట్ డేటా రకాలు మరియు మిగిలిన ఒక 'చార్' డేటా రకాన్ని ఉంచే “tuple” కీవర్డ్‌ని ఉపయోగిస్తాము. దాని క్రింద, మేము టుపుల్‌ను తిరిగి ఇవ్వడానికి విలువలను ప్యాక్ చేయడానికి “రిటర్న్” కీవర్డ్‌ని ఉపయోగిస్తాము.
ఇప్పుడు, మేము బహుళ విలువలను అందించడానికి “పెయిర్” పద్ధతిని ఉపయోగిస్తాము. ఈ “పెయిర్” పద్ధతిలో, మేము రెండు వేరియబుల్ డేటా రకాలను ఉంచాము మరియు రెండూ ఇక్కడ “ఫ్లోట్”. వేరియబుల్స్‌కు “float_1” మరియు “float_2” అని పేరు పెట్టారు. అప్పుడు, మేము 'జతలకు' తిరిగి రావడానికి రెండు విలువలను ప్యాక్ చేస్తాము. దీని తర్వాత, మేము ఇక్కడ “ప్రధాన()”ని ప్రారంభించి, ఆపై “f_1, f_2” పేరుతో రెండు “ఫ్లోట్” వేరియబుల్‌లను ప్రకటిస్తాము. “char” వేరియబుల్ ఇక్కడ “myChar” గా కూడా ప్రకటించబడింది. అప్పుడు, మేము “My_Tuple()” ఫంక్షన్ ద్వారా అందించబడిన విలువలను అన్‌ప్యాక్ చేస్తాము.
దీని క్రింద, మేము తిరిగి వచ్చిన విలువలను జతలలో నిల్వ చేస్తాము. మేము “My_Tuple” ఫంక్షన్‌లో ”4.99, 8.98”ని మరియు “My_Pair” ఫంక్షన్‌లో “6.86, 3.22”ని నిల్వ చేస్తాము. అప్పుడు, మేము దాని లోపల వ్రాసిన మొత్తం సమాచారాన్ని ప్రింట్ చేసే 'కౌట్' ను ఉపయోగిస్తాము.
కోడ్ 1:
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
టుపుల్ < తేలుతుంది , తేలుతుంది , చార్ > నా_టుపుల్ ( తేలుతుంది f_1, తేలుతుంది f_2 ) {
తిరిగి తయారు_టుపుల్ ( f_2, f_1, '$' ) ;
}
జత < తేలుతుంది , తేలుతుంది > నా_జత ( తేలుతుంది f_a, తేలుతుంది f_b ) {
తిరిగి తయారు_జత ( f_b, f_a ) ;
}
int ప్రధాన ( ) {
తేలుతుంది f_1,f_2 ;
చార్ myChar ;
టై ( f_1, f_2, myChar ) = నా_టుపుల్ ( 4.99 , 8.98 ) ;
జత new_p = నా_జత ( 6.86 , 3.22 ) ;
కోట్ << 'టుపుల్స్ ద్వారా మనం పొందే విలువలు :' ;
కోట్ << f_1 << '' << f_2 << '' << myChar << endl ;
కోట్ << 'పెయిర్ ద్వారా మనం పొందే విలువలు:' ;
కోట్ << కొత్త_p. ప్రధమ << '' << కొత్త_p. రెండవ ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
“టుపుల్స్” మరియు “పెయిర్” పద్ధతిని ఉపయోగించడం ద్వారా మనం ఇక్కడ పొందే విలువలు క్రింది వాటిలో ప్రదర్శించబడతాయి. ఇది ఇక్కడ బహుళ విలువలను చూపుతుందని గమనించండి.
ఉదాహరణ 2: పాయింటర్లను ఉపయోగించడం
మేము ఇక్కడ 'పోల్చండి' ఫంక్షన్‌లో వాటి చిరునామాలతో పాటు పారామితులను పాస్ చేస్తాము. మేము 'int' రకం 'value_1' మరియు 'value_2' మరియు 'int* g_Address, int* s_Address'ని జోడిస్తాము. దీని తర్వాత, 'value_1' 'value_2' కంటే ఎక్కువగా ఉండే షరతును జోడించే 'if' కండిషన్‌ను మేము ఉపయోగిస్తాము. ఇది సంతృప్తి చెందితే, కింది ప్రకటన అమలు చేయబడుతుంది. అది కాకపోతే, ఇది దిగువన జోడించబడిన ప్రకటనను విస్మరిస్తుంది మరియు 'వేరే' భాగం వైపుకు వెళ్లండి. ఇప్పుడు, “main()”ని ప్రారంభించిన తర్వాత, మేము “g_value”, “s_value”, “newValue1” మరియు “newValue2” పేర్లతో నాలుగు కొత్త వేరియబుల్‌లను ప్రకటిస్తాము.
దీని తర్వాత, మేము సంఖ్యలను నమోదు చేయడానికి ఒక సందేశాన్ని ప్రింట్ చేసి, ఆపై వినియోగదారు నుండి రెండు విలువలను పొందే 'సిన్'ని ఉంచుతాము. వినియోగదారు నమోదు చేసే విలువలు వరుసగా 'newValue1' మరియు 'newValue2' వేరియబుల్స్‌లో సేవ్ చేయబడతాయి. దీని తరువాత, మేము ఇంతకుముందు సృష్టించిన “compare()” ఫంక్షన్‌ని పిలుస్తాము మరియు దానిలోకి నాలుగు పారామితులను పాస్ చేస్తాము. అప్పుడు, మేము 'పోల్చండి' ఫంక్షన్ చేసిన తర్వాత ఫలితాన్ని ప్రదర్శిస్తాము మరియు వినియోగదారు నమోదు చేసిన సంఖ్యల నుండి ఎక్కువ సంఖ్య మరియు చిన్న సంఖ్యను చూపుతుంది.
కోడ్ 2:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
శూన్యం సరిపోల్చండి ( int విలువ_1, int విలువ_2, int * g_చిరునామా, int * s_చిరునామా )
{
ఉంటే ( విలువ_1 > విలువ_2 ) {
* g_చిరునామా = విలువ_1 ;
* s_చిరునామా = విలువ_2 ;
}
లేకపోతే {
* g_చిరునామా = విలువ_2 ;
* s_చిరునామా = విలువ_1 ;
}
}
int ప్రధాన ( )
{
int g_value, s_value, newValue_1, newValue_2 ;
కోట్ << 'దయచేసి రెండు సంఖ్యలను నమోదు చేయండి:' <> కొత్త విలువ_1 >> కొత్త విలువ_2 ;
సరిపోల్చండి ( కొత్తవిలువ_1, కొత్తవిలువ_2, & g_value, & s_value ) ;
కోట్ << ' \n ఎక్కువ సంఖ్య ' << g_value << 'మరియు చిన్న సంఖ్య'
<< s_value ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
వినియోగదారు ఇక్కడ '86' మరియు '23'ని నమోదు చేస్తారు. 'Enter' నొక్కిన తర్వాత, అది ఫలితాన్ని ప్రదర్శిస్తుంది. ఈ విధంగా, మేము బహుళ విలువలను పొందుతాము.
ఉదాహరణ 3: అర్రేని ఉపయోగించడం
మేము ఇక్కడ “కంప్యూట్ కంపారిజన్()” ఫంక్షన్‌ను సృష్టిస్తాము, దీనిలో మేము “num_1” మరియు “num_2” అనే రెండు వేరియబుల్‌లను “int” రకంగా మరియు “my_arr[]” పేరుతో ఒక శ్రేణిని చొప్పించాము. దీని తర్వాత, 'num_1' 'num_2' కంటే ఎక్కువగా ఉందో లేదో తనిఖీ చేసే 'if' షరతును మేము కలిగి ఉన్నాము. ఇది నిజమైతే, “num_1” “my_arr[0]”కి కేటాయించబడుతుంది మరియు “num_2” “my_arr[1]”కి కేటాయించబడుతుంది. కానీ షరతు నిజం కాకపోతే, “else” తర్వాత స్టేట్‌మెంట్‌లు అమలు చేయబడతాయి, దీనిలో మేము “num_2”ని “my_arr[0]”కి మరియు “num_1”ని “my_arr[1]”కి కేటాయిస్తాము.
దీని తర్వాత, మేము ఇక్కడ “main()” అని పిలుస్తాము మరియు ఆపై మరో రెండు పూర్ణాంక వేరియబుల్‌లను ప్రకటిస్తాము: “newNum_1” మరియు “newNum_2”. దీని తరువాత, పరిమాణం '2' యొక్క శ్రేణి ప్రకటించబడింది. దీని తరువాత, మేము 'సిన్' సహాయంతో వినియోగదారు నుండి రెండు సంఖ్యలను పొందుతాము మరియు ఆపై 'కంప్యూట్ కంపారిజన్()' ఫంక్షన్‌కు కాల్ చేసి, క్రింది ఫలితాన్ని ప్రదర్శిస్తాము. కాబట్టి, ఇది ఇక్కడ బహుళ విలువలను అందిస్తుంది.
కోడ్ 3:
#ఉపయోగించి నేమ్‌స్పేస్ std ;
శూన్యం కంప్యూట్ కంపారిజన్ ( int సంఖ్య_1, int సంఖ్య_2, int నా_అర్ [ ] )
{
ఉంటే ( సంఖ్య_1 > సంఖ్య_2 ) {
నా_అర్ [ 0 ] = సంఖ్య_1 ;
నా_అర్ [ 1 ] = సంఖ్య_2 ;
}
లేకపోతే {
నా_అర్ [ 0 ] = సంఖ్య_2 ;
నా_అర్ [ 1 ] = సంఖ్య_1 ;
}
}
int ప్రధాన ( )
{
int newNum_1, newNum_2 ;
int నా_అర్ [ 2 ] ;
కోట్ << 'దయచేసి పోలిక కోసం రెండు సంఖ్యలను నమోదు చేయండి' <> newNum_1 >> newNum_2 ;
కంప్యూట్ కంపారిజన్ ( newNum_1, newNum_2, my_arr ) ;
కోట్ << ' \n ఎక్కువ సంఖ్య ' << నా_అర్ [ 0 ] << ' ఇంకా '
'చిన్న సంఖ్య' << నా_అర్ [ 1 ] ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
మేము ఇక్కడ “54” మరియు “98” రెండింటినీ టైప్ చేసి, ఫలితాన్ని ప్రదర్శించడానికి “Enter” నొక్కండి. ఇది మనం నమోదు చేసిన సంఖ్యల నుండి ఎక్కువ మరియు చిన్న సంఖ్యలను చూపుతుంది.
ఉదాహరణ 4: టుపుల్స్‌ని ఉపయోగించడం
రెండు హెడర్ ఫైల్‌లు ఇక్కడ చేర్చబడ్డాయి: “tuple” మరియు “iostream”. తరువాత, “std” నేమ్‌స్పేస్ ఇక్కడ ఉంచబడింది. తరువాత, మేము “tuple” కీవర్డ్‌ని ఉపయోగిస్తాము మరియు “int” అనే రెండు డేటా రకాలను ఇన్సర్ట్ చేస్తాము. దీని తర్వాత, మేము “findingValues()” పేరుతో ఒక ఫంక్షన్‌ని సృష్టించి, దాని పరామితులుగా “intValue_1” మరియు “intValue2”ని పాస్ చేస్తాము.
అప్పుడు, మనం 'intValue_1 < intValue_2' షరతును టైప్ చేసే చోట 'if' ఉంచబడుతుంది. దాని క్రింద, మేము “రిటర్న్” కీవర్డ్‌ని ఉపయోగిస్తాము మరియు “make_tuple()” ఫంక్షన్‌ను ఉంచుతాము, దీనిలో రెండు వేరియబుల్స్ “intValue_1, intValue2_” పరామితిగా జోడించబడతాయి. అప్పుడు, మేము 'make_tuple()' ఫంక్షన్‌తో పాటు మళ్లీ 'రిటర్న్'ని ఉంచే 'else' భాగాన్ని కలిగి ఉన్నాము. కానీ ఇక్కడ, మేము ముందుగా “intValue_2”ని ఉంచుతాము మరియు తర్వాత “intValue1”ని ఉంచుతాము. ఇప్పుడు, మేము “main()” అని పిలుస్తాము మరియు “new_value1”ని “5”తో మరియు “new_value2”ని “28”తో ప్రారంభించాము.
కింది వాటిలో, మేము 'int' రకం యొక్క మరో రెండు వేరియబుల్స్‌ను 'గ్రేటర్' మరియు 'చిన్న' పేర్లతో ప్రకటిస్తాము. అప్పుడు, మేము “టై()” ఫంక్షన్‌ను ఉంచుతాము మరియు “చిన్న, ఎక్కువ” వేరియబుల్స్‌ను పారామీటర్‌గా పాస్ చేస్తాము మరియు ఇక్కడ “findingValues()” ఫంక్షన్‌ని కూడా పిలుస్తాము. దీని తరువాత, మేము రెండు విలువలను ప్రింట్ చేస్తాము: ఎక్కువ మరియు చిన్న సంఖ్యలు.
కోడ్ 4:
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
tuple findingValues ( int intValue_1, int intValue_2 )
{
ఉంటే ( intValue_1 < intValue_2 ) {
తిరిగి తయారు_టుపుల్ ( intValue_1 , intValue_2 ) ;
}
లేకపోతే {
తిరిగి తయారు_టుపుల్ ( intValue_2 , intValue_1 ) ;
}
}
int ప్రధాన ( )
{
int కొత్త_విలువ1 = 5 , new_value2 = 28 ;
int ఎక్కువ, చిన్నది ;
టై ( చిన్నది, ఎక్కువ ) = విలువలను కనుగొనడం ( కొత్త_విలువ1, కొత్త_విలువ2 ) ;
printf ( 'ఎక్కువ సంఖ్య %d మరియు '
'చిన్న సంఖ్య %d' ,
ఎక్కువ, చిన్నది ) ;
తిరిగి 0 ;
}
అవుట్‌పుట్ :
మేము మా కోడ్‌కు జోడించే సంఖ్యలు ఏకకాలంలో ఎక్కువ మరియు చిన్న విలువలను ప్రదర్శిస్తాయి. ఈ విధంగా, మన కోడ్‌లో బహుళ విలువలను సులభంగా తిరిగి ఇవ్వవచ్చు.
ముగింపు
ఈ గైడ్ C++ కోడ్‌లలో “బహుళ విలువలను తిరిగి ఇవ్వడం” గురించి. మేము ఈ గైడ్‌లో ఈ భావనను పూర్తిగా అన్వేషించాము మరియు C++ ప్రోగ్రామింగ్‌లో బహుళ విలువలను తిరిగి ఇవ్వడంలో సహాయపడే మూడు పద్ధతులను చర్చించాము. టుపుల్స్, జంటలు, పాయింటర్‌లు మరియు అర్రే టెక్నిక్‌లను ఉపయోగించడం ద్వారా బహుళ విలువలు అందించబడతాయని మేము వివరించాము. ఈ పద్ధతులన్నీ ఇక్కడ క్షుణ్ణంగా వివరించబడ్డాయి.