C++访问者模式处理模板化字符串类型？

Question

我正在尝试使用访问者模式来序列化对象的内容。然而，我遇到的一个障碍是当我访问字符串时。我的字符串是模板类型，类似于STL的basic_string。就像这样：

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

由于我可以有很多不同的模板化字符串类型，所以我无法将它们添加到我的访问者界面中。这太荒谬了。但我无法将模板添加到 VisitString 方法中，因为 C++ 禁止在虚拟方法中使用模板参数。

那么我有什么选择来解决这个问题呢？

编辑：我添加了一些基本代码

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

您需要运行时多态性吗？

struct object {
   template <typename Visitor>
   void accept( Visitor & v )
   {
      v( x );
      v( a );
   }

   int x;
   std::string a;
};
struct complex_object {
   template <typename Visitor>
   void accept( Visitor & v ) {
      v( i );
      o.accept(v); // [1]
   }
   int i;
   object1 o;
};

struct DumpScreenVisitor {
   void operator()( int x ) { std::cout << x << std::endl; }
   template <typename char_t, typename traits_t, typename alloc_t>
   void operator()( std::basic_string<char_t, traits_t, alloc_t> const & str )
   {
      std::cout << str << std::endl;
   }
};

[1] 中的调用可以使用访问者中最不专业的通用模板化 operator() 转换为 v( o ) ：

template <typename O>
void DumpScreenVisitor::operator()( O & o )
{
   o.accept( *this );
}

但这可能会与其他访问者实现（例如，上面的访问者可以使用单个模板化方法来实现）：

struct DumpScreenVisitor {
   template <typename T>
   void operator()( T const & t ) {
      std::cout << t << std::endl;
   }
};

因此最终您将不得不以任何一种方式进行妥协。

这种方法类似于 boost::variant 访问者实现（您可能想看一下），不同之处在于 boost::variant 是单个类而不是层次结构。

Answer 2

最后，我采取了稍微不同的方法。我不希望使用具有模板化方法的访问者（这当然是不可能的），而是决定将类似访问者的类作为模板参数传递给对象的访问方法。完全简化的示例：

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

使用此方法，我仍然可以使用模板化字符串，同时仍然能够将任何类型的“访问者”传递给我的对象。

Answer 3

您的访问者应该只处理字符串的基本表示（char* / wchar*）；

然后由accept方法来处理转换。

Answer 4

好吧，问题是，字符串上的模板参数可能如此不同，您可以为它们应用一种单一的序列化方法吗？如果是这样，您可以编写一个具有模板化构造函数的适配器，该构造函数将序列化所需的所有信息提取为统一的表示形式。然后您使用适配器访问序列化器。

编辑：添加代码后，我仍然认为适配器可以解决您的问题，但反之亦然。在 Accept 方法中，构造一个本地适配器并将其传递给 Visitor。当 Visitor 对其进行修改时，您可以在适配器上使用模板方法 extractToString 将信息转换为特定的字符串版本。这可能会使适配器变得复杂，具体取决于必须处理的字符串模板实例化的不同程度。

Answer 5

由于所有字符串类都是不同的类型，因此您需要某种程度的妥协（或者是一个通用的子类型，带有虚拟方法，用于您的字符串，或者是一个适配器，或者为每个不同的 向访客输入）。混合通用编程和面向对象可能会很痛苦，特别是如果您不接受妥协的话。

例如。

class string_tag { /* common visitor interface */ };

template<typename char_t, ...> class basic_string : public string_tag {};

class IVisitor
{
public: 
     virtual void VisitString(string_tag& 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(string); 
    }
private:
   MyStringType string;
};

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


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

Answer 6

也许您可以考虑下面的内容，但在这种情况下，您需要将访问者机制分离到不同的访问者类别。 WStringVisitor 和 StringVisitor 只是不同访问者语义的示例。

#include <string>

#include <iostream>

using namespace std;

template <typename stringType>
class IVisitor{
public:
    virtual void visit(stringType _string)=0;
};

class StringVisitor: public IVisitor<string>{
public:
    void visit(string str){
        cout<<"This is std::string implementation: "<< str << endl;
    }
};
class WStringVisitor: public IVisitor<basic_string<wchar_t>>{
public:
    void visit(basic_string<wchar_t> str){
        //wprintf(L"This wide implementation : %S", str.c_str());
        wcout<<"This is WString Visitor: "<< str << endl;
    }
};

class MyObject{
public:
    typedef basic_string<char> MyStringType;

    void accept(IVisitor<MyStringType>& visitor){
        visitor.visit("TEST STRING");
    }
};

class MyOtherObject
{
public:
    typedef basic_string<wchar_t> MyOtherStringType;
    void accept(IVisitor<MyOtherStringType>& visitor)
    {
        visitor.visit(L"TEST WSTRING"); 
    }

};


int _tmain(int argc, _TCHAR* argv[])
{
    MyObject acceptor;
    MyOtherObject otheracceptor;
    StringVisitor visitor;
    WStringVisitor wvisitor;
    acceptor.accept(visitor);
    //otheracceptor.accept(visitor); compile error
    otheracceptor.accept(wvisitor);
    return 0;
} 

Answer 7

我认为这里的根本问题是访问者模式都是关于虚拟函数的，而您通过函数模板聚集字符串。而且这些不容易混合。事实上，我能想到的将两者混合的唯一方法是类型擦除。

如果您找不到使用此技术做您想做的事情的方法，我认为您不会找到方法。