当前位置:   article > 正文

【C语言】数组

【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

总结

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

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/凡人多烦事01/article/detail/463604
推荐阅读
相关标签
  

闽ICP备14008679号