UE5基础类型与容器

由 发布于

UE5基础类型与容器

1. 游戏模式类

MyGameMode.h

#pragma once

#include "CoreMinimal.h"

// 头文件必须放在这个位置，不能更改
#include "MyHUD.h"
#include "MyGameState.h"
#include "MyPawn.h"
#include "MyPlayerController.h"
#include "MyPlayerState.h"

#include "GameFramework/GameMode.h"
#include "MyGameMode.generated.h"

UCLASS()
class MYPROJECT_API AMyGameMode : public AGameMode
{
	GENERATED_BODY()
	AMyGameMode();
public:
	
	virtual void BeginPlay() override;
	virtual void Tick(float deltaTime) override;
	virtual void EndPlay(const EEndPlayReason::Type endPlayRes) override;
};

MyGameMode.cpp

#include "MyGameMode.h"

AMyGameMode::AMyGameMode() 
{
    DefaultPawnClass = AMyPawn::StaticClass();
    PlayerControllerClass = AMyPlayerController::StaticClass();
    GameStateClass = AMyGameState::StaticClass();
    PlayerStateClass = AMyPlayerState::StaticClass();
    HUDClass = AMyHUD::StaticClass();
}

void AMyGameMode::BeginPlay()
{
    Super::BeginPlay();
}

void AMyGameMode::Tick(float deltaTime)
{
    Super::Tick(deltaTime);
}

void AMyGameMode::EndPlay(const EEndPlayReason::Type endPlayRes)
{
    Super::EndPlay(endPlayRes);
}

2. 数据类型

2.1 基本类型

类 型 含 义
bool 基本的布尔类型，代表真（true）或假（false）的值。用于简单的条件和逻辑判断。
int32 32位整数类型，用于存储标准整数值。它可以存储从-2,147,483,648到2,147,483,647的范围内的值。
int64 64位整数类型，用于存储更大范围的整数值。它的范围大约在-9.22e18到9.22e18之间。
BYTE 8位无符号整数类型，通常用于存储小的数值或数据字节。它的范围是0到255。
FString 虚幻引擎的字符串类型，用于存储和操作文本。它是动态的，可以根据需要改变大小，并支持Unicode。
FName 用于存储具有内部哈希值的字符串，优化了字符串的比较和查找速度。常用于标识符和资产名称。
FText 用于处理本地化文本。它不仅存储字符串本身，还存储相关的本地化信息，以支持多语言环境。
FVector 用于表示三维空间中的点或向量。它包含三个浮点数（X, Y, Z），用于表示空间中的位置或方向。
FRotator 用于表示对象在三维空间中的旋转。它包含三个浮点数（Pitch, Yaw, Roll），分别表示绕X轴、Y轴和Z轴的旋转角度。
FTransform 用于表示对象的位置、旋转和缩放。它结合了FVector（位置）、FRotator（旋转）和FVector（缩放）来定义对象在三维空间中的变换。

2.2 类型转换

string => name

FName name = FName(*str);

string => text

FText text = FText::FromString(str);

name => string

FString str = name.ToString();

text => string

FString str = text.ToString();

name => text

FText text = FText::FromName(name);

text => name

FName name = FName(*(text.ToString()));

3. 容器

3.1 TArray

TArray 是一个动态数组，类似于C++标准库中的 std::vector。提供了快速的随机访问和高效的内存管理，适用于需要动态大小和可以改变内容的数组场景。

1. 创建和初始化

TArray<int32> MyArray; // 创建一个空的TArray
TArray<int32> InitializedArray = {1, 2, 3, 4}; // 创建并初始化TArray

2. 添加元素

MyArray.Add(5); // 在数组末尾添加一个元素
MyArray.AddUnique(6); // 添加一个元素，如果该元素已存在，则不添加
MyArray.Append(InitializedArray); // 将另一个数组的内容添加到当前数组

3. 访问元素

int32 FirstElement = MyArray[0]; // 访问第一个元素
int32 LastElement = MyArray.Last(); // 访问最后一个元素

4. 修改元素

MyArray[0] = 10; // 修改第一个元素的值
MyArray.Insert(60, 0); // 在 0 位置插入 60

5. 删除元素

MyArray.RemoveAt(0); // 删除指定索引处的元素
MyArray.Remove(10); // 删除所有值为10的元素
MyArray.Empty(); // 清空整个数组

6. 数组大小和容量

int32 NumElements = MyArray.Num(); // 获取数组中元素的数量
MyArray.Reserve(100); // 为数组预留足够的空间以容纳100个元素

7. 查找元素

int32 Index = MyArray.IndexOfByKey(10); // 找到值为10的元素的索引
int32 Index = MyArray.Find(10); // 找到第一个值为10的元素的索引
int32 Index = MyArray.FindLast(10); // 找到最后一个值为10的元素的索引
bool bContains = MyArray.Contains(10); // 检查数组是否包含特定值

8. 迭代

// 1. 迭代器
for (auto iter = MyArray.CreateIterator(); iter; iter++) 
{
    int32 Value = *iter;
    // 对Value进行操作
}

// 2. 常量迭代器
for (auto iter = MyArray.CreateConstIterator(); iter; iter++) 
{
    int32 Value = *iter;
    // 对Value进行操作
}

// 3. 内置迭代方式
for (auto& Value : MyArray)
{
    // 对Value进行操作
}

Tips： 注意不是引用。

9. 排序

MyArray.Sort(); // 对数组进行排序

10. 使用Lambda表达式

MyArray.Sort([](const int32 A, const int32 B) 
{
    return A < B; // 自定义排序准则
});

3.2 TMap

TMap 是一个关联容器，类似于C++标准库中的 std::map 。它以键值对的形式存储元素，每个键都唯一对应一个值。

1. 创建和初始化

// 创建一个空的TMap
TMap<int32, FString> MyMap;

// 使用初始化列表创建TMap
TMap<int32, FString> InitializedMap = {{1, TEXT("One")}, {2, TEXT("Two")}, {3, TEXT("Three")}};

2. 添加元素

// 添加或更新键值对
MyMap.Add(4, TEXT("Four"));

// 另一种添加或更新的方式
MyMap[5] = TEXT("Five");

3. 访问元素

// 访问元素（确保键存在）
FString Value;

if (MyMap.Contains(1)) 
{
    Value = MyMap[1];
}

4. 删除元素

// 删除具有特定键的元素
MyMap.Remove(1);

// 清空整个TMap
MyMap.Empty();

5. 遍历元素

// 使用范围基于的for循环遍历
for (const auto& Pair : MyMap) 
{
    int32 Key = Pair.Key;
    FString Value = Pair.Value;
    // 对Key和Value进行操作
}

// 使用迭代器遍历
for (auto It = MyMap.CreateConstIterator(); It; ++It) 
{
    int32 Key = It->Key;
    FString Value = It->Value;
    // 对Key和Value进行操作
}

5. 查找元素

// 查找键对应的值
FString* FoundValue = MyMap.Find(2);

if (FoundValue) 
{
    // 对找到的值进行操作
}

6. 获取大小

// 获取TMap中的元素数量
int32 Size = MyMap.Num();

7. 特定条件的操作

// 过滤或查找满足特定条件的键值对
TMap<int32, FString> FilteredMap;
for (const auto& Pair : MyMap) 
{
    if (Pair.Key > 2) 
    {
        FilteredMap.Add(Pair.Key, Pair.Value);
    }
}

3.3 TSet

TSet 是一个集合容器，类似于C++标准库中的 std::set 。它用于存储唯一元素的集合，确保没有重复项。

1. 创建和初始化

// 创建一个空的TSet
TSet<int32> MySet;

// 使用初始化列表创建TSet
TSet<int32> InitializedSet = {1, 2, 3, 4, 5};

2. 添加元素

// 添加元素
MySet.Add(6);
MySet.Add(7);

3. 检查元素存在

// 检查元素是否存在
bool bExists = MySet.Contains(3);

4. 删除元素

// 删除元素
MySet.Remove(2);

// 清空整个TSet
MySet.Empty();

5. 遍历集合

// 使用for循环遍历
for (int32 Element : MySet) 
{
    // 对Element进行操作
}

// 使用迭代器遍历
for (auto It = MySet.CreateConstIterator(); It; ++It) 
{
    int32 Element = *It;
    // 对Element进行操作
}

6. 获取大小

// 获取TSet中的元素数量
int32 Size = MySet.Num();

7. 集合操作

// 两个TSet的并集
TSet<int32> OtherSet = {4, 5, 6, 7};
MySet.Append(OtherSet);

// 两个TSet的交集
MySet.Intersect(OtherSet);

// 两个TSet的差集
MySet.Difference(OtherSet);

8. 特定条件的操作

// 过滤或查找满足特定条件的元素
TSet<int32> FilteredSet;
for (int32 Element : MySet) 
{
    if (Element > 3) 
    {
        FilteredSet.Add(Element);
    }
}

4. 打印

4.1 日志打印

// 日志记录级别：Error > Warning > Display
UE_LOG(LogTemp, Error, TEXT("Hello starts Error"));
UE_LOG(LogTemp, Warning, TEXT("Hello starts Warning"));
UE_LOG(LogTemp, Display, TEXT("Hello starts Display"));

4.2 屏幕打印

// 打印到屏幕上
// 默认值，显示时间，显示的颜色，打印内容
GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, TEXT("Hello starts in Screen"));

4.3 格式化输出

int32 test = 1;

UE_LOG(LogTemp, Warning, TEXT("Hello starts Warning : %d"), test);

GEngine->AddOnScreenDebugMessage(-1, 5.0f, FColor::Red, FString::Printf(TEXT("Hello starts in Screen : %d"), test));
#UE5#C++