What is the difference between `auto` and `std::any`?

Question

I recently came across the std::any class, introduced in C++17, based on boost::any. This class can "hold an instance of any type" and auto automatically deduces the data type of a variable.

So what is the main difference? What are the pros and cons?

Answer 1

std::any and auto are completely different constructs.

---

std::any is a container type that can hold an object of any type:

std::any a = 42;        // a holds an int, but type is std::any
a = std::string{"hi"};  // ok, a holds a string now

The type of the object held by std::any can change during the execution of the program.

---

auto is a keyword that designates a placeholder type. The type of a variable with auto is the type of the value used to initialize the variable:

auto a = 42;            // a is int, for the entirety of the program
a = std::string{"hi"};  // error, a has type int

This type is determined statically, i.e. at compile time, and can never change during the execution of the program.

---

These constructs are not interchangeable, and so they have different use cases, and you can't compare the pros and cons of one versus the other meaningfully.

Answer 2

If you write:

auto a = 42;
a = "some string";

you get a compilation error, because a is variable of type int, and you can't assign a string to it. The auto keyword just means the compiler will make the decision of what type to use for you.

Now, if you write:

std::any a = 42;
a = "some string";

That will work, because the type of a is std::any, which is a complex class type that makes use of templates to behind the scenes store any type for you. Needless to say, it is a much more complex type than int, and you should only use it when absolutely necessary.

Answer 3

What is the main difference?

The main difference is that auto is a compile time thing and std::any is runtime thing while it can be said that they do logically the same thing: they can store a variable of any type.

Answer 4

std::any is a modern and type-safe construct for those cases that you want to have a variable that its type may change at run-time. A few example use-cases are:

1. Reading specific values from a file/Gui that can have any types
2. Simulating the dynamic typing behavior of an scripting language
3. A good and type-safe candidate to wrap void* variables coming from legacy libraries

On the other hand, auto is a compiler mechanism to do a type deduction at compile time and use it for the variable used after auto. In other words, the type of the variable defined using auto cannot be changed afterwards.

Answer 5

auto is immutable, while std::any is mutable. That means auto is determined at runtime.