Overload resolution between object, rvalue reference, const reference

by

What are the rules here?

As there is only one parameter, the rule is that one of the three viable parameter initializations of that parameter must be a better match than both the other two. When two initializations are compared, either one is better than the other, or neither is better (they are indistinguishable).

Without special rules about direct reference binding, all three initializations mentioned would be indistinguishable (in all three comparisons).

The special rules about direct reference binding make int&& better than const int&, but neither is better or worse than int. Therefore there is no best match:

S1    S2
int   int&&         indistinguishable
int   const int&    indistinguishable
int&& const int&    S1 better

int&& is better than const int& because of 13.3.3.2:

S1 and S2 are reference bindings (8.5.3) and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier, and S1 binds an rvalue reference to an rvalue and S2 binds an lvalue reference.

But this rule does not apply when one of the initializations is not a reference binding.

Is there any chance int && may be preferred over int in a future standard? The reference must bind to an initializer, whereas the object type is not so constrained. So overloading between T and T && could effectively mean “use the existing object if I’ve been given ownership, otherwise make a copy.”

You propose to make a reference binding a better match than a non-reference binding. Why not post your idea to isocpp future proposals. SO is not the best for subjective discussion / opinion.

More Related Contents:

  1. What’s a use case for overloading member functions on reference qualifiers?
  2. Why compiler gives the message "call of overloaded function is ambiguous" here in C++11?
  3. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  4. Implementation C++14 make_integer_sequence
  5. What does T&& (double ampersand) mean in C++11?
  6. Do rvalue references to const have any use?
  7. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  8. Is it safe to link C++17, C++14, and C++11 objects
  9. Why is `std::move` named `std::move`?
  10. Syntax for universal references
  11. Why user-defined move-constructor disables the implicit copy-constructor?
  12. non-class rvalues always have cv-unqualified types
  13. Why are lambda expressions not allowed in an unevaluated operands but allowed in the unevaluated portions of constant expressions?
  14. Capturing perfectly-forwarded variable in lambda
  15. Parallel Loops in C++
  16. SFINAE works differently in cases of type and non-type template parameters
  17. Can I typically/always use std::forward instead of std::move?
  18. How to extract the source filename without path and suffix at compile time?
  19. Can compiler generate std::move for a last use of lvalue automatically?
  20. On how to recognize Rvalue or Lvalue reference and if-it-has-a-name rule
  21. What are the main purposes of std::forward and which problems does it solve?
  22. Which headers in the C++ standard library are guaranteed to include another header?
  23. Understanding rvalue references
  24. Operator overload which permits capturing with rvalue but not assigning to
  25. Raw pointer lookup for sets of unique_ptrs
  26. Classes with both template and non-template conversion operators in the condition of switch statement
  27. Why does constexpr static member (of type class) require a definition?
  28. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  29. Reference invalidation after applying reverse_iterator on a custom made iterator
  30. Is there a reference_wrapper for rvalue references?

Leave a Comment