Header & module

Chương trình thật không nằm trong một file khổng lồ. Dân chuyên chia nó thành các module, mỗi module là một cặp: file .h mô tả CÁI GÌ (interface công khai) và file .c chứa LÀM SAO (implementation). File khác chỉ cần #include "vec.h" là dùng được:

#ifndef VEC_H
#define VEC_H

typedef struct { int *data; int len, cap; } Vec;

void vec_init(Vec *v);
int  vec_push(Vec *v, int x);   /* tra 0 neu OK */
void vec_free(Vec *v);

#endif

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

static int vec_grow(Vec *v) {       /* RIENG TU: khong lo ra .h */
    int cap = v->cap ? v->cap * 2 : 8;
    int *p = realloc(v->data, cap * sizeof(int));
    if (!p) return -1;
    v->data = p; v->cap = cap;
    return 0;
}

void vec_init(Vec *v) { v->data = NULL; v->len = v->cap = 0; }

int vec_push(Vec *v, int x) {
    if (v->len == v->cap && vec_grow(v) != 0) return -1;
    v->data[v->len++] = x;
    return 0;
}

void vec_free(Vec *v) { free(v->data); v->data = NULL; }

#include "vec.h"      /* khong can biet vec.c lam gi ben trong */

int main(void) {
    Vec v;
    vec_init(&v);
    vec_push(&v, 10);
    vec_push(&v, 20);
    vec_free(&v);
    return 0;
}

Đây là kỹ năng cốt lõi. Phân loại từng mảnh của module vec dưới đây vào vec.h hay vec.c - bấm để xem đúng/sai và lý do:

• ▸.h (công khai): prototype hàm, kiểu (struct/typedef/enum), hằng/macro công khai, include guard.
• ▸.c (riêng tư): định nghĩa hàm, hàm static phụ trợ, include mà chỉ implementation cần.
• ▸Nguyên tắc: lộ ra interface tối thiểu, giấu mọi chi tiết còn lại.

Trong vec.c, hàm vec_grow có static đứng trước. Nó là chi tiết nội bộ - người dùng không cần và không nên thấy. static ở phạm vi file biến nó thành riêng tư (chỉ file đó dùng được):

• ▸static <hàm> → internal linkage: chỉ file .c đó gọi được; không lộ ra header.
• ▸Đóng gói: đổi/xoá hàm static thoải mái, không ai phụ thuộc nó.
• ▸Tránh đụng tên: hai file có thể cùng có hàm static tên grow() mà không xung đột.

Header tốt thì nhẹ và lộ ít. Hai thói quen quan trọng: chỉ #include thứ header THỰC SỰ cần, và dùng forward declaration khi chỉ cần một con trỏ:

/* draw.h - chi can CON TRO toi Canvas, khong can biet ben trong no */
struct Canvas;                       /* forward declaration */
void draw_line(struct Canvas *c, int x0, int y0, int x1, int y1);

/* So voi: #include "canvas.h"  -> keo theo ca the gioi cua canvas,
   tang phu thuoc & thoi gian bien dich. Chi #include khi can truy
   cap TRUONG cua Canvas hoac sizeof(Canvas). */

• ▸Include guard (#ifndef hoặc #pragma once): mỗi header chỉ dán một lần.
• ▸Include what you use: header chỉ include thứ chính nó cần cho khai báo.
• ▸Forward-declare struct khi chỉ cần con trỏ → giảm phụ thuộc, build nhanh.

Vài quy ước nhỏ tạo nên codebase chuyên nghiệp:

• ▸Tiền tố module cho mọi tên công khai: vec_init, vec_push, vec_free (C không có namespace).
• ▸Một module = MỘT trách nhiệm rõ ràng; tên file = tên module (vec.h/vec.c).
• ▸Interface ổn định: đổi implementation trong .c không làm vỡ code người dùng.
• ▸Tài liệu hoá ngay trong .h: mỗi hàm công khai một dòng nói nó làm gì, trả gì.