好的，各位观众，欢迎来到“C++那些事儿”之“Variant的正确打开方式：std::visit”。今天咱们就来聊聊C++17引入的std::variant和它的好基友std::visit，保证让你听完之后，再也不怕类型乱飞，代码安全得飞起！
开场白：类型，永远的痛
在编程的世界里，类型就像我们穿的衣服，要合身才能舒服。但有时候，需求总是千奇百怪，我们需要一件能适应各种场合的“变形金刚”——这就是std::variant的用武之地。
想象一下，你要设计一个配置系统，配置项可以是整数、字符串、布尔值，甚至是浮点数。如果没有std::variant，你可能需要祭出union大法，或者用void*强转，想想就头皮发麻，类型安全什么的，早就抛到九霄云外了。
std::variant：一个能装多种类型的盒子
std::variant就像一个神奇的盒子，它可以装多种不同类型的东西，但同一时刻只能装一个。它的定义方式很简单：
#include <variant>
#include <string>
std::variant<int, double, std::string> my_variant;这段代码定义了一个名为my_variant的变量，它可以存储int、double或std::string类型的值。
赋值与访问：小心翼翼的试探
给std::variant赋值很简单：
my_variant = 10; // 存储一个 int
my_variant = 3.14; // 存储一个 double
my_variant = "Hello"; // 存储一个 std::string但是，要访问std::variant中存储的值，就不能像访问普通变量那样直接了，因为你不知道它现在到底装的是什么。 这时候，有几种方法：
-
std::get<T>()：我知道你是谁如果你确定
std::variant中存储的是某个特定类型，可以使用std::get<T>()：int value = std::get<int>(my_variant); // 如果 my_variant 存储的是 int，则成功但是，如果
my_variant存储的不是int，这段代码就会抛出一个std::bad_variant_access异常。所以，在使用std::get<T>()之前，最好先用std::holds_alternative<T>()检查一下：if (std::holds_alternative<int>(my_variant)) { int value = std::get<int>(my_variant); std::cout << "Value: " << value << std::endl; } else { std::cout << "my_variant is not an int!" << std::endl; } -
std::get_if<T>()：温和的试探std::get_if<T>()比std::get<T>()更温和一些，它不会抛出异常，而是返回一个指向std::variant中存储值的指针。如果std::variant存储的不是指定类型，则返回nullptr：int* value_ptr = std::get_if<int>(&my_variant); if (value_ptr) { std::cout << "Value: " << *value_ptr << std::endl; } else { std::cout << "my_variant is not an int!" << std::endl; } -
std::index()：告诉我你的索引std::variant会记住它当前存储的是哪个类型，并用一个索引来表示。你可以使用std::index()来获取这个索引：size_t index = my_variant.index(); std::cout << "Current index: " << index << std::endl; //输出可能是0,1,2这个索引对应于
std::variant定义中类型的顺序。例如，在std::variant<int, double, std::string>中，int的索引是0，double的索引是1，std::string的索引是2。 你可以结合std::index和switch语句来实现类型判断，但这种方式比较繁琐。
std::visit：类型安全的终极解决方案
上面这些方法虽然能访问std::variant中的值，但都需要手动进行类型判断，代码写起来比较啰嗦，而且容易出错。 std::visit的出现，就是为了解决这个问题。它提供了一种类型安全、简洁优雅的方式来访问std::variant中的值。
std::visit接受两个参数：
- 一个可调用对象（通常是一个lambda表达式或函数对象）。
- 一个或多个
std::variant对象。
std::visit会根据std::variant中存储的类型，自动选择合适的可调用对象进行调用。
Lambda表达式：灵活的访客
最常用的方式是使用lambda表达式作为可调用对象：
#include <iostream>
#include <variant>
#include <string>
int main() {
std::variant<int, double, std::string> my_variant = "Hello";
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;
}
}, my_variant);
return 0;
}在这个例子中，lambda表达式接受一个参数arg，它的类型会根据my_variant中存储的类型自动推导。std::decay_t用于移除arg的引用和const属性，以便进行类型比较。if constexpr用于在编译时进行类型判断，避免运行时开销。
函数对象：更清晰的结构
除了lambda表达式，你也可以使用函数对象：
#include <iostream>
#include <variant>
#include <string>
struct Visitor {
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> my_variant = 3.14;
std::visit(Visitor{}, my_variant);
return 0;
}这个例子中，Visitor是一个函数对象，它重载了operator()，针对不同的类型提供了不同的处理方式。这种方式比lambda表达式更清晰，更易于维护。
通用访客：让代码更简洁
C++17引入了std::variant，同时也带来了std::visit，以及一种更简洁的访问方式：通用访客。 我们可以使用一个模板化的operator()来实现：
#include <iostream>
#include <variant>
#include <string>
struct GenericVisitor {
template <typename T>
void operator()(const T& arg) const {
std::cout << "It's a " << typeid(T).name() << ": " << arg << std::endl;
}
};
int main() {
std::variant<int, double, std::string> my_variant = "Hello";
std::visit(GenericVisitor{}, my_variant);
return 0;
}这个例子中，GenericVisitor的operator()是一个模板函数，它可以接受任何类型的参数。这种方式最简洁，但缺点是无法针对不同的类型进行特殊处理。
多个Variant：一起跳舞
std::visit不仅可以处理单个std::variant，还可以同时处理多个。 例如，假设我们有两个std::variant，分别存储了不同的类型：
#include <iostream>
#include <variant>
#include <string>
int main() {
std::variant<int, double> v1 = 10;
std::variant<std::string, bool> v2 = true;
std::visit([](auto&& arg1, auto&& arg2) {
using T1 = std::decay_t<decltype(arg1)>;
using T2 = std::decay_t<decltype(arg2)>;
std::cout << "v1 is a " << typeid(T1).name() << ": " << arg1 << std::endl;
std::cout << "v2 is a " << typeid(T2).name() << ": " << arg2 << std::endl;
if constexpr (std::is_same_v<T1, int> && std::is_same_v<T2, bool>) {
std::cout << "v1 is an int and v2 is a bool" << std::endl;
}
}, v1, v2);
return 0;
}在这个例子中，lambda表达式接受两个参数arg1和arg2，分别对应于v1和v2中存储的类型。std::visit会根据v1和v2中存储的类型组合，自动选择合适的lambda表达式进行调用。
std::monostate：处理空Variant
std::variant还有一个特殊的类型std::monostate，用于表示std::variant未存储任何值的情况。 如果你想处理这种情况，可以将std::monostate添加到std::variant的类型列表中：
#include <iostream>
#include <variant>
#include <string>
int main() {
std::variant<int, double, std::string, std::monostate> my_variant; // 默认构造，未存储任何值
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;
} else if constexpr (std::is_same_v<T, std::monostate>) {
std::cout << "It's empty!" << std::endl;
}
}, my_variant);
return 0;
}一个更实际的例子：配置系统
让我们回到最初的配置系统例子。 假设我们有一个配置类，它使用std::variant来存储配置项的值：
#include <iostream>
#include <variant>
#include <string>
#include <map>
class Configuration {
public:
using ValueType = std::variant<int, double, std::string, bool>;
void set(const std::string& key, ValueType value) {
config_[key] = value;
}
template <typename T>
T get(const std::string& key, const T& default_value) const {
auto it = config_.find(key);
if (it == config_.end()) {
return default_value;
}
try {
return std::get<T>(it->second);
} catch (const std::bad_variant_access&) {
return default_value;
}
}
void print() const {
for (const auto& [key, value] : config_) {
std::cout << key << ": ";
std::visit([](auto&& arg) {
std::cout << arg;
}, value);
std::cout << std::endl;
}
}
private:
std::map<std::string, ValueType> config_;
};
int main() {
Configuration config;
config.set("port", 8080);
config.set("host", "localhost");
config.set("debug", true);
config.set("pi", 3.14);
std::cout << "Port: " << config.get("port", 0) << std::endl;
std::cout << "Host: " << config.get("host", std::string("")) << std::endl;
std::cout << "Debug: " << config.get("debug", false) << std::endl;
std::cout << "Pi: " << config.get("pi", 0.0) << std::endl;
config.print();
return 0;
}在这个例子中，Configuration类使用一个std::map来存储配置项，每个配置项的值是一个std::variant，可以是int、double、std::string或bool。get()方法使用std::get<T>()来获取配置项的值，如果类型不匹配，则返回默认值。print()方法使用std::visit来打印配置项的值。
总结：Variant + Visit = 类型安全 + 优雅
std::variant和std::visit是C++17中非常强大的工具，它们可以让你编写更安全、更灵活的代码。 std::variant提供了一种存储多种不同类型的值的方式，而std::visit提供了一种类型安全、简洁优雅的方式来访问这些值。 记住，类型安全是编程的基石，std::variant和std::visit可以帮助你构建更健壮的应用程序。
一些额外的提示和技巧
- 编译时检查： 使用
if constexpr在编译时进行类型判断，避免运行时开销。 - constexpr： 如果可能，尽量将
std::variant和std::visit用于constexpr上下文中，以提高性能。 - 自定义类型：
std::variant可以存储任何类型，包括自定义类型。 - 异常安全：
std::visit保证异常安全，即使可调用对象抛出异常，std::variant的状态也不会被破坏。
表格：各种访问方式的对比
| 方法 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|
std::get<T>() |
快速，直接访问已知类型 | 如果类型不匹配，抛出异常 | 确定std::variant中存储的是某个特定类型 |
std::get_if<T>() |
不抛出异常，返回指针 | 需要检查指针是否为空 | 不确定std::variant中存储的是否是某个特定类型 |
std::index() + switch |
可以处理所有类型 | 代码冗长，容易出错 | 需要手动进行类型判断，不推荐使用 |
std::visit |
类型安全，简洁优雅，自动选择合适的可调用对象进行调用 | 需要定义可调用对象 | 所有需要访问std::variant中存储的值的场景，强烈推荐使用 |
最后，记住一点：代码安全第一，优雅第二。 std::variant和std::visit就是你安全又优雅的利器！
好了，今天的讲座就到这里，希望大家有所收获！ 下次再见！