Nullable类型，C#溢出检查，typeof运算符和运算符的重载

迈不过友情╰ 2022-05-19 14:14 164阅读 0赞

1）Nullable类型

一个Nullable类型就是基本类型加上一个“是否为null指示器”的合成类型。对于一个类型，如果既可以给它分配一个值，也可以给它分配null引用（表示没有任何值），我们就说这个类型是可以空的。因此，可空类型可表示一个值，或表示不存在任何值。例如，类似String的引用类型就是可空类型，而类似Int32的值类型不是可空类型。由于值类型的容量只够表示适合于该类型的值，因此它不可为空。

有些人认为int型变量的值为0就表示空，这是不对的，0也是它的值，而并不表示空。

看下面的代码演示：

1 static void Main(string[] args)
     2         {
     3             //int n = null;
     4             //当直接给int类型赋值null时，编译器报错“无法将Null型转化为int型，因为它是一种不可以为null型的类型”
     5             int? oneValue = null;
     6             //定义Nullable类型和定义非Nullable类型非常相似，关键在于类型后面的修饰符“？”
     7             //int? oneValue = 10;
     8             if (oneValue.HasValue)//使用Nullable类型的HasValue属性来判定是否有值存储
     9             {
    10                 //int nNum = oneValue;
    11                 //如果尝试获取oneValue的值，编译器就会报错
    12                 Console.WriteLine(oneValue.Value);
    13             }
    14             else
    15             {
    16                 Console.WriteLine("oneValue的值为空！");
    17             }
    18         }

2)C\#的溢出检查

当一种整型转换到另一种整型，这个过程取决于溢出检查上下文。checked关键字用于对整型算术运算和转换显式启用溢出检查，而unchecked关键字则用于取消整型算术运算和转换的溢出检查。

①启用溢出检查：当操作数的值在目标类型的取值范围内，则转换成功，否则将要抛出异常。

看下面代码演示：

1 class TypeConvert
     2     {
     3         static void Main(string[] args)
     4         {
     5             TypeConvert typeConvert = new TypeConvert();
     6             typeConvert.DoSomething();
     7         }
     8 
     9         public void DoSomething()
    10         {
    11             //MyInt的值为2147483647
    12             try
    13             {
    14                 int MyInt = int.MaxValue;
    15                 byte MyByte = checked((byte)MyInt);
    16             }
    17             catch(OverflowException)
    18             {
    19                 throw;
    20             }
    21         }
    22     }

在代码中MyInt的最大值是2147483647，在强制转换为byte类型后，由于byte的取值范围为0-255，在这里使用了checked关键字进行了溢出检查，这里的byte型MyByte型无法容纳远大于其容量的值而抛出异常。

②取消溢出检查

在类型转换的过程中不检查数据是否超过目标数据类型的最大值，意味着类型转换永远是成功的。如果源数据类型的取值范围大于目标类型的取值范围，超过的部分将会被截取掉；如果源数据的取值范围小于目标类型的，转换后将使用符号或者零填充至与目标类型的大小相等；如果等于，则直接转换成目标类型

看实例代码如下：

1  1 class TypeConvert
     2  2     {
     3  3         static void Main(string[] args)
     4  4         {
     5  5             TypeConvert typeConvert = new TypeConvert();
     6  6             typeConvert.DoSomething();
     7  7         }
     8  8 
     9  9         public void DoSomething()
    10 10         {
    11 11             //MyInt的值为2147483647
    12 12             try
    13 13             {
    14 14                 int MyInt = int.MaxValue;
    15 15         //byte MyByte = unchecked(byte)MyInt;
    16 16         //这样写与下面的写法一样，区别就是生命了关键字
    17 17                 byte MyByte = (byte)MyInt;
    18 18         //这里没有使用溢出检查，结果也不会抛出异常。但是转换的结果是有问题的，是byte类型的最大值255，与原始的值相差很大。
    19 19             }
    20 20             catch(OverflowException)
    21 21             {
    22 22                 throw;
    23 23             }
    24 24         }
    25 25     }

③typeof运算符

typeof是一元运算符，用于返回任意一个类型的类型信息  
typeof运算符的语法如下：  Type type=typeof（类型）;  
示例代码演示如下：

1 class Program
     2     {
     3         static void Main(string[] args)
     4         {
     5             Type t = typeof(Program);
     6             Console.WriteLine("方法：");
     7 
     8             MethodInfo[] methodInfo = t.GetMethods();
     9             //返回该Type类型的所有公共方法
    10             foreach (MethodInfo mInfo in methodInfo)
    11             {
    12                 Console.WriteLine(mInfo.ToString());
    13             }
    14 
    15             Console.WriteLine("成员：");
    16             MemberInfo[] memberInfo = t.GetMembers();
    17             //返回该Type类型的所有公共成员
    18             foreach (MemberInfo mInfo in methodInfo)
    19             {
    20                 Console.WriteLine(mInfo.ToString());
    21             }
    22 
    23             Console.ReadKey();
    24         }
    25     }

运行结果如下图：

![1351425229_3816.png][]

④运算符的重载  
运算符重载只能应用于类或结构。要重载一个运算符，可以声明一个名为operator X的方法并实现它，如operator +和operator -，一元运算符和二元运算符都可以被重载，相应地，重载方法分别带一个或者两个参数（类或者结构类型），其语法为：  
 //一元运算符的重载         
 public static 自定义类型 operator 要重载的运算符（类型）         
//二元运算符的重载         
 public static 自定义类型 operator 要重载的运算符（类型1，类型2）

注意：所有运算符的重载均是静态的方法，必须得用public修饰  
代码示例如下：

1 class Program
     2     {
     3         public int Value { get;set; }
     4 
     5         static void Main(string[] args)
     6         {
     7             Program o1 = new Program();
     8             o1.Value = 10;
     9             Program o2 = new Program();
    10             o2.Value = 20;
    11 
    12             Program o3 = o1 + o2;
    13             Console.WriteLine(o3.Value);
    14             Console.ReadKey();
    15         }
    16 
    17         /// <summary>
    18         /// 这里为Program类重载了“加（+）”运算符实现了两个对象的相加的功能，运算符的重载提高了编程的便利性
    19         /// </summary>
    20         /// <param name="o1"></param>
    21         /// <param name="o2"></param>
    22         /// <returns></returns>
    23         public static Program operator +(Program o1, Program o2)
    24         {
    25             Program o = new Program();
    26             o.Value = o1.Value + o2.Value;
    27             return o;
    28         }
    29     }

--------------------

原创作品，允许转载，转载时请务必以超链接形式标明文章 原始出处 、作者信息和本声明。否则将追究法律责任。

[![1.png][]][1.png 1]

[1351425229_3816.png]: https://img-my.csdn.net/uploads/201210/28/1351425229_3816.png
[1.png]: /images/20220519/d506dd9b1a12468ca8432867e94a4f3a.png
[1.png 1]: http://weibo.com/u/1770922665?s=6uyXnP