C จัดการข้อผิดพลาด



C ไม่มี exception ไม่มี try/catch — จัดการ error ด้วย return value และตัวแปร global errno

รูปแบบ 1: return code

// คืน 0 = สำเร็จ, ไม่ใช่ 0 = error (มักเป็นค่าลบหรือ enum)
int parse_config(const char *path, Config *out)
{
    FILE *f = fopen(path, "r");
    if (!f) {
        return -1;              // เปิดไฟล์ไม่ได้
    }
    if (fscanf(f, "%d %d", &out->width, &out->height) != 2) {
        fclose(f);
        return -2;              // รูปแบบผิด
    }
    fclose(f);
    return 0;
}

// ผู้เรียกต้องเช็ค
Config cfg;
if (parse_config("app.conf", &cfg) != 0) {
    fprintf(stderr, "โหลด config ไม่ได้\n");
    return 1;
}

ใช้ enum แทนตัวเลขดิบให้อ่านออก:

typedef enum {
    CONFIG_OK = 0,
    CONFIG_ERR_OPEN,
    CONFIG_ERR_FORMAT,
    CONFIG_ERR_RANGE,
} ConfigResult;

รูปแบบ 2: คืน pointer, NULL = error

Node *node_create(int value)
{
    Node *n = malloc(sizeof(Node));
    if (!n) {
        return NULL;            // ผู้เรียกเช็ค NULL
    }
    n->value = value;
    n->next = NULL;
    return n;
}

fopen, malloc, strchr ทำแบบนี้

รูปแบบ 3: out-parameter สำหรับผลลัพธ์ + return บอกสถานะ

#include <limits.h>

// return 0/-1, ผลลัพธ์ผ่าน *result (ไม่แตะ *result เมื่อ error)
int safe_multiply(int a, int b, int *result)
{
    // long long การันตีว่ากว้างกว่า int → (long long)a * b ไม่มีทาง overflow
    long long product = (long long)a * b;
    if (product < INT_MIN || product > INT_MAX) {
        return -1;
    }
    *result = (int)product;
    return 0;
}

int r;
if (safe_multiply(x, y, &r) != 0) {
    fprintf(stderr, "overflow\n");
}

วิธี “เช็คก่อนคูณ” ด้วย a > INT_MAX / b ต้องแยกครบทุกคู่เครื่องหมาย (บวก×บวก, ลบ×ลบ, บวก×ลบ, ลบ×บวก) และ ระวัง INT_MIN / -1 ที่เป็น UB เอง — พลาดง่ายมาก ใช้ชนิดที่กว้างกว่า (ข้างบน) หรือ __builtin_mul_overflow(a, b, &r) ของ GCC/Clang (ส่วนขยาย) จะปลอดภัยกว่า ถ้า int กับ long long กว้างเท่ากันในระบบนั้น ต้องกลับไปเช็คทีละคู่เครื่องหมาย

errno — รหัส error ของ libc

ฟังก์ชัน library หลายตัวตั้ง errno (จาก <errno.h>) เมื่อล้มเหลว:

#include <stdio.h>
#include <errno.h>
#include <string.h>

int main(void)
{
    errno = 0;                              // reset ก่อนเรียก
    FILE *f = fopen("/ไม่มีจริง", "r");
    if (f == NULL) {
        printf("errno = %d\n", errno);           // เช่น 2 (ENOENT)
        printf("%s\n", strerror(errno));         // "No such file or directory"
        perror("fopen");                          // "fopen: No such file or directory"
    }
    return 0;
}
  • errno เป็น thread-local ในระบบสมัยใหม่
  • เช็ค errno เฉพาะหลังฟังก์ชันที่คืนค่าบอก error แล้ว — อย่าเช็ค errno เพื่อดูว่ามี error ไหม (ฟังก์ชันที่สำเร็จอาจไม่ reset errno)
  • strerror(errno) — คืนสตริงคำอธิบาย (strerror ไม่ thread-safe, มี strerror_r แบบ POSIX)
  • perror("prefix") — พิมพ์ prefix: <คำอธิบาย errno> ไป stderr

ค่า errno ที่พบบ่อย: ENOENT (ไม่พบไฟล์), EACCES (ไม่มีสิทธิ์), ENOMEM (หน่วยความจำหมด), EINVAL (argument ผิด), EEXIST (มีอยู่แล้ว)

goto cleanup — คืนทรัพยากรทุก exit path

ฟังก์ชันที่จองหลายอย่าง — ทุก error path ต้องคืนสิ่งที่จองไปแล้ว การเขียน free ซ้ำทุก if ผิดพลาดง่าย goto cleanup เป็นสำนวนที่ยอมรับใน C:

int process_data(const char *path)
{
    int rc = -1;
    FILE *f = NULL;
    char *buffer = NULL;
    int *results = NULL;

    f = fopen(path, "r");
    if (!f) {
        perror(path);
        goto cleanup;                    // rc ยังเป็น -1
    }

    buffer = malloc(BUFSIZE);
    if (!buffer) {
        goto cleanup;
    }

    results = malloc(100 * sizeof(int));
    if (!results) {
        goto cleanup;
    }

    // ... ทำงานจริง ...
    if (something_failed()) {
        goto cleanup;
    }

    rc = 0;                              // สำเร็จ

cleanup:
    free(results);                       // free(NULL) ปลอดภัย — ไม่ต้องเช็ค
    free(buffer);
    if (f) fclose(f);
    return rc;
}

กฎ:

  • ประกาศ resource เป็น NULL ไว้ก่อน (ให้ free(NULL) ทำงานได้)
  • goto ไปข้างหน้าเท่านั้น ไปที่ label เดียว (cleanup)
  • คืนทรัพยากรใน cleanup ตามลำดับย้อนกลับของการจอง
  • ตั้ง rc เป็นค่า error ไว้ก่อน เปลี่ยนเป็น 0 เฉพาะเมื่อถึงจุดสำเร็จ

หลาย label เมื่อจองเป็นขั้น (ไม่ต้อง free สิ่งที่ยังไม่จอง):

cleanup_results:
    free(results);
cleanup_buffer:
    free(buffer);
cleanup_file:
    fclose(f);
    return rc;

assert สำหรับ “ไม่ควรเกิด”

#include <assert.h>

void set_percentage(int *p, int value)
{
    assert(value >= 0 && value <= 100);   // bug ถ้าไม่จริง — crash พร้อมข้อความ
    *p = value;
}

assert สำหรับ precondition/invariant ที่ถ้าผิดแปลว่าโค้ดมีบั๊ก ไม่ใช่ error ปกติจาก input -DNDEBUG ปิด assert ทั้งหมดตอน build release — อย่าใส่ side effect ใน assert (assert(f()) — f ไม่ถูกเรียกใน release)

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

  • ไม่เช็ค return value — fopen, malloc, fscanf ล้มเหลวเงียบ ๆ แล้วพังทีหลัง
  • เช็ค errno โดยไม่ reset ก่อน หรือเช็คทั้งที่ฟังก์ชันสำเร็จ — ได้ค่าเก่า reset errno = 0 ก่อน, เช็คเฉพาะหลัง return บอก error
  • goto กระโดด *เข้า* scope ของ VLA หรือข้าม initializer แล้วใช้ตัวแปรนั้นต่อ — UB/ค่าไม่ init (goto ย้อนหลังเฉย ๆ ไม่ผิด แต่ goto cleanup ไปข้างหน้าอ่านง่ายกว่า)
  • cleanup ไม่ครบทุก path — early return ที่ลืม free = leak (ใช้ goto cleanup)
  • strerror ในโปรแกรม multi-thread — ไม่ thread-safe, ใช้ strerror_r
  • ใช้ assert แทน error handling ของ input — assert(fopen(...)) ปิดใน release = ไม่เช็คเลย
  • คืน errno ตรง ๆ เป็น return code — ปนกับ 0 (สำเร็จ) ได้ ใช้ค่าลบหรือ enum แยก

สรุป

  • ไม่มี exception — จัดการ error ด้วย: return code (0 ok, enum สำหรับชนิด), pointer (NULL = error), out-parameter + return สถานะ
  • errno (<errno.h>) — รหัส error ของ libc; perror("ctx") / strerror(errno) แปลเป็นข้อความ; reset errno=0 ก่อน, เช็คหลัง return error
  • goto cleanup — คืนทรัพยากรทุก exit path; ประกาศ resource เป็น NULL, free(NULL) ปลอดภัย, ตั้ง rc error ไว้ก่อน
  • assert = precondition/invariant (bug ถ้าผิด) ไม่ใช่ error จาก input; ปิดด้วย -DNDEBUG — ไม่มี side effect

บทถัดไปว่าด้วยการดีบั๊กด้วย gdb — breakpoint, backtrace, print และการวิเคราะห์ core dump