C++ auto Keyword: Type Deduction Explained with Examples

Let the Compiler Pick the Type

On the previous page you saw that every C++ variable has a fixed type - int, double, std::string, and so on. Writing that type out by hand is fine for int count = 0;, but it gets noisy once the types grow long. The auto keyword (C++11 and later) lets the compiler deduce the type from the value you assign, so you write the value once and let the compiler fill in the rest.

#include <iostream>
using namespace std;

int main() {
    auto count = 0;        // int
    auto price = 3.99;     // double
    auto letter = 'A';     // char
    auto greeting = "hi";  // const char*

    cout << count << " " << price << " " << letter << " " << greeting << "\n";
    return 0;
}

The key idea: auto is not dynamic typing. Each variable still has one concrete type, locked in at compile time. auto just saves you from spelling it out.

Why auto Earns Its Keep

For short, obvious types, auto count = 0; and int count = 0; are equally readable. Where auto really pays off is with long, repetitive type names - the kind you get from the standard library's containers and iterators.

Compare the verbose version with the auto version:

// Without auto - the type is written twice, in effect
std::vector<std::pair<std::string, int>>::iterator it = scores.begin();

// With auto - the compiler already knows the type
auto it = scores.begin();

Both declare exactly the same iterator type. The second one is easier to read and won't fall out of sync if you later change scores to a different container.

Here it is in a complete program:

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<pair<string, int>> scores = {{"Ada", 90}, {"Boris", 85}};

    for (auto it = scores.begin(); it != scores.end(); ++it) {
        cout << it->first << ": " << it->second << "\n";
    }
    return 0;
}

auto in Range-Based for Loops

The most common place you'll meet auto is the range-based for loop. You almost never want to spell out the element type by hand, and how you write the auto decides whether you get a copy or a reference.

#include <iostream>
#include <vector>
#include <string>
using namespace std;

int main() {
    vector<string> names = {"Ada", "Boris", "Rosa"};

    // const auto& - read-only, no copy. The usual default for reading.
    for (const auto& name : names) {
        cout << name << "\n";
    }
    return 0;
}

Three variants you'll see, and what each means:

• for (auto x : v) - x is a copy of each element. Cheap for int, wasteful for big objects.
• for (auto& x : v) - x is a reference; you can modify the elements in place.
• for (const auto& x : v) - x is a read-only reference. Use this when you only need to read.

This next program modifies the container through auto&:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> nums = {1, 2, 3};

    for (auto& n : nums) {
        n *= 10;        // modifies the real element
    }

    for (const auto& n : nums) {
        cout << n << " ";   // 10 20 30
    }
    cout << "\n";
    return 0;
}

Gotcha: write for (auto n : nums) (no &) in that loop and the n *= 10 would silently change only the copy, leaving nums untouched. The compiler won't warn you - the loop just does nothing useful.

What auto Strips Away

A plain auto deduces the type the same way a function-by-value parameter does: it drops top-level const, references, and volatile. That means auto always gives you a fresh, modifiable copy unless you ask for otherwise.

#include <iostream>
using namespace std;

int main() {
    const int original = 42;

    auto copy = original;   // type is int, NOT const int
    copy = 100;             // perfectly legal - the const was stripped

    cout << original << " " << copy << "\n";  // 42 100
    return 0;
}

If you want to keep const or avoid the copy, you add the qualifiers yourself. The pattern is to decorate auto the same way you'd decorate any type:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";

    const auto& ref = name;   // const std::string& - no copy, read-only
    cout << ref << " has " << ref.size() << " letters\n";

    // ref = "Boris";         // error: ref is const
    return 0;
}

So auto deduces the base type; &, const, and * are knobs you add on top. auto is the type, const auto& is a read-only reference to it.

Common Mistakes and Gotchas

auto removes typing effort, not the need to understand types. A few traps catch beginners:

You must initialize. auto has nothing to deduce from an empty declaration, so this is a hard compile error:

auto x;        // error: declaration of 'auto x' has no initializer
auto y = 0;    // fine

Integer literals are int, not double. auto half = 1 / 2; deduces int and stores 0, because 1 / 2 is integer division before auto ever sees it. The type follows the value:

#include <iostream>
using namespace std;

int main() {
    auto wrong = 1 / 2;      // int division -> 0
    auto right = 1.0 / 2;    // double -> 0.5

    cout << wrong << " " << right << "\n";  // 0 0.5
    return 0;
}

auto strips the reference - watch for dangling-copy surprises. If a function returns a reference and you grab it with plain auto, you get a copy, which is sometimes a real performance bug in a hot loop (a deep copy of a large object every iteration). Reach for const auto& when you mean "look, don't take."

Don't hide the type when it matters. auto result = compute(); is fine when compute's return type is obvious from context, but if a reader has to hunt for what result actually is, spelling out the type can be the friendlier choice. auto is for cutting noise, not for hiding intent.

Next: Constants and const

You've now seen that auto deliberately drops const unless you ask to keep it - which raises the obvious question: what does const actually guarantee, and when should you mark a value as unchangeable in the first place? The next page digs into const, constant expressions, and why "make it const by default" is one of the most useful habits in C++.