6

有没有一种方法可以让我们在 C++ 中获取一个类的所有对象。就像在 Python 中我们可以做的那样

class_name.objects.all()

获取一个类的所有对象。如果它存在，它在 C++ 中的模拟是什么？

4

5 回答 5

13

您可以自己执行此操作，但请确保您知道自己在做什么。

如何：

C++ 中没有任何东西已经做到了这一点，但你自己很容易做到这一点。关键是要认识到一个类可以有静态成员变量和函数（即属于整个类的函数，而不是属于类的单个对象）。

因此，您可以使用某种表或其他数据结构来存储对每个对象的引用。像这样：

class A {

public:
  //constructor assigns this object an id based on the static value curID,
  //which is common to the class (i.e. the next class to call the constructor 
  //will be assigned an id thats 1 more than this one
  //also, constructor adds the pointer to this object to a static map of ids 
  //to objects. This way, the map can be queried for the pointer to an object 
  //that has a particular id
  A() { 
    id = curID++;
    objects[id] = this;
  }

  //copy constructor ensures an object copied from another does not 
  //take the id of the other object, and gets added to the map
  A(const A&) {
    id = curID++; //don't want have the same ID as the object we are copying from
    objects[id] = this;
    x = A.x;
    y = A.y;
  }

  A&  operator=(const A&) {
    id = curID++;
    objects[id] = this;
    x = A.x;
    y = A.y;
    return *this; 
  }

  //destructor removes the pointer to this object from the map
  ~A() {
    objects.erase(id);
  }

  //function to get the map that stores all the objects
  static map<int, A*>& GetMapOfObjects() { 
    return objects;
  }

private:
  //the following variable is **static**, which means it does not
  //belong to a single object but to the whole class. Here, it is
  //used to generate a unique ID for every new object that's 
  //instantiated. If you have a lot of objects (e.g. more than
  //32,767), consider using a long int
  static int curID;  

  //this variable is also static, and is map that stores a pointer
  //to each object. This way, you can access the pointer to a
  //particular object using its ID. Depending on what you need, you
  //could use other structures than a map
  static map<int, A*> objects; 


  //this is a (non-static) member variable, i.e. unique to each object.
  //Its value is determined in the constructor, making use of curID.
  int id;

  //these are some other member variables, depending on what your object actually is
  double x;
  double y; 
}

注意：上述设计非常基本且不完整，但只是为了让您了解如何使用静态成员/函数来实现您所要求的内容。例如，对于您想要对所有对象执行的操作，最好实现一个迭代元素映射的静态函数，而不是获取映射然后在“外部”进行迭代。

为什么：

我自己从未使用过这种方法，但我能想到的一个潜在用例是在图形或游戏应用程序中，您可能只想绘制范围内的对象 并更改所有这些对象的某些与绘图相关的属性一次，例如颜色或尺寸。我正在开发一个可能最终需要这样的应用程序（一种可视化调试器）。我相信人们可以在评论中提供更多示例。

为什么不：

当涉及到继承时，情况会变得复杂。

  • 如果您有一个派生自 A 的 B 类（即 B“是”A），那么谁应该跟踪 B 的对象？A 中的对象的静态成员，或 B 中的类似对象，或两者兼而有之？
  • 让我们说两个。那么如果适用于 A 中所有对象的静态函数在每个对象上调用虚拟成员函数会发生什么？如果虚函数已在派生类中被覆盖，则将为 A 类中跟踪的所有实际上是 B 对象的对象调用该函数。如果你在 B 中的另一个静态函数中再次调用该函数会发生什么？
于 2013-07-07T05:48:18.903 回答
6

我不知道有没有办法，但你可以与static成员一起实施

#include <iostream>
#include <vector>
class MyClass{
private:
 static std::vector<MyClass*> objList;
public:
 MyClass() {
  objList.push_back(this);
 }
 static std::vector<MyClass*> getAllObjects(){
  return objList;
 }
};

std::vector<MyClass*> MyClass::objList;

main(){
 MyClass m,a;
 for (int i=0;i<MyClass::getAllObjects().size();i++){
  std::cout<<MyClass::getAllObjects()[i]<<std::endl;
 }
}
于 2013-07-07T05:48:48.763 回答
3

不，除非你自己实现这个机制。默认情况下，它不是由 C++ 语言提供的。

你可以很容易地自己实现这个机制——在构造函数中的某种表中注册类，在析构函数中取消注册。只要你遵循三规则，它就可以正常工作。

于 2013-07-07T05:28:23.083 回答
2

当然有。只需使用工厂模式来创建和销毁所有对象，并在工厂实现中返回您将提供的工厂函数中的活动对象集合。

于 2013-07-07T05:35:49.200 回答
1

如前所述，C++ 不提供自动执行此操作的机制。但是（再次在评论中已经说明）您可以使用标准库容器之一来维护已创建对象的列表，然后在构造函数中注册它们并在析构函数中取消注册它们。下面的示例显示了执行此操作的一种方法...

#include <iostream>
#include <memory>
#include <utility>
#include <map>
#include <algorithm>
#include <iterator>
#include <typeinfo>
#include <vector>

class Object
{
    static std::map<const Object*, Object*> objects_;

public:

    Object()
    {
        objects_.insert(std::make_pair(this, this));
    }

    virtual ~Object()
    {
        objects_.erase(this);
    }

    static std::vector<Object*> get_all()
    {
        std::vector<Object*> o;
        o.reserve(objects_.size());
        for (auto obj : objects_)
        {
            o.push_back(obj.second);
        }
        return std::move(o);
    }

    template<class Type>
    static std::vector<Type*> get_bytype()
    {
        std::vector<Type*> o;
        for(auto obj : objects_)
        {
            Type *t = dynamic_cast<Type*>(obj.second);
            if (t != nullptr)
            {
                o.push_back(t);
            }
        };
        return std::move(o);
    }


    void print() const
    {
        std::cout << "I'm a " << typeid(*this).name() << " object @ " << this << std::endl;
    }
};

std::map<const Object*, Object*> Object::objects_;

class Foo : public Object {};
class Bar : public Object {};
int main()
{
    std::unique_ptr<Object> o1 = std::unique_ptr<Object>(new Foo());
    std::unique_ptr<Object> o2 = std::unique_ptr<Object>(new Bar());
    std::unique_ptr<Object> o3 = std::unique_ptr<Object>(new Foo());
    std::unique_ptr<Object> o4 = std::unique_ptr<Object>(new Bar());

    std::vector<Object*> objects = Object::get_all();
    for (auto o : objects)
    {
        o->print();
    }

    std::cout << "-----" << std::endl;

    std::vector<Foo*> foos = Object::get_bytype<Foo>();
    for (auto o : foos)
    {
        o->print();
    }

    std::cout << "-----" << std::endl;

    std::vector<Bar*> bars = Object::get_bytype<Bar>();
    for (auto o : bars)
    {
        o->print();
    }
}

上面的示例产生以下输出

我是 Foo 类对象 @ 003FED00
我是 Bar 类对象 @ 003FED30
我是 Foo 类对象 @ 003FED60
我是 Bar 类对象 @ 003FED90

我是 Foo 类对象 @ 003FED00
我是 Foo 类对象 @ 003FED60

我是类 Bar 对象 @ 003FED30
我是类 Bar 对象 @ 003FED90

于 2013-07-07T05:55:29.497 回答