Klasė ir objektai
Klasė - tai kintamųjų ir funkcijų, veikiančių kartu, rinkinys; kur kintamiesiems nėra priskirtos reikšmės. Kai kintamiesiems priskiriamos vertės, klasė tampa objektu. Skirtingos tos pačios klasės vertės suteikia skirtingus objektus; tai yra, skirtingi objektai yra ta pati klasė su skirtingomis vertėmis. Sakoma, kad objekto sukūrimas iš klasės yra objekto išradimas.
Pavadinimas, eilutė, yra klasė. Iš eilučių klasės sukurtas objektas turi programuotojo pasirinktą pavadinimą.
Funkcija, priklausanti klasei, reikalinga objektui iš klasės išvesti. C ++ ta funkcija turi tą patį pavadinimą kaip ir klasės pavadinimas. Iš klasės sukurti (atkurti) objektai turi skirtingus pavadinimus, kuriuos jiems suteikė programuotojas.
Sukurti objektą iš klasės reiškia objekto konstravimą; tai taip pat reiškia akimirksnį.
C ++ programa, kurioje naudojama eilutės klasė, prasideda šiomis eilutėmis failo viršuje:
#įtraukti#įtraukti
naudojant vardų srities standartą;
Pirmoji eilutė skirta įėjimui/išėjimui. Antroji eilutė - leisti programai naudoti visas styginių klasės funkcijas. Trečioji eilutė leidžia programai naudoti standartinėje vardų erdvėje esančius pavadinimus.
Funkcijos perkrovimas
Kai du ar daugiau skirtingų funkcijų parašų turi tą patį pavadinimą, sakoma, kad tas pavadinimas yra perkrautas. Kai iškviečiama viena funkcija, argumentų skaičius ir tipas nustato, kuri funkcija vykdoma.
Statyba
eilutė ()
Šis teiginys sukuria nulinio ilgio eilutę be simbolio.
Jis prasideda klasės pavadinimu (objekto tipas), eilute. Po to nurodomas programuotojo pateiktas objekto eilutės pavadinimas. Toliau paskiriamas operatorius; tada konstruktoriaus vardas su tuščiais skliausteliais. Čia „strCol“ yra momentinis objektas su visais duomenų nariais (ypatybėmis) ir narių funkcijomis (metodais).
eilutė (str)
Tai panašu į aukščiau aprašytą, tačiau konstruktoriuje kaip argumentas naudojamas eilutės literalas arba identifikatorius. Toliau pateiktas teiginys tai iliustruoja:
Konstrukcija su inicializatorių sąrašu
Toliau pateiktas kodas tai iliustruoja:
eilutė strCol=eilutė({'Aš','','','arba',„v“,'Ir','','ir','arba','tu',' 0'});Tiesioginė eilutė - aš tave myliu. Atkreipkite dėmesį į nulinį simbolį inicializatorių sąrašo pabaigoje.
eilutė (str, n)
Tai sudaro eilutės rinkinį, sudarytą iš kitos eilutės pirmųjų n simbolių. Toliau pateiktas kodas tai iliustruoja:
anglisp[] = 'Aš tave myliu';eilutė strCol=eilutė(p, 6);
kaina<<strCol<< ' n';
Rezultatas yra „Aš myliu“ su pirmaisiais 6 „Aš tave myliu“ simboliais. Atminkite: viena erdvė yra simbolis.
eilutė (str, pos, n)
Tai sudaro n simbolių eilučių rinkinį, pradedant nuo kitos eilutės nulinės indeksuotos pozicijos poz. Toliau pateiktas kodas tai iliustruoja:
anglisp[] = 'Aš tave myliu';eilutė strCol=eilutė(p, 2, 4);
kaina<<strCol<< ' n';
Rezultatas yra, meilė.
Anksčiau nurodytais atvejais, jei n yra didesnis už eilutės dydį, išimtis out_of_range išmetama - žr. Vėliau.
eilutė (n, „c“)
Sudaro n simbolių rinkinį, kuriame visi simboliai yra vienodi. Apsvarstykite,
eilutė strCol=eilutė(5,'Ir');kaina<<strCol<< ' n';
Rezultatas yra, eeeee, 5 e.
Stygos priskyrimas
Eilutę galima priskirti taip, paskelbus abi eilutes:
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2;
strCol2=strCol1;
kaina<<strCol2<< ' n';
Rezultatas - aš tave myliu.
Konstrukcija naudojant „Iterator“
Iteratorius pateikia bendrą nuskaitymo vaizdą per kolekcijos vertes. Sintaksė, skirta sukurti eilutę su iteratoriumi, yra tokia:
šabloną<klasės „InputIterator“>basic_string(Pradėkite „InputIterator“,„InputIterator“ pabaiga, konstSkirstytuvas&
į=Skirstytuvas());
Taip sukuriama diapazono [pradžia, pabaiga] eilutė - daugiau informacijos rasite vėliau.
Stygos sunaikinimas
Norėdami sunaikinti eilutę, tiesiog leiskite jai išeiti iš taikymo srities.
Prieiga prie styginių klasės elementų
Momentinis eilutės objektas gali būti subkomponuotas (indeksuotas) kaip masyvas. Indekso skaičiavimas prasideda nuo nulio.
stringName [i]
Operacija stringName [i] grąžina nuorodą į simbolį (elementą) itūkstsimbolių kolekcijos rodyklė. Šie kodo išėjimai v:
eilutė strCol=eilutė('Aš tave myliu');anglisch=strCol[4];
kaina<<ch<< ' n';
stringName [i] konst
Operacija stringName [i] const vykdoma vietoj stringName [i], kai eilutės objektas yra pastovus objektas. Pavyzdžiui, jis naudojamas šiame kode:
konsteilutė strCol=eilutė('Aš tave myliu');anglisch=strCol[4];
kaina<<ch<< ' n';
Išraiška grąžina nuolatinę nuorodą į itūksteilutės objekto elementas. Nė vienas iš eilutės elementų negali būti pakeistas.
Simbolio priskyrimas indeksui
Simbolį galima priskirti nekintamam eilutės objektui taip:
eilutė strCol=eilutė('Aš skambinu');strCol[2] = „f“;
kaina<<strCol<< ' n';
Rezultatas yra I rudenį. „C“ buvo pakeistas į „f“.
stringName.at (i)
stringName.at (i) yra panašus į stringName [i], tačiau stringName.at (i) yra patikimesnis. Šis kodas parodo, kaip jis turėtų būti naudojamas:
eilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.adresu(4);
kaina<<ch<< ' n';
at () iš tikrųjų yra eilutės klasės nario funkcija.
stringName.at (i) const
stringName.at (i) const yra panašus į stringName [i] const, bet stringName.at (i) const yra patikimesnis. stringName.at (i) const vykdomas vietoj stringName.at (i), kai eilutės objektas yra pastovus eilutės objektas. Jis naudojamas šiame kode, pavyzdžiui:
konsteilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.adresu(4);
kaina<<ch<< ' n';
at () const iš tikrųjų yra eilutės klasės nario funkcija.
Vertės priskyrimas funkcijai at ()
Vertę galima priskirti nekintamam eilutės objektui, naudojant funkciją at (), taip:
eilutė strCol=eilutė('Aš skambinu');strCol.adresu(2) = „f“;
kaina<<strCol<< ' n';
Rezultatas yra I rudenį.
Problema su papildomu scenarijumi
Antrinio scenarijaus (indeksavimo) problema yra ta, kad jei indeksas yra už diapazono ribų, gali būti gautas neteisingas rezultatas arba vykdymo metu gali būti pateikta klaida.
priekis ()
Tai grąžina nuorodą į pirmąjį eilutės objekto elementą, nepašalinus elemento. Šio kodo išvestis yra „aš“.
eilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.priekyje();
kaina<<ch<< ' n';
Simbolis nepašalinamas iš eilutės objekto.
priekis () konst
Kai prieš eilutės objekto konstrukciją yra const, vietoj front () vykdoma išraiška front () const. Pavyzdžiui, jis naudojamas šiame kode.
konsteilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.priekyje();
kaina<<ch<< ' n';
Pateikiama nuolatinė nuoroda. Elementas nepašalinamas iš eilutės objekto. Nuolatinės eilutės objekto simbolio negalima pakeisti.
atgal ()
Tai grąžina nuorodą į paskutinį eilutės objekto elementą, nepašalinus elemento. Šio kodo išvestis yra „u“.
eilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.atgal();
kaina<<ch<< ' n';
atgal () konst
Kai prieš eilutės objekto konstrukciją yra konst, išraiška back () const vykdoma vietoj back (). Pavyzdžiui, jis naudojamas šiame kode.
konsteilutė strCol=eilutė('Aš tave myliu');anglisch=strCol.atgal();
kaina<<ch<< ' n';
Pateikiama nuolatinė nuoroda. Elementas nepašalinamas iš eilutės objekto.
Eilutės talpa
size_type capacity () const noexcept
Visą simbolių skaičių, kurį eilutė gali turėti nereikalaujant perskirstymo, grąžina ši pajėgumo nario funkcija. Tam skirtas kodo segmentas:
eilutė strCol=eilutė();tarptant vieno=strCol.talpa();
kaina<<ant vieno<< ' n';
Mano kompiuterio išvestis yra 15.
rezervas (n)
Nemokamoje parduotuvėje ne visada yra vietos atmintyje. Papildomą vietą galima rezervuoti iš anksto. Apsvarstykite šį kodo segmentą:
eilutė strCol=eilutė('meilė');strCol.rezervas(6);
kaina<<strCol.talpa() << ' n';
Mano kompiuterio išvestis yra 15.
size () const noexcept
Tai grąžina simbolių skaičių eilutėje. Šis kodas iliustruoja:
eilutė strCol=eilutė('Aš tave myliu');tarptant vieno=strCol.dydžio();
kaina<<ant vieno<< ' n';
Išvestis yra 10, kurioje nėra nulinio, 0 simbolio.
length () const noexcept
-toks pat kaip ir dydis().Pastaba:dydžio() <=talpa().
Sumažinti, kad tilptų()
Gali sumažinti pajėgumus () iki dydžio () sukeldamas perskirstymą; tai neprivaloma. Toliau pateiktas kodas tai parodo:
eilutė strCol=eilutė('Aš tave myliu');strCol.rezervas(12);
strCol.Sumažinti, kad tilptų();
tarpts=strCol.dydžio();
kaina<<s<< ' n';
Išvestis yra 10, o ne 12 ar 16. Funkcija grąžina tuščią.
keisti dydį (sz), keisti dydį (sz, 'c')
Tai pakeičia eilutės dydį. Jei naujas dydis yra mažesnis nei senas, tada pabaigos elementai ištrinami. Jei naujas dydis yra ilgesnis, pabaigoje pridedamas numatytasis simbolis. Jei norite pridėti tam tikrą simbolį, naudokite funkciją resize () su dviem argumentais. Šis kodo segmentas iliustruoja dviejų funkcijų naudojimą:
eilutė strCol=eilutė('Aš tave myliu');strCol.pakeisti dydį(6);
kaina<< 'Naujas' strCol 'dydis:' <<strCol.dydžio() << ' n';
eilutė strCol1=eilutė('Myliu', 'Ir');
strCol1.pakeisti dydį(12);
kaina<< „Naujas„ strCol1 “dydis:“ <<strCol1.dydžio() << ' n';
Išėjimas yra:
Naujas „strCol“ dydis: 6Naujas strCol1: 12 dydis
Funkcija grąžina tuščią.
aišku () išimtis
Pašalina visus eilutės elementus, kaip parodyta šiame kodo segmente:
eilutė strCol=eilutė('Aš tave myliu');strCol.aišku();
kaina<<strCol.dydžio() << ' n';
Išvestis yra 0. Funkcija grąžina tuščią.
empty () const noexcept
Tai grąžina 1, jei tiesa, jei eilutės objekte nėra simbolio, arba 0, jei klaidingas, jei eilutės objektas nėra tuščias. Toliau pateiktas kodas tai iliustruoja:
eilutė strCol1=eilutė('Aš tave myliu');kaina<<strCol1.tuščia() << ' n';
eilutė strCol2=eilutė();
kaina<<strCol2.tuščia() << ' n';
Išėjimas yra:
01
Grįžtantys kartotojai ir styginių klasė
Iteratorius yra kaip rodyklė, tačiau turi daugiau funkcijų nei rodyklė.
begin () noexcept
Grąžina iteratorių, kuris nurodo į pirmąjį eilutės objekto simbolį (elementą), kaip nurodyta šiame kodo segmente:
eilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::iteratoriusiter=strCol.pradėti();
kaina<< *iter<< ' n';
Rezultatas yra „aš“. Atkreipkite dėmesį į tai, kaip buvo deklaruota iteratorių gaunanti deklaracija. Iteratoriui nurodoma grįžtamoji išraiška, norint gauti vertę taip pat, kaip ir žymeklio nuoroda.
begin () const noexcept;
Grąžina iteratorių, kuris nurodo į pirmąjį eilutės objektų rinkinio elementą. Kai prieš objekto konstrukciją yra const, vietoj begin () vykdoma išraiška begin () const. Esant tokioms sąlygoms, atitinkamo objekto elemento negalima keisti. Pavyzdžiui, jis naudojamas šiame kode.
konsteilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::const_iteratoriter=strCol.pradėti();
kaina<< *iter<< ' n';
Rezultatas yra „aš“. Atminkite, kad grąžintam iteratoriui gauti šį kartą buvo naudojamas „const_iterator“, o ne tik iteratorius.
end () noexcept
Grąžina iteratorių, nurodantį iškart už paskutinio eilutės objekto elemento. Apsvarstykite šį kodo segmentą:
eilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::iteratoriusiter=strCol.galas();
kaina<< *iter<< ' n';
Išvestis yra nulinė, o tai nieko, nes nėra konkretaus elemento už paskutinio elemento.
end () const noexcept
Grąžina iteratorių, nurodantį iškart už paskutinio eilutės objekto elemento. Kai prieš eilutės objekto konstrukciją rašoma const, vietoj end () vykdoma išraiška end () const. Apsvarstykite šį kodo segmentą:
konsteilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::const_iteratoriter=strCol.galas();
kaina<< *iter<< ' n';
Išėjimas yra nulinis. Atminkite, kad grąžintam iteratoriui gauti šį kartą buvo naudojamas „const_iterator“, o ne tik iteratorius.
Atvirkštinis kartojimas
Galima turėti iteratorių, kuris kartojasi nuo faktinio pabaigos iki pat pirmojo elemento:
rbegin () išimtis
Grąžina iteratorių, kuris nurodo į paskutinį eilutės pavyzdžio objekto elementą, kaip nurodyta šiame kodo segmente:
eilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::reverse_iteratoriter=strCol.rbegin();
kaina<< *iter<< ' n';
Išvestis yra „u“. Atkreipkite dėmesį į tai, kaip buvo deklaruota deklaracija, kuri gauna atvirkštinį iteratorių. Iteratoriui nurodoma grįžtamoji išraiška, norint gauti vertę taip pat, kaip ir žymeklio nuoroda.
rbegin () const noexcept;
Grąžina iteratorių, nurodantį paskutinį eilutės objekto elementą. Kai prieš objekto konstrukciją rašoma const, vietoj rbegin () vykdoma išraiška rbegin () const. Esant tokioms sąlygoms, atitinkamo objekto elemento negalima keisti. Ši funkcija naudojama, pavyzdžiui, šiame kode.
konsteilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::const_reverse_iteratoriter=strCol.rbegin();
kaina<< *iter<< ' n';
Išvestis yra „u“. Atminkite, kad grąžintam iteratoriui gauti šį kartą buvo naudojamas „const_reverse_iterator“, o ne tik „reverse_iterator“.
render () noexcept
Grąžina iteratorių, kuris nurodo prieš pat pirmąjį eilutės objekto elementą. Apsvarstykite šį kodo segmentą:
eilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::reverse_iteratoriter=strCol.daro();
kaina<< *iter<< ' n';
Išvestis yra nulinė, o tai nieko, nes prieš pat pirmąjį elementą nėra konkretaus elemento.
render () const noexcept
Grąžina iteratorių, kuris nurodo prieš pat pirmąjį eilutės objekto elementą. Kai prieš objekto konstrukciją rašoma const, vietoj rend () vykdoma išraiška rend () const. Apsvarstykite šį kodo segmentą:
konsteilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::const_reverse_iteratoriter=strCol.daro();
kaina<< *iter<< ' n';
Išėjimas yra nulinis. Atminkite, kad grąžintam iteratoriui gauti šį kartą buvo naudojamas „const_reverse_iterator“, o ne tik „reverse_iterator“.
Styginių modifikatoriai
Modifikatorius, modifikuojantis eilutės objektą, taip pat gali paimti arba grąžinti iteratorių.
Pridedama
basic_string&operatorius+ =(konstbasic_string&p)Prideda dešinįjį eilutės objektą prie kairiojo eilutės objekto. Pavyzdys:
eilutė strCol1=eilutė('Myliu');eilutė strCol2=eilutė(' tu');
strCol1+ =strCol2;
kaina<<strCol1<< ' n';
Rezultatas - aš tave myliu. Nepamirškite, kad strCol1 += strCol2 yra toks pat kaip strCol1 = strCol1 +strCol2.
basic_string & operatorius+= (const charT* s)
Prie eilutės objektų kolekcijos prideda eilutę. Pavyzdys:
eilutė strCol=eilutė('Myliu');strCol+ = ' tu';
kaina<<strCol<< ' n';
Išvada: aš tave myliu.
pagrindinė eilutė ir operatorius+= (charT c)
Prideda vieną simbolį prie objekto eilutės. Pavyzdys:
eilutė strCol=eilutė('Aš tave myliu');strCol+ = 'tu';
kaina<<strCol<< ' n';
Išvada: aš tave myliu.
pagrindinė eilutė ir operatorius+= (inicializatoriaus_raštis)
Pridedamas inicializatorių sąrašas. Pavyzdys:
eilutė strCol=eilutė('Myliu');strCol+ = {'','ir','arba','tu',' 0'};
kaina<<strCol<< ' n';
Išvada: aš tave myliu. Visada gerai simbolių inicijavimo sąrašo pabaigoje pridėti nulį, 0.
basic_string & append (const basic_string & str)
Prideda argumentų eilutės objektą prie pagrindinio eilutės objekto. Pavyzdys:
eilutė strCol1=eilutė('Myliu');eilutė strCol2=eilutė(' tu');
strCol1.pridėti(strCol2);
kaina<<strCol1<< ' n';
Išvada: aš tave myliu.
basic_string & append (const charT* s)
Prie pagrindinės eilutės prideda tiesioginį eilutės argumentą. Pavyzdys
eilutė strCol=eilutė('Myliu');strCol=strCol.pridėti(' tu');
kaina<<strCol<< ' n';
Išvada: aš tave myliu.
basic_string & addend (inicializatoriaus_raštis)
Prideda inicializatorių sąrašą, kuris yra argumentas, prie pagrindinės eilutės. Pavyzdys:
eilutė strCol=eilutė('Myliu');strCol=strCol.pridėti({'','ir','arba','tu',' 0'});
kaina<<strCol<< ' n';
Išvada: aš tave myliu. Iniciatorių sąrašo pabaigoje visada naudinga pridėti nulį, 0 simbolį.
basic_string & addend (dydžio_ tipas n, charT c)
Prideda to paties simbolio n. Pavyzdys:
eilutė strCol=eilutė(„skirtukas“);strCol=strCol.pridėti(2, 'arba');
kaina<<strCol<< ' n';
Rezultatas: tabu.
basic_string & append (const charT* s, size_type n)
Prie pagrindinio eilutės objekto pridedami pirmieji n eilutės literalo elementai. Pavyzdys:
eilutė strCol=eilutė('Myliu');strCol=strCol.pridėti(' tu taip pat', 4);
kaina<<strCol<< ' n';
Rezultatas: aš tave myliu. Jei n yra didesnis už literalo ilgį, išmetama ilgio klaidos išimtis.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Prie pagrindinės eilutės prideda n simbolių iš indekso, poz. Pavyzdys:
eilutė strCol=eilutė('Myliu');strCol=strCol.pridėti('ar tu toks', 2, 4);
kaina<<strCol<< ' n';
Išvada: aš tave myliu. Čia taip pat būtų išmesta išimtis, žr. Vėliau.
Priskyrimas
basic_string&priskirti(konstbasic_string&p)Priskiria argumento eilutės objektą pagrindinei eilutei, pakeisdamas bet kokį turinį.
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2=eilutė('Jai reikia manęs');
strCol1=strCol1.priskirti(strCol2);
kaina<<strCol1<< ' n';
Išvada: jai reikia manęs.
basic_string&priskirti(konstcharT*s)Pagrindinei eilutei priskiriamas tiesioginis eilutės argumentas, pakeičiant bet kokį turinį.
eilutė strCol=eilutė('Aš tave myliu');strCol=strCol.priskirti('Jai reikia manęs');
kaina<<strCol<< ' n';
Išvada: jai reikia manęs.
basic_string&priskirti(Initial_list<charT>)Priskiria inicializatorių sąrašo argumentą pagrindinei eilutei,pakeisti bet kokį turinį.
[cc lang=„c“pabėgo='tiesa'pločio=„780“]
eilutė strCol=eilutė('Aš tave myliu');
strCol=strCol.priskirti({„S“,'h','Ir','',„n“,'Ir','Ir',„d“,'s','',„aš“,'Ir',' 0'});
kaina<<strCol<< ' n';
Išvada: jai reikia manęs. Gerai visada simbolių sąrašo pabaigoje pridėti nulį, 0, kad sudarytumėte eilutės literalą.
basic_string&priskirti(konstcharT*s,dydis_ tipas n)Priskiria pirmuosius n simbolių eilutinio argumento pagrindinei eilutei, pakeisdamas bet kokį turinį.
eilutė strCol=eilutė('Aš tave myliu');strCol=strCol.priskirti('Jai reikia manęs', 9);
kaina<<strCol<< ' n';
Išvada: jai reikia.
basic_string&priskirti(dydis_ tipas n,charC c)Pagrindinei eilutei priskiria tų pačių simbolių n argumentą, pakeičiant bet kokį turinį.
eilutė strCol=eilutė('Aš tave myliu');strCol=strCol.priskirti(4, 'Ir');
kaina<<strCol<< ' n';
Išėjimas: eeee
basic_string&priskirti(konstbasic_string&p,size_type poz,dydis_ tipas n=npos)
Priskiria n simbolių eilutės objekto argumentui, pradedant nuo pos, pagrindinei eilutei, pakeičiant bet kokį turinį.
eilutė strCol=eilutė('Aš tave myliu');strCol=strCol.priskirti('Jai reikia manęs', 4, 5);
kaina<<strCol<< ' n';
Išėjimas: poreikiai. Išmestų išimtį - žiūrėkite vėliau.
Įterpimas
basic_string&Įdėti(size_type poz, konstbasic_string&p)Įterpia eilutės objekto argumentą į pagrindinę eilutę, rodyklėje, poz.
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2=eilutė('nekenčiu ir');
strCol1=strCol1.Įdėti(2,strCol2);
kaina<<strCol1<< ' n';
Išvada: aš tavęs nekenčiu ir myliu. Išmestų išimtį - žiūrėkite vėliau.
basic_string&Įdėti(size_type poz1, konstbasic_string&p,size_type pos2,dydis_ tipas n=npos)
Įterpia n simbolių ilgį iš eilutės objekto argumento pos2 į pagrindinę eilutę, esantį indekse, poz1.
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2=eilutė('nekenčiu, noriu ir reikia');
strCol1=strCol1.Įdėti(2,strCol2, 6, 9);
kaina<<strCol1<< ' n';
Išvada: Aš noriu ir myliu tave.
iteratoriaus intarpas (const_iterator p, charT c)
Įterpia tam tikrą simbolį, kuris yra argumentas, į iteratoriaus nurodytą poziciją. Grąžina naujai įterpto simbolio padėties iteratorių.
eilutė strCol=eilutė('Aš tave myliu');basic_string<anglis> ::iteratoriusiter=strCol.pradėti();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
basic_string<anglis> ::iteratoriustinklas=strCol.Įdėti(iter, „d“);
kaina<< *tinklas<< ' n';
kaina<<strCol<< ' n';
Išėjimas yra:
„D“
aš mylėjau tave
iteratoriaus intarpas (const_iterator p, size_type n, charT c)
To paties argumento pobūdžio n įterpia į iteratoriaus nurodytą poziciją. Grąžina naujai įterptų simbolių pradžios vietos iteratorių.
eilutė strCol=eilutė(„Skirtukas žemėje“.);basic_string<anglis> ::iteratoriusiter=strCol.pradėti();
++iter; ++iter; ++iter;
basic_string<anglis> ::iteratoriustinklas=strCol.Įdėti(iter, 2, 'arba');
kaina<< *tinklas<< ' n';
kaina<<strCol<< ' n';
Išėjimas yra:
'arba'
Tabu žemėje.
basic_string&Įdėti(size_type poz, konstcharT*s)Įtraukia argumento eilutės literalą į indeksą, poz į pagrindinę eilutę.
eilutė strCol=eilutė(„Skirtukas žemėje“.);strCol=strCol.Įdėti(3, 'oo');
kaina<<strCol<< ' n';
Rezultatas: Tabu žemėje.
basic_string&Įdėti(size_type poz, konstcharT*s,dydis_ tipas n)Įterpia pirmuosius n simbolių argumento eilutės pažodžiui, prie rodyklės, poz pagrindinėje eilutėje.
eilutė strCol=eilutė(„Skirtukas žemėje“.);strCol=strCol.Įdėti(3, 'oooo', 2);
kaina<<strCol<< ' n';
Rezultatas: Tabu žemėje.
Pakeičiamas
basic_string&pakeisti(size_type poz1,dydis_ tipas n1, konstbasic_string&p))Pakeičia n1 simbolį pagrindiniame eilutės objekte iš indekso, pos1, argumento eilutės objektu.
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2=eilutė('nekenčiu tavęs ir');
strCol1=strCol1.pakeisti(2, 4,strCol2);
kaina<<strCol1<< ' n';
Išvada: nekenčiu tavęs ir tavęs. Išmestų išimtį - žiūrėkite vėliau.
basic_string&pakeisti(size_type poz1,dydis_ tipas n1, konstbasic_string&p,size_type pos2,dydis_ tipas n2=npos)
Pakeičia n1 simbolius pagrindiniame eilutės objekte iš indekso, pos1, su n2 simbolių argumento eilutės objekto iš indekso, pos2.
eilutė strCol1=eilutė('Aš tave myliu');eilutė strCol2=eilutė('mes nekenčiame jo ir jos');
strCol1=strCol1.pakeisti(2, 4,strCol2, 3, 12);
kaina<<strCol1<< ' n';
Išvada: nekenčiu jo ir tavęs.
basic_string&pakeisti(size_type poz1,dydis_ tipas n1, konstcharT*s,dydis_ tipas n2)
Pakeičia n1 simbolius pagrindiniame eilutės objekte iš indekso, pos1, pirmaisiais n2 simboliais iš pažodinės eilutės argumento.
eilutė strCol1=eilutė('Aš tave myliu');strCol1=strCol1.pakeisti(2, 4, 'nekenčiu jo ir jos', 12);
kaina<<strCol1<< ' n';
Išvada: nekenčiu jo ir tavęs.
basic_string & pakeisti (size_type pos, size_type n, const charT* s)
Pakeičia n simbolius pagrindiniame eilutės objekte iš indekso, poz, pažodinės eilutės argumentu.
eilutė strCol1=eilutė('Aš tave myliu');strCol1=strCol1.pakeisti(2, 4, 'nekenčiu jo ir');
kaina<<strCol1<< ' n';
Išvada: nekenčiu jo ir tavęs.
basic_string&pakeisti(size_type poz1,dydis_ tipas n1,dydis_ tipas n2,charC c)Pakeičia n1 simbolius pagrindiniame eilutės objekte iš indekso, pos1, to paties argumento simbolio n2.
eilutė strCol1=eilutė(„Ten bloga planšetė“.);strCol1=strCol1.pakeisti(9, 3, 2, 'arba');
kaina<<strCol1<< ' n';
Išvada: ten blogas tabu ..
iteratoriaus ištrynimas (const_iterator p)
Pašalina simbolį toje vietoje, kurią nurodo iteratorius; tada grąžina iteratoriaus poziciją, kurią dabar užima simbolis, buvęs šalia šio simbolio (arba pabaigos ()). Toliau pateiktas kodas tai iliustruoja:
eilutė strCol=eilutė(„abcd“);basic_string<anglis> ::iteratoriusiter=strCol.pradėti();
++iter; ++iter;
strCol.ištrinti(iter);
kaina<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Išėjimas: a b d
basic_string&ištrinti(size_type poz= 0,dydis_ tipas n=npos)Pašalina n simbolių iš rodyklės, poz.
eilutė strCol=eilutė(„abcd“);strCol.ištrinti(1, 2);
kaina<<strCol[0] << '' <<strCol[1] << ' n';
Išėjimas: a d
void push_back (charT c)
Norėdami pridėti vieną simbolį eilutės pabaigoje:
eilutė strCol=eilutė(„abcd“);strCol.pastumti atgal(„5“);
kaina<<strCol<< ' n';
Išvestis: abcd5
void pop_back ()
Pašalina paskutinį simbolį jo negrąžindamas. Eilutės dydis sumažinamas 1.
eilutė strCol=eilutė('a B C D E');strCol.pop_back();
kaina<<strCol<< ' n';
Išvestis: abcd
negaliojantis apsikeitimas (pagrindinės eilutės ir eilutės)
Dviejų styginių objektų literatai gali būti keičiami.
eilutė strCol1=eilutė(<id='post-69618 -__ DdeLink__781_3724385525'>į>'a B C D E');eilutė strCol2=eilutė(„1234567“);
strCol1.apsikeisti(strCol2);
kaina<<strCol1<< ' n';
kaina<<strCol2<< ' n';
Išėjimas yra:
„1234567“'a B C D E'
Styginių operacijos
const charT* c_str () const noexcept
Grąžina žymeklį į pirmąjį eilutės elementą. Rodyklę galima padidinti.
konsteilutė strCol=eilutė('a B C D E');konst anglis*p=strCol.c_str();
kaina<< *p<< ' n';
++p;
kaina<< *p<< ' n';
Išėjimas yra:
įb
Dėl antrosios antraštės konstantos programa negali pakeisti jokių eilutės simbolių. Prieš konstrukciją yra konst.
const charT* duomenys () const noexcept
Grąžina žymeklį į pirmąjį eilutės elementą. Rodyklę galima padidinti.
konsteilutė strCol=eilutė('a B C D E');konst anglis*p=strCol.duomenis();
kaina<< *p<< ' n';
++p;
kaina<< *p<< ' n';
Išėjimas yra:
įb
Dėl antrosios antraštės konstantos programa negali pakeisti jokių eilutės simbolių. Prieš konstrukciją yra konst.
basic_string substr (size_type pos = 0, size_type n = npos) const
Grąžina eilutės objektą, sudarytą iš n simbolių, esančių antrinėje eilutėje, prasidedančioje nuo indekso, poz.
konsteilutė strCol=eilutė('abcdefghij');konsteilutė retStr=strCol.substr(2, 4);
kaina<<retStr<< ' n';
Išėjimas: cdef
rasti () nario funkcijas
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Ieškomas antrinės eilutės objektas, prasidedantis nuo rodyklės, poz. Jei randama, grąžina pagrindinės eilutės antrinės eilutės pradžią.
eilutė strCol=eilutė('Mes esame pasaulis!');eilutė strCol1=eilutė('');
tarptant vieno=strCol.rasti(strCol1, 2);
kaina<<ant vieno<< ' n';
Išėjimas:
indeksas: 7Grąžina -1, kai nerasta.
size_type find (const charT* s, size_type pos = 0) const
Ieškoma antrinės eilutės literato, prasidedančio nuo indekso, poz. Jei randama, grąžina pagrindinės eilutės antrinės eilutės pradžią.
eilutė strCol=eilutė('Mes esame pasaulis!');tarptant vieno=strCol.rasti('yra', 0);
kaina<<ant vieno<< ' n';
Kadangi pos = 0 yra numatytasis, argumentas 0 galėjo būti praleistas.
Išėjimas: 3
Grąžina -1, kai nerasta.
size_type find (const charT* s, size_type pos, size_type n) const
Ieškoma pirmųjų n simbolių antrinės eilutės literale, prasidedančiame indekse, poz. Jei randama, grąžina pagrindinės eilutės antrinės eilutės pradžią.
eilutė strCol=eilutė(„Didžiausias berniukas“);tarptant vieno=strCol.rasti('didesnis', 1, 3);
kaina<<ant vieno<< ' n';
Išėjimas: 4
Grąžina -1, kai nerasta.
size_type find (charT c, size_type pos = 0) const
Ieško simbolio, c prasideda nuo rodyklės, poz. Jei randama, grąžina pagrindinės eilutės antrinės eilutės pradžią. Jei nerandama, grąžina -1.
eilutė strCol=eilutė('Mes esame pasaulis!');tarptant vieno=strCol.rasti('Su');
kaina<<ant vieno<< ' n';
Išėjimas: -1
Yra šios atvirkštinio paieškos () nario funkcijos:
size_type rfind(konstbasic_string&p,size_type poz=npos) konstisskyrus;size_type rfind(konstcharT*s,size_type poz=npos) konst;
size_type rfind(konstcharT*s,size_type poz,dydis_ tipas n) konst;
size_type rfind(charC c,size_type poz=npos) konst;
Narių funkcijų palyginimas
int palyginti (const basic_string & str) const noexcept
Palygina argumentų eilutės objektą su pagrindiniu eilutės objektu. Jei pagrindinė eilutė atsiranda prieš argumentą (žodyne), jis grąžina teigiamą skaičių. Jei jis atsiranda po pagrindinės eilutės, jis grąžina neigiamą skaičių. Jei abi eilutės yra vienodos, tai grąžina nulį.
eilutė strCol1=eilutė('minia');eilutė strCol2=eilutė('žmonės');
tarptant vieno=strCol1.palyginti(strCol2);
kaina<<ant vieno<< ' n';
Išėjimas: -13
int palyginti (const charT* s) const
Tas pats, kas aukščiau, bet argumentas yra eilutės pažodinis.
eilutė strCol1=eilutė('žmonės');tarptant vieno=strCol1.palyginti('žmonės');
kaina<<ant vieno<< ' n';
Išėjimas: 0
Styginių operatoriai
Šie operatoriai taikomi eilutės objektams, o nebūtinai - eilutės literalams.
+
Sujungia du eilutės objektus ir grąžina sujungimą.
eilutė strCol1=eilutė('šoka');eilutė strCol2=eilutė(' Mėnulis');
eilutė strCol=strCol1+strCol2;
kaina<<strCol<< ' n';
Rezultatas: šokiai Mėnulyje.
==
Grąžina 1 tiesą, jei eilutės objektai yra vienodi; ir nulis už klaidingą, jei jų nėra.
eilutė strCol1=eilutė('šoka');eilutė strCol2=eilutė(' Mėnulyje');
bool bl=strCol1==strCol2;
kaina<<bl<< ' n';
Išėjimas: 0
! =
Grąžina 1, jei eilutės objektai nėra vienodi, ir nulį, jei jie yra.
eilutė strCol1=eilutė('šoka');eilutė strCol2=eilutė(' Mėnulyje');
bool bl=strCol1! =strCol2;
kaina<<bl<< ' n';
Išėjimas: 1
<
Grąžina 1, jei kairysis operandas pagal žodyną yra mažesnis už dešinįjį, arba nulis, jei ne.
eilutė strCol1=eilutė('šoka');eilutė strCol2=eilutė(' Mėnulyje');
bool bl=strCol1<strCol2;
kaina<<bl<< ' n';
Išėjimas: 0
Paprastiems simboliams C ++ didėjančia tvarka skaičiai pateikiami prieš didžiąsias raides, o prieš mažąsias raides. Erdvės simbolis yra prieš nulį ir visi jie.
C ++ pagrindinių eilučių simbolių tipai
anglis
„Char“ tipas yra originalus C ++ tipas ir paprastai saugo simbolį 8 bitais.
char16_t
Tai išsaugo simbolį 16 bitų.
char32_t
Tai išsaugo simbolį 32 bitais.
wchar_t
char16_t ir char32_t yra platūs simboliai. „wchar_t“ yra plataus pobūdžio simbolis, priklausantis nuosavybei ir apibrėžtas įgyvendinimui.
Šios rūšys vadinamos savybėmis. Tačiau C ++ jas techniškai vadina bruožų specializacijomis. Šiame straipsnyje daugiausia dėmesio buvo skiriama anglies tipui. Kitų tipų požiūris šiek tiek skiriasi - žr. Vėliau.
Kitos eilutės operacijos nario funkcijos
Kitų eilutės operacijų funkcijų parašai yra šie:
size_type find_first_of(konstbasic_string&p,size_type poz= 0) konstisskyrus;size_type find_first_of(konstcharT*s,size_type poz,dydis_ tipas n) konst;
size_type find_first_of(konstcharT*s,size_type poz= 0) konst;
size_type find_first_of(charC c,size_type poz= 0) konst;
size_type find_last_of(konstbasic_string&p,size_type poz=npos) konstisskyrus;
size_type find_last_of(konstcharT*s,size_type poz,dydis_ tipas n) konst;
size_type find_last_of(konstcharT*s,size_type poz=npos) konst;
size_type find_last_of(charC c,size_type poz=npos) konst;
size_type find_first_not_of(konstbasic_string&p,size_type poz= 0) konstisskyrus;
size_type find_first_not_of(konstcharT*s,size_type poz,dydis_ tipas n) konst;
size_type find_first_not_of(konstcharT*s,size_type poz= 0) konst;
size_type find_first_not_of(charC c,size_type poz= 0) konst;
size_type find_last_not_of(konstbasic_string&p,size_type poz=npos) konstisskyrus;
size_type find_last_not_of(konstcharT*s,size_type poz,dydis_ tipas n) konst;
size_type find_last_not_of(konstcharT*s,size_type poz=npos) konst;
size_type find_last_not_of(charC c,size_type poz=npos) konst;
Išvada
„C ++“ turi eilutės literatūrą ir eilutės objektus. Eilutės objekte yra simbolių rinkinys iš eilės, panašus į eilės simbolių masyvą. Skirtumas tarp stygų rinkinio ir masyvo yra tas, kad eilutės gali išaugti arba susitraukti. Styginių objektas yra sukurtas (sukonstruotas) iš eilutės klasės. Eilutės objektas yra duomenų struktūra su nario funkcijomis. Narių funkcijos gali būti klasifikuojamos pagal objektų konstrukcijos, prieigos prie elementų, eilutės talpos, eilutės narių funkcijas su iteratoriaus argumentais ir grąžinimo tipais bei eilutės modifikatorius. Taip pat egzistuoja styginių lygybės ir santykių operatoriai.