Function with universal reference argument not being used when called with lvalue - c++11

Question

Consider this simple code snippet:
static void Foo(std::string&& arg) {
printf("(universal reference) = %s\n", arg.c_str());
}
static void Foo(const std::string&& arg) {
printf("(const universal reference) = %s\n", arg.c_str());
}
static void Foo(std::string& arg) {
printf("(reference) = %s\n", arg.c_str());
}
static void Foo(const std::string& arg) {
printf("(const reference) = %s\n", arg.c_str());
}
int main(int argc, const char * argv[]) {
std::string value{"value"};
const std::string const_value{"const_value"};
Foo(value);
Foo(const_value);
Foo(std::string("temporary"));
Foo("litteral");
}
The resulting output under Clang is:
(reference) = value
(const reference) = const_value
(universal reference) = temporary
(universal reference) = literal
Why is the value case not using the universal reference version of the function? I thought one of the key benefits of universal references was that they could accept both lvalues and rvalues?
PS: It's not possible to force it either:
static void Foo(std::string&& arg) {
printf("(universal reference) = %s\n", arg.c_str());
}
//static void Foo(const std::string&& arg) {
// printf("(const universal reference) = %s\n", arg.c_str());
//}
//
//static void Foo(std::string& arg) {
// printf("(reference) = %s\n", arg.c_str());
//}
//
//static void Foo(const std::string& arg) {
// printf("(const reference) = %s\n", arg.c_str());
//}
int main(int argc, const char * argv[]) {
std::string value{"value"};
const std::string const_value{"const_value"};
Foo(value); <--- FAILS COMPILING: No matching function for call to 'Foo'
// Foo(const_value);
Foo(std::string("temporary"));
Foo("literal");
}
UPDATE: It appears "universal references" are only for templates, not regular functions, which explains why the above is not working as I was expecting.
However here's a version using a templated function:
template<typename T>
static void Foo(T&& arg) {
printf("%s\n", arg.c_str());
}
int main(int argc, const char * argv[]) {
std::string value{"value"};
const std::string const_value{"const_value"};
Foo<std::string>(value); <--- FAILS COMPILING: No matching function for call to 'Foo'
Foo<std::string>(const_value); <--- FAILS COMPILING: No matching function for call to 'Foo'
Foo<std::string>(std::string("temporary"));
Foo<std::string>("literal");
}
Why is the value case still not working through universal references (I understand why the const_value case is not)?
UPDATE: For reference, here's the final version that works with both lvalues and rvalues:
template<typename T>
static void Foo(T&& arg) {
printf("%s\n", arg.c_str());
}
int main(int argc, const char * argv[]) {
std::string value{"value"};
const std::string const_value{"const_value"};
Foo(value);
Foo(const_value);
Foo(std::string("temporary"));
//Foo("literal"); <--- Cannot work anyway since template is instantiated with arg as a const char*
}

Answer 1

Those are not "universal references". Those are merely rvalue references.
A "universal reference" (FYI: this term has fallen out of disfavor) refers explicitly to an rvalue reference applied directly to a fully template deduced type (as opposed to something like vector<T> &&v, which is only partially deduced) when using template argument deduction. None of your functions are template functions, so they behave like regular rvalue references.
foo(value) calls the lvalue reference version because variables passed as parameters bind to lvalue reference parameter types.
However here's a version using a templated function:
None of those functions use template argument deduction. You're explicitly specifying the template parameter directly, not allowing it to be deduced by the arguments you call it with.
Or more to the point:
Foo<std::string>(value);
Foo(value);
Foo<std::string>(std::string("temporary"));
Foo(std::string("temporary"));
In the first case, T is std::string, because you specified it to be so. Therefore, Foo<std::string> takes a std::string&&. value cannot bind to an rvalue reference, so it's a compile error.
In the second case, T is deduced through template argument deduction based on the argument expression. value is an lvalue, so T is deduced as std::string&. Therefore, Foo in this case takes a std::string& &&, which devolves down to std::string&.
In the third case, T is std::string. Therefore again, Foo<std::string> takes a std::string&&. A temporary can bind to an rvalue reference just fine, so it does so.
In the fourth case, T is deduced through template argument deduction based on the argument expression. The expression is a std::string temporary prvalue, so T is deduced as std::string (note the lack of references). So Foo in this case takes a std::string&&.