C++面试题：C++怎么避免头文件循环引用？

头文件循环引用是C++编程中常见的问题，通常发生在两个或多个头文件相互包含对方的情况下。这种情况下，编译器可能会陷入无限递归，导致编译错误或不正确的代码生成。

1、问题描述

首先看一个典型的循环引用场景:

// a.h
#ifndef A_H
#define A_H
#include "b.h"class A {B* b_ptr;  // 需要完整的B类定义
public:void doSomething();
};
#endif// b.h
#ifndef B_H
#define B_H
#include "a.h"class B {A* a_ptr;  // 需要完整的A类定义
public:void doSomething();
};
#endif

这会导致编译错误,因为两个头文件互相包含。

2、解决方案

2.1 前向声明

最常用也是最简单的方法：

// a.h
#ifndef A_H
#define A_Hclass B;  // 前向声明class A {B* b_ptr;  // 只需要不完整类型声明
public:void doSomething();
};
#endif// b.h
#ifndef B_H
#define B_Hclass A;  // 前向声明class B {A* a_ptr;  // 只需要不完整类型声明
public:void doSomething();
};
#endif// a.cpp
#include "a.h"
#include "b.h"  // 在实现文件中包含完整定义void A::doSomething() {b_ptr->doSomething();
}// b.cpp
#include "b.h"
#include "a.h"  // 在实现文件中包含完整定义void B::doSomething() {a_ptr->doSomething();
}

2.2 接口分离原则

循环引用的根本原因是设计上的问题。通过重构代码，减少类之间的直接依赖，可以从根本上解决问题。例如，可以考虑将共同的功能提取到一个独立的模块中，或者使用接口或抽象类来解耦类之间的关系

假设 A 和 B 之间有很强的依赖关系，可以通过引入一个中间类 C 来解耦：

引入类C

// C.h
#ifndef C_H
#define C_Hclass C {
public:virtual void doSomething() = 0;virtual ~C() = default;
};#endif // C_H

类A

// A.h
#ifndef A_H
#define A_H#include "C.h"  // 只依赖于 Cclass A:public C
{
public:C* m_Pc;;
public:void setProcessor(C* p) { m_Pc = p; }void doWork() { m_Pc->doSomething(); }void doSomething() override{std::cout << "A do something" << std::endl;}
};#endif // A_H

类B

// B.h
#ifndef B_H
#define B_H#include "C.h"  // 只依赖于 Cclass B : public C
{
public:C* m_Pc;;
public:void setProcessor(C* p) { m_Pc = p; }void doWork() { m_Pc->doSomething(); }public:void doSomething() override{std::cout << "B Do Something" << std::endl;}
};
#endif // B_H

main函数使用

#include <iostream>
#include "a.h"
#include "b.h"
#include "c.h"
int main()
{{C* pC = new B();A a;a.setProcessor(pC);a.doWork();}{C* pC = new A();B b;b.setProcessor(pC);b.doWork();}return 0;
}

运行main函数，a.dowork输出是B的内容，b.dowork是A的内容。

2.3 PIMPL模式

PIMPL模式不能直接解决循环依赖问题，但是这种做法很常见，所以这里简单介绍下

PIMPL（Pointer to IMPLementation，指向实现的指针）模式是一种用于隐藏类的实现细节的设计模式。它通过将类的私有成员和实现细节移到一个独立的实现类中，并在头文件中只保留一个指向该实现类的指针，PIMPL 模式的核心思想是将类的接口与其实现分离。

使用 PIMPL 模式重构代码

类A

// A.h
#ifndef A_H
#define A_Hclass A {
public:A();~A();void doSomething();private:class Impl;  // 前向声明实现类std::unique_ptr<Impl> pImpl;  // 指向实现类的智能指针
};#endif // A_H// A.cpp
#include "A.h"
#include "B.h"  // 只在 .cpp 文件中包含 B 的头文件class A::Impl {
public:B* m_B;  // 实现类中持有 B 的指针void doSomething() {if (m_B) {m_B->doSomething();}}
};A::A() : pImpl(std::make_unique<Impl>()) {pImpl->m_B = nullptr;
}A::~A() = default;void A::doSomething() {pImpl->doSomething();
}

类B

// B.h
#ifndef B_H
#define B_H
class B {
public:B(); ~B();void doSomething();private:class Impl;  // 前向声明实现类std::unique_ptr<Impl> pImpl;  // 指向实现类的智能指针
};#endif // B_H// B.cpp
#include "B.h"
#include "A.h"  // 只在 .cpp 文件中包含 A 的头文件class B::Impl {
public:A* m_A;  // 实现类中持有 A 的指针void doSomething() {if (m_A) {m_A->doSomething();}}
};B::B() : pImpl(std::make_unique<Impl>()) {pImpl->m_A = nullptr;
}B::~B() = default;void B::doSomething() {pImpl->doSomething();
}