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

iOS 開發之路(三):C 語言指標入門完全指南

編輯:iOS 相關教學

指標是 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 指向某個陣列,則 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++ 並沒有任何意義——函式在記憶體中的排布不是連續的資料序列,指標算術對它並不適用。

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