C pointer กับอาร์เรย์



ใน C อาร์เรย์กับ pointer เกี่ยวพันกันแน่น จนหลายคนสับสนว่ามันคือสิ่งเดียวกัน — ไม่ใช่ แต่เชื่อมกันด้วยกฎไม่กี่ข้อ

ชื่ออาร์เรย์ = ที่อยู่ของสมาชิกตัวแรก

ในนิพจน์ส่วนใหญ่ ชื่ออาร์เรย์ “สลายตัว” (decay) เป็น pointer ไปสมาชิกตัวแรก:

#include <stdio.h>

int main(void)
{
    int arr[5] = {10, 20, 30, 40, 50};

    printf("%p\n", (void *)arr);        // ที่อยู่ของ arr[0]
    printf("%p\n", (void *)&arr[0]);    // ที่อยู่เดียวกัน
    printf("%d\n", *arr);               // 10 — deref = arr[0]

    int *p = arr;                        // ไม่ต้องมี & — arr เป็นที่อยู่อยู่แล้ว
    printf("%d\n", *p);                  // 10
    return 0;
}

ข้อยกเว้นที่ไม่ decay: sizeof(arr) (ได้ขนาดทั้งอาร์เรย์), &arr (ได้ pointer ไปทั้งอาร์เรย์ ชนิด int (*)[5])

arr[i] คือ *(arr + i)

int arr[5] = {10, 20, 30, 40, 50};

printf("%d\n", arr[2]);        // 30
printf("%d\n", *(arr + 2));    // 30 — เหมือนกันเป๊ะ

// จริง ๆ compiler แปลง arr[i] เป็น *(arr + i) เสมอ
// ผลข้างเคียงประหลาด: 2[arr] ก็ใช้ได้! (*(2 + arr)) — อย่าเขียนแบบนี้

arr[i] = “ไปที่ arr เลื่อน i ตำแหน่ง แล้วเอาค่าตรงนั้น”

pointer arithmetic — เลื่อนทีละ “ขนาดของชนิด”

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;                  // p ชี้ arr[0]

printf("%d\n", *p);            // 10
printf("%d\n", *(p + 1));      // 20 — p+1 เลื่อนไป 4 ไบต์ (sizeof(int)) ไม่ใช่ 1 ไบต์!
printf("%d\n", *(p + 3));      // 40

p++;                           // ตอนนี้ p ชี้ arr[1]
printf("%d\n", *p);            // 20

p += 2;                        // ชี้ arr[3]
printf("%d\n", *p);            // 40

p + n เลื่อนไป n * sizeof(*p) ไบต์ — คอมไพเลอร์คูณขนาดชนิดให้ ทำให้ *(p + i) ชี้สมาชิกที่ i พอดี

char   ca[4] = "abc";
double da[3] = {1.0, 2.0, 3.0};

char   *pc = ca;              // ชี้อาร์เรย์จริง (ต้องมีที่ให้ชี้ก่อนบวก)
double *pd = da;

// pc+1 กับ pd+1 เลื่อน "1 สมาชิก" เท่ากัน แต่คนละระยะไบต์
printf("%zu\n", (size_t)((char *)(pc + 1) - (char *)pc));   // 1  = sizeof(char)
printf("%zu\n", (size_t)((char *)(pd + 1) - (char *)pd));   // 8  = sizeof(double)

double *pd; เฉย ๆ แล้วเขียน pd + 1 เป็น undefined behavior — pointer ยังไม่ชี้อะไร ต้องให้ชี้อาร์เรย์ (หรือหน่วยความจำจาก malloc) ก่อนทำ pointer arithmetic

ผลต่างของ pointer สองตัว

int arr[5] = {10, 20, 30, 40, 50};
int *start = &arr[1];
int *end   = &arr[4];

printf("%td\n", end - start);   // 3 — จำนวน "สมาชิก" ที่ห่างกัน (ไม่ใช่ไบต์)

ผลต่างมีชนิด ptrdiff_t — ใช้ %td ใน printf ใช้ได้เฉพาะ pointer สองตัวที่ชี้ในอาร์เรย์เดียวกัน

เดินอาร์เรย์ด้วย pointer

int arr[5] = {10, 20, 30, 40, 50};

// แบบ index
for (int i = 0; i < 5; i++) {
    printf("%d ", arr[i]);
}

// แบบ pointer
for (int *p = arr; p < arr + 5; p++) {
    printf("%d ", *p);
}
printf("\n");

ทั้งสองให้ผลเหมือนกัน — สไตล์ pointer พบบ่อยในโค้ดที่เดินสตริง:

size_t my_strlen(const char *s)
{
    const char *p = s;
    while (*p != '\0') {       // เดินจนเจอ null terminator
        p++;
    }
    return p - s;              // จำนวน char ที่เดินมา
}

อาร์เรย์กับ pointer — ต่างกันตรงไหน

อาร์เรย์ int a[5]pointer int *p
เก็บอะไรสมาชิก 5 ตัวที่อยู่หนึ่งค่า
sizeof5 * sizeof(int) (มัก 20)ขนาดของ pointer (มัก 8 บนระบบ 64 บิต, 4 บน 32 บิต)
assign ใหม่ไม่ได้ (a = ... error)ได้ (p = ...)
&a vs &pชนิด int (*)[5]ชนิด int **

p = a; ได้ (a decay เป็น address), แต่ a = p; ไม่ได้ (a ไม่ใช่ตัวแปรที่ assign ได้)

ทำไมฟังก์ชันรับอาร์เรย์ = รับ pointer

void f(int arr[]);       // เหมือนกันทั้งหมด
void f(int arr[100]);    // ตัวเลขถูกเมิน
void f(int *arr);        //

int a[10];
f(a);                    // a decay เป็น &a[0] ส่ง pointer ไป

ในฟังก์ชัน sizeof(arr) = ขนาดของ pointer (มัก 8) ไม่ใช่ขนาดอาร์เรย์ — ต้องรับขนาดเป็นพารามิเตอร์แยกเสมอ (บทที่ 9)

ระวังเดิน pointer เกินขอบ

int arr[5];
int *p = arr;
p += 10;                 // ชี้นอกอาร์เรย์ — การคำนวณเองก็ UB (แม้ยังไม่ deref)
*p = 0;                  // เขียนนอกขอบ — เขียนทับอะไรก็ไม่รู้

int *q = arr + 5;        // OK — one-past-the-end เป็นที่อยู่ที่ valid สำหรับ "เปรียบเทียบ"
// *q                    // แต่ deref ไม่ได้

arr + n (ชี้หลังสมาชิกสุดท้ายพอดี) ใช้เปรียบเทียบใน loop ได้ (p < arr + n) แต่ห้าม deref

เรื่องที่คนมักพลาด

  • คิดว่า p + 1 เลื่อน 1 ไบต์ — เลื่อน sizeof(*p) ไบต์ (สำหรับ int * มัก 4)
  • sizeof(arr) ในฟังก์ชัน — ได้ 8 ไม่ใช่ขนาดอาร์เรย์ ส่งขนาดแยก
  • a = p; เมื่อ a เป็นอาร์เรย์ — assign อาร์เรย์ไม่ได้
  • เดิน pointer เกินอาร์เรย์ — แม้แค่คำนวณ p + bignum (ไม่ deref) ก็เป็น UB
  • &arr vs arr — ค่าเลขเท่ากันแต่คนละชนิด (int(*)[5] vs int*) &arr + 1 เลื่อน 20 ไบต์
  • char *s = "abc"; s[3] — เป็น '\0', s[4] = นอกขอบ
  • deref arr + n (one-past-end) — ที่อยู่นั้น valid แต่ deref ไม่ได้

สรุป

  • ชื่ออาร์เรย์ในนิพจน์ส่วนใหญ่ = pointer ไปสมาชิกตัวแรก (&a[0]) — ยกเว้น sizeof(a), &a
  • arr[i] ≡ *(arr + i) — คอมไพเลอร์แปลงแบบนี้เสมอ
  • p + n เลื่อน n * sizeof(*p) ไบต์ — คูณขนาดชนิดให้อัตโนมัติ
  • end - start = จำนวนสมาชิกที่ห่างกัน (ชนิด ptrdiff_t, %td)
  • อาร์เรย์ ≠ pointer: ต่างที่ sizeof, การ assign, & — แต่แปลงกันได้ในหลายบริบท
  • ห้ามคำนวณ/deref pointer เกินขอบอาร์เรย์ (one-past-end เปรียบเทียบได้ deref ไม่ได้)

บทถัดไปว่าด้วยการส่งค่ากลับผ่าน pointer — swap, out-parameter และ pointer parameter แบบ const