C++ Virtual template method

Question

I have an abstract class (I know that it will not compile this way, but it's for comprehension of what I want to do) :

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); }; 

So when I call setData<double>("foodouble", data) I want the double identified by foodouble (internal mechanism which is not the main concern here) to be set to the double data.

So how to do that?

I think that there may be a mean by typing something like virtual void setData<double>(std::string id, double data) but I don't know how to do it.

Answer 1

The problem is that you cannot mix static time polymorphism (templates) with runtime polymorphism easily. The reason for the language disallowing the particular construct in your example is that there are potentially infinite different types that could be instantiating your template member function, and that in turn means that the compiler would have to generate code to dynamically dispatch those many types, which is infeasible.

There are different things that can be done here to get around the limitation, basically either take away the static or the dynamic polymorphism. Removing dynamic polymorphism from the equation could be done by providing a type that is not derived from, to store the <key,value> mappings, and then offering the template that resolves that only at the base level:

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; }; 

Now deriving classes can access the ValueStore from the base and there is no need for polymorphism. (This can also be done by implementing the functionality directly in AbstractComputation but it probably makes sense to separate concerns)

The other option is to maintain runtime polymorphism, but remove static polymorphism. This can be done by performing type erasure on the base class and then dispatching to the appropriate (non-templated) function that takes the type-erased arguments. The simplest version of this is just using 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; }; 

How type erasure is implemented under the hood is interesting, but out of the scope here, the important part is that a boost::any is a concrete (non-templated) type that can store any type internally by using type erasure on the arguments, and at the same time allows for type-safe retrieval of the data.