c语言分层理解（c语言指针（下））

最新推荐文章于 2024-10-07 08:59:31 发布

脚踏车(crush)

最新推荐文章于 2024-10-07 08:59:31 发布

阅读量1.5k

点赞数 20

分类专栏： c语言学习文章标签： c语言

本文链接：https://blog.csdn.net/m0_46343224/article/details/126630269

版权

c语言学习专栏收录该内容

25 篇文章 7 订阅

订阅专栏

本文深入讲解了C++中的指针数组与数组指针的区别，通过实例展示了它们的用法。接着探讨了数组参数和指针参数的传递方式，包括一维、二维数组及一级、二级指针。重点介绍了函数指针的概念，并通过模拟计算器展示了如何使用函数指针数组实现动态操作。此外，还详细解析了标准库函数`qsort`的使用，以及如何实现通用的冒泡排序，并对结构体数组进行排序。最后，文章提到了回调函数的概念及其在实际中的应用。

摘要由CSDN通过智能技术生成

1.指针数组和数组指针区分

指针数组是存放指针的数组，实质上是数组。数组指针是指向数组的指针，实质上是指针。

1.1指针数组

比如int* arr[10];这里怎么理解，这里的arr[10 ]就是数组，数组中存放的是int类型的指针。

用例子来说：

#include <stdio.h>
int main()
{
	char* arr[3] = { "zhangsan","lisi","wangwu" };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%s\n", arr[i]);
	}
	return 0;
}

#include <stdio.h>
int main()
{
	int arr1[5] = { 1,2,3,4,5 };
	int arr2[5] = { 2,3,4,5,6 };
	int arr3[5] = { 3,4,5,6,7 };

	int* arr[3] = { arr1,arr2,arr3 };

	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 5; j++)
		{
			printf("%d", arr[i][j]);
		}
		printf("\n");
	}

	return 0;
}

1.2数组指针

比如int (*arr)[10];这里的意思是arr是个指针，这个指针指向一个数组，数组中有十个元素，每个元素都是int类型。这里可以借用int *arr;类比，这里的意思是指向整型的指针变量arr。

这里需要注意的是&arr和arr,认识到这个数组指针，这里对其再次解读。

这里的&arr的类型是int (*)[10];是一个数组指针类型，其他的是整型指针类型，所以&arr+1跳过的是整个数组。

打印一维数组元素：

#include <stdio.h>
void print(int(*p)[10], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
	    //p=&arr,*p=arr
		printf("%d ", (*p)[i]);
	}
}

int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(&arr, sz);
	return 0;
}

打印二维数组：

#include <stdio.h>
void print(int (*p)[5], int r,int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}

int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print(&arr, 3, 5);
	return 0;
}

再来看看这个是什么鬼？

int (*parr[10])[5];

这个是什么东西？
首先它可拆分为两个int (* )[5]和parr[10]，这里的意思是 parr是存放数组指针的数组。

2.数组参数和指针参数

2.1一维数组传参

int arr[10] = {0};

可以用int arr[]和int arr[10]和int *arr接收。

int *arr[10] = {0};

这里的arr可以用int *arr[10] 和int **arr接收。

2.2二维数组传参

int arr[3][5] = {0};

这里的arr可以用int arr[3][5]和int arr[][5]和int (*arr)[5]接收，其他的都不行。

2.3一级指针传参

void test(int *p){}

这里的int *p可以用&变量和数组名和指针传参。

2.4二级指针传参

void test(int **ptr){}

这里的int **ptr可以用二级指针和&一级指针和指针数组传参。

3.函数指针

这里的函数名就是函数的地址。

这里用这个Add来写一下函数指针，void (*padd)(int x,int y);这个就是函数指针，首先把padd和void ( * )(int x,int y)分开，首先是一个指针，这个指针的类型是函数，指向函数，这个函数的参数是x和y，返回值是void。

上述代码改进：

int Add(int x, int y)
{
	return x + y;
}

int main()
{
	int a = 10;
	int b = 20;
	int (*padd)(int x,int y) = &Add;
	int ret = padd(3,5); 
	printf("%d\n", ret);
	return 0;
}
//结果是8

下面来看看这个代码是什么意思？

(* ( void( * )( ) )0 )( );

解释：void( * )( )是函数指针类型，把0强制类型转换为函数指针类型，调用0地址处的函数。这里这个代码也可以写成( void( * )( ) )0 ( );

void (* signal(int ,void( * )(int) )(int);
解释：上述代码是函数声明，声明的函数叫做signal，函数的第一个参数是int类型，第二个参数是函数指针类型，该函数指针指向的函数参数是int,返回类型是void，signal函数的返回类型也是一个函数指针，该函数指针指向的函数参数是int,返回类型是void。

4. 函数指针数组

比如：int (*p[3])(int x,int y);这里p是指数组，p中存放的是函数指针。

使用场景（模拟计算器）：

#include <stdio.h>
int add(int a, int b)
{
	return a + b;
}
int sub(int a, int b)
{
	return a - b;
}
int mul(int a, int b)
{
	return a * b;
}
int div(int a, int b)
{
	return a / b;
}
int main()
{
	int x, y;
	int input = 1;
	int ret = 0;
	//函数指针数组
	int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; 
	while (input)
	{
		printf("*************************\n");
		printf(" 1:add     2:sub \n");
		printf(" 3:mul     4:div \n");
		printf("*************************\n");
		printf("请选择：");
		scanf("%d", &input);
		if ((input <= 4 && input >= 1))
		{
			printf("输入操作数：");
			scanf("%d %d", &x, &y);
			ret = (*p[input])(x, y);
			//ret = p[input](x,y);
		}
		else
			printf("输入有误\n");
		printf("ret = %d\n", ret);
	}
	return 0;
}

5. 指向函数指针数组的指针

函数指针数组：int (*p[3])(int x,int y);
指向函数指针数组的指针：int ( * (*p)[3])(int x,int y);

6. 回调函数

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的用于对该事件或条件进行响应。

上述模拟计算器可以这样来写（利用回调函数）：

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}

int Sub(int x, int y)
{
	return x - y;
}

int Mul(int x, int y)
{
	return x * y;
}

int Div(int x, int y)
{
	return x / y;
}

void menu()
{
	printf("***************************\n");
	printf("***** 1.add    2. sub  ****\n");
	printf("***** 3.mul    4. div  ****\n");
	printf("***** 0.exit           ****\n");
	printf("***************************\n");
}

void calc(int (*p)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入2个操作数:>");
	scanf("%d %d", &x, &y);
	//回调函数
	ret = p(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);		
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:	
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
}

6.1.qsort库函数

初步了解：

再次理解：

qsort库函数可以对任意类型数据进行排序，其原理类似于快速排序。
base：待排序数组的起始地址
num:待排序数据的元素个数
size:待排序数组的元素的大小
int (* compare)(const void*,const void*): 比较两个元素的大小的函数指针

6.1.1 qsort库函数排序整型数组

int compare(const void* a, const void* b)
{
	return *(int*)a - *(int*)b;
}
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	int arr[5] = { 2,3,4,1,5 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(int), compare);
	print(arr, sz);
	return 0;
}

6.1.2 qsort库函数排序结构体数据

6.1.2.1 按照名字大小来排序

struct stu
{
	char name[20];
	int age;
};

int cmp_by_name(const void* a, const void* b)
{
	return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name);
}

void print(struct stu s[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s\n", s[i].name);
	}
}

int main()
{
	struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
	int sz = sizeof(s) / sizeof(s[0]);
	//按照名字比较
	qsort(s, sz, sizeof(s[0]), cmp_by_name);
	print(s, sz);
	return 0;
}

6.1.2.2 按照年龄来排序

struct stu
{
	char name[20];
	int age;
};

int cmp_by_age(const void* a, const void* b)
{
	return (((struct stu*)a)->age - ((struct stu*)b)->age);
}

void print(struct stu s[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", s[i].age);
	}
}

int main()
{
	struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
	int sz = sizeof(s) / sizeof(s[0]);
	//按照年龄比较
	qsort(s, sz, sizeof(s[0]), cmp_by_age);
	print(s, sz);
	return 0;
}

6.2 实现冒泡排序对任意类型的排序

6.2.1 对整型排序

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}

void Swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a,const void* b))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size)> 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size,size);
			}
		}
	}
}

void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}

int main()
{
	int arr[] = { 2,1,3,7,5,9,6,8,0,4 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]),cmp_int);
	print(arr, sz);

	return 0;
}

6.2.2 对结构体排序

6.2.2.1 按照年龄进行排序


struct stu
{
	char name[20];
	int age;
};

int cmp_by_age(const void* a, const void* b)
{
	return (((struct stu*)a)->age - ((struct stu*)b)->age);
}

void Swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print(struct stu s[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", s[i].age);
	}
}

int main()
{
	struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
	int sz = sizeof(s) / sizeof(s[0]);
	//按照年龄比较
	qsort(s, sz, sizeof(s[0]), cmp_by_age);
	print(s, sz);
	return 0;
}

6.2.2.2 按照名字排序

struct stu
{
	char name[20];
	int age;
};

int cmp_by_name(const void* a, const void* b)
{
	return strcmp(((struct stu*)a)->name, ((struct stu*)b)->name);
}

void Swap(char* buf1, char* buf2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort(void* base, int sz, int size, int (*cmp)(const void* a, const void* b))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				//交换
				Swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}

void print(struct stu s[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%s ", s[i].name);
	}
}

int main()
{
	struct stu s[] = { {"zhangsan",20},{"lisi",55},{"wangwu",40} };
	int sz = sizeof(s) / sizeof(s[0]);
	//按照年龄比较
	qsort(s, sz, sizeof(s[0]), cmp_by_name);
	print(s, sz);
	return 0;
}