1
00:00:00,000 --> 00:00:10,920
>> [Музыка Воспроизведение]

2
00:00:10,920 --> 00:00:14,680
>> David J МАЛАН: Ладно,
добро пожаловать обратно в CS50.

3
00:00:14,680 --> 00:00:16,500
Это начало второй недели.

4
00:00:16,500 --> 00:00:18,940
Слово из одного из наших
друзья на территории кампуса -

5
00:00:18,940 --> 00:00:22,620
если вы заинтересованы, вероятно, либо
сейчас или в будущем срока

6
00:00:22,620 --> 00:00:25,670
даже после того, как более удобный, обучение
учащихся средних школ немного

7
00:00:25,670 --> 00:00:27,680
что-то об информатике,
сделать голову, что URL-адрес.

8
00:00:27,680 --> 00:00:32,360
Им, в частности нужно прямо сейчас из
учителей, в частности, если у вас есть

9
00:00:32,360 --> 00:00:34,700
были некоторые воздействия информатики.

10
00:00:34,700 --> 00:00:38,060
>> Поэтому напомним, что в прошлый раз, мы ввели
нескольких типов данных в C, и

11
00:00:38,060 --> 00:00:40,590
Вы, возможно, начали, чтобы получить
руки грязные с этим до сих пор

12
00:00:40,590 --> 00:00:41,940
В задачу, поставленную один.

13
00:00:41,940 --> 00:00:43,230
И у нас был символ.

14
00:00:43,230 --> 00:00:49,100
Таким образом, в несколько технических терминов, что
является символами, как вы знаете, что на сегодняшний день?

15
00:00:49,100 --> 00:00:51,050
>> Так что это характер, но давайте
Точнее теперь.

16
00:00:51,050 --> 00:00:53,735
Что мы понимаем под характером
или отдельных символов?

17
00:00:53,735 --> 00:00:56,700

18
00:00:56,700 --> 00:00:59,500
Нечисловой символ -

19
00:00:59,500 --> 00:01:00,670
так не обязательно.

20
00:01:00,670 --> 00:01:04,580
Получается, что четные числа, даже
знаков препинания и букв

21
00:01:04,580 --> 00:01:06,980
представлены с этими данными
типа, известного как символ.

22
00:01:06,980 --> 00:01:09,440
Так что это не обязательно в алфавитном порядке.

23
00:01:09,440 --> 00:01:11,100
Да?

24
00:01:11,100 --> 00:01:12,275
>> Так что это ASCII символ.

25
00:01:12,275 --> 00:01:15,510
Так что, если вы вспомните нулевой неделе, когда
у нас были наши добровольцы байт

26
00:01:15,510 --> 00:01:19,150
придумать и либо держать поднятыми вверх руками
или не все, они представляли бит.

27
00:01:19,150 --> 00:01:22,450
Но все вместе как группа из восьми,
они представляли собой байта.

28
00:01:22,450 --> 00:01:26,030
И мы ввели понятие ASCII
в то лекции, которая просто

29
00:01:26,030 --> 00:01:28,170
соответствие между цифрами и буквами.

30
00:01:28,170 --> 00:01:32,010
И ASCII применений, как те люди
подразумеваемые, восемь бит

31
00:01:32,010 --> 00:01:33,660
для представления символа.

32
00:01:33,660 --> 00:01:36,890
>> Таким образом, соответственно, если восемь битов может
каждая принимать одно из двух значений -

33
00:01:36,890 --> 00:01:38,010
ноль или один -

34
00:01:38,010 --> 00:01:40,280
Это означает, что две возможности
для этого человека -

35
00:01:40,280 --> 00:01:41,230
ноль или один -

36
00:01:41,230 --> 00:01:44,070
две для этого человека, две для этого
лицо, две для этого.

37
00:01:44,070 --> 00:01:47,450
Таким образом, в общей сложности два раза в два раза
два раза дважды два -

38
00:01:47,450 --> 00:01:49,700
так что два восьмым в общей сложности.

39
00:01:49,700 --> 00:01:54,320
Так что общее количество символов
256 Возможно, что вы можете

40
00:01:54,320 --> 00:01:55,750
представлять с восемью битами.

41
00:01:55,750 --> 00:01:59,210
>> Теперь, те из вас, кто говорит Азиатский
языков может знать, что есть больше

42
00:01:59,210 --> 00:02:02,620
символов в мире, чем просто
И × и Cs и Ds.

43
00:02:02,620 --> 00:02:06,130
И действительно, ASCII не хватает для
многие языки мира.

44
00:02:06,130 --> 00:02:07,760
Но об этом в другой раз.

45
00:02:07,760 --> 00:02:11,240
На данный момент известно, что в C, если вы хотите
представлять письмо, кусок

46
00:02:11,240 --> 00:02:15,780
пунктуации, или просто что-то характер
в природе, мы используем символ.

47
00:02:15,780 --> 00:02:18,240
И это один байт или восемь бит.

48
00:02:18,240 --> 00:02:19,690
>> Как насчет десятичного?

49
00:02:19,690 --> 00:02:20,780
Ну, Целочисленное является целым числом.

50
00:02:20,780 --> 00:02:23,175
Сколько битов, если вы помните,
было целое обычно?

51
00:02:23,175 --> 00:02:25,930

52
00:02:25,930 --> 00:02:27,512
Любой напомнить?

53
00:02:27,512 --> 00:02:29,600
Так оно, как правило 32.

54
00:02:29,600 --> 00:02:32,120
Это на самом деле зависит от компьютера
что вы используете.

55
00:02:32,120 --> 00:02:35,770
Но в приборе, и в большом количестве
Компьютеры, это 32 бита или четыре

56
00:02:35,770 --> 00:02:37,140
байт - восемь раз четыре.

57
00:02:37,140 --> 00:02:39,790
И целых чисел используются только для хранения
числами, либо отрицательным,

58
00:02:39,790 --> 00:02:41,610
положительное или ноль.

59
00:02:41,610 --> 00:02:45,250
>> И если у вас есть 32 бита, и вы только
заботятся о положительных чисел, может

60
00:02:45,250 --> 00:02:48,960
любой стадион, сколько возможных
целые компьютера могут составлять от

61
00:02:48,960 --> 00:02:51,820
нулю на до?

62
00:02:51,820 --> 00:02:56,130
Поэтому было бы в два-32, который
примерно в четыре миллиарда долларов.

63
00:02:56,130 --> 00:02:59,720
Таким образом, эти двойки будут
повторяющиеся темы в области компьютерных наук.

64
00:02:59,720 --> 00:03:03,930
Как мы увидим, они довольно удобно
работать с, даже если это не совсем

65
00:03:03,930 --> 00:03:05,790
Легко делать математику в голове.

66
00:03:05,790 --> 00:03:07,000
>> Поэтому мы будем говорить примерно в четыре миллиарда долларов.

67
00:03:07,000 --> 00:03:08,620
Теперь, очень долго -

68
00:03:08,620 --> 00:03:09,770
Вы можете вида предположение.

69
00:03:09,770 --> 00:03:10,480
Это дольше, чем Int.

70
00:03:10,480 --> 00:03:12,440
Сколько битов?

71
00:03:12,440 --> 00:03:14,250
Так 64 бит или восемь байт.

72
00:03:14,250 --> 00:03:17,480
Это просто означает, что вы можете представлять даже
большие числа, большие положительные или

73
00:03:17,480 --> 00:03:19,160
больше отрицательных чисел.

74
00:03:19,160 --> 00:03:20,060
>> А как насчет плавать?

75
00:03:20,060 --> 00:03:22,260
Вот с плавающей точкой
значение 32 бит.

76
00:03:22,260 --> 00:03:25,180
Это всего лишь действительное число, то
с запятой.

77
00:03:25,180 --> 00:03:30,100
Но если вы вместо этого нужно больше места
после запятой, или вы хотите

78
00:03:30,100 --> 00:03:33,720
представляют большее число с некоторыми
фракции после этого, вы можете использовать

79
00:03:33,720 --> 00:03:36,260
двоих человек, который составляет 64 бита.

80
00:03:36,260 --> 00:03:38,240
>> Но есть интересный
вынос здесь.

81
00:03:38,240 --> 00:03:42,890
Так что если целые ограничены 32 битами и
даже длинный длинных ограничены 64

82
00:03:42,890 --> 00:03:46,180
бит, такого рода возникает вопрос,
Что делать, если вы на самом деле хотите посчитать

83
00:03:46,180 --> 00:03:48,790
выше, чем 4000000000 для десятичного?

84
00:03:48,790 --> 00:03:50,330
Ну, вы просто используете очень долго.

85
00:03:50,330 --> 00:03:54,200
Но что, если вы хотите высокого количества
чем на два 64-й, плюс-минус?

86
00:03:54,200 --> 00:03:55,810
>> Так вот, это огромное количество.

87
00:03:55,810 --> 00:03:59,250
Но в конце концов, вы можете на самом деле
заботиться о таких ценностях,

88
00:03:59,250 --> 00:04:03,070
особенно если вы используете базу данных
и начинаю собирать много-много

89
00:04:03,070 --> 00:04:06,190
и много данных и присвоение уникального
номера для каждой части этих данных.

90
00:04:06,190 --> 00:04:07,430
Таким образом, мы отчасти есть проблемы.

91
00:04:07,430 --> 00:04:10,700
И точно так же, с плавающей точкой
значения - поплавками или двухместных -

92
00:04:10,700 --> 00:04:14,290
Если вы получили только конечное число
бит, сколько всего ты мог номеров

93
00:04:14,290 --> 00:04:16,980
возможно, представляют?

94
00:04:16,980 --> 00:04:19,540
>> Ну, это менее понятно, когда вы
включать десятичную точку.

95
00:04:19,540 --> 00:04:20,899
Но это, конечно, конечно.

96
00:04:20,899 --> 00:04:24,390
Если у вас есть конечное число бит,
конечным числом людей, конечному

97
00:04:24,390 --> 00:04:27,350
количество лампочек, конечно, вы можете
представляют собой лишь конечное число

98
00:04:27,350 --> 00:04:28,510
значения с плавающей точкой.

99
00:04:28,510 --> 00:04:33,170
Но сколько действительных чисел
являются их в мире?

100
00:04:33,170 --> 00:04:33,680
Там в бесконечность.

101
00:04:33,680 --> 00:04:37,280
Так что это своего рода проблема, потому что мы
не имеют бесконечное количество

102
00:04:37,280 --> 00:04:39,970
памяти или оперативной памяти внутри наших компьютеров.

103
00:04:39,970 --> 00:04:41,780
Таким образом, некоторые сложные вещи могут случиться.

104
00:04:41,780 --> 00:04:43,900
>> Так что давайте идти вперед и попробовать
чтобы выразить это здесь.

105
00:04:43,900 --> 00:04:46,240
Позвольте мне идти вперед и открывать Gedit.

106
00:04:46,240 --> 00:04:50,360
Я собираюсь идти вперед и сохранить файл
называется "floats0.c" просто быть

107
00:04:50,360 --> 00:04:54,630
в соответствии с примером, который
доступных в Интернете, если вы хотели бы.

108
00:04:54,630 --> 00:04:58,080
И я собираюсь идти вперед и
определить его следующим образом -

109
00:04:58,080 --> 00:05:01,540
Я собираюсь пойти дальше и сказать, внутр
Основной пустота, как мы часто делаем.

110
00:05:01,540 --> 00:05:07,190
>> А потом в этой программе, я собираюсь
объявляю себя поплавком, так 32-битные

111
00:05:07,190 --> 00:05:09,700
переменная F, произвольно.

112
00:05:09,700 --> 00:05:13,910
А потом я собираюсь хранить в нем
Я не знаю, одну десятую, поэтому 0,1.

113
00:05:13,910 --> 00:05:16,590
Так что я собираюсь выразить, что как один
делится на 10, что вполне

114
00:05:16,590 --> 00:05:17,790
в законную C.

115
00:05:17,790 --> 00:05:20,460
>> А потом на второй линии, я просто
хотите распечатать это значение.

116
00:05:20,460 --> 00:05:22,950
Поэтому напомним, что мы можем использовать
Е знакомы.

117
00:05:22,950 --> 00:05:25,420
Мы не хотим использовать% я для Int.

118
00:05:25,420 --> 00:05:28,360
Мы хотим использовать% F для поплавка.

119
00:05:28,360 --> 00:05:33,080
А потом я собираюсь сделать обратную косую черту N,
Закрыть цитаты, запятая, F, точка с запятой.

120
00:05:33,080 --> 00:05:34,400
>> Итак, вот моя программа.

121
00:05:34,400 --> 00:05:35,820
Там уже одна ошибка.

122
00:05:35,820 --> 00:05:38,640
У кого-нибудь, для которого эта нажата
уже хочу указать по крайней мере,

123
00:05:38,640 --> 00:05:40,220
одну ошибку я сделал?

124
00:05:40,220 --> 00:05:42,470
Да?

125
00:05:42,470 --> 00:05:42,800
Да.

126
00:05:42,800 --> 00:05:47,860
Я забыл "# включить" в
вершины, они симптомом которой, если я попытаюсь

127
00:05:47,860 --> 00:05:50,490
компиляции этого будет, что
компилятор будет кричать на меня,

128
00:05:50,490 --> 00:05:52,770
говоря неопределенный символ или
что-то в этом роде.

129
00:05:52,770 --> 00:05:55,360
Он чего-то не понимает
Е нравится.

130
00:05:55,360 --> 00:05:59,380
>> Так что я собираюсь делать "# включить
», Сохраните файл.

131
00:05:59,380 --> 00:06:00,400
И сейчас он находится в лучшей форме.

132
00:06:00,400 --> 00:06:02,690
Но я также собираюсь указать
одну новую деталь сегодня.

133
00:06:02,690 --> 00:06:08,620
В дополнение к определению места
как держатели% F% I% с, вы можете

134
00:06:08,620 --> 00:06:12,320
иногда влиять на поведение
этого заполнителя.

135
00:06:12,320 --> 00:06:15,540
Например, в случае с плавающей
точкой, если я только хочу

136
00:06:15,540 --> 00:06:22,200
для отображения одного десятичного знака после
период, я могу реально сделать 0.1f.

137
00:06:22,200 --> 00:06:26,830
Итак, другими словами, я отделяю F и
знак процента с 0,1, как раз

138
00:06:26,830 --> 00:06:30,200
Е говоря, вы могли бы иметь целый
кучей цифр после запятой

139
00:06:30,200 --> 00:06:30,930
момент для меня.

140
00:06:30,930 --> 00:06:32,870
Но я только хочу, чтобы увидеть одну из них.

141
00:06:32,870 --> 00:06:36,280
>> Так что я собираюсь идти вперед сейчас и сэкономьте
эту программу, зайдите в мой терминал

142
00:06:36,280 --> 00:06:41,870
окна, и я собираюсь идти вперед
Тип и сделать поплавок 0, введите.

143
00:06:41,870 --> 00:06:44,930
Я вижу, что несколько загадочные линии, которая
начнет больше смысла, как мы

144
00:06:44,930 --> 00:06:46,900
дразнить его на части этой неделе и на следующей.

145
00:06:46,900 --> 00:06:50,480
Теперь я собираюсь идти вперед
и запустить поплавок нулю.

146
00:06:50,480 --> 00:06:52,020
И, черт.

147
00:06:52,020 --> 00:06:54,880
>> Так что есть еще одна ошибка
здесь по некоторым причинам.

148
00:06:54,880 --> 00:07:02,490
Я уверен, что одна десятая, или
единица, деленная на 10, не 0.0.

149
00:07:02,490 --> 00:07:04,590
Возможно, я просто не смотрел
при достаточно цифр.

150
00:07:04,590 --> 00:07:08,580
Так почему же я не говорил, два 0,2 видеть две
знаков после запятой, а не только один.

151
00:07:08,580 --> 00:07:11,810
Позвольте мне вернуться к моей окно терминала
здесь и подбросить пару раз, чтобы

152
00:07:11,810 --> 00:07:12,840
см. мою историю.

153
00:07:12,840 --> 00:07:15,910
Как убедиться, плавают нуля снова,
а затем снова вверх.

154
00:07:15,910 --> 00:07:17,730
И теперь войти.

155
00:07:17,730 --> 00:07:20,000
>> И теперь я уверен, что это неправильно.

156
00:07:20,000 --> 00:07:23,030
И я мог бы сделать три и четыре, и я
, вероятно, будет продолжать видеть нули.

157
00:07:23,030 --> 00:07:24,880
Так где же ошибка?

158
00:07:24,880 --> 00:07:27,910
Один разделенный на 10 должно быть 0,1.

159
00:07:27,910 --> 00:07:30,310
Кто-то хочет принять удар на то, что
, фундаментальная проблема состоит?

160
00:07:30,310 --> 00:07:32,400
Да?

161
00:07:32,400 --> 00:07:33,420
Они оба целыми числами.

162
00:07:33,420 --> 00:07:33,920
Ну и что?

163
00:07:33,920 --> 00:07:37,820
Так что с одной делится на 10, это
что я делаю в арифметике.

164
00:07:37,820 --> 00:07:41,185
И я получаю 0,1.

165
00:07:41,185 --> 00:07:41,660
>> Да.

166
00:07:41,660 --> 00:07:43,240
И вот это действительно этим вопросом.

167
00:07:43,240 --> 00:07:46,700
Когда вы принимаете целое число в компьютер
и вы разделите его на другое целое число,

168
00:07:46,700 --> 00:07:50,430
компьютера по умолчанию будет
Предположим, что вы хотите целое.

169
00:07:50,430 --> 00:07:54,620
Проблема, хотя, конечно,
что 0,1 не является целым числом.

170
00:07:54,620 --> 00:07:55,680
Это реальное число.

171
00:07:55,680 --> 00:07:59,610
И так, что компьютер делает на
по умолчанию это просто выбрасывает

172
00:07:59,610 --> 00:08:01,070
все после запятой.

173
00:08:01,070 --> 00:08:03,380
Это не округляет вниз или вверх, как таковой.

174
00:08:03,380 --> 00:08:06,480
Он просто выбрасывает все
после запятой.

175
00:08:06,480 --> 00:08:07,430
И теперь, когда имеет смысл.

176
00:08:07,430 --> 00:08:09,740
Потому что сейчас мы четко
остались с нулем.

177
00:08:09,740 --> 00:08:10,250
>> Но подождите минуту.

178
00:08:10,250 --> 00:08:11,840
Я не вижу Целочисленное нулю.

179
00:08:11,840 --> 00:08:14,910
Я на самом деле видим 0,00.

180
00:08:14,910 --> 00:08:16,340
Так как я могу согласовать это сейчас?

181
00:08:16,340 --> 00:08:22,850
Если разделить на 10 равно нулю, но я
видя 0.00, где он получает

182
00:08:22,850 --> 00:08:24,250
преобразовано обратно в реальный номер?

183
00:08:24,250 --> 00:08:25,500
Да.

184
00:08:25,500 --> 00:08:29,850

185
00:08:29,850 --> 00:08:30,630
Именно так.

186
00:08:30,630 --> 00:08:35,600
>> Так что здесь, в линию пять, когда я на самом деле
хранить, что 0,1, который затем

187
00:08:35,600 --> 00:08:39,549
усекается до нуля, внутри поплавка,
это практически эквивалентно

188
00:08:39,549 --> 00:08:42,100
хранить его не в виде целого числа, но,
в самом деле, как поплавок.

189
00:08:42,100 --> 00:08:46,540
Более того, я затем с помощью Е к
явно напечатать это число до двух

190
00:08:46,540 --> 00:08:49,740
знаков после запятой, хотя там
не может на самом деле быть любой.

191
00:08:49,740 --> 00:08:51,020
>> Поэтому такого рода сосет, не так ли?

192
00:08:51,020 --> 00:08:53,640
Видимо, вы не можете сделать математику,
по крайней мере, на этом уровне

193
00:08:53,640 --> 00:08:55,600
точности, в компьютере.

194
00:08:55,600 --> 00:08:56,930
Но, конечно, есть решение.

195
00:08:56,930 --> 00:09:00,410
Что простым способом исправить, может быть, мы могли бы
сделать, даже просто интуитивно здесь, чтобы

196
00:09:00,410 --> 00:09:01,130
решить эту проблему?

197
00:09:01,130 --> 00:09:02,380
Да?

198
00:09:02,380 --> 00:09:04,700

199
00:09:04,700 --> 00:09:06,574
Поверните целых чисел в -

200
00:09:06,574 --> 00:09:06,976
да.

201
00:09:06,976 --> 00:09:10,420
Даже если я не совсем уверен, что именно
происходит на самом деле здесь, если он

202
00:09:10,420 --> 00:09:13,440
принципиально связано с этим как
бытие целые, хорошо, почему бы мне не

203
00:09:13,440 --> 00:09:18,230
делают, что 10,0, что делает этот
1.0, сохраните файл.

204
00:09:18,230 --> 00:09:20,990
Позвольте мне вернуться вниз, чтобы
нижняя и перекомпилировать.

205
00:09:20,990 --> 00:09:23,030
Позвольте мне теперь повторяется.

206
00:09:23,030 --> 00:09:23,420
А там -

207
00:09:23,420 --> 00:09:27,690
Теперь, у меня есть одна десятая
представлена ​​в виде 0,10.

208
00:09:27,690 --> 00:09:28,420
>> Хорошо.

209
00:09:28,420 --> 00:09:29,220
Так что это не плохо.

210
00:09:29,220 --> 00:09:31,730
И я хотел бы отметить один способ
мы могли бы решить эту.

211
00:09:31,730 --> 00:09:35,580
Позвольте мне на самом деле откат во времени
, когда у нас было это как один

212
00:09:35,580 --> 00:09:36,680
десятая минуту назад.

213
00:09:36,680 --> 00:09:40,800
И позвольте мне идти вперед и сохраните этот файл
как другое имя файла, просто чтобы

214
00:09:40,800 --> 00:09:41,750
есть немного контрольно-пропускного пункта.

215
00:09:41,750 --> 00:09:43,450
Так, чтобы была одна версия.

216
00:09:43,450 --> 00:09:45,520
А теперь позвольте мне идти вперед и
сделать еще одну версию.

217
00:09:45,520 --> 00:09:48,540
Мы назовем эту версию
два нуля индексируется.

218
00:09:48,540 --> 00:09:51,280
>> И я собираюсь сделать вместо
это - вы знаете, что?

219
00:09:51,280 --> 00:09:54,400
Добавление точки нуля работает в этом случае.

220
00:09:54,400 --> 00:09:56,060
Но предположим, что были одной переменной.

221
00:09:56,060 --> 00:09:57,680
Предполагаемые 10 были переменной.

222
00:09:57,680 --> 00:10:00,680
Другими словами, предположим, что я не мог
Просто трудно-кода 0,0 в конце

223
00:10:00,680 --> 00:10:02,340
этого арифметического выражения.

224
00:10:02,340 --> 00:10:05,820
Ну, я могу сделать что-то
в скобках называется литье.

225
00:10:05,820 --> 00:10:11,920
Я могу бросить, что целое число 10 к плавающему курсу,
и я могу бросить, что целое в одном

226
00:10:11,920 --> 00:10:12,800
плавают, а также.

227
00:10:12,800 --> 00:10:17,190
Тогда математику, которая собирается быть сделано
эффективно 1,0 деленное на 10,0,

228
00:10:17,190 --> 00:10:19,250
результате чего происходит
в F, как раньше.

229
00:10:19,250 --> 00:10:26,130
Так что если я перекомпилировать как сделать поплавки
2, и теперь плавает 2, я получаю такое же

230
00:10:26,130 --> 00:10:27,020
ответить, а также.

231
00:10:27,020 --> 00:10:29,640
>> Так что это довольно надуманный пример,
Для решения этой проблемы

232
00:10:29,640 --> 00:10:31,400
путем введения литья.

233
00:10:31,400 --> 00:10:34,410
Но в целом, литье будет
сильная вещь, особенно для

234
00:10:34,410 --> 00:10:38,180
Проблема установить два в недельный срок, когда
Вы хотите, чтобы преобразовать один тип данных

235
00:10:38,180 --> 00:10:41,800
другой, что в конце дня
представлены таким же образом.

236
00:10:41,800 --> 00:10:44,970
В конце концов, каждый
, что мы говорили о до сих пор является

237
00:10:44,970 --> 00:10:46,710
просто целыми под капотом.

238
00:10:46,710 --> 00:10:48,950
Или, если это слишком низком уровне для
Вас, они просто цифры

239
00:10:48,950 --> 00:10:49,750
под капотом.

240
00:10:49,750 --> 00:10:52,850
Даже символов, опять же, вспомним
от нулевой неделе, есть числа,

241
00:10:52,850 --> 00:10:53,990
под капотом.

242
00:10:53,990 --> 00:10:57,240
>> Который должен сказать, мы можем преобразовать между
различные типы номеров, если

243
00:10:57,240 --> 00:10:58,060
они просто бит.

244
00:10:58,060 --> 00:11:01,020
Мы можем конвертировать между номерами
и буквы, если они просто

245
00:11:01,020 --> 00:11:02,580
бит, и наоборот.

246
00:11:02,580 --> 00:11:07,170
И литья таким образом, представляет собой механизм
в программировании, которая позволяет принудительно

247
00:11:07,170 --> 00:11:10,970
изменить один тип данных в другой.

248
00:11:10,970 --> 00:11:14,570
К сожалению, это не так
просто, как я, возможно, понравилось.

249
00:11:14,570 --> 00:11:19,220
>> Я собираюсь вернуться в поплавках
1, который был более простым,

250
00:11:19,220 --> 00:11:22,830
просто с одной
0,0 добавлены к каждому.

251
00:11:22,830 --> 00:11:25,260
И как быстро переподготовки,
Позвольте мне идти вперед и перекомпилировать

252
00:11:25,260 --> 00:11:27,670
это, убедитесь, поплавки 2 -

253
00:11:27,670 --> 00:11:30,300
К сожалению, это сделать поплавки 1.

254
00:11:30,300 --> 00:11:32,050
А теперь давайте запустим поплавков 1.

255
00:11:32,050 --> 00:11:34,810
А в нижней, заметит
что я действительно получить 0,1.

256
00:11:34,810 --> 00:11:36,165
Итак, проблема решена.

257
00:11:36,165 --> 00:11:37,280
>> Но не сейчас.

258
00:11:37,280 --> 00:11:40,000
Сейчас я собираюсь получить немного любопытно,
и я собираюсь вернуться в мою

259
00:11:40,000 --> 00:11:41,620
Е заявление и
Скажите, вы знаете, что?

260
00:11:41,620 --> 00:11:44,090
Я хотел бы подтвердить, что это
действительно одна десятая.

261
00:11:44,090 --> 00:11:47,890
И я собираюсь хотите видеть это в
, скажем, до пяти знаков после запятой.

262
00:11:47,890 --> 00:11:48,570
Это не проблема.

263
00:11:48,570 --> 00:11:52,020
Изменить двух до пяти,
Я перекомпилировать с макияжем.

264
00:11:52,020 --> 00:11:53,770
Я перегрузите его как поплавки 1.

265
00:11:53,770 --> 00:11:54,990
Выглядит неплохо.

266
00:11:54,990 --> 00:11:58,570
Мои проверки вменяемости может закончиться там, но
Я получаю немного больше приключений.

267
00:11:58,570 --> 00:12:00,330
Я собираюсь изменить 0,5 до 0,10.

268
00:12:00,330 --> 00:12:03,440
Я хочу видеть 10 цифр после
десятичного знака.

269
00:12:03,440 --> 00:12:09,060
>> И я собираюсь идти вперед и перекомпилировать
это и перезапустить плавает 1.

270
00:12:09,060 --> 00:12:13,060
Я вроде сожаления испытав этого
дальше, потому что моя математика не так

271
00:12:13,060 --> 00:12:14,320
исправить больше, кажется.

272
00:12:14,320 --> 00:12:15,630
Но постойте, может быть,
это просто счастливая случайность.

273
00:12:15,630 --> 00:12:17,810
Может быть, компьютер работает
немного странно.

274
00:12:17,810 --> 00:12:21,810
Позвольте мне идти вперед и делать 20 знаков после запятой
и успокоить себя, что я знаю,

275
00:12:21,810 --> 00:12:22,540
как сделать математику.

276
00:12:22,540 --> 00:12:23,460
Я знаю, как программу.

277
00:12:23,460 --> 00:12:26,960
Сделать поплавки 1, перекомпилировать и черт побери.

278
00:12:26,960 --> 00:12:31,110
Это действительно, действительно получаю
Недалеко от знака.

279
00:12:31,110 --> 00:12:32,490
>> Так что же здесь происходит?

280
00:12:32,490 --> 00:12:36,050
Интуитивно, исходя из наших предположений
ранее о размерах типов данных,

281
00:12:36,050 --> 00:12:38,040
, что должно происходить здесь
под капотом?

282
00:12:38,040 --> 00:12:39,290
Да?

283
00:12:39,290 --> 00:12:43,000

284
00:12:43,000 --> 00:12:43,590
Именно так.

285
00:12:43,590 --> 00:12:46,480
Если вы хотите, чтобы это большой точностью, и
это чертовски большой точностью -

286
00:12:46,480 --> 00:12:48,770
20 числа после запятой.

287
00:12:48,770 --> 00:12:51,990
Вы не можете возможно, представляют
произвольное число, если у вас

288
00:12:51,990 --> 00:12:52,930
произвольное число битов.

289
00:12:52,930 --> 00:12:54,190
Но мы не делаем.

290
00:12:54,190 --> 00:12:57,200
Для поплавком, у нас есть только 32 бита.

291
00:12:57,200 --> 00:13:02,260
>> Так, если 32 бита может быть переставляются
способом - так же, как наши люди на, стадии

292
00:13:02,260 --> 00:13:05,780
руки вверх или вниз - в конечном числе
способами, есть лишь конечное число

293
00:13:05,780 --> 00:13:08,640
действительных чисел можно представить
с этими битами.

294
00:13:08,640 --> 00:13:10,500
И так компьютер в конце концов
будет иметь для

295
00:13:10,500 --> 00:13:11,730
начать сокращать углы.

296
00:13:11,730 --> 00:13:15,500
Компьютер может скрыть эти детали
от нас немного времени.

297
00:13:15,500 --> 00:13:18,880
Но если мы начинаем тыкать на цифры
и смотрит дальше и дальше на

298
00:13:18,880 --> 00:13:23,220
задняя числа в целое число,
Затем мы начинаем видеть, что это

299
00:13:23,220 --> 00:13:26,480
фактически аппроксимации
Идея одна десятая.

300
00:13:26,480 --> 00:13:29,860
>> И так получается, к сожалению, есть
бесконечное количество чисел

301
00:13:29,860 --> 00:13:35,060
мы не можем представить именно в
компьютер, по крайней мере, с конечной

302
00:13:35,060 --> 00:13:38,030
Число битов, конечное
объем оперативной памяти.

303
00:13:38,030 --> 00:13:41,210
Сейчас, к сожалению, это иногда
имеет реальные последствия.

304
00:13:41,210 --> 00:13:45,980
Если люди не нарадуются этому
или рода принимают как должное тот факт,

305
00:13:45,980 --> 00:13:48,310
, что их компьютер будет делать то, что
они говорят это делать и не

306
00:13:48,310 --> 00:13:51,430
понять эти основные
Представление детали -

307
00:13:51,430 --> 00:13:55,290
которые, честно говоря, в некоторых языках
скрыта от пользователя, в отличие от C -

308
00:13:55,290 --> 00:13:56,500
некоторые плохие вещи могут случиться.

309
00:13:56,500 --> 00:13:58,650
>> И то, что я думал, что мы делаем
как сделать шаг назад.

310
00:13:58,650 --> 00:14:00,420
А это примерно
восемь-минутное видео.

311
00:14:00,420 --> 00:14:04,200
Это эфир несколько лет назад, и это дает
взглянуть на самом деле, что может пойти

312
00:14:04,200 --> 00:14:09,290
так, когда вы по-достоинству оценят эти
виды деталей в самом все слишком

313
00:14:09,290 --> 00:14:10,080
реальном мире.

314
00:14:10,080 --> 00:14:12,965
Если бы мы могли приглушить свет
в течение нескольких минут.

315
00:14:12,965 --> 00:14:14,360
>> Выступающий 1: Вернемся к инженерной

316
00:14:14,360 --> 00:14:17,160
бедствий для современных чудес.

317
00:14:17,160 --> 00:14:18,680
>> Компьютеры -

318
00:14:18,680 --> 00:14:21,340
Мы все пришли к пониманию
Часто проблемы разочарование

319
00:14:21,340 --> 00:14:23,170
которые идут с ними.

320
00:14:23,170 --> 00:14:27,570
Ошибок, вирусов и сбоев программного обеспечения
небольшие цены, чтобы заплатить за

321
00:14:27,570 --> 00:14:28,960
удобство.

322
00:14:28,960 --> 00:14:32,040
Но в сфере высоких технологий и высокоскоростных
военных и космических программ

323
00:14:32,040 --> 00:14:38,650
приложений, наименьшая проблема
могут быть увеличены в катастрофу.

324
00:14:38,650 --> 00:14:44,480
>> 4 июня 1996 года, ученые готов
запуска беспилотных ракет Ariane 5.

325
00:14:44,480 --> 00:14:48,700
На его борту научных спутников
, направленных на создание, как именно

326
00:14:48,700 --> 00:14:53,250
Магнитное поле Земли взаимодействует
с солнечными ветрами.

327
00:14:53,250 --> 00:14:57,540
Ракета была построена для европейских
Космического агентства и стартовал с его

328
00:14:57,540 --> 00:14:59,906
объекта на побережье
Французской Гвианы.

329
00:14:59,906 --> 00:15:03,660
>> JACK Ganssle: примерно в 37 секунд в
полета, они впервые заметили

330
00:15:03,660 --> 00:15:04,910
что-то идет не так.

331
00:15:04,910 --> 00:15:08,130
Поворотных сопел в
так, как они действительно не должны.

332
00:15:08,130 --> 00:15:12,380
Около 40 секунд в полете,
четко автомобиля попал в беду.

333
00:15:12,380 --> 00:15:14,400
И вот, когда они сделали
решение его уничтожить.

334
00:15:14,400 --> 00:15:18,520
Офицер для обеспечения безопасности, с
огромное мужество, нажал на кнопку,

335
00:15:18,520 --> 00:15:23,900
взорвалась ракета, прежде чем можно
стать опасностью для общественной безопасности.

336
00:15:23,900 --> 00:15:27,810
>> Выступающий 1: Это был первый рейс
из Ariane 5, и ее разрушение

337
00:15:27,810 --> 00:15:32,020
состоялся из-за ошибки встроенного
в программном обеспечении ракеты.

338
00:15:32,020 --> 00:15:33,980
>> JACK Ganssle: Проблема на Ariane
оказалось то, что число

339
00:15:33,980 --> 00:15:36,390
, которые требовали 64 бит выразить.

340
00:15:36,390 --> 00:15:39,420
И они хотели, чтобы преобразовать
в 16-битное число.

341
00:15:39,420 --> 00:15:43,130
Они предположили, что количество никогда не было
будет очень большой, что большинство

342
00:15:43,130 --> 00:15:46,810
эти цифры в 64-битном
числа были нули.

343
00:15:46,810 --> 00:15:48,270
Они были неправы.

344
00:15:48,270 --> 00:15:51,380
>> Выступающий 1: неспособность одного программного обеспечения
Программа принять вид

345
00:15:51,380 --> 00:15:55,350
номер, который генерируется другой был
в корне недостаточности.

346
00:15:55,350 --> 00:15:59,970
Разработка программного обеспечения стала очень
затратная часть новой технологии.

347
00:15:59,970 --> 00:16:03,980
Ariane 4 ракеты были очень
успешным, так что большая часть программного обеспечения

348
00:16:03,980 --> 00:16:07,480
созданных для него был также
используется в Ariane 5.

349
00:16:07,480 --> 00:16:11,980
>> Филипп Койл: Основная проблема была
что Ariane 5 был быстрее,

350
00:16:11,980 --> 00:16:13,720
ускорился быстрее.

351
00:16:13,720 --> 00:16:17,250
И программное обеспечение не было
приходится за это.

352
00:16:17,250 --> 00:16:20,770
>> Выступающий 1: Разрушение ракеты
была огромная финансовая катастрофа,

353
00:16:20,770 --> 00:16:24,200
Все из-за ошибки программного обеспечения минуту.

354
00:16:24,200 --> 00:16:27,820
Но это было не в первый раз данные
проблемы преобразования была охвачена современными

355
00:16:27,820 --> 00:16:30,620
ракетной техники.

356
00:16:30,620 --> 00:16:34,480
>> JACK Ganssle: В 1991 году, с началом
первой войны в Персидском заливе, Patriot

357
00:16:34,480 --> 00:16:38,610
испытал ракету подобного рода
проблема количество переходов.

358
00:16:38,610 --> 00:16:44,910
В результате, 28 американских солдат
убиты и около 100 ранены

359
00:16:44,910 --> 00:16:48,600
когда Patriot, которая должна была
для защиты от входящих Скад,

360
00:16:48,600 --> 00:16:51,630
осечку ракетой.

361
00:16:51,630 --> 00:16:55,110
>> Выступающий 1: Когда Ирак вторгся в Кувейт и
Америка развязала Буря в пустыне

362
00:16:55,110 --> 00:17:00,570
начале 1991 года, батареи ракет Patriot
были развернуты для защиты Саудовской Аравии

363
00:17:00,570 --> 00:17:04,760
и Израиль от иракских Scud
ракетные удары.

364
00:17:04,760 --> 00:17:09,720
Patriot является американской средней дальности
поверхность-воздух система производства

365
00:17:09,720 --> 00:17:11,569
Компания Raytheon.

366
00:17:11,569 --> 00:17:16,410
>> Т. Постол: размер Patriot
перехватчиков себя примерно

367
00:17:16,410 --> 00:17:17,710
20 футов в длину.

368
00:17:17,710 --> 00:17:20,800
И он весит около 2000 фунтов.

369
00:17:20,800 --> 00:17:22,940
И несет в себе боеголовку около -

370
00:17:22,940 --> 00:17:24,905
Я думаю, это примерно 150 фунтов.

371
00:17:24,905 --> 00:17:31,030
И боеголовка сама
фугасных который имеет

372
00:17:31,030 --> 00:17:33,270
Фрагменты вокруг него.

373
00:17:33,270 --> 00:17:37,490
Кожух боеголовки предназначен
действовать, как картечь.

374
00:17:37,490 --> 00:17:40,720
>> Выступающий 1: ракеты осуществляются четыре
за контейнер и перевозится

375
00:17:40,720 --> 00:17:43,050
на полуприцепе.

376
00:17:43,050 --> 00:17:47,490
>> Филипп Койл: Patriot противоракетных
Система вернется в

377
00:17:47,490 --> 00:17:50,710
не менее 20 лет.

378
00:17:50,710 --> 00:17:54,350
Первоначально он был разработан в качестве
ракеты ПВО

379
00:17:54,350 --> 00:17:56,190
сбивать вражеские самолеты.

380
00:17:56,190 --> 00:18:02,490
В первой войны в Персидском заливе, когда эта война
пришли вместе, армии хотел использовать его

381
00:18:02,490 --> 00:18:05,535
сбивать Скад, а не самолеты.

382
00:18:05,535 --> 00:18:09,310
Иракские ВВС не было
столько проблема.

383
00:18:09,310 --> 00:18:12,450
Но армия беспокоился о Скад.

384
00:18:12,450 --> 00:18:15,950
И таким образом они попытались переехать
Patriot.

385
00:18:15,950 --> 00:18:18,750
>> Выступающий 1: Перехват ракету противника
Путешествия в Машине было пять

386
00:18:18,750 --> 00:18:20,890
будет достаточно сложной задачей.

387
00:18:20,890 --> 00:18:25,590
Но когда Patriot был доставлен в
службы, из армии не было известно о

388
00:18:25,590 --> 00:18:31,710
Иракские модификации, которые сделали свой
Скад почти невозможно попасть.

389
00:18:31,710 --> 00:18:35,240
>> Т. Постол: Что случилось
является Скад, которые были

390
00:18:35,240 --> 00:18:36,570
В ближайшие были нестабильны.

391
00:18:36,570 --> 00:18:37,532
Они были биения.

392
00:18:37,532 --> 00:18:43,220
Причиной этого было иракцев, в
Для того чтобы получить 600 километров от

393
00:18:43,220 --> 00:18:47,530
300-километровой дальности, взял
вес из передней боеголовку.

394
00:18:47,530 --> 00:18:49,290
Они сделали боеголовку легче.

395
00:18:49,290 --> 00:18:53,110
Так что теперь пытается Patriot
прийти на Скад.

396
00:18:53,110 --> 00:18:56,470
И большую часть времени, подавляющее
Большую часть времени, было бы просто

397
00:18:56,470 --> 00:18:58,730
летать на Скад.

398
00:18:58,730 --> 00:19:01,760
>> Выступающий 1: Как только система Patriot
операторы осознали Patriot пропустил

399
00:19:01,760 --> 00:19:06,690
своей цели, они взорвали патриотов
боеголовку, чтобы избежать возможных

400
00:19:06,690 --> 00:19:10,300
жертв, если оно было разрешено
падать на землю.

401
00:19:10,300 --> 00:19:14,540
>> Т. Постол: Это было то, что большинство
люди видели, как большие огненные шары в небе

402
00:19:14,540 --> 00:19:20,350
и не понял, как перехватывает
Скад боеголовок.

403
00:19:20,350 --> 00:19:23,320
>> Выступающий 1: Хотя в ночном небе
Патриотов, казалось, были успешно

404
00:19:23,320 --> 00:19:27,530
уничтожая Скад, в Дахрана есть
не могло быть ошибкой о его

405
00:19:27,530 --> 00:19:29,140
производительность.

406
00:19:29,140 --> 00:19:34,180
Там, радиолокационная система Patriot потеряли
Не отслеживать входящие и никогда Скад

407
00:19:34,180 --> 00:19:36,380
запустил Вследствие программного изъян.

408
00:19:36,380 --> 00:19:39,890

409
00:19:39,890 --> 00:19:42,700
>> Это были израильтяне, которые первыми открыли
что чем дольше система

410
00:19:42,700 --> 00:19:48,020
шел, тем больше времени расхождение
стал в связи с часами

411
00:19:48,020 --> 00:19:50,470
встроенных в компьютер системы.

412
00:19:50,470 --> 00:19:54,640
>> JACK Ganssle: за две недели до
Трагедия в Дахране, израильтяне

413
00:19:54,640 --> 00:19:58,440
доведены до сведения Министерства обороны
что система теряла времени.

414
00:19:58,440 --> 00:20:01,280
Примерно через восемь часов работы,
они заметили, что система

415
00:20:01,280 --> 00:20:03,530
становится заметно менее точным.

416
00:20:03,530 --> 00:20:07,710
Министерство обороны ответил,
говорю всем батарей Patriot

417
00:20:07,710 --> 00:20:10,500
не выходить из системы
в течение длительного времени.

418
00:20:10,500 --> 00:20:12,430
Они никогда не говорили, что долгое время был.

419
00:20:12,430 --> 00:20:13,330
Восемь часов?

420
00:20:13,330 --> 00:20:13,810
10 часов?

421
00:20:13,810 --> 00:20:14,990
1000 часов?

422
00:20:14,990 --> 00:20:17,150
Никто не знал.

423
00:20:17,150 --> 00:20:20,220
>> Выступающий 1: Patriot размещены батареи
в казармах на Дахрана

424
00:20:20,220 --> 00:20:24,660
и ее недостатки внутренние часы были
о более 100 часов в ночь на

425
00:20:24,660 --> 00:20:27,470
25 февраля.

426
00:20:27,470 --> 00:20:31,770
>> JACK Ganssle: Это время, чтобы отслеживать
точность около одной десятой доли секунды.

427
00:20:31,770 --> 00:20:34,480
Теперь, десятая доля секунды является
интересное число, потому что оно не может быть

428
00:20:34,480 --> 00:20:39,940
выраженный в двоичном точно, что означает
она не может быть выражена именно в

429
00:20:39,940 --> 00:20:42,500
любого современного цифрового компьютера.

430
00:20:42,500 --> 00:20:46,920
Трудно поверить, но
использовать это в качестве примера.

431
00:20:46,920 --> 00:20:49,000
Давайте числа треть.

432
00:20:49,000 --> 00:20:53,150
Треть не может быть выражено
в десятичной точно.

433
00:20:53,150 --> 00:20:57,500
Треть 0,333 собирается
на бесконечности.

434
00:20:57,500 --> 00:21:02,270
Там нет способа сделать это с
абсолютная точность в десятичной системе.

435
00:21:02,270 --> 00:21:05,370
Это точно такая же проблема
что происходило в патриота.

436
00:21:05,370 --> 00:21:09,880
Чем дольше система работала,
худшие ошибки времени стал.

437
00:21:09,880 --> 00:21:13,840
>> Выступающий 1: После 100 часов работы,
ошибки во времени только

438
00:21:13,840 --> 00:21:16,140
около одной трети секунды.

439
00:21:16,140 --> 00:21:20,800
Но с точки зрения ориентации ракеты
Путешествия в Машине пять, это привело к

440
00:21:20,800 --> 00:21:24,410
ошибки слежения более 600 метров.

441
00:21:24,410 --> 00:21:27,670
Было бы фатальной ошибкой для
солдаты на Дахрана.

442
00:21:27,670 --> 00:21:33,450
>> Т. Постол: Дело в том,
Скад запуск был обнаружен рано

443
00:21:33,450 --> 00:21:34,280
предупреждение спутников.

444
00:21:34,280 --> 00:21:38,550
И они знали, что Скад шел
в их общем направлении.

445
00:21:38,550 --> 00:21:41,000
Они не знали, откуда он исходит.

446
00:21:41,000 --> 00:21:43,900
>> Выступающий 1: Теперь настало время для радарных
компонентом системы Patriot

447
00:21:43,900 --> 00:21:48,910
защиты Дахрана, чтобы найти и сохранить
отслеживать управляемой ракеты противника.

448
00:21:48,910 --> 00:21:50,580
>> JACK Ganssle: радар
был очень умным.

449
00:21:50,580 --> 00:21:53,770
Было бы фактически отслеживать положение
Scud, а затем предсказать, где она

450
00:21:53,770 --> 00:21:57,160
, вероятно, будет в следующий раз
Радар направил импульсный выход.

451
00:21:57,160 --> 00:21:58,870
, Который был назван диапазон ворот.

452
00:21:58,870 --> 00:22:04,020
>> Т. Постол: Тогда, как только Patriot
решает, прошло достаточно времени, чтобы пойти

453
00:22:04,020 --> 00:22:09,420
назад и проверить следующее место для
это обнаруженного объекта, оно восходит.

454
00:22:09,420 --> 00:22:14,450
Поэтому, когда речь вернулась к неправильному
место, он затем не видит объект.

455
00:22:14,450 --> 00:22:18,200
И она решит, что не было никакой объект,
это была ложная обнаружения и

456
00:22:18,200 --> 00:22:19,680
Капли дорожки.

457
00:22:19,680 --> 00:22:22,970
>> Выступающий 1: входящие Скад исчезли
На экране радара, и

458
00:22:22,970 --> 00:22:26,050
секунд спустя это хлопнуло
в казарму.

459
00:22:26,050 --> 00:22:31,950
Скад погибли 28 и был последним
уволили во время первой войны в Персидском заливе.

460
00:22:31,950 --> 00:22:37,700
Трагично, что обновленное программное обеспечение прибыли
Дахрана на следующий день.

461
00:22:37,700 --> 00:22:41,800
Программное обеспечение недостаток был установлен,
закрытию одной главы в неспокойном

462
00:22:41,800 --> 00:22:43,690
История Пэтриот.

463
00:22:43,690 --> 00:22:46,780

464
00:22:46,780 --> 00:22:50,710
>> Patriot на самом деле сокращение
для отслеживания фазированной решеткой

465
00:22:50,710 --> 00:22:51,960
Перехват цели.

466
00:22:51,960 --> 00:22:54,650

467
00:22:54,650 --> 00:23:00,840
>> David J МАЛАН: Ладно,
отрезвляющим примером того, чтобы быть уверенным.

468
00:23:00,840 --> 00:23:03,430
И, к счастью, эти низком уровне
ошибки не являются чем-то, что мы будем

469
00:23:03,430 --> 00:23:06,220
обычно должны ценить, конечно,
Не с некоторыми из наших

470
00:23:06,220 --> 00:23:07,360
ранняя из программ.

471
00:23:07,360 --> 00:23:10,450
Скорее всего, большинство ошибок вы будете
Встреча будет логично в природе,

472
00:23:10,450 --> 00:23:12,900
синтаксических в природе в результате чего
Код просто не работает правильно.

473
00:23:12,900 --> 00:23:14,140
И вы знаете, это довольно быстро.

474
00:23:14,140 --> 00:23:16,850
>> Но особенно, когда мы добираемся до
конце семестра, он собирается

475
00:23:16,850 --> 00:23:20,620
все больше и больше возможность
действительно задуматься о дизайне

476
00:23:20,620 --> 00:23:22,960
из ваших программ и основные
представление

477
00:23:22,960 --> 00:23:24,520
там тоже данных.

478
00:23:24,520 --> 00:23:28,010
Например, давайте познакомимся с MySQL,
который является популярным компонентом Database Engine

479
00:23:28,010 --> 00:23:30,850
, которые можно использовать с веб-сайты для
хранить данные на задней части.

480
00:23:30,850 --> 00:23:34,630
И вы будете иметь, чтобы начать решать в
конце семестра не только то,

481
00:23:34,630 --> 00:23:38,790
типов данных вдоль этих линий использовать
но точно, сколько бит в использовании,

482
00:23:38,790 --> 00:23:42,740
действительно ли вы хотите хранить даты
как дата и время, как раз, а также

483
00:23:42,740 --> 00:23:46,890
такие вещи, как большой Вы хотите
уникальные идентификаторы, чтобы быть, скажем, для пользователей

484
00:23:46,890 --> 00:23:47,680
в базе данных.

485
00:23:47,680 --> 00:23:51,210
>> В самом деле, если некоторые из вас были
Facebook приходится довольно долго,

486
00:23:51,210 --> 00:23:53,680
и вы знаете, как получить доступ
В пользовательский ID -

487
00:23:53,680 --> 00:23:57,930
которая иногда появляется в вашей
URL профиля, если вы не выбрали

488
00:23:57,930 --> 00:24:02,070
Псевдоним для URL, или если вы
Facebook, используемых График API,

489
00:24:02,070 --> 00:24:05,510
общедоступных API с помощью которого вы
Facebook может попросить и для сырых данных -

490
00:24:05,510 --> 00:24:07,580
Вы можете увидеть, что ваши числовой идентификатор.

491
00:24:07,580 --> 00:24:10,880
И несколько лет назад, по существу Facebook
пришлось изменить от использования

492
00:24:10,880 --> 00:24:15,980
эквивалент к целые использовании длинных
долго, потому что с течением времени, как пользователи приходят

493
00:24:15,980 --> 00:24:19,780
и уходят, и создать много счетов и
поддельные счета, даже они очень легко

494
00:24:19,780 --> 00:24:24,630
смогли исчерпать что-то вроде 4
млрд. возможное значение, как Int.

495
00:24:24,630 --> 00:24:28,340
>> Так больше на те виды вопросов
в будущем, а также.

496
00:24:28,340 --> 00:24:30,750
Ладно, так, чтобы было литье.

497
00:24:30,750 --> 00:24:31,670
Это была неточность.

498
00:24:31,670 --> 00:24:32,730
Несколько быстрых объявлений.

499
00:24:32,730 --> 00:24:35,710
Так разделах формально начать предстоящий
Воскресенье, понедельник, вторник.

500
00:24:35,710 --> 00:24:39,080
Вы услышите по электронной почте в конце этой недели
Что касается вашего назначение разделам.

501
00:24:39,080 --> 00:24:42,570
И вы также будете здесь в этой точке как
изменить свой раздел, если ваши

502
00:24:42,570 --> 00:24:45,660
графика в настоящее время изменилась или ваш
Уровень комфорта в настоящее время изменилась.

503
00:24:45,660 --> 00:24:49,380
Между тем P-набор одного и хакерских являются одним
из-за этого четверга с возможностью

504
00:24:49,380 --> 00:24:52,450
продлить этот срок на
Спецификации по пятницу

505
00:24:52,450 --> 00:24:53,830
в типичном способом.

506
00:24:53,830 --> 00:24:57,500
>> Поймите, что в комплекте с проблемой
набор спецификаций Инструкции по

507
00:24:57,500 --> 00:25:02,770
как использовать прибор CS50, марка,
а также некоторые конкретные инструменты CS50

508
00:25:02,770 --> 00:25:06,540
как стиль 50, который может предоставить вам
с обратной связью динамически

509
00:25:06,540 --> 00:25:10,230
качество вашего кода стиле, а также
проверить 50, который может предоставить вам

510
00:25:10,230 --> 00:25:13,160
динамической обратной связи, чтобы ваши
Код корректности.

511
00:25:13,160 --> 00:25:16,850
Прости, что мы все еще гладильные
из несколько петель с проверкой 50.

512
00:25:16,850 --> 00:25:21,490
Некоторые из ваших одноклассников, которые действительно начинали
около 4 утра в ночь на пятницу, когда

513
00:25:21,490 --> 00:25:25,130
спецификации подошел заметили с тех пор
несколько ошибок, которые мы работаем

514
00:25:25,130 --> 00:25:29,010
до конца, и извинения для тех, кто
испытал чрезмерных разочарований.

515
00:25:29,010 --> 00:25:30,340
Неисправность заключается в шахту.

516
00:25:30,340 --> 00:25:34,080
Но мы будем следить за CS50
обсудить, что, когда будет решена.

517
00:25:34,080 --> 00:25:35,700
>> Так что слова о себе баллы.

518
00:25:35,700 --> 00:25:38,990
Так что это будет через неделю или две, прежде чем
начать, чтобы получить обратную связь на домашних заданий

519
00:25:38,990 --> 00:25:40,640
потому что вы еще не имеют
преподавание парень.

520
00:25:40,640 --> 00:25:44,510
И даже тогда, мы начнем оценивать
Проблема C ставит перед нами

521
00:25:44,510 --> 00:25:46,970
вернуться назад и оценить царапинам так
что вы получаете больше соответствующего

522
00:25:46,970 --> 00:25:48,150
обратная связь быстрее.

523
00:25:48,150 --> 00:25:51,870
Но в целом в программе, CS50
Проблема наборы оценивались по длине

524
00:25:51,870 --> 00:25:53,580
после четырех осей -

525
00:25:53,580 --> 00:25:55,760
сферы, правильность, дизайн и стиль.

526
00:25:55,760 --> 00:25:59,210
>> Область будет число обычно
от нуля до пяти, что

527
00:25:59,210 --> 00:26:01,830
захватывает сколько
часть, которую Вы откусили.

528
00:26:01,830 --> 00:26:03,750
Как правило, вы хотите, чтобы это было пять.

529
00:26:03,750 --> 00:26:05,300
Вы по крайней мере, попробовал все.

530
00:26:05,300 --> 00:26:09,330
И заметили, что это множителя
так что делает только часть

531
00:26:09,330 --> 00:26:12,520
Проблема набора не лучшая стратегия.

532
00:26:12,520 --> 00:26:15,610
>> Между тем, более очевидным является
Важность правильности -

533
00:26:15,610 --> 00:26:18,620
просто ваша программа с правильными
в отношении спецификации?

534
00:26:18,620 --> 00:26:21,510
Это взвешенный намеренно больше
степени, чем две другие оси с помощью

535
00:26:21,510 --> 00:26:24,450
в три раза, потому что мы признаем
, которые обычно вы собираетесь потратить

536
00:26:24,450 --> 00:26:28,600
намного больше времени, чтобы гоняться за некоторые ошибки,
Заставьте ваш код работать, то вы

537
00:26:28,600 --> 00:26:31,540
отступов и выбрав
соответствующие имена переменных и

538
00:26:31,540 --> 00:26:33,800
как, который на другом конце
спектра стиля.

539
00:26:33,800 --> 00:26:36,160
>> Это не значит, что стиль не
важно, и мы будем проповедовать его более

540
00:26:36,160 --> 00:26:37,920
время как в лекциях и в секциях.

541
00:26:37,920 --> 00:26:40,520
Стиль относится к эстетике
вашего кода.

542
00:26:40,520 --> 00:26:43,980
Вы выбрали хорошо названные переменные
, которые являются короткими, но несколько

543
00:26:43,980 --> 00:26:44,680
описательные?

544
00:26:44,680 --> 00:26:47,840
Является ли ваш код отступом, как вы видели в
лекцию и в соответствии

545
00:26:47,840 --> 00:26:49,070
в стиле 50?

546
00:26:49,070 --> 00:26:51,220
>> Наконец является проектирование права
там в середине.

547
00:26:51,220 --> 00:26:54,090
Дизайн, тем труднее одну, чтобы поместить
пальцем, потому что это гораздо более

548
00:26:54,090 --> 00:26:55,000
субъективно.

549
00:26:55,000 --> 00:26:58,610
Но это, пожалуй, самый важный из
трех осей с точки зрения педагогической

550
00:26:58,610 --> 00:27:02,050
стоимости с течением времени и что это будет
обучение стипендиата возможность

551
00:27:02,050 --> 00:27:04,110
предоставить Вам качественные обратной связи.

552
00:27:04,110 --> 00:27:08,100
Действительно, в CS50, хотя у нас есть
эти формулы и оценки, в конце

553
00:27:08,100 --> 00:27:11,350
дня это совершенно сознательно
очень маленькие ведра - точка

554
00:27:11,350 --> 00:27:13,460
от нуля до трех
и нулевой и пять.

555
00:27:13,460 --> 00:27:17,800
Мы не пытаемся привлечь очень грубых линий
Проблема между наборами или между

556
00:27:17,800 --> 00:27:21,490
студенты а сосредоточиться столько, сколько
мы можем на качественные, обычное письмо

557
00:27:21,490 --> 00:27:25,490
обратной связи, либо типизированных или устного от
Вашей товарищей обучения,

558
00:27:25,490 --> 00:27:27,050
Вы узнаете достаточно хорошо.

559
00:27:27,050 --> 00:27:32,340
>> Но в общем, те веса
что различные оси будут иметь.

560
00:27:32,340 --> 00:27:35,480
Между тем, также, это стоит иметь в
виду, что вы не должны считать, что

561
00:27:35,480 --> 00:27:38,870
три из пяти представляет собой 60% и
Поэтому примерно неудачу.

562
00:27:38,870 --> 00:27:41,410
Три сознательно предназначается, чтобы быть
рода середине пути хорошо.

563
00:27:41,410 --> 00:27:43,480
Если вы получаете в тройках
начале семестра, это

564
00:27:43,480 --> 00:27:46,340
действительно предназначено, чтобы быть хорошим
место, чтобы начать.

565
00:27:46,340 --> 00:27:50,510
Если вы получаете двойку, ярмарках, есть
безусловно, некоторые работы, чтобы заплатить немного

566
00:27:50,510 --> 00:27:53,250
больше внимания, чтобы воспользоваться
разделов и рабочее время.

567
00:27:53,250 --> 00:27:54,590
>> Если вы получаете четвереньках
и пятерками, отлично.

568
00:27:54,590 --> 00:27:57,430
Но на самом деле, мы надеемся увидеть траектории
Среди студентов - очень

569
00:27:57,430 --> 00:28:00,575
индивидуально на одного студента, но начиная
семестра здесь, в роду

570
00:28:00,575 --> 00:28:04,100
от двух до трех диапазона, но окончание
здесь, в 4:56 диапазоне.

571
00:28:04,100 --> 00:28:05,440
Это то, что мы на самом деле ищем.

572
00:28:05,440 --> 00:28:09,590
И мы иметь в виду, что дельта
Вы показываете между нулем неделю и неделю

573
00:28:09,590 --> 00:28:12,170
12, когда я делаю классах.

574
00:28:12,170 --> 00:28:16,380
Это не имеет значения для нас совсем так, как
Вы справедливым в начале, если ваш

575
00:28:16,380 --> 00:28:19,330
Траектория действительно
вверх и сильным.

576
00:28:19,330 --> 00:28:24,000
>> Академической честности - так что позвольте мне надел
более серьезным голосом на мгновение.

577
00:28:24,000 --> 00:28:28,510
Так что этот курс имеет честь
посылая больше студентов, чем любой другой

578
00:28:28,510 --> 00:28:30,950
в истории, Доска объявлений, я верю.

579
00:28:30,950 --> 00:28:34,220
У нас есть вроде потерял счет в этом
точки как часто это происходит.

580
00:28:34,220 --> 00:28:37,090
И это не потому, что студенты в 50
носят более нечестными, чем их

581
00:28:37,090 --> 00:28:38,690
одноклассников в других местах.

582
00:28:38,690 --> 00:28:42,800
Но понимаете, и то, что мы очень хороши
при обнаружении такого рода вещи.

583
00:28:42,800 --> 00:28:45,920
>> И это то преимущество, что
информатика класс, в котором мы

584
00:28:45,920 --> 00:28:49,110
может и мы сравнить все студенты
Проблема устанавливает попарно против всех

585
00:28:49,110 --> 00:28:51,470
другом, а не только в этом году
Но все предыдущие годы.

586
00:28:51,470 --> 00:28:55,080
У нас есть возможность, как студенты в
класс, Google и найти код

587
00:28:55,080 --> 00:28:57,440
на сайтах, как GitHub и
дискуссионные форумы.

588
00:28:57,440 --> 00:29:00,840
Есть абсолютно решения CS50 автора
Р-множеств плавающие вокруг там.

589
00:29:00,840 --> 00:29:02,710
Но если вы можете найти их,
мы можем найти их.

590
00:29:02,710 --> 00:29:07,130
И все это очень автоматизирован
и легко, и печальные для нас найти.

591
00:29:07,130 --> 00:29:10,990
>> Но я хочу подчеркнуть также, что
академической политики честности курса является

592
00:29:10,990 --> 00:29:13,960
очень должно быть очень много
противоположностью этого духа.

593
00:29:13,960 --> 00:29:17,506
Действительно, в этом году мы перефразировать вещи
в учебном плане, чтобы быть этим, точка

594
00:29:17,506 --> 00:29:19,790
точка точка, с более подробно
в учебном плане.

595
00:29:19,790 --> 00:29:22,860
Но главной темой в ходе
самом деле, чтобы быть разумным.

596
00:29:22,860 --> 00:29:26,160
Мы признаем, что существует значительная
количество педагогических

597
00:29:26,160 --> 00:29:30,550
значение в сотрудничающих, в некоторой степени,
с одноклассниками, в котором вы

598
00:29:30,550 --> 00:29:33,700
двух или трех или вы вам больше являются
стоя на белой доске

599
00:29:33,700 --> 00:29:35,670
доской, так
говорят, ваши идеи -

600
00:29:35,670 --> 00:29:39,480
выписывая псевдокод в картинках,
диаграмм, что должно быть, если Марио

601
00:29:39,480 --> 00:29:41,350
Вы должны были написать его первым
в псевдокоде.

602
00:29:41,350 --> 00:29:43,240
Какой должна быть жадным алгоритмом -

603
00:29:43,240 --> 00:29:46,100
как он должен вести себя в
Проблема сейчас одна?

604
00:29:46,100 --> 00:29:50,440
>> И так понимаю, что поведение
что мы поощряем очень

605
00:29:50,440 --> 00:29:51,470
многое в этом направлении.

606
00:29:51,470 --> 00:29:53,890
А в программе, вы увидите
целую кучу под пулями

607
00:29:53,890 --> 00:29:57,740
разумные категорию и не разумно
категория, которая помогает нам помочь

608
00:29:57,740 --> 00:30:00,740
Вы обернуть ваш разум вокруг, где
мы нарисовать эту линию.

609
00:30:00,740 --> 00:30:04,340
И вообще, достойный правило
том, что если вы боретесь, чтобы решить

610
00:30:04,340 --> 00:30:07,990
какая-то ошибка и вашего друга или одноклассника
сидит рядом с вами, это

611
00:30:07,990 --> 00:30:11,530
разумное для вас, чтобы показать ему или ей
код и сказать: эй, вы можете помочь

612
00:30:11,530 --> 00:30:13,700
мне понять, что происходит здесь не так?

613
00:30:13,700 --> 00:30:17,110
>> Мы обычно не охватывают
противоположной стороне.

614
00:30:17,110 --> 00:30:20,730
Это не правильный ответ для ваших
друга или одноклассника здесь, чтобы сказать, о,

615
00:30:20,730 --> 00:30:22,510
просто посмотрите на мои и фигуры
его от этого.

616
00:30:22,510 --> 00:30:24,400
Это является своего рода необоснованным.

617
00:30:24,400 --> 00:30:27,750
Но имея другого, другой мозг,
еще одна пара глаз смотрят на

618
00:30:27,750 --> 00:30:31,620
экране или смотрели ваш код
и говорите, вы уверены, что хотите

619
00:30:31,620 --> 00:30:32,760
иметь петли здесь?

620
00:30:32,760 --> 00:30:34,800
Или Вы уверены, что хотите
эта точка с запятой здесь?

621
00:30:34,800 --> 00:30:37,090
Или о, это сообщение об ошибке означает это.

622
00:30:37,090 --> 00:30:39,580
Это очень разумно и
поощряется поведение.

623
00:30:39,580 --> 00:30:44,010
>> Случаях, к которым я имел в виду
ранее сводятся к тому, когда студенты

624
00:30:44,010 --> 00:30:47,350
поздно вечером делает недальновидности
решения и по электронной почте свой код

625
00:30:47,350 --> 00:30:50,130
кому-либо или просто говорю,
здесь, это в Dropbox или

626
00:30:50,130 --> 00:30:51,610
Погуглить поздно вечером.

627
00:30:51,610 --> 00:30:54,880
И поэтому я призываю и умоляю вас,
Если у вас есть тех неизбежных

628
00:30:54,880 --> 00:30:58,450
моменты стресса, вы натыкаясь
против срока, у вас нет конца

629
00:30:58,450 --> 00:31:01,490
день, так как это уже в пятницу на что
точки, электронной почте руководители курса или

630
00:31:01,490 --> 00:31:02,330
себя непосредственно.

631
00:31:02,330 --> 00:31:04,790
Скажем, слушай, я в своем
переломным моментом здесь.

632
00:31:04,790 --> 00:31:06,660
Давайте вести разговор
и понять это.

633
00:31:06,660 --> 00:31:10,400
Прибегая к сети или некоторых других не
разумное поведение никогда не бывает

634
00:31:10,400 --> 00:31:13,070
раствора и слишком много ваших
одноклассники уже не здесь, на

635
00:31:13,070 --> 00:31:15,150
кампуса из-за этой недальновидности.

636
00:31:15,150 --> 00:31:17,840
Но это очень легко обойти эту линию.

637
00:31:17,840 --> 00:31:22,950
>> А вот маленькая картинка, чтобы подбодрить
Вас из Reddit, так что теперь

638
00:31:22,950 --> 00:31:25,720
все будет ОК.

639
00:31:25,720 --> 00:31:30,210
>> Так быстрое резюме, то,
, где мы остановились.

640
00:31:30,210 --> 00:31:33,690
Так на прошлой неделе, напомним, что мы вводим
условиях, а не в царапинам

641
00:31:33,690 --> 00:31:34,880
но в C этого времени.

642
00:31:34,880 --> 00:31:38,300
И был некоторый новый синтаксис, но
Действительно никакие новые идеи как таковой.

643
00:31:38,300 --> 00:31:42,630
У нас были логические выражения, что мы могли
или вместе с двумя вертикальными

644
00:31:42,630 --> 00:31:46,490
барах или и вместе с двумя
амперсандах, говоря, что как левая

645
00:31:46,490 --> 00:31:49,990
и права должны быть истинными
для этого выполнить.

646
00:31:49,990 --> 00:31:53,150
Тогда у нас были выключатели, которые мы смотрели
в кратко, но я предлагаю действительно

647
00:31:53,150 --> 00:31:56,830
просто разный синтаксис для достижения
такие же цели, если вы знаете, в

648
00:31:56,830 --> 00:31:59,270
заранее, что ваши случаи
будут.

649
00:31:59,270 --> 00:32:00,160
>> Мы смотрели на петлях.

650
00:32:00,160 --> 00:32:03,340
Цикл, может быть, наиболее распространенным,
или по крайней мере один, что люди

651
00:32:03,340 --> 00:32:05,330
обычно достигают за инстинктивно.

652
00:32:05,330 --> 00:32:08,240
Хотя это выглядит немного загадочно,
вы увидите много, много примеров этого

653
00:32:08,240 --> 00:32:11,590
в скором времени, у вас есть
уже в конце прошлой недели.

654
00:32:11,590 --> 00:32:14,280
В то время как петли могут аналогично
достичь того же.

655
00:32:14,280 --> 00:32:17,550
Но если вы хотите сделать какие-либо приращения
или обновление

656
00:32:17,550 --> 00:32:20,230
значения переменной, вы должны
делать это более, чем вручную

657
00:32:20,230 --> 00:32:22,440
цикл до позволяет.

658
00:32:22,440 --> 00:32:25,310
А тут еще делать-то время как цикл,
что позволяет нам сделать что-нибудь в

659
00:32:25,310 --> 00:32:28,460
Хотя бы раз в то время что-то
остальное является истиной.

660
00:32:28,460 --> 00:32:31,550
И это особенно хорошо для
программ или для игр, где вы хотите

661
00:32:31,550 --> 00:32:33,810
предложить пользователю что-то
по крайней мере, один раз.

662
00:32:33,810 --> 00:32:37,110
И потом, если он или она не будет сотрудничать,
Вы можете сделать это

663
00:32:37,110 --> 00:32:38,420
снова и снова.

664
00:32:38,420 --> 00:32:41,270
>> С переменными, между тем, мы были линий
кода, как это, которые могли бы

665
00:32:41,270 --> 00:32:41,950
две прямые.

666
00:32:41,950 --> 00:32:44,830
Можно объявить Целочисленное называется
счетчик, точки с запятой.

667
00:32:44,830 --> 00:32:47,660
Или вы можете просто объявить и
определить его, так сказать.

668
00:32:47,660 --> 00:32:49,950
Дайте ему значение в то же время.

669
00:32:49,950 --> 00:32:51,890
>> И тогда, наконец, мы говорили
о функциях.

670
00:32:51,890 --> 00:32:54,270
И это был хороший пример в
том смысле, что она иллюстрирует

671
00:32:54,270 --> 00:32:55,840
два типа функций.

672
00:32:55,840 --> 00:32:59,030
Одним из них является GetString (), который, опять же,
принимает строку от пользователя.

673
00:32:59,030 --> 00:33:02,040
Но GetString () является отчасти интересно,
постольку, поскольку мы использовали его,

674
00:33:02,040 --> 00:33:05,620
потому что мы всегда использовали его с
что-то на левой стороне

675
00:33:05,620 --> 00:33:06,600
Знак равенства.

676
00:33:06,600 --> 00:33:09,830
То есть, что GetString ()
возвращает значение.

677
00:33:09,830 --> 00:33:11,970
Он возвращает, конечно, строки.

678
00:33:11,970 --> 00:33:15,130
А потом на левую сторону, мы
простого сохранения этой строки внутри

679
00:33:15,130 --> 00:33:16,580
переменная с именем имя.

680
00:33:16,580 --> 00:33:21,100
>> Это совсем другое, в некотором смысле, от
Е Е, потому что, по крайней мере в нашем

681
00:33:21,100 --> 00:33:23,540
Использование здесь, ничего не возвращает.

682
00:33:23,540 --> 00:33:24,960
Как в стороне, она возвращает что-то.

683
00:33:24,960 --> 00:33:26,380
Мы просто не волнует, что это такое.

684
00:33:26,380 --> 00:33:29,090
Но в нем есть то, что
называется побочный эффект.

685
00:33:29,090 --> 00:33:31,840
И что же это побочный эффект в каждом
случае мы видели до сих пор?

686
00:33:31,840 --> 00:33:34,720
Что делать Е?

687
00:33:34,720 --> 00:33:37,780
Он печатает что-то на экран,
дисплеев текст, число или что-то

688
00:33:37,780 --> 00:33:38,380
на экране.

689
00:33:38,380 --> 00:33:41,170
И это только считается побочным эффектом
, потому что это на самом деле не вручать

690
00:33:41,170 --> 00:33:41,900
его обратно ко мне.

691
00:33:41,900 --> 00:33:44,770
Это не ответ внутри
черный ящик, который я могу после этого

692
00:33:44,770 --> 00:33:46,130
достичь в и захватить.

693
00:33:46,130 --> 00:33:49,160
Это просто делает это сам по себе, гораздо
как Колтон был подключен к этому

694
00:33:49,160 --> 00:33:52,560
Черный ящик на прошлой неделе, и он так или иначе
волшебным был чертеж на доске

695
00:33:52,560 --> 00:33:54,500
без меня на самом деле участвует.

696
00:33:54,500 --> 00:33:55,560
Это было бы побочный эффект.

697
00:33:55,560 --> 00:33:59,100
Но если я фактически должен был уходить в
здесь и говорить, ой, вот строки

698
00:33:59,100 --> 00:34:02,040
от пользователя, который бы
быть возвращаемым значением.

699
00:34:02,040 --> 00:34:05,650
>> И до сих пор мы использовали только функции
что другие люди написали.

700
00:34:05,650 --> 00:34:09,219
Но мы можем на самом деле эти
вещи сами.

701
00:34:09,219 --> 00:34:12,730
Так что я собираюсь идти в
CS50 прибор снова.

702
00:34:12,730 --> 00:34:16,020
Позвольте мне закрыть вкладку, что мы
были открытые минуту назад.

703
00:34:16,020 --> 00:34:18,530
И позвольте мне идти вперед и
создать новый файл.

704
00:34:18,530 --> 00:34:22,400
И я собираюсь идти вперед и
называют его одним positive.c.

705
00:34:22,400 --> 00:34:24,770
Поэтому я хочу сделать что-то с
положительные числа здесь.

706
00:34:24,770 --> 00:34:27,219
Так что я собираюсь идти вперед и делать Int -

707
00:34:27,219 --> 00:34:28,000
К сожалению -

708
00:34:28,000 --> 00:34:31,840
# Включить.

709
00:34:31,840 --> 00:34:34,280
Давайте не будем делать, что же
ошибка, как раньше.

710
00:34:34,280 --> 00:34:40,020
Int основных (недействительными), открывающей фигурной
скобки, закрытой фигурной скобкой.

711
00:34:40,020 --> 00:34:41,639
>> А теперь я хочу сделать следующее.

712
00:34:41,639 --> 00:34:44,600
Я хочу написать программу, которая
настаивает на том, что пользователь дает

713
00:34:44,600 --> 00:34:46,770
мне положительное целое число.

714
00:34:46,770 --> 00:34:50,969
Так нет GetPositiveInt функции
CS50 в библиотеке.

715
00:34:50,969 --> 00:34:52,610
Там только GetInt ().

716
00:34:52,610 --> 00:34:55,790
Но это нормально, потому что у меня есть
конструкций, с которыми я могу наложить

717
00:34:55,790 --> 00:34:59,360
немного больше ограничение на это значение.

718
00:34:59,360 --> 00:35:00,990
Я мог бы сделать что-то вроде этого.

719
00:35:00,990 --> 00:35:02,780
>> Так Int N -

720
00:35:02,780 --> 00:35:04,920
и если вы набираю текст, просто понимаю,
Я собираюсь вернуться и

721
00:35:04,920 --> 00:35:06,430
изменить некоторые вещи в данный момент -

722
00:35:06,430 --> 00:35:09,960
так Int N равна GetInt ().

723
00:35:09,960 --> 00:35:11,780
И, что собирается поставить
Целочисленное внутри н.

724
00:35:11,780 --> 00:35:13,830
И позвольте мне быть, более наглядный.

725
00:35:13,830 --> 00:35:23,270
Позвольте мне сказать что-то вроде: я требую, чтобы
Вы дадите мне положительное целое число.

726
00:35:23,270 --> 00:35:23,550
>> Хорошо.

727
00:35:23,550 --> 00:35:25,250
Так что просто немного инструкций.

728
00:35:25,250 --> 00:35:26,270
А теперь то, что я могу сделать?

729
00:35:26,270 --> 00:35:29,840
Ну, я уже знаю, с моей простой
условий или веток, так же, как я

730
00:35:29,840 --> 00:35:36,100
имел в нуля, я не мог сказать что-то
например, если п меньше или равна

731
00:35:36,100 --> 00:35:44,460
нулю, то я хочу сделать что-то
нравится, это не положительно.

732
00:35:44,460 --> 00:35:45,560
А потом я мог сделать -

733
00:35:45,560 --> 00:35:47,310
Хорошо, но я действительно хочу получить, что Int.

734
00:35:47,310 --> 00:35:52,020
Так что я мог подняться здесь, и я мог отчасти
копии этого и этого абзаца.

735
00:35:52,020 --> 00:35:52,570
И потом, ОК.

736
00:35:52,570 --> 00:35:56,990
Таким образом, если N меньше или
равна нулю это сделать.

737
00:35:56,990 --> 00:35:58,900
>> Теперь, что если пользователь
не сотрудничать?

738
00:35:58,900 --> 00:36:01,560
Ну, тогда я собираюсь
заимствовать это здесь.

739
00:36:01,560 --> 00:36:03,130
И тогда я иду сюда
и здесь и здесь.

740
00:36:03,130 --> 00:36:06,420
Так что это явно не
решение, не так ли?

741
00:36:06,420 --> 00:36:07,810
Потому что нет конца этому не видно.

742
00:36:07,810 --> 00:36:13,100
Если я хочу потребовать, чтобы пользователь дает
меня положительное целое число, я могу

743
00:36:13,100 --> 00:36:14,150
на самом деле получить Int.

744
00:36:14,150 --> 00:36:15,620
Затем я могу проверить, что Int.

745
00:36:15,620 --> 00:36:18,570
Но тогда я хочу проверить его еще раз и
проверить его еще раз и проверить его еще раз.

746
00:36:18,570 --> 00:36:21,680
Так, очевидно, что является лучшим
построить, используют здесь?

747
00:36:21,680 --> 00:36:22,840
Ладно, некий цикл.

748
00:36:22,840 --> 00:36:25,430
>> Так что я собираюсь избавиться
почти все это.

749
00:36:25,430 --> 00:36:27,320
И я хочу, чтобы эта
Int хотя бы раз.

750
00:36:27,320 --> 00:36:28,890
Так что я собираюсь сказать, делают -

751
00:36:28,890 --> 00:36:32,110
и я вернусь к
а через минуту -

752
00:36:32,110 --> 00:36:33,050
Теперь, что делать?

753
00:36:33,050 --> 00:36:35,860
Я собираюсь сделать Int N получает GetInt ().

754
00:36:35,860 --> 00:36:36,080
ОК.

755
00:36:36,080 --> 00:36:37,250
Так что это довольно хорошо.

756
00:36:37,250 --> 00:36:39,750
И теперь, как часто делают
Я хочу это сделать?

757
00:36:39,750 --> 00:36:45,770
>> Позвольте мне сказать Е внутри цикла
так что я могу требовать снова и снова,

758
00:36:45,770 --> 00:36:46,740
в случае необходимости.

759
00:36:46,740 --> 00:36:49,720
И что же я хочу, чтобы это
а условие делать?

760
00:36:49,720 --> 00:36:53,870
Я хочу продолжать делать это
а то, что это имеет место?

761
00:36:53,870 --> 00:36:54,125
Да.

762
00:36:54,125 --> 00:36:55,390
N меньше или равно нулю.

763
00:36:55,390 --> 00:36:58,180
Так уж, у нас значительно
убрали этот код вверх.

764
00:36:58,180 --> 00:37:00,700
Мы заимствовали очень простая конструкция -
сделай то время как цикл.

765
00:37:00,700 --> 00:37:04,690
Я украл только важные линии
кода, который я начала копирования и

766
00:37:04,690 --> 00:37:05,960
вставка, которая не была мудрым.

767
00:37:05,960 --> 00:37:09,790
И вот теперь я собираюсь на самом деле вставьте
это здесь и просто сделать это один раз.

768
00:37:09,790 --> 00:37:12,990
>> И что сейчас я хочу сделать на
В самом конце этой программы?

769
00:37:12,990 --> 00:37:16,810
Я просто скажу, что-то простое
нравится, спасибо за - и

770
00:37:16,810 --> 00:37:18,980
Я сделаю% я для Int -

771
00:37:18,980 --> 00:37:23,270
обратный слеш п, запятая, а затем
подключите N, точка с запятой.

772
00:37:23,270 --> 00:37:23,910
>> Хорошо.

773
00:37:23,910 --> 00:37:27,290
Итак, давайте посмотрим, что происходит сейчас
когда я запускаю эту программу.

774
00:37:27,290 --> 00:37:30,600
Я собираюсь идти вперед и
действительно делают положительные.

775
00:37:30,600 --> 00:37:30,880
Черт.

776
00:37:30,880 --> 00:37:31,600
Несколько ошибок.

777
00:37:31,600 --> 00:37:32,960
Итак, позвольте мне прокручивать вперед до первого.

778
00:37:32,960 --> 00:37:34,020
Не работать через них в обратном направлении.

779
00:37:34,020 --> 00:37:37,000
Работать через них сверху вниз
чтобы они каскадом и только

780
00:37:37,000 --> 00:37:38,630
одно ошибаться.

781
00:37:38,630 --> 00:37:42,532
Неявная декларация
Функция GetInt ().

782
00:37:42,532 --> 00:37:43,020
Да.

783
00:37:43,020 --> 00:37:44,420
Так было не достаточно.

784
00:37:44,420 --> 00:37:46,760
Я как бы сделал ту же ошибку, но
немного по-другому в этот раз.

785
00:37:46,760 --> 00:37:51,940
Мне нужно не только включать, но stdio.h
Также cs50.h, который включает в себя

786
00:37:51,940 --> 00:37:56,770
так называемых деклараций получить Интернешнл, которая
научить прибора или учит

787
00:37:56,770 --> 00:37:58,760
С того, что GetInt () есть.

788
00:37:58,760 --> 00:37:59,550
>> Итак, позвольте мне сохранить.

789
00:37:59,550 --> 00:38:02,040
Я собираюсь игнорировать другие ошибки
потому что я собираюсь надеяться, что они

790
00:38:02,040 --> 00:38:05,210
или иначе связаны с ошибкой
Я уже зафиксировано.

791
00:38:05,210 --> 00:38:08,710
Итак, позвольте мне идти вперед и перекомпилировать
с принимать позитивные, Enter.

792
00:38:08,710 --> 00:38:09,020
Черт.

793
00:38:09,020 --> 00:38:09,985
Три ошибки, до сих пор.

794
00:38:09,985 --> 00:38:12,650
Позвольте мне прокрутки вверх к первому.

795
00:38:12,650 --> 00:38:14,320
Неиспользованные переменной N.

796
00:38:14,320 --> 00:38:15,850
Мы не видели это прежде.

797
00:38:15,850 --> 00:38:17,200
И это тоже, немного загадочным.

798
00:38:17,200 --> 00:38:18,850
Это вывод компилятора.

799
00:38:18,850 --> 00:38:23,610
И что, что выделенную строку
там - positive.c :9:13 -

800
00:38:23,610 --> 00:38:28,960
говорит, он говорит на линии девять из
positive.c, на 13-м характера,

801
00:38:28,960 --> 00:38:31,510
13-й колонке, вы сделали эту ошибку.

802
00:38:31,510 --> 00:38:34,230
>> И в частности, это говорит
Мне неиспользуемых переменных N.

803
00:38:34,230 --> 00:38:35,790
Итак, давайте посмотрим -

804
00:38:35,790 --> 00:38:37,150
линия девять.

805
00:38:37,150 --> 00:38:40,430
Я использую N в том смысле, что
Я даю ему значение.

806
00:38:40,430 --> 00:38:44,200
Но то, что компилятор не нравится,
что я не казалось бы, его использованием.

807
00:38:44,200 --> 00:38:45,560
Но постойте, я использую его.

808
00:38:45,560 --> 00:38:48,170
В строке 11, я использую его здесь.

809
00:38:48,170 --> 00:38:52,430
Но если я прокрутите вниз дальнейшего
на positive.c :11 -

810
00:38:52,430 --> 00:38:56,230
поэтому на линии 11, 12 символов,
компилятор говорит мне, использование

811
00:38:56,230 --> 00:38:58,670
необъявленный идентификатор н.

812
00:38:58,670 --> 00:39:02,760
>> Так необъявленной означает, что я
не указано его в качестве

813
00:39:02,760 --> 00:39:04,970
Переменная с типом данных.

814
00:39:04,970 --> 00:39:05,500
Но подождите минуту.

815
00:39:05,500 --> 00:39:09,150
Я сделал именно то, что в соответствии девять.

816
00:39:09,150 --> 00:39:11,100
Так что кто-то действительно путают здесь.

817
00:39:11,100 --> 00:39:14,900
Это либо я, либо потому, что компилятор
в соответствии девять, опять же, я объявляю

818
00:39:14,900 --> 00:39:18,650
Int N, и я присвоив ему
вернуть значение GetInt ().

819
00:39:18,650 --> 00:39:22,930
Тогда я использую эту переменную N в соответствии
11 и проверки, если его значение меньше

820
00:39:22,930 --> 00:39:24,050
или равным нулю.

821
00:39:24,050 --> 00:39:27,430
Но это видимо,
плохо и сломанные почему?

822
00:39:27,430 --> 00:39:30,630

823
00:39:30,630 --> 00:39:32,490
Скажи это еще раз?

824
00:39:32,490 --> 00:39:35,690
>> Ах, я должен объявить до N
входа в цикл.

825
00:39:35,690 --> 00:39:36,370
Но почему?

826
00:39:36,370 --> 00:39:39,830
Я имею в виду, мы просто предложили немного назад, что
это прекрасно, чтобы объявить переменные

827
00:39:39,830 --> 00:39:43,600
все на одной линии, а затем
присвоить им какое-то значение.

828
00:39:43,600 --> 00:39:46,790
Глобальная переменная - Вернемся
к этой идее через минуту.

829
00:39:46,790 --> 00:39:48,690
Почему вы хотите, чтобы я положил
его вне цикла?

830
00:39:48,690 --> 00:40:03,170

831
00:40:03,170 --> 00:40:03,830
Так и есть.

832
00:40:03,830 --> 00:40:06,780
Именно так.

833
00:40:06,780 --> 00:40:09,610
>> Так, хотя, несколько парадоксально,
позвольте мне подвести итог.

834
00:40:09,610 --> 00:40:13,510
При объявлении N внутри
из блок DO там -

835
00:40:13,510 --> 00:40:16,320
специально внутри
эти фигурные скобки -

836
00:40:16,320 --> 00:40:19,210
эта переменная N имеет то, что
называется областью -

837
00:40:19,210 --> 00:40:23,210
не связанных с нашей скоринговой системы в
конечно, - но есть сферы, что это

838
00:40:23,210 --> 00:40:25,190
ограничивается теми фигурные скобки.

839
00:40:25,190 --> 00:40:28,460
Другими словами, обычно при объявлении
переменную внутри набора

840
00:40:28,460 --> 00:40:33,370
фигурные скобки, то эта переменная существует только
Внутри эти фигурные скобки.

841
00:40:33,370 --> 00:40:37,320
Итак, что логика одна, хотя
Я объявил N в соответствии девять, он

842
00:40:37,320 --> 00:40:41,910
практически исчезает из сферы,
исчезает из памяти, так сказать,

843
00:40:41,910 --> 00:40:43,370
к тому времени, я ударил линии 11.

844
00:40:43,370 --> 00:40:47,370
Так как линия 11, к сожалению,
за исключением тех, фигурные скобки.

845
00:40:47,370 --> 00:40:51,540
>> Так что я к сожалению, не можете исправить это,
возвращаюсь к тому, что я сделал это раньше.

846
00:40:51,540 --> 00:40:53,370
Вы могли бы сначала сделать это.

847
00:40:53,370 --> 00:40:56,370
Но то, что ты сейчас не
делать циклически?

848
00:40:56,370 --> 00:40:58,260
Вы, очевидно, не получают
целочисленное циклически.

849
00:40:58,260 --> 00:41:01,320
Поэтому мы можем выйти GetInt (), и мы
должны покинуть GetInt () внутри

850
00:41:01,320 --> 00:41:04,420
цикл, поскольку это то, что мы хотим
приставать у пользователя снова и снова.

851
00:41:04,420 --> 00:41:08,660
Но это достаточно, чтобы пойти
до линии, скажем, шесть.

852
00:41:08,660 --> 00:41:10,150
Int N, точка с запятой.

853
00:41:10,150 --> 00:41:12,990
Не давайте ему значение еще и потому,
Вам не нужно, чтобы только пока.

854
00:41:12,990 --> 00:41:16,220
>> Но теперь здесь, заметьте - это
было бы очень легко ошибкой.

855
00:41:16,220 --> 00:41:19,440
Я не хочу, чтобы тень моего предыдущего
Декларация N.

856
00:41:19,440 --> 00:41:22,830
Я хочу использовать N, что
на самом деле существует.

857
00:41:22,830 --> 00:41:25,780
И вот теперь в строке 10,
Поручаю п значение.

858
00:41:25,780 --> 00:41:28,580
Но в соответствии шесть, я заявляю н.

859
00:41:28,580 --> 00:41:32,940
И так я могу, или я могу не
использовать его в линии 12 сейчас?

860
00:41:32,940 --> 00:41:37,120
Я могу, потому что, между которыми фигурные
брекетов п объявлен сейчас?

861
00:41:37,120 --> 00:41:38,770
Один здесь, на линии пять.

862
00:41:38,770 --> 00:41:40,330
Чтобы здесь, на одной линии 14.

863
00:41:40,330 --> 00:41:49,770
Так что если я сейчас уменьшить масштаб, сохранить этот файл, перейдите
обратно в и запустить принимать позитивные, это

864
00:41:49,770 --> 00:41:50,820
составлен этот раз.

865
00:41:50,820 --> 00:41:51,940
Так что это уже прогресс.

866
00:41:51,940 --> 00:41:53,640
Slash. . / Положительным, Enter.

867
00:41:53,640 --> 00:41:56,060
>> Я требую, чтобы вы дать мне
целое положительное число.

868
00:41:56,060 --> 00:41:57,750
Отрицательные 1.

869
00:41:57,750 --> 00:41:59,020
Отрицательные 2.

870
00:41:59,020 --> 00:42:00,680
Отрицательные 3.

871
00:42:00,680 --> 00:42:01,760
Ноль.

872
00:42:01,760 --> 00:42:03,000
Один.

873
00:42:03,000 --> 00:42:05,130
И спасибо за один
то, что сейчас печатается.

874
00:42:05,130 --> 00:42:07,400
>> Позвольте мне попробовать что-то еще,
из любопытства.

875
00:42:07,400 --> 00:42:09,600
Мне говорят, чтобы ввести целое число.

876
00:42:09,600 --> 00:42:12,870
Но что, если я вместо этого ввести ягненка?

877
00:42:12,870 --> 00:42:14,460
Так что вы сейчас видите другое приглашение -

878
00:42:14,460 --> 00:42:15,350
повторите попытку.

879
00:42:15,350 --> 00:42:17,670
Но нигде в моем коде
я написала повторить попытку.

880
00:42:17,670 --> 00:42:22,320
Так где, по-видимому, это повтор
подскажите откуда, бы вы сказали?

881
00:42:22,320 --> 00:42:23,540
Да, от GetInt () сама.

882
00:42:23,540 --> 00:42:26,650
Так что одна из вещей, персонал делает CS50 автора
для вас, по крайней мере в первые несколько

883
00:42:26,650 --> 00:42:30,400
недели, как мы написали некоторое количество
проверки ошибок, чтобы гарантировать, что если

884
00:42:30,400 --> 00:42:34,260
вы называете GetInt (), вы по крайней мере
вернуться Целочисленное от пользователя.

885
00:42:34,260 --> 00:42:35,460
Вы не будете получать строку.

886
00:42:35,460 --> 00:42:36,440
Вы не будете получать символов.

887
00:42:36,440 --> 00:42:39,660
Вы не будете получать то,
совершенно иное.

888
00:42:39,660 --> 00:42:40,510
Вы получите Int.

889
00:42:40,510 --> 00:42:41,890
>> Теперь она не может быть положительным.

890
00:42:41,890 --> 00:42:42,770
Оно не может быть отрицательным.

891
00:42:42,770 --> 00:42:44,550
Мы не даем никаких гарантий, что вокруг.

892
00:42:44,550 --> 00:42:48,960
Но мы будем приставать к пользователю попробовать еще раз,
повтора, не повторить, пока он или она на самом деле

893
00:42:48,960 --> 00:42:49,810
сотрудничает.

894
00:42:49,810 --> 00:42:53,085
Точно так же, если я сделаю 1,23,
, который не является Int.

895
00:42:53,085 --> 00:42:58,400
Но если я ввести, скажем, 50, то
дает мне значение, которое я хотел.

896
00:42:58,400 --> 00:42:59,050
>> Хорошо.

897
00:42:59,050 --> 00:43:01,380
Так не плохо.

898
00:43:01,380 --> 00:43:04,780
Все вопросы о том, что мы только что сделали?

899
00:43:04,780 --> 00:43:07,930
Ключ вынос бытия, чтобы быть ясным, не
столько цикл, который мы видели

900
00:43:07,930 --> 00:43:10,880
Перед хотя у нас есть на самом деле не
использовали его, но вопрос о сфере, где

901
00:43:10,880 --> 00:43:17,045
переменных может быть может быть использована только
в некоторых указанной области.

902
00:43:17,045 --> 00:43:19,830
>> Хорошо, позвольте мне обратиться к предложению
вы сделали ранее, что из

903
00:43:19,830 --> 00:43:20,860
глобальной переменной.

904
00:43:20,860 --> 00:43:24,880
Как в стороне, то получается, что другой
Решение этой проблемы, но

905
00:43:24,880 --> 00:43:28,880
обычно неправильные решения или
плохо спроектированные решением является

906
00:43:28,880 --> 00:43:31,670
объявить переменную как то, что
называется глобальной переменной.

907
00:43:31,670 --> 00:43:34,610
Теперь я отчасти нарушает мое определение
объемов, потому что есть

908
00:43:34,610 --> 00:43:37,680
Нет фигурные скобки на самом верху
и в самом низу файла.

909
00:43:37,680 --> 00:43:40,190
Но последствия, что
является то, что в настоящее время в четыре линии,

910
00:43:40,190 --> 00:43:41,710
N является глобальной переменной.

911
00:43:41,710 --> 00:43:44,460
И как следует из названия, это
просто доступны везде.

912
00:43:44,460 --> 00:43:45,790
>> Царапины на самом деле имеет эти.

913
00:43:45,790 --> 00:43:48,650
Если вы использовали переменную, Вы можете вспомнить
вам пришлось выбирать, если это для

914
00:43:48,650 --> 00:43:50,780
спрайт или для всех спрайтов.

915
00:43:50,780 --> 00:43:54,270
Ну, все спрайты только тем яснее
способ сказать глобальным.

916
00:43:54,270 --> 00:43:55,520
Да?

917
00:43:55,520 --> 00:44:09,690

918
00:44:09,690 --> 00:44:10,990
Ах, очень хороший вопрос.

919
00:44:10,990 --> 00:44:14,310
>> Поэтому напомним, что в самой первой версии
мой код, когда я неправильно

920
00:44:14,310 --> 00:44:17,700
декларируются и определяются в соответствии N девять -

921
00:44:17,700 --> 00:44:19,980
Я сказал, что она переменную
и я дал ему значение с

922
00:44:19,980 --> 00:44:21,160
Оператор присваивания -

923
00:44:21,160 --> 00:44:22,520
это дало мне две ошибки.

924
00:44:22,520 --> 00:44:26,560
Один тот факт, что п не был использован,
и, во-вторых, что в строке 11

925
00:44:26,560 --> 00:44:27,770
он просто не был объявлен.

926
00:44:27,770 --> 00:44:31,120
Таким образом, первый, который я не
адрес в то время.

927
00:44:31,120 --> 00:44:35,130
Это не строго ошибки объявить
переменной, но не использовать его.

928
00:44:35,130 --> 00:44:38,540
Но одна из вещей, которые мы сделали в
CS50 устройства, сознательно,

929
00:44:38,540 --> 00:44:43,340
педагогически, как мы провернули
ожидания компилятору сделать

930
00:44:43,340 --> 00:44:46,970
Убедитесь, что вы делаете вещи не только
правильно, но на самом деле правильно.

931
00:44:46,970 --> 00:44:51,520
>> Потому что, если вы объявление переменной
N, как и никогда не использовать его, или использовать его

932
00:44:51,520 --> 00:44:53,700
Правильно, то что
оно там делает?

933
00:44:53,700 --> 00:44:55,650
Это действительно не имеет смысла.

934
00:44:55,650 --> 00:44:58,980
И это очень легко со временем, если Вы
не настроить свой компьютер в

935
00:44:58,980 --> 00:45:01,960
Таким образом, просто есть код, который имеет
немного здесь остатки, остатки там.

936
00:45:01,960 --> 00:45:04,390
А потом месяца спустя, оглядываясь назад,
вы, как, почему эта линия

937
00:45:04,390 --> 00:45:05,060
код есть?

938
00:45:05,060 --> 00:45:07,940
А если нет уважительной причины, он
не идет на пользу вы или ваши коллеги

939
00:45:07,940 --> 00:45:10,650
вниз по дороге придется
спотыкаться его тогда.

940
00:45:10,650 --> 00:45:12,540
>> Как в стороне, где
что приходит?

941
00:45:12,540 --> 00:45:16,410
Ну, вспомните, что каждый раз, когда мы составляем
программы, все это вещи

942
00:45:16,410 --> 00:45:17,380
в печати.

943
00:45:17,380 --> 00:45:18,350
Таким образом, мы еще вернемся к этому.

944
00:45:18,350 --> 00:45:22,230
Но опять же, сделать это утилита, которая
автоматизирует процесс компиляции по

945
00:45:22,230 --> 00:45:24,830
работает фактический компилятора
называется лязгом.

946
00:45:24,830 --> 00:45:27,650
Эта вещь, мы в конечном итоге увидеть, имеет
делать с отладкой со специальным

947
00:45:27,650 --> 00:45:29,060
программа под названием отладчик.

948
00:45:29,060 --> 00:45:32,150
Это связано с оптимизацией
код - подробнее об этом в будущем.

949
00:45:32,150 --> 00:45:33,620
Std = C99 -

950
00:45:33,620 --> 00:45:37,870
это просто означает, использовать версию 1999
С. С было вокруг даже дольше, чем

951
00:45:37,870 --> 00:45:40,830
, но они сделали некоторые хорошие
Изменения 10 с лишним лет назад.

952
00:45:40,830 --> 00:45:42,690
>> И вот актуальными.

953
00:45:42,690 --> 00:45:45,880
Мы говорим, сделать все, что
Ранее было бы предупреждение

954
00:45:45,880 --> 00:45:48,560
Ошибка предотвращения студента
от компиляции.

955
00:45:48,560 --> 00:45:51,400
И стены средств сделать это для
целую кучу вещей, а не

956
00:45:51,400 --> 00:45:53,060
всего связаны с переменными.

957
00:45:53,060 --> 00:45:54,700
И то позвольте мне перейти к
в конце этой линии.

958
00:45:54,700 --> 00:45:56,430
И это тоже, мы в конечном итоге
вернуться.

959
00:45:56,430 --> 00:45:59,040
Это, очевидно, название
файл я компиляции.

960
00:45:59,040 --> 00:46:02,160
Это напоминает имя файла
Я выводя в качестве имени

961
00:46:02,160 --> 00:46:04,070
моей работающую программу.

962
00:46:04,070 --> 00:46:08,970
Это-lcs50 просто означает использование CS50
библиотеки, и любое нулей и единиц, что

963
00:46:08,970 --> 00:46:12,390
Сотрудники писал ранее и составил
в этом году, интегрировать

964
00:46:12,390 --> 00:46:13,490
их в моей программе.

965
00:46:13,490 --> 00:46:16,130
>> А кто-нибудь знает, что это-LM?

966
00:46:16,130 --> 00:46:18,150
Это математическая библиотека, которая является
как раз там, даже если вы

967
00:46:18,150 --> 00:46:19,320
не делаю любую математику.

968
00:46:19,320 --> 00:46:22,620
Это просто автоматически, при условии
нам сделать.

969
00:46:22,620 --> 00:46:26,540
>> Ну, сделаем один пример
Здесь, открыв новый файл.

970
00:46:26,540 --> 00:46:30,560
И позвольте мне сохранить этот как string.c.

971
00:46:30,560 --> 00:46:37,980
Получается, что когда мы говорим о данных
Типы сегодня, есть еще больше

972
00:46:37,980 --> 00:46:40,630
происходит под капотом
, чем мы видели до сих пор.

973
00:46:40,630 --> 00:46:42,290
Итак, позвольте мне быстро сделать быструю программу.

974
00:46:42,290 --> 00:46:44,510
Включите stdio.h.

975
00:46:44,510 --> 00:46:45,730
И я оставлю это.

976
00:46:45,730 --> 00:46:48,110
И Вы знаете, позвольте мне не сделать
же ошибки снова и снова.

977
00:46:48,110 --> 00:46:50,540
Включите cs50.h.

978
00:46:50,540 --> 00:46:54,870
И позвольте мне теперь идти вперед
и делать тап_п (недействительными).

979
00:46:54,870 --> 00:46:58,790
>> А сейчас я просто хочу сделать программу
, который делает это - объявить строку

980
00:46:58,790 --> 00:47:03,610
называется с и получить строку
от пользователя.

981
00:47:03,610 --> 00:47:05,820
И позвольте мне сделать небольшое
инструкции здесь -

982
00:47:05,820 --> 00:47:09,960
пожалуйста, дайте мне строку - таким
Пользователь знает, что делать.

983
00:47:09,960 --> 00:47:13,190
А потом здесь ниже этого,
Я хочу сделать следующее -

984
00:47:13,190 --> 00:47:16,060
для INT I получает нулю.

985
00:47:16,060 --> 00:47:18,580
Опять же, программисты обычно
начать отсчет с нуля, но мы не могли

986
00:47:18,580 --> 00:47:20,340
делать что-то одно, если мы действительно хотели.

987
00:47:20,340 --> 00:47:27,240
Теперь я собираюсь сделать я меньше
чем длина строки из с.

988
00:47:27,240 --> 00:47:28,430
Так StrLen -

989
00:47:28,430 --> 00:47:29,510
S-T-R-L-E-N -

990
00:47:29,510 --> 00:47:31,650
опять же, это кратким, потому что легче
ввести, даже если это

991
00:47:31,650 --> 00:47:32,590
загадочным.

992
00:47:32,590 --> 00:47:35,290
>> , Которая является функцией мы не используется
раньше, но делает это буквально -

993
00:47:35,290 --> 00:47:37,810
возвращайся ко мне число, которое представляет
Длина строки

994
00:47:37,810 --> 00:47:38,690
, введенный пользователем.

995
00:47:38,690 --> 00:47:41,740
Если они набраны в привет, он вернется
пять, потому что есть пять

996
00:47:41,740 --> 00:47:42,890
буквы в привет.

997
00:47:42,890 --> 00:47:45,390
Затем на каждой итерации
этот цикл, я плюс плюс.

998
00:47:45,390 --> 00:47:49,170
Итак, еще раз, стандартный построить, даже если
Вы не совсем или слишком удобно

999
00:47:49,170 --> 00:47:50,420
знакомы с ним еще.

1000
00:47:50,420 --> 00:47:53,220
>> Но теперь на каждой итерации этого цикла
заметить, что я собираюсь делать.

1001
00:47:53,220 --> 00:47:56,690
Я хочу, чтобы идти вперед и распечатать
одиночный символ -

1002
00:47:56,690 --> 00:47:59,940
% С таким обратную косую черту N с новой строки.

1003
00:47:59,940 --> 00:48:00,990
И потом, вы знаете, что я хочу сделать?

1004
00:48:00,990 --> 00:48:05,090
Какими бы ни были слово в том, что пользователь вводит
в, например, привет, Я хочу напечатать

1005
00:48:05,090 --> 00:48:09,530
H-E-L-L-О, по одному символу в строке.

1006
00:48:09,530 --> 00:48:13,080
Другими словами, я хочу получить в
отдельных символов в строке,

1007
00:48:13,080 --> 00:48:16,770
которой до сих пор не имеет строки просто
была последовательность символов.

1008
00:48:16,770 --> 00:48:21,690
>> И получается, что я могу сделать с, кронштейн,
Я, закрывающую скобку, закройте

1009
00:48:21,690 --> 00:48:23,580
скобки, точка с запятой.

1010
00:48:23,580 --> 00:48:25,640
И я действительно должен сделать еще одну вещь.

1011
00:48:25,640 --> 00:48:30,570
Это в файле с именем string.h
что StrLen объявлен.

1012
00:48:30,570 --> 00:48:33,190
Так что, если я хочу использовать эту функцию,
Мне нужно, чтобы сообщить компилятору,

1013
00:48:33,190 --> 00:48:34,450
ожидать, чтобы использовать его.

1014
00:48:34,450 --> 00:48:37,040
Теперь позвольте мне пойти дальше и сделать
Программа называется строкой.

1015
00:48:37,040 --> 00:48:39,150
Точки, наклонной черты строку.

1016
00:48:39,150 --> 00:48:40,130
>> Пожалуйста, дайте мне строку.

1017
00:48:40,130 --> 00:48:40,900
Я буду идти вперед и введите его.

1018
00:48:40,900 --> 00:48:43,040
Здравствуй, заглавными буквами, Enter.

1019
00:48:43,040 --> 00:48:47,390
А теперь замечаю я напечатал
одному символу за другим.

1020
00:48:47,390 --> 00:48:51,450
Таким образом, новый деталь в том, что строка,
в конце концов, может быть

1021
00:48:51,450 --> 00:48:54,810
доступны в виде отдельных ее
символов, вводя квадратных

1022
00:48:54,810 --> 00:48:55,840
скобок.

1023
00:48:55,840 --> 00:48:59,090
И это потому, что под строкой
капот действительно последовательность

1024
00:48:59,090 --> 00:48:59,810
символов.

1025
00:48:59,810 --> 00:49:02,010
Но то, что аккуратный о них
в оперативной памяти компьютера -

1026
00:49:02,010 --> 00:49:05,300
Mac, PC, бы это ни было - они
буквально спина к спине к спине -

1027
00:49:05,300 --> 00:49:06,225
H-E-L-L-O -

1028
00:49:06,225 --> 00:49:09,920
на индивидуальном, смежный
байтов в памяти.

1029
00:49:09,920 --> 00:49:13,210
>> Так что если вы хотите получить на восьмой таких
байт, который в этом цикле будет

1030
00:49:13,210 --> 00:49:16,900
Кронштейн нуля, кронштейн одной, кронштейн два,
Кронштейн три, четыре кронштейна -

1031
00:49:16,900 --> 00:49:18,890
которая никогда нуля индексироваться вплоть до пяти -

1032
00:49:18,890 --> 00:49:23,330
, которая будет выдавать H-E-L-L-O
на отдельной строке.

1033
00:49:23,330 --> 00:49:26,320
>> Теперь, как тизер, позвольте мне показать вам
виды вещей вы в конечном итоге быть

1034
00:49:26,320 --> 00:49:31,950
способны понимать, по крайней мере
с некоторыми близкими смотреть.

1035
00:49:31,950 --> 00:49:35,610
С одной стороны, то, что мы включены в сегодняшней
примеры, если вы хотите, на самом деле

1036
00:49:35,610 --> 00:49:38,300
одна из самых первых джейлбрейк
для iPhone.

1037
00:49:38,300 --> 00:49:40,800
Jailbreaking означает растрескивания телефону
так что вы можете использовать его на

1038
00:49:40,800 --> 00:49:43,380
различных носителей или установить
собственное программное обеспечение.

1039
00:49:43,380 --> 00:49:45,660
И вы заметите, это выглядит совершенно
загадочные, скорее всего.

1040
00:49:45,660 --> 00:49:46,520
Но посмотрите на это.

1041
00:49:46,520 --> 00:49:50,420
IPhone видимо с трещинами
цикл, если условие, еще

1042
00:49:50,420 --> 00:49:52,580
состоянии, куча функций
мы не видели.

1043
00:49:52,580 --> 00:49:54,230
>> И опять же, вы не будете в
первый взгляд, вероятно,

1044
00:49:54,230 --> 00:49:55,620
понять, как это работает.

1045
00:49:55,620 --> 00:49:58,940
Но все, что мы вроде как принять
само собой разумеющимся в нашей современной жизни

1046
00:49:58,940 --> 00:50:02,040
фактически ведет к снижению даже в некоторой
этих основах мы были

1047
00:50:02,040 --> 00:50:02,820
смотрите.

1048
00:50:02,820 --> 00:50:06,680
Позвольте мне идти вперед и открыть один
другие программы, holloway.c.

1049
00:50:06,680 --> 00:50:08,970
Так что это тоже то, что вы
Не должны действительно знать.

1050
00:50:08,970 --> 00:50:12,440
Даже никто из сотрудников или я мог
вероятно, понять это, глядя на

1051
00:50:12,440 --> 00:50:15,450
это, потому что это был чей-то код
, который был представлен к тому, что

1052
00:50:15,450 --> 00:50:19,630
исторически известного как затемненный C
Конкурс, в котором можно создавать программы

1053
00:50:19,630 --> 00:50:24,670
которая компилируется и работает, но так чертовски
загадочными ни один человек не может понять, что

1054
00:50:24,670 --> 00:50:27,530
он не будет делать, пока
они на самом деле запустить его.

1055
00:50:27,530 --> 00:50:29,940
>> Так что действительно, если вы посмотрите на это
код, я вижу переключателя.

1056
00:50:29,940 --> 00:50:30,870
Я вижу основной.

1057
00:50:30,870 --> 00:50:33,800
Я вижу эти квадратные скобки подразумевая
какой-то массив.

1058
00:50:33,800 --> 00:50:35,970
Кто-нибудь хочет погадать,
эта программа на самом деле

1059
00:50:35,970 --> 00:50:37,220
делает, если я бегу Холлоуэй?

1060
00:50:37,220 --> 00:50:39,940

1061
00:50:39,940 --> 00:50:40,750
Да.

1062
00:50:40,750 --> 00:50:43,050
ОК.

1063
00:50:43,050 --> 00:50:44,690
Молодцы.

1064
00:50:44,690 --> 00:50:48,090
Таким образом, только сотрудники и я не могу понять
, что эти вещи делают.

1065
00:50:48,090 --> 00:50:51,670
>> И теперь, наконец, позвольте мне идти вперед
и открыть одной другой программе.

1066
00:50:51,670 --> 00:50:53,440
Это одно -

1067
00:50:53,440 --> 00:50:55,550
снова, то мы сделать исходный код
доступны в Интернете - это одно просто

1068
00:50:55,550 --> 00:50:57,480
вид красиво смотреть.

1069
00:50:57,480 --> 00:50:59,750
Все, что они сделали, это хит
пробел совсем немного.

1070
00:50:59,750 --> 00:51:01,320
Но это реальный код.

1071
00:51:01,320 --> 00:51:04,790
Так что если вы думаете, что это красиво, если мы
фактически управляет этим в командной строке

1072
00:51:04,790 --> 00:51:08,970
в конце концов вы увидите, как мы
может делать такие вещи.

1073
00:51:08,970 --> 00:51:14,008
>> Таким образом, мы оставим вас на этой ноте
и до встречи в среду.

1074
00:51:14,008 --> 00:51:18,440
>> [Музыка Воспроизведение]

1075
00:51:18,440 --> 00:51:23,380
>> Докладчик 2: На следующей CS50,
ТФ устроить бунт.

1076
00:51:23,380 --> 00:51:24,112
>> Выступающий 3: Там он есть.

1077
00:51:24,112 --> 00:51:25,362
Взять его!

1078
00:51:25,362 --> 00:51:29,912

1079
00:51:29,912 --> 00:51:32,074
>> [Музыка Воспроизведение]