11 Overloading [over]

Of interest in [over.call.func] are only those function calls in which the postfix-expression ultimately contains a name that denotes one or more functions that might be called.

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

postfix-expression:
	postfix-expression . id-expression
	postfix-expression -> id-expression
	primary-expression

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

In qualified function calls, the name to be resolved is an id-expression and is 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.121

Under this assumption, the id-expression in the call is looked up as a member function of T following the rules for looking up names in classes ([class.member.lookup]).

The function declarations found by that lookup constitute the set of candidate functions.

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 name is not qualified by an -> or . operator and has the more general form of a primary-expression.

The name is looked up in the context of the function call following the normal rules for name lookup in function calls.

The function declarations found by that lookup constitute the set of candidate functions.

Because of the rules for name lookup, the set of candidate functions consists (1) entirely of non-member functions or (2) entirely of member functions of some class T.

In case (1), the argument list is the same as the expression-list in the call.

In case (2), 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 keyword this is in scope and refers to class T, or a derived class of T, then the implied object argument is (*this).

If the keyword this is not in scope or refers to another class, then a contrived object of type T becomes the implied object argument.122

If the argument list is augmented by a contrived object and overload resolution selects one of the non-static member functions of T, the call is ill-formed.

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 obtained by ordinary lookup of the name operator() in the context of (E).operator().

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

operator conversion-type-id ( ) cv-qualifier ref-qualifier${}_{opt}$ noexcept-specifier${}_{opt}$ attribute-specifier-seq${}_{opt}$ ;

where cv-qualifier 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 (${\text{P}}_1,\dots ,{\text{P}}_n$) returning R”, or the type “reference to pointer to function of (${\text{P}}_1,\dots ,{\text{P}}_n$) returning R”, or the type “reference to function of (${\text{P}}_1,\dots ,{\text{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$ a${}_1$, …, P${}_n$ a${}_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.123

If such a surrogate call function is selected by overload resolution, the corresponding conversion function will be called to convert E to the appropriate function pointer or reference, and the function will then be invoked with the arguments of the call.

If the conversion function cannot be called (e.g., because of an ambiguity), the program is ill-formed.

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).

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