C จองหน่วยความจำเองด้วย malloc
จนถึงตอนนี้อาร์เรย์ของเราขนาดคงที่ตั้งแต่คอมไพล์ แต่ถ้าไม่รู้ขนาดจนกว่าจะรัน (ผู้ใช้บอกจำนวน, อ่านไฟล์ที่ไม่รู้ความยาว) ต้องจองหน่วยความจำเองบน heap
stack เทียบ heap
| stack | heap | |
|---|---|---|
| อะไรอยู่ตรงนี้ | ตัวแปร 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) ไบต์ ล้างเป็น 0calloc(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) freepointer ที่ไม่ได้มาจาก malloc — เช่นfree(&x)หรือfree(arr + 2)— UB, free ได้เฉพาะที่ malloc คืนมาเป๊ะmalloc(n * sizeof(int))โดยnมาจากscanfไม่ตรวจ —nติดลบกลายเป็นsize_tมหาศาล,nใหญ่ทำn * sizeofoverflow เช็คค่าคืนscanf+ ช่วงของnก่อนarr[i] = i * iโดยiถึงหลักหมื่น —i * ioverflow ที่ 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