C++数组(array)是一种顺序容器sequence container，是由单一数据类型元素组成的一个有序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。对数组元素的访问是通过下标（subscript）操作符，按元素在数组中的位置进行访问，称为索引访问（indexing）或下标访问（subscripting）。数组是一种组合类型,是不能作为一个整体进行访问和处理的，只能按元素进行个别的访问和处理。
如果需要存储不同类型的元素，可能需要使用结构体、类或模板等其他方式来实现。
一维数组是一个线性的数据结构，它包含相同类型的元素，并通过一个索引来访问每个元素。一维数组可以看作是一行元素的有序序列。
声明数组
在C++在声明一个数组，需要指定元素的类型和元素的数量，格式如下：
数据类型 数组名[元素数量];
上面声明的格式是一维数组的声明，其中元素个数必须是一个大于0的整型常量，数据类型可以是任意有效的C++数据类型。如声明一个类型为double的包含10个元素的数组myA，声明语句是: double myA[10];
注意，数组以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。数组元素指的是数组中存储的单个数据项。
元素数目也称为数组大小,即数组中元素的个数，是一个常量值（常量表达式）。特别说明：虽然某些编译器可能会支持变量数组，但这并不是标准的一部分。在C++中，如果你需要一个可以动态调整大小的数组，推荐使用vector容器。vector是一个动态数组，它可以在运行时动态地增加或减少元素。与数组（array）相比，vector提供了更多的灵活性，例如自动调整大小、插入和删除元素等。后面将介绍。
【https://cplusplus.com/doc/tutorial/arrays/ 或https://www.cplusplus.com/reference/array/array/ 或https://en.cppreference.com/w/cpp/container/array。】
初始化数组
在C++中，可以逐个初始化数组，也可以使用一个初始化语句，如下所示：
double myA[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};
大括号{ }之间的值的数目不能大于在数组声明时在方括号[ ]中指定的元素数目。
如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果是下面的格式，将创建一个数组，它与前一个实例中所创建的数组是完全相同的
double myA[] = {1000.0, 2.0, 3.4, 7.0, 50.0};
为数组中某个元素赋值的实例,下面的语句把数组中第五个元素的值赋为666.6。所有的数组都是以0作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去1。
myA[4] = 666.6;
一维数组的初始化方式：
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
}
一维数组访问数组元素
数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。例如：
double salary = myA[3];
声明数组、初始化数组、访问数组元素实例如下：
#include "iostream"
#include "iomanip"
using namespace std;
using std::setw; // setw() 函数来格式化输出
int main(){
int a[10]; // 声明一个包含10个元素的整型数组
// 初始化数组
for (int i = 0; i < 10; i++)
a[i] = i + 100;
cout << "元素索引" << setw(13) << "元素值" << endl;
// 输出数组中的每个元素
for (int j = 0; j < 10; j++)
cout << setw(7) << j << setw(13) << a[j] << endl;
return 0;
}
运行之，参见下图：
C++中的多维数组
C++支持多维数组。多维数组声明的一般形式如下：
数据类型名 数组名[size1][size2]...[sizeN];
例，下面的声明创建了一个三维整型数组：
int tridim[5][10][4];
二维数组是一个包含多行和多列的表格结构，它由多个一维数组组成。二维数组的元素可以通过两个索引进行访问，第一个索引表示行号，第二个索引表示列号。可以将二维数组看作是一个矩阵，其中每个元素由其在矩阵中的行和列决定。
多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。声明一个x行y列的二维整型数组，形式如下：
数据类型 数组名[x][y];
例、定义一个整型的包含3行和4列的二维数组：
int a[3][4]
一个二维数组可以被认为是一个带有x行和y列的表格。对于int a[3][4] 这个3行（Row）和4列（Column）的二维数组，示意如下：
数组中的每个元素是使用形式为a[i][j]的元素名称来标识的，其中a是数组名称，i和j 是唯一标识a中每个元素的下标。
初始化二维数组
int a[3][4] = {
{0, 1, 2, 3}, /* 初始化索引号为 0 的行 */
{4, 5, 6, 7}, /* 初始化索引号为 1 的行 */
{8, 9, 10, 11}, /* 初始化索引号为 2 的行 */
};
内部嵌套的括号是可选的,下面的初始化与上面是等同的:
int a[3][4] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};
二维数组的初始化方式：
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; // 根据需要自行给元素赋值
}
}
访问二维数组元素
二维数组中的元素是通过使用下标（即数组的行索引和列索引）来访问的。例如：
int val = a[2][3];
例、使用嵌套循环来处理前面定义的二维数组：
#include <iostream>
using namespace std;
int main ()
{
// 一个带有 3 行 4列的数组
int a[3][4] = {
{0, 1, 2, 3}, /* 初始化索引号为 0 的行 */
{4, 5, 6, 7}, /* 初始化索引号为 1 的行 */
{8, 9, 10, 11}, /* 初始化索引号为 2 的行 */
};
// 输出数组中每个元素的值
for ( int i = 0; i < 3; i++ )
for ( int j = 0; j < 4; j++ )
{
cout << "a[" << i << "][" << j << "]: ";
cout << a[i][j]<< endl;
}
return 0;
}
运行之，参见下图：
vector容器：是能够存放任意类型的动态数组，先看例子：
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cout << "请输入元素个数：";
cin >> n;
vector<int> arr(n); // 定义一个长度为n的int型动态数组
cout << "请输入元素：";
for (int i = 0; i < n; i++) {
cin >> arr[i]; // 添加元素
}
cout << "你输入的元素：";
for (int i = 0; i < n; i++) {
cout << arr[i] << " "; // 输出元素
}
cout << endl;
return 0;
}
运行效果：
vector使用与常用基本操作：
1)头文件#include<vector>
2)创建一维vector对象，vector<int> vec;二维vector<vector<int>> vec2;
3)尾部插入数字：vec.push_back(a);
4)尾部元素弹出：vec.pop_back();相当于删除尾部元素。
5)使用下标访问元素，cout<<vec[0]<<endl;记住下标是从0开始的,和数组的访问形式一样。
6)插入元素：vec.insert(vec.begin()+i,a);在第i+1个元素前面插入a。
7)删除元素：vec.erase(vec.begin()+2);删除第3个元素。
vec.erase(vec.begin()+i,vec.end()+j);删除区间[i,j-1];区间从0开始。
8)向量大小:vec.size()。
9)清空:vec.clear()。
10)初始化赋值：
vector c1(c2) // 复制一个vector（c2也是一个vector）
vector c(n) // 创建一个vector，含有n个数据，数据均已缺省构造产生
vector c(n, elem) // 创建一个含有n个elem元素的vector
vector c(beg,end) // int array[]={1,2,3}，beg=array,end=array+3，用数组为vector赋值
11)判断是否为空：vec.empty()。
先看一维数组的动态建立及输入，并输出验证的例：
#include <iostream>
#include <vector>
using namespace std;
int main(){
vector<int> vector1;
int inputnum=0;
cout << "数组元素个数:";
cin >>inputnum;
int temp = 0;
cout << "数组元素值:";
for (int i = 0; i < inputnum; i++)//输入一维数组
{
cin >> temp;
vector1.push_back(temp);
};
//输出验证
for (int i = 0; i < inputnum; i++)//打印输入的数组
{
cout << vector1[i] << " ";
}
return 0;
}
运行之，参见下图：
再看二维数组的动态建立及输入，并输出验证的例：
#include <iostream>
#include <vector>
using namespace std;
int main(){
int r = 0, c = 0;
cout << "row:";
cin >> r; //输入二维数组的行数
cout << "col:";
cin >> c;//输入二维数组的列数
vector<vector<int> >array;//定义二维数组
vector<int>v;//定义一维数组
array.clear();//将二维数组清空，即初始化
int temp = 0;
cout << "数组元素值:";
for (int i = 0; i < r; i++)//输入r*c的二维数组
{
v.clear();//子数组返回时要清除
for (int j = 0; j < c; j++)
{
cin >> temp;
v.push_back(temp);
}
array.push_back(v);
}
//输出验证
for (int i = 0; i < r; i++)//打印输入的二维数组
{
for (int j = 0; j < c; j++)
{
cout << array[i][j] << " ";
}
printf("\n");
}
return 0;
}
运行之，参见下图：
最后，简单介绍三维数组。
array[a][b][c]
如何理解三维数组含义：可以理解为该数组有a页，每一页都有一个b行c列的二维数组。参见下图：
声明三维数组，如：
int myarray[2][3][4];
定义一个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}}
};
如果已经给出了足够的初始化项，就可以不用写内部嵌套的花括号了。
每个括号对应一个维度，外层括号对应第一维，内层括号对应第二维，再内层括号对应第三维。需要注意的是，如果只给出了一部分初始化项，必须显式地使用大括号。
也可使用嵌套循环给数组赋值
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++;
}
}
}
三维数组示例
#include <iostream>
using namespace std;
int main(){
// initializing the array
int arr[2][3][4] = {1, -1 ,2 ,-2 , 3 , -3, 4, -4, 5, -5, 6, -6,
7,-7,8,-8,9,-9,10,-10,11,-11,12,-12};
// displaying array values
for (int x = 0; x < 2; x++) {
cout <<"第"<< x << "层"<< endl;
for (int y = 0; y < 3; y++) {
for (int z = 0; z < 4; z++) {
cout<<arr[x][y][z]<<" ";
}
cout << endl;
}
}
return 0;
}
运行之，参见下图：
特别提示：多维数组的构成元素优先按末尾的下标递增的顺序排列。
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++数组的元素在内存中的存储介绍 可见 https://blog.csdn.net/cnds123/article/details/132183541
字符数组（char array）是由字符组成的一维数组，包含多个字符元素。字符数组也有一维、二维、三维之分。
要学好，需要了先解字符类型。字符类型用于表示单个字符，而字符数组用于表示一系列字符，可以用来处理字符串。
字符类型（char）
在C++中，字符类型使用关键字char来定义。字符类型表示单个字符，包括数字、字母、符号等。字符类型的大小是一个字节（8位）。
字符类型变量只能存储一个字符，例如：
char c = 'A'; // 定义字符类型变量c，存储值为'A'
注意使用字符类型数据确实使用单引号（' '）。
空字符的 ASCII 码值为 0，因此，可以使用以下语句来表示空字符：
char c = '\0';
一维字符数组
c++中，可以使用字符类型数组来存储多个字符。字符类型数组是由多个字符类型变量组成的有序集合，即一串字符。可以使用花括号和逗号分隔符来初始化字符类型数组，也可以使用双引号来初始化字符类型数组，这样可以更容易地输入一串字符，而无需逐个输入每个字符。例如：
char str1[] = {'H', 'e', 'l', 'l', 'o'}; // 定义字符类型数组str1，但不是一个字符串
char str2[] = {'H', 'e', 'l', 'l', 'o', '\0'}; // 定义字符类型数组str2，并且是一个字符串
char str3[] = "Hello"; // 定义并双引号进行初始化字符类型数组str3，并且是一个字符串
str2和str3是等价的。
字符类型数组可以用来存储字符串，字符数组以空字符（'\0'）作为结尾标识，表示字符串的结束。在使用双引号进行初始化时，编译器会自动在字符数组末尾添加一个空字符'\0'，也就是说使用字符串字面值来初始化字符类型数组时，不需要明确地添加空字符。
一维字符数组和字符串的不同点：
1.字符串以空字符('\0')作为字符串的结束符，而字符数组没有特定的结束符。
2.字符串可以使用双引号("")来初始化，例如char str[] = "hello"，而字符数组则需依次赋值，例如char arr[] = {'h', 'e', 'l', 'l', 'o'}或者char arr[] = "hello";（这种方式会在数组的末尾自动添加一个空字符）。
3.字符串可以使用一些针对字符串类型的函数，例如strlen()、strcpy()、strcmp()等等。字符数组也可以使用这些函数，但是需要对其具体的长度、空字符进行处理。
注意，尽管字符数组可以用来处理字符串，但在C++中，通常推荐使用string类。
一维字符数组初始化
1.使用字符串字面值进行初始化：
char str[] = "Hello";
这会创建一个字符数组str，并将字符串字面值"Hello"复制到该数组中。注意，字符数组的大小会根据字符串的长度自动确定。
2.使用花括号初始化列表进行初始化：
char str[] = {'H', 'e', 'l', 'l', 'o', '\0'};
这里使用花括号{}来指定字符数组的初始元素，包括最后一个null字符('\0')。
3.逐个赋值：
char str[6];
str[0] = 'H';
str[1] = 'e';
str[2] = 'l';
str[3] = 'l';
str[4] = 'o';
str[5] = '\0';
这种方式需要逐个给字符数组的元素赋值，并确保最后一个元素是null字符('\0')。
4.使用strcpy函数进行赋值（需要包含头文件<cstring>）：
#include <cstring>
char str[6];
strcpy(str, "Hello");
注意，无论使用哪种方式，都需要保证字符数组的容量足够大，能够容纳赋值的字符串。另外，字符串赋值时要确保最后一个字符是字符串的结尾符 '\0'即null字符。
特别提示
C语言中只有一种方式来表示字符串，那就是使用C-style string的字符数组（char array）。
C++中处理字符串的两种常见方式是：
1.C-style string的字符数组（char array）：使用字符数组来表示和处理字符串。字符数组以null字符 '\0' 结尾，可以使用C风格的字符串函数来进行操作。这种方式需要手动管理内存，并且对于较长的字符串长度可能会有限制。
【下面两句是有区别的
char str[6] = {'H', 'e', 'l', 'l', 'o'};
char str[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
都是合法的。
第一种写法定义了一个包含5个字符的字符数组，初始化为指定的字符序列，但没有明确指定空字符('\0')。如果将其作为字符串使用，可能会导致访问越界或其他错误。
第二种写法定义了一个包含5个字符和一个空字符的字符数组，并且明确地将最后一个元素设置为空字符('\0')。这样就确保了数组以空字符结尾，可以被正确地当作字符串来处理。】
2.使用 string 类型：C++标准库提供了 string 类型（std::string），它是一个类模板。可以通过包含 <string> 头文件来使用 string 类型。string 类型提供了许多方便的字符串操作方法，它为字符串的处理提供了更高级的抽象和功能。
在C++中，您可以选择使用 char 数组或者 string 类型来处理字符串，具体取决于您的需求和偏好。
一维字符数组简单示例
#include <iostream>
using namespace std;
int main() {
char str[] = "Hello, World!"; // 自动计算大小
cout << str << endl; // 输出：Hello, World!
return 0;
}
在现代C++编程中，推荐使用string。C++标准库中的<cstring>头文件提供了许多用于操作字符数组的函数，例如：
strlen(): 返回字符串的长度。
strcpy(): 复制字符串。
strcat(): 连接字符串。
strcmp(): 比较两个字符串。
示例
#include <iostream>
#include <cstring>
using namespace std;
int main() {
char str1[] = "Hello";
char str2[] = "World";
char combined[11];
strcpy(combined, str1); // 复制str1到combined
strcat(combined, " "); // 连接空格
strcat(combined, str2); // 连接str2
cout << combined; // 输出 "Hello World"
return 0;
}
二维字符数组
最常见的初始化方式
1：逐个初始化
char charArray1[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
2：使用字符串字面值初始化
char charArray2[2][3] = {"ab", "cd"};
二维字符数组简单示例：
#include <iostream>
using namespace std;
int main() {
// 二维字符数组
char str[][10] = {"Hello", "World"}; // 大小为2x10
cout << "str[0]: " << str[0] << endl;
cout << "str[1]: " << str[1] << endl;
return 0;
}
输出：
str[0]: Hello
str[1]: World