Operator Overloading dalam C#

Lebih muatan boleh ditakrifkan sebagai proses mentakrifkan dan melaksanakan teknik polimorfisme, yang membolehkan pembolehubah atau objek dalam program mengambil pelbagai bentuk lain semasa pelaksanaan kod. Teknik ini boleh digunakan apabila sifat kaedah tidak serupa dengan jenis hujah, susunan pelaksanaan yang berbeza, apabila terdapat lebih daripada satu kaedah dengan nama yang sama dan sifat yang berbeza, dsb. Ini boleh dicapai dalam atur cara dalam kaedah yang berbeza, seperti Bilangan parameter yang berbeza, jenis parameter yang berbeza, susunan parameter yang berbeza, parameter pilihan dan argumen bernama.

Pelbagai Operator Overloading dalam C#

Terdapat berbilang operator dalam C#.

1. Kami boleh membebankan semua operator binari iaitu +, -, *, /, %, &, |, <<, >>.
2. Kami boleh membebankan semua operator unari iaitu ++, –, benar, salah, + , -, ~.
3. Sesetengah pengendali seperti &&, ||,[] ,() tidak boleh terlebih muatan.
4. Kami boleh membebankan operator hubungan secara berpasangan. Ini ialah ==, =, <, >, <= , >= dll.
5. Kami boleh membebankan pengendali kompaun kerana mereka sudah terlebih beban berkenaan dengan pengendali binari.

Jadi ini adalah beberapa operator yang dipratentukan yang boleh kami bebankan secara berlebihan.

Sintaks:

Di bawah ialah sintaks pelaksanaan lebih muatan operator:

public static classname  operator op (parameters)
{
// Code
}

Untuk Operator Unary

public static classname operator op (t)
{
// Code
}

Untuk Operator Binari

public static classname operator op (t1, t2)
{
// Code
}

Operator ialah kata kunci yang digunakan untuk melaksanakan lebihan beban operator. Jenis pemulangan beban operator tidak boleh dibatalkan. Dalam pengendali lebihan beban keutamaan sentiasa diberikan kepada pelaksanaan yang ditentukan pengguna dan bukannya pelaksanaan yang dipratakrifkan. Dalam lebihan muatan, kaedah terlebih beban harus mempunyai jenis argumen yang berbeza, bilangan argumen yang berbeza dan susunan hujah harus berbeza. Oleh itu, kaedah terlampau beban pengendali adalah sama seperti kaedah lain. Dalam pelaksanaan yang ditentukan pengguna, sintaks dan keutamaan tidak boleh diubah suai. Dalam pengendali binari, yang kiri .operator ialah ahli dan di sebelah kanan, objek dipanggil parameter.

Contoh Operator Overloading dalam C#

Di bawah ialah contoh yang menunjukkan cara melaksanakan konsep Operator Overloading dalam C#:

Contoh #1

Operator Overloading dengan Unary Operator. Dalam contoh ini, operator unary digunakan untuk lebihan muatan. – operator digunakan dalam kelas yang dinamakan sebagai Contoh yang memanggil kaedah beban lampau.  Seperti yang dinyatakan dalam pengkompil kod di bawah mengambilnya sebagai operator-(obj);.

Kod:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int val1, val2;
public Example(int no1, int no2)
{
val1 = no1;
val2 = no2;
}
public Example()
{
}
public static Example operator -(Example eg1)
{
eg1.val1 = -eg1.val1;
eg1.val1 = -eg1.val1;
return eg1;
}
public void Print()
{
Console.WriteLine("value1 =" + val1);
Console.WriteLine("value2 =" + val2);
Console.Read();
}
class Program
{
static void Main(string[] args)
{
Example eg = new Example(30, -60);
eg.Print();
Example eg1 = new Example();
eg1 = -eg;
eg1.Print();
Console.Read();
}
}
}
}

Output:

Contoh #2

Operator Overloading dengan Operator Binari. Dalam contoh ini, pengendali binari digunakan untuk menunjukkan cara kita boleh melaksanakan lebihan beban operator. + operator digunakan untuk menambah objek. Operator menerima satu parameter. Dalam kod, num ialah objek kelas yang dinamakan sebagai Contoh kepada objek yang diluluskan. Dalam lebihan muatan, operator kiri adalah ahli dan di sebelah kanan, objek dipanggil parameter.

Kod:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int num;
public Example()
{
num = 0;
}
public Example(int n)
{
num = n;
}
public static Example operator +(Example e1, Example e2)
{
Example e3 = new Example();
e3.num = e1.num + e2.num;
return e3;
}
public void display()
{
Console.WriteLine("{0}", num);
}
}
class Program
{
static void Main(string[] args)
{
Example num = new Example(200);
Example num1 = new Example(300);
Example num2 = new Example();
num2 = num + num1;
num.display();
num1.display();
num2.display();
Console.Read();
}
}
}

Output:

Contoh #3

Operator Overloading dan Warisan.

Kod:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
public int num;
public Example()
{
num = 0;
}
public Example(int n)
{
num = n;
}
public static Example operator +(Example e1, Example e2)
{
Example e3 = new Example();
e3.num = e1.num + e2.num;
return e3;
}
public void display()
{
Console.WriteLine("{0}", num);
}
}
class Example1 : Example
{
private double a;
private double b;
public Example1(double x, double y)
{
a = x;
b = y;
}
public Example1()
{
}
public void Show()
{
Console.WriteLine("{0} {1}", a, b);
}
}
class Program
{
static void Main(string[] args)
{
Example1 num = new Example1(20.0,2.3);
num.Show();
Example1 num1 = new Example1(3.0,3.1);
num1.Show();
Example1 num2 = new Example1();
//num2 = num + num1;
//num2.Show();
Console.Read();
}
}
}

Output:

Operator Terlebih Beban juga boleh diwarisi kepada kelas terbitan. Memandangkan tidak mungkin untuk mengisytiharkan pengendali dalam kelas terbitan untuk menyembunyikan pengendali yang diisytiharkan bagi kelas asas.

Contoh #4

Operator Overloading dengan Operator Kesaksamaan. Dalam contoh ini, lebihan beban pengendali ditunjukkan menggunakan pengendali kesamarataan. Operator kesamarataan digunakan di mana kita ingin melakukan perbandingan. Kita boleh membebankan kaedah dalam kelas untuk melakukan perbandingan. Dalam kod ini, nilai objek e1 dan e2 adalah sama. Tetapi rujukan mereka berbeza. Perbandingan nilai objek adalah berasaskan rujukan. Dalam kes e2 dan e3, ia merujuk kepada objek yang sama.

Kod:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace OperatorOverloading
{
class Example
{
private int a;
private int b;
public Example()
{
}
public Example(int x, int y)
{
a = x;
b = y;
}
public void Display()
{
Console.WriteLine("{0} {1}", a, b);
}
}
class Program
{
public static void Main()
{
Example e1 = new Example(30, 20);
e1.Display();
Example e2 = new Example(30, 20);
e2.Display();
Example e3 = e2;
e3.Display();
if (e1.Equals(e2))
Console.WriteLine("equal");
else
Console.WriteLine("not equal");
if (e2.Equals(e3))
Console.WriteLine("equal");
Console.ReadLine();
}
}
}

Output:

Kesimpulan

Pembebanan operator adalah konsep penting. Ia menyediakan kebolehgunaan semula pengendali dalam pelbagai operasi. Dalam C# kita boleh membebankan hanya set parameter yang ditentukan. Tidak semua bahasa .Net sokongan operator terlebih muatan. Jadi dalam C#, ia menyediakan keupayaan tambahan dari segi pelaksanaan yang ditentukan pengguna.

Atas ialah kandungan terperinci Operator Overloading dalam C#. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!