[[427113]]

 什么是對象池?

對象的池子，與線程池、內存池類似，減少頻繁創建和銷毀對象帶來的成本(特別是消耗資源較大的對象)，可用于實現對象的緩存和復用。這也算是一種設計模式。

話不多說，直接上代碼：

#include <algorithm> 
#include <cassert> 
#include <cmath> 
#include <complex> 
#include <iostream> 
#include <memory> 
#include <numeric> 
#include <vector> 
 
struct A { 
    A(std::string s) { str_ = std::move(s); } 
 
    void print() { std::cout << str_ << std::endl; } 
 
    std::string str_; 
}; 
 
template <typename T, typename Allocator = std::allocator<T>> 
class ObjectPool { 
   public: 
    ObjectPool() = default; 
    ~ObjectPool() { 
        assert(freeObjects_.size() == kInitChunkSize * (std::pow(2, pool_.size()) - 1)); 
 
        size_t chunkSize{kInitChunkSize}; 
        for (auto* chunk : pool_) { 
            allocator_.deallocate(chunk, chunkSize); 
            chunkSize *= 2; 
        } 
        pool_.clear(); 
    } 
 
    template <typename... Args> 
    std::shared_ptr<T> acquireObject(Args... args) { 
        if (freeObjects_.empty()) { 
            addChunk(); 
        } 
 
        T* object{freeObjects_.back()}; 
 
        new (object) T{std::forward<Args>(args)...}; 
 
        freeObjects_.pop_back(); 
 
        return std::shared_ptr<T>(object, [this](T* object) { 
            std::_Destroy(object); 
            freeObjects_.push_back(object); 
        }); 
    } 
 
   private: 
    std::vector<T*> pool_; 
 
    std::vector<T*> freeObjects_; 
 
    static const size_t kInitChunkSize{5}; 
 
    size_t newChunkSize{kInitChunkSize}; 
 
    void addChunk() { 
        std::cout << "add Chunk \n"; 
 
        auto* firstNewObject{allocator_.allocate(newChunkSize)}; 
        pool_.push_back(firstNewObject); 
 
        auto oldFreeObjectSize{freeObjects_.size()}; 
        freeObjects_.resize(oldFreeObjectSize + newChunkSize); 
        std::iota(std::begin(freeObjects_) + oldFreeObjectSize, std::end(freeObjects_), firstNewObject); 
 
        newChunkSize *= 2; 
    } 
 
    Allocator allocator_; 
}; 
 
using APool = ObjectPool<A>; 
 
int main() { 
    APool pool; 
    for (int i = 0; i < 20; i++) { 
        auto x = pool.acquireObject(std::string("hello")); 
        x->print(); 
    } 
    return 0; 
} 

上面的對象池實現在每次請求對象的時候都調用了構造函數和析構函數，這里大家可以根據實際情況自行選擇是否必要調用。如果構造和析構成本也比較高，可以再想辦法節省對應的開銷。