TDA String.

Şirul de caractere este un container de tip secvenţă. Clasa string este construită folosind şablonul
basic_string
Un operand de tip secvenţă poate fi specificat în mai multe moduri, şi anume:
- c - o secvenţă cu un element cu valoarea c
- n, c – o secvenţă de n elemente cu valoarea c
- s – o secvenţă terminată prin 0 (în genul şirurilor de caractere C)
- s, n – o secvenţă de n caractere, începând din s
- str – o secvenţă specificată de un obiect string
- str, pos, n – un subşir
- prim, ultim – o secvenţă delimitată de doi iteratori

1.Exemple de utilizare.
Faţă de şirurile de caractere stil C, avem următoarele avantaje:
 operaţii de nivel înalt: append(), concat(), insert(), replace()
 atribuirea de şiruri
 comparaţii de şiruri folosind operatorii: <, =, >
Exemplul 1: Detectarea unui şir palindrom.
//test palindrom
bool pal1(string& s){
string t;
t = s;
reverse(t.begin(), t.end());
return s==t;
};

//se convertesc toate literele in mici

int pal2(string& s){
string mic(s);
transform(s.begin(),s.end(),mici.begin(),tolower);
return pal1(mici);
};

void transform(iterator start, iterator stop, iterator dest, char (*f)(char)){

while(start!=stop)
dest++ =f(*start++);
};

//se elimină toate semnele de punctuaţie

int pal3(string& s){
string punct=” ,.:;!?\n”
string t=remove_all(s,punct);
return pal2(t);
};

string remove_all(string& txt, string& sep){

string rez;
int ltx=txt.length();
int lsp=sep.length();
for(int i=0; i<ltx; i++){
string car=txt.substr(i,1);
int poz=sep.find(car,0);
if(poz<0 || poz>lsp)
rez+=car;
};
return rez;
};
Exemplul 2: Separarea cuvintelor dintr-o linie.
void split(string& txt, string& sep, vector<string>cuv){

1
 int ltx=txt.length();
int start=txt.find_first_not_of(sep,0);
while(start>=0 && start<ltx){
int stop=txt.find_first_of(sep,start);
if(stop<0 || stop>ltx)
stop=ltx;
cuv.push_back(txt.substr(start, stop-start);
start=txt.find_first_not_of(sep,stop+1);
};
};

Exemplul 3: Găsirea primului şi ultimului cuvânt ordonat lexicografic dintr-un şir.

void main(){
string txt=”Un text la proba de comparatie cuvinte”;
string mic=”mijloc”;
string mare=”mijloc”;
list<string> cuv;
split(txt, ” ,.:;!?\n”, cuv);
list<string>::iterator crt;
list<string>::iterator stop=cuv.end();
for(crt=cuv.begin(); crt!=stop; ++crt){
if(*crt<mic)
mic=*crt;
if(*crt>mare)
mare=*crt;
};
cout<<mic<<endl;
cout<<mare<<endl;
};

2. Operaţii cu şiruri.
1. Declararea unei variabile şir:
string s1; //şir C++ neiniţializat
string s2(“ion”);//şir C++ iniţializat cu şir C
string s3(s2); //şir C++ iniţializat cu alt şir
2.Accesul la caracter:
//acces la caracter prin indexare
s2[0]=’B’;
//selecţie subşir de lungime 3 pornind din poz.2
string s3=s2.substr(2, 3);//
//conversie şir C++ în şir C
string nume;
FILE* f=fopen(nume.c_str(),”r”);
3.Lungime şir
s.length(); //numar de caractere din sir
s.resize(100,’x’);//schimba dim.la 100 si-l umple cu ‘x’
s.empty(); //test sir vid
4.Atribuire si concatenare
s=s1; //atribuire de sir
s+=s1; //adauga s1 la s
s1+s2 //sir format prin concatenare s1 cu s2
5.Iteratori
string::iterator i; //declarare iterator
s.begin(); //iterator de pornire
s.end(); //iteratorul dupa ultimul element
6.Inserări, ştergeri, înlocuiri
s.insert(pos,s1); //insereaza s1 in s dupa pos
s.remove(st,p); //sterge p caractere din s, dupa st
s.replace(st,l,s1);//insereaza s1 in s,inlocuind l car

2
7.Comparaţii
s1==s2, s1!=s2, s1<s2, s1>s2, s1<=s2, s1>=s2
8.Operaţii de căutare
s.find(s1); //cauta in s unde incepe s1
s.find(s1,pos); //idem, incepand cautarea din pos
s.find_first_of(s1,pos);//determina prima aparitie a primului caracter din s in s1
//pornind din pos
s.find_first_not_of(s1,pos);//determina prima aparitie a primului caracter din s
// ce nu e in s1 pornind din pos

9.Intrări / ieşiri
stream << s; //inserare s in stream
stream >> s; //extractie s din stream
getline(stream, s, sep);//citeste o linie din stream in s, terminata prin sep
O variabilă string poate primi prin atribuire:
 un alt string
 un literal
 un caracter
 un tablou de caractere stil C
Funcţiile begin() şi end() întorc iteratori cu acces direct de început şi sfârşit de şir.
Caracteristicile setului de caractere folosit(ASCII sau UNICODE) sunt descrise în structura char_traits.
Prin indexare se asigură acces la un caracter din string fără verificarea domeniului; accesul cu verificare este asigurat de
funcţia at().

3.Implementare TDA string.

class string{
public:
typedef char* iterator;
typedef int(*pfi)(int);//pointer la functie
//constructori
string(); //constructor implicit
string(char*s); //constructor de initializare
string(string&);//constructor de copiere
~string(); //destructor
//iteratori
iterator begin();
iterator end();
//functii generale
int empty();
int length();
void resize(int, char);
//intoarce un string obtinut cu elemente din pozitia p o obiectului, de lungime l
string substr(int p, int l);
//intoarce prima pozitie din obiect, (cautarea incepand din p), a stringului str
int find(string& str, int p=0);
int find(char c, int p=0);
int find(const char* s, int p=0 );
//intoarce prima pozitie din obiect(cautarea incepand din p),a unui element a lui s
int find_first_of(string& s, int p);
//intoarce prima pozitie din obiect, (cautarea
//incepand din p), a unui element care nu e in s
int find_first_not_of(string& s, int p);
//insereaza in sir, inaintea pozitiei p un
//operand secventa(sub toate formele prezentate)
string& insert(int p, char* s);
string& insert(int p, char* s,int n);
string& insert(int p, const string& str);

3
 string& insert(int p, const string& str,int pos, int n);//insereaza un subsir
void insert(iterator it,iterator pr,iterator u);
//inlocuieste in obiectul string in pozitia p, n caractere printr-un operand
//secventa
string& replace(int p, int n, const char *s);
string& replace(int p, int n,const E *s, int n);
string& replace(int p, int n,const string& str);
string& replace(int p, int n,const string& str, int pos, int n0);
string& replace(int p, int n0, int n, char c);
string& replace(iterator pr, iterator ul, const char *s);
string& replace(iterator pr, iterator ul, const char *s, int n);
string& replace(iterator pr, iterator ul, const string& str);
string& replace(iterator pr, iterator ul, int n, char c);
string& replace(iterator pr, iterator ul, const_iterator p, const_iterator u);
char& operator[](int);
void operator=(string&);
void operator+=(string&);
friend int operator==(string&, string&);
friend int operator!=(string&, string&);
friend int operator<(string&, string&);
friend int operator<=(string&, string&);
friend int operator>(string&, string&);
friend int operator>=(string&, string&);
protected:
char* buf;
int lb;
}
Algoritmii generici sunt folosiţi şi de celelalte containere. Pentru a fi generali (independenţi de tipul containerului) ei
folosesc ca parametrii iteratorii, iar tipurile acestora sunt parametrizate, apărând în şabloane.
//algoritmi generici
//inverseaza elementele in [p,u)
template <class BidIt>
void reverse(BidIt p, BidIt u);
//intoarce nr.valori din [p,u) egale cu val(aceeasi valoare in cont)
template <class InIt,class T>
size_t count(InIt p, InIt u, const T& val, int& cont);
//intoarce numarul de valori din [p,u) care satisfac predicatul p (acelasi in cont)
template <class InIt,class Pred,class Dist>
size_t count_if(InIt p, InIt u, Pred p, Dist& cont);
//pune la d transformatele cu uop ale elementelor din [p,u),
//intoarce capatul drept al destinatiei
template <class InIt,class OutIt, class Unop>
OutIt transform(InIt p,InIt u,OutIt d,Unop uop);
//pune in d valoarea obtinuta aplicand Binop la2 termeni din intervalele
//[p1,u1) si [p2,u2)
template <class InIt1,class InIt2,class OutIt,class Binop>
OutIt transform(InIt1 p1, InIt1 u1, InIt2 p2, OutIt d, Binop bop);
//intoarce pozitia primei aparitii a lui val pt. elementele containerului din
//intervalul [p,u)
template <class InIt, class T>
InIt find(InIt p, InIt u, const T& val);
//intoarce pozitia primei valori din [p,u) care satisface predicatul pr
//(u daca nu gaseste)
template <class InIt, class Pred>
InIt iterator find_if(InIt p, InIt u, Pred pr);
//inlocuieste in [p,u) toate aparitiile vv cu vn
template <class FwdIt, class T>
void replace(FwdIt p, FwdIt u, T& vv, T& vn);

4
//inlocuieste in [p,u) toate elementele care satisfac predicatul pr cu vn
template <class FwdIt, class Pred, class T>
void replace_if(FwdIt p, FwdIt u,Pred pr,T& vn);
//sorteaza elementele din intervalul [p,u) cu operatorul <
template <class RanIt>
void sort(RanIt p, RanIt u);
//sorteaza elementele din intervalul [p,u) cu operatorul pr
template <class RanIt, class Pred>
void sort(RanIt p, RanIt u, Pred pr);
//copiaza elementele din [p,u) incepand de la d
template <class InIt, class OutIt>
OutIt copy(InIt p,InIt u,OutIt d);
//determina prima pozitie din [p1,u1) pt care elementul este egal cu un element din
//[p2,u2), adica primul i pt care *(p1+i)==*(p2+j)
template <class FwdIt1, class FwdIt2>
FwdIt1 find_first_of(FwdIt1 p1,FwdIt1 u1, FwdIt2 p2,FwdIt2 u2);
//determina prima pozitie i din [p1,u1) pt care elementul *(p1+i) satisface
//predicatul pr cu un element din [p2,u2),adica pr(*(p1+i),*(p2+j))
template <class FwdIt1, class FwdIt2, class Pred>
FwdIt1 find_first_of(FwdIt1 p1,FwdIt1 u1, FwdIt2 p2,FwdIt2 u2,Pred pr);
//plaseaza aleatoriu elementele din [p,u)
template <class RanIt>
void Random_Shuffle(RanIt p,RanIt u);
// clasa string simplificata
# include <string.h>
# include <assert.h>
class string{
public:
string(); //c-tor implicit
string(char* cp); //c-tor de initializare
string (string & str); //c-tor de copiere
~string(){delete [ ] buf;} //d-tor
void operator = (string & str); //operator de atribuire
resize (unsigned int lgnoua, char fil); //alocare memorie
int length (); //lungime sir
bool empty (){return buf[0] == '\0';}; //test string vid
char & operator [ ] (unsigned int index); //operator de indexare
string substr (int start, int lung); //creere subsir
char * begin (){return buf;}; //iterator de pornire
char * end (){return buf + length();}; //iterator de dupa sfarsit
void remove (int start, int lung); //stergere portiune din string
void insert (int pos, string & sirnou); //inserare sir nou incepand cu pos
void replace (int start, int lung, string & sirnou); //inlocuire cu sirnou
void operator += (string & right);
friend string operator + (string & st, string & dr);
friend int operator < (string & st, string & dr);
int find (string & dest, int start); //cautare subsir incepand cu start
private:
int lgbuf;
char* buf;
};

// initializare string vid

string::string (){
buf = 0;
resize (0, ' '); // aloca buffer de lungime zero
}

// initializaree string cu sir tip C

string::string (char * cp){
buf = 0;

5
 resize (strlen(cp), ' '); // aloca buffer
strcpy (buf, cp); // copiere sir
}

// initializare string cu argument string

string::string (string & str){
buf = 0;
resize (str.length(), ' '); // aloca buffer
strcpy (buf, str.buf); // copiere string argument
}

// supraincarcare atribuire
void string::operator = (string & str){
resize (str.length(), ' ');
strcpy (buf, str.buf);
}

void string::resize (int lgnoua, char fil)

{
// daca nu exista buffer, lungimea este zero
if (buf == 0)
lgbuf = 0;
// caz 1, spatiu mai mic
if (lgnoua < lgbuf) {
// adauga caracter nul
buf[lgnoua] = '\0';
}
else { // caz 2, spatiu mai mare
// aloca buffer nou, cu spatiu pentru caracter nul
int i;
char * bufnou = new char[lgnoua + 1];
assert (bufnou != 0);
// copiere caractere existente
for (i = 0; i < lgbuf && buf[i] != '\0'; i++)
bufnou[i] = buf[i];
// adauga caractere de umplere
for ( ; i < lgnoua; i++)
bufnou[i] = fil;
// adauga caracter nul
bufnou[i] = '\0';
// eliberare zona veche
if (buf != 0)
delete [ ] buf;
buf = bufnou;
lgbuf = lgnoua;
}
}

// lungime string
int string::length (){
for (int i = 0; i < lgbuf; i++)
if (buf[i] == '\0')
return i;
return lgbuf;
}

// supraincarcare operator de indexare

char & string::operator [ ] (int index){
assert (index <= lgbuf);
return buf[index];
}

// formare subsir
string string::substr (int start, int lung){
assert (start + lung <= length());

6
 string sub; // subsir rezultat
sub.resize (lung, ' '); // dimensionare
for (int i = 0; i < lung; i++)
sub[i] = buf[start + i]; // copiere din sir
return sub;
}

// sterge lung caractere incepand cu start

void string::remove (int start, int lung){
// calcul unde se termina zona stearsa
int stop = start + lung;
// muta caractere
while ((stop < lgbuf) && (buf[stop] != '\0'))
buf[start++] = buf[stop++];
buf[start] = '\0';
}

// inserare sirnou, incepand din pos

void string::insert (int pos, string & sirnou){
int lung = length(); // lungime curenta
int lgss = sirnou.length(); // lungime suplimentara
int lgnoua = lung + lgss; // lungime noua

// daca estenecesar, realoca buffer

resize(lgnoua, '\0');

// muta caractere existente

for (int i = lung; i > pos; i--)
buf[i + lgss] = buf[i];

// inserare caractere noi

for (int i = 0; i < lgss; i++)
buf[pos + i] = sirnou[i];
}

// inlocuieste intre start si start + lung sirnou

void string::replace (int start, int lung, string & sirnou){
remove (start, lung);
insert (start, sirnou);
}

// adauga argumentul string la sfarsitul stringului curent

void string::operator += (string & right){
insert (length(), right);
}

// concatenare doua stringuri

string operator + (string & st, string & dr){
string clone(left); // copiere argument stang
clone += right; // adauga argument drept
return clone; // intoarce rezultat
}

# if 0 // daca este deja defined, apare o eroare de compilare

// test mai mic lexicografic
int operator < (string & st, string & dr){
return strcmp(st.buf, dr.buf) < 0;
}
# endif

// cauta sirul destinatie

int string::find (string & dest, int start){
int lgdest = dest.length();
// stop este ultima pozitie posibla de start
int stop = length() - lgdest;

7
 for (int i = start; i <= stop; i++) {
string text = substr(i, lgdest);
if (text == dest)
return i;
}
// nu s/a gasit subsir, intoarce indice in afara domeniului
return lgbuf;
}