C++ 虚拟模板方法

Question

我有一个抽象类（我知道它不会这样编译，但它是为了理解我想做的事情）：

class AbstractComputation {
    public:
        template <class T> virtual void setData(std::string id, T data);
        template <class T> virtual T getData(std::string id);
};

class Computation : public AbstractComputation {
    public:
        template <class T> void setData(std::string id, T data);
        template <class T> T getData(std::string id, T data);
};

所以当我调用setData<double>("foodouble", data) 时，我希望将foodouble 标识的双精度（这里不是主要关注的内部机制）设置为双精度数据。

那该怎么做呢？

我认为输入virtual void setData<double>(std::string id, double data) 之类的内容可能是一种意思，但我不知道该怎么做。

Answer 1

问题是您不能轻易地将静态时间多态性（模板）与运行时多态性混合在一起。语言不允许您的示例中的特定构造的原因是，可能有无限种不同的类型可以实例化您的模板成员函数，这反过来意味着编译器必须生成代码来动态调度这些类型，这是不可行的。

这里可以做不同的事情来绕过这个限制，基本上要么去掉静态多态性，要么去掉动态多态性。从方程中删除动态多态性可以通过提供一个不是派生自的类型来存储<key,value> 映射，然后提供仅在基本级别解决该问题的模板：

class AbstractComputation {
public:
   template <typename T>
   void setData( std::string const & id, T value ) {
      m_store.setData( id, value );
   }
   template <typename T>
   T getData( std::string const & id ) const {
      return m_store.getData<T>( id );
   }
protected:
   ValueStore m_store;
};

现在派生类可以从基类访问ValueStore，并且不需要多态性。 （这也可以通过直接在AbstractComputation 中实现功能来完成，但分离关注点可能是有意义的）

另一种选择是保持运行时多态性，但删除静态多态性。这可以通过在基类上执行类型擦除，然后分派到采用 type-erased 参数的适当（非模板化）函数来完成。最简单的版本就是使用boost::any：

class AbstractComputation {
public:
   template <typename T>
   void setData( std::string const & id, T value ) {
      setDataImpl( id, boost::any( value ) );
   }
   template <typename T>
   T getData( std::string const & id ) const {
      boost::any res = getDataImpl( id );
      return boost::any_cast<T>( res );
   }
protected:
   virtual void setDataImpl( std::string const & id, boost::any const & value ) = 0;
   virtual boost::any getDataImpl( std::string const & id ) const = 0;
};

类型擦除是如何在底层实现的很有趣，但超出了这里的范围，重要的部分是boost::any 是一个可以存储任何的具体（非模板化）类型通过在参数上使用类型擦除在内部键入，同时允许对数据进行类型安全的检索。

Answer 2

在某些情况下，将模板从方法级别移动到类级别可能就足够了，例如：

#include <iostream>

template<typename T>
class AbstractComputation {
public:
    virtual void setData(std::string id, T data)
    {
        std::cout << "base" << std::endl;
    }
};

template<typename T>
class Computation : public AbstractComputation<T> {
public:
    virtual void setData(std::string id, T data)
    {
        std::cout << "derived" << std::endl;
    }
};

int main()
{
    AbstractComputation<int> *x = new Computation<int>();

    x->setData("1", -1);

    delete x;
    return 0;
}

Answer 3

在您的情况下，您可能可以使用boost::any。

virtual void setData(std::string id, boost::any data);

它是一个几乎可以封装任何东西的包装器。

More info on a similar topic in this answer.

Answer 4

首先，您不能拥有virtual 模板函数。由于模板在编译时解析，virtual 将不起作用，因为编译器不知道要选择哪个模板。有关更多信息，请参阅here。

Answer 5

使用boost::any 接受数据，然后在实际设置时，从中获取正确的类型。

Answer 6

如果您事先知道可能的类型列表，预处理器可能会有所帮助：

#define MY_CLASSES MYTYPE(int) MYTYPE(float) MYTYPE(double)

class AbstractComputation {
    public:
#     define MYTYPE(T) virtual void setData(std::string id, T data)=0;\
                       virtual void getData(std::string id, T& dst_data)=0;
      MY_CLASSES
#     undef MYTYPE
};

class Computation : public AbstractComputation {
    public:
#     define MYTYPE(T) virtual void setData(std::string id, T data){std::cout<<"writing: "<<data<<std::endl;}\
                       virtual void getData(std::string id, T& dst_data){dst_data=0;/*put your actual implementation here*/}
      MY_CLASSES
#     undef MYTYPE
};

如果您不知道可能类型的完整列表，也许您的问题无法解决。正如其他人所提到的，类型擦除也可能会有所帮助..但并非在所有情况下都有效。