C++ - 将可变参数模板类对象推入向量

Question

class Base
{
public:
    virtual void foo() = 0;
};

class A : public Base
{
public:
    void foo() override { std::cout << "A\n"; }
};

class B : public Base
{
public:
    void foo() override { std::cout << "B\n"; }
};

class Registry
{
public:
    static Registry& instance()
    {
        static Registry s_instance;
        return s_instance;
    }

    void register_foo(Base* foo) 
    { 
        m_vec.emplace_back(foo); 
    }

private:
    std::vector<Base*> m_vec;
};

template<typename ... T>
class Foo : public T...
{
public:
    Foo()
    { 
        Registry::instance().register_foo(this);
    }

    void test() { (T::foo(), ...); }
};

int main()
{
    auto f1 = std::make_unique<Foo<A, B>>();
    auto f2 = std::make_unique<Foo<A>>();

    f1->test();
    f2->test();
}

如您所见，我有一个 Base 类、A 类和 B 类。

A 和 B 继承自 Base。 Foo 类是一个模板类，它带有可变参数模板。 这个想法是能够将A 和B 类传递到Foo。 然后这个Foo注册在Registry类中/推入一个向量中。

问题如下 - 如您所见，我可以同时拥有 Foo<A> 和 Foo<A, B>，或 Foo<B, A>。 我怎样才能有一个可以接受所有可能类型的Foo的向量？

Answer 1

一个简单的通用基类怎么样？

class FooBase {
public:
    virtual ~FooBase() {}

    virtual void test() = 0;
};

template<typename... T>
class Foo : public FooBase, public T...
{
public:
    Foo() { }

    void test() override { (T::foo(), ...); }
};

int main()
{
    auto f1 = std::make_unique<Foo<A, B>>();
    auto f2 = std::make_unique<Foo<A>>();

    std::vector<std::unique_ptr<FooBase>> foos;

    foos.push_back(std::move(f1));
    foos.push_back(std::move(f2));
}

Answer 2

std::vector 拥有 一个 类型的对象。您不能将不同类型的对象放入同一个向量中（从具有不同模板参数的模板创建的对象是不同的类型）。

一个选项（我不推荐它）是拥有一个包含std::any 实例的向量 - 有效，但使用起来很麻烦且效率低下。另一种选择是指向公共基类的指针向量并利用多态性。第三种选择是为每种类型的对象简单地使用单独的向量。