c# 自定义隐式转换与运算符重载

最新推荐文章于 2024-03-28 16:54:46 发布
最新推荐文章于 2024-03-28 16:54:46 发布
阅读量759 收藏 3
点赞数
分类专栏： 笔记 文章标签： c# 开发语言 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/anlog/article/details/128990227
版权

用户定义的显式和隐式转换运算符

参考代码

用户定义的显式和隐式转换运算符 - 提供对不同类型的转换 | Microsoft Learn

代码例程

using System;

public readonly struct Digit
{
    private readonly byte digit;

    public Digit(byte digit)
    {
        if (digit > 9)
        {
            throw new ArgumentOutOfRangeException(nameof(digit), "Digit cannot be greater than nine.");
        }
        this.digit = digit;
    }

    public static implicit operator byte(Digit d) => d.digit;
    public static explicit operator Digit(byte b) => new Digit(b);

    public override string ToString() => $"{digit}";
}

public static class UserDefinedConversions
{
    public static void Main()
    {
        var d = new Digit(7);

        byte number = d;
        Console.WriteLine(number);  // output: 7

        Digit digit = (Digit)number;
        Console.WriteLine(digit);  // output: 7
    }
}

自实现 隐式运算符转换例程

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

namespace ConsoleApp5
{
    class Person
    {
        public string Name { get; set; }
        public int age { get; set; }
        public Person(string name, int age)
        {
            Name = name;
            this.age = age;
        }

        /// <summary>
        /// 自定义隐式转换
        /// </summary>
        /// <param name="p"></param>
        public static  implicit operator string (Person p)
        {
            return p.Name;
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person("张三",20);
            Person p2 = new Person("李四", 30);
            string username = p1 + p2; //自定义对象隐式转换
            Console.WriteLine(username);
            Console.ReadLine();
        }
    }
}

运行结果

上面当然也可以适用于年龄，只需要修改返回值即可。

自实现 显式运算符转换例程

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

namespace ConsoleApp7
{
    class Person
    {
        public string Name { get; set; }
        public int age { get; set; }
        public Person(string name, int age)
        {
            Name = name;
            this.age = age;
        }

        /// <summary>
        /// 自定义隐式转换
        /// </summary>
        /// <param name="p"></param>
        //public static implicit operator string(Person p)
        //{
        //    return p.Name;
        //}

        //public static implicit operator Person(string name)
        //{
        //    return new Person(name, 0);
        //}
       
        ///运算符重载
        public static string operator +(Person p1, Person p2)
        {
            return p1.Name + p2.Name; 
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person("张三", 20);
            Person p2 = new Person("李四", 30);
            //string username = p1 + p2; //自定义对象隐式转换
            //Console.WriteLine(username);

            //Person p3 = "王五"; //强转，与视频中不同的时前面没有加括号
            //Person p3a = (Person)"赵六"; //视频中加了括号强转
            //Console.WriteLine(p3.Name + " " + p3.age.ToString());
            //Console.WriteLine(p3a.Name + " " + p3a.age.ToString());

            string username = p1 + p2; //自定义对象 + 重载
            Console.WriteLine(username);

            Console.ReadLine();
        }
    }
}

运行结果

与上面的相同，注意这里时显式运算符重载。

 

强制类型转换

自定义对象强转转换

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

namespace ConsoleApp6
{
    class Person
    {
        public string Name { get; set; }
        public int age { get; set; }
        public Person(string name, int age)
        {
            Name = name;
            this.age = age;
        }

        /// <summary>
        /// 自定义隐式转换
        /// </summary>
        /// <param name="p"></param>
        //public static implicit operator string(Person p)
        //{
        //    return p.Name;
        //}

        public static implicit operator Person(string name)
        {
            return new Person(name, 0);
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person("张三", 20);
            Person p2 = new Person("李四", 30);
            //string username = p1 + p2; //自定义对象隐式转换
            //Console.WriteLine(username);

            Person p3 = "王五"; //强转，与视频中不同的时前面没有加括号
            Person p3a = (Person)"赵六"; //视频中加了括号强转

            Console.WriteLine(p3.Name + " " + p3.age.ToString());
            Console.WriteLine(p3a.Name + " " + p3a.age.ToString());


            Console.ReadLine();
        }
    }
}

运行结果（注意没有初始化年龄，使用默认）

+运算符重载

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

namespace ConsoleApp8
{
    class Person
    {
        public string Name { get; set; }
        public int age { get; set; }
        public Person(string name, int age)
        {
            Name = name;
            this.age = age;
        }

        /// <summary>
        /// 自定义隐式转换
        /// </summary>
        /// <param name="p"></param>
        //public static implicit operator string(Person p)
        //{
        //    return p.Name;
        //}

        //public static implicit operator Person(string name)
        //{
        //    return new Person(name, 0);
        //}

        ///运算符重载
        public static string operator +(Person p1, Person p2)
        {
            return p1.Name + p2.Name;
        }

        public static Person operator ++(Person p)
        {
            p.age++;
            return p;
        }
    }
    internal class Program
    {
        static void Main(string[] args)
        {
            Person p1 = new Person("张三", 20);
            Person p2 = new Person("李四", 30);
            //string username = p1 + p2; //自定义对象隐式转换
            //Console.WriteLine(username);

            //Person p3 = "王五"; //强转，与视频中不同的时前面没有加括号
            //Person p3a = (Person)"赵六"; //视频中加了括号强转
            //Console.WriteLine(p3.Name + " " + p3.age.ToString());
            //Console.WriteLine(p3a.Name + " " + p3a.age.ToString());

            //string username = p1 + p2; //自定义对象 + 重载
            //Console.WriteLine(username);

            p1++;

            Console.WriteLine(p1.age.ToString());

            Console.ReadLine();
        }
    }
}

 运行结果（略）

附一个微软的例子

public readonly struct Fraction
{
    private readonly int num;
    private readonly int den;

    public Fraction(int numerator, int denominator)
    {
        if (denominator == 0)
        {
            throw new ArgumentException("Denominator cannot be zero.", nameof(denominator));
        }
        num = numerator;
        den = denominator;
    }

    public static Fraction operator +(Fraction a) => a;
    public static Fraction operator -(Fraction a) => new Fraction(-a.num, a.den);

    public static Fraction operator +(Fraction a, Fraction b)
        => new Fraction(a.num * b.den + b.num * a.den, a.den * b.den);

    public static Fraction operator -(Fraction a, Fraction b)
        => a + (-b);

    public static Fraction operator *(Fraction a, Fraction b)
        => new Fraction(a.num * b.num, a.den * b.den);

    public static Fraction operator /(Fraction a, Fraction b)
    {
        if (b.num == 0)
        {
            throw new DivideByZeroException();
        }
        return new Fraction(a.num * b.den, a.den * b.num);
    }

    public override string ToString() => $"{num} / {den}";
}

public static class OperatorOverloading
{
    public static void Main()
    {
        var a = new Fraction(5, 4);
        var b = new Fraction(1, 2);
        Console.WriteLine(-a);   // output: -5 / 4
        Console.WriteLine(a + b);  // output: 14 / 8
        Console.WriteLine(a - b);  // output: 6 / 8
        Console.WriteLine(a * b);  // output: 5 / 8
        Console.WriteLine(a / b);  // output: 10 / 4
    }
}

参考讲解实例，老师讲得非常好，希望大家多多关注ub主

c shape c# 自定义隐式转换与运算符重载_哔哩哔哩_bilibiliicon-default.png?t=N176https://www.bilibili.com/video/BV1rg411A7QU/?spm_id_from=333.1007.top_right_bar_window_history.content.click&vd_source=e821a225c7ba4a7b85e5aa6d013ac92e

特此记录

anlog

2023年2月11日

 

anlog
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c#问题 谁能解释下public static implicit operator float
10-16
c#问题 谁能解释下public static implicit operator float(currency value)中的operator是什么意思.txt
自定义隐式转换和显式转换c#简单例子
朱朱家园
12-23 3625
自定义隐式转换和显式转换c#简单例子 （出自朱朱家园http://blog.csdn.net/zhgl7688） 例子：对用户user中，用户名first name和last name进行转换成合成一个限定长度为10个字符新name。 自定义隐式转换： namespace transduction { public partial class transductionForm :
第二章 泛型
weixin_34405354的博客
07-02 111
20．泛型20.1泛型类声明泛型类声明是一个需要提供类型参数以形成实际类型的类的声明。   类声明可以有选择地定义类型参数。 class-declaration: （类声明） attributesopt class-modifiersopt  class identifieropt  type-parameter-listopt  class –baseopt  type-paramete...
用户自定义转换(隐式implicit、显式explicit)
寂蝶难双，窃窃思羽.
11-05 326
除了标准转换，我们还可以为类和结构定义隐式(implicit)和显式(explicit)转换。 用户自定义转换的约束 implicit(隐式转换) class Person { public string Name; public int Age; public Person(string name,int age) ...
C# 隐式转换
⊱MinG⊰ の 博
08-18 1443
下面几种类型的转换被称之为隐式转换 同一性转换 隐式数值转换 隐式枚举转换 隐式引用转换 包装转换 隐式常数表达式转换 用户自定义隐式转换 隐式转换可以在很多种情况下发生，包括函数子句调用，cast计算表达式和赋值语句。 预定义的隐式转换总会成功而且不会引发异常，适当合理的用户自定义隐式转换也可以展示出这些 特性。 一. 同一性转换 同一性...
C#重载运算符详解
09-04
总之，C#中的运算符重载允许我们扩展自定义类型的功能，使其能更好地适应各种计算场景。正确地重载运算符不仅可以提高代码的可读性，还能提升开发效率。但要注意，过度或不恰当的运算符重载可能会导致混淆，因此在...
复数运算符重载
03-26
3. **隐式类型转换**：有时，我们希望将`ComplexNumber`与`double`进行运算，这时可以重载隐式类型转换运算符。这允许我们将`double`值视为`ComplexNumber`，从而实现与复数的混合运算。 4. **代码示例**：创建一个...
VS2010轻松学习C#-从零到深入-天轰穿.NET4趣味编程视频教程_第16讲：运算符重载
07-26
总之，运算符重载是C#编程中的一个重要主题，它让类和结构能够更加灵活地与标准运算符结合使用。在本视频教程的第16讲中，通过天轰穿老师的指导，学习者将能够熟练地运用运算符重载这一功能，从而在.NET 4框架下编写...
c#之用户定义的数据类型转换介绍
09-04
与隐式转换不同，显式转换需要在转换时使用 `(TargetType)source` 的形式。这样可以提醒程序员转换可能会有问题，需要特别注意。 让我们看一个具体的例子： ```csharp struct Current { public uint Dollars; ...
C#中自定义类型转换
cloproad的博客
01-19 4286
类型转换
C#基础—隐式转换与显示转换
weixin_30613343的博客
04-03 515
C#的隐式类型转换 在C#语言中，一些预定义的数据类型之间存在着预定义的转换。比如，从int类型转换到long类型。C#语言中数据类型的转换可以用分为两 类：隐式转换(implicit conversions)和显式转换(explicit conversions)。这篇文章我们将详细介绍这两类转换。 1. 隐式类型转换 隐式转换就是系统默认的、不需要加以声明就可以...
LMI Gocator GoSDK C#开发学习笔记(二)
SLRiver的博客
09-17 1360
加油
C#入门之隐式转换、显示转换
MagicianThirteen
02-15 2709
类型转换 （一）隐式转换 隐式转换的基本规则：不同类型之间的自动转换（一般都是属于一种比如都是整型或者都是浮点），大范围装小范围，比如long可以装int，但特殊类型bool，char，string之间是不存在隐式转换的。 有符号可以隐式转换无符号的，但是要大范围装小范围。 浮点数可以装载任何类型得整数，当超过有效数字位后，会用科学计数法。 decimal不能隐式得转float和double，但是可以转各种类型得整数。 整数不能隐式得转浮点，因为整数不能存小数 char类型的字符对应的数字就是个ascii码
C# 运算符
Lishuangyu的专栏
09-14 551
定义：运算符是用于执行特定的数学或逻辑操作的符号。
实习回顾学习 c# 函数 （含源码和运算符重载自定义转换）
猪猪的博客
02-01 145
对于书籍学习函数基础复习总结
C# 参考之转换关键字：operator、explicit与implicit
ants717007的博客
06-20 292
(转自)C# 参考之转换关键字：operator、explicit与implicit operator operator 关键字用于在类或结构声明中声明运算符。运算符声明可以采用下列四种形式之一： public static result-type operator unary-operator ( op-type operand ) ...
C#基础 （类型转换_隐式转换）
qq_24977805的博客
04-28 1267
隐式转换的基本规则——>不同类型之间自动转换。总结 隐式转换 规则。
C#之Convert.ToInt32()和int.Parse()的区别
Kevin_Sun777的博客
11-09 2607
C#之Convert.ToInt32()和int.Parse()的区别 1、Convert.ToInt32()是将继承于object类的对象转换成int； int.Parse()只能将String类的对象转换成int，即括号中的数据类型只能是String类型 2、对NULL值得处理：Convert.ToInt32(null)会返回0而不会产生任何异常，但int.Parse(null)则会产生异常 3、当括号中得数据类型为double型时： （1）Convert.ToInt32(double val
C# 隐式转换与显示转换
最新发布
2301_80261851的博客
03-28 729
隐式转换，就是不需要声明就能进行的转换，编译器不需要进行检查就能自动进行的转换。
C#高级编程：运算符重载与类型转换解析
`J结-hta8533-md-007yy_使用说明书_v1.1_20170302`可能是一个关于C#自定义类型和运算符重载的详细指南，帮助开发者更好地理解和利用C#的这些高级特性，以创建高效且易于理解的代码。在实际开发中，熟练掌握这些知识...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值