访客设计模式和多层 class 层次结构

Question

我有五个 class 关联访客：

struct Visitor
{
    virtual ~Visitor() = default;
    virtual void visit(A&) {}
    virtual void visit(B&) {}
    virtual void visit(C&) {}
    virtual void visit(D&) {}
    virtual void visit(E&) {}
};

struct A
{
    virtual ~A() = default;
    virtual void accept(Visitor& v) { v.visit(*this); }
};
struct B : A { void accept(Visitor& v) override { v.visit(*this); } };
struct C : A { void accept(Visitor& v) override { v.visit(*this); } };
struct D : C { void accept(Visitor& v) override { v.visit(*this); } };
struct E : C { void accept(Visitor& v) override { v.visit(*this); } };

用户代码将在可能的最大抽象级别看到所有实例，因此它们都将被视为 A&。用户代码需要做两类操作：

如果实例恰好是 C

"I am C"

打印"I am C"如果实例是类型C或其任何子类型（即D或E）

操作 1 的实现非常简单，几乎可以在访问者设计模式框外使用基础设施到位：

struct OperationOne : Visitor
{
    void visit( C& ) override { std::cout << "I am C" << std::endl; }
};

正如预期的那样，字符串 "I am C" 将只打印一次：

int main( )
{
    A a; B b; C c; D d; E e;
    std::vector<std::reference_wrapper<A>> vec = { a, b, c, d, e };

    OperationOne operation_one;

    for (A& element : vec)
    {
        element.accept(operation_one);
    }
}

Demo

问题是：对于第二个操作，整个基础设施不再工作，假设我们不想重复 D 和 E 的打印代码：

struct OperationTwo : Visitor
{
    void visit( C& ) override { std::cout << "I am C" << std::endl; }
    void visit( D& ) override { std::cout << "I am C" << std::endl; }
    void visit( E& ) override { std::cout << "I am C" << std::endl; }
};

虽然这会起作用，但如果层次结构发生变化并且 D 不再是 C 的子类型，而是例如 A 的直接子类型，则此代码将仍然可以编译，但在运行时不会有预期的行为，这是危险和不可取的。

实施操作 2 的一个解决方案是更改访问者基础结构，以便每个可访问的 class 将接受的访问者传播到其基础 classes:

struct B : A
{
    void accept(Visitor& v) override
    {
        A::accept( v );
        v.visit( *this );
    }
};

这样，如果层次结构发生变化，我们将出现编译错误，因为在尝试传播接受的访问者时，编译器将不再找到基础 class。

也就是说，我们现在可以编写第二个操作 visitor，这次我们不需要重复 D 和 E:

的打印代码

struct OperationTwo : Visitor
{
    void visit(C&) override { std::cout << "I am C" << std::endl; }
}

正如预期的那样，当使用 OperationTwo 时，字符串 "I am C" 将在用户代码中打印三次：

int main()
{
    A a; B b; C c; D d; E e;
    vector< reference_wrapper< A > > vec = { a, b, c, d, e };

    OperationTwo operation_two;

    for ( A& element : vec ) 
    {
        element.accept( operation_two );
    }
}

Demo

但是等等：OperationOne 和 OperationTwo 代码是完全一样的！这意味着通过改变第二个操作的基础设施，我们基本上打破了第一个。事实上，现在 OperationOne 也会打印三次字符串 "I am C".

怎样才能让 OperationOne 和 OperationTwo 无缝协作？我是否需要将访问者设计模式与另一种设计模式相结合，还是根本不需要使用访问者？

Answer 1

您可以将以下内容作为访问者使用，它将通过重载解决方案进行分派：

template <typename F>
struct OverloadVisitor : Visitor
{
    F f;

    void visit(A& a) override { f(a); }
    void visit(B& b) override { f(b); }
    void visit(C& c) override { f(c); }
    void visit(D& d) override { f(d); }
    void visit(E& e) override { f(e); }
};

然后

struct IAmAC
{
    void operator()( C& ) { std::cout << "I am C" << std::endl; }
    void operator()( A& ) {} // Fallback
};

using OperationTwo = OverloadVisitor<IAmAC>;

Demo

访客设计模式和多层 class 层次结构

Visitor design pattern and multi layered class hierarchy

c++

design-patterns

visitor-pattern