使用带有自定义内存池/分配器的 operator new 和 operator delete

Question

我正在研究内存池/内存分配器的实现，我正在将它设置在一个庄园中，只有一个特殊的“客户端”对象类型可以从池中提取。客户端可以直接构建到池中，或者它可以将池用于动态内存调用，或者理论上可以两者兼而有之。 我希望能够重载 operator new 和 operator delete 以调用我的池“alloc()”和“free()”函数，以便获取构建对象所需的内存。

我遇到的主要问题之一是通过调用我编写的 pool->free() 函数来让我的操作员 delete 能够释放内存。我想出了一个技巧，通过将池传递给构造函数并让析构函数完成释放工作来修复它。这一切都很好而且很花哨，直到有人需要从这个类继承并根据自己的需要重写析构函数，然后忘记进行内存释放。这就是为什么我想把它全部封装在操作符中，这样功能就被隐藏起来并默认继承。

我的代码在 GitHub 上：https://github.com/zyvitski/Pool

我对 Client 的类定义如下：

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

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

    Pool* m_pPool;
};

而实现是：

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

}

这是我目前正在使用的示例 Main()：

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

到目前为止，我的代码可以正常工作，但我想知道是否有更好的方法来实现这一点？ 请让我知道我所要求/做的任何事情是不可能的、不好的做法或只是愚蠢的。我现在在 MacBook Pro 上，但如果可能的话，我想保持我的代码跨平台。

如果您有任何问题可以帮助我，请告诉我。

当然，提前感谢任何可以提供帮助的人。

Answer 1

您可以在返回的内存地址之前存储其他信息

#include <iostream>
#include <type_traits>

class Pool {
public:
    static void* Alloc(std::size_t size) { return data; }
    static void Dealloc(void*) {}
private:
    static char data[1024];
};
char Pool::data[1024];


class Client
{
public:
    void* operator new(size_t size, Pool& pool);
    void operator delete(void* memory);
};


struct MemoryHeader {
    Pool* pool;
};


void* Client::operator new(size_t size, Pool& pool)
{
    auto header = static_cast<MemoryHeader*>(pool.Alloc(sizeof(MemoryHeader) + size));
    std::cout << "    New Header: " << header << '\n';
    header->pool = &pool;
    return header + 1;
}

void Client::operator delete(void* memory)
{
    auto header = static_cast<MemoryHeader*>(memory) - 1;
    std::cout << " Delete Header: " << header << '\n';
    header->pool->Dealloc(header);
}

int main()
{
    Pool pool;
    Client* p = new(pool) Client;
    std::cout << "Client Pointer: " << p << '\n';
    delete p;
    return 0;
}

Answer 2

在Dieter Lücking 的帮助下，我能够弄清楚如何在 operator new 和 operator delete

中使用我的池

这是operator new的代码：

void* ObjectBase::operator new(size_t size, Pool* pool)
{
    if (pool!=nullptr) {
        //use pool allocation
        MemoryBlock** block = pool->Alloc(size+(sizeof(MemoryHeader)));
        MemoryBlock* t = * block;
        t = (MemoryBlock*)((unsigned char*)t+sizeof(MemoryHeader));
        MemoryHeader* header = new(*block)MemoryHeader(pool);
        header=nullptr;
        return t;
    }
    else{
        //use std allocation
        void* temp = ::operator new(size);
        if (temp!=nullptr) {
            return temp;
        }
        else throw new std::bad_alloc;
    }
}

这是操作符删除

的代码

void ObjectBase::operator delete(void* memory)
{
    MemoryBlock* temp = (MemoryBlock*)((unsigned char*)memory-sizeof(MemoryHeader));
    MemoryHeader* header = static_cast<MemoryHeader*>(temp);
    if (header->pool!=nullptr) {
        if (header->pool->Free((MemoryBlock**)&header));
        else
        {
            ::operator delete(memory);
        }
    }
    else{
        ::operator delete(memory);
    }
}

我正在使用建议的“内存标题”想法。

如果由于某种原因池失败，代码也以默认使用标准内存分配调用的方式设置。

再次感谢您的帮助。

Answer 3

如果您的delete 运算符只是调用free，您的自定义分配器将不会做得很好。自定义分配器的想法是，它将与它可以控制的预定义内存区域一起工作：当它分配内存时，它将来自它的内存区域或池，当内存被释放时，分配器被“通知”它可以重用该内存。 现在，如果您使用 free，您只需将内存返回到堆中，而不是返回到内存池中。这部分通常完成的方式是使用智能指针——跟踪可用的内存。

只要您可以跟踪哪些地址正在使用和哪些可用，任何其他机制都可以。

希望对你有帮助