C#运算符重载_c# .x .y 运算符重载-CSDN博客

转载地址：https://blog.csdn.net/hucblog/article/details/52924869

运算符重载的概念

提出运算符重载的理念是：用户自定义数据类型,应该像内置类型一样。
运算符重载是多态的一种体现
多态：OOP的一个重要思想，即发出同一个消息被不同的对象接收会导致完全不同的行为

运算符重载的好处

使代码简介优美
提高编码效率
更加符合OOP的思想

运算符重载实例

为什么会说符合OOP思想呢？试想一下，在数学领域，矩阵是可以相加的，和数字一样。代码中，用户自定义的类型(矩阵)不能相加。这就不太符合OOP了。所以应当重载加法运算符。

那么，接下来就模拟矩阵，创建一个矩阵类Vector，它有三个点（x，y，z），将重载加减等于不等于除乘法运算符，最后在重载两个特殊的运算符，true和false

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApplication27
{
    class Program
    {
        static void Main(string[] args)
        {
            Vector v1 = new Vector(12, 14, 18);
            Vector v2 = new Vector(4, 7, 3);
            Vector v3=new Vector(4,4,4);
            if(v3) //演示：true和false的重载
                Console.WriteLine("True");
            else
                Console.WriteLine("False");
            Console.WriteLine("演示：+ 的重载:"+(v1+v2));
            Console.WriteLine("演示：- 的重载:" + (v1 - v2));
            Console.WriteLine("演示：* 重载:" + (v1 * v2));
            Console.WriteLine("演示：/ 重载:" + (v1 / v2));
            Console.WriteLine("演示：== 重载:" + (v1 == v2));
        }
    }
    public class Vector
    {
        public int x { get; set; }
        public int y { get; set; }
        public int z { get; set; }
        public Vector(int x, int y, int z)
        {
            this.x = x;
            this.y = y;
            this.z = z;
        }
        public Vector(Vector rhs)
        {
            this.x = rhs.x;
            this.y = rhs.y;
            this.z = rhs.z;
        }
        public Vector()
        {

        }

        public override string ToString()
        {
            return String.Format("({0},{1},{2})", x, y, z);
        }
        /// <summary>
        /// 重载加号(二元运算符有两个参数)
        /// </summary>
        public static Vector operator +(Vector v1, Vector v2)
        {
            return new Vector() { x = v1.x + v2.x, y = v1.y + v2.y, z = v1.z + v2.z };
        }
        /// <summary>
        /// 重载减号(二元运算符有两个参数)
        /// </summary>
        public static Vector operator -(Vector v1, Vector v2)
        {
            return new Vector() { x = v1.x - v2.x, y = v1.y - v2.y, z = v1.z - v2.z };
        }
        /// <summary>
        /// 重载乘法(二元运算符有两个参数)
        /// </summary>
        public static Vector operator *(Vector v1, Vector v2)
        {
            return new Vector() { x = v1.x * v2.x, y = v1.y * v2.y, z = v1.z * v2.z };
        }
        /// <summary>
        /// 重载除法(二元运算符有两个参数)
        /// </summary>
        public static Vector operator /(Vector v1, Vector v2)
        {
            return new Vector() { x = v1.x / v2.x, y = v1.y / v2.y, z = v1.z / v2.z };
        }
        /// <summary>
        /// 重载等于(等于和不等于需要一起重载，否则编译出错)
        /// </summary>
        public static Boolean operator ==(Vector v1, Vector v2)
        {
            return (v1.x == v2.x && v1.y == v2.y && v1.z == v2.z);
        }
        /// <summary>
        /// 重载不等于(等于和不等于需要一起重载，否则编译出错)
        /// </summary>
        public static Boolean operator !=(Vector v1, Vector v2)
        {
            return !(v1 == v2);
        }
        /// <summary>
        /// 重载tue(true和false必须一起重载)
        /// </summary>
        public static Boolean operator true(Vector v)
        {
            return (v.x == v.y&&v.x == v.z);
        }
        /// <summary>
        /// 重载false(true和false必须一起重载)
        /// </summary>
        public static Boolean operator false(Vector v)
        {
            return !(v.x == v.y && v.x == v.z);
        }
        public override bool Equals(object obj)
        {
            return base.Equals(obj);
        }
        public override int GetHashCode()
        {
            return base.GetHashCode();
        }
    }
}