C语言——数组

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

提示：这里添加了本文要记录的大概内容：

数组，顾名思义，就是一组相同类型数据的集合。通过数组，我们可以轻松地访问、修改和遍历这些数据，从而实现各种复杂的逻辑和功能。在C语言中，数组的使用非常灵活，既可以作为静态数据存储的容器，也可以作为函数间数据交换的桥梁。

今天，我们将一起走进C语言数组的世界，探索其背后的原理和应用。本文将从数组的定义、初始化、访问、遍历以及常见应用等方面展开，通过实例演示和代码分析，帮助大家深入理解C语言数组的使用方法和技巧。

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、一维数组

示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。

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

1.1一维数组的创建

type_t   arr_name   [const_n];
//数组的元素类型  数组的名称 [数组元素个数];
//数组元素个数要用常量表示

//数组创建实例
char arr3[10];
float arr4[1];
double arr5[20];


//以下代码只能在支持c99标准的编译器上编译
int count = 10;
int arr2[count];//这种定义数组的方法是不能初始化的

//在c99标准之前，数组的大小必须是常量或者常量表达式
//在c99之后，数组的大小可以是变量，为了支持变长数组

数组创建，在C99标准之前， [] 中要给一个常量才可以，不能使用变量。在C99标准支持了变长数组的概念。

1.2数组的初始化

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

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

//根据初始化的内容来自己分配大小
int arr2[] = {1,2,3,4};

int arr3[5] = {1，2，3，4，5}；
char arr4[3] = {'a',98, 'c'};

//其余元素会被初始化为0，其实就是字符'\0'；（'\0'的ASCII码值就是0）
char arr5[5] = {'a','b','c'};//a b c 0 0
char arr6[5]="abc";//a b c \0 0

char arr7[] = "abcdef";

数组在创建的时候如果想不指定数组的确定的大小就得初始化。数组的元素个数根据初始化的内容来确定。
但是对于下面的代码要区分，内存中如何分配。

char arr1[] = "abc";
char arr2[3] = {'a','b','c'};

2.一维数组的使用

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

1. 数组是使用下标来访问的，下标是从0开始。数组访问的时候，下标可以是变量。

我们来看代码：

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("%d\n",arr[2]);//实际上得到的数字是3，因为下标从0开始
	int i = 0;
	for ( i = 0; i < sz; i++)
	{
		printf("%d\n", arr[i]);//用循环打印数组的内容
	
	}
	return 0;

}

2. 数组的长度可以通过计算得到。
   用sizeof(arr)首先得到整个数组的大小；
   sizeof（arr[0]）计算的是第一个元素的大小；
   最后就能得到数组的长度

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

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

//打印数组的地址
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;
}

仔细观察输出的结果，我们知道，随着数组下标的增长，元素的地址，也在有规律的递增。
由此可以得出结论：数组在内存中是连续存放的。
从下标0开始，依次从低地址到高地址。

二、二维数组

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

1.1二维数组的创建

//数组创建
//1 2 3 4
//5 6 7 8
//9 10 11 12
int arr[3][4];//创建了一个3行4列的数组
char arr[3][5];
double arr[2][4];

1.2二维数组的初始化

二维数组如果有初始化，行可以省略，列不能省略

//数组初始化
int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};//分组过后，其余数据不够用0补上
int arr[][4] = {{2,3},{4,5}};//二维数组如果有初始化，行可以省略，列不能省略

2.二维数组的使用

和一维数组一样，二维数组的下标行和列都是从0开始的。
可以把二维数组想象成一维数组，每一行都是一个一维数组。

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

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

像一维数组一样，这里我们尝试打印二维数组的每个元素。
%p打印地址

#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;

通过结果我们可以分析到，其实二维数组在内存中也是连续存储的。

三、数组越界

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

#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("%d\n", arr[i]);//当i等于10的时候，越界访问了
   }
 return 0;
}

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

四、数组作为函数参数

往往我们在写代码的时候，会将数组作为参数传个函数，比如：我要实现一个冒泡排序函数将一个整形数组排序。
冒泡排序的核心思想：两个相邻的元素进行比较，然后交换位置
那我们将会这样使用该函数：

//方法1：
#include <stdio.h>
void bubble_sort(int arr[])
{
 int sz = sizeof(arr)/sizeof(arr[0]);//这样对吗？
    int i = 0;
 for(i=0; i<sz-1; i++)
   {
        int j = 0;
        for(j=0; j<sz-i-1; j++)
       {
            if(arr[j] > arr[j+1])
           {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
           }
       }
   }
}
int main()
{
    int arr[] = {3,1,7,5,8,9,0,2,4,6};
    bubble_sort(arr);//是否可以正常排序？
    for(i=0; i<sizeof(arr)/sizeof(arr[0]); i++)
   {
        printf("%d ", arr[i]);
   }
    return 0;
}

方法1，出问题，那我们找一下问题，调试之后可以看到 bubble_sort 函数内部的 sz ，是1。难道数组作为函数参数的时候，不是把整个数组的传递过去？

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int *arr 。那么，函数内部的 sizeof(arr) 结果是4。

1. 数组名是什么

1.1 一维数组

int main()
{
	int arr[10] = { 1,2,3,4,5 };
	printf("%p\n", arr);//首元素的地址
	printf("%p\n", arr+1);//下一个元素的地址
	printf("\n");

	printf("%p\n", &arr[0]);//首元素的地址
	printf("%p\n", &arr[0]+1);//下一个元素的地址
	printf("\n");

	printf("%d\n", &arr);//整个数组的地址
	printf("%d\n", &arr+1);//整个数组完了过后的下一个地址

	printf("\n");

	printf("%d\n", *arr);//指针大小
	int n = sizeof(arr);
	printf("%d\n", n);
	//输出结果
	return 0;
}

数组名是数组首元素的地址,但是有以下两个例外：

1. sizeof(数组名)，计算整个数组的大小，单位是字节bit； sizeof内部单独放一个数组名，数组名表示整个数组。
2. & 数组名，数组名表示整个数组。取出的是整个数组的地址。

1.2二维数组的数组名

二维数组的数组名也表示数组首元素的地址，二维数组的首元素是第一行，而不是第一行第一列的那一个元素（两种情况除外）。
行数：总大小/每一行的大小；
列数：某一行的大小/一行里面某个元素的大小；

//二维数组数组名
//二维数组的数组名也表示数组首元素的地址，
//二维数组的首元素是第一行，而不是第一行第一列的那一个元素（两种情况除外）
//行数：总大小/每一行的大小
//列数：某一行的大小/一行里面某个元素的大小
int main()
{
	int arr[3][4] = {0};
	int sz = sizeof(arr);
	int hang = sizeof(arr) / sizeof(arr[0]);
	int lie = sizeof(arr[0]) / sizeof(arr[0][0]);
	printf("%d\n", hang);
	printf("%d\n", lie);

	return 0;
}

2. 正确的冒泡排序

当数组传参的时候，实际上只是把数组的首元素的地址传递过去了。
所以即使在函数参数部分写成数组的形式： int arr[] 表示的依然是一个指针： int *arr 。那么，函数内部的 sizeof(arr) 结果是4。
所以不要在函数里面用sizeof()去计算数组的长度。

//冒泡排序
//void bubble_sort(int* arr)//指针形式
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[] = { 5,6,4,8,6,9,7,3,2,1 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr,sz);
	int i = 0;
	for ( i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
 

3. 交换数组的内容

int main()
{
	int arr1[] = { 1,2,3 };
	int arr2[] = { 4,5,6 };
	int i = 0;
	int sz = sizeof(arr1) / sizeof(arr1[0]);
	for ( i = 0; i < sz; i++)
	{
		int tmp = arr1[i];
		arr1[i] = arr2[i];
		arr2[i] = tmp;
	}
	for ( i = 0; i < sz; i++)
	{
		printf("%d ", arr1[i]);
	}
	printf("\n");
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr2[i]);
	}
	return 0;
}

---

总结

提示：这里对文章进行总结：
C语言中的数组是存储相同类型数据的高效工具。通过本次探讨，我们学会了如何定义、初始化、访问和遍历数组，并了解了其在数据处理和算法实现中的重要作用。数组的灵活性和强大功能使其成为C语言编程中不可或缺的一部分，希望这些内容能对大家的编程实践有所帮助。