1
// ===== 创建与初始化 =====
2
// std::vector
3
std::vector<int> vec = {1, 2, 3};
4
std::vector<int> vec2(100, 42);       // 100 个 42
5
std::vector<int> vec3(vec2);          // 拷贝
6

7
// TArray
8
TArray<int> Arr = {1, 2, 3};          // ✓ 支持 initializer_list
9
TArray<int> Arr2;
10
Arr2.Init(42, 100);                   // 100 个 42（注意顺序：值在前，数量在后）
11
TArray<int> Arr3(Arr2);               // 拷贝
12

13
// ===== 添加元素 =====
14
// std::vector
15
vec.push_back(4);
16
vec.emplace_back(Args...);
17

18
// TArray
19
Arr.Add(4);                            // = push_back
20
Arr.Emplace(Args...);                  // = emplace_back
21
Arr.Insert(42, 0);                     // 在索引 0 处插入
22
Arr.Append({5, 6, 7});               // 批量追加
23
Arr.AddUnique(4);                      // 只有在不存在时才添加（TSet 更适合大量去重）
24

25
// ===== 删除元素 =====
26
// std::vector
27
vec.pop_back();
28
vec.erase(vec.begin() + idx);
29

30
// TArray
31
Arr.Pop();                             // 移除末尾（不返回值）
32
Arr.RemoveAt(0);                       // 按索引移除
33
Arr.Remove(42);                        // 移除所有等于 42 的元素
34
Arr.RemoveAll([](int x) { return x < 0; });    // 条件移除
35
Arr.RemoveSingle(42);                  // 只移除第一个等于 42 的
36

37
// O(1) 删除——用最后一个元素覆盖被删除位置（不保持顺序！）
38
Arr.RemoveAtSwap(0);                   // 用最后元素覆盖索引 0，O(1)
39
Arr.RemoveSwap(42);                    // 用最后元素覆盖第一个 == 42 的位置，O(1)
40
// ⚠️ RemoveAtSwap/RemoveSwap 改变元素顺序，但比 RemoveAt(0)/Remove(42) 的 O(n) 快得多！
41
// 适用于元素顺序无关紧要的场景（粒子池、缓存列表、中间结果...）
42

43
Arr.Empty();                           // 清空 + 释放所有已分配堆内存（Max() 归零）
44
Arr.Reset();                           // 清空但保留当前容量（Max() 不变，避免重新分配）
45
// 实战：每帧填充再清空的临时数组用 Reset()（省去反复 malloc/free），
46
//       需要彻底释放大块内存时用 Empty()（降低内存常驻水位）
47

48
// ===== 访问元素 =====
49
// std::vector
50
int val = vec[0];
51
int last = vec.back();
52
int first = vec.front();
53

54
// TArray
55
int Val = Arr[0];                      // Debug/Development 中有 checkSlow 越界断言
56
                                       // Shipping 中无检查 → UB（和 std::vector 的默认行为一致）
57
int Last = Arr.Last();                 // 注意：空数组调用 Last() 会断言崩溃
58
int First = Arr[0];                    // 没有 Front() 方法，直接用 [0]
59
int& Top = Arr.Top();                  // = back()，空则断言
60
bool bValid = Arr.IsValidIndex(5);     // 安全地检查索引是否有效
61

62
// ===== 遍历 =====
63
// std::vector
64
for (auto& elem : vec) { /* ... */ }
65
for (auto it = vec.begin(); it != vec.end(); ++it) { /* ... */ }
66

67
// TArray
68
for (auto& Elem : Arr) { /* ... */ }    // ✓ range-for 完全支持
69
for (int32 i = 0; i < Arr.Num(); i++)  // 索引遍历（Num() = size()）
70
{
71
    auto& Elem = Arr[i];
72
}
73
// 迭代器（返回索引而非指针，适合在遍历中安全删除）：
74
for (auto It = Arr.CreateIterator(); It; ++It)
75
{
76
    if (It->ShouldRemove()) { It.RemoveCurrent(); }
77
}
78

79
// ===== 排序与查找 =====
80
// std::vector
81
std::sort(vec.begin(), vec.end());
82
auto it = std::find(vec.begin(), vec.end(), 42);
83
bool found = std::binary_search(vec.begin(), vec.end(), 42);
84

85
// TArray
86
Arr.Sort();                            // 默认升序
87
Arr.Sort([](int A, int B) { return A > B; });  // 自定义比较
88
Arr.StableSort();                      // 稳定排序
89
Arr.HeapSort();                        // 堆排序
90

91
int* Found = Arr.FindByPredicate([](int x) { return x > 10; });  // 返回指针！
92
int32 Idx = Arr.IndexOfByKey(42);      // 线性查找，返回索引
93
int32 Idx2 = Arr.IndexOfByPredicate([](int x) { return x > 10; });  // 条件查找索引
94
// 二分查找（需要先排序）：
95
int32 SortedIdx = Arr.BinarySearch(42); // 找到 → 返回索引；未找到 → 返回 INDEX_NONE（-1）
96
// ⚠️ BinarySearch 不会像 std::lower_bound 那样返回"插入点"！
97
//    拿着 -1 去 Arr.Insert() 会立即触发越界断言崩溃
98
//    需要插入点以维持有序性 → 改用 Algo::LowerBound(Arr, 42)
99

100
// ===== 堆操作（TArray 独有，std::vector 没有内置）=====
101
Arr.Heapify();                         // 将数组原地转换为堆
102
Arr.HeapPush(99);                      // 插入并维护堆性质
103
Arr.HeapPop();                         // 移出堆顶并维护堆性质
104
int& HeapTop = Arr.HeapTop();          // 查看堆顶
105

106
// ===== 内存管理 =====
107
// std::vector
108
vec.reserve(100);
109
vec.shrink_to_fit();
110
size_t cap = vec.capacity();
111

112
// TArray
113
Arr.Reserve(100);                      // 预分配
114
Arr.Shrink();                          // 收缩到实际大小
115
int32 Max = Arr.Max();                 // 最大容量（当前预分配的上限）
116
int32 Num = Arr.Num();                 // 当前元素个数
117
int32 Slack = Arr.GetSlack();          // 剩余容量 = Max() - Num()

1
// 坑 1：Remove() 删除所有匹配项，不像 std::vector::erase 只删一个
2
TArray<int> Arr = {1, 2, 2, 3};
3
Arr.Remove(2);                         // → {1, 3}，两个 2 都被删了！
4
// 如果只想删第一个 → RemoveSingle(2) → {1, 2, 3}
5
// 新手常常用 Remove 期望只删一个，结果删了所有
6

7
// 坑 2：operator[] 的越界行为和构建配置相关
8
TArray<int> Arr = {1, 2, 3};
9
// Debug/Development 构建中：越界会触发 checkSlow 断言→ 崩溃，准确定位问题
10
// Shipping 构建中：越界变为 UB（和 std::vector::operator[] 一样无检查）
11
int Val = Arr[100];                    // Debug/Dev 中这里必崩；Shipping 中 UB
12
// 用 IsValidIndex() 做安全边界检查（所有构建配置中都安全）
13

14
// 坑 3：Add() 触发的内存分配可能很昂贵
15
// 和 std::vector 一样，TArray 在扩容时会复制所有元素
16
// 预知大小时务必 Reserve：
17
TArray<FVector> Vertices;
18
Vertices.Reserve(100000);              // 一次分配到位
19
for (int i = 0; i < 100000; i++)
20
{
21
    Vertices.Add(ComputeVertex(i));    // 不会反复扩容
22
}
23

24
// 坑 4：TArray<T*> 不会自动管理指针的生命周期
25
TArray<AActor*> Actors;
26
Actors.Add(GetWorld()->SpawnActor<AActor>());
27
Actors.RemoveAt(0);  // 从数组中移除了，但 Actor 仍然存在于关卡中
28
// TArray 只管自己的内存，不管元素指向的对象
29
// → 想要 GC 追踪，必须把 TArray 放在 UPROPERTY 下

1
// ==== 默认分配器（堆分配）====
2
TArray<int> Arr;                        // 内存在堆上，和 std::vector 一样
3

4
// ==== TInlineAllocator —— 小数组走栈，大了才走堆 ====
5
// 适合：绝大多数元素数量在 N 以内的场景
6
// 原理：对象内部预留 N 个元素的空间（栈上），超出后再堆分配
7
TArray<int, TInlineAllocator<16>> InlineArr;
8
// 前 16 个元素：存储在 TArray 对象内部的栈空间中，零堆分配
9
// 第 17 个元素起：自动切换到堆分配
10
// 典型应用：函数参数列表（通常不超过 4-8 个）、临时索引缓冲
11

12
// ⚠️ TInlineAllocator 的内存膨胀陷阱：
13
// 内联空间直接嵌入在宿主对象中。如果你把
14
//   TArray<int, TInlineAllocator<64>> LargeInlineArr;
15
// 作为 UActorComponent 的成员变量，关卡中每生成该组件的一个实例，
16
// 就会常驻 64 * sizeof(int) = 256 字节的内联存储，
17
// 即使这个数组大多数时候是空的！
18
//
19
// 审慎选择 N 的大小——只对极大概率用到的元素数量预留空间。
20
// 默认堆分配的 TArray 只在 Add 时才分配内存，空数组零额外开销。
21

22
// ==== TMemStackAllocator —— 帧分配器（每帧自动清空）====
23
// 适合：单帧内的临时数据，帧结束时自动回收
24
// ⚠️ 不能在帧结束后保留引用！
25
{
26
    TArray<int, TMemStackAllocator<>> FrameArr;
27
    FrameArr.Add(42);
28
    // ... 使用 FrameArr ...
29
}  // ← 帧结束时，FrameArr 的内存被回收（无需手动释放）
30

31
// 分配器选择总结：
32
// 默认堆分配      → 通用场景，和 std::vector 一样的语义
33
// TInlineAllocator → 热点路径中的小数组（避免堆分配开销）
34
// TMemStackAllocator → 单帧生命周期内的临时数组

1
// ===== 创建与插入 =====
2
TMap<FString, int32> Map;
3

4
// Add：如果 key 不存在则插入，存在则 覆盖旧值（= std::map::insert_or_assign）
5
Map.Add(TEXT("A"), 1);                 // 插入 "A" → 1
6
Map.Add(TEXT("A"), 42);               // 覆盖！"A" → 42（不会崩溃！）
7
Map.Emplace(TEXT("B"), 2);            // 同 Add，避免临时变量拷贝
8

9
// FindOrAdd：只接收一个参数 Key——不存在则插入默认值（零初始化）并返回引用
10
int32& Ref = Map.FindOrAdd(TEXT("C"));   // "C" 不存在 → 插入默认值 0，返回引用
11
Ref = 3;                                  // 再赋值为 3
12
int32& Ref2 = Map.FindOrAdd(TEXT("C"));  // "C" 已存在 → 返回已有值(3)的引用
13
Ref2 = 100;                               // 更新为 100
14
// ⚠️ 如果想在插入的同时指定初始值，使用 Add() 或 Emplace()：
15
// Map.Add(TEXT("C"), 3);  // key 存在则覆盖，不存在则插入
16

17
// ===== 查找 =====
18
// ⚠️ 核心差异：TMap::operator[] 和 std::unordered_map::operator[] 行为完全不同！
19
int32* Val = Map.Find(TEXT("A"));       // 返回指针，找不到返回 nullptr
20
if (Val) { Use(*Val); }
21

22
// TMap::operator[] → key 不存在时 断言崩溃！
23
// int32 Crash = Map[TEXT("NotExist")]; // ← 断言！不要用 [] 做查找
24
// （std::unordered_map 的 [] 在 key 不存在时插入默认值——TMAP 不做这件事）
25

26
// 安全的访问方式：
27
int32 SafeVal = Map.FindRef(TEXT("A"));           // 返回值的拷贝，找不到返回默认值(0)
28
int32& SafeRef = Map.FindOrAdd(TEXT("A"));         // 找不到就插入默认值
29
bool bFound = Map.Contains(TEXT("A"));             // 检查 key 是否存在
30

31
// ===== 删除 =====
32
Map.Remove(TEXT("A"));                  // 按 key 删除
33
Map.Empty();                            // 清空
34
int32 OutValue = 0;  // 声明接收删除值的变量
35
int32 NumRemoved = Map.RemoveAndCopyValue(TEXT("B"), OutValue);  // 删除并获取被删除的值
36

37
// ===== 遍历 =====
38
for (auto& Pair : Map)
39
{
40
    // Pair.Key, Pair.Value            ← 不是 .first / .second！
41
    UE_LOG(LogTemp, Log, TEXT("%s → %d"), *Pair.Key, Pair.Value);
42
}
43

44
for (auto It = Map.CreateConstIterator(); It; ++It)
45
{
46
    // It->Key, It->Value
47
}
48

49
// ===== 其他常用操作 =====
50
int32 Count = Map.Num();                // = size()
51
Map.Reserve(100);                       // 预分配哈希桶
52
Map.Compact();                          // 整理内存碎片（删除大量元素后）
53
Map.Shrink();                           // 释放多余内存
54

55
// 获取所有 Keys / Values：
56
TArray<FString> Keys;
57
Map.GetKeys(Keys);                      // 填充到已存在的 TArray 中
58

59
TArray<int32> Values;
60
Map.GenerateValueArray(Values);         // 生成 Values 数组

1
// TMap 使用的是 UE 自己定义的哈希和相等性检查
2
// 对于 FString、FName、int32、指针等内置类型，开箱即用
3

4
// 自定义 Key 类型需要同时提供哈希函数和相等比较：
5
struct FMyKey
6
{
7
    int32 ID;
8
    FString Name;
9

10
    // 哈希函数
11
    friend uint32 GetTypeHash(const FMyKey& Key)
12
    {
13
        return HashCombine(GetTypeHash(Key.ID), GetTypeHash(Key.Name));
14
    }
15

16
    // 相等比较
17
    bool operator==(const FMyKey& Other) const
18
    {
19
        return ID == Other.ID && Name == Other.Name;
20
    }
21
};
22

23
// 然后可以直接使用：
24
TMap<FMyKey, int32> CustomMap;

1
// TQueue 支持 SPSC（单生产者单消费者）和 MPMC（多生产者多消费者）模式
2
TQueue<int32> Queue;                     // 默认 MPSC（多生产单消费）
3

4
Queue.Enqueue(42);
5
int32 Val;
6
if (Queue.Dequeue(Val))
7
{
8
    // 成功出队
9
}
10

11
// 线程安全模式配置：
12
TQueue<int32, EQueueMode::Spsc> SPSCQueue;  // 更快，但只能一生产一消费
13
TQueue<int32, EQueueMode::Mpsc> MPSCQueue;
14

15
// 清空：
16
Queue.Empty();

1
// TArrayView = std::span（C++20）
2
// 不拥有数据，只是"看"一段连续内存
3

4
void ProcessVertices(TArrayView<FVector> Vertices)
5
{
6
    for (FVector& V : Vertices)
7
    {
8
        V *= 2.0f;
9
    }
10
}
11

12
// 可以从多种来源构造：
13
TArray<FVector> Arr = {FVector(0), FVector(1), FVector(2)};
14
ProcessVertices(TArrayView<FVector>(Arr));          // 整个 TArray
15
ProcessVertices(TArrayView<FVector>(&Arr[1], 2));   // 从索引 1 开始，2 个元素
16

17
// 也可以从裸指针构造：
18
FVector* Buffer = /* ... */;
19
ProcessVertices(TArrayView<FVector>(Buffer, Count));
20

21
// 性能对比：
22
// void Process(TArray<FVector> Data);  // ✗ 每次传参都拷贝整个数组
23
// void Process(TArrayView<FVector> D); // ✓ 只传指针+大小，零拷贝

1
#include "Containers/UnrealString.h"  // 实际上 CoreMinimal.h 已包含
2

3
// ===== 创建 =====
4
FString Str1 = TEXT("Hello 世界");       // ← 字面量必须用 TEXT() 宏
5
FString Str2 = FString(TEXT("Direct"));
6
FString Str3 = FString::Printf(TEXT("HP: %d/%d"), CurrentHP, MaxHP);
7
//                                ↑ UE 的 sprintf，没有 std::format
8

9
// ===== 拼接 =====
10
FString Combined = Str1 + TEXT(" ") + Str2;
11
Combined += TEXT("!");
12
FString Joined = FString::Join(ArrayOfStrings, TEXT(", "));
13

14
// ===== 修改 =====
15
Str1.ToUpper();
16
Str1.ToLower();
17
Str1.Replace(TEXT("Hello"), TEXT("你好"));
18
Str1.TrimStartAndEnd();                  // 去前后空白
19

20
// ===== 查找 =====
21
bool bStartsWith = Str1.StartsWith(TEXT("Hello"));
22
bool bContains = Str1.Contains(TEXT("世界"));
23
int32 Idx = Str1.Find(TEXT("世"));        // 返回索引，-1 为未找到
24
FString Left5 = Str1.Left(5);             // 前 5 个字符
25
FString Right3 = Str1.Right(3);           // 后 3 个字符
26
FString Mid = Str1.Mid(2, 4);            // 从索引 2 开始，4 个字符
27

28
// ===== 数值转换 =====
29
FString NumStr = FString::FromInt(42);              // int → FString
30
FString FloatStr = FString::SanitizeFloat(3.14159);  // float → FString
31
int32 Val = FCString::Atoi(*Str1);                   // FString → int（*取出 TCHAR*）
32
float FVal = FCString::Atof(*Str1);                  // FString → float
33

34
// ===== 平台编码转换 =====
35
// FString → std::string (UTF-8)
36
std::string StdStr = TCHAR_TO_UTF8(*Str1);
37

38
// std::string → FString
39
FString UEStr = UTF8_TO_TCHAR(StdStr.c_str());
40

41
// FString → const wchar_t* (Windows)
42
const wchar_t* Wide = *Str1;             // 解引用 FString 得到 TCHAR*
43

44
// FString → ANSI (注意可能的编码丢失)
45
FString AnsiStr = ANSI_TO_TCHAR("Hello");  // "Hello" 是纯 ASCII，安全

1
// FName 是不区分大小写的、不可变的哈希字符串
2
// 内部结构（64 位系统占 8 字节）：
3
//   - ComparisonIndex (4 字节)：指向全局名字表（Name Table）的哈希索引，用于 O(1) 比较
4
//   - Number (4 字节)：数字后缀，处理同名变体（如 "Mesh_0", "Mesh_1", "Mesh_2"）
5
// 相同内容的 FName 在名字表中只存一份——ComparisonIndex 指向同一位置
6
// 比较两个 FName == 比较 (ComparisonIndex + Number) → O(1)
7
//
8
// Number 字段的意义：大量带数字后缀的重名资产（如骨骼网格的 LOD 名称），
9
// 不会导致名字表无限膨胀——它们共享同一个字符串 "Mesh"，仅 Number 不同
10

11
// ===== 创建 =====
12
FName Name1 = FName(TEXT("MyAssetName"));
13
FName Name2 = TEXT("MyAssetName");       // 隐式转换（通过构造函数）
14
FName Name3(TEXT("myassetname"));        // 和 Name1 是同一个 FName！
15
// FName 不区分大小写：TEXT("MyAssetName") == TEXT("MYASSETNAME")
16

17
// ===== 比较 =====
18
if (Name1 == Name2) { /* true！O(1) 整数比较 */ }
19
// FName 的比较比 FString 快约 100 倍（不需要逐字符比较）
20

21
// ===== 查询 =====
22
FString Str = Name1.ToString();          // FName → FString
23
int32 Idx = Name1.GetComparisonIndex();  // 获取内部索引（用于调试）
24
bool bNone = Name1.IsNone();             // 是否是空 FName
25

26
// ===== 使用场景 =====
27
// ✓ 资源路径：/Game/Characters/Hero
28
// ✓ 资产名：SK_Hero_Body
29
// ✓ 属性名、函数名（反射系统全部用 FName）
30
// ✓ Socket 名、Bone 名
31
// ✗ 不要用于需要修改、拼接的字符串
32
// ✗ 不要用于 UI 显示文本
33

34
// ===== 性能警告 =====
35
// FName 的创建不是免费的——它需要查全局哈希表
36
// 不要在 Tick 中创建 FName：
37
void Tick(float DeltaTime)
38
{
39
    // ✗ 每帧查哈希表，不好
40
    FName DynamicName = FName(FString::Printf(TEXT("Bone_%d"), FrameCount));
41

42
    // ✓ 用静态/缓存的 FName
43
    static FName CachedBone = FName(TEXT("Bone_Head"));
44
}

1
// FText 是为本地化（翻译）设计的
2
// 内部存储：源字符串 + 翻译 Key + 可选的格式化参数
3

4
// ===== 创建 =====
5
// 方式 1：用 NSLOCTEXT（Namespace + Key + 默认文本）
6
FText WelcomeText = NSLOCTEXT("MyGame", "WelcomeMessage", "欢迎来到这个世界");
7
//   Namespace: "MyGame" → 用于组织翻译文件
8
//   Key: "WelcomeMessage" → 翻译系统通过此 Key 查找对应语言的文本
9
//   Default Text: "欢迎来到这个世界" → 没有翻译时的回退文本
10

11
// 方式 2：用 LOCTEXT（快捷方式，Namespace 自动设为文件名）
12
FText ShortText = LOCTEXT("StartGame", "开始游戏");
13

14
// 方式 3：从 FString 创建（非本地化，仅占位用）
15
FText DynamicText = FText::FromString(TEXT("一些动态内容"));
16

17
// 方式 4：格式化文本（带参数）
18
FText DamageText = FText::Format(
19
    NSLOCTEXT("MyGame", "DamageFormat", "造成了 {0} 点伤害"),
20
    DamageAmount  // {0} 被替换为 DamageAmount
21
);
22

23
// ===== 显示 =====
24
// 在 UMG TextBlock 中：
25
MyTextBlock->SetText(WelcomeText);       // ✓ 会自动查找翻译
26
// MyTextBlock->SetText(FText::FromString(...));  // △ 不会翻译
27

28
// ===== 规则 =====
29
// ✓ 所有玩家能看到的 UI 文字 → 必须用 FText
30
// ✗ 日志、调试信息 → 不需要翻译，用 FString
31
// ✗ 资源路径、标识符 → 用 FName

1
// TCHAR 是 UE 的跨平台字符类型，现代 UE5 全平台统一为 16 位宽度：
2

3
// Windows: TCHAR = wchar_t (2 字节，UTF-16)
4
// Linux/Mac/Android/iOS: TCHAR = char16_t (2 字节，UTF-16)
5

6
// TEXT() 宏的作用：在编译期根据平台包裹正确的字符前缀
7
// Windows: TEXT("Hello") → L"Hello"     (wchar_t 数组)
8
// Mac:     TEXT("Hello") → u"Hello"     (char16_t 数组)
9
// 全平台统一为宽字符——绝不存在"Mac 上是窄 char"的情况
10

11
// 所有 UE API 都使用 TCHAR*，不要直接使用 char* 或 wchar_t*
12
FString Path = TEXT("/Game/Assets/Hero");  // 跨平台安全
13

14
// 当你需要和外部库交互时，显式转换：
15
std::string Utf8Str = TCHAR_TO_UTF8(*Path);       // → std::string (UTF-8)
16
FString FromUtf8 = UTF8_TO_TCHAR(Utf8Str.c_str()); // ← 从 std::string 回来
17

18
// 和 Windows API 交互：
19
const wchar_t* WinStr = *Path;           // Windows 上 TCHAR = wchar_t，直接兼容
20
// Mac/Linux 上 TCHAR = char16_t，需通过 TCHAR_TO_UTF8 转为 UTF-8 再对接 POSIX API

1
// 字符串转换有成本！以下是性能排序（从快到慢）：
2

3
// 1. FName ↔ FName：O(1)，就是整数比较
4
// 2. FString → FName：O(n)，需要哈希计算 + 查表
5
// 3. FString ↔ std::string：O(n)，内存拷贝 + 可能的编码转换
6
// 4. FString → FText：O(n)，内存拷贝
7
// 5. FText → 翻译后的字符串：O(1)，取缓存的翻译结果
8

9
// 避免在 Tick 中做字符串转换：
10
void Tick(float DeltaTime)
11
{
12
    // ✗ 每帧都从路径创建 FName，查哈希表
13
    FName BoneName = FName(TEXT("/Game/Characters/Hero/Bones/Head"));
14

15
    // ✓ 缓存在成员变量中，构造时创建一次
16
    // UPROPERTY()
17
    // FName CachedBoneName;
18
}
19

20
// 对于大量字符串比较的场景，用 FName：
21
// FString 比较 = O(n) 逐字符
22
// FName 比较 = O(1) 整数比较

1
// FName(TEXT("...")) 在每次调用时都会去查全局名字表的哈希表
2
// 在循环中反复构造同一个 FName 是常见的性能陷阱
3

4
TArray<TMap<FName, int32>> ComplexData;
5

6
// ✗ 每次迭代都查全局哈希表构造 FName：
7
for (int i = 0; i < ComplexData.Num(); i++)
8
{
9
    for (int j = 0; j < InnerArray.Num(); j++)
10
    {
11
        int32 Val = ComplexData[i][FName(TEXT("Key"))];
12
        //                        ↑ 每圈都查一次全局哈希表，构造完全相同的 FName！
13
    }
14
}
15

16
// ✓ 提到循环外，构造一次，复用：
17
static const FName KeyName(TEXT("Key"));  // 全局名字表中只查一次
18
for (int i = 0; i < ComplexData.Num(); i++)
19
{
20
    const TMap<FName, int32>& Map = ComplexData[i];  // 引用，避免重复 operator[]
21
    for (int j = 0; j < InnerArray.Num(); j++)
22
    {
23
        int32* Val = Map.Find(KeyName);  // O(1) FName 比较 + 没有重复构造
24
        // 也避免了 TMap::operator[] 的 key-not-found 断言风险
25
    }
26
}

1
// 和 STL 一样，在遍历中删除元素需要小心
2

3
// ✗ 危险：在 range-for 中删除
4
for (auto& Elem : Arr)
5
{
6
    if (ShouldRemove(Elem))
7
    {
8
        Arr.Remove(Elem);  // 迭代器失效！未定义行为
9
    }
10
}
11

12
// ✓ 方式 1：反向索引遍历
13
for (int32 i = Arr.Num() - 1; i >= 0; --i)
14
{
15
    if (ShouldRemove(Arr[i]))
16
    {
17
        Arr.RemoveAt(i);
18
    }
19
}
20

21
// ✓ 方式 2：使用 TArray 的迭代器（自动处理失效）
22
for (auto It = Arr.CreateIterator(); It; ++It)
23
{
24
    if (ShouldRemove(*It))
25
    {
26
        It.RemoveCurrent();  // 安全删除，迭代器自动指向下一个
27
    }
28
}
29

30
// ✓ 方式 3：RemoveAll（最推荐）
31
Arr.RemoveAll([](auto& Elem) { return ShouldRemove(Elem); });