c++内存池

实现一个简单的内存池，用于高效分配和释放固定大小的对象。

代码示例

#include <iostream>
#include <cstdlib>
#include <stack>

class MemoryPool {
public:
MemoryPool(size_t objectSize, size_t poolSize)
: objSize(objectSize), totalSize(poolSize), pool((char*)malloc(objectSize * poolSize)) {
if (pool == nullptr) {
throw std::bad_alloc();
}
// 初始化 free list
for (size_t i = 0; i < poolSize; ++i) {
freeList.push(pool + i * objectSize);
}
}

~MemoryPool() {
free(pool);
}

void* allocate() {
if (freeList.empty()) {
throw std::bad_alloc();
}
void* ptr = freeList.top();
freeList.pop();
return ptr;
}

void deallocate(void* ptr) {
freeList.push((char*)ptr);
}

private:
size_t objSize;
size_t totalSize;
char* pool;
std::stack<void*> freeList;
};

class MyClass {
public:
MyClass(int val) : value(val) {
std::cout << "MyClass constructor: " << value << std::endl;
}
~MyClass() {
std::cout << "MyClass destructor: " << value << std::endl;
}
int value;
};

int main() {
try {
// 创建一个能容纳 3 个 MyClass 对象的内存池
MemoryPool pool(sizeof(MyClass), 3);

// 分配对象内存
void* mem1 = pool.allocate();
void* mem2 = pool.allocate();

// 使用“定位 new”构造对象
MyClass* obj1 = new(mem1) MyClass(100);
MyClass* obj2 = new(mem2) MyClass(200);

// 使用对象
std::cout << "obj1 value: " << obj1->value << std::endl;
std::cout << "obj2 value: " << obj2->value << std::endl;

// 显式调用析构函数
obj1->~MyClass();
obj2->~MyClass();

// 释放内存
pool.deallocate(mem1);
pool.deallocate(mem2);

}
catch (const std::bad_alloc& e) {
std::cerr << "Memory pool allocation error: " << e.what() << std::endl;
return 1;
}

return 0;
}

输出：

MyClass constructor: 100
MyClass constructor: 200
obj1 value: 100
obj2 value: 200
MyClass destructor: 100
MyClass destructor: 200

说明：

• MemoryPool 管理固定大小的内存块，避免频繁调用 malloc 和 free。
• 使用“定位 new”在预分配的内存上构造对象。
• 需要手动调用析构函数和将内存返回给内存池。

注意：这种方法适用于大量小对象的高效管理，但需要确保正确使用构造和析构函数。