C++标准是否允许类定义间的这种双向依赖？

这是个非常细节且有意思的问题，涉及C++模板系统中延迟实例化和依赖名称查找的核心规则，咱们结合你的例子一步步分析：

核心结论 #

先给个明确答案：你的代码是完全符合C++标准的，不是编译器的“巧合”，而是合理利用了模板的设计规则。

第一个例子：交换成员声明导致编译失败的原因 #

先看你能编译通过的原代码：

template <class Sum> struct A { 
    using X = char; // (1) 非依赖类型别名
    using Z = typename Sum::B::Y; // (2) 依赖类型别名
};
template <class Sum> struct B { 
    using Y = typename Sum::A::X; // 依赖类型别名
};
struct AplusB { 
    using A = ::A<AplusB>; 
    using B = ::B<AplusB>; 
};
AplusB::A::Z z; // 触发Z的实例化
int main() {}

编译通过的原理： #

C++标准规定了按需实例化（懒实例化）规则：

1. 当你使用AplusB::A::Z时，编译器才会实例化A<AplusB>中与Z相关的部分。
2. 实例化A<AplusB>时，会先处理所有非依赖的成员（比如X = char;），这一步完成后，A<AplusB>::X就已经是有效的类型了。
3. 接下来解析Z的定义，需要查找Sum::B::Y（也就是B<AplusB>::Y），这会触发B<AplusB>的实例化。
4. B<AplusB>中的Y是依赖名称（依赖于模板参数Sum），此时A<AplusB>::X已经存在，所以Y可以成功解析为char，Z也就被定义为char，编译通过。

交换(1)(2)后失败的原因： #

如果把A中的两行交换：

template <class Sum> struct A { 
    using Z = typename Sum::B::Y; // (2) 现在先声明这个依赖别名
    using X = char; // (1) 后声明非依赖别名
};

此时实例化顺序被打乱：

1. 当使用AplusB::A::Z时，首先需要解析Z的定义，触发B<AplusB>的实例化。
2. B<AplusB>中的Y需要查找Sum::A::X（即A<AplusB>::X），但此时A<AplusB>的X还没有被实例化（因为X的声明在Z之后，A的成员是按顺序处理的），所以编译器找不到X，报错no type named 'X' in 'A'。

第二个例子：使用顺序影响实例化结果 #

你的第二个例子本质和第一个一致：

template <class Sum> struct A { using X = char; using P = typename Sum::B::Q; };
template <class Sum> struct B { using Y = typename Sum::A::X; using Q = int; };
struct AplusB { using A = ::A<AplusB>; using B = ::B<AplusB>; };
AplusB::A::X z; // (1) 先触发A的实例化
AplusB::B::Q t; // (2) 后触发B的实例化
int main() {}

原代码编译通过的原理： #

1. AplusB::A::X z;触发A<AplusB>的实例化，先处理非依赖的X = char;，而P是依赖名称，暂时不解析。
2. AplusB::B::Q t;触发B<AplusB>的实例化，处理非依赖的Q = int;，Y是依赖名称，此时A<AplusB>::X已经存在，不会报错。

交换(1)(2)后失败的原因： #

交换后先执行AplusB::B::Q t;：

1. 触发B<AplusB>的实例化，先处理Q = int;，但Y是依赖名称，需要A<AplusB>::X，此时A<AplusB>还未被实例化。
2. 之后执行AplusB::A::X z;触发A<AplusB>的实例化，处理X = char;，然后解析P = typename Sum::B::Q;——此时B<AplusB>的Q已经存在，理论上应该没问题？但你提到报错no type named 'Q' in 'B'，这其实是因为部分编译器在实例化B<AplusB>时，会提前检查依赖名称的有效性，而此时A<AplusB>未实例化导致连锁反应，但核心逻辑还是：使用顺序决定了实例化顺序，依赖的成员必须在被查找前已经被实例化。

总结：为什么这种写法符合标准？ #

C++标准明确允许这种“循环依赖”的模板定义，只要满足：

• 依赖于模板参数的名称（比如typename Sum::B::Y）的解析被延迟到模板实例化时。
• 当需要解析某个依赖名称时，对应的目标类型/成员已经被实例化完成。

这种写法的正确性完全依赖于成员的使用顺序，只要保证被依赖的成员先被实例化，代码就能正常编译——这也是为什么交换代码行后会失败的原因：它颠倒了实例化的顺序，导致某个依赖的成员还未被定义。

内容的提问来源于stack exchange，提问作者D. Dmitriy