1
00:00:07,420 --> 00:00:08,160
[Powered by Google Translate] David J. Малан: Все правильно.

2
00:00:08,160 --> 00:00:11,170
Это CS50, и это в конце второй недели.

3
00:00:11,170 --> 00:00:14,650
Если вы планируете быть голодным вокруг этого завтра время, знают, что мы собираемся

4
00:00:14,650 --> 00:00:18,920
провести как небольшой группой завтра, четверг, 1:15 PM.

5
00:00:18,920 --> 00:00:21,460
Там есть URL здесь, если вы хотите, чтобы RSVP.

6
00:00:21,460 --> 00:00:25,270
Места ограничены, так что простите, если форма заполнена к тому времени вы

7
00:00:25,270 --> 00:00:26,680
заполнить эту анкету.

8
00:00:26,680 --> 00:00:29,400
Другой URL, хотя это может быть интересно это.

9
00:00:29,400 --> 00:00:32,409
>> Так что почти в течение месяца, курс будет доступна

10
00:00:32,409 --> 00:00:36,090
Все более широко через EDX, через которые люди в интернете будет

11
00:00:36,090 --> 00:00:39,580
возможность следить вместе, участвовать в процессе достаточно активно, на самом деле.

12
00:00:39,580 --> 00:00:43,070
Они буду использовать CS50 и CS50 Appliance Обсудить и большинство

13
00:00:43,070 --> 00:00:45,840
различные программные средства, которые мы уже использовали в этом семестре.

14
00:00:45,840 --> 00:00:49,030
И одна из инициатив, которые мы хотели бы взять в качестве эксперимента в этом году

15
00:00:49,030 --> 00:00:53,120
, чтобы увидеть, как много содержания, которое мы можем перевести в другие говорят и

16
00:00:53,120 --> 00:00:54,110
письменных языков.

17
00:00:54,110 --> 00:00:58,000
Так что, если вы могли бы иметь заинтересованность в участии в этом проекте, в результате чего

18
00:00:58,000 --> 00:01:02,090
мы предоставим английском стенограммы и субтитры для курса

19
00:01:02,090 --> 00:01:05,190
Лекции и шорты и семинаров, секций и т.п. -

20
00:01:05,190 --> 00:01:08,700
если вы свободно говорить и писать свободно на другом языке, мы бы

21
00:01:08,700 --> 00:01:12,240
любите заниматься вы в этом проекте, в котором вы взять на себя одну или несколько

22
00:01:12,240 --> 00:01:15,340
Видео, переводя их на язык, вы знаете достаточно хорошо.

23
00:01:15,340 --> 00:01:19,050
Чтобы дать вам представление о интерфейсе, там данном веб-интерфейс

24
00:01:19,050 --> 00:01:22,330
, которые мы будем использовать, что создаст существенно пользовательского интерфейса, как это.

25
00:01:22,330 --> 00:01:24,520
Это было мне преподавании некоторых Хэллоуин назад.

26
00:01:24,520 --> 00:01:27,710
А на правой стороне там в черном рядом с этими метками времени,

27
00:01:27,710 --> 00:01:31,300
Вы увидите различные вещи, которые вышли из моих уст в тот день.

28
00:01:31,300 --> 00:01:34,660
И тогда под ним, вы сможете перевести на другой язык.

29
00:01:34,660 --> 00:01:37,840
Именно то, что отображение между ними, в данном случае, английского

30
00:01:37,840 --> 00:01:38,660
и, скажем, испанского языка.

31
00:01:38,660 --> 00:01:40,480
Так что это на самом деле очень удобный инструмент.

32
00:01:40,480 --> 00:01:43,690
Вы можете перемотки назад и вперед очень легко с помощью сочетаний клавиш.

33
00:01:43,690 --> 00:01:46,710
Так что, если вы хотите принять участие в этом эксперименте, и ваши слова

34
00:01:46,710 --> 00:01:50,730
видел и читал, потенциально тысячи людей там, пожалуйста чувствуют

35
00:01:50,730 --> 00:01:51,960
бесплатное участие.

36
00:01:51,960 --> 00:01:56,940
>> Теперь несколько слов об котенок с понедельника, чтобы мы отправили чрезмерно

37
00:01:56,940 --> 00:01:58,120
страшно сообщении.

38
00:01:58,120 --> 00:02:02,130
Понимаю, что как офисные часы предложить и как разделы предположить,

39
00:02:02,130 --> 00:02:05,110
Дизайн, конечно, очень многое сделать, чтобы студенты сотрудничают и

40
00:02:05,110 --> 00:02:09,250
говорят, чтобы работать через проблемы множеств и проблемы вместе.

41
00:02:09,250 --> 00:02:13,630
И действительно линии просто сводится к, опять же, работа, которую вы в конечном итоге

42
00:02:13,630 --> 00:02:16,420
должны представить должно быть вашей собственной.

43
00:02:16,420 --> 00:02:19,080
И так будет, честно говоря - в рабочее время, это совершенно нормально -

44
00:02:19,080 --> 00:02:21,560
это полностью и следовало ожидать, даже - поболтать с некоторыми

45
00:02:21,560 --> 00:02:22,370
друзья рядом с Вами.

46
00:02:22,370 --> 00:02:25,240
Если он или она борется с некоторой теме, и вы, как: ой, ну пусть

47
00:02:25,240 --> 00:02:27,750
мне дать вам взглянуть на некоторые строки кода, который я написал.

48
00:02:27,750 --> 00:02:28,290
Это нормально.

49
00:02:28,290 --> 00:02:28,700
Это бывает.

50
00:02:28,700 --> 00:02:31,580
И это очень благоприятный, я думаю, с процессом обучения.

51
00:02:31,580 --> 00:02:35,270
Там, где линия, опять же, получает перешли, когда голова наклонена рода более

52
00:02:35,270 --> 00:02:38,800
здесь слишком много секунд или минут, которые действительно иметь только

53
00:02:38,800 --> 00:02:41,250
была возможность разблокировки для вашего друга.

54
00:02:41,250 --> 00:02:43,870
И, конечно, когда все становится обмен по электронной почте и Dropbox и

55
00:02:43,870 --> 00:02:45,350
как, там тоже есть линии.

56
00:02:45,350 --> 00:02:48,940
Таким образом, все средства, чувствовать себя комфортно и чувствовать рекомендуется общаться с друзьями

57
00:02:48,940 --> 00:02:51,270
и одноклассникам о psets и многое другое.

58
00:02:51,270 --> 00:02:54,680
И так же, понимаю, что то, что вы в конечном итоге представить, должны быть действительно

59
00:02:54,680 --> 00:02:57,780
продукт вашего творчества, а не кто-то другой.

60
00:02:57,780 --> 00:03:01,010
>> Так, в том же ключе из приятные существа, вы можете

61
00:03:01,010 --> 00:03:02,820
знаю этого парня здесь.

62
00:03:02,820 --> 00:03:06,180
Так что это ужасно дрянной фильм с лет назад.

63
00:03:06,180 --> 00:03:08,680
Кто здесь видел Космические яйца?

64
00:03:08,680 --> 00:03:09,120
Хорошо.

65
00:03:09,120 --> 00:03:10,220
Так что хороший номер здесь.

66
00:03:10,220 --> 00:03:13,840
Таким образом, это наши замечательные академические способ введения Сегодня в конечном счете,

67
00:03:13,840 --> 00:03:15,130
Понятие криптографии.

68
00:03:15,130 --> 00:03:19,010
И поэтому одним из области конкретных задач для PSET 2, который придет

69
00:03:19,010 --> 00:03:22,770
поздно ночью завтра, погрузиться в мир криптографии, которая

70
00:03:22,770 --> 00:03:26,380
это искусство шифрования или скремблирования информации.

71
00:03:26,380 --> 00:03:30,160
И это в конечном итоге связано с миром безопасности.

72
00:03:30,160 --> 00:03:34,440
>> Теперь безопасность для большинства нас приходит в виде довольно мирской механизмов.

73
00:03:34,440 --> 00:03:36,920
У всех нас есть имена пользователей и пароли.

74
00:03:36,920 --> 00:03:41,350
И у всех нас есть очень плохие имена пользователей и пароли, скорее всего.

75
00:03:41,350 --> 00:03:45,250
Если ваш пароль так же на нескольких веб-сайтах, что, вероятно, не

76
00:03:45,250 --> 00:03:47,920
лучшая идея, так как мы обсудим ближе к концу семестра.

77
00:03:47,920 --> 00:03:51,680
Если ваш пароль записывается на записки - не шутка - на

78
00:03:51,680 --> 00:03:55,130
мониторе, то это тоже не обязательно лучший дизайн, но довольно распространенное

79
00:03:55,130 --> 00:03:56,140
явлению.

80
00:03:56,140 --> 00:04:00,420
И если вы не используете криптографию для шифрования паролей, они

81
00:04:00,420 --> 00:04:01,610
Особенно уязвимы.

82
00:04:01,610 --> 00:04:04,670
Так что если вы думаете, что быть супер умный, имея скрытые слова

83
00:04:04,670 --> 00:04:07,740
документ где-то на вашем жестком диске, который имеет все ваши пароли, но

84
00:04:07,740 --> 00:04:10,550
он находится в папке, что никто не собирается заглянуть, что тоже не очень

85
00:04:10,550 --> 00:04:11,540
безопасный механизм.

86
00:04:11,540 --> 00:04:15,100
И то, что PSET 2 будет ввести это искусство криптографии и

87
00:04:15,100 --> 00:04:18,300
скремблирования информации, так что такие вещи, как пароли

88
00:04:18,300 --> 00:04:19,500
Тем более безопасным.

89
00:04:19,500 --> 00:04:24,500
Таким образом, чтобы мотивировать это очень реальные проблемы с очень не в реальном мире

90
00:04:24,500 --> 00:04:28,740
Сценарий, позвольте мне познакомить вас с одним из наших любимых клипов вот с этого

91
00:04:28,740 --> 00:04:29,895
Фильм, Космические яйца.

92
00:04:29,895 --> 00:04:30,565
>> [ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

93
00:04:30,565 --> 00:04:32,995
-Шлем, вы злодей, что происходит?

94
00:04:32,995 --> 00:04:34,730
Что вы делаете с моей дочерью?

95
00:04:34,730 --> 00:04:38,960
-Позвольте мне представить блестящий молодой пластический хирург, д-р Филип

96
00:04:38,960 --> 00:04:43,290
Schlotkin, величайшим человеком носа во всем

97
00:04:43,290 --> 00:04:45,526
Вселенная и Беверли-Хиллз.

98
00:04:45,526 --> 00:04:46,450
-Ваше Высочество.

99
00:04:46,450 --> 00:04:47,380
Нос работу?

100
00:04:47,380 --> 00:04:48,035
Не понимаю.

101
00:04:48,035 --> 00:04:49,480
Она уже была носа.

102
00:04:49,480 --> 00:04:51,490
Это был сладкий 16 настоящего.

103
00:04:51,490 --> 00:04:53,090
-Нет, это не то, что вы думаете.

104
00:04:53,090 --> 00:04:55,150
Это гораздо, гораздо хуже.

105
00:04:55,150 --> 00:04:59,860
Если вы не дадите мне сочетании с щитом воздуха, д-р Schlotkin будет

106
00:04:59,860 --> 00:05:04,135
дать вашей дочери назад ее старый нос.

107
00:05:04,135 --> 00:05:05,385
-Нет!

108
00:05:08,202 --> 00:05:10,186
Где ты это взял?

109
00:05:10,186 --> 00:05:11,178
-Все в порядке.

110
00:05:11,178 --> 00:05:11,674
Я расскажу.

111
00:05:11,674 --> 00:05:12,666
Я расскажу.

112
00:05:12,666 --> 00:05:14,154
-Нет, папа, нет.

113
00:05:14,154 --> 00:05:15,150
Вы не должны.

114
00:05:15,150 --> 00:05:16,460
-Ты права, моя дорогая.

115
00:05:16,460 --> 00:05:18,450
Я буду скучать по вашим новым носом.

116
00:05:18,450 --> 00:05:21,550
Но я не буду говорить им комбинации ни на что.

117
00:05:21,550 --> 00:05:23,100
-Очень хорошо.

118
00:05:23,100 --> 00:05:25,510
Доктор Schlotkin, дело ваше.

119
00:05:25,510 --> 00:05:26,760
-С удовольствием.

120
00:05:30,560 --> 00:05:31,180
-Нет!

121
00:05:31,180 --> 00:05:33,450
Подождите, подождите.

122
00:05:33,450 --> 00:05:34,770
Я расскажу.

123
00:05:34,770 --> 00:05:36,400
Я расскажу.

124
00:05:36,400 --> 00:05:38,630
-Я знал, что он будет работать.

125
00:05:38,630 --> 00:05:42,040
Хорошо, дайте его мне.

126
00:05:42,040 --> 00:05:46,890
-Сочетание является одним.

127
00:05:46,890 --> 00:05:47,290
-One.

128
00:05:47,290 --> 00:05:48,183
-One.

129
00:05:48,183 --> 00:05:48,950
-Два.

130
00:05:48,950 --> 00:05:49,370
-Два.

131
00:05:49,370 --> 00:05:50,450
-Два.

132
00:05:50,450 --> 00:05:50,715
Три

133
00:05:50,715 --> 00:05:51,380
-Три.

134
00:05:51,380 --> 00:05:52,390
-Три.

135
00:05:52,390 --> 00:05:53,200
Четыре.

136
00:05:53,200 --> 00:05:53,720
Четыре.

137
00:05:53,720 --> 00:05:55,830
Четыре.

138
00:05:55,830 --> 00:05:56,580
Пять

139
00:05:56,580 --> 00:05:57,120
-Пять.

140
00:05:57,120 --> 00:05:58,560
-Пять.

141
00:05:58,560 --> 00:06:03,770
-Таким образом, комбинация один, два, три, четыре, пять.

142
00:06:03,770 --> 00:06:06,745
Это самое глупое сочетание я когда-либо слышал в своей жизни.

143
00:06:06,745 --> 00:06:09,290
Это такая вещь, идиот будет иметь на своем багаже.

144
00:06:09,290 --> 00:06:11,540
-Благодарю вас, ваше высочество.

145
00:06:11,540 --> 00:06:12,940
-Что ты сделал?

146
00:06:12,940 --> 00:06:14,230
-Я выключил стену.

147
00:06:14,230 --> 00:06:14,630
-Нет, ты этого не сделал.

148
00:06:14,630 --> 00:06:15,430
Вы выключили весь фильм.

149
00:06:15,430 --> 00:06:16,722
-Должно быть, я нажал не на ту кнопку.

150
00:06:16,722 --> 00:06:18,078
-Ну, положил его обратно.

151
00:06:18,078 --> 00:06:18,805
Положить фильм обратно.

152
00:06:18,805 --> 00:06:19,080
-Да, сэр.

153
00:06:19,080 --> 00:06:19,270
Да, сэр.

154
00:06:19,270 --> 00:06:19,830
-Пойдем, Эрна.

155
00:06:19,830 --> 00:06:20,270
Ну, Гретхен.

156
00:06:20,270 --> 00:06:22,850
Конечно, вы знаете, я все равно придется выставить вам счет за это.

157
00:06:27,400 --> 00:06:28,325
-Ну, это сработало?

158
00:06:28,325 --> 00:06:29,550
Где ворота?

159
00:06:29,550 --> 00:06:29,910
-Это сработало, сэр.

160
00:06:29,910 --> 00:06:30,770
Мы имеем комбинацию.

161
00:06:30,770 --> 00:06:31,390
-Отлично.

162
00:06:31,390 --> 00:06:35,630
Теперь мы можем взять каждый последний глоток свежего воздуха с планеты Druidia.

163
00:06:35,630 --> 00:06:36,550
Какая комбинация?

164
00:06:36,550 --> 00:06:38,805
-Один, два, три, четыре, пять.

165
00:06:38,805 --> 00:06:40,610
-Один, два, три, четыре, пять?

166
00:06:40,610 --> 00:06:41,070
-Да.

167
00:06:41,070 --> 00:06:41,760
-Это удивительно.

168
00:06:41,760 --> 00:06:45,200
У меня та же комбинация на мой багаж.

169
00:06:45,200 --> 00:06:47,800
Подготовка Spaceball 1 для немедленного отъезда.

170
00:06:47,800 --> 00:06:48,536
-Да, сэр.

171
00:06:48,536 --> 00:06:52,350
-И изменить комбинацию на мой багаж.

172
00:06:52,350 --> 00:06:53,250
-Ой!

173
00:06:53,250 --> 00:06:55,020
[END ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

174
00:06:55,020 --> 00:06:57,470
>> David J. Малан: удивительный фильм, который вы должны теперь все видят.

175
00:07:00,600 --> 00:07:06,540
Таким образом, контекст здесь является то, что с небезопасной данные поступают возможность

176
00:07:06,540 --> 00:07:07,790
зашифровать его и, чтобы засекретить его.

177
00:07:07,790 --> 00:07:11,060
И вот этот, например, является примером зашифрованное сообщение.

178
00:07:11,060 --> 00:07:12,980
Это на самом деле что-то говорит на английском языке.

179
00:07:12,980 --> 00:07:14,750
Но это явно не вполне очевидна.

180
00:07:14,750 --> 00:07:17,360
И мы прошли полный круг сегодня, чтобы дразнить друг от друга, что это секрет

181
00:07:17,360 --> 00:07:18,380
сообщение здесь.

182
00:07:18,380 --> 00:07:22,370
Но в реальном мире компьютеров, вещи, даже не похоже, что они могут

183
00:07:22,370 --> 00:07:23,440
быть английские фразы.

184
00:07:23,440 --> 00:07:27,500
Например, это то, что вы можете найти на стандартной Linux или Mac или

185
00:07:27,500 --> 00:07:32,080
Unix компьютере в файл, который был когда-то называли файла паролей.

186
00:07:32,080 --> 00:07:34,170
В настоящее время, это были перемещены в другие места.

187
00:07:34,170 --> 00:07:38,660
Но если вы посмотрите в нужном месте в системе, вы увидите не только ваши

188
00:07:38,660 --> 00:07:41,430
Имя пользователя или других людей в системе, но вы увидите,

189
00:07:41,430 --> 00:07:43,410
зашифрованную версию пароля.

190
00:07:43,410 --> 00:07:47,800
Действительно, слово склеп там предполагает, что следующие вещи в зашифрованном виде.

191
00:07:47,800 --> 00:07:52,030
И этот ряд, казалось бы, случайных букв и символов и цифр

192
00:07:52,030 --> 00:07:56,370
т.д. могут быть расшифрованы только в целом зная некоторые тайны -

193
00:07:56,370 --> 00:07:58,600
секретное слово, секретный номер.

194
00:07:58,600 --> 00:08:02,760
И действительно, искусство криптографии в конечном счете, сводится к тому, доверяю некоторых

195
00:08:02,760 --> 00:08:05,700
рода и, зная то, что кто-то не делает.

196
00:08:05,700 --> 00:08:10,010
Мы рассмотрим это в немного более подробно сегодня и в PSET в будущем.

197
00:08:10,010 --> 00:08:11,860
>> А теперь несколько слов о Pass / Fail.

198
00:08:11,860 --> 00:08:15,250
Таким образом, в частности, как некоторые из вас нырнул в PSET 1, устройство и

199
00:08:15,250 --> 00:08:18,390
Очень новый мир для себя, понял, что разочарования и

200
00:08:18,390 --> 00:08:21,340
путаницу и просто технических трудностей следует ожидать.

201
00:08:21,340 --> 00:08:24,410
Особенно с первым PSET, где есть так много всего нового, просто получаю

202
00:08:24,410 --> 00:08:28,830
знакомый с Ls и компакт-диск, и все эти тайные команды в новых условиях.

203
00:08:28,830 --> 00:08:32,679
И это отдельно от фактического материала и программирование себя.

204
00:08:32,679 --> 00:08:35,960
Так понимаю и то, что есть, конечно, рабочие часы, которые существуют как

205
00:08:35,960 --> 00:08:36,770
Поддержка структуры.

206
00:08:36,770 --> 00:08:38,620
Разделы начать в ближайшее воскресенье.

207
00:08:38,620 --> 00:08:41,990
Но самое главное, если вы чувствуете себя просто, что это не

208
00:08:41,990 --> 00:08:44,420
мир для тебя, понимаешь, что это действительно просто нужно время.

209
00:08:44,420 --> 00:08:47,520
И если бы не эта возможность лет назад для меня взять класс

210
00:08:47,520 --> 00:08:50,840
годен / не годен, если честно, я никогда бы даже ступить в классе.

211
00:08:50,840 --> 00:08:53,520
И вы можете изменить это до, скажем, пятый понедельник курс.

212
00:08:53,520 --> 00:08:57,110
Так что если вы на краю теперь, понимаешь, что вместо головы в некоторых других

213
00:08:57,110 --> 00:09:01,000
вод в целом, не только, конечно, рассмотреть изменения в зачет / незачет.

214
00:09:01,000 --> 00:09:03,750
Опять же, это не совсем эту культуру здесь, в Гарварде принимать вещи

215
00:09:03,750 --> 00:09:08,080
годен / не годен, так как все на самом деле хочет достичь или overachieve.

216
00:09:08,080 --> 00:09:11,470
Но, откровенно говоря, это прекрасный способ попробовать что-то, что, возможно, не

217
00:09:11,470 --> 00:09:13,110
быть вам знакомы.

218
00:09:13,110 --> 00:09:17,090
И вы будете в конечном итоге делают в большинстве случаев достаточно хорошо, может быть,

219
00:09:17,090 --> 00:09:18,040
много к вашему удивлению.

220
00:09:18,040 --> 00:09:20,850
И более конкретно, то, что я думаю, что годен / не годен вообще делает,

221
00:09:20,850 --> 00:09:23,350
Особенно, как вы, возможно, испытали с PSET 0, если вы разместили

222
00:09:23,350 --> 00:09:27,200
В 10 часов, 15 часов, 25 часов в некоторых PSET - и вы просто стучать

223
00:09:27,200 --> 00:09:28,180
головой о стену,

224
00:09:28,180 --> 00:09:29,850
и она становится супер поздно ночью,

225
00:09:29,850 --> 00:09:31,880
но вы сделали PSET как 90% пути,

226
00:09:31,880 --> 00:09:33,780
Вы знаете, вы просто не можете понять одну вещь -

227
00:09:33,780 --> 00:09:36,830
годен / не годен действительно снимает остроту класса, как это, где вы можете сортировать

228
00:09:36,830 --> 00:09:39,150
из радостно сказал хорошо, я знаю, что это не идеально.

229
00:09:39,150 --> 00:09:40,470
Но я работал свою задницу на этот счет.

230
00:09:40,470 --> 00:09:42,410
Я очень доволен, где все это закончилось.

231
00:09:42,410 --> 00:09:44,780
И это будет соответствовать ожиданиям для годен / не годен.

232
00:09:44,780 --> 00:09:46,850
Так что имейте это в виду.

233
00:09:46,850 --> 00:09:47,140
>> Хорошо.

234
00:09:47,140 --> 00:09:50,980
Так что те из вас, кто пытался использовать Гарвардского университета Wi-Fi знать

235
00:09:50,980 --> 00:09:54,780
что есть CS50 SSID, Wi-Fi соединение плавающие вокруг, что вы

236
00:09:54,780 --> 00:09:56,520
возможно, повезет больше для.

237
00:09:56,520 --> 00:09:59,430
Это немного парадоксально, что пароль для этого - если вы хотели бы попробовать

238
00:09:59,430 --> 00:10:03,080
подключение к этому для лучшей скорости и дайте нам знать, если это не лучше -

239
00:10:03,080 --> 00:10:09,240
один, два, три, четыре, пять, вплоть до восьми, потому что восемь является

240
00:10:09,240 --> 00:10:10,270
более безопасным, чем пять лет.

241
00:10:10,270 --> 00:10:15,520
Так что если вам нужен Wi-Fi пароль, подключиться к беспроводному CS50 здесь.

242
00:10:15,520 --> 00:10:16,950
Один, два, три, четыре, пять, шесть, семь, восемь.

243
00:10:16,950 --> 00:10:20,440
И сообщению CS50 Обсудить если вы до сих пор периодически возникающих проблем подключения,

244
00:10:20,440 --> 00:10:24,880
и мы дадим полномочия, которые будут знать это пространство.

245
00:10:24,880 --> 00:10:25,180
>> Хорошо.

246
00:10:25,180 --> 00:10:30,350
Так быстро тизер, особенно для тех из вас, кто вентилятора мальчиков или девочек

247
00:10:30,350 --> 00:10:31,900
всех Яблоко вещи.

248
00:10:31,900 --> 00:10:37,566
То, что я выкопал из несколько лет назад был этот файл здесь, ilock.c, просто чтобы

249
00:10:37,566 --> 00:10:40,930
вид сделать более конкретными и более сложные некоторых из более фундаментальных C

250
00:10:40,930 --> 00:10:42,350
программы мы писали.

251
00:10:42,350 --> 00:10:44,360
Так я открыл этот файл, ilock.c.

252
00:10:44,360 --> 00:10:46,830
Он доступен на странице лекции на сегодняшний день.

253
00:10:46,830 --> 00:10:49,470
С левой стороны, вы увидите длинный список функций.

254
00:10:49,470 --> 00:10:51,860
Таким образом, человек, который написал это написал много функций,

255
00:10:51,860 --> 00:10:53,290
больше, чем просто основной.

256
00:10:53,290 --> 00:10:55,490
Он использовал целую кучу библиотек здесь.

257
00:10:55,490 --> 00:11:00,450
И если мы начнем прокрутки, что это на самом деле является очень

258
00:11:00,450 --> 00:11:04,670
Во-первых, я считаю, русификатор для оригинального iPhone.

259
00:11:04,670 --> 00:11:08,000
Когда Вы хотели сделать джейлбрейк оригинальный iPhone, а это значит непривязанный джейлбрейк

260
00:11:08,000 --> 00:11:11,800
от AT & T и фактически установить специальное программное обеспечение на нем и делать вещи

261
00:11:11,800 --> 00:11:13,510
, что Яблоко не хочу, чтобы люди делают -

262
00:11:13,510 --> 00:11:17,020
Ну, кто-то нашел время, чтобы выяснить, как именно они могут использовать

263
00:11:17,020 --> 00:11:20,880
программные ошибки, ошибки, ошибки, программного обеспечения Apple.

264
00:11:20,880 --> 00:11:22,650
И таким образом родилась ilock.c.

265
00:11:22,650 --> 00:11:26,670
Вот если бы он был скомпилирован на компьютере и установить его на iPhone, что

266
00:11:26,670 --> 00:11:29,810
был подключен к компьютеру с помощью, скажем, кабель USB, это даст вам

267
00:11:29,810 --> 00:11:33,360
административные или привилегии на вашем iPhone и позволяет сделать очень многое,

268
00:11:33,360 --> 00:11:34,170
что вы хотите.

269
00:11:34,170 --> 00:11:36,740
>> И вот там был этот увлекательный кошки-мышки между Apple, и

270
00:11:36,740 --> 00:11:39,920
остального мира, в частности, так как они, как и многие компании, пытаются заблокировать

271
00:11:39,920 --> 00:11:43,220
свои вещи вниз, так что вы можете делать с ним, что они намерены.

272
00:11:43,220 --> 00:11:46,620
Но благодаря таким людям, как это и своего понимания низкого уровня

273
00:11:46,620 --> 00:11:50,580
детали и, в данном случае, C программирования и много знакомых конструкций

274
00:11:50,580 --> 00:11:54,630
что мы начали играть, вы сможете по-настоящему рычаги

275
00:11:54,630 --> 00:11:59,050
аппаратного таким образом, вы считаете нужным, и не обязательно некоторым юридическим лицом.

276
00:11:59,050 --> 00:12:01,360
Так, например, я понятия не имею, что все это делают.

277
00:12:01,360 --> 00:12:03,220
Но GetVersion звучит довольно просто.

278
00:12:03,220 --> 00:12:05,480
И, похоже, это функция, что этот человек написал.

279
00:12:05,480 --> 00:12:09,240
Возьми своего рода целое в качестве аргумента, ничего не возвращает, но

280
00:12:09,240 --> 00:12:13,080
кажется, петли с цикла здесь и, если условие, если условие,

281
00:12:13,080 --> 00:12:15,620
разорвать, и как-то относится к номеру версии.

282
00:12:15,620 --> 00:12:16,700
Если мы прокрутить вниз -

283
00:12:16,700 --> 00:12:19,570
хотя многие из этих ключевых слов будет новая, и есть

284
00:12:19,570 --> 00:12:22,590
много функций здесь мы никогда не видели и не могли бы когда-нибудь увидеть более

285
00:12:22,590 --> 00:12:23,830
семестра -

286
00:12:23,830 --> 00:12:27,150
В конце концов, это следует тем же правилам и логике, что мы были

287
00:12:27,150 --> 00:12:28,760
играть с до сих пор.

288
00:12:28,760 --> 00:12:34,220
Так что это слишком стар, чтобы взломать ваш iPhone или 3s 4s 5s или вскоре, в наши дни,

289
00:12:34,220 --> 00:12:37,320
но знаю, что все это очень полученные из этого мира, который мы

290
00:12:37,320 --> 00:12:38,430
нырнул.

291
00:12:38,430 --> 00:12:41,900
>> Итак, давайте взглянем на несколько более простой пример.

292
00:12:41,900 --> 00:12:46,100
Это одна, просто чтобы согреться с некоторыми синтаксиса, а также некоторые другие данные

293
00:12:46,100 --> 00:12:49,240
Тип, что мы говорили, но действительно не видел в С. Таким образом, это

294
00:12:49,240 --> 00:12:51,680
Файл называется positive1.c.

295
00:12:51,680 --> 00:12:55,120
И в комментариях на вершине, это просто требует, чтобы пользователь предоставлял

296
00:12:55,120 --> 00:12:55,960
положительное число.

297
00:12:55,960 --> 00:12:59,530
Так что это пример сделай то время как цикл, который хорош для пользователей интерактивного

298
00:12:59,530 --> 00:13:01,980
программ, где вы должны сказать пользователю, чтобы что-то сделать.

299
00:13:01,980 --> 00:13:05,190
И если они не сотрудничают, вы кричать на них или отклонить их ввода.

300
00:13:05,190 --> 00:13:11,610
Дело в точку, я собираюсь сделать линии от 19 до 24 так долго, как пользователь

301
00:13:11,610 --> 00:13:14,310
не дал мне положительное число.

302
00:13:14,310 --> 00:13:20,400
Теперь эта деталь здесь, на линии 18, почему я заявляю, п выше всего этого

303
00:13:20,400 --> 00:13:24,490
цикл конструкция, в отличие от прямо рядом с линией 22, где я

304
00:13:24,490 --> 00:13:26,880
на самом деле заботятся, чтобы получить п?

305
00:13:26,880 --> 00:13:27,330
Да?

306
00:13:27,330 --> 00:13:27,780
[Неразборчиво]

307
00:13:27,780 --> 00:13:29,040
>> David J. Малан: Да, так что этот вопрос из области видимости.

308
00:13:29,040 --> 00:13:30,850
И в срок непрофессионала, что делает область относится?

309
00:13:34,690 --> 00:13:36,610
Да?

310
00:13:36,610 --> 00:13:37,860
[Неразборчиво]

311
00:13:40,040 --> 00:13:41,105
David J. Малан: Можете ли вы говорить громче?

312
00:13:41,105 --> 00:13:43,450
Выступающий 1: Где можно получить доступ к конкретной переменной.

313
00:13:43,450 --> 00:13:45,170
David J. Малан: Perfect.

314
00:13:45,170 --> 00:13:47,360
Где Вы можете получить доступ к конкретной переменной.

315
00:13:47,360 --> 00:13:50,400
И вообще, правило до сих пор было, что сфера применения некоторых

316
00:13:50,400 --> 00:13:55,860
Переменная определяется самой последней фигурные скобки, что вы видели.

317
00:13:55,860 --> 00:14:02,010
И поэтому в данном случае, если я сделал ошибку, объявив п на линии 22,

318
00:14:02,010 --> 00:14:03,010
, что линия будет работать.

319
00:14:03,010 --> 00:14:10,990
Я хотел бы получить целое число, и я бы поставил его в этой переменной п в строке 22.

320
00:14:10,990 --> 00:14:16,900
Но какие строки кода, теперь понятия не имею, о чем я говорю?

321
00:14:16,900 --> 00:14:22,650
Таким образом, 25, и оказывается, что 24, а также, потому что в этом случае он выходит за пределы

322
00:14:22,650 --> 00:14:23,610
в фигурные скобки.

323
00:14:23,610 --> 00:14:27,280
Так что просто немного неприятность, но очень легко решается просто объявив

324
00:14:27,280 --> 00:14:30,140
переменную за пределами самой функции.

325
00:14:30,140 --> 00:14:32,600
>> Сейчас мы увидим позже сегодня, вы можете сделать еще один шаг.

326
00:14:32,600 --> 00:14:34,860
И вы можете даже получить немного ленивый -

327
00:14:34,860 --> 00:14:37,320
и это не рекомендуется, в общем -

328
00:14:37,320 --> 00:14:42,260
но вы можете даже получить ленивого и положить переменную в глобальном масштабе, так сказать, не

329
00:14:42,260 --> 00:14:46,670
внутри функции, а не внутри цикла, но в самом файле, вне

330
00:14:46,670 --> 00:14:49,600
всех функций вы написали, как я сделал здесь, на линии 15.

331
00:14:49,600 --> 00:14:51,160
Но это, как правило, с неодобрением.

332
00:14:51,160 --> 00:14:55,680
Но понимаю, что это решение иногда к другим проблемам, как мы

333
00:14:55,680 --> 00:14:56,620
в конечном счете видеть.

334
00:14:56,620 --> 00:14:58,130
Таким образом, на данный момент, мы оставим это так.

335
00:14:58,130 --> 00:15:01,030
Но давайте посмотрим, если мы можем переписать это только начало выразить себя

336
00:15:01,030 --> 00:15:01,990
немного по-другому.

337
00:15:01,990 --> 00:15:05,330
>> Таким образом, эта программа, просто чтобы быть ясно, является positive1.

338
00:15:05,330 --> 00:15:11,810
Позвольте мне идти вперед здесь и в моем окне терминала сделать positive1, Enter.

339
00:15:11,810 --> 00:15:12,740
Компиляция, хорошо.

340
00:15:12,740 --> 00:15:14,910
Я собираюсь запустить positive1, нажмите Enter.

341
00:15:14,910 --> 00:15:16,820
Я требую, чтобы вы дать мне целое положительное число.

342
00:15:16,820 --> 00:15:18,260
Я скажу -1.

343
00:15:18,260 --> 00:15:18,910
Это не работает.

344
00:15:18,910 --> 00:15:22,150
0, 99, что, кажется, работает.

345
00:15:22,150 --> 00:15:23,570
Может быть, не самый строгий тест.

346
00:15:23,570 --> 00:15:26,480
Но по крайней мере это хорошая проверка вменяемости, что мы находимся на правильном пути.

347
00:15:26,480 --> 00:15:29,240
Так что теперь позвольте мне идти вперед и открыть второй вариант этого.

348
00:15:29,240 --> 00:15:32,500
И чем отличается уже?

349
00:15:32,500 --> 00:15:35,140
Он реализует то же самое.

350
00:15:35,140 --> 00:15:40,660
Но то, что прыгает, как четко в этот раз?

351
00:15:40,660 --> 00:15:42,560
Да, так это BOOL в зеленый цвет.

352
00:15:42,560 --> 00:15:45,980
Gedit был выделен зеленым цветом это ключевое слово известно как логический,

353
00:15:45,980 --> 00:15:47,000
, который является типом данных.

354
00:15:47,000 --> 00:15:51,080
Она не приходит построен в для всех версий C. Необходимо включить

355
00:15:51,080 --> 00:15:52,010
конкретной библиотеки.

356
00:15:52,010 --> 00:15:54,770
В нашем случае, я включил CS50 библиотеки, так что мы

357
00:15:54,770 --> 00:15:56,460
иметь доступ к BOOL.

358
00:15:56,460 --> 00:15:59,810
Но в строке 18, мы, кажется, есть логическое значение здесь называют благодарны.

359
00:15:59,810 --> 00:16:01,040
Так что я мог бы назвать это ничего.

360
00:16:01,040 --> 00:16:04,500
Но я назвал это благодарна просто вид передают смысловое значение.

361
00:16:04,500 --> 00:16:07,930
Таким образом, первоначально на линии 18, я, видимо, не благодарен, потому что

362
00:16:07,930 --> 00:16:12,150
Логическое значение благодарны инициализируется ложным в строке 18.

363
00:16:12,150 --> 00:16:16,890
И тогда кажется, что я сделал здесь в строках с 21 по 23 это я только что

364
00:16:16,890 --> 00:16:18,610
вид переписать мою логику.

365
00:16:18,610 --> 00:16:21,020
Так что не функционально разные.

366
00:16:21,020 --> 00:16:26,940
Но в строке 22 сейчас, я могу проверить, если Int пользователь предоставил больше

367
00:16:26,940 --> 00:16:31,120
0, то я просто изменить значение благодарны правда.

368
00:16:31,120 --> 00:16:32,290
А зачем мне это делать?

369
00:16:32,290 --> 00:16:35,600
Потому что в строке 25, по-видимому, я собираюсь проверить состояние.

370
00:16:35,600 --> 00:16:39,380
У этого цикла в то время как благодарный является ложным.

371
00:16:39,380 --> 00:16:43,610
>> Так что я предлагаю это в качестве альтернативы версию, потому что она, по крайней мере

372
00:16:43,610 --> 00:16:45,130
немного больше интуитивно, может быть.

373
00:16:45,130 --> 00:16:46,900
Это немного более обоснованной на английском языке.

374
00:16:46,900 --> 00:16:51,710
Таким образом, выполните следующие действия, пока вы не благодарны или при благодарны является ложным.

375
00:16:51,710 --> 00:16:55,890
И на этот раз я тоже, видимо, не люблю вспоминать то, что пользователь набрал

376
00:16:55,890 --> 00:16:57,730
В уведомлении, потому что нет переменной п.

377
00:16:57,730 --> 00:16:58,650
Таким образом, на самом деле, я -

378
00:16:58,650 --> 00:17:00,080
маленькая белая ложь там.

379
00:17:00,080 --> 00:17:02,770
Функционально программа немного отличается, как только мы получим на дно

380
00:17:02,770 --> 00:17:04,819
это потому что я не помнил, что п.

381
00:17:04,819 --> 00:17:09,579
Но я хотел показать здесь, что, хотя мы видели и GetInt

382
00:17:09,579 --> 00:17:13,920
GetString используется на правую сторону знака равенства до сих пор, так что

383
00:17:13,920 --> 00:17:17,160
Мы помним значение, технически, это не строго обязательно.

384
00:17:17,160 --> 00:17:20,950
Если по каким-либо причинам вы просто не заботятся, чтобы сохранить значение, вы просто хотите

385
00:17:20,950 --> 00:17:25,710
для проверки значения, заметили, что мы можем просто написать это как GetInt открытым

386
00:17:25,710 --> 00:17:27,000
парень, рядом парень.

387
00:17:27,000 --> 00:17:30,460
Эта функция будет возвращать значение, как мы уже говорили.

388
00:17:30,460 --> 00:17:32,010
Это будет вернуть вам Int.

389
00:17:32,010 --> 00:17:36,450
И поэтому, если вы мысленно думаю, что это произойдет, когда я печатаю в 99, GetInt

390
00:17:36,450 --> 00:17:38,160
возвращает число 99.

391
00:17:38,160 --> 00:17:41,330
И так концептуально, это как бы мой код был на самом деле этого.

392
00:17:41,330 --> 00:17:45,880
Так, если 99 действительно больше 0, то благодарный становится истинным.

393
00:17:45,880 --> 00:17:50,420
Тогда линия 25 реализует ох, мы сделали, потому что я теперь благодарна.

394
00:17:50,420 --> 00:17:54,590
А в строке 26, мы просто говорим, спасибо за натуральное, какой бы она

395
00:17:54,590 --> 00:17:55,710
случилось быть.

396
00:17:55,710 --> 00:17:58,900
>> Теперь давайте сделаем небольшой синтаксический сахар здесь, так сказать.

397
00:17:58,900 --> 00:18:02,990
Давайте посмотрим, если мы можем убирать эту линию 25 с этой третьей и последней дисперсии

398
00:18:02,990 --> 00:18:04,640
В positive3.

399
00:18:04,640 --> 00:18:08,250
Так заметить той лишь разницей, что теперь строки кода?

400
00:18:11,930 --> 00:18:13,260
Да, так 25.

401
00:18:13,260 --> 00:18:15,520
И мы действительно не видел этот трюк только пока.

402
00:18:15,520 --> 00:18:19,510
Но мы видели восклицательный знак в понедельник, который обозначает, что?

403
00:18:19,510 --> 00:18:20,970
Так нет, или отрицание.

404
00:18:20,970 --> 00:18:23,460
Так что берите логическое значение и перевернуть его значение.

405
00:18:23,460 --> 00:18:24,390
Правда, становится ложным.

406
00:18:24,390 --> 00:18:25,500
Ложные становится истинным.

407
00:18:25,500 --> 00:18:28,910
Так что это, я хотел бы предложить, даже немного более интуитивным способом

408
00:18:28,910 --> 00:18:32,200
написание кода, потому что я до сих пор благодарен инициализации ложным.

409
00:18:32,200 --> 00:18:33,530
Я все еще делаю следующее.

410
00:18:33,530 --> 00:18:35,700
Я поставил благодарны верно, когда придет время.

411
00:18:35,700 --> 00:18:40,690
Но теперь вы действительно можете просто перевести этот код устно слева направо,

412
00:18:40,690 --> 00:18:42,550
хотя и не благодарны.

413
00:18:42,550 --> 00:18:46,170
Из-за взрыва, или восклицательный знак, обозначает понятие нет, так что пока

414
00:18:46,170 --> 00:18:47,010
Не благодарны.

415
00:18:47,010 --> 00:18:49,740
>> Итак, еще раз, мы не введены новые понятия как такового.

416
00:18:49,740 --> 00:18:53,230
Мы говорили о логических назад, когда мы играли с нуля.

417
00:18:53,230 --> 00:18:55,690
Но понимаю, теперь мы можем просто начать писать наш код в

418
00:18:55,690 --> 00:18:56,550
по-разному.

419
00:18:56,550 --> 00:19:00,010
Таким образом, особенно в pset1, если вы вроде пытается выяснить способ

420
00:19:00,010 --> 00:19:03,400
написать программу, наверняка вам повезло, потому что это будет любая

421
00:19:03,400 --> 00:19:05,780
ряд решений, которые вы можете случайно встретить.

422
00:19:05,780 --> 00:19:09,850
Например, это всего лишь три даже для простейших программ.

423
00:19:09,850 --> 00:19:10,180
Хорошо.

424
00:19:10,180 --> 00:19:13,860
А теперь вспомним в понедельник, мы вышли на эту записку с возвращением значения.

425
00:19:13,860 --> 00:19:18,280
Так, в первый раз, мы написали программу, которая не просто главной,

426
00:19:18,280 --> 00:19:22,240
она также имеет свою собственную функцию, которую я написал здесь.

427
00:19:22,240 --> 00:19:26,640
Таким образом, в соответствии с 31 по 34, я реализовал функцию куб.

428
00:19:26,640 --> 00:19:27,800
Это не комплекс.

429
00:19:27,800 --> 00:19:29,830
Это всего лишь раза в раз, и в этом случае.

430
00:19:29,830 --> 00:19:34,920
Но, что важно о нем, что я беру входа в форме и

431
00:19:34,920 --> 00:19:38,910
Я возвращаюсь выход в форме раза в раз.

432
00:19:38,910 --> 00:19:43,940
>> Так что теперь у меня есть возможность, так же, как я раньше с Printf один, звонить

433
00:19:43,940 --> 00:19:47,120
эту функцию, вызвав функцию куб.

434
00:19:47,120 --> 00:19:49,470
И куб функция принимает некоторые вход.

435
00:19:49,470 --> 00:19:52,030
И куб функция возвращает несколько выходных.

436
00:19:52,030 --> 00:19:56,660
И наоборот, Printf просто что-то сделал.

437
00:19:56,660 --> 00:19:59,490
Она не возвращает ничего, что мы заботились о - хотя, как

438
00:19:59,490 --> 00:20:00,820
в сторону, она возвращает значение.

439
00:20:00,820 --> 00:20:02,650
Вы просто вообще игнорируют его.

440
00:20:02,650 --> 00:20:04,000
Printf просто что-то сделал.

441
00:20:04,000 --> 00:20:06,220
Это был побочный эффект печати на экране.

442
00:20:06,220 --> 00:20:09,480
В отличие от здесь, у нас есть куб функции, которые

443
00:20:09,480 --> 00:20:11,400
на самом деле возвращает что-то.

444
00:20:11,400 --> 00:20:12,960
>> Так что это вообще -

445
00:20:12,960 --> 00:20:15,260
для тех, кто знаком с этим, это довольно простая идея.

446
00:20:15,260 --> 00:20:18,460
Но для тех, кто менее знаком с этой идеей проходящих в входы и получение

447
00:20:18,460 --> 00:20:21,700
назад выходов, давайте попробуем просто что-то супер просто.

448
00:20:21,700 --> 00:20:25,180
Кто-нибудь удобные подойдя на этапе кратко?

449
00:20:25,180 --> 00:20:27,460
Вы должны быть знакомы с камерой на вас, как хорошо.

450
00:20:27,460 --> 00:20:27,640
Да.

451
00:20:27,640 --> 00:20:28,610
Хорошо, что вас зовут?

452
00:20:28,610 --> 00:20:29,020
KEN: Кен.

453
00:20:29,020 --> 00:20:29,420
David J. Малан: Кен.

454
00:20:29,420 --> 00:20:29,810
Ладно, Кен.

455
00:20:29,810 --> 00:20:31,060
Поднимайся.

456
00:20:31,060 --> 00:20:34,660
Так что Кен будет функция вида здесь.

457
00:20:34,660 --> 00:20:35,760
И давайте идти вперед и делать это.

458
00:20:35,760 --> 00:20:38,790
Давайте немного фантазии.

459
00:20:38,790 --> 00:20:39,770
Очень приятно.

460
00:20:39,770 --> 00:20:41,010
Добро пожаловать в центре сцены.

461
00:20:41,010 --> 00:20:41,980
Хорошо.

462
00:20:41,980 --> 00:20:45,590
Давайте хит этой кнопки здесь.

463
00:20:45,590 --> 00:20:46,420
Хорошо.

464
00:20:46,420 --> 00:20:49,490
Так что здесь у вас есть современный доске.

465
00:20:49,490 --> 00:20:53,050
И то, что я является основной функцией, например.

466
00:20:53,050 --> 00:20:55,990
И я не имею IPad в руках.

467
00:20:55,990 --> 00:20:59,000
Я действительно не помню, как - ну, на самом деле, не могу сказать.

468
00:20:59,000 --> 00:21:02,200
Я действительно не имеют хороший почерк.

469
00:21:02,200 --> 00:21:05,260
И поэтому я хочу, чтобы вы что-то напечатать на экране для меня.

470
00:21:05,260 --> 00:21:07,470
>> Так что я являясь основной программы.

471
00:21:07,470 --> 00:21:15,060
И я хочу, чтобы ты сказал это, написав его в моей куриной нуля и

472
00:21:15,060 --> 00:21:16,600
Затем мимо вас вход.

473
00:21:16,600 --> 00:21:20,000
Так же глупо, хотя это упражнение, понятие функций и вызова

474
00:21:20,000 --> 00:21:22,260
Функция и возвращение функцией действительно сводится к этому.

475
00:21:22,260 --> 00:21:23,120
Я на-Майне.

476
00:21:23,120 --> 00:21:26,270
Я только что написал Е ("нечто") на экране.

477
00:21:26,270 --> 00:21:27,470
Я бегу этой программы.

478
00:21:27,470 --> 00:21:30,900
И как только Printf вызывается, она принимает один аргумент - или один параметр,

479
00:21:30,900 --> 00:21:31,660
иногда -

480
00:21:31,660 --> 00:21:32,780
в двойные кавычки.

481
00:21:32,780 --> 00:21:33,960
Вот это аргумент.

482
00:21:33,960 --> 00:21:35,740
Я передаю его Кен.

483
00:21:35,740 --> 00:21:39,390
Теперь он является черным ящиком написал некоторое количество лет назад, по-видимому

484
00:21:39,390 --> 00:21:41,070
знает только как печатать вещи на экране.

485
00:21:41,070 --> 00:21:42,320
>> Таким образом, выполнение.

486
00:21:48,842 --> 00:21:49,900
Это не плохо.

487
00:21:49,900 --> 00:21:50,890
Так, очень хорошо.

488
00:21:50,890 --> 00:21:52,900
Так что теперь Кен делается выполнение.

489
00:21:52,900 --> 00:21:55,810
Ему нужно, чтобы передать мне ничего взамен?

490
00:21:55,810 --> 00:21:57,240
Таким образом, не то, что мы видели до сих пор.

491
00:21:57,240 --> 00:21:59,230
Опять же, Printf ли на самом деле возвращает число.

492
00:21:59,230 --> 00:22:01,640
Но мы собираемся игнорировать, что на данный момент, потому что мы никогда не использовали его.

493
00:22:01,640 --> 00:22:03,400
Так вот оно что для Кена.

494
00:22:03,400 --> 00:22:06,650
И вот теперь основные возвращается выполнить -

495
00:22:06,650 --> 00:22:09,630
Основными берет на себя управление программой снова, потому что строки кода,

496
00:22:09,630 --> 00:22:11,010
Printf, осуществляется выполнение.

497
00:22:11,010 --> 00:22:13,890
И мы идем о нашем пути выполнения любых других линий есть.

498
00:22:13,890 --> 00:22:14,130
>> Хорошо.

499
00:22:14,130 --> 00:22:17,080
Итак, теперь давайте попробуем немного другой пример.

500
00:22:17,080 --> 00:22:22,430
И на этот раз здесь, давайте сначала очистить экран здесь.

501
00:22:22,430 --> 00:22:24,670
И на этот раз мы будем делать измерения кубатуры функции.

502
00:22:24,670 --> 00:22:27,350
Но на этот раз, я думаю, выходное значение.

503
00:22:27,350 --> 00:22:28,630
Так что давайте идти вперед и делать это.

504
00:22:28,630 --> 00:22:35,680
Так что теперь у меня есть строка кода, которая говорит, х = куба (х).

505
00:22:35,680 --> 00:22:36,930
Так что на самом деле let's -

506
00:22:41,450 --> 00:22:43,940
строка кода, напомним, выглядит следующим образом.

507
00:22:43,940 --> 00:22:45,960
х = куба (х).

508
00:22:45,960 --> 00:22:48,100
Так как это будет работать?

509
00:22:48,100 --> 00:22:50,820
Так что давайте идти вперед и дать вам белый экран.

510
00:22:50,820 --> 00:22:55,000
И я собираюсь писать теперь до значения х, которые в данный момент

511
00:22:55,000 --> 00:23:01,080
Время случается, скажем, 2, сохранить его простым.

512
00:23:01,080 --> 00:23:04,890
Так что я записал на бумажке значение 2,

513
00:23:04,890 --> 00:23:06,100
, который является моим значения х.

514
00:23:06,100 --> 00:23:08,250
Я передаю его Кен.

515
00:23:08,250 --> 00:23:09,200
KEN: А я просто пишу ответ?

516
00:23:09,200 --> 00:23:12,660
David J. Малан: Да, давайте просто написать ответ.

517
00:23:12,660 --> 00:23:13,030
Хорошо.

518
00:23:13,030 --> 00:23:16,280
И теперь он должен вернуть мне что-нибудь.

519
00:23:16,280 --> 00:23:17,560
Так что -

520
00:23:17,560 --> 00:23:18,170
совершенной.

521
00:23:18,170 --> 00:23:18,840
Приятно переход.

522
00:23:18,840 --> 00:23:21,970
>> Так что теперь он протягивает мне обратно значение 8, в данном случае.

523
00:23:21,970 --> 00:23:23,220
И что мне делать с ним?

524
00:23:23,220 --> 00:23:26,130
Ну, на самом деле, давайте посмотрим.

525
00:23:26,130 --> 00:23:26,640
Получить это право.

526
00:23:26,640 --> 00:23:27,880
Что я буду с ней делать?

527
00:23:27,880 --> 00:23:31,900
Теперь я собираюсь принять это значение и на самом деле хранить его в тех

528
00:23:31,900 --> 00:23:33,400
те же биты в памяти.

529
00:23:33,400 --> 00:23:35,030
Но заметьте, я немного борются здесь.

530
00:23:35,030 --> 00:23:38,280
Я немного смущен, потому что где я на самом деле писать значение х?

531
00:23:38,280 --> 00:23:41,840
Потому что я только что сделал физически руку Кен бумаге

532
00:23:41,840 --> 00:23:44,400
, которые имели значение 2, которое было х.

533
00:23:44,400 --> 00:23:46,300
И действительно, это именно то, что происходит.

534
00:23:46,300 --> 00:23:50,100
Вот и получается, что при вызове функции, и вы передаете в качестве аргумента

535
00:23:50,100 --> 00:23:54,130
как "привет мир" или вы передаете в качестве аргумента, как 2, как правило, вы

536
00:23:54,130 --> 00:23:56,720
проходящей в копии этого аргумента.

537
00:23:56,720 --> 00:24:01,020
И так же, как я записал номер 2 здесь и передал его Кена, которые должны

538
00:24:01,020 --> 00:24:04,760
означает, что у меня еще есть копия значения 2 где-то.

539
00:24:04,760 --> 00:24:08,140
Потому что действительно, теперь, когда я получил обратно значение 8, мне нужно, чтобы вернуться в

540
00:24:08,140 --> 00:24:12,010
RAM и фактически записать 8, где я когда-то был номер 2.

541
00:24:12,010 --> 00:24:15,720
>> Таким образом, визуально помню это понятие проходящей в буквальном

542
00:24:15,720 --> 00:24:16,730
копию значения.

543
00:24:16,730 --> 00:24:19,570
Кен делает свое дело, протягивает мне в ответ что-то - в данном случае,

544
00:24:19,570 --> 00:24:20,820
значения, как 8.

545
00:24:20,820 --> 00:24:22,660
А то у меня что-то сделать с этим значением, если я

546
00:24:22,660 --> 00:24:24,880
хотите сохранить его вокруг.

547
00:24:24,880 --> 00:24:29,470
Так что все это будет слишком хорошо знакомы в скором времени.

548
00:24:29,470 --> 00:24:33,082
Спасибо вам большое за это демо здесь, Кен.

549
00:24:33,082 --> 00:24:34,820
Хорошо.

550
00:24:34,820 --> 00:24:36,720
Очень хорошо сделано.

551
00:24:36,720 --> 00:24:40,610
Итак, давайте посмотрим, как это в конечном итоге связано с некоторыми из функций

552
00:24:40,610 --> 00:24:42,270
вызове, что мы делаем здесь.

553
00:24:42,270 --> 00:24:47,610
Итак, позвольте мне идти вперед и вернуть нас к измерения кубатуры пример.

554
00:24:47,610 --> 00:24:53,080
И обратите внимание, что если мы действительно хотим начать принимать это дальше, мы собираемся

555
00:24:53,080 --> 00:24:57,050
иметь, чтобы помнить о том, что число х который передается в

556
00:24:57,050 --> 00:25:01,390
здесь отличается от того, что на самом деле передается в функцию.

557
00:25:01,390 --> 00:25:03,940
Итак, еще раз, это принятый копия станет совсем

558
00:25:03,940 --> 00:25:05,620
уместны в одну минуту.

559
00:25:05,620 --> 00:25:09,320
>> Итак, давайте взглянем на то, что не совсем правильно работать еще.

560
00:25:09,320 --> 00:25:11,790
Я собираюсь идти вперед и открыть третий пример ошибки, которая

561
00:25:11,790 --> 00:25:13,560
несовершенна по своей природе.

562
00:25:13,560 --> 00:25:18,070
И это называется buggy3, и реализует замены.

563
00:25:18,070 --> 00:25:23,500
Таким образом, здесь мы имеем основные функции, которые х и у произвольно инициализируется

564
00:25:23,500 --> 00:25:24,720
1 и 2, соответственно.

565
00:25:24,720 --> 00:25:27,590
Мы могли бы использовать GetInt, но нам просто нужно простое упражнение.

566
00:25:27,590 --> 00:25:29,680
Таким образом, это жестко, как 1 и 2.

567
00:25:29,680 --> 00:25:35,330
В строках 21 и 22, мы, видимо, распечатайте х и у, по одному на строку.

568
00:25:35,330 --> 00:25:39,620
Затем в строке 23, я утверждаю, я обмен этими значениями, точка, точка, точка.

569
00:25:39,620 --> 00:25:43,030
Я видимо вызова функции в строке 24 называется своп

570
00:25:43,030 --> 00:25:44,000
, которая принимает два аргумента.

571
00:25:44,000 --> 00:25:46,430
Это совершенно законно для функции принимают два аргумента.

572
00:25:46,430 --> 00:25:48,220
Мы видели Printf это сделать уже.

573
00:25:48,220 --> 00:25:50,370
Таким образом, своп-видимому, имеет х и у.

574
00:25:50,370 --> 00:25:53,010
И, как предполагает его название, я надеюсь, что это будет

575
00:25:53,010 --> 00:25:54,320
поменять эти два значения.

576
00:25:54,320 --> 00:25:57,560
Тогда я претендовать на линии 25, поменялись местами.

577
00:25:57,560 --> 00:26:01,570
И я перепечатать х и у в предположении, что

578
00:26:01,570 --> 00:26:02,830
они действительно были поменяны местами.

579
00:26:02,830 --> 00:26:04,370
Но если я действительно запустить эту программу -

580
00:26:04,370 --> 00:26:06,060
Позвольте мне открыть окно терминала.

581
00:26:06,060 --> 00:26:07,750
Позвольте мне сделать buggy3.

582
00:26:07,750 --> 00:26:09,970
Как следует из названия, это не кончится хорошо.

583
00:26:09,970 --> 00:26:14,690
Потому что, когда я ударил Enter, заметил, что х 1.

584
00:26:14,690 --> 00:26:15,720
у-2.

585
00:26:15,720 --> 00:26:19,160
И все же в конце программы, они все еще, по сути, то же самое.

586
00:26:19,160 --> 00:26:22,760
>> Таким образом, на основе демонстрации только сейчас с Кеном, то, что происходит на самом деле?

587
00:26:22,760 --> 00:26:24,660
Ну, давайте погрузиться в эту своп функции.

588
00:26:24,660 --> 00:26:25,800
Это супер короткие.

589
00:26:25,800 --> 00:26:28,020
Это всего лишь несколько строк кода долго.

590
00:26:28,020 --> 00:26:32,810
Но то, что фундаментальные проблемы на основе простую историю рассказал

591
00:26:32,810 --> 00:26:34,270
здесь с Кеном?

592
00:26:34,270 --> 00:26:36,115
Почему подкачки не работает?

593
00:26:36,115 --> 00:26:37,365
[Неразборчиво]

594
00:26:39,840 --> 00:26:40,460
Именно так.

595
00:26:40,460 --> 00:26:43,610
Таким образом, мы хранении на копию, а не саму переменную.

596
00:26:43,610 --> 00:26:46,810
Иными словами, своп-видимому, имеет два аргумента, Int.

597
00:26:46,810 --> 00:26:49,370
И это условно назвать и б.

598
00:26:49,370 --> 00:26:54,430
И здесь, я прошла по х и у, которые являются соответственно 1 и 2.

599
00:26:54,430 --> 00:26:56,580
Но я не в буквальном смысле проходящей в х.

600
00:26:56,580 --> 00:26:58,410
Я не буквально проходящий в год.

601
00:26:58,410 --> 00:27:01,230
Я передаю копии х и копию у.

602
00:27:01,230 --> 00:27:05,180
Это все равно, почти как если бы вы скопировали и вставили в поменяйте значения,

603
00:27:05,180 --> 00:27:07,440
Вы хотите, чтобы на самом деле манипулировать.

604
00:27:07,440 --> 00:27:11,970
Так что, если это так, когда я, программу, начать выполнение

605
00:27:11,970 --> 00:27:14,140
строка 35, то 36 -

606
00:27:14,140 --> 00:27:17,740
когда я добираюсь до линии 37, на данный момент в этой истории, что значение?

607
00:27:20,740 --> 00:27:24,850
В этот момент в истории, строка 37, что является значение в этой точке?

608
00:27:24,850 --> 00:27:25,980
Так оно и должно быть просто 1.

609
00:27:25,980 --> 00:27:26,170
Верно?

610
00:27:26,170 --> 00:27:29,100
Поскольку х был принят в качестве первого аргумента.

611
00:27:29,100 --> 00:27:33,150
И эта функция просто произвольно называет свой первый аргумент,.

612
00:27:33,150 --> 00:27:35,130
Точно так же это у, второй аргумент.

613
00:27:35,130 --> 00:27:37,930
И это просто произвольно вызова второго б аргумент.

614
00:27:37,930 --> 00:27:40,510
>> Теперь эта дихотомия на самом деле довольно просто объяснить.

615
00:27:40,510 --> 00:27:40,880
Подумайте об этом.

616
00:27:40,880 --> 00:27:42,980
Никто из нас не встречал человека, который написал Printf.

617
00:27:42,980 --> 00:27:49,880
Так что, конечно, он или она не знает, что наши переменные спустя 30 лет собираются

618
00:27:49,880 --> 00:27:50,710
называется.

619
00:27:50,710 --> 00:27:55,110
Так что должно быть различие между, что вы называете переменные в

620
00:27:55,110 --> 00:27:59,960
Функции вы пишете и что вы называете переменные в функциях вы

621
00:27:59,960 --> 00:28:01,770
позвонив или использования.

622
00:28:01,770 --> 00:28:05,120
Итак, другими словами, я написал мои переменных х и у.

623
00:28:05,120 --> 00:28:08,060
Но если кто-то другой написал своп функции, он или она, конечно,

624
00:28:08,060 --> 00:28:10,480
не знаю, что мое переменных будет называться.

625
00:28:10,480 --> 00:28:13,850
Так понимаю, что это, почему у вас есть эта двойственность имен.

626
00:28:13,850 --> 00:28:16,800
Технически я мог сделать это случайно.

627
00:28:16,800 --> 00:28:19,750
Но они все равно передается в качестве копии.

628
00:28:19,750 --> 00:28:22,940
Было бы просто чистое совпадение эстетически, если это человек, который написал

629
00:28:22,940 --> 00:28:25,590
подкачки использовали те же имена.

630
00:28:25,590 --> 00:28:25,930
>> Хорошо.

631
00:28:25,930 --> 00:28:29,010
Таким образом, на данный момент в этой истории, строка 37, 1.

632
00:28:29,010 --> 00:28:30,410
Ь 2.

633
00:28:30,410 --> 00:28:32,040
А теперь я перехожу к поменять их местами.

634
00:28:32,040 --> 00:28:34,730
Ну, во-первых, позвольте мне на самом деле сделать это гораздо проще.

635
00:28:34,730 --> 00:28:36,500
Я не знаю, что эти три строки кода делали.

636
00:28:36,500 --> 00:28:37,370
Позвольте мне сделать это.

637
00:28:37,370 --> 00:28:38,850
б получает.

638
00:28:38,850 --> 00:28:40,170
получает б.

639
00:28:40,170 --> 00:28:41,450
Готово.

640
00:28:41,450 --> 00:28:43,540
Почему это сломанный, логически?

641
00:28:46,980 --> 00:28:48,590
Это своего рода интуитивные вещи, не так ли?

642
00:28:48,590 --> 00:28:50,640
Таким образом, становится б.

643
00:28:50,640 --> 00:28:52,450
И б становится.

644
00:28:52,450 --> 00:28:55,410
Но проблема в том, что как только строке 37 выполняется, то, что

645
00:28:55,410 --> 00:28:58,170
Значение и б?

646
00:28:58,170 --> 00:28:59,070
То же самое, 1.

647
00:28:59,070 --> 00:29:03,460
Потому что вы сходу, так сказать, вы изменили б равным.

648
00:29:03,460 --> 00:29:06,000
Поэтому, как только линия 37 выполнена, это здорово.

649
00:29:06,000 --> 00:29:09,940
Теперь у вас есть две копии номером 1 внутри этой функции.

650
00:29:09,940 --> 00:29:14,720
Итак, когда вы говорите в строке 38, б получает, ну, ты вроде на болтах.

651
00:29:14,720 --> 00:29:17,370
Потому что вы просто присвоении 1 к 1.

652
00:29:17,370 --> 00:29:20,400
Ты вроде потерял значение, которое вы заботились о.

653
00:29:20,400 --> 00:29:22,910
>> Таким образом, в оригинальную версию этой, обратите внимание, что я сделал.

654
00:29:22,910 --> 00:29:26,620
Вместо этого я была третья строка кода, которая выглядела следующим образом.

655
00:29:26,620 --> 00:29:29,910
Я заявляю, временная переменная - TMP является очень распространенным названием

656
00:29:29,910 --> 00:29:31,240
для временных переменных.

657
00:29:31,240 --> 00:29:34,280
Это Int потому что он должен соответствовать тому, что я хочу сделать копию.

658
00:29:34,280 --> 00:29:39,720
Я храню копии внутри TMP. Поэтому, как только линия 37 была выполнена,

659
00:29:39,720 --> 00:29:41,390
Значение это -

660
00:29:41,390 --> 00:29:42,970
быстрая проверка исправности -

661
00:29:42,970 --> 00:29:43,460
1.

662
00:29:43,460 --> 00:29:45,780
Значение Ь 2.

663
00:29:45,780 --> 00:29:48,470
И ценность TMP также 1.

664
00:29:48,470 --> 00:29:51,470
Так что теперь я исполню линии 38.

665
00:29:51,470 --> 00:29:57,180
Поэтому, как только линия 38 выполняется, принимает значение б.

666
00:29:57,180 --> 00:29:58,510
И В 2.

667
00:29:58,510 --> 00:30:00,500
Таким образом, в настоящее время 2.

668
00:30:00,500 --> 00:30:03,110
Таким образом, на данный момент в этой истории, равно 2, б = 2,

669
00:30:03,110 --> 00:30:05,130
и TMP 1.

670
00:30:05,130 --> 00:30:09,330
Так что теперь логически, мы можем значения просто хлопнуть TMP в в б.

671
00:30:09,330 --> 00:30:10,690
И мы сделали.

672
00:30:10,690 --> 00:30:12,170
>> Итак, мы решили эту проблему.

673
00:30:12,170 --> 00:30:16,040
К сожалению, когда я запускаю эту программу в таком виде, это на самом деле не поменять

674
00:30:16,040 --> 00:30:17,700
любые значения.

675
00:30:17,700 --> 00:30:18,950
Но чтобы быть понятным, почему?

676
00:30:23,420 --> 00:30:26,310
Я установил логические задачи из всего минуту назад.

677
00:30:26,310 --> 00:30:31,150
Но опять же, если я запускаю эту программу, х и у, остаются неизменными до конца

678
00:30:31,150 --> 00:30:33,834
программы исполнения.

679
00:30:33,834 --> 00:30:34,760
[Неразборчиво]

680
00:30:34,760 --> 00:30:36,030
David J. Малан: Таким образом, мы не вернули ничего.

681
00:30:36,030 --> 00:30:36,960
Так что это правда.

682
00:30:36,960 --> 00:30:39,880
Но, оказывается, есть небольшая проблема здесь, потому что до сих пор,

683
00:30:39,880 --> 00:30:42,460
Единственное, что мы смогли вернуть это одно.

684
00:30:42,460 --> 00:30:46,540
И это ограничение C. Вы можете вернуть только действительно одно значение,

685
00:30:46,540 --> 00:30:48,970
В этом случае, я немного застрял здесь

686
00:30:48,970 --> 00:30:51,805
потому что я мог вернуть новое значение х, или я мог бы вернуться

687
00:30:51,805 --> 00:30:53,160
Новое значение у.

688
00:30:53,160 --> 00:30:54,330
Но я хочу, и обратно.

689
00:30:54,330 --> 00:30:58,010
Таким образом, возвращения не простое решение здесь.

690
00:30:58,010 --> 00:30:59,770
Но проблема в корне почему?

691
00:30:59,770 --> 00:31:03,270
Что мы на самом деле поменялись местами?

692
00:31:03,270 --> 00:31:04,010
а и б.

693
00:31:04,010 --> 00:31:07,670
Но и б являются копиями х и у, которая означает, что мы только что сделали все это

694
00:31:07,670 --> 00:31:10,080
работать - мы только что провели, как три минуты говорить о своп

695
00:31:10,080 --> 00:31:11,680
функцию, и все три из этих переменных.

696
00:31:11,680 --> 00:31:15,090
И это замечательно, совершенно правильно в изоляции.

697
00:31:15,090 --> 00:31:20,230
Но и сферы B, только в этих строках здесь.

698
00:31:20,230 --> 00:31:24,130
Так как цикл, если вы объявите целое я внутрь для

699
00:31:24,130 --> 00:31:27,400
петлю - так же, если вы объявлении и б внутри функции, что

700
00:31:27,400 --> 00:31:30,550
Вы написали, что они действительны только внутри этой функции.

701
00:31:30,550 --> 00:31:35,020
Это означает, как только своп сделать выполнение, и мы идем от линии 24 до

702
00:31:35,020 --> 00:31:38,380
строка 25, х и у не изменилось.

703
00:31:38,380 --> 00:31:42,580
Вы просто впустую много времени, обмен копиями переменных.

704
00:31:42,580 --> 00:31:46,490
>> Вот и получается, что решение это на самом деле, не очевидно.

705
00:31:46,490 --> 00:31:49,210
Это не вполне достаточно, чтобы возвращать значения, потому что мы можем

706
00:31:49,210 --> 00:31:50,320
возвращать только одно значение.

707
00:31:50,320 --> 00:31:53,370
И я действительно хочу, чтобы обменять х и у в то же время.

708
00:31:53,370 --> 00:31:55,020
Так что мы собираемся вернуться к этому.

709
00:31:55,020 --> 00:31:58,770
Но сейчас понимаю, что вопрос принципиально связано с тем,

710
00:31:58,770 --> 00:32:00,660
что А и В являются копиями.

711
00:32:00,660 --> 00:32:03,450
А они в свою сферу.

712
00:32:03,450 --> 00:32:04,980
Ну, давайте попробуем решить это в некотором роде.

713
00:32:04,980 --> 00:32:09,200
Позвольте мне на самом деле прокрутить назад здесь и открыть, скажем, четвертый вариант

714
00:32:09,200 --> 00:32:11,170
это, buggy4.

715
00:32:11,170 --> 00:32:13,230
А что по этому поводу?

716
00:32:13,230 --> 00:32:16,690
Это похожие, но более простую задачу, чтобы смотреть на, прежде чем принять удар на

717
00:32:16,690 --> 00:32:17,530
ее решения.

718
00:32:17,530 --> 00:32:19,440
Эта программа называется приращением.

719
00:32:19,440 --> 00:32:24,320
И он, очевидно, инициализирует целое число х 1 в строке 18.

720
00:32:24,320 --> 00:32:25,950
Я тогда утверждать, х 1.

721
00:32:25,950 --> 00:32:28,020
Я тогда претензии приращения, точка, точка, точка.

722
00:32:28,020 --> 00:32:29,460
Затем я вызываю прирост.

723
00:32:29,460 --> 00:32:33,480
Но тогда в строках 22 и 23, я утверждаю, что это было увеличивается.

724
00:32:33,480 --> 00:32:37,780
Я утверждаю х сейчас бы это ни было, 2 предположительно.

725
00:32:37,780 --> 00:32:39,770
>> Но эта программа глючит.

726
00:32:39,770 --> 00:32:41,020
В чем проблема?

727
00:32:43,450 --> 00:32:44,418
Да?

728
00:32:44,418 --> 00:32:45,668
[Неразборчиво]

729
00:32:49,260 --> 00:32:49,850
David J. Малан: Совершенно верно.

730
00:32:49,850 --> 00:32:52,430
Таким х была объявлена ​​явно в строке 18.

731
00:32:52,430 --> 00:32:54,410
То есть в фигурных скобках основного автора.

732
00:32:54,410 --> 00:32:58,470
Таким образом, простой ответ в том, что, ну, х существует здесь.

733
00:32:58,470 --> 00:33:01,510
Она не существует в строке 32.

734
00:33:01,510 --> 00:33:03,710
Таким образом, эта программа на самом деле даже не будет компилироваться.

735
00:33:03,710 --> 00:33:07,910
Компилятора, когда я пытаюсь компиляции этого кода, будет кричать на меня

736
00:33:07,910 --> 00:33:13,190
О некоторых необъявленный идентификатор или что-то в этом роде.

737
00:33:13,190 --> 00:33:13,870
В самом деле, давайте попробуем.

738
00:33:13,870 --> 00:33:15,235
Это делает buggy4.

739
00:33:17,780 --> 00:33:18,190
Там она есть.

740
00:33:18,190 --> 00:33:22,030
Использование необъявленных х идентификатор в строке 32.

741
00:33:22,030 --> 00:33:25,700
А на самом деле, давайте будем более четко здесь сегодня, так что это полезно

742
00:33:25,700 --> 00:33:27,140
рабочее время и дома.

743
00:33:27,140 --> 00:33:29,000
Обратите внимание, что это немного загадочно написано.

744
00:33:29,000 --> 00:33:31,560
Но то, что Clang имеет кричал на нас, сказав:

745
00:33:31,560 --> 00:33:36,970
buggy4.c: 32:5, на самом деле полезно.

746
00:33:36,970 --> 00:33:41,970
Это означает, что ошибка в строке 32 на позицию символа пять.

747
00:33:41,970 --> 00:33:44,670
Таким образом, один, два, три, четыре, пять.

748
00:33:44,670 --> 00:33:46,640
Это, в самом деле, где проблема.

749
00:33:46,640 --> 00:33:49,710
А также иметь в виду, в рабочее время и дома, мне повезло здесь.

750
00:33:49,710 --> 00:33:50,740
У меня есть одна ошибка.

751
00:33:50,740 --> 00:33:52,660
Это собирается быть относительно легко исправить.

752
00:33:52,660 --> 00:33:56,220
Но если вы получите весь экран полный подавляющее сообщения об ошибках, опять же,

753
00:33:56,220 --> 00:33:59,240
понимают, что самый нижний можно просто быть симптомом

754
00:33:59,240 --> 00:34:00,320
самый верхний из них.

755
00:34:00,320 --> 00:34:03,560
Так всегда гоняться за ваши ошибки сверху вниз.

756
00:34:03,560 --> 00:34:06,720
Потому что там может быть просто цепочкой эффект, предлагаю вам

757
00:34:06,720 --> 00:34:09,030
есть намного больше проблем, чем вы на самом деле.

758
00:34:09,030 --> 00:34:14,989
>> Итак, как мы можем это исправить, если моей целью является, чтобы увеличить х?

759
00:34:14,989 --> 00:34:15,370
Что это?

760
00:34:15,370 --> 00:34:15,620
Хорошо.

761
00:34:15,620 --> 00:34:16,679
Таким образом, мы можем сделать глобальное х.

762
00:34:16,679 --> 00:34:18,860
Давайте ярлык, который я предупреждал раньше.

763
00:34:18,860 --> 00:34:20,550
Но черт возьми, нам просто нужно быстро исправить.

764
00:34:20,550 --> 00:34:23,949
Так что давайте просто скажем, Int х здесь.

765
00:34:23,949 --> 00:34:25,600
Это делает х глобальной.

766
00:34:25,600 --> 00:34:28,460
Так что теперь основным имеет к нему доступ.

767
00:34:28,460 --> 00:34:31,780
И прирост имеет к нему доступ.

768
00:34:31,780 --> 00:34:33,860
И поэтому позвольте мне идти дальше и собрать это сейчас.

769
00:34:33,860 --> 00:34:36,330
Сделать buggy4, Enter.

770
00:34:36,330 --> 00:34:37,440
Кажется, для компиляции сейчас.

771
00:34:37,440 --> 00:34:40,949
Давайте запустим buggy4, и кажется, на самом деле работает.

772
00:34:40,949 --> 00:34:42,780
Теперь это одна из этих вещей -

773
00:34:42,780 --> 00:34:45,870
Делай, как я говорю, а не как я делаю, как я только что сделал здесь.

774
00:34:45,870 --> 00:34:49,239
Потому что в целом наши программы собираются получить гораздо более интересным и

775
00:34:49,239 --> 00:34:50,440
гораздо дольше, чем это.

776
00:34:50,440 --> 00:34:53,199
И если ваше решение жизненных проблем является просто ах, положить все

777
00:34:53,199 --> 00:34:57,550
переменных в начало файла, очень быстро сделать программы получают

778
00:34:57,550 --> 00:34:59,700
ужасно трудно управлять.

779
00:34:59,700 --> 00:35:02,050
Это становится все труднее придумывать новые имена переменных.

780
00:35:02,050 --> 00:35:05,240
Это становится все труднее понять, что переменная делает.

781
00:35:05,240 --> 00:35:08,250
>> А так в общем, это не очень хорошее решение.

782
00:35:08,250 --> 00:35:09,780
Так давайте сделаем это лучше.

783
00:35:09,780 --> 00:35:11,920
Мы не хотим использовать глобальную переменную здесь.

784
00:35:11,920 --> 00:35:14,050
Я хочу, чтобы увеличить х.

785
00:35:14,050 --> 00:35:16,050
Так что я мог бы, очевидно -

786
00:35:16,050 --> 00:35:18,450
В конце концов, это своего рода глупые истории, потому что мы просто делаем это.

787
00:35:18,450 --> 00:35:22,050
Но если бы я не знал о том, что оператор, или я не разрешили

788
00:35:22,050 --> 00:35:27,700
изменить его в основной себе, как еще я мог осуществлять Кен здесь, это

789
00:35:27,700 --> 00:35:31,450
Время не куба, но для увеличения?

790
00:35:31,450 --> 00:35:32,700
Как изменить эту вещь здесь?

791
00:35:32,700 --> 00:35:33,025
Да.

792
00:35:33,025 --> 00:35:34,275
[Неразборчиво]

793
00:35:37,430 --> 00:35:38,000
David J. Малан: Ладно, хорошо.

794
00:35:38,000 --> 00:35:40,490
Так почему бы мне не пройти в X?

795
00:35:40,490 --> 00:35:44,390
И тогда, а не возвращать его, почему бы мне не сделать возврат х + 1?

796
00:35:44,390 --> 00:35:46,370
Теперь, несколько вещей должны изменить здесь.

797
00:35:46,370 --> 00:35:47,530
Я нахожусь на правильном пути.

798
00:35:47,530 --> 00:35:48,910
Что еще нужно настроить?

799
00:35:48,910 --> 00:35:49,470
Кто-то другой.

800
00:35:49,470 --> 00:35:49,882
Да?

801
00:35:49,882 --> 00:35:51,530
[Неразборчиво]

802
00:35:51,530 --> 00:35:53,520
David J. Малан: Мне нужно изменить тип возврата прироста

803
00:35:53,520 --> 00:35:54,590
потому что это не аннулировать.

804
00:35:54,590 --> 00:35:56,650
Пустота означает, что ничего не возвращается.

805
00:35:56,650 --> 00:35:57,600
Но, очевидно, теперь он есть.

806
00:35:57,600 --> 00:36:01,280
Так что нужно изменить в целое, чтобы быть последовательным с тем, что

807
00:36:01,280 --> 00:36:02,580
Я на самом деле возвращения.

808
00:36:02,580 --> 00:36:04,580
>> Сейчас что-то еще по-прежнему багги здесь.

809
00:36:04,580 --> 00:36:04,982
Да?

810
00:36:04,982 --> 00:36:06,590
[Неразборчиво]

811
00:36:06,590 --> 00:36:07,630
David J. Малан: Так что мне нужно увеличивать х?

812
00:36:07,630 --> 00:36:10,336
[Неразборчиво]

813
00:36:10,336 --> 00:36:11,880
David J. Малан: Ах, так что мне нужно пройти х.

814
00:36:11,880 --> 00:36:13,300
Так что мне нужно сделать это здесь.

815
00:36:17,590 --> 00:36:19,690
Таким образом, прототип, я должен изменить это здесь.

816
00:36:19,690 --> 00:36:21,290
Таким образом, это должно стать Int.

817
00:36:21,290 --> 00:36:22,820
Это должно стать -

818
00:36:22,820 --> 00:36:23,670
хм.

819
00:36:23,670 --> 00:36:24,710
Я на самом деле есть ошибка здесь.

820
00:36:24,710 --> 00:36:25,780
Давайте исправим это в первую очередь.

821
00:36:25,780 --> 00:36:27,990
Что это на самом деле быть?

822
00:36:27,990 --> 00:36:29,330
Так что это должно быть что-то Int.

823
00:36:29,330 --> 00:36:30,340
Это может быть х.

824
00:36:30,340 --> 00:36:33,120
Но, откровенно говоря, если вы начинаете призывая всех ваших переменных х, он собирается получить

825
00:36:33,120 --> 00:36:35,250
все менее и менее ясно, что есть что.

826
00:36:35,250 --> 00:36:38,210
Так что давайте просто произвольно выбрать различные именования для моего

827
00:36:38,210 --> 00:36:40,220
вспомогательные функции, функции я пишу.

828
00:36:40,220 --> 00:36:41,100
Мы будем называть его.

829
00:36:41,100 --> 00:36:44,500
Или мы могли бы назвать его - давайте назовем это even_number быть еще более явной.

830
00:36:44,500 --> 00:36:47,610
И тогда я должен вернуть все, что номер плюс 1.

831
00:36:47,610 --> 00:36:49,720
А теперь я должен изменить одну вещь здесь и одно

832
00:36:49,720 --> 00:36:50,700
Другая вещь, которую здесь.

833
00:36:50,700 --> 00:36:54,150
Что я должен изменить в строке 21 в первую очередь?

834
00:36:54,150 --> 00:36:55,390
Я должен назначить его на х.

835
00:36:55,390 --> 00:36:57,480
Поэтому я не могу просто позвонить приращение х.

836
00:36:57,480 --> 00:37:01,000
Мне нужно помнить ответ на изменение значения х на

837
00:37:01,000 --> 00:37:02,020
с левой стороны.

838
00:37:02,020 --> 00:37:04,930
И хотя х сейчас находится на левой и правой, это совершенно нормально, потому что

839
00:37:04,930 --> 00:37:08,370
правая часть запускается на выполнение первого затем получает шлепнулся в левую

840
00:37:08,370 --> 00:37:10,240
руки вещь, х в этом случае.

841
00:37:10,240 --> 00:37:11,900
И тогда, наконец, это легко исправить сейчас.

842
00:37:11,900 --> 00:37:15,080
Это должно просто соответствовать тому, что это внизу.

843
00:37:15,080 --> 00:37:17,120
Int номер.

844
00:37:17,120 --> 00:37:17,320
>> Хорошо.

845
00:37:17,320 --> 00:37:20,290
Таким образом, целый букет изменений действительно глупо функции.

846
00:37:20,290 --> 00:37:24,250
Но представитель вещей, которые мы больше хотим сделать.

847
00:37:24,250 --> 00:37:25,490
Так что buggy4.

848
00:37:25,490 --> 00:37:26,485
Я где-то напортачили.

849
00:37:26,485 --> 00:37:27,520
О, мой Бог.

850
00:37:27,520 --> 00:37:29,660
Пять ошибок в, вроде бы, шесть строки.

851
00:37:29,660 --> 00:37:36,500
Так что же случилось на линии 18, символ 5?

852
00:37:36,500 --> 00:37:36,970
Хорошо.

853
00:37:36,970 --> 00:37:39,330
Так что я должен заявить об этом Int.

854
00:37:39,330 --> 00:37:39,630
Хорошо.

855
00:37:39,630 --> 00:37:41,790
Итак, давайте посмотрим, целая куча других ошибок.

856
00:37:41,790 --> 00:37:42,230
О, мой бог.

857
00:37:42,230 --> 00:37:43,880
19, 18, 21.

858
00:37:43,880 --> 00:37:46,020
Но, опять же, давайте просто очистить экран -

859
00:37:46,020 --> 00:37:48,660
Управление L здесь - и повторные Clang.

860
00:37:48,660 --> 00:37:51,340
Таким образом, пять проблем на самом деле только это.

861
00:37:51,340 --> 00:37:53,500
Итак, теперь давайте запустим buggy4, Enter.

862
00:37:53,500 --> 00:37:54,150
Вот так.

863
00:37:54,150 --> 00:37:57,434
х был увеличен правильно.

864
00:37:57,434 --> 00:37:58,420
>> Хорошо.

865
00:37:58,420 --> 00:38:01,700
Любые вопросы о том, как увеличить число?

866
00:38:01,700 --> 00:38:02,896
Да?

867
00:38:02,896 --> 00:38:06,864
SPEAKER 2: Почему это, что вы можете просто изменить X на номер в переменную

868
00:38:06,864 --> 00:38:08,860
имя, и он будет знать, что вы имеете в виду?

869
00:38:08,860 --> 00:38:09,600
David J. Малан: Хороший вопрос.

870
00:38:09,600 --> 00:38:13,130
Как это, что я могу просто изменить х на номер и программа будет знать,

871
00:38:13,130 --> 00:38:13,990
сразу?

872
00:38:13,990 --> 00:38:16,120
Итак, еще раз, думать о нем, как это абстракция.

873
00:38:16,120 --> 00:38:20,110
Так что, если я главный и Кен дополнительных, честно говоря, мне все равно

874
00:38:20,110 --> 00:38:21,540
что Кен называет свою Ipad.

875
00:38:21,540 --> 00:38:25,350
Меня не волнует, что он называет все, что имеет отношение к его осуществлению

876
00:38:25,350 --> 00:38:26,550
из этой функции.

877
00:38:26,550 --> 00:38:32,130
Так что это деталь реализации, что я, главное, не

878
00:38:32,130 --> 00:38:33,010
должны заботиться о.

879
00:38:33,010 --> 00:38:37,440
И так просто изменив его последовательно внутри функции, количество здесь

880
00:38:37,440 --> 00:38:41,340
и номер здесь, это все, что занимает так много времени, как я перекомпилировать.

881
00:38:41,340 --> 00:38:43,820
Это вроде как если вы думаете о - многие из нас, тех, у кого водителя

882
00:38:43,820 --> 00:38:46,590
Лицензии кто ездил, или если вы даже въехал в автомобиль -

883
00:38:46,590 --> 00:38:50,710
Большинство из нас не знают, как машина работает под капотом.

884
00:38:50,710 --> 00:38:54,710
И буквально, если вы открываете капот, большинство из нас - я в том числе -

885
00:38:54,710 --> 00:38:56,580
не собирается знаю, что мы смотрим.

886
00:38:56,580 --> 00:38:58,850
Вроде как вы можете чувствовать себя в такие вещи, как это прямо сейчас.

887
00:38:58,850 --> 00:39:01,380
Но мы действительно не должны заботиться, как машина работает.

888
00:39:01,380 --> 00:39:05,000
Мы не должны заботиться, что все стержни и поршней и кабелей внутри

889
00:39:05,000 --> 00:39:07,700
машина на самом деле делает.

890
00:39:07,700 --> 00:39:11,360
>> Так что-то вроде, что вы называете поршень не имеет значения

891
00:39:11,360 --> 00:39:11,920
Здесь в этом случае.

892
00:39:11,920 --> 00:39:12,490
Та же самая идея.

893
00:39:12,490 --> 00:39:12,670
Да?

894
00:39:12,670 --> 00:39:13,920
[Неразборчиво]

895
00:39:25,250 --> 00:39:29,530
David J. Малан: Если бы было больше использовании переменного момента ха назад,

896
00:39:29,530 --> 00:39:32,220
Вы, программист, придется менять их повсюду.

897
00:39:32,220 --> 00:39:35,230
Или вы могли бы сделать буквально файлов, меню, а затем Найти / Заменить,

898
00:39:35,230 --> 00:39:36,270
что-то вроде этого.

899
00:39:36,270 --> 00:39:40,110
Но вы будете иметь, чтобы сделать эти изменения самостоятельно.

900
00:39:40,110 --> 00:39:41,200
Вы должны быть последовательны.

901
00:39:41,200 --> 00:39:42,450
[Неразборчиво]

902
00:39:47,200 --> 00:39:48,960
David J. Малан: определенном порядке, как здесь?

903
00:39:48,960 --> 00:39:52,660
Если бы это было Int другой номер?

904
00:39:52,660 --> 00:39:52,940
Да.

905
00:39:52,940 --> 00:39:56,430
Таким образом, порядок имеет значение, когда вы вызываете функцию.

906
00:39:56,430 --> 00:40:00,350
Так что если я звонили прирост здесь что-то в этом запятой,

907
00:40:00,350 --> 00:40:01,400
есть прямое отображение.

908
00:40:01,400 --> 00:40:04,490
Первая переменная, как там это называется, сделана копия первой

909
00:40:04,490 --> 00:40:05,480
Аргумент здесь.

910
00:40:05,480 --> 00:40:07,280
К сожалению, этого не должно быть круглых скобках.

911
00:40:07,280 --> 00:40:09,300
Второй аргумент линии с вторым.

912
00:40:09,300 --> 00:40:11,220
>> Так порядке, да, вопросов.

913
00:40:11,220 --> 00:40:11,490
Хорошо.

914
00:40:11,490 --> 00:40:13,360
Извините, что я взял длинный путь, чтобы добраться там.

915
00:40:13,360 --> 00:40:14,610
Другие вопросы?

916
00:40:16,460 --> 00:40:16,850
Хорошо.

917
00:40:16,850 --> 00:40:20,300
Итак, давайте посмотрим, если мы не можем нарисовать картину того, что происходит на самом деле

918
00:40:20,300 --> 00:40:22,160
Здесь под капотом, так сказать.

919
00:40:22,160 --> 00:40:26,310
Так что это прямоугольник, который может представлять памяти компьютера.

920
00:40:26,310 --> 00:40:31,240
Так что даже если вы не знаете, как работает память или как RAM работы, по крайней мере,

921
00:40:31,240 --> 00:40:33,590
Предположим, что у вас есть пучки она в эти дни.

922
00:40:33,590 --> 00:40:34,740
У вас есть мегабайты его.

923
00:40:34,740 --> 00:40:35,760
У вас есть гигабайты его.

924
00:40:35,760 --> 00:40:40,690
И мы знаем, от недели нулю, что байт именно то, что?

925
00:40:40,690 --> 00:40:41,280
8 бит.

926
00:40:41,280 --> 00:40:42,730
Право, таким образом, 8 нулей и единиц.

927
00:40:42,730 --> 00:40:46,300
Итак, если ваш компьютер имеет гигабайт оперативной памяти, два гигабайта оперативной памяти в эти дни, у вас есть

928
00:40:46,300 --> 00:40:54,450
млрд. или 2 млрд. байт памяти, или примерно 8 млрд., или 16 млрд

929
00:40:54,450 --> 00:40:56,560
битов, внутри компьютера.

930
00:40:56,560 --> 00:40:59,710
Теперь, в отличие от маленьких Woolly например Вилли, это не магнитные частицы

931
00:40:59,710 --> 00:41:00,560
Обычно больше.

932
00:41:00,560 --> 00:41:04,470
Все чаще в ноутбуках по крайней мере, это твердотельные накопители SSD, что

933
00:41:04,470 --> 00:41:05,560
просто не имеют движущихся частей.

934
00:41:05,560 --> 00:41:06,710
Это все электронные.

935
00:41:06,710 --> 00:41:08,070
Это все электричество основе.

936
00:41:08,070 --> 00:41:12,360
Так что думаю, хотя, это просто прямоугольник, как представляющие одну или две

937
00:41:12,360 --> 00:41:13,930
гигабайтами памяти, которая у вас есть.

938
00:41:13,930 --> 00:41:15,500
>> Так что это кусок памяти.

939
00:41:15,500 --> 00:41:20,460
Сейчас в мире компьютерных наук имеет вид отгорожена куски

940
00:41:20,460 --> 00:41:22,570
памяти, чтобы сделать разные вещи.

941
00:41:22,570 --> 00:41:25,930
Так, например, если это оперативной памяти компьютера - как это было предложено

942
00:41:25,930 --> 00:41:30,400
Прямоугольник там - Получается, что по соглашению, в верхней части вашей памяти, поэтому

943
00:41:30,400 --> 00:41:33,170
говорить, как правило, то, что называется текстовый сегмент.

944
00:41:33,170 --> 00:41:35,910
Те нулей и единиц, что вы собрали.

945
00:41:35,910 --> 00:41:39,040
Поэтому, когда мы смотрели под капотом на то, что a.out есть все

946
00:41:39,040 --> 00:41:40,360
нулей и единиц -

947
00:41:40,360 --> 00:41:44,000
При запуске программы, эти нули и единицы загружается с жесткого

948
00:41:44,000 --> 00:41:46,290
диск в то, что называется оперативной памяти.

949
00:41:46,290 --> 00:41:48,950
И в памяти, они помещаются в верхней части.

950
00:41:48,950 --> 00:41:50,330
Теперь Тем временем, у вас есть другие вещи.

951
00:41:50,330 --> 00:41:53,060
Инициализированных данных, неинициализированных данных.

952
00:41:53,060 --> 00:41:56,440
Эти два валка памяти обратитесь к глобальные переменные, которые

953
00:41:56,440 --> 00:41:57,530
вы не часто используете.

954
00:41:57,530 --> 00:42:00,630
Но иногда, если вы это сделаете, они в конечном итоге там также.

955
00:42:00,630 --> 00:42:01,620
Тогда есть некоторые другие вещи.

956
00:42:01,620 --> 00:42:04,130
Переменные среды, которые мы не будем тратить много времени на.

957
00:42:04,130 --> 00:42:06,120
Но затем две важные вещи, которые будут возвращаться на протяжении всего этого

958
00:42:06,120 --> 00:42:08,130
семестра, стека и кучи.

959
00:42:08,130 --> 00:42:12,280
>> Поэтому большинство из памяти компьютера сохраняется при запуске программы

960
00:42:12,280 --> 00:42:14,880
то, что называется стеком и то, что называется кучей.

961
00:42:14,880 --> 00:42:16,940
И мы не собираемся говорить о куче сегодня, но мы будем

962
00:42:16,940 --> 00:42:18,180
говорить о стеке.

963
00:42:18,180 --> 00:42:22,910
И стека предназначена вызвать в воображении визуальные подобных столовой

964
00:42:22,910 --> 00:42:26,120
еду в лотках Mather дом, или там, где вы будете, где

965
00:42:26,120 --> 00:42:27,810
Персонал столовой чистить их каждый день.

966
00:42:27,810 --> 00:42:30,180
Они складываются их от пола вверх.

967
00:42:30,180 --> 00:42:33,800
И точно так же в памяти, есть такая идея поставить что-то на

968
00:42:33,800 --> 00:42:36,740
стек, поставив что-то на стеке, положить что-то в стеке.

969
00:42:36,740 --> 00:42:38,000
И что же мы подразумеваем под этим?

970
00:42:38,000 --> 00:42:41,430
Ну, давайте увеличить только на нижнюю половину этой картины, вашего компьютера

971
00:42:41,430 --> 00:42:43,990
RAM, предложить следующее.

972
00:42:43,990 --> 00:42:48,300
Оказывается, что когда вы запускаете программу, как a.out или привет, независимо от

973
00:42:48,300 --> 00:42:49,920
Программа является то, что вы написали,

974
00:42:49,920 --> 00:42:53,030
Опять же, те нулей и единиц загружается с жесткого диска - который является

975
00:42:53,030 --> 00:42:56,190
длительного хранения, остается там, даже когда вы вилку -

976
00:42:56,190 --> 00:42:57,220
загружаются в оперативную память.

977
00:42:57,220 --> 00:42:59,020
RAM быстрее, чем жесткие диски.

978
00:42:59,020 --> 00:43:00,700
Это меньше, чем жесткие диски.

979
00:43:00,700 --> 00:43:03,490
Но это там, где программы жить, пока вы работаете них.

980
00:43:03,490 --> 00:43:06,380
>> Таким образом, вы дважды щелкните программу на Mac или ПК - она ​​загружается из

981
00:43:06,380 --> 00:43:07,750
жесткого диска в оперативную память.

982
00:43:07,750 --> 00:43:11,760
Как только он будет загружен в оперативную память, нулей и единиц пойти на то, как сверху,

983
00:43:11,760 --> 00:43:13,130
так называемый текстовый сегмент.

984
00:43:13,130 --> 00:43:17,040
Но тогда, как только ваша программа фактически начинает работать, основная

985
00:43:17,040 --> 00:43:18,140
Функция называется.

986
00:43:18,140 --> 00:43:21,070
А главное, как мы видели, часто имеет локальные переменные.

987
00:43:21,070 --> 00:43:24,560
И она имеет целых и строк и символов и тому подобное.

988
00:43:24,560 --> 00:43:28,300
Так что если ваши программы, которые вы написали или программы, которые у вас есть

989
00:43:28,300 --> 00:43:33,680
двойном щелчке использовать некоторые переменные внутри основного, они в конечном итоге на

990
00:43:33,680 --> 00:43:37,020
нижней части стека памяти, так сказать.

991
00:43:37,020 --> 00:43:39,160
Теперь более конкретно, что же это на самом деле означает?

992
00:43:39,160 --> 00:43:44,080
Это просто означает, что если мы будем нумеровать вещи -

993
00:43:44,080 --> 00:43:49,380
если мы собираемся число байт оперативной памяти на компьютере, заметили, что

994
00:43:49,380 --> 00:43:51,650
это может быть нулевым байтом числа.

995
00:43:51,650 --> 00:43:56,130
Это может быть байтом номер один, два, три, четыре, пять, шесть, все

996
00:43:56,130 --> 00:43:57,290
вплоть до нравится -

997
00:43:57,290 --> 00:44:01,520
2 млрд будет всю дорогу там на самом верху.

998
00:44:01,520 --> 00:44:05,960
Итак, другими словами, когда мы говорим об оперативной памяти или памяти в байтах, он

999
00:44:05,960 --> 00:44:09,680
просто означает, что кто-то решил, что номер каждого из

1000
00:44:09,680 --> 00:44:11,110
эти куски памяти.

1001
00:44:11,110 --> 00:44:16,950
>> Поэтому, когда вам нужно 32 бита для Int, или вам нужно 8 бит на символ, где

1002
00:44:16,950 --> 00:44:18,320
они в конечном итоге в памяти?

1003
00:44:18,320 --> 00:44:20,650
Ну концептуально, они просто в конечном итоге в нижней части этого

1004
00:44:20,650 --> 00:44:21,780
то, что называется стек.

1005
00:44:21,780 --> 00:44:25,670
Но что интересно теперь, когда основные вызывает функцию.

1006
00:44:25,670 --> 00:44:28,830
Пусть функция называется Фу, просто произвольное имя.

1007
00:44:28,830 --> 00:44:32,480
Что происходит, является основным находится в нижней части этого стека памяти.

1008
00:44:32,480 --> 00:44:35,630
Foo теперь помещается в верхней части главного в памяти.

1009
00:44:35,630 --> 00:44:40,020
Таким образом, любые локальные переменные, Foo была в конечном итоге рода концептуально выше

1010
00:44:40,020 --> 00:44:40,770
те, в основном.

1011
00:44:40,770 --> 00:44:46,920
Если Foo вызывает другую функцию под названием бара, эти переменные в конечном итоге здесь.

1012
00:44:46,920 --> 00:44:49,790
Если баре называет что-то еще, здесь, здесь, здесь.

1013
00:44:49,790 --> 00:44:53,900
Так что же интересного о запуске программы является то, что вы называете функций,

1014
00:44:53,900 --> 00:44:57,720
и как эти функции вызывать функции, а также функции, которые вызывают функции,

1015
00:44:57,720 --> 00:45:00,980
Вы создаете этот стек функций в памяти.

1016
00:45:00,980 --> 00:45:06,740
И только один раз функция возвращает вы начнете получать эту память обратно.

1017
00:45:06,740 --> 00:45:11,190
Таким образом, одним из самых простых способов запустить из памяти в компьютере программы является

1018
00:45:11,190 --> 00:45:14,170
написать функции, которые никогда не вернутся.

1019
00:45:14,170 --> 00:45:16,650
>> Так, например, давайте продемонстрировать, как много с

1020
00:45:16,650 --> 00:45:18,460
умышленно ошибки программы.

1021
00:45:18,460 --> 00:45:24,690
Позвольте мне идти вперед и делать # включить <stdio.h>, Int основных (недействительными).

1022
00:45:24,690 --> 00:45:31,270
И я собираюсь делать, а (2> 1), который, вероятно, никогда не будет

1023
00:45:31,270 --> 00:45:33,370
изменится на нас.

1024
00:45:33,370 --> 00:45:37,720
И позвольте мне теперь идти вперед и делать Printf.

1025
00:45:37,720 --> 00:45:39,950
На самом деле, это будет менее визуально интересным.

1026
00:45:39,950 --> 00:45:40,460
Давайте сделаем это.

1027
00:45:40,460 --> 00:45:44,840
Для Int (я = 0; I> 0).

1028
00:45:44,840 --> 00:45:49,740
Давайте сделаем эту ошибку, я + +.

1029
00:45:49,740 --> 00:45:51,150
И давайте не Printf здесь.

1030
00:45:51,150 --> 00:45:52,550
Давайте практиковать то, что я проповедовал.

1031
00:45:52,550 --> 00:45:54,090
Давайте метод здесь.

1032
00:45:54,090 --> 00:46:00,860
Пустота хор, и мы будем говорить Int я.

1033
00:46:00,860 --> 00:46:02,295
А потом я собираюсь сказать, Printf -

1034
00:46:04,871 --> 00:46:06,790
ой, давайте сделаем это более интересно.

1035
00:46:06,790 --> 00:46:08,350
Давайте на самом деле не печатает вообще ничего.

1036
00:46:08,350 --> 00:46:10,530
Давайте просто это сделать.

1037
00:46:10,530 --> 00:46:11,780
Хор (I).

1038
00:46:16,630 --> 00:46:17,000
>> Хорошо.

1039
00:46:17,000 --> 00:46:20,040
Так что это багги, потому что зачем?

1040
00:46:20,040 --> 00:46:22,850
Я придумываю, как я иду, потому что программа не делает ничего

1041
00:46:22,850 --> 00:46:23,420
интерес.

1042
00:46:23,420 --> 00:46:24,670
Но это не цель.

1043
00:46:24,670 --> 00:46:30,440
Цель состоит в том, чтобы написать программу, основной функцией которого делает то, что, по-видимому?

1044
00:46:30,440 --> 00:46:31,370
Позвоните себя.

1045
00:46:31,370 --> 00:46:32,600
А на самом деле, мы не нуждаемся в петлю.

1046
00:46:32,600 --> 00:46:36,070
Давайте даже упростить этот раз, чтобы не терять из виду на самом деле

1047
00:46:36,070 --> 00:46:37,310
фундаментальную ошибку.

1048
00:46:37,310 --> 00:46:39,200
Главные вызовы хором петь хором.

1049
00:46:39,200 --> 00:46:41,760
Тогда я сделал глупость, и я должен был хор хор вызов, потому что я предполагал,

1050
00:46:41,760 --> 00:46:43,550
кто-то еще собирается реализовать это возможно.

1051
00:46:43,550 --> 00:46:45,960
И теперь это не будет собрать еще.

1052
00:46:45,960 --> 00:46:48,340
Мне нужно сделать что?

1053
00:46:48,340 --> 00:46:49,700
Мне нужно прототип, помню.

1054
00:46:49,700 --> 00:46:55,520
Поэтому мне нужно, чтобы здесь пустота хора (INT я);.

1055
00:46:55,520 --> 00:46:57,470
>> Так что теперь, если я иду сюда -

1056
00:46:57,470 --> 00:46:59,030
на самом деле, давайте использовать большие окна.

1057
00:46:59,030 --> 00:47:01,670
Давайте пойдем дальше и сделать хором.

1058
00:47:01,670 --> 00:47:06,000
Давайте пойдем дальше и сделать хором.

1059
00:47:06,000 --> 00:47:08,302
Использование неизвестные разыгрывающий я.

1060
00:47:08,302 --> 00:47:09,860
О, это было глупо.

1061
00:47:09,860 --> 00:47:11,020
Нам не нужны аргументы.

1062
00:47:11,020 --> 00:47:13,680
Давайте просто это сделать.

1063
00:47:13,680 --> 00:47:14,550
Жаль, что мы начали этот путь.

1064
00:47:14,550 --> 00:47:16,160
Было бы гораздо проще написать программу.

1065
00:47:16,160 --> 00:47:20,100
Так и тут.

1066
00:47:20,100 --> 00:47:23,870
Теперь давайте перейдем к моим окно терминала, повторные Clang.

1067
00:47:23,870 --> 00:47:26,900
И здесь мы идем.

1068
00:47:26,900 --> 00:47:28,020
Это было действительно быстро.

1069
00:47:28,020 --> 00:47:30,690
Что на самом деле только что произошло, правда?

1070
00:47:30,690 --> 00:47:33,430
Ну, теперь я добавлю печати линии, так что мы можем видеть.

1071
00:47:33,430 --> 00:47:41,330
Итак, позвольте мне сказать Printf, скажем так, я здесь.

1072
00:47:41,330 --> 00:47:43,470
Ладно, не переменные, мы оставим это так.

1073
00:47:43,470 --> 00:47:44,860
Позвольте мне снова запустить сделать.

1074
00:47:44,860 --> 00:47:47,940
Позвольте мне повтор припева.

1075
00:47:47,940 --> 00:47:51,235
И давай.

1076
00:47:53,880 --> 00:47:55,130
Продолжайте.

1077
00:47:57,630 --> 00:47:59,750
Как в стороне, почему она не потерпела крах?

1078
00:47:59,750 --> 00:48:02,050
Ошибки сегментации произошло супер быстрый раньше.

1079
00:48:02,050 --> 00:48:04,250
[Неразборчиво]

1080
00:48:04,250 --> 00:48:04,830
David J. Малан: Совершенно верно.

1081
00:48:04,830 --> 00:48:06,350
Так что это занимает время, чтобы напечатать.

1082
00:48:06,350 --> 00:48:08,370
Это займет больше работы со стороны компьютера.

1083
00:48:08,370 --> 00:48:09,550
И это так.

1084
00:48:09,550 --> 00:48:10,620
Сегментация вина.

1085
00:48:10,620 --> 00:48:12,140
>> Так заметите, как быстро запускать программы.

1086
00:48:12,140 --> 00:48:14,110
Если вы не печатает ничего, супер быстро.

1087
00:48:14,110 --> 00:48:18,100
Но мы все же получили эту ошибку сегментации, потому что то, что происходит?

1088
00:48:18,100 --> 00:48:21,310
Ну, если вы думаете о том, как память компьютера выложено, это

1089
00:48:21,310 --> 00:48:22,890
бывает основным.

1090
00:48:22,890 --> 00:48:23,800
Но здесь -

1091
00:48:23,800 --> 00:48:28,670
Давайте просто называть этот хор, и назовем этот хор.

1092
00:48:28,670 --> 00:48:33,420
И теперь, если я делаю свою эстетику права, это как раз собирался сказать хором,

1093
00:48:33,420 --> 00:48:38,060
хор, хор, хор, хор, хор, хор, до тошноты.

1094
00:48:38,060 --> 00:48:39,920
И в конце концов, что же будет дальше?

1095
00:48:39,920 --> 00:48:46,690
Если картина буквально это то, что просто происходит концептуально?

1096
00:48:46,690 --> 00:48:48,320
Стек перерасход кучи.

1097
00:48:48,320 --> 00:48:52,400
Или, того хуже, вы просто захвачены все, включая текстовый сегмент, который является

1098
00:48:52,400 --> 00:48:54,530
нулей и единиц, которые представляют вашу программу.

1099
00:48:54,530 --> 00:48:56,690
Короче говоря, это просто супер, супер плохого.

1100
00:48:56,690 --> 00:48:56,860
Верно?

1101
00:48:56,860 --> 00:48:58,620
Ваша программа вышла из-под контроля.

1102
00:48:58,620 --> 00:49:02,840
Вы используете способ больше памяти, чем вы рассчитывали все из-за глупой

1103
00:49:02,840 --> 00:49:03,920
ошибка, в этом случае.

1104
00:49:03,920 --> 00:49:08,160
Или в данном случае, совершенно сознательно сделали функцию, называющая себя.

1105
00:49:08,160 --> 00:49:09,210
Теперь это не так уж плохо.

1106
00:49:09,210 --> 00:49:12,540
Функции, называющих себя действительно имеет большую силу

1107
00:49:12,540 --> 00:49:13,700
когда вы используете его правильно.

1108
00:49:13,700 --> 00:49:15,650
Я не использовал его правильно здесь.

1109
00:49:15,650 --> 00:49:16,940
>> Так что не все так плохо.

1110
00:49:16,940 --> 00:49:20,620
Но то, что я никогда не перестанут называть себя является фундаментальным

1111
00:49:20,620 --> 00:49:23,050
Слабость здесь этой программы.

1112
00:49:23,050 --> 00:49:25,090
Так куда мы идем со всем этим?

1113
00:49:25,090 --> 00:49:26,230
Ну, а что происходит на самом деле?

1114
00:49:26,230 --> 00:49:30,010
Когда я называю приращение функции, как мы делали в тех примерах,

1115
00:49:30,010 --> 00:49:33,290
У меня есть значение, как 1, что я прохожу дюйма

1116
00:49:33,290 --> 00:49:35,820
Я прохожу в копию номер один.

1117
00:49:35,820 --> 00:49:37,080
Таким образом, происходит следующее.

1118
00:49:37,080 --> 00:49:40,390
Так что давайте идти в шаг пример.

1119
00:49:40,390 --> 00:49:44,230
И этот парень прямо здесь.

1120
00:49:44,230 --> 00:49:46,800
Итак, вот что на самом деле происходит.

1121
00:49:46,800 --> 00:49:50,770
Когда я позвонил прирост, и я прохожу по х, наглядно то, что

1122
00:49:50,770 --> 00:49:53,660
происходит здесь, это -

1123
00:49:53,660 --> 00:50:00,240
если у меня есть стоимость 1 хранится здесь, и я на самом деле зовут прирост, который

1124
00:50:00,240 --> 00:50:02,680
теперь называется хор -

1125
00:50:02,680 --> 00:50:04,010
Да, бросив меня здесь.

1126
00:50:04,010 --> 00:50:06,750
Итак, давайте называть это приращение.

1127
00:50:06,750 --> 00:50:09,420
И мы не знаем, что это следующая функция собирается быть.

1128
00:50:09,420 --> 00:50:14,270
Так что же на самом деле происходит где-то здесь в основном, у меня есть кусок

1129
00:50:14,270 --> 00:50:16,670
памяти, которая хранит номер 1.

1130
00:50:16,670 --> 00:50:19,730
Когда я называю прирост, я использую другую часть памяти, но теперь я

1131
00:50:19,730 --> 00:50:20,840
есть копия 1.

1132
00:50:20,840 --> 00:50:25,480
Когда я увеличить это значение, это становится 2 - ужасно написанных на

1133
00:50:25,480 --> 00:50:26,420
Экран здесь.

1134
00:50:26,420 --> 00:50:30,550
Но то, что происходит, как только прирост прибыли?

1135
00:50:30,550 --> 00:50:34,610
Эта память просто получает вернул к операционной системе, которая означает, что все

1136
00:50:34,610 --> 00:50:37,470
Вы сделали ничего полезного.

1137
00:50:37,470 --> 00:50:43,460
Тот, который был первоначально содержащейся в основной по-прежнему на самом деле.

1138
00:50:43,460 --> 00:50:44,650
>> Так куда мы идем с этим?

1139
00:50:44,650 --> 00:50:49,400
Ну, получается, что в памяти у вас есть эта спина к спине последовательность

1140
00:50:49,400 --> 00:50:50,940
байтов, которые Вы можете положить вещи дюйма

1141
00:50:50,940 --> 00:50:53,760
И получается, что мы уже видели нечто, что включает в себя положив

1142
00:50:53,760 --> 00:50:55,100
вещей спина к спине, чтобы спина к спине.

1143
00:50:55,100 --> 00:51:00,170
Что представляет собой строку, основанные на неделю одну, то недели две?

1144
00:51:00,170 --> 00:51:01,840
Так что это просто набор символов.

1145
00:51:01,840 --> 00:51:05,290
Вот и получается, как вы можете положить номеров в памяти, так же вы можете

1146
00:51:05,290 --> 00:51:06,900
положить символов в памяти.

1147
00:51:06,900 --> 00:51:09,810
И как только мы начинаем положить символов в памяти спиной к спине, чтобы вернуться к

1148
00:51:09,810 --> 00:51:12,800
назад, то получается, что с помощью простейших вещах, как цикл или

1149
00:51:12,800 --> 00:51:14,510
время цикла, мы можем повторять -

1150
00:51:14,510 --> 00:51:17,130
слева направо по символов в строке -

1151
00:51:17,130 --> 00:51:20,720
и начать массируя их в разные персонажи в целом.

1152
00:51:20,720 --> 00:51:25,550
Может стать B. B может стать C. Так что в конечном итоге, мы можем взять

1153
00:51:25,550 --> 00:51:28,830
Английский предложение, которое действительно имеет смысл и преобразует каждый из этих

1154
00:51:28,830 --> 00:51:32,440
буквы по одной за раз, идя через нашу память компьютера остается

1155
00:51:32,440 --> 00:51:34,300
Право на самом деле шифрования.

1156
00:51:34,300 --> 00:51:36,590
>> Итак, давайте сделаем наш пятиминутный перерыв здесь, и когда мы вернемся, мы будем

1157
00:51:36,590 --> 00:51:39,060
начать этот процесс скремблирования информации.

1158
00:51:41,640 --> 00:51:43,180
>> Хорошо.

1159
00:51:43,180 --> 00:51:48,440
Поэтому, прежде чем погрузиться в некоторых крипто и эти вещи называются массивами, позвольте мне

1160
00:51:48,440 --> 00:51:51,610
Пауза на любые вопросы, потому что я чувствую, что я действительно отчасти запутанной некоторые из

1161
00:51:51,610 --> 00:51:52,230
эти темы.

1162
00:51:52,230 --> 00:51:53,940
Так что давайте зафиксируем теперь, если мы можем.

1163
00:51:53,940 --> 00:51:56,480
Таким образом, мы только что говорили о возвращении ценностей.

1164
00:51:56,480 --> 00:51:58,630
Мы говорили о аргументов.

1165
00:51:58,630 --> 00:52:02,330
И мы говорили об этом понятии, которое мы вернемся в ближайшие недели

1166
00:52:02,330 --> 00:52:07,140
пришел, просмотра памяти целую кучу этих стеками

1167
00:52:07,140 --> 00:52:08,540
Лотки, так сказать.

1168
00:52:08,540 --> 00:52:13,460
Снизу на вверх, так, что каждый лоток, который получает положить в стек представляет

1169
00:52:13,460 --> 00:52:15,160
функция, которая в настоящее время называется.

1170
00:52:17,970 --> 00:52:20,300
Есть вопросы?

1171
00:52:20,300 --> 00:52:22,890
Так как о - дайте мне попробовать задать вопрос.

1172
00:52:22,890 --> 00:52:25,520
Я все портит, но теперь it's - you've все видели лицо мальчика.

1173
00:52:25,520 --> 00:52:27,020
Таким образом, мы вернемся к этому.

1174
00:52:27,020 --> 00:52:29,700
>> Итак, позвольте мне задать вопрос здесь.

1175
00:52:29,700 --> 00:52:34,810
Позвольте мне упростить это к тому, что было до некоторых из наших ранних Q & A.

1176
00:52:34,810 --> 00:52:41,730
И тот факт, что прирост имеет открытую скобку, внутр номер, закрытый

1177
00:52:41,730 --> 00:52:42,260
скобках.

1178
00:52:42,260 --> 00:52:46,370
Что Int числа представляют?

1179
00:52:46,370 --> 00:52:47,250
[Неразборчиво]

1180
00:52:47,250 --> 00:52:47,870
David J. Малан: аргумент.

1181
00:52:47,870 --> 00:52:50,732
Хорошо, но что это аргумент?

1182
00:52:50,732 --> 00:52:51,620
[Неразборчиво]

1183
00:52:51,620 --> 00:52:52,500
David J. Малан: Извините, что это такое?

1184
00:52:52,500 --> 00:52:53,150
Выступающий 3: Что-то вы передаете дюйма

1185
00:52:53,150 --> 00:52:53,570
David J. Малан: Хорошо.

1186
00:52:53,570 --> 00:52:54,780
Таким образом, то, что вы передаете дюйма

1187
00:52:54,780 --> 00:52:56,560
И вообще, это просто вход.

1188
00:52:56,560 --> 00:52:59,860
Если вы пишете функции и цели, функции в жизни, чтобы сделать

1189
00:52:59,860 --> 00:53:03,290
что-то немного иначе каждый раз, когда вы используете его, то единственным способом для

1190
00:53:03,290 --> 00:53:07,710
Чтобы это произошло на самом деле, казалось бы предоставить ему вход так, чтобы она

1191
00:53:07,710 --> 00:53:10,180
может сделать что-то другое с помощью этого вклада каждый раз.

1192
00:53:10,180 --> 00:53:13,590
>> Таким образом, вы должны определить две вещи, когда функция принимает входы.

1193
00:53:13,590 --> 00:53:17,240
Вы должны указать имя, которое вы хотите дать, что вход только для

1194
00:53:17,240 --> 00:53:20,790
вашего удобства, чтобы вы могли ссылаться на него в функцию, которую

1195
00:53:20,790 --> 00:53:23,610
сами пишете, как я сделал здесь, в строке 32.

1196
00:53:23,610 --> 00:53:27,840
Но вы также должны указать его тип, потому что C является языком программирования

1197
00:53:27,840 --> 00:53:28,840
что именно требуется

1198
00:53:28,840 --> 00:53:31,810
что если вы хотите переменной, вы должны сообщить компьютеру, что

1199
00:53:31,810 --> 00:53:32,790
тип данных, это,

1200
00:53:32,790 --> 00:53:35,540
В большей части так, чтобы он не знает, сколько бит

1201
00:53:35,540 --> 00:53:37,230
выделить для этой переменной.

1202
00:53:37,230 --> 00:53:38,600
Потому что это может быть шесть -

1203
00:53:38,600 --> 00:53:39,990
Извините, это не будет шесть.

1204
00:53:39,990 --> 00:53:41,050
Это может быть 16.

1205
00:53:41,050 --> 00:53:41,630
Это может быть 8.

1206
00:53:41,630 --> 00:53:44,410
Это может быть 32, даже 64.

1207
00:53:44,410 --> 00:53:45,820
Но компьютер должен знать.

1208
00:53:45,820 --> 00:53:49,110
Теперь Int на левую сторону представляет то, что, в отличие от?

1209
00:53:52,825 --> 00:53:53,780
[Неразборчиво]

1210
00:53:53,780 --> 00:53:54,570
David J. Малан: Что это?

1211
00:53:54,570 --> 00:53:55,390
[Неразборчиво]

1212
00:53:55,390 --> 00:53:57,920
David J. Малан: тип функции и, более конкретно,

1213
00:53:57,920 --> 00:53:59,755
Тип выпускаемой продукции.

1214
00:53:59,755 --> 00:54:00,220
Право.

1215
00:54:00,220 --> 00:54:04,220
Таким образом, в то время как вещь в скобках представляет свой вход, если таковые имеются,

1216
00:54:04,220 --> 00:54:06,640
вещь, чтобы левая представляет свою продукцию.

1217
00:54:06,640 --> 00:54:10,560
И в этом случае, по-видимому прирост возвращает целое.

1218
00:54:10,560 --> 00:54:14,590
И так Int является тип возвращаемого этой функцией.

1219
00:54:14,590 --> 00:54:16,090
>> Что это значит вернуть?

1220
00:54:16,090 --> 00:54:19,810
Буквально, вы используете ключевое слово возвращения.

1221
00:54:19,810 --> 00:54:24,640
И потом, если то, что вы возвращаетесь в правом ключевое слово

1222
00:54:24,640 --> 00:54:28,340
число, то, что действительно соответствует тому, что мы обещали.

1223
00:54:28,340 --> 00:54:31,110
Вы не могли бы сделать что-то вроде этого -

1224
00:54:31,110 --> 00:54:32,280
Привет, мир -

1225
00:54:32,280 --> 00:54:33,500
потому что это строка.

1226
00:54:33,500 --> 00:54:35,440
Очевидно, это не является целым числом.

1227
00:54:35,440 --> 00:54:40,450
Короче говоря, бремя на самом деле на нас, программистов, чтобы быть конкретным, как

1228
00:54:40,450 --> 00:54:44,730
к тому, что мы возвращаемся, и тогда на самом деле идти о возвращении его.

1229
00:54:44,730 --> 00:54:49,030
И тогда, чтобы сделать немного более четкие контексте -

1230
00:54:49,030 --> 00:54:50,080
Вот он снова.

1231
00:54:50,080 --> 00:54:51,060
Контекста -

1232
00:54:51,060 --> 00:54:52,830
Большим сюрпризом в ближайшие одну минуту.

1233
00:54:52,830 --> 00:54:57,720
Контекст здесь, сейчас, в том, что память компьютера, опять же,

1234
00:54:57,720 --> 00:54:59,070
гигабайт, два гигабайта, что угодно.

1235
00:54:59,070 --> 00:54:59,630
Может быть, это другое.

1236
00:54:59,630 --> 00:55:00,540
Может быть, это меньше.

1237
00:55:00,540 --> 00:55:03,750
Но компьютер рассматривает ее как имеющие различные разделы.

1238
00:55:03,750 --> 00:55:04,860
Что-то идет туда.

1239
00:55:04,860 --> 00:55:06,020
Что-то еще происходит там.

1240
00:55:06,020 --> 00:55:07,540
Разные вещи идет в середине.

1241
00:55:07,540 --> 00:55:09,300
И сегодня, мы просто начинаем рассказываю эту историю.

1242
00:55:09,300 --> 00:55:11,130
>> Но мы вернемся к этому с течением времени.

1243
00:55:11,130 --> 00:55:15,000
В настоящее время, только кусок памяти мы действительно заботимся о том, текстовый сегмент

1244
00:55:15,000 --> 00:55:17,160
потому что только что представляет нулей и единиц

1245
00:55:17,160 --> 00:55:18,460
Clang, что был сигнал.

1246
00:55:18,460 --> 00:55:21,570
Итак, когда вы запустите команду на клавиатуре, как a.out, или вы дважды

1247
00:55:21,570 --> 00:55:25,350
щелкните по значку на Mac OS или Windows, ваши программы загружается с жесткого

1248
00:55:25,350 --> 00:55:26,930
диска в оперативную память.

1249
00:55:26,930 --> 00:55:30,850
И она шлепнулась в верхней части оперативной памяти компьютера, так сказать.

1250
00:55:30,850 --> 00:55:35,470
Теперь Между тем, как ваша программа начинает работать и основные вызывается в

1251
00:55:35,470 --> 00:55:39,240
Вы писали программы или программы Microsoft или Apple, пишет, любого из ее

1252
00:55:39,240 --> 00:55:42,930
локальные переменные в конечном итоге там на дне памяти компьютера.

1253
00:55:42,930 --> 00:55:46,490
Но если основная вызывает другую функцию, которая сама по себе имеет переменные или

1254
00:55:46,490 --> 00:55:48,340
аргументами, они в конечном итоге над ним.

1255
00:55:48,340 --> 00:55:50,670
И если эта функция вызывает то, что они в конечном итоге над ним,

1256
00:55:50,670 --> 00:55:51,840
над ним, над ним.

1257
00:55:51,840 --> 00:55:56,100
И только один раз в функции осуществляется выполнение делает стопки лотков, так

1258
00:55:56,100 --> 00:55:58,320
говорить, начинают получать все ниже и ниже.

1259
00:55:58,320 --> 00:56:03,370
И это то, что тогда, в двух словах, объясняет, почему, когда вы звоните куба -

1260
00:56:03,370 --> 00:56:04,660
или вы звоните прирост -

1261
00:56:04,660 --> 00:56:06,490
вы передаете копию значения.

1262
00:56:06,490 --> 00:56:09,840
А что это означает, что наглядно это то, что вы буквально написания

1263
00:56:09,840 --> 00:56:14,540
номер 1 в другую часть памяти, которая меняется от 1 до 2, в случае

1264
00:56:14,540 --> 00:56:15,360
прирост -

1265
00:56:15,360 --> 00:56:17,450
или 8, в случае куба -

1266
00:56:17,450 --> 00:56:21,450
, а затем бросали, что память далеко, как только увеличение или кубе

1267
00:56:21,450 --> 00:56:23,410
Функция возвращает.

1268
00:56:23,410 --> 00:56:24,267
>> Вопрос.

1269
00:56:24,267 --> 00:56:25,517
[Неразборчиво]

1270
00:56:28,090 --> 00:56:29,970
David J. Малан: где - глобальные переменные хранятся в то, что

1271
00:56:29,970 --> 00:56:32,960
в настоящее время называется инициализируются данные или неинициализированных данных.

1272
00:56:32,960 --> 00:56:35,900
Разница в том, если у вас есть глобальная переменная, и вы назначаете его

1273
00:56:35,900 --> 00:56:39,530
сразу же значение с знака равенства, она заканчивается на вершине.

1274
00:56:39,530 --> 00:56:43,390
А если просто сказать Int х запятой без значения, это заканчивается немного

1275
00:56:43,390 --> 00:56:46,670
ниже в памяти просто конвенции.

1276
00:56:46,670 --> 00:56:49,308
Другие вопросы.

1277
00:56:49,308 --> 00:56:49,750
Хорошо.

1278
00:56:49,750 --> 00:56:53,040
>> Таким образом, эта картина будет возвращаться, как мы получим более мощный с тем, что мы можем сделать

1279
00:56:53,040 --> 00:56:53,830
с компьютером.

1280
00:56:53,830 --> 00:56:58,790
Но сейчас, давайте краткое введение в криптографию, специфический тип

1281
00:56:58,790 --> 00:57:01,910
криптографии, что не решает всех проблем в мире, но никак решить

1282
00:57:01,910 --> 00:57:02,480
некоторые из них.

1283
00:57:02,480 --> 00:57:06,090
В этом случае здесь, у нас есть то, что называется секретным ключом шифрования.

1284
00:57:06,090 --> 00:57:10,430
И секрет криптографии ключ, как следует из названия, происходит ее безопасности

1285
00:57:10,430 --> 00:57:11,330
от тайной.

1286
00:57:11,330 --> 00:57:14,720
Так, например, если вы еще в начальной школе, и вы передаете

1287
00:57:14,720 --> 00:57:18,040
Маленький секрет любовное письмо к мальчику или девочке вы дробления на - если вы

1288
00:57:18,040 --> 00:57:20,820
хотел передать, что через аудиторией, вы, вероятно, не будет писать

1289
00:57:20,820 --> 00:57:24,120
такая записка на английском языке или что ваш родной язык, а, скорее, вы

1290
00:57:24,120 --> 00:57:25,800
может зашифровать его.

1291
00:57:25,800 --> 00:57:27,820
Или вы можете просто отправить им текстовое сообщение в эти дни.

1292
00:57:27,820 --> 00:57:30,310
Но вы могли бы на самом деле передают их к сведению всем классе.

1293
00:57:30,310 --> 00:57:33,820
И сделать это безопасно, так что ваши друзья и учителя

1294
00:57:33,820 --> 00:57:36,820
Не знаю, что вы пишете, вы можете придумать достаточно простой

1295
00:57:36,820 --> 00:57:37,800
Алгоритм -

1296
00:57:37,800 --> 00:57:39,290
Молодой хотя вы могли бы быть -

1297
00:57:39,290 --> 00:57:40,780
просто карабкаться слова.

1298
00:57:40,780 --> 00:57:44,390
Таким образом, вместо того чтобы писать, вы можете написать B. Вместо B, вы можете написать

1299
00:57:44,390 --> 00:57:46,670
C. Вместо C, вы можете написать D, и так далее.

1300
00:57:46,670 --> 00:57:50,020
Или вы могли бы придумать более сложный перевод писем

1301
00:57:50,020 --> 00:57:51,300
различных букв.

1302
00:57:51,300 --> 00:57:55,440
Но загвоздка в том, мальчик или девочка, которым вы отправляете эту записку необходимо

1303
00:57:55,440 --> 00:57:56,850
что-то знать.

1304
00:57:56,850 --> 00:57:59,620
Какие это то, что, очевидно?

1305
00:57:59,620 --> 00:58:01,400
Как и то, что ваш секрет.

1306
00:58:01,400 --> 00:58:04,620
Мол, что это такое сопоставление Как и завтрак и Cs и Ds?

1307
00:58:04,620 --> 00:58:08,780
Это только добавив к нему один, так сказать, к каждой из букв, чтобы перейти от

1308
00:58:08,780 --> 00:58:09,730
А в B, B в C?

1309
00:58:09,730 --> 00:58:11,350
Это более сложный, чем это?

1310
00:58:11,350 --> 00:58:16,450
Таким образом, вы и ваш раздавить нужно, чтобы у этой секретной информации.

1311
00:58:16,450 --> 00:58:18,170
Но есть своего рода уловки-22 здесь.

1312
00:58:18,170 --> 00:58:20,760
Если это в первый раз вы отправляете эту любовь через письма

1313
00:58:20,760 --> 00:58:25,590
класса, как то, что мальчик или девочка будет знать, в чем секрет даже есть?

1314
00:58:25,590 --> 00:58:28,450
Так что секретный ключ шифрования не решает всех проблем в мире.

1315
00:58:28,450 --> 00:58:30,490
И там на самом деле отношения, которые мы вернемся к к

1316
00:58:30,490 --> 00:58:31,370
семестра конца.

1317
00:58:31,370 --> 00:58:35,970
>> Кроме того, есть ни один из нас, вероятно, никогда не послал -

1318
00:58:35,970 --> 00:58:39,453
Аналогично, большинство из нас не знает, что кто-то работает, например, на

1319
00:58:39,453 --> 00:58:40,300
Amazon.com.

1320
00:58:40,300 --> 00:58:43,130
И тем не менее, многие из нас, наверное, купил материал на Amazon.com.

1321
00:58:43,130 --> 00:58:45,670
И нас учили считать, что эти электронной коммерции

1322
00:58:45,670 --> 00:58:47,060
безопасность транзакций.

1323
00:58:47,060 --> 00:58:47,210
Верно?

1324
00:58:47,210 --> 00:58:49,310
URL, вероятно, говорит HTTPS.

1325
00:58:49,310 --> 00:58:51,590
Там в, может быть, глупый маленький значок замка где-то.

1326
00:58:51,590 --> 00:58:54,680
Там какая-то криптографии обеспечения вашей кредитной карты

1327
00:58:54,680 --> 00:58:56,980
между вами и Amazon.com.

1328
00:58:56,980 --> 00:59:00,410
И еще, если криптография включает в себя зная некоторые тайны, и все же я не

1329
00:59:00,410 --> 00:59:03,330
знаю никого, на Амазонке, и я, конечно, не устроил любой

1330
00:59:03,330 --> 00:59:07,350
тайну с кем-то на Amazon, как мой компьютер или мой браузер это делает?

1331
00:59:07,350 --> 00:59:10,100
Что ж, оказывается, есть другие виды криптографии в целом, которые решают

1332
00:59:10,100 --> 00:59:10,740
этой проблеме.

1333
00:59:10,740 --> 00:59:13,610
Но на сегодняшний день, мы сосредоточимся на простой, где вы можете устроить в

1334
00:59:13,610 --> 00:59:18,480
продвижение знать некоторые тайны, как плюс 1 или некоторое отображение между Как и завтрак.

1335
00:59:18,480 --> 00:59:20,710
>> И процесс криптографии обычно включает в себя это.

1336
00:59:20,710 --> 00:59:23,550
У вас есть обычный текст, изображенный здесь, на левом.

1337
00:59:23,550 --> 00:59:26,260
Вы запускаете его через какой-то алгоритм или процедура

1338
00:59:26,260 --> 00:59:27,670
для шифрования.

1339
00:59:27,670 --> 00:59:31,390
Может быть, это просто становится B, B становится C. И тогда вы в конечном итоге с

1340
00:59:31,390 --> 00:59:32,260
зашифрованный текст.

1341
00:59:32,260 --> 00:59:36,450
Между тем, как только ваш раздавить получает тайные записки, он или она должны затем

1342
00:59:36,450 --> 00:59:39,950
расшифровать его, как правило задним ходом, что алгоритм так, чтобы получить

1343
00:59:39,950 --> 00:59:41,640
Резервное простой текст.

1344
00:59:41,640 --> 00:59:43,860
Теперь есть физическое воплощение этого.

1345
00:59:43,860 --> 00:59:46,720
Например, это маленький секрет кольца декодер.

1346
00:59:46,720 --> 00:59:50,060
И это кольцо в том смысле, что есть два набора здесь.

1347
00:59:50,060 --> 00:59:53,630
На внешней периферии этой вещью, есть буквы от А до Z,

1348
00:59:53,630 --> 00:59:55,110
хотя они в случайном порядке.

1349
00:59:55,110 --> 00:59:58,410
И с внутренней стороны, там на самом деле некоторые числа, такие, что с этой

1350
00:59:58,410 --> 01:00:02,940
Кольцо, вы можете включить вид снаружи, но не внутри для того, чтобы выстроиться

1351
01:00:02,940 --> 01:00:04,110
Номера с буквами.

1352
01:00:04,110 --> 01:00:08,290
И в клипе вы собираетесь посмотреть - некоторые из которых вы, возможно, видели 24/7

1353
01:00:08,290 --> 01:00:11,120
вокруг рождественского сезона из фильма под названием Рождественская история.

1354
01:00:11,120 --> 01:00:16,050
Вы увидите, что мало Ральфи так не терпелось выяснить, что сиротка

1355
01:00:16,050 --> 01:00:19,810
Секретное сообщение Энни была для него, что было сообщено, я думаю, в

1356
01:00:19,810 --> 01:00:22,810
виде цифровых сообщений на серийный окно.

1357
01:00:22,810 --> 01:00:26,760
И надо было аккумулировать все маленькие карты, которые пришли

1358
01:00:26,760 --> 01:00:27,480
в коробки от хлопьев.

1359
01:00:27,480 --> 01:00:28,320
Нужно было, чтобы отправить их сюда

1360
01:00:28,320 --> 01:00:31,060
Вы должны были получить обратно тайну кольца декодер, так что вы можете, наконец, понять

1361
01:00:31,060 --> 01:00:34,190
, что отображение между буквами и цифрами,

1362
01:00:34,190 --> 01:00:35,420
или букв и букв.

1363
01:00:35,420 --> 01:00:39,790
Таким образом, я даю вам этот короткий клип из Рождественская история мотивировать PSET 2 и

1364
01:00:39,790 --> 01:00:42,340
наша дискуссия, в момент, массивов.

1365
01:00:42,340 --> 01:00:43,773
Таким образом, здесь мы имеем Ральфи.

1366
01:00:43,773 --> 01:00:44,126
>> [ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

1367
01:00:44,126 --> 01:00:47,470
-Да будет известно всем и каждому, что Ральф Паркер настоящим назначен

1368
01:00:47,470 --> 01:00:50,690
член маленький круг сирот Энни секретно и имеет право на все

1369
01:00:50,690 --> 01:00:53,500
почести и преимущества, происходящие с ними.

1370
01:00:53,500 --> 01:00:56,040
-Подпись, Little Orphan Annie.

1371
01:00:56,040 --> 01:00:58,730
Контрассигнуют, Пьер Андре!

1372
01:00:58,730 --> 01:01:00,150
В чернил!

1373
01:01:00,150 --> 01:01:02,910
Достижения и преимущества, уже в возрасте девяти лет.

1374
01:01:09,970 --> 01:01:10,730
Давай, давай покончим с этим.

1375
01:01:10,730 --> 01:01:15,000
Мне не нужны все такое прочее о контрабандистов и пиратов.

1376
01:01:15,000 --> 01:01:17,624
-Слушай завтра ночью для заключительных приключений The Black

1377
01:01:17,624 --> 01:01:19,710
Пиратский корабль.

1378
01:01:19,710 --> 01:01:23,380
Теперь пришло время для тайного сообщения Энни для вас членами

1379
01:01:23,380 --> 01:01:25,670
Тайного Круга.

1380
01:01:25,670 --> 01:01:30,260
Помните, что дети, только члены тайный кружок Энни может декодировать

1381
01:01:30,260 --> 01:01:31,660
Секрет Энни сообщении.

1382
01:01:31,660 --> 01:01:36,230
Помните, Энни зависит от вас.

1383
01:01:36,230 --> 01:01:38,720
Установить контакты с B2.

1384
01:01:38,720 --> 01:01:41,040
Вот сообщение.

1385
01:01:41,040 --> 01:01:42,470
12, 11 -

1386
01:01:42,470 --> 01:01:46,000
-Я в первом заседании тайным.

1387
01:01:46,000 --> 01:01:49,440
-14, 11, 18, 16 -

1388
01:01:49,440 --> 01:01:51,700
-Пьер был в отличной сегодня голос.

1389
01:01:51,700 --> 01:01:54,890
Я могу сказать, что сегодня сообщение было действительно важно.

1390
01:01:54,890 --> 01:01:56,750
-3, 25.

1391
01:01:56,750 --> 01:01:58,590
Вот сообщение от Annie себя.

1392
01:01:58,590 --> 01:01:59,840
Помните, никому не говорите.

1393
01:02:04,570 --> 01:02:08,750
-90 Секунд спустя, я в единственную комнату в доме, где девятилетний мальчик

1394
01:02:08,750 --> 01:02:12,980
мог сидеть в уединении и декодирования.

1395
01:02:12,980 --> 01:02:17,130
Ага, Б. Я пошел к другому.

1396
01:02:17,130 --> 01:02:20,330
E. Первое слово будет.

1397
01:02:20,330 --> 01:02:22,670
S. Он шел легче.

1398
01:02:22,670 --> 01:02:24,590
U.

1399
01:02:24,590 --> 01:02:26,510
-Ой, да ладно, Ральфи.

1400
01:02:26,510 --> 01:02:28,430
Я должен идти.

1401
01:02:28,430 --> 01:02:30,350
-Я спущусь, штат Массачусетс.

1402
01:02:30,350 --> 01:02:33,720
-Вот здорово.

1403
01:02:33,720 --> 01:02:38,270
-T, О. Обязательно.

1404
01:02:38,270 --> 01:02:40,000
Будьте уверены, к чему?

1405
01:02:40,000 --> 01:02:42,105
Что Little Orphan Annie пытаюсь сказать?

1406
01:02:42,105 --> 01:02:43,095
Будьте уверены, к чему?

1407
01:02:43,095 --> 01:02:43,590
-Ральфи!

1408
01:02:43,590 --> 01:02:44,580
Рэнди должен идти.

1409
01:02:44,580 --> 01:02:45,570
Не могли бы вы выйти?

1410
01:02:45,570 --> 01:02:46,560
-Все в порядке, мама.

1411
01:02:46,560 --> 01:02:48,540
Я сейчас выйду.

1412
01:02:48,540 --> 01:02:50,580
-Я получаю ближе.

1413
01:02:50,580 --> 01:02:52,550
Напряжение было ужасным.

1414
01:02:52,550 --> 01:02:53,355
Что это было?

1415
01:02:53,355 --> 01:02:56,315
Судьба планеты может повиснуть на волоске.

1416
01:02:56,315 --> 01:02:56,790
-Ральфи!

1417
01:02:56,790 --> 01:02:59,165
Рэнди должен уйти.

1418
01:02:59,165 --> 01:03:02,310
-Я бы сразу, с ума сойти.

1419
01:03:02,310 --> 01:03:04,000
-Ну и дела, почти нет.

1420
01:03:04,000 --> 01:03:05,180
Мои пальцы летали.

1421
01:03:05,180 --> 01:03:07,150
Мой разум был стальной капкан.

1422
01:03:07,150 --> 01:03:08,790
Каждый пор вибрации.

1423
01:03:08,790 --> 01:03:10,040
Это было почти ясно.

1424
01:03:10,040 --> 01:03:13,400
Да, да, да, да.

1425
01:03:13,400 --> 01:03:18,960
-Будьте уверены, чтобы пить Ovaltine.

1426
01:03:18,960 --> 01:03:20,210
Ovaltine?

1427
01:03:24,010 --> 01:03:25,260
Вшивой коммерческой?

1428
01:03:28,200 --> 01:03:29,640
Сын сука.

1429
01:03:29,640 --> 01:03:33,340
[END ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

1430
01:03:33,340 --> 01:03:36,040
>> David J. Малан: То есть у нас есть криптографии.

1431
01:03:36,040 --> 01:03:39,670
Так как в компьютере, мы можем идти о реализации или

1432
01:03:39,670 --> 01:03:40,950
представляющие такие вещи?

1433
01:03:40,950 --> 01:03:44,430
Что ж, нам нужен способ выразить себя немного более гибко, чем

1434
01:03:44,430 --> 01:03:46,420
наши переменные до сих пор позволил.

1435
01:03:46,420 --> 01:03:47,370
У нас были целые.

1436
01:03:47,370 --> 01:03:48,380
У нас были символы.

1437
01:03:48,380 --> 01:03:50,790
У нас были поплавки и двухместные и некоторые другие.

1438
01:03:50,790 --> 01:03:55,050
Но эти отдельные части памяти, которая на самом деле не позволяют нам

1439
01:03:55,050 --> 01:03:58,010
выразить вещи, как слова и предложения и фразы.

1440
01:03:58,010 --> 01:04:00,200
В самом деле, мы называли такие строки вещи.

1441
01:04:00,200 --> 01:04:03,650
Но мы обещали, что это действительно просто упрощение CS50

1442
01:04:03,650 --> 01:04:07,020
библиотеки, которые мы намерены отогните.

1443
01:04:07,020 --> 01:04:08,970
>> И так, давайте начнем делать это здесь.

1444
01:04:08,970 --> 01:04:11,130
Позвольте мне идти вперед и открывать файл -

1445
01:04:11,130 --> 01:04:13,770
Все эти файлы доступны как обычные онлайн -

1446
01:04:13,770 --> 01:04:19,120
называется array.c решить проблему не связанных с строки, но что рисует

1447
01:04:19,120 --> 01:04:23,040
Картина здесь о том, как мы могли бы использовать то, что называется массивом.

1448
01:04:23,040 --> 01:04:25,530
Массив представляет собой тип данных.

1449
01:04:25,530 --> 01:04:31,320
Это тип переменной, своего рода, который имеет несколько меньшие типы данных

1450
01:04:31,320 --> 01:04:34,150
внутри него спина к спине, чтобы спина к спине.

1451
01:04:34,150 --> 01:04:37,700
Так, например, если мы хотим написать небольшую программу, которая дает Вам

1452
01:04:37,700 --> 01:04:42,110
Тест среднем на курс, как 50, который имеет два викторины, вы можете очень легко

1453
01:04:42,110 --> 01:04:45,170
написать эту программу - на основе даже на некоторых из материала на прошлой неделе -

1454
01:04:45,170 --> 01:04:47,770
с помощью GetInt и несколько переменных.

1455
01:04:47,770 --> 01:04:51,920
Quiz1 Int, Int quiz2, и это довольно просто.

1456
01:04:51,920 --> 01:04:55,930
Это может быть 10, 20 строк кода, не более, реализовать программу, которая запрашивает

1457
01:04:55,930 --> 01:05:01,170
Пользователь в течение двух баллов викторины и затем вычисляет их среднее, добавив их

1458
01:05:01,170 --> 01:05:03,850
вместе, разделив на два, а затем печати результатов.

1459
01:05:03,850 --> 01:05:06,380
Мы могли бы сделать это довольно легко теперь, после

1460
01:05:06,380 --> 01:05:07,510
некоторое количество минут.

1461
01:05:07,510 --> 01:05:11,005
>> Но проблема в том, что предположим, что 50 было три или четыре викторины.

1462
01:05:11,005 --> 01:05:13,510
Предположим, что вы хотели использовать ту же программу для класса, который был

1463
01:05:13,510 --> 01:05:14,850
еженедельные викторины.

1464
01:05:14,850 --> 01:05:16,610
Подумайте о классе, который еженедельные викторины.

1465
01:05:16,610 --> 01:05:20,610
Если есть вроде 16 или около того недель в семестр, теперь у вас есть 16 переменных -

1466
01:05:20,610 --> 01:05:24,270
quiz1 Int, Int quiz2, внутр quiz3, внутр quiz4.

1467
01:05:24,270 --> 01:05:27,560
Как только вы начинаете видеть эту избыточность, это копирование и вставка

1468
01:05:27,560 --> 01:05:31,390
кода, он должен начать делать вы хотите там было лучше.

1469
01:05:31,390 --> 01:05:33,930
И к счастью, потому что массивы, есть.

1470
01:05:33,930 --> 01:05:34,980
Так давайте сделаем это.

1471
01:05:34,980 --> 01:05:38,430
Во-первых, позвольте мне представить очень простую вещь, что мы не использовали до сих пор,

1472
01:05:38,430 --> 01:05:40,140
но вы увидите, что иногда в коде.

1473
01:05:40,140 --> 01:05:42,360
Это то, что обычно называется постоянной.

1474
01:05:42,360 --> 01:05:45,790
Так что это постоянная в том смысле, что это значение никогда не меняется.

1475
01:05:45,790 --> 01:05:49,210
Человеческие конвенции при создании постоянной заключается в использовании всех капитальных

1476
01:05:49,210 --> 01:05:51,940
буквы, просто так, что он действительно выделяется в коде.

1477
01:05:51,940 --> 01:05:55,960
А специальные ключевые слова, которые вы используете в С # определить.

1478
01:05:55,960 --> 01:06:00,250
Так что, если вы говорите # определить, то пространство, то слово, которое вы хотите использовать для

1479
01:06:00,250 --> 01:06:03,260
постоянное название, а затем значение константы.

1480
01:06:03,260 --> 01:06:06,180
Таким образом, уведомление, это отличается от присвоения что-то переменная.

1481
01:06:06,180 --> 01:06:07,020
Там нет знака равенства.

1482
01:06:07,020 --> 01:06:08,240
Там нет запятой.

1483
01:06:08,240 --> 01:06:11,410
Это то, что известно как директива препроцессора, но больше на

1484
01:06:11,410 --> 01:06:12,210
в другой раз.

1485
01:06:12,210 --> 01:06:18,540
>> На данный момент, это создает неизменное значение, называемое викторины, фактические

1486
01:06:18,540 --> 01:06:19,940
числовое значение 2.

1487
01:06:19,940 --> 01:06:24,020
Таким образом, везде, где есть тесты, викторины, тесты на протяжении всего этого файла, это

1488
01:06:24,020 --> 01:06:25,410
только номер 2.

1489
01:06:25,410 --> 01:06:28,100
Теперь, если я смотрю на основные Теперь, давайте посмотрим, как это работает.

1490
01:06:28,100 --> 01:06:29,500
Во-первых, это выглядит немного загадочно.

1491
01:06:29,500 --> 01:06:31,340
Но это все вещи из неделе один.

1492
01:06:31,340 --> 01:06:32,710
Спросите у пользователя классах.

1493
01:06:32,710 --> 01:06:33,630
Как мы это делаем?

1494
01:06:33,630 --> 01:06:35,470
Ну, а в строке 22 -

1495
01:06:35,470 --> 01:06:37,210
это действительно сочные части -

1496
01:06:37,210 --> 01:06:40,960
Я заявляю с плавающей точкой, а не просто одним поплавком.

1497
01:06:40,960 --> 01:06:44,620
Я объявив, скорее, массив значений с плавающей точкой.

1498
01:06:44,620 --> 01:06:49,100
Это переменная будет называться классах, как это подразумевается здесь.

1499
01:06:49,100 --> 01:06:53,080
Но только часть нового синтаксиса, то эти квадратные скобки, тот факт,

1500
01:06:53,080 --> 01:06:59,350
что я сказал поплавок классах, а затем открыть скобку, а затем число.

1501
01:06:59,350 --> 01:07:02,460
Обратите внимание, если это постоянно, это так же, как мы сделали это.

1502
01:07:02,460 --> 01:07:06,890
Это означает, эй компьютер, дайте мне два поплавка, и давайте коллективно называют

1503
01:07:06,890 --> 01:07:08,220
их оценки.

1504
01:07:08,220 --> 01:07:11,920
Это в отличие от гораздо более трудоемкий процесс, как это.

1505
01:07:11,920 --> 01:07:15,850
Поплавок Grade1, плавать grade2, и так далее.

1506
01:07:15,850 --> 01:07:20,010
Таким образом, массив позволяет нам реализовать эту идею, но гораздо менее неряшливо, в

1507
01:07:20,010 --> 01:07:24,630
таким образом, что мы можем написать одну строку кода, а не, скажем, 16 на 16

1508
01:07:24,630 --> 01:07:25,740
неделя семестра.

1509
01:07:25,740 --> 01:07:29,950
Так что я не хочу жесткий код 2, потому что если вы думаете об этом сейчас

1510
01:07:29,950 --> 01:07:34,160
логично - предположим, в следующем году CS50 изменений до 3 викторины вместо этого.

1511
01:07:34,160 --> 01:07:35,510
И у меня был номер 2 здесь.

1512
01:07:35,510 --> 01:07:36,600
У меня был номер 2 здесь.

1513
01:07:36,600 --> 01:07:37,580
У меня был номер 2 здесь.

1514
01:07:37,580 --> 01:07:38,560
У меня был номер 2 здесь.

1515
01:07:38,560 --> 01:07:43,180
Она становится очень утомительным и очень легко испортить и случайно изменить

1516
01:07:43,180 --> 01:07:47,690
одно значение на 3 и пропустить некоторые другие значения 2.

1517
01:07:47,690 --> 01:07:52,460
Так что я собираюсь вместо абстрактного это расстояние и использовать эту константу, которая, как и ее

1518
01:07:52,460 --> 01:07:54,120
название, никогда не меняется.

1519
01:07:54,120 --> 01:07:57,710
И теперь, независимо от того, будем ли мы иметь различные викторины этом или следующем году, я

1520
01:07:57,710 --> 01:08:01,210
просто изменить его в одном месте, здесь на вершине.

1521
01:08:01,210 --> 01:08:02,720
>> Так что все константы.

1522
01:08:02,720 --> 01:08:08,680
Между тем, новая концептуальная особенность состоит в том массива.

1523
01:08:08,680 --> 01:08:14,660
Таким образом, в квадратных скобках дать мне это много плавает и позволяет мне коллективно

1524
01:08:14,660 --> 01:08:16,630
называть их классах здесь.

1525
01:08:16,630 --> 01:08:17,990
Итак, теперь давайте посмотрим, что я собираюсь делать.

1526
01:08:17,990 --> 01:08:20,359
Здесь, в строке 24 является началом цикла.

1527
01:08:20,359 --> 01:08:22,260
Это действительно ничего особенного.

1528
01:08:22,260 --> 01:08:25,060
Это только с помощью тестов, а не жестко числа.

1529
01:08:25,060 --> 01:08:27,790
Но нет ничего интеллектуально разных там с прошлой недели.

1530
01:08:27,790 --> 01:08:29,040
Это просто Printf.

1531
01:08:29,040 --> 01:08:35,490
Таким образом, Е ("тест номер% сут% D"), потому что я просто хочу, чтобы распечатать дать мне викторины

1532
01:08:35,490 --> 01:08:38,050
номер одного из двух, а затем два из двух.

1533
01:08:38,050 --> 01:08:39,850
Так что это чисто эстетическая вещь.

1534
01:08:39,850 --> 01:08:42,500
Но самое интересное сейчас находится в строке 27.

1535
01:08:42,500 --> 01:08:48,310
Для того, чтобы заполнить одну из двух заполнителей с плавающей точкой

1536
01:08:48,310 --> 01:08:51,029
значение, вы снова использовать квадратные скобки.

1537
01:08:51,029 --> 01:08:55,620
В этом случае, я использую я, потому что это цикл начался с равной я

1538
01:08:55,620 --> 01:08:57,560
Какое значение, по-видимому?

1539
01:08:57,560 --> 01:08:58,279
0.

1540
01:08:58,279 --> 01:09:01,350
>> Таким образом, на первой итерации этого цикла, это, как будто я

1541
01:09:01,350 --> 01:09:02,689
написал это в коде.

1542
01:09:02,689 --> 01:09:05,580
Но на второй итерации этого цикла, это, как будто я

1543
01:09:05,580 --> 01:09:07,750
написал это в своем коде.

1544
01:09:07,750 --> 01:09:10,750
Но то, что я использую переменную прекрасно, потому что, как следует из названия

1545
01:09:10,750 --> 01:09:14,300
предполагает, что это изменение его значения на каждой итерации.

1546
01:09:14,300 --> 01:09:17,370
Так что я заполнение этого массива одном месте за один раз.

1547
01:09:17,370 --> 01:09:18,910
Что это массив выглядит?

1548
01:09:18,910 --> 01:09:21,430
Ну, почему я нарисовал это супер простой прямоугольник на экране здесь

1549
01:09:21,430 --> 01:09:23,350
Перед именно по этой причине.

1550
01:09:23,350 --> 01:09:27,279
Массив это просто кусок памяти последовал еще один кусок памяти,

1551
01:09:27,279 --> 01:09:30,109
последовал еще один кусок памяти, и так далее.

1552
01:09:30,109 --> 01:09:35,260
Так что, если мой массив размером 2, в данном случае здесь, все, что я сделал бы по

1553
01:09:35,260 --> 01:09:37,590
ввод в моей оценки викторины, как здесь.

1554
01:09:37,590 --> 01:09:39,430
Я получил 100 на этом.

1555
01:09:39,430 --> 01:09:42,020
А потом я получил 99 на этом.

1556
01:09:42,020 --> 01:09:46,040
Тогда эта память не может даже быть использован, потому что я только спросил

1557
01:09:46,040 --> 01:09:48,689
компьютер массив размером 2.

1558
01:09:48,689 --> 01:09:50,180
Эти квадраты все еще там.

1559
01:09:50,180 --> 01:09:50,340
Верно?

1560
01:09:50,340 --> 01:09:52,500
У вас еще есть два гигабайта оперативной памяти, даже если вы только

1561
01:09:52,500 --> 01:09:53,979
просит двумя поплавками.

1562
01:09:53,979 --> 01:09:58,710
Таким образом, идея массивов является то, что компьютер просто берет кусок памяти

1563
01:09:58,710 --> 01:10:03,230
, а затем распределяет мелкие куски спина к спине, чтобы спина к спине.

1564
01:10:03,230 --> 01:10:04,740
И это все, что массив.

1565
01:10:04,740 --> 01:10:09,080
Это непрерывный кусок памяти, внутри которой вы можете положить вещи.

1566
01:10:09,080 --> 01:10:12,400
>> Теперь это происходит тогда делать лишь некоторые скучно арифметика.

1567
01:10:12,400 --> 01:10:16,170
Если я прокрутите вниз здесь, это где я тогда итерации по массиву.

1568
01:10:16,170 --> 01:10:19,410
Я придумал суммирование всех значений в массиве.

1569
01:10:19,410 --> 01:10:22,390
И тогда я использовать круглые функцию здесь на самом деле делать

1570
01:10:22,390 --> 01:10:23,940
сумма делится на викторины.

1571
01:10:23,940 --> 01:10:27,450
Но позвольте мне махнуть рукой на что как своего рода достаточно арифметических сейчас.

1572
01:10:27,450 --> 01:10:30,010
Но все, что делает для меня, в конечном счете, вычисление среднего.

1573
01:10:30,010 --> 01:10:33,640
Итак, сначала тест плюс вторая викторина, разделенная на 2, а затем печати

1574
01:10:33,640 --> 01:10:34,700
его, как Int.

1575
01:10:34,700 --> 01:10:39,030
>> Но давайте теперь переход к другой пример называется string1,

1576
01:10:39,030 --> 01:10:42,370
который рисует аналогичную картину, но с использованием строк.

1577
01:10:42,370 --> 01:10:45,550
Позвольте мне идти вперед и упростить этот на мгновение.

1578
01:10:45,550 --> 01:10:48,340
И прости отступ на данный момент.

1579
01:10:48,340 --> 01:10:52,280
Обратите внимание на линию 19 из этого примера, я получаю строку от пользователя.

1580
01:10:52,280 --> 01:10:55,780
Но обратите внимание на то, что я делаю в следующем линий 22 и далее.

1581
01:10:55,780 --> 01:11:00,260
На самом деле я итерация от Я до - и это новый трюк -

1582
01:11:00,260 --> 01:11:02,730
StrLen, длина строки.

1583
01:11:02,730 --> 01:11:07,010
Это функция, которая поставляется с C, что если вы передаете его строки, он говорит

1584
01:11:07,010 --> 01:11:08,950
Вам, сколько символов в этой строке.

1585
01:11:08,950 --> 01:11:09,440
Вот и все.

1586
01:11:09,440 --> 01:11:12,520
Тот факт, что это StrLen, а длина строки просто потому, что это

1587
01:11:12,520 --> 01:11:13,040
более кратким.

1588
01:11:13,040 --> 01:11:17,100
30 лет назад, людям нравилось писать вещи, как лаконично, насколько возможно.

1589
01:11:17,100 --> 01:11:19,080
Таким образом, мы сохранили эту конвенцию здесь.

1590
01:11:19,080 --> 01:11:21,730
я + + означает лишь то увеличиваем я в каждой итерации.

1591
01:11:21,730 --> 01:11:24,310
А теперь замечаю это, что действительно интересно.

1592
01:11:24,310 --> 01:11:28,730
Таким образом, в строке 24, я говорю компьютер, дайте мне характер, восемь

1593
01:11:28,730 --> 01:11:30,770
битов, и называют это в.

1594
01:11:30,770 --> 01:11:35,370
Но что это на правой стороне говорите?

1595
01:11:35,370 --> 01:11:38,150
В английском языке, что это представляете?

1596
01:11:38,150 --> 01:11:40,070
[Неразборчиво]

1597
01:11:40,070 --> 01:11:40,490
David J. Малан: Совершенно верно.

1598
01:11:40,490 --> 01:11:42,390
Дайте мне первый символ в массиве.

1599
01:11:42,390 --> 01:11:45,400
Или, в более общем, дай мне I-ый символ в массиве.

1600
01:11:45,400 --> 01:11:48,230
И понимаю, что это важно сейчас, как компьютерные науки, мы на самом деле

1601
01:11:48,230 --> 01:11:49,330
начиная с 0.

1602
01:11:49,330 --> 01:11:51,290
Вы не должны усмотрению сейчас, чтобы начать это делать.

1603
01:11:51,290 --> 01:11:54,580
Теперь вы должны вести себя в соответствии с ожиданиями компьютера и

1604
01:11:54,580 --> 01:11:58,010
считать с нуля, потому что [0] будет первым

1605
01:11:58,010 --> 01:11:59,670
символов в строке.

1606
01:11:59,670 --> 01:12:01,320
[1] будет второй.

1607
01:12:01,320 --> 01:12:03,610
[2] будет третьим, и так далее.

1608
01:12:03,610 --> 01:12:08,840
Таким образом, эта программа, если я скомпилировать его - это, опять же, string1.

1609
01:12:08,840 --> 01:12:11,040
>> Так что string1.

1610
01:12:11,040 --> 01:12:16,730
А теперь я бегу string1 в моем окне терминала.

1611
01:12:16,730 --> 01:12:19,180
Он ожидает ввода, так что я собираюсь ввести, скажем, Давида.

1612
01:12:19,180 --> 01:12:20,080
Enter.

1613
01:12:20,080 --> 01:12:23,350
И теперь он печатает DAVID все на разных линиях, потому что

1614
01:12:23,350 --> 01:12:24,430
заметит, что я делаю.

1615
01:12:24,430 --> 01:12:27,510
Я печать одного символа за один раз.

1616
01:12:27,510 --> 01:12:29,100
Сейчас мы не будем вдаваться в подробности сегодня на этом.

1617
01:12:29,100 --> 01:12:31,610
Но я удалил эту минуту назад здесь галочку.

1618
01:12:31,610 --> 01:12:36,310
Оказывается, что если пользователь неправильно, состязательности, или просто

1619
01:12:36,310 --> 01:12:41,780
замешательстве, вы можете фактически не дают строки некоторой длины.

1620
01:12:41,780 --> 01:12:43,640
Если вы нажмете не ту клавишу на клавиатуре, вы могли бы дать

1621
01:12:43,640 --> 01:12:44,390
Строка не на всех.

1622
01:12:44,390 --> 01:12:47,790
Или, если вы злой, вы можете попробовать, чтобы вставить в стоимость гигабайта о

1623
01:12:47,790 --> 01:12:49,380
эссе для заполнения этой строки.

1624
01:12:49,380 --> 01:12:52,060
И если на компьютере не хватает памяти, то получается, что мы собираемся

1625
01:12:52,060 --> 01:12:54,310
вернуть это специальное значение, называемое нулевое.

1626
01:12:54,310 --> 01:12:57,550
Таким образом, на данный момент, просто знаю, что есть это специальное значение, называемое нулевое, что

1627
01:12:57,550 --> 01:13:01,000
позволит нам проверить, когда мы из памяти, между прочим.

1628
01:13:01,000 --> 01:13:07,330
>> Но если я открываю сейчас string2, обратите внимание на одно различие здесь.

1629
01:13:07,330 --> 01:13:09,760
Обратите внимание на одно различие здесь с string2.

1630
01:13:09,760 --> 01:13:13,260
С string2, этот цикл немного отличается.

1631
01:13:13,260 --> 01:13:16,350
Позвольте мне удалить нули, так что мы можем говорить о тех, кто в другой раз.

1632
01:13:16,350 --> 01:13:18,460
Но чем же отличается цикла на этот раз?

1633
01:13:21,580 --> 01:13:23,160
И я могу вернуться к предыдущему примеру.

1634
01:13:23,160 --> 01:13:24,800
Так что это второй вариант.

1635
01:13:24,800 --> 01:13:27,020
Это версия одного.

1636
01:13:27,020 --> 01:13:31,935
Один, два, раз-два.

1637
01:13:35,030 --> 01:13:38,240
Так StrLen вызов где?

1638
01:13:38,240 --> 01:13:40,420
Это в первой части цикла.

1639
01:13:40,420 --> 01:13:43,060
Любые мысли о том, почему я это делаю?

1640
01:13:43,060 --> 01:13:43,690
Да.

1641
01:13:43,690 --> 01:13:46,010
[Неразборчиво]

1642
01:13:46,010 --> 01:13:47,630
David J. Малан: Так что мы не вызываем функцию каждый раз.

1643
01:13:47,630 --> 01:13:48,040
Именно так.

1644
01:13:48,040 --> 01:13:50,350
Напомним, с петлями на то, что они супер просто, как только вы рода

1645
01:13:50,350 --> 01:13:52,180
понимаю, что это инициализации

1646
01:13:52,180 --> 01:13:53,330
состоянии, и обновление.

1647
01:13:53,330 --> 01:13:55,430
Проблема в том, что условие происходит на каждом

1648
01:13:55,430 --> 01:13:56,600
итерации цикла.

1649
01:13:56,600 --> 01:13:59,930
И поэтому в данном примере, что такое плохо о том,

1650
01:13:59,930 --> 01:14:03,500
что это мое состояние?

1651
01:14:03,500 --> 01:14:05,920
Вы звоните StrLen снова и снова, и снова.

1652
01:14:05,920 --> 01:14:08,990
Но как только я набрал в DAVID, длина этой строки равно пяти.

1653
01:14:08,990 --> 01:14:11,560
И он не собирается менять на каждой итерации цикла, поскольку

1654
01:14:11,560 --> 01:14:15,560
Строка по-прежнему D--V-I-D. Так что это намек на то, что собирается стать

1655
01:14:15,560 --> 01:14:19,650
более важная идея известна как дизайнерское решение, где - просто не

1656
01:14:19,650 --> 01:14:21,640
заставить компьютер делать ненужную работу.

1657
01:14:21,640 --> 01:14:25,630
>> Теперь же, как предварительный просмотр PSET 2, PSET 2 в стандартном издании

1658
01:14:25,630 --> 01:14:28,850
собираюсь бросить вам вызов на самом деле реализации некоторого числа шифров, некоторые

1659
01:14:28,850 --> 01:14:32,650
количество алгоритмов шифрования, так что вы можете как шифрование и дешифрование

1660
01:14:32,650 --> 01:14:35,530
секретные сообщения, похожую на ту, Ральфи там декодировать.

1661
01:14:35,530 --> 01:14:38,720
В хакером издание PSET 2, мы собираемся пойти немного дальше.

1662
01:14:38,720 --> 01:14:42,010
Мы собираемся передать вам файл с фактическими компьютерную систему, которая содержит

1663
01:14:42,010 --> 01:14:45,690
целую кучу имен и фактической зашифрованные пароли, и задача

1664
01:14:45,690 --> 01:14:49,110
для хакера издание будет взламывать эти пароли и фигуры

1665
01:14:49,110 --> 01:14:53,060
, что криптография и тайные, что была использована на самом деле

1666
01:14:53,060 --> 01:14:55,080
генерировать эти пароли.

1667
01:14:55,080 --> 01:14:58,360
И мы собираемся сделать это с помощью новой функции здесь C, что я дам

1668
01:14:58,360 --> 01:15:02,200
Вы только демо-версия, известная как аргументы командной строки.

1669
01:15:02,200 --> 01:15:05,930
>> Вот и получается, как некоторые из вас, возможно, видели в разделе или в учебниках,

1670
01:15:05,930 --> 01:15:09,850
Основным не всегда должна быть пустота в скобках.

1671
01:15:09,850 --> 01:15:14,060
Оказывается, что основная можно также записать как это, с двумя аргументами,

1672
01:15:14,060 --> 01:15:19,690
ARGC и ARGV, где ARGC число слов, которые вы вводите после

1673
01:15:19,690 --> 01:15:21,940
Программы имя в командной строке.

1674
01:15:21,940 --> 01:15:24,550
И ARGV является фактическим слов.

1675
01:15:24,550 --> 01:15:29,470
И, как квадратные скобки там предлагают, ARGV видимо массива.

1676
01:15:29,470 --> 01:15:33,720
Это собирается быть строкой после строки после строки в памяти.

1677
01:15:33,720 --> 01:15:36,170
Так что мы собираемся быть в состоянии сделать, начиная с PSET 2,

1678
01:15:36,170 --> 01:15:37,310
что-то вроде этого.

1679
01:15:37,310 --> 01:15:42,450
Если я делаю argv1, который является примером мы вернемся к в понедельник, и запустите

1680
01:15:42,450 --> 01:15:45,180
это, заметьте, что это не похоже, чтобы сделать что-нибудь еще.

1681
01:15:45,180 --> 01:15:47,050
Он просто выводит свое имя.

1682
01:15:47,050 --> 01:15:53,220
Но если я прощаюсь класса, обратите внимание, что эта программа по-видимому итерации

1683
01:15:53,220 --> 01:15:57,030
над каждым из слов, которые были напечатаны в командной строке.

1684
01:15:57,030 --> 01:16:02,050
И средства, с помощью которых мы сможем получить доступ к словам, которые пользователь имеет

1685
01:16:02,050 --> 01:16:06,780
печатается в строке является изменение основного, начиная этот уик-энд, от Int

1686
01:16:06,780 --> 01:16:10,710
основных (недействительными) в целое основные (агдс, ARGV).

1687
01:16:10,710 --> 01:16:13,700
И, таким образом родится аргументы командной строки.

1688
01:16:13,700 --> 01:16:17,210
И как только вы получите действительно сложная в этом, вы будете иметь возможность писать

1689
01:16:17,210 --> 01:16:21,370
действительно трип программ, таких, как этот вот, который идет выше и вне

1690
01:16:21,370 --> 01:16:25,520
некоторые функции, которые мы сделали до сих пор, но все довольно мощный.

1691
01:16:25,520 --> 01:16:27,330
>> Таким образом, мы оставим это с этим на экране.

1692
01:16:27,330 --> 01:16:29,160
И мы будем видеть Вас в понедельник.