1
00:00:07,632 --> 00:00:10,270
[Powered by Google Translate] JORDAN JOZWIAK：在最简单的意义上，类型转换，是一个

2
00:00:10,270 --> 00:00:13,300
改变计算机的一些数据解释

3
00:00:13,300 --> 00:00:16,560
隐式或显式地改变它的数据类型。

4
00:00:16,560 --> 00:00:19,940
如改变一个int浮动，反之亦然。

5
00:00:19,940 --> 00:00:21,550
要了解类型转换，我们需要

6
00:00:21,550 --> 00:00:22,680
从基础开始 - 

7
00:00:22,680 --> 00:00:24,140
数据类型本身。

8
00:00:24,140 --> 00:00:26,960
在计算机语言，如C，所有的变量有某种

9
00:00:26,960 --> 00:00:29,690
数据类型，它决定电脑，同样地

10
00:00:29,690 --> 00:00:32,140
用户，解释变量。

11
00:00:32,140 --> 00:00:35,160
如如int，long，float和数值数据类型

12
00:00:35,160 --> 00:00:38,110
双，都有自己独特的特点，并

13
00:00:38,110 --> 00:00:41,370
用于指定值的变化范围和精度。

14
00:00:41,370 --> 00:00:44,800
类型强制转换，使我们能够采取这样一个浮点数

15
00:00:44,800 --> 00:00:49,170
3.14和小数点之前的部分，3在这种情况下，

16
00:00:49,170 --> 00:00:51,590
铸造为int。

17
00:00:51,590 --> 00:00:53,900
让我们举个例子，一个简短的英语

18
00:00:53,900 --> 00:00:56,910
审查类型，类型转换，如何改变

19
00:00:56,910 --> 00:00:59,380
我们解释的一组数据。

20
00:00:59,380 --> 00:01:05,269
对于数据，让我们在这里的符号。

21
00:01:05,269 --> 00:01:07,570
我只是指这些精心配置的线

22
00:01:07,570 --> 00:01:10,100
符号，但谁知道英语的人，

23
00:01:10,100 --> 00:01:12,750
你立即认出他们，其实，字母。

24
00:01:12,750 --> 00:01:15,580
你含蓄地理解数据类型。

25
00:01:15,580 --> 00:01:17,620
在这串字母中，我们可以看到两个

26
00:01:17,620 --> 00:01:20,140
不同的词，每个都有其自己的含义。

27
00:01:20,140 --> 00:01:25,530
有名词，风，在以外的风吹。

28
00:01:25,530 --> 00:01:28,280
有动词，风，在我需要

29
00:01:28,280 --> 00:01:31,410
风我的模拟手表。

30
00:01:31,410 --> 00:01:33,420
这是一个有趣的例子，因为我们可以看到

31
00:01:33,420 --> 00:01:36,270
该类型如何，我们分配给我们的数据，无论是名词或

32
00:01:36,270 --> 00:01:39,080
动词的时候，我们如何使用这些数据的变化 - 

33
00:01:39,080 --> 00:01:41,730
词风或风。

34
00:01:41,730 --> 00:01:44,100
尽管计算机不关心语法和零部件

35
00:01:44,100 --> 00:01:47,750
英语演讲，适用于同样的基本原则。

36
00:01:47,750 --> 00:01:50,290
也就是说，我们可以改变的确切解释

37
00:01:50,290 --> 00:01:53,140
相同的数据存储在内存中简单地将它转换为

38
00:01:53,140 --> 00:01:54,576
不同的类型。

39
00:01:54,576 --> 00:01:57,250
下面是一个32位的最常见的类型的大小

40
00:01:57,250 --> 00:01:58,340
操作系统。

41
00:01:58,340 --> 00:02:02,070
我们有一个char 1个字节中，int和float 4个字节，长

42
00:02:02,070 --> 00:02:04,390
长和双8个字节。

43
00:02:04,390 --> 00:02:07,670
因为int占用4个字节，它会占用32位

44
00:02:07,670 --> 00:02:10,060
当它被存储在存储器中，作为一个二进位序列

45
00:02:10,060 --> 00:02:11,500
0和1。

46
00:02:11,500 --> 00:02:14,020
只要我们的变量仍然是一个int类型，

47
00:02:14,020 --> 00:02:16,740
电脑总是转换的那些和零

48
00:02:16,740 --> 00:02:19,120
二进制到原来的数量。

49
00:02:19,120 --> 00:02:21,270
不过，我们可以从理论上投那些32

50
00:02:21,270 --> 00:02:23,510
成一系列的布尔类型的位。

51
00:02:23,510 --> 00:02:26,090
然后电脑就再也看不到了一些，但

52
00:02:26,090 --> 00:02:28,810
，而不是零和一的集合。

53
00:02:28,810 --> 00:02:31,570
我们也可以尝试不同的数字来读取该数据

54
00:02:31,570 --> 00:02:34,660
类型，甚至作为一个四个字符的字符串。

55
00:02:34,660 --> 00:02:37,820
在铸造与数字打交道时，你必须考虑如何

56
00:02:37,820 --> 00:02:40,470
您的值的精度将受到影响。

57
00:02:40,470 --> 00:02:43,240
请记住，精度可保持不变，

58
00:02:43,240 --> 00:02:47,150
或者你可能会失去精度，但你永远无法获得精确。

59
00:02:47,150 --> 00:02:49,060
让我们通过三种最常见的方式，你可以

60
00:02:49,060 --> 00:02:50,400
失去精度。

61
00:02:50,400 --> 00:02:53,060
铸造持股量为int类型会导致截断一切

62
00:02:53,060 --> 00:02:54,900
小数点后的，所以你离开

63
00:02:54,900 --> 00:02:55,950
整个号码。

64
00:02:55,950 --> 00:03:02,000
如果我们把持股量x，它等于3.7，我们可以投

65
00:03:02,000 --> 00:03:05,580
这个变量x为int，简单地写int的

66
00:03:05,580 --> 00:03:07,050
括号内。

67
00:03:07,050 --> 00:03:10,010
当我们使用这个术语在这里，我们将有效地

68
00:03:10,010 --> 00:03:12,810
使用的价值，因为我们三个已经被截断

69
00:03:12,810 --> 00:03:14,880
小数点后的一切。

70
00:03:14,880 --> 00:03:17,210
我们也可以转换为int很长很长，这将

71
00:03:17,210 --> 00:03:20,760
同样导致亏损高阶位。

72
00:03:20,760 --> 00:03:23,910
很长很长占用8个字节或64位内存。

73
00:03:23,910 --> 00:03:27,050
所以，当我们将它转​​换为一个int，它只有4个字节，即32

74
00:03:27,050 --> 00:03:29,820
位，我们基本上是砍掉所有的位

75
00:03:29,820 --> 00:03:32,420
代表更高的二进制值。

76
00:03:32,420 --> 00:03:34,690
你也可以蒙上了双浮动，这将给

77
00:03:34,690 --> 00:03:37,340
你最接近的可能浮动的双重不

78
00:03:37,340 --> 00:03:39,100
一定四舍五入。

79
00:03:39,100 --> 00:03:41,840
很长很长的int转换，损失在相似

80
00:03:41,840 --> 00:03:44,890
精度是因为双包含更多的数据。

81
00:03:44,890 --> 00:03:47,910
双将允许你存储53重要位，

82
00:03:47,910 --> 00:03:50,650
大概16个显着的数字。

83
00:03:50,650 --> 00:03:53,050
而一个浮动将只允许你存储24个

84
00:03:53,050 --> 00:03:56,235
重要的位，数字大约7显著。

85
00:03:56,235 --> 00:03:58,700
在这两种情况下，它可能是可以认为，

86
00:03:58,700 --> 00:04:01,200
类型强制转换和调整大小的照片。

87
00:04:01,200 --> 00:04:03,860
当你从大尺寸到小尺寸的，你看不到

88
00:04:03,860 --> 00:04:05,600
事情清楚，因为你丢失的数据

89
00:04:05,600 --> 00:04:07,530
在像素的形式。

90
00:04:07,530 --> 00:04:09,270
类型转换，也会造成一些麻烦时，我们

91
00:04:09,270 --> 00:04:11,050
投int型浮动。

92
00:04:11,050 --> 00:04:13,920
由于漂浮在一个32位的机器只有24

93
00:04:13,920 --> 00:04:16,959
显着的位，它们不能准确地表示的值

94
00:04:16,959 --> 00:04:22,750
超过2 24 16777217的力量。

95
00:04:22,750 --> 00:04:25,540
现在让我们来谈谈显式和隐式转换。

96
00:04:25,540 --> 00:04:28,000
显式转换是当我们写在括号内的类型

97
00:04:28,000 --> 00:04:29,430
前一个变量名。

98
00:04:29,430 --> 00:04:33,100
作为一个例子，我们写int在括号之前，我们的

99
00:04:33,100 --> 00:04:35,640
浮动变量x。

100
00:04:35,640 --> 00:04:37,200
在这种方式中，我们得到的int值，

101
00:04:37,200 --> 00:04:38,593
截断值3.7  - 

102
00:04:38,593 --> 00:04:40,370
3。

103
00:04:40,370 --> 00:04:42,970
隐式转换时，编译器会自动改变

104
00:04:42,970 --> 00:04:46,340
同类型的超类型，或执行一些其他类型的

105
00:04:46,340 --> 00:04:48,310
铸造而无需用户写

106
00:04:48,310 --> 00:04:49,720
任何额外的代码。

107
00:04:49,720 --> 00:04:53,550
例如，当我们添加5和1.1，我们的价值观已经有

108
00:04:53,550 --> 00:04:55,680
与他们相关联的类型。

109
00:04:55,680 --> 00:04:59,480
的是一个int，而1.1是一个浮点数。

110
00:04:59,480 --> 00:05:02,390
为了增加他们的计算机转换成浮动，

111
00:05:02,390 --> 00:05:04,530
这将是同样的事情写在5.0

112
00:05:04,530 --> 00:05:06,476
第一的位置。

113
00:05:06,476 --> 00:05:13,210
但是，这就像我们说的持股量5或5.0，再加上已经

114
00:05:13,210 --> 00:05:16,960
浮动，1.1，和从那里，我们其实可以添加这些

115
00:05:16,960 --> 00:05:18,640
值，并获得价值6.1。

116
00:05:21,170 --> 00:05:23,500
隐式转换，也让我们给变量赋值

117
00:05:23,500 --> 00:05:25,590
彼此的不同类型。

118
00:05:25,590 --> 00:05:28,110
我们总是可以分配一个不太精确的类型更

119
00:05:28,110 --> 00:05:29,250
精确的。

120
00:05:29,250 --> 00:05:37,060
例如，如果我们有一个的双重X，诠释y  - 

121
00:05:37,060 --> 00:05:40,120
能有什么价值，我们将其设置为 - 

122
00:05:40,120 --> 00:05:43,560
我们可以说，x等于y。

123
00:05:43,560 --> 00:05:46,340
因为双比int更精确，所以我们

124
00:05:46,340 --> 00:05:48,380
不会丢失任何信息。

125
00:05:48,380 --> 00:05:50,420
另一方面，它不一定是正确的说

126
00:05:50,420 --> 00:05:54,060
y等于的x，因为双可能有一个较大的值比

127
00:05:54,060 --> 00:05:55,220
的整数。

128
00:05:55,220 --> 00:05:57,420
这样一来，的整数可能无法容纳所有的

129
00:05:57,420 --> 00:05:59,560
的信息存储在一个双。

130
00:05:59,560 --> 00:06:02,610
也用在隐式铸造等比较运算符

131
00:06:02,610 --> 00:06:06,410
大于，小于或相等运算符。

132
00:06:06,410 --> 00:06:13,050
通过这种方式，我们可以说，如果5.1大于5，我们得到的

133
00:06:13,050 --> 00:06:14,750
导致真实的。

134
00:06:14,750 --> 00:06:18,470
因为5是一个整数，但它会被转换为float，以

135
00:06:18,470 --> 00:06:22,090
相比的浮动5.1，我们要说：5.1

136
00:06:22,090 --> 00:06:24,550
大于5.0。

137
00:06:24,550 --> 00:06:31,320
同样是真实的说，如果2.0等于等于2。

138
00:06:31,320 --> 00:06:34,190
同时，我们还会得到真正的，因为计算机将投

139
00:06:34,190 --> 00:06:39,750
整数2浮动，然后说2.0等于等于2.0，

140
00:06:39,750 --> 00:06:41,660
这是真实的。

141
00:06:41,660 --> 00:06:44,180
不要忘了，我们也可以整型和字符之间转换，

142
00:06:44,180 --> 00:06:46,350
或ASCII值。

143
00:06:46,350 --> 00:06:49,690
字符数也将减少到二进制，这就是为什么你

144
00:06:49,690 --> 00:06:51,920
可以很容易地转换成字符和它们各自的

145
00:06:51,920 --> 00:06:53,260
ASCII值。

146
00:06:53,260 --> 00:06:56,180
要了解更多关于这一点，看看我们的视频ASCII。

147
00:06:56,180 --> 00:06:58,080
当你需要时间来考虑如何存储数据的，

148
00:06:58,080 --> 00:06:59,990
它开始有很大的意义。

149
00:06:59,990 --> 00:07:02,790
这就像顺风和逆风之间的差异。

150
00:07:02,790 --> 00:07:05,490
数据是一样的，但类型可以改变我们的

151
00:07:05,490 --> 00:07:06,720
解释。

152
00:07:06,720 --> 00:07:10,430
我的名字是乔丹Jozwiak，这CS50。