C语言——数组

一、一维数组的创建和初始化

1.1 数组的创建

• 数组是一组相同类型元素的集合（数组可以用来存放一组相同类型的元素）
• 数组（Array）的创建方式

标准格式为：

type_t arr_name [const_n];
//type_t 是指数组的元素类型
//arr_name是数组的变量名
//const_n是一个常量表达式，用来指定数组的大小

• 数组创建示例

int arr[10]; //创建一个整形数组arr，可以存放10个整形元素
//同样的
char arr2[5];
float arr3[4];

• 数组错误创建方式

注：C99标准之前，[ ]中不能使用变量，C99标准支持了变长数组的概念（ [ ]里可用变量）
因为const_n是一个常量表达式，所以创建数组时[ ]里不能使用变量，如

int n=10;
int arr[n]; //这里的n是变量，所以创建失败

1.2 数组的初始化

• 数组的初始化是指，在创建数组的同时，给数组的内容一些合理的初始值（初始化）

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };//数组中每一个元素都赋值（完全初始化）
	int arr1[10] = { 1,2,3 };//不完全初始化，其余元素默认都是0
	int arr2[10] = { 0 };//所以当你想让数组中的元素全为0时，可以仅设置第一个元素值为0
	int arr3[] = { 0 };//省略数组大小时，数组必须初始化，数组的大小是根据初始化的内容确定
	//arr3里有1个元素，所以这里相当于arr3[1]
	int arr4[] = { 1,2,3 };//相当于arr4[3]
	//int arr5[];//错误
	char arr5[] = "abc";//注意，arr5里四个元素，字符串结尾隐藏一个\0，arr5存的是'a','b','c','\0'
	char arr6[] = { 'a','b','c' }; //我只想存abc时可以用大括号括起来后，用单引号引起来存储
	return 0;
}

注意：数组的初始化分为完全初始化和不完全初始化，完全初始化就是给每一个位置都附上值；不完全初始化就是只给部分位置附上值，如int arr1[10] = { 1,2,3 };，当不完全初始化时，其余未赋值位置的值默认为0；
另外一种写法就是定义数组时[ ]里不放东西，这种情况下必须要进行初始化，数组大小则会根据你放入元素个数来确定，如int arr4[] = { 1,2,3 };这里的数组大小就相当于int arr4[3]的大小
注意：当用数组存储字符串时，则数组最后存储的是 ‘\0’ ；如char arr5[] = “abc”;//注意，arr5里四个元素，字符串结尾隐藏一个\0，arr5存的是’a’,‘b’,‘c’,‘\0’；但是如果我只想存储abc的话，就使用{ }括起来，abc分别用单引号引起，如arr6；打开监视界面可以看到arr6里面内容仅有abc

另外，字符在内存中是通过ASCII码值来存的，如’b’的码值就是98，所以我们存98和存字符’b’是一个效果，以下两种写法等价

int main()
{
	char arr[] = { 'b' };
	char arr1[] = { 98 };
	printf("%c\n", arr[0]);
	printf("%c", arr1[0]);
	return 0;
}

1.3 一维数组的使用

• 前面出现的 [ ] 是下标引用操作符，它其实就是数组访问的操作符

数组下标是从0开始，并且数组中的元素是在内存中连续存放的（见1.4）；
所以通过下标访问数组就是从下标0开始依次访问

数组的大小可以通过计算得来，见代码注释

//根据下标访问数组
int main()
{
	int arr[] = { 1,2,3,4,5,6 };
	int sz = sizeof(arr) / sizeof(arr[0]);//sz为arr数组的元素个数
	//sizeof(arr)是arr数组所占空间，arr[0]是arr中一个元素所占空间
	//则相除的值就是数组中元素个数
	for (int i = 0; i < sz; i++) //因为数组下标从0开始，则i最大为sz-1，所以i<sz或i<=sz-1
	{
		printf("%d ",arr[i]); //依次打印数组元素
	}
	return 0;
}
//输出结果为：1 2 3 4 5 6

数组存入数据也可以由scanf函数输入，如下

//scnaf函数输入
int main()
{
	int arr[10];
	printf("输入：");
	for (int i = 0; i < 10; i++)
	{
		scanf("%d", &arr[i]); //依次输入数组元素
	}
	printf("输出：");
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]); //依次打印数组元素
	}
	return 0;
}

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

• 接下来我们讨论数组在内存中的存储

而要研究其在内存中的存储，自然要根据元素在内存中的地址来分析，看以下代码

//观察数组内部地址
int main()
{
	int arr[] = { 1,2,3,4,6 };
	for (int i = 0; i < (sizeof(arr) / sizeof(arr[0])); i++)
	{
		//依次打印各元素在内存中的地址
		printf("&arr[%d]=%p\n", i, &arr[i]);
	}
	return 0;
}

运行上面代码后，可以看到数组各元素地址，可以观察到，每个元素地址相隔4个字节，而数组元素为int型，刚好是4个字节，这也说明了数组是连续存放的
如果感觉不够直观，还可以按照以下步骤找到内存，根据元素地址（可以在地址栏直接输入数组名arr）可以找到内存中的东西，刚好是数组元素对应内容

• 结论：数组在内存中是连续存放的，并且随着数组下标的增长，元素的地址也有规律的递增
  

二、二维数组的创建和初始化

2.1 二维数组的创建

• 二维数组：一维数组只能存储一组元素，但是如果想存多组数据，一维数组就不能解决了，所以引入二维数组，可以存储多组数据

二维数组有行有列，行列下标都是从0开始 ，在了解二维数组在内存中的存储之前，可以把二维数组的形态先假象的理解为一个矩阵的形态，如arr[3][4]为3行4列的数组，其中一行对应一组数据
二维数组的创建与一维数组类似，如下

//数组创建
int arr[3][4];
char arr1[3][5];

2.2 二维数组的初始化

• 二维数组的初始化和一维数组大同小异，具体方法见下代码
• 需注意，因为二维数组有行列之分，其中行可以省略，列不能省（原因见2.4）

	//一个大括号内容代表一行数据，4个大括号就是4行，一个大括号里面有几个元素就是几列
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
	//方法2，该初始化方法的特点是一行放满再放下一行，当元素未被完全初始化时，不足的地方补0
	int arr1[4][5] = { 1,2,3,4,5,6,7,8 }; //1到5为一行，6，7，8，0，0为第二行内容，其余行全为0
	//二维数组，如果初始化，行可以省略，但列不能省略
	int arr2[][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };

打开监视界面可以看到初始化后的内容

2.3 二维数组的使用

• 二维数组也是通过下标去访问，其行列下标也都是从0开始，如下图，想访问第二行第二列的元素，对应数组下标为[1][1]，故arr[1][1]=6
  
  知道以上访问方法，我们可以用循环的方式依次打印整个二维数组

//二维数组的初始化
int main()
{
	int arr[4][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7},{4,5,6,7,8} };
	for (int i = 0; i < 4; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
	return 0;
}

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

• 这里我们依次打印每个元素的地址，通过地址来分析其在内存中的结构

//打印二维数组中元素地址
int main()
{
	int arr[3][4] = { 0 };
	for (int i = 0; i < 3;i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("&arr[%d][%d]=%p\n", i, j, & arr[i][j]);
		}
	}
	return 0;
}

• 运行后我们可以发现，二维数组的存储内部也是从低地址向高地址存储，并且每个元素相隔4B，也就是一个元素的大小，所以是依次连续存储，并且我们发现，行与行直接也是连续的，所以，二维数组在内存中是一行一行存储的，真实的结构应该如下图所示
  
• 由于二维数组也是连续存放的，所以我们可以不知道有几行，但是必须得知道有几列，因为这样下一行存放的位置我才能知道，这也就是为什么二维数组初始化时行可以省略但列不可以省的原因

三、数组越界

数组的下标是有范围限制的
n个元素的数组下标范围为0~n-1，如果使用数组时下标超过这个范围，就是越界访问了
C语言本身不做越界访问检查，编译器不一定抱错，但不报错不代表程序正确，这一点需要注意

//数组越界访问
int main()
{
	int arr[3] = { 1,2,3 };
	//这里i的范围可以取到3，而下标最大为2，所以是越界访问
	for (int i = 0; i <= 3; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

• 这里第四个值就是数组越界访问所导致的
  

四、数组作为函数参数

• 我们写代码时，会将数组作为参数传入函数，比如：我要实现一个冒泡排序，则需要讲整形数组排序，在这之前，先来搞清楚数组名是什么

4.1 数组名是什么

• 数组名通常情况下就是数组的首元素地址
• 但是有两个例外：
• 1. sizeof(数组名)，数组名单独放在该函数内部时，这里的数组名表示整个数组，计算的是整个数组的大小
• 2. &数组名，这里的数组名表示整个数组，这里取出的是整个数组的地址

int main()
{
	int arr[5] = { 123,2,3,4,5 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr);
	printf("%d\n", *arr);//因为数组名为首元素地址，所以*数组名就是首元素的内容
	return 0;
}

通过地址可以观察到，&arr[0]，arr，&arr都是地址，下面讨论他们是否有不同之处

int main()
{
	int arr[5] = { 123,2,3,4,5 };
	printf("%p\n", arr);
	printf("%p\n\n", arr+1);
	printf("%p\n", &arr[0]);
	printf("%p\n\n", &arr[0]+1);
	printf("%p\n", &arr); //表示整个数组
	printf("%p\n", &arr+1);
	return 0;
}

注意：通过运行结果我们可以看出，&arr[0]与arr是完全等价的，但arr与&arr不同之处在于整个数组+1后，地址相当于跳过整个数组，而arr+1只是相当于跳过一个元素的地址，这就是为什么&arr被称为整个数组

4.2 冒泡排序的错误设计

#include <stdio.h>

void bubbleSort(int arr[]) {
    int i, j, temp;
    //错误之处出现在这里
    int n=sizeof(arr)/sizeof(arr[0]);
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j + 1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("原数组: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    bubbleSort(arr);
    printf("排序后数组: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
    return 0;
}

• 为什么在排序函数内部不能这样使用呢 int n=sizeof(arr)/sizeof(arr[0]);
• 因为排序函数接收的是一个地址，而sizeof要求内部是整个数组，所以不能这样使用，这一点的理解很重要
• 以下是正确冒泡排序代码

#include <stdio.h>
//需要额外将数组元素个数传入排序函数才可以
void bubbleSort(int arr[], int n) {
    int i, j, temp;
    for (i = 0; i < n - 1; i++) {
        for (j = 0; j < n - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                // 交换 arr[j] 和 arr[j + 1]
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

int main() {
    int arr[] = {64, 34, 25, 12, 22, 11, 90};
    int n = sizeof(arr) / sizeof(arr[0]);

    printf("原数组: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    bubbleSort(arr, n);

    printf("排序后数组: \n");
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    return 0;
}