12 Overloading [over]

12.2 Overload resolution [over.match]

12.2.2 Candidate functions and argument lists [over.match.funcs]

12.2.2.2 Function call syntax [over.match.call]

12.2.2.2.1 General [over.match.call.general]

postfix-expression ( expression-list

_{o p t}

)

if the postfix-expression names at least one function or function template, overload resolution is applied as specified in [over.call.func].

If the postfix-expression denotes an object of class type, overload resolution is applied as specified in [over.call.object].

If the postfix-expression is the address of an overload set, overload resolution is applied using that set as described above.

[Note 1:

No implied object argument is added in this case.

— end note]

If the function selected by overload resolution is an implicit object member function, the program is ill-formed.

[Note 2:

The resolution of the address of an overload set in other contexts is described in [over.over].

— end note]

12.2.2.2.2 Call to designated function [over.call.func]

Of interest in [over.call.func] are only those function calls in which the postfix-expression ultimately contains an id-expression or splice-expression that designates one or more functions.

Such a postfix-expression, perhaps nested arbitrarily deep in parentheses, has one of the following forms:

postfix-expression:
postfix-expression . id-expression
postfix-expression . splice-expression
postfix-expression -> id-expression
postfix-expression -> splice-expression
id-expression
splice-expression

These represent two syntactic subcategories of function calls: qualified function calls and unqualified function calls.

In qualified function calls, the function is designated by an id-expression or splice-expression E preceded by an -> or . operator.

Since the construct A->B is generally equivalent to (*A).B, the rest of [over] assumes, without loss of generality, that all member function calls have been normalized to the form that uses an object and the . operator.

Furthermore, [over] assumes that the postfix-expression that is the left operand of the . operator has type “cv T” where T denotes a class.100

The set of candidate functions either is the set found by name lookup ([class.member.lookup]) if E is an id-expression or is the set determined as specified in [expr.prim.splice] if E is a splice-expression.

The argument list is the expression-list in the call augmented by the addition of the left operand of the . operator in the normalized member function call as the implied object argument ([over.match.funcs]).

In unqualified function calls, the function is designated by an id-expression or a splice-expression E The set of candidate functions either is the set found by name lookup ([basic.lookup]) if E is an id-expression or is the set determined as specified in [expr.prim.splice] if E is a splice-expression.

The set of candidate functions consists either entirely of non-member functions or entirely of member functions of some class T.

In the former case or if E is either a splice-expression or the address of an overload set, the argument list is the same as the expression-list in the call.

Otherwise, the argument list is the expression-list in the call augmented by the addition of an implied object argument as in a qualified function call.

If the current class is, or is derived from, T, and the keyword this ([expr.prim.this]) refers to it,

(3.1)
if the unqualified function call appears in a precondition assertion of a constructor or a postcondition assertion of a destructor and overload resolution selects a non-static member function, the call is ill-formed;
(3.2)
otherwise, the implied object argument is (*this).

Otherwise,

(3.3)
if overload resolution selects a non-static member function, the call is ill-formed;
(3.4)
otherwise, a contrived object of type T becomes the implied object argument.101

[Example 1: struct C { bool a(); void b() { a(); // OK, (*this).a() } void c(this const C&); // #1 void c() &; // #2 static void c(int = 0); // #3 void d() { c(); // error: ambiguous between #2 and #3 (C::c)(); // error: as above (&(C::c))(); // error: cannot resolve address of overloaded this->C::c ([over.over]) (&C::c)(C{}); // selects #1 (&C::c)(*this); // error: selects #2, and is ill-formed ([over.match.call.general]) (&C::c)(); // selects #3 } void f(this const C&); void g() const { f(); // OK, (*this).f() f(*this); // error: no viable candidate for (*this).f(*this) this->f(); // OK } static void h() { f(); // error: contrived object argument, but overload resolution // picked a non-static member function f(C{}); // error: no viable candidate C{}.f(); // OK } void k(this int); operator int() const; void m(this const C& c) { c.k(); // OK } C() pre(a()) // error: implied this in constructor precondition pre(this->a()) // OK post(a()); // OK ~C() pre(a()) // OK post(a()) // error: implied this in destructor postcondition post(this->a()); // OK }; — end example]

100)100)

Note that cv-qualifiers on the type of objects are significant in overload resolution for both glvalue and class prvalue objects.

101)101)

An implied object argument is contrived to correspond to the implicit object parameter attributed to member functions during overload resolution.

It is not used in the call to the selected function.

Since the member functions all have the same implicit object parameter, the contrived object will not be the cause to select or reject a function.

12.2.2.2.3 Call to object of class type [over.call.object]

If the postfix-expression E in the function call syntax evaluates to a class object of type “cv T”, then the set of candidate functions includes at least the function call operators of T.

The function call operators of T are the results of a search for the name operator() in the scope of T.

In addition, for each non-explicit conversion function declared in T of the form

operator conversion-type-id ( ) cv-qualifier-seq

_{o p t}

ref-qualifier

_{o p t}

noexcept-specifier

_{o p t}

attribute-specifier-seq

_{o p t}

;

where the optional cv-qualifier-seq is the same cv-qualification as, or a greater cv-qualification than, cv, and where conversion-type-id denotes the type “pointer to function of (

P_{1}, \dots, P_{n}

) returning R”, or the type “reference to pointer to function of (

P_{1}, \dots, P_{n}

) returning R”, or the type “reference to function of (

P_{1}, \dots, P_{n}

) returning R”, a surrogate call function with the unique name call-function and having the form

R call-function ( conversion-type-id F, P

_{1}

_{1}

, …, P

_{n}

_{n}

) { return F (a

_{1}

, …, a

_{n}

); }

is also considered as a candidate function.

Similarly, surrogate call functions are added to the set of candidate functions for each non-explicit conversion function declared in a base class of T provided the function is not hidden within T by another intervening declaration.102

The argument list submitted to overload resolution consists of the argument expressions present in the function call syntax preceded by the implied object argument (E).

[Note 1:

When comparing the call against the function call operators, the implied object argument is compared against the object parameter of the function call operator.

When comparing the call against a surrogate call function, the implied object argument is compared against the first parameter of the surrogate call function.

— end note]

[Example 1: int f1(int); int f2(float); typedef int (*fp1)(int); typedef int (*fp2)(float); struct A { operator fp1() { return f1; } operator fp2() { return f2; } } a; int i = a(1); // calls f1 via pointer returned from conversion function — end example]

102)102)

Note that this construction can yield candidate call functions that cannot be differentiated one from the other by overload resolution because they have identical declarations or differ only in their return type.

The call will be ambiguous if overload resolution cannot select a match to the call that is uniquely better than such undifferentiable functions.