తరగతి మరియు వస్తువులు
క్లాస్ అనేది వేరియబుల్స్ మరియు ఫంక్షన్ల సమిష్టిగా పనిచేస్తుంది; వేరియబుల్స్ కేటాయించిన విలువలు లేని చోట. వేరియబుల్స్‌కు విలువలు కేటాయించినప్పుడు, తరగతి ఒక వస్తువు అవుతుంది. ఒకే తరగతికి ఇచ్చిన విభిన్న విలువలు వేర్వేరు వస్తువులను కలిగిస్తాయి; అంటే, విభిన్న వస్తువులు ఒకే విలువ కలిగిన ఒకే తరగతి. తరగతి నుండి ఒక వస్తువును సృష్టించడం ఆ వస్తువును తక్షణం చెప్పడం.
పేరు, స్ట్రింగ్, ఒక తరగతి. స్ట్రింగ్ క్లాస్ నుండి సృష్టించబడిన ఒక ఆబ్జెక్ట్ ప్రోగ్రామర్ ఎంచుకున్న పేరును కలిగి ఉంది.
తరగతికి చెందిన ఒక వస్తువును తరగతి నుండి తక్షణం అమలు చేయడానికి అవసరం. C ++ లో, ఆ ఫంక్షన్ క్లాస్ పేరు వలె అదే పేరును కలిగి ఉంటుంది. తరగతి నుండి సృష్టించబడిన (తక్షణం) ఆబ్జెక్ట్‌లు ప్రోగ్రామర్ ద్వారా వారికి వేర్వేరు పేర్లు ఇవ్వబడ్డాయి.
తరగతి నుండి వస్తువును సృష్టించడం అంటే వస్తువును నిర్మించడం; ఇది తక్షణం అని కూడా అర్థం.
స్ట్రింగ్ క్లాస్‌ని ఉపయోగించే C ++ ప్రోగ్రామ్, ఫైల్ ఎగువన కింది లైన్‌లతో మొదలవుతుంది:
#చేర్చండి#చేర్చండి
నేమ్‌స్పేస్ std ఉపయోగించి;
మొదటి లైన్ ఇన్‌పుట్/అవుట్పుట్ కోసం. స్ట్రింగ్ క్లాస్ యొక్క అన్ని ఫీచర్‌లను ఉపయోగించడానికి ప్రోగ్రామ్‌ని అనుమతించడం రెండవ లైన్. మూడవ పంక్తి ప్రామాణిక నేమ్‌స్పేస్‌లోని పేర్లను ఉపయోగించడానికి ప్రోగ్రామ్‌ను అనుమతిస్తుంది.
ఫంక్షన్‌ని ఓవర్‌లోడ్ చేస్తోంది
రెండు లేదా అంతకంటే ఎక్కువ విభిన్న ఫంక్షన్ సంతకాలు ఒకే పేరును కలిగి ఉన్నప్పుడు, ఆ పేరు ఓవర్‌లోడ్ చేయబడిందని చెప్పబడింది. ఒక ఫంక్షన్‌ను పిలిచినప్పుడు, ఆర్గ్యుమెంట్‌ల సంఖ్య మరియు రకం, ఏ ఫంక్షన్ అమలు చేయబడుతుందో నిర్ణయించండి.
నిర్మాణం
స్ట్రింగ్ ()
కింది స్టేట్‌మెంట్ అక్షరం లేకుండా సున్నా పొడవు స్ట్రింగ్‌ని నిర్మిస్తుంది.
ఇది తరగతి (వస్తువు రకం), స్ట్రింగ్ పేరుతో ప్రారంభమవుతుంది. దీని తర్వాత ప్రోగ్రామర్ అందించిన ఆబ్జెక్ట్ స్ట్రింగ్ కోసం పేరు వస్తుంది. అసైన్‌మెంట్ ఆపరేటర్ అనుసరిస్తాడు; అప్పుడు ఖాళీ కుండలీకరణాలతో కన్స్ట్రక్టర్ పేరు. ఇక్కడ, strCol అనేది మొత్తం డేటా సభ్యులు (లక్షణాలు) మరియు సభ్యుల విధులు (పద్ధతులు) కలిగిన తక్షణ వస్తువు.
స్ట్రింగ్ (str)
ఇది పైవాటిని పోలి ఉంటుంది, కానీ కన్స్ట్రక్టర్‌లో స్ట్రింగ్ లిటరల్ లేదా ఐడెంటిఫైయర్‌ను వాదనగా తీసుకుంటుంది. కింది ప్రకటన దీనిని వివరిస్తుంది:
ఇనిషియలైజర్ జాబితాతో నిర్మాణం
కింది కోడ్ దీనిని వివరిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్({'నేను','','ది','లేదా','v','మరియు','','మరియు','లేదా','u',' 0'});స్ట్రింగ్ అక్షరాలా నేను నిన్ను ప్రేమిస్తున్నాను. ఇనిషియలైజర్ జాబితా చివరన ఉన్న శూన్య అక్షరాన్ని గమనించండి.
స్ట్రింగ్ (str, n)
ఇది మరొక స్ట్రింగ్ యొక్క మొదటి n అక్షరాల స్ట్రింగ్ సేకరణను రూపొందిస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
చార్p[] = 'నేను నిన్ను ప్రేమిస్తున్నాను';స్ట్రింగ్ strCol=స్ట్రింగ్(p, 6);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్ అంటే నేను నిన్ను ప్రేమిస్తున్న మొదటి 6 అక్షరాలతో ప్రేమించాను. గుర్తుంచుకోండి: ఒకే స్థలం ఒక పాత్ర.
స్ట్రింగ్ (str, pos, n)
ఇది n అక్షరాల స్ట్రింగ్ సేకరణను రూపొందిస్తుంది, మరొక స్ట్రింగ్ యొక్క సున్నా-ఆధారిత సూచిక స్థానం, pos నుండి ప్రారంభమవుతుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
చార్p[] = 'నేను నిన్ను ప్రేమిస్తున్నాను';స్ట్రింగ్ strCol=స్ట్రింగ్(p, 2, 4);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్, ప్రేమ.
పై రెండు సందర్భాలలో, స్ట్రింగ్ పరిమాణం కంటే n ఎక్కువ ఉంటే, out_of_range మినహాయింపు విసిరివేయబడుతుంది - తర్వాత చూడండి.
స్ట్రింగ్ (n, 'c')
అన్ని అక్షరాలు ఒకేలా ఉండే n అక్షరాల సేకరణను రూపొందిస్తుంది. పరిగణించండి,
స్ట్రింగ్ strCol=స్ట్రింగ్(5,'మరియు');ఖరీదు<<strCol<< ' n';
అవుట్పుట్, ఈఈ, 5 ఇ.
స్ట్రింగ్‌ను కేటాయించడం
రెండు స్ట్రింగ్‌లను ప్రకటించిన తర్వాత, స్ట్రింగ్‌ను ఈ క్రింది విధంగా కేటాయించవచ్చు:
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2;
strCol2=strCol1;
ఖరీదు<<strCol2<< ' n';
అవుట్పుట్ ఏమిటంటే, నేను నిన్ను ప్రేమిస్తున్నాను.
ఐటరేటర్‌తో నిర్మాణం
ఇటరేటర్ స్కానింగ్ యొక్క సాధారణ ప్రాతినిధ్యాన్ని సేకరణ విలువల ద్వారా అందిస్తుంది. ఇటరేటర్‌తో స్ట్రింగ్‌ను రూపొందించడానికి వాక్యనిర్మాణం:
టెంప్లేట్<తరగతి ఇన్పుట్ఇట్రేటర్>బేసిక్_స్ట్రింగ్(ఇన్‌పుట్ ఇట్రేటర్ ప్రారంభమవుతుంది,ఇన్పుట్ఇట్రేటర్ ముగింపు, కానిస్టేట్కేటాయించేవాడు&
కు=కేటాయించేవాడు());
ఇది పరిధి కోసం ఒక స్ట్రింగ్‌ను నిర్మిస్తుంది [ప్రారంభం, ముగింపు) - తర్వాత వివరాలను చూడండి.
స్ట్రింగ్‌ను నాశనం చేయడం
స్ట్రింగ్‌ని నాశనం చేయడానికి, అది పరిధి నుండి బయటపడనివ్వండి.
స్ట్రింగ్ క్లాస్ ఎలిమెంట్ యాక్సెస్
ఒక తక్షణ స్ట్రింగ్ వస్తువును శ్రేణి వలె ఉప-స్క్రిప్ట్ చేయవచ్చు (ఇండెక్స్ చేయబడింది). సూచిక లెక్కింపు సున్నా నుండి ప్రారంభమవుతుంది.
స్ట్రింగ్ నేమ్ [i]
ఆపరేషన్ స్ట్రింగ్ నేమ్ [i] i వద్ద అక్షరానికి (మూలకం) సూచనను అందిస్తుందివఅక్షర సేకరణ యొక్క సూచిక. కింది కోడ్ అవుట్‌పుట్‌లు v:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol[4];
ఖరీదు<<చ<< ' n';
stringName [i] const
స్ట్రింగ్ ఆబ్జెక్ట్ స్థిరమైన వస్తువు అయినప్పుడు స్ట్రింగ్ నేమ్ [i] కి బదులుగా ఆపరేషన్ స్ట్రింగ్ నేమ్ [i] const అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు:
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol[4];
ఖరీదు<<చ<< ' n';
వ్యక్తీకరణ i కి స్థిరమైన సూచనను అందిస్తుందివస్ట్రింగ్ వస్తువు యొక్క మూలకం. స్ట్రింగ్ యొక్క మూలకాలు ఏవీ మార్చబడవు.
సబ్‌స్క్రిప్ట్‌తో అక్షరాన్ని కేటాయించడం
కింది విధంగా నిరంతర స్ట్రింగ్ ఆబ్జెక్ట్‌కు అక్షరాన్ని కేటాయించవచ్చు:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను పిలుస్తాను');strCol[2] = 'f';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్ నేను పడిపోయాను. 'C' 'f' గా మార్చబడింది.
stringName.at (i)
stringName.at (i) అనేది stringName [i] లాగా ఉంటుంది, కానీ stringName.at (i) మరింత విశ్వసనీయమైనది. కింది కోడ్ దీన్ని ఎలా ఉపయోగించాలో చూపుతుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.వద్ద(4);
ఖరీదు<<చ<< ' n';
at () నిజానికి స్ట్రింగ్ క్లాస్ మెంబర్ ఫంక్షన్.
stringName.at (i) const
stringName.at (i) const అనేది stringName [i] const లాగా ఉంటుంది, కానీ stringName.at (i) const మరింత విశ్వసనీయమైనది. స్ట్రింగ్ ఆబ్జెక్ట్ స్థిరమైన స్ట్రింగ్ ఆబ్జెక్ట్ అయినప్పుడు stringName.at (i) const స్ట్రింగ్ నేమ్.అట్ (i) కి బదులుగా అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు:
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.వద్ద(4);
ఖరీదు<<చ<< ' n';
at () const నిజానికి స్ట్రింగ్ క్లాస్ మెంబర్ ఫంక్షన్.
వద్ద () ఫంక్షన్‌తో విలువను కేటాయించడం
వద్ద () ఫంక్షన్‌తో, ఒక నిరంతర స్ట్రింగ్ ఆబ్జెక్ట్‌కు ఒక విలువను ఈ విధంగా కేటాయించవచ్చు:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను పిలుస్తాను');strCol.వద్ద(2) = 'f';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్ నేను పడిపోయాను.
సబ్-స్క్రిప్టింగ్‌తో సమస్య
ఉప-స్క్రిప్టింగ్ (ఇండెక్సింగ్) తో సమస్య ఏమిటంటే, ఇండెక్స్ పరిధికి మించి ఉంటే, తప్పు ఫలితం పొందవచ్చు లేదా రన్-టైమ్‌లో లోపం సంభవించవచ్చు.
ముందు ()
ఇది మూలకాన్ని తీసివేయకుండా, స్ట్రింగ్ వస్తువు యొక్క మొదటి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్పుట్ 'I'.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.ముందు();
ఖరీదు<<చ<< ' n';
స్ట్రింగ్ వస్తువు నుండి అక్షరం తీసివేయబడలేదు.
ముందు () const
స్ట్రింగ్ ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్ట్ ఉన్నప్పుడు, ఫ్రంట్ () కు బదులుగా ఫ్రంట్ () కాన్స్ట్ అనే ఎక్స్‌ప్రెషన్ అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.ముందు();
ఖరీదు<<చ<< ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. స్ట్రింగ్ వస్తువు నుండి మూలకం తీసివేయబడలేదు. స్థిరమైన స్ట్రింగ్ వస్తువు కోసం ఏ అక్షరాన్ని మార్చలేము.
తిరిగి ()
ఇది మూలకాన్ని తీసివేయకుండా, స్ట్రింగ్ వస్తువు యొక్క చివరి మూలకానికి సూచనను అందిస్తుంది. కింది కోడ్ యొక్క అవుట్పుట్ 'u'.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.తిరిగి();
ఖరీదు<<చ<< ' n';
తిరిగి () కానిస్టేట్
స్ట్రింగ్ ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ బ్యాక్ () కాస్ట్ బదులుగా () కు బదులుగా అమలు చేయబడుతుంది. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');చార్చ=strCol.తిరిగి();
ఖరీదు<<చ<< ' n';
స్థిరమైన సూచన తిరిగి ఇవ్వబడుతుంది. స్ట్రింగ్ వస్తువు నుండి మూలకం తీసివేయబడలేదు.
స్ట్రింగ్ సామర్థ్యం
size_type సామర్థ్యం () const noexcept
పునloస్థాపన అవసరం లేకుండా స్ట్రింగ్ కలిగి ఉన్న మొత్తం అక్షరాల సంఖ్య, ఈ సామర్థ్య సభ్యుల ఫంక్షన్ ద్వారా తిరిగి ఇవ్వబడుతుంది. దీని కోసం కోడ్ సెగ్మెంట్:
స్ట్రింగ్ strCol=స్ట్రింగ్();intఒకదానిపై=strCol.సామర్థ్యం();
ఖరీదు<<ఒకదానిపై<< ' n';
నా కంప్యూటర్‌లో అవుట్పుట్ 15.
రిజర్వ్ (n)
మెమరీ స్థలం ఎల్లప్పుడూ ఉచిత స్టోర్‌లో అందుబాటులో ఉండదు. అదనపు స్థలాన్ని ముందుగానే రిజర్వ్ చేసుకోవచ్చు. కింది కోడ్ విభాగాన్ని పరిగణించండి:
స్ట్రింగ్ strCol=స్ట్రింగ్('ప్రేమ');strCol.రిజర్వ్(6);
ఖరీదు<<strCol.సామర్థ్యం() << ' n';
నా కంప్యూటర్‌లో అవుట్పుట్ 15.
పరిమాణం () const noexcept
ఇది స్ట్రింగ్‌లోని అక్షరాల సంఖ్యను అందిస్తుంది. కింది కోడ్ వివరిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');intఒకదానిపై=strCol.పరిమాణం();
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్ 10, ఇందులో nul, 0 అక్షరం ఉండదు.
పొడవు () కానిస్టెప్ట్
-పరిమాణం వలె().గమనిక:పరిమాణం() <=సామర్థ్యం().
కుదించు_కు_ (
సామర్థ్యాన్ని () పరిమాణానికి తగ్గించవచ్చు () రియల్‌లొకేషన్‌కు కారణమవుతుంది; అది తప్పనిసరి కాదు. కింది కోడ్ దీనిని ప్రదర్శిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol.రిజర్వ్(12);
strCol.కుదించు_కు();
intలు=strCol.పరిమాణం();
ఖరీదు<<లు<< ' n';
అవుట్పుట్ 10 మరియు 12 లేదా 16 కాదు. ఫంక్షన్ శూన్యంగా తిరిగి వస్తుంది.
పునizeపరిమాణం (sz), పునizeపరిమాణం (sz, 'c')
ఇది స్ట్రింగ్ పరిమాణాన్ని మారుస్తుంది. ఒకవేళ కొత్త సైజు పాత సైజు కంటే చిన్నగా ఉంటే, చివర ఉన్న ఎలిమెంట్స్ చెరిపివేయబడతాయి. కొత్త పరిమాణం పొడవుగా ఉంటే, చివరికి కొంత డిఫాల్ట్ అక్షరం జోడించబడుతుంది. నిర్దిష్ట అక్షరాన్ని జోడించడానికి, రెండు ఆర్గ్యుమెంట్‌లతో పునizeపరిమాణం () ఫంక్షన్‌ని ఉపయోగించండి. కింది కోడ్ సెగ్మెంట్ రెండు ఫంక్షన్ల వినియోగాన్ని వివరిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol.పరిమాణం మార్చండి(6);
ఖరీదు<< 'కొత్త పరిమాణం strCol:' <<strCol.పరిమాణం() << ' n';
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను', 'మరియు');
strCol1.పరిమాణం మార్చండి(12);
ఖరీదు<< 'StrCol1 యొక్క కొత్త పరిమాణం:' <<strCol1.పరిమాణం() << ' n';
అవుట్పుట్:
StrCol కొత్త పరిమాణం: 6StrCol1:12 యొక్క కొత్త పరిమాణం
ఫంక్షన్ శూన్యతను అందిస్తుంది.
స్పష్టమైన () మినహా
స్ట్రింగ్ నుండి అన్ని మూలకాలను తొలగిస్తుంది, కింది కోడ్ సెగ్మెంట్ వివరిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol.స్పష్టమైన();
ఖరీదు<<strCol.పరిమాణం() << ' n';
అవుట్పుట్ 0. ఫంక్షన్ శూన్యతను అందిస్తుంది.
ఖాళీ () కానిస్టెప్ట్
స్ట్రింగ్ ఆబ్జెక్ట్‌లో అక్షరం లేనట్లయితే ఇది నిజం కోసం 1 లేదా స్ట్రింగ్ ఆబ్జెక్ట్ ఖాళీగా లేనట్లయితే తప్పుడు కోసం 0 ని అందిస్తుంది. కింది కోడ్ దీనిని వివరిస్తుంది:
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');ఖరీదు<<strCol1.ఖాళీ() << ' n';
స్ట్రింగ్ strCol2=స్ట్రింగ్();
ఖరీదు<<strCol2.ఖాళీ() << ' n';
అవుట్పుట్:
01
రిటర్నింగ్ ఐటరేటర్లు మరియు స్ట్రింగ్ క్లాస్
ఇటరేటర్ ఒక పాయింటర్ లాంటిది కానీ పాయింటర్ కంటే ఎక్కువ కార్యాచరణను కలిగి ఉంటుంది.
ప్రారంభం () తప్ప
కింది కోడ్ విభాగంలో వలె స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క మొదటి అక్షరాన్ని (మూలకం) సూచించే ఇటరేటర్‌ను అందిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::iteratoriter=strCol.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 'I'. ఇటరేటర్‌ను అందుకున్న డిక్లరేషన్ ప్రకటించబడిన విధానాన్ని గమనించండి. పాయింటర్ డిఫరెన్స్ చేయబడిన విధంగా, విలువను పొందడానికి రిటర్న్ ఎక్స్‌ప్రెషన్‌లో ఇటరేటర్ డిఫరెన్స్ చేయబడింది.
start () const noexcept;
స్ట్రింగ్ ఆబ్జెక్ట్ సేకరణ యొక్క మొదటి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది. ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్టాట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ప్రారంభం () కాంట్ స్టార్ట్ () కి బదులుగా అమలు చేయబడుతుంది. ఈ పరిస్థితిలో, వస్తువులోని సంబంధిత మూలకాన్ని సవరించలేము. ఇది క్రింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::const_iteratoriter=strCol.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 'I'. తిరిగి ఇచ్చిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం ఇటరేటర్‌కు బదులుగా ఈసారి const_iterator ఉపయోగించబడిందని గమనించండి.
ముగింపు () తప్ప
స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క చివరి ఎలిమెంట్‌ని మించి వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::iteratoriter=strCol.ముగింపు();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ శూన్యమైనది, ఇది ఏమీ కాదు, ఎందుకంటే గత మూలకానికి మించిన కాంక్రీట్ మూలకం లేదు.
ముగింపు () const noexcept
స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క చివరి ఎలిమెంట్‌ని మించి వెంటనే సూచించే ఇటరేటర్‌ను అందిస్తుంది. స్ట్రింగ్ ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్ట్ ఉన్నప్పుడు, ఎక్స్‌ప్రెషన్ ఎండ్ () కాన్స్ట్ అనేది ఎండ్ () కి బదులుగా అమలు చేయబడుతుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::const_iteratoriter=strCol.ముగింపు();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ శూన్యం. తిరిగి ఇచ్చిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం ఇటరేటర్‌కు బదులుగా ఈసారి const_iterator ఉపయోగించబడిందని గమనించండి.
రివర్స్ ఇట్రేషన్
మొదటి మూలకానికి ముందు వాస్తవ ముగింపు నుండి ఇట్రేట్ చేసే ఇటరేటర్‌ను కలిగి ఉండటం సాధ్యమే:
rbegin () తప్ప
కింది కోడ్ విభాగంలో వలె స్ట్రింగ్ ఇన్‌స్టాంటియేటెడ్ ఆబ్జెక్ట్ యొక్క చివరి ఎలిమెంట్‌ను సూచించే ఇటరేటర్‌ను అందిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::reverse_iteratoriter=strCol.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 'u'. రివర్స్ ఇటరేటర్‌ను అందుకున్న డిక్లరేషన్ ప్రకటించబడిన విధానాన్ని గమనించండి. పాయింటర్ డిఫరెన్స్ చేయబడిన విధంగా, విలువను పొందడానికి రిటర్న్ ఎక్స్‌ప్రెషన్‌లో ఇటరేటర్ డిఫరెన్స్ చేయబడింది.
rbegin () const noexcept;
స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క చివరి మూలకాన్ని సూచించే ఇటరేటర్‌ను అందిస్తుంది. ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్ట్ ఉన్నప్పుడు, rbegin () కు బదులుగా rbegin () const అనే ఎక్స్‌ప్రెషన్ అమలు చేయబడుతుంది. ఈ పరిస్థితిలో, వస్తువులోని సంబంధిత మూలకాన్ని సవరించలేము. ఈ ఫీచర్ కింది కోడ్‌లో ఉపయోగించబడుతుంది, ఉదాహరణకు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::const_reverse_iteratoriter=strCol.ప్రారంభించండి();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ 'u'. రిటర్న్ చేయబడిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం రివర్స్_ఇటరేటర్‌కు బదులుగా ఈసారి const_reverse_iterator ఉపయోగించబడిందని గమనించండి.
రెండర్ () తప్ప
స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క మొదటి మూలకానికి ముందు సూచించే ఇటరేటర్‌ను అందిస్తుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::reverse_iteratoriter=strCol.తయారీలను();
ఖరీదు<< *iter<< ' n';
మొదటి మూలకం ముందు కాంక్రీట్ మూలకం లేనందున అవుట్పుట్ శూన్యం, ఇది ఏమీ కాదు.
రెండర్ () కానిస్టెప్ట్
స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క మొదటి మూలకానికి ముందు సూచించే ఇటరేటర్‌ను అందిస్తుంది. ఆబ్జెక్ట్ నిర్మాణానికి ముందు కాన్స్ట్ ఉన్నప్పుడు, రెండ్ () కి బదులుగా రెండ్ () const అనే ఎక్స్‌ప్రెషన్ అమలు చేయబడుతుంది. కింది కోడ్ విభాగాన్ని పరిగణించండి:
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::const_reverse_iteratoriter=strCol.తయారీలను();
ఖరీదు<< *iter<< ' n';
అవుట్పుట్ శూన్యం. రిటర్న్ చేయబడిన ఇట్రేటర్‌ను స్వీకరించడానికి కేవలం రివర్స్_ఇటరేటర్‌కు బదులుగా ఈసారి const_reverse_iterator ఉపయోగించబడిందని గమనించండి.
స్ట్రింగ్ మాడిఫైయర్లు
స్ట్రింగ్ ఆబ్జెక్ట్‌ను సవరించే మాడిఫైయర్, ఇటరేటర్‌ను కూడా తీసుకోవచ్చు లేదా తిరిగి ఇవ్వవచ్చు.
కలుపుతోంది
బేసిక్_స్ట్రింగ్&ఆపరేటర్+ =(కానిస్టేట్బేసిక్_స్ట్రింగ్&p)కుడి స్ట్రింగ్ వస్తువును ఎడమ స్ట్రింగ్ ఆబ్జెక్ట్‌కు జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('నువ్వు');
strCol1+ =strCol2;
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్ ఐ లవ్ యు. StrCol1 += strCol2 strCol1 = strCol1 +strCol2 లాగానే ఉంటుంది అని మర్చిపోవద్దు.
బేసిక్_స్ట్రింగ్ & ఆపరేటర్+= (const charT* s)
స్ట్రింగ్ ఆబ్జెక్ట్ సేకరణకు స్ట్రింగ్ అక్షరాలా జోడించబడింది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol+ = 'నువ్వు';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను.
బేసిక్_స్ట్రింగ్ & ఆపరేటర్+= (చార్ట్ సి)
ఒక వస్తువు స్ట్రింగ్‌కు ఒకే అక్షరాన్ని జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol+ = 'u';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను.
బేసిక్_స్ట్రింగ్ & ఆపరేటర్+= (initializer_list)
ఇనిషియలైజర్ జాబితాను జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol+ = {'','మరియు','లేదా','u',' 0'};
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను. అక్షరం ఇనిషియలైజర్ జాబితా చివరన nul, 0 ని జోడించడం ఎల్లప్పుడూ మంచిది.
బేసిక్_స్ట్రింగ్ & అపెండ్ (కాన్స్ట్ బేసిక్_స్ట్రింగ్ & స్ట్రీ)
ఆర్గ్యుమెంట్ స్ట్రింగ్ ఆబ్జెక్ట్‌ను ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌కు జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('నువ్వు');
strCol1.అనుబంధం(strCol2);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను.
బేసిక్_స్ట్రింగ్ & అపెండ్ (const charT* s)
ప్రధాన స్ట్రింగ్‌కు స్ట్రింగ్ అక్షర వాదనను జోడిస్తుంది. ఉదాహరణ
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol=strCol.అనుబంధం('నువ్వు');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను.
బేసిక్_స్ట్రింగ్ & అపెండ్ (ఇనిషియలైజర్_లిస్ట్)
ప్రధాన స్ట్రింగ్‌కు వాదన అయిన ఇనిషియలైజర్ జాబితాను జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol=strCol.అనుబంధం({'','మరియు','లేదా','u',' 0'});
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను. ఇనిషియలైజర్ జాబితా చివరన nul, 0 అక్షరాన్ని జోడించడం ఎల్లప్పుడూ మంచిది.
బేసిక్_స్ట్రింగ్ & అపెండ్ (size_type n, charT c)
అదే పాత్ర యొక్క n ని జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('టాబ్');strCol=strCol.అనుబంధం(2, 'లేదా');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నిషిద్ధం.
బేసిక్_స్ట్రింగ్ & అపెండ్ (const charT* s, size_type n)
స్ట్రింగ్ యొక్క మొదటి n మూలకాలను ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌కు జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol=strCol.అనుబంధం('నువ్వు అలా', 4);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను. అక్షరార్థం కంటే n ఎక్కువ ఉంటే, లెంగ్త్_ఎర్రర్ మినహాయింపు విసిరివేయబడుతుంది.
బేసిక్_స్ట్రింగ్ & అపెండ్ (కాన్స్ట్ బేసిక్_స్ట్రింగ్ & స్ట్రీ, సైజ్_టైప్ పోస్, సైజ్_టైప్ ఎన్ = ఎన్‌పోస్)
ఇండెక్స్, పోస్ నుండి ప్రధాన అక్షరానికి n అక్షరాలను జోడిస్తుంది. ఉదాహరణ:
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను ప్రేమిస్తున్నాను');strCol=strCol.అనుబంధం(నువ్వు అలా ఉన్నావు ', 2, 4);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: నేను నిన్ను ప్రేమిస్తున్నాను. మినహాయింపు కూడా ఇక్కడ వేయబడుతుంది, తర్వాత చూడండి.
కేటాయించడం
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(కానిస్టేట్బేసిక్_స్ట్రింగ్&p)ఆర్గ్యుమెంట్ స్ట్రింగ్ ఆబ్జెక్ట్‌ను ప్రధాన స్ట్రింగ్‌కు కేటాయిస్తుంది, అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('ఆమెకు నేను కావాలి');
strCol1=strCol1.కేటాయించవచ్చు(strCol2);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: ఆమెకు నేను కావాలి.
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(కానిస్టేట్charT*లు)ప్రధాన స్ట్రింగ్‌కు స్ట్రింగ్ అక్షర వాదనను కేటాయిస్తుంది, అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol=strCol.కేటాయించవచ్చు('ఆమెకు నేను కావాలి');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: ఆమెకు నేను కావాలి.
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(initializer_list<charT>)ప్రధాన స్ట్రింగ్‌కి ఇనిషియలైజర్ జాబితా వాదనను కేటాయిస్తుంది,అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేయడం.
[cc లాంగ్='సి'తప్పించుకున్నారు='నిజం'వెడల్పు='780']
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');
strCol=strCol.కేటాయించవచ్చు({'ఎస్','h','మరియు','','n','మరియు','మరియు','d','s','','m','మరియు',' 0'});
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: ఆమెకు నేను కావాలి. అక్షర జాబితా చివరన n ను ఎల్లప్పుడూ జోడించడం మంచిది, స్ట్రింగ్ అక్షరాలా.
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(కానిస్టేట్charT*లు,size_type n)స్ట్రింగ్ అక్షర వాదన యొక్క మొదటి n అక్షరాలను ప్రధాన స్ట్రింగ్‌కు కేటాయిస్తుంది, అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol=strCol.కేటాయించవచ్చు('ఆమెకు నేను కావాలి', 9);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: ఆమెకు అవసరం.
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(size_type n,చార్ట్ సి)ప్రధాన అక్షరానికి అదే అక్షరాల n యొక్క వాదనను కేటాయిస్తుంది, అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol=strCol.కేటాయించవచ్చు(4, 'మరియు');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: eeee
బేసిక్_స్ట్రింగ్&కేటాయించవచ్చు(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos,size_type n=npos)
స్ట్రింగ్ ఆబ్జెక్ట్ ఆర్గ్యుమెంట్ యొక్క ఎన్ అక్షరాలను పోస్ నుండి మొదలుకొని, ప్రధాన స్ట్రింగ్ వరకు, అక్కడ ఉన్న ఏదైనా కంటెంట్‌ను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol=strCol.కేటాయించవచ్చు('ఆమెకు నేను కావాలి', 4, 5);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: అవసరాలు. మినహాయింపును విసురుతాను - తర్వాత చూడండి.
చొప్పించడం
బేసిక్_స్ట్రింగ్&చొప్పించు(size_type pos, కానిస్టేట్బేసిక్_స్ట్రింగ్&p)స్ట్రింగ్ ఆబ్జెక్ట్ ఆర్గ్యుమెంట్‌ను ప్రధాన స్ట్రింగ్‌కి, ఇండెక్స్, pos వద్ద ఇన్సర్ట్ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('ద్వేషం మరియు');
strCol1=strCol1.చొప్పించు(2,strCol2);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను నిన్ను ద్వేషిస్తున్నాను మరియు ప్రేమిస్తున్నాను. మినహాయింపును విసురుతాను - తర్వాత చూడండి.
బేసిక్_స్ట్రింగ్&చొప్పించు(size_type pos1, కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos2,size_type n=npos)
స్ట్రింగ్ ఆబ్జెక్ట్ ఆర్గ్యుమెంట్ యొక్క pos2 నుండి, ప్రధాన స్ట్రింగ్‌కు, ఇండెక్స్, pos1 వద్ద n అక్షరాల పొడవును ఇన్సర్ట్ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('ద్వేషం, కావాలి మరియు అవసరం');
strCol1=strCol1.చొప్పించు(2,strCol2, 6, 9);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను నిన్ను కోరుకుంటున్నాను మరియు ప్రేమిస్తున్నాను.
ఇటరేటర్ ఇన్సర్ట్ (const_iterator p, charT c)
ఇట్రేటర్ సూచించిన స్థానానికి వాదన అయిన ఒక నిర్దిష్ట అక్షరాన్ని ఇన్సర్ట్ చేస్తుంది. కొత్తగా చొప్పించిన అక్షరం యొక్క స్థానం కోసం ఇట్రేటర్‌ను అందిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');బేసిక్_స్ట్రింగ్<చార్> ::iteratoriter=strCol.ప్రారంభించండి();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
బేసిక్_స్ట్రింగ్<చార్> ::iteratorనెట్‌వర్క్=strCol.చొప్పించు(iter, 'd');
ఖరీదు<< *నెట్‌వర్క్<< ' n';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్:
'D'
నేను నిన్ను ప్రేమించాను
ఇటరేటర్ ఇన్సర్ట్ (const_iterator p, size_type n, charT c)
వాదన యొక్క అదే పాత్ర n ని ఇన్‌సర్ట్‌లు, ఇట్రేటర్ ద్వారా సూచించబడిన స్థానంలోకి. కొత్తగా చేర్చబడిన అదే అక్షరాల ప్రారంభ స్థానం కోసం ఇటరేటర్‌ను అందిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('భూమిలో ట్యాబ్.');బేసిక్_స్ట్రింగ్<చార్> ::iteratoriter=strCol.ప్రారంభించండి();
++iter; ++iter; ++iter;
బేసిక్_స్ట్రింగ్<చార్> ::iteratorనెట్‌వర్క్=strCol.చొప్పించు(iter, 2, 'లేదా');
ఖరీదు<< *నెట్‌వర్క్<< ' n';
ఖరీదు<<strCol<< ' n';
అవుట్పుట్:
'లేదా'
భూమిలో నిషిద్ధం.
బేసిక్_స్ట్రింగ్&చొప్పించు(size_type pos, కానిస్టేట్charT*లు)ఇండెక్స్ వద్ద ఆర్గ్యుమెంట్ స్ట్రింగ్ అక్షరాలా, ప్రధాన స్ట్రింగ్‌లో pos చేర్చబడుతుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('భూమిలో ట్యాబ్.');strCol=strCol.చొప్పించు(3, 'ఊ');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: భూమిలో నిషిద్ధం.
బేసిక్_స్ట్రింగ్&చొప్పించు(size_type pos, కానిస్టేట్charT*లు,size_type n)ఆర్గ్యుమెంట్ స్ట్రింగ్ యొక్క మొదటి n అక్షరాలను, ఇండెక్స్ వద్ద, ప్రధాన స్ట్రింగ్‌లో pos చేర్చండి.
స్ట్రింగ్ strCol=స్ట్రింగ్('భూమిలో ట్యాబ్.');strCol=strCol.చొప్పించు(3, 'oooo', 2);
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: భూమిలో నిషిద్ధం.
భర్తీ చేస్తోంది
బేసిక్_స్ట్రింగ్&భర్తీ(size_type pos1,పరిమాణం_ రకం n1, కానిస్టేట్బేసిక్_స్ట్రింగ్&p))ఇండెక్స్, pos1 నుండి ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌లోని n1 అక్షరాలను ఆర్గ్యుమెంట్ స్ట్రింగ్ ఆబ్జెక్ట్‌తో భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('నిన్ను ద్వేషిస్తున్నాను');
strCol1=strCol1.భర్తీ(2, 4,strCol2);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను నిన్ను మరియు నిన్ను ద్వేషిస్తున్నాను. మినహాయింపును విసురుతాను - తర్వాత చూడండి.
బేసిక్_స్ట్రింగ్&భర్తీ(size_type pos1,పరిమాణం_ రకం n1, కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos2,పరిమాణం_ రకం n2=npos)
ఇండెక్స్, pos1 నుండి ఆర్గ్యుమెంట్ స్ట్రింగ్ ఆబ్జెక్ట్ యొక్క n2 అక్షరాలతో ఇండెక్స్, pos1 నుండి ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌లోని n1 అక్షరాలను భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');స్ట్రింగ్ strCol2=స్ట్రింగ్('మేము అతనిని మరియు ఆమెను ద్వేషిస్తాము');
strCol1=strCol1.భర్తీ(2, 4,strCol2, 3, 12);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను అతనిని మరియు మిమ్మల్ని ద్వేషిస్తున్నాను.
బేసిక్_స్ట్రింగ్&భర్తీ(size_type pos1,పరిమాణం_ రకం n1, కానిస్టేట్charT*లు,పరిమాణం_ రకం n2)
ఇండెక్స్, pos1 నుండి ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌లోని n1 అక్షరాలను అక్షర స్ట్రింగ్ ఆర్గ్యుమెంట్ యొక్క మొదటి n2 అక్షరాలతో భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol1=strCol1.భర్తీ(2, 4, 'అతడిని మరియు ఆమెను ద్వేషించండి', 12);
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను అతనిని మరియు మిమ్మల్ని ద్వేషిస్తున్నాను.
బేసిక్_స్ట్రింగ్ & రీప్లేస్ (size_type pos, size_type n, const charT* s)
ఇండెక్స్, పోస్ నుండి ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌లోని ఎన్ అక్షరాలను అక్షర స్ట్రింగ్ ఆర్గ్యుమెంట్‌తో భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నేను నిన్ను ప్రేమిస్తున్నాను');strCol1=strCol1.భర్తీ(2, 4, 'అతన్ని ద్వేషించండి మరియు');
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: నేను అతనిని మరియు మిమ్మల్ని ద్వేషిస్తున్నాను.
బేసిక్_స్ట్రింగ్&భర్తీ(size_type pos1,పరిమాణం_ రకం n1,పరిమాణం_ రకం n2,చార్ట్ సి)ఇండెక్స్, pos1 నుండి ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌లోని n1 అక్షరాలను వాదన యొక్క అదే అక్షరంలోని n2 తో భర్తీ చేస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('అక్కడ ఒక చెడ్డ టాబ్లెట్.');strCol1=strCol1.భర్తీ(9, 3, 2, 'లేదా');
ఖరీదు<<strCol1<< ' n';
అవుట్పుట్: అక్కడ చెడ్డ నిషేధం ..
iterator erase (const_iterator p)
ఇటరేటర్ ద్వారా సూచించబడిన స్థానంలో ఒక అక్షరాన్ని తొలగిస్తుంది; అప్పుడు ఇట్రేటర్ పొజిషన్‌ను తిరిగి ఇస్తుంది, ఇప్పుడు ఈ క్యారెక్టర్ (లేదా ఎండ్ ()) పక్కన ఉన్న క్యారెక్టర్ ద్వారా ఆక్రమించబడింది. కింది కోడ్ దీనిని వివరిస్తుంది:
స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి');బేసిక్_స్ట్రింగ్<చార్> ::iteratoriter=strCol.ప్రారంభించండి();
++iter; ++iter;
strCol.చెరిపివేయి(iter);
ఖరీదు<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
అవుట్పుట్: a b d
బేసిక్_స్ట్రింగ్&చెరిపివేయి(size_type pos= 0,size_type n=npos)ఇండెక్స్, pos నుండి n అక్షరాలను తొలగిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి');strCol.చెరిపివేయి(1, 2);
ఖరీదు<<strCol[0] << '' <<strCol[1] << ' n';
అవుట్పుట్: డి
శూన్యమైన పుష్_బ్యాక్ (చార్ట్ సి)
స్ట్రింగ్ చివరిలో ఒకే అక్షరాన్ని జోడించడానికి:
స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి');strCol.వెనుకకు నెట్టడం('5');
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: abcd5
శూన్యమైన పాప్_బ్యాక్ ()
చివరి అక్షరాన్ని తిరిగి ఇవ్వకుండా తీసివేస్తుంది. స్ట్రింగ్ పరిమాణం 1 ద్వారా తగ్గించబడుతుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి ఇ');strCol.పాప్_బ్యాక్();
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: abcd
శూన్య మార్పిడి (బేసిక్_స్ట్రింగ్ & లు)
రెండు స్ట్రింగ్ వస్తువుల అక్షరాలను మార్చుకోవచ్చు.
స్ట్రింగ్ strCol1=స్ట్రింగ్(<ఒక ఐడి='పోస్ట్ -69618 -__ DdeLink__781_3724385525'>కు>'ఎ బి సి డి ఇ');స్ట్రింగ్ strCol2=స్ట్రింగ్('1234567');
strCol1.మార్పిడి(strCol2);
ఖరీదు<<strCol1<< ' n';
ఖరీదు<<strCol2<< ' n';
అవుట్పుట్:
'1234567''ఎ బి సి డి ఇ'
స్ట్రింగ్ ఆపరేషన్స్
const charT* c_str () const noexcept
స్ట్రింగ్ యొక్క మొదటి మూలకానికి పాయింటర్‌ను అందిస్తుంది. పాయింటర్ పెంచవచ్చు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి ఇ');కానిస్టేట్ చార్*p=strCol.c_str();
ఖరీదు<< *p<< ' n';
++p;
ఖరీదు<< *p<< ' n';
అవుట్పుట్:
కుబి
శీర్షికలోని రెండవ కాన్స్టాట్ కారణంగా, ప్రోగ్రామ్ స్ట్రింగ్‌లోని ఏ అక్షరాన్ని మార్చదు. నిర్మాణానికి ముందు కాన్స్టార్.
const charT* డేటా () const noexcept
స్ట్రింగ్ యొక్క మొదటి మూలకానికి పాయింటర్‌ను అందిస్తుంది. పాయింటర్ పెంచవచ్చు.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('ఎ బి సి డి ఇ');కానిస్టేట్ చార్*p=strCol.సమాచారం();
ఖరీదు<< *p<< ' n';
++p;
ఖరీదు<< *p<< ' n';
అవుట్పుట్:
కుబి
శీర్షికలోని రెండవ కాన్స్టాట్ కారణంగా, ప్రోగ్రామ్ స్ట్రింగ్‌లోని ఏ అక్షరాన్ని మార్చదు. నిర్మాణానికి ముందు కాన్స్టార్.
బేసిక్_స్ట్రింగ్ సబ్‌స్ట్రర్ (సైజు_టైప్ పోస్ = 0, సైజ్_టైప్ ఎన్ = ఎన్‌పోస్) కాన్స్టాట్
ఇండెక్స్, pos నుండి ప్రారంభమయ్యే ఉప-స్ట్రింగ్ కోసం n అక్షరాల స్ట్రింగ్ వస్తువును అందిస్తుంది.
కానిస్టేట్స్ట్రింగ్ strCol=స్ట్రింగ్('abcdefghij');కానిస్టేట్స్ట్రింగ్ retStr=strCol.సబ్‌స్ట్రార్(2, 4);
ఖరీదు<<retStr<< ' n';
అవుట్పుట్: cdef
కనుగొను () సభ్యుల విధులు
size_type కనుగొను (const basic_string & str, size_type pos = 0) const noexcept
ఇండెక్స్, pos నుండి ప్రారంభమయ్యే ఉప-స్ట్రింగ్ వస్తువు కోసం చూస్తుంది. కనుగొనబడితే, ప్రధాన స్ట్రింగ్‌లోని ఉప-స్ట్రింగ్ ప్రారంభాన్ని అందిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('మనం ప్రపంచం!');స్ట్రింగ్ strCol1=స్ట్రింగ్('ది');
intఒకదానిపై=strCol.కనుగొనండి(strCol1, 2);
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్:
సూచిక: 7రిటర్న్స్ -1, దొరకనప్పుడు.
size_type కనుగొను (const charT* s, size_type pos = 0) const
ఇండెక్స్, పోస్ నుండి ఉప-స్ట్రింగ్ సాహిత్య ప్రారంభంలో కనిపిస్తోంది. కనుగొనబడితే, ప్రధాన స్ట్రింగ్‌లోని ఉప-స్ట్రింగ్ ప్రారంభాన్ని అందిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('మనం ప్రపంచం!');intఒకదానిపై=strCol.కనుగొనండి('ఉన్నారు', 0);
ఖరీదు<<ఒకదానిపై<< ' n';
Pos = 0 డిఫాల్ట్ కాబట్టి, ఆర్గ్యుమెంట్‌లోని 0 విస్మరించబడి ఉండవచ్చు.
అవుట్పుట్: 3
రిటర్న్స్ -1, దొరకనప్పుడు.
size_type find (const charT* s, size_type pos, size_type n) const
ఇండెక్స్, pos నుండి ప్రారంభమయ్యే ఉప-స్ట్రింగ్ సాహిత్యంలోని మొదటి n అక్షరాల కోసం చూస్తుంది. కనుగొనబడితే, ప్రధాన స్ట్రింగ్‌లోని ఉప-స్ట్రింగ్ ప్రారంభాన్ని అందిస్తుంది.
స్ట్రింగ్ strCol=స్ట్రింగ్('అతిపెద్ద అబ్బాయి');intఒకదానిపై=strCol.కనుగొనండి('పెద్దది', 1, 3);
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్: 4
రిటర్న్స్ -1, దొరకనప్పుడు.
size_type కనుగొను (charT c, size_type pos = 0) const
సూచిక, పోస్ నుండి ప్రారంభమయ్యే పాత్ర కోసం చూస్తుంది. కనుగొనబడితే, ప్రధాన స్ట్రింగ్‌లోని ఉప-స్ట్రింగ్ ప్రారంభాన్ని అందిస్తుంది. కనుగొనబడకపోతే, రిటర్న్స్ -1.
స్ట్రింగ్ strCol=స్ట్రింగ్('మనం ప్రపంచం!');intఒకదానిపై=strCol.కనుగొనండి('తో');
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్: -1
కింది రివర్స్ ఫైండ్ () సభ్యుల విధులు ఉన్నాయి:
size_type rfind(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos=npos) కానిస్టేట్తప్ప;size_type rfind(కానిస్టేట్charT*లు,size_type pos=npos) కానిస్టేట్;
size_type rfind(కానిస్టేట్charT*లు,size_type pos,size_type n) కానిస్టేట్;
size_type rfind(చార్ట్ సి,size_type pos=npos) కానిస్టేట్;
పోలిక సభ్యుల విధులు
int compare (const basic_string & str) const noexcept
ఆర్గ్యుమెంట్ స్ట్రింగ్ ఆబ్జెక్ట్‌ను ప్రధాన స్ట్రింగ్ ఆబ్జెక్ట్‌తో పోలుస్తుంది. ప్రధాన స్ట్రింగ్ వాదనకు ముందు సంభవించినట్లయితే (డిక్షనరీలో) అది పాజిటివ్ సంఖ్యను అందిస్తుంది. ప్రధాన స్ట్రింగ్ తర్వాత అది సంభవించినట్లయితే, అది ప్రతికూల సంఖ్యను అందిస్తుంది. రెండు తీగలు ఒకేలా ఉంటే, అది సున్నాను అందిస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('గుంపు');స్ట్రింగ్ strCol2=స్ట్రింగ్('ప్రజలు');
intఒకదానిపై=strCol1.సరిపోల్చండి(strCol2);
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్: -13
int సరిపోల్చండి (const charT* s) const
పైన చెప్పినట్లుగానే ఉంటుంది, కానీ వాదన ఒక స్ట్రింగ్ అక్షరసత్యం.
స్ట్రింగ్ strCol1=స్ట్రింగ్('ప్రజలు');intఒకదానిపై=strCol1.సరిపోల్చండి('ప్రజలు');
ఖరీదు<<ఒకదానిపై<< ' n';
అవుట్పుట్: 0
స్ట్రింగ్ ఆపరేటర్లు
ఈ ఆపరేటర్లు స్ట్రింగ్ వస్తువులకు వర్తిస్తాయి మరియు అక్షరాలను స్ట్రింగ్ చేయాల్సిన అవసరం లేదు.
+
రెండు స్ట్రింగ్ ఆబ్జెక్ట్‌లను కలుపుతుంది, మరియు సంశ్లేషణను అందిస్తుంది.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నృత్యం');స్ట్రింగ్ strCol2=స్ట్రింగ్(' చంద్రుడు');
స్ట్రింగ్ strCol=strCol1+strCol2;
ఖరీదు<<strCol<< ' n';
అవుట్పుట్: చంద్రునిపై నృత్యం.
==
స్ట్రింగ్ ఆబ్జెక్ట్‌లు ఒకేలా ఉంటే, ట్రూ కోసం 1 ని అందిస్తుంది; మరియు తప్పుడు కోసం సున్నా, అవి కాకపోతే.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నృత్యం');స్ట్రింగ్ strCol2=స్ట్రింగ్('చంద్రునిపై');
బూల్ bl=strCol1==strCol2;
ఖరీదు<<bl<< ' n';
అవుట్పుట్: 0
! =
స్ట్రింగ్ ఆబ్జెక్ట్‌లు ఒకేలా లేకపోతే 1, మరియు అవి ఉంటే సున్నా.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నృత్యం');స్ట్రింగ్ strCol2=స్ట్రింగ్('చంద్రునిపై');
బూల్ bl=strCol1! =strCol2;
ఖరీదు<<bl<< ' n';
అవుట్పుట్: 1
<
1 ప్రకారం, ఎడమ ఒపెరాండ్ కుడి ఒపెరాండ్ కంటే డిక్షనరీ ప్రకారం తక్కువగా ఉంటే లేదా అది కాకపోతే సున్నా.
స్ట్రింగ్ strCol1=స్ట్రింగ్('నృత్యం');స్ట్రింగ్ strCol2=స్ట్రింగ్('చంద్రునిపై');
బూల్ bl=strCol1<strCol2;
ఖరీదు<<bl<< ' n';
అవుట్పుట్: 0
C ++ లో సాధారణ అక్షరాల కోసం, ఆరోహణ క్రమంలో, చిన్న అక్షరాలకు ముందు వచ్చే పెద్ద అక్షరాలకు ముందు సంఖ్యలు వస్తాయి. స్పేస్ క్యారెక్టర్ సున్నాకి ముందు వస్తుంది మరియు అవన్నీ.
C ++ ప్రధాన స్ట్రింగ్ అక్షర రకాలు
చార్
చార్ రకం అసలు సి ++ రకం మరియు సాధారణంగా 8 బిట్స్‌లో ఒక అక్షరాన్ని నిల్వ చేస్తుంది.
char16_t
ఇది 16 బిట్స్‌లో ఒక అక్షరాన్ని నిల్వ చేస్తుంది.
char32_t
ఇది 32 బిట్స్‌లో అక్షరాన్ని నిల్వ చేస్తుంది.
wchar_t
char16_t మరియు char32_t విస్తృత అక్షరాలు. wchar_t అనేది యాజమాన్య మరియు అమలు-నిర్వచించిన విస్తృత అక్షరం.
ఈ రకాలను లక్షణాలు అంటారు. అయితే, C ++ వాటిని సాంకేతికంగా, లక్షణాల ప్రత్యేకతలుగా సూచిస్తుంది. ఈ వ్యాసం చార్ రకంపై దృష్టి పెట్టింది. ఇతర రకాలకు సంబంధించిన విధానం కొద్దిగా భిన్నంగా ఉంటుంది - తర్వాత చూడండి.
ఇతర స్ట్రింగ్ ఆపరేషన్ సభ్యుల విధులు
ఇతర స్ట్రింగ్ ఆపరేషన్ ఫంక్షన్ల సంతకాలు:
సైజ్_టైప్ ఫస్ట్_ఫోర్డ్(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos= 0) కానిస్టేట్తప్ప;సైజ్_టైప్ ఫస్ట్_ఫోర్డ్(కానిస్టేట్charT*లు,size_type pos,size_type n) కానిస్టేట్;
సైజ్_టైప్ ఫస్ట్_ఫోర్డ్(కానిస్టేట్charT*లు,size_type pos= 0) కానిస్టేట్;
సైజ్_టైప్ ఫస్ట్_ఫోర్డ్(చార్ట్ సి,size_type pos= 0) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడానికి_చివరిది(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos=npos) కానిస్టేట్తప్ప;
పరిమాణం_ రకం కనుగొనడానికి_చివరిది(కానిస్టేట్charT*లు,size_type pos,size_type n) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడానికి_చివరిది(కానిస్టేట్charT*లు,size_type pos=npos) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడానికి_చివరిది(చార్ట్ సి,size_type pos=npos) కానిస్టేట్;
పరిమాణం_రూపం_మొదటిది_కాదు(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos= 0) కానిస్టేట్తప్ప;
పరిమాణం_రూపం_మొదటిది_కాదు(కానిస్టేట్charT*లు,size_type pos,size_type n) కానిస్టేట్;
పరిమాణం_రూపం_మొదటిది_కాదు(కానిస్టేట్charT*లు,size_type pos= 0) కానిస్టేట్;
పరిమాణం_రూపం_మొదటిది_కాదు(చార్ట్ సి,size_type pos= 0) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడంలో_చివరిది కాదు(కానిస్టేట్బేసిక్_స్ట్రింగ్&p,size_type pos=npos) కానిస్టేట్తప్ప;
పరిమాణం_ రకం కనుగొనడంలో_చివరిది కాదు(కానిస్టేట్charT*లు,size_type pos,size_type n) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడంలో_చివరిది కాదు(కానిస్టేట్charT*లు,size_type pos=npos) కానిస్టేట్;
పరిమాణం_ రకం కనుగొనడంలో_చివరిది కాదు(చార్ట్ సి,size_type pos=npos) కానిస్టేట్;
ముగింపు
C ++ లో స్ట్రింగ్ లిటరల్స్ మరియు స్ట్రింగ్ ఆబ్జెక్ట్‌లు ఉన్నాయి. స్ట్రింగ్ ఆబ్జెక్ట్ సీక్వెన్స్‌లో అక్షరాల సముదాయాన్ని కలిగి ఉంటుంది. స్ట్రింగ్ సేకరణ మరియు శ్రేణి మధ్య వ్యత్యాసం ఏమిటంటే, స్ట్రింగ్ సేకరణ పొడవుగా పెరుగుతుంది లేదా పొడవు తగ్గిపోతుంది. స్ట్రింగ్ ఆబ్జెక్ట్ స్ట్రింగ్ క్లాస్ నుండి తక్షణం (నిర్మించబడింది). స్ట్రింగ్ ఆబ్జెక్ట్ అనేది సభ్యుల ఫంక్షన్లతో కూడిన డేటా స్ట్రక్చర్. ఆబ్జెక్ట్ నిర్మాణం, ఎలిమెంట్ యాక్సెస్, స్ట్రింగ్ కెపాసిటీ, స్ట్రింగ్ మెంబర్ ఫంక్షన్‌లు ఇట్రేటర్ ఆర్గ్యుమెంట్‌లు మరియు రిటర్న్ రకాలు మరియు స్ట్రింగ్ మోడిఫైయర్‌లు అనే శీర్షికల కింద సభ్యుల విధులను వర్గీకరించవచ్చు. స్ట్రింగ్ సమానత్వం మరియు సంబంధిత ఆపరేటర్లు కూడా ఉన్నాయి.