Address of an overloaded function

Neben Funktionsaufrufausdrücken , wo Überladungsauflösung stattfindet, kann der Name einer überladenen Funktion in den folgenden 7 Kontexten erscheinen:

In jedem Kontext darf der Name einer überladenen Funktion dem Adressoperator & vorangestellt werden und kann in einen redundanten Satz von Klammern eingeschlossen werden.

Auswahl von Funktionen

Wenn die Adresse einer überladenen Funktion genommen wird, wird eine Menge S von Funktionen aus dem Überladungssatz ausgewählt, auf den durch den Namen der überladenen Funktion verwiesen wird:

• Wenn es kein Ziel gibt, werden alle benannten Nicht-Template-Funktionen ausgewählt.
• Andernfalls wird eine Nicht-Template-Funktion mit Typ F für den Funktionstyp FT des Zieltyps ausgewählt, wenn F (nach möglicher Anwendung der Funktionszeigerkonvertierung ) (seit C++17) identisch mit FT ist. ^[1]
• Die Spezialisierung (falls vorhanden), die durch Template-Argumentableitung für jede benannte Funktionsvorlage generiert wird, wird ebenfalls zu S hinzugefügt.

Wenn das Ziel vom Typ Funktionszeiger oder Referenz auf Funktionstyp ist, S kann nur Nicht-Member-Funktionen enthalten , explizite Objekt-Member-Funktionen (seit C++23) und statische Member-Funktionen. Wenn das Ziel vom Typ Zeiger-auf-Member-Funktion ist, S kann nur implizite Objekt-Member-Funktionen enthalten.

1. ↑ Mit anderen Worten, die Klasse, von der die Funktion ein Mitglied ist, wird ignoriert, wenn der Zieltyp ein Zeiger-auf-Mitgliedsfunktion-Typ ist.

Eliminierung von Funktionen

Nach der Bildung der Menge S werden Funktionen in der folgenden Reihenfolge eliminiert:

• Wenn mehr als eine Funktion in S verbleibt, werden alle Funktions-Templatespezialisierungen in S eliminiert, falls S auch eine Nicht-Template-Funktion enthält.

• Jede gegebene Funktionstemplatespezialisierung spec wird eliminiert, falls S eine zweite Funktionstemplatespezialisierung enthält, deren Funktionstemplate spezialisierter als das Funktionstemplate von spec ist.

Nach solchen Eliminierungen (falls vorhanden) sollte genau eine ausgewählte Funktion in S verbleiben. Andernfalls ist das Programm fehlerhaft.

Beispiel

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. Initialisierung
    int (*pf)(double) = f; // wählt int f(double)
    int (&rf)(int) = f; // wählt int f(int)
    int (Foo::*mpf)(int) = &Foo::mf; // wählt int mf(int)
    // 2. Zuweisung
    pf = nullptr;
    pf = &f; // wählt int f(double)
    // 3. Funktionsargument
    g(f, f); // wählt int f(int) für das 1. Argument
             // und int f(double) für das zweite
    // 4. Benutzerdefinierter Operator
    Emp{} << f; // wählt int f(double)
    // 5. Rückgabewert
    auto foo = []() -> int (*)(int)
    {
        return f; // wählt int f(int)
    };
    // 6. Cast
    auto p = static_cast<int(*)(int)>(f); // wählt int f(int)
    // 7. Template-Argument
    Templ<f> t;  // wählt int f(int)
    // Verhindert "unused variable"-Warnungen wie durch [[maybe_unused]]
    [](...){}(pf, rf, mpf, foo, p, t);
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

Referenzen