Address of an overloaded function

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.

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.

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.

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);
}

Defect reports

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

References