c#运算符重载

在C#中，您可以通过运算符重载来为自定义类型定义特定的操作行为。运算符重载允许您重新定义与特定运算符相关的操作，以便适应您自定义的类型。

以下是运算符重载的基本语法：

public static <returnType> operator <operator> (operandType operand1, operandType operand2)
{
    // 实现运算符操作的逻辑
    // 返回结果
}

1
2
3
4
5
6

returnType：运算符重载的返回类型。
operator：要重载的运算符，例如+、-、*等。
operandType：运算符操作数的类型。
operand1、operand2：运算符的操作数。
下面是一个示例，演示如何重载+运算符来实现自定义类型的加法操作

public class ComplexNumber
{
    public double Real { get; set; }
    public double Imaginary { get; set; }

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

    // 重载+运算符
    public static ComplexNumber operator +(ComplexNumber c1, ComplexNumber c2)
    {
        double realPart = c1.Real + c2.Real;
        double imaginaryPart = c1.Imaginary + c2.Imaginary;
        return new ComplexNumber(realPart, imaginaryPart);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上面的示例中，我们定义了一个ComplexNumber类来表示复数。然后，我们重载了+运算符来实现两个复数对象之间的加法操作。

以下是使用重载的+运算符的示例：

ComplexNumber c1 = new ComplexNumber(2, 3);
ComplexNumber c2 = new ComplexNumber(4, 5);
ComplexNumber result = c1 + c2;
Console.WriteLine(result.Real); // 输出：6
Console.WriteLine(result.Imaginary); // 输出：8

1
2
3
4
5
6

通过运算符重载，我们可以为自定义类型定义各种运算符的操作行为，从而使它们能够像内置类型一样进行常见的数学和逻辑运算。

显示转换和隐式转换运算符重载

问题：如何把一个int类型的数字赋值给一个class 类的变量，如何把class类的变量赋值给一个int类型的数字呢？这就需要显示转换和隐式转换运算符重载了

    public class person1
    {
        public int age;
        public string? name;

        //隐式类型转换 person p1=10;
        public static implicit operator person1(int age)
        {
            return new person1() { age = age };
        }

        //显示类型转换 int age=(int)person
        public static explicit operator int(person1 P1)
        {
            return P1.age;
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

main方法

person1 P1 = new person1();
P1.age = 1;
P1.name = "Test";
//隐式转换
person1 person1 = 10;
//显示转换
int age = (int)P1;
1
2
3
4
5
6
7