将模板化基类的子类添加到没有超基类的容器？

Question

我正在尝试创建一个向量（或任何 STL 容器，实际上），它可以包含一组不同的对象，这些对象是一种特定类型的子类。问题是我的基类是模板化的。

据我所知，我必须创建一个接口/抽象超级基类（不确定首选的 C++ 术语是什么）。我不想这样做，而只使用我的（模板化的）抽象基类。下面是一些示例代码。

基本上，有没有办法不需要WidgetInterface？以某种方式告诉编译器忽略模板要求？如果我必须有WidgetInterface，我是否会按照以下方式进行正确的操作？

#include <vector>
#include "stdio.h"

enum SomeEnum{
    LOW = 0,
    HIGH = 112358
};

// Would like to remove this WidgetInterface
class WidgetInterface{
public:
    // have to define this so we can call it while iterating
    // (would remove from Widget if ended up using this SuperWidget
    // non-template baseclass method)
    virtual void method() = 0; 
};

template <class TDataType>
class AbstractWidget : public WidgetInterface{
public:
    TDataType mData;
    virtual void method() = 0;
    // ... bunch of helper methods etc
};

class EnumWidget : public AbstractWidget<SomeEnum>{
public:
    EnumWidget(){
        mData = HIGH;
    }
    void method(){
        printf("%d\n", mData); // sprintf for simplicity
    }
};

class IntWidget : public AbstractWidget<int>{
public:
    IntWidget(){
        mData = -1;
    }
    void method(){
        printf("%d\n", mData); // sprintf for simplicity
    }
};


int main(){
    // this compiles but isn't a workable solution, not generic enough
    std::vector< AbstractWidget<int>* > widgets1; 

    // only way to do store abitary subclasses?
    std::vector<WidgetInterface*> widgets2; 
    widgets2.push_back(new EnumWidget());
    widgets2.push_back(new IntWidget());

    for(std::vector<WidgetInterface*>::iterator iter = widgets2.begin();
        iter != widgets2.end(); iter++){
        (*iter)->method();
    }

    // This is what i'd _like_ to do, without needing WidgetInterface
    // std::vector< AbstractWidget* > widgets3; 

    return 0;
}

Answer 1

不，您不能直接将AbstractWidget 用作STL 容器或其他任何东西的参数。 原因是类AbstractWidget不存在。它只是一个模板，供编译器从中构造类。

存在AbstractWidget<SomeEnum> 和AbstractWidget<int> 只是因为EnumWidget 和IntWidget 从它们继承而来。

模板仅存在于编译器级别。如果AbstractWidget<T> 没有在您的代码中的任何地方使用，则在运行时没有任何痕迹。

因此，您发布的代码似乎是解决您问题的最佳（如果不是唯一）解决方案。

Answer 2

您所做的是解决方案：您需要一个 common 类/接口，并且由于 AbstractWidget 是类模板，因此它不能用作所有具体类的公共类模板参数不同。所以我认为，你应该采用这种类设计。这似乎是一个相当合理的解决方案。

Answer 3

实际上AbstractWidget<int> 和AbstractWidget<double> 类是不同的类，因此您的类 IntWidget 是第一个类的子类，但与第二个无关。您需要有一个公共父类才能放入向量中，因此很遗憾您无法避免未模板化的公共接口。

Answer 4

这可能是完全错误的方向，但你能做这样的事情吗：

template <class T>
class ConcreteWidget : public AbstractWidget<T>
{
};

然后使用模板专业化来定义您的特定小部件，如下所示：

template <>
class ConcreteWidget : public AbstractWidget<int>
{
public:
    ConcreteWidget() : mData(-1) {}
};

template <>
class ConcreteWidget : public AbstractWidget<SomeEnum>
{
public:
    ConcreteWidget() : mData(HIGH) {}
};

因此，与其拥有一个 IntWidget 和一个 EnumWidget，不如拥有一个 ConcreteWidget 和 ConcreteWidget，然后可以简单地拥有一个 vector<WidgetInterface>，这将是所有这些通用子级的超级？

我不确定这是否能解决您的问题，或者是否会起作用。我希望得到有关此答案的反馈。