std::allocator

std::allocator

---

Prerequisites

---

1. What is an Allocator

An allocator is a mechanism that handles memory allocation and deallocation

for objects used in containers like:

• std::vector
• std::list
• std::map

Containers do not allocate memory directly

Instead:

Container → Allocator → Memory

When It Matters:

• high-frequency allocation
• real-time systems
• game engines
• memory-constrained environments

Basic Usage

#include <memory>

std::allocator<int> alloc;
int* p = alloc.allocate(5);  // allocate space for 5 ints

Only allocates memory (no construction)

Construct Object

std::construct_at(p, 10);

Destroy Object

std::destroy_at(p);

Deallocate Memory

alloc.deallocate(p, 5);

Full Example

#include <iostream>
#include <memory>

int main()
{
    std::allocator<int> alloc;

    int* p = alloc.allocate(1);
    std::construct_at(p, 42);       // new(p) int(42);

    std::cout << *p << "\n";

    std::destroy_at(p);
    alloc.deallocate(p, 1);
}

2. Why Allocator Exists

2-1. Separation of Concerns

• Container → data structure logic
• Allocator → memory management

2-2. Custom Memory Strategies

You can replace default allocator with:

• memory pool
• arena allocator
• stack allocator

2-3. Performance Optimization

👉 Avoid frequent new/delete

Example

std::vector<int> v;

Internally:

std::vector<int, std::allocator<int>>

Custom Allocator Example

template<typename T>
struct MyAllocator
{
    using value_type = T;

    T* allocate(size_t n)
    {
        return static_cast<T*>(::operator new(n * sizeof(T)));
    }

    void deallocate(T* p, size_t)
    {
        ::operator delete(p);
    }
};

std::vector<int, MyAllocator<int>> v;

3. Advanced Concepts

Rebinding (Old concept)

Used to allocate different types. Mostly replaced by allocator_traits

std::allocator<int>

Alloc::rebind<U>::other

std::allocator<int> alloc; // std::allocator<double>: want to be exchanged
typename std::allocator<int>::rebind<double>::other new_alloc;

Allocator Traits

std::allocator_traits<Alloc>

using Alloc = std::allocator<int>;
using NewAlloc = std::allocator_traits<Alloc>::rebind_alloc<double>;

Standard way to interact with allocators

construct/destroy

❗ Deprecated

alloc.construct(...)
alloc.destroy(...)

✔️ Use Instead

std::construct_at(ptr, args...);
std::destroy_at(ptr);

Feature	Allocator	new/delete
Abstraction	High	Low
Flexibility	High	Low
Customization	Yes	No
Used in STL	Yes	No

4. Advanced Concepts

❌ Mixing new/delete with allocator

int* p = new int;
alloc.deallocate(p, 1);  // ❌ wrong