c语言数组笔记

数组的概念：

在c语言中，数组是用来存放相同类型数据的集合，跟javascript不同，javascript可以存放不同类型的数据，

数组的特点：

1.存放的数据类型必须是相同的

2.数组的元素为1个或多个，但是不能为0个

一维数组：

1. 一维数组的创建

   #include <stdio.h>
   int main()
   {
   
   要存放的数据类型 数组名[常量(也就是数组元素个数)];
   
   int arr[5];
   char arr2[20];
   double arr3[15];
   
   
   
   return 0;
   }

2. 一维数组的初始化:
   所谓的数组的初始化就是在创建数组的同时给他赋值，数组的初始化一般使用大花括号,将数据都存放在大花括号里。
   
   完全初始化：(数组的大小是多少，数组里就存放多少个元素)
   int arr[4]={1,2,3,4};
   
   不完全初始化：(剩余的元素没有初始化，他们的默认值为0)
   int arr[5]={1,2,3};
   
   错误初始化：(存放的数组元素个数与数组大小不匹配,明明只能放5个，你却放6个)
   int arr[5]={1,2,3,4,5,6};
   
   如果初始化了，可以省略数组的大小:(这时数组的大小就取决于数组元素个数)
   int arr[ ]={1,2,3,4};
3. 数组的类型
   数组也是有类型的，它属于自定义类型，它的类型主要取决于数组的大小，去掉数组名就是数组的类型

   int arr1[6]={1,2,3};
   int arr2[3]={1};
   char arr3[9];
   数组arr1的类型是int [6]
   数组arr2的类型是int [3]
   数组arr3的类型是char [9]

4. 数组的下标
   数组的下标是从0开始的，也就是说第一个元素的下标为0，以此类推；因此得出一条规律，数组最后1个元素的下标一定小于数组元素个数，假设共有n个元素，那么最后1个元素的下标=数组元素个数-1
5. 下标引用操作符[ ]:
   数组元素初始化用大花括号，引用下标用方括号，
    
6. 访问数组中的元素：
   数组名+[下标]
    

   int arr[3]={1,2,3};    //创建一个数据类型为int,数组元素个数为3的数组
   printf("%d\n",arr[0]);  //打印下标为0，也就是第1个数组元素

7. 利用for循环和下标引用操作符打印数组的元素:(遍历数组法)

   #include <stdio.h>
   int main()
   {
   
   /*
   1.先创建一个数组
   
   2.创建下标变量,int i=0，因为最终我们要完成的任务是将数组里的6个元素打印出来，
   而访问数组元素是通过数组名+下标引用操作符的方式来实现的，也就是arr[0]-arr[5],
   这个下标是不断变化的，所以我们需要为不断变化的下标定义一个变量
   
   3.进入for循环，i的初始值为0，代表从从下标为0，也就是第一个数组元素开始打印，i一定小于数组元素总个数，因为最后1个数组元素的下标一定小于数组元素总个数，然后开始执行循环体里的句子，也就是打印数组元素,每一轮for循环结束后,i自增。
   
   */
   
   int arr[6]={1,2,3,4,5,6};
   int i=0;
   for(i=0;i<6;i++)
   {
   printf("%d ",arr[i]);
   
   }
   
   return 0;}

8. 利用for循环解决数组的输入：

   int arr[8];
   int input=0;
   int i=0;
   
   for(i=0;i<8;i++)
   {
   scanf("%d",&arr[i]);
   }
   
   for(i=0;i<8;i++)
   {
   
   printf("%d ",arr[i]);
   
   }
   
   

   
    
9. 注意事项:
   1.在定义数组大小时，只能用常量，不能用变量，但是访问数组元素也就是数组的下标可以用变量。

   int i=10;
   int arr[i];
   //这样写就是错误的

10. 数组在内存中的存储：
    数组在内存中的存储是连续的，而且随着下标的变化，地址是由低到高

    打印数组的地址
    int main()
    {
    
    int arr[3]={1,2,3};
    int i=0;
    int r=sizeof arr/sizeof(int);
    for(i=0;i<r;i++)
    {
    printf("arr的地址是：%p\n",&arr[i]);
    
    }
    
    return 0;
    }

11. sizeof关键字：
    sizeof在c语言中是一个关键字，它是用来计算类型或变量所占内存空间大小的，当然也可以计算数组的内存大小，单位是字节

    //计算int类型所占内存空间大小，输出结果为4，一个int类型的数据占4个字节
    printf("%d\n",sizeof(int));
    
    
    //计算变量b所占内存空间大小
    int b=10;
    printf("%d\n",sizeof(b));
    
    //计算数组所占内存空间大小,输出结果为12，一个int类型数组占4个字节，一共有3个
    int arr[3]={1,2,3};
    printf("%d\n",sizeof(arr));
    
    
    变量或数组名可以省略sizeof后面的括号，类型不可以省略括号

利用sizeof关键字计算数组元素个数：
举个例子，比如1个int类型的数据是占4个字节，当我们知道数组元素共占多少内存空间时，用总空间大小除以这个数组所存放的数据类型大小，就可以得到这个数组一共有多少个元素
第一种写法：
 

int main()
{

int arr[6]={1,2,3,4,5,6};
int r=sizeof arr;
int d=sizeof(int);
printf("%d\n",r/d);

return 0;}

第二种写法：
 

int main()
{

int arr[4]={1,2,3,4};
int r=sizeof arr/sizeof(arr[0]);
printf("%d\n",r);

return 0;
}

利用sizeof打印数组元素：
 

int arr[4]={1,2,3,4};
int i=0;
int r=sizeof arr/sizeof(arr[0]);
for(i=0;i<r;i++)
{

printf("%d ",arr[i]);


}

12.变长数组：
所谓的变长数组指的是数组的大小是可以使用变量的，在c99之前，数组的大小是用常量或常量表达式的，在c99之后，数组的 大小是可以使用变量的，但是在vs中，暂且不支持数组使用变量，在vscode中可以。
 

13.变长数组注意事项：
变长数组是不能初始化的，像下面的这种写法就是错误的
 

int n=10;
int arr[n]={1,2,3};

二维数组：

1. 二维数组的概念：
   把一维数组的元素作为数组的元素，就是二

    d

   维数组，如果把二维数组的元素作为数组元素就是三维数组元素，二维以上的数组作为数组的元素称为多维数组。
2. 二维数组的创建：
   数据类型  数组名[行标][列标];
   行标和列标都是常量，行标代表着一共有几组一维数组，列表代表每一个一维数组有多少个元素。
3. 二维数组的初始化：
   完全初始化：
   每一行都要放满，每一行完了是用逗号隔开的

   int arr[2][3]={1,2,3,4,5,6};
   第一行：1 2 3
   第二行：4 5 6

   
   不完全初始化：
   先放满一行，再放下一行

   int arr[2][3]={1,2,3,4,5};
   第一行：1 2 3
   第二行：4 5 0
   
   
   int arr[3][5]={1,2,3,4,5};
   第一行：1 2 3 4 5
   第二行：0 0 0 0 0
   第三行：0 0 0 0 0
   
   
   int arr[2][3]={0};
   第一行：0 0 0
   第二行：0 0 0

   
   
   错误初始化：
   同一维数组一样
   
   按照行初始化：
    

   因为每一行其实都是一个一维数组，所以每一行可以用大花括号引起来，用逗号将每一组隔开
   int main()
   {
   
   int arr[3][2]={{1,2},{3,4},{5,6}};
   
   return 0;
   }

   
   
   初始化时，省略行标，但是列标不能省略：

   int arr[][3]={1,2,3};
   //行数取决于花括号里的，一共有1行
   
   int arr[][5]={1,2,3};
   //一共有1行
   
   int arr2[][5]={1,2,3,4,5,6,7};
   //一共有2行
   
   int arr3[][5]={{1,2},{3,4},{5,6}};
   //一共有3行

   
    
4. 二维数组的下标:
   二维数组的行标和列标也都是从0开始的，最后1行的行标或最后一行的列标一定小于行数或列数。
5. 访问二维数组中的元素
   数组名[行标][列标];
6. 利用for循环遍历数组输出

   //首先创建二维数组
   int arr[2][3]={{1,2},{3,4,5}};
   
   //要输出的结果是printf("%d\n",arr[i][n]);
   
   //定义行标和列标，行标用i,列标用n;
   int i=0;
   int n=0;
   
   //用双层for循环实现，外层for循环控制行标i，内层for循环控制列标n
   for(i=0;i<2;i++)
   {
   
   for(n=0;n<3;n++)
   {
   printf("%d ",arr[i][n]);
   
   
   }
   printf("\n");
   
   }

7. 利用for循环遍历数组输入

   int arr[2][2];
   int i=0;
   int j=0;
   //输入
   for(i=0;i<2;i++)
   {
   
   for(j=0;j<2;j++)
   {
   scanf("%d",&arr[i][n]);
   
   }
   
   
   }
   
   
   //输出
   for(i=0;i<2;i++)
   {
   
   for(j=0;j<2;j++)
   {
   printf("%d ",arr[i][j]);
   
   }
   printf("\n");
   
   }

8. 二维数组在内存中的存储
   同一维数组一样，二维数组在内存中的存放也是连续的，即使是跨行
9. 扩展知识点
   二维数组的每一行的数组名是：数组名[行标]

   int arr[2][3]={1,2,3,4,5,6};
   第一行的数组名是arr[0];
   第二行的数组名是arr[1];