Error Umum di C: Kesalahan Pemula dan Cara Memperbaikinya

Setiap programmer C menemui daftar kesalahan pendek yang sama, biasanya di minggu pertama dan sesekali sepuluh tahun kemudian. Daftar ini layak dicatat karena sebagian besar kesalahan itu menghasilkan pesan error yang tidak menjelaskannya, atau lebih buruk lagi, tidak menghasilkan pesan sama sekali.

Setiap entri di bawah berisi gejala, penyebab di baliknya, dan solusinya.

Titik Koma yang Hilang dan Efek Berantainya

Gejala: deretan error, semuanya dilaporkan di baris yang terlihat benar.

program.c:6:5: error: expected ';' before 'printf'
program.c:7:5: error: expected declaration specifiers before 'return'

Penyebab: C mengakhiri pernyataan dengan ;. Kalau satu terlewat, compiler menempelkan baris berikutnya ke baris saat ini, lalu melaporkan kebingungan di titik di mana gabungan teks itu tidak lagi masuk akal, biasanya di baris berikutnya.

int main(void) {
    int x = 5      /* missing semicolon */
    printf("%d\n", x);
    return 0;
}

Solusi: saat sekumpulan error muncul, perbaiki hanya yang pertama lalu kompilasi ulang. Semua error setelahnya mungkin hanya akibatnya. Dan selalu periksa baris sebelum baris yang disebut compiler.

Efek berantai yang sama muncul dari kurung kurawal yang tidak ditutup atau komentar /* yang tidak diakhiri, di mana error-nya bisa muncul puluhan baris jauhnya.

#include <stdio.h>

int main(void) {
    int x = 5;
    printf("%d\n", x);
    return 0;
}

Satu catatan tambahan: tidak ada titik koma setelah header if, for, while, atau setelah kurung kurawal penutup definisi fungsi. if (x > 0); bisa dikompilasi dan tidak melakukan apa-apa: ; itu adalah seluruh body-nya.

Assignment, Bukan Perbandingan

Gejala: kondisi yang selalu bernilai true, atau variabel yang berubah secara misterius.

int x = 5;
if (x = 10) {              /* assigns 10, then tests 10 -> true */
    printf("x is ten\n");  /* always prints; x is now 10 */
}

Penyebab: = meng-assign, == membandingkan. Nilai sebuah assignment adalah nilai yang di-assign, jadi if (x = 10) menguji 10, yang bukan nol, sehingga bernilai true. Compiler menerimanya karena sesekali memang itu yang dimaksud orang.

Solusi: gunakan == di setiap kondisi, dan nyalakan -Wall supaya compiler memberi peringatan:

warning: suggest parentheses around assignment used as truth value

#include <stdio.h>

int main(void) {
    int x = 5;

    if (x == 10) {
        printf("x is ten\n");
    } else {
        printf("x is %d, not ten\n", x);
    }
    return 0;
}

Kalau kamu memang bermaksud melakukan assignment di dalam kondisi, yang umum di while ((c = getchar()) != EOF), tanda kurung ekstra menyatakan maksud itu dan membungkam peringatannya.

Implicit Declaration pada Fungsi

Gejala:

warning: implicit declaration of function 'printf'
warning: implicit declaration of function 'malloc'

...kadang diikuti hasil aneh saat program berjalan atau error saat linking.

Penyebab: compiler menemukan pemanggilan fungsi yang tidak punya deklarasi. Di dialek sebelum C99, compiler menganggap fungsi itu mengembalikan int lalu jalan terus; di sistem 64-bit, anggapan itu memotong pointer yang dikembalikan menjadi 32 bit. Begitulah <stdlib.h> yang terlupa membuat malloc berujung crash.

Solusi: include header yang tepat.

Untuk fungsimu sendiri, peringatan yang sama berarti kamu memanggilnya sebelum mendefinisikannya. Taruh prototipe di atas main:

#include <stdio.h>

int triple(int n);      /* prototype: declared before use */

int main(void) {
    printf("%d\n", triple(7));
    return 0;
}

int triple(int n) {     /* definition, after main */
    return n * 3;
}

scanf Tanpa &

Gejala: program crash saat menerima input, atau tidak membaca apa pun dan variabelnya tidak berubah.

int age;
scanf("%d", age);     /* missing & : passes the value, not the address */

Penyebab: scanf menulis ke dalam variabelmu, jadi ia butuh alamat variabel itu. Memberikan age berarti menyerahkan nilai sampah apa pun yang ada di dalamnya, dan scanf menganggapnya sebagai tempat untuk menulis, yang biasanya berujung segfault.

Solusi: & sebelum variabel, untuk semua tipe kecuali array, yang sudah merupakan alamat:

#include <stdio.h>

int main(void) {
    int    age = 0;
    double height = 0.0;
    char   name[50] = "";

    /* Reading from a string here so the example runs without input */
    sscanf("30 1.82 Alex", "%d %lf %49s", &age, &height, name);
    /*                                    ^    ^        ^
       & for int, & for double, no & for the array                */

    printf("%s is %d and %.2f m tall\n", name, age, height);
    return 0;
}

Dua jebakan di keluarga yang sama: gunakan %lf untuk double di scanf (%f di sana berarti float, dan menulis byte sebanyak float ke dalam double membuat nilainya salah), dan selalu batasi %s dengan lebar, misalnya %49s untuk buffer 50 byte, atau kata yang panjang akan meluap.

Lebih baik lagi: baca satu baris penuh dengan fgets lalu parse, yang tidak bisa meluap dan tidak meninggalkan sisa input di buffer. Penjelasan lebih lengkap tentang keduanya ada di scanf.

Membandingkan String dengan ==

Gejala: dua string yang jelas sama dianggap berbeda.

char a[] = "hello";
char b[] = "hello";

if (a == b) {              /* comparing two addresses: false */
    printf("same\n");
}

Penyebab: string C bukan sebuah nilai, melainkan pointer ke karakter pertama. == membandingkan pointer-nya. Dua array yang berisi teks yang sama berada di alamat yang berbeda, jadi hasilnya false. (Yang membingungkan, membandingkan dua literal yang sama kadang menghasilkan true, karena compiler mungkin hanya menyimpan satu salinan, sehingga bug ini muncul kadang-kadang saja.)

Solusi: strcmp, dan ingat bahwa ia mengembalikan 0 kalau sama:

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

int main(void) {
    char a[] = "hello";
    char b[] = "hello";
    char c[] = "world";

    printf("a == b (pointers): %s\n", (a == b) ? "true" : "false");
    printf("strcmp(a, b) == 0: %s\n", (strcmp(a, b) == 0) ? "true" : "false");
    printf("strcmp(a, c) == 0: %s\n", (strcmp(a, c) == 0) ? "true" : "false");

    if (strcmp(a, b) == 0) {
        printf("The strings match\n");
    }
    return 0;
}

Cara membaca yang terbalik juga sering menjebak: if (strcmp(a, b)) bernilai true kalau string-nya berbeda, karena hasil bukan nol berarti "tidak sama". Selalu tulis == 0 secara eksplisit.

Pembagian Integer

Gejala: rata-rata bernilai 0, persentase yang selalu 0 atau 100, rasio yang kehilangan pecahannya.

int correct = 7, total = 10;
double score = correct / total;      /* 0.0, not 0.7 */

Penyebab: kedua operand bertipe int, jadi C melakukan pembagian integer dan memotong hasilnya sebelum di-assign ke double. 7 / 10 adalah 0; mengonversi 0 ke double menghasilkan 0.0.

Solusi: jadikan salah satu operand floating point sebelum pembagian:

#include <stdio.h>

int main(void) {
    int correct = 7, total = 10;

    printf("correct / total            = %.4f\n", (double)(correct / total));
    printf("(double)correct / total    = %.4f\n", (double)correct / total);
    printf("correct / (double)total    = %.4f\n", correct / (double)total);
    printf("correct * 100.0 / total    = %.1f%%\n", correct * 100.0 / total);
    return 0;
}

Melakukan cast pada satu operand otomatis menaikkan tipe operand lainnya. Melakukan cast pada hasilnya sudah terlambat, karena pemotongan sudah terjadi. Lihat type casting.

Jebakan yang sama bersembunyi di ekspresi seperti (a + b) / 2 untuk titik tengah dan 1 / 2 * x, yang selalu 0 berapa pun nilai x.

return yang Hilang atau Salah

Gejala: sebuah fungsi mengembalikan angka salah yang terlihat masuk akal, berbeda di setiap run atau setiap build.

int add(int a, int b) {
    int sum = a + b;
    /* no return statement */
}

Penyebab: mencapai akhir fungsi non-void tanpa return memberikan nilai yang tidak ditentukan, dalam praktiknya apa pun yang kebetulan ada di register kembalian. Itu undefined behavior kalau pemanggil memakainya.

Bentuk yang lebih licik melakukan return di sebagian jalur saja:

int classify(int n) {
    if (n > 0) return 1;
    if (n < 0) return -1;
    /* n == 0 falls off the end */
}

Solusi: lakukan return di setiap jalur, dan kompilasi dengan -Wall: pesan GCC "control reaches end of non-void function" menangkap kedua versi.

#include <stdio.h>

int classify(int n) {
    if (n > 0) {
        return 1;
    }
    if (n < 0) {
        return -1;
    }
    return 0;          /* the path that was missing */
}

int main(void) {
    printf("%d %d %d\n", classify(5), classify(-5), classify(0));
    return 0;
}

Variabel yang Belum Diinisialisasi

Gejala: output berisi nilai sampah, atau hasil yang berubah antar-run dan antar-level optimasi.

int total;                       /* contains whatever was on the stack */
for (int i = 1; i <= 5; i++) {
    total += i;                  /* adding to garbage */
}
printf("%d\n", total);           /* some enormous number */

Penyebab: variabel lokal tidak diisi nol. Variabel global atau static otomatis bernilai nol; variabel lokal dimulai dengan byte apa pun yang sudah ada di alamat stack itu.

Solusi: inisialisasi di tempat deklarasi. Tidak ada biayanya dan seluruh jenis bug ini hilang:

#include <stdio.h>

int main(void) {
    int total = 0;              /* initialized */
    int values[5] = {0};        /* every element zeroed */
    char name[32] = "";         /* empty string, not garbage */

    for (int i = 1; i <= 5; i++) {
        total += i;
        values[i - 1] = i * i;
    }

    printf("total = %d\n", total);
    printf("values[4] = %d\n", values[4]);
    printf("name = '%s' (length %zu)\n", name, sizeof name);
    return 0;
}

-Wall -Wextra memperingatkan banyak kasus seperti ini ("may be used uninitialized"), dan -fsanitize=memory atau valgrind menangkap sisanya. Yang ini sangat berbahaya karena pointer yang belum diinisialisasi langsung berujung segmentation fault.

Off-by-One

Gejala: item terakhir terlewat, atau satu elemen kelebihan tersentuh dan program berperilaku aneh belakangan.

int arr[5];
for (int i = 0; i <= 5; i++) {   /* touches arr[5], which does not exist */
    arr[i] = i;
}

Penyebab: array berisi n elemen punya indeks 0 sampai n - 1. <= menjalankan satu putaran ekstra.

Solusi: pola i < n, dan hitung n dari array alih-alih menulis angkanya dua kali:

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

int main(void) {
    int arr[5];
    size_t n = sizeof arr / sizeof arr[0];

    for (size_t i = 0; i < n; i++) {
        arr[i] = (int)i * 10;
    }
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    /* Strings need one extra byte for the terminating '\0' */
    char word[6];                  /* 5 letters + terminator */
    strcpy(word, "hello");
    printf("'%s' uses %zu of %zu bytes\n", word, strlen(word) + 1, sizeof word);
    return 0;
}

Versi string-nya, yaitu lupa menyediakan tempat untuk '\0', adalah kesalahan yang sama dalam wujud berbeda, dan char word[5] yang diisi "hello" adalah buffer overrun.

Dua Kesalahan Kecil yang Perlu Diketahui

Titik koma setelah header loop. for (int i = 0; i < 10; i++); yang diikuti blok berkurung kurawal menjalankan loop sepuluh kali tanpa melakukan apa-apa, lalu menjalankan blok itu satu kali. Kodenya bisa dikompilasi tanpa masalah.

sizeof pada pointer. Di dalam fungsi, parameter array adalah pointer, jadi sizeof(arr) adalah ukuran pointer (8 byte), bukan ukuran array. Kirim panjangnya sebagai argumen terpisah:

#include <stdio.h>

void report(int arr[], size_t n) {
    printf("sizeof(arr) inside the function: %zu\n", sizeof arr);
    printf("actual element count passed in:  %zu\n", n);
}

int main(void) {
    int data[10] = {0};
    printf("sizeof(data) in main: %zu bytes\n", sizeof data);
    report(data, sizeof data / sizeof data[0]);
    return 0;
}

Kebiasaan yang Mencegah Sebagian Besar Masalah Ini

Kompilasi dengan peringatan menyala, sejak program pertama:

gcc -Wall -Wextra -g program.c -o program

-Wall -Wextra menangkap assignment di dalam kondisi, return yang hilang, pembacaan variabel yang belum diinisialisasi, variabel yang tidak dipakai, dan specifier printf yang tidak cocok dengan argumennya. Menambahkan -fsanitize=address,undefined selama pengembangan menangkap hampir semua sisanya tepat saat terjadi.

Anggap setiap peringatan sebagai error yang belum kamu alami. Program C yang dikompilasi tanpa peringatan belum tentu benar, tetapi hampir setiap program C yang crash sebelumnya sudah memperingatkan sesuatu.