Ich arbeite an einer Speicherpool- / Speicherzuordnungsimplementierung und richte sie in einem Herrenhaus ein, in dem nur ein spezieller "Client" -Objekttyp aus dem Pool gezeichnet werden kann. Der Client kann entweder direkt auf dem Pool erstellt werden oder es kann Verwenden Sie den Pool für dynamische Speicheraufrufe, oder er kann theoretisch beides. Ich möchte überladen könnenBetreiber neu undOperator löschen auf eine Weise, die meine Pools "alloc ()" und "free ()" aufruft, um den Speicher abzurufen, den das Objekt zum Aufbau benötigt.

Eines der Hauptprobleme ist, dass mein Operator delete in der Lage ist, den Speicher freizugeben, indem er die von mir geschriebene pool-> free () -Funktion aufruft. Ich habe mir einen Hack ausgedacht, der das Problem behebt, indem der Pool an den Konstruktor übergeben wird und der Destruktor die Aufhebung der Zuweisung vornimmt. Dies ist alles in Ordnung, bis jemand von dieser Klasse erben und den Destruktor für seine eigenen Bedürfnisse überschreiben und dann die Speicherfreigabe vergessen muss. Aus diesem Grund möchte ich alles in die Operatoren einschließen, damit die Funktionalität nicht in den Hintergrund tritt und standardmäßig vererbt wird.

Mein Code ist auf GitHub hier:https://github.com/zyvitski/Pool

Meine Klassendefinition für den Client lautet wie folgt:

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

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

    Pool* m_pPool;
};

Und die Implementierung ist:

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

}

Hier ist das Beispiel Main (), das ich im Moment benutze:

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;
}

Bisher funktioniert mein Code, aber ich möchte wissen, ob es einen besseren Weg gibt, dies zu erreichen. Bitte lassen Sie mich wissen, wenn etwas, was ich frage / tue, einfach unmöglich, schlecht oder einfach nur dumm ist. Ich bin gerade auf einem MacBook Pro, möchte aber meinen Code möglichst plattformübergreifend verwenden.

Wenn Sie irgendwelche Fragen haben, die Ihnen helfen würden, lassen Sie es mich wissen.

Und natürlich Danke im Voraus an alle, die helfen können.