Syntax for universal references

by

A universal reference such as T&& can deduce T to be an “object type“, or a “reference type“

In your example it can deduce T as int when passed an rvalue, so the function parameter is int&&, or it can deduce T as int& when passed an lvalue, in which case the function parameter is int& (because the reference collapsing rules say std::add_rvalue_reference<int&>::type is just int&)

If T isn’t deduced by the function call (as in your X::baz example) then it can’t be deduced to int&, so the reference isn’t a universal reference.

So IMHO there’s really no need for new syntax, it fits nicely into template argument deduction and reference collapsing rules, with the small tweak that a template parameter can be deduced as a reference type (where in C++03 a function template parameter of type T or T& would always deduce T as an object type.)

These semantics and this syntax were proposed right from the beginning when rvalue references and a tweak to the argument deduction rules were proposed as the solution to the forwarding problem, see N1385. Using this syntax to provide perfect forwarding was proposed in parallel with proposing rvalue references for the purposes of move semantics: N1377 was in the same mailing as N1385. I don’t think an alternative syntax was ever seriously proposed.

IMHO an alternative syntax would actually be more confusing anyway. If you had template<typename T> void bar(T&@) as the syntax for a universal reference, but the same semantics as we have today, then when calling bar(i) the template parameter T could be deduced as int& or int and the function parameter would be of type int& or int&& … neither of which is “T&@” (whatever that type is.) So you’d have grammar in the language for a declarator T&@ which is not a type that can ever exist, because it actually always refers to some other type, either int& or int&&.

At least with the syntax we’ve got the type T&& is a real type, and the reference collapsing rules are not specific to function templates using universal references, they’re completely consistent with the rest of the type system outside of templates: 

struct A {} a;
typedef A& T;
T&& ref = a;    // T&& == A&

Or equivalently:

struct A {} a;
typedef A& T;
std::add_rvalue_reference<T>::type ref = a;    // type == A&

When T is an lvalue reference type, T&& is too. I don’t think a new syntax is needed, the rules really aren’t that complicated or confusing.

More Related Contents:

  1. Rule-of-Three becomes Rule-of-Five with C++11? [closed]
  2. What does T&& (double ampersand) mean in C++11?
  3. C++11 rvalues and move semantics confusion (return statement)
  4. Rvalue Reference is Treated as an Lvalue?
  5. Is returning by rvalue reference more efficient?
  6. Move capture in lambda
  7. C++11 make_pair with specified template parameters doesn’t compile
  8. Do rvalue references to const have any use?
  9. Why is `std::move` named `std::move`?
  10. What does auto&& tell us?
  11. Overload resolution between object, rvalue reference, const reference
  12. How to actually implement the rule of five?
  13. Why user-defined move-constructor disables the implicit copy-constructor?
  14. What’s a use case for overloading member functions on reference qualifiers?
  15. non-class rvalues always have cv-unqualified types
  16. Can I typically/always use std::forward instead of std::move?
  17. Can compiler generate std::move for a last use of lvalue automatically?
  18. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  19. What are the main purposes of std::forward and which problems does it solve?
  20. Is there any case where a return of a RValue Reference (&&) is useful?
  21. Should a move constructor take a const or non-const rvalue reference?
  22. What does `auto && e` do in range-based for-loops?
  23. Understanding rvalue references
  24. Operator overload which permits capturing with rvalue but not assigning to
  25. Why aren’t there compiler-generated swap() methods in C++0x?
  26. What’s the standard/official name for universal references?
  27. Overloading on R-value references and code duplication
  28. How does std::forward receive the correct argument?
  29. Is there a reference_wrapper for rvalue references?
  30. C++ forwarding reference and r-value reference

Leave a Comment