Pustaka Standar C: Peta Header yang Perlu Kamu Kenal

C sebagai bahasa itu sangat kecil: tipe, operator, alur kontrol, fungsi, pointer. C tidak bisa mencetak, membaca file, membandingkan string, atau mengalokasikan memori. Semua itu adalah tugas pustaka standar: sekumpulan header yang disertakan oleh setiap implementasi yang sesuai standar.

Halaman ini adalah sebuah peta. Setiap bagian menjelaskan kegunaan sebuah header, menunjukkan satu contoh singkat yang bisa dijalankan, dan menunjuk ke halaman yang lebih lengkap jika ada.

stdio.h: Input dan Output

Header yang pertama kamu include di hampir setiap program. Isinya printf dan scanf, tipe FILE beserta fungsi-fungsi file, dan fungsi input per baris yang lebih aman.

#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;
}

Yang paling penting: printf, fprintf, sprintf, snprintf untuk output; scanf, fscanf, sscanf, fgets, getchar untuk input; fopen, fclose, fread, fwrite, fseek untuk file. Pembahasan lebih dalam ada di printf, scanf, dan penanganan file.

Satu aturan yang perlu diingat: jangan pernah memakai gets(). Fungsi ini tidak punya cara untuk mengetahui ukuran buffer-mu dan sudah dihapus dari standar sejak C11. Penggantinya adalah fgets(buf, sizeof buf, stdin).

stdlib.h: Utilitas Umum

Header serbaguna: memori, konversi, bilangan acak, kontrol proses, dan pengurutan.

#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;
}

Yang menonjol: malloc, calloc, realloc, free (lihat memori dinamis); atoi, atof, strtol, strtod untuk konversi, dan sebaiknya pilih keluarga strto* karena bisa melaporkan kegagalan, sementara atoi diam-diam mengembalikan 0; rand dan srand (lihat bilangan acak); exit, abort, getenv, system; serta qsort/bsearch.

string.h: String dan Blok Memori

String di C adalah array char yang diakhiri '\0', dan setiap operasi padanya adalah pemanggilan fungsi.

#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;
}

Dua kebiasaan menjaga header ini agar tidak menjadi sumber buffer overflow: selalu ketahui ukuran tujuan, dan ingat bahwa strcmp mengembalikan 0 jika kedua string sama, sehingga if (strcmp(a, b)) bernilai benar justru saat kedua string berbeda. Fungsi string membahas pola strncpy/snprintf yang lebih aman secara rinci.

math.h: Matematika

sqrt, pow, fabs, floor, ceil, round, fmod, keluarga fungsi trigonometri dan logaritma, INFINITY dan 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;
}

Inilah satu-satunya header yang mungkin butuh flag linker: di Linux, tambahkan -lm di akhir perintah compile, atau linker akan melaporkan "undefined reference to sqrt". Tur lengkapnya ada di fungsi matematika.

time.h: Jam dan Tanggal

#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;
}

Dua offset di struct tm menjebak semua orang: tm_year dihitung dari 1900, dan tm_mon dimulai dari 0. time(NULL) juga merupakan seed yang biasa dipakai untuk srand.

ctype.h: Klasifikasi Karakter

Kecil, tetapi lebih berguna daripada kelihatannya. Setiap fungsinya menerima satu karakter dan menjawab pertanyaan ya/tidak, atau mengubah huruf besar dan kecil.

#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;
}

Set lengkapnya: isalpha, isdigit, isalnum, isspace, isupper, islower, ispunct, isxdigit, isprint, ditambah toupper dan tolower.

Perhatikan cast (unsigned char). Fungsi-fungsi ini didefinisikan untuk nilai yang bisa direpresentasikan sebagai unsigned char ditambah EOF. char biasa bersifat signed di sebagian besar sistem, jadi byte di atas 127 tiba sebagai bilangan negatif dan pemanggilannya menjadi undefined behavior. Cast ini tidak memakan biaya dan menghilangkan seluruh jenis masalah tersebut.

Selain itu, pilih fungsi-fungsi ini daripada pengecekan buatan sendiri. c >= '0' && c <= '9' kebetulan berhasil, tetapi isdigit(c) menyatakan maksudmu dengan jelas dan tetap benar di mana saja.

limits.h dan float.h: Batas Setiap Tipe

Seberapa besar sebuah int di mesin ini? Header-header ini menjawabnya, dan jawabannya adalah alasan kode yang portabel selalu bertanya alih-alih berasumsi.

#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 adalah cara mengecek overflow sebelum terjadi. Ini penting karena overflow pada bilangan signed adalah undefined behavior, bukan wraparound yang bisa kamu uji sesudahnya.

stdbool.h dan stdint.h: Tipe yang Lebih Baik

C tidak punya tipe boolean sampai C99. <stdbool.h> menyediakannya:

#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, dan false adalah makro untuk _Bool, 1, dan 0, tetapi ketiganya membuat maksud kode jadi jelas. (Di C23 ketiganya menjadi kata kunci dan header ini tidak lagi diperlukan.)

<stdint.h> memberi tipe dengan lebar yang dijamin. Ini wajib untuk format file, protokol jaringan, dan apa pun yang embedded, di mana "sebuah int mungkin 32 bit" tidak cukup baik:

#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;
}

Makro bergaya PRId32 dari <inttypes.h> diekspansi menjadi specifier printf yang benar untuk setiap tipe dengan lebar tetap di platform saat ini. Itulah cara portabel untuk mencetaknya, karena %d benar untuk int32_t di beberapa sistem dan salah di sistem lain.

assert.h: Mengecek Asumsimu

assert(expr) tidak melakukan apa-apa jika ekspresinya benar, dan menghentikan program dengan sebuah pesan jika ekspresinya salah.

#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;
}

Compile dengan -DNDEBUG menghapus semua assertion, jadi tidak ada biayanya di build rilis. Itu juga peringatannya: jangan pernah menaruh efek samping di dalam assert. assert(read_next() > 0) berhenti membaca sama sekali di build rilis, dan bug yang muncul hanya terlihat di produksi.

Assertion ditujukan untuk kesalahan kamu sendiri: kondisi yang seharusnya mustahil jika kodenya benar. Input pengguna yang salah bukan urusan assertion; itu urusan if dan pesan error.

Sisanya, Secara Singkat

• <stddef.h>: size_t, ptrdiff_t, NULL, offsetof
• <stdarg.h>: fungsi variadik, mesin di balik printf
• <errno.h>: errno ditambah perror dan strerror untuk melaporkan kenapa sebuah pemanggilan gagal
• <signal.h>: menangani sinyal seperti Ctrl-C
• <setjmp.h>: lompatan non-lokal; jarang menjadi jawaban yang tepat
• <locale.h>, <wchar.h>, <wctype.h>: locale dan karakter lebar (wide character)
• <stdnoreturn.h>, <stdalign.h>, <threads.h>, <stdatomic.h>: tambahan di C11

Dua kebiasaan membuat library ini nyaman dipakai. Baca halaman manual sebelum menebak-nebak signature sebuah fungsi: man 3 strtol di macOS dan Linux itu otoritatif dan cepat. Dan cek nilai kembalian: malloc, fopen, dan strtol semuanya melaporkan kegagalan, dan program yang mengabaikannya akan gagal jauh belakangan dengan cara yang jauh lebih membingungkan.