1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [Музыка играет]

3
00:00:11,210 --> 00:00:12,100
>> ROB BODEN: Хорошо.

4
00:00:12,100 --> 00:00:15,620
Так, первое, что во-первых, видео
от знакомого лица.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [ВИДЕОВОСПРОИЗВЕДЕНИЕ]

7
00:00:22,560 --> 00:00:23,370
>> -Все в порядке.

8
00:00:23,370 --> 00:00:27,150
Это CS50, и это
начало недели три.

9
00:00:27,150 --> 00:00:29,980
Жаль, что я не мог быть там с вами
сегодня, но позвольте мне представить

10
00:00:29,980 --> 00:00:32,880
CS50 собственной Роб Боден.

11
00:00:32,880 --> 00:00:33,872
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

12
00:00:33,872 --> 00:00:39,340
>> [Аплодисменты, переходящие в овацию]

13
00:00:39,340 --> 00:00:41,277
>> ROB BODEN: фильмография в
что видео является фантастическим.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
Хорошо.

16
00:00:47,770 --> 00:00:50,960
Итак, сначала, есть другой обед.

17
00:00:50,960 --> 00:00:52,330
Это завтра в 1:15.

18
00:00:52,330 --> 00:00:54,480
Там нет никакого обеда в эту пятницу.

19
00:00:54,480 --> 00:00:55,810
Именно с Quora.

20
00:00:55,810 --> 00:01:00,190
И Томми еще не здесь, но один из
люди там является бывший глава CF,

21
00:01:00,190 --> 00:01:01,530
Томми McWilliam.

22
00:01:01,530 --> 00:01:02,730
Так что он веселый парень.

23
00:01:02,730 --> 00:01:04,819
Вы должны прийти.

24
00:01:04,819 --> 00:01:05,900
>> Хорошо.

25
00:01:05,900 --> 00:01:11,360
Так на прошлой неделе, мы начали разваливается
о том, что строка на самом деле.

26
00:01:11,360 --> 00:01:14,830
Мы знали с самого начала, что
это последовательность символов.

27
00:01:14,830 --> 00:01:18,130
Но на прошлой неделе, мы погрузились в тот факт,
что то, что на самом деле является последовательность

28
00:01:18,130 --> 00:01:22,110
персонажи, ну, у нас теперь есть
массивы символов.

29
00:01:22,110 --> 00:01:26,450
И мы знаем, что это строка, это массив
символов, в самом конце,

30
00:01:26,450 --> 00:01:30,920
у нас есть этот специальный нулевой байт, это
обратный слеш 0, что указывает на конец

31
00:01:30,920 --> 00:01:32,230
строка.

32
00:01:32,230 --> 00:01:36,970
>> И поэтому строка представляет собой массив
персонажи, но мы можем иметь более

33
00:01:36,970 --> 00:01:39,530
просто массив символов,
мы можем иметь массив любой

34
00:01:39,530 --> 00:01:40,890
тип вещи мы хотим.

35
00:01:40,890 --> 00:01:51,570
Так что, если вы помните с прошлой недели,
Программа века, что Давид ввел

36
00:01:51,570 --> 00:01:53,560
очень быстро.

37
00:01:53,560 --> 00:01:57,010
Так первое, что мы собираемся сделать, это
спросить пользователя для целого числа,

38
00:01:57,010 --> 00:01:58,800
количество людей в комнате.

39
00:01:58,800 --> 00:02:01,260
Как только у нас есть, что целое,
мы объявлении массива.

40
00:02:01,260 --> 00:02:02,890
Обратите внимание, этот синтаксис кронштейн.

41
00:02:02,890 --> 00:02:04,540
Вы собираетесь, чтобы привыкнуть к этому.

42
00:02:04,540 --> 00:02:09,430
>> Таким образом, мы объявлении массива целых чисел
называется возраст, и есть п

43
00:02:09,430 --> 00:02:12,080
целые числа в этом массиве.

44
00:02:12,080 --> 00:02:16,480
Так эта картина прямо здесь, это 4 внутр
я равна 0, я меньше п, я плюс

45
00:02:16,480 --> 00:02:20,580
плюс, что также собирается быть образцом
что вы получите очень привыкли.

46
00:02:20,580 --> 00:02:24,000
Потому что очень много, как вы
всегда будет перебора массивов.

47
00:02:24,000 --> 00:02:26,330
Так что помните, что п
длина нашего массива.

48
00:02:26,330 --> 00:02:32,120
И вот, мы неоднократно с просьбой
для возраста человек, которого я в комнате.

49
00:02:32,120 --> 00:02:36,640
>> После этого, мы идем вниз, и по тем или иным
произвольное причина, мы тогда

50
00:02:36,640 --> 00:02:40,220
распечатать сколько лет они собираются
быть через год.

51
00:02:40,220 --> 00:02:49,980
И выполняет эту программу, давайте
сделать возрастов, точка косой возрастов.

52
00:02:49,980 --> 00:02:53,010
Так количество людей в комнате,
скажем есть три.

53
00:02:53,010 --> 00:02:59,880
И сказать, первый человек, составляет 13,
Следующий составляет 26, а последний 30.

54
00:02:59,880 --> 00:03:05,080
Так то он будет перебирать этих трех
люди, распечатать 14, 27, и 31.

55
00:03:05,080 --> 00:03:16,060
>> Так что помните, что, когда мы заявляем,
массив размера п, индексы в том, что

56
00:03:16,060 --> 00:03:19,950
Массив, массив имеет значения и
индексы 0, 1, 2, на всем пути

57
00:03:19,950 --> 00:03:21,680
до н минус 1.

58
00:03:21,680 --> 00:03:26,255
Поэтому, когда мы сказали, что было три человека
в комнате, и мы ставим здесь

59
00:03:26,255 --> 00:03:29,850
первая итерация через это
цикл, я будет 0.

60
00:03:29,850 --> 00:03:31,650
Так в индексе 0.

61
00:03:31,650 --> 00:03:34,540
Мы присваиваем первый
С возрастом, когда пользователь вводит.

62
00:03:34,540 --> 00:03:38,870
Тогда в следующий, мы входим
Второй н пользователь вводит, а в

63
00:03:38,870 --> 00:03:40,580
рядом с двумя, последних п.

64
00:03:40,580 --> 00:03:44,200
>> Так заметить, что массив размера
три не имеет ничего

65
00:03:44,200 --> 00:03:46,040
в индексе три.

66
00:03:46,040 --> 00:03:49,036
Это не относится.

67
00:03:49,036 --> 00:03:50,250
Хорошо.

68
00:03:50,250 --> 00:03:55,136
Так, возвращаясь здесь.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
Итак, что мы имели дело с массивами,
мы немного знакомы.

71
00:04:01,590 --> 00:04:03,780
Теперь мы собираемся перейти к команде
аргументы командной строки, которые будут

72
00:04:03,780 --> 00:04:05,890
довольно отношение к этой проблеме набора.

73
00:04:05,890 --> 00:04:09,670
>> Так до сих пор, всякий раз, когда у Вас есть
объявили о своей главной функции, мы

74
00:04:09,670 --> 00:04:11,230
сказал тап_п недействительными.

75
00:04:11,230 --> 00:04:14,070
Так недействительными просто означает, что
мы не проходя любой

76
00:04:14,070 --> 00:04:16,440
Аргументы этой функции.

77
00:04:16,440 --> 00:04:19,190
Теперь мы собираемся, чтобы увидеть, что основные
может занять несколько аргументов.

78
00:04:19,190 --> 00:04:22,470
Здесь мы называем их внутр агдс
и струнные ARGV скобки.

79
00:04:22,470 --> 00:04:26,930
Скобки, в очередной раз, что указывает на
что мы имеем дело с массивами.

80
00:04:26,930 --> 00:04:31,850
Так вот, строка ARGV скобки, мы
дело с массивом строк.

81
00:04:31,850 --> 00:04:35,360
Так агдс, что происходит, чтобы указать,
сколько аргументов мы в

82
00:04:35,360 --> 00:04:37,580
прошел в эту программу.

83
00:04:37,580 --> 00:04:46,050
И видеть, что это значит,
давайте закроем этот.

84
00:04:46,050 --> 00:04:46,490
>> ОК.

85
00:04:46,490 --> 00:04:50,790
Так до сих пор, мы запускаем каждый
программа, как точечных возрастов косой.

86
00:04:50,790 --> 00:04:55,250
Мы можем также, в командной строке, мимо
передать аргументы таким образом, термин, команда,

87
00:04:55,250 --> 00:04:56,550
аргументы командной строки.

88
00:04:56,550 --> 00:04:59,760
Таким образом, первый аргумент, привет мир.

89
00:04:59,760 --> 00:05:03,350
Так вот, агдс будет три.

90
00:05:03,350 --> 00:05:07,720
Это кол-во аргументов
в командной строке.

91
00:05:07,720 --> 00:05:12,840
ARGC всегда по крайней мере 1, так как точка
сократить возраст, себя, считается одним из

92
00:05:12,840 --> 00:05:14,490
аргументы командной строки.

93
00:05:14,490 --> 00:05:17,010
>> Тогда привет является первым.

94
00:05:17,010 --> 00:05:20,460
Если точка возраст слэш является нулевой, то
Привет является первым, и мир

95
00:05:20,460 --> 00:05:22,830
Вторая строка аргумент командной.

96
00:05:22,830 --> 00:05:29,490
Так строка агду, мы собираемся, чтобы увидеть,
содержит строки, точка слэш

97
00:05:29,490 --> 00:05:33,830
возраст, привет, и мир.

98
00:05:33,830 --> 00:05:38,945
И, по запросу Давида, мы собираемся
для воспроизведения видео, представляя, что.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [ВИДЕОВОСПРОИЗВЕДЕНИЕ]

101
00:05:43,890 --> 00:05:46,240
>> не-До сих пор в программах мы
написано, мы заявляем

102
00:05:46,240 --> 00:05:48,500
Основным как тап_п недействительными.

103
00:05:48,500 --> 00:05:51,170
И все это время, что пустота есть
просто был уточнив, что

104
00:05:51,170 --> 00:05:54,430
Программа не принимать какие-либо
аргументы командной строки.

105
00:05:54,430 --> 00:05:57,750
Другими словами, когда пользователь запускает
Программа, он или она может обеспечить команду

106
00:05:57,750 --> 00:06:01,710
аргументы командной строки, прописав дополнительные
слова или фразы после програмы

107
00:06:01,710 --> 00:06:03,000
назвать в командной строке.

108
00:06:03,000 --> 00:06:06,550
>> Ну, если вы хотите, чтобы ваша программа
принимать аргументы командной строки, один или

109
00:06:06,550 --> 00:06:10,540
больше таких слов, мы должны заменить
аннулированию с парой аргументов.

110
00:06:10,540 --> 00:06:12,200
Так давайте сделаем это.

111
00:06:12,200 --> 00:06:15,750
Включите CS50.h.

112
00:06:15,750 --> 00:06:19,360
Включите стандартный io.h.

113
00:06:19,360 --> 00:06:20,760
Int основной.

114
00:06:20,760 --> 00:06:26,330
И теперь, вместо того, пустота, я собираюсь
указать Int названием агдс и

115
00:06:26,330 --> 00:06:28,780
массив строк называемых агду.

116
00:06:28,780 --> 00:06:31,820
Теперь, агдс и агду являются
просто конвенций.

117
00:06:31,820 --> 00:06:34,000
>> Мы могли бы назвать эти аргументы
Наиболее все, что мы хотим.

118
00:06:34,000 --> 00:06:37,630
Но важно то, что агдс является
внутр потому, по определению, это

119
00:06:37,630 --> 00:06:41,360
будет содержать количество аргументов,
число слов в целом, что

120
00:06:41,360 --> 00:06:43,380
пользователь ввел в его или ее строке.

121
00:06:43,380 --> 00:06:47,910
агду, тем временем, аргумент вектор, является
собирается быть на самом деле массив хранения

122
00:06:47,910 --> 00:06:52,020
все слова о том, что пользователь имеет
набрали по его или ее строке.

123
00:06:52,020 --> 00:06:54,500
>> Перейдем сделать что-то сейчас
с одним или более из этих

124
00:06:54,500 --> 00:06:55,660
аргументы командной строки.

125
00:06:55,660 --> 00:07:00,070
В частности, давайте идти вперед и печать
каковы бы ни были слово пользователь вводит

126
00:07:00,070 --> 00:07:03,960
после имени программы
в командной строке.

127
00:07:03,960 --> 00:07:04,730
Открыть кронштейн.

128
00:07:04,730 --> 00:07:06,240
Закрыть кронштейн.

129
00:07:06,240 --> 00:07:10,510
Printf процентов с обратной косой и запятая.

130
00:07:10,510 --> 00:07:14,550
А теперь я должен сказать Printf какое значение
для подключения к этой заполнителя.

131
00:07:14,550 --> 00:07:18,600
Я хочу первое слово, которое пользователь должен
набрали после имени программы,

132
00:07:18,600 --> 00:07:23,130
и поэтому я собираюсь указать
агду кронштейн 1, недалеко

133
00:07:23,130 --> 00:07:24,830
скобка, точка с запятой.

134
00:07:24,830 --> 00:07:27,290
>> Теперь, почему кронштейн 1, а не кронштейн 0?

135
00:07:27,290 --> 00:07:30,990
Ну, оказывается, автоматически сохраняются
в ARGV 0 будет

136
00:07:30,990 --> 00:07:32,620
настоящее имя программы.

137
00:07:32,620 --> 00:07:36,180
Таким образом, первое слово, которое пользователь вводит
после имя программы является, по

138
00:07:36,180 --> 00:07:38,990
Конвенция, будет
хранится в ARGV 1.

139
00:07:38,990 --> 00:07:42,380
Давайте сейчас компилировать и
запустить эту программу.

140
00:07:42,380 --> 00:07:47,780
>> Сделать ARGV 0, точка слэш ARGV 0.

141
00:07:47,780 --> 00:07:50,520
А теперь слово как привет.

142
00:07:50,520 --> 00:07:51,670
Enter.

143
00:07:51,670 --> 00:07:53,520
И у нас это есть, привет.

144
00:07:53,520 --> 00:07:55,750
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

145
00:07:55,750 --> 00:07:57,000
>> ROB BODEN: Хорошо.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
Закрыть это.

148
00:08:01,230 --> 00:08:16,730
Так взглянуть на эту программу, что
мы только что представила нам, ну просто

149
00:08:16,730 --> 00:08:24,710
показать, если мы печатаем агду 0, сделать, теперь
что это такое, агду 0, точка слэш агду 0.

150
00:08:24,710 --> 00:08:30,440
Так что, как ожидается, это вывод на печать
Название программы, так как агду 0

151
00:08:30,440 --> 00:08:32,970
всегда будет
Название программы.

152
00:08:32,970 --> 00:08:35,640
Но давайте сделаем что-то
немного более интересным.

153
00:08:35,640 --> 00:08:42,080
>> Таким образом, в множестве проблем, вы будете
познакомился с этой функцией, atoi.

154
00:08:42,080 --> 00:08:44,440
Так что же нам использовать atoi для?

155
00:08:44,440 --> 00:08:48,550
Это собирается преобразовать
строку в целое число.

156
00:08:48,550 --> 00:08:53,280
Так что если я передать строку, один, два, три,
чтобы atoi, который будет конвертировать, что

157
00:08:53,280 --> 00:08:56,910
к целому, один, два, три.

158
00:08:56,910 --> 00:09:01,480
Так что мы собираемся преобразовать первый
Аргумент командной строки в целое число,

159
00:09:01,480 --> 00:09:05,690
а затем просто распечатать, что целое число.

160
00:09:05,690 --> 00:09:09,680
>> Так в основном, мы вроде
повторной реализации GetInt, просто

161
00:09:09,680 --> 00:09:12,350
целое вводится по команде
линия, а не в программе

162
00:09:12,350 --> 00:09:14,560
в интерактивном режиме.

163
00:09:14,560 --> 00:09:23,170
Итак, что делает ARGV 0, давайте сделаем
это здесь, и закройте это.

164
00:09:23,170 --> 00:09:27,670
Так работает ARGV 0, и давайте введите
целое число, один два три четыре один два.

165
00:09:27,670 --> 00:09:30,840
Так это будет вывести целое, один
два три четыре один два.

166
00:09:30,840 --> 00:09:35,500
Есть некоторые тонкости, чтобы atoi, что
это будет перестать беспокоиться ни о чем

167
00:09:35,500 --> 00:09:39,040
за действительного числового символа,
но это не имеет значения.

168
00:09:39,040 --> 00:09:42,870
>> Так что же вы думаете, что происходит
если я сделаю это?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
Сегментация вина.

171
00:09:47,050 --> 00:09:50,410
Так почему же?

172
00:09:50,410 --> 00:09:56,060
Если вы посмотрите на нашу программу, мы
преобразования ARGV 1, первый аргумент

173
00:09:56,060 --> 00:09:59,610
после имени программы, в целое число.

174
00:09:59,610 --> 00:10:03,350
Но нет аргумент, передаваемый
после имени программы.

175
00:10:03,350 --> 00:10:08,060
Так вот, мы видим, что это багги
Программа, поскольку, если мы попытаемся запустить его

176
00:10:08,060 --> 00:10:10,530
без каких-либо аргументов,
он просто будет крах.

177
00:10:10,530 --> 00:10:16,950
>> Так еще одна распространенная картина, то вы увидите,
будет что-то вроде, если агдс меньше

178
00:10:16,950 --> 00:10:21,100
не два, с указанием, что не было
по крайней мере, имя программы и

179
00:10:21,100 --> 00:10:29,100
Первый аргумент, то мы сделаем что-то
как Е, не достаточно

180
00:10:29,100 --> 00:10:31,190
аргументы командной строки.

181
00:10:31,190 --> 00:10:33,170
Это, вероятно, не хороший для печати,
это, наверное, что-то, как

182
00:10:33,170 --> 00:10:35,440
вы должны ввести целое число
в командной строке.

183
00:10:35,440 --> 00:10:37,450
Я просто закончить его там.

184
00:10:37,450 --> 00:10:39,600
А потом вернуть 1.

185
00:10:39,600 --> 00:10:44,740
Так что помните, что в конце нашей
Программа, если мы вернемся 0, такого рода

186
00:10:44,740 --> 00:10:47,060
указывает на успешное завершение.

187
00:10:47,060 --> 00:10:50,940
А главное автоматически
возвращает 0, если вы не делаете.

188
00:10:50,940 --> 00:10:55,800
>> Так вот, мы перенастройки 1, чтобы указать
что это не успех.

189
00:10:55,800 --> 00:11:01,000
И вы можете вернуться, что вы хотите,
просто, 0 указывает на успешное завершение, и

190
00:11:01,000 --> 00:11:03,390
что-нибудь еще указывает на ошибку.

191
00:11:03,390 --> 00:11:04,855
Так что давайте запустить эту версию вещей.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
Так что теперь, если мы не введите командную строку
аргумент, это будет правильно рассказать

194
00:11:16,600 --> 00:11:18,290
нам, не достаточно командной строки.

195
00:11:18,290 --> 00:11:20,610
Не закончить фразу.

196
00:11:20,610 --> 00:11:24,950
Иначе, если мы на самом деле передать ему один,
он может завершить программу.

197
00:11:24,950 --> 00:11:27,920
Так что это, как вы будете использовать ARGC в
Для того чтобы проверить количество

198
00:11:27,920 --> 00:11:30,630
аргументы командной строки, что
на самом деле прошло.

199
00:11:30,630 --> 00:11:39,360
>> Так давайте сделаем эту программу немного больше
сложно, и посмотреть на секунду

200
00:11:39,360 --> 00:11:42,180
итерация вещей.

201
00:11:42,180 --> 00:11:46,310
Так что теперь, мы не просто печать
Первая строка аргумент командной.

202
00:11:46,310 --> 00:11:51,210
Здесь мы итерации от десятичного я равных
0, я меньше агдс, я плюс

203
00:11:51,210 --> 00:11:55,280
плюс, и печать агду, индекс г.

204
00:11:55,280 --> 00:11:59,300
Так эта картина, опять же, это то же самое
картина, как и раньше, за исключением того, вместо того, чтобы

205
00:11:59,300 --> 00:12:02,600
вызова переменную
п, мы используем ARGC.

206
00:12:02,600 --> 00:12:09,520
>> Так что это перебор каждого индекса
в массиве, и печать каждого

207
00:12:09,520 --> 00:12:11,910
элемент в этом массиве.

208
00:12:11,910 --> 00:12:20,300
И вот, когда мы запустим эту программу, хорошо,
Я не ввести любой командной строки

209
00:12:20,300 --> 00:12:22,540
аргументы, так что просто печатает
название программы.

210
00:12:22,540 --> 00:12:26,053
Если я вхожу кучу вещей, оно будет
распечатать один, каждый на отдельной строке.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> ОК.

213
00:12:32,210 --> 00:12:34,770
Итак, давайте еще один шаг.

214
00:12:34,770 --> 00:12:38,890
И вместо того, чтобы печатать каждый аргумент
на отдельной строке, давайте печатать каждый

215
00:12:38,890 --> 00:12:42,590
характер каждого аргумента
на отдельной строке.

216
00:12:42,590 --> 00:12:46,700
Поэтому помните, что агду является
массив строк.

217
00:12:46,700 --> 00:12:50,960
Так что это строка, но
массив символов?

218
00:12:50,960 --> 00:12:57,140
Так это значит, что агду действительно
Массив массив символов.

219
00:12:57,140 --> 00:13:04,920
Так, воспользовавшись, что,
давайте обращать на него внимания.

220
00:13:04,920 --> 00:13:08,190
Давайте просто рассмотрим строки ARGV 0.

221
00:13:08,190 --> 00:13:14,170
>> Так что если мы хотим принести каждый символ
агду 0 на отдельной строке, то я хочу

222
00:13:14,170 --> 00:13:19,500
сделать шаблон мы привыкли, я это
меньше, чем длина массива,

223
00:13:19,500 --> 00:13:23,990
которые здесь, в STRLEN из, это
не то, что я хочу сделать, строка

224
00:13:23,990 --> 00:13:26,450
с равно агду 0.

225
00:13:26,450 --> 00:13:30,390
Так что я меньше длины нашего
массив, который в данном случае представляет собой массив

226
00:13:30,390 --> 00:13:34,410
символов, я плюс плюс.

227
00:13:34,410 --> 00:13:41,040
И так, как мы видели на прошлой неделе, он идеально подходит
если мы будем двигаться, что STRLEN пределами

228
00:13:41,040 --> 00:13:45,210
состояния, так как п будет добавлять
STRLEN из с каждый раз мы идем

229
00:13:45,210 --> 00:13:47,720
через петлю, и это
не будет изменяться.

230
00:13:47,720 --> 00:13:50,230
Так мы установим его равным п над здесь.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> ОК.

233
00:13:55,170 --> 00:14:01,320
Так что теперь, мы итерации
каждый индекс в массиве.

234
00:14:01,320 --> 00:14:05,630
Так вот, если мы хотим напечатать каждый
характер в этом массиве, процентов с является

235
00:14:05,630 --> 00:14:06,880
флаг мы хотим использовать
для персонажей.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
А теперь планка я будет
строка, индекс символа я, так что, если

238
00:14:19,770 --> 00:14:20,970
Строка были привет.

239
00:14:20,970 --> 00:14:27,530
Тогда S 0 будет H, S кронштейн
1 будет е и так далее.

240
00:14:27,530 --> 00:14:30,800
>> Так что теперь мы хотим объединить
эти две вещи.

241
00:14:30,800 --> 00:14:35,440
Мы хотим, чтобы напечатать каждый символ
каждого аргумента командной строки.

242
00:14:35,440 --> 00:14:38,950
Таким образом, мы будем иметь
вложенными цикла.

243
00:14:38,950 --> 00:14:47,480
И обычно, первый счетчик
Я, на следующий будет J, п

244
00:14:47,480 --> 00:14:54,450
будет STRLEN из ARGV г, г
меньше п, я плюс плюс.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
И теперь вместо печати агду I, так
агду кронштейн я собирается индекса -

247
00:15:06,870 --> 00:15:14,280
что будет г-я командной строки
Аргумент, агду I, J собирается

248
00:15:14,280 --> 00:15:16,925
быть JTH характер
г-я аргумент.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
Я избавиться от этого здесь сейчас
так как мы положить его в этом цикле.

251
00:15:24,810 --> 00:15:33,900
Так эквивалентно равных струны с
агду я, а затем с кронштейн J.

252
00:15:33,900 --> 00:15:36,980
>> Ну, мы не должны объявить
эта переменная с.

253
00:15:36,980 --> 00:15:44,530
Вместо этого, мы просто совместить эти
два в то, что у нас было, агду I, J.

254
00:15:44,530 --> 00:15:45,780
>> Выступающий 1: [неразборчиво].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ROB BODEN: Хорошее слово.

257
00:15:49,680 --> 00:15:52,936
Так что это не работает.

258
00:15:52,936 --> 00:15:55,510
Если я на самом деле запустил его, мы бы
это поняли.

259
00:15:55,510 --> 00:16:01,210
Так счетчик меня волнует
В данном конкретном за

260
00:16:01,210 --> 00:16:05,410
цикл у, итератор.

261
00:16:05,410 --> 00:16:08,560
Таким образом, вы бы столкнуться с проблемами,
вероятно, бесконечный цикл, если мы

262
00:16:08,560 --> 00:16:09,540
не зафиксировано, что.

263
00:16:09,540 --> 00:16:12,220
Вот почему мы также говорим
об отладке сегодня.

264
00:16:12,220 --> 00:16:13,120
>> ОК.

265
00:16:13,120 --> 00:16:15,240
Так что давайте запустить эту программу.

266
00:16:15,240 --> 00:16:21,200
И давайте на самом деле добавить отдельный Printf
прямо здесь, что будет просто распечатать

267
00:16:21,200 --> 00:16:27,480
другая линия, так как это означает, когда мы
запустить программу, там будет пусто

268
00:16:27,480 --> 00:16:31,830
линия между каждым характером
каждая строка аргумент командной.

269
00:16:31,830 --> 00:16:33,448
Ну, мы увидим, что это значит.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
ООП.

272
00:16:37,790 --> 00:16:39,870
Есть некоторые ошибки.

273
00:16:39,870 --> 00:16:42,860
Ошибка неявно объявив
Библиотечная функция STRLEN.

274
00:16:42,860 --> 00:16:51,630
>> Так возвращаясь в нашу программу, я
забыл хэш включают string.h.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
Так string.h будет
Файл заголовка, который объявляет

277
00:16:57,730 --> 00:16:58,980
функция STRLEN.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
Хорошо, он компилирует.

280
00:17:06,060 --> 00:17:09,109
Теперь, давайте запустим его.

281
00:17:09,109 --> 00:17:10,930
Так именно это.

282
00:17:10,930 --> 00:17:17,790
Это собирается распечатать наши
Имя программы, привет мир.

283
00:17:17,790 --> 00:17:23,510
Это собирается печатать каждую вещь, каждый
характер, в отдельной строке.

284
00:17:23,510 --> 00:17:24,540
ОК.

285
00:17:24,540 --> 00:17:30,625
>> Так что давайте на самом деле принять это
еще один шаг вперед.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
И вместо того чтобы использовать string.h, давайте
думать о том, как мы бы реализовать наше собственное

288
00:17:39,700 --> 00:17:41,420
STRLEN функция.

289
00:17:41,420 --> 00:17:45,600
Так что я буду немедленно дать
функция подпись.

290
00:17:45,600 --> 00:17:52,900
Так что давайте называть в my_strlen, и это
собирается взять строку в качестве аргумента,

291
00:17:52,900 --> 00:17:57,220
и мы ожидаем, чтобы вернуться
Длина этой строки.

292
00:17:57,220 --> 00:18:03,430
Так, где этот парень?

293
00:18:03,430 --> 00:18:04,990
Да.

294
00:18:04,990 --> 00:18:06,740
ОК.

295
00:18:06,740 --> 00:18:12,900
Так что помните из предыдущего слайда,
был также с прошлой недели, что

296
00:18:12,900 --> 00:18:18,890
массив символов, ну, это строка,
так скажем это наша строка с.

297
00:18:18,890 --> 00:18:29,870
Так что если с это строка, привет, а затем,
Н-Е-Л-Л-О, в памяти, что происходит, чтобы

298
00:18:29,870 --> 00:18:35,610
быть, и то это обратная косая черта
0 характер.

299
00:18:35,610 --> 00:18:39,170
>> Так как же нам получить длину с?

300
00:18:39,170 --> 00:18:43,190
Ну, трюк ищет этот
люфта 0 характер, этот нуль

301
00:18:43,190 --> 00:18:44,380
терминатор.

302
00:18:44,380 --> 00:18:50,270
Таким образом, алгоритм Собирается
должно быть что-то, как мало

303
00:18:50,270 --> 00:18:51,510
достаточно символов, которые -

304
00:18:51,510 --> 00:18:56,180
давайте эта рука представляют некоторые
счетчик, давайте назовем эту длину Int.

305
00:18:56,180 --> 00:19:00,060
Так, начиная с здесь, мы
собирается перебрать нашей строки.

306
00:19:00,060 --> 00:19:04,100
>> Таким образом, первый символ, это H,
и это не обратный слэш 0, так что

307
00:19:04,100 --> 00:19:05,170
длина равна 1.

308
00:19:05,170 --> 00:19:08,050
Перебор к следующему символу,
E, и это не обратную косую черту 0.

309
00:19:08,050 --> 00:19:09,630
Длина составляет 2.

310
00:19:09,630 --> 00:19:10,960
L, 3.

311
00:19:10,960 --> 00:19:11,850
L, 4.

312
00:19:11,850 --> 00:19:13,050
O, 5.

313
00:19:13,050 --> 00:19:16,690
И, наконец, мы достигаем обратную косую черту
0, и так, чтобы средства, ну,

314
00:19:16,690 --> 00:19:17,780
эта строка закончилась.

315
00:19:17,780 --> 00:19:20,130
Так давайте вернемся 5.

316
00:19:20,130 --> 00:19:33,630
>> Поэтому на самом деле реализации, что, во-первых,
моя длина п равна 0, моя правая рука.

317
00:19:33,630 --> 00:19:36,088
И мы собираемся для итерации -

318
00:19:36,088 --> 00:19:38,000
>> Выступающий 1: [неразборчиво]

319
00:19:38,000 --> 00:19:38,640
>> ROB BODEN: О, черт.

320
00:19:38,640 --> 00:19:39,870
Хорошее слово.

321
00:19:39,870 --> 00:19:42,680
Бум.

322
00:19:42,680 --> 00:19:44,140
Так длина п равна 0.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
Так что теперь, длина в то время как с не
равны, а затем, обратный слеш 0.

325
00:19:58,310 --> 00:20:04,660
Так что помните, этот обратный слеш 0, это
Фактический символ, и это означает,

326
00:20:04,660 --> 00:20:05,820
конец строки.

327
00:20:05,820 --> 00:20:09,850
Так же, как, также, косая черта
н является актуальной характер.

328
00:20:09,850 --> 00:20:14,040
Обратная косая черта 0 собирается указывают
конец нашей строки.

329
00:20:14,040 --> 00:20:15,414
Я не хочу, чтобы положить, что там.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
И в то время с индексируются длиной не
равна нулевое окончание, то

332
00:20:25,620 --> 00:20:27,130
мы только собираемся, чтобы увеличить длину.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
Итак, в конце нашей программы,
длина в конечном итоге будет

335
00:20:34,880 --> 00:20:37,610
быть 5 в этом случае.

336
00:20:37,610 --> 00:20:39,210
И мы будем просто вернуть длину.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> ОК.

339
00:20:43,530 --> 00:20:48,290
Так что теперь здесь, я не
сделать my_strlen.

340
00:20:48,290 --> 00:20:50,700
Давайте скомпилировать его, чтобы убедиться,
все проходит гладко.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
Был ли я делаю в 2?

343
00:20:58,210 --> 00:21:00,565
Или в том, что 1?

344
00:21:00,565 --> 00:21:01,940
Это должно сделать.

345
00:21:01,940 --> 00:21:02,690
Хорошо.

346
00:21:02,690 --> 00:21:08,490
Так что это агду 2.

347
00:21:08,490 --> 00:21:11,585
Работает, как ожидалось, хотя
было то, что один я сделал это в?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
Да.

350
00:21:15,550 --> 00:21:16,760
ОК.

351
00:21:16,760 --> 00:21:21,820
Эта версия вещей не было
Е новая линия после, но это

352
00:21:21,820 --> 00:21:22,910
не имеет никакого значения.

353
00:21:22,910 --> 00:21:23,300
ОК.

354
00:21:23,300 --> 00:21:25,780
Так работало как ожидалось.

355
00:21:25,780 --> 00:21:34,750
>> Теперь мы можем даже совместить это еще один шаг
дальше, когда уведомление здесь, ну,

356
00:21:34,750 --> 00:21:38,920
во-первых, мы хватая StrLen из ARGV
я, а затем мы итерации

357
00:21:38,920 --> 00:21:41,450
каждый символ в этой строке.

358
00:21:41,450 --> 00:21:47,480
Таким образом, вместо того, чтобы делать, что, что, если мы
просто объединить эту логику ожидания

359
00:21:47,480 --> 00:21:50,740
пока мы попали обратную косую черту 0 право
в этот цикл?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Так итерации в то время как агду I, J делает
не равны обратный слеш 0.

362
00:22:07,490 --> 00:22:10,680
Так что давайте запустить его в первую очередь.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> Хорошо.

365
00:22:21,180 --> 00:22:27,655
Так вот, это условие говоря -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
давайте проясним, что.

368
00:22:40,060 --> 00:22:49,140
Так что теперь, пусть это будет наша агду.

369
00:22:49,140 --> 00:22:55,290
Поэтому, когда я просто побежал эту программу раньше,
агду является массив строк.

370
00:22:55,290 --> 00:23:03,100
Так вот, если я запускаю его с точечной слэш ARGV
2, привет мир, то агду

371
00:23:03,100 --> 00:23:07,650
само по себе является длина 3, для ARGV
нулю, привет, и мир.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> А внутри каждого из этих показателей,
Сам массив, где это будет

374
00:23:19,660 --> 00:23:23,780
точка, то это будет слэш, я не знаю,
если бы это было правильное направление, я

375
00:23:23,780 --> 00:23:25,680
не думаю, что это было.

376
00:23:25,680 --> 00:23:30,110
-R-V тире, нужно больше места.

377
00:23:30,110 --> 00:23:32,570
Давайте нарезать этом массиве.

378
00:23:32,570 --> 00:23:38,230
-R-V тире 0, а затем обратный слеш 0.

379
00:23:38,230 --> 00:23:43,160
А потом в беспорядке будет привет.

380
00:23:43,160 --> 00:23:45,910
Скажем, Н-Е обратную косую черту 0.

381
00:23:45,910 --> 00:23:51,130
И, наконец, W-O обратный слеш 0.

382
00:23:51,130 --> 00:23:59,730
>> Таким образом, алгоритм, который мы только что написал,
вложенных циклов, то, что они

383
00:23:59,730 --> 00:24:07,321
делать есть, мы сначала должны
противостоять I, а затем J.

384
00:24:07,321 --> 00:24:15,206
Это было бы проще с кодом на
экран, Давайте вернемся к этому.

385
00:24:15,206 --> 00:24:17,476
ОК.

386
00:24:17,476 --> 00:24:24,600
Так заметить, что я это итератор это
итерации по каждой команды

387
00:24:24,600 --> 00:24:25,610
линия аргумент.

388
00:24:25,610 --> 00:24:28,870
И J является итератор итерации
в течение каждого символа в том, что

389
00:24:28,870 --> 00:24:30,410
линия аргумент командной.

390
00:24:30,410 --> 00:24:46,755
Так что же это внутренний Е делает
есть, мы Printf агду 0 0, Е

391
00:24:46,755 --> 00:24:58,680
агду 0 1, Е агду 0 2 0 3, 0 4, 0
5, 0 6, но теперь, агду 0 7 собирается

392
00:24:58,680 --> 00:25:00,670
равна обратный слеш 0.

393
00:25:00,670 --> 00:25:05,730
>> Итак, мы выйти, что для цикла,
и теперь я итерация 1.

394
00:25:05,730 --> 00:25:10,910
И теперь мы собираемся печати
агду 1 0, агду 1 1 -

395
00:25:10,910 --> 00:25:17,040
хорошо, теперь, так как я вырезал привет Короче говоря,
агду 1 2 снова будет

396
00:25:17,040 --> 00:25:18,170
обратный слеш 0.

397
00:25:18,170 --> 00:25:25,050
И так, увеличьте I и продолжить, и
так далее, пока мы не распечатать все

398
00:25:25,050 --> 00:25:28,580
мир, и те три командной строки
аргументы, и мы будем выходить из

399
00:25:28,580 --> 00:25:31,670
внешний контур, и
завершить нашу программу.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
ОК.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> Так что давайте возвращаться сюда.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
Таким образом, вы получите некоторое знакомство с
аргументы командной строки на этом

406
00:25:52,370 --> 00:25:54,460
Особая проблема установить.

407
00:25:54,460 --> 00:25:56,630
>> Теперь, отладка.

408
00:25:56,630 --> 00:26:01,680
Таким образом, вы, наверное, уже должен был сделать
некоторые отладка с ваш предыдущий

409
00:26:01,680 --> 00:26:03,120
Проблема установить.

410
00:26:03,120 --> 00:26:08,420
И один очень простой способ отладки,
Сначала давайте посмотрим на программы багги.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
Ну, прогуливаясь по этой программе,
мы собираемся попросить у пользователя

413
00:26:23,830 --> 00:26:29,350
целое число, захватить, что целое, а затем,
произвольно, у нас есть какое-то время цикла, что

414
00:26:29,350 --> 00:26:32,280
только собирается уменьшать
я пока это не равно 10.

415
00:26:32,280 --> 00:26:35,820
Давайте просто предположим, я ввода
целым числом, большим чем 10.

416
00:26:35,820 --> 00:26:38,700
Так уменьшения я пока это не равно 10.

417
00:26:38,700 --> 00:26:42,630
>> А потом у нас есть еще время цикла
, что, хотя я не равна 0, мы

418
00:26:42,630 --> 00:26:44,540
собирается уменьшать I на 3.

419
00:26:44,540 --> 00:26:49,790
Так что если вы видите намерение ошибка
здесь, это, что это будет уменьшать я в

420
00:26:49,790 --> 00:26:57,010
быть 10, а затем это пока петля воля
декремент я с 10, до 7, до 4, до 1,

421
00:26:57,010 --> 00:27:02,880
к отрицательному 2, на отрицательный 5, и так далее,
минус бесконечности, так как я буду

422
00:27:02,880 --> 00:27:05,920
никогда не равны 0.

423
00:27:05,920 --> 00:27:08,610
А потом в конце этой программы,
у нас есть функция Foo, который

424
00:27:08,610 --> 00:27:12,130
происходит печать, что я.

425
00:27:12,130 --> 00:27:16,520
>> Так что это короткие и тривиально программа,
и ошибка очевидна,

426
00:27:16,520 --> 00:27:18,790
особенно после того как я просто
сказал, что ошибка была.

427
00:27:18,790 --> 00:27:24,840
Но цель здесь, ну, это может
на самом деле выглядит некоторые из ваших

428
00:27:24,840 --> 00:27:30,040
решения от жадного от последнего
Проблема установить, и, возможно, у вас есть

429
00:27:30,040 --> 00:27:32,800
некоторые бесконечный цикл в вашей программе,
и вы не имеете ни малейшего представления,

430
00:27:32,800 --> 00:27:34,100
чем это вызвано.

431
00:27:34,100 --> 00:27:38,690
Так очень полезным методом отладки
это просто добавить printfs

432
00:27:38,690 --> 00:27:40,180
во всем коде.

433
00:27:40,180 --> 00:27:49,200
>> Так вот я хочу Printf пределами
первую очередь, а петля.

434
00:27:49,200 --> 00:27:53,155
И здесь я хочу Printf,
и я просто распечатать I.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
Я даже сделать в первую очередь то время как цикл, я.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
Снаружи, второй в то время как петля.

439
00:28:09,040 --> 00:28:12,170
Еще раз, распечатать внутри
отсюда, значение я.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
И давайте запустим этот.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> Так точка слэш отладки.

444
00:28:24,800 --> 00:28:25,610
Введите целое число.

445
00:28:25,610 --> 00:28:28,150
Давайте сделаем 13.

446
00:28:28,150 --> 00:28:28,760
И бум.

447
00:28:28,760 --> 00:28:33,300
Мы видим, что мы зацикливания
внутри второго время цикла.

448
00:28:33,300 --> 00:28:36,305
Так что теперь мы знаем, что ошибка есть.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
Но Е отладки совершенно замечательно,
но как только ваши программы получить

451
00:28:45,610 --> 00:28:50,560
более и более сложными, существует
более сложные решения

452
00:28:50,560 --> 00:28:51,705
получать все заработало.

453
00:28:51,705 --> 00:28:52,955
Так что давайте удалить все эти printfs.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
И давайте удостоверимся, что я не сделал
сломать что-нибудь.

456
00:29:08,896 --> 00:29:09,850
ОК.

457
00:29:09,850 --> 00:29:14,180
>> Таким образом, программа, которую мы собираемся
ввести называется

458
00:29:14,180 --> 00:29:16,715
GDB, для GNU Debugger.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
Ну, на самом деле, давайте уберем отладки для
во-вторых, и сделать отладку снова.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
Ну, на самом деле первый, хороший урок
в аргументы командной строки.

463
00:29:34,440 --> 00:29:37,780
Обратите внимание, что это Clang команда, которая является
компиляции все передается

464
00:29:37,780 --> 00:29:41,300
в командной строке, это
аргументы командной строки.

465
00:29:41,300 --> 00:29:46,250
Так как именно вы собираетесь использовать
аргументы командной строки, как мы

466
00:29:46,250 --> 00:29:51,500
раньше, и как вы будете в PSET
2, вот как Clang использует их.

467
00:29:51,500 --> 00:30:00,070
>> Так заметить, что это первый флаг, тире
ggdb3, что это говорит есть, Clang,

468
00:30:00,070 --> 00:30:03,790
вы должны скомпилировать этот файл с
Цель, что мы в конечном итоге

469
00:30:03,790 --> 00:30:05,380
нужно отлаживать его.

470
00:30:05,380 --> 00:30:13,840
Так что, пока у вас есть этот флаг,
то мы можем GDB отлаживать.

471
00:30:13,840 --> 00:30:17,380
И это будет открыть GNU отладчик.

472
00:30:17,380 --> 00:30:22,920
>> Таким образом, есть много команд
что вам нужно привыкнуть.

473
00:30:22,920 --> 00:30:27,100
Сначала один, что вы, вероятно,
сразу нужно Run.

474
00:30:27,100 --> 00:30:28,200
Так что же Запустите собираетесь делать?

475
00:30:28,200 --> 00:30:30,910
Это собирается начать нашу программу.

476
00:30:30,910 --> 00:30:36,180
Так бегите, начиная программу, программу
просит нас для целого числа, 13.

477
00:30:36,180 --> 00:30:39,170
А потом это бесконечное зацикливание как
Ожидается, кроме я удалил

478
00:30:39,170 --> 00:30:40,500
printfs, поэтому мы даже не видим, что.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
Вышел нормально.

481
00:30:44,600 --> 00:30:45,850
О.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
Вполне возможно, что это завернутые все
наоборот, к - игнорируя это.

484
00:30:53,640 --> 00:30:55,170
Предположим, это не выйти нормально.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
Там в сложной ответ на этот вопрос.

487
00:31:03,370 --> 00:31:07,890
>> Так что теперь, это не очень полезно.

488
00:31:07,890 --> 00:31:11,480
Так просто работает нашу программу внутри
это отладчик не помочь нам в любом

489
00:31:11,480 --> 00:31:15,610
образом, так как мы могли только что сделали
точка слэш отладки извне GDB.

490
00:31:15,610 --> 00:31:21,250
Так команда одна, что
вы, вероятно, -

491
00:31:21,250 --> 00:31:22,970
и я брошу это.

492
00:31:22,970 --> 00:31:25,850
Control-D или бросить курить, и работу.

493
00:31:25,850 --> 00:31:29,550
Так давайте откроем его снова.

494
00:31:29,550 --> 00:31:31,130
>> Другая команда, что вы, вероятно,
сразу хочу

495
00:31:31,130 --> 00:31:33,600
привыкнуть к тому, Перерыв.

496
00:31:33,600 --> 00:31:37,120
Таким образом, мы сломаю на главную на данный момент,
а затем я объясню, что.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
Ну, вот мы видим, мы установить точку останова
на этой линии в debug.c.

499
00:31:46,370 --> 00:31:50,160
Так что перерыв средства является то, что, когда я
введите бег, программа будет

500
00:31:50,160 --> 00:31:53,560
не продолжать работать до тех пор,
Я ударил точку останова.

501
00:31:53,560 --> 00:31:59,390
Поэтому, когда я ударил бег, программа начинает,
а затем он распадается, как только это

502
00:31:59,390 --> 00:32:01,940
входит в основную функцию.

503
00:32:01,940 --> 00:32:06,930
Перерыв основной будет что-то
Вы довольно часто делать.

504
00:32:06,930 --> 00:32:11,340
>> И теперь, чтобы познакомить вас
чтобы еще несколько команд.

505
00:32:11,340 --> 00:32:14,330
Заметьте здесь, то это говорит, что мы
нарушил на линии 11, который

506
00:32:14,330 --> 00:32:16,230
Е, введите целое число.

507
00:32:16,230 --> 00:32:21,260
Так команда Следующая будет, как
мы идем в следующей строке кода.

508
00:32:21,260 --> 00:32:24,810
Это будет, чтобы позволить нам шаг
через нашу программу строка за строкой.

509
00:32:24,810 --> 00:32:26,260
Так что в следующий.

510
00:32:26,260 --> 00:32:29,820
>> Теперь линия 12, мы собираемся
чтобы получить целое.

511
00:32:29,820 --> 00:32:30,450
Следующая.

512
00:32:30,450 --> 00:32:34,290
И если вы просто нажмите Enter снова, оно будет
повторить последнее, что вы сделали.

513
00:32:34,290 --> 00:32:36,480
Так что я не нужно вводить
Следующий каждый раз.

514
00:32:36,480 --> 00:32:40,100
Так введите целое число, 13.

515
00:32:40,100 --> 00:32:46,940
Так что теперь, строка 14, в то время как я больше
чем 10, и я буду делать дальше.

516
00:32:46,940 --> 00:32:48,685
И мы видим, что мы собираемся уменьшить I.

517
00:32:48,685 --> 00:32:50,210
Так что мы собираемся для уменьшения я снова.

518
00:32:50,210 --> 00:32:53,620
>> Так что теперь, еще один полезный
команда печати.

519
00:32:53,620 --> 00:32:55,750
Так Распечатать собирается распечатать
Значение переменной.

520
00:32:55,750 --> 00:32:57,825
Давайте выявить значение
переменной I.

521
00:32:57,825 --> 00:32:58,705
Давайте печатать I.

522
00:32:58,705 --> 00:33:00,910
Это будет сказать, что я на 11.

523
00:33:00,910 --> 00:33:03,330
Теперь мы еще раз Далее, в то время как
я больше 10.

524
00:33:03,330 --> 00:33:05,590
Так что я по-прежнему больше, чем
10, так как это 11.

525
00:33:05,590 --> 00:33:06,920
я минус минус.

526
00:33:06,920 --> 00:33:08,250
Давайте печатать я снова.

527
00:33:08,250 --> 00:33:10,950
Как и ожидалось, это 10.

528
00:33:10,950 --> 00:33:12,510
>> Так что теперь, рядом.

529
00:33:12,510 --> 00:33:16,250
Это возвращаясь к состоянию, я это
больше 10, но я теперь 10, так что

530
00:33:16,250 --> 00:33:20,040
это не больше 10, поэтому мы ожидаем,
это выпасть из то время цикла.

531
00:33:20,040 --> 00:33:22,220
И теперь мы ниже этого строки кода.

532
00:33:22,220 --> 00:33:28,750
И другая команда, Список, просто будет
для отображения предыдущего и следующего

533
00:33:28,750 --> 00:33:31,240
пару строк кода, в
случае, если вы потеряли себя.

534
00:33:31,240 --> 00:33:35,420
Так что мы просто вышли эту то время как цикл,
и теперь мы вступили в этом

535
00:33:35,420 --> 00:33:37,080
в то время как цикл, линия 18.

536
00:33:37,080 --> 00:33:39,860
Таким образом, хотя я не равно 0.

537
00:33:39,860 --> 00:33:46,570
И, далее, я равна I минус 3, и мы будем
Отметим, это будет просто продолжать идти.

538
00:33:46,570 --> 00:33:48,270
И мы можем напечатать I.

539
00:33:48,270 --> 00:33:49,990
>> Каждая команда рода имеет ярлыки.

540
00:33:49,990 --> 00:33:51,720
Так р короток для печати.

541
00:33:51,720 --> 00:33:53,400
Таким образом, мы можем P I.

542
00:33:53,400 --> 00:33:57,550
Просто удерживайте п,
или продолжать делать Далее.

543
00:33:57,550 --> 00:33:58,340
Распечатать я снова.

544
00:33:58,340 --> 00:34:00,380
Вы видите сейчас он отрицательный 167.

545
00:34:00,380 --> 00:34:06,030
Так что это будет продолжаться вечно, но не
действительно навсегда, так как вы только что видели, это

546
00:34:06,030 --> 00:34:09,330
на самом деле конец в некоторой точке.

547
00:34:09,330 --> 00:34:15,699
>> Так что, начиная GDB.

548
00:34:15,699 --> 00:34:19,504
Но давайте сделаем еще одну вещь в GDB.

549
00:34:19,504 --> 00:34:20,754
Э-э, отладки.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
Таким образом, в данном конкретном случае
бесконечный цикл, оказалось, внутри

552
00:34:28,534 --> 00:34:30,050
основная функция.

553
00:34:30,050 --> 00:34:35,779
И на данный момент, просто признать, что, что я
будет двигаться бесконечный цикл в

554
00:34:35,779 --> 00:34:37,029
функция Foo.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
Только помните, что, в конце этого
Программа, также, это было первоначально

557
00:34:43,730 --> 00:34:46,210
вызова Foo, который был просто
в печать I.

558
00:34:46,210 --> 00:34:51,880
Но теперь мы называем Фу, который является
собирается уменьшать I, пока это не 0, а

559
00:34:51,880 --> 00:34:54,548
затем распечатать эту переменную.

560
00:34:54,548 --> 00:34:55,469
ОК.

561
00:34:55,469 --> 00:34:57,970
Сохранить это.

562
00:34:57,970 --> 00:35:00,175
Сделать отладки.

563
00:35:00,175 --> 00:35:03,310
А теперь, GDB отладки.

564
00:35:03,310 --> 00:35:04,090
ОК.

565
00:35:04,090 --> 00:35:10,580
>> Так что, если я просто запустить то я не собираюсь
быть в состоянии фактически пошагово мой

566
00:35:10,580 --> 00:35:11,730
Программа линия за линией.

567
00:35:11,730 --> 00:35:19,820
Так давайте разберем на основной,
а затем введите перспективе.

568
00:35:19,820 --> 00:35:28,160
Так пройти через это, Е, введите
целое число, получить целое, 13.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
Таким образом, мы собираемся продолжать уменьшая
пока я не больше 10.

571
00:35:37,490 --> 00:35:42,840
Тогда мы идем, чтобы провалиться
в то время как цикл, и добраться до линии -

572
00:35:42,840 --> 00:35:44,364
давайте откроем его в отдельном окне.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
Таким образом, мы не уменьшается, пока я уже не
больше 10, и тогда мы

575
00:35:53,300 --> 00:35:55,700
называется функцией, Foo.

576
00:35:55,700 --> 00:36:01,340
>> Так что же произошло, как только я попал
Функция Foo, ну, я позвонил Фу, и

577
00:36:01,340 --> 00:36:04,030
не то я уже не имел контроля над GDB.

578
00:36:04,030 --> 00:36:10,230
Поэтому, как только я ударил Далее в этой линии,
вещи продолжали, пока это не произошло,

579
00:36:10,230 --> 00:36:12,400
где вышла программа, когда -

580
00:36:12,400 --> 00:36:14,450
предположить, что это не было в конце концов.

581
00:36:14,450 --> 00:36:16,390
Вы видели это приостановить на некоторое время все же.

582
00:36:16,390 --> 00:36:22,040
Так почему же я теряю контроль над
программа в этот момент?

583
00:36:22,040 --> 00:36:27,540
Ну, когда я печатаю следующий, который идет в
буквальный Следующая строка кода, что

584
00:36:27,540 --> 00:36:28,850
будет выполнять.

585
00:36:28,850 --> 00:36:35,950
Таким образом, после линии 21, в следующей строке кода
, который будет выполнять это линия 22,

586
00:36:35,950 --> 00:36:38,520
который, выходя из основной.

587
00:36:38,520 --> 00:36:43,810
Так что я не хочу, чтобы просто пойти
в следующей строке кода.

588
00:36:43,810 --> 00:36:48,170
Я хочу пойти в функцию, Фу,
а потом еще и пошагово

589
00:36:48,170 --> 00:36:49,830
эти строки кода.

590
00:36:49,830 --> 00:36:53,726
>> Таким образом, для этого у нас есть альтернатива.

591
00:36:53,726 --> 00:36:56,770
Давайте бросить это снова.

592
00:36:56,770 --> 00:36:58,020
Перерыв основной.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
Э-э, 1, рядом, рядом, 13, рядом,
Далее, следующий, осторожно,

595
00:37:06,370 --> 00:37:09,820
прежде чем мы попали строки Foo.

596
00:37:09,820 --> 00:37:10,520
ОК.

597
00:37:10,520 --> 00:37:13,700
>> Так что теперь, мы в строке 21,
где мы называем Foo.

598
00:37:13,700 --> 00:37:17,100
Мы не хотим, чтобы ввести следующий, так что
просто вызвать функцию Фу, и

599
00:37:17,100 --> 00:37:18,710
перейти к следующей строке кода.

600
00:37:18,710 --> 00:37:20,840
Что мы хотим использовать это Шаг.

601
00:37:20,840 --> 00:37:25,690
Так что есть разница между шаге
А рядом, где Шаг шаги в

602
00:37:25,690 --> 00:37:28,190
функционировать, и Следующая идет
на себя функцию.

603
00:37:28,190 --> 00:37:32,830
Это просто выполняет полноту
функция, и продолжает идти.

604
00:37:32,830 --> 00:37:37,210
>> Так Шаг собирается привести нас
в функцию, Foo.

605
00:37:37,210 --> 00:37:41,160
И мы видим здесь, сейчас, когда мы вернулись в
это в то время как цикл, который это, по идее,

606
00:37:41,160 --> 00:37:44,190
собирается продолжаться вечно.

607
00:37:44,190 --> 00:37:50,420
И если вы попали Шаг, когда это даже не
функция вызываемая, то это

608
00:37:50,420 --> 00:37:51,720
идентичен Далее.

609
00:37:51,720 --> 00:37:55,320
Так что это только тогда, когда вы находитесь на линии, которая
вызывает функцию на этот шаг

610
00:37:55,320 --> 00:37:56,970
собирается отличаться от Next.

611
00:37:56,970 --> 00:37:57,930
Так Шаг принесет нам здесь.

612
00:37:57,930 --> 00:38:02,100
Шаг, шаг, шаг, шаг, шаг, шаг, и
мы просто бесконечный цикл навсегда.

613
00:38:02,100 --> 00:38:06,810
>> Так что вы можете привыкнуть к тому, как ваш
способ идентификации бесконечные циклы, является

614
00:38:06,810 --> 00:38:08,960
просто держа эту клавишу ввода, чтобы
увидеть, где вы застряли.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
Есть более эффективные способы сделать это, но
на данный момент, то есть вполне достаточно.

617
00:38:14,780 --> 00:38:17,967
И стилистически, чтобы соответствовать стилю
50, я должен был сделать это.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
ОК.

620
00:38:24,030 --> 00:38:28,400
>> Так что последняя команда ввести.

621
00:38:28,400 --> 00:38:30,810
Ну, давайте GDB отлаживать дюйма

622
00:38:30,810 --> 00:38:35,580
Поэтому вместо того, ломая при основной, если я
знать функцию Foo также

623
00:38:35,580 --> 00:38:39,230
Проблема, то я, возможно, просто
сказал, перерыв на Foo, вместо этого.

624
00:38:39,230 --> 00:38:42,310
Скажем, я разорвать на
как основной и Foo.

625
00:38:42,310 --> 00:38:45,390
Таким образом, вы можете установить столько точек останова
как вы хотите.

626
00:38:45,390 --> 00:38:49,230
Когда я печатаю работать, это будет
останавливаться на -

627
00:38:49,230 --> 00:38:52,180
ох, давайте перекомпилировать, так как
Я изменил вещи.

628
00:38:52,180 --> 00:38:55,950
Вы увидите эту строку, предупреждение, источник
файл более новое, чем исполняемый файл.

629
00:38:55,950 --> 00:38:59,680
Так это значит, что я просто пошел сюда
и изменил их в соответствие с стиле

630
00:38:59,680 --> 00:39:03,100
50, но я не перекомпилировать
программа.

631
00:39:03,100 --> 00:39:04,870
Так GDB делает меня в курсе.

632
00:39:04,870 --> 00:39:10,130
Я брошу, сделать отладку снова,
ударил GDB отлаживать.

633
00:39:10,130 --> 00:39:10,700
ОК.

634
00:39:10,700 --> 00:39:12,800
>> Так что теперь, к тому, что я делал.

635
00:39:12,800 --> 00:39:15,720
Перерыв основной, перерыв Foo.

636
00:39:15,720 --> 00:39:20,680
Теперь, если я запускаю программу, так что это
собирается продолжить, пока не попадает

637
00:39:20,680 --> 00:39:21,320
останова.

638
00:39:21,320 --> 00:39:24,680
Это останова происходит с
быть первым в основной.

639
00:39:24,680 --> 00:39:28,630
Теперь, вместо того, чтобы делать следующий, следующий, следующий,
следующий, следующий, пока я не попал Фу, я

640
00:39:28,630 --> 00:39:35,230
можно ввести продолжать, которая будет продолжаться
пока вы не попали следующей точки останова.

641
00:39:35,230 --> 00:39:37,200
Я должен ввести целое первым.

642
00:39:37,200 --> 00:39:40,570
Продолжить будет продолжаться, пока я не попал
следующей точки, которая является то, что

643
00:39:40,570 --> 00:39:43,320
функция пищевой.

644
00:39:43,320 --> 00:39:50,130
>> Так Run будет работать, пока вы нажмете
останова, но вы только тип запуска, когда

645
00:39:50,130 --> 00:39:54,060
вы начинаете программу, а затем,
с тех пор, это продолжать.

646
00:39:54,060 --> 00:40:01,950
Если бы я просто сделал брейк основной и
потом побежал, он будет перерыв в

647
00:40:01,950 --> 00:40:03,670
Основной, а затем продолжить.

648
00:40:03,670 --> 00:40:10,050
Поскольку у меня нет точки останова на Foo,
введите целое, то теперь я

649
00:40:10,050 --> 00:40:11,380
не собирается сломать в пищевой.

650
00:40:11,380 --> 00:40:16,318
Это просто будет до бесконечности
цикл, пока что.

651
00:40:16,318 --> 00:40:17,568
ОК.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> Так вот Введение в GDB.

654
00:40:24,420 --> 00:40:27,790
Вы должны начать использовать его
в ваших проблемных множеств.

655
00:40:27,790 --> 00:40:30,550
Это может быть очень полезно
определить ошибки.

656
00:40:30,550 --> 00:40:35,280
Если вы на самом деле просто, линия за линией, перейдите
по коду, и сравнить то, что является

657
00:40:35,280 --> 00:40:39,740
на самом деле происходит с тем, что вы ожидаете
произойдет, то это довольно

658
00:40:39,740 --> 00:40:41,060
трудно не заметить ваши ошибки.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
ОК.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> Так на прошлой неделе Дэвид воспитывался этот
секретным ключом вещи для

663
00:40:54,040 --> 00:40:59,350
первый раз, когда мы не хотим
пароли просто храниться на нашем

664
00:40:59,350 --> 00:41:03,210
компьютер в некотором простом текстовом файле, где
кто-то может приехать и просто

665
00:41:03,210 --> 00:41:04,660
открыть его и прочитать их.

666
00:41:04,660 --> 00:41:07,530
В идеале, они будут зашифрованы
в некотором роде.

667
00:41:07,530 --> 00:41:13,340
И в задаче установить 2, вы будете иметь дело
с одного способа шифрования,

668
00:41:13,340 --> 00:41:16,520
или, ну, два метода, но
они не настолько велики.

669
00:41:16,520 --> 00:41:20,050
Если вы делаете хакер издание, вы
также собирается иметь дело с

670
00:41:20,050 --> 00:41:22,150
расшифровки некоторые вещи.

671
00:41:22,150 --> 00:41:29,770
>> Так что вопрос теперь в том, хорошо, даже если
у нас есть стойкое шифрование

672
00:41:29,770 --> 00:41:34,830
Алгоритм в мире, если вы выбираете
особенно бедных пароль, то она

673
00:41:34,830 --> 00:41:37,720
не поможет вам очень много, так как люди
еще смогут понять это.

674
00:41:37,720 --> 00:41:41,530
Даже если посмотреть зашифрованную строку и
это выглядит как беспорядок мусора

675
00:41:41,530 --> 00:41:44,760
что ничего не значит для них, если они
еще просто нужно попробовать несколько паролей

676
00:41:44,760 --> 00:41:50,560
чтобы понять это, то вы
не очень безопасно.

677
00:41:50,560 --> 00:41:55,890
Так просмотре видео,
делает эту точку.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [ВИДЕОВОСПРОИЗВЕДЕНИЕ]

680
00:42:00,970 --> 00:42:02,100
>> -Шлем, вы злодей.

681
00:42:02,100 --> 00:42:03,370
Что происходит?

682
00:42:03,370 --> 00:42:05,170
Что ты делаешь с моей дочерью?

683
00:42:05,170 --> 00:42:09,910
>> -Позвольте мне представить блестящий
молодой пластический хирург, доктор Филипп

684
00:42:09,910 --> 00:42:13,730
Schlotkin, наибольшее нос
работа мужчина в всей

685
00:42:13,730 --> 00:42:16,080
Вселенной, и Беверли-Хиллз.

686
00:42:16,080 --> 00:42:17,210
>> -Ваше Высочество.

687
00:42:17,210 --> 00:42:18,070
>> -Нос работа?

688
00:42:18,070 --> 00:42:18,670
Не понимаю.

689
00:42:18,670 --> 00:42:20,090
Она уже была работа носа.

690
00:42:20,090 --> 00:42:21,910
Это был сладкий шестнадцать присутствует.

691
00:42:21,910 --> 00:42:22,140
>> -Нет.

692
00:42:22,140 --> 00:42:23,690
Это не то, что вы думаете.

693
00:42:23,690 --> 00:42:25,420
Это гораздо, гораздо хуже.

694
00:42:25,420 --> 00:42:30,300
Если вы не даете мне комбинацию, чтобы
воздух щит, доктор Schlotkin будет

695
00:42:30,300 --> 00:42:34,226
дать свою дочь обратно свой старый нос.

696
00:42:34,226 --> 00:42:35,476
>> -Нет.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
Где ты это взял?

699
00:42:40,516 --> 00:42:41,440
>> -Все в порядке.

700
00:42:41,440 --> 00:42:42,180
Я скажу.

701
00:42:42,180 --> 00:42:43,381
Я скажу.

702
00:42:43,381 --> 00:42:44,263
Нет, папа.

703
00:42:44,263 --> 00:42:45,590
Нет, вы не должны.

704
00:42:45,590 --> 00:42:46,860
>> -Вы правы, моя дорогая.

705
00:42:46,860 --> 00:42:48,450
Я буду скучать по вашей новой нос.

706
00:42:48,450 --> 00:42:52,090
Но я не скажу ему комбинацию,
несмотря ни на что.

707
00:42:52,090 --> 00:42:53,680
>> -Очень хорошо.

708
00:42:53,680 --> 00:42:55,685
Доктор Schlotkin, дело ваше.

709
00:42:55,685 --> 00:42:56,914
>> -С удовольствием.

710
00:42:56,914 --> 00:43:00,690
>> [ИНСТРУМЕНТЫ точат]

711
00:43:00,690 --> 00:43:01,910
>> -Нет.

712
00:43:01,910 --> 00:43:02,520
Подождите.

713
00:43:02,520 --> 00:43:03,836
Подождите.

714
00:43:03,836 --> 00:43:05,300
Я скажу.

715
00:43:05,300 --> 00:43:06,880
Я скажу.

716
00:43:06,880 --> 00:43:09,130
>> -Я знал, что это будет работать.

717
00:43:09,130 --> 00:43:09,900
Хорошо.

718
00:43:09,900 --> 00:43:12,850
Отдай его мне.

719
00:43:12,850 --> 00:43:16,918
>> Сочетание-один.

720
00:43:16,918 --> 00:43:17,406
>> -Один.

721
00:43:17,406 --> 00:43:18,382
>> -Один.

722
00:43:18,382 --> 00:43:19,358
>> -Два.

723
00:43:19,358 --> 00:43:19,846
>> -Два.

724
00:43:19,846 --> 00:43:20,822
>> -Два.

725
00:43:20,822 --> 00:43:21,310
>> -Три.

726
00:43:21,310 --> 00:43:21,798
>> -Три.

727
00:43:21,798 --> 00:43:22,774
>> -Три.

728
00:43:22,774 --> 00:43:23,262
>> -Четыре.

729
00:43:23,262 --> 00:43:23,750
>> -Четыре.

730
00:43:23,750 --> 00:43:26,150
>> -Четыре.

731
00:43:26,150 --> 00:43:27,010
>> -Пять.

732
00:43:27,010 --> 00:43:27,670
>> -Пять.

733
00:43:27,670 --> 00:43:29,010
>> -Пять.

734
00:43:29,010 --> 00:43:34,770
>> -Так сочетание является одним,
два, три, четыре, пять.

735
00:43:34,770 --> 00:43:37,460
Это самая глупая комбинация
Я когда-либо слышал в своей жизни.

736
00:43:37,460 --> 00:43:39,710
Это та вещь, идиот
будет иметь на своем багаже.

737
00:43:39,710 --> 00:43:42,000
>> -Спасибо, ваше высочество.

738
00:43:42,000 --> 00:43:43,530
>> -Что ты сделал?

739
00:43:43,530 --> 00:43:44,490
>> -Я выключил стену.

740
00:43:44,490 --> 00:43:45,420
>> -Нет, ты не сделал.

741
00:43:45,420 --> 00:43:45,840
Вы выключили весь фильм.

742
00:43:45,840 --> 00:43:46,930
>> -Должно быть, я нажал не ту кнопку.

743
00:43:46,930 --> 00:43:48,265
>> -Ну, положил его обратно на.

744
00:43:48,265 --> 00:43:49,110
Положите видеофильм на.

745
00:43:49,110 --> 00:43:49,510
>> -Да, сэр.

746
00:43:49,510 --> 00:43:49,917
Да, сэр.

747
00:43:49,917 --> 00:43:50,324
>> -Пойдем, Арнольд.

748
00:43:50,324 --> 00:43:51,140
Приходите, Гретхен.

749
00:43:51,140 --> 00:43:53,060
Конечно, вы знаете, я буду по-прежнему
должны выставить вам счет за это.

750
00:43:53,060 --> 00:43:53,440
>> [КОНЕЦ ВИДЕОВОСПРОИЗВЕДЕНИЕ]

751
00:43:53,440 --> 00:43:54,690
>> ROB BODEN: Хорошо.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
Так что теперь мы уже говорим о
безопасности в некоторых отношениях, хороший

754
00:44:08,430 --> 00:44:16,050
немного постер фильма, поэтому в последнее время
дней, эти вопросы с АНБ

755
00:44:16,050 --> 00:44:17,300
мониторинга все.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
Это может быть трудно, чтобы чувствовать, что вы
есть своего рода частной жизни в

758
00:44:26,930 --> 00:44:34,540
Онлайновый мир, хотя я не мог сказать
Вас больше деталей PRISM.

759
00:44:34,540 --> 00:44:42,130
Так выходит за рамки PRISM, мы не собираемся
чтобы говорить о том, что, в настоящее время

760
00:44:42,130 --> 00:44:44,030
думаю о своем ноутбуке.

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

762
00:44:48,360 --> 00:44:50,370
с моей маленькой пингвина.

763
00:44:50,370 --> 00:44:57,310
Так у меня есть набор паролей, и что
пароль, что я хочу, чтобы это было.

764
00:44:57,310 --> 00:45:02,430
>> Но помните, что то, что я входа
в с, так что это Войти

765
00:45:02,430 --> 00:45:04,850
подскажите, есть какая-то программа.

766
00:45:04,850 --> 00:45:07,910
Это какая-то программа, которая была
написано несколько человек.

767
00:45:07,910 --> 00:45:13,250
И так, что человек, если они
особенно вредоносным, они могли

768
00:45:13,250 --> 00:45:17,780
уже говорили, все в порядке, так что, если пароль
что я вхожу равна мой

769
00:45:17,780 --> 00:45:22,800
реальный пароль, или он равен
в некоторой специального пароля -

770
00:45:22,800 --> 00:45:25,550
Дэвид является удивительным или что-то -

771
00:45:25,550 --> 00:45:27,190
то пусть их сюда

772
00:45:27,190 --> 00:45:33,760
Так вредоносный программист может иметь
доступ ко всем вашим Mac, или

773
00:45:33,760 --> 00:45:36,150
Окна, или что-либо.

774
00:45:36,150 --> 00:45:41,980
>> Так что это не большая проблема, так как,
Я имею в виду, это Войти программа

775
00:45:41,980 --> 00:45:48,720
который поставляется с OS X, сотни
или тысячи людей имеют

776
00:45:48,720 --> 00:45:50,020
отзывы этот код.

777
00:45:50,020 --> 00:45:55,330
Так вот, если, в коде где-то, вы
говорят, что если эта строка равна равных

778
00:45:55,330 --> 00:45:58,860
Дэвид является удивительным, Логин, то кто-то
будет, как, подождите.

779
00:45:58,860 --> 00:45:59,800
Это не правильно.

780
00:45:59,800 --> 00:46:01,790
Это не должно быть здесь.

781
00:46:01,790 --> 00:46:06,650
Так вот один из способов получить вещи
быть своего рода безопасным.

782
00:46:06,650 --> 00:46:10,300
>> Но думать об даже программ
что вы пишете.

783
00:46:10,300 --> 00:46:13,000
Допустим, вы написали программу входа в систему.

784
00:46:13,000 --> 00:46:20,440
Так что это Войти программа, что вы написали,
так что, очевидно, вы хороший

785
00:46:20,440 --> 00:46:21,210
программист.

786
00:46:21,210 --> 00:46:25,610
Вы не собираетесь поставить любой вредоносный
если х = равна Дэвид является удивительным

787
00:46:25,610 --> 00:46:27,860
в код.

788
00:46:27,860 --> 00:46:31,930
Но эта программа, то, что вы
использовать для компиляции этой программы?

789
00:46:31,930 --> 00:46:34,180
Что-то вроде Clang.

790
00:46:34,180 --> 00:46:38,460
Так что если человек, который, оказалось,
написать Clang специальное упакованным в Clang

791
00:46:38,460 --> 00:46:44,310
что-то вроде, если я компиляции
войдите программу, а затем введите этот код

792
00:46:44,310 --> 00:46:49,720
в программу авторизации, которая говорит, если
х равна равна Дэвид является удивительным?

793
00:46:49,720 --> 00:46:59,890
Так что не совсем еще, но у нас есть то же самое
выдавать здесь, где Clang, ну,

794
00:46:59,890 --> 00:47:03,790
тысячи, если не десятки тысяч
люди, смотрели на Clang, есть

795
00:47:03,790 --> 00:47:07,160
посмотрел на ее строк кода и сказал:
Все в порядке, нет ничего плохо здесь.

796
00:47:07,160 --> 00:47:10,680
Очевидно, что никто не делает
ничего этот вредоносный.

797
00:47:10,680 --> 00:47:15,780
>> Но то, что лязгом себя, вроде бы,
что, если я компиляции Clang?

798
00:47:15,780 --> 00:47:20,900
Что делать, если у меня есть компилятор, который
компилирует Clang, который вставляет в Clang

799
00:47:20,900 --> 00:47:25,610
этот специальный хак, который говорит, все в порядке,
когда я компиляции Clang, то

800
00:47:25,610 --> 00:47:31,290
исполняемый я получаю должны специально искать
внутри программы входа в систему и вставки

801
00:47:31,290 --> 00:47:34,230
этот пароль, равна равных
Дэйв является удивительным?

802
00:47:34,230 --> 00:47:37,990
Поэтому помните, что ваш компилятор сам
должен быть скомпилирован в какой-то момент.

803
00:47:37,990 --> 00:47:42,810
Так что, если то, что вы выбираете для компиляции Clang
с, само по себе является вредоносным, то вы

804
00:47:42,810 --> 00:47:45,580
может быть пьяным всю
путь вниз линии.

805
00:47:45,580 --> 00:47:49,630
>> Так вот, у нас есть Кен Томпсон
и Деннис Ритчи.

806
00:47:49,630 --> 00:47:53,780
Так что это является знаковым фото.

807
00:47:53,780 --> 00:47:55,470
Деннис Ритчи находится справа.

808
00:47:55,470 --> 00:47:58,740
Он является одним из основных -

809
00:47:58,740 --> 00:48:03,640
в значительной степени писал С. Таким образом, вы можете
поблагодарить его за этого класса.

810
00:48:03,640 --> 00:48:04,840
Кен Томсон находится на левой стороне.

811
00:48:04,840 --> 00:48:07,780
Два из них в основном писал UNIX.

812
00:48:07,780 --> 00:48:10,140
Ну, они были основными причинами
в UNIX.

813
00:48:10,140 --> 00:48:11,310
Были некоторые другие.

814
00:48:11,310 --> 00:48:16,240
Так Кен Томпсон, в какой-то момент,
он выигрывает премию Тьюринга.

815
00:48:16,240 --> 00:48:20,860
И премию Тьюринга, я всегда слышал
это ссылки таким образом, что это

816
00:48:20,860 --> 00:48:23,100
Нобелевская премия информатики.

817
00:48:23,100 --> 00:48:27,500
>> Так на премию Тьюринга, он должен
дать своей речи.

818
00:48:27,500 --> 00:48:31,790
И он дает этому очень знаменитой речи
сейчас, называется Размышления на доверии

819
00:48:31,790 --> 00:48:35,620
Доверие, которое мы связаны
Чтобы на сайте курса.

820
00:48:35,620 --> 00:48:41,670
И в этой речи, по его словам, все в порядке,
поэтому я написал UNIX, и теперь все

821
00:48:41,670 --> 00:48:43,320
Вы люди используют UNIX.

822
00:48:43,320 --> 00:48:46,960
Теперь, помните, что сегодня Linux является
прямой потомок UNIX.

823
00:48:46,960 --> 00:48:50,140
OS X непосредственно использует UNIX.

824
00:48:50,140 --> 00:48:53,810
Окна не так много, но много
идей были взяты из UNIX.

825
00:48:53,810 --> 00:48:59,220
>> Поэтому он идет на сцену и говорит:
Все в порядке, я написал UNIX.

826
00:48:59,220 --> 00:49:03,940
И только так вы, ребята, знаете, я
возможность войти в каждый

827
00:49:03,940 --> 00:49:05,590
ни одного из ваших компьютеров.

828
00:49:05,590 --> 00:49:14,280
Так как я положил один из них специальным, если х
равна равна Кен Томсон является удивительным,

829
00:49:14,280 --> 00:49:16,350
Затем я позволил для входа.

830
00:49:16,350 --> 00:49:18,370
Таким образом, люди, как, ну,
Как ты это сделал?

831
00:49:18,370 --> 00:49:21,090
Мы смотрели на программы входа
и ничего не есть.

832
00:49:21,090 --> 00:49:24,700
Он, как, ну, я изменил компилятору
, чтобы войти в программу авторизации

833
00:49:24,700 --> 00:49:30,490
так что программа Войти теперь придется
что х равно равно Кен Томпсон

834
00:49:30,490 --> 00:49:31,700
является удивительным.

835
00:49:31,700 --> 00:49:33,120
>> И они говорят, хорошо, что это не так.

836
00:49:33,120 --> 00:49:35,740
Мы смотрим на компилятором, а
компилятор не имеет линии

837
00:49:35,740 --> 00:49:36,400
Код в этом роде.

838
00:49:36,400 --> 00:49:40,540
Он как, в порядке, но то, что вы
компиляции компилятор с?

839
00:49:40,540 --> 00:49:44,810
И они думают, и он, как, ну,
Я тот, кто дал тебе компилятор

840
00:49:44,810 --> 00:49:50,580
вы используете для компиляции компилятор, поэтому
вы компилируете компилятор, что

841
00:49:50,580 --> 00:49:56,390
Сам вредоносным и будет
ломать программы входа в систему.

842
00:49:56,390 --> 00:49:59,360
Так в основном, в этой точке, есть
нет, как вы могли посмотреть на источник

843
00:49:59,360 --> 00:50:02,450
Код программы входа в систему
чтобы увидеть, что это неправильно.

844
00:50:02,450 --> 00:50:04,220
Вы не могли даже смотреть в
исходный код компилятора

845
00:50:04,220 --> 00:50:06,790
чтобы увидеть, что это неправильно.

846
00:50:06,790 --> 00:50:11,940
>> Вы должны были бы смотреть на машины
Код, в двоичном формате из

847
00:50:11,940 --> 00:50:16,760
составлен компилятор, чтобы увидеть, подождите, это
строк кода не должно быть здесь.

848
00:50:16,760 --> 00:50:22,130
Но Кен Томпсон взял еще один шаг
дальше и сказал, ну, есть

849
00:50:22,130 --> 00:50:25,980
эти специальные программы, которые на самом деле
помочь вам читать двоичный программ,

850
00:50:25,980 --> 00:50:29,340
и поэтому, если кто-то использовал эту программу, чтобы
читать двоичный, они увидели бы эти

851
00:50:29,340 --> 00:50:30,490
строк кода.

852
00:50:30,490 --> 00:50:34,020
Он изменил эти программы, чтобы сказать, все
Хорошо, если вы смотрите на

853
00:50:34,020 --> 00:50:38,460
компилятор, не показывают именно этот
набор бинарных.

854
00:50:38,460 --> 00:50:42,830
>> Тогда вы должны принять это шаг
дальше и в принципе, что может иметь

855
00:50:42,830 --> 00:50:46,210
принятые несколько уровней абстракции,
и в какой-то момент, никто не на самом деле

856
00:50:46,210 --> 00:50:47,990
будет проверять.

857
00:50:47,990 --> 00:50:52,590
Таким образом, мораль сей басни такова, что ты
не собираюсь писать

858
00:50:52,590 --> 00:50:54,340
Лязгом в этом классе.

859
00:50:54,340 --> 00:50:57,020
Вы собираетесь использовать восхождение
Лязгом много в этом классе.

860
00:50:57,020 --> 00:51:00,490
Для всех вы знаете, Clang является вредоносной
программа, которая саботирует каждый

861
00:51:00,490 --> 00:51:03,520
одна программа вы когда-либо компиляции.

862
00:51:03,520 --> 00:51:08,206
И, чтобы оставить вас на что очень зловещим
Отметим, увидимся в среду.

863
00:51:08,206 --> 00:51:10,030
>> [Аплодисменты]

864
00:51:10,030 --> 00:51:12,935
>> СПИКЕР 2: На следующем CS50.

865
00:51:12,935 --> 00:51:14,580
>> СПИКЕР 3: Не смей говорить, что.

866
00:51:14,580 --> 00:51:15,930
Вы можете сделать это.

867
00:51:15,930 --> 00:51:19,440
Вы сделали это раньше, вы можете сделать это
сегодня, вы можете сделать это завтра.

868
00:51:19,440 --> 00:51:20,930
Вы делали это в течение многих лет.

869
00:51:20,930 --> 00:51:22,790
Просто пойти туда и сделать это.

870
00:51:22,790 --> 00:51:24,310
Вы можете сделать это.

871
00:51:24,310 --> 00:51:26,102
>> [Музыка играет]