C#运算符重载

运算符重载允许为运算指定用户定义的运算符实现，其中一个或两个操作数是用户定义的类或结构类型。用户定义的运算符实现的优先级总是高于预定义运算符实现：仅当没有适用的用户定义运算符实现时才会考虑预定义运算符实现。

运算符	可重载性
+、-、!、~、++、--、true、false	可以重载这些一元运算符。   true和false运算符必须成对重载。
+、-、*、/、%、&、|、^、<<、>>	可以重载这些二元运算符。
==、!=、<、>、<=、>=	可以重载比较运算符。必须成对重载。
&&、||	不能重载条件逻辑运算符。   但可以使用能够重载的&和|进行计算。
[]	不能重载数组索引运算符，但可以定义索引器。
()	不能重载转换运算符，但可以定义新的转换运算符。
+=、-=、*=、/=、%=、&=、|=、^=、<<=、>>=	不能显式重载赋值运算符。   在重写单个运算符如+、-、%时，它们会被隐式重写。
=、.、?:、->、new、is、sizeof、typeof	不能重载这些运算符。

//-------------------------------------------------------------------------------------------------------------------------

可以重载的运算符：
可以重载的一元运算符：+、-、!、~、++、--、true 和 false
可以重载的二进制运算符：+, -, *, /, %, &, |, ^, <<, >>
可以重载的比较运算符：==, !=, <, >, <=, >=

不能重载的运算符：
&&, || 条件逻辑运算符不能重载，但可使用能够重载的 & 和 | 进行计算。
[]不能重载数组索引运算符，但可定义索引器。
()不能重载转换运算符，但可定义新的转换运算符（请参见 explicit 和 implicit）。
+=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=赋值运算符不能重载，但 += 可使用 + 计算
=、.、?:、->、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;
        }
    }
}

 

输出：