【C语言】数组知识点总结

【C语言】数组知识点总结

标签： 数组
2018年04月12日 17:44:4481人阅读 评论(0) 收藏 举报
 分类：

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_41035588/article/details/79915673

 

目录(?)[+]

 

致读者：

在程序设计中，为了处理方便，把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。在C语言中，数组属于构造数据类型。

数组：一组有序数据集合，且其中的元素都属于同一数据类型（type_t arr_name [const_n];)，利用数组名和下表来唯一确定数组中的元素。

1.数组的创建和初始化

创建数组方式：

一维数组：

[cpp] view plain copy
 
  1.   
[cpp] view plain copy
 
  1. type_t  arr_name [const_n];    
  2. //type_t  是数组元素的类型    
  3. //arr_name  是数组名    
  4. //const_n 是数组元素的个数，用来指定数组的大小，即整形表达式。  
  5. int arr[10] = {0};//创建一个一维整型数组，包括十个数组元素。  

二维数组：

[cpp] view plain copy
 
  1. type_t  arr_name [const_n][const_n];    
  2. //type_t  是数组元素的类型    
  3. //arr_name  是数组名    
  4. //const_n 是数组元素的个数，用来指定数组的大小，即整形表达式。  
  5. int arr[3][4] = {0};//创建一个二维整型数组，包括十个数组元素。  

初始化数组方式：

普通方式：

[cpp] view plain copy
 
  1. int arr[10] = {0,1,2,3,4,5,6,7,8,9};  
  2.   
  3. int arr[3][4] = {1,2,3,4,5,6,7,8,9,10,11,12};  

函数方式<一维数组>：

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2. void initarr(int arr[], int sz)     
  3. {    
  4.     int i = 0;    
  5.     for (i=0; i<10; i++)    
  6.     {    
  7.         arr[i] = i;  //给数组初始化为i   
  8.     }    
  9. }    
  10.     
  11. void printarr(int arr[], int sz)     
  12. {    
  13.     int i = 0;    
  14.     for (i=0; i<10; i++)    
  15.     {    
  16.         printf("%d ", arr[i]);//打印数组    
  17.     }    
  18. }    
  19. int main()    
  20. {    
  21.     int arr[10] = {0}; //创建整型数组arr，元素为10个    
  22.     initarr(arr, 10); //数组初始化函数    
  23.     printarr(arr, 10);//打印数组函数    
  24.     return 0;    
  25. }    

结果所示：

二维数组函数初始化方法同一维数组函数初始化。

2.数组的引用

数组的使用是通过数组元素的下标来对数组元素进行调用。

一维数组引用代码如下：

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2. int main()    
  3. {    
  4.     int arr[10] = {0};    
  5.     int i = 0;    
  6.     for (i = 0; i < 10; i++)    
  7.     {    
  8.         arr[i] = i;    
  9.     }    
  10.     for (i = 9; i >= 0; i--)    
  11.     {    
  12.         printf("%d ", arr[i]);    
  13.     }    
  14.     return 0;    
  15. }    

结果所示：

二维数组使用也是通过元素下标的方式，代码如下：

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2.     
  3. int main()    
  4. {    
  5.     int arr[3][4] = {0};    
  6.     int i = 0;    
  7.     int j = 0;    
  8.     for (i = 0; i < 3; i++)    
  9.     {    
  10.         for (j = 0; j < 4; j++)    
  11.         {    
  12.             arr[i][j] = i * 4 + j + 1;    
  13.         }    
  14.     }    
  15.     for (i = 0; i < 3; i++)    
  16.     {    
  17.         for (j = 0; j < 4; j++)    
  18.         {    
  19.             printf("%d ",arr[i][j]);    
  20.         }    
  21.     }    
  22.     return 0;    
  23. }    

结果所示：

3.数组在内存当中的存储：

一维数组：

[cpp] view plain copy
 
  1. #include<stdio.h>    
  2. int main()    
  3. {    
  4.   int arr[10] = { 0 };    
  5.   int i = 0;    
  6.   for (i = 0; i < 10; i++)    
  7.   {    
  8.     arr[i] = i;  }  
  9.     for (i = 0; i < 10; i++)    
  10.     {    
  11.     printf("&arr[%d] = %p ", i, &arr[i]);//打印数组每个元素的地址    
  12.     }  
  13.     return 0;    
  14. }    

结果所示： 

  

   

二维数组：

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2. int main()    
  3. {    
  4.     int arr[3][4] = {0};    
  5.     int i = 0;    
  6.     int j = 0;    
  7.     for (i = 0; i < 3; i++)    
  8.     {    
  9.         for (j = 0; j < 4; j++)    
  10.         {    
  11.             arr[i][j] = i * 4 + j + 1;    
  12.             printf("&arr[%d][%d]=%p  ", i, j, &arr[i][j]);    
  13.         }    
  14.     }    
  15.     return 0;    

结果所示：

综上分析：

无论是一维还是二维数组，都是随着数组元素下标的增加，数组元素在内存当中的地址也是递增的。
再看其在内存中的存储方向，都是由低地址到高地址。
由此，我们可推断出，数组元素在内存当中的存储是连续的，其存储方向为由低地址指向高地址。

4.数组的指针访问

一维数组的指针访问，创建代码如下：

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2.     
  3. int main()    
  4. {    
  5.     int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };    
  6.     printf("%p ", arr);    
  7.     printf("%d ", *arr);    
  8.     return 0;    
  9. }    

结果所示：

综上：数组名所代表的是数组首元素的地址。

[cpp] view plain copy
 
  1. #include <stdio.h>    
  2. int main()    
  3. {    
  4.     int arr[] = { 1, 2 ,3 ,4 , 5 };    
  5.     printf("%d ", sizeof(arr));    
  6.     printf("%d ", sizeof(arr + 0));    
  7.     printf("%d ", sizeof(*arr));    
  8.     printf("%d ", sizeof(arr[1]));    
  9.     printf("%d ", sizeof(&arr));    
  10.     printf("%d ", sizeof(&arr+1));    
  11.     printf("%d ", sizeof(&arr[0]));    
  12.     printf("%d ", sizeof(&arr[0]+1));    
  13.     return 0;    
  14. }    

结果所示：

综上：

数组名所代表的是数组首元素的地址。
而数组名代替整个数组（即不作为指针常量）的时候只有两种情况：
1. sizeof（数组名）   2. &数组名
只有这两种情况下，数组名才代替整个数组。

二维数组指针访问同上。

5.数组作为函数参数

在面对大量数据的处理时，有时不仅仅是要创建数组，更要将数组作为函数的参数进行相应的运算。
参数等价：int arr[]  <==>int *arr;
[cpp] view plain copy
 
  1. #include <stdio.h>     
  2. int LenTh(int arr[])    
  3. {    
  4.     int sz = sizeof(arr) / sizeof(arr[0]);    
  5.     return sz;    
  6. }    
  7.     
  8. int main()    
  9. {    
  10.     int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };    
  11.     int ret = 0;    
  12.     ret =LenTh(arr);    
  13.     printf("%d ", ret);    
  14.     return 0;    
  15. }    

结果所示：

综上：

数组在作为函数参数传参时，传过去的是数组的首元素的地址，而不是整个数组。
而首元素地址为4个字节，地址也为四个字字节（32位仪器中），因此求出sz为1，其输出为1。
数组作为可以包含大量数据的集合，可以有效的处理大批量的数据，因此应用相当广泛。
【推广】 免费学中医，健康全家人
原文地址：https://www.cnblogs.com/sw520/p/8818481.html