关于 UE4 的 TArray

TArray，是UE4的可动态扩容数组容器，是UE4里最常见，也是用的最多的一种容器，类似于STL中的vector

 

1. 遍历Array的三种方法

1.1 下标遍历Array（lambda写法）

// 下标法遍历 Array
    auto Foreach_1 = [](TArray<int32> _arr)->void
    {
        for (int32 i = 0; i < _arr.Num(); i++)
        {
            UE_LOG(LogTemp, Display, TEXT("Foreach_1: arr[%d] == %d"), i, _arr[i]);
        }
        UE_LOG(LogTemp, Display, TEXT(" ========================= "));
    };

 

1.2 foreach 遍历Array（lambda写法）

    // foreach 遍历 Array
    auto Foreach_2 = [](TArray<int32> _arr)->void
    {
        if (_arr.Num() > 0)
        {
            for (int32 val : _arr)
            {
                UE_LOG(LogTemp, Display, TEXT("Foreach_2: arr == %d"), val);
            }
            UE_LOG(LogTemp, Display, TEXT(" ========================= "));
        }
    };

 

1.3 迭代器遍历Array（lambda写法）

    // 迭代器遍历 Array
    auto Foreach_3 = [](TArray<int32> _arr)->void
    {
        if (_arr.Num() > 0)
        {
            for (TArray<int32>::TConstIterator it = _arr.CreateConstIterator(); it; ++it)
            {
                UE_LOG(LogTemp, Display, TEXT("Foreach_3: arr == %d"), *it);
            }
            UE_LOG(LogTemp, Display, TEXT(" ========================= "));
        }
    };

 

 

2. Array 的操作

 

　　　　这里所有代码时放置到Actor对象的BeginPlay方法中执行的，并且这里会使用上方的迭代器遍历Array

void AArrayActor::BeginPlay()
{
    Super::BeginPlay();

    // 下标法遍历 Array
    auto Foreach_1 = [](TArray<int32> _arr)->void
    {
        for (int32 i = 0; i < _arr.Num(); i++)
        {
            UE_LOG(LogTemp, Display, TEXT("Foreach_1: arr[%d] == %d"), i, _arr[i]);
        }
        UE_LOG(LogTemp, Display, TEXT(" ========================= "));
    };

    // foreach 遍历 Array
    auto Foreach_2 = [](TArray<int32> _arr)->void
    {
        if (_arr.Num() > 0)
        {
            for (int32 val : _arr)
            {
                UE_LOG(LogTemp, Display, TEXT("Foreach_2: arr == %d"), val);
            }
            UE_LOG(LogTemp, Display, TEXT(" ========================= "));
        }
    };

    // 迭代器遍历 Array
    auto Foreach_3 = [](TArray<int32> _arr)->void
    {
        if (_arr.Num() > 0)
        {
            for (TArray<int32>::TConstIterator it = _arr.CreateConstIterator(); it; ++it)
            {
                UE_LOG(LogTemp, Display, TEXT("Foreach_3: arr == %d"), *it);
            }
            UE_LOG(LogTemp, Display, TEXT(" ========================= "));
        }
    };

    TArray<int32> Arr;
    TArray<int32> Arr_2;
    Arr_2.Init(88, 1);
    // 初始化
    Arr.Init(1, 2);                    　　　　　　　// 初始化内存，初始化类型为int32，每个内存的数据为2，一共初始化3个int32
    Foreach_3(Arr);
    

    // 增加元素，返回 Index
    Arr.Add(2);                                    // Add 提供了引用和右值引用两个版本，会将元素插入到数组的最后位置，并返回元素的Index，内部实现都是通过 CheckAddress() 检查参数有效性并调用Emplace函数。
    Arr.Emplace(3);                                // Emplace 只有右值引用版本，在数组的末尾构造一个新项，可能会重新分配整个数组以适应。也是 Add 调用的方法，Add 只是比他多了数据有效性检查。
    Arr.Push(4);                                　 // 为了方便C语言语法所存在的方法。其源码分引用与右值引用两个版本。其实现是直接调用 Add 方法
    Foreach_3(Arr);

    // 将另一个数组添加到数组（大批量添加）
    Arr.Append(Arr_2);                            // 大批量Add时可以使用，参数为另一个数组。注意右值参数的版本，内部实现可以看到不能避免新分配内存
    Arr += Arr_2;                                 // 与AppEnd一样，大批量添加元素时可以使用
    Foreach_3(Arr);

    // 指定位置添加
    Arr.Insert(0, 3);                            // 将元素0添加到指定下标3的位置，同样这个函数提供了包括右值，GetRef多个版本方便使用。
    Foreach_3(Arr);
    
    // 增加元素，返回增加元素的引用，与上方的Add Emplace 内部实现是一致的，唯一区别是返回值是元素的引用而不是元素的Index
    Arr.Add_GetRef(5);                            // 提供了引用与右值应用两个版本，返回新插入元素的引用；在参数传入后先检查了安全性，然后调用了 Emplace_GetRef
    Arr.Emplace_GetRef(6);                        // 在数组的末尾构造一个新项，可能会重新分配整个数组以适应。也是 Add_GetRef 调用的方法，Add_GetRef 只是比他多了数据有效性检查。
    Foreach_3(Arr);
    
    // 增加元素，保证插入的元素不是重复的,如果重复就返回已经存在的那个Index
    Arr.AddUnique(6);
    Arr.AddUnique(7);
    Arr.AddUnique(8);
    Foreach_3(Arr);

    // 删除元素
    Arr.Remove(1);                                // 删除与参数相等的所有参数，其是用 RemoveAll 实现的
    Foreach_3(Arr);
    Arr.RemoveAll([](const int32 &vel) {return vel < 4; });        // 删除所有符合条件的元素
    Foreach_3(Arr);
    Arr.RemoveAt(0, 2, true);                    // 删除指定位置区间的参数，三个参数：1. 从下标几开始。2. 删除几个元素。3. 删除后的内存是否需要释放。
    Foreach_3(Arr);
    Arr.RemoveAtSwap(0, 2, true);                //在对数组元素的顺序要求不是那么高的情况下，可以使用这个 RemoveAtSwap 函数。这个函数和RemoveAt不同的是在移除之后将数组最后一个元素挪到删除的位置而其他元素位置都保持不变这样就不存在遍历移动的耗时操作了，对于性能要求很高但顺序要求不高的场合下，用这个函数性能会更好一些。
    Foreach_3(Arr);

    // 查找元素
    UE_LOG(LogTemp, Display, TEXT("(7)Index = %d"), Arr.Find(7));        // 查找元素在Array中的下标位置，查找到返回下标，否则返回-1
    UE_LOG(LogTemp, Display, TEXT("(8)Index = %d"), Arr.Find(8));
    UE_LOG(LogTemp, Display, TEXT("(9)Index = %d"), Arr.Find(9));
}

 

打印结果：

　　

 

2.2 关于 TArry 的排序

TArray<int32> KeyList;
    KeyList.Add(1);
    KeyList.Add(0);
    KeyList.Add(3);
    KeyList.Add(5);
    KeyList.Add(2);
    KeyList.Add(4);
    if (KeyList.Num() > 0)
    {
        for (int32 KeyNode : KeyList)
        {
            UE_LOG(LogTemp, Display, TEXT("Key: %d"), KeyNode);
        }
        UE_LOG(LogTemp, Display, TEXT("======================"));

        // 使用 Array 的 Sort (快速排序) 排序后重新输出，排序参数是lambda，< 为升序排序，>为降序排序
        KeyList.Sort([](int32 A, int32 B)->bool {return A < B; });
        for (int32 KeyNode : KeyList)
        {
            UE_LOG(LogTemp, Display, TEXT("Sort       | Key: %d"), KeyNode);
        }
        UE_LOG(LogTemp, Display, TEXT("======================"));

        // 使用 Array 的 HeapSort (堆排序) 排序后重新输出，排序参数是lambda，< 为升序排序，>为降序排序
        KeyList.HeapSort([](int32 A, int32 B)->bool {return A > B; });
        for (int32 KeyNode : KeyList)
        {
            UE_LOG(LogTemp, Display, TEXT("HeapSort   | Key: %d"), KeyNode);
        }
        UE_LOG(LogTemp, Display, TEXT("======================"));

        // 使用 Array 的 StableSort () 排序后重新输出，排序参数是lambda，< 为升序排序，>为降序排序
        KeyList.StableSort([](int32 A, int32 B)->bool {return A < B; });
        for (int32 KeyNode : KeyList)
        {
            UE_LOG(LogTemp, Display, TEXT("StableSort | Key: %d"), KeyNode);
        }
        UE_LOG(LogTemp, Display, TEXT("======================"));
    }

打印结果