Address of an overloaded function

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

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

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

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

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

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

1. ↑ Другими словами, класс, членом которого является функция, игнорируется, если целевой тип является типом указателя-на-функцию-член.

Устранение функций

После формирования множества 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. инициализация
    int (*pf)(double) = f; // выбирает int f(double)
    int (&rf)(int) = f; // выбирает int f(int)
    int (Foo::*mpf)(int) = &Foo::mf; // выбирает int mf(int)
    // 2. присваивание
    pf = nullptr;
    pf = &f; // выбирает int f(double)
    // 3. аргумент функции
    g(f, f); // выбирает int f(int) для первого аргумента
             // и int f(double) для второго
    // 4. пользовательский оператор
    Emp{} << f; // выбирает int f(double)
    // 5. возвращаемое значение
    auto foo = []() -> int (*)(int)
    {
        return f; // выбирает int f(int)
    };
    // 6. приведение типа
    auto p = static_cast<int(*)(int)>(f); // выбирает int f(int)
    // 7. аргумент шаблона
    Templ<f> t;  // выбирает int f(int)
    // предотвращение предупреждений "неиспользуемая переменная" как с помощью [[maybe_unused]]
    [](...){}(pf, rf, mpf, foo, p, t);
}

Отчеты о дефектах

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

Ссылки