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
>> 因此，我們聲明一個整數數組
所謂的年齡，並有n個

43
00:02:09,430 --> 00:02:12,080
整數此數組中。

44
00:02:12,080 --> 00:02:16,480
因此，這種模式就在這裡，這4整型
i等於0，i小於N，I加

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
所以請記住，n是
我們的長陣。

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
>> 所以請記住，當我們聲明
大小為n的數組，該指數

56
00:03:16,060 --> 00:03:19,950
數組，數組有值和
索引0，1，2，一路

57
00:03:19,950 --> 00:03:21,680
最多n減去1。

58
00:03:21,680 --> 00:03:26,255
因此，當我們說，有三個人
在房間裡，和我們擺在這裡

59
00:03:26,255 --> 00:03:29,850
通過本第一次迭代
循環中，i將是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
那麼在未來一，我們正在進入
第二n用戶輸入，並且在

63
00:03:38,870 --> 00:03:40,580
接下來的兩個，最後n。

64
00:03:40,580 --> 00:03:44,200
>> 所以請注意大小的數組
3沒有什麼

65
00:03:44,200 --> 00:03:46,040
在索引3。

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
>> 所以直到現在，每當你已經
宣告你的main函數，我們已經

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
在這裡，我們稱他們為整型的argc
和字符串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
這樣的argc，那將表明
我們有多少爭論已經

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
所以在這裡，ARGC將三人。

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
因此字符串argv的，我們要看到，
包含字符串，點斜線

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
主要為INT主要作廢。

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
詮釋為主。

114
00:06:20,760 --> 00:06:26,330
而現在，而不是無效的，我要去
指定所謂的argc一個int和一個

115
00:06:26,330 --> 00:06:28,780
數組叫做argv的字符串。

116
00:06:28,780 --> 00:06:31,820
現在，argc和argv是
簡單的約定。

117
00:06:31,820 --> 00:06:34,000
>> 我們可以稱這些論點
大多數我們想要的東西。

118
00:06:34,000 --> 00:06:37,630
但是，什麼是重要的是，是ARGC
一個int，因為按照定義，它是

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
argv的，同時，參數向量，是
會實際上是一個數組存儲

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的百分比s反斜線和逗號。

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
所以我要去指定
argv的支架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
輸入。

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
顯示，如果我們打印的argv 0，使得現在
它是什麼，ARGV 0，點斜線的argv 0。

150
00:08:24,710 --> 00:08:30,440
因此，正如所料，它打印出
該程序的名稱，因為ARGV 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
所以它會打印出整數，1
一二三四一二。

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
>> 所以，你會看到另一個常見模式
是一樣的東西，如果ARGC是少

178
00:10:16,950 --> 00:10:21,100
大於2，表明有不
至少程序名和一

179
00:10:21,100 --> 00:10:29,100
第一個參數，然後我們會做一些事情
如printf，沒有足夠的

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
在這裡，我們從int i等於迭代
0，i是小於的argc，我加

203
00:11:51,210 --> 00:11:55,280
再加上，印刷的argv，索引i。

204
00:11:55,280 --> 00:11:59,300
所以此模式下，再次，這是相同的
圖案和以前一樣，除了代替

205
00:11:59,300 --> 00:12:02,600
調用該變量的
N，我們使用的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
所以請記住，argv是
一個字符串數組。

217
00:12:46,700 --> 00:12:50,960
那麼，什麼是一個字符串，但
字符數組？

218
00:12:50,960 --> 00:12:57,140
這樣就意味著argv是一個真正的
字符數組的數組。

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
>> 因此，如果我們想帶給每個字符
argv的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
s等於argv的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
的條件下，由於n將增加
第每次我們去時的strlen

229
00:13:45,210 --> 00:13:47,720
通過循環，並且它是
不會被改變。

230
00:13:47,720 --> 00:13:50,230
因此，我們將其設置等於n在這裡。

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
所以，如果我們要打印的每個
字符數組，百分比c是

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
因此，我們將有
一個嵌套的for循環。

243
00:14:38,950 --> 00:14:47,480
與以往，第一計數器
是我，接下來的將是J，N

244
00:14:47,480 --> 00:14:54,450
將是我的argv strlen的，我
小於n，我加再加。

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

246
00:14:59,150 --> 00:15:06,870
而不是印刷的argv我和現在，所以
argv的支架我打算指數 - 

247
00:15:06,870 --> 00:15:14,280
這將是第i個命令行
參數，argv的I，J是要

248
00:15:14,280 --> 00:15:16,925
是第j個字符
第i個說法。

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
這樣就相當於字符串s等於
argv的我，和則S支架Ĵ。

252
00:15:33,900 --> 00:15:36,980
>> 好了，我們不需要聲明
這個變量s。

253
00:15:36,980 --> 00:15:44,530
相反，我們就結合這
兩成我們的曾經，的argv 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
環為j，迭代器。

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
得到了一些bug。

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
字符數組，那麼，一個字符串，
所以讓我們說這是我們的字符串s。

297
00:18:18,890 --> 00:18:29,870
所以，如果s是字符串，你好，那麼，
H-E-L-L-O，內存，那將

298
00:18:29,870 --> 00:18:35,610
定，然後將這個反斜杠
0字符。

299
00:18:35,610 --> 00:18:39,170
>> 那麼，如何才能得到s的長度？

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
讓我們來這一手代表的一些
計數器，讓我們稱這個整數長度。

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
>> 因此，實際上執行的是，第一，
我的N長度等於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
因此n長度等於0。

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

324
00:19:46,910 --> 00:19:58,310
所以現在，而S長度不
平等，那麼，反斜線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
就好像，另外，反斜杠
n是一個實際的字符。

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
並同時通過索引的長度s是不
等於空終止，然後

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
所以這是ARGV 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
這個版本的東西沒有
printf的新行之後，但它

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
首先，我們要抓住的argv的strlen的
我，然後我們遍歷

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右
這個for循環？

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

361
00:21:53,740 --> 00:22:07,490
所以，當遍歷ARGV 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
所以，現在，讓這次成為我們的argv。

369
00:22:49,140 --> 00:22:55,290
所以，當我剛剛才跑了程序，
argv是一個字符串數組。

370
00:22:55,290 --> 00:23:03,100
所以，如果我用點斜線的argv運行
2，你好世界，那麼在argv

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
A-R-V的儀表板，需要更多的空間。

377
00:23:30,110 --> 00:23:32,570
讓我們切入這個數組。

378
00:23:32,570 --> 00:23:38,230
A-R-V的儀表板0，然後反斜線0。

379
00:23:38,230 --> 00:23:43,160
然後趁亂會打招呼。

380
00:23:43,160 --> 00:23:45,910
比方說，H-E反斜杠0。

381
00:23:45,910 --> 00:23:51,130
最後，W-O反斜杠0。

382
00:23:51,130 --> 00:23:59,730
>> 所以，我們剛剛編寫的算法，
嵌套的for循環，他們在做什麼

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是做
是，我們的printf的argv 0 0，printf的

391
00:24:46,755 --> 00:24:58,680
argv的0 1，printf的ARGV 0 2 0 3 0 4 0
5，0 6，但現在，argv的0 7即將

392
00:24:58,680 --> 00:25:00,670
等於反斜線0。

393
00:25:00,670 --> 00:25:05,730
>> 於是我們退出了for循環，
現在我遍歷1。

394
00:25:05,730 --> 00:25:10,910
現在我們將要打印
argv的1 0，argv的1 1  - 

395
00:25:10,910 --> 00:25:17,040
好了，現在，因為我砍你好短，
argv的1 2再次將是

396
00:25:17,040 --> 00:25:18,170
反斜杠0。

397
00:25:18,170 --> 00:25:25,050
因此，增加我和繼續，
依此類推，直到我們打印出所有的

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
整數，搶了整數，然後，
隨意，我們有一個while循環，

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
>> 然後我們還有一個while循環
，雖然我不等於0，我們是

418
00:26:42,630 --> 00:26:44,540
要通過3遞減我。

419
00:26:44,540 --> 00:26:49,790
所以，如果你看到錯誤的意圖
在這裡，它是這將減小到我

420
00:26:49,790 --> 00:26:57,010
是10，然後這個while循環的意志
遞減我從10到07到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
第一個while循環。

434
00:27:49,200 --> 00:27:53,155
在這裡，我想一個printf，
我將只打印我。

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

436
00:27:55,670 --> 00:27:58,330
我什至可以做第一個while循環，我。

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

438
00:28:05,130 --> 00:28:09,040
外，第二個while循環。

439
00:28:09,040 --> 00:28:12,170
再次，裡面打印
這裡，i的值。

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
我們看到，我們是無限循環
裡面的第二個while循環。

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
但printf的調試是完全很棒，
但是一旦你的程序得到

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調試器。

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
請注意，這鏘命令是
編譯一切都被傳遞

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，這就是鐺是如何使用它們。

467
00:29:51,500 --> 00:30:00,070
>> 所以請注意，這第一個標誌，破折號
ggdb3，是什麼在說的是，鐺，

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
第一個，你可能會
立即需要的是執行。

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
控制-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
那麼，什麼破手段是，當我
鍵入run，該程序將

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
printf的，輸入一個整數。

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
如果你只是打再次輸入，它會
重做你做的最後一件事。

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
我們看到我們將要遞減我。

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
讓我們來打印我。

522
00:32:58,705 --> 00:33:00,910
它會說，我是11。

523
00:33:00,910 --> 00:33:03,330
現在，我們接著再而
i大於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，因此我們預計
它掉下來的while循環。

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
所以我們只是退出這個while循環，
現在我們已經進入了這個

535
00:33:35,420 --> 00:33:37,080
while循環中，第18行。

536
00:33:37,080 --> 00:33:39,860
因此，雖然我不等於0。

537
00:33:39,860 --> 00:33:46,570
而且，接下來，我等於我減3，我們將
請注意，這將只是繼續前進。

538
00:33:46,570 --> 00:33:48,270
我們可以打印我。

539
00:33:48,270 --> 00:33:49,990
>> 排序的每個命令都有快捷鍵。

540
00:33:49,990 --> 00:33:51,720
因此P是短期的打印。

541
00:33:51,720 --> 00:33:53,400
因此，我們可以p我。

542
00:33:53,400 --> 00:33:57,550
只要繼續保持N，
或者繼續做下一步。

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，這只是
要打印我。

558
00:34:46,210 --> 00:34:51,880
但現在我們調用foo，這是
要我遞減，直到它的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
所以經過這個，printf的輸入
的整數，得到的整數，13。

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

570
00:35:34,180 --> 00:35:37,490
因此，我們要保持遞減
直到i大於10。

571
00:35:37,490 --> 00:35:42,840
那麼我們要落空了
while循環，並獲得了線 - 

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，好，我叫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
我想進入該函數foo，
然後還通過加強

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
之前我們打線富。

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
我們不希望接下來的輸入，因為這
只是調用函數foo，以及

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
我們在這裡看到，現在，我們回到了
這個while循環的，從理論上講，

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
打算從明年有所不同。

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
的問題，那麼我可以只
說，在打破富，而不是。

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
當我鍵入run，這是怎麼回事
停在 - 

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
主要的突破，打破富。

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
函數foo。

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
因為我沒有一個破發點時富，
輸入的整數，那麼現在我

649
00:40:10,050 --> 00:40:11,380
不會打破在foo中。

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
這是一個甜蜜的16出現。

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
>>  - 組合是1。

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
>>  - 因此，組合是1，
兩個，三個，四個，五個。

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
網絡世界，雖然我不能告訴
你最棱鏡的細節。

759
00:44:34,540 --> 00:44:42,130
所以超越棱鏡，我們不會
要談的是，現在

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
Windows中，或任何東西。

774
00:45:36,150 --> 00:45:41,980
>> 所以這不是太大的關注，因為，
我的意思是，這是login程序

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
你不會把任何惡意
如果x等於等於大衛是真棒

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
類似鏘。

790
00:46:34,180 --> 00:46:38,460
那麼，如果誰發生的人
寫鐺專用套管中鏘

791
00:46:38,460 --> 00:46:44,310
是這樣，如果我編譯
登錄程序，然後輸入這個代碼

792
00:46:44,310 --> 00:46:49,720
進入login程序，上面寫著，如果
x等於等於大衛是真棒？

793
00:46:49,720 --> 00:46:59,890
所以不太，但我們有同樣的
問題在這裡，在這裡鏘，好了，

794
00:46:59,890 --> 00:47:03,790
成千上萬，如果不是數以萬計
人，都看著鐺，有

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
>> 但是，什麼是鐺本身一樣，
如果我編譯鐺？

798
00:47:15,780 --> 00:47:20,900
如果我有一些編譯器
編譯鏘說插入到鏘

799
00:47:20,900 --> 00:47:25,610
這個特殊的黑客，說，沒事的，
當我編譯鏘，則

800
00:47:25,610 --> 00:47:31,290
可執行我應該得到特別期待
login程序和插件的內部

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
所以，如果你選擇什麼樣的編譯鏘
用，本身就是惡意的，那麼你

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
幾乎寫道C.所以，你可以
感謝他為這一類。

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
Windows確實沒有那麼多，但很多
想法是從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
自從我把這些特殊的一個如果x
等於等於肯·湯姆森是真棒，

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
我們看著login程序
僅此而已的存在。

832
00:49:21,090 --> 00:49:24,700
他的樣子，好了，我修改了編譯器
登錄login程序

833
00:49:24,700 --> 00:49:30,490
讓login程序現在將有
即x等於等於肯·湯普森

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
login程序代碼
看看什麼是錯的。

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
對於所有你知道的，鐺是一種惡意
程序，它是每一個破壞

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
>> [音樂播放]