C สร้าง static library และแยกโมดูล



เมื่อมีโค้ดชุดหนึ่งที่หลายโปรแกรมใช้ (โครงสร้างข้อมูล, utility) รวมเป็น library แล้ว link เข้าโปรแกรมต่าง ๆ

static library = archive ของ .o

gcc -std=c17 -Wall -Wextra -c list.c    # -> list.o
gcc -std=c17 -Wall -Wextra -c hashmap.c # -> hashmap.o
gcc -std=c17 -Wall -Wextra -c strutil.c # -> strutil.o

ar rcs libmystuff.a list.o hashmap.o strutil.o

ar (archiver) รวม .o เป็นไฟล์เดียว .a:

  • r — เพิ่ม/แทนที่ไฟล์ใน archive
  • c — สร้าง archive ใหม่ถ้ายังไม่มี
  • s — สร้าง index (symbol table) ให้ linker หาเร็ว

ธรรมเนียม: ชื่อขึ้นต้น lib ลงท้าย .a — libmystuff.a

gcc main.c -L. -lmystuff -o prog
  • -L. — หา library ในโฟลเดอร์ปัจจุบัน (.)
  • -lmystuff — link libmystuff.a (เขียน mystuff ไม่ใช่ libmystuff.a)
  • ต้องมาหลังไฟล์ที่ใช้มัน — gcc -lmystuff main.c อาจ link ไม่ติด (linker ประมวลผลซ้ายไปขวา)

ตอน link linker หยิบเฉพาะ .o ที่ ถูกใช้จริง จาก archive มาใส่ executable

ที่ static — โค้ด library ถูกฝังใน executable

libmystuff.a  ──(link)──►  prog (มีโค้ด list, hashmap ฝังอยู่ในตัว)
  • executable ใหญ่ขึ้น แต่รันได้เดี่ยว ๆ ไม่ต้องมี .a บนเครื่องปลายทาง
  • อัปเดต library ต้อง re-link executable ใหม่
  • ต่างจาก shared library (.so / .dll) ที่โหลดตอนรัน หลายโปรแกรมใช้ไฟล์เดียว (ท้ายบท)

Makefile สำหรับ library + โปรแกรม

CC = gcc
CFLAGS = -std=c17 -Wall -Wextra -g -MMD -MP    # -MMD -MP: ให้ gcc สร้าง dependency ของ header (บทที่ 27)
LIB = libmystuff.a
LIB_OBJS = list.o hashmap.o strutil.o
OBJS = main.o $(LIB_OBJS)

all: prog

$(LIB): $(LIB_OBJS)
	ar rcs $@ $^

prog: main.o $(LIB)
	$(CC) $(CFLAGS) -o $@ main.o -L. -lmystuff

%.o: %.c
	$(CC) $(CFLAGS) -c $< -o $@

.PHONY: all clean
clean:
	rm -f prog *.o *.d $(LIB)

-include $(OBJS:.o=.d)

pattern rule %.o: %.c มีแค่ .c เป็น prerequisite — แก้ header แล้ว .o (และ library) จะค้างโค้ดเก่า ต้องเพิ่ม -MMD -MP + -include *.d เหมือนบท 27 ไม่งั้น make บอก “Nothing to be done” ทั้งที่ interface เปลี่ยน

ออกแบบ header ที่ดี

header คือ “สัญญา” ที่ผู้ใช้ library เห็น — ให้เปิดเผยเท่าที่จำเป็น

vector.h — เปิดเผย struct (ผู้ใช้เข้าถึง field ได้)

#ifndef VECTOR_H
#define VECTOR_H

#include <stddef.h>

typedef struct {
    int   *data;
    size_t len;
    size_t cap;
} Vector;

Vector *vec_new(void);
void    vec_free(Vector *v);
int     vec_push(Vector *v, int value);
int     vec_get(const Vector *v, size_t i, int *out);
size_t  vec_len(const Vector *v);

#endif

opaque pointer — ซ่อน struct ทั้งหมด

ถ้าไม่อยากให้ผู้ใช้แตะ field ข้างใน (เปลี่ยน implementation ได้อิสระ) — ประกาศแค่ชื่อ struct ใน header, นิยามจริงใน .c:

stack.h

#ifndef STACK_H
#define STACK_H

typedef struct Stack Stack;      // ประกาศชื่อ ไม่บอก field — opaque

Stack *stack_new(void);
void   stack_free(Stack *s);
int    stack_push(Stack *s, int value);
int    stack_pop(Stack *s, int *out);   // คืน 0 = ok, -1 = ว่าง
int    stack_is_empty(const Stack *s);

#endif

stack.c

#include "stack.h"
#include <stdlib.h>

struct Stack {                    // นิยามจริง — ผู้ใช้ library มองไม่เห็น
    int   *items;
    size_t len;
    size_t cap;
};

Stack *stack_new(void)
{
    Stack *s = malloc(sizeof(struct Stack));
    if (!s) return NULL;
    s->items = NULL;
    s->len = s->cap = 0;
    return s;
}
// ... ที่เหลือ

ผู้ใช้ทำได้แค่ Stack *s = stack_new(); แล้วเรียกฟังก์ชัน — เข้า s->len ไม่ได้ (ชนิดไม่สมบูรณ์) ทำให้เราเปลี่ยนโครงสร้างข้างในได้โดยไม่กระทบผู้ใช้ นี่คือ encapsulation แบบ C — ใช้ใน FILE, SQLite (sqlite3), pthreads

หลักการออกแบบ library API

  • 1 header ต่อ 1 โมดูล, มี include guard
  • ฟังก์ชัน public เท่านั้นใน header, ตัวช่วยเป็น static ใน .c
  • ตั้ง prefix ให้ทุกชื่อ (vec_, stack_) กันชนกับผู้ใช้
  • return code สม่ำเสมอ (0 ok, ไม่ใช่ 0 error) หรือ pointer (NULL = error)
  • คู่ xxx_new / xxx_free ให้ ownership ชัด
  • const กับ parameter ที่แค่อ่าน
  • อย่า #include header ที่ไม่จำเป็นใน header ของเรา (เพิ่ม compile time ให้ผู้ใช้)

shared library — พอให้รู้จัก

gcc -fPIC -c list.c hashmap.c
gcc -shared -o libmystuff.so list.o hashmap.o
gcc main.c -L. -lmystuff -o prog
LD_LIBRARY_PATH=. ./prog          # บอกที่อยู่ .so ตอนรัน
  • .so (Linux) / .dylib (macOS) / .dll (Windows)
  • โหลดตอนรัน — executable เล็ก, หลายโปรแกรมใช้ไฟล์เดียว, อัปเดต library ไม่ต้อง re-link
  • แต่ต้องมี .so บนเครื่องปลายทาง และเวอร์ชันต้องเข้ากัน (“DLL hell”)
  • ระบบ libc, libssl ฯลฯ เป็น shared library

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

  • วาง -lmystuff ก่อน main.o — linker ยังไม่รู้ว่าต้องใช้ symbol ไหน → undefined reference วางหลัง
  • ลืม -L. — linker หา libmystuff.a ไม่เจอ (มันไม่หาในโฟลเดอร์ปัจจุบันโดยอัตโนมัติ)
  • แก้ .c ของ library แล้วไม่ ar rcs ใหม่ — .a ยังมีโค้ดเก่า
  • opaque struct แล้วผู้ใช้ sizeof(Stack) — incomplete type ใช้ไม่ได้ (นั่นคือจุดประสงค์ — ต้องผ่าน stack_new)
  • header ของ library #include <stdio.h> ทั้งที่ไม่จำเป็น — บังคับให้ทุกผู้ใช้โหลด stdio
  • ไม่ใส่ prefix ให้ชื่อฟังก์ชัน — push, get, new ชนกับโค้ดผู้ใช้ตอน link

สรุป

  • ar rcs libX.a a.o b.o รวม object เป็น static library
  • link: gcc main.c -L<dir> -lX -o prog — -l มาหลังไฟล์ที่ใช้มัน
  • static = โค้ด library ฝังใน executable (รันเดี่ยวได้, ใหญ่ขึ้น); shared .so = โหลดตอนรัน
  • header ดี: 1 โมดูล/1 header + guard, public เท่านั้น, มี prefix, new/free คู่กัน
  • opaque pointer (typedef struct S S; ใน header, นิยามใน .c) = ซ่อน struct ทั้งหมด เปลี่ยน implementation ได้อิสระ

จบเฟสไฟล์/build บทถัดไปเข้าเฟสความถูกต้อง เริ่มที่ undefined behavior — สิ่งที่ต้องเข้าใจและกลัวมากที่สุดใน C