charAt() ఫంక్షన్ విలువైనది మరియు స్ట్రింగ్‌లోని అక్షరాలను యాక్సెస్ చేయడానికి మరియు మానిప్యులేట్ చేయడానికి చాలా ఉపయోగకరంగా ఉంటుంది. అయితే అదే ఫంక్షన్‌ని C++లో ఎలా నిర్వహించగలం? స్ట్రింగ్::at() ఫంక్షన్ C++ ప్రోగ్రామింగ్ లాంగ్వేజ్‌లో అదే కార్యాచరణను సులభతరం చేస్తుంది. ఈ కథనంలో, స్ట్రింగ్::at() ఫంక్షన్ యొక్క కార్యాచరణను సమర్థవంతంగా అర్థం చేసుకోవడంలో మీకు సహాయపడటానికి సరళమైన మరియు ఖచ్చితమైన ఉదాహరణలను అందించడం ద్వారా మేము స్ట్రింగ్::at() ఫంక్షన్‌ను పరిశీలిస్తాము.
జావా స్ట్రింగ్ చార్ట్()
జావాలో, 'స్ట్రింగ్' క్లాస్ యొక్క charAt() పద్ధతి చాలా సాధారణంగా ఉపయోగించే మరియు ప్రభావవంతమైన ఫంక్షన్. ఈ పద్ధతి స్ట్రింగ్ మానిప్యులేషన్‌లో ముఖ్యమైన పాత్రను పోషిస్తుంది, దీని సూచిక స్థానాల ఆధారంగా స్ట్రింగ్‌లోని ప్రతి అక్షరానికి ప్రాప్యతను ప్రారంభించడం ద్వారా. జావా ప్రోగ్రామ్‌లలో సమర్థవంతమైన స్ట్రింగ్ హ్యాండ్లింగ్ కోసం charAt() యొక్క సింటాక్స్ మరియు కార్యాచరణను అర్థం చేసుకోవడం చాలా అవసరం. జావా యొక్క charAt() ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రిందిది:
సింటాక్స్:
ప్రజా చార్ charAt ( int సూచిక )
charAt() ఫంక్షన్ ఒక పరామితిని పూర్ణాంకం, సూచికగా తీసుకుంటుంది, అది కావలసిన అక్షరం యొక్క స్థానాన్ని సూచిస్తుంది. ఈ ఫంక్షన్ యొక్క రిటర్న్ రకం చార్. ఇది త్వరగా ఎలా పని చేస్తుందో అర్థం చేసుకోవడానికి charAt() ఫంక్షన్ యొక్క ఉదాహరణను చూద్దాం:
పబ్లిక్ క్లాస్ మెయిన్ {
ప్రజా స్థిరమైన శూన్యం ప్రధాన ( స్ట్రింగ్ [ ] ఆర్గ్స్ ) {
స్ట్రింగ్ Char_at = 'టెస్టింగ్ CharAt' ;
చార్ చరోన్ = చార్_అట్. charAt ( 0 ) ;
చార్ చార్ట్ రెండు = చార్_అట్. charAt ( 5 ) ;
చార్ చార్త్రీ = చార్_అట్. charAt ( 8 ) ;
వ్యవస్థ. బయటకు . println ( '0 సూచిక వద్ద అక్షరం:' + చరోన్ ) ;
వ్యవస్థ. బయటకు . println ( '5 సూచిక వద్ద అక్షరం:' + చార్ట్ రెండు ) ;
వ్యవస్థ. బయటకు . println ( '8 సూచిక వద్ద అక్షరం:' + చార్త్రీ ) ;
}
}
ఈ ఉదాహరణలో, 'Testing CharAt' స్ట్రింగ్ ఉపయోగించబడుతుంది మరియు సూచిక 0, 5 మరియు 8 వద్ద అక్షరాలను పొందడానికి charAt() ఫంక్షన్ అమలు చేయబడుతుంది. సంబంధిత అక్షరాలు 'T', 'n' మరియు 'C' పేర్కొన్న సూచికలు కన్సోల్‌కు ముద్రించబడతాయి. కింది అవుట్‌పుట్ స్నాప్‌షాట్‌ను చూడండి:
మీరు అవుట్‌పుట్‌లో చూడగలిగినట్లుగా, charAt() ఫంక్షన్ సూచిక 0, 5 మరియు 8 వద్ద అక్షరాలను తిరిగి పొందుతుంది మరియు కన్సోల్‌లో ముద్రించబడుతుంది. మేము C++ ప్రోగ్రామింగ్ భాషలో పని చేయవలసి వస్తే, మేము 'string::at' ఫంక్షన్‌ని ఉపయోగిస్తాము. C++లో charAt()కి సమానమైన ఫంక్షన్ అదే ఫంక్షన్‌ను చేసే “string::at” ఫంక్షన్.
C++ స్ట్రింగ్::at() – Java CharAt() ఫంక్షన్‌కి సమానం
C++ ప్రోగ్రామింగ్ భాషలో, స్ట్రింగ్::at() ఫంక్షన్ జావా యొక్క charAt()కి సమానం. స్ట్రింగ్::at() ఫంక్షన్ యొక్క వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
చార్ & str. వద్ద ( int సూచిక )charAt() పద్ధతి ఇన్‌పుట్ మరియు అవుట్‌పుట్ మాదిరిగానే, str.at() ఫంక్షన్ పూర్ణాంక పరామితిని తీసుకుంటుంది, అది గుర్తించాల్సిన పాత్ర యొక్క సూచికను సూచిస్తుంది. అదే 0-ఆధారిత సూచిక str.at() ఫంక్షన్ ద్వారా అనుసరించబడుతుంది. తదుపరి అక్షరాల కోసం సూచిక 1 ద్వారా పెంచబడుతుంది. str.at() ఫంక్షన్ యొక్క ఫలితం char టైప్‌కు చెందినది, అంటే అది ఒక చార్‌ని అందిస్తుంది. str.at() ఫంక్షన్ వినియోగాన్ని వివరించడానికి, కింది ఉదాహరణను పరిగణించండి:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
స్ట్రింగ్ స్ట్రింగ్ = 'టెస్టింగ్ CharAt' ;
చార్ చరోన్ = str. వద్ద ( 0 ) ;
చార్ చార్ట్ రెండు = str. వద్ద ( 5 ) ;
చార్ చార్త్రీ = str. వద్ద ( 8 ) ;
కోట్ << '0 సూచిక వద్ద అక్షరం:' << చరోన్ << endl ;
కోట్ << '5 సూచిక వద్ద అక్షరం:' << చార్ట్ రెండు << endl ;
కోట్ << '8 సూచిక వద్ద అక్షరం:' << చార్త్రీ << endl ;
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము జావాలో charAt() ఫంక్షన్‌ని ఉపయోగించి అమలు చేసే C++లో str.at() ఫంక్షన్‌ని ఉపయోగించి అదే కోడ్‌ని అమలు చేయడానికి ఎంచుకుంటాము. మళ్ళీ, 'టెస్టింగ్ CharAt' స్ట్రింగ్ సృష్టించబడింది మరియు C++ యొక్క 0-ఆధారిత ఇండెక్సింగ్ ఇచ్చిన మొదటి, నాల్గవ మరియు ఏడవ అక్షరాలను సూచించే సూచిక 0, 5 మరియు 8 వద్ద అక్షరాన్ని పొందడానికి str.at() ఫంక్షన్ అమలు చేయబడుతుంది. క్యారెక్టర్ అప్పుడు చారోన్, చార్ట్‌టూ మరియు చార్త్రీ వేరియబుల్స్‌లో నిల్వ చేయబడుతుంది మరియు కన్సోల్‌కు ముద్రించబడుతుంది. str.at() ఫంక్షన్ యొక్క పనిని మరింత వివరంగా వివరించే మరో ఉదాహరణను అమలు చేద్దాం. కింది కోడ్‌ను చూడండి:
#includeనేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
స్ట్రింగ్ స్ట్రింగ్ = 'str.at() ట్యుటోరియల్' ;
కోసం ( int i = 0 ; i < strng. పొడవు ( ) ; i ++ ) {
కోట్ << 'ది క్యారెక్టర్ ఇన్ ది స్ట్రింగ్ ఎట్ ఇండెక్స్' << i << 'ఉంది ='
<< strng. వద్ద ( i ) << endl ;
}
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము “str.at() ట్యుటోరియల్” విలువతో “strng” అనే స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించాము మరియు ప్రారంభించాము. అప్పుడు, మేము ప్రతి అక్షరం ద్వారా స్ట్రింగ్‌లో పునరావృతం కోసం “ఫర్” లూప్‌ని ఉపయోగిస్తాము. లూప్ లోపల, మేము ప్రతి స్ట్రింగ్ అక్షరాన్ని దాని సూచికతో ప్రదర్శిస్తాము. ఈ ప్రోగ్రామ్ యొక్క అవుట్‌పుట్ “str.at() ట్యుటోరియల్” స్ట్రింగ్‌లోని ప్రతి అక్షరాన్ని దాని సంబంధిత సూచికతో పాటు ప్రదర్శిస్తుంది. లూప్ యొక్క ప్రతి పునరావృతం సమయంలో పేర్కొన్న సూచిక వద్ద అక్షరాన్ని పొందడానికి strng.at(i) పద్ధతి ఉపయోగించబడుతుంది.
స్ట్రింగ్‌లోని నిర్దిష్ట అక్షరం యొక్క సూచికను పొందడానికి str.at() ఫంక్షన్‌ను ఉపయోగించవచ్చు. str.at() ఫంక్షన్ స్ట్రింగ్‌లో సరిపోలిన మొదటి అక్షరం యొక్క సూచికను అందిస్తుంది. దీన్ని ప్రదర్శించడానికి, మేము ఈ క్రింది ఉదాహరణను అమలు చేస్తాము. కింది కోడ్‌ను చూడండి:
##
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
స్ట్రింగ్ స్ట్రింగ్ = 'str.at() ట్యుటోరియల్' ;
కోసం ( int i = 0 ; i < strng. పరిమాణం ( ) ; i ++ ) {
ఉంటే ( strng. వద్ద ( i ) == 't' ) {
కోట్ << ''t' యొక్క సూచిక = ' << i << endl ;
బ్రేక్ ;
}
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ ఇచ్చిన స్ట్రింగ్‌లో “t” అక్షరం యొక్క మొదటి సంభవం కోసం శోధించే ప్రోగ్రామ్‌ను ప్రదర్శిస్తుంది మరియు దాని సూచికను ముద్రిస్తుంది. “str.at() ట్యుటోరియల్” విలువతో స్ట్రింగ్ వేరియబుల్ ప్రకటించబడింది మరియు ప్రారంభించబడింది. “ఫర్” లూప్‌ని ఉపయోగించి, “t” అక్షరం యొక్క మొదటి సంఘటనను కనుగొనడానికి మేము ప్రతి అక్షరం ద్వారా స్ట్రింగ్‌లో పునరావృతం చేస్తాము.
స్ట్రింగ్‌లోని ప్రతి అక్షరాన్ని “t” కాదా అని తనిఖీ చేయడానికి ఎంచుకున్న అక్షరంతో పోల్చడానికి “if” షరతు ఉపయోగించబడింది. స్ట్రింగ్‌లో మొదటి అక్షరం సరిపోలినప్పుడు, ఆ అక్షరం యొక్క సూచిక కన్సోల్‌కు ముద్రించబడుతుంది మరియు ఫంక్షన్ 'బ్రేక్' ఉపయోగించి లూప్ నుండి నిష్క్రమిస్తుంది. ఈ ప్రోగ్రామ్ స్ట్రింగ్‌లోని 't' అక్షరం యొక్క మొదటి సంఘటన యొక్క సూచికను ఇస్తుంది. స్ట్రింగ్‌లో “t” కనుగొనబడకపోతే, ఏదైనా ముద్రించకుండానే లూప్ పూర్తవుతుంది.
C++ స్ట్రింగ్::at()ని Java CharAt()తో పోల్చడం
జావాలో charAt() మరియు C++లో str.at అనే రెండు ఫంక్షన్‌లు ఒకే ప్రాథమిక ప్రయోజనాన్ని అందిస్తాయి, C++లోని str.at() ఫంక్షన్ జావాలోని charAt() ఫంక్షన్ కంటే చాలా వేగంగా ఉంటుంది. ఇది ఇండెక్స్ ద్వారా క్యారెక్టర్‌లకు యాక్సెస్‌ని అందిస్తుంది మరియు పనితీరు కీలకం అయ్యే పరిస్థితులకు ఇది సరైన ఎంపికగా చేస్తుంది. C++లో str.at() ఫంక్షన్ యొక్క ఇతర ముఖ్యమైన అంశం దాని సామర్థ్యం. జావా నుండి C++కి మారుతున్న డెవలపర్లు లేదా C++ మరియు Java రెండింటిని కలిగి ఉన్న ప్రాజెక్ట్‌లలో పని చేస్తున్నవారు ఈ సామర్థ్య అంశాలను అర్థం చేసుకోవడం ద్వారా ప్రయోజనం పొందవచ్చు.
ముగింపు
ముగింపులో, C++ స్ట్రింగ్ మానిప్యులేషన్‌ను అర్థం చేసుకోవడంలో జావా యొక్క charAt()కి ప్రత్యామ్నాయమైన స్ట్రింగ్::at() ఫంక్షన్‌తో పరిచయం ఉంటుంది. ఇలస్ట్రేటెడ్ ఉదాహరణలు charAt() మరియు str.at() ఫంక్షన్‌ల యొక్క ఆచరణాత్మక వినియోగాన్ని ప్రదర్శిస్తాయి, డెవలపర్లు నిర్దిష్ట అక్షరాలను త్వరగా మరియు సమర్ధవంతంగా యాక్సెస్ చేయడానికి అనుమతిస్తుంది. C++లో str.at() ఫంక్షన్ యొక్క సామర్థ్యం దాని అవసరాన్ని మరింత పెంచుతుంది, ఇది స్ట్రింగ్ మానిప్యులేషన్ టాస్క్‌లకు ముఖ్యమైన విధిగా చేస్తుంది. మీరు జావా భాష నుండి C++ భాషకు మారుతున్నా లేదా సంక్లిష్టమైన C++ ప్రాజెక్ట్‌ను రూపొందించబోతున్నా, మీ ప్రోగ్రామ్‌లలోని స్ట్రింగ్‌లను సమర్థవంతంగా మరియు ప్రభావవంతంగా నిర్వహించడానికి ఈ ఫంక్షన్‌ల గురించి దృఢమైన అవగాహన తప్పనిసరి.