1. 函数指针

函数名 VS &函数名

对于数组而言，数组名=首元素地址,&数组名=整个数组的地址

那么函数名和&函数名等于什么

#include <stdio.h>
void test()
{
	;
}
int main()
{
	test();
	printf("%p\n", test);
	printf("%p\n", &test);

}

注：函数名和&函数名不能+-整数

指针进阶2 - 指针和函数

结论是：函数名和&函数名一样 = 函数的地址

什么是函数指针

既然函数名=函数地址，就可以用一个变量进行存储

这个变量就是函数指针，存储一个函数地址的变量

#include <stdio.h>
int test(int x, int y)
{
	;
}
int main()
{
	int(*ptr)(int, int) = test; 
}

这里的ptr就是一个函数指针

(*ptr)，表示ptr是一个指针变量，(int, int), 表示ptr存储的是一个函数的地址，这个函数有两个int类型的参数，(*ptr)前面的int, 表示这个函数的返回类型为int整形

函数指针的应用

#include <stdio.h>
int test(int x, int y)
{
	return x + y;
}
int main()
{
	int(*ptr)(int, int) = test;
	int ret = (*ptr)(1,2);
	printf("%d\n", ret);
}

指针进阶2 - 指针和函数

*ptr表示通过地址访问空间 ---> 得到函数的地址 ---> 传值(1,2) ---> 得到结果3 ---> 打印

函数指针作为参数

// 使用冒泡排序，排序任意类型数组
#include <string.h>
#include <stdio.h>
struct Stu
{
	char name[10];
	int age;
};

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

// 以年龄比较
int cmp_by_name(const void* e1,const void* e2)
{
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
// 以名字比较
int cmp_by_age(const void* e1, const void* e2)
{
	return ((struct Stu*)e1)->age - ((struct Stu*)e2)->age;
}

// 交换
void swap(char* buf1, char* buf2, int width)
{
	while (width--)
	{
		char tmp = *buf1;
		*buf1 = *buf2;
		*buf2 = tmp;
		buf1++;
		buf2++;
	}
}

// 排序
void bubble_sort(void* base, size_t sz, size_t width, int (*cmp)(const void* e1, const void* e2))
{
	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*width), (char*)base+((j+1)*width)) > 0)
			{
				swap((char*)base + (j * width), (char*)base + ((j + 1) * width), width);
			}
		}
	}
}

 //排序整形数组
void sort_int()
{
	int arr[10] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz, sizeof(arr[0]), cmp_int);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
}

// 排序结构体数组
void sort_struct()
{
	struct Stu t1[5] = { {"c",5 }, { "a",4 }, { "b",3 }, { "e",2 }, { "d",1 } };
	int sz = sizeof(t1) / sizeof(t1[0]);
	bubble_sort(t1, sz, sizeof(t1[0]), cmp_by_name); // 以名字排序
	//bubble_sort(t1, sz, sizeof(t1[0]), cmp_by_age);// 以年龄排序

}

int main()
{
	//sort_int();
	sort_struct();
}

2. 函数指针数组

什么是函数指针数组

首先梳理一下概念，数组是一组相同类型元素的集合，函数指针是存储函数地址的变量

所以函数指针数组，就是存储一组函数地址的集合

#include <stdio.h>
void test1()
{
	;
}
void test2()
{
	;
}
void test3()
{
	;
}
int main()
{
	void(*ptr[3])() = { test1,test2,test3 };
}

void (* ptr[3] )() , 如何理解 ?

ptr首先会与[3]结合，表示ptr是一个数组，数组有3个元素

void (* ptr[3] )() ---> void (*)(),

(*) 表示数组的每一个元素是一个指针，()表示这个指针是一个函数指针且函数没有参数，void表示函数返回值为空

函数指针数组的应用

#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("1.add	2.sub\n");
	printf("3.mul	4.div\n");
}

int main()
{
	int(*ptr[5])(int, int) = { 0,add,sub,mul,div }; //函数指针数组
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	do 
	{
		menu();
		printf("输入: ");
		scanf("%d", &input);
		if (input > 4 || input <= 0)
		{
			printf("退出程序\n");
		}
		else
		{
			printf("输入x: ");
			scanf("%d", &x);
			printf("输入y: ");
			scanf("%d", &y);
			ret = (ptr[input])(x, y); //通过input，锁定函数地址，最后传参得到结果
			printf("%d\n", ret);
		}
	} while (input);
}

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

直接看代码

#include <stdio.h>
int main()
{	
	int arr[10] = { 0 }; // 整形数组
	int(*pa)[10] = &arr; // 数组指针，指向数组的指针

	int(*pf[10])(int, int); // 函数指针数组
	int(*(*ppf)[10])(int,int)= &pf // 指向函数指针数组的地址	 
}

既然可以用&操作符取出一个整形数组的地址，那么也可以取出一个函数指针数组的地址

所以，指向函数指针数组的指针就是存储整个函数指针数组的地址的变量

int (* (*ppf) [10] ) (int, int) 如何理解 ?

(*ppf), 表示ppf是一个指针, [10]表示这个指针存储一个数组的地址，数组有10个元素，int (*) (int, int), 表示数组的每一个元素是一个函数指针

原文链接：https://www.cnblogs.com/xumu11291/p/17134666.html

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：指针进阶2 – 指针和函数 - Python技术站