虛幻引擎的TArray:數組

本文章由cartzhang編寫，轉載請註明出處。 所有權利保留。 

文章鏈接： http://blog.csdn.NET/cartzhang/article/details/45367171

作者：cartzhang

說明：這個爲虛幻官方翻譯的一篇文章。

原文地址：https://docs.unrealengine.com/latest/INT/Programming/UnrealArchitecture/TArrays/index.html

一個月前翻譯的，官方很忙，自己先貼這裏。

若有問題，請隨時聯繫！

時間：2015-03-27

翻譯：cartzhang 

虛幻引擎的TArray:數組

檢查引擎版本爲虛幻4.7

概述

TArray是重要的指向性容器類。它是一個對類型相同的對象（稱爲元素）進行序列組織和管理的類。作爲一個TArray的類，本身就是一個序列，其元素有很好的順序性和它的方法用於準確的操作這些對象和他們的順序。

TArray

TArray是虛幻引擎中最常見的容器類。它被定義爲快速，安全和有效的內存處理類。TArray類型是由兩個屬性來定義的：主元素類型和可選的分配器。

 

元素的類型是指將要被存儲在數組中的對象類型。TArray被稱爲同類型的容器：因爲所有的元素類型必須是嚴格的同一類型。不允許存在混合類型的元素。

 

分配器是經常被忽略的，在大多數的使用時會自動缺省一個分配器。它定義了對象在內存中怎麼放置和數組是怎麼自動適應更多元素的情況。當你覺得缺省的分配器行爲不符合你的要求，你可以使用其他很多不同的分配器，或者你可以自定義分配器。這個將在下面詳細說明。

 

TArray是一個類型，就意味着它應該跟其他的內置類型，比如int32或float類型一樣來對待。它的設計不是用來繼承，並且在堆上創建/銷燬數組被認爲是一個不尋常的做法。容器擁有元素是值類型的，此類元素在數組銷燬時候被銷燬。從另外一個容器中創建一個TArray變量，將會拷貝容器中所有的元素到一個新的變量中；它們的狀態是不共享。

 

創建和填充一個數組

創建一個數組，定義如下：

TArray<int32> IntArray;

這是定義了一個空的數組來存放整數變量的隊列。元素的類型可以是任何可拷貝和可析構的符合常規C++值類型，比如：int32,FString,TSharedPtr等等……因爲沒有指定特殊的分配器，所以這個數組使用的就是常規的堆分配器。而此時，並沒有內存被分配。

 

TArray類型可以被幾種方式來填充。其中一種是通過單個數的多次拷貝來實現填充數組。

IntArray.Init(10, 5);
// IntArray == [10,10,10,10,10] // 把10來拷貝5次填充到數組中。

通過Add和Emplace兩種方式，在數組的最後來添加新的對象。

TArray<FString> StrArr;
StrArr.Add    (TEXT("Hello"));
StrArr.Emplace(TEXT("World"));
// StrArr == ["Hello","World"]

隨着元素的添加，數組的內存通過分配器來分配。Add和Emplace做的事情基本類似，但是有些微小的差別：

l Add將會拷貝（或移動）一個元素類型的實例到數組中。

l Emplace將根據你給的參數創建一個新的元素實例。

因此，在我們的TArray中，Add將會從給出的字符串文字中創建一個臨時的FString對象，然後把臨時對象的內容移動到容器中一個新的FString對象裏面；然而Emplace將會直接使用字符串文字來創建一個FString對象。結果是一樣的，但是Emplace避免了創建臨時對象，這個對於像FString這樣有實際構造的類型來說是非常不受歡迎的。Push和Add的使用是一樣的。

通常來說，Emplace是比Add更好一些的，對將要被容器拷貝或移動的對象，儘量的避免不必要的臨時變量創建。根據以往經驗，對於無實際構造的類型使用Add，否則使用Emplace。Emplace並不是總比Add的效率高，有時候Add也許讀效率更好點。

 

Append允許你一次添加多個元素。不管你是從另外一個TArray、一個指針類型+字節數或常規的C數組，都是可以的。

FString Arr[] = { TEXT("of"), TEXT("Tomorrow") };
StrArr.Append(Arr, ARRAY_COUNT(Arr));
// StrArr == ["Hello","World","of","Tomorrow"]

AddUnique只允許添加一個元素，並且容器中沒有與此元素相同的元素。相等的判定是使用元素類型的操作符==來實現的。

StrArr.AddUnique(TEXT("!"));
// StrArr == ["Hello","World","of","Tomorrow","!"]

StrArr.AddUnique(TEXT("!"));
// StrArr is unchanged as "!" is already an element // 已經有了！，就不改變了。

Insert，跟Add、Emplace和Append類型，它允許你在給出的序列號位置上添加單個元素或拷貝一串元素。

StrArr.Insert(TEXT("Brave"), 1);
// StrArr == ["Hello","Brave","World","of","Tomorrow","!"]

 

SetNum方法直接設置容器中元素個數。若設置的元素個數大於當前容器中元素個數，則新的元素就會通過元素類型的缺省構造函數來創建新元素。

StrArr.SetNum(8);
// StrArr == ["Hello","Brave","World","of","Tomorrow","!","",""]

 

SetNum在新設置的元素個數小於容器中元素個數時，也可以用來刪除元素。更多關於元素刪除細節稍後說明。

StrArr.SetNum(6);
// StrArr == ["Hello","Brave","World","of","Tomorrow","!"]

 

迭代

有幾種關於數組元素迭代的方法，但是仍舊推薦使用C++的範圍循環(ranged-for):

FString JoinedStr;
for (auto& Str : StrArr)
{
    JoinedStr += Str;
    JoinedStr += TEXT(" ");
}
// JoinedStr == "Hello Brave World of Tomorrow ! "

常規的基於順序的迭代當然也是可以的：

for (int32 Index = 0; Index != StrArr.Num(); ++Index)
{
    JoinedStr += StrArr[Index];
    JoinedStr += TEXT(" ");
}

最後，數組自身的迭代器可以來控制迭代。這裏有兩種方法爲CreateIterator和CreateConstIterator，分別用於元素的讀寫和只讀操作。

for (auto It = StrArr.CreateConstIterator(); It; ++It)
{
    JoinedStr += *It;
    JoinedStr += TEXT(" ");
}

 

排序

數組可以調用排序方法來進行簡單的排序。

StrArr.Sort();
// StrArr == ["!","Brave","Hello","of","Tomorrow","World"]

這裏，元素的值通過元素類型的的操作符“<”來進行比較。在FString中，是不區分大小寫的字符順序比較。一個二元匹配條件也可提供不同的比較方式。例如：

StrArr.Sort([](const FString& A, const FString& B) {
    return A.Len() < B.Len();
});
// StrArr == ["!","of","Hello","Brave","World","Tomorrow"]

 

現在，所有字符串按照其長度進行排序。注意到其中有三個字符串的長度是一樣的-：“Hello”，“Brave”和“World”,只是改變了在數組中之前的相對位置。這是因爲排序算法是不穩定的，相等的元素（這裏這些字符串是相等的，因爲他們有一樣的長度）排列順序是無保障的。排序算法比如：快速排序。

 

堆排序，無論是否帶二元的匹配條件，都可以實現堆排序。是否使用堆排序取決於你的特定數據和相對其他排序算法堆排序的有效性。跟之前排序算法相似，堆排序是不穩定排序算法。如果你使用堆排序代替之前的排序，以下是排序結果（本例下，結果是一樣的）：

StrArr.HeapSort([](const FString& A, const FString& B) {
    return A.Len() < B.Len();
});
// StrArr == ["!","of","Hello","Brave","World","Tomorrow"]

 

總之，穩定排序算法在排序後可以保證相等元素的相對位置。然而，如果使用快排或堆排序代替穩定排序，結果如下：

StrArr.StableSort([](const FString& A, const FString& B) {
    return A.Len() < B.Len();
});
// StrArr == ["!","of","Brave","Hello","World","Tomorrow"]

“Hello”，“Brave”和“World”在根據字母順序排序，排序後仍舊得到它們相同的相對位置。穩定排序算法比如歸併排序。

 

查詢

我們可以通過Num方法來知道數組中元素個數。

int32 Count = StrArr.Num();
// Count == 6

如果你需要直接訪問數組內存，或許爲了互操作c-類型的API，你可以使用GetData()方法來返回數組中的元素指針。指針有效性必須以數組存在和任何其他變異操作數組之前。StrPtr指向數組的指針就是指向Num()取得的第一個索引值的元素。

FString* StrPtr = StrArr.GetData();
// StrPtr[0] == "!"
// StrPtr[1] == "of"
// ...
// StrPtr[5] == "Tomorrow"
// StrPtr[6] - undefined behavior

若容器類型是const，那麼返回的指針將也是const類型的。

 

你可以獲得容器可包含元素的空間大小：

uint32 ElementSize = StrArr.GetTypeSize();
// ElementSize == sizeof(FString)

你可以使用索引的操作符 “[]”來檢索元素，只需給它一個從零開始的你想得到的元素索引：

FString Elem1 = StrArr[1];
// Elem1 == "of"

給一個無效的索引值-比0小或比大於等於Num()值的索引-將會導致運行時錯誤。你可以通過IsValidIndex方法來請求容器某個索引否有有效：

bool bValidM1 = StrArr.IsValidIndex(-1);
bool bValid0  = StrArr.IsValidIndex(0);
bool bValid5  = StrArr.IsValidIndex(5);
bool bValid6  = StrArr.IsValidIndex(6);
// bValidM1 == false
// bValid0  == true
// bValid5  == true
// bValid6  == false

 

操作符[]返回值是一個引用值，只要你的數組不是const類型的，你就可以改變數組中的元素。

StrArr[3] = StrArr[3].ToUpper();
// StrArr == ["!","of","Brave","HELLO","World","Tomorrow"]

 

跟GetData方法類型，若數組是const的，操作符[]將返回一個const的引用。你可以使用Last方法來從數組最後來獲得序列元素。索引的缺省值爲0。Top方法與Last作用相反，只是Top不帶索引參數。

FString ElemEnd  = StrArr.Last();
FString ElemEnd0 = StrArr.Last(0);
FString ElemEnd1 = StrArr.Last(1);
FString ElemTop  = StrArr.Top();
// ElemEnd  == "Tomorrow"
// ElemEnd0 == "Tomorrow"
// ElemEnd1 == "World"
// ElemTop  == "Tomorrow"

 

還可以檢查數組中是否包含特定元素：

bool bHello   = StrArr.Contains(TEXT("Hello"));
bool bGoodbye = StrArr.Contains(TEXT("Goodbye"));
// bHello   == true
// bGoodbye == false

或檢查數組中是否匹配特定的匹配條件：

bool bLen5 = StrArr.ContainsByPredicate([](const FString& Str){
    return Str.Len() == 5;
});
bool bLen6 = StrArr.ContainsByPredicate([](const FString& Str){
    return Str.Len() == 6;
});
// bLen5 == true
// bLen6 == false

 

我們可以通過Find家族函數來查找元素。檢查元素是否存在並返回元素索引，可以用：

int32 Index;
if (StrArr.Find(TEXT("Hello"), Index))
{
    // Index == 3
}

這種方法獲得的是從容器中查找到第一個匹配元素索引。如果容器中存在多個複製元素，我們想找到從後倒數第一個匹配元素，我們使用FindLast方法來代替之前：

int32 IndexLast;
if (StrArr.FindLast(TEXT("Hello"), IndexLast))
{
    // IndexLast == 3, because there aren’t any duplicates
}

兩種方法均返回一個布爾值來表示元素是否被找到，並且若找到元素，會將元素索引寫入參數變量中。

 

Find和FindLast也可以直接返回元素索引。只要你不顯式傳遞參數給函數，就會返回元素索引。這種方法比之前的更簡潔，使用哪種方法取決於你的特定需求或風格。

 

若沒有找到元素，則返回一個特殊值INDEX_NONE：

int32 Index2     = StrArr.Find(TEXT("Hello"));
int32 IndexLast2 = StrArr.FindLast(TEXT("Hello"));
int32 IndexNone  = StrArr.Find(TEXT("None"));
// Index2     == 3
// IndexLast2 == 3
// IndexNone  == INDEX_NONE

 

IndexOfByKey的使用方法類似，但是它允許元素和任意對象進行比較。在Find方法中，參數實際上在搜素開始時被轉化爲元素類型（本例轉爲FString）。而在IndexOfByKey方法中，“鍵值”是直接比較的，甚至鍵值類型都不需要轉化爲元素類型。

 

IndexOfByKey可以爲任何類型的鍵值工作，只要你存在操作符“==(ElementType,KeyType)”；這個將會被用於比較。IndexOfByKey將返回第一個被找到的元素索引，或元素沒有找到返回INDEX_NONE。

int32 Index = StrArr.IndexOfByKey(TEXT("Hello"));
// Index == 3

 

IndexOfByPredicate方法可以用於查找到與特定匹配條件第一個匹配的元素索引，若沒有找到，依舊返回特定值INDEX_NONE。

int32 Index = StrArr.IndexOfByPredicate([](const FString& Str){
    return Str.Contains(TEXT("r"));
});
// Index == 2

 

除了返回索引，我們也可以返回找到元素的指針。FindByKey與IndexOfByKey也可用於元素和任意對象比較，但是返回是元素指針。沒找元素返回nullptr。

auto* OfPtr  = StrArr.FindByKey(TEXT("of")));
auto* ThePtr = StrArr.FindByKey(TEXT("the")));
// OfPtr  == &StrArr[1]
// ThePtr == nullptr

 

同樣，FindByPredicate也可以像IndexOfByPredicate使用，但它返回值是索引號。

auto* Len5Ptr = StrArr.FindByPredicate([](const FString& Str){
    return Str.Len() == 5;
});
auto* Len6Ptr = StrArr.FindByPredicate([](const FString& Str){
    return Str.Len() == 6;
});
// Len5Ptr == &StrArr[2]
// Len6Ptr == nullptr

 

最後，當元素中數組匹配某個特殊匹配條件時候，可使用FilterByPredicate方法：

auto Filter = StrArray.FilterByPredicate([](const FString& Str){
    return !Str.IsEmpty() && Str[0] < TEXT('M');
});

 

刪除

你可以使用Remove家族的函數來進行刪除元素的操作。Remove方法將刪除所有與給出的元素相等的元素：

StrArr.Remove(TEXT("hello"));
// StrArr == ["!","of","Brave","World","Tomorrow"]

StrArr.Remove(TEXT("goodbye"));
// StrArr is unchanged, as it doesn’t contain "goodbye"

注意到“HELLo”通過請求移“hello”來刪除了。等於的操作測試是通過元素的操作符“==”來進行的。謹記，對FString而已，比較不區分大小寫。

 

最後一個元素的刪除可以通過 Pop方法來實現：

StrArr.Pop();

// StrArr == ["!", "of", "Brave", "World"]

Remove刪除的是與條件相符的所有實例。例如：

TArray<int32> ValArr;
int32 Temp[] = { 10, 20, 30, 5, 10, 15, 20, 25, 30 };
ValArr.Append(Temp, ARRAY_COUNT(Temp));
// ValArr == [10,20,30,5,10,15,20,25,30]

ValArr.Remove(20);
// ValArr == [10,30,5,10,15,25,30]

你也可以使用RemoveSingle來刪除數組中從前面數到最近的元素。這個是很有用的，比如:你知道數組中包含多個複製對象，你只想刪除一個的時候，或你的數組只能存在一個這樣的元素作爲對數組的優化時，因爲當它找到並刪除以後，就會停止搜索。

ValArr.RemoveSingle(30);
// ValArr == [10,5,10,15,25,30]

我們也可以使用RemoveAt方法來通過元素索引來刪除元素。索引必須存在，否則會報運行時錯誤。謹記：索引是從0開始的：

ValArr.RemoveAt(2); // Removes the element at index 2
// ValArr == [10,5,15,25,30]

ValArr.RemoveAt(99); // This will cause a runtime error as
                       // there is no element at index 99

我們可以使用RemoveAll來刪除與匹配條件匹配的元素。例如：刪除所有3的倍數的值：

ValArr.RemoveAll([](int32 Val) {
    return Val % 3 == 0;
});
// ValArr == [10,5,25]

在所有的刪除操作中，當元素被刪除後，此被刪除元素後面的元素索引會調整到低索引，不可能刪除元素後數組中留下一個“洞”。

這種索引調整過程是有開銷的。若你不在乎剩下的元素順序這種開銷可以使用RemoveSwap、RemoveAtSwap和RemoveAllSwap來降低開銷。這些方法的工作類似與非交換區變量，它們不需要保證剩下元素的順序，只保證它們使用的高效性。

TArray<int32> ValArr2;
for (int32 i = 0; i != 10; ++i)
    ValArr2.Add(i % 5);
// ValArr2 == [0,1,2,3,4,0,1,2,3,4]

ValArr2.RemoveSwap(2);
// ValArr2 == [0,1,4,3,4,0,1,3]

ValArr2.RemoveAtSwap(1);
// ValArr2 == [0,3,4,3,4,0,1]

ValArr2.RemoveAllSwap([](int32 Val) {
    return Val % 3 == 0;
});
// ValArr2 == [1,4,4]

最後，所有元素的刪除使用Empty方法：

ValArr2.Empty();
// ValArr2 == []

操作符

數組作爲一個常規值類型，可通過標準拷貝構造函數或賦值運算操作符來實現拷貝。作爲數組完全擁有其元素，在拷貝數組時進行的是深度拷貝，新數組也將完全擁有拷貝的元素。

TArray<int32> ValArr3;
ValArr3.Add(1);
ValArr3.Add(2);
ValArr3.Add(3);

auto ValArr4 = ValArr3;
// ValArr4 == [1,2,3];
ValArr4[0] = 5;
// ValArr3 == [1,2,3];
// ValArr4 == [5,2,3];

作爲Append方法的替代，數據使用操作符“+=”來實現連接。

ValArr4 += ValArr3;
// ValArr4 == [5,2,3,1,2,3]

數組的比較使用的是操作符==和操作符!=。兩個數組相等，必須是相同的索引有相同的元素值---元素的順序是很重要的。元素的比較使用的是他們自己的操作符“==”。

TArray<FString> FlavorArr1;
FlavorArr1.Emplace(TEXT("Chocolate"));
FlavorArr1.Emplace(TEXT("Vanilla"));
// FlavorArr1 == ["Chocolate","Vanilla"]

auto FlavorArr2 = Str1Array;
// FlavorArr2 == ["Chocolate","Vanilla"]

bool bComparison1 = FlavorArr1 == FlavorArr2;
// bComparison1 == true

for (auto& Str : FlavorArr2)
{
    Str = Str.ToUpper();
}
// FlavorArr2 == ["CHOCOLATE","VANILLA"]

bool bComparison2 = FlavorArr1 == FlavorArr2;
// bComparison2 == true, because FString comparison ignores case

Exchange(FlavorArr2[0], FlavorArr2[1]);
// FlavorArr2 == ["VANILLA","CHOCOLATE"]

bool bComparison3 = FlavorArr1 == FlavorArr2;
// bComparison3 == false, because the order has changed

堆

TArray有支持二叉堆數據結構的函數。堆是任意父節點等效或排序與所有子節點之前的二叉樹。當作爲數組使用時，樹的根節點元素是0，左右字節點序號N的索引依次爲2N+1和2N+2。子節點之間沒有任何特殊排序。

 

一個已存在的數組通過調用Heapify可以轉換到堆空間上。這個是可以根據是否匹配條件來重載函數，沒有匹配條件的版本將使用元素類型的操作符“<”來決定順序：

TArray<int32> HeapArr;
for (int32 Val = 10; Val != 0; --Val)
    HeapArr.Add(Val);
// HeapArr == [10,9,8,7,6,5,4,3,2,1]
HeapArr.Heapify();
// HeapArr == [1,2,4,3,6,5,8,10,7,9]

樹的視圖如下：

 

樹上節點可從左到右，從上到下根據堆數組中元素順序讀取。要說明的是，數組轉換到堆後排序並不是必須的。已排序數組是一個有效堆，其結構定義是足夠鬆散的，並允許多個有效堆有相同元素集。

 

新元素通過使用HeapPush方法來添加到堆上，重新排序其他節點以更新堆。

HeapArr.HeapPush(4);
// HeapArr == [1,2,4,3,4,5,8,10,7,9,6]

 

HeapPop和HeapPopDiscard方法是用來刪除堆的頂節點。不同之處在於前者傳入參數引用，並返回最上面一個元素的拷貝，而後者簡單的刪除頂部節點，不返回任何值。兩種方法結果對數組來說是一樣的，堆通過自適應排序來更新堆。

int32 TopNode;
HeapArr.HeapPop(TopNode);
// TopNode == 1
// HeapArr == [2,3,4,6,4,5,8,10,7,9]

 

HeapRemoveAt方法將刪除指定索引號的元素對象，然後重新排序以更新堆。

HeapArr.HeapRemoveAt(1);
// HeapArr == [2,4,4,6,9,5,8,10,7]

 

值得注意的是，HeapPush、HeapPop、 HeapPopDiscard和HeapRemoveAt均只在堆結構爲有效堆時可被調用，比如：在Heapify()調用之後、其他堆操作或手動把數組轉換之後。

 

當然，這些操作，包括Heapify()，都可以通過二元匹配條件選項來決定節點在堆中順序。當使用匹配條件時，同一匹配條件要使用到所有的堆操作中以維持正確的樹結構。若無特殊匹配條件，堆操作使用的是元素的操作符“<”來決定順序。

 

最後，堆中頂端節點可通過HeapTop來取得，但並不改變數組。

int32 Top = HeapArr.HeapTop();
// Top == 2

預留空間

由於數組是可調整的，它使用的是變長的內存。爲避免每增加一個元素就開闢一次內存，分配器總是提供比請求多的內存，以便在將來添加時重新分配內存的造成性能消耗。同理，刪除元素並不釋放內存。不同的是在作爲預留空間時，容器中多少個元素和有多個的元素能被添加進來，在下次內存分配之前是已知的。

 

數組的缺省構造並不分配內存，預留空間初始化爲0。你可以使用GetSlack方法來獲取數組中有多少個預留空間。另外，在容器中最多能容納的元素個數可以通過Max方法來獲得。GetSlack() 等於Max() - Num()。

TArray<int32> SlackArray;
// SlackArray.GetSlack() == 0
// SlackArray.Num()      == 0
// SlackArray.Max()      == 0

SlackArray.Add(1);
// SlackArray.GetSlack() == 3
// SlackArray.Num()      == 1
// SlackArray.Max()      == 4

SlackArray.Add(2);
SlackArray.Add(3);
SlackArray.Add(4);
SlackArray.Add(5);
// SlackArray.GetSlack() == 17
// SlackArray.Num()      == 5
// SlackArray.Max()      == 22

在重新分配內存後有多少個預留空間取決於分配器，所以它不依賴於用戶數組。

 

大多數情況，你不用關心預留空間。但是當你意識到它時，你可以使用它的優點來對數組進行優化。例如：若你知道，數組中將添加100個新元素，你可以保證你的預留空間至少有100個，這樣當你添加元素時，就不需要再申請空間。上面提到的Empty方法，接受一個可選的預留空間參數。

SlackArray.Empty();
// SlackArray.GetSlack() == 0
// SlackArray.Num()      == 0
// SlackArray.Max()      == 0
SlackArray.Empty(3);
// SlackArray.GetSlack() == 3
// SlackArray.Num()      == 0
// SlackArray.Max()      == 3
SlackArray.Add(1);
SlackArray.Add(2);
SlackArray.Add(3);
// SlackArray.GetSlack() == 0
// SlackArray.Num()      == 3
// SlackArray.Max()      == 3

 

Reset方法工作方式與Empty類似，稍有不同的是，當請求的預留空間已經由當前分配器提供時，它並不釋放內存空間。然而，當需要更大的預留空間時，它將會分配更多內存空間。

 

SlackArray.Reset(0);
// SlackArray.GetSlack() == 3
// SlackArray.Num()      == 0
// SlackArray.Max()      == 3
SlackArray.Reset(10);
// SlackArray.GetSlack() == 10
// SlackArray.Num()      == 0
// SlackArray.Max()      == 10

最後，Shrink方法，它會刪除任何浪費的預留空間，重新分配與當前元素序列需要求同樣大小的空間，實際上不刪除這些對象。

SlackArray.Add(5);
SlackArray.Add(10);
SlackArray.Add(15);
SlackArray.Add(20);
// SlackArray.GetSlack() == 6
// SlackArray.Num()      == 4
// SlackArray.Max()      == 10
SlackArray.Shrink();
// SlackArray.GetSlack() == 0
// SlackArray.Num()      == 4
// SlackArray.Max()      == 4

 

Raw內存

TArray只是對一些分配內存的包裝。它可被當做一個可修改分配字節數和創建元素的類型。TArray總是盡其所能的提供它所有信息，但是有時你也需要降低標準。

 

需要注意的是，若你犯錯誤，這些操作會把容器變成了無效狀態或引起無定義行爲。在這些方法調用之後，其他常規方法被調用之前，你要保證容器處於有效狀態。

 

AddUninitialized和InsertUninitialized方法允許你添加未初始化的空間到數組中。他們分別類似於Add和Insert的工作方式，但是不調用元素類型的構造函數。這對於有安全或方便構造函數的類型來說是很有用的，但是不管怎樣這你都得完全重寫狀態（例如:調用Memcpy內存拷貝），最好不要自尋煩惱。

int32 SrcInts[] = { 2, 3, 5, 7 };
TArray<int32> UninitInts;
UninitInts.AddUninitialized(4);
FMemory::Memcpy(UninitInts.GetData(), SrcInts, 4*sizeof(int32));
// UninitInts == [2,3,5,7]

若你想或者需要控制構造過程，你可以使用保留一些你將要構造對象的內存空間。

TArray<FString> UninitStrs;
UninitStrs.Emplace(TEXT("A"));
UninitStrs.Emplace(TEXT("D"));
UninitStrs.InsertUninitialized(1, 2);
new ((void*)(UninitStrs.GetData() + 1)) FString(TEXT("B"));
new ((void*)(UninitStrs.GetData() + 2)) FString(TEXT("C"));
// UninitStrs == ["A","B","C","D"]

 

AddZeroed和InsertZeroed 功能類似，還將通過添加/插入內存空間清空。當你有一個類型需要插入一些有效的0狀態的字節位時，這個非常有用。

struct S
{
    S(int32 InInt, void* InPtr, float InFlt)
        : Int(InInt)
        , Ptr(InPtr)
        , Flt(InFlt)
    {
    }
    int32 Int;
    void* Ptr;
    float Flt;
};
TArray<S> SArr;
SArr.AddZeroed();

 

與SetNum類似，有SetNumUninitialized和SetNumZeroed兩個方法，不同的是，當新的數字大於當前數字時，兩函數對新元素空間分別進行不初始化或按位賦零。在你使用AddUninitialized和InsertUninitialized方法時，有必要保證，新元素在他們被需要時，被正確的構造在新的空間中。

SArr.SetNumUninitialized(3);
new ((void*)(SArr.GetData() + 1)) S(5, (void*)0x12345678, 3.14);
new ((void*)(SArr.GetData() + 2)) S(2, (void*)0x87654321, 2.72);
// SArr == [
//   { Int: 0, Ptr: nullptr,    Flt: 0.0f  },
//   { Int: 5, Ptr: 0x12345678, Flt: 3.14f },
//   { Int: 2, Ptr: 0x87654321, Flt: 2.72f }
// ]

SArr.SetNumZeroed(5);
// SArr == [
//   { Int: 0, Ptr: nullptr,    Flt: 0.0f  },
//   { Int: 5, Ptr: 0x12345678, Flt: 3.14f },
//   { Int: 2, Ptr: 0x87654321, Flt: 2.72f },
//   { Int: 0, Ptr: nullptr,    Flt: 0.0f  },
//   { Int: 0, Ptr: nullptr,    Flt: 0.0f  }
// ]

使用任何Uninitialized或 Zeroed方法都需要謹慎對待。如果一個元素類型因添加一個成員而被修改，或它不具有有效的字節位爲零的狀態，都能導致無效的數組元素和未定義的行爲。使用這些方法對於幾乎不改變的數組類型大多數是很有用的，比如：FMatrix或FVector。

 

雜項

BulkSerialize方法是一個序列化函數，它可以用於替代數組的操作符“<<”序列化操作，用一塊原生字節的序列化來替代逐個元素的序列化。當你元素類型是常見，比如內置類型或普通數據結構類型時，它的表現還是很棒的。

 

CountBytes和GetAllocatedSize用來估計數組中當前多少內存處於使用中。CountBytes使用的是可直接被調用的FArchive和GetAllocatedSize兩個函數。他們常用於狀態報告。

 

Swap和SwapMemory均需要兩個索引號，將交換兩個索引的元素值。他們兩個作用是一樣的，唯一區別在於Swap會做一些索引的錯誤檢查，若索引不在範圍內就引起斷言。

 

 --------------THE END -------

中途了修改了幾次版本，這個是最後的版本....

不足之處還請各位多多指教。

若有問題，請隨時聯繫！

最後，期待你在下面點擊一下，頂一下那就是對我莫大的鼓舞。再次感謝！