add simple example about memory-allocators HOT 1 OPEN

#include <iostream>
#include <string>
#include <array>

#include "freelistallocator.h"

class Base
{
public:
    Base()
    {
        std::cout << "base constructor" << std::endl;
    }

    virtual ~Base()
    {
        std::cout << "base destructor" << std::endl;
    }

    virtual void Does() = 0;
};

class Child: public Base
{
public:
    Child(const std::string& _msg)
    {
        std::cout << "child constructor" << std::endl;
        msg = _msg;
    }

    ~Child()
    {
        std::cout << "child destructor" << std::endl;
    }

    void Does()
    {
        std::cout << msg << std::endl;
    }

private:
    std::string msg {""};
};

class System
{
public:
    System(const System& src) = delete;

    ~System()
    {
        std::cout << "~System()" << std::endl;
        _allocator.Reset();
    }

    Allocator* GetAllocator()
    {
        return &_allocator;
    }

    void SayHello() const
    {
        std::cout << "Hello from System" << std::endl;
    }

    static System& getInstance()
    {
        static System _instance;
        return _instance;
    }

private:
    System(): _allocator(sizeof(Child)*1000, FreeListAllocator::FIND_FIRST)
    {
        std::cout << "System()" << std::endl;
        _allocator.Init();
    }

private:
    FreeListAllocator _allocator;
};

void TestSingleAllocation()
{
    Allocator* _allocator = System::getInstance().GetAllocator();
    Base* b_ptr = nullptr;

    {
        Child* c_ptr = (Child*)_allocator->Allocate(sizeof(Child),8);

        if (c_ptr)
        {
            new(c_ptr) Child("\tchild does smth");
            b_ptr = c_ptr;
        }
    }

    if (b_ptr)
    {
        b_ptr->Does();

        b_ptr->~Base();
        _allocator->Free(b_ptr);

        b_ptr = nullptr;
    }
}

void TestMultiAllocation()
{
    std::array<Base*,10> container {nullptr};

    Allocator* _allocator = System::getInstance().GetAllocator();

    for (size_t i=0; i<container.size(); i++)
    {
        Base* b_ptr = nullptr;

        {
            Child* c_ptr = (Child*)_allocator->Allocate(sizeof(Child),8);

            if (c_ptr)
            {
                new(c_ptr) Child("\tchild");
                b_ptr = c_ptr;
            }
        }

        container[i] = b_ptr;
    }

    for (size_t i=0; i<container.size(); i++)
    {
        if (container[i])
            container[i]->Does();
    }

    // std::cout << "total: " << _allocator->GetTotal() << " used: " << _allocator->GetUsed() << std::endl;

    for (size_t i=0; i<container.size(); i++)
    {
        Base* b_ptr = container[i];

        if (b_ptr)
        {
            b_ptr->~Base();
            _allocator->Free(b_ptr);
            container[i]=nullptr;
        }
    }

    // std::cout << "total: " << _allocator->GetTotal() << " used: " << _allocator->GetUsed() << std::endl;
}

int main()
{
    System::getInstance().SayHello();

    //TestSingleAllocation();
    TestMultiAllocation();

    return 0;
}