本文详细介绍了数组的创建和初始化，包括一维数组和二维数组的创建、初始化方法以及使用下标访问元素。同时，讨论了数组在内存中的存储方式，强调了数组越界问题和数组作为函数参数时的注意事项，特别是传参时数组名代表的是首元素地址。
目录
调试之后可以看到 bubble_sort 函数内部的 sz ，是1。
1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数
2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
一、一维数组的创建和初始化
1、数组的创建
数组是一组相同类型元素的集合。type_t arr_name [ const_n ];//type_t 是指数组的元素类型//const_n 是一个常量表达式，用来指定数组的大小
数组什么时候创建？注： 数组创建，在 C99 标准之前， [] 中要给一个 常量 才可以，不能使用变量。在 C99 标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。所以： 代码2是错误的例子
//代码1
int arr1[10];
//代码2 - 错误示范
int count = 10;
int arr2[count];//数组时候可以正常创建？
//代码3
char arr3[10];
float arr4[1];
double arr5[20];试了一下，此环境下不支持C99标准，可以从这个n下面的红波浪线看出来，报错了，这里的数组[]
里面只能是常量！！！！
2、 数组的初始化
数组的初始化是指：在创建数组的同时给数组的内容一些合理初始值（初始化）
初始化有完全初始化和不完全初始化
完全初始化：数组指定了明确的元素个数，且每个元素空间里都有元素
不完全初始化：数组指定了元素个数，但元素空间有剩余，没有占满整个数组空间，默认补0
int main()
{
//完全初始化
int arr1[10] = { 1,2,3,4,5,6,7,8,9,10 };
//不完全初始化，剩余的默认初始化为0
int arr2[10] = { 1,2,3,4,5 };//1 2 3 4 5 0 0 0 0 0
int arr3[10] = { 0 };// 0 0 0 0 0 0 0 0 0 0
//字符数组：可以放单个字符
char ch1[5] = { 'a','b',99 };//a b c 0 0 0
//可以放字符串
char ch2[10] = "abcdef";
//数组初始化，可以不知道数组元素大小，但必须有数组内容，数组的大小会根据数组内容来确定
char ch3[] = "abc";
char ch4[] = { 'a','b','c' };
printf("%s\n", ch3);//abc //遇到\0就结束了
printf("%s\n", ch4);//abc烫烫烫烫蘟bc //打印完abc之后随机打印，直到遇到\0
return 0;
}
3.一维数组的使用
数组通过下标来访问
对于数组使用操作符： [] ，下标引用操作符。它其实就数组访问的操作符
总结:
1. 数组是使用下标来访问的，下标是从0开始。
2. 数组的大小可以通过计算得到。
int arr [ 10 ];int sz = sizeof ( arr ) / sizeof ( arr [ 0 ]);
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
// 0 1 2 3 4 5 6 7 8 9
printf("%d\n", arr[9]);//打印下标为9的元素10
//打印数组
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < 10; i++)
{
printf("%d ", arr[i]);
}
int a = 10;
printf("%d\n", sizeof(arr));//40
printf("%d\n", sizeof(int[10]));
printf("%d\n", sizeof(a));
printf("%d\n", sizeof(int));
return 0;
}
4、一维数组在内存中的存储
仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。由此可以得出结论： 数组在内存中是连续存放的。
int main()
{
int arr[10] = { 0 };
int i = 0;
int sz = sizeof(arr) / sizeof(arr[0]);
for (i = 0; i < 10; i++)
{
printf("&arr[%d]=%p\n", i,&arr[i]);
}
return 0;
}
可以看出来：地址是用16进制表示的。0~9和a~f（0~15）
整型数组，首元素地址C0结尾，因为整型占4字节，+4之后就是下一个元素的首元素地址C4，依次类推第三个元素首元素地址为C8..
二、 二维数组的创建和初始化
1.二维数组的创建
//数组创建
int arr[3][4];
char arr[3][5];
double arr[2][4];2.二维数组的初始化
二维数组的初始化：行可以省略，列不能省略
//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略
3.二维数组的使用
二维数组的使用也是通过下标的方式。
int main()
{
//3行4列
//int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
//int arr1[3][4] = { {1,2},{3,4},{5,6} };
//char arr2[5][6];//5行6列
//二维数组的初始化：行可以省略，列不能省略
//int arr1[][4] = { {1,2},{3,4},{5,6} };
int arr1[3][4] = { 1,2,3,4,5,6,7,8,9,10,11,12 };
//printf("%d\n", arr1[1][2]);//7
//打印二维数组
int i = 0;
for (i = 0; i < 3; i++)
{
int j = 0;
for (j = 0; j < 4; j++)
{
printf("%-2d ", arr1[i][j]);
}
printf("\n");
}
return 0;
}
4、二维数组在内存中的存储
二维数组看似多行多列，实际上 是连续存储的， 本质上还是个一维数组
如果把二维数组的每一行看作一个一维数组，那么每一行的一维数组
也有数组名，arr[0]就是第一行的数组名，arr[1]就是第二行的数组名，以此类推
int main()
{
int arr[3][4] = { 0 };
int i = 0;
int j = 0;
for (i = 0; i < 3; i++)
{
for (j = 0; j < 4; j++)
{
printf("&arr[%d][%d] = %p\n", i, j, &arr[i][j]);
}
}
return 0;
}
三、 数组越界
数组的下标是有范围限制的。
数组的下规定是从 0 开始的，如果数组有 n 个元素，最后一个元素的下标就是 n-1 。所以数组的下标如果小于 0 ，或者大于 n-1 ，就是 数组越界访问了，超出了数组合法空间的访问。一维数组、二维数组都可能存在越界。C 语言本身是不做数组下标的越界检查， 编译器也不一定报错 ，但是编译器不报错，并不意味着程序就 是正确的， 所以程序员 写代码时，最好自己做越界的检查
int main()
{
int arr[10] = { 0 };
int i = 0;
for (i = 0; i <= 10; i++)//越界了
{
printf("%d ", arr[i]);//能运行代码，但在这里arr[i]能看到警告
}
return 0;
}
可以发现：访问数组内部下标0~9的元素时，都正常打印 0，但是越界打印下标为10的元素，是一个随机值，同时在没有运行的时候，编译器也提示了，在arr[i]下面提示绿色波浪线；
四、数组作为函数参数
往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序（这里要讲算法 思想）写函数 将一个整形数组排序。在不了解传参真正传递的是什么时候，很容易出现的问题：
错误设计（冒泡排序）：
错误原因：误以为传递的参数时整个数组，其实时数组首元素地址
导致了在函数中，计算数组大小时 ，int sz = sizeof(arr)/sizeof(arr[0]);//传参出现问题，sz=1
其实是首元素大小/首元素大小=1。
正确做法：在主函数计算完，再一起传参给函数
//方法1：
#include <stdio.h>
void bubble_sort(int arr[])
{
int sz = sizeof(arr)/sizeof(arr[0]);//传参出现问题，sz=1 这样对吗？
int i = 0;
for(i=0; i<sz-1; i++)
{
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;
}发现并没有按照我们预期的排序
引出了一个问题：
调试之后可以看到 bubble_sort 函数内部的 sz ，是1。
难道数组作为函数参数的时候，不是把整个数组的传递过去？
数组传参规则：
1. sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数
组。
2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
除此 1,2 两种情况之外，所有的数组名都表示数组首元素的地址。
1、数组传参传递的是：首元素地址
可以发现：当我们打印数组的地址时，和打印数组第一个元素时，是同一个地址，也就说明了arr的地址就是首元素地址，同时我们对arr地址解引用，得到了第一个元素的值1，更能确信的确是这样
2、数组有时候也代表整个数组
正确设计 - 冒泡排序
正确使用数组传参，完成冒泡排序：先在主函数求出整个数组的大小，传参时再传递数组首元素地址和数组大小
void bubble_sort(int arr[], int sz)//参数接收：数组arr首元素地址，数组元素个数
{
//代码同上面函数
}
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;
}现在运行，正常排序了
扫一扫
8373
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
