我正在设计一个内存管理容器，考虑到性能和易用性，尤其是对于游戏开发项目。 Here's it in it's current state.

我将从源代码中提取最重要的部分。

// Uptr is a typedef for std::unique_ptr

class MemoryManageable {
    bool alive{true};
    public: bool isAlive() const { return alive; }
};

template<typename T> struct Deleter {
    bool operator()(const Uptr<T>& mItem) const { return !mItem->isAlive(); } 
};  

template<typename T> class MemoryManager {
    // T is the type of items being stored and must inherit MemoryManageable
    std::vector<Uptr<T>> items; 
    std::vector<T*> toAdd; // will be added to items on the next refresh() call
    Deleter<T> deleter;

    void refresh() { 
        items.erase(std::remove_if(std::begin(items), std::end(items), deleter), std::end(items)); 
        for(const auto& i : toAdd) items.push_back(Uptr<T>(i)); toAdd.clear(); 
    }
    void clear() { items.clear(); toAdd.clear(); }

    // Del sets alive to false, so that the item will be deleted and deallocated on the next refresh() call
    void del(T& mItem) { mItem.alive = false; }

    template<typename TType, typename... TArgs> TType& create(TArgs&&... mArgs) { /* creates a new TType* (derived from T) and puts it in toAdd */ }
    template<typename... TArgs> T& create(TArgs&&... mArgs) { return create<T, TArgs...>(std::forward<TArgs>(mArgs)...); }
}

You can see a real usage here.

所需的用法是这样的:

struct Entity : public MemoryManageable { 
     Manager& manager; 
     void destroy() { manager.del(*this); } 
     ... 
}

struct Mnnager { 
    MemoryManager<Entity> mm; 
    void del(Entity& mEntity) { mm.del(mEntity); }
    ... 
 }

Manager::update() {
    mm.refresh(); // entities with 'alive == false' are deallocated, and entities in 'mm.toAdd' are added to 'mm.items' 
    for(auto& entity : mm) entity->update(); // entities 'die' here, setting their 'alive' to false 
}

这种延迟插入设计有refresh()有一些很大的优势:

• 速度很快
• 一个实体即使已经死了也可以被“杀死”
• 实体可以从其他实体创建，因为它们在 populate() 之前不会直接存储在项目中被称为

但是，如果不需要继承我会很高兴MemoryManageable ，如果有更优雅的方式来删除实体。

• 有没有办法让MemoryManager处理 alive bool 内部，无需继承 MemoryManageable ，最重要的是，没有任何性能开销？
• 是否有更优雅的方法可用于删除 MemoryManager 处理的项目?

理想情况下，由 MemoryManager 处理的项目应该对此一无所知。

示例用法:在 gamedev 中，实体在更新期间被销毁是很常见的。考虑一个具有 int 生命成员的“敌人”实体:if(life <= 0) this->destroy(); - 在更新循环期间很容易发生这种情况，如果实体在销毁时立即从管理器中删除，则会导致循环和其他指向死实体的实体出现问题。

最佳答案

首先要说的是:我不太喜欢 C++11，所以我编写的代码中可能有一些语法错误，但重要的是逻辑。

如果我理解您的问题，您只是希望能够在容器中异步添加和删除项目，而容器不知道它们的状态。在这种情况下，您可以使用 std::map< std::unique_ptr< Elem >, bool >处理元素状态:true = 活着，false = 死了。

内存管理类

字段:

• std::vector< T * > m_toAdd ，一个尚未添加项目的 vector ；
• std::map< std::unique_ptr< T >, bool > m_items ，一个管理每个项目的 map 和一个bool旗帜

方法:

• add() , 它在 m_toAdd 中添加了一个新项目 vector ；
• del() , 标记要在 m_items 中删除的项目使用它的旗帜；
• refresh() ，它删除死项并提交 m_toAdd m_items 中的项目广告, 然后清除 vector

元素类

字段:

• MemoryManager & m_manager , 对其内存管理器的引用；

方法:

• Elem() , ctor，调用m_manager::add() ;
• del() ，它调用 m_manager::del() .

创作

当 Elem创建后，它会自动将自己添加到其内存管理器中，内存管理器将其添加到其 m_toAdd 中 vector ，然后当一切都被刷新时，那些 Elem此 vector 中的 s 在 std::map 中传递搭配 true bool 值(最初标记为事件)。

删除

当 Elem要删除，它调用一个del()它的管理器的方法在其 std::map 中简单地将其标记为已死，然后当一切都被刷新时，每个 Elem在标记为死亡的经理中删除，m_toAdd vector 被清除。

(我还建议您使用 std::enable_shared_from_this 以便更好地处理 ptr，但您必须使用 std::shared_ptr，而不是 std::unique_ptr，但那也不会太糟糕。)

我的建议是这样的:

template< class T >
class MemoryManager
{
   typedef std::unique_ptr< T > unique_t;
   typedef std::map< unique_t, bool > map_t;
   typedef std::pair< unique_t, bool > pair_t;
   typedef std::vector< T * > vector_t;

public:
   void add(T * item)
   {
      m_toAdd.push_back(item);
   }

   void remove(T & item)
   {
      typename map_t::iterator it = m_items.find(item);
      if (it != m_items.end() )(* it).second = false;
   }

   void refresh()
   {
      // clear dead
      typename map_t::iterator it = m_items.begin();
      while ((it = std::find_if(it, m_items.end(), isDead)) != m_items.end())
      {
         m_items.erase(it++);
      }

      // add new
      for(T & item : m_toAdd)
      {
         m_items.insert(std::make_pair(unique_t(item), true));
      }
      m_toAdd.clear();
   }

   void clear()
   {
      m_items.clear();
      m_toAdd.clear();
   }

protected:
   bool isDead(pair_t itemPair)
   {
      // true = alive, false = dead
      return itemPair.second;
   }

private:
   map_t m_items;
   vector_t m_toAdd;
};

class Entity
{
public:
   Entity(MemoryManager< Entity > & manager)
      : m_manager(manager)
   {
      m_manager.add(this);
   }

   void die()
   {
      m_manager.remove(this);
   }

private:
   MemoryManager< Entity > & m_manager;
}; 

注意:代码未经测试，肯定有问题，重要的是逻辑!

关于c++ - 内存管理容器设计问题 - 项目需要继承，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17538057/