C++20模块私有片段为何无法像实现文件那样打破循环依赖？

测试环境：Visual Studio 2022 Preview

两种实现的差异 #

编译成功的分离式模块实现 #

这种实现将模块的接口和实现代码拆分到不同文件中：

ModuleA.ixx（模块接口文件）

export module ModuleA;
import ModuleB;

export class ClassA
{
public:
    ClassB foo;
    void sayHello();
};

ModuleA.cpp（模块实现文件）

module;
#include <iostream>
module ModuleA;

void ClassA::sayHello()
{
    std::cout << "Hello" << std::endl;
}

ModuleB.ixx（模块接口文件）

export module ModuleB;

export class ClassB
{
public:
    void sayHello();
};

ModuleB.cpp（模块实现文件）

module ModuleB;
import ModuleA;

void ClassB::sayHello()
{
    ClassA bar;
    bar.sayHello();
}

main.cpp

import ModuleB;

int main()
{
    ClassB baz;

    baz.sayHello();

    return 0;
}

报错的单文件私有片段实现 #

这种实现将模块的接口和实现放在同一个文件中，用module :private;标记私有实现部分：

ModuleA.ixx

export module ModuleA;
import ModuleB;

export class ClassA
{
public:
    ClassB foo;
    void sayHello();
};

module :private;
import <iostream>;

void ClassA::sayHello()
{
    std::cout << "Hello" << std::endl;
}

ModuleB.ixx

export module ModuleB;

export class ClassB
{
public:
    void sayHello();
};

module :private;
import ModuleA;

void ClassB::sayHello()
{
    ClassA bar;
    bar.sayHello();
}

为何一种可行另一种报错？ #

核心差异：编译单元的拆分与依赖解析 #

• 分离式实现可行的原因：
  分离式实现将模块拆分为接口编译单元（.ixx）和实现编译单元（.cpp）：

  1. ModuleA的接口仅依赖ModuleB的接口（import ModuleB;），此时ModuleB的接口已经导出了ClassB的完整类型声明，足以让ModuleA的ClassA声明ClassB foo;。
  2. ModuleB的实现文件（.cpp）属于独立的编译单元，它导入ModuleA的接口时，ModuleA的接口已经完成编译，ClassA的类型是完整的，因此可以创建ClassA bar;的实例。
  3. 编译器可以按依赖顺序分别处理各个编译单元，不会形成循环依赖。

• 私有片段实现报错的原因：
  私有片段（module :private;）属于同一个编译单元的一部分，无法拆分编译流程：

  1. 当编译ModuleB的.ixx文件时，即使import ModuleA;放在私有片段里，编译器需要处理整个文件的所有依赖。此时ModuleB的编译单元需要ModuleA的完整模块信息，但ModuleA的.ixx又依赖ModuleB的接口，形成了编译单元级别的循环依赖。
  2. 编译器无法确定先编译哪个模块的接口文件，因此抛出循环依赖错误。

简单来说：私有模块片段只是隐藏了实现细节，但无法像分离式实现那样通过拆分编译单元来打破循环依赖。分离式实现通过将接口和实现拆分，让接口之间的依赖可单向解析，实现代码对其他模块的依赖可以延后处理，从而避免循环依赖。

内容的提问来源于stack exchange，提问作者DobizGazer