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)