初阶C语言--数组

偷图小番茄

已于 2024-07-22 18:50:53 修改

阅读量785

点赞数 34

文章标签： c语言开发语言

于 2024-07-22 18:49:04 首次发布

本文链接：https://blog.csdn.net/2203_75522143/article/details/140575905

版权

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

1.1 数组的创建

数组是一组相同类型元素的集合。

数组的创建方式：

type_t arr_name [const_n];

type_t：数组的元素类型

arr_name：数组名

[const_n]：是一个常量表达式，用来指定数组大小

数组的创建举例：

#include<stdio.h>
int main()
{
   int arr[5];
   char ch[10];
   double day[10 + 5];//这种表达方式也可以，属于常量表达式
   return 0;
}

注意：

#include<stdio.h>
int main()
{
	int n = 10;
	scanf("%d", &n);
	int arr2[n];
}

在C99标准之前，数组的大小必须是常量或常量表达式，在C99之后，数组的大小可以是变量，这是为了支持变长数组 （变长数组是指数组的长度通过变量来指定的）。

所以上述代码只能在支持C99的编译器上编译，并且这种数组不能进行初始化。

1.2 数组的初始化

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

int arr[10] = { 1,2,3 };//不完全初始化，剩余的元素默认为0

//1 2 3 0 0 0 0 0 0 0
   int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
注意：
   char ch1[10] = { 'a','b','c' };

//a b c 0 0 0 0 0 0 0
   char ch2[10] = "abc";

//a b c \0 0 0 0 0 0 0

上面两组数组里面存放内容会有一点不一样，因为字符串是以 '\0' 结尾的，但它们的打印结果是一样的

如果没有指定数组的大小会根据与初始化内容来确定大小。
举例：

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

//1 2 3

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

//a b c

char ch1[ ]="abc";

//a b c \0

1.3 一维数组的使用

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

通过例子来感受一下：

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);//求数组元素个数
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

总结：

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

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

1.4 一维数组在内存中的存储

#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	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;
}

%p是用来打印地址，这样我们可以清晰的看到每个元素的地址，打印结果如下：

左图为打印结果，右图为调试下的内存显示。

由图可知，地址的存放是十六进制，8+4=12,12在十六进制中表示为C，12+4=16，十六进制逢十六进一，也正好是下一个元素地址，随着数组的增长，元素的地址也有规律递增，每个元素差4，因为一个整形占4个字节，这也侧面说明了一维数组在内存中是连续存放的。

关于进制：

组成

二进制：0 1 逢二进一

八进制：0 1 2 3 4 5 6 7 逢八进一

十进制：0 1 2 3 4 5 6 7 8 9 逢十进一

十六进制：0 1 2 3 4 5 6 7 8 9 A B C D E F 逢十六进一

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

2.2 二维数组的创建

//数组创建

int arr[3][4]; 3行4列

int arr[3][3]; 3行3列

int arr[2][4]; 2行4列

2.2 二维数组的初始化

//数组初始化

int arr[3][4]={1,2,3,,4,2,3,4,5,3,4,5,6}; //完全初始化

int arr1[3][4]={1,2,3,4}; //不完全初始化，剩余位都补0

如果想指定数字在哪行（进行一个分组）：

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

打印效果为：1 2 0 0

3 4 0 0

5 6 0 0

注意：二维数组如果有初始化，行可以省略，列不能省略，行会根据初始化内容来推测。

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

打印效果为：1 2 3 4

2 3 0 0

2.3 二维数组的使用

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

#include<stdio.h>
int main()
{
	int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
	//int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	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] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
	//int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			scanf("%d", &arr[i][j]);//输入
		}
	}
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);//二维数组的基本访问
		}
	}
	return 0;
}

我们也可以把二维数组看作一维数组

2.4 二维数组在内存中的存储

我们还是通过代码来看：

#include<stdio.h>
int main()
{
	int arr[3][4] = { 1,2,3,4,2,3,4,5,3,4,5,6 };
	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;
}

打印结果为：

由此我们可以得出结论，二维数组在内存中也是连续存放的。

3. 数组越界

数组的下标是有范围限制的
数组的下标规定从0开始，如果数组有n个元素，最后一个元素下标为n-1
所以数组的下标小于0，或者大于n-1,就是数组越界访问，超出了数组合法空间的访问
C语言本身是不做数组下标的越界检查的，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的。最好自己做越界检查

int main()
{
   int arr[10] = { 1,2,3,4,5,6 };
   int i = 0;
   for (i = 0; i <= 10; i++)
   {
       printf("%d\n", arr[i]);//当i=10时数组就越界访问了
   }                                  //二维数组的行和列也可能存在越界
   return 0;
}

4. 数组作为函数参数

往往我们在写代码的时候，会将数组作为函数的参数，比如：我要实现一个冒泡排序（这里主要讲算法思想）函数。

冒泡排序的核心思想：两个相邻的元素进行比较

假如现在要比较6,5,4,3,2,1：

这就是一趟冒泡排序，可以让一个数据来到它最终应该出现的位置上。

n个元素，需要n-1趟冒泡排序。

4.1 冒泡排序的错误设计

假设我们要对int arr[ ]={0,1,2,3,4,5,6,7,8,9},进行降序

//错误的冒泡排序设计
#include<stdio.h>
void bubble_sort(int arr[])
{
	int i = 0;
	int sz= sizeof(arr) / sizeof(arr[0]);
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] < arr[j + 1])
			{
				//把相邻元素交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	bubble_sort(arr);
	//打印结果
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

我们运行后会发现，结果是0 1 2 3 4 5 6 7 8 9，这明显不对，为什么会产生这个结果呢？

图解：

所以这里我们会发现，排序还是原来的。这里的错误点在sz的计算上，不能在函数内部求元素个数。

正确代码：

#include<stdio.h>
void bubble_sort(int arr[],int sz)
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] < arr[j + 1])
			{
				//把相邻元素交换
				int tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;
			}
		}
	}
}
int main()
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	int i = 0;
	bubble_sort(arr,sz);
	//打印结果
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}