重载可以定义为定义和实现多态性技术的过程，它允许程序中的变量或对象在代码执行期间呈现各种其他形式。当方法属性与参数类型不相似、执行顺序不同、存在多个具有相同名称和不同属性的方法等时，可以使用这一技术。这可以在一个程序中的不同方法中实现，例如不同数量的参数、不同类型的参数、不同的参数顺序、可选参数和命名参数。
C# 中有多个运算符。
这些是一些我们可以重载的预定义运算符。
语法：
下面是实现运算符重载的语法：
public static classname operator op (parameters)
{
// Code
}对于一元运算符
public static classname operator op (t)
{
// Code
}对于二元运算符
public static classname operator op (t1, t2)
{
// Code
}Operator 是用于实现运算符重载的关键字。运算符重载的返回类型永远不能为 void。在运算符重载中，始终优先考虑用户定义的实现而不是预定义的实现。在重载中，重载的方法应该有不同类型的参数，不同的参数数量以及参数的顺序应该不同。因此运算符重载方法与任何其他方法相同。在用户定义的实现中，语法和优先级无法修改。在二元运算符中，.operator 的左边是成员，右边的对象称为参数。
以下示例展示了如何在 C# 中实现运算符重载概念：
使用一元运算符重载运算符。 在此示例中，一元运算符用于重载。 – 运算符用于调用重载方法的名为Example 的类中。 正如下面的代码中提到的，编译器将其视为operator-(obj);.
代码：
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();
}
}
}
}输出：
使用二元运算符重载运算符。 在这个例子中，二元运算符用于展示如何实现运算符重载。 + 运算符用于添加对象。操作员接收一个参数。在代码中，num 是名为Example 的类的对象，该对象将被传递到该类。在重载中，运算符的左边是成员，右边的对象称为参数。
代码：
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();
}
}
}输出：
运算符重载和继承。
代码：
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();
}
}
}输出：
重载运算符也可以继承到派生类。因为不可能在派生类中声明运算符来隐藏基类声明的运算符。
使用相等运算符重载运算符。在此示例中，使用相等运算符显示了运算符重载。相等运算符用于我们想要进行比较的地方。我们可以重载类中的方法来进行比较。在此代码中，对象 e1 和 e2 的值相同。但他们的参考文献不同。对象值的比较是基于引用的。对于 e2 和 e3，它指的是同一个对象。
代码：
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();
}
}
}输出：
运算符重载是一个重要的概念。它提供了操作符在多个操作中的可重用性。在 C# 中，我们只能重载一组已定义的参数。并非所有 .Net 语言都支持运算符重载。因此在 C# 中，它在用户定义的实现方面提供了额外的功能。
以上是C# 中的运算符重载的详细内容。更多信息请关注PHP中文网其他相关文章！
