C#操作符重载

【C#操作符重载】

C#操作符重载是指允许用户使用用户定义的类型编写表达式的能力。

例如，通常需要编写类似于以下内容的代码，以将两个数字相加。很明显，sum 是两个数字之和。

int i = 5;
int sum = i + j;

如果可以使用代表复数的用户定义的类型来编写相同类型的表达式，那当然是最好不过了：

Complex i = 5;
Complex sum = i + j;

运算符重载允许为用户定义的类型重载（即指定明确的含义）诸如“+”这样的运算符。如果不进行重载，则用户需要编写以下代码：

Complex i = new Complex(5);
Complex sum = Complex.Add(i, j);

此代码可以很好地运行，但 Complex 类型并不能象语言中的预定义类型那样发挥作用。

在我看来是操作符重载是让struct、class、Interface等能够进行运算。

如时实现C#操作符重载。

先写关键词public和static，后跟返回类型，后跟operator关键词，后跟要声明的操作符符号，最后在对一对圆括号中添加恰当的参数。

如下例中的struct Hour中的public static Hour operator+ (Hour lhs,Hour rhs){...}

C#操作符重载方法：

1、编写操作符重载方法。

2、实例化后，进行操作符运算

下边用C#操作符重载代码进行说明：

  1. class Program  
  2. {  
  3.      static void Main(string[] args)  
  4.     {  
  5.         Hour hrValue1 = new Hour(10);  
  6.         Hour hrValue2 = new Hour(20);  
  7.  
  8.         //2、得到两个Hour相加结果  
  9.         Hour hrSum = hrValue1 + hrValue2;  
  10.  
  11.         //得到Hour+Int的结果  
  12.         Hour hrSumInt = hrValue1 + 10;  
  13.  
  14.         //得到Int+Hour的结果  
  15.         Hour hrIntSum = 11 + hrValue2;  
  16.         Console.WriteLine("hrValue1 +  hrValue2 = {0}", hrSum.iValue);  
  17.         Console.WriteLine("hrValue1 +  10  = {0}", hrSumInt.iValue);  
  18.         Console.WriteLine("11 +  hrValue2  = {0}", hrIntSum.iValue);  
  19.         Console.ReadKey();  
  20.     }
  21. }  
  22. struct Hour  
  23. {  
  24.      private int value;  
  25.     //此构造函数根据int值创建Hour类 ，C#操作符重载 
  26.     public Hour(int iValue)  
  27.     {  
  28.        this.value = iValue;  
  29.     }  
  30.     //定义一个属性，便于取用value值  
  31.     public int iValue  
  32.     {  
  33.         get 
  34.        {  
  35.             return value;  
  36.        }  
  37.    } //C#操作符重载
  38.    //1、声明一个二元操作符，将两个Hour类加到一起   
  39.    public static Hour operator+ (Hour lhs,Hour rhs)  
  40.    {  
  41.         return new Hour(lhs.value + rhs.value);  
  42.    }  
  43.  
  44.   /*  
  45.   操作符是public的。所有操作符都必须是public的  
  46.  
  47.   操作符是static的。所有操作符都必须是static的，操作永远不具有多态性，  
  48.  
  49.   面且不能使用virtual、abstract、override或者sealed修饰符。  
  50.  
  51.   二元操作符(比如+)有两个显式参数；一元操作符有一个显式的参数  
  52.  
  53.   我们有了public Hour(int iValue)构造函数，就可以将一个int与Hour相加，只是首先要将int转换成为Hour  
  54.  
  55.   hour a= ;  
  56.  
  57.   int b= ;  
  58.  
  59.   Hour sum=a+new Hour(b);  
  60.  
  61.   虽然上述代码完全有效，但相较于让一个Hour和一个int直接相加它即不清晰也不准确。  
  62.  
  63.   为了使Hour可以+ int，必须声明一个二元操作符＋，它的第一个参数是Hour，第二个参数是一个int。  
  64.   C#操作符重载
  65.   */ 
  66.      public static Hour operator+ (Hour lhs,int rhs)  
  67.     {  
  68.          return lhs + new Hour(rhs);  
  69.     }  
  70.    //使一个int 可以＋hour。  
  71.     public static Hour operator +(int lhs, Hour rhs)  
  72.     {  
  73.           return new Hour(lhs)+rhs;  
  74.     }  
  75. } 

C#操作符重载示例2：

  1. struct Hour  
  2. {  
  3.       public int iValue;  
  4.        //构造函数  
  5.      public Hour(int initialValue)  
  6.      {  
  7.         this.iValue = initialValue;  
  8.      }  
  9.      //1、定义操作符重载（一元操作符）  
  10.     public static Hour operator ++ (Hour huValue)  
  11.     {  
  12.         huValue.iValue++;  
  13.         return huValue;  
  14.     }  //C#操作符重载
  15.  
  16.     //==操作符是二元操作符，必须带有两个参数  
  17.    public static bool operator==(Hour lhs,Hour rhs)  
  18.   {  
  19.          return lhs.iValue == rhs.iValue;  
  20.   }  
  21.   public static bool operator!=(Hour lhs,Hour rhs)  
  22.   {  
  23.         return lhs.iValue != rhs.iValue;  
  24.    }  
  25. }  
  26.  
  27. //++操作符有前缀和后缀的形式，C#能智能地为前缀后后缀使用同一个操作符。  
  28.  
  29. static void Main(string[] args)  
  30. {  
  31.      //2、实例化类  ,C#操作符重载
  32.      Hour hu = new Hour(10);  
  33.     //3、  
  34.     //操作符重载  
  35.      hu++;  
  36.     //输出重载后的结果  
  37.     Console.WriteLine("Hu++ = {0}", hu.iValue);  
  38.    //C#操作符重载  
  39.    ++hu;  
  40.    //输出重载后的结果  
  41.  
  42.     Console.WriteLine("Hu++ = {0}", hu.iValue);  
  43.     Console.ReadKey();  
  44. }  
posted @ 2013-10-23 15:05  酷乐公司  阅读(212)  评论(0)  编辑  收藏  举报