3． 傳遞函數(shù)指針

從上篇文章中我們知道，函數(shù)名本身就代表一個地址，在這個地址中存儲著函數(shù)體中定義的一連串指令碼，只要給這個地址后面加上一個調(diào)用符（小括號），就進入這個函數(shù)中執(zhí)行。在實際程序中，函數(shù)名常常作為函數(shù)參數(shù)來進行傳遞。

熟悉C＋＋的小伙伴都知道，在標準庫中對容器類型的數(shù)據(jù)進行各種算法操作時，可以傳入用戶自己的提供的算法函數(shù)（如果不傳入函數(shù)，標準庫就使用默認的）。

下面是一個示例代碼，對一個 int 行的數(shù)組進行排序，排序函數(shù) demo3＿handle＿data 的最后一個參數(shù)是一個函數(shù)指針，因此需要傳入一個具體的排序算法函數(shù)。示例中有 2 個候選函數(shù)可以使用：

降序排列： 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）        ｛            ／／ 調(diào)用傳入的排序函數(shù)            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）；    ／／ 調(diào)用排序函數(shù)，需要傳遞排序算法函數(shù)    ／／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（＂＂）；｝這個就不用畫圖了，函數(shù)指針 pf 就指向了傳入的那個函數(shù)地址，在排序的時候直接調(diào)用就可以了。
4． 指向結構體的指針

在嵌入式開發(fā)中，指向結構體的指針使用特別廣泛，這里以智能家居中的一條控制指令來舉例。在一個智能家居系統(tǒng)中，存在各種各樣的設備（插座、電燈、電動窗簾等），每個設備的控制指令都是不一樣的，因此可以在每個設備的控制指令結構體中的最前面，放置所有指令都需要的、通用的成員變量，這些變量可以稱為指令頭（指令頭中包含一個代表命令類型的枚舉變量）。

當處理一條控制指令時，先用一個通用命令（指令頭）的指針來接收指令，然后根據(jù)命令類型枚舉變量來區(qū)分，把控制指令強制轉換成具體的那個設備的數(shù)據(jù)結構，這樣就可以獲取到控制指令中特定的控制數(shù)據(jù)了。

本質上，與 Java／C＋＋ 中的接口、基類的概念類似。

／／ 指令類型枚舉typedef enum ＿CMD＿TYPE＿ ｛    CMD＿TYPE＿CONTROL＿SWITCH ＝ 1，    CMD＿TYPE＿CONTROL＿LAMP，｝ CMD＿TYPE；
／／ 通用的指令數(shù)據(jù)結構（指令頭）typedef struct ＿CmdBase＿ ｛    CMD＿TYPE cmdType； ／／ 指令類型    int deviceId；     ／／ 設備 Id｝ CmdBase；
typedef struct ＿CmdControlSwitch＿ ｛    ／／ 前 2 個參數(shù)是指令頭    CMD＿TYPE cmdType；       int deviceId；        ／／ 下面都有這個指令私有的數(shù)據(jù)    int slot；  ／／ 排插上的哪個插口    int state； ／／ 0：斷開， 1：接通｝ CmdControlSwitch；
typedef struct ＿CmdControlLamp＿ ｛    ／／ 前 2 個參數(shù)是指令頭    CMD＿TYPE cmdType；    int deviceId；        ／／ 下面都有這個指令私有的數(shù)據(jù)    int color；      ／／ 顏色    int brightness； ／／ 亮度｝ CmdControlLamp；
／／ 參數(shù)是指令頭指針void demo4＿control＿device（CmdBase ＊pcmd）｛    ／／ 根據(jù)指令頭中的命令類型，把指令強制轉換成具體設備的指令    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． 函數(shù)指針數(shù)組

這個示例在上篇文章中演示過，為了完整性，這里再貼一下。

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． 在結構體中使用柔性數(shù)組

先不解釋概念，我們先來看一個代碼示例：

／／ 一個結構體，成員變量 data 是指針typedef struct ＿ArraryMemberStruct＿NotGood＿ ｛    int num；    char ＊data；｝ ArraryMemberStruct＿NotGood；
void demo6＿not＿good（）｛    ／／ 打印結構體的內(nèi)存大小    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 個字節(jié)（int 型占 4 個字節(jié)，指針型占 4 個字節(jié)）。

結構體中的 data 成員是一個指針變量，需要單獨為它申請一塊空間才可以使用。而且在結構體使用之后，需要先釋放 data，然后釋放結構體指針 ams，順序不能錯。這樣使用起來，是不是有點麻煩？

于是，C99 標準就定義了一個語法：flexible array member（柔性數(shù)組），直接上代碼（下面的代碼如果編譯時遇到警告，請檢查下編譯器對這個語法的支持）：

／／ 一個結構體，成員變量是未指明大小的數(shù)組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 單獨分配空間了；釋放空間時，直接釋放結構體指針即可；

是不是用起來簡單多了？！這就是柔性數(shù)組的好處。

從語法上來說，柔性數(shù)組就是指結構體中最后一個元素個數(shù)未知的數(shù)組，也可以理解為長度為 0，那么就可以讓這個結構體稱為可變長的。

前面說過，數(shù)組名就代表一個地址，是一個不變的地址常量。在結構體中，數(shù)組名僅僅是一個符號而已，只代表一個偏移量，不會占用具體的空間。

另外，柔性數(shù)組可以是任意類型。這里示例大家多多體會，在很多通訊類的處理場景中，常常見到這種用法。

7． 通過指針來獲取結構體中成員變量的偏移量

這個標題讀起來似乎有點拗口，拆分一下：在一個結構體變量中，可以利用指針操作的技巧，獲取某個成員變量的地址、距離結構體變量的開始地址、之間的偏移量。

在 Linux 內(nèi)核代碼中你可以看到很多地方都利用了這個技巧，代碼如下：

＃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(chǎn)）；    printf（＂＆os－＞b ＝ 0x％x ＂， ＆os．b）；    printf（＂＆os－＞c ＝ 0x％x ＂， ＆os．c）；    printf（＂＝＝＝＝＝ ＂）；    ／／ 打印成員變量地址，與結構體變量開始地址，之間的偏移量    printf（＂offset： a ＝ ％d ＂， （char ＊）＆os．a(chǎn) － （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 行的打印信息不需要解釋了，直接看下面這個內(nèi)存模型即可理解。

下面這個語句也不需要多解釋，就是把兩個地址的值進行相減，得到距離結構體變量開始地址的偏移量，注意：需要把地址強轉成 char＊ 型之后，才可以相減。

printf（＂offset： a ＝ ％d ＂， （char ＊）＆os．a(chǎn) － （char ＊）＆os）；

下面這條語句需要好好理解：

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

數(shù)字 0 看成是一個地址，也就是一個指針。上篇文章解釋過，指針就代表內(nèi)存中的一塊空間，至于你把這塊空間里的數(shù)據(jù)看作是什么，這個隨便你，你只要告訴編譯器，編譯器就按照你的意思去操作這些數(shù)據(jù)。

現(xiàn)在我們把 0 這個地址里的數(shù)據(jù)看成是一個 OffsetStruct 結構體變量（通過強制轉換來告訴編譯器），這樣就得到了一個 OffsetStruct 結構體指針（下圖中綠色橫線），然后得到該指針變量中的成員變量 a（藍色橫線），再然后通過取地址符 ＆ 得到 a 的地址（橙色橫線），最后把這個地址強轉成 size＿t 類型（紅色橫線）。

因為這個結構體指針變量是從 0 地址開始的，因此，成員變量 a 的地址就是 a 距離結構體變量開始地址的偏移量。

上面的描述過程，如果感覺拗口，請結合下面這張圖再讀幾遍：

上面這張圖如果能看懂的話，那么最后一種通過宏定義獲取偏移量的打印語句也就明白了，無非就是把代碼抽象成宏定義了，方便調(diào)用：

＃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 內(nèi)核中的（大家平常沒事時多挖掘，可以發(fā)現(xiàn)很多好東西）。

＃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(chǎn) ＝ ％d， os．b ＝ ％d， os．c ＝ ％d ＂， os．a(chǎn)， os．b， os．c）；
   printf（＂＝＝＝＝＝ ＂）；        ／／ 假設只知道某個成員變量的地址    int ＊pc ＝ ＆os．c；    OffsetStruct ＊p ＝ NULL；        ／／ 根據(jù)成員變量的地址，得到結構體變量的地址    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）；｝

先看打印結果：

首先要清楚宏定義中參數(shù)的類型：

ptr： 成員變量的指針；type： 結構體類型；member：成員變量的名稱；

這里的重點就是理解宏定義 container＿of，結合下面這張圖，把宏定義拆開來進行描述：

宏定義中的第 1 條語句分析：

綠色橫線：把數(shù)字 0 看成是一個指針，強轉成結構體 type 類型；藍色橫線：獲取該結構體指針中的成員變量 member；橙色橫線：利用 typeof 關鍵字，獲取該 member 的類型，然后定義這個類型的一個指針變量 ＿＿mptr；紅色橫線：把宏參數(shù) ptr 賦值給 ＿＿mptr 變量；

宏定義中的第 2 條語句分析：

綠色橫線：利用 demo7 中的 offset 宏定義，得到成員變量 member 距離結構體變量開始地址的偏移量，而這個成員變量指針剛才已經(jīng)知道了，就是 ＿＿mptr；藍色橫線：把 ＿＿mptr 這個地址，減去它自己距離結構體變量開始地址的偏移量，就得到了該結構體變量的開始地址；橙色橫線：最后把這個指針（此時是 char＊ 型），強轉成結構體 type 類型的指針；

三、總結

上面這 8 個關于指針的用法掌握之后，再去處理子字符、數(shù)組、鏈表等數(shù)據(jù)，基本上就是熟練度和工作量的問題了。希望大家都能用好指針這個神器，提高程序程序執(zhí)行效率。

面對代碼，永無bug；面對生活，春暖花開！祝您好運！

原創(chuàng)不易，如果這篇文章有幫助，請轉發(fā)、分享給您的朋友，道哥在此表示感謝！

【原創(chuàng)聲明】

作者：道哥