C++ std::visit结合std::variant的多态访问模式

C++ std::visit结合std::variant的多态访问模式

在现代 C++（C++17 及以上）开发中，std::variant 提供了一种类型安全的联合体，而 std::visit 则是访问这个联合体中数据的钥匙。这种组合被称为“静态多态”，它相比传统的基于继承和虚函数的“动态多态”，不仅消除了堆内存分配的开销，还能让代码逻辑更加内聚。以下是通过 std::visit 实现 std::variant 多态访问的完整实操步骤。

第一步：定义数据结构

首先，抛弃传统的基类和派生类结构，定义一组独立的结构体或类。这些类之间不需要继承关系，只需要包含各自需要的数据成员。

编写以下代码来定义两种图形：圆形和矩形。

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

// 定义圆形结构体
struct Circle {
    double radius;
};

// 定义矩形结构体
struct Rectangle {
    double width;
    double height;
};

创建一个类型别名 Shape，将 Circle 和 Rectangle 封装在 std::variant 中。这意味着 Shape 类型的变量，要么是 Circle，要么是 Rectangle。

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

第二步：构建容器并填充数据

声明一个 std::vector<Shape> 容器，用于存储多种不同的图形对象。这种方式避免了存储指针，对象直接存储在 vector 的内存中。

执行以下代码，向容器中添加不同的图形实例：

std::vector<Shape> shapes;

// 添加一个半径为 5.0 的圆
shapes.emplace_back(Circle{5.0});

// 添加一个宽 4.0、高 6.0 的矩形
shapes.emplace_back(Rectangle{4.0, 6.0});

// 再次添加一个半径为 2.5 的圆
shapes.emplace_back(Circle{2.5});

第三步：使用泛型 Lambda 进行基础访问

std::visit 的核心机制是接受一个“访问者”和一个 variant。访问者通常是一个可调用对象（如 Lambda），它必须能够处理 variant 中的所有可能类型。

使用“泛型 Lambda”（即 auto 参数）是处理 std::variant 最简单的方式。配合 if constexpr（C++17 特性），可以在编译期根据具体类型执行不同逻辑。

编写如下代码遍历容器并计算面积：

for (const auto& shape : shapes) {
    // 使用 std::visit 访问 shape
    std::visit([](const auto& s) {
        // if constexpr 在编译时判断类型
        if constexpr (std::is_same_v<std::decay_t<decltype(s)>, Circle>) {
            double area = 3.14159 * s.radius * s.radius;
            std::cout << "Circle Area: " << area << std::endl;
        }
        else if constexpr (std::is_same_v<std::decay_t<decltype(s)>, Rectangle>) {
            double area = s.width * s.height;
            std::cout << "Rectangle Area: " << area << std::endl;
        }
    }, shape);
}

在此步骤中，std::visit 会自动检测当前 shape 持有的具体类型，并将其作为参数传递给 Lambda。

第四步：实现高阶模式 Overloaded

虽然泛型 Lambda 很强大，但当类型逻辑复杂时，代码会变得冗长。C++ 社区常用一种名为 Overloaded 的辅助模式，将多个针对不同类型的 Lambda 组合成一个访问者。这种模式极大提高了可读性。

定义 Overloaded 辅助类模板：

template<class... Ts>
struct Overloaded : Ts... { 
    using Ts::operator()...; 
};

// 显式推导指引（C++17 必需）
template<class... Ts>
Overloaded(Ts...) -> Overloaded<Ts...>;

这个类利用了 C++17 的类模板参数推导和变参模板展开，将多个 Lambda “合并”成一个对象。

第五步：组合 Lambda 处理不同逻辑

现在，我们可以创建一组独立的 Lambda，分别处理 Circle 和 Rectangle，并将它们传递给 Overloaded，最终传入 std::visit。

运行以下代码，实现更清晰的多态访问：

for (const auto& shape : shapes) {
    std::visit(Overloaded{
        // 专门处理 Circle 的 Lambda
        [](const Circle& c) {
            std::cout << "Processing Circle with radius: " << c.radius << std::endl;
        },
        // 专门处理 Rectangle 的 Lambda
        [](const Rectangle& r) {
            std::cout << "Processing Rectangle with size: " << r.width << "x" << r.height << std::endl;
        }
    }, shape);
}

这种写法将不同类型的逻辑物理隔离，看起来非常像传统的 switch-case，但却是类型安全的。

流程解析

为了更直观地理解 std::visit 的分发机制，请参考以下执行流程图。它展示了 std::visit 如何根据 variant 当前持有的类型索引，将调用路由到正确的 Lambda 函数。

总结：传统虚函数 vs Variant 模式

为了帮助在实际项目中选择合适的技术方案，下表对比了 std::variant 模式与传统虚函数模式的关键差异。