C++访问者模式遍历复杂对象结构操作-C++-PHP中文网

C++访问者模式通过双重分派机制将操作与对象结构分离，使新增操作无需修改元素类，符合开放/封闭原则，提升扩展性与维护性，适用于对象结构稳定但操作多变的场景。

c++访问者模式遍历复杂对象结构操作

C++的访问者模式（Visitor Pattern）提供了一种优雅的解决方案，用于在不修改复杂对象结构（比如树形结构或复合对象）内部类的前提下，对这些结构中的元素执行各种操作。它将算法从对象结构中分离出来，使得添加新操作变得更加容易，尤其适合那些对象结构相对稳定，但操作需求多变且不断增加的场景。

解决方案

在我看来，C++访问者模式的核心魅力在于它巧妙地利用了“双重分派”（Double Dispatch）机制。当我们需要对一个由多种不同类型对象组成的复杂结构进行操作时，如果直接在每个对象类中添加操作方法，那么每增加一种新操作，我们就得修改所有相关的对象类，这显然违反了开放/封闭原则。访问者模式就是为了解决这个痛点而生的。

它通常由以下几个关键角色构成：

```
Visitor
```
登录后复制
接口 (访问者接口)：这是一个抽象类或接口，它为每一种具体元素类型声明一个
```
Visit
```
登录后复制
方法。例如，如果你的对象结构包含
```
Number
```
登录后复制
和
```
Add
```
登录后复制
节点，那么
```
Visitor
```
登录后复制
接口就会有
```
Visit(Number&)
```
登录后复制
和
```
Visit(Add&)
```
登录后复制
这样的方法。

立即学习“C++免费学习笔记（深入）”；
```
ConcreteVisitor
```
登录后复制
(具体访问者)：这些是
```
Visitor
```
登录后复制
接口的实现类。每个具体访问者都代表一个特定的操作。例如，你可以有一个
```
PrintVisitor
```
登录后复制
来打印表达式树，或者一个
```
EvaluateVisitor
```
登录后复制
来计算表达式的值。它们会根据传入的元素类型，执行不同的逻辑。
```
Element
```
登录后复制
接口 (元素接口)：这也是一个抽象类或接口，它声明一个
```
Accept
```
登录后复制
方法，这个方法接受一个
```
Visitor
```
登录后复制
对象的引用作为参数。
```
ConcreteElement
```
登录后复制
(具体元素)：这些是
```
Element
```
登录后复制
接口的实现类，代表对象结构中的具体节点。它们的
```
Accept
```
登录后复制
方法实现非常关键：它会调用传入的
```
Visitor
```
登录后复制
对象的相应
```
Visit
```
登录后复制
方法，并将自身（
```
this
```
登录后复制
）作为参数传递过去。这就是所谓的“双重分派”：方法的调用既依赖于
```
Accept
```
登录后复制
方法所属的元素类型，也依赖于传入的
```
Visitor
```
登录后复制
类型。

举个例子，我们来构建一个简单的算术表达式树，包含数字和加法操作，并用访问者模式来打印和求值：

#include <iostream>
#include <vector>
#include <string>
#include <memory> // For std::unique_ptr

// 1. 前向声明，因为元素和访问者会相互引用
class Number;
class Add;
class Expression; // 抽象元素接口

// 2. 访问者接口
class ExpressionVisitor {
public:
    virtual ~ExpressionVisitor() = default;
    virtual void visit(Number& number) = 0;
    virtual void visit(Add& add) = 0;
    // ... 如果有其他元素类型，这里也要声明对应的visit方法
};

// 3. 抽象元素接口
class Expression {
public:
    virtual ~Expression() = default;
    virtual void accept(ExpressionVisitor& visitor) = 0;
};

// 4. 具体元素：数字
class Number : public Expression {
private:
    int value_;
public:
    Number(int value) : value_(value) {}
    int getValue() const { return value_; } // 访问者可能需要这个
    void accept(ExpressionVisitor& visitor) override {
        visitor.visit(*this);
    }
};

// 5. 具体元素：加法
class Add : public Expression {
private:
    std::unique_ptr<Expression> left_;
    std::unique_ptr<Expression> right_;
public:
    Add(std::unique_ptr<Expression> left, std::unique_ptr<Expression> right)
        : left_(std::move(left)), right_(std::move(right)) {}

    Expression& getLeft() const { return *left_; }
    Expression& getRight() const { return *right_; }

    void accept(ExpressionVisitor& visitor) override {
        visitor.visit(*this);
    }
};

// 6. 具体访问者：打印表达式
class PrintVisitor : public ExpressionVisitor {
public:
    void visit(Number& number) override {
        std::cout << number.getValue();
    }
    void visit(Add& add) override {
        std::cout << "(";
        add.getLeft().accept(*this); // 递归访问左子树
        std::cout << " + ";
        add.getRight().accept(*this); // 递归访问右子树
        std::cout << ")";
    }
};

// 7. 具体访问者：求值表达式
class EvaluateVisitor : public ExpressionVisitor {
private:
    int result_ = 0; // 存储计算结果
public:
    int getResult() const { return result_; }

    void visit(Number& number) override {
        result_ = number.getValue();
    }
    void visit(Add& add) override {
        // 先访问左子树，获取其值
        add.getLeft().accept(*this);
        int leftVal = result_;

        // 再访问右子树，获取其值
        add.getRight().accept(*this);
        int rightVal = result_;

        result_ = leftVal + rightVal;
    }
};

/*
int main() {
    // 构建表达式树: (3 + (4 + 5))
    std::unique_ptr<Expression> expr =
        std::make_unique<Add>(
            std::make_unique<Number>(3),
            std::make_unique<Add>(
                std::make_unique<Number>(4),
                std::make_unique<Number>(5)
            )
        );

    // 使用 PrintVisitor 打印
    PrintVisitor printer;
    expr->accept(printer);
    std::cout << std::endl; // 输出: (3 + (4 + 5))

    // 使用 EvaluateVisitor 求值
    EvaluateVisitor evaluator;
    expr->accept(evaluator);
    std::cout << "Result: " << evaluator.getResult() << std::endl; // 输出: Result: 12

    return 0;
}
*/

登录后复制

从这个例子可以看出，

PrintVisitor

登录后复制

和

EvaluateVisitor

登录后复制

都可以独立地对表达式树进行操作，而

Number

登录后复制

和

Add

登录后复制

类本身并没有包含任何打印或求值的逻辑。如果未来我需要添加一个“序列化”操作，我只需要创建一个

SerializeVisitor

登录后复制

，而无需触碰现有的

Number

登录后复制

或

Add

登录后复制

类。这，就是访问者模式的精髓所在。

C++的访问者模式如何提升复杂对象结构的维护性与扩展性？

在我看来，访问者模式在提升复杂对象结构（比如AST、DOM树、图形场景图）的维护性和扩展性方面，主要体现在它对“变化”的管理上。我们知道，软件设计中一个核心挑战就是如何应对需求变更。访问者模式在这方面，特别擅长处理“操作”的变化。

首先，它极大地增强了扩展性。当我们需要为对象结构中的元素添加新的操作时，比如我们上面例子中的表达式树，如果想增加一个“转换为后缀表达式”的功能，我们只需创建一个新的

PostfixVisitor

登录后复制

类，实现

ExpressionVisitor

登录后复制

接口中的

Visit

登录后复制

方法即可。我们不需要修改

Number

登录后复制

或

Add

登录后复制

这些核心的元素类。这完美契合了开放/封闭原则——对扩展开放，对修改封闭。想象一下，如果没有访问者模式，你可能需要在每个

Expression

登录后复制

子类中都添加一个

toPostfix()

登录后复制

方法，一旦忘记添加或修改，就可能导致编译错误或运行时异常，更别提维护多个操作时代码的膨胀和耦合。

其次，它提升了维护性，特别是对操作逻辑的维护。所有与特定操作相关的逻辑都被封装在一个

ConcreteVisitor

登录后复制

类中。这意味着，如果你需要修改打印逻辑，你只需要关注

PrintVisitor

登录后复制

；如果你需要调整求值逻辑，你只需要修改

EvaluateVisitor

登录后复制

。这种关注点分离让代码更加清晰，降低了理解和修改的难度。在我写代码的经验里，这种清晰的边界能大大减少引入新bug的风险。不同于将操作逻辑分散在各个元素类中，访问者模式将它们集中管理，使得代码的逻辑流更容易追踪。

当然，这种模式也有它的“另一面”。它的扩展性主要体现在“增加新操作”上。如果你的需求是频繁地“增加新的元素类型”，那么访问者模式的优势就会变成劣势，因为每次增加一个新元素，你就不得不修改

Visitor

登录后复制

接口以及所有

ConcreteVisitor

登录后复制

的实现，这会带来不小的维护负担。所以，在选择是否使用访问者模式时，我们需要权衡，看是操作更频繁地变化，还是元素类型更频繁地变化。对我而言，如果核心数据结构相对稳定，但上面需要跑各种分析、转换、渲染任务，那访问者模式几乎是首选。

在C++中实现访问者模式时，有哪些常见的陷阱和最佳实践？

实现访问者模式，特别是用C++，确实有些地方需要注意，否则可能会事与愿违。这就像是开车，你知道方向盘和油门在哪，但有些路况和操作技巧，是经验之谈。

常见的陷阱：

添加新元素类型时的痛苦： 这是最显著的缺点。如果你的对象结构经常需要引入新的
```
ConcreteElement
```
登录后复制
类型，那么你必须修改
```
Visitor
```
登录后复制
接口，为新元素添加对应的
```
Visit
```
登录后复制
方法，然后，所有现有的
```
ConcreteVisitor
```
登录后复制
都必须被修改以实现这个新的
```
Visit
```
登录后复制
方法。这简直是灾难性的，因为它违反了开放/封闭原则中对“修改封闭”的期望。所以，如果你预见到元素类型会频繁变动，可能需要重新考虑是否采用访问者模式，或者结合其他模式（如工厂方法）来缓解。
打破封装性： 为了让访问者能够执行操作，它通常需要访问
```
ConcreteElement
```
登录后复制
内部的状态。这意味着你可能需要在
```
ConcreteElement
```
登录后复制
中提供大量的公共getter方法，或者更糟糕地，将
```
Visitor
```
登录后复制
类声明为
```
ConcreteElement
```
登录后复制
的
```
friend
```
登录后复制
。这无疑会削弱元素的封装性，增加了耦合。在我看来，尽量通过元素提供的公共接口来获取必要信息，是更好的选择，如果非要访问私有成员，也要仔细权衡其影响。

北极象沉浸式AI翻译
免费的北极象沉浸式AI翻译 - 带您走进沉浸式AI的双语对照体验

0

查看详情
循环依赖： 访问者接口和元素接口之间存在相互依赖（
```
Element
```
登录后复制
引用
```
Visitor
```
登录后复制
，
```
Visitor
```
登录后复制
引用
```
Element
```
登录后复制
）。在C++中，这需要使用前向声明来解决，如我们代码示例所示。如果处理不当，容易造成编译问题。
过度设计： 访问者模式并非银弹。如果你的对象结构简单，操作类型固定且数量少，或者你只需要对同构对象进行操作，那么引入访问者模式反而会增加不必要的复杂性。简单的多态或者模板方法模式可能更合适。

最佳实践：

明确设计意图： 在决定使用访问者模式之前，先问问自己：我的对象结构稳定吗？我预期的变化是操作类型多变，还是元素类型多变？如果答案是前者，那么访问者模式是强有力的候选者。
细化
```
Element
```
登录后复制
接口： 尽量保持
```
Element
```
登录后复制
接口的精简，只包含
```
Accept
```
登录后复制
方法。具体的元素类可以提供一些公共的、只读的接口，供访问者查询其状态，但要避免暴露过多内部细节。
利用基类提供默认行为： 如果某些
```
ConcreteVisitor
```
登录后复制
不需要处理所有
```
ConcreteElement
```
登录后复制
类型，或者对某些元素有通用的默认处理方式，可以考虑创建一个
```
BaseVisitor
```
登录后复制
或
```
DefaultVisitor
```
登录后复制
类，提供空的
```
Visit
```
登录后复制
方法实现，或者抛出异常，让子类选择性地覆盖。这样可以减少
```
ConcreteVisitor
```
登录后复制
的代码量。
智能指针管理内存： 在复杂对象结构中，内存管理是个大问题。使用
```
std::unique_ptr
```
登录后复制
或
```
std::shared_ptr
```
登录后复制
来管理
```
Expression
```
登录后复制
节点，可以大大简化内存生命周期管理，避免内存泄漏，就像我们示例中那样。
考虑常量访问者： 如果某些操作不需要修改元素的状态，可以设计一个
```
ConstExpressionVisitor
```
登录后复制
，其
```
Visit
```
登录后复制
方法接受
```
const
```
登录后复制
引用，这样可以更好地表达意图并利用C++的
```
const
```
登录后复制
正确性。
善用
```
dynamic_cast
```
登录后复制
的替代品： 访问者模式本身就是为了避免在运行时使用
```
dynamic_cast
```
登录后复制
进行类型判断的链式调用。它通过编译时的多态性（双重分派）来确保类型安全。所以，如果你发现自己在访问者模式的
```
Visit
```
登录后复制
方法内部还在大量使用
```
dynamic_cast
```
登录后复制
，那可能说明你的设计有问题，或者你没有完全理解访问者模式的意图。

除了表达式树，C++访问者模式还能在哪些实际场景中发挥作用？

访问者模式的应用场景远不止表达式树这么单一，它在处理任何具有异构节点（不同类型）且结构复杂（通常是树形或图状）的数据结构时，都能大放异彩。在我看来，只要你的问题符合“对象结构稳定，但操作多变”这个大前提，访问者模式就值得考虑。

编译器和解释器： 这是访问者模式的经典应用之一。编译器的前端会生成抽象语法树（AST），而后续的语义分析、类型检查、优化、代码生成等阶段，都可以通过不同的访问者来完成。每个访问者专注于AST上的一种特定操作，比如一个
```
TypeCheckerVisitor
```
登录后复制
检查类型，一个
```
CodeGeneratorVisitor
```
登录后复制
生成目标代码。
图形用户界面（GUI）工具包： GUI通常由复杂的组件树构成（窗口、面板、按钮、文本框等）。访问者模式可以用来遍历这些组件，执行渲染（
```
RenderVisitor
```
登录后复制
）、事件处理（
```
EventHandlingVisitor
```
登录后复制
）、布局计算（
```
LayoutVisitor
```
登录后复制
）或者序列化（
```
SerializationVisitor
```
登录后复制
）等操作。
文档对象模型（DOM）解析器： 无论是XML、HTML还是JSON，它们都可以被解析成一个DOM树。对DOM树的各种操作，如查找特定节点、修改节点属性、验证文档结构、转换为其他格式等，都可以通过访问者模式来实现。例如，一个
```
SchemaValidationVisitor
```
登录后复制
可以遍历DOM树并根据预设的Schema进行验证。
CAD/CAM 软件： 在计算机辅助设计或制造软件中，设计图纸通常由各种几何形状（点、线、圆、多边形、曲面等）组成一个复杂的结构。访问者模式可以用于执行各种几何操作，如计算面积/体积（
```
AreaVolumeCalculatorVisitor
```
登录后复制
）、渲染（
```
RenderVisitor
```
登录后复制
）、碰撞检测（
```
CollisionDetectionVisitor
```
登录后复制
）或导出到不同文件格式（
```
ExportVisitor
```
登录后复制
）。
网络协议栈： 在处理网络数据包时，数据包可能包含不同类型的头部（以太网、IP、TCP/UDP等）和有效载荷。访问者模式可以用来解析和处理这些不同类型的数据包头部，执行路由、过滤、校验和等操作。
文件系统遍历： 虽然文件系统本身不完全是一个C++对象结构，但你可以将其抽象为
```
File
```
登录后复制
和
```
Directory
```
登录后复制
对象的树形结构。然后，你可以用访问者模式来执行文件搜索（
```
SearchVisitor
```
登录后复制
）、权限修改（
```
PermissionVisitor
```
登录后复制
）、备份（
```
BackupVisitor
```
登录后复制
）或统计（
```
SizeCalculatorVisitor
```
登录后复制
）等操作。