మనందరికీ తెలిసినట్లుగా, C++ అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ లాంగ్వేజ్ మరియు దానిలో లూప్ భావనలను ఉపయోగిస్తుంది కాబట్టి నేర్చుకోవడం సులభం. C++ యొక్క విభిన్న డేటాటైప్‌లు ఉన్నాయి మరియు స్ట్రింగ్ ఆ డేటాటైప్‌లలో ఒకటి. స్ట్రింగ్ అనేది దానిలోని మూలకాల క్రమాన్ని కలిగి ఉన్న ఒక వస్తువు.
పరిచయం
C++ స్ట్రింగ్‌లో, ఇన్‌పుట్ స్ట్రింగ్ యొక్క ఎలిమెంట్ లేదా క్యారెక్టర్‌ను యాక్సెస్ చేయడానికి అనేక విభిన్న ఎలిమెంట్ యాక్సెసర్‌లు ఉపయోగించబడతాయి. ఇక్కడ, మేము ఇన్‌పుట్ స్ట్రింగ్ యొక్క మొదటి మరియు చివరి అక్షరాన్ని యాక్సెస్ చేయడానికి ముందు() పద్ధతి మరియు వెనుక() పద్ధతిని ఉపయోగిస్తున్నాము. ఇప్పుడు, ఈ పద్ధతులను వివరిస్తాము మరియు ఈ పద్ధతులు C++లో ఎలా పని చేస్తాయో చూద్దాం.
స్ట్రింగ్ :: ఫ్రంట్ () పద్ధతి
ఇన్‌పుట్ స్ట్రింగ్ యొక్క మొదటి లేదా ముందు మూలకాన్ని యాక్సెస్ చేయడానికి స్ట్రింగ్ ఫ్రంట్() పద్ధతి ఉపయోగించబడుతుంది మరియు ఇన్‌పుట్ స్ట్రింగ్ ప్రారంభంలో మనం ఎలిమెంట్ లేదా క్యారెక్టర్‌ను కూడా చొప్పించవచ్చు. మొదటి చొప్పించిన అక్షరం పాత మొదటి అక్షరంతో భర్తీ చేయబడుతుంది. కాబట్టి, ఇన్‌పుట్ స్ట్రింగ్ పొడవు అలాగే ఉంటుంది.
వాక్యనిర్మాణం
మేము ఫ్రంట్() పద్ధతి యొక్క వాక్యనిర్మాణాన్ని వ్రాయడం ప్రారంభించినప్పుడు, మేము మొదట 'చార్' అనే కీవర్డ్‌ని వ్రాస్తాము, అది మనం అక్షరాన్ని యాక్సెస్ చేయబోతున్నామని చూపుతుంది. అప్పుడు, మేము ఇచ్చిన ఇన్‌పుట్ స్ట్రింగ్‌లోని మొదటి అక్షరాన్ని నిల్వ చేసే వేరియబుల్‌ను ప్రకటిస్తాము. మేము ఇప్పటికే సృష్టించిన ఇన్‌పుట్ స్ట్రింగ్‌ని పిలుస్తాము. మేము కాలింగ్ ద్వారా దానితో ఫ్రంట్() పద్ధతిని సంగ్రహించాము. ఫ్రంట్() పద్ధతి అనేది ఇన్‌పుట్ స్ట్రింగ్ యొక్క మొదటి మూలకాన్ని యాక్సెస్ చేయడానికి ఉపయోగించే స్ట్రింగ్ యొక్క ముందే నిర్వచించబడిన పద్ధతి.
లోపాలు & మినహాయింపులు
ఇన్‌పుట్ స్ట్రింగ్ ఖాళీగా ఉంటే, అది నిర్వచించబడని ప్రవర్తనను చూపుతుంది లేదా లోపాన్ని జాబితా చేస్తుంది. ఇన్‌పుట్ స్ట్రింగ్ ఖాళీగా లేకుంటే, అది కావలసిన అవుట్‌పుట్‌ను చూపుతుంది మరియు మినహాయింపును త్రోయదు.
రిటర్న్ విలువ
స్ట్రింగ్ ఫ్రంట్() పద్ధతి అందించిన ఇన్‌పుట్ స్ట్రింగ్‌లోని మొదటి అక్షరాన్ని లేదా మూలకాన్ని అందిస్తుంది.
ఉదాహరణ
స్ట్రింగ్ ఫ్రంట్() పద్ధతికి ఉదాహరణ ఇక్కడ ఉంది. ఉదాహరణను అమలు చేయడానికి ముందు, మనకు మొదట C++ కంపైలర్ అవసరం, తద్వారా మన ప్రోగ్రామ్‌ను వ్రాసి అమలు చేయవచ్చు. C++ ప్రోగ్రామ్‌లలో, మేము ఎల్లప్పుడూ మా ప్రోగ్రామ్‌కు సంబంధించిన కొన్ని హెడర్ ఫైల్‌లను చేర్చుతాము ఎందుకంటే C++ మాకు హెడర్ ఫైల్‌లను ఉపయోగించడానికి అనుమతిస్తుంది కాబట్టి మేము ప్రతి కోడ్‌ను వ్రాయవలసిన అవసరం లేదు.
ముందే నిర్వచించిన హెడర్ ఫైల్‌లను ఉపయోగించడం ద్వారా, మా కోడ్ ఖచ్చితమైనది, నిర్వహించదగినది మరియు సులభంగా అర్థం చేసుకోవచ్చు. మేము చేర్చిన మొదటి హెడర్ ఫైల్ “#include
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ స్ట్రింగ్ = 'ప్రోగ్రామింగ్ ప్రపంచానికి స్వాగతం \n ' ;
కోట్ << str << endl ;
చార్ మొదటి_మూలకం = str. ముందు ( ) ;
కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్ యొక్క మొదటి మూలకం:' << మొదటి_మూలకం << endl ;
str. ముందు ( ) = '_' ;
కోట్ << endl << 'అప్‌డేటింగ్ స్ట్రింగ్:' << str << endl ;
తిరిగి 0 ;
}
ప్రోగ్రామ్‌లో ప్రాథమిక లైబ్రరీలను చేర్చిన తర్వాత, మేము అమలు చేయాలనుకుంటున్న వాస్తవ లైన్ కోడ్‌ను వ్రాయడం ప్రారంభిస్తాము. దీని కోసం, ప్రధాన () ఫంక్షన్‌కు కాల్ చేసి, అందులో కోడ్ రాయడం ప్రారంభించండి. మొదట, మేము 'str' అనే 'స్ట్రింగ్' కీవర్డ్‌ని వ్రాసి ఇన్‌పుట్ స్ట్రింగ్‌ను ప్రకటించి, ఆపై ఇన్‌పుట్ స్ట్రింగ్‌ను డబుల్ కొటేషన్ మార్కులలో వ్రాస్తాము. ఆపై మేము C++ యొక్క ముందే నిర్వచించిన కౌట్ () పద్ధతిని ఉపయోగించి దాన్ని ముద్రించాము.
మేము స్ట్రింగ్ ఫ్రంట్ () పద్ధతిని వ్రాస్తాము. దాని కోసం, ముందుగా, 'char' అనే కీవర్డ్‌ని వ్రాయండి, అంటే మనం అక్షరాన్ని యాక్సెస్ చేస్తున్నాము మరియు ఇన్‌పుట్ స్ట్రింగ్ యొక్క మూలకాలను నిల్వ చేసే వేరియబుల్ 'First_Element'ని ప్రకటిస్తాము. అప్పుడు, మేము ఇన్‌పుట్ స్ట్రింగ్ యొక్క ముందు లేదా మొదటి మూలకాన్ని యాక్సెస్ చేస్తున్నామని కంపైలర్‌కు చెప్పే ఫ్రంట్() పద్ధతిని పిలుస్తాము. మేము దానిని cout() పద్ధతిని ఉపయోగించి ప్రదర్శించాము మరియు దానిలోని స్ట్రింగ్ వేరియబుల్ “str”ని పాస్ చేసాము.
ఫ్రంట్() పద్ధతికి కాల్ చేసిన తర్వాత, ఇన్‌పుట్ స్ట్రింగ్ నుండి వేరియబుల్ ఎక్కడ నుండి యాక్సెస్ చేయబడిందో వినియోగదారుకు స్పష్టంగా తెలియజేసే మరో పనిని చేసాము. దాని కోసం, మేము మొదట స్ట్రింగ్ వేరియబుల్ పేరు “str” ను వ్రాసి, దానిని ఫ్రంట్() పద్ధతితో సంగ్రహించి, ఆపై ఏదైనా వేరియబుల్ లేదా చిహ్నాన్ని నిల్వ చేస్తాము. ఇలా చేయడం ద్వారా ఇది ఇన్‌పుట్ స్ట్రింగ్ యొక్క పాత మొదటి మూలకాన్ని కొత్త మూలకంతో భర్తీ చేస్తుంది. అమలు చేయబడిన ప్రోగ్రామ్ యొక్క అవుట్‌పుట్‌ను చూద్దాం:
స్ట్రింగ్:: బ్యాక్ () పద్ధతి
ఇన్‌పుట్ స్ట్రింగ్‌లోని చివరి మూలకాన్ని యాక్సెస్ చేయడానికి స్ట్రింగ్ బ్యాక్() పద్ధతి ఉపయోగించబడుతుంది మరియు ఇన్‌పుట్ స్ట్రింగ్ చివరిలో మనం ఎలిమెంట్ లేదా క్యారెక్టర్‌ను కూడా జోడించవచ్చు. చివరి అక్షరం పాత చివరి అక్షరంతో భర్తీ చేయబడుతుంది. కాబట్టి, ఇన్‌పుట్ స్ట్రింగ్ పొడవు అలాగే ఉంటుంది.
వాక్యనిర్మాణం
స్ట్రింగ్ యొక్క బ్యాక్() పద్ధతి యొక్క అమలును అర్థం చేసుకుందాం. మొదట, మేము 'char' అనే కీవర్డ్‌ని వ్రాసి, ఇన్‌పుట్ స్ట్రింగ్ యొక్క చివరి మూలకాన్ని నిల్వ చేసే వేరియబుల్‌ను ప్రకటించి, ఆపై బ్యాక్() పద్ధతిని కాల్ చేస్తాము.
లోపాలు & మినహాయింపులు
ఇన్‌పుట్ స్ట్రింగ్ ఖాళీగా లేకుంటే, అది కావలసిన అవుట్‌పుట్‌ను చూపుతుంది మరియు మినహాయింపును త్రోయదు మరియు అది ఖాళీగా ఉంటే, అది నిర్వచించబడని ప్రవర్తనను చూపుతుంది.
రిటర్న్ విలువ
స్ట్రింగ్ బ్యాక్() పద్ధతి ఇచ్చిన ఇన్‌పుట్ స్ట్రింగ్‌లోని చివరి మూలకాన్ని తిరిగి అందిస్తుంది.
ఉదాహరణ
ఈ ఉదాహరణలో, మేము మొదట ప్రోగ్రామ్‌ను వ్రాసేటప్పుడు సహాయపడే ప్రాథమిక లైబ్రరీలను చేర్చాము మరియు దానిలో “నేమ్‌స్పేస్ stdని ఉపయోగించడం” అని వ్రాస్తాము. అప్పుడు, మేము ప్రధాన విధిని పిలుస్తాము మరియు మేము
మేము అక్కడ కోడ్ యొక్క అసలు లైన్ వ్రాస్తాము. ముందుగా, మేము ఇన్‌పుట్ స్ట్రింగ్‌ని తీసుకొని కౌట్() పద్ధతిని ఉపయోగించి ప్రింట్ చేస్తాము. అప్పుడు, మేము స్ట్రింగ్ బ్యాక్() పద్ధతిని పిలిచాము, తద్వారా ఇన్‌పుట్ స్ట్రింగ్ యొక్క చివరి మూలకాన్ని యాక్సెస్ చేయవచ్చు. దీని తరువాత, మేము ఇన్‌పుట్ స్ట్రింగ్ యొక్క పాత చివరి మూలకాన్ని భర్తీ చేసి, ప్రధాన() ఫంక్షన్‌కి 0ని తిరిగి ఇవ్వడం ద్వారా చివరి మూలకాన్ని కూడా జోడించాము. #
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( )
{
స్ట్రింగ్ స్ట్రింగ్ = 'హలో వరల్డ్' ;
కోట్ << 'ఇన్‌పుట్ స్ట్రింగ్:' << str << endl ;
చార్ ముగింపు_మూలకం = str. తిరిగి ( ) ;
కోట్ << endl << 'ది లాస్ట్ క్యారెక్టర్ ఆఫ్ స్ట్రింగ్:' << ముగింపు_మూలకం << endl ;
str. తిరిగి ( ) = '_' ;
కోట్ << endl << 'నవీకరించబడిన స్ట్రింగ్:' << str ;
తిరిగి 0 ;
}
పైన ఉన్న ఇలస్ట్రేషన్ కోడ్ యొక్క అవుట్‌పుట్‌ని చూద్దాం మరియు స్ట్రింగ్ యొక్క బ్యాక్() పద్ధతిని అమలు చేయడం ద్వారా మనకు ఏమి లభిస్తుందో చూద్దాం:
ముగింపు
ఈ కథనంలో, C++లో స్ట్రింగ్ అంటే ఏమిటి మరియు స్ట్రింగ్ రకాల పద్ధతులు ఏమిటి మరియు మేము వాటిని ఎలా అమలు చేస్తాం అని తెలుసుకున్నాము. మేము స్ట్రింగ్ యొక్క ముందు() మరియు వెనుక() పద్ధతులను నేర్చుకున్నాము మరియు మేము కోడ్ యొక్క ప్రతి లైన్ యొక్క వివరణాత్మక వివరణతో కొన్ని ఉదాహరణలను కూడా చేసాము.