【C++】C++中的數組

目錄結構：

contents structure [-]

1. 一維數組
1. 數組的定義和初始化
2. 數組元素的訪問
3. 數組和指針
2. 多維數組

數組是存放相同類型的容器，數組的大小肯定不變，不能隨意向數組中添加元素。由於數組的大小固定，所以對某些特殊應用來講程序的運行時性能較好，但相應的損失了一些靈活性。

1. 一維數組

1.1 數組的定義和初始化

一維數組的聲明形如：a[b]，其中a是數組的名字，b是數組的維度（數組中元素的個數）。其實這裏說成數組的定義更加準確，由於a[b];是會被分配內存的。
好比：

int arr[10]; //arr是含有10個整型的數組
int arr[10]={}; //arr是含有10個整型的數組，進行了初始化，每一個元素的值都是10
int *arr[10]; //arr是含有10個整型指針的數組
int arr[] = {1,2,3}; //arr是含有3個整型的數組
int arr[5] = {1,2,3}; //等價於int arr[5] = {1,2,3,0,0}
string arr[3] = {"hello","world"}; //等價於 string arr[3] = {"hello","world",""};
char arr[6] = "hello"; //這裏不能聲明維度爲5，由於字符串末尾還有一個空字符('\0')，因此應該是"hello\0"
char arr[6] = {'h','e','l','l','o','\0'}; //等價於 char arr[] = "hello";
char arr[6] = {'h','e','l','l','o'}; //這條語句和上面一條語句是同樣的。默認字符初始化值是'\0'

若是在定義了整型類型的數組後，並無對內存進行初始化的話，那麼裏面會存放之前的垃圾值。用字符串字面值初始化字符數組時，必定要注意字符串字面值的末尾還有一個空字符。

 

上面介紹一些簡單的一維數組的定義，下面結合引用和指針來介紹一些複雜的數組聲明，理解數組聲明格式的步驟：默認順序從右到左，若是有括號，要先看括號裏的。

int *arr1[10];//1
int (*arr2)[10];//2

第1條語句和第2條語句的含義徹底不一樣，第1條語句表示：「arr1是含有10個整型指針的數組」；第2條語句的含義是：「arr2是指向一個10個整型大小的指針」。也就是說，arr1是一個數組，數組的大小是10，數組中每一個元素類型是int類型的指針；arr2首先是一個指針，指向了大小爲10的數組，數組中每一個元素是int類型。

 

int &arr3[10];//3，錯誤
int (&arr4)[10];//4，錯誤
int a[10] = {};
int (&arr5)[10] = a;//5

arr3的本意是想聲明瞭一個數組，數組的大小是10，數組中的每一個元素的類型是一個int類型的引用，可是c++並不存在這種數組的聲明格式，語法錯誤。
arr4的本意是想聲明一個引用，引用的是一個數組，數組的大小是10，數組中每一個元素的類型是int類型，但arr4既然是一個引用，因此必須要初始化，因此arr4錯誤，arr5正確。

 

還能夠結合指針和引用來共同聲明更復雜的數組，理解的方式和上面都是同樣的（從右到左，有括號先看括號），例如：

int *(&arr)[10] = ...;//必需要進行正確的初始化

上面一條語句的含義：arr首先是一個引用，引用的類型是一個大小爲10的數組，數組的每一個元素是int*（整型指針）類型。由於arr是一個引用，因此這條語句必需要初始化，不然會報錯。

 

1.2 數組元素的訪問

數組的下標是從0開始的，在使用數組下標的時候，一般將其定義爲size_t類型（通常不要使用int類型），size_t位於cstddef頭文件（該文件是C標準庫stddef.h頭文件的C++版本）中，是無符號整型的別名，能夠表明任意字節對象的大小。
例如：

#include <cstddef>
#include <iostream>
using namespace std;

int main(){
    size_t size = 20;
    int arr[size] = {};
    for(size_t index=0; index < size; index++){
        cout << arr[index] << " ";
    }
    cout << endl;
    return 0;
}

 

C++11標準提供了auto關鍵字：

for(auto a : arr)
    cout << a << " ";

1.3 數組和指針

在c/c++語言中，數組和指針有着很是緊密的聯繫，在使用數組編譯的時候一般會把它轉化爲它的第一個元素的指針。

例如：

string nums[] = {"one","two","three"};
string *p = &nums[0];
string *p2 = nums;

p和p2其實等價的，都是表示指向nums首元素的指針。

int ia[] = {0,1,2,3,4,5};
auto ia2(ia);//ia2是一個整型指針，指向ia的第一個元素

ia是含有6個整數的數組，但當使用ia做爲ia2的初始值時，編譯器實際的編譯類型是：

auto ia2(&ia[0]);

能夠看出，ia2是一個指針，指向了ia數組的第一個元素。

使用auto會發生上述的轉化，但當使用decltype關鍵字時上述轉化不會發生

decltype(ia) ia3 = {0,1,2,3,4,5};//ia3是一個含有6個整數的數組

其中ia是一個含有6個整數的數組int[6]類型，decltype(ia)獲得的類型也是int[6]，因此ia3的類型也是int[6]。

 

上面提到了如何獲取數組第一個元素的指針，接下來討論一下如何獲取數組尾元素下一元素的指針

string *p = &nums[3];//nums的大小爲3，p指向數組尾元素的下一個元素。

對於獲取首元素和尾元素下一元素的指針，c++11提供了兩個新方法，begin()和end()方法

#include <iostream>
using namespace std;
int main(){
    int ia[] = {0,1,2,3,4,5,6,7,8};
    int *p1 = begin(ia);//獲取首元素的指針
    int *p2 = end(ia);//獲取尾元素下一元素的指針
    for(; p1 != p2 ; p1++)
        cout << *p1 << " ";
    cout << endl;
}

指向數組元素的兩個指針能夠進行解運算、比較、遞增、遞減、指針相減等操做。指針的比較就是比較地址的大小。遞增/遞減就是內存地址日後/往前移動1，除此以外，還能夠在指針上加上/減去某整數n，表示日後/往前移動n位的新指針。指針相減就是內存地址相減，差值表示間隔的元素個數。

 

兩個指針相減是一種ptrdiff_t的標準庫類型，和size_t同樣，ptrdiff_t也是定義在cstddef頭文件中的。由於差值可能爲負，因此ptrdiff_t是一種有符號整型。

auto n = end(ia) - begin(ia);//等價於：ptrdiff_t n = end(ia) - begin(ia);

 

例如：

#include <iostream>
#include <cstddef>
using namespace std;
int main(){
    int ia[] = {1,2,3,4,5,6,7,8,9};
    auto p1 = begin(ia);//首元素的指針
    auto p2 = end(ia);//尾元素下一元素的指針
    while(p1 < p2){
        *p1 = (*p1) * 2;
        p1++;
    }
    ptrdiff_t length = end(ia) - begin(ia);//獲得ia數組的長度，ptrdiff_t是指針相減的類型（一種有符號整數的別名）
    for(size_t index=0; index<length; index++)
        cout << ia[index] << " ";
    cout << "\n";
    int *p3 = &ia[4];//獲得第5個元素
    cout << "第7個元素 : "  <<  *(p3 + 2) << "\n";
    cout << "第3個元素 : "  <<  *(p3 - 2) << endl;
    return 0;
}

結果：

2 4 6 8 10 12 14 16 18
第7個元素 : 14
第3個元素 : 6

 

當一個指針指向一個數組後，使用指針能夠直接經過下標訪問數組中的值：

int a[]={1,2,3,4,5,6};
int *p=a;//指向a的首元素

for(int index=0; index<6; index++)
　　cout << p[index] << " ";//等同於 *(p+index)

cout << endl;

注意：p[index]是未移動指針p的位置的，指針p始終都未改變（p一直都指向數組a的首元素）。

 

C++數組的初始化長度不能是變量， 若是須要變量長度來初始化數組，那麼這時候能夠new一個數組，而後用指針指向數組來解決這個問題：

    std::string s = "Hello World!";
    char *cstr = new char[s.size() + 1];//不能寫成char cstr[s.size()+1]
#注意：在不使用cstr時，必定要手動delete cstr.

 

 

2. 多維數組

嚴格的說，在C++語言中是沒有多維數組的，一般所說的多維數組其實就是數組的數組。

 

當一個數組中的元素依然是一個數組時，一般使用兩個維度來定義它。

int arr1[m][n];//二維數組,大小爲m的數組，每一個數組的元素都是大小爲n的數組。
int arr2[m][n][q];//三維數組，大小爲m的數組，每一個數組的元素都是大小爲n的數組，而後大小爲n的數組中的每一個元素又是大小爲q的數組。

 

對二維數組來講，一般把第一維度稱爲行，把第二維度稱爲列，所以上面的arr1是一個含有m行n列的二維數組。

 

int ia1[3][4]={
{0,1,2,3},
{4,5,6,7},
{8,9,10,11},
}
int ia2[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
//顯式初始化每行的首元素
int ia3[3][4]={{0},{4},{8}};
//顯式初始化第一行元素
int ia4[3][4]={0,1,2,3};

上面的ia1和ia2是等價的，ia1分配了12個整型內存空間，因爲這些空間都是連續的（由於數組就是一塊連續的內存空間），因此換成ia2的聲明方式徹底同樣。

 

可使用下標運算符來訪問多維數組的元素，此時數組的每一個維度對應一個下標運算符。

// 用arr的首元素爲ia的最後一行的最後一列元素賦值
ia[2][3] = arr[0][0][0];//ia是一個3行4列的數組，arr是一個三維數組
int (&row)[4] = ia[1];//把ia的第二行綁定到引用a上

 

例如:

#include <iostream>
using namespace std;
int main(){
    int ia[3][4] = {{0,1,2,3},{4,5,6,7},{8,9,10,11}};
　　 //使用下標運算符
    for(size_t row=0; row < 3; row++)
        for(size_t col=0; col<4; col++)
            cout << ia[row][col]<< " ";
    cout << "\n";

　　 //使用指針
    for(int (*row)[4] = ia; row != ia + 3; row++)
        for(int *col = *row; col != *row + 4; col++)
            cout << *col << " ";
    cout << "\n";

　　 //使用指針
    for(int *val : ia)
        cout << *val << " ";
    cout << "\n";

　　 //使用引用
    for(auto &row : ia)
        for(auto &col : row)
            cout << col << " ";
    cout << endl;
    return 0;
}

注意，上面的auto循環不能寫成

for(auto row : ia){
    for(auto col : row){//錯誤，由於row是int*類型
    }
}

由於數組名在使用的時候，默認是會被編譯成指向首元素的指針。換句話說，循環語句for(auto row : ia);其中的 row 是int *類型，對於for(auto col : row)的話，顯然錯誤。使用auto &row 讓編譯器知道本身要使用的是引用，編譯器就不會再把它轉化爲指針。對於獲取首元素和尾元素下一元素的指針，能夠經過標準庫中的begin()和end()方法。