C语言之数组篇

唐唐思

已于 2024-02-25 13:19:58 修改

阅读量200

点赞数 6

分类专栏：初阶C语言文章标签： c语言开发语言

于 2023-08-02 13:58:44 首次发布

本文链接：https://blog.csdn.net/m0_74841364/article/details/132018165

版权

初阶C语言专栏收录该内容

14 篇文章 1 订阅

订阅专栏

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

一维数组的创建

//数组创建方式
type_t   arr_name   [const_n];

type_t 是指数组的元素类型；

arr_name是数组名；

const_n 是一个常量表达式，用来指定数组的大小；

数组创建，[]中要给到一个常量才可以，不能使用变量。

创建的时候三个要素缺一不可。

int arr1[10];
int arr1[3+2];
char arr2[3];
float arr3[10];
double arr4[4];

？?那下面这个数组可以正常创建吗

int n = 0;
scanf("%d", &n);
int arr[n];

C99之前的数组只能是常量指定大小

C99之后引用了变长数组的概念，数组的大小是可以使用变量指定的

//但是在VS2022 2019不支持C99的变长数组

变长数组是不能初始化的。

一维数组的初始化

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

int arr1[10] = {1,2,3};//不完全初始化
int arr2[] = {1,2,3,4};//根据初始化内容决定数组大小
int arr[2]={0};
int arr3[5] = {1，2，3，4，5}；//完全初始化
char arr4[3] = {'a',98, 'c'};//Ascll码
char arr5[] = {'a','b','c'};//没有\0
char arr6[] = "abcdef";//有\0
char arr1[] = "abc";
char arr2[3] = {'a','b','c'};

一维数组的使用

根据下标来访问
根据下标来修改数组
数组大小的计算

根据下标访问：

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

根据下标来修改数组：

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

数组元素大小的计算：

//数组中元素的个数的计算sizeof
#include<stdio.h>
int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("数组的空间大小：%d\n", sizeof(arr));
	printf("数组中1个元素的大小：%d\n", sizeof(arr[7]));
	printf("数组中有多少个元素：%d\n", sizeof(arr)/sizeof(arr[7]));
}
//数组中元素的计算字符串sizeof和strlen
#include<stdio.h>
#include<string.h>
int main()
{
	char arr[] = "a,b,c";
	printf("数组中元素的个数：%d\n", sizeof(arr) / sizeof(arr[0]));
	printf("数组中最右元素的下标：%d\n", sizeof(arr) / sizeof(arr[0]) - 2);
	//-2指的是下标从0开始和减去"\0"
	printf("数组中元素的个数：%d\n", strlen(arr));
	//strlen是不计算"\0"的，需要包含头文件#include<string.h>
	printf("数组中最右元素的下标：%d\n", strlen(arr) - 1);
	//所以只要-1就是指的是下标从0开始
	return 0;
}

sizeof------------------- sz=sizeof(arr)/sizeof(arr[0]);

strlen-------------------- sz=strlen(arr);

一维数组在内存中的存储

如果想要知道一维数组在内存中的存储，我们需要将所有数组元素的地址打印在屏幕上。

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

数组在内存中是连续存放的
随着下标的增长，地址是由低到高变化的

二维数组的创建

//数组创建方式
type_t   arr_name   [const_n][const_n];

type_t 指的是数组元素类型

arr_name 指的是数组名字

const_n 一个常量表达式，用来指定数组元素大小

第一个[ ]是指行

第二个[ ]是指列

在初始化时行可以省略，列不能省略。

int arr[3][4];
char arr[3][5];
double arr[2][4];

二维数组的初始化

//二维数组的初始化
#include<stdio.h>
int main()
{
	int arr1[3][4] = { 1,2,3,4 };//无{}小括号
	int arr2[3][4] = { {1,2},{4,5} };//不完全初始化
	int arr3[3][4] = { {1,2,3,4},{2,3,4,5},{3,4,5,6} };//完全初始化
	int arr4[][4] = { {2,3},{4,5} };//省略行根据初始化内容确定行位2，列不可以省略
	//对于二维数组，如果初始化，对于行数是可以省略，但是列不能省略
	//行数省略根据初始化内容来确定
}

对于二维数组，如果初始化了，对于行数是可以省略的，但是列不能省略。

二维数组的使用

根据下标来访问：

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

根据下标来修改数组：

#include<stdio.h>
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	int i = 0;
	int j = 0;
	for (i = 0; i <= 2; i++)//一行一行遍历
	{
		for (j = 0; j <= 4; j++)
		{
			arr[i][j] = 5 * i + j + 1;//用下标找到元素，用元素元素赋值修改
		}
	}

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

二维数组在内存中的存储

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

二维数组在内存也是连续存放的。

二维数组其实是一维数组的数组

例如：arr[i][j]可以看成arr[i]是数组名 [j]是数组大小。

数组越界

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

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

所以数组的下标处于<0||>n-1就是数组越界访问了，超出了数组合法空间的访问.

即便编译器不会报错，它有容忍性。那是属于内存的错误。

数组作为函数参数——冒泡排序

往往我们在写代码的时候，会将数组作为参数传给某个函数。

比如：我要实现一个冒泡排序函数将一个整形数组排序。将其倒序排列。

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

传统方式（无函数）

#include<stdio.h>
int main()
{
	int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序
	int i = 0;
	int j = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//趟数
	for (i = 0; i < sz-1; i++)
	{
		//每一趟的比较
		for (j = 0; j < sz-1-i; j++)
		{
			//比较交换
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;

			}
			
		}
	}
	for (j = 0; j <sz; j++)
	{
		printf("%d ", arr[j]);
	}
	return 0;
}

未修改前函数传参

//请问以下代码可以运行结果正确吗？❌❌❌
#include<stdio.h>
void bubble_sort(int arr[])
{
	int i = 0;
	int j = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		//每一趟的比较
		for (j = 0; j < sz - 1 - i; j++)
		{
			//比较交换
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;

			}

		}
	}
	for (j = 0; j < sz; j++)
	{
		printf("%d ", arr[j]);
	}
}

int main()
{
	int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序
	bubble_sort(arr);
	return 0;
}

为什么结果错误呢？

这里涉及到数组作为函数参数传参的知识了

数组名是什么？

数组名就是地址，通常来说：数组名就是数组首元素的地址。

例外：

sizeof(数组名)，这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节
&数组名，这里的数组名表示整个数组，取出的是整个数组的地址

除此之外，所有遇到的数组名都是数组首元素的地址

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

修改之后函数传参

#include<stdio.h>
void bubble_sort(int arr[],int sz)
//这样写也可以
//void bubble_sort(int* arr,int sz)
{
	int i = 0;
	int j = 0;
	
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		//每一趟的比较
		for (j = 0; j < sz - 1 - i; j++)
		{
			//比较交换
			if (arr[j] > arr[j + 1])
			{
				int tmp = 0;
				tmp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = tmp;

			}

		}
	}
	for (j = 0; j < sz; j++)
	{
		printf("%d ", arr[j]);
	}
}

int main()
{
	int arr[10] = { 10,9,8,7,6,5,4,3,2,1 };//降序
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);//arr这里不是特殊情况的两种，就是指首元素地址
	return 0;
}

void bubble_sort(int arr[],int sz)

void bubble_sort(int* arr,int sz)

以上两种写法均可，本质都是指正，第一种写法更容易学习和理解。

小游戏

我们学习完函数和数组的知识，我们将在接下来的博文里去实现到小游戏。🙂🙂🙂

汉诺塔
青蛙跳
三子棋
扫雷

✔✔✔✔✔✔感谢大家的阅读，有任何错误和不足欢迎指正！！！！

代码----------------------→【gitee：https://gitee.com/TSQXG】

联系----------------------→【邮箱：2784139418@qq.com】

唐唐思

关注

6
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
2
评论
C语言之数组篇

我们学习完函数和数组的知识，我们将在接下来的博文里去实现到小游戏。汉诺塔，青蛙跳，三子棋，扫雷。
复制链接

扫一扫

专栏目录

C语言之数组篇

一维数组的创建

一维数组的初始化

一维数组的使用

根据下标访问：

根据下标来修改数组：

数组元素大小的计算：

一维数组在内存中的存储

二维数组的创建

二维数组的初始化

二维数组的使用

根据下标来访问：

根据下标来修改数组：

二维数组在内存中的存储

数组越界

数组作为函数参数——冒泡排序

传统方式（无函数）

未修改前函数传参

修改之后函数传参

小游戏

“相关推荐”对你有帮助么？