printf di C: format string, specifier, dan mencetak float

printf adalah fungsi pertama yang dipelajari setiap programmer C, dan juga fungsi yang manualnya hampir tidak pernah dibaca sampai habis. Fungsi ini layak diberi sepuluh menit, karena format string-nya adalah bahasa kecil tersendiri, dan karena salah menulis specifier bukan sekadar salah ketik: itu undefined behavior.

Fungsi ini ada di <stdio.h>, jadi setiap program yang memakainya diawali #include <stdio.h>.

Model format string

printf menelusuri format string satu karakter setiap kali. Apa pun yang bukan % dicetak persis seperti yang ditulis. % memulai spesifikasi konversi, yang memakan argumen berikutnya dan mencetaknya dalam bentuk yang diminta.

#include <stdio.h>

int main(void) {
    int    count = 5;
    double price = 2.5;
    char   grade = 'A';
    const char *name = "apples";

    printf("Plain text, no arguments.\n");
    printf("%d %s cost $%.2f (grade %c)\n", count, name, price, grade);
    return 0;
}

Argumen dicocokkan dengan specifier secara ketat berdasarkan posisi: % pertama mengambil count, yang kedua mengambil name, dan seterusnya. printf tidak punya cara untuk memeriksa apakah kamu mengirim apa yang kamu janjikan, karena ia tidak bisa melihat tipenya. Jadi format string adalah kontrak yang harus kamu tepati. Karena itulah -Wall layak dinyalakan: GCC membaca format string literal saat kompilasi dan memberi peringatan kalau ada argumen yang tidak cocok.

Tidak ada yang memaksa baris baru. printf("Hello") meninggalkan kursor setelah o, dan karena itulah hampir setiap format string diakhiri \n.

Specifier yang kamu pakai sehari-hari

Lima specifier sudah mencakup kebanyakan kode:

#include <stdio.h>

int main(void) {
    int x = 42;

    printf("int     : %d\n", x);
    printf("double  : %f\n", 2.5);
    printf("string  : %s\n", "hello");
    printf("char    : %c\n", 'A');
    printf("pointer : %p\n", (void *)&x);
    printf("percent : 100%%\n");
    return 0;
}

Ada dua aturan yang tersembunyi di potongan kode itu. % literal ditulis %%: % yang sendirian di akhir format string adalah undefined behavior. Lalu %p membutuhkan void *, jadi lakukan cast pada pointernya; memberikan int * secara langsung secara teknis undefined meskipun dalam praktiknya tercetak dengan baik.

Tabel lengkapnya, yaitu setiap specifier, setiap length modifier, dan kolom untuk scanf, ada di halaman format specifier. Halaman ini hanya membahas yang sering kamu pakai.

Width, precision, dan perataan

Di antara % dan hurufnya, kamu bisa menaruh flag, width, dan precision. Begitulah caramu mengubah sebuah loop menjadi tabel.

#include <stdio.h>

int main(void) {
    printf("|%5d|\n", 42);        /* width 5, padding before the value */
    printf("|%-5d|\n", 42);       /* minus flag: pad after the value   */
    printf("|%05d|\n", 42);       /* zero flag: pad with zeros         */
    printf("|%+d|\n", 42);        /* plus flag: always show the sign   */
    printf("|%8.2f|\n", 3.14159); /* width 8, 2 digits after the point */
    printf("|%-10s|\n", "ok");    /* strings pad too                   */
    printf("|%.3s|\n", "truncate me");  /* precision on a string cuts it */
    return 0;
}

Width adalah batas minimum, bukan maksimum: %3d dengan nilai 123456 tetap mencetak keenam digitnya. Precision punya arti yang berbeda untuk setiap tipe: digit setelah titik desimal untuk %f, jumlah karakter maksimum untuk %s, dan jumlah digit minimum untuk %d.

Keduanya bisa diberikan saat runtime dengan *, yang membaca sebuah argumen int:

#include <stdio.h>

int main(void) {
    const char *names[] = {"Ada", "Grace", "Alan"};
    double scores[] = {92.5, 105.25, 87.0};
    int width = 10;

    printf("%-*s %8s\n", width, "NAME", "SCORE");
    for (int i = 0; i < 3; i++) {
        printf("%-*s %8.2f\n", width, names[i], scores[i]);
    }
    return 0;
}

Mengubah width menyusun ulang seluruh tabel. Inilah cara standar mencetak kolom yang rata di C, tanpa perlu fungsi pembantu untuk menambah spasi pada string.

Mencetak float dengan rapi

%f tanpa precision selalu mencetak enam digit setelah titik, dan itu jarang sekali yang diinginkan orang:

#include <stdio.h>

int main(void) {
    double value = 1234.5;
    double tiny  = 0.000012345;
    double huge  = 123456789012.0;

    printf("%%f    : %f\n", value);
    printf("%%.2f  : %.2f\n", value);
    printf("%%.0f  : %.0f\n", value);
    printf("%%e    : %e\n", tiny);
    printf("%%g    : %g\n", tiny);
    printf("%%g    : %g\n", huge);
    printf("%%g    : %g\n", value);
    return 0;
}

Ada tiga pilihan, dan pedoman untuk masing-masing:

• %.Nf untuk uang, hasil pengukuran, dan apa pun yang punya jumlah desimal yang wajar. %.2f adalah yang kamu butuhkan untuk mata uang.
• %e untuk notasi ilmiah, selalu dalam bentuk d.dddddde±dd.
• %g saat kamu tidak tahu besarnya nilai sebelumnya. Specifier ini memilih %f atau %e, mana yang lebih pendek, dan membuang nol di belakang. Inilah pilihan bawaan paling masuk akal untuk mencatat nilai yang belum pernah kamu lihat.

Ada satu jebakan yang perlu dikatakan terus terang: tidak ada %lf di printf. Argumen float dipromosikan menjadi double sebelum printf melihatnya, jadi %f menangani keduanya, dan %lf hanya bermakna di scanf, tempat ukuran tujuan penyimpanannya penting. (C99 memang menerima %lf di printf sebagai sinonim, tapi kebiasaan menulisnya membuat orang menulis %f di scanf, dan itu benar-benar rusak.)

Integer dengan lebar lain

%d adalah untuk int. Tipe yang lebih besar atau unsigned butuh length modifier, dan salah mencocokkannya adalah undefined behavior, bukan sekadar kesalahan pembulatan:

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

int main(void) {
    long           big  = 3000000000L;
    unsigned int   u    = 4000000000u;
    size_t         len  = sizeof "hello";
    uint64_t       id   = 1234567890123456789ULL;

    printf("long     : %ld\n", big);
    printf("unsigned : %u\n", u);
    printf("size_t   : %zu\n", len);
    printf("uint64_t : %llu\n", (unsigned long long)id);

    printf("hex      : %x  HEX: %X  octal: %o\n", 255, 255, 8);
    return 0;
}

%zu untuk size_t adalah yang paling sering salah: sizeof mengembalikan size_t, bukan int, jadi printf("%d", sizeof x) adalah bug yang kebetulan bekerja di sistem 32-bit dan berperilaku aneh di sistem 64-bit.

Nilai kembalian

printf mengembalikan jumlah karakter yang ditulisnya, atau angka negatif kalau gagal. Nilai ini biasanya diabaikan, dan umumnya itu tidak masalah, tapi sangat berguna saat kamu perlu tahu seberapa lebar output-nya:

#include <stdio.h>

int main(void) {
    int written = printf("Hello, world!\n");
    printf("that call wrote %d characters\n", written);

    /* Handy for underlining something whose width you do not know: */
    const char *title = "Report";
    int n = printf("%s\n", title) - 1;   /* minus the newline */
    for (int i = 0; i < n; i++) {
        putchar('=');
    }
    putchar('\n');
    return 0;
}

Fungsi terkait, sprintf dan snprintf, menulis ke buffer, bukan ke layar, dan mengembalikan panjang yang dihasilkannya. Selalu utamakan snprintf, yang menerima ukuran buffer dan tidak bisa overflow:

#include <stdio.h>

int main(void) {
    char buffer[32];
    int n = snprintf(buffer, sizeof buffer, "%s scored %.1f", "Ada", 92.5);

    printf("[%s] (%d chars wanted)\n", buffer, n);
    return 0;
}

snprintf mengembalikan panjang yang seharusnya dibutuhkan string lengkapnya, jadi nilai kembalian yang sama dengan atau lebih besar dari ukuran buffer memberitahumu bahwa output-nya terpotong.

Kerentanan format string

Ini satu-satunya masalah keamanan di printf, dan masalahnya serius. Jangan pernah memberikan data yang tidak kamu tulis sendiri sebagai format string:

/* DANGEROUS - never do this */
printf(user_input);

/* Correct */
printf("%s", user_input);

Kalau user_input berisi %s, printf membaca argumen yang tidak pernah dikirim dan mengikuti sampah berbentuk pointer apa pun yang ditemukannya, biasanya sampai crash. %x yang diulang-ulang menumpahkan isi stack ke layar, yang mungkin berisi password atau kunci. Lalu %n, yang menulis jumlah karakter ke sebuah argumen, dulu mengubah masalah ini menjadi kerusakan memori sembarang dan eksekusi kode jarak jauh.

Aturannya mutlak dan tidak ada biayanya: format string selalu berupa literal yang kamu tulis sendiri. Apa pun yang berubah-ubah masuk sebagai argumen. -Wformat-security dari GCC menandai kesalahan ini, dan flag itu sudah termasuk di -Wall -Wextra.

Buffering: kenapa output kadang muncul terlambat

printf tidak langsung menulis ke terminal. Output-nya di-buffer, lalu dikeluarkan saat buffer penuh, saat ada baris baru di terminal, atau saat program keluar dengan normal. Ada dua akibatnya:

• Program yang crash bisa kehilangan output yang "sudah dicetak". Kalau kamu melakukan debug dengan printf dan pesan terakhir tidak pernah muncul, crash-nya terjadi setelah baris itu, bukan sebelumnya. Tambahkan fflush(stdout) atau kirim output debug ke stderr, yang tidak di-buffer.
• fprintf(stderr, ...) adalah cara yang benar untuk mencetak error. Stream ini tidak di-buffer, dan merupakan stream terpisah yang bisa dialihkan pengguna secara terpisah dari output normal.

#include <stdio.h>

int main(void) {
    printf("normal output goes to stdout\n");
    fprintf(stderr, "errors go to stderr\n");
    fflush(stdout);
    return 0;
}