TUGAS 3 OOP-BP2
>> Rabu, 23 September 2009
NAMA : SATIYA RIZKI NURRAKHIM
NPM : 0834010092 (GENAP)
==================================================================================================
OVERLOADING
Overloading adalah : Menuliskan kembali method dengan nama yang sama pada suatu class yang bertujuan memudahkan penggunaan/pemanggilan method dengan fungsionalitas yang mirip.
Aturan Pendeklarasian Method Overloading
1. Nama method harus sama
2. Daftar parameter harus berbeda
3. Return type boleh sama, juga boleh berbeda
Konsep dasar yang harus dimiliki untuk dapat melakukan overload terhadap operator adalah dengan mendefinisikan suatu fungsi, yaitu yang dikenal dengan sebutan fungsi operator . Untuk membuat fungsi ini digunakan kata kunci operator. Fungsi operator kebanyakan berperan sebagai anggota (member function ) dari suatu kelas. Kalaupun tidak, maka fungsi tersebut biasanya merupakan suatu friend function . Terdapat perbedaan antara penulisan fungsi untuk pembuatan fungsi operator yang merupakan anggota kelas dan yang bukan.
Berikut ini bentuk umum pembuatan fungsi operator yang merupaka n anggota dari suatu kelas.
tipe_kembalian nama_kelas::operator#(daftar_parameter) {
// Operasi yang akan dilakukan }
Pada bentuk umum di atas, nama_kelas adalah nama dari kelas pemilik fungsi tersebut. Sedangkan tanda # di atas berfungsi sebagai placeholder , artinya di sinilah kita mendefinisikan operator apa yang akan kita overload . Apabila kita ingin melakukan overload terhada p operator +, maka penulisan fungsinya adalah operator+. Begitu pula jika kita akan melakukan overload terhadap operator /, maka kita akan menulisnya operator/. Sedangkan bentuk umum dari pembuata n fungsi yang bukan merupaka n anggota kelas (yang biasanya adalah friend function ) adalah sama seperti pendefinisian fungsi biasa, yaitu sebagai berikut :
tipe_kembalian operator#(daftar_parameter) {
// Operasi yang akan dilakukan }
Operator yang Tidak Dapat di- overload
Meskipun C++ telah memberikan kebebasan kepada kita untuk melakukan overload , namun ada beberapa operator yang tidak diizinkan untuk di- overload . Berikut ini operator - operator yang dimaksud di atas.
. .* :: ?:
MELAKUKAN OVERLOAD TERHADAP OPERATOR BINARY
Pada bagian ini kita akan membahas mengenai overload terhadap operator binary , Adapun operator binary yang akan di- overload di sini hanyalah tiga, yaitu operator +, – dan =. Namun operator binary ada beberapa macam diantaranya adalah + - * / % ^ & | << >>,+= -= *= /= %= ^= &= |= <<= >>=,< <= > >= == != && || , [] () new new[] delete delete[]
Overload Operator +
Di sini kita akan membuat program yang di dalamnya terdapat overload operator plus (+) sehingga operator tersebut dapat menjumlahkan dua buah nilai yang bertipe objek. Fokuskan perhatian Anda ke pembuatan fungsi operator di bawah ini. Adapun sintak program nya adalah sebagai berikut.
#include
using namespace std;
// Membuat kelas TITIK
class TITIK {
int X, Y;
public:
// Membuat fungsi constructor untuk kelas TITIK
TITIK(int XX, int YY) {
X = XX;
Y = YY;
}
// Membuat fungsi ShowXY
void ShowXY() {
cout<<”Nilai X : “<<
cout<<”Nilai Y : “<<
}
// Mendeklarasikan fungsi operator yang mengembalikan
// objek TITIK
TITIK TITIK::operator +(TITIK P);
};
// Implementasi dari fungsi operator di atas
TITIK TITIK::operator +(TITIK P) {
return TITIK(P.X + X, P.Y + Y);
}
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas TITIK
TITIK A(2, 3);
TITIK B(5, 4);
// Menampilkan nilai X dan Y yang terdapat pada objek A dan B
A.ShowXY();
cout< B.ShowXY();
cout<
// Menjumlahkan objek A dan B dan menyimpannya ke objek C
TITIK C = A + B;
// Menampilkan nilai X dan Y yang terdapat pada objek C
C.ShowXY();
return 0;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Nilai X : 2
Nilai Y : 3
Nilai X : 5
Nilai Y : 4
Nilai X : 7
Nilai Y : 7
Seperti yang kita lihat di atas bahwa operator + dapat kita gunakan untuk menjumlahkan dua buah objek bertipe TITIK. Secara default , operasi ini tentu tidak diperbolehkan oleh kompiler. Namun dengan melakukan overload terhadap operator tersebut, maka kita dapat melakukannya.
Overload Operator –
Untuk melakukan overload terhadap operator – tentu prinsipnya sama dengan overload terhada p operator + di atas. Namun, sebagai pengetahuan bagi Anda, kita akan melakukan modifikasi terhada p program di atas dengan menamba hkan fungsi operator untuk operator –. Adapun sintak program nya adalah sebagai berikut :
#include
using namespace std;
class TITIK {
int X, Y;
public:
// Membuat fungsi SetXY dan ShowXY
void SetXY(int XX, int YY) {
X = XX;
Y = YY;
}
void ShowXY() {
cout<<”Nilai X : “<<
cout<<”Nilai Y : “<<
}
// Mendeklarasikan fungsi operator untuk operator -
TITIK TITIK::operator –(TITIK P);
};
// Implementasi dari fungsi operator di atas
TITIK TITIK::operator –(TITIK P) {
TITIK temp; // Membuat objek temporary yang bertipe TITIK
temp.X = X – P.X;
temp.Y = Y – P.Y;
return temp;
}
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas TITIK
TITIK A, B, C;
// Mengeset nilai X dan Y untuk objek A dan B
A.SetXY(10, 6);
B.SetXY(4,2);
// Menampilkan nilai X dan Y yang terdapat pada objek A
A.ShowXY();
cout<
// Menampilkan nilai X dan Y yang terdapat pada objek A
B.ShowXY();
cout<
// Melakukan pengurangan terhadap objek A dan B
C = A – B;
// Menampilkan nilai X dan Y yang terdapat pada objek C
C.ShowXY();
return 0;
}
Apabila dijalankan progra m di atas akan memberikan hasil sebagai
berikut :
Nilai X : 10
Nilai Y : 6
Nilai X : 4
Nilai Y : 2
Nilai X : 6
Nilai Y : 4
Overload Operator =
Pada bagian ini kita akan melakukan overload terhada p operator =. Sebelumnya kita telah mengetahui bahwa operator = digunakan untuk melakukan assigment suatu nilai ke dalam suatu variabel. Namun di sini, kita akan menjadikan operator tersebut bekerja untuk assignment nilai ke dalam sebuah objek. Prinsip kerjanya sama dengan layaknya fungsi yang
digunakan untuk pengesetan nilai (misalnya SetX()). Untuk lebih memaha minya, perhatikan dahulu program di bawah ini, dimana nilai diset melalui fungsi. Adapun sintaknya adalah sebagai berikut :
#include
using namespace std;
class CONTOH {
int X;
public:
void SetX(int XX) {
X = XX;
}
int GetX() {
return X;
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas CONTOH
CONTOH A;
// Memasukkan nilai 5 ke variabel X yang terdapat
// pada kelas CONTOH
A.SetX(5);
// Menampilkan nilai X
cout<<”Nilai X : “<
return 0;
}
Seperti yang kita lihat di atas bahwa untuk memasukkan nilai ke dalam variabel X yang terdapat pada objek A, kita menggunakan fungsi SetX(). Di sini kita tidak dapat melakukan nya dengan menggunakan operator =, yaitu dengan statemen :
A = 5; // SALAH, tidak diizinkan oleh compiler Namun, untuk mengatasi kasus seperti ini, sebenarnya kita dapat melakukan overload terhadap operator =. Berikut ini contoh program yang akan menunjukka n hal tersebut.
#include
using namespace std;
class CONTOH {
int X;
public:
int GetX() {
return X;
}
// Membuat fungsi operator
int operator =(int nilai) {
X = nilai;
return 1; // return true
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas CONTOH
CONTOH A;
// Memasukkan nilai 5 ke variabel X yang terdapat
// pada kelas CONTOH
A = 5; // Sebenarnya memanggil A.operator=(5)
// Menampilkan nilai X
cout<<”Nilai X : “<
return 0;
}
Apabila kedua program di atas dijalankan, maka akan memberikan hasil yang sama, yaitu sebagai berikut :
Nilai X : 5
MELAKUKAN OVERLOAD TERHADAP OPERATOR UNARY
Selain operator binary , kita juga dapat melakukan overload terhadap operator - operator unary . Adapun contoh yang akan kita bahas di sini hanya mencakup operator increment (++) dan decrement (--) saja. Beberapa operator unary : + - * & ~ ! ++ -- -> ->*
Overload Operator ++
Secara default , dalam C++ operator increment (++) digunakan untuk menamba hkan nilai satu terhadap suatu variabel yang bertipe bilangan bulat, bilangan floating - point maupun karakter. Namun di sini, kita akan melakukan overload terhadap operator tersebut sehingga dapat bekerja untuk tipe objek. Adapun kelas yang akan diambil sebagai contoh di sini adalah kelas titik (yang mempu nyai data X dan Y). Pada contoh ini, setiap increment objek maka nilai X dan Y dari objek tersebut secara otomatis akan bertambah satu. Berikut ini sintak progra m yang menunjukkan hal tersebut.
#include
using namespace std;
class TITIK {
int X, Y;
public:
// Membuat fungsi constructor untuk kelas TITIK
TITIK (int XX, int YY) {
X = XX;
Y = YY;
}
// Membuat fungsi ShowXY()
void ShowXY() {
cout<<”Nilai X : “<<
cout<<”Nilai Y : “<<
}
// Membuat fungsi operator untuk pre-increment
TITIK operator ++() {
X += 1; // dapat dituliskan X = X + 1
Y += 1; // dapat dituliskan Y = Y + 1
return *this;
}
// Membuat fungsi operator untuk post-increment
TITIK operator ++(int) {
X += 1;
Y += 1;
return *this;
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas TITIK
TITIK A(2, 4);
// Melakukan pre-increment terhadap objek A
cout<<”Pre-increment untuk objek A”<
++A;
// Menampilkan nilai X dan Y yang terdapat pada objek A
A.ShowXY();
cout<
// Melakukan instansiasi terhadap kelas TITIK
TITIK B(10, 5);
// Melakukan post-increment terhadap objek B
cout<<”Post-increment untuk objek B”<
B++;
// Menampilkan nilai X dan Y yang terdapat pada objek B
B.ShowXY();
return 0;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Pre- increment untuk objek A
Nilai X : 3
Nilai Y : 5
Post - increment untuk objek B
Nilai X : 11
Nilai Y : 6
Overload Operator --
Masih seputar kelas TITIK, di sini kita akan menjadikan operator decrement (--) dapat bekerja untuk objek yang bertipe TITIK. Sebenarnya prinsip yang terapat di dalamnya adalah sama saja dengan overload terhadap operator increment (++) di atas. Untuk lebih jelasnya, perhatikan contoh program di bawah ini.
#include
using namespace std;
class TITIK {
int X, Y;
public:
// Membuat fungsi constructor untuk kelas TITIK
TITIK (int XX, int YY) {
X = XX;
Y = YY;
}
// Membuat fungsi ShowXY()
void ShowXY() {
cout<<”Nilai X : “<<
cout<<”Nilai Y : “<<
}
// Membuat fungsi operator untuk pre-increment
TITIK operator --() {
X -= 1; // dapat dituliskan X = X - 1
Y -= 1; // dapat dituliskan Y = Y - 1
return *this;
}
// Membuat fungsi operator untuk post-increment
TITIK operator --(int) {
X -= 1;
Y -= 1;
return *this;
}
};
// Fungsi utama
int main() {
// Melakukan instansiasi terhadap kelas TITIK
TITIK A(10, 20);
// Melakukan pre-decrement terhadap objek A
cout<<”Pre-decrement untuk objek A”<
--A;
// Menampilkan nilai X dan Y yang terdapat pada objek A
A.ShowXY();
cout<
// Melakukan instansiasi terhadap kelas TITIK
TITIK B(2, 6);
// Melakukan post-decrement terhadap objek B
cout<<”Post-decrement untuk objek B”<
B--;
// Menampilkan nilai X dan Y yang terdapat pada objek B
B.ShowXY();
return 0;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Pre- decrement untuk objek A
Nilai X : 9
Nilai Y : 19
Post - decrement untuk objek B
Nilai X : 1
Nilai Y : 5
