C++实现Visitor Pattern：利用`std::variant`与`std::visit`实现无虚函数的动态派发

C++ Visitor Pattern：基于 std::variant 与 std::visit 的无虚函数动态派发

各位听众，大家好。今天我们来探讨一个重要的设计模式——Visitor Pattern，并着重介绍如何利用C++17引入的 std::variant 和 std::visit 来实现一种无虚函数的动态派发机制，从而避免传统面向对象中虚函数带来的性能开销和代码复杂性。

1. Visitor Pattern 的本质与传统实现

Visitor Pattern 的核心思想是将算法与它所操作的对象结构分离。这意味着我们可以独立地修改算法，而无需修改对象结构的定义。这在以下场景中特别有用：

• 对象结构稳定，但需要在其上执行多种不同的操作。
• 需要在运行时动态地选择要执行的操作。
• 希望避免在对象结构中添加大量特定于操作的代码。

传统的Visitor Pattern通常依赖于虚函数来实现。对象结构中的每个元素都定义一个 accept() 方法，该方法接受一个 Visitor 对象作为参数，并在内部调用 Visitor 对象的 visit() 方法，并将自身作为参数传递给 visit() 方法。Visitor 对象针对每种元素类型都有一个对应的 visit() 方法，从而实现动态派发。

举例说明，假设我们有一个图形对象结构，包含 Circle 和 Rectangle 两种类型。我们可以使用传统的Visitor Pattern来实现一个计算面积的Visitor。

#include <iostream>

class Shape {
public:
    virtual void accept(class Visitor& visitor) = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape {
public:
    Circle(double radius) : radius_(radius) {}
    double getRadius() const { return radius_; }
    void accept(Visitor& visitor) override;
private:
    double radius_;
};

class Rectangle : public Shape {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
    void accept(Visitor& visitor) override;
private:
    double width_;
    double height_;
};

class Visitor {
public:
    virtual void visit(Circle& circle) = 0;
    virtual void visit(Rectangle& rectangle) = 0;
    virtual ~Visitor() = default;
};

void Circle::accept(Visitor& visitor) {
    visitor.visit(*this);
}

void Rectangle::accept(Visitor& visitor) {
    visitor.visit(*this);
}

class AreaCalculator : public Visitor {
public:
    void visit(Circle& circle) override {
        area_ = 3.14159 * circle.getRadius() * circle.getRadius();
    }
    void visit(Rectangle& rectangle) override {
        area_ = rectangle.getWidth() * rectangle.getHeight();
    }
    double getArea() const { return area_; }
private:
    double area_ = 0.0;
};

int main() {
    Circle circle(5.0);
    Rectangle rectangle(4.0, 6.0);

    AreaCalculator areaCalculator;
    circle.accept(areaCalculator);
    std::cout << "Circle area: " << areaCalculator.getArea() << std::endl;

    rectangle.accept(areaCalculator);
    std::cout << "Rectangle area: " << areaCalculator.getArea() << std::endl;

    return 0;
}

这种实现方式的缺点在于：

• 虚函数开销： 每次调用 accept() 和 visit() 方法都会涉及虚函数调用，这会带来一定的性能开销。
• 代码侵入性： 需要在 Shape 类及其子类中添加 accept() 方法，这会修改对象结构的代码。
• 可扩展性限制： 添加新的 Shape 子类， 需要修改 Visitor 类， 添加新的visit 函数， 违反了开闭原则。

2. 基于 std::variant 和 std::visit 的 Visitor Pattern

C++17 引入的 std::variant 和 std::visit 提供了一种更优雅、更高效的实现Visitor Pattern的方式，避免了虚函数的使用。

• std::variant： std::variant 是一种可以安全地存储多种不同类型的值的类型。它类似于一个类型安全的 union。

• std::visit： std::visit 接受一个 Visitor 对象和一个 std::variant 对象作为参数，并根据 std::variant 中存储的类型，调用 Visitor 对象中对应的函数。这个过程不需要虚函数，而是利用编译时的类型信息进行静态分发。

下面我们用 std::variant 和 std::visit 来重新实现上面的例子。

#include <iostream>
#include <variant>

class Circle {
public:
    Circle(double radius) : radius_(radius) {}
    double getRadius() const { return radius_; }
private:
    double radius_;
};

class Rectangle {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
private:
    double width_;
    double height_;
};

// 定义一个 variant 类型，它可以存储 Circle 或 Rectangle 对象
using Shape = std::variant<Circle, Rectangle>;

class AreaCalculator {
public:
    double operator()(const Circle& circle) const {
        return 3.14159 * circle.getRadius() * circle.getRadius();
    }
    double operator()(const Rectangle& rectangle) const {
        return rectangle.getWidth() * rectangle.getHeight();
    }
};

int main() {
    Shape circle = Circle(5.0);
    Shape rectangle = Rectangle(4.0, 6.0);

    AreaCalculator areaCalculator;

    // 使用 std::visit 调用 AreaCalculator 中对应的函数
    double circleArea = std::visit(areaCalculator, circle);
    std::cout << "Circle area: " << circleArea << std::endl;

    double rectangleArea = std::visit(areaCalculator, rectangle);
    std::cout << "Rectangle area: " << rectangleArea << std::endl;

    return 0;
}

在这个例子中，我们不再需要定义 Shape 的基类和 accept() 方法。我们定义了一个 Shape 的 std::variant 类型，它可以存储 Circle 或 Rectangle 对象。AreaCalculator 类现在变成了一个函数对象，它重载了 operator()，针对 Circle 和 Rectangle 类型分别定义了计算面积的函数。最后，我们使用 std::visit 来调用 AreaCalculator 中对应的函数，从而实现动态派发。

3. std::visit 的原理和优势

std::visit 的实现原理依赖于编译时的类型信息。当 std::visit 接受一个 std::variant 对象和一个 Visitor 对象作为参数时，它会在编译时确定 std::variant 中存储的类型，并找到 Visitor 对象中对应的函数。然后，它会直接调用该函数，而不需要使用虚函数。

这种实现方式的优势在于：

• 无虚函数开销： 避免了虚函数调用带来的性能开销。
• 代码简洁： 代码更加简洁易懂，不需要定义 accept() 方法。
• 类型安全： std::variant 提供了类型安全的存储，避免了类型转换错误。
• 非侵入性： 不需要修改 Circle 和 Rectangle 类， 符合开闭原则。

4. 更复杂的使用场景

现在，我们考虑一个更复杂的使用场景：我们需要实现一个 Visitor，它可以打印图形对象的描述信息。

#include <iostream>
#include <variant>
#include <string>

class Circle {
public:
    Circle(double radius) : radius_(radius) {}
    double getRadius() const { return radius_; }
private:
    double radius_;
};

class Rectangle {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
private:
    double width_;
    double height_;
};

using Shape = std::variant<Circle, Rectangle>;

class DescriptionPrinter {
public:
    std::string operator()(const Circle& circle) const {
        return "Circle with radius: " + std::to_string(circle.getRadius());
    }
    std::string operator()(const Rectangle& rectangle) const {
        return "Rectangle with width: " + std::to_string(rectangle.getWidth()) +
               ", height: " + std::to_string(rectangle.getHeight());
    }
};

int main() {
    Shape circle = Circle(5.0);
    Shape rectangle = Rectangle(4.0, 6.0);

    DescriptionPrinter descriptionPrinter;

    std::string circleDescription = std::visit(descriptionPrinter, circle);
    std::cout << circleDescription << std::endl;

    std::string rectangleDescription = std::visit(descriptionPrinter, rectangle);
    std::cout << rectangleDescription << std::endl;

    return 0;
}

在这个例子中，DescriptionPrinter 类重载了 operator()，针对 Circle 和 Rectangle 类型分别定义了打印描述信息的函数。

5. 使用 Lambda 表达式简化 Visitor

如果 Visitor 的逻辑比较简单，我们可以使用 Lambda 表达式来进一步简化代码。

#include <iostream>
#include <variant>

class Circle {
public:
    Circle(double radius) : radius_(radius) {}
    double getRadius() const { return radius_; }
private:
    double radius_;
};

class Rectangle {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
private:
    double width_;
    double height_;
};

using Shape = std::variant<Circle, Rectangle>;

int main() {
    Shape circle = Circle(5.0);
    Shape rectangle = Rectangle(4.0, 6.0);

    // 使用 Lambda 表达式计算面积
    double circleArea = std::visit([](const auto& shape) -> double {
        if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Circle>) {
            return 3.14159 * shape.getRadius() * shape.getRadius();
        } else if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Rectangle>) {
            return shape.getWidth() * shape.getHeight();
        } else {
            return 0.0; // 默认情况
        }
    }, circle);
    std::cout << "Circle area: " << circleArea << std::endl;

    double rectangleArea = std::visit([](const auto& shape) -> double {
        if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Circle>) {
            return 3.14159 * shape.getRadius() * shape.getRadius();
        } else if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Rectangle>) {
            return shape.getWidth() * shape.getHeight();
        } else {
            return 0.0; // 默认情况
        }
    }, rectangle);
    std::cout << "Rectangle area: " << rectangleArea << std::endl;

    return 0;
}

或者更加简洁的写法,利用结构化绑定

#include <iostream>
#include <variant>

class Circle {
public:
    Circle(double radius) : radius_(radius) {}
    double getRadius() const { return radius_; }
private:
    double radius_;
};

class Rectangle {
public:
    Rectangle(double width, double height) : width_(width), height_(height) {}
    double getWidth() const { return width_; }
    double getHeight() const { return height_; }
private:
    double width_;
    double height_;
};

using Shape = std::variant<Circle, Rectangle>;

int main() {
    Shape circle = Circle(5.0);
    Shape rectangle = Rectangle(4.0, 6.0);

    // 使用 Lambda 表达式计算面积
    double circleArea = std::visit([](const auto& shape) -> double {
        if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Circle>) {
            const auto& [radius] = shape; // 结构化绑定访问 radius
            return 3.14159 * radius * radius;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Rectangle>) {
            const auto& [width, height] = shape; // 结构化绑定访问 width 和 height
            return width * height;
        } else {
            return 0.0; // 默认情况
        }
    }, circle);
    std::cout << "Circle area: " << circleArea << std::endl;

    double rectangleArea = std::visit([](const auto& shape) -> double {
        if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Circle>) {
            const auto& [radius] = shape; // 结构化绑定访问 radius
            return 3.14159 * radius * radius;
        } else if constexpr (std::is_same_v<std::decay_t<decltype(shape)>, Rectangle>) {
            const auto& [width, height] = shape; // 结构化绑定访问 width 和 height
            return width * height;
        } else {
            return 0.0; // 默认情况
        }
    }, rectangle);
    std::cout << "Rectangle area: " << rectangleArea << std::endl;

    return 0;
}

但是, 请注意,使用lambda表达式时, 需要确保lambda表达式能够处理variant的所有类型.

6. 错误处理

在使用 std::variant 和 std::visit 时，需要注意错误处理。如果 Visitor 对象中没有提供对应于 std::variant 中存储的类型的函数，std::visit 会抛出一个 std::bad_variant_access 异常。因此，我们需要确保 Visitor 对象能够处理 std::variant 中所有可能的类型，或者使用 try-catch 块来捕获异常。

7. 表格对比：传统 Visitor vs. std::variant Visitor

特性	传统 Visitor (虚函数)	std::variant Visitor
性能	虚函数调用开销	无虚函数开销
代码复杂度	较高	较低
类型安全	较低	较高
代码侵入性	高	低
可扩展性	较差	较好(添加新的visitor更为方便)

8. 总结：一种更高效的动态派发方案

总而言之，通过 std::variant 和 std::visit，我们能够以更加高效和安全的方式实现 Visitor Pattern。它避免了虚函数的性能开销，降低了代码的复杂性，并提供了更好的类型安全性。在 C++17 及更高版本中，这种方式是实现 Visitor Pattern 的首选方案。使用时,需要注意错误处理,确保Visitor能够处理Variant的所有类型。

更多IT精英技术系列讲座，到智猿学院