LAPORAN PRAKTIKUM APLIKASI PEMROGRAMAN BAHASA C Dosen Pengampu : Ibrahim Lammada.,ST.,MT
Disusun Oleh : Farhan Auriza 1510631160047 1510631160047 Ferdyansyah sultonia 1510631160048 1510631160048
PROGRAM STUDI TEKNIK ELEKTRO FAKULTAS TEKNIK UNIVERSITAS SINGAPERBANGSA KARAWANG TAHUN 2017
DAFTAR ISI DAFTAR ISI ................................................................................................................................... ......................................................................................................................................... ....... 2 ALGORITMA & FLOWCHART ....................................................................................................... 4 1.1 TUJUAN ...................................................................... ....................................................................................................................................... ................................................................. 4 1.2 TEORI DASAR ........................................................................................................................... ........................................................................................................................... 4 1.3 PERCOBAAN ........................................................... ............................................................................................................................. .................................................................. 6 1.4 LISTING PROGRAM ..................................................................... ................................................................................................................ ........................................... 6 1.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 12 PRAKTIKUM 2 ................................................................... .................................................................................................................................. ............................................................... 13 DASAR PROGRAM BAHASA C ..................................................................................................... 13 2.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 13 2.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 13 2.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 16 2.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 17 2.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 20 PRAKTIKUM 3 ................................................................... .................................................................................................................................. ............................................................... 21 PENGAMBILAN KEPUTUSAN ....................................................................................................... ...................................................................................................... 21 3.1 TUJUAN...................................................................... ..................................................................................................................................... ............................................................... 21 3.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 21 3.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 25 3.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 26 3.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 35 PRAKTIKUM 4 ................................................................... .................................................................................................................................. ............................................................... 36 PENGULANGAN PENGULANGAN PROSES ...................................................................... ............................................................................................................... ......................................... 36 4.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 36 4.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 36 4.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 43 4.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 44 4.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 48 PRAKTIKUM 5 ................................................................... .................................................................................................................................. ............................................................... 49 FUNGSI DASAR ................................................................................................................................. ................................................................................................................................ 49 5.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 49 5.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 49 5.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 55 5.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 55
DAFTAR ISI DAFTAR ISI ................................................................................................................................... ......................................................................................................................................... ....... 2 ALGORITMA & FLOWCHART ....................................................................................................... 4 1.1 TUJUAN ...................................................................... ....................................................................................................................................... ................................................................. 4 1.2 TEORI DASAR ........................................................................................................................... ........................................................................................................................... 4 1.3 PERCOBAAN ........................................................... ............................................................................................................................. .................................................................. 6 1.4 LISTING PROGRAM ..................................................................... ................................................................................................................ ........................................... 6 1.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 12 PRAKTIKUM 2 ................................................................... .................................................................................................................................. ............................................................... 13 DASAR PROGRAM BAHASA C ..................................................................................................... 13 2.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 13 2.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 13 2.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 16 2.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 17 2.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 20 PRAKTIKUM 3 ................................................................... .................................................................................................................................. ............................................................... 21 PENGAMBILAN KEPUTUSAN ....................................................................................................... ...................................................................................................... 21 3.1 TUJUAN...................................................................... ..................................................................................................................................... ............................................................... 21 3.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 21 3.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 25 3.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 26 3.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 35 PRAKTIKUM 4 ................................................................... .................................................................................................................................. ............................................................... 36 PENGULANGAN PENGULANGAN PROSES ...................................................................... ............................................................................................................... ......................................... 36 4.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 36 4.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 36 4.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 43 4.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 44 4.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 48 PRAKTIKUM 5 ................................................................... .................................................................................................................................. ............................................................... 49 FUNGSI DASAR ................................................................................................................................. ................................................................................................................................ 49 5.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 49 5.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 49 5.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 55 5.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 55
5.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 59 PRAKTIKUM 6 ................................................................... .................................................................................................................................. ............................................................... 60 FUNGSI MATEMATIKA .................................................................................................................. ................................................................................................................. 60 6.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 60 6.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 60 6.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 61 6.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 61 6.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 63 PRAKTIKUM 7 ................................................................... .................................................................................................................................. ............................................................... 64 P O I N T E R ......................................................................................................... ...................................................................................................................................... .............................. 64 7.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 64 7.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 64 7.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 66 7.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 67 7.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 70 PRAKTIKUM 8 ................................................................... .................................................................................................................................. ............................................................... 71 A R R A Y ......................................................................................................................... ............................................................................................................................................ ................... 71 8.1 TUJUAN ..................................................................................................................................... ..................................................................................................................................... 71 8.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 71 8.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 76 8.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 77 8.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 80 PRAKTIKUM 9 ................................................................... .................................................................................................................................. ............................................................... 81 S T R I N G ............................................................... ..................................................................................................................................... ........................................................................... ..... 81 9.1 TUJUAN ...................................................................... ..................................................................................................................................... ............................................................... 81 9.2 TEORI DASAR ......................................................................................................................... ......................................................................................................................... 81 9.3 PERCOBAAN ........................................................... ........................................................................................................................... ................................................................ 84 9.4 LISTING PROGRAM ................................................................................ .............................................................................................................. .............................. 84 9.5 KESIMPULAN ..................................................................................................................... ......................................................................................................................... ..... 88 PRAKTIKUM 10 ................................................................. ................................................................................................................................ ............................................................... 89 S T R U K T U R .................................................................................................... ................................................................................................................................. .............................. 89 10.1 TUJUAN ..................................................................................................... .................................................................................................................................. .............................. 89 10.2 TEORI DASAR ....................................................................................................................... ....................................................................................................................... 89 10.3 PERCOBAAN ......................................................... ......................................................................................................................... ................................................................ 93 10.4 LISTING PRPOGRAM ..................................................................................................... ......................................................................................................... ..... 95 10.5 KESIMPULA K ESIMPULAN N ................................................................................................................... ....................................................................................................................... ..... 97
PRAKTIKUM 1 ALGORITMA & FLOWCHART 1.1 TUJUAN 1. Mampu memahamin persoalan 2. Mendesain penyelesaian persoalan ke dalam algoritma 3. Menotasikan algoritma yang ssudah dibuat menggunakan notasi flowchart
1.2 TEORI DASAR Beberapa langkah dalam proses pembuatan suatu program atau software 1. Mendefinisikan masalah dan menganalisanya
Langkah awal yang harus dilakukan adalah mengidentifikasikan masalah antara lain tujuan dari awal oembuatan program, parameter-parameter yang digunakan, fasilitas apa saja yang akan disediakan oleh program. Kemudian menentukan metode atau algoritma apa yang akan diterapkan untuk menyelesaikan masalah tersebut dan terakhir menentukan bahasa program yang digunakan untuk pembuatan program. 2. Merealisasikan dengan langkah-langkah berikut :
Start
Desain Algoritma & flowchart
Menulis Program
Test Kebenaran Program
Dokumentasi
End
Algoritma
Algoritma adalah urutan langkah-langkah logika yang menyatakan suatu tugas dalam menyelesaikan suatu masalah atau problem. Contoh : Buatlah algoritma untuk menentukan apakah suatu bilangan merupakan bilangan ganjil atau bilangan genap. Algoritmanya : 1. 2. 3. 4.
Masukkan sebuah bilangan sembarang Bagi bilangan tersebut dengan bilangan 2 Hitung sisa hasil bagi pada langkah 2. Bila sisa hasil bagi sama dengan 0 maka bilangan itu adalah bilangan genap tetapi bila sisa hasil bagi sama dengan 1 maka bilangan itu adalah bilangan ganjil
Dari contoh algoritma di atas tentang menentukan apakah suatu bilangan adalah bilangan ganjil atau bilangan genap, flowchart dari program adalah sebagai berikut
1.3 PERCOBAAN Untuk semua persoalan di bawah ini buatlah programnya : 1. Menghitung luas lingkaran dan mencetak hasilnya 2. Proses pengiriman email, jika email tidak terkirim maka akan dilakukan proses pengiriman email lagi. 3. Proses melakukan panggilan telepon, jika tidak diangkat maka dilakukan panggilan telepon lagi. 4. Perusahaan daerah air minum menentukan tarif per m 3 air berdasarkan ketentuan sebagai berikut: Buatlah program yang membaca jumlah pemakaian air, untuk menghitung biaya yang harus dibayar dan menampilkan hasilnya di layar 5. Buatlah program untuk menjumlahkan bilangan 1 sampai 10, tapi yang dijumlahkan bilangan ganjil saja.
1.4 LISTING PROGRAM 1.1 #include main() { float phi = 3.14; float jari2,luas; printf ("masukan jari2 lingkaran:"); scanf("%f", &jari2); luas=phi*jari2*jari2;
printf("luas : %f", luas); }
1.2 #include int main() { char huruf; printf ("proses pengiriman email\apakah email terkitim atau tidak [Y/T]?="); scanf ("%c", &huruf); switch (huruf) { case 'Y' : printf ("Email sudah terkirim\n");break; case 'T' : printf ("Mengirim ulang\n");break; }
}
1.3 #include int main() { char huruf; printf ("proses pemanggilan telepon\apakah apakah diangkat atau tidak [Y/T]?="); scanf ("%c", &huruf);
switch (huruf) { case 'Y' : printf ("Telepon terhubung\n");break; case 'T' : printf ("TELEPON ULANG\n");break; } }
1.4 #include #include void main() { int jpa; int tpm,total; printf ("jumlah pemakaian air:"); scanf("%d",&jpa); if (jpa<=15) tpm=300; else tpm=650; total=jpa*tpm; printf("harga air: %d",tpm); printf("\n total biaya air: %d\n",total); }
1.5 #include long int deret (int x); main() { int N; long int hasil; printf("masukan nilai akhir deret:"); scanf ("%d",&N); hasil=deret(N); printf("\n Nilai hasil penjumlahan deret= %d", hasil); } long int deret (int x) { int I; long int Z=0; printf("Nilai I :"); for (I=1; I<=x; I=I+2)
{ Z+=I; printf("\n %d",I); } return (Z); }
1.5 KESIMPULAN
PRAKTIKUM 2 DASAR PROGRAM BAHASA C 2.1 TUJUAN 1. Mengenal sintaks dan fungsi-fungsi dasar dalam bahasa C 2. Mampu membuat flowchart untuk algoritma untuk memecahkan suatu masalah sederhana, selanjutnya mengimplementasikannya dalam bahasa
2.2 TEORI DASAR Akar dari bahasa C adalah bahasa BCPL yang dikembangkan oleh Martin Richards pada tahun 1967. Bahasa ini memberikan ide kepada Ken Thompson yang kemudian mengembangkan bahasa yang disebut dengan B pada tahun 1970. Perkembangan selanjutnya dari bahasa B adalah bahasa C oleh Dennis Ritchie sekitar tahun 1970-an di Bell Telephone Laboratories Inc. (sekarang adalah AT&T Bell Laboratories). Bahasa C pertama kali digunakan pada komputer Digital Equipment Corporation PDP-11 yang menggunakan sistem operasi UNIX. Proses Kompilasi dan Linking Program C Proses dari bentuk source program, yaitu program yang ditulis dalam bahasa C hingga menjadi program yang executable ditunjukkan pada Gambar 1 di bawah ini:
Struktur Penulisan Program C
Program C pada hakekatnya tersusun atas sejumlah blok fungsi. Sebuah program minimal mengandung sebuah fungsi. Fungsi pertama yang harus ada dalam program C dan sudah ditentukan namanya adalah main(). Setiap fungsi terdiri atas satu atau beberapa pernyataan, yang secara keseluruhan dimaksudkan untuk melaksanakan tugas khusus. Bagian pernyataan fungsi (sering disebut tubuh fungsi) diawali dengan tanda kurung kurawal buka ({) dan diakhiri dengan tanda kurung kurawal tutup (}). Di antara kurung kurawal itu dapat dituliskan statemen-statemen program C. Namun pada kenyataannya, suatu fungsi bisa saja tidak mengandung pernyataan sama sekali. Walaupun fungsi tidak memiliki pernyataan, kurung kurawal haruslah tetap ada. Sebab kurung kurawal mengisyaratkan awal dan akhir definisi fungsi. Berikut ini adalah struktur dari program C
Pemrograman dengan bahasa C dikatakan bahasa terstruktur karena strukturnya menggunakan fungsi-fungsi sebagai program-program bagiannya ( subroutine). Fungsi fungsi yang ada selain fungsi utama (main()) merupakan program-program bagian. Fungsi-fungsi ini dapat ditulis setelah fungsi utama atau diletakkan di f ile pustaka (library). Jika fungsi-fungsi diletakkan di file pustaka dan akan dipakai di suatu program, maka nama file judulnya (header file) harus dilibatkan dalam program yang menggunakannya dengan preprocessor directive berupa #include. Fungsi-Fungsi Dasar a. Fungsi main() Fungsi main() harus ada pada program, sebab fungsi inilah yang menjadi titik awal dan titik akhir eksekusi program. Tanda { di awal fungsi menyatakan awal tubuh fungsi dan sekaligus awal eksekusi program, sedangkan tanda } di akhir fungsi merupakan akhir tubuh fungsi dan sekaligus adalah akhir eksekusi program. Jika program terdiri atas lebih dari satu fungsi, fungsi main() biasa ditempatkan pada posisi yang paling atas dalam pendefinisian fungsi. Hal ini hanya merupakan kebiasaan. Tujuannya untuk memudahkan pencarian terhadap program utama bagi pemrogram. Jadi bukanlah merupakan suatu keharusan.
b. Fungsi pri ntf() Fungsi printf() merupakan fungsi yang umum dipakai untuk menampilkan suatu keluaran pada layar peraga. Untuk menampilkan tulisan.
Selamat belajar bahasa C misalnya, pernyataan yang diperlukan berupa:
printf(“Selamat belajar bahasa C”);
Pernyataan di atas berupa pemanggilan fungsi printf() dengan argumen atau parameter berupa string. Dalam C suatu konstanta string ditulis dengan diawali dan diakhiri tanda petik-ganda (“). Perlu juga diketahui pernyataan dalam C selalu diakhiri dengan tanda titik koma (;). Tanda titik koma dipakai sebagai tanda pemberhentian sebuah pernyataan dan bukanlah sebagai pemisah antara dua pernyataan. Tanda \ pada string yang dilewatkan sebagai argumen printf() mempunyai makna yang khusus. Tanda ini bisa digunakan untuk menyatakan karakter khusus seperti karakter baris-baru ataupun karakter backslash (miring kiri). Jadi karakter seperti \n sebenarnya menyatakan sebuah karakter. Contoh karakter yang ditulis dengan diawali tanda \ adalah: \” menyatakan karakter petik -ganda \\ menyatakan karakter backslash \t menyatakan karakter tab Dalam bentuk yang lebih umum, format printf()
printf(“string kontrol”, daftar argumen); dengan string kontrol dapat berupa satu atau sejumlah karakter yang akan ditampilkan ataupun berupa penentu format yang akan mengatur penampilan dari argumen yang terletak pada daftar argumen. Mengenai penentu format diantaranya berupa: %d untuk menampilkan bilangan bulat (integer) %f untuk menampilkan bilangan titik-mengambang (pecahan) %c untuk menampilkan sebuah karakter %s untuk menampilkan sebuah string Contoh: #include main( ) { printf(“No : %d \n”, 10); printf(“Nama : %s \n”, “Ali”; printf(“Nilai : %f \n”,80.5; printf(“Huruf : %c \n”,‘A’); } Praprosesor #include #include merupakan salah satu jenis pengarah praprosesor ( preprocessor directive). Pengarah praprosesor ini dipakai untuk membaca file yang di antaranya berisi deklarasi fungsi dan definisi konstanta. Beberapa file judul disediakan dalam C. Filefile ini mempunyai ciri yaitu namanya diakhiri dengan ekstensi .h. Misalnya pada program #include menyatakan pada kompiler agar membaca file bernama stdio.h saat pelaksanaan kompilasi. Bentuk umum #include: #include “namafile”
Bentuk pertama (#include ) mengisyaratkan bahwa pencarian file dilakukan pada direktori khusus, yaitu direktori file include. Sedangkan bentuk kedua (#include “namafile”) menyatakan bahwa pencarian file dilakukan pertama kali pada direktori aktif tempat program sumber dan seandainya tidak ditemukan pencarian akan dilanjutkan pada direktori lainnya yang sesuai dengan perintah pada sistem operasi.
Kebanyakan program melibatkan file stdio.h (file-judul I/O standard, yang disediakan dalam C). Program yang melibatkan file ini yaitu program yang menggunakan pustaka I/O (input-output ) standar seperti printf(). Komentar dalam Program Untuk keperluan dokumentasi dengan maksud agar program mudah dipahami disuatu saat lain, biasanya pada program disertakan komentar atau keterangan mengenai program. Dalam C, suatu komentar ditulis dengan diawali dengan tanda /* dan diakhiri dengan tanda */.
Contoh : /* Tanda ini adalah komentar untuk multiple lines */ #include main() { printf(“Coba\n”); //Ini komentar satu baris }
2.3 PERCOBAAN Implementasikan semua permasalahan dibawah ini dengan menggunakan bahasa pemrograman C: 1. Mencetak kalimat dalam beberapa baris, dengan tampilan sebagai berikut: Program Studi Teknik Elektro Kampus UNSIKA tahun 2013 2. Mencetak kalimat dalam beberapa baris, dengan tampilan sebagai berikut : Saya sekarang sedang makan Kantin UNSIKA Murah meriah Cocok untuk kalangan mahasiswa 3. Program di bawah ini tidak berhasil di-compile karena masih terdapat beberapa kesalahan. Betulkan kesalahan program dibawah ini, dan tampilkan hasilnya:
#include main() { printf(”ternyata semester %f ini nilaiku jelek”,4); printf(”matematika %d dan metode numeric %c”,’B’,D); printf(”ooooo.....ternyata kuliah itu susah %d”,”sekali”); printf(”sepertinya %s rajin belajar minimal %s sehari”,’harus’,8); }
4. Mencetak kalimat dalam beberapa baris, dengan tampilan sebagai berikut: Dalam membuat ”program komputer” Terdapat \aturan \aturan yang harus dipenuhi Dalam menuliskan perintah-perintah dasar Untuk itu ”programmer” harus menghafal aturanaturan
Yang berlaku.
2.4 LISTING PROGRAM 1.1 #include main () { printf ("Program Studi Teknik Elektro\n"); printf ("Kampus UNSIKA Tahun 2013"); }
1.2 a#include main () { printf ("Saya sekarang sedang makan\n"); printf ("kantin UNSIKA\n"); printf ("Murah meriah\n"); printf ("cocok untuk kalangan mahasiswa"); }
1.3 #include main() { printf("ternyata semester ini nilaiku jelek %d\n",4); printf("matematika %s dan metode numerik %s\n","C","C"); printf("oooo....ternyata kuliah teh sesaaah pisaaaan %s\n","sekali"); printf("sepertinya saya %s mau belajar minimal %d", "harus",9); }
1.4 #include main() { printf("\tDalam membuat \"Program komputer\"\n"); printf("\tTerdapat \aturan \atiran yang harus dipenuhi\n"); printf("\tDalam menuliskan perintah perintah dasar \n"); printf("\tUntuk itu \"programmer\" harus menghafal aturan\n aturan\n"); printf("\tYang berlaku"); }
2.5 KESIMPULAN
PRAKTIKUM 3 PENGAMBILAN KEPUTUSAN 3.1 TUJUAN 1. 2. 3. 4. 5. 6.
Menjelaskan tentang operator kondisi (operator relasi dan logika) Menjelaskan penggunaan pernyataan if Menjelaskan penggunaan pernyataan if-else Menjelaskan penggunaan pernyataan if dalam if Menjelaskan penggunaan pernyataan else-if Menjelaskan penggunaan pernyataan switch
3.2 TEORI DASAR Untuk keperluan pengambilan keputusan, C menyediakan beberapa jenis pernyataan, berupa: a) Pernyataan if b) Pernyataan if-else, dan c) Pernyataan switch Pernyataan-pernyataan tersebut memerlukan suatu kondisi, sebagai basis dalam pengambilan keputusan. Kondisi umum yang dipakai berupa keadaan benar dan salah. Operator Relasi Operator relasi biasa dipakai untuk membandingkan dua buah nilai. Hasil pembandingan berupa keadaan benar atau salah. Keseluruhan operator relasi pada C ditunjukkan pada Tabel 3-1
Operator Logika Operator logika biasa dipakai untuk menghubungkan ekspresi relasi. Keseluruhan operator logika ditunjukkan pada tabel 2.
Bentuk pemakaian operator && dan || adalah Operand1 Operator Operand2 Pernyataan if Pernyataan if mempunyai bentuk umum : if (kondisi) pernyataan; Bentuk ini menyatakan : jika kondisi yang diseleksi adalah benar (bernilai logika = 1), maka pernyataan yang mengikutinya akan diproses. Sebaliknya, jika kondisi yang diseleksi adalah tidak benar (bernilai logika = 0), maka pernyataan yang mengikutinya tidak akan diproses.
Mengenai kodisi harus ditulis diantara tanda kurung, sedangkan pernyataan dapat berupa sebuah pernyataan tunggal, pernyataan majemuk atau pernyataan kosong. Diagram alir dapat dilihat seperti gambar 3.1
Arti dari pernyataan if-else :
Jika kondisi benar, maka pernyataan-1 dijalankan. Sedangkan bila kondisi bernilai salah, maka pernyataaan-2 yang dijalankan.
Masing-masing pernyataan-1 dan pernyataan-2 dapat berupa sebuah pernyataan tunggal, pernyataan majemuk ataupun pernyataan kosong. Contoh penggunaan pernyataan if-else adalah untuk menyeleksi nilai suatu bilangan pembagi. Jika nilai bilangan pembagi adalah nol, maka hasil pembagian dengan nilai nol akan mendapatkan hasil tak berhingga. Jika ditemui nilai pembaginya nol, maka proses pembagian tidak akan dilakukan. Pernyataan if di dalam if Di dalam suatu pernyataan if (atau if-else) bisa saja terdapat pernyataan if (atau if else) yang lain. Bentuk seperti ini dinamakan sebagai nested if . Secara umum, bentuk dari pernyataan ini adalah sebagai berikut :
Kondisi yang akan diseleksi pertama kali adalah kondisi yang terluar (kondisi -1). Jika kondisi-1 bernilai salah, maka statemen else yang terluar (pasangan if yang bersangkutan) yang akan diproses. Jika else (pasangannya tsb) tidak ditulis, maka penyeleksian kondisi akan dihentikan. Jika kondisi-1 bernilai benar, maka kondisi berikutnya yang lebih dalam (kondisi-2) akan diseleksi. Jika kondisi-2 bernilai salah, maka statemen else pasangan dari if yang bersangkutan yang akan diproses. Jika else (untuk kondisi-2) tidak ditulis, maka penyeleksian kondisi akan dihentikan. Dengan cara yang sama, penyeleksian kondisi akan dilakukan sampai dengan kondisi-n, jika kondisi-kondisi sebelumnya bernilai benar.
Pernyataan else-if Contoh implementasi nested if ini misalnya pembuatan sebuah program kalkulator sederhana. User memberikan masukan dengan format :
Operand1 operator operand2 Jenis operasi yang dikenakan bergantung pada jenis operator ang dimasukkan oleh user. Oleh karena itu program akan mengecek apakah operator berupa tanda ‘*’, ‘/’, ‘+’, ataukah tanda ‘-‘. Jika operator berupa tanda ‘*’ maka operand1 akan dikalikan dengan operand2. Jika operator berupa tanda ‘/’ maka operand1 akan dibagi dengan operand2 . Jika operator berupa tanda ‘+’ maka operand1 akan dijumlahkan dengan operand2. Jika operator berupa tanda ‘-’ maka operand1 akan dikurangi dengan operand2.
Kalau operator yang dimasukkan bukan merupakan salah satu dari jenis operator di atas, maka ekspresi tersebut tidak akan diproses, dan user akan mendapatkan pesan berupa : “Invalid operator!”
Pernyataan switch Pernyataan switch merupakan pernyataan yang dirancang khusus untuk menangani pengambilan keputusan yang melibatkan sejumlah alternatif, misalnya untuk menggantikan pernyataan if bertingkat.
Bentuk umum pernyataan switch adalah :
dengan ekspresi dapat berupa ekspresi bertipe integer atau bertipe karakter. Demikian juga konstanta-1 , konstanta-2, …, konstanta-n dapat berupa konstanta integer atau karakter. Setiap pernyataan-i (pernyataan-1, … , pernyataan-n) dapat berupa pernyataan tunggal ataupun pernyataan jamak. Dalam hal ini urutan penulisan pernyataan case tidak berpengaruh. Proses penyeleksian berlangsung sebagai berikut: pengujian pada switch akan dimulai dari konstanta-1 . Kalau nilai konstanta-1 cocok dengan ekspresi maka pernyataan-1 dijalankan. Kata kunci break harus disertakan di bagian akhir setiap pernyataan case, yang akan mengarahkan eksekusi ke akhir switch. Kalau ternyata pernyataan-1 tidak sama dengan nilai ekspresi, pengujian dilanjutkan pada konstanta-2, dan berikutnya serupa dengan pengujian pada konstanta-1. Jika sampai pada pengujian case yang terakhir ternyata tidak ada kecocokan, maka pernyataan yang mengikuti kata kunci default yang akan dieksekusi. Kata kunci default ini bersifat opsional. Tanda kurung kurawal tutup (}) menandakan akhir dari proses penyeleksian kondisi case.
3.3 PERCOBAAN 1. Dengan menggunakan pernyataan if-else bertingkat, buatlah program untuk memilih penghitungan luas segitiga, persegi panjang atau bujur sangkar.
2. Dengan menggunakan pernyataan switch-case, buatlah program untuk mengkonversikan nilai huruf ke nilai angka. Huruf A memiliki nilai angka 4, huruf B memiliki nilai angka 3, huruf C memiliki nilai angka 2, huruf D memiliki nilai angka 1, sedangkan huruf E memiliki nilai angka 0.
3. Dengan menggunakan nested if , buatlah program untuk mencari nilai terkecil dari 3 angka yang diinputkan. Adapun potongan programnya adalah:
4. Kerjakan soal no 2 dengan menggunakan pernyataan if else.
3.4 LISTING PROGRAM 1.1 #include #include #include main() { int pilih; float panjang, lebar, luas_persegi; float alas, tinggi, luas_segitiga; menu: printf("Tampilan:\nMasukan pilihan anda [1/2]:");scanf("%d",&pilih); switch(pilih) { case 1: segitiga: system ("cls"); printf("menghitung luas segitiga\n"); printf("masukan alas:"); scanf("%f",&alas); printf("masukan tinggi:"); scanf("%f",&tinggi); putchar (7); luas_segitiga=alas*tinggi/2; printf("jadi luasnya adalah:=%2.2f cm2\n\n",luas_segitiga); getch(); break; case 2: persegi: system("cls"); printf("menghitung luas persegi panjang\n");
printf("masukan panjang:"); scanf("%f", &panjang); printf("masukan lebar:"); scanf("%f",&lebar); luas_persegi=panjang*lebar; printf("jadi luasnya adalah:%2.2f cm2\n",luas_persegi); break; } }
1.2 #include int main() { char huruf; printf("masukan nilai huruf="); scanf("%c",&huruf); if (huruf=='A') printf("nilai angka 4\n"); else if (huruf=='B') printf("nilai angka 3\n"); else if (huruf=='C') printf("nilai angka 2\n"); else if (huruf=='D') printf("nilai angka 1\n"); else if (huruf=='E')
printf("nilai angka 0\n"); else printf("dibaca ya perintahnya\n"); return 0; }
1.3 #include main() { int a, b, c, hasil; printf("Masukan 3 angka:\n"); scanf("%d %d %d", &a, &b, &c); if(a
1.4 #include int main() { char huruf; printf("masukan nilai huruf="); scanf("%c", &huruf); switch (huruf) { case 'A':printf("nilai 4\n");break; case 'B':printf("nilai 3\n");break; case 'C':printf("nilai 2\n");break; case 'D':printf("nilai 1\n");break; case 'E':printf("nilai 0\n");break; } }
3.5 KESIMPULAN
PRAKTIKUM 4 PENGULANGAN PROSES 4.1 TUJUAN 1. Menjelaskan proses pengulangan menggunakan pernyataan for 2. Menjelaskan proses pengulangan menggunakan pernyataan while 3. Menjelaskan proses pengulangan menggunakan pernyataan do-while
4.2 TEORI DASAR Pernyataan for Mengulang suatu proses merupakan tindakan yang banyak dijumpai dalam pemrograman. Pada semua bahasa pemrograman, pengulangan proses ditangani dengan suatu mekanisme yang disebut loop. Dengan menggunakan loop, suatu proses yang berulang misalnya menampilkan tulisan yang sama seratus kali pada layar dapat diimpelementasikan dengan kode program yang pendek. Pernyataan pertama yang digunakan untuk keperluan pengulangan proses a dalah pernyataan for. Bentuk pernyataan ini : Pernyataan-pernyataan tersebut memerlukan suatu kondisi, sebagai basis dalam pengambilan keputusan. Kondisi umum yang dipakai berupa keadaan benar dan salah.
for (ungkapan1; ungkapan2; ungkapan3) pernyataan;
Kegunaan dari masing-masing ungkapan pada pernyataan for. Ungkapan1 : digunakan untuk memberikan inisialisasi terhadap variable pengendali loop. Ungkapan2 : dipakai sebagai kondisi untuk keluar dari loop. Ungkapan3 : dipakai sebagai pengatur kenaikan nilai variabel pengendali loop. Ketiga ungkapan dalam for tersebut harus dipisahkan dengan tanda titik koma (;). Dalam hal ini pernyatan bisa berupa pernyataan tunggal maupun jamak. Jika pernyataannya berbentuk jamak, maka pernyataan-pernyataan tersebut harus diletakkan di antara kurung kurawal buka ({) dan kurung kurawal tutup (}), sehingga formatnya menjadi :
for (ungkapan1; ungkapan2; ungkapan3 { pernyataan; pernyataan; . . . }
Contoh penggunaan for, misalnya untuk menampilkan deretan angka sebagai berikut : 20
30 40 50 . . . 100 Untuk keperluan ini, pernyataan for yang digunakan berupa : for (bilangan = 20; bilangan <= 100; bilangan += 10) printf("%d\n", bilangan); Kalau digambarkan dalam bentuk diagram alir, akan terlihat sbb
/* File program : for1.c Contoh pemakaian for untuk membentuk deret naik */ #include main() { int bilangan; for(bilangan = 20; bilangan <= 100; bilangan += 10) printf("%d\n",bilangan); } Contoh eksekusi : 20 30 40
50 60 70 80 90 100 Pada program di atas, kenaikan terhadap variabel pengendali loop sebesar 10 (positif), yang dinyatakan dengan ungkapan bilangan += 10 yang sama artinya dengan bilangan = bilangan + 10 Pada contoh yang melibatkan pernyataan for di atas, kenaikan variabel pengendali loop berupa nilai positif. Sebenarnya kenaikan terhadap variabel pengendali loop bisa diatur bernilai negatif. Cara ini dapat digunakan untuk memperoleh deret sebagai berikut : 60 50 40 30 20 10 Untuk itu selengkapnya program yang dibutuhkan adalah sebagai berikut : /* File program : for2.c Contoh pemakaian for untuk membentuk deret turun */ #include main() { int bilangan; for (bilangan = 60; bilangan >= 10; bilangan -= 10) printf("%d\n", bilangan); } Contoh eksekusi : 60 50 40 30 20 10 Kadang-kadang dijumpai adanya pernyataan for yang tidak men gandung bagian ungkapan yang lengkap (beberapa ungkapan dikosongkan). Dengan cara ini, pernyataan:
Tampak bahwa ungkapan yang biasa dipakai untuk inisialisasi variabel pengendali loop tak ada. Sebagai gantinya pengendalian loop diatur sebelum pernyataan for, berupa bilangan = 20; Pengosongan ini juga dilakukan pada ungkapan yang biasa dipakai untuk menaikkan nilai variabel pengendali loop. Sebagai gantinya, di dalam tubuh loop diberikan pernyataan untuk menaikkan nilai variabel pengendali loop, yaitu berupa bilangan += 10; Ungkapan yang tidak dihilangkan berupa bilangan <=100. Ungkapan ini tetap disertakan karena dipakai sebagai kondisi untuk keluar dari loop. Sesungguhnya ungkapan yang dipakai sebagai kondisi keluar dari loop juga bisa dihilangkan, sehingga bentuknya menjadi: for (;;) pernyataan Suatu pertanyaan mungkin timbul “Lalu bagaimana caranya kalau ingin k eluar dari loop pada bentuk di atas?”. Caranya adalah dengan menggunakan pernyataan yang dirancang khusus untuk keluar dari loop. Mengenai hal ini akan dibahas pada sub bab yang lain. Pernyataan while Pada pernyataan while, pengecekan terhadap loop dilakukan di bagian awal (sebelum tubuh loop). Lebih jelasnya, bentuk pernyataan while adalah sebagai berikut :
while (kondisi) pernyataan; dengan pernyataan dapat berupa pernyataan tunggal, pernyataan majemuk ataupun pernyataan kosong. Proses pengulangan terhadap pernyataan dijelaskan pada gambar berikut :
Dengan melihat gambar 5.2, tampak bahwa ada kemungkinan pernyataan yang merupakan tubuh loop tidak dijalankan sama sekali, yaitu kalau hasil pengujian kondisi while yang pertama kali ternyata bernilai salah. Contoh pemakaian while misalnya untuk mengatur agar tombol yang ditekan oleh pemakai program berupa salah satu diantara 'Y','y', 'T' atau 't'. Impelementasinya :
Contoh eksekusi : Pilihlah Y atau T Pilihan anda adalah Y Inisialisasi terhadap variabel sudah_benar yang akan dijalankan pada kondisi while dengan memberi nilai awal bernilai false (sudah_benar = 0) dimaksudkan agar tubuh loop dijalankan minimal sekali. Pernyataan do-while Bentuk pernyataan do-while
do pernyataan; while (kondisi) Pada pernyataan do-while, tubuh loop berupa pernyataan,dengan pernyataan bisa berupa pernyataan tunggal, pernyataan majemuk ataupun pernyataan kosong. Pada pernyataan do, mula-mula pernyataan dijalankan. Selanjutnya, kondisi diuji. Seandainya kondisi bernilai benar, maka pernyataan dijalankan lagi, kemudian kondisi diperiksa kembali, dan seterusnya. Kalau kondisi bernilai salah pada saat dites, maka
pernyataan tidak dijalankan lagi. Untuk lebih jelasnya dapat dilihat pada Gambar 4.3. Berdasarkan Gambar 4.3 terlihat bahwa tubuh loop minimal akan dijalankan sekali.
Program berikut memberikan contoh pemakaian do-while untuk mengatur penampilan tulisan "BAHASA C" sebanyak sepuluh kali. Contoh: i = 0; do { puts("BAHASA C"); i++; } while(i<10); Pada program di atas, variabel pencacah dipakai untuk menghitung jumlah tulisan yang sudah ditampilkan pada layar. Selama nilai pencacah kurang dari 10, maka perintah put("BAHASA C") akan dilaksanakan kembali Penanganan pembacaan tombol pada contoh program pilihan.c yang memakai while di atas, kalau diimplementasikan dengan memakai do-while adalah sebagai berikut: Contoh eksekusi : Pilihlah Y atau T Pilihan anda adalah T Mula-mula tombol dibaca dengan menggunakan getchar () dan kemudian diberikan ke variabel pilihan. Sesudah itu, variabel sudah_benar akan diisi dengan nilai benar (1) atau salah (0) tergantung dari nilai pilihan. Kalau pilihan berisi salah satu diantara ‘Y’,‘y’, ‘T’ atau ‘t’, maka sudah berisi salah satu diantara ‘Y’, ‘y’, ‘T’ atau ‘t’, maka sudah_benar akan berisi benar. Nilai pada vaiabel sudah_benar ini selanjutnya dijadikan sebagai kondisi do-while. Pengulangan terhadap pembacaan tombol akan dilakukan kembali selama sudah_benar benilai salah.
4.3 PERCOBAAN 1) Dengan menggunakan pernyataan for, buatlah program untuk menjumlahkan integer mulai dari 1 sampai dengan harga batas yang dibaca dari keyboard. Penjumlahan dapat dilakukan dengan menggunakan sebuah tempat penampungan hasil penjumlahan, dan penjumlahan dilakukan satu per satu terhadap angka mulai 1 sampai dengan angka yang dibaca dengan hasil sementara yang telah disimpan. Jika angka terakhir telah dijumlahkan, maka penampungan hasil sementara menjadi hasil akhir.
Tampilan: integer positif :10 Jumlah 1 sampai 10=55 2) Gunakan loop while untuk membuat program yang dapat mencari total angka yang dimasukkan dengan tampilan sebagai berikut : bilangan ke-1 : 5 memasukkan data lagi [y/t] ? y bilangan ke-2 : 3 Mau memasukkan data lagi [y/t] ? t Total bilangan = 8
3) Buatlah program yang menentukan sebuah integer dengan acak, dan membaca sebuah integer berulang kali sampai integer yang dibaca sama dengan integer yang ditentukan secara acak.
Tampilan: misalkan angka hasil pengacakan adalah) Angka tebakan:34 Tebakan terlalu kecil Angka Tebakan:55 Tebakan Terlalu besar Angka Tebakan:50 Tebakan benar
4.4 LISTING PROGRAM 1.1 #include long int deret(int x); main() { int N; long int hasil; printf ("tampilan:\n masukan integer positif:"); scanf("%d",&N); hasil=deret (N); printf("\n jumlah = %d", hasil); } long int deret(int x) { int i; long int z=0; printf("Nilai i:"); for (i=1; i<=x; i=i+1) { z+=i; printf("\n %d",i); } return (z); }
1.2 #include main() { char jawab='y'; int a=0, hasil=0, n=0; while (jawab=='y' || jawab=='y') { n=n+1; printf("masukan bilangan ke-%d : ",n);
scanf("%d", &a); printf("mau masukin lagi [y/t]?"); getchar(); jawab= getchar(); hasil += a; } printf("total bilangan=%d\n", hasil); }
1.3 #include #include #define max_angka (100+1) int main() { char mulai; int tebakan, angka_user, langkah; time_t t; srand((unsigned)time(&t)); do { angka_user=0; langkah=0; tebakan=rand() %max_angka; if (tebakan==0) tebakan=1; while (angka_user!=tebakan) {langkah++; printf("masukan angka tebakan anda:"); scanf("%d", &angka_user); getchar(); if (angka_user > tebakan) { printf ("tebakan terlalu besar\n"); } else if (angka_user < tebakan){ printf("tebakan terlalu kecil\n"); } else { printf("mantap! anda menebak dalam %d kali\n\n\n", langkah); langkah); } } getchar(); }while (mulai=='y'); return 0; }
4.5 KESIMPULAN
PRAKTIKUM 5 FUNGSI DASAR 5.1 TUJUAN 1. 2. 3. 4.
Memahami fungsi dasar bahaca C Membuat Fungsi Memahami parameter dalam fungsi Memahami cara melewatkan parameter ke dalam fungsi
5.2 TEORI DASAR Pengertian Fungsi adalah suatu bagian dari program yang dirancang untuk melaksanakan tugas tertentu dan letaknya dipisahkan dari program yang menggunakannya. Elemen utama dari program bahasa C berupa fungsi-fungsi, dalam hal ini program dari bahasa C dibentuk dari kumpulan fungsi pustaka (standar) dan fungsi yang dibuat sendiri oleh pemrogram. Fungsi banyak digunakan pada program C dengan tujuan : a) Program menjadi terstruktur, sehingga mudah dipahami dan mudah dikembangkan. Dengan memisahkan langkah-langkah detail ke satu atau lebih fungsi-fungsi, maka fungsi utama (main()) menjadi lebih pendek, jelas dan mudah dimengerti. b) Dapat mengurangi pengulangan (duplikasi) kode. Langkah-langkah program yang sama dan dipakai berulang-ulang di program dapat dituliskan sekali saja secara terpisah dalam bentuk fungsi-fungsi. Selanjutnya bagian program yang membutuhkan langkah-langkah ini tidak perlu selalu menuliskannya, tetapi cukup memanggil fungsifungsi tersebut. Fungsi Dasar Fungsi standar C yang mengemban tugas khusus contohnya adalah ; printf() , yaitu untuk menampilkan informasi atau data ke layar. scanf() , yaitu untuk membaca kode tombol yang diinputkan.
Pada umumnya fungsi memerlukan nilai masukan atau parameter yang disebut sebagai argumen. Nilai masukan ini akan diolah oleh fungsi. Hasil akhir fungsi berupa sebuah nilai (disebut sebagai return value atau nilai keluaran fungsi). Oleh karena itu fungsi sering digambarkan sebagai "kotak gelap" seperti ditunjukkan pada gambar di bawah ini.
Penggambaran sebagai kotak gelap di antaranya menjelaskan bahwa bagian dalam fungsi bersifat pribadi bagi fungsi. Tak ada suatu pernyataan di luar fungsi yang bisa mengakses bagian dalam fungsi, selain melalui parameter (atau variabel eksternal
yang akan dibahas belakangan). Misalnya melakukan goto dari pernyataan di luar fungsi ke pernyataan dalam fungsi adalah tidak diperkenankan. Bentuk umum dari definisi sebuah fungsi adalah sebagai berikut :
Keterangan : tipe-keluaran-fungsi, dapat berupa salah satu tipe data C, misalnya char atau int . Kalau penentu tipe tidak disebutkan maka dianggap bertipe int (secara default). tubuh fungsi berisi deklarasi variabel (kalau ada) dan statemen-statemen yang akan melakukan tugas yang akan diberikan kepada fungsi yang bersangkutan. Tubuh fungsi ini ditulis di dalam tanda kurung kurawal buka dan kurung kurawal t utup.
Sebuah fungsi yang sederhana bisa saja tidak mengandung parameter sama sekali dan tentu saja untuk keadaan ini deklarasi parameter juga tidak ada. Contoh : int inisialisasi() { return(0); } Pada fungsi di atas : tipe keluaran fungsi tidak disebutkan, berarti keluaran fungsi ber tipe int. inisialisasi adalah nama fungsi Tanda () sesudah nama fungsi menyatakan bahwa fungsi tak memiliki parameter. Tanda { dan } adalah awal dan akhir fungsi return(0) merupakan sebuah pernyataan dalam tubuh fungsi.
Memberikan Nilai Keluaran Fungsi Suatu fungsi dibuat untuk maksud menyelesaikan tugas tertentu. Suatu fungsi dapat hanya melakukan suatu tugas saja tanpa memberikan suatu hasil keluaran atau melakukan suatu tugas dan kemudian memberikan hasil keluaran. Fungsi yang hanya melakukan suatu tugas saja tanpa memberikan hasil keluaran misalnya adalah fungsi untuk menampilkan hasil di layar.
Dalam tubuh fungsi, pernyataan yang digunakan untuk memberikan nilai keluaran fungsi berupa return. Sebagai contoh, pada fungsi inisialisasi () di atas terdapat pernyataan return(0); merupakan pernyataan untuk memberikan nilai keluaran fungsi berupa nol. Selengkapnya perhatikan program di bawah ini /* File program : inisial.c Contoh pembuatan fungsi */ int inisialisasi(); #include main() { int x, y;
x = inisialisasi(); printf("x = %d\n", x); y = inisialisasi(); printf("y = %d\n", y); } int inisialisasi() { return(0); } Contoh eksekusi : x = 0 y = 0 Program di atas sekaligus menjelaskan bahwa suatu fungsi cukup didefinisikan satu kali tetapi bisa digunakan beberapa kali. Pada keadaan semacam ini seandainya tubuh fungsi mengandung banyak pernyataan, maka pemakaian fungsi dapat menghindari duplikasi kode dan tentu saja menghemat penulisan program maupun kode dalam memori.
Misalnya pada saat pernyataan x = inisialisasi(); dijalankan, mula-mula eksekusi akan diarahkan ke fungsi inisialisasi(), selanjutnya suatu nilai keluaran (hasil fungsi) akhir fungsi diberikan ke x. Proses yang serupa, dilakukan untuk pernyataan y = inisialisasi(); Bagi suatu fungsi, jika suatu pernyataan return dieksekusi, maka eksekusi t erhadap fungsi akan berakhir dan nilai pada parameter return akan menjadi kel uaran fungsi. Untuk fungsi yang tidak memiliki pernyataan return, tanda } pada bagian akhir fungsi akan menyatakan akhir eksekusi fungsi. Di bawah ini diberikan contoh sebuah fungsi yang mengandung dua buah pernyataan return. Fungsi digunakan untuk memperoleh nilai minimum di antara 2 buah nilai yang menjadi parametern ya. int minimum(int x, int y) { if (x < y) return(x); else return(y); }
Pada fungsi di atas terdapat dua buah parameter berupa x dan y. Oleh karena itu fungsi juga mengandung bagian untuk mendeklarasikan parameter, yang menyatakan x dan y bertipe int . Adapun penentuan nilai keluaran fungsi dilakukan pada tubuh fungsi, berupa pernyataan if (x < y) return(x); else return(y); yang menyatakan : jika x < y maka nilai keluaran fungsi adalah sebesar nilai x. untuk keadaan lainnya (x >= y) maka keluaran fungsi adalah sebesar y.
Selengkapnya perhatikan program di bawah ini.
/* File program : minimum1.c */ #include int minimum (int, int); main() { int a, b, kecil; printf("Masukkan nilai a : "); scanf("%d", &a); printf("Masukkan nilai b : "); scanf("%d", &b); kecil = minimum(a, b); printf("\nBilangan terkecil antara %d dan %d adalah %d\n\n", a, b, kecil); } minimum(int x, int y) { if (x < y) return(x); else return(y); } Contoh eksekusi : Masukkan nilai a = 4 Masukkan nilai b = 2 Bilangan terkecil antara 4 dan 2 adalah 2 Fungsi Dengan Keluaran Bukan Integer Untuk fungsi yang mempunyai keluaran bertipe bukan integer, maka fungsi haruslah didefiniskan dengan diawali tipe keluaran fungsinya (ditulis di depan nama fungsi). Sebagai contoh untuk menghasilkan nilai terkecil di antara dua buah nilai real, maka definisinya berupa :
float minimum(float x, float y) { if (x < y) return(x); else return(y); }
Perhatikan, di depan nama minimum diberikan tipe keluaran fungsi berupa float . Seluruh parameter sendiri juga didefinisikan dengan tipe float . Selengkapnya adalah sebagai berikut : /* File program : minimum2.c */ #include float minimum (float, float); main() { float a, b, kecil; printf("Masukkan nilai a : "); scanf("%f", &a); printf("Masukkan nilai b : "); scanf("%f", &b); kecil = minimum(a, b); printf("\nBilangan terkecil antara %g dan %g adalah %g\n\n", a, b, kecil); } float minimum(float x, float y) { if (x < y) return(x); else return(y); } Contoh eksekusi :
Masukkan nilai a = 5.5 Masukkan nilai b = 6.23 Bilangan terkecil antara 5 dan 6.23 adalah 5.5 Khusus untuk fungsi yang dirancang tanpa memberikan nilai keluaran (melainkan hanya menjalankan suatu tugas khusus) biasa didefinisikan dengan diawali kata kunci void (di depan nama fungsi). Sebagai contoh perhatikan program di bawah ini.
Contoh Keluaran
Prototipe Fungsi Prototipe fungsi digunakan untuk menjelaskan kepada kompiler mengenai : tipe keluaran fungsi jumlah parameter tipe dari masing-masing parameter
Bagi kompiler, informasi dalam prototipe akan dipakai untuk memeriksa keabsahan (validitas) parameter dalam pemanggilan fungsi. Salah satu keuntungannya adalah, kompiler akan melakukan konversi seandainya antara tipe parameter dalam fungsi dan parameter saat pemanggilan fungsi tidak sama, atau akan menunjukan kesalahan bila jumlah parameter dalam definisi dan saat pemanggilan berbeda. Contoh prototipe fungsi;
5.3 PERCOBAAN 1) Dengan menggunakan pernyataan for, buatlah program untuk menjumlahkan integer mulai dari 1 sampai dengan harga batas yang dibaca dari keyboard. Penjumlahan dapat dilakukan dengan menggunakan sebuah tempat penampungan hasil penjumlahan, dan penjumlahan dilakukan satu per satu terhadap angka mulai 1 sampai dengan angka yang dibaca dengan hasil sementara yang telah disimpan. Jika angka terakhir telah dijumlahkan, maka penampungan hasil sementara menjadi hasil akhir.
Tampilan: Masukkan integer positif :10 Jumlah 1 sampai 10=55 2) Gunakan loop while untuk membuat program yang dapat mencari total angka yang dimasukkan dengan tampilan sebagai berikut :
Masukkan bilangan ke-1 : Mau memasukkan data lagi Masukkan bilangan ke-2 : Mau memasukkan data lagi Total bilangan = 8
5 [y/t] ? y 3 [y/t] ? t
3) Buatlah program yang menentukan sebuah integer dengan acak, dan membaca sebuah integer berulang kali sampai integer yang dibaca sama dengan integer yang ditentukan secara acak.
Tampilan: misalkan angka hasil pengacakan adalah) Angka tebakan:34 Tebakan terlalu kecil Angka Tebakan:55 Tebakan Terlalu besar Angka Tebakan:50 Tebakan benar
5.4 LISTING PROGRAM 1.1 #include long int deret(int x); main() { int N;
long int hasil; printf("Tampilan:\nMasukan Integer Positif:"); scanf("%d",&N); hasil=deret(N); printf("\nJumlah=%d",hasil); } long int deret(int x) { int i; long int z=0; printf("nilai i:"); for (i=1; i<=x; i=i+1) { z+=i; printf("\n %d",i); } return (z); }
1.2 #include main() { char jawab='y'; int a=0, hasil=0, n=0; while (jawab=='y'||jawab=='y') { n=n+1; printf("masukan bilangan ke-%d:",n); scanf("%d",&a); printf("mau masukan lagi[y/t]?"); getchar(); jawab= getchar(); hasil +=a; } printf("total bilangan = %d\n",hasil); }
1.3 #include #include #define max_angka (100+1) int main() { char mulai; int tebakan, angka_user, langkah; time_t t; srand((unsigned)time(&t)); do { angka_user=0; langkah=0; tebakan=rand() %max_angka; if (tebakan==0) tebakan=1; while (angka_user!=tebakan) {langkah++; printf("masukan angka tebakan anda:"); scanf("%d", &angka_user); getchar(); if (angka_user > tebakan) { printf ("tebakan terlalu besar\n"); } else if (angka_user < tebakan){ printf("tebakan terlalu kecil\n"); } else { printf("mantap! anda menebak dalam %d kali\n\n\n", langkah); } } getchar(); }while (mulai=='y'); return 0; }
5.5 KESIMPULAN
PRAKTIKUM 6 FUNGSI MATEMATIKA 6.1 TUJUAN 1. Menjelaskan fungsi matematika dalam bahasa C. 2. Menerapkan fungsi-fungsi matematika yang terdapat dalam C dalam menyelesaikan permasalahan.
6.2 TEORI DASAR Bahasa C menyediakan bawaan fungsi matematika yang terdapat dalam pustaka ( Library) : math.h. Agar fungsi matematika tersebut dapat digunakan dalam program maka fungsi matematika harus disertakan dalam program melalui pernyataan: #include Beberapa fungsi matematika yang terdapat dalam library math.h bahasa C yakni:
Berikut contoh penggunaan math.h bahasa c:
Penjelasan:
6.3 PERCOBAAN Buat program gerak jatu bebas untuk menghitung durasi benda di udara dan kecepatan sebelum menyentuh tanah untuk beberapa kali percobaan dengan ketinggian yo berbeda-beda.
6.4 LISTING PROGRAM #include
#include main() { float y0,v0,y,v,t,g=9.8; printf("masukan ketinggian awal:"); scanf("%f",&y0); printf("masukan kelajuan awal:"); scanf("%f",&v0); t=(v0+sqrt(v0+2*g*y0))/g; v=v0-g*t; printf("waktu yang diperlukan untuk menyentuh tanah:%.2fs\n",t); printf("kelajuan benda saat menyentuh tanah:%.2fm/s2\n",v); }
6.5 KESIMPULAN
PRAKTIKUM 7 POINTER 7.1 TUJUAN 1. Mengetahui konsep dari variabel pointer 2. Mengetahui penggunaan pointer array 3. Mengetahui penggunaan pointer string
7.2 TEORI DASAR Konsep Dasar Pointer Variabel pointer sering dikatakan sebagai variabel yang menunjuk ke obyek lain. Pada kenyataan yang sebenarnya, variabel pointer berisi alamat dari suatu ob yek lain (yaitu obyek yang dikatakan ditunjuk oleh pointer).
Sebagai contoh, px adalah variabel pointer dan x adalah variabel yang ditunjuk oleh px. Kalau x berada pada alamat memori (alamat awal) 1000, maka px akan berisi 1000. Sebagaimana diilustrasikan pada gambar berikut:
Mendeklarasikan Variabel Pointer Suatu variabel pointer dideklarasikan dengan bentuk sebagai berikut :
dengan tipe dapat berupa sembarang tipe yang sudah dibahas pada bab-bab sebelumnya, maupun bab-bab berikutnya. Adapun nama_variabel adalah nama dari variabel pointer.
Contoh pertama menyatakan bahwa px adalah variabel pointer yang menunjuk ke suatu data bertipe int, sedangkan contoh kedua masing pch1 dan pch2 adalah variabel pointer yang menunjuk ke data bertipe char
Mengatur Pointer agar Menunjuk ke Variabel Lain Agar suatu pointer menunjuk ke variabel lain, mula-mula pointer harus diisi dengan alamat dari variabel yang akan ditunjuk. Untuk menyatakan alamat dari suatu variabel, operator & (operator alamat, bersifat unary ) bisa dipergunakan, dengan menempatkannya di depan nama variabel.
Sebagai contoh, bila x dideklarasikan sebagai variabel bertipe int, maka &x berarti “alamat dari variabel x”. Adapun contoh pemberian alamat x ke suatu variabel pointer px (yang dideklarasikan sebagai pointer yang menunjuk ke data bertipe int) yaitu : px = &x Pernyataan di atas berarti bahwa px diberi nilai berupa alamat dari variabel x. Setelah pernyataan tersebut dieksekusi barulah dapat dikatakan bahwa px menunjuk ke variabel x. Mengakses Isi Suatu Variabel Melalui Pointer Jika suatu variabel sudah ditunjuk oleh pointer, variabel yang ditunjuk oleh pointer tersebut dapat diakses melalui variabel itu sendiri (pengaksesan langsung) ataupun melalui pointer (pengaksesan tak langsung).
Pengaksesan tak langsung dilakukan dengan menggunakan operator indirection (tak langsung) berupa simbol * (bersifat unary). Contoh penerapan operator * yaitu : *px yang menyatakan “isi atau nilai variabel/data yang ditunjuk oleh pointer px” . Sebagai contoh jika y bertipe int, maka sesudah dua pernyataan berikut px = &x; y = *px; y akan berisi nilai yang sama dengan nilai x. Mengakses dan Mengubah isi Suatu Variabel Pointer Contoh berikut memberikan gambaran tentang pengubahan isi suatu variable secara tak langsung (yaitu melalui pointer). Mula-mula pd dideklarasikan sebagai pointer
yang menunjuk ke suatu data bertipe float dan d sebagai variabel bertipe float. Selanjutnya d = 54.5; digunakan untuk mengisikan nilai 54,5 secara langsung ke variabel d. Adapun pd = &d; digunakan untuk memberikan alamat dari d ke pd. Dengan demikian pd menunjuk ke variabel d. Sedangkan pernyataan berikutnya *pd = *pd + 10; (atau: *pd += 10; ) merupakan instruksi untuk mengubah nilai variabel d secara tak langsung. Perintah di atas berarti “jumlahkan yang ditunjuk pd dengan 10 kemudian berikan ke yang ditunjuk oleh pd”, atau identik dengan pernyataan d = d + 10; Akan tetapi, seandainya tidak ada instruksi pd = &d; maka pernyataan *pd = *pd + 10; tidaklah sama dengan d = d + 10; Pointer dan Array Hubungan antara pointer dan array pada C sangatlah erat. Sebab sesungguhnya array secara internal akan diterjemahkan dalam bentuk pointer. Pembahasan berikut akan memberikan gambaran hubungan antara pointer dan array . Misalnya dideklarasikan di dalam suatu fungsi.
int tgl_lahir[3] = { 01, 09, 64 }; dan
int *ptgl; Kemudian diberikan instruksi ptgl = &tgl_lahir[0]; maka ptgl akan berisi alamat dari elemen array tgl_lahir yang berindeks nol. Instruksi di atas bisa juga ditulis menjadi ptgl = tgl_lahir; sebab nama array tanpa tanda kurung menyatakan alamat awal dari array. Sesudah penugasan seperti di atas, *ptgl dengan sendirinya menyatakan elemen pertama (berindeks sama dengan nol) dari array tgl_lahir.
7.3 PERCOBAAN 1) Buatlah program untuk mengetahui alamat suatu variabel // ---------------------------------------------------// Program untuk menampilkan alamat suatu variabel // ---------------------------------------------------#include
int main() { int alif = 5; float ba = 7.5; double ta = 17.777; printf("Isi variabel:\n"); printf("alif = %d\n", alif); printf("ba = %f\n", ba); printf("ta = %lf\n", ta); printf("\n"); printf("Alamat variabel:\n"); printf("alif = %p\n", &alif); printf("ba = %p\n", &ba); printf("ta = %p\n", &ta); return 0; } 2) Buatlah program untuk mengakses elemen Array via ponter // -------------------------------------------// Program Pengaksesan elemen array via pointer // ---------------------------------------------------#include int main() { int tgl_lahir[] = { 24, 6, 1965 }; int *ptgl; ptgl = tgl_lahir; // ptgl menunjuk ke array; // Menampilkan isi array via pointer int i; for (i = 0; i < sizeof(tgl_lahir) / sizeof(int); i++) printf("%d\n", *(ptgl + i)); return 0; }
7.4 LISTING PROGRAM 1.1 #include int main() { int alif=5; float ba=7.5; double ta=17.777; printf("isi variable:\n"); printf("alif=%d\n",alif); printf("ba=%f\n",ba); printf("ta=%1f\n",ta); printf("\n"); printf("alamat variable:\n"); printf("alif=%p\n",&alif); printf("ba=%p\n",&ba);
printf("ta=%p\n",&ta); return 0; }
1.2 #include int main() { int tgl_lahir[]={24,6,1965}; int *ptgl; ptgl=tgl_lahir;
int i; for (i=0;i
7.5 KESIMPULAN
PRAKTIKUM 8 ARRAY 8.1 TUJUAN 1. Menjelaskan tentang array berdimensi satu, dua dan berdimensi banyak 2. Menjelaskan tentang inisialisasi array tak berukuran 3. Menjelaskan array sebagai parameter fungsi
8.2 TEORI DASAR Array sering disebut (diterjemahkan) sebagai larik. Array adalah kumpulan dari nilainilai data bertipe sama dalam urutan tertentu yang menggunakan sebuah nama yang sama. Nilai-nilai data di suatu array disebut dengan elemen-elemen array. Letak urutan dari elemen-elemen array ditunjukkan oleh suatu subscript atau indeks. Array bisa berupa array berdimensi satu, dua, tiga atau lebih. Array berdimensi satu (onedimensional array) mewakili bentuk suatu vektor. Array berdimensi dua (two dimensional array) mewakili bentuk dari suatu matriks atau table. Array berdimensi tiga (three-dimensional array) mewakili bentuk suatu ruang. A. Arr ay Berdimensi Satu Suatu array berdimensi satu dideklarasikan dalam bentuk umum berupa : tipe_data nama_var[ukuran]; dengan : tipe_data : untuk menyatakan tipe dari elemen array, misalnya int, char, float . nama_var : nama variabel array ƒ ukuran : untuk menyatakan jumlah maksimal elemen array.
Contoh pendeklarasian array : float nilai_tes[5]; menyatakan bahwa array nilai_tes mengandung 5 elemen bertipe float. Mengakses Elemen Array Berdimensi Satu Pada C, data array akan disimpan dalam memori yang berurutan. Elemen pertama mempunyai indeks bernilai 0. Jika variabel nilai_tes dideklarasikan sebagai array dengan 5 elemen, maka elemen pertama memiliki indeks sama dengan 0, dan elemen terakhir memiliki indeks 4.
Bentuk umum pengaksesan array adalah sbb : nama_var[indeks] sehingga, untuk array nilai_tes, maka : nilai_tes[0] elemen pertama dari nilai_tes nilai_tes[4] elemen ke-5 dari nilai_tes Contoh : nilai_tes[0] = 70; scanf(“%f”, &nilai_tes[2]);
Contoh pertama merupakan pemberian nilai 70 ke nilai_tes[0]. Sedangkan contoh 2 merupakan perintah untuk membaca data bilangan dari keyboard dan diberikan ke nilai_tes[2]. Pada contoh 2 ini &nilai_tes[2] berarti “alamat dari nilai_tes[2]”. Perlu diingat bahwa scanf() memerlukan argumen berupa alamat dari variabel yang digunakan untuk menyimpan nilai masukan. Inisialisasi Array Berdimensi Satu Sebuah array dapat diinisialisasi sekaligus pada saat dideklarasikan. Untuk mendeklarasikan array, nilai-nilai yang diinisialisasikan dituliskan di a ntara kurung kurawal ({}) yang dipisahkan dengan koma.
int jum_hari[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; Beberapa Variasi dalam Mendeklarasikan Array Ada beberapa variasi cara mendeklarasikan sebua h array (dalam hal ini yang berdimensi satu), diantaranya adalah sebagai berikut : int numbers[10]; int numbers[10] = {34, 27, 16}; int numbers[] = {2, -3, 45, 79, -14, 5, 9, 28, -1, 0}; char text[] = "Welcome to New Zealand."; float radix[12] = {134.362, 1913.248}; double radians[1000];
Array Berdimensi Dua Array berdimensi satu dapat disimpan pada sebuah array berdimensi dua. Pendeklarasian array berdimensi dua adalah sebagai berikut :
int data_lulus[4][3]; Nilai 4 untuk menyatakan banyaknya baris dan 3 menyatakan banyaknya kolom. Gambar berikut memberikan ilustrasi untuk memudahkan pemahaman tentang array berdimensi dua.
Sama halnya pada array berdimensi satu, data array akan ditempatkan pada memori yang berurutan
Mengakses Elemen Array Berdimensi Dua Array seperti data_lulus dapat diakses dalam bentuk data_lulus [indeks pertama, indeks kedua] :
1) data_lulus[0][1] = 540; merupakan instruksi untuk memberikan nilai 540 ke array data_lulus untuk indeks pertama = 0 dan indeks kedua bernilai 1. 2) printf(“%d”,data_lulus[2][0]) ; merupakan perintah untuk menampilkan elemen yang memiliki indeks pertama = 2 dan indeks kedua = 0. Perhatikan contoh potongan program di bawah ini.
Array Berdimensi Banyak C memungkinkan untuk membuat array yang dimensinya lebih dari dua. Bentuk umum pendeklarasian array berdimensi banyak : tipe nama_var[ukuran 1][ukuran2}…[ukuranN]; sebagai contoh :
int data_huruf[2][8][8]; merupakan pendeklarasian array data_huruf sebagai array berdimensi tiga. Sama halnya dengan array berdimensi satu atau dua, array berdimensi banyak juga bisa diinisialisasi. Contoh inisialisasi array berdimensi tiga :
Atau bisa juga ditulis menjadi:
ARRAY SEBAGAI PARAMETER Array juga dapat dilewatkan sebagai parameter fungsi. Sebagai contoh ditujukan pada program sorting.c. Program digunakan untuk memasukkan sejumlah data, kemudian data tersebut diurutkan naik (ascending ) dan dicetak ke layar.
Untuk melakukan sorting (proses pengurutan data), cara yang dipakai yaitu metode buble sort (suatu metode pengurutan yang paling sederhana, dan memiliki kecepatan pengurutan yang sangat lambat). Algoritma pada metode pengurutan ini adalah sebagai berikut : 1. Atur i bernilai 0 2. Bandingkan x[i] dengan x[j], dg j berjalan dari i + 1 sampai dengan n-1. 3. Pada setiap pembandingan, jika x[i] > x[j], maka isi x[i] dan x[j] ditukarkan 4. Bila i < (n – 1), ulangi mulai langkah 2.
Catatan i = indeks array x = nama array untuk menyimpan data n = jumlah data
Algoritma diatas b erlaku untuk pengurutan menaik (ascending ). Untuk pengurutan menurun (descending ), penukaran dilakukan jika x[i] < x[j]. Penjelasa n proses pengurutan terhadap 5 buah data ditunjukkan pada gambar di bawah. Data semula (sebelum pengurutan) adalah 50,5 30,3 20,2 25,2 31,3 Setelah pengurutan menaik (secara ascending ), hasil yang diharapkan berupa 20,2 25,2 30,3 31,3 50,5
8.3 PERCOBAAN 1. Buatlah program yang membaca sebuah array karakter,’a’…’z’. Kemudian menghitung frekuensi kemunculan tiap karakter. Tampilan: Masukkan jumlah karakter yang akan dihitung: 5 Masukkan karakter ke-1:a Masukkan karakter ke-2:b Masukkan karakter ke-3:c Masukkan karakter ke-3:a Masukkan karakter ke-3:a Frekuensi a=3 Frekuensi b=1 Frekuensi c=1
2. Buatlah program menggunakan inisialisasi array berdimensi dua sebagai berikut: // ------------------------------------------// Program inisialisasi array berdimensi dua // ------------------------------------------#include int main() { int huruf_A[8][8] = {
{ 0, 1, 1, 1, 1, 1, 0, 0 { 0, 1, 0, 0, 0, 1, 0, 0 { 0, 1, 0, 0, 0, 1, 0, 0 { 1, 1, 1, 1, 1, 1, 1, 0 { 1, 1, 0, 0, 0, 0, 1, 0 { 1, 1, 0, 0, 0, 0, 1, 0 { 1, 1, 0, 0, 0, 0, 1, 0 { 0, 0, 0, 0, 0, 0, 0, 0 }; int i, j; for (i = 0; i < 8; i++) { for (j = 0; j < 8; j++) if (huruf_A[i][j] == 1) putchar('*'); else putchar(' '); printf("\n"); } return 0; }
}, }, }, }, }, }, }, }
Kemudian lakukan untuk beberapa percobaan
8.4 LISTING PROGRAM 1.1 #include main() { char tmp,kar[225]; int htg[255]; int a, b, c=0, n, cek; printf("masukan jumlah karakter:"); scanf("%d",&n); for(a=1;a<=n;a++) { printf("masukan karakter ke-%d\t:",a); scanf("\n%c",&tmp); for(b=0;b<=c;b++) { cek=1; if(tmp==kar[b]) { cek=0; htg[b]++; break; } } if(cek==1) { kar[c]=tmp; htg[c]=1;
c++; } } printf("\n"); for(a=0;a
1.2 #include int main() { int huruf_A[8] [8]= { {0,1,1,1,1,1,0,0}, {0,1,0,0,0,1,0,0}, {0,1,0,0,0,1,0,0}, {1,1,1,1,1,1,1,0}, {1,1,0,0,0,0,1,0}, {1,1,0,0,0,0,1,0}, {1,1,0,0,0,0,1,0}, {0,0,0,0,0,0,0,0}, }; int i,j; for (i=0;i<8;i++) { for (j=0;j<8;j++) if (huruf_A [i] [j]==1) putchar('*'); else putchar(' '); printf("\n"); } return 0; }
8.5 KESIMPULAN
PRAKTIKUM 9 STRING 9.1 TUJUAN 1. 2. 3. 4.
Menjelaskan tentang konsep string Menjelaskan operasi I/O pada string Menjelaskan cara mengakses elemen string Menjelaskan berbagai fungsi mengenai string
9.2 TEORI DASAR Konstanta dan Variabel String String merupakan bentuk data yang biasa dipakai dalam bahasa pemrograman untuk keperluan menampung dan memanipulasi data teks, misalnya untuk menampung (menyimpan) suatu kalimat. Pada bahasa C, string bukanlah merupakan tipe data tersendiri, melainkan hanyalah kumpulan dari nilai-nilai karakter yang berurutan dalam bentuk array berdimensi satu. Konstanta String Suatu konstanta string ditulis dengan diawali dan diakhiri tanda petik ganda, misalnya: “ABCDE” Nilai string ini disimpan dalam memori secara berurutan dengan komposisi sebagai berikut:
Setiap karakter akan menempati memori sebesar 1 byte. Byte terakhir otomatis akan berisi karakter NULL (\0). Dengan mengetahui bahwa suatu string diakhiri nilai NULL, maka akhir dari nilai suatu string akan dapat dideteksi. Sebagai sebuah array karakter, karakter pertama dari nilai string mempunyai indeks ke-0, karakter kedua mempunyai indeks ke-1, dan seterusnya. Variabel String Variabel string adalah variabel yang dipakai utuk menyimpan nilai string. Misalnya : char name[15];
merupakan instruksi untuk mendeklarasikan variabel string dengan panjang maksimal 15 karakter (termasuk karakter NULL). Deklarasi tersebut sebenarnya tidak lain merupakan deklarasi array bertipe char . Inisialisasi String Suatu variabel string dapat diinisialisasi seperti halnya array yang lain. Namun tentu saja elemen terakhirnya haruslah berupa karakter NULL. Sebagai contoh : char name[] = {'R','A','N', 'I',’\0’};
yang menyatakan bahwa name adalah variabel string dengan nilai awal berupa string : “RANi” . Bentuk inisialisasi yang lebih singkat : char name[] = “RANI”; Pada bentuk ini, karakter NULL tidak perlu ditulis. Secara implisit akan disisipkan oleh kompiler. Perlu diperhatikan, bila name dideklarasikan sebagai string, penugasan (assignment ) suatu string ke variabel string seperti name = “RANI”; adalah tidak diperkenankan. Pengisian string ke variabel string akan dibahas pada sub bab berikutnya.
INPUT OUTPUT DATA STRING
Memasukkan Data String
Perhatikan : nama_array adalah variabel bertipe array of char yang akan digunakan untuk menyimpan string masukan. Di depan nama_array tidak perlu ada operator & (operator alamat), karena nama_array tanpa kurung siku sudah menyatakan alamat yang ditempati oleh elemen pertama dari array tsb. Kalau memakai scanf( ), data string masukan tidak boleh mengandung spasi. Menampilkan Isi Variabel String Untuk menampilkan isi variabel string, fungsi yang digunakan adalah puts() atau printf(). Bentuk umum pemakaiannya adalah sebagai berikut :
#include puts(var_string); atau printf("%s",var_string); Dalam hal ini var_string adalah sebuah variabel yang berupa sebuah array of char. Fungsi puts() akan menampilkan isi dari var_string dan secara otomatis menambahkan karakter '\n' di akhir string. Sedangkan fungsi printf() akan menampilkan isi variabel string tanpa memberikan tambahan '\n'. Sehingga, agar kedua pernyataan di atas memberikan keluaran yang sama, maka pada pernyataan printf() dirubah menjadi: printf("%s\n", var_string);
Fungsi-Fungsi Mengenai String Berikut ini akan dibahas beberapa fungsi pustaka yang umumnya disediakan oleh kompiler C untuk mengoperasikan suatu nilai string. Fungsi-fungsi pustaka untuk operasi string, prototype-prototype nya berada di file judul string.h. Beberapa di antara fungsi pustaka untuk operasi string akan dibahas di bawah ini.
Fungsi strcpy() untuk Menyalin Nilai String Bentuk pemakaian : #include strcpy(tujuan, asal) Fungsi ini dipakai untuk menyalin string asal ke variabel string tujuan te rmasuk karakter '\0'. Keluaran dari fungsi ini ( return value) adalah string tujuan. Dalam hal ini, variabel tujuan haruslah mempunyai ukuran yang dapat digunakan untuk menampung seluruh karakter dari string asal. Fungsi strlen() untuk Mengetahui Panjang Nilai String
Fungsi ini digunakan untuk memperoleh banyaknya karakter di dalam string yang menjadi argumennya ( var_string ). Keluaran dari fungsi ini adalah panjang dari var_string . Karakter NULL tidak ikut dihitung.
Menggabungkan dua buah nilai string tidak dapat dilakukan dengan operator ‘+’, karena operator ini bukan operator untuk operasi string. Penggabungan dua buah nilai string dapat dilakukan dengan fungsi pustaka strcat() dengan menambahkan string sumber ke bagian akhir dari string tujuan . Keluaran dari fungsi ini adalah string tujuan . Fungsi strcmp() untuk Membandingkan Dua Nilai String Membandingkan dua nilai string juga tidak dapat digunakan dengan operator hubungan, karena operator tersebut tidak untuk operasi string. Membandingkan dua buah nilai string dapat dilakukan dengan fungsi pustaka strcmp(). Contoh bentuk pemakaian fungsi :
#include strcmp(str1, str2);
9.3 PERCOBAAN 1) Ketikkan sebuah kalimat melalui keyboard kemudian didapatkan keluaran berupa laporan apakah kalimat tsb palindrom ataukah bukan. Misal : Kalimat : KASUR RUSAK Termasuk PALINDROM Kalimat : MAKAN MALAM Bukan PALINDROM Catatan : disebut palindrom adalah bila urutan kalimat dibalik akan menghasilkan kalimat yang sama 2) Buatlah program untuk mengurutkan nama seseorang. Contoh: Sebelum diurutkan : Nama ke-1: Suadi marwan Nama ke-2: Abdi Raharjo Nama ke-3: Shintiana Nama ke-4: Budi Sulistyo Sesudah diurutkan : Nama ke-1: Abdi Raharjo Nama ke-2: Budi Sulistyo Nama ke-3: Shintiana Nama ke-4: Suadi Marwan
9.4 LISTING PROGRAM 1.1 #include #include #include int main() { char a[100], b[100]; printf("Kalimat:"); gets(a); strcpy(b,a); strrev(b); if(strcmp(a,b)==0) printf("\nKata'%s'merupakan kata polindrom\n",&a); else printf("\nKata'%s'bukan merupakan kata polindrom\n",&a); getch(); }
1.2 #include #define N 20 char nama [N][20]; int i, j, k, l; main() { int jml; char jumlah[10]; printf("jumlah nama yang akan diurutkan="); gets(jumlah); jml=atoi(jumlah); for(i=0;inama[j][l])
{for(k=0; k<20; k++) {temp=nama[i-1][k]; nama[i-1][k]=nama[j][k]; nama [j][k]=temp; }break; }}}}}
9.5 KESIMPULAN
PRAKTIKUM 10 STRUKTUR 10.1 TUJUAN 1. 2. 3. 4.
Menjelaskan cara mendeklarasikan struktur Menjelaskan cara menginisialisasi struktur Menjelaskan cara mengakses elemen struktur Menjelaskan pembentukan dan cara mengakses array dari struktur (array of struct )
10.2 TEORI DASAR Dalam Struktur adalah pengelompokan variabel-variabel yang bernaung dalam satu nama yang sama. Berbeda dengan array yang berisi kumpulan variabel-variabel yang bertipe sama dalam satu nama, maka suatu struktur dapat terdiri atas variabel-variabel yang berbeda tipenya dalam satu nama struktur. Struktur biasa dipakai untuk mengelompokkan beberapa informasi yang berkaitan menjadi sebuah. Variabel-variabel yang membentuk suatu struktur, selanjutnya disebut sebagai e lemen dari struktur atau field. Dengan demikian dimungkinkan suatu struktur dapat berisi elemen-elemen data berbeda tipe seperti char, int, float, double, dan lain-lain. Contoh sebuah struktur adalah informasi data tanggal (date) yang berisi: day month, dan year
Mendefinisikan & Mendeklarasikan Struktur Suatu struktur didefinisikan dengan menggunakan kata kunci st ruct. Contoh pendefinisian sebuah tipe data struktur :
struct date { int month; int day; int year; }; struct date { int month, day, year; }; yang mendefinisikan sebuah tipe data struktur bernama date yang memiliki tiga buah elemen ( field ) berupa:
Dalam mendefinisikan sebuah struktur, elemen yang terkandung di dalamnya bisa juga berupa sebuah struktur, contoh : struct date { int month, day, year; }; struct person { char name[30]; struct date birthday; }; struct person student; //deklarasi var student Diagram struktur data dari variabel student dapat digambarkan sbb :
Elemen dari suatu variabel struktur dapat diakses dengan menyebutkan nama variabel struktur diikuti dengan operator titik (‘.’) dan nama dari elemen strukturnya. Cara penulisannya sebagai berikut variabel_struktur.nama_field Untuk memberikan data nama ke field name dari variabel student di at as, maka pernyataan yang diperlukan misalnya adalah : strcpy(student.name, "MUHAMMAD IHSAN"); Pada pernyataan di atas, student.name dapat dibaca sebagai " field name dari student".
Contoh berikut merupakan instruksi untuk mengisikan data pada field birthday : student.birthday.day = 10; Sedangkan untuk mendapatkan isi suatu field dari variabel struktur, contohnya : tgl = student.birthday.day; puts(student.name); Contoh pertama merupakan instruksi untuk memberikan isi dari field day ke variabel tgl. Sedangkan contoh kedua merupakan instruksi untuk menampilkan isi dari field name.
Menginisialisasi Struktur Sebuah struktur juga bisa diinisialisasi pada saat dideklarasikan. Hal ini serupa dengan inisialisasi array, yaitu elemen-elemennya dituliskan di dalam sepasang kurung kurawal (‘{ }‘) dengan masing-masing dipisahkan dengan koma. Deklarasi struktur didahului dengan kata kunci static, contoh: static struct zodiak bintang = {"Sagitarius", 22, 11, 21, 12};
Array dan Struktur Elemen-elemen dari suatu array juga dapat berbentuk sebuah struktur. Misalnya array yang dipakai untuk menyimpan sejumlah data siswa ( struct student ). Array struktur berdimensi satu ini membentuk suatu tabel, dengan barisnya menunjukkan elemen dari array-nya dan kolomnya menunjukkan elemen dari struktur. Dalam hal ini maka deklarasi yang dibutuhkan adalah sebagai berikut :
yang artinya, mendeklarasikan array student yang memiliki elemen yang bertipe struct person sebanyak MAKS. Setelah array student dideklarasikan, maka ruang yang disediakan ditunjukkan dalam Gambar berikut.
Elemen-elemen dari array stuktur tersebut bisa diakses dengan cara sebagai berikut:
Di samping cara pendeklarasian di atas, struktur juga dapat dideklarasikan dalam berbagai bentuk yang lain, di antaranya sbb :
yaitu mendefinisikan struktur date, sekaligus mendeklarasikan variabel today dan tomorrow dengan tipe struktur date. Demikian juga mendefinisikan struktur person, sekaligus mendeklarasikan variabel array student seban yak MAKS elemen dengan tipe struktur person. Atau cara lainnya mendefinisikan, mendeklarasikan sekaligus menginisialisasi struktur, sebagai berikut : struct date { int month, day, year; } today = {5,14,2001};
10.3 PERCOBAAN 1. Definisikan sebuah struktur (misalkan namanya = data_toko) yang memiliki 3 buah field berupa : sebuah array karakter dengan 5 elemen (misalkan namanya = nama), sebuah integer (misalkan namanya = data), dan sebuah float (misalkan namanya = harga). Inputkan data & tampilkan hasilnya ! Tampilan : Masukkan nama barang : sabun Masukkan jumlah barang : 5 Masukkan harga per barang : 20000 Jadi barang yang dimasukkan adalah sabun, jumlah barang 5 dan total harganya adalah 100000 2. Buatlah program sebagai berikut dengan menggunakan array of struct : Input: Nama Mhs Nilai Tugas Nilai UTS Nilai UAS Pengisian nilai dilakukan secara langsung
Proses: Nilai Akhir= 20% tugas + 40% UTS + 40%UAS Nilai huruf A(81-100), AB(71-80), B(65-70), BC(61-64), C(56-60), D(40-55), E(0-39) Nilai dinyatakan lulus jika minimal C Output : Nama : Rano Nilai tugas Nilai UTS : Nilai UAS : Nilai akhir Nilai Huruf
: 60 80 80 : 76 : AB
Nama : Cita Nilai tugas Nilai UTS : Nilai UAS : Nilai akhir Nilai Huruf
: 80 100 80 : 88 : A
3. Buatlah program untuk Pembuatan dan Pengsksessan Struktur berikut: // --------------------------------------------------------------------------------
// pembuatan dan pengaksesan struktur // ------------------------------------------#include int main() { struct data_tanggal { int tahun; int bulan;
int tanggal; }; // Deklarasi variabel struktur struct data_tanggal tanggal_lahir; tanggal_lahir; // Pengaksesan anggota struktur tanggal_lahir.tanggal tanggal_lahir.tanggal = 1; tanggal_lahir.bulan tanggal_lahir.bulan = 9; tanggal_lahir.tahun tanggal_lahir.tahun = 1964; printf("%d/%d/%d\n", printf("%d/%d/%d\n", tanggal_lahir.tanggal, tanggal_lahir.tanggal, tanggal_lahir.bulan, tanggal_lahir.tahun); return 0; } Kemudian lakukan percobaan dengan untuk beberapa variable akses anggota struktur. 4. Buatlah Program Penetapan Zodiak dengan menggunkan fungsi Struktur, untuk menentukan apakah zodiak anda Sagitarius atau bukan // -----------------------------------------------------// Program inisialisasi struktur // untuk penentuan zodiak // -----------------------------------------------------#include struct zodiak { char nama[11]; int tgl_awal; int bln_awal; int tgl_akhir; int bln_akhir; }; int main() { struct zodiak bintang = { "Sagitarius", 22, 11, 21, 12 }; int tgl_lhr, bln_lhr, thn_lhr; printf("Tanggal printf("Tanggal lahir anda (XX-XX-XXXX): "); scanf("%d-%d-%d", scanf("%d-%d-%d", &tgl_lhr, &bln_lhr, &thn_lhr); if ( (tgl_lhr >= bintang.tgl_awal && bln_lhr == bintang.bln_awal) || (tgl_lhr <= bintang.tgl_akhir && bln_lhr == bintang.bln_akhir) ) printf("Bintang printf("Bintang Anda adalah %s\n", bintang.nama); else printf("Bintang printf("Bintang Anda bukanlah %s\n", bintang.nama); return 0; }
Kemudian Lakukan percobaan untuk zodiak yang lain
10.4 LISTING PRPOGRAM 1.1 1.2 1.3 #include int main() { struct data_tanggal { int tahun; int bulan; int tanggal; }; struct data_tanggal tanggal_lahir; tanggal_lahir.tanggal=1; tanggal_lahir.bulan=9; tanggal_lahir.tahun=1964; printf("%d/%d/%d\n",tanggal_lahir.tanggal,tanggal_lahir.bulan, tanggal_lahir.tahun); return 0; }
1.4 #include struct zodiak { char nama[15]; int tgl_awal; int bln_awal; int tgl_akhir;
int bln_akhir; }; int main() { struct zodiak bintang= { "sagitarius",22,11,21,12 }; int tgl_lhr,bln_lhr,thn_lhr; printf("tanggal lahir anda(xx-xx-xxxx):"); scanf("%d-%d-%d",&tgl_lhr,&bln_lhr,&thn_lhr); if((tgl_lhr>=bintang.tgl_awal&& bln_lhr==bintang.bln_awal)|| (tgl_lhr<=bintang.tgl_akhir&& bln_lhr==bintang.bln_akhir)) printf("bintang anda adalah %s\n", bintang.nama); else printf("bintang anda bukanlah%s\n",bintang.nama); bukanlah%s\n",bintang.nama); return 0; }
10.5 KESIMPULAN
