Categories

在 C#中，重写操作符（Operator Overloading）是指为自定义的类或结构体提供特定运算符的实现。这样你可以定义如何对自定义类型使用标准的运算符（如 +、-、*、/ 等等）。通过重载操作符，可以让自定义类型更自然地与内置类型进行交互，提高代码的可读性和可维护性。

为什么要重载操作符？

重载操作符的主要动机是为了增强类型的可用性和直观性。例如，假设你定义了一个表示复数的类，重载加法和减法操作符可以使得两个复数对象可以用 + 和 - 来进行相加和相减，而不需要调用特别的方法。

如何重载操作符？

在 C#中，重载操作符的基本步骤如下：

定义一个静态方法: 操作符重载必须定义为静态方法。
使用 operator 关键字: 该方法名称使用 operator 关键字后跟你要重载的运算符。
指定操作数和返回类型: 定义该操作符的操作数（参数）和返回类型。

操作符重载示例

以下是一个具体的示例，展示了如何为一个自定义的 Complex（复数）类重载加法（+）和减法（-）操作符。

示例：复数类的操作符重载

using System;

public struct Complex
{
    public double Real { get; }
    public double Imaginary { get; }

    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // 重载 + 操作符
    public static Complex operator +(Complex c1, Complex c2)
    {
        return new Complex(c1.Real + c2.Real, c1.Imaginary + c2.Imaginary);
    }

    // 重载 - 操作符
    public static Complex operator -(Complex c1, Complex c2)
    {
        return new Complex(c1.Real - c2.Real, c1.Imaginary - c2.Imaginary);
    }

    // 重写 ToString 方法以便于显示
    public override string ToString()
    {
        return $"{Real} + {Imaginary}i";
    }
}

public class Program
{
    public static void Main()
    {
        Complex c1 = new Complex(3, 4);
        Complex c2 = new Complex(1, 2);

        Complex sum = c1 + c2;  // 使用重载的 + 操作符
        Complex difference = c1 - c2;  // 使用重载的 - 操作符

        Console.WriteLine($"c1: {c1}");
        Console.WriteLine($"c2: {c2}");
        Console.WriteLine($"Sum: {sum}");
        Console.WriteLine($"Difference: {difference}");
    }
}

输出结果：

c1: 3 + 4i
c2: 1 + 2i
Sum: 4 + 6i
Difference: 2 + 2i

可重载的操作符

C#中大多数运算符都是可以重载的，包括：

一元操作符: +, -, !, ~, ++, --, true, false
二元操作符: +, -, *, /, %, &, |, ^, <<, >>
比较操作符: ==, !=, >, <, =, <=

重载操作符的规则和限制

操作符必须是 public static 的。
至少有一个操作数是包含该操作符的类或结构体。
无法重载**=和? :**操作符。
重载的操作符应尽量保持预期的行为，避免令人困惑的实现。
重载的比较操作符应成对出现（如 == 和 != 必须同时重载）。

重载一元操作符

一元操作符作用于单个操作数，如正号、负号、自增和自减操作符。

public struct Point
{
    public int X { get; }
    public int Y { get; }

    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }

    // 重载一元 - 操作符
    public static Point operator -(Point p)
    {
        return new Point(-p.X, -p.Y);
    }

    public override string ToString()
    {
        return $"({X}, {Y})";
    }
}

public class Program
{
    public static void Main()
    {
        Point p = new Point(3, 4);
        Point negatedP = -p;  // 使用重载的 - 操作符

        Console.WriteLine($"p: {p}");
        Console.WriteLine($"negatedP: {negatedP}");
    }
}

输出结果：

1 2	p: (3, 4) negatedP: (-3, -4)

重载比较操作符

比较操作符（如 == 和 !=）必须成对重载，因为它们是对称的。

public struct Complex
{
    public double Real { get; }
    public double Imaginary { get; }

    public Complex(double real, double imaginary)
    {
        Real = real;
        Imaginary = imaginary;
    }

    // 重载 == 操作符
    public static bool operator ==(Complex c1, Complex c2)
    {
        return c1.Real == c2.Real && c1.Imaginary == c2.Imaginary;
    }

    // 重载 != 操作符
    public static bool operator !=(Complex c1, Complex c2)
    {
        return !(c1 == c2);
    }

    // 必须重写 Equals 方法和 GetHashCode 方法
    public override bool Equals(object obj)
    {
        if (obj is Complex)
        {
            Complex other = (Complex)obj;
            return this == other;
        }
        return false;
    }

    public override int GetHashCode()
    {
        return Real.GetHashCode() ^ Imaginary.GetHashCode();
    }

    public override string ToString()
    {
        return $"{Real} + {Imaginary}i";
    }
}

public class Program
{
    public static void Main()
    {
        Complex c1 = new Complex(1, 2);
        Complex c2 = new Complex(1, 2);
        Complex c3 = new Complex(3, 4);

        Console.WriteLine($"c1 == c2: {c1 == c2}");
        Console.WriteLine($"c1 != c3: {c1 != c3}");
    }
}

输出结果：

1 2	c1 == c2: True c1 != c3: True

总结

操作符重载: 允许你为自定义类型定义标准运算符的行为，使得对象之间的操作更直观和一致。
语法要求: 重载操作符的方法必须是 public static，且至少有一个操作数是定义该操作符的类型。
安全性和一致性: 重载的操作符应遵循预期的行为规则，确保代码的可读性和可维护性。

通过重载操作符，可以使自定义类型与内置类型一样自然地进行操作，从而提高代码的可用性和直观性。