BAB
4.
Pembebanan
Operator
4.1 Pengantar
Operator-operator seperti +, -, *, dan lainnya dipakai untuk menjalankan
operasi-operasi tertentu dan sering digunakan pada statemen-statemen program.
C++ memiliki banyak operator semacam itu yang didefinisikan untuk
variabel-variabel bertipe fundamental seperti int, float, double, char. Sebagai contoh, dimisalkan diberikan statemen-statemen
berikut.
int z = int x + int y ;
bool(y == z);
Pada ekseksusi atas statemen pertama, nilai dari int x ditambahkan pada nilai dari int y dan hasilnya ditugaskan kepada int z. Aksi dari operator + dan operator = telah didefinisikan di
dalam C++. Operasi-operasi semacam itu otomatis dilakukan oleh kompiler dan
programer tidak perlu menuliskan kode lain kecuali menuliskan statemen tersebut
di dalam program dan menjalankannya. Sama halnya, pada statemen kedua, nilai
dari y dibandingkan dengan nilai dari z dan jika keduanya sama maka dihasilkan
true atau 1 dan jika tidak sama dihasilkan keluaran false atau 0. Mode
perbandingan telah didefinisikan untuk tipe-tipe fundamental.
Untuk tipe-tipe data yang didefiisikan oleh user seperti objek-objek kelas
dimana di dalamnya sebuah objek dapat memuat beberapa item data, bagaimana Anda
membandingkan apakah satu objek kelas sama dengan objek kelas lain atau
bagaimana Anda menugaskan nilai-nilai yang terkait dengan satu objek kepada
objek dari kelas lain?. Sebagai contoh, dimisalkan Anda memiliki kelas Graf dan dimisalkan pula bahwa Graf1 dan Graf2 adalah dua objek dari kelas itu (Gambar 4.1a). Sekarang, jika
diinginkan untuk membandingkan dua graf untuk mengetahui apakah Graf1 sama dengan Graf2, bagaimana Anda menuliskan kode untuk membandingkan ini?.
Gambar 4.1b menunjukkan contoh lain, dua vektor V1 dan V2 sebagai objek-objek
dari kelas Vektor. Seperti yang Anda
ketahui bahwa sebuah vektor memiliki magnitudo dan arah. Sekarang, diinginkan
untuk membandingkan kedua vektor untuk memeriksa apakah keduanya sama atau untuk
menugaskan sebuah vektor ke vektor lain, sama seperti ketika Anda sering
melakukannya pada variabel-variabel int,
float, dan char. Selain itu, C++ tidak mengijinkan adanya operator-operator
baru. Anda harus menggunakan operator-operator yang Anda gunakan untuk
tipe-tipe fundamental. Jadi, Anda tidak bisa menuliskan V1 = V2 seperti ketika
Anda menggunakannya untuk variabel-variabel bertipe fundamental kecuali jika
Anda mendefinisikan-ulang bagaimana operator = diterapkan pada kasus itu. C++
mengijinkan Anda untuk mendefinisikan-ulang fungsionalitas operator-operator
tersebut sehingga dapat melakukan operasi-operasi yang Anda harapkan untuk
objek-objek dari kelas tertentu. Pendefinisian-ulang fungsionalitas dari
operator-operator untuk objek kelas dinamakan dengan pembebanan (overloading) operator.
Pada kasus graf (Gambar 4.1a), Anda bisa menuliskan kode bahwa jika garis
pada urutan yang sama memiliki panjang yang sama maka kedua graf dikatakan
sama. Sebagai contoh, dimulai dari kiri jika garis di sisi paling kiri dari Graf1 sama dengan garis di sisi paling
kiri dari Graf2, dan seterusnya jika
semua garis lain memiliki panjang yang sama pada kedua graf di posisi-posisi
yang sama maka dikatakan kedua graf itu sama.
GAMBAR 4.1
Fungsionalitas dari semua operator di dalam C++, kecuali beberapa operator
tertentu, dapat didefinisikan ulang untuk tipe-tipe user (objek-objek kelas)
untuk melakukan operasi-operasi yang diinginkan user. Ini dikatakan dengan pmbebanan operator. Ingat bahwa pembebanan
operator hanya berlaku pada tipe-tipe yang didefinisikan oleh user atau pada
campuran dari tipe-tipe user dan tipe-tipe fundamental. Untuk tipe-tipe
fundamental, operasi dari semua operator telah didefinisikan di dalam pustaka
standar C++, yang tidak bisa diubah oleh pembebanan operator.
Pembebanan operator merupakan aspek sangat penting dari C++ dan sangat
berguna dalam pemrograman berorientasi objek. Fitur ini memberikan Anda
fasilitas untuk menugaskan satu objek kelas ke objek kelas lain, atau untuk
membandingkan dua objek kelas dan lainnya. Jadi, pembebanan operator merupakan
perluasan dari C++.
4.2 Operator-Operator
yang bisa Dibebani
Hampir semua operator C++ dapat dibebani. Tabel 4.1 menyajikan daftar
operator yang dapat dibebani dan hanya ada 5 operator yang tidak bisa dibebani.
TABEL 4.1 Operator-operator yang bisa dibebani
|
+
|
-
|
*
|
/
|
%
|
=
|
&
|
|
|
~
|
^
|
|
==
|
<
|
>
|
!=
|
<=
|
>=
|
+=
|
-=
|
*=
|
/=
|
|
%=
|
&=
|
^=
|
|=
|
>>
|
<<
|
>>=
|
<<=
|
&&
|
||
|
|
!
|
unary ++
|
unary
--
|
unary
+
|
unary
-
|
,
|
[]
|
()
|
->
|
->*
|
|
new
|
new[]
|
delete
|
delete[]
|
|
|
|
|
|
|
OPERATOR-OPERATOR YANG TIDAK BISA DIBEBANI
Operator-operator berikut tidak bisa dibebani.
. .* :: ?:
sizeof
ATURAN PEMBEBANAN OPERATOR
Pembebanan operator memiliki kondisi dan persyaratan beriktu.
- Operator dapat dibebani hanya untuk tipe-tipe yang didefinisikan user (objek-objek kelas) atau campuran dari tipe-tipe yang didefinisikan user dan tipe-tipe fundamental.
- Jumlah operand yang diperlukan oleh operator tidak berubah. Jadi, jika operator + memerlukan dua operand, maka jika operator + dibebani, operator itu juga memerlukan dua operand.
- Keutamaan operator tidak bisa diubah dengan pembebanan.
- Asosiatifitas operator (dari kiri ke kanan atau dari kanan ke kiri) tidak bisa diubah dengan pembebanan.
- Tidak ada batasan dalam pendefinisian fungsionalitas (watak) dari operator yang dibebani. Namun, direkomendasikan agar operator yang dibebani seharusnya melakukan operasi yang sama pada objek-objek kelas seperti dilakukannya pada tipe-tipe fundamental. Sebagai contoh, jika operator + melakukan operasi penjumlahan pada tipe-tipe fundamental, maka sebaiknya ia juga melakukan hal yang sama pada objek-objek kelas.
4.3 Fungsi
Pembebanan Operator
Untuk membebani suatu operator, Anda perlu mendefinisikan sebuah fungsi
yang mendefinisikan ulang fungsionalitas operator yang sedang dibebani. Jadi,
fungsi pembebanan mendefinisikan apa yang akan dilakukan oleh operator dan
bagaimana operator melakukan operasinya ketika diterapkan pada objek-objek dari
kelas tertentu. Fungsi pembebanan operator merupakan fungsi tak-statis (karena
ia harus beroperasi pada argumen-argumen tak-statis). Fungsi pembebanan
dideklarasikan dengan kata pertama tipe
(tipe data yang dihasilkan) yang diikuti oleh katakunci operator yang diikuti oleh simbol operator yang ingin dibebani yang
diikuti oleh argumen-argumen di dalam kurung. Fungsi pembebanan operator dapat
dijadikan sebagai fungsi anggota kelas. Fungsi pembebanan operator dapat pula
menjadi fungsi friend dari kelas
atau menjadi fungsi global. Sebagai contoh, untuk pembebanan operator +, Anda
bisa menjadikannya sebagai suatu fungsi anggota kelas. Di dalam tubuh kelas,
fungsi pembebanan didefinisikan dengan cara berikut.
tipe operator + (argumen_argumen)
{tubuh_fungsi}
Di sini, tipe adalah tipe data
yang dihasilkan. Jika fungsi menghasilkan sebuah objek kelas, maka nama kelas
menjadi tipe. Apakah fungsi
pembebanan operator akan dijadikan fungsi anggota kelas, fungsi friend, atau
fungsi global? Baik fungsi kelas maupun fungsi friend dapat mengakses semua
anggota kelas, yaitu private, protected, dan public. Fungsi global tidak memiliki akses langsung pada anggota
private dan terproteksi dari suatu kelas, sehingga fungsi-fungsi publik lain
perlu dicantumkan untuk mengakses anggota-anggota private dan terproteksi dari
kelas. Ini melukai kapabilitas penyembunyian informasi dari kelas dan juga
menjadi beban tambahan bagi kinerja program. Oleh karena itu, fungsi pembebanan
operator sebisa mungkin dijadikan fungsi anggota kelas atau fungsi friend.
Pada program berikut, operator + dibebani untuk melakukan penjumlahan atas
dua vektor.
|
Program 4.1 Mengilustrasikan
pembebanan operator + untuk menjumlahkan dua vektor
|
|
|
|
#include <iostream>
using namespace std;
class Vektor{
private:
int
x, y, z ; //tiga komponen dari
sebuah Vektor
public:
Vektor(int a, int b, int c){x =a; y = b; z =c;}
//konstruktor
Vektor(){}; //konstruktor kosong atau
default
Vektor operator+ (const Vektor&S)
//untuk membebani operator biner +
{ //hanya satu argumen yang diperlukan
x = x +S.x;
y = y + S.y;
z = z + S.z;
return
Vektor (x,y,z);
} //fungsi pembebanan operator menjadi
fungsi anggota kelas
void
Tampil()
{
cout<<"Komponen x =
"<<x<<endl;
cout<<"Komponen y =
"<<y<<endl;
cout<<"Komponen z =
"<<z<<endl;
}
}; //akhir dari
kelas Vektor
int main()
{
Vektor V1(2, 4, 5), V2(6, 5, 8), V3;
V3 = V1 + V2;
V3.Tampil();
return
0;
}
|
|
KELUARAN
|
|
|
Perkalian1 = 20
Perkalian2 = 60
|
|
Jika pembebanan operator didefinisikan di luar kelas, maka prototipe
fungsi harus dideklarasikan di dalam tubuh kelas. Untuk kasus di atas, di dalam
tubuh kelas, Anda menuliskan prototipe fungsi berikut.
Vektor operator + (Vektor);
Definisi fungsi ditempatkan di luar kelas berikut.
Vektor Vektor :: operator+ (const Vektor&S)
{
x = x +S.x;
y = y + S.y;
z = z + S.z;
return Vektor(x,y,z);
}
Ini diilustrasikan pada program 4.2. Baris terakhir pada kode di atas
dapat pula dituliskan berikut.
return *this ;
OPERATOR + DIDEFINISIKAN UNTUK OPERASI MINUS
Pada pembebanan, fungsionalitas operator didefinisikan ulang. Jadi, adalah
memungkinkan bahwa operator + didefinisikan untuk menjalankan operator minus
(lihat program 4.2) atau perkalian atau pembagian. Hal ini merupakan praktek
yang buruk. Anda direkomendasikan fungsionalitas operator tetap dipertahankan
pada pembebanan. Karena, dalam waktu yang cukup lama, programer bisa jadi lupa
pendefinisian-ulang dari operator dan hal itu dapat menyebabkan error yang
serius pada program. Namun, untuk sekadar ilustrasi, program berikut akan
disajikan bagi Anda.
|
Program 4.2 Mengilustrasikan
pembebanan operator + untuk melakukan operasi minus
|
|
|
|
#include <iostream>
using namespace std;
class Bilangan{
private:
int
x, y ;
public:
Bilangan (int a, int b ){ x = a
; y = b;} //konstruktor
Bilangan(){}; //konstruktor default
Bilangan operator+(const
Bilangan & m); //prototipe fungsi
void
Tampil()
{
cout<<"Komponen x =
"<<x<<endl;
cout<<"Komponen y =
"<<y<<endl;
}
}; //akhir dari
kelas
Bilangan
Bilangan :: operator+ (const
Bilangan & m) //definisi fungsi
{ //di luar
kelas
x =x - m.x;
y =y - m.y;
return
Bilangan (x,y);
}
int main()
{
Bilangan N(16, 21), M(5, 6), D, E; //N, M,
D, E adalah objek
D = N + M;
D.Tampil();
int
A = 10; // A dan B adalah integer-integer tipe fundamental
int
B =5;
cout<<"A + B =
"<<A+B<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Komponen x = 11
Komponen y = 15
A + B = 15
|
|
Keluaran program menunjukkan bahwa terhadap objek-objek kelas, operator +
melakukan operasi minus, yaitu x = 16 – 5 = 11 pada baris pertama dan 21 – 6 =
15 pada baris kedua. Namun, fungsionalitas asli (penjumlahan) dari operator
untuk tipe-tipe fundamental tidak hilang akibat pembebanan. Ini ditunjukkan
pada baris ketiga keluaran dengan menjumlahkan dua integer A dan B dimana
operator + tetap melakukan penjumlahan. Program tersebut juga mengilustrasikan
bagaimana mendefinisikan fungsi pembebanan di luar kelas.
4.4 Penjumlahan
Bilangan Kompleks
Dalam aljabar, Anda menuliskan sebuah bilangan kompleks dengan x + yi. Di
sini, x adalah komponen rill, dan yi dimana i =
adalah komponen imajiner. Dimisalkan bahwa Anda ingin menjumlahkan dua
bilangan kompleks seperti (6 + 5i) + (4 + 8i). Hasil dalam aljabar adalah 10 +
13i, dimana komponen riil ditambahkan pada komponen rill dan komponen imajiner
ditambahkan dengan komponen imajiner. Operator + di dalam C++ dengan
fungsionalitas asli yang didefinisikan untuk tipe-tipe fundamental tidak dapat
melakukan penjumlahan semacam itu. Namun, C++ mengijinkan Anda untuk membebani
operator + sehingga ia dapat melakukan penjumlahan bilangan kompleks.
|
Program 4.3 Mengilustrasikan
penjumlahan dua bilangan kompleks
|
|
|
|
#include <iostream>
using namespace std;
class Bilangan
{
int
x, y; //bilangan kompleks, x + yi, private secara default
public:
Bilangan(int a, int b) {x =a ;
y = b;} // konstruktor
Bilangan(){}; //konstruktor default
Bilangan& operator+(const Bilangan
& m) //pendefinisian-ulang operator +
{
x = x + m.x;
y = y + m.y;
return*
this;
}
void
Tampil(){
cout<<"Bilangan resultan
adalah = "<<x<<" +
"<<y<<"i"<<endl;}
}; //akhir dari
kelas Bilangan
int main()
{
Bilangan N(16, 21), M(5, 6), D;
D = N + M;
D.Tampil();
return
0;
}
|
|
KELUARAN
|
|
|
Bilangan
resultan adalah = 21 + 27i
|
|
4.5 Pembebanan
Operator += dan -=
Pada program berikut, operator += dan -= akan dibebani.
|
Program 4.4 Mengilustrasikan
pembebanan operator += dan -=
|
|
|
|
#include <iostream>
using namespace std;
class Vektor
{
private:
int
x, y, z ; //tiga komponen Vektor
public:
void
set_nilai(int a, int b, int c) {x =a; y = b; z = c;}
void
operator += (Vektor P) //definisi dari fungsi pembebanan operator
{
x = x + P.x ;
y = y + P.y ;
z = z + P.z ;
}
operator -= ( Vektor P) //definisi dari
fungsi pembebanan operator
{
x = x - P.x;
y = y - P.y;
z = z - P.z;
}
void
Tampil()
{cout<<"x =
"<<x<<"\ty = "<<y<<"\tz =
"<<z<<endl;}
}; //akhir dari
kelas Vektor
int main()
{
Vektor V1, V2, V3;
V1.set_nilai(12, 4, 6);
V2.set_nilai(2, 5, 7);
V3.set_nilai(4, 5, 6);
V1 += V2;
V3 -= V2;
cout<<"Komponen-komponen dari
V1 adalah: ";
V1.Tampil() ;
cout<<"Komponen-komponen dari
V3 adalah: ";
V3.Tampil();
cout<<"Komponen-komponen dari
V2 adalah: ";
V2.Tampil();
return
0;
}
|
|
KELUARAN
|
|
|
Komponen-komponen
dari V1 adalah: x = 14 y =
9 z = 13
Komponen-komponen
dari V3 adalah: x = 2 y = 0 z = -1
Komponen-komponen
dari V2 adalah: x = 2 y = 5 z = 7
|
|
Komponen-komponen dari V1 didapatkan dengan menjumlahkan komponen-komponen
dari V2 dengan komponen-komponen dari V1 dan menugaskan hasilnya kepada
komponen-komponen dari V1. Jadi, pada keluaran program, Anda mendapatkan 14, 9,
dan 13 sebagai komponen-komponen dari V1. Pada kasus V3, komponen-komponen dari
V2 dikurangi dari komponen-komponen dari V3 dan hasilnya ditugaskan kepada
komponen-komponen dari V3. Jadi, diperoleh 2, 0, dan -1 sebagai komponen-komponen
dari V3.
4.6 Pembebanan
Operator Penyisipan (<<),Operator Ekstraksi (>>), dan Operator /=
Karena operand kiri dari operator << dan operator >> bukanlah
objek kelas, yang merupakan tujuan dari pembebanan fungsi, maka, Anda perlu
menggunakan fungsi global atau fungsi friend. Fungsi friend dapat mengakses
semua anggota kelas, jadi, pada program berikut, Anda menggunakan fungsi friend
untuk membebani operator << dan operator >>. Program juga
mengilustrasikan bagaimana membebani operator /= untuk array.
|
Program 4.5 Mengilustrasikan
pembebanan operator <<, >>, dan /=
|
|
|
|
#include <iostream.h>
const int n = 5;
class List{
friend
ostream & operator << (ostream &, List &);
friend
istream & operator >> (istream &, List &);
float
x[n] ; //private secara
default
public
:
List(){}; //konstruktor default
List(float a[n])
//konstruktor
{
for
(int i =0; i<5; i++)
x[i] = a[i];
}
float
operator /=(int m) //pembebanan
operator /=
{
for
(int i =0; i<5; i++)
x[i] = x[i]/m;
return
x[i];
}
} ; //akhir
dari kelas List
istream &
operator>> (istream &Masuk, List&L) //definisi fungsi friend
{
for
(int i = 0; i< n; i++)
Masuk >> L.x[i]; //Masuk adalah sebuah objek
dari istream
return
Masuk;
} //L
adalah sebuah objek dari List
ostream &
operator<< (ostream &Keluar, List &L) //definisi fungsi friend
{
Keluar<<"("<<L.x[0];
for
(int i = 1; i<n; i++) //Keluar adalah sebuah objek dari
ostream
Keluar<<", "<<
L.x[i];
Keluar<<")";
return
Keluar;
}
int main()
{
List L1, L2;
float B[n] ={2.2,3.3,4.4,5.5,6.6};
cout<<"Tuliskan
"<<n<<" buah elemen dari L2: ";
cin>>L2;
L1 = B ;
L1 /=2;
cout<<L1<<"\n";
L2 /=3;
cout<<L2 <<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Tuliskan 5 buah
elemen dari L2: 23.34 45.56 67.78 89.76 87.65
(1.1, 1.65,
2.2, 2.75, 3.3)
(7.78, 15.1867,
22.5933, 29.92, 29.2167)
|
|
4.7 Pembebanan
Operator Inkremen (++) dan Operator Dekremen (--)
Operator unary ++ dapat diprefiks sebelum nama variabel atau objek kelas
atau dapat dipostfiks setelah nama variabel atau objek kelas. Pada kasus
pertama, operator ini menginkremen nilai variabel atau objek kelas kemudian
nilai itu dipakai untuk evaluasi dari ekspresi berikutnya. Pada postfiks, nilai
awal dipakai untuk evaluasi ekspresi dan kemudian nilai itu diinkremen.
Operator unary – berperilaku sama dengan operasi pendekremanan nilai.
|
Program 4.6 Mengilustrasikan
pembebanan operator ++ dan --
|
|
|
|
#include <iostream>
using namespace std;
class Vektor
{
private:
int
x, y, z ; //tiga komponen Vektor
public
:
Vektor(int a, int b,int c) {x =a; y = b; z =c;}
Vektor (){}
Vektor operator ++(int) //Operator
postinkremen ++
{
x +=1;
y += 1;
z +=1;
return
Vektor((x-1), (y-1), (z-1));
}
Vektor operator ++() //Operator prainkremen ++
{
x +=1;
y += 1;
z +=1;
return
Vektor (x,y,z);
}
Vektor operator --() //Operator
pradekremen --
{
x -= 1;
y -= 1;
z -= 1;
return
Vektor (x,y,z);
}
Vektor operator --(int) //Operator postdekremen –
{
x -= 1;
y -= 1;
z -=1;
return
Vektor((x+1), (y+1), (z+1));
}
void
Tampil()
{cout<<"x =
"<<x<<", y = "<<y<<", z =
"<<z<<endl;}
}; //akhir dari
kelas B
int main()
{
Vektor V1(4, 5, 6), V2(21, 22, 23), V3(1,
2, 3), V4(11, 12, 13);
cout<<"Komponen-komponen awal
dari V1 adalah: ";
V1.Tampil();
cout<<"Setelah postinkremen,
komponen-komponen V1 adalah: ";
(V1++).Tampil();
cout<<"Sekarang
komponen-komponen V1 adalah: ";
V1.Tampil();
cout<<"Komponen-komponen awal
dari V2 adalah: ";
V2.Tampil();
cout<<"Setelah prainkremen,
komponen-komponen V2 adalah: ";
(++V2).Tampil () ;
cout<<"Komponen-komponen awal
dari V3 adalah: ";
V3.Tampil();
cout<<"Setelah postdekremen,
komponen-komponen V3 adalah: ";
(V3--).Tampil();
cout<<"Sekarang
komponen-komponen V3 adalah: " ;
V3.Tampil();
cout<<"Komponen-komponen awal
dari V4 adalah: " ;
V4.Tampil();
cout<<"Setelah pradekremen,
komponen-komponen V3 adalah: ";
(--V4).Tampil () ;
return
0;
}
|
|
KELUARAN
|
|
|
Komponen-komponen
awal dari V1 adalah: x = 4, y = 5, z = 6
Setelah
postinkremen, komponen-komponen V1 adalah: x = 4, y = 5, z = 6
Sekarang
komponen-komponen V1 adalah: x = 5, y = 6, z = 7
Komponen-komponen
awal dari V2 adalah: x = 21, y = 22, z = 23
Setelah
prainkremen, komponen-komponen V2 adalah: x = 22, y = 23, z = 24
Komponen-komponen
awal dari V3 adalah: x = 1, y = 2, z = 3
Setelah
postdekremen, komponen-komponen V3 adalah: x = 1, y = 2, z = 3
Sekarang komponen-komponen
V3 adalah: x = 0, y = 1, z = 2
Komponen-komponen
awal dari V4 adalah: x = 11, y = 12, z = 13
Setelah
pradekremen, komponen-komponen V3 adalah: x = 10, y = 11, z = 12
|
|
4.8 Perkalian
Dot atas Vektor
Dalam matematika vektor, perkalian dot melibatkan perkalian atas
komponen-komponen terkait (komponen-komponen dengan nilai indeks sama) dari dua
vektor dan menjumlahkan tiap hasil perkaliannya. Program berikut
mengilustrasikannya.
|
Program 4.7 Mengilustrasikan pembebanan operator * yang
melibatkan fungsi friend untuk melakukan operasi perkalian dot atas dua
vektor
|
|
|
|
#include <iostream>
using namespace std;
class Vektor{
private:
int
x, y, z ; //tiga komponen Vektor
public
:
Vektor(int a, int b, int c) {x =a ; y = b; z =c;}
Vektor (){};
friend
int &operator*(const Vektor &, const Vektor & ); //dua parameter
}; //akhir dari
kelas Vektor
int &
operator* (const Vektor &S, const Vektor &P) //definisi
fungsi
{
int
perkalianDalam;
perkalianDalam = S.x * P.x + S.y * P.y +
S.z *P.z;
return
perkalianDalam;
}
int main()
{
Vektor V1(3, 5, 5);
Vektor V2(10, 6, 8);
int
perkalianDot = V1 * V2;
cout<<"Perkalian dot atas V1
dan V2 = "<<perkalianDot<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Perkalian dot
atas V1 dan V2 = 100
|
|
4.9 Pembebanan
Operator Ekualitas ==
Ketika menangani kuantitas seperti vektor, bilangan kompleks, dan lainnya,
perbandingan untuk memeriksa apakah dua vektor sama melibatkan perbandingan
dari tiap komponen vektor V1 dengan komponen terkait dari vektor V2. Dua vektor
dikatakan sama jika komponen-komponen dari satu vektor sama dengan
komponen-komponen terkait dari vektor lain. Jadi, Anda perlu
mendefinisikan-ulang fungsionalitas dari operator ==. Ini diilustrasikan pada
program berikut.
|
Program 4.8 Mengilustrasikan pembebanan operator == untuk
vektor
|
|
|
|
#include <iostream>
using namespace std;
class Vektor
{
int
x, y, z ; //private secara default
public:
Vektor(){x = 3, y = 2, z =1;}
//konstruktor default
Vektor (int a, int b,int c) {x =a ; y = b; z =c;}
void
operator== (Vektor S)
{
if
( x==S.x && y == S.y && z== S.z)
cout<<"true"<<endl;
else
cout<<"false"<<endl;
}
void
Tampil()
{
cout<<"Vektor =
("<<x<<", "<<y<<"
"<<z<<")"<<endl;
}
}; //akhir dari
kelas Vektor
int main()
{
Vektor V1(2, 4, 5), V2(6, 5, 8) ,V3(6, 5,
8);
V1 == V2;
V2 == V3;
V1.Tampil();
V2.Tampil();
V3.Tampil();
return
0;
}
|
|
KELUARAN
|
|
|
false
true
Vektor = (2, 4
5)
Vektor = (6, 5
8)
Vektor = (6, 5
8)
|
|
4.10 Pembebanan
Operator Indeks []
Dalam C++, tidak ada operasi default untuk memeriksa apaka indeks atau
nilai subskrip dari suatu elemen array berada di dalam rentang yang benar atau
tidak. Jika indeks lebih besar dari jumlah elemen di dalam array, maka program
akan berhenti karena error. Program berikut memeriksa hal ini dengan membebani
operator indeks [].
|
Program 4.9 Mengilustrasikan pembebanan operator indeks
[]
|
|
|
|
#include <iostream.h>
#include <cstdlib>
const int n = 5;
class List
{
friend
ostream & operator << (ostream & , List &);
int
x[n] ; //private secara default
public
:
void
set_nilai(int a[n])
{
for
(int j = 0; j< n; j++)
x[j] = a[j];
}
int
operator [](int k)
{
if
(k <0 || k > n)
{
cout<<"Indeks array k
di luar rentang"<<endl;
exit(0);
}
return
x[k];
}
}; //akhir dari
kelas List
ostream &
operator<< (ostream &Taruh , List &L)
{
Taruh<<"Komponen-komponen
adalah: ("<<L.x[0];
for
(int i = 1; i<n; i++)
Taruh<<", "<<
L.x[i] ;
Taruh<<")";
return (Taruh);
}
int main()
{
List L1;
int
B1[] = {11, 12, 13, 14, 15};
L1.set_nilai(B1);
cout<<L1<<endl;
cout<<L1[2]<<endl;
cout<<"Hasil berikut adalah
untuk L1[7]: "<<endl;
cout<<L1[7]<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
false
true
Vektor = (2, 4
5)
Vektor = (6, 5
8)
Vektor = (6, 5
8)
|
|
LATIHAN
1.
Apa itu pembebanan operator?
2.
Untuk apa pembebanan operator?
3.
Operator-operator apa yang tidak bisa
dibebani?
4.
Bagaimana Anda mendefinisikan sebuah
fungsi pembebanan operator?
5.
Bagaimana Anda memutuskan apakah fungsi
pembebanan dijadikan fungsi anggota kelas, fungsi friend, atau fungsi global?
6.
Berapa banyak argumen yang diperlukan
fungsi kelas untuk membebani operator-operator berikut:
a.
+ (biner)
b.
– (unary)
c.
+=
d.
==
7.
Apa jenis
fungsi (kelas, friend, atau global) yang bisa dipakai untuk membebani
operator-operator berikut?
a.
Operator +
b.
Operator
>>
c.
Operator +=
d.
Operator ++
atau --
8.
Berapa banyak argumen yang diperlukan
fungsi kelas untuk membebani operator-operator berikut:
a.
Operator
<<
b.
Operator ++
c.
Operator *=
d.
Operator ==
9.
Dapatkan
pembebanan operator dipakai untuk variabel dengan tipe data fundamental?
10.
Manakah
operator-operator yang bisa dibebani?
a.
==
b.
.
c.
::
d.
.*
e.
/=
11.
Apakah
kondisi-kondisi (atau batasan-batasan) pada operator-operator yang dibebani?
12.
Apa jenis
fungsi (kelas, friend, atau global) yang bisa dipakai untuk membebani
operator-operator berikut?
a.
<<
b.
[]
c.
>>
d.
->
e.
/=
f.
==
13.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator << dan >>.
14.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator * untuk perkalian atas dua
bilangan kompleks.
15.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator + untuk penjumlahan dua string.
16.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator new dan delete.
17.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator new[] dan delete[].
18.
Tulislah sebuah
program untuk mengilustrasikan pembebanan operator || (OR) dan && (AND).
19.
Tulislah sebuah
program untuk mengilustrasikan perkalian dalam atas dua vektor dengan
masing-masing vektor memiliki 10 komponen.
Jawaban:
|
Program 4.9 Mengilustrasikan pembebanan operator indeks
[]
|
|
|
|
#include <iostream>
using namespace std;
const n =10;
class Vektor
{
int
x[n]; // n buah komponen Vektor atau array
public:
Vektor(int A[n])
{
for
(int i = 0; i < n; i++)
x[i] = A[i];
}
Vektor(){};
friend
int operator* (Vektor P, Vektor
S);
}P, S; //akhir
dari kelas Vektor
int operator*
(Vektor P, Vektor S)
{
int
IP = 0;
for
(int j =0; j< n; j++)
IP = IP + P.x[j] * S.x[j];
return
IP;
}
int main()
{
int
C1[] = {4, 3, 2, 3, 2, 5, 3, 1, 2, 3};
int
C2[] = {4, 2, 1, 3, 2, 1, 3, 1, 4, 2};
Vektor V1(C1);
Vektor V2(C2);
int
perkalianDot = V1 * V2;
cout<<"Perkalian dot atas V1
dan V2 = "<<perkalianDot<<endl;
return
0;
}
|
|
KELUARAN
|
|
|
Perkalian dot
atas V1 dan V2 = 66
|
|
No comments:
Post a Comment