数组——“C”

各位CSDN的uu们你们好呀，今天是个特别的日子，小雅兰开学了，但是开学并不意味着我就不更新文章了，哈哈哈。言归正传，小雅兰今天的内容是数组，数组当中的小知识点特别多，也算是C语言中比较重要的部分了，现在，就让我们一起进入数组的世界吧

怎样定义一维数组

一维数组的初始化

一维数组的使用

一维数组在内存中的存储

怎样定义二维数组

二维数组的初始化

二维数组的使用

二维数组在内存中的存储

数组越界

数组的应用实例

之前我们学习的内容，使用的变量都属于基本类型，例如整型、字符型、浮点型数据，这些都是简单的数据类型。

对于有些数据，只用简单的数据类型是不够的，难以反映出数据的特点，也难以有效地进行处理。

下面，我们就引出了数组的概念：

数组是一组有序数据的集合。数组中各数据的排列是有一定规律的，下标代表数据在数组中的序号。

用一个数组名和下标唯一确定数组中的元素

数组中的每一个元素都属于同一个数据类型

怎样定义一维数组

定义一维数组的一般形式为：

        类型符  数组名  [常量表达式];

数组名的命名规则和变量名相同

         如  int a[10];

 其中，int表示每个元素的数据类型，a表示数组名，10表示数组长度

下面，我们来看看数组创建的实例

int arr[10];//合法
int arr[4+6];//合法

这两种数组创建的方式都是合法的

int count=10;
int arr2[count];
//这样的数组是否可以成功创建呢？

我们用编译器来运行看看：

然后我们会发现，编译器报了一堆错误，小雅兰使用的编译器是VS2022，我的VS2022不支持这样的写法

实际上，数组创建，在C99标准之前，数组的大小只能是常量来指定，例如int arr[10];

                               在C99标准中，引入一个变长数组的概念，变长数组允许数组的大小使用变量                                  来指定，但是数组不能初始化

很显然，在我的VS2022，这样的数组创建是不可以的

char arr3[10];
float arr4[1];
double arr5[20];
//这样的数组创建的方式都是非常ok的

一维数组的初始化

数组的初始化是指：在创建数组的同时给数组的内容一些合理初始值。

int arr[10]={0,1,2,3,4,5,6,7,8,9,10};

int arr[10]={1,2,3};——不完全初始化，剩余的默认初始化为0——相当于

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

int arr[10]={1,2,3,4,5,6,7,8,9,10};——可写为

int arr[]={1,2,3,4,5,6,7,8,9,10};——这样的数组称为完全初始化

数组在创建的时候如果想不指定数组的确定的大小就得初始化，数组的元素个数根据初始化的内容来确定。

char arr[3]={'a',98,'c'};——98是'b'的ASCII码值——相当于

char arr[3]={'a','b','c'};

但是，对于下面的代码：

char arr[]="abc";——内存中表示a b c \0

char arr[3]={'a','b','c'};——内存中就表示a b c

一维数组的使用

对于数组的使用我们之前介绍了一个操作符： [] ，下标引用操作符。它其实就是数组访问的操作符。

下面，我们来看一小段代码

#include<stdio.h>
int main()
{
   int arr[10]={0};//数组的不完全初始化
   //计算数组的元素个数
   int sz=sizeof(arr)/sizeof(arr[0]);
   //这个sizeof(arr)计算的是数组的总大小
   //对数组内容赋值，数组是使用下标来访问的，下标从0开始
   int i=0;
   for(i=0;i<10;i++)
   {
      arr[i]=i;
   }
   //输出数组的内容
   for(i=0;i<10;i++)
   {
      printf("%d ",arr[i]);
   }
   return 0;
}

其实，在这段代码中，我们计算数组中总元素的大小有两种写法：

printf("%d\n",sizeof(arr));//计算结果为40

printf("%d\n",sizeof(int [10]));//这样的写法也是可以的，计算结果仍然为40

下面，我们再来举个例子：

int a=10;

printf("%d\n",sizeof(a));//计算结果为4

printf("%d\n",sizeof(int));//这样的写法仍然是可以的，计算结果还是4

我们来复习一下之前学过的一个小知识点

#include<stdio.h>
int main()
{
    printf("%d\n", sizeof(int));//4个字节
  printf("%d\n", sizeof(char));//1个字节
  printf("%d\n", sizeof(short));//2个字节
  printf("%d\n", sizeof(long));//4个字节
  printf("%d\n", sizeof(long long));//8个字节
  printf("%d\n", sizeof(float));//4个字节
  printf("%d\n", sizeof(double));//8个字节
  printf("%d\n", sizeof(long double));//8个字节
    return 0;
}

总结:

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

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

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

下面，我们来看一个题目：

例：对10个数组元素依次赋值为0，1，2，3，4，5，6，7，8，9，要求按逆序输出。

 解题思路：

• 定义一个长度为10的数组，数组定义为整型
• 要赋的值是从0到9，可以用循环来赋值
• 用循环按下标从大到小输出这10个元素

#include<stdio.h>
int main()
{
   int i=0;
   int arr[10]={0};
   for(i=0;i<10;i++)
   {
      arr[i]=i;
   }
   for(i=9;i>=0;i--)
   {
      printf("%d ",arr[i]);
   }
   printf("\n");
   return 0;
}

一维数组在内存中的存储

话不多说，直接上代码：

#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",&arr[i]);
   }
   return 0;
}

下面来看看输出结果

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。（由低到高变化）

由此可以得出结论：数组在内存中是连续存放的。

我们需要看得更清楚一点

#include<stdio.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  int* p = &arr[0];
  for (i = 0; i < sz; i++)
  {
    printf("%p==%p\n", p + i, &arr[i]);
  }
  return 0;
}

我们会发现p+i的地址和&arr[i]的地址完全一样

#include<stdi.h>
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int i = 0;
  int sz = sizeof(arr) / sizeof(arr[0]);
  int* p = &arr[0];
  for (i = 0; i < sz; i++)
  {
    printf("%d ", *(p + i));
  }
  return 0;
}

怎样定义二维数组

二维数组定义的一般形式为

类型符 数组名 [常量表达式][常量表达式];

 如：float a[3][4],b[5][10];

二维数组可被看作是一种特殊的一维数组；

 它的元素又是一个一维数组；

例如：把a看作是一个一维数组，它有3个元素：a[0],a[1],a[2]

每个元素又是一个包含4个元素的一维数组

二维数组的初始化

int arr[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};——相当于

int arr[3][4]={1,2,3,4,5,6,7,8,9,10};

int arr[3][4]={{1},{5},{9}};——相当于

int arr[3][4]={{1,0,0,0},{5,0,0,0},{9,0,0,0}};

int arr[3][4]={{1},{5,6}};——相当于

int arr[3][4]={{1},{5,6},{0}};

int arr[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};——相当于

int arr[][4]={1,2,3,4,5,6,7,8,9,10,11,12};

二维数组如果有初始化，行可以省略，列不可以省略

int arr[][4]={{0,0,3},{},{0,10}};——这样的写法是合法的

二维数组的使用

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

直接看代码吧

#include<stdio.h>
int main()
{
   int arr[3][4]={0};
   int i=0;
   for(i=0;i<3;i++)
   {
      int j=0;
      for(j=0;j<4;j++)
      {
         arr[i][j]=i*4+j;
      }
   }
   for(i=0;i<3;i++)
   {
      int j=0;
      for(j=0;j<4;j++)
      {
         printf("%d ",arr[i][j]);
      }
   }
   return 0;
}

二维数组在内存中的存储

像一维数组一样，这里我们尝试打印二维数组的每个元素。

#include<stdio.h>
int main()
{
   int arr[3][4]={0};
   int i=0;
   for(i=0;i<3;i++)
   {
      int j=0;
      for(j=0;j<4;j++)
      {
         printf("&arr[%d][%d]=%p\n",i,j,&arr[i][j]);
      }
   }
   return 0;
}

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

如果把二维数组的每一行看做一个一维数组，那么每一行的一维数组也有数组名

arr[0]就是第一行的数组名

arr[1]就是第二行的数组名

以此类推

数组越界

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

数组的下规定是从0开始的，如果数组有n个元素，最后一个元素的下标就是n-1。

所以数组的下标如果小于0，或者大于n-1，就是数组越界访问了，超出了数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就 是正确的， 所以程序员写代码时，最好自己做越界的检查。

#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\n",arr[i]);
      //当i等于10的时候，越界访问了
   }
   return 0;
}

这个程序虽然跑起来了，并且有输出结果，但是我们发现，最后的结果不是我们想要看到的，那么，这个就是数组的越界访问

所以，二维数组的行和列也可能存在越界。

数组的应用实例1：三子棋  这个内容我之前写过了的 三子棋——“C”_认真学习的小雅兰.的博客-CSDN博客

数组的应用实例2：扫雷 这个内容我之前也写过 扫雷——“C”_认真学习的小雅兰.的博客-CSDN博客

接下来的这个知识点呢，是为数组作为函数参数，小雅兰想把这个内容在下一篇博客中专门讲一下，因为，我们需要讲到一种算法——冒泡排序。

好啦，小雅兰今天的内容就到这里啦，今天也是努力的小菜兰呀！！！