1
00:00:00,000 --> 00:00:03,000
[Powered by Google Translate] [4-я неделя]

2
00:00:03,000 --> 00:00:05,000
[David J. Малан] [Harvard University]

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

4
00:00:08,000 --> 00:00:12,000
>> Все правильно, это CS50, и это начало недели 4,

5
00:00:12,000 --> 00:00:16,000
и это одна из самых медленных возможные алгоритмы сортировки.

6
00:00:16,000 --> 00:00:19,000
Какой это был, что мы просто смотрели туда?

7
00:00:19,000 --> 00:00:24,000
Это было пузырьковой сортировки, для того, большая O (N ^ 2) + сумма,

8
00:00:24,000 --> 00:00:28,000
да и мы не единственные в этом мире, чтобы, кажется, знают

9
00:00:28,000 --> 00:00:30,000
что пузырь сортировки или время его работы.

10
00:00:30,000 --> 00:00:33,000
Действительно, это было интервью с Эриком Шмидтом из Google

11
00:00:33,000 --> 00:00:45,000
и бывший сенатор Барак Обама всего лишь несколько лет назад.

12
00:00:45,000 --> 00:00:48,000
>> Теперь, сенатор, вы здесь, в Google,

13
00:00:48,000 --> 00:00:54,000
и мне нравится думать президентства, как собеседование.

14
00:00:54,000 --> 00:00:58,000
Теперь, трудно устроиться на работу в качестве президента, и вы собираетесь через суровые сейчас.

15
00:00:58,000 --> 00:01:00,000
Это также трудно устроиться на работу в Google.

16
00:01:00,000 --> 00:01:05,000
У нас есть вопросы, и мы просим наших кандидатов вопросы,

17
00:01:05,000 --> 00:01:10,000
и это одна из Ларри Швиммер.

18
00:01:10,000 --> 00:01:14,000
Вы, ребята, думаете, я шучу? Это прямо здесь.

19
00:01:14,000 --> 00:01:18,000
Какой самый эффективный способ сортировки миллионов 32-разрядных целых чисел?

20
00:01:18,000 --> 00:01:21,000
[Смех]

21
00:01:21,000 --> 00:01:24,000
Ну-

22
00:01:24,000 --> 00:01:26,000
Мне очень жаль. >> Нет, нет, нет, нет.

23
00:01:26,000 --> 00:01:34,000
Я думаю, что пузырьковой сортировки бы неправильный путь.

24
00:01:34,000 --> 00:01:39,000
>> Ну, кто сказал ему об этом?

25
00:01:39,000 --> 00:01:43,000
На прошлой неделе помните, мы взяли перерыв с кодом, по крайней мере, на один день,

26
00:01:43,000 --> 00:01:46,000
и начал упором на более высоком уровне идей и решения проблем в более общем

27
00:01:46,000 --> 00:01:49,000
в контексте поиска и сортировки,

28
00:01:49,000 --> 00:01:53,000
и мы ввели то, что мы не шлепать это имя на прошлой неделе,

29
00:01:53,000 --> 00:01:56,000
но асимптотические обозначения, Big O, Большой Omega,

30
00:01:56,000 --> 00:02:00,000
, а иногда и большую обозначения Theta, и они были просто способы

31
00:02:00,000 --> 00:02:02,000
описания времени работы алгоритмов,

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

33
00:02:05,000 --> 00:02:08,000
>> А вы помните, что вы говорили о времени работы с точки зрения размера

34
00:02:08,000 --> 00:02:11,000
на входе, который мы обычно называем п, что проблема может быть,

35
00:02:11,000 --> 00:02:13,000
где п-количество людей в комнате,

36
00:02:13,000 --> 00:02:17,000
Количество страниц в телефонной книге, и мы начали писать вещи

37
00:02:17,000 --> 00:02:21,000
как O (N ^ 2) или O (п) или O (п § п),

38
00:02:21,000 --> 00:02:24,000
и даже когда математика не совсем выработать так прекрасно

39
00:02:24,000 --> 00:02:28,000
и это был п ² - п / 2 или что-то вроде того

40
00:02:28,000 --> 00:02:31,000
вместо этого мы будем просто выбросить некоторые из младших членов,

41
00:02:31,000 --> 00:02:34,000
и мотивация есть то, что мы действительно хотим

42
00:02:34,000 --> 00:02:37,000
рода объективный способ оценки

43
00:02:37,000 --> 00:02:39,000
выполнение программы или выполнение алгоритмов

44
00:02:39,000 --> 00:02:42,000
что в конце дня не имеет ничего общего, например,

45
00:02:42,000 --> 00:02:45,000
со скоростью компьютера сегодня.

46
00:02:45,000 --> 00:02:47,000
>> Например, если вы реализуете пузырьковой сортировки,

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

48
00:02:50,000 --> 00:02:53,000
2 ГГц компьютер, и вы запустите его,

49
00:02:53,000 --> 00:02:56,000
и это занимает некоторое количество секунд, в следующем году есть 3 ГГц

50
00:02:56,000 --> 00:02:59,000
или 4 ГГц компьютер, и вы могли бы тогда утверждать, что "Ух ты, мой алгоритм

51
00:02:59,000 --> 00:03:03,000
Теперь в два раза быстрее ", когда на самом деле это, очевидно, не так.

52
00:03:03,000 --> 00:03:06,000
Это просто аппаратные получила быстрее, но компьютер

53
00:03:06,000 --> 00:03:10,000
не, и поэтому мы действительно хотим, чтобы выбросить вещи, как

54
00:03:10,000 --> 00:03:13,000
кратные 2 или кратных 3, когда дело доходит до описания

55
00:03:13,000 --> 00:03:17,000
как быстро или как медленно алгоритм и действительно просто сосредоточиться

56
00:03:17,000 --> 00:03:20,000
на п или некоторый фактор их,

57
00:03:20,000 --> 00:03:24,000
некоторые силы его, как в случае с видами на прошлой неделе.

58
00:03:24,000 --> 00:03:27,000
И напомним, что с помощью сортировки слиянием

59
00:03:27,000 --> 00:03:31,000
мы были в состоянии сделать это гораздо лучше, чем пузырьковой сортировки и выбора рода

60
00:03:31,000 --> 00:03:33,000
и даже вставок.

61
00:03:33,000 --> 00:03:36,000
>> Мы приступили к п § п, и снова,

62
00:03:36,000 --> 00:03:39,000
Напомним, что журнал п как правило, относится к тому, что растет

63
00:03:39,000 --> 00:03:43,000
медленнее, чем я, так что п § п до сих пор было хорошо

64
00:03:43,000 --> 00:03:45,000
потому что это было меньше, чем ² н.

65
00:03:45,000 --> 00:03:47,000
Но для достижения п п войти с сортировки слиянием

66
00:03:47,000 --> 00:03:51,000
то, что было основной росток идея, что мы должны были использовать

67
00:03:51,000 --> 00:03:54,000
что мы также использовала еще в недели 0?

68
00:03:54,000 --> 00:03:58,000
Как мы будем решать задачи сортировки умно с сортировки слиянием?

69
00:03:58,000 --> 00:04:04,000
Что было ключевым пониманием, что ли?

70
00:04:04,000 --> 00:04:07,000
Любой вообще.

71
00:04:07,000 --> 00:04:09,000
Хорошо, давайте сделаем шаг назад.

72
00:04:09,000 --> 00:04:11,000
Опишите сортировки слиянием в свои слова.

73
00:04:11,000 --> 00:04:15,000
Как это работает?

74
00:04:15,000 --> 00:04:17,000
Хорошо, мы будем грести обратно в неделю 0.

75
00:04:17,000 --> 00:04:19,000
Хорошо, да.

76
00:04:19,000 --> 00:04:22,000
[Неразборчиво-студент]

77
00:04:22,000 --> 00:04:26,000
Ладно, хорошо, так что мы разделили массив чисел на 2 части.

78
00:04:26,000 --> 00:04:29,000
Мы отсортировали каждой из этих частей, и тогда мы объединили их,

79
00:04:29,000 --> 00:04:33,000
и мы видели эту идею до принятия Проблема вот эта большая

80
00:04:33,000 --> 00:04:36,000
и измельчение его в проблему, вот эта большая или это большое.

81
00:04:36,000 --> 00:04:38,000
>> Напомним, например, телефонную книгу.

82
00:04:38,000 --> 00:04:42,000
Напомним, самостоятельного подсчета алгоритм из недели назад,

83
00:04:42,000 --> 00:04:45,000
так сортировки слиянием были подведены итоги этого псевдокод здесь.

84
00:04:45,000 --> 00:04:48,000
Когда вам дают п элементов, сначала это была проверка исправности.

85
00:04:48,000 --> 00:04:51,000
Если п <2, то ничего не делаем на всех

86
00:04:51,000 --> 00:04:55,000
потому что, если п <2, то п, очевидно, 0 или 1,

87
00:04:55,000 --> 00:04:57,000
и поэтому, если это 0 или 1 нет ничего, чтобы отсортировать.

88
00:04:57,000 --> 00:04:59,000
Вы сделали.

89
00:04:59,000 --> 00:05:01,000
Ваш список уже тривиально отсортированы.

90
00:05:01,000 --> 00:05:04,000
Но в противном случае, если у вас есть 2 или более элементов, идти вперед и разделить их

91
00:05:04,000 --> 00:05:06,000
на 2 половины, слева и справа.

92
00:05:06,000 --> 00:05:09,000
Сортировка каждой из этих половин, а затем объединить отсортированы половины.

93
00:05:09,000 --> 00:05:13,000
Но проблема здесь в том, что на первый взгляд это выглядит, как будто мы понтировавшего.

94
00:05:13,000 --> 00:05:17,000
Это круговая определения в том, что, если я попросил вас разобраться этих п элементов

95
00:05:17,000 --> 00:05:22,000
и ты говоришь мне "Ладно, хорошо, мы разберемся тех, п / 2 и тех, п / 2 элементов"

96
00:05:22,000 --> 00:05:27,000
Затем мой следующий вопрос будет "Хорошо, как вы сортировать п / 2 элементов?"

97
00:05:27,000 --> 00:05:30,000
>> Но из-за структуры этой программы,

98
00:05:30,000 --> 00:05:33,000
потому что это базовый вариант, так сказать,

99
00:05:33,000 --> 00:05:39,000
это особый случай, который говорит, что если п <некоторое фиксированное значение, как 2 возвращение немедленно.

100
00:05:39,000 --> 00:05:42,000
Не отвечать с той же круговой ответ.

101
00:05:42,000 --> 00:05:46,000
Этот процесс, эта цикличность в конечном счете закончится.

102
00:05:46,000 --> 00:05:50,000
Если я спрошу тебя "Сортировка этих п элементов", и вы говорите: "Хорошо, отсортировать п / 2"

103
00:05:50,000 --> 00:05:53,000
Затем вы говорите: "Хорошо, род этих п / 4, п / 8, n/16"

104
00:05:53,000 --> 00:05:56,000
в конечном итоге вы будете делить на достаточно большое число

105
00:05:56,000 --> 00:05:59,000
что вы будете иметь только 1 элемент влево, и в этот момент можно сказать,

106
00:05:59,000 --> 00:06:02,000
"Вот, вот отсортированы одного элемента."

107
00:06:02,000 --> 00:06:06,000
Тогда блеск этого алгоритма здесь является вывод из того факта,

108
00:06:06,000 --> 00:06:09,000
что, как только у Вас есть все эти отсортирован списки,

109
00:06:09,000 --> 00:06:12,000
все из которых имеют размер 1, который, кажется, бесполезно,

110
00:06:12,000 --> 00:06:15,000
как только вы начинаете их слияние и объединение их

111
00:06:15,000 --> 00:06:19,000
Вы сформируете, наконец, как Роб сделал в видео, наконец, отсортированный список.

112
00:06:19,000 --> 00:06:22,000
>> Но эта идея выходит далеко за рамки сортировки.

113
00:06:22,000 --> 00:06:26,000
Существует эта идея встроенных в эту программу известный как рекурсия,

114
00:06:26,000 --> 00:06:29,000
Идея, в котором вы находитесь программы,

115
00:06:29,000 --> 00:06:32,000
и решить некоторые проблемы, вы называете себя,

116
00:06:32,000 --> 00:06:36,000
или положить в контексте языков программирования вы находитесь функции,

117
00:06:36,000 --> 00:06:39,000
и для того, чтобы решить проблему, вы называете себя функции

118
00:06:39,000 --> 00:06:42,000
снова и снова, и снова, но вам функцию

119
00:06:42,000 --> 00:06:44,000
не может называть себя бесконечно много раз.

120
00:06:44,000 --> 00:06:47,000
В конце концов вы должны дна, так сказать,

121
00:06:47,000 --> 00:06:49,000
и есть жестко базы условии, что говорит

122
00:06:49,000 --> 00:06:53,000
в этот момент прекратить называть себя так, что весь процесс

123
00:06:53,000 --> 00:06:56,000
Наконец, на деле остановить.

124
00:06:56,000 --> 00:06:58,000
Что это действительно означает, рекурсивно?

125
00:06:58,000 --> 00:07:01,000
>> Давайте посмотрим, если мы можем сделать простой, банальный пример, скажем,

126
00:07:01,000 --> 00:07:03,000
3 человека со мной здесь, на сцене, если кто-то это удобно.

127
00:07:03,000 --> 00:07:06,000
1, давай вверх, 2 и 3.

128
00:07:06,000 --> 00:07:09,000
Если вам 3 хотят приехать сюда.

129
00:07:09,000 --> 00:07:12,000
Если вы хотите стоять рядом со мной здесь, в линию, предположим, что проблема под рукой

130
00:07:12,000 --> 00:07:15,000
очень тривиально подсчитать количество людей, которые находятся здесь.

131
00:07:15,000 --> 00:07:18,000
Но, откровенно говоря, я устал от всех этих подсчета примеров.

132
00:07:18,000 --> 00:07:21,000
Это займет некоторое время, 1, 2, и точка, точка, точка.

133
00:07:21,000 --> 00:07:23,000
Это будет длиться вечно.

134
00:07:23,000 --> 00:07:25,000
Я бы предпочел просто Пунт этой проблемы в целом с помощью, как тебя зовут?

135
00:07:25,000 --> 00:07:27,000
Сара. >> Сара, все в порядке.

136
00:07:27,000 --> 00:07:29,000
Келли. >> Келли и?

137
00:07:29,000 --> 00:07:31,000
>> Вилли. >> Вилли, Сара, Келли, и Вилли.

138
00:07:31,000 --> 00:07:34,000
Сейчас я задал вопрос кто-то

139
00:07:34,000 --> 00:07:37,000
сколько людей на этом этапе, и я понятия не имею.

140
00:07:37,000 --> 00:07:40,000
Это очень длинный список, и поэтому вместо этого я буду делать этот трюк.

141
00:07:40,000 --> 00:07:43,000
Я собираюсь попросить человека рядом со мной, чтобы сделать большую часть работы,

142
00:07:43,000 --> 00:07:46,000
и как только она делается делают большую часть работы

143
00:07:46,000 --> 00:07:49,000
Я собираюсь сделать наименьшее количество работ можно и просто добавить 1

144
00:07:49,000 --> 00:07:51,000
к тому, что ее ответ, так что здесь мы идем.

145
00:07:51,000 --> 00:07:54,000
Я спросил, как много людей на сцене.

146
00:07:54,000 --> 00:07:57,000
Сколько человек на сцену, чтобы слева от вас?

147
00:07:57,000 --> 00:08:00,000
Слева от меня? >> Хорошо, но не обманывают.

148
00:08:00,000 --> 00:08:04,000
Это хорошо, это правильно, но если мы хотим продолжить эту логику

149
00:08:04,000 --> 00:08:08,000
Давайте предположим, что вы так же хотите, чтобы выбивать из рук эту проблему слева от вас,

150
00:08:08,000 --> 00:08:11,000
Таким образом, вместо ответа напрямую идти вперед и просто сваливать.

151
00:08:11,000 --> 00:08:14,000
Ах, как много людей находятся слева от меня?

152
00:08:14,000 --> 00:08:16,000
Сколько людей налево?

153
00:08:16,000 --> 00:08:18,000
1.

154
00:08:18,000 --> 00:08:27,000
[Смех]

155
00:08:27,000 --> 00:08:30,000
Итак, 0, так что теперь Вилли сделал

156
00:08:30,000 --> 00:08:33,000
это ты вернулся ваш ответ этому направлению говоря 0.

157
00:08:33,000 --> 00:08:36,000
Итак, что вы должны сделать? >> 1.

158
00:08:36,000 --> 00:08:39,000
Итак, вы 1, так вы говорите: "Ладно, я собираюсь добавить 1

159
00:08:39,000 --> 00:08:41,000
к тому, что количество Вилли было ", так что 1 + 0.

160
00:08:41,000 --> 00:08:43,000
Вы сейчас 1 так что ваш ответ на правом теперь-

161
00:08:43,000 --> 00:08:45,000
1. >> А моя будет 2.

162
00:08:45,000 --> 00:08:48,000
Хорошо, так вы принимаете предыдущий ответ 1,

163
00:08:48,000 --> 00:08:51,000
добавив минимальное количество работы, которую вы хотите сделать, что является +1.

164
00:08:51,000 --> 00:08:55,000
Теперь у вас есть 2, а затем вы передать мне, какое значение?

165
00:08:55,000 --> 00:08:57,000
3, я имею в виду, извините, 2.

166
00:08:57,000 --> 00:08:59,000
Хорошо.

167
00:08:59,000 --> 00:09:02,000
>> Ну, у нас было от 0 до левого.

168
00:09:02,000 --> 00:09:05,000
Тогда у нас была 1, а затем мы добавляем 2,

169
00:09:05,000 --> 00:09:07,000
и теперь вы вручая мне номер 2,

170
00:09:07,000 --> 00:09:10,000
и поэтому я говорю, ладно, +1, 3.

171
00:09:10,000 --> 00:09:13,000
Там в самом деле 3 человек стоял рядом со мной на этой сцене,

172
00:09:13,000 --> 00:09:16,000
таким образом, мы могли бы, очевидно, сделал это очень линейно,

173
00:09:16,000 --> 00:09:19,000
очень очевидным образом, но что мы действительно делаем?

174
00:09:19,000 --> 00:09:21,000
Мы взяли проблеме размером 3 на начальном этапе.

175
00:09:21,000 --> 00:09:24,000
Затем мы сломали его на проблеме размер 2,

176
00:09:24,000 --> 00:09:27,000
Затем проблема размер 1, и, наконец, базовый сценарий

177
00:09:27,000 --> 00:09:29,000
действительно, ой, там никого нет,

178
00:09:29,000 --> 00:09:33,000
в этот момент Вилли вернулся эффективно жестко ответить пару раз,

179
00:09:33,000 --> 00:09:36,000
, а второй затем пропускают до пузырьками, вверх, вверх пузырьками,

180
00:09:36,000 --> 00:09:39,000
, а затем, добавив в этот дополнительный 1

181
00:09:39,000 --> 00:09:41,000
мы реализовали эту основную идею рекурсии.

182
00:09:41,000 --> 00:09:44,000
>> Теперь, в данном случае это действительно не решить проблему

183
00:09:44,000 --> 00:09:46,000
любой более эффективно то, что мы видели до сих пор.

184
00:09:46,000 --> 00:09:48,000
Но думать об алгоритмах мы сделали на сцене до сих пор.

185
00:09:48,000 --> 00:09:51,000
У нас было 8 листов бумаги на доске,

186
00:09:51,000 --> 00:09:55,000
на видео, когда Шон искал номер 7, и что он реально сделать?

187
00:09:55,000 --> 00:09:58,000
Ну, он не делал любые разделяй и властвуй.

188
00:09:58,000 --> 00:10:01,000
Он не сделал любой рекурсии.

189
00:10:01,000 --> 00:10:03,000
Скорее, он просто сделал это линейный алгоритм.

190
00:10:03,000 --> 00:10:07,000
Но когда мы предложили идею отсортированы номера на сцене живут на прошлой неделе

191
00:10:07,000 --> 00:10:09,000
Затем у нас был этот инстинкт собирается к середине,

192
00:10:09,000 --> 00:10:13,000
в этот момент у нас было меньше списке размере 4 или другой список размере 4,

193
00:10:13,000 --> 00:10:17,000
а потом у нас была точно такая же проблема, поэтому мы повторили, повторяется, повторяется.

194
00:10:17,000 --> 00:10:19,000
Другими словами, мы рекурсия.

195
00:10:19,000 --> 00:10:24,000
Большое спасибо нашему 3 добровольцев здесь для демонстрации рекурсии с нами.

196
00:10:24,000 --> 00:10:28,000
>> Давайте посмотрим, если мы не можем сделать этого сейчас немного более конкретным,

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

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

199
00:10:34,000 --> 00:10:37,000
Если я хочу, чтобы вычислить суммированием кучу цифр,

200
00:10:37,000 --> 00:10:39,000
Например, если вы проходите в число 3,

201
00:10:39,000 --> 00:10:42,000
Я хочу дать вам значение сигма-3,

202
00:10:42,000 --> 00:10:46,000
так что сумма 3 + 2 + 1 + 0.

203
00:10:46,000 --> 00:10:48,000
Я хочу получить обратно ответ 6,

204
00:10:48,000 --> 00:10:51,000
таким образом, мы будем реализовывать эту функцию сигма, эта функция суммирования

205
00:10:51,000 --> 00:10:54,000
что, опять же, берет на входе, а затем возвращает суммирования

206
00:10:54,000 --> 00:10:57,000
из этого числа вплоть до 0.

207
00:10:57,000 --> 00:10:59,000
Мы могли бы сделать это довольно просто, не так ли?

208
00:10:59,000 --> 00:11:01,000
Мы могли бы сделать это с какой-то цикл структуры,

209
00:11:01,000 --> 00:11:04,000
так что позвольте мне идти вперед и получить эту работу.

210
00:11:04,000 --> 00:11:07,000
>> Включить stdio.h.

211
00:11:07,000 --> 00:11:09,000
Позвольте мне получить себе в основную работу с здесь.

212
00:11:09,000 --> 00:11:12,000
Давайте сохраним это как sigma.c.

213
00:11:12,000 --> 00:11:14,000
Тогда я пойду сюда, и я собираюсь объявить Int N,

214
00:11:14,000 --> 00:11:18,000
и я собираюсь сделать следующее, пока пользователь не сотрудничают.

215
00:11:18,000 --> 00:11:22,000
Пока пользователь не дал мне положительного числа

216
00:11:22,000 --> 00:11:26,000
Позвольте мне идти вперед и побудить их к GetInt п =,

217
00:11:26,000 --> 00:11:28,000
и позвольте мне дать им инструкции относительно того, что делать,

218
00:11:28,000 --> 00:11:33,000
так что Е ("Положительное целое, пожалуйста»).

219
00:11:33,000 --> 00:11:39,000
Просто что-то относительно простое, как это так, что к тому времени мы попали линия 14

220
00:11:39,000 --> 00:11:42,000
у нас теперь есть натуральное число, вероятно, в с.

221
00:11:42,000 --> 00:11:44,000
>> Теперь давайте что-то делать с этим.

222
00:11:44,000 --> 00:11:50,000
Позвольте мне идти вперед и вычислить суммы, так Int сумма = сигма (п).

223
00:11:50,000 --> 00:11:54,000
Sigma просто суммирование, так что я просто пишу это в причудливые пути.

224
00:11:54,000 --> 00:11:56,000
Мы просто называем это сигма там.

225
00:11:56,000 --> 00:11:58,000
Это сумма, и теперь я собираюсь распечатать результат,

226
00:11:58,000 --> 00:12:08,000
Е ("Сумма% г \ п", сумма).

227
00:12:08,000 --> 00:12:11,000
И тогда я буду возвращать 0 для хорошей мерой.

228
00:12:11,000 --> 00:12:15,000
Мы сделали все, что эта программа требует, кроме интересной части,

229
00:12:15,000 --> 00:12:18,000
которая является на самом деле реализации сигма функции.

230
00:12:18,000 --> 00:12:22,000
>> Отпусти меня сюда на дно, и позвольте мне объявить функцию сигма.

231
00:12:22,000 --> 00:12:26,000
Это должно принимать переменное, что это типа целое число,

232
00:12:26,000 --> 00:12:30,000
и какой тип данных, я хочу, чтобы вернуться предположительно от Sigma?

233
00:12:30,000 --> 00:12:34,000
Int, потому что я хочу, чтобы соответствовать моим ожиданиям по линии 15.

234
00:12:34,000 --> 00:12:37,000
В здесь, позвольте мне пойти дальше и реализовать эту

235
00:12:37,000 --> 00:12:41,000
В довольно простым способом.

236
00:12:41,000 --> 00:12:45,000
>> Давайте пойдем дальше и сказать Int сумма = 0,

237
00:12:45,000 --> 00:12:47,000
и теперь я собираюсь немного цикла здесь

238
00:12:47,000 --> 00:12:50,000
что собирается сказать что-то вроде этого,

239
00:12:50,000 --> 00:13:01,000
для (INT = 0; I <= номер, я + +) Сумма + = я.

240
00:13:01,000 --> 00:13:05,000
А потом я собираюсь вернуть сумму.

241
00:13:05,000 --> 00:13:07,000
Я мог бы осуществляться этом в любом количестве способами.

242
00:13:07,000 --> 00:13:09,000
Я мог бы использовать цикл.

243
00:13:09,000 --> 00:13:11,000
Я мог бы пропустить с помощью суммы переменной, если я действительно хотел,

244
00:13:11,000 --> 00:13:15,000
но в общем, мы просто есть функция, которая, если я не лох заявляет сумма равна 0.

245
00:13:15,000 --> 00:13:18,000
Затем он перебирает от 0 на вверх через номер,

246
00:13:18,000 --> 00:13:23,000
и на каждой итерации он добавляет, что текущее значение суммы, а затем возвращает сумму.

247
00:13:23,000 --> 00:13:25,000
>> Так вот, есть небольшая оптимизация здесь.

248
00:13:25,000 --> 00:13:29,000
Это, наверное, зря шаг, но пусть будет так. Это хорошо на данный момент.

249
00:13:29,000 --> 00:13:32,000
Мы по крайней мере быть тщательным и собирался 0 все пути вверх.

250
00:13:32,000 --> 00:13:34,000
Не очень жесткий и довольно проста,

251
00:13:34,000 --> 00:13:37,000
но оказывается, что с помощью функции сигма мы имеем те же возможности

252
00:13:37,000 --> 00:13:39,000
как мы сделали здесь, на сцене.

253
00:13:39,000 --> 00:13:42,000
На сцене мы просто посчитал, сколько людей было рядом со мной,

254
00:13:42,000 --> 00:13:47,000
но вместо этого, если мы хотим подсчитать число 3 + 2 + 1

255
00:13:47,000 --> 00:13:51,000
на до 0, мы могли аналогичным плоскодонки к функции

256
00:13:51,000 --> 00:13:55,000
что я буду описывать, а не как рекурсивные.

257
00:13:55,000 --> 00:13:57,000
Вот давайте сделаем быстро здравомыслие проверить и убедиться, что я не лох.

258
00:13:57,000 --> 00:14:00,000
>> Я знаю, что есть по крайней мере одна вещь в этой программе, что я сделал неправильно.

259
00:14:00,000 --> 00:14:04,000
Когда я попала ввести я собираюсь получить любую кричать на меня?

260
00:14:04,000 --> 00:14:06,000
Что мне будет кричать на о?

261
00:14:06,000 --> 00:14:11,000
Да, я забыл прототип, поэтому я использую функцию под названием Sigma в строке 15,

262
00:14:11,000 --> 00:14:16,000
но это не объявлены, пока линия 22, так что я лучший активно идут сюда

263
00:14:16,000 --> 00:14:22,000
и объявить прототип, и я скажу Int сигма (внутр номер), вот и все.

264
00:14:22,000 --> 00:14:24,000
Он реализован в нижней части.

265
00:14:24,000 --> 00:14:27,000
>> Или другой способ я могу решить эту проблему,

266
00:14:27,000 --> 00:14:30,000
Я мог бы переместить функцию там, наверху, который не плох,

267
00:14:30,000 --> 00:14:32,000
но по крайней мере, когда ваши программы начинают получать длинный, откровенно говоря,

268
00:14:32,000 --> 00:14:35,000
Я думаю, что есть некоторое значение в всегда с основными в верхнем

269
00:14:35,000 --> 00:14:38,000
так что вы у читателя может открыть файл, а затем сразу же увидеть

270
00:14:38,000 --> 00:14:40,000
то, что делает программа, без необходимости искать через него

271
00:14:40,000 --> 00:14:42,000
ищет, что основной функцией.

272
00:14:42,000 --> 00:14:49,000
Пойдем в мой окне терминала здесь, попробуйте сделать сигма сделать сигма,

273
00:14:49,000 --> 00:14:51,000
и я облажался здесь.

274
00:14:51,000 --> 00:14:55,000
Неявная декларация функции GetInt означает, что я забыл сделать то, что еще?

275
00:14:55,000 --> 00:14:57,000
[Неразборчиво-студент]

276
00:14:57,000 --> 00:15:00,000
Хорошо, таким образом, по-видимому распространенная ошибка, так давайте это здесь,

277
00:15:00,000 --> 00:15:04,000
cs50.h, а теперь давайте вернемся к моему окне терминала.

278
00:15:04,000 --> 00:15:08,000
>> Я буду очистить экран, и я буду повторно сделать сигма.

279
00:15:08,000 --> 00:15:11,000
Мне кажется, собрали. Позвольте мне теперь работать сигма.

280
00:15:11,000 --> 00:15:15,000
Я введите номер 3, и я получить 6, так что не строгая проверка,

281
00:15:15,000 --> 00:15:18,000
но по крайней мере, кажется, работает на первый взгляд, но теперь давай рвать его на части,

282
00:15:18,000 --> 00:15:21,000
и давайте на самом деле опираются на идею рекурсии, опять же,

283
00:15:21,000 --> 00:15:24,000
В очень простых условий, с тем, что в течение нескольких недель

284
00:15:24,000 --> 00:15:27,000
когда мы начинаем изучать любитель структур данных, чем массивы

285
00:15:27,000 --> 00:15:30,000
у нас есть еще один инструмент в инструментарии, с которым

286
00:15:30,000 --> 00:15:33,000
манипулировать этими данными структурами, как мы увидим.

287
00:15:33,000 --> 00:15:36,000
Это итеративный подход, цикл подхода.

288
00:15:36,000 --> 00:15:39,000
>> Позвольте мне вместо этого теперь сделать это.

289
00:15:39,000 --> 00:15:44,000
Позвольте мне сказать, что вместо суммирования числа

290
00:15:44,000 --> 00:15:48,000
на до 0 на самом деле то же самое,

291
00:15:48,000 --> 00:15:53,000
Число + сигма (количество - 1).

292
00:15:53,000 --> 00:15:57,000
Другими словами, так же, как на сцене, я плыла по течению, чтобы каждый из людей рядом со мной,

293
00:15:57,000 --> 00:16:00,000
а они, в свою очередь, держали понтировавшего, пока мы, наконец, дна на Вилли,

294
00:16:00,000 --> 00:16:03,000
, которые должны были вернуться жестко ответить, как 0.

295
00:16:03,000 --> 00:16:07,000
Вот теперь мы так же понтировавшего сигма

296
00:16:07,000 --> 00:16:10,000
те же функции, изначально называлась, но ключ понимания здесь

297
00:16:10,000 --> 00:16:12,000
то, что мы не призываем сигма одинаково.

298
00:16:12,000 --> 00:16:14,000
Мы не проходящая на русском языке.

299
00:16:14,000 --> 00:16:17,000
Мы четко проходящей в номер - 1,

300
00:16:17,000 --> 00:16:20,000
так что немного меньше проблем, немного меньше проблем.

301
00:16:20,000 --> 00:16:23,000
>> К сожалению, это не совсем решение еще, и прежде, чем мы фиксируем

302
00:16:23,000 --> 00:16:26,000
что можно было бы прыгать, как очевидно на некоторые из вас

303
00:16:26,000 --> 00:16:28,000
Позвольте мне идти вперед и повторно сделать.

304
00:16:28,000 --> 00:16:30,000
Кажется, собрать все в порядке.

305
00:16:30,000 --> 00:16:32,000
Позвольте мне повторно сигма с 6.

306
00:16:32,000 --> 00:16:37,000
Ой, дайте мне повторно сигма с 6.

307
00:16:37,000 --> 00:16:42,000
Мы видели это раньше, хотя и случайно последний раз.

308
00:16:42,000 --> 00:16:48,000
Почему я получаю это загадочное вине сегментации? Да.

309
00:16:48,000 --> 00:16:50,000
[Неразборчиво-студент]

310
00:16:50,000 --> 00:16:53,000
Там нет базового варианта и, более конкретно, что, вероятно, произошло?

311
00:16:53,000 --> 00:16:58,000
Это симптом того, что поведение?

312
00:16:58,000 --> 00:17:00,000
Скажите это немного громче.

313
00:17:00,000 --> 00:17:02,000
[Неразборчиво-студент]

314
00:17:02,000 --> 00:17:05,000
Это бесконечный цикл эффективно, и проблема с бесконечной петли

315
00:17:05,000 --> 00:17:08,000
когда они связаны рекурсии в данном случае, функции, называющей себя,

316
00:17:08,000 --> 00:17:10,000
то, что происходит каждый раз, когда вы вызываете функцию?

317
00:17:10,000 --> 00:17:13,000
Ну, вспомните, как мы выложили памяти в компьютере.

318
00:17:13,000 --> 00:17:16,000
Мы сказали, что есть этот кусок памяти, называемой стеком, что это на дне,

319
00:17:16,000 --> 00:17:19,000
и каждый раз, когда вы вызываете функцию немного больше памяти, получает положить

320
00:17:19,000 --> 00:17:24,000
На этой так называемой стеком, содержащие локальные переменные, функции или параметры,

321
00:17:24,000 --> 00:17:27,000
так что если сигма сигма называет звонки сигма называет сигма

322
00:17:27,000 --> 00:17:29,000
 призывает сигма где же эта история закончится?

323
00:17:29,000 --> 00:17:31,000
>> Ну, это в конечном итоге перерасход на общую сумму

324
00:17:31,000 --> 00:17:33,000
памяти, которые у вас есть для вашего компьютера.

325
00:17:33,000 --> 00:17:37,000
Вы переполнения сегмента, что вы должны оставаться в пределах,

326
00:17:37,000 --> 00:17:40,000
и вы получите эту ошибку сегментации, основные бросили,

327
00:17:40,000 --> 00:17:43,000
и то, что основной сбрасывали означает, что теперь у меня есть файл с именем основного

328
00:17:43,000 --> 00:17:46,000
который представляет собой файл, содержащий нули и единицы

329
00:17:46,000 --> 00:17:49,000
что на самом деле в будущем будет диагностически полезны.

330
00:17:49,000 --> 00:17:52,000
Если это не очевидно для вас, где ваша ошибка

331
00:17:52,000 --> 00:17:54,000
Вы можете фактически сделать немного судебно-медицинской экспертизы, так сказать,

332
00:17:54,000 --> 00:17:58,000
На этой файла дампа памяти, который, опять же, это просто целая куча нулей и единиц

333
00:17:58,000 --> 00:18:02,000
, что по существу представляет состояние вашей программы в памяти

334
00:18:02,000 --> 00:18:05,000
момент он разбился на этом пути.

335
00:18:05,000 --> 00:18:11,000
>> Исправление в том, что мы не можем просто слепо вернуться сигма,

336
00:18:11,000 --> 00:18:14,000
Число + сигма немного меньше проблем.

337
00:18:14,000 --> 00:18:16,000
Мы должны иметь какое-то основание в данном случае,

338
00:18:16,000 --> 00:18:19,000
и что должно базовый вариант, вероятно, будет?

339
00:18:19,000 --> 00:18:22,000
[Неразборчиво-студент]

340
00:18:22,000 --> 00:18:25,000
Итак, если число является положительным, мы фактически должны вернуть это,

341
00:18:25,000 --> 00:18:29,000
или, другими словами, если число, скажем, <= 0,

342
00:18:29,000 --> 00:18:32,000
Вы знаете, что я буду идти вперед и возвращать 0,

343
00:18:32,000 --> 00:18:36,000
так же, как Вилли сделал, и еще, я собираюсь идти вперед

344
00:18:36,000 --> 00:18:41,000
и вернуть эту, так что это не то, что намного короче,

345
00:18:41,000 --> 00:18:44,000
чем итерационные версии, что мы на скорую руку сначала с помощью цикла,

346
00:18:44,000 --> 00:18:48,000
но обратите внимание, что есть такая элегантность к нему.

347
00:18:48,000 --> 00:18:51,000
Вместо возвращения некоторого числа и выполнения всей этой математике

348
00:18:51,000 --> 00:18:54,000
и добавление вещи с локальными переменными

349
00:18:54,000 --> 00:18:57,000
Вы вместо того, говоря: "Хорошо, если это супер легкая задача,

350
00:18:57,000 --> 00:19:01,000
как число <0, позвольте мне немедленно вернуть 0 ".

351
00:19:01,000 --> 00:19:03,000
>> Мы не собираемся возиться поддержки отрицательных чисел,

352
00:19:03,000 --> 00:19:05,000
так что я собираюсь на жесткий код значением 0.

353
00:19:05,000 --> 00:19:08,000
Но с другой стороны, для реализации этой идеи суммирования

354
00:19:08,000 --> 00:19:11,000
Все эти цифры вместе, вы можете эффективно взять небольшой укус

355
00:19:11,000 --> 00:19:14,000
из этой проблемы, так же, как мы делали здесь, на сцене,

356
00:19:14,000 --> 00:19:18,000
Затем плоскодонки остальные задачи на следующий человек,

357
00:19:18,000 --> 00:19:20,000
но в этом случае следующий человек, это вы сами.

358
00:19:20,000 --> 00:19:22,000
Это же именем функции.

359
00:19:22,000 --> 00:19:25,000
Просто передайте его все меньше и меньше проблемой каждый раз,

360
00:19:25,000 --> 00:19:28,000
И хотя у нас не совсем формализованных вещи в коде здесь

361
00:19:28,000 --> 00:19:33,000
это именно то, что происходило в неделю 0 с телефонной книгой.

362
00:19:33,000 --> 00:19:36,000
Это именно то, что происходит в последние недели с Шоном

363
00:19:36,000 --> 00:19:39,000
и с нашей демонстрации поиска номеров.

364
00:19:39,000 --> 00:19:42,000
Это занимает проблема и разделив его снова и снова.

365
00:19:42,000 --> 00:19:44,000
>> Другими словами, есть способ в настоящее время перевода

366
00:19:44,000 --> 00:19:47,000
это реальная конструкция мира, это более высокий уровень конструкции

367
00:19:47,000 --> 00:19:51,000
разделяй и властвуй и делать что-то снова и снова

368
00:19:51,000 --> 00:19:56,000
В коде, так это то, что мы увидим снова в течение долгого времени.

369
00:19:56,000 --> 00:20:00,000
Теперь, как и в сторону, если вы новичок в рекурсии вы должны по крайней мере, понять сейчас

370
00:20:00,000 --> 00:20:02,000
почему это смешно.

371
00:20:02,000 --> 00:20:05,000
Я собираюсь пойти на google.com,

372
00:20:05,000 --> 00:20:17,000
и я буду искать какие-то советы и рекомендации по рекурсию, введите.

373
00:20:17,000 --> 00:20:21,000
Расскажите человек рядом с вами, если они не смеялись только сейчас.

374
00:20:21,000 --> 00:20:23,000
Вы имели в виду рекурсии?

375
00:20:23,000 --> 00:20:25,000
Вы имели в виду-а-а, вот так.

376
00:20:25,000 --> 00:20:28,000
Хорошо, теперь вот остальные каждого.

377
00:20:28,000 --> 00:20:30,000
Немного пасхальное яйцо встроенных где-то там, в Google.

378
00:20:30,000 --> 00:20:33,000
Как в сторону, одной из ссылок мы ставим на сайте курса

379
00:20:33,000 --> 00:20:36,000
на сегодняшний день является только эта сетка различных алгоритмов сортировки,

380
00:20:36,000 --> 00:20:39,000
некоторые из которых мы посмотрели на прошлой неделе, но то, что хорошо об этом визуализация

381
00:20:39,000 --> 00:20:43,000
как вы пытаетесь обернуть ваш разум вокруг различных вещей, связанных с алгоритмами

382
00:20:43,000 --> 00:20:46,000
знаю, что вы можете очень легко начинать с различными типами входов.

383
00:20:46,000 --> 00:20:50,000
Входы все вспять, входы основном сортируется, случайные входы и так далее.

384
00:20:50,000 --> 00:20:53,000
Как вы пытаетесь, опять же, различать эти вещи в своем уме

385
00:20:53,000 --> 00:20:57,000
понимаю, что это URL на веб-сайте курса на лекции страницу

386
00:20:57,000 --> 00:21:00,000
может помочь вам причину через некоторые из них.

387
00:21:00,000 --> 00:21:05,000
>> Сегодня мы, наконец, получить, чтобы решить эту проблему некоторое время назад,

388
00:21:05,000 --> 00:21:08,000
которых было то, что эта функция подкачки просто не работает,

389
00:21:08,000 --> 00:21:12,000
и то, что основная проблема с этой функцией подкачки,

390
00:21:12,000 --> 00:21:15,000
целью которой было, опять же, для обмена значение здесь и здесь

391
00:21:15,000 --> 00:21:17,000
такое, что это происходит?

392
00:21:17,000 --> 00:21:20,000
Это на самом деле не работают. Почему?

393
00:21:20,000 --> 00:21:22,000
Да.

394
00:21:22,000 --> 00:21:28,000
[Неразборчиво-студент]

395
00:21:28,000 --> 00:21:31,000
Точно, объяснение этому грубых ошибок

396
00:21:31,000 --> 00:21:34,000
Просто потому, что когда вы вызываете функции в C

397
00:21:34,000 --> 00:21:38,000
и эти функции принимают аргументы, как и б здесь,

398
00:21:38,000 --> 00:21:42,000
Вы передаете в копии какое бы значение вы предоставляете к этой функции.

399
00:21:42,000 --> 00:21:46,000
Вы не предоставления исходных значений себе,

400
00:21:46,000 --> 00:21:49,000
таким образом, мы видели это в контексте buggyc,

401
00:21:49,000 --> 00:21:52,000
buggy3.c, который выглядел немного что-то вроде этого.

402
00:21:52,000 --> 00:21:57,000
>> Напомним, что у нас было х и у инициализируются 1 и 2, соответственно.

403
00:21:57,000 --> 00:21:59,000
Затем распечатать то, что они были.

404
00:21:59,000 --> 00:22:03,000
Я тогда утверждал, что я был заменяя их по телефону своп х, у.

405
00:22:03,000 --> 00:22:06,000
Но проблема в том, что замена работал,

406
00:22:06,000 --> 00:22:10,000
но только в рамках своп самой функции.

407
00:22:10,000 --> 00:22:13,000
Как только мы попали линия 40 местами эти значения

408
00:22:13,000 --> 00:22:16,000
были выброшены на свалку, а так ничего

409
00:22:16,000 --> 00:22:21,000
В исходной функции основного был на самом деле изменилась,

410
00:22:21,000 --> 00:22:26,000
поэтому, если вы считаете, тогда как, в какой это выглядит с точки зрения нашей памяти

411
00:22:26,000 --> 00:22:29,000
если это левая сторона платы представляет собой-

412
00:22:29,000 --> 00:22:33,000
и я сделаю все возможное, чтобы все видели это, если это левая сторона платы

413
00:22:33,000 --> 00:22:37,000
представляет, скажем, ваша память и стек будет расти на эту образом,

414
00:22:37,000 --> 00:22:43,000
и мы вызываем функцию как основного, а главное есть 2 локальные переменные х и у,

415
00:22:43,000 --> 00:22:48,000
Давайте описывать их как х здесь, и опишем, как у этих здесь,

416
00:22:48,000 --> 00:22:55,000
и давайте в значения 1 и 2, так что здесь главный,

417
00:22:55,000 --> 00:22:58,000
и когда основной вызывает функцию подкачки операционной системы

418
00:22:58,000 --> 00:23:02,000
дает функцию подкачки свою полосу памяти в стеке,

419
00:23:02,000 --> 00:23:04,000
своих кадров в стеке, так сказать.

420
00:23:04,000 --> 00:23:08,000
Он также выделяет 32 бит для этих целыми.

421
00:23:08,000 --> 00:23:11,000
Это происходит называть их А и Б, но это совершенно произвольными.

422
00:23:11,000 --> 00:23:13,000
Это могло бы назвал их, что хочет, но то, что происходит, когда основной

423
00:23:13,000 --> 00:23:19,000
звонки своп он принимает это 1, помещает копию там, помещает копию там.

424
00:23:19,000 --> 00:23:23,000
>> Существует 1 другие локальные переменные в подкачки, однако, то, что называется? >> Tmp.

425
00:23:23,000 --> 00:23:27,000
Tmp, поэтому позвольте мне дать себе еще 32 бита здесь,

426
00:23:27,000 --> 00:23:29,000
и что же мне делать в этой функции?

427
00:23:29,000 --> 00:23:34,000
Я сказал Int TMP получает, таким образом, имеет 1, так что я сделал это, когда мы в последний раз играли с этим примером.

428
00:23:34,000 --> 00:23:39,000
Тогда б получает, таким образом, б = 2, так что теперь это становится 2,

429
00:23:39,000 --> 00:23:42,000
и теперь б получает временный, так что температура равна 1,

430
00:23:42,000 --> 00:23:44,000
так что теперь это становится б.

431
00:23:44,000 --> 00:23:46,000
Это здорово. Это сработало.

432
00:23:46,000 --> 00:23:49,000
Но тогда, как только функция возвращает

433
00:23:49,000 --> 00:23:52,000
памяти свопа эффективно исчезает, так что его можно использовать повторно

434
00:23:52,000 --> 00:23:58,000
некоторые другие функции в будущем, а главное, очевидно, совершенно не изменился.

435
00:23:58,000 --> 00:24:00,000
Нам нужен способ принципиально решить эту проблему,

436
00:24:00,000 --> 00:24:03,000
и сегодня мы, наконец, есть способ сделать это посредством чего

437
00:24:03,000 --> 00:24:06,000
мы можем ввести так называемый указатель.

438
00:24:06,000 --> 00:24:09,000
Получается, что мы можем решить эту проблему

439
00:24:09,000 --> 00:24:12,000
Не переходя в копии х и у

440
00:24:12,000 --> 00:24:18,000
но вместо этого, передав в чем, как вы думаете, в своп функции?

441
00:24:18,000 --> 00:24:20,000
Да, насчет адреса?

442
00:24:20,000 --> 00:24:22,000
Мы еще не говорили об адресах очень подробно,

443
00:24:22,000 --> 00:24:25,000
но если эта доска представляет памяти моего компьютера

444
00:24:25,000 --> 00:24:28,000
Мы, безусловно, может начать нумерацию байт в моей памяти

445
00:24:28,000 --> 00:24:31,000
и говорят, что это байт № 1, это байт № 2, № 3 байта,

446
00:24:31,000 --> 00:24:35,000
№ 4 байта, байт # ... 2 миллиардов, если у меня есть 2 гигабайта оперативной памяти,

447
00:24:35,000 --> 00:24:38,000
таким образом, мы, безусловно, может выступить с некоторыми произвольной схемы нумерации

448
00:24:38,000 --> 00:24:41,000
для всех отдельных байтов в памяти моего компьютера.

449
00:24:41,000 --> 00:24:43,000
>> Что, если вместо этого, когда я называю своп

450
00:24:43,000 --> 00:24:47,000
, а не пропуск в копии х и у

451
00:24:47,000 --> 00:24:51,000
почему бы мне не пройти, а не в адрес х здесь,

452
00:24:51,000 --> 00:24:55,000
адрес у здесь, по существу, почтовый адрес,

453
00:24:55,000 --> 00:24:59,000
х и у, потому что тогда поменяться, если он проинформировал

454
00:24:59,000 --> 00:25:01,000
адреса в память о х и у,

455
00:25:01,000 --> 00:25:04,000
Затем поменяться, если мы обучили его немного,

456
00:25:04,000 --> 00:25:07,000
Он потенциально может ездить по этому адресу, так сказать,

457
00:25:07,000 --> 00:25:11,000
х, и изменить номер есть, то ехать в адрес у,

458
00:25:11,000 --> 00:25:16,000
изменить номер есть, даже если на самом деле не получает копии этих значений себе,

459
00:25:16,000 --> 00:25:19,000
так что даже если мы об этом говорили как основной памяти в

460
00:25:19,000 --> 00:25:23,000
и это как своп-памяти мощная и опасная часть C

461
00:25:23,000 --> 00:25:28,000
является то, что любая функция может коснуться памяти где-нибудь в компьютер,

462
00:25:28,000 --> 00:25:32,000
и это мощный в том, что вы можете сделать очень модные вещи с компьютерными программами на языке C.

463
00:25:32,000 --> 00:25:36,000
Это опасно, потому что вы можете испортить очень легко.

464
00:25:36,000 --> 00:25:39,000
В самом деле, одним из наиболее распространенных способов для программ, в эти дни быть использованы

465
00:25:39,000 --> 00:25:42,000
по-прежнему является для программиста, чтобы не понимать

466
00:25:42,000 --> 00:25:45,000
что он или она разрешает данных

467
00:25:45,000 --> 00:25:49,000
быть написаны на место в памяти, которая не была предназначена.

468
00:25:49,000 --> 00:25:51,000
>> Например, он или она объявляет массив размером 10

469
00:25:51,000 --> 00:25:56,000
но потом случайно пытается поставить 11 байт в этом массиве памяти,

470
00:25:56,000 --> 00:25:59,000
и вы начинаете касаясь частей памяти, которые более не являются действительными.

471
00:25:59,000 --> 00:26:02,000
Просто контекстной это, некоторые из вас могут знать, что

472
00:26:02,000 --> 00:26:06,000
Программное обеспечение часто предлагает ввести серийный номер или регистрационные ключи,

473
00:26:06,000 --> 00:26:08,000
Photoshop и Слово и подобных программах.

474
00:26:08,000 --> 00:26:12,000
Там существуют трещины, так как некоторые из вас знают, в Интернете, где вы можете запустить небольшую программу,

475
00:26:12,000 --> 00:26:14,000
и вуаля, не более запрос на серийный номер.

476
00:26:14,000 --> 00:26:16,000
Как это работает?

477
00:26:16,000 --> 00:26:21,000
Во многих случаях эти вещи просто найти в компьютерах

478
00:26:21,000 --> 00:26:24,000
Текст сегментов в реальной нули компьютера и те,

479
00:26:24,000 --> 00:26:28,000
где это функция, где серийный номер просил,

480
00:26:28,000 --> 00:26:31,000
и перезаписи, что пространство или во время выполнения программы

481
00:26:31,000 --> 00:26:33,000
Вы можете выяснить, где ключ хранится на самом деле

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

483
00:26:37,000 --> 00:26:40,000
Это не означает, что это наша цель на ближайшие пару дней,

484
00:26:40,000 --> 00:26:42,000
но она имеет очень реальные последствия.

485
00:26:42,000 --> 00:26:45,000
Тот происходит привлечь кражу программного обеспечения,

486
00:26:45,000 --> 00:26:47,000
но есть также компромисс всей машины.

487
00:26:47,000 --> 00:26:50,000
>> В самом деле, когда веб-сайты в эти дни эксплуатируется

488
00:26:50,000 --> 00:26:53,000
и скомпрометирован и данные просочились и пароли были украдены

489
00:26:53,000 --> 00:26:58,000
это очень часто связано с плохим управлением своей памяти,

490
00:26:58,000 --> 00:27:01,000
или, в случае баз данных, неспособность предвидеть

491
00:27:01,000 --> 00:27:03,000
состязательности вход, так что больше на том, что в ближайшие недели,

492
00:27:03,000 --> 00:27:07,000
а сейчас просто предварительный просмотр рода ущерб, который вы можете сделать

493
00:27:07,000 --> 00:27:11,000
, не совсем понимая, как все это работает под капотом.

494
00:27:11,000 --> 00:27:14,000
Давайте идти о понимая, почему это не работает

495
00:27:14,000 --> 00:27:17,000
с инструментом, который будет становиться все более и более полезными

496
00:27:17,000 --> 00:27:19,000
как наши программы становятся все более сложными.

497
00:27:19,000 --> 00:27:21,000
До сих пор, когда у вас была ошибка в вашей программе

498
00:27:21,000 --> 00:27:23,000
как вы ушли об отладке это?

499
00:27:23,000 --> 00:27:25,000
Что ваши методы были до сих пор, учил ли ваша TF

500
00:27:25,000 --> 00:27:27,000
или просто самоучка?

501
00:27:27,000 --> 00:27:29,000
[Студент] Printf.

502
00:27:29,000 --> 00:27:31,000
Printf, так Printf, вероятно, был вашим другом в том, что если вы хотите увидеть

503
00:27:31,000 --> 00:27:33,000
что происходит внутри вашей программы

504
00:27:33,000 --> 00:27:36,000
вы просто положить Printf здесь, Printf здесь, Printf здесь.

505
00:27:36,000 --> 00:27:38,000
Тогда вы запустите его, и вы получите целую кучу вещей на экране

506
00:27:38,000 --> 00:27:43,000
, которые можно использовать, чтобы затем определить, что на самом деле происходит не так в вашей программе.

507
00:27:43,000 --> 00:27:45,000
>> Printf, как правило, очень мощная вещь,

508
00:27:45,000 --> 00:27:47,000
но это очень ручной процесс.

509
00:27:47,000 --> 00:27:49,000
Вы должны поставить Printf здесь, Printf здесь,

510
00:27:49,000 --> 00:27:51,000
и если вы поместите его внутри цикла вы можете получить 100 линий

511
00:27:51,000 --> 00:27:53,000
продукции, которые затем нужно просеять через.

512
00:27:53,000 --> 00:27:58,000
Это не очень удобно или интерактивный механизм для отладки программ,

513
00:27:58,000 --> 00:28:00,000
но, к счастью, существует альтернативы.

514
00:28:00,000 --> 00:28:03,000
Там в программе, например, называют GDB, GNU Debugger,

515
00:28:03,000 --> 00:28:06,000
который немного тайной в том, как вы его используете.

516
00:28:06,000 --> 00:28:08,000
Это немного сложно, но, откровенно говоря,

517
00:28:08,000 --> 00:28:11,000
это одна из тех вещей, где, если вы положите в эту неделю и следующую

518
00:28:11,000 --> 00:28:14,000
дополнительный час, чтобы что-то понять, как GDB

519
00:28:14,000 --> 00:28:18,000
это сэкономит вам, вероятно, десятки часов в долгосрочной перспективе,

520
00:28:18,000 --> 00:28:21,000
Так с этим, позвольте мне дать вам тизер, как эта штука работает.

521
00:28:21,000 --> 00:28:23,000
>> Я в моем окне терминала.

522
00:28:23,000 --> 00:28:26,000
Позвольте мне идти вперед и скомпилировать эту программу, buggy3.

523
00:28:26,000 --> 00:28:28,000
Он уже в курсе.

524
00:28:28,000 --> 00:28:31,000
Позвольте мне запустить его так же, как мы делали некоторое время назад, и, действительно, она сломана.

525
00:28:31,000 --> 00:28:34,000
Но почему это происходит? Может быть, я облажался своп функции.

526
00:28:34,000 --> 00:28:37,000
Может быть, это и Ъ. Я не совсем их перемещением правильно.

527
00:28:37,000 --> 00:28:39,000
Позвольте мне идти вперед и делать это.

528
00:28:39,000 --> 00:28:43,000
Вместо того, чтобы просто запустить buggy3 позвольте мне вместо запуска этой программы GDB,

529
00:28:43,000 --> 00:28:48,000
и я собираюсь сказать ему, чтобы запустить buggy3,

530
00:28:48,000 --> 00:28:52,000
и я собираюсь включить параметр командной строки,-туй,

531
00:28:52,000 --> 00:28:55,000
и мы поместим это в будущем проблем в спецификации, чтобы напомнить.

532
00:28:55,000 --> 00:28:57,000
И вот теперь этот черно-белый интерфейс выскочил, что, опять же,

533
00:28:57,000 --> 00:28:59,000
немного подавляющим сначала, потому что все это

534
00:28:59,000 --> 00:29:02,000
Информация о гарантии здесь, но по крайней мере есть что-то знакомое.

535
00:29:02,000 --> 00:29:04,000
В верхней части окна находится мой реальный код,

536
00:29:04,000 --> 00:29:08,000
и если я прокрутки вверх здесь, позвольте мне перейти к самой верхней части моего файла,

537
00:29:08,000 --> 00:29:11,000
и, действительно, есть buggy3.c, и обратите внимание, в нижней части этого окна

538
00:29:11,000 --> 00:29:13,000
У меня есть GDB строке.

539
00:29:13,000 --> 00:29:16,000
>> Это не то же самое, как моя нормальная Джон Гарвард строке.

540
00:29:16,000 --> 00:29:19,000
Это подсказка, которая собирается, чтобы позволить мне контролировать GDB.

541
00:29:19,000 --> 00:29:21,000
GDB является отладчиком.

542
00:29:21,000 --> 00:29:24,000
Отладчик это программа, которая позволяет вам идти через

543
00:29:24,000 --> 00:29:27,000
выполнение программы строка за строкой за строкой,

544
00:29:27,000 --> 00:29:30,000
по пути делаем все, что вы хотите программу,

545
00:29:30,000 --> 00:29:33,000
даже вызовом функций, либо искать, что еще более важно,

546
00:29:33,000 --> 00:29:35,000
при значениях различных переменных.

547
00:29:35,000 --> 00:29:37,000
Давайте пойдем дальше и сделать это.

548
00:29:37,000 --> 00:29:40,000
Я собираюсь пойти дальше и ввести в беге на оперативное GDB,

549
00:29:40,000 --> 00:29:43,000
так что заметить в левой нижней части экрана, я набрал бежать,

550
00:29:43,000 --> 00:29:45,000
и я попал ввести, и что же, что делать?

551
00:29:45,000 --> 00:29:50,000
Он буквально бежал моя программа, но я на самом деле не вижу большой продолжать здесь

552
00:29:50,000 --> 00:29:55,000
потому что я на самом деле не сказал отладчик

553
00:29:55,000 --> 00:29:57,000
, чтобы приостановить на определенный момент времени.

554
00:29:57,000 --> 00:29:59,000
Просто введите перспективе запускает программу.

555
00:29:59,000 --> 00:30:01,000
Я на самом деле не вижу. Я не могу управлять ею.

556
00:30:01,000 --> 00:30:03,000
>> Вместо этого позвольте мне сделать это.

557
00:30:03,000 --> 00:30:08,000
В этой строке GDB позвольте мне вместо введите перерыва, ввести.

558
00:30:08,000 --> 00:30:10,000
Это не то, что я имел в виду, чтобы напечатать.

559
00:30:10,000 --> 00:30:13,000
Давайте вместо этого ввести перерыв основной.

560
00:30:13,000 --> 00:30:15,000
Другими словами, я хочу установить так называемый останова,

561
00:30:15,000 --> 00:30:18,000
которую назвали потому, что он сломается или паузы

562
00:30:18,000 --> 00:30:21,000
выполнение программы в этом конкретном месте.

563
00:30:21,000 --> 00:30:23,000
Главное это имя моей функции.

564
00:30:23,000 --> 00:30:25,000
Обратите внимание, что GDB является довольно умная.

565
00:30:25,000 --> 00:30:28,000
Он выяснил, что основная происходит, чтобы начать примерно на линии 18

566
00:30:28,000 --> 00:30:32,000
из buggy3.c, а затем заметить здесь, в левом верхнем

567
00:30:32,000 --> 00:30:34,000
B + расположен рядом с линией 18.

568
00:30:34,000 --> 00:30:38,000
Это напоминает мне, что я поставил точку останова на строке 18.

569
00:30:38,000 --> 00:30:42,000
Это время, когда я печатаю перспективе, я собираюсь запустить мою программу

570
00:30:42,000 --> 00:30:45,000
До она попадает, что останова,

571
00:30:45,000 --> 00:30:48,000
так что программа будет приостановлена ​​для меня в строке 18.

572
00:30:48,000 --> 00:30:50,000
Здесь мы идем, бежать.

573
00:30:50,000 --> 00:30:53,000
Ничто, кажется, случилось, но обратите внимание на левый нижний

574
00:30:53,000 --> 00:30:58,000
начиная программу, buggy3, останова 1 в основной buggy3.c на линии 18.

575
00:30:58,000 --> 00:31:00,000
Что я могу сделать сейчас?

576
00:31:00,000 --> 00:31:03,000
>> Обратите внимание, я могу начать печатать такие вещи, как печать,

577
00:31:03,000 --> 00:31:08,000
Не Printf, печать х, и сейчас это странно.

578
00:31:08,000 --> 00:31:11,000
$ 1 это просто любопытство, как мы увидим

579
00:31:11,000 --> 00:31:14,000
каждый раз, когда вы печатаете то, что вы получите новый $ значение.

580
00:31:14,000 --> 00:31:18,000
Вот, так что вы можете вернуться к предыдущим значениям на всякий случай,

581
00:31:18,000 --> 00:31:21,000
но сейчас то, что печать говорит мне, что значение х в этот момент в истории

582
00:31:21,000 --> 00:31:26,000
видимо 134514032.

583
00:31:26,000 --> 00:31:29,000
Что? Где, что даже взялся?

584
00:31:29,000 --> 00:31:31,000
[Неразборчиво-студент]

585
00:31:31,000 --> 00:31:34,000
В самом деле, это то, что мы называем мусором значение, и мы не говорили по этому поводу,

586
00:31:34,000 --> 00:31:37,000
но причина, что вы инициализация переменных

587
00:31:37,000 --> 00:31:40,000
Очевидно, так что они имеют некоторое значение, которое вы хотите их иметь.

588
00:31:40,000 --> 00:31:44,000
Но улов напомнить, что вы можете объявлять переменные

589
00:31:44,000 --> 00:31:46,000
как я минуту назад в моем примере сигма

590
00:31:46,000 --> 00:31:48,000
, фактически не давая им значения.

591
00:31:48,000 --> 00:31:50,000
Напомним, что я сделал здесь, в сигма.

592
00:31:50,000 --> 00:31:52,000
Я заявил, п, но какое значение я дать ему?

593
00:31:52,000 --> 00:31:56,000
Нет, потому что я знал, что в ближайшие несколько строк

594
00:31:56,000 --> 00:31:59,000
GetInt будет заботиться о проблеме положить значение внутри н.

595
00:31:59,000 --> 00:32:02,000
>> Но в этот момент в истории строке 11

596
00:32:02,000 --> 00:32:05,000
и 12 линией и линией 13 и строка 14

597
00:32:05,000 --> 00:32:08,000
в течение этих нескольких строках то, что значение п?

598
00:32:08,000 --> 00:32:10,000
В C Вы просто не знаю.

599
00:32:10,000 --> 00:32:14,000
Это вообще какая-то фигня значение, некоторые совершенно случайное число

600
00:32:14,000 --> 00:32:17,000
что остается за главным образом из некоторых предыдущих функций

601
00:32:17,000 --> 00:32:21,000
будучи работать, так как ваша программа работает

602
00:32:21,000 --> 00:32:24,000
Напомним, что функция получает функции, функции, функции.

603
00:32:24,000 --> 00:32:27,000
Все эти кадры получить положить на память, а затем эти функции возвращают,

604
00:32:27,000 --> 00:32:31,000
и так же, как я предложил, с ластиком их памяти, в конечном счете повторно.

605
00:32:31,000 --> 00:32:37,000
Ну, так уж случилось, что эта переменная х в этой программе

606
00:32:37,000 --> 00:32:41,000
по-видимому, содержит некоторые мусора значение, как 134514032

607
00:32:41,000 --> 00:32:44,000
от некоторых предыдущих функции, а не тот, который я написал.

608
00:32:44,000 --> 00:32:47,000
Это может быть что-то, что приходит эффективно с операционной системой,

609
00:32:47,000 --> 00:32:49,000
некоторые функции под капотом.

610
00:32:49,000 --> 00:32:52,000
>> Ладно, это хорошо, но давайте теперь перейти к следующей строке.

611
00:32:52,000 --> 00:32:55,000
Если я типа "Следующий" на GDB мои строки, и я ударил войти,

612
00:32:55,000 --> 00:32:58,000
заметить, что выделение движется вниз к линии 19,

613
00:32:58,000 --> 00:33:01,000
но логический подразумевается, что строка 18

614
00:33:01,000 --> 00:33:06,000
В настоящее время закончил работу, так что если я еще раз введите "печать х"

615
00:33:06,000 --> 00:33:10,000
Я должен появиться 1, и, действительно, я делаю.

616
00:33:10,000 --> 00:33:14,000
Опять же, $ вещей является способом GDB напоминать вам

617
00:33:14,000 --> 00:33:17,000
что история отпечатки, что вы сделали.

618
00:33:17,000 --> 00:33:21,000
Теперь позвольте мне идти вперед и распечатать у, и, действительно, у есть некоторые сумасшедшие значения, а также,

619
00:33:21,000 --> 00:33:24,000
но не большая проблема, потому что в строке 19 мы собираемся назначить его

620
00:33:24,000 --> 00:33:27,000
значение 2, так что позвольте мне ввести "Следующий" еще раз.

621
00:33:27,000 --> 00:33:29,000
И сейчас мы находимся на Printf линии.

622
00:33:29,000 --> 00:33:31,000
Позвольте мне сделать печать х.

623
00:33:31,000 --> 00:33:34,000
Позвольте мне сделать печать у. Честно говоря, я уже немного устал от этой печати.

624
00:33:34,000 --> 00:33:38,000
Позвольте мне вместо этого ввести "дисплей X" и "Y Дисплей",

625
00:33:38,000 --> 00:33:41,000
и теперь каждый раз, когда я введите команду в будущем

626
00:33:41,000 --> 00:33:45,000
Я буду напомнил о том, что это х и у, что х и у, что х и у.

627
00:33:45,000 --> 00:33:48,000
>> Я также могу, а в сторону, типа "Информация местными жителями".

628
00:33:48,000 --> 00:33:50,000
Информация является специальной командой.

629
00:33:50,000 --> 00:33:52,000
Местные жители означает, что он показывает мне локальные переменные.

630
00:33:52,000 --> 00:33:55,000
На всякий случай я забыл, или это сумасшедшая, сложная функция

631
00:33:55,000 --> 00:33:57,000
что я или кто-то другой писал Информация местные жители скажут вам,

632
00:33:57,000 --> 00:34:00,000
что все локальные переменные внутри этой локальной функции

633
00:34:00,000 --> 00:34:03,000
что вы могли бы заботиться о том, если вы хотите, чтобы ткнуть вокруг.

634
00:34:03,000 --> 00:34:07,000
Теперь, Printf собирается выполнять, поэтому позвольте мне идти вперед и только типа "Далее".

635
00:34:07,000 --> 00:34:10,000
Потому что мы в этой среде мы на самом деле не видя его

636
00:34:10,000 --> 00:34:14,000
выполнить здесь, но заметил, что это становится немного искаженное здесь.

637
00:34:14,000 --> 00:34:17,000
Но обратите внимание, что это переопределение экрана есть,

638
00:34:17,000 --> 00:34:21,000
так что это не идеальная программа здесь, но это нормально, потому что я всегда могу копаться

639
00:34:21,000 --> 00:34:23,000
использованием печати, если я хочу.

640
00:34:23,000 --> 00:34:26,000
>> Позвольте мне ввести следующий раз, и вот теперь самое интересное.

641
00:34:26,000 --> 00:34:29,000
На данный момент в этой истории у 2, а х 1,

642
00:34:29,000 --> 00:34:32,000
как предложено здесь, и снова,

643
00:34:32,000 --> 00:34:35,000
Причиной этого автоматически отображаются сейчас, потому что я использовал команду

644
00:34:35,000 --> 00:34:40,000
Дисплей х и у дисплея, так что момент, когда я введите следующую

645
00:34:40,000 --> 00:34:43,000
В теории х и у должны стать местами.

646
00:34:43,000 --> 00:34:45,000
Теперь мы уже знаем, что не собирается быть в случае,

647
00:34:45,000 --> 00:34:49,000
но мы увидим через мгновение, как мы можем нырять глубже, чтобы выяснить, почему это так.

648
00:34:49,000 --> 00:34:54,000
Далее, и, к сожалению, у еще 2 и х еще 1, и я могу подтвердить, как много.

649
00:34:54,000 --> 00:34:56,000
Печать х, у печати.

650
00:34:56,000 --> 00:34:59,000
Действительно, ни замена произошло на самом деле, так что давайте начнем над этим.

651
00:34:59,000 --> 00:35:01,000
Ясно, что своп сломан.

652
00:35:01,000 --> 00:35:04,000
Давайте вместо этого ввести "Выполнить".

653
00:35:04,000 --> 00:35:07,000
Позвольте мне сказать, да, я хочу, чтобы перезапустить его с самого начала, ввести.

654
00:35:07,000 --> 00:35:09,000
>> Теперь я обратно в строке 18.

655
00:35:09,000 --> 00:35:11,000
Теперь обратите внимание х и у мусорных значения снова.

656
00:35:11,000 --> 00:35:15,000
Следующий, следующий, следующий, следующий.

657
00:35:15,000 --> 00:35:17,000
Если я получаю скучно я могу просто введите п для следующего.

658
00:35:17,000 --> 00:35:21,000
Вы можете сократить его в кратчайшие последовательность символов.

659
00:35:21,000 --> 00:35:23,000
Сменный теперь сломана.

660
00:35:23,000 --> 00:35:25,000
Давайте погрузимся в, так что вместо того, чтобы печатать дальше,

661
00:35:25,000 --> 00:35:30,000
Теперь я собираюсь ввести шагом, так что я активизации внутри этой функции

662
00:35:30,000 --> 00:35:33,000
так что я могу пройти через это, так что я ударил шаг, а затем ввести.

663
00:35:33,000 --> 00:35:37,000
Обратите внимание, что выделение скачки вниз ниже в моей программе линии 36.

664
00:35:37,000 --> 00:35:39,000
Теперь то, что являются локальные переменные?

665
00:35:39,000 --> 00:35:41,000
Информация местные жители.

666
00:35:41,000 --> 00:35:43,000
Ничто не просто еще и потому, что мы не дошли до этой строки,

667
00:35:43,000 --> 00:35:47,000
так что давайте идти вперед и сказать: "Следующий".

668
00:35:47,000 --> 00:35:50,000
Теперь мы, кажется, TMP, печать TMP.

669
00:35:50,000 --> 00:35:52,000
Мусор значение, не так ли? Я так думаю.

670
00:35:52,000 --> 00:35:55,000
Как насчет печать, печать б, 1 и 2?

671
00:35:55,000 --> 00:35:58,000
В момент, как только я набираю следующий раз

672
00:35:58,000 --> 00:36:02,000
TMP будет принимать значение 1, мы надеемся,

673
00:36:02,000 --> 00:36:05,000
TMP, потому что собирается быть присвоено значение.

674
00:36:05,000 --> 00:36:08,000
>> Теперь давайте сделаем печать, печать б,

675
00:36:08,000 --> 00:36:11,000
но теперь печати TMP, и это действительно 1.

676
00:36:11,000 --> 00:36:14,000
Позвольте мне делать дальше. Позвольте мне делать дальше.

677
00:36:14,000 --> 00:36:16,000
Я закончил своп функции.

678
00:36:16,000 --> 00:36:19,000
Я все еще внутри него в строке 40, так что позвольте мне печать,

679
00:36:19,000 --> 00:36:22,000
б печати, и я не волнует, что TMP есть.

680
00:36:22,000 --> 00:36:27,000
Похоже, что своп правильно, когда дело доходит до замены и б.

681
00:36:27,000 --> 00:36:31,000
Но если я сейчас введите следующую, я чтобы вернуться к строке 25,

682
00:36:31,000 --> 00:36:34,000
и, конечно, если я типа х и печати у

683
00:36:34,000 --> 00:36:38,000
они по-прежнему без изменений, так что мы не решили проблему.

684
00:36:38,000 --> 00:36:41,000
Но диагностически сейчас, пожалуй, с этой программой GDB

685
00:36:41,000 --> 00:36:44,000
Мы по крайней мере, получил один шаг ближе к пониманию

686
00:36:44,000 --> 00:36:47,000
что происходит не так, не засорять наш код, поставив Printf здесь,

687
00:36:47,000 --> 00:36:50,000
Printf здесь, Printf здесь, а затем запустить его снова и снова

688
00:36:50,000 --> 00:36:52,000
пытается выяснить, что происходит не так.

689
00:36:52,000 --> 00:36:55,000
>> Я собираюсь идти вперед и выйти из этого всего с курить.

690
00:36:55,000 --> 00:36:57,000
Это будет сказать: "Все равно выйти?" Да.

691
00:36:57,000 --> 00:37:00,000
Сейчас я вернулся в мой нормальный строки, и я сделано с помощью GDB.

692
00:37:00,000 --> 00:37:03,000
Как в стороне, вы не должны использовать эту-туй флаг.

693
00:37:03,000 --> 00:37:07,000
В самом деле, если вы пропустите его, то получите по существу в нижней половине экрана.

694
00:37:07,000 --> 00:37:11,000
Если бы я затем введите перерыв основной, а затем запустите

695
00:37:11,000 --> 00:37:15,000
Я все еще можно запускать мою программу, но что он будет делать более текстуально

696
00:37:15,000 --> 00:37:18,000
просто покажите мне текущем одну строку за один раз.

697
00:37:18,000 --> 00:37:21,000
-Туй, текстовый пользовательский интерфейс,

698
00:37:21,000 --> 00:37:25,000
просто показывает вам несколько программ одновременно, что, вероятно, немного концептуально проще.

699
00:37:25,000 --> 00:37:27,000
Но на самом деле, я могу просто сделать следующий, следующий, следующий,

700
00:37:27,000 --> 00:37:30,000
и я иду к одной строке за один раз, и если я действительно хочу видеть, что происходит на

701
00:37:30,000 --> 00:37:35,000
Я могу напечатать список и увидеть целую кучу соседних линий.

702
00:37:35,000 --> 00:37:39,000
>> Там есть видео, которое мы просили, что вы следите за проблемы устанавливает 3

703
00:37:39,000 --> 00:37:43,000
, в котором Nate покрывает некоторые из тонкостей GDB,

704
00:37:43,000 --> 00:37:46,000
и это одна из тех вещей, честно говоря, где некоторые нетривиальные процент вы

705
00:37:46,000 --> 00:37:49,000
никогда не коснется GDB, и это будет плохо

706
00:37:49,000 --> 00:37:53,000
потому что буквально вы будете в конечном итоге тратят больше времени в этом семестре

707
00:37:53,000 --> 00:37:56,000
гоняться за ошибки, то вы бы, если бы вы положили в том, что полчаса / час

708
00:37:56,000 --> 00:38:00,000
На этой неделе и в следующем обучения, чтобы освоиться с GDB.

709
00:38:00,000 --> 00:38:02,000
Printf был вашим другом.

710
00:38:02,000 --> 00:38:05,000
GDB должен теперь быть вашим другом.

711
00:38:05,000 --> 00:38:08,000
>> Любые вопросы по GDB?

712
00:38:08,000 --> 00:38:12,000
И вот краткий список некоторых из наиболее мощных и полезных команд.

713
00:38:12,000 --> 00:38:15,000
Да. >> Можно ли печатать строку?

714
00:38:15,000 --> 00:38:17,000
Вы можете печатать строку? Совершенно верно.

715
00:38:17,000 --> 00:38:19,000
Это не должны быть просто целые числа.

716
00:38:19,000 --> 00:38:22,000
Если переменная а представляет собой строку, просто наберите в печати с.

717
00:38:22,000 --> 00:38:24,000
Он покажет вам, что это строка переменной.

718
00:38:24,000 --> 00:38:26,000
[Неразборчиво-студент]

719
00:38:26,000 --> 00:38:28,000
Это даст вам адрес и саму строку.

720
00:38:28,000 --> 00:38:32,000
Он покажет вам обоим.

721
00:38:32,000 --> 00:38:34,000
И еще одна последняя вещь, только потому, что это хорошо, чтобы знать тоже.

722
00:38:34,000 --> 00:38:37,000
Backtrace и рамы, позвольте мне погрузиться в это в последний раз,

723
00:38:37,000 --> 00:38:39,000
точно такой же программе с GDB.

724
00:38:39,000 --> 00:38:44,000
Позвольте мне идти вперед и запустить текстовую версию пользовательского интерфейса,

725
00:38:44,000 --> 00:38:46,000
разбить основные.

726
00:38:46,000 --> 00:38:49,000
Позвольте мне идти вперед и бежать снова. Вот я.

727
00:38:49,000 --> 00:38:55,000
Теперь позвольте мне идти дальше, дальше, дальше, дальше, дальше, шаг, ввести.

728
00:38:55,000 --> 00:39:00,000
>> А теперь предположим, что я сейчас в своп намеренно, но я, как "Черт, что было значение х?"

729
00:39:00,000 --> 00:39:02,000
Я не могу сделать больше х.

730
00:39:02,000 --> 00:39:05,000
Я не могу сделать у, потому что они не входят в комплект.

731
00:39:05,000 --> 00:39:07,000
Они не в контексте, но не проблема.

732
00:39:07,000 --> 00:39:09,000
Я могу напечатать след.

733
00:39:09,000 --> 00:39:13,000
Это показывает мне все функции, которые выполняются до этого момента времени.

734
00:39:13,000 --> 00:39:16,000
Обратите внимание, что один на дно, главное, на одной линии с основными

735
00:39:16,000 --> 00:39:18,000
находясь на нижней части нашей картины здесь.

736
00:39:18,000 --> 00:39:22,000
Тот факт, что своп выше линии с своп быть выше его в памяти здесь,

737
00:39:22,000 --> 00:39:26,000
и если я хочу вернуться к основной временной я могу сказать "рамку".

738
00:39:26,000 --> 00:39:30,000
Какой номер? Главное это кадр № 1.

739
00:39:30,000 --> 00:39:32,000
Я собираюсь идти вперед и сказать: "кадр 1".

740
00:39:32,000 --> 00:39:36,000
>> Сейчас я вернулся в основной, и я могу печатать х, и я могу напечатать у,

741
00:39:36,000 --> 00:39:40,000
но я не могу распечатать или б.

742
00:39:40,000 --> 00:39:43,000
Но я могу, если я скажу: «Хорошо, подождите минутку. Где был своп?"

743
00:39:43,000 --> 00:39:46,000
Позвольте мне идти вперед и сказать: "кадр 0".

744
00:39:46,000 --> 00:39:48,000
Сейчас я там, где я хочу быть, и в сторону,

745
00:39:48,000 --> 00:39:52,000
есть другие команды тоже, как если бы вы действительно скучно набрав следующий, следующий, следующий, следующий,

746
00:39:52,000 --> 00:39:56,000
Вы можете вообще сказать что-то вроде "следующие 10", и что уйдет в течение следующих 10 строк.

747
00:39:56,000 --> 00:39:59,000
Вы также можете написать "продолжить", когда вы действительно устаете от пошагового он.

748
00:39:59,000 --> 00:40:05,000
Продолжайте будет запустить программу без перерыва, пока не встретит другую точку останова,

749
00:40:05,000 --> 00:40:07,000
будь то в петлю или ниже в вашу программу.

750
00:40:07,000 --> 00:40:11,000
>> В этом случае мы продолжали до конца, и программа нормально завершился.

751
00:40:11,000 --> 00:40:13,000
Это причудливый способ, уступает процесса.

752
00:40:13,000 --> 00:40:16,000
Просто ваша программа нормально завершился.

753
00:40:16,000 --> 00:40:24,000
Подробнее об этом в видео и в отладке сессий в будущем.

754
00:40:24,000 --> 00:40:26,000
Это было много.

755
00:40:26,000 --> 00:40:35,000
Давайте возьмем наш 5-минутный перерыв здесь, и мы вернемся с структурам и файлов.

756
00:40:35,000 --> 00:40:38,000
>> Если вы нырнули в PSET на этой неделе уже

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

758
00:40:41,000 --> 00:40:45,000
исходный код, который мы предоставляем вам в качестве отправной точки, некоторые новые методы.

759
00:40:45,000 --> 00:40:50,000
В частности, мы ввели это новое ключевое слово называется структура, для структуры,

760
00:40:50,000 --> 00:40:53,000
так что мы можем создавать пользовательские переменные сортов.

761
00:40:53,000 --> 00:40:57,000
Мы также ввели понятие файла I / O, файлового ввода и вывода,

762
00:40:57,000 --> 00:41:00,000
и это так, что мы можем сохранить состояние

763
00:41:00,000 --> 00:41:03,000
Вашей Scramble платы в файл на диске

764
00:41:03,000 --> 00:41:06,000
так что обучение стипендиатов и я могу понять

765
00:41:06,000 --> 00:41:09,000
что происходит внутри вашей программы без необходимости вручную играть

766
00:41:09,000 --> 00:41:11,000
десятки игр Scramble.

767
00:41:11,000 --> 00:41:13,000
Мы можем сделать это более automatedly.

768
00:41:13,000 --> 00:41:18,000
>> Эта идея структуры решает довольно убедительные проблемы.

769
00:41:18,000 --> 00:41:21,000
Предположим, что мы хотим реализовать некоторые программы

770
00:41:21,000 --> 00:41:25,000
что каким-то образом отслеживает информацию о студентах,

771
00:41:25,000 --> 00:41:28,000
и студенты могли бы иметь, например, ID, имя,

772
00:41:28,000 --> 00:41:31,000
и дом в таком месте, как Гарвард, поэтому эти 3 части информации

773
00:41:31,000 --> 00:41:34,000
мы хотим, чтобы вокруг, так что позвольте мне идти вперед и начать писать небольшую программу здесь,

774
00:41:34,000 --> 00:41:38,000
включает stdio.h.

775
00:41:38,000 --> 00:41:42,000
Позвольте мне сделать включать cs50.h.

776
00:41:42,000 --> 00:41:44,000
А потом начать свою основную функцию.

777
00:41:44,000 --> 00:41:46,000
Я не буду с любыми аргументами командной строки,

778
00:41:46,000 --> 00:41:49,000
и вот я хочу, чтобы студент, так что я собираюсь сказать,

779
00:41:49,000 --> 00:41:54,000
Студент имеет имя, так что я собираюсь сказать "строка имя".

780
00:41:54,000 --> 00:41:59,000
Тогда я собирался сказать студент также имеет идентификатор, так Int Идентификатор,

781
00:41:59,000 --> 00:42:03,000
и студент имеет дом, поэтому я также хотел сказать "строка дом".

782
00:42:03,000 --> 00:42:06,000
Тогда я закажу эти немного более аккуратно, как это.

783
00:42:06,000 --> 00:42:11,000
Хорошо, теперь у меня есть 3 переменные, с которыми представляют студента, так что "студент".

784
00:42:11,000 --> 00:42:15,000
>> А теперь я хочу, чтобы заполнить эти ценности, так что позвольте мне идти вперед и сказать что-то вроде:

785
00:42:15,000 --> 00:42:18,000
"ID = 123".

786
00:42:18,000 --> 00:42:21,000
Имя собирается получить Давида.

787
00:42:21,000 --> 00:42:24,000
Скажем, дом собирается получить Mather,

788
00:42:24,000 --> 00:42:31,000
, а затем я собираюсь сделать что-то произвольно, как Е ("% S,

789
00:42:31,000 --> 00:42:37,000
с идентификатором% D,% проживает в с.

790
00:42:37,000 --> 00:42:41,000
А теперь, что я хочу подключить сюда, один за другим?

791
00:42:41,000 --> 00:42:47,000
Имя, идентификатор, дом, возвращается 0.

792
00:42:47,000 --> 00:42:50,000
Хорошо, если я облажался где-то здесь

793
00:42:50,000 --> 00:42:54,000
Я думаю, что у нас есть довольно хорошая программа, которая хранит один студент.

794
00:42:54,000 --> 00:42:57,000
Конечно, это не все, что интересно. Что делать, если я хочу иметь 2 студента?

795
00:42:57,000 --> 00:42:59,000
Это не большая проблема. Я могу поддерживать 2 человек.

796
00:42:59,000 --> 00:43:03,000
Позвольте мне пойти дальше и выделить это и спуститься сюда,

797
00:43:03,000 --> 00:43:09,000
и я могу сказать "ID = 456" для кого-то, как Роб, который живет в Kirkland.

798
00:43:09,000 --> 00:43:12,000
>> Ладно, подожди, но я не могу назвать это то же самое,

799
00:43:12,000 --> 00:43:15,000
и, похоже, я буду иметь, чтобы скопировать это,

800
00:43:15,000 --> 00:43:19,000
так что позвольте мне сказать, что это будут переменные Давида,

801
00:43:19,000 --> 00:43:23,000
и позвольте мне получить копии этих Роба.

802
00:43:23,000 --> 00:43:27,000
Мы называем эти Роба, но это не будет работать сейчас

803
00:43:27,000 --> 00:43:33,000
потому что я-подождите, давайте изменим меня id1, name1 и House1.

804
00:43:33,000 --> 00:43:35,000
Роб будет 2, 2.

805
00:43:35,000 --> 00:43:42,000
Я должен изменить это здесь, здесь, здесь, здесь, здесь, здесь.

806
00:43:42,000 --> 00:43:45,000
Подождите, а как же Томми? Давайте сделаем это снова.

807
00:43:45,000 --> 00:43:49,000
Очевидно, что если вы все еще думаете, что это хороший способ сделать это, это не так,

808
00:43:49,000 --> 00:43:52,000
так копировать / вставить плохо.

809
00:43:52,000 --> 00:43:55,000
Но мы решили эту неделю назад.

810
00:43:55,000 --> 00:43:59,000
>> Что это было наше решение, когда мы хотели иметь несколько экземпляров одного и того же типа данных?

811
00:43:59,000 --> 00:44:01,000
[Студенты] массива.

812
00:44:01,000 --> 00:44:03,000
Массива, так что позвольте мне попытаться очистить это.

813
00:44:03,000 --> 00:44:07,000
Позвольте мне сделать несколько номеров для себя на вершине, и позвольте мне вместо этого здесь.

814
00:44:07,000 --> 00:44:12,000
Мы называем этих людей, а вместо этого я собираюсь сказать "Int идентификаторы"

815
00:44:12,000 --> 00:44:14,000
и я собираюсь поддержать 3 из нас в настоящее время.

816
00:44:14,000 --> 00:44:18,000
Я собираюсь сказать "строка имен", и я буду поддерживать 3 из нас,

817
00:44:18,000 --> 00:44:22,000
и тогда я буду говорить "строка дома", и я буду поддерживать 3 из нас.

818
00:44:22,000 --> 00:44:26,000
Теперь здесь вместо Давида получать свои локальные переменные

819
00:44:26,000 --> 00:44:28,000
Мы можем избавиться от них.

820
00:44:28,000 --> 00:44:30,000
Это чувствует себя хорошо, что мы очистка это.

821
00:44:30,000 --> 00:44:35,000
Затем я могу сказать Дэвид будет [0] и имен [0]

822
00:44:35,000 --> 00:44:38,000
и дома [0].

823
00:44:38,000 --> 00:44:41,000
А потом Роб аналогично можно сэкономить на этом.

824
00:44:41,000 --> 00:44:46,000
Давайте поставим это здесь, так что он собирается быть произвольно идентификаторов [1].

825
00:44:46,000 --> 00:44:50,000
Он собирается быть имена [1],

826
00:44:50,000 --> 00:44:53,000
, а затем, наконец, дома [1].

827
00:44:53,000 --> 00:44:57,000
>> Еще немного утомительно, и теперь у меня есть, чтобы понять это,

828
00:44:57,000 --> 00:45:03,000
так скажем, "имена [0], ID [0], дома [0],

829
00:45:03,000 --> 00:45:06,000
и давайте множественном числе это.

830
00:45:06,000 --> 00:45:09,000
Идентификаторы, идентификаторы, идентификаторы.

831
00:45:09,000 --> 00:45:12,000
И опять же, я делаю это, так снова, я уже прибегая к копировать / вставить снова,

832
00:45:12,000 --> 00:45:14,000
так что шансы есть другое решение здесь.

833
00:45:14,000 --> 00:45:18,000
Я, вероятно, может очистить это далее с петлей или что-то вроде этого,

834
00:45:18,000 --> 00:45:21,000
Короче говоря, это немного лучше, но все еще чувствует себя

835
00:45:21,000 --> 00:45:24,000
Я прибегая к копировать / вставить, но даже это, я утверждаю,

836
00:45:24,000 --> 00:45:27,000
на самом деле не принципиально правильное решение, потому что

837
00:45:27,000 --> 00:45:29,000
Что делать, если когда-нибудь мы решим вы знаете, что?

838
00:45:29,000 --> 00:45:32,000
Мы действительно должны были хранения адресов электронной почты для Дэвида и Роб

839
00:45:32,000 --> 00:45:34,000
и все остальное в этой программе.

840
00:45:34,000 --> 00:45:36,000
Мы должны также сохранять телефонные номера.

841
00:45:36,000 --> 00:45:39,000
Мы должны также сохранять номера экстренной связи.

842
00:45:39,000 --> 00:45:41,000
У нас есть все эти фрагменты данных, которые мы хотим сохранить,

843
00:45:41,000 --> 00:45:43,000
так как вы идете для этого сделать?

844
00:45:43,000 --> 00:45:46,000
>> Вы объявляете другой массив в верхней части, а затем вручную добавить

845
00:45:46,000 --> 00:45:49,000
адрес электронной почты [0], адрес электронной почты [1]

846
00:45:49,000 --> 00:45:51,000
для Дэвида и Роб и так далее.

847
00:45:51,000 --> 00:45:56,000
Но на самом деле всего лишь предположение, лежащие в основе этой конструкции

848
00:45:56,000 --> 00:45:59,000
что я использую системе чести знать, что

849
00:45:59,000 --> 00:46:03,000
[I] в каждом из нескольких массивов

850
00:46:03,000 --> 00:46:06,000
Просто так случилось, чтобы обратиться к тем же лицом,

851
00:46:06,000 --> 00:46:10,000
так [0] в идентификаторами это номер 123,

852
00:46:10,000 --> 00:46:13,000
и я буду считать, что имена [0]

853
00:46:13,000 --> 00:46:16,000
такое же имя человека и дома [0]

854
00:46:16,000 --> 00:46:21,000
является домом того же самого человека и так далее для всех различных массивов, которые я создаю.

855
00:46:21,000 --> 00:46:24,000
Но обратите внимание, что нет никаких фундаментальных связей

856
00:46:24,000 --> 00:46:27,000
Среди этих 3 частей информации, номер, имя и дом,

857
00:46:27,000 --> 00:46:32,000
даже если лицо мы пытаемся модель в этой программе не массивы.

858
00:46:32,000 --> 00:46:35,000
Массивы являются именно этот программный способ сделать это.

859
00:46:35,000 --> 00:46:38,000
То, что мы действительно хотим, чтобы смоделировать в нашей программе это человек,

860
00:46:38,000 --> 00:46:41,000
как Давид, человек, как Роб, внутри которого

861
00:46:41,000 --> 00:46:46,000
или инкапсуляции это имя и ID и дома.

862
00:46:46,000 --> 00:46:49,000
>> Можем ли мы как-то выразить эту идею инкапсуляции

863
00:46:49,000 --> 00:46:52,000
, при котором человек имеет идентификатор, название и дом

864
00:46:52,000 --> 00:46:55,000
и не прибегать к действительности этот хак которой мы только что

865
00:46:55,000 --> 00:46:58,000
верить, что что-то кронштейн

866
00:46:58,000 --> 00:47:02,000
относится к той же человеческой сущности в каждом из этих разрозненных массивов?

867
00:47:02,000 --> 00:47:04,000
Мы можем реально сделать это.

868
00:47:04,000 --> 00:47:08,000
Позвольте мне пойти выше основного на данный момент, и позвольте мне создать свой собственный тип данных

869
00:47:08,000 --> 00:47:10,000
на самом деле в первый раз.

870
00:47:10,000 --> 00:47:14,000
Мы использовали эту технику в Scramble,

871
00:47:14,000 --> 00:47:17,000
но здесь я собираюсь пойти дальше и создать тип данных,

872
00:47:17,000 --> 00:47:19,000
и вы знаете, что я собираюсь называть это студент или человек,

873
00:47:19,000 --> 00:47:23,000
и я собираюсь использовать ЬурейеЕ для определения типа.

874
00:47:23,000 --> 00:47:25,000
Я хочу сказать, что это структура,

875
00:47:25,000 --> 00:47:29,000
а затем эта структура будет иметь тип студента, мы будем говорить,

876
00:47:29,000 --> 00:47:31,000
хотя это немного датированы теперь для меня.

877
00:47:31,000 --> 00:47:33,000
Мы говорим "Int Идентификатор».

878
00:47:33,000 --> 00:47:35,000
Мы говорим "строку имя".

879
00:47:35,000 --> 00:47:37,000
Тогда мы говорим "Строка дом"

880
00:47:37,000 --> 00:47:40,000
так что теперь до конца эти несколько строк кода

881
00:47:40,000 --> 00:47:45,000
Я только что учил лязг, что существует

882
00:47:45,000 --> 00:47:49,000
Тип данных, кроме целых чисел, кроме строк, кроме того, в два раза, кроме того, поплавки.

883
00:47:49,000 --> 00:47:54,000
>> По состоянию на данный момент времени строка 11, в настоящее время новый тип данных, который называется студентов,

884
00:47:54,000 --> 00:47:58,000
и теперь я могу объявить переменную любой студент я хочу,

885
00:47:58,000 --> 00:48:01,000
так что позвольте мне прокрутите вниз для людей.

886
00:48:01,000 --> 00:48:05,000
Теперь я могу избавиться от этого, и я могу вернуться вниз к Давиду здесь,

887
00:48:05,000 --> 00:48:10,000
и для Дэвида я могу реально сказать, что Давид,

888
00:48:10,000 --> 00:48:13,000
можно буквально назвать переменной после себя,

889
00:48:13,000 --> 00:48:16,000
будет тип студента.

890
00:48:16,000 --> 00:48:18,000
Это может показаться немного странным, но это не все, что отличается

891
00:48:18,000 --> 00:48:22,000
от объявления что-то в виде целого числа или строки или с плавающей точкой.

892
00:48:22,000 --> 00:48:24,000
Просто так случилось, будет называться студентом сейчас,

893
00:48:24,000 --> 00:48:28,000
и если я хочу поставить что-то внутри этой структуры

894
00:48:28,000 --> 00:48:31,000
У меня теперь есть использовать новую часть синтаксиса, но это довольно просто,

895
00:48:31,000 --> 00:48:39,000
david.id = 123, david.name = "Давид" в столице D,

896
00:48:39,000 --> 00:48:42,000
и david.house = "Mather,"

897
00:48:42,000 --> 00:48:46,000
и теперь я могу избавиться от этой вещи здесь.

898
00:48:46,000 --> 00:48:51,000
Обратите внимание, сейчас мы переработали наши программы действительно намного лучше

899
00:48:51,000 --> 00:48:54,000
в том, что теперь наша программа отражает реальный мир.

900
00:48:54,000 --> 00:48:57,000
>> Там в реальном мире понятие человека или студента.

901
00:48:57,000 --> 00:49:02,000
Здесь мы имеем сейчас версии C лица или, более конкретно студента.

902
00:49:02,000 --> 00:49:05,000
Внутри этого человека эти соответствующие характеристики,

903
00:49:05,000 --> 00:49:10,000
ID, имя и дом, так что Роб сути становится то же самое здесь,

904
00:49:10,000 --> 00:49:14,000
так ограбить студента, а теперь rob.id = 456,

905
00:49:14,000 --> 00:49:17,000
rob.name = "Боб".

906
00:49:17,000 --> 00:49:20,000
Тот факт, что переменная называется Rob является своего рода бессмысленными.

907
00:49:20,000 --> 00:49:22,000
Мы могли бы назвал это х или у, или г.

908
00:49:22,000 --> 00:49:25,000
Мы только что назвал его Роб быть семантически последовательным,

909
00:49:25,000 --> 00:49:28,000
но на самом деле зовут внутри этого самого поля,

910
00:49:28,000 --> 00:49:30,000
так что теперь у меня есть.

911
00:49:30,000 --> 00:49:33,000
Это тоже не похоже на лучший дизайн в том, что я жестко Давида.

912
00:49:33,000 --> 00:49:35,000
Я жестко Роб.

913
00:49:35,000 --> 00:49:39,000
И я все еще вынуждены прибегать к некоторым скопируйте и вставьте каждый раз, когда я хочу новых переменных.

914
00:49:39,000 --> 00:49:43,000
Кроме того, я должен по-видимому дать каждой из этих переменных имя,

915
00:49:43,000 --> 00:49:46,000
хотя я бы предпочел описать эти переменные

916
00:49:46,000 --> 00:49:48,000
 в более общем плане, как студенты.

917
00:49:48,000 --> 00:49:52,000
>> Теперь мы можем объединить идеи, которые работают хорошо для нас

918
00:49:52,000 --> 00:49:56,000
и вместо этого сказал: "Знаешь что, дай мне переменную называемую студентов,

919
00:49:56,000 --> 00:50:01,000
и пусть вас это будет размером 3 ", так что теперь я могу уточнить это дальше,

920
00:50:01,000 --> 00:50:04,000
избавиться от ручного заявил Давид,

921
00:50:04,000 --> 00:50:08,000
и я могу, а сказать что-то вроде студентов [0] здесь.

922
00:50:08,000 --> 00:50:11,000
Затем я могу сказать студентов [0] здесь,

923
00:50:11,000 --> 00:50:14,000
Студенты [0] Здесь и так далее, и я могу ходить

924
00:50:14,000 --> 00:50:16,000
и чистый, что для Роба.

925
00:50:16,000 --> 00:50:19,000
Я мог бы также идти об теперь, возможно, добавление петли

926
00:50:19,000 --> 00:50:23,000
и использование GetString и GetInt на самом деле получить эти значения от пользователя.

927
00:50:23,000 --> 00:50:27,000
Я мог бы идти о добавлении постоянной, потому что это вообще плохая практика

928
00:50:27,000 --> 00:50:29,000
на жесткий код некоторые произвольные числа, как 3 прямо здесь

929
00:50:29,000 --> 00:50:33,000
, а затем просто помните, что вы должны поставить не более 3 студентов в нем.

930
00:50:33,000 --> 00:50:36,000
Вероятно, было бы лучше использовать # определить в верхней части моего файла

931
00:50:36,000 --> 00:50:40,000
и фактор, который, таким образом, действительно, дай мне пойти дальше и обобщить это.

932
00:50:40,000 --> 00:50:43,000
>> Позвольте мне открыть примеру, что среди сегодняшних

933
00:50:43,000 --> 00:50:46,000
Примеры заранее, structs1.

934
00:50:46,000 --> 00:50:49,000
Это более полная программа, которая использует # определить здесь

935
00:50:49,000 --> 00:50:51,000
и говорит, что мы собираемся иметь 3 студентов по умолчанию.

936
00:50:51,000 --> 00:50:54,000
Здесь я объявлении класса стоит студентов,

937
00:50:54,000 --> 00:50:57,000
так классе студентов, и теперь я с помощью цикла

938
00:50:57,000 --> 00:51:00,000
только, чтобы сделать код немного более элегантно, заполнить класс

939
00:51:00,000 --> 00:51:05,000
с участием пользователя, так итерации с I = 0 на до студентов, что на 3.

940
00:51:05,000 --> 00:51:07,000
И тогда я предложить пользователю в этой версии

941
00:51:07,000 --> 00:51:10,000
 Что ID студента, и я получаю его с GetInt.

942
00:51:10,000 --> 00:51:13,000
Что имя студента, а потом получить его с GetString.

943
00:51:13,000 --> 00:51:15,000
Что доме студента? Я получаю его с GetString.

944
00:51:15,000 --> 00:51:19,000
А затем в нижней здесь я просто решил изменить

945
00:51:19,000 --> 00:51:22,000
как я печатаю эти, и на самом деле использовать цикл,

946
00:51:22,000 --> 00:51:24,000
И кто я печатью?

947
00:51:24,000 --> 00:51:27,000
В соответствии с комментарием я печатаю никому в Mather,

948
00:51:27,000 --> 00:51:30,000
и вот именно поэтому Роб и Томми и так далее, на самом деле Томми в Mather.

949
00:51:30,000 --> 00:51:34,000
Томми и Дэвид будут напечатаны в этом случае, но как это работает?

950
00:51:34,000 --> 00:51:40,000
Мы не видели эту функцию раньше, но сделать предположение о том, что это делает.

951
00:51:40,000 --> 00:51:42,000
Сравнивает строки.

952
00:51:42,000 --> 00:51:45,000
>> Это немного неочевидным, как он сравнивает строки, потому что оказывается,

953
00:51:45,000 --> 00:51:49,000
если она возвращает 0, что означает, что строки равны.

954
00:51:49,000 --> 00:51:53,000
Если она возвращает -1, что означает, что человек приходит в алфавитном порядке перед другими,

955
00:51:53,000 --> 00:51:57,000
и если она возвращает +1, что означает слово приходит другой в алфавитном порядке

956
00:51:57,000 --> 00:52:00,000
перед другими, и вы можете смотреть онлайн или в справочную страницу

957
00:52:00,000 --> 00:52:04,000
, чтобы увидеть, какой именно способ которую, но все это сейчас делает это говорит

958
00:52:04,000 --> 00:52:09,000
если [I]. Дом равно "Мазер"

959
00:52:09,000 --> 00:52:13,000
затем пойти дальше и распечатать так и так находится в Mather.

960
00:52:13,000 --> 00:52:16,000
Но вот то, что мы раньше не видели, и мы вернемся к этому.

961
00:52:16,000 --> 00:52:21,000
Я не помню, никогда не имея для этого ни в одной из моих программ.

962
00:52:21,000 --> 00:52:24,000
Бесплатные видимо ссылкой на память, освобождая оперативную память,

963
00:52:24,000 --> 00:52:31,000
но то, что память я видимо освобождение в этом цикле в нижней части этой программы?

964
00:52:31,000 --> 00:52:34,000
Похоже, я освобождая имя человека

965
00:52:34,000 --> 00:52:37,000
и дом человека, но зачем это?

966
00:52:37,000 --> 00:52:41,000
>> Оказывается, все эти недели, что вы используете GetString

967
00:52:41,000 --> 00:52:45,000
Мы видов внедряет ошибку в каждой из ваших программ.

968
00:52:45,000 --> 00:52:51,000
GetString памятью дизайн выделяет так что он может вернуться к вам строки,

969
00:52:51,000 --> 00:52:55,000
подобно Давиду, и Роб, и вы можете делать все, что вы хотите

970
00:52:55,000 --> 00:52:59,000
с этой строки в программе, потому что мы защищены памяти для вас.

971
00:52:59,000 --> 00:53:02,000
Проблема в том, все это время каждый раз, когда вы звоните GetString

972
00:53:02,000 --> 00:53:05,000
Мы, авторы GetString, спрашивали операционной системы

973
00:53:05,000 --> 00:53:07,000
, чтобы дать нам немного оперативной памяти для этой строки.

974
00:53:07,000 --> 00:53:09,000
Дайте нам немного ОЗУ для следующей строки.

975
00:53:09,000 --> 00:53:11,000
Дайте нам немного больше оперативной памяти для следующей строки.

976
00:53:11,000 --> 00:53:13,000
То, что вы программист, никогда не делал

977
00:53:13,000 --> 00:53:15,000
дает нам, что память назад,

978
00:53:15,000 --> 00:53:17,000
Таким образом, для этих нескольких недель все программы, вы написали

979
00:53:17,000 --> 00:53:20,000
было то, что называется памятью скачок которой они продолжают использовать

980
00:53:20,000 --> 00:53:24,000
больше и больше памяти при каждом вызове GetString, и это нормально.

981
00:53:24,000 --> 00:53:27,000
Мы сознательно делаем, что в первые недели, потому что это не интересно

982
00:53:27,000 --> 00:53:29,000
, чтобы беспокоиться о том, где строки и откуда.

983
00:53:29,000 --> 00:53:34,000
Все, что вы хотите это слово Робу вернуться, когда пользователь вводит его дюйма

984
00:53:34,000 --> 00:53:38,000
>> Но движение вперед у нас теперь есть, чтобы начать получать более сложные по этому поводу.

985
00:53:38,000 --> 00:53:42,000
Каждый раз, когда мы выделяем память, мы лучше в конечном итоге передать его обратно.

986
00:53:42,000 --> 00:53:45,000
В противном случае в реальном мире на вашем Mac или PC вы, возможно, иногда опытные

987
00:53:45,000 --> 00:53:50,000
Симптомы, где ваш компьютер зависает в конечном итоге

988
00:53:50,000 --> 00:53:54,000
или глупый вращающийся шар пляж находится всего занимают компьютера

989
00:53:54,000 --> 00:53:56,000
все внимание, и вы не можете делать вещи.

990
00:53:56,000 --> 00:54:00,000
Это можно объяснить любое количество ошибок, но среди тех, возможны ошибки

991
00:54:00,000 --> 00:54:03,000
которые, что называется утечка памяти которой тот, кто писал, что часть программного обеспечения

992
00:54:03,000 --> 00:54:07,000
Вы используете не помню, чтобы освободить память

993
00:54:07,000 --> 00:54:10,000
что он или она попросила операционной системы для,

994
00:54:10,000 --> 00:54:14,000
не используется GetString, потому что это CS50 вещь, но с использованием аналогичных функций

995
00:54:14,000 --> 00:54:16,000
спросите, что операционная система на память.

996
00:54:16,000 --> 00:54:19,000
Если вы или они испортить и никогда не вернутся, что память

997
00:54:19,000 --> 00:54:24,000
симптом, который может быть то, что программа замедляется и замедляется и замедляется

998
00:54:24,000 --> 00:54:26,000
если вы помните, чтобы позвонить бесплатно.

999
00:54:26,000 --> 00:54:28,000
>> Мы вернемся, когда и почему вы могли бы назвать свободным,

1000
00:54:28,000 --> 00:54:32,000
Но давайте идти вперед только для хорошей мерой и попробуйте запустить эту конкретную программу.

1001
00:54:32,000 --> 00:54:35,000
Это называется structs1, введите.

1002
00:54:35,000 --> 00:54:40,000
Позвольте мне идти вперед и работать structs1, 123, David Mather,

1003
00:54:40,000 --> 00:54:47,000
456, Rob Kirkland, 789,

1004
00:54:47,000 --> 00:54:50,000
Томми Mather, и мы видим Давида в Mather, Томми в Mather.

1005
00:54:50,000 --> 00:54:53,000
Это всего лишь маленькая проверка вменяемости, что программа работает.

1006
00:54:53,000 --> 00:54:56,000
Сейчас, к сожалению, эта программа является немного расстраивает в том, что

1007
00:54:56,000 --> 00:55:00,000
Я сделал все, что работа, я набрал в 9 различных строк, нажмите ввод,

1008
00:55:00,000 --> 00:55:04,000
сказали, кто был в Mather, но, очевидно, я не знал, кто был в Mather уже потому, что я набрал его.

1009
00:55:04,000 --> 00:55:07,000
Было бы по меньшей мере неплохо, если бы эта программа больше похожа на базу данных

1010
00:55:07,000 --> 00:55:10,000
и он действительно помнит, что я набрал в

1011
00:55:10,000 --> 00:55:12,000
так что я никогда больше не придется вводить эти записи студентов.

1012
00:55:12,000 --> 00:55:15,000
Может быть, это как registrarial системы.

1013
00:55:15,000 --> 00:55:21,000
>> Мы можем сделать это с помощью этого метода, известного как файловый ввод / вывод, файлового ввода и вывода,

1014
00:55:21,000 --> 00:55:24,000
Очень общий способ сказать, что в любое время вы хотите читать файлы или записать файлы

1015
00:55:24,000 --> 00:55:26,000
Вы можете сделать это с определенным набором функций.

1016
00:55:26,000 --> 00:55:29,000
Позвольте мне идти вперед и открыть этот пример structs2.c,

1017
00:55:29,000 --> 00:55:33,000
которые почти идентичны, но давайте посмотрим, что он сейчас делает.

1018
00:55:33,000 --> 00:55:36,000
В верхней части файла я объявить класс студентов.

1019
00:55:36,000 --> 00:55:38,000
Я тогда заполнения класса с пользовательским вводом,

1020
00:55:38,000 --> 00:55:41,000
так что те строки кода так же, как и раньше.

1021
00:55:41,000 --> 00:55:45,000
Тогда, если я прокрутите вниз здесь я печатаю все, кто находится в Mather произвольно, как и раньше,

1022
00:55:45,000 --> 00:55:47,000
Но это интересная новая функция.

1023
00:55:47,000 --> 00:55:51,000
Эти строки кода являются новыми, и они вносят что-то здесь,

1024
00:55:51,000 --> 00:55:55,000
FILE, все заглавные, и она имеет * здесь также.

1025
00:55:55,000 --> 00:55:58,000
Позвольте мне перенести этот сюда, * здесь также.

1026
00:55:58,000 --> 00:56:00,000
>> Эта функция, которую мы раньше не видели, Еореп,

1027
00:56:00,000 --> 00:56:03,000
но это означает открытие файла, так что давайте бегло этим,

1028
00:56:03,000 --> 00:56:05,000
и это то, что мы вернемся в будущем psets,

1029
00:56:05,000 --> 00:56:10,000
но эта линия здесь по существу открывает файл с именем базы данных,

1030
00:56:10,000 --> 00:56:13,000
и это определенно открывает его таким образом, что он может делать все, что с ним?

1031
00:56:13,000 --> 00:56:15,000
[Неразборчиво-студент]

1032
00:56:15,000 --> 00:56:19,000
Право, таким образом, "W" означает лишь то это говорит операционной системы

1033
00:56:19,000 --> 00:56:21,000
открыть этот файл таким образом, что я могу написать к нему.

1034
00:56:21,000 --> 00:56:23,000
Я не хочу, чтобы прочитать его. Я не хочу, чтобы просто посмотреть на нее.

1035
00:56:23,000 --> 00:56:26,000
Я хочу изменить и добавить материал потенциально к нему,

1036
00:56:26,000 --> 00:56:28,000
и файл будет называться базой данных.

1037
00:56:28,000 --> 00:56:30,000
Это можно назвать что угодно.

1038
00:56:30,000 --> 00:56:32,000
Это может быть database.txt. Это могло бы быть. Дб.

1039
00:56:32,000 --> 00:56:37,000
Это может быть слово, как Foo, но я произвольно выбрал имя файла базы данных.

1040
00:56:37,000 --> 00:56:42,000
Это немного проверку вменяемости, что мы вернемся к очень подробно с течением времени,

1041
00:56:42,000 --> 00:56:47,000
Если FP, для указателя файла, не равно NULL, что означает, что все хорошо.

1042
00:56:47,000 --> 00:56:51,000
>> Короче говоря, такие функции, как Еореп иногда терпят неудачу.

1043
00:56:51,000 --> 00:56:53,000
Возможно, файл не существует. Может быть, вы из дискового пространства.

1044
00:56:53,000 --> 00:56:55,000
Может быть, вы не имеете прав доступа к этой папке,

1045
00:56:55,000 --> 00:56:58,000
так что если Еореп возвращает нулевое что-то плохое случилось.

1046
00:56:58,000 --> 00:57:02,000
И наоборот, если Еореп не возвращает нулевое все хорошо

1047
00:57:02,000 --> 00:57:04,000
и я могу начать писать в этот файл.

1048
00:57:04,000 --> 00:57:06,000
Вот новый трюк.

1049
00:57:06,000 --> 00:57:08,000
Это цикл который итерации по каждому из моих студентов,

1050
00:57:08,000 --> 00:57:10,000
и это выглядит так похожи на то, что мы делали раньше,

1051
00:57:10,000 --> 00:57:15,000
но эта функция является двоюродным братом Printf называется Fprintf для файла Printf,

1052
00:57:15,000 --> 00:57:18,000
и заметите, что он отличается только 2 пути.

1053
00:57:18,000 --> 00:57:20,000
Во-первых, он начинается с F вместо р,

1054
00:57:20,000 --> 00:57:23,000
но тогда ее первым аргументом является то, что видимо?

1055
00:57:23,000 --> 00:57:25,000
[Студенты] файла. >> Это файл.

1056
00:57:25,000 --> 00:57:30,000
Это то, что называется FP, который мы в конце концов дразнят друг от друга, что файл указателя,

1057
00:57:30,000 --> 00:57:35,000
но сейчас FP представляет собой просто файл, который я открыл,

1058
00:57:35,000 --> 00:57:41,000
так Fprintf здесь говорят распечатать ID этого пользователя к файлу, а не на экран.

1059
00:57:41,000 --> 00:57:44,000
Распечатать имя пользователя в файл, а не на экран,

1060
00:57:44,000 --> 00:57:47,000
Дом в файл, а не на экране, а затем здесь, очевидно,

1061
00:57:47,000 --> 00:57:50,000
закрыть файл, а затем сюда бесплатный памяти.

1062
00:57:50,000 --> 00:57:53,000
>> Единственная разница между этой версии 2 и версии 1

1063
00:57:53,000 --> 00:57:58,000
является введение Еореп и это файл с расширением *

1064
00:57:58,000 --> 00:58:01,000
и это понятие Fprintf, так что давайте посмотрим, что конечный результат.

1065
00:58:01,000 --> 00:58:03,000
Отпустите меня в моем окне терминала.

1066
00:58:03,000 --> 00:58:06,000
Позвольте мне выполнить structs2, введите.

1067
00:58:06,000 --> 00:58:09,000
Похоже, все будет хорошо. Давайте повторно structs2.

1068
00:58:09,000 --> 00:58:15,000
123, David Mather, 456, Rob Kirkland,

1069
00:58:15,000 --> 00:58:19,000
789, Томми Mather, введите.

1070
00:58:19,000 --> 00:58:23,000
Похоже, он вел себя так же, но если я сейчас делаю Ls

1071
00:58:23,000 --> 00:58:28,000
заметите, что файл находится здесь среди всех мой код, базы данных,

1072
00:58:28,000 --> 00:58:32,000
так давайте откроем, что Gedit базы данных, и смотреть на это.

1073
00:58:32,000 --> 00:58:34,000
Это не самый сексуальный форматов файлов.

1074
00:58:34,000 --> 00:58:38,000
Это на самом деле одна часть данных линии на линию за линией,

1075
00:58:38,000 --> 00:58:42,000
но те из вас, кто использует Excel или CSV файлов, значения, разделенные запятыми,

1076
00:58:42,000 --> 00:58:47,000
Я мог бы, конечно, использовать Fprintf вместо этого, может быть, сделать что-то вроде этого

1077
00:58:47,000 --> 00:58:50,000
так что я мог фактически создать эквивалент файл Excel

1078
00:58:50,000 --> 00:58:53,000
путем отделения вещи с запятыми, а не только новых линий.

1079
00:58:53,000 --> 00:58:56,000
>> В этом случае, если бы вместо этого использовать запятые вместо новых линий

1080
00:58:56,000 --> 00:59:01,000
Я мог буквально открыть этот файл базы данных в Excel, если я вместо этого сделал его похожим на это.

1081
00:59:01,000 --> 00:59:03,000
Короче говоря, теперь, когда у нас есть силы, чтобы писать файлы

1082
00:59:03,000 --> 00:59:07,000
Теперь мы можем начать сохранения данных, сохраняя его на диск вокруг

1083
00:59:07,000 --> 00:59:10,000
так что мы можем хранить информацию вокруг снова и снова.

1084
00:59:10,000 --> 00:59:14,000
Обратите внимание на несколько других вещей, которые сейчас немного более знакомо.

1085
00:59:14,000 --> 00:59:16,000
В верхней части этого файла C мы имеем ЬурейеЕ

1086
00:59:16,000 --> 00:59:21,000
потому что мы хотели создать тип данных, который представляет собой слово,

1087
00:59:21,000 --> 00:59:25,000
так что этот тип называется словом, а внутри этой структуры

1088
00:59:25,000 --> 00:59:27,000
это немного любитель сейчас.

1089
00:59:27,000 --> 00:59:30,000
Почему слово состоит из видимому массива?

1090
00:59:30,000 --> 00:59:33,000
Что такое слово просто интуитивно?

1091
00:59:33,000 --> 00:59:35,000
>> Это массив символов.

1092
00:59:35,000 --> 00:59:37,000
Это последовательность символов, спина к спине к спине.

1093
00:59:37,000 --> 00:59:41,000
ПИСЬМА заглавными буквами, случается, мы сколь угодно говорить максимальной длины

1094
00:59:41,000 --> 00:59:44,000
любое слово в словарь, который мы используем для Scramble.

1095
00:59:44,000 --> 00:59:46,000
Почему я +1?

1096
00:59:46,000 --> 00:59:48,000
Нулевой символ.

1097
00:59:48,000 --> 00:59:51,000
Напомним, когда мы делали например Bananagrams мы должны особое значение

1098
00:59:51,000 --> 00:59:55,000
В конце слово для того, чтобы отслеживать

1099
00:59:55,000 --> 00:59:59,000
, где слова на самом деле закончились, и как спецификация проблема набора говорит

1100
00:59:59,000 --> 01:00:03,000
Здесь мы общения с данным словом логическое значение,

1101
01:00:03,000 --> 01:00:05,000
Флаг, так сказать, истинным или ложным.

1102
01:00:05,000 --> 01:00:09,000
Нашли ли вы это слово уже, потому что мы понимаем,

1103
01:00:09,000 --> 01:00:13,000
мы действительно нуждаемся способ запоминания не только то, что слово есть в Scramble

1104
01:00:13,000 --> 01:00:15,000
но вы или нет, человека, нашли его

1105
01:00:15,000 --> 01:00:20,000
так что если вы найдете слово "" Вы не можете просто ввести, вводить, вводить, введите

1106
01:00:20,000 --> 01:00:23,000
и получите 3 балла, 3 балла, 3 балла, 3 балла.

1107
01:00:23,000 --> 01:00:26,000
Мы хотим иметь возможность в черный список, что слово, установив логическое

1108
01:00:26,000 --> 01:00:29,000
истинно, если вы уже нашли его, и именно поэтому мы

1109
01:00:29,000 --> 01:00:31,000
инкапсулированные его в эту структуру.

1110
01:00:31,000 --> 01:00:35,000
>> Сейчас, здесь, в Scramble есть эта другая структура называется словарем.

1111
01:00:35,000 --> 01:00:39,000
При отсутствии здесь является слово ЬурейеЕ, потому что в этом случае

1112
01:00:39,000 --> 01:00:43,000
мы должны инкапсулировать Идея словаря,

1113
01:00:43,000 --> 01:00:46,000
и словарь содержит целую кучу слов,

1114
01:00:46,000 --> 01:00:49,000
как следует из этого массива, и как многие из этих слов?

1115
01:00:49,000 --> 01:00:51,000
Ну, что бы эта переменная размеру говорит.

1116
01:00:51,000 --> 01:00:53,000
Но нам просто нужно один словарь.

1117
01:00:53,000 --> 01:00:55,000
Нам не нужны типы данных называются словарь.

1118
01:00:55,000 --> 01:00:58,000
Нам нужно всего лишь одно из них, так получается в C

1119
01:00:58,000 --> 01:01:03,000
что, если вы не говорите ЬурейеЕ, вы просто говорите структуры, то в фигурных скобках

1120
01:01:03,000 --> 01:01:05,000
Вы помещаете ваши переменные, то вы помещаете имя.

1121
01:01:05,000 --> 01:01:09,000
Это объявление одной переменной называется словарь

1122
01:01:09,000 --> 01:01:11,000
который выглядит следующим образом.

1123
01:01:11,000 --> 01:01:16,000
С другой стороны, эти линии создания многоразовых структура данных называется словом

1124
01:01:16,000 --> 01:01:19,000
что вы можете создать несколько копий, так же, как мы создали

1125
01:01:19,000 --> 01:01:22,000
несколько копий студентов.

1126
01:01:22,000 --> 01:01:24,000
>> Что это в конечном итоге позволит нам делать?

1127
01:01:24,000 --> 01:01:30,000
Позвольте мне вернуться в, скажем так, более простой пример из более простых времен,

1128
01:01:30,000 --> 01:01:34,000
и позвольте мне открыть, скажем, compare1.c.

1129
01:01:34,000 --> 01:01:38,000
Проблема здесь в руках на самом деле отогните

1130
01:01:38,000 --> 01:01:41,000
слой строку и начать взлет этих учебных колесах

1131
01:01:41,000 --> 01:01:44,000
потому что получается, что строка все это время

1132
01:01:44,000 --> 01:01:47,000
является, как мы и обещали в неделю 1 действительно только прозвище,

1133
01:01:47,000 --> 01:01:51,000
Синоним от CS50 библиотеки за то, что выглядит немного более загадочным,

1134
01:01:51,000 --> 01:01:53,000
символ *, и мы видели эту звезду раньше.

1135
01:01:53,000 --> 01:01:55,000
Мы видели это в контексте файлы.

1136
01:01:55,000 --> 01:01:59,000
>> Давайте посмотрим, почему мы скрывали эту деталь в течение некоторого времени.

1137
01:01:59,000 --> 01:02:02,000
Вот файл с именем compare1.c,

1138
01:02:02,000 --> 01:02:07,000
и он, очевидно, предлагает пользователю на 2 строки, с и т,

1139
01:02:07,000 --> 01:02:11,000
а затем он пытается сравнить эти строки равенства в строке 26,

1140
01:02:11,000 --> 01:02:14,000
и если они равны она говорит: "Вы набрали одно и то же»,

1141
01:02:14,000 --> 01:02:17,000
и если они не равны она говорит: "Вы ввели разные вещи".

1142
01:02:17,000 --> 01:02:19,000
Позвольте мне идти вперед и запустить эту программу.

1143
01:02:19,000 --> 01:02:23,000
Отпустите меня в мой исходный каталог, сделать compare1. Он составлен в порядке.

1144
01:02:23,000 --> 01:02:25,000
Позвольте мне выполнить compare1.

1145
01:02:25,000 --> 01:02:27,000
Я буду увеличивать, введите.

1146
01:02:27,000 --> 01:02:29,000
Скажи что-нибудь. HELLO.

1147
01:02:29,000 --> 01:02:32,000
Я скажу что-то снова. HELLO.

1148
01:02:32,000 --> 01:02:34,000
Я определенно не вводить разные вещи.

1149
01:02:34,000 --> 01:02:37,000
>> Позвольте мне попробовать это снова. BYE BYE.

1150
01:02:37,000 --> 01:02:40,000
Определенно не отличается, так что здесь происходит?

1151
01:02:40,000 --> 01:02:44,000
Ну, то, что действительно по сравнению в строке 26?

1152
01:02:44,000 --> 01:02:46,000
[Неразборчиво-студент]

1153
01:02:46,000 --> 01:02:49,000
Да, так получается, что строка, тип данных, это своего рода ложь во спасение.

1154
01:02:49,000 --> 01:02:53,000
Строка символов *, но то, что символ *?

1155
01:02:53,000 --> 01:02:56,000
Символ *, как говорят, является указателем,

1156
01:02:56,000 --> 01:03:00,000
и указатель эффективно адрес,

1157
01:03:00,000 --> 01:03:05,000
Сумма место в памяти, и, если вам случится ввели в слово, как HELLO,

1158
01:03:05,000 --> 01:03:08,000
Напомним прошлых обсуждений строк

1159
01:03:08,000 --> 01:03:16,000
это похоже на слово HELLO.

1160
01:03:16,000 --> 01:03:19,000
Помните, что слово, как ПРИВЕТ могут быть представлены

1161
01:03:19,000 --> 01:03:22,000
как массив символов, как это

1162
01:03:22,000 --> 01:03:25,000
а затем с помощью специального символа в конце называемый нулевой символ,

1163
01:03:25,000 --> 01:03:27,000
как \ обозначает.

1164
01:03:27,000 --> 01:03:29,000
Что на самом деле является строкой?

1165
01:03:29,000 --> 01:03:32,000
Заметим, что это несколько участков памяти,

1166
01:03:32,000 --> 01:03:36,000
и в самом деле, конец известно только, если посмотреть всю строку

1167
01:03:36,000 --> 01:03:38,000
ищет особый характер нулевой.

1168
01:03:38,000 --> 01:03:41,000
Но если это кусок памяти из моего компьютера,

1169
01:03:41,000 --> 01:03:44,000
Давайте произвольно сказать, что эта строка просто повезло,

1170
01:03:44,000 --> 01:03:47,000
и он, были устроены в самом начале оперативной памяти моего компьютера.

1171
01:03:47,000 --> 01:03:54,000
Это байт 0, 1, 2, 3, 4, 5, 6 ...

1172
01:03:54,000 --> 01:04:02,000
>> Когда я говорю что-то вроде GetString и я строка S = GetString

1173
01:04:02,000 --> 01:04:04,000
что на самом деле возвращаются?

1174
01:04:04,000 --> 01:04:08,000
За эти последние несколько недель, что на самом деле хранится в ы

1175
01:04:08,000 --> 01:04:13,000
Не эта строка сама по себе, но в данном случае то, что хранится является

1176
01:04:13,000 --> 01:04:18,000
число 0, так что на самом деле делает GetString

1177
01:04:18,000 --> 01:04:20,000
оно физически не возвращать строку.

1178
01:04:20,000 --> 01:04:22,000
Это даже не реально сделать концептуальном смысле.

1179
01:04:22,000 --> 01:04:24,000
Что она делает возвращение числа.

1180
01:04:24,000 --> 01:04:28,000
Это число является адресом ПРИВЕТ в памяти,

1181
01:04:28,000 --> 01:04:32,000
и строка с потом, если мы отогните этот слой, строка на самом деле не существует.

1182
01:04:32,000 --> 01:04:35,000
Это всего лишь упрощение CS50 библиотеки.

1183
01:04:35,000 --> 01:04:38,000
>> Это действительно то, что называется символ *.

1184
01:04:38,000 --> 01:04:41,000
Char имеет смысл, потому что слово, как Алло?

1185
01:04:41,000 --> 01:04:44,000
Ну, это серия символов, набор символов.

1186
01:04:44,000 --> 01:04:47,000
Char * означает, что адрес характера,

1187
01:04:47,000 --> 01:04:50,000
так что это значит для возврата строки?

1188
01:04:50,000 --> 01:04:53,000
Хороший, простой способ возвращения строки

1189
01:04:53,000 --> 01:04:57,000
есть, а не пытаться выяснить, как я возвращаюсь в 5 или 6 различных байтов

1190
01:04:57,000 --> 01:05:01,000
Позвольте мне вернуться в адрес которого байт?

1191
01:05:01,000 --> 01:05:03,000
Первый.

1192
01:05:03,000 --> 01:05:06,000
Иными словами, позвольте мне дать вам адрес символа в памяти.

1193
01:05:06,000 --> 01:05:10,000
Вот что символ * представляет собой, по адресу одного символа в памяти.

1194
01:05:10,000 --> 01:05:12,000
Вызовите эту переменную с.

1195
01:05:12,000 --> 01:05:15,000
Хранить в частности, что с адреса, который я условно сказал равен 0,

1196
01:05:15,000 --> 01:05:19,000
только, чтобы держать вещи простыми, но на самом деле это вообще большие числа.

1197
01:05:19,000 --> 01:05:21,000
>> Подождите минуту.

1198
01:05:21,000 --> 01:05:23,000
Если вы только что дали мне адрес первого символа, как я знаю, что адрес

1199
01:05:23,000 --> 01:05:25,000
второй персонаж, третий, четвертый и пятый?

1200
01:05:25,000 --> 01:05:27,000
[Неразборчиво-студент]

1201
01:05:27,000 --> 01:05:31,000
Вы только знаете, где в конце строки через этот удобный трюк,

1202
01:05:31,000 --> 01:05:35,000
поэтому, когда вы используете что-то вроде Printf, что Printf буквально берет в качестве аргумента,

1203
01:05:35,000 --> 01:05:39,000
Напомним, что мы используем заполнитель% с этим, а потом перейти в

1204
01:05:39,000 --> 01:05:41,000
переменной, которая хранения строки.

1205
01:05:41,000 --> 01:05:47,000
То, что вы действительно проходящей это адрес первого символа этой строки.

1206
01:05:47,000 --> 01:05:50,000
Printf затем используется для цикла или время цикла при получении этому адресу,

1207
01:05:50,000 --> 01:05:53,000
Например, 0, так что позвольте мне сделать это сейчас,

1208
01:05:53,000 --> 01:06:02,000
Е ("% с \ п", с);

1209
01:06:02,000 --> 01:06:07,000
Когда я называю Е ("% с \ п", с); что я действительно предоставлении Printf с

1210
01:06:07,000 --> 01:06:13,000
это адрес первого символа в S, которое в этом случае является произвольным H.

1211
01:06:13,000 --> 01:06:16,000
>> Как Printf знать, что именно для отображения на экране?

1212
01:06:16,000 --> 01:06:19,000
Человек, который реализуется Printf реализован цикл во время или цикл

1213
01:06:19,000 --> 01:06:23,000
, что говорит эта характер равна специальный символ NULL?

1214
01:06:23,000 --> 01:06:25,000
Если нет, то распечатать его. Как насчет этого?

1215
01:06:25,000 --> 01:06:28,000
Если не печатать, печатать, печатать, печатать.

1216
01:06:28,000 --> 01:06:32,000
О, это одно особенное. Остановите печать и вернуться к пользователю.

1217
01:06:32,000 --> 01:06:35,000
И вот буквально все, что происходило под капотом,

1218
01:06:35,000 --> 01:06:38,000
и что это много, чтобы переварить в первый день класса,

1219
01:06:38,000 --> 01:06:43,000
но сейчас это действительно строительный блок понимании все

1220
01:06:43,000 --> 01:06:46,000
, который был происходит внутри памяти нашего компьютера,

1221
01:06:46,000 --> 01:06:49,000
и в конечном итоге мы будем дразнить этого друг от друга с небольшой помощью

1222
01:06:49,000 --> 01:06:51,000
у одного из наших друзей в Стэнфорде.

1223
01:06:51,000 --> 01:06:56,000
>> Профессор Ник Parlante в Стэнфорде сделали этот замечательный видеоряд

1224
01:06:56,000 --> 01:06:58,000
от всех видов различных языков, которые ввели

1225
01:06:58,000 --> 01:07:00,000
эта маленькая Бинки характер Claymation.

1226
01:07:00,000 --> 01:07:03,000
Голос вы услышите всего несколько секунд просмотра подхалима

1227
01:07:03,000 --> 01:07:05,000
является то, что профессор Стэнфорда, и вы получаете

1228
01:07:05,000 --> 01:07:07,000
Только 5 или 6 секунд это прямо сейчас,

1229
01:07:07,000 --> 01:07:09,000
Но это к сведению, на которых мы закончим сегодня

1230
01:07:09,000 --> 01:07:11,000
и начать в среду.

1231
01:07:11,000 --> 01:07:15,000
Я даю вам Указатель Fun с Бинки, предварительный просмотр.

1232
01:07:15,000 --> 01:07:18,000
[♪ Музыка ♪] [Профессор Parlante] Эй, Бинки.

1233
01:07:18,000 --> 01:07:21,000
Проснись. Это время для указателя весело.

1234
01:07:21,000 --> 01:07:24,000
[Бинки] Что это? Узнать о указателей?

1235
01:07:24,000 --> 01:07:26,000
О, сентиментальный!

1236
01:07:26,000 --> 01:07:29,000
>> Мы будем видеть Вас в среду.

1237
01:07:29,000 --> 01:07:32,000
[CS50.TV]