Posted on Feb 3, 2022 • Edited on Sep 25, 2024

C/C++ 語言的陣列與指位器 (pointer)

學習 C/C++ 語言的過程中一定都多少聽過陣列與指位器 (pointer) 可以互換使用, 但其實內藏玄虛, 若不注意, 就會誤踩陷阱。

位址相同但語意不同的指位器

對於一個陣列, 有多種方式可以取得開頭的位址, 例如以下的範例：

#include <stdio.h>  int main(){ int a[10]; printf("%p\n", a); printf("%p\n", &a); printf("%p\n", &a[0]); return 0; }

執行結果如下：

0x7fff15d92640 0x7fff15d92640 0x7fff15d92640

的確可以看到指向的位址都相同, 就字面上來看, &a 是陣列的位址, 而 &a[0] 是陣列第一個元素的位址, 所以這兩個位址相同並沒有問題, 但是為什麼 a 也會是陣列的位址呢？

這是因為在 C 語言的陣列轉指位器規則(C++ 文件)裡明定運算結果是一個陣列, 而且這個運算結果不是 sizeof 也不是取址 & 運算器的運算元時, 會自動將運算結果轉換成指向陣列第一個元素的指位器, 因此, 剛剛範例中的 a 就被轉換成 &(a[0]) 了, 如下圖所示：

 a | &a --> +-|-+---+---+---+---+---+---+---+---+---+ | V | | | | | | | | | | +---+---+---+---+---+---+---+---+---+---+ 0 1 2 3 4 5 6 7 8 9

你可以透過以下範例確認 a 和 &(a[0]) 是相等的 (由於 [] 優先權大於 &, 所以一般會寫成 &a[0])：

#include <stdio.h>  int main(){ int a[10]; printf("%d\n", a==&a[0]); return 0; }

執行結果就是比較成立得到的運算結果 1：

你可能會想『咦？那麼難道 a 和 &a 不相等嗎？不是都指向同樣的位址？』我們可以透過以下的範例試試看：

#include <stdio.h>  int main(){ int a[10]; printf("%d\n", a==&a); return 0; }

事實上這個程式連編譯都會出現錯誤訊息：

$ g++ test.c test.c: In function ‘int main()’: test.c:6:19: error: comparison between distinct pointer types ‘int*’ and ‘int (*)[10]’ lacks a cast [-fpermissive] 6 | printf("%d\n", a==&a); | ~^~~~

編譯器認為 a 和 &a 是指向不同型別的指位器, 不應該拿來比較, a 因為是指向陣列第一個元素的指位器, 所以型別是 int*, 但是 &a 是指向陣列的指位器, 所以型別是 int (*)[10], 兩者雖然指向相同的位址, 但是語意上並不相同。

註：以 gcc 編譯時, 只會出現警告, 程式仍可編譯執行, 但以 g++ 編譯則會出現錯誤, 停止編譯程序。

以陣列索引取址就是透過指位器間接取值

瞭解上述規則後, 我們就可以來看如何從陣列中取值, 請看以下範例：

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

範例中的三種方式都可以取得正確的元素：

4 4 4

其實根據 [] 運算器的說明(C++ 的文件), a[3] 實際的運算等同於 *(a + 3), 而 + 運算器的說明(C++ 文件)則規定了指位器與整數的加減是以元素為單位, 因此 a + 3 就會是指向陣列 a 中的第 3 個元素, 所以 *(a + 3) 就可以取得 a 的第 3 個元素了。

也就是說, 編譯器實際上就是把陣列當成指位器處理, 兩者是等義的。

不完整的型別 (incomplete type)

如果想要取得指向陣列的指位器, 可以依照剛剛錯誤訊息看到的型別宣告：

#include <stdio.h>  int main(){ int a[10]; int (*p)[10] = &a; printf("%d\n", *p==&a[0]); return 0; }

這裡比較特別的地方是 p 是指向陣列的指位器, 所以 *p 就是陣列本人, 依據前述規則, *p 會被轉換為指向陣列第一個元素的指位器, 因此 *p 和 &a[0] 相等。

其實在宣告指向陣列的指位器時, 並不需要明確標示元素個數, 像是這樣：

#include <stdio.h>  int main(){ int a[10]; int (*p)[] = &a; printf("%d\n", *p==&a[0]); return 0; }

也可以得到一樣的結果, 不過其中有個細微的差異, 我們透過以下範例來說明：

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

這個程式在編譯時就會出錯, 錯誤訊息如下：

$ g++ test.c test.c: In function ‘int main()’: test.c:10:18: error: invalid application of ‘sizeof’ to incomplete type ‘int []’ 10 | printf("%d\n", sizeof *p2); | ^~~~~~~~~~

由於宣告時是 int (*p2)[] 沒有指明元素個數, 編譯器認為資訊不完整, 這稱為『不完整的型別 (incomplete type)』, 會導致 sizeof 無法判定資料大小, 所以引發編譯錯誤。

多維陣列與指位器的關係

上述的說明也一樣可以使用在多維陣列上, 首先, 陣列本身出現在非 sizeof 與 & 的運算元時, 會被視為是指向以第一個維度為視角的一維陣列中的第一個元素, 我們以底下的範例來說明：

#include<stdio.h>  int main(void) { int num[3][4]; // 宣告3×4的二維陣列num printf("%s%p\n", "num =", num); // 印出 num[0] 一維陣列的位址 printf("%s%p\n", "&num =", &num); // 印出 num 陣列的位址 printf("%s%p\n", "num[0] =", &num); // 印出 num[0][0] 的位址 printf("%s%p\n", "*num =", *num); // num 被視為指向 num[0] 這個一維陣列的指標 // *num 就等同 num[0], 視為指向 num[0][0] 的指標 printf("%s%p\n", "num+1 =", num + 1); // num[0] 一維陣列的位址 + 4個 int 的長度 printf("%s%p\n", "&num+1 =", &num + 1); // num 陣列的位址 + 3*4 個 int 的長度 printf("%s%p\n", "num[0]+1=", num[0] + 1); // num[0][0]的位址 + int 的長度 printf("%s%p\n", "*num+1 =", *num + 1); // *num 等同 num[0] return 0; }

由於 num 是一個 3×4 維的陣列, 以第一個維度來看, 就是有 3 個元素的一維陣列, 其中每個元素個別是一個內含 4 個元素的一維陣列, 所以 num 會被編譯器視為是指向第一個一維陣列的指位器, &num 仍是指向整個陣列, 而 num[0] 指的是第一個一維陣列, 不過它沒有作為 sizeof 或是 & 的運算元, 因此會被編譯器轉換成指向陣列內第一個元素的指位器, 如下圖所示：

 num[0] | &num --> +-|-+---+---+---+ num --> | v | | | | 0 +---+---+---+---+ num+1 --> | | | | | 1 +---+---+---+---+ num+2 --> | ^ | | | | 2 +-|-+---+---+---+ | num[2]

剛剛程式的輸出結果如下：

num =000000ca16fff6f0 ----+ &num =000000ca16fff6f0 ----+--+ num[0] =000000ca16fff6f0 ----+--+--+ *num =000000ca16fff6f0 | | | num+1 =000000ca16fff700 <-+16 | | &num+1 =000000ca16fff720 <-+48--+ | num[0]+1=000000ca16fff6f4 <-+4------+ *num+1 =000000ca16fff6f4

你可以看到 num, &num, num[0] 都會指向同一個位址, 但是他們的語意並不相同, 也就是他們的型別並不相同, 這可以透過對指位器進行加減運算來驗證：

num 指向的是有 4 個 int 元素的一維陣列, 型別是
```
int (*)[4] 
```
所以 num+1 時位址會加上 4×4, 也就是 16。
&num 指向的是 3×4 的陣列, 型別是
```
int (*)[3][4] 
```
所以 &num+1 時位址是加上 3×4×4, 也就是 48。
num[0] 是指向一維陣列中的元素, 也就是指向 int, 型別是
```
int* 
```
因此num[0]+1 是加上 4。
比較特別的是 *num, 因為 num 是指向一維陣列, 所以 *num 就是一維陣列本人, 由於這裡不是 sizeof 與 & 的運算元, 所以 *num 會被編譯器轉換成指向這個一維陣列內第一個元素的指位器, 因此 *num 就等同 num[0] 了。

這樣的設計使得二維陣列運作起來很像是雙重指位器, 有些教學就直接把 num 當成雙重指位器, 這在部分情況會得到正確的結果, 但是某些情況下卻會有問題, 例如做指位器加減運算時, 若是雙重指位器由於指向的是指位器, num+1 就應該是加 1 個指位器的大小, 而不是一個一維陣列的大小了。

傳遞陣列到引數

瞭解陣列被轉換成指位器的原理後, 現在你就可以知道為什麼傳遞陣列到函數時不是傳遞整個陣列, 而是傳遞位址了, 精確的來說, 實際上傳遞的不是陣列的位址, 而是陣列中第一個元素的位址, 例如：

#include<stdio.h>  void f(int *pa, int len) { for(int i=0;i < len;i++) { printf("pa[%d]:%d\n", i, pa[i]); } } int main() { int a[] = {1,2,3}; f(a, sizeof(a)/sizeof(int)); return 0; }