模板对象数组

Question

我不知道如何解决模板和继承问题。

在我的代码中有一个模板类，看起来或多或少像：

template<typename T>
class Derived : public Base{
     T value;
public:
     Derived(T arg) { value=arg; };
     T getValue() { return value;};
};

class Base{
};

我的 Base 类的唯一目的是对 Derived 类的对象数组进行分组。参数 T 通常是 double、float 或 complex，尽管 int 和 structs 也可能有用。 （稍后应该会有更多类似的派生类，并带有一些附加功能。）

我可以创建这样的组

Base** M = new Base*[numElements];

并将派生类的元素分配给它们，例如：

M[54] = new Derived<double>(100.);

但是我怎样才能知道第 55 个元素的值是 100 呢？ 我需要类似的东西

virtual T getValue() = 0;

但是 T 是派生类的类型名，对于这个数组的任意两个元素可能不同。

Answer 1

将方法“getDouble”添加到您的基类。然后，派生类必须实现此方法，并在需要时将自己的类型转换为 double。

Answer 2

您可以使用 dynamic_cast 来了解它是什么类型（除了 @StackedCrooked 所说的）。 它需要在基类中定义一些虚函数，但您已经需要一个虚析构函数（能够通过基类指针删除值）。

作为替代方案，您可以尝试 boost::variant 或 boost::any :)

Answer 3

没有。实际上不可能有这样的功能，原因有两个：

1. Base 不能是模板，因为你 想要一个通用句柄来存储 可以包含任何类型的数组 Derived 喜欢 <int>, <double>, <float>, any struct <abc>。
2. Base 内不能有template virtual 方法， 因为语言不允许

解决这个问题的简单方法是为get_double()、get_int()、get_float()、get_abc() 等每种类型设置“getter”方法。但是，您的Base 会被这些方法弄得一团糟。

Answer 4

Visitor 模式可能是您最好的选择。迭代数组的代码必须提供一个知道如何处理各种类型的“Visitor”对象。

struct NumericVisitor
{
    virtual void visit(double) = 0;
    virtual void visit(int) = 0;
    virtual void visit(unsigned char) = 0;
};

struct Visitable
{
    virtual void visitValue(NumericVisitor& visitor) = 0;
};

template<typename T>
class Derived : public Visitable
{
     T value;
public:
     Derived(const T& arg) value(arg) {}
     void visitValue(NumericVisitor& visitor) { visitor.visit(value); }
};

现在您可以为要对集合执行的每个操作定义访问者，例如将每个元素转换为字符串，为每种类型使用不同的格式，或者将每个元素存储到一个文件中，其中每种类型可以占用不同的空间量。

Answer 5

使用 boost::any 将对象存储在数组中。然后当你想对其进行操作时，你可以将 boost::any_cast 用于你可能拥有的类型。

Answer 6

您可以将重载的 has_value() 方法添加到 Base 类：

class Base
{
public:
    virtual ~Base () {}
    virtual bool has_value (int i) {return false;}
    virtual bool has_value (double d) {return false;}
    virtual bool has_value (const std::string& s) {return false;}
    // etc.
};

您在 Derived 类中覆盖的其中一个：

template<typename T>
class Derived : public Base
{
     T value;
public:
     Derived(T arg) {value=arg;}
     T getValue() { return value;}

     virtual bool has_value (T t)
     {
         return t == value;
     }
};

例如：

bool test ()
{
    std::vector<Base*> bases;
    bases.push_back (new Derived<double> (1.234));
    bases.push_back (new Derived<int> (100));
    bases.push_back (new Derived<std::string> ("zap"));

    for(std::vector<Base*>::const_iterator iter = bases.begin (); iter != bases.end (); ++iter)
        if ((*iter)->has_value (100))
            return true;
    return false;
}

请注意，您不能将 Base 类中的 has_value 方法替换为单个模板化方法，因为虚拟方法无法模板化。