Pracuję nad implementacją puli pamięci / alokatora pamięci i ustawiam ją w rezydencji, w której z puli można rysować tylko specjalny typ obiektu „Klient”. Klient może być albo skonstruowany bezpośrednio na puli, albo może użyj puli do dynamicznych wywołań pamięci lub może teoretycznie zrobić obie te rzeczy. Chciałbym być w stanie przeciążyćoperator nowy ioperator usunąć w sposób, który nazwałby moje pule "alloc ()" i "free ()", aby uzyskać pamięć potrzebną do zbudowania obiektu.

Jednym z głównych problemów, które mam, jest skasowanie mojego operatora, aby móc zwolnić pamięć, wywołując napisaną przeze mnie funkcję pool-> free (). Wymyśliłem hak, który to naprawia, przekazując pulę do konstruktora i wykonując deallocation. Wszystko jest w porządku, dopóki ktoś nie musi dziedziczyć z tej klasy i nadpisywać destruktora na własne potrzeby, a następnie zapomina o zwolnieniu pamięci. Dlatego chcę zawinąć to wszystko w operatory, aby funkcja była domyślnie ukryta i dziedziczona.

Mój kod jest na GitHub tutaj:https://github.com/zyvitski/Pool

Moja definicja klasy dla klienta jest następująca:

class Client
{
public:
    Client();
    Client(Pool* pool);
    ~Client();

    void* operator new(size_t size,Pool* pool);
    void operator delete(void* memory);

    Pool* m_pPool;
};

A realizacja to:

Client::Client()
{

}
Client::Client(Pool* pool)
{
    m_pPool = pool;
}
Client::~Client()
{
    void* p = (void*)this;
    m_pPool->Free(&p);
    m_pPool=nullptr;
}
void* Client::operator new(size_t size, Pool* pool)
{
    if (pool!=nullptr) {
        //use pool allocator
        MemoryBlock** memory=nullptr;
        memory = pool->Alloc(size);
       return *memory;
    }
    else throw new std::bad_alloc;
}
void Client::operator delete(void* memory)
{
    //should somehow free up the memory back to the pool
    // the proper call will be:
    //pool->free(memory);
    //where memory is the address that the pool returned in operator new

}

Oto przykład Main (), którego aktualnie używam:

int main(int argc, const char * argv[]){
    Pool* pool = new Pool();
    Client* c = new(pool) Client(pool);
    /*
    I'm using a parameter within operator new to pass the pool in for use and i'm also passing the pool as a constructor parameter so i can free up the memory in the destructor
    */

    delete c;
    delete pool;
    return 0;
}

Jak dotąd mój kod działa, ale chcę wiedzieć, czy istnieje lepszy sposób na osiągnięcie tego celu? Daj mi znać, jeśli coś, o co pytam / robię, jest po prostu niemożliwe, zła praktyka lub po prostu głupia. Jestem teraz na MacBooku Pro, ale chciałbym, aby mój kod był dostępny na wielu platformach.

Jeśli masz jakieś pytania, które pomogą mi pomóc, daj mi znać.

I oczywiście z góry dziękuję każdemu, kto może pomóc.