Estou trabalhando na implementação de um pool de memória / alocador de memória e configurando-o em uma mansão em que apenas um tipo de objeto "Cliente" especial pode ser extraído do pool. O cliente pode ser construído diretamente no pool ou pode use o pool para chamadas de memória dinâmica ou, em teoria, poderia fazer as duas coisas. Eu gostaria de poder sobrecarregaroperador novo eexclusão de operador de uma maneira que chamaria meus pools de funções "assign ()" e "free ()" para obter a memória necessária para a construção do objeto.

Um dos principais problemas que estou enfrentando é fazer com que meu operador exclua para poder liberar a memória chamando a função pool-> free () que eu escrevi. Eu vim com um hack que o corrige passando o pool para o construtor e fazendo com que o destruidor faça o trabalho de desalocação. Isso é ótimo e elegante até que alguém precise herdar dessa classe e substituir o destruidor por suas próprias necessidades e depois se esqueça de fazer as desalocações de memória. É por isso que eu quero agrupar tudo nos operadores para que a funcionalidade seja escondida e herdada por padrão.

Meu código está no GitHub aqui:https://github.com/zyvitski/Pool

Minha definição de classe para o cliente é a seguinte:

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

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

    Pool* m_pPool;
};

E a implementação é:

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

}

Aqui está o exemplo Main () que estou usando no momento:

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

Até agora, meu código funciona, mas quero saber se existe uma maneira melhor de conseguir isso? Por favor, deixe-me saber se algo que estou pedindo / fazendo é simplesmente impossível, má prática ou simplesmente burro. Estou em um MacBook Pro agora, mas gostaria de manter meu código em várias plataformas, se possível.

Se você tiver alguma dúvida que o ajude a me ajudar, entre em contato.

E, claro, Agradecemos antecipadamente a quem puder ajudar.