Clasa și obiecte
O clasă este un set de variabile și funcții care funcționează împreună; unde variabilele nu au valori atribuite. Când valorile sunt atribuite variabilelor, clasa devine un obiect. Valori diferite date aceleiași clase rezultă în obiecte diferite; adică diferite obiecte sunt aceeași clasă cu valori diferite. Se spune că crearea unui obiect dintr-o clasă este instanțierea obiectului.
Numele, șirul, este o clasă. Un obiect creat din clasa de șiruri are un nume ales de programator.
O funcție care aparține clasei este necesară pentru a crea un obiect din clasă. În C ++, acea funcție are același nume ca și numele clasei. Obiectele create (instanțiate) din clasă au nume diferite date de către programator.
Crearea unui obiect dintr-o clasă înseamnă construirea obiectului; înseamnă și instanțierea.
Un program C ++ care folosește clasa string, începe cu următoarele linii în partea de sus a fișierului:
#include#include
folosind spațiul de nume std;
Prima linie este pentru intrare / ieșire. A doua linie este de a permite programului să utilizeze toate caracteristicile clasei de șiruri. A treia linie permite programului să utilizeze numele din spațiul de nume standard.
Supraîncărcarea unei funcții
Când două sau mai multe semnături de funcții diferite au același nume, se spune că acel nume este suprasolicitat. Când se apelează o funcție, numărul și tipul argumentelor, determinați ce funcție este executată.
Constructie
şir()
Instrucțiunea următoare construiește un șir de lungime zero, fără caracter.
Începe cu numele clasei (tip de obiect), șir. Acesta este urmat de numele șirului de obiecte, dat de programator. Urmează operatorul de atribuire; apoi numele constructorului cu paranteze goale. Aici, strCol este obiectul instanțiat cu toți membrii de date (proprietăți) și funcțiile de membru (metode).
șir (str)
Acest lucru este similar cu cele de mai sus, dar ia fie un literal șir sau un identificator ca argument, în constructor. Următoarea afirmație ilustrează acest lucru:
Construcție cu Listă inițializatoare
Următorul cod ilustrează acest lucru:
string strCol=şir({„Eu”,'',„cel”,'sau',„v”,'Și','','și','sau',tu,' 0'});Șirul literal este că te iubesc. Rețineți caracterul nul la sfârșitul listei de inițializatoare.
șir (str, n)
Aceasta formează o colecție de șiruri, din primele n caractere ale altui șir. Următorul cod ilustrează acest lucru:
charstr[] = 'Te iubesc';string strCol=şir(str, 6);
cost<<strCol<< ' n';
Rezultatul este I love with the first 6 characters from I love you. Amintiți-vă: spațiul unic este un personaj.
șir (str, pos, n)
Aceasta formează o colecție de șiruri de n caractere, începând de la poziția indexată zero, poz, a unui alt șir. Următorul cod ilustrează acest lucru:
charstr[] = 'Te iubesc';string strCol=şir(str, 2, 4);
cost<<strCol<< ' n';
Rezultatul este, dragoste.
Pentru cele două cazuri de mai sus, dacă n este mai mare decât dimensiunea șirului, se aruncă excepția out_of_range - vezi mai târziu.
șir (n, „c”)
Formează o colecție de n caractere, în care toate personajele sunt la fel. Considera,
string strCol=şir(5,'Și');cost<<strCol<< ' n';
Rezultatul este, eeeee, 5 e’s.
Atribuirea unui șir
Un șir poate fi atribuit după cum urmează, după ce a declarat ambele șiruri:
string strCol1=şir('Te iubesc');șir strCol2;
strCol2=strCol1;
cost<<strCol2<< ' n';
Rezultatul este că te iubesc.
Construirea cu Iterator
Un iterator oferă o reprezentare generică a scanării, prin valorile unei colecții. O sintaxă pentru a crea un șir cu iterator este:
șablon<clasa InputIterator>șir_de bază(InputIterator începe,InputIterator end, constAlocator&
la=Alocator());
Aceasta construiește un șir pentru intervalul [begin, end) - vezi detaliile mai târziu.
Distrugerea unui șir
Pentru a distruge un șir, lăsați-l să iasă din sfera de aplicare.
Acces la element de clasă șir
Un obiect șir instanțiat poate fi sub-scriptat (indexat) ca un tablou. Numărarea indexului începe de la zero.
stringName [i]
Operațiunea stringName [i] returnează o referință la caracterul (elementul) de la iaindexul colecției de personaje. Următorul cod de ieșiri v:
string strCol=şir('Te iubesc');charcap=strCol[4];
cost<<cap<< ' n';
stringName [i] const
Operația stringName [i] const este executată în loc de stringName [i] atunci când obiectul șir este un obiect constant. De exemplu, este utilizat în următorul cod:
conststring strCol=şir('Te iubesc');charcap=strCol[4];
cost<<cap<< ' n';
Expresia returnează o referință constantă la iaelement al obiectului șir. Niciunul dintre elementele șirului nu poate fi modificat.
Atribuirea unui caracter cu subscript
Un caracter poate fi atribuit unui obiect șir neconstant, după cum urmează:
string strCol=şir('Eu chem');strCol[2] = 'f';
cost<<strCol<< ' n';
Rezultatul este că cad. „C” a fost schimbat în „f”.
stringName.at (i)
stringName.at (i) este similar cu stringName [i], dar stringName.at (i) este mai fiabil. Următorul cod arată cum trebuie utilizat:
string strCol=şir('Te iubesc');charcap=strCol.la(4);
cost<<cap<< ' n';
at () este de fapt o funcție membru de clasă șir.
stringName.at (i) const
stringName.at (i) const este similar cu stringName [i] const, dar stringName.at (i) const este mai fiabil. stringName.at (i) const este executat în loc de stringName.at (i) atunci când obiectul șir este un obiect șir constant. Se folosește în următorul cod, de exemplu:
conststring strCol=şir('Te iubesc');charcap=strCol.la(4);
cost<<cap<< ' n';
at () const este de fapt o funcție membru de clasă șir.
Atribuirea unei valori cu funcția at ()
O valoare poate fi atribuită unui obiect șir neconstant, cu funcția at (), după cum urmează:
string strCol=şir('Eu chem');strCol.la(2) = 'f';
cost<<strCol<< ' n';
Rezultatul este că cad.
Problemă cu sub-scriptarea
Problema cu sub-scriptarea (indexarea) este că, dacă indexul este în afara intervalului, se poate obține rezultatul greșit sau se poate emite o eroare în timpul rulării.
față()
Aceasta returnează o referință la primul element al obiectului șir, fără a elimina elementul. Ieșirea următorului cod este „I”.
string strCol=şir('Te iubesc');charcap=strCol.față();
cost<<cap<< ' n';
Caracterul nu este eliminat din obiectul șir.
front () const
Când construcția obiectului șir este precedată de const, expresia front () const este executată în loc de front (). Este folosit, de exemplu, în următorul cod.
conststring strCol=şir('Te iubesc');charcap=strCol.față();
cost<<cap<< ' n';
Se returnează o referință constantă. Elementul nu este eliminat din obiectul șir. Niciun caracter nu poate fi schimbat pentru un obiect șir constant.
înapoi()
Aceasta returnează o referință la ultimul element al obiectului șir, fără a elimina elementul. Ieșirea următorului cod este „u”.
string strCol=şir('Te iubesc');charcap=strCol.înapoi();
cost<<cap<< ' n';
back () const
Când construcția obiectului șir este precedată de const, expresia back () const este executată în loc de back (). Este folosit, de exemplu, în următorul cod.
conststring strCol=şir('Te iubesc');charcap=strCol.înapoi();
cost<<cap<< ' n';
Se returnează o referință constantă. Elementul nu este eliminat din obiectul șir.
Capacitatea șirului
size_type capacity () const noexcept
Numărul total de caractere pe care șirul îl poate deține fără a necesita realocare este returnat de această funcție membru capacitate. Un segment de cod pentru aceasta este:
string strCol=şir();intpe unu=strCol.capacitate();
cost<<pe unu<< ' n';
Ieșirea este de 15 pe computerul meu.
rezerva (n)
Spațiul de memorie nu este întotdeauna disponibil în magazinul gratuit. Spațiu suplimentar poate fi rezervat în avans. Luați în considerare următorul segment de cod:
string strCol=şir('dragoste');strCol.rezervă(6);
cost<<strCol.capacitate() << ' n';
Ieșirea este de 15 pe computerul meu.
size () const noexcept
Aceasta returnează numărul de caractere din șir. Următorul cod ilustrează:
string strCol=şir('Te iubesc');intpe unu=strCol.mărimea();
cost<<pe unu<< ' n';
Ieșirea este 10, care nu include caracterul nul, 0.
length () const noexcept
-la fel ca mărimea().Notă:mărimea() <=capacitate().
shrink_to_fit ()
Poate reduce capacitatea () la dimensiune () provocând realocarea; nu este obligatoriu. Următorul cod demonstrează acest lucru:
string strCol=şir('Te iubesc');strCol.rezervă(12);
strCol.shrink_to_fit();
ints=strCol.mărimea();
cost<<s<< ' n';
Ieșirea este 10 și nu 12 sau 16. Funcția returnează nul.
redimensionare (sz), redimensionare (sz, 'c')
Aceasta redimensionează șirul. Dacă noua dimensiune este mai mică decât dimensiunea veche, atunci elementele spre final sunt șterse. Dacă noua dimensiune este mai lungă, atunci se adaugă un caracter implicit spre final. Pentru a adăuga un anumit caracter, utilizați funcția resize () cu două argumente. Următorul segment de cod ilustrează utilizarea celor două funcții:
string strCol=şir('Te iubesc');strCol.redimensionare(6);
cost<< „Dimensiune nouă a strCol:” <<strCol.mărimea() << ' n';
string strCol1=şir('Iubesc', 'Și');
strCol1.redimensionare(12);
cost<< 'Nouă dimensiune a strCol1:' <<strCol1.mărimea() << ' n';
Ieșirea este:
Noua dimensiune a strCol: 6Noua dimensiune a strCol1: 12
Funcția returnează nul.
clear () noexcept
Elimină toate elementele din șir, așa cum ilustrează următorul segment de cod:
string strCol=şir('Te iubesc');strCol.clar();
cost<<strCol.mărimea() << ' n';
Ieșirea este 0. Funcția returnează nul.
empty () const noexcept
Aceasta returnează 1 pentru adevărat dacă nu există niciun caracter în obiectul șir sau 0 pentru fals dacă obiectul șir nu este gol. Următorul cod ilustrează acest lucru:
string strCol1=şir('Te iubesc');cost<<strCol1.gol() << ' n';
șir strCol2=şir();
cost<<strCol2.gol() << ' n';
Ieșirea este:
01
Iteratorii care se întorc și clasa de corzi
Un iterator este ca un indicator, dar are mai multe funcționalități decât indicatorul.
begin () noexcept
Returnează un iterator care indică primul caracter (element) al obiectului șir, ca în următorul segment de cod:
string strCol=şir('Te iubesc');șir_de bază<char> ::iteratoriter=strCol.începe();
cost<< *iter<< ' n';
Ieșirea este „eu”. Rețineți modul în care a fost declarată declarația care primește iteratorul. Iteratorul este dereferențiat într-o expresie returnată pentru a obține valoarea, în același mod, că un pointer este dereferențiat.
begin () const noexcept;
Returnează un iterator care indică primul element al colecției de obiecte șir. Când construcția obiectului este precedată de const, expresia begin () const este executată în loc de begin (). În această condiție, elementul corespunzător din obiect nu poate fi modificat. Este folosit, de exemplu, în următorul cod.
conststring strCol=şir('Te iubesc');șir_de bază<char> ::const_iteratoriter=strCol.începe();
cost<< *iter<< ' n';
Ieșirea este „eu”. Rețineți că const_iterator a fost folosit de această dată, în loc de doar iterator, pentru a primi iteratorul returnat.
end () noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al obiectului șir. Luați în considerare următorul segment de cod:
string strCol=şir('Te iubesc');șir_de bază<char> ::iteratoriter=strCol.Sfârșit();
cost<< *iter<< ' n';
Rezultatul este nul, ceea ce nu este nimic, deoarece nu există niciun element concret dincolo de ultimul element.
end () const noexcept
Returnează un iterator care indică imediat dincolo de ultimul element al obiectului șir. Când construcția obiectului șir este precedată de const, expresia end () const este executată în loc de end (). Luați în considerare următorul segment de cod:
conststring strCol=şir('Te iubesc');șir_de bază<char> ::const_iteratoriter=strCol.Sfârșit();
cost<< *iter<< ' n';
Ieșirea este nulă. Rețineți că const_iterator a fost folosit de această dată, în loc de doar iterator, pentru a primi iteratorul returnat.
Iterare inversă
Este posibil să aveți un iterator care iterează de la finalul real până la chiar înainte de primul element:
rbegin () noexcept
Returnează un iterator care indică ultimul element al obiectului instanțat de șir, ca în următorul segment de cod:
string strCol=şir('Te iubesc');șir_de bază<char> ::invers_iteratoriter=strCol.rbegin();
cost<< *iter<< ' n';
Ieșirea este „u”. Rețineți modul în care a fost declarată declarația care primește iteratorul invers. Iteratorul este dereferențiat într-o expresie returnată pentru a obține valoarea, în același mod, că un pointer este dereferențiat.
rbegin () const noexcept;
Returnează un iterator care indică ultimul element al obiectului șir. Când construcția obiectului este precedată de const, expresia rbegin () const este executată în loc de rbegin (). În această condiție, elementul corespunzător din obiect nu poate fi modificat. Funcția este utilizată în următorul cod, de exemplu.
conststring strCol=şir('Te iubesc');șir_de bază<char> ::const_reverse_iteratoriter=strCol.rbegin();
cost<< *iter<< ' n';
Ieșirea este „u”. Rețineți că const_reverse_iterator a fost folosit de această dată, în loc de doar reverse_iterator, pentru a primi iteratorul returnat.
render () noexcept
Returnează un iterator care indică chiar înainte de primul element al obiectului șir. Luați în considerare următorul segment de cod:
string strCol=şir('Te iubesc');șir_de bază<char> ::invers_iteratoriter=strCol.face();
cost<< *iter<< ' n';
Ieșirea este nulă, ceea ce nu este nimic, deoarece nu există un element concret chiar înainte de primul element.
render () const noexcept
Returnează un iterator care indică chiar înainte de primul element al obiectului șir. Când construcția obiectului este precedată de const, expresia rend () const este executată în loc de rend (). Luați în considerare următorul segment de cod:
conststring strCol=şir('Te iubesc');șir_de bază<char> ::const_reverse_iteratoriter=strCol.face();
cost<< *iter<< ' n';
Ieșirea este nulă. Rețineți că const_reverse_iterator a fost folosit de această dată, în loc de doar reverse_iterator, pentru a primi iteratorul returnat.
Modificatoare de șiruri
Un modificator care modifică obiectul șir poate, de asemenea, să ia sau să returneze un iterator.
Anexare
șir_de bază&operator+ =(constșir_de bază&str)Adaugă obiectul șir drept la obiectul șir stâng. Exemplu:
string strCol1=şir('Iubesc');șir strCol2=şir(' tu');
strCol1+ =strCol2;
cost<<strCol1<< ' n';
Rezultatul este că te iubesc. Nu uitați că strCol1 + = strCol2 este același ca strCol1 = strCol1 + strCol2.
șir_de bază & operator + = (const charT * s)
Adaugă un literal șir la o colecție de obiecte șir. Exemplu:
string strCol=şir('Iubesc');strCol+ = ' tu';
cost<<strCol<< ' n';
Rezultat: te iubesc.
șir_de bază & operator + = (charT c)
Adaugă un singur caracter unui șir de obiecte. Exemplu:
string strCol=şir('Te iubesc');strCol+ = tu;
cost<<strCol<< ' n';
Rezultat: te iubesc.
șir_de bază & operator + = (listă_inicializator)
Adaugă o listă de inițializatoare. Exemplu:
string strCol=şir('Iubesc');strCol+ = {'','și','sau',tu,' 0'};
cost<<strCol<< ' n';
Rezultat: te iubesc. Este întotdeauna bine să adăugați nulul, 0 la sfârșitul unei liste de inițializatoare de caractere.
basic_string & append (const basic_string & str)
Adaugă obiectul șir argument la obiectul șir principal. Exemplu:
string strCol1=şir('Iubesc');șir strCol2=şir(' tu');
strCol1.adăuga(strCol2);
cost<<strCol1<< ' n';
Rezultat: te iubesc.
basic_string & append (const charT * s)
Adaugă un argument literal șir la șirul principal. Exemplu
string strCol=şir('Iubesc');strCol=strCol.adăuga(' tu');
cost<<strCol<< ' n';
Rezultat: te iubesc.
basic_string & append (initializer_list)
Adaugă lista de inițializatoare, care este un argument, la șirul principal. Exemplu:
string strCol=şir('Iubesc');strCol=strCol.adăuga({'','și','sau',tu,' 0'});
cost<<strCol<< ' n';
Rezultat: te iubesc. Este întotdeauna bine să adăugați caracterul nul, 0 la sfârșitul unei liste de inițializatoare.
șir_de bază & adăugați (mărime_tip n, diagramă c)
Adaugă n de același caracter. Exemplu:
string strCol=şir(„filă”);strCol=strCol.adăuga(2, 'sau');
cost<<strCol<< ' n';
Ieșire: tabu.
șir_de bază & adăugați (const charT * s, size_type n)
Adaugă primele n elemente ale unui literal șir la obiectul șir principal. Exemplu:
string strCol=şir('Iubesc');strCol=strCol.adăuga('tu asa', 4);
cost<<strCol<< ' n';
Rezultatul este: te iubesc. Dacă n este mai mare decât lungimea literalului, se aruncă o excepție length_error.
basic_string & append (const basic_string & str, size_type pos, size_type n = npos)
Adaugă n caractere din index, poz la șirul principal. Exemplu:
string strCol=şir('Iubesc');strCol=strCol.adăuga(te-am atat, 2, 4);
cost<<strCol<< ' n';
Rezultat: te iubesc. O excepție ar fi, de asemenea, aruncată aici, vezi mai târziu.
Atribuire
șir_de bază&atribui(constșir_de bază&str)Atribuie obiectul șir de argumente șirului principal, înlocuind orice conținut care se afla acolo.
string strCol1=şir('Te iubesc');șir strCol2=şir(„Are nevoie de mine”);
strCol1=strCol1.atribui(strCol2);
cost<<strCol1<< ' n';
Rezultate: Are nevoie de mine.
șir_de bază&atribui(constdiagramă*s)Atribuie un argument literal al șirului principal, înlocuind orice conținut care era acolo.
string strCol=şir('Te iubesc');strCol=strCol.atribui(„Are nevoie de mine”);
cost<<strCol<< ' n';
Rezultate: Are nevoie de mine.
șir_de bază&atribui(initializer_list<diagramă>)Atribuie un argument listă inițializatorului șirului principal,înlocuind orice conținut care se afla acolo.
[cc lang=„c”a scăpat='Adevărat'lăţime=„780”]
string strCol=şir('Te iubesc');
strCol=strCol.atribui({„S”,'h','Și','','n','Și','Și','d','s','','m','Și',' 0'});
cost<<strCol<< ' n';
Rezultate: Are nevoie de mine. Este bine să adăugați întotdeauna nulul, 0 la sfârșitul listei de caractere, pentru a forma un șir literal.
șir_de bază&atribui(constdiagramă*s,size_type n)Atribuie primele n caractere ale unui argument literal șir șirului principal, înlocuind orice conținut care a fost acolo.
string strCol=şir('Te iubesc');strCol=strCol.atribui(„Are nevoie de mine”, 9);
cost<<strCol<< ' n';
Rezultate: Are nevoie.
șir_de bază&atribui(size_type n,diagramă c)Atribuie un argument de n din aceleași caractere șirului principal, înlocuind orice conținut care era acolo.
string strCol=şir('Te iubesc');strCol=strCol.atribui(4, 'Și');
cost<<strCol<< ' n';
Ieșire: eeee
șir_de bază&atribui(constșir_de bază&str,size_type pos,size_type n=npos)
Atribuie n caractere ale unui argument de tip șir, începând de la poz, șirului principal, înlocuind orice conținut care se afla acolo.
string strCol=şir('Te iubesc');strCol=strCol.atribui(„Are nevoie de mine”, 4, 5);
cost<<strCol<< ' n';
Rezultate: nevoi. Ar arunca o excepție - vezi mai târziu.
Se introduce
șir_de bază&introduce(size_type pos, constșir_de bază&str)Inserează argumentul obiectului șir în șirul principal, la index, poz.
string strCol1=şir('Te iubesc');șir strCol2=şir(„ura și”);
strCol1=strCol1.introduce(2,strCol2);
cost<<strCol1<< ' n';
Rezultat: te urăsc și te iubesc. Ar arunca o excepție - vezi mai târziu.
șir_de bază&introduce(size_type pos1, constșir_de bază&str,size_type pos2,size_type n=npos)
Inserează o lungime de n caractere de la poziția 2 a argumentului obiectului șir, la șirul principal, la index, poz1.
string strCol1=şir('Te iubesc');șir strCol2=şir(„urăsc, doresc și au nevoie”);
strCol1=strCol1.introduce(2,strCol2, 6, 9);
cost<<strCol1<< ' n';
Rezultat: te vreau și te iubesc.
insert iterator (const_iterator p, charT c)
Inserează un anumit caracter, care este un argument, în poziția indicată de iterator. Returnează un iterator pentru poziția caracterului nou inserat.
string strCol=şir('Te iubesc');șir_de bază<char> ::iteratoriter=strCol.începe();
++iter; ++iter; ++iter; ++iter; ++iter; ++iter;
șir_de bază<char> ::iteratorreţea=strCol.introduce(iter, 'd');
cost<< *reţea<< ' n';
cost<<strCol<< ' n';
Ieșirea este:
„D”
te-am iubit
insert iterator (const_iterator p, size_type n, charT c)
Inseră n același caracter al argumentului, în poziția indicată de iterator. Returnează un iterator pentru poziția de la începutul acelorași caractere nou inserate.
string strCol=şir(„Tab în țară”.);șir_de bază<char> ::iteratoriter=strCol.începe();
++iter; ++iter; ++iter;
șir_de bază<char> ::iteratorreţea=strCol.introduce(iter, 2, 'sau');
cost<< *reţea<< ' n';
cost<<strCol<< ' n';
Ieșirea este:
'sau'
Tabu în țară.
șir_de bază&introduce(size_type pos, constdiagramă*s)Inserează un șir de argumente literal la index, poz în șirul principal.
string strCol=şir(„Tab în țară”.);strCol=strCol.introduce(3, 'oo');
cost<<strCol<< ' n';
Ieșire: tabu în țară.
șir_de bază&introduce(size_type pos, constdiagramă*s,size_type n)Inserează primele n caractere ale șirului de argumente literal, la index, poz în șirul principal.
string strCol=şir(„Tab în țară”.);strCol=strCol.introduce(3, 'oooo', 2);
cost<<strCol<< ' n';
Ieșire: tabu în țară.
Înlocuind
șir_de bază&a inlocui(size_type pos1,size_type n1, constșir_de bază&str))Înlocuiește n1 caractere în obiectul șir principal din index, pos1, cu obiectul șir argument.
string strCol1=şir('Te iubesc');șir strCol2=şir(„te urăsc și”);
strCol1=strCol1.a inlocui(2, 4,strCol2);
cost<<strCol1<< ' n';
Rezultat: Te urăsc pe tine și pe tine. Ar arunca o excepție - vezi mai târziu.
șir_de bază&a inlocui(size_type pos1,size_type n1, constșir_de bază&str,size_type pos2,size_type n2=npos)
Înlocuiește n1 caractere din obiectul șir principal din index, pos1, cu n2 caractere ale obiectului șir argument din index, pos2.
string strCol1=şir('Te iubesc');șir strCol2=şir(„îl urâm pe el și pe ea”);
strCol1=strCol1.a inlocui(2, 4,strCol2, 3, 12);
cost<<strCol1<< ' n';
Rezultat: îl urăsc pe el și pe tine.
șir_de bază&a inlocui(size_type pos1,size_type n1, constdiagramă*s,size_type n2)
Înlocuiește n1 caractere din obiectul șir principal din index, pos1, cu primele n2 caractere ale argumentului șir literal.
string strCol1=şir('Te iubesc');strCol1=strCol1.a inlocui(2, 4, „urăște-l și pe ea”, 12);
cost<<strCol1<< ' n';
Rezultat: îl urăsc pe el și pe tine.
string_basic & înlocuire (size_type pos, size_type n, const charT * s)
Înlocuiește n caractere din obiectul șir principal din index, pos, cu argumentul șir literal.
string strCol1=şir('Te iubesc');strCol1=strCol1.a inlocui(2, 4, „urăște-l și”);
cost<<strCol1<< ' n';
Rezultat: îl urăsc pe el și pe tine.
șir_de bază&a inlocui(size_type pos1,size_type n1,size_type n2,diagramă c)Înlocuiește n1 caractere din obiectul șir principal din index, pos1, cu n2 din același caracter al argumentului.
string strCol1=şir(- O tabletă proastă acolo.);strCol1=strCol1.a inlocui(9, 3, 2, 'sau');
cost<<strCol1<< ' n';
Ieșire: un tabu rău acolo ..
ștergere iterator (const_iterator p)
Elimină un caracter în poziția indicată de iterator; apoi returnează poziția iteratorului, care este acum ocupată de caracterul care era lângă acest personaj (sau sfârșitul ()). Următorul cod ilustrează acest lucru:
string strCol=şir(„abcd”);șir_de bază<char> ::iteratoriter=strCol.începe();
++iter; ++iter;
strCol.şterge(iter);
cost<<strCol[0] << '' <<strCol[1] << '
' <<strCol[2]<< ' n';
Ieșirea: a b d
șir_de bază&şterge(size_type pos= 0,size_type n=npos)Elimină n caractere din index, poz.
string strCol=şir(„abcd”);strCol.şterge(1, 2);
cost<<strCol[0] << '' <<strCol[1] << ' n';
Ieșire: a d
void push_back (charT c)
Pentru a adăuga un singur caracter la sfârșitul șirului:
string strCol=şir(„abcd”);strCol.împinge înapoi(„5”);
cost<<strCol<< ' n';
Ieșire: abcd5
void pop_back ()
Elimină ultimul personaj fără a-l returna. Dimensiunea șirului este redusă cu 1.
string strCol=şir(„abcde”);strCol.pop_back();
cost<<strCol<< ' n';
Ieșire: abcd
swap de gol (șir_de bază & s)
Literalele a două obiecte șir pot fi schimbate.
string strCol1=şir(<ajutor=„post-69618 -__ DdeLink__781_3724385525”>la>„abcde”);șir strCol2=şir(„1234567”);
strCol1.swap(strCol2);
cost<<strCol1<< ' n';
cost<<strCol2<< ' n';
Ieșirea este:
„1234567”„abcde”
Operații de șir
const charT * c_str () const noexcept
Returnează un pointer la primul element al șirului. Pointerul poate fi incrementat.
conststring strCol=şir(„abcde”);const char*p=strCol.c_str();
cost<< *p<< ' n';
++p;
cost<< *p<< ' n';
Rezultatul este:
lab
Din cauza celei de-a doua constanții din titlu, programul nu poate schimba niciun caracter din șir. Construcția este precedată de const.
const charT * data () const noexcept
Returnează un pointer la primul element al șirului. Pointerul poate fi incrementat.
conststring strCol=şir(„abcde”);const char*p=strCol.date();
cost<< *p<< ' n';
++p;
cost<< *p<< ' n';
Rezultatul este:
lab
Din cauza celei de-a doua constanții din titlu, programul nu poate schimba niciun caracter din șir. Construcția este precedată de const.
basic_string substr (size_type pos = 0, size_type n = npos) const
Returnează un obiect șir de n caractere pentru șirul secundar care începe de la index, poz.
conststring strCol=şir(„abcdefghij”);constșir retStr=strCol.substr(2, 4);
cost<<retStr<< ' n';
Ieșire: cdef
find () Funcții de membru
size_type find (const basic_string & str, size_type pos = 0) const noexcept
Caută un obiect sub-șir care începe de la index, poz. Dacă este găsit, returnează începutul sub-șirului din șirul principal.
string strCol=şir('Noi suntem lumea!');string strCol1=şir(„cel”);
intpe unu=strCol.găsi(strCol1, 2);
cost<<pe unu<< ' n';
Ieșire:
index: 7Returnează -1, când nu este găsit.
size_type find (const charT * s, size_type pos = 0) const
Căutați un sub-șir literal care începe de la index, poz. Dacă este găsit, returnează începutul sub-șirului din șirul principal.
string strCol=şir('Noi suntem lumea!');intpe unu=strCol.găsi('sunt', 0);
cost<<pe unu<< ' n';
Deoarece pos = 0 este implicit, 0 din argument ar fi putut fi omis.
Ieșire: 3
Returnează -1, când nu este găsit.
size_type find (const charT * s, size_type pos, size_type n) const
Caută primele n caractere ale unui sub-șir literal începând de la index, poz. Dacă este găsit, returnează începutul sub-șirului din șirul principal.
string strCol=şir(„Cel mai mare băiat”);intpe unu=strCol.găsi('mai mare', 1, 3);
cost<<pe unu<< ' n';
Ieșire: 4
Returnează -1, când nu este găsit.
size_type find (charT c, size_type pos = 0) const
Caută caracterul, c începând de la index, poz. Dacă este găsit, returnează începutul sub-șirului din șirul principal. Dacă nu este găsit, returnează -1.
string strCol=şir('Noi suntem lumea!');intpe unu=strCol.găsi('Cu');
cost<<pe unu<< ' n';
Ieșire: -1
Următoarele funcții ale membrilor find () există:
size_type rfind(constșir_de bază&str,size_type pos=npos) constfără excepția;size_type rfind(constdiagramă*s,size_type pos=npos) const;
size_type rfind(constdiagramă*s,size_type pos,size_type n) const;
size_type rfind(diagramă c,size_type pos=npos) const;
Funcții de comparație ale membrilor
int compare (const basic_string & str) const noexcept
Compară obiectul șir argument cu obiectul șir principal. Dacă șirul principal apare înainte de argument (în dicționar), acesta returnează un număr pozitiv. Dacă apare după șirul principal, returnează un număr negativ. Dacă cele două șiruri sunt aceleași, returnează zero.
string strCol1=şir('mulțime');șir strCol2=şir('oameni');
intpe unu=strCol1.comparaţie(strCol2);
cost<<pe unu<< ' n';
Ieșire: -13
int compare (const charT * s) const
La fel ca mai sus, dar argumentul este un literal șir.
string strCol1=şir('oameni');intpe unu=strCol1.comparaţie('oameni');
cost<<pe unu<< ' n';
Ieșire: 0
Operatori de șiruri
Acești operatori sunt aplicabili obiectelor șir și nu neapărat literele șirului.
+
Concatenează două obiecte șir și returnează concatenarea.
string strCol1=şir(„dansând”);șir strCol2=şir(' luna');
string strCol=strCol1+strCol2;
cost<<strCol<< ' n';
Ieșire: dans pe lună.
==
Returnează 1 pentru adevărat, dacă obiectele șir sunt aceleași; și zero pentru fals, dacă nu sunt.
string strCol1=şir(„dansând”);șir strCol2=şir(' pe luna');
bool bl=strCol1==strCol2;
cost<<bl<< ' n';
Ieșire: 0
! =
Returnează 1 dacă obiectele șir nu sunt aceleași și zero dacă sunt.
string strCol1=şir(„dansând”);șir strCol2=şir(' pe luna');
bool bl=strCol1! =strCol2;
cost<<bl<< ' n';
Ieșire: 1
<
Returnează 1, dacă operandul din stânga este mai mic decât operandul din dreapta conform dicționarului sau zero dacă nu este.
string strCol1=şir(„dansând”);șir strCol2=şir(' pe luna');
bool bl=strCol1<strCol2;
cost<<bl<< ' n';
Ieșire: 0
Pentru caracterele obișnuite în C ++, în ordine crescătoare, numerele sunt înaintea literelor mari, care vin înainte de literele mici. Caracterul spațial vine înainte de zero și toate.
Tipuri de caractere ale șirului principal C ++
char
Tipul char este tipul C ++ original și ar stoca de obicei un caracter în 8 biți.
char16_t
Aceasta stochează un caracter în 16 biți.
char32_t
Aceasta stochează un caracter în 32 de biți.
wchar_t
char16_t și char32_t sunt caractere largi. wchar_t este un caracter larg, proprietar și definit de implementare.
Aceste tipuri se numesc trăsături. Cu toate acestea, C ++ se referă la acestea din punct de vedere tehnic ca fiind specializări ale trăsăturilor. Acest articol sa concentrat asupra tipului de caracter. Abordarea celorlalte tipuri este ușor diferită - vezi mai târziu.
Alte funcții de funcționare ale șirului de funcții
Semnăturile altor funcții de operație șir sunt:
size_type find_first_of(constșir_de bază&str,size_type pos= 0) constfără excepția;size_type find_first_of(constdiagramă*s,size_type pos,size_type n) const;
size_type find_first_of(constdiagramă*s,size_type pos= 0) const;
size_type find_first_of(diagramă c,size_type pos= 0) const;
size_type find_last_of(constșir_de bază&str,size_type pos=npos) constfără excepția;
size_type find_last_of(constdiagramă*s,size_type pos,size_type n) const;
size_type find_last_of(constdiagramă*s,size_type pos=npos) const;
size_type find_last_of(diagramă c,size_type pos=npos) const;
size_type find_first_not_of(constșir_de bază&str,size_type pos= 0) constfără excepția;
size_type find_first_not_of(constdiagramă*s,size_type pos,size_type n) const;
size_type find_first_not_of(constdiagramă*s,size_type pos= 0) const;
size_type find_first_not_of(diagramă c,size_type pos= 0) const;
size_type find_last_not_of(constșir_de bază&str,size_type pos=npos) constfără excepția;
size_type find_last_not_of(constdiagramă*s,size_type pos,size_type n) const;
size_type find_last_not_of(constdiagramă*s,size_type pos=npos) const;
size_type find_last_not_of(diagramă c,size_type pos=npos) const;
Concluzie
C ++ are caractere literale și obiecte șir. Obiectul șir are o colecție de caractere în ordine, similar cu o serie de caractere în ordine. Diferența dintre colecția de șiruri și o matrice este că colecția de șiruri poate crește în lungime sau se poate micșora în lungime. Un obiect șir este instanțiat (construit) dintr-o clasă șir. Un obiect șir este o structură de date cu funcții membre. Funcțiile de membru pot fi clasificate la rubricile de construcție de obiecte, acces la elemente, capacitate de șir, funcții de membri de șir cu argumente iteratoare și tipuri de returnare și modificatori de șiruri. Egalitatea șirurilor și operatorii relaționali există, de asemenea.