Klass ja objektid
Klass on muutujate ja funktsioonide kogum, mis töötavad koos; kus muutujatele pole määratud väärtusi. Kui muutujatele määratakse väärtused, muutub klass objektiks. Samale klassile antud erinevad väärtused annavad erinevaid objekte; see tähendab, et erinevad objektid on sama klass erinevate väärtustega. Klassist objekti loomine on objekti initsieerimine.
Nimi, string, on klass. Stringiklassist loodud objektil on programmeerija valitud nimi.
Funktsioon, mis kuulub klassi, on vajalik objekti klassist eraldamiseks. C ++ puhul on sellel funktsioonil sama nimi kui klassi nimel. Klassist loodud (näidatud) objektidel on programmeerija poolt antud erinevad nimed.
Klassist objekti loomine tähendab objekti konstrueerimist; see tähendab ka kohesust.
Stringiklassi kasutav C ++ programm algab faili ülaosas järgmiste ridadega:
#kaasake#kaasake
kasutades nimeruumi std;
Esimene rida on sisend/väljund. Teine rida on lubada programmil kasutada kõiki stringiklassi funktsioone. Kolmas rida võimaldab programmil kasutada standardse nimeruumi nimesid.
Funktsiooni ülekoormamine
Kui kahel või enamal erineval funktsiooniallkirjal on sama nimi, öeldakse, et see nimi on ülekoormatud. Kui kutsutakse üks funktsioon, määrake argumentide arv ja tüüp, milline funktsioon täidetakse.
Ehitus
string ()
Järgmine lause konstrueerib nullpikkuse stringi, millel puudub märk.
See algab klassi nimega (objekti tüüp), string. Sellele järgneb programmeerija antud objektistringi nimi. Järgneb ülesandeoperaator; siis tühjade sulgudega konstruktori nimi. Siin on strCol aktiveeritud objekt kõigi andmete liikmete (atribuutide) ja liikmefunktsioonidega (meetoditega).
string (str)
See sarnaneb ülaltooduga, kuid võtab konstruktoris argumendiks kas stringi literaali või identifikaatori. Seda illustreerib järgmine avaldus:
Ehitus initsialisaatorite loendiga
Seda illustreerib järgmine kood:
string strCol=string({'Mina','','','või','v','Ja','','ja','või','s',' 0'});String literal on ma armastan sind. Pange tähele nullmärki initsialiseerijate loendi lõpus.
string (str, n)
See moodustab stringide kogu, mis koosneb teise stringi esimesest n tähemärgist. Seda illustreerib järgmine kood:
süsilk[] = 'Ma armastan sind';string strCol=string(lk, 6);
maksma<<strCol<< ' n';
Väljund on 'Ma armastan' koos esimese kuue tegelasega 'Ma armastan sind'. Pidage meeles: ühtne ruum on märk.
string (str, pos, n)
See moodustab n-tähemärgist koosneva stringikogu, mis algab teise stringi nullpõhisest indekseeritud positsioonist pos. Seda illustreerib järgmine kood:
süsilk[] = 'Ma armastan sind';string strCol=string(lk, 2, 4);
maksma<<strCol<< ' n';
Väljund on, armastus.
Kui ülaltoodud kahel juhul on n nööri suurusest suurem, visatakse erand vahemiku_väljast - vt hiljem.
string (n, 'c')
Moodustab n tähemärgi kogumi, kus kõik märgid on samad. Mõelge,
string strCol=string(5,'Ja');maksma<<strCol<< ' n';
Väljund on, eeeee, 5 e.
Stringi määramine
Pärast mõlema stringi deklareerimist saab stringi määrata järgmiselt.
string strCol1=string('Ma armastan sind');string strCol2;
strCol2=strCol1;
maksma<<strCol2<< ' n';
Väljund on, ma armastan sind.
Ehitamine Iteraatoriga
Iteraator pakub skaneerimise üldist kujutist kogu väärtuste kaudu. Iteraatoriga stringi loomise süntaks on järgmine:
malli<klassi InputIterator>põhiline_string(InputIterator käivitub,InputIterator lõpp, constAllokaator&
et=Allokaator());
See loob vahemikule [algus, lõpp] stringi - vaadake üksikasju hiljem.
Stringi hävitamine
Stringi hävitamiseks laske sellel lihtsalt ulatusest välja minna.
Juurdepääs stringiklassi elementidele
Väljendatud stringiobjekti saab alamskripteerida (indekseerida) nagu massiivi. Indeksite lugemine algab nullist.
stringinimi [i]
Operatsioon stringName [i] tagastab viite märgile (elemendile) i -sthtähemärkide kogu indeks. Järgmised koodiväljundid v:
string strCol=string('Ma armastan sind');süsich=strCol[4];
maksma<<ch<< ' n';
stringNimi [i] konst
Operatsioon stringName [i] const täidetakse stringName [i] asemel, kui stringi objekt on konstantne objekt. Seda kasutatakse näiteks järgmises koodis:
conststring strCol=string('Ma armastan sind');süsich=strCol[4];
maksma<<ch<< ' n';
Avaldis tagastab pideva viite i -lethstringi objekti element. Ühtegi stringi elementi ei saa muuta.
Märgi määramine allindeksiga
Märgi saab määrata mittekonstantsele stringiobjektile järgmiselt.
string strCol=string('Ma helistan');strCol[2] = 'f';
maksma<<strCol<< ' n';
Väljund on I kukkumine. 'C' asendati tähega 'f'.
stringName.at (i)
stringName.at (i) on sarnane stringName [i], kuid stringName.at (i) on usaldusväärsem. Järgmine kood näitab, kuidas seda kasutada:
string strCol=string('Ma armastan sind');süsich=strCol.kl(4);
maksma<<ch<< ' n';
at () on tegelikult stringiklassi liigefunktsioon.
stringName.at (i) const
stringName.at (i) const on sarnane stringName [i] const, kuid stringName.at (i) const on usaldusväärsem. stringName.at (i) const täidetakse stringName.at (i) asemel, kui stringiobjekt on konstantne stringiobjekt. Seda kasutatakse näiteks järgmises koodis:
conststring strCol=string('Ma armastan sind');süsich=strCol.kl(4);
maksma<<ch<< ' n';
at () const on tegelikult stringiklassi liigefunktsioon.
Väärtuse määramine funktsiooniga at ()
Väärtuse saab määrata mittekonstantsele stringiobjektile funktsiooniga at () järgmiselt.
string strCol=string('Ma helistan');strCol.kl(2) = 'f';
maksma<<strCol<< ' n';
Väljund on I kukkumine.
Probleem alamskriptimisega
Alamskriptimise (indekseerimise) probleem on see, et kui indeks on vahemikust väljas, võidakse saada vale tulemus või ilmneda tõrge käitamise ajal.
ees ()
See tagastab viite stringiobjekti esimesele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 'I'.
string strCol=string('Ma armastan sind');süsich=strCol.ees();
maksma<<ch<< ' n';
Märki ei eemaldata stringiobjektist.
ees () const
Kui stringiobjekti konstrueerimisele eelneb const, käivitatakse front () asemel avaldis front () const. Seda kasutatakse näiteks järgmises koodis.
conststring strCol=string('Ma armastan sind');süsich=strCol.ees();
maksma<<ch<< ' n';
Pidev viide tagastatakse. Elementi stringiobjektilt ei eemaldata. Pideva stringi objekti jaoks ei saa ühtegi märki muuta.
tagasi()
See tagastab viite stringiobjekti viimasele elemendile ilma elementi eemaldamata. Järgmise koodi väljund on 'u'.
string strCol=string('Ma armastan sind');süsich=strCol.tagasi();
maksma<<ch<< ' n';
tagasi () konst
Kui stringiobjekti konstrueerimisele eelneb konst, käivitatakse tagasiside () asemel avaldis back () const. Seda kasutatakse näiteks järgmises koodis.
conststring strCol=string('Ma armastan sind');süsich=strCol.tagasi();
maksma<<ch<< ' n';
Pidev viide tagastatakse. Elementi stringiobjektilt ei eemaldata.
Stringi maht
size_type capacity () const noexcept
See võimsusliikme funktsioon tagastab tähemärkide koguarvu, mida string mahutab ilma ümberjaotamist nõudmata. Koodisegment selleks on:
string strCol=string();intühe peale=strCol.võimsus();
maksma<<ühe peale<< ' n';
Minu arvuti väljund on 15.
reserv (n)
Tasuta poes pole mäluruumi alati saadaval. Lisaruumi saab ette broneerida. Mõelge järgmisele koodilõigule:
string strCol=string('armastus');strCol.reservi(6);
maksma<<strCol.võimsus() << ' n';
Minu arvuti väljund on 15.
size () const noexcept
See tagastab stringi märkide arvu. Järgmine kood illustreerib:
string strCol=string('Ma armastan sind');intühe peale=strCol.suurus();
maksma<<ühe peale<< ' n';
Väljund on 10, mis ei sisalda nulli, 0 märki.
length () const noexcept
-sama suurusega().Märge:suurus() <=võimsus().
shrink_to_fit ()
Võib ümberpaigutamise tõttu vähendada võimsust () suuruseks (); see ei ole kohustuslik. Seda näitab järgmine kood:
string strCol=string('Ma armastan sind');strCol.reservi(12);
strCol.kokkutõmbumisvastane();
ints=strCol.suurus();
maksma<<s<< ' n';
Väljund on 10, mitte 12 või 16. Funktsioon tagastab tühja.
suuruse muutmine (sz), suuruse muutmine (sz, ’c’)
See muudab stringi suurust. Kui uus suurus on väiksem kui vana, kustutatakse lõpupoole jäävad elemendid. Kui uus suurus on pikem, lisatakse lõppu mõni vaikimärk. Konkreetse märgi lisamiseks kasutage resize () funktsiooni koos kahe argumendiga. Järgmine koodisegment illustreerib kahe funktsiooni kasutamist:
string strCol=string('Ma armastan sind');strCol.suurust muuta(6);
maksma<< 'StrColi uus suurus:' <<strCol.suurus() << ' n';
string strCol1=string('Ma armastan', 'Ja');
strCol1.suurust muuta(12);
maksma<< 'StrCol1 uus suurus:' <<strCol1.suurus() << ' n';
Väljund on:
StrCol uus suurus: 6StrCol1 uus suurus: 12
Funktsioon tagastab tühja.
selge () noexcept
Eemaldab stringist kõik elemendid, nagu illustreerib järgmine koodisegment:
string strCol=string('Ma armastan sind');strCol.selge();
maksma<<strCol.suurus() << ' n';
Väljund on 0. Funktsioon tagastab tühja.
tühi () const noexcept
See tagastab väärtuse 1 korral tõese, kui stringiobjektis pole märki, või väärtuse 0 puhul, kui stringiobjekt pole tühi. Seda illustreerib järgmine kood:
string strCol1=string('Ma armastan sind');maksma<<strCol1.tühi() << ' n';
string strCol2=string();
maksma<<strCol2.tühi() << ' n';
Väljund on:
01
Iteraatorite ja stringiklassi tagasitulek
Iteraator on nagu osuti, kuid sellel on rohkem funktsioone kui osuti.
algus () noexcept
Tagastab iteraatori, mis osutab stringiobjekti esimesele märgile (elemendile), nagu järgmises koodisegmendis:
string strCol=string('Ma armastan sind');põhiline_string<süsi> ::iteraatoriter=strCol.alustada();
maksma<< *iter<< ' n';
Väljund on 'mina'. Pange tähele, kuidas iteraatori saanud deklaratsioon on deklareeritud. Iteraatorile on tagasiväljendis tühistatud viide, et saada väärtus samamoodi nagu kursori tühistamine.
begin () const noexcept;
Tagastab iteraatori, mis osutab stringiobjektide kogu esimesele elemendile. Kui objekti konstrueerimisele eelneb konst, käivitatakse avaldise algus () const asemel algus (). Selle tingimuse korral ei saa objekti vastavat elementi muuta. Seda kasutatakse näiteks järgmises koodis.
conststring strCol=string('Ma armastan sind');põhiline_string<süsi> ::const_iteratoriter=strCol.alustada();
maksma<< *iter<< ' n';
Väljund on 'mina'. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud mitte ainult iteraatorit, vaid const_iteratorit.
end () noexcept
Tagastab iteraatori, mis osutab stringiobjekti viimasest elemendist kohe kaugemale. Mõelge järgmisele koodilõigule:
string strCol=string('Ma armastan sind');põhiline_string<süsi> ::iteraatoriter=strCol.lõpp();
maksma<< *iter<< ' n';
Väljund on null, mis pole midagi, kuna peale viimase elemendi pole ühtegi konkreetset elementi.
end () const noexcept
Tagastab iteraatori, mis osutab stringiobjekti viimasest elemendist kohe kaugemale. Kui stringiobjekti konstrueerimisele eelneb const, käivitatakse end () asemel avaldis end () const. Mõelge järgmisele koodilõigule:
conststring strCol=string('Ma armastan sind');põhiline_string<süsi> ::const_iteratoriter=strCol.lõpp();
maksma<< *iter<< ' n';
Väljund on null. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud mitte ainult iteraatorit, vaid const_iteratorit.
Vastupidine kordamine
Võimalik on iteraator, mis kordub tegelikust lõpust vahetult enne esimest elementi:
rbegin () noexcept
Tagastab iteraatori, mis osutab stringi aktiveeritud objekti viimasele elemendile, nagu järgmises koodisegmendis:
string strCol=string('Ma armastan sind');põhiline_string<süsi> ::reverse_iteratoriter=strCol.rbegin();
maksma<< *iter<< ' n';
Väljund on 'u'. Pange tähele, kuidas on deklareeritud vastupidise iteraatori deklaratsioon. Iteraatorile on tagasiväljendis tühistatud viide, et saada väärtus samamoodi nagu kursori tühistamine.
rbegin () const noexcept;
Tagastab iteraatori, mis osutab stringiobjekti viimasele elemendile. Kui objekti ehitamisele eelneb const, täidetakse rbegin () asemel avaldis rbegin () const. Selle tingimuse korral ei saa objekti vastavat elementi muuta. Seda funktsiooni kasutatakse näiteks järgmises koodis.
conststring strCol=string('Ma armastan sind');põhiline_string<süsi> ::const_reverse_iteratoriter=strCol.rbegin();
maksma<< *iter<< ' n';
Väljund on 'u'. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud lihtsalt tagasipööratud_iteraatori asemel konstant_reverse_iteraatorit.
render () noexcept
Tagastab iteraatori, mis osutab vahetult stringi objekti esimese elemendi ette. Mõelge järgmisele koodilõigule:
string strCol=string('Ma armastan sind');põhiline_string<süsi> ::reverse_iteratoriter=strCol.teeb();
maksma<< *iter<< ' n';
Väljund on null, mis pole midagi, kuna vahetult enne esimest elementi pole ühtegi konkreetset elementi.
render () const noexcept
Tagastab iteraatori, mis osutab vahetult stringi objekti esimese elemendi ette. Kui objekti ehitamisele eelneb const, täidetakse rend () asemel avaldis rend () const. Mõelge järgmisele koodilõigule:
conststring strCol=string('Ma armastan sind');põhiline_string<süsi> ::const_reverse_iteratoriter=strCol.teeb();
maksma<< *iter<< ' n';
Väljund on null. Pange tähele, et tagastatud iteraatori vastuvõtmiseks on seekord kasutatud lihtsalt tagasipööratud_iteraatori asemel konstant_reverse_iteraatorit.
Stringide muutjad
Stringiobjekti modifitseeriv modifikaator võib samuti iteraatori võtta või tagastada.
Lisamine
põhiline_string&operaator+ =(constpõhiline_string&lk)Lisab parema stringi objekti vasakule stringi objektile. Näide:
string strCol1=string('Ma armastan');string strCol2=string('sina');
strCol1+ =strCol2;
maksma<<strCol1<< ' n';
Väljund on Ma armastan sind. Ärge unustage, et strCol1 += strCol2 on sama mis strCol1 = strCol1 +strCol2.
basic_string & operator+= (const charT* s)
Lisab stringi objektide kogumile stringi literaali. Näide:
string strCol=string('Ma armastan');strCol+ = 'sina';
maksma<<strCol<< ' n';
Väljund: Ma armastan sind.
põhiline_string & operaator+= (charT c)
Lisab objekti stringile ühe märgi. Näide:
string strCol=string('Ma armastan sind');strCol+ = 's';
maksma<<strCol<< ' n';
Väljund: Ma armastan sind.
põhiline string ja operaator+= (initsialiseerimisnimekiri)
Lisab initsialiseerijate loendi. Näide:
string strCol=string('Ma armastan');strCol+ = {'','ja','või','s',' 0'};
maksma<<strCol<< ' n';
Väljund: Ma armastan sind. Alati on hea märkide initsiaatorite loendi lõppu lisada nul, 0.
basic_string & add (const basic_string & str)
Lisab argumendi stringi objekti peamisele stringiobjektile. Näide:
string strCol1=string('Ma armastan');string strCol2=string('sina');
strCol1.lisama(strCol2);
maksma<<strCol1<< ' n';
Väljund: Ma armastan sind.
basic_string & add (const charT* s)
Lisab stringi sõnasõnalise argumendi põhistringile. Näide
string strCol=string('Ma armastan');strCol=strCol.lisama('sina');
maksma<<strCol<< ' n';
Väljund: Ma armastan sind.
põhiline string ja lisamine (initsialiseerimisnimekiri)
Lisab initsialiseerijate loendi, mis on argument, põhistringile. Näide:
string strCol=string('Ma armastan');strCol=strCol.lisama({'','ja','või','s',' 0'});
maksma<<strCol<< ' n';
Väljund: Ma armastan sind. Initsialiseerimisloendi lõppu on alati hea lisada null, 0 märk.
põhiline_string ja lisamine (suurus_tüüp n, sümbol c)
Lisab n sama märgi. Näide:
string strCol=string('sakk');strCol=strCol.lisama(2, 'või');
maksma<<strCol<< ' n';
Väljund: tabu.
põhiline_string ja lisamine (const charT* s, size_type n)
Lisab stringi literaali esimese n elemendi peamisele stringiobjektile. Näide:
string strCol=string('Ma armastan');strCol=strCol.lisama('sina nii', 4);
maksma<<strCol<< ' n';
Väljund on: Ma armastan sind. Kui n on suurem kui literaali pikkus, visatakse pikkus_vea erand.
põhiline_string & lisamine (konst
Lisab peastringile n märgi, pos. Näide:
string strCol=string('Ma armastan');strCol=strCol.lisama('kas sa oled nii', 2, 4);
maksma<<strCol<< ' n';
Väljund: Ma armastan sind. Siia visataks ka erand, vaata hiljem.
Määramine
põhiline_string&määrama(constpõhiline_string&lk)Määrab argumendistringi objekti põhistringile, asendades seal oleva sisu.
string strCol1=string('Ma armastan sind');string strCol2=string('Ta vajab mind');
strCol1=strCol1.määrama(strCol2);
maksma<<strCol1<< ' n';
Väljund: Ta vajab mind.
põhiline_string&määrama(constcharT*s)Määrab stringile sõnasõnalise argumendi põhistringile, asendades seal oleva sisu.
string strCol=string('Ma armastan sind');strCol=strCol.määrama('Ta vajab mind');
maksma<<strCol<< ' n';
Väljund: Ta vajab mind.
põhiline_string&määrama(Initial_list<charT>)Määrab põhistringile initsialiseerimisloendi argumendi,mis tahes sisu asendamine.
[cc lang='c'pääses='tõsi'laius='780']
string strCol=string('Ma armastan sind');
strCol=strCol.määrama({'S','h','Ja','','n','Ja','Ja','d','s','','mina','Ja',' 0'});
maksma<<strCol<< ' n';
Väljund: Ta vajab mind. Stringide literaali moodustamiseks on hea märkide loendi lõppu alati lisada nul, 0.
põhiline_string&määrama(constcharT*s,suurus_tüüp n)Määrab stringi literaalse argumendi esimese n tähemärgi põhistringile, asendades seal oleva sisu.
string strCol=string('Ma armastan sind');strCol=strCol.määrama('Ta vajab mind', 9);
maksma<<strCol<< ' n';
Väljund: Ta vajab.
põhiline_string&määrama(suurus_tüüp n,sümbol c)Määrab põhistringile samade märkide n argumendi, asendades seal oleva sisu.
string strCol=string('Ma armastan sind');strCol=strCol.määrama(4, 'Ja');
maksma<<strCol<< ' n';
Väljund: eeee
põhiline_string&määrama(constpõhiline_string&lk,suurus_tüüp pos,suurus_tüüp n=npos)
Määrab stringi objekti argumendi n tähemärgi, alustades posist, peamisele stringile, asendades seal oleva sisu.
string strCol=string('Ma armastan sind');strCol=strCol.määrama('Ta vajab mind', 4, 5);
maksma<<strCol<< ' n';
Väljund: vajab. Teeks erandi - vaata hiljem.
Sisestamine
põhiline_string&sisestada(suurus_tüüp pos, constpõhiline_string&lk)Lisab stringi objekti argumendi põhistringile, indeks, pos.
string strCol1=string('Ma armastan sind');string strCol2=string('vihkan ja');
strCol1=strCol1.sisestada(2,strCol2);
maksma<<strCol1<< ' n';
Väljund: Ma vihkan ja armastan sind. Teeks erandi - vaata hiljem.
põhiline_string&sisestada(suurus_tüüp pos1, constpõhiline_string&lk,suurus_tüüp pos2,suurus_tüüp n=npos)
Lisab n -tähemärgi pikkuse stringi objekti argumendi pos2 -st põhistringi, indeksisse, pos1.
string strCol1=string('Ma armastan sind');string strCol2=string('vihkan, tahan ja vajan');
strCol1=strCol1.sisestada(2,strCol2, 6, 9);
maksma<<strCol1<< ' n';
Väljund: Ma tahan ja armastan sind.
iteraatori sisestus (const_iterator p, charT c)
Lisab iteraatori osutatud positsiooni konkreetse märgi, mis on argument. Tagastab äsja sisestatud märgi asukoha iteraatori.
string strCol=string('Ma armastan sind');põhiline_string<süsi> ::iteraatoriter=strCol.alustada();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
põhiline_string<süsi> ::iteraatorvõrku=strCol.sisestada(iter, 'd');
maksma<< *võrku<< ' n';
maksma<<strCol<< ' n';
Väljund on:
'D'
ma armastasin sind
iteraatori sisestus (const_iterator p, size_type n, charT c)
Lisab argumendi sama iseloomu n iteraatori osutatud asendisse. Tagastab äsja lisatud samade märkide alguse positsiooni iteraatori.
string strCol=string('Vahekaart maal.');põhiline_string<süsi> ::iteraatoriter=strCol.alustada();
++iter; ++iter; ++iter;
põhiline_string<süsi> ::iteraatorvõrku=strCol.sisestada(iter, 2, 'või');
maksma<< *võrku<< ' n';
maksma<<strCol<< ' n';
Väljund on:
'või'
Tabu maal.
põhiline_string&sisestada(suurus_tüüp pos, constcharT*s)Lisab argumendi stringi literaali indeksisse, pos põhitringi.
string strCol=string('Vahekaart maal.');strCol=strCol.sisestada(3, 'oo');
maksma<<strCol<< ' n';
Väljund: tabu maal.
põhiline_string&sisestada(suurus_tüüp pos, constcharT*s,suurus_tüüp n)Lisab argumendi stringi literaali esimesed n tähemärki põhitringi indeksi, pos.
string strCol=string('Vahekaart maal.');strCol=strCol.sisestada(3, 'oooo', 2);
maksma<<strCol<< ' n';
Väljund: tabu maal.
Asendamine
põhiline_string&asendada(suurus_tüüp pos1,suurus_tüüp n1, constpõhiline_string&lk))Asendab peamise stringi objekti n1 märki indeksist pos1 argumendistringi objektiga.
string strCol1=string('Ma armastan sind');string strCol2=string('vihkan sind ja');
strCol1=strCol1.asendada(2, 4,strCol2);
maksma<<strCol1<< ' n';
Väljund: Ma vihkan sind ja sind. Teeks erandi - vaata hiljem.
põhiline_string&asendada(suurus_tüüp pos1,suurus_tüüp n1, constpõhiline_string&lk,suurus_tüüp pos2,suurus_tüüp n2=npos)
Asendab indeksi peamise stringiobjekti n1 tähemärki indeksist pos1 ja argumendi stringi objekti n2 tähemärki indeksist pos2.
string strCol1=string('Ma armastan sind');string strCol2=string('me vihkame teda ja teda');
strCol1=strCol1.asendada(2, 4,strCol2, 3, 12);
maksma<<strCol1<< ' n';
Väljund: ma vihkan teda ja sind.
põhiline_string&asendada(suurus_tüüp pos1,suurus_tüüp n1, constcharT*s,suurus_tüüp n2)
Asendab indeksi pos1 põhitringiobjekti n1 tähemärki literaalse stringi argumendi esimeste n2 tähemärgiga.
string strCol1=string('Ma armastan sind');strCol1=strCol1.asendada(2, 4, 'vihkan teda ja teda', 12);
maksma<<strCol1<< ' n';
Väljund: ma vihkan teda ja sind.
põhiline_string ja asendamine (suurustüüp pos, suurustüüp n, konst charT* s)
Asendab n -tähemärgi peamises stringiobjektis indeksist pos ja sõnasõnalise stringi argumendiga.
string strCol1=string('Ma armastan sind');strCol1=strCol1.asendada(2, 4, 'vihkan teda ja');
maksma<<strCol1<< ' n';
Väljund: ma vihkan teda ja sind.
põhiline_string&asendada(suurus_tüüp pos1,suurus_tüüp n1,suurus_tüüp n2,sümbol c)Asendab indeksi pos1 peamise stringiobjekti n1 tähemärki argumendi sama tähemärgiga n2.
string strCol1=string('Halb tablett seal.');strCol1=strCol1.asendada(9, 3, 2, 'või');
maksma<<strCol1<< ' n';
Väljund: halb tabu seal ..
iteraatori kustutamine (const_iterator p)
Eemaldab märgi iteraatori osutatud positsioonilt; tagastab seejärel iteraatori positsiooni, mille nüüd hõivab selle märgi kõrval olev märk (või lõpp ()). Seda illustreerib järgmine kood:
string strCol=string('abcd');põhiline_string<süsi> ::iteraatoriter=strCol.alustada();
++iter; ++iter;
strCol.kustutada(iter);
maksma<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Väljund: a b d
põhiline_string&kustutada(suurus_tüüp pos= 0,suurus_tüüp n=npos)Eemaldab indeksist n tähemärki, pos.
string strCol=string('abcd');strCol.kustutada(1, 2);
maksma<<strCol[0] << '' <<strCol[1] << ' n';
Väljund: a d
void push_back (charT c)
Üksiku märgi lisamiseks stringi lõppu tehke järgmist.
string strCol=string('abcd');strCol.lükka tagasi('5');
maksma<<strCol<< ' n';
Väljund: abcd5
tühine pop_back ()
Eemaldab viimase märgi ilma seda tagastamata. Stringi suurust vähendatakse 1 võrra.
string strCol=string('abcde');strCol.pop_back();
maksma<<strCol<< ' n';
Väljund: abcd
tühine vahetus (põhiline string & s)
Kahe stringiobjekti literaale saab vahetada.
string strCol1=string(<abi='post-69618 -__ DdeLink__781_3724385525'>et>'abcde');string strCol2=string(„1234567”);
strCol1.vahetada(strCol2);
maksma<<strCol1<< ' n';
maksma<<strCol2<< ' n';
Väljund on:
„1234567”'abcde'
Stringi toimingud
const charT* c_str () const noexcept
Tagastab kursori stringi esimesele elemendile. Kursorit saab suurendada.
conststring strCol=string('abcde');const süsi*lk=strCol.c_str();
maksma<< *lk<< ' n';
++lk;
maksma<< *lk<< ' n';
Väljund on:
etb
Pealkirja teise konstati tõttu ei saa programm stringi ühtegi märki muuta. Konstruktsioonile eelneb konst.
const charT* andmed () const noexcept
Tagastab kursori stringi esimesele elemendile. Kursorit saab suurendada.
conststring strCol=string('abcde');const süsi*lk=strCol.andmed();
maksma<< *lk<< ' n';
++lk;
maksma<< *lk<< ' n';
Väljund on:
etb
Pealkirja teise konstati tõttu ei saa programm stringi ühtegi märki muuta. Konstruktsioonile eelneb konst.
põhi_string alamstring (suurustüüp pos = 0, suurustüüp n = npos) konst
Tagastab n-tähemärgist koosneva stringiobjekti alamstringi jaoks, mis algab indeksist, pos.
conststring strCol=string('abcdefghij');conststring retStr=strCol.alamstr(2, 4);
maksma<<retStr<< ' n';
Väljund: cdef
leia () liikme funktsioonid
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Otsib alamstringi objekti, mis algab indeksist, pos. Kui see leitakse, tagastab peastringi alamstringi algus.
string strCol=string('Me oleme maailm!');string strCol1=string('');
intühe peale=strCol.leida(strCol1, 2);
maksma<<ühe peale<< ' n';
Väljund:
indeks: 7Tagastab -1, kui seda ei leita.
size_type find (const charT* s, size_type pos = 0) const
Otsib alamstringi literaali, mis algab indeksist, pos. Kui see leitakse, tagastab peastringi alamstringi algus.
string strCol=string('Me oleme maailm!');intühe peale=strCol.leida('on', 0);
maksma<<ühe peale<< ' n';
Kuna vaikimisi on pos = 0, oleks argumendi 0 võinud välja jätta.
Väljund: 3
Tagastab -1, kui seda ei leita.
size_type find (const charT* s, size_type pos, size_type n) const
Otsib indeksist algava alamstringi literaali esimest n tähemärki, pos. Kui see leitakse, tagastab peastringi alamstringi algus.
string strCol=string('Suurim poiss');intühe peale=strCol.leida('suurem', 1, 3);
maksma<<ühe peale<< ' n';
Väljund: 4
Tagastab -1, kui seda ei leita.
size_type find (charT c, size_type pos = 0) const
Otsib märki, c alates indeksist, pos. Kui see leitakse, tagastab peastringi alamstringi algus. Kui ei leitud, tagastab -1.
string strCol=string('Me oleme maailm!');intühe peale=strCol.leida('Koos');
maksma<<ühe peale<< ' n';
Väljund: -1
Olemas on järgmised pöördotsingu () liikmefunktsioonid:
size_type rfind(constpõhiline_string&lk,suurus_tüüp pos=npos) constvälja arvatud;size_type rfind(constcharT*s,suurus_tüüp pos=npos) const;
size_type rfind(constcharT*s,suurus_tüüp pos,suurus_tüüp n) const;
size_type rfind(sümbol c,suurus_tüüp pos=npos) const;
Liikmete funktsioonide võrdlus
int võrrelda (const basic_string & str) const noexcept
Võrdleb argumendi stringi objekti peamise stringiobjektiga. Kui peamine string esineb enne argumenti (sõnastikus), tagastab see positiivse arvu. Kui see ilmneb pärast põhistringi, tagastab see negatiivse arvu. Kui kaks stringi on samad, tagastab see nulli.
string strCol1=string('rahvahulk');string strCol2=string('inimesed');
intühe peale=strCol1.võrdlema(strCol2);
maksma<<ühe peale<< ' n';
Väljund: -13
int võrrelda (const charT* s) const
Sama nagu eespool, kuid argument on string literal.
string strCol1=string('inimesed');intühe peale=strCol1.võrdlema('inimesed');
maksma<<ühe peale<< ' n';
Väljund: 0
Stringioperaatorid
Need operaatorid on rakendatavad stringiobjektidele, mitte tingimata string literaalidele.
+
Ühendab kaks stringiobjekti ja tagastab liitmise.
string strCol1=string('tantsib edasi');string strCol2=string(' kuu');
string strCol=strCol1+strCol2;
maksma<<strCol<< ' n';
Väljund: tantsimine Kuul.
==
Tagastab 1 väärtuse true, kui stringi objektid on samad; ja null vale, kui nad seda ei tee.
string strCol1=string('tantsib edasi');string strCol2=string(' kuu peal');
bool bl=strCol1==strCol2;
maksma<<bl<< ' n';
Väljund: 0
! =
Tagastab 1, kui stringiobjektid pole samad, ja nulli, kui need on.
string strCol1=string('tantsib edasi');string strCol2=string(' kuu peal');
bool bl=strCol1! =strCol2;
maksma<<bl<< ' n';
Väljund: 1
<
Tagastab 1, kui vasakpoolne operand on sõnastiku järgi paremast parem või vähem, kui seda pole.
string strCol1=string('tantsib edasi');string strCol2=string(' kuu peal');
bool bl=strCol1<strCol2;
maksma<<bl<< ' n';
Väljund: 0
Tavaliste tähemärkide puhul C ++ - s on kasvavas järjekorras numbrid enne suurtähti, mis enne väiketähti. Kosmosemärk tuleb enne nulli ja kõik need.
C ++ peamised stringid
süsi
Sümbolitüüp on algne C ++ tüüp ja tavaliselt salvestab see tähemärgi 8 bitti.
char16_t
See salvestab märgi 16 bitti.
char32_t
See salvestab märgi 32 bitti.
wchar_t
char16_t ja char32_t on laiad märgid. wchar_t on laia iseloomuga, mis on omandiõiguse ja rakenduse määratletud.
Neid tüüpe nimetatakse tunnusteks. Kuid C ++ viitab neile tehniliselt kui tunnuste spetsialiseerumisele. See artikkel on keskendunud sümboli tüübile. Lähenemine teistele tüüpidele on veidi erinev - vt hiljem.
Muud stringi operatsiooni liikme funktsioonid
Muude stringifunktsioonide allkirjad on järgmised:
size_type find_first_of(constpõhiline_string&lk,suurus_tüüp pos= 0) constvälja arvatud;size_type find_first_of(constcharT*s,suurus_tüüp pos,suurus_tüüp n) const;
size_type find_first_of(constcharT*s,suurus_tüüp pos= 0) const;
size_type find_first_of(sümbol c,suurus_tüüp pos= 0) const;
size_type find_last_of(constpõhiline_string&lk,suurus_tüüp pos=npos) constvälja arvatud;
size_type find_last_of(constcharT*s,suurus_tüüp pos,suurus_tüüp n) const;
size_type find_last_of(constcharT*s,suurus_tüüp pos=npos) const;
size_type find_last_of(sümbol c,suurus_tüüp pos=npos) const;
size_type find_first_not_of(constpõhiline_string&lk,suurus_tüüp pos= 0) constvälja arvatud;
size_type find_first_not_of(constcharT*s,suurus_tüüp pos,suurus_tüüp n) const;
size_type find_first_not_of(constcharT*s,suurus_tüüp pos= 0) const;
size_type find_first_not_of(sümbol c,suurus_tüüp pos= 0) const;
size_type find_last_not_of(constpõhiline_string&lk,suurus_tüüp pos=npos) constvälja arvatud;
size_type find_last_not_of(constcharT*s,suurus_tüüp pos,suurus_tüüp n) const;
size_type find_last_not_of(constcharT*s,suurus_tüüp pos=npos) const;
size_type find_last_not_of(sümbol c,suurus_tüüp pos=npos) const;
Järeldus
C ++ -l on stringide literaalid ja stringiobjektid. Stringiobjektil on järjestuses tähemärkide kogum, mis sarnaneb järjestikuste märkide massiiviga. Stringikogu ja massiivi erinevus seisneb selles, et stringide kogu võib kasvada või kahaneda. Stringiobjekt luuakse (konstrueeritakse) stringiklassist. Stringiobjekt on liikmefunktsioonidega andmestruktuur. Liikmefunktsioone saab liigitada objektide ehitamise, elementidele juurdepääsu, stringimahu, stringiliikmete funktsioonide, iteraatori argumentide ja tagastustüüpidega ning stringimodifikaatorite rubriikide alla. Samuti on olemas stringide võrdsuse ja relatsioonioperaatorid.