Class constructor merupakan suatu fungsi yang memiliki kegunaan khusus di dalam suatu class yang akan dipanggil (eksekusi) ketika objek suatu class dideklarasikan. Fungsi tersebut akan memiliki nama sama dengan nama classnya, seperti CKotak(), yang merupakan constructor untuk class CKotak. Fungsi tersebut tidak memiliki nilai kembalian dan kegunaan utama dari class constructor adalah memberikan nilai awal (inisialisasi dengan suatu nilai) kepada data anggota class.
CONTOH SOURCE CODE PENGGUNAAN CONSTRUCTOR
#include "iosream.h"
class CKotak
{
public:
double m_panjang; /* panjang dari suatu kotak */
double m_lebar; /* lebar dari suatu kotak */
double m_tinggi; /* tinggi dari suatu kotak */
CKotak(double p, double l, double t) /* definisi constructor */
{
m_panjang = p; /* panjang dari suatu kotak */
m_lebar = l; /* lebar dari suatu kotak */
m_tinggi = t; /* tinggi dari suatu kotak */
cout << endl << "Constructor dipanggil";
}
/* fungsi untuk menghitung volume kotak */
double Volume()
{
return (m_panjang * m_lebar * m_tinggi);
}
/* fungsi untuk menghitung luas permukaan kotak */
double LuasKotak()
{
return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
}
};
void main()
{
CKotak kotak1(15.0, 12.0, 6.0); /* deklarasikan & inisialisasi kotak1 */
CKotak kotak2(20.0, 10.0, 5.0); /* deklarasikan & inisialisasi kotak2 */
/* simpan hasil perhitungan luasan permukaan kotak */
double Luas_Kotak = 0.0;
Luas_Kotak = kotak1.LuasKotak(); /* luas permukaan kotak1 */
cout << endl << endl << "Luas Permukaan kotak1 = " << Luas_Kotak;
cout << endl << "Volume kotak1 = " << kotak1.Volume();
cout << endl << endl << "Luas Permukaan kotak2 = " << kotak2.LuasKotak()
<< endl << "Volume kotak2 = " <<kotak2.Volume();
cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
<< sizeof kotak1 << " bytes" << endl << endl;
return;
}
OUTPUT PROGRAM
ANALISA PROGRAM
Dari contoh source code di atas dapat di analisa bahwa Constructor CKotak dibuat dengan memiliki tiga buah parameter yang masing-masing bertipe double, sesuai dengan banyaknya data anggota class. Masing-masing parameter akan digunakan untuk menginisialisasikan data anggota class untuk objek CKotak : m_panjang, m_lebar, dan m_tinggi. Pernyataan terakhir di dalam constructor tersebut merupakan stream cout yang digunakan untuk menunjukkan bahwa setiap kali objek CKotak dideklarasikan maka constructor dari class CKotak akan dipanggil.
Di dalam fungsi main() dideklarasikan dua buah objek CKotak yaitu kotak1 dan kotak2 dan diinisialisasikan langsung dengan nilai-nilai tertentu, dimana teknik penulisannya serupa dengan teknik penulisan fungsi pemanggil yang melewatkan suatu argumen tertentu. Ketiga nilai yang dilewatkan tersebut diinisialisasikan dengan ketiga data anggota class yang bersesuaian : m_panjang, m_lebar, dan m_tinggi. Nilai-nilai (argumen-argumen) yang diinisialisasikan diletakkan di dalam sepasang tanda kurung setelah penulisan nama objek dilakukan. Kemudian, dilakukan perhitungan LuasKotak dan Volume untuk masing-masing objek. Penulisan / penambahan constructor tidak akan menambah ukuran suatu objek.
Dua baris pertama dari output program merupakan hasil dari pemanggilan constructor CKotak yang terjadi pada saat dilakukannya deklarasi objek kotak1 dan kotak2. Constructor di dalam definisi class akan secara otomatis dipanggil ketika terdapat pendeklarasian objek CKotak sehingga jika terjadi proses inisialisasi di dalam pendeklarasian tersebut maka nilai argumen akan dilewatkan ke dalam constructor untuk diset dengan data anggota class dengan urutan yang bersesuaian.
DEFAULT CONSTRUCTOR
* Jika kita ingin mendeklarasikan suatu objek tanpa harus menginisialisasikannya, maka kita harus menggunakan Default Constructor.
Program di atas dapat dimodifikasi dengan menambahkan pernyataan :
CKotak kotak3;
di bawah pendeklarasian objek kotak2.
Disini kita mendeklarasikan suatu objek CKotak tanpa menginisialisasikannya dengan suatu nilai apapun. Jika program dikompilasi, maka kompiler akan menunjukkan pesan kesalahan seperti berikut :
Arti dari pesan kesalahan tersebut adalah kompiler akan mencari suatu default constructor yang dimiliki oleh objek kotak3, yaitu constructor yang tidak memiliki argumen apapun. Karena tidak menemukan constructor yang sesuai untuk kotak3 (default constructor), pesan kesalahan akan ditampilkan. Untuk menghindari hal itu, di dalam definisi class harus ditambahkan sebuah default constructor, yaitu :
//definisi default constructorCKotak()
{ }
Sekarang, jika program dikompilasi ulang tidak akan ada lagi pesan kesalahan yang muncul.
CONTOH SOURCE CODE yang telah ditambahkan DEFAULT CONSTRUCTOR :
#include "iostream.h"
class CKotak
{
public:
double m_panjang; /* panjang dari suatu kotak */
double m_lebar; /* lebar dari suatu kotak */
double m_tinggi; /* tinggi dari suatu kotak */
CKotak(double p, double l, double t) /* definisi constructor */
{
m_panjang = p; /* panjang dari suatu kotak */
m_lebar = l; /* lebar dari suatu kotak */
m_tinggi = t; /* tinggi dari suatu kotak */
cout << endl << "Constructor dipanggil";
}
/* definisi default constructor */
CKotak()
{
cout << endl << "Default Constructor dipanggil";
}
/* fungsi untuk menghitung volume kotak */
double Volume()
{
return (m_panjang * m_lebar * m_tinggi);
}
/* fungsi untuk menghitung luas permukaan kotak */
double LuasKotak()
{
return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
}
};
void main()
{
CKotak kotak1(15.0, 12.0, 6.0); /* deklarasikan & inisialisasi kotak1 */
CKotak kotak2(20.0, 10.0, 5.0); /* deklarasikan & inisialisasi kotak2 */
CKotak kotak3; /* deklarasikan kotak3 */
/* set data anggota objek kotak3 dengan nilai-nilai tertentu */
kotak3.m_panjang = kotak1.m_panjang - 7.0;
kotak3.m_lebar = kotak1.m_lebar / 3.0;
kotak3.m_tinggi = kotak2.m_panjang / 5;
/* simpan hasil perhitungan luasan permukaan kotak */
double Luas_Kotak = 0.0;
Luas_Kotak = kotak1.LuasKotak(); /* luas permukaan kotak1 */
cout << endl << endl << "Luas Permukaan kotak1 = " << Luas_Kotak;
cout << endl << "Volume kotak1 = " << kotak1.Volume();
cout << endl << endl << "Luas Permukaan kotak2 = " << kotak2.LuasKotak()
<< endl << "Volume kotak2 = " <<kotak2.Volume();
cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
<< endl << "Volume kotak3 = " << kotak3.Volume();
cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
<< sizeof kotak1 << " bytes" << endl << endl;
return;
}
OUTPUT PROGRAM
ANALISA PROGRAM
Dari contoh source code di atas dapat di analisa bahwa di dalam program tersebut telah memiliki sebuah default constructor di dalam definisi class CKotak dan tidak akan ada lagi pesan kompiler karena tidak ditemukannya default construtor seperti yang terlihat pada gambar di atas, di samping constructor, default constructor pun kini dipanggil dalam pendeklarasian objek kotak3. Ukuran objek masih tetap tidak berubah dengan penambahan default constructor. Satu aspek penting yang harus dicermati dalam contoh program kali ini bahwa constructor berlaku sebagai fungsi overloading. Kompiler akan secara otomatis memilih constructor yang sesuai dalam pendeklarasian objek.
MEMBERIKAN NILAI DEFAULT DI DALAM CONSTRUCTOR
Parameter suatu fungsi dapat memiliki nilai default yang didefinisikan di dalam prototipe fungsi. Fungsi-fungsi, anggota class, termasuk constructor pun, dapat memiliki parameter default di dalam suatu definisi class. Jika definisi fungsi terdapat di dalam definisi class, nilai-nilai default untuk paramete-parameter fungsi dapat diletakkan di dalam header suatu fungsi. Tetapi, jika di dalam definisi class hanya terdapat prototipe fungsi, nilai default parameter fungsi harus ditulis di dalam prototipe fungsi tersebut.
Jika kita menginginkan agar objek untuk class CKotak memiliki ukuran-ukuran minimum adalah 1, maka constructor class CKotak akan menjadi seperti :
Hal tersebut dapat terjadi disebabkan kompiler tidak dapat menentukan yang mana dari kedua constructor tersebut yang dipanggil- constructor yang memiliki nilai default untuk parameter-parameternya atau constructor tidak menerima parameter apapun (default constructor). Dengan kata lain, pendeklarasian kotak3 akan membutuhkan suatu constructor tanpa parameter ataukah constructor yang dapat dipanggil tanpa menggunakan inisialisasi parameter-parameternya (constructor yang memiliki nilai default). Solusi alternatif dari masalah itu adalah dengan menghapus default constructor. Dalam hal ini, memberikan nilai default untuk parameter-parameter suatu constructor akan menyebabkan objek yang dideklarasikan tanpa inisialisasi suatu nilai secara otomatis akan memiliki nilai default, yaitu dalam kasus ini, nilai data anggota class akan sama dengan 1. Setelah default constructor di dalam definisi class CKotak dihapus, maka program sudah dapat dijalankan.
CONTOH SOURCE CODE setelah ditambahkan NILAI DEFAULT untuk parameter CONSTRUCTOR pada Class CKotak :
#include "iostream.h"
class CKotak /* definisi class dengan jangkauan global */
{
public:
double m_panjang; /* panjang dari suatu kotak */
double m_lebar; /* lebar dari suatu kotak */
double m_tinggi; /* tinggi dari suatu kotak */
/* definisi constructor */
CKotak(double p = 1.0, double l = 1.0, double t = 1.0)
{
m_panjang = p; /* dapatkan */
m_lebar = l; /* nilai-nilai */
m_tinggi = t; /* data anggota class */
cout << endl << "Constructor dipanggil";
}
/* fungsi untuk menghitung volume kotak */
double Volume()
{
return (m_panjang * m_lebar * m_tinggi);
}
/* fungsi untuk menghitung luas permukaan kotak */
double LuasKotak()
{
return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
}
};
void main()
{
CKotak kotak3; /* deklarasikan kotak3 */
cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
<< endl << "Volume kotak3 = " << kotak3.Volume();
cout <<endl <<endl << "Suatu objek dari CKotak akan menempati memori sebesar : "
<< sizeof kotak3 << " bytes" << endl << endl;
return;
}
OUTPUT PROGRAM
ANALISA PROGRAM
Dari contoh source code di atas dapat di analisa bahwa di dalam program tersebut, hanya dideklarasikan variabel kotak3 tanpa diikuti dengan inisialisasi suatu nilai apapun. Pada output di atas, terlihat bahwa constructor yang memiliki parameter-parameter dengan nilai default dipanggil dan dapat melakukan tugasnya yaitu menginisialisasikan data anggota class dari objek kotak3 dengan nilai-nilai default, yaitu 1.
Penggunaan nilai default untuk parameter-parameter di dalam program tersebut hanyalah untuk ilustrasi. Di dalam kenyataan praktik pemrograman sehari-hari, akan sangat banyak alasan untuk tetap menggunakan suatu default constructor di dalam program, tetapi ada kalanya juga, kita tidak membutuhkan suatu default constructor sama sekali. Pemberian contoh ini hanya untuk menunjukkan kepada kita bahwa semua objek suatu class yang dideklarasikan pasti memiliki nilai inisialisasi.
MENGGUNAKAN DAFTAR INISIALISASI DI DALAM SUATU CONSTRUCTOR
Sejauh ini, proses inisialisasi anggota suatu objek dilaksanakan di dalam class constructor secara eksplisit dengan menggunakan operator penugasan. Ada cara lain yang disebut " Dafatar Inisialisasi ". Sebagai contoh, jika kita ingin mengubah constructor di dalam class CKotak agar sesuai dengan versi tersebut maka dapat ditulis :
/* Definisi constructor dengan memakai daftar inisialisasiCKotak(double p = 1.0, double l = 1.0, double t = 1.0) : m_panjang(p), m_lebar(l), m_tinggi(t)
{
cout << endl << "Constructor dipanggil";
}
Pada pernyataan-pernyataan di atas, nilai-nilai default tidak diset melalui pernyataan penugasan di dalam badan constructor, melainkan diset seperti halnya pelewatan suatu nilai sebagai argumen di dalam fungsi pemanggil. Setiap anggota dari daftar inisialisasi dipisahkan oleh tanda koma dan daftar inisialisasi tersebut berada di luar badan fungsi / constructor. Teknik inisialisasi seperti itu banyak dipraktikkan dalam pemrograman.
BENTUK " DEFAULT " COPY CONSTRUCTOR
CKotak kotak1(3.5, 4.0, 1.7);
Sekarang, kita buat lagi sebuah objek CKotak yang sama dengan objek sebelumnya dan kita inisialisasikan objek kotak ini dengan objek kotak1. Di dalam fungsi main() dilakukan duplikat informasi objek kotak3 dari objek kotak1 dengan menginisialisasikan objek kotak3 dengan objek kotak1.
CONTOH SOURCE CODE COPY CONSTRUCTOR
#include "iostream.h"
class CKotak /* definisi class dengan jangkauan global */
{
public:
/* definisi constructor dengan memakai daftar inisialisasi */
CKotak(double p = 1.0, double l = 1.0, double t = 1.0) : m_panjang(p), m_lebar(l), m_tinggi(t)
{
cout << endl << "Constructor dipanggil";
}
/* fungsi untuk menghitung volume kotak */
double Volume()
{
return (m_panjang * m_lebar * m_tinggi);
}
/* fungsi untuk menghitung luas permukaan kotak */
double LuasKotak()
{
return (2 * (m_panjang * m_lebar) + 2 * (m_panjang * m_tinggi) + 2 * (m_lebar * m_tinggi));
}
private:
double m_panjang; /* panjang dari suatu kotak */
double m_lebar; /* lebar dari suatu kotak */
double m_tinggi; /* tinggi dari suatu kotak */
};
int main(void)
{
CKotak kotak1(3.5, 4.0, 1.7);
/* deklarasikan & inisialisasikan kotak3 dengan kotak1 */
CKotak kotak3 = kotak1;
cout << endl << endl << "Luas Permukaan kotak3 = " << kotak3.LuasKotak()
<< endl << "Volume kotak3 = " << kotak3.Volume();
cout << endl << endl << "Luas Permukaan kotak1 = " << kotak1.LuasKotak()
<< endl << "Volume kotak1 = " << kotak1.Volume() << endl << endl;
return 0;
}
OUTPUT PROGRAM
ANALISA PROGRAM
Masing-masing kotak memiliki luas permukaan kotak dan volume yang sama. Tetapi jika diperhatikan, constructor hanya dipanggil sekali dalam penciptaan (pendeklarasian) objek kotak1. Bagaimana objek kotak3 dibuat ? Kasus itu serupa dengan pada saat kita membahas tidak adanya default constructor dalam pembuatan suatu objek. Pada kasus tersebut, kompiler memproduksi suatu versi default dari apa yang dikenal sebagai copy constructor. Objek kotak3 terbentuk karena adanya copy constructor. Dengan copy constructor, objek suatu class dapat dibentuk melalui proses inisialisasi dengan objek lain dari suatu class yang sama. Versi default copy constructor menciptakan suatu objek baru dengan mengopi dari objek yang sudah ada, anggota demi anggota.
Cara penduplikasian suatu objek dengan copy constructor cukup memadai untuk kasus CKotak yang sederhana itu. Untuk class-class yang lebih kompleks, dimana terdapat array atau pointer di dalamnya, mekanisme copy constructor secara default tidak akan berlaku. Kita harus membuat sendiri suatu copy constructor yang sesuai dengan kebutuhan.
***********************************************************************************
***********************************************************************************
OVERRIDING
* Istilah Overriding sangat erat kaitannya dengan konsep Inheritance dalam konsep pemrograman berorientasi objek / OOP.
* Overriding merupakan suatu keadaan dimana kelas anak dapat
mengubah atau memodifikasi atau memperluas data dan method, pada kelas induk. Overriding
merupakan redefinisi data dan method, maksudnya proses ini akan mengubah data
dan method dari keduanya, kelas induk dan kelas anaknya. Sebelum melakukan
overriding perlu diperhatikan bagaimana tingkat aksesibilitas data dan method
tersebut. Overriding menyatakan suatu keadaan dimana method pada subclass
menolak method pada parent classnya
* Peraturan pada Overriding :
Method yang terkena override (overriding method) tidak boleh
mempunyai modiffer yang lebih luas aksesnya daripada method yang meng override (overriding
method)
* Alasan melakukan Overriding :
- Mendefinisikan kembali method kelas induknya
secara total. Hal ini menyebabkan virtual machine menjalankan method anak, bukan
method milik induk.
- Menambahkan behaviour tertentu pada method
kelas induknya
- Dapat menambahkan sifat / atribut pada kelas
induknya
- Nama method harus sama
- Daftar parameter harus sama
- Return type harus sama
TEORI TENTANG OVERRIDING
Ambil contoh kasus
tentang class induk Mobil dan class turunannya CitiCar. Method naikkanKecepatan
diwariskan ke class CitiCar. Kalau CitiCar tidak mendeklarasi dan menuliskan
kembali method naikkanKecepatan, maka setiap kali method CitiCar.naikkanKecepatan
dipanggil, maka yang dijalankan adalah method Mobil.naikkanKecepatan. Dalam kasus
overriding, method naikkanKecepatan dideklarasi dan ditulis kembali di CitiCar.
Ketika method CitiCar.naikkanKecepatan dipanggil, virtual machine akan
menjalankan method milik CitiCar, meskipun di class induknya Mobil method yang
sama telah dituliskan.
Kalau ada
method yang sama ditulis di CitiCar yaitu naikkanKecepatan, kemudian method
Mobil.naikkanKecepatan dipanggil, siapa yang akan dijalankan? Milik CitiCar
ataukah milik Mobil? Tentu saja miliknya Mobil dong! :) Inheritance adalah
pewarisan sifat kebawah, bukan ke atas. Pemikiran seperti ini bisa di-counter
dengan pengandaian seperti ini: Kalau misalnya class turunan dari Mobil lebih
dari satu dan mereka sama-sama menuliskan kembali method naikkanKecepatan, punya
siapa yang akan dipakai? Dari sini sebenarnya dapat disimpukan bahwa Overriding-nya
jelas, mengacu pada satu class induk. Bayangkan bagaimana rumitnya kalau sebuah
class mengizinkan multiple inheritance?
CONTOH SOURCE CODE
#include "iostream.h"
#include "conio.h"
using namespace std;
/*--------------------------------------------------------------
: Nama Kelas : convert_base :
: Tujuan : Menyediakan kelas dasar dengan virtual function :
: Kelas lain dapat diturunkan dari kelas ini dengan :
: implementasi polymorphism :
----------------------------------------------------------------*/
class convert_base
{
protected: /* atribut dari kelas dasar */
double initial_value;
double converted_value;
public: /* fungsi dari kelas dasar */
convert_base(double passed_value) /* constructor */
{
initial_value = passed_value;
}
double get_initial()
{
return initial_value;
}
double get_converted()
{
return converted_value;
}
virtual void convert_it() = 0; /* a PURE virtual function */
}; /* akhir dari kelas convert_base */
/*--------------------------------------------
: Nama Kelas : kilos_miles :
: Tujuan : konversi dari kilometers ke miles :
----------------------------------------------*/
class kilos_miles : public convert_base
{
public:
kilos_miles(double passed_value) : convert_base(passed_value) { }
void convert_it() /* meng-override virtual class convert_it() */
{
converted_value = initial_value * 0.6;
}
}; /* akhir kelas kilos_miles */
/*--------------------------------------------
: Nama Kelas : miles_kilos :
: Tujuan : konversi dari miles ke kilometers :
----------------------------------------------*/
class miles_kilos : public convert_base
{
public:
miles_kilos(double passed_value) : convert_base(passed_value) { }
/* Kode untuk fungsi konversi kilo ke miles
1 kilometer = 0.6 miles */
void convert_it() /* meng-override virtual class convert_it() */
{
converted_value = initial_value * (1/0.6);
}
}; /* akhir kelas miles_kilos */
/*------------------------------------------
: Nama Kelas : meters_yards :
: Tujuan : konversi dari meters ke yards :
-------------------------------------------*/
/* Kode untuk membuat class yang mengonversi METER ke YARDS
1 Yard = 36.0 / 39.0 Meter */
class meter_yard : public convert_base
{
public:
meter_yard (double passed_value): convert_base(passed_value) { }
void convert_it()
{
converted_value = (initial_value) * (39.0/36.0);
}
}; /* akhir kelas meters_yards */
/*------------------------------------------
: Nama Kelas : yards_meters :
: Tujuan : konversi dari yards ke meters :
-------------------------------------------*/
/* Berikut kode untuk membuat kelas yang mengonversi YARD ke METER
1 Meter = 39.0/36.0 Yard */
class yard_meter : public convert_base
{
public:
yard_meter (double passed_value) : convert_base(passed_value) { }
void convert_it()
{
converted_value = (initial_value) * (36.0/39.0);
}
}; /* akhir kelas yards_meters */
/************* Main Function Starts Here ***********/
int main()
{
kilos_miles kilos1(100.0); /* membuat objek kilos_miles */
kilos1.convert_it(); /* memanggil virtual function dari kelas tsb */
cout << endl;
cout << endl << "Distance in kilometers is: " << kilos1.get_initial();
cout << endl << "Distance in miles is: " << kilos1.get_converted();
cout << endl;
/*
1. Membuat objek miles_to_kilos, dengan nilai awal 60
2. Memanggil virtual function dari objek tsb
3. Mencetak nilai awal dan nilai konversi
Catatan: lihat kode untuk Kilos_to_miles di atas.
*/
miles_kilos miles1(60.0); /* membuat objek miles_to_kilos */
miles1.convert_it(); /* memanggil virtual function dari kelas tsb */
cout << endl;
cout << endl << "Distance in miles is: " << miles1.get_initial();
cout << endl << "Distance in kilometers is: " << miles1.get_converted();
cout << endl;
/*
1. Membuat objek Yards_to_Meters, dengan nilai awal 4.
2. Mencetak nilai awal dan nilai konversi
*/
yard_meter yard1(4.0); /* membuat objek yard_meter */
yard1.convert_it(); /* memanggil virtual function dari kelas tsb */
cout << endl;
cout << endl << "Distance in yard is: " << yard1.get_initial();
cout << endl << "Distance in meter is: " << yard1.get_converted();
cout << endl;
/*
3. Gunakan kelas Meters_to_Yards, beri nilai awal 4
4. Cetak nilai awal dan nilai konversi
*/
meter_yard meter1(4.0); /* membuat objek meter_yard */
meter1.convert_it(); /* memanggil virtual function dari kelas tsb */
cout << endl;
cout << endl << "Distance in meter is: " << meter1.get_initial();
cout << endl << "Distance in yard is: " << meter1.get_converted();
cout << endl;
getch();
return(0);
} /* end main */
Tidak ada komentar:
Posting Komentar