初始C语言 - 数组（一维数组、二维数组、数组越界、数组传参）

目录

 

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

1、数组的创建

 2、 数组的初始化

3.一维数组的使用  

数组通过下标来访问

总结:

1. 数组是使用下标来访问的，下标是从0开始。

2. 数组的大小可以通过计算得到。

 4、一维数组在内存中的存储

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

1.二维数组的创建

2.二维数组的初始化

二维数组的初始化：行可以省略，列不能省略

 3.二维数组的使用

二维数组的使用也是通过下标的方式。

 4、二维数组在内存中的存储

三、 数组越界

数组的下标是有范围限制的。

四、数组作为函数参数

错误设计（冒泡排序）：

错误原因：误以为传递的参数时整个数组，其实时数组首元素地址

引出了一个问题：

调试之后可以看到 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 };//不完全初始化，剩余的默认初始化为0int 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之后随机打印，直到遇到\0return 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 9printf("%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));//40printf("%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;
}

现在运行，正常排序了