Overload resolution with ref-qualifiers

by

Firstly, the implicit object parameter is treated as a normal parameter as per 13.3.1.4:

For non-static member functions, the type of the implicit object parameter is

— “lvalue reference to cv X” for functions declared without a ref-qualifier or with the & ref-qualifier

— “rvalue reference to cv X” for functions declared with the && ref-qualifier

where X is the class of which the function is a member and cv is the cv-qualification on the member
function declaration.

So what you are asking is equivalent to the following:

void bar(foo&);
void bar(foo&&);
void bar(const foo&);
void bar(const foo&&);

int main()
{
    bar(foo());
}

The expression foo() is a class prvalue.

Secondly, the non-const lvalue reference version is not viable, as a prvalue cannot bind to it.

This leaves us with three viable functions for overload resolution.

Each has a single implicit object parameter (const foo&, foo&& or const foo&&), so we must rank these three to determine the best match.

In all three case it is a directly bound reference binding. This is described in declarators/initialization (8.5.3).

The ranking of the three possible bindings (const foo&, foo&& and const foo&&) is described in 13.3.3.2.3:

Standard conversion sequence S1 is a better conversion sequence than standard conversion sequence S2 if

  • S1 and S2 are reference bindings and neither refers to an implicit object parameter of a non-static member function declared without a ref-qualifier [this exception doesn’t apply here, they all have ref-qualifiers], and S1 binds an rvalue reference to an rvalue [a class prvalue is an rvalue] and S2 binds an lvalue reference.

This means that both foo&& and const foo&& are better then const foo&.

  • S1 and S2 are reference bindings, and the types to which the references refer are the same type except for top-level cv-qualifiers, and the type to which the reference initialized by S2 refers is more cv-qualified than the type to which the reference initialized by S1 refers.

This means that foo&& is better than const foo&&.

So Clang is right, and it is a bug in GCC. The overload ranking for foo().bar() is as follows:

struct foo
{
    int&& bar() &&;             // VIABLE - BEST  (1)
    int const&& bar() const &&; // VIABLE -       (2)
    int const& bar() const &;   // VIABLE - WORST (3)
    int& bar() &;               // NOT VIABLE

    int _bar;
};

The bug in GCC seems to apply purely to implicit object parameters (with ref-qualifiers), for a normal parameter it seems to get the ranking correct, at least in 4.7.2.

More Related Contents:

  1. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  2. Is the size of std::array defined by standard
  3. Resolving ambiguous overload on function pointer and std::function for a lambda using + (unary plus)
  4. Overload resolution between object, rvalue reference, const reference
  5. Capturing a reference by reference in a C++11 lambda
  6. Is a moved-from vector always empty?
  7. c++ access static members using null pointer
  8. What’s a use case for overloading member functions on reference qualifiers?
  9. In C++11, does `i += ++i + 1` exhibit undefined behavior?
  10. Why is modifying a string through a retrieved pointer to its data not allowed?
  11. SFINAE works differently in cases of type and non-type template parameters
  12. Is it legal to declare a constexpr initializer_list object?
  13. Are notes and examples in the core language specification of the C++ Standard non-normative?
  14. What does the void() in decltype(void()) mean exactly?
  15. Can the point-of-instantiation be delayed until the end of the translation unit?
  16. Can C++ code be valid in both C++03 and C++11 but do different things?
  17. What is the value category of the operands of C++ operators when unspecified?
  18. How can an incomplete type be used as a template parameter to vector here?
  19. Is the Empty Base Class Optimization now a mandatory optimization (at least for standard-layout classes)?
  20. Is left-shifting (
  21. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  22. Classes with both template and non-template conversion operators in the condition of switch statement
  23. Does C++11 allow dollar signs in identifiers?
  24. reinterpret_cast between char* and std::uint8_t* – safe?
  25. What is the difference between std::quick_exit and std::abort and why was std::quick_exit needed?
  26. Does C++11 change the behavior of explicitly calling std::swap to ensure ADL-located swap’s are found, like boost::swap?
  27. STL algorithms: Why no additional interface for containers (additional to iterator pairs)?
  28. C++11 cross compiler/standard library random distribution reproducibility
  29. Using std::bind with member function, use object pointer or not for this argument?
  30. memcpy/memmove to a union member, does this set the ‘active’ member?

Leave a Comment