C# 程序员参考--运算符重载教学文章

 本教程演示用户定义的类如何重载运算符。

示例文件

请参见“运算符重载”示例以下载和生成本教程中讨论的示例文件。
教程

运算符重载允许为运算指定用户定义的运算符实现，其中一个或两个操作数是用户定义的类或结构类型。本教程包含两个示例。第一个示例展示如何使用运算符重载创建定义复数加法的复数类。第二个示例展示如何使用运算符重载实现三值的逻辑类型。

示例 1

本示例展示如何使用运算符重载创建定义复数加法的复数类 Complex。本程序使用 ToString方法的重载显示数字的虚部和实部以及加法结果。

// complex.cs



using System;







public struct Complex 



{



   public int real;



   public int imaginary;







   public Complex(int real, int imaginary) 



   {



      this.real = real;



      this.imaginary = imaginary;



   }







   // Declare which operator to overload (+), the types 



   // that can be added (two Complex objects), and the 



   // return type (Complex):



   public static Complex operator +(Complex c1, Complex c2) 



   {



      return new Complex(c1.real + c2.real, c1.imaginary + c2.imaginary);



   }



   // Override the ToString method to display an complex number in the suitable format:



   public override string ToString()



   {



      return(String.Format("{0} + {1}i", real, imaginary));



   }







   public static void Main() 



   {



      Complex num1 = new Complex(2,3);



      Complex num2 = new Complex(3,4);







      // Add two Complex objects (num1 and num2) through the



      // overloaded plus operator:



      Complex sum = num1 + num2;







     // Print the numbers and the sum using the overriden ToString method:



      Console.WriteLine("First complex number:  {0}",num1);



      Console.WriteLine("Second complex number: {0}",num2);



      Console.WriteLine("The sum of the two numbers: {0}",sum);



 



   }



}

输出

First complex number:  2 + 3i



Second complex number: 3 + 4i



The sum of the two numbers: 5 + 7i

示例 2

本示例展示如何使用运算符重载实现三值的逻辑类型。该类型的可能值有DBBool.dbTrue、DBBool.dbFalse 和 DBBool.dbNull，其中 dbNull 成员表示未知值。

注意   定义 True 和 False 运算符只对表示 True、False 和 Null（既非 True 也非 False）的类型有用，如数据库中使用的类型。

// dbbool.cs



using System;







public struct DBBool



{



   // The three possible DBBool values:



   public static readonly DBBool dbNull = new DBBool(0);



   public static readonly DBBool dbFalse = new DBBool(-1);



   public static readonly DBBool dbTrue = new DBBool(1);



   // Private field that stores -1, 0, 1 for dbFalse, dbNull, dbTrue:



   int value; 







   // Private constructor. The value parameter must be -1, 0, or 1:



   DBBool(int value) 



   {



      this.value = value;



   }







   // Implicit conversion from bool to DBBool. Maps true to 



   // DBBool.dbTrue and false to DBBool.dbFalse:



   public static implicit operator DBBool(bool x) 



   {



      return x? dbTrue: dbFalse;



   }







   // Explicit conversion from DBBool to bool. Throws an 



   // exception if the given DBBool is dbNull, otherwise returns



   // true or false:



   public static explicit operator bool(DBBool x) 



   {



      if (x.value == 0) throw new InvalidOperationException();



      return x.value > 0;



   }







   // Equality operator. Returns dbNull if either operand is dbNull, 



   // otherwise returns dbTrue or dbFalse:



   public static DBBool operator ==(DBBool x, DBBool y) 



   {



      if (x.value == 0 || y.value == 0) return dbNull;



      return x.value == y.value? dbTrue: dbFalse;



   }






 
[1] [2] 下一页  

	

  





                              

                              

                                

                                  

                                    

 

                                

                              

                            

                              



  

    

	
   // Inequality operator. Returns dbNull if either operand is



   // dbNull, otherwise returns dbTrue or dbFalse:



   public static DBBool operator !=(DBBool x, DBBool y) 



   {



      if (x.value == 0 || y.value == 0) return dbNull;



      return x.value != y.value? dbTrue: dbFalse;



   }







   // Logical negation operator. Returns dbTrue if the operand is 



   // dbFalse, dbNull if the operand is dbNull, or dbFalse if the



   // operand is dbTrue:



   public static DBBool operator !(DBBool x) 



   {



      return new DBBool(-x.value);



   }







   // Logical AND operator. Returns dbFalse if either operand is 



   // dbFalse, dbNull if either operand is dbNull, otherwise dbTrue:



   public static DBBool operator &(DBBool x, DBBool y) 



   {



      return new DBBool(x.value < y.value? x.value: y.value);



   }







   // Logical OR operator. Returns dbTrue if either operand is 



   // dbTrue, dbNull if either operand is dbNull, otherwise dbFalse:



   public static DBBool operator |(DBBool x, DBBool y) 



   {



      return new DBBool(x.value > y.value? x.value: y.value);



   }







   // Definitely true operator. Returns true if the operand is 



   // dbTrue, false otherwise:



   public static bool operator true(DBBool x) 



   {



      return x.value > 0;



   }







   // Definitely false operator. Returns true if the operand is 



   // dbFalse, false otherwise:



   public static bool operator false(DBBool x) 



   {



      return x.value < 0;



   }







   // Overload the conversion from DBBool to string:



   public static implicit operator string(DBBool x) 



   {



      return x.value > 0 ? "dbTrue"



           : x.value < 0 ? "dbFalse"



           : "dbNull";



   }







   // Override the Object.Equals(object o) method:



   public override bool Equals(object o) 



   {



      try 



      {



         return (bool) (this == (DBBool) o);



      }



      catch 



      {



         return false;



      }



   }







   // Override the Object.GetHashCode() method:



   public override int GetHashCode() 



   {



      return value;



   }







   // Override the ToString method to convert DBBool to a string:



   public override string ToString() 



   {



      switch (value) 



      {



         case -1:



            return "DBBool.False";



         case 0:



            return "DBBool.Null";



         case 1:



            return "DBBool.True";



         default:



            throw new InvalidOperationException();



      }



   }



}







class Test 



{



   static void Main() 



   {



      DBBool a, b;



      a = DBBool.dbTrue;



      b = DBBool.dbNull;







      Console.WriteLine( "!{0} = {1}", a, !a);



      Console.WriteLine( "!{0} = {1}", b, !b);



      Console.WriteLine( "{0} & {1} = {2}", a, b, a & b);



      Console.WriteLine( "{0} | {1} = {2}", a, b, a | b);



      // Invoke the true operator to determine the Boolean 



      // value of the DBBool variable:



      if (b)



         Console.WriteLine("b is definitely true");



      else



         Console.WriteLine("b is not definitely true");   



   }



}

输出

!DBBool.True = DBBool.False



!DBBool.Null = DBBool.Null



DBBool.True & DBBool.Null = DBBool.Null



DBBool.True | DBBool.Null = DBBool.True



b is not definitely true
 

上一页  [1] [2]