Clasa sablon string

Clasa sablon string

Clasa string se bazeaza pe definirea unui sablon:

template<class charT, class traits = char_traits<charT>,

class Allocator = allocator<charT> >

class basic_string ;

Aici charT reprezinta tipul stocat în sir. Parametrul traits reprezinta o clasa care defineste proprietatile necesare pentru ca un tip sa poata fi reprezentat ca sir. De exemplu, ar trebui sa posede o metoda length() care sa returneze lungimea unui sir reprezentat ca un tablou de tip charT. Sfârsitul unui astfel de tablou este indicat de valoarea charT(0), care este generalizarea caracterului nul. (Expresia charT(0) este o conversie de tip a lui 0 la tipul charT. Poate fi chiar un 0, ca pentru tipul char, sau mai general, este un obiect creat de un constructor charT.) Clasa mai include metode de comparare a valorilor, si asa mai departe. Parametrul Allocator reprezinta o clasa care gestioneaza memoria ce se aloca sirului. sablonul prestabilit allocator<charT> utilizeaza new si delete în maniera obisnuita.

Exista doua specializari predefinite:

typedef basic_string<char> string;

typedef basic_string<wchar_t> wstring;

Aceste specializari utilizeaza, la rândul lor urmatoarele specializari:

char_traits<char>

allocator<char>

char_traits<wchar_t>

allocator<wchar_t>

Puteti crea o clasa string si pentru alt tip, nu numai pentru char sau wchar_t, definind o clasa traits si utilizând & 545o1421f #351;ablonul basic_string

Treisprezece tipuri si o constanta

sablonul basic_string defineste câteva tipuri care vor fi folosite ulterior în definitiile metodelor:

typedef traits traits_type;

typedef typename traits::char_type value_type;

typedef Allocator allocator_type;

typedef typename Allocator::size_type size_type;

typedef typename Allocator::difference_type difference_type;

typedef typename Allocator::reference reference;

typedef typename Allocator::const_reference const_reference;

typedef typename Allocator::pointer pointer;

typedef typename Allocator::const_pointer const_pointer;

Observati ca traits este un parametru sablon care va corespunde unui tip specific, cum ar fi char_traits<char> traits_type va deveni un typedef pentru acel tip specific. Notatia

typedef typename traits::char_type value_type;

înseamna ca char_type este un nume tip definit în clasa reprezentata de traits. Cuvântul cheie typename este folosit pentru a-i spune compilatorului ca expresia traits::char_type este un tip. Pentru specializarea sirului, de exemplu, value_type va fi char

size_type este folosit ca si size_of, numai ca returneaza dimensiunea sirului în termenii tipului stocat. Pentru specializarea sirului, va fi în char, deci în acest caz size_type este acelasi lucru cu size_of. Este un tip fara semn.

difference_type este utilizat pentru a masura distanta dintre doua elemente ale sirului, din nou folosind unitati corespunzând marimii unui singur element. În mod normal, este un tip cu semn derivat din tipul care sta la baza lui size_type

Pentru specializarea char pointer va fi de tip char *, iar reference va fi de tip char &. Totusi, daca creati o specializare pentru un tip definit de dumneavoastra, atunci aceste tipuri (pointer si reference) pot sa se refere la clase care au aceleasi proprietati de baza ca si pointerii si referintele normale.

Pentru ca algoritmii STL sa functioneze cu siruri, sablonul defineste si câteva tipuri de iteratori:

typedef (modeleaza un iterator cu acces aleator) iterator;

typedef (modeleaza un iterator cu acces aleator) const_iterator;

typedef std::reverse_iterator<iterator> reverse_iterator;

typedef reverse_iterator<const_iterator> const_reverse_iterator;

sablonul mai defineste o constanta statica:

static const size_type npos = -1;

Deoarece size_type este fara semn, atribuirea unei valori -1 duce de fapt la atribuirea celei mai mari valori fara semn lui npos. Aceasta este cu 1 mai mare decât indexul maxim posibil al unui tablou.

Datele, constructorii si celelalte

Constructorii pot fi descrisi în functie de efectele pe care le au. Deoarece sectiunile private ale unei clase pot fi dependente de implementare, aceste efecte trebuie sa fie descrise în functie de informatiile disponibile ca parti ale interfetei publice. Tabelul F.1 prezinta câteva metode ale caror valori returnate pot fi folosite pentru a descrie efectele constructorilor si ale altor metode. Observati ca o mare parte din terminologie deriva din STL.

Tabelul F.1 Unele metode string legate de date.

Metoda    Returneaza

begin() Un iterator la primul caracter din sir (este disponibil si în versiune const

care returneaza un iterator const

end() Un iterator care este valoarea dincolo-de-sfârsit (disponibil si în versiune

const

rbegin() Un iterator invers care este valoarea dincolo-de-sfârsit (disponibil si în versiune const

rend() Un iterator invers care indica primul caracter (disponibil si în versiune

const

size() Numarul elementelor din sir, egal cu distanta dintre begin() si end()

length() La fel cu size()

capacity() Numarul de elemente alocate în sir.

max_size() Dimensiunea maxima permisa pentru sir.

data() Un pointer de tip const charT* la primul element al unui tablou ale carui

prime size() elemente sunt egale cu elementele corespunzatoare ale sirului

controlat de *this. Pointerul nu este obligatoriu valid, daca obiectul sir a fost

el însusi modificat.

c_str() Un pointer de tip const charT* la primul element al unui tablou ale carui

prime size() elemente sunt egale cu elementele corespunzatoare ale sirului

controlat de *this si al carui element urmator este caracterul charT(0)

(marcajul de sfârsit de sir al tipului charT). Pointerul nu este obligatoriu

valid, daca obiectul sir a fost el însusi modificat.

get_allocator()O copie a obiectului alocator utilizat pentru alocarea memoriei necesare

sirului.

Fiti atent la diferentele existente între begin() rend() data() si c_str(). Toate sunt legate de primul caracter din sir, dar în moduri diferite. Astfel, metodele begin() si rend() returneaza iteratori, care sunt generalizari ale pointerilor, asa cum am vazut în discutia despre STL din Capitolul 15. În particular, begin() returneaza un model de iterator de înaintare, iar rend() o copie a unui iterator invers. Amândoi se refera la sirul gestionat de obiectul string. (Deoarece clasa string foloseste alocarea dinamica a memoriei, continutul efectiv al sirului nu se afla în interiorul obiectului, deci vom folosi termenul gestiune pentru a descrie relatia dintre obiect si sir.) Puteti folosi metodele care returneaza iteratori cu algoritmii bazati pe iteratori ai STL. De exemplu, puteti folosi functia STL transform() pentru a transforma elementele unui sir în litere mari:

string cuvant;

cin >> cuvant;

transform(cuvant.begin(), cuvant.end(), toupper);

Pe de alta parte, metodele data() si c_str() returneaza pointeri normali. În plus, acesti pointeri indica primul element al unui tablou care pastreaza caracterele sirului. Acest tablou, poate fi, dar nu neaparat, o copie a sirului original gestionat de obiectul string. (Reprezentarea interna utilizata de obiectul string poate fi un tablou, dar nu neaparat.) Deoarece pointerii returnati ar putea indica chiar datele originale, sunt const, deci nu pot fi folositi pentru modificarea datelor. De asemenea, pointerii nu sunt neaparat valizi dupa modificarea sirului; acest lucru reflecta din nou faptul ca pointerii ar putea indica datele originale. Diferenta dintre data() si c_str() este ca tabloul indicat de c_str() se termina cu caracterul nul (sau echivalentul sau), în timp ce data() contine numai caracterele continute efectiv de sir. Prin urmare, metoda c_str() poate fi utilizata, de exemplu, ca argument al unei functii care cere un sir în stil C:

string fisier("tofu.man");

ofstream outFile(fisier.c_str());

Analog, data() si size() pot fi folosite în functii care primesc ca argumente un pointer la un element al unui tablou si o valoare care reprezinta numarul de elemente de procesat:

string vampir("Oh, dragul meu, nu infige tarusul!");

int vlad = byte_check(vampir.data(), vampir.size());

O anumita implementare poate reprezenta sirul unui obiect string ca un sir în stil C alocat dinamic si sa implementeze iteratorul de înaintare ca pointer char *. În acest caz, implementarea poate alege ca begin() data() si c_str() sa returneze acelasi pointer. Dar la fel de legitim (daca nu la fel de usor), pot returna referinte la trei obiecte diferite.

Tabelul F.2 listeaza cei sase constructori si destructorul clasei sablon basic_string. Observati ca toti constructorii au un argument de forma:

const Allocator & a = Allocator()

Va reamintiti ca termenul Allocator este numele parametrului sablon pentru clasa alocatoare care gestioneaza memoria. Termenul Allocator() reprezinta constructorul prestabilit al acelei clase. Prin urmare, constructorii folosesc versiunea prestabilita a obiectului alocator, dar va ofera optiunea de a folosi orice alta versiune a acestuia. Sa examinam constructorii pe rând.

Tabelul F.2 Constructori string

Prototipuri pentru constructori si destructor

explicit basic_string(const Allocator& a = Allocator());

basic_string(const charT* s, const Allocator& a = Allocator());

basic_string(const basic_string& str, size_type pos = 0,

size_type n = npos, const Allocator& a = Allocator());

basic_string(const charT* s, size_type n,

const Allocator& a = Allocator());

basic_string(size_type n, charT c,

const Allocator& a = Allocator());

template<class InputIterator>

basic_string(InputIterator begin, InputIterator end,

const Allocator& a = Allocator());

~basic_string();

Constructorul prestabilit

Acesta este constructorul prestabilit:

explicit basic_string(const Allocator& a = Allocator());

În mod normal, veti folosi argumentul prestabilit si veti utiliza acest constructor pentru a crea siruri vide:

string boaba;

wstring teorie;

Urmatoarele relatii se pastreaza dupa apelul constructorului:

Metoda data() returneaza un pointer diferit de cel nul la care se poate aduna 0.

Metoda size() returneaza 0.

Valoarea returnata de capacity() nu este specificata.

Sa presupunem ca atribuiti valoarea returnata de data() pointerului sir. Atunci, prima conditie spune ca sir + 0 este valid, de unde rezulta ca expresia sir[0] este valida.

Constructor care foloseste un tablou

Urmatorul constructor va permite sa initializati un obiect string cu un sir în stil C; sau mai general, va permite sa initializati o specializare charT dintr-un tablou de valori charT

basic_string(const charT* s, const Allocator& a = Allocator());

Pentru a determina câte caractere se copiaza, constructorul aplica metoda traits::length() la tabloul indicat de pointerul s. (Pointerul s nu poate fi pointerul nul.) De exemplu, instructiunea

string toast("In sanatatea ta, baiete.");

initializeaza obiectul toast utilizând sirul de caractere indicat. În cazul tipului char metoda traits::length() va folosi caracterul nul pentru a determina câte caractere se copiaza. Urmatoarele relatii se pastreaza dupa apelul constructorului:

Metoda data() returneaza un pointer la primul element al unei copii a tabloului s

Metoda size() returneaza o valoare egala cu traits::length()

Metoda capacity() returneaza o valoare cel putin egala cu size()

Constructor care foloseste o parte dintr-un tablou

Urmatorul constructor va permite sa initializati un obiect string cu o portiune a unui sir în stil C; sau, mai general, va permite sa initializati o specializare charT dintr-o portiune a unui tablou de valori charT

basic_string(const charT* s, size_type n,

const Allocator& a = Allocator());

Acest constructor copiaza un total de n caractere din tabloul indicat de s în obiectul construit. Copierea nu se opreste daca s are mai putin de n caractere. Daca n este mai mare decât lungimea lui s, atunci constructorul va interpreta continutul memoriei de dupa sir ca si când ar contine valori de tip charT

Constructorul cere ca s sa nu fie pointer nul iar n < npos. (Amintiti-va ca npos este o constanta statica a clasei egala cu numarul maxim posibil de elemente dintr-un sir.) Daca n este egal cu npos, constructorul arunca o exceptie out_of_range. (Deoarece n este de tip size_type iar npos este valoarea maxima size_type n nu poate fi mai mare decât npos

În rest, dupa apelul constructorului, se pastreaza urmatoarele relatii:

Metoda data() returneaza un pointer la primul element al unei copii a tabloului s

Metoda size() returneaza n

Metoda capacity() returneaza o valoare cel putin la fel de mare ca si size()

Constructorul de copiere

Constructorul de copiere furnizeaza câteva argumente cu valori prestabilite:

basic_string(const basic_string& str, size_type pos = 0,

size_type n = npos, const Allocator& a = Allocator());

Apelul doar cu un argument basic_string initializeaza noul obiect cu sirul argument:

string mel("Sunt bine!");

string ida(mel);

Aici ida primeste o copie a sirului gestionat de mel

Argumentul optional pos specifica locatia în sirul sursa din care începe copierea:

string tel("Da telefon acasa.");

string el(tel, 3);

Numerotarea începe cu 0, deci pozitia 3 este caracterul t. Prin urmare, el este initializat cu "telefon acasa."

Urmatorul argument optional n specifica numarul maxim de caractere care se copiaza. Prin urmare,

string tel("Da telefon acasa.");

string tl(tel, 3, 7);

va initializa tl cu sirul "telefon". Totusi, acest constructor nu va copia dincolo de sfârsitul sirului sursa; de exemplu,

string tl(tel, 3, 200)

se va opri dupa ce se copiaza punctul. Deci constructorul copiaza un numar de caractere egal cu minimul dintre n si str.size() - pos

Acest constructor cere ca pos <= str.size(), adica pozitia initiala de la care se începe copierea sa fie în interiorul sirului sursa; în caz contrar va arunca o exceptie out_of_range. Daca copy_len reprezinta minimul dintre n si str.size() - pos, dupa apelul constructorului, se pastreaza urmatoarele relatii:

Metoda data() returneaza un pointer la copia a copy_len elemente din sirul str, începând cu elementul din pozitia pos din str

Metoda size() returneaza copy_len

Metoda capacity() returneaza o valoare cel putin la fel de mare ca si size()

Constructor care foloseste n copii ale unui caracter

Constructorul urmator creeaza un obiect string care este alcatuit din n caractere consecutive care au valoarea identica c

basic_string(size_type n, charT c,

const Allocator& a = Allocator());

Constructorul cere ca n < npos. Daca n este egal cu npos, constructorul arunca o exceptie out_of_range. Urmatoarele relatii se pastreaza dupa apelul constructorului:

Metoda data() returneaza un pointer la primul element al unui sir de n elemente, fiecare setat la c

Metoda size() returneaza n

Metoda capacity() returneaza o valoare cel putin la fel de mare ca si size()

Constructor care foloseste un interval

Ultimul constructor foloseste un interval definit de iteratori în stilul STL:

template<class InputIterator>

basic_string(InputIterator begin, InputIterator end,

const Allocator& a = Allocator());

Iteratorul begin indica elementul din sursa de unde începe copierea, iar end indica locatia imediat urmatoare ultimului caracter de copiat.

Aceasta forma o puteti folosi cu tablouri, siruri, sau containere STL:

char cole[40] = "Batranul rege Cole era un suflet vesel.";

string titlu(cole + 9, cole + 13);

vector<char> intrare;

char car;

while (cin.get(car) && car != '\n')

intrare.push_back(car);

string str_intrare(intrare.begin(), intrare.end());

În primul exemplu, InputIterator este evaluat la tipul const char *. În al doilea, InputIterator este evaluat la tipul vector<char>::iterator

Urmatoarele relatii se pastreaza dupa apelul constructorului:

Metoda data() returneaza un pointer la primul element al sirului format prin copierea elementelor din intervalul [begin, end)

Metoda size() returneaza distanta dintre begin si end. (Distanta este masurata în unitati egale cu dimensiunea tipului de date obtinut la dereferentierea iteratorului.)

Metoda capacity() returneaza o valoare cel putin la fel de mare ca si size()

Metode pentru memorie

Mai multe metode se ocupa cu memoria; de exemplu, stergerea continutului din memorie, redimensionarea unui sir, ajustarea capacitatii unui sir. Tabelul F.3 va prezinta câteva metode legate de memorie.

Tabelul F.3 Câteva metode legate de memorie.

Metoda    Efect

void resize(size_type n) Arunca exceptie out_of_range daca n >

npos. Altfel modifica dimensiunea sirului la n

prin trunchiere la sfârsit, daca n < size()

sau prin umplerea cu caractere charT(0)

daca n > size()

void resize(size_type n, charT c) Arunca exceptie out_of_range daca n >

npos. Altfel modifica dimensiunea sirului la n

prin trunchiere la sfârsit, daca n < size()

sau prin umplerea cu caractere c daca n >

size()

void reserve(size_type res_arg = 0)Seteaza capacity() la o valoare mai mare sau

egala cu res_arg. Deoarece în acest fel sirul

este alocat din nou, sunt golite referintele,

pointerii si iteratorii spre sir anteriori.

void clear() sterge toate caracterele din sir.

bool empty() const Returneaza true daca size() == 0

Accesul la siruri

Exista patru metode pentru accesul individual la caractere, doua care utilizeaza operatorul si doua care folosesc metoda at()

reference operator[](size_type pos);

const_reference operator[](size_type pos) const;

reference at(size_type n);

const_reference at(size_type n) const;

Prima metoda operator[]() va permite sa accesati un element individual al unui sir prin notatia de tablou; poate fi folosita pentru a obtine sau modifica valoarea. A doua metoda operator[]() poate fi folosita cu obiecte const si nu poate modifica valoarea, ci doar sa o obtina:

string cuvant("crama");

cout << cuvant[0]; // afiseaza c

cuvant[2] = 'i'; // suprascrie a cu i

const aparat("usturoi");

cout << aparat[2]; // afiseaza t

Metoda at() asigura un acces similar, dar indexul este furnizat ca argument de functie:

string cuvant("crama");

cout << cuvant.at(0); // afiseaza c

O alta diferenta (în afara de sintaxa) este ca metodele at() efectueaza verificari de limite, iar daca pos >= size() arunca o exceptie out_of_range. Observati ca pos este de tip size_type, care este fara semn, deci pos nu poate fi negativ. Metodele operator[]() nu fac verificari, deci comportamentul în cazul în care pos >= size() este nedefinit, exceptând versiunea const care returneaza echivalentul caracterului nul daca pos == size()

Prin urmare aveti de ales între siguranta (utilizând at() si testând exceptii) si viteza de executie (utilizând notatia tablou).

Mai exista o functie care returneaza un sir nou care este un subsir al sirului original:

basic_string substr(size_type pos = 0, size_type n = npos) const;

Returneaza un sir care este o copie a sirului care începe la pozitia pos si are n caractere sau se termina la sfârsitul sirului. De exemplu, instructiunea urmatoare initializeaza animal cu "magar"

string mesaj("Poate ca magarul va invata sa cante.");

string animal(mesaj.substr(9, 7));

Atribuirea de baza

Sunt trei metode de atribuire supraîncarcate:

basic_string& operator=(const basic_string& str);

basic_string& operator=(const charT* s);

basic_string& operator=(charT c);

Prima atribuie un obiect string la altul, a doua atribuie un sir în stil C la un obiect string, iar a treia atribuie un singur caracter la un obiect string. Prin urmare, sunt posibile urmatoarele operatii:

string nume ("George Wash");

string pres, bip, sursa;

pres = nume;

bip = "Road Runner";

sursa = 'X';

Cautarea în sir

Clasa string dispune de sase functii de cautare, fiecare având patru prototipuri. Le vom descrie pe scurt.

Familia find()

Iata prototipurile find()

size_type find(const basic_string& str, size_type pos = 0) const;

size_type find(const charT *s, size_type pos = 0) const;

size_type find(const charT *s, size_type pos, size_type n) const;

size_type find(charT c, size_type pos = 0) const;

Primul membru returneaza pozitia de la începutul primei aparitii a subsirului str în obiectul apelant; cautarea începând de la pozitia pos. Daca subsirul nu este gasit, metoda returneaza npos

string lung("Si cu asta basta");

string scurt("asta");

size_type loc1 = lung.find(scurt); // seteaza loc1 la 6

size_type loc2 = lung.find(scurt, loc1 + 1); // seteaza loc2 la 12

Deoarece a doua cautare începe de la pozitia 7 (s din asta), prima aparitie a asta pe care o gaseste este la sfârsitul sirului. Pentru a testa esecul, utilizati valoarea string::npos

if (loc1 == string::npos)

cout << "Nu s-a gasit\n";

A doua metoda face acelasi lucru, numai ca foloseste ca subsir un tablou de caractere, nu un obiect string

size_type loc3 = lung.find("cu"); // seteaza loc3 la 3

A treia metoda face acelasi lucru ca si a doua, numai ca foloseste doar primele n caractere ale sirului s. Produce acelasi efect cu utilizarea constructorului basic_string(const charT* s, size_type n) si folosirea rezultatului acestuia ca argument pentru prima forma a lui find(). De exemplu, în urmatorul cod este cautat subsirul "bas"

size_type loc4 = lung.find("basca", 3); // seteaza loc4 la 11

A patra metoda face acelasi lucru ca si prima, numai ca foloseste un singur caracter ca subsir, nu un obiect string

size_type loc5 = lung.find('a'); // seteaza loc5 la 6

Familia rfind()

Metodele rfind() au urmatoarele prototipuri:

size_type rfind(const basic_string& str, size_type pos = npos)

const;

size_type rfind(const charT *s, size_type pos = npos) const;

size_type rfind(const charT *s, size_type pos, size_type n) const;

size_type rfind(charT c, size_type pos = npos) const;

Aceste metode functioneaza analog cu metodele find(), dar gasesc ultima aparitie a unui sir sau a unui caracter care începe la sau înainte de pozitia pos. Daca subsirul nu este gasit se returneaza npos

string lung("Si cu asta basta");

string scurt("asta");

size_type loc1 = lung.rfind(scurt); // seteaza loc1 la 12

size_type loc2 = lung.rfind(scurt, loc1 - 1);// seteaza loc2 la 6

Familia find_first_of()

Metodele find_first_of() au urmatoarele prototipuri:

size_type find_first_of(const basic_string& str,

size_type pos = 0) const;

size_type find_first_of(const charT *s, size_type pos,

size_type n) const;

size_type find_first_of(const charT *s, size_type pos = 0) const;

size_type find_first_of(charT c, size_type pos = 0) const;

Aceste metode functioneaza analog cu metodele find(), dar în loc sa caute pentru o potrivire a întregului subsir, ele cauta prima potrivire a oricarui caracter din subsir.

string lung("Si cu asta basta");

string scurt("alba");

size_type loc1 = lung.find_first_of(scurt); // seteaza loc1 la 6

size_type loc2 = lung.find_first_of("acut"); // seteaza loc2 la 3

Prima aparitie a oricarui caracter din alba în lung este a în asta. Prima aparitie a oricarui din cele patru caractere din acut în lung este c în cu

Familia find_last_of()

Metodele find_last_of() au urmatoarele prototipuri:

size_type find_last_of(const basic_string& str,

size_type pos = npos) const;

size_type find_last_of(const charT *s, size_type pos, size_type n)

const;

size_type find_last_of(const charT *s, size_type pos = npos)

const;

size_type find_last_of(charT c, size_type pos = npos) const;

Aceste metode functioneaza analog cu metodele rfind(), dar în loc sa caute pentru o potrivire a întregului subsir, ele cauta ultima potrivire a oricarui caracter din subsir.

string lung("Si cu asta basta");

string scurt("asta");

size_type loc1 = lung.find_last_of(scurt); // seteaza loc1 la 15

size_type loc2 = lung.find_last_of("troc"); // seteaza loc2 la 14

Ultima aparitie a oricarui caracter din asta în lung este a în basta. Ultima aparitie a oricarui din cele patru caractere din troc în lung este t în basta

Familia find_first_not_of()

Metodele find_first_not_of() au urmatoarele prototipuri:

size_type find_first_not_of(const basic_string& str,

size_type pos = 0) const;

size_type find_first_not_of(const charT *s, size_type pos,

size_type n) const;

size_type find_first_not_of(const charT *s, size_type pos = 0)

const;

size_type find_first_not_of(charT c, size_type pos = 0) const;

Aceste metode functioneaza analog cu metodele find_first_of(), doar ca ele cauta prima aparitie a oricarui caracter care nu face parte din subsir.

string lung("Si cu asta basta");

string scurt("Sac");

size_type loc1 = lung.find_first_not_of(scurt);//seteaza loc1 la 1

size_type loc2 = lung.find_first_not_of(Sica);// seteaza loc2 la 2

i din Si este primul caracter din lung care nu apare în Sac. Primul spatiu din sirul lung este primul caracter care nu este în Sica

Familia find_last_not_of()

Metodele find_last_not_of() au urmatoarele prototipuri:

size_type find_last_not_of(const basic_string& str,

size_type pos = npos) const;

size_type find_last_not_of(const charT *s, size_type pos,

size_type n) const;

size_type find_last_not_of(const charT *s, size_type pos = npos)

const;

size_type find_last_not_of(charT c, size_type pos = npos) const;

Aceste metode functioneaza analog cu metodele find_last_of(), doar ca ele cauta ultima aparitie a oricarui caracter care nu face parte din subsir.

string lung("Si cu asta basta");

string scurt("asta");

size_type loc1 = lung.find_last_not_of(scurt);

// seteaza loc1 la 11

size_type loc2 = lung.find_last_not_of(scurt, 10);

// seteaza loc2 la 10

b în basta este ultimul caracter din lung care nu face parte din scurt. Ultimul spatiu din sirul lung este ultimul caracter care nu este din scurt, gasit pâna la pozitia 10.

Metode si functii de comparare

Clasa string ofera metode si functii pentru compararea a doua siruri. În primul rând, iata prototipurile:

int compare(const basic_string& str) const;

int compare(size_type pos1, size_type n1,

const basic_string& str) const;

int compare(size_type pos1, size_type n1,

const basic_string& str,

size_type pos2, size_type n2) const;

int compare(const charT* s) const;

int compare(size_type pos1, size_type n1,

const charT *s, size_type n2 = npos) const;

Aceste metode utilizeaza o metoda traits::compare() care este definita pentru tipul de caractere folosit de sir. Prima metoda returneaza o valoare mai mica decât 0 daca primul sir este înaintea celui de-al doilea în ordinea data de traits::compare(). Returneaza 0 daca sirurile sunt identice, si o valoare mai mare ca 0 daca primul sir îl urmeaza pe al doilea. Daca doua siruri sunt identice pâna la sfârsitul sirului mai scurt, atunci acesta îl precede pe cel mai lung.

string s1("clopotel");

string s2("clopot");

string s3("dangat");

int a13 = s1.compare(s3); // a13 < 0

int a12 = s1.compare(s2); // a12 > 0

A doua metoda se aseamana cu prima, doar ca utilizeaza doar n1 caractere începând cu pozitia pos1 din primul sir, pentru a efectua comparatia.

string s1("clopotel");

string s2("clopot");

int a2 = s1.compare(0, 6, s2); // a2 = 0

A treia metoda se aseamana cu prima, doar ca utilizeaza doar n1 caractere începând cu pozitia pos1 din primul sir si n2 caractere începând cu pozitia pos2 din al doilea sir pentru a efectua comparatia. De exemplu, urmatorul cod compara bust din robust cu bust din arbust

string st1("mistret robust");

string st2("iubea un arbust");

int a3 = st1.compare(10, 4, st2, 11, 4); //a3 este 0

A patra metoda este ca si prima, numai ca utilizeaza un tablou în loc de un obiect string pentru al doilea sir.

A cincea metoda este ca si a treia, numai ca utilizeaza un tablou în loc de un obiect string pentru al doilea sir.

Functiile de comparare care nu sunt membre sunt operatori relationali supraîncarcati:

operator==()

operator<()

operator<=()

operator>()

operator>=()

operator!=()

Fiecare operator este supraîncarcat astfel încât sa poata compara un obiect string cu un obiect string, un obiect string cu un sir tablou si un sir tablou cu un obiect string. Toti sunt definiti în functie de metoda compare(), deci ofera o modalitate de notare mai comoda a comparatiilor care se realizeaza.

Modificatori de siruri

Clasa string ofera mai multe metode pentru modificarea sirurilor. Cele mai multe prezinta versiuni supraîncarcate pentru a putea fi folosite cu obiecte string, cu tablouri, cu caractere individuale si intervale de iteratori.

Concatenare si adaugare

Puteti adauga un sir la altul utilizând operatorul supraîncarcat sau folosind metoda append(). Toate arunca o exceptie length_error daca rezultatul este mai mare decât dimensiunea maxima a unui sir. Operatorii va permit sa adaugati un obiect string, un tablou sau un caracter individual la un alt string

basic_string& operator+=(const basic_string& str);

basic_string& operator+=(const charT* s);

basic_string& operator+=(charT c);

Metodele append() de asemenea va permit sa adaugati un obiect string, un tablou sau un caracter individual la un alt string. În plus, va permit sa adaugati o parte a unui obiect string, specificând o pozitie initiala si numarul de caractere din sir care se vor adauga sau precizând un interval. Puteti adauga o parte a unui sir precizând câte caractere ale sirului se vor folosi. Versiunea care adauga un caracter va permite sa precizati de câte ori se va copia acel caracter.

basic_string& append(const basic_string& str);

basic_string& append(const basic_string& str, size_type pos,

size_type n);

template<class InputIterator>

basic_string& append(InputIterator first, InputIterator last);

basic_string& append(const charT *s);

basic_string& append(const charT *s, size_type n);

basic_string& append(size_type n, charT c); // adauga n copii ale

// lui c

Iata câteva exemple:

string test("Teo");

test.append("rie"); // test este "Teorie"

test.append(3, '!'); // test este "Teorie!!!"

Functia operator+() este supraîncarcata astfel încât sa permita concatenarea a doua siruri. Functia supraîncarcata nu modifica sirurile, ci creeaza un nou sir care este alcatuit dintr-un sir adaugat la celalalt. Functiile aditive nu sunt functii membre si va permit sa adaugati un obiect string la un obiect string, un tablou la un obiect string, un obiect string la un tablou, un caracter la un obiect string si un obiect string la un caracter. Iata câteva exemple:

string st1("alb");

string st2("astru");

string st3 = st1 + "ume"; // st3 este "albume"

string st4 = 'c' + st2; // st4 este "castru"

string st5 = st1 + st2; // st5 este "albastru"

Alte atribuiri

Pe lânga operatorul de atribuire de baza, clasa string contine si metodele assign() care va permit sa atribuiti un sir întreg, o parte dintr-un sir sau o secventa de caractere identice la un obiect string

basic_string& assign(const basic_string& str);

basic_string& assign(const basic_string& str, size_type pos,

size_type n);

basic_string& assign(const charT* s, size_type n);

basic_string& assign(const charT* s);

basic_string& assign(size_type n, charT c); // atribuie n copii

// ale lui c

template<class InputIterator>

basic_string& assign(InputIterator first, InputIterator last);

Iata câteva exemple:

string test;

string chestii("usi turnante pentru rate");

test.assign(chestii, 1, 5); // test este "si tu"

test.assign(6, '#'); // test este "######"

Metode de inserare

Metodele insert() va permit sa inserati un obiect string, un tablou, un caracter, sau mai multe caractere într-un obiect string. Metodele sunt similare cu metodele append(), dar preiau un argument suplimentar care indica pozitia în care se va insera noul material. Acest argument poate fi o pozitie sau un iterator. Materialul este inserat înaintea punctului de insertie. Câteva dintre metode returneaza o referinta la sirul rezultat. Daca pos1 este dincolo de sfârsitul sirului tinta iar pos2 este dincolo de sfârsitul sirului de inserat, metoda va arunca o exceptie out_of_range. Daca sirul rezultat are o lungime mai mare decât dimensiunea maxima, metoda arunca o exceptie length_error

basic_string& insert(size_type pos1, const basic_string& str);

basic_string& insert(size_type pos1, const basic_string& str,

size_type pos2, size_type n);

basic_string& insert(size_type pos, const charT* s, size_type n);

basic_string& insert(size_type pos, const charT* s);

basic_string& insert(size_type pos, size_type n, charT c);

iterator insert(iterator p, charT c = charT());

void insert(iterator p, size_type n, charT c);

template<class InputIterator>

void insert(iterator p, InputIterator first,

InputIterator last);

De exemplu, urmatorul cod insereaza sirul "fost " înainte de b în bancher

string st3("Acel bancher.");

st3.insert(5, "fost ");

Atunci, codul care urmeaza insereaza sirul " a valsat" (fara , care ar fi al zecelea caracter), chiar înainte de punctul de la sfârsitul sirului "Acel fost bancher."

st3.insert(st3.size() - 1, " a valsat!", 9);

Metode de stergere

Metodele erase() sterg caractere din sir. Iata prototipurile:

basic_string& erase(size_type pos = 0, size_type n = npos);

iterator erase(iterator position);

iterator erase(iterator first, iterator last);

Prima forma sterge n caractere de la pozitia pos spre sfârsit, sau toate caracterele pâna la sfârsit. A doua sterge caracterul indicat de iterator si returneaza un iterator la urmatorul element, sau daca nu mai exista elemente returneaza end(). A treia sterge caracterele din interval (first last; adica îl sterge pe first dar nu si pe last). Metoda returneaza un iterator la elementul care urmeaza dupa ultimul element sters.

Metode de înlocuire

Variatele metode replace() identifica o parte din sir care trebuie înlocuita si identifica si înlocuitorul. Partea care se înlocuieste poate fi identificata prin pozitie initiala si un numar de caractere sau printr-un interval de iteratori. Înlocuitorul poate fi un obiect string, un tablou sau un caracter duplicat de mai multe ori. Obiectele string sau tablourile înlocuitoare pot fi modificate indicând o portiune anume, prin pozitie si numar, doar prin numar sau un interval de iteratori.

basic_string& replace(size_type pos1, size_type n1,

const basic_string& str);

basic_string& replace(size_type pos1, size_type n1,

const basic_string& str, size_type pos2, size_type n2);

basic_string& replace(size_type pos, size_type n1, const charT* s,

size_type n2);

basic_string& replace(size_type pos, size_type n1,

const charT* s);

basic_string& replace(size_type pos, size_type n1, size_type n2,

charT c);

basic_string& replace(iterator i1, iterator i2,

const basic_string& str);

basic_string& replace(iterator i1, iterator i2, const charT* s,

size_type n);

basic_string& replace(iterator i1, iterator i2, const charT* s);

basic_string& replace(iterator i1, iterator i2,

size_type n, charT c);

template<class InputIterator>

basic_string& replace(iterator i1, iterator i2,

InputIterator j1, InputIterator j2);

Iata un exemplu:

string test("Pe bulevard o iei la dreapta si ajungi.");

test.replace(21, 7, "stanga"); // inlocuieste dreapta cu stanga

Alte metode de modificare: copy() si swap()

Metoda copy() copiaza un obiect string, sau doar o parte a sa într-un tablou:

size_type copy(charT* s, size_type n, size_type pos = 0) const;

Aici s indica tabloul de destinatie, n indica numarul de caractere ce se copiaza iar pos indica pozitia din obiectul string din care începe copierea. Copierea continua pâna la al n-lea caracter sau pâna la ultimul caracter din obiectul string. Functia returneaza numarul de caractere copiate. Metoda nu adauga caracterul nul si verificarea dimensiunii tabloului cade în sarcina programatorului.

Atentie

Metoda copy() nu verifica daca tabloul de destinatie este destul de mare pentru a pastra copia si nici nu adauga caracterul nul.

Metoda swap() schimba continutul a doua obiecte string utilizând un algoritm în timp constant:

void swap(basic_string<charT, traits, Allocator>&);

Intrari si iesiri

Clasa string supraîncarca operatorul << pentru a afisa obiecte string. Returneaza o referinta la obiectul istream pentru ca iesirea sa poata fi concatenata:

string pretentie("Clasa string are multe caracteristici.");

cout << pretentie << endl;

Clasa string supraîncarca operatorul >> pentru a putea introduce informatii în obiecte string

string cine;

cin >> cine;

Intrarea se opreste la EOF, la citirea numarului maxim de caractere permise într-un sir sau la un caracter alb. (Definitia caracterului alb depinde de setul de caractere si de tipul reprezentat de charT

Exista doua functii getline(). Prima are prototipul:

template<class charT, class traits, class Allocator>

basic_istream<charT, traits>&

getline(basic_istream <charT, traits>& is,

basic_string<charT, traits, Allocator>& str, charT delim);

Aceasta citeste caractere din fluxul de intrare is în sirul str pâna întâlneste caracterul de delimitare delim, ocupa spatiul maxim permis pentru un sir sau întâlneste EOF. Caracterul delim este citit (scos din fluxul de intrare), dar nu este stocat. A doua versiune nu are al treilea argument si foloseste în locul lui delim caracterul linie noua (sau generalizarea acestuia):

string str1, str2;

getline(cin, str1); // citeste pana la sfarsitul liniei

getline(cin, str2, '.'); // citeste pana la punct