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?
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.
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.
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.
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:
void* variables coming from legacy librariesOn 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.
auto is immutable, while std::any is mutable. That means auto is determined at runtime.