optional, variant and any (C++17)

C++17 added three vocabulary types that let you express common shapes of data precisely: std::optional<T> for a value that might be absent, std::variant<...> for a value that is one of several known types, and std::any for a single value of a type decided at runtime. By the end you'll know which one fits each problem — and why variant usually beats any .

Learn optional, variant and any (C++17) in our free C++ course — an interactive lesson with worked examples, a practice exercise and a quick reference.

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Picture a small parcel locker. std::optional is a single box that is either empty or holds one item — you check before reaching in. std::variant is a box with a labelled slot list : it can hold a coin, a letter, or a key, but only one at a time, and the label always tells you which, so you never grab the wrong thing. std::any is a magic box that swallows anything at all — flexible, but you must remember exactly what you put in to get it back out, and guessing wrong throws it on the floor. Most of the time you know the shortlist of things you store, so the labelled box ( variant ) is the right tool.

1. std::optional — Maybe a Value

A function that might not have an answer used to return a sentinel ( -1 , an empty string) or take an out-parameter. std::optional<T> says it directly: the result is either engaged (holds a T ) or disengaged (empty, written std::nullopt ). Test it with has_value() or the implicit bool conversion, read it with * or -> , and supply a fallback with value_or() . Beware: calling .value() on an empty optional throws std::bad_optional_access .

Your turn. The division below can fail when the divisor is zero. Fill in the blank to print a fallback of -1 using value_or :

2. std::variant — One of Several Known Types

A std::variant<A, B, C> is a type-safe union : it holds a value of exactly one of its alternatives at any moment, and it always remembers which (its index() ). Unlike a raw union , it tracks the active type for you and refuses unsafe access. Ask holds_alternative<T>(v) which type is active, read it with get<T>(v) (which throws std::bad_variant_access on a mismatch) or probe safely with get_if<T>(&v) (which returns a pointer, or nullptr ).

When you need to act on whatever the variant holds, reach for std::visit . It applies a callable to the active alternative and, crucially, won't compile unless you handle every type — so adding an alternative later forces you to update the code. The common idiom bundles one lambda per type into an overloaded set:

A variant is default-constructed to its first alternative, which must therefore be default-constructible. When your real types aren't — or when you want an explicit "nothing chosen yet" state — list std::monostate first:

These lines should make a variant, switch it to a string, and safely print it. Put them in the right order:

Open main (D), create the variant holding an int (B), reassign it to a string (A), then probe with get_if and print (C), then return 0; (E) and close the brace (F).

3. std::any — A Single Value of Any Type

std::any stores a single value whose type is chosen at runtime . It is the most flexible of the three and the least checked: you must recover the exact type with std::any_cast<T> , and a wrong guess throws std::bad_any_cast (the pointer form returns nullptr instead). Because it type-erases and may allocate, any is slower and offers no compile-time safety — so prefer variant whenever the candidate types are known, and keep any for genuinely open-ended storage like a heterogeneous property bag.

optional answers "is there a value?" — one type, present or absent. variant answers "which of these types is it?" — a closed, compile-time-known set. any answers "some value, type decided later" — an open set, checked only at runtime. Reach down this list in order: most problems are an optional or a variant ; any is the rare last resort.

A handy combination is std::optional<std::variant<...>> : a result that might be absent, and when present is one of several types. And note that std::variant never heap-allocates for its alternatives, while std::any may — another reason to prefer variant on hot paths.

Predict the result before revealing the answer.

-1 — the optional is empty, so value_or returns the fallback.

It throws std::bad_variant_access — the active alternative is a string, not an int. Use get_if to probe safely.

3. Why list std::monostate first in a variant?

So the variant has a valid default-constructible first alternative and a clear "nothing chosen yet" state, even when the real type isn't default-constructible.

Model a JSON-like value with a variant (using monostate for null), then print it with std::visit and an overloaded set of lambdas — one per alternative.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary