Storing a pointer to a base object that has template functions - c++

Question

Based on the following code how can I store a pointer to Base in my 'Controller' class?
template< class Derived >
class Base
{
public:
template < typename T >
void Serialise( T* t )
{
Derived* d = static_cast< Derived* >( this );
d->Serialise( t );
}
};
class Derived : public Base< Derived >
{
public:
template < typename T >
void Serialise( T* t )
{
printf( "serialising to object T\n" );
}
};
So if I have a Controller class that will call the Serialise function and pass in the object to serialise to I end up having to store the pointer with its derived type known because it's part of the object's type when what I need is to be able to use the Base type without knowing what it's actual type is:
class Controller
{
public:
void DoSerialise();
private:
Base< Derived >* m_myObject; // I want this to just be Base* m_myObject but cant due to template!
};

Answer 1

Short answer - you can't.
Assuming the template argument doesn't affect Base's interface (ie: Derived doesn't appear in any function signatures) you could have a non template Base class, and the derived classes could be templates. This however doesn't fit at all with your current pattern.
In your case if the template argument DOES affect the interface (and I strongly suspect it does in this case) then the Controller would need to know about Derived in order to use Base, so where's the harm in it also knowing about Derived in order to declare Base.
EDIT after comment:
Are you sure that you want any derived class to be able to serialise to any type? Why not to have a heirarchy of classes that derive from a Serialiser base class, then Serialise() can accept a reference to type Serialiser and lose the template parameter.

Answer 2

You can't do that. But the only thing Base::Serialise does is call the derived class's Serialise method. Why not just make it pure virtual, so that Base doesn't need a template parameter?

Answer 3

The specific approach that you seem to want to take to the problem is not possible because the type of the base class is dependent on the type of the derived class. That means the base class template instantiations cannot be represented as a single type, which would be necessary to achieve the approach you're taking.
However, this looks to be a problem begging for the visitor pattern. The visitor pattern makes double dispatch possible without casting, which is exactly what you want here. Here's a possible solution:
// First declare a base serializable interface that accepts a serializer.
struct ISerializer;
struct ISerializable {
virtual void accept_serializer(ISerializer const &) const = 0;
};
// Now declare a base serializer type that can accept any serializable type.
struct Serializable1;
struct Serializable2;
...
struct ISerializer {
virtual void serialize(Serializable1 const &) = 0;
virtual void serialize(Serializable2 const &) = 0;
...
};
// Then implement your concrete serializable types to accept the serializer and
// invoke it on themselves.
struct Serializable1 : public ISerializable {
void acceptSerializer(ISerializer const &s) const {
s.serialize(*this);
}
};
struct Serializable2 : public ISerializable {
void acceptSerializer(ISerializer const &s) const {
s.serialize(*this);
}
};
// You can actually be a bit more clever to eliminate redundant code:
template<typename DerivedT>
struct SerializableAdapter {
void acceptSerializer(ISerializer const &s) const {
s.serialize(*static_cast<DerivedT const *>(this));
}
};
struct Serializable1 : public SerializableAdapter<Serializable1> {
};
struct Serializable2 : public SerializableAdapter<Serializable2> {
};
// Finally, implement your concrete serializers, including one function for each
// serializable type.
struct Serializer1 : public ISerializer {
void serialize(Serializable1 const &s) const {
...
}
void serialize(Serializable2 const &s) const {
...
}
};
struct Serializer2 : public ISerializer {
void serialize(Serializable1 const &s) const {
...
}
void serialize(Serializable2 const &s) const {
...
}
};
// Now you can store the serializers through the base interface.
struct Controller {
void doSerialize(ISerializable &p_serializable) {
p_serializable.acceptSerializer(*m_serializer)
}
private:
ISerializer *m_serializer;
};