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
Такие, как изменение внутр с поплавком, или наоборот.

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, долго долго, плавать и

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
У нас есть символ в 1 байт, Int и плавать на 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
из нулей и единиц.

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
Литье с плавающей точкой в ​​целое число вызовет усечение все

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
Если взять поплавок х, которая будет равна 3,7, мы можем бросить

65
00:03:02,000 --> 00:03:05,580
эта переменная х в целое число путем простого написания 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
Поэтому, когда мы бросили его в целое число которых только 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
значащих бит, примерно в семь значащих цифр.

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
бросили целые поплавков.

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
плавать переменной х.

100
00:04:35,640 --> 00:04:37,200
Таким образом, мы получаем целочисленное значение,

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
5 представляет собой целое число, в то время как 1.1 является поплавок.

110
00:04:59,480 --> 00:05:02,390
Для того, чтобы добавить их, компьютер ставит под 5 в поплавком,

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
Например, если мы имеем двойную х, Int у -

121
00:05:37,060 --> 00:05:40,120
и это может иметь любые значения, которые мы ставим их -

122
00:05:40,120 --> 00:05:43,560
мы можем сказать, х = у.

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
У равна х, потому что двойные может иметь большее значение, чем

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 является INT, но это будет приведен к поплавка для того, чтобы

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.