4.C语言数组篇

数组的定义以及初始化

格式：

​ 数据类型 数组名 [数组长度] = {数据1，数据2，. . .};

数组内存地址

第一个元素的第一个字节空间的地址，也就是首地址

索引：在内存中就是偏移量

比如

int arr[10] = {1,2,3};

arr: 可以获得数组的首地址（数组中第一个元素的内存地址）

[索引]：偏移量，就是根据数组类型决定偏移多少位（比如int类型的数组就是偏移4位）

#include<stdio.h>

int main()
{
	int arr[] = { 1,2,3,4,5 };
	printf("%p\n", &arr);     //00000010F432F828
	printf("%p\n", &arr[0]);  //00000010F432F828
	printf("%p\n", &arr[1]);  //00000010F432F82C
	printf("%p\n", &arr[2]);  //00000010F432F830
	return 0;
}

数组作为函数的参数

• 数组作为函数的参数，实际传递的是数组的首地址
• 如果要进行数组遍历的话，要连带数组长度一起传递
• 定义处的数组arr表示的是一个完整的数组
• 而函数中的arr只是一个变量，用于记录数组的首地址

#include<stdio.h>

void printArr(int arr[], int len);

int main()
{
	int arr[] = { 1,2,3,4,5 };
	int len = sizeof(arr) / sizeof(int);
	printArr(arr, len);
	printf("定义处地址：%p\n", &arr);				// 000000CFF8B6FD18
	printf("定义处字节：%zu\n", sizeof(arr));		// 20
	return 0;
}

void printArr(int arr[], int len)
{
	/*
		注意：一个字节有八个位 1bit = 8byte
		这里的arr是一个记录了64位二进制的变量
		所以当我们计算arr的字节长度时，将会输出（64/8=8）个字节
	*/
	printf("函数处地址：%p\n", arr);				// 000000CFF8B6FD18
	printf("函数处字节：%zu\n", sizeof(arr));		// 8
	for (int i = 0; i < len; i++)
	{
		printf("%d\n", arr[i]);
	}
}

二维数组

• 和Java一样，先行后列

• int arr[row][col]
  

二维数组第二种定义方式的遍历

• 索引遍历

#include<stdio.h>

int main()
{
	//二维数组的第二种定义方式
	int arr1[] = { 1,2,3 };
	int arr2[] = { 1,2,3,4,5 };
	int arr3[] = { 1,2,3,4,5,6,7 };
	int* arr[] = { arr1,arr2,arr3 };
	//计算每个一维数组的长度
	int len1 = sizeof(arr1) / sizeof(int);
	int len2 = sizeof(arr2) / sizeof(int);
	int len3 = sizeof(arr3) / sizeof(int);
	//定义一个数组存储每个一维数组的长度
	int lenarr[] = { len1,len2,len3 };
	//用索引的方式遍历二维数组
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < lenarr[i]; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

• 数组指针遍历

#include<stdio.h>

int main()
{
	//定义一个二维数组
	int arr[3][5] = { {1,2,3,4,5},{11,22,33,44,55},{111,222,333,444,555} };
	//获取二维数组的首地址
	/*
		二维数组的首地址 = 第一行一维数组 arr[0] 的首地址 = arr[0][0] 的首地址（三者在内存上是同一个地址，只是 “类型含义” 不同）
		「行指针」：指向包含 5 个 int 的一维数组的指针 步长：20 字节
		「列指针」：指向单个 int 的指针				步长：4 字节
	*/
	int (*p) [5] = arr;
	printf("p	 = %p\n", p);			// 二维数组的首地址也叫 “行指针” 类型：int[5]* 正确写法为 int(*)[5]
	printf("*p	 = %p\n", *p);			// 对二维数组的首地址解引用，拿到的是5个int的数组(arr[0]) 会被隐式转换成一维数组的首地址也叫 “列指针” 类型：int*
	printf("**p	 = %d\n", **p);			// 对一维数组的首地址解引用（因为被隐式转换了），得到的是一维数组中存储的元素 类型: int
	printf("&**p	 = %p\n", &**p);	// 得到int型整数的地址 类型：int*
	printf("-----------------------------------\n");
	// 利用数组指针遍历二维数组
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 5; j++)
		{
			printf("%d ", *(*p + j));
		}
		p++;
		printf("\n");
	}
}
/*
	p        = 0000002843AFF668
	*p       = 0000002843AFF668
	**p      = 1
	&**p     = 0000002843AFF668
*/

#include<stdio.h>

int main()
{
	//定义一个二维数组
	int arr1[] = { 1,2,3 };
	int arr2[] = { 1,2,3,4,5 };
	int arr3[] = { 1,2,3,4,5,6,7 };

	int len1 = sizeof(arr1) / sizeof(int);
	int len2 = sizeof(arr2) / sizeof(int);
	int len3 = sizeof(arr3) / sizeof(int);
	int len[] = {len1,len2,len3};
	int* plen = len;

	int* arr[] = {arr1,arr2,arr3};
	//获取二维数组的首地址
	int** p = arr;
	//利用数组指针遍历二维数组
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < *plen; j++)
		{
			printf("%d ", *(*p + j));
		}
		printf("\n");
		plen++;
		p++;
	}
}