指標是 C 語言的精華所在,但也最容易讓初學者越學越模糊。本文試著用最樸素的例子把指標講透,重點放在三件事:什麼是指標、陣列與指標的關係,以及函式指標。
存放變數位址的變數,我們稱之為「指標變數」。簡單說,若變數 p 存放的是變數 a 的位址,那麼 p 就是指標變數,也可以說 p 指向 a。
這裡需要區分兩種存取方式:
直接引用。存取 a 時,程式先取得 a 的位址,再到該位址對應的儲存空間中取出 a 的值。
間接引用。透過 p 存取 a 時,程式先取得 p 的位址,從中讀出儲存的內容——這個內容其實就是 a 的位址——再依此位址到對應空間取出真正的值。
用表格列出 a 與 p 的儲存關係,會更清楚:

接著看指標的賦值:
#include <stdio.h>
int main(int argc, const char * argv[]) {
int a = 1;
int *p;
p = &a; // 也可以直接寫成:int *p = &a;
printf("address(a)=%x,address(p)=%x\n", &a, p);
// 結果:address(a)=5fbff81c,address(p)=5fbff81c
printf("a=%d,p=%d\n", a, *p); // 結果:a=1,p=1
*p = 2;
printf("a=%d,*p=%d\n", a, *p); // 結果:a=2,p=2
int b = 8;
char c = 1;
int *q = &c; // 型別不匹配!
printf("address(b)=%x,address(c)=%x\n", &b, &c);
printf("c=%d,q=%d\n", c, *q); // 結果:c=1,q=2049 —— 為什麼不是 1?
return 0;
}
三個重點:
第一,* 有兩種身份。在 int *p; 中,* 只是宣告 p 為指標變數;而在 *p 這樣的運算式中,* 是取值運算子,表示 p 所指向的那塊儲存空間。由於 *p == a,修改 *p 就等於修改 a,所以第二次輸出 a 變成了 2。
第二,指標的型別必須與它指向的資料一致。上面 q 宣告為 int 指標卻指向 char,於是 *q 印出了 2049 這個怪數字。原因見下圖(假設 16 位元編譯器,指標長度 2 位元組):

局部變數存放在堆疊中,配置順序是 b 先、a 與 p 後。取值 *q 時,程式會從 q 指向的位址開始,取出「指標型別所對應的長度」——因為 p 宣告為 int,在 16 位元環境下 int 為 2 個位元組,於是它從 c 的起始位址抓了 2 個位元組,剛好把 b 的其中一個位元組也讀了進來。最終 *q 的二進位為 0000100000000001(見上圖黃色區塊),換算成十進位就是 2049。
第三,指標變數自身的長度與它指向的型別無關,只取決於編譯器的位元數(更精確地說,取決於定址方式)。32 位元環境下指標是 4 位元組,64 位元環境下則是 8 位元組。
由於陣列的配置是連續的,而陣列名稱就是陣列的位址,兩者的關係自然變得微妙。
#include <stdio.h>
void changeValue(int a[]){
a[0] = 2;
}
void changeValue2(int *p){
p[0] = 3;
}
int main(int argc, const char * argv[]) {
int a[] = {1,2,3};
int *p = &a[0]; // 等價於:*p = a; 這種寫法不合法,這裡只是說明含義
printf("len=%lu\n", sizeof(int)); // 取得 int 長度
// 指標加 1,代表位址往後移動「一個所指向型別的長度」
// 這裡型別是 int,所以 p+1 指向 a[1],以此類推
for (int i = 0; i < 3; ++i){
// printf("a[%d]=%d\n", i, a[i]);
printf("a[%d]=%d\n", i, *(p + i));
// 由於 a 本身就代表陣列位址,也可寫成 *(a + i)
// 但注意:*(p + i) 可以寫成 *(p++),*(a + i) 卻不能寫成 *(a++)
// 因為陣列名稱是常量,不可被修改
}
/* 輸出結果:a[0]=1 a[1]=2 a[2]=3 */
changeValue(p); // 等價於 changeValue(a)
for (int i = 0; i < 3; ++i){
printf("a[%d]=%d\n", i, a[i]);
}
/* 輸出結果:a[0]=2 a[1]=2 a[2]=3 */
changeValue2(a); // 等價於 changeValue2(p)
for (int i = 0; i < 3; ++i){
printf("a[%d]=%d\n", i, a[i]);
}
/* 輸出結果:a[0]=3 a[1]=2 a[2]=3 */
return 0;
}
歸納出四條結論:
a 等於 &a[0],也等於指向該陣列時的 *p。p+1 指向下一個元素;移動的實際位元組數取決於 p 的型別,並非固定。p++,但陣列名稱不行,因為它是常量。C 語言的字串就是 char 陣列,那麼指標與字串的關係如何?
#include <stdio.h>
int main(int argc, const char * argv[]) {
char a[] = "Kenshin";
// 同一個變數 a,用 %s 印出字串內容,用 %x 印出位址 —— 取決於格式參數
printf("%x,%s\n", a, a); // 結果:5fbff820,Kenshin
printf(a); // 結果:Kenshin
printf("\n");
char b[] = "Kenshin";
char *p = b;
printf("b=%s,p=%s\n", b, p); // 結果:b=Kenshin,p=Kenshin
// 指標存的是位址,陣列名稱存的也是位址;
// 既然 char 陣列能表示字串,指向 char 的指標自然也可以
char *c = "Kenshin"; // 等價於 char c[] = "Kenshin";
printf("c=%s\n", c); // 結果:c=Kenshin
return 0;
}
為什麼 printf(a) 能直接印出字串?看一下它的宣告:
int printf(const char * __restrict, ...) __printflike(1, 2);
printf 的第一個參數要求的是「指向 char 的指標」,而陣列名稱本身就是位址,因此可以傳入。同理,上一篇文章提到的 strcat()、strcpy() 等函式也是如此。
在談函式指標之前,先看一個回傳指標型別的函式——指標本身也是 C 的資料型別,作為回傳值理所當然。以下用「字串轉大寫」為例,順便示範指標的移動操作:
#include <stdio.h>
char * toUpper(char *a){
char *b = a; // 保留最初的位址,因為後續迴圈會改變 a
int len = 'a' - 'A'; // 大小寫 ASCII 碼的差值
while (*a != '\0') { // 判斷字串是否結束
if (*a > 'a' && *a < 'z') { // 若是小寫字母
*(a++) -= len; // 轉為大寫,同時 a 前進到下一個字元
} else {
a++;
}
}
return b;
}
int main(int argc, const char * argv[]) {
char a[] = "hello";
char *p = toUpper(a);
printf("%s\n", p); // 結果:HELLO
return 0;
}
函式只能有一個回傳值,那需要回傳多個值時怎麼辦?把指標當作參數傳進去就行了。以下再次示範指標作為參數的用法:
#include <stdio.h>
int operate(int a, int b, int *c){
*c = a - b; // 透過指標把結果帶回呼叫端
return a + b;
}
int main(int argc, const char * argv[]) {
int a = 1, b = 2, c, d;
d = operate(a, b, &c);
printf("a+b=%d,a-b=%d\n", d, c); // 結果:a+b=3,a-b=-1
return 0;
}
函式同樣存在於記憶體中,也有起始位址——實際上函式名稱就是函式的起始位址。函式指標的定義形式為:
回傳型別 (*指標變數名稱)(形參1, 形參2)
拿到函式指標,就等於拿到了這個函式本身,所有操作都能透過指標完成。而既然指標可以作為參數與回傳值,函式指標自然也可以:
#include <stdio.h>
int sum(int a, int b){ return a + b; }
int sub(int a, int b){ return a - b; }
// 函式指標作為參數傳遞
int operate(int a, int b, int (*p)(int, int)){
return p(a, b);
}
int main(int argc, const char * argv[]) {
int a = 1, b = 2;
int (*p)(int, int) = sum; // 函式名稱即函式首址
// 等價於:int (*p)(int,int); p = sum;
int c = p(a, b);
printf("a+b=%d\n", c); // 結果:a+b=3
printf("%d\n", operate(a, b, sum)); // 結果:3
printf("%d\n", operate(a, b, sub)); // 結果:-1
return 0;
}
能動態替換傳入的函式,設計上的彈性瞬間拉開一個檔次。寫過 C# 的人應該會馬上聯想到委派(delegate)——C# 書籍裡常說「委派類似於函式指標」,講的正是上面這種情形。
最後提醒一個容易混淆的點:普通指標可以寫成 p++ 來移動,但函式指標寫 p++ 並沒有任何意義——函式在記憶體中的排布不是連續的資料序列,指標算術對它並不適用。