運算符重載

基本概念

• 我們可以重定義或重載 C# 中內(nèi)置的運算符
• 可以使用用戶自定義類型的運算符
• 重載運算符是具有 特殊名稱的函數(shù) ，是通過關鍵字 ** operator **后跟運算符的符號來定義的
• 與其他函數(shù)一樣，重載運算符有****返回類型和參數(shù)列表
• 使用 operator 關鍵字來聲明運算符。 運算符聲明必須符合以下規(guī)則
  • 同時包含 public 和 static 修飾符
  • 一元運算符有一個輸入?yún)?shù)，二元運算符有兩個輸入?yún)?shù)
• **語法示例： 正面的class 表示用戶自定義的類，以下是重載 + **

public static Class operator+ (Class a, Class b)

使用案例

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Car car1 = new Car();
            car1.length=2;
            car1.speed = 120;


            Car car2 = new Car();
            car2.length = 3;
            car2.speed = 90;
            // 將兩個car對象相加
            Car c3 = car1 + car2;
            Console.WriteLine(c3);  // output: length:5,speed:210
        }
    }




    public class Car
    {
        /// 

        /// 長度
        /// 
        public int length;
        /// 

        /// 速度
        /// 
        public int speed;


        // 重載 對象的 +
        public static Car operator +(Car c1, Car c2)
        {
            Car c3 = new Car();
            c3.length = c1.length + c2.length;
            c3.speed = c1.speed + c2.speed;
            return c3;
        }


        // 重寫tostring方法，方便打印對象信息
        public override string ToString()
        {
            return string.Format("length:{0},speed:{1}", this.length, this.speed);
        }


    }
}

**如果不使用重載也想要達成以上效果，作法如下：

**

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Car car1 = new Car();
            car1.length=2;
            car1.speed = 120;


            Car car2 = new Car();
            car2.length = 3;
            car2.speed = 90;

            // 將兩個car對象相加
            Car car3 = new Car();
            car3.length = car1.length + car2.length;
            car3.speed = car1.speed + car2.speed;
            Console.WriteLine(car3);  // output: length:5,speed:210
        }
    }




    public class Car
    {
        /// 

        /// 長度
        /// 
        public int length;
        /// 

        /// 速度
        /// 
        public int speed;


        // 重載 對象的 +
        public static Car operator +(Car c1, Car c2)
        {
            Car c3 = new Car();
            c3.length = c1.length + c2.length;
            c3.speed = c1.speed + c2.speed;
            return c3;
        }


        // 重寫tostring方法，方便打印對象信息
        public override string ToString()
        {
            return string.Format("length:{0},speed:{1}", this.length, this.speed);
        }


    }
}

可以看到效果，如果不重載運算符，則需要在外面調(diào)用時 自己去計算，以上只有一處調(diào)用，是否重載無所謂，但是如果 調(diào)用的地方多了，每個調(diào)用的地方都得寫此邏輯就太麻煩了，所以用好運算符重載還是很好用的

重載多個運算符實現(xiàn)

using System;


namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            Car car1 = new Car();
            car1.length = 2;
            car1.speed = 120;
            // 利用重載的 true/false 運算符
            if (car1)
            {
                Console.WriteLine(car1);  // output: length:2,speed:120
            }



            Car car2 = new Car();
            car2.length = 3;
            car2.speed = 90;
            // 將兩個car對象相加
            Car c3 = car1 + car2;
            Console.WriteLine(c3);  // output: length:5,speed:210


            // 相減
            c3 = car1 - car2;
            Console.WriteLine(c3);  // output: length:-1,speed:30


            // 比較
            if (car1 != car2)
            {
                Console.WriteLine("我們不相等");
            }


        }
    }




    public class Car
    {
        /// 

        /// 長度
        /// 
        public int length;
        /// 

        /// 速度
        /// 
        public int speed;


        // 重載 對象的 +
        public static Car operator +(Car c1, Car c2)
        {
            Car c3 = new Car();
            c3.length = c1.length + c2.length;
            c3.speed = c1.speed + c2.speed;
            return c3;
        }


        // 重載 對象的 -
        public static Car operator -(Car c1, Car c2)
        {
            Car c3 = new Car();
            c3.length = c1.length - c2.length;
            c3.speed = c1.speed - c2.speed;
            return c3;
        }


        // 重載 對象的 ==, 注 == 和 != 是一對的，重寫了一個，兩個就都必須重寫
        public static bool operator ==(Car c1, Car c2)
        {
            return c1.length == c2.length && c1.speed == c2.speed;
        }


        // 重載 對象的 !=
        public static bool operator !=(Car c1, Car c2)
        {
            return c1.length != c2.length || c1.speed != c2.speed;
        }


        // 重載 對象的 true，  true和false也是一對
        public static bool operator true(Car c1)
        {
            return c1.length != 0  || c1.speed != 0;
        }


        // 重載 對象的 false
        public static bool operator false(Car c1)
        {
            return c1.length == 0 && c1.speed == 0;
        }


        // 重寫tostring方法，方便打印對象信息
        public override string ToString()
        {
            return string.Format("length:{0},speed:{1}", this.length, this.speed);
        }


    }
}

可重載和不可重載的運算****符