问题 C ++中是否可以使用无状态访问者模式？

我试图将以下Haskell代码转换为C ++：

data List t = Nil | Cons t (List t)

将代数数据类型直接转换为无状态访问者模式会产生以下Java代码

interface List<T> {
  <R> R accept(ListVisitor<T,R> v);
}

interface ListVisitor<T,R> {
  R visitNil();
  R visitCons(T head, List<T> tail);
}

class Nil<T> implements List<T> {
  @Override
  public <R> R accept(ListVisitor<T,R> v) {
    return v.visitNil();
  }
}

class Cons<T> implements List<T> {
  public final T head;
  public final List<T> tail;
  public Cons(T head, List<T> tail) {
    this.head = head;
    this.tail = tail;
  }
  @Override
  public <R> R accept(ListVisitor<T,R> v) {
    return v.visitCons(head, tail);
  }
}

以下是我到目前为止的C ++代码：

template<class T> class List;

template<class T, class R> class ListVisitor {
  virtual R visitNil() = 0;
  virtual R visitCons(T head, List<T> tail) = 0;
};

template<class T> class List {
  template<class R> virtual R accept(ListVisitor<T,R> v) = 0;
};

请注意，Java版本使用虚拟通用函数 accept。当我把它翻译成C ++时，我最终得到了一个 虚拟模板 函数，C ++不允许。

除了制作之外，还有解决方案 accept 返回 void 并要求访客是有状态的？

更新： 根据要求，以下是一些如何使用接口的示例（模数智能指针和可能的编译错误）：

template<class T> struct LengthVisitor : ListVisitor<T, int> {
  bool visitNil() { return 0; }
  bool visitCons(const T&, const List<T> &tail) { return 1 + tail.accept(*this); }
};

template<class T> struct ConcatVisitor : ListVisitor<T, const List<T> *> {
  const List<T> *right;
  ConcatVisitor(const List<T> *right) : right(right) {} 
  List<T> * visitNil() { return right; }
  List<T> * visitCons(const T &head, const List<T> & tail) {
    return new Cons(head, tail.accept(*this));
  }
};

另一个例子，一个更高级别的功能 fold在Java中，可以在这里找到： http://hpaste.org/54650

这肯定可以改进（例如，使用智能指针进行尾部所有权），但基本思路是：

template <typename T>
struct cons_list {
     T head;
     cons_list<T>* tail;

     explicit cons_list(T head, cons_list *tail = nullptr)
         : head(head), tail(tail) {}

     template <template<typename> class Visitor>
     typename Visitor<T>::return_type accept(const Visitor<T>& visitor) {
          return visitor.visit(head, tail);
     }
};

template <typename T>
struct some_visitor {
     typedef void return_type;

     return_type visit(T head, cons_list<T>* tail) const {
          std::cout << head << '\n';
          if (tail != nullptr) tail->accept(*this);
     }
};

演示。不需要虚拟分派和类层次结构。 nullptr 是C ++ 11，但它在03上应该可以正常工作。

实施可能是一个更好的主意 accept 作为自由函数，而不是使用空指针作为零节点，但正如我所说，这是基本的东西。

注意：这或多或少是背后的想法提高:: static_visitor。

完整的C ++ 11 Boost.Variant版本（需要模板别名）。未经测试，因为我附近没有g ++ 4.7。

struct nil_node {};
template <typename T> cons_node;

template <typename T>
using cons_list = boost::make_recursive_variant<
     nil_node, cons_node<T>
>::type;

template <typename T>
struct cons_node {
     T head;
     cons_list<T> tail;

     explicit cons_node(T head, const cons_list<T>& tail)
         : head(head), tail(tail)
     {}
};

template <typename T>
struct some_visitor : boost::static_visitor<T> {
     void operator()(nil_node&) {}
     void operator()(cons_node<T>& node) {
         std::cout << node.head << '\n';
         boost::apply_visitor(node.tail, *this);
     }
};

int main() {
    cons_node<int> x(1, cons_node<int>(2, cons_node<int>(3, nil_node())));
    boost::apply_visitor(some_visitor<int>(), x);
};

请问，你能添加一个c ++代码最终用法的例子吗？ - Alessandro Teruzzi

为什么不使用每种语言，因为它意味着使用 - Cheers and hth. - Alf

visitCons 和 accept 方法还需要指向那些抽象类而不是值，所以为什么不有状态？ - Arpegius

狮子，他们应该采取 const &。阿尔夫，你的意思是应该乐意使用 void 和可变的访客？ - Rotsor

我的理解是否正确，即提升 variant type通过放弃虚拟调度来实现这一点，通过访问者模式的通常描述建议，有利于 switch 在enum伴随静态演员阵容？您的第一个示例没有证明（非常重要）部分，因为它通过将所有内容放入单个数据结构中来完全避免继承。 - Rotsor

@Rotsor： variant 是一个标记联合的实现，就像Haskell一样 data。我不知道实现细节，如果你想了解它们，你可以阅读Boost源代码。 - Cat Plus Plus

问题 C ++中是否可以使用无状态访问者模式？

答案:

热门问题