C++ C++；模板类的向量，多态性

每次创建一个对象时，我都会将该对象的指针存储在一个向量中，该向量是对象类的静态成员，以便监视其状态，如下所示：

class A {
private:
    static std::vector<A *> as;
    STATE state = NONE; //<- enum
    void doSomething();

public:
    A() {
        as.push_back(this);
    }

    static void monitor() {
        auto end = as.end();

        for (auto obj = as.begin(); obj != end; obj++) {
            switch ((*obj)->state) {
                //process it
                (*obj)->doSomething();
            }
        }
    }
}

//// recurrent call in other part of the program or even in other thread
A::monitor();

A类{
私人：
静态std：：向量as；
状态=无；//状态）{
//处理它
（*obj）->doSomething（）；
}
}
}
}
////程序的其他部分甚至其他线程中的重复调用
A：：monitor（）；

上面的代码显然不完整，缺少适当的析构函数，无法删除正在删除的向量的指针

现在的问题是，我必须对模板类执行同样的操作

template <typename T>
class A {            

    void doSomething(); //<--independent, no template
    ....
}

模板
A类{
void doSomething（）；//您也可以这样做：

template <typename T>
class A {
private:
    static std::vector<A<T>*> as;
    STATE state = NONE; //<- enum
    void doSomething()

public:
    A() { as.push_back(this); }

    static void monitor() {
        auto end = as.end();

        for (auto obj = as.begin(); obj != end; obj++) {
            switch ((*obj)->state) {
                //process it
                (*obj)->doSomething();
            }
        }
    }
}

template <typename T>
std::vector<A<T>*> as;

模板
甲级{
私人：
静态std：：向量as；
状态=无；//状态）{
//处理它
（*obj）->doSomething（）；
}
}
}
}
模板
std：：向量as；

你只要打个电话就行了

A<MyType>::monitor();

A:：monitor（）；
您也可以这样做：

template <typename T>
class A {
private:
    static std::vector<A<T>*> as;
    STATE state = NONE; //<- enum
    void doSomething()

public:
    A() { as.push_back(this); }

    static void monitor() {
        auto end = as.end();

        for (auto obj = as.begin(); obj != end; obj++) {
            switch ((*obj)->state) {
                //process it
                (*obj)->doSomething();
            }
        }
    }
}

template <typename T>
std::vector<A<T>*> as;

模板
甲级{
私人：
静态std：：向量as；
状态=无；//状态）{
//处理它
（*obj）->doSomething（）；
}
}
}
}
模板
std：：向量as；

你只要打个电话就行了

A<MyType>::monitor();

A:：monitor（）；
这是一个非常好的解决方案，但我计划将该类用作一种接口，因此，对每个类进行调用有点乏味。@quetzalfir:因此，似乎您希望每个
类a
都派生自某个
Base
（可以在其中移动该实现），然后执行
Base:：monitor（）
这是一个非常好的解决方案，但我计划将该类用作一种接口，因此，对每个类进行调用有点乏味。@quetzalfir:看来您希望每个
类a
都派生自某个
基
（可以移动该实现），然后执行
基：：监视器（）