scanf di C: membaca input, aturan &, dan kenapa scanf berhenti bekerja

scanf adalah cerminan printf: header yang sama, format string yang mirip, arah yang berlawanan. Fungsi ini membaca teks dari standard input, mengonversinya sesuai format, lalu menyimpan hasilnya lewat pointer yang kamu berikan.

Fungsi ini juga yang paling sering membuat pemula bingung di C, karena tiga perilakunya mengejutkan dan salah satunya adalah celah keamanan. Halaman ini membahas keempatnya.

Bentuk dasarnya, dan kenapa &

#include <stdio.h>

int main(void) {
    int age;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Next year you will be %d.\n", age + 1);
    return 0;
}

Ketik sebuah angka lalu tekan Enter untuk menjalankannya. &age bukan hiasan. C mengirim setiap argumen berdasarkan nilai, jadi kalau kamu menulis scanf("%d", age), fungsi itu akan menerima salinan nilai age saat ini (sampah) dan tidak punya cara untuk menjangkau variabel itu sendiri. &age mengirim alamat variabel, lalu scanf menulis lewat alamat itu. Lihat halaman pointer untuk gambaran lengkapnya.

Lupa menulis & adalah kesalahan scanf yang paling umum. Compiler dengan -Wall menangkapnya (format '%d' expects argument of type 'int *'); tanpa peringatan yang menyala, kodenya bisa dikompilasi dan merusak memori di alamat acak.

Membaca beberapa nilai

Satu pemanggilan bisa membaca beberapa nilai. Whitespace di input, yaitu spasi, tab, dan baris baru, memisahkan nilai-nilainya, dan specifier angka melewati whitespace sebanyak apa pun.

#include <stdio.h>

int main(void) {
    int    day, month, year;

    printf("Enter a date as DD MM YYYY: ");
    if (scanf("%d %d %d", &day, &month, &year) != 3) {
        printf("That was not three numbers.\n");
        return 1;
    }

    printf("%04d-%02d-%02d\n", year, month, day);
    return 0;
}

Spasi literal di "%d %d %d" sebenarnya berlebihan, karena %d sudah melewati whitespace di depan, tapi spasi itu membuat formatnya mudah dibaca. Yang tidak berlebihan adalah memeriksa nilai kembaliannya, yang dibahas di bawah.

Karakter yang bukan whitespace di format harus cocok persis dengan input, dan begitulah caramu membaca input yang terstruktur:

#include <stdio.h>

int main(void) {
    int h, m;

    printf("Enter a time as HH:MM: ");
    if (scanf("%d:%d", &h, &m) == 2) {
        printf("%d hours and %d minutes\n", h, m);
    } else {
        printf("Could not parse that.\n");
    }
    return 0;
}

: di format menuntut adanya : di input. Ketik 9:30 dan input-nya terbaca; ketik 9 30 dan pembacaannya gagal setelah membaca 9.

Selalu periksa nilai kembaliannya

scanf mengembalikan jumlah item yang berhasil diisi, bukan jumlah karakter, dan bukan tanda berhasil. Fungsi ini mengembalikan EOF kalau input berakhir sebelum ada yang dikonversi.

#include <stdio.h>

int main(void) {
    int n;

    printf("Enter a number: ");
    int result = scanf("%d", &n);

    if (result == 1) {
        printf("Got %d\n", n);
    } else if (result == 0) {
        printf("That was not a number.\n");
    } else {
        printf("Input ended.\n");
    }
    return 0;
}

Ketik hello di prompt. scanf mengembalikan 0, n dibiarkan tidak tersentuh, masih menyimpan sampah apa pun yang ada sejak awal, dan teks penyebab masalahnya masih tertinggal di stream input. Bagian terakhir itulah yang mengubah satu input buruk menjadi loop tak berujung:

/* BUG: spins forever on non-numeric input */
while (scanf("%d", &n) != 1) {
    printf("Try again: ");
}

scanf tidak pernah menghabiskan teks yang tidak bisa dikonversinya, jadi pemanggilan berikutnya gagal pada karakter yang sama, selamanya. Untuk memulihkannya, kamu harus membuang sisa barisnya sendiri:

#include <stdio.h>

/* Throw away everything up to and including the next newline. */
static void discard_line(void) {
    int c;
    while ((c = getchar()) != '\n' && c != EOF) {
        /* nothing */
    }
}

int main(void) {
    int n;
    int r;

    printf("Enter a number: ");
    while ((r = scanf("%d", &n)) != 1) {
        if (r == EOF) {
            printf("\nNo more input.\n");
            return 1;
        }
        discard_line();
        printf("Not a number. Try again: ");
    }

    printf("Got %d\n", n);
    return 0;
}

Pengecekan EOF itu penting: saat stream input berakhir (pengguna menekan Ctrl+D, atau file yang dialirkan lewat pipe sudah habis), scanf mengembalikan EOF terus-menerus, jadi loop yang hanya menguji != 1 akan mencoba ulang selamanya. Tangani "input buruk" dan "tidak ada input lagi" sebagai dua kasus yang memang berbeda. Dengan begitu, fungsi pembantu discard_line layak disimpan di program mana pun yang memakai scanf untuk input dari manusia.

Buffer overflow pada %s

%s membaca karakter ke dalam array char. Perhatikan tidak ada &: nama array sudah berubah (decay) menjadi pointer ke elemen pertamanya, jadi &name akan bertipe salah.

Masalahnya, %s biasa tidak tahu seberapa besar array-mu:

char name[10];
scanf("%s", name);      /* DANGEROUS: types 40 characters, writes 41 bytes */

Tidak ada yang menghentikan penulisan di ujung array. Penulisannya terus berlanjut ke apa pun yang ada berikutnya di memori, seperti variabel lain atau alamat kembali. Inilah buffer overflow klasik, dan secara historis kelas bug yang paling banyak dieksploitasi di C. Perbaikannya adalah width di antara % dan s, satu lebih kecil dari ukuran array untuk menyisakan tempat bagi '\0' penutup:

#include <stdio.h>

int main(void) {
    char name[20];

    printf("Enter your first name: ");
    if (scanf("%19s", name) == 1) {     /* 19 chars + '\0' = 20 */
        printf("Hello, %s!\n", name);
    }
    return 0;
}

Width-nya harus ditulis sebagai literal di format string, sehingga merepotkan untuk menjaganya tetap sesuai dengan ukuran array. Satu alasan lagi kenapa kebanyakan C di production memakai fgets.

Kejutan kedua dari %s: specifier ini berhenti di whitespace pertama. Ketik Ada Lovelace, maka name berisi Ada; Lovelace menunggu di stream untuk pembacaan berikutnya. %s membaca sebuah kata, bukan sebuah baris.

Bug baris baru yang tertinggal

Inilah "scanf tidak berfungsi" yang dialami semua orang. Specifier angka melewati whitespace di depan; %c tidak.

#include <stdio.h>

int main(void) {
    int age;
    char initial;

    printf("Enter your age: ");
    scanf("%d", &age);

    printf("Enter your initial: ");
    scanf(" %c", &initial);      /* the leading space is the whole fix */

    printf("%c is %d years old.\n", initial, age);
    return 0;
}

Beginilah yang terjadi tanpa spasi itu. Kamu mengetik 30 lalu menekan Enter. %d menghabiskan 3 dan 0 lalu berhenti di baris baru, meninggalkan '\n' di buffer. scanf("%c", &initial) berikutnya membaca baris baru itu sebagai karakternya dan langsung kembali: prompt-nya muncul dan terlewati dalam sekejap.

Spasi di format string scanf berarti "lewati whitespace sebanyak apa pun di sini", jadi " %c" melangkahi baris baru yang nyasar itu lalu menunggu karakter sungguhan. Spasi itu hanya dibutuhkan sebelum %c dan %[; specifier lain sudah melewati whitespace sendiri.

Membaca float dan char

Specifier-nya sebagian besar sama dengan printf, dengan satu perbedaan penting: scanf perlu tahu ukuran tujuan penyimpanannya dengan tepat, karena ia menulis lewat pointer.

#include <stdio.h>

int main(void) {
    float  f;
    double d;
    int    i;
    char   c;

    printf("Enter a float, a double, an int and a char: ");
    if (scanf("%f %lf %d %c", &f, &d, &i, &c) == 4) {
        printf("%.2f %.4f %d %c\n", f, d, i, c);
    } else {
        printf("Input did not match.\n");
    }
    return 0;
}

Coba 1.5 2.25 7 x.

%f membaca float, %lf membaca double. Di printf keduanya dicetak dengan cara yang sama karena float dipromosikan ke double sebelum pemanggilan, tapi di scanf tidak ada promosi, dan memakai %f dengan double * menulis empat byte ke variabel delapan byte sehingga nilainya rusak. %c di sini tidak butuh spasi di depan karena %d sebelumnya sudah berhenti di spasi, bukan di baris baru. (Tabel lengkapnya ada di halaman format specifier.)

fgets: alternatif yang tangguh

Untuk apa pun yang diketik manusia, baca seluruh barisnya lalu parse sesudahnya. fgets menerima ukuran buffer sebagai argumen, jadi secara fisik tidak bisa overflow, dan kalau barisnya muat, fungsi ini ikut menghabiskan baris barunya sehingga tidak ada yang tertinggal untuk membingungkan pembacaan berikutnya. (Baris yang lebih panjang dari buffer meninggalkan ekornya belum terbaca, dan '\n' yang tidak ada di hasilmu adalah cara mendeteksinya.)

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

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

    printf("Enter your full name: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    line[strcspn(line, "\n")] = '\0';     /* trim the newline fgets keeps */
    printf("Hello, %s!\n", line);

    printf("Enter your age: ");
    if (fgets(line, sizeof line, stdin) == NULL) {
        return 1;
    }
    int age = (int)strtol(line, NULL, 10);
    printf("Next year: %d\n", age + 1);
    return 0;
}

Tiga hal tentang pola itu:

• sizeof line mengirim ukuran yang sebenarnya, jadi mengubah ukuran array tidak butuh perubahan lain, berbeda dengan literal %19s.
• fgets menyimpan baris baru kalau barisnya muat, dan karena itulah ada pemangkasan dengan strcspn. Itu juga cara mendeteksi baris yang terlalu panjang untuk buffer: tidak ada '\n' di hasil yang kamu dapat.
• Parse sesudahnya. strtol untuk integer (fungsi ini juga bisa memberitahumu di mana parsing berhenti), strtod untuk floating point, atau sscanf(line, "%d %d", &a, &b) untuk memakai format scanf pada string yang sudah kamu pegang dengan aman.

sscanf layak disebut tersendiri: fungsi ini adalah scanf yang membaca dari string, bukan dari stream input, dan berpadu sempurna dengan fgets. Kamu mendapat parsing yang praktis ala scanf tanpa masalah stream-nya sama sekali.

Kesalahan umum

• Lupa & pada argumen yang bukan array. Kompilasi dengan -Wall.
• %s tanpa width. Buffer overflow yang tinggal menunggu input yang panjang.
• Mengabaikan nilai kembalian. Lalu membaca variabel yang tidak pernah diisi scanf.
• Melakukan loop pada scanf yang gagal tanpa membuang input. Loop tak berujung.
• %c tanpa spasi di depan setelah membaca angka. Bug prompt yang terlewati.
• Memakai %f untuk double. Kerusakan diam-diam; scanf butuh %lf.
• Mengira %s membaca satu baris. Specifier ini hanya membaca satu kata yang dibatasi whitespace.