C#基本語法學習（四）

重載

　　一個方法的名字和方法的參數列表稱為方法的簽名。C#根據方法簽名來識別方法，如果兩個方法簽名不同那麼他們就是兩個不同的方法。

　　重載可以是方法重載（包括構造函數重載）和運算符重載。方法重載指的是一組名字相同而參數列表不同的方法。但方法的返回值類型不同不能構成重載。

 public static int max(int a, int b)
 {
 
 }
 
 public static int max(int a, int b, int c)
 {
 
 }

　　C#中除了方法可以重載，運算符（+、-、*）也可以被重載。運算符重載允許一個類或者結構支持某種運算符運算。當然也可以用方法實現與運算符重載相同的功能，但在某些情況下，使用運算符重載比使用方法更符合人們日常的方式和習慣。

　　運算符重載語法如下：

　　public static 返回類型 operator 運算符（參數列表）

　　{

　　　　//運算過程代碼

　　}

　　在運算符重載定義語法中public、static和operator是固定的，必須在運算符重載定義中出現，public和static表示這個方法是公共的和靜態的，operator表示這是一個運算符重載方法。參數列表個數與具體運算符對應。

　　還有一種特殊的運算符重載，叫做類型轉換運算符重載。語法如下：

　　public static explicit|implicit operator 轉換目的類型（參數）

　　參數為待轉換的數據，轉換目的類型為想要得到的轉換後的數據類型，explicit表示轉換必須為顯示轉換，implicit表示轉換可以是隱式轉換。

　　如下一維向量重載“+”和類型轉換：

 namespace OperatorOverload
 {
        //一維向量 
     class Vector
     {
         private int _rank = 0;
         public int rank
         {
             get { return _rank; }
         }
 
         private double[] _values;
         public double[] values
         {
             get { return _values; }
         }
 
         public Vector(int n)
         {
             _rank = n;
             _values = new double[n];
         }
 
         public Vector(double[] doubleArray)
         {
             _rank = doubleArray.Length;
             _values = doubleArray;
         }
         
         //+重載
         public static Vector operator +(Vector a, Vector b)
         {
             if (a.rank == 0 || b.rank == 0)
                 return null;
 
             //向量秩不相等無法相加
             if (a.rank != b.rank)
                 return null;
 
             double[] sum = new double[a.rank];
             double[] valuesa = a.values;
             double[] valuesb = b.values;
 
             for (int i = 0; i < a.rank; i++)
             {
                 sum[i] = valuesa[i] + valuesb[i];
             }
 
             Vector result = new Vector(sum);
 
             return result;
         }
 
         //類型轉換重載
         public static explicit operator double[](Vector v)
         {
             return v.values;
         }
 
         public static explicit operator Vector(double[] array)
         {
             return new Vector(array);
         }
 
         //重寫ToString方法
         public override string ToString()
         {
             string result = "(";
             for (int i = 0; i < _rank - 1; i++)
             {
                 result += _values[i].ToString() + ", ";
             }
             result += _values[_rank - 1] + ")";
 
             return result;
         }
     }
 }
 
 namespace OperatorOverload
 {
     class Program
     {
         static void Main(string[] args)
         {
             Vector a, b, c;
 
             a = new Vector(new double[] { 11.1, 12.1, 13.1, 14.1, 15.1 });
             b = new Vector(new double[] {22.2, 32.2, 33.2, 34.2, 35.2});
             c = a + b;
             Console.WriteLine("Vector a=" + a.ToString());
             Console.WriteLine("Vector b=" + b.ToString());
             Console.WriteLine("Vector a+b=" + c.ToString());
 
             double[] array = new double[] { 1, 2, 3, 4, 5 };
             Vector d = (Vector)array;
 
             Console.WriteLine("array-->Vector: " + d.ToString());
 
             Console.ReadLine();
         }
     }
 }

 運行結果

Vector a=(11.1, 12.1, 13.1, 14.1, 15.1)
Vector b=(22.2, 32.2, 33.2, 34.2, 35.2)
Vector a+b=(33.3, 44.3, 46.3, 48.3, 50.3)
array-->Vector: (1, 2, 3, 4, 5)