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, ie 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.
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.