C++ ప్రోగ్రామింగ్‌లో, స్టాండర్డ్ టెంప్లేట్ లైబ్రరీ (STL) నుండి “std::any” ఒక వైవిధ్యమైన డేటాను నిర్వహించడానికి డైనమిక్ టైపింగ్‌ను పరిచయం చేస్తుంది. సాంప్రదాయ కంటెయినర్‌ల వలె కాకుండా, “std:: any” అనేది ఏదైనా రకం విలువలను ఒకే కంటైనర్‌లో నిల్వ చేయడానికి అనుమతిస్తుంది, డేటా రకాలు తెలియని లేదా రన్‌టైమ్‌లో మారుతున్న దృశ్యాలలో సౌలభ్యాన్ని మెరుగుపరుస్తుంది. ఈ రకం-అజ్ఞేయ విధానం సాధారణ ప్రోగ్రామింగ్‌ను ప్రోత్సహిస్తుంది, ఇది రకం భద్రతను కొనసాగిస్తూ మరింత అనుకూలమైన మరియు వ్యక్తీకరణ కోడ్‌ను రూపొందించడానికి డెవలపర్‌లకు అధికారం ఇస్తుంది. ఈ అన్వేషణలో, మేము 'std:: ఏదైనా' యొక్క లక్షణాలు, దాని వినియోగ నమూనాలు మరియు బలమైన మరియు సౌకర్యవంతమైన C++ కోడ్‌ను వ్రాయడంలో దాని పాత్రను వివరించే ఆచరణాత్మక ఉదాహరణలను పరిశీలిస్తాము.
ఉదాహరణ 1: Std:: ఏదైనా యొక్క ప్రాథమిక వినియోగం
ముందుగా, 'std:: any' యొక్క ప్రాథమిక వినియోగాన్ని ప్రదర్శించడానికి సూటిగా ఉదాహరణను అన్వేషిద్దాం. వివిధ రకాల పారామితులను ఆమోదించడానికి మీకు ఫంక్షన్ అవసరమయ్యే దృష్టాంతాన్ని పరిగణించండి:
కోడ్ స్నిప్పెట్ ఇక్కడ ఉంది:
#
#<ఏదైనా> చేర్చండి
శూన్య ప్రక్రియ ఏదైనా ( const std:: ఏదైనా & విలువ ) {
ఉంటే ( విలువ.ఉంది_విలువ ( ) ) {
std::cout << 'నిల్వ చేసిన విలువ రకం:' << విలువ.రకం ( ) .పేరు ( ) << std::endl;
ఉంటే ( విలువ.రకం ( ) == టైపిడ్ ( int ) ) {
std::cout << 'విలువ: ' << std:: any_cast < int > ( విలువ ) << std::endl;
} లేకపోతే ఉంటే ( విలువ.రకం ( ) == టైపిడ్ ( రెట్టింపు ) ) {
std::cout << 'విలువ: ' << std:: any_cast < రెట్టింపు > ( విలువ ) << std::endl;
} లేకపోతే ఉంటే ( విలువ.రకం ( ) == టైపిడ్ ( std:: స్ట్రింగ్ ) ) {
std::cout << 'విలువ: ' << std:: any_cast < std:: స్ట్రింగ్ > ( విలువ ) << std::endl;
} లేకపోతే {
std::cout << 'మద్దతు లేని రకం!' << std::endl;
}
} లేకపోతే {
std::cout << 'std:: any లో విలువ నిల్వ చేయబడలేదు.' << std::endl;
}
}
పూర్ణాంక ప్రధాన ( ) {
ప్రక్రియ ఏదైనా ( 42 ) ;
ప్రక్రియ ఏదైనా ( 3.14 ) ;
ప్రక్రియ ఏదైనా ( std:: స్ట్రింగ్ ( 'హలో, std:: ఏదైనా!' ) ) ;
ప్రక్రియ ఏదైనా ( 4.5f ) ; // మద్దతు లేదు రకం
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము “std:: any” సూచనను పారామీటర్‌గా తీసుకొని దాని కంటెంట్‌ని పరిశీలించే “processAny” ఫంక్షన్‌ని నిర్వచించాము. ఫంక్షన్ లోపల, మేము మొదట “std:: ఏదైనా” వేరియబుల్ has_value()ని ఉపయోగించి నిల్వ చేసిన విలువను కలిగి ఉందో లేదో తనిఖీ చేస్తాము. విలువ ఉన్నట్లయితే, మేము టైప్().పేరు()ని ఉపయోగించి నిల్వ చేయబడిన విలువ రకాన్ని నిర్ధారిస్తాము మరియు దాని రకం ఆధారంగా సంబంధిత విలువను ప్రింట్ చేయడానికి కొనసాగిస్తాము. ప్రధాన విధి 'processAny' యొక్క ప్రయోజనాన్ని వివిధ రకాలతో కాల్ చేయడం ద్వారా ప్రదర్శిస్తుంది: ఒక పూర్ణాంకం (42), డబుల్ (3.14), మరియు స్ట్రింగ్ ('హలో, std:: ఏదైనా!'). ఫంక్షన్ ప్రతి రకాన్ని తగిన విధంగా నిర్వహిస్తుంది మరియు సంబంధిత విలువలను ముద్రిస్తుంది. అయితే, ఈ ఉదాహరణలో మద్దతు లేని ఫ్లోటింగ్-పాయింట్ నంబర్ (4.5f)ని ప్రాసెస్ చేయడానికి ప్రయత్నిస్తున్నప్పుడు, ప్రోగ్రామ్ రకానికి మద్దతు లేదని సూచించడం ద్వారా పరిస్థితిని చక్కగా నిర్వహిస్తుంది.
ఉత్పత్తి చేయబడిన అవుట్‌పుట్:
'std:: any' వివిధ డేటా రకాల డైనమిక్ హ్యాండ్లింగ్‌ను ఎలా ప్రారంభిస్తుందో ఇది చూపిస్తుంది, ఇది C++లో జెనరిక్ ప్రోగ్రామింగ్ కోసం బహుముఖ సాధనంగా చేస్తుంది.
ఉదాహరణ 2: వినియోగదారు నిర్వచించిన రకాలను నిల్వ చేయడం
ప్రామాణిక టెంప్లేట్ లైబ్రరీ (STL)లోని ఈ డైనమిక్ రకం కస్టమ్ డేటా స్ట్రక్చర్‌లను సజావుగా ఎలా కల్పిస్తుందో రెండవ ఉదాహరణ విశ్లేషిస్తుంది. వినియోగదారు నిర్వచించిన రకం, పాయింట్ స్ట్రక్చర్‌పై దృష్టి సారిస్తూ, అటువంటి నిర్మాణాల యొక్క సందర్భాలను “std:: ఏదైనా” ఎలా నిర్వహిస్తుందో మేము ప్రదర్శిస్తాము.
ఇక్కడ కోడ్ ఉంది:
##<ఏదైనా> చేర్చండి
తరగతి MyClass {
ప్రజా:
నా తరగతి ( పూర్ణాంక విలువ ) : సమాచారం ( విలువ ) { }
ప్రింట్‌డేటా శూన్యం ( ) స్థిరంగా {
std::cout << 'MyClassలో డేటా:' << సమాచారం << std::endl;
}
ప్రైవేట్:
int డేటా;
} ;
పూర్ణాంక ప్రధాన ( ) {
std:: any anyObject = MyClass ( 42 ) ;
ఉంటే ( anyObject.has_value ( ) ) {
దానంతట అదే & myClassInstance = std:: any_cast < నా తరగతి &> ( ఏదైనా వస్తువు ) ;
myClassInstance.printData ( ) ;
} లేకపోతే {
std::cout << 'std:: any లో విలువ నిల్వ చేయబడలేదు.' << std::endl;
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ స్నిప్పెట్‌లో, “MyClass” అనే వినియోగదారు నిర్వచించిన తరగతితో “std:: any” రకాన్ని ఉపయోగించి వివరించడానికి మేము ఒక సాధారణ ఉదాహరణను సృష్టిస్తాము. తరగతిలో, ఈ డేటా విలువను ప్రదర్శించడానికి “డేటా” అనే ప్రైవేట్ మెంబర్ వేరియబుల్ మరియు printData() అనే పబ్లిక్ పద్ధతి ఉన్నాయి. పూర్ణాంకం విలువ పాస్ చేయబడింది మరియు కన్స్ట్రక్టర్‌లోని “డేటా” సభ్యునికి కేటాయించబడుతుంది.
“ప్రధాన” ఫంక్షన్‌లో, మేము 42 ప్రారంభ విలువతో “MyClass” యొక్క ఆబ్జెక్ట్‌ను ఇన్‌స్టాంటియేట్ చేసి, ఆపై దానిని “yyClass” అనే “std:: any” వేరియబుల్‌లో నిల్వ చేస్తాము. ఇది వినియోగదారు నిర్వచించిన తరగతుల ఉదంతాలను ఉంచడానికి “std:: any” యొక్క సామర్థ్యాన్ని ప్రదర్శిస్తుంది.
దీన్ని అనుసరించి, has_value() పద్ధతిని ఉపయోగించి 'ఏదైనా ఆబ్జెక్ట్' విలువను కలిగి ఉందో లేదో తనిఖీ చేయడానికి మేము 'if' స్టేట్‌మెంట్‌ను ఉపయోగిస్తాము. విలువ ఉంటే, మేము 'std:: any_cast'ని ఉపయోగించి నిల్వ చేసిన వస్తువును తిరిగి పొందుతాము. 'std:: any_cast' నిల్వ చేయబడిన వస్తువును 'MyClass' యొక్క సూచనకు ప్రసారం చేయడానికి 'MyClass&' టెంప్లేట్ ఆర్గ్యుమెంట్‌తో ఉపయోగించబడుతుంది. ఈ సూచన, “myClassInstance”, అప్పుడు printData() పద్ధతిని కాల్ చేయడానికి ఉపయోగించబడుతుంది, ఇది “std::any”లో నిల్వ చేయబడిన వినియోగదారు నిర్వచించిన రకాన్ని యాక్సెస్ చేయగల మరియు ఆపరేట్ చేయగల సామర్థ్యాన్ని ప్రదర్శిస్తుంది.
“std::any”లో ఎటువంటి విలువ నిల్వ చేయబడకపోతే, మేము దీనిని సూచించే సందేశాన్ని ముద్రిస్తాము. ఈ షరతులతో కూడిన తనిఖీ 'std:: any' వేరియబుల్ ఖాళీగా ఉండే సందర్భాలను మేము నిర్వహిస్తామని నిర్ధారిస్తుంది.
ఇక్కడ అవుట్‌పుట్ ఉంది:
ఉదాహరణ 3: మిశ్రమ రకాల కంటైనర్
ప్రోగ్రామింగ్‌లో, “మిశ్రమ-రకం కంటైనర్” అనేది విభిన్నమైన, సంభావ్యంగా సంబంధం లేని డేటా రకాల మూలకాలను కలిగి ఉండే సామర్థ్యం ఉన్న డేటా నిర్మాణాన్ని సూచిస్తుంది. కంపైల్ సమయంలో డేటా రకాలు తెలియని లేదా ప్రోగ్రామ్ అమలు సమయంలో డైనమిక్‌గా మారుతున్న దృశ్యాలతో వ్యవహరించేటప్పుడు ఈ సౌలభ్యం విలువైనది. C++లో, “std:: any” ఈ భావనను ఉదహరిస్తుంది, వివిధ రకాల విలువలను నిల్వ చేయడానికి ఒకే కంటైనర్‌ను సృష్టించడాన్ని అనుమతిస్తుంది.
మేము వివిధ రకాలను కలిగి ఉండే కంటైనర్‌ను సృష్టించే దృష్టాంతాన్ని అన్వేషిద్దాం:
##<ఏదైనా> చేర్చండి
#
పూర్ణాంక ప్రధాన ( ) {
std:: వెక్టర్ < std:: ఏదైనా > మిశ్రమ కంటైనర్;
mixedContainer.push_back ( 42 ) ;
mixedContainer.push_back ( 3.14 ) ;
mixedContainer.push_back ( std:: స్ట్రింగ్ ( 'హలో' ) ) ;
mixedContainer.push_back ( నిజం ) ;
కోసం ( స్థిర ఆటో & మూలకం: మిశ్రమ కంటైనర్ ) {
ఉంటే ( మూలకం.రకం ( ) == టైపిడ్ ( int ) ) {
std::cout << 'పూర్ణ సంఖ్య: ' << std:: any_cast < int > ( మూలకం ) << std::endl;
} లేకపోతే ఉంటే ( మూలకం.రకం ( ) == టైపిడ్ ( రెట్టింపు ) ) {
std::cout << 'డబుల్:' << std:: any_cast < రెట్టింపు > ( మూలకం ) << std::endl;
} లేకపోతే ఉంటే ( మూలకం.రకం ( ) == టైపిడ్ ( std:: స్ట్రింగ్ ) ) {
std::cout << 'స్ట్రింగ్:' << std:: any_cast < std:: స్ట్రింగ్ > ( మూలకం ) << std::endl;
} లేకపోతే ఉంటే ( మూలకం.రకం ( ) == టైపిడ్ ( బూల్ ) ) {
std::cout << 'బూలియన్:' << std:: any_cast < బూల్ > ( మూలకం ) << std::endl;
} లేకపోతే {
std::cout << 'తెలియని రకం' << std::endl;
}
}
తిరిగి 0 ;
}
ఈ దృష్టాంతంలో, మేము C++ మరియు “std:: any” లక్షణాన్ని ఉపయోగించి మిశ్రమ-రకం కంటైనర్ భావనను ప్రదర్శిస్తాము. మేము విభిన్న డేటా రకాల మూలకాలను ఉంచడానికి మా కంటైనర్‌గా పనిచేయడానికి “మిక్స్డ్కంటైనర్” పేరుతో “std::vector
మేము 'ఫర్' లూప్‌ని ఉపయోగించి 'మిక్స్డ్కంటైనర్' ద్వారా పునరావృతం చేస్తున్నప్పుడు, ప్రతి మూలకం యొక్క డేటా రకాన్ని డైనమిక్‌గా గుర్తించడానికి మేము టైప్() ఫంక్షన్‌ని ఉపయోగిస్తాము. “std:: any_cast”ని ఉపయోగించి, మేము వాటి రకాల ఆధారంగా సంబంధిత విలువలను సంగ్రహించి ప్రింట్ చేస్తాము. ఉదాహరణకు, మూలకం 'పూర్ణాంక' రకంగా ఉంటే, మేము దానిని పూర్ణాంకంగా ముద్రిస్తాము. ఇది 'డబుల్' రకం అయితే, మేము దానిని డబుల్‌గా ప్రింట్ చేస్తాము మరియు మొదలైనవి.
ఉత్పత్తి చేయబడిన అవుట్‌పుట్ ఇక్కడ ఉంది:
ఉదాహరణ 4: Std:: ఏదైనాతో నిర్వహించడంలో లోపం
'std:: any'ని ఉపయోగిస్తున్నప్పుడు లోపాలను నిర్వహించడం అనేది రకానికి మద్దతు ఇస్తుందా లేదా విలువ నిల్వ చేయబడిందా అని తనిఖీ చేయడం. ఈ ఉదాహరణలో, మేము మద్దతు లేని రకాలను ఎలా నిర్వహించాలో ప్రదర్శిస్తాము:
##<ఏదైనా> చేర్చండి
పూర్ణాంక ప్రధాన ( ) {
std:: any myAny = 42 ;
ప్రయత్నించండి {
డబుల్ విలువ = std:: any_cast < రెట్టింపు > ( నా ఏదైనా ) ;
std::cout << 'విలువ: ' << విలువ << std::endl;
} క్యాచ్ ( const std::bad_any_cast & అది ) {
std::cerr << 'లోపం:' << ఇ.ఏమి ( ) << std::endl;
}
తిరిగి 0 ;
}
మేము పూర్ణాంక రకం 42 విలువతో “std:: any” వేరియబుల్, “myAny”ని ప్రారంభించడం ద్వారా ప్రారంభిస్తాము. తదుపరి “ప్రయత్నించండి” బ్లాక్‌లో, “std:: any_cast
ఈ సంభావ్య లోపాన్ని సునాయాసంగా నిర్వహించడానికి, మేము 'std::bad_any_cast' యొక్క నిర్దిష్ట మినహాయింపు రకాన్ని క్యాచ్ చేయడానికి రూపొందించబడిన 'క్యాచ్' బ్లాక్‌తో మినహాయింపు నిర్వహణను అమలు చేస్తాము. తారాగణం విఫలమైతే, 'క్యాచ్' బ్లాక్ సక్రియం చేయబడుతుంది మరియు లోపం యొక్క స్వభావాన్ని తెలియజేయడానికి మేము 'std::cerr'ని ఉపయోగించి ఎర్రర్ సందేశాన్ని రూపొందిస్తాము. ఈ ఎర్రర్-హ్యాండ్లింగ్ వ్యూహం 'std:: any' వేరియబుల్‌లో నిల్వ చేయబడిన వాస్తవ రకంతో ప్రయత్నించిన రకం తారాగణం ఘర్షణకు గురయ్యే పరిస్థితులను మా ప్రోగ్రామ్ సునాయాసంగా నిర్వహించగలదని నిర్ధారిస్తుంది.
ముగింపు
ఈ కథనంలో, మేము C++లో “std::any” అప్లికేషన్‌లను అన్వేషించాము, విభిన్న రకాల విలువల కోసం C++లో పరిచయం చేయబడిన డైనమిక్ రకం కంటైనర్. మేము వివిధ ఉదాహరణల ద్వారా దాని బహుముఖ ప్రజ్ఞను ప్రదర్శించాము, ప్రాథమిక వినియోగం నుండి వినియోగదారు నిర్వచించిన రకాలు మరియు భిన్నమైన సేకరణలను నిర్వహించడం వరకు ఉన్న దృశ్యాలను ప్రదర్శిస్తాము. కంపైల్ సమయంలో డేటా రకం తెలియని సందర్భాల్లో మేము దాని ఆచరణాత్మక అనువర్తనాన్ని ప్రదర్శించాము. అదనంగా, మేము లోపం-నిర్వహణ పద్ధతుల గురించి అన్వేషించాము, మినహాయింపు నిర్వహణ ద్వారా మద్దతు లేని రకాలను సునాయాసంగా నిర్వహించడం యొక్క ప్రాముఖ్యతను నొక్కిచెప్పాము.