C++教程之array數組使用示例詳解

Posted on by

背景

上一篇文章我們介紹瞭C++中的迭代器，這篇文章將會介紹C++中數組的概念，數組是一種和vector類似的數據結構，但是其在性能和靈活性上的權衡中選擇瞭性能而放棄瞭一定的靈活性，其與vector相同的地方是，它們都是同一類型的對象的容器，也都可以通過下標訪問。其不同點是數組的大小是固定的，所以無法向一個數組添加元素，也正是因為其大小固定，所以其在運行時有更好的性能。

定義和初始化數組

數組是一個復合類型，可以通過類似a[d]的形式定義，其中a是數組名，d是數組的容量，d必須要大於0，數組的容量是數組類型的一部分，其導致數組容量必須要在編譯時就已知，這要求數組容量必須是常量表達式，以下提供瞭數組聲明的幾種形式：

unsigned cnt = 42; //不是一個常量表達式
constexpr unsigned sz = 42; //是常量表達式

int arr[10]; //聲明一個容量為10的整型數組
int *parr[sz]; //42個指向整形指針的數組
string bad[cnt]; //這是個錯誤聲明，因為cnt不是常量表達式

默認情況下，數組裡面的元素都會被默認初始化。

我們可以通過列表初始化一個數組，通過這種方式我們在定義時可以忽略數組的容量，如果我們指定瞭數組容量，那麼在列表初始化時初始化的元素數量不能超過設置的容量值，如果少於設置的數組的數量，沒有指定值的元素會使用默認初始化的值，例子如下：

const unsigned sz = 3;
int a1[sz] = {0, 1, 2};
int a2[] = {0, 1, 2}; //可以忽略數組的容量
int a3[5] = {0, 1, 2}; //等價於{0, 1, 2, 0, 0}
string a4[3] = {"hi", "bye"}; //等價於{"hi", "bye", ""}
int a5[2] = {0, 1, 2}; //錯誤

字符數組的定義

字符數組有一個額外的初始化方式，就是可以通過一個字符還去初始化字符數組，但是需要註意的是string是以null字符結尾的，所以在定義數組容量時要考慮null字符：

char a1[] = "C++"; //其等價於{'C', '+', '+', '\0'}
char a2[6] = "Daniel" //錯誤，其未考慮到null字符

❝需要註意的是一些編譯器是不支持數組的拷貝，如果直接通過一個數組去初始化另一個數組可能會報錯❞

理解復雜的數組聲明

正如vector，array也可以容納所有的類型，例如指針的數組，由於數組是一個對象，所以可以定義指向數組的指針和引用，，定義指向數組的指針或者引用可以通過以下方式：

int *ptre[10]; //ptre是一個數組，其中的元素是10個指向整型的指針
int (*parray)[10] = &arr; //parray是一個指針，其指向的對象是一個容量為10的整型數組
int (&arrRef)[10] = arr; //arrRef是一個引用，其指向的是一個容量為10的整型數組

❝在理解聲明時可以按照從左到右，從內到外的順序。❞

指針與數組

在C++中指針和數組關系是很近的，一般來說，當我們使用一個數組，編譯器會自動將其轉化為一個指針，一般來說我們是通過地址操作符來獲取一個對象的指針的，但是對於數組而言，當我們使用數組時，編譯器將會自動獲取一個指針指向數組的第一個元素：

string nums = {"one", "two", three}; 
string *p = &nums[0]; //p指向nums的第一個元素
string *p2 = nums //等價於string *p = &nums[0];

❝在大多數表達式中，我們使用數組對象，我們其實是獲取一個指針指向數組的第一個元素❞

由於這個影響，我們對於數組的操作其實絕大多數都是對於指針的操作，其中一個比較明顯的是當我們使用auto和數組去初始化一個變量時，其實是聲明瞭一個指針而不是數組：

int ia[] = {0, 1, 2, 3, 4};
auto ia2(ia); //ia2是一個整形指針，指向ia的第一個元素
ia2 = 43 //錯誤，不可以將int賦值給一個指針
auto ia3(&ia[0]) //這樣看起來更清楚，ia3是整型指針

需要註意的是當我們使用之前提到的decltype時不會發生這種轉化, decltype(ia)返回的類型是10個整型的數組：

decltype(ia) ia3 = {0, 1, 2, 3, 4};
ia3 = p; // 錯誤，不可以將一個整型指針賦值給一個數組
ia3[4] = i; //正確，可以對數組的元素賦值

指針是迭代器

指針也是迭代器，指向數組元素的指針同樣支持我們之前提到的vector和string中迭代器的操作，例如可以通過自增操作實現從一個元素移動到下一個元素：

int arr[] = [0, 1, 2, 3, 4, 5];
int *p = arr; //現在p指向arr[0]
++p; //現在p指向arr[1]

正如我們可以使用迭代器遍歷vector中的元素，我們也可以使用指針去遍歷數組中的元素，我們可以通過上面的方式獲取數組的第一個元素的指針，那麼我們又該如何獲取數組最後一個元素之後的不存在的元素呢，我們可以通過以下方式：

int *e = &arr[6];

我們隻可以獲取最後一個元素的下一個元素的地址

for (int *b = arr; b != e; ++b)
    cout<< *b<<endl

雖然我們可以通過上述方式獲取數組的第一個元素的地址和最後一個元素的下一個地址，但是這並不是一個好的方法，在新的規范中已經提供瞭新的函數begin和end可以獲取數組的第一個元素的地址和最後一個元素的下一個地址：

int ia[] = {0, 1, 2, 3, 4};
int *beg = begin(ia);
int *last = end(ia);

指針的算術運算

指向數組元素的指針可以使用我們之前在迭代器的文章中提到的所有的迭代器的操作，當我們使用指針加上或者減去一個整型的值時我們將會獲得一個新的指針，這個指針指向原來數組元素前或者後幾個位置的元素，具體的位置取決於加或者減的值:

constexpr size_t sz = 5;
int arr[sz] = {1, 2, 3, 4, 5};
int *p1 = arr; //等價於*p1 = &arr[0]
int *p2 = p1 + 4; //p2指向arr[4]

當我們用數組加上sz時，編譯器會把arr轉化為指向數組第一個元素的指針，所以如下p就是指向數組最後一個元素的下一個元素，如果相加結果超出數組的范圍則會發生錯誤：

int *p = arr + sz; //小心使用，沒有解引用
int *p3 = arr + 10; //錯誤，數組隻有5個元素，雖然編譯器可能無法檢測到這個錯誤

和迭代器一樣，兩個指針相減其結果是兩個指針之間的距離，其前提是這兩個指針式同一個數組中的元素：

auto n = end(arr) - begin(arr);

解引用和指針的算術運算

通過上面的介紹我們已經知道瞭指針也有算數運算，那麼如何判斷是指針的算術運算還是元素的算術運算呢，可以和之前復雜的指針對應，都是先從括號內部開始：

int ia = {0, 2, 4, 6, 8};
int last = *(ia + 4); //先看括號內，所以這是指針的元素暗，last = ia[4] = 8
int last2 = *ia + 4; //ia指向ia[0], 所以last2 = ia[0] + 4 = 4

下標與指針

我們可以看到數組其實就是一個指向數組第一個元素的指針，所以對於數組的下標操作其實就是對於指針的算數元運算,ia[2]等價於*(ia + 2):

int ia = {0, 2, 4, 6, 8};
int *p = &ia[2]; //p指向ia[2]的指針
int j = p[-2]; p[-2]等價於*(p - 2), 所以j = ia[0]

最後

這篇文章主要講述的是C++數組相關的內容，更多關於C++ 數組教程的資料請關註WalkonNet其它相關文章！

推薦閱讀：