Klase un objekti
Klase ir mainīgo un funkciju kopums, kas darbojas kopā; kur mainīgajiem nav piešķirtas vērtības. Kad mainīgajiem tiek piešķirtas vērtības, klase kļūst par objektu. Dažādas vērtības, kas piešķirtas vienai klasei, rada dažādus objektus; tas ir, dažādi objekti ir viena klase ar dažādām vērtībām. Tiek uzskatīts, ka objekta izveidošana no klases ir objekta eksponēšana.
Nosaukums, virkne, ir klase. No virkņu klases izveidotam objektam ir programmētāja izvēlēts nosaukums.
Funkcija, kas pieder klasei, ir nepieciešama, lai parādītu objektu no klases. C ++ šai funkcijai ir tāds pats nosaukums kā klases nosaukumam. No klases izveidotajiem (paraugajiem) objektiem programmētājs ir piešķīris dažādus nosaukumus.
Izveidot objektu no klases nozīmē konstruēt objektu; tas nozīmē arī momentānošanu.
C ++ programma, kas izmanto virkņu klasi, sākas ar šādām rindām faila augšdaļā:
#iekļaut#iekļaut
izmantojot nosaukumvietas std;
Pirmā rinda ir paredzēta ievadīšanai/izvadīšanai. Otrā rinda ir ļaut programmai izmantot visas virkņu klases funkcijas. Trešā rinda ļauj programmai izmantot nosaukumus standarta nosaukumu telpā.
Funkcijas pārslodze
Ja diviem vai vairākiem dažādu funkciju parakstiem ir vienāds nosaukums, tiek uzskatīts, ka šis nosaukums ir pārslogots. Izsaucot vienu funkciju, argumentu skaits un veids nosaka, kura funkcija tiek izpildīta.
Būvniecība
virkne ()
Šis paziņojums veido nulles garuma virkni bez rakstzīmes.
Tas sākas ar klases nosaukumu (objekta tips), virkni. Pēc tam seko programmētāja dotais objekta virknes nosaukums. Piešķiršanas operators seko; tad konstruktora nosaukums ar tukšām iekavām. Šeit strCol ir izveidotais objekts ar visiem datu dalībniekiem (rekvizītiem) un dalībnieku funkcijām (metodēm).
virkne (str)
Tas ir līdzīgs iepriekšminētajam, taču konstruktorā kā argumentu tiek ņemts vai nu virknes literāls, vai identifikators. To ilustrē šāds paziņojums:
Būvniecība ar inicializētāju sarakstu
To ilustrē šāds kods:
virkne strCol=virkne({'Es','','','vai','v','Un','','un','vai','tu',' 0'});Stīgu burtiski ir es tevi mīlu. Ievērojiet nulles rakstzīmi inicializētāju saraksta beigās.
virkne (str, n)
Tas veido virkņu kolekciju, kas sastāv no citas virknes pirmajām n rakstzīmēm. To ilustrē šāds kods:
charlpp[] = 'Es mīlu Tevi';virkne strCol=virkne(lpp, 6);
izmaksas<<strCol<< ' n';
Rezultāts ir I love ar pirmajām 6 rakstzīmēm no I love you. Atcerieties: vienotā atstarpe ir raksturs.
virkne (str, pos, n)
Tas veido virkni no n rakstzīmēm, sākot ar citas virknes indeksēto pozīciju poz. To ilustrē šāds kods:
charlpp[] = 'Es mīlu Tevi';virkne strCol=virkne(lpp, 2, 4);
izmaksas<<strCol<< ' n';
Rezultāts ir, mīlestība.
Iepriekš minētajos divos gadījumos, ja n ir lielāks par virknes lielumu, tiek izmests izņēmums out_of_range - skatīt vēlāk.
virkne (n, “c”)
Veido n rakstzīmju kolekciju, kurā visas rakstzīmes ir vienādas. Apsveriet,
virkne strCol=virkne(5,'Un');izmaksas<<strCol<< ' n';
Rezultāts ir, eeeee, 5 e.
Virknes piešķiršana
Pēc abu virkņu deklarēšanas virkni var piešķirt šādi:
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2;
strCol2=strCol1;
izmaksas<<strCol2<< ' n';
Rezultāts ir - es tevi mīlu.
Konstruēšana ar Iterator
Iterators nodrošina vispārīgu skenēšanas attēlojumu, izmantojot kolekcijas vērtības. Sintakse, lai izveidotu virkni ar iteratoru, ir šāda:
veidne<klases InputIterator>pamata_virkne(Sākas InputIterator,InputIterator beigas, konstPiešķīrējs&
uz=Piešķīrējs());
Tādējādi tiek izveidota virkne diapazonam [sākums, beigas] - sīkāku informāciju skatiet vēlāk.
Stīgu iznīcināšana
Lai iznīcinātu virkni, vienkārši ļaujiet tai iziet no darbības jomas.
Piekļuve stīgu klases elementiem
Izveidots virknes objekts var tikt subkripts (indeksēts) kā masīvs. Indeksa skaitīšana sākas no nulles.
stringName [i]
Operācija stringName [i] atgriež atsauci uz rakstzīmi (elementu) itūkstrakstzīmju kolekcijas rādītājs. Šādi koda izvadi v:
virkne strCol=virkne('Es mīlu Tevi');charch=strCol[4];
izmaksas<<ch<< ' n';
stringName [i] const
Operācija stringName [i] const tiek izpildīta stringName [i] vietā, ja virknes objekts ir nemainīgs objekts. To izmanto, piemēram, šādā kodā:
konstvirkne strCol=virkne('Es mīlu Tevi');charch=strCol[4];
izmaksas<<ch<< ' n';
Izteiksme atgriež pastāvīgu atsauci uz itūkstvirknes objekta elements. Nevienu no virknes elementiem nevar mainīt.
Rakstzīmes piešķiršana ar apakšindeksu
Rakstzīmi var piešķirt nemainīgam virknes objektam šādi:
virkne strCol=virkne('Es zvanu');strCol[2] = 'f';
izmaksas<<strCol<< ' n';
Rezultāts ir I kritums. “C” tika mainīts uz “f”.
stringName.at (i)
stringName.at (i) ir līdzīgs stringName [i], bet stringName.at (i) ir ticamāks. Šis kods parāda, kā tas jāizmanto:
virkne strCol=virkne('Es mīlu Tevi');charch=strCol.plkst(4);
izmaksas<<ch<< ' n';
at () faktiski ir virkņu klases dalībnieka funkcija.
stringName.at (i) const
stringName.at (i) const ir līdzīgs stringName [i] const, bet stringName.at (i) const ir ticamāks. stringName.at (i) const tiek izpildīts stringName.at (i) vietā, ja virknes objekts ir nemainīgs virknes objekts. To izmanto, piemēram, šādā kodā:
konstvirkne strCol=virkne('Es mīlu Tevi');charch=strCol.plkst(4);
izmaksas<<ch<< ' n';
at () const faktiski ir virkņu klases dalībnieka funkcija.
Vērtības piešķiršana funkcijai at ()
Vērtību var piešķirt nemainīgam virknes objektam ar funkciju at () šādi:
virkne strCol=virkne('Es zvanu');strCol.plkst(2) = 'f';
izmaksas<<strCol<< ' n';
Rezultāts ir I kritums.
Problēma ar apakšskriptēšanu
Apakšskriptēšanas (indeksēšanas) problēma ir tāda, ka, ja indekss ir ārpus diapazona, var tikt iegūts nepareizs rezultāts vai izpildes laikā var tikt parādīta kļūda.
priekšā ()
Tas atgriež atsauci uz virknes objekta pirmo elementu, nenoņemot elementu. Šāda koda izvade ir “I”.
virkne strCol=virkne('Es mīlu Tevi');charch=strCol.priekšā();
izmaksas<<ch<< ' n';
Rakstzīme netiek noņemta no virknes objekta.
front () const
Ja pirms virknes objekta konstrukcijas ir Const, izteiksme front () const tiek izpildīta, nevis front (). Piemēram, tas tiek izmantots šādā kodā.
konstvirkne strCol=virkne('Es mīlu Tevi');charch=strCol.priekšā();
izmaksas<<ch<< ' n';
Tiek atgriezta pastāvīga atsauce. Elements nav noņemts no virknes objekta. Pastāvīga virknes objektam nevar mainīt nevienu rakstzīmi.
atpakaļ ()
Tas atgriež atsauci uz virknes objekta pēdējo elementu, nenoņemot elementu. Šāda koda izvade ir “u”.
virkne strCol=virkne('Es mīlu Tevi');charch=strCol.atpakaļ();
izmaksas<<ch<< ' n';
atpakaļ () konst
Ja pirms virknes objekta konstrukcijas ir const, izteiksme back () const tiek izpildīta, nevis back (). Piemēram, tas tiek izmantots šādā kodā.
konstvirkne strCol=virkne('Es mīlu Tevi');charch=strCol.atpakaļ();
izmaksas<<ch<< ' n';
Tiek atgriezta pastāvīga atsauce. Elements nav noņemts no virknes objekta.
Stīgu ietilpība
size_type capacity () const noexcept
Kopējo rakstzīmju skaitu, ko virkne var saturēt, neprasot pārdalīšanu, atgriež šī kapacitātes dalībnieka funkcija. Koda segments tam ir šāds:
virkne strCol=virkne();intuz vienu=strCol.jaudu();
izmaksas<<uz vienu<< ' n';
Manā datorā izvade ir 15.
rezerve (n)
Brīvā veikalā ne vienmēr ir pieejama atmiņas vieta. Papildu vietu var rezervēt iepriekš. Apsveriet šādu koda segmentu:
virkne strCol=virkne('mīlestība');strCol.rezervē(6);
izmaksas<<strCol.jaudu() << ' n';
Manā datorā izvade ir 15.
size () const noexcept
Tas atgriež virknes rakstzīmju skaitu. Šis kods ilustrē:
virkne strCol=virkne('Es mīlu Tevi');intuz vienu=strCol.Izmērs();
izmaksas<<uz vienu<< ' n';
Rezultāts ir 10, kas neietver nulles, 0 rakstzīmi.
length () const noexcept
-tāds pats kā izmērs().Piezīme:Izmērs() <=jaudu().
shrink_to_fit ()
Var samazināt jaudu () līdz izmēram (), izraisot pārdali; tas nav obligāti. To parāda šāds kods:
virkne strCol=virkne('Es mīlu Tevi');strCol.rezervē(12);
strCol.shrink_to_fit();
ints=strCol.Izmērs();
izmaksas<<s<< ' n';
Izeja ir 10, nevis 12 vai 16. Funkcija atgriež tukšu.
mainīt izmērus (sz), mainīt izmērus (sz, ’c’)
Tādējādi tiek mainīts virknes lielums. Ja jaunais izmērs ir mazāks par veco, tad beigās esošie elementi tiek izdzēsti. Ja jaunais izmērs ir garāks, beigās tiek pievienota kāda noklusējuma rakstzīme. Lai pievienotu noteiktu rakstzīmi, izmantojiet resize () funkciju ar diviem argumentiem. Šis koda segments ilustrē abu funkciju izmantošanu:
virkne strCol=virkne('Es mīlu Tevi');strCol.mainīt izmērus(6);
izmaksas<< 'Jauns strCol izmērs:' <<strCol.Izmērs() << ' n';
virkne strCol1=virkne('ES mīlu', 'Un');
strCol1.mainīt izmērus(12);
izmaksas<< 'Jauns strCol1 izmērs:' <<strCol1.Izmērs() << ' n';
Rezultāts ir šāds:
Jauns strCol izmērs: 6Jauns strCol1: 12 izmērs
Funkcija atgriežas spēkā neesoša.
skaidrs () noexcept
Noņem visus elementus no virknes, kā parādīts šādā koda segmentā:
virkne strCol=virkne('Es mīlu Tevi');strCol.skaidrs();
izmaksas<<strCol.Izmērs() << ' n';
Rezultāts ir 0. Funkcija atgriež tukšu.
empty () const noexcept
Tas atgriež 1 par patiesu, ja virknes objektā nav rakstzīmes, vai 0 par nepatiesu, ja virknes objekts nav tukšs. To ilustrē šāds kods:
virkne strCol1=virkne('Es mīlu Tevi');izmaksas<<strCol1.tukšs() << ' n';
virkne strCol2=virkne();
izmaksas<<strCol2.tukšs() << ' n';
Rezultāts ir šāds:
01
Iteratoru atgriešanās un stīgu klase
Iterators ir kā rādītājs, bet tam ir vairāk funkcionalitātes nekā rādītājam.
start () noexcept
Atgriež iteratoru, kas norāda uz virknes objekta pirmo rakstzīmi (elementu), kā norādīts šādā koda segmentā:
virkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::iteratorsiter=strCol.sākt();
izmaksas<< *iter<< ' n';
Rezultāts ir “es”. Ievērojiet, kā ir deklarēta deklarācija, kas saņem iteratoru. Atkārtotajā izteiksmē iteratoram tiek atsaukta atsauce, lai iegūtu vērtību tādā pašā veidā, kā norādes atcelšana.
begin () const noexcept;
Atgriež iteratoru, kas norāda uz virknes objektu kolekcijas pirmo elementu. Ja pirms objekta konstrukcijas ir const, izteiksme begin () const tiek izpildīta, nevis begin (). Šādā gadījumā atbilstošo elementu objektā nevar mainīt. Piemēram, tas tiek izmantots šādā kodā.
konstvirkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::const_iteratoriter=strCol.sākt();
izmaksas<< *iter<< ' n';
Rezultāts ir “es”. Ņemiet vērā, ka atgrieztā iteratora saņemšanai šoreiz tika izmantots const_iterator, nevis tikai iterators.
end () noexcept
Atgriež iteratoru, kas norāda tieši aiz virknes objekta pēdējā elementa. Apsveriet šādu koda segmentu:
virkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::iteratorsiter=strCol.beigas();
izmaksas<< *iter<< ' n';
Rezultāts ir nulle, kas nav nekas, jo ārpus pēdējā elementa nav konkrēta elementa.
end () const noexcept
Atgriež iteratoru, kas norāda tieši aiz virknes objekta pēdējā elementa. Ja pirms virknes objekta konstrukcijas ir konst, izteiksme end () const tiek izpildīta, nevis end (). Apsveriet šādu koda segmentu:
konstvirkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::const_iteratoriter=strCol.beigas();
izmaksas<< *iter<< ' n';
Izeja ir nulle. Ņemiet vērā, ka atgrieztā iteratora saņemšanai šoreiz tika izmantots const_iterator, nevis tikai iterators.
Apgrieztā atkārtošana
Ir iespējams izveidot atkārtotāju, kas atkārtojas no faktiskā gala līdz tieši pirmajam elementam:
rbegin () noexcept
Atgriež iteratoru, kas norāda uz virknes paraudzītā objekta pēdējo elementu, kā norādīts šādā koda segmentā:
virkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::reverse_iteratoriter=strCol.rbegin();
izmaksas<< *iter<< ' n';
Rezultāts ir “u”. Ievērojiet veidu, kādā deklarēta deklarācija, kas saņem reverso iteratoru. Atkārtotajā izteiksmē iteratoram tiek atsaukta atsauce, lai iegūtu vērtību tādā pašā veidā, kā norādes atcelšana.
rbegin () const noexcept;
Atgriež iteratoru, kas norāda uz virknes objekta pēdējo elementu. Ja pirms objekta konstrukcijas ir Const, izteiksme rbegin () const tiek izpildīta rbegin () vietā. Šādā gadījumā atbilstošo elementu objektā nevar mainīt. Šī funkcija tiek izmantota, piemēram, šādā kodā.
konstvirkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::const_reverse_iteratoriter=strCol.rbegin();
izmaksas<< *iter<< ' n';
Rezultāts ir “u”. Ņemiet vērā, ka atgrieztā iteratora saņemšanai šoreiz tika izmantots konstanta_reversais_iterators, nevis tikai reversais_iterators.
render () noexcept
Atgriež iteratoru, kas norāda tieši pirms virknes objekta pirmā elementa. Apsveriet šādu koda segmentu:
virkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::reverse_iteratoriter=strCol.padara();
izmaksas<< *iter<< ' n';
Rezultāts ir nulle, kas nav nekas, jo tieši pirms pirmā elementa nav konkrēta elementa.
render () const noexcept
Atgriež iteratoru, kas norāda tieši pirms virknes objekta pirmā elementa. Ja objekta konstrukcijas priekšā ir konst, izteiksme rend () const tiek izpildīta nevis rend (). Apsveriet šādu koda segmentu:
konstvirkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::const_reverse_iteratoriter=strCol.padara();
izmaksas<< *iter<< ' n';
Izeja ir nulle. Ņemiet vērā, ka atgrieztā iteratora saņemšanai šoreiz tika izmantots konstanta_reversais_iterators, nevis tikai reversais_iterators.
Stīgu pārveidotāji
Modifikators, kas maina virknes objektu, var arī ņemt vai atgriezt atkārtotāju.
Pievienošana
pamata_virkne&operators+ =(konstpamata_virkne&lpp)Pievieno labo virknes objektu kreisajam virknes objektam. Piemērs:
virkne strCol1=virkne('ES mīlu');virkne strCol2=virkne('tu');
strCol1+ =strCol2;
izmaksas<<strCol1<< ' n';
Rezultāts ir es tevi mīlu. Neaizmirstiet, ka strCol1 += strCol2 ir tāds pats kā strCol1 = strCol1 +strCol2.
pamata_virkne un operators+= (const charT* s)
Virkņu objektu kolekcijai pievieno virknes literālu. Piemērs:
virkne strCol=virkne('ES mīlu');strCol+ = 'tu';
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu.
pamata_virkne un operators+= (charT c)
Objekta virknei pievieno vienu rakstzīmi. Piemērs:
virkne strCol=virkne('Es tevi mīlu');strCol+ = 'tu';
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu.
pamata_virkne un operators+= (inicializācijas_saraksts)
Pievieno inicializētāju sarakstu. Piemērs:
virkne strCol=virkne('ES mīlu');strCol+ = {'','un','vai','tu',' 0'};
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu. Rakstzīmju inicializētāju saraksta beigās vienmēr ir labi pievienot nulli, 0.
pamata_virkne un pievienot (konst pamata_virkne un str)
Pievieno argumentu virknes objektu galvenajam virknes objektam. Piemērs:
virkne strCol1=virkne('ES mīlu');virkne strCol2=virkne('tu');
strCol1.pievienot(strCol2);
izmaksas<<strCol1<< ' n';
Rezultāts: Es tevi mīlu.
basic_string & append (const charT* s)
Pievieno virknei burtisku argumentu galvenajai virknei. Piemērs
virkne strCol=virkne('ES mīlu');strCol=strCol.pievienot('tu');
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu.
pamata_virkne un pievienot (inicializācijas_saraksts)
Pievieno inicializētāju sarakstu, kas ir arguments, galvenajai virknei. Piemērs:
virkne strCol=virkne('ES mīlu');strCol=strCol.pievienot({'','un','vai','tu',' 0'});
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu. Vienmēr ir labi inicializētāju saraksta beigās pievienot nulli, 0 rakstzīmi.
pamata_virkne un pievienošana (izmēra_tips n, charT c)
Pievieno n ar tādu pašu rakstzīmi. Piemērs:
virkne strCol=virkne('cilne');strCol=strCol.pievienot(2, 'vai');
izmaksas<<strCol<< ' n';
Rezultāts: tabu.
basic_string & append (const charT* s, size_type n)
Pievieno virknes literāļa pirmo n elementu galvenajam virknes objektam. Piemērs:
virkne strCol=virkne('ES mīlu');strCol=strCol.pievienot('tu tik', 4);
izmaksas<<strCol<< ' n';
Rezultāts: es tevi mīlu. Ja n ir lielāks par literāra garumu, tiek izmests garuma kļūdas izņēmums.
pamata_virkne un pievienošana (konst.
Pievieno n rakstzīmes no indeksa, poz galvenajai virknei. Piemērs:
virkne strCol=virkne('ES mīlu');strCol=strCol.pievienot(vai tu tāds esi, 2, 4);
izmaksas<<strCol<< ' n';
Rezultāts: Es tevi mīlu. Šeit tiktu izmests arī izņēmums, skatīt vēlāk.
Piešķiršana
pamata_virkne&piešķirt(konstpamata_virkne&lpp)Piešķir argumentam virknes objektu galvenajai virknei, aizstājot visu tajā esošo saturu.
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2=virkne('Viņai esmu vajadzīga');
strCol1=strCol1.piešķirt(strCol2);
izmaksas<<strCol1<< ' n';
Rezultāts: Viņai esmu vajadzīga.
pamata_virkne&piešķirt(konstraksturs*s)Piešķir virknei burtisku argumentu galvenajai virknei, aizstājot visu tajā esošo saturu.
virkne strCol=virkne('Es mīlu Tevi');strCol=strCol.piešķirt('Viņai esmu vajadzīga');
izmaksas<<strCol<< ' n';
Rezultāts: Viņai esmu vajadzīga.
pamata_virkne&piešķirt(initializer_list<raksturs>)Piešķir inicializatoru saraksta argumentu galvenajai virknei,aizstājot visu tur esošo saturu.
[cc lang='c'aizbēga='patiess'platums='780']
virkne strCol=virkne('Es mīlu Tevi');
strCol=strCol.piešķirt({'S','h','Un','','n','Un','Un','d','s','','es','Un',' 0'});
izmaksas<<strCol<< ' n';
Rezultāts: Viņai esmu vajadzīga. Ir labi rakstzīmju saraksta beigās vienmēr pievienot nulli, 0, lai izveidotu virknes literālu.
pamata_virkne&piešķirt(konstraksturs*s,izmēra_tips n)Piešķir galvenajai virknei burtu argumenta pirmās n rakstzīmes, aizstājot visu tur esošo saturu.
virkne strCol=virkne('Es mīlu Tevi');strCol=strCol.piešķirt('Viņai esmu vajadzīga', 9);
izmaksas<<strCol<< ' n';
Rezultāts: viņai vajag.
pamata_virkne&piešķirt(izmēra_tips n,rakstzīme c)Piešķir galvenajai virknei argumentu ar vienādām rakstzīmēm, aizstājot visu tur esošo saturu.
virkne strCol=virkne('Es mīlu Tevi');strCol=strCol.piešķirt(4, 'Un');
izmaksas<<strCol<< ' n';
Izeja: eeee
pamata_virkne&piešķirt(konstpamata_virkne&lpp,lieluma_tips poz,izmēra_tips n=npos)
Piešķir galvenajai virknei virknes objekta argumenta n rakstzīmes, sākot no pos, aizstājot visu tur esošo saturu.
virkne strCol=virkne('Es mīlu Tevi');strCol=strCol.piešķirt('Viņai esmu vajadzīga', 4, 5);
izmaksas<<strCol<< ' n';
Rezultāts: vajadzības. Izmestu izņēmumu - skatīt vēlāk.
Ievietošana
pamata_virkne&ielikt(lieluma_tips poz, konstpamata_virkne&lpp)Ievieto virknes objekta argumentu galvenajā virknē, indeksā, poz.
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2=virkne('ienīst un');
strCol1=strCol1.ielikt(2,strCol2);
izmaksas<<strCol1<< ' n';
Rezultāts: Es tevi ienīstu un mīlu. Izmestu izņēmumu - skatīt vēlāk.
pamata_virkne&ielikt(size_type pos1, konstpamata_virkne&lpp,size_type pos2,izmēra_tips n=npos)
Ievieto n rakstzīmju garumu no virknes objekta argumenta pos2, galvenajā virknē, indeksā, pos1.
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2=virkne('ienīst, gribēt un vajag');
strCol1=strCol1.ielikt(2,strCol2, 6, 9);
izmaksas<<strCol1<< ' n';
Rezultāts: Es gribu un mīlu tevi.
iteratora ieliktnis (const_iterator p, charT c)
Ievada iteratora norādītajā pozīcijā noteiktu rakstzīmi, kas ir arguments. Atgriež iterētāju tikko ievietotās rakstzīmes pozīcijai.
virkne strCol=virkne('Es mīlu Tevi');pamata_virkne<char> ::iteratorsiter=strCol.sākt();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
pamata_virkne<char> ::iteratorstīklā=strCol.ielikt(iter, 'd');
izmaksas<< *tīklā<< ' n';
izmaksas<<strCol<< ' n';
Rezultāts ir šāds:
“D”
ES tevi mīlēju
iteratora ieliktnis (const_iterator p, size_type n, charT c)
Iekļauj n ar tāda paša rakstura argumentu pozīcijā, uz kuru norāda iterators. Atgriež iteratoru tikko ievietoto to pašu rakstzīmju sākuma pozīcijai.
virkne strCol=virkne('Tab zemē.');pamata_virkne<char> ::iteratorsiter=strCol.sākt();
++iter; ++iter; ++iter;
pamata_virkne<char> ::iteratorstīklā=strCol.ielikt(iter, 2, 'vai');
izmaksas<< *tīklā<< ' n';
izmaksas<<strCol<< ' n';
Rezultāts ir šāds:
'vai'
Tabu zemē.
pamata_virkne&ielikt(lieluma_tips poz, konstraksturs*s)Indeksā ievieto argumentu virknes literālu, poz galvenajā virknē.
virkne strCol=virkne('Tab zemē.');strCol=strCol.ielikt(3, 'oo');
izmaksas<<strCol<< ' n';
Rezultāts: Tabu zemē.
pamata_virkne&ielikt(lieluma_tips poz, konstraksturs*s,izmēra_tips n)Galvenajā virknē ieraksta argumentu virknes literālās pirmās n rakstzīmes indeksā, poz.
virkne strCol=virkne('Tab zemē.');strCol=strCol.ielikt(3, 'oooo', 2);
izmaksas<<strCol<< ' n';
Rezultāts: Tabu zemē.
Aizvietošana
pamata_virkne&aizvietot(size_type pos1,lieluma_tips n1, konstpamata_virkne&lpp))Aizstāj n1 rakstzīmes galvenajā virknes objektā no indeksa, pos1, ar argumentu virknes objektu.
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2=virkne('ienīstu tevi un');
strCol1=strCol1.aizvietot(2, 4,strCol2);
izmaksas<<strCol1<< ' n';
Rezultāts: Es ienīstu tevi un tevi. Izmestu izņēmumu - skatīt vēlāk.
pamata_virkne&aizvietot(size_type pos1,lieluma_tips n1, konstpamata_virkne&lpp,size_type pos2,lieluma_tips n2=npos)
Aizstāj n1 rakstzīmes galvenajā virknes objektā no indeksa, pos1, ar n2 rakstzīmju argumentu virknes objektu no indeksa, pos2.
virkne strCol1=virkne('Es mīlu Tevi');virkne strCol2=virkne('mēs ienīstam viņu un viņu');
strCol1=strCol1.aizvietot(2, 4,strCol2, 3, 12);
izmaksas<<strCol1<< ' n';
Rezultāts: Es ienīstu viņu un tevi.
pamata_virkne&aizvietot(size_type pos1,lieluma_tips n1, konstraksturs*s,lieluma_tips n2)
Aizstāj n1 rakstzīmes galvenajā virknes objektā no indeksa, pos1, ar burtiskās virknes argumenta pirmajām n2 rakstzīmēm.
virkne strCol1=virkne('Es mīlu Tevi');strCol1=strCol1.aizvietot(2, 4, 'ienīstu viņu un viņu', 12);
izmaksas<<strCol1<< ' n';
Rezultāts: Es ienīstu viņu un tevi.
pamata_virkne un aizstāšana (izmēra_tipa poz., izmēra_tips n, konstanta simbols* s)
Aizstāj n rakstzīmes galvenajā virknes objektā no indeksa, poz, ar burtiskās virknes argumentu.
virkne strCol1=virkne('Es mīlu Tevi');strCol1=strCol1.aizvietot(2, 4, 'ienīstu viņu un');
izmaksas<<strCol1<< ' n';
Rezultāts: Es ienīstu viņu un tevi.
pamata_virkne&aizvietot(size_type pos1,lieluma_tips n1,lieluma_tips n2,rakstzīme c)Aizstāj n1 rakstzīmes galvenajā virknes objektā no indeksa, pos1, ar n2 ar tāda paša rakstura argumentu.
virkne strCol1=virkne('Tur ir slikta tablete.');strCol1=strCol1.aizvietot(9, 3, 2, 'vai');
izmaksas<<strCol1<< ' n';
Rezultāts: tur ir slikts tabu ..
iteratora dzēšana (const_iterator p)
Noņem rakstzīmi vietā, uz kuru norāda atkārtotājs; pēc tam atgriež iteratora pozīciju, kuru tagad aizņem rakstzīme, kas atradās blakus šai rakstzīmei (vai beigām ()). To ilustrē šāds kods:
virkne strCol=virkne('abcd');pamata_virkne<char> ::iteratorsiter=strCol.sākt();
++iter; ++iter;
strCol.dzēst(iter);
izmaksas<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Rezultāts: a b d
pamata_virkne&dzēst(lieluma_tips poz= 0,izmēra_tips n=npos)Noņem no indeksa n rakstzīmes, poz.
virkne strCol=virkne('abcd');strCol.dzēst(1, 2);
izmaksas<<strCol[0] << '' <<strCol[1] << ' n';
Izeja: a d
void push_back (charT c)
Lai virknes beigās pievienotu vienu rakstzīmi:
virkne strCol=virkne('abcd');strCol.atgrūst(“5”);
izmaksas<<strCol<< ' n';
Izeja: abcd5
void pop_back ()
Noņem pēdējo rakstzīmi, neatgriežot to. Virknes izmērs tiek samazināts par 1.
virkne strCol=virkne('abcde');strCol.pop_back();
izmaksas<<strCol<< ' n';
Izeja: abcd
void swap (pamata_virkne un s)
Divu virkņu objektu literāļus var apmainīt.
virkne strCol1=virkne(<a id='post-69618 -__ DdeLink__781_3724385525'>uz>'abcde');virkne strCol2=virkne('1234567');
strCol1.apmainīt(strCol2);
izmaksas<<strCol1<< ' n';
izmaksas<<strCol2<< ' n';
Rezultāts ir šāds:
'1234567''abcde'
Stīgu operācijas
const charT* c_str () const noexcept
Atgriež rādītāju uz virknes pirmo elementu. Rādītāju var palielināt.
konstvirkne strCol=virkne('abcde');konst char*lpp=strCol.c_str();
izmaksas<< *lpp<< ' n';
++lpp;
izmaksas<< *lpp<< ' n';
Izeja ir:
uzb
Sakarā ar virsraksta otro konst, programma nevar mainīt virknes rakstzīmi. Konstrukcijas priekšā ir konst.
const charT* dati () const noexcept
Atgriež rādītāju uz virknes pirmo elementu. Rādītāju var palielināt.
konstvirkne strCol=virkne('abcde');konst char*lpp=strCol.dati();
izmaksas<< *lpp<< ' n';
++lpp;
izmaksas<< *lpp<< ' n';
Izeja ir:
uzb
Sakarā ar virsraksta otro konst, programma nevar mainīt virknes rakstzīmi. Konstrukcijas priekšā ir konst.
basic_string substr (lieluma_tips pos = 0, lieluma_tips n = npos) konst
Atgriež virknes objektu ar n rakstzīmēm apakšvirknei, kas sākas no indeksa, poz.
konstvirkne strCol=virkne('abcdefghij');konstvirkne retStr=strCol.apakšstr(2, 4);
izmaksas<<retStr<< ' n';
Izeja: cdef
atrast () dalībnieku funkcijas
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Meklē apakšvirkņu objektu, kas sākas no indeksa, poz. Ja tiek atrasts, atgriež apakšvirknes sākumu galvenajā virknē.
virkne strCol=virkne('Mēs esam pasaule!');virkne strCol1=virkne('');
intuz vienu=strCol.atrast(strCol1, 2);
izmaksas<<uz vienu<< ' n';
Izeja:
indekss: 7Atgriež -1, ja nav atrasts.
size_type find (const charT* s, size_type pos = 0) const
Meklē burtu burtu, kas sākas ar indeksu, poz. Ja tiek atrasts, atgriež apakšvirknes sākumu galvenajā virknē.
virkne strCol=virkne('Mēs esam pasaule!');intuz vienu=strCol.atrast('ir', 0);
izmaksas<<uz vienu<< ' n';
Tā kā noklusējums ir pos = 0, argumentu 0 varēja izlaist.
Izeja: 3
Atgriež -1, ja nav atrasts.
size_type find (const charT* s, size_type pos, size_type n) const
Meklē apakšvirknes burtiskā vārda pirmās n rakstzīmes, sākot no indeksa, poz. Ja tiek atrasts, atgriež apakšvirknes sākumu galvenajā virknē.
virkne strCol=virkne('Lielākais zēns');intuz vienu=strCol.atrast('lielāks', 1, 3);
izmaksas<<uz vienu<< ' n';
Izeja: 4
Atgriež -1, ja nav atrasts.
size_type find (charT c, size_type pos = 0) const
Meklē rakstzīmi, c sākot no indeksa, poz. Ja tiek atrasts, atgriež apakšvirknes sākumu galvenajā virknē. Ja netiek atrasts, atgriež -1.
virkne strCol=virkne('Mēs esam pasaule!');intuz vienu=strCol.atrast('Ar');
izmaksas<<uz vienu<< ' n';
Izeja: -1
Pastāv šādas dalībnieku atgriezeniskās meklēšanas () funkcijas:
size_type rfind(konstpamata_virkne&lpp,lieluma_tips poz=npos) konstizņemot, izņemot;size_type rfind(konstraksturs*s,lieluma_tips poz=npos) konst;
size_type rfind(konstraksturs*s,lieluma_tips poz,izmēra_tips n) konst;
size_type rfind(rakstzīme c,lieluma_tips poz=npos) konst;
Dalībnieku funkciju salīdzinājums
int salīdzināt (const basic_string & str) const no except
Salīdzina argumentu virknes objektu ar galveno virknes objektu. Ja galvenā virkne parādās pirms argumenta (vārdnīcā), tas atgriež pozitīvu skaitli. Ja tas notiek pēc galvenās virknes, tas atgriež negatīvu skaitli. Ja abas virknes ir vienādas, tas atgriež nulli.
virkne strCol1=virkne('pūlis');virkne strCol2=virkne('cilvēki');
intuz vienu=strCol1.salīdzināt(strCol2);
izmaksas<<uz vienu<< ' n';
Rezultāts: -13
int salīdzināt (const charT* s) const
Tas pats, kas iepriekš, bet arguments ir virknes literālis.
virkne strCol1=virkne('cilvēki');intuz vienu=strCol1.salīdzināt('cilvēki');
izmaksas<<uz vienu<< ' n';
Izeja: 0
Stīgu operatori
Šie operatori ir piemērojami virkņu objektiem, nevis obligāti virkņu literāļiem.
+
Apvieno divus virkņu objektus un atgriež saikni.
virkne strCol1=virkne('dejot tālāk');virkne strCol2=virkne(' Mēness');
virkne strCol=strCol1+strCol2;
izmaksas<<strCol<< ' n';
Rezultāts: dejas uz Mēness.
==
Atgriež vērtību 1, ja virknes objekti ir vienādi; un nulle par nepatiesu, ja tie nav.
virkne strCol1=virkne('dejot tālāk');virkne strCol2=virkne(' uz Mēness');
bool bl=strCol1==strCol2;
izmaksas<<bl<< ' n';
Izeja: 0
! =
Atgriež 1, ja virknes objekti nav vienādi, un nulli, ja tie ir.
virkne strCol1=virkne('dejot tālāk');virkne strCol2=virkne(' uz Mēness');
bool bl=strCol1! =strCol2;
izmaksas<<bl<< ' n';
Izeja: 1
<
Atgriež 1, ja kreisais operands ir mazāks par labo operandu saskaņā ar vārdnīcu, vai nulle, ja tā nav.
virkne strCol1=virkne('dejot tālāk');virkne strCol2=virkne(' uz Mēness');
bool bl=strCol1<strCol2;
izmaksas<<bl<< ' n';
Izeja: 0
Parastajām C ++ rakstzīmēm augošā secībā cipari ir pirms lielajiem burtiem, bet pirms mazajiem burtiem. Kosmosa raksturs ir pirms nulles, un tie visi.
C ++ galveno virkņu rakstzīmju tipi
char
Ogļu tips ir sākotnējais C ++ tips, un rakstzīme parasti tiek saglabāta 8 bitos.
char16_t
Tas saglabā rakstzīmi 16 bitos.
char32_t
Tas saglabā rakstzīmi 32 bitos.
wchar_t
char16_t un char32_t ir plašas rakstzīmes. wchar_t ir plaša rakstzīme, kas ir patentēta un noteikta ieviešanai.
Šos veidus sauc par īpašībām. Tomēr C ++ tos tehniski apzīmē kā īpašību specializācijas. Šajā rakstā galvenā uzmanība tika pievērsta ogļu tipam. Pieeja citiem veidiem ir nedaudz atšķirīga - skatīt vēlāk.
Citas virkņu darbības dalībnieku funkcijas
Citu virkņu darbības funkciju paraksti ir:
size_type find_first_of(konstpamata_virkne&lpp,lieluma_tips poz= 0) konstizņemot, izņemot;size_type find_first_of(konstraksturs*s,lieluma_tips poz,izmēra_tips n) konst;
size_type find_first_of(konstraksturs*s,lieluma_tips poz= 0) konst;
size_type find_first_of(rakstzīme c,lieluma_tips poz= 0) konst;
size_type find_last_of(konstpamata_virkne&lpp,lieluma_tips poz=npos) konstizņemot, izņemot;
size_type find_last_of(konstraksturs*s,lieluma_tips poz,izmēra_tips n) konst;
size_type find_last_of(konstraksturs*s,lieluma_tips poz=npos) konst;
size_type find_last_of(rakstzīme c,lieluma_tips poz=npos) konst;
size_type find_first_not_of(konstpamata_virkne&lpp,lieluma_tips poz= 0) konstizņemot, izņemot;
size_type find_first_not_of(konstraksturs*s,lieluma_tips poz,izmēra_tips n) konst;
size_type find_first_not_of(konstraksturs*s,lieluma_tips poz= 0) konst;
size_type find_first_not_of(rakstzīme c,lieluma_tips poz= 0) konst;
size_type find_last_not_of(konstpamata_virkne&lpp,lieluma_tips poz=npos) konstizņemot, izņemot;
size_type find_last_not_of(konstraksturs*s,lieluma_tips poz,izmēra_tips n) konst;
size_type find_last_not_of(konstraksturs*s,lieluma_tips poz=npos) konst;
size_type find_last_not_of(rakstzīme c,lieluma_tips poz=npos) konst;
Secinājums
C ++ ir virkņu literāli un virkņu objekti. Virknes objektam ir rakstzīmju kolekcija pēc kārtas, līdzīga rakstzīmju masīvam pēc kārtas. Atšķirība starp virkņu kolekciju un masīvu ir tāda, ka virkņu kolekcija var pieaugt vai samazināties. Stīgu objekts tiek veidots (konstruēts) no virkņu klases. Virknes objekts ir datu struktūra ar dalībnieku funkcijām. Dalībnieku funkcijas var klasificēt zem virsrakstiem objektu konstrukcija, elementu piekļuve, virkņu ietilpība, virkņu dalībnieku funkcijas ar iteratoru argumentiem un atgriešanās veidiem, kā arī virkņu pārveidotāji. Pastāv arī virkņu vienlīdzības un relāciju operatori.