数组知识点

最新推荐文章于 2023-05-13 14:43:29 发布

是小刘同学啦

最新推荐文章于 2023-05-13 14:43:29 发布

阅读量960

点赞数 4

分类专栏： C语言初阶笔记文章标签： c语言

本文链接：https://blog.csdn.net/m0_57388581/article/details/122756858

版权

笔记同时被 2 个专栏收录

52 篇文章 4 订阅

订阅专栏

C语言初阶

26 篇文章 1 订阅

订阅专栏

励志模块

你未来的路还很长别自卑别将就

一、一维数组的创建和初始化

1.1 数组的创建

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

数组的创建方式：

代码展示：

int arr[5];
char ch[5];
double arr1[10];

int arr[5]; char ch[5];这些都可以，但是不能用int aar[n]；因为[ ]内必须是常量表达式。

（C99标准之前是不支持变量的，只能是常量。 C99标准中增加了变长数组的概念，允许数组的大小出现变量，但是要求编译器必须支持C99标准）

1.2 数组的初始化

创建的同时给一些值叫初始化。

strlen是一个库函数，计算的是字符串的长度，并且只能针对字符串，关注的字符串是否有\0，计算的是\0之前的字符个数

sizeof是一个操作符（运算符）（就像加减乘除一样）是用来计算变量所占内存空间大小的，任何类型都是可以使用，只关注空间的大小，不在乎内存中是否存在\0

1.3 一维数组的使用

数组访问操作符[ ]

元素通过下标访问元素，下标从0开始

求元素个数

遍历数组每个元素：

代码展示：

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

总结：

（1）数组是通过下标来访问的，下标是从0开始

（2）数组的大小可以通过计算得到

输入1-9，输出 1-9

代码展示：

#include <stdio.h>
int main() 
{
	int arr[10] = { 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;
}

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

研究数组各个元素在内存中如何存储（打印数组每个元素的地址）

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

调试结果：

地址为16进制，每两个之间相差4.

知识点：

（1）%p 打印取地址符号时 printf（"%p", &a）

（2）一维数组在内存是连续存放的

（3）数组随着下标的增长，地址是由低到高变化的。

代码展示：

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

调试结果：

s是地址，s+1下一个元素的地址，*s 储存的数字，*（s+1）下一个地址对应的元素。

二、二维数组的创建和初始化

2.1 二维数组的创建

对于arr[3][4]，如上图所示序号① 对应的下标是 [0][0] ;序号② 对应的下标是[0][1] ; 序号⑤对应的下标是[1][0] 下标⑦对应的下标是[2][1]。

2.2 二维数组的初始化

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

三行四列，第一行放的数字是1,2,3,4 第二行放的数字是 5,6,7,8 第三行放的数字是9,10,11,12

（2）arr[3][4] = { 1,2,3,4,5,6,7 } 不完全初始化，没有定义的部分默认值为0；

（3）arr[3][4] = { {1,2},{3,4},{5,6} }

第一行的前两个数字为1,2，第二行的前两个数字是3,4 第三行的前两个数字是5,6

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

数组在内存中是连续存放的，所以列溢出元素，可以换行。

2.3 二维数组的使用

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

代码展示：

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

调试结果：

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

代码展示：

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

调试结果：

总结：二维数组在内存中也是连续的。

三、数组越界

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

数组的下标规定是从0开始的，如果数组有n个元素，那么最后一个元素的下标就是n-1,所以数组的下标如果小于0，大于n-1，就是数组下标越界访问了，超出数组合法空间的访问。

C语言本身是不做数组下标的越界检查，编译器也不一定会报错，但是编译器不报错，并不意味着程序就是正确的。

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

c语言中也支持多维数组。例如：三维数组、四维数组等

四、数组作为函数参数

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

设计一个函数对arr数组进行排序——冒泡排序的算法（bubble 动词：冒泡）

冒泡排序的思想：

两两相邻的元素进行比较，如果有可能的需要交换。

一趟冒泡排序只能解决一个数字，让当前待排序的的数组中的一个元素来到最终应该出现的位置上。 n个元素，需要n-1趟冒泡排序。第一趟n个待排序元素，第二趟n-1个元素，第三趟n-2个元素。

（1）确定趟数（2）内部操作，相邻两个元素交换

4.1 冒泡排序函数的设计

代码1展示：

#include <stdio.h>
void bubble_sort(int arr[],int a)
{
	int i = 0;
	int j = 0;
	
	for (i = 0; i < a - 1; i++)//确定趟数
	{
		for (j = 0; j < a - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int b = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = b;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,5,2,4,9,0,7,6,8 };
	int a = 0;
	a = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, a);//实际上数组传参，传递的不是整个数组，传递的是首元素地址
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

代码展示：（void bubble(int arr[], int a)可以写成void bubble(int* arr, int a)）

#include <stdio.h>
void bubble_sort(int* arr,int a)
{
	int i = 0;
	int j = 0;
	
	for (i = 0; i < a - 1; i++)//确定趟数
	{
		for (j = 0; j < a - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int b = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = b;
			}
		}
	}
}
int main()
{
	int arr[] = { 3,1,5,2,4,9,0,7,6,8 };
	int a = 0;
	a = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, a);//实际上数组传参，传递的不是整个数组，传递的是首元素地址
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

代码理解：

（1）函数里第一个for 循环，是确定冒泡趟数。

（2）函数里第二个for循环，是比较元素交换个数，10个元素就要进行9次比较；

（3）void bubble(int arr[], int a)可以写成void bubble(int* arr, int a) 实际上就是一个地址，不是整个数组。

知识点：

（1）实际上数组传参，传递的不是整个数组，传递的是首元素地址，所以在函数里sizeof（arr）的结果是4，所以在主函数的sizeof（arr）才是40，所以在主函数确定元素个数再传递到函数里面。

4.2 数组名是什么？

数组名是首元素地址。（有两个例外）

（1）sizeof内部单独放一个数组名，数组名表示整个数组。sizeof（数组名）计算的是整个数组的大小，单位是字节。 sizeof(arr) 这个就是特例，这里的arr就是整个数组，而不是首元素地址（2）&数组名，数组名表示整个数组，取出的是整个数组的地址。

代码展示：

#include <stdio.h>
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	printf("%p\n", arr);//数组名
	printf("%p\n", &arr[0]);//数组首元素地址
	printf("%p\n", &arr);//整个数组的地址
	printf("%p\n", arr + 1);//第二个元素的地址 
	printf("%p\n", &arr[0] + 1);//第二个元素的地址
	printf("%p\n", &arr + 1);//跨过一个数组的地址
	return 0;
}

由于&arr是整个元素的地址，所以与&arr+1相错20个字节。相当于加了一个元素的地址。

数组知识点在这里就结束了。如果有问题的话，希望友友们可以提出宝贵的的意见。

是小刘同学啦

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
3
评论
数组知识点

励志模块你未来的路还很长别自卑别将就一、一维数组的创建和初始化1.1数组的创建数组是一组相同类型元素的集合。数组的创建方式：代码展示：int arr[5];char ch[5];double arr1[10];int arr[5]; char ch[5];这些都可以，但是不能用int aar[n]；因为[ ]内必须是常量表达式。（C99标准之前是不支持变量的，只能是常量。 C99标准中增加了变长数组的概念，允许数组的大小出现变量，但是要求编译器必...
复制链接

扫一扫