auto & decltype

Some C++ types are long and ugly — iterator types, template results, lambda types. auto lets the compiler figure them out for you, and decltype reports the exact type of an expression when you need precision. Used well, they make code shorter and safer; used carelessly, they hide important detail. This lesson teaches you when each one earns its keep.

Learn auto & decltype in our free C++ course — a beginner-friendly interactive lesson with worked examples, a practice exercise and a quick recall.

Part of the free C++ course at LearnCodingFast — hands-on lessons with examples you run in your browser, plus practice exercises and a quick quiz.

Imagine filling out a form. With explicit types you write the full label every time: "this box holds a 32-bit signed integer". With auto you instead say "whatever fits what I'm putting in" — you hand over a value and the form figures out the right box. It's not weaker typing : the box still has exactly one fixed type, you just let the value decide it. decltype is like asking a clerk "what type is that field over there?" — it tells you the precise declared type of something that already exists, without touching it.

1. auto: Deduce the Type

auto asks the compiler to deduce a variable's type from its initializer. It's still strongly, statically typed — once deduced, the type is locked in. The classic payoff is iterators: instead of writing , you write auto . Note that an auto variable must be initialized, since there's nothing to deduce from otherwise.

2. auto Copies — Use auto& to Avoid It

Here's the subtle part: plain auto deduces by value , so it makes a copy and strips away references and top-level const . In a range-based for loop that means for (auto n : v) modifies copies, not the real elements. Use auto& to bind a reference (to modify the originals) or const auto& to read efficiently without copying.

Your turn. The loop below should double each price in place . Fill in the blank with the right form of auto :

These lines declare a value with auto , derive a decltype type from it, and print. Put them in order:

Open main (D), let price deduce to double (B), declare tax with the same type via decltype(price) (A), print the sum 5.25 (C), then return 0; (E) and close (F). decltype(price) needs price to exist first.

3. decltype: the Exact Type of an Expression

Where auto deduces from a value and strips references and const, decltype(expr) reports the exact declared type of an expression — including const and references — and it does not evaluate the expression. This makes it the precise tool when you must mirror the type of something that already exists, such as the result type of a + b in a template.

4. Deduced Return Types

Since C++14, a function can use auto as its return type and the compiler deduces it from the return statements — invaluable for templates where the result type depends on the inputs. The older trailing return type syntax, auto f(...) -> decltype(...) , spells the type out explicitly using decltype , which is occasionally clearer or required.

Plain auto follows the same rules as template argument deduction: it deduces by value , dropping top-level const and references. You opt back in explicitly:

decltype(auto) is a special return-type form that uses decltype's rules instead of auto's, so it preserves references and const. It's mainly for generic wrappers that must forward an expression's exact type:

Predict the output before revealing the answer.

1 — plain auto copies each element, so n += 100 changes copies, not the vector. Use auto& to actually modify it.

3 — 7 / 2 is integer division giving an int 3, so x is deduced as int . auto doesn't change the math.

99 — decltype(a) is int , so b is an int& bound to a . Assigning to b updates a .

Put const auto& and structured bindings to work iterating a map, and let auto hold your running total.

Practice quiz

• Browse all free courses
• Cheat sheets & quizzes
• Coding dictionary