simple pool allocator

pool_allocator.h

#pragma once
#include<memory>

template<typename T, size_t ChunkSize = 1024>
struct pool_allocator
{
    using alloc_type = T;
    using pointer_type = alloc_type*;

    pool_allocator() 
    {
    }

    ~pool_allocator()
    {
        free_chunk();
    }

    pointer_type allocate() 
    {
        if (free_block == nullptr)
        {
            alloc_chunk();
        }


        element* elem = free_block;
        free_block = free_block->next_free;

        return &(elem->item);
    }

    void free(pointer_type item) 
    {
        element* p = (element*)item;
        p->next_free = free_block->next_free;
        free_block = p;
    }

private:
    
    void alloc_chunk()
    {
        chunk* p = (chunk*)std::malloc(sizeof(chunk));
        p->next_chunk = chunks;
        chunks = p;

        for (size_t i = 0; i < ChunkSize - 1; i++)
        {
            p->pool[i].next_free = p->pool + i + 1;
        }
        p->pool[ChunkSize - 1].next_free = free_block;
        free_block = (p->pool);
    }

    void free_chunk()
    {
        while (chunks)
        {
            chunk* next = chunks->next_chunk;
            std::free(chunks);
            chunks = next;
        }
        chunks = nullptr;
        free_block = nullptr;
    }

    struct element
    {
        union
        {
            alloc_type item;
            element* next_free;
        };
    };

    struct chunk
    {
        chunk* next_chunk;
        element pool[ChunkSize];
    };

    chunk* chunks = nullptr;

    element* free_block = nullptr;
};