Unqualifizierte Namenssuche
Für einen nicht qualifizierten Namen, d. h. einen Namen, der nicht rechts von einem Bereichsauflösungsoperator :: erscheint, untersucht die Namensabfrage die Bereiche wie unten beschrieben, bis sie mindestens eine Deklaration irgendeiner Art findet, woraufhin die Abfrage stoppt und keine weiteren Bereiche mehr untersucht werden. (Hinweis: Die Abfrage aus bestimmten Kontexten überspringt einige Deklarationen, z. B. ignoriert die Abfrage des Namens, der links von :: verwendet wird, Funktions-, Variablen- und Aufzählungsdeklarationen, die Abfrage eines Namens, der als Basisklassenbezeichner verwendet wird, ignoriert alle Nicht-Typ-Deklarationen).
Für den Zweck der nicht qualifizierten Namensabfrage erscheinen alle Deklarationen aus einem Namensraum, der durch eine using-Direktive nominiert wird, so, als ob sie im nächstgelegenen umschließenden Namensraum deklariert wären, der sowohl die using-Direktive als auch den nominierten Namensraum direkt oder indirekt enthält.
Die nicht qualifizierte Namensabfrage des Namens, der links vom Funktionsaufrufoperator (und äquivalent dazu, dem Operator in einem Ausdruck) verwendet wird, ist in argumentabhängiger Abfrage beschrieben.
[bearbeiten] Dateibereich
Für einen Namen, der im globalen (Top-Level-Namensraum) Bereich außerhalb einer Funktion, Klasse oder eines benutzerdefinierten Namensraums verwendet wird, wird der globale Bereich vor der Verwendung des Namens untersucht.
int n = 1; // declaration of n int x = n + 1; // OK: lookup finds ::n int z = y - 1; // Error: lookup fails int y = 2; // declaration of y
[bearbeiten] Namensraumbereich
Für einen Namen, der in einem benutzerdefinierten Namensraum außerhalb einer Funktion oder Klasse verwendet wird, wird dieser Namensraum vor der Verwendung des Namens durchsucht, dann der Namensraum, der diesen Namensraum vor der Deklaration dieses Namensraums umschließt, usw., bis der globale Namensraum erreicht ist.
int n = 1; // declaration namespace N { int m = 2; namespace Y { int x = n; // OK, lookup finds ::n int y = m; // OK, lookup finds ::N::m int z = k; // Error: lookup fails } int k = 3; }
[bearbeiten] Definition außerhalb seines Namensraums
Für einen Namen, der in der Definition einer Namensraum-Mitgliedsvariablen außerhalb des Namensraums verwendet wird, verläuft die Abfrage genauso wie für einen Namen, der innerhalb des Namensraums verwendet wird.
namespace X { extern int x; // declaration, not definition int n = 1; // found 1st } int n = 2; // found 2nd int X::x = n; // finds X::n, sets X::x to 1
[bearbeiten] Nicht-Member-Funktionsdefinition
Für einen Namen, der in der Definition einer Funktion verwendet wird, entweder in ihrem Körper oder als Teil eines Standardarguments, wobei die Funktion ein Mitglied eines benutzerdefinierten oder globalen Namensraums ist, wird der Block, in dem der Name verwendet wird, vor der Verwendung des Namens durchsucht, dann wird der umschließende Block vor dem Beginn dieses Blocks durchsucht, usw., bis der Block erreicht ist, der der Funktionskörper ist. Dann wird der Namensraum, in dem die Funktion deklariert ist, bis zur Definition (nicht notwendigerweise der Deklaration) der Funktion, die den Namen verwendet, durchsucht, dann die umschließenden Namensräume, usw.
namespace A { namespace N { void f(); int i = 3; // found 3rd (if 2nd is not present) } int i = 4; // found 4th (if 3rd is not present) } int i = 5; // found 5th (if 4th is not present) void A::N::f() { int i = 2; // found 2nd (if 1st is not present) while (true) { int i = 1; // found 1st: lookup is done std::cout << i; } } // int i; // not found namespace A { namespace N { // int i; // not found } }
[bearbeiten] Klassendefinition
Für einen Namen, der irgendwo in einer Klassendefinition (einschließlich Basisklassenbezeichnern und verschachtelten Klassendefinitionen) verwendet wird, außer innerhalb eines Member-Funktionskörpers, eines Standardarguments einer Member-Funktion, einer Exception-Spezifikation einer Member-Funktion oder eines Standard-Member-Initialisierers, wobei das Mitglied zu einer verschachtelten Klasse gehören kann, deren Definition im Körper der umschließenden Klasse liegt, werden die folgenden Bereiche durchsucht:
Für eine friend-Deklaration verläuft die Abfrage zur Bestimmung, ob sie sich auf eine zuvor deklarierte Entität bezieht, wie oben beschrieben, außer dass sie nach dem innersten umschließenden Namensraum stoppt.
namespace M { // const int i = 1; // never found class B { // static const int i = 3; // found 3rd (but will not pass access check) }; } // const int i = 5; // found 5th namespace N { // const int i = 4; // found 4th class Y : public M::B { // static const int i = 2; // found 2nd class X { // static const int i = 1; // found 1st int a[i]; // use of i // static const int i = 1; // never found }; // static const int i = 2; // never found }; // const int i = 4; // never found } // const int i = 5; // never found
[bearbeiten] Eingefügter Klassenname
Für den Namen einer Klasse oder Klassenvorlage, der innerhalb der Definition dieser Klasse oder Vorlage oder einer davon abgeleiteten Klasse verwendet wird, findet die nicht qualifizierte Namensabfrage die definierte Klasse, so als ob der Name durch eine Member-Deklaration eingeführt worden wäre (mit öffentlichem Member-Zugriff). Weitere Details finden Sie unter eingefügter Klassenname.
[bearbeiten] Member-Funktionsdefinition
Für einen Namen, der innerhalb eines Member-Funktionskörpers, eines Standardarguments einer Member-Funktion, einer Exception-Spezifikation einer Member-Funktion oder eines Standard-Member-Initialisierers verwendet wird, sind die durchsuchten Bereiche die gleichen wie bei der Klassendefinition, mit der Ausnahme, dass der gesamte Bereich der Klasse betrachtet wird und nicht nur der Teil vor der Deklaration, die den Namen verwendet. Bei verschachtelten Klassen wird der gesamte Körper der umschließenden Klasse durchsucht.
class B { // int i; // found 3rd }; namespace M { // int i; // found 5th namespace N { // int i; // found 4th class X : public B { // int i; // found 2nd void f(); // int i; // found 2nd as well }; // int i; // found 4th } } // int i; // found 6th void M::N::X::f() { // int i; // found 1st i = 16; // int i; // never found } namespace M { namespace N { // int i; // never found } }
- In beiden Fällen werden bei der Untersuchung der Basen, von denen die Klasse abgeleitet ist, die folgenden Regeln befolgt, die manchmal als Dominanz bei virtueller Vererbung bezeichnet werden:
Ein Member-Name, der in einem Unterobjekt B gefunden wird, verdeckt denselben Member-Namen in jedem Unterobjekt A, wenn A ein Basisklassen-Unterobjekt von B ist. (Beachten Sie, dass dies nicht den Namen in zusätzlichen, nicht virtuellen Kopien von A im Vererbungsdiagramm verdeckt, die keine Basen von B sind: Diese Regel hat nur Auswirkungen auf die virtuelle Vererbung.) Namen, die durch using-Deklarationen eingeführt wurden, werden wie Namen in der Klasse behandelt, die die Deklaration enthält. Nach der Untersuchung jeder Basis muss die resultierende Menge entweder Deklarationen eines statischen Members aus Unterobjekten desselben Typs oder Deklarationen von Nicht-Static-Members aus demselben Unterobjekt enthalten. |
(bis C++11) |
Es wird ein Abfrageset konstruiert, das die Deklarationen und die Unterobjekte, in denen diese Deklarationen gefunden wurden, enthält. Using-Deklarationen werden durch die von ihnen repräsentierten Member ersetzt, und Typdeklarationen, einschließlich eingefügter Klassennamen, werden durch die von ihnen repräsentierten Typen ersetzt. Wenn C die Klasse ist, in deren Bereich der Name verwendet wurde, wird C zuerst untersucht. Wenn die Liste der Deklarationen in C leer ist, wird das Abfrageset für jede ihrer direkten Basen Bi aufgebaut (wobei diese Regeln rekursiv angewendet werden, wenn Bi eigene Basen hat). Sobald es aufgebaut ist, werden die Abfragesets für die direkten Basen in das Abfrageset in C wie folgt zusammengeführt:
|
(seit C++11) |
struct X { void f(); }; struct B1: virtual X { void f(); }; struct B2: virtual X {}; struct D : B1, B2 { void foo() { X::f(); // OK, calls X::f (qualified lookup) f(); // OK, calls B1::f (unqualified lookup) } }; // C++98 rules: B1::f hides X::f, so even though X::f can be reached from D // through B2, it is not found by name lookup from D. // C++11 rules: lookup set for f in D finds nothing, proceeds to bases // lookup set for f in B1 finds B1::f, and is completed // merge replaces the empty set, now lookup set for f in C has B1::f in B1 // lookup set for f in B2 finds nothing, proceeds to bases // lookup for f in X finds X::f // merge replaces the empty set, now lookup set for f in B2 has X::f in X // merge into C finds that every subobject (X) in the lookup set in B2 is a base // of every subobject (B1) already merged, so the B2 set is discarded // C is left with just B1::f found in B1 // (if struct D : B2, B1 was used, then the last merge would *replace* C's // so far merged X::f in X because every subobject already added to C (that is X) // would be a base of at least one subobject in the new set (B1), the end // result would be the same: lookup set in C holds just B1::f found in B1)
- Die nicht qualifizierte Namensabfrage, die statische Member von
B, verschachtelte Typen vonBund inBdeklarierte Aufzählungen findet, ist eindeutig, auch wenn es mehrere nicht virtuelle Basis-Unterobjekte vom TypBim Vererbungsbaum der untersuchten Klasse gibt.
struct V { int v; }; struct B { int a; static int s; enum { e }; }; struct B1 : B, virtual V {}; struct B2 : B, virtual V {}; struct D : B1, B2 {}; void f(D& pd) { ++pd.v; // OK: only one v because only one virtual base subobject ++pd.s; // OK: only one static B::s, even though found in both B1 and B2 int i = pd.e; // OK: only one enumerator B::e, even though found in both B1 and B2 ++pd.a; // error, ambiguous: B::a in B1 and B::a in B2 }
[bearbeiten] Friend-Funktionsdefinition
Für einen Namen, der in einer friend-Funktionsdefinition innerhalb des Körpers der Klasse verwendet wird, die die Freundschaft gewährt, verläuft die nicht qualifizierte Namensabfrage genauso wie für eine Member-Funktion. Für einen Namen, der in einer friend-Funktion verwendet wird, die außerhalb des Körpers einer Klasse definiert wird, verläuft die nicht qualifizierte Namensabfrage genauso wie für eine Funktion in einem Namensraum.
int i = 3; // found 3rd for f1, found 2nd for f2 struct X { static const int i = 2; // found 2nd for f1, never found for f2 friend void f1(int x) { // int i; // found 1st i = x; // finds and modifies X::i } friend int f2(); // static const int i = 2; // found 2nd for f1 anywhere in class scope }; void f2(int x) { // int i; // found 1st i = x; // finds and modifies ::i }
[bearbeiten] Friend-Funktionsdeklaration
Für einen Namen, der im Deklarator einer friend-Funktionsdeklaration verwendet wird, die eine Member-Funktion einer anderen Klasse befreundet, und der Name nicht Teil eines Template-Arguments im Deklarator-Identifikator ist, untersucht die nicht qualifizierte Abfrage zuerst den gesamten Bereich der Klasse der Member-Funktion. Wenn er in diesem Bereich nicht gefunden wird (oder wenn der Name Teil eines Template-Arguments im Deklarator-Identifikator ist), setzt sich die Abfrage fort, als ob es sich um eine Member-Funktion der Klasse handeln würde, die die Freundschaft gewährt.
template<class T> struct S; // the class whose member functions are friended struct A { typedef int AT; void f1(AT); void f2(float); template<class T> void f3(); void f4(S<AT>); }; // the class that is granting friendship for f1, f2 and f3 struct B { typedef char AT; typedef float BT; friend void A::f1(AT); // lookup for AT finds A::AT (AT found in A) friend void A::f2(BT); // lookup for BT finds B::BT (BT not found in A) friend void A::f3<AT>(); // lookup for AT finds B::AT (no lookup in A, because // AT is in the declarator identifier A::f3<AT>) }; // the class template that is granting friendship for f4 template<class AT> struct C { friend void A::f4(S<AT>); // lookup for AT finds A::AT // (AT is not in the declarator identifier A::f4) };
[bearbeiten] Standardargument
Für einen Namen, der in einem Standardargument in einer Funktionsdeklaration verwendet wird, oder einen Namen, der im Ausdruck-Teil eines Member-Initialisierers eines Konstruktors verwendet wird, werden zuerst die Funktionsparameter-Namen gefunden, bevor die umschließenden Block-, Klassen- oder Namensraum-Bereiche untersucht werden.
class X { int a, b, i, j; public: const int& r; X(int i): r(a), // initializes X::r to refer to X::a b(i), // initializes X::b to the value of the parameter i i(i), // initializes X::i to the value of the parameter i j(this->i) // initializes X::j to the value of X::i {} }; int a; int f(int a, int b = a); // error: lookup for a finds the parameter a, not ::a // and parameters are not allowed as default arguments
[bearbeiten] Statische Datenmember-Definition
Für einen Namen, der in der Definition eines statischen Datenmembers verwendet wird, verläuft die Abfrage genauso wie für einen Namen, der in der Definition einer Member-Funktion verwendet wird.
struct X { static int x; static const int n = 1; // found 1st }; int n = 2; // found 2nd int X::x = n; // finds X::n, sets X::x to 1, not 2
[bearbeiten] Enumerator-Deklaration
Für einen Namen, der im Initialisierer-Teil einer Enumerator-Deklaration verwendet wird, werden zuerst zuvor deklarierte Enumeratoren in derselben Aufzählung gefunden, bevor die nicht qualifizierte Namensabfrage mit der Untersuchung des umschließenden Block-, Klassen- oder Namensraum-Bereichs fortfährt.
const int RED = 7; enum class color { RED, GREEN = RED + 2, // RED finds color::RED, not ::RED, so GREEN = 2 BLUE = ::RED + 4 // qualified lookup finds ::RED, BLUE = 11 };
[bearbeiten] Handler eines Funktions- try-Blocks
Für einen Namen, der im Handler eines Funktions- try-Blocks verwendet wird, verläuft die Abfrage so, als ob es sich um einen Namen handelt, der ganz am Anfang des äußersten Blocks des Funktionskörpers verwendet wird (insbesondere sind Funktionsparameter sichtbar, aber Namen, die in diesem äußersten Block deklariert sind, nicht).
int n = 3; // found 3rd int f(int n = 2) // found 2nd try { int n = -1; // never found } catch(...) { // int n = 1; // found 1st assert(n == 2); // loookup for n finds function parameter f throw; }
[bearbeiten] Überladener Operator
Für einen Operator, der in einem Ausdruck verwendet wird (z. B. operator+ in a + b), sind die Abfrageregeln leicht unterschiedlich von denen für einen Operator, der in einem expliziten Funktionsaufruf-Ausdruck verwendet wird, wie z. B. operator+(a, b): Beim Parsen eines Ausdrucks werden zwei separate Abfragen durchgeführt: für Nicht-Member-Operatorüberladungen und für Member-Operatorüberladungen (für die Operatoren, bei denen beide Formen zulässig sind). Diese Mengen werden dann mit den integrierten Operatorüberladungen auf gleicher Basis wie in Überladungsauflösung zusammengeführt. Wenn eine explizite Funktionsaufrufsyntax verwendet wird, wird eine normale nicht qualifizierte Namensabfrage durchgeführt.
struct A {}; void operator+(A, A); // user-defined non-member operator+ struct B { void operator+(B); // user-defined member operator+ void f(); }; A a; void B::f() // definition of a member function of B { operator+(a, a); // error: regular name lookup from a member function // finds the declaration of operator+ in the scope of B // and stops there, never reaching the global scope a + a; // OK: member lookup finds B::operator+, non-member lookup // finds ::operator+(A, A), overload resolution selects ::operator+(A, A) }
[bearbeiten] Template-Definition
Für einen nicht abhängigen Namen, der in einer Template-Definition verwendet wird, findet die nicht qualifizierte Namensabfrage statt, wenn die Template-Definition untersucht wird. Die Bindung an die zu diesem Zeitpunkt gemachten Deklarationen wird nicht durch Deklarationen beeinflusst, die am Punkt der Instanziierung sichtbar sind. Für einen abhängigen Namen, der in einer Template-Definition verwendet wird, wird die Abfrage bis zur Bekanntheit der Template-Argumente verschoben. Zu diesem Zeitpunkt untersucht ADL Funktionsdeklarationen mit externer Verknüpfung(bis C++11), die aus dem Kontext der Template-Definition sowie aus dem Kontext der Template-Instanziierung sichtbar sind, während die Nicht-ADL-Abfrage nur Funktionsdeklarationen mit externer Verknüpfung(bis C++11) untersucht, die aus dem Kontext der Template-Definition sichtbar sind (mit anderen Worten, das Hinzufügen einer neuen Funktionsdeklaration nach der Template-Definition macht sie nicht sichtbar, außer über ADL). Das Verhalten ist undefiniert, wenn eine bessere Übereinstimmung mit externer Verknüpfung in den von der ADL-Abfrage untersuchten Namensräumen besteht, die in einer anderen Übersetzungseinheit deklariert wurde, oder wenn die Abfrage mehrdeutig gewesen wäre, wenn diese Übersetzungseinheiten untersucht worden wären. In jedem Fall, wenn eine Basisklasse von einem Template-Parameter abhängt, wird ihr Bereich nicht durch nicht qualifizierte Namensabfragen untersucht (weder am Punkt der Definition noch am Punkt der Instanziierung).
void f(char); // first declaration of f template<class T> void g(T t) { f(1); // non-dependent name: lookup finds ::f(char) and binds it now f(T(1)); // dependent name: lookup postponed f(t); // dependent name: lookup postponed // dd++; // non-dependent name: lookup finds no declaration } enum E { e }; void f(E); // second declaration of f void f(int); // third declaration of f double dd; void h() { g(e); // instantiates g<E>, at which point // the second and the third uses of the name 'f' // are looked up and find ::f(char) (by lookup) and ::f(E) (by ADL) // then overload resolution chooses ::f(E). // This calls f(char), then f(E) twice g(32); // instantiates g<int>, at which point // the second and the third uses of the name 'f' // are looked up and find ::f(char) only // then overload resolution chooses ::f(char) // This calls f(char) three times } typedef double A; template<class T> class B { typedef int A; }; template<class T> struct X : B<T> { A a; // lookup for A finds ::A (double), not B<T>::A };
Hinweis: Die Abfrageregeln für abhängige Namen geben Auskunft über die Gründe und Auswirkungen dieser Regel.
[bearbeiten] Template-Name
| Dieser Abschnitt ist unvollständig Grund: Dual-Scope-Abfrage des Template-Namens nach -> und .. |
[bearbeiten] Mitglied einer Klassenvorlage außerhalb der Vorlage
| Dieser Abschnitt ist unvollständig |
[bearbeiten] Fehlerberichte
Die folgenden Verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | angewendet auf | Verhalten wie veröffentlicht | Korrigiertes Verhalten |
|---|---|---|---|
| CWG 490 | C++98 | Jeder Name in einem Template-Argument eines Friend Member-Funktionsdeklaration wurde nicht gesucht in dem Bereich der Klasse der Member-Funktion |
schließt nur die Namen aus in Template-Argumenten in dem Deklarator-Identifikator |
| CWG 514 | C++98 | Jeder nicht qualifizierte Name, der in einem Namensraum verwendet wird Bereich wurde zuerst in diesem Bereich gesucht |
die nicht qualifizierten Namen, die zur Definition eines Namensraum-Variablenmembers außerhalb dieses Namensraums werden zuerst in diesem Namensraum gesucht |
[bearbeiten] Referenzen
- C++23 Standard (ISO/IEC 14882:2024)
- 6.5 Namensabfrage [basic.lookup] (S. 44-45)
- 6.5.2 Member-Namensabfrage [class.member.lookup] (S. 45-47)
- 13.8 Namensauflösung [temp.res] (S. 399-403)
- C++20 Standard (ISO/IEC 14882:2020)
- 6.5 Namensabfrage [basic.lookup] (S. 38-50)
- 11.8 Member-Namensabfrage [class.member.lookup] (S. 283-285)
- 13.8 Namensauflösung [temp.res] (S. 385-400)
- C++17 Standard (ISO/IEC 14882:2017)
- 6.4 Namensabfrage [basic.lookup] (S. 50-63)
- 13.2 Member-Namensabfrage [class.member.lookup] (S. 259-262)
- 17.6 Namensauflösung [temp.res] (S. 375-378)
- C++14 Standard (ISO/IEC 14882:2014)
- 3.4 Namensabfrage [basic.lookup] (S. 42-56)
- 10.2 Member-Namensabfrage [class.member.lookup] (S. 233-236)
- 14.6 Namensauflösung [temp.res] (S. 346-359)
- C++11 Standard (ISO/IEC 14882:2011)
- 3.4 Namensabfrage [basic.lookup]
- 10.2 Member-Namensabfrage [class.member.lookup]
- 14.6 Namensauflösung [temp.res]
- C++98 Standard (ISO/IEC 14882:1998)
- 3.4 Namensabfrage [basic.lookup]
- 10.2 Member-Namensabfrage [class.member.lookup]
- 14.6 Namensauflösung [temp.res]
