前言

最近真的是忙的不可開交，公司一直給安排任務，連學習和寫筆記的時間都沒有了，落下好幾次課的筆記都沒有寫，所以我抽空把目前的進度給追上來，不然會越落越多。加油吧~（感覺身體都要被掏空了）

指標

我們通過指標，可以簡化一些 C 程式設計任務的執行，還有一些任務，如動態記憶體分配，沒有指標是無法執行的。所以，學習指標是很有必要的。
正如您所知道的，每一個變數都有一個記憶體位置，每一個記憶體位置都定義了可使用連字號（&）運算子訪問的地址，它表示了在記憶體中的一個地址。請看下面的例項，它將輸出定義的變數地址：

#include <stdio.h>

int main ()
{
   int
 
  var1;
   char var2[10];

   printf("var1 變數的地址： %x\n", &var1  );
   printf("var2 變數的地址： %x\n", &var2  );

   return 0;
}

當上面的程式碼被編譯和執行時，它會產生下列結果：

var1 變數的地址： bff5a400
var2 變數的地址： bff5a3f6

通過上面的栗子，我們瞭解了什麼是記憶體地址以及如何訪問它。接下來讓我們看看什麼是指標吧！

什麼是指標？

指標是一個變數，其值為另一個變數的地址，即記憶體位置的直接地址。就像其他變數或常量一樣，您必須在使用指標儲存其他變數地址之前，對其進行宣告。指標變數宣告的一般形式為：

type *name;

這裡的type 是指標的基型別，它必須是一個有效的 C 資料型別，name 是指標變數的名稱。用來宣告指標的星號 * 與乘法中使用的星號是相同的。但是，在這個語句中，星號是用來指定一個變數是指標。以下是有效的指標宣告：

int    *ip;    /* 一個整型的指標 */
double *dp;    /* 一個 double 型的指標 */
float  *fp;    /* 一個浮點型的指標 */
char   *ch     /* 一個字元型的指標 */

所有指標的值的實際資料型別，不管是整型、浮點型、字元型，還是其他的資料型別，都是一樣的，都是一個代表記憶體地址的長的十六進位制數。不同資料型別的指標之間唯一的不同是，指標所指向的變數或常量的資料型別不同。

如何使用指標？

• 使用指標時會頻繁進行以下幾個操作：定義一個指標變數、把變數地址賦值給指標、訪問指標變數中可用地址的值。這些是通過使用一元運算子 * 來返回位於運算元所指定地址的變數的值。下面的例項涉及到了這些操作：

#include <stdio.h>
//指標
//指標儲存的是變數的記憶體地址
//記憶體地址，系統給資料分配的編號（門牌號）

void main(){
    int i = 90;
    //指標變數，建立一個int型別的指標
    int* p = &i; //p的值就是i這個變數的記憶體地址
    printf("%#x\n",p);

    float f = 89.5f;
    //建立一個float型別的指標
    float *fp = &f;
    printf("%#x\n", fp);

    system("pause");
}

上面的程式碼被編譯和執行時，執行的結果：

0xeffb30
0xeffb18
請按任意鍵繼續. . .

• 對指標存的地址指向的變數進行操作

#include <stdio.h>

void change(int* p){
    *p = 300;
}

//變數名，對記憶體空間上的一段資料的抽象
void main(){
    int i = 90;
    //i = 89;
    //建立一個int型別的指標
    int *p = &i;
    //輸出地址
    printf("p的地址：%#x\n",&p);
    printf("i的地址：%#x\n",&i);
    printf("i的值為：%d\n", i);
    //間接賦值 i = 200;

    //對p存的地址指向的變數進行操作
    //*p = 200;
    //change(p);
    change(&i);  // int *p = &i;
    printf("i的值為：%d\n",i);

    system("pause");
}

上面程式碼編譯執行結果如下：

p的地址：0x6ffdb0
i的地址：0x6ffdbc
i的值為：90
i的值為：300
請按任意鍵繼續. . .

通過上面栗子，我們可以看出，指標所指向的變數值已經被更改了。

C中的NULL 指標

在變數宣告的時候，如果沒有確切的地址可以賦值，為指標變數賦一個 NULL 值是一個良好的程式設計習慣。賦為 NULL 值的指標被稱為空指標。
NULL 指標是一個定義在標準庫中的值為零的常量。請看下面的程式：

#include <stdio.h>

int main ()
{
   int  *ptr = NULL;

   printf("ptr 的值是 %x\n", ptr  );

   return 0;
}

執行結果為：

ptr 的值是 0

在大多數的作業系統上，程式不允許訪問地址為 0 的記憶體，因為該記憶體是作業系統保留的。然而，記憶體地址 0 有特別重要的意義，它表明該指標不指向一個可訪問的記憶體位置。但按照慣例，如果指標包含空值（零值），則假定它不指向任何東西。
如需檢查一個空指標，您可以使用 if 語句，如下所示：

#include <stdio.h>

int main(int argc, char const *argv[]) {

  char *s = "hello";

  if (!s) {
    fprintf(stderr, "s is null\n");
  } else {
    fprintf(stderr, "%s\n", s);
  }

  if (s == NULL) {
    fprintf(stderr, "s is null\n");
  } else {
    fprintf(stderr, "%s\n", s);
  }


  return 0;
}

這兩種方法都能判斷字元指標是否為空，但推薦使用前者。”NULL” 的本質是個巨集，並非是個常量，C99 中甚至可以自行定義，故儘量避免使用它去判斷，當 !s 與 s == NULL 表示同一含義的時候，使用前者吧！

C中的二級指標（多級指標）

指標可以指向一份普通型別的資料，例如 int、double、char 等，也可以指向一份指標型別的資料，例如 int 、double 、char * 等。

如果一個指標指向的是另外一個指標，我們就稱它為二級指標，或者指向指標的指標。
假設有一個 int 型別的變數 a，p1是指向 a 的指標變數，p2 又是指向 p1 的指標變數，它們的關係如下圖所示：

用程式碼表示為：

int a =100;
int *p1 = &a;
int **p2 = &p1;

指標變數也是一種變數，也會佔用儲存空間，也可以使用&獲取它的地址。C語言不限制指標的級數，每增加一級指標，在定義指標變數時就得增加一個星號 * 。p1 是一級指標，指向普通型別的資料，定義時有一個 * ；p2 是二級指標，指向一級指標 p1，定義時有兩個*。

如果再定義一個三級指標 p3，讓它指向 p2，那麼可以這樣寫：

int ***p3 = &p2;

四級指標：

int ****p4 = &p3;

等等，以此類推。。。
不過，經常使用的也就是一級指標和二級指標了。
在獲取指標指向的資料時，一級指標加一個 * ，二級指標加兩個 * ，三級指標加三個 *，以此類推，請看程式碼：

#include <stdio.h>
int main(){
    int a =100;
    int *p1 = &a;
    int **p2 = &p1;
    int ***p3 = &p2;
    printf("%d, %d, %d, %d\n", a, *p1, **p2, ***p3);
    printf("&p2 = %#X, p3 = %#X\n", &p2, p3);
    printf("&p1 = %#X, p2 = %#X, *p3 = %#X\n", &p1, p2, *p3);
    printf(" &a = %#X, p1 = %#X, *p2 = %#X, **p3 = %#X\n", &a, p1, *p2, **p3);
    return 0;
}

編譯並執行結果如下：

以三級指標 p3 為例來分析上面的程式碼。* p3等價於 * ( * (* p3))。* p3 得到的是 p2 的值，也即 p1 的地址；* ( * p3) 得到的是 p1 的值，也即 a 的地址；經過三次“取值”操作後，* ( *(p3)) 得到的才是 a 的值。

假設 a、p1、p2、p3 的地址分別是 0X00A0、0X1000、0X2000、0X3000，它們之間的關係可以用下圖來描述：

方框裡面是變數本身的值，方框下面是變數的地址。

C中指標的運算

指標變數儲存的是地址，本質上是一個整數，可以進行部分運算，例如加法、減法、比較等，請看下面的程式碼：

#include <stdio.h>
//指標的運算，一般在陣列遍歷時才有意義，基於陣列在記憶體中線性排列的方式
void main(){
    //陣列在記憶體中連續儲存
    int ids[] = { 78, 90, 23, 65, 19 };
    //陣列變數名：ids就是陣列的首地址
    printf("%#x\n",ids);
    printf("%#x\n",&ids);
    printf("%#x\n",&ids[0]);
    //指標變數
    int *p = ids;
    printf("%d\n",*p);
    //指標的加法
    p++; //p++向前移動sizeof(資料型別)個位元組
    printf("p的值:%#x\n", p);
    //p--;
    printf("%d\n", *p);
    getchar();
}

編譯並執行的結果如下：

0x5ff7d0
0x5ff7d0
0x5ff7d0
78
p的值:0x5ff7d4
90

從上面的栗子來看，陣列變數名：ids就是陣列的首地址，指標的加法，p++就是向前移動了sizeof(資料型別)個位元組。
我們知道，陣列中的所有元素在記憶體中是連續排列的，如果一個指標指向了陣列中的某個元素，那麼加 1 就表示指向下一個元素，減 1 就表示指向上一個元素，不過C語言並沒有規定變數的儲存方式，如果連續定義多個變數，它們有可能是挨著的，也有可能是分散的，這取決於變數的型別、編譯器的實現以及具體的編譯模式，所以對於指向普通變數的指標，我們往往不進行加減運算，雖然編譯器並不會報錯，但這樣做沒有意義，因為不知道它後面指向的是什麼資料。

下面舉一個栗子，通過指標獲取下一個變數的地址：

#include <stdio.h>
int main(){
    int a = 1, b = 2, c = 3;
    int *p = &c;
    int i;
    for(i=0; i<8; i++){
        printf("%d, ", *(p+i) );
    }
    return 0;
}

編譯並執行結果如下：

3, -858993460, -858993460, 2, -858993460, -858993460, 1, -858993460,

可以看出變數 a、b、c 並不挨著，它們中間還有其他的資料。

指標變數除了可以參與加減運算，還可以參與比較運算。當對指標變數進行比較運算時，比較的是指標變數本身的值，也就是資料的地址。如果地址相等，那麼兩個指標就指向同一份資料，否則就指向不同的資料。
所以總結出，不要對指向普通變數的指標進行加減運算；另外需要說明的是，不能對指標變數進行乘法、除法、取餘等其他運算，除了會發生語法錯誤，也沒有實際的含義。

C中的指標陣列

如果一個數組中的所有元素儲存的都是指標，那麼我們就稱它為指標陣列。指標陣列的定義形式一般為：

dataType *arrayName[length];

]的優先順序高於*，該定義形式應該理解為：

dataType *(arrayName[length]);

括號裡面說明arrayName是一個數組，包含了length個元素，括號外面說明每個元素的型別為dataType *。

除了每個元素的資料型別不同，指標陣列和普通陣列在其他方面都是一樣的，下面是一個簡單的栗子：

#include <stdio.h>
int main(){
    int a = 16, b = 932, c = 100;
    //定義一個指標陣列
    int *arr[3] = {&a, &b, &c};//也可以不指定長度，直接寫作 int *parr[]
    //定義一個指向指標陣列的指標
    int **parr = arr;
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));
    return 0;
}

編譯並執行結果如下：

16, 932, 100
16, 932, 100

arr 是一個指標陣列，它包含了 3 個元素，每個元素都是一個指標，在定義 arr 的同時，我們使用變數 a、b、c 的地址對它進行了初始化，這和普通陣列是多麼地類似。

parr 是指向陣列 arr 的指標，確切地說是指向 arr 第一個元素的指標，它的定義形式應該理解為int * ( * parr)，括號中的 * 表示 parr 是一個指標，括號外面的int * 表示 parr 指向的資料的型別。arr 第一個元素的型別為 int *，
所以在定義 parr 時要加兩個 * （星號）（MD語法自動識別其他的格式了）。

第一個 printf() 語句中，arr[i] 表示獲取第 i 個元素的值，該元素是一個指標，還需要在前面增加一個 * 才能取得它指向的資料，也即 *arr[i] 的形式。

第二個 printf() 語句中，parr+i 表示第 i 個元素的地址，* (parr+i) 表示獲取第 i 個元素的值（該元素是一個指標），**(parr+i) 表示獲取第 i 個元素指向的資料。

通過指標給陣列賦值，下面是一個簡單的栗子：

#include <stdio.h>
void main(){
    int uids[5];
    //高階寫法
    //int i = 0;
    //for (; i < 5; i++){
    //  uids[i] = i;
    //}
    //早些版本的寫法
    int* p = uids;
    printf("%#x\n",p);
    int i = 0; //i是陣列元素的值
    for (; p < uids + 5; p++){
        *p = i;
        i++;
    }

    getchar();
}

C中的指標與二維陣列

二維陣列在概念上是二維的，有行和列，但在記憶體中所有的陣列元素都是連續排列的，它們之間沒有“縫隙”。以下面的二維陣列 a 為例：

int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };

從概念上來理解，陣列a 的分佈如下：

0   1   2   3
4   5   6   7
8   9  10  11

但在記憶體中，a 的分佈是一維線性的，整個陣列佔用一塊連續的記憶體：

C語言中的二維陣列是按行排列的，也就是先存放 a[0] 行，再存放 a[1] 行，最後存放 a[2] 行；每行中的 4 個元素也是依次存放。陣列 a 為 int 型別，每個元素佔用 4 個位元組，整個陣列共佔用 4×(3×4) = 48 個位元組。

C語言允許把一個二維陣列分解成多個一維陣列來處理。對於陣列 a，它可以分解成三個一維陣列，即 a[0]、a[1]、a[2]。每一個一維陣列又包含了 4 個元素，例如 a[0] 包含 a[0][0]、a[0][1]、a[0][2]、a[0][3]。

假設陣列 a 中第 0 個元素的地址為 1000，那麼每個一維陣列的首地址如下圖所示：

為了更好的理解指標和二維陣列的關係，我們先來定義一個指向 a 的指標變數 p：

int (*p)[4] = a;

int *p[4]; //定義一個指標陣列，該陣列中每個元素是一個指標，每個指標指向哪裡就需要程式中後續再定義了。

int (*p)[4]; //定義一個數組指標，該指標指向含4個元素的一維陣列（陣列中每個元素是int型）。

區分int *p[n]; 和int (*p)[n]; 就要看運算子的優先順序了。
int *p[n]; 中，運算子[ ]優先順序高，先與p結合成為一個數組，再由int*說明這是一個整型指標陣列。
int (*p)[n]; 中( )優先順序高，首先說明p是一個指標，指向一個整型的一維陣列。

對指標進行加法（減法）運算時，它前進（後退）的步長與它指向的資料型別有關，p 指向的資料型別是int [4]，那麼p+1就前進 4×4 = 16 個位元組，p-1就後退 16 個位元組，這正好是陣列 a 所包含的每個一維陣列的長度。也就是說，p+1會使得指標指向二維陣列的下一行，p-1會使得指標指向陣列的上一行。

下面我們就來實現如何使用指標 p 來訪問二維陣列中的每個元素。按照上面的定義：

• p指向陣列 a 的開頭，也即第 0 行；p+1前進一行，指向第 1 行。
• *(p+1)表示取地址上的資料，也就是整個第 1 行資料。注意是一行資料，是多個數據，不是第 1 行中的第 0 個元素，下面的執行結果有力地證明了這一點：

#include <stdio.h>
int main(){
    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };
    int (*p)[4] = a;
    printf("%d\n", sizeof(*(p+1)));
    return 0;
}

編譯並執行結果為：

16

那麼，*(p+1)+1表示第 1 行第 1 個元素的地址。這個如何理解呢？（注意，這裡的小細節）

  *(p+1)單獨使用時表示的是第 1 行資料，放在表示式中會被轉換為第 1 行資料的首地址，也就是第 1 行第 0 個元素的地址，因為使用整行資料沒有實際的含義，編譯器遇到這種情況都會轉換為指向該行第 0 個元素的指標；就像一維陣列的名字，在定義時或者和 sizeof、& 一起使用時才表示整個陣列，出現在表示式中就會被轉換為指向陣列第 0 個元素的指標。

* ( *(p+1)+1) 表示第 1 行第 1 個元素的值。很明顯，增加一個 * 表示取地址上的資料。

根據上面的推論，推出以下等價關係：

a+i == p+i
a[i] == p[i] == *(a+i) == *(p+i)
a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)

可能有點繞，不好理解，不過沒關係，多看幾遍，相信你是可以的。

栗子：
使用指標遍歷二維陣列

#include <stdio.h>
int main(){
    int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
    int(*p)[4];
    int i,j;
    p=a;
    for(i=0; i<3; i++){
        for(j=0; j<4; j++) printf("%2d  ",*(*(p+i)+j));
        printf("\n");
    }
    return 0;
}

編譯並執行的結果如下：

 0   1   2   3
 4   5   6   7
 8   9  10  11

指標陣列和二維陣列指標的區別：

指標陣列和二維陣列指標在定義時非常相似，只是括號的位置不同：

int *(p1[5]);  //指標陣列，可以去掉括號直接寫作 int *p1[5];
int (*p2)[5];  //二維陣列指標，不能去掉括號

指標陣列和二維陣列指標有著本質上的區別：指標陣列是一個數組，只是每個元素儲存的都是指標，以上面的 p1 為例，在32位環境下它佔用 4×5 = 20 個位元組的記憶體。二維陣列指標是一個指標，它指向一個二維陣列，以上面的 p2 為例，它佔用 4 個位元組的記憶體。

C中的函式指標

一個函式總是佔用一段連續的記憶體區域，函式名在表示式中有時也會被轉換為該函式所在記憶體區域的首地址，這和陣列名非常類似。我們可以把函式的這個首地址（或稱入口地址）賦予一個指標變數，使指標變數指向函式所在的記憶體區域，然後通過指標變數就可以找到並呼叫該函式。這種指標就是函式指標。

函式指標的定義形式為：

returnType (*pointerName)(param list);

returnType 為函式返回值型別，pointerNmae 為指標名稱，param list 為函式引數列表。

注意：

( )的優先順序高於*，第一個括號不能省略，如果寫作returnType *pointerName(paramlist);
就成了函式原型，它表明函式的返回值型別為returnType *。

下面寫一個簡單的栗子：

#include <stdio.h>
#include <Windows.h>

int msg(char* msg,char* title){
    MessageBox(0,msg,title,0);
    return 0;
}
void main(){
    //msg();
    printf("%#x\n",msg);
    printf("%#x\n",&msg);
    //函式指標
    //函式返回值型別，函式指標的名稱，函式的引數列表
    int(*fun_p)(char* msg, char* title) = msg;
    fun_p("訊息內容","標題");

    getchar();
}

編譯並執行結果如下：

上面對msg函式進行了呼叫，fun_p是一個函式指標。

總結：

指標（Pointer）就是記憶體的地址，C語言允許用一個變數來存放指標，這種變數稱為指標變數。指標變數可以存放基本型別資料的地址，也可以存放陣列、函式以及其他指標變數的地址。

常見的指標含義：

- int *p;       p 可以指向 int 型別的資料，也可以指向類似 int arr[n] 的陣列。
- int **p;      p 為二級指標，指向 int * 型別的資料。
- int *p[n];    p 為指標陣列。[ ] 的優先順序高於 *，所以應該理解為 int *(p[n]);
- int (*p)[n];  p 為二維陣列指標。
- int *p();     p 是一個函式，它的返回值型別為 int *。
- int (*p)();   p 是一個函式指標，指向原型為 int func() 的函式。

以上就是通過學習對指標的概念的理解，不能再寫了，不然又是長篇大論，很難讓讀者看完，（我也不喜歡）。

更多系列相關文章傳送門：