3． 传递函数指针

从上篇文章中我们知道，函数名本身就代表一个地址，在这个地址中存储着函数体中定义的一连串指令码，只要给这个地址后面加上一个调用符（小括号），就进入这个函数中执行。在实际程序中，函数名常常作为函数参数来进行传递。

熟悉C＋＋的小伙伴都知道，在标准库中对容器类型的数据进行各种算法操作时，可以传入用户自己的提供的算法函数（如果不传入函数，标准库就使用默认的）。

下面是一个示例代码，对一个 int 行的数组进行排序，排序函数 demo3＿handle＿data 的最后一个参数是一个函数指针，因此需要传入一个具体的排序算法函数。示例中有 2 个候选函数可以使用：

降序排列： demo3＿algorithm＿decend；升序排列： demo3＿algorithm＿ascend；typedef int BOOL；＃define FALSE 0＃define TRUE  1
BOOL demo3＿algorithm＿decend（int a， int b）｛    return a ＞ b；｝
BOOL demo3＿algorithm＿ascend（int a， int b）｛    return a ＜ b；｝
typedef BOOL （＊Func）（int， int）；void demo3＿handle＿data（int ＊data， int size， Func pf）｛    for （int i ＝ 0； i ＜ size － 1； ＋＋i）    ｛        for （int j ＝ 0； j ＜ size － 1 － i； ＋＋j）        ｛            ／／ 调用传入的排序函数            if （pf（data［j］， data［j＋1］））            ｛                int tmp ＝ data［j］；                data［j］ ＝ data［j ＋ 1］；                data［j ＋ 1］ ＝ tmp；            ｝        ｝    ｝｝
void demo3（）｛    int a［5］ ＝ ｛5， 1， 9， 2， 6｝；    int size ＝ sizeof（a）／sizeof（int）；    ／／ 调用排序函数，需要传递排序算法函数    ／／demo3＿handle＿data（a， size， demo3＿algorithm＿decend）； ／／ 降序排列    demo3＿handle＿data（a， size， demo3＿algorithm＿ascend）；   ／／ 升序排列    for （int i ＝ 0； i ＜ size； ＋＋i）        printf（＂％d ＂， a［i］）；    printf（＂＂）；｝这个就不用画图了，函数指针 pf 就指向了传入的那个函数地址，在排序的时候直接调用就可以了。
4． 指向结构体的指针

在嵌入式开发中，指向结构体的指针使用特别广泛，这里以智能家居中的一条控制指令来举例。在一个智能家居系统中，存在各种各样的设备（插座、电灯、电动窗帘等），每个设备的控制指令都是不一样的，因此可以在每个设备的控制指令结构体中的最前面，放置所有指令都需要的、通用的成员变量，这些变量可以称为指令头（指令头中包含一个代表命令类型的枚举变量）。

当处理一条控制指令时，先用一个通用命令（指令头）的指针来接收指令，然后根据命令类型枚举变量来区分，把控制指令强制转换成具体的那个设备的数据结构，这样就可以获取到控制指令中特定的控制数据了。

本质上，与 Java／C＋＋ 中的接口、基类的概念类似。

／／ 指令类型枚举typedef enum ＿CMD＿TYPE＿ ｛    CMD＿TYPE＿CONTROL＿SWITCH ＝ 1，    CMD＿TYPE＿CONTROL＿LAMP，｝ CMD＿TYPE；
／／ 通用的指令数据结构（指令头）typedef struct ＿CmdBase＿ ｛    CMD＿TYPE cmdType； ／／ 指令类型    int deviceId；     ／／ 设备 Id｝ CmdBase；
typedef struct ＿CmdControlSwitch＿ ｛    ／／ 前 2 个参数是指令头    CMD＿TYPE cmdType；       int deviceId；        ／／ 下面都有这个指令私有的数据    int slot；  ／／ 排插上的哪个插口    int state； ／／ 0：断开， 1：接通｝ CmdControlSwitch；
typedef struct ＿CmdControlLamp＿ ｛    ／／ 前 2 个参数是指令头    CMD＿TYPE cmdType；    int deviceId；        ／／ 下面都有这个指令私有的数据    int color；      ／／ 颜色    int brightness； ／／ 亮度｝ CmdControlLamp；
／／ 参数是指令头指针void demo4＿control＿device（CmdBase ＊pcmd）｛    ／／ 根据指令头中的命令类型，把指令强制转换成具体设备的指令    if （CMD＿TYPE＿CONTROL＿SWITCH ＝＝ pcmd－＞cmdType）    ｛        ／／ 类型强制转换        CmdControlSwitch ＊cmd ＝ pcmd；        printf（＂control switch． slot ＝ ％d， state ＝ ％d ＂， cmd－＞slot， cmd－＞state）；    ｝    else if （CMD＿TYPE＿CONTROL＿LAMP ＝＝ pcmd－＞cmdType）    ｛        ／／ 类型强制转换        CmdControlLamp ＊ cmd ＝ pcmd；        printf（＂control lamp．   color ＝ 0x％x， brightness ＝ ％d ＂， cmd－＞color， cmd－＞brightness）；    ｝｝
void demo4（）｛    ／／ 指令1：控制一个开关    CmdControlSwitch cmd1 ＝ ｛CMD＿TYPE＿CONTROL＿SWITCH， 1， 3， 0｝；    demo4＿control＿device（＆cmd1）；
   ／／ 指令2：控制一个灯泡    CmdControlLamp cmd2 ＝ ｛CMD＿TYPE＿CONTROL＿LAMP， 2， 0x112233， 90｝；    demo4＿control＿device（＆cmd2）；｝
5． 函数指针数组

这个示例在上篇文章中演示过，为了完整性，这里再贴一下。

int add（int a， int b） ｛ return a ＋ b； ｝int sub（int a， int b） ｛ return a － b； ｝int mul（int a， int b） ｛ return a ＊ b； ｝int divide（int a， int b） ｛ return a ／ b； ｝
void demo5（）｛    int a ＝ 4， b ＝ 2；    int （＊p［4］）（int， int）；    p［0］ ＝ add；    p［1］ ＝ sub；    p［2］ ＝ mul；    p［3］ ＝ divide；    printf（＂％d ＋ ％d ＝ ％d ＂， a， b， p［0］（a， b））；    printf（＂％d － ％d ＝ ％d ＂， a， b， p［1］（a， b））；    printf（＂％d ＊ ％d ＝ ％d ＂， a， b， p［2］（a， b））；    printf（＂％d ／ ％d ＝ ％d ＂， a， b， p［3］（a， b））；｝
6． 在结构体中使用柔性数组

先不解释概念，我们先来看一个代码示例：

／／ 一个结构体，成员变量 data 是指针typedef struct ＿ArraryMemberStruct＿NotGood＿ ｛    int num；    char ＊data；｝ ArraryMemberStruct＿NotGood；
void demo6＿not＿good（）｛    ／／ 打印结构体的内存大小    int size ＝ sizeof（ArraryMemberStruct＿NotGood）；    printf（＂size ＝ ％d ＂， size）；
   ／／ 分配一个结构体指针    ArraryMemberStruct＿NotGood ＊ams ＝ （ArraryMemberStruct＿NotGood ＊）malloc（size）；    ams－＞num ＝ 1；
   ／／ 为结构体中的 data 指针分配空间    ams－＞data ＝ （char ＊）malloc（1024）；    strcpy（ams－＞data， ＂hello＂）；    printf（＂ams－＞data ＝ ％s ＂， ams－＞data）；
   ／／ 打印结构体指针、成员变量的地址    printf（＂ams ＝ 0x％x ＂， ams）；    printf（＂ams－＞num  ＝ 0x％x ＂， ＆ams－＞num）；    printf（＂ams－＞data ＝ 0x％x ＂， ams－＞data）；
   ／／ 释放空间    free（ams－＞data）；    free（ams）；｝

在我的电脑上，打印结果如下：

可以看到：该结构体一共有 8 个字节（int 型占 4 个字节，指针型占 4 个字节）。

结构体中的 data 成员是一个指针变量，需要单独为它申请一块空间才可以使用。而且在结构体使用之后，需要先释放 data，然后释放结构体指针 ams，顺序不能错。这样使用起来，是不是有点麻烦？

于是，C99 标准就定义了一个语法：flexible array member（柔性数组），直接上代码（下面的代码如果编译时遇到警告，请检查下编译器对这个语法的支持）：

／／ 一个结构体，成员变量是未指明大小的数组typedef struct ＿ArraryMemberStruct＿Good＿ ｛    int num；    char data［］；｝ ArraryMemberStruct＿Good；
void demo6＿good（）｛    ／／ 打印结构体的大小    int size ＝ sizeof（ArraryMemberStruct＿Good）；    printf（＂size ＝ ％d ＂， size）；
   ／／ 为结构体指针分配空间    ArraryMemberStruct＿Good ＊ams ＝ （ArraryMemberStruct＿Good ＊）malloc（size ＋ 1024）；
   strcpy（ams－＞data， ＂hello＂）；    printf（＂ams－＞data ＝ ％s ＂， ams－＞data）；
   ／／ 打印结构体指针、成员变量的地址    printf（＂ams ＝ 0x％x ＂， ams）；    printf（＂ams－＞num  ＝ 0x％x ＂， ＆ams－＞num）；    printf（＂ams－＞data ＝ 0x％x ＂， ams－＞data）；
   ／／ 释放空间    free（ams）；｝

打印结果如下：

与第一个例子中有下面几个不同点：

结构体的大小变成了 4；为结构体指针分配空间时，除了结构体本身的大小外，还申请了 data 需要的空间大小；不需要为 data 单独分配空间了；释放空间时，直接释放结构体指针即可；

是不是用起来简单多了？！这就是柔性数组的好处。

从语法上来说，柔性数组就是指结构体中最后一个元素个数未知的数组，也可以理解为长度为 0，那么就可以让这个结构体称为可变长的。

前面说过，数组名就代表一个地址，是一个不变的地址常量。在结构体中，数组名仅仅是一个符号而已，只代表一个偏移量，不会占用具体的空间。

另外，柔性数组可以是任意类型。这里示例大家多多体会，在很多通讯类的处理场景中，常常见到这种用法。

7． 通过指针来获取结构体中成员变量的偏移量

这个标题读起来似乎有点拗口，拆分一下：在一个结构体变量中，可以利用指针操作的技巧，获取某个成员变量的地址、距离结构体变量的开始地址、之间的偏移量。

在 Linux 内核代码中你可以看到很多地方都利用了这个技巧，代码如下：

＃define offsetof（TYPE， MEMBER） （（size＿t） ＆（（（TYPE＊）0）－＞MEMBER））
typedef struct ＿OffsetStruct＿ ｛    int a；    int b；    int c；｝ OffsetStruct；
void demo7（）｛    OffsetStruct os；    ／／ 打印结构体变量、成员变量的地址    printf（＂＆os ＝ 0x％x ＂， ＆os）；    printf（＂＆os－＞a ＝ 0x％x ＂， ＆os．a）；    printf（＂＆os－＞b ＝ 0x％x ＂， ＆os．b）；    printf（＂＆os－＞c ＝ 0x％x ＂， ＆os．c）；    printf（＂＝＝＝＝＝ ＂）；    ／／ 打印成员变量地址，与结构体变量开始地址，之间的偏移量    printf（＂offset： a ＝ ％d ＂， （char ＊）＆os．a － （char ＊）＆os）；    printf（＂offset： b ＝ ％d ＂， （char ＊）＆os．b － （char ＊）＆os）；    printf（＂offset： c ＝ ％d ＂， （char ＊）＆os．c － （char ＊）＆os）；    printf（＂＝＝＝＝＝ ＂）；    ／／ 通过指针的强制类型转换来获取偏移量    printf（＂offset： a ＝ ％d ＂， （size＿t） ＆（（OffsetStruct＊）0）－＞a）；    printf（＂offset： b ＝ ％d ＂， （size＿t） ＆（（OffsetStruct＊）0）－＞b）；    printf（＂offset： c ＝ ％d ＂， （size＿t） ＆（（OffsetStruct＊）0）－＞c）；    printf（＂＝＝＝＝＝ ＂）；    ／／ 利用宏定义来得到成员变量的偏移量    printf（＂offset： a ＝ ％d ＂， offsetof（OffsetStruct， a））；    printf（＂offset： b ＝ ％d ＂， offsetof（OffsetStruct， b））；    printf（＂offset： c ＝ ％d ＂， offsetof（OffsetStruct， c））；｝

先来看打印结果：

前面 4 行的打印信息不需要解释了，直接看下面这个内存模型即可理解。

下面这个语句也不需要多解释，就是把两个地址的值进行相减，得到距离结构体变量开始地址的偏移量，注意：需要把地址强转成 char＊ 型之后，才可以相减。

printf（＂offset： a ＝ ％d ＂， （char ＊）＆os．a － （char ＊）＆os）；

下面这条语句需要好好理解：

printf（＂offset： a ＝ ％d ＂， （size＿t） ＆（（OffsetStruct＊）0）－＞a）；

数字 0 看成是一个地址，也就是一个指针。上篇文章解释过，指针就代表内存中的一块空间，至于你把这块空间里的数据看作是什么，这个随便你，你只要告诉编译器，编译器就按照你的意思去操作这些数据。

现在我们把 0 这个地址里的数据看成是一个 OffsetStruct 结构体变量（通过强制转换来告诉编译器），这样就得到了一个 OffsetStruct 结构体指针（下图中绿色横线），然后得到该指针变量中的成员变量 a（蓝色横线），再然后通过取地址符 ＆ 得到 a 的地址（橙色横线），最后把这个地址强转成 size＿t 类型（红色横线）。

因为这个结构体指针变量是从 0 地址开始的，因此，成员变量 a 的地址就是 a 距离结构体变量开始地址的偏移量。

上面的描述过程，如果感觉拗口，请结合下面这张图再读几遍：

上面这张图如果能看懂的话，那么最后一种通过宏定义获取偏移量的打印语句也就明白了，无非就是把代码抽象成宏定义了，方便调用：

＃define offsetof（TYPE， MEMBER） （（size＿t） ＆（（（TYPE＊）0）－＞MEMBER））
printf（＂offset： a ＝ ％d ＂， offsetof（OffsetStruct， a））；

可能有小伙伴提出：获取这个偏移量有什么用啊？那就请接着看下面的示例 8。

8． 通过结构体中成员变量的指针，来获取该结构体的指针

标题同样比较拗口，直接结合代码来看：

typedef struct ＿OffsetStruct＿ ｛    int a；    int b；    int c；｝ OffsetStruct；

假设有一个 OffsetStruct 结构体变量 os，我们只知道 os 中成员变量 c 的地址（指针），那么我们想得到变量 os 的地址（指针），应该怎么做？这就是标题所描述的目的。

下面代码中的宏定义 container＿of 同样是来自于 Linux 内核中的（大家平常没事时多挖掘，可以发现很多好东西）。

＃define container＿of（ptr， type， member） （｛      const typeof（ （（type ＊）0）－＞member ） ＊＿＿mptr ＝ （ptr）；      （type ＊）（ （char ＊）＿＿mptr － offsetof（type，member） ）；｝）
void demo8（）｛    ／／ 下面 3 行仅仅是演示 typeof 关键字的用法    int n ＝ 1；    typeof（n） m ＝ 2；  ／／ 定义相同类型的变量m    printf（＂n ＝ ％d， m ＝ ％d ＂， n， m）；
   ／／ 定义结构体变量，并初始化    OffsetStruct os ＝ ｛1， 2， 3｝；        ／／ 打印结构体变量的地址、成员变量的值（方便后面验证）    printf（＂＆os ＝ 0x％x ＂， ＆os）；    printf（＂os．a ＝ ％d， os．b ＝ ％d， os．c ＝ ％d ＂， os．a， os．b， os．c）；
   printf（＂＝＝＝＝＝ ＂）；        ／／ 假设只知道某个成员变量的地址    int ＊pc ＝ ＆os．c；    OffsetStruct ＊p ＝ NULL；        ／／ 根据成员变量的地址，得到结构体变量的地址    p ＝ container＿of（pc， OffsetStruct， c）；        ／／ 打印指针的地址、成员变量的值    printf（＂p ＝ 0x％x ＂， p）；    printf（＂p－＞a ＝ ％d， p－＞b ＝ ％d， p－＞c ＝ ％d ＂， p－＞a， p－＞b， p－＞c）；｝

先看打印结果：

首先要清楚宏定义中参数的类型：

ptr： 成员变量的指针；type： 结构体类型；member：成员变量的名称；

这里的重点就是理解宏定义 container＿of，结合下面这张图，把宏定义拆开来进行描述：

宏定义中的第 1 条语句分析：

绿色横线：把数字 0 看成是一个指针，强转成结构体 type 类型；蓝色横线：获取该结构体指针中的成员变量 member；橙色横线：利用 typeof 关键字，获取该 member 的类型，然后定义这个类型的一个指针变量 ＿＿mptr；红色横线：把宏参数 ptr 赋值给 ＿＿mptr 变量；

宏定义中的第 2 条语句分析：

绿色横线：利用 demo7 中的 offset 宏定义，得到成员变量 member 距离结构体变量开始地址的偏移量，而这个成员变量指针刚才已经知道了，就是 ＿＿mptr；蓝色横线：把 ＿＿mptr 这个地址，减去它自己距离结构体变量开始地址的偏移量，就得到了该结构体变量的开始地址；橙色横线：最后把这个指针（此时是 char＊ 型），强转成结构体 type 类型的指针；

三、总结

上面这 8 个关于指针的用法掌握之后，再去处理子字符、数组、链表等数据，基本上就是熟练度和工作量的问题了。希望大家都能用好指针这个神器，提高程序程序执行效率。

面对代码，永无bug；面对生活，春暖花开！祝您好运！

原创不易，如果这篇文章有帮助，请转发、分享给您的朋友，道哥在此表示感谢！

【原创声明】

作者：道哥