重载

===============================重载操作符==============================

孔羸思想：操作符：引用类型进行算术操作时 如：类
// 重载操作符 ==
  public static bool operator==(Rectangle a,Rectangle b)
  {
    return ((a.Height==b.Height)&&(a.Width==b.Width));
  }

  // 重载操作符 !=
  public static bool operator!=(Rectangle a,Rectangle b)
  {
    return !(a==b);
  }

//><操作符必须一起用
  // 重载操作符 >
  public static bool operator>(Rectangle a,Rectangle b)
  {
    return a.Area>b.Area;
  }

  // 重载操作符 <
  public static bool operator<(Rectangle a,Rectangle b)
  {
    return !(a>b);
  }

  // 重载操作符 >=
  public static bool operator>=(Rectangle a,Rectangle b)
  {
    return (a>b)||(a==b);
  }

  // 重载操作符 <=
  public static bool operator<=(Rectangle a,Rectangle b)
  {
    return (a<b)||(a==b);
  }
----------------------------------------Demo   '+'重载
public class overload_example
    {
        public int number;
       
        public overload_example(int oex)
        {
            number = oex;
        }

        public static overload_example operator +(overload_example obj1,overload_example obj2)
        {
            return new overload_example(obj1.number * obj2.number);//new overload_example:调用上面的一参构造函数
            //return:new overloas_example:返回一个实例，
            //调用一参构造器传给number返回
        }
       
        public override string ToString()
        {
            return (String.Format("", number));
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("这个程序演示了如何对+操作符进行重载的过程");
            Console.WriteLine("===========================================/n");
            overload_example oex1 = new overload_example(100);//number
            overload_example oex2 = new overload_example(200);//number

            overload_example oex3 = oex1 + oex2;//==new over...(oex1 + oex2);//调用+号重载方法
            //==new overload_example(100)+new overload_example(200);
            Console.WriteLine("第一个数字: " + oex1.number);
            Console.WriteLine("第二个数字: " + oex2.number);
            Console.WriteLine("            --------------");
            Console.WriteLine("总和是:     " + oex3.number.ToString());
            Console.ReadLine();
        }
    }
-----------------不同类型的操作符重载
class symmetric_ex
    {
        public int value;

        public symmetric_ex(int initvalue)
        {
            this.value = initvalue;
        }

        public static symmetric_ex operator +(symmetric_ex obj1, symmetric_ex obj2)
        {
            return new symmetric_ex(obj1.value+obj2.value);
        }

        public static symmetric_ex operator +(symmetric_ex obj1, int obj2)
        {
            return obj1 + new symmetric_ex(obj2);
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            symmetric_ex obj1 = new symmetric_ex(100);//obj1.value=100
            symmetric_ex obj2 = new symmetric_ex(200);//obj1.value=200
            symmetric_ex obj3 = new symmetric_ex(300);//obj1.value=300

            int num = 400;

            Console.WriteLine("相同类型的操作符");
            obj3.value = obj1.value + obj2.value;
            Console.WriteLine("obj1's value is:{0}/n,obj2's value is:{1}/n,obj3's first value is:{2}/n",obj1.value.ToString(),obj2.value.ToString(),obj3.value.ToString());

            Console.WriteLine("不同类型的操作符，操作符重载之前会自动转换");
            obj3 = obj1 + num;
            Console.WriteLine("obj1's value is:{0}/n,obj3's second value is:{1}/n",obj1.value.ToString(),obj3.value.ToString());

            Console.ReadLine();
        }
    }
-------------------------------------++  --操作符重载
class Increment_Decrement
    {
        public int value;

        public Increment_Decrement(int args)
        {
            this.value = args;
        }

        public static Increment_Decrement operator ++(Increment_Decrement args)
        {
            args.value = args.value + 2;
            return args;
        }

        public static Increment_Decrement operator --(Increment_Decrement args)
        {
            args.value = args.value - 2;
            return args;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Increment_Decrement iargs = new Increment_Decrement(20);

            Console.WriteLine("按照递增重载后的定义，每次递增的增量为2");

            for (int i = 0; i < iargs.value; i++)
            {
                if (iargs.value < 50)
                {
                    iargs++;
                    Console.WriteLine("iargs's value is:{0}", iargs.value.ToString());
                }
            }

            Console.WriteLine("--------------------------------");

            Console.WriteLine("按照递减重载后的定义，每次递减的减量为2");
            for (int i = 50; i > 0; i--)
            {
                if (iargs.value > 0)
                {
                    iargs--;
                    Console.WriteLine("iargs's value is:{0}", iargs.value.ToString());
                }
            }
        }
    }
--------------------------------< < ==  !=
class pair
    {
        public int value;

        public pair(int initvalue)
        {
            this.value = initvalue;
        }

        //改变了操作符原有的含义
        public static bool operator ==(pair lValue, pair rValue)//传递的是值比较，类变量
        {   //return :bool 
            return lValue.value != rValue.value;//true返回true  所以调用处:下面的if条件为true 执行if内
        }

        public static bool operator !=(pair lValue, pair rValue)
        {
            return lValue.value == rValue.value;//true  返回true
        }

        //改变了一对操作符原有的含义，现在与原来的含义相反
        public static bool operator >(pair lValue, pair rValue)
        {
                return lValue.value < rValue.value;
        }

        public static bool operator <(pair lValue, pair rValue)
        {
                return lValue.value > rValue.value;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            pair lhs = new pair(100);//lhs.value=100
            pair rhs = new pair(300);//rhs.value=300

            Console.WriteLine("重载第一对操作符==和!=");
            //此时，lhs与rhs实际上是不相等的，所以条件语句为true
            if (lhs == rhs)
            {
                Console.WriteLine("OK, result is right");
            }
            else
            {
                Console.WriteLine("如果你看到这一步,意味着重载操作符"=="并没有成功");
            }

            Console.WriteLine("--------------------");
            Console.WriteLine("重载第二对操作符>和<");
            //此时,lhs是小于rhs，所以根据重载后的操作符定义，条件语句为true
            if (lhs > rhs)
            {
                Console.WriteLine("OK, override is working");
            }
            else if (lhs < rhs)//>除外，<=中的<
            {
                Console.WriteLine("如果你看到这一步,意味着重载操作符>并没有成功");
            }
            else
            {
                Console.WriteLine("重载操作符都没有成功");
            }

            Console.ReadLine();
        }
    }

==============================重载ToString

  public override String ToString()
  {
    return "高=" + Height + ",宽=" + Width;
  }