**标题：在 C++ 中利用 std::variant 实现类型安全的多态**

作者

在面向对象的编程中，多态是实现灵活代码的核心手段。然而，传统的继承和虚函数往往带来隐式转换、运行时错误和性能损失。C++17 引入了 std::variant，它是一个类型安全的联合体，能够存储多种类型中的一种，并在编译时保证访问的正确性。本文将介绍如何使用 std::variant 来替代传统多态，并展示一段完整的示例代码。

1. 传统多态的局限

class Shape {
public:
    virtual double area() const = 0;
    virtual ~Shape() {}
};

class Circle : public Shape {
public:
    double radius;
    double area() const override { return 3.14159 * radius * radius; }
};

class Square : public Shape {
public:
    double side;
    double area() const override { return side * side; }
};

std::vector<std::unique_ptr<Shape>> shapes;
  • 运行时开销：虚表查找。
  • 隐藏的类型：使用时只能通过基类接口访问，难以直接得到派生类的特定成员。
  • 多继承与二义性：复杂的继承树可能导致不可预期的行为。

2. std::variant 的概念

std::variant<T...> 是一个可变大小的容器，内部使用单一类型存储，并通过 std::get<T>(v) 或 std::visit 对其进行访问。 

using ShapeVariant = std::variant<Circle, Square>;
  • 类型安全：编译器会检查访问的类型是否合法。
  • 无运行时开销：std::variant 采用布局相同的联合体实现，访问方式与普通联合体相同。
  • 无继承：无需基类，直接把具体类型放进容器。

3. 用 std::visit 实现“多态”

std::visit 接受一个可调用对象（如 lambda）和一个或多个 variant，对其中的实际值进行访问。 

double compute_area(const ShapeVariant& shape) {
    return std::visit([](auto&& s) -> double {
        return s.area();   // 只要所有类型都有 area()
    }, shape);
}

这里的 lambda 是多态的：auto&& s 会根据传入的 variant 类型自动推导成 Circle& 或 Square&。

4. 完整示例

#include <iostream>
#include <variant>
#include <vector>
#include <cmath>
#include <numeric>

struct Circle {
    double radius;
    double area() const { return M_PI * radius * radius; }
};

struct Square {
    double side;
    double area() const { return side * side; }
};

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

int main() {
    std::vector <Shape> shapes = {
        Circle{5.0},
        Square{3.0},
        Circle{2.5}
    };

    // 计算总面积
    double total = std::accumulate(shapes.begin(), shapes.end(), 0.0,
        [](double acc, const Shape& s) {
            return acc + std::visit([](auto&& shape) { return shape.area(); }, s);
        });

    std::cout << "Total area: " << total << std::endl;

    // 访问特定类型
    for (const auto& s : shapes) {
        if (std::holds_alternative <Circle>(s)) {
            const auto& c = std::get <Circle>(s);
            std::cout << "Circle radius: " << c.radius << '\n';
        } else if (std::holds_alternative <Square>(s)) {
            const auto& sq = std::get <Square>(s);
            std::cout << "Square side: " << sq.side << '\n';
        }
    }
}

运行结果： 

Total area: 78.5398
Circle radius: 5
Square side: 3
Circle radius: 2.5

5. 何时使用 std::variant

  • 类型集合已知且有限：如不同几何图形、不同消息类型。
  • 不需要继承链：更简单、可维护。
  • 需要高性能：variant 的访问几乎无额外开销。

6. 结语

std::variant 为 C++ 提供了一个轻量级、类型安全且高性能的多态实现方式。它消除了虚函数表带来的运行时成本，同时避免了复杂继承层次的弊端。只要在设计阶段清楚地列举所有可能的类型，使用 std::variant 能让代码更简洁、更易维护。希望本文能帮助你在未来的项目中更好地运用这项技术。

发表评论