当前位置: 澳门新濠3559 > 编程 > 正文

它实现了对私有类域的受控访问,/也可以重载

时间:2019-11-29 05:49来源:编程
注意: implicit implicit 它实现了对私有类域的受控访问,/也可以重载。 关键字用于声明隐式的用户定义类型转换运算符。 static implicit operator target_type { source_type identifier } 注意: 隐式转

  注意:

implicit

implicit它实现了对私有类域的受控访问,/也可以重载。 关键字用于声明隐式的用户定义类型转换运算符。

static implicit operator target_type { source_type identifier }
注意:
  1. 隐式转换可以通过消除不必要的类型转换来提高源代码的可读性。但是,因为可以在程序员未指定的情况下发生隐式转换,因此必须注意防止令人不愉快的后果。一般情况下,隐式转换运算符应当从不引发异常并且从不丢失信息,以便可以在程序员不知晓的情况下安全使用它们。如果转换运算符不能满足那些条件,则应将其标记为
    explicit。

示例:

以下是一个综合示例,简要展示用法。如要更具体细节的了解,请参阅MSDN Library。

//
keywords_operator.cs
// keywords_operator.cs

using System;

namespace Hunts.Keywords
{
    // 定义一个人民币结构。数据类型转换的语法对于结构和类是一样的
    public struct RMB
    {
        // 注意:这些数的范围可能不能满足实际中的使用
        public uint Yuan;
        public uint Jiao;
        public uint Fen;

        public RMB(uint yuan, uint jiao, uint fen)
        {
            if (fen > 9)
            {
                jiao += fen / 10;
                fen = fen % 10;
            }
            if (jiao > 9)
            {
                yuan += jiao / 10;
                jiao = jiao % 10;
            }
            this.Yuan = yuan;
            this.Jiao = jiao;
            this.Fen = fen;
        }

        public override string ToString()
        {
            return string.Format("¥{0}元{1}角{2}分", Yuan, Jiao, Fen);
        }

        // 一些操作
        public static RMB operator +(RMB rmb1, RMB rmb2)
        {
            return new RMB(rmb1.Yuan + rmb2.Yuan, rmb1.Jiao + rmb2.Jiao, rmb1.Fen + rmb2.Fen);
        }

        public static implicit operator float(RMB rmb)
        {
            return rmb.Yuan + (rmb.Jiao/10.0f) + (rmb.Fen/100.00f);
        }

        public static explicit operator RMB(float f)
        {
            uint yuan = (uint)f;
            uint jiao = (uint)((f - yuan) * 10);
            uint fen = (uint)(((f - yuan) * 100) % 10);
            return new RMB(yuan, jiao, fen);
        }

        // more
    }
    class App
    {
        static void Main()
        {
            RMB r1, r2, r3, r4;

            // 记得小学时的某次捐款,我把口袋里藏好的一块钱加6张一毛钱以及13个一分钱的硬币都贡献出去了:(
            r1 = new RMB(1, 6, 13);
            // 其实当时其他人都已经交过了,他们总共交了:
            r2 = new RMB(46, 9, 3);
            // 那么加上我的就是:
            r3 = r1 + r2;
            Console.WriteLine("r3 = {0}", r3.ToString());

            // 隐式转换
            float f = r3;
            Console.WriteLine("float f= {0}", f);

            // 显式转换
            r4 = (RMB)f;
            Console.WriteLine("r4 = {0}", r4.ToString());
            //如果不进行显示转换,将出现错误 CS0266: 无法将类型“float”隐式转换为“Hunts.Keywords.RMB”。存在一个显式转换(是否缺少强制转换?)

            Console.Read();
        }
    }
}

/* style="color: #008000;">
控制台输出:
r3 = ¥48元6角6分
float f = 48.66
r4 = ¥48元6角5分
*/

我们会发现r4结果少了一分钱!这是因为在:

uint style="color: #000000;"> fen style="color: #000000;">= (uint style="color: #000000;">)(((f style="color: #000000;">- yuan) * style="color: #000000;">100) % style="color: #000000;">10 style="color: #000000;">);

这句中,在将float转换为uint时发生了圆整错误(这与计算机以二进制存储有关)。解决这个错误,我们可以使用System.Convert类中用于处理数字的静态方法:

uint style="color: #000000;"> fen style="color: #000000;">= Convert.ToUInt32(((f style="color: #000000;">- yuan) * style="color: #000000;">100) % style="color: #000000;">10 style="color: #000000;">);

不过使用System.Convert处理会有些性能的损失。

 

 

本文转载自 C#澳门新濠3559, 参考之转换关键字:operator、explicit与implicit

 

索引器的定义:

  d、C# 不允许重载=运算符,但如果重载例如+运算符,编译器会自动使用+运算符的重载来执行+=运算符的操作。

explicit

explicit 关键字用于声明必须使用强制转换来调用的用户定义的类型转换运算符。

static explicit operator target_type { source_type identifier }

 

参数:

 

  1. target_type 目标类型
  2. source_type 源类型。
  3. identifier Something。

 

注意:

 

  1. 转换运算符将源类型转换为目标类型。源类型提供转换运算符。与隐式转换不同,必须通过强制转换的方式来调用显式转换运算符。如果转换操作可能导致异常或丢失信息,则应将其标记为
    explicit。这可以防止编译器无提示地调用可能产生无法预见后果的转换操作。

澳门新濠3559 1澳门新濠3559 2Code
using System;
using System.Collections.Generic;

编译"运算符重载实例一"将产生错误,错误信息:二元运算符的参数之一必须是包含类型。这里的错误跟我们上面的"注意事项二实例"的错误大同小异,因为在Teacher类中,他不知道Student是什么,只有Student自己知道。只有Student才能决定自己能不能"+-",而不能让别人决定。operator

operator

operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一:

  1. public static result-type operator unary-operator ( op-type operand )

  2. public static result-type operator binary-operator (

        op-type operand,
        op-type2 operand2
        )
    
  3. public static implicit operator conv-type-out ( conv-type-in operand )

  4. public static explicit operator conv-type-out ( conv-type-in operand )

参数:

  1. result-type 运算符的结果类型。
  2. unary-operator 下列运算符之一:+ - ! ~ ++ — true false
  3. op-type 第一个(或唯一一个)参数的类型。
  4. operand 第一个(或唯一一个)参数的名称。
  5. binary-operator 其中一个:+ - * / % & | ^ << >> == != > <
    >= <=
  6. op-type2 第二个参数的类型。
  7. operand2 第二个参数的名称。
  8. conv-type-out 类型转换运算符的目标类型。
  9. conv-type-in 类型转换运算符的输入类型。

注意:

  1. 前两种形式声明了用户定义的重载内置运算符的运算符。并非所有内置运算符都可以被重载(请参见可重载的运算符)。op-type 和 op-type2
    中至少有一个必须是封闭类型(即运算符所属的类型,或理解为自定义的类型)。例如,这将防止重定义整数加法运算符。
  2. 后两种形式声明了转换运算符。conv-type-in 和 conv-type-out
    中正好有一个必须是封闭类型(即,转换运算符只能从它的封闭类型转换为其他某个类型,或从其他某个类型转换为它的封闭类型)。
  3. 运算符只能采用值参数,不能采用 ref 或 out 参数。
  4. C# 要求成对重载比较运算符。如果重载了==,则也必须重载!=,否则产生编译错误。同时,比较运算符必须返回bool类型的值,这是与其他算术运算符的根本区别。
  5. C# 不允许重载=运算符,但如果重载例如+运算符,编译器会自动使用+运算符的重载来执行+=运算符的操作。
  6. 运算符重载的其实就是函数重载。首先通过指定的运算表达式调用对应的运算符函数,然后再将运算对象转化为运算符函数的实参,接着根据实参的类型来确定需要调用的函数的重载,这个过程是由编译器完成。
  7. 任何运算符声明的前面都可以有一个可选的属性(C# 编程指南)列表。

        for (int i = 0; i < student.listStudents.Count; i++)
        {
            Console.WriteLine("student number:" + student[i].Sid + ",name:" + student[i].Name + ",score:" + student[i].Score);
        }

  4、后两种形式声明了转换运算符。conv-type-in 和 conv-type-out 中正好有一个必须是封闭类型(即转换运算符只能从它的封闭类型转换为其他某个类型,或从其他某个类型转换为它的封闭类型)。

        //设置索引器的值
        student[0].Name = "jeff";
        Console.WriteLine("After modified,all the students:");
        for (int i = 0; i < num; i++)
        {
            Console.WriteLine(student[i].Name); 
        }

  3、前两种形式声明了用户定义的重载内置运算符的运算符。op-type 和 op-type2 中至少有一个必须是封闭类型(即运算符所属的类型,或理解为自定义的类型)。例如,这将防止重定义整数加法运算符。可参考注意事项二实例。

public class Student
{
    private string name;
    /// <summary>
    /// 定义学生的姓名属性
    /// </summary>
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

public ActionResult Index()
        {
            string message = string.Empty;
            Student stuA = new Student(1, 18, "晓菜鸟");
            Student stuB = new Student(2, 21, "博客园");
            Student stuC = new Student(1, 23, "攻城狮");
            message = stuA.Name + (stuA == stuC ? "是" : "不是") + stuC.Name + "<br />";
            message += stuA.Name + (stuA != stuB ? "不是" : "是") + stuB.Name + "<br />";
            Student stuSum = stuA + stuC;
            Student stuDiffe = stuA - stuB;
            message += stuSum.Name + "的年龄总和为:" + stuSum.Age + "<br />";
            message += stuDiffe.Name + "的年龄差为:" + stuDiffe.Age + "<br />";
            message += stuA;
            ViewData.Model = message;
            return View();
        }
    }

    public class Student
    {
        public int Id { get; set; }
        public int Age { get; set; }
        public string Name { get; set; }

        public Student()
        { }

        public Student(int id,int age, string name)
        {
            this.Id = id;
            this.Age = age;
            this.Name = name;
        }

        //重载运算符"+",计算两个学生的年龄总和.
        public static Student operator +(Student lhs, Student rhs)
        {
            return new Student(0, lhs.Age + rhs.Age, lhs.Name + " 和 " + rhs.Name);
        }

        //重载运算符"-",计算两个学生的年龄差.
        public static Student operator -(Student lhs, Student rhs)
        {
            return new Student(0, Math.Abs(lhs.Age - rhs.Age), lhs.Name + " 和 " + rhs.Name);
        }

        //重载==运算符,同一Id的学生默认为同一个人.
        public static bool operator ==(Student lhs, Student rhs)
        {
            return lhs.Id == rhs.Id;
        }

        //比较运算符必须成对重载.
        public static bool operator !=(Student lhs, Student rhs)
        {
            return !(lhs == rhs);
        }

        //重载ToString(),自定义格式化输出.
        public override string ToString()
        {
            return "编号:" + Id + ";姓名:" + Name + ";年龄:" + Age;
        }
    }

    public class Teacher
    {
        public int Id { get; set; }

        public string Name { get; set; }

        public int Duties { get; set; }
    }

<2>、

搜集的运算符重载。。。。。。。。。。。。。。。。。。。。。。。。。。。

澳门新濠3559 3澳门新濠3559 4Code
using System;
using System.Collections.Generic;

        public Student()
        { }

        public Student(int age, string name)
        {
            this.Age = age;
            this.Name = name;
        }

        //语法错误:ref和out参数在此上下文中无效(去掉ref和out关键字即可).
        public static Student operator +(ref Student stu1,out Student stu2)
        {
            return new Student(stu1.Age + stu2.Age, stu1.Name + "+++" + stu2.Name);
        }
    }

访问修饰符 返回类型 this[参数类型 参数...]

       get{语句集合}
       set{语句集合}

  result-type:运算符的结果类型。
  unary-operator:下列运算符之一:+ - ! ~ ++ — true false
  op-type:第一个(或唯一一个)参数的类型。
  operand:第一个(或唯一一个)参数的名称。
  binary-operator:其中一个:+ - * / % & | ^ << >> == != > < >= <=
  op-type2:第二个参数的类型。
  operand2:第二个参数的名称。
  conv-type-out:类型转换运算符的目标类型。
  conv-type-in:类型转换运算符的输入类型。

    private int sid; //学号
    public int Sid
    {
        get { return sid; }
        set { sid = value; }
    }
    private string name;//姓名
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    private int score; //总分
    public int Score
    {
        get { return score; }
        set { score = value; }
    }
    public Student(int sid, string name, int score)
    {
        this.sid = sid;
        this.name = name;
        this.score = score;
    }
    public Student()
    {
        this.listStudents.Add(new Student(1, "jeff wong", 375));
        this.listStudents.Add(new Student(2,"jeffery zhao",450));
        this.listStudents.Add(new Student(3,"terry lee",400));
        this.listStudents.Add(new Student(4,"dudu",500));
    }
}

运算符重载实例二:


      get{语句集合}
      set{语句集合}

比较运算符的重载:
  a、C#要求成对重载比较运算符,如果重载了==,也必须重载!=,否则会产生编译错误。

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        Student stu = student[1, "jeff wong"];
        Console.WriteLine("student number:" + stu.Sid + ",name:" + stu.Name + ",score:" + stu.Score);

public class Student
{
    public int Id { get; set; }
    public int Age { get; set; }
    public string Name { get; set; }

    public Student()
    { }

    public Student(int id, int age, string name)
    {
        this.Id = id;
        this.Age = age;
        this.Name = name;
    }

    //重载ToString(),自定义格式化输出.
    public override string ToString()
    {
        return "编号:" + Id + ";姓名:" + Name + ";年龄:" + Age;
    }
}

public class Teacher
{
    public int Id { get; set; }

    public string Name { get; set; }

    public int Duties { get; set; }

    //重载运算符"+",计算两个学生的年龄总和.
    public static Student operator +(Student lhs, Student rhs)
    {
        return new Student(0, lhs.Age + rhs.Age, lhs.Name + " 和 " + rhs.Name);
    }

    //重载运算符"-",计算两个学生的年龄差.
    public static Student operator -(Student lhs, Student rhs)
    {
        return new Student(0, Math.Abs(lhs.Age - rhs.Age), lhs.Name + " 和 " + rhs.Name);
    }

    //重载==运算符,同一Id的学生默认为同一个人.
    public static bool operator ==(Student lhs, Student rhs)
    {
        return lhs.Id == rhs.Id;
    }

    //比较运算符必须成对重载.
    public static bool operator !=(Student lhs, Student rhs)
    {
        return !(lhs == rhs);
    }
}

public class Student
{
    public List<Student> listStudents = new List<Student>();

注意事项二:
public class Student
{
public int Age { get; set; }
public string Name { get; set; }

索引器使得对象可按照与数组相似的方法进行索引。
this 关键字用于定义索引器。
get 访问器返回值。set 访问器分配值。
value 关键字用于定义由 set 索引器分配的值。
索引器不必根据整数值进行索引,由你决定如何定义特定的查找机制。
索引器可被重载。
<3>、属性和索引器的主要区别:
a、类的每一个属性都必须拥有唯一的名称,而类里定义的每一个索引器都必须拥有唯一的签名(signature)或者参数列表(这样就可以实现索引器重载)。
b、属性可以是static(静态的)而索引器则必须是实例成员。
<4>、索引器重载实例:

  参数说明:

上面代码中,我们看到索引器的访问器带一个参数(参数为整数),其实可以构建多个参数的索引器。还以上述代码为例,我们要根据学生学号和姓名得到学生的考试总分,修改后代码如下:

三、实例

        Console.Read();
    }
}

二、声明
  operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一:

    private string name;
    /// <summary>
    /// 属性
    /// </summary>
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    public Student(string name)
    {
        this.name = name;
    }
    public Student()
    {
        this.listStudents.Add(new Student("jeff wong"));
        this.listStudents.Add(new Student("jeffery zhao"));
        this.listStudents.Add(new Student("terry lee"));
        this.listStudents.Add(new Student("dudu"));
    }
}

public static result-type operator unary-operator ( op-type operand )

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        int num = student.listStudents.Count;
        Console.WriteLine("All the students:");
        for (int i = 0; i < num; i++)
        {
            Console.WriteLine(student[i].Name); //通过索引器,取所有学生名
        }

  1、运算符重载的声明方式:operator 关键字告诉编译器,它实际上是一个运算符重载,后面是相关运算符的符号。

3、总结:
<1>、

"运算符重载实例三"运行结果图:
澳门新濠3559 5

属性的定义:
访问修饰符 返回类型 属性名

    public Student()
    { }

    public Student(int age, string name)
    {
        this.Age = age;
        this.Name = name;
    }

    //编译错误:二元运算符的参数之一必须是包含类型(参数c1、c2中有一个类型为Student即可).
    public static Student operator +(int c1, int c2)
    {
        return new Student(c1 + c2, "晓菜鸟");
    }
}

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        Student stu = student[1, "jeff wong"];
        Console.WriteLine("student number:" + stu.Sid + ",name:" + stu.Name + ",score:" + stu.Score);
      
        Console.WriteLine("all the students:");

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

1、属性
所谓属性其实就是特殊的类成员,它实现了对私有类域的受控访问。在C#语言中有两种属性方法,其一是get,通过它可以返回私有域的值,其二是set,通过它就可以设置私有域的值。比如说,以下面的代码为例,创建学生姓名属性,控制对name字段的受控访问:

一、简介
  C# 允许用户定义的类型通过使用 operator 关键字定义静态成员函数来重载运算符。注意必须用public修饰且必须是类的静态的方法。但并非所有内置运算符都可以被重载,详见表1:
澳门新濠3559 6

        Console.Read();
    }
}

public static implicit operator conv-type-out ( conv-type-in operand )

public class Student
{
    public List<Student> listStudents = new List<Student>();

  6、C#要求所有的运算符重载都声明为public和static,必须是类的静态方法,这表示它们与它们的类或结构相关联,而不是与实例相关联。

2、索引器 简单说来,所谓索引器就是一类特殊的属性,通过它们你就可以像引用数组一样引用自己的类。显然,这一功能在创建集合类的场合特别有用,而在其他某些情况下,比如处理大型文件或者抽象某些有限资源等,能让类具有类似数组的行为当然也是非常有用的。比如,上例中,我们假设一个班级有若干个学生,构建索引器就可以很方便地调用:

public class UserController : Controller
{
    public ActionResult Index()
    {
        string message = string.Empty;
        Teacher teaA = new Teacher(11, 30, "刘主任", "教导室主任");
        Teacher teaB = new Teacher(12, 45, "吕老师", "校长助理");
        Teacher teaC = new Teacher(11, 27, "刘老师", "小二班班主任");
        Student stuOne = new Student(1, 18, "晓菜鸟");
        Student stuTwo = new Student(2, 21, "博客园");
        Student stuThree = new Student(1, 23, "攻城狮");
        message = stuOne.Name + (stuOne == stuThree ? "是" : "不是") + stuThree.Name + "<br />";
        message += stuOne.Name + (stuOne != stuTwo ? "不是" : "是") + stuTwo.Name + "<br />";
        message += string.Format("{0}和{1}的年龄总和为:{2}<br />", stuOne.Name, stuThree.Name, stuOne + stuThree);
        message += string.Format("{0}和{1}的年龄差为:{2}<br />", stuOne.Name, stuTwo.Name, stuOne - stuTwo);
        message += stuOne;
        ViewData.Model = message;
        return View();
    }
}

public class Student : People
{
    public Student()
    { }

    public Student(int id, int age, string name)
    {
        this.Id = id;
        this.Age = age;
        this.Name = name;
    }

    //重载ToString(),自定义格式化输出.
    public override string ToString()
    {
        return "编号:" + Id + ";姓名:" + Name + ";年龄:" + Age;
    }
}

public class Teacher : People
{
    /// <summary> 职务 </summary>
    public string Duties { get; set; }

    public Teacher() { }

    public Teacher(int id, int age, string name, string duties)
    {
        this.Id = id;
        this.Age = age;
        this.Name = name;
        this.Duties = duties;
    }
}

//abstract:抽象类用做基类,不能被实例化,用途是派生出其他非抽象类.
public abstract class People
{
    public int Id { get; set; }
    public int Age { get; set; }
    public string Name { get; set; }

    //重载运算符"+",计算年龄总和.
    public static int operator +(People lhs, People rhs)
    {
        return lhs.Age + rhs.Age;
    }

    //重载运算符"-",计算年龄差.
    public static int operator -(People lhs, People rhs)
    {
        return Math.Abs(lhs.Age - rhs.Age);
    }

    //重载==运算符,Id相同则视为相等.
    public static bool operator ==(People lhs, People rhs)
    {
        return lhs.Id == rhs.Id;
    }

    //比较运算符必须成对重载.
    public static bool operator !=(People lhs, People rhs)
    {
        return !(lhs == rhs);
    }
}

        Console.Read();
    }
}

重点:
  运算符重载其实就是函数重载。首先通过指定的运算表达式调用对应的运算符函数,然后再将运算对象转化为运算符函数的实参,接着根据实参的类型来确定需要调用的函数的重载,这个过程是由编译器完成。

澳门新濠3559 7澳门新濠3559 8Code
using System;

运算符重载实例一:
public class UserController : Controller
{
public ActionResult Index()
{
string message = string.Empty;
Student stuA = new Student(1, 18, "晓菜鸟");
Student stuB = new Student(2, 21, "博客园");
Student stuC = new Student(1, 23, "攻城狮");
message = stuA.Name + (stuA == stuC ? "是" : "不是") + stuC.Name + "
";
message += stuA.Name + (stuA != stuB ? "不是" : "是") + stuB.Name + "
";
message += stuA;
ViewData.Model = message;
return View();
}
}

    public Student this[int i,string name]
    {
        get
        {
            foreach (Student stu in listStudents.ToArray())
            {
                if (stu.sid == i && stu.name == name) //按照学号和姓名取出学生
                {
                    return stu;
                }
            }
            return null;
        }
        set { listStudents[i] = value; }
    }

运算符重载实例三:

class Program
{
    static void Main(string[] args)
    {
        Student student = new Student();
        student.Name = "Jeff Wong";
        Console.WriteLine(student.Name);
        Console.Read();
    }
}

public class Student
{
    public int Age { get; set; }
    public string Name { get; set; }

    public Student()
    { }

    public Student(int age, string name)
    {
        this.Age = age;
        this.Name = name;
    }

    public static Student operator +(Student stu, int c2)
    {
        return new Student(stu.Age + c2, stu.Name + "-晓菜鸟");
    }

    public static Student operator +(Student stu, string suffix)
    {
        return new Student(stu.Age + 11, stu.Name + suffix);
    }
}

    private int sid; //学号
    public int Sid
    {
        get { return sid; }
        set { sid = value; }
    }
    private string name;//姓名
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
    private int score; //总分
    public int Score
    {
        get { return score; }
        set { score = value; }
    }
    public Student(int sid, string name, int score)
    {
        this.sid = sid;
        this.name = name;
        this.score = score;
    }
    public Student()
    {
        this.listStudents.Add(new Student(1, "jeff wong", 375));
        this.listStudents.Add(new Student(2,"jeffery zhao",450));
        this.listStudents.Add(new Student(3,"terry lee",400));
        this.listStudents.Add(new Student(4,"dudu",500));
    }
}

public static result-type operator binary-operator ( op-type operand, op-type2 operand2 )

澳门新濠3559 9澳门新濠3559 10Code
using System;
using System.Collections.Generic;

C#最常见的重载是构造函数重载,各种方法包括ToString()也可以重载,运算符+-*/也可以重载,今天我们就来说说运算符重载。

    /// <summary>
    /// 索引器重载
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public Student this[int i] //i从0开始
    {
        get { return listStudents[i]; }
        set { listStudents[i] = value; }
    }

  2、运算符只能采用值参数,不能采用ref或out参数。可参考注意事项一实例。

    public Student this[int i,string name]
    {
        get
        {
            foreach (Student stu in listStudents.ToArray())
            {
                if (stu.sid == i && stu.name == name) //按照学号和姓名取出学生
                {
                    return stu;
                }
            }
            return null;
        }
        set { listStudents[i] = value; }
    }

参考实例:
public class UserController : Controller
{
public ActionResult Index()
{
Student student = new Student(18, "博客园");
var resultOne = student + 3;
var resultTwo = student + "晓菜鸟";
return View();
}
}

public class Student
{
    public List<Student> listStudents = new List<Student>();

  e、任何运算符声明的前面都可以有一个可选的属性(C# 编程指南)列表。

    /// <summary>
    /// 构建索引器
    /// </summary>
    /// <param name="i"></param>
    /// <returns></returns>
    public Student this[int i]
    {
        get { return listStudents[i]; }
        set { listStudents[i] = value; }
    }

  c、在重载==和!=时,还应该重载从System.Object中继承的Equals()和GetHashCode()方法,否则会产生一个编译警告,原因是Equals方法应执行与==运算符相同的相等逻辑。

  • 相当于一个函数,我们可以这样去理解,operator +(op-type operand, op-type2 operand2) 等于 op-type.operator +(operand,operand2) 或者 op-type2.operator +(operand,operand2)。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

//简单的运算符重载 方便理解
namespace 运算符重载
{
    public class Money
    {
        public decimal Weight { get; set; }
        public static decimal operator -(Money a1, Money a2)//public static 必须要写上。operator是关键字
        {
            return a1.Weight - a2.Weight;
        }
    }

    class Program
    {
        static void Main(string[] args)
        {
            Money a = new Money { Weight = 100.00M };
            Money b = new Money { Weight = 200.66M };

            Console.Write(b - a);

            Console.Read();
        }
    }
}

  我这里想到的就是继承,让子类去继承父类的重载!请看"运算符重载实例三"。

  b、比较运算符必须返回bool类型的值,这是与其他算术运算符的根本区别。

注意事项一:
public class Student
{
public int Age { get; set; }
public string Name { get; set; }

public static explicit operator conv-type-out ( conv-type-in operand )

  5、对于二元运算符,第一个参数是放在运算符左边的值,一般命名为lhs;第二个参数是放在运算符右边的值,一般命名为rhs。

"运算符重载实例二"是完全没有问题的,这个时候我们想一个问题,将如我们的Teacher类也涉及到求教师年龄的总和和差值怎么办?难道只能重写一遍?不知道您有什么好的思路和见解,不妨在评论里面留下您的看法!请多多指教,晓菜鸟不胜感激!

编辑:编程 本文来源:它实现了对私有类域的受控访问,/也可以重载

关键词: