• Log in

Besides function-call expressions, where overload resolution takes place, the name of an overloaded function may appear in the following 7 contexts:

In each context, the name of an overloaded function may be preceded by address-of operator & and may be enclosed in a redundant set of parentheses.

[edit] Selecting functions

When the address of an overloaded function is taken, a set S of functions is selected from the overload set referred to by the name of the overload function:

• If there is no target, all non-template functions named are selected.
• Otherwise, a non-template function with type F is selected for the function type FT of the target type if F (after possibly applying the function pointer conversion)(since C++17) is identical to FT.^[1]
• The specialization (if any) generated by template argument deduction for each function template named is also added to S.

If the target is of function pointer type or reference to function type, S can only include non-member functions, explicit object member functions(since C++23) and static member functions. If the target is of pointer-to-member-function type, S can only include implicit object member functions.

1. ↑ In other words, the class of which the function is a member is ignored if the target type is a pointer-to-member-function type.

[edit] Eliminating functions

After forming the set S, functions are elimiated in the following order:

• If more than one function in S remains, all function template specializations in S are eliminated if S also contains a non-template function.

• Any given function template specialization spec is eliminated if S contains a second function template specialization whose function template is more specialized than the function template of spec.

After such eliminations (if any), exactly one selected function should remain in S. Otherwise, the program is ill-formed.

[edit] Example

int f(int) { return 1; }
int f(double) { return 2; }
 
void g(int(&f1)(int), int(*f2)(double)) { f1(0); f2(0.0); }
 
template<int(*F)(int)>
struct Templ {};
 
struct Foo
{
 int mf(int) { return 3; }
 int mf(double) { return 4; }
};
 
struct Emp
{
 void operator<<(int (*)(double)) {}
};
 
int main()
{
 // 1. initialization
 int (*pf)(double) = f; // selects int f(double)
 int (&rf)(int) = f; // selects int f(int)
 int (Foo::*mpf)(int) = &Foo::mf; // selects int mf(int)
 
 // 2. assignment
 pf = nullptr;
 pf = &f; // selects int f(double)
 
 // 3. function argument
 g(f, f); // selects int f(int) for the 1st argument
 // and int f(double) for the second
 
 // 4. user-defined operator
 Emp{} << f; //selects int f(double)
 
 // 5. return value
 auto foo = []() -> int (*)(int)
 {
 return f; // selects int f(int)
 };
 
 // 6. cast
 auto p = static_cast<int(*)(int)>(f); // selects int f(int)
 
 // 7. template argument
 Templ<f> t; // selects int f(int)
 
 // prevent "unused variable" warnings as if by [[maybe_unused]]
 [](...){}(pf, rf, mpf, foo, p, t);
}

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] References

• In other languages

• Español
• 日本語
• Русский
• 中文