What is the difference between std::variant and std::optional?

Both std::variant and std::optional are tools for representing values that may or may not be present, but they serve different purposes.

std::optional is used to represent a value that may or may not exist. It's essentially a type-safe alternative to using a pointer to indicate the presence or absence of a value. An std::optional<T> can either hold a value of type T, or it can hold no value at all.

Here's an example:

1#include <optional>
2#include <iostream>
3
4int main() {
5  std::optional<int> maybeInt = 42;
6  if (maybeInt.has_value()) {
7    std::cout << "Value: " << *maybeInt << '\n';
8  } else {
9    std::cout << "No value\n";
10  }
11
12  maybeInt = std::nullopt;
13  if (maybeInt.has_value()) {
14    std::cout << "Value: " << *maybeInt << '\n';
15  } else {
16    std::cout << "No value\n";
17  }
18}

On the other hand, std::variant is used to represent a value that can be one of several possible types. It's a type-safe union. A std::variant<T1, T2, ...> holds a value that is one of the types T1, T2, etc.

Here's an example:

1#include <variant>
2#include <iostream>
3
4using std::variant, std::holds_alternative,
5  std::string, std::get, std::cout;
6
7int main() {
8  variant<int, string> v = 42;
9  if (holds_alternative<int>(v)) {
10    cout << "Int: " << get<int>(v) << '\n';
11  } else if (holds_alternative<string>(v)) {
12    cout << "String: " << get<string>(v) << '\n';
13  }
14
15  v = "hello";
16  if (holds_alternative<int>(v)) {
17    cout << "Int: " << get<int>(v) << '\n';
18  } else if (holds_alternative<string>(v)) {
19    cout << "String: " << get<string>(v) << '\n';
20  }
21}

1Int: 42
2String: hello

So, the main difference is that std::optional is used when you have a single type that may or may not have a value, while std::variant is used when you have multiple possible types and the value is always one of those types.

Choose std::optional when you have a value that may not exist, like the return value of a function that may not succeed, or a field in a struct that is not always filled in.

Choose std::variant when you need to store a value that can be one of several different types, like a JSON value that could be a string, a number, a boolean, etc.

Of course, you can combine them: you can have a std::optional<std::variant<...>> if you have a value that may or may not exist, and if it does exist, it could be one of several types.