Custom memory manager

#include <iostream>
#include <string>
#include <list>
#include <vector>
#include <chrono>
#include <memory>
#include <random>
 
using namespace std;
using namespace std::chrono;
 
class memory_pool
{
    typedef unsigned char byte;
    
    struct free_space
    {
    public:
        free_space(void *ptr, size_t lenght) : _ptr(ptr), _lenght(lenght) {};
 
        size_t _lenght = 0;
        void *_ptr = nullptr;
    };
 
private:
    size_t _defaultSize;
    size_t _currentIndex;
    byte *wrapped_array;
    list<void*> linkedPool;
    vector<shared_ptr<free_space>> free_space_list;
 
public:
    memory_pool(size_t defaultSize);
    void* getPointer(size_t size);
    void free(void * ptr, int lenght);
};
 
memory_pool::memory_pool(size_t defaultSize)
{
    _defaultSize = defaultSize;
    _currentIndex = 0;
    wrapped_array = new byte[_defaultSize];
    linkedPool.push_front(&wrapped_array[_currentIndex]);
}
 
void* memory_pool::getPointer(size_t size)
{
    void *returnedPtr = nullptr;
    for (auto i = free_space_list.begin(); i != free_space_list.end(); ++i)
    {
        if ((*i)->_lenght == size)
        {
            returnedPtr = (*i)->_ptr;
            free_space_list.erase(i);
            break;
        }
        else if ((*i)->_lenght > size)
        {
            returnedPtr = (*i)->_ptr;
            (*i)->_ptr = (void*)((uintptr_t)(*i)->_ptr + size);
            (*i)->_lenght -= size;
            break;
        }
    }
 
    if (returnedPtr == nullptr)
    {
        if (_currentIndex + size > _defaultSize)
        {
            wrapped_array = new byte[_defaultSize];
            _currentIndex = 0;
 
            linkedPool.push_front(&wrapped_array[_currentIndex]);
        }
 
        returnedPtr = (void*)((uintptr_t)linkedPool.front() + _currentIndex);
 
        _currentIndex += size;
    }
    return returnedPtr;
}
 
void memory_pool::free(void * ptr, int lenght)
{
    free_space_list.push_back(make_shared<free_space>(ptr, lenght));
}
 
memory_pool pool(1 * 1024);
 
template<class T>
class IMemoryPooled
{
public:
    void *operator new(size_t size)
    {
        return pool.getPointer(sizeof(T));
    };
    
    void operator delete(void* ptr) noexcept
    {
        pool.free(ptr, sizeof(T));
    };
};
 
 
class MyType : public IMemoryPooled<MyType>
{
public: 
    int i;
    float j;
    double d;
    double d2;
    double d3;
    double d4;
    string str;
};
 
class MyType2
{
public:
    int i;
    float j;
    double d;
    double d2;
    double d3;
    double d4;
    string str;
};
 
int main()
{
    const int DEFAULT_N = 1000000;
 
    std::default_random_engine generator;
    std::uniform_int_distribution<int> distribution(1, 20);
    
    high_resolution_clock::time_point start = high_resolution_clock::now();
    for (int i = 0; i < DEFAULT_N; i++)
    {
        MyType *mt = new MyType();
        delete mt;
    }
    high_resolution_clock::time_point end = high_resolution_clock::now();
    duration<double> time_span = duration_cast<duration<double>>(end - start);
    cout << time_span.count() << endl;
 
    cout << endl << endl << endl << endl << endl << endl;
    
    high_resolution_clock::time_point start2 = high_resolution_clock::now();
    for (int i = 0; i < DEFAULT_N; i++)
    {
        MyType2 *mt = new MyType2();
        delete mt;
    }
    high_resolution_clock::time_point end2 = high_resolution_clock::now();
    duration<double> time_span2 = duration_cast<duration<double>>(end2 - start2);
    cout << time_span2.count() << endl;
    
    getchar();
    return 0;
}