注入されたクラス名

int X;
struct X {
    void f() {
        X* p; // OK、 X は注入されたクラス名を参照します。
        ::X* q; // エラー、名前探索は変数名を発見します (変数名が構造体名を隠蔽します)。
    }
};

struct A {};
struct B : private A {};
struct C : public B {
    A* p; // エラー、注入されたクラス名 A はアクセス不可能です。
    ::A* q; // OK、注入されたクラス名は使用しません。
};

template <template <class, class> class> struct A;
 
template<class T1, class T2>
struct X {
    X<T1, T2>* p; // OK、 X はテンプレート名として扱われます。
    using a = A<X>; // OK、 X はテンプレート名として扱われます。
    template<class U1, class U2>
    friend class X; // OK、 X はテンプレート名として扱われます。
    X* q; // OK、 X は型名として扱われます (X<T1, T2> と同等です)。
};

template<>
struct X<void, void> {
    X* p; // OK、 X は型名として扱われます (X<void, void> と同等です)。
    template<class, class>
    friend class X; // OK、 X はテンプレート名として扱われます (プライマリテンプレートの場合と同じです)。
    X<void, void>* q; // OK、 X はテンプレート名として扱われます。
};
template<class T>
struct X<char, T> {
    X* p, q; // OK、 X は型名として扱われます (X<char, T> と同等です)。
    using r = X<int, int>; // OK、別の特殊化を表すために使用できます。
};

template<> class X<int, char> {
    class B {
        X a; // X<int, char> を意味します。
        template<class,class> friend class X; // ::X を意味します。
    };
};
template <class T> struct Base {
    Base* p;
};
template <class T> struct Derived: public Base<T> {
    typename Derived::Base* p; // Derived::Base<T> を意味します。
};
template<class T, template<class> class U = T::template Base> struct Third { };
Third<Derived<int>> t; // OK、デフォルト引数は注入されたクラス名をテンプレートとして使用します。

template <class T> struct Base {};
template <class T> struct Derived: Base<int>, Base<char> {
    typename Derived::Base b; // エラー、曖昧です。
    typename Derived::Base<double> d; // OK。
};

struct A {
    A();
    A(int);
    template<class T> A(T) {}
};
using A_alias = A;
 
A::A() {}
A_alias::A(int) {}
template A::A(double);
 
struct B : A {
    using A_alias::A;
};
 
A::A a; // エラー、 A::A は型ではなくコンストラクタを表すとみなされます。
struct A::A a2; // OK、「A a2;」と同じです。
B::A b; // OK、「A b;」と同じです。