Why decltype isn't implicit?

Question

Why decltype can't be implicitly added to an expression when type was expected?

template <class X, class Y, class Z>
auto foo(X x, Y y, Z z){
    std::vector<decltype(x+y*z)> values;  // valid in c++11/c++14
    //std::vector<x+y*z> values;            // invalid
    values.push_back(x+y*z);
    return values;                        // type deduced from expression - OK
}

In c++14 compilers will able to deduce function return type based on return expressions. Why this can't be extended to any 'expression -> type' conversion?

The same apply to declval, why I have to write:

std::vector<decltype(declval<X>() + declval<Y>() * declval<Z>())> values;

instead of:

std::vector<X+Y*Z> values;

Answer 1

If implicit addition of decltype would be allowed, some very common templates would become ambiguous, or even impossible to express.

---

Consider the following example :

struct tp 
{
    template<typename T>
    void foo() { cout << "Type parameter\n"; }   

    template<int Value>
    void foo() { cout << "Value parameter\n"; }   
};

int main() 
{
  const int x = 1;
  const int y = 2;
  const int z = 3;

  tp t1;
  t1.foo<x*y+z>();
  t1.foo<decltype(x*y+z)>(); // Oops ! different version of foo() 
  t1.foo<int>();

  return 0;
}

Output:

Value parameter

Type parameter

Type parameter

If decltype is implicitly added to t1.foo<x*y+z>();, the wrong version of foo() is called.

• C++ policy for expressing what you do, and avoid when possible any implicit work by the compiler is IMHO a very good thing. It makes things easier to read, to understand, and to maintain.
• After all, decltype is only 8 letters

Live demo here.