【虚幻C++笔记】TArray，TMap，TSet容器

TArray

TArray是虚幻c++中的动态数组，TArray特点：速度快，内存消耗小，安全性高。并且TArray所有元素均完全为相同类型，不能进行不同元素类型的混合

//构造
TArray<int> arr = {1, 2, 3, 4, 5, 6, 7};
// Add 和 Push类似，但是将元素复制或移动到数组中，而Emplace
// 则使用给定参数构建元素类型的新实例；通常来说，Emplace 的效率高于Add；
//添加
arr.Add(8);
//添加
arr.Push(8);
//添加
Arr.Emplace(8);
//当数组里面没有时添加
arr.AddUnique(7);
//在某个位置插入，注意，第一个参数是插入的值，第二个参数是插入位置，如果插入位置大于长度，会崩溃
arr.Insert(99, 2);
TArray<int> arr2 = {8, 9, 9, 9, 10, 11, 12};
//把另外一个TArray拼接进来
arr.Append(arr2);
//删除数组里面的全部某个元素
arr.Remove(9);
//删除数组里面第一个出现符合的元素
arr.RemoveSingle(8);
//删除某个下标位置的元素
arr.RemoveAt(1);

//自定义条件删除元素
arr.RemoveAll([](const int val) { return val < 5; });

//查找第一个出现某个元素的位置
int index = arr.Find(99);
//查找最后一个出现某个元素的位置
int lastIndex = arr.FindLast(99);
//判断数组是否包含某个元素
bool isContain = arr.Contains(99);

// Sort 基于快速排序，是不稳定的排序；
// HeapSort 基于堆排序，是不稳定的排序；
// StableSort 基于归并排序，是稳定的排序。

//从小到大排序 基于快速排序，是不稳定的排序；
arr.Sort();
//自定义条件排序
arr.Sort([](const int A, const int B) { return A > B; });
//基于堆排序，是不稳定的排序；
arr.HeapSort([](const int A, const int B) { return A > B; });
//基于归并排序，是稳定的排序。
arr.StableSort([](const int A, const int B) { return A > B; });

//数组长度
UE_LOG(LogTemp, Display, TEXT("num:%d"), arr.Num());
//待分配长度
UE_LOG(LogTemp, Display, TEXT("Slack:%d"), arr.GetSlack());
//数组已申请内存长度
UE_LOG(LogTemp, Display, TEXT("Max:%d"), arr.Max());
// 3种遍历
for (int val : arr) {
  UE_LOG(LogTemp, Display, TEXT("%d"), val);
}

for (int i = 0; i < arr.Num(); i++) {
  UE_LOG(LogTemp, Display, TEXT("%d"), arr[i]);
}

for (auto it = arr.CreateIterator(); it; ++it) {
  UE_LOG(LogTemp, Display, TEXT("%d"), *it);
}

//清空数组，并释放内存
arr.Empty();
//重置数组，但不释放已经申请的内存
arr.Reset();

TArray<FString> Arr = { TEXT("Are"), TEXT("you"), TEXT("OK"), TEXT("OK") };
int Index = Arr.Find(TEXT("OK"));
//Index is 2 返回数组中第一个与 Str 相同的元素的索引，是否相同用 == 运算符判断；

Index = Arr.Find(TEXT("I"));
//Index is INDEX_NONE

Index = Arr.FindLast(TEXT("OK"));
//Index is 3 返回数组中最后一个与 Str 相同的元素的索引，是否相同用 == 运算符判断；

Index = Arr.IndexOfByKey(TEXT("OK"));
//Index is 2 返回数组中第一个与 Str 相同的元素的索引，是否相同用 == 运算符判断；

Index = Arr.IndexOfByPredicate([](const FString& Str) {return Str.Len() == 3; });
//Index is 0 IndexOfByKey 的lambda 版，用lambda 表达式来指定查找元素的规则。

TArray<FString> Arr = { TEXT("Are"), TEXT("you"), TEXT("OK"), TEXT("OK") };
FString* StrPtr = Arr.FindByKey(TEXT("OK"));
//StrPtr 是一个指向字符串"OK"的指针

StrPtr = Arr.FindByPredicate([](const FString& Str) {return Str.Len() == 3; });
//StrPtr 是一个指向字符串"Are"的指针

TArray<FString> StrArr = Arr.FilterByPredicate([](const FString& Str) {return Str.Len() == 3; });
//StrArr is [Are you]

TMap

TMap是使用Key和Value配对的字典。

//构造
TMap<FString,int> map;
//添加或修改元素
map.Add(TEXT("A"), 10);
map.Add(TEXT("B"), 11);
map.Add(TEXT("C"), 12);
map.Add(TEXT("D"), 13);
map.Emplace(TEXT("B"), 20);
  
//修改元素
map.Emplace(TEXT("C"), 16);
//移除元素
map.Remove(TEXT("D"));
//移除某个key，并把值保存下来
int copyVal = 0;
map.RemoveAndCopyValue(TEXT("C"), copyVal);
//判断是否为空
bool isEmpty = map.IsEmpty();
//获取元素个数
int count = map.Num();
UE_LOG(LogTemp, Display, TEXT("num:%d"),count);
//是否包含
bool isContain = map.Contains(TEXT("B"));
//查找某个Key的元素
int32 *index = map.Find(TEXT("B"));
//查找某个Value的元素
const FString *keyIndex = map.FindKey(20);
//查找某个key的元素的引用
int rIndex = map.FindRef(TEXT("B"));

UE_LOG(LogTemp, Display, TEXT("Find:%d:%s:%d"), *index,*(*keyIndex),rIndex);

//合并另外一个TMap
TMap<FString, int> map2;
map2.Add(TEXT("AA"), 101);
map2.Add(TEXT("BB"), 102);
map2.Add(TEXT("CC"), 103);
map.Append(map2);

//将TMap移动到另外一个TMap，原TMap清空
TMap<FString, int> map3;
map3 = MoveTemp(map);


//获取所有key和value的列表
TArray<FString> keys;
TArray<int> values;
map.GenerateKeyArray(keys);
map.GenerateValueArray(values);
//遍历
for (auto& item : map3)
{
  UE_LOG(LogTemp, Display, TEXT("%s:%d"), *item.Key, item.Value);
}

for (auto It = map3.CreateIterator(); It; ++It)
{
  UE_LOG(LogTemp, Display, TEXT("%s:%d"), *It.Key(), It.Value());
}
//清空
map.Empty();
map.Reset();

TSet

TSet是一种特殊的字典，它不是以下标作为Key，而是用Value本身作为Key。所以TSet里面的元素是不能重复的。

//构建
TSet<FString> strSet = { TEXT("a"),TEXT("d") };
//添加元素
strSet.Add(TEXT("c"));
strSet.Add(TEXT("b"));
strSet.Emplace("f");
//由于key就是值，所以重复添加是不会产生2个的
strSet.Add(TEXT("b"));

//把另一个TSet合并，合并后的顺序没有保证
TSet<FString> strSet2 = { TEXT("x"),TEXT("y"),TEXT("n"),TEXT("e") };
strSet.Append(strSet2);

//移除某个值，返回移除的数量，如果没有包含，则返回0
int removeCount = strSet.Remove(TEXT("n"));

strSet.Sort([](const FString& A, const FString& B)
  {
    return A > B;
  });

//是否包含某个元素
bool isContain = strSet.Contains(TEXT("x"));

//查找某个值，如果找不到会返回nullptr
FString* val = strSet.Find(TEXT("r"));
if (val == nullptr)
{
  UE_LOG(LogTemp, Display, TEXT("find:%s"), TEXT("nullptr"));
}
else
{
  UE_LOG(LogTemp, Display, TEXT("find:%s"), *(*val));
}
//转TArray
TArray<FString> strArr = strSet.Array();
//求交集
TSet<FString> strSet3 = strSet.Intersect(strSet2);
//求并集
TSet<FString> strSet4 = strSet.Union(strSet2);
//求strSet不在strSet2里面的元素集合
TSet<FString> strSet5 = strSet.Difference(strSet2);
//判断strSet是否包含strSet2
bool isInclude = strSet.Includes(strSet2);
//遍历
for (auto& item : strSet)
{
  UE_LOG(LogTemp, Display, TEXT("%s"), *item);
}

for (auto It = strSet.CreateIterator(); It; ++It)
{
  UE_LOG(LogTemp, Display, TEXT("%s"), *(*It));
}
//清空
strSet.Empty();
strSet.Reset();