C语言数组（Array）

●🧑个人主页:你帅你先说.

●📃如果文章有帮助,欢迎点赞👍关注💡收藏💖

●📖既选择了远方，便只顾风雨兼程。

●🤟欢迎大家有问题随时私信我！

●🧐版权：本文由[你帅你先说.]原创，CSDN首发，侵权必究。

目录

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

1.1一维数组的创建

1.2一维数组的初始化

1.3一维数组的使用

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

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

2.1 二维数组的创建

2.2 二维数组的初始化

2.3 二维数组的使用

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

3.数组越界

4.冒泡排序

---

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

1.1一维数组的创建

type_t   arr_name   [const_n];
//type_t 是指数组的元素类型
//const_n 是一个常量表达式，用来指定数组的大小

例如

int arr[10];
char arr[20];

特别注意:[ ]中必须是常量表达式！

1.2一维数组的初始化

int arr1[20] = {1,2,3};//不完全初始化，剩余的默认初始化为0
int arr2[] = { 1,2,3};//数组元素个数视大括号内而定
char arr3[] = "abc";//结尾默认补上\0，数组内容为abc\0
char arr4[] = { 'a', 'b', 'c' };//数组内容为abc
char arr5[] = { 'a', 98, 'c' };//数组内容为abc
//arr5[]中，因为b所对应的ASCII码值为98，所以98在数组中以字符b存在

1.3一维数组的使用

#include <stdio.h>
int main()
{
 int arr[10] = {1};//数组的不完全初始化 第一个元素初始化为1,其余元素默认为0
    //计算数组的元素个数
    int sz = sizeof(arr)/sizeof(arr[0]);
 //对数组内容赋值,数组是使用下标来访问的，下标从0开始。所以：
 int i = 0;//做下标
 for(i=0; i<sz; i++)//
 {
 arr[i] = i;
 } 
 //输出数组的内容
 for(i=0; i<sz; ++i)
 {
 printf("%d ", arr[i]);
 }
 return 0; }

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

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

输出结果

通过观察我们可以知道,随着数组下标的增长，元素的地址也在有规律的递增。

由此可以得出结论： 数组在内存中是连续存放的。

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

2.1 二维数组的创建

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

2.2 二维数组的初始化

int arr[3][4] = {1,2,3,4};
int arr[3][4] = {{1,2},{4,5}};
int arr[][4] = {{2,3},{4,5}};
char arr[3][4] = {"abc","def","qwe"};

第二种初始化方式与第一种不同，第一种方式是每行存满后进入下一行，而第二种方式则是第一行存1、2，第二行存4、5，其余位置以0补齐。同理，第四种初始化原理和第二种相同，每个" "代表不同行，每行以'\0'为结尾。

注意:二维数组的初始化行可以省略，列不能省略！

2.3 二维数组的使用

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

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

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

输出结果

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

所以二维数组的存储不是这样

而是这样的

3.数组越界

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

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

所以数组的下标如果小于 0 ，或者大于 n-1, 就是数组越界访问了,超出了数组合法空间的访问。

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

输出结果

 超出范围后就出现了随机值。

注意:C语言本身是不做数组下标的越界检查，编译器也不一定报错，但是编译器不报错，并不意味着程序就是正确的，所以程序员写代码时，最好自己做越界的检查。

4.冒泡排序

图解

void Sort(int* arr, int sz)
{
	int i = 0;
	//冒泡排序的趟数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		int flag = 1;//假设已经有序
		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;
				flag = 0;	
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}
#include<stdio.h>
int main()
{
	int i;
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	
	Sort(arr, sz); 
	for (i = 0; i < 10; i++)
	{
		printf("%d", arr[i]);
	}
	return 0;
}

有的人会疑惑，sz为什么也要作为参数传过去，在函数内部算不就行了。实际上arr在主函数里，sizeof（arr）中arr代表的是整个数组，当你把数组传参给函数时，函数是以指针的方式接收，相当于是传了个地址过去，这样就会导致在自定义函数内部计算sizeof（arr）是4个字节（以32bit为例），再除每个元素的大小，算出来是1个元素，这就与实际不符合了。

这里的flag是为了提升效率的，如果一组数本来就是有序的，你再进行排序就多此一举了，所以在这里增加个判断是否有序，如果有序直接跳出去，避免无用功，造成程序效率低下。

在这里总结一下：

数组名就是首元素的地址

有2个例外：

1. sizeof(数组名)，这里的数组名表示整个数组，sizeof(数组名)计算的是整个数组的大小。

2. &数组名，这里的数组名表示整个数组，取出的是数组的地址。

我们可以进行验证

虽然三个地址都是一样的，但意义不一样。第一个和第二个代表都是首元素的地址，而第三个表示的是整个数组的地址。

显然，前两个+1跳过的只是4个字节，而&arr+1跳过的是整个数组，40个字节。

5.数组与字符数组

这道题很多人可能会选择D，为什么会这样认为呢，因为他以为第一个是" "初始化方式，所以结尾会添\0,所以长度为7,第二个则是随机值但一定比7大。请大家仔细审题，这道题题目问的是数组的长度，而你刚刚所想的确实用strlen函数算出来的长度。数组X里的内容应该是abcdefg\0，长度应为8，而数组Y里的内容为abcdefg，长度为7，所以本题为C。 

看完这些，我相信你现在应该是这样的

但别气馁，学习的过程总是痛苦的。

本人水平有限，请大家批评指正！喜欢我就点个关注吧！