C union, enum และ bit-field



enum — ตั้งชื่อให้ค่าคงที่

#include <stdio.h>

enum Direction { NORTH, EAST, SOUTH, WEST };   // = 0, 1, 2, 3

enum Status {
    STATUS_PENDING = 1,
    STATUS_ACTIVE  = 2,
    STATUS_CLOSED  = 10,       // กำหนดค่าเองได้
    STATUS_ARCHIVED,           // = 11 (ต่อจากตัวก่อน)
};

int main(void)
{
    enum Direction d = EAST;
    printf("%d\n", d);         // 1

    if (d == EAST) {
        printf("ไปทางตะวันออก\n");
    }

    switch (d) {
        case NORTH: printf("เหนือ\n"); break;
        case EAST:  printf("ตะวันออก\n"); break;
        case SOUTH: printf("ใต้\n"); break;
        case WEST:  printf("ตะวันตก\n"); break;
    }
    return 0;
}
  • ค่า ของ enumeration constant เป็นชนิด int (ใน C17) — ค่าเริ่มจาก 0 เพิ่มทีละ 1 (เว้นแต่กำหนดเอง) ส่วน ชนิด enum เอง คอมไพเลอร์เลือก integer type ที่ compatible ให้ ไม่จำเป็นต้องเป็น int เสมอ
  • ใช้แทน “magic number” — if (status == 2) อ่านไม่รู้เรื่อง, if (status == STATUS_ACTIVE) อ่านออก
  • switch บน enum + -Wall เตือนถ้าลืม case ไหน (-Wswitch)

typedef ก็ได้:

typedef enum { LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR } LogLevel;

void log_msg(LogLevel level, const char *msg)
{
    const char *names[] = {"DEBUG", "INFO", "WARN", "ERROR"};
    printf("[%s] %s\n", names[level], msg);
}

enum ไม่ปลอดภัยเรื่อง type เท่าภาษาอื่น — LogLevel x = 999; คอมไพล์ผ่าน มันคือ int

union — พื้นที่ร่วม

union มี member หลายตัวแต่ ใช้หน่วยความจำที่เดียวกัน — เก็บได้ทีละอย่าง ขนาด = member ที่ใหญ่สุด

#include <stdio.h>

union Number {
    int    i;
    float  f;
    char   bytes[4];
};

int main(void)
{
    union Number n;
    printf("sizeof: %zu\n", sizeof(n));   // 4 (ไม่ใช่ 12)

    n.i = 1065353216;
    printf("as float: %f\n", n.f);        // 1.000000 — อ่านบิตเดียวกันเป็น float

    n.f = 3.14f;                           // เขียน f ทับ i
    printf("as int: %d\n", n.i);           // ค่าบิตของ 3.14 ตีความเป็น int
    return 0;
}

การเขียน member หนึ่งแล้วอ่านอีก member (type punning) — บางกรณีเป็น UB ทางที่ portable คือใช้ memcpy

tagged union — เก็บชนิดที่ต่างกันในตัวแปรเดียว อย่างปลอดภัย

รูปแบบที่ใช้จริง: struct ที่มี “tag” บอกว่าตอนนี้ union เก็บอะไร

#include <stdio.h>

typedef enum { VAL_INT, VAL_DOUBLE, VAL_STRING } ValueType;

typedef struct {
    ValueType type;
    union {
        int         as_int;
        double      as_double;
        const char *as_string;
    };
} Value;

void print_value(const Value *v)
{
    switch (v->type) {
        case VAL_INT:    printf("int: %d\n", v->as_int); break;
        case VAL_DOUBLE: printf("double: %f\n", v->as_double); break;
        case VAL_STRING: printf("string: %s\n", v->as_string); break;
    }
}

int main(void)
{
    Value a = {.type = VAL_INT, .as_int = 42};
    Value b = {.type = VAL_STRING, .as_string = "hello"};
    print_value(&a);
    print_value(&b);
    return 0;
}

type บอกเสมอว่า union field ไหน valid — อ่าน field ให้ตรงกับ tag ตัว interpreter, AST node, JSON value มักใช้รูปนี้

bit-field — บีบหลาย flag ลงในไม่กี่บิต

#include <stdio.h>

typedef struct {
    unsigned int is_active   : 1;   // 1 บิต
    unsigned int is_admin    : 1;
    unsigned int is_verified : 1;
    unsigned int role        : 3;   // 3 บิต (0-7)
    unsigned int             : 2;   // padding ไม่มีชื่อ
} UserFlags;

int main(void)
{
    UserFlags f = {0};
    f.is_active = 1;
    f.role = 5;

    printf("sizeof: %zu\n", sizeof(f));    // 4 (บีบลงใน 1 int)
    printf("active=%u role=%u\n", f.is_active, f.role);

    if (f.is_admin) { /* ... */ }
    return 0;
}
  • ตัวเลขหลัง : = จำนวนบิต
  • ประหยัดพื้นที่เมื่อมี flag เยอะ (เช่น hardware register, protocol header)
  • layout ไม่ portable — ลำดับบิต, padding ต่างกันตามคอมไพเลอร์/สถาปัตยกรรม อย่าใช้กับ format ที่ต้องแลกเปลี่ยนข้ามระบบ

ทางเลือกที่ portable กว่าสำหรับ flag: unsigned + bitwise (บทที่ 5):

#define FLAG_ACTIVE   (1u << 0)
#define FLAG_ADMIN    (1u << 1)
unsigned flags = FLAG_ACTIVE | FLAG_ADMIN;
if (flags & FLAG_ADMIN) { ... }

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

  • อ่าน union member ที่ไม่ใช่ตัวที่เพิ่งเขียน โดยไม่มี tag — ได้ค่าตีความผิด ใช้ tagged union
  • enum = type safe — ไม่ใช่ มันเป็น int, enum Color c = 999; ผ่าน
  • ลืม break ใน switch บน enum — fallthrough
  • bit-field สำหรับ file/network format — layout ไม่ portable ใช้ bitwise บน uint8_t/uint16_t
  • sizeof(union) = ผลรวม member — ไม่ ขนาด = member ใหญ่สุด (+ padding)
  • bit-field แบบ int x : 1; — int เปล่า ๆ มี signedness ที่ implementation เลือกได้ บางระบบเป็น signed (x:1 เก็บ 0/-1) ระบุ unsigned int x : 1; ให้ชัดเสมอ
  • เก็บ pointer ใน union แล้วเขียน member อื่นทับ — pointer เดิมหาย (memory leak ถ้าไม่ได้ free ก่อน)

สรุป

  • enum — ตั้งชื่อค่า int คงที่ (จาก 0 เพิ่มทีละ 1) แทน magic number; switch + -Wswitch ช่วยครบ case
  • union — member ใช้พื้นที่ร่วม เก็บได้ทีละอย่าง sizeof = member ใหญ่สุด
  • tagged union (enum tag + union) = เก็บชนิดต่างกันในตัวแปรเดียวอย่างปลอดภัย — อ่าน field ตาม tag
  • bit-field (unsigned x : 3;) — บีบหลายค่าลงในไม่กี่บิต แต่ layout ไม่ portable
  • flag ที่ portable: #define + bitwise | & ~

บทถัดไปว่าด้วยการสร้าง linked list — โครงสร้างข้อมูลแรกที่ต้อง malloc/free เอง