1
00:00:00,000 --> 00:00:11,200

2
00:00:11,200 --> 00:00:12,580
>> DAVID МАЛАН: Хорошо, с возвращением.

3
00:00:12,580 --> 00:00:13,290
Это CS50.

4
00:00:13,290 --> 00:00:15,130
Это начало недели семь.

5
00:00:15,130 --> 00:00:18,890
Так что это было некоторое время, так что я думал, что мы
принять беглый тур, где мы

6
00:00:18,890 --> 00:00:20,760
остановились и где мы теперь собираемся.

7
00:00:20,760 --> 00:00:23,310
>> Так что эта вещь здесь, возможно, придется
вызвало некоторую тоску на первый взгляд.

8
00:00:23,310 --> 00:00:27,680
Но, надеюсь, вы начинаете
акклиматизироваться к тому, что это обозначает здесь -

9
00:00:27,680 --> 00:00:32,670
звезда представляющий указатель, который
только то, что, с точки зрения более непрофессионала?

10
00:00:32,670 --> 00:00:33,400
Так что это адрес.

11
00:00:33,400 --> 00:00:35,490
>> Так что это адрес
что-то в памяти.

12
00:00:35,490 --> 00:00:38,260
И мы начали отогните слоев
Пару недель назад, и тому подобное

13
00:00:38,260 --> 00:00:41,800
GetString и других подобных функций
Все это время возвращались

14
00:00:41,800 --> 00:00:46,010
Адреса вещи в памяти, как и
адрес первого символа в

15
00:00:46,010 --> 00:00:46,990
некоторой последовательности.

16
00:00:46,990 --> 00:00:50,360
>> Таким образом, мы также ввели Valgrind, которая
Вы начнете использовать для этой проблемы

17
00:00:50,360 --> 00:00:53,380
установлена, в частности, для следующего
Проблема также установлен.

18
00:00:53,380 --> 00:00:54,980
И Valgrind и что делает для нас?

19
00:00:54,980 --> 00:00:57,520

20
00:00:57,520 --> 00:01:01,020
При этом проверка на утечки памяти, и это
также проверяет злоупотребления памяти.

21
00:01:01,020 --> 00:01:05,890
>> Он может, с некоторой вероятностью, обнаружить, если
код будет касаться памяти

22
00:01:05,890 --> 00:01:07,100
что это просто не нужно.

23
00:01:07,100 --> 00:01:10,410
Так что не обязательно утечки, но если вы
выходят за пределы некоторого

24
00:01:10,410 --> 00:01:14,730
массиве, а как вы выполните VALGRIND
и вызывают такое поведение в то время как

25
00:01:14,730 --> 00:01:17,870
Valgrind работает в вашей программе
работает внутри него, вы получите

26
00:01:17,870 --> 00:01:21,460
сообщения, как это - "Неверная писать о
размером 4 ", который, напомним пару

27
00:01:21,460 --> 00:01:25,880
недель назад означало, что я случайно
как на одного десятичного слишком далеко

28
00:01:25,880 --> 00:01:27,250
за пределами массива.

29
00:01:27,250 --> 00:01:30,790
И таким размером 4 означает здесь размер
этого конкретного внутр.

30
00:01:30,790 --> 00:01:35,260
>> Так примите заверения в том, что
valgrind есть выход, формат его,

31
00:01:35,260 --> 00:01:36,170
просто зверским.

32
00:01:36,170 --> 00:01:40,180
Это действительно трудно понять, через беспорядок
за интересную информацию.

33
00:01:40,180 --> 00:01:42,910
Итак, что мы сделали здесь просто отрывок
некоторые из пары более

34
00:01:42,910 --> 00:01:43,850
интересные строки.

35
00:01:43,850 --> 00:01:46,760
Но понимаю, что 80% valgrind есть
Выход будет немного

36
00:01:46,760 --> 00:01:47,650
отвлечение.

37
00:01:47,650 --> 00:01:52,820
>> Просто ищите модели, как эти -
недействительным права, недействительные читать, 40 байт

38
00:01:52,820 --> 00:01:56,690
и некоторое количество блоков определенно
потерян, ключевые слова, как, что.

39
00:01:56,690 --> 00:02:01,920
И то, что вы, мы надеемся увидеть некоторое
вида следов, какие функции

40
00:02:01,920 --> 00:02:03,340
ошибка на самом деле дюйма

41
00:02:03,340 --> 00:02:07,195
В этом случае здесь, в том, что линия
мой код ошибки по-видимому?

42
00:02:07,195 --> 00:02:09,729

43
00:02:09,729 --> 00:02:14,130
>> 26 в файле с именем memory.c, который был
Например, мы играли с

44
00:02:14,130 --> 00:02:14,890
в то время.

45
00:02:14,890 --> 00:02:16,460
Так что это, вероятно, не в Malloc.

46
00:02:16,460 --> 00:02:18,630
Это было, вероятно, в своем коде вместо этого.

47
00:02:18,630 --> 00:02:20,910
Таким образом, мы увидим это снова
и снова в ближайшее время.

48
00:02:20,910 --> 00:02:24,080
>> Так SCANF, это произошло в
Пару формы до сих пор.

49
00:02:24,080 --> 00:02:26,410
Мы видели Sscanf кратко.

50
00:02:26,410 --> 00:02:28,330
Это было что-то рядом
Вы нырнули в вашей

51
00:02:28,330 --> 00:02:29,535
подготовка к викторине.

52
00:02:29,535 --> 00:02:33,130
И SCANF на самом деле то, что CS50
Библиотеки используют под

53
00:02:33,130 --> 00:02:36,560
капот в течение достаточно долгого времени для того,
для получения данных от пользователя.

54
00:02:36,560 --> 00:02:40,420
>> Например, если я перееду к CS50
Прибор здесь, позвольте мне открыть

55
00:02:40,420 --> 00:02:45,315
Например сегодня, что называется SCANF-0.c
И это супер просто.

56
00:02:45,315 --> 00:02:46,590
Это всего лишь несколько строк кода.

57
00:02:46,590 --> 00:02:50,880
Но это показывает, действительно, как GetInt
работал все это время.

58
00:02:50,880 --> 00:02:54,710
>> В этой программе, в строке 16
Обратите внимание, что я заявляю Int.

59
00:02:54,710 --> 00:02:57,270
Так что никаких указателей, ничего магического
там, просто Int.

60
00:02:57,270 --> 00:03:00,330
Затем в строке 17, я предложит
пользователя число, пожалуйста.

61
00:03:00,330 --> 00:03:02,930
Затем, в конце 18, я использую SCANF здесь.

62
00:03:02,930 --> 00:03:06,910
И я указал, вроде как Е,
что я ожидаю цитатой

63
00:03:06,910 --> 00:03:08,110
конец цитаты процентов я.

64
00:03:08,110 --> 00:03:10,920
>> Так процентов я, конечно,
обозначает Int.

65
00:03:10,920 --> 00:03:14,580
Но обратите внимание на то, что второй
Аргумент SCANF есть.

66
00:03:14,580 --> 00:03:17,350
Как бы вы описали второй
Аргумент после запятой?

67
00:03:17,350 --> 00:03:19,450
Что это?

68
00:03:19,450 --> 00:03:20,670
>> Это адрес х.

69
00:03:20,670 --> 00:03:25,490
Так что это полезно, потому что, предоставляя
SCANF с адресом х, то, что делает

70
00:03:25,490 --> 00:03:29,560
, которые позволяют этой функции делать?

71
00:03:29,560 --> 00:03:33,010
Не просто идут туда, но и делать то, что?

72
00:03:33,010 --> 00:03:34,060
>> Внести изменения в нем.

73
00:03:34,060 --> 00:03:38,080
Потому что вы можете пойти туда, это своего рода
как карта к местоположению в памяти.

74
00:03:38,080 --> 00:03:41,900
И до тех пор, пока вы предоставляете SCANF или
любую функцию с такой карты, которые

75
00:03:41,900 --> 00:03:45,840
Функция может пойти туда, и не только
посмотрите значение, но он также может

76
00:03:45,840 --> 00:03:49,670
изменить это значение, которое является полезным, если
Цель в жизни является SCANF

77
00:03:49,670 --> 00:03:53,060
сканировать входные данные от пользователя, в частности
с клавиатуры.

78
00:03:53,060 --> 00:03:57,830
И F обозначает отформатированных, так же, как
Е, F обозначает отформатированных

79
00:03:57,830 --> 00:03:58,930
Строка, которую необходимо распечатать.

80
00:03:58,930 --> 00:04:04,430
>> Короче говоря, эта линия 18 просто говорит:
попробуйте прочитать Целочисленное от пользователя

81
00:04:04,430 --> 00:04:10,420
клавиатуры, и сохраняет его внутри х, в
любой адрес, х, оказывается, живет в.

82
00:04:10,420 --> 00:04:14,860
А потом, наконец, строка 19 просто говорит,
спасибо за Интернешнл, в этом случае.

83
00:04:14,860 --> 00:04:15,940
>> Итак, позвольте мне пойти дальше и сделать это.

84
00:04:15,940 --> 00:04:18,570
Поэтому убедитесь, SCANF 0.

85
00:04:18,570 --> 00:04:20,130
Позвольте мне идти вперед и увеличения масштаба

86
00:04:20,130 --> 00:04:22,960
Я пойду и выполнить это с
точками слэш SCANF 0.

87
00:04:22,960 --> 00:04:24,020
Номер, пожалуйста?

88
00:04:24,020 --> 00:04:24,720
50.

89
00:04:24,720 --> 00:04:25,730
Спасибо за 50.

90
00:04:25,730 --> 00:04:27,270
Так что это довольно просто.

91
00:04:27,270 --> 00:04:28,160
>> Теперь то, что он не делает?

92
00:04:28,160 --> 00:04:29,940
Это не делает целый букет
проверки ошибок.

93
00:04:29,940 --> 00:04:33,000
Например, если я не буду сотрудничать,
и я не вводить номер, но

94
00:04:33,000 --> 00:04:37,860
вместо этого я написать что-то вроде "привет",
это просто странно.

95
00:04:37,860 --> 00:04:41,130
И вот одна из вещей, CS50
библиотека была для нас делать для некоторых

96
00:04:41,130 --> 00:04:43,440
времени является то, что reprompting
и reprompting.

97
00:04:43,440 --> 00:04:49,320
>> Повторить фразу отзыве в cs50.c,
и это причина того, что в GetInt

98
00:04:49,320 --> 00:04:51,670
библиотеки CS50 фактически весь
куча строк, потому что мы

99
00:04:51,670 --> 00:04:53,190
проверка на глупые вещи, как это.

100
00:04:53,190 --> 00:04:55,730
Же пользователь не дают
нам, по сути, Целочисленное?

101
00:04:55,730 --> 00:04:57,910
Он или она дать нам что-то
подобное алфавитному письмо?

102
00:04:57,910 --> 00:05:01,410
Если это так, мы хотим, чтобы обнаружить
, что и кричать на них.

103
00:05:01,410 --> 00:05:03,915
>> Но все становится более интересным
В следующем примере.

104
00:05:03,915 --> 00:05:09,840
Если я пойду в SCANF-1с, то, что одна
вещь, которая коренным образом изменила в

105
00:05:09,840 --> 00:05:11,135
Следующий пример?

106
00:05:11,135 --> 00:05:13,690

107
00:05:13,690 --> 00:05:16,010
Я использую символ *, конечно,
вместо Int.

108
00:05:16,010 --> 00:05:19,210
>> Так что это интересно, потому что символ *,
Напомним, что на самом деле просто

109
00:05:19,210 --> 00:05:20,190
То же самое в виде строки.

110
00:05:20,190 --> 00:05:23,840
Таким образом, похоже, может быть, это супер
Простая реализация GetString.

111
00:05:23,840 --> 00:05:26,010
Но я отогнул слоя
CS50 из библиотеки, так что я

112
00:05:26,010 --> 00:05:27,550
вызове этого символ * сейчас.

113
00:05:27,550 --> 00:05:30,070
Итак, давайте посмотрим, где, если угодно,
мы делаем неправильно.

114
00:05:30,070 --> 00:05:30,840
>> Строка 17 -

115
00:05:30,840 --> 00:05:33,950
Я еще раз говорю, пожалуйста, дайте мне что-нибудь,
В этом случае, строка.

116
00:05:33,950 --> 00:05:37,940
И тогда в следующей строке, я называю SCANF,
снова, придав ему формат кода,

117
00:05:37,940 --> 00:05:39,310
но эта пора процентов.

118
00:05:39,310 --> 00:05:41,900
И то на этот раз, я
придав ему буфера.

119
00:05:41,900 --> 00:05:43,550
>> А теперь обратите внимание, что я не использую
амперсанд.

120
00:05:43,550 --> 00:05:47,120
Но почему в том, что здесь, вероятно, хорошо?

121
00:05:47,120 --> 00:05:49,760
Ведь что такое буфер уже?

122
00:05:49,760 --> 00:05:50,770
Это уже указатель.

123
00:05:50,770 --> 00:05:51,650
Уже адресу.

124
00:05:51,650 --> 00:05:54,510
>> И давайте это слово "путают", позвольте мне
назвать его просто с, например, для

125
00:05:54,510 --> 00:05:55,050
простота.

126
00:05:55,050 --> 00:05:58,250
Но я назвал его потому, что в буфер
Вообще, в программировании, если у вас есть

127
00:05:58,250 --> 00:06:02,130
часть памяти, которая действительно строку
просто есть, вы могли бы назвать это буфер.

128
00:06:02,130 --> 00:06:04,460
Это место для хранения информации.

129
00:06:04,460 --> 00:06:07,400
>> Похожие вещи, как YouTube, когда
они буфер, поэтому говорить, что

130
00:06:07,400 --> 00:06:10,270
просто означает, что он загрузкой битов из
Интернет и сохраняя их в

131
00:06:10,270 --> 00:06:14,160
Локальный массив, местный кусок памяти, так
что вы можете смотреть их без

132
00:06:14,160 --> 00:06:16,830
это пропуск или висит на
Вы во время воспроизведения.

133
00:06:16,830 --> 00:06:20,930
>> Так что проблема здесь, хотя,
, потому что я говорю SCANF, ожидают

134
00:06:20,930 --> 00:06:22,320
строки от пользователя.

135
00:06:22,320 --> 00:06:24,410
Вот адрес
кусок памяти.

136
00:06:24,410 --> 00:06:26,180
Поместите эту строку там.

137
00:06:26,180 --> 00:06:31,230
Почему это связанное дать
нам неприятности, правда?

138
00:06:31,230 --> 00:06:33,490
>> Что это?

139
00:06:33,490 --> 00:06:35,510
Могу ли я получить доступ к
что часть памяти?

140
00:06:35,510 --> 00:06:36,250
Вы знаете, я не знаю.

141
00:06:36,250 --> 00:06:39,210
Т.к. обладает буфером инициализирован
к чему?

142
00:06:39,210 --> 00:06:39,820
Не совсем так.

143
00:06:39,820 --> 00:06:43,090
И так это то, что мы называем
мусора значение, которое

144
00:06:43,090 --> 00:06:44,040
не является официальным словом.

145
00:06:44,040 --> 00:06:49,200
Это просто означает, что мы понятия не имею, какие биты
внутри из четырех байт, которые

146
00:06:49,200 --> 00:06:51,240
Я выделил в качестве буфера.

147
00:06:51,240 --> 00:06:52,450
>> Я не называется Malloc.

148
00:06:52,450 --> 00:06:53,940
Я определенно не называется GetString.

149
00:06:53,940 --> 00:06:56,380
Так что кто знает, что на самом деле
внутри буфера?

150
00:06:56,380 --> 00:07:00,550
И все же говорить SCANF вслепую, туда
и положить все, что ввел пользователь.

151
00:07:00,550 --> 00:07:04,460
>> Так что, вероятно, вызовет
в нашем коде, если мы его запустить?

152
00:07:04,460 --> 00:07:05,700
Наверное сегментации.

153
00:07:05,700 --> 00:07:07,970
Может и нет, но, вероятно, сегментации.

154
00:07:07,970 --> 00:07:10,620
И я говорю, может быть, не потому, что иногда
Вы делаете, иногда

155
00:07:10,620 --> 00:07:11,380
Вы не получаете сегментации.

156
00:07:11,380 --> 00:07:14,280
Иногда вам просто везет, но
это тем не менее будет

157
00:07:14,280 --> 00:07:15,340
ошибка в нашей программе.

158
00:07:15,340 --> 00:07:17,060
>> Итак, позвольте мне идти вперед и составить этот.

159
00:07:17,060 --> 00:07:18,280
Я собираюсь сделать это по-старому школе.

160
00:07:18,280 --> 00:07:23,825
Так лязгом тире 0, SCANF-1,
SCANF-1с, Enter.

161
00:07:23,825 --> 00:07:24,720
Упс, слишком старой школы.

162
00:07:24,720 --> 00:07:26,550
Давайте посмотрим.

163
00:07:26,550 --> 00:07:28,440
Где я?

164
00:07:28,440 --> 00:07:29,700
О, символ * буфера.

165
00:07:29,700 --> 00:07:33,595

166
00:07:33,595 --> 00:07:35,130
О, спасибо -

167
00:07:35,130 --> 00:07:36,930
Сохранить, OK -

168
00:07:36,930 --> 00:07:37,690
очень старая школа.

169
00:07:37,690 --> 00:07:38,900
Ладно, это было в то время.

170
00:07:38,900 --> 00:07:41,720
>> Так что я только что сохраненный файл после
делает, что временные

171
00:07:41,720 --> 00:07:42,700
изменить минуту назад.

172
00:07:42,700 --> 00:07:46,090
А теперь я собрал это
вручную с помощью Clang.

173
00:07:46,090 --> 00:07:49,500
И теперь я собираюсь идти вперед
и запустить SCANF-1, Enter.

174
00:07:49,500 --> 00:07:50,290
Струнный пожалуйста.

175
00:07:50,290 --> 00:07:51,600
Я наберите "привет".

176
00:07:51,600 --> 00:07:54,070
>> А теперь, вот где, честно говоря, Е
может немного раздражать.

177
00:07:54,070 --> 00:07:56,020
Это на самом деле не собирается
сегментации в этом случае.

178
00:07:56,020 --> 00:07:59,860
Printf стоит несколько особняком, потому что
это так супер широко используется, что

179
00:07:59,860 --> 00:08:03,570
существенно Е делает
нам одолжение и реализации,

180
00:08:03,570 --> 00:08:04,830
это не действительный указатель.

181
00:08:04,830 --> 00:08:09,080
Позвольте мне взять это на себя, чтобы просто распечатать
в нулевые скобки, даже

182
00:08:09,080 --> 00:08:13,340
хотя это и не обязательно, что
мы сами ожидали.

183
00:08:13,340 --> 00:08:16,940
>> Поэтому мы не можем действительно легко вызвать
сегментации с этим, но очевидно, что это

184
00:08:16,940 --> 00:08:18,600
не поведение я хотел.

185
00:08:18,600 --> 00:08:19,800
Так в чем же простое решение?

186
00:08:19,800 --> 00:08:25,650
Ну, а в SCANF-2, позвольте мне предложить, что
а на самом деле просто выделение

187
00:08:25,650 --> 00:08:30,100
символ *, позвольте мне быть немного умнее, о
это, и позвольте мне выделить буфер

188
00:08:30,100 --> 00:08:32,940
как последовательность из 16 символов.

189
00:08:32,940 --> 00:08:34,200
>> Так что я могу сделать это в несколько способов.

190
00:08:34,200 --> 00:08:35,610
Я мог бы использовать абсолютно Malloc.

191
00:08:35,610 --> 00:08:38,980
Но я могу вернуться в неделю два, когда
Мне просто нужно было целый букет

192
00:08:38,980 --> 00:08:39,620
символов.

193
00:08:39,620 --> 00:08:40,860
Вот только массив.

194
00:08:40,860 --> 00:08:44,870
Итак, позвольте мне вместо переопределить буфер
быть массивом из 16 символов.

195
00:08:44,870 --> 00:08:47,340
>> И теперь, когда я прохожу в буфер -

196
00:08:47,340 --> 00:08:49,940
и это то, что мы не сделали
говорить в неделю два -

197
00:08:49,940 --> 00:08:53,730
но вы можете рассматривать массив как
хотя это адреса.

198
00:08:53,730 --> 00:08:56,390
Технически, как мы видели, они
немного по-другому.

199
00:08:56,390 --> 00:09:01,290
Но SCANF не будет возражать, если вы передаете его
имя массива, потому что то,

200
00:09:01,290 --> 00:09:05,030
Clang сделает для нас по существу
лечить имя этого массива в качестве

201
00:09:05,030 --> 00:09:08,280
адрес блока 16 байт.

202
00:09:08,280 --> 00:09:09,550
>> Так что это лучше.

203
00:09:09,550 --> 00:09:12,110
Это означает, что теперь, когда я могу, мы надеемся,
выполнить следующее.

204
00:09:12,110 --> 00:09:16,800
Позвольте мне уменьшить масштаб на мгновение и
делают SCANF-2, составленный в порядке.

205
00:09:16,800 --> 00:09:19,390
Сейчас сделаю получил слэш SCANF-2.

206
00:09:19,390 --> 00:09:22,430
Струнный пожалуйста. "Hello". И это
казалось, работали в этот раз.

207
00:09:22,430 --> 00:09:26,020
>> Но кто-то может предложить сценарий
, в котором он не может все еще работает?

208
00:09:26,020 --> 00:09:28,550
Да?

209
00:09:28,550 --> 00:09:30,640
Что-то длиннее 16 символов.

210
00:09:30,640 --> 00:09:32,020
А на самом деле, мы можем быть
немного более точным.

211
00:09:32,020 --> 00:09:36,540
Что-то дольше, чем 15 символов,
потому что действительно мы должны иметь в виду,

212
00:09:36,540 --> 00:09:39,920
что нам нужно, что обратная косая черта нуля
неявно в конце строки,

213
00:09:39,920 --> 00:09:42,950
которая в стороне, как правило, SCANF
заботиться о нас.

214
00:09:42,950 --> 00:09:46,210
>> Итак, позвольте мне сделать нечто подобное -

215
00:09:46,210 --> 00:09:48,040
Иногда мы можем только
оставить все как есть, что.

216
00:09:48,040 --> 00:09:50,630
Итак, мы теперь индуцированных
наши ошибки сегментации.

217
00:09:50,630 --> 00:09:51,000
Почему?

218
00:09:51,000 --> 00:09:54,940
Потому что я набрал в более чем 15
символов, и так мы фактически

219
00:09:54,940 --> 00:09:58,280
коснулся памяти, что я на самом деле
не должен был.

220
00:09:58,280 --> 00:10:00,180
>> Так что на самом деле решение здесь?

221
00:10:00,180 --> 00:10:02,210
Ну, а что если нам нужно более длинную строку?

222
00:10:02,210 --> 00:10:03,960
Ну, мы, возможно, сделать это 32 байт.

223
00:10:03,960 --> 00:10:05,160
Ну, а если это не достаточно долго?

224
00:10:05,160 --> 00:10:06,040
Как насчет 64 байт?

225
00:10:06,040 --> 00:10:07,080
Что делать, если это не достаточно долго?

226
00:10:07,080 --> 00:10:09,640
Как насчет 128 или 200 байт?

227
00:10:09,640 --> 00:10:12,660
То, что действительно есть решение здесь, в
общем случае, если мы не знаем, в

228
00:10:12,660 --> 00:10:14,460
продвигать то, что пользователь собирается печатать?

229
00:10:14,460 --> 00:10:20,000

230
00:10:20,000 --> 00:10:23,050
>> Это просто какая-то большая боль в заднице,
честно говоря, именно поэтому

231
00:10:23,050 --> 00:10:29,050
CS50 библиотеке имеется несколько десятков строк
кода, которые в совокупности реализуют

232
00:10:29,050 --> 00:10:32,390
GetString строку таким образом, что мы не
должны знать заранее, что

233
00:10:32,390 --> 00:10:33,430
пользователь собирается ввести.

234
00:10:33,430 --> 00:10:37,370
В частности, если вы посмотрите на
cs50.c от двух недель назад, вы увидите,

235
00:10:37,370 --> 00:10:40,480
, что на самом деле делает GetString
Не используйте SCANF таким образом.

236
00:10:40,480 --> 00:10:43,720
Скорее, он читает один символ
за один раз.

237
00:10:43,720 --> 00:10:46,010
>> Потому что тот, хорошая вещь о
чтение одного символа, мы можем

238
00:10:46,010 --> 00:10:48,490
гарантировать себе всегда
иметь по крайней мере один символ.

239
00:10:48,490 --> 00:10:51,740
Я могу просто объявить символ, а затем принять
эти поистине шаги ребенка просто

240
00:10:51,740 --> 00:10:54,380
читать один символ в
время от клавиатуры.

241
00:10:54,380 --> 00:10:58,240
И потом, что вы увидите GetString
делает это каждый раз, когда заканчивается,

242
00:10:58,240 --> 00:11:02,280
скажем, 16 байт памяти, она использует
Malloc, или двоюродный брат его, чтоб

243
00:11:02,280 --> 00:11:06,810
выделить больше памяти, копирование старых
памяти в новых, а затем ползком

244
00:11:06,810 --> 00:11:09,900
вдоль, получая один символ за один раз,
и когда оно заканчивается, что

245
00:11:09,900 --> 00:11:13,370
кусок памяти, выбрасывает его, захваты
больший кусок памяти, копирует старые

246
00:11:13,370 --> 00:11:14,750
в новые и повторяет.

247
00:11:14,750 --> 00:11:18,480
И это действительно боль на самом деле
реализовать что-то же просто, как

248
00:11:18,480 --> 00:11:19,710
получение данных от пользователя.

249
00:11:19,710 --> 00:11:21,090
>> Таким образом, вы можете использовать SCANF.

250
00:11:21,090 --> 00:11:22,430
Вы можете использовать другие аналогичные функции.

251
00:11:22,430 --> 00:11:25,420
И много учебников и онлайн
примеры делают, но они все

252
00:11:25,420 --> 00:11:27,210
уязвимы к проблемам, как эта.

253
00:11:27,210 --> 00:11:29,550
И в конечном счете, получить сегментации
вид раздражает.

254
00:11:29,550 --> 00:11:30,680
Это не хорошо для пользователя.

255
00:11:30,680 --> 00:11:33,560
>> Но в худшем случае, то, что делает
это принципиально положить ваши

256
00:11:33,560 --> 00:11:37,160
код риску?

257
00:11:37,160 --> 00:11:39,250
Своего рода атаки, потенциально.

258
00:11:39,250 --> 00:11:41,680
Мы говорили об одной из таких атак -
переполнение стека.

259
00:11:41,680 --> 00:11:44,660
Но в целом, если вы имеете на это право
Переполнение буфера, как мы сделали

260
00:11:44,660 --> 00:11:48,070
Пару недель назад, только с письменной
больше, чем "привет" в стеке, вы

261
00:11:48,070 --> 00:11:52,330
действительно может взять на себя, потенциально,
компьютер, или, по крайней мере, получить данные, которые в

262
00:11:52,330 --> 00:11:53,510
не принадлежит вам.

263
00:11:53,510 --> 00:11:55,970
>> Короче говоря, именно поэтому у нас есть
этих учебных колес.

264
00:11:55,970 --> 00:11:59,090
Но теперь, мы начинаем снимать их,
как наши программы больше не нужна,

265
00:11:59,090 --> 00:12:00,610
обязательно, ввод от пользователя.

266
00:12:00,610 --> 00:12:03,960
Но в случае возникновения проблем установить шесть,
ваш вклад будет поступать из огромного

267
00:12:03,960 --> 00:12:07,520
файл словаря с некоторыми 150
лишним тысяч слов.

268
00:12:07,520 --> 00:12:10,330
>> Так что вам не придется беспокоиться о
произвольного пользователя ввода.

269
00:12:10,330 --> 00:12:13,720
Мы дадим вам некоторые предположения
об этом файле.

270
00:12:13,720 --> 00:12:20,340
Любые вопросы по указателям или SCANF
или ввода данных пользователем в целом?

271
00:12:20,340 --> 00:12:24,450
>> Ладно, быстрый взгляд то на одного
задняя темы от двух недель назад.

272
00:12:24,450 --> 00:12:28,590
И это было это понятие структуры.

273
00:12:28,590 --> 00:12:34,180
Не то, что - это понятие
Построим, которое было что?

274
00:12:34,180 --> 00:12:35,430
Что структуры сделать для нас?

275
00:12:35,430 --> 00:12:39,280

276
00:12:39,280 --> 00:12:39,860
>> Определить -

277
00:12:39,860 --> 00:12:41,710
извините?

278
00:12:41,710 --> 00:12:42,820
Определить тип переменной.

279
00:12:42,820 --> 00:12:44,410
Так вроде.

280
00:12:44,410 --> 00:12:46,180
Мы на самом деле объединения двух темах.

281
00:12:46,180 --> 00:12:49,510
Так что с ЬурейеЕ, вспомним, что мы можем
объявить типа нашей, как и

282
00:12:49,510 --> 00:12:51,500
синоним, как и строку для символ *.

283
00:12:51,500 --> 00:12:56,200
Но использование ЬурейеЕ и структуры, мы можем
создать действительно наши собственные структуры данных.

284
00:12:56,200 --> 00:12:59,600
>> Например, если я вернусь в Gedit
здесь всего мгновение, и я иду вперед

285
00:12:59,600 --> 00:13:08,230
и сделать что-то подобное, позвольте мне сохранить
это как, скажем, structs.c

286
00:13:08,230 --> 00:13:10,840
временно, я просто хочу,
идти вперед и включают

287
00:13:10,840 --> 00:13:14,360
standardio.h, тап_п недействительными.

288
00:13:14,360 --> 00:13:18,960
А потом здесь, предположим, что я хочу
написать программу, которая хранит

289
00:13:18,960 --> 00:13:21,840
несколько студентов из нескольких
дома, например.

290
00:13:21,840 --> 00:13:24,430
Так что это как registrarial
данных какой-то.

291
00:13:24,430 --> 00:13:29,550
>> Так что, если мне нужно название одного студента, я
может сделать что-то вроде символа имя *,

292
00:13:29,550 --> 00:13:31,570
и я сделаю что-то вроде -

293
00:13:31,570 --> 00:13:34,410
На самом деле, мы будем использовать CS50 библиотеке
на мгновение, чтобы сделать это

294
00:13:34,410 --> 00:13:38,380
немного проще, так что мы можем заимствовать
тех десятков строк кода.

295
00:13:38,380 --> 00:13:39,340
И давайте просто держать его проста.

296
00:13:39,340 --> 00:13:42,610
Мы будем держать это строка,
и теперь GetString.

297
00:13:42,610 --> 00:13:47,420
>> Поэтому я утверждаю, теперь, когда я хранится название
некоторых студентов, и дом

298
00:13:47,420 --> 00:13:50,240
какой-нибудь студент, просто с помощью переменных
как мы делали и в неделю один.

299
00:13:50,240 --> 00:13:52,370
Но предположим, что я теперь хочу поддержать
несколько студентов.

300
00:13:52,370 --> 00:13:58,460
Ладно, так что мои инстинкты делать
Строка name2, получает GetString, строка

301
00:13:58,460 --> 00:14:01,370
Дом2 получает GetString.

302
00:14:01,370 --> 00:14:05,850
А потом наш третий студент,
давайте сделаем name3 GetString.

303
00:14:05,850 --> 00:14:09,170
>> Ладно, так что это, мы надеемся, поразительно
Вы как вида глупо,

304
00:14:09,170 --> 00:14:11,580
потому что этот процесс не будет действительно никогда
кончится, и он просто будет

305
00:14:11,580 --> 00:14:13,130
сделать мой код выглядит хуже
и все хуже и хуже.

306
00:14:13,130 --> 00:14:14,810
Но мы решили это тоже в неделю два.

307
00:14:14,810 --> 00:14:19,450
Что представляла из себя относительно чистым решением
когда у нас было несколько переменных

308
00:14:19,450 --> 00:14:23,580
тот же тип данных, которые все связаны, но
мы не хотели этого жестокого беспорядок

309
00:14:23,580 --> 00:14:26,870
из одноименных переменных?

310
00:14:26,870 --> 00:14:30,060
Что мы сделали, а?

311
00:14:30,060 --> 00:14:31,260
>> Так что я думаю, что я услышал, что несколько мест.

312
00:14:31,260 --> 00:14:32,590
У нас было множество.

313
00:14:32,590 --> 00:14:37,110
Если вы хотите несколько экземпляров
что-то, почему бы нам не очистить это все

314
00:14:37,110 --> 00:14:39,540
и просто сказать, дайте мне
Массив обзывали?

315
00:14:39,540 --> 00:14:41,640
>> А пока, давайте жесткий 3 кода.

316
00:14:41,640 --> 00:14:44,450
А потом дать мне еще один массив
называемые дома, и пусть меня

317
00:14:44,450 --> 00:14:45,800
Теперь жесткий код 3.

318
00:14:45,800 --> 00:14:49,220
И я массово очищены
беспорядок, что я только что создали.

319
00:14:49,220 --> 00:14:52,400
Теперь, я по-прежнему жестко 3, но даже
3 может динамически исходить от

320
00:14:52,400 --> 00:14:54,350
пользователя, или агду или тому подобное.

321
00:14:54,350 --> 00:14:55,720
Так что это уже чище.

322
00:14:55,720 --> 00:15:00,100
>> Но то, что раздражает в этом то, что
Теперь, даже если зовут как-то

323
00:15:00,100 --> 00:15:02,280
принципиально связано с
студенческий дом -

324
00:15:02,280 --> 00:15:04,720
это студент, что я действительно
хотим представить -

325
00:15:04,720 --> 00:15:08,080
Теперь у меня есть два массива, которые параллельны
В том смысле, что они

326
00:15:08,080 --> 00:15:13,930
одинаковый размер, и имена кронштейн 0
Предположительно карт для дома кронштейн 0,

327
00:15:13,930 --> 00:15:16,600
имена и кронштейном 1 карт
Кронштейн в дома 1.

328
00:15:16,600 --> 00:15:19,280
Другими словами, что студент живет в
этот дом, то, что другой студент

329
00:15:19,280 --> 00:15:20,530
жизнь в этом другом доме.

330
00:15:20,530 --> 00:15:23,720
Но, конечно, это может быть
сделали еще более чисто.

331
00:15:23,720 --> 00:15:24,990
>> Ну, может, на самом деле.

332
00:15:24,990 --> 00:15:28,730
И позвольте мне идти вперед и открыть
до structs.h, и Вы будете

333
00:15:28,730 --> 00:15:31,130
см. эту идею здесь.

334
00:15:31,130 --> 00:15:34,905
Обратите внимание, что я использовал, объявление типа, как вы
ссылался на момент назад, чтобы заявить о своей

335
00:15:34,905 --> 00:15:35,570
собственный тип данных.

336
00:15:35,570 --> 00:15:39,660
Но я также использую эту другому ключевому слову
называется структура, которая дает мне новое

337
00:15:39,660 --> 00:15:40,790
Структура данных.

338
00:15:40,790 --> 00:15:43,980
>> И эта структура данных я утверждаю, что происходит
иметь две вещи внутри

339
00:15:43,980 --> 00:15:47,060
это - строка называется имя и
Строка называется домом.

340
00:15:47,060 --> 00:15:49,820
И имя я собираюсь дать
эта структура данных будет

341
00:15:49,820 --> 00:15:51,005
называться учеником.

342
00:15:51,005 --> 00:15:54,030
Я мог бы назвать это все, что захочу,
но это делает семантически

343
00:15:54,030 --> 00:15:55,810
смысл для меня в моем сознании.

344
00:15:55,810 --> 00:15:59,160
>> Так что теперь, если я открываю лучшую версию
программы я начал писать

345
00:15:59,160 --> 00:16:00,390
там, позвольте мне перейти к вершине.

346
00:16:00,390 --> 00:16:03,190
И есть еще несколько строк кода
здесь, но позвольте мне остановиться на

347
00:16:03,190 --> 00:16:04,160
момент на один.

348
00:16:04,160 --> 00:16:07,790
Я объявил постоянный называемых студентов
и жестко 3 на данный момент.

349
00:16:07,790 --> 00:16:11,110
Но теперь, обратите внимание, как чистый
мой код начинает получать.

350
00:16:11,110 --> 00:16:15,030
>> В строке 22 я заявляю
Массив студентов.

351
00:16:15,030 --> 00:16:18,760
И заметьте, что студент по-видимому
Теперь тип данных.

352
00:16:18,760 --> 00:16:23,360
Потому что в верхней части этого файла, заметит
Я включил этот заголовок файла

353
00:16:23,360 --> 00:16:24,820
что я остановился на минуту назад.

354
00:16:24,820 --> 00:16:28,820
, А этот заголовок файла просто-напросто было
это определение студента.

355
00:16:28,820 --> 00:16:32,470
>> Так что теперь, я создал мои собственные пользовательские данные
Тип что авторы лет C

356
00:16:32,470 --> 00:16:33,890
назад не думали заранее.

357
00:16:33,890 --> 00:16:34,570
Но не проблема.

358
00:16:34,570 --> 00:16:35,870
Я могу сделать это сам.

359
00:16:35,870 --> 00:16:39,050
Так что это массив с именем студентов,
каждый из членов которой

360
00:16:39,050 --> 00:16:41,100
является студентом структуры.

361
00:16:41,100 --> 00:16:44,270
И я хочу, три из них
в массиве.

362
00:16:44,270 --> 00:16:46,030
>> И сейчас, что сделает все остальное
этой программы делать?

363
00:16:46,030 --> 00:16:47,550
Мне нужно что-то немного произвольным.

364
00:16:47,550 --> 00:16:51,450
Так что с онлайн 24 годов,
Я итерации от 0 до 3.

365
00:16:51,450 --> 00:16:54,000
Я тогда спрашиваю у пользователя
Имя и фамилия учащегося.

366
00:16:54,000 --> 00:16:56,110
А затем использую GetString, как раньше.

367
00:16:56,110 --> 00:16:59,410
Тогда я спрашиваю для дома студента,
и я использую GetString, как раньше.

368
00:16:59,410 --> 00:17:01,780
>> Но обратите внимание - несколько новых
часть синтаксиса -

369
00:17:01,780 --> 00:17:07,010
Я до сих пор индекс к I-го студента,
но как я могу получить на конкретных данных

370
00:17:07,010 --> 00:17:08,354
поле внутри структуры?

371
00:17:08,354 --> 00:17:11,770
Ну, что по-видимому
новая часть синтаксиса?

372
00:17:11,770 --> 00:17:13,339
Это просто точка оператора.

373
00:17:13,339 --> 00:17:14,510
>> Мы на самом деле не видел этого раньше.

374
00:17:14,510 --> 00:17:17,819
Вы видели это в PSET пять, если у вас есть
нырнул в уже и графических файлов.

375
00:17:17,819 --> 00:17:22,372
Но просто означает, что точка внутри этого
структуры или несколько полей, дать точку

376
00:17:22,372 --> 00:17:24,510
имя, или дайте мне точку дома.

377
00:17:24,510 --> 00:17:28,690
Это означает, что ты внутри структуры
и получить эти конкретных областях.

378
00:17:28,690 --> 00:17:30,200
>> Что делает остальную часть этой программы делать?

379
00:17:30,200 --> 00:17:31,190
Это еще не все, что сексуально.

380
00:17:31,190 --> 00:17:34,640
Заметьте, что я итерации от 0 до 3 раз,
и я просто создаю английском

381
00:17:34,640 --> 00:17:40,500
фраза типа так и так находится в таком и
такой дом, переходя в точку название от

382
00:17:40,500 --> 00:17:43,320
I-го студента и их
дома, а также.

383
00:17:43,320 --> 00:17:47,560
>> А потом, наконец, теперь мы начнем, чтобы получить
Анальный об этом, теперь, когда мы

384
00:17:47,560 --> 00:17:49,580
знакомы с тем, что и Malloc
другие функции были

385
00:17:49,580 --> 00:17:50,570
делал все это время.

386
00:17:50,570 --> 00:17:54,220
Почему я должен освободить оба названия
и дома, хотя я

387
00:17:54,220 --> 00:17:56,960
не звонил Malloc?

388
00:17:56,960 --> 00:17:58,020
>> GetString сделал.

389
00:17:58,020 --> 00:18:00,930
И это был маленький грязный секрет для
несколько недель, но GetString имеет

390
00:18:00,930 --> 00:18:03,530
была утечка памяти во всем
разместить весь семестр до сих пор.

391
00:18:03,530 --> 00:18:05,990
И, наконец, valgrand
показать это нам.

392
00:18:05,990 --> 00:18:10,730
>> Но это не имеет большого значения, потому что я знаю
что я могу просто освободить имя

393
00:18:10,730 --> 00:18:15,750
и дом, хотя технически, чтобы
быть супер, супер безопасный, я должен быть

394
00:18:15,750 --> 00:18:17,890
делают некоторые здесь ошибки.

395
00:18:17,890 --> 00:18:19,040
Каковы ваши инстинкты говорю?

396
00:18:19,040 --> 00:18:22,480
Что я должен для проверки
прежде чем я бесплатно Что является

397
00:18:22,480 --> 00:18:25,470
Строка, которая ака символ *?

398
00:18:25,470 --> 00:18:33,460
>> Я должен действительно быть проверка, если студенты
Кронштейн я точка имя не

399
00:18:33,460 --> 00:18:34,840
равным нулю.

400
00:18:34,840 --> 00:18:40,400
Тогда все будет в порядке, чтобы идти вперед и бесплатно
что указатель, и то же или другое

401
00:18:40,400 --> 00:18:41,160
, а также.

402
00:18:41,160 --> 00:18:46,860
Если студенты кронштейн я точка дом не
равна нулю, это теперь будет защищать

403
00:18:46,860 --> 00:18:52,520
по отношению к углу случай, в котором
GetString возвращает что-то вроде нулевой.

404
00:18:52,520 --> 00:18:57,310
И мы увидели минуту назад, Е будет
защитить нас здесь, просто говоря

405
00:18:57,310 --> 00:18:58,990
пустое значение, что будет выглядеть странно.

406
00:18:58,990 --> 00:19:02,340
Но по крайней мере не будут падать,
как мы уже видели.

407
00:19:02,340 --> 00:19:05,990
>> Ну, позвольте мне сделать еще одну вещь здесь.
структур-0 это своего рода глупые программы

408
00:19:05,990 --> 00:19:09,700
, потому что я все это ввести данные, а затем
он потерял, когда программа заканчивается.

409
00:19:09,700 --> 00:19:10,940
Но позвольте мне идти вперед и делать это.

410
00:19:10,940 --> 00:19:12,830
Позвольте мне сделать терминал
окна немного больше.

411
00:19:12,830 --> 00:19:17,000
Позвольте мне сделать структур-1, который
это новая версия этого.

412
00:19:17,000 --> 00:19:18,520
>> Я увеличить немного.

413
00:19:18,520 --> 00:19:21,620
А теперь позвольте мне работать точка
слэш структур-1.

414
00:19:21,620 --> 00:19:22,590
Имя и фамилия учащегося -

415
00:19:22,590 --> 00:19:31,500
Дэвид Mather, давайте сделаем Роб Kirkland,
давайте сделаем Левереттом Лорен.

416
00:19:31,500 --> 00:19:33,650
Что интересно, теперь уведомления -

417
00:19:33,650 --> 00:19:35,540
и я знаю, что это только потому, что
Я написал программу -

418
00:19:35,540 --> 00:19:38,930
есть файл теперь на моем текущем
каталог с именем students.csv.

419
00:19:38,930 --> 00:19:40,420
Некоторые из вас, возможно, видели
это в реальном мире.

420
00:19:40,420 --> 00:19:42,980
>> Что такое файл CSV?

421
00:19:42,980 --> 00:19:44,170
Значений, разделенных запятыми.

422
00:19:44,170 --> 00:19:46,670
Это вроде как бедного человека
версия файла Excel.

423
00:19:46,670 --> 00:19:50,580
Это таблица строк и столбцов,
Вы можете открыть в программу, как Excel,

424
00:19:50,580 --> 00:19:51,800
или цифры на Mac.

425
00:19:51,800 --> 00:19:55,180
>> И если я открываю этот файл здесь на Gedit,
уведомление - а цифры там нет.

426
00:19:55,180 --> 00:19:57,360
Вот только говорить GEdit
мне номера строк.

427
00:19:57,360 --> 00:19:59,740
Обратите внимание, на первой линии этого
Файл Давида и Mather.

428
00:19:59,740 --> 00:20:01,450
Следующая строка Rob Kirkland запятой.

429
00:20:01,450 --> 00:20:04,170
И третья линия Лорен
Левереттом запятой.

430
00:20:04,170 --> 00:20:05,480
>> Так что же я создал?

431
00:20:05,480 --> 00:20:09,580
Я теперь написано-программу, которая
эффективно может генерировать таблицы

432
00:20:09,580 --> 00:20:11,840
которые могут быть открыты в
программы, как Excel.

433
00:20:11,840 --> 00:20:15,520
Не все, что убедительным набором данных, но
если у вас есть много больших кусков

434
00:20:15,520 --> 00:20:18,440
данные, которые вы действительно хотите
манипулировать и делать графики и

435
00:20:18,440 --> 00:20:21,260
нравится, это, пожалуй, один
способ создания этих данных.

436
00:20:21,260 --> 00:20:25,370
Кроме того, CSV, на самом деле супер общие
просто для хранения простых данных -

437
00:20:25,370 --> 00:20:28,940
Yahoo Finance, например, если вы получаете
котировки акций с помощью своих так называемых

438
00:20:28,940 --> 00:20:33,180
API, бесплатный сервис, который позволяет
получить ток до-к-дата акции

439
00:20:33,180 --> 00:20:35,650
котировки компаний, они
дать данные обратно в

440
00:20:35,650 --> 00:20:37,800
супер простой формат CSV.

441
00:20:37,800 --> 00:20:39,380
>> Так как же мы это сделаем?

442
00:20:39,380 --> 00:20:42,530
Хорошо заметить, большая часть этой программы
почти то же самое.

443
00:20:42,530 --> 00:20:46,870
Но обратите внимание, здесь, внизу, а не для печати
студентов, операции по линии 35

444
00:20:46,870 --> 00:20:51,040
и далее, я утверждаю, что я экономлю
студентов на диск, так что сохранение файла.

445
00:20:51,040 --> 00:20:53,630
>> Так заметить я объявляю файл * -

446
00:20:53,630 --> 00:20:57,260
Теперь, это вид аномалии в C.
По какой-то причине, то файл будет заглавными буквами,

447
00:20:57,260 --> 00:21:00,690
который не похож на большинство других типов данных
в C. Но это встроенный

448
00:21:00,690 --> 00:21:02,320
Тип данных, файл *.

449
00:21:02,320 --> 00:21:05,900
И я объявляю указатель на файл,
как вы можете думать об этом.

450
00:21:05,900 --> 00:21:08,070
>> FOPEN означает открытый файл.

451
00:21:08,070 --> 00:21:09,470
Какую файловую вы хотите открыть?

452
00:21:09,470 --> 00:21:12,620
Я хочу открыть файл, который я буду
Условно назовем students.csv.

453
00:21:12,620 --> 00:21:14,480
Я могу позвонить, что все, что захочу.

454
00:21:14,480 --> 00:21:15,200
>> А потом сделать предположение.

455
00:21:15,200 --> 00:21:18,960
Что означает второй аргумент
к FOPEN, вероятно, означает?

456
00:21:18,960 --> 00:21:21,480
Право, W для записи, может
быть R для чтения.

457
00:21:21,480 --> 00:21:24,120
Там есть для добавления, если вы
хотите добавить строки, а не

458
00:21:24,120 --> 00:21:25,200
переписать все это.

459
00:21:25,200 --> 00:21:28,005
>> Но я просто хочу создать этот файл
один раз, поэтому я буду использовать в кавычках Вт.

460
00:21:28,005 --> 00:21:31,880
И я знаю, что только прочитав
документации, или справочные страницы.

461
00:21:31,880 --> 00:21:35,100
Если файл не является нулевым, - другими словами,
если ничего не пошло не так там -

462
00:21:35,100 --> 00:21:37,820
Позвольте мне перебора
студентов от 0 до 3.

463
00:21:37,820 --> 00:21:40,410
>> А теперь обратите внимание, есть что-то
очень немного разный

464
00:21:40,410 --> 00:21:42,110
о линии 41 здесь.

465
00:21:42,110 --> 00:21:42,960
Это не Е.

466
00:21:42,960 --> 00:21:46,530
Это Fprintf Е для файла.

467
00:21:46,530 --> 00:21:47,790
Так это будет запись в файл.

468
00:21:47,790 --> 00:21:48,860
Какой файл?

469
00:21:48,860 --> 00:21:53,630
Один, указатель указать
В качестве первого аргумента.

470
00:21:53,630 --> 00:21:55,940
>> Затем мы указываем строку формата.

471
00:21:55,940 --> 00:21:59,660
Затем мы определяем, какие строки мы хотим
плагин для первого с процентов, а

472
00:21:59,660 --> 00:22:04,320
затем другой переменной или
второй с процентов.

473
00:22:04,320 --> 00:22:06,760
Тогда мы закрываем файл с FCLOSE.

474
00:22:06,760 --> 00:22:09,380
Чем я освободить память, как и раньше, хотя
Я должен вернуться и добавить

475
00:22:09,380 --> 00:22:10,540
некоторые проверки для нулевых.

476
00:22:10,540 --> 00:22:12,090
>> И это все.

477
00:22:12,090 --> 00:22:16,960
FOPEN, Fprintf, FCLOSE дает мне
возможность создавать текстовые файлы.

478
00:22:16,960 --> 00:22:19,640
Теперь, вы увидите в Архив задач пять,
который включает в себя изображения, которые вы будете использовать

479
00:22:19,640 --> 00:22:20,990
двоичные файлы вместо этого.

480
00:22:20,990 --> 00:22:24,200
Но важно то, что идея та же,
, хотя эти функции вы будете

481
00:22:24,200 --> 00:22:28,710
видите, немного по-другому.

482
00:22:28,710 --> 00:22:32,580
>> Так ураганный тур, но вы получите
слишком хорошо знакомы с файла I/O--

483
00:22:32,580 --> 00:22:34,960
входные и выходные - с PSET пять.

484
00:22:34,960 --> 00:22:38,607
И все вопросы о
начальные основы здесь?

485
00:22:38,607 --> 00:22:39,857
Да?

486
00:22:39,857 --> 00:22:41,880

487
00:22:41,880 --> 00:22:43,710
>> Что, если вы попытаетесь освободить нулевое значение?

488
00:22:43,710 --> 00:22:48,880
Я считаю, если бесплатно не получила
немного более удобным для пользователей, вы можете

489
00:22:48,880 --> 00:22:49,890
потенциально сегментация.

490
00:22:49,890 --> 00:22:54,160
Передача его недействительным плохо, потому что я не
верю бесплатно мешает проверить для вас,

491
00:22:54,160 --> 00:22:57,330
потому что это потенциально может быть пустой тратой
времени для того, чтобы сделать для себя

492
00:22:57,330 --> 00:22:59,022
каждый человек в мире.

493
00:22:59,022 --> 00:23:00,590
Хороший вопрос, однако.

494
00:23:00,590 --> 00:23:04,300
>> Хорошо, поэтому этот вид получает
нам интересную тему.

495
00:23:04,300 --> 00:23:07,010
Темой проблемой набора
пять является криминалистика.

496
00:23:07,010 --> 00:23:08,420
По крайней мере, часть
проблемы набора.

497
00:23:08,420 --> 00:23:12,030
Криминалистика в целом относится к
восстановление информации, которые могут или

498
00:23:12,030 --> 00:23:14,110
не может быть удален
намеренно.

499
00:23:14,110 --> 00:23:18,680
И поэтому я думал, что дам вам быстрый
вкус того, что происходит на самом деле все

500
00:23:18,680 --> 00:23:21,230
на этот раз под
капотом вашего компьютера.

501
00:23:21,230 --> 00:23:23,960
>> Например, если у вас есть внутри вашего
ноутбуке или настольном компьютере

502
00:23:23,960 --> 00:23:28,040
жесткий диск, это либо механическими
устройство, которое на самом деле спины -

503
00:23:28,040 --> 00:23:31,650
есть, что называется круговой пластины
, которые выглядят совсем как то, что я

504
00:23:31,650 --> 00:23:34,540
только что был на экране здесь, хотя
это более старой школы.

505
00:23:34,540 --> 00:23:37,370
Это три с половиной дюйма
жесткого диска.

506
00:23:37,370 --> 00:23:40,070
И три с половиной дюйма относится из
с этой вещи, когда вы установите его

507
00:23:40,070 --> 00:23:40,890
в компьютере.

508
00:23:40,890 --> 00:23:44,890
>> Многие из вас, ребята, в ваших ноутбуков сейчас
есть твердотельные накопители или твердотельные накопители,

509
00:23:44,890 --> 00:23:46,260
которые не имеют движущихся частей.

510
00:23:46,260 --> 00:23:49,170
Они больше похожи на ОЗУ, а не как
эти механические устройства.

511
00:23:49,170 --> 00:23:51,450
Но идеи все те же,
конечно же, как они относятся

512
00:23:51,450 --> 00:23:52,790
на вопрос, поставленный пять.

513
00:23:52,790 --> 00:23:57,400
>> И если вы думаете о теперь жесткий диск
представляет будучи круг, который

514
00:23:57,400 --> 00:23:58,930
Я нарисую вот так вот.

515
00:23:58,930 --> 00:24:02,290
Когда вы создаете файл на вашем компьютере,
будь то SSD или в

516
00:24:02,290 --> 00:24:06,610
этом случае старший школьный жестком диске,
этот файл содержит несколько битов.

517
00:24:06,610 --> 00:24:10,510
Давайте предположим, что это это 0 и 1,
целый букет из 0 и 1.

518
00:24:10,510 --> 00:24:11,660
Так что это мой весь жесткий диск.

519
00:24:11,660 --> 00:24:13,225
Это, очевидно, довольно большой файл.

520
00:24:13,225 --> 00:24:18,080
И он использует до 0 и 1, что на
часть физического пластины.

521
00:24:18,080 --> 00:24:19,750
>> Ну, что же, что физическая часть?

522
00:24:19,750 --> 00:24:25,310
Ну, получается, что на жестком диске,
по крайней мере такого типа, есть

523
00:24:25,310 --> 00:24:27,340
эти маленькие магнитные частицы.

524
00:24:27,340 --> 00:24:32,630
И они по сути есть север и
южный полюса к ним, так что, если вы

525
00:24:32,630 --> 00:24:35,710
свою очередь, один из тех магнитных частиц
Таким образом, можно сказать, что это

526
00:24:35,710 --> 00:24:36,720
представляющих 1.

527
00:24:36,720 --> 00:24:39,340
И если это вверх ногами на юг к
Север, вы могли бы сказать, что это

528
00:24:39,340 --> 00:24:40,390
представляющие 0.

529
00:24:40,390 --> 00:24:43,660
>> Таким образом, в реальном физическом мире, это
как вы могли бы представлять собой нечто в

530
00:24:43,660 --> 00:24:45,670
двоичный состояния 0 и 1.

531
00:24:45,670 --> 00:24:46,720
Так что все файл.

532
00:24:46,720 --> 00:24:49,300
Там целая куча магнитного
частицы, которые их так или

533
00:24:49,300 --> 00:24:51,920
Таким образом, создание модели
0 и 1.

534
00:24:51,920 --> 00:24:56,760
>> Но, оказывается, когда вы сохраняете файл,
некоторая информация сохраняется отдельно.

535
00:24:56,760 --> 00:25:00,000
Таким образом, это столик,
каталог, так сказать.

536
00:25:00,000 --> 00:25:05,810
И я называю это имя столбца, а
Я назову эту колонку месте.

537
00:25:05,810 --> 00:25:08,850
>> И я собираюсь сказать, предположим,
это мое резюме.

538
00:25:08,850 --> 00:25:14,050
Мой resume.doc хранится при
месте, скажем, 123.

539
00:25:14,050 --> 00:25:15,390
Я всегда иду на это число.

540
00:25:15,390 --> 00:25:18,810
Но достаточно сказать, что, как и
в оперативной памяти, вы можете взять жесткий диск

541
00:25:18,810 --> 00:25:22,350
вот гигабайт или 200 гигабайтов
и терабайт, и вы можете

542
00:25:22,350 --> 00:25:23,750
число все байты.

543
00:25:23,750 --> 00:25:26,480
Вы можете пронумеровать все куски 8 бит.

544
00:25:26,480 --> 00:25:29,030
>> Поэтому мы будем говорить, что это
123, является расположение.

545
00:25:29,030 --> 00:25:32,070
Так что этот каталог внутри моей операционной
Система помнит, что моя

546
00:25:32,070 --> 00:25:34,250
Резюме находится в местоположении 123.

547
00:25:34,250 --> 00:25:36,850
Но самое интересное, когда
Вы удаляете файл.

548
00:25:36,850 --> 00:25:37,820
>> Так, например -

549
00:25:37,820 --> 00:25:40,790
и, к счастью, большинство стран мира имеет
поймали на этом - что происходит, когда

550
00:25:40,790 --> 00:25:45,040
вы перетащите файл в ваш мусор Mac OS
или ваш Windows корзины?

551
00:25:45,040 --> 00:25:48,290

552
00:25:48,290 --> 00:25:50,510
Какая цель делать это?

553
00:25:50,510 --> 00:25:53,860
Это, очевидно, чтобы избавиться от файлов,
но то, что делает акт перемещении и

554
00:25:53,860 --> 00:25:57,550
падения в ваш мусор или ваш
Корзины делать на компьютере?

555
00:25:57,550 --> 00:25:59,230
>> Совершенно ничего, на самом деле.

556
00:25:59,230 --> 00:26:00,320
Это просто, как папки.

557
00:26:00,320 --> 00:26:01,800
Это особая папка, чтобы быть уверенным.

558
00:26:01,800 --> 00:26:04,460
Но так ли это на самом деле удалить файл?

559
00:26:04,460 --> 00:26:06,780
>> Ну, нет, потому что некоторые из вас, наверное
был похож, ой блин, вы этого не сделали

560
00:26:06,780 --> 00:26:07,420
хотел этого делать.

561
00:26:07,420 --> 00:26:09,130
Таким образом, вы дважды щелкните
Trash или корзины.

562
00:26:09,130 --> 00:26:11,630
Вы ткнули вокруг, и вы выздоровели
файл, просто перетащив его

563
00:26:11,630 --> 00:26:12,110
оттуда.

564
00:26:12,110 --> 00:26:14,420
Итак, ясно, что это не обязательно
удалением.

565
00:26:14,420 --> 00:26:15,990
>> Хорошо, что ты умнее.

566
00:26:15,990 --> 00:26:18,860
Вы знаете, что просто перетащить его в
Корзины или корзины не означает

567
00:26:18,860 --> 00:26:19,930
Вы очистке корзины.

568
00:26:19,930 --> 00:26:24,110
Так вы идете до меня, а вы говорите
Очистить корзину или пустой корзины.

569
00:26:24,110 --> 00:26:25,360
Тогда что происходит?

570
00:26:25,360 --> 00:26:29,070

571
00:26:29,070 --> 00:26:32,530
>> Да, так оно удаляется больше.

572
00:26:32,530 --> 00:26:37,660
Но все, что происходит это.

573
00:26:37,660 --> 00:26:45,350
Компьютер забывает, где
resume.doc было.

574
00:26:45,350 --> 00:26:47,400
>> Но то, что не изменилось по-видимому
на картинке?

575
00:26:47,400 --> 00:26:51,390

576
00:26:51,390 --> 00:26:55,570
Бит, 0 и 1, что я утверждаю, являются
На территории некоторых физический аспект

577
00:26:55,570 --> 00:26:56,280
аппаратных средств.

578
00:26:56,280 --> 00:26:57,110
Они все еще там.

579
00:26:57,110 --> 00:26:58,930
Это просто компьютер
забыл, что они есть.

580
00:26:58,930 --> 00:27:03,160
>> Так что это по сути освободил файла
Биты так что они могут быть использованы повторно.

581
00:27:03,160 --> 00:27:06,940
Но не раньше, вы создаете несколько файлов,
и более файлов и многое другое файлы

582
00:27:06,940 --> 00:27:12,150
вероятностно, те, 0 и 1,
эти магнитные частицы, используются повторно,

583
00:27:12,150 --> 00:27:16,220
вверх или правой стороной вверх, для
другие файлы, 0 и 1.

584
00:27:16,220 --> 00:27:17,980
>> Так что у вас есть этот промежуток времени.

585
00:27:17,980 --> 00:27:19,860
И это не предсказуемых
Длина, на самом деле.

586
00:27:19,860 --> 00:27:22,240
Это зависит от размера жесткого
диск и сколько файлов у вас есть и

587
00:27:22,240 --> 00:27:23,490
как быстро вы сделать новые.

588
00:27:23,490 --> 00:27:27,050
Но есть окно времени, в течение
который, что файл все еще прекрасно

589
00:27:27,050 --> 00:27:27,770
возмещена.

590
00:27:27,770 --> 00:27:31,050
>> Так что если вы когда-либо использовать программы, как McAfee
или Нортон, чтобы попытаться восстановить

591
00:27:31,050 --> 00:27:35,680
данным, все они делают пытается
восстановить эту так называемую каталог

592
00:27:35,680 --> 00:27:37,340
выяснить, где твой файл был.

593
00:27:37,340 --> 00:27:40,605
А иногда Нортон и скажет:
Файл 93% извлекаемых.

594
00:27:40,605 --> 00:27:42,020
Ну, что же это значит?

595
00:27:42,020 --> 00:27:45,690
Это просто означает, что некоторый другой файл
случайно закончил с использованием, скажем,

596
00:27:45,690 --> 00:27:48,920
эти биты из исходного файла.

597
00:27:48,920 --> 00:27:51,950
>> Так что же на самом деле участвует
в восстановлении данных?

598
00:27:51,950 --> 00:27:55,720
Ну, если у вас нет что-то вроде
Нортон предварительно установленной на Вашем компьютере,

599
00:27:55,720 --> 00:27:59,510
Лучшее, что можно иногда сделать, это посмотреть
на весь жесткий диск ищет

600
00:27:59,510 --> 00:28:00,510
последовательности битов.

601
00:28:00,510 --> 00:28:05,350
И одна из тем проблема набора
пять в том, что вы будете искать

602
00:28:05,350 --> 00:28:09,570
аналог жесткого диска, судебно
образ компактного флэш-карту от

603
00:28:09,570 --> 00:28:13,660
цифровая камера, поиск 0s
и 1, которые обычно с высокой

604
00:28:13,660 --> 00:28:16,720
вероятности, представляют
начало изображения JPEG.

605
00:28:16,720 --> 00:28:21,120
>> И вы, ребята, можете восстановить эти образы на
при условии, если я вижу эту модель

606
00:28:21,120 --> 00:28:24,380
биты на судебно изображения, с
высокая вероятность, что знаменует

607
00:28:24,380 --> 00:28:25,650
начала JPEG.

608
00:28:25,650 --> 00:28:29,520
И если я вижу, по той же схеме снова,
что, вероятно, знаменует собой начало

609
00:28:29,520 --> 00:28:32,440
другой JPEG, а другой
JPEG, а другой в формате JPEG.

610
00:28:32,440 --> 00:28:34,970
И это, как правило, как
восстановление данных работает.

611
00:28:34,970 --> 00:28:37,870
То, что хорошо о формате JPEG является хотя
формат файла сам несколько

612
00:28:37,870 --> 00:28:44,400
комплекс, в начале каждого такого
файл на самом деле довольно идентифицируемых

613
00:28:44,400 --> 00:28:47,370
и простой, как вы увидите,
если у вас не сделали.

614
00:28:47,370 --> 00:28:50,270
>> Итак, давайте взглянем под
капот как точно, что было

615
00:28:50,270 --> 00:28:53,360
происходит, и то, что эти 0 и 1
есть, чтобы дать вам немного больше

616
00:28:53,360 --> 00:28:55,330
контекст для этого конкретного вызов.

617
00:28:55,330 --> 00:28:55,510
>> [ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

618
00:28:55,510 --> 00:28:58,700
>> -Где Ваш компьютер хранит самые
его постоянных данных.

619
00:28:58,700 --> 00:29:03,390
Чтобы сделать это, данные перемещаются из оперативной памяти
вместе с программным обеспечением сигналы, которые говорят

620
00:29:03,390 --> 00:29:06,110
жесткого диска, как хранить эти данные.

621
00:29:06,110 --> 00:29:09,410
Жесткий диск Перевести схем
этих сигналов в напряжение

622
00:29:09,410 --> 00:29:10,870
колебаниям.

623
00:29:10,870 --> 00:29:14,970
Эти, в свою очередь, контролируют жесткого диска
движущихся частей, некоторые из нескольких

624
00:29:14,970 --> 00:29:17,910
движущихся частей, оставшихся в
современного компьютера.

625
00:29:17,910 --> 00:29:22,130
>> Некоторые из сигналов управления двигателем
который вращает металлическим покрытием пластин.

626
00:29:22,130 --> 00:29:25,470
Ваши данные на самом деле хранятся
на этих пластинах.

627
00:29:25,470 --> 00:29:28,610
Другие сигналы перемещения чтения / записи
головы, чтобы читать или

628
00:29:28,610 --> 00:29:30,710
записи данных на пластинах.

629
00:29:30,710 --> 00:29:35,450
Этот механизм настолько точны, что человека
Волосы не мог даже пройти между

630
00:29:35,450 --> 00:29:37,280
руководители и спиннинг пластин.

631
00:29:37,280 --> 00:29:40,316
Тем не менее, все это работает на потрясающей скорости.

632
00:29:40,316 --> 00:29:40,660
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

633
00:29:40,660 --> 00:29:42,190
>> DAVID МАЛАН: небольшое увеличение
глубокое теперь на то, что это

634
00:29:42,190 --> 00:29:44,360
на самом деле на этих пластинах.

635
00:29:44,360 --> 00:29:44,720
>> [ВОСПРОИЗВЕДЕНИЕ ВИДЕО]

636
00:29:44,720 --> 00:29:47,660
>> -Давайте посмотрим на то, что мы просто
видела в замедленном темпе.

637
00:29:47,660 --> 00:29:51,710
Когда короткого импульса электричества
направляется в головку чтения / записи, если переворачивается

638
00:29:51,710 --> 00:29:54,650
на крошечном для электромагнитных
доли секунды.

639
00:29:54,650 --> 00:29:58,970
Магнит создает поле, которое
изменения полярности крошечный, крошечный

640
00:29:58,970 --> 00:30:02,850
часть металлических частиц, которые
покрыть каждую поверхность пластин.

641
00:30:02,850 --> 00:30:05,940
>> Модель серия этих крошечных,
взимается территорий на диске

642
00:30:05,940 --> 00:30:08,470
представляет собой один бит
Данные в двоичное число

643
00:30:08,470 --> 00:30:10,530
Система, используемая на компьютерах.

644
00:30:10,530 --> 00:30:13,775
Теперь, если ток направляется в одну сторону
через головки чтения / записи, площадь

645
00:30:13,775 --> 00:30:15,970
поляризован в одном направлении.

646
00:30:15,970 --> 00:30:17,950
Если текущее отправляется в
противоположном направлении

647
00:30:17,950 --> 00:30:19,930
поляризация меняется на противоположную.

648
00:30:19,930 --> 00:30:22,370
>> Как вы получаете данные с жесткого диска?

649
00:30:22,370 --> 00:30:24,090
Просто повернуть процесс вспять.

650
00:30:24,090 --> 00:30:26,550
Так что это частицы на диске
которые получают ток в

651
00:30:26,550 --> 00:30:27,960
головка чтения / записи движения.

652
00:30:27,960 --> 00:30:30,700
Все вместе эти миллионы
намагниченных сегментов, а также

653
00:30:30,700 --> 00:30:32,160
у вас есть файл.

654
00:30:32,160 --> 00:30:36,060
>> Теперь, части одного файла может
быть разбросаны по всему диску

655
00:30:36,060 --> 00:30:39,970
блюда, вроде как беспорядок
бумаг на вашем столе.

656
00:30:39,970 --> 00:30:43,500
Таким образом, специальный дополнительный файл отслеживает
о том, где что находится.

657
00:30:43,500 --> 00:30:45,985
Разве вы не хотели бы иметь
что-то вроде этого?

658
00:30:45,985 --> 00:30:46,470
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

659
00:30:46,470 --> 00:30:47,820
>> DAVID МАЛАН: Хорошо, наверное, нет.

660
00:30:47,820 --> 00:30:52,070
Так как многие из вас, ребята
рос с этим?

661
00:30:52,070 --> 00:30:53,970
ОК, так что это все меньше и меньше
руки с каждым годом.

662
00:30:53,970 --> 00:30:56,550
Но я рад, что вы по крайней мере знакомы
с ними, потому что это и наша собственная

663
00:30:56,550 --> 00:31:00,520
Книга демо, к сожалению, умирают очень
медленную смерть здесь фамильярность.

664
00:31:00,520 --> 00:31:04,010
>> Но это то, что я, по крайней мере, еще в
средней школы, использовал использование для резервного копирования.

665
00:31:04,010 --> 00:31:08,110
И это было удивительно, потому что вы
может хранить 1,4 мегабайт на

666
00:31:08,110 --> 00:31:08,930
данный диск.

667
00:31:08,930 --> 00:31:12,260
И это было высокой плотности Версия,
как указано в HD, который имеет

668
00:31:12,260 --> 00:31:14,240
это означает, прежде HD сегодняшнего видео.

669
00:31:14,240 --> 00:31:16,400
>> Стандартная плотность была 800 килобайт.

670
00:31:16,400 --> 00:31:18,640
А до этого, были
400 килобайт дисками.

671
00:31:18,640 --> 00:31:23,120
А до этого, было 5 и 1/4
дюймовые диски, которые были по-настоящему гибких,

672
00:31:23,120 --> 00:31:25,680
и немного шире и выше
чем эти вещи здесь.

673
00:31:25,680 --> 00:31:29,150
Но вы можете увидеть так называемую
дискеты аспект этих дисков.

674
00:31:29,150 --> 00:31:32,630
>> И функционально, они на самом деле
очень похоже на жестких дисках в

675
00:31:32,630 --> 00:31:33,570
мере этого типа.

676
00:31:33,570 --> 00:31:37,270
Опять же, твердотельные диски в новых компьютерах
работают несколько иначе.

677
00:31:37,270 --> 00:31:41,530
Но если вы перемещаете, что мало вкладку металл,
вы можете увидеть немного печенья,

678
00:31:41,530 --> 00:31:42,560
или блюде.

679
00:31:42,560 --> 00:31:43,830
>> Это не металл, как этот.

680
00:31:43,830 --> 00:31:46,000
Этот на самом деле некоторые более дешевые
пластикового материала.

681
00:31:46,000 --> 00:31:46,750
И вы можете вида шевелить его.

682
00:31:46,750 --> 00:31:50,310
И вы Trully просто стерт некоторых
Число битов или магнитные частицы

683
00:31:50,310 --> 00:31:51,220
с этого диска.

684
00:31:51,220 --> 00:31:52,710
>> Так, к счастью, нет ничего на нем.

685
00:31:52,710 --> 00:31:55,790
Если эта вещь находится в пути - и охватывают
Ваши глаза и те из ваших соседей -

686
00:31:55,790 --> 00:31:58,865
Вы можете только отчасти осуществить это
целом от оболочки подобное.

687
00:31:58,865 --> 00:32:01,900
Но есть немного весны, так что будьте
осознает, что своими глазами.

688
00:32:01,900 --> 00:32:03,620
Так что теперь у вас есть действительно дискету.

689
00:32:03,620 --> 00:32:07,090
>> И то, что об этой замечательной
в том, что в той мере, что это

690
00:32:07,090 --> 00:32:10,830
мелкого представление большего
жесткий диск, эти вещи супер,

691
00:32:10,830 --> 00:32:11,590
супер просто.

692
00:32:11,590 --> 00:32:15,170
Если вы щепотку дне его, теперь,
что металлические вещи выключен, и кожица

693
00:32:15,170 --> 00:32:20,990
их открытыми, и все, что состоит из двух частей
войлока и так называемый гибкий диск

694
00:32:20,990 --> 00:32:22,930
с куском металла на внутренней стороне.

695
00:32:22,930 --> 00:32:25,990
>> И там идет половина
мой диск содержимое.

696
00:32:25,990 --> 00:32:27,540
Там идет другая половина из них.

697
00:32:27,540 --> 00:32:31,375
Но это все, что кружилась внутри
вашего компьютера в прошлых.

698
00:32:31,375 --> 00:32:35,220

699
00:32:35,220 --> 00:32:38,310
>> И опять же, чтобы поставить это в перспективе,
насколько велика большинство ваших

700
00:32:38,310 --> 00:32:39,560
Жесткие диски в эти дни?

701
00:32:39,560 --> 00:32:41,960

702
00:32:41,960 --> 00:32:46,230
500 гигабайт, терабайт, может быть, в
настольный компьютер, 2 Тб, 3

703
00:32:46,230 --> 00:32:47,630
терабайт, 4 терабайта, верно?

704
00:32:47,630 --> 00:32:52,480
Это один мегабайт, плюс-минус,
, которые не могут даже соответствовать типичным MP3

705
00:32:52,480 --> 00:32:55,310
больше в эти дни, или некоторые
Похожие музыкальные файлы.

706
00:32:55,310 --> 00:32:59,500
>> Таким образом, маленький сувенир для вас сегодня, и
Также, чтобы помочь то, что контекст

707
00:32:59,500 --> 00:33:03,570
мы будем принимать как должное
Сейчас в задачу, поставленную пять.

708
00:33:03,570 --> 00:33:04,820
Итак, это ваши.

709
00:33:04,820 --> 00:33:07,340

710
00:33:07,340 --> 00:33:13,370
Итак, позвольте мне переход к которой будет
провести следующие PSET также.

711
00:33:13,370 --> 00:33:18,470
Так что мы теперь установлена ​​для этой страницы - о,
пару объявления быстро.

712
00:33:18,470 --> 00:33:21,730
>> В эту пятницу, если вы хотите присоединиться к CS50
на обед, перейдите на обычном месте,

713
00:33:21,730 --> 00:33:23,610
cs50.net/rsvp.

714
00:33:23,610 --> 00:33:25,100
И последний проект -

715
00:33:25,100 --> 00:33:28,520
так в программе, мы отправили
окончательной спецификации проекта уже.

716
00:33:28,520 --> 00:33:31,410
Поймите, что это не значит,
это из-за особенности в ближайшее время.

717
00:33:31,410 --> 00:33:33,990
Он отвечал, на самом деле, лишь бы получить
вы, ребята, думал об этом.

718
00:33:33,990 --> 00:33:37,620
И действительно, супер значительные
процент вы будете искать пути решения

719
00:33:37,620 --> 00:33:40,780
дипломные проекты на материале, который мы
даже еще не в классе,

720
00:33:40,780 --> 00:33:42,730
но будет уже на следующей неделе.

721
00:33:42,730 --> 00:33:45,530
>> Заметьте, однако, что спецификация требует
несколько различных компонентов

722
00:33:45,530 --> 00:33:46,190
окончательный проект.

723
00:33:46,190 --> 00:33:49,590
Во-первых, в течение нескольких недель, является
предпроектные предложения, довольно случайный электронной почте

724
00:33:49,590 --> 00:33:52,760
Вашей TF сказать ему или то, что вы
думать о для вашего проекта, с

725
00:33:52,760 --> 00:33:53,650
Нет обязательств.

726
00:33:53,650 --> 00:33:56,710
Предложение будет вашим
обязательство, говоря, вот, это то, что

727
00:33:56,710 --> 00:33:57,770
Я хотел бы сделать для моего проекта.

728
00:33:57,770 --> 00:33:58,250
Что вы думаете?

729
00:33:58,250 --> 00:33:58,650
Слишком большой?

730
00:33:58,650 --> 00:33:59,145
Слишком маленький?

731
00:33:59,145 --> 00:34:00,330
Это управляемым?

732
00:34:00,330 --> 00:34:02,230
И вы видите, спецификации для более подробной информации.

733
00:34:02,230 --> 00:34:05,060
>> Пару недель после этого является статус
доклад, который аналогичным образом

734
00:34:05,060 --> 00:34:08,260
случайный электронной почте своим TF сказать, насколько
далеко позади Вы находитесь в своем окончательном

735
00:34:08,260 --> 00:34:12,360
реализации проекта, а затем
CS50 Hackathon которому каждый

736
00:34:12,360 --> 00:34:17,520
предлагается, который будет событие из
8:00 вечера на одном вечера до 7:00

737
00:34:17,520 --> 00:34:19,150
Утра следующего дня.

738
00:34:19,150 --> 00:34:22,560
Пицца, как я, возможно, упомянутые в неделю
нулю, Виль быть подан в 9:00 вечера,

739
00:34:22,560 --> 00:34:24,120
Китайская еда в 1:00 утра.

740
00:34:24,120 --> 00:34:27,929
И если вы еще не спал в 5:00 утра,
мы отвезем вас к IHOP на завтрак.

741
00:34:27,929 --> 00:34:31,310
>> Таким образом, Hackathon является одним из наиболее
незабываемых впечатлений в классе.

742
00:34:31,310 --> 00:34:35,290
Затем осуществления объясняется тем, а
Затем кульминационной CS50 ярмарка.

743
00:34:35,290 --> 00:34:38,070
Более подробную информацию о всех этих
в ближайшие недели.

744
00:34:38,070 --> 00:34:40,739
>> Но давайте вернемся к тому,
старой школы -

745
00:34:40,739 --> 00:34:41,920
снова, массив.

746
00:34:41,920 --> 00:34:45,040
Так массив был хорош, потому что решает
проблемы, как мы видели, только

747
00:34:45,040 --> 00:34:49,290
Минуту назад со студенческими структурами
становится немного из-под контроля, если мы

748
00:34:49,290 --> 00:34:52,405
хотят иметь одного студента, студент два,
три студента, студент точка точка точка,

749
00:34:52,405 --> 00:34:54,400
некоторые произвольные числа студентов.

750
00:34:54,400 --> 00:34:58,850
>> Так массивы, несколько недель назад, напала
и решил все наши проблемы не

751
00:34:58,850 --> 00:35:03,340
зная заранее, сколько вещей
некоторого типа мы могли бы хотеть.

752
00:35:03,340 --> 00:35:07,390
И мы видели, что структуры могут помочь нам
дальнейшей организации нашего кода и сохранить

753
00:35:07,390 --> 00:35:11,660
концептуально похоже переменных, таких как
имя и дома, вместе, так что мы

754
00:35:11,660 --> 00:35:15,570
их можно рассматривать как единое целое, внутри
которой имеются мелкие куски.

755
00:35:15,570 --> 00:35:17,810
>> Но массивы имеют некоторые недостатки.

756
00:35:17,810 --> 00:35:19,780
Каковы некоторые из недостатков
мы столкнулись

757
00:35:19,780 --> 00:35:22,320
с массивами до сих пор?

758
00:35:22,320 --> 00:35:23,450
Что это?

759
00:35:23,450 --> 00:35:28,130
Фиксированный размер - так что даже если вы, возможно,
сможет выделить память для

760
00:35:28,130 --> 00:35:32,310
Массив, как только вы знаете, сколько студентов
у вас есть, сколько символов у вас есть

761
00:35:32,310 --> 00:35:35,460
от пользователя, как только вы выделили
массиве, вы вид окрашены

762
00:35:35,460 --> 00:35:36,740
себя в угол.

763
00:35:36,740 --> 00:35:40,600
>> Потому что вы не можете вставить новые элементы
в середину массива.

764
00:35:40,600 --> 00:35:43,660
Вы не можете вставить больше элементов
в конце массива.

765
00:35:43,660 --> 00:35:47,750
Действительно, вы вынуждены прибегать к созданию
совершенно новый массив, как мы уже обсуждали,

766
00:35:47,750 --> 00:35:49,320
копированием старого в новое.

767
00:35:49,320 --> 00:35:52,610
И опять же, это головная боль, которая
GetString занимается для вас.

768
00:35:52,610 --> 00:35:56,170
>> Но опять же, вы не можете даже вставить
что-то в середину массива

769
00:35:56,170 --> 00:35:58,200
Если ставка не полностью заполнена.

770
00:35:58,200 --> 00:36:03,010
Например, если этот массив здесь размеров
шесть только пять вещей в нем,

771
00:36:03,010 --> 00:36:06,080
Ну, вы могли просто тактику
то на конце.

772
00:36:06,080 --> 00:36:08,200
Но что, если вы хотите вставить что-то
в середине

773
00:36:08,200 --> 00:36:11,280
массивом, хотя он может иметь
пять из шести вещей в нем?

774
00:36:11,280 --> 00:36:14,250
>> Ну, что же мы делаем, когда мы были все
наших человеческих добровольцев на сцене в

775
00:36:14,250 --> 00:36:15,110
недели прошлого?

776
00:36:15,110 --> 00:36:18,710
Если бы мы хотели поставить кого-то здесь, или
эти люди, как двигаться этим

777
00:36:18,710 --> 00:36:22,540
Кстати, эти люди или как двигаться этим
Кстати, и это стало дорогим.

778
00:36:22,540 --> 00:36:26,950
Перемещение людей внутри
Массив закончилось тем, что добавил и стоимостью

779
00:36:26,950 --> 00:36:31,240
нам время, поэтому многие наши N квадрат
время работы, как сортировка вставкой, для

780
00:36:31,240 --> 00:36:32,550
Например, в худшем случае.

781
00:36:32,550 --> 00:36:36,520
Так массивы являются большими, но вы должны
заранее знать, как большой Вы хотите их.

782
00:36:36,520 --> 00:36:38,030
>> Так хорошо, вот решение.

783
00:36:38,030 --> 00:36:43,860
Если я не знаю заранее, сколько
Я студентам могли иметь, и я знаю, как только

784
00:36:43,860 --> 00:36:47,870
Я решаю, хотя, я застрял с этим
многие студенты, то почему бы мне просто не всегда

785
00:36:47,870 --> 00:36:51,740
выделить два раза больше места
как я мог бы думаю, что нужно?

786
00:36:51,740 --> 00:36:54,450
Разве это не разумное решение?

787
00:36:54,450 --> 00:36:58,240
>> Реально, я не думаю, что мы
понадобится более 50 слотов

788
00:36:58,240 --> 00:37:02,190
в массив для среднего класса,
так что давайте просто округлить.

789
00:37:02,190 --> 00:37:07,040
Я сделаю 100 слотов в моем массиве, всего
так что мы можем определенно получить

790
00:37:07,040 --> 00:37:10,330
количество студентов, которых я ожидал
быть в некотором среднего класса.

791
00:37:10,330 --> 00:37:14,320
Так почему бы не окружить и выделить
больше памяти, обычно, для массива

792
00:37:14,320 --> 00:37:16,290
чем вы думаете, вы могли бы даже нужно?

793
00:37:16,290 --> 00:37:20,190
Что это простое буксировки
к этой идее?

794
00:37:20,190 --> 00:37:21,440
>> Вы просто тратите памяти.

795
00:37:21,440 --> 00:37:25,350
Буквально каждую программу вы пишете то
, может быть, используете в два раза больше памяти, чем

796
00:37:25,350 --> 00:37:26,680
вам действительно нужно.

797
00:37:26,680 --> 00:37:28,990
И, что просто не хочется
Особенно элегантное решение.

798
00:37:28,990 --> 00:37:31,990
Кроме того, он просто уменьшает
Вероятность проблема.

799
00:37:31,990 --> 00:37:35,300
Если вам посчастливилось иметь популярный курс
один семестр и у вас есть 101

800
00:37:35,300 --> 00:37:39,610
студентов, ваша программа по-прежнему
принципиально сталкивается с той же проблемой.

801
00:37:39,610 --> 00:37:44,280
>> Так к счастью, есть решение
это объявление все наши проблемы в виде

802
00:37:44,280 --> 00:37:46,790
структур данных, которые
более сложные, чем те

803
00:37:46,790 --> 00:37:47,970
мы видели до сих пор.

804
00:37:47,970 --> 00:37:50,530
Это, я утверждаю, является связанным списком.

805
00:37:50,530 --> 00:37:51,920
Это список чисел -

806
00:37:51,920 --> 00:37:54,970
9, 17, 22, 26 и 34 -

807
00:37:54,970 --> 00:38:00,120
, которые были связаны друг с другом посредством
о том, что я нарисовал, как стрелы.

808
00:38:00,120 --> 00:38:03,580
>> Другими словами, если бы я хотел, чтобы представлять
массивом, что я мог сделать

809
00:38:03,580 --> 00:38:04,910
что-то вроде этого.

810
00:38:04,910 --> 00:38:07,310
И я положу это на накладные
через минуту.

811
00:38:07,310 --> 00:38:09,970
Я мог бы сделать -

812
00:38:09,970 --> 00:38:12,520
привет, все в порядке.

813
00:38:12,520 --> 00:38:14,470
Оставайтесь на связи.

814
00:38:14,470 --> 00:38:17,360
Новый компьютер здесь, ясно -

815
00:38:17,360 --> 00:38:18,090
Все в порядке.

816
00:38:18,090 --> 00:38:21,730
>> Так что, если у меня есть эти числа в массиве -

817
00:38:21,730 --> 00:38:28,880
9, 17, 22, 26, 24 -

818
00:38:28,880 --> 00:38:30,530
не обязательно в масштабе.

819
00:38:30,530 --> 00:38:33,730
Ладно, вот моя массива -

820
00:38:33,730 --> 00:38:34,980
Боже мой.

821
00:38:34,980 --> 00:38:38,700

822
00:38:38,700 --> 00:38:40,395
Ладно, вот моя массива.

823
00:38:40,395 --> 00:38:44,110

824
00:38:44,110 --> 00:38:45,050
О, мой бог.

825
00:38:45,050 --> 00:38:48,820
>> [Смеется]

826
00:38:48,820 --> 00:38:49,440
>> DAVID МАЛАН: притворяться.

827
00:38:49,440 --> 00:38:52,330
Это слишком много усилий, чтобы вернуться
и исправить это, так что -

828
00:38:52,330 --> 00:38:54,290
26.

829
00:38:54,290 --> 00:38:57,650
Так что у нас есть этот массив
9, 17, 22, 26 и 34.

830
00:38:57,650 --> 00:39:00,260
Для тех из вас может видеть
досадное недоразумение я только что сделал,

831
00:39:00,260 --> 00:39:00,830
там это.

832
00:39:00,830 --> 00:39:04,490
>> Поэтому я утверждаю, что это
очень эффективным решением.

833
00:39:04,490 --> 00:39:07,310
Я выделил столько как целые
Мне нужно - раз, два, три,

834
00:39:07,310 --> 00:39:09,100
четыре, пять, или шесть -

835
00:39:09,100 --> 00:39:11,660
и я затем хранятся номера
внутри этого массива.

836
00:39:11,660 --> 00:39:15,220
Но предположим, то, я хочу вставить
значение как число 8?

837
00:39:15,220 --> 00:39:16,100
Ну, куда это идет?

838
00:39:16,100 --> 00:39:18,530
Предположим, я хочу, чтобы вставить
число, например 20.

839
00:39:18,530 --> 00:39:19,790
Ну, куда это идет?

840
00:39:19,790 --> 00:39:23,160
Где-то там в середине,
или число 35 должно пойти

841
00:39:23,160 --> 00:39:24,010
где-то в конце.

842
00:39:24,010 --> 00:39:25,320
Но я все из космоса.

843
00:39:25,320 --> 00:39:29,120
>> И таким образом, это является фундаментальной проблемой
массивов, что делает это решение.

844
00:39:29,120 --> 00:39:32,280
Я утверждал, минуту назад, GetString
решает эту проблему.

845
00:39:32,280 --> 00:39:37,380
Если Вы хотите вставить шестым номером
В этот массив, то, что по крайней мере один

846
00:39:37,380 --> 00:39:40,090
решение, которое вы можете опереться наверняка,
так же, как мы делаем с GetString?

847
00:39:40,090 --> 00:39:44,340

848
00:39:44,340 --> 00:39:46,030
Что это?

849
00:39:46,030 --> 00:39:48,190
>> Ну, сделать его больше, тем
легче сказать, чем сделать.

850
00:39:48,190 --> 00:39:52,810
Мы не можем обязательно делать массива
больше, но что мы можем сделать?

851
00:39:52,810 --> 00:39:56,570
Сделать новый массив, который больше, размером
6, а может, размер 10, если мы хотим

852
00:39:56,570 --> 00:40:00,490
опередить вещи, а затем скопировать
старого массива в новый, а затем

853
00:40:00,490 --> 00:40:01,680
освободить старого массива.

854
00:40:01,680 --> 00:40:05,770
>> Но то, что время работы
Теперь этого процесса?

855
00:40:05,770 --> 00:40:09,870
Это большое О от N, так как копирование
будет стоить вам несколько единиц

856
00:40:09,870 --> 00:40:13,480
времени, так что не так идеально, если мы должны
выделить новый массив, который будет

857
00:40:13,480 --> 00:40:15,610
потреблять в два раза больше
памяти временно.

858
00:40:15,610 --> 00:40:16,660
Скопируйте старые на новые -

859
00:40:16,660 --> 00:40:18,800
Я имею в виду, это просто головная боль, которая
, опять же, почему мы написали

860
00:40:18,800 --> 00:40:19,920
GetString для вас.

861
00:40:19,920 --> 00:40:21,380
>> Так что мы могли бы сделать вместо этого?

862
00:40:21,380 --> 00:40:25,000
Ну, что, если наши структуры данных
на самом деле имеет пробелы в нем?

863
00:40:25,000 --> 00:40:30,790
Предположим, что я расслабляюсь моей цели, имеющие
непрерывные блоки памяти, где 9

864
00:40:30,790 --> 00:40:34,500
находится рядом с 17, который
рядом с 22, и так далее.

865
00:40:34,500 --> 00:40:39,570
>> И предположим, что 9 может быть здесь, в
Оперативной памяти, и 17 может быть здесь, в оперативной памяти,

866
00:40:39,570 --> 00:40:40,990
и 22 может быть здесь, в оперативной памяти.

867
00:40:40,990 --> 00:40:43,610
Другими словами, я не нуждаюсь в них
даже спина к спине больше.

868
00:40:43,610 --> 00:40:47,850
Мне просто нужно как-то нитку в иголку
в каждом из этих цифр, или каждый

869
00:40:47,850 --> 00:40:51,010
из этих узлов, как мы будем называть
прямоугольниками, как я нарисовал их,

870
00:40:51,010 --> 00:40:55,670
помню, как добраться до последнего
такой узел от первого.

871
00:40:55,670 --> 00:40:59,940
>> Так в чем же конструкции программирования
мы видели совсем недавно, с которой я

872
00:40:59,940 --> 00:41:03,030
можно реализовать, что нить, или
сделанные здесь, с которой я могу

873
00:41:03,030 --> 00:41:05,430
осуществлять эти стрелки?

874
00:41:05,430 --> 00:41:06,500
Поэтому указатели, не так ли?

875
00:41:06,500 --> 00:41:09,560
Если бы я выделить не только
Интеллект, но узел - и

876
00:41:09,560 --> 00:41:10,810
узел, я просто означать контейнере.

877
00:41:10,810 --> 00:41:12,900
И визуально, я имею в виду прямоугольник.

878
00:41:12,900 --> 00:41:16,420
Так узла видимо нужны
содержать два значения -

879
00:41:16,420 --> 00:41:21,490
целочисленное себя, а потом, как это следует из
нижнюю половину прямоугольника

880
00:41:21,490 --> 00:41:23,010
достаточно места для Int.

881
00:41:23,010 --> 00:41:26,130
>> Поэтому просто позаботиться об этом заранее здесь,
насколько велик этот узел, это

882
00:41:26,130 --> 00:41:27,170
Контейнер идет речь?

883
00:41:27,170 --> 00:41:29,250
Сколько байт для целочисленное?

884
00:41:29,250 --> 00:41:31,310
Предположительно 4, если это
так же, как обычно.

885
00:41:31,310 --> 00:41:33,270
А потом, сколько байт
для указателя?

886
00:41:33,270 --> 00:41:33,650
4.

887
00:41:33,650 --> 00:41:37,940
Так что этот контейнер или этот узел, является
будет 8 байт структуры.

888
00:41:37,940 --> 00:41:41,760
О, и это счастливое совпадение, что
мы точно также это понятие

889
00:41:41,760 --> 00:41:44,400
структура или структура C.

890
00:41:44,400 --> 00:41:48,890
>> Поэтому я утверждаю, что я хочу сделать шаг
к этому более сложные

891
00:41:48,890 --> 00:41:52,560
реализация список номеров,
связанный список номеров, мне нужно сделать

892
00:41:52,560 --> 00:41:56,920
немного больше мышление фронт и
объявить не только Интеллект, но структура

893
00:41:56,920 --> 00:41:58,620
, что я позвоню, условно
Здесь, узла.

894
00:41:58,620 --> 00:42:01,630
Мы могли бы назвать ее как угодно,, но
узел будет тематическим во многих

895
00:42:01,630 --> 00:42:03,560
из вещей, мы начнем рассматривать сейчас.

896
00:42:03,560 --> 00:42:06,480
>> Внутри этого узла будет Int N.

897
00:42:06,480 --> 00:42:09,350
А потом этот синтаксис, немного
странно на первый взгляд -

898
00:42:09,350 --> 00:42:12,960
Структура узла * следующий.

899
00:42:12,960 --> 00:42:16,900
Ну графически, что это такое?

900
00:42:16,900 --> 00:42:21,000
То есть нижняя половина
прямоугольник, который мы видели

901
00:42:21,000 --> 00:42:22,730
просто мгновение назад.

902
00:42:22,730 --> 00:42:27,600
>> Но почему я говорю структура узла *
а не только узлом *?

903
00:42:27,600 --> 00:42:31,370
Потому что, если этот указатель указывает
на другом узле, это просто

904
00:42:31,370 --> 00:42:32,760
адрес узла.

905
00:42:32,760 --> 00:42:35,630
Это согласуется с того, что мы
обсуждали об указателях до сих пор.

906
00:42:35,630 --> 00:42:39,690
Но почему, если я утверждаю, эта структура
называется узлом, я должен сказать, что структура

907
00:42:39,690 --> 00:42:42,660
узлом внутри здесь?

908
00:42:42,660 --> 00:42:43,190
>> Именно так.

909
00:42:43,190 --> 00:42:46,490
Это своего рода глупые реальность C.
Определение типа, так сказать, не имеет

910
00:42:46,490 --> 00:42:47,220
произошло.

911
00:42:47,220 --> 00:42:48,510
С супер буквально.

912
00:42:48,510 --> 00:42:51,050
Она читает ваш код сверху
вниз, слева направо.

913
00:42:51,050 --> 00:42:54,930
И, пока не встретит, что точка с запятой на
Суть, думаю, что не

914
00:42:54,930 --> 00:42:57,590
существовать как тип данных?

915
00:42:57,590 --> 00:42:59,060
Узла, в кавычках узла.

916
00:42:59,060 --> 00:43:03,050
>> Но из-за более подробный
Я сделал заявление на первой линии -

917
00:43:03,050 --> 00:43:05,340
ЬурейеЕ узла структуры -

918
00:43:05,340 --> 00:43:08,790
потому, что пришел первым, перед
фигурные скобки, что вроде как

919
00:43:08,790 --> 00:43:11,800
предварительного обучения Clang, что, вы
Знаете что, дайте мне структуры

920
00:43:11,800 --> 00:43:13,570
структура называется узлом.

921
00:43:13,570 --> 00:43:16,270
Честно говоря, я не люблю называть вещи
Структура узла, узла структуры всех

922
00:43:16,270 --> 00:43:17,090
на протяжении всей моей кода.

923
00:43:17,090 --> 00:43:20,660
Но я буду использовать его только один раз, только внутри,
так что я могу эффективно

924
00:43:20,660 --> 00:43:25,010
создать своего рода циклическую ссылку, а не
указатель на себя таковой, но

925
00:43:25,010 --> 00:43:29,400
указатель на другой
идентичного типа.

926
00:43:29,400 --> 00:43:32,330
>> Вот и получается, что в структуре данных
как это, есть несколько

927
00:43:32,330 --> 00:43:34,470
операции, которые могут быть
Интересующие нас.

928
00:43:34,470 --> 00:43:37,460
Мы, возможно, захотите, чтобы вставить
в список, как это.

929
00:43:37,460 --> 00:43:39,850
Мы, возможно, захотите удалить
из списка, как это.

930
00:43:39,850 --> 00:43:43,490
Мы можем захотеть поиск в списке для
значение, или в более общем хода.

931
00:43:43,490 --> 00:43:46,410
И траверс просто причудливый способ
начала говорить на левой и переместить все

932
00:43:46,410 --> 00:43:47,650
до упора вправо.

933
00:43:47,650 --> 00:43:52,640
>> И заметьте, даже с этим немного более
сложные структуры данных, не говоря

934
00:43:52,640 --> 00:43:56,510
мне предлагают, чтобы мы можем заимствовать некоторые из
идеи в последние две недели и

935
00:43:56,510 --> 00:43:58,410
реализовать функцию называют
поиск, как это.

936
00:43:58,410 --> 00:44:01,360
Это собирается вернуть истинным или
ложными, указывая, да или

937
00:44:01,360 --> 00:44:03,390
Нет, N в списке.

938
00:44:03,390 --> 00:44:05,960
Второй аргумент является указателем
к списку себе, так

939
00:44:05,960 --> 00:44:07,920
указатель на узел.

940
00:44:07,920 --> 00:44:10,350
>> Все, что я собираюсь сделать, это то заявляю
временную переменную.

941
00:44:10,350 --> 00:44:12,730
Мы назовем это PTR по соглашению,
для указателя.

942
00:44:12,730 --> 00:44:15,220
И я назначу его равным
начало списка.

943
00:44:15,220 --> 00:44:16,680
>> А теперь замечаю то время цикла.

944
00:44:16,680 --> 00:44:20,640
До тех пор пока указатель не равно
к нулю, я собираюсь проверить.

945
00:44:20,640 --> 00:44:24,520
Является ли стрелка указателя N равны
N, который был передан в?

946
00:44:24,520 --> 00:44:26,410
И подождите минуту - новый
часть синтаксиса.

947
00:44:26,410 --> 00:44:29,324
Что такое стрелка вдруг?

948
00:44:29,324 --> 00:44:30,574
Да?

949
00:44:30,574 --> 00:44:34,200

950
00:44:34,200 --> 00:44:34,810
>> Именно так.

951
00:44:34,810 --> 00:44:38,860
Так в то время как несколько минут назад, мы использовали
точечную нотацию для доступа что-то

952
00:44:38,860 --> 00:44:43,080
Внутри структуры, если переменная
Вы не структуры

953
00:44:43,080 --> 00:44:47,420
себя, но указатель на структуру,
К счастью, часть синтаксиса,

954
00:44:47,420 --> 00:44:48,620
наконец, имеет интуитивный смысл.

955
00:44:48,620 --> 00:44:52,360
Стрелка означает следовать за указателем,
как наши стрелки как правило, означает

956
00:44:52,360 --> 00:44:56,570
графически, и уходить в
Данные поля внутри.

957
00:44:56,570 --> 00:44:59,700
Так стрелка то же самое, точка, но
вы используете его, когда у вас есть указатель.

958
00:44:59,700 --> 00:45:05,270
>> Так просто, чтобы резюмировать то, если поле N
Внутри структуры, называемых указатель

959
00:45:05,270 --> 00:45:07,760
равна равна N, вернуться правда.

960
00:45:07,760 --> 00:45:11,970
В противном случае, эта линия здесь - указатель
равно указатель следующего.

961
00:45:11,970 --> 00:45:17,540
Так что же это делает, заметьте, если я
я в настоящее время указывает на структуру

962
00:45:17,540 --> 00:45:21,430
содержащий 9 и 9 не число
Я ищу - Предположим, я ищу

963
00:45:21,430 --> 00:45:22,830
для N равна 50 -

964
00:45:22,830 --> 00:45:25,930
Я собираюсь обновить свой временный указатель
не указывать в этом узле

965
00:45:25,930 --> 00:45:31,190
больше, но указателя стрелки рядом, которая
собирается поставить меня сюда.

966
00:45:31,190 --> 00:45:34,270
>> Теперь я понял, вихрь
Введение.

967
00:45:34,270 --> 00:45:37,380
В среду, мы на самом деле сделать это
с некоторыми людьми и с некоторыми более

968
00:45:37,380 --> 00:45:38,900
кода в более медленном темпе.

969
00:45:38,900 --> 00:45:42,990
Но поймите, мы сейчас делают наши данные
более сложные структуры, чтобы наши

970
00:45:42,990 --> 00:45:45,780
Алгоритмы можете получить более эффективные, которые
будет условием для

971
00:45:45,780 --> 00:45:50,500
PSET шесть, когда мы загружаем в, опять же, те,
150 000 слов, но нужно сделать так

972
00:45:50,500 --> 00:45:55,650
эффективно, и, в идеале, создают
программа, которая работает для наших пользователей не в

973
00:45:55,650 --> 00:46:00,460
линейной, а не на русском языке в квадрате, а в
постоянное время, в идеал.

974
00:46:00,460 --> 00:46:02,300
>> Увидимся в среду.

975
00:46:02,300 --> 00:46:07,240
>> СЛУШАЛИ: На следующей CS50, Дэвид
забывает о своем базовом варианте.

976
00:46:07,240 --> 00:46:12,770
>> DAVID МАЛАН: И вот как вы посылаете
текстовыми сообщениями с C. Какие -

977
00:46:12,770 --> 00:46:14,020
>> [Различные ТЕКСТ СООБЩЕНИЯ
Звуки уведомлений]

978
00:46:14,020 --> 00:46:19,734