如何使用using指令拆分C++中的循环依赖问题

假设存在类A和类B，二者可互相构造，原代码通过分离声明与实现避免了循环依赖：

原代码实现 #

A.hpp #

#pragma once
class B;
class A {
  B foo();
};

A.cpp #

#include <A.hpp>
#include <B.hpp>
B A::foo(){ return B(); }

B.hpp #

#pragma once
class A;
class B {
  A foo();
};

B.cpp #

#include <B.hpp>
#include <A.hpp>
A B::foo(){ return A(); }

引入新类型后的问题 #

现在需要引入A_or_B类型，定义为std::variant<A, B>，并让A和B的foo()方法返回该类型，但调整代码后出现了类型解析错误：

尝试定义的A_or_B.hpp #

#pragma once

// 选项1：直接包含头文件会触发循环依赖
#include "A.hpp"
#include "B.hpp"
// 选项2：用前向声明，但std::variant需要完整类型，编译/链接会失败
// class A;
// class B;

using A_or_B = std::variant<A, B>;

修改后的A.hpp（报错版本） #

// A.hpp
#pragma once

#include "A_or_B.hpp" // 错误：A_or_B的类型无法解析
class A {
  A_or_B foo();
};

问题原因 #

• 若在A_or_B.hpp中直接包含A.hpp和B.hpp，由于头文件保护机制，会出现类型未定义问题（比如A.hpp包含A_or_B.hpp，而A_or_B.hpp又包含A.hpp，导致A的声明在A_or_B定义前未完成）。
• 若在A_or_B.hpp中使用A和B的前向声明，std::variant<A, B>实例化需要完整类型，会在编译或链接阶段报错。

A和B原本无循环依赖是因为声明与实现分离，但using定义的类型别名无法拆分声明与实现，因此触发了循环依赖问题。

解决方案 #

方案1：拆分A_or_B的声明与定义（推荐） #

通过前向声明A_or_B打破头文件循环，将具体定义放到确保完整类型可见的位置：

1. 修改A.hpp和B.hpp，仅前向声明A_or_B：

// A.hpp
#pragma once
class B;
class A_or_B; // 前向声明A_or_B

class A {
  A_or_B foo();
};

// B.hpp
#pragma once
class A;
class A_or_B; // 前向声明A_or_B

class B {
  A_or_B foo();
};

2. 完善A_or_B.hpp，确保包含A和B的完整类型：

// A_or_B.hpp
#pragma once
#include <variant>
#include "A.hpp"
#include "B.hpp"

using A_or_B = std::variant<A, B>;

3. 在实现文件中包含A_or_B.hpp以获取完整类型：

// A.cpp
#include "A_or_B.hpp"

A_or_B A::foo(){ return B(); }

// B.cpp
#include "A_or_B.hpp"

A_or_B B::foo(){ return A(); }

该方案保留了值语义，同时彻底打破头文件循环，是最贴合原需求的解决方案。

方案2：使用智能指针包装（适合允许修改返回类型的场景） #

如果业务逻辑允许返回指针，可通过智能指针包装A和B，此时std::variant可接受不完整类型的指针：

1. 定义A_or_B.hpp：

// A_or_B.hpp
#pragma once
#include <variant>
#include <memory>

class A;
class B;

using A_or_B = std::variant<std::unique_ptr<A>, std::unique_ptr<B>>;

2. 修改A.hpp和B.hpp直接包含A_or_B.hpp：

// A.hpp
#pragma once
#include "A_or_B.hpp"
class B;

class A {
  A_or_B foo();
};

3. 实现foo()方法时返回智能指针：

// A.cpp
#include "A.hpp"
#include "B.hpp"

A_or_B A::foo(){ return std::make_unique<B>(); }

该方案无需调整头文件包含顺序，但改变了返回值语义（从值变为智能指针），需根据业务场景评估适用性。

方案3：重构为基类多态（适合有公共接口的场景） #

如果A和B存在公共行为接口，可提取基类Base，用std::unique_ptr<Base>替代std::variant<A,B>：

1. 定义基类Base.hpp：

// Base.hpp
#pragma once
class Base {
public:
  virtual ~Base() = default;
  // 声明公共接口
};

2. 让A和B继承自Base：

// A.hpp
#pragma once
#include "Base.hpp"
class B;

class A : public Base {
  std::unique_ptr<Base> foo();
};

3. 实现时返回对应类型的智能指针：

// A.cpp
#include "A.hpp"
#include "B.hpp"

std::unique_ptr<Base> A::foo(){ return std::make_unique<B>(); }

该方案彻底消除循环依赖，但需要重构类型体系，仅适合A和B存在公共行为的场景。

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