编辑“︁C Sharp 运算符重载”︁（章节）

= C#运算符重载 =

== 介绍 ==
'''运算符重载'''是C#中的一项高级类特性，它允许开发者重新定义或扩展内置运算符（如+、-、*、/等）的行为，使其能够作用于自定义类型（如类或结构体）。通过运算符重载，可以使代码更加直观和易于理解，尤其是在处理数学或逻辑运算时。

运算符重载的核心思想是为运算符提供特定于类的实现，从而让对象能够像基本数据类型一样参与运算。需要注意的是，并非所有运算符都可以重载，且重载的运算符必须保持其原有的语义一致性。

== 可重载的运算符 ==
C#中允许重载的运算符包括：
* 算术运算符：<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code>
* 比较运算符：<code>==</code>, <code>!=</code>, <code><</code>, <code>></code>, <code><=</code>, <code>>=</code>
* 逻辑运算符：<code>true</code>, <code>false</code>
* 位运算符：<code>&</code>, <code>|</code>, <code>^</code>, <code>~</code>, <code><<</code>, <code>>></code>
* 转换运算符：<code>implicit</code>, <code>explicit</code>

不可重载的运算符包括：
* 条件运算符：<code>&&</code>, <code>||</code>, <code>?:</code>
* 赋值运算符：<code>=</code>, <code>+=</code>, <code>-=</code>（但可以通过重载基础运算符间接实现）
* 成员访问运算符：<code>.</code>, <code>-></code>
* 其他：<code>new</code>, <code>is</code>, <code>sizeof</code>, <code>typeof</code>

== 语法与实现 ==
运算符重载通过定义类的静态方法来实现，方法名使用<code>operator</code>关键字后跟要重载的运算符符号。方法的参数和返回类型决定了运算符的行为。

以下是一个简单的示例，展示如何为自定义的<code>Vector</code>类重载<code>+</code>运算符：

<syntaxhighlight lang="csharp">
public class Vector
{
    public int X { get; set; }
    public int Y { get; set; }

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

    // 重载 + 运算符
    public static Vector operator +(Vector v1, Vector v2)
    {
        return new Vector(v1.X + v2.X, v1.Y + v2.Y);
    }

    // 重载 == 运算符（必须同时重载 !=）
    public static bool operator ==(Vector v1, Vector v2)
    {
        return v1.X == v2.X && v1.Y == v2.Y;
    }

    public static bool operator !=(Vector v1, Vector v2)
    {
        return !(v1 == v2);
    }

    // 重写 Equals 和 GetHashCode 以确保一致性
    public override bool Equals(object obj)
    {
        if (obj is Vector other)
            return this == other;
        return false;
    }

    public override int GetHashCode()
    {
        return X.GetHashCode() ^ Y.GetHashCode();
    }
}
</syntaxhighlight>

=== 示例输入与输出 ===
<syntaxhighlight lang="csharp">
Vector v1 = new Vector(1, 2);
Vector v2 = new Vector(3, 4);
Vector sum = v1 + v2;  // 调用重载的 + 运算符
Console.WriteLine($"Sum: ({sum.X}, {sum.Y})"); // 输出: Sum: (4, 6)

bool areEqual = v1 == v2;
Console.WriteLine($"Are equal? {areEqual}"); // 输出: Are equal? False
</syntaxhighlight>

== 实际应用场景 ==
运算符重载在以下场景中非常有用：
1. '''数学库'''：如复数、矩阵或向量的运算。
2. '''物理引擎'''：如力的合成、速度的叠加。
3. '''游戏开发'''：如坐标变换、碰撞检测。
4. '''财务计算'''：如货币的加减或汇率转换。

=== 复数运算示例 ===
以下是一个复数类的运算符重载实现：
<syntaxhighlight lang="csharp">
public class Complex
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

    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,
            c1.Real * c2.Imaginary + c1.Imaginary * c2.Real
        );
    }

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

=== 输入与输出 ===
<syntaxhighlight lang="csharp">
Complex a = new Complex(1, 2);
Complex b = new Complex(3, 4);
Complex sum = a + b;
Complex product = a * b;

Console.WriteLine($"Sum: {sum}");      // 输出: Sum: 4 + 6i
Console.WriteLine($"Product: {product}"); // 输出: Product: -5 + 10i
</syntaxhighlight>

== 注意事项 ==
1. '''语义一致性'''：重载的运算符应保持其原始含义。例如，<code>+</code>不应用于减法操作。
2. '''成对重载'''：某些运算符必须成对重载，如<code>==</code>和<code>!=</code>、<code><</code>和<code>></code>等。
3. '''性能考虑'''：避免在重载的运算符中执行复杂操作，以免影响性能。
4. '''可读性'''：过度使用运算符重载可能导致代码难以理解，需谨慎使用。

== 转换运算符 ==
除了算术和比较运算符，C#还允许重载类型转换运算符（隐式或显式）。例如：

<syntaxhighlight lang="csharp">
public class Temperature
{
    public double Celsius { get; set; }

    // 隐式转换：double -> Temperature
    public static implicit operator Temperature(double celsius)
    {
        return new Temperature { Celsius = celsius };
    }

    // 显式转换：Temperature -> double
    public static explicit operator double(Temperature temp)
    {
        return temp.Celsius;
    }
}
</syntaxhighlight>

=== 使用示例 ===
<syntaxhighlight lang="csharp">
Temperature temp = 25.0; // 隐式转换
double celsius = (double)temp; // 显式转换
</syntaxhighlight>

== 总结 ==
运算符重载是C#中一项强大的特性，能够使自定义类型的行为更接近内置类型，从而提升代码的简洁性和可读性。然而，开发者需遵循语义一致性和成对重载的原则，并避免滥用以确保代码的可维护性。通过实际案例（如向量运算、复数计算等），可以更好地理解其应用场景和实现方式。

[[Category:编程语言]]
[[Category:C Sharp]]
[[Category:C Sharp 高级类特性]]