Using a class template in a function template with universal reference parameter

Question

According to msvc, gcc and clang, the following code is illegal:

template <typename T>
void f(T&& e) {
    std::vector<T> v;
    // do something with v and e ...
}
int main() {

    int i;
    f(i);
}

msvc yields

xmemory0(591): error C2528: 'pointer': pointer to reference is illegal

gcc and clang give similar sounding error messages. Note that the universal reference parameter e is not used. The compiler obviously fails to instantiate the vector v, complaining about it being used with a reference to int:

note: see reference to class template instantiation 'std::vector<T,std::allocator<_Ty>>' being compiled with

    [
        T=int &,
        _Ty=int &
    ]

But I can't see where the function template f is instantiated with a reference to int.

Can somebody explain the compiler errors that we see here?

Answer 1

When f is called with an lvalue int, T will be deduced as int&, so v will be a std::vector<int&>. This is invalid.

One way to get around this is to remove references from T before using it:

template <typename T>
void f(T&& e) {
    using value_type = typename std::remove_reference<T>::type;
    //using value_type = std::remove_reference_t<T>; for C++14
    std::vector<value_type> v;
    // do something with v and e ...
}

However, if you want the function to be as generic as possible, you should use std::decay instead of std::remove_reference. This will let f work with cv-qualified types, arrays and functions.

Answer 2

Scott Meyers explains in this article.

If the expression initializing a universal reference is an lvalue, the universal reference becomes an lvalue reference.

If the expression initializing the universal reference is an rvalue, the universal reference becomes an rvalue reference.

In your case i is an lvalue and so T is deduced as int&.