MODUL 1

POINTER
A. TUJUAN
1. Menjelaskan tentang konsep dari variabel pointer 2. Menjelaskan tentang pointer array 3. Menjelaskan tentang pointer string B. DASAR TEORI Konsep Dasar Pointer Variabel pointer sering dikatakan sebagai variabel yang menunjuk ke obyek lain. Pada kenyataan yang sebenarnya, variabel pointer berisi alamat dari suatu obyek lain (yaitu obyek yang dikatakan ditunjuk oleh pointer). Sebagai contoh, px adalah variabel pointer dan x adalah variabel yang ditunjuk oleh px. Kalau x berada pada alamat memori (alamat awal) 1000, maka px akan berisi 1000. Sebagaimana diilustrasikan pada gambar 1.1 di bawah ini.

Gambar 1.1 Variabel pointer px menunjuk ke variabel x Mendeklarasikan Variabel Pointer Suatu variabel pointer dideklarasikan dengan bentuk sebagai berikut :
tipe *nama_variabel

dengan tipe dapat berupa sembarang tipe yang sudah dibahas pada bab-bab sebelumnya, maupun bab-bab berikutnya. Adapun nama_variabel adalah nama dari variabel pointer. Sebagai contoh : int px; / *contoh 1 */ char *pch1, *pch2; / *contoh 2 */ Contoh pertama menyatakan bahwa px adalah variabel pointer yang menunjuk ke suatu data bertipe int, sedangkan contoh kedua masing pch1 dan pch2 adalah variabel pointer yang menunjuk ke data bertipe char.

Gambar 1.2 Ilustrasi pendeklarasian variabel pointer Mengatur Pointer agar Menunjuk ke Variabel Lain Agar suatu pointer menunjuk ke variabel lain, mula-mula pointer harus diisi dengan alamat dari variabel yang akan ditunjuk. Untuk menyatakan alamat dari suatu variabel, operator & (operator alamat, bersifat unary) bisa dipergunakan, dengan menempatkannya di depan nama variabel. Sebagai contoh, bila x dideklarasikan sebagai variabel bertipe int, maka &x berarti alamat dari variabel x. Adapun contoh pemberian alamat x ke suatu variabel pointer px (yang dideklarasikan sebagai pointer yang menunjuk ke data bertipe int) yaitu : px = &x; Pernyataan di atas berarti bahwa px diberi nilai berupa alamat dari variabel x. Setelah pernyataan tersebut dieksekusi barulah dapat dikatakan bahwa px menunjuk ke variabel x. Mengakses Isi Suatu Variabel Melalui Pointer Jika suatu variabel sudah ditunjuk oleh pointer, variabel yang ditunjuk oleh pointer tersebut dapat diakses melalui variabel itu sendiri (pengaksesan langsung) ataupun melalui pointer (pengaksesan tak langsung). Pengaksesan tak langsung dilakukan dengan menggunakan operator indirection (tak langsung) berupa simbol * (bersifat unary). Contoh penerapan operator * yaitu : *px yang menyatakan isi atau nilai variabel/data yang ditunjuk oleh pointer px . Sebagai contoh jika y bertipe int, maka sesudah dua pernyataan berikut px = &x; y = *px; y akan berisi nilai yang sama dengan nilai x. Mengakses dan Mengubah isi Suatu Variabel Pointer Contoh berikut memberikan gambaran tentang pengubahan isi suatu variabel secara tak langsung (yaitu melalui pointer). Mula-mula pd dideklarasikan sebagai pointer yang menunjuk ke suatu data bertipe float dan d sebagai variabel bertipe float. Selanjutnya

d = 54.5; digunakan untuk mengisikan nilai 54,5 secara langsung ke variabel d. Adapun pd = &d; digunakan untuk memberikan alamat dari d ke pd. Dengan demikian pd menunjuk ke variabel d. Sedangkan pernyataan berikutnya *pd = *pd + 10; (atau: *pd += 10; ) merupakan instruksi untuk mengubah nilai variabel d secara tak langsung. Perintah di atas berarti jumlahkan yang ditunjuk pd dengan 10 kemudian berikan ke yang ditunjuk oleh pd, atau identik dengan pernyataan d = d + 10; Akan tetapi, seandainya tidak ada instruksi pd = &d; px = &x; y = *px; maka pernyataan *pd = *pd + 10; tidaklah sama dengan d = d + 10; Pointer dan Array Hubungan antara pointer dan array pada C sangatlah erat. Sebab sesungguhnya array secara internal akan diterjemahkan dalam bentuk pointer. Pembahasan berikut akan memberikan gambaran hubungan antara pointer dan array. Misalnya dideklarasikan di dalam suatu fungsi int tgl_lahir[3] = { 01, 09, 64 }; dan int *ptgl; Kemudian diberikan instruksi ptgl = &tgl_lahir[0]; maka ptgl akan berisi alamat dari elemen array tgl_lahir yang berindeks nol. Instruksi di atas bisa juga ditulis menjadi ptgl = tgl_lahir; sebab nama array tanpa tanda kurung menyatakan alamat awal dari array. Sesudah penugasan seperti di atas, *ptgl dengan sendirinya menyatakan elemen pertama (berindeks sama dengan nol) dari array tgl_lahir. Kesimpulan

 Tipe variabel pointer adalah tipe variabel yang berisi alamat dari variabel yang sebenarnya. Tipe variabel pointer harus sama dengan tipe variabel yang ditunjuk. Hubungan antara pointer dan array pada C sangatlah erat, sebab sesungguhnya array secara internal akan diterjemahkan dalam bentuk pointer Variabel pointer bisa berupa string, array atau tipe variabel yang lainnya. C. TUGAS PENDAHULUAN 1. Buat program untuk menampilkan sebaris string seperti contoh berikut ; Selamat Pagi menggunakan variable pointer (pointer to string). 2. Buat potongan program untuk mencetak huruf ketiga ( L ) dari kata : P O L I T E K N I K dengan menggunakan variabel pointer D. PERCOBAAN Untuk setiap program di bawah ini, - gambarkan ilustrasi alokasi memori dari setiap baris pernyataan yang diproses - perkirakan hasil eksekusinya 1. #include <stdio.h> main() { int x = 3, y = 4; int *ip; ip = &x; y = *ip; x = 10; *ip = 3; printf(x = %d, y = %d, x, y); } 2. #include <stdio.h> main() { int count = 16, sum = 17, *x, *y; x = &sum; *x = 27; y = x; x = &count; *x = count; sum = *x / 2 * 3; printf("count = %d, sum = %d, *x = %d, *y = %d\n", count,sum,*x,*y); } 3. #include <stdio.h> int r, q = 8; int go_crazy(int *, int *); main() { int *ptr1 = &q; int *ptr2 = &q; r = go_crazy(ptr2, ptr1); printf("q = %d, r = %d, *ptr1 = %d, *ptr2 = %d\n", q, r,*ptr1,*ptr2); ptr1 = &r;

go_crazy(ptr1, ptr2); printf("q = %d, r = %d, *ptr1 = %d, *ptr2 = %d\n", q, r,*ptr1,*ptr2); } int go_crazy(int *p1, int *p2) { int x = 5; r = 12; *p2 = *p1 * 2; p1 = &x; return *p1 * 3; } 4. #include <stdio.h> main() { int var_x = 273; int *ptr1; int **ptr2; ptr1 = &var_x; ptr2 = &ptr1; printf("Nilai var_x = *ptr1 = %d\n", *ptr1); printf("Nilai var_x = **ptr2 = %d\n\n", **ptr2); printf("ptr1 = &var_x = %p\n", ptr1); printf("ptr2 = &ptr1 = %p\n", ptr2); printf(" &ptr2 = %p\n", &ptr2); } 5. int array1[10], array2[10]; int *ip1, *ip2 = array2; int *akhir = &array1[10]; for(ip1 = &array1[0]; ip1 < akhir; ip1++) *ip2++ = *ip1;

E. LAPORAN RESMI
1. Kumpulkan listing program, ilustrasi alokasi memorinya beserta hasil eksekusinya

MODUL 2

POINTER lanjutan
A. TUJUAN

1. Menjelaskan tentang Array of Pointer 2. Menjelaskan tentang Pointer to Pointer 3. Menjelaskan tentang Pointer dalam Fungsi 4. Menjelaskan tentang Pointer sebagai Parameter Fungsi 5. Menjelaskan tentang Pointer sebagai Keluaran Fungsi

B. Dasar Teori Array dari Pointer (Array of Pointer) Suatu array bisa digunakan untuk menyimpan sejumlah pointer. Sebagai contoh: char *namahari[10]; merupakan pernyataan untuk mendeklarasikan array pointer. Array namahari terdiri dari 10 elemen berupa pointer yang menunjuk ke data bertipe char.

Gambar 2.1 Array pointer

Array pointer bisa diinisialisasi sewaktu pendeklarasian. Sebagai contoh: static char *namahari[] = {Senin, Selasa, Rabu, Kamis, Jumat, Sabtu, Minggu}; Pada contoh ini, namahari[0] berisi alamat yang menunjuk ke string Senin. namahari[1] berisi alamat yang menunjuk ke string Selasa. namahari[2] berisi alamat yang menunjuk ke string Rabu. dan sebagainya.

Pointer menunjuk Pointer (Pointer to Pointer) Suatu pointer bisa saja menunjuk ke pointer lain. Gambar berikut memberikan contoh mengenai pointer menunjuk pointer.

Gambar 2.2 Pointer yang menunjuk pointer

Untuk membentuk rantai pointer seperti pada gambar di atas, pendeklarasian yang diperlukan berupa int var_x; int *ptr1; int **ptr2; Perhatikan pada deklarasi di depan: var_x adalah variabel bertipe int. ptr1 adalah variabel pointer yang menunjuk ke data bertipe int. ptr2 adalah variabel pointer yang menunjuk ke pointer int. (itulah sebabnya deklarasinya berupa int **ptr2; ) Agar ptr1 menunjuk ke variabel var_x, perintah yang diperlukan berupa ptr1 = &var_x; Sedangkan supaya ptr2 menunjuk ke ptr1, instruksi yang diperlukan adalah ptr2 = &ptr1; Pointer dalam Fungsi Pointer dan kaitannya dengan fungsi yang akan dibahas berikut meliputi : Pointer sebagai parameter fungsi Pointer sebagai keluaran fungsi Pointer Sebagai Parameter Fungsi Penerapan pointer sebagai parameter yaitu jika diinginkan agar nilai suatu variabel internal dapat diubah oleh fungsi yang dipanggil. Sebagai contoh dapat dilihat pada fungsi berikut. void naikkan_nilai (int *x, int *y) { *x = *x + 2; *y = *y + 2; } Fungsi di atas dimaksudkan agar kalau dipanggil, variabel yang berkenaan dengan parameter aktual dapat diubah nilainya, masing-masing dinaikkan sebesar 2. Contoh pemanggilan : naikkan_nilai(&a, &b); Perhatikan, dalam hal ini variabel a dan b harus ditulis diawali operator alamat (&) yang berarti menyatakan alamat variabel, sebab parameter fungsi dalam pendefinisian berupa pointer. Pointer Sebagai Keluaran Fungsi (return value) Suatu fungsi dapat dibuat agar keluarannya berupa pointer. Misalnya, suatu fungsi menghasilkan keluaran berupa pointer yang menunjuk ke string nama_bulan, seperti pada contoh berikut:

char *nama_bulan(int n) { static char *bulan[]= {Kode bulan salah, Januari, Februari, Maret, April, Mei, Juni, Juli, "Agustus, September, Oktober, Nopember,Desember }; return ( (n<1 | | n>12) ? bulan[0] : bulan[n] ); } Pada definisi fungsi di atas, char *nama_bulan() menyatakan bahwa keluaran fungsi nama_bulan() berupa pointer yang menunjuk ke obyek char (atau string). Dalam fungsi nama_bulan(), mula-mula array bernama bulan dideklarasikan dan sekaligus diinisialisasi agar menunjuk sejumlah string yang menyatakan nama bulan. Di bagian akhir fungsi, pernyataan return ( (n<1 || n>12) ? bulan[0] : bulan[n] ); menyatakan bahwa hasil fungsi berupa pointer yang menunjuk ke string Kode bulan salah (bulan[0]) jika masukan fungsi n<1 atau n>12 bulan[n] untuk n yang terletak antara 1 sampai dengan 12. C. TUGAS PENDAHULUAN 1. Buatlah program untuk menghitung banyaknya karakter yang dimasukkan dengan menggunakan pointer! Hasil: Ketik sebuah string: andri Jumlah karakternya adalah 5 D. PERCOBAAN 1. Untuk potongan program di bawah ini, gambarkan ilustrasi alokasi memori dari setiap baris pernyataan yang diproses int *i; int j=10, k, m[]={2, 5}; int **l; i = m; i++; *i = j; j = *i; i = &j; k = *(&j); l = &i; 2. Tentukan setiap statemen di bawah ini benar atau salah. Jika salah sertakan alasannya. Deklarasi : int a[5] = {2,4,8,1,23}; int c = 5; int *ptr1 = &c; int *ptr2 = a;

Statement Benar (beri tanda X) Salah (beri tanda X)

a = c; *c = 6; a[2] = c; *ptr2 = c; &ptr1 = c; *(ptr2 + 1) = *(a + 3); c = *(ptr2 + 1); c = &ptr1; c = a[3] + 2; *(ptr2 + 2) = *ptr1;

3. Berikan ilustrasi dan jelaskan apa yang dilakukan oleh program di bawah ini dan tampilkan hasil eksekusinya. #include <stdio.h> char strA[80] = "A string to be used for demonstration"; char strB[80]; main() { char *pA, *pB; puts(strA); pA = strA; puts(pA); pB = strB; putchar('\n'); while(*pA != '\0') { *pB++ = *pA++; } *pB = '\0'; puts(strB); } Proses apakah yang sebenarnya dilakukan pada program tersebut ? 4. Berikan ilustrasi dan jelaskan apa yang dilakukan oleh program di bawah ini #include <stdio.h> char *my_strcpy(char *, char *); main() { char strA[80]="A string to be used for demonstration"; char strB[80]; my_strcpy(strB, strA); puts(strB); } char *my_strcpy(char *destination, char *source) { char *p = destination; while (*source != '\0') { *p++ = *source++; } *p = '\0'; return destination;

} 5. Bandingkan fungsi my_strcpy di atas dengan fungsi my_strcpy di bawah ini. Berikan penjelasan terhadap perbedaan proses dari kedua fungsi tersebut char *my_strcpy(char dest[], char source[]) { int i = 0; while (source[i] != '\0') { dest[i] = source[i]; i++; } dest[i] = '\0'; return dest; }

E. LAPORAN RESMI
1. Kumpulkan listing program, ilustrasi alokasi memorinya beserta hasil eksekusinya

MODUL 3

Object dan Class

A. TUJUAN
1. Mampu memahami syntax penulisan class 2. Mampu membedakan tiga macam proteksi member 3. Mampu memindahkan letak definisi fungsi yang semula di dalam class menjadi diluar class atau sebaliknya. 4. Mampu membuat class sederhana.

B. DASAR TEORI Dalam C++ class merupakan organisasi data dan fungsi :

DATA CLASS

FUNGSI

Encapsulation : Data & Fungsi dalam organisasi yang sama, yakni class. Member class : data & fungsi. Syntaxnya sbb: class nama_class { permission_label_1: member1; permission_label_2: member2; ... } nama_object; Permission Label/Proteksi member : 1. Private bisa diakses oleh class sama, friend class, sifat information hiding, member (data/fungsi) tidak dapat diakses dari luar class) 2. Protected bisa diakses oleh class sama, friend class, class turunan 3. Public bisa diakses oleh siapa saja (class lain fungsi lain, fungsi main).

Contoh 2.1: // classes example #include <iostream.h> class CRectangle {

int x, y; public: void set_values (int,int); int area (void) {return (x*y);} }; void CRectangle::set_values (int a, int b) { x = a; y = b; } int main () { CRectangle rect; rect.set_values (3,4); cout << "Area: " << rect.area(); }

Keterangan : Ada 2 permission label dalam class CRectangle yakni 1. private membernya berupa data x dan y 2. public membernya adalah fungsi set_values() dan fungsi area() Fungsi set_value() didefinisikan diluar class sehingga harus menggunakan tanda scope :: Fungsi area() dedeklarasikan di dalam class.

Letak definisi fungsi

1. Didefinisikan secara lengkap dalam class. Akan dianggap satu kesatuan oleh compiler

2. Dideklarasikan prototype fungsinya saja. Fungsi lengkap didefinisikan diluar class. Menggunakan operator scope ::

Dari class CRectangle kita dapat membuat banyak objek.

Contoh 2.2 : // class example #include <iostream.h> class CRectangle { int x, y; public: void set_values (int,int); int area (void) {return (x*y);} }; void CRectangle::set_values (int a, int b) { x = a; y = b; } int main () { CRectangle rect, rectb; rect.set_values (3,4); rectb.set_values (5,6); cout << "Rect area: " << rect.area() << endl; cout << "Rectb area: " << rectb.area() << endl; } Langkah Kerja Praktikum : 1. Cobalah program contoh 2.1 dan 2.2 diatas. Pahami kembali masing-masing instruksi. 2. Untuk lebih memahami contoh 2.1 dan 2.2 cobalah contoh berikut: #include <iostream.h> #include <conio.h> class p_panjang { public:

int p,l; int luas() {return (p*l);} };

main() { p_panjang a; a.p=5; a.l=9; cout<<"Luas = "<<a.luas(); getch(); } 3. Agar anda dapat menginputkan p dan l dari keyboard ganti instruksi : a.p=5; a.l=9; dengan instruksi : cout<<"Panjang = ";cin>>a.p; cout<<"Luas = ";cin>>a.l; sehingga program menjadi : #include <iostream.h> #include <conio.h> class p_panjang { public: int p,l; int luas() {return (p*l);} };

main() { p_panjang a; cout<<"Panjang = ";cin>>a.p;

cout<<"Lebar = ";cin>>a.l; cout<<"Luas = "<<a.luas(); getch(); } Jalankan program dan amati hasilnya. 4. Ganti permission label dari public menjadi private sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { private: int p,l; int luas() {return (p*l);} };

main() { p_panjang a; cout<<"Panjang = ";cin>>a.p; cout<<"Luas = ";cin>>a.l; cout<<"Luas = "<<a.luas(); getch(); } Jalankan program amati pesan kesalahan yang muncul. Mengapa kesalahan tersebut muncul? Note: Member private tidak boleh diakses dari luar class 5. Ganti permission label untuk fungsi luas() dari public menjadi private sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { private: int p,l; public:

int luas() {return (p*l);} };

main() { p_panjang a; cout<<"Panjang = ";cin>>a.p; cout<<"Luas = ";cin>>a.l; cout<<"Luas = "<<a.luas(); getch(); } Jalankan program amati pesan kesalahan yang muncul. Note: Pesan kesalahan muncul karena masih terdapat pengaksesan member private diluar class.

6. Tambahkan fungsi beri_nilai (int, int) pada public member dan ubah instruksi pada fungsi main () untuk input data sehingga program menjadi : #include <iostream.h> #include <conio.h> class p_panjang { private: int p,l; public: int luas() {return (p*l);} void beri_nilai (int p1, int l1) {p=p1; l=l1;} };

main() { p_panjang a,b; int x,y;

cout<<"Panjang = ";cin>>x; cout<<"Luas = ";cin>>y; a.beri_nilai(x,y); b.beri_nilai(10,15); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); getch(); } Jalankan program dan amati outputnya. Note: Penambahan fungsi beri_nilai(int,int) bertujuan agar member p dan l tetap bersifat private, tetapi nilainya bisa didapatkan dari luar class.

7. Tambahkan fungsi beri_nilai () (tanpa parameter) dan ubah instruksi pada fungsi main () sehingga program menjadi : #include <iostream.h> #include <conio.h> class p_panjang { private: int p,l; public: int luas() {return (p*l);} void beri_nilai (int p1, int l1) {p=p1; l=l1;} void beri_nilai() {p=7; l=10;} };

main() { p_panjang a,b,c; int x,y; cout<<"Panjang = ";cin>>x;

cout<<"Luas = ";cin>>y; a.beri_nilai(x,y); b.beri_nilai(10,15); c.beri_nilai(); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); cout<<"\nLuas c = "<<c.luas(); getch(); } Jalankan program amati perubahan outputnya. Note : Dalam satu class boleh ada fungsi yang namanya sama, tetapi parameternya harus berbeda.

8. Hapus permission label private sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { int p,l; public: int luas() {return (p*l);} void beri_nilai (int p1, int l1) {p=p1; l=l1;} void beri_nilai() {p=7; l=10;} };

main() { p_panjang a,b,c; int x,y; cout<<"Panjang = ";cin>>x; cout<<"Luas = ";cin>>y;

a.beri_nilai(x,y); b.beri_nilai(10,15); c.beri_nilai(); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); cout<<"\nLuas c = "<<c.luas(); getch(); } Jalankan program. Note: Permission label private boleh tidak ditulis jika dituliskan diawal class.

9. Ubah susunan penulisan class, member public dituliskan lebih dulu, baru kemudian private, sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { public: int luas() {return (p*l);} void beri_nilai (int p1, int l1) {p=p1; l=l1;} void beri_nilai() {p=7; l=10;} private: int p,l; };

main() { p_panjang a,b,c; int x,y; cout<<"Panjang = ";cin>>x; cout<<"Luas = ";cin>>y;

a.beri_nilai(x,y); b.beri_nilai(10,15); c.beri_nilai(); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); cout<<"\nLuas c = "<<c.luas(); getch(); }

Jalankan program.

Note :Susunan penulisan member class dapat dibolak-balik sesuai dengan kelompok permission labelnya.

10. Ubah definisi fungsi agar menjadi diluar class sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { public: int luas(); void beri_nilai (int, int); void beri_nilai(); private: int p,l; };

int p_panjang::luas() {return (p*l);} void p_panjang::beri_nilai (int p1, int l1) {p=p1; l=l1;} void p_panjang::beri_nilai() {p=7; l=10;}

main() { p_panjang a,b,c; int x,y; cout<<"Panjang = ";cin>>x; cout<<"Luas = ";cin>>y; a.beri_nilai(x,y); b.beri_nilai(10,15); c.beri_nilai(); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); cout<<"\nLuas c = "<<c.luas(); getch(); } Jalankan program. Note : Definisi fungsi dapat diletakkan didalam class (no. 9) dapat pula diletakkan diluar class. Perhatikan penulisannya jika diletakkan di luar class (menggunakan operator :: )

11. Pindahkan definisi fungsi setelah fungsi main() sehingga program menjadi: #include <iostream.h> #include <conio.h> class p_panjang { public: int luas(); void beri_nilai (int, int); void beri_nilai(); private: int p,l; };

main() {

p_panjang a,b,c; int x,y; cout<<"Panjang = ";cin>>x; cout<<"Luas = ";cin>>y; a.beri_nilai(x,y); b.beri_nilai(10,15); c.beri_nilai(); cout<<"\nLuas a = "<<a.luas(); cout<<"\nLuas b = "<<b.luas(); cout<<"\nLuas c = "<<c.luas(); getch(); }

int p_panjang::luas() {return (p*l);} void p_panjang::beri_nilai (int p1, int l1) {p=p1; l=l1;} void p_panjang::beri_nilai() {p=7; l=10;}

Jalankan program. Note : Definisi fungsi dapat diletakkan sebelum main() maupun setelan main()

12. Class kalkulator berikut mempunyai 4 fungsi yang bertipe void. #include <iostream.h> #include <conio.h> float z; class kalkulator { int x, y; public : void jml(int x, int y)

{ z=x+y; cout<<"\nPenjumlahan = "<<z;}; void kurang(int x, int y) { z=x-y; cout<<"\nPengurangan = "<<z;}; void kali(int x, int y) { z=x*y; cout<<"\nPerkalian = "<<z;}; void bagi(int x, int y) { z=x/y; cout<<"\nPembagian = "<<z;}; }; main() { kalkulator a,b,c,d; a.jml(2,3); b.kurang(4,5); c.kali(2,10); d.bagi(9,5); getch(); } a. Pada contoh program diatas terdapat deklarasi ganda untuk x dan y. Pertama x, y sebagai member private dan yang kedua x dan y sebagai parameter di semua fungsi. 1. Coba anda hilangkan deklarasi x dan y sebagai member private. Apakah program tetap jalan? 2. Kembalikan deklarasi x dan y seperti semula (sebagai member private). Lakukan langkah berikut : a. Hilangkan deklarasi x dan y sebagai parameter di semua fungsi. b. Tambahkan fungsi beri_nilai(int, int), untuk memberi nilai x dan y pada class di dalam member yang sifatnya public. c. Tambahkan instruksi untuk memanggil fungsi beri_nilai(int, int) tersebut di dalam main sebelum memanggil fungsi jml(). d. Ubah instruksi untuk memanggil fungsi jml, kurang, kali dan bagi di dalam main menjadi tanpa parameter. Ingat: x dan y sebagai parameter fungsi sudah dihilangkan. b. Buat agar semua definisi fungsi terletak diluar class (didalam class hanya dideklarasikan prototypenya saja)

c.

Ubah keempat fungsi tersebut menjadi fungsi yang memiliki return value (missal bertipe: int/float).

d. Tuliskan hasil akhir program anda pada selembar kertas dan KUMPULKAN.

MODUL 4

Konstruktor dan Destruktor

A. TUJUAN
1. Mampu memahami syntax penulisan konstruktor dan destruktor. 2. Mampu memahami fungsi konstruktor dan destruktor. 3. Mampu melakukan pengalokasian dan pendealokasian memory secara dinamis.

B. DASAR TEORI
Konstruktor adalah fungsi khusus anggota kelas yang otomatis dijalankan pada saat penciptaan objek (mendeklarasikan instance). Konstruktor ditandai dengan namanya, yaitu sama dengan nama kelas. Konstruktor tidak mempunyai tipe hasil (return value). Biasanya konstruktor dipakai untuk inisialisasi anggota data dan melakukan operasi lain seperti membuka file dan melakukan alokasi memori secara dinamis. Meskipun konstruktor tidak harus ada dalam kelas, tetapi jika diperlukan konstruktor dapat lebih dari satu. Konstruktor adalah fungsi anggota yang mempunyai nama yang sama dengan nama kelas. Kegunaannya : Mengalokasikan ruang bagi sebuah objek Memberikan nilai awal terhadap anggota data suatu objek Membentuk tugas-tugas umum lainnya Sifat : otomatis dijalankan pada saat objek class diciptakan. tidak bertipe walaupun void sekalipun , dan tdk punya return value. nama constructor = nama class Overloading Konstruktor . Seperti telah dijelaskan di atas bahwa dalam satu kelas bisa terdapat lebih dari satu buah konstruktor, hal ini seringkali disebut dengan overloading konstruktor. Overloading terhadap konstruktor merupakan suatu mekanisme pembuatan konstruktor yang memiliki bentuk lebih dari satu. Dalam hal ini pembeda antar satu konstruktor dengan konstruktor yang lain berupa jumlah parameter atau tipe parameter. Destruktor adalah pasangan konstruktor. Pada saat program membuat objek maka secara otomatis kontruktor akan dijalankan, yang biasanya dimaksudkan untuk memberi nilai awal variable private. Sejalan dengan itu, C++ menyediakan fungsi destruktor (penghancur atau pelenyap) yang secara otomatis akan dijalankan pada saat berakhirnya objek. Setiap kelas mempunyai tepat satu destuktor. jika kita tidak mendeklarasikan sebuah destruktor dalam sebuah kelas, maka destruktor akan diciptakan sendiri oeh compiler C++. Fungsi destruktor itu sendiri adalah untuk mendealokasikan memori dinamis yang diciptakan konstruktor. Nama destruktor sama dengan nama kelas ditambah awalan karakter tilde (~). Walaupun compiler C++ akan secara otomatis mendeklarasikan sebuah destruktor, akan tetapi sangat disarankan untuk mendeklarasikan sendiri sebuah destruktor. Karena dengan mendeklarasikan sendiri destruktor maka kita mempunyai kontrol penuh terhadap apa yang dilakukan destruktor dari kelas yang kita buat. Destruktor adalah fungsi anggota yang mempunyai nama yang sama dengan nama kelas ditambah symbol tilde (~) didepannya.

C. LANGKAH PRAKTIKUM 1. Cobalah program dibawah ini: #include <iostream.h> //deklarasi kelas class counter { public: int angka; //data anggota counter(); //konstruktor void naik_satu(); void info();//fungsi anggota }; int main() { //konstruktor dipanggil counter a; cout<<"Nilai awal.."<<endl; a.info(); //konstruktor dipanggil cout<<"Nilai angka setelah dinaikkan satu.."<<endl; naik_satu(); info(); return 0; } //definisi konstruktor counter()::angka(4) { cout<<"Konstruktor diberi nilai 4..?"<<endl; } //definisi fungsi void counter:naik_satu() { angka ++; } void counter::info() { cout<<"Nilai angka= " <<angka<<endl; }

Coba amati hasil eksekusi program diatas, tuliskan urutan dijalankan nya setiap sintaks. Kemudian simpulkan kapan konstruktor dijalankan?

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

2. Untuk lebih memperdalam coba dan amati program dibawah ini:

#include<iostream.h> Class Tpersegi { int *lebar, *panjang; public: Tpersegi (int, int); ~Tpersegi(); int Luas() {return (*lebar * *panjang);} }; Tpersegi::Tpersegi(int a, int b) { lebar=new int; panjang=new int; *lebar = a; *panjang = b; } Tpersegi::~Tpersegi() { delete lebar; delete panjang; } int main() { Tpersegi pers(3,4), persg(5,6); cout<<Luas pers= <<pers.Luas()<<endl; cout<<Luas persg = <<persg.Luas()<<endl; return 0;

} Coba amati hasil eksekusi program diatas, tuliskan urutan dijalankan nya setiap sintaks. Kemudian simpulkan kapan konstruktor, destruktor dan fungsi main dijalankan?

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

3. Overloding konstruktor. Pada program dibawah ini dideklarasikan dua buah konstruktor dalam satu kelas. Perhatikan dan amati apa perbedaan dari kedua konstruktor yang di dideklarasikan tersebut.
#include <iostream.h> class CRectangle { int width, height; public: CRectangle (); CRectangle (int,int); int area (void) {return (width*height);} }; CRectangle::CRectangle () { width = 5; height = 5; } CRectangle::CRectangle (int a, int b) { width = a; height = b; } int main () { CRectangle rect (3,4); CRectangle rectb; cout << "rect area: " << rect.area() << endl; cout << "rectb area: " << rectb.area() << endl;

Perhatikan dan amati hasil eksekusi program diatas, kemudian tulis sebuah kesimpulan tentang overloading konstruktor!!!.

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------4. Setelah anda pahami konstruktor dan destruktor, sebagai latihan anda buat sebuah program menggunakan konstruktor dan destruktor untuk menginputkan dan menampilkan data buku!!!