Simple Pool Allocator This is a simple pool allocator, based (to at least some degree) on a previous answer. The basic idea is pretty simple: allow a user to allocate objects of some type quickly (in relatively large contiguous chunks) and only free objects when the allocator itself is freed, then destroy all the objects and free the memory they occupy.

#include &lt;iostream&gt;
#include &lt;vector&gt;

template &lt;class T, size_t T_per_page = 200&gt;
class Allocator {
    const size_t pool_size = T_per_page * sizeof(T);
    std::vector&lt;T *&gt; pools;
    size_t next_pos;

    void alloc_pool() {
        next_pos = 0;       
        void *temp = operator new(pool_size);
        pools.push_back(static_cast&lt;T *&gt;(temp));
    }

public:
    Allocator() {
        alloc_pool();
    }

    T* operator()(T const &amp;x) {
        if (next_pos == T_per_page)
            alloc_pool();

        T *ret = new(pools.back() + next_pos) T(x);
        ++next_pos;
        return ret;
    }

    ~Allocator() {
        while (!pools.empty()) {
            T *p = pools.back();
            for (size_t pos = T_per_page; pos &gt; 0; --pos)
                p[pos - 1].~T();
            operator delete(static_cast&lt;void *&gt;(p));
            pools.pop_back();
        }
    }
};

#ifdef TEST

struct list_node {
    int val;
    list_node *next;

    list_node(int x) : val(x), next(nullptr) {}

    friend std::ostream &amp;operator&lt;&lt;(std::ostream &amp;os, list_node const &amp;n) { return os &lt;&lt; n.val; }
};

Allocator&lt;list_node&gt; alloc;

int main() {
    for (int i = 0; i &lt; 20; i++) {
        list_node *j = alloc(i + 1000);
    }
}

#endif


I'd welcome any and all suggestions (including adding specialization to avoid executing destructors on trivially destructible types). I'm also wondering (sort of thinking out loud) whether it would make sense to use a geometric allocation strategy, similar to std::vector's, to (perhaps) fit allocation time to size more effectively.
Allocation of raw memory
Rather than using operator new you could use std::get_temporary_buffer&lt;T&gt;(n). This allocates contiguous &quot;correctly aligned&quot; storage for enough memory to store approx n objects of type T (its non binding contract read documents).
Constructor
It may be more efficient to use normal constructor than the copy constructor. You should also provide the move constructor.
T* operator()(T&amp;&amp; x);
T* operator()(T const &amp;x);
template&lt;typename... Args&gt;
T* operator()(Args... args);

Destructor
Yes you can optimize the destructor if Ts destructor is guranteed to do nothing.
template&lt;typename T&gt;
struct SimpleDestructableTrivialy
{
    static constexpr bool value = std::is_trivially_destructible&lt;T&gt;::value;
};
template&lt;typename T, bool = SimpleDestructableTrivialy&lt;T&gt;::value&gt;
class SimpleDestroy
{
    public:
        void destroyElements(T* p, std::size_t T_per_page);
};
template&lt;typename T&gt;
class SimpleDestroy&lt;T, true&gt;
{
    public:
        void destroyElements(T* p, std::size_t T_per_page) {}
};
template&lt;typename T&gt;
class SimpleDestroy&lt;T, false&gt;
{
    public:
        void destroyElements(T* p, std::size_t T_per_page)
        {
            for (size_t pos = T_per_page; pos &gt; 0; --pos)
                p[pos - 1].~T();
        }
};