数组是存放相同类型数据的一种容器，其中的数据被称为数组元素。

一维数组

1.一维数组初始化方法：

int arr[]=[1,2,3,4,5];
//1,2,3,4,5

int arr[5]=[1,2,3,4,5];
//1,2,3,4,5

int arr[5]=[1,2,3];
//1,2,3,0,0
1
2
3
4
5
6
7
8

2.数组定义时的容量必须是正整数：

//1
int arr[9];

//2
#define N 9
int arr[N];

//3
int a=9;
int arr[a];
1
2
3
4
5
6
7
8
9
10

3.编译器不会对数组做数组越界检查：

//在此情况下编译通过，不会有任何错误信息提示，但不对。
int a[9];
a[10]=10;
1
2
3

4.不能在定义数组后再对数组进行初始化：

int a[9];
a={1,2,3}; //error!

int a[9]={1,2,3};
a={4,5,6};//error!

//定义数组后，只能对单个元素进行修改
int a[9];
a[1]=2;
1
2
3
4
5
6
7
8
9

5.初始化长度和容量长度不一致会发生什么？

int a[2]={1}; //1,0
int a[2]={1,2,3}; //error!
1
2

二维数组及多维数组

二维数组的元素也是在连续空间内存储的。

1.二维数组初始化方式：

int a[2][2]={1,2,3,4};
//1,2,3,4

int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
//1,2,3,4,5,6,7,8,9,10,11,12

int a[][4]={{1,2,3,4},{5,6,7,8}};
//1,2,3,4,5,6,7,8
1
2
3
4
5
6
7
8

2.初始化时至少要指定常量表达式2：

//以下方式是错的
int a[][]={{1,2},{3,4}}; //error!
1
2

3.二维数组的属性同一维数组类似：
越界不会检查；未初始化的部分赋0；初始化时超过容量报错。

4.多维数组性质同二维数组性质相同。

字符数组

字符数组初始化方式如下：

char a[]={'h','e','l','l','o'}; //内存占用4*5=20字节
long a[]={'h','e','l','l','o'}; //内存占用16*5=80字节
char a[6]="hello"; //会自动添加字符串结束符`\0`

//二维字符数组初始化
char a[][]={
"Monday"，
"Tuesday"，
"Wednesday"
};
1
2
3
4
5
6
7
8
9
10

字符数组的结束符：

#include
int main()
{
	char a[]="hello";
	char b[]={'q','w','e','\0'};
	char c[]={'q','w','e'};
	printf("%s\n",b); //有字符串结束符，正确输出
	printf("%s\n",c); //没有字符串结束符，不正确输出

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11

qwe
qweqwe
1
2

字符数组初始化后，不能再被赋值：

char a[]="hello"; 
a="world"; //error!
1
2

数组作为函数参数的易错点

void sort(int arr[],int n);
1

不要使用局部变量作为返回值。可以在函数内使用静态变量static或动态变量malloc，作为返回值，但是static生命周期是程序的整个运行期间，所以使用malloc比较好。

动态数组

静态数组的缺点是，只能使用常量值初始化容量，编译期完成；
动态数组的优点是，可以使用变量值（比如形参）初始化容量，运行期完成，即运行到该语句时才开始分配空间。

一维动态数组初始化及释放方法：

int *arr;
arr=(int *)malloc(sizeof(int)*n);  //其中n就是变量，不是常量，所以是动态数组
free(arr);
1
2
3

二维动态数组的初始化及释放方法：

int **arr;
int i=0,j=0;
int m=2,n=2;
//初始化方法
for(i=0;i<m;i++)
{
	arr[i]=(int *)malloc(sizeof(int)*n);
}

//释放方法
for(i=0;i<m;i++)
{
	free(arr[i]);
}
free(arr);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15