C#中如何利用操作符重载和转换操作符 （转载）

最新推荐文章于 2022-08-17 16:49:05 发布
最新推荐文章于 2022-08-17 16:49:05 发布
阅读量131 收藏
点赞数
文章标签： c#
原文链接：http://www.cnblogs.com/OpenCoder/p/9898690.html
版权

操作符重载

有的编程语言允许一个类型定义操作符应该如何操作类型的实例，比如string类型和int类型都重载了（==）和（+）等操作符，当编译器发现两个int类型的实例使用+操作符的时候，编译器会生成把两个整数加到一起的代码。
当编译器发现两个string类型的实例使用+操作符的时候，编译器会生成把两个字符串连接到一起的代码。那么编译器怎么就会知道这样做呢？如何进行操作符重载呢？
下面C#代码展示了一个类中如何进行操作符重载：

namespace DoNet.Seven.ConsoleApplicationTest
{
    class Program
    {
        static void Main(string[] args)
        {
            rational r1 = new rational(10);
            rational r2 = new rational(5);
            rational r3= r1 + r2;
            Console.WriteLine(r3.Value);
            Console.ReadKey();

        }
    }
    //有理数
    public sealed class rational
    {
        private int _value = 0;

        public int Value
        {
            get { return _value; }
            set { _value = value; }
        }
        public rational(int value)
        {
            this._value = value;
        }

        public rational()
        {

        }
        public static rational operator+(rational num1,rational num2)
        {
            rational result = new rational(num1.Value+num2.Value);
            return result;
        }

    }
}

运行代码输入结果是15
用IL工具看下编译器生成的代码如下：

  1. 首先CLR规范要求操作符重载方法必须是public和static方法。另外，C#编译器要求操作符重载方法至少有一个参数的类型与当前定义的这个方法的类型相同。之所以这样做，是为了是编译器能在合理的时间内找到要绑定的操作符方法。
  2. 编程语言的编译器看到源码中出现一个+操作符时，会检查是否有一个操作数的类型定义了一个名为op_Addtion的specialname方法，而且该方法的参数兼容于操作数的类型，如果存在这样的一个方法，编译器就生成调用它的代码。如果不存在这样的一个方法，就生成一个编译错误。
  3. 对于其它操作符编译之后对应的方法如下表所示（左边是一元操作符，右边是二元操作符）

 

 

转换操作符

当设计一个类型时应该考虑到和其它类型之间的转换，这个其实很重要，将对我们的编码有很大的好处，就像每个类型都会有的一个方法Tostring()一样，我们定义一个int类型，可以很方便的用tostring()方法把
int转换为string，当然也可以转换为其它类型。就像上面的rational一样，如果能将一个int或者double转换为一个rational，就会很方便，反之亦然。

//有理数
    public sealed class rational
    {
        private int _value = 0;

        public int Value
        {
            get { return _value; }
            set { _value = value; }
        }
        public rational(int value)
        {
            this._value = value;
        }

        public rational(double value)
        {
            this._value =(int)value;
        }
        public rational()
        {

        }

        public int ToInt()
        {
            return _value;
        }
        public double ToDouble()
        {
            return (double)_value;
        }
        public static rational operator+(rational num1,rational num2)
        {
            rational result = new rational(num1.Value+num2.Value);
            return result;
        }
        

    }

1、调用这些构造器和方法，开发人员可以很方便的将int和double对象转换成rational对象，这将给编程工作带来很多方便。设计类型时，应该认真考虑类型需要支持的转换构造器和方法。
2、int i=10;long j=i;这样的代码我们经常会看到，那么从int类型到long类型的转换为什么就可以隐士的进行呢？这就涉及到了我们的转换操作符，下面我们也为rational定义几个转换操作符。

namespace DoNet.Seven.ConsoleApplicationTest
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 10;
            rational r1 = n;
            double d=(double)r1;

            Console.WriteLine(r1.Value);
            Console.WriteLine(d.ToString());
            Console.ReadKey();

        }
    }
    //有理数
    public sealed class rational
    {
        private int _value = 0;

        public int Value
        {
            get { return _value; }
            set { _value = value; }
        }
        public rational(int value)
        {
            this._value = value;
        }

        public rational(double value)
        {
            this._value =(int)value;
        }
        public rational()
        {

        }

        public int ToInt()
        {
            return _value;
        }
        public double ToDouble()
        {
            return (double)_value;
        }
        public static rational operator+(rational num1,rational num2)
        {
            rational result = new rational(num1.Value+num2.Value);
            return result;
        }

        public static implicit operator rational(int value)
        {
            return new rational(value);
        }
        public static implicit operator rational(double value)
        {
            return new rational(value);
        }
        public static explicit operator int(rational value)
        {
            return value.ToInt();
        }
        public static explicit operator double(rational value)
        {
            return value.ToDouble();
        }

    }
}

输出的结果是10、10。 我们可以在rational、int、double之间来回转换，是不是觉得挺方便的，在这个过程中，编译器又帮我们做了什么呢？
在C#中，implicit关键字告诉编译器为了生成代码来调用方法，不需要在源代码中进行显示转换（即隐式转换），相反，explicit关键字告诉编译器只有在发现了显示转型时，才调用方法。
在implicit或explicit关键字之后，要指定operator关键字告诉编译器该方法是一个转换操作符。在operator之后，指定对象要转换成什么类型。在圆括号内，则指定要从什么类型转换。
C#编译器检测到代码中的转型，并内部生成IL代码来调用rational类型定义的转换操作符方法，如果用反编译器看的话可以发现，转换操作符方法会生成下面这样的代码：

 

 

结论

不论是操作符重载还是转换操作符，都是在设计类型是考虑到我们编码方便而设计的，下面我们看下C#中decimal类型中的定义。

 

 

隐式转换重载可自动作用于其它运算符重载

C#的隐式转换重载很多时候会自动作用于其它运算符重载，下面例子中我们在Program类的Main方法中，使用rational类型的对象rational，来加上int类型的变量number：

//有理数
public class rational
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rational(int value)
    {
        this._value = value;
    }

    public rational()
    {

    }

    public static rational operator +(rational num1, rational num2)
    {
        Console.WriteLine("rational operator + invoked!");

        rational result = new rational(num1.Value + num2.Value);
        return result;
    }

    public static implicit operator rational(int value)
    {
        Console.WriteLine("rational implicit operator invoked!");

        return new rational(value);
    }
}

class Program
{
    static void Main(string[] args)
    {
        int number = 80;
        rational rational = new rational(10);
        rational rationalAdd = rational + number;//rational类型加上int类型

        Console.WriteLine("Press any key to quit...");
        Console.ReadKey();
    }
}

结果如下：

从输出结果，我们可以看到由于rational类型的对象rational加上int类型的变量number，C#首先调用了rational类的implicit operator隐式转换重载方法，将int类型隐式转换为了rational类型，然后才调用rational类的operator +操作符重载方法，来做的加法。

 

 

C#会自动选择最优的操作符重载方法

此外，C#会自动调用最优的操作符重载方法，例如下例中我们有两个类rationalA和rationalB，我们使用rationalA类的变量rationalX，加上rationalB类的变量rationalY，代码如下：

public class rationalA
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalA(int value)
    {
        this._value = value;
    }

    public rationalA()
    {

    }

    public static rationalA operator +(rationalA num1, rationalA num2)
    {
        Console.WriteLine("rationalA operator rationalA + rationalA invoked!");

        rationalA result = new rationalA(num1.Value + num2.Value);
        return result;
    }

    public static rationalA operator +(rationalA num1, rationalB num2)
    {
        Console.WriteLine("rationalA operator rationalA + rationalB invoked!");

        rationalA result = new rationalA(num1.Value + num2.Value);
        return result;
    }

    public static implicit operator rationalA(rationalB value)
    {
        Console.WriteLine("rationalA implicit operator invoked!");

        return new rationalA(value.Value);
    }
}

public class rationalB
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalB(int value)
    {
        this._value = value;
    }

    public rationalB()
    {

    }
}

class Program
{
    static void Main(string[] args)
    {
        rationalA rationalX = new rationalA(10);
        rationalB rationalY = new rationalB(10);

        rationalA rationalZ = rationalX + rationalY;//rationalA类型加上rationalB类型

        Console.WriteLine("Press any key to quit...");
        Console.ReadKey();
    }
}

结果如下：

可以看到当我们在调用rationalA类型加上rationalB类型时：

C#并没有先调用rationalA类的implicit operator重载方法将rationalB转换为rationalA，再调用rationalA类的operator +(rationalA num1, rationalA num2)重载方法做加法。

而是直接调用了rationalA类的operator +(rationalA num1, rationalB num2)重载方法，说明C#觉得这才是最优的运算符重载方法。

 

如果我们注释掉rationalA类的operator +(rationalA num1, rationalB num2)重载方法，运行结果就会如下：

 

 

操作符重载是有顺序的

需要注意C#在重载操作符时，是有先后顺序的，例如下面的rationalA类中我们定义了操作符重载方法operator +(rationalA num1, rationalB num2)，但是在Program类的Main方法中，我们反过来用rationalB类型加上rationalA类型：

public class rationalA
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalA(int value)
    {
        this._value = value;
    }

    public rationalA()
    {

    }

    public static rationalA operator +(rationalA num1, rationalB num2)
    {
        Console.WriteLine("rationalA operator rationalA + rationalB invoked!");

        rationalA result = new rationalA(num1.Value + num2.Value);
        return result;
    }

    public static implicit operator rationalA(rationalB value)
    {
        Console.WriteLine("rationalA implicit operator invoked!");

        return new rationalA(value.Value);
    }
}

public class rationalB
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalB(int value)
    {
        this._value = value;
    }

    public rationalB()
    {

    }
}

class Program
{
    static void Main(string[] args)
    {
        rationalA rationalX = new rationalA(10);
        rationalB rationalY = new rationalB(10);

        rationalA rationalZ = rationalY + rationalX;//rationalB类型加上rationalA类型会报错，因为rationalA类没有定义操作符重载方法operator +(rationalB num1, rationalA num2)

        Console.WriteLine("Press any key to quit...");
        Console.ReadKey();
    }
}

这样C#会报编译错误，因为rationalB类型加上rationalA类型，需要定义操作符重载方法operator +(rationalB num1, rationalA num2)，但是我们只在rationalA类中定义了操作符重载方法operator +(rationalA num1, rationalB num2)：

 

 

不要定义有二义性的操作符重载方法

C#遇到具有二义性的操作符重载方法时会报错，如下所示：

public class rationalA
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalA(int value)
    {
        this._value = value;
    }

    public rationalA()
    {

    }

    //rationalA类定义了operator +(rationalA num1, rationalB num2)操作符重载方法
    public static rationalA operator +(rationalA num1, rationalB num2)
    {
        Console.WriteLine("rationalA operator rationalA + rationalB invoked!");

        rationalA result = new rationalA(num1.Value + num2.Value);
        return result;
    }

    public static implicit operator rationalA(rationalB value)
    {
        Console.WriteLine("rationalA implicit operator invoked!");

        return new rationalA(value.Value);
    }
}

public class rationalB
{
    private int _value = 0;

    public int Value
    {
        get { return _value; }
        set { _value = value; }
    }
    public rationalB(int value)
    {
        this._value = value;
    }

    public rationalB()
    {

    }

    //rationalB类也定义了operator +(rationalA num1, rationalB num2)操作符重载方法
    public static rationalB operator +(rationalA num1, rationalB num2)
    {
        Console.WriteLine("rationalA operator rationalA + rationalB invoked!");

        rationalB result = new rationalB(num1.Value + num2.Value);
        return result;
    }
}

class Program
{
    static void Main(string[] args)
    {
        rationalA rationalX = new rationalA(10);
        rationalB rationalY = new rationalB(10);

        var rationalZ = rationalX + rationalY;//rationalA类型加上rationalB类型会报错，因为rationalA类定义了操作符重载方法operator +(rationalA num1, rationalB num2)，而rationalB类也定义了同样的操作符重载方法operator +(rationalA num1, rationalB num2)

        Console.WriteLine("Press any key to quit...");
        Console.ReadKey();
    }
}

上面的代码编译时，C#会报错，错误如下：

可以看到由于我们既在rationalA类中定义了操作符重载方法operator +(rationalA num1, rationalB num2)，又在rationalB类中也定义了同样的操作符重载方法operator +(rationalA num1, rationalB num2)，当使用rationalA类型加上rationalB类型时，C#就不知道该调用哪一个重载方法了，产生了二义性，所以切记操作符重载不能滥用，否则会带来不必要的麻烦。

 

 

原文链接

 

转载于:https://www.cnblogs.com/OpenCoder/p/9898690.html

anyi2404
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#操作符重载
IT成功之路开始
02-26 604
<br />C#操作符重载是什么？<br />是指允许用户使用用户定义的类型编写表达式的能力。<br />例如，通常需要编写类似于以下内容的代码，以将两个数字相加。很明显，sum 是两个数字之和。<br />int i = 5; <br /> int sum = i + j;<br />如果可以使用代表复数的用户定义的类型来编写相同类型的表达式，那当然是最好不过了：<br />Complex i = 5;<br /> Complex sum = i + j;<br />运算符重载允许为用户定义的类型重载
C#——面向对象——重载操作符——重载运算符
DC的博客
06-14 290
什么是重载运算符？ 利用现有的某种运算符，针对自定义类或结构，定义某种运算操作。 为什么要重载运算符呢？ 为的是简化自定义类型的操作（最好是该运算符和该操作有一定的相关性）。 重载运算符的语法细节？ public static Dog operator +(Dog male,Dog female) { ... return new Dog(); } 一元运算符：+、-、
c# --- 索引器与运算符重载
qq_51947882的博客
08-17 764
1.索引器其实就是数组中的那个 [ ]，索引器常常用在数组中。哎其实就是下标引用操作符，本质上还是解引用那一套。2.在类中我们可以定义自己的索引器定义语法：索引器访问权限 调用索引器后的返回权限 this(调用索引器的对象)[ index的类型 index（用来接收索引值的index） ]{ get{当我们调用用索引器给别的变量进行赋值的时候，就会运行这里面的代码}set{当我们调用索引器，并给索引器赋值的时候，就会运行着里面的代码} }...
【C#】运算符重载(operator)
指错||纠正||建议||水评+点赞&&评论&&关注&&转发，在这里你大概率会有所收获
04-19 3370
可重载预定义的 C# 运算符。也就是说，当一个或两个操作数都是某类型时，此类型可提供操作的自定义实现。使用 operator 关键字来声明运算符。
C# 使用技巧之 += 操作符的重载
最新发布
05-12
在实际开发中，需要注意的是，操作符重载应当保持一致性和合理性，确保它们的行为符合用户预期。例如，如果`Vector2D`类代表物理中的向量，那么`+=`操作符应该遵守向量加法规则，而不是随意改变其含义。 总之，`+=`...
19操作符重载[参照].pdf
10-10
【操作符重载】是C#编程中的一种高级特性，允许程序员为自定义类型赋予特定操作符的新功能，以便在类或结构中更加自然地表达计算逻辑。在.NET框架下，操作符重载有助于增强代码的可读性和简洁性。 19.1 理解操作符 ...
19操作符重载[归类].pdf
10-19
操作符重载是C#语言中的一种特性，它允许程序员为自定义数据类型定义操作符的行为，以便这些操作符在处理这些类型时能符合预期的逻辑。操作符重载主要涉及以下几个方面： 1. **操作符重载的概念**：操作符重载是...
详解C# 泛型中的数据类型判定与转换
08-18
在这个结构体中，我们使用泛型约束数据为值类型，并使用操作符重载函数来实现加法操作。 然而，在泛型中，我们不能直接将泛型参数强转为任何一种非 object 数据类型。这时，我们可以使用 object 类型作为桥梁，进行...
C# 四则运算符重载
04-07
下面将详细探讨四则运算符重载的概念、实现方式以及其在实际应用中的意义。 一、运算符重载概念 运算符重载并不创建新的运算符，而是为已存在的运算符赋予新的操作。在C#中，可以重载的运算符包括加法(+), 减法(-),...
C#转换运算符
hbxtlhx的专栏
04-30 1891
C# 允许程序员在类或结构上声明转换，以便类或结构与其他类或结构或者基本类型进行相互转换。 转换的定义方法类似于运算符，并根据它们所转换到的类型命名。 要转换的参数类型或转换结果的类型必须是（不能两者同时都是）包含类型。 class SampleClass {     public static explicit operator SampleClass(int i)
C#中如何利用操作符重载
一起来捉 Bug 呀~~
05-17 1264
多态性是OOP（面向对象编程）的基本原则之一。多态性(Polymorphism)来源于两个词——“poly”意为很多，“morph”意为形式。因此，多态性意味着同样的事情以不同的形式存在。操作符重载是静态多态性的一个示例。可以利用操作符重载或增加操作符功能，使用基本数据类型相同的用户定义类型方法进行操作。什么是操作符？什么是能被重载的操作符？表达式中通常有操作符和操作数。操作符对操作数起作用并且是...
C#学习（四）——自动转换、重载运算符
有问题请发邮箱dengyifanlittle@163.com进行讨论
07-17 751
自定义转换：为自己的结构或者类定义显式和隐式转换。 隐式转换语法： public static implicit operator Dog(Cat cat)//本质上是实现一个静态的方法，隐式转换关键字使用implicit，使用operator关键字标明这是一种转换操作，这里的Dog本质上是函数名，但实际上并不是函数名，实际上是返回的类型 { ... } ...
全面理解C#中的重载运算符和转换运算符
芽芽民工广场
10-23 1253
关于重载运算符大家可能都很少用，也就对他不是很理解了。大家很少用的原因其中一个是因为写程序的时候都是用dataset datatable来保存数据，并没有构建自己的数据类，这样实现功能起来虽然很方便，但是灵活度就不够了，一直就限制在线性表的操作。2005年以前我也是这样做的，因为那时候我觉的dataset很方便，很好用，但是用久了就觉得，怎么C#就是dataset datagrid 。直到深入的去
C#语法小知识（二十三）重载运算符
凯奥斯的注释
11-29 2648
C#里使用Operator关键字定义静态方法来重载运算符。
C#运算符重载(操作符重载)
weixin_34060741的博客
01-08 332
1.什么是操作符重载 定义:(百科定义)就是把已经定义的、有一定功能的操作符进行重新定义，来完成更为细致具体的运算等功能。操作符重载可以将概括性的抽象操作符具体化，便于外部调用而无需知晓内部具体运算过程。   2.为什么需要运算符重载？ 在C#中 ,内置的数据类型有：int、double等这些类型是可以直接进行数值加减运算。例如：int i, j = 1; int sum=i+j；可以直接...
C#重载操作符==和!=时注意问题
冰封的落叶的博客
12-04 1288
public class MyClass {     public int ID;     /* public static bool operator ==(MyClass c1, MyClass c2)     {         //下面这段代码中的“==”调用会进入递归，直至崩溃         if (c1 == null || c2 == null)         {  ...
C#入门：理解赋值操作符与表达式及其应用
这些操作符使得代码更加高效和紧凑，体现了C#中的运算符重载特性。 在学习C#时，这部分内容是基础语法的重要组成部分，它涉及到了变量的声明和更新，以及如何利用这些操作符进行高效的程序设计。同时，课程还会深入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值