数组

变长数组

int n = 0;
int ch[n];

• C99中引入了变长数组的概念
• 变长数组支持数组的大小使用变量来指定
• 变长数组不是数组的长度可以变化,而是数组的大小可以用变量来指定
• VS2019,2022都不支持,大部分的OJ刷题平台/VSCode/gcc都支持变长数组

一维数组

• 数组的创建

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

• 数组的初始化

//1.指定大小的初始化
int arr1[5] = {0};//五个元素都为0
int arr2[5] = {1,2,3,4,5}//初始化了五个数字,有明确的值
char arr3[5] = "abcde";//结尾默认由\0结尾(a b c d e f \0)
char arr4[5] = {'a','b','c','d','e'}//结尾没有\0终止(a b c d e)

//2.未指定大小的初始化:由初始化的内容元素决定
int arr1[] = {0};//只有一个元素0,所以数组的大小默认为1
int arr2[] = {1,2,3,4,5};//初始化内容中有5个元素,所以数组的大小为5
char arr3[] = "abcde";//因为结尾默认由\0结尾,所以此数组的大小为6(\0也要计入)
char arr4[] = {'a','b','c','d','e'};//正常打印计算时大小为5
//此时没有\0结尾,字符数组用strlen计算大小时,计算到有\0时默认截止,所以此时数组计算时的大小是未知的(a b c d e ...... \0)

//3.特殊情况
int arr1[4]={1,2,3};//此时缺少的元素默认补上0
char arr1[]={'a','b','c','0'};//此时数组的大小为4,因为0本质和\0是一样的,所以到0的时候默认停止计算长度

//4.strlen情况
char arr1[]={'a','b','c'};
char arr2[3]={'a','b','c'};
int ret = strlen(arr1)//ret = 未知(找到\0停止计算)
int ret2 = strlen(arr2)//与上行结果一样,直到找到\0停止计算

一维数组的使用

• 遍历数组元素:

//输出数组元素个数和内容
int main()
{
	int arr[10]={1,2,3,4,5,6};
	int sz = sizeof(arr)/sizeof(arr[0]);
	int i = 0;
	for(i = 0;i < sz; i++)
	{
		printf("%d",arr[i]);
	}
}

一维数组在内存中的存放

• 一维数组在内存中的存放是连续的
• 随着数组下标的增长,元素的地址,也在有规律的递增

二维数组

二维数组的创建

int arr[3][4];
char arr1[3][5];
char arr2[][4];

二维数组的初始化

int arr[3][4]={1,2,3,4};//1 2 3 4|0 0 0 0|0 0 0 0
int arr1[3][4]={[1,2],[3,4]};//1 2 0 0|3 4 0 0|0 0 0 0
int arr2[][4] = {1,2,3,4};//1 2 3 4
int arr3[][4] = {[2,3],[4,5]}//2 3 0 0|4 5 0 0
int arr5[3][4] = {1,2,3,4,5}//1 2 3 4|5 0 0 0|0 0 0 0

二维数组的使用

//二维数组的遍历
int main()
{
	int arr[3][4] = { {2,3},{4,5} };
	for (int i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 4; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

//二维数组的置换操作
int main()
{
	int arr[3][4] = { {2,3},{4,5} };
	for (int j = 0; j < 4; j++)
	{
		int i = 0;
		for (i = 0; i < 3; i++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

二维数组在内存中的存储

• 二维数组与一维数组相同，都是连续存储的

数组越界

• 数组的下标有规范限制,对于n个元素的数组,基本从0开始到n-1结束,如果小于n或者大于n-1则就是数组越界访问了
• 有些时候,编译器对于这种操作不一定报错
  
• 如图,以二维数组为例,即便越界,他后面访问时不会报错,只会访问在这个位置的一些脏数据
• 有时,一维数组的越界访问对于VS而言也会产生编译报错的情况

数组作为函数参数(冒泡排序)

数组名

int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	printf("%p\n", arr);
	printf("%p\n", &arr[0]);
	printf("%d", *arr);
	return 0;
}

• 对于数组而言,数组名是首元素的地址
• 但存在两个特殊的例子:
  sizeof(数组名)和&数组名:
  1.sizeof(数组名):计算整个数组的大小,sizeof内部单独放一个数组名,数组名表示整个数组
  2.&数组名:&数组名,数组名表示整个数组,&数组名+1跳过整个数组

int main()
{
	int arr[10]={0};
	printf("%p\n", arr);//首元素地址
	printf("%p\n", arr + 1);//首元素地址+1

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

	printf("%p\n", &arr);//数组的地址
	printf("%p\n", &arr + 1);//数组的地址,+1跳过整个数组进40个字节
}

• 如果是三行四列的二维数组,arr[1]代表第二行的数组首元素,&arr[1]+1跳过这一行的元素

冒泡排序的设计

#include <stdio.h>

void bubble_sort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz-1; i++)
	{
		int j = 0;
		for (int 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[10] = { 0,2,1,4,5,6,7,8,3,9 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	for (int i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}

• 这里运用了数组传参,数组传参时,传的是首元素的地址,而不是整个数组,如果在冒泡函数中再进行计算数组大小,此时无法计算
• 为了节省空间,传输地址,我们可以通过首元素地址访问至原数组的位置,进行访问调用
• 所以当我们自定义的函数需要用到原本数组大小时,需要在主函数计算后,一同传过去才可以