1

这个问题源于这个问题的结果： 如何自动维护类实例列表？

参考上一个问题，我创建了我的静态对象列表static std::set< Object* > objects;

但是，为了避免 and 之间的循环引用Engine，Object我将其移出Engine并移入单独的头文件中。然后我意识到，我可以使用一堆静态访问器，而不是直接与列表交互。这样，如果有任何东西对列表进行更改，我总是可以打破这些功能。

这样做还有其他好处吗？或者这是一个不好的方法？ 我从不打算实例化ObjectManager——我是否应该使用我认为所谓的“自由函数”来管理这个std::set，而不用上课？

我创建了一个测试项目，以使测试变得简单。该类Inheritor继承自Object该类。该类的代码ObjectManager（由 引用Main.cpp，在本例中Object，Inheritor但在我的主项目中将使用非常相似的代码）如下：

对象管理器.h：

#include <set>

class ObjectManager
{
    friend class Object;
    friend class Inheritor;

public:
    static int ObjectCount();
    static void AddObject(Object *);
    static void RemoveObject(Object *);

    static int InheritorCount();
    static void AddInheritor(Inheritor *);
    static void RemoveInheritor(Inheritor *);

    static std::set<Object *>::iterator GetObjectListBegin();
    static std::set<Object *>::iterator GetObjectListEnd();

    static std::set<Inheritor *>::iterator GetInheritorListBegin();
    static std::set<Inheritor *>::iterator GetInheritorListEnd();
private:
    ObjectManager();
    ~ObjectManager();
};

对象管理器.cpp：

#include "ObjectManager.h"

static std::set<Object *> objectList;
static std::set<Inheritor *> inheritorList;

ObjectManager::ObjectManager()
{

}
ObjectManager::~ObjectManager()
{
}

int ObjectManager::ObjectCount()
{
    return objectList.size();
}

void ObjectManager::AddObject(Object *input)
{
    objectList.insert(input);
}

void ObjectManager::RemoveObject(Object *input)
{
    objectList.erase(input);
}


int ObjectManager::InheritorCount()
{
    return inheritorList.size();
}

void ObjectManager::AddInheritor(Inheritor *input)
{
    inheritorList.insert(input);
}

void ObjectManager::RemoveInheritor(Inheritor *input)
{
    inheritorList.erase(input);
}

std::set<Object *>::iterator ObjectManager::GetObjectListBegin()
{
    return objectList.begin();
}

std::set<Object *>::iterator ObjectManager::GetObjectListEnd()
{
    return objectList.end();
}

std::set<Inheritor *>::iterator ObjectManager::GetInheritorListBegin()
{
    return inheritorList.begin();
}

std::set<Inheritor *>::iterator ObjectManager::GetInheritorListEnd()
{
    return inheritorList.end();
}

**

编辑：

** 我已经重写了我的代码以消除对 ObjectManager 的需求。

而不是使用ObjectManager，我想要一个列表的每个类都包含其源文件中的静态列表，因此Object.cppcontainsstatic std::set<Object *> objectList;和Inheritor.cppcontains static std::set<Inheritor *> inheritorList;。

然后，这两个类中的每一个都包含一个静态Count()函数，用于获取其各自列表中的项目数，GetListBegin()以及GetListEnd()获取集合的开头和结尾。

由于函数在基类和派生类中共享相同的名称，因此Object::Count()获取其各自列表中的实例数Object，并Inheritor::Count()获取Inheritor其各自列表中的实例数。

我不知道这是否是一种不好的做法。在每个相应的类之外，没有任何东西可以从列表中添加或删除。我唯一的问题是我不确定如何阻止静态函数在任何东西中可用，Inheritor例如继承自。

4

2 回答 2

0

如果std::set提供了完全正确的接口，那么您可以直接使用它。如果没有（通常是这种情况：它有一个非常广泛的接口），那么您应该编写一个类或一组函数来提供您需要的接口，并适当地实现，也许使用std::set，也许使用其他东西。

于 2013-08-06T14:28:23.733 回答
0

我会将这个集合作为 Object 类的私有静态成员，它会将自身添加到构造函数中的集合中（如果允许，不要忘记复制构造函数）。然后对集合创建一个公共只读访问器（返回 const 引用）。

我不明白您的继承者集的含义。

如果这是游戏引擎中活动对象的列表，我会将其设为引擎类的非静态成员，以跟踪其所有对象。

于 2013-08-06T17:00:55.540 回答