1
// GC 的标记过程（概念代码，不是真实实现）：
2
void GarbageCollector::Mark()
3
{
4
    // 第一步：从 Root Set 出发
5
    TArray<UObject*> RootSet = GetRootSet();
6
    // Root Set 包含：
7
    //   - UGameInstance
8
    //   - UWorld（当前关卡）
9
    //   - 所有显式调用 AddToRoot() 的对象
10
    //   - 所有加载到内存中的 UPackage
11

12
    TArray<UObject*> ReachableObjects;
13

14
    for (UObject* Root : RootSet)
15
    {
16
        MarkRecursive(Root, ReachableObjects);
17
    }
18
}
19

20
void GarbageCollector::MarkRecursive(UObject* Obj, TArray<UObject*>& OutReachable)
21
{
22
    if (OutReachable.Contains(Obj)) return;  // 已标记，跳过
23
    OutReachable.Add(Obj);
24

25
    // 遍历这个对象的所有 UPROPERTY
26
    // GC 通过反射系统知道每个 UPROPERTY 的偏移量和类型
27
    for (FProperty* Property : GetClassProperties(Obj->GetClass()))
28
    {
29
        if (FObjectProperty* ObjProp = CastField<FObjectProperty>(Property))
30
        {
31
            // 这是一个 UObject* 类型的属性
32
            UObject* ReferencedObj = ObjProp->GetObjectPropertyValue(Obj);
33
            if (ReferencedObj)
34
            {
35
                MarkRecursive(ReferencedObj, OutReachable);
36
            }
37
        }
38
        else if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(Property))
39
        {
40
            // 这是一个 TArray<UObject*> 类型的属性
41
            FScriptArrayHelper Helper(ArrayProp, Property->GetValuePtr(Obj));
42
            for (int i = 0; i < Helper.Num(); i++)
43
            {
44
                UObject* Element = *(UObject**)Helper.GetRawPtr(i);
45
                if (Element) MarkRecursive(Element, OutReachable);
46
            }
47
        }
48
        // else: int, float, FString... 不包含 UObject 引用，跳过
49
    }
50
}

1
UCLASS()
2
class UMyObject : public UObject
3
{
4
    GENERATED_BODY()
5

6
    // ==== 以下引用会被 GC 追踪 ====
7

8
    UPROPERTY()
9
    UObject* SafeRef;                    // ✓ UPROPERTY + UObject* → GC 能看见
10

11
    UPROPERTY()
12
    TArray<UObject*> SafeArray;          // ✓ TArray<UObject*> + UPROPERTY → GC 遍历每个元素
13

14
    UPROPERTY()
15
    TMap<int, UObject*> SafeMap;         // ✓ TMap 的 Value 是 UObject* → GC 追踪
16

17
    UPROPERTY()
18
    TSet<UObject*> SafeSet;
19

20
    // ==== 以下引用 GC 看不见！====
21

22
    UObject* NakedRef;                   // ✗ 没有 UPROPERTY → GC 不知道这里引用了对象
23

24
    TArray<UObject*> NakedArray;         // ✗ 同上
25

26
    // 在函数栈上的引用
27
    void SomeFunction()
28
    {
29
        UObject* LocalRef = LoadObject<UObject>(...);
30
        // 如果 LocalRef 是最后一个引用，函数返回后对象立即变得"不可达"
31
        // 下一次 GC 时被回收
32
    }
33
};

1
// 核心机制：时间片驱动（Time-Sliced）
2
// 引擎内部通过 IncrementalPurgeGarbage() 实现
3

4
// 简化版概念代码：
5
void IncrementalPurgeGarbage(bool bUseTimeLimit, float TimeLimit)
6
{
7
    static TArray<UObject*> PendingDestroyObjects;  // 待销毁队列
8

9
    double StartTime = FPlatformTime::Seconds();
10

11
    while (PendingDestroyObjects.Num() > 0)
12
    {
13
        UObject* Obj = PendingDestroyObjects.Pop();
14
        Obj->ConditionalBeginDestroy();  // 销毁一个对象
15

16
        // 关键：每销毁一个对象后检查时间
17
        if (bUseTimeLimit &&
18
            FPlatformTime::Seconds() - StartTime > TimeLimit)
19
        {
20
            // 本帧时间用完了！剩下的下一帧继续
21
            break;
22
        }
23
    }
24
    // 如果队列没清空，下一帧 World::Tick 中会继续调用此函数
25
}
26

27
// 引擎默认配置：
28
// - IncrementalBeginDestroyEnabled = true（默认开启）
29
// - 单帧最大耗时约 2ms（可配置：GGarbageCollectionTimeLimit）
30
// - 首次 GC 触发后，每帧都调用 IncrementalPurgeGarbage 直到队列清空

1
// NewObject：创建不挂载到关卡中的 UObject
2
// 适用场景：数据资产、运行时临时对象、子系统
3

4
// 最简形式：
5
UMyObject* Obj = NewObject<UMyObject>();
6

7
// 指定 Outer（GC 的容器概念）：
8
UMyObject* Obj = NewObject<UMyObject>(OuterPackage);
9

10
// 指定类（运行时动态决定类型）：
11
UClass* DynamicClass = LoadClass<UMyObject>(nullptr, TEXT("/Game/MyBP.MyBP_C"));
12
UMyObject* Obj = NewObject<UMyObject>(GetTransientPackage(), DynamicClass);
13

14
// ⚠️ 注意：蓝图类没有 C++ 的 StaticClass()！
15
// 蓝图类在运行时是动态生成的 UBlueprintGeneratedClass 实例。
16
// 要使用蓝图类创建对象，必须通过 TSubclassOf 或 LoadClass 获取其 UClass*：
17

18
// 方式 1：通过 TSubclassOf（成员变量，编辑器中指定）
19
UPROPERTY(EditAnywhere)
20
TSubclassOf<UMyObject> ObjectClass;  // 编辑器中可选择 "BP_MyObject"
21

22
UMyObject* Obj = NewObject<UMyObject>(this, ObjectClass);
23

24
// 方式 2：通过 LoadClass（运行时按路径加载）
25
TSubclassOf<UMyObject> LoadedClass = LoadClass<UMyObject>(
26
    nullptr, TEXT("/Game/Blueprints/BP_MyObject.BP_MyObject_C"));
27
//                                                       ↑ _C 后缀 = 类本身
28
UMyObject* Obj2 = NewObject<UMyObject>(this, LoadedClass);

1
// SpawnActor：创建 Actor 并注册到关卡中
2
// 适用场景：角色、道具、子弹——任何需要在关卡中存在的对象
3

4
// 最简形式：
5
AMyActor* Actor = GetWorld()->SpawnActor<AMyActor>();
6

7
// 指定位置和旋转：
8
FVector Location(0, 0, 100);
9
FRotator Rotation(0, 90, 0);
10
AMyActor* Actor = GetWorld()->SpawnActor<AMyActor>(Location, Rotation);
11

12
// 指定 SpawnParameters：
13
FActorSpawnParameters Params;
14
Params.SpawnCollisionHandlingOverride =
15
    ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButAlwaysSpawn;
16
Params.Owner = this;
17
Params.Instigator = GetInstigator();
18
AMyActor* Actor = GetWorld()->SpawnActor<AMyActor>(Location, Rotation, Params);
19

20
// SpawnActor 是同步阻塞操作，返回时 Actor 已完全构造好（包括组件初始化、
21
// 蓝图 Construction Script、PostInitializeComponents、BeginPlay 全部执行完毕）
22

23
// ==== SpawnActor 内部完整生命周期链条（大厂面试高频） ====
24
//
25
// 1. NewObject<AMyActor>()           — 分配内存，构造 C++ 对象
26
// 2. InitProperties()                — 用默认值初始化所有 UPROPERTY
27
// 3. PostActorCreated()              — C++ 诞生回调（对象存在了，但还不知道自己是谁）
28
// 4. PostInitializeComponents()      — 所有组件初始化完毕
29
//    （关键：此时 C++ 组件已完全构建并初始化，可以安全访问）
30
// 5. 执行蓝图 Construction Script    — 通过 AActor::OnConstruction() 调用蓝图构造脚本
31
//    （架构逻辑：引擎必须等组件 Ready 之后才执行蓝图构造脚本——
32
//     否则策划在构造脚本中获取 C++ 组件、修改属性或动态挂载子组件时，
33
//     会因 C++ 组件尚未初始化而导致空指针或资产数据丢失崩溃）
34
// 6. OnActorSpawned() (FActorSpawnedDelegate) — 广播 Actor 已生成
35
// 7. BeginPlay()                     — 游戏开始（关卡开始或生成后首帧 Tick 前）
36
//
37
// 常规 SpawnActor 返回时机：全部 7 步执行完毕后返回（同步阻塞）
38
// → 返回时 Actor 已完成组件初始化、构造脚本、BeginPlay
39
// → 你拿到的是一个完整的成型对象，所有蓝图属性已生效
40
//
41
// ==== 延迟生成 SpawnActorDeferred（唯一在步骤间返回的路径）====
42
// 只有使用 SpawnActorDeferred 时，引擎才会在步骤 3 和 4 之间提前返回：
43
//   AMyActor* Actor = GetWorld()->SpawnActorDeferred<AMyActor>(...);
44
//   // ↑ 此时 PostActorCreated 已调用，但 PostInitializeComponents 尚未执行！
45
//   // 你可以在这里手动设置属性，作为后续初始化的"初始参数"
46
//   Actor->CustomParameter = SomeValue;
47
//   Actor->FinishSpawning(Transform);  // 此时才执行 PostInitComponents → Construction Script → BeginPlay
48
//
49
// 面试陷阱：面试官常问"SpawnActor 返回时 BeginPlay 执行了吗？"
50
// 标准答案：常规 SpawnActor → 已执行；SpawnActorDeferred → 未执行，等 FinishSpawning

1
### 3.4.3 CreateDefaultSubobject —— 创建"内置组件"
2

3
```cpp
4
// CreateDefaultSubobject：在 Actor 的构造函数中创建子对象
5
// 适用场景：Actor 的组件——每个实例都有、随 Actor 一起创建/销毁
6

7
UCLASS()
8
class AMyActor : public AActor
9
{
10
    GENERATED_BODY()
11

12
public:
13
    AMyActor()
14
    {
15
        // 在构造函数中创建组件
16
        // 第一个参数：组件名（必须唯一，用于编辑器识别）
17
        MeshComponent = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("Mesh"));
18
        RootComponent = MeshComponent;  // 通常第一个组件设为 RootComponent
19

20
        HealthComponent = CreateDefaultSubobject<UHealthComponent>(TEXT("Health"));
21
    }
22

23
private:
24
    UPROPERTY(VisibleAnywhere)
25
    UStaticMeshComponent* MeshComponent;
26

27
    UPROPERTY(VisibleAnywhere)
28
    UHealthComponent* HealthComponent;
29
};
30

31
// CreateDefaultSubobject 的特点：
32
// 1. 只能在构造函数中调用
33
// 2. 创建的组件会被序列化到 Actor 的数据中（保存/加载保留）
34
// 3. 组件名字是唯一的——不能在同一 Actor 中创建两个同名的 Component

1
// Actor 有额外的销毁逻辑：
2
void AMyActor::OnSomeEvent()
3
{
4
    // 请求销毁
5
    Destroy();
6
    // ⚠️ Destroy() 返回后，Actor 并没有立即被释放！
7
    // 它只是被标记为 Garbage（通过 MarkAsGarbage()）
8
    // 真正的释放要等 GC 清扫（参见 3.3.1 的 Incremental Purge）
9

10
    // 之后的多帧内：
11
    // - Actor 停止 Tick
12
    // - Actor 从 Level 中移除
13
    // - 等待 GC 分帧清扫
14
}
15

16
// 销毁过程中的关键回调：
17
void AMyActor::EndPlay(const EEndPlayReason::Type Reason)
18
{
19
    Super::EndPlay(Reason);
20
    // Destroy() 后立即调用
21
    // 在这里做：停止音效、取消定时器、通知关联系统...
22
    // BeginPlay 的对偶操作
23
}
24

25
void AMyActor::BeginDestroy()
26
{
27
    Super::BeginDestroy();
28
    // GC 准备删除时调用
29
    // 在这里做：释放非 UObject 资源（文件句柄、线程...）
30
}
31

32
// ⚠️ Destroy() 后指针仍然不是 nullptr！
33
void AMyActor::SomeFunction()
34
{
35
    Destroy();
36
    UE_LOG(LogTemp, Log, TEXT("%s"), *GetName());  // 还能用！对象没释放
37
    // 但被标记为 Garbage 后，IsValid() 已经返回 false
38
    // 并且 GC 清扫后，这就是野指针了
39
}
40

41
// 正确做法：Destroy() 后立即 return
42
void AMyActor::Die()
43
{
44
    Destroy();
45
    return;  // ← 必须在 Destroy() 后立即结束函数
46
}

1
### 3.5.3 非 Actor 的 UObject：MarkAsGarbage()
2

3
```cpp
4
// 对于不是 Actor 的 UObject，不能调 Destroy()（那是 AActor 专属）
5
// 正确的停止方式：
6

7
UMyObject* Obj = NewObject<UMyObject>();
8

9
// 方式 1：让 GC 来处理（推荐）
10
// 清除所有 UPROPERTY 引用 → GC 下次运行时自动回收
11
Obj = nullptr;  // 如果这是唯一的 UPROPERTY 引用
12

13
// 方式 2：手动标记为垃圾（UE5 标准写法）
14
// 将对象注册到 GC 的垃圾队列，等待 GC 分帧清扫
15
Obj->MarkAsGarbage();
16
Obj = nullptr;  // 置空自己的引用
17

18
// ⚠️ 旧版 UE4 使用 ConditionalBeginDestroy()——那是引擎内部调用的，
19
// 外部代码不应直接调用。在 UE5 中，正确的外部接口是 MarkAsGarbage()
20

21
// 方式 3：加入 Root 后再移除（精确控制生命周期的场景）
22
Obj->AddToRoot();       // 标记为 GC Root，永远不会被回收
23
// ... 使用对象 ...
24
Obj->RemoveFromRoot();  // 不再保护，GC 下次运行时回收

1
// 标准 C++：nullptr 检查就够了
2
std::shared_ptr<MyClass> ptr = /* ... */;
3
if (ptr != nullptr) { ptr->DoSomething(); }  // OK
4

5
// UE C++：nullptr 检查不够！
6
UObject* Obj = /* ... */;
7

8
// 场景：Actor 被 Destroy() 了，但指针没置空
9
AActor* Actor = GetCachedActor();
10
Actor->Destroy();  // Actor 被标记为 Garbage
11
// Actor 指针仍然不是 nullptr！它指向的内存还在（等 GC）
12
// 但 Actor 已经不能正常使用了
13

14
if (Actor != nullptr)  // ← 返回 true！但对象已经"死了"
15
{
16
    Actor->DoSomething();  // 可能崩溃，也可能悄悄失败
17
}
18

19
// ✓ 正确：用 IsValid()
20
if (IsValid(Actor))  // 检查 nullptr + 检查 Garbage 标记
21
{
22
    Actor->DoSomething();  // 安全
23
}

1
// IsValid() 的简化实现（概念，UE5 实际更复杂）：
2
bool IsValid(const UObject* Test)
3
{
4
    // 1. nullptr 检查
5
    if (Test == nullptr) return false;
6

7
    // 2. Garbage 标记检查（对象是否已被标记为垃圾）
8
    //    UE5 中不再使用 RF_BeginDestroyed 这个 ObjectFlag，
9
    //    而是检查 GUObjectArray 中该对象内部索引的 EInternalObjectFlags::Garbage
10
    if (Test->HasAnyInternalFlags(EInternalObjectFlags::Garbage))
11
        return false;
12
    // 注意：UE5.0+ 彻底废弃了 PendingKill，用 MarkAsGarbage() 替代
13

14
    // 3. 全局表索引验证
15
    //    检查对象在 GUObjectArray 中的索引是否仍然有效
16
    //    （对象可能已经从全局注册表中移除）
17
    if (!GUObjectArray.IsValid(Test))
18
        return false;
19

20
    return true;
21
}
22

23
// 使用：
24
AActor* Actor = GetSomeActor();
25

26
// 销毁前
27
IsValid(Actor);   // true
28
Actor->Destroy();  // 内部调用 MarkAsGarbage()，设置 Garbage 标记
29
IsValid(Actor);   // false ← 即使指针不为 nullptr！
30

31
// ⚠️ 性能注意：IsValid() 比 nullptr 检查慢（查 GUObjectArray 索引）
32
// 不需要在每帧 Tick 中对每个指针调 IsValid()
33
// 只在"对象可能已被销毁"的场景使用

1
// 场景 1：你自己销毁了对象 → 把指针置空，以后用 nullptr
2
AActor* MyActor = SpawnActor(...);
3
// ...
4
MyActor->Destroy();
5
MyActor = nullptr;  // 手动置空
6
// 后续：if (MyActor != nullptr) ← 够用且更快
7

8
// 场景 2：你不知道对象是否被销毁 → 用 IsValid()
9
// 典型：缓存的弱引用、其他系统传来的指针、异步回调时的 this
10
void UMyComponent::OnAsyncComplete()
11
{
12
    // this 可能在异步过程中被 Destroy 了
13
    if (!IsValid(this)) return;
14
    // 安全使用 this
15
}
16

17
// 场景 3：每帧 Tick → 缓存结果，不要每帧调 IsValid
18
void UMyComponent::Tick(float DeltaTime)
19
{
20
    // ✗ 不好：
21
    if (IsValid(CachedActor)) { CachedActor->DoSomething(); }
22

23
    // ✓ 更好：CachedActor 销毁时通知你，把指针置空
24
    //     Tick 中只需要 nullptr 检查
25
}

1
// 场景：你缓存了一个 Actor 的引用，但你不拥有它
2
// 它可能被销毁（关卡切换、敌人死亡、GC...）
3

4
// ✗ 用 UPROPERTY 保护的原始指针：
5
UPROPERTY()
6
AActor* CachedTarget;  // 这会让 GC 认为 Target 有引用 → 不会被回收
7
// → 问题：Target 该销毁时没销毁 → 泄漏 / 逻辑错误
8

9
// ✓ 用 TWeakObjectPtr：
10
TWeakObjectPtr<AActor> CachedTarget;  // 不阻止 GC 回收
11
// ...
12
if (CachedTarget.IsValid())
13
{
14
    CachedTarget->DoSomething();
15
}

1
// 设置
2
TWeakObjectPtr<AActor> WeakActor = SomeActor;
3

4
// 检查——三种方式：
5
if (WeakActor.IsValid())           // 检查是否 Stale + 检查 Garbage 标记
6
if (WeakActor.IsStale())           // 只检查对象索引是否已失效（不关心 Garbage）
7
if (WeakActor.Get())               // 返回原始指针，可能为 nullptr
8

9
// 使用：
10
if (AActor* Actor = WeakActor.Get())
11
{
12
    if (IsValid(Actor))  // 双重保险
13
    {
14
        Actor->DoSomething();
15
    }
16
}
17

18
// 重置：
19
WeakActor.Reset();  // 变回空状态

1
// UE5.1 引入了 TObjectPtr，作为 UObject* 的"增强版"
2
// 但关键设计是：它在不同构建配置下的行为完全不同
3

4
// ==== 编辑器构建（Editor Build）====
5
// TObjectPtr 是一个包装类，提供了：
6
// - 惰性加载（Lazy Loading）：通过路径字符串延迟解析资产引用
7
// - 非法访问截获：如果访问了 Garbage 标记的对象，编辑器会报错而不是静默崩溃
8
// - 资产路径追踪：你可以在编辑器中看到引用链
9

10
// ==== 打包构建（Packaged/Shipping Build）====
11
// TObjectPtr<T> 在任何构建配置下始终是一个纯正的 C++ 模板类——从未被宏展开抹除
12
// 它在 Shipping 中实现"零开销"的核心机制是模板特化：
13
// - Shipping 下，TObjectPtr<T> 内部仅持有一个原始的 T* 裸指针
14
// - 通过大量 forceinline 的隐式转换操作符，编译后生成的机器码与裸指针完全一致
15
// - 这是编译期优化（模板特化 + 内联），不是预处理器宏替换
16
// → 零运行时开销！和原始指针性能完全一致
17

18
UPROPERTY()
19
TObjectPtr<AActor> TargetActor;  // UE5.1+ 推荐
20
// 编辑器：安全包装 + 懒加载
21
// Shipping：等价于 AActor*，零开销
22

23
// TWeakObjectPtr 的目的：弱引用，不阻止 GC
24
TWeakObjectPtr<AActor> WeakTarget;  // 不阻止 GC
25

26
// 总结：
27
// - 强引用（拥有关系）→ UPROPERTY + TObjectPtr<AActor>（UE5.1+）或 AActor*
28
// - 弱引用（缓存关系）→ TWeakObjectPtr<AActor>
29
// - 非 UObject → TSharedPtr / TWeakPtr

1
// 作为普通开发者，你通常不需要手动管理 GC 簇
2
// 但理解这个概念有助于理解 GC 性能
3

4
// 让对象加入 GC 簇（引擎内部使用，你很少需要手动调）：
5
MyObject->AddToCluster(ClusterRoot);
6

7
// 创建簇（引擎内部使用）：
8
UObject* Cluster = GCClusterSystem::CreateCluster(ClusterRootObj);
9

10
// ⚠️ 自定义 UClass 想要作为簇的根节点，需要显式开启资格：
11
UCLASS()
12
class UMyAsset : public UObject
13
{
14
    GENERATED_BODY()
15

16
public:
17
    // 你的自定义类默认不能成为簇根。
18
    // 要让它具备资格，必须重写此方法：
19
    virtual bool CanBeClusterRoot() const override { return true; }
20
};
21

22
// 但是——不要盲目开启！
23
// 簇的价值体现在"一个根下有大量子节点"的场景（如 UStaticMesh 的 LOD 数据、
24
// UMaterial 的表达式节点——成百上千个子对象只需要一次标记）。
25
// 如果你的自定义 UObject 下面只有 2-3 个子对象，开簇反而增加了
26
// 簇维护的内存开销和管理复杂度，得不偿失。
27

28
// 实际项目中，关注这些就够了：
29
// - 静态网格、材质、纹理 → 引擎自动放进簇了，性能和内存都很好
30
// - 你的自定义 UObject → 绝大多数情况默认即可，不要轻易重写 CanBeClusterRoot()
31
// - 性能敏感场景 → 优先考虑用 ObjectPool 复用 UObject，而不是频繁创建/销毁

1
// 这是 UE C++ 中最致命的 bug 类别
2
UCLASS()
3
class UMyComponent : public UActorComponent
4
{
5
    GENERATED_BODY()
6

7
    // 你："我只是想缓存一个资产引用"
8
    UPROPERTY()
9
    UMyAsset* SafeAsset;     // ✓ GC 知道
10

11
    UMyAsset* UnsafeAsset;   // ✗ GC 不知道！
12
    // 结果：UnsafeAsset 指向的对象被 GC 回收
13
    //      → UnsafeAsset 变成野指针
14
    //      → 下次访问 → 崩溃（时机随机，难以复现和调试）
15

16
public:
17
    void CacheAsset(UMyAsset* Asset)
18
    {
19
        SafeAsset = Asset;   // 安全
20
        UnsafeAsset = Asset; // 定时炸弹
21
    }
22
};

1
// 1. 启用 GC 日志
2
// 启动参数：-LogGarbage
3
// 会输出每次 GC 回收了哪些对象
4

5
// 2. 在可疑对象的 BeginDestroy() 中打断点
6
void UMyAsset::BeginDestroy()
7
{
8
    Super::BeginDestroy();
9
    // 在这里打断点 → 看调用栈 → 谁触发了 GC？
10
    // 如果对象不该被回收，说明有 UPROPERTY 遗漏
11
}
12

13
// 3. 使用 TWeakObjectPtr 而不是裸指针
14
TWeakObjectPtr<UMyAsset> CachedAsset;  // 至少能用 IsValid() 检测
15
// 配合断言在早期捕获：
16
checkf(CachedAsset.IsValid(), TEXT("Asset was garbage collected!"));

1
UCLASS()
2
class UMyComponent : public UActorComponent
3
{
4
    GENERATED_BODY()
5

6
public:
7
    UMyComponent()
8
    {
9
        // ✗ 错误：构造函数中不能访问 Outer/Actor
10
        // AActor* Owner = GetOwner();  // 返回 nullptr！还没设置
11

12
        // ✗ 错误：构造函数中不能 SpawnActor
13
        // GetWorld()->SpawnActor<...>();  // World 可能还不可用
14

15
        // ✓ 构造函数中只做：
16
        //   - 设置默认值
17
        //   - CreateDefaultSubobject
18
        //   - 设置组件属性（PrimaryComponentTick 等）
19
        PrimaryComponentTick.bCanEverTick = false;
20
    }
21

22
    // ✓ 需要 Outer/World 的逻辑放 BeginPlay：
23
    virtual void BeginPlay() override
24
    {
25
        Super::BeginPlay();
26
        AActor* Owner = GetOwner();  // 此时正确
27
    }
28
};

1
UCLASS()
2
class UMyComponent : public UActorComponent
3
{
4
    GENERATED_BODY()
5

6
    void LoadAssetAsync()
7
    {
8
        // ✗ 危险：Lambda 捕获 this
9
        FStreamableManager& Manager = UAssetManager::GetStreamableManager();
10
        Manager.RequestAsyncLoad(AssetPath, [this]() {
11
            // this 可能在异步加载过程中被 Destroy 了！
12
            // → 崩溃
13
            OnAssetLoaded();
14
        });
15

16
        // ✓ 安全写法：用 TWeakObjectPtr（必须且只能用弱引用！）
17
        TWeakObjectPtr<UMyComponent> WeakThis(this);
18
        Manager.RequestAsyncLoad(AssetPath, [WeakThis]() {
19
            if (WeakThis.IsValid())
20
            {
21
                WeakThis->OnAssetLoaded();
22
            }
23
        });
24

25
        // ✗ 绝对禁止：异步回调中捕获裸指针 [this] + IsValid() 守卫
26
        // Manager.RequestAsyncLoad(AssetPath, [this]() {
27
        //     if (!IsValid(this)) return;  // ← 致命错误！
28
        //     OnAssetLoaded();
29
        // });
30
        //
31
        // 为什么这是致命毒药？
32
        // IsValid() 能安全检测 nullptr 和 Garbage 标记，但绝对不能检测
33
        // "内存已被 GC 彻底释放"的情况。如果异步加载耗时很长，this 指向的
34
        // 对象已在前面某帧被 GC 清扫（Sweep）——此时 this 是纯粹野指针，
35
        // 一旦尝试读取 this->HasAnyInternalFlags()（IsValid 内部），
36
        // 操作系统立即判定非法内存访问 → Access Violation → 闪退。
37
        //
38
        // 异步回调必须且只能使用 TWeakObjectPtr 捕获！
39
    }
40
};

1
// AddToRoot 是防止对象被 GC 的最强手段
2
// 但如果你忘了 RemoveFromRoot → 内存泄漏
3

4
UMyObject* Obj = NewObject<UMyObject>();
5
Obj->AddToRoot();  // "这个对象很重要，GC 别碰它"
6

7
// ... 使用对象 ...
8

9
// ✗ 如果忘记这行 → 对象永远不会被回收 → 泄漏！
10
Obj->RemoveFromRoot();
11

12
// ⚠️ AddToRoot 不是银弹——它能阻止回收，但也阻止了正常的清理流程
13
// 只在以下场景使用：
14
// 1. 对象被 C++ 非 UObject 代码持有（裸指针/static/全局变量）
15
// 2. 对象需要在关卡切换后仍然存活
16
// 一般用 UPROPERTY 更安全