1
// ==== 2002 年，C++98 时代的真实困境 ====
2

3
// 困境 1：没有 shared_ptr，内存管理全靠手动
4
class GameEntity {
5
    std::vector<GameEntity*> children;  // 谁负责 delete？文档？口头约定？
6
};
7
// 结果：每个引擎都自己写引用计数系统
8

9
// 困境 2：没有 std::string 的跨平台保证（各平台 STL 实现不一致）
10
// GCC 的 string 和 MSVC 的 string 内部布局不同
11
// 结果：每个引擎都自己写字符串类
12

13
// 困境 3：没有运行时反射
14
// 无法在编辑器中修改属性、无法序列化、无法和脚本语言互操作
15
// 结果：写大量样板代码手动注册每个属性
16

17
// 困境 4：没有移动语义
18
std::vector<Mesh> LoadMeshes() {
19
    std::vector<Mesh> meshes;
20
    // ... 加载 10000 个网格
21
    return meshes;  // 深拷贝整个 vector！性能灾难
22
}
23
// 结果：到处用输出参数或指针，导致代码难以组合

1
// ==== 类型前缀（匈牙利命名法的 Epic 变体）====
2

3
// U —— 继承自 UObject
4
UCLASS()
5
class UMyObject : public UObject { /* ... */ };
6
class UMyComponent : public UActorComponent { /* ... */ };
7
// 现代 UE5 极力推崇的 USubsystem 也是 U 家族的重要分支：
8
// UGameInstanceSubsystem / UWorldSubsystem / ULocalPlayerSubsystem / UEditorSubsystem
9
// 详见 Ch9 Game Framework 与 Subsystem 体系
10

11
// A —— 继承自 AActor（Actor 也是 UObject，但前缀升级为 A）
12
UCLASS()
13
class AMyActor : public AActor { /* ... */ };
14
class AMyCharacter : public ACharacter { /* ... */ };
15

16
// F —— 纯数据结构 / 非 UObject 类（"F" = Float，继承自 UE 早期的浮点类型命名习惯）
17
struct FVector { float X, Y, Z; };            // 数学类型
18
struct FMyData { int32 Value; FString Name; };  // 数据结构
19
class FMyAlgorithm { /* 纯 C++ 逻辑，无反射 */ }; // 算法类
20

21
// I —— 接口（"I" = Interface）
22
UINTERFACE()
23
class UMyInterface : public UInterface { /* ... */ }; // 接口的 UObject 包装
24
class IMyInterface { /* 实际的 C++ 接口 */ };
25

26
// E —— 枚举（"E" = Enum）
27
UENUM()
28
enum class EMyState : uint8 { Idle, Running, Dead };
29

30
// T —— 模板类（"T" = Template）
31
template<typename T>
32
class TArray { /* ... */ };
33
TSharedPtr<int> Ptr;
34

35
// S —— Slate Widget（"S" = Slate）
36
class SButton : public SCompoundWidget { /* ... */ };
37
class STextBlock : public SLeafWidget { /* ... */ };
38

39
// b —— 布尔变量前缀（小写）
40
bool bIsAlive = true;
41
bool bCanJump = false;

1
// 理由 1：代码即文档，无需跳转到定义
2
void Process(AActor* Actor, UActorComponent* Comp, FVector Location);
3
//            ↑ AActor     ↑ UActorComponent        ↑ FVector
4
// 一眼看出来：Actor 是场景实体，Component 是挂载组件，Vector 是值类型
5

6
// 对比标准 C++ 风格（需要查定义才知道类型性质）：
7
void Process(Actor* actor, ActorComponent* comp, Vector location);
8
//           ↑ 是 UObject？是普通类？是结构体？不知道。
9

10
// 理由 2：决定了对象的生命周期管理方式
11
UObject* Obj;        // GC 管理 → 必须用 UPROPERTY 保护或 NewObject 创建
12
FVector* Vec;        // 手动管理 → 可用 new/delete 或智能指针
13
AActor* Actor;       // GC 管理 → 用 SpawnActor / Destroy
14

15
// 理由 3：编辑器资产的命名一致性
16
// 内容浏览器中：SK_Hero_Body (Skeletal Mesh), M_Hero_Face (Material),
17
//              BP_Hero (Blueprint), MI_Hero_Arm (Material Instance)
18
// 命名前缀体系统一了 C++ 代码和资产命名

1
UCLASS()
2
class UMyActor : public AActor
3
{
4
    GENERATED_BODY()
5

6
    // ✗ 如果用 std::vector
7
    // std::vector<int> Scores;        // 不能被 GC 追踪（虽然 int 不需要 GC）
8
    // std::vector<UObject*> Objects;  // GC 不知道这里有 UObject 引用！
9
    //                                  // → 对象可能被 GC 误删 → 野指针 → 崩溃
10

11
    // ✓ 用 TArray
12
    UPROPERTY()
13
    TArray<int> Scores;                 // 可序列化、可网络复制
14

15
    UPROPERTY()
16
    TArray<UObject*> Objects;           // GC 知道追踪这些引用
17
};

1
// ==== 标准 C++ 的肌肉记忆 ====
2
MyClass* obj = new MyClass();
3
// ... 使用 ...
4
delete obj;  // 你负责释放
5

6
// ==== UE C++：UObject 不能这么干 ====
7
// ✗ 错误！
8
UMyObject* Obj = new UMyObject();   // 编译报错！UObject 不能 new
9
delete Obj;                          // 编译报错！UObject 不能 delete
10

11
// ✓ 正确
12
UMyObject* Obj = NewObject<UMyObject>();
13
// 不需要 delete —— GC 在 Obj 不可达时自动回收
14

15
// AActor 更特殊——必须用 SpawnActor
16
AMyActor* Actor = GetWorld()->SpawnActor<AMyActor>();
17
Actor->Destroy();  // 不是立即删除，而是标记 PendingKill，等 GC

1
// ==== 标准 C++：异常无处不在 ====
2
try {
3
    int* buf = new int[1000000000];  // 可能抛出 std::bad_alloc
4
    LoadFile(path);                   // 可能抛出各种异常
5
} catch (const std::exception& e) {
6
    std::cerr << e.what() << '\n';
7
}
8

9
// ==== UE C++：异常被禁用（/EHsc-）====
10
// 为什么？
11
// 1. 异常会阻止编译器内联优化（对游戏性能影响显著）
12
// 2. 异常使控制流不可预测（在实时渲染循环中很危险）
13
// 3. 异常的表驱动实现有运行时开销
14
// 4. 历史兼容：UE 的千万行代码从未假设异常存在
15

16
// UE 的错误处理三件套：
17
int* Buf = new int[1000000000];          // new 不会抛异常，返回 nullptr
18

19
// check：Development/Debug 构建中失败 → 立即崩溃；Shipping 中整个表达式被编译器移除
20
check(Buf != nullptr);
21
checkf(Buf, TEXT("Failed to alloc %d bytes"), Size); // 带格式化消息的 check
22

23
// ensure：Development 中失败 → 记录日志 + 调用栈 + 继续运行（首次上报，之后静默）；
24
// Shipping（DO_CHECK=0）中整个宏被剥离，连表达式判断都不会执行，仅展开为 (Buf != nullptr)
25
// 适合"开发期抓 bug 但不崩，上线后零开销"的场景
26
ensure(Buf != nullptr);
27

28
// verify：和 check 语义相同（Development 中失败=崩溃），区别在于——
29
// Shipping（DO_CHECK=0）中，verify(expr) 被编译期替换为 (expr)（即纯粹的表达式求值），
30
// 运行时不存在"检查"这个动作——它就是一行普通的函数调用，无任何断言语义
31
// 适合"函数有副作用，必须在 Shipping 中也执行，但开发期希望验证返回值"的场景
32
verify(ImportantCall());
33

34
// 函数级别的错误通过返回值：
35
UObject* Obj = LoadObject<UObject>(nullptr, TEXT("/Game/SomeAsset"));
36
if (!Obj) {
37
    UE_LOG(LogTemp, Error, TEXT("Asset not found!"));
38
    return;  // 提前返回，替代异常传播
39
}

1
// ==== 标准 C++ ====
2
Base* base = GetBase();
3
if (Derived* derived = dynamic_cast<Derived*>(base)) {
4
    derived->SpecialMethod();
5
}
6

7
// ==== UE C++：UE 默认禁用了 RTTI（编译选项 /GR-）====
8
// 为什么？
9
// 1. UE 的反射系统比 RTTI 功能强大得多——不需要 RTTI
10
// 2. RTTI 会为每个多态类型生成额外的 type_info 数据，增加内存开销
11
// 3. 最关键：UObject 的虚函数表和类型体系是引擎自己魔改过的，
12
//    dynamic_cast 对 UObject 根本就是无效且不安全的
13
//
14
// ✗ 绝对禁止对 UObject 使用 dynamic_cast！
15
//    即使你手动在 Build.cs 里开启了 bUseRTTI = true，
16
//    dynamic_cast 在 UObject 面前依然是不可靠的——必须且只能用 Cast<T>
17
// MyClass* Obj = dynamic_cast<MyClass*>(SomeObj);  // 永远不要这样做
18

19
// ✓ Cast<T>：利用 UE 反射系统，比 dynamic_cast 更可靠
20
AActor* GenericActor = GetOwner();
21
if (APlayerCharacter* Player = Cast<APlayerCharacter>(GenericActor)) {
22
    Player->SpecialMethod();  // 安全！
23
}
24

25
// ✓ static_cast：不需要反射检查时正常使用
26
int32 Val = static_cast<int32>(SomeFloat);
27

28
// ✓ Cast 内部原理（简化版）：
29
// 1. 检查 GenericActor 是否为空
30
// 2. 通过反射系统检查 GenericActor->GetClass() 是否 == APlayerCharacter::StaticClass()
31
// 3. 如果是，返回转换后的指针；否则返回 nullptr

1
#include <string>
2
#include <vector>
3
#include <functional>
4
#include <memory>
5
#include <iostream>
6

7
class HealthComponent {
8
public:
9
    HealthComponent(const std::string& name, int maxHealth)
10
        : m_name(name), m_maxHealth(maxHealth), m_health(maxHealth) {}
11

12
    void takeDamage(int damage) {
13
        m_health = std::max(0, m_health - damage);
14
        std::cout << m_name << " took " << damage << " damage, HP: "
15
                  << m_health << "/" << m_maxHealth << '\n';
16

17
        for (auto& callback : m_onHealthChanged) {
18
            callback(m_health, -damage);
19
        }
20

21
        if (m_health <= 0) {
22
            onDeath();
23
        }
24
    }
25

26
    void bindOnHealthChanged(std::function<void(int, int)> callback) {
27
        m_onHealthChanged.push_back(std::move(callback));
28
    }
29

30
    int getHealth() const { return m_health; }
31
    bool isAlive() const { return m_health > 0; }
32

33
private:
34
    std::string m_name;
35
    int m_maxHealth;
36
    int m_health;
37
    std::vector<std::function<void(int, int)>> m_onHealthChanged;
38

39
    virtual void onDeath() {
40
        std::cout << m_name << " died!\n";
41
    }
42
};
43

44
// 使用
45
int main() {
46
    auto comp = std::make_unique<HealthComponent>("Hero", 100);
47
    comp->bindOnHealthChanged([](int hp, int delta) {
48
        // UI 更新逻辑
49
    });
50
    comp->takeDamage(30);
51
}

1
#include "CoreMinimal.h"
2
#include "Components/ActorComponent.h"
3
#include "HealthComponent.generated.h"   // ← 必须最后 #include
4

5
UCLASS(ClassGroup = (Custom), meta = (BlueprintSpawnableComponent))
6
class UHealthComponent : public UActorComponent
7
{
8
    GENERATED_BODY()                     // ← 展开反射胶水代码
9

10
public:
11
    UHealthComponent();
12

13
    // --- 属性（反射 + 蓝图 + GC + 序列化 + 网络 + 编辑器）---
14
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health",
15
              meta = (ClampMin = 0, ClampMax = 1000))
16
    int32 MaxHealth = 100;
17

18
    UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Health",
19
              meta = (ClampMin = 0))
20
    int32 CurrentHealth;
21

22
    UPROPERTY(BlueprintReadOnly, Category = "Health")
23
    bool bIsAlive = true;
24

25
    // --- 委托（多播 + 蓝图可绑定）---
26
    DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(
27
        FOnHealthChanged, int32, NewHealth, int32, Delta);
28

29
    UPROPERTY(BlueprintAssignable, Category = "Events")
30
    FOnHealthChanged OnHealthChanged;
31

32
    // --- 函数（蓝图可调用）---
33
    UFUNCTION(BlueprintCallable, Category = "Health")
34
    void TakeDamage(int32 Damage);
35

36
    UFUNCTION(BlueprintPure, Category = "Health")
37
    int32 GetHealth() const { return CurrentHealth; }
38

39
    UFUNCTION(BlueprintPure, Category = "Health")
40
    bool IsAlive() const { return bIsAlive; }
41

42
protected:
43
    virtual void BeginPlay() override;
44

45
    UFUNCTION()
46
    virtual void OnDeath();
47
};
48

49
// ===== .cpp 实现 =====
50
#include "HealthComponent.h"
51
#include "GameFramework/Actor.h"
52

53
UHealthComponent::UHealthComponent()
54
{
55
    PrimaryComponentTick.bCanEverTick = false;
56
}
57

58
void UHealthComponent::BeginPlay()
59
{
60
    Super::BeginPlay();
61
    CurrentHealth = MaxHealth;
62
}
63

64
void UHealthComponent::TakeDamage(int32 Damage)
65
{
66
    if (!bIsAlive) return;
67

68
    CurrentHealth = FMath::Clamp(CurrentHealth - Damage, 0, MaxHealth);
69
    bIsAlive = CurrentHealth > 0;
70

71
    UE_LOG(LogTemp, Log, TEXT("%s took %d damage, HP: %d/%d"),
72
           *GetOwner()->GetName(), Damage, CurrentHealth, MaxHealth);
73

74
    OnHealthChanged.Broadcast(CurrentHealth, -Damage);
75

76
    if (!bIsAlive) { OnDeath(); }
77
}
78

79
void UHealthComponent::OnDeath()
80
{
81
    UE_LOG(LogTemp, Warning, TEXT("%s died!"), *GetOwner()->GetName());
82
    // 播放死亡动画、生成掉落物、通知 GameMode...
83
}