81.数组

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;
}

5）指针也是迭代器

  vector 和string的迭代器（参见3.4节， 第95页）支待的运算，数组的指针全都支待。例如，允许使用递增运算符将指向数组元素的指针向前移动到下一个位置上：

int arr[]= {0,1,2,3,4,5,6,7,8,9}; 
int *p= arr;//p指向arr的第一个元素
++p; 
//p指向arr[1]

我们可以设法获取数组尾元素之后的那个并不存在的元素的地址：

int *e = &arr[10];//指向arr尾元素的下一位置的指针

  这里显然使用下标运算符索引了一个不存在的元素，arr有10个元素，尾元素所在位置的索引是9，接下来那个不存在的元素唯一的用处就是提供其地址用于初始化e。就像尾后迭代器（参见3.4.1节，第95页）一样，尾后指针也不指向具体的元素。

6)指针运算

  和迭代器一样，两个指针相减的结果是它们之间的距离。参与运算的两个指针必须指向同一个数组当中的元素：

auto n = end(arr) - begin(arr);//n的值是5，也就是arr中元素的数量

  两个指针相减的结果的类型是种名为ptrdiff_t的标准库类型，和size_t一样，ptrdiff_t也是一种定义在cstddef头文件中的机器相关的类型。因为差值可能为负值，所以ptrdiff_t是一种带符号类型。

  只要两个指针指向同一个数组的元素，或者指向该数组的尾元素的下一位置，就能利用关系运算符对其进行比较。例如，可以按照如下的方式遍历数组中的元素：

int *b = arr, *e = arr + sz;
while(b < e)
{
    //使用*b
    ++b;
}

如果两个指针分别指向不相关的对象，则不能比较它们：

inti= 0, sz = 42; 
int *p = &i, *e = &sz; 
//未定义的：p和e元关，因此比较毫无意义！
while (p < e) 

  尽管作用可能不是特别明显，但必须说明的是，上述指针运算同样适用于空指针（参见2.3.2节，第48页）和所指对象并非数组的指针。在后一种情况下，两个指针必须指向同一个对象或该对象的下一位置。如果p是空指针，允许给p加上或减去一个值为0的整型常量表达式（参见2.4.4节，第58页）。两个空指针也允许彼此相减，结果当然是0。

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;    // 每显示一个方阵后，输出两个换行符。
	}
}

参考资料：

来源于慕课网和C++ Primer