Note Pemrograman Bahasa c 2011

Untuk kalangan sendiri tdk untuk disebar luaskan

TF-FTI ITB

Pemrograman Bahasa C Buku tambahan untuk kuliah PTI-B FTI

Nugraha, Dr.Eng 8/28/2010

C

halaman | 1-1


DAFTAR ISI BAB 1. OVERVIEW PEMROGRAMAN .............................................................................................................1-3

PEMROGRAMAN.........................................................................................................................................................1-3

ALGORITMA ................................................................................................................................................................1-3

BAHASA PEMROGRAMAN ..........................................................................................................................................1-7

MENJALANKAN PROGRAM C/C++ ..........................................................................................................................1-8

LATIHAN ..................................................................................................................................................................1-9

BAB 2. TIPE DATA.............................................................................................................................................. 2-11

PENDAHULUAN ....................................................................................................................................................... 2-11

IDENTIFIER ............................................................................................................................................................... 2-14

TIPE DATA ............................................................................................................................................................... 2-14

TIPE DATA INTEGER (INT) ................................................................................................................................... 2-15

TIPE DATA FLOAT................................................................................................................................................ 2-15

TIPE DATA KARAKTER (CHAR) ........................................................................................................................... 2-15

TIPE DATA BOOLEAN (BOOL) ............................................................................................................................. 2-16

VARIABEL DAN KONSTANTA ................................................................................................................................... 2-16

VARIABEL............................................................................................................................................................ 2-16

KONSTANTA ....................................................................................................................................................... 2-17

ASSIGNMENT STATEMENT....................................................................................................................................... 2-17

PERNYATAAN GABUNGAN...................................................................................................................................... 2-18

LATIHAN-LATIHAN............................................................................................................................................ 2-19

BAB 3. OPERATOR ............................................................................................................................................ 3-20

OPERATOR ARITMATIKA ......................................................................................................................................... 3-20

ATURAN PRECEDENCE ....................................................................................................................................... 3-20

KONVERSI TIPE DATA ........................................................................................................................................ 3-20

OPERATOR ASSIGNMENT........................................................................................................................................ 3-21

OPERATOR LOGIKA DAN PEMBANDINGAN ............................................................................................................ 3-21

LATIHAN : ................................................................................................................................................................ 3-23

BAB 4. FUNGSI INPUT DAN OUTPUT.......................................................................................................... 4-24

STANDAR IO ........................................................................................................................................................... 4-24

FUNGSI INPUT ......................................................................................................................................................... 4-24

GETCHAR (PROTOTYPE : INT GETCHAR (VOID)) ................................................................................................. 4-24

SCANF ................................................................................................................................................................. 4-25

FUNGSI OUTPUT...................................................................................................................................................... 4-27

PUTCHAR (PROTOTYPE: INT PUTCHAR(INT C)) .................................................................................................. 4-27

PRINTF ................................................................................................................................................................ 4-28

STREAM IO (HANYA ADA DI C++) ......................................................................................................................... 4-31

ALIRAN OUTPUT (OUTPUT STREAM) ................................................................................................................ 4-31

ALIRAN INPUT (INPUT STREAM) ........................................................................................................................ 4-32

FORMAT OUTPUT STREAM ................................................................................................................................. 4-33

BAB 5. KONTROL LOOP .................................................................................................................................. 5-36

WHILE LOOPING ...................................................................................................................................................... 5-36

DO LOOPING............................................................................................................................................................ 5-37

FOR LOOPING.......................................................................................................................................................... 5-37

LATIHAN : ................................................................................................................................................................ 5-38

halaman | 1-2


Pelengkap untuk matakuliah KU1072 PTI-B FTI

BAB 6. KONTROL PENCABANGAN.............................................................................................................. 6-39

PERNYATAAN IF....................................................................................................................................................... 6-39

PERNYATAAN IF-ELSE.............................................................................................................................................. 6-39

PENGGUNAAN BREAK DAN CONTINUE DI DALAM LOOP ..................................................................................... 6-40

SWITCH.................................................................................................................................................................... 6-41

EKSPRESI BERSYARAT............................................................................................................................................... 6-42

OPERATOR KOMA ................................................................................................................................................... 6-43

MENGAKHIRI INPUT DATA NUMERIK..................................................................................................................... 6-43

BAB 7. FUNGSI DAN PROTOTIPE ................................................................................................................. 7-45

PENDAHULUAN ....................................................................................................................................................... 7-45

FUNGSI TANPA PARAMETER ................................................................................................................................... 7-45

FUNGSI DENGAN PARAMETER ................................................................................................................................ 7-47

FUNGSI YANG MENGEMBALIKAN NILAI ................................................................................................................. 7-49

VARIABEL LOKAL, GLOBAL DAN SCOPE OPERATOR............................................................................................... 7-52

PASS BY VALUE, PASS BY PARAMETER DAN PASS BY ADDRESS............................................................................ 7-53

FUNCTION OVERLOADING...................................................................................................................................... 7-55

FUNGSI LIBRARY STANDARD .................................................................................................................................. 7-57

BAB 8. ARRAY, POINTER DAN STRING....................................................................................................... 8-58

ARRAY DAN ARITMATIKA ALAMAT......................................................................................................................... 8-58

ARRAYS MULTIDIMENSI .......................................................................................................................................... 8-60

POINTER .................................................................................................................................................................. 8-61

STRING..................................................................................................................................................................... 8-63

OPERASI_OPERASI STRING................................................................................................................................ 8-64

BAB 9. STRUKTUR DAN UNION ................................................................................................................... 9-67

STRUKTUR................................................................................................................................................................ 9-67

TYPE DEFINITION..................................................................................................................................................... 9-68

STRUKTUR DALAM STRUKTUR................................................................................................................................. 9-69

UNION ..................................................................................................................................................................... 9-70

BAB 10. FILE INPUT OUTPUT ......................................................................................................................... 10-73

MENULISKAN DATA KE FILE................................................................................................................................... 10-73

MEMBACA DATA DARI FILE ................................................................................................................................... 10-75

REFERENSI............................................................................................................................................................... 10-79

halaman | 1-3


Bab 1. OVERVIEW PEMROGRAMAN

Pemrograman

Program : Bersisi instruksi langkah perlangkah yang menyatakan apa yang harus dikerjakan oleh

komputer. Instruksi ini harus dalam bahasa yang dipahami oleh komputer.

Bahasa Pemrograman : merupakan sekumpulan aturan, symbol dan kosa kata khusus yang dipakai

untuk membangun program, missal C dan C++ merupakan salah satu bahasa pemrograman yang

dimengerti oleh computer.

Langkah-langkah dalam penulisan program

Langkah Problem-Solving

Analisa dan spesifikasi masalah (data input, output, asumsi & batasan masalah)

Pembuatan algorithma yang merupakan solusi dari permasalahan tsb, yang berisi langkah-

langkah intruksi untuk menghasilkan output yang diharapkan.

Fasa Implementasi

Terjemahkan algorithma kedalam bahasa pemrograman (kodifikasi)

Test program serta perbaiki jika ada kesalahan (debugging).

Fasa Pemeliharaan

Menggunakan program, merubah algoritma atau program agar sesuai dengan kebutuhan,

serta membuat dokumentasi agar program mudah dibaca oleh orang lain.

Beberapa petunjuk dalam pemecahan masalah.

Ada 3 hal yang diperlukan untuk memecahkan masalah

pernyataan masalah yang jelas

input yang diperlukan

output yang diinginkan

Ajukan pertanyaan

Cobalah untuk mengerti permasalahan dengan mengajukan pertanyaan

Lihatlah pada hal-hal yang sudah familiar (Do not reinvent the wheel !!)

Selesaikan permasalahan dengan analogi

Buatlah analogi masalah yang dihadapi dengan masalah yang lain yang sudah pernah

dipecahkan.

Memiliki pengalaman yang luas akan membuat anda menjadi programmer yang baik

Bagi dan Selesaikan

Bagi masalah yang besar kedalam masalah yang kecil-kecil untuk memudahkan penyelesaian

masalah

Algoritma

Orang awam mungkin menganggap bahwa computer adalah perkakas elektronik yang sangat hebat,

dapat mengerjakan berbagai fungsi. Namun orang yang paham komputer menganggap komputer

hanyalah barang elektronik yang mengolah data digital berdasarkan program tertentu. Jika tidak ada

program, maka komputerpun tidak dapat mengerjakan apa-apa.

halaman | 1-4



Program akan memberikan perintah kepada komputer tentang apa yang harus dilakukan serta

bagaimana cara melakukannya. Karena itu program berisi kumpulan instruksi langkah-langkah untuk

melakukan suatu tugas pada komputer.Intruksi ini ditulis dalam bahasa yang dimengerti oleh

komputer.

Menurut pakar komputer Niklaus Wirth, program terdiri dari algoritma dan data.Data merupakan

informasi yang harus diolah komputer dan disimpan sebagai variable dalam program.Algoritma

merupakan urutan langkah yang sistematis untuk menyelesaikan masalah. Menurut Donal E. Knuth,

algoritma yang baik harus memiliki beberapa ketentuan, yaitu :

1. Algoritma berhenti setelah mengerjakan sejumlah langkah terbatas (terminated)

2. Setiap langkah harus terdefinisi dengan baik, tidak ambigu sehingga dapat di realisasikan

3. Algoritma memiliki nol atau lebih nilai masukan

4. Algoritma mempunyai nol atau lebih nilai keluaran

5. Algoritma harus efektif dan effisien

Berikut ini adalah contoh dari algoritma membuat kopi :

Algoritma Membuat Kopi

1. Tuangkan kopi kedalam gelas

2. Jika tidak tersedia air panas maka panaskanlah air terlebih dahulu

3. Tuangkan air panas secukupnya kedalam gelas berisi kopi

4. Tuangkan satu sendok teh gula kedalamnya serta aduk hingga gulanya larut

5. Jika kurang manis ulangi lagi langkah 4 diatas.

Dari algoritma diatas terlihat bahwa ada tiga jenis proses dalam algoritma, yaitu proses berurutan,

pemilihan serta pengulangan.

Proses Berurutan (sequence)

Proses pada algoritma dijalankan dengan urutan tertentu.

Proses Pemilihan (selection)

Proses ini ditandai dengan adanya kalimat jika <kondisi> maka (if <kondisi> then), algoritma

harus memilih salah satu dari dua atau lebih pilihan yang ada.

Proses pengulangan (repititon)

Proses ini ditandai dengan kata ulangi (repeat, for …to….do, while <kondisi> do .., atau do….

while<kondisi>). Pada proses ini suatu langkah dilakukan berulang-ulang sesuai dengan

kebutuhan atau kondisi yang ada.

Penulisan algoritma dapat dilakukan dengan berbagai cara, yaitu :

1. Non-Formal : menggunakan deskripsi bahasa sehari-hari seperti contoh diatas

2. Formal : menggunakan ekspresi matematika

3. Pseudocode : menggunakan deskripsi bahasa yang mendekati bahasa pemrograman

4. Flowchart : langkah-langkah digambarkan secara diagramatik

Pseudocode dan flowchart merupakan dua cara penulisan algoritma yang banyak dipakai. Flowchart

berisi kumpulan diagram berbagai bentuk yang dihubungkan dengan garis panah. Masing -masing

bentuk diagram mewakili langkah-langkah dalam algoritma. Beberapa bentuk diagram/simbol yang

halaman | 1-5


Tabel 1 Diagram/Simbol pada flowchart

Simbol Arti

Untuk tanda mulai dan akhir program

Arah program

Inisialisasi/pemberian harga awal

Proses perhitungan/pengolahan data

Proses pencabangan

Input/output data, parameter, informasi

Menjalankan subprogram

Aturan umum flowchart

1. Seluruh diagram flowchart terhubung dengan tanda panah (bukan garis)

2. Simbol flowchart memiliki titik masuk pada bagian atas dan titik keluar pada bagian bawah

kecuali simbol pemilihan (decision)

3. Simbol pemilihan (decision) memiliki dua keluaran di kedua sisi atau bawah dengan samping

4. Simbol konektor digunakan untuk memotong dan menghubungkan flowchart dengan flowchart

yang lain, misalnya ketika pindah halaman

5. Program subroutine memiliki flowchart tersendiri

6. Flowchart dimulai dan berakhir pada suatu terminal

Flowchart memiliki kelebihan mudah diinterpretasi dan dibaca, relatif mudah dimengerti serta relatif

mudah untuk dibuat.Namun flowchart membutuhkan media penulisan yang relatif besar, kurang

fleksibel untuk menjelaskan konsep-konsep spesifik dalam pemrograman misalnya tipe data.

Pseudocode cara untuk menyatakan algoritma seperti bentuk tek non formal namun dengan kosa

kata yang lebih terbatas dan terdefinisi dengan baik serta dekat dengan bahasa pemrograman.Misal

jika kita ingin menampilkan data x, maka dituliskan dalam pseudocode sebagai

print (x);

Notasi ini bersesuaian dengan perintah

printf (x); di C/C++

writeln (x); di Java

write (x); di Pascal

Meskipun tidak ada standarrisasi untuk pseudocode, namun pada umumnya dapat dikelompokan

menjadi grup input, output, iterasi, pemilihan, proses, assignment dan fungs i. Beberpa kosakata yang

biasa digunakan pada pseudocode beserta contohnya diperlihatkan pada Tabel 2 berikut ini

halaman | 1-6



Tabel 2 Kosa kata pseudocode

Grup Kata kunci/operator Contoh

Input read, input, get, obtain read x, y;

Output print, write, show, display print (“nama saya :”, nama)

Pemilihan

(Decision)

if <kondisi> then

pernyataan

endif

if <kondisi>

then pernyataan1

else pernyataan2

endif

if (x== y) then

print (“sama”)

endif

if (x== y)

then print (“sama”)

else print (“tidak sama”)

endif

Iterasi

(Iteration)

repeat

pernyataan

until <kondisi>

dowhile <kondisi>

pernyataan

enddowhile

for <var> = <start value> to <stop value>

pernyataan

endfor

repeat

x = x +1

until (x > 100)

dowhile (x <= 100)

x = x +1

enddowhile

for i = 1 to 100

x = x + 1

endfor

Proses add, substract, compute, set, init add 3 to x

compute x + 5 giving new x

Assignment <variable><variable>;

<variable> = <variable>;

x y + 2;

Fungsi function <function name>(<arguments>)

do statement with arguments;

return <expression>;

Pemanggilan fungsi

<function name>(<arguments>)

function rata2 (x,y)

rata = (x + y)/2;

return rata;

rata2(10,6);

Pada dasarnya penulisan algoritma pseudocode tersusun atas tiga bagian :

1. Judul Algoritma : terdiri dari nama algoritma yg diikuti penjelasan mengenai algoritma, berisi

uraian singkat mengenai apa yang dikerjakan oleh algoritma tersebut yg disebut spesifikasi

algoritma

2. Deklarasi Algoritma : berisi semua nama yang digunakan dalam algoritma , mencakup nama-

nama tipe, konstanta, variabel, prosedur, fungsi yang didefinisikan pada algoritma.

3. Deskripsi Algoritma : berisi semua langkah-langkah algor itma. Urutan langkah dibaca dari atas

kebawah dan menentukan urutan pelaksanaan perintah

Setiap bagian dilengkapi komentar, untuk memperjelas tek yang dituliskan. Komentar ditulis dalam

tanda kurung kurawal

halaman | 1-7


Contoh algoritma untuk menjumlahkan 100 bilangan bulat pertama.

Flowchart Pseudocode

Penjumlahan100 Integer Pertama {menjumlahkan

bilangan integer dari 1 sampai 100}

Deklarasi :

Sum : integer

i : integer

Deskripsi :

Sum0

for i=1 to 100

sumsum+1

endfor

print sum

Contoh kasus: jumlahkanlah N buah deret bilangan integer dimana harga N diberikan oleh pengguna

Menjumlahkan N buah Bilangan Integer

{Menjumlahkan deret 1+2+3+….+N , dengan N bilangan bulat positif yang dibaca di perangkat

masukan. Jumlahderetditampilkandiperangkatkeluaran}

Deklarasi:

N : integer{banyaknyasuku}

k : integer{suku deret ke-”k”}

jumlah: integer{jumlahderet}

Deskripsi:

read(N) {membaca banyaknya suku}

jumlah 0 {inisialisasi jumlah deret}

k 1 {suku deret ke-”k=1”}

repeat

jumlah jumlah+k

k k +1 {sukuderetberikutnya}

while k < N

write (jumlah)

Bahasa Pemrograman

Bahasa Pemrograman terbagi kedalam beberapa tingkatan :

1. Bahasa Mesin

MULAI

SELESAI

SUM = 0

I = 0

SUM = SUM + 1

I = I + 1

I>100?

PRINT SUM

halaman | 1-8



Bahasa yang terdiri dari intruksi-instruksi dlm kode biner yang dapat langsung dimengerti oleh

komputer. Komputer dengan CPU yang berbeda akan menggunakan kode biner yang berbeda

untuk masalah yang sama. Program yang ditulis dalam bahasa mesin sangat sukar untuk dibaca

dan dimodifikasi.

2. Bahasa assembler (Bahasa pemrograman tingkat rendah)

Hampir sama dengan bahasa mesin hanya instruksi -instruksinya mudah dibaca.Agar dapat dibaca

oleh computer diperlukan program yang menerjemahkan intruksi bahasa assembler ke bahasa

mesin.

Bahasa assembler Bahasa mesin

ADD100101

SUB010011

3. Bahasa pemrograman tingkat tinggi

Bahasa ini lebih mudah digunakan disbanding bahasa assembler dan bahasa mesin, karena

mendekati bahasa Inggris.Misalnya : C, C++, Pascal, Fortran, Cobol, Ada.Proses kompilasi akan

menerjemahkan bahasa tingkat tinggi ke bahasa mesin.

Menjalankan program C/C++

Pembuatan program dengan menggunakan bahasa pemrograman terkompilasi (compiled language)

seperti C/C++ memertlukan sedikitnya 4 langkah pekerjaan :

1. Editing/penulisan program

Penulisan program dilakukan dengan bahasa pemrograman yang masih dapat dimengerti oleh

manusia, penulisan dapat dilakukan dengan menggunakan perangkat lunak untuk mengedit tek,

seperti emacs, vi dll. Untuk C dan C++ biasanya nama file belakangnya menggunakan .c atau .cpp

Misalnya harga_buku.c atau harga_buku.cpp

2. Kompilasi

File .c agar dapat dieksekusi oleh computer harus diubah (kompilasi) ke dalam bahasa mesin yang

dimengerti oleh CPU oleh compiler, misalnya di linux biasa menggunakan gcc untuk sebagai

compiler bahasa c. Proses kompilasi biasanya menghasilkan file .obj

3. Linking

Pada bahasa pemrograman seperti C dan C++, kita sering menggunakan lib rary yang sudah

disediakan oleh bahasa pemrograman seperti pengontrolan input output, fungsi-fungsi matematik

dsb. Dengan melakukan linking fungsi-fungsi tersebut dapat ditambahkan pada program kita.

Hasil linking sudah merupakan file yang dapat dieksekusi .exe (windows) atau .out (linux). Proses

kompilasi dan linking bisa terpisah bisa juga menjadi satu tergantung pada program kompilasi

yang dipakai.

Misalnya :

gcc harga_buku.c, akan menghasilkan file a.out yang bias langsung dieksekusi

gcc -o harga_buku harga_buku.c, akan menghasilkan file harga_buku.out yang bias langsung

dieksekusi

4. Eksekusi

File yang sudah melewati proses linking dapat langsung dieksekusi dengan

menuliskan/memanggil nama file tersebut.

halaman | 1-9


Misalnya di linux: ./harga_buku

Contoh kasus:

Ali membeli tiga buah buku, dia ingin tahu harga total buku-buku yang dia beli serta harga rata-rata

buku tersebut.

Deskripsi masalah :

Input : harga 3 buah buku (harga_b1, harga_b2, harga_b3)

Output : harga total 3 buah buku dan harga rata-rata

Batasan masalah : jumlah buku = 3 buah

Algoritma :

Menghitung Harga Rata-rata 3 Buah Buku

{Program ini menghitung harga rata-rata 3 buah buku yang dimasukan menggunakan piranti

masukan}

Deklarasi :

Sum, rata2, harga_b1, harga_b2, harga_b3: integer

Deskripsi:

1. read harga_b1, harga_b2, harga_b3

2. Hitung jumlah total

Sum = harga_b1+ harga_b2+ harga_b3

3. Hitung harga rata-rata

rata2 = Sum/3

Program dalam C :

//Contoh 1.1 : Program menghitung harga total 3 buah buku dan harga rata -rata

#include<stdio.h> //header untuk standard input output

int main()

{

int harga_b1, harga_b2, harga_b3; //deklarasi variable harga buku

printf(“Masukan harga 3 buah buku : \n”);

scanf (“%d %d %d”, &harga_b1, &harga_b2, &harga_b3);

int sum = harga_b1 + harga_b2 + harga_b3;

int rata2 = sum/3;

printf(“Harga total dari 3 buah buku = %d \n”, sum);

printf(“Harga rata-rata dari 3 buah buku = %d \n “, rata2);

return 0;

}

Sebuah algoritma dapat memiliki berbagai implementasi

Think first, code later !!!

LATIHAN

1. Buatlah algoritma program untuk menentukan apakah fluida yang mengalir dalam pipa berada

dalam keadaan aliran laminer, turbulen atau tidak stabil. Program mendapat masukan masa jenis

fluida, kecepatan alir fluida, viskositas fluida serta diameter pipa lewat piranti masukan. Bilangan

Reynold dihitung dengan menggunakan persamaa :

Reynold‘s Number = (density x velocity x diameter) / viscosity

halaman | 1-10



Jika bilangan reynold sama dengan 2000 atau dibawahnya maka aliran fluida adalah laminer, jika

bilangan reynold sama dengan 3000 atau diatasnya maka alairan fluida adalah turbulen, jika

diantara 2000 dan 3000 maka aliran fluida adalah tidak stabil

halaman | 2-11


Bab 2. TIPE DATA

Pendahuluan

Setelah mengenal langkah-langkah pembuatan program dan menjalankan program, maka sekarang

anda dapat mencoba membuat program C, namun sebelum itu akan diperkenalkan terlebih dahulu

beberapa command dalam linux untuk membuat direktori dan pemakaian sebuah editor yang dijamin

ada disemua edisi linux yaitu vi editor. Sebenarnya selain vi editor dapat juga digunakan editor lain

seperti emacs, kwrite, gedit dll, namun pada kali ini hanya akan dikenalkan vi editor saja.

Di linux untuk membuat sebuah direktori baru yang diberinama misalnya direktori_saya dapat

dilakukan melalui terminal dengan menggunakan perintah (dalam hal ini $ adalah prompt diterminal):

$ mkdirdirektori_saya

Di sini kita masih berada di direktori home dan untuk pindah ke direktori direktori_saya dapat

dilakukan dengan menggunakan perintah:

$ cddirektori_saya

Sekarang kita telah berada di direktori direktori_saya dan setiap file yang kita buat akan berada di

direktori ini. Marilah kita mencoba membuat program yang kita mulai dengan progam C melalui

CONTOH2.1 yang membaca dua buah bilangan bulat a dan b dari keyboard untuk menghitung u =

(a+b)2 dan v = (a-b)

2 . Ketikan pada terminal

$ vi contoh2_1.c

maka pada layar akan muncul seperti dibawah ini :

anda berada pada mode COMMAND dari vi editor. Untuk dapat menuliskan program, anda harus

masuk kemode INSERT dengan menekan a, i atau o lalu ketikan program dibawah ini.

/* CONTOH 2.1 : Sebuah program untuk menghitung kuadrat jumlahdan kuadrat selisih dari dua

buah bilangan bulatyang diberikan. */

#include<stdio.h>

main()

{

printf(“Masukan dua buah bilangan bulat: \n”);

/* Tampilkan permintaan untuk

menuliskan dua bilangan bulat */

inta, b;

scanf(“%d %d”, &a, &b); // Baca a dan b.

intjml = a + b, beda = a - b,

u = jml * jml, v = beda * beda;

printf(“Pangkat dari Jumlah : %d \n”, u);

printf(“Pangkat dari Perbedaan : %d \n”, v);

}

~

~

~

~

~

~

“contoh2_1.c” [New file]

halaman | 2-12



untuk kembali ke mode COMMAND tekanlah Esc.Pada mode COMMANDkita dapat mengedit teks

yang telah kita tulis.

x untuk mendelete karakter

dwuntuk mendelete kata

dd untuk mendelete baris

r untuk replace

Bagian yang ingin diedit dapat dipilih dengan menggerakan kursor dengan keyboard tanda panah.

Jika pada mode COMMAND kita tekan :maka kita masuk ke mode INLINE, ditandai dengan adanya

tanda : pada bagian bawah terminal. Pada mode ini kita dapat melakukan :

:q keluar vi editor tanpa men-save file

:w (nama file) men-save file

:wq men-save dan keluar editor

:e (nama file) membuka file baru

:r (nama file) meng-insert file

Jika tidak ada kesalahan pengetikan program contoh2.1, maka tutuplah editor dengan megetikan :wq

untuk men-save dan keluar dari vi editor.

Kita dapat menulis program dalam bahasa C jika kita mengetahui ketentuan-ketentuan tatabahasa C.

Marilah kita perhatikan program di atas. Merupakan kebiasaan yang baik dalam menulis program

dengan memberikan komentar-komentar yang dirasa amat membantu pada saat kita membaca

kembali program tersebuf diwaktu-waktu mandatang. Komentar tersebut dapat dituliskan dengan dua

cara. Pertama dengan dimulai oleh dua buah karakter yaitu /*, dan diakhiri dengan dua buah karakter

lagi */. Kedua pasangan dua-karakter itu tidak harus terletak dalam satu baris. Berbeda halnya dengan

cara penulisan kedua yang menggunakan dua karakter //. Akhir baris sekaligus merupakan akhir dari

komentar. Sebagaimana yang kita lihat dalam contoh2.1 di atas, kedua cara menulis komentar itu

telah kita gunakan di sini. Dalam contoh di atas juga kita temui baris include sebagai berikut:

#include <stdio.h>

Bagian ini biasa disebut Pre-processor Directives.Preprocessor dapat menambah atau mengurangi

source code program yang kita buat. Dalam kasus diatas directive #include memerintahkan processor

untuk meng-include-kan modul stdio kedalam source code program yang kita buat, yang dalam hal

ini kita perlukan untuk aliran input dan output. Baris-baris yang melibatkan suatu file selalu dimulai

dengan #include dan mareka memerlukan baris tersendiri di dalam penulisan program. Misalnya kita

tidak diperkenankan menuliskan main () sebaris dengan #include. Baris untuk melibatkan suatu file

memang berbeda dengan ketentuan umum yang menyebutkan bahwa teks dan program dapat

dipecah menjadi beberapa baris sesuai dengan kemauan kita. Sebagai contoh kita bisa saja mengganti

baris:

int jml= a +b, beda= a - b;

dengan dua buah baris sebagai berikut:

int jml= a + b,

beda= a - b;

Kita bisa saja memecah baris ini lebih lanjut, tetapi jelas bahwa hal tersebut tidak akan meningkatkan

kemudahan dalam membacanya.

Setiap program C berisi satu atau lebih fungsi yang salah satu diantaranya adalah main. Perlu

ditekankan di sini bahwa fungsi disini maksudnya adalah sebuah fragmen program. Untuk kasus

contoh2.1 di atas main merupakan satu-satunya fungsi dan ia memiliki bentuk:

halaman | 2-13


main()

{

…………….

…………….

}

Sebuah fungsi bisa saja mempunyai atau tidak mempunyai parameter. Jika mempunyai maka

kita menuliskannya diantara tanda kurung (nanti akan kita temui dalam contoh -contoh

selanjutnya). Sebaliknya jika ia tidak mempunyai parameter, tanda kurung masih digunakan, namun

tanpa tulisan apapun, seperti dalam contoh2.1 di atas. Bagian utama (body) dari suatu fungsi

berada di antara kurung kurawal { }. Merupakan suatu kebiasaan yang baik untuk menuliskan

pasangan kurung kurawal itu dituliskan dalam satu kolom yang sama. Setelah tanda buka

kurung kurawal { ini akan kita temui pernyataan-pernyataan (statements). Sepanjang kita tidak

menggunakan pernyataan gabungan (akan dibahas dalam modul selanjutnya), setiap pernyataan

diakhiri dengan sebuah semikolon ;. Dalam contoh2.1 di atas kita lihat ada 6 semikolon;

masing-masingnya mengakhiri suatu pernyataan. Kita akan sering menuliskan satu pernyataan

saja setiap barisnya. Meskipun demikian, bisa ada lebih dari satu pernyataan dalam satu baris, dan

ada juga sebuah pernyataan yang membutuhkan lebih dari satu baris seperti contoh di bawah ini:

int jml = a + b, beda = a -b,

u = jml * jml, v = beda * beda;

Pernyataan seperti ini disebut sebagai deklarasi, Di sini deklarasi itu menyatakan bahwa variabel-

variabel jml, beda, u, dan v mempunyai tipe atau jenis int yang berarti bilangan bulat. Pernyataan

di atas tidak saja menyatakan variabel-variabel jml, beda, u, dan v, tetapi juga memberikan harga-

harga awalnya melalui harga-harga a dan b. Variabel-variabel a dan b dideklarasikan dalam

pernyataan:

int a, b;

tanpa diberi harga awal (inisialisasi) sehingga segera setelah pernyataan ini harga mareka tidak

terdefinisi. Selanjutnya terdapat juga sebuah pernyataan yang berbeda sama sekali dengan

pernyataan-pernyataan sebelumnya yaitu :

printf (―Masukan dua buah bilangan bulat: \n‖);

printf merupakan standard input output dimana kita dapat mengirim karakter-karakter “Masukan dua

buah bilangan bulat:”kelayar. Demikian pula halnya dengan pemyataan:

scanf(―%d %d‖, &a, &b); // Baca a dan b

membaca dua buah harga input standard (yaitu dari keyboard) dan selanjutnya menyimpannya di

dalam variabel-vanabel a dan b. Pada saat mengeksekusi pernyataan ini, komputer akan

menunggu hadirnya suatu input melalui keyboard. Setelah u dan v dihitung, harga variabel-variabel

ini, yang didahului oleh sejumlah kata-kata pengantar dicetak dengan perintah pernyataan sebagai

berikut:

printf (―Pangkat dari Jumlah : %d \n‖, u);

printf (―Pangkat dari Perbedaan : %d \n‖, v);

Kita gunakan \n untuk menyatakan bahwa baris pemyataan itu berakhir di sini.

Secara umum layout dari program C adalah sbb:

documentation section

pre-processor directives (link section and definition section)

halaman | 2-14



global declarations

main()

{

local variables to function main ;

statements associated with function main ;

}

f1()

{

local variables to function 1 ;

statements associated with function 1 ;

}

…

etc

Untuk mengkompile program contoh2.1 diatas ketikan dari terminal

gcc contoh2_1.c

disini kita menggunakan gcc sebagai program kompilasi untuk merubah program bahasa C

contoh2_1.c menjadi program dalam bahasa mesin yang secara otomatis akan menghasilkan file a.out

sebagai hasil kompilasi. File a.out dapat dieksekusi secara langsung dengan mengetikan : ./a.out

Jika kita ingin menggunakan nama lain untuk hasil kompilasi, misalnya contoh2_1.out, maka ketikan

baris dibawah ini pada waktu kompilasi.

gcc -o contoh2_1 contoh2_1.c

maka sebagai hasil kompilasi akan dihasilkan file contoh2_1.out. Untuk mengeksekusi file

contoh2_1.out, ketikan: ./contoh2_1.out

Identifier

Identifier adalah nama yang kita pakai untuk mengacu pada sesuatu (misalnya variabel, konstanta,

fungsi dll.). Nama yang kita pilih tidak ada artinya bagi komputer karena itu pilihlah nama yang ada

artinya bagi kita agar mudah dimengerti. Indentifier boleh tersusun dari huruf (A-Z atau a-z), angka

(0-9) dan garis bawah (_).Karakter pertamanya tidak boleh berupa angka. Nama identifier bersifat

case sensitive sehingga Bandung berbeda dengan bandung. Biasakanlah untuk menuliskan identifler

ini dengan karakter awalnya berupa huruf (jangan garis bawah), karena ada fungsi-fungsi sistem

yang diberi nama dengan awalan baris bawah. Jangan gunakan identifiers berikut ini karena telah

digunakan untuk keywords:

asm, auto, break, case, catch, char, class, canst, continue, default, delete, do, double, else, enum,

extern, float, for, friend, goto, if, inline, int, long, new, operator, private, protected, public, register, return,

short, signed, sizeof, static, struct, switch, template, this, throw, try, typedef, un ion, unsigned, virtual,

void, volatile, while.

Contoh nama identifier yang benar : _x, _y, akar_kuadrat, Nama_kota, nomor_telepon, win4lin, p4ls,

AmbilData, Box22A, NamaVariabelYangPanjang.

Contoh nama identifier yang salah : 4Box, while, new model, alamat rumah.

Tipe Data

Tipe data menentukan bagaimana data itu direpresentasikan serta diproses oleh komputer. Tipe data

yang dasar terdiri dari int, float, char dan bool.

halaman | 2-15


Tipe data integer (int)

Tipe data integer digunakan untuk merepresentasikan bilangan integer baik positip maupun negatip

(misalnya 22, 16, 0, -4600). Ukuran nilai yang dapat direpresentasikan tergantung pada jenis

komputer. Pada PC tipe integer memakai alokasi memori 16 bits (2 bytes) atau dari -32768 sampai

32767. Tipe integer memiliki variasi yang terdiri dari :

short int 16 bits (2 byte) - range angka = [-32,768, 32,767]

long int 32 bits (4 bytes) - range angka = [-2147483648, 2147483647]

long long int 64bits (8 bytes)

Jika kurang dari range tersebut maka akan terjadi underflow serta jika range tersebut dilampaui

maka akan terjadi overflow.

Selain itu tipe integer dapat berjenis unsigned atau signed. Jenis/format integer terdiri dari bilangan

desimal (123), hexadesimal (0xFF3A), oktal (0777) dan Long desimal (123L). Jika karakter pertama

dan sebuah konstanta adalah 0 dan segera diikuti o leh digit berikutnya, maka konstanta itu

dipahami sebagai sebuah bilangan oktal (dengan basis 8); hanya digit 0, .., 7 yang boleh ada dalam

konstanta ini. Jika suatu konstanta diawali dengan 0x atau 0X maka la merupakan bilangan

heksadesimal. Kita gunakan huruf-huruf A, ., F (atau a, ..., f) sebagai bilangan heksadesimal

untuk harga-harga 10,..., 15. Huruf L (atau 1), yang berarti long, diakhir suatu konstanta merupakan

sebuah suffix. Kita dapat juga menggunakan suffix U (atau u) yang berarti unsigned. Urutan

penempatan L dan U tidak menjadi persoalan. Tipe data integer dapat dideklarasikan dengan

menggunakan keyword int, long, short, unsigned short dan unsigned long. Bilangan integer

direperentasikan secara exact oleh memori komputer.

Tipe data float

Tipe data float dipakai untuk merepresentasikan bilangan riil (misalnya 19.0, 153.24, 3., .9). Alokasi

memori yang digunakan tipe data float tergantung pada jenis presisi yang digunakan yang terdiri dari

single precision (float) : 4 byte dan 6 digit desimal

double precision (double): 8 bytes and 16 digit desimal

long double : 10 byte and 20 digit desimal

Selain itu bilangan riil dapat juga diekspresikan dalam notasi scientific xEy = x.10y (misalnya 2.3E11 =

2.3x1011

). Tipe data float dideklarasikan dengan menggunakan keyword float, double dan long

double. Bilangan riil direpresentasikan sebagai pendekatan oleh memori komputer .

Tipe Data Karakter (char)

Tipe data karakter dideklarasikan dengan menggunakan keyword char dan dipakai untuk

mengekspresikan karakter tunggal dari alphanumerik (huruf, angka dan simbol khusus), misalnya „X‟,

„x‟, „$‟, „9‟.Karakter harus dituliskan diantara tanda petik tunggal sehingga program kompilasi bisa

membedakan antara data karakter „2‟ dengan angka integer 2. Alokasi memori yang digunakan untuk

merepresentasikan karakter adalah 8 bit (1 byte). Sejumlah karakter mempunyai pengertian khusus

setelah didahului oleh karakter „\ „sebagai berikut :

\n baris baru, meloncat ke awal baris berikutnya

\r prompt kembali ke awal baris saat ini

\t tabhorizontal

\v tabvertical

\b backspace

\f form feed

\\ backlash

\' single quote

\” double quote

halaman | 2-16



\? Tanda tanya

\000 Bilangan oktal

\xhh Bilangan heksadesimal

Tipe data Boolean (bool)

Pada C++, tipe data boolean dideklarasikan dengan menggunakan keyword bool dan hanya memiliki

dua harga yaitu true atau false. Di C tidak ada tipe data keyword bool, sebagai gantinya kita dapat

menggunakan tipe data integer dengan 0 menyatakan FALSE dan 1 adalah TRUE

Alokasi memori serta range data yang dapat dipakai untuk berbagai tipe data dapat dilihat pada table

dibawah ini .

Tipe data Alokasi memori Range

unsigned short int 2 bytes [-0, 65,535]

short int 2 bytes [--32,768, 32,767]

unsigned long int 4 bytes [-0, 4,294,967,295]

long int 4 bytes [--2,147,483,648, 2,147,483,647]

int (16 bit) 2 bytes [--32,768, 32,767]

int (32 bit) 4 bytes [--2,147,483,648, 2,147,483,647]

unsigned int (16 bit) 2 bytes [-0, 65,535]

unsigned int (32 bit) 2 bytes [-0, 4,294,967,295]

char 1 byte nilai dari 256 karakter

float 4 bytes [-1.2e-38, 3.4e38]

double 8 bytes [-2.2e-308, 1.8e308]

Variabel dan Konstanta

Variabel

Variable adalah identifier yang merepresentasikan lokasi di memori komputer dimana isi lokasi

tersebut dapat diubah. Selain harus punya nama, variabel juga harus dideklarasikan sebelum dapat

digunakan. Deklarasi variabel adalah sbb :

Tipe_Data Indetifier;

Contoh :

int nim;

double akar;

char nama;

booltest;

long nomor_telepon; // tipe data integer long

unsigned longy; // tipe data integer long unsigned (>0)

float rata_rata;

Pada waktu deklarasi variabel dapat diberi harga inisiasi, misalnya :

int a = 5;

halaman | 2-17


float b = 2.1;

Konstanta

Konstanta adalah identifier yang merepresentasikan lokasi di memori komputer dimana isi lokasi

tersebut tidak dapat diubah. Pendefinisian/deklarasi konstanta dapat dilakukan dengan 2 cara. Cara

pertama berasal dari bahasa C menggunakan preprocessor directive #define .

#define PI 3.1416

#define MIN 12

#define bintang ‗*‘

Kompiler akan merubah semua konstanta yang muncul di dalam program, yang memiliki nama yang

sama dengan yang didefinisikan diatas, dengan harga yang didefinisikan tanpa melihat tipe data,

scope dan pembatasan, sehingga disarankan untuk tidak menggunakan definisi dengan cara seperti

ini.

Cara pendefinisian/deklarasi konstanta yang kedua adalah dimulai dengan keyword const dan tipe

data lalu nama konstanta beserta harga konstanta tersebut. Deklarasi konstanta adalah sbb :

const Tipe Data Indetifier = suatu harga;

Contoh :

const float PI=3.1416;

const int MIN=12;

const char bintang = '*';

Assignment statement

Assigment statement digunakan untuk menyimpan nilai kedalam variabel, tapi variabelnya harus

dideklarasikan terlebih dahulu.

Variabel = Ekspresi;

Ekspresi dapat terdiri dari konstanta, variabel dan operator.Operators (diantaranya): +, -, *, /, %

(modulus – sisa dari pembagian integer)

Contoh Assigment :

//deklarasi variabel :

int x, k, l, nilai;

float f, g;

char c;

//Assigment

x=20;

k=l+5;

nilai=15+x;

c='C';

f=1.2-g;

Harus diingat penggunaan tipe integer dan float pada waktu pembagian :

Tipe integer : 8/2=4, 9/2=4, 2/3=0

Tipe float : 9.0/2.0=4.5, 2.0/3.0=0.66667

Pencampuran tipe data dalam satu ekspresi

halaman | 2-18



Program kompilasi akan mengubah tipe yang lebih rendah ke yang lebih tinggi

Hirarki: long double, double, float, long int, int, short int

contoh :2.0+8 = 10.0

C memiliki notasi lvalues dan rvalues (l=left, r=right) yang berhubungan dengan variabel dan

konstanta. rvalue adalah nilai data dari variabel (atau biasa dihubungkan sbg „read‟), sedangkan lvalue

adalah lokasi dari data („location‟). Pada lvalue hanya bisa diisi oleh variabel sedangkan rvalue bisa

diisi oleh variabel dan konstanta.

Contoh :

int x;

x = 5; // ini OK, x boleh sebagai lvalue.

5 = x; // ini illegal. konstanta 5 tidak boleh sbg lvalue.

Pernyataan Gabungan

Banyak pernyataan, seperti tampak di bawah ini berisi suatu ekspresi yang diikuti oleh sebuah titik

koma:

scanf (―%d‖, n);

c = a + b;

printf (―Tamat. \n‖);

Kita dapat menggunakan kurung kurawal { } untuk menuliskan penyataan yang kompleks dari

pernyataan-pernyataan yang sederhana. Misalnya pernyataan berikut ini :

{k = 2*a+c; l = b+3*d; m = 5*e + f;}

mengandung pernyataan gabungan yang berasal dari tiga buah pernyataan sederhana. Pernyataan-

pernyataan gabungan disebut juga blocks khususnya jika kita memproklamirkan sejumlah variabel di

dalamnya. Bagian dan program ini disebut scope dari variabel yang dideklarasikan. Suatu variabel

dikatakan terlihat (visible) dalam scopenya kecuali jika ada scope lainnya yang memiliki variabel

dengan nama yang sama. Contoh berikut ini akan memperjelas hal tersebut

//Contoh 2.2 : Keterlihatan variabel.

#include <stdio.h>

main()

{

int nilai = 2;

{

printf( “nilai = %d \n”, nilai);

// Output: nilai = 2 karena int nilai tampak (visible).

float nilai=3.7;

{

printf( “nilai = %f \n”, nilai);

// Output: nilai = 3.7 karena float niliai tampak.

// int nilai masih dalam scope tetapi tersembunyi.

char nilai = 'A';

printf( “nilai = %c \n”, nilai);

// Output: nilai = A (karena char nilai visible).

// float nilai dan int nilai masih dalam scope tetapi

// tersembunyi.

}

printf( “nilai = %f \n”, nilai);

halaman | 2-19


// Output: nilai = 3.7 (karena float nilai visible).

// int nilai masih dalam scope tetapi tersembunyi.

// char nilai di luar scope.

}

printf( “nilai = %d \n”, nilai);

// Output: nilai = 2 (karena int nilai visible)

// float nilai dan char nilai diluar scope.

}

LATIHAN-LATIHAN

1. Carilah kesalahan-kesalahan dalam program berikut ini, dan selanjutnya perbaikilah:

include <std.h>

main();

{

float a, b

a = „A'.

b = “B”.

a = „C‟ +1;

printf(“Akhir dari program ini”)

}

2. Apakah output dari pernyataan berikut ini?

printf(―tanda petik: \' \n tanda petik dua: \‖ \n‖

―Backlash: \\\nThe End. \n‖);

3. Buatlah program yang mencetak nama dan nim anda pada baris yang berlainan. Selanjutnya

compile dan run program tersebut di komputer anda.

4. Buatlah program yang mencetak umur anda. Program ini harus mengajukan

Permintaan kepada anda untuk memasukan tahun kelahiran dan tahun saat ini kepada anda.

5. Diberikan persamaan sbb : x(t) = xo + v0.t + 1/2 at2, buatlah program C++ dengan masukan jarak

awal, kecepatan awal, percepatan dan waktu serta tampilkan hasil perhitungan jarak sekarang

halaman | 3-20



Bab 3. OPERATOR

Operator Aritmatika

Padabagiansebelumnyakitatelahmenggunakan operator-operator seperti :

Operator penjumlahan : x + y

Operator pengurangan : x – y

Operator perkalian : x * y

Operator pembagian : x / y

Operator modulus : x % y

Semuanyamempunyaiduabuah operand, yaitu x dan y olehkarenaitudisebutsebagai operator biner.

Selain operator bineradajuga operator unary yang hanyamemerlukansatu operand saja, yaitu :

x++ atau ++x disebut operator increment (x=x+1)

x-- atau—x disebut operator decrement (x=x-1)

Kedua operator diatasakanseringdijumpaiterutamapadawaktu looping

dandapatjugasebagaibagiandariekspresi. Jika operator munculsebelum variable makahargaakhir

variable dipakaisebagaihargaekspresi, sedangkanjika operator munculsetelah variable harga variable

asaldipakaisebagaihargaekspresi, misalnya

x = 10; x = 10

y = ++a; (sekarangharga x = 11, y = 11) y = x++; (sekarangharga x = 11, y = 10)

Aturan Precedence

Operasiaritmatikaakandilaksanakanberdasarkanaturanpengurutansebagaiberikut :

Precedence tertinggi : ()

Precedence berikutnya: * / %

Precedence terrendah : + -

Sehinggapernyataan

rata_rata = a + b / 2.0;

akanmenghitung b/2.0 terlebihdahulubaruhasilnyaditambahkandengan a. Jika ingin a + b

dilakukanterlebihdahulumakaharusditulissbb :

rata_rata = (a + b) / 2.0;

Jikaadabeberapa operator aritmatika yang sederajatdalamsatuekspresi,

makaoperasiaritmatikaakandikerjakandariarahkirikekanan.

a * b /5 (samadengan (a * b)/5)

KonversiTipe Data

Konversi data secara implisit akandilakukanoleh program kompilasiapabilabeberapatipe data

dicampurdalamsuatuekspresi. Aturankonversiadalahsebagaiberikut :

1. Jikakedua operand bertipe integer makahasilakanbertipe integer

2. Jikasalahsatuataukedua operand bertipe float makahasilakanbertipe float

3. Jikaekspresi yang dievaluasibertipe integer sedangkan variabel hasilbertipe float maka integer

akandikonversiketipe float sebelum di diberikanke var iable hasil.

halaman | 3-21


4. Jikaekspresi yang dievaluasibertipe float sedangkan variabel hasilbertipe integer maka float

akandikonversiketipe integer sebelum di diberikanke variabel hasil.

Kasuskeempatakanmenyebabkankehilanganakurasikarenapembulatandari float ke integer. Contoh :

float varFloat = 4., varFloat2 = 3.,hasilFloat;

int varInt = 4, varInt2=3, hasilInt;

hasilInt = varInt * varInt2;

printf (―\nhasilInt = %d‖,hasilInt);

hasilFloat = varFloat / varInt2;

printf(―\nhasilFloat = %f‖, hasilFloat);

hasilFloat = varInt * varInt2;

printf(―\nhasilFloat = %f‖, hasilFloat);

hasilInt = varFloat / varInt2;

printf(―\nhasilInt = %d‖, hasilInt);

akanmenghasilkan output

hasilInt = 12

hasilFloat = 1.33333

hasilFloat = 12.0

hasilInt = 1

Operator Assignment

Pada pernyataan assigment kitatelahmengenal operator „=‟ sebagai operator assigment, misalnyapada

statement dibawahini :

a = a + b;

Pada C penulisandiatasdapat di persingkatdenganmenggunakansimplifikasi operator menjadi :

a+=b; yang artinyasamadengan a = a + b

dengananalogisepertidiatas operator assignment lainnya yang merupakanhasildisimplifikasiadalahsbb

:

a-=b; (a = a – b)

a*=b; ( a = a * b)

a/=b; ( a = a / b)

a%=b; ( a = a % b)

// Contoh3.1 : Program konversidari Fahrenheit keCelcius

#include <stdio.h>

main()

{

const float pengali = 5.0/9.0; // jika integer hasilnyaakan 0

const int pengurang = 32;

float fahr, cel;

printf(“Masukan temperaturdalamderajat Fahrenheit: “);

scanf (“%f”,&fahr);

cel = (fahr - pengurang) * pengali;

printf(“Temperatur %f Fsetaradengan %f C”,fahr,cel);

}

Operator LogikadanPembandingan

Jikakitaharusmelakukanpemrograman yang melibatkan proses

pengambilankeputusandanpengulangan, seringkitamemerlukan operator- operator berikut ini

halaman | 3-22



Simbol Keterangan

==

!=

<

<=

>

>=

&&

||

!

samadengan

tidaksamadengan

lebihkecil

lebihkecilatausamadengan

lebihbesar

lebihbesaratausamadengan

operator logika AND

operator logika OR

operator logika NOT

Operator-operator <, <=, >, >= disebut operator ketidaksamaansedangkan == dan != adalah

operator kesamaan. Operator ketidaksamaanmempunyaipreseden yang lebihtinggidibanding operator

kesamaaan. Tingkat preseden operator logikalebihrendah dibanding kedua operator diatas,

dandiantara operator logika&&memilikipreseden yang lebihtinggikemud iandiikutioleh || serta

!memilikipreseden yang terendah. Perbandingan, misalnya a < b,

merupakansebuahekspresidenganduakemungkinan, yang secaraintuitifdikatakansebagai true (benar)

and false (salah). Dalampemrograman C, bilanganinteger 1 dan 0 digunakanuntuktujuanitudimana:

1 berarti true

0 berarti false

Perbandingan (danekspesilogikapadaumumnya) mempunyaitipe int.

Dengandemikianekspresiberikutini :

(3<4) + (7<9)

Merupakanekspresi integer yang sah, danharganyaadalah 2. Yang lebihmenariklagiadalah

5<4<3

Ekspresidiatasdipahamisebagai : (5<4)<3 atausebagai0<3, sehingganilainyaadalah1. Operator unary

(!) umumnyadigunakanuntukmengubahtrue menjadi false:, dansebaliknya. Sebagaicontoh, harga -

hargadarikeduaekspresisebagaiberikutadalahsamauntuksemua x dan y;

x<y

! (x>=y)

Kita dapatmengkombinasikansejumlahperbandingandenganmenggunakan operator logika&&dan ||.

Denganmenggunakanbentuksbb:

operand1 && operand2

operand1 || operand2

sepertiditunjukkanpadacontohberikutini:

x>10 && x<2

untukmenyatakanbahwa x terletakantara 2 dan 10.

Tabel berikut ini menampilkan summary dari preseden semua operator

halaman | 3-23


Precedence Operator Description Associativity

1

++ -- Suffix increment and decrement Left-to-right

() Function call

[] Array subscripting

. Element selection by reference

-> Element selection through pointer

2

++ -- Prefix increment and decrement Right-to-left

+ - Unary plus and minus

! ~ Logical NOT and bitwise NOT

(type) Type cast

* Indirection

& Address-of

sizeof Size-of

3 * / % Multiplication, division, and modulus Left-to-right

4 + - Addition and subtraction

5 <<>> Bitwise left shift and right shift

6 <<= For relational operators < and ≤ respectively

>>= For relational operators > and ≥ respectively

7 == != For relational = and ≠ respectively

8 & Bitwise AND

9 ^ Bitwise XOR (exclusive or)

10 | Bitwise OR (inclusive or)

11 && Logical AND

12 || Logical OR

13 c ? t : f Ternary conditional Right-to-Left

14

+= -= Assignment by sum and difference

*= /= %= Assignment by product, quotient, and remainder

<<=

>>=

Assignment by bitwise left shift and right shift

&= ^=

|=

Assignment by bitwise AND, XOR, and OR

15 , Comma Left-to-right

Latihan :

1. Buatlah ekspresi dalam C untuk beberapa persamaan matematik dibawah ini : 2

2 324 ; ; * ( 2 )

bb ac a b c

ac

2. Buatlah program yang mengkonversi integer km ke m, cm dan mm

3. Berapa harga integer x pada ekspresi dibawah ini :

x = (34<65)&&(„a‟>‟b‟)+23-(„b‟<‟a‟)

4. Buatlah program beserta deklarasi variabelnya untuk menampilkan variabel a, b dan c yang

masing-masing diinisialisasi berturut-turut 2000, 40000, 100000

halaman | 4-24



Bab 4. FUNGSI INPUT DAN OUTPUT

Standar IO

Untuk memasukan input dari keyboard dan mengeluarkannya ke layarpada C dikenal standar io

dengan menggunakan header <stdio.h>. Pada standar io, pembacaan input dilakukan dengan

menggunakan perintah scanfmisalnya :

scanf(―%d‖,&a);

Sedangkan untuk output menggunakan perintah printf, seperti :

printf(―The value stored in a is %d‖,a);

Selain scanf, untuk input kita dapat juga menggunakan fungsi getchar(), sedangkan untuk output

selain menggunakan perintah printf, dapat juga kita gunakan fungsi putchar(). Sebenarnya masih ada

lagi beberapa perintah untuk input dan output, seperti gets, getch, getche, puts, putch dan putche.

Namun fungsi-fungsi diatas tidak termasuk kedalam printah standar ANSI-C sehingga hanya ada

untuk compiler tertentu saja.

Fungsi Input

Fungsi input merupakan fungsi yang akan menerima masukan data dari piranti standar input

(keyboard) untuk dikirimkan ke C untuk selanjutnya di olah oleh program C.

getchar (prototype : int getchar (voi d))

Fungsi getchar termasuk dalam standar io yang berfungsi untuk menerima masukan karakter dari

keyboard. Fungsi ini akan memanggil dan menunggu kiriman karakter dari keyboard, karakter yang

dimasukan lewat keyboard akan disimpan pada buffer terlebih dahulu dan buffer akan mengirimkan

ke fungsi getchar setelah tombol enter ditekan. Fungsi getchar hanya menerima satu karakter setiap

dipanggil. Fungsi getchar akan mengembalikan nilai integer yang merupakan kode ASCII dari karakter

yang diketikan pada keyboard. Perhatikan contoh program dibawah ini :

//Contoh 4.1 : penggunaan fungsi getch

#include <stdio.h>

main()

{

int ch;

printf(“ketikan karakter lalu akhiri dengan menekan enter\n”);

ch = getchar();

printf(“karakter yg diketikan adalah %c”,ch);

return 0;

}

Jika kita jalankan program diatas dan kita ketikan sebagai masukan

a lalu tekan enter

maka pada layar akan tercetak

karakter yg diketikan adalah a

Tapi jika kita ketikan

abcdefgh lalu tekan enter

maka pada layar akan tercetak

karakter yg diketikan adalah a

halaman | 4-25


Karena getchar hanya dipanggil satu kali maka yang ada di buffer hanya karakter „a‟, dan karakter ini

yang dikirim ke getchar ketika enter dite kan.

Untuk membaca satu baris kalimat menggunakan fungsi getchar dapat dilakukan dengan memanggil

fungsi getchar berkali-kali sampai enter ditekan, missal perhatikan contoh program berikut ini

//Contoh 4.2 : penggunaan fungsi getch

#include <stdio.h>

main()

{

int karakter;

while ((karakter = getchar()) != '\n') putchar(karakter);

return 0;

}

Jika kita ketikan sebagai input adalah

Ini sebuah String

maka dilayar akan ditampilkan

Ini sebuah String

Isi variabel karakter adalah

Karakter terakhir yang diberikan ke variable karakter adalah \n (ganti baris). Agar input dari getchar

dapat disimpan maka gunakan variable tipe string (array dari char) untuk menampungnya, seperti

diperlihatkan pada contoh program berikut ini

//Contoh 4.3: Menggunakan getchar() untuk masukan strings.

#include <stdio.h>

main()

{

char karakter, string[20];

int i = 0;

while ((karakter = getchar()) != '\n' && i < 19)

{

string[i] = karakter;//karakter diberikan ke string ke i

i = i + 1;//i di naikan

}

string[i] = '\0';//mengakhiri string

printf(“%s\n”, string);

}

scanf

Perintah scanf merupakan fungsi input yang terformat. Bentuk umum dari scanf adalah sbb:

scanf(format string, address list);

Format string pada scanf disarankan untuk tidak menggunakan konstanta string tapi hanya spesifikasi

field saja. Jika kita menuliskan konstanta string, maka pada waktu memasukan data harus dituliskan

konstanta string tersebut dengan urutan dan posisi yang sama. Misalnya program berikut ini :

//Contoh 4.4 : Penggunaan scanf

#include <stdio.h>

main()

halaman | 4-26



{

int x;

scanf(“Masukan nilai x=%d”, &x);

printf(“Nilai x adalah %d.\n”, x);

return 0;

}

Jika pada program diatas ingin ditampilkan Nilai x adalah 20, maka kita harus menuliskan pada

masukan Masukan nilai x=20. Jika hanya 20 saja yang kita ketikan maka akan dihasilkan output yang

tidak kita harapkan. Pada scanf, masukan yang diketikan lewat keyboard akan di ubah sesuai dengan

conversion-code-nya dan disimpan pada variabel yang dituliskan dalam format alamat

&nama_variabel.Karakter & menyatakan parameter alamat tempat isi variabel disimpan. Ketika

membaca bilangan integer dan floating, scanf akan mengabaikan whitespace yang mendahuluinya,

artinya space, tab dan baris baru akan diabaikan sampai dia membaca angka. Sedangkan ketika

membaca karakter (tipe char), whitespace tidak diabaikan dan dibaca sebagai bagian dari

karakter.Misalkan :

scanf(―%d%d%d%c‖, &x, &y, &z, &a);

Jika kita menuliskan pada input :

1 2 3A

maka harga x=1, y=2, z=3 dan a=‟A‟, namun jika kita masukan input sbb:

1 2 3 A

maka harga x=1, y=2, z=3 dan a=‟ ‟. Agar input diatas dapat dibaca dengan benar maka pada scanf

harus dimasukan space sebelum %c

scanf(―%d%d%d %c‖, &x, &y, &z, &a);

Sehingga kalau kita ketikan masukan

1 2 3 A

maka akan terbaca harga x=1, y=2, z=3 dan a=‟A‟. Untuk tipe integer dan floating :

scanf(―%d %d %d ―, &x, &y, &z);

adalah ekivalen dengan

scanf(―%d%d%d ―, &x, &y, &z);

Serta masukan berikut ini :

1

2

3

adalah ekivalen dengan

1 2 3

Jika width modifier digunakan, maka scanf akan membaca maksimum sebanyak width yang diberikan.

Contoh :

//Contoh 4.5 : Penggunaan format scanf

#include <stdio.h>

main() {

halaman | 4-27


int x; scanf(“%5d”, &x);

printf(“Nilai x adalah %d.\n”, x); return 0;

}

Jika kita nasukan input dengan berbagai panjang karakter maka akan diperoleh output sebagai

berikut :

input output

123

12345678

12 456

123

12345

12

scanf akan berhenti membaca nilai dari suatu variabel jika menemui :

1. Karakter whitespace

2. Jumlah maksimum karakter terlampaui

3. Karakter EOF

4. Erro terdeteksi.

Error dapat muncul misalnya pada perintah scanf(―%d‖, &x);kita masukan Hello Worldmaka error

akan muncul karena yang diminta adalah nilai integer sedangkan yang dimasukan adalah karakter.

Masalah utama dalam penggunaan scanf adalah cenderung untuk mengabaikan white spaces

(misalnya space) sehingga tidak reliable untuk kasus tertentu yang memerlukan input white spaces

misalnya string. Sehingga untuk string akan lebih baik jika menggunakan fungsi getstr() dibandingkan

memakai scanf.

Fungsi Output

Fungsi output akan menampilkan data yang dikirim dari C ke piranti standar output (layar).

putchar (prototype: int putchar(int c))

Fungsi putchar akan menampilkan karakter yang disimpan di C ke standar output (layar). Fungsi ini

merupakan fungsi yang menembalikan nilai integer dan memerlukan argument bernila i integer pula.

Bilangan integer ini merupakan representasi integer dari kode ASCII, jadi hanya bilangan integer yang

ada representasi karakternya saja yang akan ditampilkan ke layar Jika diberikan bilangan yang tidak

ada padaan karakternya maka akan terjadi error. Berikut ini adalah contoh program pemakaian

putchar() yang menerima argument bilangan integer 97 sampai 123 yang merepresentasikan huruf a

samapai z.

//Contoh 4.6 : penggunaan putchar()

#include <stdio.h>

main()

{

int i;

for (i=97; i<123; i++) putchar(i);

}

Seperti pada getchar, putchar hanya mengirim satu karakter setiap kali dipanggil, sehingga untuk

menampilkan deretan karakter atau string kita harus memanggil putchar sebanyak jumlah karakter

yang ada, seperti ditampilkan pada contoh program berikut ini.

halaman | 4-28



//Contoh 4.7 menampilkan string dengan putchar()

#include <stdio.h>

main()

{

int i;

char string[]=“String ditampilkan dengan putchar”;

for (i = 0; i < 100; i++) //loop untuk menampilkan string muali dari karakter pertama

{

if (string[i] == '\0') //test akhir dari string

{

putchar( '\n');

break;

}

else

putchar(s tring[i]); //tampilkan karakter berikutnya

}

}

printf

Fungsi printf merupakan fungsi untuk menampilkan data ke piranti standar keluaran (layar) secara

terformat. Fungsi printf harus selalu menggunakan parameter string (misal “Hello World”) sebagai

parameter pertamanya, setelah itu dapat diikuti oleh beberapa parameter dengan berbagai tipe. Jadi

fungsi printf harus berbentuk :

printf(format string, data list);

Format string ditulis diantara tanda petik dua dan berisi tek dan/atau spesifikasi field. Format string ini

sangat penting karena menentukan tipe variabel apa yang ada pada data list serta dalam format

bagaimana dia harus ditampilkan. Perintah printf akan men-scan format string dari kiri ke kanan dan

menampilkannya di layar atau divais lain sampai bertemu dengan karakter %. Karakter % merupakan

spesifikasi field yang menyatakan bagaimana menampilkan format variabel yang ada pada data list

berikutnya. Masing-masing spesifikasi field memiliki bentuk sbb :

%<flag(s)><width><.precision><size>conversion-code

Tanda % dan conversion-code harus ada sedangkan yang lain hanyalah optional. Conversion code yang

ada adalah sbb :

Tipe variabel Display

%c char karakter tunggal

%d (%i) int signed integer

%e (%E) float or double format exponential

%f float or double signed desimal

%g (%G) float or double gunakan %f atau %e sesuai keperluan

%o int unsigned nilai oktal

%p pointer address yg disimpan di pointer

%s array of char Barisan karakter atau string

halaman | 4-29


%u int unsigned desimal

%x (%X) int unsigned nilai hex

Conversion-codeakan mengkonversi variabel yang akan ditampilkan kedalam format yang sesuai

dengan conversion-code yang dipakai. Gunakanlah conversion-code sesuai dengan tipe variabel yang

akan ditampilkan agar tidak terjadi kesalahan.

Untuk optional size ada dua pilihan yaitu h, dan l, yang berturut-turut digunakan untuk menyatakan

short integer, dan long integer.

%hd /* short integer */

%ld /* long integer */

Pilihan flag antara lain :

Pemakaian flag # akan tergantung pada conversion code yang dipakai, misalnya :

%#o menambahkan karakter 0 didepan nilai octal

%#x menambahkan karakter 0x didepan nilai hex

%#f atau %#e untuk menyakinkan titik desimal di cetak

Pilihanwidth menyatakan jumlah karakter yang digunakan untuk menampilkan nilai, dan precision

menunjukan jumlah karakter yang digunakan setelah titik desimal, misalnya

%-10d akan menampilkan 10 karakter integer rata kiri

%+5d akan menampilkan 5 karakter integer dan tambahan tanda + atau -

%10.3f akan menampilkan 10 karakter (termasuk titik desimal dan tanda) dengan 3 angka

setelah titik desimal.

Jika nilai yang akan di tampilkan memiliki jumlah karakter lebih besar dibandingkan dengan width,

maka jumlah karakter yang ditampilkan akan sesuai dengan jumlah karakter nilai. Jadi width

menyatakan jumlah karakter terkecil yang akan ditampilkan.

printf(―angka =%1d\n‖, 15);




printf(―angka =%4ld\n‖, 100000);

printf(―angka =%7.2f\n‖, 1.2345);

printf(―angka =%+.2f\n‖, 1.2345);

printf(―angka =%.9f\n‖, 1.2345);

printf(―angka =%e\n‖, 21.2345);

printf(―angka =%.2e\n‖, 21.2345);

flag arti

-

+

space

0

#

left justify

selalu menampilkan tanda

tampilkan space jika tdk ada tanda

karakter yang kosong akan diisi 0

gunakan bentuk alternate dari jenis format

halaman | 4-30



Output :

angka =15

angka =15

angka = 15

angka =-31072

angka =100000

angka = 1.23

angka =+1.23

angka =1.234500000

angka =21.23450e+01

angka =21.230e+01

String yang akan kita bahas pada bagian yang lain merupakan deretan karakter. Untuk menampilkan

string dapat menggunakan %s seperti dibawah ini :

printf(―Hello World\n‖);

printf(―%s‖, ―Hello World‖);

printf(―%4s‖, ―Hello World‖);

printf(―%20s‖, ―Hello World‖);

printf(―%.4s‖, ―Hello World‖);

printf(―%20.8s‖, ―Hello World‖);

akan menghasilkan output :

Hello World

Hello World

Hello World

Hello World

Hell

Hello Wo

Karakter-karakter dibawah ini merupakan kode kontrol yang dapat dipakai untuk mengontrol

penampilan variabel pada layar :

\b backspace

\f formfeed

\n new line

\r carriage return

\t horizontal tab

\' single quote

\0 null

//Contoh 4.8 : Pengolahan bilangan float dan cara penampilan

#include <stdio.h>

main ()

{

int a = 20;

long b = 1234567890;

float c = 12345.123456789;

double d = 12345.123456789;

//menampilkan bilangan bulat 15 dan 1234567890

printf (“\nBilangan integer a = 20, b = 1234567890 \n”);

printf (“Berbagai macam cara penulisan dengan %%xd \n”);

printf (“dengan format %%1d a = %1d\n”,a);

halaman | 4-31




printf (“dengan format %%4d b = %4d\n”,b);

printf (“dengan format %%4ld b = %4ld\n”,b);

//menampilkan bilangan float bentuk xx.xx

printf (“\nBilangan float c = 12345.123456789 \n”) ;

printf (“Berbagai macam cara penulisan dengan x.xx \n”);

printf (“dengan format %%f c = %f\n”,c);

printf (“dengan format %%3.2f c = %3.2f\n”,c);

printf (“dengan format %%-.5f c = %-.5f\n”,c);

printf (“dengan format %%+.6f c = %+.6f\n”,c);

printf (“dengan format %%+.4e c = %+.4e\n”,c);

//menampilkan bilangan double bentuk xx.xx

printf(“\nBilangan double d= 12345.123456789 \n”);

printf(“Berbagai macam cara penulisan dengan x.xx \n”);

printf (“dengan format %%f c = %f\n”,d);

printf (“dengan format %%3.2f c = %3.2f\n”,d);

printf (“dengan format %%-.5f c = %-.5f\n”,d);

printf (“dengan format %%+.6f c = %+.6f\n”,d);

printf (“dengan format %%+.4e c = %+.4e\n”,d);

// perhatikan perbedaan bilangan dibelakang .xx

// antara float dan double

//Menampilkan string dengan berbagai format

printf(“\nString \” Ini contoh STRING\”\n”);

printf(“Ini contoh STRING\n”);

printf(“dengan format %%s : %s\n”, “Ini contoh STRING”);

printf(“dengan format %%4s : %4s\n”, “Ini contoh STRING”);

printf(“dengan format %%20s : %20s\n”, “Ini contoh STRING”);

printf(“dengan format %%.4s : %.4s\n”, “Ini contoh STRING”);

printf(“dengan format %%20.8s : %20.8s\n”, “Ini contoh STRING”);

return 0;

}

Stream io (hanya ada di C++)

Seperti yang telah disinggung pada bagian sebelumnya, header iostream.h. merupakan salah satu

preprocessor yang menyediakan fungsi input s tream dan output stream untuk menggunakan input-

output pada program C++.

Aliran Output (Output stream)

Dapat dibayangkan sebagai rangkaian karakter yang keluar dari program menuju peralatan output

standar.Peralatan output standar yang biasa digunakan pada komputer adalah layar monitor .

coutdipakai sebagai fungsi untuk menyatakan output stream dengan format sbb :

cout << Ekspresi atau String (<<Ekspresi atau String <<….) ;

Operator << berarti simpan data ke output stream. Operator << dapat dipakai berkali-kali

halaman | 4-32



Aliran Input (Input stream)

Dapat dibayangkan sebagai rangkaian akarakter yang datang ke dalam program kita dari peralatan

input standar.Peralatan input standar yang biasa digunakan pada komputer adalah keyboard .

cindipakai sebagai fungsi untuk menyatakan input stream dengan sintak sbb :

cin >> Variable (>>Variabel>>….) ;

Operator >> berarti ambil data dari input stream. Operator >> dapat dipakai berkali-kali

cin>>x>>y; ekivalen dengan

cin>>x;

cin>>y;

cin akan berhenti membaca nilai variabel sampai bertemu whitespace untuk tipe data integer dan

float, sedang untuk tipe data char hanya akan membaca satu karakter saja

Input data yang dimasukan harus sesuai dengan tipe variabel dalam pernyataan cin, jika tidak sama

dapat terjadi error, misalnya :

int i;

char c;

float f;

cin >> f; (jika kita ketikan integer, akan diubah ke float)

cin >> i; (jika kita ketikan float, akan terjadi error!)

cin >> c; (jika kita ketikan integer atau float, akan terjadi error!)

Perhatikan contoh program dibawah ini :

//Contoh 4.9

#include <iostream.h>

main()

{

int x;

float y;

char z;

cin>>x>>y>>z;

cout<<x<<“,”<<y<<“,”<<z;

return 0;

}

Jika kita masukan input sbb :

Keyboard cin

File Aliran

Input

cout Layar

Monitor

File Aliran

Output

halaman | 4-33


2 7.5 FTI

maka outputnya adalah :

2,7.5,F

Format output stream

Untuk mengatur format pada output stream dapat dilakukan dengan menggunakan output

manipulator sbb :

Manipulator Keterangan

dec

hex

oct

endl

ends

flush

Konversi ke bilangan desimal

Konversi ke bilangan hexadesimal

Konversi ke bilangan octal

Baris baru

Menyisipkan null xero pada string

Flush output stream

Selain itu dapat juga memanipulasi output dengan menggunakan manipulator berikut ini, namun

pada bagian header harus ditambahkan baris

#include<manipio.h>

Manipulator Keterangan

setbase (int n)

setw(int n)

setprecision(int n)

setfill(char)

setiosflags(flag)

resetiosflags(flag)

dgn flagnya :

ios::left

ios::right

ios::scientific

ios::fixed

ios::dec

ios::hex

ios::oct

ios::uppercase

ios::showbase

ios::showpoint

ios::showpos

Konversi ke base n (0=dec, 8=oct, 16=hex)

Setting lebar field

Setting floating point dengan n presisi

Setting dengan memasukan karakter

Setting format flag

Mereset format flag

Rata kiri

Rata kanan

Format angka dgn notasi scientific

Format anggka dengan desimal

Format bilangan desimal

Format bilangan hexadesimal

Format bilangan octal

Merubah scientif dan hexadesimal menjadi huruf besar

Mencetak base prefix (0x:hex, 0:octal)

Mencetak titik untuk menunjukan presisi

Mencetak tanda + atau -

Format penggunaan manipulator adalah sbb :

cout<<manipulator<<variabel<<variabel….;

Penulisan format manipulator untuk iosflag adalah sbb :

setiosflags(ios::flagname)

setiosflags(ios::flagname | ios::flagname)//untuk penggunaan lebih dari satu flag

//Contoh 4.10 :

#include<iostream.h>

main ()

halaman | 4-34



{

int angka=125;

cout<<“Angka desimal”<<endl

<<dec<<angka<<endl;

cout<<“Angka hexadesimal”<<endl

<<hex<<angka<<endl;

cout<<“Angka octal”<<endl

<<oct<<angka;

return 0;

}

akan menghasilkan output :

Angka desimal

125

Angka hexadesimal

7d

Angka octal

175

Output yang sama dapat pula diperoleh dari dua program berikut :

//Contoh 4.11 :


#include<iomanip.h>

main ()

{

int angka=125;


<<setbase(10)<<angka<<endl;

cout<<“Angka Hexadesimal”<<endl

<<setbase(16)<<angka<<endl;

cout<<“Angka Octal”<<endl

<<setbase(8)<<angka;

return 0;

}

atau program

//Contoh 4.12 :


#include<iomanip.h>

main ()

{

int angka=125;


<<setiosflags(ios::dec)<<angka<<endl;

cout<<“Angka Hexadesimal”<<endl

<<setiosflags(ios::hex)<<angka<<endl;

cout<<“Angka Octal”<<endl

<<setiosflags(ios::oct)<<angka;

return 0;

}

pernyataan dibawah ini :

halaman | 4-35


float x=125.1234567;

cout<<setprecision(6)<<x<<setprecision(11)<<endl;

cout<<setiosflags(ios::scientific) <<x<<endl;

cout<<resetiosflags(ios::scientific)<<setw(15)<<x<<endl;

cout<<setiosflags(ios::left)<<setw(15)<<x<<endl;

cout<<resetiosflags(ios::left)<<setfill('*')<<setw(15)<<x<<endl;

cout<< setiosflags(ios::showpos)<<x<<endl;

return 0;

akan menghasilkan output

125.123

1.251234567e+02

125.1234567

125.1234567

***125.1234567

+125.1234567

halaman | 5-36



Bab 5. KONTROL LOOP

Jika kita diminta untuk menampilkan Hello World sebanyak 5 baris, maka kita dapat melakukannya

dengan membuat program menggunakan aliran kontrol sequencial sbb:

//Contoh 5.1 :Program menampilkan Hello World dlm 5 baris

#include<stdio.h>

main()

{

printf(“Hello World\n”);

printf(“Hello World \n”);




}

Pada program diatas, kita menulis „printf (“Hello World\n”);‟ sebanya 5 kali, jumlah sebanyak ini belum

jadi masalah. Namun jika kita diminta untuk menampilkan Hello World 10 kali, 100, atau 1000 kali

apakah kita akan menuliskannya berulang -ulang sebanyak yang diminta?. Tentu saja kita tidak ingin

melakukannya. Untuk melakukan pengulangan didalam program C, selain aliran kontrol squencial,

dikenal juga control loop atau looping. Ada 3 jenis looping, yaitu while looping, do while looping dan

for looping

While looping

While looping digunakan untuk mengeksekusi blok pernyataan sepanjang suatu kondisi dipenuhi.

Jika kondisi tidak dipenuhi maka blok pernyataan tidak akan dieksekusi lagi. Sintak dari while looping

adalah sbb :

while (kondisi)

{

Blok pernyataan

}

Karena pengecekan kondisi berlangsung pada bagian paling atas, maka ada kemungkinan blok

pernyataan tidak pernah dieksekusi. Kondisi biasanya berupa pembandingan, kebanyakan yang

dibandingkan adalah variabel yang berfungsi sebagai counter yang menghitung jumlah pengulangan

dengan konstanta atau variabel yang membatasi jumlah pengulangan. Misalnya dalam kasus contoh

program menampilkan Hello World berulang-ulang seperti diatas dapat dilakukan dengan program

sebagai berikut:

//Contoh 5.2 :Program menampilkan Hello World dlm 5 baris dengan menggunakan

// while looping

#include<stdio.h>

main()

{

int x=0;

while (x<5) //selama x<5 dipenuhi pernyataan dlm {} akan dieksekusi

{


x++; //increment x

}

return 0;

halaman | 5-37


}

Dengan menggunakan program diatas, jumlah pengulangan berapa kalipun dengan mudah kita buat

hanya dengan menggati konstanta 5 dengan jumlah pengulangan yang kita inginkan.

do looping

Do looping pada dasarnya sama dengan whilelooping hanya pada do looping pengetesan kondisi

dilakukan dibawah. Do looping memiliki sintak sbb :

do{

Blok pernyataan

} while (kondisi);

Karena pengetesan dilakukan dibawah maka sedikitnya blok pernyataan telah dieksekusi satu kali

sebelum pengetesan kondisi dilakukan. Kondisi yang kita test bisa pembandingan yang simpel bisa

juga pembandingan yang komplek dengan melibatkan operator logika. (dalam pembandingan sama

dengan, kita harus menggunakan == bukan =). Misalnya kita diminta menebak suatu angka yang

akan dibangkitkan secara otomatis oleh program, kesempatan yang diberikan maksimum 5 kali. Untuk

membangkitkan angka random digunakan fungsi rand() dari stdlib.h

// Contoh 5.3 :Program menebak angka integer 0 sampai 10

#include<stdio.h>

#include<stdlib.h>//diperlukan untuk menggunakan rand()

main()

{

int angka, tebak, jml_tebakan=0;

angka=rand()%10; //Membangkitkan angka 0-10

printf (“Tebaklah angka integer yang digenerate program\n”);

do {

printf (“\nMasukan tebakan ke %d :”, jml_tebakan+1);

scanf (“%d”, &tebak);

jml_tebakan++;

}while((angka!=tebak)&&(jml_tebakan<5));

return 0;

}

Program diatas akan berhenti jika kita berhasil menebak dengan benar atau tebakan kita sudah

melewati 5 kali kesempatan. Untuk kasus yang pertama kita dapat mengetahui angka yang

dibangkitkan komputer berdasarkan tebakan terakhir kita, namun untuk kasus kedua kita tidak dapat

mengetahui apakah program berhenti karena tebakan kita benar atau karena kesempatan menebak

telah melewati 5 kali.

For Loopi ng

For looping dapat digunakan untuk mengeksekusi blok pernyataan untuk jumlah pengulangan yang

tetap.Sintak dari for looping adalah sbb :

for (inisialisasi;kondisi;aksi)

{

blok pernyataan

}

Misalnya program untuk menampilkan angka integer 1 sampai 10 dapat dilakukan dengan perintah

for(int i=1; i<=10;i++)

{

halaman | 5-38



printf (“%d \n”, i);

}

Kondisi pengetesan bisa saja tidak ada hubungannya dengan variabel yang diinisialisasi.Inisialisasi,

kondisi dan aksi dapat berbentuk simpel atau komplek dengan multiple inisialisasi, multipel aksi atau

pembandingan yang komplek.Selain itu inisialisasi, kondisi dan aksi merupakan optional boleh saja

tidak ada. Pada program dibawah ini looping akan berhenti jika jawab=N walaupun variabel yang

diinisiasi adalah i.

for (i = 1; jawab == 'Y'; i++)

{

printf (“%d \n”, i);

printf (“Teruskan (Y/N): “);

scanf (“%c”, &jawab);

}

Inisialisasi dan aksi melibatkan dua variabel x dan y.

for (x = 0, y = 50; y != x; x++, y--)

{

printf(“%d, %d\n”, x, y);

}

printf(“%d, %d\n”, x, y);

Program dibawah ini tanpa menggunakan aksi, namun tanda „;‟ tetap harus ditul iskan.

for (i = 1; jawab != 'N';)

{

printf(“%d\n”, i);

printf (“Teruskan (Y/N): “);


}

Untuk membuat program looping tanpa akhir kita dapat menggunakan program dibawah ini.

int i=1

for (;;)

{

printf(“%d\n”, i);

}

Program diatas akan berakhir apabila kita melakukan break (ctrl -break, dst.). Walupun inisialisasi,

kondisi dan aksi tidak dipakai, tapi tanda „;‟ tetap harus ada.

Latihan :

1. Buat program untuk menghitung mundur dari 10 sampai 1 dengan menggunakan ketiga looping

diatas.

2. Buat program untuk menghitung x! (faxtorial x) dimana x!=1*2*…*x dengan x adalah bilangan

integer positip.

halaman | 6-39


Bab 6. KONTROL PENCABANGAN

Pada waktu mengeksekusi sebuah kondisi sering kita memerlukan untuk memilih blok pernyataan

mana yang harus dikerjakan sesuai dengan kondisi yang ada, atau biasa disebut pencabangan. Untuk

keperluan pencabangan tersebut kita dapat menggunakan perintah if, if-elseatauswitch.

Pernyataan I f

Pernyataan if (if s tatement) biasa digunakan untuk mengeksekusi suatu pernyataan (boleh berupa

pernyataan yang komplek) apabila suatu kondisi dipenuhi, jika tidak dipenuhi pernyataan tersebut

tidak akan dieksekusi. Format pernyataan if adalah sbb :

if (kodisi) pernyataan;

Berikut ini adalah contoh pemakaian if statement.

// Contoh 6.1 :Program mencari angka terbesar dan terkecil dari 2 angka integer

#include <stdio.h>

main()

{

int angka1 , angka2;

printf(“\nMasukan angka ke 1: “);

scanf(“%d” , &angka1);

printf(“\n Masukan angka ke 2: “);

scanf(“%d” , &angka2);

if (angka1<angka2) printf(“\nAngka ke 1 lebih kecil dari Angka ke 2”);

if (angka2<angka1) printf(“\nAngka ke 2 lebih kecil dari Angka ke 1”);

}

Pernyataan I f-else

Pernyataan if hanya dapat mengeksekusi antau men-skip suatu pernyataan saja. Jika kita ingin

program memilih pernyataan mana yang harus dikerjakan dari dua pilihan pernyataan yang ada maka

kita harus menggunakan pernyataanif-else. Sintak dari pernyataanif-else adalah sbb :

if (kondisi)

pernyataan1;

else

pernyataan2;

Jika kondisi dipenuhi akan mengerjakan pernyataan1 jika kondisi tidak dipenuhi akan mengerjakan

pernyataan2. Sebagai contoh kita gunakan program yang telah dibicarakan pada bagian looping yaitu

program untuk menebak angka yang dibangkitkan program dengan kesempatan menebak maksimum

5 kali.Namun pada program yang telah dibuat ternyata ada masalah yaitu ada kasus dimana kita tidak

dapat mengetahui apakah program berhenti karena tebakan kita benar atau karena kesempatan

menebak telah melewati 5 kali. Untuk mengatasi hal tersebut kita dapat melakukannya dengan

menambahkan pernyataanif-else pada program yang telah dibuat Sehingga program yang telah

ditambah dengan pernyataanif-else menjadi :

// Contoh 6.2 :Program menebak angka integer 0 sampai 10

#include<stdio.h>

#include<stdlib.h>//diperlukan untuk menggunakan rand()

main()

{

int angka, tebak, jml_tebakan=0;

angka=rand()%10; //Membangkitkan angka 0-10

halaman | 6-40



printf (“Tebaklah angka integer yang dibangkitkan program\n”);

do {

printf (“\nMasukan tebakan ke %d : “, jml_tebakan+1);

scanf (“%d”, &tebak);

jml_tebakan++;

}while((angka!=tebak)&&(jml_tebakan<5));

if(angka==tebak)

printf(“\ntebakan anda tepatpada tebakan ke : %d”, jml_tebakan);

else

printf(“tebakan anda salah\n”);

return 0;

}

Dalam pernyataan if-else dapat berisi pernyataan if-else lagi sehingga membentuk pencabangan yang

lebih komplek. Misalnya pencabangan seperti berikut ini :

if (kondisi1)

if (kondisi2)

if (kondisi3)

pernyataan1;

else

pernyataan2;

else

pernyataan3;

else

if (kondisi)

pernyataan4;

else

pernyataan5;

Penggunaan Break dan Continue di dalam Loop

Pernyataan break digunakan untuk keluar dari program looping dengan mem-bypass ekspresi

terminasi yang normal. Jika pernyataan break ditemui di dalam loop, maka loop akan berhenti dan

program akan mengeksekusi pernyataan yang mengikuti loop tersebut. Pernyataan break dapat

digunakan di ketiga jenis looping.

Pernyataan break dapat digunakan dimana saja di dalam loop, namun gunakanlah break untuk hal

khusus saja dan jangan gunakan break untuk keluar loop pada keadaan normal. Break juga digunakan

didalam fungsi dan pernyataan case.

Pernyataan continue adalah kebalikan dari pernyataan break. Pernyataan continue akan memaksa

loop untuk mengeksekusi iterasi berikutnya dengan mem-bypass pernyataan yang ada antara

pernyataan continue dengan test kondisi. Pada loop while dan do-while loops, pernyataan continue

akan menyebabkan program loncat ke bagian pengetesan kondisi. Sedangkan pada kasus lo op for,

program akan mengeksekusi bagian aksi (increment). Contoh yang baik dalam pemakaian pernyataan

continue adalah untuk me-restart rangkaian pernyataan apabila ditemui error.

// Contoh 6.3 :Program mengurutkan bilangan genap dari 0 sd 100

#include <stdio.h>

main()

{

int x ;

for ( x=0 ; x<=100 ; x++)

halaman | 6-41


{

if (x%2) continue;

printf(“%d\n” , x);

}

}

Contoh program menggunakan break.

// Contoh 6.4 :Program menghitung pembagian

#include <stdio.h>

main()

{

int a,b; float c;char jawab;

for ( ; ; )

{

printf (“\nMasukan bilangan integer a :”);

scanf(“%d”, a);

printf(“\nMasukan bilangan integer b :”);

scanf(“%d”, b);

if ( b==0 ) break ;

c=a/b;

printf(“Hasil Pembagian %d/%d = %f\n”, a, b, c);

printf(“Teruskan (Y/N) ?”);

jawab = getchar();

if (jawab==‟N‟)break;

}

printf(“Akhir dari loop...\n”);

}

Switch

Pernyataan if-else dapat digunakan untuk menentukan pilihan diantara dua alternatif yang ada,

namun jika alternatif yang ada lebih dari dua maka pernyataan switch dapat digunakan untuk

menyelesaikan permasalahan ini. Bentuk sintak dari pernyataan switch adalah sbb :

switch(ekspresi)

{

case constant1: rangkaian pernyataan; break;



.

default: rangkaian pernyataan; break;

}

Ekspresi pada switch berisi suatu variabel yang akan dibandingkan terhadap beberapa harga

konstanta integer atau karakter yang menjadi label dari masing-masing case, jika harga yang sama

ditemukan maka rangkaian pernyataan yang berhubungan dengan label case tersebut akan dieksekusi

sampai bertemu break. Jika tidak ditemukan harga yang sama, maka case default akan dieksekusi.

Sebagai contoh :

// Contoh 6.5 :Contoh program pemakaian switch

#include <stdio.h>

main()

{

int i;

halaman | 6-42



printf(“Masukan bilangan integer antara 1 sampai 4”);

scanf(“%d”,&i);

switch (i)

{

case 1:

printf(“satu”);

break;

case 2:

printf(“dua”);

break;

case 3:

printf(“tiga”);

break;

case 4:

printf(“empat”);

break;

default:

printf(“bilangan tidak dikenal”);

} /* akhir dari switch */

}

Ekspresi bersyarat

Di samping pernyataan bersyarat (conditional s tatement), yang diawali dengan if , terdapat

juga ekspresi bersyarat yang menggunakan dua buah karakter „?‟, dan‟:‟. Ekspresi bersyarat ini

mempunyai bentuk sebagai berikut

ekspresi1 ?ekspresi2 : ekspresi3

Pertama-tama, ekspresi1 dievaluasi, jika benar maka ekspresi2 dikerjakan tapi jika salah maka

ekspresi3 yang dikerjakan. Dengan kata lain berdasarkan nilai ekspresi1 dilakukan pilihan

antara ekspresi2 dan ekspresi3. Pernyataan bersyarat dan ekspresi bersyarat berbeda tidak

hanya dalam penampilannya tetapi juga dalam penggunaannya. Keduanya digunakan dalam

konteks yang berbeda. Ekspresi bersyarat dapat digunakan dalam setiap ekspresi sedangkan

pernyataan bersyarat tidak demikian. Perhatikan contoh berikut ini:

z = 3*(a<b?a+l:b-1)+2;

Jika dituliskan dengan menggunakan pernyataan bersyarat maka kita harus menuliskannya

sebagai berikut:

if (a<b) z =3* (a+1) +2; else z =3* (b-1) +2;

atau dengan menggunakan variabel temporer t sebagai berikut:

if (a<b) t = a +1; else t = b -1;

z = 3*t + 2;

Format ekspresi bersyarat tampak lebih efisien dibandingkan dengan format pernyataan

bersyarat . Ekspresi bersyarat juga sangat berguna sebagai argumen fungsi. Misalnya pada sebuah

fungsi standar, seperti printf.Ekspresi bersyarat dapat digunakan dalam argumen untuk printf seperti

contoh berikut ini:

printf(―Bilangan terbesar antara a and b adalah ―, (a > b ?a : b));

Sebuah program yang ekivalen dengan fragmen program di atas tanpa menggunakanekspresi

bersyarat misalnya adalah sebagai berikut:

halaman | 6-43


printf (―Bilangan terbesar antara a and b adalah ―);

if (a>b) printf(―%d‖, a); else printf(―%d‖, b);

Perlu digaris bawahi di sini bahwa ada kasus-kasus di mana pernyataan bersyarat lebihbaik digunakan

dibandingkan ekspresi bersyarat, misalnya kasus dengan pernyataan yang merupakan bagian dari

pernyataan bersyarat yang cukup kompleks.

Operator Koma

Dua buah ekspresi yang dipisahkan oleh operator koma ditunjukkan dalam contoh berikut ini:

ekspresi1, ekspresi2

Kedua ekspresi itu dievaluasi sesuai dengan urutannya, dan harga dari keseluruhan sama dengan

ekspresi2. Konstruksi bahasa seperti ini akan berarti hanya jika ekspresi1 melakukan sesuatu, tidak

hanya sekedar sebuah harga. Berikut ini adalahcontoh dari hal tersebut :

// Contoh 6.6 :PENJUMLAHAN 1: Solusi berbasis operator koma.

#include <stdio.h>

main ()

{

int s=0, i;

printf (“Masukan Bilangan bulat serta akhiri dengan harga negative\n”);

while (scanf(“%d”, &i), i>0) s+=i;

printf(“jumlah s = %d\n”, s);

}

Program ini menghitung penjumlahan bilangan bulat positif yang diberikan melalui keyboard dan

diikuti oleh sebuah bilangan bulat negatif atau nol. Yang menarik dalam contoh ini adalah bahwa

ekspresi scanf(“%d”, i) terjadi dalam kurung mengikuti kata while meskipun tujuannya bukan untuk

menguji suatu loop. Cara lain dalam menuliskan program di atas adalah sebagai berikut:

// Contoh 6.7 :PENJUMLAHAN2: Solusi berbasis pernyataan break.

#include <stdio.h>

main ()

{

int s=0, i;

printf(“Masukan Bilangan bulat akhiri dengan harga negative\n”);

for( ; ; )

{

scanf(“%d”, &i);

if (i<0) break;

s += i;

}

printf(“jumlah s = %d\n”, s);

}

Mengakhiri Input Data Numerik

Dalam contoh sebelumnya barisan bilangan bulat dari keyboard diakhiri dengan sebuah bilangan

nonpositip. Kita mungkin ingin mengakhiri hal itu dengan cara lain, misalnya dengan kata END. Hal ini

dapat kita lakukan secara tradisional misalnya dengan cara sebagai berikut:

// Contoh 6.8 : PENJUMLAHAN 3: Data input diakhiri dengan kata END.

#include <stdio.h>

main ()

{

halaman | 6-44



int s=0, i;

printf(“Masukan Bilangan bulat akhiri dengan END\n”);

while (scanf(“%d” , &i)) s+= i;

printf(“jumlah s = %d”,s);

}

Pada saat scanf membaca sebuah bilangan bulat ia akan melanjutkannya dengan mengabaikan white -

space charakter sampai ditemui character yang bukan bilangan bulat. Akibatnya bila menemui huruf E

dari kata END ia akan mengakhiri pembacaannya.

halaman | 7-45


Bab 7. FUNGSI DAN PROTOTIPE

Pendahuluan

Fungsi didalam bahasa C/C++ adalah sama dengan apa yang disebut dengan subroutin atau

procedure yang dikenal pada bahasa pemrograman yang lain. Fungsi didalam pemrograman

diperlukan untuk :

1. Memecahkan masalah besar kedalam masalah yang lebih kecil, sehingga seorang pemerogram

dapat menuliskannya dalam bentuk fungsi-fungsi yang dapat di test keberhasilannya secara

terpisah.

2. Menangani pekerjaan yang sering dilakukan berulang -ulang.

3. Dapat menggunakan program yang telah dibuat orang lain (fungsi librari) sehingga kita tidak

perlu membuatnya lagi tinggal menggunakannya saja.

Selain menyediakan beberapa fungsi standar seperti fungsi-fungsi matematik, cin, cout dsb., C++

mengijinkan pemrogram mendefinisikan fungsi miliknya sendiri. Misalnya pada fungsi berikut ini

fungsi untuk menghitung jarak titik terhadap titik 0 pada koordinat x,y.

// Contoh 7.1 : fungsi menghitung jarak antara dua titik

float jarak(float x, float y) // Returns jarak koordinat (x, y) dari ttk pusat

{

float jarak; // var iable lokal

jarak = sqrt(x * x + y * y);

return jarak;

}

Fungsi diatas memiliki dua parameter input bilangan real x dan y, serta mengembalikan (return) jarak

ttk pusat ke ttk (x,y). Di dalam fungsi dideklarasikan variabel lokal (variabel yang hanya berlaku

didalam fungsi ini saja) jarak sebagai variabel untuk menyimpan hasil perhitungan sementara. Bentuk

umum dari definisi fungsi adalah sbb :

Tipe_fungsi nama_fungsi (list parameter)

{

definisi lokal;

implementasi fungsi;

}

Jika fungsi mengembalikan nilai maka tipe dari nilai harus dispesifikasikan oleh tipe fungsi, dapat

berupa int, float atau char. Jika fungsi tidak mengembalikan nilai maka tipe fungsi harus void.

Nama fungsi mengikuti aturan untuk identifier seperti untuk variabel atau konstanta.

List-parameter merupakan daftar parameter yang dipakai disertai tipe datanya.

Definisi lokal adalah variabel yang dideklarasikan di dlm fungsi dan akan digunakan pada bagian

implementasi fungsi.

Implementasi fungsi merupakan rangkaian statemen C yang mengimplementasikan efek dari

fungsi.

Fungsi tanpa Parameter

Fungsi yang tidak memiliki parameter biasanya tidak mengembalikan nilai tapi melakukan suatu

operasi. Tipe fungsi seperti ini digunakan untuk hal terbatas. Misalnya fungsi dibawah ini hanya

melakukan operasi mencetak “Belajar Bahasa C” dalam 2 baris :

halaman | 7-46



//Contoh 7.2 : Contoh prosedur mencetak 2 baris ―Belajar Bahasa C‖

void cetak2baris (void)

{

printf(“Belajar Bahasa C\n”);


}

Pada fungsi diatas kata void pertama digunakan untuk menyatakan fungsi tidak mengembalikan nilai

sedang void kedua yang berada dalam tanda kurung menyatakan bahwa fungsi ini tidak memiliki

variabel. Fungsi tersebut mengimplementasikan perintah printf (―Belajar Bahasa C\n‖) sebanyak2

kali. Karena tidak mengempalikan nilai maka fungsi diatas dalam pemakaiannya tidak dapat

digunakan dalam bentuk pernyataan assigment, tapi dipanggil dalam statement sbb :

cetak2baris();

Walupun tidak memiliki parameter namun tanda () harus dituliskan. Penulisan fungsi didalam program

dapat dilakukan dalam dua cara. Cara pertama menuliskan definisi fungsi sebelum fungsi main.

// Contoh 7.3 :Program penggunaan fungsi


{



}

main()

{

printf(“Cetak Bela jar Bahasa C 2 baris\n”);

cetak2baris();

printf(“Cetak Bela jar Bahasa C 2 baris lagi\n”);

cetak2baris();

}

Pada penulisan diatas terlihat bahwa sebelum ke program utama sepertinya terlalu banyak informasi

yang mendahuluinya, yang sebenarnya ingin menampilkan sebuah fungsi. Karena itu lebih baik jika

fungsi diletakan setelah program utama. Namun persoalan akan muncul ketika kita mengkompilasi

program, karena fungsi akan dikompilasi sebelum program kompilasi menemukan definisi fungsinya.

Untuk mengatasi hal tersebut diatas dapat dilakukan dengan menggunakan prototipe fungsi

(Function prototypes). Prototipe fungsi mememberi informasi mengenai tipe return dari fungsi dan

tipe parameternya. Prototipe fungsi diletakan sebelum program main. Definisi fungsi yang lengkap

diletakan setelah fungsi main atau dapat berada pada file lain yang dikompile terpisah dan di-link

program main. Prototipe fungsi merupakan pengulangan fungsi heading sehingga untuk program

contoh 7.3 diatas dapat dituliskan menjadi :

// Contoh 7.4 :Program penggunaan fungsi

void cetak2baris (void);//prototype

main()

{


cetak2baris();


cetak2baris();

}


halaman | 7-47


{



}

Fungsi prototipe dapat juga diletakan di dalam program main seperti deklarasi tipe data lainnya,

sehingga program diatas dapat dituliskan juga sbb:

// Contoh 7.4 (2) :Program penggunaan fungsi

main()

{

void cetak2baris (void);


cetak2baris();


cetak2baris();

}


{



}

Deklarsi fungsi pada cara pertama disebut deklarasi global, artinya kita hanya perlu mendeklarasikan

fungsi itu sekali saja tidak tergantung kepada jumlah fungsi yang memanggilnya. Misalnya jika ada

fungsi lain selain fungsi main() yang memanggil fungsi cetak2baris() maka kita tidak perlu

mendeklarasikannya pada fungsi yang memanggilnya. Deklarasi pada cara kedua memerlukan

pendeklarasian pada setiap fungsi yang memanggil fungsi tersebut. Misalnya jika ada fungsi lain yang

juga memanggil fungsi cetak2baris() maka kita perlu mendeklarasikan fungsi cetak2baris() itu didalam

fungsi yang memanggilnya.

Fungsi dengan Parameter

Berbeda dengan fungsi tanpa parameter, pada fungsi dengan parameter harus ada parameter yang

digunakan beserta tipenya. Misalkan pada kasus untuk mencetak 2 baris “Belajar Bahasa C” pada

contoh 7.4 diatas, kita hanya dapat melakukan mencetak 2 baris “Belajar Bahasa C” pada setiap

memanggil fungsi. Jika kita ingin mencetak “Belajar Bahasa C” dengan jumlah baris yang berbeda

sesuai dengan kebutuhan setiap kita memanggil fungsi, maka kita dapat melakukannya dengan

memasukan parameter int n sebagai penghitung jumlah baris yang harus dicetak, sehingga fungsi

yang harus dipakai akan memiliki bentuk :

void cetaknbaris (int n) // Fungsi mencetak n baris “ Belajar Bahasa C”pada output

{

int i; // nariabel local

for (i = 0; i < n; i++) // loop n kali


}

Seperti fungsi sebelumnya, fungsi diatas tidak me-return nilai sehingga digunakan tipe fungsi void,

namun pada kasus sekarang ada parameter int n yang akan menentukan jumlah baris “Belajar Bahasa

C” yang harus dicetak. Di dalam body fungsi ada variabel lokal i. Variabel lokal yang ada pada body

fungsi dapat menggunakan nama identifier yang sama dengan variabel lain ditempat yang lain.

Perubahan nilai di lokal variabel i tidak akan mempengaruhi variabel i di tempat lain. Sebaliknya

halaman | 7-48



perubahan variabel i di tempat lain tidak akan mempengaruhi nilai di lokal variabel i. Cara

pemanggilan fungsi diatas, sama dengan contoh sebelumnya hanya diberikan parameter integer n

saja. Parameter yang diberikan oleh program pada fungsi disebut argumen.

// Contoh 7.5 :Program penggunaan fungsi memakai parameter

#include <stdio.h>

void cetaknbaris (void);//prototype

main()

{


cetaknbaris(1);//1 adalah argumen


cetaknbaris(3);

}

void cetaknbaris (int n) // Fungsi mencetak n baris “ Belajar Bahasa C”pada output

{

int i; // variabel local

for (i = 0; i < n; i++) // loop n kali


}

Argumen yang diberikan ketika memanggil fungsi harus sama dengan tipe parameter pada definisi

fungsi, jika tidak maka akan terjadi error. Misalnya pada contoh 7.5 diatas jika kita panggil dengan

perintah :

cetaknbaris(3.0);

Akan menghasilkan error karena berbeda tipe parameter yang diberikan. Contoh lain dari fungsi yang

tidak mengembalikan nilai tapi memerlukan parameter adalah sbb:

// Contoh 7.6 :Program penggunaan fungsi memakai parameter

/* MAKSIMUM: Sebuah fungsi yang mencetak harga maksimum dari

tiga buah bilangan bulat. */

#include <stdio.h>

main()

{

int i, j, k;

void maks(int x, int y, int z); //fungsi prototipe

printf (“Masukan tiga buah bilangan integer: “);

scanf(“%d %d %d”,&i,&j, &k);

maks(i,j,k);

}

void maks(int x, int y, int z) //definisi fungsi

{

if (y>x) x=y;

if (z>x) x=z;

printf (“Harga maksimum dan ketiga bilangan itu: %d \n”, x);

}

halaman | 7-49


Fungsi yang Mengembalikan Nilai

Salah satu kegunaan dari fungsi adalah kemampuannya untuk menghasilkan suatu nilai. Dalam kasus

fungsi yang mengembalikan nilai, tipe fungsi merupaka n tipe nilai yang akan diberikan oleh fungsi.

Misalnya pada contoh 7.1, yang menghitung jarak titik koordinat ke pusat, kita dapat menjadikan

program tersebut menjadi fungsi seperti contoh dibawah ini :


{

float jarak; // variable lokal


return jarak;

}

Prototipe fungsi untuk fungsi diatas adalah sbb:

float jarak(float x, float y);// function prototype

Sebenarnya kita dapat juga menghilangkan nama-narna parameter di dalam fungsi seperti

float jarak(float, float);// function prototype

Tetapi kita lebih baik menuliskan nama-nama itu, pertama, mareka mungkin bermanfaat untuk

tujuan-tujuan dokumentasi, dan kedua, kompiler dapat menggunakan nama-nama itu untuk

tujuan error messages.

Penggunaan jarak sebagai variabel sementara untuk menyimpan hasil perhitungan tidak penting

karena untuk mengembalikan nilai kita bisa langsung melakukan perintah :

return sqrt(x * x + y * y);

Ketika fungsi di panggil, parameter formal x dan y diganti oleh argumen tipe float dalam urutan yang

sama. Karena fungsi mengembalikan nilai maka fungsi dapat digunakan dalam ekspresi.

Berikut ini contoh penggunaan fungsi diatas :

//Contoh 7.7 : Fungsi yang mengembalikan nilai tipe float

#include<stdio.h>

float jarak(float x, float y); // prototipe fungsi

main()

{

float a, b, c, d, x, y;

a = 3.0, b = 4.4, c = 5.1, d = 2.6;

x = jarak(a, b);

y = jarak(c, d);

printf (“jarak ttk (3.0,4.4) ke ttk pusat = %f \n”, x);

printf(“jarak ttk (5.1,2.6) ke ttk pusat = %f \n”, y);

}


{

float jarak; // variable lokal


return jarak;

}

halaman | 7-50



Satu fungsi bisa memiliki beberapa pernyataan return. Misalnya contoh-contoh program berikut ini :

//Contoh 7.8 : Fungsi menghitung akar

#include<stdio.h>

#include<math.h> // untuk memanggil fungsi library matematik.

float akar2(float x);

main()

{

float x, hasil;

char jawab;

do

{

printf(“Masukan bil. Riil untuk dihitung akarnya : “);

scanf(“%f”, &x);

hasil = akar2(x);

printf(“\nAkar dari %f = %f”, x. hasil);

printf(“\nLakukan perhitungan lagi ? (y/n) “);

scanf(“%c”, &jawab);

}while ((jawab=='Y')||(jawab=='y'));

return 0;

}

float akar2(float x) // fungsi menghitung untuk akar kuadrat x.

//Jika x < 0, hasilnya = 0.

{

const float toleransi = 1.0e-7; // 7 digit dibelakang koma

float x1, x2; //variabel lokal

if (x <= 0.0)

return 0.0; // untuk kasus <= 0

else

{

x1 = x; //pendekatan pertama

x2 = 0.5 * (x1 + x / x1); // pendekatan yang lebih baik

while (fabs((x1-x2)/x2) > toleransi) //fabs: fungsi untuk nilai absolut

{

x1 = x2;

x2 = 0.5 * (x1 + x / x1);

}

return x2;

}

} // akhir dari akar2

//Contoh 7.9 : Program menghitung x power n

#include<stdio.h>

#include<math.h>

float pangkat(float x, int n);

main()

{

float x, y;

int n;

char jawab='y';

while((jawab=='Y')||(jawab=='y'))

halaman | 7-51


{

printf (“Masukan bilangan riil dan integer : “);

scanf (“%f&d”, &x, &n);

y = pangkat(x, n);

printf (“\nHarga %f pangkat %d = %f”, x, n, y);

printf (“\nLakukan perhitungan lagi ? (y/n)”);


}

return 0;

}

float pangkat(float x, int n)

{

float hasil = 1.0;

int absn;

int i;

if ( n == 0)

return 1.0;

else

{

absn = int(fabs(n));

for (i = 1; i <= absn; i++)

hasil*=x;

if (n < 0)

return 1.0; // hasil;

else

return hasil;

}

} // end of power

Fungsi yang mengembalikan suatu harga dapat pula tidak memiliki parameter, misalnya seperti

contoh dibawah ini :

//Contoh 7.10 : Menggunakan sebuah fungsi tanpa parameter

#include<stdio.h>

double readreal(void);

main()

{

double xx;

float x;

printf (“\nMasukan sebuah bilangan riil : “);

xx = readreal();

printf (“Masukan lagi bilangan riil lainnya: “);

x = readreal();

printf (“Bilangan berikut ini telah dibaca : %f %f”, xx , x);

}

double readreal(void)

{

double x;

char ch;

while(!(scanf(“%1f”, &x)))

halaman | 7-52



{

do ch = getchar(); while (ch != „\n');

printf (“\nTidak benar. Masukan sebuah bilangan:\n” ) ;

}

return x;

}

Variabel lokal, Global dan Scope Operator

Variabel-variabel yang kita gunakan dalam sebuah fungsi dapat tersifat lokal maupun global.

Sebuah variabel bersifat lokal jika hanya dideklarasikan dan digunakan di dalam fungsi tersebut.

Sebagai pegangan umum, variabel selalu lokal kecuali ji ka keadaan menuntut lainnya. Sedangkan

variabel global selalu harus dideklarasikan. Berikut ini adalah contoh sederhana yang

menggambarkan hal tersebut

//Contoh 7.11 : variabel global dan lokal

#include<stdio.h>

int i; //deklarasi i sbg variabel global

void print_i(); // fungsi prototipe

main()

{

i = 123; //tdk perlu deklarasi int i, krn i adalah var global

print_i();

}

void print_i()

{

printf(“%d \n”, i);

}

Karena kita telah mendefinisikan i sebelum fungsi print_i dan main, maka kita dapat menggunakannya

di kedua fungsi itu. C++ memungkinkan kita untuk menggunakan sebuah variabel global bahkan di

dalam sebuah fungsi di mana suatu variabel lain dengan nama yang sama didefinisikan. Kita dapat

memberikan indikasi bahwa yang dimaksud adalah variabel global dengan cara menuliskan scope-

resolution-operator „::‟ di depan nama variabel seperti yang diberikan dalam contoh berikut ini:

//Contoh 7.12 : Penggunaan scope-resolution-operator


int i=l; //global variabel

main()

{

int i=2; //lokal variabel

cout<< ::i <<endl; // Output: 1 (variabel global)

cout<< i <<ends; // Output: 2 (variabel lokal)

}

Titik dua sebanyak dua kali „::‟ juga akan digunakan didalam kelas, seperti yang akan ditemui nanti

pada modul-modul selanjutnya.

Penggunaan global variabel harus hati-hati karena semua fungsi yang memanggilnya dapat merubah

harganya sehingga dapat menjadi sumber kesalahan yang susah dilacak. Misalnya perhatikan contoh

dibawah ini :

//Contoh 7.13 : Perubahan harga global variabel

#include<stdio.h>

int i=3; //global variabel

halaman | 7-53


void fungsi();

int main()

{

printf(“%d \n”, i); // Output: 1 (i global)

i+=2;

printf(“%d \n”, i);// Output: 1 (stl expresi dr main)

fungsi();

printf(“%d \n”, i);// Output: 2 (stl ekspresi dari fungsi)

return 0;

}

void fungsi()

{

i*=5;

}

Pass by Value, Pass by Parameter dan Pass by Address

Sampai saat ini parameter-parameter fungsi dapat dianggap sebagai variabel – variabel lokal yang

memperoleh harga awal dari argumen-argumennya. Prinsip ini tidak memungkinkan kita untuk,

misalnya. menuliskan sebuah fungsi yang menukarkan harga-harga dua buah variabel yang dilalukan

via argumen-argumennya. Misalnya jika kita coba hal itu dengan menggunakan cara sebagai berikut

ini:

void tukar_value(int x, int y) // Pass by value

{

int temp = x;

x = y; y= temp;

}

Jika kita panggil fungsi dengan pernyataan :

tukar_value(i, j)

Harga integer i dan j tidak akan tertukar, meskipun di dalam fungsi harga-harga x dan y

dipertukarkan, tetapi argumen-argumen i dan j hanya digunakan satu kali saja, yaitu untuk memberi

harga (value) awal parameter-parameter x dan y. Setelah pertukaran itu, harga-harga baru x dan y

tidak disampaikan ke i dan j lagi. Pemberian harga parameter dari i dan j ke parameter x dan y pada

fungsi diatas disebut pass by value.

Untuk melakukan parameter seperti yang diinginkan pada program diatas dapat dilakukan dengan

menggunakan reference (pass by reference) atau dengan menggunakan alamat (pass by address).

void tukar_reference(int*x, int*y) // Pass by reference

{

int temp = *x;

*x = *y; *y= temp;

}

Perhatikan penggunaan operator pointer * pada fungsi tukar_reference(int *x, int *y). *x dan *y

merupakan pointer yang menunjuk pada variabel asalnya. Perubahan pada isi pointer akan merubah

pula variabel asalnya, sehingga ketika pernyataan tukar_reference(&i,&j) dieksekusi maka variabel *x

sinonim dengan i dan variabel *y sinonim dengan j. Perubahan haraga *x dan *y akan merubah harga i

dan j. Contoh berikut ini lebih memperjelas mengenai konsep reference parameters atau reference

variables:

halaman | 7-54



//Contoh 7.14 : Contoh penggunaan sebuah variabel acuan .

#include <stdio. h>

main()

{

int i, &x =i; //&x reference dari variabel i

i = 2; x*= 100; //perubahan pada I atau x akan merubah harga keduanya

printf (“Harga i sekarang adalah: %d\n”, i);

printf (“Dengan menggunakan x diperoleh i = %d\n”, x);

}

//Contoh 7.14 : Contoh penggunaan sebuah variabel acuan.

#include <stdio.h>

main()

{

int *i, x;

i = &x; //i menunjuk ke x

x = 2; //isi alamat yg ditunjuk i yaitu x dgn 2

*i *= 100; //perubahan x akan merubah harga *i juga

printf ("Harga x sekarang adalah: %d\n", x);

printf ("Dengan menggunakan *i diperoleh x = %d\n", *i);

}

Yang paling menarik untuk disimak dari program ini adalah bahwa x *= 100 yang sebenarnya adalah

mengalikan *i dengan 100. Output dari program ini adalah :

Harga x sekarang adalah: 200.

Dengan menggunakan *i diperoleh x = 200.

Dalam pembahasan di atas kita menemui sebuah operator unary: & dan * yang bersifat inversi satu

terhadap lainnya yaitu:

OPERATOR ARTI

& Alamat dari

* Isi dari

Alamat adalah sebuah bilangan yang secara permanen dinyatakan sebagai atau diasosiasikan dengan

sebuah lokasi memori. Operator * dikenal dengan nama pointer yaitu tipe variabel khusus yang berisi

alamat memori. Pointer akan dibahas lebih lanjut pada bagian berikutnya. Karena * merupakan inverse

dari & maka ekspresi *&i tidak lebih dan sekedar suatu cara yang berlebihan untuk menuliskan i.

Pada fungsi tukar_reference, nilai-nilai dari x dan y adalah alamat-alamat dan suatu lokasi tertentu,

serta *x dan *y menyatakan isi dari lokasi-lokasi itu. Karena kita berhubungan dengan alamat dart

variabel int maka *x dan *y mempunyai tipe int sehingga dideklarasikan sebagai:

int *x, int *y

Contoh program penggunaan ketiga fungsi diatas adalah sbb :

//Contoh 7.15 :Pass by reference

#include<stdio.h>

main()

{

void tukar_value(int x, int y);

void tukar_reference(int *x, int *y);

halaman | 7-55


int i = 2, j = 7;

printf (“Harga i = %d Harga j = %d\n”, i, j);

tukar_value(i, j);

printf (“Harga setelah tukar_address\n”);


tukar_reference(&i, &j);

printf (“Harga setelah tukar_reference\n”);


}

void tukar_value(int x, int y) // Pass by value

{

int temp = x;

x = y; y= temp;

}

void tukar_reference(int*x, int*y) // Pass by address

{

int temp = *x;

*x = *y; *y= temp;

}

Function Overloading

Misalkan kita memerlukan fungsi untuk merubah temperatur dari Fahrenheit ke Celsius.

voidUbahFToC(float f, float&c); //Deklarasi Prototype

voidUbahFToC(float f, float&c) //Definisi fungsi

{

c = (f - 32.) * 5./9.;

}

Sekarang misalkan kita harus juga merubah temperatur untuk tipe data integer. Mungkin kita masih

dapat mendefinisikan fungsi dengan nama yang berbeda, misalnya :

void fUbahFToC(float f, float &c);

void iUbahFToC(int f, int &c);

Namun jika sekarang perlu juga menghitung untuk tipe data misalkan double, short serta long, maka

kita harus mendefinisikan fungsi sbb:

void fUbahFToC(float f, float &c);

void iUbahFToC(int f, int &c);

void dUbahFToC(double f, double &c);

void lUbahFToC(long f, long &c);

void sUbahFToC(short f, short &c);

Nama-nama diatas mungkin akan sulit untuk diingat sehingga sangatlah membingungkan karena

fungsi yang dipakai semuanya melakukan penghitungan yang sama hanya berbeda tipe datanya saja.

Beruntung sekali fungsi overloading memberikan alternatif yang lebih baik. Untuk fungsi yang hanya

berbeda jumlah dan tipe datanya saja dapat menggunakan nama yang sama. Fungsi yang mana yang

akan dikerjakan akan dipilih oleh kompiler sesuai dengan tipe dan jumlah parameter yang diberikan.

Untuk kasus diatas hanya tipe parameter saja yang berbeda, pemilihan fungsi akan dilakukan oleh

kompiler berdasarkan tipe parameter yang diberikan kepada fungsi. Fungsi overloading hanya dapat

dijalankan di C++, tidak untuk di C.

halaman | 7-56



Solusi untuk permasalahan perubahan temperatur dari Fahrenheit ke Celsius dapat dilakukan dengan

menggunakan program sbb:

//Contoh 7.16 : Penggunaan fungsi overloading

#include <iostream.h>

void UbahFToC(double f, double&c);

void UbahFToC(float f, float&c);

void UbahFToC(int f, int&c);

int main()

{

double df, dc;

float ff, fc;

int i_f,i_c;

df = 75.0;

ff = 75.0;

i_f = 75;

printf (“Memanggil versi double\n”);

UbahFToC(df,dc);

printf(“%lf == %lf\n \n”, df, dc);

printf (“Memanggil versi float \n”);

UbahFToC(ff,fc);

printf(“%f == %f\n \n”, ff, fc);

printf (“Memanggil versi integer\n”);

UbahFToC(i_f,i_c);

printf(“%d == %d\n \n”, i_f, i_c);

}

void UbahFToC(double f, double&c)

{

printf (“Dalam versi double\n”);

c = (f - 32.0) * 5. / 9.;

}

void UbahFToC(float f, float&c)

{

printf (“Dalam versi float\n”);

c = (f - 32.0) * 5. / 9.;

}

void UbahFToC(int f, int&c)

{

printf (“Dalam versi integer\n”);

c = (f - 32) * 5. / 9.;

}

halaman | 7-57


Fungsi Li brary Standard

Beberapa “commands” di dalam C/C++ sebenarnya bukan “commands” tetapi fungsi. Misalnya printf

dan scanf adalah fungsi untuk output dan input, selain itu banyak fungsi-fungsi lainnya yang sudah

disediakan oleh kompiler sebagai fungsi librari standar, diantaranya adalah :

stdio.h: fungsi I/O:

getchar() menghasilkan karakter berikunya yang diketikan pada keyboard.

putchar() menampilkan karakter tunggal pada

printf() seperti yg telah dijelaskan sebelumnya

scanf() seperti yg telah dijelaskan sebelumnya

string.h: fungsi String :

strcat() menggabungkan str2 ke str1

strcmp() membandingkan dua strings

strcpy() mengcopy isi str2 ke str1

ctype.h: fungsi karakter :

isdigit() menghasilkannon-0 jika arg adalahangka 0 sampai 9

isalpha() menghasilkan non-0 jika arg adalahhuruf alphabet

isalnum()menghasilkan non-0 jika arg adalahhuruf atau angka

islower() menghasilkan non-0 jika arg adalahhuruf kecil

isupper() menghasilkan non-0 jika arg adalahhuruf besar

math.h: fungsi Mathematik :

acos() menghasilkan arc cosine dari arg

asin()menghasilkan arc sine dariarg

atan()menghasilkan arc tangent dariarg

cos() menghasilkan cosine dariarg

exp() menghasilkan natural logarithim e

fabs() menghasilkan absolute value darinum

sqrt() menghasilkan square root darinum

time.h: fungsi waktu dan tanggal :

time() menghasilkan waktukalender sistem

difftime() menghasilkan perbedaan dalam detik antara dua waktu

clock() menghasilkan jumlah siklus sistem clock sejak program dijalankan

stdlib.h: fungsi Miscellaneous functions

malloc() menyediakan dynamic memory allocation

rand() menghasilkan bilangan random

srand() digunakan untuk menset titik awal rand()

halaman | 8-58



Bab 8. ARRAY, POINTER DAN STRING

Array dan Aritmatika Alamat

Jika program kita memerlukan 5 buah data dari tipe data yang sama misalkan integer, maka kita dapat

mendeklarasikan lima variabel untuk masing-masing data tersebut. Namun lain ceritanya jika data

yang kita perlukan adalah 100 buah data integer. Kita tidak mungkin mendeklarasikan 100 buah

variabel bertipe integer. Untuk mengatasi sekumpulan data yang memiliki tipe data yang sama, maka

kita dapat menggunakan array.

Array adalah struktur data yang digunakan untuk menyimpan sekumpulan tipe data sejenis secara

sekuensial di dalam memori. Array satu dimensi dapat dibuat dengan menggunakan deklarasi array

seperti dibawah ini;

<tipe data><nama variable>[ukuran]

dimana ukuran merupakan jumlah data yang dapat disimpan pada array, misalnya

int data[100];

dengan dekalarasi ini kita memiliki variable-variabel: data [0], data [1], …, data [99]

Konstanta 100 dalam deklarasi itu menyatakan bahwa terdapat 100 elemen array, tetapi dimulai dari

data[0] sehingga elemen terakhir adalah data [99] bukan data[100]. Dalam hal ini tipe data elemen

array itu adalah integer. Selain dengan menggunakan bilangan bulat, elemen array dapat juga diakses

melalui sebuah ekspresi yang hasilnya bilangan bulat, seperti dalam bentuk di bawah ini:

k = 50 * a[3*i + j/2] – 1;

dengan catatan bahwa 3*i+j/2harus lebih kecil dari 100 dan tidak negatif. Nilai yang berada dalam

tanda kurung disebut subscript dan harus mempunyai tipe integer tidak peduli apapun tipe data

elemen array-nya.Dalam deklarasi itu dimensi 100 hanya sekedar contoh tetapi kita harus senantiasa

menuliskan dimensi array sebagai konstanta. Jika kita mengisikan data pada array melebihi dimensi

yang dideklarasikan maka akan terjadi error.

Array dapat diinisialisasi ketika deklarasi atau setelah deklarasi, seperti pada contoh dibawah ini

int data_int[3] = {2 ,4, 6};//inisialisasi bersamaan dengan deklarsi

atau int data_int[5];// deklarsi

data_int[0] = 2;//inisialisasi

data_int[1] = 4;

data_int[2] = 5;

Akses data elemen array dapat dilakukan dengan memanggil array beserta indek elemen data yang

ingin diakses, misalnya untuk mengakses nilai pada elemen array data_int ke 2 dan memberikannya ke

variable a, maka kita tuliskan dalam bentuk a = data_int[2]

Seperti sudah dibahas sebelumnya ekspresi &z, merupakan alamat dari variabel z. Selain ekspresi

tersebut, terdapat jenis ekspresi lainnya yang jika dievaluasi juga menghasilkan alamat. Salah satunya

adalah nama dari array, ditulis tanpa kurung. Alamat yang diperoleh dengan cara ini adalah elemen

pertama dari array tersebut. Sebagai contoh, setelah deklarasi ini:

doubledata[50];

kita dapat menggunakan data, tanpa diikuti dengan [..], sebagai ringkasan dari &(data[0]), yang dapat

dituliskan sebagai &data[0]. Ekspresi lainnya yang harganya juga merupakan alamat adalah data + i, di

mana i adalah bilangan bulat, Dalam hal ini alamat itu adalah data[i] dan dengan demikian kita

mempunyai ekivalensi seperti berikut ini:

halaman | 8-59


data= &data[0]

data + i =&data[i]

Perhatikan sebuah int array sebagai berikut:

charstring[10];

Di sini alamat-alamat string dan string + i terpisah sejauh bilangan bulat i. Maka ekivalensi seperti

berikut ini:

string +i = &string[i]

juga berlaku untuk setiap array. Kedua baris berikut ini juga ekivalen:

for (i=0; i<10; i++) printf(―%7d‖ , string[i]);

for (i=0; i<10; i++) printf(―%7d‖, *[string+i] );

Juga dimungkinkan untuk mengurangi sebuah bilangan bulat dan sebuah alamat seperti contoh

berikut ini:

&string[5] - 3

Ingat bahwa &string[9] dapat dituliskan pula sebagai string + 5 maka pengurangan di atas akan

menghasilkan s tring + 2 yang dapat dituliskan setagai &string[2]. Kita dapat juga mengurangkan

sebuah alamat dari alamat yang 1ainnya. Jadi misalnya

&string[7] - &string[5] = (string + 7) - (string + 5)

hasilnya adalah 2.

Kita mempunyai akses ke semua elemen array jika kita tahu alamat dari elemen pertamanya.

Oleh karena itulah dalam C tidak diperlukan mekanisme parameter passing untuk array. Perhatikan

contoh sebuah program berikut ini:

/* Contoh 8.1 : Mencari elemen terkecil dan sebuah arraybilangan bulat. */

#include <stdio. h>

main()

{

int data[10], minimum(int *a, int n), i;

printf (“Masukan 10 bilangin bulat: \n”);

for (i=0; i<10; i++) scanf(“%d”,&data[i]);

printf(“\nHarga minimum dari bilangan itu %d \n”, minimum(data, 10));

}

int minimum(int *a, int n)

{

int small, i;

small = *a;

for (i=1; i<n; i++) if (*(a+i) <small)

small = *(a+i);

return small;

}

Dari pembahasan sebelumnya kita tahu bahwa int *a berarti bahwa a menyatakan alamat sebuah

bilangan bulat. Argumennya, yaitu table, merupakan alamat dari table[0], yang memberi implikasi

bahwa kedua panggilan di bawah ini adalah ekivalen:

minimum(&table[0], 10)

minimum(table, 10)

halaman | 8-60



Dari contoh 8.1 fungsi minimum di atas jelas bahwa aritmatika alamat telah digunakan. Kita dapat

saja menuliskan kembali program di atas dengan cara konvensional sehingga mungkin lebih

mudah dibaca karena kebiasaan menggunakan notasi array konvensional. Perhatikan penulisan di

bawah ini:


{

int small,

small = a[0];

for (i=l; i<n; i++)

if (a[i] < small) small = a[i];

return small;

}

Kita bahkan dapat lebih menekankan lagi sifat alami array dari a dengan mengganti baris pertama

dari fungsi itu dengan:

int minimum(int a[], int n)

Perhatikan bahwa panjangnya array dikosongkan dalam a[]. Jika panjang itu kita tuliskan maka ia jelas

sekedar merupakan konstanta dan dengan demikian fungsi itu menjadi tidak bersifat umum dan

kurang elegan.

Arrays Multi dimensi

Misalnya kita diminta untuk melakukan penjumlahan matrik sbb :

1 2 5 6 1 2 5 6, ,

3 4 3 9 3 4 3 9A B C A B

Kalau hanya menggunakan array satu demensi saja kita tidak bisa mengerjakan penjumlahanmatrik-

matrik dua dimensi diatas, untuk itu harus digunakan array multidimensi yang pemakaiannya diijinkan

oleh C. Array multidimensi misalnya dalam kasus diatas dapat dilakukan dengan definisi sbb:

//Contoh 8.2 : Penjumlahan matrik

#include <stdio.h>

main()

{

int A[2][2] = {{1,2},{3,4}};//inisialisasi matrik A

int B[2][2];

int C[2][2];

int i,j;

for(i=0;i<2;i++) //inisialisasi matrik B dari keyboard

for(j=0;j<2;j++)

{

printf("\nB$%d,%d$ = ",i,j);

scanf(“%d%”,B[i][j]);

}

printf(“\n”);

//penjumlahan matrik

for(i=0;i<2;i++)

for(j=0;j<2;j++)

C[i][j]= A[i][j]+ B[i][j];

halaman | 8-61


//Menampilkan matrik C

printf(“Matrik C =\n”);

for(i=0;i<2;i++)

{

for(j=0;j<2;j++)

printf(“%d \n”, C[i][j]);

}

}

Pointer

Pointer adalah variable yang menyimpan alamat pada C. Pointer memberikan programmer power dan

utilitas yang besar untuk mengakses dan memanipulasi data dengan cara yang tidak ditemui pada

bahasa pemrograman lainnya. Pointer juga sangat berguna untuk passing parameter kedalam fungsi

yang memungkinkan fungsi untuk memodifikasi dan mengembalikan nilai pada routine yang

memanggilnya.Tapi jika penggunaannya tidak benar, pointer dapat menjadi sumber kesalahan

program dan frustasi programmer.

Ketika program dieksekusi, seluruh variabel disimpan dalam memori yang masing-masing memiliki

alamat yang unik.Variabel dan alamat memori yang diasosiasikannya berisi nilai data. Misalnya

int hitung = 2;

Harga “2” disimpan didalam memori dan dapat diakses dengan menggunakan nama variabel hitung.

Pointer merupakan tipe variabel spesial yang menyimpan alamat memori bukan isi dari memori.

Seperti juga pada variabel lainnya, nilai alamat yang disimpan pada pointer akan termodifikasi jika

variabel pointer dimanipulasi.

Biasanya alamat yang disimpan pada pointer adalah alamat variabel lain, dan pointer biasa di

deklarasikan serta diinisialisasi sebagai berikut :

int *ptr; // deklarasi

ptr = &count //inisialisasi – simpan alamat variabel count di dlm ptr

Untuk melihat harga dari lokasi memori yang disimpan pada pointer, pointer harus di- dereference

dengan menggunakan operator „*‟

int total;

total = *ptr; // Nilai dari alamat yang disimpan di ptr diberikan ke total

Jika kita mendeklarasikan :

int *p

maka p merupakan sebuah variabel pointer, atau pointer saja untuk singkatnya. Kita menggunakan

pointer untuk menyimpan alamat sebagaimana halnya kita menggunakan variabel aritmatika

untuk menyimparn angka. Pointer dapat digunakan sebagai parameter seperti dalam contoh ini:


maupun sebagai variabel pada umumnya, misalnya pada program berikut ini:


{ int small, *p,

small = *a;

for (p = a+1; p < a+n; p++)

if (*p < small) small = *p;

return small;

}

halaman | 8-62



Harga dari p adalah sebuah alamat dan isinya dinyatakan oleh *p. Pada mulanya p diberi harga a+1

yaitu alamat dari a[1]. Di sini kita asumsikan bahama fungsi minimum dipanggil dengan menggunakan

minimum(table, 10)

Dengan menambah p kita bergerak ke elemen berikutnya, sampai penambahan itu menyebabkan p

sama dengan a + n, maka p sama dengan alamat lokasi memori elemen terakhir yaitu table[n-1].

Hal lain yang perlu disampaikan di sini adalah bahwa setelah mendeklarasikan sebuah pointer, misal p,

kita tidak boleh menggunakan *p sebelum memberikan sebuah harga pada p. Jika kita paksakan

maka ada kemungkinan akan terjadi kesalahan yang amat serius. Program berikut ini memberikan

contoh mengenai kesalahan tersebut:

main()

{

char *p, ch;

*p = „A‟;

}

Kesalahan ini amat serius harga p yang tidak terdefinisi digunakan dan dipahami sehagai suatu alamat

dan selanjutnya isi dari alamat tersebut diubah. Hal ini mungkin akan menyebabkan hilangnya

sejumlah informasi dalam memori. Dalam contoh ini sangat mudah untuk mengoreksinya yaitu

dengan memasukkan pernyataan koreksi sehingga program menjadi sebagai berikut:

main()

{

char *p, ch;

p = &ch;

*p = „A'

}

Kita juga dapat menggunakan sebuah pointer sebagai sebuah array tetapi sekali lagi hal ini hanya

mungkin setelah kita memberinya sebuah nilai yang tepat. Perhatikan contoh berikut ini:

main()

{

char s[10], *p,

p = s;

p[9] = „A';

}

Dalam program di atas deklarasi s mengalokasikan 10 bytes untuknya.Sebagai kontras hanya tersedia

sebuah lokasi dalam pendeklarasian p, dan nilai awalnya tidak terdefinisi. Dengan mengeksekusi

pernyataan p = s; alamat s[0] diberikan ke p, dan setelah itu maka kita dapat menggunakan p[0], p[1],

…,p[9] sebagaimana halnya kita menggunakan s[0], s[l],.. s[9] atau dengan kata lain variabel variabel

p[i] dan s[i] menempati lokasi memori yang sama. Jika pernyataan p = s; dihilangkan maka pernyataan

p[9] = `A'; menjadi tidak benar.

Kita juga akan sering merasa perlu untuk mempunyai sebuah pointer yang umum yang dapat

menyebutkan alamat setiap objek tanpa peduli dengan tipenya. Misal kita lihat pernataan berikut ini:

int i

float riil

int *p_int

float *p_flaot

halaman | 8-63


Karena alamat sebuah integer mempunyai format internal yang sama dengan alamat float maka kita

boleh saja menduga bahwa pernyataan berikut ini dibolehkan:

p_float = &i; // SALAH!!

Ekspresi &i mempunyai tipe pointer-to-int sementara itu p_float mempunyai tipe pointer-to-

float.Kedua tipe tidaklah bersesuaian yang berarti pernyataan di atas tidak sah. Tetapi hal ini dapat

kita koreksi dengan menggunakan type castsebagai berikut:

p_float = (float *)&i

Perhatikan kehadiran tanda * dalam ( float *). Hal itu menyatakan bahwa &i akan dikonversikan

menjadi tipe pointer-to-float, bukan ke tipe float.

Pointer void merupakan salah satu tipe pointer khusus dimana kita dapat menghubungkan tipe

pointer ini ke segala jenis tipe data. Pointer void dideklarasikan sebagai berikut:

void *nama_pointer

misalkan jika pada contoh diatas kita tambahkan baris

void *p_void

maka pernyataan berikut ini diijinkan:

p_void = &i;// Dari pointer-to-int ke pointer-to-void

p_void = &riil;// Dari pointer-to-float ke pointer-to-void

p_void = (float *)p_void;//Dari pointer-to-void ke pointer-to-float

String

Kita telah mengenal dengan ide bahwa sebuah alamat dapat mempunyai tiga bentuk:

Sebuah ekspresi yang berawal dengan operator &, seperti &table[0].

Nama sebuah array seperti table.

Sebuah pointer, seperti p.

Ada lagi sebuah bentuk yang penting, yang juga menghasilkan sebuah alamat:

sebuah string, seperti ―ABC‖

Jika string “ABC” terjadi dalam sebuah program, ketiga karakter „A'. `B' dan 'C' akan disimpan di

memory sebagaimana halnya sebuah array karakter disimpan. Oleh karena itu kita dapat

menganggap bahwa “ABC” sebagai sebuah array dari empat elemen char. Harga aktual dari

string ini adalah alamat karakter pertamanya dan tipenya adalah pointer -to-char. Dengan

menggunakan operator * pada objek yang mempunvai tipe seperti ini akan menghasilkan

karakter yang membentuk isinya. Juga perlu diketahui bahwa kita juga dapat menggunakan

aritmatika alamat terhadap string:

*‖ABC‖ sama dengan ‗A'

*(―ABC‖ + 1) sama dengan ‗B'

*(―ABC‖ + 2) sama dengan 'C'

*(―ABC‖ + 3) sama dengan ‗\0'

Seperti yang kita lihat tidak hanya array yang dapat mempunyai subscript tetapi juga pointers.

Nama-nama array dan pointer mempunyai persamaan yaitu mareka mempunyai tipe pointer -to-

…. (dimana … dapat berupa semua tipe) atau dengan kata lain nilainya adalah alamat. Hal ini dapat

digeneralisir untuk semua ekspresi dengan karakteristik seperti ini. Sebuah string merupakan salah

satu contoh sehingga dapat dituliskan scbagai berikut:

―ABC‖ [0] sama dengan ‗A'

―ABC‖ [1] sama dengan ‗B'

halaman | 8-64



―ABC‖ [2] sama dengan 'C'

―ABC‖ [3] sama dengan ‗\0'

Hanya jika mengetahui bahwa “ABC” adalah alamat maka kita mengerti mengapa progam

seperti di bawah ini bekerja:

// Contoh 8.3 : Pointer - Penggunaan string

#include <stdio.h>

main()

{ char *p;

p = “ABC”;

printf(p);

}

Pertama, sungguh salah jika membayangkan bahwa pernyataan pemberian harga dalam

program diatas akan mengcopy karakter. Padahal hanya alamat awal dan barisan ABC yang

diberikan ke p. Output dari program di atas adalah

ABC

Sekarang kita dapat dengan mudah membuktikan bahwa outputnya akan berupa BC

seandainya saja „printf (p)‟ digantikan oleh salah satu dan panggilan berikut ini:

printf(p+1);

printf( ―ABC‖ + 1);

Operasi_Operasi String

Dengan menggunakan string.h yaitu melalui

#include <string.h>

maka string dapat diberikan pada sebuah array karakter seperti teriihat pada contoh berikut ini

strcpy(s, ―ABC‖ ) ;

di mana strcpy merupakan sebuah fungsi dengan dua argumen yang dapat berupa semua

ekspresi yang mempunyai tipe pointer-to-char. Dengan kata lain adalah ekspresi-ekspresi

yang merupakan destinasi dan.sumber yang pada waktu memanggilnya

strcpy(destinasi, sumber);

akan menghasilkan alamat-alamat. Program di bawah ini akan memberi gambaran, yang lebih jelas:

// Contoh 8.4 : Penggunaan strcpy

#include <stdio.h>

#include <string.h>

main()

{

char s[100] = “Belajar Pemrograman” , t[100];

strcpy(t, s);

strcpy(t+8, “Bahasa C”) ;

printf (“%s\n%s”, s, t);

}

yang outputnya adalah

Belajar Pemrograman

halaman | 8-65


Belajar Bahasa C.

strcpy(t+8, “Bahasa C”) mengcopy “Bahasa C” ke string t mulai dari posisi ke 8, yaitu setelah “Belajar “,

sehingga string t menjadi “Belajar Bahasa C”. Pada kedua baris di bawah ini s merupakan sebuah array

dengan empat buah elemen, ini lebih dari cukup untuk memuat“ABC” plus karakter null:

char s[4] = ―ABC‖;

char *p = ―DEF‖;

Selama inisialisasi keempat karakter (“ABC” + karakter null) dikopikan ke s, atau kita dapat juga

menempatkan karakter lainnya kedalam s asal panjangnya 4.Tetapi hal ini berbeda dengan variabel

pointer p. Di sini alamat “DEF”, bukan urutan karakter itu sendiri, yang dikopikan ke p (tidak ke *p).

Kita dapat memisahkan baris terakhir itu menjadi sebuah deklarasi dan sebuah pemberian harga

(assignment) sebagai berikut:

char *p;

p = ―DEF‖;

Kita tidak dapat melakukan hal ini pada s (kecuali dengan menggunakan strcpy). Hal lain yang pe rlu

juga untuk diketahui adalah bahwa p tidak dibatasi hanya untuk array dengan empat elemen

sebagaimana halnya s. Di p hanya sebuah alamat saja yang disimpan dan oleh karena itu bisa saja kita

menuliskan:

p = ―ABCDEFGH‖;

Setelah melihat perbedaan-perbedaan antara s dan p, kita juga harus mengingat bahwa mareka juga

meiniliki sejumlah kesamaan; sebagai contoh ekspresi-ekspresi di bawah ini juga sah:

s[i]

p[i]

*(s+i)

*(p+i)

Meskipun strcpy merupakan sebuah fungsi yang amat berguna, mengcopy segalanya dari sebuah

sumber sampai ditemuinya karakter null tidak selalu yang kita inginkan. Sering kita hanya

menginginkan beberapa bagian yang perlu dicopy. Hal seperti ini dapat kita lakukan dengan

menggunakan strncpy. Fungsi ini mempunyai bentuk:

strncpy(destinasi, sumber, n)

yang akan mengcopy n buah karakter dari sumber ke destinasi kecuali jika ditemui karakter null

sebelum n karakter itu tercopy. Sebagai contoh:

char s[100];

strcpy( ―Nama saya reni.‖);

kita dapat meaggunakan pernyataan:

strncpy(s + 10, ―so‖ , 2);

yang akan menghasilkan perubahan sebagai berikut:

Nama saya soni.

Setelah mengcopy huruf-huruf s dano jumlah karakter maksimum tercapai sehingga proses

mengcopy diakhiri. Jika argumen terakhir lebih besar dari 2, maka tepat 3 karakter yang akan dicopy,

yaitu s, o dan ‗\n'. Hasil-hasil strcpy dan strncpy tidak terdefinisi jika destinasi dan sumbernya

tumpang tindih.Sebagai contoh, jika kita menginginkan untuk memasukkan string “Prof.“ di awal

dari string yang disimpan di dalam s.

char s[100] = ―Muhammad Ali‖;

halaman | 8-66



strcpy(s, ―Prof.―);

jika perintah diatas dijalankan maka akan dihasilkan Prof. mmad Alibukan Prof. Muhammad

Aliseperti yang diinginkan, maka untuk itu kita harus menggunakan variabel temporer temp misalnya

dengan menuliskan:

strcpy(temp, s);// temp = “Muhammad Ali”

strcpy(s, ―Prof. ―);// s = “Prof. “

strcpy(s + 6, temp);// s = “Prof. Muhammad Ali”

Fungsi-fungsi strcpy dan strncpy mengembalikan alamat awal ke destinasi. Kila sering tidak

memerlukan nilai pengembalian ini, tetapi kita dapat me nggunakannya jika memang

dikehendaki.

Selain strcpy dan strncpy masih ada lagi beberapa fungsi yang ada di pustaka string.h yaitu :

strlen untuk mencari panjang string

strlwr untuk mengubah semua karakter dalam string ke huruf kecil (lower case)

strupr untuk mengubah semua karakter dalam string ke huruf kecil (upper case)

strcat untuk menambahkan string ke string lainnya

strncat untuk menambahkan n buah karakter pertama sebuah string ke string lainnya

strcmp untuk membandingkan dua string

strncmp untuk membandingkan n buah karakter pertama dari dua string

halaman | 9-67


Bab 9. STRUKTUR DAN UNION

Struktur

Untuk menyimpan sekelompak data kita dapat menggunakan array, namun sayang array hanya dapat

menyimpan sekelompok data yang tipe datanya sama, jika tipe data berbeda tidak dapat disimpan

dalam array. Untuk menyimpan sekumpulan data yang dapat terdiri dari berbagai tipe kita dapat

menggunakan struktur. Pemahaman tentang struktur dapat membuka jalan untuk memahami konsep

class dalam bahasa pemrograman berorientasi objek. Stuktur adalah tipe data yang dapat dibuat oleh

programer yang dapat berisi kumpulan beberapa tipe data. Sehingga struktur dapat disebut pula

sebagai kumpulan data.

Struktur dideklarasikan dengan menggunakan keyword struct, dengan sintak sbb :

struct nama_struktur

{

daftar komponen variable

};

Komponen variabel dalam struktur biasa disebut field atau member dari struktur. Misalnya kita ingin

menyimpan data nama mahasiswa, nim serta kehadiran kuliah dalam suatu struktur. Hal itu dapat

dilakukan dengan mendeklarsikan sebuah struktur, misalnya absensi, dengan variabel komponen

nama, nim dan kehadiran seperti dibawah ini :

struct absensi

{

char nama[30];

long nim;

float kehadiran; //% kehadiran

}; //jangan lupa diakhiri dengan tanda „;‟

Setelah struktur dideklarasikan maka kita dapat mendeklarasikan variabel bertipe struktur tersebut,

dengan sintak sbb:

struct nama_variabel;

Misalnya kita membuat variabel absensi untuk peserta kuliah Dasar Pemrograman

struct absensi peserta1, peserta2;

Deklarasi variabel ini dapat juga dilakukan bersamaan dengan deklarasi struktur :

struct absensi

{

char nama[30];

long nim;


} peserta1, peserta2;

Contoh program pemakaian struktur dapat dilihat pada program dibawah ini.

//Contoh 9.1: Struktur 1

#include<stdio.h>

struct absensi

{

char nama[30];

halaman | 9-68



unsigned long nim;


};

main()

{

//inisialisasi struktur

struct absensi peserta1 = {“Alpha”, 13303100, 85};

struct absensi peserta2 = {“Betha”, 13303101, 80};

struct absensi peserta3;

peserta3 = peserta2;

//Menampilkan data

printf (“Absensi Kehadiran Kuliah Dasar Pemrograman\n”);

printf (“1. %s %l %f\n”, peserta1.nama, peserta1.nim, peserta1.kehadiran);



}

Pada contoh diatas terlihat bahwa untuk mengakses field yang ada pada struktur digunakan opertor „.‟

seperti peserta1.kehadiran yang mengakses field kehadiran pada variabel peserta1. Pada contoh diatas

juga terlihat ada assigment

peserta3 = peserta2

hal ini hanya bisa dilakukan pada struktur yang sama saja.

Type Definition

Salah satu konsep yang sering berhubungan dengan structures adalah konsep type definitions. Type

definition digunakan untuk memakai tipe data yang ada dan memberinya nama baru. Tipe data yang

dipakai dapat berupa tipe data standar yang disediakan C, misalnya integer, float, dan char, atau tipe

data yang dibuat programer misalnya struktur. Biasanya penamaan type definitions menggunakan

huruf besar semua. Type definitions dideklarasikan dengan menggunakan keyword typedef.Misalnya

kita ingin mendefinisikan tipe int (integer) sebagai INTEGER :

typedef int INTEGER

Sehingga kita dapat mendeklarasikan variabel integer dalam bentuk :

INTEGER x, y, z; yang ekivalen dengan int x, y, z;

Untuk struktur typedef dapat dideklarasikan bersamaan dengan deklarasi struktur atau terpisah :

struct titik{

int x;

int y;

};

typedef struct titik TITIK;

TITIK titik1, titik 2;

typedef struct titik{

int x;

int y;

} TITIK;

TITIK titik1, titik 2;

halaman | 9-69


Struktur dalam Struktur

Data struktur dapat dikelompokan dalam struktur seperti pada contoh program berikut ini :

//Contoh 9.2: Struktur dlm struktur

#include<stdio.h>

struct titik

{

int x;

int y;

};

typedef struct titik TITIK;

struct segi_empat

{

struct titik atas_kiri;

struct titik bawah_kanan;

};

main()

{

TITIK titik1 = {1,5},titik2 = {5,1};

struct segi_empat segi_empat1, segi_empat2 = {{2,7},{4,1}};

int xx1, xx2, yy1, yy2;

segi_empat1. atas_kiri.x = titik1.x;

segi_empat1. atas_kiri.y = titik1.y;

segi_empat1.bawah_kanan.x = titik2.x;

segi_empat1.bawah_kanan.x = titik2.y;

xx1 = titik2.x - titik1.x;

yy1 = titik1.y - titik2.y;

xx2 = segi_empat2.bawah_kanan.x - segi_empat2.atas_kiri.x;

yy2 = segi_empat2.atas_kiri.y - segi_empat2.bawah_kanan.y;

printf (“Luas segi empat 1 = %d\n”, xx1*yy1);

printf (“Luas segi empat 2 = %d\n”,xx2*yy2);

}

akan menghasilkan ourtput

Luas segi empat 1 = 16

Luas segi empat 2 = 12

Didalam struktur dimungkinkan menggunakan array, misalnya pada contoh berikut ini.

//Contoh 9.3: Struktur dengan array

#include<stdio.h>

struct absensi

{

char nama[30];

unsignedlong nim;


};

halaman | 9-70



main()

{

//inisialisasi struktur

struct absensi peserta[3];

strcpy(peserta[0].nama, “Alpha”);

peserta[0].nim = 13303100;

peserta[0].kehadiran = 85;

strcpy(peserta[0].nama, “Betha”);

peserta[1].nim = 13303101;


strcpy(peserta[0].nama, “Gamma”);

peserta[2].nim = 13303102;


//Menampilkan data

printf (“Absensi Kehadiran Kuliah Dasar Pemrograman\n”);

for(i=0;i<3;i++)

{

printf (“%d. %s\t %l\t %f \% \n”, i+1, peserta[i].nama, peserta[i].nim,

peserta[i].kehadiran);

}

}

Union

Union adalah sekumpulan data yang memiliki tipe data yang berbeda, sama seperti struct. Union

dideklarasikan sebagai mana struct dideklarasikan, yaitu sebagai berikut

Struktur dideklarasikan dengan menggunakan keyword struct, dengan sintak sbb :

union nama_union

{

daftar komponen variable

};

Komponen variabel dalam union disebut f ield atau member dari union sama seperti dalam struct.

Misalnya kita membuat harga laptop dalam rupiah dan US dolar.

unionharga

{

int rupiah;//harga dlm rupiah

float dollar; //harga dlm US dollar

}; //jangan lupa diakhiri dengan tanda „;‟

Setelah union dideklarasikan maka kita dapat mendeklarasikan variabel bertipe union tersebut,

dengan sintak yang sama seperti struct, yaitu sbb:

union nama_variabel;

Misalnya kita membuat variable harga untuk netbook dan notebook

halaman | 9-71


union harganetbook, notebook;

Kita juga dapat menggabungkan deklarasi union beserta pembuatan variable secara bersamaan

seperti pada contoh dibawah ini.

union harga

{

int rupiah;//harga dlm rupiah

float dollar; //harga dlm US dollar

}netbook, notebook;

Member dari union diakses dengan cara yang sama seperti struct, yaitu menggunakan operator '.'

untuk variabel union atau operator'->' untuk pointer umion

variabel_union.member atau pointer_union->member

Jadi apa bedanya antara union dan struct. Perbedaan antara union dan struct terdapat pada fungsinya

dan tujuannya. Untuk melihat bedanya mari kita lihat deklarasi union dan struct berikut ini.

struct data {

float data_float;

int data_int;

char data_char;

}data1;

union data {

float data_float;

int data_int;

char data_char;

}data1;

Ketika struct dideklarasikan, maka struct akan memesan memori 4 byte untuk float, 2 byte untuk

integer dan 1 byte untuk char sehingga total 7 byte. Namun union ketika dideklarasikan hanya

memesan sebesar ukuran tipe data terbesar yang diperlukan yaitu 4 byte untuk float, karena tipe data

character dan integer dapat masuk ke tipe data float. Perbedaan ini dikarenakan perbedaan fungsi

union dan s truct dalam mengelola data. Jika ketiga tipe data pada contoh diatas ada kemungkinan

diakses pada waktu yang bersamaan, maka gunakanlah struct, namun jika hanya satu jenis tipe data

saja yang diakses pada suatu waktu maka cukup gunakan union saja. Sehingga tipe data yang

tersimpan di union adalah tipe data yang terakhir diakses oleh program. Misal perhatikan contoh

program dibawah ini.

//Contoh 9.4 : Contoh pemakaian union

#include <stdio.h>

union data {

float data_f;

int data_i;

char data_c;

};

main ()

{

union data data1;

data1.data_f = 12.56;

printf (“data_f = %f, data_i = %d, data_c = %c\n”, data1.data_f, data1.data_i, data1.data_c);

data1.data_i = 10;


data1.data_c = 'A';


}

Jika kita jalankan maka akan kita peroleh hasil sebagai berikut :

halaman | 9-72



data_float = 12.560000, data_int = 1015389231, data_char = 0

data_float = 0.000000, data_int = 10, data_char =

data_float = 0.000000, data_int = 65, data_char = A

Dari hasil terlihat setelah pernyataan inisialisasi data float, maka data yang ditampilkan ke layar

dengan benar hanya tipe data float saja yang lain tidak sesuai dengan kenyataan. Begitu juga setelah

inisialisasi data integer dan char, hanya tipe data yang diinisialisasi terakhir saja yang benar, yang

lainnya diisi dengan harga yang tidak menentu.

halaman | 10-73


Bab 10. FILE INPUT OUTPUT

Untuk mengetes suatu program kadang kita memerlukan sejumlah data input yang harus dimasukan

ketika program dijalankan. Jika data input yang diperlukan cukup banyak dan harus dimasukan secara

langsung lewat keyboard, maka mungkin suatu saat kita akan merasa bosan dan malas untuk

melakukannya lagi. Untuk mengatasi hal tersebut, data input yang diperlukan oleh program dapat kita

simpan dalam bentuk file yang dapat dibaca oleh program sehingga kita tidak usah mengetikan data

lewat keyboard, begitu juga output dari program dapat disimpoan kedalam file oleh program.

Ada dua jenis file I/O yang umum digunakan yaitu text file dan binary file. Keduanya ketika

dibaca/ditulis ole program akan diperlakukan sebagai text stream dan binary stream, karena C hanya

mengijinkan aliran data dalam bentuk stream dari karakter. Isi file dibaca secara sekuensial karakter

per-karakter sesuai dengan indikatorposisi yang juga akan bergerak mengikuti posisi karakter yang

dibaca. Indikator posisi diset diawal file pada saat awal pembacaan dan dapat dipindahkan ke suatu

tempat berdasarkan perintah dalam program.

Text file hanya berisi rangkaian karakter yang tersusun dalam rangkaian baris tek. Tiap baris dapat

berisi karakter sampai 255 karakter dan diakhiri dengan karakter „newline‟ (\n). Ada karakter-karakter

yang memiliki arti tertentu yang harus diinterpretasi secara khusus, misalnya „\n‟ (ganti baris). Data

text file dapat dibaca di flatform/mesin manapun. Sedangkan binary text dapat menyimpan data

terurut termasuk data tek dan dibaca apa adanya. Isi data dalam bentuk binary text pada umumnya

tergantung dari flatform/mesin dimana data itu dibuat.

Menuliskan data ke file

Untuk dapat berhubungan dengan file kita akan menggunakan fungsi-fungsi yang ada di pustaka

stdio.h. Untuk tipe text file, pertama-tama kita harus mendeklarasikan variabel FILE yang merupakan

pointer ke file. Deklarasi FILE di lakukan dengan menggunakan sintak sebagai berikut :

FILE *< pointer file >;

FILE adalah tipe data/struktur yang didefinisikan di dalam stdio.h. FILE akan menyimpan semua

informasi yang berhubungan dengan file. Setelah ponter file dideklarasikan kita harus membuka file

dimana data akan disimpan sebelum melakukan proses penyimpanan data. Pembukaan file dilakukan

dengan menggunakan sintak

< pointer file > = fopen(char nama_file, char mode);

Nama file adalah nama file yang akan kita buka termasuk lokasi direktori dimana file itu disimpan. Jika

file dismpan di direktori yang sama dengan program, hanya nama file saja sudah c ukup. Mode file

menandakan untuk tujuan apa file akan dipakai, ada beberapa mode yang dapat dipilih sesuai dengan

keperluannya. Untuktipetext-file mode yang dapat digunakan diantaranya adalah :

Mode Arti

r file yang dibuka hanya bisa dibaca saja

r+ file yang dibuka bisa dibaca dan ditulis

w file yang dibuka hanya bisa ditulis saja, jika nama file yang sama sudah ada maka file yang

lama akan terhapus diganti dengan yang baru

w+ file yang dibuka bisa dibaca dan ditulis, jika nama file yang sama sudah ada maka file yang

lama akan terhapus diganti dengan yang baru

a pada file yang dibuka hanya dapat ditambahkan data saja mulai dari akhir data yang ada. Jika

nama file yang bersesuaian tidak ada maka file baru akan dibuat

a+ pada file yang dibuka dapat dibaca dan ditambahkan data. Jika nama file yang bersesuaian

tidak ada maka file baru akan dibuat

halaman | 10-74



Fungsi fopen jika berhasil membuka file akan mengembalikan “pointer file”, tapi jika gagal akan

mengembalikan NULL.

Setelah file terbuka barulah kita dapat menuliskan data ke dalam file. Ada beberapa cara untuk

menuliskan data ke dalam file dengan menggunakan fungsi-fungsi yang ada di pustaka stdio.h.

Fungsi-fungsi di pustaka stdio.h yang dapat dipakai untuk menuliskan data ke file adalah putc , fputs

dan fprintf.

putc digunakan untuk menuliskan satu karakter ke dalam stream, sintak untuk menggunakan putc

adalah

putc( <karakter>, < pointer file> );

perintah putc akan mengembalikan karakter yang akan ditulis jika berhasil dan akan mengembalikan

EOF jika gagal. Berikut ini adalah contoh program untuk menyimpan string “Menyimpan data dengan

putc” ke dalam file data_putc.dat menggunakan perintah putc.

//Contoh 10.1 demontrasi pemakaian putc

#include <stdio.h>

void main()

{

FILE *p_file; //pointer file

p_file = fopen(“data_putc.dat”, “w”);

int i;

char string[]=“Menyimpan data dengan putc”;

for (i = 0; i < 100; i++)

{

if (string[i] == '\0') //test akhir dari string

{

putc('\n', p_file);

break;

}

else

putc(string[i], p_file); //tuliskan karakter berikutnya

}

fclose(p_file);

return 0;

}

fputs digunakan untuk menuliskan satu baris string kedalam file. Pemakaianfputsdilakukan dengan

menggunakan sintak

fputs( <string / array karakter>, <pointerfile> );

jika perintah ini berhasil dijalan kan maka akan mengembalikan string yang akan ditulis, dan jika gagal

akan mengembalikan EOF. Berikut ini adalah contoh penggunaan fputs yang dipakai untuk

menuliskan string “Menyimpan data dengan fputs” ke dalam file data_fputs.dat.

//Contoh 10.2 : Demonstrasi penggunaan fputs

#include <stdio.h>

void main()

halaman | 10-75


{


p_file = fopen(“data_fputs.dat”, “w”);

fputs( “Menyimpan data dengan fputs”, p_file );

fclose(p_file);

}

fprintf fungsi ini sama dengan printf yang telah kita bahas sebelumnya, hanya destinasinya saja yang

berbeda, kalau printf menuliskan secara terformat data ke layar (stdin), maka fprintf menuliskan data

secara terformat ke file (pointer_file). Sintak penulisannya adalah sbb:

fprintf(<pointerfile>,<string format data>, <daftar variabel>) ;

Jika perintah ini berhasildijalankan akan mengembalikan bilangan bulat positip (jumlah karakter yang

ditulis ke dalam file) atau bilangan negatip jika berakhir dengan kegagalan. Berikut ini contoh

penggunaan fprintf

//Contoh 10.3 : Penggunaan fprintf

#include <stdio.h>

main()

{

float dataf = 123.4567;

int datai = 250;

char datas[] = “data string”;


p_file = fopen(“data_fprintf.dat”, “w”);

fprintf(p_file, “ %f %d %s”, dataf, datai, datas);

printf(“ %f %d %s”, dataf, datai, datas);

fclose(p_file);

}

Setelah selesai menuliskan datamaka seperti pada ketiga contoh diatas, kita harus menutup file yang

telah kita buka dengan menggunakan perintah fclose. Jika sampai akhir program tidak dijumpai

perintah ini, maka program akan dengan sendirinya menutup semua file yang sedang dibuka ketika

mengakhiri eksekusi program. fclose ditulis dengan menggunakan sintak

fclose(<pointerfile>);

fungsi ini akan mengembaikan nilai 0 jika sukses dan EOF jika gagal.

Membaca data dari file

Untuk membaca data yang sudah disimpan didalam file bertipe text file , dapat dilakukan dengan

menggunakan fungsi getc, fgets dan fscanf yang tersedia di pustaka stdio.h. Seperti juga ketika kita

mau menuliskan data ke file, sebelum membaca data dari file terlebih dahulu kita harus membuat

variabel FILE sebagai pointer ke file serta membuka file yang akan kita baca, lalu setelah selesai

membaca data dari file harus kita akhiri dengan menutup file.

Pastikan file yang akan dibuka ada, terutama pada mode „r‟ (baca saja). Untuk mengecek apakah file

yang akan dibaca ada atau tidak, dalam program dapat kita lakukan dengan cara sebagai berikut


halaman | 10-76



p_file = fopen(“data.txt”, “r”);//buka file data.txt didirektori yg sama dgn program

if (p_file == NULL)

{

printf (“file yang tidak ada”);

exit(1);//keluar dari program

}

Fungsi getc merupakan fungsi untuk membaca satu karakter dari file dengan menggunkan sintak

<char variabel> = getc( < pointer file > );

fungsi ini akan mengembalikan karakter yang akan dibaca jika berhasil dijalankan dan menghasilkan

EOF jika gagal dijalankan. Berikut ini adalah contoh program untuk membaca data pada file

data_putc.dat yang ditulis dengan menggunakan putc pada program contoh 10.1 diatas.

//Contoh 10.4 Program membaca data dgn getc

#include <stdio.h>

#include <stdlib.h>//untuk exit(1)

main()

{


int karakter;// menyimpan bilangan ASCII dr karakter

p_file = fopen(“data_putc.dat”, “r”);

if (p_file == NULL)

{

printf (“file tidak ada”);

exit(1); //keluar dari program

}

karakter = getc(p_file) ;

while (karakter!= EOF)

{

putchar(karakter);//data ditampilkan ke layar

karakter = getc(p_file);

}

fclose(p_file);

}

Fungsi fgets merupakan fungsi yang dapat digunakan untuk membaca rangkaian karakter dalam baris

per baris sampai bertemu dengan new line atau panjang maksimum string, data akan yang dibaca

akan disimpan sebagai string. Sintak untuk menggunakan fgets adalah

fgets(<string>, <max panjang string>, <pointer file>);

fungsi tersebut akan mengembalikan string jika berhasil dan EOF jika gagal. Berikut ini contoh

program menggunakan fgets. Pada contoh ini fgets akan digunakan untuk membaca data_fputs.data

yang dibuat pada program contoh 10.2.

//Contoh 10.5 : Demonstrasi penggunaan fgets

#include <stdio.h>


#define MAX 256 //maximum karakter perbaris

main()

halaman | 10-77


{


char karakter[MAX];

p_file = fopen(“data_fputs.dat”, “r”);

if (p_file == NULL)

{



}

while (fgets(karakter,MAX,p_file)!= NULL)

{

printf(“%s”,karakter);

fgets(karakter,MAX,p_file);

}

fclose(p_file);

}

Fungsi fscanf merupakan fungsi untuk membaca data file terformat dengan format yang sama seperti

pada pemakaian scanf. Karena fscanf ini membaca file yang terformat, maka kita harus tahu terlebih

dahulu format data yang tersimpan pada file yang akan dibaca dengan menggunakan scanf sebelum

kita membacanya, karena jika formatnya tidak sesuai akan menghasilkan kesalahan. fscanf dipakai

dengan menggunakan sintak

fscanf(<pointer file>, <string format data>, <daftar variabel>) ;

fungsi ini akan menghasilkan nilai bilangan bulat jika berhasil dan EOF jika gagal. Berikut ini contoh

program memakai fscanf yang akan membaca file data_fprintf.dat yang ditulis secara terformat

menggunakan fprintf pada program Contoh 10.3

//Contoh 10.6 : Penggunaan fscanf

#include <stdio.h>


main()

{

float dataf;

int datai;

char datas[50];


p_file = fopen(“data_fprintf.dat”, “r”);

if (p_file == NULL)

{



}

fscanf(p_file, “ %f %d %s”, &dataf, &datai, datas);

printf(“ %.3f %d %s”, dataf, datai, datas);

fclose(p_file);

}

halaman | 10-78



Selain fungsi-fungsi diatas, pada pustaka stdio.h juga terdapat beberapa fungsi lain yang

berhubungan dengan penulisan dan pembacaan file, fungsi-fungsi tersebut adalah

Fungsi fseek() merupakan fungsi untuk memilih lokasi serta panjangnya data yang ingin dibaca atau

ditulis serta memiliki sintak:

fseek( <pointer file>, <offset>, <awal> );

Offset merupakan bilangan riil yang menyatakan panjang byte yang akan dibaca pada file. Awal

adalah bilangan integer yang merupakan pilihan dari 3 konstanta berikut yang terdapat pada

“stdio.h”:

SEEK_SET Start of file.

SEEK_CUR Current location.

SEEK_END End of file.

Fungsi fseek() akan mengembalikan nilai 0 jika sukses dan nilai yang bukan 0 jika gagal.

Fungsi rewind() digunakan untuk mengembalikan indicator posisi pembacaan file ke posisi awal ketika

file mulai dibuka. Pengunaan fungsi rewind() dilakukan dengan sintak sebagai berikut :

rewind(<file_pointer>);

Fumgsi rename() akan mengubah nama file lama menjadi nama file yang baru dengan menggunakan

sintak:

rename(<nama_file_lama>, <nama_file_baru>);

Fungsi remove() dapat menghapus file data yangada. Sintak untuk fungsi ini adalah sebagai berikut:

remove(<file_name_string>);

halaman | 10-79


REFERENSI

1. http://cplus.about.com

2. http://www.mycplus.com/

3. http://www.cprogramming.com/

4. http://en.wikibooks.org/wiki/A_Little_C_Primer/

http://cplus.about.com/

http://www.mycplus.com/

http://www.cprogramming.com/

http://en.wikibooks.org/wiki/A_Little_C_Primer/

Note Pemrograman Bahasa c 2011

Documents

Transcript of Note Pemrograman Bahasa c 2011