4.2 C#-----------------------------操作符的重载------------------------------------------

                                  操作符一般用于系统预定义的数据类型。如果在类中定义操作符,就称为操作符重载。

操作符重载包括一元操作符重载和二元操作符重载，以及用户定义的数据类型转换。

　　如果有一个复数Complex 类对一元操作符“++”重载，可以写成：

public static Complex operator ++(Complex a)

{

.......................................................

}

如果是对二元操作符“+”重载可以写成：

 public static Complex operator +(Complex a,Complex b) 2 { 3 ............... 4 } 

 一元操作符有一个参数，二元操作符有两个参数，重载操作符的开始必须以public static 修饰。可以重载的操作符包括：

　　一元操作符：+、-、！、~、++、--、true、false。

　　二元操作符：+、-、*、/、 %、 &、 |、^、<<、>>、==、！=、 >、<、 >=、<=。

下面的操作符要求同时重载、不能只重载其中的一个：

　　一元操作符：true和false。

　　二元操作符：==和！=    >和<   >=和<=。

　操作符的作用：

　　操作符重载给类的一些操作带来一些方便，俩个复数的实部相加运算可以写成：

public static double Add(Complex a，Complex b)

{

return a.r+b.r

}

这样的写发不够简洁，并且类的成员修饰符不为public时就不能这样直接操作了。

　　4.7操作符重载的实现-------------------------------------->>>>>>>>>>>>>>>>>>

先新建一个类：Complex.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Application27
{
    class Complex
    {
        double r, v;
        public Complex(double r, double v)
        {
            this.r = r;
            this.v = v;

        }
        //二元操作符“+”重载
        public static Complex operator +(Complex a, Complex b) { return new Complex(a.r + b.r, a.v + b.v); }

        //一元操作符“-”重载
        public static Complex operator -(Complex a)
        {
            return new Complex(-a.r, -a.v);

        }

        //一元操作符“++”重载
        public static Complex operator ++(Complex a)
        {
            double r = a.r + 1;
            double v = a.v + 1;
            return new Complex(r,v);

        }
        public void Print()
        {
            Console.Write(r+" + " +v+ "i
");
        }

    }
}

然后在主程序中实现：Test.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Application27
{
    class Test
    {
        public static void Main()
        {
            Complex a = new Complex(3, 4);
            Complex b = new Complex(5,6);
            
            Complex c = -a;
            c.Print();
            
            Complex d = a + b;
            d.Print();
            a.Print();

            Complex e = a++;  //先赋值后++
            a.Print();
            e.Print();

            Complex f = ++a;   //先++后赋值
            a.Print();
            f.Print();
        }
    }
}

　　

 在操作符重载中，返回值往往需要新建（new）一个新建的Complex对象。

　　另外一个种操作符重载类型是用户定义的数据类型转换，它实现不同类型之间的转换，包括显示转换和隐式转换两种方式。

　　编程中往往需要将一个类型转换成另外一个类型。例如将Int转换成double,  他们是系统已经预定义的类型，编译器知道如何来执行他们的转换，具体内容以后在说吧。

　　如果他们中间有的类型不是编译器预定义的类型，编译器将不知道如何执行转换，解决的方法是使用用户定义的数据类型转换。

　　　　如果转换过程不会因丢失数据而出现异常，就采用隐式转换。如果转换过程有可能丢失数据，就要采用显示转换。

　　隐式类型转换的写法如下：

//隐式转换如下
public static implicit operator Square(double s)
{
..................
}

要实现double向Square 转换功能，用关键字explicit进行显式类型转换：

　　

public static explicit operator double (Square a)
{
....................
}

4.8  用户定义的数据类型转换

　　我们用实例来具体的进行数据类型的转换，首先我们先建立一个类，Square.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Application29
{
    class Square
    {
        private double Side;
        public Square(int a)
        {
            Console.WriteLine("Int 类型参数构造函数");
            Side = (double)a;
        }
        public Square(double a)
        {
            Console.WriteLine("double类型参数构造函数");
            Side = a;
        }
        //重写object类的Tostring()方法
        public override string ToString()
        {
            Console.WriteLine("重写object类的ToString()方法");
           // return base.ToString();
            return this.Side.ToString();
        }
        //重载“+”操作符,参数为两个Square类
        public static Square operator +(Square x, Square y)
        {
            Console.WriteLine("重载+操作符，参数为两个Square类");
            return new Square(x.Side+y.Side);
        }
        //重载“+”操作符，参数一个为Square类，另外一个为double类型
        public static Square operator +(Square x, double y)
        {
            Console.WriteLine("重载+操作符，参数一个为Square类，另外一个为double类型");
            return new Square(x.Side+y);
        }

        //重载“+”操作符，参数一个为Square类，另一个为int类型
        public static Square operator +(Square x, int y)
        {
            Console.WriteLine("重载+操作符，参数一个为Square类，另一个为double类型");
            return x + (double)y;   //调用上面的重载“+”操作符
        }

        //隐式类型转换，实现double类型转换为Square
        public static implicit operator Square(double s)
        {
            Console.WriteLine("隐式类型转换，实现double类型转换为Square");
            return new Square(s);
        
        }
        //隐式类型转换，实现int类型转换为Square
        public static implicit operator Square(int s)
        {
            Console.WriteLine("隐式类型换换，实现int 类型转换为Square");
            return new Square((double)s);
        }
        //重载“==”操作符
        public static bool operator ==(Square x, Square y)
        {
            Console.WriteLine("重载==操作符，俩个参数都为Square类");
            return x.Side == y.Side;
        }
        //重载“！=”操作符
        public static bool operator !=(Square x, Square y)
        {
            Console.WriteLine("重载！=操作符,两个参数都为square类");
            return !(x==y);   //调用前面的操作符“==”操作符
        }
        //重载“==”和“!=”的同时还要重载object类的GetRashCode()和Equals(),否则编译器会发出警告
        //也可以不重写这两个方法，这时对运行结果没有影响
        public override bool Equals(object o)
        {
            return this == (Square)o;
        }
        public override int GetHashCode()
        {
            return (int)Side;
        }
        //重载“>”操作符
        public static bool operator >(Square x, Square y)
        {
            Console.WriteLine("重载>操作符，这个两个参数都为Squarel类");
            return x.Side > y.Side;
        }
        //重载“<”操作符
        public static bool operator <(Square x, Square y)
        {
            Console.WriteLine("重载<操作符，两个参数都为Square类");
            return x.Side < y.Side;
        }
        //重载“<=”操作符
        public static bool operator <=(Square x, Square y)
        {
            Console.WriteLine("重载<=操作符，两个参数都为Square类");
            return (x < y) || (x == y);  //调用重载操作符“==”和“<”
        }
        //重载“>=”操作符
        public static bool operator >=(Square x, Square y)
        {
            Console.WriteLine("重载>=操作符，两个参数都为Square类");
            return (x > y) || (x == y);  //调用重载操作符“==”和“>”
        }

    }

}

------------------在主程序中执行

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Application29
{
    class Program
    {
        static void Main(string[] args)
        {
            Square s1 = new Square(10);
            Square s2 = new Square(20);
            Square s3 = s1 + s2; //调用operator+(Square,Square)
            Console.WriteLine(s3);//调用重写object类的ToString()方法
            Console.WriteLine(s3 + 15);//调用重写的operator+(Square,int)以及ToString()
            Console.WriteLine(s3 + 1.5);//调用重写operator+(Square,double)和ToString()
            s3=10;  //调用隐式转换public Static implicit operator Square(int )
            Console.WriteLine(s3);
            Square s4 = 10;
            Console.WriteLine(s1==s4);   //调用==操作符
            Console.WriteLine(s1!=s4);  //调用！=操作符
            Console.WriteLine(s1>s2);   //调用>操作符
            Console.WriteLine(s1<s4);   //调用<=操作符

        }
    }
}

执行结果如下：

　分析上面：

　　Square与double和int之间有两个隐式转换，从double以及int的转换过程不会因丢失数据而出现异常，所以采用了隐式转换。

　　Square类默认的基类是Object类，所以可以重载Objcet类的ToString方法。Writeline方法默认的参数为String对象，所以在输出之前要调用ToString方法，将参数转换为String类型。