陣列在 C 語言裡有著特殊地位:它的記憶體配置是連續的,而且陣列名稱本身就代表陣列的位址。另一方面,C 語言並沒有 String 型別,要表示一段文字,只能回頭使用 char 陣列。今天就把一維陣列、多維陣列與字串這三件事一次講清楚。
一維陣列的操作本身不難,但有幾條規則必須記牢:
#include <stdio.h>
int main(){
int len = 2;
//int a[len] = { 1, 2 }; // 錯誤:長度不能用變數
int a[2]; // 正確
a[0] = 1;
a[1] = 2;
//a[2] = 3; // 超出範圍,編譯器不會檢查,執行期才出錯
int b['a'] = {1,2,3}; // 'a' 的 ASCII 值為 97,可作為長度;
// 後續元素未初始化,值預設為 0
for (int i = 0; i < 97; ++i){
printf("b[%d]=%d\n", i, b[i]);
}
int c[2 * 3]; // 2*3 是固定值,可以作為長度
int d[] = { 1, 2, 3 }; // 賦值時省略長度,元素個數即為 3
}
陣列在記憶體中佔據一塊連續空間。只要知道元素型別與起始位址,就能推算出其他元素的位址;反過來說,由於陣列名稱等於第一個元素的位址,因此當陣列作為函式參數傳遞時,實際上是傳址呼叫(call by reference)。
#include <stdio.h>
int main(){
int const l = 3;
int a[l] = { 1, 2, 3 };
for (int i = 0; i < l; ++i){
// 在 32 位元編譯器下 int 為 4 個位元組,
// 可以觀察到三個元素的位址兩兩相差 4
printf("a[%d]=%d,address=%x\n", i, a[i], &a[i]);
}
/* 輸出結果:
a[0]=1,address=c9f95c
a[1]=2,address=c9f960
a[2]=3,address=c9f964 */
}
對應的記憶體結構如下圖:

再看陣列(注意:是陣列本身,不是某個元素)作為參數傳遞的情形:
#include <stdio.h>
void changeValue(int a[]){
a[0] = 10;
}
int main(){
int a[2] = {1,2};
changeValue(a);
for (int i = 0; i < 2; ++i){
printf("a[%d]=%d\n", i, a[i]);
}
/* 輸出結果:
a[0]=10
a[1]=2 */
}
呼叫端傳入的 a 被直接改動了——這正是傳址呼叫的明證。因此在設計函式時,若不想讓被調用的函式動到原始資料,就得自己先複製一份再傳入。
多維陣列其實可以理解為一種特殊的一維陣列:它的每個元素又是一個一維陣列。
#include <stdio.h>
int main(){
int a[2][3]; // 2 列 3 行
a[0][0] = 1; a[0][1] = 2; a[0][2] = 3;
a[1][0] = 4; a[1][1] = 5; a[1][2] = 6;
for (int i = 0; i < 2; ++i){
for (int j = 0; j < 3; ++j){
printf("a[%d][%d]=%d,address=%x\n", i, j, a[i][j], &a[i][j]);
}
}
/* 輸出結果:
a[0][0]=1,address=f8fb24 a[0][1]=2,address=f8fb28 a[0][2]=3,address=f8fb2c
a[1][0]=4,address=f8fb30 a[1][1]=5,address=f8fb34 a[1][2]=6,address=f8fb38 */
// 宣告並直接賦值
int b[2][3] = { { 1, 2, 3 }, { 4, 5, 6 } };
// 由於賦值順序是「第一列第一欄 → 第一列第二欄 → … → 第二列第一欄 → …」,
// 因此也可以寫成扁平的形式
int c[2][3] = { 1, 2, 3, 4, 5, 6 };
// 也可以只初始化部分元素,其餘預設為 0
int d[2][3] = { 1, 2, 3, 4 };
for (int i = 0; i < 2; ++i){
for (int j = 0; j < 3; ++j){
printf("d[%d][%d]=%d\n", i, j, d[i][j]);
}
}
/* 輸出結果:
d[0][0]=1 d[0][1]=2 d[0][2]=3
d[1][0]=4 d[1][1]=0 d[1][2]=0 */
int e[2][3] = { {}, { 4, 5, 6 } };
// 列數可以省略,但欄數絕對不行——因為編譯器要靠欄數推算列數
int f[][3] = { {1,2,3}, {4,5,6} };
}
以上面的 a 陣列為例,記憶體結構如下:

結合一維陣列的結論,可以整理出二維陣列的位址關係:
a == a[0] == &a[0][0] a[1] == &a[1][0]
也就是說,二維陣列的名稱同時是整個陣列的位址、第一列子陣列的位址,以及第一個元素的位址;而第二列子陣列的位址則等於該列第一個元素的位址。更高維度可以此類推。
C 語言沒有字串型別,要表示字串就得使用 char 陣列——畢竟字串本質上就是一串字元的組合。但這裡有個關鍵:字串是一個特殊的陣列,它的尾端必須有一個 \0(ASCII 中的 0,表示空操作)作為結束標記,否則編譯器無從判斷字串在哪裡結束。若直接用字面值賦值,程式會自動補上這個結束符。
#include <stdio.h>
int main(int argc, const char * argv[]) {
char a[] = {'K','e','n','s','h','i','n','\0'};
printf("%s", a); // 結果:Kenshin
// 注意用 %s 輸出字串內容;若改用整數格式,印出的是 a 的位址
printf("\n");
printf("address=%x", a); // 結果:address=5fbff890
printf("\n");
// 後面的 \0 絕對不能省。若沒有它會發生什麼?
char b[] = { 'I', 'a', 'm'};
printf("%s", b); // 未如預期輸出,多了一堆垃圾資料
// 當前環境的輸出結果:IamKenshin
printf("\n");
printf("address=%x", b); // 結果:address=5fbff88d
printf("\n");
// 直接以字串字面值賦值,編譯器會自動補上 \0
char c[] = "Kenshin";
printf("c=%s", c); // 結果:c=Kenshin
printf("\n");
// 用二維陣列存放多個字串
char d[2][3] = {"Kenshin","Kaoru","Rose","Jack","Tom","Jerry"};
return 0;
}
為什麼 b 印出來不是「Iam」,而是「IamKenshin」?要看 a 與 b 在記憶體中的配置:

a 佔用 8 個位元組,而 b 緊接其後配置了 3 個位元組。當程式輸出 b 時,印完「Iam」之後並沒有遇到 \0,於是一路往後印,直到碰上陣列 a 中的 \0 才停下——因此結果是「IamKenshin」。這個例子很直观地說明了為什麼 C 字串一定要以 \0 收尾。
#include <stdio.h>
int main(int argc, const char * argv[]) {
/* 字元操作 */
putchar('a'); // 結果:a,putchar 一次只能輸出一個字元
printf("\n");
putchar(97); // 結果:a,傳入 ASCII 碼同樣可行
printf("\n");
char a;
a = getchar(); // getchar 一次只能接收一個字元,空格、Tab、回車都算
printf("a=%c", a);
printf("\n");
/* 字串操作 */
char b[] = "Kenshin";
printf("b=%s", b);
printf("\n");
puts(b); // puts 輸出單一字串,不能格式化,會自動換行
printf("\n");
char c[10];
scanf("%s", c); // 注意 c 不必寫成 &c,因為 c 本身就是陣列的位址
printf("c=%s\n", c);
// gets() 是不安全的:它無法得知接收緩衝區的大小,容易造成緩衝區溢位,不建議使用
char d[10];
gets(d); // gets 一次接收一整行(可含空格、Tab),scanf 則不行
printf("d=%s", d);
printf("\n");
char e[] = {'K','s','\0'};
printf("%lu", strlen(e)); // 結果:2,不是 3,因為 \0 不計入長度
printf("\n");
char f[] = "Kenshin";
printf("%lu", strlen(f)); // 結果:7
printf("\n");
// strcpy 不會檢查目標緩衝區大小,即使 g 只有 5 個位元組也會照樣拷滿
char g[5];
strcpy(g, "hello,world!");
printf("%s", g); // 結果:hello
printf("\n");
char h[5];
char i[] = {'a','b','c','\0','d','e','f','\0'};
strcpy(h, i);
printf("%s", h); // 結果:abc,遇到第一個 \0 就結束
printf("\n");
strcat(i, "ghi");
printf("%s", i); // 結果:abcghi
// 注意不是 abcfghi:strcat 從 i 的第一個 \0 開始以 "ghi" 覆寫,
// 覆寫後再補一個 \0。此時記憶體中的內容應為:
// {'a','b','c','g','h','i','\0','f','\0'}
char j[] = "abc";
char k[] = "aBc";
char l[] = "acb";
char m[] = {'a','\0'};
// strcmp 遇到第一個不同的字元或 \0 時,回傳兩者之差
printf("%d,%d,%d", strcmp(j,k), strcmp(k,l), strcmp(l,m)); // 結果:32,-33,99
printf("\n");
return 0;
}
補充一點:在 Xcode 中會直接提示 gets 不安全。原因是 Xcode 採用 clang / gcc 系工具鏈,其中的 C 標準庫已不建議使用 gets,請改用 fgets(),並明確指定緩衝區大小,例如 fgets(d, sizeof(d), stdin)。
同樣地,strcpy 與 strcat 都不做邊界檢查,在處理外部輸入時應改用 strncpy 與 strncat,並自行確保結束符的位置。這不只是風格問題,而是實際的安全邊界。