C、C++之動態數組的實現二（C++版本）

c、c++動態數組（c++版本）

本篇文章基於筆者正在參與的c++課程，第二次作業的內容是要求使用c++的特性對上一次的程序實現改進並封裝（上一版本戳我）。

嚴格來說，上一個版本不能算是純粹的C語言版本，這是因為代碼中使用了c++的引用特性，這是C語言所不包含的。然而，這是由於測試代碼的限制，因而我們還是把它看做C語言的實現。（也可以編寫一種不包含引用的代碼來達到相同的效果，這要求使用到宏定義和一種稱之為“wrapper”的小技巧）

閑話少敘，先放出新的測試代碼，再具體討論各個函數的改寫方法。

//LibArray.cpp
// 實驗內容：
// 1：將C語言版本LibArray用C++封裝，注意，原C版本保留一個備份

// 實驗目的：
// 1：C++類定義的基本方法

// 只提交CLibArray.cpp及CLibArray.h

#include "stdafx.h"
#include <assert.h>
#include "CLibArray.h"

int _tmain(int argc, _TCHAR* argv[])
{
    CArray array;
	// 不再需要initial，但應該有正確的初始化
    // array_initial(array); 

    //array.recap(10); 
    //assert(array.capacity() == 10); 

    //////////////////////////////////////////////////////////////////////////
    for (int i = 0; i < 20; ++i)
    {
        array.append(i); 
    }
    assert(array.size() == 20); 

    for (int i = 0; i < array.size(); ++i)
    {
        assert(array.at(i) == i); 
    }

    //////////////////////////////////////////////////////////////////////////
    CArray array2, array3; 
    // array_initial(array2); 
    // array_initial(array3); 

    array2.copy(array); 
    assert(array.compare(array2) == true); 

    array3.copy(array); 
    assert(array.compare(array3) == true); 

    //////////////////////////////////////////////////////////////////////////
    array2.insert(2, 3); 
    assert(array.compare(array2) == false); 

    //////////////////////////////////////////////////////////////////////////
    array3.at(2) = 5; 
    assert(array.compare(array3) == false); 

    //////////////////////////////////////////////////////////////////////////
	// 不再需要destroy，但應該有正確的內存釋放
    // array_destroy(array); 
    // array_destroy(array2); 
    // array_destroy(array3); 

	return 0;
}

類的定義

從測試代碼和注釋中可見，對變量 array，我們只需要定義一個合適的 CArray 類即可。而在類的定義部分，將原有的結構體成員放到 private 私有數據成員：

typedef int TypeName;
const int INITLENGTH = 10; //初始化長度可以為任意正整數,也可以為零，但需要把append函數里的語句做適當修改

private:
	TypeName *arrayhead;
	int arraysize;
	int arraycapacity;

自然而然地，我們需要將C語言版的各個函數，放到 CArray 類的公有部分作為接口。
另一方面，注意到注釋部分：不再需要 initial 和 destroy 函數，學過c++的盆友們都知道，這是很自然的，因為在使用c++編程時，一般需要給自己定義的類寫好對應的構造函數和析構函數，實際上這樣的兩種函數，就對應於原來的 initial 和 destroy 函數。（關於構造函數和析構函數，可以參考這篇文章）
另外，注意到測試文件不再包含下列語句 array.recap(10); 由於在C語言實現中， recap 函數用於給動態數組賦予一定的空間大小， 而測試函數中取消了此語句，那么就有兩種可能的操作，一種是要考慮將空間的分配放在其他的函數中，或者保留 recap 函數，再讓其他函數調用它。這樣的特性很符合類的 protected 方法的定義。（當然，若不考慮繼承，將其作為 private 方法也未嘗不可）
於是總體思路清晰了：在 private 成員中定義了動態數組的必要參數，在 public 部分定義了可以進行的操作：

public:
	CArray();
	~CArray();
	inline int capacity() { return arraycapacity; };
	inline int size() { return arraysize; };
	inline TypeName& at(int num) { return arrayhead[num]; };
	void append(int num);
	void copy(CArray &another);
	bool compare(CArray &another);
	void insert(int num, TypeName value);

protected:
	void recap(int length);
	void printarray();

簡短的函數直接定義為內聯函數（注意若直接寫在類定義的頭文件內，則無需 inline 關鍵字，然而是否最終編譯為內聯函數，取決於編譯器的具體實現，關於 inline 關鍵字，可以參考這篇博客）

函數 printarray 用來輸出動態數組的關鍵信息。

在改寫函數時，主要工作是修改其參數，並在具體的定義中省去對調用對象本身的顯式表示（也可以采用 this 指針來完成）。

構造函數和析構函數

在構造函數中，可以選擇給頭指針分配一定大小的內存，也可以賦值為空（nullptr，即C語言中的NULL），出於一種合情合理的原因，我給它分配了一定的大小。
在 c++中，使用 new 和 delete 來分配和釋放內存，

CArray::CArray()
{
	arrayhead = new TypeName[INITLENGTH];
	arraysize = 0;
	arraycapacity = INITLENGTH;
}

而對於析構函數，只要相應地釋放內存即可：

CArray::~CArray()
{
	delete[] arrayhead;
	arrayhead = nullptr;
	arraycapacity = 0;
	arraysize = 0;
}

注意：釋放內存是必需步驟。且 delete[] 與new []相對應。（關於 new 和 delete 的注意事項及原理， 可參閱這篇博客）

recap函數

此函數是內存分配的關鍵，首先需保證其參數（capacity）合法，接下來，先新定義一個同類型的指針來指向需要的內存大小（capacity）的地址，並把原有的 arrayhead 所指向的內存里的數據復制到新的內存中，再刪去原有的數據， 並讓 arrayhead 指向新的內存地址。
這樣的做的原因是，由於參數 capacity 與原有數組的 arraycapacity 和 arraysize 的大小關系不確定，因此只能新分配一塊內存，再將所需內存大小的數據進行轉存。
最后需要修改相關的 private 成員的值。

void  CArray::recap(int capacity)
{
	if (capacity < 0)
	{
		cout << "array's length should be larger than zero, check out array_recap()" << endl;
		exit(EXIT_FAILURE);
	}

	arraycapacity = capacity;
	arraysize = arraysize > capacity ? capacity : arraysize;

	TypeName* buffer = nullptr;
	buffer = new TypeName[capacity];
	memcpy(buffer, arrayhead, sizeof(TypeName) * arraycapacity);

	delete[] arrayhead;
	arrayhead = buffer;

	//分配失敗
	if (arrayhead == nullptr)
	{
		cout << "malloc failed in array_recap()." << endl;
		exit(0);
	}
}

append 函數

該函數所需要做的工作是給第 num 位的成員賦值為 num。 為了達到此目的，需要檢查 num 和 capacity 之間的關系，若 num > arraycapacity，則需要使用 recap 函數擴大數組的容量，擴大的方式和大小可自行定義， 在此采取每次擴大一倍的方式，這樣，算法的復雜度將由O(n) 減小為 O(c)，此原理不詳述。
注意到每次擴大一倍容量的前提是， capacity不為零，因此，在構造函數中， 我選擇給數組一個不為零的內存大小，當然，如果堅持在構造函數中要使用 arrayhead = nullptr;那么在 append 函數中， 可以使用 (*this).recap((arraysize +1)*2); 這樣的代碼。

//給 arrayhead 數組的第 num 位賦值為 num， 若 num 大於實際長度，則擴充長度至 num
void  CArray::append(int num)
{
	if (num + 1 > arraycapacity)
	{
		// 一次擴大為原來的兩倍， 時間復雜度更小（O(n) - > O(c)）
		(*this).recap(arraysize *2);
	}
	arrayhead[arraysize++] = num;
}

copy函數

和C語言版本基本一致，我們需要做的工作是使調用對象的容量與被復制的對象大小一致，然后將所有數據復制到調用對象的內存中，這樣可以實現動態數組的復制。

//將 another 對象復制給調用的對象
void  CArray::copy(CArray &another)
{
	(*this).recap(another.capacity());
	memcpy(arrayhead, another.arrayhead, another.size() * sizeof(TypeName));
	arraysize = another.size();
}

注意：使用 memcpy 函數，比用 for 循環逐一賦值的效率要高，因為 mencpy 可以充分利用數據總線的位數進行傳輸。

compare函數

此函數幾乎沒有要修改的地方，唯一值得注意的是，為了輸出比較的結果，我選擇了用 for 循環來逐一比較數據， 若只要求其總體比較的結果，可以使用 memcmp 函數，效率更高，也更簡潔。

bool  CArray::compare(CArray &another)
{
	//another.printarray();
	//輸出 size 不同的信息
	if (another.size() != arraysize)
	{
		cout << "Their size are not equal, check out in CArray::compare()." << endl;
		return false;
	}

	if (another.capacity() != arraycapacity)
	{
		cout << "Their capacity are not equal, check out in CArray::compare()." << endl;
		return false;
	}
	//為了輸出是第幾位不同，采用循環，否則可以采用以下語句，效率更高
	//return memcmp(another.arrayhead, arrayhead, size() * sizeof(TypeName)) == 0;
	for (int i = 0; i < another.size(); i++)
		if (another.arrayhead[i] != arrayhead[i])
		{
			cout << "They are not equal in the NO." << i << " place" << endl;
			return false;
		}

	return true;
}

insert 函數

此函數需要在 第 index 的位置插入一個值為 value 的元素，為此，只需要使用 recap 函數每次多增加一個單位長度的內存空間即可，順次移動 index 前的各位，然后將第 index 位賦值。

void  CArray::insert(int index, TypeName value)
{
	if (index > arraycapacity || index < 0)
	{
		cout << "Cannot insert with an invaild index, check out in array_insert()." << endl;
		exit(EXIT_FAILURE);
	}
	else
	{
		(*this).recap(arraycapacity + 1);

		for (int i = arraycapacity - 1; i > index; i--)
			arrayhead[i] = arrayhead[i - 1];
		arrayhead[index] = value;

		arraysize ++;
	}
}

printarray函數

此函數的實現因人而異，只需要獲得調試時所需要的信息即可。

總結

本篇博客實現了動態數組的C++版本的一種簡單實現。未完善的地方必然存在，望廣大讀者批評指正。為了符合測試程序， 我沒有采用模板進行代碼的編寫，雖然在上一版的實驗要求中提到了，對程序的要求是能夠各種不同類型的數據。然而代碼中沒有使用模板進行對象的聲明，可知無需進行模板類和模板函數的編寫。
關於異常的編寫，代碼中某些函數使用了諸如exit(EXIT_FAILURE)這樣的語句。在 C++ 中，更為規范的實現是拋出異常， 再進行針對性的處理，由於測試程序較為簡單，因此沒有編寫針對異常的代碼