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?

Niece

They are not comparable because they are not interchangeable. There is no pros and cons. The type of an auto object is resolved during compilation. The type of an object help by a std::any is not. – Blubberhead

Docs for auto. Docs for std::any. – Gasp

Two very different things. There is no meaningful way to compare them. – Cathouse

I haven't downvoted but this question does not show any research. Even minimal research like a google search answers it – Tarragon

std::any has nothing to do with auto. It's more comparable to std::variant. See C++ std::variant vs std::any – Multi

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.

Jeddy

Weird how we used the same variable name and the same integer value. I guess 42 is special. – Dunbarton

@Dunbarton Not too weird :) a is the first character in the alphabet, and 42 most certainly is special :) – Jeddy

@Dunbarton Also, both auto and any start with a, so that explains a lot :) I think that might have been a subconscious bias for me at least. – Jeddy

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.

Dunbarton

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.

Aucoin

I'm not too comfortable with the wording "logically do the same thing". Could you expand on what you mean by that? auto can only hold one type. – Jeddy

I mean that OP probably noticed that they can write auto a = 42 or std::any a = 42. This may seem that both statements do the same or almost the same thing. But it is not because the 1st is done at compile time and the 2nd at runtime. – Aucoin

Yes, so logically not the same thing, right? Even if it seems that way. – Jeddy

No, they logically look the same, but they can't be absolutely the same because of the differences I mentioned. – Aucoin

Logically is still not the right word. You might mean they're syntactically the same but they are semantically(which is the logic of the statement) different. – Aurora

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.

Lexicography

Answer 5

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

Pentapody