NPM : 0834010119
Kelas: TF C
A. Polimorfisme sederhana dalam c++
Polymorphism adalah pemikiran bahwa objek dinamis suatu class dasar dapat berperilaku seperti class turunan. Jika objek menunjuk class dasar maka ia perilaku seperti class dasar, dan jika ia menunjuk class turunan ia akan berperilaku seperti class turunan.
Dalam hal ini obkjek memiliki beberapa bentuk, tergantung ia menunjuk kemana. Dalam hal ini suatu objek atau class dan perubahan perilakunya adalah dari kelas dasar ke kelas turunan, tidak bisa objek kelas turunan menunjuk ke kelas dasar. Polimorfisme dimungkinkan karena adanya mekanisme ikatan dinamis, ikatan ini adalah ikatan yang terjadi ketika program dijalankan (run-time), ikatan yang terjadi pada saat compiling disebut ikatan dinamis. Ikatan dinamis hanya akan terjadi antara suatu objek dinamis dengan metode yang dinamis juga, dalam hal ini metode virtual (maya)
#include
#include
class Tbujursangkar
{
protected:
double panjang;
Membuat class dengan nama class Tbujursangkar dengan variable panjang dengan tipe data double dengan sifat protected, class ini akan menjadi class dasar.
public:
Tbujursangkar(double pj){panjang=pj;}
Konstruktor dengan sifat public Tbujursangkar(double pj){panjang=pj;} yang mendefinisikan variable pj sama dengan panjang,
double Panjang(){return panjang;}
fungsi Panjang dengan return value double yang mengembalikan nilai kembali ke variable panjang
virtual double Lebar(){return panjang;}
Lalu fungsi Lebar dengan penambahan syntax virtual di depan nama fungsi menandakan fungsi tersebut bersifat polimorfisme, syntax virtual akan menciptakan ikatan dinamis, ikatan ini adalah ikatan yang terjadi ketika program dijalankan (ru-time), Ikatan dinamis ini hanya akan terjadi antara suatu objek dinamis dengan metode yang dinamis juga, dalam hal ini metode virtual (maya)
double Luas(){return Panjang() *Lebar() ;}};
fungsi double Luas dengan parameter mengalikan antara fungsi Panjang dengan fungsi Lebar, yang akan menghasilkan Luas persegi panjang.
class Tpersegipanjang:public Tbujursangkar
{
Deklarasi Class diatas merupakan class Tpersegipanjang yang merupakan turunan dari class Tbujursangkar,
protected:
double lebar;
deklarasi variable lebar, variable lebar merupakan variable tambahan yang diperlukan untuk menghitung suatu persegi panjang, karena variable panjang telah ada dalam class induknya sehingga tidak perlu ditampilkan lagi.
public:
Tpersegipanjang(double pj, double lb):Tbujursangkar(pj){lebar=lb;}
Pada bagian public terdapat konstruktor Tpersegipanjang, yang mendeklarasikan variable pj dan lb dimana pj sama dengan panjang dan lb sama dengan lebar.
virtual double Lebar(){return lebar;}
deklarasi virtual fungsi Lebar yang menandakan bersifat polimorfisme ini diketahui dengan penambahan kode virtual didepan nama fungsi.
void main()//program utama
{
Tpersegipanjang *pp=new Tpersegipanjang(8,6);
Memanggil konstruktor Tpersegipanjang dalam variable pointer pp, variable pp ini di inisialiasi dengan nilai dari dari Tpersegipanjang yaitu 8 dan 6.
cout<<"panjang = "
Menampilkan nilai dari panjang() dengan fungsi yang dipanggil pada kelas Tbujursangkar, lebar() dipanggil dengan fungsi dari kelas Tpersegipanajng yang bersifat polymorfisme sehingga akan terbentuk ikatan dinamis antara variable panjang dengan fungsi lebar() dan luas() dengan fungsi yang dipanggil dari kelas Tbujursangkar.
delete pp;
getch();
}
menghapus nilai dari variable pp agar tidak membebani memori. Dari dua kelas diatas, pada kelas TBujursangkar pada saat pendefinisian fungsi lebar, return ditujukan ke variabel panjang, sedangkan pada kelas Tpersegipanjang juga didefinisikan fungsi lebar yang return valuenya dikembalikan ke variabel lebar. Sehingga dari kejadian inilah terjadi apa yang dinamakan polimorfisme, yaitu pendefinisian dua fungsi dengan nama yang sama pada kelas yang berbeda dan dengan parameter yang berbeda. Polimorfisme tidak sama dengan overloading. Untuk menghindari polimorfisme yaitu dengan cara menambahkan keyword virtual didepan fungsi tersebut seperti yang terlihat pada contoh program diatas. Sehingga ketika program tersebut jika dijalankan hasil dari fungsi luas() adalah 48.
untuk penambahan fungsi keliling pada program, penambahanya adalah sebagai berikut :
virtual double keliling(){return 2*(panjang+lebar);}
atau dapat juga menambahkanya pada class Tbujursangkar, hasilnya akan sama saja. Isi dari fungsi diatas adalah rumus dari keliling persegipanjang. Dan untuk menampilkan output adalah sebagai berikut
<<"Keliling= "
Merupakan pemanggilan dari fungsi keliling pada program utama sama dengan pemanggilan pada fungsi lebar sebelumnya.
kode langkap :
#include
#include
/* class DENGAN virtual( POLYMORPHISME)==========*/
class tbujursangkar_vir
{
protected :
double panjang; //panjang sisi bujur sangkar
public:
tbujursangkar_vir(double pj) {panjang = pj;}
double panjangf() {return panjang;}
virtual double lebarf() {return panjang;}
double luasf() {return panjangf()*lebarf();}
double keliling() {return 4*panjang;}
};
class tpersegipanjang_vir:public tbujursangkar_vir
{
protected:
double lebar; //lebar persegi panjang
public:
tpersegipanjang_vir(double pj, double lb):
tbujursangkar_vir(pj) {lebar = lb;}
virtual double lebarf() {return lebar;}
double keliling() {return 2*panjang+2*lebar;}
};
//=========================================main===============================//
void main()
{
double a,b;
cout<>a ;
cout<>b ;
tbujursangkar_vir *bujur = new tbujursangkar_vir(a);
tpersegipanjang_vir *persegi = new tpersegipanjang_vir(a,b);
cout<<"===========hasil pada class tbujursangkar================"<
cout<<"===========hasil pada class tpersegipanjang================"<
delete bujur;
delete persegi;
system("pause");
}
B.Constructor
C() adalah anggota class yang bertugas melakukan inisialisasi obyek (instance) dari suatu class C. Constructor mempunyai nama yang sama dengan nama class, dan tidak mempunyai return value. Sebuah class dapat mempunyai lebih dari satu constructor. Constructor yang tidak mempunyai argumen, disebut default constructor, sebaliknya constructor yang mempunyai lebih dari satu argumen adalah non-default consructor. Constructor dengan satu default argument tetap merupakan sebuah default constructor,
class C
{
public:
C(int count=10) : _count(count) {}
…
private:
int _count;
};
Compiler C++ dapat menambahkan default constructor bilamana diperlukan, jika dalam definisi class
1. • tidak tertulis secara eksplisit sebuah default constructor dan tidak ada deklarasi constructor lain (copy constructor).
2. • tidak ada anggota class berupa data const maupun reference.
Sebagai contoh definisi class C sebagai berikut,
class C {…};
C c1; // memerlukan default constructor
C c2(c1); // memerlukan copy constructor
Compiler C++ memutuskan untuk menambahkan default dan copy construtor setelah menemui kedua baris program tersebut, sehingga definisi class secara efektif menjadi sebagai berikut,
class C
{
public:
C(); // default costructor
C(const C& rhs); // copy constructor
~C(); // destructor
4Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
C& operator=(const C& rhs); // assignment operator
C* operator&(); // address-of operator
const C* operator&(const C& rhs) const;
};
compiler menambahkan public constructor, dan destructor. Selain itu, compiler juga menambahkan assignment operator dan address-of operator. Constructor (default dan non-default) tidak harus mempunyai akses public, sebagai contoh adalah pola desain (design pattern) Singleton.
class Singleton
{
public:
static Singleton* instance();
protected:
Singleton();
private:
static Singleton* _instance;
};
obyek (instance) singleton tidak dibentuk melalui constructor melainkan melalui fungsi instance. Tidak ada obyek singleton lain yang dapat dibentuk jika sudah ada satu obyek singleton.
Umumnya default constructor bentukan compiler (generated default constructor) menggunakan default constructor anggota bertipe class, sedangkan anggota biasa (built-in type) tidak diinisialisasi. Demikian halnya dengan obyek yang dibentuk dari obyek lain (copy), maka copy constructor bentukan compiler (generated copy constructor) menggunakan copy constructor dari anggota bertipe class pada saat inisialisasi. Sebagai contoh deklarasi class C berikut ini,
class C
{
public:
C(const char* aName);
C(const string& aName);
…
private:
std::string name;
};
copy constructor bentukan compiler menggunakan copy constructor class string untuk inisialisasi name dari aName. Jika class C tidak mempunyai constructor, maka compiler menambahkan juga default constructor untuk inisialisasi name menggunakan default constructor class string.
Inisialisasi obyek menggunakan constructor (non-default) dapat dilakukan dengan member initializer maupun dengan assignment sebagai berikut,
5Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
Kedua cara tersebut memberikan hasil yang sama, tidak ada perbedaan signifikan antara kedua cara tersebut untuk data bukan tipe class. Cara member initializer mutlak diperlukan untuk data const maupun reference, seperti kedua contoh berikut ini:
class C //:1
{
public:
C(int hi,int lo) : _hi(hi),_lo(lo) {}
…
private:
const int _hi,_lo; // const member
};
class C //:2
{
public:
C(const string& aName) : name(aName) {}
…
private:
std::string& name; // reference member
};
Cara member initialization sebaiknya dilakukan untuk anggota bertipe class (user-defined type) seperti ditunjukkan pada contoh berikut ini,
class C
{
public:
C(const string& aName) : name(aName) { }
private:
std::string name; // bukan reference member
};
6Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
Pertimbangan menggunakan cara member initialization terletak pada efisiensi eksekusi program. Hal ini berkaitan dengan cara kerja C++ yang membentuk obyek dalam dua tahap,
1. • pertama, inisialisasi data
2. • kedua, eksekusi constructor (assignment)
Dengan demikian jika menggunakan cara assignment sebenarnya eksekusi program dilakukan dua kali, pertama inisialisasi kemudian assignment, sedangkan menggunakan member initialization hanya memanggil sekali constructor class string. Semakin kompleks class tersebut (lebih kompleks dari class string) semakin mahal (tidak efisien) proses pembentukan obyek melalui cara assignment.
Constructor dengan satu argumen berfungsi juga sebagai implicit conversion operator. Sebagai contoh deklarasi class A dan B berikut ini,
class A
{
public:
A();
};
class B
{
public:
B(const A&);
};
pada cuplikan baris program di bawah ini terjadi konversi tipe obyek A ke B secara implisit melalui copy constructor class B.
A a
B b=a; // implicit conversion
explicit
C++ menyediakan satu sarana, menggunakan keyword explicit, untuk mengubah perilaku constructor dengan satu argumen agar tidak berfungsi sebagai conversion operator. Jika class B menyatakan explicit pada copy constructor sebagai berikut,
class B
{
public:
explicit B(const A& a); // explicit ctor
};
maka konversi A ke B secara implisit tidak dapat dilakukan. Konversi A ke B dapat dilakukan secara eksplisit menggunakan typecast,
A a;
7Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
B b=static_cast(a); atau
B b=(B)a;
Konversi secara implisit dapat terjadi melalui argumen fungsi f dengan tipe B
void f(const B& );
tetapi f diakses dengan variabel tipe A, f(a). Apabila class B menghalangi konversi secara implisit maka argumen fungsi f menjadi,
f((B)a); atau
f(static_cast(a));
Konversi tipe obyek secara implisit sebaiknya dihindari karena efeknya mungkin lebih besar terhadap aplikasi program secara keseluruhan dan tidak dapat dicegah pada saat kompilasi, karena construcor dengan argumen tunggal adalah suatu pernyataan program yang sah dan memang dibutuhkan.
Copy Constructor dan Copy Assignment
Sejauh ini sudah dibahas mengenai copy constructor sebagai anggota class yang berperan penting pada saat pembentukan obyek. Apabila sebuah class tidak menyatakan secara tegas copy constructor class tersebut, maka compiler menambahkan copy constructor dengan bentuk deklarasi,
C(const C& c);
Bentuk lain copy constructor adalah sebagai berikut,
C(C& c); atau
C(C volatile& c); atau
C(C const volatile& c);
Copy constructor class C adalah constructor yang mempunyai satu argumen. Sebuah copy constructor boleh mempunyai lebih dari satu argumen, asalkan argumen tersebut mempunyai nilai default (default argument).
C(C c); // bukan copy constructor
C(C const& c,A a=b); //copy constructor
Constructor dengan argumen bertipe C saja (tanpa reference) bukan merupakan copy constructor.
Copy constructor juga dibutuhkan pada saat memanggil suatu fungsi yang menerima argumen berupa obyek suatu class,
void f(C x);
memerlukan copy onstructor class C untuk mengcopy obyek c bertipe C ke obyek x dengan tipe yang sama, yaitu pada saat memanggil fungsi f(c)(pass-by-value).
8Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
Hal serupa terjadi pada saat fungsi f sebagai berikut,
C f()
{
C c;
…
return c;
}
mengirim obyek c ke fungsi lain yang memanggil fungsi f() tersebut.
Copy assignment operator class C adalah operator=, sebuah fungsi yang mempunyai satu argumen bertipe C. Umumnya deklarasi copy assignment mempunyai bentuk,
C &operator=(const C &c);
Bentuk lain yang mungkin adalah,
C &operator=(C &c); atau
C &operator=(C volatile &c); atau
C &operator=(C const volatile &c);
Copy assignment boleh mempunyai argumen dengan tipe C (bukan reference), tetapi tidak boleh mempunyai argumen lebih dari satu walaupun argumen tersebut mempunyai nilai default (default argument). Seperti halnya copy constructor, compiler akan menambahkan copy assignment jika suatu class tidak mempunyai fungsi tersebut. Copy assignment dibutuhkan untuk membentuk obyek melalui assignment, seperti contoh berikut
class C
{
public:
C(); //ctor
~C(); //dtor
…
};
C c1;
C c2=c1; //copy constructor
C c3;
c3=c1; //copy assignment
Class C tidak mempunyai copy constructor maupun copy assignment operator, maka pembentukan obyek c2, dan c3 menggunakan copy constructor dan copy assignment yang ditambahkan oleh compiler ke class C tersebut.
Suatu class yang mempunyai data dengan alokasi dinamik (pointer) sebaiknya tidak mengandalkan copy constructor maupun copy assignment operator yang ditambahkan compiler. Copy assignment hasil tambahan compiler mengcopy (memberwise copy)
9Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
pointer dari obyek satu (yang dicopy) ke obyek lainnya (hasil copy), sehingga kedua obyek mengacu ke lokasi memori yang sama. Masalah timbul jika kedua obyek mempunyai masa pakai (lifetime1 ) yang berbeda. Jika salah satu obyek sudah habis masa pakainya maka destructor obyek tersebut mengembalikan memori (dynamic memory) yang digunakan obyek tersebut, padahal copy obyek tersebut masih mengacu ke lokasi memori yang sama.
Copy assignment b=a
Hasil copy assignment b=a
Pada contoh hasil copy assignment b=a (shalow copy), menunjukkan kedua obyek a dan b mengacu ke lokasi memori p. Apabila obyek a melepas memori p (melalui destructor), maka obyek b mengacu ke lokasi memori yang sudah tidak valid lagi. Lokasi memori p dapat digunakan obyek lain jika obyek a melepasnya. Demikian pula halnya dengan lokasi memori q, apabila obyek b habis masa pakainya (keluar scope, dihapus dll) maka destructor class B tidak melepas memori q. Akibatnya terjadi pemborosan memori (memory leak).
Salah satu jalan keluar adalah dengan menyatakan secara tegas copy constructor dan copy assignment yang dibutuhkan suatu class sehingga compiler tidak membuat copy constructor dan copy assignment ke class tersebut. Alternatif lain adalah menempatkan deklarasi copy constructor dan copy assignment operator private sebagai berikut,
class C
{
…
private:
C(const C&);
C &operator=(const C&);
};
definisi copy constructor dan copy assignment operator class C pada contoh di atas tidak perlu ada, karena tujuannya adalah menghalangi proses penggandaan (copy) menggunakan kedua fungsi tersebut. Pada tahap kompilasi penggunaan assignment, b=a masih dapat diterima karena deklarasi asignment operator tersebut tersedia. Pada saat link akan gagal karena linker tidak dapat menemukan definisi copy assignment operator. Teknik ini masih mempunyai kelemahan, karena class lain masih mungkin
A
B
A
p
q
p
B
q
1 Lifetime atau storage duration adalah waktu sejak pembentukan (construction) sampai penghancuran (destruction) obyek.
10Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
mempunyai akses ke private copy constructor dan copy assignment operator tersebut (melalui hubungan friendship).
Destructor
Destructor adalah anggota class (member function) yang berfungsi melepas memori pada saat suatu obyek sudah tidak diperlukan lagi. Fungsi destructor kebalikan constructor. Destructor tidak mempunyai atau memerlukan argumen. Destructor juga tidak mengembalikan nilai apapun (tidak mempunyai return type). Seperti halnya constructor, compiler dapat menambahkan sebuah destructor jika sebuah class tidak mempunyai destructor.
virtual Destructor
Sebuah destructor dapat berupa fungsi virtual. Hal ini menjadi keharusan jika class B,
1. • merupakan base class.
2. • class D yang menggunakan B sebagai base class mempunyai anggota berupa data dengan alokasi memori dinamik (pointer).
class B
{
public:
B();
~B();
};
class D : public B
{
public:
D() : p(new char[256]) {}
~D()
{
delete[] p;
}
…
private:
char *p;
};
Pada contoh tersebut destructor base class B bukan fungsi virtual. Dalam C++ umumnya obyek class D digunakan secara polimorphic dengan membentuk obyek class D (derived class) dan menyimpan alamat obyek tersebut dalam pointer class B (base class) seperti pada contoh berikut ini,
void main(void)
{
B *pB=new D();
delete pB;
}
11Kuliah Umum Ilmukomputer.com Copyright © 2003-2004 Ilmukomputer.com
Dalam standar C++ menghapus obyek D (derived class) melalui pointer class B (base class) sedangkan destructor base class non-virtual mempunyai efek yang tidak menentu (undefined behaviour). Apabila standard C++ tidak menetapkan apa yang seharusnya berlaku, maka terserah kepada pembuat compiler menentukan perilaku program pada kondisi semacam ini. Umumnya pembuat compiler mengambil langkah untuk tidak memanggil destructor class D (derived class). Dengan demikian, pada saat menjalankan perintah delete, destructor class D tidak dieksekusi karena destructor base class B non-virtual. Akibatnya lokasi memori dinamik yang digunakan class D tidak pernah dilepas. Hal ini adalah contoh lain terjadinya pemborosan memori (memory leak) oleh suatu program. Jalan keluarnya adalah membuat destructor base class B virtual,
class B
{
public:
B();
virtual ~B();
}
Tidak seperti destructor, tidak ada virtual constructor atau virtual copy constructor. Pada saat membentuk obyek, tipe obyek harus diketahui terlebih dahulu, apakah membentuk obyek class A, B, C dsb. Tidak ada aspek bahasa C++ untuk mewujudkan virtual constructor secara langsung, menempatkan virtual pada deklarasi constructor merupakan kesalahan yang terdeteksi pada proses kompilasi. Efek virtual constructor bukan tidak mungkin dicapai, C++ memungkinkan membuat idiom virtual constructor yang bertumpu pada fungsi virtual dalam kaitannya dengan hubungan antara sebuah class dengan base classnya.
Ringkasan
Sejauh ini pembahasan artikel masih belum menyentuh aspek praktis pemrograman, namun demikian dalam menterjemahkan suatu desain maupun memahami program yang ditulis orang lain sangatlah penting mengetahui aturan dasar sesuai standarisasi C++.
Butir-butir pembahasan dalam artikel ini antara lain,
1. • Fokus pembahasan adalah aspek pembentukan obyek. Tidak membahas aturan (rule) berkaitan dengan class dalam C++ secara komprehensif.
2. • Constructor merupakan anggota class yang berperan dalam pembentukan obyek. Compiler menambahkan constructor bilamana diperlukan ke class yang tidak mempunyai constructor. Constructor tidak harus mempunyai akses public. Inisialisasi data menggunakan constructor dapat dilakukan dengan cara member initialization dan assignment. Keduanya tidak mempunyai perbedaan signifikan untuk data biasa (built-in type seperti char, int, float, dll). Cara member initialization lebih efisien untuk data berupa class (user-defined type).
3. • Constructor dengan satu argumen dapat digunakan untuk konversi tipe data secara implisit. C++ menyediakan explicit untuk mengubah perilaku ini, karena hal tersebut melonggarkan janji C++ sebagai bahasa yang mengutamakan strict type (type safe).
