一覽：初學 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型別的指標papa：指標*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++ 寫代碼的人，指標肯定早就不是問題了，所以搞清基本原理，接下來就花時間去大量實踐吧，時間到了，自然就會豁然開朗，
如有錯誤，還請指正，
如果覺得寫的不錯可以關注一下我，
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/265041.html
標籤：其他