C++ 在创建相互引用的类时，如何避免循环依赖和未定义的类型错误？

我想创建一些对象，这些对象可以将一些工作委托给其嵌套的子对象，但这会使我陷入循环依赖性问题。如果我只有两个类（

ClassA

和

ClassB

），那么使用

#ifndef

指令可以很好地工作，但是添加

ClassC

时，此模式不起作用。是否有可能实现如下代码所示的结构类型，并且不会出现“未定义类型”错误

ClassA.h

    #pragma once
    #include "CoreMinimal.h"
    
    #include "ClassB.h"
    class UClassB;
    
    #include ClassA.generated.h
    
    UCLASS()
    class PROJ_API UClassA : public UObject
    {
        GENERATED_BODY()
    
        UPROPERTY()
        UClassB* ObjB;
        
    public:
        void DoDelegation()
        {
            auto* ThisInstance = this;  
            ObjB = NewObject<UClassB>();        
            ObjB->DoWorkClassB(ThisInstance);
        }
    }

    
    #pragma once
    #include "CoreMinimal.h"
    
    //works nice
    #ifndef CLASSA_H
    #define CLASSA_H
    #include "ClassA.h"
    class UClassA;
    #endif
    
    //trying to use similar pattern which works with ClassA.h and ClassB.h 
    #include "ClassC.h"
    class UClassC;
    
    #include ClassB.generated.h
    
    UCLASS()
    class PROJ_API UClassB : public UObject
    {
        GENERATED_BODY()
    
        UPROPERTY()
        UClassC* ObjC;
        
    public:
        void DoDelegation()
        {
            auto* ThisInstance = this;  
            ObjC = NewObject<UClassC>();        
            ObjC->DoWorkClassC(ThisInstance);
        }
        
        void DoWorkClassB(UClassA* &ObjectClassA)
        {
            // do some stuff with ObjectClassA
        }
    }

创建相互引用的类

是否有可能实现如下代码所示的结构类型，并且不会出现“未定义类型”错误

当然可以。引用某个类的对象（例如带有指针）只需要声明另一个类，而不需要定义

---

简单的解决方法是在定义两个类之前声明这两个类。

我还不太清楚，但至少我理解了为什么前向声明第一次不起作用。严格来说，不建议使用内联实现的方法来处理此类引用类。如果函数是在cpp中实现的，那么它可以很好地编译。

使用指针的代码必须知道完整类型，这样就不能将其内联到类中。半相关：使用shared_ptr和weak_ptr。你也可以阅读更多关于“转发声明”的内容。我想你会在这里找到答案：