您现在的位置: IOS教程網 >> IOS系統 >  >> iOS 教學 >> iOS 相關教學

iOS 開發之路(二):C 語言陣列與字串完全解析

編輯:iOS 相關教學

陣列在 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,並自行確保結束符的位置。這不只是風格問題,而是實際的安全邊界。

  1. 上一篇文章:
  2. 下一篇文章:
蘋果刷機越獄教程| IOS教程問題解答| IOS技巧綜合| IOS7技巧| IOS8教程
Copyright © IOS教程網 All Rights Reserved