进化论——从函数指针到被结构封装的函数指针及参数的应用举例

✎ 编 者 悟 语

        借口再小也会瓦解人的意志。

文 章 导 读

    今天带大家用下函数指针，然后将函数指针和函数参数封装到结构体中，接着将数据用动态分配和静态分配的方式赋值给相应的函数，从而实现比较灵活的函数封装和调用的目的。

1

函数指针

#include <stdio.h>#include <stdlib.h>
// 图省事，函数定义在main函数前了int TestFun1(int val1, int val2){ return (val1 + val2); }
int TestFun2(int val1, int val2){ return (val1 - val2); }
// 定义函数指针fun指向 int(*)(int,int)类型的函数int (*fun)(int val1, int val2);
int main(int argc,char *argv[]){    // 指向要操作的函数，并赋值参数 fun = TestFun1; printf('testFun1 = %d\n',(*fun)(2,1));
fun = TestFun2; printf('testFun2 = %d\n',(*fun)(2,1));    
}


    运行结果：

      

关于int (*fun)(int,int)需要说明下，其为定义一个函数指针fun，它指向返回值为int，两个参数类型都是int的函数。即fun指向的函数类型为 int(*)(int,int)，也可以说fun是int(*)(int,int)型的指针。

2

结构封装函数指针及参数

    1）动态分配方式调用

#include <stdio.h>#include <stdlib.h>
// 指针fun指向 int (*)(int , int )的函数typedef int (*fun)(int val1, int val2);   // 定义封装的函数及参数typedef struct{    int val1;    int val2;    fun function;  }TestStruct_t;
int TestFun1(int val1, int val2){    return (val1 + val2);  }
int TestFun2(int val1, int val2){    TestStruct_t t;      // 调用函数TestFun1，与TestFun2参数交叉使用，实际中根据需要来    t.function = TestFun1;    t.val1 = val1 + 1;    t.val2 = (*(t.function))(t.val1, val2); // t.val1 + val2 = val1 + 1 + val2      return (t.val2 - t.val1);               // t.val2 - t.val1 = (val1 + 1 + val2) - (val1 + 1) = val2}
// 定义testStruct_t类型的二维数组,动态分配时没用TestStruct_t testArray[2][3] ={    {3,      2,     TestFun1},      {4,      5,     TestFun2}      };

int main(int argc,char *argv[]){    // 动态分配空间    TestStruct_t *pMap = malloc(sizeof(testStruct_t));        // 给动态分配的空间赋值    pMap->val1 = 4;    pMap->val2 = 6;    // TestFun2 处理结构是获得参数val2的值，只是为了演示没有啥实际意义    pMap->function = TestFun2;         // 指定参数获得指向函数的返回值      printf('%d',(*(pMap->function))(pMap->val1, pMap->val2));  }

    运行结果：

      

TestFun2利用封装的结构体类型引入TestFun1函数，利用结构体分装方便切换函数。

    2）静态分配方式调用

#include <stdio.h>#include <stdlib.h>
// fun 指向 int (*)(int , int )typedef int (*fun)(int val1, int val2); // 定义封装的函数及参数typedef struct{ int val1; int val2; fun function; }TestStruct_t;
int TestFun1(int val1, int val2){ return (val1 + val2); }
int TestFun2(int val1, int val2){    TestStruct_t t; // 调用函数TestFun1，与TestFun2参数交叉使用，实际中根据需要来 t.function = TestFun1; t.val1 = val1 + 1; t.val2 = (*(t.function))(t.val1, val2); // t.val1 + val2 = val1 + 1 + val2 return (t.val2 - t.val1); // t.val2 - t.val1 = (val1 + 1 + val2) - (val1 + 1) = val2}

TestStruct_t testArray[2][3] ={    {3,      2,      TestFun1},      {4,      5,      TestFun2}      };

int main(int argc,char *argv[]){ TestStruct_t *pMap; //利用数组的静态空间即可，不用动态分配了 // testStruct_t *pMap = malloc(sizeof(testStruct_t)); pMap = testArray[1]; //将数组第二行的首地址赋给testStruct_t类型的指针pMap

// 用数组中的值赋值，不用下面的赋值了 /* pMap->val1 = 4; pMap->val2 = 6; pMap->function = TestFun2;*/ printf('\nThe value of TestFun2 is:%d\n',(*(pMap->function))(pMap->val1, pMap->val2)); }

    运行结果：

      

可以看出，在此实例中动态分配与静态分配主要差别在内存分配方式和赋值形式上。

总结

    总的来说，不封装的函数指针调用函数还是比较清晰的，但做比较大的项目的时候有时需要灵活的将函数及参数封装起来，一是方便管理，二是运用灵活。