C#：運算符重載

運算符重載允許為運算指定用戶定義的運算符實現，其中一個或兩個操作數是用戶定義的類或結構類型。用戶定義的運算符實現的優先級總是高於預定義運算符實現：僅當沒有適用的用戶定義運算符實現時才會考慮預定義運算符實現。

運算符	可重載性
+、-、!、~、++、--、true、false	可以重載這些一元運算符。   true和false運算符必須成對重載。
+、-、*、/、%、&、|、^、<<、>>	可以重載這些二元運算符。
==、!=、<、>、<=、>=	可以重載比較運算符。必須成對重載。
&&、||	不能重載條件邏輯運算符。   但可以使用能夠重載的&和|進行計算。
[]	不能重載數組索引運算符，但可以定義索引器。
()	不能重載轉換運算符，但可以定義新的轉換運算符。
+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=	不能顯式重載賦值運算符。   在重寫單個運算符如+、-、%時，它們會被隱式重寫。
=、.、?:、->、new、is、sizeof、typeof	不能重載這些運算符。

 

 下面的例子中Vector結構表示一個三維矢量：

using System;

namespace ConsoleApplication19
{
    class Program
    {
        static void Main(string[] args)
        {
            Vector vect1, vect2, vect3;
            vect1 = new Vector(3.0, 3.0, 1.0);
            vect2 = new Vector(2.0, -4.0, -4.0);
            vect3 = vect1 + vect2;

            Console.WriteLine("vect1=" + vect1.ToString());
            Console.WriteLine("vect2=" + vect2.ToString());
            Console.WriteLine("vect3=" + vect3.ToString());
            Console.ReadLine();
        }
    }

    struct Vector
    {
        public double x, y, z;

        public Vector(double x, double y, double z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }

        public Vector(Vector rhs)
        
        {
            this.x = rhs.x;
            this.y = rhs.y;
            this.z = rhs.z;
        }

        public override string ToString()
        {
            return "(" + x + "," + y + "," + z + ")";
        }

        public static Vector operator +(Vector lhs, Vector rhs)
        {
            Vector result = new Vector(lhs);
            result.x += rhs.x;
            result.y += rhs.y;
            result.z += rhs.z;
            return result;
        }
    }
}

輸出：

• 運算符重載的聲明方式：operator關鍵字告訴編譯器，它實際上是一個運算符重載，后面是相關運算符的符號
• 對於二元運算符，第一個參數是放在運算符左邊的值，一般命名為lhs；第二個參數是放在運算符右邊的值，一般命名為rhs
• C#要求所有的運算符重載都聲明為public和static，這表示它們與它們的類或結構相關聯，而不是與實例相關聯。

添加重載乘法運算符：

        public static Vector operator *(double lhs, Vector rhs)
        {
            return new Vector(lhs * rhs.x, lhs * rhs.y, lhs * rhs.z);
        }

如果a和b聲明為Vector類型，就可以編寫代碼：b=2*a; 編譯器會隱式的把整數2轉換為double類型，但是不能編譯代碼：b=a*2;

 

比較運算符的重載：

• C#要求成對重載比較運算符，如果重載了==，也必須重載！=，否在會產生編譯錯誤。
• 比較運算符必須返回bool類型的值
• 注意：在重載==和！=時，還應該重載從System.Object中繼承的Equals()和GetHashCode()方法，否則會產生一個編譯警告，原因是Equals方法應執行與==運算符相同的相等邏輯。

下面給Vector結構重載==和！=運算符：

        public static bool operator ==(Vector lhs, Vector rhs)
        {
            if (lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public static bool operator !=(Vector lhs, Vector rhs)
        {
            return !(lhs == rhs);
        }

 

重載True和False運算符：

using System;

namespace ConsoleApplication20
{
    class Program
    {
        static void Main(string[] args)
        {
            // 輸出20以內的所有素數
            for (uint i = 2; i <= 20; i++)
            {
                Prime p = new Prime(i);
                if (p)
                { 
                    Console.Write(i + " ");
                }
            }
            Console.ReadLine();
        }
    }

    public struct Prime
    {
        private uint value;
        public Prime(uint value)
        {
            this.value = value;
        }

        public static bool operator true(Prime p)
        {
            return IsPrime(p.value);
        }

        public static bool operator false(Prime p)
        {
            return !(IsPrime(p.value));
        }

        public static bool IsPrime(uint value)
        {
            for (uint i = 2; i <= value / 2; i++)
            {
                if (value % i == 0)
                {
                    return false;
                }
            }
            return true;
        }

        public override string ToString()
        {
            return ("" + value);
        }
    }
}

輸出：

using System;

namespace ConsoleApplication21
{
    class Program
    {
        static void Main(string[] args)
        {
            DBBool b;
            b = DBBool.dbTrue;
            if (b)
            {
                Console.WriteLine("b is definitely true");
            }
            else
            {
                Console.WriteLine("b is not definitely true");
            }
            Console.ReadLine();
        }
    }

    public struct DBBool
    {
        public static readonly DBBool dbNull = new DBBool(0);
        public static readonly DBBool dbFalse = new DBBool(-1);
        public static readonly DBBool dbTrue = new DBBool(1);

        int value;

        DBBool(int value)
        {
            this.value = value;
        }

        public static bool operator true(DBBool x)
        {
            return x.value > 0;
        }

        public static bool operator false(DBBool x)
        {
            return x.value < 0;
        }
    }
}

輸出：