Operatorüberladung in C#

Überladen kann als ein Prozess der Definition und Implementierung der Polymorphismustechnik definiert werden, der es den Variablen oder Objekten im Programm ermöglicht, während der Codeausführung verschiedene andere Formen anzunehmen. Diese Technik kann verwendet werden, wenn die Methodeneigenschaften nicht mit der Art der Argumente übereinstimmen, die Ausführungsreihenfolge unterschiedlich ist, wenn mehr als eine Methode mit demselben Namen und unterschiedlichen Eigenschaften vorhanden ist usw. Dies kann in einem Programm mit verschiedenen Methoden erreicht werden. wie zum Beispiel die unterschiedliche Anzahl von Parametern, unterschiedliche Parametertypen, unterschiedliche Reihenfolge von Parametern, optionale Parameter und benannte Argumente.

Verschiedene Operatorüberladungen in C#

Es gibt mehrere Operatoren in C#.

1. Wir können alle binären Operatoren überladen, d. h. +, -, *, /, %, &, |, <<, >>.
2. Wir können alle unären Operatoren überladen, d. h. ++, –, wahr, falsch, +, -, ~.
3. Einige Operatoren wie &&, ||,[],() können nicht überladen werden.
4. Wir können relationale Operatoren paarweise überladen. Dies sind ==, =, <, >, <= , >= usw.
5. Wir können zusammengesetzte Operatoren überladen, da sie in Bezug auf den binären Operator bereits überladen sind.

Das sind also einige vordefinierte Operatoren, die wir überladen können.

Syntax:

Unten finden Sie die Syntax zur Implementierung der Operatorüberladung:

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

Für unären Operator

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

Für binären Operator

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

Operator ist das Schlüsselwort, das zur Implementierung der Operatorüberladung verwendet wird. Der Rückgabetyp der Operatorüberladung kann niemals ungültig sein. Bei der Operatorüberladung werden immer benutzerdefinierten Implementierungen der Vorzug gegeben gegenüber vordefinierten Implementierungen. Beim Überladen sollten überladene Methoden eine andere Art von Argumenten haben, eine andere Anzahl von Argumenten und eine andere Reihenfolge der Argumente. Operatorüberladene Methoden sind also dieselben wie alle anderen Methoden. In benutzerdefinierten Implementierungen können Syntax und Priorität nicht geändert werden. Im binären Operator ist das linke Element von .operator ein Mitglied und auf der rechten Seite wird das Objekt als Parameter bezeichnet.

Beispiele für Operatorüberladung in C#

Im Folgenden finden Sie Beispiele, die zeigen, wie das Konzept der Operatorüberladung in C# implementiert wird:

Beispiel #1

Operatorüberladung mit unärem Operator. In diesem Beispiel wird der unäre Operator zum Überladen verwendet. – Der Operator wird in der Klasse „Example“ verwendet, die die Überladungsmethode aufruft.  Wie im folgenden Code-Compiler erwähnt, nimmt es den Operator-(obj);.

Code:

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();
}
}
}
}

Ausgabe:

Beispiel #2

Operatorüberladung mit binärem Operator. In diesem Beispiel wird der binäre Operator verwendet, um zu zeigen, wie wir eine Operatorüberladung implementieren können. Der +-Operator wird zum Hinzufügen der Objekte verwendet. Der Bediener erhält einen Parameter. Im Code ist num ein Objekt der Klasse „Example“, an die das Objekt übergeben wird. Beim Überladen ist das linke Element des Operators ein Mitglied und auf der rechten Seite wird das Objekt als Parameter bezeichnet.

Code:

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();
}
}
}

Ausgabe:

Beispiel #3

Operatorüberladung und Vererbung.

Code:

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();
}
}
}

Ausgabe:

Überladene Operatoren können auch an die abgeleitete Klasse vererbt werden. Da es nicht möglich ist, den deklarierten Operator in der abgeleiteten Klasse zu verbergen, um den deklarierten Operator der Basisklasse auszublenden.

Beispiel #4

Operatorüberladung mit Gleichheitsoperatoren. In diesem Beispiel wird die Operatorüberladung mithilfe des Gleichheitsoperators gezeigt. Der Gleichheitsoperator wird verwendet, wenn wir einen Vergleich durchführen möchten. Wir können die Methode in der Klasse überladen, um einen Vergleich durchzuführen. In diesem Code sind die Werte der Objekte e1 und e2 gleich. Aber ihre Referenzen sind unterschiedlich. Der Vergleich von Objektwerten erfolgt referenzbasiert. Im Fall von e2 und e3 bezieht es sich auf dasselbe Objekt.

Code:

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();
}
}
}

Ausgabe:

Fazit

Bedienerüberlastung ist ein wichtiges Konzept. Es ermöglicht die Wiederverwendbarkeit von Operatoren in mehreren Vorgängen. In C# können wir nur einen definierten Parametersatz überladen. Nicht alle Sprachen von .Net unterstützen die Überladung von Operatoren. In C# bietet es also zusätzliche Funktionen in Bezug auf benutzerdefinierte Implementierungen.

Das obige ist der detaillierte Inhalt vonOperatorüberladung in C#. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!