సి ++ లోని స్ట్రింగ్స్ గురించి మీరు తెలుసుకోవలసిన ప్రతిదీ

పదం అక్షరాల క్రమం క్రమం. C ++ లోని తరగతి యొక్క వస్తువును ఉపయోగించి అక్షరాల శ్రేణిని సూచించవచ్చు. అలా చేయడానికి నిర్వచనాన్ని అందించే తరగతిని స్ట్రింగ్ క్లాస్ అంటారు. సింగిల్-బైట్ అక్షరానికి ప్రాప్యతను అనుమతించే కార్యాచరణతో స్ట్రింగ్ క్లాస్ అక్షరాలను బైట్‌ల క్రమం వలె నిల్వ చేస్తుంది. C ++ లో పరివేష్టిత డీలిమిటర్లు డబుల్ కోట్స్. ఈ “C ++ లోని స్ట్రింగ్స్” వ్యాసంలో నేను ఈ క్రింది విషయాలను చర్చిస్తాను:

• స్ట్రింగ్ క్లాస్ మరియు క్యారెక్టర్ అర్రే తేడా
• C ++ లో స్ట్రింగ్స్‌ను ప్రకటించండి మరియు ప్రారంభించండి
• సి ++ లో స్ట్రింగ్స్‌పై ఆపరేషన్లు
  • స్ట్రింగ్ సైజు
  • స్ట్రింగ్ సంయోగం
  • అనుబంధ తీగలను
  • తీగలను శోధిస్తోంది

స్ట్రింగ్ క్లాస్ మరియు క్యారెక్టర్ అర్రే తేడా

C ++ లో స్ట్రింగ్స్‌ను ప్రకటించండి మరియు ప్రారంభించండి

సి ++ లో స్ట్రింగ్ ప్రారంభించడం చాలా సులభం! మేము ఈ క్రింది పద్ధతుల్లో దేనినైనా ఉపయోగించవచ్చు.

నేమ్‌స్పేస్ std స్ట్రింగ్ std_string ఉపయోగించి

లేదా

std :: string std_string

# నేమ్‌స్పేస్‌ను ఉపయోగించడం చేర్చండి std int main () {char ch [12] = {'H', 'e', ​​'l', 'l', 'o', '', 'b', 'y', '' , 'c', 'h', ''} string st = 'stlo' by st 'std :: string std_st =' std_st 'cout ద్వారా హలో<< ch << endl cout << st << endl cout << std_st << endl return 0 }

అవుట్పుట్:

హలో చే ch హలో ద్వారా st హలో std_st

ఈ ఉదాహరణలో, మేము అక్షర శ్రేణి (ch) మరియు స్ట్రింగ్ cl రెండింటినీ చూపించాముగాడిద (st మరియు std_st) ప్రారంభ పద్ధతులు. మొదట, మేము అక్షర శ్రేణి ch [12] ను నిర్వచించడం ద్వారా అక్షర శ్రేణి పద్ధతిని ఉపయోగించాము, ఇది 12 అంశాలను కలిగి ఉంటుంది మరియు శూన్య అక్షరంతో ముగుస్తుంది. రెండవ భాగంలో, మేము స్ట్రింగ్ క్లాస్ పద్ధతిని ఉపయోగించాము.

సి ++ లో స్ట్రింగ్స్‌పై ఆపరేషన్లు

స్ట్రింగ్ క్లాస్‌ని ఉపయోగించడం వల్ల కలిగే ప్రయోజనం ఏమిటంటే, వాటిని మార్చడానికి సి ++ లో అనేక అంతర్నిర్మిత విధులు ఉన్నాయి. ఇది ప్రోగ్రామింగ్ సులభం మరియు ప్రభావవంతంగా చేస్తుంది. కొన్ని ముఖ్యమైన స్ట్రింగ్ మానిప్యులేషన్ ఫంక్షన్లను తీసుకుందాం మరియు కొన్ని ఉదాహరణలను చూడటం ద్వారా వాటిని అర్థం చేసుకుందాం.

స్ట్రింగ్ పరిమాణం: పరిమాణం () మరియు పొడవు () పద్ధతులు రెండూ వస్తువు యొక్క పరిమాణాన్ని తిరిగి ఇవ్వడానికి ఉపయోగించవచ్చు.

system.exit (0) జావా

ధర<< st.length() <
 అవుట్పుట్: 
11 11
 స్ట్రింగ్ సంయోగం: వాటి మధ్య + ఆపరేటర్‌ను ఉపయోగించడం ద్వారా మేము రెండు లేదా అంతకంటే ఎక్కువ తీగలను సంగ్రహించవచ్చు
స్ట్రింగ్ new_string = st + 'మరియు' + std_st cout<< new_string <
 అవుట్పుట్: 
St ద్వారా హలో మరియు std_st ద్వారా హలో
 అనుబంధ తీగలు: .Append (స్ట్రింగ్) క్లాస్ మెంబర్ ఫంక్షన్ స్ట్రింగ్‌లోని ఒక నిర్దిష్ట అక్షర స్థానంలో ఒక స్ట్రింగ్‌ను కలపడానికి మరియు జోడించడానికి ఉపయోగించవచ్చు. ఒక ప్రోగ్రామర్ str.append (str1, p, n) ను ఉంచితే, స్ట్రింగ్ str1 లోని స్థానం p నుండి n సంఖ్యల సంఖ్య str యొక్క చివరికి జోడించబడుతుంది.
స్ట్రింగ్ str = 'నేను నేర్చుకోవడం ఆనందించాను' string str1 = 'పైథాన్, C ++, లేదా C' str.append (str1, 8, 3) cout<< str << endl
 అవుట్పుట్: 
జావా పద్ధతి నుండి బయటపడింది
నేను సి ++ నేర్చుకోవడం ఆనందించాను
 తీగలను శోధిస్తోంది: మరొక లోపల స్ట్రింగ్ యొక్క మొదటి సంఘటనను కనుగొనడానికి మేము ఫైండ్ () సభ్యుల ఫంక్షన్‌ను ఉపయోగించవచ్చు. కనుగొను () స్థానం పోస్ నుండి ప్రారంభమయ్యే స్ట్రింగ్ గడ్డివాము లోపల స్ట్రింగ్ సూది కోసం చూస్తుంది మరియు సూది యొక్క మొదటి సంభవించిన స్థానాన్ని తిరిగి ఇస్తుంది. ఫంక్షన్ rfind () అదేవిధంగా పనిచేస్తుంది, ఇది ఆమోదించిన స్ట్రింగ్ యొక్క చివరి సంఘటనను తిరిగి ఇస్తుంది తప్ప.
స్ట్రింగ్ గడ్డివాము = 'హలో వరల్డ్!' స్ట్రింగ్ సూది = 'o' కౌట్<< haystack.find(needle)<
 అవుట్పుట్: 
4 4 7 4294967295
మొదటి కౌట్ కమాండ్ కేవలం '4' ను ప్రింట్ చేస్తుంది, ఇది గడ్డివాము స్ట్రింగ్‌లో “o” యొక్క మొదటి సంఘటన యొక్క సూచిక. మనకు “వరల్డ్” లో “ఓ” కావాలంటే, మొదటి సంఘటనను సూచించడానికి “పోస్” ను సవరించాలి. haystack.find (సూది, 4) మళ్ళీ 4 ను తిరిగి ఇస్తుంది, అయితే haystack.find (సూది, 5) 7 ఇస్తుంది. సబ్‌స్ట్రింగ్ కనుగొనబడకపోతే, కనుగొనండి () std :: string :: npos.
Npos అనేది సైజు_టైప్ రకం ద్వారా సూచించబడే గరిష్ట విలువకు సమానమైన ప్రత్యేక విలువ. ఇక్కడ ఇది 4294967295. సాధారణంగా, స్ట్రింగ్ సూచికను ఆశించే ఫంక్షన్ల ద్వారా స్ట్రింగ్ ఇండికేటర్ ముగింపుగా లేదా స్ట్రింగ్ ఇండెక్స్‌ను తిరిగి ఇచ్చే ఫంక్షన్ల ద్వారా లోపం సూచికగా ఉపయోగిస్తారు.
హాష్ మ్యాప్ vs హాష్ టేబుల్
ఈ సాధారణ కోడ్ str2 లోని “C ++” యొక్క అన్ని సంఘటనల కోసం ఒక స్ట్రింగ్‌ను శోధిస్తుంది మరియు వాటి స్థానాలను ముద్రిస్తుంది:
స్ట్రింగ్ str2 = 'C ++ అనేది ఆబ్జెక్ట్-ఓరియెంటెడ్ ప్రోగ్రామింగ్ లాంగ్వేజ్ మరియు తరగతులు, వారసత్వం, పాలిమార్ఫిజం, డేటా సంగ్రహణ మరియు ఎన్కప్సులేషన్‌ను కలిగి ఉంటుంది. C. ++ మినహాయింపు నిర్వహణను అనుమతిస్తుంది మరియు C.C ++ లో సాధ్యం కాని ఫంక్షన్ ఓవర్‌లోడింగ్ శక్తివంతమైన, సమర్థవంతమైన మరియు వేగవంతమైన భాష. ' for (string :: size_type i = 0, tfind (tfind = wikistr.find ('C ++', i))! = string :: npos i = tfind + 1) {std :: cout<< 'Found occurrence of 'C++' at position ' << tfind << std::endl }
 అవుట్పుట్: 
స్థానం 0 వద్ద 'సి ++' కనుగొనబడింది 132 స్థానంలో 'సి ++' సంభవించింది 212 స్థానంలో 'సి ++' సంభవించింది
# నేమ్‌స్పేస్‌ను ఉపయోగించి చేర్చండి std క్లాస్ బేస్ {పబ్లిక్: శూన్యమైన ఫన్_1 () {కౌట్<< 'base class function 1n' } virtual void fun_2() { cout << 'base class function 2n' } virtual void fun_3() { cout << 'base class function 3n' } virtual void fun_4() { cout << 'base class function 4n' } } class derived : public base { public: void fun_1() { cout << 'derived class function 1n' } void fun_2() { cout << 'derived class function 2n' } void fun_4(int x) { cout fun_2 () // లేట్ బైండింగ్ (RTP) ptr-> fun_3 () // లేట్ బైండింగ్ (RTP) ptr-> fun_4 () // ప్రారంభ బైండింగ్ కానీ ఈ ఫంక్షన్ కాల్ // చట్టవిరుద్ధం (లోపం ఉత్పత్తి చేస్తుంది) ఎందుకంటే పాయింటర్ // యొక్క బేస్ రకం మరియు ఫంక్షన్ // ఉత్పన్న తరగతి // p-> fun_4 (5)}
 అవుట్పుట్: 
బేస్ క్లాస్ ఫంక్షన్ 1 ఉత్పన్నమైన క్లాస్ ఫంక్షన్ 2 బేస్ క్లాస్ ఫంక్షన్ 3 బేస్ క్లాస్ ఫంక్షన్ 4
 దీనితో, మేము C ++ లోని స్ట్రింగ్స్‌పై ఈ కథనాన్ని ముగించాము. దానిపై చేయగలిగే వివిధ ఆపరేషన్ల గురించి మీకు అవగాహన వచ్చిందని నేను ఆశిస్తున్నాను. మీరు మరింత తెలుసుకోవాలనుకుంటే, విశ్వసనీయ ఆన్‌లైన్ లెర్నింగ్ సంస్థ ఎడురేకా చేత జావా శిక్షణను చూడండి. ఎడురేకా  శిక్షణ మరియు ధృవీకరణ కోర్సు కోర్ మరియు అధునాతన జావా భావనలతో పాటు హైబర్నేట్ & స్ప్రింగ్ వంటి వివిధ జావా ఫ్రేమ్‌వర్క్‌ల కోసం మీకు శిక్షణ ఇవ్వడానికి రూపొందించబడ్డాయి. 
 మాకు ప్రశ్న ఉందా? దయచేసి ఈ బ్లాగ్ యొక్క వ్యాఖ్యల విభాగంలో దీనిని ప్రస్తావించండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.