Format Specifier di C: Referensi Lengkap printf dan scanf

Format specifier memberi tahu printf cara mengubah nilai menjadi teks, dan memberi tahu scanf cara mengubah teks menjadi nilai. Inilah satu bagian C di mana compiler secara default tidak bisa membantumu, karena tipe argumen tidak terlihat oleh fungsinya. Jadi halaman ini adalah tabel untuk dijadikan pegangan.

Bentuk umum sebuah spesifikasi adalah:

%[flags][width][.precision][length]conversion

Hanya % dan huruf konversi yang wajib. %-8.2lf memakai kelima bagiannya.

Tabel Konversi

#include <stdio.h>

int main(void) {
    int x = 255;

    printf("%%d  : %d\n", x);
    printf("%%u  : %u\n", x);
    printf("%%x  : %x\n", x);
    printf("%%X  : %X\n", x);
    printf("%%o  : %o\n", x);
    printf("%%c  : %c\n", 65);
    printf("%%s  : %s\n", "text");
    printf("%%f  : %f\n", 3.5);
    printf("%%e  : %e\n", 3.5);
    printf("%%g  : %g\n", 3.5);
    printf("%%p  : %p\n", (void *)&x);
    return 0;
}

Dua entri perlu diberi peringatan. %n menulis ke memori alih-alih mencetak, dan merupakan mekanisme di balik celah keamanan format string: jangan pernah biarkan teks dari pengguna masuk ke format string. Lalu %p membutuhkan void *; memberikan int * langsung adalah undefined behavior, meski setiap compiler sungguhan tetap mencetak alamatnya.

Length Modifier

Length modifier ditaruh di antara presisi dan huruf konversi, dan menyatakan seberapa besar argumennya sebenarnya.

Konversi signed (d i) dan unsigned (u x o) menerima tipe yang berbeda: %lu menginginkan unsigned long, bukan long, dan salah memilihnya adalah undefined behavior, bukan sekadar kesalahan kosmetik.

Dan untuk keluarga floating-point dan karakter:

Kombinasi yang benar-benar akan kamu ketik:

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

int main(void) {
    short              s   = -12;
    long               l   = 3000000000L;
    long long          ll  = 9000000000000000000LL;
    unsigned long      ul  = 4000000000UL;
    unsigned long long ull = 18000000000000000000ULL;
    size_t             len = strlen("hello");
    long double        ld  = 2.5L;

    printf("short              : %hd\n", s);
    printf("long               : %ld\n", l);
    printf("long long          : %lld\n", ll);
    printf("unsigned long      : %lu\n", ul);
    printf("unsigned long long : %llu\n", ull);
    printf("size_t             : %zu\n", len);
    printf("long double        : %Lf\n", ld);
    return 0;
}

%zu adalah yang wajib dihafal. sizeof, strlen, dan setiap ukuran dari library standar mengembalikan size_t, yang berukuran 8 byte di sistem 64-bit sementara int berukuran 4. printf("%d", strlen(s)) adalah bug sungguhan yang terlihat berfungsi di sebagian platform; gunakan %zu.

Modifier hh dan h terutama ada untuk scanf, di mana ukuran tujuan itu penting. Di printf, short dinaikkan menjadi int sebelum pemanggilan, jadi %d toh akan mencetaknya dengan benar; %hd hanya mendokumentasikan maksudnya.

Tipe dengan Lebar Pasti

Untuk tipe <stdint.h> seperti int32_t, specifier yang portabel adalah macro dari <inttypes.h>:

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

int main(void) {
    int32_t  a = -2000000000;
    uint64_t b = 18000000000000000000ULL;

    printf("int32_t  : %" PRId32 "\n", a);
    printf("uint64_t : %" PRIu64 "\n", b);
    return 0;
}

PRId32 dijabarkan menjadi huruf yang tepat untuk platformmu, dan string literal yang bersebelahan otomatis digabung, karena itulah format-nya dipecah menjadi tiga bagian. Bentuknya jelek; alternatifnya, melakukan cast ke long long lalu memakai %lld, sering kali lebih mudah dibaca dan selalu benar.

Flag

Flag ditaruh tepat setelah % dan mengubah tampilannya. Flag hanya berlaku untuk printf.

#include <stdio.h>

int main(void) {
    printf("|%6d|\n",   42);
    printf("|%-6d|\n",  42);
    printf("|%06d|\n",  42);
    printf("|%+d|\n",   42);
    printf("|% d|\n",   42);
    printf("|%#x|\n",  255);
    printf("|%#o|\n",   64);
    printf("|%#.0f|\n", 3.0);
    return 0;
}

Flag bisa digabung: %-+8.2f berarti lebar minimum 8, dua desimal, selalu bertanda, dengan padding di belakang angka. - mengalahkan 0 kalau kamu menulis keduanya.

Lebar dan Presisi

Lebar adalah ukuran field minimum: output diberi padding untuk mencapainya, dan tidak pernah dipotong agar muat. Presisi (setelah titik) punya arti berbeda untuk setiap keluarga:

#include <stdio.h>

int main(void) {
    printf("|%10.3f|\n", 3.14159);     /* width 10, 3 decimals */
    printf("|%.5d|\n",   42);          /* minimum 5 digits     */
    printf("|%.3s|\n",   "abcdefg");   /* at most 3 chars      */
    printf("|%.0f|\n",   2.71828);     /* no decimals          */
    printf("|%*d|\n",    8, 42);       /* width from an argument */
    printf("|%.*f|\n",   3, 3.14159);  /* precision from an argument */
    return 0;
}

* di tempat salah satu angka itu mengambil nilainya dari argumen int, yang dibaca sebelum nilainya sendiri. Begitulah cara membuat tabel yang lebar kolomnya dihitung saat program berjalan.

Di scanf, lebar punya tugas yang berbeda dan jauh lebih penting: ia membatasi berapa banyak input yang dipakai sebuah konversi, satu-satunya hal yang menghalangi %s dari buffer overflow.

Di Mana printf dan scanf Berbeda

Keduanya terlihat mirip tetapi berbeda di empat hal. Masing-masing adalah sumber bug yang nyata:

#include <stdio.h>

int main(void) {
    double d;
    char   word[16];

    printf("Enter a decimal number and a word: ");
    if (scanf("%lf %15s", &d, word) == 2) {   /* %lf and a width */
        printf("%.3f and \"%s\"\n", d, word); /* %f and a precision */
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

Coba 2.5 hello. Format yang membacanya dan format yang mencetaknya memakai huruf berbeda untuk double yang sama, dan 15 di %15s membatasi input sampai 15 karakter ditambah terminator, persis seukuran word.

Scanset di scanf

%[...] membaca sekumpulan karakter, bukan kata yang dibatasi whitespace. Inilah cara membaca satu baris penuh dengan scanf, meski fgets tetap alat yang lebih baik:

#include <stdio.h>

int main(void) {
    char line[64];

    printf("Type a sentence: ");
    if (scanf("%63[^\n]", line) == 1) {     /* everything up to a newline */
        printf("You typed: %s\n", line);
    }
    return 0;
}

[^\n] berarti "karakter apa pun kecuali baris baru". %[0-9] hanya akan membaca digit, %[abc] hanya tiga huruf itu. Berbeda dengan %s, scanset tidak melewati whitespace di depan, jadi satu baris baru yang tersisa di buffer membuatnya sama sekali tidak cocok dengan apa pun.

Salah Memilih Adalah Undefined Behavior

printf tidak bisa melihat tipe asli argumenmu. Ia membaca byte sebanyak yang diisyaratkan specifier, dan menafsirkannya sesuai kata specifier itu. Jadi ketidakcocokan bukan sekadar gangguan format, melainkan membaca memori sebagai sesuatu yang salah:

printf("%d\n", 3.5);        /* prints garbage: reads a double's bits as int */
printf("%s\n", 42);         /* treats 42 as an address - crash */
printf("%d\n", strlen(s));  /* size_t read as int - wrong on 64-bit */
printf("%f\n", 3);          /* int read as double - garbage */

Pertahanannya hanya butuh satu flag. Kompilasi dengan -Wall dan GCC memeriksa setiap format string literal terhadap argumennya:

gcc -Wall -Wextra program.c -o program

Compiler melaporkan keempat baris di atas saat kompilasi. Ini peringatan paling berharga di C, dan sudah menyala secara default di editor di atas.

Untuk sisi praktis memakai semua ini, seperti tabel yang rata, mencetak float agar mudah dibaca, dan membaca input tanpa bug baris baru yang klasik, lihat printf dan scanf.