【c#学习笔记十二】运算符重载

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

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

 

 

operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一:

  • public static result-type operator unary-operator ( op-type operand )
  • public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )
  • public static implicit operator conv-type-out ( conv-type-in operand )
  • public static explicit operator conv-type-out ( conv-type-in operand )

 

参数说明:

result-type:运算符的结果类型。
unary-operator:下列运算符之一:+ – ! ~ ++ — true false
op-type:第一个(或唯一一个)参数的类型。
operand:第一个(或唯一一个)参数的名称。
binary-operator:其中一个:+ – * / % & | ^ << >> == != > < >= <=
op-type2:第二个参数的类型。
operand2:第二个参数的名称。
conv-type-out:类型转换运算符的目标类型。
conv-type-in:类型转换运算符的输入类型。

注意:

1、运算符重载的声明方式:operator 关键字告诉编译器,它实际上是一个运算符重载,后面是相关运算符的符号。

2、运算符只能采用值参数,不能采用ref或out参数。可参考注意事项一实例。

3、前两种形式声明了用户定义的重载内置运算符的运算符。op-type 和 op-type2 中至少有一个必须是封闭类型(即运算符所属的类型,或理解为自定义的类型)。例如,这将防止重定义整数加法运算符。可参考注意事项二实例。

4、后两种形式声明了转换运算符。conv-type-in 和 conv-type-out 中正好有一个必须是封闭类型(即转换运算符只能从它的封闭类型转换为其他某个类型,或从其他某个类型转换为它的封闭类型)。

5、对于二元运算符,第一个参数是放在运算符左边的值,一般命名为lhs;第二个参数是放在运算符右边的值,一般命名为rhs。

6、C#要求所有的运算符重载都声明为publicstatic,必须是类的静态方法,这表示它们与它们的类或结构相关联,而不是与实例相关联


下面的例子中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;
         }
     }
 }

输出:

发表评论

电子邮件地址不会被公开。 必填项已用*标注