C++ ప్రోగ్రామింగ్ డొమైన్‌లో, సమర్థత మరియు పనితీరుకు ప్రాధాన్యత ఇవ్వడం చాలా ముఖ్యం. 'std::string_view' క్లాస్, C++17లో పరిచయం చేయబడింది, సాంప్రదాయ స్ట్రింగ్ మానిప్యులేషన్‌కు బహుముఖ మరియు మెమరీ-సమర్థవంతమైన ప్రత్యామ్నాయాన్ని అందిస్తుంది. దాని ప్రధాన భాగంలో, “std::string_view” అనేది అక్షరాల శ్రేణికి స్వంతం కాని సూచన, సాధారణంగా పెద్ద స్ట్రింగ్ యొక్క సబ్‌స్ట్రింగ్‌ను సూచిస్తుంది. దాని డేటాను కలిగి ఉన్న మరియు అంతర్గతంగా మెమరీని నిర్వహించే “std::string” వలె కాకుండా, “std::string_view” అంతర్లీన డేటాను స్వంతం చేసుకోకుండా పనిచేస్తుంది. ఈ లక్షణం మెమరీని కాపీ చేయడం లేదా నిర్వహించడం యొక్క ఓవర్‌హెడ్ అవాంఛనీయమైన దృశ్యాలకు ఇది చాలా విలువైనదిగా చేస్తుంది. ఈ కథనంలో, C++లో “std::string_view” వినియోగాన్ని అర్థం చేసుకోవడానికి మేము విభిన్న ఉదాహరణలను విశ్లేషిస్తాము.
ఉదాహరణ 1: సమర్థవంతమైన స్ట్రింగ్ హ్యాండ్లింగ్
ఆధునిక C++ అభివృద్ధిలో, పనితీరు మరియు వనరుల వినియోగాన్ని ఆప్టిమైజ్ చేయడానికి సమర్థవంతమైన స్ట్రింగ్ హ్యాండ్లింగ్ కీలకం. ఇది మెమరీ రీలొకేషన్ లేదా డూప్లికేషన్ అవసరం లేకుండా స్ట్రింగ్‌ల యొక్క సమర్థవంతమైన యాక్సెస్ మరియు మానిప్యులేషన్‌ను అనుమతిస్తుంది. ఈ భావనను వివరించడానికి, ఒక ఆచరణాత్మక ఉదాహరణను పరిశీలిద్దాం.
కింది కోడ్ స్నిప్పెట్‌ను పరిగణించండి:
#
#
శూన్యమైన processStringView ( std::string_view strView ) {
std::cout << 'పొడవు:' << strView.length ( ) << std::endl;
std::cout << 'విషయము: ' << strవ్యూ << std::endl;
}
పూర్ణాంక ప్రధాన ( ) {
std::string originalString = 'సమర్థవంతమైన స్ట్రింగ్ హ్యాండ్లింగ్' ;
std::string_view viewOfString ( అసలైన స్ట్రింగ్ ) ;
processStringView ( వీక్షణ ఆఫ్ స్ట్రింగ్ ) ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, 'std::string_view'ని పారామీటర్‌గా తీసుకునే 'processStringView' ఫంక్షన్‌ని మేము కలిగి ఉన్నాము. ఫంక్షన్ స్టాండర్డ్ అవుట్‌పుట్ ఉపయోగించి స్ట్రింగ్ వ్యూ యొక్క పొడవు మరియు కంటెంట్‌ను ప్రింట్ చేస్తుంది. ప్రధాన విధి 'ఒరిజినల్ స్ట్రింగ్' అనే 'std:: string'ని 'సమర్థవంతమైన స్ట్రింగ్ హ్యాండ్లింగ్' విలువతో ప్రారంభిస్తుంది. తదనంతరం, 'ఒరిజినల్ స్ట్రింగ్' యొక్క కంటెంట్‌ను సూచిస్తూ 'viewOfString' పేరుతో 'std::string_view' సృష్టించబడుతుంది.
“processStringView” ఫంక్షన్‌కి “viewOfString”ని పాస్ చేయడం ద్వారా, అదనపు మెమరీ కేటాయింపుల అవసరాన్ని తొలగిస్తూ, స్ట్రింగ్‌పై మేము ఆపరేషన్‌లను సమర్థవంతంగా నిర్వహించగలము. “std::string_view” అనేది డేటాను కాపీ చేయకుండానే “ఒరిజినల్ స్ట్రింగ్” యొక్క అంతర్లీన అక్షర క్రమానికి తేలికైన సూచన.
ఉత్పత్తి చేయబడిన అవుట్‌పుట్ ఇక్కడ ఉంది:
ఉదాహరణ 2: లెగసీ కోడ్‌తో పరస్పర చర్య
C++ డెవలప్‌మెంట్ రంగంలో, కొత్త మరియు పాత కోడ్‌బేస్‌ల అతుకులు లేని ఏకీకరణ తరచుగా క్లిష్టమైన ఆందోళన కలిగిస్తుంది. “std::string_view” డెవలపర్‌లు “const char” పాయింటర్‌లను అందించే లెగసీ ఫంక్షన్‌లతో అప్రయత్నంగా ఇంటరాక్ట్ అవ్వడానికి అనుమతిస్తుంది.
ఇంటర్‌ఆపరేబిలిటీ కోసం “std::string_view” యొక్క ఆచరణాత్మక ఉపయోగాన్ని ప్రదర్శించే క్రింది ఉదాహరణను పరిగణించండి. ఇక్కడ, 'const char' పాయింటర్‌ని అందించే 'legacyFunction()' అనే లెగసీ ఫంక్షన్‌ని మేము కలిగి ఉన్నాము:
##
కాన్స్ట్ చార్ * లెగసీ ఫంక్షన్ ( ) {
తిరిగి 'లెగసీ స్ట్రింగ్' ;
}
పూర్ణాంక ప్రధాన ( ) {
std::string_view legacyStrView ( లెగసీ ఫంక్షన్ ( ) ) ;
std::cout << 'లెగసీ స్ట్రింగ్ వీక్షణ:' << legacyStrView << std::endl;
తిరిగి 0 ;
}
మేము 'లెగసీ ఫంక్షన్()' పేరుతో లెగసీ ఫంక్షన్‌ని నిర్వచించడం ద్వారా ప్రారంభిస్తాము, ఇది 'లెగసీ స్ట్రింగ్' అని లేబుల్ చేయబడిన స్ట్రింగ్‌ను సూచించే 'const char' పాయింటర్‌ను అందిస్తుంది. ఈ లెగసీ డేటాను మా ఆధునిక C++ ప్రోగ్రామ్‌లో సజావుగా చేర్చడానికి, మేము “std::string_view”ని ఉపయోగిస్తాము. ప్రధాన() ఫంక్షన్‌లో, ప్రత్యేకంగా, మేము “legacyStrView” పేరుతో “std::string_view” యొక్క ఉదాహరణను సృష్టిస్తాము మరియు లెగసీ ఫంక్షన్ ఫలితంతో దాన్ని ప్రారంభిస్తాము. లెగసీ “const char” పాయింటర్‌తో సమర్ధవంతంగా ఎన్‌క్యాప్సులేట్ చేయడానికి మరియు పని చేయడానికి ఈ ఇన్‌స్టాంటియేషన్ మమ్మల్ని అనుమతిస్తుంది.
ఫలితంగా, మేము అనవసరమైన డేటా కాపీని ఆశ్రయించకుండా, సమర్థత మరియు అనుకూలత రెండింటినీ సంరక్షించకుండా లెగసీ స్ట్రింగ్‌ని యాక్సెస్ చేయవచ్చు మరియు మార్చవచ్చు. కోడ్‌లోని చివరి దశలో లెగసీ స్ట్రింగ్ వీక్షణ యొక్క కంటెంట్‌ను ప్రింట్ చేయడానికి “std::cout”ని ఉపయోగించడం ఉంటుంది.
అమలు చేయబడిన అవుట్‌పుట్:
ఉదాహరణ 3: మెరుగైన స్ట్రింగ్ లిటరల్స్ హ్యాండ్లింగ్
C++లోని స్ట్రింగ్ అక్షరాలు సాంప్రదాయకంగా అక్షరాల శ్రేణులుగా సూచించబడతాయి. “std::string_view” అనుకూలమైన ఇంటర్‌ఫేస్‌ని అందించడం ద్వారా స్ట్రింగ్ లిటరల్స్‌తో పని చేయడాన్ని సులభతరం చేస్తుంది. స్పష్టమైన మార్పిడులు అవసరం లేకుండా అంతర్లీన అక్షర శ్రేణికి ప్రత్యక్ష ప్రాప్యతను అనుమతించడం ద్వారా, “std::string_view” స్ట్రింగ్ లిటరల్స్‌లో కార్యకలాపాలను క్రమబద్ధీకరిస్తుంది.
##
పూర్ణాంక ప్రధాన ( ) {
కాన్స్ట్ చార్ * myLiteral = 'హలో, స్ట్రింగ్ వ్యూ!' ;
std::string_view literalView ( నా సాహిత్యం ) ;
std::cout << 'మొదటి పాత్ర:' << సాహిత్య వీక్షణ [ 0 ] << std::endl;
size_t స్థానం = literalView.find ( 'స్ట్రింగ్' ) ;
std::cout << 'సబ్‌స్ట్రింగ్ స్థానం:' << స్థానం << std::endl;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, “హలో, స్ట్రింగ్ వ్యూ!” 'myLiteral' పాయింటర్‌కు స్ట్రింగ్ లిటరల్ కేటాయించబడింది. “std::string_view” పరిచయం ఈ స్ట్రింగ్‌లోని కంటెంట్‌లను కాపీ చేయనవసరం లేకుండా మరింత సమర్థవంతమైన ప్రాతినిధ్యాన్ని సులభతరం చేస్తుంది. 'literalView' ఆబ్జెక్ట్ 'myLiteral' పాయింటర్‌ని ఉపయోగించి సృష్టించబడింది, ఇది అంతర్లీన అక్షర క్రమాన్ని వీక్షించడానికి మరియు మార్చడానికి అనుమతిస్తుంది.
“std::string_view” వినియోగం స్ట్రింగ్‌లోని వ్యక్తిగత అక్షరాలకు సులభమైన యాక్సెస్‌ను అందిస్తుంది. కోడ్ స్నిప్పెట్‌లో, “లిటరల్ వ్యూ[0]” స్ట్రింగ్ యొక్క మొదటి అక్షరాన్ని తిరిగి పొందుతుంది మరియు ప్రింట్ చేస్తుంది, ఎలిమెంట్‌లను యాక్సెస్ చేయడం యొక్క సరళత మరియు ప్రత్యక్షతను ప్రదర్శిస్తుంది. అసలు స్ట్రింగ్‌లోని “స్ట్రింగ్” సబ్‌స్ట్రింగ్ స్థానాన్ని గుర్తించడానికి “std::string_view” యొక్క “కనుగొను” పద్ధతి ఉపయోగించబడుతుంది.
ఉదాహరణ 4: సబ్‌స్ట్రింగ్ ఎక్స్‌ట్రాక్షన్
సబ్‌స్ట్రింగ్ వెలికితీత పనిలో డీలిమిటర్ స్థానం వంటి పేర్కొన్న ప్రమాణాల ఆధారంగా ఇచ్చిన స్ట్రింగ్‌లోని కొంత భాగాన్ని తిరిగి పొందడం ఉంటుంది. సబ్‌స్ట్రింగ్‌లను అప్రయత్నంగా సంగ్రహించే సామర్థ్యం “std::string_view” యొక్క శక్తివంతమైన లక్షణం. మేము డీలిమిటర్ ఆధారంగా స్ట్రింగ్‌లోని కొంత భాగాన్ని సంగ్రహించాల్సిన దృష్టాంతాన్ని పరిగణించండి:
##
పూర్ణాంక ప్రధాన ( ) {
std::string fullString = 'యాపిల్-నారింజ-అరటి' ;
size_t delimiterPos = fullString.find ( '-' ) ;
std::string_view subString = fullString.substr ( 0 , డీలిమిటర్ పోస్ ) ;
std::cout << 'సంగ్రహించిన సబ్‌స్ట్రింగ్:' << సబ్ స్ట్రింగ్ << std::endl;
తిరిగి 0 ;
}
ఈ కోడ్ స్నిప్పెట్‌లో, “ఆపిల్-ఆరెంజ్-బనానా” విలువతో ప్రారంభించబడిన అసలైన స్ట్రింగ్ “ఫుల్‌స్ట్రింగ్” డిక్లరేషన్‌తో మేము ప్రారంభిస్తాము. సబ్‌స్ట్రింగ్ వెలికితీతను నిర్వహించడం మా లక్ష్యం. దీన్ని సాధించడానికి, మేము C++ ప్రామాణిక లైబ్రరీ అందించిన “కనుగొనండి” ఫంక్షన్‌ని ఉపయోగిస్తాము.
“డీలిమిటర్‌పోస్” వేరియబుల్‌లో నిల్వ చేయబడిన “ఫుల్‌స్ట్రింగ్” లోపల డీలిమిటర్ స్థానాన్ని గుర్తించిన తర్వాత, మేము కావలసిన సబ్‌స్ట్రింగ్‌ను సంగ్రహిస్తాము. 'substr' ఫంక్షన్ అసలు స్ట్రింగ్‌లో పిలువబడుతుంది, ఇది ప్రారంభ స్థానం (0) మరియు డీలిమిటర్ యొక్క స్థానం అయిన సబ్‌స్ట్రింగ్ యొక్క పొడవును పేర్కొంటుంది. ఈ ఆపరేషన్ ఫలితంగా 'subString' పేరుతో 'std::string_view' సృష్టించబడుతుంది, ఇది మొదటి నుండి డీలిమిటర్ వరకు అసలైన స్ట్రింగ్ యొక్క భాగాన్ని సూచిస్తుంది.
ఉదాహరణ 5: మెమరీ-సమర్థవంతమైన డేటా నిర్మాణాలు
మెమరీ-సమర్థవంతమైన డేటా నిర్మాణాలను రూపొందించడంలో “std::string_view” కీలక పాత్ర పోషిస్తుంది. స్ట్రింగ్‌ల యొక్క బహుళ కాపీలను నిల్వ చేయడానికి బదులుగా, డేటా స్ట్రక్చర్‌లు “std::string_view” ఉదాహరణలను నిల్వ చేయగలవు, తద్వారా మెమరీ ఓవర్‌హెడ్ తగ్గుతుంది.
##
struct రికార్డ్ {
std::string_view పేరు;
పూర్ణాంక వయస్సు;
} ;
పూర్ణాంక ప్రధాన ( ) {
రికార్డ్ వ్యక్తి = { 'జాన్ డో' , 30 } ;
std::cout << 'పేరు:' << వ్యక్తి.పేరు << ', వయస్సు:' << వ్యక్తి.వయస్సు << std::endl;
తిరిగి 0 ;
}
ఈ కోడ్ స్నిప్పెట్‌లో, మేము మెమరీ-సమర్థవంతమైన డేటా నిర్మాణంలో “std::string_view” వినియోగాన్ని ప్రదర్శిస్తాము. మేము 'పేరు' అనే 'std::string_view' సభ్యుడు మరియు 'వయస్సు' అనే పూర్ణాంక సభ్యునితో కూడిన 'రికార్డ్' నిర్మాణాన్ని నిర్వచించాము. ఈ సందర్భంలో “std::string_view” ఉపయోగం అదనపు మెమరీ కేటాయింపు అవసరం లేకుండా స్ట్రింగ్ యొక్క తేలికైన ప్రాతినిధ్యాన్ని సృష్టించడానికి అనుమతిస్తుంది.
'ప్రధాన' ఫంక్షన్‌లో, మేము 'జాన్ డో' పేరుతో మరియు 30 సంవత్సరాల వయస్సు గల 'వ్యక్తి' అనే 'రికార్డ్' ఆబ్జెక్ట్‌ని ఇన్‌స్టాంటియేట్ చేస్తాము. 'std::string_view' సభ్యుడు 'పేరు' అనేది స్వంతం కాని వీక్షణగా పనిచేస్తుంది పేరుకు సంబంధించిన అక్షర డేటా, స్ట్రింగ్ కంటెంట్‌ను నకిలీ చేయవలసిన అవసరాన్ని తొలగిస్తుంది. “std::cout << “పేరు: ” << person.name << “, Age: ” << person.age << std::endl;” ప్రకటన 'రికార్డ్' ఆబ్జెక్ట్‌లో నిల్వ చేయబడిన వ్యక్తి పేరు మరియు వయస్సును అందిస్తుంది.
ముగింపు
C++ డెవలప్‌మెంట్ యొక్క ఎప్పటికప్పుడు అభివృద్ధి చెందుతున్న ల్యాండ్‌స్కేప్‌లో, ప్రోగ్రామర్ యొక్క టూల్‌కిట్‌కు 'std::string_view' విలువైన అదనంగా నిలుస్తుంది. ఈ కథనంలో ఉదహరించబడిన సందర్భాలు C++ ప్రోగ్రామింగ్ పరిధిలో “std::string_view” యొక్క అనుకూలత మరియు ప్రయోజనాన్ని హైలైట్ చేస్తాయి. లెగసీ కోడ్‌తో సమర్ధవంతమైన స్ట్రింగ్ మానిప్యులేషన్ మరియు అతుకులు లేని ఇంటర్‌ఆపెరాబిలిటీ నుండి మెమరీ-సమర్థవంతమైన డేటా స్ట్రక్చర్‌ల వరకు, విభిన్న దృశ్యాలలో మెరుగైన పనితీరు మరియు ఆప్టిమైజ్ చేసిన కోడ్ కోసం ప్రయత్నిస్తున్న డెవలపర్‌లకు “std::string_view” విలువైనది. ఈ వాస్తవ-ప్రపంచ దృశ్యాలు 'std::string_view' కోడ్‌ను ఎలా ఆప్టిమైజ్ చేయగలదో, అనవసరమైన మెమరీ ఓవర్‌హెడ్‌ను ఎలా తగ్గించగలదో మరియు C++ అప్లికేషన్‌ల మొత్తం సామర్థ్యానికి ఎలా దోహదపడగలదో ప్రదర్శిస్తాయి.