`std::forward_list` în C++

Listă simplu înlănțuită: fiecare nod știe doar de următorul. Ocupă mai puțină memorie decât std::list.

Sintaxă

#include <forward_list>

std::forward_list<T> nume;
void push_front(const T& valoare);
iterator insert_after(const_iterator poz, const T& valoare);
iterator erase_after(const_iterator poz);

Ce face `std::forward_list`

std::forward_list este varianta minimală a listei: se poate parcurge doar înainte, se adaugă doar la început (push_front) și nu are size() (ca să nu țină un contor în plus). Fiecare nod are un singur pointer, deci consumă mai puțină memorie decât std::list.

Pentru că un nod nu își cunoaște predecesorul, inserarea și ștergerea se fac după o poziție: insert_after, erase_after, emplace_after. Ca să lucrezi chiar la început, există before_begin(), o poziție aflată înaintea primului element.

Are și sort, remove, unique, reverse, merge și splice_after, la fel ca std::list.

Parametri

Parametru	Descriere
`poz`	Pentru `insert_after`/`erase_after`: elementul după care se inserează sau se șterge.
`valoare`	Elementul de adăugat.

Ce returnează

insert_after: iterator la elementul inserat. erase_after: iterator la elementul de după cel șters.

Exemple

Exemplul 1: Adăugare la început și după o poziție

#include <forward_list>
#include <iterator>
#include <print>

int main() {
    std::forward_list<int> l{2, 4, 8};
    l.push_front(1);
    auto it = std::next(l.begin(), 2);     // elementul 4
    l.insert_after(it, 6);                 // după 4
    std::println("{}", l);

    l.erase_after(l.before_begin());       // șterge primul element
    std::println("{}", l);
    std::println("Elemente: {}", std::distance(l.begin(), l.end()));
}

Rezultat

[1, 2, 4, 6, 8]
[2, 4, 6, 8]
Elemente: 4

Greșeli frecvente

Cauți l.size() sau l.push_back(): nu există. Numără cu std::distance(l.begin(), l.end()) și adaugă la început; dacă ai nevoie de ele, folosește std::list.
Încerci să ștergi chiar elementul indicat de un iterator. Funcția este erase_after: șterge elementul de după iterator. Păstrează iteratorul anterior.

Comenzi înrudite

std::list: Listă dublu înlănțuită: inserare și ștergere rapidă oriunde, fără invalidarea celorlalte elemente, dar fără acces după poziție.
std::distance: Numără câte poziții sunt între doi iteratori, adică câte elemente are intervalul [prim, ultim).
std::next: std::next returnează un iterator mutat cu n poziții înainte, std::prev unul mutat înapoi; originalul rămâne neschimbat.

Ce face std::forward_list