1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [Неделя 2, продолжение]

2
00:00:02,270 --> 00:00:04,220
[David J. Малан, Гарвардский университет]

3
00:00:04,220 --> 00:00:06,880
[Это CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
Хорошо. Это CS50, и это в конце недели 2.

5
00:00:10,990 --> 00:00:14,410
Если вы планируете быть голодным в это время завтра,

6
00:00:14,410 --> 00:00:18,620
знать, что мы собираемся провести как небольшой группой завтра, четверг, 1:15 вечера.

7
00:00:18,620 --> 00:00:21,360
Там есть URL здесь, если вы хотите, чтобы RSVP.

8
00:00:21,360 --> 00:00:26,740
Места ограничены, так что простите, если форма заполнена к тому времени вы заполните это.

9
00:00:26,740 --> 00:00:29,300
Другой URL, однако, что может быть интересно это.

10
00:00:29,300 --> 00:00:32,369
В почти через месяц, курс будет доступна

11
00:00:32,369 --> 00:00:36,890
Все более широко через EDX, через которые люди в Интернете будет иметь возможность следить вместе,

12
00:00:36,890 --> 00:00:39,380
участвовать в процессе достаточно активно, на самом деле.

13
00:00:39,380 --> 00:00:42,270
Они буду использовать CS50 и CS50 Appliance Обсудить

14
00:00:42,270 --> 00:00:45,490
и самые различные программные средства, которые мы уже использовали в этом семестре.

15
00:00:45,490 --> 00:00:48,710
И одна из инициатив, которые мы хотели бы взять в качестве эксперимента в этом году

16
00:00:48,710 --> 00:00:51,930
, чтобы увидеть, как много содержания, которое мы можем перевести

17
00:00:51,930 --> 00:00:53,960
в других устных и письменных языков.

18
00:00:53,960 --> 00:00:57,500
Так что, если вы могли бы иметь заинтересованность в участии в этом проекте

19
00:00:57,500 --> 00:01:02,270
которым мы будем предоставлять английском стенограммы и субтитры для лекций курса

20
00:01:02,270 --> 00:01:05,450
и шортах и ​​семинарах и секциях и т.п.,

21
00:01:05,450 --> 00:01:08,200
если вы свободно говорить и писать свободно какой-то другой язык,

22
00:01:08,200 --> 00:01:12,290
мы хотели бы обратиться к вам в этот проект, в котором вы взять на себя одну или несколько видео,

23
00:01:12,290 --> 00:01:15,200
переводя их на язык, вы знаете достаточно хорошо.

24
00:01:15,200 --> 00:01:18,700
>> Чтобы дать вам представление о интерфейсе, там данном веб-интерфейс

25
00:01:18,700 --> 00:01:22,090
, которые мы будем использовать, что создаст существенно пользовательского интерфейса, как это.

26
00:01:22,090 --> 00:01:24,290
Это было мне преподавании некоторых Хэллоуин назад,

27
00:01:24,290 --> 00:01:27,390
и на правой стороне в черном рядом с этими метками времени,

28
00:01:27,390 --> 00:01:31,210
Вы увидите различные вещи, которые вышли из моих уст в тот день,

29
00:01:31,210 --> 00:01:34,850
, а затем под ним вы сможете перевести на другой язык

30
00:01:34,850 --> 00:01:38,690
именно то, что отображение между ними, в данном случае, английского и, скажем, испанского языка.

31
00:01:38,690 --> 00:01:40,440
Так что это на самом деле очень удобный инструмент.

32
00:01:40,440 --> 00:01:43,370
Вы можете перемотки назад и вперед очень легко с помощью сочетаний клавиш.

33
00:01:43,370 --> 00:01:47,490
Так что, если вы хотите принять участие в этом эксперименте, и ваши слова видел и читал

34
00:01:47,490 --> 00:01:51,850
на потенциально тысячи людей там, пожалуйста, не стесняйтесь участвовать.

35
00:01:51,850 --> 00:01:54,350
Одно слово о котенок с понедельника.

36
00:01:54,350 --> 00:02:00,350
Чтобы мы отправили слишком страшно сообщение, понимаем, что, как рабочее время предлагают

37
00:02:00,350 --> 00:02:03,300
а также разделы предлагают, дизайн, конечно, очень много

38
00:02:03,300 --> 00:02:07,360
, что студенты сотрудничают и говорить, чтобы работать через проблемы наборы

39
00:02:07,360 --> 00:02:11,260
и проблемы вместе, и действительно линии просто сводится к тому,

40
00:02:11,260 --> 00:02:16,010
снова, работа, которую вы в конечном итоге представить, должны быть вашей собственной.

41
00:02:16,010 --> 00:02:18,860
И, честно говоря, в рабочее время это совершенно нормально,

42
00:02:18,860 --> 00:02:22,240
это полностью можно ожидать даже поболтать с некоторыми друг рядом с вами.

43
00:02:22,240 --> 00:02:24,370
>> Если он или она борется с некоторыми тему и вы, как:

44
00:02:24,370 --> 00:02:27,940
"Ну, что ж, позвольте мне дать вам представление о некоторой строки кода, который я написал," это нормально,

45
00:02:27,940 --> 00:02:31,250
что происходит, и это очень способствует, я думаю, с процессом обучения.

46
00:02:31,250 --> 00:02:36,750
Там, где линия пересекла получает, когда голова наклонена рода здесь для слишком многих секунд

47
00:02:36,750 --> 00:02:41,160
или минут для того, чтобы действительно только что были возможности для разблокирования вашего друга,

48
00:02:41,160 --> 00:02:44,160
и, конечно, когда все становится обмен по электронной почте и Dropbox и т.п.,

49
00:02:44,160 --> 00:02:45,640
там тоже есть линии.

50
00:02:45,640 --> 00:02:48,620
Таким образом, все средства чувствовать себя комфортно и вдохновляет общаться с друзьями

51
00:02:48,620 --> 00:02:52,810
и одноклассникам о psets и больше и просто понимаю, что то, что вы в конечном итоге представить

52
00:02:52,810 --> 00:02:57,340
должно быть действительно продукт вашего творчества, а не кто-то другой.

53
00:02:57,340 --> 00:03:00,490
И вот одна из предметно-ориентированных задач для pset2,

54
00:03:00,490 --> 00:03:04,740
который выйдет поздно вечером завтра, погрузиться в мир криптографии,

55
00:03:04,740 --> 00:03:08,970
, которая является искусством шифрования или скремблирования информации,

56
00:03:08,970 --> 00:03:12,600
и это в конечном счете относится к миру безопасности.

57
00:03:12,600 --> 00:03:16,560
Теперь, безопасность для большинства из нас приходит в виде довольно мирской механизмов.

58
00:03:16,560 --> 00:03:19,050
У всех нас есть имена пользователей и пароли,

59
00:03:19,050 --> 00:03:23,450
и у всех нас есть очень плохие имена пользователей и пароли, скорее всего.

60
00:03:23,450 --> 00:03:28,240
>> Если ваш пароль так же на нескольких веб-сайтах, что, вероятно, не лучшая идея,

61
00:03:28,240 --> 00:03:30,070
как мы обсудим ближе к концу семестра.

62
00:03:30,070 --> 00:03:34,720
Если ваш пароль записывается на записки - не шутка - на вашем мониторе,

63
00:03:34,720 --> 00:03:38,350
это тоже не обязательно лучший дизайн, но довольно распространенное явление.

64
00:03:38,350 --> 00:03:42,470
И если вы не используете криптографию для шифрования паролей,

65
00:03:42,470 --> 00:03:44,210
они особенно уязвимы.

66
00:03:44,210 --> 00:03:47,270
Так что если вы думаете, что быть супер умный, имея скрытый документ Word

67
00:03:47,270 --> 00:03:49,910
где-то на вашем жестком диске, который имеет все ваши пароли

68
00:03:49,910 --> 00:03:53,670
но это в папке, что никто не собирается заглянуть, что тоже не очень надежный механизм.

69
00:03:53,670 --> 00:03:56,990
И то, что pset2 представит это искусство криптографии

70
00:03:56,990 --> 00:04:02,010
и скремблирования информации, так что такие вещи, как пароли все более безопасной.

71
00:04:02,010 --> 00:04:05,790
Контекст здесь является то, что с небезопасной данных

72
00:04:05,790 --> 00:04:07,930
приходит возможность зашифровать его и, чтобы засекретить его.

73
00:04:07,930 --> 00:04:11,470
И вот этот, например, является примером зашифрованное сообщение.

74
00:04:11,470 --> 00:04:14,700
Это на самом деле что-то говорит на английском языке, но это явно не вполне очевидна.

75
00:04:14,700 --> 00:04:18,279
И мы прошли полный круг сегодня, чтобы дразнить друг от друга, что это секретное сообщение здесь.

76
00:04:18,279 --> 00:04:23,490
Но в реальном мире компьютеров, вещи, даже не похоже, что они могут быть английские фразы.

77
00:04:23,490 --> 00:04:28,430
Например, это то, что вы можете найти на стандартной Linux или Mac или UNIX компьютер

78
00:04:28,430 --> 00:04:32,070
в файл, который был когда-то называли файла паролей.

79
00:04:32,070 --> 00:04:34,200
>> В настоящее время это были перемещены в другие места.

80
00:04:34,200 --> 00:04:39,210
Но если вы посмотрите в нужном месте в системе, вы увидите не только ваше имя пользователя

81
00:04:39,210 --> 00:04:43,400
или других людей в системе, но вы увидите, зашифрованную версию пароля.

82
00:04:43,400 --> 00:04:47,980
Действительно, слово склеп там предполагает, что следующие вещи в зашифрованном виде,

83
00:04:47,980 --> 00:04:52,680
и этот ряд, казалось бы, случайных букв и символов и цифр и т.д.

84
00:04:52,680 --> 00:04:56,480
могут быть расшифрованы только в целом зная некоторые тайны -

85
00:04:56,480 --> 00:04:58,840
секретное слово, секретный номер -

86
00:04:58,840 --> 00:05:03,160
и так на самом деле, искусство криптографии в конечном счете, сводится к тому, доверять какой-то

87
00:05:03,160 --> 00:05:05,650
и зная то, что кто-то не делает.

88
00:05:05,650 --> 00:05:10,090
Таким образом, мы рассмотрим это в немного более подробно сегодня и в PSET в будущем.

89
00:05:10,090 --> 00:05:12,200
А теперь несколько слов о Pass / Fail.

90
00:05:12,200 --> 00:05:15,360
Тем более, что некоторые из вас нырнул в pset1, техника,

91
00:05:15,360 --> 00:05:19,080
и совершенно новый мир для себя, понимаешь, что разочарование и растерянность

92
00:05:19,080 --> 00:05:21,700
и только технические трудности, вполне можно ожидать,

93
00:05:21,700 --> 00:05:24,180
Особенно с первым PSET, где есть так много всего нового,

94
00:05:24,180 --> 00:05:27,730
только знакомится с Л. и компакт-диск, и все эти тайные команды

95
00:05:27,730 --> 00:05:33,050
и новую среду, и это отдельно от фактического материала и программирование себя.

96
00:05:33,050 --> 00:05:36,940
Так понимаю также, что есть, конечно, рабочие часы, которые существуют в качестве опорной конструкции.

97
00:05:36,940 --> 00:05:38,880
>> Разделы начать в ближайшее воскресенье.

98
00:05:38,880 --> 00:05:42,960
Но самое главное, если вы чувствуете себя просто, что это не мир для вас,

99
00:05:42,960 --> 00:05:44,710
понимаешь, что это действительно просто нужно время.

100
00:05:44,710 --> 00:05:48,600
И если бы не эта возможность лет назад для меня взять класс годен / не годен,

101
00:05:48,600 --> 00:05:50,990
Честно говоря, я никогда бы даже ступить в классе.

102
00:05:50,990 --> 00:05:53,690
И вы можете изменить это до, скажем, пятый понедельник конечно,

103
00:05:53,690 --> 00:05:58,280
так что если вы на краю теперь, понимаешь, что вместо головы в некоторых других вод в целом,

104
00:05:58,280 --> 00:06:01,260
этого, конечно, рассматривать только изменения в зачет / незачет.

105
00:06:01,260 --> 00:06:04,570
Опять же, это не совсем эту культуру здесь, в Гарварде принимать вещи зачет / незачет

106
00:06:04,570 --> 00:06:08,670
так как все на самом деле хочет достичь или overachieve,

107
00:06:08,670 --> 00:06:11,130
но, честно говоря, это прекрасный способ попытаться что-то из

108
00:06:11,130 --> 00:06:16,720
которые не могут быть вам знакомы, и вы будете в конечном итоге делают, в большинстве случаев, вполне нормально,

109
00:06:16,720 --> 00:06:18,210
возможно, многое к вашему удивлению.

110
00:06:18,210 --> 00:06:20,980
И более конкретно, то, что я думаю, что годен / не годен вообще делает,

111
00:06:20,980 --> 00:06:22,940
Особенно, как вы, возможно, испытали с pset0,

112
00:06:22,940 --> 00:06:26,560
если вы положите в 10 часов, 15 часов, 25 часов в некоторых PSET

113
00:06:26,560 --> 00:06:29,920
и вы просто биться головой о стену, и она становится супер поздно ночью

114
00:06:29,920 --> 00:06:33,950
но вы сделали PSET 90% пути, и вы просто не могу понять одну вещь,

115
00:06:33,950 --> 00:06:36,520
годен / не годен действительно снимает остроту класса, как это,

116
00:06:36,520 --> 00:06:39,100
где вы можете сортировать радостно говорят: "Хорошо, я знаю, что это не идеальный,

117
00:06:39,100 --> 00:06:42,350
Но я работал от своей задницы на это, я очень счастлива с тем, где это закончилось »,

118
00:06:42,350 --> 00:06:44,850
и что будет соответствовать ожиданиям за зачет / незачет.

119
00:06:44,850 --> 00:06:47,540
Так что имейте это в виду. Хорошо.

120
00:06:47,540 --> 00:06:50,520
>> Так что те из вас, кто пытался использовать Гарвардского университета Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
знаю, что есть CS50 SSID, Wi-Fi соединение, плавающие вокруг

122
00:06:54,780 --> 00:06:56,490
что вы могли бы лучше удачи.

123
00:06:56,490 --> 00:07:00,130
Это немного парадоксально, что пароль для этого, если вы хотели бы попробовать подключении к этому

124
00:07:00,130 --> 00:07:08,350
для лучшей скорости - и дайте нам знать, если это не лучше - 12345, на всем пути до 8

125
00:07:08,350 --> 00:07:10,910
потому что 8 является более безопасной, чем 5.

126
00:07:10,910 --> 00:07:16,910
Так что если вам нужен Wi-Fi пароль, подключиться к беспроводному CS50 здесь, 12345678,

127
00:07:16,910 --> 00:07:20,380
и сообщение о CS50 Обсудить если вы до сих пор периодически возникающих проблем подключения,

128
00:07:20,380 --> 00:07:25,420
и мы дадим полномочия, которые будут знать это пространство. Хорошо.

129
00:07:25,420 --> 00:07:32,230
Так быстро тизер, особенно для тех из вас, кто вентилятора мальчиков и девочек всех Яблоко вещи.

130
00:07:32,230 --> 00:07:37,460
То, что я выкопал из несколько лет назад был этот файл здесь, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
только вид делают более конкретные и более сложные

132
00:07:39,930 --> 00:07:42,560
некоторые из наиболее основных программ C мы уже писали.

133
00:07:42,560 --> 00:07:46,910
Так я открыл этот файл, iUnlock.c. Он доступен на странице Лекции на сегодняшний день.

134
00:07:46,910 --> 00:07:49,810
На левой стороне вы увидите длинный список функций.

135
00:07:49,810 --> 00:07:53,230
Таким образом, человек, который написал это написал много функций, больше, чем просто основной.

136
00:07:53,230 --> 00:07:57,340
Он использовал целую кучу библиотек здесь, и если мы начнем прокрутки,

137
00:07:57,340 --> 00:08:04,890
что это на самом деле самый первый, я считаю, крэк для оригинального iPhone.

138
00:08:04,890 --> 00:08:09,830
>> Когда Вы хотели сделать джейлбрейк оригинальный iPhone, а это значит непривязанный джейлбрейк от AT & T

139
00:08:09,830 --> 00:08:13,710
и фактически установить специальное программное обеспечение на нем и делать то, что Яблоко не хочу, чтобы люди делают,

140
00:08:13,710 --> 00:08:18,480
кто-то взял время, чтобы выяснить, как именно они могут использовать программные ошибки,

141
00:08:18,480 --> 00:08:22,690
ошибки, ошибки, в программном обеспечении Apple, и таким образом родился iUnlock.c--

142
00:08:22,690 --> 00:08:26,760
что если вы собрали его на свой компьютер и установить его на iPhone

143
00:08:26,760 --> 00:08:29,430
, который был подключен к компьютеру с помощью, скажем, кабель USB,

144
00:08:29,430 --> 00:08:32,450
это даст вам административной или привилегии на вашем iPhone

145
00:08:32,450 --> 00:08:34,620
и позволяют сделать очень многое, что вы хотите.

146
00:08:34,620 --> 00:08:36,400
И вот там был этот увлекательный кошки-мышки

147
00:08:36,400 --> 00:08:39,340
между Яблоком и остального мира, в частности, так как они, как и многие компании,

148
00:08:39,340 --> 00:08:43,350
пытаются заблокировать свои вещи вниз, так что вы можете сделать только с ним, что они намерены.

149
00:08:43,350 --> 00:08:47,360
Но благодаря таким людям, как это и понимания низкого уровня деталей -

150
00:08:47,360 --> 00:08:50,830
и в этом случае C программирования - и много знакомых конструкций

151
00:08:50,830 --> 00:08:55,280
что мы начали играть, вы сможете по-настоящему использующие аппаратную

152
00:08:55,280 --> 00:08:59,250
таким образом, вы считаете нужным, и не обязательно некоторым юридическим лицом.

153
00:08:59,250 --> 00:09:01,600
Так, например, я понятия не имею, что все это делают,

154
00:09:01,600 --> 00:09:03,580
но GetVersion звучит довольно просто,

155
00:09:03,580 --> 00:09:05,710
и, похоже, это функция, что этот человек написал.

156
00:09:05,710 --> 00:09:09,250
Это займет какое-то целое число в качестве аргумента, ничего не возвращает,

157
00:09:09,250 --> 00:09:13,710
но, кажется, петли с цикла здесь и, если условие, если условие перерыва,

158
00:09:13,710 --> 00:09:16,770
и так или иначе связана с номерами версий, если прокрутить вниз,

159
00:09:16,770 --> 00:09:19,650
хотя многие из этих ключевых слов будет новый.

160
00:09:19,650 --> 00:09:22,590
И есть много функций здесь мы никогда не видели и не могли бы никогда не увидит

161
00:09:22,590 --> 00:09:24,350
в течение семестра.

162
00:09:24,350 --> 00:09:29,160
>> В конце концов, это следует тем же правилам и логике, что мы играли с до сих пор.

163
00:09:29,160 --> 00:09:34,340
Так что это слишком стар, чтобы взломать ваш iPhone или 3s 4s 5s или вскоре эти дни,

164
00:09:34,340 --> 00:09:38,830
но знаю, что все это очень полученные из этого мира, что мы нырнули.

165
00:09:38,830 --> 00:09:42,280
Давайте взглянем на несколько более простой пример:

166
00:09:42,280 --> 00:09:46,260
это, просто согреться с некоторыми синтаксиса, а также некоторые другие типы данных

167
00:09:46,260 --> 00:09:48,910
что мы говорили, но действительно не видел в C.

168
00:09:48,910 --> 00:09:53,670
Этот файл называется positive1.c, и в комментариях на вершине,

169
00:09:53,670 --> 00:09:56,070
это просто требует, чтобы пользователь обеспечить положительное число.

170
00:09:56,070 --> 00:09:59,910
Так что это пример сделай то время как цикл, который хорош для пользователей интерактивных программ

171
00:09:59,910 --> 00:10:02,070
где вы должны сказать пользователю, чтобы что-то сделать,

172
00:10:02,070 --> 00:10:05,530
и если они не сотрудничают вы кричать на них или отклонить их ввода.

173
00:10:05,530 --> 00:10:10,480
Дело в точку: я собираюсь делать строках 19 до 24

174
00:10:10,480 --> 00:10:14,620
тех пор, пока пользователь не дал мне положительное число.

175
00:10:14,620 --> 00:10:21,340
Эта деталь здесь, на линии 18, почему я заявляю, п выше всего этого цикла построить

176
00:10:21,340 --> 00:10:26,870
в отличие от прямо рядом с линией 22, где я на самом деле заботятся, чтобы получить п? Да.

177
00:10:26,870 --> 00:10:29,330
[Студент] Scope. >> Да, так что этот вопрос из области видимости.

178
00:10:29,330 --> 00:10:31,770
И с точки зрения непрофессионала, что делает область относится?

179
00:10:34,880 --> 00:10:41,560
Да. >> [Неразборчиво ответ студента] >> Можете ли вы говорить громче?

180
00:10:41,560 --> 00:10:45,440
[Студент] Где можно получить доступ к этой переменной. >> Perfect.

181
00:10:45,440 --> 00:10:47,610
Где Вы можете получить доступ к конкретной переменной.

182
00:10:47,610 --> 00:10:50,990
И вообще, правило до сих пор было, что сфера некоторые переменные

183
00:10:50,990 --> 00:10:56,140
определяется самой последней фигурные скобки, что вы видели.

184
00:10:56,140 --> 00:11:03,070
>> И поэтому в данном случае, если я сделал ошибку, объявив п на линии 22, что линия будет работать.

185
00:11:03,070 --> 00:11:10,840
Я хотел бы получить целое число, и я бы поставил его в этой переменной п в строке 22,

186
00:11:10,840 --> 00:11:17,060
но какая строка кода теперь не знаю, что я говорю? >> [Студент] 25.

187
00:11:17,060 --> 00:11:23,840
[Малан] 25, и оказывается, что 24, а потому, что в этом случае он выходит за пределы фигурные скобки.

188
00:11:23,840 --> 00:11:28,550
Так что просто немного неприятность, но очень легко решается просто объявить переменную

189
00:11:28,550 --> 00:11:30,700
за пределами самой функции.

190
00:11:30,700 --> 00:11:32,760
Позже мы увидим, сегодня вы можете сделать еще один шаг

191
00:11:32,760 --> 00:11:34,940
и вы даже можете получить немного ленивый.

192
00:11:34,940 --> 00:11:39,660
И это не рекомендуется вообще, но вы можете даже получить ленивого

193
00:11:39,660 --> 00:11:44,150
и положить переменную в глобальном масштабе, так сказать, не внутри функции, а не внутри цикла,

194
00:11:44,150 --> 00:11:49,800
но в самом файле, за пределами всех функций вы написали, как я сделал здесь, на линии 15.

195
00:11:49,800 --> 00:11:55,220
Это, как правило, с неодобрением, но понимаю, что это решение иногда к другим проблемам,

196
00:11:55,220 --> 00:11:56,910
как мы в конечном счете видеть.

197
00:11:56,910 --> 00:11:59,500
Так что сейчас мы оставим это так, но давайте посмотрим, если мы можем переписать это

198
00:11:59,500 --> 00:12:02,360
только, чтобы начать выразить себя немного по-другому.

199
00:12:02,360 --> 00:12:05,550
Эта программа, просто чтобы быть ясно, является positive1.

200
00:12:05,550 --> 00:12:11,980
Позвольте мне идти вперед здесь и в моем окне терминала сделать positive1, Enter.

201
00:12:11,980 --> 00:12:15,080
Компилирует порядке. Я собираюсь запустить positive1, нажмите Enter.

202
00:12:15,080 --> 00:12:19,250
Я требую, чтобы вы дать мне целое положительное число. Я скажу -1. Это не работает.

203
00:12:19,250 --> 00:12:22,340
0, 99. Это похоже на работу.

204
00:12:22,340 --> 00:12:25,310
Может быть, не самый строгий тест, но по крайней мере это хорошая проверка вменяемости

205
00:12:25,310 --> 00:12:27,100
что мы находимся на правильном пути.

206
00:12:27,100 --> 00:12:29,570
>> Так что теперь позвольте мне идти вперед и открыть версию 2 настоящей,

207
00:12:29,570 --> 00:12:32,800
и чем отличается уже?

208
00:12:32,800 --> 00:12:39,030
Он реализует ту же самую вещь, но то, что прыгает, как четко в этот раз?

209
00:12:40,790 --> 00:12:47,090
Это BOOL в зеленый цвет. Он будет выделен зеленым цветом, это ключевое слово известно как логический, который является типом данных.

210
00:12:47,090 --> 00:12:50,510
Она не приходит построен в для всех версий C.

211
00:12:50,510 --> 00:12:52,650
Вам необходимо включить конкретную библиотеку.

212
00:12:52,650 --> 00:12:56,460
В нашем случае, я включил CS50 библиотеку, так что у нас есть доступ к BOOL.

213
00:12:56,460 --> 00:12:59,860
Но в строке 18, мы, кажется, есть логическое значение здесь называют благодарны.

214
00:12:59,860 --> 00:13:02,190
Я мог бы назвать это что угодно, но я назвал его благодарна

215
00:13:02,190 --> 00:13:04,750
просто вид передают смысловое значение.

216
00:13:04,750 --> 00:13:07,700
Таким образом, первоначально на линии 18, я, видимо, не благодарный

217
00:13:07,700 --> 00:13:12,230
потому что логическое значение благодарны инициализируется ложным в строке 18.

218
00:13:12,230 --> 00:13:16,500
И тогда кажется, что я сделал здесь в строках с 21 по 23

219
00:13:16,500 --> 00:13:19,200
это я только отчасти переписать мою логику.

220
00:13:19,200 --> 00:13:26,100
Так что не функционально разные, но в строке 22 теперь я могу проверить, если Int пользователь предоставил

221
00:13:26,100 --> 00:13:31,360
больше 0, то я просто изменить значение благодарны правда.

222
00:13:31,360 --> 00:13:35,590
А зачем мне это делать? Потому что в строке 25, по-видимому, я собираюсь проверить состояние.

223
00:13:35,590 --> 00:13:39,760
У этого цикла в то время как благодарный является ложным.

224
00:13:39,760 --> 00:13:42,960
Так что я предложил это в качестве альтернативы версия 1

225
00:13:42,960 --> 00:13:47,050
потому что это по крайней мере немного более интуитивным, возможно, это немного более обоснованной на английском языке.

226
00:13:47,050 --> 00:13:51,980
Таким образом, выполните следующие действия, пока вы не благодарны или при благодарны является ложным.

227
00:13:51,980 --> 00:13:56,220
И на этот раз я тоже, видимо, не люблю вспоминать то, что пользователь набрал в

228
00:13:56,220 --> 00:14:00,050
потому что уведомления нет переменной п, так на самом деле, маленькая белая ложь там.

229
00:14:00,050 --> 00:14:03,290
>> Функционально программа немного отличается, как только мы перейдем к нижней его

230
00:14:03,290 --> 00:14:04,960
потому что я не помнил, что п.

231
00:14:04,960 --> 00:14:09,120
Но я хотел показать здесь, что, хотя мы видели GetInt

232
00:14:09,120 --> 00:14:13,780
и GetString используется на правую сторону знака равенства до сих пор

233
00:14:13,780 --> 00:14:17,310
так что мы помним значение, технически, это не строго обязательно.

234
00:14:17,310 --> 00:14:20,290
Если по каким-либо причинам вы просто не заботятся, чтобы сохранить значение,

235
00:14:20,290 --> 00:14:25,540
Вы просто хотите проверить значение, заметили, что мы можем просто написать это как GetInt,

236
00:14:25,540 --> 00:14:27,320
открытая скобка, рядом парень.

237
00:14:27,320 --> 00:14:30,570
Эта функция будет возвращать значение, как мы уже говорили.

238
00:14:30,570 --> 00:14:32,220
Это будет вернуть вам Int.

239
00:14:32,220 --> 00:14:34,460
И поэтому, если вы мысленно думаю, что это произойдет,

240
00:14:34,460 --> 00:14:38,190
при вводе в 99, GetInt возвращает число 99,

241
00:14:38,190 --> 00:14:41,840
и так концептуально, это как бы мой код был на самом деле этого.

242
00:14:41,840 --> 00:14:45,950
Так, если 99 действительно больше 0, то благодарный становится истинным,

243
00:14:45,950 --> 00:14:50,810
Затем линия 25 реализует ох, мы сделали, потому что я сейчас благодарен,

244
00:14:50,810 --> 00:14:53,970
и в строке 26, мы просто говорим: "Спасибо за натуральное!"

245
00:14:53,970 --> 00:14:55,960
Как бы там ни случилось быть.

246
00:14:55,960 --> 00:14:59,140
Теперь давайте сделаем небольшой синтаксический сахар здесь, так сказать.

247
00:14:59,140 --> 00:15:04,670
Давайте посмотрим, если мы можем убирать эту линию 25 с этим третий и последний вариант, в positive3.

248
00:15:04,670 --> 00:15:13,600
>> Обратите внимание, с той лишь разницей, что теперь это строка кода? >> [Студент] 25. >> [Малан] Да, 25.

249
00:15:13,600 --> 00:15:17,680
И мы действительно не видел этот трюк, но его мы видели восклицательный знак в понедельник,

250
00:15:17,680 --> 00:15:21,070
, который обозначает, что? >> [Студент] Не. >> Не или отрицание.

251
00:15:21,070 --> 00:15:23,510
Так что берите логическое значение и перевернуть его значение.

252
00:15:23,510 --> 00:15:25,810
Правда, становится ложным, ложное становится истинным.

253
00:15:25,810 --> 00:15:30,420
Так что это, я хотел бы предложить, даже немного более интуитивным способом написания кода

254
00:15:30,420 --> 00:15:33,430
потому что я до сих пор благодарен инициализации ложным, я все еще делаю следующее,

255
00:15:33,430 --> 00:15:36,010
Я поставил благодарны верно, когда придет время,

256
00:15:36,010 --> 00:15:40,880
но теперь вы действительно можете просто перевести этот код устно слева направо,

257
00:15:40,880 --> 00:15:45,630
а (благодарны!), потому что взрыва или восклицательный знак обозначает понятие не

258
00:15:45,630 --> 00:15:47,580
так что пока не благодарны.

259
00:15:47,580 --> 00:15:49,900
Итак, еще раз, мы не введены новые понятия как такового.

260
00:15:49,900 --> 00:15:53,730
Мы говорили о логических назад, когда мы играли с нуля,

261
00:15:53,730 --> 00:15:56,720
но понимаю, теперь мы можем просто начать писать наш код по-разному.

262
00:15:56,720 --> 00:16:01,060
Таким образом, особенно в pset1 если вы вроде пытается выяснить способ, чтобы написать несколько программ,

263
00:16:01,060 --> 00:16:04,340
Шансы Вам повезло, потому что там может быть любое число решений

264
00:16:04,340 --> 00:16:06,110
что вы можете случайно встретить.

265
00:16:06,110 --> 00:16:10,500
Например, это находится всего в 3 даже для простейших программ. Хорошо.

266
00:16:10,500 --> 00:16:14,200
А теперь вспомним в понедельник мы вышли на эту записку с возвращением значения.

267
00:16:14,200 --> 00:16:18,450
Таким образом, в первый раз, когда мы написали программу, которая не просто основной;

268
00:16:18,450 --> 00:16:22,550
она также имеет свою собственную функцию, которую я написал здесь.

269
00:16:22,550 --> 00:16:26,810
Таким образом, в строке 31 по 34 я реализовал функцию куб.

270
00:16:26,810 --> 00:16:30,240
Это не комплекс. Это просто * а * а в этом случае.

271
00:16:30,240 --> 00:16:34,750
Но, что важно о нем, что я беру вход в виде

272
00:16:34,750 --> 00:16:39,180
и я возвращаюсь выход в виде * а *.

273
00:16:39,180 --> 00:16:43,560
Так что теперь у меня есть возможность, так же, как я раньше с prinf один,

274
00:16:43,560 --> 00:16:47,240
для вызова этой функции, вызвав функцию куб.

275
00:16:47,240 --> 00:16:51,970
>> И куб функция принимает некоторые вход, и куб функция возвращает некоторый выход.

276
00:16:51,970 --> 00:16:56,960
В отличие от Printf просто что-то сделал.

277
00:16:56,960 --> 00:17:00,840
Она не возвращает ничего, что мы заботились о, хотя, как в сторону оно возвращает значение;

278
00:17:00,840 --> 00:17:03,110
Вы просто вообще игнорируют его.

279
00:17:03,110 --> 00:17:06,510
Printf просто что-то сделал. Это был побочный эффект печати на экране.

280
00:17:06,510 --> 00:17:11,770
В отличие от здесь, у нас есть куб функции, которые на самом деле возвращает что-то.

281
00:17:11,770 --> 00:17:15,520
Так что для тех, кто знаком с этим, это довольно простая идея.

282
00:17:15,520 --> 00:17:19,640
Но для тех, кто менее знаком с этой идеей проходящих в входы и выходы возвращаются,

283
00:17:19,640 --> 00:17:21,950
Давайте попробуем просто что-то супер просто.

284
00:17:21,950 --> 00:17:25,490
Кто-нибудь удобные подойдя на этапе кратко?

285
00:17:25,490 --> 00:17:28,040
Вы должны быть знакомы с камерой на вас. Да? Хорошо.

286
00:17:28,040 --> 00:17:31,240
Как тебя зовут? >> [Студент] Кен. >> Кен. Хорошо. Кен, давай вверх.

287
00:17:31,240 --> 00:17:35,050
Кен будет функция вида здесь.

288
00:17:35,050 --> 00:17:38,720
Давайте пойдем дальше и сделать это. Давайте немного фантазии.

289
00:17:38,720 --> 00:17:42,260
Очень приятно. Добро пожаловать в центре сцены. Хорошо.

290
00:17:42,260 --> 00:17:46,640
Давайте хит этой кнопки здесь. Хорошо.

291
00:17:46,640 --> 00:17:49,820
Так что здесь у вас есть современный доске,

292
00:17:49,820 --> 00:17:53,470
и что я является основной функцией, например,

293
00:17:53,470 --> 00:17:56,460
и у меня нет IPad в руках.

294
00:17:56,460 --> 00:17:59,710
>> Я действительно не помню, как - Ну, я не могу сказать.

295
00:17:59,710 --> 00:18:02,480
Я действительно не имеют хороший почерк,

296
00:18:02,480 --> 00:18:05,520
и т.д. Поэтому я хочу, чтобы что-то напечатать на экране для меня.

297
00:18:05,520 --> 00:18:12,040
Я являющийся основной программе, и я буду у вас говорят, что это

298
00:18:12,040 --> 00:18:16,720
записав ее в моей куриной нуля, а затем мимо вас вход.

299
00:18:16,720 --> 00:18:20,400
Так глупо, хотя это упражнение, понятие функции и вызова функции

300
00:18:20,400 --> 00:18:22,400
и возвращение функцией действительно сводится к этому.

301
00:18:22,400 --> 00:18:26,260
Я главный, я только что написал Printf, цитата-конец цитаты что-то на экране,

302
00:18:26,260 --> 00:18:29,110
Я иду в эту программу, и как только Printf вызывается,

303
00:18:29,110 --> 00:18:32,880
он принимает один аргумент или один параметр иногда в двойные кавычки.

304
00:18:32,880 --> 00:18:35,880
Вот это аргумент. Я передаю его Кен.

305
00:18:35,880 --> 00:18:39,020
Он представляет собой черный ящик, написал некоторое количество лет назад

306
00:18:39,020 --> 00:18:41,510
которые, очевидно, знает только как печатать вещи на экране.

307
00:18:41,510 --> 00:18:43,150
Таким образом выполнить.

308
00:18:49,280 --> 00:18:51,280
Это не плохо. Очень хорошо.

309
00:18:51,280 --> 00:18:55,510
Так что теперь Кен делается выполнение. Ему нужно, чтобы передать мне ничего взамен?

310
00:18:55,510 --> 00:18:57,470
Не то, что мы видели до сих пор.

311
00:18:57,470 --> 00:19:00,460
Опять же, Printf ли на самом деле возвращает число, но мы собираемся игнорировать, что на данный момент

312
00:19:00,460 --> 00:19:03,470
потому что мы никогда не использовали его. Так вот оно что для Кена.

313
00:19:03,470 --> 00:19:08,580
И вот теперь основные берет на себя контроль над программой еще раз

314
00:19:08,580 --> 00:19:11,060
потому что строки кода, Printf, осуществляется выполнение.

315
00:19:11,060 --> 00:19:14,050
И мы движемся к нашей образом, выполнение любых других линий есть.

316
00:19:14,050 --> 00:19:17,320
Итак, теперь давайте попробуем немного другой пример.

317
00:19:17,320 --> 00:19:24,940
На этот раз здесь, давайте сначала очистить экран, и на этот раз мы будем делать измерения кубатуры функции,

318
00:19:24,940 --> 00:19:27,080
но на этот раз, я думаю, выходное значение.

319
00:19:27,080 --> 00:19:29,180
>> Так что давайте идти вперед и делать это.

320
00:19:29,180 --> 00:19:35,790
Теперь у меня есть строка кода, которая говорит х получает куб х.

321
00:19:41,370 --> 00:19:46,370
Строка кода, напомним, выглядит следующим образом: х = куба (х);

322
00:19:46,370 --> 00:19:50,930
Так как это будет работать? Давайте пойдем дальше и дать вам белый экран.

323
00:19:50,930 --> 00:19:54,070
Я собираюсь записать теперь значение х,

324
00:19:54,070 --> 00:20:01,400
которые в данный момент времени, случается, скажем, 2, чтобы держать его проста.

325
00:20:01,400 --> 00:20:06,150
Я написал на листке бумаги значение 2, который является моим значения х.

326
00:20:06,150 --> 00:20:10,920
Я передаю его Кен. >> А я просто пишу ответ? >> Да, давайте просто написать ответ.

327
00:20:12,760 --> 00:20:18,940
Хорошо. И теперь он должен вернуть мне что-нибудь. Perfect. Приятно переход.

328
00:20:18,940 --> 00:20:23,120
Так что теперь он протягивает мне обратно значение 8 в данном случае, и что мне с ним делать?

329
00:20:23,120 --> 00:20:28,250
На самом деле - посмотрим, получить это право. Что я буду с ней делать?

330
00:20:28,250 --> 00:20:33,440
Теперь я собираюсь принять это значение и на самом деле хранить его в те же биты в памяти.

331
00:20:33,440 --> 00:20:35,170
Но заметьте, я немного борются здесь.

332
00:20:35,170 --> 00:20:38,210
Я немного смущен, потому что где же я на самом деле записать значение х,

333
00:20:38,210 --> 00:20:43,150
потому что я только что сделал физически руку Кен листок бумаги, который был значение 2,

334
00:20:43,150 --> 00:20:46,590
который был х, и, действительно, это именно то, что произошло.

335
00:20:46,590 --> 00:20:50,210
Вот и получается, что при вызове функции, и вы передаете в качестве аргумента

336
00:20:50,210 --> 00:20:53,290
например, привет, мир, или вы передаете в качестве аргумента как 2,

337
00:20:53,290 --> 00:20:57,110
Как правило, вы передаете копию этого аргумента.

338
00:20:57,110 --> 00:21:00,730
И так же, как я записал номер 2 здесь и передал его Кен,

339
00:21:00,730 --> 00:21:04,720
, что должно означать, что у меня еще есть копия значения 2 где-то

340
00:21:04,720 --> 00:21:08,890
потому что действительно, теперь, когда я получил обратно значение 8, мне нужно вернуться в оперативной памяти

341
00:21:08,890 --> 00:21:12,130
и фактически записать 8, где я когда-то был номер 2.

342
00:21:12,130 --> 00:21:16,950
Таким образом, визуально, помните об этом понятии проходящей в буквальном смысле, копию значения.

343
00:21:16,950 --> 00:21:20,780
>> Кен делает свое дело, протягивает мне в ответ что-то - в этом случае значение, например, 8 -

344
00:21:20,780 --> 00:21:24,980
а то у меня что-то сделать с этим значением, если я хочу сохранить его окрестностях.

345
00:21:24,980 --> 00:21:29,650
Так что все это вернется, чтобы быть слишком хорошо знакомы в скором времени.

346
00:21:29,650 --> 00:21:34,920
Спасибо вам большое за это демо здесь, Кен. [Аплодисменты]

347
00:21:34,920 --> 00:21:36,920
Очень хорошо сделано.

348
00:21:36,920 --> 00:21:42,690
Давайте посмотрим, как это в конечном итоге связано с некоторыми из вызова функции, что мы делаем здесь.

349
00:21:42,690 --> 00:21:47,910
Позвольте мне идти вперед и вернуть нас к измерения кубатуры пример.

350
00:21:47,910 --> 00:21:53,300
Обратите внимание, что если мы действительно хотим начать принимать это дальше,

351
00:21:53,300 --> 00:21:57,570
мы собираемся должны помнить о том, что число х, что это передается здесь

352
00:21:57,570 --> 00:22:01,530
отличается от того, что на самом деле передается в функцию.

353
00:22:01,530 --> 00:22:05,880
Итак, еще раз, это проходит мимо копии станет весьма уместны в одну минуту.

354
00:22:05,880 --> 00:22:09,580
Давайте взглянем на то, что не совсем правильно работать еще.

355
00:22:09,580 --> 00:22:13,250
Я собираюсь идти вперед и открыть третий пример ошибки, которая является ущербной по своей природе,

356
00:22:13,250 --> 00:22:18,550
и это называется buggy3 и реализует замены.

357
00:22:18,550 --> 00:22:25,110
Здесь у нас есть основные функции, которые х и у произвольно устанавливается в 1 и 2, соответственно.

358
00:22:25,110 --> 00:22:27,700
Мы могли бы использовать GetInt, но нам просто нужно простое упражнение,

359
00:22:27,700 --> 00:22:30,170
таким образом, это жестко, как 1 и 2.

360
00:22:30,170 --> 00:22:35,340
В строках 21 и 22, мы, видимо, распечатайте х и у, 1 на линию.

361
00:22:35,340 --> 00:22:39,720
Затем в строке 23, я утверждаю, я обмен этими значениями, точка, точка, точка.

362
00:22:39,720 --> 00:22:44,170
Я видимо вызова функции в строке 24 называемым своп, который принимает 2 аргументов.

363
00:22:44,170 --> 00:22:48,300
Это полностью законно для функций взять 2 аргументы. Мы видели Printf это сделать уже.

364
00:22:48,300 --> 00:22:51,830
>> Таким образом, своп-видимому, имеет х и у, и, как предполагает его название,

365
00:22:51,830 --> 00:22:54,670
Я надеюсь, что он собирается поменять эти 2 значения.

366
00:22:54,670 --> 00:23:00,090
Так вот я утверждаю, в строке 25 "перестановки"! и я перепечатать х и у

367
00:23:00,090 --> 00:23:03,070
при условии, что они действительно были поменяны местами.

368
00:23:03,070 --> 00:23:06,080
Но если я действительно запустить эту программу - позвольте мне открыть окно терминала,

369
00:23:06,080 --> 00:23:09,860
позвольте мне сделать buggy3 - как следует из названия, это не закончится хорошо

370
00:23:09,860 --> 00:23:15,770
потому что, когда я ударил Enter, заметили, что х = 1, у = 2,

371
00:23:15,770 --> 00:23:19,420
и все же в конце программы, они все еще, по сути, то же самое.

372
00:23:19,420 --> 00:23:22,960
Таким образом, на основе демонстрации только сейчас с Кеном, то, что происходит на самом деле?

373
00:23:22,960 --> 00:23:28,710
Давайте погрузимся в эту своп функции. Это супер короткие. Это всего лишь несколько строк кода долго.

374
00:23:28,710 --> 00:23:34,520
Но то, что основная проблема основана на простой истории, рассказанной здесь с Кеном?

375
00:23:34,520 --> 00:23:36,670
Почему подкачки не работает?

376
00:23:36,670 --> 00:23:39,660
[Студент] вы храните на копию, а не переменная.

377
00:23:39,660 --> 00:23:43,980
Именно так. Мы хранении на копию, а не саму переменную.

378
00:23:43,980 --> 00:23:47,170
Иными словами, своп-видимому, имеет 2 аргумента, INT,

379
00:23:47,170 --> 00:23:49,370
и это условно называть а и б,

380
00:23:49,370 --> 00:23:54,420
и здесь я прошел по х и у, которые являются соответственно 1 и 2,

381
00:23:54,420 --> 00:23:58,770
но я не в буквальном смысле проходящей в х, я не в буквальном смысле проходящей в у,

382
00:23:58,770 --> 00:24:01,450
Я передаю копии х и копию у.

383
00:24:01,450 --> 00:24:04,510
Это почти как если бы вы скопировали и вставили в своп

384
00:24:04,510 --> 00:24:07,810
значения, которые вы хотите, чтобы он на самом деле манипулировать.

385
00:24:07,810 --> 00:24:14,480
Так что, если это так, когда я начала программы выполнения строки 35, то 36,

386
00:24:14,480 --> 00:24:18,650
когда я добираюсь до линии 37, на данный момент в этой истории, что значение?

387
00:24:21,040 --> 00:24:25,050
В этот момент в истории, строка 37, что является значение в этой точке? >> [Студент] 1.

388
00:24:25,050 --> 00:24:29,280
[Малан] Она просто должна быть 1, правы, потому что х был принят в качестве первого аргумента,

389
00:24:29,280 --> 00:24:33,080
и эта функция просто произвольно называет свой первый аргумент.

390
00:24:33,080 --> 00:24:38,200
Точно так же есть у второго аргумента, и это просто произвольно вызова второго б аргумент.

391
00:24:38,200 --> 00:24:40,990
>> Эта дихотомия на самом деле довольно просто объяснить. Подумайте об этом.

392
00:24:40,990 --> 00:24:43,320
Никто из нас не встречал человека, который написал Printf,

393
00:24:43,320 --> 00:24:50,770
поэтому, конечно, он или она не знает, что наши переменные через 30 лет будут называть.

394
00:24:50,770 --> 00:24:56,650
Так что должно быть различие между, что вы называете переменные в функциях вы пишете

395
00:24:56,650 --> 00:25:02,080
и что вы называете переменные в функциях вы звоните или использование.

396
00:25:02,080 --> 00:25:05,340
Итак, другими словами, я написал мои переменные х и у,

397
00:25:05,340 --> 00:25:08,890
Но если кто-то другой написал своп функции, он или она, конечно, не знал бы,

398
00:25:08,890 --> 00:25:10,690
что мои переменных будет называться,

399
00:25:10,690 --> 00:25:13,830
так понимаю, что это, почему у вас есть эта двойственность имен.

400
00:25:13,830 --> 00:25:16,750
Технически, я мог бы сделать это, совпадение,

401
00:25:16,750 --> 00:25:20,080
но они будут по-прежнему передается в качестве копии.

402
00:25:20,080 --> 00:25:23,650
Было бы просто чистое совпадение эстетически, если это человек, который написал своп

403
00:25:23,650 --> 00:25:26,150
были использованы те же имена.

404
00:25:26,150 --> 00:25:32,370
Таким образом, на данный момент в этой истории, строка 37, 1, B 2, а теперь я перехожу к поменять их местами.

405
00:25:32,370 --> 00:25:34,900
Прежде всего, позвольте мне на самом деле сделать это гораздо проще.

406
00:25:34,900 --> 00:25:36,690
Я не знаю, что те 3 строки кода делали.

407
00:25:36,690 --> 00:25:41,210
Позвольте мне сделать это: B = A, A = B; сделано.

408
00:25:41,210 --> 00:25:44,690
Почему это сломанный, логически?

409
00:25:46,490 --> 00:25:48,900
Это своего рода интуитивные вещи, не так ли?

410
00:25:48,900 --> 00:25:52,560
Так а становится Ъ и Ъ становится,

411
00:25:52,560 --> 00:25:57,730
но проблема в том, что как только линия 37 выполняет, что значение А и В?

412
00:25:57,730 --> 00:26:03,410
То же самое, 1, потому что вы сходу, так сказать, вы изменили б равным.

413
00:26:03,410 --> 00:26:08,890
Поэтому, как только линия 37 была выполнена, это здорово, теперь у вас есть 2 экземпляра № 1

414
00:26:08,890 --> 00:26:13,350
Внутри этой функции, так что потом, когда вы говорите в строке 38 = B,

415
00:26:13,350 --> 00:26:17,640
Вы видов резьбовых потому что вы просто присвоении 1 к 1.

416
00:26:17,640 --> 00:26:20,580
Ты вроде потерял значение, которое вы заботились о.

417
00:26:20,580 --> 00:26:23,220
Таким образом, в оригинальную версию этой, обратите внимание, что я сделал.

418
00:26:23,220 --> 00:26:26,850
Вместо этого я была третья строка кода, которая выглядела следующим образом.

419
00:26:26,850 --> 00:26:28,580
Я заявляю, временных переменных.

420
00:26:28,580 --> 00:26:32,170
>> Tmp это очень распространенное имя для временной переменной, и это Int

421
00:26:32,170 --> 00:26:34,580
потому что он должен соответствовать тому, что я хочу сделать копию.

422
00:26:34,580 --> 00:26:39,770
Я храню копии внутри TMP, поэтому, как только линия 37 была выполнена,

423
00:26:39,770 --> 00:26:45,860
Значение это - быстрая проверка вменяемости - 1, значение Ь 2,

424
00:26:45,860 --> 00:26:48,970
и значение TMP также 1.

425
00:26:48,970 --> 00:26:52,060
Так что теперь я исполню линии 38.

426
00:26:52,060 --> 00:27:00,540
Как только линия 38 выполняется, принимает значение б. И В 2, так что теперь 2.

427
00:27:00,540 --> 00:27:05,210
Таким образом, на данный момент в этой истории, равно 2, B 2, а TMP 1,

428
00:27:05,210 --> 00:27:11,060
так что теперь логически, мы можем значения просто хлопнуть TMP в в б и мы сделали.

429
00:27:11,060 --> 00:27:12,800
Итак, мы решили эту проблему.

430
00:27:12,800 --> 00:27:17,720
К сожалению, когда я запускаю эту программу в таком виде, это на самом деле не поменять любые значения.

431
00:27:17,720 --> 00:27:20,100
Но чтобы быть понятным, почему?

432
00:27:23,660 --> 00:27:26,450
Я установил логические задачи из всего минуту назад,

433
00:27:26,450 --> 00:27:31,020
но опять же, если я запускаю эту программу, х и у, остаются неизменными

434
00:27:31,020 --> 00:27:33,310
К концу выполнения программы.

435
00:27:33,310 --> 00:27:37,220
[Неразборчиво комментарий студент] >> Мы не вернулись ничего, так что это правда.

436
00:27:37,220 --> 00:27:39,670
Но, оказывается, есть небольшая проблема здесь, потому что до сих пор,

437
00:27:39,670 --> 00:27:44,170
Единственное, что мы смогли вернуть это одно, и это ограничение C.

438
00:27:44,170 --> 00:27:49,070
Вы можете вернуть только действительно одно значение, и в этом случае я немного застрял здесь

439
00:27:49,070 --> 00:27:53,310
потому что я мог вернуть новое значение х, или я мог бы вернуть новое значение у,

440
00:27:53,310 --> 00:27:55,190
но я хочу и обратно.

441
00:27:55,190 --> 00:27:58,650
Таким образом, возвращения не простое решение здесь.

442
00:27:58,650 --> 00:28:01,710
Но проблема в корне почему? Что мы на самом деле поменялись местами?

443
00:28:01,710 --> 00:28:04,190
[Студент] а и б. >> А и б.

444
00:28:04,190 --> 00:28:08,230
Но и б являются копиями х и у, которая означает, что мы только что сделали все эти работы,

445
00:28:08,230 --> 00:28:11,650
Мы только что провели 3 минуты говорим о функции подкачки и все 3 из этих переменных,

446
00:28:11,650 --> 00:28:15,420
и это здорово, совершенно правильно в изоляции,

447
00:28:15,420 --> 00:28:20,740
но и сферу б лишь в этих строках.

448
00:28:20,740 --> 00:28:24,790
>> Так как цикл, если вы объявите целое я внутри цикла,

449
00:28:24,790 --> 00:28:28,760
Аналогично, если вы объявлением и б внутри функции, которые вы написали,

450
00:28:28,760 --> 00:28:33,320
они действительны только внутри этой функции, а значит, как только своп сделать выполнение

451
00:28:33,320 --> 00:28:38,470
и мы переходим от линии 24 в линию 25, х и у не изменилось.

452
00:28:38,470 --> 00:28:42,790
Вы просто впустую много времени, обмен копиями переменных.

453
00:28:42,790 --> 00:28:47,010
Вот и получается, что решение это на самом деле, не очевидно.

454
00:28:47,010 --> 00:28:50,670
Это не вполне достаточно, чтобы возвращать значения, потому что мы можем только вернуть значение 1,

455
00:28:50,670 --> 00:28:53,470
и я действительно хочу поменять х и у в то же время,

456
00:28:53,470 --> 00:28:55,210
так что мы собираемся иметь, чтобы вернуться к этому.

457
00:28:55,210 --> 00:29:01,020
Но сейчас понимаю, что вопрос принципиально вытекает из того факта, что А и В являются копиями

458
00:29:01,020 --> 00:29:03,630
и они находятся в своей собственной области.

459
00:29:03,630 --> 00:29:05,050
Давайте попробуем решить это в некотором роде.

460
00:29:05,050 --> 00:29:11,250
Позвольте мне на самом деле прокрутить назад здесь и открыть, скажем, четвертый вариант этого, buggy4.

461
00:29:11,250 --> 00:29:13,370
Что по этому поводу?

462
00:29:13,370 --> 00:29:17,810
Это похожие, но более простую задачу, чтобы смотреть на, прежде чем принять удар на ее решение.

463
00:29:17,810 --> 00:29:24,190
Эта программа называется приращением, и он, очевидно, инициализирует целое число х 1 в строке 18.

464
00:29:24,190 --> 00:29:28,150
Я тогда утверждать, х = 1, тогда я претендовать "инкремента ..."

465
00:29:28,150 --> 00:29:33,730
Затем я вызываю прирост, но затем в линиях 22 и 23, я утверждаю, что это было увеличивается,

466
00:29:33,730 --> 00:29:40,220
Я утверждаю х сейчас бы это ни было - 2, по-видимому, - но эта программа глючит.

467
00:29:40,220 --> 00:29:42,610
В чем проблема?

468
00:29:43,440 --> 00:29:50,160
Да. >> [Неразборчиво ответ студента] >> Именно так.

469
00:29:50,160 --> 00:29:52,490
Таким х было объявлено, очевидно, в строке 18.

470
00:29:52,490 --> 00:29:54,700
То есть в фигурных скобках основного автора.

471
00:29:54,700 --> 00:29:58,440
Так что однозначного ответа здесь является то, что в то время как х существует здесь,

472
00:29:58,440 --> 00:30:03,930
она не существует в строке 32, так что эта программа на самом деле даже не будет компилироваться.

473
00:30:03,930 --> 00:30:07,940
Компилятора, когда я пытаюсь компиляции данного кода будет кричать на меня

474
00:30:07,940 --> 00:30:14,100
О некоторых необъявленный идентификатор или что-то в этом роде. В самом деле, давайте попробуем.

475
00:30:14,100 --> 00:30:18,470
Это делает buggy4. Там она есть.

476
00:30:18,470 --> 00:30:22,110
Использование 'X' необъявленный идентификатор в строке 32.

477
00:30:22,110 --> 00:30:25,580
А на самом деле, давайте будем более четко здесь сегодня, так что это полезно

478
00:30:25,580 --> 00:30:27,580
в рабочее время и дома.

479
00:30:27,580 --> 00:30:29,300
>> Обратите внимание, что это немного загадочно написано.

480
00:30:29,300 --> 00:30:37,270
Но то, что Clang имеет кричал на нас, сказав buggy4.c: 32:5, на самом деле полезно.

481
00:30:37,270 --> 00:30:42,050
Это означает, что ошибка в строке 32 на позицию символа 5.

482
00:30:42,050 --> 00:30:46,700
Таким образом, 1, 2, 3, 4, 5. Это, в самом деле, где проблема.

483
00:30:46,700 --> 00:30:49,790
А также, тоже имейте в виду, в рабочее время и на дому, мне повезло здесь.

484
00:30:49,790 --> 00:30:52,990
У меня есть одна ошибка. Это собирается быть относительно легко исправить.

485
00:30:52,990 --> 00:30:55,990
Но если вы получите весь экран полный подавляющее сообщения об ошибках,

486
00:30:55,990 --> 00:31:00,330
еще раз осознать, что нижний можно просто быть симптомом самых верхних один.

487
00:31:00,330 --> 00:31:03,450
Так всегда гоняться за ваши ошибки сверху вниз

488
00:31:03,450 --> 00:31:05,820
потому что там может быть просто эффект цепочке

489
00:31:05,820 --> 00:31:09,240
, который предлагаю вам иметь намного больше проблем, чем вы на самом деле.

490
00:31:09,240 --> 00:31:15,150
Итак, как мы можем это исправить, если моей целью является, чтобы увеличить х? >> [Студент] Сделать х глобальной.

491
00:31:15,150 --> 00:31:17,060
Итак, мы можем сделать глобальное х.

492
00:31:17,060 --> 00:31:20,480
Давайте ярлык, который я предупреждал о более ранних, но черт возьми, нам просто нужно быстро исправить,

493
00:31:20,480 --> 00:31:25,730
так что давайте просто скажем, Int х здесь. Это делает х глобальной.

494
00:31:25,730 --> 00:31:31,800
Так что теперь основным имеет к ним доступ и приращение имеет к ним доступ,

495
00:31:31,800 --> 00:31:34,110
и поэтому позвольте мне идти дальше и собрать это сейчас.

496
00:31:34,110 --> 00:31:37,630
Сделать buggy4, Enter. Кажется, для компиляции сейчас.

497
00:31:37,630 --> 00:31:41,230
Давайте запустим buggy4. И, кажется, на самом деле работает.

498
00:31:41,230 --> 00:31:45,150
Это одна из этих вещей, которые делать, как я говорю, а не как я делаю,

499
00:31:45,150 --> 00:31:47,010
как я только что сделал здесь, потому что в целом,

500
00:31:47,010 --> 00:31:50,440
наши программы собираются получить гораздо интереснее и намного дольше, чем это,

501
00:31:50,440 --> 00:31:56,390
и если ваше решение жизненных проблем просто положить все переменные в начало файла,

502
00:31:56,390 --> 00:31:59,690
Очень быстро у программы получают ужасно трудно управлять.

503
00:31:59,690 --> 00:32:02,190
Это становится все труднее придумывать новые имена переменных,

504
00:32:02,190 --> 00:32:05,240
становится все труднее понять, что переменная делать то, что,

505
00:32:05,240 --> 00:32:08,460
и т.д. В общем, это не очень хорошее решение.

506
00:32:08,460 --> 00:32:10,030
Так давайте сделаем это лучше.

507
00:32:10,030 --> 00:32:12,160
Мы не хотим использовать глобальную переменную здесь.

508
00:32:12,160 --> 00:32:16,240
>> Я хочу, чтобы увеличить х, так что я мог бы, очевидно -

509
00:32:16,240 --> 00:32:18,670
В конце концов, это вроде глупой истории, потому что мы просто делаем это -

510
00:32:18,670 --> 00:32:24,450
но если бы я не знал о том, что оператор или я не смог изменить его в основной себе,

511
00:32:24,450 --> 00:32:30,730
Как еще я мог осуществлять Кен сюда на этот раз не в кубе, но для увеличения?

512
00:32:31,380 --> 00:32:33,190
Как изменить эту вещь здесь? Да.

513
00:32:33,190 --> 00:32:38,480
[Студент] Pass х, а затем вернуться [неразборчиво] >> Ладно, хорошо.

514
00:32:38,480 --> 00:32:41,900
Так почему бы мне не пройти в х, а затем, а не возвращать его,

515
00:32:41,900 --> 00:32:44,870
почему я не просто вернуть х + 1.

516
00:32:44,870 --> 00:32:47,710
Еще пара вещей нужно менять здесь. Я нахожусь на правильном пути.

517
00:32:47,710 --> 00:32:49,770
Что еще нужно настроить? Кто-то другой. Да.

518
00:32:49,770 --> 00:32:51,740
[Неразборчиво ответ студента]

519
00:32:51,740 --> 00:32:54,730
Мне нужно, чтобы изменить тип возврата прироста потому что это не аннулировать.

520
00:32:54,730 --> 00:32:57,780
Пустота ничего не средство возвращается, но ясно, теперь это,

521
00:32:57,780 --> 00:32:59,830
так что это нужно изменить, чтобы - >> [студент] Int.

522
00:32:59,830 --> 00:33:02,740
INT в соответствие с тем, что я на самом деле возвращения.

523
00:33:02,740 --> 00:33:05,180
Сейчас что-то еще по-прежнему багги здесь. Да.

524
00:33:05,180 --> 00:33:08,400
[Неразборчиво ответ студента] >> [Малан] Так что мне нужно увеличивать х?

525
00:33:08,400 --> 00:33:12,080
[Неразборчиво ответ студента] >> [Малан] Ах, так мне нужно передать х.

526
00:33:12,080 --> 00:33:16,660
Так что мне нужно сделать это здесь. >> [Неразборчиво комментарий студент]

527
00:33:16,660 --> 00:33:20,050
[Малан] Таким образом, прототип, я должен изменить это здесь.

528
00:33:20,050 --> 00:33:22,930
Таким образом, это должно стать INT, это должно стать -

529
00:33:22,930 --> 00:33:25,620
хм, я на самом деле есть ошибка здесь. Давайте исправим это в первую очередь.

530
00:33:25,620 --> 00:33:29,590
Что это на самом деле быть? Это должно быть что-то Int.

531
00:33:29,590 --> 00:33:32,700
Это может быть х, но, честно говоря, если начать называть всех ваших переменных х,

532
00:33:32,700 --> 00:33:35,390
это будет все менее и менее ясно, что есть что.

533
00:33:35,390 --> 00:33:39,560
>> Так что давайте просто произвольно выбрать различные именования для моего вспомогательные функции,

534
00:33:39,560 --> 00:33:41,940
Функции я пишу. Мы будем называть его, или мы могли бы назвать это -

535
00:33:41,940 --> 00:33:45,010
Давайте назовем это число будет еще более явным.

536
00:33:45,010 --> 00:33:47,560
И тогда я должен вернуть все, что номер плюс 1,

537
00:33:47,560 --> 00:33:50,740
и теперь я должен изменить 1 вещь, здесь и еще одна вещь здесь.

538
00:33:50,740 --> 00:33:54,350
Что я должен изменить в строке 21 в первую очередь? >> [Неразборчиво ответ студента]

539
00:33:54,350 --> 00:33:57,610
[Малан] Я должен назначить его на х. Я не могу просто позвонить приращение (х).

540
00:33:57,610 --> 00:34:01,960
Мне нужно помнить ответ на изменение значения х на левой стороне.

541
00:34:01,960 --> 00:34:04,680
И хотя х сейчас находится на левой и правой, это совершенно нормально

542
00:34:04,680 --> 00:34:08,860
потому что правая часть запускается на выполнение первого затем получает шлепнулся в левой вещь -

543
00:34:08,860 --> 00:34:10,600
х в этом случае.

544
00:34:10,600 --> 00:34:12,159
И тогда, наконец, это легко исправить сейчас.

545
00:34:12,159 --> 00:34:17,230
Это должно просто соответствовать тому, что вот внизу, внутр номер.

546
00:34:17,230 --> 00:34:20,570
Таким образом, целый букет изменений действительно глупо функции

547
00:34:20,570 --> 00:34:24,420
но представитель вещей, которые мы больше хотим сделать.

548
00:34:24,420 --> 00:34:27,090
Так что buggy4. Я где-то напортачили.

549
00:34:27,090 --> 00:34:30,139
О, мой Бог. Пять ошибок в 6-строчным программы.

550
00:34:30,139 --> 00:34:35,690
Так что же случилось на линии 18, символ 5?

551
00:34:35,690 --> 00:34:39,610
Так что я должен заявить об этом, внутр.

552
00:34:39,610 --> 00:34:41,920
Давайте посмотрим. Есть целая куча других ошибок.

553
00:34:41,920 --> 00:34:47,010
О, Боже мой - 19, 18, 21 - но, опять же, давайте просто очистить экран, управление L здесь,

554
00:34:47,010 --> 00:34:49,380
и перезапустить Clang.

555
00:34:49,380 --> 00:34:51,340
Таким образом, 5 задач на самом деле просто, что 1.

556
00:34:51,340 --> 00:34:57,520
Итак, теперь давайте запустим buggy4, Enter. Вот так, х был увеличен правильно.

557
00:34:57,520 --> 00:35:02,720
Хорошо. Любые вопросы о том, как увеличить число? Да.

558
00:35:02,720 --> 00:35:09,870
[Неразборчиво вопрос студента] >> Хороший вопрос.

559
00:35:09,870 --> 00:35:14,220
Как это, что я могу просто изменить х на номер, и программа будет знать сразу же?

560
00:35:14,220 --> 00:35:16,200
>> Опять же, думаю о нем, как это абстракция.

561
00:35:16,200 --> 00:35:21,600
Так что, если я главный и Кен прирост, честно говоря, я не волнует, что Кен называет свой iPad.

562
00:35:21,600 --> 00:35:26,570
Меня не волнует, что он называет все, что имеет отношение к его реализации этой функциональности.

563
00:35:26,570 --> 00:35:33,340
Это детали реализации, которые я, главное, не нужно заботиться о.

564
00:35:33,340 --> 00:35:38,250
И так просто изменив его последовательно внутри функции - здесь номер и номер здесь -

565
00:35:38,250 --> 00:35:40,960
Все это занимает так много времени, как я перекомпилировать.

566
00:35:40,960 --> 00:35:44,180
Это вроде как если вы думаете о многих из нас, тех, у кого водительские права

567
00:35:44,180 --> 00:35:46,770
которые въехали или если вы даже въехал в автомобиль,

568
00:35:46,770 --> 00:35:50,950
Большинство из нас не знают, как машина работает под капотом.

569
00:35:50,950 --> 00:35:54,970
И буквально, если вы открываете капот, большинство из нас - я в том числе -

570
00:35:54,970 --> 00:35:56,940
не собирается знаю, что мы смотрим на,

571
00:35:56,940 --> 00:35:59,220
вроде как вы можете чувствовать себя в такие вещи, как это прямо сейчас.

572
00:35:59,220 --> 00:36:01,480
Но мы действительно не должны заботиться, как машина работает,

573
00:36:01,480 --> 00:36:05,970
мы не должны заботиться, что все стержни и поршней и кабелей внутри автомобиля

574
00:36:05,970 --> 00:36:08,160
на самом деле делает.

575
00:36:08,160 --> 00:36:12,770
Так что-то вроде, что вы называете поршень здесь не имеет значения в данном случае. Та же самая идея.

576
00:36:12,770 --> 00:36:25,300
Да. >> [Неразборчиво вопрос студента]

577
00:36:25,300 --> 00:36:29,180
Если есть несколько видов переменная момент ха назад,

578
00:36:29,180 --> 00:36:32,150
Вы, программист, придется менять их повсюду.

579
00:36:32,150 --> 00:36:36,600
Или вы могли бы сделать буквально файлов, меню, а затем Найти, Заменить - что-то в этом роде -

580
00:36:36,600 --> 00:36:39,170
но вы будете иметь, чтобы сделать эти изменения самостоятельно.

581
00:36:39,170 --> 00:36:47,450
Вы должны быть последовательны. >> [Студент] При наличии нескольких переменных [неразборчиво]

582
00:36:47,450 --> 00:36:53,100
Определенном порядке, как здесь, если бы это было Int другой номер? >> [Студент] Правильно.

583
00:36:53,100 --> 00:36:56,590
[Малан] Да. Заказать имеет значение, когда вы вызываете функцию.

584
00:36:56,590 --> 00:37:00,050
>> Так что если я звонили прирост здесь что-то в этом запятой,

585
00:37:00,050 --> 00:37:01,680
есть прямое отображение.

586
00:37:01,680 --> 00:37:05,690
Первая переменная, как там это называется, сделал копию первого аргумента здесь.

587
00:37:05,690 --> 00:37:07,760
Извините. Это не должно быть круглых скобках.

588
00:37:07,760 --> 00:37:11,490
Второй аргумент линии с вторым. Так порядке, да, вопросов. Хорошо.

589
00:37:11,490 --> 00:37:17,020
Извините. Я взял длинный путь, чтобы добраться там. Другие вопросы? Хорошо.

590
00:37:17,020 --> 00:37:20,610
Итак, давайте посмотрим, если мы не можем нарисовать картину того, что происходит на самом деле здесь

591
00:37:20,610 --> 00:37:23,090
под капотом, так сказать.

592
00:37:23,090 --> 00:37:26,640
Это прямоугольник, который может представлять памяти компьютера.

593
00:37:26,640 --> 00:37:30,970
Даже если вы не представляете, как память работает или как RAM работ,

594
00:37:30,970 --> 00:37:33,940
по крайней мере, предположить, что у вас есть пучки она в эти дни.

595
00:37:33,940 --> 00:37:36,280
У вас есть мегабайт это, у вас есть гигабайты это,

596
00:37:36,280 --> 00:37:40,870
и мы знаем, от недели 0 байт, что именно то, что? >> [Студент] 8 бит.

597
00:37:40,870 --> 00:37:42,950
8 бит, не так ли? Таким образом, 8 нулей и 1.

598
00:37:42,950 --> 00:37:45,880
Итак, если ваш компьютер имеет гигабайт оперативной памяти, 2 гигабайтами оперативной памяти в эти дни,

599
00:37:45,880 --> 00:37:55,030
у вас есть миллиард или 2 млрд. байт памяти, или примерно 8 миллиардов или 16 миллиардов бит

600
00:37:55,030 --> 00:37:56,890
внутри компьютера.

601
00:37:56,890 --> 00:38:00,590
В отличие от небольшой пример Wooly Вилли, это не магнитные частицы обычно больше.

602
00:38:00,590 --> 00:38:04,450
Все чаще - в ноутбуках, по крайней мере, - это твердотельные накопители SSD,

603
00:38:04,450 --> 00:38:08,580
что просто не имеют движущихся частей. Это все электронные. Это все электричество основе.

604
00:38:08,580 --> 00:38:14,060
Так что думайте этого прямоугольника, как только представляет 1 или 2 гигабайтами памяти, что у вас есть.

605
00:38:14,060 --> 00:38:16,020
>> Так что это кусок памяти.

606
00:38:16,020 --> 00:38:19,830
Мир информатики рода отгорожена

607
00:38:19,830 --> 00:38:22,950
участки памяти, чтобы сделать разные вещи.

608
00:38:22,950 --> 00:38:27,190
Например, если это оперативной памяти компьютера, как это было предложено прямоугольник там,

609
00:38:27,190 --> 00:38:31,130
Оказывается, что по соглашению, в верхней части вашей памяти, так сказать,

610
00:38:31,130 --> 00:38:33,660
, как правило, то, что называется текстовый сегмент.

611
00:38:33,660 --> 00:38:36,740
Таковы 0 и 1, что вы собрали.

612
00:38:36,740 --> 00:38:39,020
Поэтому, когда мы смотрели под капотом на то, что a.out есть,

613
00:38:39,020 --> 00:38:41,980
Все эти 0 и 1, когда вы запускаете программу,

614
00:38:41,980 --> 00:38:46,290
тех, 0 и 1 загружается с жесткого диска в то, что называется RAM,

615
00:38:46,290 --> 00:38:49,320
и в оперативной памяти, они помещаются в верхней части.

616
00:38:49,320 --> 00:38:52,770
В то же время, у вас есть другие вещи: инициализация данных, инициализацию данных.

617
00:38:52,770 --> 00:38:57,510
Эти 2 валка памяти обратитесь к глобальные переменные, которые вы не часто используете

618
00:38:57,510 --> 00:39:00,760
но иногда, если вы это сделаете, они в конечном итоге там также.

619
00:39:00,760 --> 00:39:04,260
Тогда есть некоторые другие вещи: переменные окружения, которые мы не будем тратить много времени на,

620
00:39:04,260 --> 00:39:06,860
но затем 2 важные вещи, которые будут возвращаться в течение семестра,

621
00:39:06,860 --> 00:39:08,550
стека и кучи.

622
00:39:08,550 --> 00:39:12,210
Поэтому большинство из памяти компьютера сохраняется при запуске программы

623
00:39:12,210 --> 00:39:15,370
за то, что называется стеком и то, что называется кучей.

624
00:39:15,370 --> 00:39:18,840
Мы не собираемся говорить о куче сегодня, но мы будем говорить о стеке.

625
00:39:18,840 --> 00:39:24,600
Стек означало вызвать в воображении визуальные от столовой лотки зал еды в доме Mather

626
00:39:24,600 --> 00:39:28,110
или там, где вы будете где персонал столовой чистить их каждый день,

627
00:39:28,110 --> 00:39:30,180
они складывают их от пола на вверх,

628
00:39:30,180 --> 00:39:34,550
и, аналогично, в памяти, есть такая идея поставить что-то на стеке,

629
00:39:34,550 --> 00:39:36,860
положить что-то на стеке, положить что-то в стеке.

630
00:39:36,860 --> 00:39:38,240
И что же мы подразумеваем под этим?

631
00:39:38,240 --> 00:39:41,860
>> Давайте увеличить только на нижнюю половину этой картине, оперативной памяти компьютера,

632
00:39:41,860 --> 00:39:44,330
предложить следующее.

633
00:39:44,330 --> 00:39:48,170
Оказывается, что когда вы запускаете программу, как a.out или привет -

634
00:39:48,170 --> 00:39:50,100
независимо от программы является то, что вы написали -

635
00:39:50,100 --> 00:39:54,020
Опять же, те 0 и 1 загружается с жесткого диска, который длительное хранение,

636
00:39:54,020 --> 00:39:57,230
остается там, даже когда вы вилку, загружается в оперативную память.

637
00:39:57,230 --> 00:40:00,610
RAM быстрее, чем жесткие диски - это меньше, чем жесткие диски -

638
00:40:00,610 --> 00:40:03,300
но это там, где программы жить, пока вы работаете них.

639
00:40:03,300 --> 00:40:08,230
Таким образом, вы дважды щелкните программу на Mac или PC, она загружается с жесткого диска в оперативную память.

640
00:40:08,230 --> 00:40:11,520
Как только он будет загружен в оперативную память, 0 и 1 пойти на путь сверху,

641
00:40:11,520 --> 00:40:16,610
так называемых текстовых сегментов, но потом, как только ваша программа фактически начинает работать,

642
00:40:16,610 --> 00:40:21,360
Основная функция называется, а главное, как мы видели, часто имеет локальные переменные,

643
00:40:21,360 --> 00:40:24,870
и она имеет целых и строк и символов и тому подобное.

644
00:40:24,870 --> 00:40:29,180
Так что если ваши программы, которые вы написали или программы, которые вы двойном щелчке

645
00:40:29,180 --> 00:40:32,970
использовать некоторые переменные внутри основного,

646
00:40:32,970 --> 00:40:37,240
они в конечном итоге в нижней части вашего стека памяти, так сказать.

647
00:40:37,240 --> 00:40:39,410
Более конкретно, что же это на самом деле означает?

648
00:40:39,410 --> 00:40:48,450
Это просто означает, что если мы собираемся число байт оперативной памяти на вашем компьютере,

649
00:40:48,450 --> 00:40:55,750
заметить, что это может быть номер байта 0, это может быть номер байта 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
все, вплоть до 2 млрд. будет всю дорогу там на самом верху.

651
00:41:01,480 --> 00:41:05,880
Итак, другими словами, когда мы говорим об оперативной памяти или памяти в байтах,

652
00:41:05,880 --> 00:41:11,500
это просто означает, что кто-то решил, что нумеровать каждый из этих участков памяти.

653
00:41:11,500 --> 00:41:16,650
Поэтому, когда вам нужно 32 бита для Int или вам нужно 8 бит на символ,

654
00:41:16,650 --> 00:41:18,840
где они в конечном итоге в памяти?

655
00:41:18,840 --> 00:41:22,350
>> Концептуально, они просто в конечном итоге в нижней части этой вещи, называемой стеком.

656
00:41:22,350 --> 00:41:25,870
Но что интересно теперь, когда основные вызывает функцию -

657
00:41:25,870 --> 00:41:28,750
предположим, что функция называется Фу, просто произвольное название -

658
00:41:28,750 --> 00:41:32,330
что происходит, является основным находится в нижней части этого стека памяти;

659
00:41:32,330 --> 00:41:35,680
Foo теперь помещается в верхней части главного в памяти.

660
00:41:35,680 --> 00:41:40,990
Таким образом, любые локальные переменные, Foo была в конечном итоге рода концептуально выше, чем в основной.

661
00:41:40,990 --> 00:41:47,070
Если Foo вызывает другую функцию под названием бара, эти переменные в конечном итоге здесь.

662
00:41:47,070 --> 00:41:50,120
Если баре называет что-то еще, здесь, здесь, здесь.

663
00:41:50,120 --> 00:41:53,830
Так что же интересного о запуске программы является то, что, как вы вызываете функции

664
00:41:53,830 --> 00:41:57,750
и как эти функции вызывать функции и как эти функции называют функциями,

665
00:41:57,750 --> 00:42:01,470
Вы создаете этот стек функций в памяти.

666
00:42:01,470 --> 00:42:06,890
И только один раз функция возвращает вы начнете получать эту память обратно.

667
00:42:06,890 --> 00:42:10,860
Таким образом, одним из самых простых способов запустить из памяти в компьютерной программе

668
00:42:10,860 --> 00:42:14,360
, чтобы написать функции, которые никогда не вернутся.

669
00:42:14,360 --> 00:42:18,900
Так, например, давайте продемонстрировать, как много с намеренно багги программы.

670
00:42:18,900 --> 00:42:22,230
Позвольте мне идти вперед и делать # включить <stdio.h>,

671
00:42:22,230 --> 00:42:25,000
Int основных (недействительными),

672
00:42:25,000 --> 00:42:32,940
и я собираюсь делать, а (2> 1), который, вероятно, никогда не будет изменяться на нас,

673
00:42:32,940 --> 00:42:37,560
и позвольте мне теперь идти вперед и делать Printf.

674
00:42:37,560 --> 00:42:40,700
На самом деле, это будет менее визуально интересным. Давайте сделаем это.

675
00:42:40,700 --> 00:42:50,240
Для Int = 0;> 0 - давайте делать эту ошибку - я + +.

676
00:42:50,240 --> 00:42:52,720
И давайте не Printf здесь. Давайте практиковать то, что я проповедовал.

677
00:42:52,720 --> 00:43:00,190
Давайте здесь метод, недействительными хор, и мы будем говорить Int я,

678
00:43:00,190 --> 00:43:06,830
и тогда я буду говорить Printf - нет, давайте сделаем это более интересно.

679
00:43:06,830 --> 00:43:15,790
Давайте на самом деле не печатает вообще ничего. Давайте просто это сделать: хор (I).

680
00:43:15,790 --> 00:43:20,390
Хорошо. Так что это багги, потому что зачем?

681
00:43:20,390 --> 00:43:23,380
Я придумываю, как я иду, потому что программа на самом деле не делают ничего интересного.

682
00:43:23,380 --> 00:43:25,320
>> Но это не цель.

683
00:43:25,320 --> 00:43:29,630
Цель состоит в том, чтобы написать программу, основной функцией которого делает то, что, по-видимому?

684
00:43:30,720 --> 00:43:32,860
Позвоните себя. А на самом деле, мы не нуждаемся в петлю.

685
00:43:32,860 --> 00:43:37,200
Давайте даже упростить этот раз, чтобы не упускать из виду действительно фундаментальная ошибка.

686
00:43:37,200 --> 00:43:39,640
Главные вызовы хором петь хором,

687
00:43:39,640 --> 00:43:41,440
Затем я сделал что-то глупое и я должен был хор хор вызова

688
00:43:41,440 --> 00:43:43,760
потому что я предполагал, кто-то еще собирается осуществить это, может быть,

689
00:43:43,760 --> 00:43:47,210
и теперь это не будет собрать еще. Мне нужно сделать что?

690
00:43:47,210 --> 00:43:49,970
Мне нужно прототип, помню.

691
00:43:49,970 --> 00:43:56,110
Поэтому мне нужно, чтобы здесь пустота хора (INT я);

692
00:43:56,110 --> 00:43:59,210
Так что теперь, если я иду сюда - на самом деле, давайте использовать большие окна.

693
00:43:59,210 --> 00:44:01,980
Давайте пойдем дальше и сделать хором.

694
00:44:01,980 --> 00:44:06,490
Давайте пойдем дальше и сделать хором.

695
00:44:06,490 --> 00:44:08,370
Использование необъявленный идентификатор я.

696
00:44:08,370 --> 00:44:12,500
О, это было глупо. Нам не нужны аргументы. Давайте просто это сделать.

697
00:44:12,500 --> 00:44:16,370
Жаль, что мы начали этот путь. Было бы гораздо проще написать программу.

698
00:44:16,370 --> 00:44:25,590
Там же. Теперь давайте перейдем к моим окно терминала, повторно Clang, и здесь мы идем.

699
00:44:25,590 --> 00:44:28,460
Это было действительно быстро.

700
00:44:28,460 --> 00:44:31,150
Что на самом деле только что произошло, правда?

701
00:44:31,150 --> 00:44:33,730
Ну, теперь я добавлю печати линии, поэтому мы можем видеть.

702
00:44:33,730 --> 00:44:43,490
Позвольте мне сказать, Е ("я здесь") - не переменные. Мы оставим это так.

703
00:44:43,490 --> 00:44:47,480
Позвольте мне сделать повторно. Позвольте мне повторно хор.

704
00:44:47,480 --> 00:44:57,380
И ... давай. Продолжайте.

705
00:44:57,380 --> 00:44:59,930
Как в стороне, почему она не потерпела крах?

706
00:44:59,930 --> 00:45:02,080
Ошибки сегментации произошло супер быстрый раньше.

707
00:45:02,080 --> 00:45:06,570
[Неразборчиво ответ студента] >> Именно так. Так что это занимает время, чтобы напечатать, не так ли?

708
00:45:06,570 --> 00:45:08,610
Это займет больше работы со стороны компьютера.

709
00:45:08,610 --> 00:45:10,620
И вот это: ошибки сегментации.

710
00:45:10,620 --> 00:45:12,340
>> Так заметите, как быстро запускать программы.

711
00:45:12,340 --> 00:45:14,130
Если вы не печатает ничего, супер быстро.

712
00:45:14,130 --> 00:45:18,770
Но мы все же получили эту ошибку сегментации, потому что то, что происходит?

713
00:45:18,770 --> 00:45:21,210
Если вы думаете о том, как память компьютера выкладывается,

714
00:45:21,210 --> 00:45:28,740
В этом случае, чтобы быть основным, но вот давайте просто называть этот хор, и давайте называть это хор.

715
00:45:28,740 --> 00:45:34,550
И теперь, если я делаю свою эстетику права, это просто будет сказать, хор, хор, хор,

716
00:45:34,550 --> 00:45:40,550
хор, хор, хор, хор, до тошноты, и в конце концов, то, что произойдет?

717
00:45:40,550 --> 00:45:45,630
Если большая картина, в буквальном смысле, это то, что просто происходит концептуально?

718
00:45:46,520 --> 00:45:48,630
Стек перерасход кучи.

719
00:45:48,630 --> 00:45:51,940
Или, что еще хуже, вы просто захвачены все, включая текст сегмента,

720
00:45:51,940 --> 00:45:54,590
которая является 0 и 1, которые представляют вашу программу.

721
00:45:54,590 --> 00:45:57,080
Короче говоря, это просто супер, супер плохого.

722
00:45:57,080 --> 00:45:58,830
Ваша программа вышла из-под контроля.

723
00:45:58,830 --> 00:46:01,220
Вы используете способ больше памяти, чем предполагалось

724
00:46:01,220 --> 00:46:03,960
все из-за глупой ошибки в данном случае,

725
00:46:03,960 --> 00:46:08,040
или в данном случае совершенно сознательно сделали функцию, называющая себя.

726
00:46:08,040 --> 00:46:09,500
Так вот, это не так уж плохо.

727
00:46:09,500 --> 00:46:13,800
Функции, называющих себя действительно имеет большую силу, когда вы используете его правильно.

728
00:46:13,800 --> 00:46:15,800
Я не использовал его правильно здесь.

729
00:46:15,800 --> 00:46:19,780
Так что не все так плохо, но то, что я никогда не перестанут называть себя

730
00:46:19,780 --> 00:46:23,520
является фундаментальной слабостью здесь этой программы.

731
00:46:23,520 --> 00:46:26,400
Так куда мы идем со всем этим? Что на самом деле происходит?

732
00:46:26,400 --> 00:46:30,340
Когда я называю приращение функции, как мы делали в тех примерах,

733
00:46:30,340 --> 00:46:33,420
У меня есть значение, как 1, что я прохожу дюйма

734
00:46:33,420 --> 00:46:37,570
Я прохожу в копии номер 1, так происходит следующее.

735
00:46:37,570 --> 00:46:44,240
Пойдем в приращения, например, этот парень прямо здесь.

736
00:46:44,240 --> 00:46:46,870
Вот что на самом деле происходит.

737
00:46:46,870 --> 00:46:53,400
Когда я называю прирост и я прохожу по х, графически, что происходит вот это.

738
00:46:53,400 --> 00:46:59,520
>> Если у меня есть стоимость 1 хранится здесь, и я на самом деле зовут прирост,

739
00:46:59,520 --> 00:47:04,330
которая теперь называется хор - Ipad бросает меня здесь.

740
00:47:04,330 --> 00:47:09,760
Давайте назовем это приращение, и мы не знаем, что это следующая функция будет.

741
00:47:09,760 --> 00:47:14,840
Так что же на самом деле происходит где-то здесь в основном у меня есть кусок памяти

742
00:47:14,840 --> 00:47:17,000
, который хранится номер 1.

743
00:47:17,000 --> 00:47:19,380
Когда я называю прирост, я использую другую часть памяти,

744
00:47:19,380 --> 00:47:21,230
но теперь у меня есть копия 1.

745
00:47:21,230 --> 00:47:26,660
Когда я увеличить это значение, это становится 2,

746
00:47:26,660 --> 00:47:30,560
но что происходит потом, как только прирост прибыли?

747
00:47:30,560 --> 00:47:33,630
Эта память просто получает вернул к операционной системе,

748
00:47:33,630 --> 00:47:37,450
которое означает, что все, что вы сделали ничего полезного.

749
00:47:37,450 --> 00:47:43,120
1, который был первоначально содержались в основном по-прежнему на самом деле.

750
00:47:43,120 --> 00:47:44,890
Так куда мы идем с этим?

751
00:47:44,890 --> 00:47:49,770
Оказывается, что в памяти у вас есть эта спина к спине последовательность байтов

752
00:47:49,770 --> 00:47:53,050
что вы можете положить вещи в, и оказывается, что мы уже видели нечто

753
00:47:53,050 --> 00:47:55,390
который включает в себя наведение спиной к спине, чтобы спина к спине.

754
00:47:55,390 --> 00:47:59,860
Что представляет собой строку, основываясь на неделе 1, и теперь неделя 2?

755
00:48:00,020 --> 00:48:01,980
Это просто набор символов.

756
00:48:01,980 --> 00:48:04,310
Вот и получается, как вы можете поставить номера в памяти,

757
00:48:04,310 --> 00:48:06,990
Точно так же вы можете положить символов в памяти.

758
00:48:06,990 --> 00:48:10,530
И как только мы начинаем положить символов в памяти спиной к спине, чтобы спина к спине,

759
00:48:10,530 --> 00:48:13,620
Оказывается, что с помощью простейших вещей, как для цикла или время цикла,

760
00:48:13,620 --> 00:48:17,170
мы можем повторять слева направо по символов в строке

761
00:48:17,170 --> 00:48:20,600
и начать массируя их в разные персонажи в целом -

762
00:48:20,600 --> 00:48:23,370
может стать B, B мог бы стать C -

763
00:48:23,370 --> 00:48:27,780
так что в конечном счете, мы можем принять английское предложение, что на самом деле имеет смысл

764
00:48:27,780 --> 00:48:30,310
и конвертировать каждую из этих писем по одному

765
00:48:30,310 --> 00:48:34,400
пешком через нашу память компьютера слева направо на самом деле шифрования.

766
00:48:34,400 --> 00:48:35,810
Итак, давайте сделаем наш пятиминутный перерыв здесь,

767
00:48:35,810 --> 00:48:40,730
и когда мы вернемся, мы начнем этот процесс скремблирования информации.

768
00:48:42,020 --> 00:48:43,520
>> Хорошо.

769
00:48:43,520 --> 00:48:48,070
Прежде чем мы углубимся в некоторые шифрования и эти вещи называются массивами,

770
00:48:48,070 --> 00:48:51,470
Позвольте мне паузу на любые вопросы, потому что я чувствую, что я действительно добрый опьянелых

771
00:48:51,470 --> 00:48:54,080
некоторые из этих вопросов. Так что давайте зафиксируем теперь, если мы можем.

772
00:48:54,080 --> 00:48:58,700
Мы только что говорили о возвращении ценностей, о которых мы говорили аргументы,

773
00:48:58,700 --> 00:49:03,250
и мы говорили об этом понятии, которое мы вернемся в ближайшие недели,

774
00:49:03,250 --> 00:49:08,720
просмотра памяти целую кучу этих сложенных лотках, так сказать,

775
00:49:08,720 --> 00:49:12,660
снизу на вверх, так, что каждый лоток, который получает положить в стек

776
00:49:12,660 --> 00:49:16,530
представляет собой функцию, которая в настоящее время называется.

777
00:49:17,900 --> 00:49:20,260
Есть вопросы?

778
00:49:20,260 --> 00:49:22,640
Позвольте мне задать вопрос здесь.

779
00:49:22,640 --> 00:49:27,890
Позвольте мне упростить это к тому, что было до некоторых из наших ранних Q & A.

780
00:49:27,890 --> 00:49:35,570
Тот факт, что прирост имеет открытую скобку, внутр номер, закрытый скобках -

781
00:49:35,570 --> 00:49:39,110
Что же Int числа представляют?

782
00:49:39,110 --> 00:49:42,790
[Студент] аргумент. >> Аргумент. Хорошо. Но то, что аргумент?

783
00:49:42,790 --> 00:49:46,370
[Неразборчиво ответ студента] >> Что это такое? >> [Студент] То, что вы передаете дюйма

784
00:49:46,370 --> 00:49:49,940
Итак, то, что вы передаете дюйма И вообще, это просто вход.

785
00:49:49,940 --> 00:49:52,450
Если бы вы писали функции и цели, которые функционируют в жизни

786
00:49:52,450 --> 00:49:55,770
должен сделать что-то немного другое каждый раз, когда вы используете его,

787
00:49:55,770 --> 00:50:00,110
, то единственный способ, чтобы это произошло на самом деле, казалось бы предоставить ему вход

788
00:50:00,110 --> 00:50:03,510
так что он может сделать что-то другое с помощью этого вклада каждый раз.

789
00:50:03,510 --> 00:50:06,650
>> Таким образом, вы должны определить две вещи, когда функция принимает вход.

790
00:50:06,650 --> 00:50:09,590
Вы должны указать имя, которое вы хотите дать, что входной

791
00:50:09,590 --> 00:50:12,700
исключительно для вашего удобства, чтобы вы могли обратиться к нему

792
00:50:12,700 --> 00:50:16,540
В функции, которые вы сами пишете, как я сделал здесь, в строке 32.

793
00:50:16,540 --> 00:50:20,800
Но вы также должны указать его тип, потому что C является языком программирования

794
00:50:20,800 --> 00:50:25,940
что именно требуется, если вы хотите переменной, вы должны сообщить компьютеру, какой тип данных она есть,

795
00:50:25,940 --> 00:50:30,200
В большей части так, чтобы он не знает, сколько битов выделить для этой переменной

796
00:50:30,200 --> 00:50:33,020
потому что это может быть 6 - извините, это не будет 6.

797
00:50:33,020 --> 00:50:37,080
Это может быть 16, может быть 8, это может быть 32, даже 64,

798
00:50:37,080 --> 00:50:39,130
но компьютер должен знать.

799
00:50:39,130 --> 00:50:43,180
Теперь, внутр на левой стороне представляет то, что, в отличие от?

800
00:50:46,350 --> 00:50:48,850
[Неразборчиво ответ студента] >> Что это такое? >> [Студент] Тип функции.

801
00:50:48,850 --> 00:50:53,610
Тип функции и, более конкретно, типа своей продукции. Право.

802
00:50:53,610 --> 00:50:57,380
Таким образом, в то время как вещь в скобках представляет свой вход, если таковые имеются,

803
00:50:57,380 --> 00:50:59,660
вещь, чтобы левая представляет свою продукцию.

804
00:50:59,660 --> 00:51:03,530
И в этом случае, по-видимому прирост возвращает целое,

805
00:51:03,530 --> 00:51:07,690
и так Int является типом возвращаемого этой функцией.

806
00:51:07,690 --> 00:51:09,340
Что это значит вернуть?

807
00:51:09,340 --> 00:51:15,090
Буквально, вы используете ключевое слово возвращение и то, если то, что вы возвращаете

808
00:51:15,090 --> 00:51:18,600
справа от ключевого слова является целым числом,

809
00:51:18,600 --> 00:51:21,660
то, что действительно соответствует тому, что мы обещали.

810
00:51:21,660 --> 00:51:26,410
Вы не могли бы сделать что-то вроде этого - Здравствуй, мир - потому что это строка.

811
00:51:26,410 --> 00:51:28,860
>> Очевидно, это не является целым числом.

812
00:51:28,860 --> 00:51:33,140
Короче говоря, бремя на самом деле на нас, программистов, для определенности

813
00:51:33,140 --> 00:51:37,770
о том, что мы возвращаемся, и тогда на самом деле идти о возвращении его.

814
00:51:37,770 --> 00:51:43,440
Контекст здесь, сейчас, в том, что память компьютера составляет один гигабайт, 2 гигабайта -

815
00:51:43,440 --> 00:51:45,920
что угодно, - может быть, это больше, может быть, это меньше,

816
00:51:45,920 --> 00:51:49,050
но компьютер рассматривает ее как имеющие различные разделы.

817
00:51:49,050 --> 00:51:51,200
Что-то идет туда, что-то еще происходит там, наверху,

818
00:51:51,200 --> 00:51:54,290
различные вещи идет в середине, и сегодня мы только начинаем рассказывать историю,

819
00:51:54,290 --> 00:51:56,340
но мы вернемся к этому с течением времени.

820
00:51:56,340 --> 00:51:59,980
В настоящее время, только кусок памяти мы действительно заботимся о том, текстовый сегмент

821
00:51:59,980 --> 00:52:03,360
потому что только что представляет 0 и 1, что Clang был сигнал.

822
00:52:03,360 --> 00:52:06,050
Итак, когда вы запустите команду на клавиатуре, как a.out

823
00:52:06,050 --> 00:52:09,110
или вы дважды щелкните значок на Mac OS или Windows,

824
00:52:09,110 --> 00:52:11,880
Ваша программа загружается с жесткого диска в оперативную память

825
00:52:11,880 --> 00:52:16,330
и он шлепнулся в верхней части оперативной памяти компьютера, так сказать.

826
00:52:16,330 --> 00:52:20,450
Между тем, как ваша программа начинает работать и основные вызывается

827
00:52:20,450 --> 00:52:23,640
В программе вы писали или программы Microsoft или Apple, пишет,

828
00:52:23,640 --> 00:52:27,860
любого из ее локальные переменные в конечном итоге там на дне памяти компьютера.

829
00:52:27,860 --> 00:52:33,230
Но если основные вызовы другую функцию, которая сама по себе имеет переменные или аргументы, они в конечном итоге над ним.

830
00:52:33,230 --> 00:52:36,680
И если эта функция вызывает то, что они в конечном итоге над ним, над ним, над ним.

831
00:52:36,680 --> 00:52:41,460
>> И только один раз в функции осуществляется выполнением ли стек лотков, так сказать,

832
00:52:41,460 --> 00:52:43,240
начинают получать все ниже и ниже.

833
00:52:43,240 --> 00:52:48,250
И это то, что тогда, в двух словах, объясняет, почему, когда вы звоните кубе

834
00:52:48,250 --> 00:52:51,550
или вы звоните прирост, вы передаете копию значения.

835
00:52:51,550 --> 00:52:55,520
А что это означает, что наглядно это то, что вы буквально написания номер 1

836
00:52:55,520 --> 00:53:00,460
В другой части памяти, изменения, что с 1 по 2 в случае приращения

837
00:53:00,460 --> 00:53:04,820
или 8 в случае куба, а затем бросали, что память далеко

838
00:53:04,820 --> 00:53:09,140
как только увеличения или возврата куб функции. Вопрос.

839
00:53:09,140 --> 00:53:12,900
[Студент] Где глобальные переменные хранятся?

840
00:53:12,900 --> 00:53:18,100
Глобальные переменные хранятся в то, что в настоящее время называется инициализируются данные или неинициализированных данных,

841
00:53:18,100 --> 00:53:21,920
разница в том, если у вас есть глобальная переменная и вы назначаете его сразу же значение

842
00:53:21,920 --> 00:53:24,640
с знак равенства, она заканчивается на вершине,

843
00:53:24,640 --> 00:53:29,200
и если вы просто говорите Int х, без значения, это заканчивается немного ниже, в оперативной памяти

844
00:53:29,200 --> 00:53:31,710
Просто по соглашению.

845
00:53:31,710 --> 00:53:34,940
Другие вопросы? Хорошо.

846
00:53:34,940 --> 00:53:37,340
Таким образом, эта картина будет возвращаться, как мы получим более мощный

847
00:53:37,340 --> 00:53:39,170
с тем, что мы можем сделать с компьютером,

848
00:53:39,170 --> 00:53:42,720
но сейчас, давайте краткое введение в криптографию,

849
00:53:42,720 --> 00:53:46,080
определенный тип шифрования, не решает всех проблем в мире

850
00:53:46,080 --> 00:53:47,720
но решить некоторые из них.

851
00:53:47,720 --> 00:53:51,700
В этом случае здесь, у нас есть то, что называется секретным ключом.

852
00:53:51,700 --> 00:53:56,410
Секретным ключом, как следует из названия, происходит ее безопасности от тайной.

853
00:53:56,410 --> 00:54:00,690
>> Например, если вы были еще в начальной школе, и вы проходили немного любовное письмо тайного

854
00:54:00,690 --> 00:54:04,850
к мальчику или девочке вы давили на, если вы хотели передать эту записку по аудитории,

855
00:54:04,850 --> 00:54:08,380
Вы, вероятно, не будет писать такую ​​записку на английском языке или что ваш родной язык.

856
00:54:08,380 --> 00:54:13,340
Вместо этого, вы можете зашифровать или вы можете просто отправить им текстовое сообщение в эти дни.

857
00:54:13,340 --> 00:54:15,460
Но вы могли бы на самом деле передают их к сведению всем классе.

858
00:54:15,460 --> 00:54:18,700
И сделать это надежно таким образом, что ваши друзья и учителя

859
00:54:18,700 --> 00:54:22,650
Не знаю, что вы пишете, вы можете придумать достаточно простой алгоритм,

860
00:54:22,650 --> 00:54:25,920
Молодой хотя вы могли бы быть, просто карабкаться слова.

861
00:54:25,920 --> 00:54:28,130
Таким образом, вместо того, чтобы писать вы можете написать б,

862
00:54:28,130 --> 00:54:30,220
вместо б вы могли бы написать с,

863
00:54:30,220 --> 00:54:32,140
вместо того, чтобы с вами могли бы написать D, и так далее.

864
00:54:32,140 --> 00:54:34,360
Или вы могли бы придумать более сложный перевод

865
00:54:34,360 --> 00:54:36,720
писем в разные буквы.

866
00:54:36,720 --> 00:54:39,740
Но загвоздка в том, мальчик или девочка, которым вы отправляете эту заметку

867
00:54:39,740 --> 00:54:45,020
нужно знать что-то, что и, очевидно? >> [Студент] Что вы отправляете.

868
00:54:45,020 --> 00:54:49,720
Какой ваш секрет, как и то, что в том, что соответствие между а и Ь и с и д ы.

869
00:54:49,720 --> 00:54:54,650
Это только добавление 1 к каждой из букв, чтобы перейти от А до Б, В к С?

870
00:54:54,650 --> 00:54:56,670
Это более сложный, чем это?

871
00:54:56,670 --> 00:55:01,540
>> Таким образом, вы и ваш раздавить должны иметь эту секретную информацию,

872
00:55:01,540 --> 00:55:03,190
но есть виды Catch-22 здесь.

873
00:55:03,190 --> 00:55:06,830
Если это в первый раз вы отправляете эту любовь письмо через класс,

874
00:55:06,830 --> 00:55:10,720
Как это мальчик или девочка будет знать, в чем секрет даже есть?

875
00:55:10,720 --> 00:55:13,930
Так что секретный ключ шифрования не решает всех проблем в мире,

876
00:55:13,930 --> 00:55:16,320
и есть на самом деле связь здесь, что мы вернемся к к концу семестра.

877
00:55:16,320 --> 00:55:25,110
Точно так же большинство из нас не знает, что кто-то работает, например, на Amazon.com,

878
00:55:25,110 --> 00:55:28,190
и все же многие из нас, наверное, купил материал в Amazon.com,

879
00:55:28,190 --> 00:55:31,990
и нас учили считать, что эти транзакции электронной торговли находятся в безопасности.

880
00:55:31,990 --> 00:55:36,470
URL, вероятно, говорит HTTPS, есть, может быть, глупый маленький значок замка где-то,

881
00:55:36,470 --> 00:55:39,930
есть какая-то криптографии обеспечении информации о кредитной карте

882
00:55:39,930 --> 00:55:42,160
между вами и Amazon.com.

883
00:55:42,160 --> 00:55:45,430
И все же, если криптография включает в себя знание какой-то секрет

884
00:55:45,430 --> 00:55:48,620
И все же я не знаю никого, на Амазонке, и я, конечно, не устроил любой секрет

885
00:55:48,620 --> 00:55:52,710
с кем-то на Amazon, как мой компьютер или мой браузер это делает?

886
00:55:52,710 --> 00:55:55,720
Оказывается, есть другие виды криптографии вообще, что решить эту проблему.

887
00:55:55,720 --> 00:55:57,670
Но на сегодняшний день, мы сосредоточимся на простой

888
00:55:57,670 --> 00:56:00,290
, где можно организовать заранее знать некоторые тайные

889
00:56:00,290 --> 00:56:03,760
+1 или как некоторое отображение между а и б о.

890
00:56:03,760 --> 00:56:05,840
И процесс криптографии обычно включает в себя это.

891
00:56:05,840 --> 00:56:08,620
У вас есть обычный текст, изображенный здесь, на левом,

892
00:56:08,620 --> 00:56:12,930
вы запускаете его через какой-то алгоритм или процедура шифрования -

893
00:56:12,930 --> 00:56:15,100
Может быть, это просто становится B, B становится с -

894
00:56:15,100 --> 00:56:17,490
и тогда вы в конечном итоге с зашифрованного текста.

895
00:56:17,490 --> 00:56:20,380
Между тем, как только ваш раздавить получает эту тайну, обратите внимание,

896
00:56:20,380 --> 00:56:24,200
Он или она должен расшифровать его, как правило задним ходом, что алгоритм

897
00:56:24,200 --> 00:56:27,190
таким образом, чтобы вернуть обычный текст.

898
00:56:27,190 --> 00:56:28,960
Есть физические воплощения этого.

899
00:56:28,960 --> 00:56:31,680
>> Например, это колечко декодер секрет,

900
00:56:31,680 --> 00:56:35,110
и это кольцо в том смысле, что есть два набора здесь.

901
00:56:35,110 --> 00:56:38,490
На внешней периферии этой вещью, есть буквы от А до Z,

902
00:56:38,490 --> 00:56:40,340
хотя они в случайном порядке,

903
00:56:40,340 --> 00:56:42,880
и с внутренней стороны, там на самом деле некоторые цифры

904
00:56:42,880 --> 00:56:46,620
такие, что с этим кольцом Вы можете включить вид снаружи, но не внутри

905
00:56:46,620 --> 00:56:49,140
для того, чтобы выстроить номера с буквами.

906
00:56:49,140 --> 00:56:53,020
Из фильма под названием Рождественская история, вы увидите, что мало Ральфи

907
00:56:53,020 --> 00:56:58,000
так не терпелось выяснить, что секретное сообщение Little Orphan Annie была для него

908
00:56:58,000 --> 00:57:02,570
что было сообщено, я думаю, в виде числовых сообщения на коробки от хлопьев

909
00:57:02,570 --> 00:57:07,220
и нужно было собрать все маленькие карты, которые пришли в зерновых окна,

910
00:57:07,220 --> 00:57:09,770
Вы должны были отправить им по почте, вы должны были вернуться тайну кольца декодер

911
00:57:09,770 --> 00:57:13,910
так что вы можете, наконец, выяснить, что отображение между буквами и цифрами

912
00:57:13,910 --> 00:57:15,550
или букв и букв.

913
00:57:15,550 --> 00:57:19,520
Как в компьютере мы можем идти о реализации или представляющие такие вещи?

914
00:57:19,520 --> 00:57:22,560
Нам нужно найти способ выразить себя немного более гибко

915
00:57:22,560 --> 00:57:25,080
чем наши переменные до сих пор позволил.

916
00:57:25,080 --> 00:57:29,000
У нас были целыми, у нас были символы, которые мы имели поплавки и двухместные и некоторые другие,

917
00:57:29,000 --> 00:57:34,200
но эти отдельные части памяти, которая на самом деле не позволяют выразить вещи

918
00:57:34,200 --> 00:57:36,440
как слова и предложения и фразы.

919
00:57:36,440 --> 00:57:38,630
В самом деле, мы называли такие строки вещи,

920
00:57:38,630 --> 00:57:42,660
но мы обещаем, что это действительно просто упрощение CS50 библиотеки

921
00:57:42,660 --> 00:57:45,540
что мы намерены отогните.

922
00:57:45,540 --> 00:57:47,500
И так, давайте начнем делать это здесь.

923
00:57:47,500 --> 00:57:49,840
Позвольте мне идти вперед и открывать файл -

924
00:57:49,840 --> 00:57:54,100
Все эти файлы доступны, как обычно, онлайн - называемые array.c

925
00:57:54,100 --> 00:57:58,960
решить проблему, не связанных с строками, но это рисует картину здесь

926
00:57:58,960 --> 00:58:01,520
о том, как мы могли бы использовать то, что называется массивом.

927
00:58:01,520 --> 00:58:04,050
>> Массив представляет собой тип данных.

928
00:58:04,050 --> 00:58:10,730
Это тип переменной рода, который имеет несколько меньшие типы данных внутри него

929
00:58:10,730 --> 00:58:12,680
спиной к спине, чтобы спина к спине.

930
00:58:12,680 --> 00:58:16,980
Так, например, если мы хотим написать небольшую программу, которая дает вам ваш тест среднего

931
00:58:16,980 --> 00:58:19,780
на курс, как 50, которая имеет 2 викторины,

932
00:58:19,780 --> 00:58:23,450
Вы можете очень легко написать эту программу, основанную даже на некоторых из материала на прошлой неделе

933
00:58:23,450 --> 00:58:28,830
с помощью GetInt и несколько переменных: Int quiz1, внутр quiz2.

934
00:58:28,830 --> 00:58:30,550
И это довольно просто.

935
00:58:30,550 --> 00:58:33,500
Это может быть 10, 20 строк кода, максимальная реализация программы

936
00:58:33,500 --> 00:58:38,940
, который просит пользователя в течение 2 баллов викторины и затем вычисляет их среднее

937
00:58:38,940 --> 00:58:42,020
, складывая их вместе, деля на 2, а затем печати результатов.

938
00:58:42,020 --> 00:58:46,400
Мы могли бы сделать это довольно легко сейчас, после некоторого количества минут.

939
00:58:46,400 --> 00:58:49,450
Но проблема в том, что предположим, что 50 было 3 или 4 викторины.

940
00:58:49,450 --> 00:58:52,830
Предположим, что вы хотели использовать ту же программу для класса, который был еженедельные викторины.

941
00:58:52,830 --> 00:58:55,100
Подумайте о классе, который еженедельные викторины.

942
00:58:55,100 --> 00:58:58,840
Если есть 16 или так недель в семестр, теперь у вас есть 16 переменных:

943
00:58:58,840 --> 00:59:03,030
quiz1 Int, Int quiz2, внутр quiz3, внутр quiz4.

944
00:59:03,030 --> 00:59:06,870
Как только вы начинаете видеть эту избыточность, это скопировать и вставить код,

945
00:59:06,870 --> 00:59:09,810
он должен начать делать вы хотите там было лучше.

946
00:59:09,810 --> 00:59:13,610
И к счастью, потому что массивы есть. Так давайте сделаем это.

947
00:59:13,610 --> 00:59:16,700
Во-первых, позвольте мне представить очень простую вещь, что мы не использовали до сих пор,

948
00:59:16,700 --> 00:59:18,820
но вы увидите, что иногда в коде.

949
00:59:18,820 --> 00:59:21,270
>> Это то, что обычно называется постоянной.

950
00:59:21,270 --> 00:59:24,410
Так что это постоянная в том смысле, что это значение никогда не меняется.

951
00:59:24,410 --> 00:59:26,450
Человеческие конвенции при создании постоянной

952
00:59:26,450 --> 00:59:30,420
является использование всех заглавных букв просто так, что он действительно выделяется в коде,

953
00:59:30,420 --> 00:59:34,270
и специальные ключевые слова, которые вы используете в С # определить.

954
00:59:34,270 --> 00:59:39,970
Поэтому мы говорим, # определить, то пространство, то слово, которое вы хотите использовать для названия константы

955
00:59:39,970 --> 00:59:41,730
, а затем значение константы.

956
00:59:41,730 --> 00:59:44,710
Обратите внимание, что это отличается от присвоения что-то переменная.

957
00:59:44,710 --> 00:59:46,430
Там нет знака равенства, нет запятой.

958
00:59:46,430 --> 00:59:49,140
Это то, что известно как директива препроцессора,

959
00:59:49,140 --> 00:59:50,840
но об этом в другой раз.

960
00:59:50,840 --> 00:59:56,350
На данный момент, это создает неизменное значение, называемое викторины

961
00:59:56,350 --> 00:59:58,290
, фактическое числовое значение 2.

962
00:59:58,290 --> 01:00:02,180
Таким образом, везде, где есть тесты, викторины, тесты на протяжении всего этого файла,

963
01:00:02,180 --> 01:00:04,230
вот только номер 2.

964
01:00:04,230 --> 01:00:06,550
Если я смотрю на основные Теперь, давайте посмотрим, как это работает.

965
01:00:06,550 --> 01:00:09,770
Сначала это выглядит немного загадочно, но это все вещи из неделе 1.

966
01:00:09,770 --> 01:00:12,210
Спросите у пользователя классах. Как мы это делаем?

967
01:00:12,210 --> 01:00:17,350
В строке 22 - это действительно сочные части - я заявляю, поплавок

968
01:00:17,350 --> 01:00:23,240
но не только одним поплавком. Я объявив, скорее, массив значений с плавающей точкой.

969
01:00:23,240 --> 01:00:27,700
Это переменная будет называться классах, как это подразумевается здесь,

970
01:00:27,700 --> 01:00:31,420
но только часть нового синтаксиса, то эти квадратные скобки.

971
01:00:31,420 --> 01:00:37,280
Тот факт, что я сказал поплавок классах, а затем открыть скобку, а затем номер -

972
01:00:37,280 --> 01:00:40,980
заметит, если это постоянная это так же, как мы сделали это -

973
01:00:40,980 --> 01:00:46,840
это означает: "Эй, компьютер, дайте мне 2 поплавка и давайте коллективно называют их оценки."

974
01:00:46,840 --> 01:00:51,780
>> Это в отличие от гораздо более трудоемкий процесс следующим образом: поплавок Grade1;

975
01:00:51,780 --> 01:00:54,580
grade2 плавать, и так далее.

976
01:00:54,580 --> 01:00:58,310
Таким образом, массив позволяет нам реализовать эту идею, но гораздо менее неряшливо,

977
01:00:58,310 --> 01:01:04,560
таким образом, что мы можем написать 1 строку кода, а не, скажем, 16 на 16-недельный семестр.

978
01:01:04,560 --> 01:01:09,060
Я не хочу, чтобы закодировать 2, потому что, если вы думаете об этом теперь логически,

979
01:01:09,060 --> 01:01:12,560
Предположим, в следующем году CS50 изменений до 3 викторины вместо

980
01:01:12,560 --> 01:01:15,010
и у меня был номер 2 здесь, у меня был номер 2 здесь,

981
01:01:15,010 --> 01:01:17,210
У меня был номер 2 здесь, номер 2 здесь.

982
01:01:17,210 --> 01:01:19,890
Она становится очень утомительным и очень легко испортить

983
01:01:19,890 --> 01:01:26,550
и случайно изменить значение 1 до 3 и пропустить некоторые другие значения 2.

984
01:01:26,550 --> 01:01:30,660
Так что я собираюсь вместо абстрактного это расстояние и использовать эту константу, которая,

985
01:01:30,660 --> 01:01:32,520
как предполагает его название, никогда не меняется.

986
01:01:32,520 --> 01:01:35,870
И теперь независимо от того, есть ли у нас различные викторины этом или следующем году,

987
01:01:35,870 --> 01:01:39,380
Я просто изменить его в одном месте, здесь на вершине.

988
01:01:39,380 --> 01:01:41,230
Так что все константы.

989
01:01:41,230 --> 01:01:47,100
Между тем, новая концептуальная особенность состоит в том массива.

990
01:01:47,100 --> 01:01:55,030
Таким образом, в квадратных скобках дать мне это много плавает и позволяет мне коллективно называют их классах здесь.

991
01:01:55,030 --> 01:01:56,720
Итак, теперь давайте посмотрим, что я собираюсь делать.

992
01:01:56,720 --> 01:01:59,220
Здесь, в строке 24 является началом цикла.

993
01:01:59,220 --> 01:02:03,380
>> Это действительно ничего особенного. Это только с помощью викторин, а не жестко числа.

994
01:02:03,380 --> 01:02:06,740
Но нет ничего интеллектуально разных там с прошлой недели.

995
01:02:06,740 --> 01:02:11,650
Это просто Printf, поэтому Е ("Викторина #% сут% D:")

996
01:02:11,650 --> 01:02:16,670
потому что я просто хочу, чтобы распечатать дать мне викторины № 1 из 2, а затем 2 из 2.

997
01:02:16,670 --> 01:02:18,480
Так что это чисто эстетическая вещь.

998
01:02:18,480 --> 01:02:21,000
Но самое интересное сейчас находится в строке 27.

999
01:02:21,000 --> 01:02:27,840
Для того, чтобы заполнить одну из двух заполнителей с плавающей точкой,

1000
01:02:27,840 --> 01:02:29,640
Вы снова использовать квадратные скобки.

1001
01:02:29,640 --> 01:02:35,170
В этом случае, я использую я, потому что это цикл начался с я, какое значение равное, по-видимому?

1002
01:02:35,170 --> 01:02:36,670
[Студент] 0. >> [Малан] 0.

1003
01:02:36,670 --> 01:02:40,990
Таким образом, на первой итерации этого цикла, это как если бы я написал это в коде,

1004
01:02:40,990 --> 01:02:46,310
но на второй итерации этого цикла, это как если бы я написал это в своем коде.

1005
01:02:46,310 --> 01:02:49,970
Но то, что я использую переменную прекрасно, потому что, как следует из названия,

1006
01:02:49,970 --> 01:02:52,600
это изменение его значения на каждой итерации,

1007
01:02:52,600 --> 01:02:55,900
так что я заполнение этого массива одном месте за один раз.

1008
01:02:55,900 --> 01:02:57,380
Что это массив выглядит?

1009
01:02:57,380 --> 01:03:01,570
Поэтому я обратил супер простой прямоугольник на экране здесь раньше была для этого причина.

1010
01:03:01,570 --> 01:03:05,590
Массив это просто кусок памяти последовал еще один кусок памяти

1011
01:03:05,590 --> 01:03:08,570
последовал еще один кусок памяти и так далее.

1012
01:03:08,570 --> 01:03:13,120
Так что, если мой массив размером 2 в этом случае здесь, все, что я буду делать

1013
01:03:13,120 --> 01:03:20,200
, введя в моей оценки викторины нравится здесь, - я получил 100 на один, а затем я получил 99 на этом -

1014
01:03:20,200 --> 01:03:24,970
Затем эта память не может даже быть использован, потому что я только спросил компьютера

1015
01:03:24,970 --> 01:03:26,840
для массива размером 2.

1016
01:03:26,840 --> 01:03:28,600
Эти квадраты все еще там, не так ли?

1017
01:03:28,600 --> 01:03:32,670
У вас еще есть 2 гигабайта оперативной памяти, даже если вы только просят 2 поплавка.

1018
01:03:32,670 --> 01:03:36,840
Таким образом, идея массивов является то, что компьютер просто берет кусок памяти

1019
01:03:36,840 --> 01:03:41,340
, а затем распределяет мелкие куски спина к спине, чтобы спина к спине.

1020
01:03:41,340 --> 01:03:43,310
И это все, что массив.

1021
01:03:43,310 --> 01:03:47,350
>> Это непрерывный кусок памяти, внутри которой вы можете положить вещи.

1022
01:03:47,350 --> 01:03:50,700
Это происходит, чтобы потом сделать лишь несколько скучно арифметика.

1023
01:03:50,700 --> 01:03:54,640
Если я прокрутите вниз здесь, это где я тогда итерации по массиву.

1024
01:03:54,640 --> 01:03:58,020
Я придумал суммирование всех значений в массиве,

1025
01:03:58,020 --> 01:04:02,470
а потом использовать круглый функцию здесь на самом деле делать сумма делится на викторины.

1026
01:04:02,470 --> 01:04:06,320
Но позвольте мне махнуть рукой на что как своего рода достаточно арифметических сейчас.

1027
01:04:06,320 --> 01:04:08,370
Но все, что делает для меня, в конечном счете, вычисление среднего.

1028
01:04:08,370 --> 01:04:13,580
Итак, сначала тест, плюс второй тест делится на 2, а затем распечатать его, как Int.

1029
01:04:13,580 --> 01:04:17,280
Но давайте теперь переход к другой пример называется string1,

1030
01:04:17,280 --> 01:04:20,700
который рисует аналогичную картину, но с использованием строк.

1031
01:04:20,700 --> 01:04:23,940
Позвольте мне идти вперед и упростить этот на мгновение.

1032
01:04:23,940 --> 01:04:27,090
Простите отступ на данный момент.

1033
01:04:27,090 --> 01:04:30,870
Обратите внимание на линию 19 из этого примера, я получаю строку от пользователя.

1034
01:04:30,870 --> 01:04:34,640
Но обратите внимание на то, что я делаю в следующем линий 22 и далее.

1035
01:04:34,640 --> 01:04:41,250
На самом деле я итерация от Я до - и это новый трюк - StrLen, длина строки.

1036
01:04:41,250 --> 01:04:44,880
Это функция, которая поставляется с C, что если вы передаете его строки,

1037
01:04:44,880 --> 01:04:47,730
он говорит вам, сколько символов в этой строке. Вот и все.

1038
01:04:47,730 --> 01:04:51,550
А то, что это StrLen вместо того, чтобы длина строки просто потому, что это более кратким.

1039
01:04:51,550 --> 01:04:55,100
Тридцать лет назад, людям нравилось писать вещи, как лаконично насколько это возможно,

1040
01:04:55,100 --> 01:04:57,630
поэтому мы сохранили эту конвенцию здесь.

1041
01:04:57,630 --> 01:05:00,660
я + + означает лишь то увеличиваем я в каждой итерации.

1042
01:05:00,660 --> 01:05:02,990
А теперь замечаю это, что действительно интересно.

1043
01:05:02,990 --> 01:05:09,180
В строке 24, я говорю: "Компьютер, дай мне характером, 8 бит, и называем его с".

1044
01:05:09,180 --> 01:05:12,630
Но что это на правой стороне говорите?

1045
01:05:13,490 --> 01:05:16,530
В английском языке, что это представляете?

1046
01:05:16,530 --> 01:05:18,730
[Студент] Первый символ в массиве.

1047
01:05:18,730 --> 01:05:20,790
Именно так. Дайте мне первый символ в массиве.

1048
01:05:20,790 --> 01:05:24,090
Или, в более общем, дай мне-й символ в массиве.

1049
01:05:24,090 --> 01:05:26,100
И понимаю, что это важно сейчас, как компьютерные науки,

1050
01:05:26,100 --> 01:05:27,890
мы на самом деле начиная с 0.

1051
01:05:27,890 --> 01:05:29,720
>> Вы не должны усмотрению сейчас, чтобы начать это делать.

1052
01:05:29,720 --> 01:05:34,160
Теперь вы должны вести себя в соответствии с ожиданиями компьютер и считать от 0

1053
01:05:34,160 --> 01:05:38,180
потому что [0] будет первый символ в строке,

1054
01:05:38,180 --> 01:05:42,150
[1] будет второй, [2] будет третьим, и так далее.

1055
01:05:42,150 --> 01:05:49,720
Таким образом, эта программа, если я скомпилировать его, это опять string1, так что string1,

1056
01:05:49,720 --> 01:05:54,670
и теперь я столкнулся string1 в моем окне терминала.

1057
01:05:54,670 --> 01:05:58,330
Он ожидает ввода, так что я собираюсь ввести Давида, Enter

1058
01:05:58,330 --> 01:06:02,540
и теперь она печатает Дэвид все на разных линиях, потому что уведомление, что я делаю.

1059
01:06:02,540 --> 01:06:05,820
Я печать одного символа за один раз.

1060
01:06:05,820 --> 01:06:10,100
Мы не будем вдаваться в подробности сегодня на этом, но я удалил эту минуту назад здесь галочку.

1061
01:06:10,100 --> 01:06:15,480
Оказывается, что если пользователь неправильно, состязательности, или просто путают,

1062
01:06:15,480 --> 01:06:20,210
Вы можете фактически не дают строки некоторой длины.

1063
01:06:20,210 --> 01:06:22,860
Если вы нажмете не ту клавишу на клавиатуре, вы можете не дают строку на всех,

1064
01:06:22,860 --> 01:06:26,950
или если вы злой, вы можете попробовать, чтобы вставить в стоимость гигабайта о эссе

1065
01:06:26,950 --> 01:06:29,290
чтобы заполнить эту строку, и если компьютер работает из памяти,

1066
01:06:29,290 --> 01:06:32,710
Оказывается, что мы собираемся вернуть это специальное значение, называемое NULL.

1067
01:06:32,710 --> 01:06:35,580
Таким образом, на данный момент, просто знаю, что есть это специальное значение, называемое NULL

1068
01:06:35,580 --> 01:06:39,580
, что позволит нам проверить, когда мы из памяти, между прочим.

1069
01:06:39,580 --> 01:06:45,630
Но если я открываю сейчас string2, обратите внимание на одно различие здесь.

1070
01:06:45,630 --> 01:06:48,210
Обратите внимание на одно различие здесь с string2.

1071
01:06:48,210 --> 01:06:51,340
С string2, этот цикл немного отличается.

1072
01:06:51,340 --> 01:06:55,010
>> Позвольте мне удалить нули, так что мы можем говорить о тех, кто в другой раз.

1073
01:06:55,010 --> 01:06:57,800
Чем отличается цикл на этот раз?

1074
01:06:59,620 --> 01:07:01,670
Я могу вернуться к предыдущему примеру.

1075
01:07:01,670 --> 01:07:08,580
Так вот версия 2, это версия 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
StrLen вызов где?

1078
01:07:16,660 --> 01:07:18,860
Это в первой части цикла.

1079
01:07:18,860 --> 01:07:21,830
Любые мысли о том, почему я это делаю? Да.

1080
01:07:21,830 --> 01:07:24,560
[Студент] Таким образом, вы не вызываете функцию каждый раз.

1081
01:07:24,560 --> 01:07:26,440
[Малан] Таким образом, мы не вызываем функцию каждый раз. Именно так.

1082
01:07:26,440 --> 01:07:28,300
Напомним, с петлями на то, что они супер просто

1083
01:07:28,300 --> 01:07:31,770
Как только вы вроде понимаю, что это инициализация, условие и обновления.

1084
01:07:31,770 --> 01:07:34,750
Проблема в том, что условие происходит на каждой итерации цикла.

1085
01:07:34,750 --> 01:07:40,010
И поэтому в данном примере, что такое плохо о том, что это мое состояние?

1086
01:07:40,010 --> 01:07:41,830
[Студент] Вы звоните StrLen.

1087
01:07:41,830 --> 01:07:44,340
[Малан] Вы звоните StrLen снова и снова, и снова.

1088
01:07:44,340 --> 01:07:47,410
Но как только я набрал в Дэвида, длина этой строки равен 5,

1089
01:07:47,410 --> 01:07:49,650
и он не собирается менять на каждой итерации

1090
01:07:49,650 --> 01:07:51,670
потому что строка по-прежнему D--V-я-д.

1091
01:07:51,670 --> 01:07:55,320
Так что это намек на то, что собирается становиться все более важной идеей

1092
01:07:55,320 --> 01:08:00,410
известный как дизайнерское решение, где только не делают компьютер делать ненужную работу.

1093
01:08:00,410 --> 01:08:03,920
>> Так же, как предварительный просмотр pset2, pset2 в стандартном издании

1094
01:08:03,920 --> 01:08:07,030
собирается бросить вам вызов на самом деле реализации некоторого числа шифров,

1095
01:08:07,030 --> 01:08:10,410
некоторое количество алгоритмов шифрования, так что вы можете не только зашифровать

1096
01:08:10,410 --> 01:08:13,840
и дешифрования секретных сообщений так же, как одной Ральфи там декодировать.

1097
01:08:13,840 --> 01:08:16,810
В хакером издание pset2, мы собираемся пойти немного дальше.

1098
01:08:16,810 --> 01:08:19,649
Мы собираемся передать вам файл с фактическими компьютерной системы

1099
01:08:19,649 --> 01:08:23,479
, который содержит целую кучу имен и фактической зашифрованные пароли,

1100
01:08:23,479 --> 01:08:26,939
и задачи для хакера издание будет взламывать эти пароли

1101
01:08:26,939 --> 01:08:33,200
и выяснить, что криптография и тайные, что был использован для создания самом деле эти пароли.

1102
01:08:33,200 --> 01:08:36,109
И мы собираемся сделать это с помощью новой функции здесь C

1103
01:08:36,109 --> 01:08:40,630
что я дам вам только демо известный как аргументы командной строки.

1104
01:08:40,630 --> 01:08:44,229
Оказывается, как некоторые из вас, возможно, видели в разделе или в учебниках,

1105
01:08:44,229 --> 01:08:48,260
Основным не всегда должна быть пустота в скобках.

1106
01:08:48,260 --> 01:08:52,430
Оказывается, что основная можно также записать как это, с двумя аргументами,

1107
01:08:52,430 --> 01:08:56,870
ARGC и ARGV, где ARGC число слов

1108
01:08:56,870 --> 01:09:00,020
что вы вводите после названия программы на вашем командной строки

1109
01:09:00,020 --> 01:09:03,420
и ARGV является фактическим слов.

1110
01:09:03,420 --> 01:09:07,540
И, как квадратные скобки там предлагают, ARGV видимо массива.

1111
01:09:07,540 --> 01:09:12,210
Это собирается быть строкой после строки после строки в памяти.

1112
01:09:12,210 --> 01:09:16,010
>> Так что мы собираемся быть в состоянии сделать, начиная с PSET 2, что-то вроде этого.

1113
01:09:16,010 --> 01:09:21,350
Если я делаю argv1, который является примером мы вернемся к в понедельник, и запустить его,

1114
01:09:21,350 --> 01:09:23,370
заметить, что это не похоже, чтобы сделать что-нибудь еще.

1115
01:09:23,370 --> 01:09:25,490
Он просто выводит свое имя.

1116
01:09:25,490 --> 01:09:31,479
Но если я прощаюсь класса, обратите внимание, что эта программа по-видимому итерации

1117
01:09:31,479 --> 01:09:35,479
над каждым из слов, которые были напечатаны в командной строке.

1118
01:09:35,479 --> 01:09:41,630
И средства, с помощью которых мы сможем получить доступ к словам, которые пользователь ввел в командной строке

1119
01:09:41,630 --> 01:09:49,160
является изменение основной отправной этот уик-энд от Int основных (недействительными) на Int основных (агдс, ARGV)

1120
01:09:49,160 --> 01:09:52,050
и, следовательно, родится аргументы командной строки.

1121
01:09:52,050 --> 01:09:57,100
И как только вы получите действительно сложная в этом, вы сможете написать действительно трип программ

1122
01:09:57,100 --> 01:09:59,610
таких, как этот вот, который идет выше и вне

1123
01:09:59,610 --> 01:10:03,940
некоторые функции, которые мы сделали до сих пор, но все довольно мощный.

1124
01:10:03,940 --> 01:10:08,950
>> Таким образом, мы оставим это с этим на экране, и мы будем видеть Вас в понедельник.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]