Work around for limitation of template virtual member functions?

[rozick1]

Hi

I have a Message class which other classes inherit from. The inherited classes will need to have a serialisation member function. I would like to make these member functions virtual (so that I take advantage of dynamic dispatch).

So as an example:

  class Message
  {
     private:
       int x;

     public:

     virtual void serialise(char* str)
     {
          // do serialisation
     }

  };

  class MessageWStr : public Message
  {

     private:
       
        string str;

     public:

     virtual void serialise(char* str) override
     {
          // do serialisation
     }

  };

The problem arises with the serialisation library which I'm using which requires the class (being serialised) to have a template member function of the form:

// in Message
template <typename T>
void serialize(T& t)
{
   t.saveInt(x); // serialisation library function - serialises member variable x
}

// in MessageWStr
template <typename T>
void serialize(T& t)
{
   t.saveStr(str); // serialisation library function - serialises member variable str
}

However, I cannot make these functions virtual as apparently c++ does not permit virtual template member functions.

I wondered if anyone might know of a solution to this problem?

Thanks

[mbozzi]

You could use some special-case code for each class, or exploit that T is constrained and put it inside some polymorphic wrapper.

To restate, the problem is to call A::f polymorphically.

struct A    { template <typename T> void f() {}; };
struct B: A { template <typename T> void f() {}; };
struct C: A { template <typename T> void f() {}; };

The first way is just to have some special cases:

template <typename T>
    void f(A* pa)
    {
      if (B* pb = dynamic_cast<B*>(pa)) pb->f<T>(); else
      if (C* pc = dynamic_cast<C*>(pa)) pc->f<T>(); else pa->f();
    }

And then to arrange to call this instead of f, which can essentially be done by implementing a less-general version of the visitor pattern and making this function into the visitor.

A second way is to exploit the commonality between every T that is passed to serialize. An example of that commonality could be that every T has a member function whose signature is void saveInt(int).

Maybe look up "visitor pattern" and "c++ type erasure".