Progres sesi
0 / 5
Sheet 10 · Materi Detail

Mesin Kecil dalam Program

Fungsi dan prosedur — memecah program jadi bagian kecil yang bisa dipakai ulang, memahami parameter, nilai kembali, lingkup variabel, pass by value, dan pointer secukupnya. Proyek akhir dimulai hari ini.

Durasi: 120 menit Prasyarat: Pertemuan 3–9 Tools: penelusur stack pemanggilan fungsi
1

Fungsi = Mesin dengan Masukan dan Keluaran

Blender itu mesin: masukkan buah (input/parameter), tekan tombol, keluar jus (output/nilai kembali). Kamu nggak perlu tahu isi mesinnya setiap kali mau bikin jus — cukup tahu cara memakainya. Fungsi di program sama: sekali ditulis, bisa dipanggil berkali-kali dari mana saja.

Dalam pseudocode ada dua jenis: FUNGSI (mengembalikan nilai) dan PROSEDUR (hanya melakukan sesuatu, tanpa nilai kembali). Di C, prosedur ditulis sebagai fungsi bertipe void.

FUNGSI Kuadrat(x : integer) → integer
    KEMBALIKAN x * x

PROSEDUR Garis(n : integer)
    UNTUK i ← 1 SAMPAI n LAKUKAN
        TULIS "-"
    AKHIR UNTUK
int kuadrat(int x) {
    return x * x;
}

void garis(int n) {
    int i;
    for (i = 1; i <= n; i++) {
        printf("-");
    }
}
BagianContohArti
Tipe kembalianint, double, voidJenis nilai yang dikeluarkan; void = tidak ada.
NamakuadratAturannya sama dengan nama variabel. Pakai kata kerja/deskriptif.
Parameter(int x)Variabel lokal yang diisi nilai dari pemanggil. Boleh kosong: (void).
returnreturn x * x;Mengirim hasil ke pemanggil dan langsung keluar dari fungsi.
2

Prototipe dan Alur Pemanggilan

Compiler C membaca dari atas ke bawah. Kalau main memanggil fungsi yang baru didefinisikan di bawahnya, compiler perlu "diperkenalkan" dulu lewat prototipe — baris judul fungsi diakhiri titik koma. Dengan begitu main bisa ditaruh di atas dan dibaca seperti daftar isi.

#include <stdio.h>

/* prototipe */
int luasPersegiPanjang(int p, int l);
double rataRata(int a, int b, int c);
void garis(int n);

int main(void) {
    garis(24);
    printf("Luas 7 x 3   = %d\n", luasPersegiPanjang(7, 3));
    printf("Rata-rata    = %.2f\n", rataRata(80, 75, 90));
    garis(24);
    return 0;
}

int luasPersegiPanjang(int p, int l) {
    return p * l;
}

double rataRata(int a, int b, int c) {
    return (a + b + c) / 3.0;
}

void garis(int n) {
    int i;
    for (i = 0; i < n; i++) {
        printf("-");
    }
    printf("\n");
}
------------------------
Luas 7 x 3   = 21
Rata-rata    = 81.67
------------------------
Saat fungsi dipanggil: (1) nilai argumen disalin ke parameter, (2) main "berhenti sejenak" dan eksekusi pindah ke badan fungsi, (3) saat return (atau akhir fungsi void), eksekusi kembali ke titik pemanggilan membawa nilai kembaliannya.
3

Lingkup Variabel dan Pass by Value

Setiap pemanggilan fungsi mendapat ruang kerja sendiri (disebut stack frame) berisi parameter dan variabel lokalnya. Variabel lokal hanya hidup selama fungsinya berjalan dan tidak terlihat dari fungsi lain — main nggak bisa mengintip temp milik fungsi lain, dan sebaliknya.

Di C, argumen dikirim sebagai salinan nilai (pass by value). Fungsi menerima fotokopi, bukan dokumen aslinya — mencoret fotokopi nggak mengubah aslinya. Itu sebabnya fungsi tukar di bawah gagal. Supaya berhasil, kita kirim alamat variabelnya (pointer), bukan nilainya.

&a

Alamat dari a

"Di mana kotak a berada." Inilah yang dikirim ke scanf sejak Pertemuan 3.

int *x

Pointer ke int

Variabel yang isinya alamat sebuah int. Parameter int *x menerima &a.

*x

Isi di alamat itu

"Kotak yang ditunjuk x." Mengubah *x berarti mengubah a milik pemanggil.

4

Mengirim Array ke Fungsi

Array tidak disalin saat dikirim ke fungsi — yang dikirim adalah alamat loker pertamanya (ingat: nama array = alamat). Konsekuensinya dua:

  • Fungsi bisa mengubah isi array milik pemanggil.
  • Fungsi tidak tahu panjang array — sizeof di dalam fungsi tidak memberi jumlah elemen. Jadi panjangnya harus dikirim sebagai parameter tambahan n.
#include <stdio.h>

int jumlahArray(int a[], int n) {
    int i, total = 0;
    for (i = 0; i < n; i++) {
        total += a[i];
    }
    return total;
}

void gandakan(int a[], int n) {
    int i;
    for (i = 0; i < n; i++) {
        a[i] *= 2;
    }
}

int main(void) {
    int data[] = {4, 1, 5};
    int n = 3;

    printf("Jumlah awal       : %d\n", jumlahArray(data, n));
    gandakan(data, n);
    printf("Setelah digandakan: %d %d %d\n", data[0], data[1], data[2]);
    printf("Jumlah sekarang   : %d\n", jumlahArray(data, n));
    return 0;
}
Jumlah awal       : 10
Setelah digandakan: 8 2 10
Jumlah sekarang   : 20
5

Proyek Akhir Tahap 1: Mini Toolkit Angka

Mini Toolkit Angka adalah program menu di terminal yang mengumpulkan "alat hitung" dari seluruh kelas. Dibangun dalam tiga tahap:

Tahap 1 · P10

Kerangka & fungsi

Menu berulang (do-while + switch), cek prima, cek genap/ganjil, jumlah digit.

Tahap 2 · P11

Rekursif dasar

Faktorial, pangkat, dan jumlah digit versi rekursif.

Tahap 3 · P12

Rekursif lanjutan

Fibonacci, cek palindrom rekursif, pencarian biner — lalu presentasi.

Aturan main: main() hanya berisi perulangan menu dan pemanggilan fungsi. Semua perhitungan ada di fungsi terpisah. Ini kerangka tahap 1 yang sudah jalan — salin, jalankan, lalu kembangkan.

#include <stdio.h>

/* ===== Mini Toolkit Angka — tahap 1 ===== */
int cekPrima(int n);
int cekGenap(int n);
int jumlahDigit(int n);
void tampilkanMenu(void);

int main(void) {
    int pilihan, n;

    do {
        tampilkanMenu();
        printf("Pilih: ");
        scanf("%d", &pilihan);

        switch (pilihan) {
            case 1:
                printf("n = ");
                scanf("%d", &n);
                printf("%d %s prima\n", n, cekPrima(n) ? "adalah" : "bukan");
                break;
            case 2:
                printf("n = ");
                scanf("%d", &n);
                printf("%d adalah bilangan %s\n", n, cekGenap(n) ? "genap" : "ganjil");
                break;
            case 3:
                printf("n = ");
                scanf("%d", &n);
                printf("Jumlah digit %d = %d\n", n, jumlahDigit(n));
                break;
            case 0:
                printf("Sampai jumpa!\n");
                break;
            default:
                printf("Pilihan tidak dikenal\n");
        }
    } while (pilihan != 0);
    return 0;
}

void tampilkanMenu(void) {
    printf("\n=== MINI TOOLKIT ANGKA ===\n");
    printf("1. Cek bilangan prima\n");
    printf("2. Cek genap/ganjil\n");
    printf("3. Jumlah digit\n");
    printf("0. Keluar\n");
}

int cekPrima(int n) {
    int d;
    if (n < 2) return 0;
    for (d = 2; d * d <= n; d++) {
        if (n % d == 0) return 0;
    }
    return 1;
}

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

int jumlahDigit(int n) {
    int total = 0;
    if (n < 0) n = -n;
    while (n > 0) {
        total += n % 10;
        n /= 10;
    }
    return total;
}
=== MINI TOOLKIT ANGKA ===
1. Cek bilangan prima
2. Cek genap/ganjil
3. Jumlah digit
0. Keluar
Pilih: 1
n = 17
17 adalah prima

=== MINI TOOLKIT ANGKA ===
1. Cek bilangan prima
2. Cek genap/ganjil
3. Jumlah digit
0. Keluar
Pilih: 3
n = 472
Jumlah digit 472 = 13

=== MINI TOOLKIT ANGKA ===
1. Cek bilangan prima
2. Cek genap/ganjil
3. Jumlah digit
0. Keluar
Pilih: 0
Sampai jumpa!
Tugas tahap 1 (dikumpulkan sebelum Pertemuan 11):
  1. Tambahkan menu 4: tabel perkalian n × n sebagai prosedur void tabelPerkalian(int n).
  2. Tambahkan menu 5: bilangan terbesar dari array — baca k angka ke array, lalu panggil int maksArray(int a[], int k).
  3. Tambahkan menu 6: tukar dua bilangan dengan void tukar(int *x, int *y) dan tampilkan hasilnya.
  4. Pastikan input menu yang salah (misal 9) tidak membuat program berhenti.
6

Cek Pemahaman

1. Fungsi bertipe void artinya…

void sebagai tipe kembalian = prosedur: melakukan sesuatu (mencetak, mengubah array) tanpa mengirim nilai balik.

2. Apa output program ini?

#include <stdio.h>

int gandakan(int x) {
    x = x * 2;
    return x;
}

int main(void) {
    int a = 5;
    int b = gandakan(a);
    printf("%d %d\n", a, b);
    return 0;
}
x adalah salinan a. Mengubah x tidak mengubah a (tetap 5). Nilai x yang sudah digandakan dikembalikan dan disimpan ke b (10).

3. Kenapa void tukar(int x, int y) tidak berhasil menukar a dan b milik main?

Pass by value: yang ditukar hanya salinannya di frame fungsi. Solusinya kirim alamat (&a, &b) ke parameter pointer.

4. Fungsi yang menerima array sebaiknya juga menerima panjangnya karena…

Di dalam fungsi, int a[] sebenarnya pointer. sizeof(a) memberi ukuran pointer, bukan array — jadi n harus dikirim terpisah.

5. Prototipe fungsi dibutuhkan ketika…

Compiler membaca dari atas. Prototipe memberi tahu nama, tipe kembalian, dan parameter sebelum fungsinya dipakai.
Skor: 0 / 5 terjawab benar
7

Ringkasan Pertemuan 10

  • Fungsi: tipe nama(parameter) { … return nilai; }. Prosedur = fungsi void.
  • Prototipe memperkenalkan fungsi yang didefinisikan di bawah main.
  • Setiap pemanggilan punya stack frame sendiri; variabel lokal tidak terlihat dari luar.
  • Argumen dikirim sebagai salinan (pass by value). Untuk mengubah variabel pemanggil, kirim alamatnya: tukar(&a, &b) dengan parameter int *x.
  • Array dikirim sebagai alamat: fungsi bisa mengubah isinya dan butuh parameter panjang.
Selanjutnya

Fungsi bisa memanggil fungsi lain. Tapi bagaimana kalau sebuah fungsi memanggil dirinya sendiri? Pertemuan 11: rekursif — dan stack frame yang baru kamu lihat akan jadi kunci memahaminya.

made by boflyeta.dev