c语言_初识数组

  c语言中支持数组数据结构。它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。简单来说，数组是一组相同类型元素的集合。

一维数组的创建： [ 类型 ] [ 数组名 ] [ 数组大小 ]

int arr1[10];   //可以容纳 10个类型为 int 的数字

int count=10;
int arr2[count]; //这样创建是错误的，数组的大小必须是一个确定的常量

char   arr3[10];  //可以容纳 10个类型为 char 的字符
float  arr4[20];  //可以容纳 20个类型为 float 的数字
double arr5[30];  //可以容纳 30个类型为 double 的数字

在创建数组的同时，我们还可以对其进行初始化。如果我们不想指定数组的大小，就要对其进行初始化，数组的元素个数会根据初始化的内容来自动进行确定。大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

int  arr1[5]={1,2,3,4,5};
int  arr2[5]={1,2,3};
int  arr3[]={1,2,3,4};
char arr4[3]={'a','b','c'};
char arr5[]={'d','e'};
char arr6[]="abcd";

  需要注意的是arr5和arr6的定义区别，在这里我们借助sizeof关键字求一下两个数组的长度。

#include<stdio.h>

int main()
{
char arr5[]={'d','e'};
char arr6[]="abcd";
printf("%d\n",sizeof(arr5)/sizeof(arr5[0]));
printf("%d\n",sizeof(arr6)/sizeof(arr6[0]));
return 0;
}

  我们看到，arr6数组明明只有4个字符，长度为什么是5呢？这是因为我们以字符串对数组进行初始化或者赋值的时候，数组会在字符串的末尾多开辟一个空间来保存一个’\0’，用来表示字符的结束。

总结： 1. 数组是使用下标来访问的，下标是从0开始。2. 数组的大小可以通过计算得到。

  接下来我们看看一维数组在内存中是以何种方式存储的。

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

  通过打印数组各个元素的地址我们发现，数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

二维数组： 多维数组最简单的形式是二维数组。一个二维数组，在本质上，是一个一维数组的列表。创建一个 x 行 y 列的二维整型数组，形式如下：

[ 类型 ] [ 数组名 ] [ x ] [ y ]

int  arr1[2][3]; //逻辑上是定义一个两行三列,可以容纳 6 个类型为 int 的数字的二维数组
char arr2[3][4]; //逻辑上是定义一个三行四列,可以容纳 12 个类型为char 的字符的二维数组
double arr3[3][5];//逻辑上是定义一个三行五列,可以容纳 15 个类型为 double 的数字的二维数组

二维数组的初始化：

int arr1[3][4] = {1,2,3,4};
int arr2[3][4] = {{1,2},{4,5}};
int arr3[][4] = {{2,3},{4,5}};

  以上的代码到底初始化的是二维数组中的哪些元素呢，我们不妨打印一下二维数组来观察观察。为了方便观察，每4列的时候我们进行换行操作。

#include<stdio.h>
int main()
{
int arr1[3][4] = {1,2,3,4};
int arr2[3][4] = {{1,2},{4,5}};
int arr3[][4] = {{2,3},{4,5}};
//打印arr1数组
for(int i=0;i<3;i++)
{
for(int j=0;j<4;j++)
{
printf("%d ",arr1[i][j]);
}
printf("\n");
}
printf("-----------------------\n");

//打印arr2数组
for(int i=0;i<3;i++)
{
for(int j=0;j<4;j++)
{
printf("%d ",arr2[i][j]);
}
printf("\n");
}
printf("-----------------------\n");

//打印arr3数组
for(int i=0;i<2;i++)
{
for(int j=0;j<4;j++)
{
printf("%d ",arr3[i][j]);
}
printf("\n");
}
}

  显而易见，最外层的花括号{ }里面的花括号{ }每一个代表二维数组的一行，一行中按照从左到右来进行初始化，没进行初始化的默认为0。

  在内存中，二维数组真的是按照咱们认为的x行y列在进行存储吗？

  我们不妨打印一下一个二维数组各个元素的地址来进行观察。

#include <stdio.h>

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

  我们可以发现，二维数组在内存中也是连续来进行存储的！ 为了方便计算与思考，我们只是在逻辑上把二维数组看做x行y列。

数组名的含义：
我们先看如下代码：

#include<stdio.h>

int main()
{
int arr[5]={0};
printf("arr地址:%d\n",arr);
printf("arr[0]地址:%d\n",&arr[0]);
printf("*arr:%d",*arr);
printf("arr[0]:%d\n",arr[0]);
return 0;
}

数组名和首元素地址相同,内容也相同！

  数组名指向数组的起始地址，数组首元素也指向数组的起始地址，两者相同也算是正常。但是，所有的情况下数组名都是数组首元素的地址吗？

两个例外： 1. sizeof(数组名)，计算整个数组的大小，sizeof内部 单独 放一个数组名，数组名表示整个数组。2. &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。除此1,2两种情况之外，所有的数组名都表示数组首元素的地址。

我们可以用代码来进行验证：

#include<stdio.h>

int main()
{
int arr[5]={0};
printf("sizeof(arr):%d\n",sizeof(arr)); //sieof中单独使用,表示整个数组大小
printf("sizeof(arr+0):%d\n",sizeof(arr+0)); //虽然是 +0,但这样不算是单独使用
printf("&arr:%d\n",&arr);
printf("&arr+1:%d\n",&arr+1); //增加了整个数组的大小 (20),并没有只增加一个元素的大小
printf("arr[1]地址:%d\n",&arr[1]);
return 0;
}

sizeof中单独使用，&数组名，代表整个数组的大小。其他情况下，数组名都表示数组首元素的地址！

越努力，越幸福！