C struct ขั้นต่อไป



padding และ alignment — ทำไม sizeof ไม่ตรงกับที่คิด

#include <stdio.h>

struct Bad {
    char  a;      // 1 ไบต์
    int   b;      // 4 ไบต์
    char  c;      // 1 ไบต์
};

int main(void)
{
    printf("%zu\n", sizeof(struct Bad));   // 12 ไม่ใช่ 6!
    return 0;
}

CPU อ่านหน่วยความจำเร็วที่สุดเมื่อข้อมูลอยู่ที่อยู่ที่หารด้วยขนาดตัวเองลงตัว (int 4 ไบต์ ควรอยู่ที่อยู่หาร 4 ลงตัว) คอมไพเลอร์เลย แทรก padding (ไบต์ว่าง):

Bad:  [a][pad][pad][pad][b b b b][pad][pad][pad]   = 12 ไบต์

จัดเรียง member จากใหญ่ไปเล็กเพื่อลด padding:

struct Good {
    int   b;      // 4
    char  a;      // 1
    char  c;      // 1
    // pad 2
};
printf("%zu\n", sizeof(struct Good));       // 8
  • struct ทั้งก้อนถูก align ตาม member ที่ต้องการ alignment สูงสุด
  • sizeof(struct) เป็นพหุคูณของ alignment นั้นเสมอ (มี padding ท้ายด้วย เพื่อให้อาร์เรย์ของ struct ยังเรียงถูก)
  • ดู offset ของ member ด้วย offsetof(struct Bad, b) จาก <stddef.h>

เมื่อ layout สำคัญ (เขียนลงไฟล์ binary, network protocol) #pragma pack เอา padding ออกได้ก็จริง แต่ ไม่แก้เรื่อง endianness และการแทนค่าของ type ที่ต่างกันในแต่ละเครื่อง — ทางที่ปลอดภัยคือ serialize ทีละ field ด้วย byte order ที่กำหนดชัด (htonl/memcpy ทีละ field) ไม่ใช่ fwrite ทั้ง struct (ดูบท 38 §7)

designated initializer และ compound literal

typedef struct { int x, y, z; } Vec3;

Vec3 a = {.x = 1, .z = 3};              // y = 0
Vec3 b = {.y = 5};                       // x, z = 0

// compound literal — สร้าง struct ชั่วคราวกลางนิพจน์ (C99)
print_vec((Vec3){.x = 1, .y = 2, .z = 3});

Vec3 *p = &(Vec3){10, 20, 30};           // pointer ไป compound literal

designated initializer ช่วยเรื่องอ่านง่ายและกันพลาดลำดับ — ใช้เสมอเมื่อ member เยอะ

reset struct

Vec3 v = {1, 2, 3};
// ...
v = (Vec3){0};              // reset ทุก member เป็น 0
// หรือ
memset(&v, 0, sizeof v);

copy struct ที่มี pointer — shallow vs deep

typedef struct {
    char *name;             // pointer!
    int age;
} Person;

Person a;
a.name = malloc(20);
strcpy(a.name, "สมชาย");
a.age = 30;

Person b = a;               // shallow copy — b.name ชี้ก้อนเดียวกับ a.name

b.age = 31;                 // ไม่กระทบ a (age เป็น int, copy จริง)
b.name[0] = 'X';            // กระทบ a.name ด้วย! ชี้ก้อนเดียวกัน

free(a.name);
free(b.name);               // ❌ double free — ก้อนเดียวกัน!

deep copy ต้องทำเอง:

// คืน 0 = ok, -1 = หน่วยความจำไม่พอ (ไม่แตะ *dst เมื่อพลาด)
int person_copy(Person *dst, const Person *src)
{
    char *name_copy = malloc(strlen(src->name) + 1);
    if (!name_copy) {
        return -1;
    }
    strcpy(name_copy, src->name);
    dst->name = name_copy;
    dst->age = src->age;
    return 0;
}

นี่คือเหตุผลที่ C ยาก — ภาษาไม่รู้ว่า member ไหนเป็นเจ้าของ (owns) หน่วยความจำ เราต้องออกแบบเอง

nested struct — เข้าถึงลึก

typedef struct { double lat, lng; } Coord;
typedef struct { Coord location; char city[50]; } Place;
typedef struct { Place origin, destination; int distance_km; } Route;

Route r = {
    .origin = {.location = {13.75, 100.50}, .city = "กรุงเทพ"},
    .destination = {.location = {18.79, 98.98}, .city = "เชียงใหม่"},
    .distance_km = 700,
};

printf("%s -> %s: %d km\n", r.origin.city, r.destination.city, r.distance_km);
printf("จุดเริ่ม lat %.2f\n", r.origin.location.lat);

ผ่าน pointer ก็ chain -> ได้: route_ptr->origin.location.lat

flexible array member — struct + อาร์เรย์ขนาดตอนรัน

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>         // SIZE_MAX

typedef struct {
    size_t len;
    int data[];             // flexible array member — ต้องเป็น member สุดท้าย
} IntArray;

IntArray *make_array(size_t n)
{
    // sizeof(IntArray) + n*sizeof(int) — ตรวจ overflow ทั้งคูณและบวกก่อนจอง
    if (n > (SIZE_MAX - sizeof(IntArray)) / sizeof(int)) {
        return NULL;
    }
    IntArray *arr = malloc(sizeof(IntArray) + n * sizeof(int));   // struct + n ints
    if (!arr) {
        return NULL;
    }
    arr->len = n;
    for (size_t i = 0; i < n; i++) arr->data[i] = 0;
    return arr;
}

int main(void)
{
    IntArray *a = make_array(10);
    if (!a) return 1;        // เช็คก่อนใช้เสมอ
    a->data[3] = 42;
    printf("%zu %d\n", a->len, a->data[3]);
    free(a);                 // free ครั้งเดียว — ทั้ง struct + data
    return 0;
}

ข้อมูลและ header อยู่ในก้อนเดียว — free ครั้งเดียว, cache-friendly ใช้ในไลบรารีจริง (เช่น struct ของ Redis)

anonymous struct/union (C11)

typedef struct {
    int type;
    union {                  // ไม่มีชื่อ — เข้าถึง member ตรง ๆ
        int i;
        double d;
        char *s;
    };
} Value;

Value v = {.type = 1, .i = 42};
printf("%d\n", v.i);         // ไม่ต้อง v.u.i

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

  • คิดว่า sizeof(struct) = ผลรวม sizeof ของ member — มี padding ต้องวัดจริงด้วย sizeof
  • เขียน struct ลงไฟล์ binary ด้วย fwrite(&s, sizeof s, 1, f) แล้วอ่านบนเครื่องอื่น — padding/endianness ต่างกัน กำหนด format เอง
  • shallow copy struct ที่มี pointer member — double free, ข้อมูลปนกัน ต้อง deep copy
  • flexible array member ไม่ใช่ member สุดท้าย — compile error
  • sizeof(struct) แทนที่จะเป็น sizeof(struct) + n*sizeof(elem) ตอน malloc struct ที่มี flexible array
  • ไม่ตรวจ overflow ของ sizeof(struct) + n*sizeof(elem) — n จากภายนอกที่ใหญ่มากทำให้จองก้อนเล็กแล้วเขียนทะลุ เช็ค n > (SIZE_MAX - sizeof(struct)) / sizeof(elem) ก่อน
  • deep copy แล้วไม่เช็ค malloc — คืน struct ที่ name เป็น NULL แล้ว strcpy พังทันที คืนสถานะ/-1 และไม่แตะ output เมื่อพลาด
  • จัดเรียง member เล็กสลับใหญ่ — เปลือง padding เรียงใหญ่→เล็ก
  • memcmp เทียบ struct — padding มีค่าขยะ อาจไม่เท่าทั้งที่ member เท่ากัน เทียบทีละ member

สรุป

  • struct มี padding เพื่อ alignment — sizeof ใหญ่กว่าผลรวม member; เรียง member ใหญ่→เล็กลด padding
  • designated initializer (.x = 1) และ compound literal ((T){...}) — ใช้เมื่อ member เยอะ
  • copy struct ที่มี pointer = shallow — deep copy ต้องเขียนเอง (malloc + copy)
  • flexible array member (int data[]; ตัวสุดท้าย) — struct + ข้อมูลในก้อนเดียว, free ครั้งเดียว
  • อย่า fwrite struct ลงไฟล์/network ตรง ๆ — layout ไม่ portable

บทถัดไปว่าด้วย union, enum และ bit-field