C++
Argument Afhankelijke naam opzoeken

Welke functies zijn gevonden

Functies worden gevonden door eerst een set "bijbehorende klassen" en "bijbehorende naamruimten" te verzamelen die een of meer van de volgende items bevatten, afhankelijk van het argumenttype T Laten we eerst de regels weergeven voor namen van klassen, opsomming en specialisaties van klassensjablonen.

• Als T een geneste klasse is, opsomming van leden, dan is de omringende klasse ervan.
• Als T een opsomming is (het kan ook een lid van de klas zijn!), De binnenste naamruimte ervan.
• Als T een klasse is (deze kan ook worden genest!), Alle basisklassen en de klasse zelf. De binnenste naamruimte van alle bijbehorende klassen.
• Als T een ClassTemplate<TemplateArguments> (dit is ook een klasse!), De klassen en naamruimten die zijn gekoppeld aan de sjabloontype-argumenten, de naamruimte van een sjabloonsjabloonargument en de omringende klasse van een sjabloonsjabloonargument, als een sjabloonargument is een ledensjabloon.

Nu zijn er ook een paar regels voor ingebouwde typen

• Als T een pointer is naar U of een array van U , de klassen en naamruimten die aan U gekoppeld. Voorbeeld: void (*fptr)(A); f(fptr); , bevat de naamruimten en klassen die zijn geassocieerd met void(A) (zie volgende regel).
• Als T een functietype is, de klassen en naamruimten die zijn gekoppeld aan parameter- en retourtypen. Voorbeeld: void(A) zou de naamruimten en klassen bevatten die aan A gekoppeld.
• Als T een pointer naar lid is, zijn de klassen en naamruimten die aan het lidtype zijn gekoppeld (mogelijk van toepassing op zowel pointer naar lidfuncties als pointer naar gegevenslid!). Voorbeeld: BA::*p; void (A::*pf)(B); f(p); f(pf); bevat de naamruimten en klassen die zijn gekoppeld aan A , B , void(B) (hetgeen opsommingsteken hierboven van toepassing is voor functietypen).

Alle functies en sjablonen binnen alle bijbehorende naamruimten worden gevonden op basis van argumentafhankelijke zoekopdracht. Bovendien worden friendpace-scope friend-functies gevonden die zijn opgegeven in bijbehorende klassen , die normaal niet zichtbaar zijn. Het gebruik van richtlijnen wordt echter genegeerd.

Alle volgende voorbeeldoproepen zijn geldig, zonder f te kwalificeren op basis van de naamruimte in de oproep.

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!