C จองหน่วยความจำเองด้วย malloc



จนถึงตอนนี้อาร์เรย์ของเราขนาดคงที่ตั้งแต่คอมไพล์ แต่ถ้าไม่รู้ขนาดจนกว่าจะรัน (ผู้ใช้บอกจำนวน, อ่านไฟล์ที่ไม่รู้ความยาว) ต้องจองหน่วยความจำเองบน heap

stack เทียบ heap

stackheap
อะไรอยู่ตรงนี้ตัวแปร local, พารามิเตอร์สิ่งที่ malloc จอง
อายุจบเมื่อฟังก์ชัน returnจนกว่าเราจะ free
ขนาดจำกัด (~8 MB) กำหนดตอนคอมไพล์ใหญ่ (เกือบเท่า RAM) กำหนดตอนรัน
จัดการอัตโนมัติด้วยมือ (malloc / free)
เร็วเร็วมากช้ากว่า
void f(void)
{
    int local[100];              // บน stack — หายเมื่อ f จบ
    int *heap = malloc(100 * sizeof(int));   // บน heap — อยู่จนกว่า free
    // ...
    free(heap);
}

malloc

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
    int n = 0;
    printf("จำนวนสมาชิก: ");
    if (scanf("%d", &n) != 1 || n <= 0 || n > 46340) {   // 46340² ยังไม่ล้น int
        fprintf(stderr, "จำนวนไม่ถูกต้อง\n");
        return 1;
    }

    int *arr = malloc((size_t)n * sizeof(int));   // จอง n * 4 ไบต์
    if (arr == NULL) {                             // ** เช็คเสมอ **
        fprintf(stderr, "จองหน่วยความจำไม่สำเร็จ\n");
        return 1;
    }

    for (int i = 0; i < n; i++) {
        arr[i] = i * i;                       // ใช้เหมือนอาร์เรย์ปกติ
    }
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    free(arr);                                // คืนเมื่อใช้เสร็จ
    arr = NULL;                                // กัน use-after-free (บทที่ 15)
    return 0;
}
  • malloc(size) — จอง size ไบต์ คืน void * ไปบล็อกนั้น (หรือ NULL ถ้าไม่สำเร็จ)
  • เนื้อในเป็นขยะ — malloc ไม่ล้างเป็น 0
  • คำนวณขนาดด้วย n * sizeof(type) เสมอ ไม่ hardcode ตัวเลข

calloc — จอง + ล้างเป็น 0

int *arr = calloc(n, sizeof(int));   // จอง n ช่อง ช่องละ sizeof(int) ไบต์ ล้างเป็น 0

calloc(count, size) รับ 2 argument, ล้างหน่วยความจำเป็น 0 ทั้งหมด และ เช็ค overflow ของ count * size ให้ — ปลอดภัยกว่า malloc(count * size) เมื่อ count มาจาก input

realloc — เปลี่ยนขนาด

int *arr = malloc(4 * sizeof(int));
// ... เต็ม อยากขยาย
int *bigger = realloc(arr, 8 * sizeof(int));
if (bigger == NULL) {
    free(arr);                        // arr ยังใช้ได้ — ต้อง free เอง
    return 1;
}
arr = bigger;                         // ** อย่าเขียน arr = realloc(arr, ...) โดยตรง **

realloc:

  • ขยาย/ย่อบล็อกเดิม — อาจย้ายข้อมูลไปที่ใหม่ แล้วคืนที่อยู่ใหม่ (pointer เดิมใช้ไม่ได้แล้ว)
  • ข้อมูลเดิมถูก copy ตามให้ (ส่วนที่ขยายเป็นขยะ)
  • ถ้าล้มเหลว คืน NULL แต่บล็อกเดิมยังอยู่ — ถ้าเขียน arr = realloc(arr, ...) แล้วได้ NULL จะ leak บล็อกเดิม
  • realloc(NULL, size) = malloc(size), realloc(p, 0) = พฤติกรรมไม่แน่นอน (เลี่ยง)

free — คืนทุกก้อน

int *p = malloc(100);
// ... ใช้
free(p);              // คืน

กฎ: ทุก malloc/calloc/realloc ต้องมี free คู่กัน 1 ครั้ง ไม่มากไม่น้อย

  • ไม่ free = memory leak — โปรแกรมกินหน่วยความจำเรื่อย ๆ (สคริปต์สั้น ๆ OS เก็บคืนตอนจบ แต่ server ที่รันนาน = ระเบิด)
  • free 2 ครั้ง = double free — UB, มัก crash หรือช่องโหว่
  • ใช้หลัง free = use-after-free — UB (บทที่ 15)

free(NULL) ปลอดภัย ไม่ทำอะไร — ทำให้ cleanup ง่ายขึ้น

รูปแบบ: ฟังก์ชันสร้าง / ฟังก์ชันทำลาย

typedef struct {
    int *data;
    size_t len;
} IntList;

IntList *list_create(size_t len)
{
    IntList *list = malloc(sizeof(IntList));
    if (!list) return NULL;

    list->data = calloc(len, sizeof(int));
    if (!list->data) {
        free(list);               // คืนสิ่งที่จองไปแล้วก่อน return error
        return NULL;
    }
    list->len = len;
    return list;
}

void list_destroy(IntList *list)
{
    if (!list) return;
    free(list->data);             // คืนข้างในก่อน
    free(list);                   // แล้วค่อยคืนตัว struct
}

ทุก list_create ต้องมี list_destroy — API สไตล์นี้ทำให้ความรับผิดชอบชัด

จองสตริงตอนรัน

const char *name = "สมชาย";
size_t len = strlen(name);

char *copy = malloc(len + 1);     // +1 สำหรับ '\0' — ลืมบ่อยมาก!
if (copy) {
    strcpy(copy, name);
    printf("%s\n", copy);
    free(copy);
}

// หรือใช้ strdup (POSIX) ที่ malloc + copy ให้
char *dup = strdup(name);         // อย่าลืม free(dup)

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

  • ไม่เช็ค malloc คืน NULL — ระบบหน่วยความจำเต็ม แล้ว deref NULL = crash เช็คทุกครั้ง
  • arr = realloc(arr, n) — ถ้าคืน NULL จะ leak บล็อกเดิม ใช้ตัวแปรชั่วคราว
  • ลืม +1 ตอน malloc สตริง — malloc(strlen(s)) ไม่มีที่ให้ '\0' → buffer overflow ตอน strcpy
  • sizeof ผิด — malloc(n * sizeof(int *)) แทน sizeof(int) (จองใหญ่/เล็กเกิน) หรือ malloc(sizeof(arr)) เมื่อ arr เป็น pointer (ได้ 8)
  • free แล้วใช้ต่อ / free ซ้ำ — UB (บทหน้า)
  • leak — ทุก path ที่ return/break ต้อง free สิ่งที่จองไว้ (ใช้ goto cleanup — บทที่ 32)
  • free pointer ที่ไม่ได้มาจาก malloc — เช่น free(&x) หรือ free(arr + 2) — UB, free ได้เฉพาะที่ malloc คืนมาเป๊ะ
  • malloc(n * sizeof(int)) โดย n มาจาก scanf ไม่ตรวจ — n ติดลบกลายเป็น size_t มหาศาล, n ใหญ่ทำ n * sizeof overflow เช็คค่าคืน scanf + ช่วงของ n ก่อน
  • arr[i] = i * i โดย i ถึงหลักหมื่น — i * i overflow ที่ i≈46341 แม้ i เป็น int ปกติ จำกัดช่วงตามการคำนวณจริง

สรุป

  • stack = อัตโนมัติ อายุสั้น ขนาดคงที่; heap = malloc ด้วยมือ อยู่จน free ขนาดตอนรัน
  • malloc(n * sizeof(T)) (เนื้อขยะ), calloc(n, sizeof(T)) (ล้าง 0 + เช็ค overflow)
  • เช็ค == NULL ทุกครั้ง หลัง malloc/calloc/realloc
  • realloc อาจย้ายข้อมูล — รับผลใส่ตัวแปรใหม่ ไม่ p = realloc(p, ...)
  • ทุก malloc มี free คู่กัน 1 ครั้ง; free(NULL) ปลอดภัย; ตั้ง p = NULL หลัง free
  • malloc สตริงต้อง +1 สำหรับ '\0'

บทถัดไปว่าด้วยบั๊กหน่วยความจำและเครื่องมือจับ — use-after-free, double free, leak, และ AddressSanitizer / valgrind