1.一维数组的创建和初始化

1.1数组的创建

数组是一组相同类型元素的集合。

数组的创建方式：
数组的元素类型 数组名 [常量表达式];
eg. int arr[5]; char ch[100];

VS编译器中的易错点：【】内应为常量表达式
int n = 5;
int arr[n];（×）

int arr[5];（√）

（其实C99标准之前是不支持使用变量的，只能是常量！
C99中增加了变长数组的概念，允许数组大小是变量，而且要求编译器支持C99标准。
VS对C99的支持就不够好）

1.2数组的初始化

创建的同时给一些初始值叫初始化
int arr[5] = { 1, 2, 3, 4, 5 };
int arr[5] = { 1, 2, 3 };//不完全初始化，剩余元素默认初始化为0
int arr[] = { 1, 2, 3 };//未确定大小的数组根据初始化内容分配空间

	char arr1[] = { 'a', 'b', 'c' };char arr2[] = "abc";//sizeof求数组大小printf("%d\n", sizeof(arr1));//arr1有三个元素，数组大小是3个字节printf("%d\n", sizeof(arr2));//arr2有四个元素，数组大小是4个字节//strlen求字符串长度，遇到 '\0' 才停下printf("%d\n", strlen(arr1));//数组末尾没有‘\0’，我们没法知道‘\0’会出现在什么地方，因此arr1的长度是随机值printf("%d\n", strlen(arr2));//数组末尾有‘\0’,在其之前有三个元素，arr2的长度为3

strlen是一个库函数，使用前要加 #include<string.h>
计算的是字符串的长度，并且只针对字符串
关注的是字符串中是否有\0，计算的是\0之前的字符个数

sizeof是一个操作符（运算符）
sizeof使用来计算变量所占内存空间大小的，任何类型都可以使用哦
只关注空间大小，不在乎内存中是否有\0

1.3一维数组的使用

数组是有下标的，第一个元素下标为0，依次增加

	int arr[5] = { 1, 2, 3, 4, 5 };printf("%d", arr[2]);//[]是下表访问操作符，这里是打印下标为2的数，打印出了3//打印数组所有元素，即打印下标为0，1，2，3，4的元素int i = 0;int sz = sizeof(arr) / sizeof(arr[0]);//40/4求出元素个数，数组大小for (i = 0; i < sz; i++){printf("%d ", arr[i]);}

1.4 一维数组在内存中的存储

	int arr[5] = { 1, 2, 3, 4, 5 };//打印数组每个元素的地址int i = 0;for (i = 0; i < 5; i++){printf("&arr[%d] = %p \n",i, &arr[i]);}

每两个地址之间相差4
一个整型是四个字节
内存中一个字节给一个地址

结论
1.一维数组在内存中是连续存放的
2.数组随着下标的增长，地址是由低到高变化的

	int arr[5] = { 1, 2, 3, 4, 5 };int i = 0;int *p = &arr[0];for (i = 0; i < 5; i++){printf("%p----- %p \n", &arr[i], p + i);}

可以用首地址+i跳转到第i个元素地址
因此可以用*（p+i）来得到第i个元素（这个跟之后要讲的指针有关系哟，现在先了解一下下）

2.二维数组的创建和初始化

2.1二维数组的创建

int arr[3][4];
char arr[3][5];
double arr[2][4];

int arr[3][4];

2.2二维数组的初始化

int arr[3][4] = {1,2,3,4};//不完全初始化,不够就添0
int arr[3][4] = {{1,2},{4,5}};//1 2 0 0//4 5 0 0//0 0 0 0
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

2.3二维数组的使用

//打印二维数组int arr[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 4; j++){printf("%d ", arr[i][j]);}}

2.4二维数组在内存中的存储

//打印数组每个元素的地址int arr[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 4; j++){printf("&arr[%d][%d] = %p \n",i,j, &arr[i][j]);}}

二维数组存放看似不连续，实则连续存放

3. 数组越界

数组的下标是有范围限制的。
数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。
所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。
C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，
二维数组的行和列也可能存在越界。
所以程序员写代码时，最好自己做越界的检查

#include <stdio.h>
int main()
{int i = 0;int arr[] = {1,2,3,4,5,6,7,8,9,10};for(i=0; i<=12; i++)//在这里数组越界访问了，但这是主要问题吗？{arr[i] = 0;printf("haha\n");}return 0;
}

让我们公布答案吧！
这段代码的bug是死循环
很抱歉满屏的haha吵到了你的眼睛（手动狗头）
是不是难以想象？请带着疑惑看看下文解释

有以下几个规则：

1. i和arr是局部变量
2. 局部变量是放在栈区上的
3. 栈区上内存的使用习惯是：先使用高地址处空间再使用地地址处空间
4. 数组随着下标的增长，地址由低到高变化

示意图如下

“由低到高”和“由高到低”相遇了。
arr [12] = 0; 间接改变了i，相当于i = 0；
这样一来i又从0依次变大再回归0，实现了死循环的局面

至于空白格子代表的局部变量储存时相间隔的的字节个数是如何确定的，
这得看不同编译器了。vs编译器是空两格，其他编译器是什么样的，感兴趣可以自己探索哦。

4. 数组作为函数参数

4.1 冒泡排序函数的错误设计

冒泡排序的核心思想：
相邻的两元素进行比较，有需要的话就交换

#include <stdio.h>void bubble_sort(int arr[])
{int sz = sizeof(arr)/sizeof(arr[0]);//这样对吗？int i = 0;for(i=0; i<sz-1; i++)//sz-1趟冒泡排序{int j = 0;for(j=0; j<sz-i-1; j++){if(arr[j] > arr[j+1]){//交换int tmp = arr[j];arr[j] = arr[j+1];arr[j+1] = tmp;}}}
}int main()
{int arr[] = {3,1,7,5,8,9,0,2,4,6};bubble_sort(arr);//是否可以正常排序？for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++){printf("%d ", arr[i]);}return 0;
}

4.2 数组名是什么？

数组传参的实质不是传整个数组，而是首元素的地址
bubble_sort函数中的sizeof(arr)算出的是指针的大小，因此导致错误
arr本质是首元素地址，数组接收时也可以用int *arr代替int arr[]

特殊情况：1.&arr

2.sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组

4.3 冒泡排序函数的正确设计

void bubble_sort(int arr[], int sz)//参数接收数组元素个数
{//代码同上面函数int i = 0;for(i=0; i<sz-1; i++)//sz-1趟冒泡排序{int j = 0;for(j=0; j<sz-i-1; j++){if(arr[j] > arr[j+1]){int tmp = arr[j];arr[j] = arr[j+1];arr[j+1] = tmp;}}}
}
int main()
{int arr[] = {3,1,7,5,8,9,0,2,4,6};int sz = sizeof(arr)/sizeof(arr[0]);bubble_sort(arr, sz);//是否可以正常排序？for(i=0; i<sz; i++){printf("%d ", arr[i]);}return 0;
}

5. 数据实例

5.1 数组的应用实例1：三子棋

我的其它博客里有写到：
三子棋.

5.2 数组的应用实例2：扫雷游戏

我的其它博客里有写到：
扫雷游戏.

让我们学以致用，玩起来吧！