CS1L6——隐式转换

隐式转换

隐式转换就是某些变量类型按照隐式转换的规则，可以直接转变为另一种变量类型
大致要点是：大集合完全包含的小集合，小集合即可转换为大集合

隐式转换的规则

相同类型的隐式转换

​sbyte​ -> short​ -> int​ -> long​（小范围的类型可以隐式转换为大范围类型）

1
2
3
4
5
6
7
8
9
10
11
sbyte sb = 1; // -128~127
int i = 1;  //  -21亿~21亿
short s = 1;    //  -32768~32767
long l = 1;    //  -九百万兆~九百万兆

s = sb;
i = sb;
i = s;
l = sb;
l = s;
l = i;

无符号 byte​ -> ushort​ -> uint​ -> ulong​（小范围的类型可以隐式转换为大范围类型）

1
2
3
4
5
6
7
8
9
10
11
byte b = 1;    //  0~255
uint ui = 1;    //  0~42亿
ushort us = 1;  //  0~65535
ulong ul = 1;   //  0~18百万兆

us = b;
ui = b;
ui = us;
ul = b;
ul = us;
ul = ui;

​float​ -> double​
​decimal​ 不与其他两种浮点数转换

1
2
3
float f = 1.1f;
double d = 1.1;
d = f;

特殊类型 bool​，string​，char​ 之间不存在隐式转换

不同大类型的隐式转换

无符号不能装有符号的
有符号装无符号，若无符号的范围小于该有符号的范围则可以隐式转换

1
2
3
4
5
6
s = b;
i = b;
i = us;
l = b;
l = us;
l = ui;

浮点数可以装所有的整数类型，过大的整数以科学计数法计数

1
2
3
4
decimal de = 1.0m;
f = ul;
d = ul;
de = ul;

整数不能装浮点数

​bool​，string​ 与其他任何类型都不能相互隐式转换

其他类型不能转换为 char​

​char​ 可以隐式转换为 ushort​ 以及比 ushort​ 更大范围的整形和浮点型

1
2
3
4
5
6
7
8
us = c;
i = c;
l = c;
ui = c;
ul = c;
f = c;
d = c;
de = c;

本课源代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
namespace lesson6隐式转换
{
    internal class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("隐式转换（要点：大集合完全包含的小集合，小集合即可转换为大集合）");
            #region 变量申明
            //1、有符号的整形变量 能存储一定范围内的正负数包括0的变量类型
            sbyte sb = 1; // -128~127
            int i = 1;  //  -21亿~21亿
            short s = 1;    //  -32768~32767
            long l = 1;    //  -九百万兆~九百万兆
            //2、无符号的整型变量 能存储一定范围内0和正数的变量类型
            byte b = 1;    //  0~255
            uint ui = 1;    //  0~42亿
            ushort us = 1;  //  0~65535
            ulong ul = 1;   //  0~18百万兆
            //3、浮点数（小数）
            float f = 0.1f;    //  数字后必须加f声明float，因为小数会被默认为double，从非0数算起为有效数字，7/8位有效数字，根据编译器不同有可能不同，超出部分会四舍五入
            double d = 0.1;    //  从非0数算起为有效数字，15~17位有效数字，超出部分会四舍五入
            decimal de = 0.1m;    //  数字后必须加m声明，因为小数会被默认为double，27~28位有效数字，不建议使用
            //4、特殊类型
            bool bo = true; //  true或者false
            char c = 'a';   //  需要加'',单个字符
            string st = "hello";    //  需要加"",字符串
            #endregion

            #region 相同类型的隐式转换
            // 有符号  sbyte -> short -> int -> long（小范围的类型可以隐式转换为大范围类型）
            s = sb;
            i = sb;
            i = s;
            l = sb;
            l = s;
            l = i;
            // 无符号  byte -> ushort -> uint -> ulong（小范围的类型可以隐式转换为大范围类型）
            us = b;
            ui = b;
            ui = us;
            ul = b;
            ul = us;
            ul = ui;
            // 浮点数  float -> double | decimal不与其他两种浮点数转换
            d = f;
            // 特殊类型 bool,string,char不存在隐式转换
            #endregion

            #region 不同大类型的隐式转换
            //无符号不能装有符号的
            //有符号装无符号   若无符号的范围小于该有符号的范围则可以隐式转换
            s = b;
            i = b;
            i = us;
            l = b;
            l = us;
            l = ui;
            //浮点数装整数    所有浮点数都可以装所有的整数类型，过大的数以科学计数法计数   
            f = ul;
            d = ul;
            de = ul;
            //整数不能装浮点数
            //bool与其他任何类型不能相互隐式转换
            //其他类型不能转换为char
            //char可以隐式转换为ushort及比ushort更大范围的整形和浮点型（原理:char可以转化为对应的Unicode码，Unicode码最多有65536个，与ushort相同）
            us = c;
            i = c;
            l = c;
            ui = c;
            ul = c;
            f = c;
            d = c;
            de = c;
            //string与其他任何类型不能相互隐式转换
            #endregion
        }
    }
}

‍