C++17中的std::variant：使用案例与实战

作者

std::variant是C++17引入的一种强类型联合体，旨在替代传统的std::any和手写的联合体。它不仅提供了类型安全，还具备良好的可读性和可维护性。本文将从基础概念、常用成员函数、异常安全以及典型场景三方面，对std::variant进行系统讲解，并给出完整的代码示例。

1. 基本概念

std::variant是一个模板类，接受若干种类型作为参数： 

std::variant<T1, T2, T3> v;

v的值只能是T1、T2或T3中的一种。其底层实现类似于std::tuple+std::aligned_union，内部维护了一个“索引”字段来标记当前存储的是哪一种类型。

核心特点

  • 类型安全：在编译期就能判断合法的类型。
  • 显式访问：使用`std::get (v)`或`std::get(v)`访问，若索引不匹配会抛出`std::bad_variant_access`。
  • 访问器：std::visit提供多态访问，能在一次遍历中处理所有类型。

2. 常用成员函数

函数 说明 示例
index() 返回当前存放的类型索引，从0开始 v.index()
valueless_by_exception() 若异常导致variant无效返回true v.valueless_by_exception()
`std::get
(v)| 获取存储的T值 |int i = std::get(v);`
`std::get
(v)| 通过索引获取 |int i = std::get(v);`
std::visit(f, v) 对variant进行访问 std::visit([](auto&& x){ std::cout << x; }, v);

3. 典型使用场景

3.1 JSON值表示

JSON的值可以是字符串、数字、布尔、数组、对象、null。使用std::variant可直接映射： 

using JsonValue = std::variant<
    std::nullptr_t,
    bool,
    double,
    std::string,
    std::vector<std::shared_ptr<JsonValue>>,
    std::unordered_map<std::string, std::shared_ptr<JsonValue>>
>;

通过std::visit即可递归遍历和序列化。

3.2 命令行参数解析

参数可以是整数、字符串或布尔标志： 

std::variant<int, std::string, bool> option;

在解析过程中，用std::get<>()根据类型处理对应逻辑。

3.3 GUI事件处理

不同事件（鼠标点击、键盘输入、窗口调整）可以用variant统一存储： 

using Event = std::variant<
    MouseEvent,
    KeyboardEvent,
    ResizeEvent
>;

std::visit可以在事件循环中按类型分发。

4. 异常安全与移动语义

  • 移动构造：variant的移动构造在C++17里已实现为异常安全。
  • 拷贝/移动时的异常：若拷贝或移动时抛出异常，variant将进入“valueless”状态。使用valueless_by_exception()检查。
  • 如何恢复：可以通过variant的移动或重新赋值来恢复。

5. 性能对比

与std::any相比：

  • 大小：variant在典型实现中比any略小（因为any需要额外的类型信息）。
  • 访问速度：variant的访问通过索引直接定位，比any的动态类型识别更快。

与手写联合体+枚举相比：

  • 类型安全：variant在编译期检查类型，避免手写时的错误。
  • 可维护性：不需要手动管理构造/析构，减少内存泄漏风险。

6. 完整示例：实现一个简单的配置文件解析器

#include <iostream>
#include <variant>
#include <string>
#include <unordered_map>
#include <vector>
#include <fstream>
#include <sstream>
#include <cctype>
#include <stdexcept>

// 1. 定义配置值类型
using ConfigValue = std::variant<
    std::nullptr_t,
    bool,
    int,
    double,
    std::string,
    std::unordered_map<std::string, std::shared_ptr<ConfigValue>>
>;

// 2. 解析器核心函数
class ConfigParser {
public:
    std::unordered_map<std::string, std::shared_ptr<ConfigValue>> parse(const std::string& content) {
        std::istringstream ss(content);
        return parseObject(ss);
    }
private:
    std::unordered_map<std::string, std::shared_ptr<ConfigValue>> parseObject(std::istringstream& ss) {
        std::unordered_map<std::string, std::shared_ptr<ConfigValue>> obj;
        std::string token;
        while (ss >> token) {
            if (token == "}") break;
            if (token.back() != ':') throw std::runtime_error("Expected ':'");
            std::string key = token.substr(0, token.size()-1);
            auto val = parseValue(ss);
            obj[key] = std::make_shared <ConfigValue>(std::move(val));
        }
        return obj;
    }

    ConfigValue parseValue(std::istringstream& ss) {
        std::string token;
        ss >> token;
        if (token == "null") return nullptr;
        if (token == "true") return true;
        if (token == "false") return false;
        if (token.front() == '"' && token.back() == '"') {
            token = token.substr(1, token.size()-2);
            return token;
        }
        if (token.front() == '{') {
            return parseObject(ss);
        }
        // try number
        std::istringstream numss(token);
        double d;
        if (numss >> d && numss.eof()) {
            if (d == static_cast <int>(d)) return static_cast<int>(d);
            return d;
        }
        throw std::runtime_error("Unknown token: " + token);
    }
};

// 3. 打印辅助函数
void printValue(const ConfigValue& val, int indent = 0) {
    const std::string prefix(indent, ' ');
    std::visit([&](auto&& arg){
        using T = std::decay_t<decltype(arg)>;
        if constexpr (std::is_same_v<T, std::nullptr_t>) {
            std::cout << "null\n";
        } else if constexpr (std::is_same_v<T, bool>) {
            std::cout << (arg ? "true" : "false") << "\n";
        } else if constexpr (std::is_same_v<T, int>) {
            std::cout << arg << "\n";
        } else if constexpr (std::is_same_v<T, double>) {
            std::cout << arg << "\n";
        } else if constexpr (std::is_same_v<T, std::string>) {
            std::cout << "\"" << arg << "\"\n";
        } else if constexpr (std::is_same_v<T, std::unordered_map<std::string, std::shared_ptr<ConfigValue>>>) {
            std::cout << "{\n";
            for (const auto& [k,v] : arg) {
                std::cout << prefix << "  \"" << k << "\": ";
                printValue(*v, indent + 2);
            }
            std::cout << prefix << "}\n";
        }
    }, val);
}

int main() {
    std::string cfg = R"(
    {
        name: "demo",
        version: 1,
        debug: true,
        threshold: 0.75,
        null_value: null,
        nested: {
            a: 10,
            b: false
        }
    }
    )";

    ConfigParser parser;
    auto data = parser.parse(cfg);
    for (const auto& [k,v] : data) {
        std::cout << k << " : ";
        printValue(*v, 2);
    }
    return 0;
}

运行结果 

name : "demo"
version : 1
debug : true
threshold : 0.75
null_value : null
nested : {
  "a": 10
  "b": false
}

7. 小结

  • std::variant提供了编译期类型安全与运行时灵活性的完美结合。
  • 通过std::visit可实现对多态数据的统一访问，极大简化代码逻辑。
  • 在需要多种可能值的场景（如配置解析、事件系统、JSON等）中，variant是首选工具。

希望本文能帮助你在C++项目中更好地利用std::variant，提升代码质量与可维护性。

发表评论