1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [Обзор] [Викторина 0]

2
00:00:03,000 --> 00:00:05,000
>> [Lexi Росс, Томми MacWilliam, Лукас Фрейтас, Иосиф Ong] [Harvard University]

3
00:00:05,000 --> 00:00:08,000
>> [Это CS50.] [CS50.TV]

4
00:00:08,000 --> 00:00:10,000
>> Привет, всем.

5
00:00:10,000 --> 00:00:15,000
Добро пожаловать на рассмотрение сессии Викторина 0, которое проходит в среду.

6
00:00:15,000 --> 00:00:19,000
Что мы собираемся делать сегодня вечером, я с 3 другими ТФ,

7
00:00:19,000 --> 00:00:24,000
и вместе мы собираемся пройти через обзор того, что мы сделали в ходе сих пор.

8
00:00:24,000 --> 00:00:27,000
Это не собирается быть на 100% всеобъемлющей, но она должна дать вам более полное представление

9
00:00:27,000 --> 00:00:31,000
о том, что у вас уже есть вниз и то, что вы все еще нужно изучить, прежде чем в среду.

10
00:00:31,000 --> 00:00:34,000
И не стесняйтесь поднимать руку с вопросами, когда мы собираемся вместе,

11
00:00:34,000 --> 00:00:38,000
но имейте в виду, что мы будем иметь немного времени в конце-

12
00:00:38,000 --> 00:00:41,000
если мы пройдем с нескольких минут, чтобы запасных, чтобы сделать общие вопросы,

13
00:00:41,000 --> 00:00:47,000
так что имейте это в виду, и поэтому мы собираемся начать в начале недели с 0.

14
00:00:47,000 --> 00:00:50,000
>> [Викторина 0 Обзор] [Часть 0] [Lexi Ross] Но прежде чем мы это сделаем, давайте поговорим о

15
00:00:50,000 --> 00:00:53,000
материально-техническое обеспечение викторины.

16
00:00:53,000 --> 00:00:55,000
>> [Логистика] [викторины состоится в среду 10/10 вместо лекции]

17
00:00:55,000 --> 00:00:57,000
>> [(См. http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf подробности)] Это в среду, 10 октября.

18
00:00:57,000 --> 00:01:00,000
>> Вот в эту среду, и если вы идете на этот адрес здесь,

19
00:01:00,000 --> 00:01:03,000
который также доступен из CS50.net-Там ссылка на него-

20
00:01:03,000 --> 00:01:06,000
Вы можете увидеть информацию о том, куда пойти на основе

21
00:01:06,000 --> 00:01:10,000
Вашу фамилию или школу принадлежности, а также

22
00:01:10,000 --> 00:01:14,000
он говорит именно о том, что тест будет охватывать и типов вопросов, что вы собираетесь получить.

23
00:01:14,000 --> 00:01:19,000
Имейте в виду, что вы также будете иметь возможность просмотреть на викторину в разделе

24
00:01:19,000 --> 00:01:21,000
так что ваши ТФ должны идти на некоторые практики проблемы,

25
00:01:21,000 --> 00:01:29,000
и это еще один хороший шанс, чтобы увидеть, где вы все еще нужно изучить для викторины.

26
00:01:29,000 --> 00:01:32,000
Давайте начнем с самого начала с Б-н-бит.

27
00:01:32,000 --> 00:01:35,000
Помните, чуть только 0 или 1,

28
00:01:35,000 --> 00:01:38,000
и байт представляет собой набор из 8 этих битов.

29
00:01:38,000 --> 00:01:42,000
Давайте посмотрим на эту коллекцию битов прямо здесь.

30
00:01:42,000 --> 00:01:44,000
Мы должны быть в состоянии выяснить, сколько бит есть.

31
00:01:44,000 --> 00:01:48,000
Где мы рассчитываем есть только 8 из них восемь 0 или 1 шт.

32
00:01:48,000 --> 00:01:51,000
А так как есть 8 бит, это 1 байт,

33
00:01:51,000 --> 00:01:53,000
и давайте преобразовать его в шестнадцатеричный.

34
00:01:53,000 --> 00:01:58,000
Шестнадцатеричные является основанием 16, и это довольно легко преобразовать

35
00:01:58,000 --> 00:02:01,000
Число в двоичной системе, которая является, что это такое, и их число в шестнадцатеричное.

36
00:02:01,000 --> 00:02:04,000
Все что мы делаем, мы смотрим на группы по 4,

37
00:02:04,000 --> 00:02:07,000
и мы конвертировать их в соответствующий шестнадцатеричный.

38
00:02:07,000 --> 00:02:11,000
Начнем с самой правой группе 4, поэтому 0011.

39
00:02:11,000 --> 00:02:16,000
Это будет одна 1 и одна 2, так вместе, что делает 3.

40
00:02:16,000 --> 00:02:19,000
А потом давайте посмотрим на другой блок 4.

41
00:02:19,000 --> 00:02:24,000
1101. Это будет одна 1, одна 4, и один 8.

42
00:02:24,000 --> 00:02:28,000
Вместе что это будет 13, что делает D.

43
00:02:28,000 --> 00:02:32,000
И мы будем помнить, что в шестнадцатеричной мы не просто идти от 0 до 9.

44
00:02:32,000 --> 00:02:36,000
Мы идем от 0 до F, так что после 9, 10 соответствует,

45
00:02:36,000 --> 00:02:40,000
От 11 до B, и так далее, где F 15.

46
00:02:40,000 --> 00:02:44,000
Здесь 13 представляет собой D,

47
00:02:44,000 --> 00:02:49,000
так, чтобы преобразовать его в десятичное все что мы делаем, мы на самом деле

48
00:02:49,000 --> 00:02:52,000
относиться друг к позиции силы 2.

49
00:02:52,000 --> 00:02:58,000
Это одна 1, одна 2, нулевой 4s, 8s нуля, одной 16, и так далее,

50
00:02:58,000 --> 00:03:03,000
и это немного трудно вычислить в вашей голове, но если мы идем к следующему слайду

51
00:03:03,000 --> 00:03:05,000
мы видим, ответ на этот вопрос.

52
00:03:05,000 --> 00:03:09,000
>> По сути, мы собираемся напротив право вернуться к левым,

53
00:03:09,000 --> 00:03:14,000
и мы умножая каждую цифру соответствующей степенью 2.

54
00:03:14,000 --> 00:03:19,000
И помните, для шестнадцатеричных обозначить эти цифры с 0x в начале

55
00:03:19,000 --> 00:03:23,000
поэтому мы не путайте его с десятичное число.

56
00:03:23,000 --> 00:03:29,000
Продолжая, это ASCII таблицы,

57
00:03:29,000 --> 00:03:35,000
и то, что мы используем для ASCII является преобразование из символов в числовые значения.

58
00:03:35,000 --> 00:03:39,000
Помните, в PSET криптографии мы широко использовали ASCII таблицы

59
00:03:39,000 --> 00:03:43,000
Для использования различных методов криптографии,

60
00:03:43,000 --> 00:03:47,000
Цезарь и шифр Виженера, конвертировать различные буквы

61
00:03:47,000 --> 00:03:52,000
В строку в соответствии с ключевыми задается пользователем.

62
00:03:52,000 --> 00:03:56,000
Давайте посмотрим на немного ASCII математике.

63
00:03:56,000 --> 00:04:02,000
Глядя на 'P' + 1, в символьной форме, которая была бы Q,

64
00:04:02,000 --> 00:04:07,000
и помните, что '5 '≠ 5.

65
00:04:07,000 --> 00:04:10,000
И как бы мы точно конвертировать между этими 2 формы?

66
00:04:10,000 --> 00:04:13,000
Это на самом деле не слишком трудно.

67
00:04:13,000 --> 00:04:16,000
Для того, чтобы получить 5 мы вычитаем '0 '

68
00:04:16,000 --> 00:04:20,000
потому что есть 5 мест между '0 'и '5.

69
00:04:20,000 --> 00:04:23,000
Для того, чтобы пойти по другому пути, мы просто добавим 0,

70
00:04:23,000 --> 00:04:25,000
так что это вроде как регулярные арифметика.

71
00:04:25,000 --> 00:04:29,000
Только помните, что, когда что-то кавычки, это характер

72
00:04:29,000 --> 00:04:37,000
и, следовательно, соответствует значению в таблице ASCII.

73
00:04:37,000 --> 00:04:40,000
Перемещение в более общие темы по информатике.

74
00:04:40,000 --> 00:04:43,000
Мы узнали, что такое алгоритм и как мы используем программированию

75
00:04:43,000 --> 00:04:45,000
для реализации алгоритмов.

76
00:04:45,000 --> 00:04:48,000
Некоторые примеры алгоритмов нечто простое, как

77
00:04:48,000 --> 00:04:51,000
проверки, является ли число четным или нечетным.

78
00:04:51,000 --> 00:04:54,000
Для этого помните, что мы мода число на 2 и проверить, если результат равен 0.

79
00:04:54,000 --> 00:04:57,000
Если это так, то это еще. Если нет, то это странно.

80
00:04:57,000 --> 00:04:59,000
И это пример действительно основной алгоритм.

81
00:04:59,000 --> 00:05:02,000
>> Немного сложнее один бинарный поиск,

82
00:05:02,000 --> 00:05:05,000
которые мы рассмотрим позже в обзоре сессии.

83
00:05:05,000 --> 00:05:09,000
И программировании термин, который мы используем для принятия алгоритма

84
00:05:09,000 --> 00:05:15,000
и преобразование его в код, компьютер может читать.

85
00:05:15,000 --> 00:05:20,000
2 примера программирования Scratch,

86
00:05:20,000 --> 00:05:22,000
что мы и сделали в неделю 0.

87
00:05:22,000 --> 00:05:25,000
Даже если мы на самом деле не впечатать код это способ реализации

88
00:05:25,000 --> 00:05:29,000
Этот алгоритм, который печатает номера 1-10,

89
00:05:29,000 --> 00:05:32,000
и здесь мы сделать то же самое на языке программирования Си.

90
00:05:32,000 --> 00:05:41,000
Эти функционально эквивалентны, только что написанные на разных языках или синтаксиса.

91
00:05:41,000 --> 00:05:44,000
Затем мы узнали о логических выражений,

92
00:05:44,000 --> 00:05:48,000
и логическое является значение, которое либо истинно, либо ложно,

93
00:05:48,000 --> 00:05:51,000
и здесь часто логические выражения

94
00:05:51,000 --> 00:05:55,000
Заходим внутрь условиях, так что если (х ≤ 5),

95
00:05:55,000 --> 00:06:00,000
Ну, мы уже установлены х = 5, так что условие будет оценить, верно.

96
00:06:00,000 --> 00:06:03,000
И если это правда, что код под условие

97
00:06:03,000 --> 00:06:08,000
будет оцениваться с помощью компьютера, так что строка будет печататься

98
00:06:08,000 --> 00:06:12,000
на стандартный вывод, а термин условие

99
00:06:12,000 --> 00:06:16,000
относится к тому, что находится внутри скобки, если заявление.

100
00:06:16,000 --> 00:06:20,000
Помните, что все операторы.

101
00:06:20,000 --> 00:06:26,000
Помните, что это && и | |, когда мы пытаемся объединить 2 или более условий,

102
00:06:26,000 --> 00:06:30,000
Не == = проверить 2 вещи равны.

103
00:06:30,000 --> 00:06:36,000
Помните, что = для назначения в то время как == это логический оператор.

104
00:06:36,000 --> 00:06:41,000
≤, ≥, а затем окончательный 2 говорят сами за себя.

105
00:06:41,000 --> 00:06:45,000
Общий обзор булевой логики здесь.

106
00:06:45,000 --> 00:06:48,000
И логические выражения также являются важными в петлях,

107
00:06:48,000 --> 00:06:50,000
которые мы рассмотрим сейчас.

108
00:06:50,000 --> 00:06:56,000
Мы узнали о 3 вида петель до сих пор в CS50, ибо, в то время как, и сделать в то время.

109
00:06:56,000 --> 00:06:59,000
И это важно знать, что в то время как для большинства целей

110
00:06:59,000 --> 00:07:02,000
мы действительно можем использовать любой тип цикла в целом

111
00:07:02,000 --> 00:07:06,000
Есть определенные типы целей или общих закономерностей

112
00:07:06,000 --> 00:07:09,000
в программировании, что конкретный призыв к одному из этих петель

113
00:07:09,000 --> 00:07:13,000
, которые делают его наиболее эффективным и элегантным, чтобы закодировать его таким образом.

114
00:07:13,000 --> 00:07:18,000
Давайте посмотрим, что каждая из этих петель, как правило, используется для наиболее часто.

115
00:07:18,000 --> 00:07:21,000
>> В цикл мы в целом уже знаю, сколько раз мы хотим перебрать.

116
00:07:21,000 --> 00:07:24,000
Это то, что мы вкладываем в состоянии.

117
00:07:24,000 --> 00:07:28,000
Ибо, я = 0, <10, например.

118
00:07:28,000 --> 00:07:31,000
Мы уже знаем, что мы хотим сделать что-то в 10 раз.

119
00:07:31,000 --> 00:07:34,000
Теперь, в то время как цикл, как правило, мы не обязательно

120
00:07:34,000 --> 00:07:36,000
знаю, сколько раз мы хотим, чтобы петля для запуска.

121
00:07:36,000 --> 00:07:39,000
Но мы знаем, своего рода условие, что мы хотим, чтобы

122
00:07:39,000 --> 00:07:41,000
Всегда быть истинным или ложным всегда.

123
00:07:41,000 --> 00:07:44,000
Например, в то время установлена.

124
00:07:44,000 --> 00:07:46,000
Давайте говорить, что это логическая переменная.

125
00:07:46,000 --> 00:07:48,000
Хотя это правда, мы хотим, чтобы код, чтобы оценить,

126
00:07:48,000 --> 00:07:52,000
так что немного более расширяемой, немного более общее, чем цикл,

127
00:07:52,000 --> 00:07:55,000
но любой цикл может быть преобразовано в то время как петля.

128
00:07:55,000 --> 00:08:00,000
И, наконец, делать, пока петли, которая может быть самая сложная понять сразу,

129
00:08:00,000 --> 00:08:04,000
часто используется, когда мы хотим оценить Сначала код

130
00:08:04,000 --> 00:08:06,000
Перед Впервые мы проверяем состояние.

131
00:08:06,000 --> 00:08:09,000
Общий случай использования делать во время цикла

132
00:08:09,000 --> 00:08:12,000
когда вы хотите получить пользовательский ввод, и вы знаете, вы хотите спросить пользователя

133
00:08:12,000 --> 00:08:15,000
для ввода крайней мере один раз, но если они не дают вам хорошие входные сразу

134
00:08:15,000 --> 00:08:18,000
Вы хотите продолжать просить их, пока они дают вам хороший вход.

135
00:08:18,000 --> 00:08:21,000
Это самый распространенный способ использования этого время цикла,

136
00:08:21,000 --> 00:08:23,000
и давайте посмотрим на реальную структуру этих петель.

137
00:08:23,000 --> 00:08:27,000
Как правило, они всегда стремятся следовать этим паттернам.

138
00:08:27,000 --> 00:08:30,000
>> На цикл внутри вас есть 3 компонента:

139
00:08:30,000 --> 00:08:35,000
инициализации, как правило, что-то вроде Int я = 0, где я есть счетчик,

140
00:08:35,000 --> 00:08:40,000
состояние, в котором мы хотим сказать, запустить этот цикл, пока это условие остается в силе,

141
00:08:40,000 --> 00:08:44,000
как я <10, и, наконец, обновление, который является, как мы увеличиваем

142
00:08:44,000 --> 00:08:47,000
переменная счетчика в каждой точке цикла.

143
00:08:47,000 --> 00:08:50,000
Обычная вещь, чтобы видеть, что есть только я + +,

144
00:08:50,000 --> 00:08:52,000
что означает увеличивать я на 1 каждый раз.

145
00:08:52,000 --> 00:08:55,000
Вы также можете сделать что-то вроде я + = 2,

146
00:08:55,000 --> 00:08:58,000
что означает, добавьте 2 к я каждый раз вы идете через петлю.

147
00:08:58,000 --> 00:09:03,000
И тогда сделать это только относится к любой код, который фактически работает как часть цикла.

148
00:09:03,000 --> 00:09:09,000
И на некоторое время цикла, на этот раз у нас действительно есть инициализация вне цикла,

149
00:09:09,000 --> 00:09:12,000
Так, например, предположим, что мы пытаемся сделать то же самое тип цикла, как я только что описал.

150
00:09:12,000 --> 00:09:16,000
Мы хотели бы сказать Int = 0 перед началом цикла.

151
00:09:16,000 --> 00:09:20,000
Тогда мы могли бы сказать, когда я <10 этого

152
00:09:20,000 --> 00:09:22,000
так же блок кода, как и прежде,

153
00:09:22,000 --> 00:09:26,000
и на этот раз обновление части кода, например, я + +,

154
00:09:26,000 --> 00:09:29,000
на самом деле происходит внутри цикла.

155
00:09:29,000 --> 00:09:33,000
И, наконец, в то время как делать, это похоже на время цикла,

156
00:09:33,000 --> 00:09:36,000
но мы должны помнить, что код будет оценивать раза

157
00:09:36,000 --> 00:09:40,000
Перед условие проверяется, поэтому он делает намного больше смысла

158
00:09:40,000 --> 00:09:44,000
если вы посмотрите на нее в порядке сверху вниз.

159
00:09:44,000 --> 00:09:49,000
В то время как цикл сделать код оценивает прежде, чем вы даже смотреть на это время условия,

160
00:09:49,000 --> 00:09:55,000
в то время как время цикла, она проверяет в первую очередь.

161
00:09:55,000 --> 00:09:59,000
Заявления и переменные.

162
00:09:59,000 --> 00:10:04,000
Когда мы хотим создать новую переменную, мы сначала хотим инициализировать его.

163
00:10:04,000 --> 00:10:07,000
>> Например, внутр бар инициализирует переменную бар,

164
00:10:07,000 --> 00:10:10,000
но это не дает ей значение, так что значение баре сейчас?

165
00:10:10,000 --> 00:10:12,000
Мы не знаем.

166
00:10:12,000 --> 00:10:14,000
Это может быть какая-то фигня значение, которое хранится в памяти там,

167
00:10:14,000 --> 00:10:16,000
и мы не хотим использовать эту переменную

168
00:10:16,000 --> 00:10:19,000
пока мы фактически не дать ему значения,

169
00:10:19,000 --> 00:10:21,000
таким образом, мы объявим его здесь.

170
00:10:21,000 --> 00:10:24,000
Затем мы инициализируем, что это будет 42 ниже.

171
00:10:24,000 --> 00:10:28,000
Сейчас, конечно, мы знаем, что это может быть сделано на одной линии, внутр бар = 42.

172
00:10:28,000 --> 00:10:30,000
Но Просто чтобы быть ясно нескольких шагов, что происходит,

173
00:10:30,000 --> 00:10:34,000
Декларация и инициализация происходит раздельно.

174
00:10:34,000 --> 00:10:38,000
Это происходит на один шаг, и следующий, внутр Баз = бар + 1,

175
00:10:38,000 --> 00:10:44,000
это утверждение ниже, которое увеличивает Баз, так что в конце этого блока кода

176
00:10:44,000 --> 00:10:48,000
если бы мы были на печать значение Баз было бы 44

177
00:10:48,000 --> 00:10:52,000
потому что мы объявить и инициализировать, что это будет 1> бара,

178
00:10:52,000 --> 00:10:58,000
и тогда мы увеличиваем его еще раз с + +.

179
00:10:58,000 --> 00:11:02,000
Мы пошли на это довольно кратко, но это хорошо, чтобы иметь общее

180
00:11:02,000 --> 00:11:04,000
понимание того, что темы и события.

181
00:11:04,000 --> 00:11:06,000
В основном мы сделали это в Scratch,

182
00:11:06,000 --> 00:11:09,000
так что вы можете думать о темы, как несколько последовательностей кода

183
00:11:09,000 --> 00:11:11,000
работает в то же время.

184
00:11:11,000 --> 00:11:14,000
На самом деле, это, вероятно, не работает, в то же время,

185
00:11:14,000 --> 00:11:17,000
а как бы абстрактно мы можем думать об этом таким образом.

186
00:11:17,000 --> 00:11:20,000
>> В Scratch, например, у нас было несколько спрайтов.

187
00:11:20,000 --> 00:11:22,000
Это может быть выполнение другого кода, в то же время.

188
00:11:22,000 --> 00:11:26,000
Можно было ходить, а другой говорит что-то

189
00:11:26,000 --> 00:11:29,000
В другой части экрана.

190
00:11:29,000 --> 00:11:34,000
События еще один способ выделения логики

191
00:11:34,000 --> 00:11:37,000
между различными элементами кода,

192
00:11:37,000 --> 00:11:40,000
и царапинам, мы смогли смоделировать события с помощью трансляции,

193
00:11:40,000 --> 00:11:43,000
и что на самом деле, когда я получаю, а не когда я слышу,

194
00:11:43,000 --> 00:11:47,000
но по сути это способ передачи информации

195
00:11:47,000 --> 00:11:49,000
от одного спрайта на другой.

196
00:11:49,000 --> 00:11:52,000
Например, вы можете передать игру на себя,

197
00:11:52,000 --> 00:11:56,000
и когда другой спрайт получает за игру,

198
00:11:56,000 --> 00:11:58,000
он реагирует определенным образом.

199
00:11:58,000 --> 00:12:03,000
Это важная модель для понимания программирования.

200
00:12:03,000 --> 00:12:07,000
Просто перейти на основную неделя 0, то, что мы перешли до сих пор,

201
00:12:07,000 --> 00:12:10,000
давайте посмотрим на этот простой программы на Си.

202
00:12:10,000 --> 00:12:14,000
Текст может быть немного небольшим отсюда, но я пойду на это очень быстро.

203
00:12:14,000 --> 00:12:20,000
Мы в том числе 2 файлы заголовков в верхней части, cs50.h и stdio.h.

204
00:12:20,000 --> 00:12:23,000
Мы тогда определении постоянной называется пределом в 100.

205
00:12:23,000 --> 00:12:26,000
Мы тогда осуществлении нашей главной функции.

206
00:12:26,000 --> 00:12:29,000
Так как мы не будем использовать аргументы командной строки здесь мы должны поставить недействительными

207
00:12:29,000 --> 00:12:32,000
в качестве аргументов для основного.

208
00:12:32,000 --> 00:12:38,000
Мы видим Int выше основного. Это тип возвращаемого значения, поэтому возвращать 0 в нижней части.

209
00:12:38,000 --> 00:12:41,000
И мы используем CS50 функции библиотеки получают Int

210
00:12:41,000 --> 00:12:45,000
спросить пользователя для входа, и мы храним его в этой переменной х,

211
00:12:45,000 --> 00:12:51,000
таким образом, мы заявляем х выше, и мы инициализировать его с х = GetInt.

212
00:12:51,000 --> 00:12:53,000
>> Затем мы проверяем, если пользователь дал нам хороший вход.

213
00:12:53,000 --> 00:12:59,000
Если это ≥ LIMIT мы хотим вернуть код ошибки 1 и печатать сообщение об ошибке.

214
00:12:59,000 --> 00:13:02,000
И, наконец, если пользователь дал нам хороший вход

215
00:13:02,000 --> 00:13:08,000
мы собираемся возвести в квадрат числа и распечатать этот результат.

216
00:13:08,000 --> 00:13:11,000
Просто чтобы убедиться, что те все хит домой

217
00:13:11,000 --> 00:13:17,000
Вы можете видеть этикетки различных частей кода здесь.

218
00:13:17,000 --> 00:13:19,000
Я упоминал постоянно, файлы заголовков.

219
00:13:19,000 --> 00:13:21,000
О, Int х. Убедитесь в том, помните, что это локальная переменная.

220
00:13:21,000 --> 00:13:24,000
Это контрастирует его от глобальных переменных, которые мы будем говорить о

221
00:13:24,000 --> 00:13:27,000
Чуть позже в обзоре сессии

222
00:13:27,000 --> 00:13:30,000
и мы призываем библиотечные функции Printf,

223
00:13:30,000 --> 00:13:34,000
так что, если бы мы не включили заголовочный файл stdio.h

224
00:13:34,000 --> 00:13:37,000
мы не были бы в состоянии назвать Printf.

225
00:13:37,000 --> 00:13:42,000
И я считаю, что стрелка, которая получила отрезать здесь указывает на% D,

226
00:13:42,000 --> 00:13:45,000
которая является форматирования строки в Printf.

227
00:13:45,000 --> 00:13:52,000
Он говорит, распечатайте эту переменную как число,% D.

228
00:13:52,000 --> 00:13:58,000
И это все за неделю 0.

229
00:13:58,000 --> 00:14:06,000
Теперь Лукас намерен продолжать.

230
00:14:06,000 --> 00:14:08,000
Эй, ребята. Меня зовут Лукас.

231
00:14:08,000 --> 00:14:10,000
Я на втором курсе в лучшем доме на территории кампуса, Mather,

232
00:14:10,000 --> 00:14:14,000
и я хочу поговорить немного о неделя 1 и 2,1.

233
00:14:14,000 --> 00:14:16,000
[Неделя 1 и 2,1!] [Лукас Фрейтас]

234
00:14:16,000 --> 00:14:19,000
Как Lexi говорил, когда мы начали переводить код с нуля C

235
00:14:19,000 --> 00:14:23,000
одна из вещей, которые мы заметили, что вы не можете просто

236
00:14:23,000 --> 00:14:26,000
написать свой код и запустить его с помощью зеленого флага больше.

237
00:14:26,000 --> 00:14:30,000
На самом деле, вы должны использовать некоторые шаги, чтобы сделать вашу программу C

238
00:14:30,000 --> 00:14:33,000
стали исполняемый файл.

239
00:14:33,000 --> 00:14:36,000
В основном, что вы делаете, когда вы пишете программы является то, что

240
00:14:36,000 --> 00:14:40,000
Вы переводите ваши идеи на язык, компилятор может понять,

241
00:14:40,000 --> 00:14:44,000
поэтому, когда вы пишете программу в C

242
00:14:44,000 --> 00:14:47,000
что вы делаете на самом деле что-то писал, что компилятор будет понимать,

243
00:14:47,000 --> 00:14:50,000
, а затем компилятор собирается перевести этот код

244
00:14:50,000 --> 00:14:53,000
в то, что ваш компьютер будет понимать.

245
00:14:53,000 --> 00:14:55,000
>> А дело в том, компьютер на самом деле очень глупо.

246
00:14:55,000 --> 00:14:57,000
Ваш компьютер может понять только 0 и 1,

247
00:14:57,000 --> 00:15:01,000
так на самом деле в первые компьютеры обычно люди запрограммированы

248
00:15:01,000 --> 00:15:04,000
использование 0 и 1, но не больше, слава Богу.

249
00:15:04,000 --> 00:15:07,000
Мы не нужно запоминать последовательности 0 и 1

250
00:15:07,000 --> 00:15:10,000
за цикл или цикл, пока и так далее.

251
00:15:10,000 --> 00:15:13,000
Вот почему у нас есть компилятор.

252
00:15:13,000 --> 00:15:17,000
Какой компилятор делает это в основном переводит код C,

253
00:15:17,000 --> 00:15:21,000
В нашем случае, к языку, что ваш компьютер будет понимать,

254
00:15:21,000 --> 00:15:25,000
которая является объектный код, а компилятор, который мы используем

255
00:15:25,000 --> 00:15:30,000
называется звон, так что это на самом деле символ лязг.

256
00:15:30,000 --> 00:15:33,000
Если у вас есть программа, что вам нужно сделать 2 вещи.

257
00:15:33,000 --> 00:15:37,000
Во-первых, вы должны компилировать вашу программу, а затем вы собираетесь запустить программу.

258
00:15:37,000 --> 00:15:41,000
Для компиляции программы у вас есть много вариантов, чтобы сделать это.

259
00:15:41,000 --> 00:15:44,000
Первый делать лязг program.c

260
00:15:44,000 --> 00:15:47,000
В какой программе это название вашей программы.

261
00:15:47,000 --> 00:15:51,000
В этом случае вы можете видеть, что они просто говорят: "Эй, компиляции моей программы".

262
00:15:51,000 --> 00:15:56,000
Вы не говорите "я хочу это название для моей программы", или ничего.

263
00:15:56,000 --> 00:15:58,000
>> Второй вариант дает название вашей программы.

264
00:15:58,000 --> 00:16:02,000
Можно сказать, лязг-O, а затем имя, которое вы хотите

265
00:16:02,000 --> 00:16:06,000
исполняемый файл будет называться, как и program.c.

266
00:16:06,000 --> 00:16:11,000
И вы также можете сделать сделать программу, и посмотреть, как в первых 2-х случаях

267
00:16:11,000 --> 00:16:15,000
Я ставлю. С, а в третьем у меня только программы?

268
00:16:15,000 --> 00:16:18,000
Да, вы на самом деле не стоит ставить. С, когда вы используете сделать.

269
00:16:18,000 --> 00:16:22,000
В противном случае компилятор на самом деле происходит, чтобы кричать на вас.

270
00:16:22,000 --> 00:16:24,000
А также, я не знаю, если вы, ребята, помните,

271
00:16:24,000 --> 00:16:29,000
но много раз мы также использовали lcs50-или-лм.

272
00:16:29,000 --> 00:16:31,000
Это называется связей.

273
00:16:31,000 --> 00:16:35,000
Он просто сообщает компилятору, что вы будете использовать эти библиотеки тут же,

274
00:16:35,000 --> 00:16:39,000
так что если вы хотите использовать cs50.h вы на самом деле должны ввести

275
00:16:39,000 --> 00:16:43,000
лязг program.c-lcs50.

276
00:16:43,000 --> 00:16:45,000
Если вы не сделаете этого, компилятор не будет знать,

277
00:16:45,000 --> 00:16:50,000
что вы используете эти функции в cs50.h.

278
00:16:50,000 --> 00:16:52,000
И когда вы хотите запустить вашу программу у вас есть 2 варианта.

279
00:16:52,000 --> 00:16:57,000
Если вы сделали лязг program.c Вы не дать название вашей программы.

280
00:16:57,000 --> 00:17:01,000
Вы должны запустить его с помощью. / A.out.

281
00:17:01,000 --> 00:17:06,000
A.out является стандартным именем, лязг дает вашей программе, если вы не даете ему имя.

282
00:17:06,000 --> 00:17:11,000
В противном случае вы собираетесь делать. / Программа, если вы дали название вашей программы,

283
00:17:11,000 --> 00:17:15,000
а также, если вы делали программу имя, которое программа будет получить

284
00:17:15,000 --> 00:17:23,000
уже будет запрограммирован тем же именем, что и файл с.

285
00:17:23,000 --> 00:17:26,000
Тогда мы говорили о типах данных и данных.

286
00:17:26,000 --> 00:17:31,000
>> Основном типов данных одни и те же вещи, как маленькие коробочки они используют

287
00:17:31,000 --> 00:17:35,000
для хранения значений, так что типы данных на самом деле так же, как покемонов.

288
00:17:35,000 --> 00:17:39,000
Они бывают разных размеров и типов.

289
00:17:39,000 --> 00:17:43,000
Я не знаю, что аналогия имеет смысл.

290
00:17:43,000 --> 00:17:46,000
Размер данных на самом деле зависит от архитектуры машины.

291
00:17:46,000 --> 00:17:49,000
Все данные размеров, что я собираюсь показать здесь

292
00:17:49,000 --> 00:17:53,000
на самом деле для 32-битных машин, которые в случае нашего прибора,

293
00:17:53,000 --> 00:17:56,000
Но если вы на самом деле кодирования вашего Mac или Windows, в также

294
00:17:56,000 --> 00:17:59,000
вероятно, вы будете иметь 64-разрядные машины,

295
00:17:59,000 --> 00:18:03,000
так что не забудьте, что данные размеры, которые я собираюсь показать здесь

296
00:18:03,000 --> 00:18:06,000
предназначены для 32-разрядных машин.

297
00:18:06,000 --> 00:18:08,000
Первое, что мы увидели, было INT,

298
00:18:08,000 --> 00:18:10,000
который является довольно простым.

299
00:18:10,000 --> 00:18:13,000
Вы можете использовать Int для хранения целого числа.

300
00:18:13,000 --> 00:18:16,000
Мы также видели символ, символ.

301
00:18:16,000 --> 00:18:20,000
Если вы хотите использовать буквы или символа мало вы, вероятно, будете использовать символ.

302
00:18:20,000 --> 00:18:26,000
Символ имеет 1 байт, что означает 8 бит, как сказала Лекси.

303
00:18:26,000 --> 00:18:31,000
В основном мы должны ASCII таблицы, что имеет 256

304
00:18:31,000 --> 00:18:34,000
возможные комбинации 0 и 1,

305
00:18:34,000 --> 00:18:37,000
, а затем, когда вы вводите символ он собирается переводить

306
00:18:37,000 --> 00:18:44,000
символ, который вы входов номер, который вы имеете в ASCII таблице, как Лекси сказала.

307
00:18:44,000 --> 00:18:48,000
У нас также есть поплавок, который мы используем для хранения десятичных чисел.

308
00:18:48,000 --> 00:18:53,000
Если вы хотите выбрать 3.14, например, вы собираетесь использовать поплавок

309
00:18:53,000 --> 00:18:55,000
или двойной, который имеет больше точности.

310
00:18:55,000 --> 00:18:57,000
Поплавок имеет 4 байт.

311
00:18:57,000 --> 00:19:01,000
Двойное имеет 8 байт, поэтому разница только в том точностью.

312
00:19:01,000 --> 00:19:04,000
У нас также есть длинный, который используется для целых чисел,

313
00:19:04,000 --> 00:19:09,000
и вы можете видеть на 32-битной машине Int и длинный имеют одинаковый размер,

314
00:19:09,000 --> 00:19:13,000
таким образом, это действительно не имеет смысла использовать длинный в 32-битной машине.

315
00:19:13,000 --> 00:19:17,000
>> Но если вы используете Mac и 64-разрядных машин, на самом деле давно имеет размер 8,

316
00:19:17,000 --> 00:19:19,000
так что это действительно зависит от архитектуры.

317
00:19:19,000 --> 00:19:22,000
Для 32-битной машине он не имеет смысла использовать длинный действительности.

318
00:19:22,000 --> 00:19:25,000
А потом долго долго, с другой стороны, имеет 8 байт,

319
00:19:25,000 --> 00:19:30,000
так что это очень хорошо, если вы хотите иметь больше целого.

320
00:19:30,000 --> 00:19:34,000
И, наконец, у нас есть строка, которая является на самом деле символ *,

321
00:19:34,000 --> 00:19:37,000
, который является указателем на символ.

322
00:19:37,000 --> 00:19:40,000
Это очень легко думать, что размер строки будет, как

323
00:19:40,000 --> 00:19:42,000
Количество символов, которые у вас там,

324
00:19:42,000 --> 00:19:45,000
но на самом деле символ * сама

325
00:19:45,000 --> 00:19:49,000
имеет размер указателя на символ, который составляет 4 байта.

326
00:19:49,000 --> 00:19:52,000
Размер символ * 4 байта.

327
00:19:52,000 --> 00:19:56,000
Это не имеет значения, если у вас есть небольшой словом или письмом или ничего.

328
00:19:56,000 --> 00:19:58,000
Это будет 4 байт.

329
00:19:58,000 --> 00:20:01,000
Мы также узнали немного о литья,

330
00:20:01,000 --> 00:20:04,000
так как вы можете видеть, если у вас, например, программу, которая говорит

331
00:20:04,000 --> 00:20:08,000
Int х = 3, а затем Е ("% D", х / 2)

332
00:20:08,000 --> 00:20:12,000
вы, ребята, знаете, что он собирается печатать на экране?

333
00:20:12,000 --> 00:20:14,000
>> Кто-то? >> [Студенты] 2.

334
00:20:14,000 --> 00:20:16,000
1. >> 1, да.

335
00:20:16,000 --> 00:20:20,000
Когда вы делаете 3/2 он собирается получить 1,5,

336
00:20:20,000 --> 00:20:24,000
но так как мы используем целое она собирается игнорировать дробной части,

337
00:20:24,000 --> 00:20:26,000
и вы будете иметь 1.

338
00:20:26,000 --> 00:20:29,000
Если вы не хотите, чтобы это случилось, что вы можете сделать, например,

339
00:20:29,000 --> 00:20:33,000
это объявить поплавок у = х.

340
00:20:33,000 --> 00:20:40,000
Тогда х, что раньше было 3, теперь будет 3,000 в год.

341
00:20:40,000 --> 00:20:44,000
И тогда вы можете печатать у / 2.

342
00:20:44,000 --> 00:20:50,000
На самом деле, я должен иметь 2. там.

343
00:20:50,000 --> 00:20:55,000
Он собирается сделать 3.00/2.00,

344
00:20:55,000 --> 00:20:58,000
и вы будете получать 1,5.

345
00:20:58,000 --> 00:21:06,000
А у нас это 0,2 F просто спрашивать 2 десятичных единиц в десятичной части.

346
00:21:06,000 --> 00:21:12,000
Если у вас есть 0,3 F, что это будет иметь на самом деле 1.500.

347
00:21:12,000 --> 00:21:16,000
Если это 2 это будет 1,50.

348
00:21:16,000 --> 00:21:18,000
У нас также есть это в данном случае.

349
00:21:18,000 --> 00:21:22,000
Если вы поплавок х = 3,14, и тогда вы Printf х

350
00:21:22,000 --> 00:21:24,000
Вы собираетесь получить 3,14.

351
00:21:24,000 --> 00:21:29,000
И если вы делаете х = Int х,

352
00:21:29,000 --> 00:21:34,000
, что означает лечение х в виде целого числа и печати х сейчас

353
00:21:34,000 --> 00:21:36,000
Вы будете иметь 3,00.

354
00:21:36,000 --> 00:21:38,000
Имеет ли это смысл?

355
00:21:38,000 --> 00:21:41,000
Потому что вы первый лечении х как целое, так что вы не обращая внимания на дробную часть,

356
00:21:41,000 --> 00:21:45,000
а затем вы печатаете х.

357
00:21:45,000 --> 00:21:47,000
И, наконец, вы также можете сделать это,

358
00:21:47,000 --> 00:21:52,000
Int х = 65, а затем объявить символ с = х,

359
00:21:52,000 --> 00:21:56,000
а затем, если вы печатаете с вы на самом деле собираетесь получить

360
00:21:56,000 --> 00:21:59,000
, Поэтому в основном то, что вы здесь делаете

361
00:21:59,000 --> 00:22:02,000
переводит целое число в символ,

362
00:22:02,000 --> 00:22:05,000
как ASCII таблице делает.

363
00:22:05,000 --> 00:22:08,000
Мы также говорили о математике операторов.

364
00:22:08,000 --> 00:22:14,000
Большинство из них довольно просты, поэтому +, -, *, /,

365
00:22:14,000 --> 00:22:20,000
а также мы говорили о моде, которая является остаток от деления 2-х номеров.

366
00:22:20,000 --> 00:22:23,000
Если у вас есть 10% 3, например,

367
00:22:23,000 --> 00:22:27,000
это означает, разделите 10 на 3, а что остальные?

368
00:22:27,000 --> 00:22:30,000
Это будет 1, так что это на самом деле очень полезно для многих программ.

369
00:22:30,000 --> 00:22:38,000
Для Виженера и Цезаря я уверен, что все вы, ребята использовали мод.

370
00:22:38,000 --> 00:22:43,000
О математические операторы, будьте очень осторожны при комбинировании * и /.

371
00:22:43,000 --> 00:22:48,000
>> Например, если вы делаете (3/2) * 2, что вы собираетесь получить?

372
00:22:48,000 --> 00:22:50,000
[Студенты] 2.

373
00:22:50,000 --> 00:22:54,000
Да, 2, так как 3/2 будет 1,5,

374
00:22:54,000 --> 00:22:57,000
но так как вы делаете операции между 2 целых чисел

375
00:22:57,000 --> 00:22:59,000
на самом деле вы только собираетесь считать 1,

376
00:22:59,000 --> 00:23:03,000
и 1 * 2 будет 2, так что будьте очень, очень осторожны

377
00:23:03,000 --> 00:23:07,000
когда делать арифметические действия с целыми числами, потому что

378
00:23:07,000 --> 00:23:12,000
Вы могли бы получить, что 2 = 3, в этом случае.

379
00:23:12,000 --> 00:23:14,000
А также быть очень осторожным приоритет.

380
00:23:14,000 --> 00:23:21,000
Вы должны обычно использовать скобки, чтобы быть уверенным, что вы знаете, что вы делаете.

381
00:23:21,000 --> 00:23:27,000
Некоторые полезные ярлыки, конечно, один я + + или я + = 1

382
00:23:27,000 --> 00:23:30,000
или с помощью + =.

383
00:23:30,000 --> 00:23:34,000
Это то же самое, что делал I = I + 1.

384
00:23:34,000 --> 00:23:39,000
Вы также можете сделать я - или я - = 1,

385
00:23:39,000 --> 00:23:42,000
что то же самое, что и I = -1,

386
00:23:42,000 --> 00:23:46,000
что-то вы, ребята используют много в циклы, по крайней мере.

387
00:23:46,000 --> 00:23:52,000
Кроме того, для *, если вы используете * = и, если вы, например,

388
00:23:52,000 --> 00:23:57,000
я * = 2, то же самое, говоря, что я = I * 2,

389
00:23:57,000 --> 00:23:59,000
и то же самое для деления.

390
00:23:59,000 --> 00:24:08,000
Если у вас в / = 2 это то же самое, что я = я / 2.

391
00:24:08,000 --> 00:24:10,000
>> Теперь о функциях.

392
00:24:10,000 --> 00:24:13,000
Вы, ребята узнали, что функции являются очень хорошей стратегией для сохранения кода

393
00:24:13,000 --> 00:24:16,000
в то время как вы программируете, поэтому, если вы хотите выполнить ту же задачу

394
00:24:16,000 --> 00:24:20,000
в код снова и снова, вероятно, вы хотите использовать функцию

395
00:24:20,000 --> 00:24:25,000
просто так вам не придется скопировать и вставить код снова и снова.

396
00:24:25,000 --> 00:24:28,000
На самом деле, основная функция, и когда я покажу вам формат функции

397
00:24:28,000 --> 00:24:32,000
Вы увидите, что это довольно очевидно.

398
00:24:32,000 --> 00:24:35,000
Мы также используем некоторые функции из библиотеки,

399
00:24:35,000 --> 00:24:39,000
Например, Printf, Getin, что из библиотеки CS50,

400
00:24:39,000 --> 00:24:43,000
и другие функции, такие как ToUpper.

401
00:24:43,000 --> 00:24:46,000
Все эти функции реализуются на практике в других библиотеках,

402
00:24:46,000 --> 00:24:49,000
и когда вы поместить эти файлы троса в начале вашей программы

403
00:24:49,000 --> 00:24:53,000
Вы говорите, не могли бы вы дать мне код для этих функций

404
00:24:53,000 --> 00:24:57,000
так что я не должна реализовывать их самостоятельно?

405
00:24:57,000 --> 00:25:00,000
Также вы можете написать свои собственные функции, поэтому, когда вы начинаете программирование

406
00:25:00,000 --> 00:25:04,000
Вы понимаете, что библиотеки не имеют все функции, которые вам нужно.

407
00:25:04,000 --> 00:25:10,000
За последние PSET, например, мы писали рисовать, борьба и поиск,

408
00:25:10,000 --> 00:25:13,000
, и это очень, очень важно, чтобы иметь возможность писать функции

409
00:25:13,000 --> 00:25:17,000
потому что они полезны, и мы используем их все время в программировании,

410
00:25:17,000 --> 00:25:19,000
и это экономит много кода.

411
00:25:19,000 --> 00:25:21,000
Формат функции этого.

412
00:25:21,000 --> 00:25:24,000
У нас есть возвращаемого типа в самом начале. Какой тип возвращаемого значения?

413
00:25:24,000 --> 00:25:27,000
Это просто, когда ваша функция будет возвращать.

414
00:25:27,000 --> 00:25:29,000
Если у вас есть функция, например, факторного,

415
00:25:29,000 --> 00:25:31,000
, которая будет вычислять факториал целого числа,

416
00:25:31,000 --> 00:25:34,000
вероятно, он собирается возвращать целое число, тоже.

417
00:25:34,000 --> 00:25:37,000
Тогда возвращаемого типа будет Int.

418
00:25:37,000 --> 00:25:41,000
Printf на самом деле имеет пустоту возвращаемого типа

419
00:25:41,000 --> 00:25:43,000
потому что вы не возвращается ничего.

420
00:25:43,000 --> 00:25:45,000
Ты просто печатать вещи на экране

421
00:25:45,000 --> 00:25:48,000
и выход из функции после этого.

422
00:25:48,000 --> 00:25:51,000
Тогда у вас есть имя функции, которые вы можете выбрать.

423
00:25:51,000 --> 00:25:55,000
Вы должны быть немного разумны, как не выбирают имя, как XYZ

424
00:25:55,000 --> 00:25:58,000
или как х2.

425
00:25:58,000 --> 00:26:02,000
Попробуйте сделать себе имя, которое имеет смысл.

426
00:26:02,000 --> 00:26:04,000
>> Например, если это факториал, скажем факториал.

427
00:26:04,000 --> 00:26:08,000
Если это функция, которая будет рисовать что-то, назовите его рисовать.

428
00:26:08,000 --> 00:26:11,000
И тогда у нас есть параметры, которые также называются аргументами,

429
00:26:11,000 --> 00:26:14,000
, которые, как ресурсы, что ваша функция должна

430
00:26:14,000 --> 00:26:17,000
из вашего кода для выполнения своих задач.

431
00:26:17,000 --> 00:26:20,000
Если вы хотите, чтобы вычислить факториал числа

432
00:26:20,000 --> 00:26:23,000
вероятно, у Вас должен быть рядом, чтобы вычислить факториал.

433
00:26:23,000 --> 00:26:27,000
Один из аргументов, которые вы собираетесь есть, сам номер.

434
00:26:27,000 --> 00:26:31,000
И тогда это будет что-то делать, и возвращать значение в конце

435
00:26:31,000 --> 00:26:35,000
если это не пустота функции.

436
00:26:35,000 --> 00:26:37,000
Давайте посмотрим на примере.

437
00:26:37,000 --> 00:26:40,000
Если я хочу написать функцию, которая суммирует все числа в массив целых чисел,

438
00:26:40,000 --> 00:26:43,000
Прежде всего, возвращаемого типа будет Int

439
00:26:43,000 --> 00:26:46,000
потому что у меня есть массив целых чисел.

440
00:26:46,000 --> 00:26:51,000
И тогда я буду иметь имя функции, как sumArray,

441
00:26:51,000 --> 00:26:54,000
а затем он собирается взять сам массив, в целое НУМС,

442
00:26:54,000 --> 00:26:58,000
, а затем длину массива, поэтому я знаю, как много чисел, у меня подвести.

443
00:26:58,000 --> 00:27:02,000
Тогда у меня есть для инициализации переменной называют сумму, например, 0,

444
00:27:02,000 --> 00:27:08,000
и каждый раз, когда я вижу элемент в массиве я должен добавить его в сумму, поэтому я сделал цикл.

445
00:27:08,000 --> 00:27:15,000
Так же, как Лекси сказала, вы делаете Int я = 0, <длина и я + +.

446
00:27:15,000 --> 00:27:20,000
И для каждого элемента в массиве я сделал сумму + = НУМС [я],

447
00:27:20,000 --> 00:27:24,000
а потом я вернулся сумму, так что это очень просто, и это экономит много кода

448
00:27:24,000 --> 00:27:28,000
если вы используете эту функцию много раз.

449
00:27:28,000 --> 00:27:32,000
Затем мы рассмотрели условия.

450
00:27:32,000 --> 00:27:38,000
У нас, если, еще, и еще, если.

451
00:27:38,000 --> 00:27:42,000
Давайте посмотрим, в чем разница между теми, кто.

452
00:27:42,000 --> 00:27:45,000
Взгляните на эти 2 коды. В чем разница между ними?

453
00:27:45,000 --> 00:27:49,000
Первая была в основном-коды хочу, чтобы ты

454
00:27:49,000 --> 00:27:51,000
если число +, - или 0.

455
00:27:51,000 --> 00:27:55,000
Первый говорит, что если он> 0, то это положительно.

456
00:27:55,000 --> 00:28:00,000
Если это = 0, то это 0, а если <0, то это отрицательно.

457
00:28:00,000 --> 00:28:04,000
>> А другой делает, если, иначе, если другое.

458
00:28:04,000 --> 00:28:07,000
Разница между ними состоит в том, что этот человек на самом деле собирается

459
00:28:07,000 --> 00:28:13,000
проверить, если> 0, <0 = 0 или три раза,

460
00:28:13,000 --> 00:28:17,000
так что если у вас есть номер 2, например, он собирается приехать сюда и сказать:

461
00:28:17,000 --> 00:28:21,000
Если (X> 0), и он скажет да, так я печатать положительные.

462
00:28:21,000 --> 00:28:25,000
Но, хотя я знаю, что это> 0, и он не собирается быть 0 или <0

463
00:28:25,000 --> 00:28:29,000
Я все еще собираюсь делать это 0, то <0,

464
00:28:29,000 --> 00:28:33,000
так что я на самом деле происходит внутри IFS, что я не должна

465
00:28:33,000 --> 00:28:38,000
потому что я уже знаю, что он не собирается, чтобы удовлетворить любое из этих условий.

466
00:28:38,000 --> 00:28:41,000
Я могу использовать, если, иначе, если другое заявление.

467
00:28:41,000 --> 00:28:45,000
Это в основном говорит, что если х = 0 напечатать положительные.

468
00:28:45,000 --> 00:28:48,000
Если это не так, я буду также проверить это.

469
00:28:48,000 --> 00:28:51,000
Если это 2 не я собираюсь это сделать.

470
00:28:51,000 --> 00:28:54,000
В принципе, если у меня было х = 2 вы могли бы сказать

471
00:28:54,000 --> 00:28:57,000
Если (X> 0), да, так печатать.

472
00:28:57,000 --> 00:29:00,000
Теперь, когда я знаю, что это> 0 и что он удовлетворен первым, если

473
00:29:00,000 --> 00:29:02,000
Я даже не собираюсь запустить этот код.

474
00:29:02,000 --> 00:29:09,000
Код работает быстрее, на самом деле, в 3 раза быстрее, если вы используете это.

475
00:29:09,000 --> 00:29:11,000
Мы также узнали о и и или.

476
00:29:11,000 --> 00:29:15,000
Я не собираюсь пройти через это, потому что Лекси уже говорили о них.

477
00:29:15,000 --> 00:29:17,000
Это просто && и | | оператора.

478
00:29:17,000 --> 00:29:21,000
>> Единственное, что я скажу, будьте осторожны, когда у вас есть 3 условия.

479
00:29:21,000 --> 00:29:24,000
Используйте скобки, потому что это очень запутанным, когда у Вас есть условие

480
00:29:24,000 --> 00:29:27,000
и еще одно или другое.

481
00:29:27,000 --> 00:29:30,000
Используйте скобки просто чтобы быть уверенным, что ваши условия смысла

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

483
00:29:34,000 --> 00:29:38,000
это может быть первым условием и одним или другим

484
00:29:38,000 --> 00:29:41,000
или 2 условия объединенных в и

485
00:29:41,000 --> 00:29:45,000
или третье, так что будьте осторожны.

486
00:29:45,000 --> 00:29:48,000
И, наконец, мы говорили о коммутаторах.

487
00:29:48,000 --> 00:29:53,000
Выключатель очень полезно, когда у вас есть переменная.

488
00:29:53,000 --> 00:29:55,000
Давайте предположим, что у вас есть переменная, как п

489
00:29:55,000 --> 00:29:59,000
что может быть 0, 1 или 2, и для каждого из этих случаев

490
00:29:59,000 --> 00:30:01,000
Вы собираетесь выполнить задачу.

491
00:30:01,000 --> 00:30:04,000
Вы можете сказать переключения переменной, а это означает, что

492
00:30:04,000 --> 00:30:08,000
значение то, как value1 я собираюсь сделать это,

493
00:30:08,000 --> 00:30:12,000
а потом ломается, который означает, что я не буду смотреть на любую из других случаях

494
00:30:12,000 --> 00:30:15,000
потому что мы уже удовлетворены тем, что дело

495
00:30:15,000 --> 00:30:20,000
, а затем value2 и так далее, и я также может иметь значение по умолчанию переключателя.

496
00:30:20,000 --> 00:30:24,000
Это означает, что, если он не удовлетворяет ни одному из дел, которые у меня были

497
00:30:24,000 --> 00:30:29,000
что я собираюсь сделать что-то еще, но это необязательно.

498
00:30:29,000 --> 00:30:36,000
Это все для меня. Теперь давайте Томми.

499
00:30:36,000 --> 00:30:41,000
Все правильно, это будет неделя 3-иш.

500
00:30:41,000 --> 00:30:45,000
Вот некоторые из тем, которые мы будем покрытие, крипто, сферы применения, массивы, и так далее.

501
00:30:45,000 --> 00:30:49,000
Просто слов о криптографии. Мы не собираемся забивать этим домом.

502
00:30:49,000 --> 00:30:52,000
>> Мы сделали это в PSET 2, но для тест убедитесь, что вы знаете разницу

503
00:30:52,000 --> 00:30:54,000
между шифр Цезаря и шифр Виженера,

504
00:30:54,000 --> 00:30:57,000
как обе эти работы шифров и что это такое для шифрования

505
00:30:57,000 --> 00:30:59,000
и расшифровать текст, используя эти 2 шифры.

506
00:30:59,000 --> 00:31:03,000
Помните, что шифр Цезаря просто поворачивает каждый символ на ту же сумму,

507
00:31:03,000 --> 00:31:06,000
убедившись, что вы мода на количество букв в алфавите.

508
00:31:06,000 --> 00:31:09,000
И шифра Виженера, с другой стороны, вращается каждый символ

509
00:31:09,000 --> 00:31:12,000
по другую сумму, так что вместо того, чтобы говорить

510
00:31:12,000 --> 00:31:15,000
каждый персонаж повернут на 3 Виженера будет вращать каждый символ

511
00:31:15,000 --> 00:31:17,000
на разное количество в зависимости от некоторых ключевых слов

512
00:31:17,000 --> 00:31:20,000
где каждая буква в ключевое слово представляет собой некоторую другую сумму

513
00:31:20,000 --> 00:31:26,000
чтобы повернуть открытым текстом по.

514
00:31:26,000 --> 00:31:28,000
Давайте сначала поговорим о переменной области.

515
00:31:28,000 --> 00:31:30,000
Есть 2 различных типов переменных.

516
00:31:30,000 --> 00:31:33,000
У нас есть локальные переменные, и эти будут определены

517
00:31:33,000 --> 00:31:36,000
за пределами основного или вне какой-либо функции или блока,

518
00:31:36,000 --> 00:31:39,000
и они будут доступны в любом месте программы.

519
00:31:39,000 --> 00:31:41,000
Если у вас есть функция, и в этой функции является время цикла

520
00:31:41,000 --> 00:31:44,000
большие глобальные переменные доступны везде.

521
00:31:44,000 --> 00:31:48,000
Локальная переменная, с другой стороны, является областью к месту, где она определена.

522
00:31:48,000 --> 00:31:53,000
>> Если у вас есть функция Вот, например, у нас есть эта функция г,

523
00:31:53,000 --> 00:31:56,000
и внутри G есть переменная здесь называется у,

524
00:31:56,000 --> 00:31:58,000
и это означает, что это локальная переменная.

525
00:31:58,000 --> 00:32:00,000
Даже если эта переменная называется у

526
00:32:00,000 --> 00:32:03,000
и эта переменная называется у этих 2 функций

527
00:32:03,000 --> 00:32:06,000
не знаю, что друг друга локальных переменных.

528
00:32:06,000 --> 00:32:10,000
С другой стороны, здесь мы говорим Int х = 5,

529
00:32:10,000 --> 00:32:12,000
и это выходит за рамки любой функции.

530
00:32:12,000 --> 00:32:16,000
Это выходит за рамки основного, так это глобальная переменная.

531
00:32:16,000 --> 00:32:20,000
Это означает, что внутри этих 2 функций, когда я говорю х - или х + +

532
00:32:20,000 --> 00:32:26,000
Я доступ к той же х причем это у и у этого являются различными переменными.

533
00:32:26,000 --> 00:32:30,000
Вот в чем разница между глобальных переменных и локальных переменных.

534
00:32:30,000 --> 00:32:33,000
Что касается дизайна, то, иногда это хорошей идеей

535
00:32:33,000 --> 00:32:37,000
сохранить локальные переменные, когда вы, возможно, может

536
00:32:37,000 --> 00:32:39,000
так как с кучей глобальных переменных можно получить очень запутанной.

537
00:32:39,000 --> 00:32:42,000
Если у вас есть куча функций все изменения одно и то же

538
00:32:42,000 --> 00:32:45,000
Вы можете забыть, что если эта функция случайного изменяет этот глобальный,

539
00:32:45,000 --> 00:32:47,000
и эта другая функция не знает об этом,

540
00:32:47,000 --> 00:32:50,000
и это действительно становится довольно запутанным, как вы получите больше кода.

541
00:32:50,000 --> 00:32:53,000
Сохранение локальных переменных, когда вы, возможно, может

542
00:32:53,000 --> 00:32:56,000
просто хороший дизайн.

543
00:32:56,000 --> 00:33:00,000
Массивы, помните, что это просто списки из элементов того же типа.

544
00:33:00,000 --> 00:33:04,000
Внутри CI не может иметь список, как 1, 2,0, здравствуйте.

545
00:33:04,000 --> 00:33:06,000
Мы просто не можем этого сделать.

546
00:33:06,000 --> 00:33:11,000
>> Когда мы объявляем массив в C все элементы должны быть того же типа.

547
00:33:11,000 --> 00:33:14,000
Здесь у меня есть массив из 3 целых чисел.

548
00:33:14,000 --> 00:33:18,000
Вот у меня есть длина массива, но если я просто объявить его в этот синтаксис

549
00:33:18,000 --> 00:33:21,000
где я указываю, что все элементы я технически не нужна эта 3.

550
00:33:21,000 --> 00:33:25,000
Компилятор достаточно умен, чтобы понять, насколько большой массив должен быть.

551
00:33:25,000 --> 00:33:28,000
Теперь, когда я хочу, чтобы получить или установить значение массива

552
00:33:28,000 --> 00:33:30,000
это синтаксис, чтобы сделать это.

553
00:33:30,000 --> 00:33:33,000
Это на самом деле изменить второй элемент массива, потому что, помните,

554
00:33:33,000 --> 00:33:36,000
Нумерация начинается с 0, а не с 1.

555
00:33:36,000 --> 00:33:42,000
Если я хочу прочитать, что значение я могу сказать что-то вроде Int х = массив [1].

556
00:33:42,000 --> 00:33:44,000
Или, если я хочу установить это значение, как я здесь делаю,

557
00:33:44,000 --> 00:33:47,000
Я могу сказать, массив [1] = 4.

558
00:33:47,000 --> 00:33:50,000
В это время доступ к элементам по индексу

559
00:33:50,000 --> 00:33:52,000
или их положения или где они находятся в массиве,

560
00:33:52,000 --> 00:33:57,000
и что в каталоге начинается с 0.

561
00:33:57,000 --> 00:34:00,000
Мы можем также есть массивы массивов,

562
00:34:00,000 --> 00:34:03,000
и это называется многомерным массивом.

563
00:34:03,000 --> 00:34:05,000
Когда у нас есть многомерный массив

564
00:34:05,000 --> 00:34:07,000
это означает, что мы можем иметь что-то вроде строк и столбцов,

565
00:34:07,000 --> 00:34:11,000
и это только один из способов визуализации этого или думать об этом.

566
00:34:11,000 --> 00:34:14,000
Когда у меня есть многомерный массив, который означает, что я собираюсь начать нуждающихся

567
00:34:14,000 --> 00:34:17,000
более чем на 1 индекс, потому что если у меня есть сетка

568
00:34:17,000 --> 00:34:19,000
просто говорю, что строка вы находитесь в не дает нам номер.

569
00:34:19,000 --> 00:34:22,000
Это действительно просто хочу, чтобы дать нам список номеров.

570
00:34:22,000 --> 00:34:25,000
Скажем, у меня есть этот массив здесь.

571
00:34:25,000 --> 00:34:30,000
У меня есть массив называется сетка, и я говорю, что это 2 строки и 3 столбца,

572
00:34:30,000 --> 00:34:32,000
и таким образом, это является одним из способов визуализации его.

573
00:34:32,000 --> 00:34:37,000
Когда я говорю, я хочу, чтобы элемент [1] [2]

574
00:34:37,000 --> 00:34:41,000
это означает, что, поскольку эти строки, а затем столбцы

575
00:34:41,000 --> 00:34:44,000
Я собираюсь перейти на строку 1, так как я сказал 1.

576
00:34:44,000 --> 00:34:49,000
>> Тогда я собираюсь приехать сюда в колонке 2, и я собираюсь получить значение 6.

577
00:34:49,000 --> 00:34:51,000
Смысл?

578
00:34:51,000 --> 00:34:55,000
Многомерные массивы, помните, что технически просто массив массивов.

579
00:34:55,000 --> 00:34:57,000
Мы можем иметь массивы массивов массивов.

580
00:34:57,000 --> 00:35:00,000
Мы можем продолжать, но действительно один способ думать о

581
00:35:00,000 --> 00:35:03,000
как это в настоящее время заложен, и то, что происходит, чтобы визуализировать

582
00:35:03,000 --> 00:35:09,000
в сетке, как это.

583
00:35:09,000 --> 00:35:12,000
Когда мы передаем массивов в функции, они будут вести себя

584
00:35:12,000 --> 00:35:16,000
немного по-другому, чем когда мы переходим регулярных переменных функции

585
00:35:16,000 --> 00:35:18,000
как передача Int или с плавающей точкой.

586
00:35:18,000 --> 00:35:21,000
Когда мы передаем в Int или символ или любой из этих других типов данных

587
00:35:21,000 --> 00:35:24,000
мы только что рассмотрели, если функция изменяет

588
00:35:24,000 --> 00:35:28,000
значение этой переменной, что изменения не собираюсь распространяться вверх

589
00:35:28,000 --> 00:35:32,000
в вызывающую функцию.

590
00:35:32,000 --> 00:35:35,000
С массивом, с другой стороны, что будет происходить.

591
00:35:35,000 --> 00:35:39,000
Если бы я передать массив к некоторой функции и функция изменяет некоторые элементы,

592
00:35:39,000 --> 00:35:43,000
когда я вернусь к функции, которые назвали его

593
00:35:43,000 --> 00:35:47,000
мой массив теперь будет по-другому, и словарь для этого

594
00:35:47,000 --> 00:35:50,000
это массивы передаются по ссылке, как мы увидим позже.

595
00:35:50,000 --> 00:35:53,000
Это связано как указатели работы, где эти основные типы данных,

596
00:35:53,000 --> 00:35:55,000
С другой стороны, передаются по значению.

597
00:35:55,000 --> 00:35:59,000
>> Мы можем думать о том, как сделать копию некоторые переменные и переходя затем в копии.

598
00:35:59,000 --> 00:36:01,000
Не имеет значения, что мы делаем с этой переменной.

599
00:36:01,000 --> 00:36:06,000
Вызывающая функция не будет знать, что он изменился.

600
00:36:06,000 --> 00:36:10,000
Массивы являются лишь немного отличается в этом отношении.

601
00:36:10,000 --> 00:36:13,000
Например, как мы только что видели, основным является просто функцией

602
00:36:13,000 --> 00:36:15,000
что можно взять в 2 аргументов.

603
00:36:15,000 --> 00:36:20,000
Первый аргумент основной функцией является агдс, или количество аргументов,

604
00:36:20,000 --> 00:36:23,000
а второй аргумент называется ARGV,

605
00:36:23,000 --> 00:36:27,000
и те фактические значения этих аргументов.

606
00:36:27,000 --> 00:36:30,000
Скажем, у меня есть программа под названием this.c,

607
00:36:30,000 --> 00:36:34,000
и я говорю это сделать, и я собираюсь запустить в командной строке.

608
00:36:34,000 --> 00:36:38,000
Теперь, чтобы пройти в некоторые аргументы, чтобы моя программа называется это,

609
00:36:38,000 --> 00:36:42,000
Я мог бы сказать нечто подобное. / Это CS 50.

610
00:36:42,000 --> 00:36:45,000
Это то, что мы воображаем, Дэвид делать каждый день на терминале.

611
00:36:45,000 --> 00:36:48,000
Но теперь основная функция внутри этой программы

612
00:36:48,000 --> 00:36:52,000
имеет следующие значения, так агдс равна 4.

613
00:36:52,000 --> 00:36:56,000
Это может быть немного запутанным, потому что на самом деле мы только проходящие в это CS 50.

614
00:36:56,000 --> 00:36:58,000
Вот только 3.

615
00:36:58,000 --> 00:37:02,000
Но помните, что первый элемент ARGV или первый аргумент

616
00:37:02,000 --> 00:37:05,000
это имя самой функции.

617
00:37:05,000 --> 00:37:07,190
Таким образом, это означает, что у нас есть 4 вещи здесь,

618
00:37:07,190 --> 00:37:10,530
и первый элемент будет. / это.

619
00:37:10,530 --> 00:37:12,970
И это будет представлено в виде строки.

620
00:37:12,970 --> 00:37:18,590
Тогда остальные элементы того, что мы набрали после названия программы.

621
00:37:18,590 --> 00:37:22,720
Так же, как в стороне, так как мы, наверное, видели в PSET 2,

622
00:37:22,720 --> 00:37:28,780
помните, что строка 50, ≠ целых 50.

623
00:37:28,780 --> 00:37:32,520
Поэтому мы не можем сказать что-то вроде: "INT X = ARGV 3".

624
00:37:32,520 --> 00:37:36,470
>> Вот только не собирается смысла, потому что это строка, и это число.

625
00:37:36,470 --> 00:37:38,510
Так что, если вы хотите конвертировать между 2, помните, что мы собираемся

626
00:37:38,510 --> 00:37:40,810
есть эта волшебная функция называется atoi.

627
00:37:40,810 --> 00:37:46,270
, Которая принимает строку и возвращает целое число представлено в этой строке.

628
00:37:46,270 --> 00:37:48,360
Так что это легко сделать ошибку в викторине,

629
00:37:48,360 --> 00:37:51,590
просто думал, что это будет автоматически правильный тип.

630
00:37:51,590 --> 00:37:53,860
Но точно знаю, что это всегда будет строк

631
00:37:53,860 --> 00:38:00,920
даже если строка содержит только целое число или символ или с плавающей точкой.

632
00:38:00,920 --> 00:38:03,380
Итак, теперь давайте поговорим о времени работы.

633
00:38:03,380 --> 00:38:06,700
Когда у нас есть все эти алгоритмы, которые делают все эти безумные вещи,

634
00:38:06,700 --> 00:38:11,580
это становится действительно полезно задаться вопросом: «Как долго они принимают?"

635
00:38:11,580 --> 00:38:15,500
Мы представляем, что нечто, называемое асимптотическое обозначение.

636
00:38:15,500 --> 00:38:18,430
Таким образом, это означает, что - ну, скажем, мы даем нашим алгоритмом

637
00:38:18,430 --> 00:38:20,840
некоторые очень, очень, очень большой вклад.

638
00:38:20,840 --> 00:38:23,840
Мы хотим задать вопрос: "Как долго это займет?

639
00:38:23,840 --> 00:38:26,370
Сколько шагов займет наш алгоритм для запуска

640
00:38:26,370 --> 00:38:29,980
в зависимости от размера входных данных? "

641
00:38:29,980 --> 00:38:33,080
Итак, первый способ, которым мы можем описать время выполнения с большой О.

642
00:38:33,080 --> 00:38:35,380
И это наш наихудший ход времени.

643
00:38:35,380 --> 00:38:38,590
Поэтому если мы хотим, чтобы отсортировать массив, и мы даем нашим алгоритмом массива

644
00:38:38,590 --> 00:38:41,000
это в порядке убывания, когда оно должно быть в порядке возрастания,

645
00:38:41,000 --> 00:38:43,130
что будет в худшем случае.

646
00:38:43,130 --> 00:38:49,800
Это наша верхняя грань в максимальное время наш алгоритм будет.

647
00:38:49,800 --> 00:38:54,740
С другой стороны, эта Ω будет описывать лучшем случае время работы.

648
00:38:54,740 --> 00:38:58,210
Так что, если мы дадим уже отсортированный массив в алгоритм сортировки,

649
00:38:58,210 --> 00:39:00,940
Как долго это займет, чтобы уладить его?

650
00:39:00,940 --> 00:39:06,610
И это, то, описывает нижнюю границу на время работы.

651
00:39:06,610 --> 00:39:10,980
Итак, вот лишь некоторые слова, которые описывают некоторые общие работает раза.

652
00:39:10,980 --> 00:39:13,120
Это в порядке возрастания.

653
00:39:13,120 --> 00:39:16,060
Самый быстрый бег времени у нас называется постоянным.

654
00:39:16,060 --> 00:39:19,800
>> Это означает, что независимо от того, сколько элементов мы даем нашим алгоритмом,

655
00:39:19,800 --> 00:39:22,280
независимо от того, насколько велика наша массив, сортировка

656
00:39:22,280 --> 00:39:26,510
или делать то, что мы делаем в массив всегда будет такое же количество времени.

657
00:39:26,510 --> 00:39:30,270
Таким образом, мы можем представить, что только с 1, который является постоянным.

658
00:39:30,270 --> 00:39:32,410
Мы также посмотрели на логарифмическое время перспективе.

659
00:39:32,410 --> 00:39:34,800
Так что-то вроде двоичного поиска является логарифмической,

660
00:39:34,800 --> 00:39:37,140
где мы сократили проблема в два раза каждый раз, когда

661
00:39:37,140 --> 00:39:40,970
а потом все просто получить высшее оттуда.

662
00:39:40,970 --> 00:39:43,580
И если вы когда-нибудь письменно о любых факториал алгоритм,

663
00:39:43,580 --> 00:39:47,850
Вы, вероятно, не следует рассматривать это как свою работу дня.

664
00:39:47,850 --> 00:39:53,910
Когда мы сравниваем времени работы очень важно иметь в виду эти вещи.

665
00:39:53,910 --> 00:39:57,760
Так что, если у меня есть алгоритм, который O (N), а кто-то другой

666
00:39:57,760 --> 00:40:03,590
была алгоритма O (2n), это на самом деле асимптотически эквивалентны.

667
00:40:03,590 --> 00:40:06,590
Таким образом, если представить себе, п быть большое количество, как eleventy млрд:

668
00:40:06,590 --> 00:40:13,090
поэтому, когда мы сравниваем eleventy млрд. что-то вроде eleventy млрд. + 3,

669
00:40:13,090 --> 00:40:17,640
+3 внезапно, что на самом деле не делают большой разницы больше.

670
00:40:17,640 --> 00:40:20,980
Вот почему мы собираемся начать рассматривать эти вещи, чтобы быть эквивалентными.

671
00:40:20,980 --> 00:40:24,220
Так что такие вещи, как эти константы здесь, есть 2 х это, или добавление 3,

672
00:40:24,220 --> 00:40:27,180
это просто константы, и они собираются бросить вверх.

673
00:40:27,180 --> 00:40:32,480
Так вот почему все эти 3 раза перспективе такие же, как говорят они O (N).

674
00:40:32,480 --> 00:40:37,490
Аналогично, если у нас есть 2 другие времена перспективе, скажем, O (N ³ + 2n ²), мы можем добавить

675
00:40:37,490 --> 00:40:42,070
+ П, + 7, а затем у нас есть еще время выполнения, что просто O (N ³).

676
00:40:42,070 --> 00:40:46,290
опять же, это одно и то же, потому что это - это не то же самое.

677
00:40:46,290 --> 00:40:49,840
Это те же самые вещи, извините. Таким образом, это те же самые, потому что

678
00:40:49,840 --> 00:40:53,090
эта ³ п будет доминировать в этом 2n ².

679
00:40:53,090 --> 00:40:59,130
>> Что не одно и то же, если мы уже запустили время, как O (N ³) и O (N ²)

680
00:40:59,130 --> 00:41:02,820
потому что эта ³ п гораздо больше, чем эта ² н.

681
00:41:02,820 --> 00:41:05,470
Так что, если у нас есть показатели, вдруг это начинает значения,

682
00:41:05,470 --> 00:41:08,280
Но когда мы просто дело с факторами, как мы здесь,

683
00:41:08,280 --> 00:41:12,810
то он не собирается значения, потому что они только собираются бросать.

684
00:41:12,810 --> 00:41:16,760
Давайте взглянем на некоторые алгоритмы, которые мы видели до сих пор

685
00:41:16,760 --> 00:41:19,260
и говорить об их выполнения.

686
00:41:19,260 --> 00:41:23,850
Первый взгляд на номер в списке, который мы видели, был линейный поиск.

687
00:41:23,850 --> 00:41:26,950
И реализация линейного поиска супер просто.

688
00:41:26,950 --> 00:41:30,490
Мы просто есть список, и мы будем смотреть на каждый отдельный элемент в списке

689
00:41:30,490 --> 00:41:34,260
пока мы не найдем число, которое мы ищем.

690
00:41:34,260 --> 00:41:38,370
Таким образом, это означает, что в худшем случае, это O (N).

691
00:41:38,370 --> 00:41:40,860
А в худшем случае здесь могло бы быть, если элемент

692
00:41:40,860 --> 00:41:45,710
Последний элемент, то с помощью линейного поиска, мы должны смотреть на каждый отдельный элемент

693
00:41:45,710 --> 00:41:50,180
пока мы не получим до последнего, чтобы знать, что это было на самом деле в списке.

694
00:41:50,180 --> 00:41:52,910
Мы не можем просто бросить на полпути и сказать: "Это, наверное, нет».

695
00:41:52,910 --> 00:41:55,980
С линейный поиск, мы должны смотреть на все это.

696
00:41:55,980 --> 00:41:59,090
Лучшем случае время работы, с другой стороны, постоянно

697
00:41:59,090 --> 00:42:04,200
потому что в лучшем случае элемент мы ищем это только первый в списке.

698
00:42:04,200 --> 00:42:08,930
Таким образом, он собирается взять нас ровно на 1 шаг, независимо от того, насколько большой список

699
00:42:08,930 --> 00:42:12,140
если мы ищем первый элемент каждый раз.

700
00:42:12,140 --> 00:42:15,390
>> Поэтому, когда вы будете искать, помните, это не требует, чтобы наш список будет отсортирован.

701
00:42:15,390 --> 00:42:19,430
Потому что мы просто будем смотреть на каждый отдельный элемент, и это действительно не имеет значения

702
00:42:19,430 --> 00:42:23,560
в каком порядке эти элементы дюйма

703
00:42:23,560 --> 00:42:28,110
Более интеллектуальный алгоритм поиска что-то вроде бинарного поиска.

704
00:42:28,110 --> 00:42:31,500
Помните, что реализация бинарного поиска, когда вы собираетесь

705
00:42:31,500 --> 00:42:34,320
продолжайте смотреть в середину списка.

706
00:42:34,320 --> 00:42:38,000
И потому, что мы смотрим на середине, мы требуем, чтобы список сортируется

707
00:42:38,000 --> 00:42:40,580
иначе мы не знаем, где середина, и мы должны смотреть на

708
00:42:40,580 --> 00:42:44,480
весь список, чтобы найти его, а затем на тот момент мы просто теряем время.

709
00:42:44,480 --> 00:42:48,480
Так что, если у нас есть отсортированный список, и мы находим середину, мы собираемся сравнить средние

710
00:42:48,480 --> 00:42:51,590
к элементу мы ищем.

711
00:42:51,590 --> 00:42:54,640
Если она слишком высока, то мы можем забыть правой половины

712
00:42:54,640 --> 00:42:57,810
потому что мы знаем, что если наш элемент уже слишком высоки

713
00:42:57,810 --> 00:43:01,080
и все, что правее этого элемента еще выше,

714
00:43:01,080 --> 00:43:02,760
то мы не должны смотреть там больше.

715
00:43:02,760 --> 00:43:05,430
Если, с другой стороны, если наш элемент является слишком низкой,

716
00:43:05,430 --> 00:43:08,700
Мы знаем все, чтобы слева от этого элемента также является слишком низкой,

717
00:43:08,700 --> 00:43:11,390
таким образом, это действительно не имеет смысла искать там, также.

718
00:43:11,390 --> 00:43:15,760
Таким образом, с каждым шагом, и каждый раз, когда мы смотрим на середину списка,

719
00:43:15,760 --> 00:43:19,060
Мы собираемся сократить наши проблемы в половину, потому что внезапно мы знаем,

720
00:43:19,060 --> 00:43:23,040
целую кучу цифр, что не может быть тот, который мы ищем.

721
00:43:23,040 --> 00:43:26,950
>> В псевдокоде это будет выглядеть примерно так,

722
00:43:26,950 --> 00:43:30,990
и потому, что мы резки списка в два раза каждый раз,

723
00:43:30,990 --> 00:43:34,920
наши наихудшие время выполнения прыжков с линейной к логарифмической.

724
00:43:34,920 --> 00:43:39,260
Так неожиданно мы имеем вход в систему шаги для того, чтобы найти элемент в списке.

725
00:43:39,260 --> 00:43:42,460
Лучшем случае ход времени, хотя, по-прежнему постоянной

726
00:43:42,460 --> 00:43:45,180
потому что теперь, давайте просто скажем, что элемент мы ищем является

727
00:43:45,180 --> 00:43:48,380
Всегда точно посередине первоначального списка.

728
00:43:48,380 --> 00:43:52,080
Так что мы можем развивать наш список как большой, как мы хотим, но если элемент мы ищем находится на середине,

729
00:43:52,080 --> 00:43:54,910
Затем она только собирается взять нас на 1 шаг.

730
00:43:54,910 --> 00:44:00,920
Так вот почему мы O (журнал N) и Ω (1) или постоянными.

731
00:44:00,920 --> 00:44:04,510
Давайте реально работать бинарный поиск в этом списке.

732
00:44:04,510 --> 00:44:08,020
Так что давайте говорить, что мы ищем элемент 164.

733
00:44:08,020 --> 00:44:11,650
Первое, что мы собираемся сделать, это найти середину этого списка.

734
00:44:11,650 --> 00:44:15,060
Просто так получилось, что середина будет падать между этими 2 номера,

735
00:44:15,060 --> 00:44:18,960
так что давайте просто сколь угодно говорить, каждый раз середина находится между 2 номера,

736
00:44:18,960 --> 00:44:21,150
Давайте просто округлить.

737
00:44:21,150 --> 00:44:24,330
Нам просто нужно убедиться, что мы делаем это каждый шаг пути.

738
00:44:24,330 --> 00:44:29,040
Так что мы собираемся сгонять, и мы собираемся сказать, что 161 является средним из нашего списка.

739
00:44:29,040 --> 00:44:34,640
Так что 161 <164, и каждый элемент в левом из 161

740
00:44:34,640 --> 00:44:39,120
Также <164, так что мы знаем, что это не поможет нам на всех

741
00:44:39,120 --> 00:44:42,690
, чтобы начать искать здесь, потому что элемент мы ищем не может быть там.

742
00:44:42,690 --> 00:44:47,060
Итак, что мы можем сделать, мы можем просто забыть о том, что вся левая половина списка,

743
00:44:47,060 --> 00:44:51,700
а теперь рассматривать только с правой из 161 и далее.

744
00:44:51,700 --> 00:44:54,050
>> Итак, еще раз, это середина, давайте просто округлить.

745
00:44:54,050 --> 00:44:56,260
Сейчас 175 является слишком большой.

746
00:44:56,260 --> 00:44:59,180
Итак, мы знаем, что это не поможет нам искать здесь или здесь,

747
00:44:59,180 --> 00:45:06,610
поэтому мы можем просто бросить, что далеко, и в итоге мы попали в 164.

748
00:45:06,610 --> 00:45:10,560
Любые вопросы по двоичного поиска?

749
00:45:10,560 --> 00:45:14,180
Давайте перейдем от поиска в уже отсортированный список

750
00:45:14,180 --> 00:45:17,660
на самом деле принимает список чисел в любом порядке

751
00:45:17,660 --> 00:45:20,960
и сделать этот список в порядке возрастания.

752
00:45:20,960 --> 00:45:24,060
Первый алгоритм мы смотрели на называлось пузырьковой сортировки.

753
00:45:24,060 --> 00:45:27,300
И это будет гораздо проще алгоритмов, которые мы видели.

754
00:45:27,300 --> 00:45:32,970
Bubble рода говорит, что когда любые 2 элемента внутри списка не на месте,

755
00:45:32,970 --> 00:45:36,500
то есть есть большее число слева от меньшего числа,

756
00:45:36,500 --> 00:45:40,190
Затем мы собираемся поменять их местами, потому что это означает, что список будет

757
00:45:40,190 --> 00:45:42,860
"Более упорядоченные", чем это было раньше.

758
00:45:42,860 --> 00:45:45,180
И мы просто будем продолжать этот процесс снова и снова, и снова

759
00:45:45,180 --> 00:45:52,100
пока в конце концов элементов вида пузырь на их правильное расположение и у нас есть отсортированный список.

760
00:45:52,100 --> 00:45:57,230
>> Время выполнения этого будет O (N ²). Почему?

761
00:45:57,230 --> 00:46:00,370
Ну, потому что в худшем случае, мы собираемся взять каждый элемент, и

762
00:46:00,370 --> 00:46:04,570
мы собираемся в конечном итоге, сравнивая ее с любой другой элемент в списке.

763
00:46:04,570 --> 00:46:08,030
Но в лучшем случае, у нас есть уже отсортированный список, пузырьковой сортировки в

764
00:46:08,030 --> 00:46:12,230
только собирается пройти один раз, сказать: "Нет. Я не делал никаких свопов, так что я сделал".

765
00:46:12,230 --> 00:46:17,410
Итак, мы имеем лучшем случае время работы Ω (N).

766
00:46:17,410 --> 00:46:20,680
Давайте запустим пузырьковой сортировки в списке.

767
00:46:20,680 --> 00:46:23,560
Или сначала, давайте просто посмотрим на некоторые псевдокод очень быстро.

768
00:46:23,560 --> 00:46:28,160
Мы хотим сказать, что мы хотим отслеживать, в каждой итерации цикла,

769
00:46:28,160 --> 00:46:32,190
отслеживать ли мы изменили какие-либо элементы.

770
00:46:32,190 --> 00:46:37,610
Таким образом, причина этого в том, что мы собираемся остановиться, когда мы не поменялись местами любые элементы.

771
00:46:37,610 --> 00:46:41,980
Таким образом, в начале нашего цикла мы не поменялись местами ничего, поэтому мы будем говорить, что это ложь.

772
00:46:41,980 --> 00:46:47,170
Теперь, мы собираемся пройтись по списку и сравнить элемента к элементу я я + 1

773
00:46:47,170 --> 00:46:50,310
и если это так, что есть большее число слева от меньшего числа,

774
00:46:50,310 --> 00:46:52,310
Затем мы только собираемся, чтобы поменять их местами.

775
00:46:52,310 --> 00:46:54,490
>> И тогда мы будем помнить, что мы поменялись местами элемент.

776
00:46:54,490 --> 00:46:58,900
Это означает, что мы должны идти по списку, по крайней мере, еще 1 раз

777
00:46:58,900 --> 00:47:02,160
потому что состояние, в котором мы остановились, когда весь список уже отсортирован,

778
00:47:02,160 --> 00:47:04,890
означает, что мы не сделали никаких свопов.

779
00:47:04,890 --> 00:47:09,960
Так вот почему наши условия здесь является «в то время как некоторые элементы были заменены.

780
00:47:09,960 --> 00:47:13,720
Итак, теперь давайте посмотрим на это работает на список.

781
00:47:13,720 --> 00:47:16,640
У меня есть список 5,0,1,6,4.

782
00:47:16,640 --> 00:47:19,850
Bubble рода собирается начать весь путь слева, и это будет для сравнения

783
00:47:19,850 --> 00:47:24,700
я элементов, так от 0 до + 1, которое является элементом 1.

784
00:47:24,700 --> 00:47:29,020
Он скажет, ну 5> 0, но прямо сейчас 5 находится слева,

785
00:47:29,020 --> 00:47:32,500
так что мне нужно поменять местами 5 и 0.

786
00:47:32,500 --> 00:47:35,470
Когда я поменять их местами, вдруг я получаю это другой список.

787
00:47:35,470 --> 00:47:38,260
Сейчас 5> 1, так что мы собираемся поменять их местами.

788
00:47:38,260 --> 00:47:42,160
5 не> 6, поэтому мы не должны ничего делать здесь.

789
00:47:42,160 --> 00:47:46,690
Но 6> 4, так что мы должны поменять.

790
00:47:46,690 --> 00:47:49,740
Опять же, нам нужно запустить весь список, чтобы в конце концов обнаружить

791
00:47:49,740 --> 00:47:52,330
что эти вышли из строя, мы поменять их местами,

792
00:47:52,330 --> 00:47:57,120
и в этот момент нам нужно запустить через список еще 1 раз

793
00:47:57,120 --> 00:48:05,390
чтобы убедиться, что все в его распоряжении, и в этот момент пузырьковой сортировки закончен.

794
00:48:05,390 --> 00:48:10,720
Различных алгоритмов для принятия некоторых элементов и сортировка них является выбор рода.

795
00:48:10,720 --> 00:48:15,740
Идея выбора рода является то, что мы собираемся построить отсортированный часть списка

796
00:48:15,740 --> 00:48:18,150
1 элемент одновременно.

797
00:48:18,150 --> 00:48:23,170
>> И то, как мы собираемся сделать это путем создания левой части списка.

798
00:48:23,170 --> 00:48:27,510
А в принципе, каждый - на каждом шагу, мы собираемся взять наименьший элемент мы оставили

799
00:48:27,510 --> 00:48:32,310
, которые не были отсортированы еще, и мы собираемся, чтобы переместить его в это отсортированный сегменте.

800
00:48:32,310 --> 00:48:35,850
Это означает, что мы должны постоянно находить минимальный элемент несортированные

801
00:48:35,850 --> 00:48:40,720
, а затем принять, что минимальный элемент и поменять его с тем, что

802
00:48:40,720 --> 00:48:45,090
левый элемент, который не сортируется.

803
00:48:45,090 --> 00:48:50,890
Время выполнения этого будет O (N ²), потому что в худшем случае

804
00:48:50,890 --> 00:48:55,070
мы должны сравнить каждый элемент любой другой элемент.

805
00:48:55,070 --> 00:48:59,250
Потому что мы говорим, что если мы начнем в левой половине списка, мы должны

806
00:48:59,250 --> 00:49:02,970
пройти через весь правый сегмент, чтобы найти наименьший элемент.

807
00:49:02,970 --> 00:49:05,430
А потом, опять же, мы должны идти в течение всего правого сегмента и

808
00:49:05,430 --> 00:49:08,210
продолжать над этим снова и снова, и снова.

809
00:49:08,210 --> 00:49:11,350
Это будет п ². Мы собираемся нужно цикл внутри другого цикла

810
00:49:11,350 --> 00:49:13,350
что свидетельствует о п ².

811
00:49:13,350 --> 00:49:16,530
В лучшем случае мысль, скажем, мы даем ему уже отсортированный список;

812
00:49:16,530 --> 00:49:19,270
мы на самом деле не делают лучше, чем ² н.

813
00:49:19,270 --> 00:49:21,730
Потому что выбор рода не имеет возможности узнать, что

814
00:49:21,730 --> 00:49:25,540
минимальный элемент только один я, случается, смотрит.

815
00:49:25,540 --> 00:49:28,970
Он по-прежнему должен убедиться, что это действительно минимум.

816
00:49:28,970 --> 00:49:31,670
>> И единственный способ, чтобы убедиться, что это минимум, с помощью этого алгоритма,

817
00:49:31,670 --> 00:49:34,640
, чтобы смотреть на каждый отдельный элемент снова.

818
00:49:34,640 --> 00:49:38,420
Так на самом деле, если вы даете ему - если вы дадите выбор рода уже отсортированный список,

819
00:49:38,420 --> 00:49:42,720
он не собирается делать лучше, чем дать ему список, что не отсортирован еще нет.

820
00:49:42,720 --> 00:49:46,320
Кстати, если оно произойдет, будет случай, что что-то O (что-то)

821
00:49:46,320 --> 00:49:50,640
и омега-то, мы можем только сказать, более кратко, что это θ чего-то.

822
00:49:50,640 --> 00:49:52,760
Так что если вы видите, что придумать в любом месте, это то, что это просто означает.

823
00:49:52,760 --> 00:49:57,580
>> Если что-то тета-н ², это и большая O (N ²) и Ω (N ²).

824
00:49:57,580 --> 00:49:59,790
Так лучшем случае, а худшем случае, это не делает разницы,

825
00:49:59,790 --> 00:50:04,400
Алгоритм собирается сделать то же самое каждый раз.

826
00:50:04,400 --> 00:50:06,610
Так это то, что псевдокод для выбора рода могла бы выглядеть.

827
00:50:06,610 --> 00:50:10,630
Мы в основном будем говорить, что я хочу пройти по списку

828
00:50:10,630 --> 00:50:15,180
слева направо, и на каждой итерации цикла, я собираюсь переехать

829
00:50:15,180 --> 00:50:19,780
минимальный элемент в этой отсортированы часть списка.

830
00:50:19,780 --> 00:50:23,260
И как только я перехожу что-то там, я никогда не должны смотреть на этот элемент снова.

831
00:50:23,260 --> 00:50:28,600
Потому что как только я поменять элемент в левой части списка, это отсортированный

832
00:50:28,600 --> 00:50:32,600
потому что мы делаем все, что в порядке возрастания с использованием минимума.

833
00:50:32,600 --> 00:50:38,740
Поэтому мы сказали, хорошо, что мы в положении я, и мы должны смотреть на все элементы

834
00:50:38,740 --> 00:50:42,260
справа от меня, чтобы найти минимум.

835
00:50:42,260 --> 00:50:46,150
Таким образом, это означает, что мы хотим смотреть с г + 1 в конец списка.

836
00:50:46,150 --> 00:50:51,610
И теперь, если элемент, который мы в настоящее время смотрим на это меньше, чем наши минимальные до сих пор,

837
00:50:51,610 --> 00:50:54,190
который, помните, что мы начинаем с минимальным просто быть

838
00:50:54,190 --> 00:50:57,020
любого элемента мы в настоящее время, я буду считать, что это минимум.

839
00:50:57,020 --> 00:51:00,270
Если я найду элемент, который меньше, чем это, то я буду говорить, ладно,

840
00:51:00,270 --> 00:51:02,700
Ну, я нашел новый минимум.

841
00:51:02,700 --> 00:51:06,080
Я буду помнить, где что было минимальным.

842
00:51:06,080 --> 00:51:09,560
>> Так что теперь, когда я прошел через это право несортированные сегменте,

843
00:51:09,560 --> 00:51:16,690
Я могу сказать, что я собираюсь поменять местами минимальный элемент с элементом, который находится в положении я.

844
00:51:16,690 --> 00:51:21,100
Это собирается построить мой список, отсортированный моей части списка слева направо,

845
00:51:21,100 --> 00:51:25,190
и мы никогда не должны смотреть на элемент снова, как только она в этой части.

846
00:51:25,190 --> 00:51:27,930
Как только мы сменил его.

847
00:51:27,930 --> 00:51:30,260
Так что давайте работать выбор рода в этом списке.

848
00:51:30,260 --> 00:51:38,220
Синие элементом здесь будет я, а красный элемент будет минимальным элементом.

849
00:51:38,220 --> 00:51:41,570
Так что я все начинается путь в левой части списка, так на 5.

850
00:51:41,570 --> 00:51:44,610
Теперь нам нужно найти минимум несортированные элемент.

851
00:51:44,610 --> 00:51:49,480
Поэтому мы говорим, 0 <5, так что 0 является мой новый минимум.

852
00:51:49,480 --> 00:51:53,820
>> Но я не могу остановиться, потому что даже если мы можем признать, что 0 является наименьшим,

853
00:51:53,820 --> 00:51:59,390
нам нужно запустить через любой другой элемент списка, чтобы убедиться.

854
00:51:59,390 --> 00:52:01,760
Таким образом, 1 больше, 6 больше, 4 больше.

855
00:52:01,760 --> 00:52:05,850
Это означает, что после того, глядя на все эти элементы, я определяли 0 является наименьшим.

856
00:52:05,850 --> 00:52:09,800
Так что я собираюсь поменять 5 и 0.

857
00:52:09,800 --> 00:52:15,480
Однажды я поменять, что я собираюсь получить новый список, и я знаю, что я никогда не нужно смотреть на что 0 раз

858
00:52:15,480 --> 00:52:19,380
потому что как только я сменил его, я уладил его, и мы сделали.

859
00:52:19,380 --> 00:52:22,730
Теперь так уж случилось, что синий элемент снова 5,

860
00:52:22,730 --> 00:52:26,030
и мы должны смотреть на 1, 6 и 4, чтобы определить, что 1

861
00:52:26,030 --> 00:52:31,520
является наименьшим минимальным элементом, поэтому мы переставляем 1 и 5.

862
00:52:31,520 --> 00:52:36,890
Опять же, мы должны смотреть на - сравнить от 5 до 6 и 4,

863
00:52:36,890 --> 00:52:39,830
и мы собираемся поменять 4 и 5, и, наконец, сравнить

864
00:52:39,830 --> 00:52:45,740
эти 2 номера и поменять их местами, пока мы не получим наши отсортированный список.

865
00:52:45,740 --> 00:52:49,730
Любые вопросы по выбору рода?

866
00:52:49,730 --> 00:52:56,420
Хорошо. Давайте перейдем к последней теме здесь, и это рекурсия.

867
00:52:56,420 --> 00:52:59,810
>> Рекурсия, помните, что это действительно мета вещь, где функция

868
00:52:59,810 --> 00:53:02,740
неоднократно называет себя.

869
00:53:02,740 --> 00:53:05,620
Так что в какой-то момент, в то время как наши Fuction неоднократно называет себя,

870
00:53:05,620 --> 00:53:10,100
там должно быть некоторое точке, в которой мы перестать называть себя.

871
00:53:10,100 --> 00:53:13,670
Потому что если мы не сделаем этого, то мы просто будем продолжать делать это вечно,

872
00:53:13,670 --> 00:53:16,660
и наша программа просто не будет прекращаться.

873
00:53:16,660 --> 00:53:19,200
Мы называем это состояние базового варианта.

874
00:53:19,200 --> 00:53:22,570
И базовый вариант, говорит, вместо вызова функции снова,

875
00:53:22,570 --> 00:53:25,330
Я просто хочу вернуть некоторое значение.

876
00:53:25,330 --> 00:53:28,080
Поэтому, как только мы вернулись значение, мы перестали называть себя,

877
00:53:28,080 --> 00:53:32,550
и остальные вызовы мы сделали до сих пор можно вернуть.

878
00:53:32,550 --> 00:53:36,050
В противоположность базу случае является рекурсивным случае.

879
00:53:36,050 --> 00:53:39,050
И это, когда мы хотим сделать еще один вызов функции, которые мы в настоящее время дюйма

880
00:53:39,050 --> 00:53:44,690
И мы, вероятно, хотя и не всегда, хотят использовать различные аргументы.

881
00:53:44,690 --> 00:53:48,940
>> Так что, если у нас есть функция под названием F и F только что позвонил принимать по 1 аргумент,

882
00:53:48,940 --> 00:53:52,010
и мы просто звонят F (1), F (1), F (1), и так уж случилось, что

883
00:53:52,010 --> 00:53:56,510
аргумент 1 попадает в рекурсивном случае, мы еще ни разу не собирается останавливаться.

884
00:53:56,510 --> 00:54:01,620
Даже если у нас есть базовый вариант, мы должны убедиться, что в конечном счете мы собираемся ударить, что базовый вариант.

885
00:54:01,620 --> 00:54:04,250
Мы не просто сохранить, проживающие в этом случае рекурсивной.

886
00:54:04,250 --> 00:54:09,870
Вообще, когда мы называем себя, мы, вероятно, будем иметь другой аргумент каждый раз.

887
00:54:09,870 --> 00:54:12,700
Вот очень простой рекурсивной функции.

888
00:54:12,700 --> 00:54:15,090
Так что это будет вычислить факториал числа.

889
00:54:15,090 --> 00:54:17,790
До начала здесь мы имеем нашу базу случае.

890
00:54:17,790 --> 00:54:22,330
В случае, когда п ≤ 1, мы не будем называть факториальным снова.

891
00:54:22,330 --> 00:54:26,490
Мы собираемся останавливаться, мы просто собираемся вернуть некоторое значение.

892
00:54:26,490 --> 00:54:30,170
Если это не так, то мы собираемся ударить нашем случае рекурсивной.

893
00:54:30,170 --> 00:54:33,550
Заметьте, что здесь мы не просто вызовом факториал (п), потому что это было бы очень полезно.

894
00:54:33,550 --> 00:54:36,810
Мы будем называть факториал что-то другое.

895
00:54:36,810 --> 00:54:40,850
>> И поэтому вы можете увидеть, в конце концов, если мы передадим факториал (5) или что-то,

896
00:54:40,850 --> 00:54:45,900
мы будем называть факториал (4) и так далее, и в конце концов мы собираемся ударить эту базу случае.

897
00:54:45,900 --> 00:54:51,730
Таким образом, это хорошо выглядит. Давайте посмотрим, что происходит, когда мы реально работать это.

898
00:54:51,730 --> 00:54:57,840
Это стека, и давайте скажем, что основным будет вызывать эту функцию с аргументом (4).

899
00:54:57,840 --> 00:55:02,200
Поэтому, как только видит и факториал = 4, факторный будет называть себя.

900
00:55:02,200 --> 00:55:05,010
Теперь, вдруг, у нас есть факториал (3).

901
00:55:05,010 --> 00:55:10,780
Таким образом, эти функции будет продолжать расти, пока в конце концов мы попали нашу базу случае.

902
00:55:10,780 --> 00:55:17,830
На данный момент, возвращаемым значением этого является возвращение (NX возвращаемого значения этого),

903
00:55:17,830 --> 00:55:21,290
возвращаемым значением этого NX возвращаемого значения этому.

904
00:55:21,290 --> 00:55:23,290
В конечном счете мы должны поразить некоторое число.

905
00:55:23,290 --> 00:55:26,560
В верхней здесь, мы говорим, возвращает 1.

906
00:55:26,560 --> 00:55:30,650
Это означает, что, когда мы вернемся это число, мы можем поп этом из стека.

907
00:55:30,650 --> 00:55:36,570
Так что это факториал (1), то сделано.

908
00:55:36,570 --> 00:55:41,190
Когда 1 возвращается, это факториал (1) возвращается, это возвращение к 1.

909
00:55:41,190 --> 00:55:46,910
Возвращаемым значением этого, помню, был NX возвращаемого значения этому.

910
00:55:46,910 --> 00:55:50,720
Так неожиданно, этот парень знает, что я хочу вернуть 2.

911
00:55:50,720 --> 00:55:55,910
>> Так что помните, вернуть значение это просто NX возвращаемого значения здесь.

912
00:55:55,910 --> 00:56:01,160
Так что теперь мы можем сказать, 3 х 2 и, наконец, здесь мы можем сказать,

913
00:56:01,160 --> 00:56:04,010
это просто будет 4 х 3 х 2.

914
00:56:04,010 --> 00:56:09,570
И как только это возвращается, мы спускаемся к одному внутри целого основной.

915
00:56:09,570 --> 00:56:15,460
Любые вопросы по рекурсии?

916
00:56:15,460 --> 00:56:17,090
Хорошо. Таким образом, есть больше времени на вопросы в конце,

917
00:56:17,090 --> 00:56:23,360
но теперь Джозеф покроет оставшиеся вопросы.

918
00:56:23,360 --> 00:56:25,590
>> [Джозеф Ong] Все в порядке. Так что теперь мы говорили о рекурсии,

919
00:56:25,590 --> 00:56:27,840
Давайте немного поговорим о том, что слияние сортировки.

920
00:56:27,840 --> 00:56:31,740
Слияние рода в основном другой способ сортировки списка чисел.

921
00:56:31,740 --> 00:56:36,430
И как это работает, с сортировки слиянием у вас есть список, и то, что мы делаем,

922
00:56:36,430 --> 00:56:39,120
мы говорим, давайте разделить это на 2 половинки.

923
00:56:39,120 --> 00:56:42,750
Мы сначала запустить сортировки слиянием снова на левой половине,

924
00:56:42,750 --> 00:56:45,040
Затем мы запустим сортировки слиянием на правой половине,

925
00:56:45,040 --> 00:56:50,240
и это дает нам сейчас 2 половинки, которые сортируются, и теперь мы собираемся объединить эти половинки вместе.

926
00:56:50,240 --> 00:56:55,010
Это немного трудно понять без примера, поэтому мы будем проходить через движения и посмотреть, что происходит.

927
00:56:55,010 --> 00:56:59,590
Таким образом, вы начинаете с этого списка, мы разделили его на 2 половинки.

928
00:56:59,590 --> 00:57:02,300
Мы проводим сортировки слиянием на левой половине первого.

929
00:57:02,300 --> 00:57:06,660
Так вот левую половину, и теперь мы пропустить их через этот список еще раз

930
00:57:06,660 --> 00:57:09,800
который передается в сортировки слиянием, а затем мы посмотрим, опять же,

931
00:57:09,800 --> 00:57:13,270
в левой части этого списка, и мы побежали сортировки слиянием на нем.

932
00:57:13,270 --> 00:57:15,880
Теперь мы перейдем к списку из 2 цифр,

933
00:57:15,880 --> 00:57:19,010
и теперь левая половина всего 1 элемент длинный, и мы не можем

934
00:57:19,010 --> 00:57:23,380
разделить список, в котором только 1 элемент в половину, так что мы просто скажем, раз у нас есть 50,

935
00:57:23,380 --> 00:57:26,400
который находится всего в 1 элемент, он уже отсортирован.

936
00:57:26,400 --> 00:57:29,860
>> Как только мы закончим с этим, мы видим, что мы можем

937
00:57:29,860 --> 00:57:32,230
перейти на правую половину этого списка,

938
00:57:32,230 --> 00:57:36,480
и 3 также сортируются, и поэтому сейчас, что обе половины этого списка сортируются

939
00:57:36,480 --> 00:57:39,080
мы можем объединить эти цифры вместе.

940
00:57:39,080 --> 00:57:45,320
Таким образом, мы смотрим на 50 и 3, 3 меньше, чем 50, поэтому он идет в первый и затем 50 приходит дюйма

941
00:57:45,320 --> 00:57:49,340
Теперь это будет сделано, мы вернемся к этому списку и сортировка это правая половина.

942
00:57:49,340 --> 00:57:52,440
42 является его собственный номер, так что это уже отсортированы.

943
00:57:52,440 --> 00:57:57,850
Итак, теперь мы сравним эти 2 и 3 меньше, чем 42, так что получает положить в первом,

944
00:57:57,850 --> 00:58:02,340
теперь 42 получает положить в, и 50 получает вставил

945
00:58:02,340 --> 00:58:07,220
Так вот, это упорядоченные, мы пройти весь путь наверх, 1337 и 15.

946
00:58:07,220 --> 00:58:14,560
Ну, мы сейчас посмотрим на левую половину этого списка; 1337 сама по себе так что он сортируется и то же самое с 15.

947
00:58:14,560 --> 00:58:19,020
Так что теперь мы объединим эти 2 номера для сортировки, что первоначальный список, 15 <1337,

948
00:58:19,020 --> 00:58:23,060
поэтому она идет в первый, то 1337 идет дюйма

949
00:58:23,060 --> 00:58:26,640
А теперь сортируются обе половинки исходного списка наверху.

950
00:58:26,640 --> 00:58:30,440
И все, что нам нужно сделать, это объединить эти.

951
00:58:30,440 --> 00:58:36,890
Мы смотрим на первые 2 номера из этого списка, 3 <15, поэтому она идет в сортировки массива в первую очередь.

952
00:58:36,890 --> 00:58:44,460
15 <42, поэтому она идет дюйма Теперь, 42 <1337, который идет дюйма

953
00:58:44,460 --> 00:58:51,010
50 <1337, поэтому она идет дюйма И заметил, что мы просто взяли 2 номера с этого списка.

954
00:58:51,010 --> 00:58:53,640
Таким образом, мы не только чередуя 2 списка.

955
00:58:53,640 --> 00:58:56,050
Мы просто глядя на начало, и мы берем элемент

956
00:58:56,050 --> 00:59:00,270
вот и меньше, а затем положить его в наш массив.

957
00:59:00,270 --> 00:59:04,080
Теперь мы объединились все половинки, и мы сделали.

958
00:59:04,080 --> 00:59:07,780
>> Любые вопросы о слиянии рода? Да?

959
00:59:07,780 --> 00:59:14,190
[Студент] Если это расщепление в различных группах, почему они не просто разделить его один раз

960
00:59:14,190 --> 00:59:19,970
и у вас есть 3 и 2 в группе? [Остальные вопросы неразборчиво]

961
00:59:19,970 --> 00:59:24,940
Причина - так что вопрос в том, почему мы не можем просто объединить их в тот первый шаг после того, как они у нас есть?

962
00:59:24,940 --> 00:59:29,530
Поэтому мы можем сделать это, начните с самого левого элементы с обеих сторон,

963
00:59:29,530 --> 00:59:33,040
, а затем взять поменьше и положил его в том, что мы знаем, что эти

964
00:59:33,040 --> 00:59:35,290
отдельные списки в отсортированном заказов.

965
00:59:35,290 --> 00:59:37,290
Так что, если я смотрю на самый левый элементы обеих половин,

966
00:59:37,290 --> 00:59:40,490
Я знаю, что они собираются быть мельчайших элементов из этих списков.

967
00:59:40,490 --> 00:59:43,930
Так что я могу положить их в местах наименьшего элемента этого большого списка.

968
00:59:43,930 --> 00:59:47,810
С другой стороны, если я смотрю на эти 2 списка второго уровня там,

969
00:59:47,810 --> 00:59:51,640
50, 3, 42, 1337 и 15, тем не сортируются.

970
00:59:51,640 --> 00:59:55,770
Так что, если я смотрю на 50 и 1337, я собираюсь поставить 50 в моем списке первым.

971
00:59:55,770 --> 01:00:00,130
Но это не имеет смысла, так как 3 наименьший элемент из всех из них.

972
01:00:00,130 --> 01:00:04,390
Таким образом, единственная причина, мы можем сделать это объединение шаг, потому что наши списки уже отсортированы.

973
01:00:04,390 --> 01:00:07,010
Именно поэтому мы должны спускаться на всем пути до дна

974
01:00:07,010 --> 01:00:09,800
потому что, когда у нас есть только одно число, вы знаете, что один номер

975
01:00:09,800 --> 01:00:14,120
само по себе уже является отсортированный список.

976
01:00:14,120 --> 01:00:19,360
>> Есть вопросы? Нет?

977
01:00:19,360 --> 01:00:24,260
Сложность? Ну, вы видите, что на каждом шагу есть конец числа,

978
01:00:24,260 --> 01:00:27,590
и мы можем разделить список журнала 1/2 п раз,

979
01:00:27,590 --> 01:00:31,700
где мы получим этот журнал п х п сложности.

980
01:00:31,700 --> 01:00:34,940
И вы увидите, в лучшем случае для сортировки слиянием п § п, и так уж случилось,

981
01:00:34,940 --> 01:00:39,340
, что в худшем случае, или Ω там, также п п войти.

982
01:00:39,340 --> 01:00:42,480
Нужно иметь в виду.

983
01:00:42,480 --> 01:00:45,750
Двигаемся дальше, давайте перейдем к некоторым супер основной файл I / O.

984
01:00:45,750 --> 01:00:48,830
Если вы посмотрите на Scramble, вы заметите, у нас была какая-то система

985
01:00:48,830 --> 01:00:51,270
где вы могли бы написать в лог-файл, если вы читаете по коду.

986
01:00:51,270 --> 01:00:53,730
Давайте посмотрим, как вы могли бы сделать это.

987
01:00:53,730 --> 01:00:57,450
Ну, у нас Fprintf, которые вы можете думать, как только Printf,

988
01:00:57,450 --> 01:01:01,720
но только печать в файл, а и, следовательно, F в самом начале.

989
01:01:01,720 --> 01:01:07,570
Такой код здесь, что он делает, как вы, возможно, видели в Scramble,

990
01:01:07,570 --> 01:01:12,310
она проходит через вашу 2-мерный массив из печати ряд за рядом, что числа.

991
01:01:12,310 --> 01:01:17,850
В этом случае Выводит на ваш терминал или что мы называем стандартный вывод разделе.

992
01:01:17,850 --> 01:01:22,170
>> И теперь, в этом случае, все, что мы должны сделать, это заменить Printf с Fprintf,

993
01:01:22,170 --> 01:01:26,770
сказать ему, что файл, который вы хотите печатать, и в этом случае он просто выводит ее на этот файл

994
01:01:26,770 --> 01:01:32,230
вместо того, чтобы печатать его на терминал.

995
01:01:32,230 --> 01:01:36,500
Ну, то, что напрашивается вопрос: Где же взять такого рода файлов из, верно?

996
01:01:36,500 --> 01:01:39,840
Мы прошли войти в эту Fprintf Fuction но мы понятия не имел, откуда оно взялось.

997
01:01:39,840 --> 01:01:43,980
Ну, в самом начале кода, то, что мы имели, был этот кусок кода сюда,

998
01:01:43,980 --> 01:01:48,340
, который в основном говорит, что открыть файл вызывает log.txt.

999
01:01:48,340 --> 01:01:53,220
Что мы делаем после этого, что мы должны убедиться, что файл на самом деле был успешно открыт.

1000
01:01:53,220 --> 01:01:57,070
Так что, возможно, не по нескольким причинам, вам не хватает места на вашем компьютере, например.

1001
01:01:57,070 --> 01:01:59,790
Таким образом, это всегда важно, прежде чем делать любые операции с файлами

1002
01:01:59,790 --> 01:02:03,300
что мы проверяем, что файл был открыт успешно.

1003
01:02:03,300 --> 01:02:09,330
Так что это, это аргумент Еореп, хорошо, мы можем открыть файл по-разному.

1004
01:02:09,330 --> 01:02:13,510
Что мы можем сделать, мы можем передать его вес, а значит изменить файл, если он выходит уже,

1005
01:02:13,510 --> 01:02:18,070
Мы можем передать, что они добавляем в конец файла, а не перекрывая его,

1006
01:02:18,070 --> 01:02:22,730
или мы можем указать R, что означает, давайте открыть файл только для чтения.

1007
01:02:22,730 --> 01:02:24,890
Таким образом, если программа пытается внести изменения в файл,

1008
01:02:24,890 --> 01:02:30,140
кричать на них и не позволяют им это сделать.

1009
01:02:30,140 --> 01:02:33,320
Наконец, когда мы закончили с файлом, сделал делают операции на ней,

1010
01:02:33,320 --> 01:02:35,860
Мы должны убедиться, что мы закрываем файл.

1011
01:02:35,860 --> 01:02:38,830
И вот в конце вашей программы, вы собираетесь передать их снова

1012
01:02:38,830 --> 01:02:42,120
это файл, который вы открыли, и просто закрыть его.

1013
01:02:42,120 --> 01:02:44,650
Так что это что-то важное, что вы должны убедиться, что вы делаете.

1014
01:02:44,650 --> 01:02:47,180
Так что помните, что вы можете открыть файл, то вы можете записать в файл,

1015
01:02:47,180 --> 01:02:51,270
делать операции в файле, но тогда вы должны закрыть файл в конце.

1016
01:02:51,270 --> 01:02:53,270
>> Любые вопросы по основным файла I / O? Да?

1017
01:02:53,270 --> 01:02:58,050
[Студент вопрос, неразборчиво]

1018
01:02:58,050 --> 01:03:02,480
Прямо здесь. Вопрос в том, где же этот файл log.txt появляются?

1019
01:03:02,480 --> 01:03:07,890
Ну, если вы просто дать ему log.txt, он создает его в том же каталоге, что и исполняемый файл.

1020
01:03:07,890 --> 01:03:10,500
Так что, если вы - >> [Студенческий вопрос, неразборчиво]

1021
01:03:10,500 --> 01:03:18,830
Да. В той же папке, или в том же каталоге, как вы это называете.

1022
01:03:18,830 --> 01:03:21,400
Теперь память, стек и кучу.

1023
01:03:21,400 --> 01:03:23,400
Так, как это память, изложенных в компьютере?

1024
01:03:23,400 --> 01:03:26,270
Ну, вы можете себе память как своего рода этом блоке здесь.

1025
01:03:26,270 --> 01:03:30,260
И в памяти у нас есть то, что называется кучей застряли там, и стек, что там внизу.

1026
01:03:30,260 --> 01:03:34,480
И куча растет вниз, а стек растет вверх.

1027
01:03:34,480 --> 01:03:38,620
Так как Томми упоминал, - о, хорошо, и у нас есть эти другие 4 сегментов, которые я получу в секунду -

1028
01:03:38,620 --> 01:03:42,890
Как сказал Томми раньше, вы знаете, как его называют себя функции и называют друг друга?

1029
01:03:42,890 --> 01:03:44,930
Они создают такого рода кадра стека.

1030
01:03:44,930 --> 01:03:47,360
Ну, если основные вызовы Фу, Фу получает положить в стек.

1031
01:03:47,360 --> 01:03:52,430
Foo называет, бар получите поставим в стек, и что получает положить в стек после.

1032
01:03:52,430 --> 01:03:57,040
И когда они вернутся, каждая из них получают снять стек.

1033
01:03:57,040 --> 01:04:00,140
Что каждый из этих мест и память держать?

1034
01:04:00,140 --> 01:04:03,110
Ну, верхний, который является сегмент текста, содержит саму программу.

1035
01:04:03,110 --> 01:04:06,390
Таким образом, машинный код, что там, как только вы скомпилировать программу.

1036
01:04:06,390 --> 01:04:08,520
Далее, любая инициализируются глобальные переменные.

1037
01:04:08,520 --> 01:04:12,660
>> Таким образом, у Вас есть глобальные переменные в вашей программе, а вы говорите, как, = 5,

1038
01:04:12,660 --> 01:04:15,260
, который получает положить в этом сегменте, и прямо под этим,

1039
01:04:15,260 --> 01:04:18,990
у вас есть какие-то неинициализированные глобальные данные, которые просто INT,

1040
01:04:18,990 --> 01:04:20,990
но вы не говорю, что это равно ничего.

1041
01:04:20,990 --> 01:04:23,870
Поймите, это глобальные переменные, так что они за пределами основного.

1042
01:04:23,870 --> 01:04:28,560
Таким образом, это означает, что любые глобальные переменные, которые объявлены, но не инициализируются.

1043
01:04:28,560 --> 01:04:32,310
Так что в куче? Память распределяется с помощью таНос, который мы получим в немного.

1044
01:04:32,310 --> 01:04:35,990
И, наконец, со стеком у вас есть какие-то локальные переменные

1045
01:04:35,990 --> 01:04:39,950
и любой функции можно вызвать в любой из их параметров.

1046
01:04:39,950 --> 01:04:43,720
Последняя вещь, вы действительно не должны знать, что переменные окружения делать,

1047
01:04:43,720 --> 01:04:46,700
но всякий раз, когда вы запускаете программу, есть что-то связано, как

1048
01:04:46,700 --> 01:04:49,550
это имя пользователя, который запустил программу.

1049
01:04:49,550 --> 01:04:51,550
И это будет как бы на дне.

1050
01:04:51,550 --> 01:04:54,540
С точки зрения адреса памяти, которые являются шестнадцатеричные значения,

1051
01:04:54,540 --> 01:04:58,170
Значения в верхней начинаются с 0, и пройти весь путь до дна.

1052
01:04:58,170 --> 01:05:00,440
В этом случае, если вы находитесь на 32-битной системе,

1053
01:05:00,440 --> 01:05:05,390
адресу, указанному внизу будет 0x, а затем А.Ф., потому что это 32 бит,

1054
01:05:05,390 --> 01:05:10,890
, что на 8 байт, и в этом случае 8 байт соответствует 8 шестнадцатеричных цифр.

1055
01:05:10,890 --> 01:05:20,110
Так что здесь вы будете иметь, вроде бы, 0xffffff, и там вы будете иметь 0.

1056
01:05:20,110 --> 01:05:23,660
Так что указатели? Некоторые из вас, возможно, не покрытые этим в разделе ранее.

1057
01:05:23,660 --> 01:05:26,660
но мы не вдаваться в лекции, поэтому указатель просто тип данных

1058
01:05:26,660 --> 01:05:34,030
которые магазинах, а не какое-то значение, например 50, она сохраняет адрес определенное место в памяти.

1059
01:05:34,030 --> 01:05:36,020
Как и что память [неразборчиво].

1060
01:05:36,020 --> 01:05:41,120
Таким образом, в данном случае, то, что мы есть, мы имеем указатель на целое или целое число *,

1061
01:05:41,120 --> 01:05:46,210
и содержит этом шестнадцатеричный адрес 0xDEADBEEF.

1062
01:05:46,210 --> 01:05:50,880
>> Итак, что мы имеем сейчас, этот указатель указывает на определенное место в памяти,

1063
01:05:50,880 --> 01:05:56,020
и это только, значение 50 в это расположение в памяти.

1064
01:05:56,020 --> 01:06:01,810
На некоторых 32-битных системах, на всех 32-битных систем, указатели занимают 32 бита или 4 байта.

1065
01:06:01,810 --> 01:06:06,020
Но, например, на 64-битной системе, указатели являются 64-битными.

1066
01:06:06,020 --> 01:06:08,040
Так что то, что вы хотите, чтобы держать в уме.

1067
01:06:08,040 --> 01:06:12,310
Таким образом, на конец-битной системы, указатель конца бит.

1068
01:06:12,310 --> 01:06:17,320
Указатели являются своего рода трудно переварить без дополнительных вещей,

1069
01:06:17,320 --> 01:06:20,300
так давайте пройдем пример динамического распределения памяти.

1070
01:06:20,300 --> 01:06:25,130
Что динамического распределения памяти делает для вас, или то, что мы называем таНос,

1071
01:06:25,130 --> 01:06:29,280
она позволяет выделить какой-то данных за пределами съемочной площадке.

1072
01:06:29,280 --> 01:06:31,830
Таким образом, эти данные является своего рода более постоянным в течение всего срока программы.

1073
01:06:31,830 --> 01:06:36,430
Потому что, как вы знаете, если вы объявите х внутри функции, а функция возвращает значение,

1074
01:06:36,430 --> 01:06:40,910
Вам больше не имеют доступа к данным, которые хранятся в х.

1075
01:06:40,910 --> 01:06:44,420
Что указатели будем делать, они позволяют нам хранить память или хранят значения

1076
01:06:44,420 --> 01:06:46,840
в другой сегмент памяти, а именно в кучу.

1077
01:06:46,840 --> 01:06:49,340
Теперь, когда мы вернемся из функций тех пор, пока у нас есть указатель

1078
01:06:49,340 --> 01:06:54,960
в то же место в памяти, то, что мы можем сделать, мы можем просто смотреть на значения там.

1079
01:06:54,960 --> 01:06:58,020
Давайте посмотрим на примере: Это наша память макет снова.

1080
01:06:58,020 --> 01:07:00,050
И у нас есть эта функция, основной.

1081
01:07:00,050 --> 01:07:06,870
Что она делает это - хорошо, так просто, правда? - Int х = 5, вот только на стеке в главном.

1082
01:07:06,870 --> 01:07:12,450
>> С другой стороны, теперь мы объявляем указатель, который вызывает функцию giveMeThreeInts.

1083
01:07:12,450 --> 01:07:16,800
И вот теперь мы идем в эту функцию, и мы создаем новый кадр стека для него.

1084
01:07:16,800 --> 01:07:20,440
Однако, в этом кадре стека, мы заявляем Int * температура,

1085
01:07:20,440 --> 01:07:23,210
который в mallocs 3 целых для нас.

1086
01:07:23,210 --> 01:07:25,880
Таким образом, размер Int даст нам сколько байт этом Int есть,

1087
01:07:25,880 --> 01:07:29,620
и таНос дает нам, что многие байт пространства в куче.

1088
01:07:29,620 --> 01:07:32,890
Таким образом, в этом случае, мы создали достаточно места для 3 числа,

1089
01:07:32,890 --> 01:07:36,830
и куча путь там, поэтому я нарисовал ее выше.

1090
01:07:36,830 --> 01:07:42,900
Как только мы закончим, мы вернемся сюда, вам нужно всего лишь 3 целыми вернулись,

1091
01:07:42,900 --> 01:07:47,000
и она возвращает адрес, в данном случае над тем, где эта память.

1092
01:07:47,000 --> 01:07:51,250
И мы поставили указатель = выключатель, и там у нас есть еще один указатель.

1093
01:07:51,250 --> 01:07:54,550
Но то, что эта функция возвращает укладывается здесь и исчезает.

1094
01:07:54,550 --> 01:07:59,250
Таким образом, темп исчезает, но мы по-прежнему поддерживают адреса, где

1095
01:07:59,250 --> 01:08:01,850
эти 3 числа находятся внутри сети.

1096
01:08:01,850 --> 01:08:06,180
Таким образом, в этом наборе, указатели областью на местном уровне для сложенных кадров,

1097
01:08:06,180 --> 01:08:09,860
но память к которым они относятся в кучу.

1098
01:08:09,860 --> 01:08:12,190
>> Имеет ли это смысл?

1099
01:08:12,190 --> 01:08:14,960
[Студент] Не могли бы вы повторить? >> [Иосиф] Да.

1100
01:08:14,960 --> 01:08:20,270
Так что, если я вернусь чуть-чуть, вы видите, что температура выделено

1101
01:08:20,270 --> 01:08:23,500
некоторый объем памяти в куче там.

1102
01:08:23,500 --> 01:08:28,680
Поэтому, когда эта функция, giveMeThreeInts возвращается, этот стек здесь собирается исчезать.

1103
01:08:28,680 --> 01:08:35,819
А вместе с ней любой из переменных, в данном случае, это указатель, который был выделен в стек кадра.

1104
01:08:35,819 --> 01:08:39,649
То есть исчезнет, ​​но так как мы вернулись температура

1105
01:08:39,649 --> 01:08:46,330
и мы указателя = температура, указатель теперь будет указывать ту же самую память о месте, темп был.

1106
01:08:46,330 --> 01:08:50,370
Так что теперь, даже если мы потеряем темп, что местные указатель,

1107
01:08:50,370 --> 01:08:59,109
Мы по-прежнему сохраняют адрес памяти, что он был направлен внутрь этой переменной указатель.

1108
01:08:59,109 --> 01:09:03,740
Вопросы? Это может быть даже запутанной темы, если вы не перешли его в разделе.

1109
01:09:03,740 --> 01:09:09,240
Мы можем, ваш TF определенно пойдет на это и, конечно, мы можем ответить на вопросы

1110
01:09:09,240 --> 01:09:11,500
В конце сессии по обзору для этого.

1111
01:09:11,500 --> 01:09:14,220
Но это своего рода сложный вопрос, и у меня есть другие примеры, которые собираются, чтобы показать

1112
01:09:14,220 --> 01:09:18,790
, которая поможет прояснить, что указатели на самом деле.

1113
01:09:18,790 --> 01:09:22,500
>> В этом случае, указателей эквивалентно массивов,

1114
01:09:22,500 --> 01:09:25,229
так что я могу просто использовать этот указатель, как то же самое, Int массива.

1115
01:09:25,229 --> 01:09:29,840
Так что я индексации в 0, и изменение первое число 1,

1116
01:09:29,840 --> 01:09:39,689
изменение второго числа 2, и 3-й целое число 3.

1117
01:09:39,689 --> 01:09:44,210
Так что больше на указатели. Ну, вспомните Бинки.

1118
01:09:44,210 --> 01:09:48,319
В этом случае мы выделили указатель, или мы объявили указатель,

1119
01:09:48,319 --> 01:09:52,760
но вначале, когда я только что объявили указатель, это не указывает на любой памяти.

1120
01:09:52,760 --> 01:09:54,930
Это просто мусор значения внутри него.

1121
01:09:54,930 --> 01:09:56,470
Так что я понятия не имею, где этот указатель указывает.

1122
01:09:56,470 --> 01:10:01,630
Он имеет адрес, который просто наполнен 0 и 1, где он был изначально объявлен.

1123
01:10:01,630 --> 01:10:04,810
Я ничего не могу сделать с этим, пока я называю таНос на нее

1124
01:10:04,810 --> 01:10:08,390
и это дает мне мало места в куче, где я могу поставить значения внутри.

1125
01:10:08,390 --> 01:10:11,980
Опять же, я не знаю, что внутри этой памяти.

1126
01:10:11,980 --> 01:10:16,780
Поэтому первое, что я должен сделать, это проверить, является ли система имела достаточно памяти

1127
01:10:16,780 --> 01:10:20,850
, чтобы дать мне назад 1 целое, в первую очередь, поэтому я делаю это проверить.

1128
01:10:20,850 --> 01:10:25,020
Если указатель пуст, это означает, что у него не было достаточно места, или другие ошибки,

1129
01:10:25,020 --> 01:10:26,320
так что я должен выйти из моей программы.

1130
01:10:26,320 --> 01:10:29,400
 Но если это и не удалось, теперь я могу использовать этот указатель

1131
01:10:29,400 --> 01:10:35,020
и то, что * указатель делает это следующим где адрес

1132
01:10:35,020 --> 01:10:38,480
где это значение, и это отличает его равным 1.

1133
01:10:38,480 --> 01:10:41,850
Так что здесь, мы проверяем, если что память существует.

1134
01:10:41,850 --> 01:10:45,380
>> Когда вы знаете, она существует, вы можете поместить в нее

1135
01:10:45,380 --> 01:10:50,460
Какое значение вы хотите вложить в нее, в этом случае 1.

1136
01:10:50,460 --> 01:10:53,060
Как только мы покончим с этим, необходимо, чтобы освободить этот указатель

1137
01:10:53,060 --> 01:10:57,160
потому что мы должны вернуться к системе, памяти, которые вы просили в первую очередь.

1138
01:10:57,160 --> 01:10:59,690
Поскольку компьютер не знает, когда мы покончим с этим.

1139
01:10:59,690 --> 01:11:02,510
В этом случае мы явно говорит он, хорошо, мы закончили с этой памятью.

1140
01:11:02,510 --> 01:11:10,780
Если некоторые другие процессы в ней нуждается, некоторые другие программы в ней нуждается, не стесняйтесь идти вперед и принимать его.

1141
01:11:10,780 --> 01:11:15,110
Что мы можем сделать, это мы можем просто получить адрес локальных переменных на съемочной площадке.

1142
01:11:15,110 --> 01:11:19,080
Так Int х находится внутри сложены рамках основной.

1143
01:11:19,080 --> 01:11:23,060
И когда мы используем этот символ, это и оператора, что она делает это

1144
01:11:23,060 --> 01:11:27,310
он принимает х, и х лишь некоторые данные в памяти, но у него есть адрес.

1145
01:11:27,310 --> 01:11:33,790
Она находится где-то. Так, позвонив по телефону и х, то, что это делает он дает нам по адресу х.

1146
01:11:33,790 --> 01:11:38,430
Делая это, мы делаем указатель точки, где х находится в памяти.

1147
01:11:38,430 --> 01:11:41,710
Теперь мы просто сделать что-то вроде * х, мы собираемся, чтобы получить 5 назад.

1148
01:11:41,710 --> 01:11:43,820
Звезда называется разыменования его.

1149
01:11:43,820 --> 01:11:46,640
Вы следуете адрес, и вы получите значение она хранится там.

1150
01:11:51,000 --> 01:11:53,310
>> Есть вопросы? Да?

1151
01:11:53,310 --> 01:11:56,500
[Студент] Если вы этого не сделаете 3-заостренные вещь, это все еще скомпилировать?

1152
01:11:56,500 --> 01:11:59,490
Да. Если вы этого не сделаете 3-указатель вещь, она по-прежнему будет составлять,

1153
01:11:59,490 --> 01:12:02,720
Но я покажу вам, что происходит в секунду, а без этого,

1154
01:12:02,720 --> 01:12:04,860
это то, что мы называем утечкой памяти. Вы не даете системе

1155
01:12:04,860 --> 01:12:07,850
Резервное его памяти, так что через некоторое время программа будет накапливаться

1156
01:12:07,850 --> 01:12:10,940
память, что она не используется, и ничто другое не может его использовать.

1157
01:12:10,940 --> 01:12:15,750
Если вы когда-либо видели Firefox с 1,5 миллиона килобайт на вашем компьютере,

1158
01:12:15,750 --> 01:12:17,840
в диспетчере задач, вот что происходит.

1159
01:12:17,840 --> 01:12:20,760
У вас есть утечки памяти в программе, что они не обрабатывает.

1160
01:12:23,080 --> 01:12:26,240
Так как же арифметика указателей работы?

1161
01:12:26,240 --> 01:12:29,480
Ну, арифметика указателей вроде как индексация в массиве.

1162
01:12:29,480 --> 01:12:36,370
В этом случае, у меня есть указатель, и то, что я делаю, я делаю указатель указывает на первый элемент

1163
01:12:36,370 --> 01:12:42,100
этого массив из 3 целых чисел, которые я выделил.

1164
01:12:42,100 --> 01:12:46,670
Так что теперь мне делать, звезда просто меняет указатель на первый элемент в списке.

1165
01:12:46,670 --> 01:12:49,140
Звезда указатель +1 очков здесь.

1166
01:12:49,140 --> 01:12:53,140
Таким образом, указатель мыши здесь, +1 является указателем здесь, указатель +2 является здесь.

1167
01:12:53,140 --> 01:12:56,610
>> Так что добавление 1, то же самое, двигаясь по этому массиву.

1168
01:12:56,610 --> 01:12:59,880
Что мы делаем, когда мы делаем указатель +1 Вы получите адрес здесь,

1169
01:12:59,880 --> 01:13:04,180
и для того, чтобы получить значение здесь, вы положили звезду в от всего выражения

1170
01:13:04,180 --> 01:13:05,990
Обращаться к ним.

1171
01:13:05,990 --> 01:13:09,940
Таким образом, в данном случае, я устанавливаю первое место в этом массиве в 1,

1172
01:13:09,940 --> 01:13:13,970
Второе место 2, а третье место на 3.

1173
01:13:13,970 --> 01:13:18,180
Затем, что я делаю здесь есть я печатаю наш указатель +1,

1174
01:13:18,180 --> 01:13:19,970
который просто дает мне 2.

1175
01:13:19,970 --> 01:13:23,650
Теперь я увеличивая указатель, поэтому указатель равно указатель +1,

1176
01:13:23,650 --> 01:13:26,780
, которая движется вперед.

1177
01:13:26,780 --> 01:13:30,810
И вот теперь, если я распечатать указатель +1, указатель +1 теперь 3,

1178
01:13:30,810 --> 01:13:33,990
который в данном случае выводит 3.

1179
01:13:33,990 --> 01:13:36,560
И для того, чтобы что-то бесплатно, указатель, который я даю ему

1180
01:13:36,560 --> 01:13:40,540
должны быть направлены на начало массива, который я вернулся из таНос.

1181
01:13:40,540 --> 01:13:43,430
Таким образом, в данном случае, если бы я был звонить 3 прямо здесь, это было бы неправильно,

1182
01:13:43,430 --> 01:13:45,070
потому что это в середине массива.

1183
01:13:45,070 --> 01:13:48,820
Я должен вычесть, чтобы получить на прежнем месте

1184
01:13:48,820 --> 01:13:50,420
начальная первом месте прежде чем я смогу освободить его.

1185
01:13:56,300 --> 01:13:58,450
Итак, вот более сложный пример.

1186
01:13:58,450 --> 01:14:03,360
В этом случае, мы выделении 7 символов в массив символов.

1187
01:14:03,360 --> 01:14:06,480
>> И в этом случае то, что мы делаем, мы циклов в течение первых 6 из них,

1188
01:14:06,480 --> 01:14:09,900
и мы устанавливаем их в Z.

1189
01:14:09,900 --> 01:14:13,350
Таким образом, для Int я = 0, г> 6, я + +,

1190
01:14:13,350 --> 01:14:16,220
Таким образом, указатель + Я просто дать нам, в данном случае,

1191
01:14:16,220 --> 01:14:20,860
указатель, указатель +1, +2 указатель, указатель +3, и так далее, и так далее в цикле.

1192
01:14:20,860 --> 01:14:24,040
Что он собирается делать это получает, что адрес, разыменовывает его, чтобы получить значение,

1193
01:14:24,040 --> 01:14:27,440
и изменения, значение Z.

1194
01:14:27,440 --> 01:14:30,350
Затем, в конце помните, что это строка, не так ли?

1195
01:14:30,350 --> 01:14:33,560
Все строки должны закончить с нулевой символ завершения.

1196
01:14:33,560 --> 01:14:38,620
Итак, что я делаю, это указатель в 6 я поставил пустой символ конца дюйма

1197
01:14:38,620 --> 01:14:43,980
А теперь то, что я в основном делаю здесь реализуется Printf для строки, не так ли?

1198
01:14:43,980 --> 01:14:46,190
>> Итак, когда же Printf теперь, когда она достигла конца строки?

1199
01:14:46,190 --> 01:14:48,230
Когда она снизится до нулевой символ завершения.

1200
01:14:48,230 --> 01:14:52,030
Таким образом, в данном случае, мои исходные точки, указатель на начало этого массива.

1201
01:14:52,030 --> 01:14:56,410
Я напечатать первый символ из. Я переместить его на один.

1202
01:14:56,410 --> 01:14:58,420
Я печатаю этот символ из. Я двигаюсь его.

1203
01:14:58,420 --> 01:15:02,180
И я продолжаю делать это, пока я дойти до конца.

1204
01:15:02,180 --> 01:15:07,750
А теперь указатель конца * будет разыменовать и получить нулевой завершающий символ назад.

1205
01:15:07,750 --> 01:15:11,780
И поэтому моя в то время как цикл выполняется только тогда, когда это значение не является нулевой символ завершения.

1206
01:15:11,780 --> 01:15:13,770
Итак, теперь я выйти из этой петли.

1207
01:15:18,780 --> 01:15:21,180
И поэтому, если я вычесть 6 из этого указателя,

1208
01:15:21,180 --> 01:15:22,860
Я возвращаюсь весь путь с самого начала.

1209
01:15:22,860 --> 01:15:27,880
Помните, я делаю это потому, что я должен пойти к началу, чтобы освободить его.

1210
01:15:27,880 --> 01:15:30,270
>> Так вот, я знаю, что было много. Есть ли вопросы?

1211
01:15:30,270 --> 01:15:31,870
Пожалуйста, да?

1212
01:15:31,870 --> 01:15:36,610
[Студент вопрос неразборчиво]

1213
01:15:36,610 --> 01:15:38,190
Можете ли вы сказать, что громче? Извините.

1214
01:15:38,190 --> 01:15:44,140
[Студент] На последнем слайде право, прежде чем освободить указатель,

1215
01:15:44,140 --> 01:15:47,300
где вы были на самом деле изменить значение указателя?

1216
01:15:47,300 --> 01:15:50,370
[Джозеф] Так, прямо здесь. >> [Студент] О, все в порядке.

1217
01:15:50,370 --> 01:15:51,890
[Джозеф] Итак, у меня есть указатель минус минус, право,

1218
01:15:51,890 --> 01:15:54,140
который перемещает вещи обратно на один, а потом освободить его,

1219
01:15:54,140 --> 01:15:57,000
потому что этот указатель должен быть указала на начало массива.

1220
01:15:57,000 --> 01:16:00,420
[Студент] Но это был бы не нужен, если бы вы остановились после этой строки.

1221
01:16:00,420 --> 01:16:03,130
[Джозеф] Так что, если я остановился после этого, это будет рассматриваться как утечка памяти,

1222
01:16:03,130 --> 01:16:04,810
потому что я не запустить бесплатный.

1223
01:16:04,810 --> 01:16:11,290
[Студент] Я [неразборчиво] после первых трех линиях, где вы были указателя +1 [неразборчиво].

1224
01:16:11,290 --> 01:16:13,140
[Джозеф] Угу. Так, что вопрос там?

1225
01:16:13,140 --> 01:16:14,780
Извините. Нет, нет. Иди, иди, пожалуйста.

1226
01:16:14,780 --> 01:16:16,870
[Студент] Таким образом, вы не изменив значение указателей.

1227
01:16:16,870 --> 01:16:19,130
Вы не должны были бы сделать указатель минус минус.

1228
01:16:19,130 --> 01:16:19,730
[Джозеф] Да, именно так.

1229
01:16:19,730 --> 01:16:21,890
Так что, когда я делаю указатель и указатель +1 +2,

1230
01:16:21,890 --> 01:16:24,410
Я не делаю указателя равно указатель +1.

1231
01:16:24,410 --> 01:16:27,260
Таким образом, указатель остается только указывает на начало массива.

1232
01:16:27,260 --> 01:16:31,460
И только когда я делаю плюс плюс, что он устанавливает значение обратно в указатель,

1233
01:16:31,460 --> 01:16:33,550
что он фактически движется вдоль этого.

1234
01:16:36,860 --> 01:16:37,780
Хорошо.

1235
01:16:40,550 --> 01:16:42,030
Еще вопросы?

1236
01:16:44,680 --> 01:16:47,790
>> Опять же, если это является своего рода подавляющим, это будут рассмотрены на сессии.

1237
01:16:47,790 --> 01:16:50,710
Попросите вашего обучения коллег об этом, и мы можем ответить на вопросы в конце.

1238
01:16:53,510 --> 01:16:56,600
И обычно мы не хотели делать это минус вещь.

1239
01:16:56,600 --> 01:16:59,760
Это должно требуют от меня отслеживать, насколько я Смещение в массиве.

1240
01:16:59,760 --> 01:17:04,520
Так, в общем, это просто объяснить, как работает арифметика указателей.

1241
01:17:04,520 --> 01:17:07,970
Но то, что мы обычно нравится делать, мы хотели бы создать копию указателя,

1242
01:17:07,970 --> 01:17:11,640
и тогда мы будем использовать эту копию, когда мы движемся вокруг в строку.

1243
01:17:11,640 --> 01:17:14,660
Таким образом, в этих случае если вы используете копии напечатать всю строку,

1244
01:17:14,660 --> 01:17:19,040
но мы не должны делать, как указатель минус 6 или отслеживать, сколько мы переехали в это,

1245
01:17:19,040 --> 01:17:22,700
только потому, что мы знаем, что наша исходная точка по-прежнему указывает на начало списка

1246
01:17:22,700 --> 01:17:25,340
и все, что мы изменили эта копия.

1247
01:17:25,340 --> 01:17:28,250
Так, в общем, изменять копии оригинальных указатель.

1248
01:17:28,250 --> 01:17:32,350
Не пытайтесь что-то вроде - don't изменить экземплярах.

1249
01:17:32,350 --> 01:17:35,290
Попытка изменить только копии оригинала.

1250
01:17:41,540 --> 01:17:44,870
Таким образом, вы заметите, когда мы передаем строку в Printf

1251
01:17:44,870 --> 01:17:48,990
Вы не должны поместить звезду перед ним, как мы делали со всеми другими разыменовывает, верно?

1252
01:17:48,990 --> 01:17:54,180
Так что, если вы печатаете из всей строки с% ожидает, что это адрес,

1253
01:17:54,180 --> 01:17:57,610
и в этом случае указатель или в данном случае, как массив символов.

1254
01:17:57,610 --> 01:18:00,330
>> Персонажи, символ * с, и массивы одно и то же.

1255
01:18:00,330 --> 01:18:03,690
Указатель состоит в символы и символьные массивы одно и то же.

1256
01:18:03,690 --> 01:18:05,720
А так, все, что мы должны сделать, это передать в указатель.

1257
01:18:05,720 --> 01:18:08,150
Мы не должны проходить в как указатель * или что-нибудь подобное.

1258
01:18:13,110 --> 01:18:14,930
Таким образом, массивы и указатели одно и то же.

1259
01:18:14,930 --> 01:18:19,160
Когда вы делаете что-то вроде X [Y] здесь для массива,

1260
01:18:19,160 --> 01:18:21,960
что он делает под капотом это говорит, хорошо, что это массив символов,

1261
01:18:21,960 --> 01:18:23,690
так что это указатель.

1262
01:18:23,690 --> 01:18:26,510
И поэтому х одно и то же,

1263
01:18:26,510 --> 01:18:28,650
и так, что он делает это добавляет г х,

1264
01:18:28,650 --> 01:18:31,820
что то же самое, что двигаться вперед в памяти, что много.

1265
01:18:31,820 --> 01:18:34,930
А теперь х + у дает нам какой-то адрес,

1266
01:18:34,930 --> 01:18:37,570
и мы разыменовать адрес или следить за стрелками

1267
01:18:37,570 --> 01:18:41,640
где это место в памяти, и мы получим значение из этого места в памяти.

1268
01:18:41,640 --> 01:18:43,720
Таким образом, так что эти две точно такие же вещи.

1269
01:18:43,720 --> 01:18:45,840
Это просто синтаксический сахар.

1270
01:18:45,840 --> 01:18:48,090
Они делают то же самое. Они просто разные синтактика друг для друга.

1271
01:18:51,500 --> 01:18:57,590
>> Итак, что может пойти не так с указателями? Мол, много. Хорошо. Так, плохие вещи.

1272
01:18:57,590 --> 01:19:02,410
Некоторые плохие вещи, которые вы можете сделать, не проверяя, если ваш таНос вызов возвращает нуль, верно?

1273
01:19:02,410 --> 01:19:06,560
В этом случае, я прошу системы, чтобы дать мне - что это за номер?

1274
01:19:06,560 --> 01:19:11,200
Мне нравится 2 миллиарда раз 4, так как размер целое 4 байта.

1275
01:19:11,200 --> 01:19:13,810
Я спрашиваю его для как 8 миллиардов байт.

1276
01:19:13,810 --> 01:19:17,270
Конечно, мой компьютер не будет в состоянии дать мне, что столько же обратно памяти.

1277
01:19:17,270 --> 01:19:20,960
И мы не проверить, если это нуль, поэтому, когда мы пытаемся разыменования его там -

1278
01:19:20,960 --> 01:19:24,270
следить за стрелками, где она собирается - у нас нет этой памяти.

1279
01:19:24,270 --> 01:19:27,150
Это то, что мы называем разыменования нулевого указателя.

1280
01:19:27,150 --> 01:19:29,710
А это существенно заставляет Вас падать.

1281
01:19:29,710 --> 01:19:31,790
Это один из способов сегментации.

1282
01:19:34,090 --> 01:19:38,090
Другие плохие вещи, которые вы можете сделать - да ладно.

1283
01:19:38,090 --> 01:19:40,650
Это было разыменования нулевого указателя. Хорошо.

1284
01:19:40,650 --> 01:19:45,160
Другие плохих вещей - ну, чтобы исправить, что вы просто поставьте галочку там

1285
01:19:45,160 --> 01:19:46,980
, которая проверяет, является ли указатель является нулевым

1286
01:19:46,980 --> 01:19:51,000
и выйти из программы, если она случается, что таНос возвращает нулевой указатель.

1287
01:19:55,110 --> 01:19:59,850
Это XKCD комиксов. Люди понимают это сейчас. Вроде того.

1288
01:20:06,120 --> 01:20:09,350
>> Таким образом, память. И я пошел по этому поводу.

1289
01:20:09,350 --> 01:20:12,000
Мы призываем таНос в цикле, но каждый раз, когда мы называем таНос

1290
01:20:12,000 --> 01:20:14,370
мы теряем отслеживать, где этот указатель указывает на,

1291
01:20:14,370 --> 01:20:15,750
потому что мы удалив его.

1292
01:20:15,750 --> 01:20:18,410
Таким образом, первоначальный вызов таНос дает мне памяти здесь.

1293
01:20:18,410 --> 01:20:19,990
Моя указатель указатели на это.

1294
01:20:19,990 --> 01:20:23,020
Теперь, я не освободить его, так что теперь я называю таНос снова.

1295
01:20:23,020 --> 01:20:26,070
Теперь он указывает здесь. Сейчас в моей памяти указывает здесь.

1296
01:20:26,070 --> 01:20:27,640
Указывая здесь. Указывая здесь.

1297
01:20:27,640 --> 01:20:31,820
Но я потерял все адреса памяти здесь, что я выделил.

1298
01:20:31,820 --> 01:20:35,100
И вот теперь у меня нет никаких ссылок на них больше.

1299
01:20:35,100 --> 01:20:37,230
Таким образом, я не могу освободить их за пределами этого цикла.

1300
01:20:37,230 --> 01:20:39,390
И поэтому для того, чтобы исправить что-то вроде этого,

1301
01:20:39,390 --> 01:20:42,250
если вы забыли, чтобы освободить память, и вы получите эту утечку памяти,

1302
01:20:42,250 --> 01:20:45,810
Вы должны освободить память, внутри этой петли, как только вы сделали с ним.

1303
01:20:45,810 --> 01:20:51,400
Ну, это то, что происходит. Я знаю, многие из вас ненавижу это.

1304
01:20:51,400 --> 01:20:55,270
Но теперь - ура! Вы получаете как 44000 килобайт.

1305
01:20:55,270 --> 01:20:57,110
Таким образом, вы освободите его в конце цикла,

1306
01:20:57,110 --> 01:20:59,770
и что собирается просто освободить память каждый раз.

1307
01:20:59,770 --> 01:21:03,620
По сути, ваша программа не имеет утечки памяти больше.

1308
01:21:03,620 --> 01:21:08,150
>> А теперь что-то еще, что вы можете сделать, это освободить часть памяти, что вы просили в два раза.

1309
01:21:08,150 --> 01:21:11,060
В этом случае, вы таНос что-то, вы измените его значение.

1310
01:21:11,060 --> 01:21:13,140
Вы освободить его сразу, потому что вы говорили, что сделали с ним.

1311
01:21:13,140 --> 01:21:14,940
Но тогда мы освободили его снова.

1312
01:21:14,940 --> 01:21:16,730
Это то, что очень плохо.

1313
01:21:16,730 --> 01:21:18,820
Он не собирался изначально сегментации,

1314
01:21:18,820 --> 01:21:23,350
но через некоторое время, что это будет двойное освобождение этой портит вашу кучу структуры,

1315
01:21:23,350 --> 01:21:27,200
и вы узнаете немного больше об этом, если вы решили взять класс, как CS61.

1316
01:21:27,200 --> 01:21:30,000
Но по существу, через некоторое время ваш компьютер будет запутаться

1317
01:21:30,000 --> 01:21:33,010
о том, что ячейки памяти, куда и где он хранится -

1318
01:21:33,010 --> 01:21:34,800
где данные хранятся в памяти.

1319
01:21:34,800 --> 01:21:38,080
И поэтому освобождение указателя дважды это плохо, что вы не хотите делать.

1320
01:21:38,080 --> 01:21:41,600
>> Другие вещи, которые могут пойти не так, не использует SizeOf.

1321
01:21:41,600 --> 01:21:44,460
Таким образом, в этом случае вы Malloc 8 байт,

1322
01:21:44,460 --> 01:21:46,700
и это то же самое, что и два целых числа, правильно?

1323
01:21:46,700 --> 01:21:49,580
Таким образом, это совершенно безопасно, но это такое?

1324
01:21:49,580 --> 01:21:52,160
Ну, как Лукас говорил о на разных архитектурах,

1325
01:21:52,160 --> 01:21:54,220
целых чисел различной длины.

1326
01:21:54,220 --> 01:21:57,970
Так, на устройство, которое вы используете, целые около 4 байта,

1327
01:21:57,970 --> 01:22:02,370
но на некоторых других системах они могут быть 8 байтов или они могут быть 16 байт.

1328
01:22:02,370 --> 01:22:05,680
Так что, если я просто использовать этот номер здесь,

1329
01:22:05,680 --> 01:22:07,310
эта программа может работать на приборе,

1330
01:22:07,310 --> 01:22:10,360
но он не собирается выделить достаточно памяти на некоторые другие системы.

1331
01:22:10,360 --> 01:22:14,020
В этом случае, это то, что оператор SizeOf используется.

1332
01:22:14,020 --> 01:22:16,880
Когда мы называем SizeOf (INT), что это делает

1333
01:22:16,880 --> 01:22:21,910
 это дает нам размер целого в системе, что программа работает.

1334
01:22:21,910 --> 01:22:25,490
Таким образом, в данном случае, SizeOf (INT) вернет 4 на что-то вроде прибора,

1335
01:22:25,490 --> 01:22:29,980
и теперь это будет 4 * 2, что на 8,

1336
01:22:29,980 --> 01:22:32,330
, который является только объем пространства, необходимого для двух целых чисел.

1337
01:22:32,330 --> 01:22:36,710
На другой системе, если Int, как 16 байт или 8 байтов,

1338
01:22:36,710 --> 01:22:39,380
это просто собирается вернуться достаточно байта для хранения этой суммы.

1339
01:22:41,830 --> 01:22:45,310
>> И, наконец, структуры.

1340
01:22:45,310 --> 01:22:48,340
Так что, если вы хотите сохранить судоку доска в память, как мы могли бы это сделать?

1341
01:22:48,340 --> 01:22:51,570
Вы можете представить себе, как переменной для первой вещью,

1342
01:22:51,570 --> 01:22:53,820
переменных для второго вещь, переменная третья вещь,

1343
01:22:53,820 --> 01:22:56,420
Переменная за четвертый вещь - плохо, верно?

1344
01:22:56,420 --> 01:23:00,750
Так, один улучшению вы можете сделать на верхней части этого сделать 9 х 9 массива.

1345
01:23:00,750 --> 01:23:04,480
Это прекрасно, но что, если вы хотите, чтобы связать другие вещи с доски судоку

1346
01:23:04,480 --> 01:23:06,490
нравится то, что трудности платы,

1347
01:23:06,490 --> 01:23:11,740
или, к примеру, что ваш счет, и сколько времени это заняло вам решить эту конференцию?

1348
01:23:11,740 --> 01:23:14,970
Ну, что вы можете сделать, вы можете создать структуры.

1349
01:23:14,970 --> 01:23:18,910
То, что я в основном говорю я определяю эту структуру здесь,

1350
01:23:18,910 --> 01:23:23,230
и я определяю судоку борту которого состоит из платы, что составляет 9 х 9.

1351
01:23:23,230 --> 01:23:26,650
>> И то, что она у него есть указатели на имя уровне.

1352
01:23:26,650 --> 01:23:30,730
Она также имеет х и у, которые являются координатами, где я нахожусь сейчас.

1353
01:23:30,730 --> 01:23:35,980
Он также время, затраченное [неразборчиво], и он имеет общее число ходов я введенные до сих пор.

1354
01:23:35,980 --> 01:23:40,010
И поэтому в данном случае, я могу сгруппировать целую кучу данных в одну структуру

1355
01:23:40,010 --> 01:23:42,790
вместо того, чтобы, как он летает в как различные переменные

1356
01:23:42,790 --> 01:23:44,540
что я не могу отслеживать.

1357
01:23:44,540 --> 01:23:49,720
И это позволяет нам иметь просто хороший синтаксис для рода ссылки разные вещи внутри этой структуры.

1358
01:23:49,720 --> 01:23:53,430
Я просто могу сделать board.board, и я получаю судоку доска назад.

1359
01:23:53,430 --> 01:23:56,320
Board.level, я понял, как тяжело это.

1360
01:23:56,320 --> 01:24:00,540
Board.x и board.y дать мне координаты, где я мог бы быть в совете.

1361
01:24:00,540 --> 01:24:04,730
И поэтому я доступе, что мы называем поля в структуре.

1362
01:24:04,730 --> 01:24:08,840
Это определяет sudokuBoard, который является типом, который у меня есть.

1363
01:24:08,840 --> 01:24:14,800
И вот теперь мы здесь. У меня есть переменная называется "доска" типа sudokuBoard.

1364
01:24:14,800 --> 01:24:18,820
И вот теперь я могу получить доступ ко всем полям, которые составляют эту структуру сюда.

1365
01:24:20,830 --> 01:24:22,450
>> Любые вопросы о структурах? Да?

1366
01:24:22,450 --> 01:24:25,890
[Студент] Для Int х, у, вы объявили обе на одной линии? >> [Иосиф] Угу.

1367
01:24:25,890 --> 01:24:27,400
[Студент] Таким образом, вы могли бы просто сделать это с ними со всеми?

1368
01:24:27,400 --> 01:24:31,200
Как и в х, у запятой раз, что общее?

1369
01:24:31,200 --> 01:24:34,460
[Джозеф] Да, можно определенно сделать это, но причина, я положил х и у на той же строке -

1370
01:24:34,460 --> 01:24:36,330
и вопрос в том, почему мы можем просто сделать это на той же линии?

1371
01:24:36,330 --> 01:24:38,600
Почему мы не просто поставить все это на одной линии

1372
01:24:38,600 --> 01:24:42,090
х и у связаны друг с другом,

1373
01:24:42,090 --> 01:24:44,780
и это только стилистически более правильно, в определенном смысле,

1374
01:24:44,780 --> 01:24:46,600
потому что это группировка две вещи, на той же линии

1375
01:24:46,600 --> 01:24:49,340
что, как и рода относятся к одной вещи.

1376
01:24:49,340 --> 01:24:51,440
И я просто разделить эти части. Это просто стиль вещь.

1377
01:24:51,440 --> 01:24:53,720
Это функционально делает никакой разницы.

1378
01:24:58,150 --> 01:24:59,270
Любые другие вопросы, касающиеся структуры?

1379
01:25:03,030 --> 01:25:06,620
Вы можете определить с Pokédex структуры.

1380
01:25:06,620 --> 01:25:11,720
Покемон имеет номер и он имеет письме, владелец, тип.

1381
01:25:11,720 --> 01:25:16,990
И потом, если у вас есть массив из покемонов, вы можете составить Pokédex, верно?

1382
01:25:16,990 --> 01:25:20,810
Хорошо, прохладно. Таким образом, вопросы о структур. Это связано с структурам.

1383
01:25:20,810 --> 01:25:25,270
>> Наконец, GDB. Что GDB позволяют вам делать? Это позволяет отлаживать вашу программу.

1384
01:25:25,270 --> 01:25:27,650
И если вы не использовали GDB, я бы рекомендовал смотреть на короткое

1385
01:25:27,650 --> 01:25:31,250
и как раз собирался за то, что GDB является, как вы с ним работать, как вы можете использовать его,

1386
01:25:31,250 --> 01:25:32,900
и проверить его на программу.

1387
01:25:32,900 --> 01:25:37,400
И то, что GDB позволяет вам делать это позволяет приостановить [неразборчиво] до вашей программы

1388
01:25:37,400 --> 01:25:38,920
и практической линии.

1389
01:25:38,920 --> 01:25:42,600
Например, я хочу, чтобы приостановить выполнение в строке 3, как из моей программы,

1390
01:25:42,600 --> 01:25:46,010
и пока я на линии 3 я могу напечатать все значения, которые есть.

1391
01:25:46,010 --> 01:25:49,710
И так, что мы называем, как пауза в линию

1392
01:25:49,710 --> 01:25:52,350
это мы называем это положить останова на этой линии

1393
01:25:52,350 --> 01:25:55,920
и тогда мы сможем распечатать переменных на состояние программы в то время.

1394
01:25:55,920 --> 01:25:58,990
>> Мы можем затем оттуда пройти по программе линия за линией.

1395
01:25:58,990 --> 01:26:03,200
И тогда мы можем посмотреть на состояние стека в то время.

1396
01:26:03,200 --> 01:26:08,600
И так, чтобы использовать GDB, что мы делаем, мы называем лязг на файл C,

1397
01:26:08,600 --> 01:26:11,290
но мы должны его пройти, ggdb флаг.

1398
01:26:11,290 --> 01:26:15,850
И как только мы закончим с этим, мы просто запустить GDB на результирующий файл вывода.

1399
01:26:15,850 --> 01:26:18,810
И поэтому вы сможете получить некоторые, как масса текста, как это,

1400
01:26:18,810 --> 01:26:21,990
но на самом деле все, что вам нужно сделать, это ввести команды в самом начале.

1401
01:26:21,990 --> 01:26:24,250
Перерыв основные ставит точку останова на основной.

1402
01:26:24,250 --> 01:26:28,470
Список 400 перечислены строк кода вокруг линии 400.

1403
01:26:28,470 --> 01:26:31,410
И поэтому в этом случае вы можете просто посмотреть вокруг и сказать, ой,

1404
01:26:31,410 --> 01:26:34,360
Я хочу, чтобы установить точки останова в строке 397, который эту линию,

1405
01:26:34,360 --> 01:26:37,170
и тогда ваша программа работает на такой шаг, и он собирается сломать.

1406
01:26:37,170 --> 01:26:41,120
Это собирается сделать паузу там, и Вы можете распечатать, например, значение низкое или высокое.

1407
01:26:41,120 --> 01:26:46,410
И так есть куча команд, которые вы должны знать,

1408
01:26:46,410 --> 01:26:48,660
и это слайд-шоу будет идти на сайт,

1409
01:26:48,660 --> 01:26:54,000
так что если вы просто хотите, чтобы ссылки на эти или, как положить их на свой шпаргалок, не стесняйтесь.

1410
01:26:54,000 --> 01:27:00,650
>> Cool. Это была викторина отзыв 0, и мы будем придерживаться вокруг, если вы имеете любые вопросы.

1411
01:27:00,650 --> 01:27:03,850
Хорошо.

1412
01:27:03,850 --> 01:27:09,030
>>  [Аплодисменты]

1413
01:27:09,030 --> 01:27:13,000
>> [CS50.TV]