Why is `decltype((x))` different from `decltype(x)`?

For an id-expression, `decltype(name)` gives the declared type; `decltype((name))` treats it as an expression and can yield an lvalue reference type.

When use `decltype(auto)`?

When you need the **exact** type of an expression including reference-ness—often for forwarding helpers—while watching for dangling references.

No—only the type is computed; unevaluated contexts still must be well-formed.

2026년 3월 12일 · 14분 읽기 · 수정 2026년 3월 30일 Intermediate Tutorial

How decltype preserves references and const, how it pairs with auto and C++14 decltype(auto), and common template patterns.

decltype yields the type of an expression. Unlike plain auto in many cases, it can preserve top-level const and reference.

int x = 10;
decltype(x) y = 20;        // int

const int& ref = x;
decltype(ref) z = x;       // const int&

const int& r = x;
auto a = r;           // int (decay)
decltype(r) b = r;    // const int&

template<typename T, typename U>
auto add(T a, U b) -> decltype(a + b) {
    return a + b;
}

int& getRef();

auto a = getRef();            // int
decltype(auto) b = getRef();  // int&

Note: decltype(auto) applies decltype rules to the initializer—it does not “always add references.”

template<typename T>
auto process(T v) -> decltype(v.size(), void()) {
    // selected only if v.size() is valid
}

Use with std::declval, void_t, or C++20 requires for structured constraints.

int x = 10;
decltype(x)   // int
decltype((x)) // int&  — lvalue expression

C++, decltype, decltype(auto), trailing return type, templates