C 語言指針完全掌握：從記憶體模型到高級應用的系統性指南

等價訪問四重奏

int a[5] = {10, 20, 30, 40, 50};
int *p = a;  // p = &a[0]

// 1. 下標法
a[i]           // *(a + i)

// 2. 指針算術 + 解引用
*(a + i)       // a 退化為指針
*(p + i)       // 顯式指針

// 3. 指針下標 (指針也可用 []!)
p[i]           // *(p + i)

// 4. 陣列名下標 (本質相同)
a[i]           // *(a + i)

指針遍歷陣列三種風格

// 風格 1: 索引
for (int i = 0; i < n; i++) sum += a[i];

// 風格 2: 指針移動 (經典 C 風格)
for (int *p = a; p < a + n; p++) sum += *p;

// 風格 3: 末尾哨兵 (C99 靈活數組/指針範圍)
int *end = a + n;
for (int *p = a; p != end; p++) sum += *p;

多維陣列指針

int matrix[3][4];  // 3 行 4 列

// 陣列名退化: 指向「含 4 個 int 的陣列」的指針
int (*p)[4] = matrix;  // 類型: int (*)[4]
// p+1 跳過一整行 (4*4=16 bytes)

// 訪問 matrix[i][j]:
matrix[i][j]          // *(*(matrix + i) + j)
*(*(p + i) + j)       // 顯式指針版
p[i][j]               // 指針也可雙下標!

三、指針與字串：C 風格字串的本質

兩種字串形式

char str1[] = "hello";  // 陣列: 栈上, 可修改, 大小 6 (含 \0)
char *str2 = "hello";   // 指針: 指向唯讀區 (文字段/常量區), **不可修改**, 大小 8/4 (指針大小)

// str1[0] = 'H'; // ✓ 合法
// str2[0] = 'H'; // ✗ 未定義行為 (段錯誤/SIGSEGV)

字串操作核心函數實現原理 (指針版)

// strlen
size_t my_strlen(const char *s) {
    const char *p = s;
    while (*p) p++;
    return p - s;  // 指針相減得元素個數
}

// strcpy
char *my_strcpy(char *dest, const char *src) {
    char *d = dest;
    while ((*d++ = *src++));  // 賦值 + 遞增 + 判斷 \0 (0 為假)
    return dest;
}

// strcmp
int my_strcmp(const char *s1, const char *s2) {
    while (*s1 && *s1 == *s2) { s1++; s2++; }
    return *(unsigned char*)s1 - *(unsigned char*)s2;  // 避免 char 有號溢位
}

字串指針作函數參數

void print_upper(const char *s) {  // const 承諾不修改
    while (*s) putchar(toupper(*s++));
}
// 傳遞的是首字元地址，函數內部可任意移動指針，不影響實參

四、函數指針：將函數作為數據傳遞

聲明語法解析

int (*pf)(int, int);  // pf 是指針，指向「接受兩個 int，返回 int」的函數
// 讀法: pf → *pf → (*pf)(int, int) → int

// typedef 簡化
typedef int (*BinaryOp)(int, int);
BinaryOp op = add;

賦值與調用

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

int (*pf)(int, int) = add;  // 函數名自動退化為地址
// int (*pf)(int, int) = &add; // 顯式取址也可

int result = pf(3, 5);      // 透過指針調用
// int result = (*pf)(3, 5); // 顯式解引用調用 (等價)

核心應用場景

1. 回調函數：`qsort`、`bsearch`、信號處理、事件循環
2. 狀態機/策略模式：函數指針陣列/表驅動
3. 動態載入：`dlsym` 獲取函數地址

// qsort 回調經典原型
void qsort(void *base, size_t nmemb, size_t size,
           int (*compar)(const void *, const void *));

// 策略表
typedef void (*Handler)(int);
Handler handlers[] = {handle_read, handle_write, handle_close};
handlers[event_type](fd);

五、多級指針與指針陣列

雙重指針 `int **pp`

int a = 10;
int *p = &a;
int **pp = &p;

// 解引用層層遞進:
**pp  // = *p = a = 10
*pp   // = p = &a
pp    // = &p

三大經典用途

1. 函數修改呼叫者的指針 (輸出參數為指針)
   `void allocate(int **ptr, int n) { *ptr = malloc(n * sizeof(int)); }`
2. 動態二維陣列 (指針陣列)
   `int **matrix = malloc(rows * sizeof(int*)); for(i) matrix[i] = malloc(cols * sizeof(int));`
3. `main` 參數 `argv`**

// 指針陣列: 每行獨立分配，長度可不同 (鋸齒陣列)
char *names[] = {"Alice", "Bob", "Charlie"};  // char *[]
// 記憶體: 連續指針陣列 → 離散字串

// 二維陣列: 連續塊，每行固定長度
char names2[3][10] = {"Alice", "Bob", "Charlie"}; // char [3][10]
// 記憶體: 30 bytes 連續

// C 語言: void* 可隱式轉換為任何指針類型，**無需強制轉型**
int *p = malloc(10 * sizeof(int));  // 推薦寫法
// int *p = (int*)malloc(...); // C++ 需要，C 不需要且掩蓋錯誤 (忘記 include stdlib.h)

// 分配結構體
struct Node *node = malloc(sizeof(struct Node));
// 或更安全 (不依賴類型名):
struct Node *node = malloc(sizeof *node);

int main(int argc, char *argv[])  // 等價於 char **argv
// argc: 參數個數 (含程式名)
// argv: 指針陣列，argv[0] = 程式名，argv[argc] = NULL (保證)
// 實際記憶體: 連續指針 → 連續字串 (環境變數緊隨其後)

for (int i = 1; i < argc; i++) {
    if (strcmp(argv[i], "-h") == 0) usage();
    else if (strcmp(argv[i], "-o") == 0 && i+1 < argc) output = argv[++i];
    else input = argv[i];
}
// 進階: getopt/getopt_long (POSIX 標準選項解析)

const int *p1;       // 指向 const int 的指針: *p1 不可改，p1 可改 (底層 const)
int *const p2;       // const 指針指向 int: p2 不可改，*p2 可改 (頂層 const)
const int *const p3; // 雙重 const: 都不可改
int const *p4;       // 同 p1 (const 在 * 左側修飾 *指向的類型)