如何掌握 C 語言的一大利器——指針？

一覽：初學 C 語言時，大家肯定都被指針這個概念折磨過，一會指向這里、一會指向那里，最后把自己給指暈了。本文從一些基本的概念開始介紹指針的基本使用。

內存

考慮到初學 C 語言時，大家可能對計算機的組成原理不太了解，所以這里先簡單介紹一些“內存”這個概念。

眾所周知，任何東西都需要有物理載體作為基礎。

比如說人產生的“思維”這個東西，我們看不見摸不着，但並不是說它就可以憑空存在了，思維的物理載體就是我們的大腦。“大腦”之於“思維”就如同“土地”之於“人類”。

同樣地，我們看不見摸不着的軟件 / 代碼也需要類似於“土地”和“大腦”的物理載體——存儲器。

存儲器分為兩種：

• 內存：計算機中正在運行的程序以及運行過程中暫時產生的數據都在這里。
• 外存：那些暫時不需要運行的程序和最終的運算結果存儲在這里。

比如一個 HelloWorld 程序：

#include <stdio.h>

int main()
{
    printf("Hello World!\n");
    return 0;
}

寫完保存之后，程序會被存儲在外存（硬盤）中。

當開始運行時，程序會被從外存調入內存中運行，打印 HelloWorld。

上面是內存的簡單概念（一個很淺的印象）：內存可以暫時存儲數據。

那內存的結構是什么樣的？

這里我們把內存想象為一幢有很多房間的酒店，每個房間都有一個獨一無二的房間號。

人就是數據；內存就是酒店。

酒店的職責就是供人暫時居住；內存的職責就是供數據暫時存儲。

內存的結構也像酒店一樣，有很多“房間”，稱之為“內存單元”，每個內存單元也有一個獨一無二的“房間號”，稱之為“內存地址”。數據就“住”在內存單元中。

假設現在張三住在酒店的 1001 號房間了。

我們就有以下關系：

房間號為1001的房間住了 客戶張三

放到內存中，就是：

內存地址為1001的內存單元存儲了 整數5

如此一來，我們就可以根據地址1001找到對應的內存單元，並對其中數據進行操作了。

但這樣有一個問題，就是為了操作 5，而不得不記住其地址，對於人來說，記憶這么多數字太麻煩了。

想象一下你平常和別人打招呼時說：“早上好啊，某人的身份證號”，而不是“早上好啊，某人的名字”。

光是記住自己的身份證號就不容易了，更別說別人的了，所以我們平常的稱呼是名字。盡管身份證號唯一，而名字可能會重復。

沒錯，就是名字，使用名字來代替對人不友好的內存地址。我們可以給 1001 號內存單元取個名字，就叫 a 吧。

我們取的這個“名字”就是編程語言都會有的“變量名”。

int a = 5;

變量名對我們人類來說就很友好了，什么 zhangsan、lisi等等都可以起。

通過變量名，就可以訪問其值了。現在我們有一個變量 a，存儲了值 5，可以直接通過變量名打印其值：

int a = 5;
printf("%d", a);

但這樣也出現了一個問題，就是我們不知道某個變量的地址了。

這就好比，你去酒店找張三，只知道他名字叫張三，而不知道他的房間號是多少，怎么辦？一間間的敲門嗎？

不可能。我們應該去前台問工作人員：“請問張三的房間號是多少？”，前台工作人員會告訴我們：“1001號”

類似地，要獲取某個變量的地址，我們也可以向“前台的工作人員”詢問：“請問變量 a 的‘房間號’是多少？”，當然，在現在的語境下，這句話就變成了“請問變量 a 的內存地址是多少？”。

在 C 語言中，這個充當“前台工作人員”的角色的是取地址運算符 &。

int a = 5;
printf("%p", &a); //請問a的內存地址是多少？

通過 &，我們可以得到某個變量的內存地址，通常是一串十六進制數字，比如 0061FF1C。

到這里就一切安好了嗎？不！

指針

概念

至此，我們只有能力得到某個變量的內存地址，即使用 &。現在的問題是我們如何使用它。

為什么現實中的人和事都會有一個名字？為了方便稱呼和使用。

名字之於事物，就好比刀柄之於刀身。一件事物一旦有了名字，我們就有了使用他的力量。

在程序中，我們會有大量的數據，為了使用這些數據，我們有了變量和變量名的概念。比如整型數據用整型變量存儲：

int i = 5;
float f = 5.0;
char c = 'x';

地址也屬於數據，換句話說，我們也應該有某種類型的變量來存儲地址：

int a = 5;
int p = &i; //錯誤代碼

我們的目的是使用變量 p 來存儲 int 類型變量a的地址，但是上面的代碼是錯誤的。因為我們的變量 p 被聲明為 int類型，所以變量 p 就只能存儲 int 類型數據，而不能存儲 int 類型變量的地址。

這個時候我們就需要一種能存儲整型變量的地址的變量，C 語言為我們提供了一種機制——指針。

int a = 5;
int *pa = &a;

現在我們聲明了一個能存儲 int 類型變量的地址 的變量 pa，然后使用 & 獲取變量 a 的地址，賦值給變量 pa，非常完美。

這里的 pa，就是一個指針（pointer）。可以看一下指針的定義：

In computer science, a pointer is an object in many programming languages that stores a memory address.

In computer science, an object can be a variable, a data structure, a function, or a method, and as such, is a value in memory referenced by an identifier.

在計算機科學中，指針是許多語言中存儲內存地址的對象。這里的對象可以是變量、結構體、函數或方法。

即，指針中存儲的是內存地址。

指針的聲明需要使用 * 來表示該變量是一個指針變量：

[pointer_type] *[pointer_name];

int a = 5;
float b = 5.0;
char c = 'x';

int *pa = &a; 
float *pb = &b;
char *pc = &c;

由於指針中存儲了某個變量的地址，所以我們可以說該指針指向了那個變量。比如 pa 被聲明為了指向 int 類型的指針，指向了變量 a。

間接訪問操作符

我們有了取地址運算符 &用來獲取某個變量的地址，也知道了如何聲明某種類型的指針用來存儲地址。

知道如何獲取了、懂了怎么存儲了，那么怎么使用指針呢？

房間號不是用來好看的，而是用來找到房間和房間中的人。我們已經通過 & 這個“前台工作人員”找到了房間號並記了下來，下一步就是上門把人找出來。

通過間接訪問操作符 *，我們就可以根據指針“上門找人”了。

int a = 5; //變量a中存儲5
int *pa = &a; //獲取房間號
printf("%d", *pa); //上門找人

*pa，就是取指針 pa 所指向的變量的值。

區分

初學 C語言時會容易混淆一些概念，所以這里區分一下。

int a = 5;
int b = 6;
int c = 7;

int *pa = &a;
int *pb = &b;
int *pc = &b;

printf("a = %d\n", a);
printf("b = %d\n", b);
printf("c = %d\n", c);

printf("&a = %p\n", &a);
printf("&b = %p\n", &b);
printf("&c = %p\n", &c);

printf("pa = %p\n", pa);
printf("pb = %p\n", pb);
printf("pc = %p\n", pc);

printf("*pa = %d\n", *pa);
printf("*pb = %d\n", *pb);
printf("*pc = %d\n", *pc);

輸出為

a = 5
b = 6
c = 7
&a = 0061FF10
&b = 0061FF0C
&c = 0061FF08
pa = 0061FF10
pb = 0061FF0C
pc = 0061FF0C
*pa = 5
*pb = 6
*pc = 6

• a：變量
• &a：a的地址
• int *pa：聲明一個指向 int 類型的指針 pa
• pa：指針
• *pa：指針 pa 指向的變量值

int *pa 和 *pa 中的 * 不一樣，這一點容易讓人迷惑。在聲明時，int * 是一起的，用來聲明一個指向 int 類型變量的指針，雖然寫開了，但不要分開來看。

int a; //聲明了一個變量a
int *pa; //聲明了一個變量pa

& 和 * 是一對相反的操作，& 根據變量求地址， * 根據地址求變量。

int a = 5;
printf("%d", *&a); //5
printf("%d", a); //5

*&a 的值為 5，即 a。

初始化

我們在聲明某個變量后，在使用某個變量前，一定要對其進行初始化。

比如在聲明變量 a 的同時將其初始化為 5：

int a = 5;

也可以聲明后再初始化：

int a;
a = 5;

如果不初始化，那么變量的值將是難以想象的。

指針也是變量，也必須對其進行初始化。先運行下面一段代碼：

int *p;
*p = 5;
return 0;

這段代碼的意思很簡單：聲明一個指針 p， 將 5 賦值給指針 p 所指向的那個變量。但這種代碼是錯誤的！

請問指針 p 指向了誰？由於我們沒有對其進行初始化，所以根本就不知道指針 p 指向了誰，那怎么賦值？

這就好比一個人對你說：“請把這個包裹給李四”。但是你根本就不知道李四是誰，李四住在哪里，你怎么給？

快遞員不認識你就能送貨，那是因為包裹上有地址，這就足夠了。

但是在上面的代碼中，你告訴 p 地址了嗎？沒有！因為我們沒有對指針進行初始化！

所以初始化指針非常重要！！！未初始化的指針不能用！！！

更改如下：

int a = 4;
int *p = &a;
*p = 5;

或者：

int a = 4;
int *p;
p = &a;
*p = 5;

現在變量 a 的值由 4 變為 5 了。

因為我們在“包裹”上寫了變量 a 地址，所以能把 5 送給變量 a 。

賦值

我們可以將一個指針賦值給另外一個指針。

int a = 5;

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

我們將指針 p1 的值賦給 p2，然后打印以下內容：

printf("a = %d\n", a);
printf("&a = %p\n", &a);

printf("p1 = %p\n", p1);
printf("p2 = %p\n", p2);

printf("*p1 = %d\n", *p1);
printf("*p2 = %d\n", *p2);

printf("&p1 = %p\n", &p1);
printf("&p2 = %p\n", &p2);

輸出為：

a = 5
&a = 0061FF1C
p1 = 0061FF1C
p2 = 0061FF1C
*p1 = 5
*p2 = 5
&p1 = 0061FF18
&p2 = 0061FF14

可以看到，將指針 p1 賦值給另一個指針 p2 的結果是： p1 指向哪里， p2 就指向哪里。如此一來，我們可以通過兩個指針操作變量 a。

*p1 = 4;
printf("a = %d\n", a); //從5變為4

*p2 = 3;
printf("a = %d\n", a); //從4變為3

空指針

空指針的值為 NULL， 表示不指向任何對象。

int *p = NULL;

當我們初始化一個指針的時候，如果還不知道要指向誰的時候，就把它初始化為空指針。

一些用法

我們已經以”指向變量的指針”為例，介紹了指針的基本用法。現在介紹一些指針的其他用法。

指向指針的指針

前面我們介紹了“指向變量的指針”：

int a = 5;
int *pa = &5;

指針也是個變量，只不過相對於其他類型的變量有點特殊，指針變量中存儲的是其他變量的地址。

也就是說，指針作為一個變量也有地址，該地址可以被其他指針存儲，即指向了指針的指針。

對應代碼如下：

int a = 5;
int *pa = &5;
int **ppa = &pa;

如你所見，聲明一個“指向指針的指針”需要使用兩個* ：

[pointer_type] **[pointer_name];

同樣地，要獲取 指向指針的指針 指向的 指針 指向的 變量值 需要進行兩次間接訪問，即**ppa。

請仔細體會以下代碼：

#include <stdio.h>

int main()
{
    int a = 5;
    int *pa = &a;
    int **ppa = &pa;
    
    printf("a = %d\n", a);
    printf("&a = %p\n", &a);

    printf("pa = %p\n", pa);
    printf("*pa = %d\n", *pa);
    printf("&pa = %p\n", &pa);

    printf("ppa = %p\n", ppa);
    printf("*ppa = %p\n", *ppa);
    printf("**ppa = %d\n", **ppa);
    printf("&ppa = %p\n", &ppa);
    
    return 0;
}

通過代碼，我們可以得到以下等價關系：

表達式	等價表達式
a	5
pa	&a
ppa	&pa
*pa	a、5
*ppa	pa、&a
**ppa	*pa、a、5

舉一反三，你還可以試試 {指向[指向(指針)的指針]的指針}。

指針和數組

首先運行以下代碼：

int arr[5] = {1, 2, 3, 4, 5};
printf("arr = %p\n", arr);

int *p = &arr[0];
printf("&arr[0] = %p\n", &arr[0]);
printf("p = %p\n", p);
printf("arr[0] = %d\n", arr[0]);
printf("*p = %d\n", *p);

p++;
printf("運行p++之后...\n");

printf("&arr[1] = %p\n", &arr[1]);
printf("p = %p\n", p);
printf("arr[1] = %d\n", arr[1]);
printf("*p = %d\n", *p);

輸出為：

arr = 0061FF08
&arr[0] = 0061FF08
p = 0061FF08
arr[0] = 1
*p = 1
運行p++之后...
&arr[1] = 0061FF0C
p = 0061FF0C
arr[1] = 2
*p = 2

可以得到以下結論：

• arr =&arr[0]，arr是數組的首元素指針
• int *p = &arr[0] 和 int *p = arr 是等效的
• arr[n] 和 *(p+n)是等效的

指針和函數

先運行以下函數：

#include <stdio.h>

void swap(int x, int y)
{
    int temp = x;
    x = y;
    y = temp;
}

int main()
{
    int x = 5, y = 10;
    printf("交換前 x = %d, y = %d\n", x, y);
    swap(x, y);
    printf("交換后 x = %d, y = %d\n", x, y);
    return 0;
}

swap 函數的目的很簡單：傳進來兩個值，交換他們。

但是結果令人失望——根本沒交換。原因是什么？

我們打印一些東西：

#include <stdio.h>

void swap(int x, int y)
{
    printf("在swap()中，x的地址為%p，y的地址為%p\n", &x, &y);
    printf("swap() 交換前 x = %d, y = %d\n", x, y);
    int temp = x;
    x = y;
    y = temp;
    printf("swap() 交換后 x = %d, y = %d\n", x, y);
}

int main()
{
    int x = 5, y = 10;
    printf("在main()中，x的地址為%p，y的地址為%p\n", &x, &y);
    printf("main() 交換前 x = %d, y = %d\n", x, y);
    swap(x, y);
    printf("main() 交換后 x = %d, y = %d\n", x, y);
    return 0;
}

輸出為：

在main()中，x的地址為0061FF1C，y的地址為0061FF18
main() 交換前 x = 5, y = 10
在swap()中，x的地址為0061FF00，y的地址為0061FF04
swap() 交換前 x = 5, y = 10
swap() 交換后 x = 10, y = 5
main() 交換后 x = 5, y = 10

可以看到，在 swap() 中，我們確實交換了值，但是swap() 函數執行完后回到 main() 中，值卻沒有交換。

可以看到，swap() 中的 x 、y 和 main() 中的 x 、y 的地址並不相同，這就意味着**此 x 、y 非彼 x 、y **。

原因很簡單，swap(int x, int y) 的參數傳遞為值傳遞，所謂值傳遞，即將實參的值復制到形參的對應內存單元中。函數操作的是形參的內存單元，無論形參如何變化，都不會影響到實參。

void swap(int x, int y) //xy為形參
{.....}

int main()
{
    int x = 5, y = 10;
    swap(x, y); //xy為實參
}

這里就解釋了為什么 main() 和 swap()打印出來的 x 、y 的地址不同，也解釋了為什么交換失敗。

那么，為了通過函數直接操作實參，我們必須使形參和實參是同一塊內存。所以我們直接把實參的地址傳給函數，也即，函數的參數為指針，指向實參的內存單元。這種參數傳遞為地址傳遞。

地址傳遞保證了形參的變化即為實參的變化。

代碼更正：

#include <stdio.h>

void swap(int *px, int *py) //形參為指針，接收實參的地址
{
    printf("在swap()中，px = %p，py = %p\n", px, py);
    printf("swap() 交換前 x = %d, y = %d\n", *px, *py);
    int temp = *px;
    *px = *py;
    *py = temp;
    printf("swap() 交換后 x = %d, y = %d\n", *px, *py);
}

int main()
{
    int x = 5, y = 10;
    printf("在main()中，x的地址為%p，y的地址為%p\n", &x, &y);
    printf("main() 交換前 x = %d, y = %d\n", x, y);
    swap(&x, &y);
    printf("main() 交換后 x = %d, y = %d\n", x, y);
    return 0;
}

輸出為：

在main()中，x的地址為0061FF1C，y的地址為0061FF18
main() 交換前 x = 5, y = 10
在swap()中，px = 0061FF1C，py = 0061FF18
swap() 交換前 x = 5, y = 10
swap() 交換后 x = 10, y = 5
main() 交換后 x = 10, y = 5

指針和結構體

先定義一個結構體：

typedef struct Node {
    int data;
    struct Node *next;
} Node;

然后聲明一個結構體：

Node node;

要訪問結構體內的成員，需要使用 . 操作符：

node.data;
node.next;

現在我們有一個指向該結構體的指針：

Node *p = &node;

想要通過指針訪問結構體的成員：

(*p).data;
(*p).next;

也可以使用 -> 操作符：

p->data;
p->next;

注意，-> 要對指向結構體的指針使用才行。

對於初學者，某個概念一時搞不懂其實很正常。誰都不是一下子就學會用筷子和走路的，我們需要的是花時間進行大量的實踐。就拿指針來說吧，初學者覺得難以理解是因為用得少，反過來說，對於經常使用 C/C++ 寫代碼的人，指針肯定早就不是問題了。所以搞清基本原理，接下來就花時間去大量實踐吧，時間到了，自然就會豁然開朗。

如有錯誤，還請指正。

如果覺得寫的不錯可以關注一下我。