Qt C++设计模式-＞访问者模式

访问者模式（Visitor Pattern）是一种行为型设计模式，它将操作与对象结构分离，使得你可以在不改变对象结构的前提下定义作用于这些对象的新操作。访问者模式通过引入一个访问者对象，允许你在不修改类的前提下向已有类添加新的行为。

访问者模式的核心思想

访问者模式的主要思想是将对象结构的操作封装到访问者中。对象结构中的每个元素都可以接受一个访问者，并让这个访问者对自己进行操作。这使得我们可以很方便地增加新的操作，而不需要修改对象的类。

访问者模式的主要组成部分包括：

访问者接口（Visitor）：为每个对象结构中的元素定义访问操作。每个操作方法对应一个元素类型。
具体访问者（Concrete Visitor）：实现访问者接口，定义每个元素对应的具体操作。
元素接口（Element）：定义接受访问者的方法。这个方法通常会将自身作为参数传递给访问者。
具体元素（Concrete Element）：实现元素接口，并在接受访问者时调用访问者的相应操作。
对象结构（Object Structure）：通常是一个包含多个元素的集合，负责遍历这些元素，并让它们接受访问者。

访问者模式的应用场景

需要对类的对象结构进行复杂操作：例如编译器中的语法树、绘图系统中的图形对象层次等。访问者模式允许你将复杂的操作分离出来，而不影响对象结构。
不方便修改对象结构：当对象结构比较稳定，频繁添加新行为时，访问者模式可以让你在不修改这些对象类的前提下，增加新的操作。
操作与结构的分离：当你希望将操作与对象结构进行解耦时，访问者模式非常适用。

访问者模式的示例代码

假设我们有一个对象结构，包含不同类型的形状，如圆形、矩形、三角形等。我们希望对这些形状进行不同的操作，例如计算面积、绘制形状等。访问者模式可以帮助我们在不修改形状类的前提下添加这些操作。

1. 定义访问者接口、元素接口和具体实现类

#include <QDebug>
#include <QString>
#include <QList>

// 前向声明
class Circle;
class Rectangle;
class Triangle;

// 访问者接口：定义访问每个元素的操作
class Visitor {
public:
    virtual void visitCircle(Circle* circle) = 0;
    virtual void visitRectangle(Rectangle* rectangle) = 0;
    virtual void visitTriangle(Triangle* triangle) = 0;
    virtual ~Visitor() = default;
};

// 元素接口：定义接受访问者的方法
class Shape {
public:
    virtual void accept(Visitor* visitor) = 0;
    virtual ~Shape() = default;
};

// 具体元素类：圆形
class Circle : public Shape {
private:
    int radius;

public:
    Circle(int r) : radius(r) {}

    int getRadius() const {
        return radius;
    }

    void accept(Visitor* visitor) override {
        visitor->visitCircle(this);  // 让访问者访问自己
    }
};

// 具体元素类：矩形
class Rectangle : public Shape {
private:
    int width, height;

public:
    Rectangle(int w, int h) : width(w), height(h) {}

    int getWidth() const {
        return width;
    }

    int getHeight() const {
        return height;
    }

    void accept(Visitor* visitor) override {
        visitor->visitRectangle(this);  // 让访问者访问自己
    }
};

// 具体元素类：三角形
class Triangle : public Shape {
private:
    int base, height;

public:
    Triangle(int b, int h) : base(b), height(h) {}

    int getBase() const {
        return base;
    }

    int getHeight() const {
        return height;
    }

    void accept(Visitor* visitor) override {
        visitor->visitTriangle(this);  // 让访问者访问自己
    }
};

// 具体访问者类：计算形状面积
class AreaVisitor : public Visitor {
public:
    void visitCircle(Circle* circle) override {
        int radius = circle->getRadius();
        double area = 3.14 * radius * radius;
        qDebug() << "Circle area:" << area;
    }

    void visitRectangle(Rectangle* rectangle) override {
        int area = rectangle->getWidth() * rectangle->getHeight();
        qDebug() << "Rectangle area:" << area;
    }

    void visitTriangle(Triangle* triangle) override {
        double area = 0.5 * triangle->getBase() * triangle->getHeight();
        qDebug() << "Triangle area:" << area;
    }
};

// 具体访问者类：绘制形状
class DrawVisitor : public Visitor {
public:
    void visitCircle(Circle* circle) override {
        qDebug() << "Drawing a circle with radius" << circle->getRadius();
    }

    void visitRectangle(Rectangle* rectangle) override {
        qDebug() << "Drawing a rectangle with width" << rectangle->getWidth() << "and height" << rectangle->getHeight();
    }

    void visitTriangle(Triangle* triangle) override {
        qDebug() << "Drawing a triangle with base" << triangle->getBase() << "and height" << triangle->getHeight();
    }
};

// 对象结构：形状集合
class ShapeCollection {
private:
    QList<Shape*> shapes;

public:
    void addShape(Shape* shape) {
        shapes.append(shape);
    }

    void accept(Visitor* visitor) {
        for (Shape* shape : shapes) {
            shape->accept(visitor);  // 让每个形状接受访问者
        }
    }

    ~ShapeCollection() {
        qDeleteAll(shapes);
    }
};

// 使用示例
int main() {
    // 创建一些形状
    Shape* circle = new Circle(5);
    Shape* rectangle = new Rectangle(4, 6);
    Shape* triangle = new Triangle(3, 4);

    // 创建形状集合
    ShapeCollection shapeCollection;
    shapeCollection.addShape(circle);
    shapeCollection.addShape(rectangle);
    shapeCollection.addShape(triangle);

    // 创建访问者：计算面积
    AreaVisitor* areaVisitor = new AreaVisitor();
    qDebug() << "Calculating areas:";
    shapeCollection.accept(areaVisitor);

    // 创建访问者：绘制形状
    DrawVisitor* drawVisitor = new DrawVisitor();
    qDebug() << "\nDrawing shapes:";
    shapeCollection.accept(drawVisitor);

    // 清理内存
    delete areaVisitor;
    delete drawVisitor;

    return 0;
}

代码解析

Visitor接口：定义了访问不同类型形状的操作（visitCircle、visitRectangle、visitTriangle）。
Shape接口：定义了接受访问者的方法（accept），每个具体的形状都会调用访问者的相应方法，并将自身传递给访问者。
具体元素类（Circle、Rectangle、Triangle）：这些类实现了Shape接口，并在accept方法中调用访问者的具体方法。
AreaVisitor和DrawVisitor类：这两个具体的访问者实现了访问者接口，用于计算形状的面积和绘制形状。每个访问者都提供了不同的功能，而不需要修改Shape类。
ShapeCollection类：这是一个对象结构，包含多个Shape对象，并让访问者依次访问每个形状。

访问者模式的优点

增加操作非常容易：当需要对对象结构中的元素添加新的操作时，只需要增加新的访问者，而不需要修改已有的类，这符合开闭原则。
分离关注点：访问者模式将不同操作（如计算面积、绘制形状等）分离到不同的访问者中，从而避免了将操作逻辑分散到元素类中，提高了系统的可维护性。
符合单一职责原则：每个访问者只专注于一种操作，不会影响对象结构的定义和职责。

访问者模式的缺点

违反了依赖倒置原则：访问者模式要求元素类依赖访问者接口，这在某种程度上违反了依赖倒置原则。因为对象结构中的元素需要接受访问者，这使得元素类必须知道访问者的存在。
增加了复杂性：当对象结构中的元素种类较多时，访问者接口和访问者类会变得非常庞大，尤其是当每个访问者都需要实现多个访问方法时，复杂度会增加。
元素类的变化困难：如果对象结构中的元素类需要频繁变化（如添加新的字段或属性），那么每个访问者类都需要修改，增加了维护成本。

适合使用访问者模式的情况

需要对类结构中的对象添加新行为：如果频繁需要对类结构中的对象添加新的操作，访问者模式是一个很好的选择，因为你可以通过创建新的访问者来实现新行为，而不需要修改原有的类。
稳定的类结构：访问者模式适合对象结构较为稳定、不频繁修改的情况，因为它通过增加访问者来扩展操作，而不是通过修改对象结构本身。