8. Mengoverload Operator
Dasar
Pengoverloadan Operator
Pengoverloadan
operator sangat berkaitan erat dengan pengoverloadan metode. Untuk mengoverload
sebuah operator digunakan katakunci operator
untuk mendefinisikan sebuah metode operator, yang mendefinisikan aksi dari
operator terhadap kelasnya.
Ada dua format
metode operator: satu untuk operator
unary dan satu untuk operator biner. Bentuk umum setiap format ditunjukkan di
sini:
// Bentuk umum untuk pengoverloadan operator unary
public
static tipe-nilaibalik operator op(tipe-param
operand)
{
//
operasi-operasi
}
// Bentuk umum untuk pengoverloadan operator biner
public
static tipe-nilaibalik operator op(tipe-param1
operand1, tipe-param2 operand2)
{
//
operasi-operasi
}
Di sini,
operator yang Anda overload, seperti + atau /, menggantikan op. tipe-nilaibalik menspesifikasi
tipe dari nilai balik yang dihasilkan operasi yang dispesifikasi. Meskipun bisa
bertipe sembarang, nilai balik seringkali sama dengan tipe kelas dari operator
yang sedang dioverload. Untuk operator unary, operand dilewatkan di dalam operand. Untuk operator
biner, kedua operand dilewatkan di dalam operand1 dan operand2. Perhatikan
bahwa metode operator harus
dideklarasikan public dan static.
Untuk operator
unary, operand harus bertipe sama dengan kelas operator yang sedang
didefinisikan. Untuk operator biner, sedikitnya salah satu operand harus
bertipe sama dengan kelasnya. Jadi, Anda tidak bisa mendefinisikan-ulang + untuk int atau string.
Satu hal penting
yang lain: Parameter operator tidak bisa menggunakan pemodifikasi ref atau out.
Mengoverload
Operator Biner
Untuk melihat
bagaimana pengoverloadan operator bekerja, akan disajikan sebuah contoh yang
mengoverload dua operator biner, + dan –. Program berikut menciptakan sebuah
kelas, yang bernama TigaD, yang
menetapkan koordinat sebuah objek dalam ruang tiga dimensi. Operator + teroverload menambahkan koordinat
satu Objek TigaD kepada objek TigaD lainnya. Operator – teroverload
mengurangi koordinat satu objek dari objek lainnya.
// Sebuah contoh untuk mengoverload operator.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3-D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Mengoverload
operator +.
public static TigaD operator +(TigaD op1, TigaD op2)
{
TigaD hasil = new TigaD();
/* Ini menambahkan
koordinat dari dua titik
dan menghasilkan
hasil. */
hasil.x = op1.x +
op2.x; // Penjumlahan integer
hasil.y = op1.y +
op2.y;
hasil.z = op1.z +
op2.z;
return hasil;
}
// Overload binary -.
public static TigaD operator -(TigaD op1, TigaD op2)
{
TigaD hasil = new TigaD();
/* Perhatikan
urutan operand. op1 adalah operand kiri
dan op2 adalah
operand kanan. */
hasil.x = op1.x -
op2.x; // Pengurangan integer
hasil.y = op1.y -
op2.y;
hasil.z = op1.z -
op2.z;
return hasil;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD {
static void Main() {
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c;
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menambahkan a dan b
Console.Write("Berikut adalah a + b: ");
c.Tampil();
Console.WriteLine();
c = a + b + c;
// menambahkan a, b, dan c
Console.Write("Hasil dari a + b + c: ");
c.Tampil();
Console.WriteLine();
c = c - a; //
mengurangi a
Console.Write("Hasil dari c - a: ");
c.Tampil();
Console.WriteLine();
c = c - b; //
mengurangi b
Console.Write("Hasil dari c - b: ");
c.Tampil();
Console.WriteLine();
}
}
Program ini
menghasilkan keluaran:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Berikut adalah a + b: 11, 12, 13
Hasil dari a + b + c: 22, 24, 26
Hasil dari c - a: 21, 22, 23
Hasil dari c - b: 11, 12, 13
Akan
didiskusikan program tersebut secara hati-hati, dimulai dengan operator
teroverload +. Ketika dua objek bertipe TigaD
dioperasikan oleh operator +, magnitudo dari tiap koordinat dijumlahkan,
seperti ditunjukkan di dalam operator+().
Perhatikan bahwa metode ini tidak memodifikasi nilai kedua operandnya. Sebuah
objek baru bertipe TigaD diciptakan,
yang memuat hasil operasi, dan dijadikan nilai balik. Untuk memahami mengapa
operasi + tidak mengubah isi dari operandnya, hal karena mengikuti operasi +
aritmatika yang diterapkan seperti ini: 10 + 12. Kelauaran dari operasi ini
adalah 22, dan baik 10 maupun 12 tidak berubah akibat operasi penjumlahan ini.
Meskipun tidak ada aturan yang melarang sebuah operator teroverload untuk
mengubah nilai dari operandnya, adalah hal terbaik untuk konsisten dengan makna
aslinya (pada kasus ini sesuai dengan makna aritmatika penjumlahan).
Perhatikan bahwa
operator+() menghasilkan nilai balik
berupa sebuah objek bertipe TigaD.
Meskipun metode tersebut bisa saja menghasilkan nilai balik bertipe apa saja
yang valid dalam C#, fakta bahwa ia mengembalikan sebuah objek bertipe TigaD membuat ekspresi gabungan,
seperti a + b + c, dapat dilakukan.
Di sini, a + b menghasilkan nilai
balik bertipe TigaD. Nilai ini
kemudian ditambahkan kepada c. Jika
ekspresi a + b tidak menghasilkan
nilai balik bertipe TigaD, maka
ekspresi gabungan tersebut tidak bisa dilakukan.
Di sini adalah
satu hal penting yang lain: Ketika koordinat dijumlahkan di dalam operator+(), hasil penjumlahan tersebut
dilakukan dalam penjumlahan integer. Ini karena koordinat individual x, y,
dan z adalah kuantitas integer.
Sekarang, akan
didiskusikan mengenai operator–(). Operator – bekerja seperti operator
+ kecuali bahwa pada operator ini urutan parameter menjadi penting. Ingat bahwa
penjumlahan bersifat komutatif, sedangkan pengurangan tidak. (Yaitu, A – B tidak sama dengan B – A). Untuk semua operator biner,
parameter pertama selalu merupakan operator kiri. Parameter kedua merupakan
operator kanan. Ketika mengimplementasikan versi teroverload dari operator
tak-kumulatif, Anda harus mengingat operand mana yang merupakan operand kiri
dan mana yang operand kanan.
Mengoverload
Operator Unary
Operator unary
dioverload sama seperti operator biner. Perbedaan utamanya adalah bahwa
operator unary hanya mempunyai satu operand. Sebagai contoh, berikut merupakan
sebuah metode yang mengoverload operator minus untuk kelas TigaD:
// Mengoverload unary -.
public
static TigaD operator -(TigaD op)
{
TigaD hasil = new TigaD();
hasil.x = -op.x;
hasil.y = -op.y;
hasil.z = -op.z;
return hasil;
}
Di sini, sebuah
objek baru diciptakan yang memuat bidang ternegasi dari operand. Objek ini
kemudian dijadikan nilai balik. Perhatikan bahwa operand tetap tidak berubah.
Hal ini untuk menjadi konsistensi makna dengan operasi minus unary. Sebagai
contoh, di dalam sebuah ekspresi seperti ini:
a = -b
a menerima negasi dari b,
tetapi b tetap tidak berubah.
Dalam C#,
mengoverload ++ dan -- cukup mudah; Anda hanya cukup
menjadikan nilai terinkremen atau terdekremen sebagai nilai balik, tetapi Anda
tidak perlu mengubah objek pemanggil. Sebagai contoh, berikut adalah metode operator++() untuk kelas TigaD():
// Mengoverload unary ++.
public
static TigaD operator ++(TigaD op)
{
TigaD hasil = new TigaD();
// Menghasilkan
hasil terinkremen.
hasil.x = op.x +
1;
hasil.y = op.y +
1;
hasil.z = op.z +
1;
return hasil;
}
Berikut adalah
versi terekspansi atas program sebelumnya yang mendemonstrasikan operator unary
– dan ++.
// Pengoverloadan operator lanjut.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // kooerdinat 3-D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Mengoverload biner
+.
public static TigaD operator +(TigaD op1, TigaD op2)
{
TigaD hasil = new TigaD();
/* Ini menjumlahkan
koordinat dari dua titik
dan memberikan
nilai balik hasil. */
hasil.x = op1.x +
op2.x;
hasil.y = op1.y +
op2.y;
hasil.z = op1.z +
op2.z;
return hasil;
}
// Mengoverload biner
-.
public static TigaD operator -(TigaD op1, TigaD op2) {
TigaD hasil = new TigaD();
/* Perhatikan
urutan operand. op1 adalah operand kiri
dan op2 adalah
operand kanan. */
hasil.x = op1.x -
op2.x;
hasil.y = op1.y -
op2.y;
hasil.z = op1.z -
op2.z;
return hasil;
}
// Mengoverload unary
-.
public static TigaD operator -(TigaD op)
{
TigaD hasil = new TigaD();
hasil.x = -op.x;
hasil.y = -op.y;
hasil.z = -op.z;
return hasil;
}
// Mengoverload unary
++.
public static TigaD operator ++(TigaD op)
{
TigaD hasil = new TigaD();
// Menghasilkan
hasil terinkremen.
hasil.x = op.x + 1;
hasil.y = op.y + 1;
hasil.z = op.z + 1;
return hasil;
}
// Menampilkan
koordinar X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD {
static void Main() {
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD();
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menjumlahkan a dan b
Console.Write("Hasil dari a + b: ");
c.Tampil();
Console.WriteLine();
c = a + b + c; //
menjumlahkan a, b, dan c
Console.Write("Hasil dari a + b + c: ");
c.Tampil();
Console.WriteLine();
c = c - a; //
mengurangi a
Console.Write("Hasil dari c - a: ");
c.Tampil();
Console.WriteLine();
c = c - b; //
mengurangi b
Console.Write("Hasil dari c - b: ");
c.Tampil();
Console.WriteLine();
c = -a; //
Menugaskan -a kepada c
Console.Write("Hasil dari -a: ");
c.Tampil();
Console.WriteLine();
c = a++; //
post-inkreman a
Console.WriteLine("Diberikan c = a++");
Console.Write("c adalah ");
c.Tampil();
Console.Write("a adalah ");
a.Tampil();
// Mereset a
menjadi 1, 2, 3
a = new TigaD(1, 2, 3);
Console.Write("\nMereset a dengan ");
a.Tampil();
c = ++a; //
pre-inkremen a
Console.WriteLine("\nDiberikan c = ++a");
Console.Write("c adalah ");
c.Tampil();
Console.Write("a adalah ");
a.Tampil();
}
}
Berikut adalah
keluaran program:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Hasil dari a + b: 11, 12, 13
Hasil dari a + b + c: 22, 24, 26
Hasil dari c - a: 21, 22, 23
Hasil dari c - b: 11, 12, 13
Hasil dari -a: -1, -2, -3
Diberikan c = a++
c adalah 1, 2, 3
a adalah 2, 3, 4
Mereset a dengan 1, 2, 3
Diberikan c = ++a
c adalah 2, 3, 4
a adalah 2, 3, 4
Menangani
Operasi Pada Tipe Built-in C#
Untuk sembarang
kelas dan operator, sebuah metode operator sendiri dapat dioverload. Salah satu
alasannya adalah mengijinkan operasi antara tipe kelas dan tipe data lain,
seperti tipe built-in. Sebagai contoh, sekali perhatikan kelas TigaD. Sampai sejauh ini, Anda telah
melihat bagaimana mengoverload + sehingga ia dapat menjumlahkan koordinat satu
objek TigaD dengan koordinat objek TigaD lain. Namun, hal itu bukan
satu-satunya cara Anda bisa mendefinisikan penjumlahan untuk TigaD. Misalnya, ada gunanya untuk
menambah sebuah nilai integer kepada tiap koordinat dari sebuah objek TigaD. Operasi semacam itu dapat
dipakai menggeser sumbu. Untuk melakukan operasi semacam itu, Anda perlu
mengoverload + untuk kedua kalinya, seperti ditunjukkan di sini:
// Mengoverload biner + untuk TigaD + int.
public
static TigaD operator +(TigaD op1, int op2)
{
TigaD result = new TigaD ();
hasil.x = op1.x +
op2;
hasil.y = op1.y +
op2;
hasil.z = op1.z +
op2;
return hasil;
}
Perhatikan bahwa
parameter kedua bertipe int. Jadi,
metode tersebut mengijinkan sebuah nilai integer ditambahkan ke tiap bidang
dari objek TigaD. Hal ini dibolehkan
karena, seperti dijelaskan sebelumnya, ketika mengoverload operator biner,
salah satu operand harus bertipe kelas yang sedang dioverload. Namun, operand
yang lain bisa bertipe sembarang.
Berikut adalah
sebuah versi TigaD yang mempunyai
dua metode + teroverload:
// Mengoverload penjumlahan untuk TigaD + TigaD dan untuk
TigaD + int
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD
{
int x, y, z; // koordinat 3-D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Mengoverload
operator +.
public static TigaD operator +(TigaD
op1, TigaD op2)
{
TigaD hasil = new TigaD();
/* Ini
menambahkan koordinat dari dua titik
dan
menghasilkan hasil. */
hasil.x = op1.x
+ op2.x; // Penjumlahan integer
hasil.y = op1.y
+ op2.y;
hasil.z = op1.z
+ op2.z;
return hasil;
}
// Mengoverload
biner + untuk objek + int.
public static TigaD operator +(TigaD
op1, int op2)
{
TigaD hasil = new TigaD();
hasil.x = op1.x
+ op2;
hasil.y = op1.y
+ op2;
hasil.z = op1.z
+ op2;
return hasil;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD
{
static void Main()
{
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD();
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menambahkan TigaD + TigaD
Console.Write("Berikut adalah a + b: ");
c.Tampil();
Console.WriteLine();
c = b + 10; //
TigaD + int
Console.Write("Hasil dari b + 10: ");
c.Tampil();
}
}
Hasil keluaran
program ditampilkan di sini:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Berikut adalah a + b: 11, 12, 13
Hasil dari b + 10: 20, 20, 20
Seperti yang
ditegaskan oleh keluaran, ketika + diterapkan pada dua objek TigaD, koordinatnya dijumlahkan
bersama. Ketika + diterapkan pada sebuah objek TigaD dan sebuah integer, koordinatnya dinaikkan sebesar nilai
integer.
Pengoverloadan +
yang barus saja ditunjukkan, tentu saja, menambah kapabilitas pada kelas TigaD. Tetapi, pekerjaan sebenarnya
belum selesai. Mengapa? karena operator+(TigaD, int) hanya membolehkan statemen
semacam ini:
ob1 = ob2 + 10;
tetapi operator
itu, sayangnya, tidak mengijinkan statemen seperti ini:
ob1 = 10 + ob2;
Alasannya adalah
bahwa argumen integer adalah argumen kedua, yang merupakan operand sisi-kanan,
tetapi statemen tersebut menempatkan argumen integer di kiri. Untuk membolehkan
kedua format statemen tersebut, Anda perli mengoverload + untuk ketiga kalinya.
Versi ini harus mempunyai parameter pertamanya bertipe int dan parameter keduanya bertipe TigaD. Satu versi dari metode operator+()
akan menangani TigaD + int, dan
versi lainnya akan menangani int + TigaD.
Berikut merupakan sebuah versi TigaD
yang mengoverload operator + seperti yang dideskripsikan:
// Mengoverload penjumlahan untuk TigaD + TigaD dan untuk
TigaD + int
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD
{
int x, y, z; // koordinat 3-D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Mengoverload
operator +.
public static TigaD operator +(TigaD
op1, TigaD op2)
{
TigaD hasil = new TigaD();
/* Ini
menambahkan koordinat dari dua titik
dan
menghasilkan hasil. */
hasil.x = op1.x
+ op2.x; // Penjumlahan integer
hasil.y = op1.y
+ op2.y;
hasil.z = op1.z
+ op2.z;
return hasil;
}
// Mengoverload
biner + untuk objek + int.
public
static TigaD operator +(TigaD op1, int
op2)
{
TigaD hasil = new TigaD();
hasil.x = op1.x
+ op2;
hasil.y = op1.y
+ op2;
hasil.z = op1.z
+ op2;
return hasil;
}
// Mengoverload
biner + untuk int + TigaD.
public static TigaD operator +(int
op1, TigaD op2)
{
TigaD hasil = new TigaD();
hasil.x = op2.x
+ op1;
hasil.y = op2.y
+ op1;
hasil.z = op2.z
+ op1;
return hasil;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD
{
static void Main()
{
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD();
Console.Write("Berikut
adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menambahkan TigaD + TigaD
Console.Write("Berikut adalah a + b: ");
c.Tampil();
Console.WriteLine();
c = b + 10; //
TigaD + int
Console.Write("Hasil dari b + 10: ");
c.Tampil();
c = 15 + b; // int + TigaD
Console.Write("Hasil dari 15 + b: ");
c.Tampil();
}
}
Keluaran program
ditunjukkan di sini:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Berikut adalah a + b: 11, 12, 13
Hasil dari b + 10: 20, 20, 20
Hasil dari 15 + b: 25, 25, 25
Mengoverload
Operator Relasional
Operator
relasional, seperti == atau <, dapat pula dioverload dan prosesnya cukup
sederhana. Biasanya, operator relasional teroverload menghasilkan nilai balik true atau false. Hal ini untuk menjaga konsistensi makna dari operator asli.
Berikut adalah
versi dari kelas TigaD yang
mengoverload operator < dan >. Pada contoh ini, kedua operator
membandingkan objek TigaD
berdasarkan jaraknya dari titik awal. Suatu objek lebih besar dari objek lain
jika jaraknya dari titik awal lebih besar. Suatu objek lebih kecil dari objek
lain jika jaraknya dari titik awal lebih kecil. Jika diberikan dua titik, maka
implementasi semacam itu dapat dipakai untuk menentukan titik mana yang terletak
lebih jauh atau lebih dekat dari titik awal.
// Mengoverload < dan >.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload <.
public static bool operator <(TigaD op1, TigaD op2)
{
if(Math.Sqrt(op1.x * op1.x + op1.y *
op1.y + op1.z * op1.z) <
Math.Sqrt(op2.x
* op2.x + op2.y * op2.y + op2.z * op2.z))
return true;
else
return false;
}
// Overload >.
public static bool
operator >(TigaD op1, TigaD op2)
{
if(Math.Sqrt(op1.x * op1.x + op1.y *
op1.y + op1.z * op1.z) >
Math.Sqrt(op2.x
* op2.x + op2.y * op2.y + op2.z * op2.z))
return true;
else
return false;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD {
static void Main() {
TigaD a = new TigaD(5, 6, 7);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD(1, 2, 3);
TigaD d = new TigaD(6, 7, 5);
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.Write("Berikut adalah c: ");
c.Tampil();
Console.Write("Berikut adalah d: ");
d.Tampil();
Console.WriteLine();
if (a > c) Console.WriteLine("a
> c adalah true");
if (a < c) Console.WriteLine("a
< c adalah true");
if (a > b) Console.WriteLine("a
> b adalah true");
if (a < b) Console.WriteLine("a
< b adalah true");
if (a > d) Console.WriteLine("a
> d adalah true");
else if (a < d) Console.WriteLine("a
< d adalah true");
else Console.WriteLine("a
dan d berjarak sama dari titik awal");
}
}
Keluaran program
ditampilkan di sini:
Berikut adalah a: 5, 6, 7
Berikut adalah b: 10, 10, 10
Berikut adalah c: 1, 2, 3
Berikut adalah d: 6, 7, 5
a > c adalah true
a < b adalah true
a dan d berjarak sama dari titik awal
Ada satu batasan
terhadap pengoverloadan operator relasional: Anda harus mengoverloadnya secara
berpasangan. Sebagai contoh, jika Anda mengoverload <, maka Anda juga harus
mengoverload >, dan sebaliknya. Semua pasangan operator relasional adalah
|
==
|
!=
|
|
<
|
>
|
|
<=
|
>=
|
Satu hal penting
lainnya: Jika Anda mengoverload == dan !=, maka Anda biasanya harus
mengoverride Object.Equals() dan Object.GetHashCode(). Hal ini akan
didiskusikan pada Bab 10.
Mengoverload
true dan false
Katakunci true dan false dapat pula dipakai sebagai operator unary untuk kepentingan
overload. Versi teroverload dari kedua operator ini menentukan kondisi true dan false relatif terhadap kelas yang Anda ciptakan. Begitu true dan false dioverload untuk sebuah kelas, Anda dapat memakai objek dari
kelas tersebut untuk mengendalikan statemen if, while, for, dan do-while atau di dalam eksspresi ?.
Operator true dan false harus dioverload berpasangan. Anda tidak bisa hanya
mengoverload salah satunya. Keduanya merupakan operator unary dan mempunyai
bentuk umum ini:
public
static bool operator true(tipe-param operand)
{
// return true atau false
}
public
static bool operator false(tipe-param operand)
{
// return true
atau false
}
Perhatikan bahwa
setiap operator menghasilkan nilai balik bertipe bool.
Program berikut
menunjukkan bagaimana true dan false diimplementasikan untuk kelas TigaD. Masing-masing mengasumsikan baha
objek TigaD bernilai true jika sedikitnya satu koordinat
bernilai tak-nol. Jika ketiga koordinat bernilai nol, maka objek bernilai false. Operator dekremen juga
diimplementasikan untuk ilustrasi.
// Mengoverload true dan false untuk TigaD.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload true.
public static bool operator true(TigaD op) {
if((op.x != 0) || (op.y != 0) || (op.z
!= 0))
return true; // sedikitnya satu
koordinat bernilai tak-nol
else
return false;
}
// Overload false.
public static bool operator false(TigaD op) {
if((op.x == 0) && (op.y == 0)
&& (op.z == 0))
return true; // semua koordinat
bernilai nol
else
return false;
}
// Overload unary --.
public static TigaD operator --(TigaD op)
{
TigaD hasil = new TigaD();
// Menghasilkan
hasil terdekremen.
hasil.x = op.x - 1;
hasil.y = op.y - 1;
hasil.z = op.z - 1;
return hasil;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTrueFalse
{
static void Main()
{
TigaD a = new TigaD(5, 6, 7);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD(0, 0, 0);
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.Write("Berikut adalah c: ");
c.Tampil();
Console.WriteLine();
if (a) Console.WriteLine("a
adalah true.");
else Console.WriteLine("a
adalah false.");
if (b) Console.WriteLine("b
adalah true.");
else Console.WriteLine("b
adalah false.");
if (c) Console.WriteLine("c
adalah true.");
else Console.WriteLine("c
adalah false.");
Console.WriteLine();
Console.WriteLine("Mengendalikan sebuah loop menggunakan objek
TigaD.");
do
{
b.Tampil();
b--;
} while (b);
}
}
Keluaran program
ditampilkan di sini:
Berikut adalah a: 5, 6, 7
Berikut adalah b: 10, 10, 10
Berikut adalah c: 0, 0, 0
a adalah true.
b adalah true.
c adalah false.
Mengendalikan sebuah loop menggunakan objek TigaD.
10, 10, 10
9, 9, 9
8, 8, 8
7, 7, 7
6, 6, 6
5, 5, 5
4, 4, 4
3, 3, 3
2, 2, 2
1, 1, 1
Perhatikan
bagaimana objek TigaD dipakai untuk
mengendalikan statemen if dan loop do-while. Pada kasus statemen if, objek TigaD dievaluasi menggunakan true.
Jika hasil dari operasi ini bernilai true,
maka tubuh statemeen if akan dieksekusi. Pada kasus loop do-while, setiap iterasi loop mendekremen b. Loop berulang sepanjang hasil evaluasi terhadap b bernilai true. Ketika b memuat
semua koordinat nol, hasil evaluasinya bernilai false ketika operator true
diterapkan dan loop akan berhenti.
Mengoverload
Operator Logikal
Seperti Anda
ketahui, C# mendefinisikan beberapa operator logikal berikut: &, |, !, &&, dan ||. Dari
semua operator tersebut, hanya &, |, dan ! yang
bisa dioverload. Dengan mengikuti beberapa aturan tertentu, keuntungan dari
hubung-singkat && dan || masih bisa
diperoleh. Setiap situasi ini akan dibahas.
Pendekatan
Sederhana Untuk Mengoverload Operator Logikal
Akan dimulai
dengan kasus paling sederhana. Jika Anda tidak memanfaatkan operator logikal
hubung-singkat, maka Anda bisa mengoverload & dan |, yang
masing-masing menghasilkan nilai balik bool.
Operator | teroverload akan menghasilkan nilai balik bertipe bool.
Berikut adalah
sebuah contoh yang mengoverload operator logikal !, |, dan & untuk objek bertipe TigaD.
Seperti sebelumnya, masing-masing mengasumsikan bahwa objek TigaD bernilai true jika sedikitnya satu koordinat bernilai tak-nol. Jika semua
koordinat bernilai nol, maka objek bernilai false.
// Cara sederhana untuk mengoverload !, |, dan & untuk
TigaD.
using System;
// kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload |.
public static bool operator |(TigaD op1, TigaD op2)
{
if( ((op1.x != 0) || (op1.y != 0) ||
(op1.z != 0)) |
((op2.x != 0) ||
(op2.y != 0) || (op2.z != 0)) )
return true;
else
return false;
}
// Overload &.
public static bool operator &(TigaD op1, TigaD op2)
{
if (((op1.x != 0) && (op1.y !=
0) && (op1.z != 0)) &
((op2.x != 0)
&& (op2.y != 0) && (op2.z != 0)))
return true;
else
return false;
}
// Overload !.
public static bool operator !(TigaD op)
{
if ((op.x != 0) || (op.y != 0) || (op.z
!= 0))
return false;
else return true;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoOpLogikal
{
static void Main()
{
TigaD a = new TigaD(5, 6, 7);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD(0, 0, 0);
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.Write("Berikut adalah c: ");
c.Tampil();
Console.WriteLine();
if (!a) Console.WriteLine("a bernilai false.");
if (!b) Console.WriteLine("b bernilai false.");
if (!c) Console.WriteLine("c bernilai false.");
Console.WriteLine();
if (a & b) Console.WriteLine("a
& b bernilai true.");
else Console.WriteLine("a
& b bernilai false.");
if (a & c) Console.WriteLine("a
& c bernilai true.");
else Console.WriteLine("a
& c bernilai false.");
if (a | b) Console.WriteLine("a |
b bernilai true.");
else Console.WriteLine("a | b bernilai false.");
if (a | c) Console.WriteLine("a |
c bernilai true.");
else Console.WriteLine("a | c bernilai false.");
}
}
Berikut adalah
keluaran program:
Berikut adalah a: 5, 6, 7
Berikut adalah b: 10, 10, 10
Berikut adalah c: 0, 0, 0
c bernilai false.
a & b bernilai true.
a & c bernilai false.
a | b bernilai true.
a | c bernilai true.
Memberdayakan
Operator Hubung-Singkat
Untuk
memanfaatkan operator hubung-singkat && dan ||, Anda
harus mematuhi empat aturan. Pertama, kelas harus mengoverload & dan |. Kedua, tipe nilai balik dari metode & dan | teroverload harus sama dengan tipe kelas yang sedang
dioverload. Ketiga, setiap parameter harus berupa referensi yang menunjuk ke
sebuh objek kelas yang sedang dioverload. Keempat, operator true dan false juga harus dioverload untuk kelas tersebut. Ketika semua
kondisi telah terpenuhi, operator hubung-singkat secara otomatis bisa
digunakan.
Program berikut
menunjukkan bagaiman mengimplementasikan & dan | untuk
kelas TigaD sehingga operator hubung-singkat || dan && dapat dimanfaatkan.
/* Cara lebih baik untuk mengoverload !, |, dan & untuk
TigaD.
Versi ini secara
otomatis memanfaatkan operator
&& dan ||. */
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload | untuk
evaluasi hubung-singkat.
public static TigaD operator |(TigaD op1, TigaD op2)
{
if( ((op1.x != 0) || (op1.y != 0) ||
(op1.z != 0)) |
((op2.x != 0)
|| (op2.y != 0) || (op2.z != 0)) )
return new TigaD(1, 1, 1);
else
return new TigaD(0, 0, 0);
}
// Overload &
untuk evaluasi hubung-singkat.
public static TigaD operator &(TigaD op1, TigaD op2)
{
if( ((op1.x != 0) && (op1.y !=
0) && (op1.z != 0)) &
((op2.x != 0)
&& (op2.y != 0) && (op2.z != 0)) )
return new TigaD(1, 1, 1);
else
return new TigaD(0, 0, 0);
}
// Overload !.
public static bool operator !(TigaD op)
{
if(op) return false;
else return true;
}
// Overload true.
public static bool operator true(TigaD op) {
if((op.x != 0) || (op.y != 0) || (op.z
!= 0))
return true; // sedikitnya satu
koordinat bernilai tak-nol
else
return false;
}
// Overload false.
public static bool operator false(TigaD op) {
if((op.x == 0) && (op.y == 0)
&& (op.z == 0))
return true; // semua koordinat
bernilai nol
else
return false;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoOpLogikal {
static void Main() {
TigaD a = new TigaD(5, 6, 7);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD(0, 0, 0);
Console.Write("Here is a: ");
a.Tampil();
Console.Write("Here is b: ");
b.Tampil();
Console.Write("Here is c: ");
c.Tampil();
Console.WriteLine();
if (a) Console.WriteLine("a
bernilai true.");
if (b) Console.WriteLine("b
bernilai true.");
if (c) Console.WriteLine("c
bernilai true.");
if (!a) Console.WriteLine("a bernilai false.");
if (!b) Console.WriteLine("b bernilai false.");
if (!c) Console.WriteLine("c bernilai false.");
Console.WriteLine();
Console.WriteLine("Menggunakan & dan |");
if (a & b) Console.WriteLine("a
& b bernilai true.");
else Console.WriteLine("a
& b bernilai false.");
if (a & c) Console.WriteLine("a
& c bernilai true.");
else Console.WriteLine("a & c bernilai false.");
if (a | b) Console.WriteLine("a |
b bernilai true.");
else Console.WriteLine("a |
b bernilai false.");
if (a | c) Console.WriteLine("a |
c bernilai true.");
else Console.WriteLine("a |
c bernilai false.");
Console.WriteLine();
// Sekarang,
menggunakan operator hubung-singkat.
Console.WriteLine("Menggunakan op hubung-singkat &&
dan ||");
if (a && b) Console.WriteLine("a && b bernilai true.");
else Console.WriteLine("a
&& b bernilai false.");
if (a && c) Console.WriteLine("a && c bernilai true.");
else Console.WriteLine("a
&& c bernilai false.");
if (a || b) Console.WriteLine("a ||
b bernilai true.");
else Console.WriteLine("a ||
b bernilai false.");
if (a || c) Console.WriteLine("a ||
c bernilai true.");
else Console.WriteLine("a ||
c bernilai false.");
}
}
Keluaran program
adalah sebagai berikut:
Here is a: 5, 6, 7
Here is b: 10, 10, 10
Here is c: 0, 0, 0
a bernilai true.
b bernilai true.
c bernilai false.
Menggunakan & dan |
a & b bernilai true.
a & c bernilai false.
a | b bernilai true.
a | c bernilai true.
Menggunakan op hubung-singkat && dan ||
a && b bernilai true.
a && c bernilai false.
a || b bernilai true.
a || c bernilai true.
Akan
didiskusikan secara lebih detil bagaimana & dan |
diimplementasikan, yang ditunjukkan di sini:
// Overload | untuk evaluasi hubung-singkat.
public
static TigaD operator |(TigaD op1, TigaD op2)
{
if(
((op1.x != 0) || (op1.y != 0) || (op1.z != 0)) |
((op2.x != 0) || (op2.y != 0) || (op2.z
!= 0)) )
return
new TigaD(1, 1, 1);
else
return
new TigaD(0, 0, 0);
}
// Overload & untuk evaluasi
hubung-singkat.
public
static TigaD operator &(TigaD op1, TigaD op2)
{
if(
((op1.x != 0) && (op1.y != 0) && (op1.z != 0)) &
((op2.x != 0) && (op2.y != 0)
&& (op2.z != 0)) )
return
new TigaD(1, 1, 1);
else
return
new TigaD(0, 0, 0);
}
Perhatikan bahwa
keduanya menghasilkan nilai balik sebuah objek bertipe TigaD. Perhatikan bagaimana objek ini dibangkitkan. Jika keluaran
operasi bernilai true, maka sebuah
objek TigaD true (objek dimana sedikitnya satu koordinat bernilai tak-nol)
diciptakan dan dijadikan nilai balik. Jika keluaran bernilai false, maka sebuah objek false diciptakan dan dijadikan nilai
balik. Jadi, statemen semacam ini
if(a &
b) Console.WriteLine("a & b bernilai true.");
else Console.WriteLine("a & b
bernilai false.");
Keluaran dari a & b adalah sebuah
objek TigaD, yang pada kasus ini
merupakan objek true. Karena
operator true dan false didefinisikan, pada objek yang
dihasilkan ini diterapkan operator true
dan hasil bertipe bool dijadikan
nilai balik. Pada kasus ini, hasilnya adalah true dan tubuh if
dieksekusi.
Karena semua
aturan yang diperlukan telah dipatuhi, kedua operator hubung-singkat sekarang
bisa digunakan pada objek TigaD.
Operand pertama diuji menggunakan operator
true (untuk ||) atau operator false
(untuk &&). Jika keluaran
operasi dapat ditentukan, maka operasi & atau | terkait
tidak perlu dievaluasi. Sebaliknya, operator & atau | teroverload akan dipakai untuk menentukan hasil.
Jadi, penggunaan && atau ||
menyebabkan operator & atau | terkait
hanya dipanggil ketika operand pertama tidak dapat menentukan keluaran
ekspresi. Sebagai contoh, perhatikan statemen ini dari program:
if(a || c) Console.WriteLine("a || c bernilai true.");
Operator true pertama-tama diterapkan terhadap a. Karena a bernilai true pada kasus
ini, tidak ada kebutuhan untuk menggunakan operator
|. Namun, jika statemen ditulis-ulang menjadi seperti ini:
if(c || a) Console.WriteLine("c || a bernilai true.");
maka operator true pertama-tama diterapkan terhadap c, yang pada kasus ini bernilai false. Jadi, metode operator | akan dipanggil untuk
menentukan apakah a bernilai true.
Operator
Konversi
Pada beberapa
situasi, Anda bisa saja ingin menggunakan objek sebuah kelas di dalam suatu
ekspresi yang melibatkan tipe data lain. Kadangkala, pengoverloadan satu atau
lebih operator dapat menyediakan cara menyelesaikan masalah ini. Namun, pada
beberapa kasus lain, apa yang Anda inginkan hanyalah konversi tipe sederhana
dari tipe kelas menjadi tipe target. Untuk menangani kasus tersebut, C#
mengijinkan Anda untuk menciptakan sebuah tipe spesial dari metode operator yang dinamakan operator
konversi. Operator konversi mengkonversi objek dari kelas Anda menjadi tipe
lain.
Ada dua bentuk
operator konversi, yaitu implisit dan eksplisit. Bentuk umum masing-masing
adalah:
public
static operator implicit tipe-target(tipe-sumber v) { return nilai;
}
public static operator explicit tipe-target(tipe-sumber v) { return nilai; }
Di sini, tipe-target merupakan tipe
target yang menjadi target dari konversi; tipe-sumber adalah tipe
awal yang akan dikonversi; dan nilai adalah nilai dari kelas setelah konversi. Operator konversi
menghasilkan nilai balik bertipe tipe-target.
Jika operator
konversi menspesifikasi implicit,
maka konversi dipanggil secara otomatis, seperti ketika sebuah objek digunakan
di dalam ekspresi dengan tipe target. Ketika operator konversi menspesifikasi explicit, maka konversi dipanggil
ketikan dilakukan sebuah cast. Anda tidak bisa mendefinisikan kedua operator
konversi implisit dan eksplisit untuk tipe sumber dan tipe target yang sama.
Untuk
mengilustrasikan operator konversi, akan diciptakan satu operator konversi
untuk kelas TigaD. Diasumsikan bahwa
Anda ingin mengkonversi objek bertipe TigaD
menjadi sebuah integer sehingga dapat dipakai di dalam suatu ekspresi integer.
Di samping itu, konversi akan terjadi dengan menggunakan hasil perkalian dari
ketiga dimensi. Untuk melakukannya, Anda akan menggunakan operator konversi
implisit seperti ini:
public
static implicit operator int(ThreeD
op1)
{
return op1.x * op1.y * op1.z;
}
Berikut adalah
sebuah program yang mengilustrasikan operator konversi ini:
// Sebuah contoh yang menggunakan operator konversi implisit.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload binary +.
public static TigaD operator +(TigaD op1, TigaD op2)
{
TigaD hasil = new TigaD();
hasil.x = op1.x +
op2.x;
hasil.y = op1.y +
op2.y;
hasil.z = op1.z +
op2.z;
return hasil;
}
// Sebuah konversi
implisit dari TigaD menjadi int.
public static implicit operator int(TigaD op1)
{
return op1.x * op1.y * op1.z;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD {
static void Main() {
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD();
int i;
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menjumlahkan a dan b
Console.Write("Hasil dari a + b: ");
c.Tampil();
Console.WriteLine();
i = a; //
mengkonversi ke int
Console.WriteLine("Hasil dari i = a: " + i);
Console.WriteLine();
i = a * 2 - b; //
mengkonversi ke int
Console.WriteLine("Hasil dari a * 2 - b: " + i);
}
}
Keluaran program
ditampilkan di sini:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Hasil dari a + b: 11, 12, 13
Hasil dari i = a: 6
Hasil dari a * 2 - b: -988
Seperti yang
diilustrasikan oleh program, ketika sebuah objek TigaD digunakan di dalam suatu ekspresi integer, seperti i = a, maka konversi diterapkan pada
objek tersebut. Pada kasus ini, konversi menghasilkan nilai 6, yang merupakan
perkalian dari setiap koordinat yang disimpan di dalam a. Namun, ketika sebuah ekspresi tidak memerlukan konversi ke int, operator konversi tidak dipanggil.
Itulah mengapa c = a +b tidak memanggil operator int().
Ingat bahwa Anda
dapat menciptakan berbagai operator konversi untuk memenuhi kebutuhan Anda.
Anda juga bisa mendefinisikan sebuah operator konversi kedua yang mengkonversi TigaD menjadi double. Setiap konversi diterapkan secara otomatis dan secara
independen.
Operator
konversi implisit diterapkan secara otomatis ketika sebuah konversi diperlukan
di dalam suatu ekspresi, ketika melewatkan sebuah objek ke suatu metode, di
dalam penugasan, dan juga ketika sebuah cast eksplisit menjadi tipe target
digunakan. Atau, Anda dapat menciptakan sebuah operator eksplisit, yang
dipanggil hanya ketika sebuah cast eksplisit dipakai. Operator konversi
eksplisit tidak dipanggil secara otomatis. Sebagai contoh, berikut adalah
program sebelumnya yang ditulis-ulang untuk melakukan konversi eksplisit
menjadi int:
// Menggunakan sebuah konversi eksplisit.
using System;
// Sebuah kelas koordinat tiga dimensi.
class TigaD {
int x, y, z; // koordinat 3D
public TigaD() { x = y = z = 0; }
public TigaD(int i, int j, int k) { x = i; y = j; z = k; }
// Overload binary +.
public static TigaD operator +(TigaD op1, TigaD op2)
{
TigaD hasil = new TigaD();
hasil.x = op1.x +
op2.x;
hasil.y = op1.y +
op2.y;
hasil.z = op1.z +
op2.z;
return hasil;
}
// Ini konversi
eksplisit.
public static explicit operator int(TigaD op1)
{
return op1.x * op1.y * op1.z;
}
// Menampilkan
koordinat X, Y, Z.
public void Tampil()
{
Console.WriteLine(x + ", " +
y + ", " + z);
}
}
class DemoTigaD
{
static void Main()
{
TigaD a = new TigaD(1, 2, 3);
TigaD b = new TigaD(10, 10, 10);
TigaD c = new TigaD();
int i;
Console.Write("Berikut adalah a: ");
a.Tampil();
Console.WriteLine();
Console.Write("Berikut adalah b: ");
b.Tampil();
Console.WriteLine();
c = a + b; //
menjumlahkan a dan b
Console.Write("Hasil dari a + b: ");
c.Tampil();
Console.WriteLine();
i = (int)a; //
secara eksplisit mengkonversi ke int -- cast diperlukan
Console.WriteLine("Hasil dari i = a: " + i);
Console.WriteLine();
i = (int)a * 2 - (int)b; // cast diperlukan
Console.WriteLine("Hasil dari a * 2 - b: " + i);
}
}
Hasil yang
diperoleh adalah:
Berikut adalah a: 1, 2, 3
Berikut adalah b: 10, 10, 10
Hasil dari a + b: 11, 12, 13
Hasil dari i = a: 6
Hasil dari a * 2 - b: -988
Karena operator
konversi sekarang dideklarasikan sebagai explicit,
konversi menjadi int harus dicast
secara eksplisit. Sebagai contoh, pada baris ini:
i = (int) a; // secara
eksplisit dikonversi menjadi int -- cast diperlukan
Jika Anda
membuang cast (pada kasus ini, (int)),
maka program tidak akan bisa dikompilasi.
Contoh
Lain: Penciptaan Tipe Data Empat-Bit
Contoh ini akan
mengembangkan sebuah tipe integer empat-bit dan mendefinisikan beberapa operasi
untuk tipe data tersebut. Seperti yang Anda ketahui, di awal penemuan teknologi
komputasi, kuantitas empat-bit umum dijumpai karena merepresentasikan setengah
byte. Tipe data ini juga cukup untuk menampung dijit heksadesimal. Karena empat
bit sama dengan setengah byte, kuantitas empat-bit dikenal dengan nybble.
Contoh berikut
menggunakan kelas Nybble untuk
mengimplementasikan tipe data nybble (empat bit). Kelas ini menggunakan sebuah int untuk penyimpanan, tetapi membatasi
nilai yang bisa ditampungnya dalam rentang 0 sampai 15 saja. Kelas Nybble mendefinisikan beberapa operator
berikut:
·
Penjumlahan sebuah Nybble dengan sebuah Nybble.
·
Penjumlahan sebuah int dengan sebuah Nybble.
·
Penjumlahan sebuah int dengan sebuah Nybble.
·
Kurang dari dan lebih dari.
·
Operator inkremen.
·
Konversi menjadi Nybble dari int.
·
Konversi menjadi int dari Nybble.
Semua operasi
ini cukup untuk membuktikan bagaimana sebuah tipe kelas dapat secara utuh
diintegrasikan ke dalam sistem tipe C#. Namun, untuk menyempurnakan
implementasi Nybble, Anda perlu
mendefinisikan semua operator lain. Anda bisa mencoba menambahkannya sendiri.
Kelas Nybble ditunjukkan di sini bersama
dengan kelas DemoNybble, yang
mendemonstrasikan kegunaanya:
// Menciptakan tipe 4-bit dinamakan dengan Nybble.
using System;
// Sebuah tipe data 4-bit.
class Nybble {
int nil; // tempat penyimpanan
public Nybble() { nil = 0; }
public Nybble(int i) {
nil = i;
nil = nil &
0xF; // mendapatkan 4 bit terbawah
}
// Overload biner +
untuk Nybble + Nybble.
public static Nybble operator
+(Nybble op1, Nybble op2)
{
Nybble hasil = new Nybble();
hasil.nil = op1.nil
+ op2.nil;
hasil.nil =
hasil.nil & 0xF; // mendapatkan 4-bit terbawah
return hasil;
}
// Overload biner +
untuk Nybble + int.
public static Nybble operator
+(Nybble op1, int op2)
{
Nybble hasil = new Nybble();
hasil.nil = op1.nil
+ op2;
hasil.nil =
hasil.nil & 0xF; // mendapatkan 4-bit terbawah
return hasil;
}
// Overload biner +
untuk int + Nybble.
public static Nybble operator
+(int op1, Nybble op2)
{
Nybble hasil = new Nybble();
hasil.nil = op1 +
op2.nil;
hasil.nil =
hasil.nil & 0xF; // mendapatkan 4-bit terbawah
return hasil;
}
// Overload ++.
public static Nybble operator
++(Nybble op)
{
Nybble hasil = new Nybble();
hasil.nil = op.nil
+ 1;
hasil.nil =
hasil.nil & 0xF; // mendapatkan
4-bit terbawah
return hasil;
}
// Overload >.
public static bool operator >(Nybble op1, Nybble op2)
{
if(op1.nil > op2.nil) return true;
else return false;
}
// Overload <.
public static bool operator
<(Nybble op1, Nybble op2)
{
if(op1.nil < op2.nil) return true;
else return false;
}
// Mengkonversi
sebuah Nybble menjadi sebuah int.
public static implicit operator
int (Nybble op)
{
return op.nil;
}
// Mengkonversi
sebuah int menjadi sebuah Nybble.
public static implicit operator Nybble(int op)
{
return new Nybble(op);
}
}
class DemoNybble {
static void Main() {
Nybble a = new Nybble(1);
Nybble b = new Nybble(10);
Nybble c = new Nybble();
int t;
Console.WriteLine("a: " + (int) a);
Console.WriteLine("b: " + (int) b);
// Menggunakan
sebuah Nybble di dalam statemen if.
if(a < b) Console.WriteLine("a kurang
dari b\n");
// Menambahkan dua
Nybble.
c = a + b;
Console.WriteLine("c setelah c = a + b: " + (int) c);
// Menambahkan
sebuah int dengan sebuah Nybble.
a += 5;
Console.WriteLine("a setelah a += 5: " + (int) a);
Console.WriteLine();
// Menggunakan
sebuah Nybble di dalam sebuah ekspresi int.
t = a * 2 + 3;
Console.WriteLine("Hasil dari a * 2 + 3: " + t);
Console.WriteLine();
// Ilustrasi
penugasan int dan overflow.
a = 19;
Console.WriteLine("Hasil dari a = 19: " + (int) a);
Console.WriteLine();
// Menggunakan
sebuah Nybble untuk mengendalikan loop.
Console.WriteLine("Mengendalikan loop for dengan sebuah Nybble.");
for(a = 0; a < 10; a++)
Console.Write((int) a + " ");
Console.WriteLine();
}
}
Keluaran program
ditampilkan di sini:
a: 1
b: 10
a kurang dari b
c setelah c = a + b: 11
a setelah a += 5: 6
Hasil dari a * 2 + 3: 15
Hasil dari a = 19: 3
Mengendalikan loop for dengan sebuah Nybble.
0 1 2 3 4 5 6 7 8 9
Meskipun
kebanyakan operasi Nybble mudah
dimengerti, ada satu poin penting yang perlu diperhatikan: Operator konversi
berperan besar dalam mengintegrasikan Nybble
ke dalam sistem tipe C#. Karena konversi didefinisikan dari Nybble ke int dan dari int ke Nybble, sebuah objek Nybble dapat dengan bebas dicampur
dalam ekspresi aritmatika. Sebagai contoh, perhatikan ekspresi ini dari
program:
t = a * 2 + 3;
Di sini, t adalah sebuah int, seperti 2 dan 3, tetapi a adalah sebuah Nybble.
Kedua tipe ini kompatibel di dalam ekspresi karena konversi implisit dari Nybble ke int. Pada kasus ini, karena ekspresi bertipe int, a dikonversi
menjadi int oleh metode konversinya.
Konversi dari int menjadi Nybble membolehkan sebuah objek Nybble untuk ditugasi suatu nilai int. Sebagai contoh, di dalam
program, statemen
a = 19;
bekerja seperti
ini. Operator konversi dari int
menjadi Nybble dieksekusi. Ini
menyebabkan sebuah objek Nybble baru
diciptakan yang memuat 4-bit terbawah dari nilai 19, yang menghasilkan 3 karena
19 mengoverflow rentang sebuah Nybble. Objek tersebut ditugaskan
kepada a. Tanpa operator konversi,
ekspresi semacam itu tidak akan diijinkan.
Konversi dari Nybble menjadi int juga dipakai oleh loop for.
Tanpa konversi ini, tidak dimungkinkan untuk menuliskan loop for dengan cara seperti itu.
No comments:
Post a Comment