4

早上好，

我有一个模板化的类，我想通过指针向量来操作对象。要使用指向模板化类的指针向量，我需要从非模板化类派生这个类，我做到了。

这是我的问题：要从指向基类的指针调用派生类的方法，我不能使用虚函数，因为不能将模板函数设为虚函数。我需要进行显式转换，这很乏味：一旦使用 new 创建了一个数字对象，事实上，需要对 number* 进行向下转换，尽管事先知道该对象是数字。

我以一种尴尬的方式解决了这个问题：函数 myset 测试所有支持的 typeid 值以获得正确的动态转换。它是一系列执行 typeid 检查的嵌套 if。

除了繁琐之外，该函数仅适用于调用'set'方法，并且应该定义类似的函数来调用其他方法。如果我可以对我所指向的对象进行自动转换，那一切都会简单得多。

该方法的缺点是：

  1. 代码是重复的：如果我定义了另一个函数（例如 T get() {return val;}，我需要另一个带有全套嵌套 if 的 myget 函数！
  2. 支持的类型列表必须通过嵌套 if 调用显式定义
  3. 代码可能效率低下

编译器知道 lst[0]（在下面的代码中）指向一个数字对象，尽管 lst 是一个元素对象的向量，从中派生出 number<> 对象。

是否有一种方法可以自动将定义为 base* 的指针向下转换为指向实际指向的对象的指针？

如果我有正确的向下转换，那么我可以在 number<> 类中定义数以千计的方法并使用正确转换 -> function(...) 调用来调用它们

这是代码（它可以正常工作，核心是“myset”的定义）

在此先感谢，Pietro M.

PS 我最感兴趣的是标准 C++ 方法，而不使用除 STL 之外的其他库，例如 Boost。

#include <iostream>
#include <vector>
#include <typeinfo>

using namespace std;

class element
{
public:
    virtual void print() = 0; // print is not templatized and works properly
    //template <class T> virtual set(T v) = 0; // this would solve all my problems, if only it were legal.
};

template <class T>
class number : public element
{
    T val;
public:
    void print() {cout << "number is " << val << endl;}
    void set(T v) {val = v;}
};

// That's the best I can do!
template <class T>
void myset(T v, element *ptr)
{
    // There is a kink in the template: the compiler checks the T type by the value of v, that in this case is an integer:
    // cout << "Type name for the template is: " << typeid(T).name() << endl;
    // cout << "Type name for an integer is:   " << typeid(int).name() << endl;

    if (typeid(*ptr) == typeid(number<double>))
    {
        ((number<double> *) ptr) -> set(7);
        return;
    }
    else if (typeid(*ptr) == typeid(number<float>))
    {
        ((number<float> *) ptr) -> set(7);
        return;
    }
    // add other types... (tedious)
    else
    {
        cout << "type not supported" << endl;
    }
}

int main()
{
    vector <element *> lst; // list of heterogeneous templatized objects
    lst.push_back(new number<float>);
    lst.push_back(new number<double>);

    lst[0] -> print();

    //((number<float> *) lst[0]) -> set(7); it's correct but it requires I know the type when I call it (tedious)

    myset(7, lst[0]); // may be inefficient, but it works (for the types which are explicitly supported)

    // cast_to_what_the_pointer_actually_points_to <lst[0]> -> set(7); // that's what I'd like to do: a downcast function which checks the object type and returns the correct pointer would be able to call any class method...

    lst[0] -> print();
}
4

1 回答 1

3

你快到了。您需要有一个模板化方法，该方法使用和指向其参数的指针set调用私有虚拟方法，从而允许覆盖决定如何处理它：typeidvoid *

class element
{
    virtual void set_impl(const std::type_info &, const void *) = 0;
public:
    template <class T> void set(T v) { set_impl(typeid(v), &v); }
};

以及如何编写的示例set_impl：

template <class T>
class number : public element
{
    T val;
    void set_impl(const std::type_info &ti, const void *pv) {
        if (ti == typeid(T)) {
            val = *static_cast<const T *>(pv);
        } else {
            throw std::invalid_argument("incorrect type to set()");
        }
    }
};

这类似于Boost.Any采用的方法。

于 2013-07-22T10:15:45.110 回答