C++ Auto - Automatic Type Deduction

C++ compilers can often automatically infer the type of the variables we create. We can ask the compiler to do this using the auto keyword:

1// This will create an integer
2auto MyNumber { 5 };
3

Most editors, including Visual Studio, will let us inspect what the type was deduced to be by hovering over the variable name.

Our Number variable predictably has a type of int, which we can confirm by hovering over the variable in our editor:

Types can also automatically be deduced in a variety of contexts. For example, when initialising a variable, its type can also be deduced from the return type of the function.

1float GetFloat() {
2    return 3.14f;
3}
4
5// Will be float
6auto Number { GetFloat() };
7

auto with C++ Functions

Auto can also be used to automatically determine the return type of the function. This can be inferred by how the function uses the return statement.

Below, GetDouble will have its return type correctly deduced to double. Therefore, NumberC will also have a type of double

1auto GetDouble() {
2    return 3.14;
3}
4
5auto Number { GetDouble() };
6

As of C++ 20, auto can also be used with function parameters:

1auto Add(auto x, auto y) {
2    return x + y;
3}
4
5auto Number { Add(1, 2) };
6

We're calling the add function with two integers, so x and y in that function will be integers.

Then, we are returning the result of summing two integers, therefore the return type of Add will be deduced to be an integer.

And finally, because Number is being initialised to that return value, its type will also be an integer.

C++ auto vs Dynamic Typing

Some may have experience with other programming languages, where we store data inside variables, regardless of the type of those variables.

This is sometimes called "dynamic typing". It is important to note that auto is not an implementation of dynamic types.

For example, this code will not compile:

1auto MyVariable { 10 };
2MyVariable = "Hello World"
3

The type of MyVariable is inferred to be an int as soon as line 1 is executed. It cannot later change to a string. Even though it's type is auto, that type is determined as soon as our variable is initialised.

For that reason, we also can't do this:

1auto MyVariable;
2

If we try to use auto without initialising the variable, the compiler has no way to tell what to set its type to.

C++ is a strongly typed language. The type of variables needs to be known. auto doesn't change that, it just asks the compiler to figure that out for us.

Qualifiers: auto Pointers, auto References

As with any type, we can add "qualifiers" to our auto declarations. For example, we can create references and pointers to automatically deduced types:

1int x { 5 };
2
3// Reference to an automatically deduced type
4auto& ReferenceToX { x };
5
6// Pointer to an automatically deduced type
7auto* PointerToX { &x };
8

Should We Use auto?

Generally auto should not be used if our only reason is to avoid specifying our data types.

Whilst it can save a few keystrokes, using auto can make our code more difficult to read, especially as it gets more complicated.

To figure out what type an auto variable is, we have to hover over it, rather than simply being able to read the type directly. Moreover, we don't always read code in an editor.

In larger projects, code is often read in tools that won't provide visibility on what "auto" is being interpreted as.

Secondly, even if our editors can show us what auto is being interpreted as, that capability often requires our code being in a compilable state.

If we introduce an issue that prevents code from being compilable, we often lose visibility on the types we were relying on being deduced by the compiler.

This means it can be very difficult to work with complex code that makes excessive use of auto.

However, there are some scenarios where using auto makes sense. Most notably, it could be used where it is extremely obvious what our type is, even without tool assistance.

For example, a past lesson had this code:

1enum class Faction { Human, Elf, Undead };
2Faction Faction { Faction::Undead };
3

Faction being repeated 3 times on this short line of code is quite messy. It can also be confusing for beginners, as both the name and type of the variable are the same.

The Faction:: syntax makes it clear this variable is going to be initialised from the Faction enum, so its type is obvious. Therefore, we might consider using auto in this scenario:

1auto Faction { Faction::Human };
2

For similar reasons, another scenario where auto might be preferred is when we are storing the value returned from a named cast:

1Monster* Monster { dynamic_cast<Monster*>(Target) };
2

Given we're already specifying the type we're trying to dynamic_cast to, it is reasonable to replace the duplicated type with auto:

1auto Monster { dynamic_cast<Monster*>(Target) };
2

In the remainder of this course, and the more advanced courses, we adopt a fairly conservative use of auto. We avoid it by default, but will use it if we think it makes the code clearer.

This generally falls in line with Google's style guide:

However, many others recommend avoiding auto as much as possible:

Up next, we'll see a scenario where we need to use auto. We'll learn how we can use structured bindings to quickly create a large amount of variables from one of our objects.