Language

since C++11

Beginner

auto

Type deduction keyword that deduces variable types from initializers, function returns, and parameters. Strips top-level const/references unless explicitly marked.

C++11 C++14 C++17 C++20 C++23

autosince C++11

Placeholder type that instructs the compiler to deduce the variable's or function's type from its initializer or return value, following template argument deduction rules.

Overview

auto eliminates redundant type declarations by letting the compiler infer types from context. It's one of the most impactful features of modern C++, enabling more maintainable code that adapts when right-hand sides change. The deduction mechanism follows the same rules as template argument deduction, making it predictable once you understand the pattern.

The key insight: auto strips top-level const and references. Add them back explicitly when you need them—const auto&, auto*, auto&&. This explicitness prevents surprises: you always see what qualifiers you're getting.

Syntax

Basic variable deduction

cpp

// C++11
auto i = 42;                    // int
auto d = 3.14;                  // double
auto s = std::string("hello");  // std::string
auto v = std::vector{1, 2, 3};  // std::vector<int> (C++17 CTAD)

Adding qualifiers

cpp

const auto x = 42;              // const int — prevents modification
auto& r = someVariable;         // reference to deduced type
const auto& cr = someValue;     // const reference — common for function parameters
auto* p = &someVariable;        // pointer to deduced type
auto&& fwd = someExpression;    // forwarding reference (C++11)

Function return type deduction (C++14)

cpp

auto add(int a, int b) {  // return type deduced from return statements
    return a + b;
}

auto max(double x, double y) -> double {  // trailing return type; auto deduction still works
    return x > y ? x : y;
}

Generic lambda parameters (C++14)

cpp

auto lambda = [](auto x) { return x + x; };  // template parameter
lambda(5);              // 6 (int)
lambda(2.5);            // 5.0 (double)

Abbreviated function templates (C++20)

cpp

void process(auto container) {  // equivalent to template<typename T> void process(T container)
    for (auto elem : container) {
        // elem deduced for each call
    }
}

Examples

Range-based for loops

cpp

std::vector<std::string> words = {"hello", "world"};

// Read-only — preferred pattern; avoids copy
for (const auto& w : words) {
    std::cout << w << '\n';
}

// Modify elements
for (auto& w : words) {
    w.push_back('!');
}

// Force a copy (rarely needed)
for (auto w : words) {
    std::cout << w << '\n';
}

Iterator declarations

cpp

std::map<std::string, int> m = {{"a", 1}, {"b", 2}};

// Pre-C++11: verbose
std::map<std::string, int>::iterator it = m.find("a");

// C++11+: concise, readable
auto it = m.find("a");  // type is std::map<std::string, int>::iterator

// Common loop pattern
for (auto it = m.begin(); it != m.end(); ++it) {
    std::cout << it->first << ": " << it->second << '\n';
}

Containers with exact type deduction

cpp

auto size = m.size();  // std::size_t — not int; avoids narrowing issues
auto count = std::count(v.begin(), v.end(), 42);  // std::ptrdiff_t

// Correct type prevents subtle bugs with unsigned/signed comparisons

decltype(auto) — exact type preservation (C++14)

cpp

int x = 5;
int& rx = x;

auto a = rx;            // int — reference stripped
decltype(auto) b = rx;  // int& — reference preserved

// Essential in generic code for perfect forwarding:
template<typename F, typename... Args>
decltype(auto) call(F&& f, Args&&... args) {
    return std::forward<F>(f)(std::forward<Args>(args)...);
}

Almost Always Auto (AAA) style

cpp

// C++11+: explicit braced initialization prevents narrowing
auto x = int{42};
auto name = std::string{"Alice"};
auto v = std::vector<int>{1, 2, 3};
auto fn = [](int a) { return a * 2; };

// vs. old style (easier to narrow unintentionally)
int x = 42;

Best Practices

Use auto liberally. It reduces noise, prevents type mismatches, and makes refactoring safer. When you change a function's return type, all callers using auto adapt automatically.

Add qualifiers explicitly when needed. const auto& for read-only references, auto* for pointers, auto& for mutable references. These make intent clear.

Prefer range-based for with const auto& to avoid copies and prevent accidental modification. Use auto& only when you need to modify elements.

Use decltype(auto) in forwarding code to preserve exact types and reference-ness, preventing lifetime issues and unwanted copies in template contexts.

Embrace AAA style in new code. The pattern forces explicit initialization and prevents narrowing bugs. Use braced initialization: auto x = int{42} instead of int x = 42.

Common Pitfalls

Stripping const and references

cpp

const std::string& getRef();

auto s1 = getRef();      // std::string — copy made!
const auto& s2 = getRef();  // const std::string& — no copy

This is a design feature, not a bug: auto on its own means "give me the value type." Add qualifiers for the semantics you want.

Proxy types in containers

cpp

std::vector<bool> vb = {true, false, true};
auto elem = vb[0];  // std::vector<bool>::reference — not bool
// This proxy behaves like bool but has subtle differences:
elem = false;  // modifies vb[0] (usually)

// Correct:
bool b = vb[0];

Initializer list deduction

cpp

auto a = {1, 2, 3};    // std::initializer_list<int> — may surprise
auto b = int{1};       // int — explicit
auto c = std::vector{1, 2, 3};  // std::vector<int> (C++17+)

Recursive function return deduction (C++14)

cpp

// ERROR: compiler hasn't seen return type when first recursive call compiles
auto fib(int n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);  // fib not yet defined
}

// Correct: trailing return type or explicit specialization
auto fib(int n) -> long long {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
}

Type Deduction Rules

auto follows template argument deduction (C++11). Qualifiers and reference collapse rules apply:

Initializer	`auto x = ...`	`auto& x = ...`	`const auto& x = ...`
`int i`	`int`	`int&`	`const int&`
`const int i`	`int`	`const int&`	`const int&`
`int& r`	`int`	`int&`	`const int&`
`int&& r`	`int`	ill-formed	`const int&`

C++17 addition: auto with class template argument deduction (CTAD) eliminates the need to specify template arguments for many standard library types:

cpp

auto v = std::vector{1, 2, 3};  // deduces std::vector<int>
auto p = std::pair{1, 2.0};     // deduces std::pair<int, double>

`auto` in Structured Bindings (C++17)

Structured bindings let you unpack aggregates, tuples, and pairs into named variables using auto. The qualifiers (&, const, &&) apply to the whole binding group, and each element is deduced independently from the corresponding member's type.

cpp

// C++17
std::pair<std::string, int> p{"alice", 42};
auto [name, score] = p;          // copies pair; name=std::string, score=int

const auto& [key, val] = p;      // binds both as const references; no copy, no need to name the pair type
auto& [k, v] = p;                // mutable binding; modifications reflect in the original pair
auto&& [k2, v2] = std::move(p); // perfect-forwarding form; moves members if possible

auto&& as the binding qualifier is the most general form — it preserves value category of each element, making it safe with proxy types and move-only members.

cpp

// C++17
std::map<std::string, std::vector<int>> students = {{"alice", {90, 85}}, {"bob", {78}}};

for (auto& [name, scores] : students) {
    scores.push_back(100);  // modifies in place; name is std::string&, scores is std::vector<int>&
}

Common mistake: copying instead of binding by reference. auto [x, y] = *ptr; copies the pointed-to struct into the binding. Write auto& [x, y] = *ptr; to bind by reference and avoid the copy.

`auto&&` Universal/Forwarding Reference Deduction

auto&& follows reference collapsing rules rather than plain value deduction. It can bind to both lvalues and rvalues, making it the most flexible form of auto.

cpp

// C++11
int i = 5;
auto&& r1 = i;          // deduces int& (lvalue reference — reference collapses)
auto&& r2 = 42;         // deduces int&& (rvalue reference — binds temporary)
auto&& r3 = std::move(i); // deduces int&& (explicit rvalue)

This is why auto&& is called a "universal reference" — it binds to anything without copying. In a range-for loop, it is the most general form and handles proxy types that return rvalue references from operator[].

cpp

// C++11 — safest range-for form for generic code
for (auto&& x : range) {
    // x is T& when range yields lvalues, T&& when it yields rvalues or proxies
}

// Handles std::vector<bool> correctly:
std::vector<bool> vb = {true, false};
for (auto&& bit : vb) {
    bit = true;  // modifies through proxy; plain `auto` would copy the proxy object
}

Use auto&& to extend temporary lifetime or avoid copies. auto&& result = expensive_computation(); binds directly to the returned value, extending its lifetime to the variable's scope whether the function returns by value or reference.

Compared to T&& in a template: auto&& is the local-variable equivalent. Use it in function bodies when you don't know (or care) whether an expression is an lvalue or rvalue.

`auto` with C++20 Concepts and Constraints

C++20 allows concepts to constrain auto, documenting intent and catching mismatches at the call site. Unconstrained auto accepts anything; constrained auto accepts only types that satisfy the named concept.

cpp

// C++20 — abbreviated function template; equivalent to template<typename T> void f(T x)
void f(auto x) { /* ... */ }

// Constrained auto — only accepts integral types
void print_int(std::integral auto x) {
    std::cout << x << '\n';
}

// Equivalent explicit template form:
template<std::integral T>
void print_int(T x) { std::cout << x << '\n'; }

Constrained auto works in variable declarations too, asserting at the point of initialization that the deduced type satisfies the concept.

cpp

// C++20
std::integral auto n = compute();           // compile error if compute() returns float
std::floating_point auto ratio = get_ratio(); // asserts floating-point type; documents intent

// In lambdas:
auto lambda = [](std::floating_point auto x) { return x * 2.0; };

// Multiple constrained parameters — each may deduce a different type:
void combine(std::integral auto a, std::floating_point auto b) {
    // a and b can be different types satisfying their respective concepts
}

Constrained auto is self-documenting. Prefer it over unconstrained auto in function parameters when you depend on type properties — the constraint appears right where the parameter is declared, not buried in a requires clause.

`auto` in Class Members and NSDMI

auto cannot be used as a non-static data member type through C++20 — auto x = 0; in a class body is ill-formed. The compiler cannot deduce member types without a complete class definition.

cpp

struct Bad {
    auto x = 0;       // ill-formed in C++11/14/17/20 — compiler error
};

// C++23 relaxes this for static members with NSDMI:
struct Config {
    static constexpr auto version = 42;      // C++23: OK for static constexpr
    // auto name_ = std::string{"default"};  // still ill-formed for non-static
};

For members whose type is complex or computed, use decltype or a type alias instead.

cpp

// C++11 — use decltype to deduce a member type from an expression
struct Timer {
    using ClockPoint = std::chrono::steady_clock::time_point;
    ClockPoint start_;    // explicit alias; readable and maintainable

    // Alternative with decltype (verbose but avoids the alias):
    decltype(std::chrono::steady_clock::now()) timestamp_;
};

// NSDMI works with explicit types, not auto:
struct Point {
    int x_{0};         // OK — explicit type with in-class initializer
    int y_{0};         // OK
    // auto z_ = 0;    // ill-formed
};

Workaround for complex member types: use a type alias. using ClockPoint = std::chrono::steady_clock::time_point; at class or namespace scope keeps the member declaration readable while avoiding auto.

`auto` Return Type Deduction in Templates

When a template function uses auto as its return type, the return type is deduced independently for each instantiation. decltype(auto) instead of plain auto preserves reference-ness — critical for operator[] and other accessors that must return by reference.

cpp

// C++14 — auto strips references; may cause unexpected copies
template<typename C>
auto front_copy(C& c) {
    return c.front();   // returns T (by value), even if c.front() returns T&
}

// C++14 — decltype(auto) preserves reference-ness exactly
template<typename C>
decltype(auto) front(C& c) {
    return c.front();   // returns T& if c.front() returns T&; correct for mutating access
}

std::vector<int> v{1, 2, 3};
front(v) = 99;       // OK — modifies v[0]
// front_copy(v) = 99; // ERROR — modifies a temporary

If a function has multiple return statements, all deduced types must match — the compiler enforces this.

cpp

// C++14
auto pick(bool flag) {
    if (flag) return 1;       // deduces int
    return 2.0;               // ERROR: deduces double — conflict with int
}

// Fix: make all returns consistent
auto pick(bool flag) -> double {
    if (flag) return 1;       // OK: 1 converts to double via trailing return
    return 2.0;
}

Use decltype(auto) for forwarding wrappers and operator[] overloads. Plain auto silently drops references; decltype(auto) propagates them, keeping proxy and reference semantics intact.

SFINAE with deduced return types still works via the trailing form: auto f(...) -> std::enable_if_t<cond, ReturnType>. The auto keyword here just introduces the trailing return type — it does not participate in SFINAE itself.

Common Patterns: When to Use `auto` vs Explicit Types

The choice between auto and an explicit type is about clarity and correctness, not style preference. Use auto when the type is obvious from context or irrelevant to the reader; use an explicit type when the type is part of the API contract or when numeric precision matters.

cpp

// Always use auto — type is verbose, obvious, or irrelevant
auto it = m.find("key");                         // iterator type is an implementation detail
auto fn = [](int x) { return x * 2; };          // lambda type is unnameable
auto [k, v] = *m.begin();                        // structured binding; explicit pair syntax is noise
for (const auto& elem : container) { /* ... */ } // range-for element

// Use explicit types — type is part of the contract or affects correctness
uint32_t checksum = compute_checksum(data);      // unsigned semantics matter; auto might deduce int
double ratio = 1 / 3;                            // auto here would deduce int (0); explicit forces double
std::string name = getName();                    // function parameter/API; documents what callers get

Anti-pattern: redundant cast with auto. auto x = (uint32_t)compute(); is noisy — if the cast is needed for correctness, write uint32_t x = compute(); so the type is visible without the cast syntax.

auto* and auto both work for pointer deduction, but auto* signals pointer semantics to the reader:

cpp

// C++11
int val = 42;
auto  p1 = &val;    // deduces int* — works, but pointer-ness is implicit
auto* p2 = &val;    // deduces int* — explicit; visually emphasizes this is a pointer

Situation	Recommendation
Iterator variable	`auto`
Lambda capture or parameter	`auto`
Complex template instantiation	`auto`
Range-for element (read)	`const auto&`
Range-for element (write)	`auto&`
Function parameter (public API)	Explicit type
Non-static class member	Explicit type or type alias
Numeric literal with precision intent	Explicit type (`uint32_t`, `double`)

See Also

decltype — Extract the type of an expression without evaluating it
Structured bindings — Unpack tuples and aggregates with auto [x, y] = ... (C++17)
Lambda expressions — Generic lambdas with auto parameters (C++14)
std::invoke — Call any callable with type deduction (C++17)