std::variant：如何在一个变量里装下‘猫、狗和鱼’，且不发生冲突？

各位编程爱好者，大家好！

今天，我们将深入探讨C++17引入的一个强大特性——std::variant。想象一下这样的场景：你正在开发一个宠物管理系统，需要在一个变量中存储不同类型的宠物，比如猫、狗或鱼。传统上，这可能意味着使用基类指针、void*、C风格的union，甚至是std::any。但这些方法往往伴随着类型不安全、性能开销或复杂的内存管理。std::variant正是为了解决这类“和类型”（Sum Type）问题而生，它以类型安全、零开销抽象的方式，让我们能够在一个变量中优雅地承载多个互斥的类型。

我们将从问题的根源出发，逐步揭示std::variant的魔力，并通过丰富的代码示例，确保大家能够掌握其精髓。

一、问题的起源：在C++中表示“多选一”

在软件开发中，我们经常遇到需要一个变量表示多种可能状态或类型的情况。例如，一个消息队列中的消息可以是文本消息、图片消息或心跳消息；一个几何图形可以是圆形、矩形或三角形；一个数据库查询结果可以是成功的数据集，也可以是错误信息。

在C++17之前，处理这类“多选一”的需求，我们通常有以下几种选择：

1. void*：万能指针的陷阱

void*可以指向任何类型的数据，但它完全丧失了类型信息。

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

// 假设我们有猫、狗、鱼的简单结构体
struct Cat {
    std::string name;
    void meow() const { std::cout << name << " says Meow!" << std::endl; }
};

struct Dog {
    std::string name;
    void bark() const { std::cout << name << " says Woof!" << std::endl; }
};

struct Fish {
    std::string species;
    void swim() const { std::cout << species << " fish is swimming." << std::endl; }
};

void process_pet_void_ptr(void* pet_ptr, int type_id) {
    if (type_id == 0) { // Cat
        Cat* cat = static_cast<Cat*>(pet_ptr);
        cat->meow();
    } else if (type_id == 1) { // Dog
        Dog* dog = static_cast<Dog*>(pet_ptr);
        dog->bark();
    } else if (type_id == 2) { // Fish
        Fish* fish = static_cast<Fish*>(pet_ptr);
        fish->swim();
    } else {
        std::cerr << "Unknown pet type!" << std::endl;
    }
}

// int main() {
//     Cat my_cat{"Whiskers"};
//     Dog my_dog{"Buddy"};
//     Fish my_fish{"Goldfish"};
//
//     process_pet_void_ptr(&my_cat, 0);
//     process_pet_void_ptr(&my_dog, 1);
//     process_pet_void_ptr(&my_fish, 2);
//
//     // 潜在的类型错误，编译器无法发现
//     process_pet_void_ptr(&my_cat, 1); // 错误地将Cat当作Dog处理
//     return 0;
// }

问题：

• 类型不安全： 必须手动记住原始类型，并通过static_cast进行强制转换。一旦类型信息错误，就会导致未定义行为。
• 内存管理： 如果void*指向的是堆上的对象，需要手动管理其生命周期。
• 可读性差： 代码中充斥着类型ID和static_cast，难以维护。

2. C风格的union：结构体的妥协

union允许在同一块内存区域存储不同的数据类型，但一次只能存储其中一个。

#include <iostream>
#include <string> // C风格的union通常不直接支持非POD类型

// 为了演示，我们使用简单的POD类型
union DataUnion {
    int i;
    float f;
    char c;
};

// struct PetUnion {
//     enum PetType { CAT, DOG, FISH } type;
//     union {
//         Cat cat_data; // 无法直接在C风格union中存储带有非平凡构造函数/析构函数的类型
//         Dog dog_data;
//         Fish fish_data;
//     } data;
// };
//
// int main() {
//     PetUnion my_pet;
//     my_pet.type = PetUnion::CAT;
//     my_pet.data.cat_data = {"Whiskers"}; // 这在C++中仍然是非法的，因为Cat有string成员
//     // 必须手动构造和析构union成员
//     return 0;
// }

问题：

• 类型不安全： 需要一个额外的枚举（discriminant）来指示当前存储的类型，并且必须手动维护枚举和实际类型的一致性。
• 仅限POD类型（C++11前）： union不能直接包含带有非平凡构造函数、析构函数、拷贝/移动构造函数或赋值运算符的类型（例如，含有std::string的结构体）。C++11及以后版本放宽了此限制，但仍需手动管理成员的生命周期（placement new/显式析构）。
• 繁琐： 每次访问都需要检查type字段，并手动进行类型匹配。

3. 多态（继承和虚函数）：面向对象的方案

通过定义一个共同的基类和虚函数，可以实现对不同派生类的统一处理。

#include <iostream>
#include <string>
#include <memory> // For std::unique_ptr

// 基类
struct Animal {
    std::string name;
    Animal(std::string n) : name(std::move(n)) {}
    virtual ~Animal() = default;
    virtual void speak() const = 0; // 纯虚函数
};

// 派生类：Cat
struct Cat : public Animal {
    Cat(std::string n) : Animal(std::move(n)) {}
    void speak() const override { std::cout << name << " says Meow!" << std::endl; }
    void chase_mouse() const { std::cout << name << " is chasing a mouse." << std::endl; }
};

// 派生类：Dog
struct Dog : public Animal {
    Dog(std::string n) : Animal(std::move(n)) {}
    void speak() const override { std::cout << name << " says Woof!" << std::endl; }
    void fetch_ball() const { std::cout << name << " is fetching a ball." << std::endl; }
};

// 派生类：Fish (为了演示，它可能没有典型的“说话”行为)
struct Fish : public Animal {
    std::string species;
    Fish(std::string n, std::string s) : Animal(std::move(n)), species(std::move(s)) {}
    void speak() const override { std::cout << name << " (a " << species << " fish) makes a bubble sound." << std::endl; }
    void swim() const { std::cout << name << " is swimming gracefully." << std::endl; }
};

void process_animal_polymorphic(const Animal& animal) {
    animal.speak();
    // 如果需要访问派生类特有的方法，需要使用 dynamic_cast
    if (const Cat* cat = dynamic_cast<const Cat*>(&animal)) {
        cat->chase_mouse();
    } else if (const Dog* dog = dynamic_cast<const Dog*>(&animal)) {
        dog->fetch_ball();
    } else if (const Fish* fish = dynamic_cast<const Fish*>(&animal)) {
        fish->swim();
    }
}

// int main() {
//     std::unique_ptr<Animal> my_cat = std::make_unique<Cat>("Whiskers");
//     std::unique_ptr<Animal> my_dog = std::make_unique<Dog>("Buddy");
//     std::unique_ptr<Animal> my_fish = std::make_unique<Fish>("Nemo", "Clownfish");
//
//     process_animal_polymorphic(*my_cat);
//     process_animal_polymorphic(*my_dog);
//     process_animal_polymorphic(*my_fish);
//
//     return 0;
// }

问题：

• 堆分配： 通常需要将对象存储在堆上，并通过指针（如std::unique_ptr或std::shared_ptr）来管理。这引入了内存分配和解除分配的开销。
• 引用语义： 多态通常处理的是对象的引用或指针，而不是值语义。
• 运行时开销： 虚函数调用引入了虚表查找的运行时开销。
• dynamic_cast： 当需要访问派生类特有方法时，仍需要dynamic_cast，这是一种运行时类型检查，存在失败的可能性，且不如编译时检查高效和安全。
• 强制继承： 并非所有情况都适合设计继承体系。

4. std::any (C++17)：任意类型的容器

std::any可以存储任何可拷贝构造的类型，并在运行时进行类型检查。

#include <iostream>
#include <string>
#include <any> // C++17

// 沿用之前的Cat, Dog, Fish结构体

void process_pet_any(const std::any& pet_any) {
    if (pet_any.type() == typeid(Cat)) {
        const Cat& cat = std::any_cast<const Cat&>(pet_any);
        cat.meow();
    } else if (pet_any.type() == typeid(Dog)) {
        const Dog& dog = std::any_cast<const Dog&>(pet_any);
        dog.bark();
    } else if (pet_any.type() == typeid(Fish)) {
        const Fish& fish = std::any_cast<const Fish&>(pet_any);
        fish.swim();
    } else {
        std::cerr << "Unknown or unsupported pet type in std::any!" << std::endl;
    }
}

// int main() {
//     std::any my_cat = Cat{"Whiskers"};
//     std::any my_dog = Dog{"Buddy"};
//     std::any my_fish = Fish{"Goldfish"};
//
//     process_pet_any(my_cat);
//     process_pet_any(my_dog);
//     process_pet_any(my_fish);
//
//     // std::any_cast 失败会抛出 std::bad_any_cast 异常
//     try {
//         std::any_cast<Dog>(my_cat); // 运行时错误
//     } catch (const std::bad_any_cast& e) {
//         std::cerr << "Error: " << e.what() << std::endl;
//     }
//
//     return 0;
// }

问题：

• 运行时类型检查： 尽管比void*安全，但std::any的类型检查发生在运行时，而不是编译时。
• 性能开销： 通常涉及堆分配和类型擦除，可能带来额外的性能开销。
• 未列举类型： std::any可以存储任何类型，这意味着你无法在编译时知道它可能包含哪些类型，增加了处理的复杂性。

二、std::variant：现代C++的类型安全和值语义

std::variant是C++17标准库中引入的一个模板类，它是一个类型安全的联合体（Type-safe Union），也常被称为和类型（Sum Type）或标签联合体（Tagged Union）。它能够在同一时间只持有一个指定类型列表中的一个值，并且在编译时提供类型安全保障。

它的核心思想是：在一个变量中，我可以存储T1或T2或T3…，但绝不是同时存储多个，也绝不是存储列表之外的类型。

1. std::variant 的声明与初始化

std::variant 的声明非常直观：

#include <variant> // 包含头文件

// 假设我们沿用之前的 Cat, Dog, Fish 结构体
// ... (Cat, Dog, Fish 定义如前) ...

// 声明一个可以存放 Cat, Dog 或 Fish 对象的 variant
using Pet = std::variant<Cat, Dog, Fish>;

int main() {
    // 1. 直接初始化：默认构造第一个类型（如果可默认构造）
    // 如果第一个类型是 Cat，它将被默认构造
    Pet pet1; // 错误：如果 Cat 不可默认构造，则编译失败。
              // 解决：确保至少一个类型可默认构造，或使用 in_place_index/in_place_type。
              // std::variant<int, std::string> v; // 默认构造 int，v.index() == 0

    // 2. 构造时指定类型和值
    Pet my_cat{Cat{"Whiskers"}}; // my_cat 现在存放一个 Cat 对象
    Pet my_dog{Dog{"Buddy"}};   // my_dog 现在存放一个 Dog 对象
    Pet my_fish{Fish{"Nemo", "Clownfish"}}; // my_fish 存放 Fish

    // 3. 赋值操作：可以改变 variant 内部存储的类型
    my_cat = Dog{"Max"}; // my_cat 现在存放一个 Dog 对象
    my_dog = Fish{"Bubbles", "Betta"}; // my_dog 现在存放一个 Fish 对象

    // 4. `std::in_place_type` 和 `std::in_place_index`
    // 当构造函数有歧义，或者想避免临时对象的创建时非常有用
    Pet pet_in_place1(std::in_place_type<Cat>, "Garfield"); // 直接构造 Cat
    Pet pet_in_place2(std::in_place_index<1>, "Pluto");    // 直接构造 Dog (索引为1)

    // 注意：如果 variant 列表中的类型有重载的构造函数，可能需要 in_place_type 或 in_place_index 来消除歧义。
    // 例如：std::variant<int, double> v(1); // 到底是 int 还是 double？ 默认是 int。
    // v = 1.0; // 默认是 double。
    // std::variant<short, int> v2(1); // 默认是 short。
    // std::variant<short, int> v3(std::in_place_type<int>, 1); // 明确是 int。

    return 0;
}

关键点：

• std::variant的模板参数列表定义了它可以包含的所有可能的类型。
• 它总是包含其中一个类型的值，或者处于空状态（valueless_by_exception，通常在异常发生时）。
• 默认构造函数会构造第一个类型的值（如果可默认构造）。
• 初始化和赋值会自动管理内部对象的构造和析构。

2. 访问 std::variant 的内容

访问std::variant内部存储的值是其核心操作，但由于其类型不确定性，需要特定的机制来确保类型安全。

a. index() 和 holds_alternative()

• index()：返回当前存储值的类型在模板参数列表中的索引（从0开始）。
• holds_alternative<T>()：检查当前是否存储了T类型的对象。

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

struct Cat { std::string name; void meow() const { std::cout << name << " says Meow!" << std::endl; } };
struct Dog { std::string name; void bark() const { std::cout << name << " says Woof!" << std::endl; } };
struct Fish { std::string name; std::string species; void swim() const { std::cout << name << " (a " << species << " fish) is swimming." << std::endl; } };

using Pet = std::variant<Cat, Dog, Fish>; // Cat: index 0, Dog: index 1, Fish: index 2

void inspect_pet(const Pet& pet) {
    std::cout << "Pet index: " << pet.index();

    if (pet.index() == 0) { // Cat
        std::cout << " (Cat)" << std::endl;
    } else if (pet.index() == 1) { // Dog
        std::cout << " (Dog)" << std::endl;
    } else if (pet.index() == 2) { // Fish
        std::cout << " (Fish)" << std::endl;
    }

    if (std::holds_alternative<Cat>(pet)) {
        std::cout << "  Holds a Cat." << std::endl;
    } else if (std::holds_alternative<Dog>(pet)) {
        std::cout << "  Holds a Dog." << std::endl;
    } else if (std::holds_alternative<Fish>(pet)) {
        std::cout << "  Holds a Fish." << std::endl;
    }
}

int main() {
    Pet my_cat{Cat{"Whiskers"}};
    Pet my_dog{Dog{"Buddy"}};
    Pet my_fish{Fish{"Nemo", "Clownfish"}};

    inspect_pet(my_cat);
    inspect_pet(my_dog);
    inspect_pet(my_fish);

    return 0;
}

b. std::get<T>() 和 std::get<index>()

std::get 是一个函数模板，用于从std::variant中提取指定类型或指定索引的值。

• std::get<T>(variant_obj)：如果variant_obj当前持有T类型的值，则返回其引用。否则，抛出std::bad_variant_access异常。
• std::get<index>(variant_obj)：如果variant_obj当前持有索引为index的类型值，则返回其引用。否则，抛出std::bad_variant_access异常。

注意： 使用 std::get 之前，强烈建议使用 holds_alternative 或 index 进行检查，以避免运行时异常。

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

struct Cat { std::string name; void meow() const { std::cout << name << " says Meow!" << std::endl; } };
struct Dog { std::string name; void bark() const { std::cout << name << " says Woof!" << std::endl; } };
struct Fish { std::string name; std::string species; void swim() const { std::cout << name << " (a " << species << " fish) is swimming." << std::endl; } };

using Pet = std::variant<Cat, Dog, Fish>;

void interact_with_pet(Pet& pet) {
    if (std::holds_alternative<Cat>(pet)) {
        std::get<Cat>(pet).meow();
        std::get<0>(pet).name = "Garfield"; // 也可以通过索引修改
    } else if (std::holds_alternative<Dog>(pet)) {
        std::get<Dog>(pet).bark();
    } else if (std::holds_alternative<Fish>(pet)) {
        std::get<Fish>(pet).swim();
    } else {
        // 理论上不会发生，除非 variant 处于 valueless_by_exception 状态
        std::cerr << "Pet is in an unexpected state." << std::endl;
    }
}

int main() {
    Pet my_cat{Cat{"Whiskers"}};
    Pet my_dog{Dog{"Buddy"}};
    Pet my_fish{Fish{"Nemo", "Clownfish"}};

    interact_with_pet(my_cat);
    interact_with_pet(my_dog);
    interact_with_pet(my_fish);

    // 尝试错误访问会抛出异常
    try {
        std::get<Dog>(my_cat).bark(); // my_cat 此时是 Cat，不是 Dog
    } catch (const std::bad_variant_access& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }

    interact_with_pet(my_cat); // 再次访问，验证名字已修改

    return 0;
}

c. std::get_if<T>() 和 std::get_if<index>()

std::get_if 是一个更安全的访问方式，它返回一个指针而不是引用。如果variant当前不持有请求的类型，它返回nullptr。这避免了异常，更适合于需要分支处理的场景。

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

struct Cat { std::string name; void meow() const { std::cout << name << " says Meow!" << std::endl; } };
struct Dog { std::string name; void bark() const { std::cout << name << " says Woof!" << std::endl; } };
struct Fish { std::string name; std::string species; void swim() const { std::cout << name << " (a " << species << " fish) is swimming." << std::endl; } };

using Pet = std::variant<Cat, Dog, Fish>;

void safe_interact_with_pet(Pet& pet) {
    if (Cat* cat_ptr = std::get_if<Cat>(&pet)) { // 注意这里需要传入 variant 的地址
        cat_ptr->meow();
    } else if (Dog* dog_ptr = std::get_if<Dog>(&pet)) {
        dog_ptr->bark();
    } else if (Fish* fish_ptr = std::get_if<Fish>(&pet)) {
        fish_ptr->swim();
    } else {
        std::cerr << "Pet is in an unexpected (or valueless) state." << std::endl;
    }
}

int main() {
    Pet my_cat{Cat{"Whiskers"}};
    Pet my_dog{Dog{"Buddy"}};
    Pet my_fish{Fish{"Nemo", "Clownfish"}};

    safe_interact_with_pet(my_cat);
    safe_interact_with_pet(my_dog);
    safe_interact_with_pet(my_fish);

    Pet unknown_pet; // 默认构造 Cat{" "}
    safe_interact_with_pet(unknown_pet);

    return 0;
}

3. std::visit：处理std::variant内容的强大机制

当我们需要对std::variant中可能存储的每种类型执行不同的操作时，if/else if结合std::get_if会变得冗长。std::visit提供了一种更优雅、更函数式的方法来处理variant的所有可能状态。

std::visit接受一个访问器（Visitor）对象和一个或多个std::variant对象。访问器是一个可调用对象（函数、lambda、函数对象），它必须对std::variant中所有可能的类型都提供一个重载的operator()。std::visit会根据variant当前持有的类型，自动调用访问器中匹配的operator()。

a. 使用Lambda表达式作为访问器

这是最常见和简洁的方式，尤其是在C++11及更高版本中。

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

struct Cat { std::string name; void meow() const { std::cout << name << " says Meow!" << std::endl; } };
struct Dog { std::string name; void bark() const { std::cout << name << " says Woof!" << std::endl; } };
struct Fish { std::string name; std::string species; void swim() const { std::cout << name << " (a " << species << " fish) is swimming." << std::endl; } };

using Pet = std::variant<Cat, Dog, Fish>;

// 辅助函数，用于创建重载的 lambda
// 这是一个 C++17 特性，用于简化重载 lambda 的创建
template<class... Ts> struct Overload : Ts... { using Ts::operator()...; };
template<class... Ts> Overload(Ts...) -> Overload<Ts...>;

int main() {
    Pet my_pet = Cat{"Whiskers"};

    // 使用 std::visit 和 lambda 表达式
    std::visit(Overload {
        [](Cat& c) { c.meow(); c.name += " (visited)"; },
        [](Dog& d) { d.bark(); d.name += " (visited)"; },
        [](Fish& f) { f.swim(); f.name += " (visited)"; }
    }, my_pet); // 传入 variant 对象

    std::visit(Overload {
        [](const Cat& c) { std::cout << "After visit, Cat: " << c.name << std::endl; },
        [](const Dog& d) { std::cout << "After visit, Dog: " << d.name << std::endl; },
        [](const Fish& f) { std::cout << "After visit, Fish: " << f.name << std::endl; }
    }, my_pet);

    my_pet = Dog{"Buddy"};
    std::visit(Overload {
        [](Cat& c) { c.meow(); },
        [](Dog& d) { d.bark(); },
        [](Fish& f) { f.swim(); }
    }, my_pet);

    return 0;
}

Overload辅助结构体（或称为“万能lambda包装器”）是C++17中一个非常实用的模式，它允许你将多个lambda表达式组合成一个具有重载operator()的单一函数对象。这样，std::visit就能根据variant的实际类型调用正确的lambda。

b. 使用函数对象（Visitor Struct）作为访问器

这种方式更传统，也更适用于访问器有状态或逻辑复杂的情况。

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

struct Cat { std::string name; void meow() const { std::cout << name << " says Meow!" << std::endl; } };
struct Dog { std::string name; void bark() const { std::cout << name << " says Woof!" << std::endl; } };
struct Fish { std::string name; std::string species; void swim() const { std::cout << name << " (a " << species << " fish) is swimming." << std::endl; } };

using Pet = std::variant<Cat, Dog, Fish>;

// 定义一个 Visitor struct
struct PetActionVisitor {
    void operator()(Cat& c) const {
        c.meow();
        std::cout << "Cat " << c.name << " says hi!" << std::endl;
    }
    void operator()(Dog& d) const {
        d.bark();
        std::cout << "Dog " << d.name << " is happy!" << std::endl;
    }
    void operator()(Fish& f) const {
        f.swim();
        std::cout << "Fish " << f.name << " is chilling." << std::endl;
    }
    // 处理 valueless_by_exception 状态（可选，但推荐）
    void operator()(std::monostate) const {
        std::cout << "Pet is in an empty/valueless state." << std::endl;
    }
};

int main() {
    Pet my_pet = Cat{"Whiskers"};
    std::visit(PetActionVisitor{}, my_pet);

    my_pet = Dog{"Buddy"};
    std::visit(PetActionVisitor{}, my_pet);

    my_pet = Fish{"Nemo", "Clownfish"};
    std::visit(PetActionVisitor{}, my_pet);

    // 假设某种异常导致 variant 变为空 (valueless_by_exception)
    // std::variant<int, std::string> v;
    // try {
    //     // 模拟一个导致 valueless_by_exception 的操作
    //     // 例如，将一个 large_string 赋值给一个 small_string variant，
    //     // 但在复制过程中，small_string 的内存耗尽并抛出异常
    //     // 在实际情况中，这通常与移动语义和异常安全有关
    // } catch (...) {
    //     // v 可能会进入 valueless_by_exception 状态
    // }
    // if (v.valueless_by_exception()) {
    //     std::visit(PetActionVisitor{}, v); // 如果 visitor 包含了 std::monostate 重载
    // }

    return 0;
}

std::visit 的返回值：
std::visit 的返回值是它调用的访问器操作符的返回值。如果所有重载的operator()返回类型不一致，那么std::visit的返回类型将是这些返回类型的std::common_type。如果无法找到共同类型，则会编译失败。

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

struct Cat { std::string name; };
struct Dog { std::string name; };
struct Fish { std::string name; std::string species; };

using Pet = std::variant<Cat, Dog, Fish>;

struct PetNameGetter {
    std::string operator()(const Cat& c) const { return "Cat: " + c.name; }
    std::string operator()(const Dog& d) const { return "Dog: " + d.name; }
    std::string operator()(const Fish& f) const { return "Fish: " + f.name + " (" + f.species + ")"; }
};

int main() {
    Pet my_cat = Cat{"Whiskers"};
    Pet my_dog = Dog{"Buddy"};
    Pet my_fish = Fish{"Nemo", "Clownfish"};

    std::string cat_info = std::visit(PetNameGetter{}, my_cat);
    std::string dog_info = std::visit(PetNameGetter{}, my_dog);
    std::string fish_info = std::visit(PetNameGetter{}, my_fish);

    std::cout << cat_info << std::endl;
    std::cout << dog_info << std::endl;
    std::cout << fish_info << std::endl;

    return 0;
}

c. std::visit与多个std::variant

std::visit 可以同时处理多个std::variant对象。在这种情况下，它会为每个variant持有的类型调用一次访问器，形成一个笛卡尔积。访问器需要为所有可能的类型组合提供重载。

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

struct Add {};
struct Subtract {};
struct Multiply {};
struct Divide {};

using Operation = std::variant<Add, Subtract, Multiply, Divide>;
using Value = std::variant<int, double>;

// 访问器，处理 Value 和 Operation 的所有组合
struct CalculatorVisitor {
    double operator()(int val, const Add&) const { return static_cast<double>(val) + 1.0; }
    double operator()(double val, const Add&) const { return val + 1.0; }

    double operator()(int val, const Subtract&) const { return static_cast<double>(val) - 1.0; }
    double operator()(double val, const Subtract&) const { return val - 1.0; }

    double operator()(int val, const Multiply&) const { return static_cast<double>(val) * 2.0; }
    double operator()(double val, const Multiply&) const { return val * 2.0; }

    double operator()(int val, const Divide&) const { return static_cast<double>(val) / 2.0; }
    double operator()(double val, const Divide&) const { return val / 2.0; }
};

int main() {
    Value v1 = 10;
    Value v2 = 20.5;

    Operation op1 = Add{};
    Operation op2 = Multiply{};

    std::cout << "v1 (" << std::visit([](auto&& arg){ return std::to_string(arg); }, v1) << ") with op1: "
              << std::visit(CalculatorVisitor{}, v1, op1) << std::endl; // 10 + 1.0 = 11.0

    std::cout << "v2 (" << std::visit([](auto&& arg){ return std::to_string(arg); }, v2) << ") with op2: "
              << std::visit(CalculatorVisitor{}, v2, op2) << std::endl; // 20.5 * 2.0 = 41.0

    std::cout << "v1 (" << std::visit([](auto&& arg){ return std::to_string(arg); }, v1) << ") with op2: "
              << std::visit(CalculatorVisitor{}, v1, op2) << std::endl; // 10 * 2.0 = 20.0

    return 0;
}

4. 特殊状态和辅助类型

a. std::monostate

std::monostate是一个空类型，不占用任何存储空间（或仅占用一个字节，取决于实现）。它的主要用途是作为std::variant的第一个类型，以便std::variant可以被默认构造，表示一种“空”或“未初始化”状态，而无需默认构造其他可能较重的类型。

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

struct HeavyObject {
    std::string data;
    HeavyObject() { std::cout << "HeavyObject default constructed!" << std::endl; data = "Default"; }
    HeavyObject(std::string s) : data(std::move(s)) { std::cout << "HeavyObject constructed with data: " << data << std::endl; }
    ~HeavyObject() { std::cout << "HeavyObject destructed!" << std::endl; }
};

// 如果不使用 std::monostate，默认构造 SomeVariant 会构造 HeavyObject
// std::variant<HeavyObject, int> v1; // 打印 "HeavyObject default constructed!"

// 使用 std::monostate，默认构造 variant 不会构造 HeavyObject
std::variant<std::monostate, HeavyObject, int> v2; // 默认构造 std::monostate

int main() {
    std::cout << "v2 index: " << v2.index() << std::endl; // 0 (std::monostate)

    v2 = HeavyObject{"Initial data"}; // 构造 HeavyObject
    std::cout << "v2 index: " << v2.index() << std::endl; // 1 (HeavyObject)

    v2 = 42; // 构造 int，销毁 HeavyObject
    std::cout << "v2 index: " << v2.index() << std::endl; // 2 (int)

    return 0;
}

b. valueless_by_exception()

当std::variant在构造或赋值过程中抛出异常时，它可能会进入valueless_by_exception状态。在这种状态下，std::variant不持有任何值，index()会返回std::variant_npos。

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

struct ThrowingType {
    ThrowingType(int val) {
        if (val == 0) throw std::runtime_error("Cannot construct with 0!");
        std::cout << "ThrowingType constructed with " << val << std::endl;
    }
    ~ThrowingType() { std::cout << "ThrowingType destructed." << std::endl; }
};

int main() {
    std::variant<int, ThrowingType> v; // 默认构造 int

    try {
        v = ThrowingType(10); // 成功赋值
        std::cout << "v holds ThrowingType with index: " << v.index() << std::endl;
        v = ThrowingType(0); // 赋值失败，抛出异常
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }

    // 检查 v 是否处于 valueless_by_exception 状态
    if (v.valueless_by_exception()) {
        std::cout << "Variant is valueless by exception." << std::endl;
        std::cout << "Variant index: " << v.index() << std::endl; // std::variant_npos
    } else {
        std::cout << "Variant is not valueless, current index: " << v.index() << std::endl;
    }

    return 0;
}

5. 递归std::variant

有时候，我们需要定义一个可以包含自身的std::variant类型，例如在表示抽象语法树（AST）或链表节点时。直接声明会导致无限递归，因为std::variant需要知道所有类型的大小才能分配足够的内存。

// 错误：直接递归定义会编译失败
// struct Node;
// using Expr = std::variant<int, std::string, Node>;
// struct Node { Expr left; Expr right; };

为了解决这个问题，我们需要使用一个间接层，通常是std::unique_ptr或std::recursive_wrapper（在Boost中很常见，但C++标准库没有直接提供std::recursive_wrapper，需要我们自己实现或使用智能指针）。这里我们使用std::unique_ptr：

#include <iostream>
#include <string>
#include <variant>
#include <memory> // For std::unique_ptr

// 假设我们正在构建一个简单的算术表达式树
// 节点可以是整数、变量名，或者是一个二元操作
struct AddExpr;
struct SubtractExpr;
struct MultiplyExpr;
struct DivideExpr;

// 使用 std::unique_ptr 作为间接层
using Expression = std::variant<
    int,
    std::string, // 变量名
    std::unique_ptr<AddExpr>,
    std::unique_ptr<SubtractExpr>,
    std::unique_ptr<MultiplyExpr>,
    std::unique_ptr<DivideExpr>
>;

struct AddExpr { Expression left, right; };
struct SubtractExpr { Expression left, right; };
struct MultiplyExpr { Expression left, right; };
struct DivideExpr { Expression left, right; };

// 表达式求值访问器
struct Evaluator {
    int operator()(int val) const { return val; }
    int operator()(const std::string& var_name) const {
        // 简单模拟变量查找
        if (var_name == "x") return 10;
        if (var_name == "y") return 5;
        return 0; // 未知变量
    }
    int operator()(const std::unique_ptr<AddExpr>& expr) const {
        return std::visit(*this, expr->left) + std::visit(*this, expr->right);
    }
    int operator()(const std::unique_ptr<SubtractExpr>& expr) const {
        return std::visit(*this, expr->left) - std::visit(*this, expr->right);
    }
    int operator()(const std::unique_ptr<MultiplyExpr>& expr) const {
        return std::visit(*this, expr->left) * std::visit(*this, expr->right);
    }
    int operator()(const std::unique_ptr<DivideExpr>& expr) const {
        int right_val = std::visit(*this, expr->right);
        if (right_val == 0) throw std::runtime_error("Division by zero!");
        return std::visit(*this, expr->left) / right_val;
    }
};

int main() {
    // 构建表达式：(10 + x) * y
    Expression expr = std::make_unique<MultiplyExpr>(MultiplyExpr{
        std::make_unique<AddExpr>(AddExpr{
            10,
            std::string("x")
        }),
        std::string("y")
    });

    int result = std::visit(Evaluator{}, expr);
    std::cout << "Result of (10 + x) * y where x=10, y=5 is: " << result << std::endl; // (10+10)*5 = 100

    // 另一个表达式：(y - 5) / x
    Expression expr2 = std::make_unique<DivideExpr>(DivideExpr{
        std::make_unique<SubtractExpr>(SubtractExpr{
            std::string("y"),
            5
        }),
        std::string("x")
    });

    try {
        int result2 = std::visit(Evaluator{}, expr2);
        std::cout << "Result of (y - 5) / x where x=10, y=5 is: " << result2 << std::endl; // (5-5)/10 = 0
    } catch (const std::runtime_error& e) {
        std::cerr << "Error evaluating expr2: " << e.what() << std::endl;
    }

    return 0;
}

三、std::variant与其他C++特性的对比

为了更好地理解std::variant的定位和优势，我们将其与前面提到的一些替代方案进行更深入的比较：

特性	std::variant	std::any	多态 (基类指针)	C风格union	void*
类型安全性	编译时安全，只能存储预定义类型，无法存错类型。	运行时安全，可存储任意类型，但any_cast可能失败。	运行时安全，通过虚函数和dynamic_cast实现。	不安全，需手动管理类型标签，易出错。	不安全，完全无类型信息，极易出错。
类型列表	固定，在编译时已知。	动态，可在运行时存储任何类型。	开放，通过继承可扩展新的派生类。	固定，但受限于POD类型限制（C++11前）。	不限，但无类型信息。
内存分配	通常在栈上分配（除非内部类型过大），零开销抽象。	通常在堆上分配（类型擦除），有额外开销。	通常在堆上分配（管理多态对象），有额外开销。	通常在栈上分配，零开销。	通常处理堆上对象的指针，需手动管理。
值语义	支持，像普通变量一样拷贝、赋值。	支持，可拷贝、赋值，但有性能开销。	通常处理引用/指针语义，值语义需额外包装。	部分支持，仅限POD类型，非POD需手动管理。	仅处理指针，不直接支持值语义。
访问方式	std::get, std::get_if, std::visit	std::any_cast	虚函数，dynamic_cast	手动union.member和enum标签。	static_cast
空状态	std::monostate，valueless_by_exception()	has_value()	nullptr指针检查。	无标准空状态，需自定义。	nullptr指针检查。
使用场景	“多选一”的固定类型集合，需要编译时安全。	“多选一”的开放类型集合，无需编译时类型检查，但有开销。	运行时多态行为，共享接口，类型体系。	性能敏感，且处理纯数据类型的场景（慎用）。	极低层次，与C兼容，或作为通用句柄（慎用）。

std::variant 与 std::optional

这两个都是C++17引入的类型，容易混淆，但它们解决的问题不同：

• std::optional<T>：表示一个可能存在零个或一个T类型值的容器。它的语义是“T，或者没有T”。
• std::variant<T1, T2, ..., Tn>：表示一个可能存在一个且只有一个T1或T2或…Tn类型值的容器。它的语义是“T1或T2或…Tn”。

实际上，std::optional<T> 可以被视为 std::variant<std::monostate, T> 的特化版本（尽管实现不完全相同）。

四、std::variant 的最佳实践与注意事项

1. 优先使用std::visit： 它是处理std::variant内容最安全、最灵活、最C++惯用的方式。避免过度使用std::get，除非你100%确定variant当前持有的类型，或者已经通过holds_alternative进行了检查。

2. 避免在variant中放置过多类型： 类型越多，std::visit的访问器就需要越多的重载，代码可能变得复杂。如果类型数量非常庞大且不固定，std::any或多态可能更合适。

3. 考虑std::monostate： 如果你的variant需要一个“空”或“未初始化”的状态，并且不希望默认构造第一个实际类型，std::monostate是很好的选择。

4. 异常安全： 了解valueless_by_exception状态。如果variant中的类型构造或赋值可能抛出异常，最好在访问器中处理这种状态，或者确保你的代码能够优雅地处理它。

5. 性能： std::variant通常是零开销抽象，其内存占用是其所有模板参数中最大类型的大小，加上一个用于存储当前类型索引的额外字节。它通常在栈上分配，避免了堆分配的开销和缓存局部性问题，且没有虚函数表的运行时查找开销。

6. std::variant 的相等性/比较： std::variant支持各种比较运算符（==, !=, <, >, <=, >=）。比较规则如下：

   • 如果index()不同，则index()较小的variant被认为是“较小”的。
   • 如果index()相同，则比较其内部存储的值。如果内部类型没有定义比较运算符，则会编译失败。
   • 如果一个variant是valueless_by_exception，它比任何非valueless_by_exception的variant都小。

   #include <iostream>
   #include <variant>
   
   int main() {
       std::variant<int, std::string> v1 = 10;
       std::variant<int, std::string> v2 = "hello";
       std::variant<int, std::string> v3 = 10;
       std::variant<int, std::string> v4 = 20;
   
       std::cout << "v1.index(): " << v1.index() << std::endl; // 0
       std::cout << "v2.index(): " << v2.index() << std::endl; // 1
   
       std::cout << "v1 == v3: " << (v1 == v3) << std::endl; // true (index 0, value 10 == 10)
       std::cout << "v1 == v2: " << (v1 == v2) << std::endl; // false (index 0 != 1)
       std::cout << "v1 < v2: " << (v1 < v2) << std::endl;   // true (index 0 < 1)
       std::cout << "v1 < v4: " << (v1 < v4) << std::endl;   // true (index 0, value 10 < 20)
       return 0;
   }

7. 哈希支持： std::hash<std::variant> 默认是可用的，只要variant中的所有替代类型都支持 std::hash。

五、总结与展望

std::variant是现代C++中一个极其重要的工具，它以编译时类型安全、零开销抽象和值语义的优势，完美解决了“多选一”的数据表示问题。它强制你在编译时考虑所有可能的类型，并通过std::visit提供了一种优雅、全面的处理机制，避免了运行时错误和繁琐的if/else if链。

通过今天的讲座，我们不仅理解了std::variant的基本用法和高级特性，还将其与传统解决方案进行了对比，明确了它的适用场景和优势。掌握std::variant，将使你的C++代码更加健壮、高效和富有表现力，真正体现现代C++的精髓。