C++青少年簡明教程：數組

C++數組是一種存儲固定大小連續元素的數據結構。數組中的每個元素都有一個索引，通過索引可以訪問或修改數組中的元素。

在C++中，數組中的元素數據類型必須一致。數組是一個連續的內存區域，用于存儲相同類型的元素。在聲明數組時，需要指定數組元素的數據類型，并且在數組中的所有元素都必須是該指定類型。

如果需要存儲不同類型的元素，可能需要使用結構體、類或模板等其他方式來實現。

C++數組的基本特點：

固定大小：創建時必須指定數組的大小，且大小在數組生命周期內不可改變。

同一類型：數組中所有元素必須是相同的數據類型。

連續內存：數組元素在內存中連續存儲，這意味著可以通過指針算術來訪問元素。

數組依據維度可分為：
一維數組：用于存儲線性排列的數據。由單一的索引訪問每個元素，適用于表示單行或單列的數據集合。
多維數組：用于存儲表格形或更高維度的數據。二維數組（或矩陣）是最常見的多維數組形式。通過多個索引訪問每個元素，每個額外的維度為數據結構增加一個層級，適用于更復雜的數據組織方式，如表格、立方體等。

一維數組

一維數組是一個線性的數據結構，它包含相同類型的元素，并通過一個索引來訪問每個元素。一維數組可以看作是一個行或者一列的元素列表。如：

或

可以使用一排糖果或者水果來比喻一維數組。每個位置的糖果或者水果可以看作是數組的一個元素。你可以請示學生，如果我們想要找到第3個位置的糖果，應該搜索哪個位置呢？

C++ 中，聲明（定義）數組語法格式

元素的數據類型? 數組的名稱[元素數目]

【數組元素指的是數組中存儲的單個數據項。數組下標和索引是同一個概念，用于標識數組中每個元素的位置。數組下標從0開始遞增，表示元素在數組中的位置。】

元素數目也稱為數組大小，即數組中元素的個數，是一個常量值。【元素數目也稱為數組大小是一個常量值（常量表達式）。特別說明：雖然某些編譯器可能會支持變量數組，但這并不是標準的一部分。在C++中，如果你需要一個可以動態調整大小的數組，推薦使用vector容器，vector是一個動態數組，它可以在運行時動態地增加或減少元素。與數組（array）相比，vector提供了更多的靈活性，例如自動調整大小、插入和刪除元素等。】

以下是一個聲明了大小為5的整數數組的示例：

int numbers[5]; // 創建了一個能夠存儲5個整數的數組

也可以使用常量聲明數組：

const int n = 5;

int numbers[n]; // 創建了一個能夠存儲5個整數的數組

【如果您需要在運行時動態地調整數組的大小，可以考慮使用動態數組或者標準庫提供的容器類，例如vector。這些容器類提供了更靈活的數據結構，可以動態地增加或減少其大小。

以下是使用vector容器來實現動態大小的數組的示例：

#include <vector>
#include <iostream>
using namespace std;int main() {vector<int> numbers; // 創建一個使用int類型存儲的動態數組// 在運行時向數組中添加元素numbers.push_back(10);numbers.push_back(20);numbers.push_back(30);// 輸出數組中的元素for (int i = 0; i < numbers.size(); i++) {cout << numbers[i] << " ";}return 0;
}

在這個示例中，vector容器可以存儲動態數量的整數。通過使用push_back函數，我們可以在運行時向容器中添加元素。同時，通過調用size函數，我們可以獲取容器中的元素數量，從而實現動態大小的數組。】

一維數組的初始化

1）使用大括號 {} 初始化數組，可以指定每個元素的初始值。例如：

int arr1[] = {1, 2, 3, 4, 5}; // 初始化一個包含5個元素的整型數組

2）指定整個數組的初始值。例如：

int arr2[5] = {1, 2, 3, 4, 5}; // 初始化一個包含5個元素的整型數組

3)不指定數組大小，直接使用大括號 {} 初始化數組，編譯器會自動根據初始值的個數確定數組大小。例如：

int arr3[] = {1, 2, 3, 4, 5}; // 初始化一個包含5個元素的整型數組

4）部分初始化，未指定的元素將被默認初始化為零。例如：

int arr[5] = {1, 2, 3}; // 初始化前3個元素為1、2和3，其他兩個元素默認初始化為0

5）使用循環進行初始化：

int arr[5];
for (int i = 0; i < 5; i++) {
? ? arr[i] = i + 1; // 初始化元素為1到5
}
?

數組元素賦值示例：

#include <iostream>
using namespace std;int main() {// 聲明一個整數數組，包含5個元素int numbers[5];// 初始化數組元素numbers[0] = 10;numbers[1] = 20;numbers[2] = 30;numbers[3] = 40;numbers[4] = 50;// 還可以這樣聲明數組并初始化int numbers[5] = {10, 20, 30, 40, 50};// 訪問數組元素并輸出cout << "第一個元素: " << numbers[0] << endl;cout << "第三個元素: " << numbers[2] << endl;// 修改數組元素numbers[1] = 100;// 輸出修改后的數組元素cout << "修改后的第二個元素: " << numbers[1] << endl;return 0;
}

需要注意，一維數組的索引是從0開始的，即第一個元素的索引是0，第二個元素的索引是1，依此類推。

對一維數組進行賦值或修改元素的值，示例如下：

#include <iostream>
using namespace std;int main() {int arr[5];// 賦值arr[0] = 1;arr[1] = 2;arr[2] = 3;// 修改元素值arr[2] = 4;// 訪問數組元素cout << arr[0] << endl; // 輸出：1cout << arr[2] << endl; // 輸出：4return 0;
}

例、統計數組中正數和負數和0的個數

#include <iostream>
using namespace std;int main() {  int a[10] = {1, -10, 20, 0, 5, -6, 7, 0, -2, 0};  int positiveCount = 0; // 用于統計正數的個數  int negativeCount = 0; // 用于統計負數的個數  int zeroCount = 0; // 用于統計零的個數  // 遍歷數組并統計  for (int i = 0; i < 10; ++i) {  if (a[i] > 0) {  ++positiveCount;  } else if (a[i] < 0) {  ++negativeCount;  } else {  ++zeroCount;  }  }  // 輸出結果  cout << "正數的個數: " << positiveCount << "，";  cout << "負數的個數: " << negativeCount << "，";  cout << "零的個數: " << zeroCount << endl;  return 0;  
}

運行之，輸出如下：

數組中正數4個，負數3個，零3個

【附C語言代碼：

#include<stdio.h>int main() {  int a[10] = {1, -10, 20, 0, 5, -6, 7, 0, -2, 0};  int positiveCount = 0; // 用于統計正數的個數  int negativeCount = 0; // 用于統計負數的個數  int zeroCount = 0; // 用于統計零的個數  // 遍歷數組并統計  for (int i = 0; i < 10; ++i) {  if (a[i] > 0) {  ++positiveCount;  } else if (a[i] < 0) {  ++negativeCount;  } else {  ++zeroCount;  }  }  // 輸出結果  printf("數組中正數%d個，負數%d個，零%d個\n",positiveCount ,negativeCount, zeroCount);
}

】

二維數組

二維數組是一個包含多行和多列的表格結構，它由多個一維數組組成。二維數組的元素可以通過兩個索引進行訪問，第一個索引表示行號，第二個索引表示列號。可以將二維數組看作是一個矩陣，其中每個元素由其在矩陣中的行和列決定。

例如，以下是一個包含3行和4列的二維數組的示例：

在這個示例中，通過兩個索引可以訪問每個元素，例如a[0][2]表示行號為0、列號為2的元素。

二維數組和一維數組在使用和實現上有一些區別，二維數組需要使用兩個索引來訪問元素，而一維數組只需要一個索引。此外，二維數組在內存中被連續存儲，每行的元素緊密相鄰，而一維數組的元素在內存中是連續存儲的。

可以使用一個矩陣或者棋盤來表示二維數組。你可以在黑板上畫出一個3x4的方格矩陣，并把每個方格標上數字。然后向學生解釋，我們可以使用兩個索引來找到每個方格，第一個索引表示行號，第二個索引表示列號。

可以使用珠子串來比喻二維數組。你可以用不同顏色的珠子串成一條線，然后疊加多條珠子串，每條珠子串代表二維數組的一行。然后可以請示學生，如果我們想找到第2行第3列的珠子，應該搜索哪些珠子串？

二維數組的初始化

1)使用大括號 {} 初始化二維數組，可以指定每個元素的初始值。例如：

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 初始化一個包含2行3列的二維整型數組

也可以這樣寫：

int arr[2][3] = {
? ? {1, 2, 3},
? ? {4, 5, 6}
};

每個括號對應一個維度，外層括號對應第一維，內層括號對應第二維。如果已經給出了足夠的初始化項，就可以不用寫內部嵌套的花括號了，需要注意的是，如果只給出了一部分初始化項，必須顯式地使用大括號。

2)不指定二維數組的行數，直接使用大括號 {} 初始化二維數組，編譯器會自動根據初始值的個數確定行數。例如：

int arr[2][3] = {{1, 2, 3}, {4, 5, 6}}; // 初始化一個包含2行3列的二維整型數組

二維數組的列數必須在初始化時指定，行數可以根據初始值的個數自動確定。

3）部分初始化。例如：

int arr[2][3] = {{1, 2}, {4, 5}}; // 初始化部分元素，其他元素將默認初始化為0，相當于：

int arr[2][3] = {{1, 2,0}, {4, 5,0}};

內部嵌套的括號是可選的。

4）嵌套循環進行初始化。例如：

int arr[2][3];
for (int i = 0; i < 2; i++) {
? ? for (int j = 0; j < 3; j++) {
? ? ? ? arr[i][j] = i + j; // 根據需要自行給元素賦值
? ? }
}

二維數組的示例：

#include <iostream>
using namespace std;int main() {int a[3][4] = {{1, 2, 3, 4},{5, 6, 7, 8},{9, 10, 11, 12}};// 輸出二維數組的元素for (int i = 0; i < 3; ++i) {for (int j = 0; j < 4; ++j) {cout << a[i][j] << " ";}cout << endl;}return 0;
}

這個示例中，定義了一個 3 行 4 列的二維整數數組 a，并初始化其元素。然后，使用嵌套的 for 循環遍歷二維數組并輸出其元素。輸出結果如下：

1 2 3 4
5 6 7 8
9 10 11 12
?

三維數組

C++中，三維數組的初始化和二維數組類似，但有點除外，二維數組的列數必須在初始化時指定，行數可以根據初始值的個數自動確定。但三維數組的每一維的大小都必須在定義時指定。

定義一個3維數組并賦初值

int a[2][3][4] = {{{1, 2, 3, 4},{5, 6, 7, 8}, 9, 10, 11, 12}}, {{13, 14, 15, 16}, {17, 18, 19, 20},{21, 22, 23, 24}}};

也可以這樣寫：

int a[2][3][4] = {
? {{1, 2, 3, 4},
? ?{5, 6, 7, 8},?
? ?{9, 10, 11, 12}},?
? {{13, 14, 15, 16},?
? ?{17, 18, 19, 20},?
? ?{21, 22, 23, 24}}
};

如果已經給出了足夠的初始化項，就可以不用寫內部嵌套的花括號了。

每個括號對應一個維度，外層括號對應第一維，內層括號對應第二維，再內層括號對應第三維。需要注意的是，如果只給出了一部分初始化項，必須顯式地使用大括號。

多維數組的構成元素優先按末尾的下標遞增的順序排列。

a[i][j][k] 中，最內層（從編程循環遍歷訪問數組元素的角度看）的下標是 k，其變化最快；次內層的下標是 j，其次變化；最外層的下標是 i，變化最慢。這種索引方式確實使得我們可以方便地訪問任意一個多維數組中的元素。

請結合下面的示例理解，三重循環遍歷三維元素的每個元素示例：

#include <iostream>
using namespace std;int main() {	int a[2][3][4]; // 定義一個3維數組// 給數組賦值int num=1;for(int i=0; i<2; i++){for(int j=0; j<3; j++){for(int k=0; k<4; k++){a[i][j][k] = num++;}}}// 輸出數組for(int i=0; i<2; i++){for(int j=0; j<3; j++){for(int k=0; k<4; k++){cout << "a[" << i << "][" << j << "][" << k << "] = " << a[i][j][k] << "  ";}cout << endl;}cout << endl;}return 0;
}

這個例子中，我們定義了一個 a[2][3][4] 的3維數組。然后我們使用三重循環遍歷每個元素，并給數組賦值。

最后，我們使用嵌套循環來遍歷數組并輸出每個元素的值。

這個程序的輸出應該是以下這個樣子：

a[0][0][0] = 1 ?a[0][0][1] = 2 ?a[0][0][2] = 3 ?a[0][0][3] = 4
a[0][1][0] = 5 ?a[0][1][1] = 6 ?a[0][1][2] = 7 ?a[0][1][3] = 8
a[0][2][0] = 9 ?a[0][2][1] = 10 ?a[0][2][2] = 11 ?a[0][2][3] = 12

a[1][0][0] = 13 ?a[1][0][1] = 14 ?a[1][0][2] = 15 ?a[1][0][3] = 16
a[1][1][0] = 17 ?a[1][1][1] = 18 ?a[1][1][2] = 19 ?a[1][1][3] = 20
a[1][2][0] = 21 ?a[1][2][1] = 22 ?a[1][2][2] = 23 ?a[1][2][3] = 24
?

定義數組時進行賦值，上面程序可修改為：

#include <iostream>
using namespace std;int main() {// 定義一個3維數組并賦初值int a[2][3][4] = {{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}}, {{13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24}}};// 輸出數組for(int i=0; i<2; i++){for(int j=0; j<3; j++){for(int k=0; k<4; k++){cout << "a[" << i << "][" << j << "][" << k << "] = " << a[i][j][k] << "  ";}cout << endl;}cout << endl;}return 0;
}

小結

在 C++ 中，數組是一種用于存儲同類型數據集合的簡單且高效的方式。以下是使用數組時需要注意的重要事項：

☆數組的大小在編譯時確定，并且不能改變：

數組的大小必須在編譯時指定，并且一旦定義，數組的大小在程序的生命周期內是固定的。

int arr[5]; // 定義一個包含5個整數的數組

☆數組名實際上是指向數組第一個元素的指針：

數組名本身可以作為指針使用，指向數組的第一個元素。

int* ptr = arr; // ptr 指向 arr[0]

☆當將數組作為函數參數傳遞時，傳遞的是數組的指針，而不是整個數組：

傳遞數組給函數時，實際上傳遞的是指向數組第一個元素的指針，這意味著函數內對數組的修改會影響到原數組。

void printArray(int* array, int size) {
? ? for(int i = 0; i < size; ++i) {
? ? ? ? std::cout << array[i] << " ";
? ? }
}

☆使用 sizeof 運算符可以獲取數組的大小（以字節為單位），但通常需要除以元素的大小來得到元素的數量：