精华内容
下载资源
问答
  • C#运算符重载

    2019-10-04 21:58:13
    一、C#运算符重载 1. C#运算符重载 运算符重载是指允许用户使用自己定义的类型编写运算符号,同时还允许用户定义的类型与预定义的类型具有相同的功能。 重载运算符的目的是方便我们自己的类或结构使用。所有...

    一、C#运算符重载

    1. C#运算符重载

    运算符重载是指允许用户使用自己定义的类型编写运算符号,同时还允许用户定义的类型与预定义的类型具有相同的功能。

    重载运算符的目的是方便我们自己的类或结构使用。所有运算符重载均为类或结构的静态方法。

    因此,在C#语言中,允许用户定义的类型通过使用operator关键字定义成静态成员函数的形式来重载运算符。operator关键字用于在类或结构声明中声明运算符。

    2. 运算符的可重载性

    在C#中,并不是所有的运算符都可以被重载的。下表列出了运算符的可重载性:

    注意:如果重载比较运算符,就必须成对重载;也就是说,如果重载“==”,也必须重载“!=”。反之也是这样。“<”和“>”以及“<=”和“>=”同样如此。

    3. 重载一元运算符

    一元运算符只有一个参数。

    public static return-type operator op(type operand)
    {
        // statement;
    }

    4. 重载二元运算符

    二元运算符有两个参数。

    public static return-type operator op(type operand1, type operand2)
    {
        // statement;
    }

    二、提示
     
    C#运算符重载的声明方式与方法的声明方式相同,但operator关键字告诉编译器,它实际上是一个运算符重载,后面是相关运算符的符号,返回类型是在使用这个运算符时获得的类型。

    C#要求所有的C#运算符重载都声明为public和static,这表示它们与它们的类或结构相关联,而不是与实例相关联所以运算符重载的代码体不能访问非静态成员,也不能访问this标识符。

    三、示例
     
    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;

    namespace Test
    {

      public class ComplexNumber
      {
        private int real;
        private int imaginary;
        public ComplexNumber() : this(0, 0)  // constructor
        {
        }
        public ComplexNumber(int r, int i)  // constructor
        {
          real = r;
          imaginary = i;
        }
        //Override ToString() to display a complex number in the traditional format
        public override string ToString()
        {
          return(System.String.Format("{0} + {1}i", real, imaginary));
        }
        // 重载“+”操作符
        public static ComplexNumber operator+(ComplexNumber a, ComplexNumber b)
        {
          return new ComplexNumber(a.real + b.real, a.imaginary + b.imaginary);
        }
        // 重载“'-”操作符
        public static ComplexNumber operator-(ComplexNumber a, ComplexNumber b)
        {
          return new ComplexNumber(a.real - b.real, a.imaginary - b.imaginary);
        }
      }

      class Program
      {
        static void Main(string[] args)
        {
          // C#运算符重载-www.baike369.com
          ComplexNumber a = new ComplexNumber(10, 12);
          ComplexNumber b = new ComplexNumber(8, 9);
          Console.WriteLine("Complex Number a = {0}", a.ToString());
          Console.WriteLine("Complex Number b = {0}", b.ToString()); 
          ComplexNumber sum = a + b;
          Console.WriteLine("Complex Number sum = {0}", sum.ToString());
          ComplexNumber difference = a - b;
          Console.WriteLine("Complex Number difference = {0}", 
                  difference.ToString());
          Console.ReadLine();
        }
      }
    }

    运行结果:
      
    Complex Number a = 10 + 12i
    Complex Number b = 8 + 9i
    Complex Number sum = 18 + 21i
    Complex Number difference = 2 + 3i

     

     

    C#中,下列操作符都是可以重载的:

    + - ! ~ ++ -- true false

    * / % & | ^ << >> == != > < >= <=

    但也有一些操作符是不允许进行重载的,如:

    =,&&,||,?:,new,typeof,sizeof,is

    转载于:https://www.cnblogs.com/melao2006/p/4239495.html

    展开全文
  • C# 运算符重载

    2016-10-03 12:27:00
    C# 运算符重载 C#运算符重载函数必须是public static的 struct CSTest { public int posx; public static CSTest operator + (CSTest o1, CSTest o2) {//二元运算符重载 CSTest ost...

    C# 运算符重载

    C#运算符重载函数必须是public static

        struct CSTest
        {
            public int posx;
            public static CSTest operator + (CSTest o1, CSTest o2)
            {//二元运算符重载
                CSTest ost = new CSTest();
                ost.posx = o1.posx + o2.posx;
                return ost;
            }
            public static CSTest operator - (CSTest ot)
            {//一元运算符重载
                ot.posx = -ot.posx;
                return ot;
            }
        }

        class Program
        {
            static void Main(string[] args)
            {
                CSTest ostn1 = new CSTest();
                CSTest ostn2 = new CSTest();
                ostn1.posx = 1;
                ostn2.posx = 2;
                CSTest ostn3 = ostn1 + ostn2;
                ostn3 = -ostn3;
                Console.WriteLine(ostn3.posx);
            }
        }

    C++可以对[]进行重载,而C#不可以对方括号重载但是提供了索引器的语法。

    可重载和不可重载运算符

    下表描述了 C# 中运算符重载的能力:

    运算符描述
    +, -, !, ~, ++, -- 这些一元运算符只有一个操作数,且可以被重载。
    +, -, *, /, % 这些二元运算符带有两个操作数,且可以被重载。
    ==, !=, <, >, <=, >= 这些比较运算符可以被重载。
    &&, || 这些条件逻辑运算符不能被直接重载。
    +=, -=, *=, /=, %= 这些赋值运算符不能被重载。
    =, ., ?:, ->, new, is, sizeof, typeof 这些运算符不能被重载。

    posted on 2016-10-03 12:27 时空观察者9号 阅读(...) 评论(...) 编辑 收藏

    展开全文
  • c#运算符重载

    2018-09-06 14:49:00
    C#运算符重载 您可以重定义或重载 C# 中内置的运算符。因此,程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数,是通过关键字operator后跟运算符的符号来定义的。与其他函数一样,重载...

    C# 运算符重载

    您可以重定义或重载 C# 中内置的运算符。因此,程序员也可以使用用户自定义类型的运算符。重载运算符是具有特殊名称的函数,是通过关键字 operator后跟运算符的符号来定义的。与其他函数一样,重载运算符有返回类型和参数列表。

    例如,请看下面的函数:

    public static Box operator+ (Box b, Box c)
    {
       Box box = new Box();
       box.length = b.length + c.length;
       box.breadth = b.breadth + c.breadth;
       box.height = b.height + c.height;
       return box;
    }

    上面的函数为用户自定义的类 Box 实现了加法运算符(+)。它把两个 Box 对象的属性相加,并返回相加后的 Box 对象。

    运算符重载的实现

    下面的程序演示了完整的实现:

    using System;
    
    namespace OperatorOvlApplication
    {
       class Box
       {
          private double length;      // 长度
          private double breadth;     // 宽度
          private double height;      // 高度
    
          public double getVolume()
          {
             return length * breadth * height;
          }
          public void setLength( double len )
          {
             length = len;
          }
    
          public void setBreadth( double bre )
          {
             breadth = bre;
          }
    
          public void setHeight( double hei )
          {
             height = hei;
          }
          // 重载 + 运算符来把两个 Box 对象相加
          public static Box operator+ (Box b, Box c)
          {
             Box box = new Box();
             box.length = b.length + c.length;
             box.breadth = b.breadth + c.breadth;
             box.height = b.height + c.height;
             return box;
          }
    
       }
    
       class Tester
       {
          static void Main(string[] args)
          {
             Box Box1 = new Box();         // 声明 Box1,类型为 Box
             Box Box2 = new Box();         // 声明 Box2,类型为 Box
             Box Box3 = new Box();         // 声明 Box3,类型为 Box
             double volume = 0.0;          // 体积
    
             // Box1 详述
             Box1.setLength(6.0);
             Box1.setBreadth(7.0);
             Box1.setHeight(5.0);
    
             // Box2 详述
             Box2.setLength(12.0);
             Box2.setBreadth(13.0);
             Box2.setHeight(10.0);
    
             // Box1 的体积
             volume = Box1.getVolume();
             Console.WriteLine("Box1 的体积: {0}", volume);
    
             // Box2 的体积
             volume = Box2.getVolume();
             Console.WriteLine("Box2 的体积: {0}", volume);
    
             // 把两个对象相加
             Box3 = Box1 + Box2;
    
             // Box3 的体积
             volume = Box3.getVolume();
             Console.WriteLine("Box3 的体积: {0}", volume);
             Console.ReadKey();
          }
       }
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    Box1 的体积: 210
    Box2 的体积: 1560
    Box3 的体积: 5400

    可重载和不可重载运算符

    下表描述了 C# 中运算符重载的能力:

    实例

    针对上述讨论,让我们扩展上面的实例,重载更多的运算符:

    using System;
    
    namespace OperatorOvlApplication
    {
        class Box
        {
            private double length;      // 长度
            private double breadth;     // 宽度
            private double height;      // 高度
    
            public double getVolume()
            {
                return length * breadth * height;
            }
            public void setLength( double len )
            {
                length = len;
            }
    
            public void setBreadth( double bre )
            {
                breadth = bre;
            }
    
            public void setHeight( double hei )
            {
                height = hei;
            }
            // 重载 + 运算符来把两个 Box 对象相加
            public static Box operator+ (Box b, Box c)
            {
                Box box = new Box();
                box.length = b.length + c.length;
                box.breadth = b.breadth + c.breadth;
                box.height = b.height + c.height;
                return box;
            }
    
            public static bool operator == (Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length == rhs.length && lhs.height == rhs.height
                        && lhs.breadth == rhs.breadth)
                {
                    status = true;
                }
                return status;
            }
            public static bool operator !=(Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length != rhs.length || lhs.height != rhs.height
                        || lhs.breadth != rhs.breadth)
                {
                    status = true;
                }
                return status;
            }
            public static bool operator <(Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length < rhs.length && lhs.height                < rhs.height && lhs.breadth < rhs.breadth)
                {
                    status = true;
                }
                return status;
            }        public static bool operator >(Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length > rhs.length && lhs.height
                        > rhs.height && lhs.breadth > rhs.breadth)
                {
                    status = true;
                }
                return status;
            }
    
            public static bool operator <=(Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length <= rhs.length && lhs.height                <= rhs.height && lhs.breadth <= rhs.breadth)
                {
                    status = true;
                }
                return status;
            }        public static bool operator >=(Box lhs, Box rhs)
            {
                bool status = false;
                if (lhs.length >= rhs.length && lhs.height
                        >= rhs.height && lhs.breadth >= rhs.breadth)
                {
                    status = true;
                }
                return status;
            }
            public override string ToString()
            {
                return String.Format("({0}, {1}, {2})", length, breadth, height);
            }
    
        }
    
        class Tester
        {
            static void Main(string[] args)
            {
                Box Box1 = new Box();          // 声明 Box1,类型为 Box
                Box Box2 = new Box();          // 声明 Box2,类型为 Box
                Box Box3 = new Box();          // 声明 Box3,类型为 Box
                Box Box4 = new Box();
                double volume = 0.0;   // 体积
    
                // Box1 详述
                Box1.setLength(6.0);
                Box1.setBreadth(7.0);
                Box1.setHeight(5.0);
    
                // Box2 详述
                Box2.setLength(12.0);
                Box2.setBreadth(13.0);
                Box2.setHeight(10.0);
    
                // 使用重载的 ToString() 显示两个盒子
                Console.WriteLine("Box1: {0}", Box1.ToString());
                Console.WriteLine("Box2: {0}", Box2.ToString());
    
                // Box1 的体积
                volume = Box1.getVolume();
                Console.WriteLine("Box1 的体积: {0}", volume);
    
                // Box2 的体积
                volume = Box2.getVolume();
                Console.WriteLine("Box2 的体积: {0}", volume);
    
                // 把两个对象相加
                Box3 = Box1 + Box2;
                Console.WriteLine("Box3: {0}", Box3.ToString());
                // Box3 的体积
                volume = Box3.getVolume();
                Console.WriteLine("Box3 的体积: {0}", volume);
    
                //comparing the boxes
                if (Box1 > Box2)
                    Console.WriteLine("Box1 大于 Box2");
                else
                    Console.WriteLine("Box1 不大于 Box2");
                if (Box1 < Box2)           Console.WriteLine("Box1 小于 Box2");
                else           Console.WriteLine("Box1 不小于 Box2");
                if (Box1 >= Box2)
                    Console.WriteLine("Box1 大于等于 Box2");
                else
                    Console.WriteLine("Box1 不大于等于 Box2");
                if (Box1 <= Box2)           Console.WriteLine("Box1 小于等于 Box2");
                else           Console.WriteLine("Box1 不小于等于 Box2");
                if (Box1 != Box2)           Console.WriteLine("Box1 不等于 Box2");
                else           Console.WriteLine("Box1 等于 Box2");
                Box4 = Box3;
                if (Box3 == Box4)           Console.WriteLine("Box3 等于 Box4");
                else           Console.WriteLine("Box3 不等于 Box4");
                Console.ReadKey();
            }
        }
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    Box1: (6, 7, 5)
    Box2: (12, 13, 10)
    Box1 的体积: 210
    Box2 的体积: 1560
    Box3: (18, 20, 15)
    Box3 的体积: 5400
    Box1 不大于 Box2
    Box1 小于 Box2
    Box1 不大于等于 Box2
    Box1 小于等于 Box2
    Box1 不等于 Box2
    Box3 等于 Box4

     

    转载于:https://www.cnblogs.com/wys000/p/9598302.html

    展开全文

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,119
精华内容 447
关键字:

c#运算符重载

c# 订阅