Biblioteca de şabloane standard (Standard Template Library).

Biblioteca de Şabloane Standard (STL) asigură o abstractizare standardizată a datelor prin intermediul containerelor
şi o abstractizare procedurală prin intermediul algoritmilor.
Programele dezvoltate folosind STL beneficiază de o viteză de dezvoltare şi o viteză de execuţie sporite. Ele sunt mai
eficiente, mai robuste, mai portabile, mai uşor de modificat şi întreţinut.
Componentele STL sunt: containerele, iteratorii, algoritmii, functorii (obiectele funcţii) şi adaptorii.

Containere.
Un container este un obiect care păstrează o colecţie de alte obiecte. Containerele (exceptând string şi ) sunt clase
generice (parametrizate)
În STL se folosesc două tipuri de containere:
 containere secvenţiale (vector, listă, coadă cu două capete - deque)
 containere asociative (mulţime, relaţie)
Un container secvenţial păstrează colecţia de obiecte într-o ordine strict liniară.
Containerele asociative păstrează informaţiile din colecţie sortate, ceea ce permite regăsirea rapidă a obiectelor din
colecţie, pe baza unei chei.
Vectorul (vector)
Constructor Efect Complexitat
e
vector<T>v crează un vector vid O(1)
vector<T>v(n) crează un vector cu n elemente O(n)
vector<T>v(n,val) crează un vector cu n elemente iniţializate cu val O(n)
vector<T>v(v1) crează un vector iniţializat cu vectorul v1 O(n)

Accesor Efect Complexitate

v[i] întoarce elementul i O(1)
v.front() întoarce primul element O(1)
v.back() întoarce ultimul element O(1)
v.capacity() întoarce numărul maxim de elemente O(1)
v.size() întoarce numărul curent de elemente O(1)
v.empty() întoarce true dacă vectorul este vid O(1)
v.begin() întoarce un iterator la începutul vectorului O(1)
v.end() întoarce un iterator după sfârşitul vectorului O(1)

Modificator Efect Complexitat

e
v.push_back(val) adaugă o valoare la sfârşit O(1)
v.insert(iter,val) inserează valoarea în poziţia indexată de iterator O(n)
v.pop_back() şterge valoarea de la sfârşit O(1)
v.erase(iter) şterge valoarea indexată de iterator O(n)
v.erase(iter1,iter2) şterge valorile din domeniul de iteratori O(n)
Coada cu două capete (deque)
Constructor Efect Complexitate
deque<T>d crează un deque vid O(1)
deque<T>d(n) crează un deque cu n elemente O(n)
deque<T>d(n,val) crează un deque cu n elemente iniţializate cu val O(n)
deque<T>d(d1) crează un deque iniţializat cu deque-ul d O(n)

Accesor Efect Complexitate

d[i] întoarce elementul i O(1)
d.front() întoarce primul element O(1)
d.back() întoarce ultimul element O(1)
d.capacity() întoarce numărul maxim de elemente O(1)

1
d.size() întoarce numărul curent de elemente O(1)
d.empty() întoarce true dacă deque-ul este vid O(1)
d.begin() întoarce un iterator la începutul deque-ului O(1)
d.end() întoarce un iterator după sfârşitul deque-ului O(1)

Modificator Efect Complexitate

d.push_back(val) adaugă o valoare la sfârşit O(1) sau O(n)
d.insert(iter,val) inserează valoarea în poziţia indexată de iterator O(n)
d.pop_back() şterge valoarea de la sfârşit O(1)
d.erase(iter) şterge valoarea indexată de iterator O(n)
d.erase(iter1,iter2) şterge valorile din domeniul de iteratori O(n)
Lista (list)
Constructor Efect Complexitate
list<T>L crează o listă vidă O(1)
list <T>L(L1) crează o listă iniţializată cu lista L1 O(n)

Accesor Efect Complexitate

L.front() întoarce primul element O(1)
L.back() întoarce ultimul element O(1)
L.size() întoarce numărul curent de element O(1)
L.empty() întoarce true dacă lista este vidă O(1)
L.begin() întoarce un iterator la începutul listei O(1)
L.end() întoarce un iterator după sfârşitul liste O(1)

Modificator Efect Complexitate

L.push_front(val) adaugă o valoare la început O(1)
L.push_back(val) adaugă o valoare la sfârşit O(1)
L.insert(iter,val) inserează valoarea în poziţia indexată de iterator O(1)
L.pop_front() şterge valoarea de la început O(1)
L.pop_back() şterge valoarea de la sfârşit O(1)
L.erase(iter) şterge valoarea indexată de iterator O(1)
L.erase(iter1,iter2) şterge valorile din domeniul de iteratori O(1)
L.remove(val) şterge toate apariţiile lui val în listă O(n)
L.remove_if(pred) şterge toate elementelele care satisfac predicatul O(n)
L.reverse(pred) inversează lista O(n)
L.sort() sortează lista O(nlogn)
L.sort(comp) sortează lista folosind funcţia de comparaţie O(nlogn)
L.merge(L1) interclasează două liste sortate O(n)

Stiva (stack)
Constructor Efect Complexitate
stack<T>s crează o stivă vidă O(1)

Accesor Efect Complexitat

e
s.top() întoarce elementul din vârf O(1)
s.size() întoarce numărul curent de elemente O(1)
s.empty() întoarce true dacă stiva este vidă O(1)

Modificator Efect Complexitate

s.push(val) pune o valoare în vârful stivei O(1)
s.pop() şterge valoarea din vârful stivei O(1)

Coada (queue)
Constructor Efect Complexitat
e
queue<T>q crează o coadă vidă O(1)

Accesor Efect Complexitat

2
 e
q.front() întoarce elementul din faţa cozii O(1)
q.back() întoarce elementul din spatele cozii O(1)
q.size() întoarce numărul curent de elemente O(1)
q.empty() întoarce true dacă coada este vidă O(1)

Modificator Efect Complexitate

q.push(val) pune o valoare în spatele cozii O(1)
q.pop() şterge valoarea din faţa cozii O(1)

Coada prioritară(priority queue)

Constructor Efect Complexitat
e
priority_queue<T,comp>q crează o coadă prioritarăvidă, sortată cu comp O(1)

Accesor Efect Complexitate

q.top() întoarce elementul “cel mai prioritar” (mai “mare”) O(1)
q.size() întoarce numărul curent de elemente O(1)
q.empty() întoarce true dacă coada prioritară este vidă O(1)

Modificator Efect Complexitate

q.push(val) inserează o valoare în coada prioritară O(logn)
q.pop() scoate elementul cel mai “mare” din coada prioritară O(1)

Mulţimi şi multimulţimi (set)

Mulţimile păstrează obiecte sortate cu operatorul < (care poate fi supraîncărcat), pentru a fi
regăsite rapid. Într-o mulţime, un element apare o singură dată. Într-o multimulţime pot apare mai multe
copii ale unui element.
Constructor Efect Complexitate
set<tip_ch,comp_ch>m crează o mulţime vidă; sortarea elementelor se face cu O(1)
comp_ch

Accesor Efect Complexitate

m.find(ch) întoarce un iterator la apariţia cheii în m (m.end(), dacă găseşte O(log n)
cheia în m)
m.lower_bound(ch) întoarce un iterator la prima apariţie a cheii în m (m.end(), dacă O(log n)
nu găseşte cheia în m)
m.upper_bound(ch) întoarce un iterator la primul element mai mare ca cheia în m O(log n)
(m.end(), dacă nu există un asemenea element)
m.equal_range(ch) întoarce pair<lower_bound(ch),upper_bound(ch)> O(log n)
m.count(ch) întoarce numărul de elemente egale cu cheia ch în m O(log n)
m.size() întoarce numărul curent de elemente O(1)
m.empty() întoarce true dacă coada prioritară este vidă O(1)
m.begin() întoarce un iterator la primul element (cel mai mic)din m O(1)
m.end() întoarce un iterator la ultimul element (cel mai mare)din m O(1)

Modificator Efect Complexitat

e
m.insert(iter,ch) inserează un element ch în m. Întoarce iterator la elementul ch din m O(log n)
m.insert(ch) inserează un element ch în m.Întoarce pair<iterator,bool> O(log n)
bool este true dacă inserarea a avut loc. Iterator indică cheia inserată

Relaţii şi multirelaţii (map)

Relaţiile pot fi privite ca vectori generalizaţi, în care locul indicelui întreg îl ia cheia, care poate fi de orice tip, motiv
pentru care relaţiile se mai numesc şi tabele asociative. Memorarea unei perechi <cheie, valoare> poate fi făcută prin
atribuirea map[ch]=val. Relaţiile se implementează cu arbori de căutare echilibraţi (de exemplu arbori roşii-negri), care
asigură timpi de căutare-regăsire logaritmici.. Dacă perechea <cheie, valoare> nu există în relaţie, indexarea map[ch]
crează o intrare falsă în relaţie, motiv pentru care se caută cheia în prealabil cu map.find(ch).

3
Constructor Efect Complexitate
map<tip_ch,tip_val,comp_ch>r crează o relaţie vidă; sortarea elementelor după O(1)
cheie se face cu comp_ch

Accesor Efect Complexitat

e
r[ch] întoarce valoarea accesată prin cheie O(log n)
r.find(ch) întoarce un iterator la perechea cheie-valoare (r.end(), dacă nu găseşte cheia în r) O(log n)
r.size() întoarce numărul curent de elemente O(1)
r.empty() întoarce true dacă relaţia este vidă O(1)
r.begin() întoarce un iterator la prima pereche din r O(1)
r.end() întoarce un iterator la ultima pereche din r O(1)

Modificator Efect Complexitate

r[ch]=val memorează perechea cheie-valoare în r O(log n)
m.insert(pereche) are acelaşi efect O(log n)