12 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.118

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 expressions ([basic.lookup]).

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

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-seq${}_{opt}$ ref-qualifier${}_{opt}$ noexcept-specifier${}_{opt}$ attribute-specifier-seq${}_{opt}$ ;

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 (${\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.120

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