C语言函数指针和回调函数

 彻底搞定C指针－函数名与函数指针

函数名&函数名取地址

函数指针

通常我们可以将指针指向某类型的变量，称为类型指针（如，整型指针）。若将一个指针指向函数，则称为函数指针。

函数名的意义

函数名代表函数的入口地址，同样的，我们可以通过根据该地址进行函数调用，而非直接调用函数名。

void test001(){
    printf("hello, world");
}

int main(){

    printf("函数入口地址：%d", test001);//qt中的函数入口地址不会变，C中会变，这里仅为了说明问题
    //test001();
    int *testADD = (int *)20123883;//将地址转化为int型指针
    void(*myfunc)() = testADD;//将函数写成函数指针，有些书上会写&testADD
    myfunc(); //调用函数指针
    system("pause");
    return 0;
}

另外，还有以下结论：

（1）test001的函数名与myfunc函数指针都是一样的，即都是函数指针。test001函数名是一个函数指针常量，而myfunc是一个函数指针变量，这是它们的关系。

int test001(int a, char b){
    printf("hello, world
");
    return 0;
}

int main(){

    int(*myFun)(int, char) = test001;
    myFun = test001;

    //下面四种表达式的结果是相同的
    int a = 10;
    char b = 's';
    myFun(a, b);
    (*myFun)(a, b);
    test001(a, b);
    (*test001)(a, b);

    system("pause");
    return 0;
}

（2）testADD和&testADD的值一样，但表达的含义不同，与数组名和“&数组名”类似，详见指针和数组的关系。

定义函数指针

定义函数指针最简单的是直接定义函数指针变量，另外还有定义函数类型和定义函数指针类型。

int test001(int a, char b){
    printf("hello, world
");
    return 0;
}

void test002(){

    //定义函数类型
    typedef int(Fun)(int, char);
    Fun *funFir = test001;

    //定义函数指针类型
    typedef int(*FunP)(int, char);
    FunP funSec = test001;

    //定义函数指针变量
    int(*funThi)(int, char) = NULL;//若报错，在强制转型，(int(*)(int , char))NULL
    funThi = test001;
}

函数指针用于形参

这种用法通常出现在回调函数中，一般回调函数用于定制操作，下面的例子将说明如何进行定制操作

/*
-----------------------
函数指针用作另一个函数的参数
-----------------------
*/
int con1(int a, int b){
    return a + b;
}

int con2(int a, int b){
    return a - b;
}

int con3(int a, int b){
    return a + b + 10;
}

//在函数体中显式调用函数，将失去灵活性
//尽管我可以用switch实现三种con的切换
void doc(){
    int a = 10;
    int b = 20;
    int ret = con1(a, b);
}

//用如下的调用方式，调用者并不知道调用的哪个函数
//因此根据函数指针的函数原型可以自己实现新函数，并进行调用
int doc_p(int(*temp)(int ,char)){
    int a = 10;
    int b = 20;
    int ret = temp(a,b);
    return ret;
}

/*
---------------------
函数指针数组
---------------------
*/
void func1(){
    printf("a");
}
void func2(){
    printf("a");
}
void func3(){
    printf("a");
}

void test003(){
    int(*func[3])();
    func[0] = func1;
    func[1] = func2;
    func[2] = func3;

    for (int i = 0; i < 3; ++i)
    {
        func[i];
    }
}

为什么我们要把函数作为参数来调用呢，直接在函数体里面调用不好吗？

在这个意义上，“把函数做成参数”和“把变量做成参数”目的是一致的，就是以不变应万变。形参是不变的，而实参是可以定制的。唯一不同的是，普通的实参可以由计算机程序自动产生，而函数这种参数计算机程序是无法自己写出来的，因为函数本身就是程序，它必须由人来写。所以对于回调函数这种参数而言，它的“变”在于人有变或者人的需求有变。

回调函数

回调函数和普通函数完成的功能是一样的，但回调函数更灵活，普通函数在函数体中调用，失去了变量的灵活性，有点类似于模板编程。

（1）首先是通过内存偏移，访问数组的各元素地址，两种方法的结果相同

void printAll(void *arr, int eleSize, int len){
    
    char *start = (char*)arr; //强制转型
    for (int i = 0; i < len; ++i){
        printf("%d
", start+i*eleSize);//内存偏移
    }
}

void test004(){
    int arr[5] = {1,2,3,4,5};
    printAll(arr, sizeof(int), 5);
    printf("-------------------
");
    for (int i = 0; i < 5; ++i){
        printf("%d
", &arr[i]);
    }
}

int main(){
    test004();

    system("pause");
    return 0;
}

（2）对上面的函数用函数指针进行改写

//添加函数指针作形参，必须写明变量名
void printAll(void *arr, int eleSize, int len, void(*print)(void *data)){
    
    char *start = (char*)arr; //强制转型
    for (int i = 0; i < len; ++i){
        char *eleAddr = start + i*eleSize;
        print(eleAddr);
        //print(start+i*eleSize);
    }
}

//自定义的被调用函数
void Myprint(void * data){
    int *p = (int *)data;
    printf("%d
", *p);
}

void test004(){
    int arr[5] = {1,2,3,4,5};
    printAll(arr, sizeof(int), 5, Myprint);
}

int main(){
    test004();

    system("pause");
    return 0;
}

（3）对上面的函数指针添加自定义的数据类型

//添加函数指针作形参，必须写明变量名
void printAll(void *arr, int eleSize, int len, void(*print)(void *data)){
    
    char *start = (char*)arr; //强制转型
    for (int i = 0; i < len; ++i){
        char *eleAddr = start + i*eleSize;
        print(eleAddr);
        //print(start+i*eleSize);
    }
}

//自定义的被调用函数
void Myprint(void * data){
    int *p = (int *)data;
    printf("%d
", *p);
}

struct Person{
    char name[64];
    int age;
};

//添加自定义的数据类型打印函数
void MyprintStruct(void * data){
    struct Person *p = (struct Person  *)data;
    printf("%s,%d
", p->name, p->age);
}




void test004(){
    int arr[5] = {1,2,3,4,5};
    printAll(arr, sizeof(int), 5, Myprint);

    struct Person person[] = {
        {"aaa", 10},
        {"bbb", 20}
    };
    printAll(person, sizeof(struct Person), 2, MyprintStruct);

}

int main(){
    test004();

    system("pause");
    return 0;
}

回调函数最大的优势在于灵活操作，可以实现用户定制的函数，降低耦合性，实现多样性。