OVERLOADING
Berdasarkan arti dari overloading yakni beban yang terlalu berat, tapi dalam pemrograman c++ overloading mempunyai 2 pengertian yang dapat disesuaikan dengan pemakaiannya.
OVERLOADING FUNCTION
Pada fungsi terdapat arti beberapa fungsi dapat memiliki argument berbeda tetapi nama fungsi yang sama sama. Pada fungsi ini dapat kita jelaskan pada progaram dalam pemanggilan fungsi yang mempunyai nama sama :
Contoh Program
# include “iostream.h”
#include ”stdio.h”
class variabel
{
private: char c; long x;
public:
void tulis (char c)
{
printf("karakter=c\n");
}
void tulis (int x)
{
printf("Bilangan bulat=x\n");
}
};
void main()
{
variabel penentuan;
penentuan.tulis('c');
}
Bentuk hasil compiler :
Penjelasan :
Pada program tersebut terdapat 2 fungsi yang sama, tapi tetapi compiler tahu fungsi manakah yang harus dipanggil yang di karenakan compiler tahu bahwa pada pemanggilan fungsi itu argument ”karakter= C” yang di panggil oleh compiler.
C++ hanya dapat mengkompilasi overloading function jika argument fungsinya berbeda. Bila argument fungsinya sama tetapi tipe nilai kembaliannya berbeda, compiler akan melaporkan adanya kesalahan.
Contoh :
Fungsi : double coba (int) ; ç dengan Fungsi è int coba (int) ;
* DEFAULT ARGUMEN
Contoh :
Void func ( int x = 0, int y = 0 ) ;
Maksudnya adalah :
Contoh fungsi diatas dapat dipanggil dengan 3 (tiga) cara berbeda :
1. func ( ) // nilai x dan y otomatis 0
2. func ( 7 ) // nilai x = 7 dan y = 0
3. func ( 7, 33 ) // nilai x = 7 dan y = 33
Contoh deklarasi fungsi diatas akan terjadi kesalahan, jika variable x diberi nilai, sedangkan variable y tidak beri nilai.
Contoh :
Void func ( int x = 2, int y ) ;
* AMBIGUITY PADA OVERLOADING FUNCTION
Beberapa hal yang menimbulkan ketidak jelasan pada program :
1. type conversion
Contoh :
Void f ( double nilai )
Main ( )
{
Int I = 12 ;
F ( I ) ;
}
2. reference parameter
Parameter yang memiliki perbedaan hanya pada argument, dimana fungsi yang satu menggunakan reference parameter dan yang lainnya menggunakan value parameter.
Contoh :
Void func ( int x , int y ); dengan void func func ( int x , int& y) ;
OPERATOR OVERLOADING
Seperti halnya pada fungsi, C++ juga mengizinkan kita untuk melakukan overload terhadap operator. Ini berarti bahwa operator tersebut dapat kita gunakan sesuai kebutuhan yang kita inginkan sendiri. Sebagai contoh, C++ sendiri sebenarnya telah melakukan overload terhadap operator +, sehingga operator ini dapat berlaku untuk menjumlahkan nilai yang bertipe bilangan bulat (seperti int dan long) maupun floating- point (seperti float dan double). Pada bagian ini kita akan mempelajari bagaimana konsep dasar untuk membuat suatu operator dapat bekerja sesuai yang kita harapkan. 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 merupakan 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 terhadap operator +, maka penulisan fungsinya adalah operator+. Begitu pula jika kita akan melakukan overload terhadap operator /, maka kita akan menulisnya operator/. Sedangkan bentuk umum dari pembuatan fungsi yang bukan merupakan 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.
. .* :: ?:
Selain itu kita juga tidak diizinkan untuk melakukan overload terhadap simbol preprocessor , yaitu # dan ##. Untuk lebih jelasnya, berikut ini operator- operator yang dapat kita overload .
a. Operator Unary
+ - * & ~ ! ++ -- -> ->*
b. Operator Binary
+ - * / % ^ & | << >>
+= -= *= /= %= ^= &= |= <<= >>=
< <= > >= == != && ||
, [] ()
new new[] delete delete[]
Melakukan Overload terhadap Operator Binary
Pada bagian ini kita akan membahas mengenai overload terhadap operator binary , sedangkan operator unary akan dibahas pada sub bab selanjutnya di dalam buku ini. Hal ini dimaksudkan agar Anda dapat lebih memahami konsepnya terlebih dahulu. Adapun operator binary yang akan di- overload di sini hanyalah tiga, yaitu operator +, - dan =. Ini disebabkan karena Anda tentu sudah familiar dengan penggunaan operator- operator tersebut. Untuk lebih lengkapnya, diharapkan Anda dapat mengembangkannya sendiri dengan berbekal konsep- konsep yang telah di dapat pada bab ini. Berikut ini penjelasan mengenai cara- cara melakukan overload terhadap operator- operator yang dimaksud di atas.
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 programnya adalah sebagai berikut.
Contoh Program
#include ”iostream”
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 :
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 terhadap operator + di atas. Namun, sebagai pengetahuan bagi Anda, kita akan melakukan modifikasi terhadap program di atas dengan menambahkan fungsi operator untuk operator -. Adapun sintak programnya adalah sebagai berikut :
Contoh Program
#include ”iostream”
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;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Overload Operator =
Pada bagian ini kita akan melakukan overload terhadap 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 memahaminya, perhatikan dahulu program di bawah ini, dimana nilai diset melalui fungsi. Adapun sintaknya adalah sebagai berikut :
Contoh Program
#include ”iostream”
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;
}
Bila di compile akan tampil:
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 melakukannya dengan menggunakan operator =, yaitu dengan statemen :
A = 5; // SALAH, tidak diizinkan oleh kompiler
Namun, untuk mengatasi kasus seperti ini, sebenarnya kita dapat melakukan overload terhadap operator =. Berikut ini contoh program yang akan menunjukkan hal tersebut.
Contoh Program
#include ”iostream”
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 :
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.
1. Overload Operator ++
Secara default , dalam C++ operator increment (++) digunakan untuk menambahkan 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 mempunyai 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 program yang menunjukkan hal tersebut.
Contoh Program
#include ”iostream”
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 :
2. 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.
Contoh Program
#include ”iostream”
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;
}
Melakukan Overload terhadap Operator Khusus
Seperti yang telah dikemukanan sebelumnya, C++ mengizinkan kita untuk melakukan overload terhadap operator- operator khusus selain dari operator binary dan unary . Adapun operator khusus yang akan dibahas sebagai contoh di sini hanyalah operator new dan delete. Hal ini disebabkan karena pada prakteknya dalam kebanyakan program C++ sering sekali ditemui adanya overload terhadap kedua buah operator ini.
1. Overload Operator new
Dalam C++, kita juga dapat melakukan overload terhadap operator new sehingga kita dapat melakukan pengalokasian secara khusus untuk suatu tipe ataupun kelas tertentu. Adapun bentuk umum untuk membuat fungsi operator untuk operator new yang telah ditentukan dalam C++ adalah sebagai berikut :
void *operator new(size_t size) {
// Statemen untuk menjalankan alokasi memori
// Jika alokasi gagal, lemparkan eksepsi bad_alloc
return pointer;
}
Pada bentuk umum di atas, size_t adalah suatu tipe yang telah didefinisikan di dalam C++ (hampir sama dengan tipe unsigned integer). Sebagai contoh di sini kita akan melakukan overload terhadap operator new untuk kelas titik, dimana apabila kita melakukan pengalokasian memori untuk kelas titik tersebut, maka operator new yang akan dipanggil oleh kompiler adalah operator yang telah kita definisikan sendiri, bukan operator new yang telah terdefinisi dalam C++. Untuk lebih memahaminya, berikut ini sintak program yang menunjukkan hal tersebut.
Contoh Program
#include ”iostream”
#include ”cstdlib” // Untuk menggunakan fungsi malloc()
#include ”new” // Untuk menggunakan eksepsi bad_alloc
using namespace std;
class TITIK
{
int X, Y;
public:
TITIK(int XX, int YY)
{
X = XX;
Y = YY;
}
void ShowXY()
{
cout<<"Nilai X : "<
cout<<"Nilai Y : "<
}
// Membuat fungsi operator untuk operator new
void *operator new(size_t size)
{
void *P;
cout<<"Operator new yang didefinisikan sendiri"<
// Melakukan alokasi memori
P = malloc(size);
// Jika gagal, lemparkan eksepsi bad_alloc
if (!P)
{
bad_alloc BA;
throw BA;
}
return P;
}
};
// Fungsi utama
int main()
{
// Mendeklarasikan pointer PT yang akan menunjuk tipe TITIK
TITIK *PT;
// Melakukan alokasi dengan operator new
try
{
PT = new TITIK(2, 5);
// Menampilkan nilai X dan Y
PT->ShowXY();
}
catch (bad_alloc E)
{
cout<<"Alokasi untuk PT gagal"<
return 1;
}
// Mendealokasikan memori
delete PT;
// Mendeklarasikan pointer yang akan menunjuk ke tipe int
int *PI;
PI = new int;
*PI = 300;
cout<<"\nNilai *PI : "<<*PI<
return 0;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Seperti yang kita lihat di atas bahwa pada saat kita mengalokasikan tipe TITIK, maka yang akan dipanggil adalah operator new yang kita definisikan sendiri. Namun pada saat kita mengalokasikan tipe int, operator new yang digunakan adalah operator new asli yang terdapat pada C++. Sebagai bukti, di saat kita mengalokasikan tipe int, kita tidak melihat adanya teks "Operator new yang didefinisikan sendiri". Untuk operator delete di atas juga menggunakan operator yang telah terdefinisi secara default dalam C++. Walaupun demikian, kita juga dapat melakukan overload terhadap operator delete seperti yang akan dibahas pada sub bab di bawah ini.
2. Overload Operator delete
Pada bagian ini kita akan membahas overload untuk operator delete melalui sebuah contoh program. Namun sebelumnya kita harus mengetahui terlebih dahulu bentuk umum untuk pembuatan fungsi operator untuk operator delete, yaitu seperti yang tampak di bawah ini.
void operator delete(void *p)
{
// Mendealokasikan memori yang ditunjuk oleh pointer p
}
Adapun program yang akan dituliskan di bawah ini merupakan modifikasi dari program di atas. Di sini, kita akan melakukan overload terhadap operator delete sehingga dapat digunakan secara khusus untuk kelas TITIK. Berikut ini sintak program yang dimaksud.
Contoh Program :
#include ”iostream”
#include”cstdlib” // Untuk menggunakan fungsi malloc()
// dan free()
#include ”new” // Untuk menggunakan eksepsi bad_alloc
using namespace std;
class TITIK
{
int X, Y;
public:
TITIK(int XX, int YY)
{
X = XX;
Y = YY;
}
void ShowXY()
{
cout<<"Nilai X : "<
cout<<"Nilai Y : "<
}
// Membuat fungsi operator untuk operator new
void *operator new(size_t size)
{
void *P;
cout<<"Operator new yang didefinisikan sendiri"<
// Melakukan alokasi memori
P = malloc(size);
// Jika gagal, lemparkan eksepsi bad_alloc
if (!P)
{
bad_alloc BA;
throw BA;
}
return P;
}
// Membuat fungsi operator untuk operator delete
void operator delete(void *P)
{
cout<<"Operator delete yang didefinisikan sendiri"<
free(P);
}
};
// Fungsi utama
int main()
{
// Mendeklarasikan pointer PT yang akan menunjuk tipe TITIK
TITIK *PT;
// Melakukan alokasi dengan operator new
try
{
PT = new TITIK(2, 5);
// Menampilkan nilai X dan Y
PT->ShowXY();
}
catch (bad_alloc E)
{
cout<<"Alokasi untuk PT gagal"<
return 1;
}
// Mendealokasikan memori
delete PT;
// Mendeklarasikan pointer yang akan menunjuk ke tipe int
int *PI;
PI = new int;
*PI = 300;
cout<<"\nNilai *PI : "<<*PI<
return 0;
}
// Mendeklarasikan pointer yang akan menunjuk ke tipe int
int *PI;
PI = new int;
*PI = 300;
cout<<"\nNilai *PI : "<<*PI<
return 0;
}
Hasil yang akan diberikan dari program di atas adalah sebagai berikut :
Berbeda dengan program sebelumnya, operator delete yang digunakan di sini adalah operator delete yang khusus kita definisikan sendiri untuk kelas TITIK. Sebagai bukti pernyataan ini, pada saat kita menggunakan operator delete terhadap pointer yang menunjuk ke kelas TITIK, maka di layar akan ditampi lkan teks “Operator delete yang didefinisikan sendiri”. Sedangkan untuk penghapusan pointer PI yang menunjuk ke tipe int, operator delete yang digunakan masihlah operator asli yang terdapat pada C++.
Tidak ada komentar:
Posting Komentar
Masukkan Komentar Anda.......