C语言基础：006 C基础语法- 数组详解

1. 一维数组的创建和初始化

   1. 数组的创建

      1. 数组创建
         type_t   arr_name   [const_n];
         //type_t 是指数组的元素类型
         //const_n 是一个常量表达式
         1. 注：

            数组创建，在 C99 标准之前， [] 中要给一个常量 才可以，不能使用变量。在 C99 标准支持了变长数组的概念。
      2. code实例：数组创建

         #include <stdio.h>
         
         int main()
         {
         	//代码1
         	int arr1[10];   // 正确
         	//代码2
         	int count = 10;
         	int arr2[count]; // 错误：数组时候不可以正常创建，错误信息：表达式必须含有常量值
         	//代码3
         	char arr3[10];  // 正确
         	float arr4[1];  // 正确
         	double arr5[20]; // 正确
         }

   2. 数组的初始化

      1. 数组的初始化是指，在创建数组的同时给数组的内容一些合理初始值（初始化）。
      2. 数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确 定。
      3. code实例：数组的初始化

         #include <stdio.h>
         
         int main()
         {
         	int arr1[10] = { 1,2,3 };
         	int arr2[] = { 1,2,3,4 };
         	int arr3[5] = { 1,2,3,4,5 };
         	char arr4[3] = { 'a',98, 'c' };
         	char arr5[] = { 'a','b','c' };
         	char arr6[] = "abc";
         	char arr7[] = "abcdef";
         	printf("数组arr1元素个数 = %d, strlen(arr1) = %d\n", sizeof(arr1) / sizeof(arr1[0]), strlen(arr1)); // 数组arr1元素个数 = 10, strlen(arr1) = 1
         	printf("数组arr2元素个数) = %d, strlen(arr2) = %d\n", sizeof(arr2) / sizeof(arr2[0]), strlen(arr2));// 数组arr2元素个数 = 4, strlen(arr2) = 1
         	printf("数组arr3元素个数 = %d, strlen(arr3) = %d\n", sizeof(arr3) / sizeof(arr3[0]), strlen(arr3)); // 数组arr3元素个数 = 5, strlen(arr3) = 1
         	printf("数组arr4元素个数 = %d, strlen(arr4) = %d\n", sizeof(arr4) / sizeof(arr4[0]), strlen(arr4)); // 数组arr4元素个数 = 3, strlen(arr4) = 67
         	printf("数组arr5元素个数 = %d, strlen(arr5) = %d\n", sizeof(arr5) / sizeof(arr5[0]), strlen(arr5)); // 数组arr5元素个数 = 3, strlen(arr5) = 35
         	printf("数组arr6元素个数 = %d, strlen(arr6) = %d\n", sizeof(arr6) / sizeof(arr6[0]), strlen(arr6)); // 数组arr6元素个数 = 4, strlen(arr6) = 3
         	printf("数组arr7元素个数 = %d, strlen(arr7) = %d\n", sizeof(arr7) / sizeof(arr7[0]), strlen(arr7)); // 数组arr7元素个数 = 7, strlen(arr7) = 6
         }

   3. 一维数组的使用

      1. 对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就数组访问的操作符。
      2. 总结
         1. 数组是使用下标来访问的， 下标是从0开始 。

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

            code实例：求数组的大小

            int arr[10];
            int sz = sizeof(arr)/sizeof(arr[0]);

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

      1. 数组在内存中是连续存放的。随着数组下标的增长，元素的地址，也在有规律的递增。
      2. code示例：取出每一个元素在数组中的位置

         #include <stdio.h>
         int main()
         {
         	int arr[10] = { 0 };
         	int i = 0;
         	int sz = sizeof(arr) / sizeof(arr[0]); // 求数组的大小
         
         	for (i = 0; i < sz; ++i)
         	{
         		printf("&arr[%d] = %p\n", i, &arr[i]); // 打印每个元素在内存中的位置
         	}
         	/*
         	* &arr[0] = 000000D63E60F518
         	* &arr[1] = 000000D63E60F51C
         	* &arr[2] = 000000D63E60F520
         	* &arr[3] = 000000D63E60F524
         	* &arr[4] = 000000D63E60F528
         	* &arr[5] = 000000D63E60F52C
         	* &arr[6] = 000000D63E60F530
         	* &arr[7] = 000000D63E60F534
         	* &arr[8] = 000000D63E60F538
         	* &arr[9] = 000000D63E60F53C
         */
         	return 0;
         }

2. 二维数组的创建和初始化

   1. 二维数组的创建

   2. 二维数组的初始化

   3. 二维数组的使用

      1. code示例

         #include <stdio.h>
         int main()
         {
         	//1. 二维数组创建
         	int arr1[3][4];
         	char arr2[3][5];
         	double arr3[2][4];
         	//2. 二维数组初始化
         	int arr4[3][4] = { 1,2,3,4 };
         	for (int i = 0; i < 3; i++)
         	{
         		for (int j = 0; j < 4; j++)
         		{
         			// 3. 二维数组的使用: 通过下标的方式。
         			printf("arr4[%d][%d] = %d ",i, j, arr4[i][j]); // 1 2 3 4 0 0 0 0 0 0 0 0
         		}
         	}
         	int arr5[3][4] = { {1,2},{4,5} };
         	int arr6[][4] = { {2,3},{4,5} };//二维数组如果有初始化，行可以省略，列不能省略
         	return 0;
         }

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

      1. 二维数组在内存中也是连续存储的。

3. 数据越界

   1. 所以数组的下标如果小于 0 ，或者大于 n - 1，就是数组越界访问了，超出了数组合法空间的访问。 C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。
   2. code示例

      #include <stdio.h>
      int main()
      {
      	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
      	int i = 0;
      	for (i = 0; i <= 10; i++)
      	{
      		printf("%d ", arr[i]); // 1 2 3 4 5 6 7 8 9 10 -858993460
      		//当i等于10的时候，越界访问了
      	}
      	return 0;
      }

4. 数组作为函数的参数

   1. 冒泡排序

      1. code示例： 

         //方法1：
         #include <stdio.h>
         void bubble_sort(int arr[], int sz)
         {
         	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 };
         	printf("%p\n", arr);     // 输出数组首地址：00000073897FFB58
         	printf("%p\n", &arr[0]); // 输出数组第一个元素的地址：00000073897FFB58
         	printf("%d\n", *arr);    // 输出第一个元素：3
         	printf("%d\n", sizeof(arr)); // 40
         	printf("%d\n", sizeof(arr) / sizeof(arr[0])); // 10
         
         	int sz = sizeof(arr) / sizeof(arr[0]); // 数组的大小：10
         	bubble_sort(arr, sz);//是否可以正常排序？
         	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
         	{
         		printf("%d ", arr[i]);
         	}
         	return 0;
         }