如何解决编程中的循环依赖问题（CPP）

循环依赖是编程中常常遇到的问题,为什么会出现循环依赖报错？因为我创建A对象，必须知道B的大小，而B对象的大小又依赖于A的大小。造成死循环。下面是一个常见的循环依赖。

class A
{
  B temp;  
};
​
class B
{
  A temp;  
};

指针？

如果你学了指针，可以暂时逃避一下这个问题。因为64位操作系统的指针大小是固定的，都是8字节。所以你这么写，编译器就知道内存该怎么分配了。然而这并不是真正的问题解决方法。真正该做的，是去理清类的关系，解耦类。

** ClassA.h **

#ifndef CLASSA_H
#define CLASSA_H
​
#include "ClassB.h"  // ClassA 需要访问 ClassB，因此包含 ClassB.h
​
class ClassB;  // 前向声明 ClassB，以避免完全包含 ClassB.h，但这并不解决循环依赖的问题
​
class ClassA {
public:
    ClassA();
    void setB(ClassB* b);  // ClassA 中使用 ClassB 指针作为成员变量或者函数参数
private:
    ClassB* bInstance;
};
​
#endif // CLASSA_H

ClassB.h

#ifndef CLASSB_H
#define CLASSB_H
​
#include "ClassA.h"  // ClassB 需要访问 ClassA，因此包含 ClassA.h
​
class ClassA;  // 前向声明 ClassA
​
class ClassB {
public:
    ClassB();
    void setA(ClassA* a);  // ClassB 中使用 ClassA 指针作为成员变量或者函数参数
private:
    ClassA* aInstance;
};
​
#endif // CLASSB_H

在这个例子中，ClassA.h 和 ClassB.h 互相包含对方的头文件，导致了循环依赖的问题。编译器在处理这种情况时可能会报错，因为它无法在编译 ClassA 或 ClassB 时正确地解析它们的成员变量或函数参数，从而导致编译失败。

为了解决这个问题，可以使用前向声明来代替完全包含对方的头文件，或者重新设计类之间的依赖关系，使得不同类之间的依赖更清晰和单向。

多态！

基于多态的解决方案的核心思想是引入一个抽象的接口（或纯虚基类），并让原本直接相互依赖的类通过这个接口进行交互，而不是直接包含对方的具体类定义。这样做的好处是减少了类之间的耦合度，并解决了循环依赖的问题。

具体来说：

1. 定义抽象接口：创建一个接口类（通常是一个包含纯虚函数的抽象基类），这个接口定义了类A和类B之间需要交互的方法。

2. 类A的设计：类A不再直接包含类B的对象或引用，而是包含一个指向接口类的指针。这样，类A就无需知道类B的具体实现，只需要知道它实现了某个接口。

3. 类B的实现：类B继承自接口类，并实现接口中定义的所有纯虚函数。这样，类B就成为了一个具体的实现类，同时保持了与类A的松耦合关系。

基于多态的解决方案可以通过使用接口类（interface）来解决循环依赖的问题。让我们以一个简单的例子来说明：

假设有两个类 ClassA 和 ClassB，它们需要相互引用对方的类型。

Interface0.h （接口类的定义）

#ifndef INTERFACE_H
#define INTERFACE_H
​
// 前向声明
class Interface {
public:
    virtual void doSomething() = 0;
};
​
#endif // INTERFACE_H

ClassA1.h

#ifndef CLASSA_H
#define CLASSA_H
​
#include "Interface.h"
​
class ClassA {
public:
    ClassA();
    void setB(Interface* b);  // 使用接口类的指针作为成员变量或者函数参数
private:
    Interface* bInstance;
};
​
#endif // CLASSA_H

ClassA.cpp

#include "ClassA.h"
​
ClassA::ClassA() : bInstance(nullptr) {}
​
void ClassA::setB(Interface* b) {
    bInstance = b;
}

ClassB1.h

#ifndef CLASSB_H
#define CLASSB_H
​
#include "Interface.h"
​
class ClassB : public Interface {
public:
    ClassB();
    void setA(Interface* a);  // 使用接口类的指针作为成员变量或者函数参数
    void doSomething() override;  // 实现接口方法
private:
    Interface* aInstance;
};
​
#endif // CLASSB_H

ClassB.cpp

#include "ClassB.h"
​
ClassB::ClassB() : aInstance(nullptr) {}
​
void ClassB::setA(Interface* a) {
    aInstance = a;
}
​
void ClassB::doSomething() {
    // 实现接口方法的具体逻辑
}