Thư viện chuẩn C: bản đồ các header đáng biết

Bản thân ngôn ngữ C rất nhỏ: kiểu dữ liệu, toán tử, luồng điều khiển, hàm, con trỏ. Nó không thể in ra màn hình, đọc tệp, so sánh chuỗi hay cấp phát bộ nhớ. Tất cả những việc đó thuộc về thư viện chuẩn (standard library): một bộ header mà mọi bản cài đặt đúng chuẩn đều đi kèm.

Trang này là một tấm bản đồ. Mỗi phần cho biết một header dùng để làm gì, đưa ra một ví dụ ngắn chạy được, và trỏ tới trang chi tiết hơn nếu có.

stdio.h: nhập và xuất

Header bạn include đầu tiên trong gần như mọi chương trình. Nó chứa printf và scanf, kiểu FILE và các hàm làm việc với tệp, cùng các hàm nhập theo dòng an toàn hơn.

#include <stdio.h>

int main(void) {
    printf("Formatted: %d %s %.2f %c\n", 42, "text", 3.14159, 'X');

    /* fputs writes without interpreting format specifiers */
    fputs("Plain output, no formatting\n", stdout);

    /* stderr is a separate stream for diagnostics */
    fprintf(stderr, "This goes to standard error\n");

    /* putchar writes a single character */
    for (char c = 'a'; c <= 'e'; c++) {
        putchar(c);
    }
    putchar('\n');
    return 0;
}

Những hàm thiết yếu: printf, fprintf, sprintf, snprintf cho đầu ra; scanf, fscanf, sscanf, fgets, getchar cho đầu vào; fopen, fclose, fread, fwrite, fseek cho tệp. Nội dung chi tiết hơn nằm ở printf, scanf và xử lý tệp.

Một quy tắc nên nhớ: đừng bao giờ dùng gets(). Hàm này không có cách nào biết kích thước bộ đệm của bạn và đã bị loại khỏi tiêu chuẩn từ C11. fgets(buf, sizeof buf, stdin) là hàm thay thế.

stdlib.h: các tiện ích chung

Header gom đủ thứ: bộ nhớ, chuyển đổi, số ngẫu nhiên, điều khiển tiến trình, sắp xếp.

#include <stdio.h>
#include <stdlib.h>

int compare_ints(const void *a, const void *b) {
    int x = *(const int *)a;
    int y = *(const int *)b;
    return (x > y) - (x < y);
}

int main(void) {
    /* string to number */
    printf("atoi(\"123\")     = %d\n", atoi("123"));
    printf("strtol(\"ff\", 16) = %ld\n", strtol("ff", NULL, 16));
    printf("atof(\"3.5\")     = %.2f\n", atof("3.5"));

    /* dynamic memory */
    int *nums = malloc(5 * sizeof *nums);
    if (nums == NULL) {
        return 1;
    }
    int seed_values[] = {50, 10, 40, 20, 30};
    for (int i = 0; i < 5; i++) {
        nums[i] = seed_values[i];
    }

    /* qsort sorts anything given a comparison function */
    qsort(nums, 5, sizeof *nums, compare_ints);
    for (int i = 0; i < 5; i++) {
        printf("%d ", nums[i]);
    }
    printf("\n");

    free(nums);
    return 0;
}

Nổi bật: malloc, calloc, realloc, free (xem cấp phát bộ nhớ động); atoi, atof, strtol, strtod để chuyển đổi, và nên ưu tiên họ strto* vì chúng báo được lỗi, trong khi atoi âm thầm trả về 0; rand và srand (xem số ngẫu nhiên); exit, abort, getenv, system; và qsort/bsearch.

string.h: chuỗi và khối bộ nhớ

Chuỗi trong C là mảng char kết thúc bằng '\0', và mọi thao tác trên chúng đều là một lời gọi hàm.

#include <stdio.h>
#include <string.h>

int main(void) {
    char dest[64] = "Hello";

    printf("strlen  : %zu\n", strlen(dest));

    strcat(dest, ", world");
    printf("strcat  : %s\n", dest);

    printf("strcmp  : %d\n", strcmp("apple", "banana"));
    printf("strchr  : %s\n", strchr(dest, 'w'));
    printf("strstr  : %s\n", strstr(dest, "world"));

    char copy[64];
    strcpy(copy, dest);
    printf("strcpy  : %s\n", copy);

    /* the mem* functions work on raw bytes, not just text */
    char block[10];
    memset(block, '-', 9);
    block[9] = '\0';
    printf("memset  : %s\n", block);
    return 0;
}

Hai thói quen giúp header này không trở thành nguồn gây tràn bộ đệm: luôn biết kích thước của vùng đích, và nhớ rằng strcmp trả về 0 khi bằng nhau, nên if (strcmp(a, b)) đúng khi hai chuỗi khác nhau. Các hàm xử lý chuỗi trình bày chi tiết các cách dùng strncpy/snprintf an toàn hơn.

math.h: toán học

sqrt, pow, fabs, floor, ceil, round, fmod, nhóm hàm lượng giác và logarit, INFINITY và NAN.

#include <stdio.h>
#include <math.h>

int main(void) {
    printf("sqrt(2)     = %.6f\n", sqrt(2.0));
    printf("pow(2, 10)  = %.0f\n", pow(2.0, 10.0));
    printf("ceil(4.1)   = %.0f\n", ceil(4.1));
    printf("fabs(-9.5)  = %.1f\n", fabs(-9.5));
    return 0;
}

Đây là header duy nhất có thể cần thêm cờ cho trình liên kết: trên Linux, hãy thêm -lm ở cuối lệnh biên dịch, nếu không trình liên kết sẽ báo "undefined reference to sqrt". Xem đầy đủ ở các hàm toán học.

time.h: đồng hồ và ngày tháng

#include <stdio.h>
#include <time.h>

int main(void) {
    time_t now = time(NULL);
    printf("Seconds since 1970: %ld\n", (long) now);
    printf("Local time: %s", ctime(&now));

    struct tm *lt = localtime(&now);
    printf("Year: %d, month: %d, day: %d\n",
           lt->tm_year + 1900, lt->tm_mon + 1, lt->tm_mday);

    char buf[64];
    strftime(buf, sizeof buf, "%Y-%m-%d %H:%M:%S", lt);
    printf("Formatted: %s\n", buf);

    /* clock() measures processor time used by this program */
    clock_t start = clock();
    volatile long sum = 0;
    for (long i = 0; i < 3000000L; i++) {
        sum += i;
    }
    double secs = (double)(clock() - start) / CLOCKS_PER_SEC;
    printf("Loop took %.4f CPU seconds\n", secs);
    return 0;
}

Hai độ lệch trong struct tm khiến ai cũng vấp: tm_year đếm từ năm 1900, và tm_mon bắt đầu từ 0. time(NULL) cũng là seed thường dùng cho srand.

ctype.h: phân loại ký tự

Nhỏ, nhưng hữu ích hơn vẻ ngoài. Mỗi hàm nhận một ký tự và trả lời một câu hỏi có hoặc không, hoặc đổi chữ hoa chữ thường.

#include <stdio.h>
#include <ctype.h>

int main(void) {
    const char *text = "Coddy C17, launched!";

    int letters = 0, digits = 0, spaces = 0, punct = 0;
    for (const char *p = text; *p != '\0'; p++) {
        unsigned char c = (unsigned char) *p;
        if (isalpha(c))      letters++;
        else if (isdigit(c)) digits++;
        else if (isspace(c)) spaces++;
        else if (ispunct(c)) punct++;
    }
    printf("letters=%d digits=%d spaces=%d punctuation=%d\n",
           letters, digits, spaces, punct);

    printf("Upper: ");
    for (const char *p = text; *p != '\0'; p++) {
        putchar(toupper((unsigned char) *p));
    }
    printf("\n");
    return 0;
}

Bộ đầy đủ: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, cùng toupper và tolower.

Hãy để ý phép ép kiểu (unsigned char). Các hàm này được định nghĩa cho những giá trị biểu diễn được bằng unsigned char cộng thêm EOF; trên đa số hệ thống, char thường là kiểu có dấu, nên một byte lớn hơn 127 sẽ đến dưới dạng số âm và lời gọi trở thành undefined behavior. Phép ép kiểu không tốn gì và loại bỏ cả một lớp vấn đề.

Và hãy ưu tiên các hàm này thay vì tự viết phép kiểm tra. c >= '0' && c <= '9' tình cờ chạy đúng, nhưng isdigit(c) nói đúng ý bạn và luôn đúng ở mọi nơi.

limits.h và float.h: giới hạn của các kiểu

Một int có thể lớn tới đâu trên máy này? Các header này trả lời câu hỏi đó, và chính những câu trả lời ấy là lý do code khả chuyển phải hỏi thay vì giả định.

#include <stdio.h>
#include <limits.h>
#include <float.h>

int main(void) {
    printf("char  : %d to %d (%zu byte)\n", CHAR_MIN, CHAR_MAX, sizeof(char));
    printf("int   : %d to %d (%zu bytes)\n", INT_MIN, INT_MAX, sizeof(int));
    printf("long  : %ld to %ld (%zu bytes)\n", LONG_MIN, LONG_MAX, sizeof(long));
    printf("uint  : 0 to %u\n", UINT_MAX);

    printf("float : %g to %g (%zu bytes)\n", FLT_MIN, FLT_MAX, sizeof(float));
    printf("double: %g to %g (%zu bytes)\n", DBL_MIN, DBL_MAX, sizeof(double));
    printf("double has %d decimal digits of precision\n", DBL_DIG);
    return 0;
}

INT_MAX là cách kiểm tra tràn số trước khi nó xảy ra, điều này quan trọng vì tràn số có dấu là undefined behavior, chứ không phải một vòng quay lại mà bạn có thể kiểm tra sau đó.

stdbool.h và stdint.h: kiểu dữ liệu tốt hơn

C không có kiểu boolean cho đến C99. <stdbool.h> cung cấp một kiểu như vậy:

#include <stdio.h>
#include <stdbool.h>

bool is_even(int n) {
    return n % 2 == 0;
}

int main(void) {
    bool ready = true;
    bool done  = false;

    printf("ready=%d done=%d\n", ready, done);
    printf("is_even(10) = %s\n", is_even(10) ? "true" : "false");
    return 0;
}

bool, true và false là các macro cho _Bool, 1 và 0, nhưng chúng làm ý định trở nên rõ ràng. (Từ C23 chúng trở thành từ khóa và không cần header nữa.)

<stdint.h> cung cấp các kiểu có độ rộng được đảm bảo, thiết yếu cho định dạng tệp, giao thức mạng và mọi thứ chạy trên hệ nhúng, nơi "một int chắc là 32 bit" là không đủ tốt:

#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>

int main(void) {
    int8_t   small = -128;
    uint16_t port  = 8080;
    int32_t  count = 2000000000;
    uint64_t big   = 18000000000000000000ULL;

    printf("int8_t  : %" PRId8  "\n", small);
    printf("uint16_t: %" PRIu16 "\n", port);
    printf("int32_t : %" PRId32 "\n", count);
    printf("uint64_t: %" PRIu64 "\n", big);

    printf("sizes: %zu %zu %zu %zu\n",
           sizeof small, sizeof port, sizeof count, sizeof big);
    return 0;
}

Các macro kiểu PRId32 từ <inttypes.h> mở rộng thành đặc tả printf đúng cho từng kiểu có độ rộng cố định trên nền tảng hiện tại. Đó là cách khả chuyển để in chúng, vì %d đúng với int32_t trên một số hệ thống và sai trên những hệ thống khác.

assert.h: kiểm tra các giả định

assert(expr) không làm gì khi biểu thức đúng và dừng chương trình kèm thông báo khi biểu thức sai.

#include <stdio.h>
#include <assert.h>

int divide(int a, int b) {
    assert(b != 0);          /* a contract: callers must not pass 0 */
    return a / b;
}

int main(void) {
    printf("20 / 4 = %d\n", divide(20, 4));
    printf("20 / 5 = %d\n", divide(20, 5));

    /* divide(20, 0) here would abort with:
       Assertion `b != 0' failed. */
    return 0;
}

Biên dịch với -DNDEBUG sẽ loại bỏ mọi assertion, nên chúng không tốn gì trong bản build release. Đó cũng là lời cảnh báo: đừng bao giờ đặt tác dụng phụ bên trong assert. assert(read_next() > 0) sẽ khiến việc đọc dừng hẳn trong bản build release, và bug đó chỉ xuất hiện trên môi trường production.

Assertion dành cho lỗi của bạn: những điều kiện lẽ ra không thể xảy ra nếu code đúng. Dữ liệu người dùng nhập sai không phải là assertion; đó là một câu lệnh if và một thông báo lỗi.

Phần còn lại, nói ngắn gọn

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: hàm có số đối số thay đổi, cơ chế đứng sau printf
• <errno.h>: errno cùng perror và strerror để báo vì sao một lời gọi thất bại
• <signal.h>: xử lý tín hiệu như Ctrl-C
• <setjmp.h>: nhảy không cục bộ; hiếm khi là lựa chọn đúng
• <locale.h>, <wchar.h>, <wctype.h>: locale và ký tự rộng
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: những bổ sung của C11

Hai thói quen giúp dùng thư viện dễ chịu hơn. Đọc trang hướng dẫn (man page) trước khi đoán chữ ký hàm: man 3 strtol trên macOS và Linux là nguồn chính xác và nhanh. Và kiểm tra giá trị trả về: malloc, fopen và strtol đều báo lỗi khi thất bại, và một chương trình bỏ qua chúng sẽ hỏng muộn hơn nhiều và khó hiểu hơn nhiều.