【C语言】数组详解

蔚落 2023-10-14 09:53 100阅读 0赞

**目录**

一、数组的概念

二、一维数组

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

(1) 数组的创建方式：

(2) 数组的初始化:

2. 一维数组的使用

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

三、 二维数组

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

（1）二维数组的创建

（2）二维数组的初始化

2. 二维数组的使用

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

四、 数组越界

五、 数组作为函数参数

--------------------

## 一、数组的概念 ##

*  **数组** 是一组具有相同数据类型的数据的集合，即**一组类型相同的数据**
 *  **数组元素** 是构成数组的是数据，同一个数组中的每个元素必须是**相同类型**的数据元素，共用一个数组名，**元素下标从0开始**
 *  数组的维度（需要几个下标来确定），按维度分，有一维数组，二维数组，多维数组。

## 二、一维数组 ##

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

#### **(1) 数组的创建方式：** ####

> 数组的元素类型 数组名 \[ 常量表达式 \] ;

type_arr  arr_name [const_n];

【例】

//代码1
    int arr[10];    
    
    //代码2
    int count  = 10;
    int arr2[count] ;    //注意这里是变成数组，C99 后才可以引用变长数组
    
    //代码3
    char arr3[10];
    floar arr4[20];
    double arr5[10];

**注意**，其中vs2022,vs2019不支持C99的边长数组，代码2的创建不推荐

#### **(2) 数组的初始化:** ####

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

//不完全初始化
    int arr1[10] = {1,2,3};
    
    //完全初始化
    int arr2[5] = {1,2,3,4,5};
    
    //不指定数组的大小,数组的元素个数由初始化的内容来确定
    int arr[]  = {1,2,3,4};

**注意：** “ ”里面的 \\0

char arr1[] = "abc";    //实际元素 a b c \0 是四个
    char arr2[] = {'a','b','c'};    //a b c 是三个

### 2. 一维数组的使用 ###

这里我们 需要知道一个操作符 \[ \] 下标引用 操作符，操作数由 数组名 + 一个索引（下标）

#include <stdio.h>
    
    int main() 
    {
    	int arr[5] = {0};		//数组的不完全初始化
    	int sz = sizeof(arr) / sizeof(arr[0]);	//整个数组的大小/一个数组的大小 = 数组的个数
    	int i = 0;	//记录数组的下标
    	for (i = 0; i < sz;i++)
    	{
    		arr[i] = i;		//对数组内容进行赋值
    	}
    	for (i = 0; i < sz;i++)
    	{
    		printf("%d ", arr[i]);	//打印数组的内容 0 1 2 3 4
    	}
    	return 0;
    }

**注意：**数组的下标是从0 开始的。数组的大小可以计算得到

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

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

![02132936c6d9492595a7e6dfa3b7272e.png][]

查看输出结果：随着数组下标的增长，元素的地址由低到高变化（递增）

**即：数组在内存中是连续存放的**

## **三、 二维数组** ##

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

#### （1）二维数组的创建 ####

//创建数组
    int arr[5][5];

#### （2）二维数组的初始化 ####

// 初始化数组
    int arr[5][5] = {0};
    int arr[2][3] = {
       {1,2,3},{4,5,6}};
    int arr[][3] = {
       {2,3},{1,4}};    //注意二维数组如果初始化，行可以省略，但是列不能省略

**注意** 二维数组如果初始化，行可以省略，但是列不能省略

### 2. 二维数组的使用 ###

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

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

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

![4ce329040899488ea7b0ec1bff1fcdaa.png][]

由输出可知二维数组在内存中也是连续存储的

## 四、 数组越界 ##

因为数组的下标是有范围的，例 arr\[n\] ,该数组下标为 0 ~ n-1 。当数组下标大于 n - 1 ,就是数组越界访问了。我们平时要做好数组越界的检查

#include <stdio.h>
    int main() 
    {
    	int arr[5] = {0};
    	int i = 0;
    	for (i = 0; i <= 5;i++)  //错误的地方
    	{
    		arr[i] = i;
    	}
    	return 0;
    }

![e5116ecd151b4b0694eaf652d22eddd4.png][]

## 五、 数组作为函数参数 ##

**1.** 当我们写一个冒泡排序函数的时候，是否也会遇到这种情况

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 temp = arr[j];
    				arr[j] = arr[j + 1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    }

**注意：int sz = sizeof(arr) / sizeof(arr\[0\]); 因为在函数中，传来数组的地址，sizeof（arr）求的是指针的大小，在 x64 下是 8，在 x86下是 4**

**2.** 这时，可能会考虑数组名

#include <stdio.h>
    int main()
    {
    	int arr[] = {1,2,3};
    	printf("&arr[0] = %p\n",&arr[0]);	//打印数组首元素的地址
    	printf("    arr = %p\n",arr);	//打印数组名地址
    	return 0;
    }

![32f6b06f61404907a3efd24217b6fd1d.png][]

**总结：**

**通常数组名是数组首元素的地址**，

> 但有特殊情况：
> 
>  *  sizeof(数组名) ，计算的是整个数组，单位是字节。例如：int arr\[10\] = \{0\}; sizeof(arr) 得到的结果是 40
>  *  &数组名。这里的数组名表示整个数组

**3. 正确的冒泡排序的函数**

# 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 - i - 1;j++)
    		{
    			if(arr[j]>arr[j+1])	//由小到大排序
    			{
    				int temp = arr[j];
    				arr[j] = arr[j+1];
    				arr[j + 1] = temp;
    			}
    		}
    	}
    	//输出
    	for (i = 0; i < sz;i++)
    	{
    		printf("%d ",arr[i]);	// 2 6 9
    	}
    }
    int main()
    {
    	int arr[] = { 9,2,6 };
    	int sz = sizeof(arr) / sizeof(arr[0]);
    	bubble_sort(arr,sz);
    	return 0;
    }

[02132936c6d9492595a7e6dfa3b7272e.png]: https://img-blog.csdnimg.cn/02132936c6d9492595a7e6dfa3b7272e.png
[4ce329040899488ea7b0ec1bff1fcdaa.png]: https://img-blog.csdnimg.cn/4ce329040899488ea7b0ec1bff1fcdaa.png
[e5116ecd151b4b0694eaf652d22eddd4.png]: https://img-blog.csdnimg.cn/e5116ecd151b4b0694eaf652d22eddd4.png
[32f6b06f61404907a3efd24217b6fd1d.png]: https://img-blog.csdnimg.cn/32f6b06f61404907a3efd24217b6fd1d.png