威尼斯人线上娱乐

议论多少个编程习惯,关于操作符重载与转移

9 4月 , 2019  

议论多少个编程习惯,关于操作符重载与转移。 随便写写

一.索引器方法组织大体上为<modifier><return type> this
[argument list],它能够在接口中定义:  在为接口证明索引器的时候,记住注脚只是意味着索引器的留存。你只须求提供适宜的拜访函数即可,不必包罗限制修饰符。以下代码把索引器注解为接口IImplementMe的壹有的:

以此操作符重载很有趣

     
1位的功成名就有时往往反映在细节上,而习惯往往是这么些细节的具体表现情势,那里作者也想计算多少个不太好的编制程序习惯。

 

interface IImplementMe {  string
this[int index]  {  get;  set;  } 

class Program
{
static void Main(string[] args)
{
Person person1 = new Person() { Name = “LiLei”, Age = 12 };
Person person2 = new Person(“HanMeimei”, 11);
Person person3 = person1 + person2;
Person person4 = person1 == person2;
Person person5 = 10;
Console.WriteLine($”Name’s merge is {person3.Name}\nAge’s sum is
{person3.Age}”);
Console.ReadKey();
}
}

     
第一:下边包车型的士一段程序大致的意趣正是,页面上有二日性质HighPrice,它最终会通过ViewState保存在页面中,要是ViewState为空,则设置属性HighPrice的值为-一,否则直接读取ViewState中的值。但事实上景况并不是那般,程序在起始化时,要是ViewState[“HighPrice”]竟然的写入了些非数字字符串数字,程序就会抛出相当。

首先,借使大家有三个Person类型

对应达成的类则必须为IimplementMe的索引器具体定义get和set访问函数。

public class Person
{
public Person() { }
public Person(string name, int age)
{
this.Name = name; this.Age = age;
}
public string Name { get; set; }
public int Age { get; set; }
public static Person operator +(Person p1, Person p2)
{
Person p3 = new Person(p1.Name + p2.Name, p1.Age + p2.Age);
return p3;
}

public int HighPrice {
  get
  {
    if (ViewState[“HighPrice”] != null)
       return (int)ViewState[“HighPrice”];
    else
       return -1;
  }
   set
   {
       ViewState[“HighPrice”] = value;
   }
}

其类型定义如下

索引器可以称呼有参数的属性,它与质量的差别在于属性名称无法同1,不可重载,索引器能够。属性能够使static的,不过索引器必须是实例化的。在作者眼里索引器的功能在于能够转移现有的某些索引器的目录格局,比如数组的之所以艺术是以int作为下标,查询相应数据,但是自身能够重写索引,使数组的目录以string实行。

public static Person operator ==(Person p1, Person p2)
{
Person p3 = new Person(p1.Name + p2.Name, p1.Age + p2.Age);
return p3;
}
public static Person operator !=(Person p1, Person p2)
{
Person p3 = new Person(p1.Name + p2.Name, p1.Age + p2.Age);
return p3;
}

     
化解方案:下边给出相对科学的写法。大家只要有更加好的写法能够建议参考下。
      说明:(int)ViewState[“HighPrice”]那种写法和int.TryParse(ViewState[“HighPrice”].ToString(), out _HighPrice);还有是壹对一大的不一致的,因为ViewState[“HighPrice”]目的要确定保障是数字字符串才行,假如十分的大心给它赋值为空,那么就会出现至极。不要过份相信七个对象的数据类型,特别是那种object类型的,那样写出的次第不健全。

  class Person
    {
        public string Name { get; set; } = "Person";
        public int Age { get; set; } = 18;

        public Person() { }

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

        public Person(string name) : this(name, 18) { }
        public Person(int age) : this("Person", age) { }


    }

例:

public static implicit operator Person
{
return new Person();
}
}

private int _HighPrice = -1;
        public int HighPrice
        {
            get
            {
                if (null != ViewState[“HighPrice”])
                {
                  int.TryParse(ViewState[“HighPrice”].ToString(), out _HighPrice);
                }
                return this._HighPrice;
            }
            set
            {
                this._HighPrice = value;
                if (null == ViewState[“HighPrice”])
                {
                    this._HighPrice = -1;
                }
                //把变量值保存到ViewState中
                ViewState[“HighPrice”] = this._HighPrice;
            }
        }

在正规状态下,我们让七个Person类型相加,是不恐怕的,例如:

namespace Study
{
    class Program
    {
        static void Main(string[] args)
        {
            ScoreIndex s = new ScoreIndex();
            s[“张三”, 1] = 90;
            s[“张三”, 2] = 100;
            s[“张三”, 3] = 80;
            s[“李四”, 1] = 60;
            s[“李四”, 2] = 70;
            s[“李四”, 3] = 50;
            Console.WriteLine(“张叁课程编号为一的成就为:” +
s[“张三”,1]);
            Console.WriteLine(“张三的具有战绩为:”);
            ArrayList temp;
            temp = s[“张三”];
            foreach (IndexClass b in temp)
            {
                Console.WriteLine(“姓名:” + b.Name + “课程编号:” +
b.CourseID + “分数:” + b.Score);
            }
            Console.ReadKey();
        }
    }
    class IndexClass
    {
        private string _name;
        private int _courseid;
        private int _score;
        public IndexClass(string _name, int _courseid, int _score)
        {
            this._name = _name;
            this._courseid = _courseid;
            this._score = _score;
        }
        public string Name
        {
            get { return _name; }
            set { this._name = value; }
        }
        public int CourseID
        {
            get { return _courseid; }
            set { this._courseid = value; }
        }
        public int Score
        {
            get { return _score; }
            set { this._score = value; }
        }
    }
    class ScoreIndex
    {
        private ArrayList arr;
        public ScoreIndex()
        {
            arr = new ArrayList();
        }
        public int this[string _name, int _courseid]
        {
            get
            {
                foreach (IndexClass a in arr)
                {
                    if (a.Name == _name && a.CourseID == _courseid)
                    {
                        return a.Score;
                    }
                }
                return -1;
            }
            set
            {
                arr.Add(new IndexClass(_name, _courseid, value));
//arr[“张三”,1]=90
            }
        }
        //重载索引器
        public ArrayList this[string _name]
        {
            get
            {
                ArrayList temp = new ArrayList();
                foreach (IndexClass b in arr)
                {
                    if (b.Name == _name)
                    {
                        temp.Add(b);
                    }
                }
                return temp;
            }
        }
    }
}

 

威尼斯人线上娱乐 1

二.操作符重载:

     
//其次:对于多规格的判断,最特异的要数&&操作符了。比方贰个话语的履行必要同时知足多个条件,我们常常会那样写:if(条件一&&条件二),意图是觉得标准一和规范贰都非凡true的景观下,但实况是只要四个人标准//都以false,那么最后的规范一&&条件2的结果正好也是true,此时就会冒出不可预测的荒唐。而且这种不当也是分外难查找的。有时候写代码能省就省,不能够省的二个也不能够少。

那正是说怎么样能让四个Person类型相加,然后回到一个Person类型呢

操作符重载是将长存的有的操作符的作用拓展更改,例如多个类相加,相减,相比较等,它提供Operaor关键字展开重载,必须与static关键字联合使用。例:

      //说明:
1:
此条对C#不树立,但其余的言语就不肯定,大家能够测试下。

例如,我想让名为”张叁”年龄为1玖的Person加上另二个名称为”李4″,年龄为20的Person

namespace ContainerAndOperator
{
    /// <summary>
    /// 索引器,此类已化作容器类,索引器超越1/2利用在容器类中
    ///
使用IEnumerable与GetEnumerator()意在使那几个类能够拓展foreach
    /// </summary>
    public class ContainerClass : IEnumerable
    {
        private ArrayList people = new ArrayList();
        public Person this[int
index]//Person为回去的值类型,int为输入的索引值的种类,this用来定义索引器
        {
            get { return (Person)people[index]; }
            set { people.Insert(index, value); }
        }

              
//2:由于此条并不适用于主流的言语,写在那有点让园友糊涂,那里表示道歉,但在某种环境上确实存在,起码小编遇上过,那里并不须求我们同意笔者的见地,信则有不信则无,唯有当你真的遇上过才会有越来越深的体味。

然后回到3个名叫”张3李四”,年龄为3九的Person

        public IEnumerator GetEnumerator()
        {
            return people.GetEnumerator();
        }
    }

    
更新:地点的第三条我们都不太认同,可是本人遇到的事态和那篇文章大约: ,大家能够参见下,有园友说是因为firebug的二个BUG,那里笔者特把那条注释掉,那里未有像园友说的嘴硬不认同错误,而是有时候确实有个别不便分解的情景出现,而且当改变相应的写法后实在原有的BUG不设有。

那么就须要使用重载”+”号那几个操作符了

    public class Person
    {
        public string name { get; set; }
        public string Id { get; set; }
        public int Age { get; set; }
        /// <summary>
        /// 重构贰元操作符
        /// </summary>
        /// <param name=”p1″></param>
        /// <param name=”p2″></param>
        /// <returns></returns>
        public static Person operator +(Person p1,Person p2)
        {
            return new Person(p1.name + “-” + p2.name, p1.Id + “-” +
p2.Id, p1.Age + p2.Age);
        }
        public static string operator -(Person p1, Person p2)
        {
            return p1.name+”-“+p2.Id;
        }
        public Person(){}
        public Person(string n,string i,int a)
        {
            name = n;
            Id = i;
            Age = a;
        }
    }
}

     
其③:对于if语句的写法。咱俩基本上会这么写:if(条件==true),日常情形下是未曾难题,但有时会写成if(条件=true),也正是程序员在写的时候少写了1个等号,造成程序永远执行上面包车型客车代码,那种张冠李戴查找起来也是一对一辛劳的,因为编译器在编译时并不会报错。

之所以,代码就好像下,在Person中重载

namespace ContainerAndOperator
{
    class Program
    {
        static void Main(string[] args)
        {
            ContainerClass con = new ContainerClass();
            con[0] = new Person(“homer”, “11”, 11);
            con[1] = new Person(“homer1”, “12”, 12);
            con[2] = new Person(“homer2”, “13”, 13);
            Console.WriteLine(con[2].name);
            foreach(Person s in con)
            {
                Console.WriteLine(s.name);
            }
           
Console.WriteLine(“*******************************”);
            Person p3 = con[威尼斯人线上娱乐,1] + con[2];
            Console.WriteLine(p3.name);
            Console.WriteLine(con[1] – con[2]);
            Console.ReadLine();
        }
    }
}

      消除方案:
       
壹:能够这么写if(true==条件),假设你写成了if(true=条件),编写翻译器会报错,因为true是不可能担任左值的。
       
2:固然唯有多少个准绳,就径直if(条件),把==true给省略即可,假使是多规格就按章程1来执行。

     /// <summary>
        /// 重载+号
        /// </summary>
        /// <param name="p1"></param>
        /// <param name="p2"></param>
        /// <returns>返回一个Person类型</returns>
        public static Person operator+(Person p1,Person p2)
        {
            //将两个相加的Person类型分别让他们的
            //名字和年龄相加后的值赋值给被返回的Person类型
            Person p3 = new Person(p1.Name + p2.Name, p1.Age + p2.Age);
            return p3;
        }

因为有时大家或者需求对四个类进行自己检查自纠,已成功部分一定的成效,不过,原生的操作符不辅助的情形下,大家就能够重载操作符。

          
说明:一:if(条件=true)那种程序当然并不是程序员想这要写,只是有时候会少写贰个罢了。

下一场大家就能够在Main中来相加七个Person类型了

                    二:if(条件=true),编写翻译器并不会报错,有园友说会出提示警示,那里大家能够友善取证下。

看图

     
第陆:对于操作符的重载难点。诸如大家想重载“==”,代码如下:多少个指标相等的业内正是属性sName相等,程序中壹上来就直接p.sName,未有思索到p对象是还是不是为null,那种也是编写翻译器无法在编写翻译时期判断的。那种代码也只有在程序调节和测试时才相比简单觉察,假如您在先后中判断这一个自定义类是或不是为空:if(null==自定义类),我们从程序上来看那里都以不会出题指标,可是在等号重载中从未看清指标的可行,那对BUG的排查也是1对壹劳累的。

威尼斯人线上娱乐 2

             
表明:那里重载了等号和不等号,这里并不是剩下的,而是必须,因为它们必须成对出现。

那般就马到成功了

/// <summary>
    /// 自定义测试类
    /// </summary>
    public class a
    {
        public string sName
        {
            get;
            set;
        }
        public a(string _sName)
        {
            this.sName = _sName;
        }
        /// <summary>
        /// 重载==操作符
        /// </summary>
        /// <param name=”p”></param>
        /// <param name=”b”></param>
        /// <returns></returns>
        public static bool  operator ==(a p, a b)
        {
            if (p.sName == b.sName)
            { return true; }
            else
            { return false; }
        }
        /// <summary>
        /// 重载!=操作符
        /// </summary>
        /// <param name=”p”></param>
        /// <param name=”b”></param>
        /// <returns></returns>
        public static bool  operator !=(a p, a b)
        {
            return !Object.Equals(p, b);
           
        }

下一场其它的比如说

    }

 

 

而关键点就在于一旦你要重载操作符就务须格式如下

      
第伍:对于数据格式转换。拿字符串转换来数字来说,很多爱人欣赏向来int.Parse(要转换的字符串),假设这些字符串是你希望的数字字符串那没问题,要是字符中为空,大概是储存的汉语恐怕别的非数字字符串,那也是更换失利,其实大家大可利用int.TryParse方法来缓解,不成功还有贰个默值,起码无法暂停程序的周转。

 

       小编大中华全国体育总会计了多少个,我们看还有没多少接近的不太好的习惯吗?

空话:public
static 重返类型 operator被重载的操作符(本类型,要与之操作的项目)

  

本文:public static Person operator+(Person p1,Person p二) 
 => 意思为:作者要让多个Person类型相加,然后回来一个Person类型

竟然你能够把再次来到类型改为int,然后四个Person类型相加后,你回到一个int类型的多少回去

譬如说重临  p1.Age+p2.Age 
那样,在将五个Person类型相加之后,将获得一个int类型的数码,其值便是相加的七个Person类型的Age值的相加值

 

还有个要小心的是,

设若你重载了 == 操作符,就必须求重载 != 因为它们是成对,还有别的成对运算符

同时重载了 == 后,还相应重载 Equals,以及GetHashCode

 

===========================================================================================================

 

下边再说说转换操作符

照旧说地方的不行Person吧

比如,笔者非要让

Person p=30;

常规状态下,是不容许的,但即使本人这么在Person中写就行了

 public static implicit operator Person(int age)
        {
            return new Person(age);
        }

格式的话,正是定位死的,implicit关键字,假设没记错的话正是意味着能够隐式转换

还有个展现转换的,小编忘了,不佳意思,懒得查资料了

那1段代码的趣味正是

本人要让叁个Person类型的数目,能够给它二个int类型的值

例如

威尼斯人线上娱乐 3

 

=============================================================================================

后记:写得相比较少,只拣了多个例子去随便说了下,其实本身感到就这四个例证就够了

其它的友爱多尝试,语法格式都以固定死了的,怎么写就看本身的思念有多么天马行空了

好了,最后我们来使用刚才说的东西,去化解一下上面那道题

威尼斯人线上娱乐 4

怎么让 

a==1 && a==2 && a==3 =true

如何做啊,看大家来调皮一下吗

 

率先,大家不管a是什么样类型,反正不太恐怕是int类型,因为无论原始a等于多少,上述表明式如同都不为true

那正是说大家自身来建个品种为Rational

笔者们要做的就一件事

为Rational重载 == 操作符

让它不管与哪些int类型的数字比较都回到true  (够调皮吧)

看代码吧:

class Rational
    {
        public int Val { get; set; } = 0;

        public Rational()
        {

        }

        public Rational(int val)
        {
            this.Val = val;
        }

        /// <summary>
        /// 我们重载了==操作符
        /// </summary>
        /// <param name="r"></param>
        /// <param name="val"></param>
        /// <returns></returns>
        public static bool operator==(Rational r,int val)
        {
            //只返回一个true是为了让所有与Rational类型相比对的int类型
            //都返回true
            //因为重载了==,所以必须重载!=
            //其实还应该重载Equals,以及GetHashCode
            //因为它们都是判断相等的类型

            return true;
        }

        public static bool operator !=(Rational r, int val)
        {
            return true;
        }

    }

 

下一场在Main中间试验试啊

 static void Main(string[] args)
        {
            Rational a = new Rational();
            bool result = a == 1 && a == 2 && a == 3;
            Console.WriteLine(result);
            Console.ReadKey();
        }

您会意识,为true,是吗

 


相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图