C++如何实现一个简单的对象池_C++对象复用与对象池实现

#include <vector>
#include <stack>
#include <mutex>
<p>template<typename T>
class ObjectPool {
private:
std::vector<T<em>> pool;           // 存储所有已分配对象
std::stack<T</em>> available;       // 可用对象栈
std::mutex mtx;                  // 线程安全支持</p><p>public:
// 构造函数：预分配n个对象
explicit ObjectPool(size_t n = 10) {
pool.reserve(n);
for (size_t i = 0; i < n; ++i) {
pool.push_back(new T());
available.push(pool.back());
}
}</p><pre class='brush:php;toolbar:false;'>// 获取一个对象
T* acquire() {
    std::lock_guard<std::mutex> lock(mtx);
    if (available.empty()) {
        // 池空了，扩展（可选策略）
        T* obj = new T();
        pool.push_back(obj);
        return obj;
    }
    T* obj = available.top();
    available.pop();
    return obj;
}

// 归还对象到池
void release(T* obj) {
    std::lock_guard<std::mutex> lock(mtx);
    // 注意：不调用析构函数，仅标记为可用
    available.push(obj);
}

// 析构函数：释放所有内存
~ObjectPool() {
    for (T* obj : pool) {
        delete obj;
    }
    pool.clear();
    while (!available.empty()) available.pop();
}

// 禁止拷贝
ObjectPool(const ObjectPool&) = delete;
ObjectPool& operator=(const ObjectPool&) = delete;

#include <iostream>
<p>struct Connection {
int id;
bool active;</p><pre class='brush:php;toolbar:false;'>Connection() : id(0), active(false) {
    std::cout << "Connection created\n";
}

void reset() {
    id = 0;
    active = false;
}

// 获取对象
Connection* conn1 = pool.acquire();
conn1->id = 100;
conn1->active = true;

std::cout << "Use conn: " << conn1->id << "\n";

// 使用完归还
pool.release(conn1);

// 再次获取，可能拿到同一个地址
Connection* conn2 = pool.acquire();
std::cout << "Reused? " << (conn1 == conn2) << "\n";

return 0;