模板对象数组

Question

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

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

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

class Base{
};

我的基类的唯一目的是对派生类的对象数组进行分组。参数 T 通常是双精度型、浮点型或复数型，尽管 int 和结构也可能有用。 （稍后应该有几个更类似的派生类，并具有一些附加功能。）

我可以创建这样一个组

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

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

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

但是我怎样才能发现第 55 个元素稍后的值为 100 ？ 我需要类似的东西

virtual T getValue() = 0;

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

Answer 1

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 2

您可以将重载的 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;
}

注意，您无法用单个模板化方法替换基类中的 has_value 方法，因为虚拟方法无法模板化。

Answer 3

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

Answer 4

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

1. Base 不能是模板，因为你
   想要一个通用句柄来存储
   数组可以包含任何类型
   派生，如 、、、
任何结构。
2. 您不能拥有模板
Base 内的 virtual 方法，
   因为语言不允许

解决这个问题的简单方法是为每种类型提供“getter”方法，例如 get_double()、get_int()、get_float()、get_abc() 等等。但是，您的 Base 将会因此类方法而变得混乱。

Answer 5

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

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

Answer 6

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