Fungsi di C: deklarasi, pemanggilan, dan nilai kembalian

Kenapa perlu fungsi

Sejauh ini semuanya ada di dalam main. Itu masih jalan selama program hanya melakukan satu hal. Begitu lebih dari itu, tiga masalah datang sekaligus: blok kode yang sama tersalin ke tiga tempat, main jadi terlalu panjang untuk diingat, dan tidak ada cara untuk memberi nama tujuan sepotong kode.

Fungsi menyelesaikan ketiganya. Fungsi memberi nama pada sebuah blok kode, variabel lokalnya sendiri, daftar input, dan satu nilai untuk dikembalikan.

#include <stdio.h>

int square(int n) {
    return n * n;
}

int main(void) {
    printf("%d\n", square(4));
    printf("%d\n", square(9));
    printf("%d\n", square(square(2)));
    return 0;
}

square ditulis sekali dan dipanggil tiga kali, termasuk sekali pada hasilnya sendiri. Sebenarnya kamu sudah memanggil fungsi dari tadi: printf adalah fungsi, begitu juga main.

Anatomi sebuah fungsi

returnType name(parameterList) {
    // body
    return value;
}

Ada empat bagian:

• Tipe kembalian: tipe nilai yang dikembalikan fungsi. Bisa int, double, char, tipe pointer, atau void untuk "tidak ada".
• Nama: aturannya sama dengan nama variabel, dan sebaiknya menjelaskan apa yang fungsi lakukan atau hasilkan.
• Daftar parameter: input-inputnya, masing-masing dengan tipenya sendiri, dipisahkan koma. (void) berarti fungsi tidak menerima input.
• Badan fungsi: pernyataan-pernyataan di dalam kurung kurawal, diakhiri return kecuali tipe kembaliannya void.

#include <stdio.h>

/* takes two ints, produces one int */
int add(int a, int b) {
    return a + b;
}

/* takes nothing, produces a double */
double pi(void) {
    return 3.14159265358979;
}

/* takes an int, produces nothing */
void printBanner(int width) {
    for (int i = 0; i < width; i++) {
        printf("=");
    }
    printf("\n");
}

int main(void) {
    printBanner(20);
    printf("2 + 3 = %d\n", add(2, 3));
    printf("pi     = %f\n", pi());
    printBanner(20);
    return 0;
}

Perhatikan bahwa pi() tetap butuh tanda kurung kosong saat dipanggil: itulah yang membuatnya jadi pemanggilan, bukan sekadar menyebut namanya. Lalu printBanner(20); berdiri sendiri sebagai pernyataan, karena tidak menghasilkan nilai yang bisa dipakai.

Tulis (void), bukan (), untuk fungsi tanpa parameter. Di C keduanya berarti hal yang berbeda, dan () adalah versi yang longgar. Penjelasannya sebentar lagi.

Memanggil dan mengembalikan nilai

Pemanggilan memindahkan kendali ke dalam fungsi, menjalankan badannya, lalu kembali membawa nilai yang menggantikan pemanggilan itu di ekspresi sekitarnya.

#include <stdio.h>

int larger(int a, int b) {
    if (a > b) {
        return a;      /* leaves the function immediately */
    }
    return b;
}

int main(void) {
    int x = larger(17, 42);
    printf("larger(17, 42) = %d\n", x);
    printf("nested: %d\n", larger(larger(3, 9), 5));
    return 0;
}

return melakukan dua hal sekaligus: memberikan nilai dan langsung mengakhiri fungsi di tempat itu. Apa pun setelah return di jalur yang sama tidak pernah dijalankan. Karena itulah gaya return lebih awal di larger bisa bekerja: else tidak diperlukan, karena sampai di baris terakhir sudah berarti a > b bernilai salah.

Satu fungsi boleh punya beberapa pernyataan return, tapi dalam satu pemanggilan hanya satu yang dijalankan.

Fungsi void

Fungsi yang ada untuk efeknya, bukan nilainya, punya tipe kembalian void: mencetak, mengubah sesuatu lewat pointer, menggambar.

#include <stdio.h>

void printTable(int n, int upTo) {
    for (int i = 1; i <= upTo; i++) {
        printf("%d x %d = %d\n", n, i, n * i);
    }
}

void warn(const char *message, int enabled) {
    if (!enabled) {
        return;            /* bare return: just leave early */
    }
    printf("WARNING: %s\n", message);
}

int main(void) {
    printTable(7, 5);
    warn("low disk space", 1);
    warn("this one is suppressed", 0);
    return 0;
}

Di dalam fungsi void, return; tanpa nilai berarti keluar lebih awal. return someValue; di sana adalah error kompilasi, begitu juga memakai pemanggilannya di dalam ekspresi: int x = printTable(7, 5); tidak akan bisa dikompilasi, dan itu memang tugas sistem tipe.

Dekomposisi: inti sebenarnya

Fungsi bukan terutama soal menghindari pengulangan. Fungsi itu soal mengubah satu prosedur panjang menjadi beberapa langkah yang diberi nama, sehingga main terbaca seperti deskripsi program, bukan implementasinya.

#include <stdio.h>

double average(const int values[], int count) {
    if (count == 0) {
        return 0.0;
    }
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return (double) total / count;
}

int highest(const int values[], int count) {
    int best = values[0];
    for (int i = 1; i < count; i++) {
        if (values[i] > best) {
            best = values[i];
        }
    }
    return best;
}

int countAbove(const int values[], int count, int threshold) {
    int n = 0;
    for (int i = 0; i < count; i++) {
        if (values[i] > threshold) {
            n++;
        }
    }
    return n;
}

int main(void) {
    int scores[] = {88, 92, 75, 60, 100, 47, 83};
    int n = sizeof(scores) / sizeof(scores[0]);

    double avg = average(scores, n);

    printf("Count:            %d\n", n);
    printf("Average:          %.2f\n", avg);
    printf("Highest:          %d\n", highest(scores, n));
    printf("Above average:    %d\n", countAbove(scores, n, (int) avg));
    return 0;
}

Sekarang main hanya berisi empat baris output dan satu perhitungan. Setiap fungsi pembantu melakukan satu hal, punya nama yang menjelaskan hal itu, dan bisa diuji sendiri. Perhatikan bahwa panjang array dikirim sebagai parameter kedua: begitu array dikirim ke sebuah fungsi, trik sizeof tidak lagi bekerja di sana, karena array berubah (decay) menjadi pointer.

Tiga pedoman untuk membagi pekerjaan ke dalam fungsi:

• Satu tugas per fungsi. Kalau namanya butuh kata "dan", kemungkinan itu sebenarnya dua fungsi.
• Terima yang kamu butuhkan, kembalikan yang kamu hasilkan. Fungsi yang membaca state global lebih sulit dipahami dan tidak mungkin diuji secara terpisah.
• Cukup pendek untuk dilihat sekaligus. Tidak ada jumlah baris ajaib, tapi fungsi yang tidak muat di satu layar biasanya menyembunyikan fungsi yang lebih kecil di dalamnya.

Fungsi yang memanggil fungsi lain

Sebuah fungsi bisa memanggil fungsi apa pun yang sudah dideklarasikan, termasuk fungsi yang kamu tulis sendiri:

#include <stdio.h>

int isEven(int n) {
    return n % 2 == 0;
}

int sumEvens(const int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        if (isEven(a[i])) {
            total += a[i];
        }
    }
    return total;
}

void report(const int a[], int n) {
    printf("Sum of even values: %d\n", sumEvens(a, n));
}

int main(void) {
    int data[] = {3, 8, 12, 5, 7, 20};
    report(data, sizeof(data) / sizeof(data[0]));
    return 0;
}

main memanggil report, yang memanggil sumEvens, yang memanggil isEven di dalam sebuah loop. Setiap pemanggilan mendapat sekumpulan variabel lokal yang baru, ditumpuk di atas milik pemanggilnya, dan dibuang saat fungsi itu selesai.

Definisi di atas disusun sesuai urutan ketergantungan, isEven sebelum sumEvens sebelum report, karena C mengharuskan fungsi dideklarasikan sebelum dipanggil. Panggil fungsi yang letaknya lebih bawah di file, dan compiler akan mengeluh soal deklarasi implisit. Solusi umumnya adalah prototipe di dekat bagian atas file, sehingga kamu bebas mengatur urutan definisi. Fungsi yang memanggil dirinya sendiri juga sah dan berguna; itulah rekursi.

main juga sebuah fungsi

main adalah fungsi biasa yang dipanggil runtime untukmu. Tipe kembaliannya, int, adalah status keluar program: 0 berarti berhasil, selain nol berarti gagal, dan skrip shell serta alat build membacanya.

int main(void) {
    /* ... */
    return 0;
}

Sejak C99, sampai di akhir main tanpa return otomatis mengembalikan 0. Ini aturan khusus yang hanya berlaku untuk main. Setiap fungsi non-void lain yang berakhir tanpa mengembalikan nilai menghasilkan undefined behavior saat pemanggil memakai hasilnya.

Bentuk standar lainnya adalah int main(int argc, char *argv[]), yang menerima argumen baris perintah. Keduanya benar; void main() tidak benar, apa pun kata tutorial lama.

Kesalahan umum

• Lupa return di fungsi non-void. Pemanggil lalu membaca nilai sampah. gcc -Wall akan memberi peringatan.
• Mendeklarasikan variabel dengan nama yang sama seperti parameter di dalam badan fungsi. Variabel itu menutupi parameternya, dan penugasan yang kamu maksudkan untuk input tidak sampai ke mana-mana.
• Mengira fungsi bisa mengubah argumennya. C mengirim semuanya berdasarkan nilai (by value), jadi fungsi menerima salinan. void reset(int x) { x = 0; } tidak mengubah apa pun di tempat pemanggilan. Ini topik halaman berikutnya.
• Tidak menulis tanda kurung saat memanggil. printBanner; adalah ekspresi sah yang menghitung alamat fungsi lalu membuangnya. Kode itu bisa dikompilasi, tidak melakukan apa-apa, dan -Wall menandainya.
• Menulis () alih-alih (void). Sah, tapi mematikan pemeriksaan argumen di dialek C yang lebih lama.