Why does std::declval add a reference?

Question

std::declval is a compile-time utility used to construct an expression for the purpose of determining its type. It is defined like this:

template< class T >
typename std::add_rvalue_reference<T>::type declval() noexcept;

Would this not be simpler instead?

template< class T >
T declval() noexcept;

What is the advantage of a reference return type? And shouldn't it be called declref?

The earliest historical example I find is n2958, which calls the function value() but already always returns a reference.

Note, the operand of decltype does not need to have an accessible destructor, i.e. it is not semantically checked as a full-expression.

template< typename t >
t declprval() noexcept;

class c { ~ c (); };
decltype ( declprval< c >() ) * p = nullptr; // OK

Answer 1

The "no temporary is introduced for function returning prvalue of object type in decltype" rule applies only if the function call itself is either the operand of decltype or the right operand of a comma operator that's the operand of decltype (§5.2.2 [expr.call]/p11), which means that given declprval in the OP,

template< typename t >
t declprval() noexcept;

class c { ~ c (); };

int f(c &&);

decltype(f(declprval<c>())) i;  // error: inaccessible destructor

doesn't compile. More generally, returning T would prevent most non-trivial uses of declval with incomplete types, type with private destructors, and the like:

class D;

int f(D &&);

decltype(f(declprval<D>())) i2;  // doesn't compile. D must be a complete type

and doing so has little benefit since xvalues are pretty much indistinguishable from prvalues except when you use decltype on them, and you don't usually use decltype directly on the return value of declval - you know the type already.

Answer 2

Arrays cannot be returned by value thus even just the declaration of a function returning an array by value is invalid code.

You can however return an array by reference.

Answer 3

The purpose of decltype() is to have an expression that acts as a valid value of type T, to put it as a T in expressions expecting Ts. The problem is that in C++ a type Tcan be non-copyable, or even non-default-constructible. So using the T{} for that purpose doesn't work.

What decltype() does is to return an rvalue-reference to a T. An rvalue reference should be valid for any type T, so its guaranteed that we have a valid T from an rvalue reference of T, and its guaranteed we can have an rvalue reference to any type T. Thats the trick.

Think about decltype() as "give me a valid expression of type T". Of course its usage is intended for overload resolution, type determination, etc; since its purpose is to return a valid expression (In the syntactical sense), not to return a value. Thats reflected in the fact that std::declval() is not defined at all, its only declared.
If it was defined, we have the initial problem again (We have to construct a value for an arbitrary type T, and thats not possible).