C++
Argumentabhängige Namenssuche

Welche Funktionen gefunden werden

Funktionen werden gefunden, indem zuerst eine Gruppe von "verknüpften Klassen" und "verknüpften Namespaces" erfasst wird , die je nach Argumenttyp T einen oder mehrere der folgenden T . Lassen Sie uns zunächst die Regeln für die Klassennamen von Klassen, Enumeration und Klassenvorlagen anzeigen.

• Wenn T eine verschachtelte Klasse ist, Member-Enumeration, dann die umgebende Klasse.
• Wenn T eine Aufzählung ist (es kann auch ein Klassenmitglied sein!), Der innerste Namespace davon.
• Wenn T eine Klasse ist (kann auch geschachtelt sein!), Alle ihre Basisklassen und die Klasse selbst. Der innerste Namespace aller zugehörigen Klassen.
• Wenn T ein ClassTemplate<TemplateArguments> (dies ist auch eine Klasse!), Die mit den Vorlagentypargumenten verknüpften Klassen und Namespaces, der Namensraum eines Vorlagenvorlagenarguments und die umgebende Klasse eines Vorlagenvorlagenarguments, sofern ein Vorlagenargument vorhanden ist eine Mitgliedsvorlage

Nun gibt es auch ein paar Regeln für eingebaute Typen

• Wenn T ein Zeiger auf U oder ein Array von U , die mit U verknüpften Klassen und Namespaces. Beispiel: void (*fptr)(A); f(fptr); , enthält die mit void(A) verknüpften Namespaces und Klassen (siehe nächste Regel).
• Wenn T ein Funktionstyp ist, die mit Parameter- und Rückgabetypen verknüpften Klassen und Namespaces. Beispiel: void(A) enthält die mit A verknüpften Namespaces und Klassen.
• Wenn T ein Zeiger auf einen Member ist, werden die Klassen und Namespaces, die mit dem Member-Typ verknüpft sind (möglicherweise auf Zeiger auf Member-Funktionen und Zeiger auf Datenmitglied!) Angewendet. Beispiel: BA::*p; void (A::*pf)(B); f(p); f(pf); schließt die mit A , B , void(B) verknüpften Namespaces und Klassen A (wobei das Aufzählungszeichen oben für Funktionstypen gilt).

Alle Funktionen und Vorlagen in allen zugehörigen Namespaces werden durch eine argumentabhängige Suche gefunden. Außerdem werden in zugehörigen Klassen deklarierte Freundesfunktionen für den Namensbereich gefunden , die normalerweise nicht sichtbar sind. Die Verwendung von Direktiven wird jedoch ignoriert.

Alle folgenden Beispielaufrufe sind gültig, ohne f anhand des Namespace-Namens im Aufruf zu qualifizieren.

namespace A {
   struct Z { };
   namespace I { void g(Z); }
   using namespace I;

   struct X { struct Y { }; friend void f(Y) { } };
   void f(X p) { }
   void f(std::shared_ptr<X> p) { }
}

// example calls
f(A::X());
f(A::X::Y());
f(std::make_shared<A::X>());

g(A::Z()); // invalid: "using namespace I;" is ignored!