Function dan Prototype ~ Pemrograman dan Teknologi

Dalam keseharian kita, satu pekerjaan besar bisa kita pisahkan menjadi menjadi beberapa tugas yang lebih kecil. Setiap pekerjaan kecil yang berisi serangkaian tindakan bisa kita beri nama tertentu. Nama tersebut akan memudahkan penyampaiannya sehingga kita tidak perlu menjelaskan prosesnya langkah demi langkah setiap kali kita memerintahkan orang lain untuk melakukannya.

Selain pembagian tugas di dunia nyata, pembagian tugas juga bisa dilakukan dalam sebuah kode program. Dalam pemrograman, bagian-bagian yang lebih kecil dari suatu tugas dalam kode program disebut dengan subprogram atau function. Setiap function memiliki nama yang bisa kalian gunakan saat "pemanggilan" function tersebut. Dengan adanya function, kalian bisa menggunakan sekumpulan statement yang sama berkali-kali. Kalian cukup menyebut nama yang mewakili statement-statement tersebut saat akan menggunakannya.

Kode program dalam bahasa C atau C++ minimal menggunakan satu function utama, yaitu "int main(){...}". Statement-statement dalam function utama akan dicompile sebagai bagian dari program yang pertama kali dijalankan. Saat kalian menjalankan sekumpulan pernyataan yang sama berulang-ulang "secara terpisah" kalian akan membutuhkan function selain "int main(){...}" untuk mempersingkat penulisan kode program.

#include <stdio.h>

void halo(){
    printf("dunia!");
    return;
}

int main(){
    printf("Halo, ");
    halo();
    return 0;
}

Kode program diatas memiliki dua function, yaitu "main" dan "halo". Function main merupakan function utama yang pasti akan dijalankan dalam program kita tanpa harus dipanggil. Berbeda dengan function main yang merupakan function utama, function halo baru digunakan jika ada "pemanggilan" dari function main atau function lain yang sudah dipanggil.

Pemanggilan function halo() pada kode program di atas menampilkan tulisan "dunia!". Karena tulisan "Halo, " ditampilkan sebelum pemanggilan function halo(), maka hasil dari programnya adalah "Halo, dunia!".

Parameter
Parameter adalah variabel yang akan menyimpan nilai dari variabel atau konstanta yang disertakan saat pemanggilan function. Sebuah function bisa memiliki beberapa parameter atau tidak sama sekali. Kalian bisa mendeklarasikan parameter dengan meletakkannya di antara tanda kurung "(...)" setelah nama function. Jika parameter ada lebih dari 1, maka setiap parameter bisa dipisahkan dengan tanda koma ( , ). Contoh penggunaan function dengan parameter bisa kalian lihat di bawah ini.

#include <stdio.h>

void kalkulator(float parameter_a, float parameter_b){
    printf("a + b = %f\n", parameter_a + parameter_b);
    printf("a - b = %f\n", parameter_a - parameter_b);
    printf("a x b = %f\n", parameter_a * parameter_b);
    printf("a / b = %f\n", parameter_a / parameter_b);
}

int main(){
    kalkulator(5, 2);
    return 0;
}

Saat function dipanggil, parameter harus digantikan dengan nilai berupa angka, konstanta, atau variabel. Nilai yang digunakan saat pemanggilan function harus sesuai dengan tipe data parameter dalam function tersebut. Function kalkulator pada contoh di atas parameternya ada dua, yaitu a dan b. Keduanya memiliki tipe data float.

Dalam beberapa bahasa pemrograman nilai yang terdapat dalam kurung saat pemanggilan function biasa disebut dengan argumen. Untuk mempermudah pembahasan, kali ini kita akan menggunakan istilah "argumen".

Variabel yang dijadikan argumen akan disimpan sebagai parameter function sebelum parameter tersebut digunakan dalam function. Jika function kalkulator dipanggil dengan argumen yang bernilai 5 dan 2, parameter_a dan parameter_b akan menyimpan nilai yang digunakan saat pemanggilan sesuai posisinya. Jadi, nilai dari parameter_a setelah function kalkulator dipanggil adalah 5, dan parameter_b nilainya adalah 2.

Mengembalikan Nilai dengan Return

Selain parameter, setiap function bisa memiliki tipe data kembalian yang dikembalikan dengan menggunakan return. Kalian bisa menyimpan nilai yang dikembalikan dengan return di dalam sebuah variabel. Kalau mau diumpamakan dengan tugas di dunia nyata, kalian bisa menganggap nilai yang dikembalikan oleh return adalah laporan dari tugas yang sudah selesai.

Pada contoh-contoh sebelumnya, tipe data kembalian yang kita gunakan adalah void. Tipe data "void" (kosong) digunakan jika function tidak memerlukan nilai untuk dikembalikan.

Jika kalian ingin mengembalikan nilai tertentu dari function, kalian bisa menggunakan tipe data selain void. Tentu saja, variabel yang menerima kembalian dari function harus sesuai tipe datanya.

#include <stdio.h>

float setengah(float parameter_a, float parameter_b){
       parameter_a/=parameter_b;
       return parameter_a;
}

int main(){
float kembalian, a=5;
       kembalian=setengah(a, 2);
       printf("kembalian = %f", kembalian);
       return 0;
}

Lingkup Penggunaan Variabel
Kadang kita membutuhkan beberapa variabel tambahan di dalam sebuah function. Variabel yang kita deklarasikan dalam sebuah function hanya bisa digunakan saat pemanggilan function tersebut sehingga suatu function tidak dapat menggunakan nilai dari variabel yang di deklarasikan dalam function lain. Selain itu nilai variabel yang di deklarasikan dalam sebuah function akan "dideklarasikan ulang" setiap ada pemanggilan function.

Variabel yang dideklarasikan di awal program dan di luar function disebut variabel global. Jika tidak ada variabel dengan nama yang sama di dalam function, maka variabel global yang akan digunakan. Variabel global dapat di gunakan di semua function yang tidak memiliki variabel lokal dengan nama yang sama dengan variabel global tersebut.
Variabel yang dideklarasikan di dalam function disebut variabel lokal. saat nilai variabel lokal diubah, nilai variabel global dengan nama yang sama tidak akan berubah. Walaupun namanya sama, variabel lokal dan variabel global dengan nama yang sama sebenarnya adalah dua variabel yang mempunyai tempat penyimpanan berbeda. Variabel global tidak akan digunakan jika sudah ada variabel lokal dengan nama yang sama dengan variabel global.

#include <stdio.h>

int angka;

int variabel_lokal(){
int angka;
    angka=9;
    printf("nilai angka didalam fungsi variabel_lokal: %d\n", angka);
    return 0;
}

int main(){
    angka=8;
    printf("nilai angka didalam fungsi main: %d\n", angka);
    variabel_lokal();
    printf("nilai angka didalam fungsi main: %d\n", angka);
    return 0;
}

Function Overloading?
Function overloading adalah penggunaan function-function dengan nama yang sama tapi parameternya berbeda tipe data atau jumlahnya. Dalam satu kode program, nama function yang sama bisa digunakan oleh beberapa function selama tipe data (setiap parameter) atau jumlah parameternya berbeda. Contohnya bisa kalian lihat di bawah ini.

#include <stdio.h>

int koordinat(int x, int y){
    printf("koordinat {%d, %d}\n", x, y);
    return 0;
}

int koordinat(float x, float y){
    printf("koordinat {%d, %f}\n", x, y);
    return 0;
}

int koordinat(int x, int y, int z){
    printf("koordinat {%d, %d, %d}\n", x, y, z);
    return 0;
}

int main(){
    koordinat(3, 4);
    koordinat(3, 4, 5);
    return 0;
}

Pada contoh di atas, nama functionnya sama-sama koordinat, tapi function-function tersebut memiliki jumlah parameter berbeda. Function dengan nama yang sama akan dipilih berdasarkan perbedaan parameternya. Selain menggunakan function yang berbeda jumlah parameternya, kalian juga bisa menggunakan function yang sama jumlah parameternya tapi "urutan tipe datanya" berbeda.

Kalau ada function dengan nama dan jumlah parameter yang sama, compiler seharusnya akan bisa membedakan function yang digunakan berdasarkan urutan tipe data dalam functionnya. Yang tidak boleh kalian lakukan adalah menggunakan function yang jumlah parameternya sama dan hanya berbeda nama parameternya, tanpa ada perbedaan tipe data.

Prototype
Saat membuat program, kode program dalam satu project tidak hanya dituliskan ke dalam satu file. Program bisa dibuat dengan menggunakan banyak file dalam satu project. Program akan dimulai dari file yang memiliki fungsi utama. Untuk membuat program dalam beberapa file dibutuhkan prototype sebagai penghubungnya.

Prototype adalah deklarasi dari sebuah function yang berisi nama function, tipe data kembalian dan tipe data parameternya. Prototype hanya harus dideklarasikan jika "function yang dipanggil" berada di atas "function yang memanggil", atau saat function berada dalam file yang berbeda. Tidak seperti variabel, prototype tidak selalu perlu untuk dideklarasikan saat function akan digunakan.

Contoh deklarasi prototype adalah sebagai berikut :
=====
int myfunction(int a, float b);
atau
int myfunction(int, float);
=====
Perhatikan kode program dibawah ini!

#include <stdio.h>

int angka;

int main(){
    angka=8;
    printf("nilai angka didalam fungsi main: %d\n", angka);
    variabel_lokal();
    printf("nilai angka didalam fungsi main: %d\n", angka);
    return 0;
}


int variabel_lokal(){
int angka;
    angka=9;
    printf("nilai angka didalam fungsi variabel_lokal: %d\n", angka);
    return 0;
}

Program di atas mungkin akan menghasilkan error atau peringatan karena function "variabel_lokal" berada dibawah function main (yang merupakan tempat function tersebut dipanggil). Jika tidak ingin terjadi error tanpa membalik urutan penulisannya, tambahkan prototype dari function variabel lokal.

#include <stdio.h>

int angka;
int variabel_lokal();//prototype function variabel_lokal

int main(){
    angka=8;
    printf("nilai angka didalam fungsi main: %d\n", angka);
    variabel_lokal();
    printf("nilai angka didalam fungsi main: %d\n", angka);
    return 0;
}

int variabel_lokal(){
int angka;
    angka=9;
    printf("nilai angka didalam fungsi variabel_lokal: %d\n", angka);
    return 0;
}

Menggunakan Prototype di dalam Project yang Memiliki Banyak File
Prototype juga akan berguna saat kita menggunakan lebih dari satu file sebagai source code dalam satu project. Dengan prototype, kita bisa menggunakan function dari file kode program yang berbeda. Saat kita akan menggunakan function dari kode program di file lain, kita perlu mendeklarasikan protype function-nya di file yang akan menggunakan suatu function.

Untuk menggunakan prototype dalam project dengan lebih dari satu file, yang harus kalian lakukan adalah, buat project baru dengan dua file atau lebih. Misalnya, kita akan membuat sebuah project dalam bahasa C++ dengan file bernama main.cpp dan terserah.cpp.

Setelah project dibuat, kalian bisa membuat file baru dengan menggunakan File=> New => Empty File. Kalian bisa memberi nama terserah.cpp atau yang lain pada filenya. Isi terserah.cpp dengan kode program berikut!

#include <stdio.h>

int functionku(int n){
    printf("Ada %d orang di sebelah\n", n);
    return 0;
}

Dalam file utama ( yang biasanya bernama "main.cpp" ), berikan kode program berikut ini!

int functionku(int n);

int main(){
    functionku(5);
    return 0;
}

Untuk memahami penggunaan function coba buat kode program sendiri dengan menggunakan function sederhana. Kalian tidak perlu memusingkan apa yang saya bahas kalau kalian belum paham. Kalian bisa membaca tulisan saya berulang-ulang sambil menganalisa dan mengubah kode program yang sudah saya berikan.

Waktu Hidup Variabel
Kalau penggunaan variabel di dalam lokasi memori yang sama dianggap sebagai waktu hidup variabel, maka usia variabel lokal adalah usia yang sangat singkat. Variabel lokal hanya berusia sesuai dengan seberapa lama waktu penggunaan function.

Setiap variabel lokal dalam function umumnya akan dihapus setelah digunakan. Itu karena variabel lokal menggunakan lokasi memori yang berbeda-beda setiap kali function dipanggil. Jika kalian ingin menggunakan lokasi memori yang sama secara terus menerus, kalian perlu menggunakan keyword static. Keyword static akan memperpanjang waktu penggunaan lokasi memori yang sama oleh suatu variabel sehingga lokasi memori dari sebuah variabel tidak akan berubah sampai program selesai dijalankan.

#include <stdio.h>

int fungsiku_non_static(){
int angka;
    printf("%d", angka);
    angka++;
    return 0;
}

int fungsiku_static(){
static int angka;
    printf("%d", angka);
    angka++;
    return 0;
}

int main(){
    printf("Tidak menggunakan static!\n");
    fungsiku_non_static();
    fungsiku_non_static();
    fungsiku_non_static();

    printf("\nMenggunakan static!\n");
    fungsiku_static();
    fungsiku_static();
    fungsiku_static();
    printf("\n");
    return 0;
}

Tanpa keyword static, function akan terus menerus mengalokasikan memori di alamat yang baru setiap kali function dipanggil. Karena itu, variabel lokal yang tidak menggunakan static dalam deklarasinya mungkin saja akan selalu kembali ke nilai 0. Pada beberapa compiler, variabel lokal mungkin saja akan bernilai acak setiap kali function dipanggil (sesuai nilai terakhir yang tersimpan dalam lokasi memori yang digunakan variabel tersebut).

Saat menggunakan static, variabel hanya akan dideklarasikan dan dialokasikan memorinya sekali hingga program berakhir. Nilai variabel tidak akan kembali ke nilai 0 atau nilai acak kalau nilai variabel diubah dengan operator tertentu setelah function dipanggil lebih dari sekali. Untuk lebih jelasnya, kalian bisa menganalisa sendiri kode program yang sudah saya berikan.