C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో టుపుల్ అంటే ఏమిటి?
సి++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని టుపుల్ అనేది ఆర్డర్ చేసిన అంశాల జాబితాను కలిగి ఉండే వస్తువు. ఇది ఒక మార్పులేని డేటా రకం, అంటే టుపుల్‌లోని విలువలు ఏ సమయంలోనైనా మార్చబడవు. టుపుల్ యొక్క విలువ కామాతో వేరు చేయబడిన రౌండ్ () బ్రాకెట్లలో ఇవ్వబడుతుంది మరియు సూచిక యొక్క సూచన ద్వారా యాక్సెస్ చేయవచ్చు. టుపుల్‌లో అనేక విధులు నిర్వహించవచ్చు, అనగా, get(), swap(), tuple_size(), మరియు మొదలైనవి. తదుపరి విభాగాలలో, మేము ఉదాహరణల సహాయంతో 4 ఫంక్షన్‌ల పనిని వివరిస్తాము.
ఉదాహరణ 1:
ఈ ఉదాహరణలో, మేము make_tuple() ఫంక్షన్‌ని ఉపయోగించి టుపుల్‌ని సృష్టిస్తాము. టుపుల్‌కి విలువను కేటాయించడానికి సి++ ప్రోగ్రామ్‌లో make_tuple() ఉపయోగించబడుతుంది. టుపుల్‌కు కేటాయించాల్సిన విలువలు టుపుల్‌లో ప్రకటించబడిన క్రమంలోనే ఉండాలి. c++ ప్రోగ్రామ్‌లో make_tuple() ఫంక్షన్ ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి దిగువ జోడించిన కోడ్‌ని చూద్దాం.
సిన్ మరియు కౌట్ వంటి ప్రామాణిక ఇన్‌పుట్ మరియు అవుట్‌పుట్ ఫంక్షన్‌లను ఉపయోగించడానికి ప్రోగ్రామ్‌లో ‘ఇన్‌క్లూడ్
#include
#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
టుపుల్ < చార్ , int , int , చార్ , తేలుతుంది > t ;
t = తయారు_టుపుల్ ( 'a' , 75 , 5 , 'తో' , 5.5 ) ;
తిరిగి 0 ;
}
దిగువ స్క్రీన్‌షాట్‌లో ఇవ్వబడిన ఫలిత అవుట్‌పుట్‌ను తనిఖీ చేయండి:
ప్రోగ్రామ్ ద్వారా తిరిగి ఏమీ లేదని గమనించండి. టుపుల్ విలువలను ప్రింట్ చేద్దాం.
ఉదాహరణ 2:
ఈ ఉదాహరణలో, get() ఫంక్షన్ దాని విలువలను ప్రదర్శించడానికి tupleలో ఉపయోగించబడుతుంది. tuples విలువలు c++ ప్రోగ్రామింగ్ భాషలో get() ఫంక్షన్‌తో మాత్రమే ముద్రించబడతాయి. దిగువ కోడ్ చూడండి.
మేము మునుపటి ఉదాహరణలో ఉపయోగించిన అదే కోడ్ మరియు నమూనా డేటాను ఉపయోగించామని గమనించండి. make_tuple() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా, విలువలు tupleకి విజయవంతంగా కేటాయించబడతాయి. 0 నుండి ప్రారంభమయ్యే సూచిక సంఖ్యను సూచించడం ద్వారా టుపుల్ యొక్క విలువలను యాక్సెస్ చేయడానికి get() ఫంక్షన్ ఉపయోగించబడుతుంది. ప్రతి సూచిక సంఖ్య get() ఫంక్షన్‌కు ఇవ్వబడుతుంది మరియు tuple యొక్క అన్ని విలువలు కౌట్ స్టేట్‌మెంట్‌తో ముద్రించబడతాయి.
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
టుపుల్ < చార్ , int , int , చార్ , తేలుతుంది > t ;
t = తయారు_టుపుల్ ( 'a' , 75 , 5 , 'తో' , 5.5 ) ;
int i ;
కోట్ << 'టుపుల్ యొక్క విలువలు: ' ;
కోట్ << పొందండి < 0 > ( t ) << '' << పొందండి < 1 > ( t ) << '' << పొందండి < రెండు > ( t )
<< '' << పొందండి < 3 > ( t ) << '' << పొందండి < 4 > ( t ) << endl ;
తిరిగి 0 ;
}
దిగువన ఇచ్చిన స్క్రీన్‌షాట్‌లో ఈ కోడ్ అవుట్‌పుట్‌ని చూడండి:
get() ఫంక్షన్ విలువలను టుపుల్‌కు కేటాయించిన క్రమంలోనే ప్రింట్ చేస్తుంది.
ఉదాహరణ 3:
ఈ ఉదాహరణలో, మేము tuple_size() ఫంక్షన్ యొక్క పనిని ప్రదర్శిస్తాము. నమూనా ఉదాహరణ సహాయంతో, tuple_size ఫంక్షన్‌ని ఉపయోగించి టుపుల్ పరిమాణాన్ని ఎలా పొందాలో మేము వివరిస్తాము. క్రింద ఇచ్చిన కోడ్‌ని తనిఖీ చేయండి.
కోడ్ యొక్క మిగిలిన పంక్తులు మునుపటి ఉదాహరణలలో ఉపయోగించిన విధంగానే ఉంటాయి. ఇక్కడ tuple_size ఫంక్షన్ tuple యొక్క పరిమాణాన్ని పొందుతుంది. 'decltype' అనేది ఇచ్చిన వ్యక్తీకరణ రకాన్ని పరిశీలించడానికి ఉపయోగించే డిక్లేర్డ్ రకాన్ని సూచిస్తుంది.
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
టుపుల్ < చార్ , int , int , చార్ , తేలుతుంది > t ;
t = తయారు_టుపుల్ ( 'a' , 75 , 5 , 'తో' , 5.5 ) ;
int i ;
కోట్ << 'టుపుల్ పరిమాణం =' ;
కోట్ << టుపుల్_పరిమాణం < decltype ( t ) > :: విలువ << endl ;
తిరిగి 0 ;
}
మీరు ఈ కోడ్‌ని అమలు చేసినప్పుడు, కింది అవుట్‌పుట్ ఉత్పత్తి చేయబడుతుంది:
మేము tupleకి 5 విలువలను కేటాయించాము మరియు tuple_size() ఫంక్షన్ కూడా tuple 5 యొక్క పరిమాణాన్ని అందించింది.
ఉదాహరణ 4:
మేము tuple_cat() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా tuplesని సంగ్రహించవచ్చు మరియు వాటి నుండి కొత్త tupleని సృష్టించవచ్చు. ఇక్కడ, మేము tuple_cat() ఫంక్షన్ యొక్క వినియోగాన్ని రెండు టుపుల్స్‌లను కలపడానికి ప్రదర్శిస్తాము.
క్రింద ఇవ్వబడిన కోడ్‌లో, మేము రెండు టుపుల్స్ t1 మరియు t2ని ప్రకటించాము మరియు ప్రతి టుపుల్‌కు 3/3 విలువలను కేటాయించాము. అప్పుడు, మేము tuple_cat() ఫంక్షన్‌ని ఉపయోగించి రెండు tuplesని కలిపి మరియు వాటి నుండి కొత్త tupleని సృష్టించాము. ఆ తర్వాత, మేము get() ఫంక్షన్‌ని ఉపయోగించి అన్ని tuples విలువలను ప్రింట్ చేసాము. tuple_cat() ఫంక్షన్ సంగ్రహించవలసిన టుపుల్‌లను తీసుకుంటుంది, ప్రతి టుపుల్‌కు కేటాయించిన విలువలను మిళితం చేస్తుంది మరియు దాని నుండి కొత్త టుపుల్‌ను సృష్టిస్తుంది.
టుపుల్స్ t1 మరియు t2 లు 3/3 విలువలను కలిగి ఉన్నాయని మరియు మేము ప్రతి విలువను ఇండెక్స్ 0 నుండి ఇండెక్స్ 2కి సూచించడం ద్వారా get() ఫంక్షన్‌ని ఉపయోగించి ప్రింట్ చేసాము. అయినప్పటికీ, అవి సంగ్రహించబడినప్పుడు, మొత్తం విలువలు 6 అవుతుంది. కాబట్టి, మనకు అవసరం సూచికను 0 నుండి 5 వరకు ముద్రించడానికి, తద్వారా అన్ని విలువలు ముద్రించబడతాయి. దిగువ అవుట్‌పుట్‌ని తనిఖీ చేయండి మరియు టుపుల్ t1పై 3 విలువలు ముద్రించబడిందని గమనించండి; 3 విలువలు tuple 2పై ముద్రించబడ్డాయి. అయితే, కొత్త tupleలో సంయోగం చేయబడిన విలువలు 6 అయినందున 6 విలువలు tuple 3తో ముద్రించబడతాయి.
#include#include
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
టుపుల్ < చార్ , int , తేలుతుంది > t1 ( 'a' , 75 , 6.7 ) ;
టుపుల్ < int , చార్ , తేలుతుంది > t2 ( 10 , 't' , 77.9 ) ;
దానంతట అదే t3 = టుపుల్_పిల్లి ( t1,t2 ) ;
కోట్ << 'మొదటి టుపుల్ కలిగి ఉంటుంది = ' ;
కోట్ << పొందండి < 0 > ( t1 ) << '' << పొందండి < 1 > ( t1 ) << '' << పొందండి < రెండు > ( t1 ) << endl << endl ;
కోట్ << 'రెండవ టుపుల్ కలిగి ఉంటుంది = ' ;
కోట్ << పొందండి < 0 > ( t2 ) << '' << పొందండి < 1 > ( t2 ) << '' << పొందండి < రెండు > ( t2 ) << endl << endl ;
కోట్ << 'కొత్త టుపుల్ అంటే =' ;
కోట్ << పొందండి < 0 > ( t3 ) << '' << పొందండి < 1 > ( t3 ) << '' << పొందండి < రెండు > ( t3 ) << ''
<< పొందండి < 3 > ( t3 ) << '' << పొందండి < 4 > ( t3 ) << '' << పొందండి < 5 > ( t3 ) << endl ;
తిరిగి 0 ;
}
ఇక్కడ అవుట్‌పుట్ ఉంది:
ముగింపు
ఈ కథనం c++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లోని టుపుల్స్ యొక్క అవలోకనం. c++లోని టుపుల్ అనేది ఒకే సమయంలో వివిధ డేటా రకాల విలువలను కలిగి ఉండే మార్పులేని వస్తువు. టుపుల్స్ మార్పులేనివి కాబట్టి వాటిని అమలు చేసే ఏ సమయంలోనైనా మార్చలేరు లేదా సవరించలేరు. ఒక నిర్దిష్ట ఫలితాన్ని సాధించడానికి టుపుల్స్‌పై అనేక విధులు నిర్వహించవచ్చు, వాటిలో 4 నమూనా ఉదాహరణలతో ఈ వ్యాసంలో ప్రదర్శించబడ్డాయి.