1
00:00:00,000 --> 00:00:01,000
[Powered by Google Translate] [Часть 6] [более комфортным]

2
00:00:01,000 --> 00:00:04,000
[Rob Боуден] [Harvard University]

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

4
00:00:09,000 --> 00:00:11,000
>> Мы можем отправиться в нашем разделе вопросов.

5
00:00:11,000 --> 00:00:17,000
Я послал URL для космических раньше.

6
00:00:17,000 --> 00:00:22,000
В начале раздела вопросов говорите-

7
00:00:22,000 --> 00:00:26,000
видимо я не совсем unsick-это очень простой вопрос

8
00:00:26,000 --> 00:00:28,000
всего того, что Valgrind?

9
00:00:28,000 --> 00:00:30,000
Что Valgrind делать?

10
00:00:30,000 --> 00:00:34,000
Любой хочу сказать, что Valgrind делает?

11
00:00:34,000 --> 00:00:36,000
[Студент] Проверка утечек памяти.

12
00:00:36,000 --> 00:00:41,000
Да, Valgrind общая проверка памяти.

13
00:00:41,000 --> 00:00:44,000
Это, в конце концов, говорит вам, если у вас есть какие-то утечки памяти,

14
00:00:44,000 --> 00:00:49,000
который в основном то, что мы используем его для, потому что, если вы хотите

15
00:00:49,000 --> 00:00:54,000
преуспеть в задаче набора или если вы хотите

16
00:00:54,000 --> 00:00:59,000
получить на большой доске, вы должны иметь утечек памяти вообще,

17
00:00:59,000 --> 00:01:01,000
и в случае, если есть утечки памяти, которые вы не можете найти,

18
00:01:01,000 --> 00:01:04,000
Также имейте в виду, что всякий раз, когда вы открываете файл

19
00:01:04,000 --> 00:01:07,000
и если вы не закроете его, что это утечка памяти.

20
00:01:07,000 --> 00:01:10,000
>> Многие люди ищут для некоторых узлов, что они не освобождая

21
00:01:10,000 --> 00:01:15,000
когда на самом деле, они не закрыть словарь в самый первый шаг.

22
00:01:15,000 --> 00:01:19,000
Он также говорит вам, если у вас есть какие-то недействительным читает или пишет,

23
00:01:19,000 --> 00:01:22,000
что означает, если вы пытаетесь установить значение

24
00:01:22,000 --> 00:01:26,000
что это за конец кучи и это не произойдет в сегменте вина

25
00:01:26,000 --> 00:01:30,000
но Valgrind ловит его, как вы на самом деле не должно быть письменно там,

26
00:01:30,000 --> 00:01:33,000
и таким образом, вы определенно не должны иметь любой из этих тоже.

27
00:01:33,000 --> 00:01:38,000
Как вы используете Valgrind?

28
00:01:38,000 --> 00:01:42,000
Как вы используете Valgrind?

29
00:01:42,000 --> 00:01:45,000
>> Это общий вопрос

30
00:01:45,000 --> 00:01:49,000
вид запустите ее и посмотрите на выходе.

31
00:01:49,000 --> 00:01:51,000
Выход подавляющего много раз.

32
00:01:51,000 --> 00:01:54,000
Там же, где весело ошибки, если у вас есть некоторые очень неправильные вещи

33
00:01:54,000 --> 00:01:59,000
происходит в цикле, то она будет в конечном итоге сказать: "Слишком много ошибок.

34
00:01:59,000 --> 00:02:03,000
Я собираюсь прекратить подсчет сейчас ".

35
00:02:03,000 --> 00:02:08,000
Это в основном текстовый вывод, что вам придется разобрать.

36
00:02:08,000 --> 00:02:13,000
В конце концов, он скажет вам любой утечки памяти, которые у вас есть,

37
00:02:13,000 --> 00:02:16,000
сколько блоков, которые могут быть полезны, потому что

38
00:02:16,000 --> 00:02:20,000
если это один блок unfreed, то она, как правило, легче найти

39
00:02:20,000 --> 00:02:23,000
чем 1.000 блоков unfreed.

40
00:02:23,000 --> 00:02:26,000
1000 блоков unfreed, вероятно, означает, что вы не освобождая

41
00:02:26,000 --> 00:02:30,000
ваша связанные списки надлежащим или что-то.

42
00:02:30,000 --> 00:02:32,000
Это Valgrind.

43
00:02:32,000 --> 00:02:35,000
>> Теперь у нас есть раздел вопросов,

44
00:02:35,000 --> 00:02:38,000
которые вам не нужны для загрузки.

45
00:02:38,000 --> 00:02:41,000
Вы можете нажать на мое имя, и потянуть их в пространстве.

46
00:02:41,000 --> 00:02:44,000
Теперь нажмите на меня.

47
00:02:44,000 --> 00:02:46,000
1-я редакция будет стек, который мы делаем в первую очередь.

48
00:02:46,000 --> 00:02:55,000
Пересмотр 2 будет очереди, и 3-я редакция будет однонаправленного списка.

49
00:02:55,000 --> 00:02:58,000
Начав с нашим стеком.

50
00:02:58,000 --> 00:03:02,000
Как сказано здесь, стек является одним из самых основных,

51
00:03:02,000 --> 00:03:07,000
фундаментальные структуры данных, информатики.

52
00:03:07,000 --> 00:03:11,000
Сам прототип примера

53
00:03:11,000 --> 00:03:13,000
стопку тарелок в столовой.

54
00:03:13,000 --> 00:03:16,000
Это в основном, когда вы вводятся в стек,

55
00:03:16,000 --> 00:03:20,000
кто-то скажет: "О, как стек лотков".

56
00:03:20,000 --> 00:03:22,000
Вы стек лотками.

57
00:03:22,000 --> 00:03:24,000
Затем, когда вы идете вытащить лоток,

58
00:03:24,000 --> 00:03:31,000
первый лоток, который становится вытащил является последней, которая была введена в стеке.

59
00:03:31,000 --> 00:03:34,000
Стек также, как он говорит здесь-

60
00:03:34,000 --> 00:03:37,000
у нас есть сегмент памяти, называемой стеком.

61
00:03:37,000 --> 00:03:40,000
И почему это называется стеком?

62
00:03:40,000 --> 00:03:42,000
>> Потому что, как структуры данных стека,

63
00:03:42,000 --> 00:03:46,000
он толкает и появляется кадры стека в стек,

64
00:03:46,000 --> 00:03:53,000
где кадры стека похожи на конкретный вызов функции.

65
00:03:53,000 --> 00:03:57,000
И, как стек, вы всегда будете иметь, чтобы вернуться

66
00:03:57,000 --> 00:04:03,000
от вызова функции, прежде чем спускаться в нижние кадры стека снова.

67
00:04:03,000 --> 00:04:08,000
Вы не можете иметь главный вызов Foo Bar вызова и бар возвращение к основному напрямую.

68
00:04:08,000 --> 00:04:14,000
Он всегда должны следовать правильным стек нажатия и появляются.

69
00:04:14,000 --> 00:04:18,000
Две операции, как я уже сказал, толчок и поп-музыки.

70
00:04:18,000 --> 00:04:20,000
Это универсальные термины.

71
00:04:20,000 --> 00:04:26,000
Вы должны знать, толчок и поп-музыки с точки зрения стеки ни на что.

72
00:04:26,000 --> 00:04:28,000
Мы увидим очереди вид другой.

73
00:04:28,000 --> 00:04:32,000
Это действительно не имеет универсального термина, но толчок и поп являются универсальными для стеков.

74
00:04:32,000 --> 00:04:34,000
Толчок просто положить на стек.

75
00:04:34,000 --> 00:04:37,000
Поп-это взять из стека.

76
00:04:37,000 --> 00:04:43,000
И мы видим, здесь у нас есть ЬурейеЕ стек структуры,

77
00:04:43,000 --> 00:04:46,000
поэтому мы должны символов строки **.

78
00:04:46,000 --> 00:04:51,000
Не пугайтесь любой **.

79
00:04:51,000 --> 00:04:54,000
Это будет в конечном итоге массив строк

80
00:04:54,000 --> 00:04:58,000
или массив указателей на символы, где

81
00:04:58,000 --> 00:05:00,000
указателей на символы, как правило, строки.

82
00:05:00,000 --> 00:05:05,000
Это не должны быть строками, но здесь они собираются быть строками.

83
00:05:05,000 --> 00:05:08,000
>> У нас есть массив строк.

84
00:05:08,000 --> 00:05:14,000
У нас есть размер, который представляет, сколько элементов в настоящее время в стеке,

85
00:05:14,000 --> 00:05:19,000
и у нас есть потенциал, который, как многие элементы могут быть в стеке.

86
00:05:19,000 --> 00:05:22,000
Емкость должна начаться как нечто большее, чем 1,

87
00:05:22,000 --> 00:05:27,000
но размер будет начинаться как 0.

88
00:05:27,000 --> 00:05:36,000
Сейчас, в основном существуют три различных способа вы можете думать о стеке.

89
00:05:36,000 --> 00:05:39,000
Ну, есть, вероятно, больше, но два основных пути

90
00:05:39,000 --> 00:05:43,000
Вы можете осуществить это с помощью массива, или вы можете реализовать его с помощью связанного списка.

91
00:05:43,000 --> 00:05:48,000
Связанные списки являются своего рода тривиальная, чтобы стек с.

92
00:05:48,000 --> 00:05:51,000
Это очень легко сделать стек с помощью связанных списков,

93
00:05:51,000 --> 00:05:55,000
так вот, мы собираемся сделать стек с помощью массива,

94
00:05:55,000 --> 00:05:59,000
а затем с помощью массивов, есть также два пути вы можете думать об этом.

95
00:05:59,000 --> 00:06:01,000
Раньше, когда я сказал, у нас есть потенциал для стека,

96
00:06:01,000 --> 00:06:04,000
так что мы можем соответствовать элементу в стеке.

97
00:06:04,000 --> 00:06:09,000
>> Одной стороны, это могло произойти, как только вы нажмете 10 элементов, то вы сделали.

98
00:06:09,000 --> 00:06:13,000
Возможно, вы знаете, что есть верхняя граница из 10 вещей в мире

99
00:06:13,000 --> 00:06:16,000
что вы никогда не будете иметь больше, чем 10 вещей, на ваш стек,

100
00:06:16,000 --> 00:06:20,000
В этом случае вы можете иметь верхнюю границу размера вашего стека.

101
00:06:20,000 --> 00:06:23,000
Или вы могли бы ваш стек быть неограниченным,

102
00:06:23,000 --> 00:06:27,000
Но если вы делаете массив, это означает, что каждый раз, когда вы попали 10 элементов,

103
00:06:27,000 --> 00:06:29,000
тогда вы будете иметь, чтобы вырасти до 20 элементов, и когда вы попали 20 элементов,

104
00:06:29,000 --> 00:06:33,000
Вам придется выращивать массива до 30 элементов и 40 элементов.

105
00:06:33,000 --> 00:06:37,000
Вы будете нуждаться, чтобы увеличить пропускную способность, которая является то, что мы собираемся сделать здесь.

106
00:06:37,000 --> 00:06:40,000
Каждый раз, когда мы достигаем максимального размера нашего стека,

107
00:06:40,000 --> 00:06:46,000
когда мы нажимаем на что-то другое, мы будем нуждаться, чтобы увеличить пропускную способность.

108
00:06:46,000 --> 00:06:50,000
Здесь мы толчок объявлены как BOOL толчок (символ * ул).

109
00:06:50,000 --> 00:06:54,000
Char * ул представляет собой строку, мы добиваемся в стек,

110
00:06:54,000 --> 00:06:58,000
и BOOL просто говорит ли мы успеха или неудачи.

111
00:06:58,000 --> 00:07:00,000
>> Как мы можем потерпеть неудачу?

112
00:07:00,000 --> 00:07:04,000
Что является единственным обстоятельством, что вы можете думать о

113
00:07:04,000 --> 00:07:07,000
где мы должны были бы вернуться ложным?

114
00:07:07,000 --> 00:07:09,000
Да.

115
00:07:09,000 --> 00:07:12,000
[Студент] Если это полная и мы используем ограниченную реализацию.

116
00:07:12,000 --> 00:07:17,000
Да, так как мы определяем, он ответил

117
00:07:17,000 --> 00:07:23,000
если это полная и мы используем ограниченной реализации.

118
00:07:23,000 --> 00:07:26,000
Тогда мы определенно вернемся ложным.

119
00:07:26,000 --> 00:07:31,000
Как только мы попали 10 вещей, которые в массиве, мы не может поместиться 11, так что мы возвращаемся ложным.

120
00:07:31,000 --> 00:07:32,000
Что, если она не ограничена? Да.

121
00:07:32,000 --> 00:07:38,000
Если вы не можете расширить массив по некоторым причинам.

122
00:07:38,000 --> 00:07:43,000
Да, так что память является ограниченным ресурсом,

123
00:07:43,000 --> 00:07:51,000
и в конце концов, если мы продолжать настаивать вещи в стек снова и снова,

124
00:07:51,000 --> 00:07:54,000
Мы собираемся попробовать и выделить больший массив, чтобы соответствовать

125
00:07:54,000 --> 00:07:59,000
большую емкость, и таНос или любой другой мы используем собирается вернуться ложным.

126
00:07:59,000 --> 00:08:02,000
Ну, таНос вернет NULL.

127
00:08:02,000 --> 00:08:05,000
>> Помните, что каждый раз, когда вы звоните таНос, вы должны проверять, чтобы увидеть, если она

128
00:08:05,000 --> 00:08:12,000
возвращает нулевой или еще что правильность вывода.

129
00:08:12,000 --> 00:08:17,000
Так как мы хотим иметь неограниченный стека,

130
00:08:17,000 --> 00:08:21,000
Единственный случай, мы собираемся возвращаться ложным, если мы попытаемся

131
00:08:21,000 --> 00:08:26,000
увеличить мощность и таНос или что возвращает ложь.

132
00:08:26,000 --> 00:08:30,000
Тогда поп не принимает аргументов,

133
00:08:30,000 --> 00:08:37,000
и она возвращает строку, которая находится на вершине стека.

134
00:08:37,000 --> 00:08:41,000
Каким бы ни был недавно в стек является то, что поп возвращается,

135
00:08:41,000 --> 00:08:44,000
и он также удаляется из стека.

136
00:08:44,000 --> 00:08:50,000
И заметил, что он возвращает нулевое значение, если нет ничего в стек.

137
00:08:50,000 --> 00:08:53,000
Это всегда возможно, что стек пуст.

138
00:08:53,000 --> 00:08:55,000
В Java, если вы привыкли к этому, или других языков,

139
00:08:55,000 --> 00:09:01,000
пытаются поп из пустого стека может вызвать исключение или что-то.

140
00:09:01,000 --> 00:09:09,000
>> Но в C, нулевые это своего рода много случаев, как мы справляемся с этими проблемами.

141
00:09:09,000 --> 00:09:13,000
Возвращаясь нулевой, как мы собираемся, чтобы показать, что стек был пуст.

142
00:09:13,000 --> 00:09:16,000
Мы предоставили код, который будет проверять функциональность вашего стека,

143
00:09:16,000 --> 00:09:19,000
осуществление толкать и поп-музыки.

144
00:09:19,000 --> 00:09:23,000
Это не будет много кода.

145
00:09:23,000 --> 00:09:40,000
Я воли на самом деле, прежде чем мы это сделаем, намек, подсказка-

146
00:09:40,000 --> 00:09:44,000
Если вы еще не видели его, таНос это не единственная функция

147
00:09:44,000 --> 00:09:47,000
, которая выделяет память в куче для вас.

148
00:09:47,000 --> 00:09:51,000
Есть семьи идентификатор функции.

149
00:09:51,000 --> 00:09:53,000
Первый таНос, которые вы привыкли.

150
00:09:53,000 --> 00:09:56,000
Тогда есть calloc, которая делает то же самое, что и таНос,

151
00:09:56,000 --> 00:09:59,000
но это будет нулю все для вас.

152
00:09:59,000 --> 00:10:04,000
Если вы когда-нибудь хотели, чтобы установить все до нуля после mallocing что-то

153
00:10:04,000 --> 00:10:06,000
Вы должны просто использовать calloc, в первую очередь, а не писать

154
00:10:06,000 --> 00:10:09,000
цикл обнулить весь блок памяти.

155
00:10:09,000 --> 00:10:15,000
>> Realloc, как таНос и имеет много особых случаев,

156
00:10:15,000 --> 00:10:19,000
но в основном то, что делает перераспределить

157
00:10:19,000 --> 00:10:24,000
она принимает указатель, которые уже были выделены.

158
00:10:24,000 --> 00:10:27,000
Realloc является функцией, которую необходимо обращать внимание на здесь.

159
00:10:27,000 --> 00:10:31,000
Он принимает указатель, который уже вернулся из таНос.

160
00:10:31,000 --> 00:10:35,000
Допустим, вы требовать от таНос указатель из 10 байт.

161
00:10:35,000 --> 00:10:38,000
Позже вы осознаете, что вы хотели 20 байт,

162
00:10:38,000 --> 00:10:42,000
так вы звоните перераспределить на этом указатель с 20 байт,

163
00:10:42,000 --> 00:10:47,000
и перераспределить автоматически скопировать все за вас.

164
00:10:47,000 --> 00:10:51,000
Если вы только что позвонил таНос вновь, как и у меня есть блок из 10 байт.

165
00:10:51,000 --> 00:10:53,000
Теперь мне нужно блок из 20 байт,

166
00:10:53,000 --> 00:10:58,000
так что если я таНос 20 байт, то мне придется вручную скопировать 10 байт из первой вещью

167
00:10:58,000 --> 00:11:01,000
во вторую вещь, а затем освободить первое.

168
00:11:01,000 --> 00:11:04,000
Realloc будет обрабатывать это для вас.

169
00:11:04,000 --> 00:11:11,000
>> Обратите внимание, что подпись будет недействительной *,

170
00:11:11,000 --> 00:11:15,000
который просто возвращает указатель на блок памяти,

171
00:11:15,000 --> 00:11:17,000
Затем пустоты * указатель.

172
00:11:17,000 --> 00:11:22,000
Вы можете думать о пустоте * как общий указатель.

173
00:11:22,000 --> 00:11:27,000
Вообще, вы никогда не иметь дело с недействительными *,

174
00:11:27,000 --> 00:11:30,000
но таНос возвращается пустота *, а затем просто использовать как

175
00:11:30,000 --> 00:11:34,000
это на самом деле будет символ *.

176
00:11:34,000 --> 00:11:37,000
* Предыдущие пустоту, которая была возвращена на таНос

177
00:11:37,000 --> 00:11:41,000
Теперь будет передан перераспределить, а затем размер

178
00:11:41,000 --> 00:11:49,000
это новое число байт вы хотите выделить, так что ваши новые мощности.

179
00:11:49,000 --> 00:11:57,000
Я дам вам несколько минут, и сделать это в нашем пространстве.

180
00:11:57,000 --> 00:12:02,000
Начните с пересмотра 1.

181
00:12:16,000 --> 00:12:21,000
Я остановлю тебя после надеюсь, о достаточно времени для осуществления толчок,

182
00:12:21,000 --> 00:12:24,000
и тогда я дам тебе еще один перерыв, чтобы сделать поп-музыки.

183
00:12:24,000 --> 00:12:27,000
Но на самом деле это не так уж много кода.

184
00:12:27,000 --> 00:12:35,000
Наиболее кода, вероятно, расширяет материал, расширение мощностей.

185
00:12:35,000 --> 00:12:39,000
Хорошо, никакого давления, чтобы быть полностью сделано,

186
00:12:39,000 --> 00:12:47,000
но пока вы чувствуете, что находитесь на правильном пути, это хорошо.

187
00:12:47,000 --> 00:12:53,000
>> Кто-нибудь есть код, который они чувствуют себя комфортно со мной, потянув вверх?

188
00:12:53,000 --> 00:12:59,000
Да, я хочу, а не кого-нибудь есть код я могу потянуть?

189
00:12:59,000 --> 00:13:05,000
Хорошо, вы можете начать, сохраните его, что это такое?

190
00:13:05,000 --> 00:13:09,000
Я всегда забываю, что шаг.

191
00:13:09,000 --> 00:13:15,000
Ладно, глядя на толчок,

192
00:13:15,000 --> 00:13:18,000
Вы хотите, чтобы объяснить свой код?

193
00:13:18,000 --> 00:13:24,000
[Студент] Во-первых, я увеличил размер.

194
00:13:24,000 --> 00:13:28,000
Я думаю, может быть, я должен иметь что-все равно, я увеличил размер,

195
00:13:28,000 --> 00:13:31,000
и я не вижу, если он меньше, чем емкость.

196
00:13:31,000 --> 00:13:36,000
И если это меньше, чем емкость, добавить в массив, что мы уже имеем.

197
00:13:36,000 --> 00:13:42,000
А если это не так, я умножить мощность на 2,

198
00:13:42,000 --> 00:13:50,000
и я перераспределить строк массива что-то с большей мощностью размер сейчас.

199
00:13:50,000 --> 00:13:55,000
И потом, если это не удается, я говорю пользователя и вернуться ложным,

200
00:13:55,000 --> 00:14:04,000
и если все нормально, то я ставлю строку в новом месте.

201
00:14:04,000 --> 00:14:07,000
>> [Rob B.] Также обратите внимание, что мы использовали хороший оператор побитового здесь

202
00:14:07,000 --> 00:14:09,000
умножить на 2.

203
00:14:09,000 --> 00:14:11,000
Помните, что сдвиг влево всегда будет умножить на 2.

204
00:14:11,000 --> 00:14:15,000
Сдвиг вправо делится на 2, пока вы помните, что это означает

205
00:14:15,000 --> 00:14:18,000
делим на 2, как в целое число делится на 2.

206
00:14:18,000 --> 00:14:20,000
Это может обрезать на 1 здесь или там.

207
00:14:20,000 --> 00:14:26,000
Но сдвиг влево на 1 всегда будет необходимо умножить на 2,

208
00:14:26,000 --> 00:14:32,000
если вы переполнения пределы целого, и тогда она не будет.

209
00:14:32,000 --> 00:14:34,000
Стороны комментария.

210
00:14:34,000 --> 00:14:39,000
Мне нравится делать-это не собирается менять кодирования любой форме,

211
00:14:39,000 --> 00:14:48,000
Но я хотел бы сделать что-то вроде этого.

212
00:14:48,000 --> 00:14:51,000
Это на самом деле происходит, чтобы сделать его немного дольше.

213
00:15:04,000 --> 00:15:08,000
Может быть, это не идеальный случай, чтобы показать это,

214
00:15:08,000 --> 00:15:14,000
но мне нравится сегменте его в эти блоки-

215
00:15:14,000 --> 00:15:17,000
Хорошо, если это, если произойдет, то я буду что-то делать,

216
00:15:17,000 --> 00:15:19,000
, а затем функция выполняется.

217
00:15:19,000 --> 00:15:22,000
Мне не нужно, чтобы потом прокрутить мои глаза все, вплоть функции

218
00:15:22,000 --> 00:15:25,000
, чтобы увидеть, что происходит после другого.

219
00:15:25,000 --> 00:15:27,000
Это, если это, если произойдет, то я просто вернуться.

220
00:15:27,000 --> 00:15:30,000
Она также имеет хорошее дополнительное преимущество все, что за этим

221
00:15:30,000 --> 00:15:33,000
В настоящее время сдвигается влево один раз.

222
00:15:33,000 --> 00:15:40,000
Я больше не нужно, если вы всегда рядом смешного длинные очереди,

223
00:15:40,000 --> 00:15:45,000
Затем эти 4 байта может помочь, а также левее что-то есть,

224
00:15:45,000 --> 00:15:48,000
меньше перегружены вы себя чувствовали, если хотите, хорошо, я должен помнить,

225
00:15:48,000 --> 00:15:53,000
Я в настоящее время нахожусь в то время как цикл внутри другого внутри цикла.

226
00:15:53,000 --> 00:15:58,000
Везде вы можете сделать это возвращение немедленно, я вроде как.

227
00:15:58,000 --> 00:16:05,000
Это совершенно необязательным и не ожидал никак.

228
00:16:05,000 --> 00:16:12,000
>> [Студент] Должны ли быть размером - в обязательном порядке условия?

229
00:16:12,000 --> 00:16:19,000
Непременно условие здесь мы не смогли перераспределить, так что да.

230
00:16:19,000 --> 00:16:22,000
Обратите внимание, что в обязательном порядке условие, по-видимому,

231
00:16:22,000 --> 00:16:26,000
если мы бесплатно вещи позже, мы всегда будем на провал

232
00:16:26,000 --> 00:16:29,000
независимо от того, сколько раз мы пытаемся подтолкнуть что-то.

233
00:16:29,000 --> 00:16:32,000
Если мы будем продолжать настаивать, мы продолжаем увеличивая размер,

234
00:16:32,000 --> 00:16:36,000
даже если мы не ставит ничего в стек.

235
00:16:36,000 --> 00:16:39,000
Обычно мы не увеличиваем размер до

236
00:16:39,000 --> 00:16:43,000
после того, как мы успешно положить его в стек.

237
00:16:43,000 --> 00:16:50,000
Мы хотели бы это сделать, скажем, либо здесь и здесь.

238
00:16:50,000 --> 00:16:56,000
И тогда вместо того чтобы сказать s.size ≤ потенциал, это меньше, чем мощность,

239
00:16:56,000 --> 00:17:01,000
только потому, что мы переехали, где все было.

240
00:17:01,000 --> 00:17:07,000
>> И помните, что единственное место, где мы могли бы вернуться ложным

241
00:17:07,000 --> 00:17:14,000
Здесь, где перераспределить возвращается нуль,

242
00:17:14,000 --> 00:17:19,000
и если Вы случайно не помните стандартная ошибка,

243
00:17:19,000 --> 00:17:22,000
Может быть, вы могли бы рассмотреть этот случай, когда вы хотите печатать стандартные ошибки,

244
00:17:22,000 --> 00:17:26,000
так Fprintf STDERR, а не просто печать непосредственно на стандартный вывод.

245
00:17:26,000 --> 00:17:31,000
Опять же, это не ожидание, но если это ошибка,

246
00:17:31,000 --> 00:17:41,000
Введите Printf, то вы можете сделать это печать на стандартной ошибки, а не стандартный вывод.

247
00:17:41,000 --> 00:17:44,000
>> Любой, есть что-нибудь еще отметить? Да.

248
00:17:44,000 --> 00:17:47,000
[Студент] Можете ли вы перейти на [неразборчиво]?

249
00:17:47,000 --> 00:17:55,000
[Rob B.] Да, фактически binariness это или просто, что это такое?

250
00:17:55,000 --> 00:17:57,000
[Студент] Таким образом, вы умножить на 2?

251
00:17:57,000 --> 00:17:59,000
[Rob B.] Да, в основном.

252
00:17:59,000 --> 00:18:11,000
В двоичной земли, у нас всегда есть наш набор цифр.

253
00:18:11,000 --> 00:18:22,000
Переход этом левая на 1 основном вставляет его здесь, на правой стороне.

254
00:18:22,000 --> 00:18:25,000
Вернуться к этому, просто помните, что все в двоичном

255
00:18:25,000 --> 00:18:28,000
является степенью 2, так что это представляет 2 до 0,

256
00:18:28,000 --> 00:18:30,000
это 2 к 1, это 2 к 2.

257
00:18:30,000 --> 00:18:33,000
Добавляя 0 до правой стороны сейчас, мы просто переложить все кончено.

258
00:18:33,000 --> 00:18:38,000
То, что было 2 до 0, в настоящее время 2 к 1, 2 к 2.

259
00:18:38,000 --> 00:18:41,000
На правой стороне, что мы вставили

260
00:18:41,000 --> 00:18:44,000
обязательно будет 0,

261
00:18:44,000 --> 00:18:46,000
который имеет смысл.

262
00:18:46,000 --> 00:18:49,000
Если вы когда-нибудь умножить число на 2, это не будет в конечном итоге нечетным,

263
00:18:49,000 --> 00:18:54,000
так что 2 до 0 место должно быть 0,

264
00:18:54,000 --> 00:18:59,000
и это то, что первое полугодие предупредил, прежде чем есть, если вы все-таки перейти

265
00:18:59,000 --> 00:19:01,000
за количество бит в целое,

266
00:19:01,000 --> 00:19:04,000
то это 1, будет в конечном итоге уходить.

267
00:19:04,000 --> 00:19:10,000
Это единственное беспокойство, если вам случится иметь дело с действительно большими возможностями.

268
00:19:10,000 --> 00:19:15,000
Но в этот момент, то вы имеете дело с массивом миллиарды вещей,

269
00:19:15,000 --> 00:19:25,000
которая может не поместиться в памяти в любом случае.

270
00:19:25,000 --> 00:19:31,000
>> Теперь мы можем добраться до поп-музыки, которая еще проще.

271
00:19:31,000 --> 00:19:36,000
Вы можете сделать это нравится, если вам случится поп целая куча,

272
00:19:36,000 --> 00:19:38,000
и теперь вы в половину мощности снова.

273
00:19:38,000 --> 00:19:42,000
Вы могли бы перераспределить, чтобы уменьшить объем памяти у вас есть,

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

275
00:19:47,000 --> 00:19:50,000
растущая памяти, никогда не сокращение памяти,

276
00:19:50,000 --> 00:19:59,000
который собирается сделать поп-супер просто.

277
00:19:59,000 --> 00:20:02,000
Сейчас в очереди, который будет, как стеки,

278
00:20:02,000 --> 00:20:06,000
но для того, чтобы взять вещи на противоположное.

279
00:20:06,000 --> 00:20:10,000
Простейший пример из очереди линии,

280
00:20:10,000 --> 00:20:12,000
поэтому я думаю, если бы вы были на английском, я бы сказал,

281
00:20:12,000 --> 00:20:17,000
Простейший пример из очереди в очередь.

282
00:20:17,000 --> 00:20:22,000
Так как линия, если вы первый человек в линии,

283
00:20:22,000 --> 00:20:24,000
Вы ожидаете, чтобы быть первым человеком из очереди.

284
00:20:24,000 --> 00:20:31,000
Если вы последний человек в линии, вы собираетесь быть последним человеком в ремонт.

285
00:20:31,000 --> 00:20:35,000
Мы называем это FIFO модели, в то время как стек LIFO шаблону.

286
00:20:35,000 --> 00:20:40,000
Эти слова являются довольно универсальными.

287
00:20:40,000 --> 00:20:46,000
>> Как стеки и в отличие от массивов, очередей обычно не допускают доступ к элементам в середине.

288
00:20:46,000 --> 00:20:50,000
Здесь, стек, мы должны толкать и поп-музыки.

289
00:20:50,000 --> 00:20:54,000
Здесь мы, случается, называют их постановки в очередь и удаления из очереди.

290
00:20:54,000 --> 00:20:58,000
Кроме того, я слышал, как они называют сдвигом и Отменить замену.

291
00:20:58,000 --> 00:21:02,000
Я слышал, люди говорят, толчок и поп применяются также к очередям.

292
00:21:02,000 --> 00:21:05,000
Я слышал, вставки, удаления,

293
00:21:05,000 --> 00:21:11,000
так толкать и поп, если вы говорите о стеки, вы толкаете и хлопать.

294
00:21:11,000 --> 00:21:16,000
Если вы говорите об очередях, вы могли бы выбрать слова, которые вы хотите использовать

295
00:21:16,000 --> 00:21:23,000
для вставки и удаления, и нет единого мнения о том, что они должны быть названы.

296
00:21:23,000 --> 00:21:27,000
Но здесь, у нас есть поставить в очередь и удаления из очереди.

297
00:21:27,000 --> 00:21:37,000
Теперь, структура выглядит почти идентично стек структуры.

298
00:21:37,000 --> 00:21:40,000
Но мы должны следить за голову.

299
00:21:40,000 --> 00:21:44,000
Я думаю, это говорит здесь, но почему мы нуждаемся в голову?

300
00:21:53,000 --> 00:21:57,000
Прототипы в основном идентичны толкать и поп-музыки.

301
00:21:57,000 --> 00:21:59,000
Вы можете думать об этом как толчок и поп-музыки.

302
00:21:59,000 --> 00:22:08,000
Разница лишь в том поп возвращается, вместо последнего, он возвращает первый.

303
00:22:08,000 --> 00:22:12,000
2, 1, 3, 4, или что-то еще.

304
00:22:12,000 --> 00:22:14,000
И вот старт.

305
00:22:14,000 --> 00:22:17,000
Наша очередь полностью заполнена, так что четыре элемента в нем.

306
00:22:17,000 --> 00:22:21,000
В конце нашей очереди в настоящее время 2,

307
00:22:21,000 --> 00:22:24,000
и теперь мы идем, чтобы вставить что-то другое.

308
00:22:24,000 --> 00:22:29,000
>> Когда мы хотим, чтобы вставить что-то другое, что мы сделали для стека версия

309
00:22:29,000 --> 00:22:36,000
это мы расширили наш блок памяти.

310
00:22:36,000 --> 00:22:40,000
В чем проблема с этим?

311
00:22:40,000 --> 00:22:45,000
[Студент] Вы двигаетесь 2.

312
00:22:45,000 --> 00:22:51,000
Как я уже говорил о конце очереди,

313
00:22:51,000 --> 00:22:57,000
это не имеет смысла, что мы начинаем с 1,

314
00:22:57,000 --> 00:23:01,000
Затем мы хотим, чтобы из очереди 1, то из очереди 3, то из очереди 4,

315
00:23:01,000 --> 00:23:05,000
то из очереди 2, то из очереди этого.

316
00:23:05,000 --> 00:23:08,000
Мы не можем использовать перераспределить сейчас,

317
00:23:08,000 --> 00:23:11,000
или, по крайней мере, вы должны использовать перераспределить по-другому.

318
00:23:11,000 --> 00:23:15,000
Но вы, вероятно, не следует использовать только перераспределить.

319
00:23:15,000 --> 00:23:18,000
Вы будете должны вручную скопировать памяти.

320
00:23:18,000 --> 00:23:21,000
>> Есть две функции для копирования памяти.

321
00:23:21,000 --> 00:23:25,000
Там в memcopy и memmove.

322
00:23:25,000 --> 00:23:29,000
Я сейчас читаю человек страниц, чтобы увидеть, какой вы собираетесь хотите использовать.

323
00:23:29,000 --> 00:23:35,000
Хорошо, memcopy, разница

324
00:23:35,000 --> 00:23:38,000
что memcopy и memmove, один обрабатывает случае правильно

325
00:23:38,000 --> 00:23:41,000
где вы копируете в регионе, что происходит перекрытие регионе

326
00:23:41,000 --> 00:23:46,000
Вы копировании.

327
00:23:46,000 --> 00:23:50,000
Memcopy не справиться. Memmove делает.

328
00:23:50,000 --> 00:23:59,000
Вы можете думать о проблеме, как-

329
00:23:59,000 --> 00:24:09,000
скажем, я хочу, чтобы скопировать этот парень,

330
00:24:09,000 --> 00:24:13,000
эти четыре с этим парнем старше.

331
00:24:13,000 --> 00:24:16,000
В конце концов, то, что массив должен выглядеть

332
00:24:16,000 --> 00:24:26,000
после того, как копия 2, 1, 2, 1, 3, 4, а затем некоторые вещи в конце.

333
00:24:26,000 --> 00:24:29,000
Но это зависит от порядка, в котором мы на самом деле копировать,

334
00:24:29,000 --> 00:24:32,000
так как если мы не считаем тот факт, что регион мы копирования в

335
00:24:32,000 --> 00:24:35,000
перекрывает один мы копировании,

336
00:24:35,000 --> 00:24:46,000
Затем мы могли бы сделать, как начать здесь, копирование 2 в место, где мы хотим пойти,

337
00:24:46,000 --> 00:24:52,000
затем переместить наши указатели вперед.

338
00:24:52,000 --> 00:24:56,000
>> Теперь мы собираемся быть здесь и здесь, и теперь мы хотим, чтобы скопировать

339
00:24:56,000 --> 00:25:04,000
этот парень за этим парнем, и переместить наши указатели вперед.

340
00:25:04,000 --> 00:25:07,000
То, что мы собираемся в конечном итоге получить в 2, 1, 2, 1, 2, 1

341
00:25:07,000 --> 00:25:10,000
вместо того, чтобы соответствующие 2, 1, 2, 1, 3, 4, потому что

342
00:25:10,000 --> 00:25:15,000
2, 1 преодолел оригинальный 3, 4.

343
00:25:15,000 --> 00:25:19,000
Memmove обрабатывает это правильно.

344
00:25:19,000 --> 00:25:23,000
В этом случае, в основном всегда использовать memmove

345
00:25:23,000 --> 00:25:26,000
потому что он работает правильно.

346
00:25:26,000 --> 00:25:29,000
Как правило, он не выполняет хуже.

347
00:25:29,000 --> 00:25:32,000
Идея состоит в том, а не с начала и копирования таким образом,

348
00:25:32,000 --> 00:25:35,000
как мы только что сделали здесь, она начинается с конца и копирует в,

349
00:25:35,000 --> 00:25:38,000
и в этом случае, вы не можете иметь проблемы.

350
00:25:38,000 --> 00:25:40,000
Там производительность не потерял.

351
00:25:40,000 --> 00:25:47,000
Всегда используйте memmove. Никогда не беспокойтесь о memcopy.

352
00:25:47,000 --> 00:25:51,000
И вот, когда вы будете иметь отдельно memmove

353
00:25:51,000 --> 00:26:01,000
обернутый вокруг части вашей очереди.

354
00:26:01,000 --> 00:26:04,000
Не беспокойтесь, если не полностью сделано.

355
00:26:04,000 --> 00:26:10,000
Это труднее, чем стек, толчок, и поп-музыки.

356
00:26:10,000 --> 00:26:15,000
>> Любой, есть какие-либо кода мы могли бы работать?

357
00:26:15,000 --> 00:26:21,000
Даже если полностью неполным?

358
00:26:21,000 --> 00:26:23,000
[Студент] Да, это совершенно неполным, однако.

359
00:26:23,000 --> 00:26:27,000
Полностью неполной прекрасно до тех пор, как мы, вы можете сэкономить пересмотра?

360
00:26:27,000 --> 00:26:32,000
Я забываю, что каждый раз.

361
00:26:32,000 --> 00:26:39,000
Хорошо, игнорируя то, что происходит, когда мы должны изменить размер вещи.

362
00:26:39,000 --> 00:26:42,000
Полностью игнорировать изменения размера.

363
00:26:42,000 --> 00:26:49,000
Объяснить этот код.

364
00:26:49,000 --> 00:26:54,000
Я проверяю, прежде всего, если размер меньше, чем копия, прежде всего,

365
00:26:54,000 --> 00:27:01,000
и после этого, я вставляю-я беру голову + размер,

366
00:27:01,000 --> 00:27:05,000
и я убедиться, что она обтекает емкость массива,

367
00:27:05,000 --> 00:27:08,000
и я вставить новую строку в этом положении.

368
00:27:08,000 --> 00:27:12,000
Тогда я увеличить размер и вернуть истинный.

369
00:27:12,000 --> 00:27:22,000
>> [Rob B.] Это, безусловно, один из тех случаев, когда вы захотите использовать мод.

370
00:27:22,000 --> 00:27:25,000
Любой случай, когда вы обтекания, если вы думаете обтекания,

371
00:27:25,000 --> 00:27:29,000
непосредственной мысль должна быть мода.

372
00:27:29,000 --> 00:27:36,000
Как быстро оптимизации / сделать ваш код одну строку короче,

373
00:27:36,000 --> 00:27:42,000
Вы заметили, что строки сразу после этого

374
00:27:42,000 --> 00:27:53,000
только размер + +, так что вы объединяете, что в эту линию, размер + +.

375
00:27:53,000 --> 00:27:58,000
Теперь здесь мы имеем случай

376
00:27:58,000 --> 00:28:01,000
, где у нас не хватает памяти,

377
00:28:01,000 --> 00:28:05,000
так мы увеличиваем нашу способность на 2.

378
00:28:05,000 --> 00:28:09,000
Я думаю, вы могли бы иметь те же проблемы, но мы можем игнорировать это сейчас,

379
00:28:09,000 --> 00:28:13,000
, где, если вы не смогли увеличить мощность,

380
00:28:13,000 --> 00:28:18,000
то вы будете хотеть, чтобы уменьшить емкость на 2 снова.

381
00:28:18,000 --> 00:28:24,000
Другой короткую записку так же, как вы можете сделать, + =,

382
00:28:24,000 --> 00:28:30,000
Вы также можете сделать << =.

383
00:28:30,000 --> 00:28:43,000
Почти все, что может пойти до равных, + =, | =, & =, << =.

384
00:28:43,000 --> 00:28:52,000
Char * новый наш новый блок памяти.

385
00:28:52,000 --> 00:28:55,000
О, здесь.

386
00:28:55,000 --> 00:29:02,000
>> Что люди думают о типе наш новый блок памяти?

387
00:29:02,000 --> 00:29:06,000
[Студент] Он должен быть символ **.

388
00:29:06,000 --> 00:29:12,000
Вспоминая нашу структуру здесь,

389
00:29:12,000 --> 00:29:14,000
строк то, что мы перераспределения.

390
00:29:14,000 --> 00:29:21,000
Мы делаем совершенно новый динамической памяти для элементов в очереди.

391
00:29:21,000 --> 00:29:25,000
То, что мы собираемся назначении на ваши строки является то, что мы mallocing прямо сейчас,

392
00:29:25,000 --> 00:29:30,000
и так новая будет символ **.

393
00:29:30,000 --> 00:29:34,000
Это будет массив строк.

394
00:29:34,000 --> 00:29:38,000
Тогда в чем же дело, по которому мы собираемся вернуться ложным?

395
00:29:38,000 --> 00:29:41,000
[Студент] мы должны делать символов *?

396
00:29:41,000 --> 00:29:44,000
[Rob B.] Да, хороший вызов.

397
00:29:44,000 --> 00:29:46,000
[Студент] Что это было?

398
00:29:46,000 --> 00:29:49,000
[Rob B.] Мы хотели сделать размер символов *, потому что мы уже не-

399
00:29:49,000 --> 00:29:53,000
это фактически будет очень большая проблема, потому что SizeOf (Char) будет 1.

400
00:29:53,000 --> 00:29:55,000
Sizeof символ * будет 4,

401
00:29:55,000 --> 00:29:58,000
так много раз, когда вы имеете дело с целыми,

402
00:29:58,000 --> 00:30:01,000
Вы, как правило, все сойдет с рук, потому что размер Int и размер Int *

403
00:30:01,000 --> 00:30:04,000
на 32-разрядные системы будет то же самое.

404
00:30:04,000 --> 00:30:09,000
Но здесь, SizeOf (Char) и SizeOf (Char *) теперь будет то же самое.

405
00:30:09,000 --> 00:30:15,000
>> Что такое обстоятельство, где мы вернуться ложным?

406
00:30:15,000 --> 00:30:17,000
[Студент] Новый равен нулю.

407
00:30:17,000 --> 00:30:23,000
Да, если новый пустой, мы возвращаемся ложными,

408
00:30:23,000 --> 00:30:34,000
и я собираюсь бросить здесь-

409
00:30:34,000 --> 00:30:37,000
[Студент] [неразборчиво]

410
00:30:37,000 --> 00:30:39,000
[Rob B.] Да, это прекрасно.

411
00:30:39,000 --> 00:30:46,000
Вы можете либо делать 2 раза мощность или емкость сдвиг 1, а затем только установить его здесь или любой другой.

412
00:30:46,000 --> 00:30:52,000
Мы сделаем это, как у нас было.

413
00:30:52,000 --> 00:30:56,000
Емкость >> = 1.

414
00:30:56,000 --> 00:31:08,000
И вы никогда не придется беспокоиться о потере 1-Место

415
00:31:08,000 --> 00:31:12,000
потому что вы оставили сдвинут на 1, поэтому 1-Место обязательно 0,

416
00:31:12,000 --> 00:31:16,000
так прямо сдвиг на 1, вы все еще будет хорошо.

417
00:31:16,000 --> 00:31:19,000
[Студент] Вам необходимо сделать это до возвращения?

418
00:31:19,000 --> 00:31:29,000
[Rob B.] Да, это не имеет абсолютно никакого смысла.

419
00:31:29,000 --> 00:31:36,000
>> Теперь предположим, что мы собираемся в конечном итоге возвращается истинным до конца.

420
00:31:36,000 --> 00:31:39,000
Как мы собираемся сделать это memmoves,

421
00:31:39,000 --> 00:31:45,000
Мы должны быть осторожны с тем, как мы их делаем.

422
00:31:45,000 --> 00:31:50,000
Кто-нибудь есть какие-либо предложения о том, как мы их делаем?

423
00:32:17,000 --> 00:32:21,000
Вот наш старт.

424
00:32:21,000 --> 00:32:28,000
Безусловно, мы хотим начать с самого начала еще раз

425
00:32:28,000 --> 00:32:35,000
и копии вещей в Оттуда, 1, 3, 4, 2.

426
00:32:35,000 --> 00:32:41,000
Как вы это сделали?

427
00:32:41,000 --> 00:32:52,000
Во-первых, я должен смотреть на мужчину страницы для memmove снова.

428
00:32:52,000 --> 00:32:57,000
Memmove, порядок аргументов всегда важно.

429
00:32:57,000 --> 00:33:01,000
Мы хотим, чтобы наше назначение первого, второго источника, размера третьего.

430
00:33:01,000 --> 00:33:06,000
Есть много функций, которые обратном источника и назначения.

431
00:33:06,000 --> 00:33:11,000
Направление, источник, как правило, соответствует несколько.

432
00:33:17,000 --> 00:33:21,000
Move, что это возвращение?

433
00:33:21,000 --> 00:33:27,000
Она возвращает указатель к месту назначения, по какой причине вы, возможно, захотите этого.

434
00:33:27,000 --> 00:33:32,000
Я могу себе читать, но мы хотим двигаться в нашем назначения.

435
00:33:32,000 --> 00:33:35,000
>> То, что наш пункт назначения будет?

436
00:33:35,000 --> 00:33:37,000
[Студент] New.

437
00:33:37,000 --> 00:33:39,000
[Rob B.] Да, и где мы копировании?

438
00:33:39,000 --> 00:33:43,000
Первое, что мы копируем это 1, 3, 4.

439
00:33:43,000 --> 00:33:50,000
Что такое-это 1, 3, 4.

440
00:33:50,000 --> 00:33:55,000
Что такое адрес этого 1?

441
00:33:55,000 --> 00:33:58,000
Что это адрес, что 1?

442
00:33:58,000 --> 00:34:01,000
[Студент] [неразборчиво]

443
00:34:01,000 --> 00:34:03,000
[Rob B.] Руководитель + адрес первого элемента.

444
00:34:03,000 --> 00:34:05,000
Как мы можем получить первый элемент в массиве?

445
00:34:05,000 --> 00:34:10,000
[Студент] Queue.

446
00:34:10,000 --> 00:34:15,000
[Rob B.] Да, q.strings.

447
00:34:15,000 --> 00:34:20,000
Помните, что здесь, наши головы 1.

448
00:34:20,000 --> 00:34:24,000
Штопать его. Я просто думаю, что это волшебно-

449
00:34:24,000 --> 00:34:29,000
Здесь наши головы 1. Я собираюсь менять свой цвет тоже.

450
00:34:29,000 --> 00:34:36,000
А вот строки.

451
00:34:36,000 --> 00:34:41,000
Это, мы можем либо написать его, как мы сделали здесь

452
00:34:41,000 --> 00:34:43,000
с главами + q.strings.

453
00:34:43,000 --> 00:34:51,000
Много людей также писать и q.strings [глава].

454
00:34:51,000 --> 00:34:55,000
В действительности это не любое менее эффективным.

455
00:34:55,000 --> 00:34:58,000
Вы можете думать об этом, как вы разыменования его, а затем получить адрес,

456
00:34:58,000 --> 00:35:04,000
но компилятор собирается перевести его на то, что мы были представлены во всяком случае, q.strings + голова.

457
00:35:04,000 --> 00:35:06,000
В любом случае вы хотите, чтобы думать об этом.

458
00:35:06,000 --> 00:35:11,000
>> И сколько байт мы хотим, чтобы скопировать?

459
00:35:11,000 --> 00:35:15,000
[Студент] Мощность - голова.

460
00:35:15,000 --> 00:35:18,000
Вместимость - голова.

461
00:35:18,000 --> 00:35:21,000
И тогда вы всегда можете написать пример

462
00:35:21,000 --> 00:35:23,000
чтобы выяснить, если это так.

463
00:35:23,000 --> 00:35:26,000
[Студент] Она должна быть разделена на 2, то.

464
00:35:26,000 --> 00:35:30,000
Да, поэтому я думаю, мы могли бы использовать размер.

465
00:35:30,000 --> 00:35:35,000
У нас еще есть размер бытия-

466
00:35:35,000 --> 00:35:39,000
с использованием размера, у нас есть размер, равный 4.

467
00:35:39,000 --> 00:35:42,000
Наш размер 4. Наши головы 1.

468
00:35:42,000 --> 00:35:46,000
Мы хотим, чтобы скопировать эти 3 элемента.

469
00:35:46,000 --> 00:35:54,000
Это здравомыслие проверить, что размер - голова правильно 3.

470
00:35:54,000 --> 00:35:58,000
И возвращаться сюда, как мы уже говорили,

471
00:35:58,000 --> 00:36:00,000
если бы мы использовали потенциал, то мы должны были бы разделить на 2

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

473
00:36:11,000 --> 00:36:13,000
Это копий этой части.

474
00:36:13,000 --> 00:36:18,000
Теперь нам нужно скопировать другая часть, часть, что осталось от самого начала.

475
00:36:18,000 --> 00:36:28,000
>> Это собирается memmove в каком положении?

476
00:36:28,000 --> 00:36:32,000
[Студент] Большие размеры - голова.

477
00:36:32,000 --> 00:36:38,000
Да, так мы уже скопировали в размере - глава байт,

478
00:36:38,000 --> 00:36:43,000
и поэтому там, где мы хотим скопировать оставшиеся байты нового

479
00:36:43,000 --> 00:36:48,000
, а затем размер минус, ну, количество байт, мы уже скопировали дюйма

480
00:36:48,000 --> 00:36:52,000
А потом куда мы копировании?

481
00:36:52,000 --> 00:36:54,000
[Студент] Q.strings [0].

482
00:36:54,000 --> 00:36:56,000
[Rob B.] Да, q.strings.

483
00:36:56,000 --> 00:37:02,000
Мы могли либо сделать и q.strings [0].

484
00:37:02,000 --> 00:37:05,000
Это значительно реже, чем это.

485
00:37:05,000 --> 00:37:14,000
Если он просто будет 0, то вы будете склонны видеть q.strings.

486
00:37:14,000 --> 00:37:16,000
Вот где мы копировании.

487
00:37:16,000 --> 00:37:18,000
Сколько байт у нас осталось скопировать? >> [Студент] 10.

488
00:37:18,000 --> 00:37:20,000
Право.

489
00:37:20,000 --> 00:37:25,000
[Студент] Должны ли мы умножим 5 - 10 раз больше байта или еще что-нибудь?

490
00:37:25,000 --> 00:37:30,000
Да, так это где-то, что именно мы копирования?

491
00:37:30,000 --> 00:37:32,000
[Студент] [неразборчиво]

492
00:37:32,000 --> 00:37:34,000
Какой тип вещь, которую мы копирования?

493
00:37:34,000 --> 00:37:36,000
[Студент] [неразборчиво]

494
00:37:36,000 --> 00:37:41,000
Да, так что символ * ы, что мы копирования, мы не знаем, где те и откуда.

495
00:37:41,000 --> 00:37:47,000
Ну, где они указывают на, как струны, мы в конечном итоге нажав на нее в очередь

496
00:37:47,000 --> 00:37:49,000
или enqueuing на очереди.

497
00:37:49,000 --> 00:37:51,000
Где те, и откуда, мы понятия не имеем.

498
00:37:51,000 --> 00:37:56,000
Нам просто нужно следить за символ * с себя.

499
00:37:56,000 --> 00:38:00,000
Мы не хотим, чтобы скопировать размера - начальник байт.

500
00:38:00,000 --> 00:38:03,000
Мы хотим, чтобы скопировать размера - начальник символ * с,

501
00:38:03,000 --> 00:38:11,000
так что мы собираемся умножить это на SizeOf (Char *).

502
00:38:11,000 --> 00:38:17,000
То же самое здесь, внизу, голова * SizeOf (Char *).

503
00:38:17,000 --> 00:38:24,000
>> [Студент] А [неразборчиво]?

504
00:38:24,000 --> 00:38:26,000
Это прямо здесь?

505
00:38:26,000 --> 00:38:28,000
[Студент] Нет, ниже, размер - голова.

506
00:38:28,000 --> 00:38:30,000
[Rob B.] Это прямо здесь?

507
00:38:30,000 --> 00:38:32,000
Указатель арифметика.

508
00:38:32,000 --> 00:38:35,000
Как арифметика указателей будет работать это

509
00:38:35,000 --> 00:38:40,000
он автоматически умножается на размер типа, что мы имеем дело с.

510
00:38:40,000 --> 00:38:46,000
Так же, как здесь, новая + (размер - голова)

511
00:38:46,000 --> 00:38:56,000
точно соответствует и новая [размер - начальник]

512
00:38:56,000 --> 00:39:00,000
пока мы не ожидаем, что работает правильно,

513
00:39:00,000 --> 00:39:04,000
так как если мы имеем дело с Int массива, то мы не делаем индекс INT-

514
00:39:04,000 --> 00:39:07,000
или, если это размер из 5, и вы хотите 4-й элемент, то индекс в

515
00:39:07,000 --> 00:39:10,000
Int массива [4].

516
00:39:10,000 --> 00:39:14,000
Вы не-[4] * размер Int.

517
00:39:14,000 --> 00:39:21,000
, Который обрабатывает его автоматически, и этот случай

518
00:39:21,000 --> 00:39:29,000
Буквально эквивалентны, поэтому кронштейн синтаксиса

519
00:39:29,000 --> 00:39:34,000
только собирается быть преобразован в этом, как только вы компиляции.

520
00:39:34,000 --> 00:39:38,000
Это то, что вы должны быть осторожны, что

521
00:39:38,000 --> 00:39:42,000
при добавлении размеров - голова

522
00:39:42,000 --> 00:39:45,000
Вы добавляете не один байт.

523
00:39:45,000 --> 00:39:53,000
Вы добавляете один символ *, который может быть одним байт или любой другой.

524
00:39:53,000 --> 00:39:56,000
>> Другие вопросы?

525
00:39:56,000 --> 00:40:04,000
Так, из очереди будет легче.

526
00:40:04,000 --> 00:40:11,000
Я дам вам минуту, чтобы реализовать.

527
00:40:11,000 --> 00:40:18,000
Да, и я предполагаю, что это та же самая ситуация, где

528
00:40:18,000 --> 00:40:21,000
что епдиеие случае, если мы enqueuing нулевой,

529
00:40:21,000 --> 00:40:24,000
Может быть, мы хотим справиться с этим, может быть, мы не знаем.

530
00:40:24,000 --> 00:40:27,000
Мы не будем делать это снова здесь, но так же, как наш стек случае.

531
00:40:27,000 --> 00:40:34,000
Если поставить в очередь нулевые, мы могли бы на него внимания.

532
00:40:34,000 --> 00:40:40,000
Любой, есть некоторый код, я могу потянуть?

533
00:40:40,000 --> 00:40:45,000
[Студент] Я просто из очереди.

534
00:40:45,000 --> 00:40:56,000
Версия 2 является то, что, все в порядке.

535
00:40:56,000 --> 00:40:59,000
Вы хотите, чтобы объяснить?

536
00:40:59,000 --> 00:41:01,000
[Студент] Во-первых, вы убедитесь, что есть что-то в очереди

537
00:41:01,000 --> 00:41:07,000
и что размер понижается на 1.

538
00:41:07,000 --> 00:41:11,000
Вы должны сделать это, а затем вернуть его голову

539
00:41:11,000 --> 00:41:13,000
а затем переместить голову 1.

540
00:41:13,000 --> 00:41:19,000
Итак, есть уголок случае мы должны рассмотреть. Да.

541
00:41:19,000 --> 00:41:24,000
[Студент] Если ваша голова находится на последнем элементе,

542
00:41:24,000 --> 00:41:26,000
то вы не хотите голову, чтобы указать пределы массива.

543
00:41:26,000 --> 00:41:29,000
>> Да, так, как только голова касается конце нашего массива,

544
00:41:29,000 --> 00:41:35,000
Когда мы из очереди, наша голова должна быть мода на 0.

545
00:41:35,000 --> 00:41:40,000
К сожалению, мы не можем сделать это за один шаг.

546
00:41:40,000 --> 00:41:44,000
Я думаю, так, как я бы, вероятно, исправить это

547
00:41:44,000 --> 00:41:52,000
это будет символ *, то, что мы возвращаемся,

548
00:41:52,000 --> 00:41:55,000
Независимо от вашего имени переменной хочет быть.

549
00:41:55,000 --> 00:42:02,000
Затем мы хотим мода головы наших возможностей

550
00:42:02,000 --> 00:42:10,000
, а затем вернуться в отставке.

551
00:42:10,000 --> 00:42:14,000
Многие люди здесь, они могли бы сделать-

552
00:42:14,000 --> 00:42:19,000
это случай-вы будете видеть, как люди делать, если голова

553
00:42:19,000 --> 00:42:29,000
больше емкость, сделать голову - емкость.

554
00:42:29,000 --> 00:42:36,000
И это только рабочая вокруг того, что мод.

555
00:42:36,000 --> 00:42:41,000
Глава МО = емкость намного чище

556
00:42:41,000 --> 00:42:51,000
из обтекание, чем если бы голова больше, чем мощность головой - емкость.

557
00:42:51,000 --> 00:42:56,000
>> Вопросы?

558
00:42:56,000 --> 00:43:02,000
Ладно, последняя вещь, которую мы оставили наш связанного списка.

559
00:43:02,000 --> 00:43:07,000
Вы могли бы быть использованы для некоторых из связанного списка поведение, если вы сделали

560
00:43:07,000 --> 00:43:11,000
связанных списков в вашей хэш-таблицы, если вы сделали хэш-таблицы.

561
00:43:11,000 --> 00:43:15,000
Я настоятельно рекомендую делать хэш-таблицы.

562
00:43:15,000 --> 00:43:17,000
Возможно, вы уже сделали виде дерева,

563
00:43:17,000 --> 00:43:23,000
но пытается труднее.

564
00:43:23,000 --> 00:43:27,000
В теории, они асимптотически лучше.

565
00:43:27,000 --> 00:43:30,000
Но посмотрите на большой доске,

566
00:43:30,000 --> 00:43:35,000
и старается никогда не делать лучше, и они занимают больше памяти.

567
00:43:35,000 --> 00:43:43,000
Все о попытке заканчивает тем, что еще хуже для дополнительной работы.

568
00:43:43,000 --> 00:43:49,000
Это то, что решение David Malan всегда является

569
00:43:49,000 --> 00:43:56,000
он всегда свои сообщения Trie решение, и давайте посмотрим, где он в настоящее время.

570
00:43:56,000 --> 00:44:00,000
Что он под землей, David J?

571
00:44:00,000 --> 00:44:06,000
Он № 18, так что это не очень плохо,

572
00:44:06,000 --> 00:44:09,000
и что это будет один из лучших пытается Вы можете думать

573
00:44:09,000 --> 00:44:17,000
или одна из лучших пытается из Trie.

574
00:44:17,000 --> 00:44:23,000
Это даже не его оригинальное решение?

575
00:44:23,000 --> 00:44:29,000
Я чувствую, как Trie решения, как правило, больше в этой области использования оперативной памяти.

576
00:44:29,000 --> 00:44:33,000
>> Спуститесь на самый верх, и оперативной памяти находится в одной цифры.

577
00:44:33,000 --> 00:44:36,000
Спуститесь вниз к нижней, а затем вы начинаете видеть пытается

578
00:44:36,000 --> 00:44:41,000
где вы получите абсолютно массивной оперативной памяти,

579
00:44:41,000 --> 00:44:45,000
и пытается труднее.

580
00:44:45,000 --> 00:44:53,000
Не совсем, но стоит это образовательный опыт, если вы сделали один.

581
00:44:53,000 --> 00:44:56,000
Последнее, что наша связанного списка,

582
00:44:56,000 --> 00:45:04,000
и эти три вещи, стеки, очереди и связанные списки,

583
00:45:04,000 --> 00:45:09,000
любая будущая что можно сделать в области компьютерных наук

584
00:45:09,000 --> 00:45:12,000
Предположим у вас есть знакомство с этими вещами.

585
00:45:12,000 --> 00:45:19,000
Они просто таким фундаментальным ко всему.

586
00:45:19,000 --> 00:45:25,000
>> Связанные списки, и здесь мы однонаправленного списка будет наша реализация.

587
00:45:25,000 --> 00:45:34,000
Что односвязный значит, в отличие от двусвязный? Да.

588
00:45:34,000 --> 00:45:37,000
[Студент] Это только указывает на следующий указатель, а не указателей,

589
00:45:37,000 --> 00:45:39,000
как тот перед ним и после нее.

590
00:45:39,000 --> 00:45:44,000
Да, так и в формате изображения, что я только что сделал?

591
00:45:44,000 --> 00:45:48,000
У меня есть две вещи. У меня есть картины и фотографии.

592
00:45:48,000 --> 00:45:51,000
В формате изображения, наши однонаправленного списка,

593
00:45:51,000 --> 00:45:57,000
Безусловно, у нас есть какой-то указатель на главу нашего списка,

594
00:45:57,000 --> 00:46:02,000
, а затем в наш список, мы просто указатели,

595
00:46:02,000 --> 00:46:05,000
и, возможно, это указывает на нуль.

596
00:46:05,000 --> 00:46:08,000
Это будет ваш типичный рисунок однонаправленного списка.

597
00:46:08,000 --> 00:46:14,000
Дважды связанный список, вы можете пойти в обратном направлении.

598
00:46:14,000 --> 00:46:19,000
Если я дам вам любой узел в списке, то вы можете всегда получить в

599
00:46:19,000 --> 00:46:23,000
любой другой узел в список, если он дважды связанный список.

600
00:46:23,000 --> 00:46:27,000
Но если я вам третьего узла в списке, и это однонаправленный список,

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

602
00:46:30,000 --> 00:46:34,000
И есть преимуществ и недостатков, и один очевидный

603
00:46:34,000 --> 00:46:42,000
это вы занимают больше размером, и вы должны отслеживать, где эти вещи должны быть обращены сейчас.

604
00:46:42,000 --> 00:46:49,000
Но мы заботимся только о односвязанны.

605
00:46:49,000 --> 00:46:53,000
>> Несколько вещей, которые мы собираемся иметь реализовать.

606
00:46:53,000 --> 00:47:00,000
Ваша ЬурейеЕ узла структуры, Int I: Структура узла * следующий; узла.

607
00:47:00,000 --> 00:47:09,000
Это ЬурейеЕ должны быть сожжены в вашем уме.

608
00:47:09,000 --> 00:47:14,000
Викторина 1 следует хотели дать определение типа связанного списка узлов,

609
00:47:14,000 --> 00:47:18,000
и вы должны быть в состоянии немедленно строчить, что вниз

610
00:47:18,000 --> 00:47:22,000
даже не задумываясь об этом.

611
00:47:22,000 --> 00:47:27,000
Я думаю, пара вопросов, почему мы должны построим здесь?

612
00:47:27,000 --> 00:47:32,000
Почему мы не можем сказать узла *?

613
00:47:32,000 --> 00:47:35,000
[Студент] [неразборчиво]

614
00:47:35,000 --> 00:47:38,000
Да.

615
00:47:38,000 --> 00:47:44,000
Единственное, что определяет узел, как вещь

616
00:47:44,000 --> 00:47:47,000
является ЬурейеЕ себя.

617
00:47:47,000 --> 00:47:55,000
Но на данный момент, когда мы вроде разбора через это определение узла структуры,

618
00:47:55,000 --> 00:48:01,000
Мы еще не закончили нашу ЬурейеЕ еще, так что с ЬурейеЕ не закончена,

619
00:48:01,000 --> 00:48:05,000
узел не существует.

620
00:48:05,000 --> 00:48:12,000
Но структура узла делает, и этот узел сюда,

621
00:48:12,000 --> 00:48:14,000
это также можно назвать что-либо еще.

622
00:48:14,000 --> 00:48:16,000
Это можно назвать с.

623
00:48:16,000 --> 00:48:19,000
Это можно было бы назвать связанный список узлов.

624
00:48:19,000 --> 00:48:21,000
Его можно назвать что угодно.

625
00:48:21,000 --> 00:48:26,000
Но эта структура узел должен быть названо же самое, что эта структура узла.

626
00:48:26,000 --> 00:48:29,000
Что вы называете это должно быть здесь,

627
00:48:29,000 --> 00:48:32,000
и так, что также отвечает на второй точке вопрос

628
00:48:32,000 --> 00:48:37,000
Именно поэтому-много раз, когда вы видите структур и определения типов из структуры,

629
00:48:37,000 --> 00:48:42,000
Вы увидите, анонимные структуры, где вы увидите только ЬурейеЕ структуры,

630
00:48:42,000 --> 00:48:47,000
реализация структуры, словарь, или Что угодно.

631
00:48:47,000 --> 00:48:51,000
>> Почему здесь мы должны сказать узла?

632
00:48:51,000 --> 00:48:54,000
Почему она не может быть анонимной структуры?

633
00:48:54,000 --> 00:48:56,000
Это почти тот же ответ.

634
00:48:56,000 --> 00:48:58,000
[Студент] Вам нужно ссылаться на него в пределах структуры.

635
00:48:58,000 --> 00:49:04,000
Да, в пределах структуры, необходимо обратиться к структуре самого.

636
00:49:04,000 --> 00:49:10,000
Если вы не даете структуры имени, если это анонимная структура, вы не можете ссылаться на него.

637
00:49:10,000 --> 00:49:17,000
И последнее, но не менее все они должны быть несколько прямолинейно,

638
00:49:17,000 --> 00:49:20,000
и они должны помочь вам понять, если вы пишете это вниз

639
00:49:20,000 --> 00:49:24,000
что вы делаете что-то неправильно, если такого рода вещи не имеют смысла.

640
00:49:24,000 --> 00:49:28,000
Последнее, но не менее важно, почему это должна быть структура узла *?

641
00:49:28,000 --> 00:49:34,000
Почему это не может быть просто строим узла дальше?

642
00:49:34,000 --> 00:49:37,000
[Студент] Указатель на следующую структуру.

643
00:49:37,000 --> 00:49:39,000
Это неизбежно, что мы хотим.

644
00:49:39,000 --> 00:49:42,000
Почему бы это никогда не будет структура узла дальше?

645
00:49:42,000 --> 00:49:50,000
Почему это должна быть структура узла * дальше? Да.

646
00:49:50,000 --> 00:49:53,000
[Студент] Это как бесконечный цикл.

647
00:49:53,000 --> 00:49:55,000
Да.

648
00:49:55,000 --> 00:49:57,000
[Студент], что все будет в одном.

649
00:49:57,000 --> 00:50:02,000
Да, просто думаю о том, как мы будем делать размера или что-то.

650
00:50:02,000 --> 00:50:08,000
Размер структуры в основном + или - некоторые картины здесь или там.

651
00:50:08,000 --> 00:50:15,000
Это в основном будет сумма размеры вещей в структуре.

652
00:50:15,000 --> 00:50:18,000
Это прямо здесь, ничего не меняя, размер будет легко.

653
00:50:18,000 --> 00:50:24,000
Размер структуры узла будет размером я + размер следующего.

654
00:50:24,000 --> 00:50:27,000
Размер мне будет 4. Размер следующий будет 4.

655
00:50:27,000 --> 00:50:30,000
Размер структуры узла будет 8.

656
00:50:30,000 --> 00:50:34,000
Если мы не будем иметь *, думая о SizeOf,

657
00:50:34,000 --> 00:50:37,000
Затем SizeOf (I) будет 4.

658
00:50:37,000 --> 00:50:43,000
Размер структуры узла следующий будет размером я + размер структуры узла следующего

659
00:50:43,000 --> 00:50:46,000
+ Размер я + размер структуры узла следующего.

660
00:50:46,000 --> 00:50:55,000
Было бы бесконечной рекурсии узлов.

661
00:50:55,000 --> 00:51:00,000
Вот почему все это так должно быть.

662
00:51:00,000 --> 00:51:03,000
>> Опять же, обязательно запомните, что,

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

664
00:51:06,000 --> 00:51:12,000
Причиной через то, что она должна выглядеть.

665
00:51:12,000 --> 00:51:14,000
То, что мы собираемся хотим реализовать.

666
00:51:14,000 --> 00:51:18,000
Если длина списка

667
00:51:18,000 --> 00:51:21,000
Вы можете обманывать и держать вокруг

668
00:51:21,000 --> 00:51:24,000
глобальные длины или что-то, но мы не собираемся этого делать.

669
00:51:24,000 --> 00:51:28,000
Мы собираемся, чтобы подсчитать длину списка.

670
00:51:28,000 --> 00:51:34,000
Мы содержится, так что это в основном, как поиск,

671
00:51:34,000 --> 00:51:41,000
поэтому у нас есть связанный список целых чисел, чтобы увидеть, если это число находится в связанном списке.

672
00:51:41,000 --> 00:51:44,000
Присоединение будет вставить в начале списка.

673
00:51:44,000 --> 00:51:46,000
Append собирается включить в конце.

674
00:51:46,000 --> 00:51:53,000
Insert_sorted будет вставить в упорядоченные позиции в списке.

675
00:51:53,000 --> 00:52:01,000
Insert_sorted вид предполагает, что вы никогда не использовали начало или конец в плохих отношениях.

676
00:52:01,000 --> 00:52:09,000
>> Insert_sorted, когда вы реализуете insert_sorted-

677
00:52:09,000 --> 00:52:13,000
скажем, у нас есть связанный список.

678
00:52:13,000 --> 00:52:18,000
Это то, что в настоящее время он выглядит, 2, 4, 5.

679
00:52:18,000 --> 00:52:24,000
Я хочу, чтобы вставить 3, так как пока сам список уже отсортирован,

680
00:52:24,000 --> 00:52:27,000
легко найти, где 3 принадлежит.

681
00:52:27,000 --> 00:52:29,000
Я начинаю в 2.

682
00:52:29,000 --> 00:52:32,000
Ладно, 3 больше, чем 2, поэтому я хочу, чтобы продолжать идти.

683
00:52:32,000 --> 00:52:35,000
Ах, 4 слишком большой, так что я знаю 3 будет идти между 2 и 4,

684
00:52:35,000 --> 00:52:39,000
и у меня есть, чтобы исправить указатели и все такое.

685
00:52:39,000 --> 00:52:43,000
Но если мы не будем использовать строго insert_sorted,

686
00:52:43,000 --> 00:52:50,000
хотелось давайте просто скажем, я предварять 6,

687
00:52:50,000 --> 00:52:55,000
Затем мой связанного списка станет этим.

688
00:52:55,000 --> 00:53:01,000
В настоящее время она не имеет никакого смысла, поэтому для insert_sorted, можно только предположить,

689
00:53:01,000 --> 00:53:04,000
что список отсортирован, хотя существуют операции

690
00:53:04,000 --> 00:53:09,000
которые могут привести к не быть отсортированы, вот и все.

691
00:53:09,000 --> 00:53:20,000
Найти полезным вставка-так это те основные вещи, которые вы будете иметь реализовать.

692
00:53:20,000 --> 00:53:24,000
>> Сейчас, найдите минутку, чтобы сделать длину и содержит,

693
00:53:24,000 --> 00:53:30,000
и те должны быть относительно быстро.

694
00:53:41,000 --> 00:53:48,000
Близится время закрытия, так что у кого ничего длину или содержит?

695
00:53:48,000 --> 00:53:50,000
Они собираются, чтобы быть почти идентичными.

696
00:53:50,000 --> 00:53:57,000
[Студент] Длина.

697
00:53:57,000 --> 00:54:01,000
Давайте посмотрим, пересмотр.

698
00:54:01,000 --> 00:54:04,000
Хорошо.

699
00:54:12,000 --> 00:54:15,000
Вы хотите, чтобы объяснить?

700
00:54:15,000 --> 00:54:21,000
[Студент] Я просто создать указатель узлов и инициализировать его к первому, который является нашей глобальной переменной,

701
00:54:21,000 --> 00:54:27,000
а потом проверить, если это нулевой, поэтому я не получаю сегменте вина и возвращать 0, если это так.

702
00:54:27,000 --> 00:54:34,000
В противном случае, я цикле, отслеживание в течение целого

703
00:54:34,000 --> 00:54:38,000
Сколько раз я обращался к следующему элементу списка

704
00:54:38,000 --> 00:54:43,000
и в том же операцию приращения также доступ к этой фактической элемент,

705
00:54:43,000 --> 00:54:47,000
и тогда я непрерывно сделать проверку, чтобы увидеть, если это NULL,

706
00:54:47,000 --> 00:54:56,000
и если он нулевой, то он прерывает и просто возвращает количество элементов я доступен.

707
00:54:56,000 --> 00:55:01,000
>> [Rob B.] Кто-нибудь есть какие-либо комментарии на что-нибудь?

708
00:55:01,000 --> 00:55:06,000
Это выглядит прекрасно правильность мудро.

709
00:55:06,000 --> 00:55:10,000
[Студент] Я не думаю, что вам нужно узла == NULL.

710
00:55:10,000 --> 00:55:13,000
Да, так что если узел == NULL 0 возвращению.

711
00:55:13,000 --> 00:55:18,000
Но если узел == NULL, то это-о-о, есть корректности вопроса.

712
00:55:18,000 --> 00:55:23,000
Это было просто вы возвращении я, но это не входит в комплект прямо сейчас.

713
00:55:23,000 --> 00:55:30,000
Вам просто нужно Int я, так что я = 0.

714
00:55:30,000 --> 00:55:34,000
Но если узел является нулевым, то я по-прежнему будет 0,

715
00:55:34,000 --> 00:55:39,000
и мы собираемся возвращать 0, так что этот случай является одинаковым.

716
00:55:39,000 --> 00:55:48,000
Другая распространенная вещь, чтобы сохранить декларацию

717
00:55:48,000 --> 00:55:51,000
узлов внутри цикла.

718
00:55:51,000 --> 00:55:54,000
Можно сказать, что-о-о, нет.

719
00:55:54,000 --> 00:55:56,000
Давайте держать это как это.

720
00:55:56,000 --> 00:55:59,000
Я бы, наверное положить Int = 0 здесь,

721
00:55:59,000 --> 00:56:05,000
Затем узел * = первый узел здесь.

722
00:56:05,000 --> 00:56:11,000
И это, наверное, как-избавиться от этого сейчас.

723
00:56:11,000 --> 00:56:14,000
Это, наверное, как бы я написал.

724
00:56:14,000 --> 00:56:21,000
Кроме того, можно-смотря на это, как это.

725
00:56:21,000 --> 00:56:25,000
Этот цикл структура прямо здесь

726
00:56:25,000 --> 00:56:30,000
должна быть почти столь же естественно для вас, как и для Int я = 0

727
00:56:30,000 --> 00:56:33,000
Я меньше, чем длина массива я + +.

728
00:56:33,000 --> 00:56:38,000
Если это, как вы итерации по массиву, это, как вы итерацию по списку.

729
00:56:38,000 --> 00:56:45,000
>> Это должно быть второй натурой в некоторой точке.

730
00:56:45,000 --> 00:56:50,000
Имея это в виду, это будет почти то же самое.

731
00:56:50,000 --> 00:56:57,000
Вы собираетесь хотите перебрать связанного списка.

732
00:56:57,000 --> 00:57:02,000
Если узел-я понятия не имею, что величина называется.

733
00:57:02,000 --> 00:57:04,000
Я узла.

734
00:57:04,000 --> 00:57:15,000
Если значение в этом узле = я вернусь, правда, и это все.

735
00:57:15,000 --> 00:57:18,000
Обратите внимание, что только так мы когда-нибудь вернуться ложным

736
00:57:18,000 --> 00:57:23,000
, если мы перебора всей связанный список и никогда не возвращаться правда,

737
00:57:23,000 --> 00:57:29,000
так это то, что она делает.

738
00:57:29,000 --> 00:57:36,000
Как примечание стороны, мы, вероятно, не получите, чтобы добавить начале или в конце.

739
00:57:36,000 --> 00:57:39,000
>> Быстрый последней ноты.

740
00:57:39,000 --> 00:57:52,000
Если Вы видите статическую ключевым словам, так скажем статического количество Int = 0,

741
00:57:52,000 --> 00:57:56,000
Затем мы делаем фото + +, вы можете в основном думают о нем как о глобальной переменной,

742
00:57:56,000 --> 00:58:00,000
хотя я только что сказал, что это не так, как мы собираемся реализовать длины.

743
00:58:00,000 --> 00:58:06,000
Я делаю это здесь, а потом рассчитывать + +.

744
00:58:06,000 --> 00:58:11,000
В любом случае, мы можем войти узла в нашем связанного списка мы увеличивая наш счет.

745
00:58:11,000 --> 00:58:15,000
Суть этого является то, что статическая ключевое слово значит.

746
00:58:15,000 --> 00:58:20,000
Если бы я только что соипЬ = 0, что будет регулярно старых глобальных переменных.

747
00:58:20,000 --> 00:58:25,000
Что статического Int количество средств является то, что глобальная переменная за этот файл.

748
00:58:25,000 --> 00:58:28,000
Это невозможно для некоторых других файлов,

749
00:58:28,000 --> 00:58:34,000
хотелось думать о PSET 5, если вы начали.

750
00:58:34,000 --> 00:58:39,000
Вы оба speller.c, и у вас есть dictionary.c,

751
00:58:39,000 --> 00:58:42,000
и если вы просто объявить глобальную вещь, то ничего в speller.c

752
00:58:42,000 --> 00:58:45,000
можно получить в dictionary.c и наоборот.

753
00:58:45,000 --> 00:58:48,000
Глобальные переменные доступны любому. Файл с,

754
00:58:48,000 --> 00:58:54,000
но статические переменные доступны только внутри самого файла,

755
00:58:54,000 --> 00:59:01,000
так что внутри проверку орфографии или внутри dictionary.c,

756
00:59:01,000 --> 00:59:06,000
это вроде как бы я заявляю о своем переменной для размера моей массива

757
00:59:06,000 --> 00:59:10,000
или размер моего количество слов в словаре.

758
00:59:10,000 --> 00:59:15,000
Так как я не хочу, чтобы объявить глобальную переменную, что кто-то имеет доступ,

759
00:59:15,000 --> 00:59:18,000
Я действительно заботятся только о нем для моих собственных целей.

760
00:59:18,000 --> 00:59:21,000
>> Хорошая вещь об этом также весь материал столкновения имя.

761
00:59:21,000 --> 00:59:27,000
Если некоторый другой файл пытается использовать глобальную переменную с именем графа, все идет очень, очень неправильно,

762
00:59:27,000 --> 00:59:33,000
так что это хорошо держит вещи безопасны, и только вы можете получить к нему доступ,

763
00:59:33,000 --> 00:59:38,000
и никто другой не может, и если кто-то заявляет, глобальная переменная называется граф,

764
00:59:38,000 --> 00:59:43,000
то он не будет вмешиваться в вашу статической переменной кол.

765
00:59:43,000 --> 00:59:47,000
Это то, что является статическим. Это файл глобальных переменных.

766
00:59:47,000 --> 00:59:52,000
>> Вопросы о чем-нибудь?

767
00:59:52,000 --> 00:59:59,000
Все готово. Пока.

768
00:59:59,000 --> 01:00:03,000
[CS50.TV]