c++ - 使用访问器访问静态 std::set 是明智的还是我应该直接访问它？

Question

这个问题来自这个问题的结果: How to automatically maintain a list of class instances?

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

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

这样做还有其他好处吗？或者这是一个糟糕的方法？我从未打算实例化 ObjectManager曾经 - 我是否应该使用我认为称为“免费功能”的东西来管理这个 std::set , 没有课？

我创建了一个测试项目，以简化测试过程。 Inheritor类继承自 Object类(class)。 ObjectManager 的代码类(在本例中由 Main.cpp 、 Object 和 Inheritor 引用，但在我的主要项目中会使用一个非常相似的类)如下:

ObjectManager.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();
};

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.cpp包含 static std::set<Object *> objectList;和 Inheritor.cpp包含 static std::set<Inheritor *> inheritorList; .

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

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

我不知道这样做是否是一种糟糕的方式。在每个相应类别之外的列表中，不能添加或删除任何内容。我唯一的问题是我不确定如何阻止静态函数在继承自 Inheritor 的任何内容中可用。例如。

Answer 1

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