一直覺得C語言較其他語言最偉大的地方就是C語言中的指針，有些人認為指針很簡單，而有些人認為指針很難，當然這里的對簡單和難并不是等價于對指針的理解程度。

為此在這里對C語言中的指針進行全面的總結，從底層的內存分析，徹底讓讀者明白指針的本質。

一、指針變量

首先讀者要明白指針是一個變量，為此作者寫了如下代碼來驗證之：

#include "stdio.h"

int main(int argc, char **argv)
{
    unsigned int a = 10;
    unsigned int *p = NULL;
    p = &a;
    printf("&a=%d\n",a);
    printf("&a=%d\n",&a);
    *p = 20;
    printf("a=%d\n",a);
    return 0;
}

運行后可以看到a的值被更改了，上面的例子可以清楚的明白指針實質上是一個放置變量地址的特殊變量，其本質仍然是變量。

既然指針是變量，那必然會有變量類型，因此這里必須對變量類型做解釋。在C語言中，所有的變量都有變量類型，整型、浮現型、字符型、指針類型、結構體、聯合體、枚舉等，這些都是變量類型。

變量類型的出現是內存管理的必然結果，相信讀者知道，所有的變量都是保存在計算機的內存中，既然是放到計算機的內存中，那必然會占用一定的空間。

問題來了，一個變量會占用多少空間呢，或者說應該分出多少內存空間來放置該變量呢？

為了規定這個，類型由此誕生了，對于32位編譯器來說，int類型占用4個字節，即32位，long類型占用8字節，即64位。

這里簡單說了類型主要是為后面引出指針這個特殊性，在計算機中，將要運行的程序都保存在內存中，所有的程序中的變量其實就是對內存的操作。

計算機的內存結構較為簡單，這里不詳細談論內存的物理結構，只談論內存模型。

將計算機的內存可以想象為一個房子，房子里面居住著人，每一個房間對應著計算機的內存地址，內存中的數據就相當于房子里的人。

既然指針也是一個變量，那個指針也應該被存放在內存中，對于32位編譯器來說，其尋址空間為2^32=4GB，為了能夠都操作所有內存（實際上普通用戶不可能操作所有內存），指針變量存放也要用32位數即4個字節。

這樣就有指針的地址&p，指針和變量的關系可以用如下圖表示：

從上圖可以看到&p是指針的地址，用來存放指針p，而指針p來存放變量a的地址，也就是&a，還有一個*p在C語言中是解引，意思是告訴編譯器取出該地址存放的內容。

上面提到過關于指針類型的問題，針對32位編譯器而言，既然任何指針都只占用4個字節，那為何還需要引入指針類型呢？

僅僅是為了約束相同類型的變量么？實際上這里不得不提到指針操作，先思考如下兩個操作：

上面兩個操作的意思是不同的，先說下第一種：p+1操作，如下圖所示：

對于不同類型指針而言，其p+1所指向的地址不同，這個遞增取決于指針類型所占的內存大小，而對于((unsigned int)p)+1。

該意思是將地址p所指向的地址的值直接轉換為數字，然后+1，這樣無論p是何種類型的指針，其結果都是指針所指的地址后一個地址。

從上述可以看到，指針的存在使得程序員可以相當輕松的操作內存，這也使得當前有些人認為指針相當危險，這一觀點表現在C#和Java語言中，然而實際上用好指針可以極大的提高效率。

下面深入一點來通過指針對內存進行操作，現在我們需要對內存6422216中填入一個數據125，我們可以如下操作：

unsigned int *p=(unsigned int*)(6422216);
*p=125;

當然，上面的代碼使用了一個指針，實際上C語言中可以直接利用解引操作對內存進行更方便的賦值，下面說下解引操作*。

二、解引用

所謂解引操作，實際上是對一個地址操作，比如現在想將變量a進行賦值，一般操作是a=125，現在我們用解引操作來完成，操作如下：

*(&a)=125;

上面可以看到解引操作符為*，這個操作符對于指針有兩個不同的意義，當在申明的時候是申明一個指針，而當在使用p指針時是解引操作，解引操作右邊是一個地址，這樣解引操作的意思就是該地址內存中的數據。這樣我們對內存6422216中填入一個數據125就可以使用如下操作：

*(unsigned int*)(6422216)=125;

上面需要將6422216數值強制轉換為一個地址，這個是告訴編譯器該數值是一個地址。值得注意的是上面的所有內存地址不能隨便指定，必須是計算機已經分配的內存，否則計算機會認為指針越界而被操作系統殺死即程序提前終止。

三、結構體指針

結構體指針和普通變量指針一樣，結構體指針只占4個字節（32位編譯器）,只不過結構體指針可以很容易的訪問結構體類型中的任何成員，這就是指針的成員運算符->。

上圖中p是一個結構體指針，p指向的是一個結構體的首地址，而p->a可以用來訪問結構體中的成員a，當然p->a和*(p)是相同的。

四、強制類型轉換

為何要在這里提強制類型轉換呢，上面的測試代碼可以看到編譯器會報很多警告，意思是告訴程序員數據類型不匹配，雖然并不影響程序的正確運行，但是很多警告總會讓人感到難受。

因此為了告訴編譯器代碼這里沒有問題，程序員可以使用強制類型轉換來將一段內存轉換為需要的數據類型，例如下面有一個數組a，現在將其強制轉換為一個結構體類型stu：

#include <stdio.h>

typedef struct STUDENT
{
    int      name;
    int    gender;
}stu;

int a[100]={10,20,30,40,50};

int main(int argc, char **argv)
{
    stu *student;
    student=(stu*)a;
    printf("student->name=%d\n",student->name);
    printf("student->gender=%d\n",student->gender);
    return 0;
}

上面的程序運行結果如下：

可以看到a[100]被強制轉換為stu結構體類型，當然不使用強制類型轉換也是可以的，只是編譯器會報警報。

上圖為程序的示意圖，圖中數組a[100]的前12個字節被強制轉換為了一個struct stu類型，上面僅對數組進行了說明，其它數據類型也是一樣的，本質上都是一段內存空間。

五、void指針

為何在這里單獨提到空指針類型呢？主要是因為該指針類型很特殊。

void類型很容易讓人想到是空的意思，但對于指針而言，其并不是指空，而是指不確定。

在很多時候指針在申明的時候可能并不知道是什么類型或者該指針指向的數據類型有多種再或者程序員僅僅是想通過一個指針來操作一段內存空間。這個時候可以將指針申明為void類型。

但是問題來了，由于void類型原因，對于確定的數據類型解引時，編譯器會根據類型所占的空間來解引相應的數據，例如int p，那么p就會被編譯器解引為p指針的地址的4個字節的空間大小。

但對于空指針類型來說，編譯器如何知道其要解引的內存大小呢？先看一段代碼：

#include <stdio.h>

int main(int argc, char **argv)
{
    int a=10;
    void *p;
    p=&a;
    printf("p=%d\n",*p);
    return 0;
}

編譯上面的程序會發現，編譯器報錯，無法正常編譯。

這說明編譯器確實是在解引時無法確定*p的大小，因此這里必須告訴編譯器p的類型或者*p的大小，如何告訴呢？很簡單，用強制類型轉換即可，如下：

*(int*)p

這樣上面的程序就可以寫為如下：

#include <stdio.h>

int main(int argc, char **argv)
{
    int a=10;
    void *p;
    p=&a;
    printf("p=%d\n",*(int*)p);
    return 0;
}

編譯運行后：

可以看到結果確實是正確的，也和預期的想法一致。由于void指針沒有空間大小屬性，因此void指針也沒有++操作。

六、函數指針

1. 函數指針使用

函數指針在Linux內核中用的非常多，而且在設計操作系統的時候也會用到，因此這里將詳細講解函數指針。既然函數指針也是指針，那函數指針也占用4個字節（32位編譯器）。

下面以一個簡單的例子說明：

#include <stdio.h>

int  add(int a,int b)
{
    return a+b;
}

int main(int argc, char **argv)
{
    int (*p)(int,int);
    p=add;
    printf("add(10,20)=%d\n",(*p)(10,20));
    return 0;
}

程序運行結果如下：

可以看到，函數指針的申明為：

函數指針的解引操作與普通的指針有點不一樣。

對于普通的指針而言，解引只需要根據類型來取出數據即可，但函數指針是要調用一個函數，其解引不可能是將數據取出，實際上函數指針的解引本質上是執行函數的過程，只是這個執行函數是使用的call指令并不是之前的函數，而是函數指針的值，即函數的地址。

其實執行函數的過程本質上也是利用call指令來調用函數的地址，因此函數指針本質上就是保存函數執行過程的首地址。函數指針的調用如下：

為了確認函數指針本質上是傳遞給call指令一個函數的地址，下面用一個簡單例子說明：

上面是編譯后的匯編指令，可以看到，使用函數指針來調用函數時，其匯編指令多了如下：

0x4015e3    mov    DWORD PTR [esp+0xc],0x4015c0
0x4015eb    mov    eax,DWORD PTR [esp+0xc]
0x4015ef    call   eax

分析：第一行mov指令將立即數0x4015c0賦值給寄存器esp+0xc的地址內存中，然后將寄存器esp+0xc地址的值賦值給寄存器eax(累加器），然后調用call指令，此時pc指針將會指向add函數，而0x4015c0正好是函數add的首地址，這樣就完成了函數的調用。

細心的讀者是否發現一個有趣的現象，上述過程中函數指針的值和參數一樣是被放在棧幀中，這樣看起來就是一個參數傳遞的過程。

因此可以看到，函數指針最終還是以參數傳遞的形式傳遞給被調用的函數，而這個傳遞的值正好是函數的首地址。

從上面可以看到函數指針并不是和一般的指針一樣可以操作內存，因此作者覺得函數指針可以看作是函數的引用申明。

2. 函數指針應用

在linux驅動面向對象編程思想中用的最多，利用函數指針來實現封裝，下面以一個簡單的例子說明：

#include <stdio.h>

typedef struct TFT_DISPLAY
{
    int   pix_width;
    int   pix_height;
    int   color_width;
    void (*init)(void);
    void (*fill_screen)(int color);
    void (*tft_test)(void);

}tft_display;

static void init(void)
{
    printf("the display is initialed\n");
}

static void fill_screen(int color)
{
    printf("the display screen set 0x%x\n",color);

}

tft_display mydisplay=
{
    .pix_width=320,
    .pix_height=240,
    .color_width=24,
    .init=init,
    .fill_screen=fill_screen,
};

int main(int argc, char **argv)
{

    mydisplay.init();
    mydisplay.fill_screen(0xfff);
    return 0;
}

上面的例子將一個tft_display封裝成一個對象，上面的結構體成員中最后一個沒有初始化，這在Linux中用的非常多。

最常見的是file_operations結構體，該結構體一般來說只需要初始化常見的函數，不需要全部初始化。

上面代碼中采用的結構體初始化方式也是在Linux中最常用的一種方式，這種方式的好處在于無需按照結構體的順序一對一。

3. 回調函數

有時候會遇到這樣一種情況，當上層人員將一個功能交給下層程序員完成時，上層程序員和下層程序員同步工作，這個時候該功能函數并未完成，這個時候上層程序員可以定義一個API來交給下層程序員。

而上層程序員只要關心該API就可以了而無需關心具體實現，具體實現交給下層程序員完成即可（這里的上層和下層程序員不指等級關系，而是項目的分工關系）。

這種情況下就會用到回調函數（Callback Function），現在假設程序員A需要一個FFT算法，這個時候程序員A將FFT算法交給程序員B來完成，現在來讓實現這個過程：

#include <stdio.h>

int  InputData[100]={0};
int OutputData[100]={0};

void FFT_Function(int *inputData,int *outputData,int num)
{
    while(num--)
    {

    }
}

void TaskA_CallBack(void (*fft)(int*,int*,int))
{

    (*fft)(InputData,OutputData,100);
}

int main(int argc, char **argv)
{

    TaskA_CallBack(FFT_Function);
    return 0;
}

上面的代碼中TaskA_CallBack是回調函數，該函數的形參為一個函數指針，而FFT_Function是一個被調用函數。

可以看到回調函數中申明的函數指針必須和被調用函數的類型完全相同。