How to work with std::variant in C

std::variant is a type-safe union introduced by C 17. It can safely hold values of one of the specified types. It can realize secure access and type checking through methods such as std::get, std::holds_alternative, std::visit and std::get_if. Combined with std::monostate, optional values can be simulated. It is recommended to use std::visit for type distribution and avoid large type lists to improve maintainability, and ultimately ensure type safety and exception safety.

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 (eg, 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.

The above is the detailed content of How to work with std::variant in C. For more information, please follow other related articles on the PHP Chinese website!