# Fungsi Lecture 7. Motivation Complexity of programming problem  more difficult to consider the solution as a whole  clue: dividing the problem into.

## Presentasi berjudul: "Fungsi Lecture 7. Motivation Complexity of programming problem  more difficult to consider the solution as a whole  clue: dividing the problem into."— Transcript presentasi:

Fungsi Lecture 7

Motivation Complexity of programming problem  more difficult to consider the solution as a whole  clue: dividing the problem into small parts (module) Each module represent single task, free of error Modularisation : is the process of dividing a problem into separate tasks, each with a single purpose.

Benefits of modular design Ease of understanding  each module has only one function Reusable code Elimination of redundancy  avoid the repetition of writing Efficiency of maintenance

Modular name convention Describe the work to be done as a single specific function Use a verb, followed by a two-word object. Example: –Print_page_heading –Calculate_sales_tax –Validate_input_date

Example Design a solution algorithm that will prompt a terminal operator for three characters, accept those characters as input, sort them into ascending sequence and output them to the screen. The algorithm is to continue to read characters until ´XXX´is entered.

Original Solution algorithm Process_three_characters Prompt the operator for char_1, char_2, char_3 Get char_1, char_2, char_3 DOWHILE NOT (char_1=´X`AND char_2=´X´AND char_3=´X´) IF char_1>char_2 THEN temp = char_1 char_1 = char_2 char_2 = temp ENDIF IF char_2>char_3 THEN temp = char_2 char_2 = char_3 char_3 = temp ENDIF IF char_1>char_2 THEN temp = char_1 char_1 = char_2 char_2 = temp ENDIF Output to the screen char_1, char_2, char_3 Prompt operator for char_1, char_2, char_3 Get char_1, char_2, char_3 ENDDO END

Solution Algorithm with Modul Process_three_characters Read_three_characters DOWHILE NOT (char_1=´X`AND char_2=´X´AND char_3=´X´) Sort_three_characters Print_three_characters Read_three_characters ENDDO END Read_three_characters Prompt the operator for char_1,char_2,char_3 Get char_1, char_2, char_3 END Sort_three_characters IF char_1>char_2 THEN temp = char_1 char_1 = char_2 char_2 = temp ENDIF IF char_2>char_3 THEN temp = char_2 char_2 = char_3 char_3 = temp ENDIF IF char_1>char_2 THEN temp = char_1 char_1 = char_2 char_2 = temp ENDIF END Print_three_characters Output to the screen char_1, char_2, char_3 END Mainline 1rst Module 2nd Module 3rd Module

Definisi Fungsi Fungsi merupakan bagian dari kode program yang memiliki tugas tertentu. Kegunaan fungsi: –Membuat program lebih terstruktur, mudah dipahami dan dikembangkan. –Mengurangi pengulangan kode (duplikasi kode). Tugas khusus suatu fungsi dapat dilihat dari beberapa fungsi standard, misalnya: –getch( ), untuk membaca kode tombol papan ketik yang ditekan. –printf( ), untuk menampilkan informasi atau data ke layar.

Fungsi memerlukan masukan yang dinamakan argumen atau parameter. Masukan ini selanjutnya diolah oleh fungsi dan hasil keluarannya dapat berupa sebuah nilai (disebut nilai keluaran fungsi atau nilai balik fungsi).

Bentuk umum Fungsi Penentu_tipe nama_fungsi (daftar parameter) Deklarasi parameter { tubuh fungsi }

Penentu tipe digunakan untuk menentukan tipe keluaran fungsi, dari salah satu tipe data seperti char atau int. Jika penentu tipe tidak disebutkan, maka akan dianggap sebagai int. Sebuah fungsi dapat saja tidak mengandung parameter sama sekali, bahkan tanpa deklarasi parameter. Contoh:

Memberi Nilai Akhir Fungsi Sebuah fungsi dapat mempunyai nilai keluaran (seperti diperlihatkan pada contoh di atas), dan di dalam tubuh fungsi pernyataan yang diberikan untuk memberikan nilai akhir fungsi dapat berupa pernyataan return.

Program 1. Penggunaan Fungsi /* ------------------------------------------- */ /* File program : fungsi.c */ /* Contoh pembuatan fungsi */ /* ------------------------------------------- */ #include inisialisasi(); main() { int x, y; x = inisialisasi(); printf("x = %d\n", x); y = inisialisasi (); printf("y = %d\n", y); } inisialisasi() { return(0); }

Hasil eksekusi: C>Fungsi x = 0 y = 0

Program 1 memperlihatkan bahwa suatu fungsi cukup didefinisikan satu kali, tetapi dapat digunakan beberapa kali untuk menghindari duplikasi kode dan menghemat penulisan program maupun penyimpanan kode dalam memori. Bagi suatu fungsi, jika suatu pernyataan return dieksekusi, maka eksekusi terhadap fungsi akan berakhir dan nilai pada parameter return akan menjadi keluaran fungsi. Untuk fungsi yang tidak memiliki pernyataan return, maka tanda } akan digunakan sebagai tanda akhir eksekusi fungsi.

Program 2 Fungsi untuk memperoleh nilai minimum parameternya /* ---------------------------------------------------- */ /* File program : Minimum.c */ /* Contoh fungsi yang mengandung argumen */ /* ----------------------------------------------------- */ #include minimum(x,y) int x,y; { if (x < y) return(x); else return(y); } main() { int a = 20; int b = 44; int hasil; hasil = minimum(a,b); printf("Nilai terkecil = %d\n", hasil); printf("Nilai terkecil = %d\n", minimum(3,2)); }

Hasil eksekusi: C>Minimum Nilai terkecil = 20 Nilai terkecil = 2

Fungsi pada program 2 mempunyai dua buah parameter berupa x dan y. Oleh karena itu fungsi juga mengandung bagian untuk mendeklarasikan parameter, berupa : int x, y; Penentuan nilai keluaran fungsi dilakukan pada tubuh fungsi, dengan pernyataan: if (x < y) return(x); else return(y); Pernyataan di atas menyatakan: –Jika x < y, maka nilai keluaran fungsi adalah sebesar nilai x –Untuk keadaan selainnya ( x > y), maka keluaran fungsi adalah sebesar y. Fungsi minimum() dipanggil dua kali. Yang pertama : hasil = minimum(a,b); Yang memberikan nilai terkecil diantara a dan b ke variabel hasil. Yang kedua dengan pernyataan: printf("Nilai terkecil = %d\n", minimum(3,2)); berupa instruksi untuk menampilkan nilai terkecil antara 3 dan 2.

Prototipe Fungsi Dari program 1 dan 2, dapat dilihat bahwa penulisan tubuh fungsi bisa pada awal program maupun pada akhir program. Pada contoh program 2, pendefinisian fungsi dilakukan pada awal program sebelum pernyataan program utama (main()). Model penulisan ini merupakan model klasik. Pada program 1, pendefinisian fungsi dilakukan setelah program utama, namun pada awal program (sebelum program utama) harus dituliskan nama fungsi dan parameternya yang diakhiri dengan tanda titik-koma. Pendeklarasian fungsi seperti pada program 1 dikenal sebagai prototipe fungsi (function prototype).

Prototipe fungsi digunakan untuk menjelaskan kepada kompiler mengenai: –Tipe keluaran fungsi –Jumlah parameter –Tipe dari masing-masing parameter Bagi kompiler, informasi dalam prototipe akan digunakan untuk memeriksa keabsahan (validitas) parameter dalam pemanggilan fungsi. Salah satu keuntungan penggunaan prototipe, kompiler akan melakukan konversi seandainya antara tipe parameter dalam definisi dan parameter saat pemanggilan fungsi tidak sama, atau akan menunjukkan kesalahan kalau jumlah parameter dalam definisi dan saat pemanggilan berbeda.

Program 3 /* ----------------------------------------- */ /* File program : Jumlah.c */ /* Contoh fungsi dengan prototipe */ /* ----------------------------------------- */ #include float jumlah(float x,float y); main() { int a = 6; int b = 3; float c; c = jumlah(a,b); printf("a + b = %g\n",c); printf("Hasil penjumlahan = %g\n", jumlah(20.1, 0.9)); } float jumlah(float x, float y) { return(x + y); }

Hasil eksekusi : c>Jumlah a + b = 9 Hasil penjumlahan = 21

Parameter Formal dan Parameter Aktual Parameter formal adalah variabel yang ada pada daftar parameter dalam definisi fungsi. Pada fungsi jumlah( ) program 3, x dan y dinamakan sebagai parameter formal. Parameter aktual adalah parameter (tidak selamanya menyatakan variabel) yang digunakan dalam pemanggilan fungsi. Pada pernyataan: –c = jumlah(a, b); –y = jumlah(20.1, 0.9); a dan b merupakan parameter aktual dari fungsi jumlah (), demikian pula 20.1 dan 0.9 (meskipun bukan berupa variabel).

Cara Melewatkan Parameter Terdapat dua cara untuk melewatkan parameter ke dalam fungsi, yaitu dengan cara: –Pemanggilan dengan nilai (call by value) –Pemanggilan dengan referensi (call by reference) Pemanggilan dengan nilai merupakan cara yang digunakan pada contoh fungsi program terdahulu. Pada pemanggilan dengan nilai, nilai dari parameter aktual akan disalin ke parameter formal. Dengan cara ini nilai parameter aktual tidak bisa berubah sekalipun nilai parameter formal berubah.

Program 4 /* ------------------------------------------- */ /* File program : Tukar.c */ /* Melihat pengaruh pemanggilan dengan nilai */ /* ------------------------------------------- */ #include void tukar (int x, int y); main() { int a,b; a = 88; b = 77; printf("Nilai sebelum pemanggilan fungsi\n"); printf("a = %d b = %d\n\n",a,b); tukar(a,b); printf("Nilai sesudah pemanggilan fungsi\n"); printf("a = %d b = %d\n\n",a,b); } void tukar (int x, int y) { int z; z = x; x = y; y = z; printf("Nilai diakhir fungsi tukar()\n"); printf("x = %d y = %d\n\n",x,y); }

Hasil eksekusi : c> Tukar Nilai sebelum pemanggilan fungsi a = 88 b = 77 Nilai diakhir fungsi tukar() x = 77 y = 88 Nilai sesudah pemanggilan fungsi a = 88 b = 77

Dari contoh program 4 terlihat bahwa hasil pemanggilan fungsi tukar( ), variabel a dan b (yang dilewatkan ke fungsi tukar ( )) tidak berubah, walaupun pada fungsi tukar ( ) telah terjadi penukaran antara parameter x dan y. Hal ini terjadi karena x hanyalah salinan dari a dan y salinan dari b, serta definisi fungsi tidak mengembalikan nilai (diawali dengan void dan tidak ada instruksi return( ) ). Pemanggilan dengan referensi merupakan upaya untuk melewatkan alamat dari suatu variabel ke dalam fungsi. Cara ini dapat digunakan untuk mengubah isi suatu variabel di luar fungsi dengan pelaksanaan pengubahan dilakukan di dalam fungsi.

Perubahan pertama terletak dalam definisi fungsi, yakni berupa: tukar(int *px, int *py) { int z; z = *px; *px = *py; *py = z; …….. } Adapun perubahan dalam parameter aktual adalah sebagai berikut: Tukar(&a, &b); /* variabel diawali dengan & */

Pendeklarasian parameter: int *px, *py; menyatakan bahwa px dan py adalah suatu variabel pointer, yaitu variabel yang berisi alamat variabel yang lain. Dalam pemanggilan fungsi &a dan &b masing-masing berarti “alamat a” dan “alamat b”

Variabel pointer px menunjuk variabel a dan variabel pointer py menunjuk variabel b.

Program 5 /* ---------------------------------------------------------- */ /* File program : Tukar2.c */ /* Melihat pengaruh pemanggilan dengan referensi */ /* ---------------------------------------------------------- */ #include void tukar (int *px, int *py); main() { int a,b; a = 88; b = 77; printf("Nilai sebelum pemanggilan fungsi\n"); printf("a = %d b = %d\n\n",a,b); tukar(&a,&b); /* parameter alamat a dan alamat b */ printf("Nilai sesudah pemanggilan fungsi\n"); printf("a = %d b = %d\n\n",a,b); } void tukar (int *px, int *py) { int z; z = *px; *px = *py; *py = z; printf("Nilai diakhir fungsi tukar()\n"); printf("*px = %d *py = %d\n\n",*px,*py); }

Hasil eksekusi : c> Tukar2 Nilai sebelum pemanggilan fungsi a = 88 b = 77 Nilai diakhir fungsi tukar() *px = 77 *py = 88 Nilai sesudah pemanggilan fungsi a = 77 b = 88

Presentasi serupa