1.一维数组的基本概念
数组是一组数据类型相同的变量，可以存放一组数据。
1）创建数组
声明数组的语法：数据类型 数组名[数组长度];
注意：数组长度必须是整数，可以是常量，也可以是变量和表达式。
C90规定必须用常量表达式指明数组的大小，C99允许使用整型非常量表达式。经测试，在VS中可以用整型非常量表达式，不能用变量；但是，Linux中还可以用变量。
2）数组的使用
可以通过下标访问数组中元素，数组下标从0开始。
数组中每个元素的特征和使用方法与单个变量完全相同。
语法：数组名[数组下标]
注意：
●数组下标也必须是整数，可以是常量，也可以是变量。
●合法的数组下标取值是：0~(数组长度-1)。
3）数组占用内存的情况
数组在内存中占用的空间是连续的。
用sizeof(数组名)可以得到整个数组占用内存空间的大小（只适用于C++基本数据类型）。
4）数组的初始化
声明的时候初始化：
数据类型 数组名[数组长度] = { 值1，值2，值3, ...... , 值n};
数据类型 数组名[ ] = { 值1，值2，值3, ...... , 值n};
数据类型 数组名[数组长度] = { 0 }; // 把全部的元素初始化为0。
数据类型 数组名[数组长度] = { }; // 把全部的元素初始化为0。
注意：如果{}内不足数组长度个数据，剩余数据用0补全，但是，不建议这么用，你可能在数组中漏了某个值。如果想把数组中全部的元素初始化为0，可以在{}内只填一个0或什么也不填。
C++11标准可以不写等于号。
5）清空数组
用memset()函数可以把数组中全部的元素清零。（只适用于C++基本数据类型）
函数原型：void *memset(void *s, int c, size_t n);
注意，在Linux下，使用memcpy()函数需要包含头文件#include <string.h>
6）复制数组
用memcpy()函数可以把数组中全部的元素复制到另一个相同大小的数组。（只适用于C++基本数据类型）
函数原型：void *memcpy(void *dest, const void *src, size_t n);
注意，在Linux下，使用memcpy()函数需要包含头文件#include <string.h>
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
int bh[] = {3, 6, 1,6,7,4,3,5,6,7,8,322,2,3,9}; // 超女编号。
string name[3]; // 超女姓名。
for (int ii = 0; ii < sizeof(bh)/sizeof(int); ii++)
{
cout << "bh["<<ii<<"]=" << bh[ii] << endl;
}
int bh1[sizeof(bh) / sizeof(int)]; // 数组长度必须是整数，可以是常量，也可以是变量和表达式。
memcpy(bh1, bh, sizeof(bh)); // 把数组bh中的内容复制到bh1。
for (int ii = 0; ii < sizeof(bh1) / sizeof(int); ii++)
{
cout << "bh1[" << ii << "]=" << bh1[ii] << endl;
}
}
2.一维数组和指针
1）指针的算术
将一个整型变量加1后，其值将增加1。
但是，将指针变量（地址的值）加1后，增加的量等于它指向的数据类型的字节数。
2）数组的地址
a）数组在内存中占用的空间是连续的。
b）C++将数组名解释为数组第0个元素的地址。
c）数组第0个元素的地址和数组首地址的取值是相同的。
d）数组第n个元素的地址是：数组首地址+n
e）C++编译器把 数组名[下标] 解释为 *(数组首地址+下标)
3）数组的本质
数组是占用连续空间的一块内存，数组名被解释为数组第0个元素的地址。C++操作这块内存有两种方法：数组解释法和指针表示法，它们是等价的。
4）数组名不一定会被解释为地址
在多数情况下，C++将数组名解释为数组的第0个元素的地址，但是，将sizeof运算符用于数据名时，将返回整个数组占用内存空间的字节数。
可以修改指针的值，但数组名是常量，不可修改。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
char a; cout << "sizeof(char)=" << sizeof(char) << endl; // 1字节
short b; cout << "sizeof(short)=" << sizeof(short) << endl; // 2字节
int c; cout << "sizeof(int)=" << sizeof(int) << endl; // 4字节
double d; cout << "sizeof(double)=" << sizeof(double) << endl; // 8字节
cout << "a的地址是：" << (void *)& a << endl;
cout << "a的地址+1是：" << (void*)( & a + 1) << endl;
cout << "b的地址是：" << (void*)&b << endl;
cout << "b的地址+1是：" << (void*)(&b + 1) << endl;
cout << "c的地址是：" << (void*)&c << endl;
cout << "c的地址+1是：" << (void*)(&c + 1) << endl;
cout << "d的地址是：" << (void*)&d << endl;
cout << "d的地址+1是：" << (void*)(&d + 1) << endl;
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
double a[5];
cout << "a的值是：" << (long long) a << endl;
cout << "&a的值是：" << (long long)&a << endl;
cout << "a[0]的地址是：" << (long long) &a[0] << endl;
cout << "a[1]的地址是：" << (long long) &a[1] << endl;
cout << "a[2]的地址是：" << (long long) &a[2] << endl;
cout << "a[3]的地址是：" << (long long) &a[3] << endl;
cout << "a[4]的地址是：" << (long long) &a[4] << endl;
double* p = a;
cout << "p的值是：" << (long long)p << endl;
cout << "p+0的值是：" << (long long)(p+ 0) << endl;
cout << "p+1的值是：" << (long long)(p + 1) << endl;
cout << "p+2的值是：" << (long long)(p + 2) << endl;
cout << "p+3的值是：" << (long long)(p + 3) << endl;
cout << "p+4的值是：" << (long long)(p + 4) << endl;
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
int a[5] = { 3 , 6 , 5 , 8 , 9 };
// 用数组表示法操作数组。
cout << "a[0]的值是：" << a[0] << endl;
cout << "a[1]的值是：" << a[1] << endl;
cout << "a[2]的值是：" << a[2] << endl;
cout << "a[3]的值是：" << a[3] << endl;
cout << "a[4]的值是：" << a[4] << endl;
// 用指针表示法操作数组。
int* p = a;
cout << "*(p+0)的值是：" << *(p+ 0) << endl;
cout << "*(p+1)的值是：" << *(p + 1) << endl;
cout << "*(p+2)的值是：" << *(p + 2) << endl;
cout << "*(p+3)的值是：" << *(p + 3) << endl;
cout << "*(p+4)的值是：" << *(p + 4) << endl;
}
3.一维数组用于函数的参数
1）指针的数组表示
在C++内部，用指针来处理数组。
C++编译器把 数组名[下标] 解释为 *(数组首地址+下标)
C++编译器把 地址[下标] 解释为 *(地址+下标)
2）一维数组用于函数的参数
一维数组用于函数的参数时，只能传数组的地址，并且必须把数组长度也传进去，除非数组中有最后一个元素的标志。
书写方法有两种：
void func(int* arr, int len);
void func(int arr[], int len);
注意：
在函数中，可以用数组表示法，也可以用指针表示法。
在函数中，不要对指针名用sizeof运算符，它不是数组名。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
char a[20]; // 这是一个长度为20的字符型数组。
int* p = (int *)a; // 让整型指针p指向数组a的内存。
for (int ii = 0; ii < 6; ii++)
{
p[ii] = ii + 300; // 用数组表示法操作指针。
}
for (int ii = 0; ii < 6; ii++)
{
cout << "*(p+" << ii << ")的值是：" << *(p + ii) << endl; // 地址[下标] 解释为 *(地址+下标)。
}
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// void func(int *arr,int len)
void func(int arr[],int len)
{
for (int ii = 0; ii < len; ii++)
{
cout << "arr[" << ii << "]的值是：" << arr[ii] << endl; // 用数组表示法操作指针。
cout << "*(arr+" << ii << ")的值是：" << *(arr + ii) << endl; // 地址[下标] 解释为 *(地址+下标)。
}
}
int main()
{
int a[] = {2,8,4,6,7,1,9};
func(a, sizeof(a) / sizeof(int));
}
4.用new动态创建一维数组
普通数组在栈上分配内存，栈很小；如果需要存放更多的元素，必须在堆上分配内存。
动态创建一维数组的语法：数据类型 *指针=new 数据类型[数组长度];
释放一维数组的语法：delete [] 指针;
注意：
●动态创建的数组没有数组名，不能用sizeof运算符。
● 可以用数组表示法和指针表示法两种方式使用动态创建的数组。
●必须使用delete[]来释放动态数组的内存（不能只用delete）。
● 不要用delete[]来释放不是new[]分配的内存。
●不要用delete[]释放同一个内存块两次（否则等同于操作野指针）。
●对空指针用delete[]是安全的（释放内存后，应该把指针置空nullptr）。
●声明普通数组的时候，数组长度可以用变量，相当于在栈上动态创建数组，并且不需要释放。
● 如果内存不足，调用new会产生异常，导致程序中止；如果在new关键字后面加(std::nothrow)选项，则返回nullptr，不会产生异常。
●为什么用delete[]释放数组的时候，不需要指定数组的大小？因为系统会自动跟踪已分配数组的内存。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
int *arr=new int[8]; // 创建8个元素的整型数组。
for (int ii = 0; ii < 8; ii++)
{
arr[ii] = 100 + ii; // 数组表示法。
cout << "arr[" << ii << "]=" << *(arr + ii) << endl; // 指针表示法。
}
delete[]arr;
}
5.一维数组的排序qsort
qsort()函数用于对各种数据类型的数组进行排序。
函数的原型：
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
第一个参数：数组的起始地址。
第二个参数：数组元素的个数（数组长度）。
第三个参数：数组元素所占的大小（sizeof(数组的数据类型)）。
第四个参数：回调函数的地址。
回调函数决定了排序的顺序，声明如下：
int compar(const void *p1, const void *p2);
1）如果函数的返回值<0，那么p1所指向元素会被排在p2所指向元素的前面。
2）如果函数的返回值==0，那么p1所指向元素与p2所指向元素的顺序不确定。
3）如果函数的返回值>0，那么p1所指向元素会被排在p2所指向元素的后面。
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));
qsort()函数的其它细节：
●形参中的地址用void是为了支持任意数据类型，在回调函数中必须具体化。
●为什么需要第三个形参size_t size？
●size_t是C标准库中定义的，在64位系统中是8字节无符号整型（unsigned long long）。
typedef unsigned long long size_t
●排序的需求除了升序和降序，还有很多不可预知的情况，只能用回调函数。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int compasc(const void* p1, const void* p2) // 升序的回调函数。
{
return *((int*)p1) - *((int*)p2);
}
int compdesc(const void* p1, const void* p2) // 降序的回调函数。
{
return *((int*)p2) - *((int*)p1);
}
int main()
{
int a[8] = { 4,2,7,5,8,6,1,3 };
qsort(a,sizeof(a)/sizeof(int),sizeof(int),compasc); // 对数组a进行升序排序。
for (int ii = 0; ii < 8; ii++)
{
cout << "a[" << ii << "]=" << a[ii] << endl;
}
qsort(a, sizeof(a) / sizeof(int), sizeof(int), compdesc); // 对数组a进行降序排序。
for (int ii = 0; ii < 8; ii++)
{
cout << "a[" << ii << "]=" << a[ii] << endl;
}
}
6.一维数组的查找-折半查找
折半查找也叫二分查找，只适用于已排序的数组（升序降序都可以）。
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// 在arr中查找key，成功返回key在arr中的数组下标，失败返回-1。
int search(int arr[], int len, int key)
{
int low = 0, high = len-1, mid; // 初始化：low=0，high=数组长度-1。
while (low <= high)
{
mid = (low + high) / 2; // 计算mid指针的位置。
if (arr[mid] == key)
return mid; // 查找成功。
else if (arr[mid] > key)
high = mid - 1; // 继续在前半区查找。
else
low = mid + 1; // 继续在后半区查找。
}
return -1; // 查找失败。
}
int main()
{
int a[10] = { 7,9,12,16,21,25,30,35,41,48 }; // 必须是已排好序的数组。
if (search(a, 10, 30) >= 0) cout << "在数组a中查找30成功。\n";
else cout << "在数组a中查找30失败。\n";
}
7.二维数组
一维数组的数学概念是线性表，二维数组的数学概念是矩阵。
1）创建二维数组
声明二维数组的语法：数据类型 数组名[行数][列数];
注意：数组长度必须是整数，可以是常量，也可以是变量和表达式。
C90规定必须用常量表达式指明数组的大小，C99允许使用整型非常量表达式。经测试，在VS中可以用用整型非常量表达式，不能用变量；但是，Linux中还可以用变量。
2）二维数组的使用
可以通过行下标和列下标访问二维数组中元素，下标从0开始。
二维数组中每个元素的特征和使用方法与单个变量完全相同。
语法：数组名[行下标][列下标]
注意：
●二维数组下标也必须是整数，可以是常量，也可以是变量。
●合法的行下标取值是：0~(行数-1)。
●合法的列下标取值是：0~(列数-1)。
3）二维数组占用内存的情况
用sizeof(数组名)可以得到整个二维数组占用内存空间的大小（只适用于C++基本数据类型）。
二维数组在内存中占用的空间是连续的。
4）二维数组的初始化
声明的时候初始化：
数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 },...... };
数据类型 数组名[行数][列数] = { 数据1，数据2，数据3，数据4, ......};
数据类型 数组名[ ][列数] = { 数据1，数据2，数据3，数据4,......};
数据类型 数组名[行数][列数] = { 0 }; // 把全部的元素初始化为0。
数据类型 数组名[行数][列数] = { }; // 把全部的元素初始化为0。
注意：如果{}内不足数组长度个数据，剩余数据用0补全，但是，不建议这么用，你可能在数组中漏了某个值。如果想把数组中全部的元素初始化为0，可以在{}内只填一个0或什么也不填。
C++11标准可以不写等于号。
5）清空二维数组
用memset()函数可以把二维数组中全部的元素清零。（只适用于C++基本数据类型）
函数原型：void *memset(void *s, int c, size_t n);
注意，在Linux下，使用memcpy()函数需要包含头文件#include <string.h>
6）复制二维数组
用memcpy()函数可以把二维数组中全部的元素复制到另一个相同大小的数组（没说多少维）。（只适用于C++基本数据类型）
函数原型：void *memcpy(void *dest, const void *src, size_t n);
注意，在Linux下，使用memcpy()函数需要包含头文件#include <string.h>
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
// int bh[2][3] = { {11,12,13},{21,22,23} }; // 声明一个两行三列的二维数组，存放超女的编号。
// int bh[2][3] = { 11,12,13,21,22,23 };
int bh[][3] = { 11,12,13,21,22,23 };
/*bh[0][0] = 11; bh[0][1] = 12; bh[0][2] = 13;
bh[1][0] = 21; bh[1][1] = 22; bh[1][2] = 23;*/
/*cout << "bh[0][0] = " << bh[0][0] << " bh[0][1] = " << bh[0][1] << " bh[0][2] = " << bh[0][2] << endl;
cout << "bh[1][0] = " << bh[1][0] << " bh[1][1] = " << bh[1][1] << " bh[1][2] = " << bh[1][2] << endl;*/
for (int ii = 0; ii < 2; ii++) // 第一层循环表示行数，循环继续的条件是计数器小于行数。
{
for (int jj = 0; jj < 3; jj++) // 第二层循环表示列数，循环继续的条件是计数器小于列数。
{
cout << "&bh["<<ii<<"]["<<jj<<"] = " << (long long) & bh[ii][jj] << " "; // 处理二维数组的每个元素。
}
cout << endl; // 每处理一行数据后，输出一个换行。
}
int* p = (int *)bh;
for (int ii = 0; ii < 6; ii++)
{
cout << "p[" << ii << "]=" << p[ii] << endl; // 一维数组的数组表示法。
}
}
8.二维数组用于函数的参数
int* p; // 整型指针。
int* p[3]; // 一维整型指针数组，元素是3个整型指针（p[0]、p[1]、p[2]）。
int* p(); // 函数p的返回值类型是整型的地址。
int (*p)(int ,int); // p是函数指针，函数的返回值是整型。
1）行指针（数组指针）
声明行指针的语法：数据类型 (*行指针名)[行的大小]; // 行的大小即数组长度。
int (*p1)[3]; // p1是行指针，用于指向数组长度为3的int型数组。
int (*p2)[5]; // p2行指针，用于指向数组长度为5的int型数组。
double (*p3)[5]; // p3是行指针，用于指向数组长度为5的double型数组。
一维数组名被解释为数组第0个元素的地址。
对一维数组名取地址得到的是数组的地址，是行地址。
2）二维数组名是行地址
int bh[2][3] = { {11,12,13},{21,22,23} };
bh是二维数组名，该数组有两行元素，每一个元素本身又是一个数组长度为3的整型数组。
bh被解释为数组长度为3的整型数组类型的行地址。
如果存放bh的值，要用数组长度为3的整型数组类型的行指针。
int (*p)[3]=bh;
int bh[4][2][3];
bh是三维数组名，该数组有4元素，每一个元素本身又是一个2行3列的二维数组。
bh被解释为2行3列的二维数组类型的二维地址。
如果存放bh的值，要用2行3列的二维数组类型的二维指针。
int (*p)[2][3]=bh;
3）把二维数组传递给函数
如果要把bh传给函数，函数的声明如下：
void func(int (*p)[3],int len);
void func(int p[][3],int len);
示例：
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
int main()
{
int a[10];
cout << "数组a第0个元素的地址：" << a<< endl;
cout << "数组a的地址：" << &a << endl;
cout << "数组a第0个元素的地址+1：" << a + 1 << endl; // 地址的增加量是4。
cout << "数组a的地址+1：" << &a + 1 << endl; // 地址的增加量是40。
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
// void func(int(*p)[3], int len)
void func(int p[][3], int len)
{
for (int ii = 0; ii < len; ii++)
{
for (int jj = 0; jj < 3; jj++)
cout << "p[" << ii << "][" << jj << "]=" << p[ii][jj] << " " ;
cout << endl;
}
}
int main()
{
int bh[2][3] = { {11,12,13},{21,22,23} };
func(bh,2);
}
#include <iostream> // 包含头文件。
using namespace std; // 指定缺省的命名空间。
void func(int (*p)[2][3])
{
int ii = 1;
// 遍历三维数组p，给它的每个元素赋值。
for (int a = 0; a < 4; a++)
for (int b = 0; b < 2; b++)
for (int c = 0; c < 3; c++)
p[a][b][c] = ii++;
}
int main()
{
int bh[4][2][3]; // 假设有4个超女方阵，每个方阵有2行，每行有3个超女。
memset(bh, 0, sizeof(bh));
func(bh);
for (int a = 0; a < 4; a++)
{
for (int b = 0; b < 2; b++)
{
for (int c = 0; c < 3; c++)
cout << bh[a][b][c] <<"\t";
cout << endl; // 每显示一行后，输出一个换行符。
}
cout << endl<<endl; // 每显示一个方阵后，输出两个换行符。
}
}