std:: visit

将访问器 v （一个可调用对象，能够以 Variants 中类型的任意组合进行调用）应用于 Variants values 。

给定 VariantBases 为 decltype ( as-variant ( std:: forward < Variants > ( values ) ) ... （一个包含 sizeof... ( Variants ) 个类型的包）：

这些重载仅当 VariantBases 中的每个类型均为有效类型时才参与重载决议。若由 INVOKE 或 INVOKE<R> (C++20 起) 指代的表达式无效，或 INVOKE 或 INVOKE<R> (C++20 起) 的结果对于不同 indices 具有不同类型或值类别，则程序非良构。

参数

返回值

异常

若 as-variant ( value_i ) . valueless_by_exception ( ) 对 values 中的任何变体 value_i 为 true ，则抛出 std::bad_variant_access 。

复杂度

当变体数量为零或一时，可调用对象的调用以常数时间实现；即其执行时间不取决于变体所能存储的类型数量。

如果变体数量大于一，可调用对象的调用没有复杂度要求。

注释

设 n 为 ( 1 * ... * std:: variant_size_v < std:: remove_reference_t < VariantBases >> ) ，实现通常为每个 std::visit 的特化生成一个等价于（可能是多维）包含 n 个函数指针的数组的表，这种实现方式与 虚函数 的实现类似。

实现也可以为 std::visit 生成具有 n 个分支的 switch 语句 （例如，当 n 不大于 256 时，MSVC STL 实现会使用 switch 语句）。

在典型实现中，调用 v 的时间复杂度可视为等同于访问（可能为多维）数组元素或执行 switch 语句的时间复杂度。

示例

#include <iomanip>
#include <iostream>
#include <string>
#include <type_traits>
#include <variant>
#include <vector>
// 要访问的 variant
using value_t = std::variant<int, long, double, std::string>;
// 访问器 #4 的辅助类型
template<class... Ts>
struct overloaded : Ts... { using Ts::operator()...; };
// 显式推导指南（C++20 起不再需要）
template<class... Ts>
overloaded(Ts...) -> overloaded<Ts...>;
int main()
{
    std::vector<value_t> vec = {10, 15l, 1.5, "hello"};
    for (auto& v: vec)
    {
        // 1. void 访问器，仅用于副作用（此处用于 I/O）
        std::visit([](auto&& arg){ std::cout << arg; }, v);
        // 2. 返回值访问器，演示返回另一个 variant 的惯用法
        value_t w = std::visit([](auto&& arg) -> value_t { return arg + arg; }, v);
        // 3. 类型匹配访问器：为每种类型提供不同处理的 lambda
        std::cout << "。翻倍后，variant 持有 ";
        std::visit([](auto&& arg)
        {
            using T = std::decay_t<decltype(arg)>;
            if constexpr (std::is_same_v<T, int>)
                std::cout << "值为 " << arg << " 的 int\n";
            else if constexpr (std::is_same_v<T, long>)
                std::cout << "值为 " << arg << " 的 long\n";
            else if constexpr (std::is_same_v<T, double>)
                std::cout << "值为 " << arg << " 的 double\n";
            else if constexpr (std::is_same_v<T, std::string>)
                std::cout << "值为 " << std::quoted(arg) << " 的 std::string\n";
            else
                static_assert(false, "非穷举访问器！");
        }, w);
    }
    for (auto& v: vec)
    {
        // 4. 另一个类型匹配访问器：包含 3 个重载 operator() 的类
        // 注意：`(auto arg)` 模板 operator() 在此情况下将绑定到 `int` 和 `long`，
        //       但若缺少它，`(double arg)` operator() *也会* 绑定到 `int` 和 `long`，
        //       因为两者均可隐式转换为 double。使用此形式时，需注意隐式转换的正确处理。
        std::visit(overloaded{
            [](auto arg) { std::cout << arg << ' '; },
            [](double arg) { std::cout << std::fixed << arg << ' '; },
            [](const std::string& arg) { std::cout << std::quoted(arg) << ' '; }
        }, v);
    }
}

10。翻倍后，variant 持有值为 20 的 int
15。翻倍后，variant 持有值为 30 的 long
1.5。翻倍后，variant 持有值为 3 的 double
hello。翻倍后，variant 持有值为 "hellohello" 的 std::string
10 15 1.500000 "hello"

缺陷报告

下列行为变更缺陷报告被追溯应用于先前发布的 C++ 标准。

参见