C语言之数组

目录

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

2. 一维数组的使用

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

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

5. 二维数组的使用

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

7. 数组越界

---

在开始前让我们先了解一下什么是数组：

数组 （Array）是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。

分类: 一维、二维（矩阵）、三维数组

---

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

type_t                 arr_name      [ const_n ]；

数组元素类型    数组名          数组大小

例如，我们可以这样写：

int arr1 [ 10 ];

char arr2[5];

那我们可不可以这样写呢？

int count = 10;

int arr2[count]；

需要注意的是： 数组创建，在 C99 标准之前， [] 中要给一个 常量 才可以，不能使用变量。在 C99标准支持了变长数组的概念，数组的大小可以使用变量指定，但是数组不能初始化。

那么又有疑问了，什么叫初始化？

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

例如：

int arr1[10]={1,2,3,4,5,6,7,8,9,10};   这种方式下，数组大小与初始化值的数量相同

int arr2[4]={1,2,3};                            这种方式下，数组大小为4，初始化值只有3个，那么多余的那一位默认补0

int arr3[]={1,2,3,4,5,6,7};                  这种方式下， 数组在创建的时候不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确 定。

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

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

记住：

初始化以后可以不指定数组大小。不完全初始化，剩余元素默认为0

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

同时要注意：‘\0’为数组结束的标志

char arr1 [] = "abc" ;                          输出结果为：abc

char arr2 [ 3 ] = { 'a' , 'b' , 'c' };                  输出结果为：abcttttttttt

数组arr1实际上在内存中的存储是‘a’ ‘b’ ‘c’ ‘\0’
数组arr2实际上在内存中的存储为 ‘a’ ‘b’ ‘c’
‘\0’为数组结束的标志，arr1的写法自带’\0’，因此输出结果就为abc；
arr2没有’\0’，编译器找不到结束标志便会出现随机值

2. 一维数组的使用

我们来看一个数组使用的例子

#include <stdio.h>

int main ()

{

int arr [ 10 ] = { 0 };                                // 数组的不完全初始化

int sz = sizeof ( arr ) / sizeof ( arr [ 0 ]);       // 计算数组的元素个数

：

int i = 0 ;            //做下标 ，  对数组内容赋值 , 数组是使用下标来访问的，下标从 0 开始

for ( i = 0 ; i < 10 ; i ++ )

arr [ i ] = i ;

}

for ( i = 0 ; i < 10 ; ++ i )

{

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

}

return 0 ;

}

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

2. 数组的大小可以通过计算得到。 int sz = sizeof(arr)/sizeof(arr[0]);

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

我们可以通过打印数组在内存中的地址来学习数组在内存中的储存

#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]);
 }
 return 0;
}

我们发现随着下标的增长，元素的地址也在有规律的递增

结论： 数组在内存中是连续存放的

当我们把  int  改为 char 有什么区别呢？

#include <stdio.h>
// 一维数组在内存中的存储
int main()
{
	char 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]);
	}
	return 0;
}

我们发现  int  类型下标增加1，内存增加4，char类型下标增加1，内存增加1

内存的存储也取决于数组类型

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

type_t                arr_name     [ ][ ]；

数组元素类型    数组名         行 列

int arr[3][4];       表示3行4列的整型数组

char arr[3][5];     表示3行5列的字符数组

double arr[2][4]   表示2行5列的双精度浮点型数组

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

二维数组行可以省略，列不可以

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

5. 二维数组的使用

练习：打印一个5行2列的二维数组

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

 练习：用二维数组打印杨辉三角

#include<stdio.h>
int main()
{
	int a = 0;//行
	int b = 0;//列
	int n = 0;
	int x[30][30];//二维数组
	scanf("%d", &n);
	for (a = 0; a < n; a++)
	{
		for (b = 0; b < n; b++)
		{
			if (b == 0 || a == b)
			{
				 x[a][b] = 1;
			}
			if (a >= 2 && b >= 1)
			{
				x[a][b] = x[a - 1][b - 1] + x[a - 1][b];
				//这个数等于上一行前一列与这一列数的和
			}
		}
	}
	for (a = 0; a < n; a++)
	{
		for (b = 0; b <= a; b++)
		{
			printf("%5d", x[a][b]);
		}
        printf("\n");
}
	return 0;
}

 

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

#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] = %p\n", i, j,&arr[i][j]);
 }
 }
 return 0;
}

 int 类型下标每增加1，内存增加4

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

7. 数组越界

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

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

与一维数组相同，不可以越界访问