带有池的模板化抽象工厂类

Question

我正在开发一个处理事件的游戏引擎组件。我想做的是创建一个可以按名称注册新事件类型的系统。然后，事件管理器将保存事件类型和工厂的集合来生成此类事件类型，但不同之处在于我想让它使用池系统，以便我创建一个事件，使用它，然后而不是删除它，将其放入列表中。下次我创建该事件时，我可以从池中分配，而不是使用堆。

所以给定这些事件类型的层次结构...

struct TEvent
{
  int nID;
  int nTimeStamp;
};

struct TCollisionEvent : public TEvent
{
  TEntity* pEntity1;
  TEntity* pEntity2;
  Vector3* pvecPoint;
};

然后我创建了一个智能工厂来执行此创建/回收操作：

template <class BASE_CLASS>
class CSmartFactory
{
private:
  typedef typename std::list<BASE_CLASS*> TBaseList;
  typedef typename std::list<BASE_CLASS*>::iterator TBaseListItr;

  TBaseList* m_plstPool;

public:
  explicit CSmartFactory()
  {
    m_plstPool = NULL;
  }

  ~CSmartFactory()
  {
    TBaseListItr itr;

    if (m_plstPool)
    {
      for (itr = m_plstPool->begin(); itr != m_plstPool->end(); itr++)
      {
        BASE_CLASS* pEntity = *itr;
        SAFE_DELETE(pEntity);
      }

      m_plstPool->clear();
      SAFE_DELETE(m_plstPool);
    }    
  }

  bool Init(int nPoolSize)
  {
    bool bReturn = false;

    do 
    { 
      m_plstPool = new TBaseList;
      IwAssert(MAIN, m_plstPool);

      while (nPoolSize--)
      {
        BASE_CLASS* pBaseObject = new BASE_CLASS;
        IwAssert(MAIN, pBaseObject);

        m_plstPool->push_back(pBaseObject);
      }

      bReturn = true;
    } while(0); 

    return bReturn; 
  }

  BASE_CLASS* Create()
  {
    BASE_CLASS* pBaseObject = NULL;

    //
    // grab a pre-made entity from the pool or allocate a new one
    if (m_plstPool->size() > 0)
    {
      pBaseObject = m_plstPool->front();
      m_plstPool->pop_front();
      pBaseObject->Clear();
    }
    else
    {
      pBaseObject = new BASE_CLASS;
      IwAssert(MAIN, pBaseObject);
    }

    return pBaseObject;
  }

  void Recycle(BASE_CLASS* pBaseObject)
  {
    m_plstPool->push_back(pBaseObject);
  }
};

所以现在我可以这样做：

CSmartFactory<TCollisionEvent>* pCollisionEventFactory = new CSmartFactory<TCollisionEvent>;

但是我想要做的是让我的事件管理器允许动态事件注册，但这就是我遇到了障碍。

理想情况下，RegisterEvent 将跟踪 stl::map 或其他内容中的名称和工厂指针，但不太确定如何到达该点。也许我完全走错了路。

这个编译

class TEventManager
{
public:
  TEventManager();
  ~TEventManager();

  bool RegisterEvent(char* pszEventName, CSmartFactory<TEvent>* pFactory);
};

直到你添加

TEventManager::RegisterEvent("CollisionEvent", new CSmartFactory<TEntityCollisionEvent>);

所以现在我绝望地试图找到一种方法来使这一切工作。

有人在这里有一些想法吗？

弗雷德

Answer 1

这两个类 CSmartFactory 和 CSmartFactory 将生成类似

• CSmartFactory_TEntityCollisionEvent

• CSmartFactory_TEvent

内容它们实际上是两个独立且不相关的类。尝试互换使用它们是不明智的，尽管它们的行为相同（它们的类型类是多态的）。

动态铸造不起作用，但是您可以尝试使用强力铸造：

TEventManager::RegisterEvent("CollisionEvent", 
        reinterpret_cast<CSmartFactory<TEvent>*>(new CSmartFactory<TEntityCollisionEvent>));

警告：风险自负！ ;-)

Answer 2

好吧，经过大量的头脑碰撞后，我意识到解决方案比我试图实现的要简单得多。

管理者应该关心的只是管理 TEvent*。每个 TEvent 都有一个唯一的哈希值，因此当添加新事件时，该事件的字符串名称和哈希名称都会被存储。因此，从那里我可以添加一个指向任何子类的指针，只要它被转换为 TEvent 即可。

我让它变得比需要的复杂得多。

Answer 3

我假设您想重用事件以避免昂贵的堆 malloc/free ？

我认为正确的答案不是通过编写自己的重用对象结构来使代码变得复杂，而是使用小对象分配器。首先，可能值得研究 boost::池。