Namensauflösung lokal deklarierte Namen

Der Name der Vorlage selbst kann mit oder ohne die Vorlagenargumente angegeben werden.Im Kontext einer Klassenvorlage bezieht sich der Name der Vorlage selbst an.Im Kontext einer Master spezialisierung oder der Teilausführungs spezialisierung bezieht sich der Name nicht die Spezialisierung oder Teilausführungs spezialisierung an.Andere Spezialisierungen oder Teilausführungs spezialisierungen der Vorlage können auch mit den entsprechenden Vorlagenargumenten verwiesen werden.

Beispiel

Der folgende Code zeigt, dass der Name der Klassenvorlage A nicht im Kontext einer Spezialisierung oder der Teilausführungs spezialisierung interpretiert wird.

// template_name_resolution3.cpp
// compile with: /c
template <class T> class A {
   A* a1;   // A refers to A<T>
   A<int>* a2;  // A<int> refers to a specialization of A.
   A<T*>* a3;   // A<T*> refers to the partial specialization A<T*>.
};

template <class T> class A<T*> {
   A* a4; // A refers to A<T*>.
};

template<> class A<int> {
   A* a5; // A refers to A<int>.
};

Im Falle eines Namenskonflikts zwischen einem Vorlagenparameter und einem anderen Objekt, kann der Vorlagenparameter oder kann nicht ausgeblendet werden.Die folgenden Regeln helfen, den Vorrang zu bestimmen.

Der Vorlagenparameter befindet sich im Gültigkeitsbereich aus dem Punkt, an dem sie zuerst bis das Ende der Klassen- oder Funktionsvorlage angezeigt wird.Wenn der Name erneut in der Vorlagenargumentliste oder in der Liste der Basisklassen wird, verweist er denselben Typ an.In Standard-C++ kann kein anderer Name, der dem Vorlagenparameter identisch ist, im selben Gültigkeitsbereich deklariert werden.Eine Microsoft-Erweiterung kann im Rahmen der Vorlage neu definiert werden. VorlagenparameterIm folgenden Beispiel wird mithilfe des Vorlagenparameters in der Spezifikation einer Klassenvorlage dar.

// template_name_resolution4.cpp
// compile with: /EHsc
template <class T>
class Base1 {};

template <class T>
class Derived1 : Base1<T> {};

int main() {
   // Derived1<int> d;
}

Wenn Sie die Memberfunktionen einer Vorlage außerhalb der Klassenvorlage definiert, kann ein anderer Name der Vorlagenparameter verwendet werden.Wenn die Definition memberfunktions einen anderen Namen für den Vorlagenparameter verwendet, als die Deklaration und der Name, der in den Definitions konflikten mit einem anderen Mitglied der Deklaration verwendet wird, weist der Member in der Vorlagendeklaration Vorrang.

// template_name_resolution5.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

template <class T> class C {
public:
   struct Z {
      Z() { cout << "Z::Z()" << endl; }
   };
   void f();
};

template <class Z>
void C<Z>::f() {
   // Z refers to the struct Z, not to the template arg;
   // Therefore, the constructor for struct Z will be called.
   Z z;
}

int main() {
   C<int> c;
   c.f();
}

Wenn eine Vorlagenfunktion oder - Memberfunktion außerhalb des Namespaces definiert, in dem die Vorlage deklariert wurde, hat das Vorlagenargument Vorrang vor den Namen anderer Member des Namespaces.

// template_name_resolution6.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

namespace NS {
   void g() { cout << "NS::g" << endl; }

   template <class T> struct C {
      void f();
      void g() { cout << "C<T>::g" << endl; }
   };
};

template <class T>
void NS::C<T>::f() {
   g(); // C<T>::g, not NS::g
};

int main() {
   NS::C<int> c;
   c.f();
}

In Definitionen, die außerhalb der Deklaration Vorlagenklassen werden, wenn eine Vorlagenklasse eine Basisklasse verfügt, die nicht von einem Vorlagenargument abhängig ist und wenn die Basisklasse oder seiner Member denselben Namen wie ein Vorlagenargument verfügt, blendet die Basisklasse oder der Membername das Vorlagenargument aus.

// template_name_resolution7.cpp
// compile with: /EHsc
#include <iostream>
using namespace std;

struct B {
   int i;
   void print() { cout << "Base" << endl; }
};

template <class T, int i> struct C : public B {
   void f();
};

template <class B, int i>
void C<B, i>::f() {
   B b;   // Base class b, not template argument.
   b.print();
   i = 1; // Set base class's i to 1.
}

int main() {
   C<int, 1> c;
   c.f();
   cout << c.i << endl;
}

Siehe auch

Referenz

Vorlagen und Namensauflösung