如何与C中的STD ::变体一起工作

std::variant 是 C 17 引入的类型安全联合体，能安全地持有多个指定类型之一的值，通过 std::get、std::holds_alternative、std::visit 和 std::get_if 等方法实现安全访问与类型检查，结合 std::monostate 可模拟可选值，推荐使用 std::visit 进行类型分发并避免大型类型列表以提升可维护性，最终确保类型安全和异常安全。

Working with std::variant in C involves safely handling a type-safe union that can hold one of several specified types at a time. It was introduced in C 17 as a modern, safer alternative to raw unions. Here's how to use it effectively.

Understanding std::variant Basics

std::variant is a template that can store one value from a fixed list of types. Only one type is active at a time, and the variant keeps track of which one.

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

std::variant<int, std::string, double> v;
v = 42;           // v holds an int
v = "hello";      // v holds a std::string

By default, the variant is initialized with the first type in the list (if it's default-constructible). In the example above, v starts as an int(0).

You can also explicitly construct it:

std::variant<int, std::string> v = std::string("hello");

Accessing Values Safely

Never assume which type is stored. Use proper methods to check or retrieve values.

Use std::get<T> or std::get<I>

You can retrieve the value if you know the type or index:

std::get<int>(v);        // if v holds int
std::get<0>(v);          // same, by index

But if the type doesn't match, it throws std::bad_variant_access. So always check first.

Check Active Type with std::holds_alternative

if (std::holds_alternative<int>(v)) {
    std::cout << "int: " << std::get<int>(v);
} else if (std::holds_alternative<std::string>(v)) {
    std::cout << "string: " << std::get<std::string>(v);
}

This is safe and clear for simple cases.

Using std::visit for Type-Safe Dispatch

The most powerful way to work with std::variant is std::visit, which applies a callable to the active value.

std::visit([](auto&& arg) {
    using T = std::decay_t<decltype(arg)>;
    if constexpr (std::is_same_v<T, int>) {
        std::cout << "int: " << arg;
    } else if constexpr (std::is_same_v<T, std::string>) {
        std::cout << "string: " << arg;
    } else if constexpr (std::is_same_v<T, double>) {
        std::cout << "double: " << arg;
    }
}, v);

This is clean and avoids runtime type checks when possible (thanks to if constexpr).

You can also define a visitor struct:

struct Printer {
    void operator()(int i) const { std::cout << "int: " << i; }
    void operator()(const std::string& s) const { std::cout << "string: " << s; }
    void operator()(double d) const { std::cout << "double: " << d; }
};

std::visit(Printer{}, v);

This works because the visitor must be callable for every possible alternative in the variant.

Handling Errors and Edge Cases

• Assignment: Assigning a new value changes the active type automatically.
• No value? Unlike std::optional, std::variant always holds a value (of one of the types).
• Exception safety: Construction and assignment may throw if the target type's operations throw.
• Empty variant? There’s no “empty” state unless you include std::monostate for emulating optional behavior in a variant.

Example with std::monostate:

std::variant<std::monostate, int, std::string> maybe_value;
// Initially holds std::monostate → "empty"

Tips and Best Practices

• Keep variant types small and related logically (e.g., AST node types, message variants).
• Prefer std::visit over repeated holds_alternative checks when doing complex logic.
• Avoid very large variant lists — they become hard to maintain and may impact performance.
• Make sure all visitor overloads are defined; otherwise, compilation fails.
• Use std::get_if<T>(&v) to get a pointer to the value if it’s the right type — useful for checking without exceptions:

if (auto* p = std::get_if<int>(&v)) {
    std::cout << "Got int: " << *p;
}

This is especially useful in performance-critical code where exceptions are avoided.

Basically, std::variant works best when combined with std::visit and proper type-safe access patterns. It's a key tool for modern C when you need sum types or type-safe unions.

以上是如何与C中的STD ::变体一起工作的详细内容。更多信息请关注PHP中文网其他相关文章！