C++ 具有外部实例创建的ObjectPool

我尝试修改现有的对象池类，以便能够将实例创建者类作为参数传递给对象池。基本上，我希望能够将实际的对象构造排除在内存池之外，这样我就可以更自由地创建要池化的实例

以下是对象池定义：

template < 
    typename T, 
    typename InstanceCreator = DefaultInstanceFactory<T>
>
class ObjectPool : private noncopyable {
...
}

在上面的方法中，我标记了实际的问题行。我不知道如何用外部实例创建者替换placement new

new（obj）T（）

行，以便重用该内存

为完整起见，将对象返回池的方法如下所示

ObjectPool<int> intPool((DefaultInstanceFactory<int>()));

template <typename T>
class DefaultInstanceFactory {
public:
    T * operator ()() const {
        return new T;
    }
};

void returnObject(T * obj) {
    // --- Get containing PooledItem pointer
    PooledItem * item = reinterpret_cast<PooledItem *>(obj);
    // --- Make sure object came from this pool
    if (item->next != reinterpret_cast<PooledItem *>(this)) {
        // throw Exception
    }

    // --- Destroy object now if we want to reconstruct it later
    if (destroyOnRelease) {
        item->cast()->~T();
        item->initialized = false;
    }

void returnObject（T*obj）{
//---获取包含PooledItem指针的
PooledItem*项目=重新解释铸件（obj）；
//---确保对象来自此池
如果（项目->下一步！=重新解释施法（此））{
//抛出异常
}
//---如果我们以后要重建对象，请立即销毁它
如果（destroyOnRelease）{
物品->铸造（）->~T（）；
item->initialized=false；
}

有谁能给我一些帮助，如何修改这些方法，使外部实例创建者能够正确地集成？到目前为止，我不知道是否需要更改returnObject方法中的某些内容，到目前为止，我认为没有

---

感谢您的帮助！

听起来您需要更改InstanceFactory的签名以获取指针

template <typename T>
class DefaultInstanceFactory {
public:
  void operator ()(T* out) const {
      return new(out) T;
  }
};

模板
类DefaultInstanceFactory{
公众：
void运算符（）（T*out）常量{
返回新的（输出的）T；
}
};

T * borrowObject() {
    PooledItem * item = getItem();
    T * obj = item->cast();
    if (! item->initialized) {
        // old original line, call the defaut constructor of T
        new (obj) T();
        // how to integrate the external Instance Creator at this point?
        //new (instCreator_ ()) T(1);
        //instCreator_ ();
        item->initialized = true;
    }

    if (obj == NULL) {
        throw ObjectPoolException(
            "Object is NULL!", __FILE__, __LINE__, __FUNCTION__);
    }

    return obj;
}

void returnObject(T * obj) {
    // --- Get containing PooledItem pointer
    PooledItem * item = reinterpret_cast<PooledItem *>(obj);
    // --- Make sure object came from this pool
    if (item->next != reinterpret_cast<PooledItem *>(this)) {
        // throw Exception
    }

    // --- Destroy object now if we want to reconstruct it later
    if (destroyOnRelease) {
        item->cast()->~T();
        item->initialized = false;
    }

template <typename T>
class DefaultInstanceFactory {
public:
  void operator ()(T* out) const {
      return new(out) T;
  }
};