Injected-class-name

int X;
struct X
{
    void f()
    {
        X* p;   // 正确：X 是注入类名
        ::X* q; // 错误：名称查找找到变量名，该名称隐藏了结构体名称
    }
};
template<class T>
struct Y
{
    void g()
    {
        Y* p;    // 正确：Y 是注入类名
        Y<T>* q; // 正确：Y 是注入类名，但 Y<T> 不是
    }
};

struct A {};
struct B : private A {};
struct C : public B
{
    A* p;   // 错误：注入类名 A 不可访问
    ::A* q; // 正确，不使用注入类名
};

template<template<class, class> class>
struct A;
template<class T1, class T2>
struct X
{
    X<T1, T2>* p;   // 正确：X 被视为模板名称
    using a = A<X>; // 正确：X 被视为模板名称
    template<class U1, class U2>
    friend class X; // 正确：X 被视为模板名称
    X* q;           // 正确：X 被视为类型名称，等价于 X<T1, T2>
};

template<>
struct X<void, void>
{
    X* p; // 正确：X 被视为类型名称，等价于 X<void, void>
    template<class, class>
    friend class X; // 正确：X 被视为模板名称（与主模板中相同）
    X<void, void>* q; // 正确：X 被视为模板名称
};
template<class T>
struct X<char, T>
{
    X* p, q; // 正确：X 被视为类型名称，等价于 X<char, T>
    using r = X<int, int>; // 正确：可用于命名其他特化
};

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; // 正确：Base 表示 Base<T>
};
template<class T>
struct Derived : public Base<T*>
{
    typename Derived::Base* p; // 正确：Derived::Base 表示 Derived<T>::Base，
                               // 即 Base<T*>
};
template<class T, template<class> class U = T::template Base>
struct Third {};
Third<Derived<int>> t; // 正确：默认参数使用注入类名作为模板

template<class T>
struct Base {};
template<class T>
struct Derived: Base<int>, Base<char>
{
    typename Derived::Base b;         // 错误：存在歧义
    typename Derived::Base<double> d; // 正确
};

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; // 正确，等同于 'A a2;'
B::A b;         // 正确，等同于 'A b;'