【C语言】数组

【C语言】数组

---

---

一维数组

• 元素类型角度：数组是相同类型的变量的有序集合
• 内存角度：连续的一大片内存空间

int b[10];
我们把b称作数组，因为它是一些值的集合。下标和数名一起使用，用于标识该集合中某个特定的值。例如，b[0]表示数组b的第1个值，b[4]表示第5个值。每个值都是一个特定的标量。

一维数组名

那么问题是b的类型是什么？它所表示的又是什么？一个合乎逻辑的答案是它表示整个数组，但事实并非如此。在C中，在几乎所有数组名的表达式中，数组名的值是一个指针常量，也就是数组第一个元素的地址。它的类型取决于数组元素的类型：如果他们是int类型，那么数组名的类型就是“指向int的常量指针”；如果它们是其他类型，那么数组名的类型也就是“指向其他类型的常量指针”。

请问：指针和数组是等价的吗？

答案是否定的。数组名在表达式中使用的时候，编译器才会产生一个指针常量。那么数组在什么情况下不能作为指针常量呢？在以下两种场景下：

1.当数组名作为sizeof操作符的操作数的时候，此时sizeof返回的是整个数组的长度，而不是指针数组指针的长度。
2.当数组名作为**&操作符的操作数**的时候，此时返回的是一个指向数组的指针，而不是指向某个数组元素的指针常量。

void test01()
{
	//一维数组名是不是指针？
	int arr[5] = { 1,2,3,4,5 }; 


	//有两种特殊情况，一维数组名不是指向第一个元素的指针
	//1、sizeof
	//2、对数组名取地址		得到数组指针	步长是整个数组长度
	
	printf("%d\n", sizeof(arr)); //20 
	int len = sizeof(arr) / sizeof(int);
	

	printf("%d\n", &arr); 
	printf("%d\n" ,&arr + 1); 
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

//	int arr[]	可读性更高
void printArray(int arr[], int len)	//int arr[]等价于 int*arr
{
	for (int i = 0; i < len; i++)
	{
		printf("%d\n", arr[i]);
	}
}

void test03()
{
	int arr[5] = { 1,2,3,4,5 };
	int len = sizeof(arr) / sizeof(int);
	printArray(arr, len);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void test02()
{
	//arr数组名 它是一个指针常量 指针指向不可以修改，而指针指向的值可以改int * counst a
	int arr[5] = { 1,2,3,4,5 };
	arr[0] = 12;
	//arr = NULL;	//error
}

1
2
3
4
5
6
7
8

下标引用

int arr[] = { 1, 2, 3, 4, 5, 6 };

*(arr + 3) ,这个表达式是什么意思呢？

首先，我们说数组在表达式中是一个指向整型的指针，所以此表达式表示arr指针向后移动了3个元素的长度。然后通过间接访问操作符从这个新地址开始获取这个位置的值。这个和下标的引用的执行过程完全相同。所以如下表达式是等同的：

*(arr + 3)
arr[3]

问题：数组下标可否为负值？

void test03()
{
	//数组索引 可不可以是负数	答案：可以
	int arr[5] = { 1,2,3,4,5 };
	int* p = arr; 
	p = p + 3;
	printf("%d\n", p[-1]);	//3
	printf("%d\n", *(p - 1)); //3
}

1
2
3
4
5
6
7
8
9
10

答案是：可以的。

那么是用下标还是指针来操作数组呢？对于大部分人而言，下标的可读性会强一些。

//	int arr[]	可读性更高
void printArray(int arr[], int len)	//int arr[]等价于 int*arr
{
	for (int i = 0; i < len; i++)
	{
		printf("%d\n", arr[i]);
	}
}

void test04()
{
	int arr[5] = { 1,2,3,4,5 };
	int len = sizeof(arr) / sizeof(int);
	printArray(arr, len);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

数组和指针

指针和数组并不是相等的。为了说明这个概念，请考虑下面两个声明：

int a[10];
int *b;

声明一个数组时，编译器根据声明所指定的元素数量为数组分配内存空间，然后再创建数组名，指向这段空间的起始位置。声明一个指针变量的时候，编译器只为指针本身分配内存空间，并不为任何整型值分配内存空间，指针并未初始化指向任何现有的内存空间。
因此，表达式a是完全合法的，但是表达式b却是非法的。*b将访问内存中一个不确定的位置，将会导致程序终止。另一方面b++可以通过编译，a++却不行，因为a是一个常量值。

数组指针

数组指针的定义方式：
1、先定义数组类型，再通过类型定义数组指针

typedef int(ARRARY_TYPE)[5]; // ARRARY_TYPE 代表存放5个int类型元素的数组 的数组类型

//数组指针的定义方式
//1、先定义数组类型，在通过类型定义数组指针
void test05()
{
	int arr[5] = { 1,2,3,4,5 };

	typedef int(ARRARY_TYPE)[5]; // ARRARY_TYPE 代表存放5个int类型元素的数组 的数组类型

	ARRARY_TYPE arr2; 
	for (int i = 0; i < 5; i++)
	{
		arr2[i] = 100 + i;
	}
	for (int i = 0; i < 5; i++)
	{
		printf("%d\n", arr2[i]);
	}

	ARRARY_TYPE* arrP = &arr;
	for (int i = 0; i < 5; i++)
	{
		printf("%d\n", (*arrP)[i]);
	}

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

2、先定义数组指针类型，再通过类型定义数组指针

typedef int(*ARRARY_TYPE)[5];

//2、先定义数组指针类型，在通过类型定义数组指针
void test06()
{
	int arr[5] = { 1,2,3,4,5 };
	typedef int(*ARRARY_TYPE)[5];

	ARRARY_TYPE arrP = &arr;

	for (int i = 0; i < 5; i++)
	{
		printf("%d\n", (*arrP)[i]);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13

3、直接定义数组指针变量

int arr[5] = { 1,2,3,4,5 };
int(*p)[5] = &arr;

//3、直接定义数组指针变量
void test07()
{
	int arr[5] = { 1,2,3,4,5 };
	int(*p)[5] = &arr;

	for (int i = 0; i < 5; i++)
	{
		printf("%d\n", (*p)[i]);
	}
}
1
2
3
4
5
6
7
8
9
10
11

二维数组

二维数组名

一维数组名的值是一个指针常量，它的类型是“指向元素类型的指针”，它指向数组的第1个元素。多维数组也是同理，多维数组的数组名也是指向第一个元素，只不过第一个元素是一个数组。例如：

int arr[3][10]

可以理解为这是一个一维数组，包含了3个元素，只是每个元素恰好是包含了10个元素的数组。arr就表示指向它的第1个元素的指针，所以arr是一个指向了包含了10个整型元素的数组的指针。

除了两种特殊情况外 ，二维数组名称是 指向第一个一维数组 数组指针
特殊情况1 sizeof
特殊情况2 对数组名取地址 &arr 获取的是二维数组的 数组指针 int(*p)[3][3] = &arr;

void test08()
{
	//可读性高
	int arr[3][3] = {
		{1,2,3},
		{2,3,4},
		{3,4,5},
	};
	//除了两种特殊情况外 ，二维数组名称是 指向第一个一维数组  数组指针
	//特殊情况1  sizeof
	//特殊情况2  对数组名取地址 &arr  获取的是二维数组的 数组指针 int(*p)[3][3] = &arr;

	printf("%d\n", sizeof(arr));	//36

	int(*pArray)[3] = arr;
	//访问二维数组中的 4 这个元素
	printf("%d\n", arr[1][2]);	//给人看
	printf("%d\n", *(*(pArray + 1) + 2));	//给机器看
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

二维数组做函数参数

//void printArray02(int (*array)[3], int row, int col)
//void printArray02(int array[][3], int row ,int col)
void printArray02(int array[3][3], int row, int col) //array[3][3] 等价于 一维数组指针   int (*array)[3]
{
	for (int i = 0; i < row; i++)
	{
		for (int j = 0; j < col; j++)
		{
			//printf("%d ", array[i][j]);
			printf("%d ", *(*(array + i) + j));
		}
		printf("\n");
	}
}

//二维数组做函数参数
void test09()
{
	int arr[3][3] = {
		{ 1, 2, 3 },
		{ 4, 5, 6 },
		{ 7, 8, 9 }
	};

	printArray02(arr, 3, 3);

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

二维数组排序

选择排序

选择排序算法是通过遍历数组，选择出数组的最小或最大值，与指定位置交换数据，遍历完整个数组的所有位置就完成排序。

遍历第一趟数组，找出数组的最小值，与第一个数据交换。
遍历第二趟数组，继续找出最小值，与第二个数据交换。
重复上述动作，遍历完数组就得到一个有序数组。

void mySort(int arr[], int len)
{
	for (int i = 0; i < len - 1; i++)
	{
		int min = i;	//记录最小值下标为i
		for (int j = i + 1; j < len; j++)
		{
			if (arr[min] > arr[j])
			{
				//更新真实最小值下标
				min = j;

			}
		}
		if (i != min)
		{
			int tmp = arr[i];
			arr[i] = arr[min];
			arr[min] = tmp; 
		}
	}
}


void printArray(int *arr,int len)
{
	for (int i = 0; i < len; i++)
	{
		printf("%d\n", *(arr+i));
	}
}

void test10()
{
	//从小到大 排序 利用选择排序
	int arr[] = { 2,5,1,3,4 };

	int len = sizeof(arr) / sizeof(arr[0]);
	mySort(arr,len);

	printArray(arr, len);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

练习：
对指针数组进行排序，排序的算法利用 选择排序 从大到小
char * pArray[] = { “aaa”, “fff”, “bbb”, “ddd”, “ccc”, “eee” };

void selectSort(char** array,int len)
{
	for (int i = 0; i < len-1; i++)
	{
		int max = i;
		for (int j = i + i; j < len; j++)
		{
			if (strcmp(array[max], array[j]) < 0)
			{
				max = j;
			}
		}
		if (max != i)
		{
			char* tmp = array[i];
			array[i] = array[max];
			array[max] = tmp;

		}

	}
}


void printArray2(char*array[],int len) {
	for (int i = 0; i < len; i++)
	{
		printf("%s\n", array[i]);
	}
}

void test11()
{
	//对指针数组进行排序，排序的算法利用 选择排序   从大到小
	char* pArray[4] = { "aaaaa","fff","bbbb","ddd" };

	int len = sizeof(pArray) / sizeof(pArray[0]); 


	selectSort(pArray, len);

	printArray2(pArray, len);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

---

总结

到这里这篇文章的内容就结束了，谢谢大家的观看，如果有好的建议可以留言喔，谢谢大家啦！