函数指针:函数名本身即函数指针,指向函数的入口地址。
函数指针的定义:返回值类型 (*函数指针名)(形参列表类型) = 函数名;
函数指针的调用:函数指针名(实参列表);
等价于函数名(实参列表);
示例:
void func(int param1, double param2, char param3){
...}
//定义函数指针
//返回值类型 (*函数指针名)(形参列表) = 函数名;
void (*pFunc)(int, double, char) = func;
函数指针数组的定义:
返回值类型 (* 函数指针数组名[数组元素个数])(形参列表类型);
。
示例:
int func1(int a){
return a + 1;
}
int func2(int b){
return b - 2;
}
int func3(int c){
return c * 3;
}
//定义函数指针数组
int (*func_arr[3])(int);
func_arr[0] = func1;
func_arr[1] = func2;
func_arr[2] = func3;
void func(int a, char b){...}
先定义函数类型,再通过函数类型定义函数指针变量。
定义:
typedef void(FUNC_TYPE)(int, char);
FUNC_TYPE *pFunc = func;
调用:
pFunc(1 , 'a');
注:
FUNC_TYPE
返回值类型void,形参列表类型为(int, char)。
先定义函数指针的类型,再通过函数指针类型定义函数指针变量。
定义:
typedef void(*FUNC_POINTER_TYPE)(int, char);
FUNC_POINTER_TYPE pFunc = func;
调用:
pFunc(2 , 'b');
返回值类型 (*函数指针名)(形参列表类型) = 函数名;
定义:
void (*pFunc)(int, char) = func;
调用:
pFunc(3 , 'c');
应用:
向用户提供通用的函数接口,使用函数指针作为函数形参(接收用户自定义的回调函数),并使用万能指针类型参数void *
接收任意数据类型的地址。在通用的函数接口内部,将数据传递给用户自定义的回调函数进行处理。
当用户调用该通用的函数接口时,具体指定传递的数据和回调函数(名)。
示例:实现任意数据类型元素的打印
#include
/* 对外提供通用的函数接口 */
//参数void* info:接收任意数据类型的地址
//参数void (* doPrint)(void *):函数指针,接收回调函数(名)
void printInfo(void* info, void (* doPrint)(void *)) {
doPrint(info);
}
//回调函数1-打印字符串
void printString(void* info) {
char* str = (char*)info;
printf("%s\n", str);
}
struct Object {
int field;
char attr[64];
};
//回调函数2-打印结构体
void printStruct(void* info) {
struct Object* obj = (struct Object*)(info);
printf("%d--%s\n", obj->field, obj->attr);
}
int main(){
//创建字符串变量
char str[64] = "HelloWorld";
//调用通用接口打印信息,进一步调用回调函数1:printString
//由用户传递指定的指针类型数据和函数指针(回调函数)
printInfo(str, printString); //HelloWorld
struct Object obj = {
10, "New" };
//调用通用接口打印信息,进一步调用回调函数2:printStruct
//由用户传递指定的指针类型数据和函数指针(回调函数)
printInfo(&obj, printStruct); //10--New
return 0;
}
#include
/* 提供对外的通用接口,打印任意类型的数组 */
/*
arr:数组指针
elemSize:数组元素的大小
arrLength:数组长度
void (*doPrint)(void*):用户自定义的回调函数,打印指定类型的数组元素
*/
void printInfo(void* arr, int elemSize, int arrLength, void (*doPrint)(void*)) {
//强转为char*类型,将指针的步长置为1
char* p = (char *)arr;
//printf()函数的format表达式需指定类型,无法打印任意数据类型
//for (int i = 0; i < arrLength; i++) {
// printf("%d\n", *((int*)(p + elemSize * i)));
//}
//将printf()函数在回调函数中调用,由用户指定具体类型
for (int i = 0; i < arrLength; i++) {
char* elemAddr = p + elemSize * i;
doPrint(elemAddr);
}
}
//回调函数1-打印整型数据
void printIntArr(void* info) {
int* p = (int*)info;
printf("%d\n", *p);
}
struct Object {
int field;
char attr[64];
};
//回调函数2-打印结构体数据
void printStruct(void* info) {
struct Object* obj = (struct Object*)(info);
printf("%d--%s\n", obj->field, obj->attr);
}
int main() {
int arr[] = {
1, 2 ,3 ,4 ,5 };
printInfo(arr, sizeof(int), sizeof(arr)/sizeof(int), printIntArr);
struct Object objs[] = {
{
1, "Tom"}, {
2, "Jerry"}, {
3, "Lucy"}, {
4, "Lily"} };
printInfo(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), printStruct);
return 0;
}
#include
#include
#include
/* 提供对外的通用接口,在任意类型的数组中查找指定元素 */
/*
arr:数组指针
elemSize:数组元素的大小
arrLength:数组长度
target:指向指定元素的指针
void (*doCompare)(void*, void*):用户自定义的回调函数,比较两元素是否相同
*/
bool findElement(void* arr, int elemSize, int arrLength, void* target ,bool (*doCompare)(void*, void*)) {
//强转为char*类型,将指针的步长置为1
char* p = (char*)arr;
for (int i = 0; i < arrLength; i++) {
char* elemAddr = p + elemSize * i; //当前数组元素的地址
//if ((*(int*)elemAddr == *(int*)target) //数组元素类型固定
/* 将元素比较的操作放在回调函数中,由用户指定具体类型 */
if (doCompare(elemAddr, target)) {
return true;
}
}
return false;
}
//回调函数1-比较整型数据
bool compareInt(void* data1, void* data2){
return *(int*)data1 == *(int*)data2;
}
struct Object {
int field;
char attr[64];
};
//回调函数2-比较结构体数据
bool compareStruct(void* data1, void* data2) {
struct Object* obj1 = (struct Object*)(data1);
struct Object* obj2 = (struct Object*)(data2);
return (strcmp(obj1->attr, obj2->attr) == 0) && (obj1->field == obj2->field);
}
int main() {
int arr[] = {
1, 2 ,3 ,4 ,5 };
int target = 6;
bool flag1 = findElement(arr, sizeof(int), sizeof(arr) / sizeof(int), &target, compareInt);
if (flag1) {
printf("元素%d存在\n", target);
}
else {
printf("元素%d不存在\n", target);
}
struct Object objs[] = {
{
1, "Tom"}, {
2, "Jerry"}, {
3, "Lucy"}, {
4, "Lily"} };
struct Object obj = {
3, "Newsom" };
bool flag2 = findElement(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), &obj, compareStruct);
if (flag2) {
printf("元素%s--%d存在\n", obj.attr, obj.field);
}
else {
printf("元素%s--%d不存在\n", obj.attr, obj.field);
}
return 0;
}
需求:使用冒泡排序算法,实现对任意数据类型数组元素的降序排序。
#include
#include
#include
/* 提供对外的通用接口,实现对任意数据类型数组元素的降序排序 */
/*
arr:数组指针
elemSize:数组元素的大小
arrLength:数组长度
target:指向指定元素的指针
void (*doCompare)(void*, void*):用户自定义的回调函数,比较两元素的大小(降序)
*/
void sortArray(void* arr, int elemSize, int arrLength, bool (*doCompare)(void*, void*)) {
//申请elemSize大小的堆区空间,用于memcpy交换元素
//强转为char*类型,将指针的步长置为1
char* temp = (char *)malloc(elemSize);
for (int i = 0; i < arrLength - 1; i++) {
for (int j = 0; j < arrLength - i - 1; j++) {
char* cur = (char*)arr + elemSize * j; //当前元素
char* next = (char*)arr + elemSize * (j + 1); //下一个元素
//此写法:数组元素类型固定,无法扩展
//if (*(int *)cur < *(int *)next) {}
/* 将元素比较的操作放在回调函数中,由用户指定具体类型 */
if (doCompare(cur, next)) {
//通过内存拷贝函数memcpy,实现元素交换
memcpy(temp, cur, elemSize);
memcpy(cur, next, elemSize);
memcpy(next, temp, elemSize);
}
}
}
}
//回调函数1-比较整型数据(降序)
bool compareInt(void* data1, void* data2) {
return *(int*)data1 < *(int*)data2;
}
struct Object {
int field;
char attr[64];
};
//回调函数2-比较结构体数据
bool compareStruct(void* data1, void* data2) {
struct Object* obj1 = (struct Object*)(data1);
struct Object* obj2 = (struct Object*)(data2);
return obj1->field < obj2->field;
}
int main() {
int arr[] = {
1, 2 ,3 ,4 ,5 };
sortArray(arr, sizeof(int), sizeof(arr) / sizeof(int), compareInt);
for (int i = 0; i < sizeof(arr) / sizeof(int); i++) {
printf("%d\n", arr[i]);
}
//5 4 3 2 1
struct Object objs[] = {
{
1, "Tom"}, {
2, "Jerry"}, {
3, "Lucy"}, {
4, "Lily"} };
sortArray(objs, sizeof(struct Object), sizeof(objs) / sizeof(struct Object), compareStruct);
for (int i = 0; i < sizeof(objs) / sizeof(struct Object); i++) {
printf("%s--%d\n", objs[i].attr, objs[i].field);
}
//Lily--4 Lucy--3 Jerry--2 Tom--1
return 0;
}