std::allocator în C++

std::allocator<T> a;
T* allocate(std::size_t n);
void deallocate(T* p, std::size_t n);

Ce face std::allocator

Toate containerele standard (vector, map…) primesc un alocator ca ultim parametru de șablon; implicit este std::allocator<T>, care folosește new/delete în spate.

allocate(n) rezervă memorie pentru n obiecte, dar nu le construiește. Obiectele se creează cu std::construct_at și se distrug cu std::destroy_at, apoi memoria se eliberează cu deallocate(p, n), cu același n.

În programele obișnuite nu ai nevoie de el direct. Îl întâlnești când scrii propriul container sau un alocator personalizat (de exemplu pentru un pool de memorie).

Parametri

Parametru	Descriere
n	Numărul de obiecte pentru care se rezervă memorie.
p	Pentru deallocate: pointerul primit de la allocate.

Ce returnează

allocate returnează un T* către memoria rezervată (neinițializată).

Exemple

Exemplul 1: Alocare, construire, distrugere, eliberare

Exact pașii pe care îi face un std::vector intern.

#include <memory>
#include <print>
#include <string>

int main() {
    std::allocator<std::string> a;
    std::string* p = a.allocate(3);          // memorie pentru 3 șiruri, neconstruite

    std::construct_at(p, "Ana");
    std::construct_at(p + 1, "Ion");
    std::construct_at(p + 2, "Maria");

    for (int i = 0; i < 3; ++i) {
        std::println("{}", p[i]);
    }

    std::destroy_n(p, 3);                    // apelează destructorii
    a.deallocate(p, 3);                      // eliberează memoria
}

Rezultat

Ana
Ion
Maria

Greșeli frecvente

• Folosești memoria de la allocate ca și cum ar conține obiecte. Până la construct_at nu există niciun obiect acolo: comportament nedefinit.
• Apelezi deallocate fără să distrugi întâi obiectele. Destructorii nu rulează, iar resursele lor (de exemplu memoria șirurilor) se pierd.

Comenzi înrudite

• std::vector: Tabloul dinamic din C++: ține elementele unul după altul în memorie și își mărește singur dimensiunea.
• new: Creează un obiect în memoria dinamică (heap) și returnează un pointer la el; obiectul trăiește până este distrus explicit cu delete.
• std::addressof: Returnează adresa reală a unui obiect, chiar dacă clasa lui a redefinit operatorul &.