Question

I’m trying to use the visitor pattern to serialize the contents of objects. However one snag I’m hitting is when I’m visiting strings. My strings are of a templated type, similar to STL’s basic_string. So something like:

basic_string<char_type, memory_allocator, other_possible_stuff> \\ many variations possible!

Since I can have very many different templated string types, I can’t go and add them to my visitor interface. It would be ridiculous. But I can’t add templates to my VisitString method because C++ prevents using templates parameters in virtual methods.

So what are my options to work around this?

EDIT: I’ve added some basic code

class IVisitor
{
public: 
     virtual void VisitString(some_kind_of_string_type string) = 0; // this is what I want in theory
};

class MyObject
{
public:
    typedef basic_string<char8, myAllocator, some_flag> MyStringType;
    Accept(IVisitor* visitor)
    {
        visitor->VisitString(mString); 
    }
private:
   MyStringType string;
};

class MyOtherObject
{
public:
    typedef basic_string<char16, myOtherAllocator, some_other_flag> MyOtherStringType;
    Accept(IVisitor* visitor)
    {
        visitor->VisitString(mString); 
    }
private:
   MyOtherStringType string;
};


class Reader : public IVisitor
{ 
public:
    virtual void VisitString(some_kind_of_string_type string)
    {
         // read some data, give it to the string
    }
}

Answer 1

In the end, I went with a slightly different approach. Instead of hoping to use a visitor with templated methods (which is, of course, impossible), I decided to pass a visitor-like class as a template parameter to my object’s visit method. Totally simplified example:

class SomeKindOfVisitor // doesn't need to derive from a base class. 
{
     template <class StringClass>
     void VisitString(StringClass& string) // I get to keep templated methods
}


class MyObject
{
typedef basic_string<char8, myAllocator, some_flag> MyStringType;

public:

   template <class VisitorClass>
   void Accept(VisitorClass& visitor)
   {
       vistior.VisitString<MyStringType>(mMyString);
   }
private:
    MyStringType mMyString;
}

With this method, I still get to use my templated strings while still being able to pass any kind of “visitor” to my objects.