Undefined reference

class Allocator {
protected:
    std::size_t m_totalSize;
    std::size_t m_used;   
    std::size_t m_peak;
public:
    Allocator(const std::size_t totalSize);
 
    virtual ~Allocator();
 
    virtual void* Allocate(const std::size_t size, const std::size_t alignment = 0) = 0;
 
    virtual void Free(void* ptr) = 0;
 
    virtual void Init() = 0;
 
    friend class Benchmark;
};
 
class PoolAllocator : public Allocator {
private:
    struct  FreeHeader{
    };
    typedef StackLinkedList<FreeHeader>::Node Node;
    StackLinkedList<FreeHeader> m_freeList;
 
    void * m_start_ptr = nullptr;
    std::size_t m_chunkSize;
public:
    PoolAllocator(const std::size_t totalSize, const std::size_t chunkSize);
 
    virtual ~PoolAllocator();
 
    virtual void* Allocate(const std::size_t size, const std::size_t alignment = 0) override;
 
    virtual void Free(void* ptr) override;
 
    virtual void Init() override;
 
    virtual void Reset();
private:
    PoolAllocator(PoolAllocator &poolAllocator);

PoolAllocator::PoolAllocator(const std::size_t totalSize, const std::size_t chunkSize)
: Allocator(totalSize) {
    assert(chunkSize >= 8 && "Chunk size must be greater or equal to 8");
    assert(totalSize % chunkSize == 0 && "Total Size must be a multiple of Chunk Size");
    this->m_chunkSize = chunkSize;
}
 
PoolAllocator::~PoolAllocator() {
    free(m_start_ptr);
}

Allocator::Allocator(const std::size_t totalSize){
    m_totalSize = totalSize;
    m_used = 0;
}
 
Allocator::~Allocator(){
    m_totalSize = 0;
}