Pemrograman C

MMaatteerrii PPeennuunnjjaanngg AAllggoorriittmmaa && PPeemmrrooggrraammaann

DAFTAR ISI

1 . Pengantar .................................................................................................................................................... 1 1.1. Interpreter dan Compiler ............................................................................................................................ 1 1.2. Asal Mula Bahasa C ..................................................................................................................................... 1 1.3. Menyiapkan Program .................................................................................................................................. 2 1.4. Kompilasi ..................................................................................................................................................... 2 1.5. Jenis‐jenis File yang Dimiliki Turbo C ........................................................................................................... 2

2 . Elemen Dasar Pemrograman ........................................................................................................................ 3 2.1. Cara Penulisan ............................................................................................................................................. 3 2.2. Identifier dan Variabel ................................................................................................................................ 3 2.3. Tipe Data ..................................................................................................................................................... 4 2.4. Pemodifikasi Tipe ........................................................................................................................................ 4 2.5. Penentu Format .......................................................................................................................................... 5 2.6. Menggunakan Type Cast ............................................................................................................................. 5 2.7. Konstanta .................................................................................................................................................... 6 2.8. Operator ...................................................................................................................................................... 6

2.8.1. Operator Aritmatika ....................................................................................................................... 7 2.8.2. Operator Increment dan Decrement ............................................................................................. 7 2.8.3. Operator Bitwise ............................................................................................................................ 8 2.8.4. Operator Relasi .............................................................................................................................. 9 2.8.5. Operator Logika ........................................................................................................................... 10 2.8.6. Operator Kondisi .......................................................................................................................... 10

3 . Operasi Masukan dan Keluaran ................................................................................................................. 11 3.1. Menampilkan Data Ke Layar ..................................................................................................................... 11

3.1.1. printf() .......................................................................................................................................... 11 3.1.2. puts() ............................................................................................................................................ 12 3.1.3. putchar()....................................................................................................................................... 12

3.2. Memasukkan Data .................................................................................................................................... 12 3.2.1. scanf()........................................................................................................................................... 12 3.2.2. Memasukkan Data Secara Bersamaan ......................................................................................... 13 3.2.3. getch() dan getche() ..................................................................................................................... 13

3.3. Fungsi‐Fungsi Numerik .............................................................................................................................. 14 3.3.1. Fungsi sqrt .................................................................................................................................... 14 3.3.2. Fungsi pow ................................................................................................................................... 15 3.3.3. Fungsi TAN ................................................................................................................................... 15 3.3.4. Fungsi div ..................................................................................................................................... 15 3.3.5. Fungsi ceil ..................................................................................................................................... 15 3.3.6. Fungsi floor ................................................................................................................................... 16 3.3.7. Fungsi exp ..................................................................................................................................... 16 3.3.8. Fungsi max ................................................................................................................................... 16 3.3.9. Fungsi min .................................................................................................................................... 16

4 . Kondisional ................................................................................................................................................ 17 4.1. Pernyataan IF ............................................................................................................................................ 17 4.2. Pernyataan IF‐ELSE .................................................................................................................................... 18 4.3. Nested IF .................................................................................................................................................... 18 4.4. Penggunaan ELSE Bertingkat ..................................................................................................................... 19 4.5. Pernyataan SWITCH .................................................................................................................................. 19

5 . Pengulangan Proses ................................................................................................................................... 21 5.1. Pengulangan Dengan FOR ......................................................................................................................... 21

5.1.1. Variasi Pengulangan Dengan FOR ................................................................................................ 21 5.1.2. Menghilangkan Sebuah Bagian Pengulangan .............................................................................. 22 5.1.3. Pengulangan Tak Hingga .............................................................................................................. 22 5.1.4. Pengulangan Tanpa Pernyataan................................................................................................... 22 5.1.5. Pengulangan Bersarang................................................................................................................ 22

5.2. Pengulangan Dengan WHILE dan DO‐WHILE ............................................................................................ 23 5.2.1. Pengulangan Dengan while .......................................................................................................... 23 5.2.2. Pengulangan Dengan do‐while ..................................................................................................... 23

6 . Fungsi ........................................................................................................................................................ 24 6.1. Prototype Function ................................................................................................................................... 26 6.2. Function Dengan Tipe void ........................................................................................................................ 26 6.3. Variabel Lokal ............................................................................................................................................ 26 6.4. Variabel Global .......................................................................................................................................... 27 6.5. Rekursi ....................................................................................................................................................... 27

7 . Array dan Pointer ...................................................................................................................................... 28 7.1. Array .......................................................................................................................................................... 28

7.1.1. Array Multi Dimensi ..................................................................................................................... 28 7.1.2. Array String .................................................................................................................................. 29 7.1.3. Inisialisasi Array ............................................................................................................................ 30

7.2. Pointer ....................................................................................................................................................... 30 7.2.1. Operasi Pada Pointer ................................................................................................................... 31 7.2.2. Pointer dan Array ......................................................................................................................... 31 7.2.3. Pointer dan String ........................................................................................................................ 32 7.2.4. Array Pointer ................................................................................................................................ 33

8 . Fungsi‐Fungsi String ................................................................................................................................... 34 8.1. Variabel String ........................................................................................................................................... 34 8.2. Fungsi strlen .............................................................................................................................................. 34 8.3. Fungsi strlwr .............................................................................................................................................. 35 8.4. Fungsi strupr .............................................................................................................................................. 35 8.5. Fungsi strcpy .............................................................................................................................................. 35 8.6. Fungsi strcat .............................................................................................................................................. 35 8.7. Fungsi atof ................................................................................................................................................. 36

9 . Lebih Jauh Dengan Pointer dan Struktur .................................................................................................... 37 9.1. Pointer dan Array ...................................................................................................................................... 38 9.2. Pointer dan String ..................................................................................................................................... 38 9.3. Pointer dan Fungsi..................................................................................................................................... 39 9.4. Struktur ..................................................................................................................................................... 40

9.4.1. Mengakses Elemen Struktur ........................................................................................................ 40 9.4.2. Array dengan Struktur .................................................................................................................. 41 9.4.3. Struktur dan Fungsi ...................................................................................................................... 43

10 . Manipulasi File .......................................................................................................................................... 44 10.1. Manipulasi File Menggunakan stdio.h....................................................................................................... 44 10.2. Manipulasi File Menggunakan fstream.h .................................................................................................. 46

Pemrograman C | Pengantar 1

11 .. PPEENNGGAANNTTAARR

Bahasa pemrograman C merupakan bahasa tingkat menengah (Medium Level Language) yang mengkombinasikan elemen bahasa tingkat tinggi yang mengutamakan kemudahan dalam membuat program dan bahasa tingkat rendah yang mempunyai kecepatan eksekusi. Kelebihan : Memiliki banyak operator untuk memanipulasi data. Menyediakan berbagai struktur data dan pengendalian proses yang menunjang pemrograman

terstruktur. Lebih mudah dipahami karena berorientasi pada permasalahan bukan pada mesin. Waktu eksekusi lebih cepat. Mampu memanipulasi data dalam bentuk bit maupun byte secara efisien.

Kelemahan : Banyaknya operator dan fleksibelitas kadang-kadang membingungkan programmer. Adanya fasilitas pointer yang menyulitkan programmer.

Bahasa pemrograman C biasanya di gunakan untuk keperluan pemrograman sistem, seperti : Assembler Interpreter Program paket Sistem operasi Editor Compiler Program bantu (utility)

1.1. INTERPRETER DAN COMPILER

Interpreter adalah suatu jenis penterjemah yang menterjemahkan perbaris instruksi untuk setiap saat. Keuntungannya adalah penyusunan program relatif lebih cepat dan bisa langsung diuji sekalipun masih ada beberapa kesalahan. Kelemahannya adalah kecepatannya menjadi lambat sebab sebelum suatu instruksi dijalankan selalu diterjemahkan terlebih dahulu. Disamping itu saat memori dieksekusi, interpreter juga harus ada dalam memori selain itu source program tidak dapat dirahasiakan karena dapat dilihat oleh orang lain.

Compiler menterjemahkan seluruh instruksi dalam program sekaligus. Proses pengkompilasian cukup dilakukan sekali saja dan hasil terjemahan bisa dijalankan secara langsung tanpa tergantung lagi oleh program sumber maupun Compilernya. Keuntungannya adalah proses eksekusi berjalan cepat, program sumber dapat dirahasiakan sebab yang dieksekusi adalah program dalam bahasa mesin. Kelemahannya adalah proses pembuatan dan pengujian relatif lebih lama sebab ada waktu untuk kompilasi dan adapula waktu untuk proses linking.

1.2. ASAL MULA BAHASA C

Akar dari bahasa C adalah bahasa BPCL yang diciptakan oleh Martin Richards tahun 1967. Bahasa C merupakan pengembangan dari bahasa B yang diciptakan oleh Ken Thompson tahun 1970 di Laboratorium Bell (USA) dan dikembangkan menjadi bahasa C sekitar tahun 1972. Bahasa ini diciptakan oleh oleh Dennis Ritchie. Bahasa C pertama kali digunakan di komputer Digital Equipment Corporation PDP-11 yang menggunakan sistem operasi UNIX.

Tahun 1983, ANSI (American National Standards Institute) membuat C standar ANSI yang selanjutnya digunakan sebagai referensi dari berbagai versi C yang beredar. Kemudian pada tahun1987 Borland International menciptakan Turbo C versi 1.0 dan pada tahun 1989 mengeluarkan versi 2.0.

Keistimewaan yang sangat berarti dari bahasa pemrograman C adalah karena bahasa ini mendukung pemrograman yang berorientasi objek ( OOP / Object Oriented Programming).

Pemrograman C | Pengantar 2

1.3. MENYIAPKAN PROGRAM

Source code C dapat ditulis pada text editor apapun. Baik itu digunakan pada sistem operasi Windows atau Unix (Linux, BSD, dsb).

Walaupun demikian, lebih disarankan apabila digunakan dengan editor khusus C, agar penggunaan tools yang lain lebih mudah.

1.4. KOMPILASI

Untuk mengubah source code menjadi sebuah program, kita gunakan compiler. Setelah source code tercompile, terbentuklah sebuah file objek dengan ekstension “ .obj “. File “ .obj “ ini belum merupakan sebuah program executable. Untuk membentuk program executable linker harus dijalankan. Jika program executable sudah diperoleh, walaupun di komputer anda tidak terinstall compiler C namun program masih tetap dapat dijalankan.

Saat ini banyak compiler C yang berada di pasaran, contohnyaa Borland C++, Turbo C, Microsoft C++, C Builder, sampai pada compiler gratis seperti g++ di Unix.

1.5. JENIS‐JENIS FILE YANG DIMILIKI TURBO C

Beberapa jenis file yang penting adalah:

File HEADER Adalah file teks. File ini dapat digabungkan dengan file program pada waktu proses COMPILE dengan menggunakan perintah INCLUDE. Oleh karena itu file ini dikenal juga dengan nama File INCLUDE. Semua file header mempunyai ekstensi .h (singkatan dari header). Contoh : stdio.h dan conio.h

File LIBRARY

Berisi fungsi-fungsi yang dimiliki oleh Turbo C. File ini berisi program-program dari setiap fungsi dasar yang dikenal oleh Turbo C. Program-program tersebut sudah dicompile dan dapat digabungkan dengan program yang dibuat. Cara menggabungkannya dengan proses LINK. File Library selalu mempunyai ekstensi .lib

File RUN TIME

File ini akan digabungkan dengan program pada saat proses LINK. File Run Time disesuaikan dengan model memory-nya

MATH Library

File ini digunakan untuk hal-hal yang berhubungan dengan operasi bilangan. File yang kegunaannya hampir sama dengan file ini adalah emu.lib

File Editor, File Object dan File Eksekusi

File Editor Adalah program yang disusun dalam Turbo C. File ini adalah file teks dan mempunyai ekstensi .c

File Object Adalah file hasil proses COMPILE dari File Editor. nama File Object sama dengan nama file editor dengan ekstensi .obj

File Eksekusi Adalah hasil proses LINK. File ini bernama sama dengan file-file sebelumnya dan dapat dijalankan dari prompt DOS. Ekstensi file eksekusi adalah .exe

Pemrograman C | Elemen Dasar Pemrograman 3

22 .. EELLEEMMEENN DDAASSAARR PPEEMMRROOGGRRAAMMAANN

Untuk membuat suatu program ada baiknya kita mengenal terlebih dahulu apa yang disebut dengan prepocessor directive. Preprocessor ditandai dengan adanya awalan # . Preprocessor selalu dijalankan terlebih dahulu pada saat proses kompilasi terjadi. Setiap bahasa pemrograman C mempunyai bentuk seperti di bawah , yaitu:

#prepocessor directive main() { // Batang Tubuh Program Utama }

Melihat bentuk seperti itu dapat ambil kesimpulan bahwa batang tubuh program utama berada didalam fungsi main(). Berarti dalam setiap pembuatan program utama, maka dapat dipastikan seorang pemrogram menggunakan minimal sebuah fungsi. Pembahasan lebih lanjut mengenai fungsi akan di jelaskan kemudian.

2.1. CARA PENULISAN

• Komentar Komentar tidak pernah dicompile oleh compiler. Dalam bahasa C terdapat 2 jenis komentar, yaitu: Jenis 1 : /* Komentar anda diletakkan di dalam ini

Bisa mengapit lebih dari satu baris */ Jenis 2 : // Komentar anda diletakkan disini ( hanya bisa perbaris )

• Semicolon

Tanda semicolon “;” digunakan untuk mengakhiri sebuah pernyataan. Setiap pernyataan harus diakhiri dengan sebuah tanda semicolon. Baris yang diawali dengan tanda #, seperti #include <iostream.h> tidak diakhiri dengan tanda semicolon, karena bentuk tersebut bukanlah suatu bentuk pernyataan, tetapi merupakan prepocessor directive.

2.2. IDENTIFIER DAN VARIABEL

Identifier (pengenal) merupakan nama yang biasa digunakan untuk variabel, konstanta, fungsi atau obyek yang lain yang didefinisikan oleh program. Sedangkan variabel adalah tempat penampung data yang berada di memory computer serta dapat berubah-ubah, dimana biasanya variabel mempunyai tipe. Kita dapat memilih sendiri nama variabel yang disesuaikan dengan tujuan. Ketentuan penamaan variabel : 1. Nama variabel terdiri dari huruf, angka dan garis bawah. Nama variabel boleh didahului oleh huruf

dan garis bawah, tetapi tidak boleh didahului oleh angka dan tidak boleh berisi spasi. Contoh : nilai1, nilai_1, _nilai_turbo_c, a123

2. Tidak boleh menggunakan operator hitung ( + - / * % ) dan juga tidak boleh menggunakan karakter khusus ( : ; , # @ $ & dan titik )

3. Tidak boleh memakai reserved words (kata-kata yang sudah mempunyai arti di dalam turbo C). Variabel boleh memakai reserved word jika digabungkan dengan kata lain. Contoh variabel yang salah : main, printf, scanf, dan sebagainya Contoh variabel yang benar : program_main, printf_1

4. Turbo C membedakan huruf besar dan kecil. Variabel gaji, Gaji dan GAJI adalah tiga variabel yang berbeda.

5. Panjang variabel boleh berapa saja, tetapi hanya 32 karakter pertama yang dikenal.


2.3. TIPE DATA

Data berdasarkan jenisnya dapat dibagi menjadi lima kelompok yang dinamakan sebagai tipe data dasar. Kelima tipe data dasar tersebut yaitu :

• Bilangan bulat (integer) • Bilangan real presisi-tunggal • Bilangan real presisi-ganda • Karakter • Tak-bertipe

Nama Tipe Total Bit Rentang Nilai Keterangan

char 8 -128 .. 127 Karakter int 16 -32768 .. 32767 Bilangan Integer float 32 3.4E-38 .. 3.4E+38 Bilangan Real presisi-tunggal double 64 1.7E-308 .. 1.7E+308 Bilangan Real presisi-ganda void 0 Tidak bernilai Tak-bertipe

Catatan: Untuk mengetahui ukuran memori dari suatu tipe digunakan fungsi sizeof(tipe)

Variabel digunakan untuk menyimpan suatu nilai dan nilai yang ada padanya dapat diubah-ubah selama eksekusi program berlangsung. Variabel yang digunakan dalam program haruslah dideklarasikan terlebih dahulu dengan tujuan memesan memori dan menentukan jenis data yang bisa disimpan di dalamnya. Contoh :

int jumlah; float harga_per_unit, total_harga;

Sebuah variable dapat juga di berikan nilai, misalnya :

jumlah = 10; harga_total = jumlah * harga_per_unit;

2.4. PEMODIFIKASI TIPE

Ada beberapa pemodifikasi tipe (type modifier) yang dapat dikenakan di awal tipe data dasar (kecuali void). Pemodifikasi tipe tersebut adalah :

Signed : Long Unsigned : Short

Tabel kemungkinan pemakaian pemodifikasi tipe pada tipe dasar :

Nama Tipe Total Bit Rentang Nilai unsigned char 8 0 .. 255 signed char 8 -128 .. 127 unsigned int 16 0 .. 63535 signed int 16 -32768 .. 32767 short int 16 -32768 .. 32767 unsigned short int 16 0 .. 65535 signed short int 16 -32768 .. 32767 long int 32 -2147483648 .. 2147483647 signed long int 32 -2147483648 .. 2147483647 unsigned long int 32 0 .. 4294967295 long double 80 3.4E-4932 .. 1.1E+4932

Tipe short int bisa cukup ditulis menjadi short dan long int boleh ditulis menjadi long Tipe signed int bisa ditulis menjadi signed saja Tipe unsigned int boleh ditulis dengan unsigned


2.5. PENENTU FORMAT

Penentu format untuk data tipe lain dapat dilihat pada tabel berikut :

Tipe Data Penentu Format Integer %d Floating Point - Bentuk Desimal %f Bentuk Berpangkat %e Double Precision %lf Character %c String %s Unsigned Integer %u Long Integer %ld Long Unsigned Integer %lu Unsigned Hexadec. Int. %x Unsigned Octal Int. %o

Contoh :

#include <stdio.h> #include <conio.h> int main() {

int gaji,tunj,GAJI; gaji = 20000; /* gaji pokok * / tunj = 0.1 * gaji; GAJI = gaji + tunj; /* gaji total */ clrscr(); printf(“\nGaji Pokok = Rp. %d”,gaji); printf(“\nTunjangan = Rp. %d”,tunj); printf(“\nGaji Total = Rp. %d”,GAJI); getch(); return 0;

}

Hasil : Gaji Pokok = Rp. 20000 Tunjangan = Rp. 2000 Gaji Total = Rp. 22000

Untuk mencetak agar rapat kanan, pakailah field width specifier (penentu lebar field) dengan merubah baris printf menjadi :

printf(“\nGaji Pokok = Rp. %6d”,gaji); printf(“\nTunjangan = Rp. %6d”,tunj); printf(“\nGaji Total = Rp. %6d”,GAJI);

2.6. MENGGUNAKAN TYPE CAST

Type Cast merupakan upaya untuk mengkonversikan suatu tipe menjadi tipe yang lain. Bentuk umum tipe cast adalah :

(tipe) ungkapan


Dengan tipe dapat berupa pengenal tipe seperti char atau int. Misalnya jika x dideklarasikan bertipe int, bila dikehendaki agar ungkapan x/2 menghasilkan nilai pecahan (real) maka ungkapan x/2 dapat ditulis menjadi (float) x/2. Contoh :

#include <stdio.h> #include <conio.h> int main() { int x=21; float y; clrscr(); y=x/2; printf("Nilai y = x/2 adalah %f\n", y); y=(float) x / 2; printf("Nilai y = (float) x/2 adalah %f\n", y); getch(); return 0; }

2.7. KONSTANTA

Konstanta menyatakan nilai tetap. Berbeda dengan variabel, suatu konstanta tidak dideklarasikan namun memiliki tipe. Penulisan konstanta mempunyai aturan tersendiri, sesuai dengan tipe masing-masing. Konstanta sering dipakai dalam rumus-rumus fisika dan matematika. Contoh : phi (π) yang mempunyai nilai 3.14268. Phi sering dipakai untuk rumus-rumus yang berhubungan dengan lingkaran. Berikut jenis-jenis konstanta:

1. Konstanta Oktal, digit yang digunakan 0-7 2. Konstanta Heksadesimal, digit yang digunakan 0-9, A-F 3. Konstanta Bernama

a. Menggunakan keyword const

Contoh : const float PI = 3.14152965;

Berbeda dengan variable, konstanta bernama tidak dapat diubah jika telah diinisialisasi.

b. Menggunakan #define

Contoh : #define PI 3.14152965

Keuntungan menggunakan #define apabila dibandingkan dengan const adalah kecepatan kompilasi, karena sebelum kompilasi dilaksanakan, kompiler pertama kali mencari symbol #define (oleh sebab itu mengapa # dikatakan preprocessor directive) dan mengganti semua PI dengan nilai 3.14152965.

2.8. OPERATOR

Operator merupakan simbol atau karakter yang biasa dilibatkan dalam program untuk melakukan suatu operasi atau manipulasi seperti penjumlahan, memberikan nilai, membandingkan kesamaan dan sebagainya.

Operator yang dikenakan terhadap dua buah nilai (operand) disebut unary, misalnya a + b. Sedangkan operator yang hanya memiliki sebuah operand disebut unary, misalnya –c.

Contoh : a = b + c * d / 4 a, b, c, d disebut operand =, +, *, / disebut operator


2.8.1. OPERATOR ARITMATIKA

Operator Deskripsi Contoh + Penjumlahan ( Add ) m + n - Pengurangan ( Substract ) m – n * Perkalian ( Multiply ) m * n / Pembagian ( Divide ) m / n % Sisa Pembagian Integer ( Modulus ) m % n - Negasi ( Negate ) -m

Catatan : Operator seperti operator negasi (-) disebut unary operator, karena membutuhkan hanya satu buah operand

Cara lain penulisan dengan menggunakan operator aritmatika :

m = m + n m += n m = m - n m -= n m = m * n m *= n m = m / n m /= n m = m % n m %= n

2.8.2. OPERATOR INCREMENT DAN DECREMENT

Operator increment : ++ Operator decrement : -- Contoh :

#include <stdio.h> #include <conio.h> int main() { int m = 44, n = 66; printf(“m = %d, n = %d\n”, m, n); ++m; --n; printf(“m = %d, n = %d\n”, m, n); m++; n--; printf(“m = %d, n = %d\n”, m, n); getch();

return 0; }

Keluarannya :

m = 44, n = 66 m = 45, n = 65 m = 46, n = 64

Terlihat bahwa operator pre-increment dan post-increment memiliki akibat yang sama, yaitu manambah nilai satu pada m dan memasukkan nilai tersebut kembali ke m, dimana hasilnya akan sama jika ditulis m=m+1. Hal yang sama juga terjadi pada operator pre-decrement dan post-decrement yang memberikan akibat yang sama, yaitu mengurangi nilai satu dari n, atau n=n-1.

Tetapi bila digunakan sebagai sub-ekspresi, operator post-increment dan pre-increment menunjukkan hasil yang berbeda.


Contoh : #include <stdio.h> #include <conio.h> int main() { int m = 66, n ; n = ++m; printf(“m = %d, n = %d\n”, m, n); n = m++; printf(“m = %d, n = %d\n”, m, n); printf(“m = %d\n”, m++); printf(“m = %d\n”, m); printf(“m = %d\n”, ++m); getch();

return 0; }

Keluarannya :

m = 67, n = 67 m = 68, n = 67 m = 68 m = 69 m = 70

Penjelasan :

• Dalam penugasan yang pertama, m adalah pre-increment, menaikkan nilainya menjadi 67, yang selanjutnya dimasukkan ke n.

• Dalam penugasan kedua, m adalah post-increment, sehingga 67 dimasukkan dahulu ke n baru kemudian nilai m-nya dinaikkan, itu sebabnya mengapa nilai m = 68 dan n = 67.

• Dalam penugasan ketiga, m adalah post-increment, sehingga nilai m ( = 68 ) ditampilkan dahulu ( ke layar ) baru kemudian nilai m dinaikkan menjadi 69.

• Dalam penugasan keempat, m adalah pre-increment, sehingga nilai m dinaikkan dahulu menjadi 70 baru kemudian ditampilkan ke layar.

2.8.3. OPERATOR BITWISE

Operator Deskripsi Contoh

<< Geser n bit ke kiri ( left shift ) m << n >> Geser n bit ke kanan ( right shift ) m >> n & Bitwise AND m & n | Bitwise OR m | n ^ Bitwise XOR m ^ n ~ Bitwise NOT ~m

Catatan : Seluruh operator bitwise hanya bisa dikenakan pada operand bertipe data int atau char Berikut ini diberikan tabel kebenaran untuk operator logika

P = A operator B

AND OR XOR A B P 0 0 0 0 1 0 1 0 0 1 1 1

A B P 0 0 0 0 1 1 1 0 1 1 1 1

A B P 0 0 0 0 1 1 1 0 1 1 1 0


Contoh : #include <iostream.h> void main() { int m = 82, n = 26; cout<<m<<" << 2"<<" = "<<(m<<2)<<endl; cout<<m<<" >> 2"<<" = "<<(m>>2)<<endl; cout<<m<<" & "<<n<<" = "<<(m&n)<<endl; cout<<m<<" | "<<n<<" = "<<(m|n)<<endl; cout<<m<<" ^ "<<n<<" = "<<(m^n)<<endl; cout<<"~"<<m<<" = "<<~m<<endl; }

Keluarannya :

82 << 2 = 328 82 >> 2 = 20 82 & 26 = 18 82 | 26 = 90 82 ^ 26 = 72 ~82 = 83

Penjelasan :

• Nilai keluaran diatas, tergantung dari jenis compiler yang digunakan. Hasil diatas merupakan keluaran dari compiler Turbo C.

• Pada Turbo C besar dari integer adalah 2 byte atau sama dengan 16 bit, untuk mengetahuinya digunakan perintah

sizeof(int) // Untuk mengetahui besar dari int

Maka : 8210 = 00000000010100102 dan 2610 = 00000000000110102

Sehingga : 82 << 2 00000001010010002 = 32810 82 >> 2 00000000000101002 = 2010 82 & 26 00000000010100102

00000000000110102

------------------------------------------ &

00000000000100102 = 1810

dan begitu juga untuk operasi OR dan XOR. ~82 digunakan 2’s complement, yaitu 8210 = 00000000010100102 lalu dinegasikan tiap bitnya menjadi 11111111101011012 kemudian LSB ditambah 1 menjadi

1111111110101110 = 6545410 nilai ini melebihi jangkauan maksimum int yang berkisar di -32768 sampai 32767, sehingga nilai yang keluar yaitu 83.

Cara lain penulisan dengan menggunakan operator bitwise :

m = m << n m <<= n m = m >> n m >>= n m = m & n m &= n m = m | n m |= n m = m ^ n m ^= n

2.8.4. OPERATOR RELASI

Operator relasi digunakan untuk membandingkan dua buah nilai. Operator ini biasa digunakan dalam instruksi percabangan.


Operator Deskripsi == Sama dengan ( bukan assignment ) != Tidak sama dengan > Lebih besar < Lebih kecil >= Lebih besar atau sama dengan <= Lebih kecil atau sama dengan

2.8.5. OPERATOR LOGIKA

Operator logika digunakan untuk menghubungkan dua atau lebih ungkapan menjadi sebuah ungkapan berkondisi.

Operator Deskripsi Contoh && logic AND m && n || logic OR m || n ! logic NOT !m

2.8.6. OPERATOR KONDISI

Operator kondisi digunakan untuk memperoleh nilai dari dua kemungkinan

ungkapan1 ? ungkapan2 : ungkapan3

Bila nilai ungkapan1 benar, maka nilainya sama dengan ungkapan2, bila tidak maka nilainya sama dengan ungkapan3 Contoh :

#include <stdio.h> #include <conio.h> int main() { float nilai1, nilai2, maksimal; clrscr(); printf("Masukkan dua buah nilai : "); scanf("%f %f", &nilai1, &nilai2); maksimal=(nilai1 > nilai2) ? nilai1 : nilai2; printf("\nNilai terbesar adalah %4.0f", maksimal); getch(); return 0; }

Hasil :

Masukkan dua buah nilai : 34 54 Nilai terbesar adalah 54

Operator relasi, logika dan kondisi akan banyak digunakan pada pernyataan berkondisi

Pemrograman C | Operasi Masukan dan Keluaran 11

33 .. OOPPEERRAASSII MMAASSUUKKAANN DDAANN KKEELLUUAARRAANN

Memasukkan data dan menampilkan data/informasi merupakan tindakan yang sering dilakukan dalam pemrograman. Penampilan data/informasi biasanya ditujukan ke piranti layar (monitor), sedangkan pemasukan data biasanya dilakukan melalui keyboard.

3.1. MENAMPILKAN DATA KE LAYAR

Untuk keperluan penampilan data/informasi, Turbo C menyediakan sejumlah fungsi, diantaranya adalah printf(), puts() dan putchar().

3.1.1. PRINTF()

Merupakan fungsi yang paling umum digunakan dalam menampilkan data. Berbagai jenis data dapat ditampilkan ke layar dengan fungsi ini.

Bentuk penulisan : printf(“string kontrol”, argumen1, argumen2, …);

String kontrol dapat berupa keterangan yang akan ditampilkan pada layar beserta penentu format seperti %d, %f. Penentu format dipakai untuk memberi tahu kompiler mengenai jenis data yang akan ditampilkan

Argumen adalah data yang akan ditampilkan ke layar. Argumen ini dapatr berupa variabel, konstanta atau ungkapan

Contoh :

#include <stdio.h> #include <conio.h> int main() { int nilai1=20; float nilai2=2000.0; clrscr(); printf("Abad ke-%d\n", nilai1); printf("Abad ke-%3d\n", nilai1); printf("Abad ke-%7d\n", nilai1); printf("Tahun %f\n", nilai2); printf("Tahun %8.3f\n", nilai2); printf("Tahun %8.0f\n", nilai2); printf("Tahun %-8.0f\n", nilai2); getch(); return 0; }

Hasil :

Abad ke-20 Abad ke- 20 Abad ke- 20 Tahun 2000.000000 Tahun 2000.000 Tahun 2000 Tahun 2000


3.1.2. PUTS()

Fungsi ini digunakan khusus untuk menampilkan data string ke layar. Sifat fungsi ini, string yang ditampilkan secara otomatis akan diakhiri dengan “\n” (pindah baris). Dibandingkan dengan printf(), perintah ini mempunyai kode mesin yang lebih pendek. Contoh :

#include <stdio.h> #include <conio.h> char main() { puts("kucoba dan kucoba"); puts("kini ku mulai memahaminya"); getch(); return 0; }

Hasil :

kucoba dan kucoba kini ku mulai memahaminya

3.1.3. PUTCHAR()

Digunakan khusus untuk menampilkan sebuah karakter ke layar. Penampilan karakter tidak diakhiri dengan perpindahan baris, misalnya :

putchar(‘A’); sama dengan printf(“%c”, A); Contoh :

#include <stdio.h> #include <conio.h> char main() { putchar('A'); putchar('B'); putchar('C'); getch(); }

Hasil : ABC

3.2. MEMASUKKAN DATA

Data dapat dimasukkan lewat keyboard saat eksekusi berlangsung. Fungsi yang digunakan diantaranya adalah : scanf(), getch(), dan getche().

3.2.1. SCANF()

Merupakan fungsi yang dapat digunakan untuk memasukkan berbagai jenis data. Bentuk scanf() sesungguhnya menyerupai fungsi printf() yang melibatkan penentu format.

Bentuk penulisan : scanf(“string kontrol”, daftar argumen); Hal-hal yang perlu diperhatikan dalam pemakaian scanf() yaitu : 1. scanf() memberi pergantian baris secara otomatis, artinya Anda tidak perlu memberi “\n” untuk

berpindah ke baris berikutnya. 2. scanf() memakai penentu format, tetapi tidak memerlukan penentu lebar field. Contoh yang salah :

scanf(“10.2f”,&gaji); 3. Variabel yang dipakai di dalam scanf() harus didahului dengan operator alamat (&).


Contoh : #include <stdio.h> main() { float gaji,tunj,GAJI; clrscr(); printf("Masukkan Gaji Pokok = Rp. "); scanf("%f",&gaji); tunj = 0.1 * gaji; GAJI = gaji + tunj; /* gaji total*/ printf("\nTunjangan = Rp. %6.2f",tunj); printf("\nGaji Total = Rp. %6.2f",GAJI); getch(); }

Hasil : Masukkan Gaji Pokok = Rp. 1000000 Tunjangan = Rp. 100000.00 Gaji Total = Rp. 1100000.00

3.2.2. MEMASUKKAN DATA SECARA BERSAMAAN

Data dapat dimasukkan secara bersama-sama dalam satu baris. Setiap data dipisahkan oleh sebuah karakter. Karakter-karakter yang dapat bertindak sebagai pemisah data adalah : Koma (‘) Garis hubung (-) Titik dua (:) Spasi

Contoh :

#include <stdio.h> main() { int bil1,bil2,bil3; clrscr(); printf("Masukkan 3 buah bilangan bulat : "); scanf("%d-%d-%d",&bil1,&bil2,&bil3); printf("\nBilangan pertama : %3d",bil1); printf("\nBilangan kedua : %3d",bil2); printf("\nBilangan ketiga : %3d",bil3); getch(); }

Hasil : Masukkan 3 buah bilangan bulat : 12-24-48 Bilangan pertama : 12 Bilangan kedua : 24 Bilangan ketiga : 48

Data harus di masukkan dengan cara : 12-24-48 (sesuai dengan tanda pemisah data pada scanf)

3.2.3. GETCH() DAN GETCHE()

Dipakai untuk membaca sebuah karakter dengan sifat karakter yang dimasukkan tidak perlu diakhiri dengan enter. Fungsi getch() merupakan singkatan dari get character artinya baca karakter tetapi isian data yang dimasukkan tidak akan ditampilkan di layar.


Contoh : #include <stdio.h> main() { char karakter; clrscr(); printf(“Ketik sebuah karakter : “); karakter=getch(); printf(“\nKarakter yang diketik adalah : %c”,karakter); getche(); }

Hasil : Ketik sebuah karakter : Karakter yang diketik adalah : A

Nama fungsi getche() sebenarnya adalah singkatan dari get character and echo, artinya baca karakter lalu tampilkan di layar. Jadi setelah mengetikkan sebuah huruf, huruf tersebut akan ditampilkan di layar tanpa menekan enter. Catatan : Program yang menggunakan printf(), putchar(), scanf() dan puts() mengandung baris

yang berisi #include <stdio.h> Program yang melibatkan getche() atau getch() mengandung baris yang berisi

#include <conio.h>

3.3. FUNGSI‐FUNGSI NUMERIK

Turbo C mempunyai kurang lebih 450 fungsi dan makro yang dapat dipanggil dari program yang telah dibuat. Fungsi-fungsi tersebut meliputi berbagai hal, misalnya : Proses Input Output tingkat tinggi dan tingkat rendah Manipulasi string dan file Alokasi memori Kontrol Proses Konversi data Perhitungan matematik

Fungsi-fungsi tersebut ada di dalam file library-nya (Cx.LIB, Mathx.LIB dan Graphics.LIB). Huruf x diganti dengan model memori yang dipakai. Fungsi-fungsi tersebut disimpan di dalam file header (*.H). Fungsi tersebut dapat digabungkan ke dalam program dengan menyertakan file header yang mengandung fungsi atau rutin yang dipakai.

3.3.1. FUNGSI SQRT

Fungsi : Menghitung akar positif dari sebuah bilangan bulat Include : #include <math.h> Contoh :

#include <math.h> main() { double x,y; clrscr(); printf("\nMasukkan sebuah bilangan :"); scanf("%lf",&x); y = sqrt(x); printf("\n\nAkar dari %6.2lf adalah %6.2lf",x,y); getch(); }


3.3.2. FUNGSI POW

Fungsi : Menghitung xy Include : #include <math.h> Contoh :

#include <math.h> main() { double x,y,z; printf("\nMenghitung x pangkat y\n"); printf("\nMasukkan nilai x :"); scanf("%lf",&x); printf("\nMasukkan nilai y :"); scanf("%lf",&y); z = pow(x,y); printf("\nNilai %6.2lf Pangkat %6.2lf = %6.2lf",x,y,z); getch(); }

3.3.3. FUNGSI TAN

Fungsi : Menghitung nilai tangent dari sebuah sudut Include : #include <math.h> Fungsi tan menghitung nilai tangent dari sudut x. Sudut x dalam satuan radian. Jika sudut x yang diberikan dekat dengan phi/2 atau –phi/2, hasilnya adalah 0.

3.3.4. FUNGSI DIV

Fungsi : Membagi dua bilangan bulat, memberikan hasil bagi dan sisanya Include : #include <stdlib.h> Contoh :

#include <stdlib.h> main() { int x,y; div_t hasil; printf("Contoh fungsi --- div ---"); printf("\n\nMasukkan nilai x :"); scanf("%d",&x); printf("\n\nMasukkan nilai y :"); scanf("%d",&y); hasil = div(x,y);

printf("\n%-3d DIV %3d = %3d sisa %3d",x,y,hasil.quot,hasil.rem);

getch(); }

3.3.5. FUNGSI CEIL

Fungsi : Membulatkan ke atas Include : #include <math.h> Contoh :

#include <math.h> main() { double x,hasil; printf("Contoh fungsi --- ceil ---"); printf("\nMasukkan sebuah bilangan :"); scanf("%lf",&x); hasil = ceil(x);

printf("\n\nHasil pembulatan %6.2lf = %6.2lf", x,hasil); getch(); }


3.3.6. FUNGSI FLOOR

Fungsi : Membulatkan ke bawah Include : #include <math.h> Fungsi floor menghasilkan bilangan bulat terbesar yang tidak lebih dari x

3.3.7. FUNGSI EXP

Fungsi : Menghitung ex Include : #include<math.h> Contoh :

#include <math.h> main() { double x,hasil; printf("Contoh fungsi --- exp ---"); printf("\nMasukkan sebuah bilangan :"); scanf("%lf",&x); hasil = exp(x);

printf("\nHasil e pangkat %6.2lf = %6.2lf", x,hasil); getch(); }

3.3.8. FUNGSI MAX

Fungsi : Memberikan bilangan yang lebih besar dari 2 bilangan yang diberikan Include : #include <stdlib.h> Contoh :

#include <stdlib.h> main() { float a,b,c; printf("\n\nMasukkan nilai pertama :"); scanf("%f",&a); printf("\n\nMasukkan nilai kedua :"); scanf("%f",&b); c = max (a,b);

printf("\nNilai terbesar dari %5.1f dan %5.1f = %5.1f", a,b,c);

getch(); }

3.3.9. FUNGSI MIN

Fungsi : Memberikan bilangan yang lebih kecil dari 2 bilangan yang diberikan Include : #include <stdlib.h>

Pemrograman C | Kondisional 17

44 .. KKOONNDDIISSIIOONNAALL

Kondisional merupakan suatu pengambilan keputusan. Untuk keperluan pengambilan keputusan semacam itu, Bahasa C menyediakan beberapa jenis pernyataan berupa : Pernyataan if Pernyataan if-else Pernyataan switch

4.1. PERNYATAAN IF

Pernyataan if mempunyai bentuk umum : if (kondisi) pernyataan Arti dari perintah if adalah jika kondisi bernilai benar, maka pernyataan dikerjakan. Kondisi harus ditulis diantara tanda kurung dan dapat berupa sembarang ungkapan, sedangkan pernyataan dapat berupa sebuah pernyataan tunggal, pernyataan kosong. Operator relasi digunakan untuk membandingkan nilai dari dua buah ekspresi. Operator-operator yang dikenal Turbo C adalah :

Operator Keterangan < Lebih kecil > Lebih besar = = Sama dengan <= Lebih kecil sama dengan >= Lebih besar sama dengan != Tidak sama dengan

Contoh :

#include <stdio.h> #include <conio.h> main() { double beli, diskon; printf("Jumlah pembelian : Rp. "); scanf("%lf",&beli); diskon=0; if (beli >= 500000) { diskon=0.05*beli; printf("\nBesarnya diskon Anda Rp. %10.2lf",diskon);

} getch(); }

Hasil :

Jumlah pembelian : Rp. 500000 Besarnya diskon Anda Rp. 25000.00

Untuk pernyataan if yang diikuti dengan pernyataan majemuk, pernyataan if diapit dengan tanda { dan }.


4.2. PERNYATAAN IF‐ELSE

Bentuk umum : if (syarat1) pernyataan-1; else pernyataan2;

Jika kondisi benar maka pernyataan-1 dijalankan sedangkan bila kondisi salah maka pernyataan-2 yang akan dieksekusi. Contoh :

#include <stdio.h> #include <conio.h> main() { int i;

printf("Masukkan sebuah bilangan bulat bukan nol :"); scanf("%d",&i);

if (i==0) { printf("\nAnda Memasukkan Bilangan Nol...!"); printf("\nApakah Anda tidak melihat instruksi..?"); } else { printf("\nBilangan yang anda masukkan adalah : %d",i);

} getch(); }

Hasil : Masukkan sebuah bilangan bulat bukan nol :0 Anda Memasukkan Bilangan Nol...! Apakah Anda tidak melihat instruksi..?

4.3. NESTED IF

Di dalam suatu pernyataan if atau if-else bisa saja terdapat pernyataan if atau if-else yang lain. Bentuk seperti ini dinamakan sebagai nested if. Contoh :

#include <stdio.h> #include <conio.h> main() { float x,y; printf("Masukan nilai x dan y : "); scanf("%f %f", &x, &y); if (x>0) { if (y>0) { puts("Nilai x dan y positif"); }else{ puts("Nilai x positif dan y negatif");

} }else{

puts("Nilai x negatif dan y bernilai positif atau negatif");

} getch(); }

Hasil :

Masukan nilai x dan y : -12 -12 Nilai x negatif dan y bernilai positif atau negatif


4.4. PENGGUNAAN ELSE BERTINGKAT

Bentuk umum :

if (syarat1) pernyataan; else if (syarat2) pernyataan; else if (syarat3) pernyataan; else pernyataan;

Syarat if diperiksa dari atas ke bawah. Jika sebuah syarat benar, pernyataan yang mengikutinya akan dikerjakan dan yang selanjutnya diabaikan. Jika tidak satupun syarat yang benar, else terakhir akan dikerjakan. Jika else terakhir tidak ada dan tidak ada syarat yang benar, maka tidak ada yang dikerjakan. Contoh :

#include <stdio.h> main() { int no_menu; printf("\n Menu Restaurant Mc’A"); printf("\n============================"); printf("\n1. Nasi Goreng"); printf("\n2. Nasi Soto Ayam"); printf("\n3. Gado-gado"); printf("\n============================"); printf("\nPilihan Anda... :"); scanf("%d",&no_menu); if (no_menu==1) printf("\nPilihan No.1 Nasi Goreng Rp.5.000,-"); else if (no_menu==2) printf("\nPilihan No.2 Nasi Soto Ayam Rp.7.000,-"); else if (no_menu==3) printf("\nPilihan No.3 Gado-gado Rp.4.500,-"); else printf("\nPilihan Anda tidak ada pada menu...!"); }

Hasil :

Menu Restaurant Mc'A ======================================= 1. Nasi Goreng Rp. 5.000,- 2. Nasi Soto Ayam Rp. 7.000,- 3. Gado-gado Rp. 4.500,- ======================================= Pilihan Anda... :1

Pilihan No.1 Nasi Goreng Informatika Rp.5.000,-

4.5. PERNYATAAN SWITCH

Tangga if-else dapat dipakai untuk menguji beberapa syarat, tetapi kadang-kadang sulit. Cara lain adalah dengan pernyataan switch. Di dalam pernyataan switch, sebuah variabel secara berturut-turut diuji oleh daftar konstanta bilangan bulat atau konstanta karakter. Jika sesuai dengan sebuah konstanta, pernyataan yang mengikuti konstanta akan dikerjakan.


Bentuk Umum :

switch (variabel) { case konstanta1; pernyataan; break; case konstanta2; pernyataan; break; default pernyataan; }

Jika sebuah konstanta sesuai dengan isi variabel, pernyataan-pernyataan setelah case akan dikerjakan sampai ditemukan pernyataan break. Pernyataan setelah default akan dikerjakan jika tidak ada konstanta yang sesuai. Pernyataan default bersifat optional. Jika tidak ada default dan tidak ada konstanta yang sesuai, tidak ada yang dikerjakan. Pernyataan break di dalam switch bersifat optional. Break dipakai untuk menghentikan pelaksanaan pernyataan-pernyataan yang mengikuti sebuah konstanta. Jika break tidak ada, pernyataan pada case berikutnya akan dilaksanakan sampai ditemukan break atau akhir dari switch. Juga dapat membuat sebuah switch di dalam sebuah switch (nested switch) Ada tiga hal penting : 1. Switch hanya dapat memeriksa persamaan dengan sebuah konstanta, sedangkan if dapat

memeriksa syarat-syarat lain (lebih besar, lebih kecil, tidak sama dengan dan sebagainya) 2. Tidak ada dua konstanta yang sama didalam sebuah switch 3. Pernyataan switch lebih baik daripada tangga if-else Contoh :

#include <stdio.h> #include <conio.h> main() { int kelas; float harga,pajak; printf("\nHarga Barang : Rp. "); scanf("%f",&harga); printf("\nMasukkan Jenis (1-3) : "); scanf("%d",&kelas); switch (kelas) {

case 1 : printf("\n\nJenis Barang : Makanan"); printf("\nHarga Barang : Rp. %6.2f",harga); pajak = 0.1 * harga; printf("\nPajak : Rp. %6.2f",pajak); break; case 2 : printf("\n\nJenis Barang : Pakaian, Sepatu"); printf("\nHarga Barang : Rp. %6.2f",harga); pajak = 0.15 * harga; printf("\nPajak : Rp. %6.2f",pajak); break; default :

printf("\n\nPilihan Kelas salah...!"); } getch(); }

Pemrograman C | Pengulangan Proses 21

55 .. PPEENNGGUULLAANNGGAANN PPRROOSSEESS

Merupakan pengulangan (looping) perintah-perintah sampai mencapai keadaan tertentu. Turbo C mempunyai 3 jenis pengulangan, yaitu :

for while do – while

5.1. PENGULANGAN DENGAN FOR

Bentuk umum :

for (inisialisasi; syarat; penambahan) pernyataan; Keterangan : Inisialisasi adalah pernyataan untuk menyatakan keadaan awal dari variabel kontrol. Syarat adalah ekspresi relasional yang menyatakan berhentinya pengulangan. Penambahan menyatakan perubahan variabel kontrol setiap terjadi pengulangan. Setiap bagian

harus dipisahkan oleh tanda titik koma. Contoh :

#include <stdio.h> main() { int i; for (i=1; i <=5 ; i++) { printf("%d \n",i); } }

Pada program tersebut : Inisialisasi : i = 1 Syarat : i <= 5 Penambahan : i++ , artinya ditambah 1

5.1.1. VARIASI PENGULANGAN DENGAN FOR

Kita dapat memakai beberapa variabel kontrol di dalam pengulangan for, Contoh :

#include <stdio.h> main() { int x,y; for (x=0,y=0; x+y<=20; x++,++y) { printf("%d\n",x+y); } }

Program di atas mencetak bilangan 0 sampai 20. Perhatikan pernyataan for di atas. Inisialisasi : x=0, y=0 Syarat : x+y <= 20 Penambahan : x++, y++ Tanda koma dipakai untuk memisahkan dua pernyataan di dalam sebuah bilangan. Misalnya di bagian inisialisasi ada pernyataan x=0 dan y=0. Tanda koma berarti lakukan “ini” dan “ini”.


5.1.2. MENGHILANGKAN SEBUAH BAGIAN PENGULANGAN

Variasi lain adalah dengan menghilangkan salah satu bagian dari loop, Contoh :

#include <stdio.h> main() { char ch; printf("Ketikkan karakter-karakter (z = stop) : \n"); for (ch=' '; ch!='z'; ) ch=getche(); }

Pada program di atas, diminta untuk mengetikkan karakter-karakter dan program akan berhenti jika mengetikkan huruf ‘z’.

5.1.3. PENGULANGAN TAK HINGGA

Pengulangan tak hingga dibuat dengan menghilangkan bagian syaratnya, Contoh :

#include <stdio.h> main() { char ch; printf("Ketikkan karakter-karakter : \n"); for (ch=' '; ; ) ch=getche(); }

Program tersebut meminta mengetikkan sebuah huruf dan tidak akan berhenti. Untuk menghentikannya tekan tombol CTRL + BREAK

5.1.4. PENGULANGAN TANPA PERNYATAAN

Pengulangan tanpa pernyataan dipakai untuk menunggu. Semakin banyak pengulangan, semakin lama menunggu., Contoh :

#include <stdio.h> main() { int t,x;

printf("Berapa kali loop Anda akan menunggu : \n"); scanf("%d",&x);

for (t=0 ; t<x ; t++ ) ; }

5.1.5. PENGULANGAN BERSARANG

Perhatikan contoh program berikut : #include <stdio.h> main() { int i,j; for (i=1 ; i <= 3 ; i++) { for (j=1 ; j <= 5 ; j++ ) { printf("*");

} printf(" \n"); } getch(); }

Dari contoh tersebut dapat kita simpulkan bahwa variabel i menyatakan baris dan variabel j menyatakan kolom.


5.2. PENGULANGAN DENGAN WHILE DAN DO‐WHILE

5.2.1. PENGULANGAN DENGAN WHILE

Bentuk umum :

while (syarat) pernyataan; Pernyataan pada while dapat berupa sebuah pernyataan atau blok pernyataan atau pernyataan kosong. Pernyataan akan diulang selama syarat benar, Contoh :

main() { int i; i=1; while (i <= 5) { printf("STI&K\n"); i=i+1; } getch(); }

Pengulangan while menyatakan bahwa pengulangan akan dilakukan selama syarat terpenuhi.

5.2.2. PENGULANGAN DENGAN DO‐WHILE

Pengulangan for dan while akan mengecek syarat pengulangan pada awal loop. Sedangkan pada do-while akan mengecek syaratnya pada akhir pengulangan. Pengulangan pada do-while akan selalu dikerjakan minimal sekali. Pengulangan do-while menyatakan bahwa pengulangan akan dilakukan selama syarat terpenuhi. Bentuk umum :

do { statemen; statemen; } while (syarat);

Bentuk umum untuk do-while adalah pada rutin pemilihan menu, sebab menu selalu dikerjakan minimal sekali,

Pemrograman C | Fungsi 24

66 .. FFUUNNGGSSII

Fungsi (function) adalah sebuah blok di dalam program Bentuk umum :

tipe nama_function (deklarasi parameter) { pernyataan; pernyataan; }

Tipe adalah tipe nilai yang dihasilkan oleh function. Jika tidak dinyatakan, hasil function dianggap bilangan bulat (int) Deklarasi parameter merupakan daftar tipe dan nama variabel yang akan menerima nilai pada saat function tersebut dipanggil. Setiap parameter dipisahkan oleh tanda koma. Jika function tidak mempunyai parameter daftar ini akan kosong. Jadi hanya tanda kurung saja. Deklarasi parameter agak berbeda dengan deklarasi variabel. Pada deklarasi variabel dapat menyatakan sebuah tipe untuk beberapa variabel yang tipenya sama. Contoh :

int a,b,c;

Tetapi pada deklarasi parameter harus menyatakan setiap tipe dari parameter. Bentuk umum :

f (tipe nama_var1, tipe nama_var2, …, tipe nama_varn); Contoh : f (int a, int b, int c); Pernyataan return menyatakan dua hal : 1. Return mengakhiri jalannya function dan kembali ke program pemanggil 2. Menghasilkan sebuah nilai Ada dua cara untuk kembali ke program pemanggil : 1. Pada saat pernyataan terakhir dari function dijumpai (dijumpai tanda akhir function “}” )

Contoh : main() { hai(); } hai() { printf("Hai.. Apa kabar..?"); }

2. Menggunakan pernyataan return. Pernyataan return juga dapat dipakai tanpa menghasilkan nilai.

Contoh : main() { hai(); } hai() { printf("Hai.. Apa kabar..?"); return; printf("\nBaik-baik saja kannn..?"); }

Pernyataan return pada program di atas akan mengakhiri function hai() sehingga program di bawahnya tidak dikerjakan. function hai() pada program di atas hanya dapat mencetak Hai.. Apa kabar..?. Jika kita menginginkan function tersebut dapat mencetak pesan yang berlainan, kita harus mengubahnya menjadi seperti berikut:


main() { hai("Haloo...!"); hai("Siapa nama kamu..?"); } hai(char pesan[20]) { printf("%s \n",pesan); }

Pada contoh di atas pemanggilan function hai() menggunakan argumen, yaitu Haloo...! dan Siapa nama kamu..?. Di dalam function hai() harus ada variabel yang menerima argumen tersebut. Dalam hal ini adalah pesan (dinamakan parameter). Sifat-sifat parameter sama seperti variabel lokal yang ada di dalam function. Tipe parameter harus sama dengan tipe argumen. Untuk menghasilkan sebuah nilai, kita harus menyatakan return beserta nilai yang dihasilkannya. Contoh :

main() { int a,b,c; printf("Masukkan nilai A : "); scanf("%d",&a); printf("Masukkan nilai B : "); scanf("%d",&b); c=jumlah(a,b); printf("\nJumlah kedua bilangan adalah %4d",c); } jumlah(int x, int y) { return x+y; }

Function jumlah() pada program di atas mempunyai 2 parameter yaitu : • jumlah(a,b) • jumlah(int x, int y) Isi variabel a dan b dikirimkan ke function jumlah() dan diterima oleh x dan y. Namanya tidak harus sama, tetapi tipenya harus sama. Dalam hal ini semua bertipe int. Perhatikan program :

c = jumlah(a,b) return x+y

Function jumlah() menghasilkan x+y dan hasilnya dimasukkan ke variabel c. Yang penting, variabel penerima dan hasil function harus bertipe sama. Jika tipe tidak dinyatakan secara eksplisit, function tersebut menghasilkan nilai yang bertipe int. Misalnya kita akan mengubah hasil function menjadi float, maka ada dua cara yang harus diperhatikan : 1. Function harus diberi tipe secara eksplisit 2. Sebelum function dipanggil untuk pertama kali, compiler harus diberitahu tipe function tersebut. Cara mendeklarasikan function dengan suatu tipe, sama dengan deklarasi variabel, yaitu tipe mendahului nama function. Contoh :

float jumlah(float x, float y); main() { float a,b,c; printf("Masukkan nilai A : "); scanf("%f",&a); printf("Masukkan nilai B : "); scanf("%f",&b); c=jumlah(a,b); printf("\n\nJumlah kedua tersebut adalah %4.1f",c); } float jumlah(float x, float y) { return x+y; }


6.1. PROTOTYPE FUNCTION

Prototipe function menyatakan 2 hal : 1. Tipe dari nilai yang dihasilkan function, agar compiler dapat menghasilkan kode yang benar untuk

tipe nilai yang dihasilkan 2. Tipe dan banyaknya argumen yang dipakai oleh function. Bentuk umum :

tipe nama_function(daftar parameter) Biasanya prototipe diletakkan di awal program, dan harus ditemukan sebelum function tersebut dipanggil untuk pertama kalinya. Perhatikan baris 1 pada program di atas. Pernyataan tersebut adalah prototipe function. Pemanggilan function jumlah() ada di program c=jumlah(a,b) , jadi prototipe berada sebelum pemanggilannya.

6.2. FUNCTION DENGAN TIPE VOID

Function yang tidak menghasilkan nilai dapat dideklarasikan sebagai tipe void. Hal ini dapat mencegah kesalahan yang tidak disengaja. Contoh :

void hai(); main() { clrscr(); hai(); getch(); } void hai() { printf("Hai... Apa kabar?"); }

Jika tidak menyatakan tipe void, Turbo C menganggap function menghasilkan nilai bilangan bulat.

6.3. VARIABEL LOKAL

Variabel yang dideklarasikan di dalam function dinamakan variabel lokal. Di dalam Turbo C, sebuah variabel bersifat lokal terhadap sebuah blok, jadi lebih sempit dibandingkan dengan sebuah function. Sebenarnya sebuah function juga merupakan sebuah blok dan blok tersebut dapat memiliki blok yang lebih kecil lagi. Variabel lokal hanya dapat dipakai di dalam blok dimana variabel tersebut di deklarasikan. Sebuah blok dimulai dengan tanda { dan diakhiri dengan tanda }. Variabel lokal dibuat pada saat blok tempat deklarasi variabel tersebut dijalankan. Jika blok tersebut sudah selesai dikerjakan, variabel lokal akan dibuang. Contoh :

#include <math.h> float akar (float x); main() { float a,b; clrscr(); printf("Masukkan sebuah bilangan : "); scanf("%f",&a); b=akar(a); printf("\n\nAkar dari bilangan tersebut adalah %6.2f",b); getch(); }


float akar(float x) { float y; if (x>=0) { y=sqrt(x); return y; }else return 0; }

6.4. VARIABEL GLOBAL

Variabel global dikenal di setiap bagian program. Variabel global akan menyimpan nilai yang ada di dalamnya, selama program dijalankan. Variabel global di deklarasikan di luar semua function. Contoh :

int a; void f1(void); main() { clrscr(); printf("Masukkan nilai A adalah "); scanf("%d",&a); f1(); printf("\n\nNilai A sesudah pemanggilan function = %3d",a); } void f1(void) { printf("\n\nNilai A dalam function sebelum dijumlah = %3d",a); a+=5; printf("\n\nNilai A dalam function sesudah dijumlah = %3d",a); }

Pada baris 2, variabel a di deklarasikan sebelum function main(). Sebenarnya variabel global boleh diletakkan disetiap tempat, sebelum pemakainnya yang pertama. Variabel global sebaiknya diletakkan di awal program.

6.5. REKURSI

Fungsi dalam Bahasa C dapat dipakai secara rekursi, dalam artian suatu fungsi dapat memanggil dirinya sendiri. Rekursi jarang dipakai, diantaranya disebabkan : • Membuat fungsi sulit untuk dipahami • Hanya cocok untuk persoalan tertentu saja • Memerlukan stack dengan ukuran yang lebih besar. Contoh :

#include <stdio.h> int faktorial(int); main() { clrscr(); int x; puts("Mencari Nilai Faktorial"); printf("Masukkan sebuah bilangan bulat positif : "); scanf("%d",&x); printf("Nilai faktorial dari %d = %d\n", x, faktorial (x)); } int faktorial(int m) { if (m==1) { return(1); }else return(m*faktorial(m-1)); }

Pemrograman C | Array dan Pointer 28

77 .. AARRRRAAYY DDAANN PPOOIINNTTEERR

7.1. ARRAY

Array adalah deretan variabel yang berjenis sama dan mempunyai nama sama. Pada bahasa C, array mempunyai lokasi yang bersebelahan. Alamat terkecil menunjuk ke elemen pertama dan alamat terbesar menunjuk ke alamat terakhir. Sebuah elemen pada array diakses melalui indeksnya. Bentuk umum deklarasi array :

type nama_array[ukuran] tipe : menyatakan tipe dasar array ukuran : menyatakan banyaknya elemen pada array Contoh :

int nilai[10];

hal ini menyatakan array nilai mempunyai 10 elemen, yaitu : nilai[1], nilai[1], nilai[2], …, nilai [10]

Untuk array 1 dimensi, rumus ukuran total array dalam satuan byte adalah :

byte total = ukuran dari tipe dasar * banyaknya elemen Contoh :

int nilai[10]; byte total = 2 * 10 = 20 byte (variabel bertipe int memerlukan tempat sebesar 2 byte.)

Bahasa C tidak melakukan pengecekan batas array, artinya Anda dapat memproses array meskipun sudah melewati elemen terakhirnya, Jika hal ini terjadi pada saat Anda mengisi array, berarti tanpa sadar Anda telah mengisi variabel yang terletak bersebelahan dengan array tersebut. Contoh :

main() { int i; int a[10]; clrscr(); for(i=1; i<=99; i++) { a[i] = i*2; printf("\n a[%2d] = %3d", i,a[i]); } getch(); }

Pada contoh di atas, pengulangan dilakukan sebanyak 99 kali (dari 1 sampai 99), padahal array a hanya mempunyai 10 elemen. Sebagai pemogram Anda harus yakin bahwa array yang Anda buat dapat mencukupi kebutuhan. Bahasa C memang tidak mengecek batas array, tidak seperi bahasa yang lain. Alasannya karena bahasa C dirancang untuk menggantikan bahasa assembly dan diharapkan agar prosesnya lebih cepat.

7.1.1. ARRAY MULTI DIMENSI

Bahasa C mengijinkan array dengan beberapa dimensi, contoh array 2 dimensi. Array 2 dimensi adalah sebuah daftar yang terdiri atas array-array 1 dimensi. Misalnya kita akan membuat array 2 dimensi dengan ukuran 3x5, bertipe int, maka deklarasinya adalah : int a[3] [5];


Deklarasi array pada bahasa C tidak sama dengan bahasa-bahasa lain. Biasanya setiap dimensi dipisahkan oleh tanda koma, tetapi bahasa C meletakan setiap dimensi di dalam kurung siku. Contoh :

main() { int i,j; int b[3] [5]; clrscr(); for(i=1; i<=3; i++) { for(j=1; j<=5; j++) { b[i] [j] = i*j; printf("%3d", b[i] [j]); } printf("\n"); } getch(); }

Array 2 dimensi disimpan di dalam matriks yang tersusun menjadi baris dan kolom. Index pertama menunjukkan barisnya dan index kedua menunjukkan kolomnya. Ukuran array di dalam memori yaitu : total byte = baris * kolom * ukuran dari tipe. Untuk array di atas total byte = 3*5*2 = 30 byte

7.1.2. ARRAY STRING

Array string sama dengan array karakter 2 dimensi. Indeks pertama menunjukkan banyaknya string dan indeks kedua menunjukkan panjang maksimum string. Contoh :

char nama[10] [25] nama terdiri dari 10 elemen dengan panjang maksimum 25 karakter. Untuk membaca data string dapat menggunakan fungsi gets(). Misalnya ingin membaca nama ketiga, maka gets(nama[3]); Contoh :

main() { char nama[10] [25]; float nilai[10], jumlah, rata; int data,i; clrscr(); printf("Banyaknya data : "); scanf("%d",&data); for (i=1; i<=data; i++) { printf("Nama Mahasiswa : "); scanf("%s",&nama[i]); printf("Nilai : "); scanf("%f",&nilai[i]); jumlah += nilai[i]; } clrscr(); printf("\nDaftar Nilai Ujian Bahasa C"); printf("\n=================================="); printf("\nNama Mahasiswa Nilai"); printf("\n=================================="); for (i=1; i<=data; i++) { printf("\n %-25s %5.1f", nama[i], nilai[i]); } printf("\n=================================="); rata= jumlah / data; printf("\nRata-rata adalah %5.2f ", rata); }


7.1.3. INISIALISASI ARRAY

Bentuk umum :

tipe nama_array [ukuran1, ukuran2, …, ukuran n] = {daftar nilai}; Daftar nilai berisi konstanta yang sesuai dengan tipe array. Setiap konstanta dipisahkan oleh tanda koma. Konstanta pertama akan mengisi elemen pertama, konstanta kedua untuk elemen kedua dan seterusnya. Misal : int i[10] = {12,45,67,34,2,5,60,7,19,21};

7.2. POINTER

Pointer adalah tipe data yang digunakan untuk menyimpan alamat memori sebuah variable dan bukan menyimpan nilai datanya. Pointer di definisikan juga sebagai sebuah variabel yang berisi alamat dari variabel lain.

Dari gambar di atas, variabel A berada di alamat 1004 , variabel B di 1005 dan seterusnya. 1004 ini adalah alamatnya, sedangkan 20 adalah isinya. Operator Pointer Ada 2 operator pointer : 1. Operator &

Bersifat unary (hanya memerlukan satu operan). Operator ini menghasilkan alamat dan operannya. Contoh : x = &a, jika kita mengacu pada gambar di atas, maka isi variabel x adalah 1004.

2. Operator * Operator * dan operator & bersifat saling komplemen. Operator * juga bersifat unary dan menghasilkan nilai yang berada pada sebuah alamat..

Contoh:

#include<stdio.h> main() { int a, *x, b; clrscr(); a=5; x=&a; b=*x; printf("\n Isi variabel a adalah %4d", a); printf("\n Isi variabel x adalah %4u", x); printf("\n Isi variabel b adalah %4d", b); getch(); }

Hasil :

Isi variabel a adalah 5 Isi variabel x adalah 65494 Isi variabel b adalah 5


Keterangan : Variabel a berisi 5 Variabel x berisi alamat dari variabel a. Karena variabel x berisi alamat dari variabel yang bertipe int,

maka deklarasi variabel x adalah int *x. Tanda * di depan x menyatakan variabel x berisi alamat, sedangkan int menyatakan variabel x berisi alamat dari variabel int. Jika variabel x berisi alamat dari variabel yang bertipe float, maka deklarasinya adalah float *x

Variabel b berisi nilai yang ditunjuk oleh x, yaitu 5. Jadi a=b Alamat dapat dicetak dengan format %u sebab alamat adalah bilangan bulat tanpa tanda (unsigned

integer)

7.2.1. OPERASI PADA POINTER

Operasi aritmatika pada pointer hanya ada 2, yaitu penambahan dan pengurangan. Contoh :

main() { int a, *p1, *p2; clrscr(); a=5; p1=&a; printf("\n Isi p1 sebelum ditambah adalah %5u", p1); p1++; printf("\n Isi p1 sesudah ditambah adalah %5u", p1); p2=&a; printf("\n Isi p2 sebelum dikurangi adalah %5u", p2); p2--; printf("\n Isi p2 sesudah dikurangi adalah %5u", p2); p2 = p2 + 5; printf("\n Isi p2 sesudah ditambah dengan 5 adalah %5u", p2); getch(); }

Hasil :

Isi p1 sebelum ditambah adalah 65494 Isi p1 sesudah ditambah adalah 65496 Isi p2 sebelum dikurangi adalah 65494 Isi p2 sesudah dikurangi adalah 65492 Isi p2 sesudah ditambah dengan 5 adalah 65502

Keterangan : Variabel a bertipe int, variabel p1 dan p2 adalah pointer yang menunjuk ke variabel int Pernyataan p1++ menyebabkan p1 bertambah dengan 2 sebab variabel integer berukuran 2 byte

juga dengan p2-- akan berkurang 2 Pernyataan p2=p2+5 menunjuk ke 5 elemen berikutnya sesuai dengan tipe int

7.2.2. POINTER DAN ARRAY

Contoh : char nama[20], *p1; p1=nama;

Variabel p1 berisi alamat dari elemen pertama dari variabel nama. Didalam bahasa C, nama array tanpa index sama dengan alamat dari awal array. Pernyataan p1=nama sama dengan p1=&nama[1] Pernyataan p2=str[4] artinya p2 akan menunjuk elemen ke empat dari nama, cara lainnya adalah :

p1=nama; p2=*(p1+4);


Array dapat ditunjuk dengan index-nya dan dengan alamat. Penunjukan dengan alamat akan lebih cepat daripada penunjukan dengan index-nya. Biasanya program C lebih mementingkan kecepatan sehingga dipilih penggunaan alamat. Contoh :

/* menggunakan index array */ main() { char str[80]; int i; clrscr(); printf("Masukkan string dalam huruf besar : "); gets(str); printf("String dalam huruf kecil : "); for(i=0; str[i]; i++) printf("%c",tolower(str[i])); getch(); } /* menggunakan pointer */ #include <stdio.h> #include <ctype.h> main() { char str[80], *p; clrscr(); printf("Masukkan string dalam huruf besar : "); gets(str); printf("String dalam huruf kecil : "); p=str; while (*p) printf("%c",tolower(*p++)); getch(); }

7.2.3. POINTER DAN STRING

Nama array tanpa index adalah pointer ke elemen pertama dari array. Fungsi string yang mempunyai parameter berupa string hanya mengirimkan alamatnya bukan stringnya sendiri. Contoh :

#include <stdio.h> main() { char s[80]; char *p; int i; clrscr(); printf("Masukkan dua buah kalimat : "); gets(s); for (i=0; s[i] && s[i] != '.'; i++); p=&s[i+1]; printf("Kalimat keduanya adalah : \n"); printf(p); getch(); }

Keterangan : Pada pengulangan for akan berhenti jika pada string tersebut ditemukan karakter titik atau null Pernyataan p=&s[i+1], akan menunjuk ke karakter sesudah titik atau null. Misalnya karakter kelima

adalah titik, maka p akan menunjuk ke karakter ke enam. Pernyataan tersebut dapat diganti dengan p=&s[i]+1


7.2.4. ARRAY POINTER

Pernyataan int *x[10] mendeklarasikan array x yang berisi pointer integer. Untuk mengisi elemen keempat dengan alamat dari variabel a yang bertipe int, pakailah : x[4] =&a, sedangkan untuk memperoleh isi variabel a adalah : *x[4] Contoh :

main() { char *menu[] = { "Nasi Goreng + Telur Mata Sapi\n", "Bistik Ayam\n", "Soto Ayam Madura\n", "Gado-gado\n" }; int no_menu; clrscr(); printf("Masukkan menu pilihan Anda (1-4) : "); scanf("%d",&no_menu); printf("\nMenu yang Anda minta adalah : \n"); printf("%s",menu[no_menu-1]); getch(); }

Pemrograman C | Fungsi-Fungsi String 34

88 .. FFUUNNGGSSII‐‐FFUUNNGGSSII SSTTRRIINNGG

String merupakan bentuk data yang biasa dipakai dalam bahasa pemrograman untuk keperluan menampung dan memanipulasi data teks, misalnya untuk menampung (menyimpan) suatu kalimat.

8.1. VARIABEL STRING

Variabel string adalah variabel yang dipakai untuk menyimpan string, misalnya : char nama[20]; Merupakan instruksi untuk mendeklarasikan variabel string dengan panjang maksimal mengandung 20 karakter (termasuk karakter NULL). Pemasukan data string ke dalam suatu variabel biasa dilakukan dengan memakai gets(). Bentuk penulisan : gets(nama variabel); Jika memakai scanf() instruksinya menjadi scanf(“%s”, nama variabel); Didepan nama variabel tidak perlu menggunakan operator & Data string yang dimasukkan tidak dapat mengandung spasi Prototipe gets() ada pada file stdio.h

Untuk menampilkan isi variabel string, pernyataan yang dapat digunakan berupa : puts(variabel string); printf(“%s”, variabel string); printf(variabel string);

Contoh :

#include <stdio.h> main() { char nama[20]; char alamat[30]; clrscr(); printf("Masukkan Nama : "); gets(nama); printf("Masukkan Alamat : "); scanf("%s",&alamat); printf("%s beralamat di %s",nama,alamat); getch(); }

8.2. FUNGSI STRLEN

Fungsi : Menghitung panjang string Include : #include <string.h> Prototipe : unsigned int strlen(const char *s) Hasil dari fungsi ini adalah banyaknya karakter di dalam string termasuk spasi. Argumen fungsi ini memakai pointer (dinyatakan dengan tanda *). Contoh :

#include <string.h> main() { char nama[20]; clrscr(); printf("\nNama Mahasiswa : "); gets(nama); printf("\nPanjang string %s adalah %3d",nama,strlen(nama)); getch(); }


8.3. FUNGSI STRLWR

Fungsi : Mengubah semua huruf besar yang ada di dalam sebuah string menjadi huruf kecilnya Include : #include <string.h> Prototipe : char *strlwr(char *s) Fungsi strlwr mengubah huruf besar (A-Z) menjadi huruf kecilnya. Karakter-karakter lain tidak diubah. Hasilnya ada di dalam variable s. Contoh :

#include <string.h> main() { char nama[20]; printf("Nama Mahasiswa (huruf kapital) : "); gets(nama); printf("\nHasil dari fungsi strlwr = %s",nama,strlwr(nama)); }

8.4. FUNGSI STRUPR

Fungsi : Mengubah semua huruf kecil yang ada di dalam sebuah string menjadi huruf besarnya Include : #include <string.h> Prototipe : char *strupr(char *s) Fungsi strupr mengubah huruf kecil (a-z) menjadi huruf besarnya. Karakter-karakter lain tidak diubah. Hasilnya ada di dalam variabel s

8.5. FUNGSI STRCPY

Fungsi : Menyalin sebuah string ke string lain Include : #include <string.h> Prototipe : char *strcpy(char *a, const char *b) Contoh :

#include <string.h> main() { char a[20]="Bahasa C"; char b[20]="Belajar Bahasa C"; strcpy(a,b); printf("Hasil dari fungsi strcpy adalah %s",a); }

8.6. FUNGSI STRCAT

Fungsi : Menggabung dua buah string Include : #include <string.h> Prototipe : char *strcat(char *a, const char *b) Contoh :

#include <string.h> main() { char alamat1[20]; char alamat2[20]; printf("\nMasukkan alamat 1 :"); gets(alamat1); printf("\nMasukkan alamat 2 :"); gets(alamat2); printf("\n\nAlamat lengkap = %s",strcat(alamat1,alamat2)); }


8.7. FUNGSI ATOF

Fungsi : Mengubah sebuah string menjadi bilangan real (floating point) Include : #include <math.h> Prototipe : double atof(const char *s) Fungsi atof ini mengenali semua karakter yang membentuk bilangan floating point. Proses pengubahan akan berhenti jika ditemukan karakter-karakter yang bukan pembentuk floating point, misalnya : spasi, tanda baca (selain titik) dan karakter lain yang bukan “E” atau “e”. Jika string tidak dapat diubah menjadi tipe double, hasilnya menjadi 0. Jika terjadi overflow, atof akan menghasilkan HUGE_VAL dengan tanda plus atau minus. Contoh :

#include <stdlib.h> main() { char bilangan[5]; double bil; printf("Masukkan sebuah bilangan : "); gets(bilangan); bil=atof(bilangan); printf("\n\nBilangan hasil konversi adalah %6.1lf",bil); getch(); }

Hasil :

Masukan Keluaran 100 orang 100.0 1e6 1000000.0 100 dan 200 100.0

atof singkatan dari ascii to floating point

atoi singkatan dari ascii to integer dengan tipe hasil int

atol singkatan dari ascii to long int dengan tipe hasil long int

Pemrograman C | Lebih Jauh Dengan Pointer dan Struktur 37

99 .. LLEEBBIIHH JJAAUUHH DDEENNGGAANN PPOOIINNTTEERR DDAANN SSTTRRUUKKTTUURR

Pointer banyak dilibatkan dalam program C, misalnya untuk melewatkan string dari suatu fungsi ke fungsi yang lain. Penerapan pointer yang paling umum yaitu untuk menciptakan variabel dinamis yang memungkinkan untuk memakai memori bebas (memori yang belum dipakai) selama eksekusi program. Variabel pointer sering dikatakan sebagai variabel yang menunjuk ke obyek lain. Pada kenyataan yang sebenarnya, variabel pointer berisi alamat dari suatu objek lain yaitu objek yang dikatakan ditunjuk oleh pointer. Sebagai contoh, px adalah pointer dan x adalah variabel yang ditunjuk oleh px. Jika px berada pada alamat memori (alamat awal) 1000, maka px akan berisi 1000. Suatu variabel pointer dideklarasikan dengan bentuk :

tipe *nama_variabel; dengan tipe berupa sembarang tipe sedang nama_variabel adalah nama dari pointer. Agar suatu pointer menunjujk ke variabel lain, mula-mula pointer harus diisi dengan alamat dari variabel yang akan ditunjuk. Untuk menyatakan alamat dari suatu variabel, operator & (operator alamat, yang bersifat unary) bisa digunakan dengan cara menempatkan operator di depan nama variabel. Jika suatu variabel sudah ditunjuk pointer, variabel tersebut dapat diakses melalui variabel itu sendiri (dikatakan sebagai pengaksesan langsung) ataupun melalui pointer (dikatakan sebagai pengaksesan tidak langsung). Pengaksesan tak langsung dilakukan dengan menggunakan operator indirection berupa simbol * (bersifat unary). Contoh :

main() { int x, y; int *px; /* px pointer yang menunjuk objek bertipe int */ x=87; px=&x; y=*px; printf("Alamat x = %p", &x); printf("\nIsi px = %p", px); printf("\nIsi X = %d", x); printf("\nNilai yang ditunjuk oleh px = %d", *px); printf("\nNilai y = %d",y); }

Hasil : Alamat x = FFCC Isi px = FFCC Isi X = 87 Nilai yang ditunjuk oleh px = 87 Nilai y = 87

Antara tipe pointer dan tipe objek yang akan ditunjuk oleh pointer haruslah sejenis. Contoh pemakaian pointer yang salah :

main() { float *pu, nu; int u = 1234; pu=&u; /* pernyataan ini salah karena tipe pu dan u berbeda */ nu = *pu; printf("Nilai u = %d", u); printf(\nNilai nu = %f", nu); }


Contoh program di bawah ini memberikan gambaran tentang pengubahan isi suatu variabel secara tak langsung.

main() { float d, *pd; clrscr(); d=54.5; printf("Isi d semula = %g", d); pd=&d; *pd = *pd + 10; /* identik dengan d = d + 10 */ printf("\nIsi d kini = %g", d); }

Hasil : Isi d semula = 54.5 Isi d kini = 64.5

9.1. POINTER DAN ARRAY

Hubungan antara pointer dan array pada C sangatlah erat, sebab sesunguhnya array secara internal akan diterjemahkan dalam bentuk pointer. Contoh :

main() { static int tgl_lahir[]={24, 12, 1970}; int i, *ptgl; clrscr(); ptgl = tgl_lahir; /* ptgl berisi alamat array */ for (i=0; i<3; i++) printf("Alamat ke-%d adalah %d\n",i, *(ptgl+i)); }

Hasil :

Alamat ke-0 adalah 24 Alamat ke-1 adalah 12 Alamat ke-2 adalah 1970

9.2. POINTER DAN STRING

Contoh program di bawah ini menggambarkan pertukaran dua string yang dilakukan melalui pertukaran isi array melalui pointer. Perhatikan bahwa dengan pointer, penyalinan isi arrray tidak perlu dilakukan. Sebagai efeknya bisa menghemat waktu eksekusi.

char *nama1 = "CAT WOMAN"; char *nama2 = "BATMAN"; main() { char *namax; puts("Kata Semula :"); printf("Nama-1 : %s", nama1); printf("\nNama-2 : %s", nama2); namax=nama1; /* penukaran string dengan pointer */ nama1=nama2; nama2=namax; puts("\n\nKata Akhir :"); printf("Nama-1 : %s", nama1); printf("\nNama-2 : %s", nama2); }


9.3. POINTER DAN FUNGSI

Pointer dan kaitannya dengan fungsi yang akan dibahas berikut meliputi : Pointer sebagai parameter fungsi

Penerapan pointer sebagai parameter yaitu jika diinginkan agar nilai suatu variabel internal dapat diubah oleh fungsi yang dipanggil. Contoh :

void rubah(int *x, int *y); main() { int a=3; int b=7; printf("Nilai semula : a= %d dan b= %d", a,b); rubah(&a, &b); printf("\nNilai akhir : a= %d dan b= %d", a,b); } void rubah(int *x, int *y) { *x = *y + 2; *y = *y + 2; }

Hasil :

Nilai semula : a= 3 dan b= 7 Nilai akhir : a= 9 dan b= 9

Pointer sebagai keluaran fungsi Suatu fungsi dapat dibuat agar keluarannya berupa pointer. Misalnya suatu fungsi menghasilkan keluaran berupa pointer yang menunjuk ke string. Contoh :

char *nama_bulan(int n); main() { int bl; char lagi; do { clrscr(); printf("Bulan (1..12) : "); scanf("%d", &bl); printf("%s\n", nama_bulan(bl)); printf("Input lagi [y/t] : "); lagi=getch(); }while (lagi == 'y' || lagi == 'Y'); } char *nama_bulan(int n) { static char *bulan[] = { "Kode bulan salah", "Januari", "Februari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember" }; return ((n<1 || n>12) ? bulan[0] : bulan[n]); }

Hasil :

Bulan (1..12) : 4 April Input lagi [y/t] :


9.4. STRUKTUR

Struktur adalah koleksi dari variabel yang dinyatakan dengan sebuah nama dengan sifat setiap variabel dapat memiliki tipe yang berlainan. Struktur biasa dipakai untuk mengelompokkan beberapa informasi yang berkaitan menjadi sebuah kesatuan. Deklarasi struktur :

struct nama_tipe_struktur { tipe field-1; tipe field-2; tipe field-n; } variabel_struktur1, ..., variabel struktur-n;

Masing–masing tipe elemen struktur dapat berlainan. Adapun variabel struktur menyatakan bahwa variabel struktur yang dideklarasikan bisa lebih dari satu dan dipisahkan dengan tanda titik koma. Misalnya :

struct nama_tipe_struktur { tipe field-1; tipe field-2; tipe field-n; } variabel_struktur-1, ..., variabel_struktur-n

Dalam suatu struktur, elemen yang terkandung di dalamnya bisa juga berupa struktur, misalnya :

struct data_tanggal { int tanggal; int bulan; int tahun; }; struct data_rekan { char nama[25]; struct data_tanggal tgl_lahir; }info_rekan;

9.4.1. MENGAKSES ELEMEN STRUKTUR

Elemen struktur dapat diakses dengan menggunakan bentuk : variabel_struktur.nama_field (antara variabel struktur dan nama field dipisahkan dengan tanda titik) Misalnya :

info_rekan.tgl_lahir.tanggal = 30; tgl = info_rekan.tgl_lahir.tanggal; puts(info_rekan.nama);

Untuk menampilkan data :

puts(info_rekan.nama); Contoh :

#include <stdio.h> main() { int i,n; struct data_tanggal { int tanggal; int bulan; int tahun; };


struct data_rekan { char nama[30]; struct data_tanggal tgl_lahir; }; struct data_rekan info_rekan; clrscr(); printf("Nama Lengkap : "); gets(info_rekan.nama); printf("Tanggal Lahir : "); scanf("%d",&info_rekan.tgl_lahir.tanggal); printf("Bulan Lahir : "); scanf("%d",&info_rekan.tgl_lahir.bulan); printf("Tahun Lahir : "); scanf("%d",&info_rekan.tgl_lahir.tahun); printf("\n\nNama lengkap : %s", info_rekan.nama); printf("\nTanggal Lahir : %d-%d-%d", info_rekan.tgl_lahir.tanggal, info_rekan.tgl_lahir.bulan, info_rekan.tgl_lahir.tahun); getch(); }

Hasil :

Nama Lengkap : Aditya Fajar Ramadhan Tanggal Lahir : 11 Bulan Lahir : 11 Tahun Lahir : 1978 Nama lengkap : Aditya Fajar Ramadhan Tanggal Lahir : 11-11-1978

9.4.2. ARRAY DENGAN STRUKTUR

Penggunaan struktur sering dikaitkan dengan array. Array struktur adalah array yang dipakai untuk menyimpan data. Contoh :

#include <stdio.h> #include <string.h> #include <ctype.h> #include <conio.h> #define maks 20 main() { struct data_tanggal { int tanggal; int bulan; int tahun; }; struct data_rekan { char nama[21]; struct data_tanggal tgl_lahir; };


struct data_rekan info[maks]; char tombol; int i, jumlah = 0; puts("DATA REKAN-REKAN : \n"); clrscr(); do { printf("Nama : "); gets(info[jumlah].nama); printf("Tanggal Lahir (mm-dd-yyyy) : "); scanf("%d-%d-%d", &info[jumlah].tgl_lahir.tanggal, &info[jumlah].tgl_lahir.bulan, &info[jumlah].tgl_lahir.tahun); fflush(stdin); // hapus sisa data dalam penampung keyboard jumlah ++; printf("\nMau memasukkan data lagi [y/t] ? "); tombol = toupper(getch()); while ( !(tombol == 'T' || tombol == 'Y')) tombol = toupper(getch()); printf("%c\n\n", tombol); } while (tombol== 'Y'); puts("\nData Rekan : NAMA - TANGGAL LAHIR"); for(i=0; i<jumlah; i++) printf("\n%-21s %d-%d-%d", info[i].nama, info[i].tgl_lahir.tanggal, info[i].tgl_lahir.bulan, info[i].tgl_lahir.tahun); getch(); }

Hasil : Nama : Ajeng Regita Tanggal Lahir (mm-dd-yyyy) : 13-03-1980 Mau memasukkan data lagi [y/t] ? Y Nama : Aditya Fajar Tanggal Lahir (mm-dd-yyyy) : 11-11-1981 Mau memasukkan data lagi [y/t] ? T Data Rekan : NAMA - TANGGAL LAHIR Ajeng Regita 13-3-1980 Aditya Fajar 11-11-1981


9.4.3. STRUKTUR DAN FUNGSI

Contoh: Program menentukan bulan dengan menggunakan struktur dan fungsi

void cetak_tanggal(int tg, int bl, int th); main() { struct data_tanggal { int tanggal; int bulan; int tahun; }; struct data_tanggal proses = {12, 3, 1985}; cetak_tanggal(proses.tanggal, proses.bulan, proses.tahun); } void cetak_tanggal(int tg, int bl, int th) { static char *nama_bulan[]= { "Kode bulan salah...!", "Januari", "Feburari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember" }; clrscr(); printf("%d %s %d", tg, nama_bulan[bl], th); }

Pemrograman C | Manipulasi File 44

1100 .. MMAANNIIPPUULLAASSII FFIILLEE File merupakan salah satu jenis penyimpanan yang bersifat non-volatile atau permanen, dengan demikian data-data dalam file dapat ditulis atau dibaca. Dalam pemrograman bahasa C file dikenal sebagai stream, stream merupakan kumpulan karakter yang disusun dalam baris-baris yang berpindah dari media yang satu ke yang lain dalam suatu sistem komputer. Manipulasi file dapat dilakukan dengan menggunakan stdio.h atau fstream.h

10.1. MANIPULASI FILE MENGGUNAKAN STDIO.H

Dalam menggunakan file header stdio.h setiap file memerlukan pendeklarasian sebuah variabel bertipe pointer untuk menandai file yang digunakan dalam operasi I/O. Berikut pendeklarasian pointer file:

FILE *fp, *fp2;

Untuk membuka suatu file dapat digunakan fungsi fopen. Fungsi tersebut mengembalikan nilai pointer file yang digunakan atau jika terjadi eror maka nilai NULL akan dikembalikan. Contoh di bawah ini akan membuka file bernama prog.c dengan mode “r” untuk di baca dan di asossiasikan dengan pointer file fp.

fp = fopen( “prog.c”, “r”) ;

Terdapat beberapa jenis mode pembacaan file yang digunakan yaitu: • r - open for reading • w - open for writing (file need not exist) • a - open for appending (file need not exist) • r+ - open for reading and writing, start at beginning • w+ - open for reading and writing (overwrite file) • a+ - open for reading and writing (append if file exists)

Berikut ini merupakan beberapa fungsi yang ada dalam Library Standard I/O dan dapat digunakan untuk melakukan operasi I/O pada file.

• Untuk menulis ke file dalam format tertentu: int fprintf(fp, "Testing...\n");

jika berhasil akan dikembalikan jumlah byte yang dituliskan sedangkan jika gagal dikembalikan EOF(konstanta yang menandakan akhir dari file)

• Untuk membaca dari file dalam format field tertentu:

int fscanf(fp, "Testing...\n");

jika berhasil akan dikembalikan jumlah field yang dibaca sedangkan jika gagal dikembalikan EOF

• Untuk menulis karakter ke file teks: int fputc( int c, FILE *fp );

jika berhasil akan dikembalikan karakter c sedangkan jika gagal dikembalikan EOF

• Untuk membaca file teks perkarakter: int fgetc (FILE *fp);

jika berhasil akan dikembalikan karakter c sedangkan jika gagal dikembalikan EOF


• Untuk meletakkan nilai integer ke file: int putw(int w, FILE *fp);

jika berhasil akan dikembalikan integer w sedangkan jika gagal dikembalikan EOF

• Untuk membaca nilai integer: int getw(FILE *fp);

jika berhasil akan dikembalikan integer w sedangkan jika gagal dikembalikan EOF

• Untuk menulis string ke file tanpa ada karakter NULL dan newline: int fputs(const char *s,FILE *fp);

jika berhasil akan dikembalikan string s sedangkan jika gagal dikembalikan EOF

• Untuk membaca string dari file sebanyak n karakter atau bertemu karakter ‘\n’: char *fgets(const char *s,int n,FILE *fp);

jika berhasil akan dikembalikan string s sedangkan jika gagal dikembalikan EOF

• Untuk mengetahui akhir sebuah file stream: int feof(FILE *fp);

jika berhasil akan dikembalikan nilai integer selain 0. Untuk menutup file yang digunakan pada program maka dapat digunakan fungsi fclose untuk memberikan nilai kembalian status program.

fclose ( fp ); //menutup file yang diasosiasikan dengan pointer fp

Contoh :

#include <stdio.h> void main() { FILE *fp; int c ; fp = fopen( "tes.txt", "r" ); //membuka file tes.txt c = fgetc( fp ); while ( c != EOF ) // perulangan terjadi hingga mencapai EOF { putchar( c ); //menampilkan karakter dalam file c = fgetc ( fp ); //membaca karakter dalam file } fclose( fp ); // menutup file }

Program ini akan membaca isi dari file tes.txt . Agar program ini dapat berjalan maka file tes.txt harus ada pada direktori letak program di atas berada.


Contoh: Program Untuk Menulis Nilai Integer Sebanyak Inputan User ke Dalam File

#include <stdio.h> #include <stdlib.h> void main() { int n; printf("Masukkan bilangan: "); scanf("%d",&n); FILE *fp; if((fp=fopen("coba.txt","w"))==NULL) // cek keberadaan file { printf("File error"); exit(1); } for(int bil=0;bil<n;bil++) fprintf(fp, " %i\n", bil); fclose(fp); }

10.2. MANIPULASI FILE MENGGUNAKAN FSTREAM.H

A. Output Stream • Dalam file library fstream.h digunakan fungsi ofstream untuk memberikan output data berupa

stream dari suatu file.

• Membuka file dapat menggunakan fungsi dengan syntax di bawah ini: ofstream NamaVariabel; NamaVariabel.open(“NamaFile”);

Atau dapat juga di tuliskan ofstream NamaVariabel(“NamaFile”);

• Menulis file dapat menggunakan tanda “<<” dengan syntax di bawah ini: NamaVariabel << “ Test… ”<<endl; NamaVariabel << “ Output Stream… ”<<endl;

• Menutup File dapat menggunakan fungsi close dengan syntax di bawah ini: NamaVariabel.close()

Contoh: #include <iostream.h> #include <fstream.h> void main() { ofstream file; file.open(“coba.txt”); cout <<”Mulai Menulis File…”<<endl; file <<”Sedang iseng…”<<endl; file <<”Iseng-iseng dapet gaji…”<<endl; cout <<”Menulis File Selesai…”<<endl; file.close(); }


B. Input Stream

• Dalam library fstream digunakan fungsi ifstream untuk membaca data dalam suatu file. • Membuka file dapat menggunakan fungsi dengan syntax di bawah ini:

ifstream NamaVariabel; NamaVariabel.open(“NamaFile”);

Atau dapat juga di tuliskan ifstream NamaVariabel(“NamaFile”);

• Contoh Membaca data dalam suatu file

#include <iostream.h> #include <fstream.h> void main(){ ifstream file("coba.txt"); const int MAKS = 80; char buff[MAKS+1]; while(f) { file.getline(buf,MAKS; cout<<buff<<endl } f.close(); }

• Pendeteksian akhir pada pembacaan inputstream dilakukan dengan cara: while(NamaVariabel) { ... }

Atau sebagai berikut:

while(!NamaVariabel.eof()) { ... }

• Penambahan Data pada File dapat menggunakan fungsi :

ofstream NamaVariabel (“NamaFile.txt”,ios::app);

Sehingga data dapat ditambahkan pada baris bawah dari akhir file. Contoh: #include <iostream.h> #include <fstream.h> void main() {

ofstream f; f.open("coba.txt",ios::app); cout<<"Penulisan dimulai..."<<endl; f<<"hallo lagi"<<endl; f<<"iseng lagi"<<endl; cout<<"Penulisan selesai…"<<endl; f.close();

}

Pemrograman C

Documents

Transcript of Pemrograman C