有没有一种方法可以让我们在 C++ 中获取一个类的所有对象。就像在 Python 中我们可以做的那样
class_name.objects.all()
获取一个类的所有对象。如果存在，它在 C++ 中的类比是什么？
【问题讨论】：
this作为smart_ptr放入静态vector，而析构函数将其删除。
您可以自己执行此操作，但请确保您知道自己在做什么。
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;
}
注意：上述设计非常基本且不完整，只是为了让您了解如何使用静态成员/函数来实现您所要求的功能。例如，对于您想要对所有对象执行的操作，例如，最好实现一个遍历元素映射的静态函数，而不是获取映射然后在“外部”进行迭代。
我自己从未使用过这种方法，但我能想到的一个潜在用例是，例如在图形或游戏应用程序中，您可能只想绘制范围内的对象并一次性更改所有对象的某些绘图相关属性，例如颜色或大小。我正在开发一个最终可能需要这样的应用程序（一种可视化调试器）。我相信人们可以在 cmets 中提供更多示例。
当涉及到继承时，情况会变得复杂。
【讨论】：
如前所述，C++ 不提供自动执行此操作的机制。但是（再次在 cmets 中已经说明）您可以使用其中一个标准库容器来维护已创建对象的列表，然后在构造函数中注册它们并在析构函数中取消注册它们。下面的示例显示了执行此操作的一种方法...
#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
【讨论】：
据我所知没有办法，但您可以使用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;
}
}
【讨论】：
不，除非您自己实现此机制。默认情况下，它不是由 C++ 语言提供的。
你可以很容易地自己实现这个机制——在构造函数中的某种表中注册类，在析构函数中取消注册。只要关注rule of Three就可以了。
【讨论】：
当然有。只需使用 Factory 模式创建和销毁所有对象，并在 Factory 实现中，在您将提供的 Factory 函数中返回活动对象的集合。
【讨论】：