boost::variant 的访问者模板

Question

我想使用 boost.variant作为模板“Visitor”类的参数，该类将提供 boost.variant 访问者机制所需的访问者运算符，在此如果所有情况都返回 void，即，

void operator()(T0 value);
void operator()(T1 value);
void operator()(T2 value);

模板还将为变体中的每个类型 T0... 提供一个相应的虚拟函数，默认情况下该函数不执行任何操作。用户可以继承模板类并仅重新定义他感兴趣的虚函数。这类似于众所周知的“模板方法”模式。 我能想到的唯一解决方案是将 boost::variant 和关联的访问者包装在一个模板中，并通过 typedef 访问它们。这工作正常，但感觉有点笨拙。代码如下：

#include "boost/variant.hpp"

//create specializations of VariantWrapper for different numbers of variants - 
//just show a template for a variant with three types here. 
//variadic template parameter list would be even better! 

template<typename T0, typename T1, typename T2>
struct VariantWrapper
{
    //the type for the variant
    typedef boost::variant<T0,T1,T2> VariantType;

    //The visitor class for this variant
    struct Visitor : public boost::static_visitor<>
    {
        void operator()(T0 value)
        {
            Process(value);
        }
        void operator()(T1 value)
        {
            Process(value);
        }
        void operator()(T2 value)
        {
            Process(value);
        }
        virtual void Process(T0 val){/*do nothing */}
        virtual void Process(T1 val){/*do nothing */}
        virtual void Process(T2 val){/*do nothing */}
    protected:
        Visitor(){}
    };

    typedef Visitor VisitorType;
private:
    VariantWrapper(){}
    };

然后按如下方式使用该类：

typedef VariantWapper<bool,int,double> VariantWrapperType;
typedef VariantWrapperType::VariantType VariantType;
typedef VariantWrapperType::VisitorType VisitorType;

struct Visitor : public VisitorType
{
    void Process(bool val){/*do something*/}
    void Process(int val){/*do something*/}
    /* this class is not interested in the double value */
};

VariantType data(true);
apply_visitor(Visitor(),data);

正如我所说，这似乎工作正常，但如果我不必创建一个特殊的包装类来将变体和访问者联系在一起，我会更喜欢它。我希望能够直接使用 boost.variant 来实例化模板访问者类。我已经研究过使用类型参数、非类型参数和模板模板参数，但似乎没有任何提示。我想做的事情是不可能的吗？我可能会遗漏一些东西，如果有人对此有任何意见，我将不胜感激。

Answer 1

带有 Boost Variant 和虚拟调度的代码有点可疑。特别是考虑到您知道在编译时对处理什么感兴趣，并且绝对不需要在运行时创建虚拟表来实现您的目标。

我建议您使用部分模板专业化。因此，有一个默认的模板方法，它可以接受变体中的任何类型并且不执行任何操作。对于您感兴趣的类型，只需专门化模板即可。

这是一个例子。我们有三种类型 - Foo、Bar 和 War。我们只对最后两种类型感兴趣，并且对它们进行了专门研究。所以 Foo 被忽略了。

#include <iostream>
#include <boost/variant.hpp>

using namespace std;
using namespace boost;

struct Foo {};
struct Bar {};
struct War {};

typedef variant<Foo, Bar, War> Guess;

struct Guesstimator : public boost::static_visitor<void>
{
    template <typename T>
    void operator () (T) const
    {
    }
};

template <>
inline void
Guesstimator::operator () <Bar> (Bar) const
{
    cout << "Let's go to a pub!" << endl;
}

template <>
inline void
Guesstimator::operator () <War> (War) const
{
    cout << "Make love, not war!" << endl;
}

这是一个简单的用法示例：

int
main ()
{
    Guess monday;
    apply_visitor (Guesstimator (), monday);

    War war;
    Guess ww2 (war);
    apply_visitor (Guesstimator (), ww2);

    Bar irishPub;
    Guess friday (irishPub);
    apply_visitor (Guesstimator (), friday);
}

该程序的输出将是：

Make love, not war!
Let's go to a pub!

这是另一个解决方案。我们创建一个默认访问者，忽略除您在类型列表中指定的内容之外的所有内容。这并不方便，因为您必须指定类型列表两次 - 一次在类型列表中，然后在每个处理方法（运算符）中。另外，事实上，通用模板将继承您的访问者。但尽管如此，我们还是要说：

#include <cstddef>
#include <iostream>
#include <boost/variant.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/utility/enable_if.hpp>

// Generic visitor that does magical dispatching of
// types and delegates passes down to your visitor only
// those types specified in a type list.
template <typename Visitor, typename TypeList>
struct picky_visitor :
    public boost::static_visitor<void>,
    public Visitor
{
    template <typename T>
    inline void
    operator () (T v, typename boost::enable_if< typename boost::mpl::contains< TypeList, T >::type >::type *dummy = NULL) const
    {
        Visitor::operator () (v);
    }

    template <typename T>
    inline void
    operator () (T v, typename boost::disable_if<typename boost::mpl::contains< TypeList, T >::type >::type *dummy = NULL) const
    {
    }
};

// Usage example:

struct nil {};
typedef boost::variant<nil, char, int, double> sql_field;

struct example_visitor
{
    typedef picky_visitor< example_visitor, boost::mpl::vector<char, int> > value_type;

    inline void operator () (char v) const
    {
        std::cout << "character detected" << std::endl;
    }

    inline void operator () (int v) const
    {
        std::cout << "integer detected" << std::endl;
    }
};

int
main ()
{
    example_visitor::value_type visitor;

    sql_field nilField;
    sql_field charField ('X');
    sql_field intField (1986);
    sql_field doubleField (19.86);

    boost::apply_visitor (visitor, nilField);
    boost::apply_visitor (visitor, charField);
    boost::apply_visitor (visitor, intField);
    boost::apply_visitor (visitor, doubleField);
}

Answer 2

随着时间的推移，新的、有趣的图书馆不断涌现。这个问题很老了，但从那时起就有了一个解决方案，对我个人来说，它比迄今为止给出的解决方案要优越得多。

优秀的 Mach7 库允许前所未有的匹配（因此访问）功能。它由尤里·索洛德基 (Yuriy Solodkyy)、加布里埃尔·多斯·雷斯 (Gabriel Dos Reis) 和比亚尼·斯特鲁斯特鲁普 (Bjarne Stroustrup) 本人撰写。对于那些在这个问题上遇到困难的人，这里有一个来自自述文件的例子：

void print(const boost::variant<double,float,int>& v)
{
    var<double> d; var<float> f; var<int> n;

    Match(v)
    {
      Case(C<double>(d)) cout << "double " << d << endl; break;
      Case(C<float> (f)) cout << "float  " << f << endl; break;
      Case(C<int>   (n)) cout << "int    " << n << endl; break;
    }
    EndMatch
}

我现在正在使用它，到目前为止，使用它真的很愉快。

Answer 3

汤姆，我相信你的问题在特定的背景下很有意义。假设您想要将多种类型的访问者存储在向量中，但您不能这样做，因为它们都是不同的类型。你有几个选择：再次使用variant来存储访问者，使用boost.any，或者使用虚函数。我认为虚函数是一种优雅的解决方案，但肯定不是唯一的解决方案。

事情是这样的。

首先，让我们使用一些变体； bool、int 和 float 就可以了。

typedef boost::variant<bool, int, float> variant_type;

然后是基类，或多或少与您所拥有的一样。

template
struct Visitor : public boost::static_visitor<>
{
  void operator()(T0 value)
  {
    Process(value);
  }
  void operator()(T1 value)
  {
    Process(value);
  }
  void operator()(T2 value)
  {
    Process(value);
  }
  virtual void Process(T0 val){ std::cout << "I am Visitor at T0" << std::endl; }
  virtual void Process(T1 val){ std::cout << "I am Visitor at T1" << std::endl; }
  virtual void Process(T2 val){ std::cout << "I am Visitor at T2" << std::endl; }
protected:
  Visitor(){}
};

接下来，我们有两个特定的变体。

template
struct Visitor1 : public Visitor
{
    void Process(T0 val){ std::cout << "I am Visitor1 at T0" << std::endl; }
    void Process(T2 val){ std::cout << "I am Visitor1 at T2" << std::endl; }
};


模板
struct Visitor2 ：公共访客
{
    void Process(T1 val){ std::cout <<; “我是 T1 的访客 2”<< std::endl; }
    void Process(T2 val){ std::cout << “我是 T2 的访客 2”<< std::endl; }
};

最后，我们可以制作不同变体的单个向量：

int main() {
  variant_type data(1.0f);
  std::vector*> v;
  v.push_back(new Visitor1());
  v.push_back(new Visitor2());


 apply_visitor(*v[0],数据);
  apply_visitor(*v[1],数据);
  数据=真；
  apply_visitor(*v[0],数据);
  apply_visitor(*v[1],数据);

返回0；
}

这是输出：

I am Visitor1 at T2
I am Visitor2 at T2
I am Visitor1 at T0
I am Visitor at T0

如果由于某种原因我需要在一个容器中拥有不同的变体，我肯定会考虑这种解决方案。我还会想，如果将访问者真正困在另一个变体中，会变得更糟/更好。使用继承的好处在于它是可扩展的：您始终可以从类继承，但是一旦设置了变体，您就无法在不实际接触现有代码的情况下更改它。