C語言下的容器及泛型程式設計
阿新 • • 發佈：2019-02-10
1 引言
眾所周知，C++語言提供了大名鼎鼎的標準模板庫（STL）作為C++語言下的程式設計利器受到無數青睞，而C語言下並沒有提供類似的工具，使得C語言的開發變得尤為困難和專業化。Nesty框架的NCollection容器為C語言提供了一整套標準的、豐富的模板工具，用以彌補C語言在結構化程式設計上的弱勢。之前發表的一篇文章是關於如何在C語言下進行面向物件程式設計的，主要介紹了NOOC的諸多特性。然而，NOOC真正的作用是為NCollection建立基礎。本文還是以一些簡單的程式碼作為例子，介紹NCollection的使用方法，通過閱讀本節的內容，你將瞭解為什麼NCollection可以大大地加快C語言下開發的效率。2 迭代模型
// incase MyList is a valid NList<NINT> instance
for (NINT Idx = 0; Idx < MyList.Len(); Idx++) {
// extract the element
NINT Val = MyList.GetIdx(Idx); // or MyList[Idx]
}示例（2），Position迭代模式：
for (NPosition Pos = MyList.FirstPos(); Pos; Pos = MyList.Next(Pos)) { // extract the element NINT Val = MyList.GetPos(Pos); // or MyList(Pos) }
示例（3），STL迭代器模式：
// incase my_list is a valid std::list instance
for (std::list<int>::iterator it = my_list.begin(); it != my_list.end(); it++) {
// extract the element
int value = *it;
}通過觀察上例，你會發覺Nesty容器所提供的Position迭代模式更加簡潔，而相比之下STL容器迭代器是一個子包含的物件，每次使用都需要從list型別中解壓，其語法是std::list<int>::iterator，而Position迭代模式通過呼叫容器的通用介面FirstPos返回一個位置資訊，並不斷通過Next及Prev來移動位置，並通過GetPos來從相應位置獲取資料。因此，Position僅代表一個抽象的位置，好比索引（Index）代表的是一個具有具體偏移值的位置一樣。 注意：為了方便闡述，上述程式碼使用了Nesty容器中的C++版本，C語言版本在編碼結構上與其一致，但程式碼略有不同。
3 NCollection容器框架
NCollection是在NOOC的基礎上開發的以面向物件為基礎的一套容器庫，提供約20種容器工具，其型別覆蓋所有通用資料結構，包括向量（NVector），列表（NList），集合（NSet），關聯表（NMap）等，以下是NCollection框架的全景UML圖，其中虛線框代表的是抽象類，實線框代表的是實現類：
在上圖的整個框架中，有五個最為重要的容器介面：
NCollection
NCollection是框架中最頂層的基類，所有容器都派生自NCollection。對於外部而言，NCollection中所定義的操作是隻讀的，即只提供一個Push操作來單個插入元素；由於所有容器都有清空所有元素的操作，NCollection也提供了Empty操作用於批量刪除元素。NSeque
單詞Seque是Sequence的縮寫，代表序列。序列能很好地模擬先進先出（FIFO）及先進後出（FILO）等行為的資料結構。NSeque派生自介面NCollection並提供了一個Pop操作用於一次從容器中彈出一個元素，Pop操作會根據Seque的型別表現出不同的行為。例如，NSeque介面指向的是一個NQueue，則Pop表現為從佇列最前端彈出元素，如果NSeque指向的是一個NStack，則Pop表現為從棧最頂端彈出元素，以此類推。NSeque的實現類有NVector，NPriorQueue，NQueue，NStack。NList
NList是所有列表資料結構的抽象基類。列表具有佇列或棧的屬性，因此是從NSeque派生而來，但除此之外，列表通常還能以高效的速度（通常表現為常數級操作）從前/後、中間插入/刪除元素。列表是最為常用的資料結構，儘管有時候向量（NVector）同樣可以充當列表，但列表專門針對從內部插入/刪除元素作了優化。對於NSeque的介面行為，NList及其所有實現類都表現為佇列（FIFO）的屬性。NList的實現類有NArrayList，NDeList（雙端列表），NLinkedList，NStackList（棧表，行為和連結串列相同，但對記憶體碎片進行了優化）。NSet
NSet代表的是集合。如果僅從元素儲存來看，集合非常類似於列表，都是用於儲存單個元素，而集合卻對元素有快速查詢的能力。List的查詢總是基於遍歷的，其時間複雜度為O(N)，而集合根據規則的不同，能夠提供比列表優越得多的查詢速度，例如對於雜湊而言，其平均查詢的效率通常為常數，而對於紅黑樹而言，其平均查詢時間通常為O(N Log N)。當然，集合在查詢速度上的優化是要付出代價的，例如其遍歷、插入/刪除速度不及列表，而且也無法維持列表元素的先後順序。NSet的實現類有NHashSet，NTreeSet，NArraySet，NLinkedSet，NStackSet。NMap
關聯表（Map）是以鍵（Key）和值（Value）構成的二元關係集合。如同NSet一樣，NMap對鍵擁有快速查詢的能力。為了保證容器在組成上的統一，NMap繼承了NCollection的介面，其介面表現為只對Key進行的操作。NMap的實現類包括：NHashMap，NTreeMap，NArrayMap，NLinkedMap，NStackMap。4 在C語言中使用Nesty容器
C語言是一門面向過程的程式語言，然而，通過對設計方法的規範化，依然可以在C語言使用C++中類似封裝，基於物件，甚至面向物件（NOOC）等的程式設計技術。物件包括了資料及方法的概念，因此在Nesty C的所有型別也按照類似的規則來定義。以NVector為例，NVector的資料是全大寫的物件NVECTOR，而NVector的操作是一組以NVector單詞開頭的函式的集合，如NVectorNew，NVectorAdd，NVectorDel等，以下程式碼片段演示如何在C語言下進行容器程式設計：// 建立NINT型別的容器物件
NVECTOR Vec = NVectorNew(NINT);
// 插入元素
NINT InsertValue = 3;
NVectorAdd(Vec, InsertValue);
// 刪除元素
NINT DeleteValue = 3;
NVectorDel(Vec, DeleteValue);
// 遍歷元素
NPOSITION Pos = NVectorFirstPos(Vec);
for (; Pos; Pos = NVectorNext(Vec, Pos)) {
NINT Val = NVectorGetPos(Vec, Pos, NINT);
}
// 不過對於向量，可以直接使用索引迭代模式
NINT Idx = 0;
for (; Idx < Vec->Len; Idx++) {
NINT Val = NvectorGetIdx(Vec, Pos, NINT);
}5 C語言與泛型程式設計
泛型是從C++模板引入的概念，然而C語言下實現泛型可以利用無型別指標（void *）。而型別資料從二進位制的角度來探討，不外只是一塊有指定大小的記憶體塊；由於任何型別的指標的都可以隱式轉換為一個void *的地址，因此利用一個數據大小值，以及一個指向該資料頭部的無型別地址（void *）即可以表達任何型別的泛型。 但是定義一個型別光知道型別的大小是不行的，型別必須具有其獨特的行為，從型別資料的生存期來看，型別應該具備以下三個最為基本的行為（操作）：建立（Create），拷貝（Copy），銷燬（Destroy）。以動態字串為例，字串的大小代表該字串佔用了多少個字元位元組。在字串建立時，需要將其初始化為指向一個有效字串的地址，當需要拷貝字串時，需要將字串資料進行逐字元拷貝，當字串不再被使用時，應該釋放其佔用的記憶體，並將字串指標初始化為0。 因此，在Nesty的框架中，型別的大小，建立，拷貝，銷燬這4個屬性構成了該型別的特徵簽名，這一概念和C++類的建構函式，複製拷貝操作符，解構函式等是對應的。6 泛型與Type Class
根據上一節的介紹，Nesty引入了Type Class的概念來支援C語言的泛型操作，在程式程式碼中由NTYPE_CLASS資料結構給出相關定義，Type Class指定了某型別相關的特性及操作，以下便是NTYPE_CLASS的定義：typedef struct tagNTYPE_CLASS
{
// type identifier
NINT TypeSize;
NPfnCreate FnCreate;
NPfnCopy FnCopy;
NPfnDestroy FnDestroy;
// type functions
NPfnMatch FnMatch;
NPfnCompare FnCompare;
NPfnHash FnHash;
NPfnPrint FnPrint;
// template functions
NPfnSwap FnSwap;
} NTYPE_CLASS;
typedef tagMYDATA MYDATA;
struct tagMYDATA {
NINT Value;
};
// define Create behavior
void CreateMyData(NVOID * InThis, const NVOID * InOther) {
MYDATA * This = (MYDATA *)InThis;
MYDATA * Other = (MYDATA *)Other;
if (Other) {
This->Value = Other->Value;
}
else {
This->Value = 0;
}
}
// define Copy behavior
void CopyMyData(NVOID * InThis, const NVOID * InOther) {
MYDATA * This = (MYDATA *)InThis;
MYDATA * Other = (MYDATA *)Other;
NASSERT(Other); // source MUST not NULL!!!
This->Value = Other->Value;
}
// define Destroy behavior
void DestroyMyData(NVOID * InThis) {
MYDATA * This = (MYDATA *)InThis;
This->Value = 0;
}
為了方便闡述，以下先給出了NPfnCreate，NPfnCopy，及NPfnDestroy介面的定義：
typedef (*NPfnCreate)(NVOID * InThis, const NVOID * InOther);
typedef (*NPfnCopy)(NVOID * InThis, const NVOID * InOther);
typedef (*NPfnDestroy)(NVOID * InThis);MYDATA MyData, OtherData;
// create MYDATA by default construct
CreateMyData(&MyData, NULL);
// after create, MyData.Value will have the default value of 0
NASSERT(MyData.Value == 0);
// create MYDATA by copy construct, incase OtherData.Value == 3
CreateMyData(&MyData, &OtherData);
// after create, MyData.Value will have the initialized value of 3
NASSERT(MyData.Value == 3);
// copy MYDATA, incase OtherData.Value == 5
CopyMyData(&MyData, &OtherData);
// after copy, MyData.Value will have the updated value of 5
NASSERT(MyData.Value == 5);
// destruct MYDATA
DestroyMyData(&MyData);
// after destroy, MyData.Value will have the cleanup value of 0
NASSERT(MyData.Value == 0);typedef (*NPfnCompare)(const NVOID * InThis, const NVOID * InOther);
typedef (*NPfnMatch)(const NVOID * InThis, const NVOID * InOther);
typedef (*NPfnHash)(const NVOID * InThis);
typedef (*NPfnPrint)(const NVOID * InThis, NCHAR * InBuf, NINT InLen);
typedef (*NPfnSwap)(NVOID * InThis, NVOID * InOther);NBOOL MatchMyData(const NVOID * InThis, const NVOID * InOther) {
MYDATA * This = (MYDATA *)InThis;
MYDATA * Other = (MYDATA *)Other;
return (NBOOL)(This->Value == Other->Value);
}
NBOOL CompareMyData(const NVOID * InThis, const NVOID * InOther) {
MYDATA * This = (MYDATA *)InThis;
MYDATA * Other = (MYDATA *)Other;
return (NBOOL)(This->Value < Other->Value);
}
NUINT HashMyData(const NVOID * InThis) {
MYDATA * This = (MYDATA *)InThis;
return (NUINT)This->Value;
}
NINT PrintMyData(const NVOID * InThis, NCHAR * InBuf, NINT InLen) {
MYDATA * This = (MYDATA *)InThis;
return NSnprintf(InBuf, InLen, _t("%d"), This->Value);
}
void SwapMyData(NVOID * InThis, NVOID * InOther) {
MYDATA * This = (MYDATA *)InThis;
MYDATA * Other = (MYDATA *)Other;
MYDATA Tmp = *This;
*This = *Other;
*Other = Tmp;
}NTYPE_CLASS TypeClass = { sizeof(MYDATA), CreateMyData, CopyMyData, DestroyMyData,
MatchMyData, CompareMyData, HashMyData, PrintMyData, SwapMyData };
NVECTOR Vec = NVectorNewCustom(&TypeClass, /* more parameters has been omitted */);
NINT Idx = 0;
for (; Idx < 8; Idx++) {
MYDATA Tmp;
Tmp.Value = Idx;
NVectorAdd(Vec, Tmp);
}
// print elements
NVectorPrint(Vec, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)看到這裡你或許不禁要問，如果每使用一種型別都需要定義這麼多型別操作函式，還需要填充NTYPE_CLASS，在使用上豈不是相當麻煩？從表面上看，是的。然而，Nesty框架已經考慮到了這些問題，並且系統已經為大量常用型別預定義了Type Class，這些型別包括一些基本型別，如NINT, NUINT, NFLOAT, NDOUBLE等，大部分情況下，你不需要理會Type Class，只需要簡單地使用這些預定義的型別；然而，對於像MYDATA這種使用者自定義的資料結構，你還是需要提供一個Type Class，不過Nesty已經為你定製好了非常方便的工具，在最簡單的情況下，你只需要兩行程式碼即可以定義一個Type Class，之後會有單獨的小節介紹如何使用這個功能。
7 建立容器
有了上一節的內容作為基礎，本節將詳細介紹容器的建立方法。由於所有的容器型別都是NOBJECT物件，其建立使用的是new規則，即從堆上分配一塊記憶體並初始化，因此當結束使用時仍然需要呼叫NRELEASE介面釋放物件：NVECTOR Vec = NVectorNew(NINT);
// before exit
NRELEASE(Vec);NTYPE_CLASS * TypeClass = TypeClassNINT();
NVECTOR Vec = NVectorNewCustom(TypeClass, /* more paramter has been omitted */);// create a unsigned int container
NVECTOR Vec = NVectorNew(NUINT);
// but, grammar like the following is invalid!
// NVectorNew(unsigned int); NVECTOR NVectorNewCustom(const NTYPE_CLASS * InTypeClass, NBOOL InAutoShrinkable, const NALLOC_CLASS * InAllocClass);typedef struct tagNALLOC_CLASS
{
NPfnMalloc FnMalloc;
NPfnRealloc FnRealloc;
NPfnFree FnFree;
NPfnCalculateStackSize FnCalculateStackSize;
} NALLOC_CLASS;下面是NPfnMalloc，NPfnRealloc，NPfnFree及NPfnCalculateStackSize的定義：
typedef NVOID * (*NPfnMalloc) (NSIZE_T InSize);
typedef NVOID * (*NPfnRealloc) (NVOID * InPtr, NSIZE_T InSize);
typedef void (*NPfnFree) (NVOID * InPtr);
typedef NINT (*NPfnCalculateStackSize)(NINT InStackNum, NINT InStackMax);與TypeClass的規則類似，TypeClass用於描述型別資料是如何建立和銷燬的，而AllocClass則描述容器內部的記憶體是如何被管理的；當容器內部需要為元素分配/釋放記憶體時，都會呼叫FnMalloc/FnRealloc/FnFree所指向的函式；這三者最為常見的實現是，直接呼叫作業系統的記憶體分配策略，如下所示：
NVOID * DefaultMalloc(NSIZE_T InSize) { return malloc(InSize); }
NVOID * DefaultAlloc(NVOID * InPtr, NSIZE_T InSize) { return realloc(InPtr, InSize); }
void DefaultFree(NVOID * InPtr) { free(InPtr); }值得注意的是，只有那些具有活動棧屬性的容器才會提供InAutoShrinkable標誌及FnCalculateStackSize才會發揮作用，對於那些無法提供棧屬性的容器（例如NLinkedList等），則上述的引數將被忽略掉。具有活動棧屬性的容器有：NVector，NPriorQueue，NArrayList，NDeList，NStackList，NArraySet，NStackSet，NArrayMap，NStackMap。
8 新增/刪除及訪問元素
往容器中新增元素，可以通過Push和Add方法，Push與Pop構成堆疊相互對應的操作；然而，當容器不作為堆疊使用時，為了區分這些操作的意思，大部分容器都定義了相關的Add及Del操作用於新增/刪除元素，實際上Push和Add的行為是一樣的，只不過其代表的意義不同而已。下面以NArrayList為例，演示瞭如何往容器新增元素：NARRAY_LIST List = NArrayListNew(NINT);
NINT Val = 0;
NArrayListAdd(List, Val);
Val = 1;
NArrayListAdd(List, Val);
NArrayListPrint(List, NSystemOut());
// Outputs:
// [2](0, 1)typedef void NELEMENT_T;
NPOSITION _NArrayListAdd(NARRAY_LIST InObj, const NELEMENT_T * InElement);當明白了Nesty泛型的工作原理後，你便了解為什麼需要預先初始化一份臨時資料並用於插入/刪除，因為這個臨時資料能夠產生一個有效的無符號地址，並將該地址的資料作為插入元素的資料傳遞給容器內部的Type Class的Create操作。為了便於理解這一概念，下面提供了一個分解的操作：
NINT Val = 0;
_NArrayListAdd(List, &Val);// invalid grammar, you MUST have a initialized varable, but NOT a literal
// NArrayListAdd(List, 0);NARRAY_LIST List = NArrayListNew(NINT);
NINT Idx = 0;
for (; Idx < 8; Idx++) {
NArrayListAdd(List, Idx);
}
NArrayListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)
NINT ValToDel = 3;
NArrayListDel(List, ValToDel);
NArrayListPrint(List, NSystemOut());
// Outputs:
// [7](0, 1, 2, 4, 5, 6, 7)// definition of _NArrayListGetIdx
NELEMENT_T * _NArrayListGetIdx(NARRAY_LIST InObj, NINT InIdx)
// incase List is a valide instance of NARRAY_LIST of type NINT
NArrayListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)
NINT Val = *(NINT *)_NArrayListGetIdx(List, 3);
NASSERT(Val == 3);NINT Val = NArrayListGetIdx(List, 3, NINT);
NASSERT(Val == 3);
NINT * ValPtr = &NArrayListGetIdx(List, 6, NINT);
NASSERT(*ValPtr == 6);9 基於介面的容器程式設計
從前面介紹NCollection框架的小節我們瞭解到，NCollection提供了幾個通用的介面，這些介面和實現類是通過NOOC的繼承關係實現的，意味著我們可以使用任一繼承鏈上的介面的方法來操作實現類，下面的例子演示當我們需要使用NArrayList時，可以通過NList介面的方法，因為NArrayList是繼承自NList的，這樣可以增加很多靈活性；例如，我們可以在建立介面時將NArrayList更換為別的列表而程式的其他部分不受影響：NLIST List = (NLIST)NArrayListNew(NINT);
NINT Idx = 0;
for (; Idx < 8; Idx++) {
NListAdd(List, Idx);
}
NListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)void CopyUniqueInt(NCOLLECTION InDst, const NCOLLECTION InSrc) {
NPOSITION Pos = NCollectionFirstPos(InSrc);
for (; Pos; Pos = NCollectionNext(InSrc, Pos)) {
NINT Val = NCollectionGetPos(InSrc, Pos, NINT);
if (NCollectionFindPos(InDst, Val) == 0) {
NCollectionPush(InDst, Val);
}
}
}10 遍歷元素
我們在第2小節的時候已經討論過了迭代模型，Position模式作為Nesty容器的標準模式為所有型別的容器提供了一致的的迭代介面，其意義在於為實現泛型演算法提供支援。如果你對Position模式並不適應，NList介面還提供了更為直觀的Index模式，利用Index模式進行迭代類似於遍歷陣列元素，但對某些型別的容器，Index模式在效率上會大打折扣。Position/Index模式
為了更好理解Position模式和Index模式，下面的例子用Position模式分別以前向及後向迭代列表元素：NLIST List = (NLIST)NLinkedListNew(NINT);
NPOSITION Pos = NULL;
NINT Idx = 0;
// push elements
for (; Idx < 8; Idx++) {
NListAdd(List, Idx);
}
// forward iteration
for (Pos = NListFirstPos(List); Pos; Pos = NListNext(List, Pos)) {
NINT Val = NListGetPos(List, Pos, NINT);
NPrintf(_t("%d, "), Val);
}
// Outputs:
// 0, 1, 2, 3, 4, 5, 6, 7,
// backward iteration
for (Pos = NListLastPos(List); Pos; Pos = NListPrev(List, Pos)) {
NINT Val = NListGetPos(List, Pos, NINT);
NPrintf(_t("%d, "), Val);
}
// Outputs:
// 7, 6, 5, 4, 3, 2, 1, 0,
// index iteration
for (Idx = 0; Idx < NListLen(List); Idx++) {
NINT Val = NListGetIdx(List, Idx, NINT);
NPrintf(_t("%d, "), Val);
}
// Outputs:
// 0, 1, 2, 3, 4, 5, 6, 7,迭代中刪除元素
迭代容器是按Position逐個迭代，刪除元素也是按Position逐個刪除；需要注意的是，像NListDelPos這種型別的介面會返回刪除後下一個元素的Position，其原型為：NPOSITION NListDelPos(NLIST InObj, NPOSITION InPos);NPOSITION Pos = NULL;
NListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)
for (Pos = NListFirstPos(List); Pos; ) {
NINT Val = NListGetPos(List, Pos, NINT);
if (Val > 1 && Val < 6) {
Pos = NListDelPos(List, Pos);
}
else {
Pos = NListNext(List, Pos);
}
}
NListPrint(List, NSystemOut());
// [4](0, 1, 6, 7)NPOSITION Pos = NULL;
NListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 2, 3, 4, 5, 6, 7)
for (Pos = NListLastPos(List); Pos;) {
NINT Val = NListGetPos(List, Pos, NINT);
NPOSITION Prev = NListPrev(List, Pos);
if (Val > 1 && Val < 6) {
NListDelPos(List, Pos);
}
Pos = Prev;
}
NListPrint(List, NSystemOut());
// [4](0, 1, 6, 7)11 使用迭代器
迭代器的介面是由物件NITERATOR提供的，下面通過幾段簡短的程式碼來演示其用法：NLIST List = (NLIST)NLinkedListNew(NINT);
NITERATOR It = NULL;
NINT Vals[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
NListAddNum(List, Vals, NARRAY_LEN(Vals));
It = NListIterator(List, NFALSE);
while (NIteratorHasNext(It)) {
NINT Val = NIteratorNext(It, NINT);
NPrintf(_t("%d, "), Val);
if (Val > 1 && Val < 6) {
NIteratorRemove(It);
}
}
// Outputs:
// 0, 1, 2, 3, 4, 5, 6, 7
NRELEASE(It);
NListPrint(List, NSystemOut());
// Outputs:
// [4](0, 1, 6, 7)NLIST List = (NLIST)NLinkedListNew(NINT);
NITERATOR It = NListIterator(List, NFALSE);
NPOSITION Pos = NIteratorPosition(It);
NASSERT(Pos == NULL);
if (NIteratorHasNext(It)) {
NIteratorNext(It, NINT);
Pos = NIteratorPosition(It);
NASSERT(Pos != NULL);
}迭代器的方法NIteratorHasNext及NIteratorNext/_NIteratorNext是配合使用的，只有通過NIteratorHasNext檢測存在下一個元素的時候，才能呼叫NIteratorNext/_NIteratorNext移動迭代器的位置，NIteratorNext/_NIteratorNext在移動下一位置的同時返回當前的值，使用者通過檢測這個值判斷是否要對當前元素執行刪除操作，其語法如下所示：
NITERATOR It = NListIterator(List, NFALSE);
while (NIteratorHasNext(It)) {
NINT Val = NIteratorNext(It, NINT);
NBOOL ShouldRemove = /* check current value */;
if (ShouldRemove) {
NIteratorRemove(It);
}
}
NRELEASE(It);// for list or other single element containers
NList List = (NLIST)NArrayListNew(NINT);
NITERATOR Items = NListIterator(List, NFALSE);
while (NIteratorHasNext(Items)) {
NINT Val = NIteratorNext(Items, NINT);
NINT Key = NIteratorGetKey(Items, NINT);
NASSERT(Val == Key);
}
// for map the key-value pair element containers
NMAP Map = (NMAP)NHashMapNewMulti(NINT, NCHARS);
NINT Key = 0;
NCHAR * Val = _t("ABCD");
NMapAdd(Map, Key, Val); // push more 0 and "ABCD"
NITERATOR Pairs = NMapIterator(Map, NFALSE);
while (NIteratorHasNext(Pairs)) {
NCHAR * Val = NIteratorNext(Pairs, NCHARS);
NINT Key = NIteratorGetKey(Pairs, NINT);
NASSERT(Key == 0);
NASSERT(NStrcmp(Val, _t("ABCD") == 0);
}12 字串及容器
由於TypeClass介面所發揮的特殊作用，在Nesty容器介面中使用字串元素顯得十分方便，你只需要像建立其他型別一樣使用NCHARS型別，如下所示：NHASH_MAP Map = NHashMap(NCHARS, NINT);
NCHAR * Key = _t("nesty");
NINT Val = 0;
NHashMapAdd(Map, Key, Val);
// Add more key and value ...NCHAR * Key = _t("nesty");
NPOSITION Pos = NHashMapFindPos(Map, Key);
NINT Val = NHashMapGetValue(Map, Pos, NINT);typedef const NCHAR * NCHARS;NHASH_MAP Map = NHashMap(NCHARS, NINT);
NCHAR * Key = _t("nesty");
NINT Val = 0;
NHashMapAdd(Map, Key, Val);
NPOSITION Pos = NHashMapFindPos(Map, Key);
const NCHAR * KeyFromMap = NHashMapGetKey(Map, Pos, NCHARS);
NASSERT(Key != KeyFromMap);NMAP_MAP Map = NHashMapNew(NCHARP, NINT);
NCHAR * Key = (NCHAR *)NMalloc(sizeof(NCHAR *) * NStrlen(_t("nesty")));
NINT Val = 0;
NStrcpy(Key, _t("nesty"));
NHashMapAdd(Map, Key, Val);
// ...NPOSITION Pos = NHashMapFirstPos(Map);
for (; Pos; Pos = NHashMapNext(Map, Pos)) {
const NCHAR * Key = NHashMapGetKey(Map, Pos);
// release string memory
NFree(Key);
}
NHashMapEmpty(Map);
// ...NMAP_MAP Map = NHashMapNew(NSTRING, NINT);
NSTRING Str = NStringNew(_t("nesty"));
NINT Val = 0;
NHashMapAdd(Map, Str, Val);
NRELEASE(Str);NSTRING Tmp = NStringNew(_t("nesty"));
NPOSITION Pos = NHashMapFindPos(Map, Tmp);
// After done finding
NRELEASE(Tmp);13 型別與Type Class
通過前面小節的介紹，Nesty已經預定義了部分常用資料型別的TypeClass，因此這些型別可以直接作為容器建立介面的引數，這些常用型別有： 整型：NBYTE，NUBYTE，NSHORT，NUSHORT，NINT，NUINT，NLONG，NULONG 浮點型：NFLOAT，NDOUBLE 字元型：NCHAR，NCHARP，NCHARS，NSTRING 及等等…… 然而，對於某些使用者自定義的型別（如第6節中的自定義型別MYDATA），為了能夠讓容器使用這些型別，程式設計師在定義資料的同時，也要定義相應的Type Class；Nesty的系統已經為你提供了非常方便的工具來達到目的。需要定義型別的TypeClass，需要兩個步驟，首先在宣告程式碼中（最好是與資料結構定義處於同一檔案中）使用巨集NTYPE_CLASS_DEC來宣告TypeClass，然後在實現程式碼中提供相應的協議函式（如前面介紹的Create，Copy，Destroy的操作的函式），並用NTYPE_CLASS_IMP巨集來繫結這些協議函式。建立普通型別的TypeClass
當前所指的普通型別，是指由C的關鍵字struct或者typedef定義的型別，不包括NOOC物件型別，以MYDATA為例：typedef tagMYDATA MYDATA;
struct tagMYDATA {
NINT Value;
};
// declaration part
NTYPE_CLASS_DEC(MYDATA);
// implementation part
void CreateMyData(NVOID * InThis, const NVOID * InOther) {...}
void CopyMyData(NVOID * InThis, const NVOID * InOther) {...}
void DestroyMyData(NVOID * InThis) { ... }
// ... and more actions, Match, Compare, Hash, Print
NTYPE_CLASS_IMP(MYDATA,
CreateMyData,
CopyMyData,
DestroyMyData,
MatchMyData,
CompareMyData,
HashMyData,
PrintMyData);
// After create the Type Class for MYDATA type,
// you can use 'MYDATA' as the parameter of containers
NLINKED_LIST List = NLinkedListNew(MyData);
// ....NTYPE_CLASS_IMP(MYDATA,
CreateMyData,
CopyMyData,
DestroyMyData,
NULL,
NULL,
NULL,
NULL);NTYPE_CLASS_IMP(MYDATA,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL,
NULL);NTYPE_CLASS_IMP_DEFAULT(MYDATA);TypeClass協議的預設實現
當你使用巨集NTYPE_CLASS_IMP並給相應的協議操作傳遞NULL引數時，Nesty將為這些操作提供預設實現，下面列舉出這些預設實現的相關內容，繼續以MYDATA為例： 1） Create 會有條件地執行記憶體拷貝，當Create操作的InOther引數為空時，會通過NZeroMemory將記憶體清零，如：void CreateDefaultMyData(NVOID * InThis, const NVOID * InOther) {
if (InOther) {
NMemcpy(InThis, InOther, sizeof(MYDATA));
}
else {
NZeroMemory(InThis, sizeof(MYDATA));
}
}void CopyDefaultMyData(NVOID * InThis, const NVOID * InOther) {
NMemcpy(InThis, InOther, sizeof(MYDATA));
}void DestroyDefaultMyData(NVOID * InThis, const NVOID * InOther) {
NZeroMemory(InThis, sizeof(MYDATA));
}NBOOL MatchDefaultMyData(const NVOID * InThis, const NVOID * InOther) {
return (NBOOL)(return NMemcmp(InThis, InOther, sizeof(MYDATA)) == 0);
}
NBOOL CompareDefaultMyData(const NVOID * InThis, const NVOID * InOther) {
return (NBOOL)(return NMemcmp(InThis, InOther, sizeof(MYDATA)) < 0);
}
NUINT HashDefaultMyData(const NVOID * InThis) {
return NMemhash(InThis, sizeof(MYDATA));
}NINT PrintDefaultMyData(const NVOID * InThis, NCHAR * InBuffer, NINT InLength) {
return NSnprintf(InBuffer, InLength, _t("%p"), InThis);
}NOOC物件型別Type Class
建立NOOC的物件型別的Type Class相當簡單，只需要使用巨集NTYPE_CLASS_IMP_OBJECT，不需要實現及填寫任何的協議操作，由於NOOC物件型別的NOBJECT介面包含了Clone，Comp，Equal，HashCode及ToString等操作，NTYPE_CLASS_IMP_OBJECT實現會直接呼叫這些介面來實現TypeClass，因此NOOC物件是通過過載相應的介面來實現TypeClass的協議的；下面例子只簡單演示如何為NOOC物件MYOBJ建立TypeClass：NOBJECT_PRED(MYOBJ);
NOBJECT_DEC(MYOBJ, NOBJECT);
struct tagMYOBJ {
NOBJECT_BASE(NOBJECT);
NINT Val;
}
// declaration part
NTYPE_CLASS_DEC(MYOBJ);
// implementation part
NOBJECT MyObjClone(const MYOBJ InObj) { ... }
NBOOL MyObjEqual(const MYOBJ InObj, const NOBJECT InOther) { ... }
NBOOL MyObjComp(const MYOBJ InObj, const NOBJECT InOther) { ... }
NUINT MyObjHashCode(const MYOBJ InObj) { ... }
NSTRING MyObjToString(const MYOBJ InObj) { ... }
NOBJECT_IMP(MYOBJ, NOBJECT,
NCLONE_BIND(MyObjClone)
NEQUAL_BIND(MyObjEqual)
NHASHCODE_BIND(MyObjHashCode)
NCOMP_BIND(MyObjComp)
NTOSTRING_BIND(MyObjToString)
);
NTYPE_CLASS_IMP_OBJECT(MYOBJ);14 容器與持有物件
NOOC物件是一個引用計數物件，其通過引用計數來實現例項之間的共享及垃圾回收等操作，每一個NOOC物件在通過NNEW建立時其原始計數都為，因此當使用完畢後，必須通過NRELEASE介面來釋放計數，以便系統回收為其分配的動態記憶體。然而當該物件需要被共享（或者需要被其他物件所持有時），可以通過呼叫NACQUIRE介面來增加引用計數，以NSTRING物件為例：NSTRING Str = NStringNew(_t("hello Nesty"));
NASSERT(NCOUNTER(Str) == 1);
// Hold(Acquire) object reference
NSTRING NewRef = Str;
NACQUIRE(NewRef);
NASSERT(NCOUNTER(Str) == 2);
// After done working, you have to call equivalent numbers of NRELEASE to reclaim the object
NRELEASE(NewRef);
NRELEASE(Str);
NMAP_MAP Map = NHashMapNew(NSTRING, NINT);
NSTRING Str = NStringNew(_t("nesty"));
NINT Val = 0;
NHashMapAdd(Map, Str, Val);
NRELEASE(Str);15 容器與元素分配
為了方便描述本節的內容，先回到之前MYDATA的定義，並在這裡稍作修改：typedef struct tagMYDATA MYDATA;
struct tagMYDATA {
NBYTE Data[32];
}NVECTOR Vec = NVectorNew(MYDATA);
NINT Idx = 0;
for (; Idx < 8; Idx++) {
MYDATA Tmp;
NVectorAdd(Vec, Tmp);
}// NVOIDP is a typedef of void *
NVECTOR Vec = NVectorNew(NVOIDP);
MYDATA * Tmp = (MYDATA *)NMalloc(sizeof(MYDATA));
NVectorAdd(Vec, Tmp);
// Add more elements...NINT Idx = 0;
for (; Idx < Vec->Len; Idx++) {
NVOID * Data = NVectorGetIdx(Vec, Idx, NVOIDP);
NFree(Data);
}
NVectorEmpty(Vec);16 列印及除錯容器
為了方便對容器進行除錯，容器提供了一套規範的字串化功能，但是字串花需要TypeClass協議中Print操作的支援，即前提是某型別已經在其TypeClass中定義了Print操作。所有的容器都提供了相關的Print介面，如NArrayListPrint，NSetPrint等，這些Print介面都接受一個NSTREAM_OUT的物件作為輸出物件，NSystemOut()代表輸出到系統的標準輸出介面，通常為命令列控制檯，但也可以輸出到Buffer。以NINT型別的容器為例：NARRAY_LIST List = NArrayListNew(NINT);
// incase List has elements: 0, 1, 2, 3, 4, 5, 6, 7
NArrayListPrint(List, NSystemOut());[8]( 0 1 2 3 4 5 6 7 )// String Buffer example:
NSTRING_BUFFER Buffer = NStringBufferNew(4096);
NSTRING_BUFFER_OUT BufferOut = NStringBufferOutNew(Buffer);
NArrayListPrint(List, (NSTREAM_OUT)BufferOut);
// Process buffer
NPrintf(Buffer->Chars); NHASH_SET Set = NHashSetNew(NINT);
NINT Idx = 0;
for (; Idx < 12; Idx++) {
NHashSetAdd(Set, Idx);
}
NHashSetState(Set, NSystemOut());
NRELEASE(Set);
----
State Map: Len = 12, HashSize = 8, Multiple = 0, Sorted = 0
----
State Hash:
[0]( 0 8 )[2]
[1]( 1 9 )[2]
[2]( 2 10 )[2]
[3]( 3 11 )[2]
[4]( 4 )[1]
[5]( 5 )[1]
[6]( 6 )[1]
[7]( 7 )[1]
----
Statistics:
Hash Chain = 8, Total Bucket = 12, Max Bucket = 2, Min Bucket = 1, Average Bucket = 1.500000另外，對於二叉樹資料結構，也同樣可以利用State方法來窺探其各元素在樹中的分配是否足夠平衡：
NTREE_SET Set = NTreeSetNew(NINT);
NINT Idx = 0;
for (; Idx < 12; Idx++) {
NTreeSetAdd(Set, Idx);
}
NTreeSetState(Set, NSystemOut());
NRELEASE(Set);----
State Map: Len = 12, Multiple = 0
----
State Tree:
3
.1
..0
..2
.7
..5
...4
...6
..9
...8
...10
....11
NTreeMap使用的是紅黑樹結構，由此可以觀察到，紅黑樹的平衡僅僅是子樹的區域性平衡。
17 泛型演算法
Nesty對泛型演算法的支援採取了兩種形式：（1）容器繫結的及（2）容器分離的。與容器繫結的演算法，主要是考慮到資料結構的性質，例如對於一般的排序演算法而言，像Vector，ArrayList等基於動態陣列的資料結構，最高效的排序演算法應當是快速排序，但是像LinkList等，其較為高效的排序則是歸併排序；再舉個例子，像列表旋轉演算法，基於陣列的和基於連結串列的資料結構之間的實現的方法及效率也大為不同。NCollection容器集的大部分資料結構都提供了類似Sort的方法，如NVectorSort，NLinkedSetSort，NArrayMapSort等，只有少部分在演算法上不允許排序的資料結構除外，例如NHashSet/Map，NTreeSet/Map等。另外，對於列表或向量來說，也提供了類似Rotate，Scroll及Reverse等等的演算法介面，如NVectorRotate，NLinkedListScroll，NArrayListReverse等等，由於這些演算法都與其容器的型別直接相關連，因此屬於容器繫結的演算法；儘管介面相同，但其內部實現會依據資料額結構的種類而有所/大為不同。下面以幾個清晰的例子來掩飾如何使用這些演算法。 對於排序而言，Sort方式將接受一個NPfnCompare的函式指標作為比較器，該函式的定義必須符合下面的格式（以NINT為例）：// Compare two integer value with greater than comparation
NBOOL CompareNINT_GT(const NVOID * In1, const NVOID * In2) {
return (NBOOL)(*(const NINT *)In1 > *(const NINT *)In2);
}NLINKED_LIST List = NLinkedListNew(NINT);
NINT Idx = 0;
for (; Idx < 8; Idx++) {
NLinkedListAdd(List, Idx);
}
NLinkedListSort(List, CompareNINT_GT);
NLinkedListPrint(List, NSystemOut());
// Outputs:
// [8](7, 6, 5, 4, 3, 2, 1, 0)// Sort elements between index 2 and index 2 + 4
NLinkedListSortNum(List, 2, 4, CompareNINT_GT);
NLinkedListPrint(List, NSystemOut());
// Outputs:
// [8](0, 1, 5, 4, 3, 2, 6, 7)NHASH_SET Set = NHashSetNew(NINT);
NVECTOR Vec = NVectorNew(NINT);
NCollections_Copy((NCOLLECTION)Set, (const NCOLLECTION)Vec);NLIST List = (NLIST)NArrayListNew(NINT);
NINT Val = 0;
NCollections_PushFirst((NCOLLECTION)List, &Val, 20);18 Nesty容器的侷限性
在C++的模板泛型中，模板的例項化是通過編譯器在編譯時進行，並且會為每個模板引數的型別編譯一個單獨的類，因此模板類具有靜態屬性；但是，由於Nesty容器是通過void*來對型別進行泛化的，然而任何型別的地址都可以自動轉換為void*，這將導致型別識別的問題；假設現在建立了下面兩個容器：NARRAY_LIST ListOfNINT = NArrayListNew(NINT);
NARRAY_LIST ListOfFLOAT = NArrayListNew(NFLOAT);NINT Val = 10;
NArrayListAdd(ListOfFLOAT, Val);19 在C++中使用容器
對於大部分人來說（特別是那些習慣在面向物件的環境中開發的），C泛型及TypeClass是一個難以接受的東西，為此Nesty還針對C++模板進行了封裝，但其介面和定義和C語言的容器是一模一樣的，實際上C++的版本和C語言的版本都同屬一套容器。下面是一些簡單的例子：NArrayList<NINT> List;
List.Add(3);
for (NINT Idx = 0; Idx < List.Len(); Idx++) {
NINT Val = List[Idx];
}
List.Sort<NGreater<NINT> >();