C struct — รวมข้อมูลหลายชนิด



struct จับตัวแปรหลายตัว (ชนิดต่างกันได้) มัดเป็นก้อนเดียว — เหมือน record หรือ object แบบไม่มี method

ประกาศและใช้งาน

#include <stdio.h>

struct Point {
    int x;
    int y;
};

int main(void)
{
    struct Point p;          // ต้องเขียน "struct Point" เต็ม
    p.x = 3;
    p.y = 7;

    printf("(%d, %d)\n", p.x, p.y);   // (3, 7)

    struct Point q = {10, 20};        // initialize ตามลำดับ
    struct Point r = {.y = 5, .x = 2}; // designated initializer (C99) — ระบุชื่อ
    struct Point z = {0};             // ทุก member เป็น 0

    printf("(%d, %d)\n", q.x, q.y);
    return 0;
}
  • ประกาศ member ใน { } ปิดด้วย ; หลังปีกกา
  • เข้าถึงด้วย . (dot)
  • struct Point p; — ต้องมีคำว่า struct (ต่างจาก typedef ด้านล่าง)

typedef struct — ตัดคำว่า struct

typedef struct {
    char name[50];
    int age;
    double gpa;
} Student;

int main(void)
{
    Student s = {"สมชาย", 20, 3.5};
    printf("%s อายุ %d GPA %.2f\n", s.name, s.age, s.gpa);

    Student s2;
    strcpy(s2.name, "สมหญิง");     // อาร์เรย์ในstruct — ต้อง strcpy ไม่ใช่ =
    s2.age = 22;
    return 0;
}

typedef struct { ... } Student; — หลังจากนี้เขียน Student s; ได้เลย (ไม่ต้อง struct) เป็นสไตล์ที่นิยม

รูปแบบที่ให้ทั้งชื่อ tag และ typedef (จำเป็นเมื่อ struct อ้างถึงตัวเอง เช่น linked list):

typedef struct Node {
    int value;
    struct Node *next;      // ต้องใช้ "struct Node" ตรงนี้ (typedef ยังไม่เสร็จ)
} Node;

struct copy ด้วย = ได้

ต่างจากอาร์เรย์ — struct assign/copy ทั้งก้อนได้:

struct Point a = {1, 2};
struct Point b = a;        // copy ทุก member
b.x = 99;
printf("%d %d\n", a.x, b.x);   // 1 99 — เป็นสำเนา แยกกัน

แต่ถ้า member เป็น pointer มันจะ copy แค่ที่อยู่ (shallow copy) — ทั้งสอง struct ชี้ข้อมูลเดียวกัน

struct กับ pointer — ใช้ ->

#include <stdio.h>

typedef struct {
    int x, y;
} Point;

void move(Point *p, int dx, int dy)
{
    p->x += dx;             // (*p).x += dx  เขียนย่อเป็น p->x
    p->y += dy;
}

int main(void)
{
    Point p = {0, 0};
    move(&p, 3, 4);
    printf("(%d, %d)\n", p.x, p.y);   // (3, 4)
    return 0;
}

p->x = (*p).x — “member x ของ struct ที่ p ชี้ไป” ใช้ -> เมื่อมี pointer, . เมื่อมี struct ตรง ๆ

ส่ง struct เข้าฟังก์ชัน — by value หรือ by pointer

// by value — copy ทั้ง struct (เปลืองถ้า struct ใหญ่, แก้ไม่กระทบตัวเดิม)
double distance(Point a, Point b)
{
    double dx = (double)a.x - b.x;    // ลบ/ยกกำลังเป็น double — เลี่ยง int overflow ก่อนเข้า sqrt
    double dy = (double)a.y - b.y;
    return sqrt(dx * dx + dy * dy);
}

// by pointer — ส่งแค่ที่อยู่ (เร็ว, แก้ได้)  ใส่ const ถ้าแค่อ่าน
void print_point(const Point *p)
{
    printf("(%d, %d)\n", p->x, p->y);
}

แนวปฏิบัติ: struct เล็ก (2-3 int) ส่ง by value ได้ struct ใหญ่หรือต้องแก้ ส่ง by pointer (const T * ถ้าแค่อ่าน)

คืน struct จากฟังก์ชัน

ต่างจากอาร์เรย์ — คืน struct by value ได้ (ปลอดภัย เป็นสำเนา):

Point make_point(int x, int y)
{
    Point p = {x, y};
    return p;              // OK — copy กลับไป (ไม่ใช่ dangling เหมือนอาร์เรย์)
}

int main(void)
{
    Point origin = make_point(0, 0);
    return 0;
}

struct ใน struct

typedef struct {
    int day, month, year;
} Date;

typedef struct {
    char title[100];
    Date published;
    int pages;
} Book;

int main(void)
{
    Book b = {
        .title = "เรียนภาษา C",
        .published = {.day = 15, .month = 9, .year = 2026},
        .pages = 320,
    };
    printf("%s (%d/%d/%d)\n", b.title, b.published.day,
           b.published.month, b.published.year);
    return 0;
}

อาร์เรย์ของ struct

Student class[3] = {
    {"อร",  20, 3.5},
    {"บอย", 21, 2.8},
    {"แก้ว", 19, 3.9},
};

for (int i = 0; i < 3; i++) {
    printf("%s: %.2f\n", class[i].name, class[i].gpa);
}

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

  • ลืมคำว่า struct — Point p; ไม่ได้ ถ้าไม่ได้ typedef ต้อง struct Point p;
  • . กับ pointer — p.x เมื่อ p เป็น Point * — ต้อง p->x (คอมไพเลอร์เตือน)
  • s.name = "hi" เมื่อ name เป็น char[] — assign อาร์เรย์ไม่ได้ ใช้ strcpy(s.name, "hi")
  • copy struct ที่มี pointer member ด้วย = — shallow copy ทั้งสองชี้ข้อมูลเดียวกัน (double free ตามมา)
  • ส่ง struct ใหญ่ by value ในลูป — copy ทุกรอบ ช้า ใช้ const T *
  • struct Node { struct Node next; } — struct มีตัวเองเป็น member (ขนาดไม่รู้จบ) ต้องเป็น struct Node *next
  • เปรียบเทียบ struct ด้วย a == b — ไม่ได้ ต้องเทียบ member ทีละตัวตามชนิด memcmp เทียบไบต์ดิบ — padding ที่มีขยะ และ float (-0.0 vs 0.0, NaN) ทำให้ผลผิด ใช้เฉพาะเมื่อตั้งใจเทียบ representation จริง ๆ

สรุป

  • struct { members; }; รวมตัวแปรหลายชนิด, เข้าถึงด้วย .
  • typedef struct { ... } Name; — เขียน Name x; ได้โดยไม่ต้อง struct
  • struct copy/assign/return by value ได้ (ต่างจากอาร์เรย์) — เป็นสำเนา
  • pointer ไป struct: ใช้ p->member (= (*p).member)
  • ส่งฟังก์ชัน: struct เล็ก by value, struct ใหญ่/ต้องแก้ ใช้ T * (หรือ const T * ถ้าอ่าน)
  • struct ที่อ้างตัวเองต้องผ่าน pointer (struct Node *next)

บทถัดไปว่าด้วย struct ขั้นต่อไป — nested struct ลึกขึ้น, padding/alignment และ designated initializer