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

Both std::variant and std::any are used for storing values of different types, but they serve different purposes and have different characteristics.

std::variant is a type-safe union. It can hold a value of one of a fixed set of types, which are specified at compile-time as template arguments. The key characteristics of std::variant are:

1. Type safety: You can only access the value in a variant through a visitor or by explicitly specifying the expected type. This prevents accessing data as the wrong type.
2. Fixed set of types: The types a variant can hold are fixed at compile-time. You can't add new types at runtime.
3. No heap allocations: variants usually store their values directly in the variant object (though some large types may be heap-allocated).

On the other hand, std::any is a type-erasing container. It can hold a single value of any type. The type of the value is erased and not known at compile-time. Key characteristics of std::any are:

1. Runtime polymorphism: You can store any type in an any, even types that weren't known when the any was created.
2. Type erasure: The type of the stored value is not known at compile-time. You need to cast the value back to its original type to use it.
3. Heap allocation: any typically allocates the stored value on the heap.

Use std::variant when you have a fixed set of types and want type-safety and avoid heap allocations. For example:

1#include <variant>
2#include <iostream>
3
4auto Visitor{[](auto&& arg) {
5  constexpr bool isInt{std::is_same_v<
6    std::decay_t<decltype(arg)>, int>};
7  constexpr bool isString{std::is_same_v<
8    std::decay_t<decltype(arg)>, std::string>};
9
10  if constexpr (isInt) {
11    std::cout << "int: " << arg << '\n';
12  } else if constexpr (isString) {
13    std::cout << "string: " << arg << '\n';
14  }
15}};
16
17int main() {
18  std::variant<int, std::string> v = 42;
19  std::visit(Visitor, v);
20}

1int: 42

Use std::any when you need to store any type and only know what type you're storing at runtime. For example:

1#include <any>
2#include <iostream>
3
4int main() {
5  std::any a = 42;
6  a = std::string("hello");
7  std::string& s = std::any_cast<
8    std::string&>(a);
9  std::cout << s;  // prints "hello"
10}

1hello

In summary, use std::variant for type-safe value-based polymorphism, and std::any for type-erasing runtime polymorphism.