1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Часть 4] [менее комфортно]

2
00:00:02,000 --> 00:00:04,000
[Nate Хардисон] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Это CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Ладно, добро пожаловать в раздел.

5
00:00:10,000 --> 00:00:13,000
В разделе этой недели мы собираемся сделать несколько вещей.

6
00:00:13,000 --> 00:00:17,000
Мы идем к первому поставленной задачи резюме 2,

7
00:00:17,000 --> 00:00:20,000
которая является набором Цезаря и Виженера проблемы.

8
00:00:20,000 --> 00:00:23,000
И тогда мы будем погружаться в обзор Викторина 0

9
00:00:23,000 --> 00:00:26,000
и потратить немного времени, резюмируя, что мы говорили о

10
00:00:26,000 --> 00:00:30,000
В каждом из лекций до сих пор, и мы также делаем несколько проблем

11
00:00:30,000 --> 00:00:32,000
от викторинах предыдущего года.

12
00:00:32,000 --> 00:00:36,000
Таким образом, вы, ребята, есть хороший способ подготовиться к этому.

13
00:00:36,000 --> 00:00:40,000
>> Для начала, я загрузил несколько хороших решений

14
00:00:40,000 --> 00:00:45,000
за предыдущий набор проблем, задач 2, в этом пространстве.

15
00:00:45,000 --> 00:00:48,000
Если вы, ребята, все попали на эту ссылку,

16
00:00:48,000 --> 00:00:53,000
и если вы щелкните свое имя и нажмите на моем первом пересмотре

17
00:00:53,000 --> 00:00:56,000
Вы увидите caesar.c, а это именно то, что я смотрю.

18
00:00:56,000 --> 00:01:00,000
Давайте поговорим об этом очень быстро.

19
00:01:00,000 --> 00:01:02,000
Это всего лишь пример решения.

20
00:01:02,000 --> 00:01:05,000
Это не обязательно идеальное решение.

21
00:01:05,000 --> 00:01:08,000
Есть много разных способов, чтобы написать это,

22
00:01:08,000 --> 00:01:10,000
но есть несколько вещей, которые я хотел бы подчеркнуть

23
00:01:10,000 --> 00:01:13,000
что я видел, как я сортировке, распространенные ошибки, которые я думаю,

24
00:01:13,000 --> 00:01:18,000
это решение делает очень хорошую работу в обращении.

25
00:01:18,000 --> 00:01:22,000
>> Первый по какой-то заголовок комментария в верхней части.

26
00:01:22,000 --> 00:01:25,000
В строках с 1 по 7 вы видите детали,

27
00:01:25,000 --> 00:01:28,000
что именно эта программа делает.

28
00:01:28,000 --> 00:01:32,000
Хорошая стандартная практика, когда вы пишете код C

29
00:01:32,000 --> 00:01:35,000
независимо от того, ваша программа содержится в одном файле или

30
00:01:35,000 --> 00:01:38,000
ли он разбит на несколько файлов, чтобы иметь какой-то

31
00:01:38,000 --> 00:01:40,000
ориентировочная комментарий на самом верху.

32
00:01:40,000 --> 00:01:43,000
Это тоже для людей, которые выходят и написать код в реальном мире.

33
00:01:43,000 --> 00:01:47,000
Это где положат информацию об авторском праве.

34
00:01:47,000 --> 00:01:50,000
Ниже приведены # включает в себя.

35
00:01:50,000 --> 00:01:55,000
По строке 16 есть эта # определить, что мы вернемся в только немного.

36
00:01:55,000 --> 00:01:59,000
И вот однажды функция начинается, как только основные старты,

37
00:01:59,000 --> 00:02:03,000
потому что эта программа была все содержащиеся в одной функцией

38
00:02:03,000 --> 00:02:09,000
Самое первое, что происходит, и это очень идиоматические и типичные программы C

39
00:02:09,000 --> 00:02:14,000
, которая принимает в аргументы командной строки-это то, что он сразу проверяет

40
00:02:14,000 --> 00:02:18,000
>> по количеству аргументов, агдс.

41
00:02:18,000 --> 00:02:24,000
Вот здесь мы видим, что эта программа ожидает 2 аргументы точно.

42
00:02:24,000 --> 00:02:27,000
Помните есть то, что первый аргумент, что это особенный

43
00:02:27,000 --> 00:02:29,000
это всегда имя программы, которая запускаемых,

44
00:02:29,000 --> 00:02:31,000
имя исполняемого файла.

45
00:02:31,000 --> 00:02:36,000
И так, что она делает это не позволяет пользователю запустить программу

46
00:02:36,000 --> 00:02:42,000
с большим или меньшим количеством аргументов.

47
00:02:42,000 --> 00:02:44,000
Поэтому мы хотим, чтобы проверить это сразу потому, что

48
00:02:44,000 --> 00:02:52,000
мы не можем фактически получить доступ к этой ARGV массива прямо здесь надежно

49
00:02:52,000 --> 00:02:55,000
пока мы не проверяли, насколько она велика.

50
00:02:55,000 --> 00:02:58,000
>> Одна из наиболее распространенных ошибок я видел, был бы люди сразу идут в

51
00:02:58,000 --> 00:03:01,000
и захват ARGV [1].

52
00:03:01,000 --> 00:03:06,000
Они захватить ключевые аргументы из массива и не к я проверить на нем,

53
00:03:06,000 --> 00:03:11,000
а затем они сделают тест на агдс, а также следующий тест,

54
00:03:11,000 --> 00:03:16,000
ли не первым аргументом было действительно целое, в то же время,

55
00:03:16,000 --> 00:03:20,000
и это не работает, потому что в случае, если нет аргументов,

56
00:03:20,000 --> 00:03:26,000
Вы будете захватить аргумент, что там нет или попытку захватить один, что нет.

57
00:03:26,000 --> 00:03:29,000
>> Другая большая вещь, которую вы должны были заметить, что

58
00:03:29,000 --> 00:03:32,000
Вы всегда хотите, чтобы распечатать какой-то полезный сообщение об ошибке

59
00:03:32,000 --> 00:03:34,000
пользователю ориентироваться них.

60
00:03:34,000 --> 00:03:37,000
Я уверен, что вы все запуска программ, где вдруг он выходит из строя,

61
00:03:37,000 --> 00:03:41,000
и вы получите этот смешной маленький диалог, который всплывает и говорит:

62
00:03:41,000 --> 00:03:44,000
что-то ужасно загадочным и, возможно, дает вам код ошибки или что-то в этом роде

63
00:03:44,000 --> 00:03:47,000
что не имеет смысла.

64
00:03:47,000 --> 00:03:50,000
Это где вы действительно хотите, чтобы обеспечить что-то полезное

65
00:03:50,000 --> 00:03:54,000
и ориентированные на пользователя, так что, когда они запустить его они идут "О," лицо ладонью.

66
00:03:54,000 --> 00:03:58,000
"Я точно знаю, что делать. Я знаю, как это исправить".

67
00:03:58,000 --> 00:04:01,000
>> Если вы не печатать сообщение, то в итоге вы на самом деле

68
00:04:01,000 --> 00:04:04,000
оставляя пользователю пойти изучать исходный код

69
00:04:04,000 --> 00:04:07,000
чтобы выяснить, что пошло не так.

70
00:04:07,000 --> 00:04:11,000
Есть также несколько раз, что вы будете использовать различные коды ошибок.

71
00:04:11,000 --> 00:04:14,000
Здесь мы просто использовали один говорят, что произошла ошибка,

72
00:04:14,000 --> 00:04:16,000
произошла ошибка, произошла ошибка.

73
00:04:16,000 --> 00:04:20,000
Больше программ, часто программ, которые вызываются другими программами,

74
00:04:20,000 --> 00:04:25,000
вернется какой-то специальный код ошибки в различных сценариях

75
00:04:25,000 --> 00:04:28,000
программно сообщить, что вы бы иначе

76
00:04:28,000 --> 00:04:32,000
просто использовать хороший английский сообщение для.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Как мы работаем вниз, вы видите, мы вытащить ключ из.

79
00:04:37,000 --> 00:04:40,000
Мы проверяем, чтобы увидеть, если ключ подходит.

80
00:04:40,000 --> 00:04:42,000
Мы получили сообщение от пользователя.

81
00:04:42,000 --> 00:04:46,000
Поэтому мы делаем это в этом цикле сделать в то время и это то, что мы покроем

82
00:04:46,000 --> 00:04:50,000
В немного, но оказывается, что если ввести контроль D

83
00:04:50,000 --> 00:04:54,000
когда вы получаете GetString строки на терминал

84
00:04:54,000 --> 00:04:59,000
что это на самом деле делает это он посылает специальный символ

85
00:04:59,000 --> 00:05:01,000
в программе.

86
00:05:01,000 --> 00:05:05,000
Это называется ELF или символ конца файла.

87
00:05:05,000 --> 00:05:08,000
И в этом случае, наша строка сообщения будет нулевым,

88
00:05:08,000 --> 00:05:14,000
так что это было не то, что мы проверяли в задачу поставил перед собой.

89
00:05:14,000 --> 00:05:17,000
>> Но, как мы продолжим, теперь, когда мы начали говорить об указателях

90
00:05:17,000 --> 00:05:21,000
и динамическое выделение памяти в куче,

91
00:05:21,000 --> 00:05:25,000
проверка на нуль всякий раз, когда у вас есть функция, которая может

92
00:05:25,000 --> 00:05:30,000
вернуть нулевое значение, как то, что вы хотите получить в привычку делать.

93
00:05:30,000 --> 00:05:33,000
Это здесь, прежде всего для иллюстрации.

94
00:05:33,000 --> 00:05:36,000
Но когда вы видите GetString в будущем,

95
00:05:36,000 --> 00:05:41,000
так от проблемы Set 4, Вы будете хотеть иметь это в виду.

96
00:05:41,000 --> 00:05:44,000
Опять же, это не является проблемой для задач 3 либо, так как мы не покрывается еще.

97
00:05:44,000 --> 00:05:53,000
И, наконец, мы добираемся до этой части, где мы перейдем к основной цикл шифрования,

98
00:05:53,000 --> 00:05:57,000
и есть несколько вещей, что здесь происходит.

99
00:05:57,000 --> 00:06:02,000
Во-первых, мы перебора всей строки сообщения.

100
00:06:02,000 --> 00:06:07,000
Здесь мы сохранили StrLen вызов в состояние,

101
00:06:07,000 --> 00:06:12,000
которые многие из вас указали не большой путь.

102
00:06:12,000 --> 00:06:15,000
Оказывается, в этом случае он также не велика,

103
00:06:15,000 --> 00:06:20,000
Отчасти потому, что мы, изменив содержимое самого сообщения

104
00:06:20,000 --> 00:06:27,000
внутри цикла, так что если у нас есть сообщение, что это 10 символов,

105
00:06:27,000 --> 00:06:32,000
Впервые мы начинаем цикл, что для StrLen вернется и что?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Но если мы затем изменить сообщение, сказать, что мы изменить свое 5-й символ,

108
00:06:40,000 --> 00:06:46,000
и кидаем в \ 0 символ в 5-й позиции,

109
00:06:46,000 --> 00:06:49,000
на последующей итерации StrLen (сообщение) не вернется, что он сделал

110
00:06:49,000 --> 00:06:52,000
самый первый раз, когда мы повторный,

111
00:06:52,000 --> 00:06:56,000
но вместо этого вернуть 5, потому что мы бросили в том, что нулевой терминатор,

112
00:06:56,000 --> 00:06:59,000
и длиной струны определяется

113
00:06:59,000 --> 00:07:03,000
положением, что \ 0.

114
00:07:03,000 --> 00:07:09,000
В этом случае, это отличный способ пойти, потому что мы изменив ее на место.

115
00:07:09,000 --> 00:07:13,000
Но вы заметили, что это на самом деле удивительно проста для шифрования

116
00:07:13,000 --> 00:07:16,000
если вы можете получить математику правильно.

117
00:07:16,000 --> 00:07:19,000
Все, что требуется, чтобы проверить, действительно ли письмо, что вы смотрите на

118
00:07:19,000 --> 00:07:21,000
это верхний или нижний регистр.

119
00:07:21,000 --> 00:07:24,000
>> Поэтому мы только должны проверить, что и у нас нет для проверки

120
00:07:24,000 --> 00:07:27,000
это альфа дело в том, что

121
00:07:27,000 --> 00:07:30,000
Если символ в верхнем регистре или, если это строчная

122
00:07:30,000 --> 00:07:33,000
то это определенно буквы,

123
00:07:33,000 --> 00:07:38,000
потому что у нас нет прописных и строчных знаков.

124
00:07:38,000 --> 00:07:41,000
Другая вещь, которую мы делаем, и это немного сложно-

125
00:07:41,000 --> 00:07:45,000
это мы изменили стандартный шифр Цезаря формуле

126
00:07:45,000 --> 00:07:49,000
, которые мы дали в спецификации поставленной задачи.

127
00:07:49,000 --> 00:07:52,000
В чем разница здесь в том, что мы вычитали

128
00:07:52,000 --> 00:07:58,000
В верхнем регистре капитала случай, и тогда мы добавочного капитала

129
00:07:58,000 --> 00:08:02,000
Резервное в конце.

130
00:08:02,000 --> 00:08:05,000
>> Я знаю, некоторые из вас сделали это в коде.

131
00:08:05,000 --> 00:08:09,000
Кто-нибудь из вас сделать это в ваших представлениях?

132
00:08:09,000 --> 00:08:13,000
Вы сделали это. Можете ли вы объяснить, что это делает, Sahb?

133
00:08:13,000 --> 00:08:18,000
Путем вычитания его, потому что вы сделали мод сразу после него,

134
00:08:18,000 --> 00:08:21,000
вы должны принять его, так что таким образом вы получите [кашель] позиция.

135
00:08:21,000 --> 00:08:25,000
А потом, добавив его позже вы перешла тот, который вы хотели.

136
00:08:25,000 --> 00:08:27,000
Да, именно так.

137
00:08:27,000 --> 00:08:32,000
Что Sahb сказал, что когда мы хотим добавить

138
00:08:32,000 --> 00:08:36,000
наше сообщение, и наши ключевые вместе

139
00:08:36,000 --> 00:08:42,000
, а затем мод, который, мод, который по NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
если мы не будем масштабировать наши сообщения в соответствующие 0 до 25 Диапазон во-первых,

141
00:08:50,000 --> 00:08:54,000
Затем мы могли бы в конечном итоге получить действительно странный номер

142
00:08:54,000 --> 00:08:59,000
потому, что ценности, которые мы смотрим на то, когда мы смотрим на сообщение [я],

143
00:08:59,000 --> 00:09:03,000
Когда мы смотрим на го характера наших текстовых сообщений,

144
00:09:03,000 --> 00:09:08,000
это значение где-то в этом от 65 до 122 Диапазон

145
00:09:08,000 --> 00:09:13,000
на основе ASCII значения для верхнего регистра от А до Z строчные.

146
00:09:13,000 --> 00:09:18,000
И поэтому, когда мы мода это на 26 или NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
так как это был наш # определить в правом верхнем здесь,

148
00:09:23,000 --> 00:09:28,000
что собирается дать нам значение, которое в 0 до 25 диапазон,

149
00:09:28,000 --> 00:09:30,000
и нам нужен способ, чтобы затем масштабировать, которые поддерживают

150
00:09:30,000 --> 00:09:32,000
и получить его в соответствующие ASCII диапазона.

151
00:09:32,000 --> 00:09:36,000
Самый простой способ сделать это, чтобы просто масштабировать все вниз

152
00:09:36,000 --> 00:09:39,000
в 0 до 25 Диапазон Начнем с того,

153
00:09:39,000 --> 00:09:43,000
, а затем переложить все обратно в конце.

154
00:09:43,000 --> 00:09:46,000
>> Еще одна распространенная ошибка, что я видел, люди бегут в том, что

155
00:09:46,000 --> 00:09:50,000
если вы на самом деле не сделать это прямо сейчас масштабирования

156
00:09:50,000 --> 00:09:53,000
и вы добавляете сообщение и ключевые вместе и добавить их, скажем,

157
00:09:53,000 --> 00:09:58,000
в символ переменной, проблема с этим

158
00:09:58,000 --> 00:10:01,000
это сообщение, так как [я] является относительно большое число, чтобы начать с-

159
00:10:01,000 --> 00:10:05,000
помните, что это по меньшей мере 65, если это символ верхнего регистра-

160
00:10:05,000 --> 00:10:09,000
если у вас есть большой ключ, скажем, что-то вроде 100,

161
00:10:09,000 --> 00:10:13,000
и вы добавляете эти 2 вместе в подписанных символ вы собираетесь получить переполнение.

162
00:10:13,000 --> 00:10:17,000
Вы собираетесь получить значение, которое превышает 127,

163
00:10:17,000 --> 00:10:22,000
, которая является крупнейшим значение, символ может хранить переменная.

164
00:10:22,000 --> 00:10:26,000
Опять же, почему вы хотите сделать такую ​​вещь с самого начала.

165
00:10:26,000 --> 00:10:29,000
Некоторые люди получили вокруг этого дела делать, если еще и тестирования

166
00:10:29,000 --> 00:10:33,000
чтобы увидеть, если она будет переполнение прежде чем сделать это,

167
00:10:33,000 --> 00:10:36,000
но таким образом получает от всего этого.

168
00:10:36,000 --> 00:10:40,000
И тогда в этом решении мы выводим всю строку в самом конце.

169
00:10:40,000 --> 00:10:45,000
Другие люди распечатать символ за один раз. Оба являются удивительными.

170
00:10:45,000 --> 00:10:51,000
На данный момент, вы, ребята, есть какие-либо вопросы, никаких комментариев по этому поводу?

171
00:10:51,000 --> 00:10:56,000
Что вам нравится, что вам не нравится?

172
00:10:56,000 --> 00:10:58,000
>> У меня был вопрос.

173
00:10:58,000 --> 00:11:01,000
Может быть, я пропустил его во время вашего объяснения, но как эта программа

174
00:11:01,000 --> 00:11:07,000
пропустить пространства для подключения ключа к длине текста?

175
00:11:07,000 --> 00:11:10,000
Это всего лишь шифр Цезаря. >> Эх, жаль, да.

176
00:11:10,000 --> 00:11:13,000
Да, мы видим, что.

177
00:11:13,000 --> 00:11:16,000
В шифр Цезаря мы обошли, потому что

178
00:11:16,000 --> 00:11:18,000
Мы только перевернул символов.

179
00:11:18,000 --> 00:11:27,000
Мы только повернуть их, если они были верхнем или нижнем регистре.

180
00:11:27,000 --> 00:11:32,000
Вы, ребята, чувствовал себя довольно хорошо по этому поводу?

181
00:11:32,000 --> 00:11:34,000
Вы можете скопировать этот дом, бери,

182
00:11:34,000 --> 00:11:37,000
сравнить его с тем, что вы, ребята написали.

183
00:11:37,000 --> 00:11:42,000
Определенно не стесняйтесь, присылайте вопросы на эту тему тоже.

184
00:11:42,000 --> 00:11:46,000
И опять же, понимаю, что цель здесь с вашей проблемой устанавливает

185
00:11:46,000 --> 00:11:50,000
Не чтобы вы, ребята, чтобы написать идеальный код для множества проблем.

186
00:11:50,000 --> 00:11:57,000
Это опыт. Да.

187
00:11:57,000 --> 00:12:01,000
>> Вернуться к делать во время цикла, если он равен нулю,

188
00:12:01,000 --> 00:12:06,000
так нулевого просто ничего не значит, они просто нажмите ввод?

189
00:12:06,000 --> 00:12:12,000
Null это специальное значение указателя,

190
00:12:12,000 --> 00:12:17,000
и мы используем нуль, когда мы хотим сказать,

191
00:12:17,000 --> 00:12:23,000
у нас есть указатель переменной, которая указывает на нет.

192
00:12:23,000 --> 00:12:28,000
И обычно это означает, что эта переменная, эта переменная сообщение

193
00:12:28,000 --> 00:12:35,000
пусто, и здесь, потому что мы используем CS50 особый тип строки,

194
00:12:35,000 --> 00:12:37,000
что CS50 тип строки?

195
00:12:37,000 --> 00:12:42,000
Видели ли вы, что это такое, когда Дэвид откинул капюшон в лекции?

196
00:12:42,000 --> 00:12:44,000
Это фанки-это указатель, верно?

197
00:12:44,000 --> 00:12:48,000
Хорошо, да. >> Это символ *.

198
00:12:48,000 --> 00:12:52,000
И так на самом деле мы могли бы заменить эту

199
00:12:52,000 --> 00:12:56,000
прямо здесь с символов сообщений *,

200
00:12:56,000 --> 00:13:04,000
и так GetString функция, если она не успешно получить строку от пользователя,

201
00:13:04,000 --> 00:13:08,000
он не может разобрать строку, и в одном случае, в котором он не может разобрать строку

202
00:13:08,000 --> 00:13:11,000
, если пользователь вводит символ конца файла, контрольная D,

203
00:13:11,000 --> 00:13:17,000
который не то, что вы обычно делаете, но если это произойдет,

204
00:13:17,000 --> 00:13:20,000
то функция вернет это значение, как способ сказать

205
00:13:20,000 --> 00:13:23,000
"Эй, я не получить строку".

206
00:13:23,000 --> 00:13:27,000
Что произойдет, если мы не ставим сообщение = NULL,

207
00:13:27,000 --> 00:13:30,000
которых является то, что мы не делали еще?

208
00:13:30,000 --> 00:13:32,000
Почему бы это было здесь проблема?

209
00:13:32,000 --> 00:13:38,000
Потому что я знаю, что мы немного поговорили в лекции об утечках памяти.

210
00:13:38,000 --> 00:13:42,000
Да, давайте сделаем это, и давайте посмотрим, что произойдет.

211
00:13:42,000 --> 00:13:44,000
>> Вопрос Василия Блаженного было то, что произойдет, если мы на самом деле не

212
00:13:44,000 --> 00:13:48,000
это сообщение = NULL тест?

213
00:13:48,000 --> 00:13:51,000
Давайте прокрутки вверх к вершине.

214
00:13:51,000 --> 00:13:53,000
Вы, ребята, можете прокомментировать это.

215
00:13:53,000 --> 00:13:55,000
На самом деле, я спасу его в пересмотре.

216
00:13:55,000 --> 00:13:58,000
Это будет 3-я редакция.

217
00:13:58,000 --> 00:14:02,000
Что вы должны сделать, чтобы запустить эту программу, вам придется нажать эту значок с изображением шестеренки здесь,

218
00:14:02,000 --> 00:14:04,000
и вы будете иметь, чтобы добавить аргументы к нему.

219
00:14:04,000 --> 00:14:10,000
Вы должны дать ему главный аргумент, так как мы хотим передать в аргументе командной строки.

220
00:14:10,000 --> 00:14:13,000
Здесь я собираюсь дать ему номер 3. Мне нравится 3.

221
00:14:13,000 --> 00:14:19,000
Теперь масштабирование обратно, запустив программу.

222
00:14:19,000 --> 00:14:24,000
Это работает, компиляция, строительство.

223
00:14:24,000 --> 00:14:27,000
Здесь мы идем. Он ожидает запроса.

224
00:14:27,000 --> 00:14:33,000
Если я ввожу что-то вроде привет-где прошло?

225
00:14:33,000 --> 00:14:38,000
О, моя программа занимает слишком много времени для запуска. Я был jawing слишком долго.

226
00:14:38,000 --> 00:14:40,000
Вот он идет.

227
00:14:40,000 --> 00:14:43,000
Сейчас я набираю в привет.

228
00:14:43,000 --> 00:14:46,000
Мы видим, что он шифрует надлежащим образом.

229
00:14:46,000 --> 00:14:52,000
Теперь, что произойдет, если мы делаем быструю GetString вернуть NULL?

230
00:14:52,000 --> 00:14:57,000
Помните, я говорил, что мы сделали это, нажав управления D в то же время.

231
00:14:57,000 --> 00:14:59,000
Я прокрутку вверх здесь. Мы будем запускать его снова.

232
00:14:59,000 --> 00:15:01,000
Строительство. Там он идет.

233
00:15:01,000 --> 00:15:04,000
Теперь, когда я ударил управления D

234
00:15:04,000 --> 00:15:12,000
Я получил эту строку, которая говорит opt/sandbox50/bin/run.sh, ошибки сегментации.

235
00:15:12,000 --> 00:15:15,000
Разве вы, ребята, видели, что раньше?

236
00:15:15,000 --> 00:15:17,000
>> [Студент] Почему нет->> Простите?

237
00:15:17,000 --> 00:15:20,000
[Студент] Почему нет дампа памяти в этом случае?

238
00:15:20,000 --> 00:15:26,000
Дамп это-вопрос почему нет дампа здесь?

239
00:15:26,000 --> 00:15:29,000
Вопрос в том, что там может быть, но дамп представляет собой файл

240
00:15:29,000 --> 00:15:31,000
, который получает хранится на жестком диске.

241
00:15:31,000 --> 00:15:34,000
В этом случае мы отключили дампы

242
00:15:34,000 --> 00:15:37,000
на бегу сервер, так что мы не были люди сегментам разломов

243
00:15:37,000 --> 00:15:40,000
и создание тонн дампы памяти.

244
00:15:40,000 --> 00:15:46,000
Но вы можете получить.

245
00:15:46,000 --> 00:15:48,000
Основные свалки такая штука, что часто можно отключить,

246
00:15:48,000 --> 00:15:52,000
и иногда вы делаете.

247
00:15:52,000 --> 00:15:55,000
Сегментация вина, чтобы ответить на ваш вопрос, Василий,

248
00:15:55,000 --> 00:16:00,000
говорит, что мы попытались получить доступ к указателю

249
00:16:00,000 --> 00:16:05,000
, которые не были установлены, чтобы указать на что-либо.

250
00:16:05,000 --> 00:16:09,000
Помните, Бинки в видео, когда Бинки пытается

251
00:16:09,000 --> 00:16:12,000
перейти к указателю, который не указывая на что-нибудь?

252
00:16:12,000 --> 00:16:16,000
В этом случае я думаю, технически указатель указывает на что-то.

253
00:16:16,000 --> 00:16:20,000
Это указывает на нулевой, который является технически 0,

254
00:16:20,000 --> 00:16:25,000
но, что называется в сегменте, который не доступен

255
00:16:25,000 --> 00:16:28,000
по вашей программе, так что вы получите ошибку сегментации

256
00:16:28,000 --> 00:16:31,000
потому что вы не доступа к памяти, который в действующий сегмент

257
00:16:31,000 --> 00:16:38,000
как сегмент куче или стеке сегмент или сегмент данных.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Любые вопросы о Цезаря?

260
00:16:48,000 --> 00:16:51,000
>> Давайте двигаться дальше. Давайте посмотрим на пересмотр 2 очень быстро.

261
00:16:51,000 --> 00:17:00,000
Вот Виженера.

262
00:17:00,000 --> 00:17:04,000
Здесь, в Виженера

263
00:17:04,000 --> 00:17:06,000
Мы пройдем через это довольно быстро, потому что, опять же,

264
00:17:06,000 --> 00:17:10,000
Виженера и Цезаря очень похожи.

265
00:17:10,000 --> 00:17:12,000
Заголовок комментария раньше,

266
00:17:12,000 --> 00:17:17,000
# Определить это прежде избежать использования этих магических чисел.

267
00:17:17,000 --> 00:17:21,000
Приятно то, что мы хотим, чтобы перейти к

268
00:17:21,000 --> 00:17:23,000
различных алфавита или что-то вроде этого.

269
00:17:23,000 --> 00:17:26,000
Вместо того, чтобы идти вручную изменять все 26 в коде

270
00:17:26,000 --> 00:17:30,000
мы могли бы изменить это 27 или бросить его вниз

271
00:17:30,000 --> 00:17:34,000
если бы мы использовали различные алфавиты, разные языки.

272
00:17:34,000 --> 00:17:38,000
Опять же, у нас есть эта проверка количество аргументов,

273
00:17:38,000 --> 00:17:42,000
и действительно можно почти принять это в качестве шаблона.

274
00:17:42,000 --> 00:17:46,000
Практически каждый программе вы должны написать-

275
00:17:46,000 --> 00:17:50,000
если он принимает аргументы командной строки-некоторая последовательность линий

276
00:17:50,000 --> 00:17:55,000
, который читается как это в самом начале.

277
00:17:55,000 --> 00:17:59,000
Это одно из первых испытаний здравомыслие вы хотите сделать.

278
00:17:59,000 --> 00:18:03,000
>> Вот то, что мы делали, было мы убедились, что

279
00:18:03,000 --> 00:18:06,000
Ключевое слово действительно было, и это была вторая проверка, что мы и сделали.

280
00:18:06,000 --> 00:18:11,000
Обратите внимание еще раз, что мы отделились от этого ARGC и 2.

281
00:18:11,000 --> 00:18:14,000
Обратите внимание, что в этом случае одна вещь, которую мы должны были сделать, было, вместо

282
00:18:14,000 --> 00:18:18,000
использования, чтобы я, мы хотели проверить всю строку,

283
00:18:18,000 --> 00:18:21,000
и для того, чтобы делать, что вы на самом деле нужно идти по одному символу

284
00:18:21,000 --> 00:18:23,000
за строкой.

285
00:18:23,000 --> 00:18:29,000
Там нет хороший способ называть что-то на ней

286
00:18:29,000 --> 00:18:31,000
потому что даже, например, чтобы я вернет 0

287
00:18:31,000 --> 00:18:37,000
если он не может разобрать целое, так что даже не работает.

288
00:18:37,000 --> 00:18:42,000
Опять же, хорошее сообщение о том, пользователю именно то, что произошло.

289
00:18:42,000 --> 00:18:45,000
Тогда здесь, опять же, мы также обрабатываем случай, когда

290
00:18:45,000 --> 00:18:50,000
Пользователь вводит в элемент управления D случайный характер.

291
00:18:50,000 --> 00:18:54,000
>> И тогда Шарлотта был вопрос ранее о том, как нам удастся пропустить пространства

292
00:18:54,000 --> 00:18:57,000
В нашем строка здесь.

293
00:18:57,000 --> 00:19:00,000
Это было отчасти похоже на то, что мы сделали с Myspace программы

294
00:19:00,000 --> 00:19:04,000
что мы сделали в разделе, и то, как это работает

295
00:19:04,000 --> 00:19:08,000
то, что мы отслеживали количество писем, которые мы видели.

296
00:19:08,000 --> 00:19:13,000
Когда мы шли через строку сообщения, как мы шли по одному символу,

297
00:19:13,000 --> 00:19:16,000
Мы отслеживали индекс как часть нашего цикла, и тогда мы также отслеживали

298
00:19:16,000 --> 00:19:21,000
количество букв, так что без специальных символов, без цифр, без пробелов

299
00:19:21,000 --> 00:19:27,000
что мы видели в отдельной переменной.

300
00:19:27,000 --> 00:19:33,000
А потом это решение изменяет ключ

301
00:19:33,000 --> 00:19:41,000
чтобы получить фактический ключ целое, и он делает это на лету,

302
00:19:41,000 --> 00:19:47,000
Право, прежде чем он потом идет для шифрования фактический характер сообщения.

303
00:19:47,000 --> 00:19:50,000
Есть некоторые решения, которые были совершенно отличными также

304
00:19:50,000 --> 00:19:58,000
что бы изменить вверх при проверке действия ключа.

305
00:19:58,000 --> 00:20:01,000
В дополнение к убедившись, что характер и ключевое слово

306
00:20:01,000 --> 00:20:05,000
был буквы Оказалось также, что в целое

307
00:20:05,000 --> 00:20:13,000
В 0 до 25 диапазон затем пропустить того, чтобы сделать это позже в этом цикле.

308
00:20:13,000 --> 00:20:18,000
Опять же, вы видите здесь, это действительно точно такой же код

309
00:20:18,000 --> 00:20:22,000
которые мы использовали в Цезарь в этой точке.

310
00:20:22,000 --> 00:20:25,000
Ты делаешь одно и то же, так что реальный трюк является выяснение того,

311
00:20:25,000 --> 00:20:30,000
как включить ключевое слово в целое.

312
00:20:30,000 --> 00:20:35,000
>> Одна вещь, которую мы сделали здесь, что несколько плотных

313
00:20:35,000 --> 00:20:39,000
это мы повторили эту фразу, я думаю, вы могли бы назвать его,

314
00:20:39,000 --> 00:20:45,000
3 отдельных раза на 58 линий, 59 и 61.

315
00:20:45,000 --> 00:20:52,000
Может кто-нибудь объяснить, что именно эта фраза делает?

316
00:20:52,000 --> 00:20:55,000
Это доступе характер, как вы сказали.

317
00:20:55,000 --> 00:20:59,000
Да, это [неразборчиво] символов в ключевых слов,

318
00:20:59,000 --> 00:21:04,000
и поэтому это число букв видел, потому что вы только двигаясь вдоль

319
00:21:04,000 --> 00:21:06,000
Ключевое слово раз вы видели письмо,

320
00:21:06,000 --> 00:21:10,000
так что это будет эффективно пропустить пространств и тому подобное.

321
00:21:10,000 --> 00:21:12,000
Да, именно так.

322
00:21:12,000 --> 00:21:16,000
А потом, как только вы видели ключевое слово пустым вы просто мода, чтобы вы вернуться вокруг.

323
00:21:16,000 --> 00:21:18,000
Именно так. Это идеальное объяснение.

324
00:21:18,000 --> 00:21:23,000
Что Кевин сказал, что мы хотим, чтобы индекс в ключевое слово.

325
00:21:23,000 --> 00:21:28,000
Мы хотим, чтобы num_letters_seen характер, если хотите,

326
00:21:28,000 --> 00:21:32,000
Но если num_letters_seen превышает длину ключевого слова,

327
00:21:32,000 --> 00:21:37,000
Так мы вернемся в соответствующем диапазоне мы используем мод оператора

328
00:21:37,000 --> 00:21:40,000
эффективно обернуть вокруг.

329
00:21:40,000 --> 00:21:43,000
Например, как в краткосрочной, наше ключевое слово бекон,

330
00:21:43,000 --> 00:21:46,000
и это 5 букв.

331
00:21:46,000 --> 00:21:50,000
Но мы видели 6 букв в нашей текстом в этой точке

332
00:21:50,000 --> 00:21:52,000
и зашифрованные 6.

333
00:21:52,000 --> 00:21:57,000
Мы в конечном итоге доступ к num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
, что на 6, мод длина ключевого слова, 5,

335
00:22:00,000 --> 00:22:04,000
и таким образом мы получим 1, и так, что мы будем делать это мы будем

336
00:22:04,000 --> 00:22:14,000
доступ к первому в характере нашего ключевого слова в этой точке.

337
00:22:14,000 --> 00:22:21,000
>> Ладно, любые вопросы по Виженера

338
00:22:21,000 --> 00:22:26,000
прежде чем двигаться дальше?

339
00:22:26,000 --> 00:22:31,000
Вы, ребята, чувствовал себя довольно хорошо по этому поводу?

340
00:22:31,000 --> 00:22:35,000
Круто, большое.

341
00:22:35,000 --> 00:22:38,000
Я хочу, чтобы убедиться, что вы, ребята получают шанс увидеть код

342
00:22:38,000 --> 00:22:48,000
что мы думаем, выглядит хорошо, и есть шанс узнать от него.

343
00:22:48,000 --> 00:22:53,000
Это будет последней мы будем использовать пробелы в настоящее время,

344
00:22:53,000 --> 00:22:59,000
и мы собираемся переходить сейчас, и я собираюсь пойти в cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
так что мы можем сделать немного обзора викторины.

346
00:23:06,000 --> 00:23:10,000
Лучший способ Я думаю, что начать делать тест обзор

347
00:23:10,000 --> 00:23:15,000
должен прийти к этой лекции странице, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
и под каждым из заголовков неделю, так что если я смотрю здесь на Неделе 0,

349
00:23:20,000 --> 00:23:27,000
Я вижу, что у нас есть список вопросов, которые мы обсуждали в неделю 0.

350
00:23:27,000 --> 00:23:31,000
>> Если любая из этих тем кажется незнакомой для вас

351
00:23:31,000 --> 00:23:34,000
вы определенно хотите, чтобы вернуться и прочесать лекции и, возможно,

352
00:23:34,000 --> 00:23:39,000
даже бегло лекции, смотреть их снова, если вы хотите

353
00:23:39,000 --> 00:23:44,000
чтобы чувствовать себя за то, что происходит с каждым из этих тем.

354
00:23:44,000 --> 00:23:49,000
Скажу дополнительно в этом году один из прохладных ресурсы у нас есть

355
00:23:49,000 --> 00:23:55,000
Именно эти шорты, которые мы создали, и если вы посмотрите на Неделе 0,

356
00:23:55,000 --> 00:24:00,000
у нас нет всех темам, но у нас есть довольно много из них,

357
00:24:00,000 --> 00:24:03,000
некоторые из них сложнее, поэтому наблюдать эти шорты снова

358
00:24:03,000 --> 00:24:08,000
это хороший способ, чтобы вы до скорости.

359
00:24:08,000 --> 00:24:15,000
В частности, я собираюсь поставить в разъем для 3 на дне, так как я сделал те.

360
00:24:15,000 --> 00:24:20,000
Но если вы боретесь с двоичной, биты, шестигранные, в таком же роде,

361
00:24:20,000 --> 00:24:22,000
двоичных является прекрасным местом для начала.

362
00:24:22,000 --> 00:24:25,000
ASCII еще один, это хорошо, чтобы просмотреть тоже.

363
00:24:25,000 --> 00:24:31,000
Вы даже можете следить за мной в 1,5 раза скорость, если я буду слишком медленным для вас.

364
00:24:31,000 --> 00:24:35,000
Так как это отзыв, не стесняйтесь делать это.

365
00:24:35,000 --> 00:24:40,000
>> Просто, чтобы начать очень быстро, мы собираемся пройти через пару таких викторины проблемы

366
00:24:40,000 --> 00:24:44,000
просто быстро оттока через них.

367
00:24:44,000 --> 00:24:50,000
Например, давайте посмотрим на проблемы 16, что у меня прямо здесь на доске.

368
00:24:50,000 --> 00:24:54,000
У нас это следующий расчет в двоичной,

369
00:24:54,000 --> 00:24:56,000
и мы хотим показать любую работу.

370
00:24:56,000 --> 00:24:59,000
Ладно, я собираюсь дать этому выстрел.

371
00:24:59,000 --> 00:25:01,000
Вы, ребята, должны следовать вместе с бумагой,

372
00:25:01,000 --> 00:25:04,000
и мы будем делать это очень быстро.

373
00:25:04,000 --> 00:25:06,000
Мы хотим, чтобы выполнить следующие расчеты в двоичной системе.

374
00:25:06,000 --> 00:25:16,000
У меня 00110010.

375
00:25:16,000 --> 00:25:27,000
И я собираюсь добавить к нему 00110010.

376
00:25:27,000 --> 00:25:30,000
Для гениев математики следуя вдоль дома,

377
00:25:30,000 --> 00:25:35,000
Это фактически умножением на 2.

378
00:25:35,000 --> 00:25:37,000
Давайте начнем.

379
00:25:37,000 --> 00:25:39,000
Мы собираемся следовать той же алгоритм того, что мы делаем

380
00:25:39,000 --> 00:25:43,000
когда мы добавляем десятичных чисел.

381
00:25:43,000 --> 00:25:46,000
Действительно Единственная разница в том, что мы петля назад вокруг

382
00:25:46,000 --> 00:25:51,000
когда у нас будет 1 + 1, а не только мы получим до 10.

383
00:25:51,000 --> 00:25:53,000
>> Если мы начнем с правой стороны, очень быстро, что первая цифра?

384
00:25:53,000 --> 00:25:55,000
[Студент] 0. >> [Nate H.] 0.

385
00:25:55,000 --> 00:25:58,000
Великий, вторая цифра?

386
00:25:58,000 --> 00:26:00,000
[Студент] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H.] Это 1? 1 + 1 есть?

388
00:26:02,000 --> 00:26:04,000
[Студент] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Точно, так в чем же цифру, что я пишу прямо под 2 единицы складываются?

390
00:26:08,000 --> 00:26:11,000
[Студент] 1, 0 или 0, а затем провести 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H.] 0 и нести 1, точно.

392
00:26:15,000 --> 00:26:18,000
Далее один вверх, Василий, вы вверх.

393
00:26:18,000 --> 00:26:20,000
Какой третий? >> [Василий] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, совершенным. Кевин?

395
00:26:23,000 --> 00:26:27,000
[Кевин] 0. >> [Nate H.] 0, Шарлотта?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H.] Да, и что мне делать?

397
00:26:30,000 --> 00:26:32,000
[Студент] 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H.] И что мне делать? И тогда я несу 1.

399
00:26:34,000 --> 00:26:36,000
Perfect, Sahb? >> [Sahb] Теперь у вас есть 1.

400
00:26:36,000 --> 00:26:40,000
[Nate H.] И я делаю что-то здесь?

401
00:26:40,000 --> 00:26:43,000
[Sahb] Тогда для следующего у вас есть 1, потому что вы переносится на 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Великий, так что здесь мы можем закончить это.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Студент] Ли 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, как вы сказали, 10, или 1, 0, а.

407
00:27:01,000 --> 00:27:07,000
10 является неправильным, потому что мне 10 означает число 10,

408
00:27:07,000 --> 00:27:12,000
и это причуда, как мы, представляя его, когда мы пишем это.

409
00:27:12,000 --> 00:27:20,000
Представим число 2, 1, 0, а число 10 немного отличается.

410
00:27:20,000 --> 00:27:23,000
>> Что отчасти хорошо о бинарных то, что есть на самом деле не так много

411
00:27:23,000 --> 00:27:25,000
случаях нужно учиться.

412
00:27:25,000 --> 00:27:30,000
Там в 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 = 0, а затем выполнить 1,

414
00:27:34,000 --> 00:27:37,000
а затем вы можете увидеть здесь, на третьем столбце справа

415
00:27:37,000 --> 00:27:40,000
у нас было это 1, 1, 1.

416
00:27:40,000 --> 00:27:43,000
А 1 + 1 + 1 1,

417
00:27:43,000 --> 00:27:45,000
и вы несете другую 1.

418
00:27:45,000 --> 00:27:48,000
Когда вы делаете двоичной Кроме того, довольно проста.

419
00:27:48,000 --> 00:27:51,000
Я сделаю еще пару этих здравомыслие проверить себя

420
00:27:51,000 --> 00:27:54,000
прежде чем вы идете, потому что это

421
00:27:54,000 --> 00:28:00,000
вероятно, то, что мы видим на викторину.

422
00:28:00,000 --> 00:28:03,000
Теперь давайте сделаем это в следующий также.

423
00:28:03,000 --> 00:28:06,000
Давайте сделаем проблемы 17.

424
00:28:06,000 --> 00:28:12,000
Мы собираемся преобразовать следующим двоичного числа в десятичное.

425
00:28:12,000 --> 00:28:28,000
У меня 10100111001.

426
00:28:28,000 --> 00:28:33,000
Помните, в двоичном видео, которое я сделал

427
00:28:33,000 --> 00:28:36,000
Я шел через пару примеров, и я показал, как

428
00:28:36,000 --> 00:28:41,000
все работает, когда вы делаете это в десятичной системе.

429
00:28:41,000 --> 00:28:45,000
Когда вы работаете в десятичное представление Я думаю, что мы

430
00:28:45,000 --> 00:28:48,000
На данный момент в нашей жизни так бегло говорит на это, что

431
00:28:48,000 --> 00:28:53,000
это довольно легко замазать механику того, как она действительно работает.

432
00:28:53,000 --> 00:28:59,000
>> Но чтобы сделать быстрое резюме, если у меня есть номер 137

433
00:28:59,000 --> 00:29:06,000
В действительности это означает и опять же, это в десятичное представление-

434
00:29:06,000 --> 00:29:19,000
число 137 в десятичной означает, что у меня есть 1 х 100 + 3 х 10 + 7 х 1.

435
00:29:19,000 --> 00:29:22,000
Это все пребывания на экране.

436
00:29:22,000 --> 00:29:29,000
И потом, если вы посмотрите на эти цифры прямо здесь,

437
00:29:29,000 --> 00:29:34,000
100, 10 и 1, вы видите, что они на самом деле все полномочия 10.

438
00:29:34,000 --> 00:29:43,000
У меня есть 10 ², 10 ¹, и от 10 до нуля.

439
00:29:43,000 --> 00:29:48,000
У нас подобного рода вещи в двоичной,

440
00:29:48,000 --> 00:29:55,000
исключением того, что наша база, как мы его называем, составляет 2 вместо 10.

441
00:29:55,000 --> 00:29:58,000
Эти 10s, что я написал здесь на дне,

442
00:29:58,000 --> 00:30:02,000
это 10 ², 10 ¹, 10 до нуля, 10, наша база,

443
00:30:02,000 --> 00:30:08,000
и показатель, 0, 1, или 2,

444
00:30:08,000 --> 00:30:14,000
вытекает из положения цифры в номере, что мы пишем.

445
00:30:14,000 --> 00:30:21,000
1, если мы посмотрим на это, это 1, во 2-й позиции.

446
00:30:21,000 --> 00:30:27,000
3 в 1-й позиции, а 7 находится в 0-й позиции.

447
00:30:27,000 --> 00:30:35,000
Вот как мы получим различные показатели ниже для нашей базы.

448
00:30:35,000 --> 00:30:40,000
>> После всего этого МЫ-на самом деле, вы знаете, что?

449
00:30:40,000 --> 00:30:43,000
Мы сделаем все, где же мой отменить кнопку идти?

450
00:30:43,000 --> 00:30:45,000
Там он идет.

451
00:30:45,000 --> 00:30:47,000
Я люблю эту вещь отменить.

452
00:30:47,000 --> 00:30:51,000
После этого я думаю, для меня по крайней мере

453
00:30:51,000 --> 00:30:54,000
Самый простой способ начать преобразования двоичного числа

454
00:30:54,000 --> 00:30:57,000
или шестнадцатеричное число, где база находится в 16

455
00:30:57,000 --> 00:31:02,000
, а не 10 или 2, чтобы идти вперед и пишем

456
00:31:02,000 --> 00:31:09,000
баз и индексов для всех чисел в моей двоичного числа в верхней части.

457
00:31:09,000 --> 00:31:14,000
Если мы начнем слева направо снова,

458
00:31:14,000 --> 00:31:17,000
которая является своеобразной парадоксально,

459
00:31:17,000 --> 00:31:23,000
Я изменю Back To Black здесь, у нас есть 2 до 0-я позиция,

460
00:31:23,000 --> 00:31:27,000
а то у нас 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
а затем от 2 до 3, от 2 до 4, 2 к 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9 и 10.

463
00:31:39,000 --> 00:31:41,000
Эти цифры я выписал все показатели.

464
00:31:41,000 --> 00:31:48,000
Я только написал баз здесь в первые 3 только для пространства.

465
00:31:48,000 --> 00:31:50,000
>> На данный момент я собираюсь идти вперед и на самом деле я собираюсь стереть

466
00:31:50,000 --> 00:31:53,000
вещи, которые мы сделали в десятичной, если это нормально.

467
00:31:53,000 --> 00:31:57,000
Вы все понял.

468
00:31:57,000 --> 00:32:05,000
Те из вас, смотреть онлайн Я уверена, что сможет перемотать меня, если хотите.

469
00:32:05,000 --> 00:32:07,000
Переключение обратно на перо.

470
00:32:07,000 --> 00:32:12,000
Итак, что мы можем сделать, если вы, ребята, не полностью до скорости на свои силы 2,

471
00:32:12,000 --> 00:32:15,000
это абсолютно здорово.

472
00:32:15,000 --> 00:32:18,000
Это бывает. Я понимаю.

473
00:32:18,000 --> 00:32:23,000
Я когда-то на собеседование, где мне сказали, что я должен знать все степени числа 2

474
00:32:23,000 --> 00:32:26,000
вверх через 2 до 30.

475
00:32:26,000 --> 00:32:29,000
Это была не работа у меня есть.

476
00:32:29,000 --> 00:32:32,000
В любом случае, вы, ребята, можете идти вперед и делать математику здесь,

477
00:32:32,000 --> 00:32:35,000
но с бинарными это действительно не имеет смысла,

478
00:32:35,000 --> 00:32:38,000
и также не имеет смысла с десятичной или шестнадцатеричной либо,

479
00:32:38,000 --> 00:32:43,000
делать математику, где у вас есть нули.

480
00:32:43,000 --> 00:32:49,000
Вы можете видеть, у меня 0 здесь, сюда 0, 0 здесь, 0 здесь, 0 здесь, 0 здесь.

481
00:32:49,000 --> 00:32:52,000
Почему это могло бы никакого смысла делать фактические математике

482
00:32:52,000 --> 00:32:56,000
Для расчета соответствующей мощности 2 на эту должность?

483
00:32:56,000 --> 00:32:59,000
Именно так, как сказала Шарлотта, это будет 0.

484
00:32:59,000 --> 00:33:05,000
Мог бы также сэкономить время, если вычисления степени числа 2 не является вашей сильной стороной.

485
00:33:05,000 --> 00:33:10,000
В этом случае нам нужно только вычислить его для 2 к 0, что-?

486
00:33:10,000 --> 00:33:12,000
[Студент] 1.

487
00:33:12,000 --> 00:33:14,000
[Nate H.] 1, 2 до 3, который является-?

488
00:33:14,000 --> 00:33:16,000
[Студент] 8. >> [Nate H.] 8.

489
00:33:16,000 --> 00:33:18,000
От 2 до 4?

490
00:33:18,000 --> 00:33:21,000
[Студент] 2. Мне очень жаль, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H.] 2 до 4, 16, точно.

492
00:33:26,000 --> 00:33:28,000
От 2 до 5, Кевин? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, от 2 до 8?

494
00:33:32,000 --> 00:33:38,000
[Студент] 32 х 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H.] Perfect.

496
00:33:41,000 --> 00:33:43,000
И от 2 до 10?

497
00:33:43,000 --> 00:33:45,000
[Студент] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Да, 1024.

499
00:33:49,000 --> 00:33:57,000
>> После того как мы получили эти цифры мы можем подвести их все.

500
00:33:57,000 --> 00:34:01,000
И это, где это действительно важно сделать несколько вещей.

501
00:34:01,000 --> 00:34:07,000
Один из них идут медленно и проверить вашу работу.

502
00:34:07,000 --> 00:34:10,000
Вы можете сказать, что есть 1 в конце этого числа,

503
00:34:10,000 --> 00:34:15,000
так что я обязательно должны получить нечетное число, как мой результат,

504
00:34:15,000 --> 00:34:18,000
потому что все остальные собираются быть четными номерами

505
00:34:18,000 --> 00:34:21,000
учитывая, что это двоичное число.

506
00:34:21,000 --> 00:34:24,000
Другая вещь, которую нужно сделать, это если вы добраться до этой точки на испытательном

507
00:34:24,000 --> 00:34:27,000
и вы написали ее так далеко

508
00:34:27,000 --> 00:34:30,000
и вы работаете вне времени

509
00:34:30,000 --> 00:34:33,000
посмотрите на количество очков, что эта проблема стоит.

510
00:34:33,000 --> 00:34:40,000
Эта проблема, как вы можете видеть, если я сальто назад с моим ноутбуком действительно быстро-

511
00:34:40,000 --> 00:34:44,000
эта проблема стоит 2 очка, так что это не из того

512
00:34:44,000 --> 00:34:47,000
Вы должны идти через, если вы действительно мало времени.

513
00:34:47,000 --> 00:34:52,000
Но мы будем вернуться к iPad, и мы будем пройти через это очень быстро.

514
00:34:52,000 --> 00:34:54,000
>> Мне нравится делать небольшие числа сначала

515
00:34:54,000 --> 00:34:56,000
потому что я считаю, что проще.

516
00:34:56,000 --> 00:35:00,000
Мне нравится 32 и 8, потому что они идут вместе довольно легко, и мы получаем 50.

517
00:35:00,000 --> 00:35:03,000
16 и 1 получает 17.

518
00:35:03,000 --> 00:35:05,000
Там мы получим 57,

519
00:35:05,000 --> 00:35:14,000
и тогда мы сможем сделать все остальное из этого, так что мы можем сделать, 57, 156.

520
00:35:14,000 --> 00:35:16,000
Пойдем.

521
00:35:16,000 --> 00:35:19,000
Человек, хорошо, давайте посмотрим.

522
00:35:19,000 --> 00:35:27,000
У нас было 57, 256 и 1024.

523
00:35:27,000 --> 00:35:31,000
На данный момент, я бы просто пройти.

524
00:35:31,000 --> 00:35:35,000
Я понятия не имею. Я четко нужно читать на этом.

525
00:35:35,000 --> 00:35:40,000
7, 6, 4, Вы получаете 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Тогда мы получим 3, а затем мы получаем 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Пасхальное яйцо, никто?

530
00:35:55,000 --> 00:35:59,000
Никто признать этот номер?

531
00:35:59,000 --> 00:36:02,000
Крис признается числа. Что это значит, Крис?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, так что если вы посмотрите на это, похоже, Лит.

534
00:36:11,000 --> 00:36:15,000
Хакер вещи. Следите за такого рода вещи по среднесрочному или тест, а.

535
00:36:15,000 --> 00:36:19,000
Если вы видите такие вещи, и вы задаетесь вопросом "А"

536
00:36:19,000 --> 00:36:22,000
, что может на самом деле что-то значат.

537
00:36:22,000 --> 00:36:24,000
Я не знаю. Дэвид любит положить его дюйма

538
00:36:24,000 --> 00:36:26,000
Это хороший способ проверить его вменяемость.

539
00:36:26,000 --> 00:36:30,000
Как хорошо, я вижу, что происходит.

540
00:36:30,000 --> 00:36:34,000
>> Вот неделя 1 0/Week вещи.

541
00:36:34,000 --> 00:36:39,000
Если вернуться к нашим ноутбуком сейчас,

542
00:36:39,000 --> 00:36:46,000
уменьшить масштаб, и пару других вещей.

543
00:36:46,000 --> 00:36:50,000
Там в ASCII, которые мы делали много с проблемой набора.

544
00:36:50,000 --> 00:36:55,000
Это понятие капитала A. Что это на самом деле?

545
00:36:55,000 --> 00:36:57,000
Зная это десятичное число.

546
00:36:57,000 --> 00:37:00,000
65 является то, что он отображается в таблице ASCII,

547
00:37:00,000 --> 00:37:03,000
и вот поэтому, как компьютер пишет он,

548
00:37:03,000 --> 00:37:06,000
и это, как мы уже сходит с фактической записи

549
00:37:06,000 --> 00:37:09,000
характер капитала и характер нижнего регистра

550
00:37:09,000 --> 00:37:14,000
В некоторых из этих решений и проблема набора, что вы делали.

551
00:37:14,000 --> 00:37:16,000
Несколько других вещей.

552
00:37:16,000 --> 00:37:25,000
У нас есть заявления, логические выражения, условия, циклы, переменные и потоков.

553
00:37:25,000 --> 00:37:29,000
>> Те, все, кажется, имеет смысл по большей части?

554
00:37:29,000 --> 00:37:35,000
Некоторые из этой терминологии немного напуганным в разы.

555
00:37:35,000 --> 00:37:46,000
Мне нравится думать, заявления, как по большей части то, что заканчивается точкой с запятой.

556
00:37:46,000 --> 00:37:51,000
Такие заявления, как х = 7, которая устанавливает переменную

557
00:37:51,000 --> 00:37:54,000
Предположительно называется х = 7.

558
00:37:54,000 --> 00:38:01,000
Предположительно х также тип, который может сохранить номер 7,

559
00:38:01,000 --> 00:38:05,000
так что Int или, возможно, теркой или короткая или символ,

560
00:38:05,000 --> 00:38:07,000
что-то вроде этого.

561
00:38:07,000 --> 00:38:12,000
Логическое выражение использует эти двойные равно

562
00:38:12,000 --> 00:38:17,000
и взрыва равна или не равна, меньше, больше, чем,

563
00:38:17,000 --> 00:38:22,000
меньше или равны, все в таком же роде.

564
00:38:22,000 --> 00:38:28,000
Условия то есть, если другое отчетности.

565
00:38:28,000 --> 00:38:32,000
Я помню, что вы не можете иметь другое без соответствующих если.

566
00:38:32,000 --> 00:38:37,000
Кроме того, вы не можете иметь еще, если без соответствующих если.

567
00:38:37,000 --> 00:38:40,000
Петли, напомним 3 вида петель мы были в вас молотком

568
00:38:40,000 --> 00:38:43,000
за последние пару секций и проблемы множества.

569
00:38:43,000 --> 00:38:46,000
Использование же время, когда вы получаете пользовательского ввода,

570
00:38:46,000 --> 00:38:51,000
использование в то время как петли, пока определенное условие истинно,

571
00:38:51,000 --> 00:38:56,000
, а затем с помощью этих циклов, если вам нужно

572
00:38:56,000 --> 00:39:01,000
знать, какие итерации цикла вы сейчас находитесь, как я думаю об этом.

573
00:39:01,000 --> 00:39:07,000
Или если вы делаете для каждого символа в строке я хочу что-то сделать,

574
00:39:07,000 --> 00:39:15,000
Для каждого элемента в массиве я хочу что-то сделать, чтобы этого элемента.

575
00:39:15,000 --> 00:39:18,000
>> Темы и события.

576
00:39:18,000 --> 00:39:21,000
Эти которые мы не так явно в C,

577
00:39:21,000 --> 00:39:23,000
но помните, это с нуля.

578
00:39:23,000 --> 00:39:26,000
Это понятие, имеющих различные сценарии.

579
00:39:26,000 --> 00:39:32,000
Это тоже это понятие трансляции события.

580
00:39:32,000 --> 00:39:37,000
Некоторые люди не использовали вещание в своих проектах на начальном этапе,

581
00:39:37,000 --> 00:39:40,000
который полностью прохладно,

582
00:39:40,000 --> 00:39:46,000
но эти 2 разные способы обработки этого больше проблем, параллелизм,

583
00:39:46,000 --> 00:39:49,000
который является, как вы получаете программ для выполнения

584
00:39:49,000 --> 00:39:54,000
или, казалось бы выполнить в то же время?

585
00:39:54,000 --> 00:39:59,000
Различные задачи, выполняемые в то время как другие задачи также работает.

586
00:39:59,000 --> 00:40:01,000
Это, как ваша операционная система, кажется, работает.

587
00:40:01,000 --> 00:40:04,000
Вот почему, хотя, например,

588
00:40:04,000 --> 00:40:10,000
У меня есть мой браузер работает, я также можете включить Spotify и играть песни.

589
00:40:10,000 --> 00:40:14,000
Это больше, концептуальные вещи, чтобы понять.

590
00:40:14,000 --> 00:40:17,000
Я хотел бы взглянуть на темы, коротко

591
00:40:17,000 --> 00:40:21,000
Если вы хотите узнать больше об этом.

592
00:40:21,000 --> 00:40:26,000
>> Давайте посмотрим, я считаю, что можно было бы

593
00:40:26,000 --> 00:40:31,000
Проблема об этом в одном из них.

594
00:40:31,000 --> 00:40:35,000
Опять же, я думаю, что темы и события, не то, что мы рассмотрим в C

595
00:40:35,000 --> 00:40:41,000
только потому, что это значительно труднее, чем в Scratch.

596
00:40:41,000 --> 00:40:44,000
Вы не должны беспокоиться о ней, но, безусловно, понимают концепции,

597
00:40:44,000 --> 00:40:47,000
понять, что происходит.

598
00:40:47,000 --> 00:40:52,000
Прежде чем двигаться дальше, любые вопросы на неделю 0 материалов?

599
00:40:52,000 --> 00:40:55,000
Каждый чувствовал себя довольно хорошо?

600
00:40:55,000 --> 00:41:03,000
Понимание переменных и что такое переменная?

601
00:41:03,000 --> 00:41:08,000
>> Двигаемся дальше. Неделя 1.

602
00:41:08,000 --> 00:41:12,000
Несколько вещей здесь, которые не были особенно покрытые

603
00:41:12,000 --> 00:41:21,000
В викторине отзыв обязательно, а также более концептуальные вещи, чтобы думать.

604
00:41:21,000 --> 00:41:30,000
Во-первых, это понятие о том, что исходный код, компиляторы и объектный код есть.

605
00:41:30,000 --> 00:41:32,000
Кто-нибудь? Василия.

606
00:41:32,000 --> 00:41:37,000
Является объектно-код я имею в виду исходного кода является то, что вы положили в лязг,

607
00:41:37,000 --> 00:41:42,000
и объектный код является то, что звоном ставит так, что ваш компьютер может прочитать программу.

608
00:41:42,000 --> 00:41:44,000
Именно так.

609
00:41:44,000 --> 00:41:47,000
Исходный код код C, что вы на самом деле напечатать.

610
00:41:47,000 --> 00:41:50,000
Код объекта является то, что вы выходите из лязг.

611
00:41:50,000 --> 00:41:54,000
Это 0 и 1, что в двоичном формате.

612
00:41:54,000 --> 00:41:59,000
Тогда что же происходит, когда у вас есть несколько объектных файлов,

613
00:41:59,000 --> 00:42:04,000
сказать, что вы собираете проект или программа, которая использует несколько файлов исходного кода,

614
00:42:04,000 --> 00:42:09,000
которые по соглашению предоставляется. с расширением файла.

615
00:42:09,000 --> 00:42:13,000
Вот почему у нас есть caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Если вы пишете Java программы вы даете им расширение. Java.

617
00:42:18,000 --> 00:42:24,000
Python программы имеют расширение. Ру часто.

618
00:42:24,000 --> 00:42:26,000
>> Если у вас есть несколько. С файлами, вы их компиляции.

619
00:42:26,000 --> 00:42:29,000
Clang выплевывает все это двоичный мусор.

620
00:42:29,000 --> 00:42:33,000
Потом, потому что вы только хотите 1 программа

621
00:42:33,000 --> 00:42:37,000
у вас есть компоновщик ссылке все эти объектные файлы вместе

622
00:42:37,000 --> 00:42:40,000
в 1 исполняемый файл.

623
00:42:40,000 --> 00:42:45,000
Это также то, что происходит, когда вы используете CS50 библиотеке, например.

624
00:42:45,000 --> 00:42:50,000
Библиотека CS50 является и то. Ч. файл заголовка

625
00:42:50,000 --> 00:42:53,000
что вы читаете, что # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
И тогда это также специальный файл библиотеки двоичных

627
00:42:58,000 --> 00:43:02,000
, которое было составлено это 0 и 1,

628
00:43:02,000 --> 00:43:08,000
и что-л флаг, поэтому, если мы вернемся к нашим пространствам и мы смотрим очень быстро

629
00:43:08,000 --> 00:43:11,000
на то, что здесь происходит, когда мы смотрим на нашу команду лязг,

630
00:43:11,000 --> 00:43:15,000
то, что мы получили, это наш исходный код файла прямо здесь.

631
00:43:15,000 --> 00:43:18,000
Это куча флагов компилятора.

632
00:43:18,000 --> 00:43:22,000
И тогда в самом конце, эти-л флаги ссылку в

633
00:43:22,000 --> 00:43:30,000
фактические двоичные файлы на эти 2 библиотеки, CS50 библиотеки, а затем математическую библиотеку.

634
00:43:30,000 --> 00:43:35,000
>> Понимание каждого типа файлов цели "

635
00:43:35,000 --> 00:43:38,000
В процессе компиляции является то, что вы хотите, чтобы иметь возможность

636
00:43:38,000 --> 00:43:43,000
дать хотя бы подробный обзор.

637
00:43:43,000 --> 00:43:46,000
Исходный код приходит дюйма Код объекта выходит.

638
00:43:46,000 --> 00:43:53,000
Файлы Код объекта связать вместе, и вы получите красивый, исполняемый файл.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Это также, где вы можете получить ошибки в нескольких точках

641
00:43:58,000 --> 00:44:00,000
В процессе компиляции.

642
00:44:00,000 --> 00:44:04,000
Это когда, например, если вы возьмете эту связь флаг,

643
00:44:04,000 --> 00:44:10,000
CS50 флаг, и вы опустите его в пространстве или когда вы работаете ваш код,

644
00:44:10,000 --> 00:44:13,000
это где вы получите ошибку в стадии компоновки,

645
00:44:13,000 --> 00:44:18,000
и компоновщик будет сказать: "Эй, вы называется функцией GetString

646
00:44:18,000 --> 00:44:20,000
, который в CS50 библиотеки ».

647
00:44:20,000 --> 00:44:25,000
"Вы сказали мне, что в CS50 библиотека, и я не могу найти код для него."

648
00:44:25,000 --> 00:44:28,000
Вот где вы должны связать его, и это отдельная

649
00:44:28,000 --> 00:44:33,000
от ошибки компилятора, потому что компилятор смотрит на синтаксис и такого рода вещи.

650
00:44:33,000 --> 00:44:38,000
Это хорошо, чтобы знать, что происходит, когда.

651
00:44:38,000 --> 00:44:42,000
>> Другие вещи, чтобы знать.

652
00:44:42,000 --> 00:44:49,000
Я бы сказал, вы определенно хотите, чтобы взглянуть на коротком на приведение сделано Иордании

653
00:44:49,000 --> 00:44:55,000
чтобы понять, что целыми находится под капотом,

654
00:44:55,000 --> 00:44:58,000
какие символы находятся под капотом.

655
00:44:58,000 --> 00:45:02,000
Когда мы говорим о ASCII, и мы на самом деле смотрим на таблицу ASCII,

656
00:45:02,000 --> 00:45:07,000
что это делает дает нам под капотом взгляд

657
00:45:07,000 --> 00:45:13,000
на то, как компьютер на самом деле представляет капитала и цифры 7

658
00:45:13,000 --> 00:45:17,000
и запятая и знак вопроса.

659
00:45:17,000 --> 00:45:20,000
Компьютер также имеет специальные способы представления

660
00:45:20,000 --> 00:45:23,000
число 7, как число.

661
00:45:23,000 --> 00:45:27,000
Это имеет особое способ представления числа 7 как число с плавающей точкой,

662
00:45:27,000 --> 00:45:29,000
и тех, кто очень разные.

663
00:45:29,000 --> 00:45:32,000
Приведение то, как вы говорите компьютер "Эй, я хочу вам конвертировать

664
00:45:32,000 --> 00:45:37,000
от одного представления к другому представлению ".

665
00:45:37,000 --> 00:45:40,000
Почему бы нам не посмотреть на это.

666
00:45:40,000 --> 00:45:44,000
>> Я хотел бы также взглянуть на коротких по библиотекам и короткий на компиляторы.

667
00:45:44,000 --> 00:45:47,000
Эти разговоры о процессе компиляции,

668
00:45:47,000 --> 00:45:53,000
что библиотека, и перейти на некоторые из этих вопросов, которые вы могли бы спросил.

669
00:45:53,000 --> 00:45:55,000
Вопросы по неделя 1 материал?

670
00:45:55,000 --> 00:46:03,000
Есть ли темы здесь, что в уныние вы хотите, чтобы покрыть?

671
00:46:03,000 --> 00:46:07,000
Я стараюсь, чтобы продуть большинство из них ранее тем, чтобы мы могли добраться до

672
00:46:07,000 --> 00:46:13,000
указателей и сделать немного рекурсии.

673
00:46:13,000 --> 00:46:15,000
Мысли?

674
00:46:15,000 --> 00:46:19,000
Все, что для покрытия?

675
00:46:19,000 --> 00:46:21,000
Время для некоторых шоколад может быть?

676
00:46:21,000 --> 00:46:23,000
Вы, ребята, работаете через него.

677
00:46:23,000 --> 00:46:26,000
Я буду держать потягивая свой кофе.

678
00:46:26,000 --> 00:46:31,000
2-я неделя.

679
00:46:31,000 --> 00:46:34,000
Хорошее слово, хороший вызов.

680
00:46:34,000 --> 00:46:38,000
В 2-я неделя, мы говорили немного больше о функциях.

681
00:46:38,000 --> 00:46:43,000
>> В первые несколько комплектов проблемы мы действительно не писать никаких функций на всех

682
00:46:43,000 --> 00:46:45,000
кроме котором функция?

683
00:46:45,000 --> 00:46:47,000
[Студент] Main. >> Главное, точно.

684
00:46:47,000 --> 00:46:51,000
И так мы видели разные костюмы, что основной носит.

685
00:46:51,000 --> 00:46:54,000
Там в одной, в которой он не принимает аргументов,

686
00:46:54,000 --> 00:46:58,000
и мы просто скажем, пустоту в круглых скобках,

687
00:46:58,000 --> 00:47:01,000
и тогда есть другой, где мы хотим принимать аргументы командной строки,

688
00:47:01,000 --> 00:47:08,000
и, как мы видели, что там у вас есть Int ARGC и ARGV массив строк

689
00:47:08,000 --> 00:47:13,000
или теперь, когда мы на самом деле подвергается строки, чтобы быть символ *, что

690
00:47:13,000 --> 00:47:20,000
мы собираемся, чтобы начать писать его как символ * ARGV, а затем скобки.

691
00:47:20,000 --> 00:47:22,000
В задаче Set 3, вы, ребята, видели кучу функций,

692
00:47:22,000 --> 00:47:27,000
и вы реализовали кучу функций, рисовать, смотреть вверх, схватка.

693
00:47:27,000 --> 00:47:31,000
Прототипы были написаны там для вас.

694
00:47:31,000 --> 00:47:33,000
>> То, что я хотел рассказать о здесь с функциями очень быстро

695
00:47:33,000 --> 00:47:38,000
является то, что существует 3 частей к ним всякий раз, когда вы пишете функцию.

696
00:47:38,000 --> 00:47:43,000
Вы должны указать тип возвращаемого значения функции.

697
00:47:43,000 --> 00:47:46,000
Вы должны указать имя функции, а затем вы должны указать

698
00:47:46,000 --> 00:47:51,000
Список аргументов или списка параметров.

699
00:47:51,000 --> 00:47:57,000
Например, если бы я написать функцию, чтобы подвести итоги кучу целых чисел

700
00:47:57,000 --> 00:48:03,000
, а затем вернуться ко мне сумму, что было бы моего возвращения типа

701
00:48:03,000 --> 00:48:06,000
если бы я хотел, чтобы подвести целых чисел, а затем вернуть сумму?

702
00:48:06,000 --> 00:48:12,000
Тогда имя функции.

703
00:48:12,000 --> 00:48:27,000
Если я пойду вперед и написать в зеленый, эта часть возвращаемого типа.

704
00:48:27,000 --> 00:48:34,000
Эта часть названия.

705
00:48:34,000 --> 00:48:40,000
А потом в скобках

706
00:48:40,000 --> 00:48:46,000
Здесь я даю аргументы,

707
00:48:46,000 --> 00:48:56,000
Часто сокращенно аргументы, которые иногда называются параметрами для параметров.

708
00:48:56,000 --> 00:49:00,000
И если у вас есть, вы просто указываете один.

709
00:49:00,000 --> 00:49:06,000
Если у вас несколько вы разделите каждый с запятой.

710
00:49:06,000 --> 00:49:13,000
И для каждого аргумента, вы даете ему 2 вещи, которые, Кевин?

711
00:49:13,000 --> 00:49:18,000
[Кевин] Вы должны дать типа, а затем имя.

712
00:49:18,000 --> 00:49:21,000
И то имя, и имя это имя, которое вы собираетесь использовать

713
00:49:21,000 --> 00:49:25,000
ссылаться на этот аргумент в пределах суммы функций,

714
00:49:25,000 --> 00:49:27,000
в пределах функции, которые вы в настоящее время написания.

715
00:49:27,000 --> 00:49:32,000
>> Вы не должны, например, если я собираюсь подводить итоги,

716
00:49:32,000 --> 00:49:41,000
скажем, массив целых чисел-Мы делаем Int массива,

717
00:49:41,000 --> 00:49:46,000
и я дам себе некоторые фигурные скобки там-

718
00:49:46,000 --> 00:49:51,000
Затем, когда я передать массив в сумме функций

719
00:49:51,000 --> 00:49:55,000
Я передаю его в первую позицию списка аргументов.

720
00:49:55,000 --> 00:49:59,000
Но массив, который я прохожу в не должна иметь название обр.

721
00:49:59,000 --> 00:50:07,000
Обр будет, как я ссылаться на этот аргумент в теле функции.

722
00:50:07,000 --> 00:50:10,000
Другое дело, что мы должны принять во внимание,

723
00:50:10,000 --> 00:50:14,000
и это немного отличается от функции, но я думаю, это важный момент,

724
00:50:14,000 --> 00:50:20,000
является то, что в C, когда я пишу эту функцию, как

725
00:50:20,000 --> 00:50:29,000
Откуда я знаю, сколько элементов в этом массиве?

726
00:50:29,000 --> 00:50:31,000
Это своего рода вопрос с подвохом.

727
00:50:31,000 --> 00:50:35,000
Мы говорили об этом немного в разделе прошлой неделе.

728
00:50:35,000 --> 00:50:40,000
Как мне узнать количество элементов внутри массива в C?

729
00:50:40,000 --> 00:50:44,000
Есть ли способ?

730
00:50:44,000 --> 00:50:49,000
>> Оказывается, что нет никакого способа узнать.

731
00:50:49,000 --> 00:50:52,000
Вы должны передать его в отдельности.

732
00:50:52,000 --> 00:50:55,000
Существует трюк, который вы можете сделать

733
00:50:55,000 --> 00:51:00,000
если вы находитесь в той же функцией, в которой массив был объявлен,

734
00:51:00,000 --> 00:51:04,000
и вы работаете со стеком массива.

735
00:51:04,000 --> 00:51:06,000
Но это работает, только если вы находитесь в той же функции.

736
00:51:06,000 --> 00:51:09,000
После того как вы передать массив в другую функцию или если вы объявили массив

737
00:51:09,000 --> 00:51:12,000
а вы ставите этот массив в куче, вы использовали таНос

738
00:51:12,000 --> 00:51:15,000
 и в таком же роде, то все ставки выключены.

739
00:51:15,000 --> 00:51:18,000
Тогда вам на самом деле нужно обойти

740
00:51:18,000 --> 00:51:21,000
специальный аргумент или другой параметр

741
00:51:21,000 --> 00:51:23,000
говорю вам, как большой массив.

742
00:51:23,000 --> 00:51:28,000
В этом случае, я хотел бы использовать запятую-Простите, это будет от экрана здесь-

743
00:51:28,000 --> 00:51:32,000
и я бы перейти в другой аргумент

744
00:51:32,000 --> 00:51:40,000
 и называть его Int длина по длине.

745
00:51:40,000 --> 00:51:44,000
>> Одна вещь, которая может прийти на тест

746
00:51:44,000 --> 00:51:49,000
просит вас написать или осуществлять определенную функцию называют что-то.

747
00:51:49,000 --> 00:51:54,000
Если мы не дадим вам прототип, так что это все дело здесь,

748
00:51:54,000 --> 00:51:58,000
весь этот бардак называется объявление функции или прототип функции,

749
00:51:58,000 --> 00:52:01,000
это одна из первых вещей, которые вы хотите, чтобы прибить, если она не дано

750
00:52:01,000 --> 00:52:03,000
Вам сразу на викторину.

751
00:52:03,000 --> 00:52:06,000
Другой трюк я узнал, что

752
00:52:06,000 --> 00:52:11,000
сказать, что мы действительно дают вам прототип функции, и мы говорим: "Эй, ты должен писать".

753
00:52:11,000 --> 00:52:16,000
Внутри фигурных скобках, что у вас на тест

754
00:52:16,000 --> 00:52:20,000
Если вы заметите, что есть возвращаемого типа, и вы заметите, что тип возвращаемого

755
00:52:20,000 --> 00:52:25,000
это нечто иное, чем пустота, которая означает, что функция не возвращает ничего,

756
00:52:25,000 --> 00:52:28,000
то, что вы определенно хотите сделать, это написать

757
00:52:28,000 --> 00:52:33,000
своего рода возвращение заявления в самом конце функции.

758
00:52:33,000 --> 00:52:40,000
Возвращение, и в этом случае, мы будем ставить пустую, потому что мы хотим, чтобы заполнить пустые.

759
00:52:40,000 --> 00:52:44,000
Но это получает вас думать в правильном направлении, о том, как я буду подходить к этой проблеме?

760
00:52:44,000 --> 00:52:49,000
И это напоминает вам, что вы будете иметь, чтобы вернуть значение

761
00:52:49,000 --> 00:52:51,000
вызывающей функции.

762
00:52:51,000 --> 00:52:54,000
>> Да. >> [Студент] ли стиль применяется, когда мы пишем код на викторину?

763
00:52:54,000 --> 00:52:58,000
Такие, как отступ и в таком же роде? >> [Студент] Да.

764
00:52:58,000 --> 00:53:00,000
Нет, не так много.

765
00:53:00,000 --> 00:53:09,000
Я думаю, что много-это то, что мы будем уточнить на викторину в день,

766
00:53:09,000 --> 00:53:15,000
но, как правило беспокоясь о # включает в себя и в таком же роде, это вид снаружи.

767
00:53:15,000 --> 00:53:17,000
[Студент] Вам нужно комментировать свои рукописные код?

768
00:53:17,000 --> 00:53:19,000
Вам нужно комментировать свои рукописные код?

769
00:53:19,000 --> 00:53:24,000
Комментируя это всегда хорошо, если вы беспокоитесь о частичной кредитной

770
00:53:24,000 --> 00:53:29,000
или вы хотите сообщить о своем намерении грейдер.

771
00:53:29,000 --> 00:53:33,000
Но я, опять же, будет уточнить на викторину себя и в тот день, викторины,

772
00:53:33,000 --> 00:53:39,000
Но я не верю, что вы будете обязаны писать комментарии, нет.

773
00:53:39,000 --> 00:53:42,000
Как правило, нет, но это определенно та вещь, где

774
00:53:42,000 --> 00:53:45,000
Вы можете сообщить ваши намерения, как "Эй, это куда я иду с ним".

775
00:53:45,000 --> 00:53:49,000
И иногда это может помочь с частичным кредита.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Василия.

778
00:53:53,000 --> 00:53:56,000
[Василий] В чем разница между объявлении, скажем, внутр язык

779
00:53:56,000 --> 00:54:03,000
в аргументах или параметрах по сравнению с объявлением переменной внутри функции?

780
00:54:03,000 --> 00:54:05,000
Wow, кофе пошел в дыхательное горло.

781
00:54:05,000 --> 00:54:07,000
[Василий] Как которое вещей, которые мы хотим поместить в аргументах.

782
00:54:07,000 --> 00:54:09,000
Да, это большой вопрос.

783
00:54:09,000 --> 00:54:11,000
Как вы выбираете то, что вещи, которые вы хотите поместить в рассуждениях

784
00:54:11,000 --> 00:54:17,000
против того, что вещи, которые вы должны делать внутри функции?

785
00:54:17,000 --> 00:54:24,000
В этом случае мы включили оба этих качестве аргументов

786
00:54:24,000 --> 00:54:29,000
потому что они то, что тот, кто собирается использовать функцию суммы

787
00:54:29,000 --> 00:54:32,000
Необходимо указать эти вещи.

788
00:54:32,000 --> 00:54:35,000
>> Сумма функция, о которой мы говорили, не имеет возможности узнать,

789
00:54:35,000 --> 00:54:40,000
насколько большой массив она получает от своего абонента или тот, кто использует сумму функцию.

790
00:54:40,000 --> 00:54:44,000
Он не имеет возможности узнать, как большой, что массив.

791
00:54:44,000 --> 00:54:48,000
Поэтому мы пройти в этом длина прямо здесь в качестве аргумента

792
00:54:48,000 --> 00:54:51,000
потому, что это то, что мы в основном говорят вызывающей функции,

793
00:54:51,000 --> 00:54:55,000
кто собирается использовать функцию суммы, "Эй, вы не только должны дать нам массив

794
00:54:55,000 --> 00:54:59,000
целых чисел, вы также должны сказать нам, как большой массив, который Вы дали нам ".

795
00:54:59,000 --> 00:55:03,000
[Василий] Те, оба будут аргументы командной строки?

796
00:55:03,000 --> 00:55:06,000
Нет, это фактические аргументы, которые вы передаете в функцию.

797
00:55:06,000 --> 00:55:10,000
>> Позвольте мне сделать новую страницу здесь.

798
00:55:10,000 --> 00:55:13,000
[Василий] Как имя будет проходить-

799
00:55:13,000 --> 00:55:24,000
[Nate H.] Если у меня есть Int основных (недействительными),

800
00:55:24,000 --> 00:55:27,000
и я собираюсь поставить в моем возвращении 0 вниз здесь на дне,

801
00:55:27,000 --> 00:55:31,000
и сказать, что я хочу, чтобы вызвать функцию суммы.

802
00:55:31,000 --> 00:55:42,000
Я хочу сказать, Int х = SUM ();

803
00:55:42,000 --> 00:55:46,000
Чтобы использовать функцию суммы я должен пройти как в массиве, что я хочу, чтобы подвести итог

804
00:55:46,000 --> 00:55:51,000
и длина массива, так что это, где

805
00:55:51,000 --> 00:55:54,000
предполагая, что я был массив целых чисел,

806
00:55:54,000 --> 00:56:12,000
сказать, что я Int numbaz [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
вид использования, который изрубил синтаксис там же,

808
00:56:16,000 --> 00:56:21,000
то, что я хотел бы сделать это в сумме я хотел бы перейти в

809
00:56:21,000 --> 00:56:27,000
как numbaz и № 3

810
00:56:27,000 --> 00:56:30,000
рассказать сумму функцию "Хорошо, вот массив, который я хочу, чтобы вы подвести".

811
00:56:30,000 --> 00:56:34,000
"Вот его размера."

812
00:56:34,000 --> 00:56:39,000
Имеет ли это смысл? Я ответил на ваш вопрос?

813
00:56:39,000 --> 00:56:42,000
>> Во многом это происходит параллельная, что мы делаем с основными

814
00:56:42,000 --> 00:56:44,000
когда у нас есть аргументы командной строки.

815
00:56:44,000 --> 00:56:47,000
Такая программа, как шифр Цезаря, например, что необходимо

816
00:56:47,000 --> 00:56:53,000
аргументы командной строки не смог бы ничего сделать.

817
00:56:53,000 --> 00:56:57,000
Не знаю, как для шифрования, если Вы не сказать ему, что ключ к использованию

818
00:56:57,000 --> 00:57:03,000
или если вы не сказали ему, что строка, которую вы хотели зашифровать.

819
00:57:03,000 --> 00:57:08,000
Подсказка для ввода, это где у нас есть 2 различных механизмов

820
00:57:08,000 --> 00:57:14,000
для принятия входе в от пользователя, для принятия информации от пользователя.

821
00:57:14,000 --> 00:57:19,000
Для задач 1 мы видели, это GetInt, GetString, GetFloat пути

822
00:57:19,000 --> 00:57:26,000
наведения для ввода, и это называется использованием стандартного входного потока.

823
00:57:26,000 --> 00:57:28,000
Это немного отличается.

824
00:57:28,000 --> 00:57:31,000
Это то, что вы можете сделать за один раз, в отличие от

825
00:57:31,000 --> 00:57:35,000
когда вы запускаете программу, при запуске программа работает.

826
00:57:35,000 --> 00:57:41,000
Аргументы командной строки всех указанных при запуске программы, запущенной.

827
00:57:41,000 --> 00:57:47,000
Мы смешивания двух из них.

828
00:57:47,000 --> 00:57:52,000
Когда мы используем аргументы функции, это так же, как аргументы командной строки к основному.

829
00:57:52,000 --> 00:57:56,000
Это при вызове функции вы должны сказать ему,

830
00:57:56,000 --> 00:58:05,000
что именно ему нужно для того, чтобы выполнять свои задачи.

831
00:58:05,000 --> 00:58:08,000
Еще одна хорошая вещь, чтобы смотреть на, и я дам вам посмотреть на это в свободное время,

832
00:58:08,000 --> 00:58:11,000
и она была покрыта в викторине, было это понятие за рамки

833
00:58:11,000 --> 00:58:15,000
и локальных переменных в сравнении с глобальными переменными.

834
00:58:15,000 --> 00:58:18,000
У обратить внимание на это.

835
00:58:18,000 --> 00:58:23,000
>> Теперь, когда мы становимся на эту другие вещи,

836
00:58:23,000 --> 00:58:27,000
3 недели мы начали говорить о поиска и сортировки.

837
00:58:27,000 --> 00:58:32,000
Поиск и сортировка, по крайней мере, CS50,

838
00:58:32,000 --> 00:58:39,000
очень введением в некоторые из наиболее теоретическая часть компьютерной науки.

839
00:58:39,000 --> 00:58:42,000
Проблема поиска, задачи сортировки

840
00:58:42,000 --> 00:58:46,000
большой, канонической проблемы.

841
00:58:46,000 --> 00:58:52,000
Как вы находите определенного числа в массиве миллиардов чисел?

842
00:58:52,000 --> 00:58:55,000
Как найти конкретное имя в телефонной книге

843
00:58:55,000 --> 00:58:59,000
, которая хранится на вашем ноутбуке?

844
00:58:59,000 --> 00:59:04,000
И поэтому мы введем это понятие асимптотического времени работы

845
00:59:04,000 --> 00:59:11,000
действительно количественно, как долго, как трудно эти проблемы являются,

846
00:59:11,000 --> 00:59:14,000
Как долго они принимают решения.

847
00:59:14,000 --> 00:59:20,000
В, я считаю, 2011 викторине есть проблема, что я думаю достоинств

848
00:59:20,000 --> 00:59:27,000
покрытие очень быстро, что это, проблема 12.

849
00:59:27,000 --> 00:59:32,000
О нет, это Omega.

850
00:59:32,000 --> 00:59:41,000
>> Здесь мы говорим о максимально возможной время выполнения

851
00:59:41,000 --> 00:59:46,000
для конкретного алгоритма, а затем минимально возможный время выполнения.

852
00:59:46,000 --> 00:59:52,000
Это Omega и O в действительности являются лишь ярлыки.

853
00:59:52,000 --> 00:59:55,000
Они обозначений клавиш для говоря

854
00:59:55,000 --> 00:59:59,000
как быстро в лучшем случае будет наш алгоритм выполнения,

855
00:59:59,000 --> 01:00:06,000
и как медленно в худшем случае будет наш алгоритм бежать?

856
01:00:06,000 --> 01:00:10,000
Давайте сделаем несколько из них, и они были также покрыты

857
01:00:10,000 --> 01:00:13,000
в краткосрочной об асимптотических обозначений, которые я очень рекомендую.

858
01:00:13,000 --> 01:00:17,000
Джексон сделал очень хорошую работу.

859
01:00:17,000 --> 01:00:23,000
С бинарный поиск, мы говорим о бинарного поиска как алгоритм,

860
01:00:23,000 --> 01:00:28,000
и мы обычно говорим об этом с точки зрения его большой O.

861
01:00:28,000 --> 01:00:30,000
Что такое Big O?

862
01:00:30,000 --> 01:00:34,000
Что такое минимально возможный время выполнения двоичного поиска?

863
01:00:34,000 --> 01:00:36,000
[Студент] N ²?

864
01:00:36,000 --> 01:00:41,000
Закрыть, я думаю, похоже на то.

865
01:00:41,000 --> 01:00:43,000
Это намного быстрее, чем это.

866
01:00:43,000 --> 01:00:45,000
[Студент] Двоичные? >> Да, бинарный поиск.

867
01:00:45,000 --> 01:00:47,000
[Студент] Это журнал с.

868
01:00:47,000 --> 01:00:49,000
Вход п, так что же войти п имеете в виду?

869
01:00:49,000 --> 01:00:51,000
Это половины этого каждой итерации.

870
01:00:51,000 --> 01:00:56,000
Точно, так и в минимально возможный случай,

871
01:00:56,000 --> 01:01:00,000
говорят, что если у вас есть отсортированный массив

872
01:01:00,000 --> 01:01:08,000
миллион целых чисел и номер, который вы ищете

873
01:01:08,000 --> 01:01:14,000
это либо первый элемент массива или самый последний элемент массива.

874
01:01:14,000 --> 01:01:18,000
Помните, что алгоритм двоичного поиска работы, глядя на средний элемент,

875
01:01:18,000 --> 01:01:21,000
видя если это матч, который вы ищете.

876
01:01:21,000 --> 01:01:23,000
Если это так, то большой, вы его нашли.

877
01:01:23,000 --> 01:01:27,000
>> В лучшем случае, как быстро делает выполнения двоичного поиска?

878
01:01:27,000 --> 01:01:29,000
[Студенты] 1.

879
01:01:29,000 --> 01:01:32,000
1, это постоянное время, большая O 1. Да.

880
01:01:32,000 --> 01:01:36,000
[Студент] У меня есть вопрос. Когда вы говорите войти п, вы имеете в виду по отношению к основанию 2, правильно?

881
01:01:36,000 --> 01:01:40,000
Да, так вот другая вещь.

882
01:01:40,000 --> 01:01:44,000
Мы говорим, § п, и я думаю, когда я учился в средней школе

883
01:01:44,000 --> 01:01:48,000
Я всегда считал, что журнал был основанием 10.

884
01:01:48,000 --> 01:01:57,000
Да, да так, войти основанию 2 обычно это то, что мы используем.

885
01:01:57,000 --> 01:02:02,000
Опять же, возвращаясь к бинарный поиск, если вы ищете либо

886
01:02:02,000 --> 01:02:05,000
элемента в самом конце или элемент в самом начале,

887
01:02:05,000 --> 01:02:08,000
потому что вы начинаете в середине, и тогда вы сбрасываете

888
01:02:08,000 --> 01:02:13,000
зависимости от того, половина не отвечают критериям, что вы ищете,

889
01:02:13,000 --> 01:02:15,000
и вы переходите к следующему половины и следующую половину и следующая половина.

890
01:02:15,000 --> 01:02:19,000
Если я ищу наибольший элемент в миллион целых чисел

891
01:02:19,000 --> 01:02:25,000
Я собираюсь вдвое сократить его на самый журнала 1 миллиона раз

892
01:02:25,000 --> 01:02:28,000
прежде чем я, наконец, протестировать и увидеть, что элемент я ищу

893
01:02:28,000 --> 01:02:33,000
находится в большой или в высшей индекс массива,

894
01:02:33,000 --> 01:02:38,000
и что будет журнал п, войти в 1 млн. раз.

895
01:02:38,000 --> 01:02:40,000
>> Bubble рода.

896
01:02:40,000 --> 01:02:43,000
Парни, вы помните алгоритм пузырьковой сортировки?

897
01:02:43,000 --> 01:02:47,000
Кевин, вы можете дать мне быстрое повторение того, что произошло в алгоритм сортировки пузырь?

898
01:02:47,000 --> 01:02:50,000
[Кевин] В основном это проходит через все, что в списке.

899
01:02:50,000 --> 01:02:52,000
Он смотрит на первых двух.

900
01:02:52,000 --> 01:02:55,000
Если первый больше, чем второй его свопы них.

901
01:02:55,000 --> 01:02:58,000
Затем он сравнивает второй и третьей, то же самое, свопы,

902
01:02:58,000 --> 01:03:00,000
Третий и четвертый, на всем пути вниз.

903
01:03:00,000 --> 01:03:03,000
Большие номера будут следовать до конца.

904
01:03:03,000 --> 01:03:07,000
И после однако многие петли вы сделали.

905
01:03:07,000 --> 01:03:11,000
Точно, так что Кевин сказал, что мы будем наблюдать большие числа

906
01:03:11,000 --> 01:03:15,000
Пузырь до конца массива.

907
01:03:15,000 --> 01:03:19,000
Например, вы возражаете идти с нами через эту Например, если это наш массив?

908
01:03:19,000 --> 01:03:21,000
[Кевин] Вы будете принимать 2 и 3.

909
01:03:21,000 --> 01:03:23,000
3 больше, чем 2, так что вы поменять их местами.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Право, таким образом, мы переставляем их, и таким образом мы получаем 2, 3, 6, 4 и 9.

911
01:03:29,000 --> 01:03:31,000
[Кевин] Тогда вы сравните 3 и 6.

912
01:03:31,000 --> 01:03:33,000
3 меньше, чем 6, так что вы оставите их,

913
01:03:33,000 --> 01:03:37,000
и 6 и 4, нужно поменять их местами потому что 4 меньше, чем 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Право, так что я получаю 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Кевин] и 9 больше, чем 6, так что вы оставите его.

916
01:03:46,000 --> 01:03:48,000
И вы вернулись бы через это снова.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Могу ли я сделать в этот момент? >> [Кевин] Нет

918
01:03:50,000 --> 01:03:52,000
И почему я не делал в этот момент?

919
01:03:52,000 --> 01:03:54,000
Потому что он похож на моего массив отсортирован. Я смотрю на это.

920
01:03:54,000 --> 01:03:57,000
[Кевин] пройти через это снова и убедитесь, что нет больше свопы

921
01:03:57,000 --> 01:04:00,000
прежде чем вы сможете полностью остановить.

922
01:04:00,000 --> 01:04:04,000
Именно, поэтому нужно продолжать идти до конца и убедитесь, что нет свопов

923
01:04:04,000 --> 01:04:06,000
что вы можете сделать в этой точке.

924
01:04:06,000 --> 01:04:08,000
Это было действительно просто повезло, как вы сказали, что мы закончили

925
01:04:08,000 --> 01:04:12,000
только того, чтобы сделать 1 проход, и мы сортируются.

926
01:04:12,000 --> 01:04:16,000
Но для этого, в общем случае, мы на самом деле должны делать это снова и снова.

927
01:04:16,000 --> 01:04:20,000
И в самом деле, это был пример лучшем случае,

928
01:04:20,000 --> 01:04:24,000
как мы видели в проблеме.

929
01:04:24,000 --> 01:04:28,000
Мы видели, что наилучшее дело N.

930
01:04:28,000 --> 01:04:32,000
Мы пошли через массив 1 раз.

931
01:04:32,000 --> 01:04:35,000
Что это худший возможный случай для этого алгоритма?

932
01:04:35,000 --> 01:04:37,000
[Кевин] N ².

933
01:04:37,000 --> 01:04:41,000
И что это похоже? Что бы массив похоже, что бы взять п ² время?

934
01:04:41,000 --> 01:04:43,000
[Кевин] [неразборчиво] отсортирован.

935
01:04:43,000 --> 01:04:51,000
Именно, поэтому, если у меня была масса 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
Сначала 9 будет пузырь на всем пути вверх.

937
01:04:54,000 --> 01:04:59,000
После 1 итерации мы бы 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Тогда 7 будет пузыриться, 6, 5, 2, 7, 9, и так далее, и так далее.

939
01:05:07,000 --> 01:05:13,000
>> Мы должны пройти через весь массив п раз,

940
01:05:13,000 --> 01:05:16,000
и вы можете получить немного более точным, чем это

941
01:05:16,000 --> 01:05:23,000
потому что как только мы переехали в 9 все, вплоть до последней в его возможном положении

942
01:05:23,000 --> 01:05:26,000
Мы знаем, что мы никогда не должны сравниваться с этим элементом снова.

943
01:05:26,000 --> 01:05:29,000
Как только мы начинаем пузырится 7 до

944
01:05:29,000 --> 01:05:35,000
Мы знаем, что мы можем остановить только 7 является правом до 9

945
01:05:35,000 --> 01:05:37,000
поскольку мы уже по сравнению с 9 до нее.

946
01:05:37,000 --> 01:05:46,000
Если вы делаете это в умный способ это не по-настоящему, я думаю, что много времени.

947
01:05:46,000 --> 01:05:49,000
Вы не собираетесь, чтобы сравнить все возможные [неразборчиво] комбинациях

948
01:05:49,000 --> 01:05:55,000
каждый раз, когда вы проходите через каждую итерацию.

949
01:05:55,000 --> 01:05:59,000
Но все же, когда мы говорим об этом верхняя граница мы говорим, что

950
01:05:59,000 --> 01:06:04,000
Вы смотрите на п ² сравнения весь путь до конца.

951
01:06:04,000 --> 01:06:12,000
>> Давайте вернемся, и так как мы начинаем получать немного меньше по времени

952
01:06:12,000 --> 01:06:15,000
Я бы сказал, вы должны обязательно пройти остальной части этой таблицы,

953
01:06:15,000 --> 01:06:17,000
заполнить все это.

954
01:06:17,000 --> 01:06:20,000
Подумайте о примерах. Подумайте о конкретных примерах.

955
01:06:20,000 --> 01:06:22,000
Это действительно удобно и полезно сделать.

956
01:06:22,000 --> 01:06:25,000
Нарисуйте его.

957
01:06:25,000 --> 01:06:28,000
Это своего рода таблицу, как вы идете через в области компьютерных наук

958
01:06:28,000 --> 01:06:32,000
Вы должны действительно начать знаем, что эти наизусть.

959
01:06:32,000 --> 01:06:34,000
Эти виды вопросов, которые вы получите в интервью.

960
01:06:34,000 --> 01:06:36,000
Это разные вещи, которые хорошо бы знать,

961
01:06:36,000 --> 01:06:41,000
и думать о тех крайних случаях, действительно, выясняя, как подумать о

962
01:06:41,000 --> 01:06:45,000
зная, что для пузырьковой сортировки в самый неподходящий массива

963
01:06:45,000 --> 01:06:52,000
сортировать тем, что это тот, который в обратном порядке.

964
01:06:52,000 --> 01:06:58,000
>> Указатели. Давайте немного поговорим об указателях.

965
01:06:58,000 --> 01:07:03,000
В последние несколько минут здесь мы имеем

966
01:07:03,000 --> 01:07:11,000
Я знаю, это то, что наряду с файлового ввода / вывода, что является относительно новым.

967
01:07:11,000 --> 01:07:19,000
Когда мы говорим о указателей по этой причине мы хотим говорить об указателях

968
01:07:19,000 --> 01:07:24,000
Потому что, один, когда мы работаем в C

969
01:07:24,000 --> 01:07:33,000
мы действительно на довольно низком уровне по сравнению с большинством современных языков программирования.

970
01:07:33,000 --> 01:07:38,000
Мы на самом деле способен манипулировать переменными в памяти,

971
01:07:38,000 --> 01:07:43,000
выяснить, где они на самом деле находятся в пределах нашей памяти.

972
01:07:43,000 --> 01:07:46,000
После того как вы пошли на взятие операционная система классов, которые вы увидите,

973
01:07:46,000 --> 01:07:48,000
что это, опять же, своего рода абстракцией.

974
01:07:48,000 --> 01:07:50,000
Это не на самом деле.

975
01:07:50,000 --> 01:07:52,000
У нас есть виртуальная память, что скрывает эти детали от нас.

976
01:07:52,000 --> 01:07:58,000
>> Но сейчас можно предположить, что если у вас есть программа,

977
01:07:58,000 --> 01:08:02,000
Например, когда вы начать показ шифр Цезаря программу

978
01:08:02,000 --> 01:08:06,000
Я переключиться обратно на мой IPad действительно быстро-

979
01:08:06,000 --> 01:08:12,000
, что в самом начале вашей программы, если у вас, скажем,

980
01:08:12,000 --> 01:08:15,000
4 гигабайтами оперативной памяти на вашем ноутбуке,

981
01:08:15,000 --> 01:08:21,000
Вы получите отложите этот кусок, и мы называем это RAM.

982
01:08:21,000 --> 01:08:25,000
И он начинается в место, где мы собираемся называть 0,

983
01:08:25,000 --> 01:08:30,000
и заканчивается в месте, которое мы будем называть 4 гигабайт.

984
01:08:30,000 --> 01:08:37,000
Я действительно не могу писать. Человек, который взломал.

985
01:08:37,000 --> 01:08:40,000
Когда ваша программа выполняет

986
01:08:40,000 --> 01:08:44,000
Операционная система вырезает оперативной памяти,

987
01:08:44,000 --> 01:08:51,000
и он определяет различные сегменты для различных частей вашей программы живем

988
01:08:51,000 --> 01:08:58,000
Здесь, внизу этой области, это своего рода ничейной земле.

989
01:08:58,000 --> 01:09:02,000
Когда вы идете немного дальше здесь

990
01:09:02,000 --> 01:09:05,000
у вас есть на самом деле место, где

991
01:09:05,000 --> 01:09:09,000
Код для жизни программы.

992
01:09:09,000 --> 01:09:13,000
Это фактически двоичный код, исполняемый файл, что на самом деле загружается в память

993
01:09:13,000 --> 01:09:17,000
когда вы запустите программу, и она живет в сегменте кода.

994
01:09:17,000 --> 01:09:22,000
И, как ваша программа выполняется процессором смотрит на этот сегмент кода

995
01:09:22,000 --> 01:09:24,000
чтобы выяснить, что является следующая инструкция?

996
01:09:24,000 --> 01:09:27,000
Какая следующая строка кода мне нужно выполнить?

997
01:09:27,000 --> 01:09:31,000
>> Там также сегмент данных, и это, где эти константы строк

998
01:09:31,000 --> 01:09:34,000
получить хранится, что вы используете.

999
01:09:34,000 --> 01:09:42,000
А потом дальше вверх там это место называется кучей.

1000
01:09:42,000 --> 01:09:46,000
Мы доступа к памяти там с помощью таНос,

1001
01:09:46,000 --> 01:09:49,000
, а затем на самом верху вашей программы

1002
01:09:49,000 --> 01:09:52,000
есть стек,

1003
01:09:52,000 --> 01:09:57,000
а вот где мы играли на протяжении большей части начала.

1004
01:09:57,000 --> 01:09:59,000
Это не в масштабе или ничего.

1005
01:09:59,000 --> 01:10:03,000
Много это очень зависит от машины,

1006
01:10:03,000 --> 01:10:10,000
зависит от операционной системы, но это относительно, как все получают разбит вверх.

1007
01:10:10,000 --> 01:10:17,000
Когда вы запустите программу, и вы объявите переменную х

1008
01:10:17,000 --> 01:10:27,000
Я собираюсь сделать еще одну коробку вниз, и это будет оперативной памяти.

1009
01:10:27,000 --> 01:10:29,000
И я собираюсь посмотреть.

1010
01:10:29,000 --> 01:10:34,000
Мы будем рисовать зубчатые линии, чтобы указать, это всего лишь небольшая часть оперативной памяти

1011
01:10:34,000 --> 01:10:38,000
и не все о нем, как мы рисуем на самом верху.

1012
01:10:38,000 --> 01:10:43,000
>> Если я заявляю, целая переменная называется х,

1013
01:10:43,000 --> 01:10:49,000
то, что я на самом деле получить отображение

1014
01:10:49,000 --> 01:10:54,000
, которые хранятся в таблице символов моей программы

1015
01:10:54,000 --> 01:11:00,000
, который соединяет имя х в эту область памяти, которую я нарисовала

1016
01:11:00,000 --> 01:11:03,000
прямо здесь, между вертикальными полосами.

1017
01:11:03,000 --> 01:11:08,000
Если у меня есть строка кода, в моей программе, которая говорит х = 7

1018
01:11:08,000 --> 01:11:15,000
Процессор знает "О, хорошо, я знаю, что х жизнь в этом месте в памяти."

1019
01:11:15,000 --> 01:11:25,000
"Я собираюсь пойти дальше и написать 7 существует".

1020
01:11:25,000 --> 01:11:28,000
Как он знает, что расположение это в памяти?

1021
01:11:28,000 --> 01:11:30,000
Хорошо, что все это делается во время компиляции.

1022
01:11:30,000 --> 01:11:34,000
Компилятор заботится о распределении где каждая из переменных собираетесь пойти

1023
01:11:34,000 --> 01:11:40,000
и создание специальных отображение или, скорее, соединение точек

1024
01:11:40,000 --> 01:11:43,000
между символом и куда он идет, имя переменной

1025
01:11:43,000 --> 01:11:46,000
и где он будет жить в памяти.

1026
01:11:46,000 --> 01:11:50,000
Но оказывается, что мы действительно можем получить к нему доступ в наших программах.

1027
01:11:50,000 --> 01:11:55,000
Это становится важным, когда мы начинаем говорить о некоторых структур данных,

1028
01:11:55,000 --> 01:11:58,000
которая является концепция, что мы собираемся ввести позже.

1029
01:11:58,000 --> 01:12:09,000
>> Но сейчас, как вы можете знать, что я могу создать указатель на это место, х.

1030
01:12:09,000 --> 01:12:12,000
Например, я могу создать переменную-указатель.

1031
01:12:12,000 --> 01:12:16,000
Когда мы создаем указатель переменной мы используем обозначение звезды.

1032
01:12:16,000 --> 01:12:21,000
В этом случае, это говорит, что я собираюсь создать указатель на Int.

1033
01:12:21,000 --> 01:12:24,000
Это типа как и любой другой.

1034
01:12:24,000 --> 01:12:27,000
Мы даем ему переменной, как у,

1035
01:12:27,000 --> 01:12:32,000
, а затем положить его равным адрес, по адресу.

1036
01:12:32,000 --> 01:12:38,000
В этом случае, мы можем установить у указывают на х

1037
01:12:38,000 --> 01:12:43,000
принимая адресу х, которые мы делаем с этим амперсанд,

1038
01:12:43,000 --> 01:12:55,000
, а затем положить у указывают на это.

1039
01:12:55,000 --> 01:12:59,000
То, что это по существу делает это, если мы посмотрим на нашу RAM

1040
01:12:59,000 --> 01:13:02,000
это создает отдельную переменную.

1041
01:13:02,000 --> 01:13:04,000
Это будет называть его у,

1042
01:13:04,000 --> 01:13:06,000
и когда эта строка кода выполняется

1043
01:13:06,000 --> 01:13:13,000
это на самом деле собирается создать небольшой указатель, который мы обычно используют, как стрела,

1044
01:13:13,000 --> 01:13:15,000
и он устанавливает у указывают на х.

1045
01:13:15,000 --> 01:13:17,000
Да.

1046
01:13:17,000 --> 01:13:19,000
[Студент] Если х это уже указатель, вы бы просто сделать

1047
01:13:19,000 --> 01:13:22,000
Int * у = х, вместо того, амперсанд?

1048
01:13:22,000 --> 01:13:24,000
Да.

1049
01:13:24,000 --> 01:13:27,000
Если х это уже указатель, то вы можете установить 2 указателей равны друг другу,

1050
01:13:27,000 --> 01:13:30,000
В этом случае у не будет указывать на х,

1051
01:13:30,000 --> 01:13:34,000
но это будет указывать на любой х указывает.

1052
01:13:34,000 --> 01:13:37,000
К сожалению, мы вне времени.

1053
01:13:37,000 --> 01:13:44,000
>> Что я могу сказать на данный момент, мы можем поговорить об этом в автономном режиме,

1054
01:13:44,000 --> 01:13:49,000
Но я бы сказал, начать работать через эту проблему, № 14.

1055
01:13:49,000 --> 01:13:53,000
Вы можете увидеть там уже немного заполнен для вас здесь.

1056
01:13:53,000 --> 01:13:57,000
Вы можете видеть, что, когда мы заявляем, 2 указателей, Int * х * и у,

1057
01:13:57,000 --> 01:14:01,000
и заметим, что указывает * Рядом с переменной было то, что было сделано в прошлом году.

1058
01:14:01,000 --> 01:14:05,000
Оказывается, что это похоже на то, что мы делаем в этом году.

1059
01:14:05,000 --> 01:14:11,000
Это не имеет значения, где вы пишете *, когда вы объявлении указателя.

1060
01:14:11,000 --> 01:14:17,000
Но мы написали * рядом с типом

1061
01:14:17,000 --> 01:14:24,000
потому что это делает его очень ясно, что вы объявлении переменной-указателя.

1062
01:14:24,000 --> 01:14:27,000
Вы можете видеть, что объявление 2 указателя дает нам 2 коробки.

1063
01:14:27,000 --> 01:14:31,000
Вот когда мы устанавливаем х равно таНос

1064
01:14:31,000 --> 01:14:34,000
что это говорит в отмене памяти в куче.

1065
01:14:34,000 --> 01:14:41,000
Этот маленький ящик прямо здесь, этот круг, находится в кучу.

1066
01:14:41,000 --> 01:14:43,000
X указывает на это.

1067
01:14:43,000 --> 01:14:46,000
Заметим, что у еще не указывая ни к чему.

1068
01:14:46,000 --> 01:14:50,000
Чтобы получить память для хранения числа 42 в х

1069
01:14:50,000 --> 01:14:55,000
мы будем использовать то, что обозначение?

1070
01:14:55,000 --> 01:14:59,000
[Студент] * х = 42.

1071
01:14:59,000 --> 01:15:01,000
Точно, * х = 42.

1072
01:15:01,000 --> 01:15:06,000
Это означает, следуйте за стрелкой и бросить 42 в там.

1073
01:15:06,000 --> 01:15:09,000
Здесь, где мы устанавливаем у и х мы у указывая на х.

1074
01:15:09,000 --> 01:15:13,000
Опять же, это просто нравится то, что Кевин сказал, где мы устанавливаем у равно х.

1075
01:15:13,000 --> 01:15:15,000
Y не указывает на х.

1076
01:15:15,000 --> 01:15:19,000
Скорее, это указывает на то, что X указывает на, а также.

1077
01:15:19,000 --> 01:15:24,000
>> И, наконец, в последнем окне есть 2 возможных вещей, которые мы могли бы сделать.

1078
01:15:24,000 --> 01:15:28,000
Один из них мы могли бы сказать * х = 13.

1079
01:15:28,000 --> 01:15:33,000
Другое дело, мы могли бы сказать, Алекс, вы знаете, что мы могли бы сделать здесь?

1080
01:15:33,000 --> 01:15:37,000
Можно сказать, * х = 13 или-

1081
01:15:37,000 --> 01:15:41,000
[Студент] Можно сказать, что Int.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Если это были причислены к Int переменная, которую мы могли бы сделать это.

1083
01:15:45,000 --> 01:15:49,000
Мы могли бы также сказать, у * = 13, потому что они оба указывают на то же место,

1084
01:15:49,000 --> 01:15:51,000
, чтобы мы могли использовать либо переменную туда добраться.

1085
01:15:51,000 --> 01:15:56,000
Да. >> [Студент] Что бы это выглядело, если мы просто скажем Int х 13?

1086
01:15:56,000 --> 01:16:00,000
Это было бы объявить новую переменную х, которая не будет работать.

1087
01:16:00,000 --> 01:16:04,000
Мы должны были бы столкновения, потому что мы объявили х, чтобы быть указателем здесь.

1088
01:16:04,000 --> 01:16:10,000
[Студент] Если мы просто должны были это заявление само по себе то, что это будет выглядеть с точки зрения круга?

1089
01:16:10,000 --> 01:16:14,000
Если бы мы имели х = 13, то мы должны были бы коробку, и вместо того, чтобы стрелка

1090
01:16:14,000 --> 01:16:16,000
выходя из окна мы сделать это, как только 13.

1091
01:16:16,000 --> 01:16:19,000
[Студент] в поле. Хорошо.

1092
01:16:19,000 --> 01:16:24,000
>> Спасибо за внимание и удачи на Quiz 0.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]