STL - partea II

Funcții comune tuturor containerelor STL

• empty

  bool empty() const noexcept;
  

  Returnează false dacă setul are elemente și true dacă nu are.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6 };
  
  std::cout << data.empty();
  // Se afișează: false
  

  - ### size

  size_type size() const noexcept;
  

  Returnează numărul de elemente dintr-un set.

  Exemplu

  std::map<int, char> data {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  std::cout << data.size();
  // Se afișează: 4
  

  Funcții comune pentru vector, set, map și deque

  • clear

    void clear() noexcept;
    

    Șterge toate elementele din container.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6 };
  
  data.clear();
  std::cout << data.size();
  // Se afișează: 0
  

  - ### insert

  std::pair<iterator, bool> insert( const value_type& value );
  

  Inserează value în container.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6 };
  
  data.insert(10);
  std::cout << data.size();
  // Se afișează: 5
  

  Pentru mai multe, a se consulta documentația vector | set | map | deque. - ### erase

  1. iterator erase( const_iterator pos );
  2. iterator erase( const_iterator first, const_iterator last );
  

  1. Șterge elemetul de la poziția pos. 2. Șterge elementele dintre pozițiile first și last.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6 };
  
  auto bg = data.begin();
  auto ed = data.end();
  data.erase(bg, ed);
  
  std::cout << data.size();
  // Se afișează: 0
  

<set>

Setul este un container STL asociativ, care conține sortate obiecte de tipul Key. Acestea sunt sortate cu ajutorul unei funcții de comparare, în funcție de Key. Căutarea, eliminarea și inserarea elementelor se realizează în complexitate logaritmică.

• count

  size_type count( const Key& key ) const;
  

  Returnează numărul de elemente cu cheia key. Aceasta este fie 0 fie 1, deoarece seturile nu permit duplicate.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6, 1 };
  
  
  std::cout << data.count(1) << ' ';
  std::cout << data.count(3);
  // Se afișează: 1 0
  

  - ### find

  iterator find( const Key& key );
  const_iterator find( const Key& key ) const;
  

  Găsește un element cu cheia key echivalentă cheii din set și returnează un pointer. Dacă nu găsește, este returnat iteratorul end().

  Exemplu

  std::set<int> data = { 1, 4, 5, 6, 1 };
  
  if (data.find(5) != data.end()) {
      std::cout << "found";
  } 
  // Se afișează: found
  

  - ### contains

  bool contains( const Key& key ) const;
  

  Verifică dacă există un element cu cheia key în set.

  Exemplu

  std::set<int> data = { 1, 4, 5, 6, 1 };
  
  if (data.contains(5)) {
      std::cout << "found";
  } 
  // Se afișează: found
  

<map>

Mapul este un container STL asociativ, care conține sortate obiecte pereche care conțin o cheie și o valoare. Acestea sunt sortate cu ajutorul unei funcții de comparare, în funcție de Key. Căutarea, eliminarea și inserarea elementelor se realizează în complexitate logaritmică. Acestea sunt un fel de dicționare, permitând accesul rapid la date.

• at

  T& at( const Key& key );
  const T& at( const Key& key ) const;
  

  Returnează o referință la elementul din map cu cheia key. Dacă nu există, aruncă o excepție.

  Exemplu

  std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  std::cout << data.at(1);
  // Se afișează: a
  

  - ### operator []

  T& operator[]( const Key& key );
  

  Returnează o referință la elementul din map cu cheia key. Dacă nu există, inserează cheia respectivă (Din această cauză nu se recomandă folosirea lui).

  Exemplu

  std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  std::cout << data[1];
  // Se afișează: a
  

  - ### count

  size_type count( const Key& key ) const;
  

  Returnează numărul de elemente cu cheia key. Aceasta este fie 0 fie 1, deoarece mapurile nu permit duplicate.

  Exemplu

  std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  
  std::cout << data.count(1) << ' ';
  std::cout << data.count(4);
  // Se afișează: 1 0
  

  - ### find

  iterator find( const Key& key );
  const_iterator find( const Key& key ) const;
  

  Găsește un element cu cheia key echivalentă cheii din map și returnează un iterator. Dacă nu găsește, este returnat iteratorul end().

  Exemplu

  std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  if (data.find(5) != data.end()) {
      std::cout << "found";
  } 
  // Se afișează: found
  

  - ### contains

  bool contains( const Key& key ) const;
  

  Verifică dacă există un element cu cheia key în map.

  Exemplu

  std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
  
  if (data.contains(5)) {
      std::cout << "found";
  } 
  // Se afișează: found
  

Update prin referință

O modalitate comodă de a actualiza elementele din map este prin referință, deoarece nu trebuie să le mai căutăm de fiecare data în map. Exemplu

std::map<int, char> data = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};
char& obj = data.at(1);
obj = 'b';

std::cout << data.at(1);
// Se afișează: b

<stack>

Stackul este un container STL care se oferă funcționalitatea unei stive, după principiul ultimul intrat, primul ieșit. - ### top

const_reference top() const;

Returnează valoarea din vârful stivei.

**Exemplu**
```cpp
std::stack<int> s;
s.push(2);
s.push(4);

std::cout << s.top();
// Se afișează: 4
```

• push

  cpp void push( const value_type& value ); Adaugă elementul value în stivă.

  Exemplu

  std::stack<int> s;
  s.push(2);
  
  std::cout << s.top();
  // Se afișează: 2
  

  - ### pop

  void pop();
  

  Elimină elementul din vârful stivei.

  Exemplu

  std::stack<int> s;
  s.push(2);
  s.push(4);
  
  s. pop();
  std::cout << s.top();
  // Se afișează: 2
  

<queue>

Queueul este un container STL care se oferă funcționalitatea unei cozi, după principiul primul intrat, primul ieșit. - ### front

reference front();
const_reference front() const;

Returnează prima valoare din coadă.

**Exemplu**
```cpp
std::queue<int> q;
q.push(2);
q.push(4);

std::cout << q.front();
// Se afișează: 2
```

• back

  cpp reference back(); const_reference back() const; Returnează ultima valoare din coadă.

  Exemplu

  std::queue<int> q;
  q.push(2);
  q.push(4);
  
  std::cout << q.back();
  // Se afișează: 4
  

  - ### push

  void push( const value_type& value );
  

  Adaugă elementul value în coadă.

  Exemplu

  std::queue<int> q;
  q.push(2);
  
  std::cout << q.front();
  // Se afișează: 2
  

  - ### pop

  void pop();
  

  Elimină primul element al cozii.

  Exemplu

  std::queue<int> q;
  q.push(2);
  q.push(4);
  q.pop();
  
  std::cout << q.front();
  // Se afișează: 2
  

<deque>

Dequeul este un container STL care permite inserția și eliminarea elementelor la ambele capete ale sale. Din această cauză, dequeul este scalabil, dar nu foarte eficient, acesta fiind evitat în programarea competitivă, folosindu-se alte modalități, cum ar fi 2 stive. - ### at

reference       at( size_type pos );
const_reference at( size_type pos ) const;

Returnează o referință la elementul din deque aflat la poziția pos. Dacă nu există, aruncă o excepție.

**Exemplu**
```cpp
std::deque<int> data = { 1, 2, 4, 5, 5, 6 };

std::cout << data.at(1);
// Se afișează: 2
```

• operator []

  cpp reference operator[]( size_type pos ); const_reference operator[]( size_type pos ) const; Returnează o referință la elementul din deque aflat la poziția pos, fără a verifica dacă există. Exemplu cpp std::deque<int> data = { 1, 2, 4, 5, 5, 6 }; std::cout << data[1]; // Se afișează: 2

• front

  cpp reference front(); const_reference front() const; Returnează primul element din deque.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  std::cout << data.front();
  // Se afișează: 1
  

  - ### back

  reference back();   
  const_reference back() const;
  

  Returnează ultimul element din deque.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  std::cout << data.back();
  // Se afișează: 6
  

  - ### push_back

  void push_back( const T& value );
  void push_back( T&& value );
  

  Adaugă value la finalul dequeului.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  data.push_back(7);
  std::cout << data[6];
  // Se afișează: 7
  

  - ### pop_back

  void pop_back();
  

  Elimină ultimul element al dequeului.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  data.pop_back();
  std::cout << data.size[4];
  // Se afișează: 5
  

  - ### push_front

  void push_front( const T& value );
  void push_front( T&& value );
  

  Adaugă value la începutul dequeului.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  data.push_front(7);
  std::cout << data[0];
  // Se afișează: 7
  

  - ### pop_front

  void pop_front();
  

  Elimină primul element al dequeului.

  Exemplu

  std::deque<int> data = { 1, 2, 4, 5, 5, 6 };
  
  data.pop_front();
  std::cout << data[0];
  // Se afișează: 2