Адрес перегруженной функции

Помимо выражений вызова функции, в которых выполняется разрешение перегрузки, имя перегруженной функции может встречаться в следующих 7 контекстах:

В каждом контексте перед именем перегруженной функции может стоять оператор взятия адреса &, а само имя может быть заключено в избыточный набор скобок.

Выбор функций

При взятии адреса перегруженной функции из набора перегрузки, на который ссылается имя перегруженной функции, выбирается набор S функций:

• Если целевого типа нет, выбираются все именованные функции, не являющиеся шаблонами.
• В противном случае функция, не являющаяся шаблоном, с типом F выбирается для типа функции FT целевого типа, если F (после возможного применения преобразования указателя на функцию)(начиная с C++17) идентичен FT.^[1]
• Специализация (если таковая имеется), полученная для каждого именованного шаблона функции в результате вывода аргументов шаблона, также добавляется в S.

Если целевой тип является типом указателя на функцию или ссылки на функцию, S может включать только функции, не являющиеся членами класса, функции-члены с явным объектом(начиная с C++23) и статические функции-члены. Если целевой тип является типом указателя на функцию-член, S может включать только функции-члены с неявным объектом.

Исключение функций

После формирования набора S функции исключаются в следующем порядке:

• Если в S остается более одной функции, все специализации шаблонов функций в S исключаются, если S также содержит функцию, не являющуюся шаблоном.

• Данная специализация шаблона функции spec исключается, если S содержит вторую специализацию шаблона функции, шаблон функции которой более специализирован, чем шаблон функции у spec.

После таких исключений (если они были) в S должна остаться ровно одна выбранная функция. В противном случае программа некорректна.

Пример

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

Отчеты об ошибках

Следующие отчеты об ошибках, изменяющие поведение, были ретроактивно применены к ранее опубликованным стандартам C++.

Ссылки

• Стандарт C++23 (ISO/IEC 14882:2024):
• 12.3 Адрес перегруженной функции [over.over]
• Стандарт C++20 (ISO/IEC 14882:2020):
• 12.5 Адрес перегруженной функции [over.over]
• Стандарт C++17 (ISO/IEC 14882:2017):
• 16.4 Адрес перегруженной функции [over.over]
• Стандарт C++14 (ISO/IEC 14882:2014):
• 13.4 Адрес перегруженной функции [over.over]
• Стандарт C++11 (ISO/IEC 14882:2011):
• 13.4 Адрес перегруженной функции [over.over]
• Стандарт C++98 (ISO/IEC 14882:1998):
• 13.4 Адрес перегруженной функции [over.over]