指针的进阶

目录

一、指针数组

二、数组指针

1、数组指针定义：

2、数组指针的使用

三、 数组参数、指针参数

1、一维数组传参

2、二维数组传参

四、函数指针

五、函数指针数组

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

七、回调函数

---

 

一、指针数组

指针数组是一个存放指针的数组

int* arr1[10]; //整形指针的数组

char *arr2[4]; //一级字符指针的数组

char **arr3[5];//二级字符指针的数组

二、数组指针

1、数组指针定义：

int (*p)[10];

//解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个 指针，指向一个数组，叫数组指针。

//这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

 

整型指针 - 指向整型的指针 - 存放整型变量的地址

int* p1;

字符指针 - 指向字符的指针 - 存放字符变量的地址

char* p2;

/数组指针 - 指向数组的指针 - 存放的是数组的地址

2、数组指针的使用

void print4(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < r; i++)
	{
		int j = 0;
		for (j = 0; j < c; j++)
		{
			printf("%d ", *(*(p + i) + j));
		}
		printf("\n");
	}
}
 
void test2()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
	print4(arr, 3, 5);
}

三、 数组参数、指针参数

1、一维数组传参

数组传参：形参可以是数组，也可以是指针

 最后 ** arr为二级指针，可以接收指针数组的地址

2、二维数组传参

四、函数指针

int Add(int x, int y)
{
   return x + y;
}
int main()
{
//pf就是函数指针变量

   int (*pf)(int x, int y) = &Add;//int (*)(int,int)就是函数指针的类型

   int (* pf)(int x, int y) = Add;//其中的*是便于理解，*的有无与多少对结果的输出没有影响

   int sum = (*pf)(3, 5);

  
}

拓展：

//( *( void (*)() )0 )()——把0当做一个函数的地址

//把0直接转换成一个void (*)()的函数指针，然后去调用0地址处的函数

//void(*signal(int, void(*)(int)))(int);

 //上述代码是一次函数声明

 //声明的函数叫：signal

//signal函数的第一个参数是int类型的

//signal函数的第二个参数是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void

//signal函数的返回类型也是一个函数指针类型，该函数指针指向的函数参数是int，返回类型是void

五、函数指针数组

函数指针数组可以存放多个【参数相同、返回类型相同】的函数的地址

使用函数指针数组来代替Switch实现计算器

//整数的加、减、乘、除
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");
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		
		switch (input)
		{
		case 1:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Add(x, y);
			printf("%d\n", ret);
			break;
		case 2:	
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Sub(x, y);
			printf("%d\n", ret);
			break;
		case 3:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Mul(x, y);
			printf("%d\n", ret);
		break;
		case 4:
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = Div(x, y);
			printf("%d\n", ret);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);
}

//简化一下代码
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");
}

int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//函数指针数组   - 转移表
	int (*pfArr[])(int, int) = { 0, Add, Sub, Mul, Div };

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
			break;
		}

		if (input >= 1 && input <= 4)
		{
			printf("请输入2个操作数:>");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n", ret);
		}
		else
		{
			printf("选择错误\n");
		}	
	} while (input);
}

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

指向函数指针数组的指针是一个指针，指针指向一个数组 ，数组的元素都是函数指针；

七、回调函数

定义：

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

qsort的引入：

qsort 可以排序任意类型的数据

void qsort（void* base，size_t num，size_t size，int（*）（const void*，const void*））

//void qsort(void* base, //待排序数据的起始地址

                   size_t num, //待排序数据的元素个数

                   size_t size, //待排序数据元素的大小（单位是字节）

                   int (*cmp)(const void*, const void*) //比较2个元素大小的函数指针

                   );

qsort的使用：

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

int cmp_stu_by_name(const void* e1, const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}

int cmp_stu_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

//测试qsort排序结构体数据
void test3()
{
	struct Stu s[] = { {"zhangsan", 20}, {"lisi", 55}, {"wangwu", 40}};
	//按照名字比较
	int sz = sizeof(s) / sizeof(s[0]);
	//qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}

对qsort的模拟实现：

 

#include<stdio.h>
int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

void bubble_sort2(void* base, int sz, int width, int (*cmp)(const void* e1, const void* e2))//void*的指针是非常宽容的，可以接收任意类型的地址，但其他类型不能接受void*
{
	int i = 0;
	//趟数
	for (i = 0; i < sz - 1; i++)
	{
		//一趟冒泡排序的过程
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			//强制类型转换为char类型，因void类型指针不能解引用
			if (cmp((char*)base + j * width, (char*)base + (j + 1) * width) > 0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);//width为元素大小
			}
		}
	}
}
void print(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

void test4()
{
	int arr[] = { 486,589,849,648,797,974,8595 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort2(arr, sz, sizeof(arr[0]), cmp_int);
	print(arr, sz);
}
int main()
{
	test4();
	return 0;
}