Question

我正在开发一个内存池/内存分配器实现，我在一个庄园中设置它，只有一个特殊的“Client”对象类型可以从池中绘制。客户端可以直接构建到池中，或者它可以使用池进行动态内存调用，或者理论上它可以同时执行。我希望能够以调用我的池“alloc（）”和“free（）”函数的方式重载 operator new 和 operator delete ，以便获取构造对象所需的内存。

我遇到的一个主要问题是通过调用我编写的pool-＆gt; free（）函数来删除操作符以释放内存。我想出了一个通过将池传递给构造函数并让析构函数执行解除分配工作来修复它的hack。这是好的和花花公子，直到有人需要从这个类继承并覆盖析构函数以满足他们自己的需要，然后忘记执行内存释放。这就是为什么我想将它们全部包含在运算符中，以便将功能隐藏起来并默认继承。

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

我的客户端类定义如下：

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

我正在使用建议的“Memory Header”理念。

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

再次感谢您的帮助。

Answer 3

如果您的delete运营商只是呼叫free，那么自定义分配器将无法做得很好。自定义分配器的想法是它将使用它将控制的预定义内存区域：当它分配内存时，它将来自它的内存区域或池，当释放内存时，分配器被“通知”它可以重用那个记忆。现在，如果你使用free，你只需将内存返回堆，而不是内存池。这部分通常的方式是使用智能指针 - 跟踪可用的内存。

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

希望这有帮助

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

3 个答案: