C++ `std::variant` 与 `std::visit`：类型安全的多态替代方案

好的，各位观众，欢迎来到今天的C++ “变形金刚” 特别讲座！今天我们要聊的是C++17引入的两个神器：std::variant 和 std::visit。它们就像C++里的变形金刚，能根据不同的情况变幻形态，解决你在类型安全方面遇到的各种难题。

传统的困境：多态的烦恼

在C++的世界里，多态性通常通过继承和虚函数来实现。这种方法很强大，但也有一些缺点：

• 运行时开销： 虚函数调用需要在运行时查虚函数表，这会带来性能开销。
• 类型安全性： 基类指针可以指向任何派生类对象，这可能导致类型转换错误。
• 代码膨胀： 如果有很多派生类，虚函数表会变得很大，增加代码体积。
• 侵入性： 为了使用虚函数，类必须从一个共同的基类继承，这限制了类的设计。

说白了，就是用起来有点“笨重”，不够灵活。

救星登场：std::variant 和 std::visit

std::variant 和 std::visit 的出现，为我们提供了一种类型安全、高效的多态替代方案。它们就像C++语言自带的“瑞士军刀”，能让你在处理多种类型时更加得心应手。

std::variant：容器界的变形金刚

std::variant 是一个可以容纳多个不同类型值的类型。你可以把它想象成一个“超级容器”，但这个容器一次只能装一个东西，而且你必须提前告诉它可能装哪些东西。

语法：

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

std::variant<int, double, std::string> myVar;

这里，myVar 可以存储 int、double 或 std::string 类型的值。

赋值：

myVar = 10; // 现在 myVar 存储一个 int 值
myVar = 3.14; // 现在 myVar 存储一个 double 值
myVar = "Hello"; // 现在 myVar 存储一个 std::string 值

index() 方法：

variant 通过 index() 方法告诉你当前存储的是哪个类型。

std::cout << myVar.index() << std::endl; // 输出 2，因为现在存储的是 std::string

注意：index() 返回的是类型在 variant 定义中的索引，从 0 开始。

std::get<>：精准提取

std::get<> 允许你安全地提取 variant 中存储的值。但是，如果你提取的类型与当前存储的类型不匹配，程序会抛出 std::bad_variant_access 异常。

try {
    int value = std::get<int>(myVar); // 尝试提取 int 值
    std::cout << value << std::endl;
} catch (const std::bad_variant_access& e) {
    std::cerr << "Error: " << e.what() << std::endl; // 输出错误信息
}

std::string str = std::get<std::string>(myVar); // 安全提取 std::string 值
std::cout << str << std::endl;

std::get_if<>：安全试探

std::get_if<> 是一个更安全的提取方式。它返回一个指向 variant 中存储值的指针，如果类型匹配，否则返回 nullptr。

if (int* ptr = std::get_if<int>(&myVar)) {
    std::cout << "It's an int: " << *ptr << std::endl;
} else if (double* ptr = std::get_if<double>(&myVar)) {
    std::cout << "It's a double: " << *ptr << std::endl;
} else if (std::string* ptr = std::get_if<std::string>(&myVar)) {
    std::cout << "It's a string: " << *ptr << std::endl;
} else {
    std::cout << "Variant is empty." << std::endl;
}

std::holds_alternative<>：类型判断大师

std::holds_alternative<> 让你能够判断 variant 是否存储了特定类型的值。

if (std::holds_alternative<int>(myVar)) {
    std::cout << "It's an int!" << std::endl;
} else if (std::holds_alternative<double>(myVar)) {
    std::cout << "It's a double!" << std::endl;
} else if (std::holds_alternative<std::string>(myVar)) {
    std::cout << "It's a string!" << std::endl;
}

std::visit：行为定义器

std::visit 允许你根据 variant 中存储的类型，执行不同的操作。它就像一个“策略模式”的自动化版本，根据不同的输入类型，选择不同的策略执行。

基本用法：

#include <iostream>
#include <variant>

int main() {
    std::variant<int, double, std::string> var = 10;

    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            std::cout << "It's an int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "It's a double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "It's a string: " << arg << std::endl;
        }
    }, var);

    var = 3.14;
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            std::cout << "It's an int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "It's a double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "It's a string: " << arg << std::endl;
        }
    }, var);

    var = "Hello, world!";
    std::visit([](auto&& arg) {
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, int>) {
            std::cout << "It's an int: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << "It's a double: " << arg << std::endl;
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "It's a string: " << arg << std::endl;
        }
    }, var);

    return 0;
}

这里，我们使用一个 lambda 表达式作为 visitor。std::visit 会自动将 variant 中存储的值传递给 lambda 表达式，并根据类型执行相应的代码。

使用 Functor（函数对象）：

除了 lambda 表达式，你还可以使用函数对象作为 visitor。

struct MyVisitor {
    void operator()(int i) const {
        std::cout << "It's an int: " << i << std::endl;
    }

    void operator()(double d) const {
        std::cout << "It's a double: " << d << std::endl;
    }

    void operator()(const std::string& s) const {
        std::cout << "It's a string: " << s << std::endl;
    }
};

int main() {
    std::variant<int, double, std::string> var = 10;
    std::visit(MyVisitor{}, var);

    var = 3.14;
    std::visit(MyVisitor{}, var);

    var = "Hello, world!";
    std::visit(MyVisitor{}, var);

    return 0;
}

使用 Lambda 表达式的重载:

#include <iostream>
#include <variant>

int main() {
    std::variant<int, double, std::string> var = 10;

    auto visitor = [](auto&& arg) {
        std::visit([&](auto&& x){
            if constexpr (std::is_same_v<decltype(x), int>) {
                std::cout << "It's an int: " << x << std::endl;
            } else if constexpr (std::is_same_v<decltype(x), double>) {
                std::cout << "It's a double: " << x << std::endl;
            } else if constexpr (std::is_same_v<decltype(x), std::string>) {
                std::cout << "It's a string: " << x << std::endl;
            }
        }, arg);
    };

    var = 10;
    visitor(var);

    var = 3.14;
    visitor(var);

    var = "Hello, world!";
    visitor(var);

    return 0;
}

std::monostate：空的占位符

如果你想让 variant 允许为空，可以使用 std::monostate。

#include <variant>
#include <iostream>

int main() {
    std::variant<int, std::monostate> var;

    if (std::holds_alternative<std::monostate>(var)) {
        std::cout << "Variant is empty." << std::endl;
    }

    var = 10;

    if (std::holds_alternative<int>(var)) {
        std::cout << "Variant contains an integer: " << std::get<int>(var) << std::endl;
    }

    return 0;
}

优势总结：

• 类型安全： std::variant 在编译时检查类型，避免了运行时类型转换错误。
• 高效： 避免了虚函数调用的开销，提高了性能。
• 灵活： 可以容纳任何类型，无需继承。
• 表达力强： std::visit 使得代码更加简洁易懂。

应用场景：

• 解析器： 表示不同类型的语法节点。
• 状态机： 表示不同的状态。
• 数据传输： 表示不同类型的数据。
• 事件处理： 表示不同的事件类型。
• 任何需要处理多种类型的场景。

例子：一个简单的计算器

让我们用 std::variant 和 std::visit 实现一个简单的计算器，它可以处理整数和浮点数。

#include <iostream>
#include <variant>

// 定义操作数类型
using Operand = std::variant<int, double>;

// 定义操作类型
enum class Operation {
    Add,
    Subtract,
    Multiply,
    Divide
};

// 计算函数
Operand calculate(Operand left, Operation op, Operand right) {
    return std::visit([&](auto l, auto r) -> Operand {
        if constexpr (op == Operation::Add) {
            return l + r;
        } else if constexpr (op == Operation::Subtract) {
            return l - r;
        } else if constexpr (op == Operation::Multiply) {
            return l * r;
        } else if constexpr (op == Operation::Divide) {
            if (r == 0) {
                throw std::runtime_error("Division by zero");
            }
            return l / r;
        } else {
            throw std::runtime_error("Invalid operation");
        }
    }, left, right);
}

int main() {
    Operand a = 10;
    Operand b = 3.14;

    try {
        Operand result = calculate(a, Operation::Add, b);
        std::visit([](auto r) {
            std::cout << "Result: " << r << std::endl;
        }, result);

        Operand result2 = calculate(a, Operation::Divide, 0); // 除以0
        std::visit([](auto r) {
            std::cout << "Result: " << r << std::endl;
        }, result2);
    } catch (const std::exception& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    return 0;
}

在这个例子中，Operand 是一个 std::variant，可以存储整数或浮点数。calculate 函数使用 std::visit 来根据操作数的类型执行相应的计算。

与传统多态的对比:

为了更清晰地理解 std::variant 的优势，我们用一个表格来对比它与传统多态的异同。

特性	传统多态 (虚函数)	std::variant
类型安全性	运行时	编译时
性能	运行时开销	更高效
灵活性	需要继承	无需继承
代码体积	可能较大	更小
可维护性	较高	更高
侵入性	侵入性	无侵入性

注意事项：

• 类型必须已知： std::variant 只能存储预先定义的类型。
• 异常处理： 提取错误类型的值会抛出异常，需要进行处理。
• 代码可读性： 复杂的 std::visit 可能会降低代码可读性，需要合理组织代码。
• 不支持协变和逆变： std::variant 不支持协变和逆变，这可能会限制某些场景的应用。

总结：

std::variant 和 std::visit 是C++中强大的类型安全多态工具。它们可以帮助你编写更高效、更安全、更灵活的代码。但是，就像任何工具一样，它们也有自己的适用场景和限制。你需要根据具体情况选择最合适的解决方案。

记住，编程就像烹饪，你需要选择合适的食材和调料，才能做出美味佳肴。std::variant 和 std::visit 就是C++工具箱里的一些“高级调料”，掌握它们，你的代码将会更加美味！

今天的讲座就到这里，谢谢大家！希望大家能从今天的分享中有所收获，并在实际项目中灵活运用 std::variant 和 std::visit，让你的C++代码更加强大！