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.

Is this question about how to create a special case for doubles. Or how to generically set any datatype though the use of one template function. — rerun
– rerun, Commented Nov 1, 2011 at 14:36
Possible duplicate of Can a member function template be virtual? — Niall
– Niall, Commented Jan 8, 2016 at 7:46
Ugh ... If a type has two methods named "set data" and "get data", is then "abstract computation" first you can think of when naming that type? — Chef Gladiator
– Chef Gladiator, Commented Jun 27, 2019 at 9:21

David Rodríguez - dribeas · Accepted Answer · 2011-11-01 14:45:19Z

75

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.

answered Nov 1, 2011 at 14:45

David Rodríguez - dribeas

209k23 gold badges304 silver badges497 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

Craig Reynolds Over a year ago

I liked the approach using boost::any but did not like adding a dependency on Boost. But happily, six years later c++17 added std::any (and std::variant) to the language. I ended up using std::any to have a single API across arbitrary user-defined types.

Miroslav Krajcir Over a year ago

David how does the ValueStore class look like?

TobiMcNamobi · Accepted Answer · 2014-12-16 14:06:43Z

19

In some cases it may be enough to move the templating from method level to class level, e.g.:

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

answered Dec 16, 2014 at 14:06

TobiMcNamobi

4,8433 gold badges35 silver badges52 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 11:46:55Z

3

You can probably use boost::any in your case.

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

It is a wrapper that can encapsulate almost anything.

More info on a similar topic in this answer.

edited May 23, 2017 at 11:46

CommunityBot

11 silver badge

answered Nov 1, 2011 at 14:34

jpalecek

47.9k7 gold badges105 silver badges147 bronze badges

Comments

Community · Accepted Answer · 2017-05-23 11:46:55Z

3

First, you cannot have virtual template functions. As templates are resolved at compile time, virtual will not work, as the compiler would not know which template to pick. See here, for more info about this.

edited May 23, 2017 at 11:46

CommunityBot

11 silver badge

answered Nov 1, 2011 at 14:43

Tony The Lion

63.6k71 gold badges252 silver badges424 bronze badges

Comments

user396672 · Accepted Answer · 2011-11-01 15:26:15Z

If you know list of possible types in advance, preprocessor may help:

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

If you don't know a complete list of possible types, perhaps, your problem is unresolvable. Type erasure, as mentioned by others, may also help.. but not in all circumstances.

Nim · Accepted Answer · 2011-11-01 14:34:50Z

1

Use boost::any to accept the datum, and then when you actually set, grab the correct type from it.

answered Nov 1, 2011 at 14:34

Nim

33.7k2 gold badges65 silver badges102 bronze badges

Collectives™ on Stack Overflow

C++ Virtual template method

6 Answers 6

2 Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

6 Answers 6

2 Comments

Comments

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related