C รู้จัก pointer



pointer คือหัวใจของ C และมักเป็นจุดที่มือใหม่สะดุด ค่อย ๆ อ่าน

หน่วยความจำและที่อยู่

หน่วยความจำของโปรแกรมคือช่องเรียงกันยาว ๆ แต่ละไบต์มี ที่อยู่ (address) เป็นตัวเลข ตัวแปรทุกตัวอยู่ที่ที่อยู่ใดที่อยู่หนึ่ง

#include <stdio.h>

int main(void)
{
    int x = 42;
    printf("ค่าของ x   : %d\n", x);
    printf("ที่อยู่ของ x: %p\n", (void *)&x);   // &x = "address of x"
    return 0;
}
ค่าของ x   : 42
ที่อยู่ของ x: 0x7ffe3a2b4c5c

&x อ่านว่า “address of x” — ให้ที่อยู่ในหน่วยความจำที่ x ถูกเก็บ

pointer = ตัวแปรที่เก็บที่อยู่

#include <stdio.h>

int main(void)
{
    int x = 42;
    int *p = &x;              // p เก็บที่อยู่ของ x — "p ชี้ไป x"

    printf("p เก็บ      : %p\n", (void *)p);     // ที่อยู่ของ x
    printf("*p (ค่าที่ p ชี้) : %d\n", *p);       // 42 — dereference

    *p = 100;                 // เขียนค่าผ่าน pointer ไปที่ x
    printf("x ตอนนี้    : %d\n", x);             // 100 — x เปลี่ยน!
    return 0;
}
  • int *p — ประกาศ pointer ที่ชี้ไป int (* บอกว่าเป็น pointer)
  • p = &x — ให้ p เก็บที่อยู่ของ x
  • *p — “dereference” = เข้าถึงค่าที่ p ชี้ไป (อ่านหรือเขียน)
   x                    p
┌──────┐            ┌──────────────┐
│ 100  │ ◄──────────│ 0x7ffe...5c  │
└──────┘            └──────────────┘
0x7ffe...5c

* มีสองความหมาย

int *p;          // ตอนประกาศ: "p เป็น pointer ไป int"
p = &x;
int y = *p;      // ตอนใช้: "ค่าที่ p ชี้ไป" (dereference)

int *p, q; — p เป็น pointer, q เป็น int ธรรมดา (* ผูกกับตัวแปร ไม่ใช่ชนิด) เขียนแยกบรรทัดหรือ int *p; int *q; ให้ชัด

ชนิดของ pointer สำคัญ

int *, char *, double * ต่างกัน — คอมไพเลอร์ใช้ชนิดเพื่อรู้:

  1. อ่านกี่ไบต์ตอน dereference — int * อ่าน 4 ไบต์, char * อ่าน 1 ไบต์
  2. บวก/ลบเท่าไรตอน pointer arithmetic — p + 1 ของ int * เลื่อนไป 4 ไบต์ (บทหน้า)
double d = 3.14;
double *pd = &d;
printf("%f\n", *pd);     // 3.14

// int *pi = &d;         // warning: incompatible pointer type

NULL — pointer ที่ไม่ชี้ไปไหน

#include <stdio.h>
#include <stdlib.h>       // NULL อยู่ในนี้ (หรือ stddef.h, stdio.h)

int main(void)
{
    int *p = NULL;        // p ไม่ชี้ไปที่ถูกต้องใด ๆ

    if (p == NULL) {
        printf("p ยังไม่ชี้ไปไหน\n");
    }

    // printf("%d\n", *p);   // ❌ dereference NULL = UB (บนระบบทั่วไปจะ segfault)

    int x = 5;
    p = &x;
    if (p != NULL) {
        printf("%d\n", *p);   // ปลอดภัยแล้ว
    }
    return 0;
}

เช็ค != NULL ก่อน dereference เสมอ เมื่อ pointer อาจเป็น NULL (เช่นค่าที่คืนจาก malloc, fopen, strchr)

NULL เป็น *null pointer constant* ที่ implementation กำหนด (มัก ((void *)0) หรือ 0 แล้วแต่คอมไพเลอร์ — ไม่ต้องไปสะกดเอง) — ใช้ p == NULL หรือ !p ได้ทั้งคู่

pointer ที่ยังไม่ init = อันตรายกว่า NULL

int *p;                   // ไม่ได้กำหนดค่า — ชี้ไปที่อยู่ขยะ
*p = 5;                   // เขียนลงที่ไหนก็ไม่รู้ — UB, อาจ crash อาจเงียบ ๆ ทำลายข้อมูล

บนระบบทั่วไป deref NULL มัก crash ทันที (มาตรฐานถือเป็น UB — ไม่การันตี แต่ในทางปฏิบัติ debug ง่าย) ส่วน pointer ขยะอาจชี้ไปที่ที่ “เขียนได้” ทำให้บั๊กซ่อนตัว ประกาศ pointer แล้วให้ค่าเลย int *p = NULL; หรือ int *p = &x;

pointer กับ pass by reference

จำจากบทที่ 8 — ฟังก์ชันแก้ตัวแปรของผู้เรียกไม่ได้เพราะ pass by value ส่ง pointer ไปแก้ได้:

#include <stdio.h>

void increment(int *n)       // รับ pointer
{
    (*n)++;                  // เพิ่มค่าที่ n ชี้ไป
}

int main(void)
{
    int count = 5;
    increment(&count);       // ส่งที่อยู่
    printf("%d\n", count);   // 6 — count เปลี่ยนจริง
    return 0;
}

(*n)++ ต้องมีวงเล็บ — *n++ แปลว่า *(n++) (เพิ่ม pointer แล้ว deref) บทที่ 13 ลงลึก

const กับ pointer

int x = 10;

const int *p = &x;       // ห้ามแก้ *p (แต่แก้ p ให้ชี้ที่อื่นได้)
// *p = 20;              // error
p = &y;                  // OK

int * const q = &x;      // แก้ *q ได้ แต่ q ต้องชี้ x ตลอด
*q = 20;                 // OK
// q = &y;               // error

const int * = “pointer ไป int ที่อ่านอย่างเดียว” — ใช้กับพารามิเตอร์ฟังก์ชันที่แค่อ่าน (บทที่ 30)

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

  • dereference NULL หรือ pointer ที่ไม่ init — segfault หรือ (แย่กว่า) ทำลายข้อมูลเงียบ ๆ ให้ค่า NULL ตอนประกาศเสมอ
  • int *p, q; คิดว่า q เป็น pointer — ไม่ q เป็น int แยก * ออกมา
  • ลืม & ตอนส่งเข้าฟังก์ชันที่รับ pointer — scanf("%d", n) แทน scanf("%d", &n) — segfault
  • *p เมื่อ p ยังไม่ชี้ไปที่ที่ valid — เช่นหลัง free (บทที่ 15) หรือ pointer ไป local ที่หมดอายุ
  • *n++ แทน (*n)++ — คนละความหมาย
  • %p โดยไม่ cast เป็น (void *) — technically UB, -Wall เตือน
  • สับสน p กับ *p — p คือที่อยู่, *p คือค่าที่ที่อยู่นั้น

สรุป

  • pointer = ตัวแปรที่เก็บ ที่อยู่ ของตัวแปรอื่น
  • &x = ที่อยู่ของ x, *p = ค่าที่ p ชี้ไป (อ่าน/เขียนได้)
  • ชนิดของ pointer (int * vs char *) กำหนดว่า deref อ่านกี่ไบต์ และ arithmetic เลื่อนเท่าไร
  • NULL = ไม่ชี้ไปไหน — เช็ค != NULL ก่อน deref เสมอ; ประกาศ pointer พร้อมค่าเสมอ
  • ส่ง pointer เข้าฟังก์ชัน = ให้ฟังก์ชันแก้ตัวแปรของผู้เรียกได้
  • const int *p = ห้ามแก้สิ่งที่ p ชี้

บทถัดไปว่าด้วยความสัมพันธ์ pointer กับอาร์เรย์ — array decay, pointer arithmetic และ arr[i] == *(arr + i)