C语言数组
数组的定义、初始化与访问
一、数组的基本概念
数组是多个同类型元素的连续存储区域，定义时需指定元素类型和个数，访问时通过下标区分每个元素。
二、数组的定义和初始化
1. 定义形式
int arr[5];//定义一个包含5个int类型元素的数组
int：元素类型（数组中所有元素类型必须一致）arr：数组名[5]：方括号内的数字表示数组的元素个数（存储区数量）
2.初始化规则
（1）初始化数据个数<=元素个数
未被显示赋值的元素会自动初始化为0
int arr[5] = {10,20,30,40,50};//全部元素赋值：10,20,30,40,50
int arr[5] = {0}; //第一个元素为0，其余自动为0:0,0,0,0,0
int arr[5] = {1}; //第一个元素为1，其余自动为0:1,0,0,0,0
int arr[5] = {1,3,5}; //前3个元素赋值，后2个自动为0:1,3,5,0,0
int arr[5] = {}; //所有元素自动初始化为0:0,0,0,0,0
（2）初始化数据个数>元素个数
编译器会忽略多余的初始化数据，并产生警告（不要使用，这是错误的写法）
int arr[5] = {1,2,3,4,5,6,7,8};//警告：初始化数据过多，实际只保留前5个
（3）省略数据个数
若初始化数据个数与元素个数一致，可省略[]中的数字，编译器会自动根据数据个数确定元素个数。
int arr[] = {1,2,3,4,5};//等价于 int arr[5] = {1,2,3,4,5};(元素个数为5)
三、数组元素的访问
1. 通过下标访问
数组下标从0开始，依次为0,1,2,…,n-1(n为元素个数)
printf("arr[0] = %d\n",arr[0]);//访问第1个元素
printf("arr[1] = %d\n",arr[1]);//访问第2个元素
printf("arr[2] = %d\n",arr[2]);//访问第3个元素
printf("arr[3] = %d\n",arr[3]);//访问第4个元素
printf("arr[4] = %d\n",arr[4]);//访问第5个元素
2. 数组元素的地址
数组元素在内存中连续存储，每个元素的地址按类型大小递增（int类型通常占4字节，地址间隔为4）
#include<stdio.h>
int main(void){
int arr[]={1,2,3,4,5};
for(int i = 0;i < 5;i++){
printf("&arr[%d] = %p\n",i,&arr[i]);
}
return 0;
}
输出结果：
&arr[0] = 0x7ffe01acae50
&arr[1] = 0x7ffe01acae54
&arr[2] = 0x7ffe01acae58
&arr[3] = 0x7ffe01acae5c
&arr[4] = 0x7ffe01acae60
可以看出地址间隔为4字节，也就是一个int类型
四、 注意事项：数组越界
数组下标范围是0~n-1，若访问arr[n]及以上下标，属于数组越界
越界访问不会编译报错，但会访问到非法内存，可能导致程序崩溃或数据错误（风险极高）
//错误示范：arr[5]超出下标范围(最大为arr[4])
//printf("arr[5] = %d\n",arr[5]);//有风险，禁止使用！
完整示例代码
#include<stdio.h>
int main(void){
// 数组：多个同类型的连续存储区
// 定义数组
int arr[]={1,2,3,4,5};// 初始化所有元素:1,2,3,4,5
// 通过下标访问数组元素（下标从0开始）
printf("arr[0] = %d\n", arr[0]);
printf("arr[1] = %d\n", arr[1]);
printf("arr[2] = %d\n", arr[2]);
printf("arr[3] = %d\n", arr[3]);
printf("arr[4] = %d\n", arr[4]);
// 输出每个元素的地址（验证连续性）
for(int i = 0; i < 5; i++){
printf("&arr[%d] = %p\n", i,&arr[i]);
}
// 数组越界有风险，禁止访问！
// printf("arr[5] = %d\n", arr[5]);
return 0;
}
输出结果：
arr[0] = 1
arr[1] = 2
arr[2] = 3
arr[3] = 4
arr[4] = 5
&arr[0] = 000000000062FE00
&arr[1] = 000000000062FE04
&arr[2] = 000000000062FE08
&arr[3] = 000000000062FE0C
&arr[4] = 000000000062FE10
数组和sizeof的关系
sizeof运算符可用于计算数组的总大小、单个元素大小及元素个数，是数组操作的常用工具
示例代码：
#include<stdio.h>
int main(void){
int arr[] = {1,2,3,4,5,6,7};
printf("%lu\n",sizeof(arr));// 28(数组总大小：7个int类型，int类型占4字节，总共28字节)
printf("%lu\n",sizeof(arr[4]));// 4(单个元素大小：int类型占4字节)
printf("%lu\n",sizeof(arr)/sizeof(arr[0]));// 7(元素个数：数组总大小÷单个元素大小)
printf("%ld\n",&arr[4] - &arr[1]);// 3(4-1=3个元素)
return 0;
}
输出结果：
28
4
7
3
变长数组
特点：数组长度在程序运行时确定，而非编译时
注意事项：
- 不能初始化（长度未知，无法预先赋值）
- 必须先通过输入确定长度，再声明变量
示例代码：
// 正确写法
int n;
scanf("%d",&n);//先确定长度n
int a[n]; //再声明变长数组
// 错误写法(顺序颠倒)
int n;
int a[n]; //错误：此时n未赋值，长度未知
scanf("%d",&n);
多维数组（一维、二维、三维）
多维数组的本质是“数组的数组”，可以通过“构成关系”理解：
1. 一维数组：int a[4]
4个整型构成的数组（直接存储int元素）
2. 二维数组：int a[3][4]
3个一维数组构成的数组（每个元素是int[4]类型的一维数组，每个一维数组含4个int）
3. 三维数组：int a[3][4][4]
3个二维数组构成的数组（每个元素都是int[4][4]类型的二维数组，每个二维数组含4个一维数组，每个一维数组含4个int）
二维数组初始化与sizeof
初始化方式：支持完整初始化、部分初始化或省略内层大括号（与一维数组初始化类似）
#include<stdio.h>
int main(void){
//定义一个二维数组并初始化
//int arr[3][4] = {{11,22,33,44},{22,33,44,55},{33,44,55,66}};//完整初始化
//int arr[3][4] = {{11,22,44},{22,33,44},{55,66}};//部分初始化
//int arr[3][4] = {11,22,44,22,33,44,55,66};//省略大括号初始化
int arr[3][4] = {0};
for(int i=0;i<3;i++){
for(int j=0;j<4;j++){
printf("%d ",arr[i][j]);
}
printf("\n");
}
printf("%lu\n",sizeof(arr));// 48 二维数组总大小
printf("%lu\n",sizeof(arr[0]));// 16 二维数组一个元素的大小,一个元素指的是一个一维数组
printf("%lu\n",sizeof(arr[0][0]));// 4 二维数组一个元素的大小,一个元素指的是一个整型
return 0;
}
//对于上面的例子：
//完整初始化的结果：
11 22 33 44
22 33 44 55
33 44 55 66
//部分初始化的结果：
11 22 44 0
22 33 44 0
55 66 0 0
//省略大括号初始化的结果：
11 22 44 22
33 44 55 66
0 0 0 0
注意！
二维数组省略大括号初始化时，编译器会按照“行优先”原则依次填充元素：从第一个一维数组（第一行）开始，逐个元素填充，填满一行后自动进入下一行，直到用完所有初始化数据；未被填充的元素自动初始化为0
以int arr[3][4]={11,22,44,22,33,44,55,66};为例，具体填充过程如下：
1. 确定二维数组结果：
int arr[3][4]表示有3行（3个一维数组），每行4个元素（共3×4=12个元素）
2. 按行优先顺序填充初始化数据：
初始化列表中的数据为{11,22,44,22,33,44,55,66}(共8个数据)，依次填充到每行：
- 第一行（arr[0]）：填充前4个数据→
11,22,44,22 - 第二行（arr[1]）：填充接下来的4个数据→
33,44,55,66 - 第三行（arr[2]）：初始化数据已用完，剩余元素自动填充→
0,0,0,0
3. 最终结果：
每行元素依次
11 22 44 22 (第一行)
33 44 55 66 (第二行)
0 0 0 0 (第三行，未填充的元素补0)