目录

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

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 };
	//不完全初始化，剩余的默认初始化为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.一维数组的使用  

数组通过下标来访问

对于数组使用操作符： [] ，下标引用操作符。它其实就数组访问的操作符

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;
}

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

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

//数组初始化
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;
}

现在运行，正常排序了