关注我们

C# - 运算符重载

面向对象编程概念，如多态，指的是一个名称具有不同的形式和实现。它允许变量或对象在执行代码时采用不同的形式。它主要用于以下情况：希望方法属性不与给定参数相似，而在同一名称可以与不同类型的执行方法和属性一起使用时，需要不同的执行顺序。这可以在具有不同类型的参数及其计数的程序中实现。在C#中有各种类型的运算符重载方法。您将在本教程中方便地学习所有这些方法。

C#中的运算符重载技术

C#中的运算符重载可以使用不同形式的运算符来完成。但在继续介绍这些技术之前，让无涯教程先考虑运算符的验证，以及在执行运算符重载时如何使用它们。

运算符重载语法

复制代码

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

For Unary Operator

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

For Binary Operator

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

运算符通常是实现运算符重载时使用的关键字。请注意，重载运算符的返回类型不能保持void，这一点很重要。

因此，重载方法应该始终具有不同的参数集。它们的顺序和编号不应该相同。它们与任何其他方法类似，但是对于用户定义的方法，运算符的优先级和语法不能更改。左边称为二元运算符中的成员，而右边是称为参数的对象。一旦您了解了相同的实现，您就会理解这些概念。

另一个需要考虑的重要实例是，在C#中，有一个称为运算符函数的特殊函数。此函数或方法必须始终是静电和公共的。它只包含值参数。运算符函数中通常不允许将外部参数和引用参数作为参数。应用运算符函数的一般形式遵循以下语法。

复制代码

 public static return_type operator op (argument list)

这里，op是用于重载的运算符，运算符是唯一需要的关键字。在一元运算符的情况下，您只需为二元运算符传递一个参数和两个参数。同样重要的是要注意，至少应该有一个参数是用户定义的，或者是结构类型或类。让无涯教程看看如何实现所有这些概念。

一元运算符重载

在一元运算符的情况下，运算符重载的一般形式遵循下面给出的语法。

复制代码

 public static return_type operator op (Type t)  
{  
// Statements  
}

这里，返回类型可以是任何类型，但对于+、-、~和.(点).这样的运算符，它的返回类型不应该是空的。整型或布尔类型。重要的是要注意，布尔运算符推出TRUE和FALSE，因此只能作为对进行重载。如果不这样做，将会发生编译错误，因为类通常声明此运算符而不声明另一个运算符。

考虑下面的程序，它显示了如何重载类复合体中的一元运算符。

复制代码

using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public static Complex operator -(Complex c)  
    {  
        Complex temp = new Complex();  
        temp.x = -c.x;  
        temp.y = -c.y;  
        return temp;  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex();  
        c2.ShowXY(); // displays 0 & 0  
        c2 = -c1;  
        c2.ShowXY(); // diapls -10 & -20  
    }  
}

二元运算符重载

若要重载二元运算符，必须查找两个参数。您需要确保其中一个运算符应该是定义运算符的CLASS或STRUT类型。如前所述，二元运算符不能返回void，但它可以在实现重载时返回所有其他类型的值。使用以下语法可以显示二元运算符中运算符重载的一般形式。

链接：https://www.learnfk.comhttps://www.learnfk.com/csharp/c-sharp-operator-overloading.html

来源：LearnFk无涯教程网

复制代码

 public static return_type operator op (Type1 t1, Type2 t2)  
{  
//Statements  
}

请考虑下面的示例代码，它说明了二元运算符重载是如何工作的。

复制代码

using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
}  
public Complex(int i, int j)  
{  
    x = i;  
    y = j;  
}  
public void ShowXY()  
{  
    Console.WriteLine("{0} {1}", x, y);  
}  
public static Complex operator +(Complex c1, Complex c2)  
{  
    Complex temp = new Complex();  
    temp.x = c1.x + c2.x;  
    temp.y = c1.y + c2.y;  
    return temp;  
}  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(20, 30);  
        c2.ShowXY(); // displays 20 & 30  
        Complex c3 = new Complex();  
        c3 = c1 + c2;  
        c3.ShowXY(); // dislplays 30 & 50  
    }  
}

需要注意的是，诸如==之类的运算符。！=、<；>；、<；=、>；=仅作为对重载。当二元算术运算符使用它们重载时，赋值运算符将自动重载。例如，如果重载+运算符，它也会隐式重载为+=运算符。

运算符重载和继承

另一个实例是，即使您将重载运算符声明为静电，它们也将继承派生类。之所以会发生这种情况，是因为运算符的声明要求它是要声明运算符的结构或类。因此，以前在派生类中声明的运算符不可能隐藏父类中已经存在的运算符。因此，新修饰符不是要考虑的选项，因为在声明运算符时不允许使用它们。可以使用下面给出的代码片段显示此实例。

复制代码

using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public static Complex operator +(Complex c1, Complex c2)  
    {  
        Complex temp = new Complex();  
        temp.x = c1.x + c2.x;  
        temp.y = c1.y + c2.y;  
        return temp;  
    }  
}  
class MyComplex: Complex  
{  
    private double x;  
    private double y;  
    public MyComplex(double i, double j)  
    {  
        x = i;  
        y = j;  
    }  
    public MyComplex()  
    {  
    }  
    public new void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        MyComplex mc1 = new MyComplex(1.5, 2.5);  
        mc1.ShowXY();  
        MyComplex mc2 = new MyComplex(3.5, 4.5);  
        mc2.ShowXY();  
        MyComplex mc3 = new MyComplex();  
        //mc3 = mc1 + mc2;  
        //mc3.ShowXY();  
    }  
}

相等运算符重载

在C#中，您可能已经熟悉了默认情况下从Syste.object.Equals()方法继承Syste.Object的所有用户定义类。基于引用的比较由equals()方法提供。但是，此方法有可能覆盖驻留在用户定义的类中的方法。因此，使用这种方法可以很容易地实现基于值的比较。这就是相等运算符的操作方式。要重载该操作符，您需要遵循下面显示的代码片段。

复制代码

using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(10, 20);  
        c2.ShowXY(); // displays 10 & 20  
        Complex c3 = c2;  
        c3.ShowXY(); // dislplays 10 & 20  
        if (c1.Equals(c2))  
            Console.WriteLine("OK");  
        else  
            Console.WriteLine("NOT OK");  
        if (c2.Equals(c3))  
            Console.WriteLine("OK1");  
    }  
}

在上述程序中，结果显示为“NOT OJ”和“OK1”。这通常意味着默认情况下，Equals() 方法正在执行引用比较。需要注意的是，上面代码中对象C2和C1的值是一样的，但是它们在内存地址上的偏好不同。但如果你仔细注意，C2 和 C3 共享相同的内存引用。这就是 Equals() 方法实现相等运算符重载的方式。在 C# 中，也可以覆盖 Equals() 方法，即使它可能存在于用户定义的任何类中以实现基于值的比较。可以使用下面显示的以下代码片段来支持此语句。

复制代码

using System;  
class Complex  
{  
    private int x;  
    private int y;  
    public Complex()  
    {  
    }  
    public Complex(int i, int j)  
    {  
        x = i;  
        y = j;  
    }  
    public void ShowXY()  
    {  
        Console.WriteLine("{0} {1}", x, y);  
    }  
    public override bool Equals(object o)  
    {  
        if ((Complex)o.x == this.x && (Complex)o.y == this.y)  
            return true;  
        else  
            return false;  
    }  
    public override int GetHashCode()  
    {  
        return this.ToString().GetHashCode();  
    }  
}  
class MyClient  
{  
    public static void Main()  
    {  
        Complex c1 = new Complex(10, 20);  
        c1.ShowXY(); // displays 10 & 20  
        Complex c2 = new Complex(10, 20);  
        c2.ShowXY(); // displays 10 & 20  
        Complex c3 = c2;  
        c3.ShowXY(); // dislplays 10 & 20  
        if (c1.Equals(c2))  
            Console.WriteLine("OK");  
        else  
            Console.WriteLine("NOT OK");  
        if (c2.Equals(c3))  
            Console.WriteLine("OK1");  
    }  
}

在本教程中，您了解了在C#中通常用于实现运算符重载的总体方法。您遇到了某些使用一元、二元和相等运算符实现运算符重载的实例。到目前为止，您可能已经熟悉了，在实现C#时，各种操作符限制了程序流，因此您需要了解它们将这些条件花在哪里。此外，在C#中实现运算符重载时，您需要非常好奇地了解在实现时推出的数据的工作流是什么，以及一种形式的数据如何交付不同类型的输出。

祝学习愉快！(内容编辑有误？请选中要编辑内容 -> 右键 -> 修改 -> 提交！)

技术教程推荐

JavaScript进阶实战课 -〔石川〕

好记忆不如烂笔头。留下您的足迹吧 :)