Standard Library Cheatsheet

Standard library C menyediakan ratusan fungsi yang dikelompokkan ke dalam sekitar 30 header file. Menghafal semua tidak realistis—tetapi mengetahui fungsi-fungsi inti yang paling sering dipakai akan mempercepat kerja kita secara signifikan. Bab ini menyusun fungsi-fungsi paling sering dipakai berdasarkan header, lengkap dengan signature singkat dan contoh pemakaian.

Header `<stdio.h>` #

Input/output standar—file, console, formatted print/scan.

Fungsi	Signature	Kegunaan
`printf`	`int printf(const char *fmt, ...)`	Cetak ke stdout dengan format
`fprintf`	`int fprintf(FILE f, const char fmt, ...)`	Cetak ke file
`sprintf`	`int sprintf(char s, const char fmt, ...)`	Cetak ke buffer (berbahaya)
`snprintf`	`int snprintf(char s, size_t n, const char fmt, ...)`	Cetak ke buffer dengan batas
`scanf`	`int scanf(const char *fmt, ...)`	Baca dari stdin
`fopen`	`FILE fopen(const char path, const char *mode)`	Buka file
`fclose`	`int fclose(FILE *f)`	Tutup file
`fread`	`size_t fread(void p, size_t sz, size_t n, FILE f)`	Baca blok
`fwrite`	`size_t fwrite(const void p, size_t sz, size_t n, FILE f)`	Tulis blok
`fgets`	`char fgets(char s, int n, FILE *f)`	Baca satu baris
`fputs`	`int fputs(const char s, FILE f)`	Tulis string
`fgetc` / `getc`	`int fgetc(FILE *f)`	Baca satu karakter
`fputc` / `putc`	`int fputc(int c, FILE *f)`	Tulis satu karakter
`feof`	`int feof(FILE *f)`	Cek akhir file
`ferror`	`int ferror(FILE *f)`	Cek error stream
`perror`	`void perror(const char *s)`	Cetak pesan error (pakai `errno`)

Header `<stdlib.h>` #

Utilitas umum—alokasi memori, konversi numerik, sorting, exit program.

Fungsi	Signature	Kegunaan
`malloc`	`void *malloc(size_t n)`	Alokasi blok memori
`calloc`	`void *calloc(size_t n, size_t sz)`	Alokasi + zero-init
`realloc`	`void realloc(void p, size_t n)`	Ubah ukuran blok
`free`	`void free(void *p)`	Bebaskan blok
`exit`	`void exit(int status)`	Akhiri program
`atexit`	`int atexit(void (*fn)(void))`	Daftar handler exit
`abort`	`void abort(void)`	Akhiri abnormal (SIGABRT)
`atoi`	`int atoi(const char *s)`	String ke int
`atol`	`long atol(const char *s)`	String ke long
`strtol`	`long strtol(const char s, char *end, int base)`	String ke long dengan base
`strtod`	`double strtod(const char s, char *end)`	String ke double
`rand`	`int rand(void)`	Bilangan acak 0..RAND_MAX
`srand`	`void srand(unsigned seed)`	Seed RNG
`abs`	`int abs(int n)`	Nilai absolut int
`qsort`	`void qsort(void base, size_t n, size_t sz, int (cmp)(...))`	Quicksort
`bsearch`	`void bsearch(const void key, ...)`	Binary search

Header `<string.h>` #

Operasi string dan blok memori.

Fungsi	Signature	Kegunaan
`strlen`	`size_t strlen(const char *s)`	Panjang string
`strcpy`	`char strcpy(char dst, const char *src)`	Salin string
`strncpy`	`char strncpy(char dst, const char *src, size_t n)`	Salin dengan batas
`strcat`	`char strcat(char dst, const char *src)`	Gabung string
`strncat`	`char strncat(char dst, const char *src, size_t n)`	Gabung dengan batas
`strcmp`	`int strcmp(const char a, const char b)`	Bandingkan string
`strncmp`	`int strncmp(const char a, const char b, size_t n)`	Bandingkan n karakter
`strchr`	`char strchr(const char s, int c)`	Cari karakter pertama
`strrchr`	`char strrchr(const char s, int c)`	Cari karakter terakhir
`strstr`	`char strstr(const char hay, const char *needle)`	Cari substring
`strtok`	`char strtok(char s, const char *delim)`	Tokenisasi (stateful, tidak aman thread)
`strerror`	`char *strerror(int errnum)`	Pesan errno
`memcpy`	`void memcpy(void dst, const void *src, size_t n)`	Salin blok (no overlap)
`memmove`	`void memmove(void dst, const void *src, size_t n)`	Salin blok (overlap aman)
`memset`	`void memset(void p, int c, size_t n)`	Isi blok dengan byte
`memcmp`	`int memcmp(const void a, const void b, size_t n)`	Bandingkan blok
`memchr`	`void memchr(const void p, int c, size_t n)`	Cari byte dalam blok

Header `<math.h>` #

Fungsi matematika floating point. Compile dengan -lm untuk link.

Fungsi	Signature	Kegunaan
`sqrt`	`double sqrt(double x)`	Akar kuadrat
`cbrt`	`double cbrt(double x)`	Akar pangkat tiga (C99)
`pow`	`double pow(double x, double y)`	x pangkat y
`exp`	`double exp(double x)`	e^x
`log`	`double log(double x)`	Logaritma natural
`log10`	`double log10(double x)`	Logaritma basis 10
`sin`/`cos`/`tan`	`double sin(double x)`	Trigonometri (radian)
`floor`	`double floor(double x)`	Bulatkan ke bawah
`ceil`	`double ceil(double x)`	Bulatkan ke atas
`round`	`double round(double x)`	Bulatkan ke terdekat
`fabs`	`double fabs(double x)`	Nilai absolut
`fmod`	`double fmod(double x, double y)`	Sisa pembagian
`fmin`/`fmax`	`double fmin(double x, double y)`	Min/max
`isnan`	`int isnan(double x)`	Cek NaN (macro)
`isinf`	`int isinf(double x)`	Cek infinity (macro)

Header `<ctype.h>` #

Klasifikasi dan konversi karakter.

Fungsi	Kegunaan
`isalpha(c)`	Alfabet?
`isdigit(c)`	Angka desimal?
`isalnum(c)`	Alfabet atau angka?
`isspace(c)`	Whitespace?
`isupper(c)` / `islower(c)`	Huruf besar/kecil?
`isprint(c)`	Karakter cetak?
`ispunct(c)`	Tanda baca?
`toupper(c)`	Konversi ke huruf besar
`tolower(c)`	Konversi ke huruf kecil

Header `<time.h>` #

Waktu dan tanggal.

Fungsi	Kegunaan
`time(NULL)`	Waktu sekarang (epoch)
`clock()`	Waktu CPU
`difftime(t1, t0)`	Selisih detik
`localtime(&t)`	Konversi ke struct tm (lokal)
`gmtime(&t)`	Konversi ke struct tm (UTC)
`mktime(&tm)`	Konversi struct tm ke time_t
`strftime(buf, n, fmt, tm)`	Format waktu ke string
`time_t`, `struct tm`, `clock_t`	Tipe utama

Program Lengkap #

Program berikut mendemonstrasikan fungsi inti dari <stdlib.h>, <string.h>, <math.h>, <ctype.h>, dan <time.h> dalam satu output yang ringkas.

c
/* File: stdlib1.c - Demo fungsi standar library C */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>
#include <ctype.h>

static int cmp_int(const void *a, const void *b) {
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    return (ia > ib) - (ia < ib);
}

int main(void) {
    /* stdlib.h - alokasi memori dan sorting */
    int *arr = malloc(3 * sizeof(int));
    if (!arr) return 1;
    arr[0] = 30; arr[1] = 10; arr[2] = 20;
    qsort(arr, 3, sizeof(int), cmp_int);
    printf("setelah qsort: %d %d %d\n", arr[0], arr[1], arr[2]);

    int key = 20;
    int *found = bsearch(&key, arr, 3, sizeof(int), cmp_int);
    printf("bsearch 20: %s\n", found ? "ketemu" : "tidak ketemu");
    free(arr);

    /* stdlib.h - konversi numerik */
    printf("abs(-7) = %d\n", abs(-7));
    printf("atoi(\"42\") = %d\n", atoi("42"));
    printf("strtol(\"0xFF\",NULL,0) = %ld\n", strtol("0xFF", NULL, 0));

    /* string.h */
    char buf[32];
    strcpy(buf, "Halo");
    strcat(buf, " Budi");
    printf("string: %s (len=%zu)\n", buf, strlen(buf));
    printf("strcmp(\"abc\",\"abd\") = %d\n", strcmp("abc", "abd"));
    printf("memcmp(\"AB\",\"AC\",2) = %d\n", memcmp("AB", "AC", 2));

    /* math.h */
    printf("sqrt(2.0) = %f\n", sqrt(2.0));
    printf("pow(2,10) = %f\n", pow(2.0, 10.0));
    printf("floor(3.7) = %f\n", floor(3.7));
    printf("ceil(3.2) = %f\n", ceil(3.2));
    printf("round(2.5) = %f\n", round(2.5));

    /* ctype.h */
    printf("toupper('a') = %c\n", toupper('a'));
    printf("isdigit('5') = %d (non-zero = true)\n", isdigit('5'));
    printf("isalpha('Z') = %d (non-zero = true)\n", isalpha('Z'));

    /* time.h */
    time_t t = time(NULL);
    struct tm *lt = localtime(&t);
    printf("tahun sekarang: %d\n", lt->tm_year + 1900);

    return 0;
}

Compile (perlu -lm untuk <math.h>) dan jalankan:

bash
gcc -std=c11 -Wall -Wextra -o stdlib1 stdlib1.c -lm
./stdlib1

Output yang Dihasilkan:

text
setelah qsort: 10 20 30
bsearch 20: ketemu
abs(-7) = 7
atoi("42") = 42
strtol("0xFF",NULL,0) = 255
string: Halo Budi (len=9)
strcmp("abc","abd") = -1
memcmp("AB","AC",2) = -1
sqrt(2.0) = 1.414214
pow(2,10) = 1024.000000
floor(3.7) = 3.000000
ceil(3.2) = 4.000000
round(2.5) = 3.000000
toupper('a') = A
isdigit('5') = 2048 (non-zero = true)
isalpha('Z') = 1024 (non-zero = true)
tahun sekarang: 2026

Mari kita telaah baris-baris kode di atas:

Baris 8-11 (cmp_int): Fungsi perbandingan untuk qsort/bsearch menerima dua const void * dan mengembalikan int. Pola (ia > ib) - (ia < ib) menghindari signed overflow yang terjadi pada ia - ib saat ia positif besar dan ib negatif besar.
Baris 16-19 (qsort dan bsearch): Kedua fungsi membutuhkan array terurut agar bsearch berfungsi. qsort bekerja in-place, sehingga arr terurut setelah pemanggilan.
Baris 26 (strtol("0xFF", NULL, 0)): Base 0 memberi tahu strtol untuk mendeteksi prefix otomatis: 0x untuk hex, 0 untuk oktal, lainnya desimal. Hasil 0xFF adalah 255.
Baris 35 (strcmp("abc","abd")): Mengembalikan nilai negatif jika string pertama kurang dari kedua—di sini -1 karena 'c' < 'd'. Jangan bandingkan dengan == 1 atau -1; selalu cek < 0, == 0, atau > 0.
Baris 53-54 (isdigit dan isalpha): Fungsi klasifikasi karakter mengembalikan nilai non-zero (sering bitmask) jika true, 0 jika false. Nilai spesifik bervariasi per implementasi—2048 di sini—jadi selalu uji sebagai boolean, bukan bandingkan dengan 1.

Header <stdio.h> #

Header <stdlib.h> #

Header <string.h> #

Header <math.h> #

Header <ctype.h> #

Header <time.h> #