1
00:00:00,000 --> 00:00:02,742

2
00:00:02,742 --> 00:00:05,680
>> 揚聲器1：大家好。

3
00:00:05,680 --> 00:00:07,530
我們將開始。

4
00:00:07,530 --> 00:00:09,330
我認為，人們仍然要
是在過濾。

5
00:00:09,330 --> 00:00:12,840
但因為時間的關係，所以我們可以
讓你們離開這裡的時候，

6
00:00:12,840 --> 00:00:14,110
我們將要開始。

7
00:00:14,110 --> 00:00:18,780
所以，歡迎到CS50測驗0條評論。

8
00:00:18,780 --> 00:00:23,020
對於那些你還沒有意識到誰
然而，你必須在週三的問題。

9
00:00:23,020 --> 00:00:25,700
宇豪。

10
00:00:25,700 --> 00:00:29,780
>> 如果你還沒有開始研究，或尚未
還沒有意識到這還不存在，

11
00:00:29,780 --> 00:00:34,070
過去的測驗和有關的所有信息
您的測驗上cs50.net/quizzes。

12
00:00:34,070 --> 00:00:38,090
這裡也有一些不錯的東西放在那裡，
從過去10過去的測驗

13
00:00:38,090 --> 00:00:43,760
年以及信息
有關本測驗和主題

14
00:00:43,760 --> 00:00:46,250
將被覆蓋。

15
00:00:46,250 --> 00:00:48,980
所以，讓我們開始吧。

16
00:00:48,980 --> 00:00:54,240
>> 所以你們可能還記得，第一次
一流的大衛每天對這些燈。

17
00:00:54,240 --> 00:00:59,650
所以基本上，一切都變
就在一台計算機的引擎蓋

18
00:00:59,650 --> 00:01:00,860
二進制進行。

19
00:01:00,860 --> 00:01:04,080
二是指它的聲音是什麼
等，0和1的。

20
00:01:04,080 --> 00:01:09,290
它有兩個值，即
可以被表示。

21
00:01:09,290 --> 00:01:14,675
>> 所以就像在節的第一天
當大衛打開一盞燈

22
00:01:14,675 --> 00:01:21,990
球來表示，或者1，我們的電腦
懂二進制的0和

23
00:01:21,990 --> 00:01:24,110
1的，打開或關閉。

24
00:01:24,110 --> 00:01:25,360
二進制的基礎。

25
00:01:25,360 --> 00:01:29,440

26
00:01:29,440 --> 00:01:32,470
每個地方的代表
在基地2。

27
00:01:32,470 --> 00:01:36,260
所以，你加2到0至
1至2一路上揚。

28
00:01:36,260 --> 00:01:41,970
>> 要計算你的二進制文件是什麼
十進制，你只要按照這個公式

29
00:01:41,970 --> 00:01:42,840
類型的事情。

30
00:01:42,840 --> 00:01:49,510
如果你有一個1在其中任何一個地方，
您可以通過乘以什麼

31
00:01:49,510 --> 00:01:53,820
基地是在加了起來，
你得到的小數點。

32
00:01:53,820 --> 00:01:57,930
因此，這是怎麼算
5二進制。

33
00:01:57,930 --> 00:02:01,400
就像我們在做什麼的
最後一張幻燈片，這是你會如何

34
00:02:01,400 --> 00:02:02,650
代表1到5。

35
00:02:02,650 --> 00:02:05,320

36
00:02:05,320 --> 00:02:09,660
>> 同樣，就像你可以添加和
減去十進制或基10，或

37
00:02:09,660 --> 00:02:13,040
任何真正的基地，就可以添加
並減去二進制。

38
00:02:13,040 --> 00:02:18,400
你會什麼期望時，你
添加兩個起來，如果它等於更大

39
00:02:18,400 --> 00:02:24,220
比1，你隨身攜帶1，使之成為0，
做加法的方式，只是

40
00:02:24,220 --> 00:02:29,910
就像你所期望的定期
小數或任何其它位置。

41
00:02:29,910 --> 00:02:30,970
酷。

42
00:02:30,970 --> 00:02:35,140
>> 所以像我，以前的一切說，
我們的計算機的引擎蓋下繼續

43
00:02:35,140 --> 00:02:37,560
在0和1的，或二進制完成。

44
00:02:37,560 --> 00:02:43,470
那麼，我們如何表達，例如，
字母或數字或字符？

45
00:02:43,470 --> 00:02:45,560
而這個問題的答案是ASCII碼。

46
00:02:45,560 --> 00:02:49,380
>> ASCII是字符之間的映射
我們會在常看到

47
00:02:49,380 --> 00:02:53,360
英語類的A，B的，
C'S，下劃線，破折號和

48
00:02:53,360 --> 00:02:54,910
類似的事情。

49
00:02:54,910 --> 00:02:57,260
它映射了一個ASCII值。

50
00:02:57,260 --> 00:03:03,080
ASCII值僅僅是一個數字，
可以通過你的計算機可以理解。

51
00:03:03,080 --> 00:03:07,430
就這樣，你可以做加法和
減法與數字，你可以做

52
00:03:07,430 --> 00:03:10,890
他們的ASCII值。

53
00:03:10,890 --> 00:03:14,050
>> 所以在本例中，什麼
這將打印出來？

54
00:03:14,050 --> 00:03:26,790

55
00:03:26,790 --> 00:03:35,480
是啊，所以只是一個空間B空間c空間
D.在哪裡我的鼠標去了？

56
00:03:35,480 --> 00:03:39,200

57
00:03:39,200 --> 00:03:43,380
請注意，你可以在65定義為int。

58
00:03:43,380 --> 00:03:47,080
而當你使用打印出來
％的C，它會解釋，作為一個

59
00:03:47,080 --> 00:03:49,330
性格和打印出A。

60
00:03:49,330 --> 00:03:52,800
>> 同樣，你可以聲明
它作為一個字符。

61
00:03:52,800 --> 00:03:56,860
而當你使用百分比打印出來
C，它會解釋，由於

62
00:03:56,860 --> 00:04:05,240
百分之四。就像你可以添加一個
號，可以添加字符

63
00:04:05,240 --> 00:04:06,878
ASCII值，在這種情況下。

64
00:04:06,878 --> 00:04:11,370

65
00:04:11,370 --> 00:04:16,130
>> 那麼一點點的指針為大家。

66
00:04:16,130 --> 00:04:19,610
5，作為一個字符串，不
實際上等於5。

67
00:04:19,610 --> 00:04:26,610
那麼我們如何轉換
串5的整數5？

68
00:04:26,610 --> 00:04:28,930
任何想法？

69
00:04:28,930 --> 00:04:31,630
是啊。

70
00:04:31,630 --> 00:04:36,720
>> 因此，如果我們有5個為一個字符串，
我們可以減去0。

71
00:04:36,720 --> 00:04:37,820
而這將給我們5。

72
00:04:37,820 --> 00:04:41,670
同樣，如果我們有5作為
整數，字符串添加0。

73
00:04:41,670 --> 00:04:43,112
這給予我們的字符串5。

74
00:04:43,112 --> 00:04:46,350

75
00:04:46,350 --> 00:04:48,350
酷。

76
00:04:48,350 --> 00:04:52,940
>> 如今，回想起演講之一，
我們談到的算法。

77
00:04:52,940 --> 00:04:57,260
那麼，如何才能真正想要一台電腦
做有趣的事情？

78
00:04:57,260 --> 00:05:00,460
你知道，只是加減
數字和印刷出來的東西是不是

79
00:05:00,460 --> 00:05:01,730
令人興奮。

80
00:05:01,730 --> 00:05:04,620
通常情況下，我們希望我們的計算機
執行某種算法。

81
00:05:04,620 --> 00:05:07,820
一些更複雜
不僅僅是簡單的算術題。

82
00:05:07,820 --> 00:05:11,930
>> 一個算法就是一步步套
對於如何執行的指令

83
00:05:11,930 --> 00:05:14,640
一定task--

84
00:05:14,640 --> 00:05:15,660
就像一個配方。

85
00:05:15,660 --> 00:05:19,990
你可能還記得第一天
培訓班裡大衛指望我們的房間

86
00:05:19,990 --> 00:05:22,550
人又有多少人
在房間裡。

87
00:05:22,550 --> 00:05:24,480
您可以用來計數
一個接一個。

88
00:05:24,480 --> 00:05:25,860
1，2，3，4。

89
00:05:25,860 --> 00:05:28,010
在這種情況下，一個線性時間算法。

90
00:05:28,010 --> 00:05:31,710
>> 但大衛介紹的算法
你算人在房間裡

91
00:05:31,710 --> 00:05:37,340
每個人都站起來，你說你的
號給他人，添加

92
00:05:37,340 --> 00:05:39,200
號了，一個人坐了下來。

93
00:05:39,200 --> 00:05:40,410
而你再說一遍。

94
00:05:40,410 --> 00:05:42,910
這是一種算法。

95
00:05:42,910 --> 00:05:47,520
我們可以分析一下如何有效的
算法是基於它的運行時間。

96
00:05:47,520 --> 00:05:49,680
但我們會談論一​​點點
稍後詳細說明。

97
00:05:49,680 --> 00:05:52,740

98
00:05:52,740 --> 00:05:57,090
>> 因此，所有的算法也
寫成偽代碼。

99
00:05:57,090 --> 00:06:01,120
偽就像是一個英語
語法用來表示

100
00:06:01,120 --> 00:06:02,420
一種編程語言。

101
00:06:02,420 --> 00:06:06,070
例如，如果我們想問問用戶
猜我最喜歡的數字，我們

102
00:06:06,070 --> 00:06:08,390
可能具有偽代碼本身。

103
00:06:08,390 --> 00:06:09,850
>> 獲取用戶的猜測。

104
00:06:09,850 --> 00:06:13,570
如果猜測是正確的，告訴他們
他們是正確的，別人告訴他們

105
00:06:13,570 --> 00:06:15,560
他們是不正確的。

106
00:06:15,560 --> 00:06:22,530
和偽代碼是很容易的方式
代表一個想法或一種算法。

107
00:06:22,530 --> 00:06:26,910
所以，現在我們可能要實際寫
這在語言的計算機

108
00:06:26,910 --> 00:06:27,980
可能認識。

109
00:06:27,980 --> 00:06:35,660
因此，我們可以寫我們的偽代碼和
理解到這一點的源代碼。

110
00:06:35,660 --> 00:06:41,320
>> 到目前為止，源代碼必須堅持
到了一定的語法

111
00:06:41,320 --> 00:06:42,490
一種編程語言。

112
00:06:42,490 --> 00:06:45,430
到目前為止，在CS50，我們已經
使用大多數是C被。

113
00:06:45,430 --> 00:06:48,320
所以這可能是C語言源代碼。

114
00:06:48,320 --> 00:06:51,440
後來在使用過程中，你晚上來
與其它編程接觸

115
00:06:51,440 --> 00:06:52,480
語言如PHP。

116
00:06:52,480 --> 00:06:57,540
或者，如果你甚至採取其他的類，你
可以做使用Java，Python，甚至OCML。

117
00:06:57,540 --> 00:07:01,570
但是，在我們的C程序語言，這是
我們如何編寫的源代碼

118
00:07:01,570 --> 00:07:04,760
偽代碼算法
我剛才前面所述。

119
00:07:04,760 --> 00:07:08,630

120
00:07:08,630 --> 00:07:11,430
>> 因此，如何真正做你的電腦
明白嗎？

121
00:07:11,430 --> 00:07:14,490
就像我之前，只說真的
理解零和一。

122
00:07:14,490 --> 00:07:17,880
那麼它是怎樣從源頭上得到
代碼的東西，可以

123
00:07:17,880 --> 00:07:18,960
明白？

124
00:07:18,960 --> 00:07:22,920
那麼，我們有什麼
所謂的編譯器。

125
00:07:22,920 --> 00:07:28,450
>> 如果你還記得早在大部分的
pset時，你有一些程序

126
00:07:28,450 --> 00:07:30,370
寫在一個點C文件。

127
00:07:30,370 --> 00:07:32,550
然後，您可以鍵入化妝。

128
00:07:32,550 --> 00:07:35,970
那麼，是什麼讓做什麼？

129
00:07:35,970 --> 00:07:39,970
>> 您可以鍵入make來編譯
計劃，因為someone--

130
00:07:39,970 --> 00:07:42,730
誰寫的p將;
大概David--

131
00:07:42,730 --> 00:07:44,190
創建make文件。

132
00:07:44,190 --> 00:07:51,320
並且告訴make知道你跑
編譯器，叫做鐺，這將

133
00:07:51,320 --> 00:07:55,560
然後編譯源代碼，以反對
代碼，這是零和一

134
00:07:55,560 --> 00:07:57,720
您的計算機理解。

135
00:07:57,720 --> 00:08:01,610
但過了一會兒，我們會去
更深入的了解編譯器。

136
00:08:01,610 --> 00:08:05,640

137
00:08:05,640 --> 00:08:10,800
>> 所以記得PSET 0，where--是，
你有問題嗎？

138
00:08:10,800 --> 00:08:11,620
>> 聽眾：[聽不清]？

139
00:08:11,620 --> 00:08:12,490
>> 揚聲器1：是的。

140
00:08:12,490 --> 00:08:14,960
我覺得他們其實
應該是在網上。

141
00:08:14,960 --> 00:08:15,120
是啊。

142
00:08:15,120 --> 00:08:16,572
>> 聽眾：是不是像[聽不清]？

143
00:08:16,572 --> 00:08:19,476

144
00:08:19,476 --> 00:08:20,830
>> 揚聲器1：不是。

145
00:08:20,830 --> 00:08:25,810
在上cs50.net/quizzes。

146
00:08:25,810 --> 00:08:32,900
>> 聽眾：斜線測驗，削減到2013年，
斜線0，只是通過點擊

147
00:08:32,900 --> 00:08:35,956
競猜2013年和測驗0，
審查部分幻燈片。

148
00:08:35,956 --> 00:08:40,380
>> 揚聲器1：是啊，所以如果你們想
拉了起來，看著它在你的

149
00:08:40,380 --> 00:08:42,740
自己的電腦，那也沒關係。

150
00:08:42,740 --> 00:08:43,130
再說一遍。

151
00:08:43,130 --> 00:08:44,546
>> 聽眾：[聽不清]。

152
00:08:44,546 --> 00:08:48,780
>> 揚聲器1：是啊，[聽不清]
為虛擬變量。

153
00:08:48,780 --> 00:08:49,644
哦，是嗎？

154
00:08:49,644 --> 00:08:51,372
>> 聽眾：[聽不清]？

155
00:08:51,372 --> 00:08:54,300
>> 揚聲器1：沒有，罷工
不在考試。

156
00:08:54,300 --> 00:08:55,950
對不起，她的問題是，為
罷工的考試。

157
00:08:55,950 --> 00:08:59,530
而事實並非如此。

158
00:08:59,530 --> 00:09:05,780
所以PSET 0，你們應該都
使用臨時實施的東西。

159
00:09:05,780 --> 00:09:13,100
我們學到了一些基本的編程
採用從頭構建塊。

160
00:09:13,100 --> 00:09:15,590
>> 因此，讓我們來看看一些
這些積木

161
00:09:15,590 --> 00:09:18,170
組成一個程序。

162
00:09:18,170 --> 00:09:20,570
首先是布爾表達式。

163
00:09:20,570 --> 00:09:24,540
布爾表達式是那些與
0或任何有

164
00:09:24,540 --> 00:09:25,700
兩個可能的值。

165
00:09:25,700 --> 00:09:30,320
在這種情況下，真的還是假的，
開啟或關閉，是或否。

166
00:09:30,320 --> 00:09:35,390
一個簡單的，很簡單的一個例子，
使用布爾程序

167
00:09:35,390 --> 00:09:39,140
表現在這裡。

168
00:09:39,140 --> 00:09:43,220
>> 因此，為了使布爾表達式
是有用的，我們有布爾運算符。

169
00:09:43,220 --> 00:09:48,920
這些操作符可以使用
比較特定值。

170
00:09:48,920 --> 00:09:52,820
因此，我們有和或不等於，小於
大於或等於，大於或

171
00:09:52,820 --> 00:09:55,130
等於和小於
或大於。

172
00:09:55,130 --> 00:09:59,060
但這些運營商並不十分有用
除非我們可以將它們組合成

173
00:09:59,060 --> 00:10:00,320
條件。

174
00:10:00,320 --> 00:10:04,370
>> 所以你們可能還記得從頭
並從p設置我們

175
00:10:04,370 --> 00:10:05,400
有情況。

176
00:10:05,400 --> 00:10:09,710
它們本質上是一樣的叉
你的程序的邏輯

177
00:10:09,710 --> 00:10:12,670
執行取決於是否
一個條件得到滿足。

178
00:10:12,670 --> 00:10:18,150
所以，我們有一個條件
在這個過程中多次使用的是

179
00:10:18,150 --> 00:10:21,470
如果，否則，如果和其他條件。

180
00:10:21,470 --> 00:10:24,060
>> 這裡有一個如何的例子
你可能會使用。

181
00:10:24,060 --> 00:10:28,430
有誰知道之間的區別
if語句都只是用

182
00:10:28,430 --> 00:10:32,530
下節如果，其他的方式，
如果和別人結合起來呢？

183
00:10:32,530 --> 00:10:33,013
是嗎？

184
00:10:33,013 --> 00:10:34,263
>> 聽眾：[聽不清]。

185
00:10:34,263 --> 00:10:40,741

186
00:10:40,741 --> 00:10:42,160
>> 揚聲器1：沒錯。

187
00:10:42,160 --> 00:10:50,210
所以，如果我有，如果沿著這條一路
這樣，即使該狀態下返回

188
00:10:50,210 --> 00:10:52,800
如此，它仍然會繼續
測試下兩個。

189
00:10:52,800 --> 00:11:00,120
然而，與其他人，如果一個else
語句中，如果返回true，

190
00:11:00,120 --> 00:11:02,640
其他人都沒有測試。

191
00:11:02,640 --> 00:11:05,955
關於什麼問題嗎？

192
00:11:05,955 --> 00:11:06,890
酷。

193
00:11:06,890 --> 00:11:12,240
>> 所以，你使用的if-else的其他內容
語句，如果你知道，它只能

194
00:11:12,240 --> 00:11:14,470
是這些案件之一。

195
00:11:14,470 --> 00:11:21,550
因此，我們知道，如果x小於0，它的
絕對不會是

196
00:11:21,550 --> 00:11:22,890
大於0。

197
00:11:22,890 --> 00:11:26,940

198
00:11:26,940 --> 00:11:31,480
>> 接下來，另一個積木
我們學到的循環。

199
00:11:31,480 --> 00:11:33,310
我們有三種類型的循環。

200
00:11:33,310 --> 00:11:35,830
for循環，while循環，
做while循環。

201
00:11:35,830 --> 00:11:38,730
一般，當你坐下來
寫的東西​​，你必須決定

202
00:11:38,730 --> 00:11:40,060
要使用三種。

203
00:11:40,060 --> 00:11:41,900
那麼，我們如何決定哪一個？

204
00:11:41,900 --> 00:11:44,920

205
00:11:44,920 --> 00:11:48,790
>> 我們一般使用for循環，如果我們知道
多少次我們要遍歷

206
00:11:48,790 --> 00:11:53,650
通過什麼或多少次
我們要執行的任務。

207
00:11:53,650 --> 00:11:58,830
我們使用whil​​e循環，如果我們需要一些
條件是真實的，以保持正常運行。

208
00:11:58,830 --> 00:12:03,730
我們用做的，而非常相似，
一段時間，但我們希望我們的代碼在運行

209
00:12:03,730 --> 00:12:04,880
至少一個時間。

210
00:12:04,880 --> 00:12:09,410
>> 所以，做一段時間，無論是在DO線
總是至少運行一次。

211
00:12:09,410 --> 00:12:13,120
然而，隨著時間，它
可能無法運行在所有如

212
00:12:13,120 --> 00:12:15,490
條件不成立。

213
00:12:15,490 --> 00:12:16,740
有任何問題嗎？

214
00:12:16,740 --> 00:12:20,480

215
00:12:20,480 --> 00:12:22,860
>> 因此，一個結構循環。

216
00:12:22,860 --> 00:12:23,620
你們都看到了這一點。

217
00:12:23,620 --> 00:12:25,320
您初始化它。

218
00:12:25,320 --> 00:12:26,600
你有某種條件。

219
00:12:26,600 --> 00:12:32,340
因此，舉例來說，我們可能會初始化
作為i等於0。

220
00:12:32,340 --> 00:12:34,040
i小於10。

221
00:12:34,040 --> 00:12:35,442
我+ +。

222
00:12:35,442 --> 00:12:39,010
很簡單的事，我們所做的一切。

223
00:12:39,010 --> 00:12:42,210
>> 對於一個while循環，同樣的，你有
有某種初始化的，

224
00:12:42,210 --> 00:12:44,980
某種情況下，與
一些更新。

225
00:12:44,980 --> 00:12:51,990
因此，我們可以實現我們的for循環也
作為一個while循環利用這一點。

226
00:12:51,990 --> 00:12:56,000
同樣用do while循環，
我們可能有一些初始化，

227
00:12:56,000 --> 00:12:58,640
執行的東西，更新，和
然後檢查狀態。

228
00:12:58,640 --> 00:13:03,500

229
00:13:03,500 --> 00:13:05,140
>> 所以，現在的功能。

230
00:13:05,140 --> 00:13:06,460
我們把一切融合在一起。

231
00:13:06,460 --> 00:13:10,140
我們可能需要寫一些
種功能。

232
00:13:10,140 --> 00:13:12,790
常見的功能，你可能
看到已經是主要的。

233
00:13:12,790 --> 00:13:13,770
主要是一個函數。

234
00:13:13,770 --> 00:13:16,160
它有一個返回類型，int類型。

235
00:13:16,160 --> 00:13:18,470
它有一個函數名，主。

236
00:13:18,470 --> 00:13:20,810
它有參數，argc和argv。

237
00:13:20,810 --> 00:13:24,040
因此，主要就是一個函數。

238
00:13:24,040 --> 00:13:27,230
>> 你可能已經使用的其他功能，
printf--的printf是一個函數 - 

239
00:13:27,230 --> 00:13:29,330
調用getInt，TOUPPER。

240
00:13:29,330 --> 00:13:32,010
但這些發生在已
實施為我們

241
00:13:32,010 --> 00:13:33,270
一些庫。

242
00:13:33,270 --> 00:13:37,400
如果你們還記得，包括
這CS50.h庫或

243
00:13:37,400 --> 00:13:38,510
標準I / O庫。

244
00:13:38,510 --> 00:13:39,200
是的，問題？

245
00:13:39,200 --> 00:13:41,610
>> 聽眾：主要是用C只是固有的？

246
00:13:41,610 --> 00:13:44,740
難道只是一種[聽不清]嗎？

247
00:13:44,740 --> 00:13:47,370
>> 揚聲器1：現在的問題是
如果主要是內在℃。

248
00:13:47,370 --> 00:13:51,460
是的，所有的功能
有一個主要功能。

249
00:13:51,460 --> 00:13:55,290
這是一種必要的計算機
要知道從哪裡開始

250
00:13:55,290 --> 00:13:55,993
運行代碼。

251
00:13:55,993 --> 00:13:58,108
>> 聽眾：那你會不會[聽不清]？

252
00:13:58,108 --> 00:13:59,480
>> 揚聲器1：第

253
00:13:59,480 --> 00:14:00,760
還有沒有其他問題？

254
00:14:00,760 --> 00:14:03,430

255
00:14:03,430 --> 00:14:04,770
酷。

256
00:14:04,770 --> 00:14:08,050
所以，就像你可以使用一個函數
這是為你寫的，你也可以

257
00:14:08,050 --> 00:14:10,380
編寫自己的功能。

258
00:14:10,380 --> 00:14:17,050
這是一個功能，有人可能
寫來計算容積

259
00:14:17,050 --> 00:14:18,395
一個Q，例如。

260
00:14:18,395 --> 00:14:21,300

261
00:14:21,300 --> 00:14:29,500
有一個返回類型在這裡，在這種情況下，
INT，我們的函數名稱Q和我們

262
00:14:29,500 --> 00:14:31,360
參數列表。

263
00:14:31,360 --> 00:14:34,550
>> 並請注意，您必須寫入數據
要的參數類型

264
00:14:34,550 --> 00:14:38,660
使用，否則該函數不
知道什麼樣的

265
00:14:38,660 --> 00:14:41,650
參數我應該接受。

266
00:14:41,650 --> 00:14:48,110
所以，在這種情況下，我們希望
整數作為我們的輸入。

267
00:14:48,110 --> 00:14:50,390
那麼，為什麼我們要使用的功能呢？

268
00:14:50,390 --> 00:14:52,800
>> 首先，偉大的組織。

269
00:14:52,800 --> 00:14:56,350
他們幫助打破你的代碼
更多的組織塊，使

270
00:14:56,350 --> 00:14:57,960
它更易於閱讀。

271
00:14:57,960 --> 00:14:59,760
簡化。

272
00:14:59,760 --> 00:15:01,740
這是很好的設計。

273
00:15:01,740 --> 00:15:04,570
當你讀一段代碼
而主要功能是真的，

274
00:15:04,570 --> 00:15:07,750
真的很長，它可能是更難
原因是什麼回事。

275
00:15:07,750 --> 00:15:11,710
所以，如果你把它分解成函數，
這可能是更容易閱讀。

276
00:15:11,710 --> 00:15:12,750
和复用能力。

277
00:15:12,750 --> 00:15:16,940
如果你有一個代碼塊，它的被
所謂或運行多次，

278
00:15:16,940 --> 00:15:20,690
而不是重寫代碼的10倍
在主函數中，你可能會

279
00:15:20,690 --> 00:15:21,440
想重新使用它。

280
00:15:21,440 --> 00:15:25,740
然後每次需要使用
一段代碼，調用該函數。

281
00:15:25,740 --> 00:15:30,550

282
00:15:30,550 --> 00:15:35,380
>> 因此，如果我們記得劃傷，
我們也談到了幾個概念，

283
00:15:35,380 --> 00:15:37,680
其中的一個線程。

284
00:15:37,680 --> 00:15:41,120
線程是多的概念
代碼序列

285
00:15:41,120 --> 00:15:43,040
執行在相同的時間。

286
00:15:43,040 --> 00:15:47,490
所以回想起大衛有一天1
你們算過的數

287
00:15:47,490 --> 00:15:48,440
人在房間裡。

288
00:15:48,440 --> 00:15:50,550
>> 從本質上講，是怎麼回事
上都是你們的人

289
00:15:50,550 --> 00:15:52,370
運行單獨的線程。

290
00:15:52,370 --> 00:15:55,540
而這些線程都撞在了一起
得到某種答案。

291
00:15:55,540 --> 00:15:58,890
同樣，在刮，當你有
多精靈，你可能

292
00:15:58,890 --> 00:16:01,070
有一隻貓和一隻狗。

293
00:16:01,070 --> 00:16:08,770
他們會同時
運行自己的腳本。

294
00:16:08,770 --> 00:16:10,020
即穿線的一個例子。

295
00:16:10,020 --> 00:16:12,860

296
00:16:12,860 --> 00:16:18,000
>> 和其他的概念，這是
在從頭開始介紹了事件。

297
00:16:18,000 --> 00:16:22,550
而事件的多個部位時，
與對方你的代碼進行通信。

298
00:16:22,550 --> 00:16:26,840
在划痕，這時候你用的是
廣播控制和我

299
00:16:26,840 --> 00:16:29,500
接收模塊。

300
00:16:29,500 --> 00:16:35,170
>> 而且，在習題集4，我們看到
事件一點點為好。

301
00:16:35,170 --> 00:16:38,250
你們可能已經使用
在GEVENT庫。

302
00:16:38,250 --> 00:16:42,450
並有一個功能waitForClick
在你等待

303
00:16:42,450 --> 00:16:44,300
為用戶點擊。

304
00:16:44,300 --> 00:16:47,870
和你的點擊，在這種情況下，將
該事件並等待點擊是你的

305
00:16:47,870 --> 00:16:49,120
事件處理程序。

306
00:16:49,120 --> 00:16:53,690

307
00:16:53,690 --> 00:16:58,630
>> 而且，在整個運行你的pset
與工作有關的pset時，你

308
00:16:58,630 --> 00:17:01,920
可能接觸到
其中一些命令。

309
00:17:01,920 --> 00:17:05,579
這就是你輸入到您的
終端窗口或其他窗口

310
00:17:05,579 --> 00:17:12,119
這顯示了對你的G編輯，
本質上，瀏覽你的計算機。

311
00:17:12,119 --> 00:17:19,440
>> 因此，例如，ls列出了
一個目錄的內容。

312
00:17:19,440 --> 00:17:22,510
使目錄中創建一個新的文件夾。

313
00:17:22,510 --> 00:17:24,819
CD，改變目錄。

314
00:17:24,819 --> 00:17:28,400
RM，刪除，刪除文件
或者某些目錄。

315
00:17:28,400 --> 00:17:31,050
然後刪除目錄
刪除一個目錄。

316
00:17:31,050 --> 00:17:32,300
>> 聽眾：[聽不清]？

317
00:17:32,300 --> 00:17:36,978

318
00:17:36,978 --> 00:17:38,370
>> 揚聲器1：是的，當然。

319
00:17:38,370 --> 00:17:42,530

320
00:17:42,530 --> 00:17:46,040
不好意思，問題是，如果你
建議把這個

321
00:17:46,040 --> 00:17:48,840
在備忘單。

322
00:17:48,840 --> 00:17:49,440
它可以幫助。

323
00:17:49,440 --> 00:17:51,490
如果你有足夠的空間，你可以把它放在。

324
00:17:51,490 --> 00:17:56,170
它也只是一般夠用了
要記住，因為當你使用它

325
00:17:56,170 --> 00:17:59,060
你可能只想
有它記住。

326
00:17:59,060 --> 00:18:02,750
這會讓你的生活變得更加簡單。

327
00:18:02,750 --> 00:18:04,000
我有沒有回答你的問題？

328
00:18:04,000 --> 00:18:10,528

329
00:18:10,528 --> 00:18:14,290
>> 所以，現在，我們談一點點
簡單說一下庫。

330
00:18:14,290 --> 00:18:18,570
但是，這兩個主要的，我們已經
使用至今在使用過程中有

331
00:18:18,570 --> 00:18:20,860
標準I / O和CS50。

332
00:18:20,860 --> 00:18:25,410
都包括什麼樣的東西
在標準I / O庫？

333
00:18:25,410 --> 00:18:28,410
>> 是的，到目前為止，我們已經使用了printf的。

334
00:18:28,410 --> 00:18:31,150
在CS50，我們使用調用getInt
和GetString。

335
00:18:31,150 --> 00:18:37,200
和數據類型的字符串也恰好
在這CS50庫中聲明。

336
00:18:37,200 --> 00:18:40,250
我們將討論多一點深入了解
圖書館如何工作的，以及他們如何

337
00:18:40,250 --> 00:18:41,870
用你的代碼的其他部分交互。

338
00:18:41,870 --> 00:18:46,220
但就是這兩種主要的是我們
已經走在接觸至今

339
00:18:46,220 --> 00:18:48,430
過程。

340
00:18:48,430 --> 00:18:50,050
>> 類型。

341
00:18:50,050 --> 00:18:58,120
這些都是很好的記住多少
每個類型由或代表如何

342
00:18:58,120 --> 00:19:02,840
許多個字節的每個類型的requires--

343
00:19:02,840 --> 00:19:04,990
INT，4個字節;字符，1個字節。

344
00:19:04,990 --> 00:19:06,550
浮存金是4個字節。

345
00:19:06,550 --> 00:19:07,782
什麼是雙？

346
00:19:07,782 --> 00:19:09,032
>> 聽眾：[聽不清]。

347
00:19:09,032 --> 00:19:11,398

348
00:19:11,398 --> 00:19:16,240
>> 揚聲器1：是啊，所以浮動
但增加一倍的大小。

349
00:19:16,240 --> 00:19:17,150
那麼長？

350
00:19:17,150 --> 00:19:18,400
>> 聽眾：[聽不清]。

351
00:19:18,400 --> 00:19:21,614

352
00:19:21,614 --> 00:19:24,680
>> 揚聲器1：確定。

353
00:19:24,680 --> 00:19:25,410
什麼是多長時間？

354
00:19:25,410 --> 00:19:26,660
>> 聽眾：[聽不清]。

355
00:19:26,660 --> 00:19:29,400

356
00:19:29,400 --> 00:19:31,450
>> 揚聲器1：是的，加倍的詮釋。

357
00:19:31,450 --> 00:19:34,240

358
00:19:34,240 --> 00:19:34,705
是的。

359
00:19:34,705 --> 00:19:36,100
>> 聽眾：[聽不清]。

360
00:19:36,100 --> 00:19:38,030
>> 揚聲器1：長[聽不清]。

361
00:19:38,030 --> 00:19:41,860
然後很長很長的兩倍。

362
00:19:41,860 --> 00:19:42,814
>> 聽眾：沒有，沒有。

363
00:19:42,814 --> 00:19:47,107
長僅僅是一個int。

364
00:19:47,107 --> 00:19:50,910
它依賴於結構
前[聽不清]

365
00:19:50,910 --> 00:19:52,922
及詮釋具有相同的尺寸。

366
00:19:52,922 --> 00:19:54,172
[聽不清]。

367
00:19:54,172 --> 00:19:58,841

368
00:19:58,841 --> 00:20:00,920
>> 揚聲器1：那麼漫長而
int類型是相同的。

369
00:20:00,920 --> 00:20:02,943
再長的長
是雙INT。

370
00:20:02,943 --> 00:20:03,910
酷。

371
00:20:03,910 --> 00:20:05,550
然後，什麼是最後的類型？

372
00:20:05,550 --> 00:20:06,510
>> 聽眾：指針。

373
00:20:06,510 --> 00:20:10,350
>> 揚聲器1：是的，所以我們學會了
約三分一點點。

374
00:20:10,350 --> 00:20:14,015
也不管指針是什麼
指著to--它可能是一個char明星

375
00:20:14,015 --> 00:20:15,880
或int star--

376
00:20:15,880 --> 00:20:20,530
它總是4個字節的指針。

377
00:20:20,530 --> 00:20:21,633
有關該問題？

378
00:20:21,633 --> 00:20:22,116
是嗎？

379
00:20:22,116 --> 00:20:24,531
>> 聽眾：[聽不清]？

380
00:20:24,531 --> 00:20:29,530
>> 揚聲器1：那麼長的和一個int是
同樣在這CS50設備。

381
00:20:29,530 --> 00:20:32,302
>> 聽眾：該設備是完全
互換。

382
00:20:32,302 --> 00:20:33,510
>> 揚聲器1：是啊。

383
00:20:33,510 --> 00:20:36,610
所以後來很長很長的兩倍一個int。

384
00:20:36,610 --> 00:20:39,250
>> 聽眾：這是32位？

385
00:20:39,250 --> 00:20:40,620
>> 揚聲器1：32位，是的。

386
00:20:40,620 --> 00:20:43,572
>> 聽眾：所以[聽不清]？

387
00:20:43,572 --> 00:20:46,790
>> 揚聲器1：是的，如果它不
明確地說，你

388
00:20:46,790 --> 00:20:47,870
應承擔32位。

389
00:20:47,870 --> 00:20:50,040
>> 聽眾：它會說什麼
像假設的

390
00:20:50,040 --> 00:20:51,498
建築類的設備。

391
00:20:51,498 --> 00:20:58,800

392
00:20:58,800 --> 00:21:01,710
對於64位的唯一的事情，
變化是long和指針。

393
00:21:01,710 --> 00:21:05,614
他們都[聽不清]。

394
00:21:05,614 --> 00:21:06,590
>> 揚聲器1：是嗎？

395
00:21:06,590 --> 00:21:07,566
>> 聽眾：問。

396
00:21:07,566 --> 00:21:10,982
因此，在實踐測驗之一，
它詢問一個unsigned int。

397
00:21:10,982 --> 00:21:15,374
因此，如何將是決定
從一個int [聽不清]？

398
00:21:15,374 --> 00:21:18,140
>> 揚聲器1：一個無符號
在同樣4個字節。

399
00:21:18,140 --> 00:21:21,172
但是，什麼是有關簽署不同
int和無符號整型？

400
00:21:21,172 --> 00:21:22,422
>> 聽眾：[聽不清]。

401
00:21:22,422 --> 00:21:24,868

402
00:21:24,868 --> 00:21:25,630
>> 揚聲器1：對。

403
00:21:25,630 --> 00:21:27,570
一個可以代表負值。

404
00:21:27,570 --> 00:21:28,580
但它是如何做到這一點？

405
00:21:28,580 --> 00:21:30,536
>> 聽眾：[聽不清]。

406
00:21:30,536 --> 00:21:36,370
>> 揚聲器1：是啊，這樣可以節省1
位來表示的符號。

407
00:21:36,370 --> 00:21:40,910

408
00:21:40,910 --> 00:21:45,040
簽名的有一位是
代表符號。

409
00:21:45,040 --> 00:21:48,886
和無符號僅僅是全部陽性。

410
00:21:48,886 --> 00:21:50,365
>> 聽眾：確定。

411
00:21:50,365 --> 00:21:54,230
所以，你說，一個是雙
一個浮動的兩倍？

412
00:21:54,230 --> 00:21:58,202
>> 揚聲器1：雙兩倍
一個浮動的大小，是的。

413
00:21:58,202 --> 00:22:01,639
>> 聽眾：如何做一個指針
到長隆[聽不清]？

414
00:22:01,639 --> 00:22:06,058

415
00:22:06,058 --> 00:22:10,870
>> 揚聲器1：所以，問題是怎麼做
指針長long--

416
00:22:10,870 --> 00:22:13,800
怎麼只有4個字節時，
很長很長的8個字節。

417
00:22:13,800 --> 00:22:17,310
所以，記得是一個指針，
本質上，在非常基礎的值。

418
00:22:17,310 --> 00:22:19,046
>> 聽眾：[聽不清]。

419
00:22:19,046 --> 00:22:22,670
>> 揚聲器1：是啊，所以指針
僅僅是一個內存位置。

420
00:22:22,670 --> 00:22:28,040
所以不要緊多少空間
該指針指向。

421
00:22:28,040 --> 00:22:32,060
它僅需要4個字節來跟踪
的內存位置。

422
00:22:32,060 --> 00:22:34,760

423
00:22:34,760 --> 00:22:36,010
還有沒有其他問題？

424
00:22:36,010 --> 00:22:39,800

425
00:22:39,800 --> 00:22:41,050
酷。

426
00:22:41,050 --> 00:22:42,920

427
00:22:42,920 --> 00:22:47,460
>> 所以，過去的事情我有
是標準輸出。

428
00:22:47,460 --> 00:22:51,020
你應該使用它們經常
以至於你能記住。

429
00:22:51,020 --> 00:22:54,800
但是，這是當我們使用
printf的，例如。

430
00:22:54,800 --> 00:22:59,260
而我們這些佔位符
被稱為格式代碼。

431
00:22:59,260 --> 00:23:03,910
>> 所以百分之c char字符，％的I為整數，
而且我們還可以用百分比Ð。

432
00:23:03,910 --> 00:23:05,130
這是同樣的事情。

433
00:23:05,130 --> 00:23:08,200
但是，一般地，在CS50我們
嘗試使用％的I。

434
00:23:08,200 --> 00:23:09,860
百分比的f浮動。

435
00:23:09,860 --> 00:23:15,620
LD百分比長和長
％的S代表字符串。

436
00:23:15,620 --> 00:23:18,550
>> 同樣，我們一直在使用數
這些轉義序列。

437
00:23:18,550 --> 00:23:22,431
例如，反斜杠N代表新的生產線。

438
00:23:22,431 --> 00:23:26,910
這僅僅是當你的格式
你的代碼進行打印F。

439
00:23:26,910 --> 00:23:27,260
是嗎？

440
00:23:27,260 --> 00:23:28,906
>> 聽眾：什麼是百分之D代表？

441
00:23:28,906 --> 00:23:31,850
>> 揚聲器1：所以問題
是什麼％的D代表？

442
00:23:31,850 --> 00:23:33,270
百分比d為為整數。

443
00:23:33,270 --> 00:23:37,392
百分比D和百分之i是相同的。

444
00:23:37,392 --> 00:23:41,130
>> 聽眾：有什麼的區別
反斜杠n和反斜線R'

445
00:23:41,130 --> 00:23:45,300
>> 揚聲器1：所以，問題是有什麼
反彈n和區別

446
00:23:45,300 --> 00:23:48,615
反彈R'

447
00:23:48,615 --> 00:23:50,906
我覺得反斜線Řis--

448
00:23:50,906 --> 00:23:54,340
>> 聽眾：所以反斜線Ř只是意味著
返回到行的開始

449
00:23:54,340 --> 00:23:56,670
沒有實際去一個新的生產線。

450
00:23:56,670 --> 00:24:01,000
所以，如果你打印一個反斜杠r和你
回到該行的開頭

451
00:24:01,000 --> 00:24:04,005
那麼您打印更多的東西，您覆蓋
的東西，這已經在

452
00:24:04,005 --> 00:24:04,390
[聽不清]。

453
00:24:04,390 --> 00:24:06,725
然而，正實際上進入到一個新的
線並進入[聽不清]。

454
00:24:06,725 --> 00:24:10,525

455
00:24:10,525 --> 00:24:13,915
>> 揚聲器1：嗯，沒有其它問題？

456
00:24:13,915 --> 00:24:15,430
好吧。

457
00:24:15,430 --> 00:24:18,617
我將它交給
丹誰將會繼續。

458
00:24:18,617 --> 00:24:25,078
>> [掌聲]

459
00:24:25,078 --> 00:25:08,814

460
00:25:08,814 --> 00:25:09,720
>> DAN：所有用右手。

461
00:25:09,720 --> 00:25:18,590
因此，我將談論另一個廣
來自屬於類思想範圍

462
00:25:18,590 --> 00:25:23,220
大約有代表性兩週和
本週三開始出發

463
00:25:23,220 --> 00:25:28,690
擁有鑄造，這是只是一種方式
治療某些類型的值作為

464
00:25:28,690 --> 00:25:30,830
不同類型的值。

465
00:25:30,830 --> 00:25:34,110
因此，我們可以用字符來做到這一點
整數，浮點數到整數，並

466
00:25:34,110 --> 00:25:35,360
長期多頭增加一倍。

467
00:25:35,360 --> 00:25:38,170

468
00:25:38,170 --> 00:25:44,500
>> 所有這些東西可以作為方法
一種治療某些數值的

469
00:25:44,500 --> 00:25:48,370
減炭一些其他
數值。

470
00:25:48,370 --> 00:25:54,480
因此，有一些問題這一點，
當然，當你投來的

471
00:25:54,480 --> 00:25:57,860
之類的東西浮到整數。

472
00:25:57,860 --> 00:26:00,500
所以這是一個有點怪異。

473
00:26:00,500 --> 00:26:03,170
我們有一個浮動是1.31。

474
00:26:03,170 --> 00:26:05,220
我們10,000相乘。

475
00:26:05,220 --> 00:26:08,380
然後我們將其打印為int。

476
00:26:08,380 --> 00:26:09,630
這是什麼輸出？

477
00:26:09,630 --> 00:26:11,600

478
00:26:11,600 --> 00:26:14,020
10000次1.31。

479
00:26:14,020 --> 00:26:18,761
所以13000，是猜測？

480
00:26:18,761 --> 00:26:20,685
>> 觀眾：我認為這是一萬元。

481
00:26:20,685 --> 00:26:24,234
>> 丹：所以我10,000乘以它
之前我投它。

482
00:26:24,234 --> 00:26:25,202
>> 聽眾：哦。

483
00:26:25,202 --> 00:26:27,622
那豈不是有1個9
有的0號？

484
00:26:27,622 --> 00:26:29,270
>> 丹：你可能有一些奇怪的數字。

485
00:26:29,270 --> 00:26:32,410

486
00:26:32,410 --> 00:26:37,670
所以，正確的，它的1.3倍10,000元。

487
00:26:37,670 --> 00:26:40,040
這就是13000。

488
00:26:40,040 --> 00:26:41,313
而這額外的weird--

489
00:26:41,313 --> 00:26:42,160
>> 聽眾：13,100。

490
00:26:42,160 --> 00:26:42,650
>> DAN：13,100。

491
00:26:42,650 --> 00:26:44,910
謝謝，羅布。

492
00:26:44,910 --> 00:26:46,610
而這額外的weirdness--

493
00:26:46,610 --> 00:26:48,060
這9,9--

494
00:26:48,060 --> 00:26:53,860
很簡單，因為這件
結束了向下舍入其中

495
00:26:53,860 --> 00:26:55,394
它不應該有。

496
00:26:55,394 --> 00:26:55,871
是啊。

497
00:26:55,871 --> 00:26:58,256
>> 聽眾：鑄件發生
以後別的什麼嗎？

498
00:26:58,256 --> 00:27:03,865
>> 丹：是因為我有這樣的，印刷的，它
做這個乘法之前

499
00:27:03,865 --> 00:27:05,230
這是否鑄造。

500
00:27:05,230 --> 00:27:06,140
>> 聽眾：[聽不清]。

501
00:27:06,140 --> 00:27:11,350
>> 丹：我想會先投，
是的，這將是10,000元。

502
00:27:11,350 --> 00:27:12,610
還要別的嗎？

503
00:27:12,610 --> 00:27:13,330
酷。

504
00:27:13,330 --> 00:27:16,344
因此，這是13099。

505
00:27:16,344 --> 00:27:17,840
為什麼會這樣？

506
00:27:17,840 --> 00:27:18,900
不精確。

507
00:27:18,900 --> 00:27:21,020
>> 花車是不完美的。

508
00:27:21,020 --> 00:27:27,550
他們只能代表數字一
若干顯著數字。

509
00:27:27,550 --> 00:27:35,120
因此，如果我們在打印出8 SIG的無花果
這個浮球，我們得到了一種

510
00:27:35,120 --> 00:27:36,800
難看的數字。

511
00:27:36,800 --> 00:27:45,580
那是因為1.31不能準確
可以通過簡單的表示

512
00:27:45,580 --> 00:27:49,000
兩個機器的權力。

513
00:27:49,000 --> 00:27:53,530
所以，它最終以最接近
猜，這結束了

514
00:27:53,530 --> 00:27:55,710
是有點低。

515
00:27:55,710 --> 00:27:57,730
有意義嗎？

516
00:27:57,730 --> 00:27:59,110
行。

517
00:27:59,110 --> 00:28:05,840
>> 現在，切換為不同的方式
這樣做的條件語句，所有

518
00:28:05,840 --> 00:28:09,900
我們關心的是一個單一的變量。

519
00:28:09,900 --> 00:28:16,570
所以在這個特定的例子中，我們
獲取來自用戶的整數。

520
00:28:16,570 --> 00:28:21,070
然後，我們正在尋找
什麼是整數。

521
00:28:21,070 --> 00:28:23,500
據推測，它的數量
與第一和第四。

522
00:28:23,500 --> 00:28:24,800
這就是我們要求的。

523
00:28:24,800 --> 00:28:28,450
>> 所以，你要做的開關
變量名稱。

524
00:28:28,450 --> 00:28:34,290
然後你建立可能的案件
值可能有關係。

525
00:28:34,290 --> 00:28:37,730
所以，案例一，說這是低的。

526
00:28:37,730 --> 00:28:41,080
然後你打破脫身
的開關狀態，以便

527
00:28:41,080 --> 00:28:43,270
你不繼續下去。

528
00:28:43,270 --> 00:28:44,830
>> 在接下來的case--

529
00:28:44,830 --> 00:28:46,940
所以案例二和案例three--

530
00:28:46,940 --> 00:28:51,920
如果是情況2，它只是下降到
代碼的第一行就認為與

531
00:28:51,920 --> 00:28:55,400
案例三，直到看到一個突破。

532
00:28:55,400 --> 00:29:00,430
因此原因，你得到的情況下一個
僅打印低是因為我

533
00:29:00,430 --> 00:29:01,890
這裡有這樣的突破。

534
00:29:01,890 --> 00:29:05,360
如果我說，忽略了這個break--
如果我把這個breakaway--

535
00:29:05,360 --> 00:29:09,740
它將打印低，然後它會
打印中，然後它會斷裂。

536
00:29:09,740 --> 00:29:12,200
>> 所以休息時間是一個重要的組成部分
開關條件和

537
00:29:12,200 --> 00:29:14,340
他們應該在那裡。

538
00:29:14,340 --> 00:29:20,070
未明確規定的個案
由默認處理

539
00:29:20,070 --> 00:29:26,645
案例中的開關，應投。

540
00:29:26,645 --> 00:29:31,363
>> 聽眾：那1，2，3，
4為N？

541
00:29:31,363 --> 00:29:33,310
>> DAN：價值是n即可。

542
00:29:33,310 --> 00:29:34,654
是的。

543
00:29:34,654 --> 00:29:35,146
是嗎？

544
00:29:35,146 --> 00:29:37,606
>> 聽眾：所以當你有
在[聽不清]？

545
00:29:37,606 --> 00:29:44,002

546
00:29:44,002 --> 00:29:46,830
>> 丹：你將打印低，然後
它將打印中間，並

547
00:29:46,830 --> 00:29:47,400
那麼它會打破。

548
00:29:47,400 --> 00:29:50,244
>> 聽眾：為什麼會打印
中間如果[聽不清]？

549
00:29:50,244 --> 00:29:54,036

550
00:29:54,036 --> 00:30:00,550
>> 丹：所以根據案件的一切
前下破下降。

551
00:30:00,550 --> 00:30:09,390
因此，案件一個打印是下面情況
一個作為這列打印。

552
00:30:09,390 --> 00:30:09,890
是嗎？

553
00:30:09,890 --> 00:30:11,140
>> 聽眾：[聽不清]？

554
00:30:11,140 --> 00:30:15,890

555
00:30:15,890 --> 00:30:22,170
>> 丹：所以這個數字僅僅是一個特定的
值，該變量

556
00:30:22,170 --> 00:30:23,420
可以了吧？

557
00:30:23,420 --> 00:30:26,740

558
00:30:26,740 --> 00:30:28,490
這是否有道理？

559
00:30:28,490 --> 00:30:28,990
是啊。

560
00:30:28,990 --> 00:30:31,490
>> 聽眾：[聽不清]？

561
00:30:31,490 --> 00:30:34,130
>> 丹：是的，案例2將打印
中間再突破。

562
00:30:34,130 --> 00:30:35,380
>> 聽眾：[聽不清]？

563
00:30:35,380 --> 00:30:37,954

564
00:30:37,954 --> 00:30:40,050
>> 丹：我覺得任何？

565
00:30:40,050 --> 00:30:43,855
還有什麼其他的數據類型
你能切換？

566
00:30:43,855 --> 00:30:46,320
>> 聽眾：您可以切換
以上的任何數據類型。

567
00:30:46,320 --> 00:30:50,905
但它只是意味著任何超過個字符
和整數之類的東西，因為

568
00:30:50,905 --> 00:30:55,600
如果你切換指針
這並沒有真正意義，

569
00:30:55,600 --> 00:30:59,555
切換負載，如果它甚至讓我們
你這樣做，因為浮點說，

570
00:30:59,555 --> 00:31:02,840
在精確度，你不會真的
要做到這一點呢。

571
00:31:02,840 --> 00:31:07,320
這麼漂亮多了，只是整數和
字符之類的東西。

572
00:31:07,320 --> 00:31:12,360
>> 丹：是的，這是當你有明確的
值，你知道，我認為，可以

573
00:31:12,360 --> 00:31:14,250
一個開關實際上是有用的。

574
00:31:14,250 --> 00:31:17,094

575
00:31:17,094 --> 00:31:18,990
好不好？

576
00:31:18,990 --> 00:31:21,370
行。

577
00:31:21,370 --> 00:31:26,180
>> 範圍是聲明的範圍
可變的延伸。

578
00:31:26,180 --> 00:31:32,190
因此，在這個代碼塊小我，
這將是完全錯誤的。

579
00:31:32,190 --> 00:31:41,450
而原因就是我聲明此詮釋
這個範圍的循環中島

580
00:31:41,450 --> 00:31:46,390
然後我試圖引用
I的，對循環範圍之內。

581
00:31:46,390 --> 00:31:50,330
>> 所以基本上，你可以考慮一下範圍
如任何聲明

582
00:31:50,330 --> 00:31:59,750
用大括號內只
存在這些大括號內。

583
00:31:59,750 --> 00:32:04,990
如果你嘗試使用該變量
這些大括號外面，你會

584
00:32:04,990 --> 00:32:08,356
獲得來自編譯器的錯誤。

585
00:32:08,356 --> 00:32:08,812
是嗎？

586
00:32:08,812 --> 00:32:09,724
>> 聽眾：所以這個也不行？

587
00:32:09,724 --> 00:32:11,790
>> 丹：這是不行的，肯定的。

588
00:32:11,790 --> 00:32:17,190

589
00:32:17,190 --> 00:32:18,660
字符串。

590
00:32:18,660 --> 00:32:19,780
串一個char *。

591
00:32:19,780 --> 00:32:22,250
他們是完全一樣的。

592
00:32:22,250 --> 00:32:25,540
他們只是指向字符。

593
00:32:25,540 --> 00:32:33,000
那您有任何字符串應該結束
用反斜杠零，這就是

594
00:32:33,000 --> 00:32:34,410
一個C約定。

595
00:32:34,410 --> 00:32:36,680
>> 這就是所謂的NULL結束。

596
00:32:36,680 --> 00:32:39,050
和NULL--

597
00:32:39,050 --> 00:32:41,670
資本氮，大寫的U，資本
L，資本L--

598
00:32:41,670 --> 00:32:44,290
是不一樣的
NULL結束。

599
00:32:44,290 --> 00:32:46,640
這是一個指針。

600
00:32:46,640 --> 00:32:48,280
這是一個字符。

601
00:32:48,280 --> 00:32:49,530
他們是非常不同的。

602
00:32:49,530 --> 00:32:50,200
記住它。

603
00:32:50,200 --> 00:32:52,320
這將是對測驗，大概。

604
00:32:52,320 --> 00:32:54,040
我還沒有看到測驗。

605
00:32:54,040 --> 00:32:57,880

606
00:32:57,880 --> 00:32:58,840
是嗎？

607
00:32:58,840 --> 00:33:01,232
>> 聽眾：那空是，比如說，指針？

608
00:33:01,232 --> 00:33:01,995
>> 丹：是的。

609
00:33:01,995 --> 00:33:05,170
>> 聽眾：是什麼[聽不清]？

610
00:33:05,170 --> 00:33:10,050
>> 丹：如果說，malloc的調用，當你
沒有足夠的內存來獲得

611
00:33:10,050 --> 00:33:14,400
無論你要求的尺寸，
malloc的返回NULL。

612
00:33:14,400 --> 00:33:19,550
這是，基本上，每當一個函數
應該返回一個指針，你

613
00:33:19,550 --> 00:33:22,600
需要核對NULL，因為
null是一個漂亮的good--

614
00:33:22,600 --> 00:33:25,260
這是，排序，垃圾的價值。

615
00:33:25,260 --> 00:33:27,050
這是一個零盡可能指針走。

616
00:33:27,050 --> 00:33:29,630

617
00:33:29,630 --> 00:33:32,250
>> 當你調用一個函數，
返回一個指針。

618
00:33:32,250 --> 00:33:35,960
你會想要檢查是
確保該指針不為NULL

619
00:33:35,960 --> 00:33:37,760
因為空是很常見的。

620
00:33:37,760 --> 00:33:40,160
這有點垃圾的回報。

621
00:33:40,160 --> 00:33:44,902
所以，如果事情沒有去正確的，
剛剛返回NULL來代替。

622
00:33:44,902 --> 00:33:45,898
>> 聽眾：[聽不清]？

623
00:33:45,898 --> 00:33:48,922
>> 丹：是的，這就是這個。

624
00:33:48,922 --> 00:33:51,750
>> 聽眾：[聽不清]？

625
00:33:51,750 --> 00:33:52,800
>> DAN：拼寫它，因為這。

626
00:33:52,800 --> 00:33:54,150
這是NULL結束。

627
00:33:54,150 --> 00:33:56,560
這是小寫的n-U-L-L，如果
你拼了。

628
00:33:56,560 --> 00:33:59,860
>> 聽眾：我剛去
背部和測試它。

629
00:33:59,860 --> 00:34:03,010
如果你試圖把一個浮點
值轉換開關，它會罵你

630
00:34:03,010 --> 00:34:05,916
他說，聲明需要表達
的整數類型。

631
00:34:05,916 --> 00:34:07,166
>> 丹：你去那裡。

632
00:34:07,166 --> 00:34:09,639

633
00:34:09,639 --> 00:34:12,246
但是，是的，究竟是什麼問題又來了？

634
00:34:12,246 --> 00:34:13,496
>> 聽眾：[聽不清]？

635
00:34:13,496 --> 00:34:16,150

636
00:34:16,150 --> 00:34:23,679
>> 丹：所以資本氮，大寫的U，資本
L，資本，L是一個實際的C件事。

637
00:34:23,679 --> 00:34:29,719
這是空指針和意志
只有這樣看待。

638
00:34:29,719 --> 00:34:33,530
你永遠不會嘗試拼
NULL字符和看到任何

639
00:34:33,530 --> 00:34:35,630
除此之外的方法。

640
00:34:35,630 --> 00:34:36,610
是嗎？

641
00:34:36,610 --> 00:34:42,490
>> 聽眾：所以回國為char或最大
東西在音符，將它

642
00:34:42,490 --> 00:34:43,960
體現了相同的功能
為[聽不清]？

643
00:34:43,960 --> 00:34:50,655

644
00:34:50,655 --> 00:34:54,949
>> 聽眾：所以你指的是
從getchar函數返回的字符最大，或

645
00:34:54,949 --> 00:34:55,444
不管它是什麼？

646
00:34:55,444 --> 00:34:55,940
>> 聽眾：是的。

647
00:34:55,940 --> 00:34:58,620
>> 聽眾：是啊，所以一般
長期為所有這些事情

648
00:34:58,620 --> 00:34:59,920
是定點值。

649
00:34:59,920 --> 00:35:03,640
因此，像從調用getInt返回int最大
從getchar函數字符最大，它的

650
00:35:03,640 --> 00:35:06,010
應該是這樣，那好吧，如果
這些東西都返回給我們，

651
00:35:06,010 --> 00:35:07,210
出事了。

652
00:35:07,210 --> 00:35:09,950
>> 為指針，我們只是碰巧有
該標記值，每個人都

653
00:35:09,950 --> 00:35:10,750
同意後。

654
00:35:10,750 --> 00:35:13,210
這就是你回來的東西
當事情出錯。

655
00:35:13,210 --> 00:35:15,910
因此，焦炭max是我們正在使用的是什麼
代表什麼

656
00:35:15,910 --> 00:35:18,100
如NULL或的getchar。

657
00:35:18,100 --> 00:35:23,420
>> 聽眾：所以，如果你正在測試的getchar，
可能你只是把空？

658
00:35:23,420 --> 00:35:23,910
會有所作為？

659
00:35:23,910 --> 00:35:25,400
>> 丹：你不能只檢查空。

660
00:35:25,400 --> 00:35:30,130
你必須檢查字符最大，因為
從函數返回值是

661
00:35:30,130 --> 00:35:35,416
一個字符不是一個指針。

662
00:35:35,416 --> 00:35:35,888
是嗎？

663
00:35:35,888 --> 00:35:38,248
>> 聽眾：這個問題問
字符串長度。

664
00:35:38,248 --> 00:35:40,136
這是否包括NULL字符？

665
00:35:40,136 --> 00:35:41,000
>> 丹：沒有。

666
00:35:41,000 --> 00:35:45,930
而這實際上是字符串的長度如何
知道要停止，因為它通過

667
00:35:45,930 --> 00:35:49,070
您的字符數組，直到
它看到一個空字符。

668
00:35:49,070 --> 00:35:51,030
然後，它像所有
沒錯，我完成了。

669
00:35:51,030 --> 00:35:52,130
>> 聽眾：[聽不清] 5？

670
00:35:52,130 --> 00:35:53,990
>> 丹：你好是5。

671
00:35:53,990 --> 00:35:55,240
是的。

672
00:35:55,240 --> 00:35:59,580

673
00:35:59,580 --> 00:36:02,880
所以數組是連續
的存儲器塊。

674
00:36:02,880 --> 00:36:08,480
他們可以即時訪問說的
數組的名字，然後，在大

675
00:36:08,480 --> 00:36:16,720
牙套，不管指數你想要去
到，他們是從零到索引

676
00:36:16,720 --> 00:36:20,100
減去1的陣列的長度。

677
00:36:20,100 --> 00:36:23,070
>> 他們正在用的類型聲明
那你存儲的東西

678
00:36:23,070 --> 00:36:29,750
陣列，該陣列的名稱，然後
無論大小是數組。

679
00:36:29,750 --> 00:36:36,660
因此，這是長度的字符數組
6有這些值。

680
00:36:36,660 --> 00:36:42,050

681
00:36:42,050 --> 00:36:42,700
是嗎？

682
00:36:42,700 --> 00:36:43,950
>> 聽眾：[聽不清]？

683
00:36:43,950 --> 00:36:47,980

684
00:36:47,980 --> 00:36:48,460
>> 丹：是的。

685
00:36:48,460 --> 00:36:51,340
>> 聽眾：[聽不清]？

686
00:36:51,340 --> 00:36:56,700
>> 丹：如果你有什麼事
入陣已經作出。

687
00:36:56,700 --> 00:37:02,260
所以，你可以指定，而不是以此為，
比如說，焦炭，無論名稱的

688
00:37:02,260 --> 00:37:12,200
數組是空的方括號等於花
振奮ħ逗號ê逗號Ł逗號Ł逗號

689
00:37:12,200 --> 00:37:16,290
Ø逗號NULL字符
和大括號。

690
00:37:16,290 --> 00:37:18,180
這也將作為一個聲明。

691
00:37:18,180 --> 00:37:20,886
>> 聽眾：[聽不清]？

692
00:37:20,886 --> 00:37:23,110
>> DAN：然後，你需要有
規模已經作出。

693
00:37:23,110 --> 00:37:23,896
>> 聽眾：[聽不清]？

694
00:37:23,896 --> 00:37:25,146
>> 丹：是的。

695
00:37:25,146 --> 00:37:30,114

696
00:37:30,114 --> 00:37:32,420
所有用右手。

697
00:37:32,420 --> 00:37:36,430
命令行參數的方法
從用戶為獲得輸入

698
00:37:36,430 --> 00:37:39,380
參數為主。

699
00:37:39,380 --> 00:37:40,600
主要有兩個參數。

700
00:37:40,600 --> 00:37:47,680
爭論正被數
沿著命令行和傳遞

701
00:37:47,680 --> 00:37:55,340
串載體或一個字符串數組
所有的參數。

702
00:37:55,340 --> 00:38:07,840
>> 所以，如果我說，所謂的功能，如
點了1個空格，2的空間，3，

703
00:38:07,840 --> 00:38:10,110
ARGC是4。

704
00:38:10,110 --> 00:38:17,370
而在argv 0將是一個點了。

705
00:38:17,370 --> 00:38:19,130
Argv1將是1。

706
00:38:19,130 --> 00:38:23,030
argv2將2 argv3會
3，在特定的情況下。

707
00:38:23,030 --> 00:38:23,310
是嗎？

708
00:38:23,310 --> 00:38:25,400
>> 聽眾：[聽不清]？

709
00:38:25,400 --> 00:38:34,010
>> DAN：數組中的最後一個元素
因為數組長度的argc加

710
00:38:34,010 --> 00:38:41,050
1 ARGB的，最後一個元件
是NULL指針。

711
00:38:41,050 --> 00:38:42,580
它的argc加1。

712
00:38:42,580 --> 00:38:46,210

713
00:38:46,210 --> 00:38:52,150
所以，我剛才說了，它的情況下，
會做argv 0點了。

714
00:38:52,150 --> 00:38:56,330
ARGV 1是1 argv2是2的argv 3 3。

715
00:38:56,330 --> 00:39:03,490
的argv 4，它是一個容量較大的
比的argc將是NULL。

716
00:39:03,490 --> 00:39:04,870
>> 這就是NULL指針。

717
00:39:04,870 --> 00:39:06,590
是的。

718
00:39:06,590 --> 00:39:11,250
那是因為字符串
一個char星是一個指針。

719
00:39:11,250 --> 00:39:14,102
所以它必須是相同的類型。

720
00:39:14,102 --> 00:39:14,595
是嗎？

721
00:39:14,595 --> 00:39:16,074
>> 聽眾：兩個問題。

722
00:39:16,074 --> 00:39:21,004
所以一，什麼是之間的區別
這和GetString超過一種類型的其他

723
00:39:21,004 --> 00:39:22,483
在用戶發動機？

724
00:39:22,483 --> 00:39:25,934
其二，它是存儲在
您最近的記憶？

725
00:39:25,934 --> 00:39:28,399
所以像，GetString的會
是[聽不清]？

726
00:39:28,399 --> 00:39:31,357

727
00:39:31,357 --> 00:39:33,650
>> DAN：它在哪裡存放？

728
00:39:33,650 --> 00:39:34,905
我不知道它的存儲。

729
00:39:34,905 --> 00:39:40,000
>> 聽眾：所以，其實，你知道如何任何
函數調用它的參數

730
00:39:40,000 --> 00:39:42,170
被存儲在棧？

731
00:39:42,170 --> 00:39:46,610
所以argc和argv是參數主要
他們是在棧上，還是真的

732
00:39:46,610 --> 00:39:49,131
只是上面的你在想什麼的
堆棧的開始。

733
00:39:49,131 --> 00:39:53,490
什麼是另一部
的問題嗎？

734
00:39:53,490 --> 00:39:56,821
>> 聽眾：那麼什麼是[聽不清]？

735
00:39:56,821 --> 00:40:00,990
>> 丹：是的，它只是用不同的方式
的獲取來自用戶的輸入。

736
00:40:00,990 --> 00:40:06,030
這一次的稍微更高效，
這是順手的腳本，因為你

737
00:40:06,030 --> 00:40:10,070
只需將參數傳遞到您的主
功能，而不必等待

738
00:40:10,070 --> 00:40:13,400
對於用戶，如果你沒有任何用戶。

739
00:40:13,400 --> 00:40:16,280
>> 聽。是啊，弄弦
將[聽不清]。

740
00:40:16,280 --> 00:40:17,922
它會存儲你所需要的東西。

741
00:40:17,922 --> 00:40:18,834
>> 丹：是嗎？

742
00:40:18,834 --> 00:40:21,114
>> 聽眾：[聽不清]？

743
00:40:21,114 --> 00:40:27,545
>> 丹：是的，argv的0總是包括
點斜線函數調用。

744
00:40:27,545 --> 00:40:28,042
是嗎？

745
00:40:28,042 --> 00:40:29,292
>> 聽眾：[聽不清]？

746
00:40:29,292 --> 00:40:33,509

747
00:40:33,509 --> 00:40:37,310
>> 丹：是的，每個參數都
在NULL字符結束，因為他們

748
00:40:37,310 --> 00:40:38,310
都是字符串。

749
00:40:38,310 --> 00:40:40,892
>> 聽眾：[聽不清]？

750
00:40:40,892 --> 00:40:44,116
>> 丹：是的，argv中的argc是一個NULL指針。

751
00:40:44,116 --> 00:40:45,112
>> 聽眾：[聽不清]？

752
00:40:45,112 --> 00:40:47,104
>> 丹：哦，是的。

753
00:40:47,104 --> 00:40:48,100
是啊，對不起。

754
00:40:48,100 --> 00:40:49,594
>> 聽眾：所以[聽不清]？

755
00:40:49,594 --> 00:41:08,518

756
00:41:08,518 --> 00:41:16,340
>> 丹：所以現在的問題是，如果你有
命令行點斜線點了1，2，

757
00:41:16,340 --> 00:41:20,410
會命令行的數量
論據有兩個或會是3？

758
00:41:20,410 --> 00:41:24,420

759
00:41:24,420 --> 00:41:28,240
>> 觀眾：我覺得它不
真正的問題。

760
00:41:28,240 --> 00:41:31,370
我傾向於說，哦，你沒有通過
當任何命令行參數，

761
00:41:31,370 --> 00:41:32,730
很明顯，你調用的函數。

762
00:41:32,730 --> 00:41:37,950
所以，我傾向於用聲音排除
在命令行功能

763
00:41:37,950 --> 00:41:40,350
即使它的參數
包括argv中。

764
00:41:40,350 --> 00:41:42,600
>> DAN：但如果是在test--

765
00:41:42,600 --> 00:41:46,550
yeah--而且如果你說的東西
喜歡的argc等於3，

766
00:41:46,550 --> 00:41:48,512
你在安全的地位。

767
00:41:48,512 --> 00:41:49,416
是嗎？

768
00:41:49,416 --> 00:41:50,666
>> 聽眾：[聽不清]？

769
00:41:50,666 --> 00:42:00,990

770
00:42:00,990 --> 00:42:09,510
>> 丹：我認為，如果不調用此
在argc和argv的字符串括號

771
00:42:09,510 --> 00:42:14,350
但保留了相同的類型，只是叫
不同的像他們的東西

772
00:42:14,350 --> 00:42:16,640
和b，是否仍然有效？

773
00:42:16,640 --> 00:42:18,790
它仍然正常工作，
你只是 - 

774
00:42:18,790 --> 00:42:21,520
代替使用argc--
你會用A和B。

775
00:42:21,520 --> 00:42:24,436

776
00:42:24,436 --> 00:42:25,408
是嗎？

777
00:42:25,408 --> 00:42:26,658
>> 聽眾：[聽不清]？

778
00:42:26,658 --> 00:42:34,642

779
00:42:34,642 --> 00:42:38,850
>> 丹：所以，問題是GetString的是
將存儲存儲器中的堆

780
00:42:38,850 --> 00:42:42,280
因為GetString的為char *。

781
00:42:42,280 --> 00:42:47,530
它在人堆裡，因為它存儲內存
現在要求在實際的malloc

782
00:42:47,530 --> 00:42:49,258
實施的GetString的。

783
00:42:49,258 --> 00:42:53,210

784
00:42:53,210 --> 00:42:55,090
好了，繼續前進。

785
00:42:55,090 --> 00:42:55,950
>> 安全。

786
00:42:55,950 --> 00:43:01,090
因此，要實現真正的安全，你靠不
1，你不許任何人進入任何

787
00:43:01,090 --> 00:43:04,540
您的信息，這是為什麼
每個人都建立自己的機器，

788
00:43:04,540 --> 00:43:09,580
自己的操作系統，其所有
從頭開始計劃，顯然

789
00:43:09,580 --> 00:43:13,410
不要連接到任何其他機器
通過互聯網。

790
00:43:13,410 --> 00:43:17,350
所以，電腦是不安全的。

791
00:43:17,350 --> 00:43:19,200
他們真的是。

792
00:43:19,200 --> 00:43:20,940
我們必須相信其他人。

793
00:43:20,940 --> 00:43:26,500
>> 和安全的想法是，你
試圖限制的量

794
00:43:26,500 --> 00:43:27,540
你需要信任。

795
00:43:27,540 --> 00:43:32,080
而你做到這一點的方法之一
就是通過加密。

796
00:43:32,080 --> 00:43:34,950
密碼學是，本質上，
我們有秘密。

797
00:43:34,950 --> 00:43:38,880
>> 有時候，我們必須通過我們的秘密
沿著通過，比方說，因特網或

798
00:43:38,880 --> 00:43:39,980
其他事情。

799
00:43:39,980 --> 00:43:43,180
我們不希望人們
要知道這些秘密。

800
00:43:43,180 --> 00:43:50,100
所以我們我們的秘密加密成一個方法
我們希望沒有人能搞清楚。

801
00:43:50,100 --> 00:43:51,600
>> 因此，我們used--

802
00:43:51,600 --> 00:43:54,340
通過這個類別 - 的過程中

803
00:43:54,340 --> 00:44:00,750
事情像愷撒密碼和
[聽不清]，這兩者都是非常

804
00:44:00,750 --> 00:44:03,200
加密的東西不安全的方式。

805
00:44:03,200 --> 00:44:07,930
他們很容易找出他們
是和你的秘密是。

806
00:44:07,930 --> 00:44:12,130
現實世界中使用的多
複雜的加密方案。

807
00:44:12,130 --> 00:44:13,880
我們不會進入
不止於此。

808
00:44:13,880 --> 00:44:18,280

809
00:44:18,280 --> 00:44:19,430
>> 調試。

810
00:44:19,430 --> 00:44:20,785
GDB是最好的。

811
00:44:20,785 --> 00:44:24,014

812
00:44:24,014 --> 00:44:25,810
我要再次強調這一點。

813
00:44:25,810 --> 00:44:30,920
用GDB所有的時間每
時間你有問題。

814
00:44:30,920 --> 00:44:36,030
命令，在廣發行是有用的
打破，你通過其中一條線

815
00:44:36,030 --> 00:44:41,330
數，函數名，基本上是
凡在你的代碼要停止，

816
00:44:41,330 --> 00:44:45,600
並能夠採取控制。

817
00:44:45,600 --> 00:44:54,140
>> 打印需要一個變量，並打印出
不管這個變量是在那

818
00:44:54,140 --> 00:44:55,990
點在你的執行。

819
00:44:55,990 --> 00:45:00,130
接下來將您執行
沿著一個步驟。

820
00:45:00,130 --> 00:45:05,050
並加強在函數內部的步驟
在你執行。

821
00:45:05,050 --> 00:45:10,480
>> 其他的東西跑，這是怎麼
你實際運行的代碼。

822
00:45:10,480 --> 00:45:16,630
繼續採取所有必要的步驟
到達下一個斷點。

823
00:45:16,630 --> 00:45:18,300
還有很多很多的人。

824
00:45:18,300 --> 00:45:19,040
找一找。

825
00:45:19,040 --> 00:45:19,901
他們是偉大的。

826
00:45:19,901 --> 00:45:20,863
是嗎？

827
00:45:20,863 --> 00:45:22,113
>> 聽眾：[聽不清]？

828
00:45:22,113 --> 00:45:26,635

829
00:45:26,635 --> 00:45:28,200
>> 丹：是的，這是一個調試器。

830
00:45:28,200 --> 00:45:34,230
因此，一個調試器是一個程序，
讓你調試你的程序。

831
00:45:34,230 --> 00:45:39,931
這不是一個程序，發現錯誤的
你，雖然這將是巨大的。

832
00:45:39,931 --> 00:45:43,020

833
00:45:43,020 --> 00:45:46,040
>> 而在去年對我來說是搜索。

834
00:45:46,040 --> 00:45:51,470
所以，我們談到搜索的類型
大約在這個類是線性搜索，

835
00:45:51,470 --> 00:45:55,960
這只是你通過每
搜索空間的元素，1

836
00:45:55,960 --> 00:46:00,410
元素的時間，直到你找到什麼
你正在尋找或直到您到達

837
00:46:00,410 --> 00:46:03,350
您的搜索空間的末端，在這
點你說你找不到

838
00:46:03,350 --> 00:46:06,360
你要找的元素。

839
00:46:06,360 --> 00:46:13,450
而這需要在最佳恆定時間
這是0的1，最差線性

840
00:46:13,450 --> 00:46:16,070
時間，這是0的n。

841
00:46:16,070 --> 00:46:19,250
>> 二進制搜索，它需要
骯髒的元素。

842
00:46:19,250 --> 00:46:24,230
你去你的元素中間，
看你要尋找的元素

843
00:46:24,230 --> 00:46:30,120
是比元件更大或更小
你是在中間。

844
00:46:30,120 --> 00:46:36,510
這是更大的，你說的底部
您的搜索空間是你的

845
00:46:36,510 --> 00:46:41,550
當前的位置，中間，
你重新啟動該進程。

846
00:46:41,550 --> 00:46:46,150
如果是更小的，你看說
這the--是啊，這是怎麼回事？

847
00:46:46,150 --> 00:46:47,400
>> 聽眾：[聽不清]？

848
00:46:47,400 --> 00:46:51,000

849
00:46:51,000 --> 00:46:54,260
>> 丹：是的。

850
00:46:54,260 --> 00:46:58,360
樣的一個已經教任何形式
這個類是公平的遊戲進行測試。

851
00:46:58,360 --> 00:47:01,504

852
00:47:01,504 --> 00:47:04,920
>> [笑]

853
00:47:04,920 --> 00:47:10,260
>> DAN：而事實上，你有沒有
這樣做的問題集，這是公平

854
00:47:10,260 --> 00:47:12,420
遊戲進行測試。

855
00:47:12,420 --> 00:47:15,186
>> 聽眾：我們能過目一下如何to--

856
00:47:15,186 --> 00:47:17,052
>> 丹：這將是走了過來。

857
00:47:17,052 --> 00:47:20,496
>> 揚聲器2：在實際的代碼
[聽不清]是study.cs50.net。

858
00:47:20,496 --> 00:47:25,910

859
00:47:25,910 --> 00:47:32,680
所以，如果你看一下實際問題
在合併排序頁面

860
00:47:32,680 --> 00:47:35,880
study.cs50.net，存在的代碼
實現合併排序。

861
00:47:35,880 --> 00:47:38,550
所以，你不必實施
它自己今晚。

862
00:47:38,550 --> 00:47:42,090
但要確保你了解它，而
單純的記憶。

863
00:47:42,090 --> 00:47:45,035
>> 聽眾：[聽不清]？

864
00:47:45,035 --> 00:47:49,720
>> 揚聲器2：合併排序頁面
study.cs50.net，有一種做法是

865
00:47:49,720 --> 00:47:53,570
即，如果您通過點擊問題
的問題，在最後有一個

866
00:47:53,570 --> 00:47:56,280
溶液，這是合併
排序的實現。

867
00:47:56,280 --> 00:47:58,510
但要確保你了解它
而不是單純的記憶

868
00:47:58,510 --> 00:47:59,760
或複製下來。

869
00:47:59,760 --> 00:48:02,870

870
00:48:02,870 --> 00:48:06,340
>> 聽。一個完全有效的
考試問題會

871
00:48:06,340 --> 00:48:07,990
像這裡有一個列表。

872
00:48:07,990 --> 00:48:12,100
這是什麼表像後
的選擇排序一步或

873
00:48:12,100 --> 00:48:13,330
插入排序或什麼的。

874
00:48:13,330 --> 00:48:14,940
列表中的一個完整的循環。

875
00:48:14,940 --> 00:48:18,530
所以，即使你沒有最終需要
它的代碼，你需要了解它

876
00:48:18,530 --> 00:48:20,440
足以知道怎麼回事
要修改這個數組。

877
00:48:20,440 --> 00:48:24,144

878
00:48:24,144 --> 00:48:25,394
>> 丹：這是對我來說。

879
00:48:25,394 --> 00:48:30,604

880
00:48:30,604 --> 00:48:32,588
>> [掌聲]

881
00:48:32,588 --> 00:49:06,316

882
00:49:06,316 --> 00:49:07,410
>> 盧卡斯：嘿大家。

883
00:49:07,410 --> 00:49:08,390
我的名字是盧卡斯。

884
00:49:08,390 --> 00:49:16,840
我要談的遞歸，所有
我們所學的種類，以及

885
00:49:16,840 --> 00:49:18,050
所有指針點點。

886
00:49:18,050 --> 00:49:18,740
行？

887
00:49:18,740 --> 00:49:20,340
所以首先，遞歸。

888
00:49:20,340 --> 00:49:22,951
這是什麼意思是說，
函數是遞歸？

889
00:49:22,951 --> 00:49:24,675
>> 聽眾：自稱。

890
00:49:24,675 --> 00:49:26,500
>> 盧卡斯：好，調用自身，是的。

891
00:49:26,500 --> 00:49:27,700
所以喜歡這幅畫，例如。

892
00:49:27,700 --> 00:49:30,280
這就像裡面的圖片
的圖像的等等。

893
00:49:30,280 --> 00:49:35,740
因此，舉例來說，你可以have--丹
這說的是二進制搜索。

894
00:49:35,740 --> 00:49:41,840
一種方法，其中二進制搜索是
遞歸是你的事實

895
00:49:41,840 --> 00:49:43,130
試圖找到一個號碼。

896
00:49:43,130 --> 00:49:44,250
所以，你去中間。

897
00:49:44,250 --> 00:49:47,130
然後檢查是否有數字
在左和右。

898
00:49:47,130 --> 00:49:49,650
>> 然後，如果你發現了數量為
要在左邊，這是相同的

899
00:49:49,650 --> 00:49:53,340
為再次做搜索的事情，但
只是在列表的左邊。

900
00:49:53,340 --> 00:49:57,350
所以這是它的聲音
喜歡它的遞歸。

901
00:49:57,350 --> 00:50:01,870
所以這就是為什麼你們有遞歸
解決方案歸併排序。

902
00:50:01,870 --> 00:50:04,270
>> 好了，這裡有一個例子。

903
00:50:04,270 --> 00:50:07,280
所以我們可以說，我想選擇
所有的數字從1到n。

904
00:50:07,280 --> 00:50:13,790
我也意識到，n的總和
數為n加N減1至1。

905
00:50:13,790 --> 00:50:17,810
但是，如果我看以n減1加
Ñ​​減2加1，這是相同的

906
00:50:17,810 --> 00:50:20,680
作為求和號的事
直到n減去1。

907
00:50:20,680 --> 00:50:25,890
所以我可以說的平等和之和的
等於n，減去1的n個加的總和。

908
00:50:25,890 --> 00:50:28,010
這是否有道理？

909
00:50:28,010 --> 00:50:32,630
>> 而且我也有別的東西
稱為基的情況下，它是

910
00:50:32,630 --> 00:50:37,440
數的總和最多
零是零。

911
00:50:37,440 --> 00:50:42,770
所以，當我到達數
零，我停止計數。

912
00:50:42,770 --> 00:50:45,330
這是否有道理？

913
00:50:45,330 --> 00:50:48,120
>> 因此，這裡有一個如何的例子
我可以實現這一點。

914
00:50:48,120 --> 00:50:49,860
所以我有一些這樣的功能。

915
00:50:49,860 --> 00:50:51,700
這需要一個整數n。

916
00:50:51,700 --> 00:50:56,300
所以在這裡我首先檢查是否n是
小於或等於零。

917
00:50:56,300 --> 00:51:00,310
所以，如果是小於或等於零，我
返回零，這是我們的基本情況。

918
00:51:00,310 --> 00:51:05,690
否則，我只能返回否加
的數字從和

919
00:51:05,690 --> 00:51:07,190
1到n減1。

920
00:51:07,190 --> 00:51:09,360
有意義嗎？

921
00:51:09,360 --> 00:51:10,100
行。

922
00:51:10,100 --> 00:51:11,610
>> 因此，這裡是什麼樣子。

923
00:51:11,610 --> 00:51:15,260
你有2等於總和
2加1的總和。

924
00:51:15,260 --> 00:51:18,930
而一些1是1加
總和為0，即0。

925
00:51:18,930 --> 00:51:20,216
有意義嗎？

926
00:51:20,216 --> 00:51:25,342
因此，如果我們看一下堆棧的
程序，這是什麼樣子。

927
00:51:25,342 --> 00:51:26,820
>> 首先，我們的主要功能。

928
00:51:26,820 --> 00:51:30,320
然後在主功能
所謂的總和2。

929
00:51:30,320 --> 00:51:36,690
然後和2會說，哦，總和
2等於2加一的總和。

930
00:51:36,690 --> 00:51:39,460
所以我加1和堆棧。

931
00:51:39,460 --> 00:51:43,860
與1之和為要撥打的總和
0時，其也將被加入

932
00:51:43,860 --> 00:51:44,630
到堆棧中。

933
00:51:44,630 --> 00:51:49,240
然後每個這些那些是
在另一個上面有回

934
00:51:49,240 --> 00:51:52,020
之前，其他的人可以繼續下去。

935
00:51:52,020 --> 00:51:56,240
>> 因此，例如，這裡，0相加，
首先，將要返回0。

936
00:51:56,240 --> 00:51:58,320
然後選擇1和。

937
00:51:58,320 --> 00:52:00,850
然後的1之和為要
返回1總結2。

938
00:52:00,850 --> 00:52:03,900
最後，2之和為將
返回3主。

939
00:52:03,900 --> 00:52:05,320
這是否有道理？

940
00:52:05,320 --> 00:52:09,496
>> 這是非常重要的，了解如何
堆棧的工作，並嘗試

941
00:52:09,496 --> 00:52:11,980
看它是否有道理。

942
00:52:11,980 --> 00:52:13,260
OK，這樣排序。

943
00:52:13,260 --> 00:52:16,170
那麼，為什麼是排序重要的是，
首先？

944
00:52:16,170 --> 00:52:18,260
我們為什麼要關心？

945
00:52:18,260 --> 00:52:20,310
任何人嗎？

946
00:52:20,310 --> 00:52:20,695
舉個例子？

947
00:52:20,695 --> 00:52:21,040
是嗎？

948
00:52:21,040 --> 00:52:22,968
>> 聽眾：[聽不清]。

949
00:52:22,968 --> 00:52:24,700
>> 盧卡斯：是的，確定。

950
00:52:24,700 --> 00:52:26,090
這樣你就可以更有效地進行搜索。

951
00:52:26,090 --> 00:52:28,580
這是一個很好的方式。

952
00:52:28,580 --> 00:52:32,462
因此，舉例來說，我們有很多的
的東西，其實，在我們的生活中

953
00:52:32,462 --> 00:52:32,920
進行排序。

954
00:52:32,920 --> 00:52:34,830
例如，詞典。

955
00:52:34,830 --> 00:52:39,210
>> 這是非常重要的，以把所有的
在某種順序的話，我們

956
00:52:39,210 --> 00:52:41,970
可以輕鬆地訪問。

957
00:52:41,970 --> 00:52:43,280
這就是他在說什麼。

958
00:52:43,280 --> 00:52:45,530
可以更有效地搜索。

959
00:52:45,530 --> 00:52:48,740
想起來有多難將有
字典中的詞語是在

960
00:52:48,740 --> 00:52:49,500
隨機順序。

961
00:52:49,500 --> 00:52:53,120
你必須看，好看多了，
每一個字，直到找到

962
00:52:53,120 --> 00:52:54,720
一句話，你要尋找的。

963
00:52:54,720 --> 00:52:58,710
>> 如果你使用Facebook還時
你看你的朋友，你是

964
00:52:58,710 --> 00:53:03,540
要看到，Facebook的把你的
仔細的朋友的上的那些頂級

965
00:53:03,540 --> 00:53:05,470
你不要跟那麼多。

966
00:53:05,470 --> 00:53:08,080
如果你走一路的底部
你的好友列表，你會看到

967
00:53:08,080 --> 00:53:11,250
的人，你可能甚至不
請記住，你的朋友。

968
00:53:11,250 --> 00:53:14,590
那是因為Facebook的種種
你的朋友的基礎上如何

969
00:53:14,590 --> 00:53:16,472
關閉您是給他們。

970
00:53:16,472 --> 00:53:17,930
>> 因此，組織數據。

971
00:53:17,930 --> 00:53:18,450
也口袋妖怪。

972
00:53:18,450 --> 00:53:21,400
所以你看，所有的小寵物
有數字。

973
00:53:21,400 --> 00:53:27,210
這就是像一個簡單的
存取數據的方式。

974
00:53:27,210 --> 00:53:29,050
>> 聽眾：訪問口袋妖怪。

975
00:53:29,050 --> 00:53:29,890
>> 盧卡斯：是的。

976
00:53:29,890 --> 00:53:32,395
>> 聽眾：[聽不清]。

977
00:53:32,395 --> 00:53:33,460
>> 盧卡斯：是的。

978
00:53:33,460 --> 00:53:35,140
好了，選擇排序。

979
00:53:35,140 --> 00:53:41,610
選擇排序是要選擇
列表中最小的未分類的每個值

980
00:53:41,610 --> 00:53:43,300
時間在每一次迭代。

981
00:53:43,300 --> 00:53:46,800
這有點像你做的那種
在你的頭腦，當你試圖

982
00:53:46,800 --> 00:53:48,430
排序手頭上的列表。

983
00:53:48,430 --> 00:53:51,990
>> 基本上，所有你要做的就是你
為最小的數。

984
00:53:51,990 --> 00:53:54,280
你把它在排序列表。

985
00:53:54,280 --> 00:53:56,230
然後你去找
下一個最小的數。

986
00:53:56,230 --> 00:54:00,080
然後你繼續做
該等等。

987
00:54:00,080 --> 00:54:04,600
>> 因此，選擇排序，基本上是你
選擇每次最小

988
00:54:04,600 --> 00:54:05,750
未分類的價值。

989
00:54:05,750 --> 00:54:10,840
把在排序結束
該列表的一部分。

990
00:54:10,840 --> 00:54:12,370
並繼續這樣做。

991
00:54:12,370 --> 00:54:15,890
因此，讓我們趕緊看看
這看起來像。

992
00:54:15,890 --> 00:54:19,340
因此，這裡的排序
和未排序的列表。

993
00:54:19,340 --> 00:54:23,350
>> 這樣的排序列表，
它最初是空的。

994
00:54:23,350 --> 00:54:26,760
然後我會選擇
最小數目在這裡，這是2。

995
00:54:26,760 --> 00:54:30,650
所以我得到了2號，我把
在列表的前面。

996
00:54:30,650 --> 00:54:34,910
然後我找下一個最小
元件，它是3。

997
00:54:34,910 --> 00:54:37,050
所以我把它在最後
的排序列表。

998
00:54:37,050 --> 00:54:38,140
然後我一直在這樣做。

999
00:54:38,140 --> 00:54:40,040
我發現4，並把它在末端。

1000
00:54:40,040 --> 00:54:41,360
查找5，並把它在末端。

1001
00:54:41,360 --> 00:54:44,830
>> 以及怎麼看待那些時代的
我是說把它放在結尾是，

1002
00:54:44,830 --> 00:54:46,850
基本上，交換兩個值。

1003
00:54:46,850 --> 00:54:48,100
行？

1004
00:54:48,100 --> 00:54:50,140

1005
00:54:50,140 --> 00:54:52,825
然後最後一個，你只
多了一個元素。

1006
00:54:52,825 --> 00:54:55,870
因此，它已經排序。

1007
00:54:55,870 --> 00:54:57,800
>> 好了，插入排序。

1008
00:54:57,800 --> 00:55:03,180
插入排序，你要去也有
中有一個排序的事情，

1009
00:55:03,180 --> 00:55:04,690
一個未排序的列表。

1010
00:55:04,690 --> 00:55:14,540
唯一的一點是，每一次
您要添加的元素排序

1011
00:55:14,540 --> 00:55:18,170
列表中，你只要挑元素
在未排序列表的前面。

1012
00:55:18,170 --> 00:55:20,880
然後你會發現什麼
位置應該是在所劃分的

1013
00:55:20,880 --> 00:55:22,300
該列表的一部分。

1014
00:55:22,300 --> 00:55:25,840
>> 讓我們來看看這是什麼，所以
這更有意義。

1015
00:55:25,840 --> 00:55:29,360
所以一開始，例如，我想
插入的數目3

1016
00:55:29,360 --> 00:55:30,680
列表排序的一部分。

1017
00:55:30,680 --> 00:55:31,800
因此，列表不會有什麼。

1018
00:55:31,800 --> 00:55:34,160
所以，我可以把數字3。

1019
00:55:34,160 --> 00:55:37,480
>> 現在，我想5號添加到
列表的排序的一部分。

1020
00:55:37,480 --> 00:55:38,900
所以，我看5號。

1021
00:55:38,900 --> 00:55:40,450
我注意到，這是大於3。

1022
00:55:40,450 --> 00:55:41,980
所以，我知道，那一定是3後。

1023
00:55:41,980 --> 00:55:44,100
所以我把3和5。

1024
00:55:44,100 --> 00:55:45,940
>> 然後，我想插入數字2。

1025
00:55:45,940 --> 00:55:51,630
我注意到，2號居然是
最後則兩個3和5。

1026
00:55:51,630 --> 00:55:54,580
所以，我居然還要把它所有的
方式在列表的開頭。

1027
00:55:54,580 --> 00:55:59,030
所以，我必須這樣做，種，將所有
在分類列表中，這樣我可以元素

1028
00:55:59,030 --> 00:56:01,970
令空間的數量2。

1029
00:56:01,970 --> 00:56:03,160
>> 然後，我看到的數字6。

1030
00:56:03,160 --> 00:56:05,450
我認為，它應該是在5。

1031
00:56:05,450 --> 00:56:06,240
所以我把它放在那裡。

1032
00:56:06,240 --> 00:56:07,965
最後，我看4號。

1033
00:56:07,965 --> 00:56:11,030
而且我注意到它應該
介於3和5。

1034
00:56:11,030 --> 00:56:14,870
然後我把它放在那裡，移
所有其他元素。

1035
00:56:14,870 --> 00:56:16,120
有意義嗎？

1036
00:56:16,120 --> 00:56:17,880

1037
00:56:17,880 --> 00:56:19,150
>> 冒泡排序。

1038
00:56:19,150 --> 00:56:25,730
因此，冒泡排序，基本上是你在做什麼
要do--我們稱之為泡沫

1039
00:56:25,730 --> 00:56:30,113
那種因為你通過列表中 - 
它實際上是更好，如果我只是展示

1040
00:56:30,113 --> 00:56:32,300
你喜歡this--

1041
00:56:32,300 --> 00:56:35,030
你要去比較
相鄰的號碼。

1042
00:56:35,030 --> 00:56:38,410
而且你要交換他們
如果他們沒有立場

1043
00:56:38,410 --> 00:56:39,190
以正確的順序。

1044
00:56:39,190 --> 00:56:42,570
>> 所以基本上，看到的是什麼
發生在這裡，例如，

1045
00:56:42,570 --> 00:56:44,160
你有8個和6個。

1046
00:56:44,160 --> 00:56:47,270
你知道的排序順序會
實際上是6和5，對不對？

1047
00:56:47,270 --> 00:56:49,540
所以，你要交換的訂單。

1048
00:56:49,540 --> 00:56:51,370
然後，我看到8和4在這裡。

1049
00:56:51,370 --> 00:56:52,250
我做同樣的事情。

1050
00:56:52,250 --> 00:56:53,400
我換了。

1051
00:56:53,400 --> 00:56:55,070
最後，圖2和8。

1052
00:56:55,070 --> 00:56:56,670
我也掉他們。

1053
00:56:56,670 --> 00:57:01,690
>> 這就是所謂的冒泡排序，因為後
每個迭代，其實，

1054
00:57:01,690 --> 00:57:05,910
最多列表中得到所有
的方式向列表的末尾。

1055
00:57:05,910 --> 00:57:06,940
這是否有道理？

1056
00:57:06,940 --> 00:57:11,880
因為它保持它的交換
並且將它移動到右側。

1057
00:57:11,880 --> 00:57:14,440
>> 好了，這是第二個迭代。

1058
00:57:14,440 --> 00:57:17,200
這將是同樣的東西。

1059
00:57:17,200 --> 00:57:20,190
我會做一個交換和
然後最後一個。

1060
00:57:20,190 --> 00:57:23,290
í不存在互換
和列表進行排序。

1061
00:57:23,290 --> 00:57:27,460
所以在冒泡排序，我們基本上保持
經歷名單和交換

1062
00:57:27,460 --> 00:57:32,310
事情直到我注意到，我沒有做
任何掉期這樣做迭代，這

1063
00:57:32,310 --> 00:57:34,270
意味著列表已經排序。

1064
00:57:34,270 --> 00:57:35,520
有意義嗎？

1065
00:57:35,520 --> 00:57:38,400

1066
00:57:38,400 --> 00:57:40,870
>> 讓我們來談談一點點
有關運行時間。

1067
00:57:40,870 --> 00:57:45,165
所以，不要你們還記得大
O，歐米茄，和Theta？

1068
00:57:45,165 --> 00:57:49,290

1069
00:57:49,290 --> 00:57:50,990
是嗎？

1070
00:57:50,990 --> 00:57:53,070
好了，什麼是大O，首先？

1071
00:57:53,070 --> 00:57:54,315
>> 聽眾：[聽不清]。

1072
00:57:54,315 --> 00:57:59,070
>> 盧卡斯：是的，這就是所謂的最壞情況
運行時，它只是意味著它的

1073
00:57:59,070 --> 00:58:03,470
你所期望的程序多少
取來運行。

1074
00:58:03,470 --> 00:58:04,910
如，在上of--

1075
00:58:04,910 --> 00:58:06,660
在這個case--ñ。

1076
00:58:06,660 --> 00:58:09,150
中的元素的數量
列表中的最壞情況。

1077
00:58:09,150 --> 00:58:12,520
如，在最壞的情況下。

1078
00:58:12,520 --> 00:58:17,100
>> 因此，對於冒泡排序，例如，
我們有N多的大O。

1079
00:58:17,100 --> 00:58:20,580
為什麼我們呢？

1080
00:58:20,580 --> 00:58:24,716
為什麼冒泡排序大OÑ多？

1081
00:58:24,716 --> 00:58:27,614
>> 聽眾：[聽不清]。

1082
00:58:27,614 --> 00:58:35,670
>> 盧卡斯：是的，所以最壞的情況下會
我必須做n次迭代。

1083
00:58:35,670 --> 00:58:39,260
所以每次迭代將要
帶來的最大的元素，以結束

1084
00:58:39,260 --> 00:58:40,290
的列表。

1085
00:58:40,290 --> 00:58:44,230
因此，最壞的情況是，我有
要做到這一點的事情n次。

1086
00:58:44,230 --> 00:58:48,550
並為每個時代，我要
做了N互換，因為我有比較

1087
00:58:48,550 --> 00:58:49,870
每兩個元素。

1088
00:58:49,870 --> 00:58:53,730
所以這就是為什麼它的Ñ平方
因為它的n次ñ。

1089
00:58:53,730 --> 00:59:00,120
>> 然後，選擇排序是也可為N平方
因為，每一次迭代，我要

1090
00:59:00,120 --> 00:59:02,650
看每一個元素
在列表中。

1091
00:59:02,650 --> 00:59:04,980
然後找到最小的，
這意味著我必須

1092
00:59:04,980 --> 00:59:06,130
期待通過n個元素。

1093
00:59:06,130 --> 00:59:11,750
而我所要做的是n次，因為
我要選擇所有的n個元素。

1094
00:59:11,750 --> 00:59:18,273
>> 插入排序是也可為N平方
因為在最壞的情況下會

1095
00:59:18,273 --> 00:59:20,950
是，一，我要插
n個數，對不對？

1096
00:59:20,950 --> 00:59:22,765
所以，我已經知道我要去
有n次迭代。

1097
00:59:22,765 --> 00:59:25,466

1098
00:59:25,466 --> 00:59:29,840
但對於每一個這些數字，如果我有
把所有的數字中

1099
00:59:29,840 --> 00:59:34,380
排序列表，並把它所有的方式
在前面，該將為n平方

1100
00:59:34,380 --> 00:59:36,230
因為這將為n n次重試。

1101
00:59:36,230 --> 00:59:38,280
有意義嗎？

1102
00:59:38,280 --> 00:59:41,512
怎麼樣歐米茄？

1103
00:59:41,512 --> 00:59:42,886
>> 聽眾：[聽不清]。

1104
00:59:42,886 --> 00:59:44,620
>> 盧卡斯：這是最好的情況。

1105
00:59:44,620 --> 00:59:48,810
所以，這就像在很多次的
排序，最好的情況下是

1106
00:59:48,810 --> 00:59:50,660
當列表已經排序。

1107
00:59:50,660 --> 00:59:52,670
所以，你真的沒有
做任何事情。

1108
00:59:52,670 --> 00:59:56,290
冒泡排序有最好的
情況的n。

1109
00:59:56,290 --> 00:59:58,820
難道你們知道為什麼嗎？

1110
00:59:58,820 --> 01:00:00,620
>> 聽眾：[聽不清]。

1111
01:00:00,620 --> 01:00:05,640
>> 盧卡斯：是的，如果你防不勝防
數據配給是否有任何掉期或

1112
01:00:05,640 --> 01:00:10,533
不，如果你碰到這樣的設置
如果有一個迭代中，如果真

1113
01:00:10,533 --> 01:00:15,140
名單已經排序，基本上，
什麼事情要發生是我要去

1114
01:00:15,140 --> 01:00:17,890
試換每兩個
相鄰的元素。

1115
01:00:17,890 --> 01:00:19,920
我要看到
有沒有掉。

1116
01:00:19,920 --> 01:00:21,230
我只是回來的時候了。

1117
01:00:21,230 --> 01:00:24,240
>> 因此，這意味著我不得不
通過列表一次。

1118
01:00:24,240 --> 01:00:28,990
因此，它是N，因為我期待
在n個元素。

1119
01:00:28,990 --> 01:00:30,930
為什麼選擇排序Ñ方？

1120
01:00:30,930 --> 01:00:35,150

1121
01:00:35,150 --> 01:00:45,520
>> 是啊，即使列表進行排序，對於
選擇排序的每次迭代，我

1122
01:00:45,520 --> 01:00:47,590
有選擇最小的元素。

1123
01:00:47,590 --> 01:00:49,980
因此，這意味著我必須出去找
在未排序的所有元素

1124
01:00:49,980 --> 01:00:53,350
列出並找出最小
對於每一次迭代。

1125
01:00:53,350 --> 01:00:54,600
這是否有道理？

1126
01:00:54,600 --> 01:00:56,880

1127
01:00:56,880 --> 01:01:04,690
>> 和插入劍的，因為Ñ
情況下我試圖插入

1128
01:01:04,690 --> 01:01:09,320
號碼和所有的數字，當我
嘗試插入他們，我看到他們

1129
01:01:09,320 --> 01:01:10,510
在正確的位置上。

1130
01:01:10,510 --> 01:01:15,120
我沒有去檢查所有的其他
在未排序的列表編號。

1131
01:01:15,120 --> 01:01:17,170
所以，這就是為什麼它會為n。

1132
01:01:17,170 --> 01:01:19,480
有意義嗎？

1133
01:01:19,480 --> 01:01:21,035
什麼是時間值損耗？

1134
01:01:21,035 --> 01:01:23,410
>> 聽眾：[聽不清]。

1135
01:01:23,410 --> 01:01:24,380
>> 盧卡斯：什麼，對不起？

1136
01:01:24,380 --> 01:01:24,960
再說一遍。

1137
01:01:24,960 --> 01:01:25,666
>> 聽眾：[聽不清]。

1138
01:01:25,666 --> 01:01:26,490
>> 盧卡斯：沒錯。

1139
01:01:26,490 --> 01:01:31,280
所以，你可以看到只有選擇
存儲在歸併排序有θ驅動。

1140
01:01:31,280 --> 01:01:39,920
那是因為你只有西塔
如果這兩個大O和歐米茄是相同的。

1141
01:01:39,920 --> 01:01:41,520
行。

1142
01:01:41,520 --> 01:01:44,210
最後，合併排序是在為log N。

1143
01:01:44,210 --> 01:01:48,910
>> 然後，作為丹說，合併排序
是一種像同樣的方式，

1144
01:01:48,910 --> 01:01:50,320
你做的二進制搜索。

1145
01:01:50,320 --> 01:01:53,530
所以，你得到的清單。

1146
01:01:53,530 --> 01:01:55,170
而且你會在半切。

1147
01:01:55,170 --> 01:02:00,580
然後把它們剪掉
在較小的一半。

1148
01:02:00,580 --> 01:02:01,730
然後將它們合併。

1149
01:02:01,730 --> 01:02:02,960
你們記住這一點，對不對？

1150
01:02:02,960 --> 01:02:04,960
好了，因為他說的話。

1151
01:02:04,960 --> 01:02:08,330
>> 好了，指針。

1152
01:02:08,330 --> 01:02:11,078
那麼，什麼是指針？

1153
01:02:11,078 --> 01:02:12,050
>> 聽眾：[聽不清]。

1154
01:02:12,050 --> 01:02:12,820
>> LUCAS：一個地址。

1155
01:02:12,820 --> 01:02:13,720
行。

1156
01:02:13,720 --> 01:02:18,530
我知道大衛展示了一堆
賓基和視頻的東西指著

1157
01:02:18,530 --> 01:02:19,080
彼此。

1158
01:02:19,080 --> 01:02:22,960
但我喜歡把指針
為僅僅是一個地址。

1159
01:02:22,960 --> 01:02:26,110
因此，這是即將變
以存儲一個地址。

1160
01:02:26,110 --> 01:02:31,940
>> 所以它只是這個特殊的變量
這是4個字節長。

1161
01:02:31,940 --> 01:02:36,550
請記住，該指針是什麼
總是4字節長為32位

1162
01:02:36,550 --> 01:02:39,370
機，以便與外殼
家電。

1163
01:02:39,370 --> 01:02:41,920

1164
01:02:41,920 --> 01:02:47,050
它只是有位置
它裡面的變量。

1165
01:02:47,050 --> 01:02:50,240
>> 好了，有這個記憶，基本上是這樣。

1166
01:02:50,240 --> 01:02:57,420
因此，每個內存塊實際上有一個
標籤，這是在地址

1167
01:02:57,420 --> 01:02:58,890
slotty內存。

1168
01:02:58,890 --> 01:03:02,370
因此，這意味著我可以有
指針指向

1169
01:03:02,370 --> 01:03:03,380
所有這些地址。

1170
01:03:03,380 --> 01:03:09,930
那麼，為什麼我們要使用指針的原因是
如果我要記住位置

1171
01:03:09,930 --> 01:03:12,300
一個特定的變量是內存。

1172
01:03:12,300 --> 01:03:16,560
>> 和你們記得其中的一個
案例是，如果我有一個函數

1173
01:03:16,560 --> 01:03:20,820
如果我真的想你
掉期為實數，其實我

1174
01:03:20,820 --> 01:03:22,110
必須發送一個指針。

1175
01:03:22,110 --> 01:03:23,460
不變量。

1176
01:03:23,460 --> 01:03:25,200
難道你們還記得嗎？

1177
01:03:25,200 --> 01:03:26,450
所不同的between--

1178
01:03:26,450 --> 01:03:33,350

1179
01:03:33,350 --> 01:03:34,120
名稱是什麼？

1180
01:03:34,120 --> 01:03:36,010
按價值計算，調用調用
參考了吧？

1181
01:03:36,010 --> 01:03:36,840
>> 好吧，是的。

1182
01:03:36,840 --> 01:03:38,330
所以，通過值調用。

1183
01:03:38,330 --> 01:03:43,570
當你剛發一個變量
發揮你只是發送一個值。

1184
01:03:43,570 --> 01:03:45,610
所以你實際發送
該變量的副本。

1185
01:03:45,610 --> 01:03:49,720
和你的程序一點也不在乎
關於是否真正相同的變量

1186
01:03:49,720 --> 01:03:51,650
進行複印。

1187
01:03:51,650 --> 01:03:56,330
>> 並呼籲參照指
實際上，我送的副本

1188
01:03:56,330 --> 01:03:57,550
指針指向的變量。

1189
01:03:57,550 --> 01:04:00,970
因此，這意味著我要送的
該變量的位置。

1190
01:04:00,970 --> 01:04:04,440
所以感覺我的位置
可變的，當我打電話的功能

1191
01:04:04,440 --> 01:04:09,700
使用指針，我能夠真正
改變是在主數據。

1192
01:04:09,700 --> 01:04:12,050
有意義嗎？

1193
01:04:12,050 --> 01:04:17,560
>> 雖然，指針是複印件，
指針仍具有的實際地址

1194
01:04:17,560 --> 01:04:20,090
我想改變的變量。

1195
01:04:20,090 --> 01:04:21,920
有意義嗎？

1196
01:04:21,920 --> 01:04:24,290
>> 所以創建的指針。

1197
01:04:24,290 --> 01:04:28,410
請記住，指針總是有
它的指向的類型

1198
01:04:28,410 --> 01:04:29,890
到，然後一個明星。

1199
01:04:29,890 --> 01:04:31,030
然後你把這個名字。

1200
01:04:31,030 --> 01:04:35,765
所以請記住，只要你有
什麼明星，它就像一個指針

1201
01:04:35,765 --> 01:04:38,990
，無論變
輸入您了。

1202
01:04:38,990 --> 01:04:42,850
>> 因此，這裡在星，例如，它的
指針和一個整數。

1203
01:04:42,850 --> 01:04:47,680
然後炭星是一個指針
炭星等等。

1204
01:04:47,680 --> 01:04:47,960
是嗎？

1205
01:04:47,960 --> 01:04:52,710
>> 聽眾：如果我們有一個
指針到n明星的X.

1206
01:04:52,710 --> 01:04:55,255
我知道，創建一個指向x的指針。

1207
01:04:55,255 --> 01:04:59,432
它也x聲明為整數？

1208
01:04:59,432 --> 01:05:05,170
>> 盧卡斯：好了，當你說北辰X，
你沒有創建一個指向

1209
01:05:05,170 --> 01:05:06,000
變量x。

1210
01:05:06,000 --> 01:05:08,170
您正在創建一個名為x的指針。

1211
01:05:08,170 --> 01:05:09,396
>> 聽眾：[聽不清]。

1212
01:05:09,396 --> 01:05:14,250
>> 盧卡斯：所以當我說北辰X，我
他說，嘿，在內存中，我將

1213
01:05:14,250 --> 01:05:16,390
讓這三個框之一。

1214
01:05:16,390 --> 01:05:20,750
而我會說，那
將是x，它

1215
01:05:20,750 --> 01:05:22,000
將是一個指針。

1216
01:05:22,000 --> 01:05:26,860

1217
01:05:26,860 --> 01:05:30,640
和一些有趣的指針
就是我們說他們有

1218
01:05:30,640 --> 01:05:32,620
4個字節的32位機。

1219
01:05:32,620 --> 01:05:36,320
和用於其原因是因為
4個字節的32位。

1220
01:05:36,320 --> 01:05:40,490
>> 和機器都是64位的實際
有地址的指針

1221
01:05:40,490 --> 01:05:43,480
這是64位長。

1222
01:05:43,480 --> 01:05:49,820
因此，它只是意味著的大小
在機器的地址是不同的。

1223
01:05:49,820 --> 01:05:52,270
>> 因此，引用和間接引用。

1224
01:05:52,270 --> 01:05:54,310
有兩個運算符
你們應該還記得。

1225
01:05:54,310 --> 01:05:55,450
第一是符號。

1226
01:05:55,450 --> 01:05:56,810
二是明星。

1227
01:05:56,810 --> 01:06:05,060
不要誤會由明星和這
STAR因為記得，在

1228
01:06:05,060 --> 01:06:06,950
這種情況下，你有n個明星。

1229
01:06:06,950 --> 01:06:08,700
>> 這就像一個整體的東西在一起。

1230
01:06:08,700 --> 01:06:10,720
有否N空間的明星。

1231
01:06:10,720 --> 01:06:12,070
因此，這意味著，它的類型。

1232
01:06:12,070 --> 01:06:14,870
請記住，當你擁有
變星，你是

1233
01:06:14,870 --> 01:06:16,230
談論的類型。

1234
01:06:16,230 --> 01:06:20,540
>> 當你只有明星，然後
變量的名稱，它意味著

1235
01:06:20,540 --> 01:06:24,100
你提領的指針，它
也就是說你正在看

1236
01:06:24,100 --> 01:06:28,290
指針，找到地址是
指向，將這個地址，

1237
01:06:28,290 --> 01:06:30,850
看著那無論何時
你在那裡。

1238
01:06:30,850 --> 01:06:34,310
所以我告訴我的學生，當你有
明星，你應該認為這是

1239
01:06:34,310 --> 01:06:36,850
的內容的縮寫。

1240
01:06:36,850 --> 01:06:39,770
>> 所以，如果你有一個指針，你
做明星的指針，它的

1241
01:06:39,770 --> 01:06:41,720
該指針的內容。

1242
01:06:41,720 --> 01:06:44,580
所以，你去到任何它的指向
並期待在恆定內容。

1243
01:06:44,580 --> 01:06:47,730
而符號是一樣的
東西的地址。

1244
01:06:47,730 --> 01:06:52,560
>> 所以，如果我有A--像一個變量，讓我們
說我做的int a等於3--

1245
01:06:52,560 --> 01:06:56,900
如果我想找到該地址
變量的存儲，我可以做

1246
01:06:56,900 --> 01:06:58,240
＆符號à。

1247
01:06:58,240 --> 01:07:00,280
因此，它的地址。

1248
01:07:00,280 --> 01:07:01,530
有意義嗎？

1249
01:07:01,530 --> 01:07:03,790

1250
01:07:03,790 --> 01:07:05,040
>> 因此，這裡有一個例子。

1251
01:07:05,040 --> 01:07:08,370

1252
01:07:08,370 --> 01:07:11,530
這是缺少INT B和詮釋三。

1253
01:07:11,530 --> 01:07:16,520
所以的int a = 3意味著
我打算去記憶。

1254
01:07:16,520 --> 01:07:19,870
我要去尋找一個插槽
和把數3此處。

1255
01:07:19,870 --> 01:07:22,200
>> 然後INT b等於c 4。

1256
01:07:22,200 --> 01:07:23,100
我會做同樣的事情。

1257
01:07:23,100 --> 01:07:25,840
轉到內存放了一些
4在一個箱子。

1258
01:07:25,840 --> 01:07:27,100
和INT等於5。

1259
01:07:27,100 --> 01:07:29,740
發現了另一個盒子，並把數字5。

1260
01:07:29,740 --> 01:07:36,160
>> 那麼，什麼是這行做了呢？
北辰PA等於符號à。

1261
01:07:36,160 --> 01:07:37,800
所以，首先，正星PA。

1262
01:07:37,800 --> 01:07:39,050
它是什麼做的？

1263
01:07:39,050 --> 01:07:40,930

1264
01:07:40,930 --> 01:07:42,298
>> 聽眾：[聽不清]。

1265
01:07:42,298 --> 01:07:47,890
>> 盧卡斯：是的，所以北辰PA，第一，
聲明了一個名為PA指針。

1266
01:07:47,890 --> 01:07:53,720
然後它的分配的值
該指針是一個地址。

1267
01:07:53,720 --> 01:07:55,790
所以連字號à。

1268
01:07:55,790 --> 01:07:58,510
然後，如果我做星PB，
什麼是星PB？

1269
01:07:58,510 --> 01:08:02,418

1270
01:08:02,418 --> 01:08:03,150
>> 哦，對不起。

1271
01:08:03,150 --> 01:08:06,330
這也不翼而飛。北辰PB。

1272
01:08:06,330 --> 01:08:07,905
我的意思是明星的PC。

1273
01:08:07,905 --> 01:08:11,200
我很抱歉。

1274
01:08:11,200 --> 01:08:11,940
這是同樣的事情。

1275
01:08:11,940 --> 01:08:16,408
但現在我很好AR創建一個指針
到B，然後指向到c。

1276
01:08:16,408 --> 01:08:16,886
是嗎？

1277
01:08:16,886 --> 01:08:18,136
>> 聽眾：[聽不清]？

1278
01:08:18,136 --> 01:08:25,490

1279
01:08:25,490 --> 01:08:26,670
>> 盧卡斯：是的。

1280
01:08:26,670 --> 01:08:32,630
所以，如果你去記憶和你去
盒子是代號為PA，

1281
01:08:32,630 --> 01:08:37,149
你究竟要
看到了一個地址。

1282
01:08:37,149 --> 01:08:38,399
行？

1283
01:08:38,399 --> 01:08:42,970

1284
01:08:42,970 --> 01:08:43,300
是嗎？

1285
01:08:43,300 --> 01:08:45,605
>> 聽眾：[聽不清]？

1286
01:08:45,605 --> 01:08:49,260
>> 盧卡斯：是的，指針是一個地址。

1287
01:08:49,260 --> 01:08:50,120
永遠不要忘記這一點。

1288
01:08:50,120 --> 01:08:52,800
這就像最重要
部分有關指針。

1289
01:08:52,800 --> 01:08:56,180
還有存儲和地址
一些變量。

1290
01:08:56,180 --> 01:08:56,890
還要別的嗎？

1291
01:08:56,890 --> 01:08:58,370
還有沒有其他問題？

1292
01:08:58,370 --> 01:08:59,189
行。

1293
01:08:59,189 --> 01:09:00,399
>> 所以，指針和數組。

1294
01:09:00,399 --> 01:09:08,189
請記住，當我做int數組3，
基本上，我在做什麼是我，那種

1295
01:09:08,189 --> 01:09:12,779
的，在聲明一個指針。

1296
01:09:12,779 --> 01:09:18,960
所以數組是一種像一個指向
在內存中特定的地方中，我

1297
01:09:18,960 --> 01:09:21,999
分配三個插槽的整數。

1298
01:09:21,999 --> 01:09:23,430
這是否有道理？

1299
01:09:23,430 --> 01:09:30,250
>> 所以，當我做int數組3，就是我
這樣做，基本上是創建三個

1300
01:09:30,250 --> 01:09:31,479
插槽中的內存。

1301
01:09:31,479 --> 01:09:33,899
所以，我只是覺得在內存中三個插槽。

1302
01:09:33,899 --> 01:09:38,810
所以，如果我這樣做，那麼，星陣，它
基本上意味著陣列的內容，

1303
01:09:38,810 --> 01:09:46,180
這意味著我刪除的指針，我走了
到那個地方，它的指向，

1304
01:09:46,180 --> 01:09:47,939
我把頭號。

1305
01:09:47,939 --> 01:09:53,729
>> 然後，如果我做星陣加1，
這是同樣的事情，因為這樣做陣列

1306
01:09:53,729 --> 01:09:59,690
支架一個，這只是意味著我去
它的指向的地方。

1307
01:09:59,690 --> 01:10:03,000
然後加1品牌
我移動一個位置。

1308
01:10:03,000 --> 01:10:06,510
於是我去到這個位置，實際上，
並把兩個數。

1309
01:10:06,510 --> 01:10:10,900
>> 然後，終於，當我做
陣加2，我去哪裡

1310
01:10:10,900 --> 01:10:11,825
陣列的指點一下。

1311
01:10:11,825 --> 01:10:14,690
然後我移動到內存塊。

1312
01:10:14,690 --> 01:10:16,240
然後我把三號這裡。

1313
01:10:16,240 --> 01:10:16,600
是嗎？

1314
01:10:16,600 --> 01:10:21,400
>> 聽眾：所以星陣簡直是
說的第一點。

1315
01:10:21,400 --> 01:10:25,090
你還可以加1，只是因為
我們只有真正

1316
01:10:25,090 --> 01:10:27,295
在引用的第一個地址。

1317
01:10:27,295 --> 01:10:28,545
>> 盧卡斯：是的。

1318
01:10:28,545 --> 01:10:32,720

1319
01:10:32,720 --> 01:10:36,020
我們為什麼，例如，假設數組
0，陣列1和陣列2？

1320
01:10:36,020 --> 01:10:38,970

1321
01:10:38,970 --> 01:10:42,790
我是說，你為什麼這樣做0，
1，2，3，而不是1，2，3？

1322
01:10:42,790 --> 01:10:46,550
其中一個原因是，一個，計算機
程序員喜歡開始

1323
01:10:46,550 --> 01:10:47,750
從0開始計數。

1324
01:10:47,750 --> 01:10:52,370
二是因為當你做陣列0，
這是同樣的事情，因為這樣做陣列

1325
01:10:52,370 --> 01:10:56,330
加0，這意味著我去
那個位置，我不

1326
01:10:56,330 --> 01:10:59,320
跳過任何存儲器塊。

1327
01:10:59,320 --> 01:11:01,750
所以，我不動任何內存塊。

1328
01:11:01,750 --> 01:11:02,015
是嗎？

1329
01:11:02,015 --> 01:11:03,265
>> 聽眾：[聽不清]？

1330
01:11:03,265 --> 01:11:05,928

1331
01:11:05,928 --> 01:11:12,670
>> 盧卡斯：所以她叫什麼
這樣的區別

1332
01:11:12,670 --> 01:11:14,000
這或做的malloc。

1333
01:11:14,000 --> 01:11:17,550
一的區別是
int數組3是創建一個

1334
01:11:17,550 --> 01:11:19,260
數組在棧上。

1335
01:11:19,260 --> 01:11:23,080
當我這樣做的malloc，它
在堆上創建。

1336
01:11:23,080 --> 01:11:25,250
這是否有道理？

1337
01:11:25,250 --> 01:11:28,870
>> 那麼，如何malloc的實際工作？

1338
01:11:28,870 --> 01:11:32,245
那麼，為什麼我們甚至需要使用malloc？

1339
01:11:32,245 --> 01:11:35,730

1340
01:11:35,730 --> 01:11:39,700
你的編譯器種人物所有
你聲明的變量。

1341
01:11:39,700 --> 01:11:44,040
而他所有的創造空間
他們在堆棧中。

1342
01:11:44,040 --> 01:11:47,180
因此，所有的變量都將
在某處的堆棧。

1343
01:11:47,180 --> 01:11:49,460
因此，這裡的環境變量。

1344
01:11:49,460 --> 01:11:53,850
>> 所以基本上，空間，這些變量
在內存分配在

1345
01:11:53,850 --> 01:11:55,080
編譯時間。

1346
01:11:55,080 --> 01:11:58,790
因此，這意味著你的電腦有
要知道所有這些變量的

1347
01:11:58,790 --> 01:11:59,790
事前。

1348
01:11:59,790 --> 01:12:02,500
它並不需要知道什麼樣的價值
你要放他們。

1349
01:12:02,500 --> 01:12:05,490
但是，它需要知道如何
你需要多少內存。

1350
01:12:05,490 --> 01:12:09,380
>> 但現在讓我們說，例如，
你要創建一個數組或採取

1351
01:12:09,380 --> 01:12:13,430
字符串，你正在做
從所述用戶。

1352
01:12:13,430 --> 01:12:17,300
你不知道過了多久字符串
將是，例如。

1353
01:12:17,300 --> 01:12:20,600
所以，你不知道到底有多少
你分配的內存塊，對不對？

1354
01:12:20,600 --> 01:12:24,120
>> 因此，它並沒有真正意義的
你說把100個字符。

1355
01:12:24,120 --> 01:12:26,420
然後，如果用戶寫150？

1356
01:12:26,420 --> 01:12:27,670
你會擰。

1357
01:12:27,670 --> 01:12:30,160

1358
01:12:30,160 --> 01:12:34,620
>> 所以基本上，你不能確定如何
您需要分配多大內存

1359
01:12:34,620 --> 01:12:35,960
當你編譯的程序。

1360
01:12:35,960 --> 01:12:38,240
你只知道，在運行時間。

1361
01:12:38,240 --> 01:12:39,950
所以這就是為什麼你必須堆。

1362
01:12:39,950 --> 01:12:47,610
所以堆將會有記憶
您在正在分配

1363
01:12:47,610 --> 01:12:50,810
時間程序運行。

1364
01:12:50,810 --> 01:12:55,780
>> 所以基本上，當你這樣做的malloc什麼
你正在做的，是分配內存

1365
01:12:55,780 --> 01:13:00,160
運行時，這意味著你
決定在那一刻的權利，你

1366
01:13:00,160 --> 01:13:02,670
應該有存儲器。

1367
01:13:02,670 --> 01:13:04,210
所以，當你分配它。

1368
01:13:04,210 --> 01:13:06,430
這是否有道理？

1369
01:13:06,430 --> 01:13:11,690
>> 所以請記住，棧有變數
這是在編譯時創建的。

1370
01:13:11,690 --> 01:13:14,560
然後堆有變數
那你去創建

1371
01:13:14,560 --> 01:13:15,600
使用malloc，例如。

1372
01:13:15,600 --> 01:13:16,850
>> 聽眾：[聽不清]？

1373
01:13:16,850 --> 01:13:19,179

1374
01:13:19,179 --> 01:13:24,340
>> 盧卡斯：那麼GetString的是
要調用malloc。

1375
01:13:24,340 --> 01:13:26,710
讓我談談malloc和
我會解釋的GetString。

1376
01:13:26,710 --> 01:13:32,000
所以malloc的是同樣的事情
內存分配。

1377
01:13:32,000 --> 01:13:34,600
因此，它會分配
存儲在堆中。

1378
01:13:34,600 --> 01:13:40,010
而且它會返回一個指向
如該內存被分配在。

1379
01:13:40,010 --> 01:13:43,090
>> 當你do--所以

1380
01:13:43,090 --> 01:13:44,910
這裡example--

1381
01:13:44,910 --> 01:13:45,830
北辰指針。

1382
01:13:45,830 --> 01:13:50,520
然後指針相等的malloc
英寸的10倍大小。

1383
01:13:50,520 --> 01:13:52,110
我創建一個指針。

1384
01:13:52,110 --> 01:13:59,020
然後我分配的指針
的指針，該指針的malloc的值

1385
01:13:59,020 --> 01:13:59,680
是給我的。

1386
01:13:59,680 --> 01:14:04,150
>> 所以我問的malloc可以分配你
空間為10的整數。

1387
01:14:04,150 --> 01:14:05,390
這就是它的說法。

1388
01:14:05,390 --> 01:14:09,020
和malloc給我回一個
指針指向的地方。

1389
01:14:09,020 --> 01:14:11,460
有意義嗎？

1390
01:14:11,460 --> 01:14:12,270
行。

1391
01:14:12,270 --> 01:14:17,940
i和GetString的是，基本上，做一個
打電話的malloc，所以你可以分配

1392
01:14:17,940 --> 01:14:21,680
在運行時內存。

1393
01:14:21,680 --> 01:14:26,460
>> 一定要記住檢查null
因為malloc的是要返回null

1394
01:14:26,460 --> 01:14:28,200
如果無法分配內存。

1395
01:14:28,200 --> 01:14:31,660
比方說，你問了一個可笑的
內存量。

1396
01:14:31,660 --> 01:14:33,950
您的電腦不會是
能夠分配那麼多。

1397
01:14:33,950 --> 01:14:36,410
>> 所以malloc的只是去
返回NULL。

1398
01:14:36,410 --> 01:14:42,210
所以永遠記得檢查
您從得到的malloc指針

1399
01:14:42,210 --> 01:14:45,640
空或不是，因為如果是這樣，你可能
被提領的指針和

1400
01:14:45,640 --> 01:14:48,340
導致側故障。

1401
01:14:48,340 --> 01:14:50,930
最後，不要忘了
您的可用內存。

1402
01:14:50,930 --> 01:14:57,800

1403
01:14:57,800 --> 01:15:00,560
>> malloc的是創建存儲在堆中。

1404
01:15:00,560 --> 01:15:03,436
而且你要釋放內存
前程序結束。

1405
01:15:03,436 --> 01:15:05,370
好吧，這就是我。

1406
01:15:05,370 --> 01:15:07,900
對不起，羅布。

1407
01:15:07,900 --> 01:15:07,950
謝謝。

1408
01:15:07,950 --> 01:15:09,878
>> [掌聲]

1409
01:15:09,878 --> 01:15:12,679
>> 盧卡斯：最後還有什麼問題
之前搶來？

1410
01:15:12,679 --> 01:15:13,138
不是嗎？

1411
01:15:13,138 --> 01:15:13,597
是嗎？

1412
01:15:13,597 --> 01:15:15,892
>> 觀眾：我沒看到
這個網上。

1413
01:15:15,892 --> 01:15:17,269
你已經上載了嗎？

1414
01:15:17,269 --> 01:15:19,106
>> 盧卡斯：我認為大衛是
很快上傳。

1415
01:15:19,106 --> 01:15:19,880
>> 戴夫：這將被張貼。

1416
01:15:19,880 --> 01:15:20,310
>> 盧卡斯：這將是在網上。

1417
01:15:20,310 --> 01:15:21,175
>> 聽眾：這是最高。

1418
01:15:21,175 --> 01:15:22,090
>> 盧卡斯：這事？

1419
01:15:22,090 --> 01:15:23,157
行。

1420
01:15:23,157 --> 01:15:23,644
是嗎？

1421
01:15:23,644 --> 01:15:27,053
>> 聽眾：[聽不清]？

1422
01:15:27,053 --> 01:15:30,285
>> 盧卡斯：是的，你應該釋放所有的
這被放置在堆內存中。

1423
01:15:30,285 --> 01:15:31,535
>> 聽眾：[聽不清]？

1424
01:15:31,535 --> 01:15:34,518

1425
01:15:34,518 --> 01:15:36,160
>> 盧卡斯：是的。

1426
01:15:36,160 --> 01:15:39,980
任何時候你有一個文化的malloc，
你應該有自由文化

1427
01:15:39,980 --> 01:15:42,640
在您停止使用該變量。

1428
01:15:42,640 --> 01:15:44,800
所以malloc和free的
永遠在一起。

1429
01:15:44,800 --> 01:15:45,410
他們最好的朋友。

1430
01:15:45,410 --> 01:15:46,720
是啊。

1431
01:15:46,720 --> 01:15:47,970
羅布？

1432
01:15:47,970 --> 01:15:55,595

1433
01:15:55,595 --> 01:15:56,850
>> 羅伯：我去快。

1434
01:15:56,850 --> 01:16:00,466
而且視頻將被提了起來。

1435
01:16:00,466 --> 01:16:01,716
我的麥克風。

1436
01:16:01,716 --> 01:16:24,060

1437
01:16:24,060 --> 01:16:26,230
>> 好了，每週五天的東西。

1438
01:16:26,230 --> 01:16:27,970
第一件事，我們是堆棧。

1439
01:16:27,970 --> 01:16:33,390
因此請記住，只有一個堆
每個活動函數調用框架。

1440
01:16:33,390 --> 01:16:34,710
我們會看到，在一秒鐘。

1441
01:16:34,710 --> 01:16:37,850
還記得究竟去
在每個堆棧幀將要

1442
01:16:37,850 --> 01:16:41,880
我們的函數的局部變量，
被傳入的參數我們

1443
01:16:41,880 --> 01:16:43,880
功能，再加上一對夫婦
其他的事情你真的不

1444
01:16:43,880 --> 01:16:45,260
需要擔心的。

1445
01:16:45,260 --> 01:16:50,950
>> 因此，這裡是一個示例程序，其中，
的通知，主要是printfing回報

1446
01:16:50,950 --> 01:16:52,830
富4的值。

1447
01:16:52,830 --> 01:16:57,930
富只是要返回
的4條6逗號價值。

1448
01:16:57,930 --> 01:17:02,380
酒吧是要設置一些當地的
變量n等於4倍6。

1449
01:17:02,380 --> 01:17:03,920
然後返回否。

1450
01:17:03,920 --> 01:17:09,130
>> 因此，讓我們來看看整個堆棧
這個程序的實際迭代。

1451
01:17:09,130 --> 01:17:10,500
所以這是我們的堆棧的底部。

1452
01:17:10,500 --> 01:17:12,620
請記住，堆棧長大。

1453
01:17:12,620 --> 01:17:15,370
所以在我們的棧底，我們
有主堆棧幀。

1454
01:17:15,370 --> 01:17:17,000
當程序啟動時，主
總是要處於

1455
01:17:17,000 --> 01:17:18,560
我們的堆棧底部。

1456
01:17:18,560 --> 01:17:20,880
>> 什麼是我們的內部
堆棧幀主？

1457
01:17:20,880 --> 01:17:23,810
因此，即使沒有本地
變量主，就像我之前說的，

1458
01:17:23,810 --> 01:17:29,670
我們argc和RGV佔用空間
裡面主要的棧幀。

1459
01:17:29,670 --> 01:17:33,260
所以主要是現在要
調用函數foo。

1460
01:17:33,260 --> 01:17:35,125
這意味著foo的是要
讓自己的堆棧幀。

1461
01:17:35,125 --> 01:17:36,970
>> 所以，現在我們的內部
函數foo。

1462
01:17:36,970 --> 01:17:38,610
什麼需要去
Foo的堆棧幀？

1463
01:17:38,610 --> 01:17:41,100
那麼，富有一個參數n。

1464
01:17:41,100 --> 01:17:45,440
而n等於4，因為那是什麼
主要是通過為富的說法。

1465
01:17:45,440 --> 01:17:48,490
>> 所以，現在富會打電話吧。

1466
01:17:48,490 --> 01:17:52,070
什麼是酒吧將有內
它的“堆棧幀？

1467
01:17:52,070 --> 01:17:55,610
它具有點¯x等於4 Y等於六。

1468
01:17:55,610 --> 01:17:58,540
這還不是全部，我們將不得不
因為在酒吧的堆棧幀

1469
01:17:58,540 --> 01:18:00,580
也有局部變量n。

1470
01:18:00,580 --> 01:18:03,370
而n我們將設定為24。

1471
01:18:03,370 --> 01:18:05,750
>> 所以，現在酒吧是要返回否。

1472
01:18:05,750 --> 01:18:09,300
因此，巴將返回24
堆棧幀富。

1473
01:18:09,300 --> 01:18:12,560
而由於酒吧現在回來，那
意味著我們出棧幀

1474
01:18:12,560 --> 01:18:14,250
在酒吧從堆棧中。

1475
01:18:14,250 --> 01:18:18,430
因此，所有的酒吧一直是記憶
用現在堆棧。

1476
01:18:18,430 --> 01:18:21,550
>> 現在，富也要去
回到24主。

1477
01:18:21,550 --> 01:18:25,470
所以，現在富正在恢復，內存
在富用其'

1478
01:18:25,470 --> 01:18:27,550
堆棧幀也不見了。

1479
01:18:27,550 --> 01:18:29,660
而現在，主要是要調用printf。

1480
01:18:29,660 --> 01:18:31,660
所以printf的只是另一種功能。

1481
01:18:31,660 --> 01:18:35,320
當我們調用printf，這將是
對於printf的另一個堆棧幀

1482
01:18:35,320 --> 01:18:36,470
函數調用。

1483
01:18:36,470 --> 01:18:37,990
>> 什麼是我們傳遞的printf？

1484
01:18:37,990 --> 01:18:40,090
這是怎麼回事去
在它的堆棧幀。

1485
01:18:40,090 --> 01:18:44,970
最起碼，我們傳遞
即％的I反斜杠n和

1486
01:18:44,970 --> 01:18:47,180
參數24。

1487
01:18:47,180 --> 01:18:50,370
它可能有更多在它的堆棧幀
如果printf的碰巧使用一些

1488
01:18:50,370 --> 01:18:51,200
局部變量。

1489
01:18:51,200 --> 01:18:51,920
我們不知道。

1490
01:18:51,920 --> 01:18:53,810
>> 但是，所有的雲在printf中的
堆棧幀。

1491
01:18:53,810 --> 01:18:55,740
這將執行中的printf。

1492
01:18:55,740 --> 01:18:56,830
隨後的printf的實現。

1493
01:18:56,830 --> 01:18:57,820
它會回來。

1494
01:18:57,820 --> 01:18:58,960
最後，主做。

1495
01:18:58,960 --> 01:18:59,860
主會回來。

1496
01:18:59,860 --> 01:19:02,020
然後我們的程序就完成了。

1497
01:19:02,020 --> 01:19:02,480
是嗎？

1498
01:19:02,480 --> 01:19:04,505
>> 聽眾：你看到[聽不清]

1499
01:19:04,505 --> 01:19:05,900
參數[聽不清]

1500
01:19:05,900 --> 01:19:06,830
參數？

1501
01:19:06,830 --> 01:19:09,970
>> 羅伯：所以是有細微的差別
之間的參數和參數。

1502
01:19:09,970 --> 01:19:14,400
真的，在共同的說話，人們往往
只是混淆了所有的時間。

1503
01:19:14,400 --> 01:19:17,550
但是參數是正規
的東西的名稱。

1504
01:19:17,550 --> 01:19:20,180
>> 所以argc和argv是
參數為主。

1505
01:19:20,180 --> 01:19:23,440
爭論實際上是你
傳中的那些參數。

1506
01:19:23,440 --> 01:19:28,340
所以，當我調用foo 4,4有
是我傳遞的參數。

1507
01:19:28,340 --> 01:19:31,460
和參數n，內
富，取值為4

1508
01:19:31,460 --> 01:19:32,880
因為4是參數。

1509
01:19:32,880 --> 01:19:35,826
>> 聽眾：[聽不清]？

1510
01:19:35,826 --> 01:19:37,880
>> 羅伯：n是吧一個局部變量。

1511
01:19:37,880 --> 01:19:41,420

1512
01:19:41,420 --> 01:19:44,960
n是本地還是要富，但
這是一個參數為foo。

1513
01:19:44,960 --> 01:19:48,190
這不是一個局部變量。

1514
01:19:48,190 --> 01:19:48,546
是嗎？

1515
01:19:48,546 --> 01:19:51,180
>> 聽眾：[聽不清]？

1516
01:19:51,180 --> 01:19:55,400
>> 羅伯：富時打電話是酒吧和
返回不管酒吧的回報。

1517
01:19:55,400 --> 01:19:56,786
>> 聽眾：[聽不清]？

1518
01:19:56,786 --> 01:19:59,591
>> 羅伯：是啊，剛看到多
堆棧幀。

1519
01:19:59,591 --> 01:20:00,082
是嗎？

1520
01:20:00,082 --> 01:20:03,519
>> 聽眾：為什麼叫做foo
之前的printf？

1521
01:20:03,519 --> 01:20:05,920
>> 羅伯：printf的前為何被稱為富？

1522
01:20:05,920 --> 01:20:10,740
這樣我就可以有，而是做了一些
如int x等於4富

1523
01:20:10,740 --> 01:20:12,980
再印的X.

1524
01:20:12,980 --> 01:20:17,900
而是，我結合了功能
調入的printf參數。

1525
01:20:17,900 --> 01:20:23,670
>> 但是請注意，我們不能真正
執行調用printf，直到我們

1526
01:20:23,670 --> 01:20:25,610
弄清楚了4 foo是。

1527
01:20:25,610 --> 01:20:27,480
所以，我們要評估這個。

1528
01:20:27,480 --> 01:20:32,504
只有一次這樣做了會
回來和評估的。

1529
01:20:32,504 --> 01:20:32,990
是嗎？

1530
01:20:32,990 --> 01:20:37,364
>> 聽眾：因為這兩個欄[聽不清]

1531
01:20:37,364 --> 01:20:41,738
價值，為什麼我們沒有[聽不清]？

1532
01:20:41,738 --> 01:20:44,400
>> 羅伯：他們完全應該是int。

1533
01:20:44,400 --> 01:20:46,260
這是沒有抓到過
多遍。

1534
01:20:46,260 --> 01:20:49,010
因此，它應該是int酒吧和INT
因為這兩個的富

1535
01:20:49,010 --> 01:20:50,460
正在返回的整數。

1536
01:20:50,460 --> 01:20:54,214
虛空只有當他們不打算
返回的實際值。

1537
01:20:54,214 --> 01:20:54,692
是嗎？

1538
01:20:54,692 --> 01:20:58,038
>> 聽眾：如果你有一個以上的行
返回[聽不清]？

1539
01:20:58,038 --> 01:21:01,862

1540
01:21:01,862 --> 01:21:03,730
>> 羅伯：上面返回的行？

1541
01:21:03,730 --> 01:21:04,410
>> 聽眾：是的。

1542
01:21:04,410 --> 01:21:10,780
就像如果你做了printf和[聽不清]
將其打印了兩次？

1543
01:21:10,780 --> 01:21:12,992
>> 羅伯：所以富裡面？

1544
01:21:12,992 --> 01:21:15,945
如果我們有一個printf就在這裡？

1545
01:21:15,945 --> 01:21:16,750
>> 聽眾：是的。

1546
01:21:16,750 --> 01:21:19,510
>> 羅伯：所以，如果我們有一個正確的printf
這裡，是將打印一次。

1547
01:21:19,510 --> 01:21:23,400
由於我們調用foo一次正確的
在這裡，然後我們會打的printf。

1548
01:21:23,400 --> 01:21:24,620
然後我們會打電話吧。

1549
01:21:24,620 --> 01:21:25,710
再富將返回。

1550
01:21:25,710 --> 01:21:26,275
就是這樣。

1551
01:21:26,275 --> 01:21:30,985
我們只遇到過
在printf的一次。

1552
01:21:30,985 --> 01:21:31,482
是嗎？

1553
01:21:31,482 --> 01:21:32,973
>> 聽眾：[聽不清]

1554
01:21:32,973 --> 01:21:37,950
printf的調用foo，因為我們是第一
調用printf的，然後我們傳遞

1555
01:21:37,950 --> 01:21:38,580
的論點。

1556
01:21:38,580 --> 01:21:40,960
>> 羅伯：所以在理論上，是不是
printf的調用foo？

1557
01:21:40,960 --> 01:21:42,220
因此，沒有。

1558
01:21:42,220 --> 01:21:47,360
只是為了使c為要
執行這些東西，我們才可以

1559
01:21:47,360 --> 01:21:49,800
調用一個函數，所有的參數
該函數必須

1560
01:21:49,800 --> 01:21:51,600
徹底評估。

1561
01:21:51,600 --> 01:21:53,540
因此，這是完全評估？

1562
01:21:53,540 --> 01:21:54,610
是的，它只是一個字符串。

1563
01:21:54,610 --> 01:21:55,480
這只是一個值。

1564
01:21:55,480 --> 01:21:57,200
>> 然後，我們必須徹底
評估此。

1565
01:21:57,200 --> 01:21:59,720
一旦這樣做了，現在所有的
它的參數進行評估。

1566
01:21:59,720 --> 01:22:01,982
現在，我們可以使
調用printf。

1567
01:22:01,982 --> 01:22:02,478
是嗎？

1568
01:22:02,478 --> 01:22:03,966
>> 聽眾：有一個問題。

1569
01:22:03,966 --> 01:22:06,942
如果你有一個void函數，必須
你有回報分號？

1570
01:22:06,942 --> 01:22:09,910
>> 羅伯：你不是一回分號
如果你有一個void函數。

1571
01:22:09,910 --> 01:22:13,370

1572
01:22:13,370 --> 01:22:14,780
行。

1573
01:22:14,780 --> 01:22:15,830
所以，現在有些堆東西。

1574
01:22:15,830 --> 01:22:19,640
所以堆是我們要如何應對
動態內存管理。

1575
01:22:19,640 --> 01:22:23,100
而這直接與對比
堆棧，我們稱之為自動

1576
01:22:23,100 --> 01:22:24,100
內存管理。

1577
01:22:24,100 --> 01:22:27,140
>> 因此，在堆棧上，你從來沒有真正有
處理如何局部變量

1578
01:22:27,140 --> 01:22:30,400
正在入棧和出棧關閉所有
這些堆棧幀和所有的東西。

1579
01:22:30,400 --> 01:22:31,070
你不必為此擔心。

1580
01:22:31,070 --> 01:22:32,070
這是自動的。

1581
01:22:32,070 --> 01:22:36,990
所以堆是手動的。

1582
01:22:36,990 --> 01:22:38,070
和[聽不清]

1583
01:22:38,070 --> 01:22:41,260
來自這些功能
malloc和free。

1584
01:22:41,260 --> 01:22:43,550
>> 因此，這裡的其他程序。

1585
01:22:43,550 --> 01:22:47,145
我們所要做的就是mallocing
的整數。

1586
01:22:47,145 --> 01:22:49,360
我們將它存儲在明星的X.

1587
01:22:49,360 --> 01:22:52,520
當然，我們要檢查
看是否x是零。

1588
01:22:52,520 --> 01:22:56,400
然後，我們將只設置什麼
x被指向到50。

1589
01:22:56,400 --> 01:23:00,350

1590
01:23:00,350 --> 01:23:03,260
打印x的值指向，
打印X，然後自由的X.

1591
01:23:03,260 --> 01:23:08,920
>> 所以，這是怎麼實際去看看
如果我們看一下我們的堆棧和堆？

1592
01:23:08,920 --> 01:23:10,950
因此，我們將重新開始。

1593
01:23:10,950 --> 01:23:12,580
我們的疊層作為前底部。

1594
01:23:12,580 --> 01:23:15,930
請記住，你直接堆
反對棧？

1595
01:23:15,930 --> 01:23:18,850
因此，我們將有
我們堆的頂部在那裡。

1596
01:23:18,850 --> 01:23:22,590
>> 所以我們的棧底，我們有
我們的主堆棧幀。

1597
01:23:22,590 --> 01:23:28,000
它具有的argc，argv的空間，而我們
現在有一個局部變量x，它

1598
01:23:28,000 --> 01:23:30,030
是一個int明星。

1599
01:23:30,030 --> 01:23:32,240
所以，我們要遍歷
通過這一方案。

1600
01:23:32,240 --> 01:23:34,420
第一件事，我們是
調用malloc的。

1601
01:23:34,420 --> 01:23:36,250
>> 因此，我們正在做一個調用malloc的。

1602
01:23:36,250 --> 01:23:37,100
是的malloc函數。

1603
01:23:37,100 --> 01:23:38,770
這將得到一個堆棧幀。

1604
01:23:38,770 --> 01:23:40,180
什麼是我們通過對malloc？

1605
01:23:40,180 --> 01:23:41,610
這是怎麼回事裡面去
堆棧幀。

1606
01:23:41,610 --> 01:23:45,130
我們路過N，也就是4的大小。

1607
01:23:45,130 --> 01:23:49,700
因此，傳遞函數malloc。

1608
01:23:49,700 --> 01:23:50,910
>> 什麼是malloc的呢？

1609
01:23:50,910 --> 01:23:53,820
它抓住了我們堆了一些空間。

1610
01:23:53,820 --> 01:23:55,320
所以我們會去堆。

1611
01:23:55,320 --> 01:23:57,990
而且我們要搶
4個字節從堆中。

1612
01:23:57,990 --> 01:24:01,500
所以讓我們只給了
的任意地址。

1613
01:24:01,500 --> 01:24:06,680
為0x123假裝這是一個
地址，它是在堆上。

1614
01:24:06,680 --> 01:24:12,300
>> 那麼究竟是怎樣的裡面
內存地址為Ox123區域？

1615
01:24:12,300 --> 01:24:13,080
垃圾。

1616
01:24:13,080 --> 01:24:15,270
所以，我們沒有存儲在它的任何東西。

1617
01:24:15,270 --> 01:24:18,830
因此，據我們所知，
可以是任何東西。

1618
01:24:18,830 --> 01:24:20,560
你不應該假設它是零。

1619
01:24:20,560 --> 01:24:23,870
這是最有可能不為零。

1620
01:24:23,870 --> 01:24:26,260
>> 所以，現在的malloc返回。

1621
01:24:26,260 --> 01:24:28,020
而我們該怎麼做時malloc的回報？

1622
01:24:28,020 --> 01:24:29,800
我們所設置的返回。

1623
01:24:29,800 --> 01:24:32,290
我們集合X等於什麼
它返回。

1624
01:24:32,290 --> 01:24:33,690
那麼什麼是回歸？

1625
01:24:33,690 --> 01:24:38,150
它的返回為0x123自認為是
的存儲器塊的地址，它

1626
01:24:38,150 --> 01:24:40,850
只是在堆中分配的。

1627
01:24:40,850 --> 01:24:47,160
>> 因此，返回為0x123 x被現在要設定
等於為0x123的，形象地，

1628
01:24:47,160 --> 01:24:52,940
我們經常畫為x具有實際
箭頭指向該塊。

1629
01:24:52,940 --> 01:24:55,820
但是，x只是存儲的地址。

1630
01:24:55,820 --> 01:24:58,670
所以，現在我們要檢查如果x為null。

1631
01:24:58,670 --> 01:24:59,120
這不是空。

1632
01:24:59,120 --> 01:25:02,170
我們假裝是malloc的成功。

1633
01:25:02,170 --> 01:25:04,950
>> 所以現在星x等於50。

1634
01:25:04,950 --> 01:25:08,450
因此，星記得這意味著
去那個地址。

1635
01:25:08,450 --> 01:25:12,700
所以，0x123的我們要
去那個地址。

1636
01:25:12,700 --> 01:25:14,660
所以這給我們帶來了那裡。

1637
01:25:14,660 --> 01:25:16,310
什麼是我們在該地址在做什麼？

1638
01:25:16,310 --> 01:25:19,020
我們要存儲50。

1639
01:25:19,020 --> 01:25:22,500
>> 所以，這條線之後，那是什麼
事情進展到什麼樣子。

1640
01:25:22,500 --> 01:25:24,640
所以，現在它不再
垃圾在那裡。

1641
01:25:24,640 --> 01:25:28,910
現在我們知道，50是在
具體地址，因為

1642
01:25:28,910 --> 01:25:32,410
我們設置了這一點。

1643
01:25:32,410 --> 01:25:32,790
行？

1644
01:25:32,790 --> 01:25:34,370
所以，現在我們將要打印的F。

1645
01:25:34,370 --> 01:25:38,490
>> 因此，首先我們要打印的明星的X.

1646
01:25:38,490 --> 01:25:39,640
那麼，什麼是星X你是否

1647
01:25:39,640 --> 01:25:44,300
再次，星x表示去
事情是X指向。

1648
01:25:44,300 --> 01:25:47,140
所以x被存儲為0x123去那。

1649
01:25:47,140 --> 01:25:48,490
我們得到了50。

1650
01:25:48,490 --> 01:25:50,540
因此，打印˚F的。

1651
01:25:50,540 --> 01:25:54,900
這意味著它要打印50。

1652
01:25:54,900 --> 01:25:56,850
然後返回。

1653
01:25:56,850 --> 01:25:58,340
>> 然後我們有了第二個printf。

1654
01:25:58,340 --> 01:25:59,370
我們現在百分之頁。

1655
01:25:59,370 --> 01:26:01,680
如果你還沒有看到它，這就是
只是你如何打印一個指針。

1656
01:26:01,680 --> 01:26:04,960
因此，我們有百分之一，百分之
f和所有那些已經是。

1657
01:26:04,960 --> 01:26:07,160
因此％的磷，打印一個指針。

1658
01:26:07,160 --> 01:26:08,920
>> 因此，x是一個指針。

1659
01:26:08,920 --> 01:26:13,440
所以，如果我們要打印的X本身，
我們正在打印什麼是真正的內部

1660
01:26:13,440 --> 01:26:19,220
x，它為0x123所以首
打印f被付印50。

1661
01:26:19,220 --> 01:26:23,620
第二印刷f的準備
打印0x123的呀？

1662
01:26:23,620 --> 01:26:27,460
>> 聽眾：你用百分比
X要打印的指針？

1663
01:26:27,460 --> 01:26:31,200
>> 羅伯：所以你用百分比
X要打印的指針？

1664
01:26:31,200 --> 01:26:38,350
所以，你可以，但百分之x是公正的，
概括而言，就像如果你有一些

1665
01:26:38,350 --> 01:26:40,325
整數，要打印
它作為一個十六進制數。

1666
01:26:40,325 --> 01:26:43,250

1667
01:26:43,250 --> 01:26:44,880
這只是你如何做到這一點。

1668
01:26:44,880 --> 01:26:47,160
>> 然而，百分比D會
打印為十進制。

1669
01:26:47,160 --> 01:26:50,310
這是我們得到的百分比
ð。 i是剛剛整數。

1670
01:26:50,310 --> 01:26:52,690
％的p是專
為指針。

1671
01:26:52,690 --> 01:26:54,060
>> 因此，x是一個指針。

1672
01:26:54,060 --> 01:26:56,360
我們要使用百分之頁。

1673
01:26:56,360 --> 01:26:57,937
但百分之x可能工作。

1674
01:26:57,937 --> 01:26:58,414
是嗎？

1675
01:26:58,414 --> 01:26:59,664
>> 聽眾：[聽不清]？

1676
01:26:59,664 --> 01:27:04,138

1677
01:27:04,138 --> 01:27:05,388
>> 羅伯：是啊。

1678
01:27:05,388 --> 01:27:07,870

1679
01:27:07,870 --> 01:27:13,440
至少在這個call--所以我
不包括在這裡。

1680
01:27:13,440 --> 01:27:19,850
不過，這兩種說法都必然
該堆棧幀中

1681
01:27:19,850 --> 01:27:23,040
以及任何局部變量
printf的碰巧使用。

1682
01:27:23,040 --> 01:27:27,020
然後下次調用printf的現在
printf的內部堆棧幀

1683
01:27:27,020 --> 01:27:33,960
％的p反斜杠n和不管
x值是，這是為0x123。

1684
01:27:33,960 --> 01:27:34,425
是嗎？

1685
01:27:34,425 --> 01:27:35,675
>> 聽眾：[聽不清]？

1686
01:27:35,675 --> 01:27:38,145

1687
01:27:38,145 --> 01:27:40,880
>> 羅伯：這將打印的東西
看起來是這樣的。

1688
01:27:40,880 --> 01:27:41,846
>> 聽眾：[聽不清]。

1689
01:27:41,846 --> 01:27:44,510
>> 羅伯：所以它打印它的地址表。

1690
01:27:44,510 --> 01:27:47,003
它看起來像一個地址。

1691
01:27:47,003 --> 01:27:47,494
是嗎？

1692
01:27:47,494 --> 01:27:49,458
>> 聽眾：[聽不清]？

1693
01:27:49,458 --> 01:27:51,075
>> 羅伯：為什麼呢？

1694
01:27:51,075 --> 01:27:52,920
>> 聽眾：[聽不清]？

1695
01:27:52,920 --> 01:27:55,240
>> 羅伯：這是為什麼指針4個字節？

1696
01:27:55,240 --> 01:27:58,500
因此，有一大堆
0的在這方面。

1697
01:27:58,500 --> 01:28:03,740
因此，它是真正0x0000000123。

1698
01:28:03,740 --> 01:28:06,510
在64位系統上，將有
一大堆的多個零。

1699
01:28:06,510 --> 01:28:11,410

1700
01:28:11,410 --> 01:28:11,900
是嗎？

1701
01:28:11,900 --> 01:28:13,150
>> 聽眾：[聽不清]。

1702
01:28:13,150 --> 01:28:17,290

1703
01:28:17,290 --> 01:28:21,130
>> 羅伯：所以第一個printf
將要print--

1704
01:28:21,130 --> 01:28:21,980
>> 聽眾：[聽不清]。

1705
01:28:21,980 --> 01:28:24,420
>> 羅伯：是的，這是怎麼回事打印
x的值指向。

1706
01:28:24,420 --> 01:28:27,030

1707
01:28:27,030 --> 01:28:29,070
明星說：這是什麼
事指向。

1708
01:28:29,070 --> 01:28:30,300
抓住它。

1709
01:28:30,300 --> 01:28:31,455
那麼什麼是指向？

1710
01:28:31,455 --> 01:28:31,850
50。

1711
01:28:31,850 --> 01:28:32,410
抓住它。

1712
01:28:32,410 --> 01:28:33,390
這就是我們將要打印。

1713
01:28:33,390 --> 01:28:37,020
然而，下一個，我們
剛剛打印X本身。

1714
01:28:37,020 --> 01:28:38,850
什麼是f裡面？

1715
01:28:38,850 --> 01:28:43,710
為0x123。

1716
01:28:43,710 --> 01:28:44,500
行。

1717
01:28:44,500 --> 01:28:46,620
>> 然後，終於，我們有自由。

1718
01:28:46,620 --> 01:28:48,040
什麼是我們傳遞給釋放？

1719
01:28:48,040 --> 01:28:49,470
我們傳遞的X.

1720
01:28:49,470 --> 01:28:52,380
那個時候我居然顯示
它的堆棧幀。

1721
01:28:52,380 --> 01:28:56,370
>> 所以我們傳遞的價值
0x123的釋放。

1722
01:28:56,370 --> 01:28:59,070
所以，現在免費知道，沒事的，
我必須去到堆

1723
01:28:59,070 --> 01:29:00,050
自由內存。

1724
01:29:00,050 --> 01:29:03,920
它不再使用的是什麼
在地址為0x123。

1725
01:29:03,920 --> 01:29:07,010
>> 所以，自由即將推出
從堆。

1726
01:29:07,010 --> 01:29:09,490
現在，我們的堆是空的了。

1727
01:29:09,490 --> 01:29:11,120
我們沒有內存洩漏。

1728
01:29:11,120 --> 01:29:12,940
現在免費將返回。

1729
01:29:12,940 --> 01:29:16,130
注意，x是仍然為0x123。

1730
01:29:16,130 --> 01:29:18,240
不過，現在是不是有效的內存。

1731
01:29:18,240 --> 01:29:21,220

1732
01:29:21,220 --> 01:29:23,986
我們不再提領的X.

1733
01:29:23,986 --> 01:29:24,440
是嗎？

1734
01:29:24,440 --> 01:29:27,240
>> 聽眾：是返回0冗餘？

1735
01:29:27,240 --> 01:29:28,290
>> 羅伯：是returen 0冗餘？

1736
01:29:28,290 --> 01:29:31,110
是的。

1737
01:29:31,110 --> 01:29:33,950
我們只是把有原因
我們有一個空氣回流之一。

1738
01:29:33,950 --> 01:29:36,830
所以，這就像，嗯，讓
包括返回0。

1739
01:29:36,830 --> 01:29:37,310
是嗎？

1740
01:29:37,310 --> 01:29:38,560
>> 聽眾：[聽不清]？

1741
01:29:38,560 --> 01:29:42,110

1742
01:29:42,110 --> 01:29:45,580
>> 羅伯：所以免費後X，如果發生了什麼
我們嘗試取消引用指針？

1743
01:29:45,580 --> 01:29:47,240
這有可能是萬無一失。

1744
01:29:47,240 --> 01:29:49,330
這是可能的，我們還是會得到50。

1745
01:29:49,330 --> 01:29:53,590
>> 這是可能的，也即該內存
現在正在使用的東西。

1746
01:29:53,590 --> 01:29:57,140
所以這是不確定的行為。

1747
01:29:57,140 --> 01:30:00,772
和未定義意味著什麼
可能發生。

1748
01:30:00,772 --> 01:30:01,250
是嗎？

1749
01:30:01,250 --> 01:30:02,500
>> 聽眾：[聽不清]？

1750
01:30:02,500 --> 01:30:07,942

1751
01:30:07,942 --> 01:30:10,830
>> 羅伯：無，因此，如果您指定
X要別的東西。

1752
01:30:10,830 --> 01:30:15,870
所以，如果在這裡我們說的x等於
malloc的東西else--

1753
01:30:15,870 --> 01:30:17,100
malloc的大小event--

1754
01:30:17,100 --> 01:30:20,180
那麼原來的塊
內存不釋放。

1755
01:30:20,180 --> 01:30:21,490
我們已經正式失去了它。

1756
01:30:21,490 --> 01:30:23,150
這是一個內存洩漏。

1757
01:30:23,150 --> 01:30:25,090
我們已經失去了所有的引用
到存儲器塊。

1758
01:30:25,090 --> 01:30:26,827
所以沒有辦法，我們可以不斷釋放它。

1759
01:30:26,827 --> 01:30:32,074

1760
01:30:32,074 --> 01:30:36,630
好了，再回到0來完成。

1761
01:30:36,630 --> 01:30:37,900
>> 好吧，那麼堆棧溢出。

1762
01:30:37,900 --> 01:30:39,320
這裡有什麼想法？

1763
01:30:39,320 --> 01:30:41,210
所以請記住，堆正在下降。

1764
01:30:41,210 --> 01:30:43,480
堆棧是怎麼回事了。

1765
01:30:43,480 --> 01:30:48,000
因此，這是從演講的例子，
我認為，其中主要的是只是要

1766
01:30:48,000 --> 01:30:51,380
調用此函數foo，這是怎麼回事
遞歸調用自身過去，

1767
01:30:51,380 --> 01:30:52,320
一遍。

1768
01:30:52,320 --> 01:30:55,370
>> 所以堆棧幀要
工作完全相同。

1769
01:30:55,370 --> 01:30:58,130
所以，我們要開始主
作為底部堆棧幀。

1770
01:30:58,130 --> 01:31:02,000
然後主要是要調用foo，這
會得到一個堆棧幀。

1771
01:31:02,000 --> 01:31:04,260
>> 然後，富是要調用foo
再次，這是會得到

1772
01:31:04,260 --> 01:31:05,500
另一個堆棧幀。

1773
01:31:05,500 --> 01:31:08,270
然後又一次，又一次，又一次，
又一次，直到最後，我們運行

1774
01:31:08,270 --> 01:31:09,190
入堆。

1775
01:31:09,190 --> 01:31:11,990
因此，這是我們如何得到
堆棧溢出。

1776
01:31:11,990 --> 01:31:14,910
在這一點上，你賽格故障。

1777
01:31:14,910 --> 01:31:17,335
或者你真的賽格故障前
這一點上，卻是的。

1778
01:31:17,335 --> 01:31:19,660
>> 聽眾：是核心轉儲
同賽格錯嗎？

1779
01:31:19,660 --> 01:31:26,140
>> 羅伯：所以你會看到分割
故障的核心轉儲。

1780
01:31:26,140 --> 01:31:28,760
你會得到一個核心轉儲時，
你賽格故障。

1781
01:31:28,760 --> 01:31:32,580
它就像所有的轉儲
您當前內存的內容，以便

1782
01:31:32,580 --> 01:31:36,670
你可以嘗試找出
為什麼你賽格故障。

1783
01:31:36,670 --> 01:31:37,135
是嗎？

1784
01:31:37,135 --> 01:31:38,385
>> 聽眾：[聽不清]？

1785
01:31:38,385 --> 01:31:40,855

1786
01:31:40,855 --> 01:31:45,460
>> 羅伯：所以分段錯誤方式
有一個堆棧溢出。

1787
01:31:45,460 --> 01:31:47,060
所以不一定。

1788
01:31:47,060 --> 01:31:49,880
段錯誤意味著你
觸摸記憶的方式

1789
01:31:49,880 --> 01:31:50,880
你不應該。

1790
01:31:50,880 --> 01:31:54,750
使發生的一種方式是，當
您堆棧溢出，我們開始觸摸

1791
01:31:54,750 --> 01:31:58,736
記憶體的方式，我們不應該。

1792
01:31:58,736 --> 01:31:59,208
是嗎？

1793
01:31:59,208 --> 01:32:00,458
>> 聽眾：[聽不清]？

1794
01:32:00,458 --> 01:32:03,456

1795
01:32:03,456 --> 01:32:05,830
>> 羅伯：所以的無限循環中。

1796
01:32:05,830 --> 01:32:08,770
喜歡，這就像一個無限遞歸
循環，所以我們得到另一個

1797
01:32:08,770 --> 01:32:09,770
堆棧每個時間幀。

1798
01:32:09,770 --> 01:32:13,540
只是裡面的一個普通
無限的，而埃德蒙頓

1799
01:32:13,540 --> 01:32:16,390
好了，讓我們甚至沒有打印F--

1800
01:32:16,390 --> 01:32:17,040
做一些事情。

1801
01:32:17,040 --> 01:32:18,390
不管。

1802
01:32:18,390 --> 01:32:20,610
>> 我們不會將越來越
另一個堆棧幀。

1803
01:32:20,610 --> 01:32:22,530
我們只是要保持循環
在這個單指令。

1804
01:32:22,530 --> 01:32:23,920
堆棧沒有增長。

1805
01:32:23,920 --> 01:32:27,290
這是事實，每個遞歸
電話是給了我們一個堆棧幀。

1806
01:32:27,290 --> 01:32:31,231
這就是為什麼我們得到一個堆棧溢出。

1807
01:32:31,231 --> 01:32:31,728
是嗎？

1808
01:32:31,728 --> 01:32:38,189
>> 聽眾：如果你說得到
while循環，然後按[聽不清]？

1809
01:32:38,189 --> 01:32:42,000
>> 羅伯：所以，如果內部的while循環
有一個printf，你仍然會

1810
01:32:42,000 --> 01:32:42,790
不賽格故障。

1811
01:32:42,790 --> 01:32:46,090
我只是不希望的事情混淆。

1812
01:32:46,090 --> 01:32:46,610
它會循環。

1813
01:32:46,610 --> 01:32:48,225
你會得到一個堆棧
框架中的printf。

1814
01:32:48,225 --> 01:32:49,580
>> 隨後的printf會回來。

1815
01:32:49,580 --> 01:32:50,280
然後你再就不斷循環。

1816
01:32:50,280 --> 01:32:51,460
你會得到一個堆棧
框架中的printf。

1817
01:32:51,460 --> 01:32:52,850
它會回來。

1818
01:32:52,850 --> 01:32:54,060
單棧幀。

1819
01:32:54,060 --> 01:33:00,215
所以，你沒有得到這個無限
堆放堆棧幀。

1820
01:33:00,215 --> 01:33:03,185
>> 聽眾：[聽不清]？

1821
01:33:03,185 --> 01:33:04,040
>> 羅伯：是的。

1822
01:33:04,040 --> 01:33:09,360
所以這個堆棧溢出發生
因為沒有這些

1823
01:33:09,360 --> 01:33:11,600
調用富都回來了。

1824
01:33:11,600 --> 01:33:15,250
因此，如果我們回來，然後我們會
開始失去堆棧幀。

1825
01:33:15,250 --> 01:33:17,870
然後我們就不會堆棧溢出。

1826
01:33:17,870 --> 01:33:20,070
這就是為什麼你需要一個基本情況
為您的個人功能。

1827
01:33:20,070 --> 01:33:22,992

1828
01:33:22,992 --> 01:33:23,479
是嗎？

1829
01:33:23,479 --> 01:33:27,375
>> 聽眾：是對潛在的尺寸和
棧堆一樣的

1830
01:33:27,375 --> 01:33:29,880
所有的程序？

1831
01:33:29,880 --> 01:33:31,910
>> 羅伯：大約。

1832
01:33:31,910 --> 01:33:35,090
在堆疊的電勢的大小和
堆相同的所有項目？

1833
01:33:35,090 --> 01:33:37,180
粗略。

1834
01:33:37,180 --> 01:33:40,080
有一些隨機化
其中棧開始和

1835
01:33:40,080 --> 01:33:42,400
其中堆開始。

1836
01:33:42,400 --> 01:33:45,870
如果你碰巧有一大堆
全局變量和的事情，你可能

1837
01:33:45,870 --> 01:33:49,520
從一些空間帶走
你堆。

1838
01:33:49,520 --> 01:33:54,060
>> 在64位系統上，你幾乎
有無限懷念。

1839
01:33:54,060 --> 01:33:55,820
這裡還有這麼多。

1840
01:33:55,820 --> 01:33:59,250
之間的32位和64位，即
是顯著差。

1841
01:33:59,250 --> 01:34:02,350
>> 你會得到一大堆更多
在64位堆棧和堆空間

1842
01:34:02,350 --> 01:34:05,810
制度，因為只是多
解決了他們可以使用。

1843
01:34:05,810 --> 01:34:09,360
但單個系統上，它會
是一疊大約相同數量的

1844
01:34:09,360 --> 01:34:10,785
和堆空間。

1845
01:34:10,785 --> 01:34:13,635

1846
01:34:13,635 --> 01:34:15,530
好吧。

1847
01:34:15,530 --> 01:34:18,220
>> 所以最後一件事是編譯。

1848
01:34:18,220 --> 01:34:19,810
所以，你應該知道這個過程。

1849
01:34:19,810 --> 01:34:22,240
有四個大的步驟。

1850
01:34:22,240 --> 01:34:24,400
所以，第一個應該
很容易記住。

1851
01:34:24,400 --> 01:34:25,085
預處理。

1852
01:34:25,085 --> 01:34:28,390
它具有預先在它的前綴。

1853
01:34:28,390 --> 01:34:32,080
所以，說到一切之前。

1854
01:34:32,080 --> 01:34:34,000
>> 要記住的是哈希值。

1855
01:34:34,000 --> 01:34:37,250
因此，散列定義和散列包括
在所有這些的。

1856
01:34:37,250 --> 01:34:39,560
這些都是預處理器
指令。

1857
01:34:39,560 --> 01:34:42,030
這些事情了
預處理器需要照顧。

1858
01:34:42,030 --> 01:34:43,680
>> 那麼什麼是預處理器嗎？

1859
01:34:43,680 --> 01:34:44,850
這是一個非常愚蠢的事情。

1860
01:34:44,850 --> 01:34:49,380
所有它的能力是所有這些
複製和剪切和粘貼操作。

1861
01:34:49,380 --> 01:34:51,790
>> 因此，散列包括標準I0點小時。

1862
01:34:51,790 --> 01:34:52,990
那是什麼做的？

1863
01:34:52,990 --> 01:34:56,610
它抓住了標準I0點ħ
文件並將其粘貼到頂部

1864
01:34:56,610 --> 01:34:58,960
無論它說散列包括
標準I0點小時。

1865
01:34:58,960 --> 01:35:02,480
>> 和任何散列定義，我們已經
可見，那是什麼做的？

1866
01:35:02,480 --> 01:35:06,730
其複製的值的哈希
定義的被定義為和粘貼的

1867
01:35:06,730 --> 01:35:08,500
無論你使用的值。

1868
01:35:08,500 --> 01:35:13,400
所以預處理器少了點真的
基於簡單的文本操作。

1869
01:35:13,400 --> 01:35:15,870
它什麼都不聰明。

1870
01:35:15,870 --> 01:35:18,920
所以，一切是
更為複雜。

1871
01:35:18,920 --> 01:35:22,970
>> 所以，現在預處理器
完成後，我們實際編譯。

1872
01:35:22,970 --> 01:35:24,320
那麼，是什麼編制是什麼意思？

1873
01:35:24,320 --> 01:35:27,310
我們現在從C代碼中去
為彙編代碼。

1874
01:35:27,310 --> 01:35:27,570
是嗎？

1875
01:35:27,570 --> 01:35:28,820
>> 聽眾：[聽不清]？

1876
01:35:28,820 --> 01:35:32,390

1877
01:35:32,390 --> 01:35:34,220
>> 羅伯：是的，我們抓住了這一點。

1878
01:35:34,220 --> 01:35:36,880

1879
01:35:36,880 --> 01:35:38,660
所以編譯。

1880
01:35:38,660 --> 01:35:40,310
我們打算從C到裝配。

1881
01:35:40,310 --> 01:35:42,470
因此，這是一個實際的語言變化。

1882
01:35:42,470 --> 01:35:45,240
編譯本身就意味著從去
更高層次的語言

1883
01:35:45,240 --> 01:35:47,340
低層次的語言。

1884
01:35:47,340 --> 01:35:50,720
>> 和c是一個高層次的語言
相比於裝配。

1885
01:35:50,720 --> 01:35:52,320
什麼是組件？

1886
01:35:52,320 --> 01:35:56,440
它的指令是，相當
多了，做了你的CPU。

1887
01:35:56,440 --> 01:35:59,130
但是你的電腦仍然
不明白組裝。

1888
01:35:59,130 --> 01:36:01,570
這只能理解和0。

1889
01:36:01,570 --> 01:36:06,160
因此，下一步的組裝，這
使我們從這些指令

1890
01:36:06,160 --> 01:36:08,760
你的CPU的理解，實際上
它們翻譯，以

1891
01:36:08,760 --> 01:36:10,820
1和0。

1892
01:36:10,820 --> 01:36:13,570
>> 所以C到組裝成二進制。

1893
01:36:13,570 --> 01:36:15,870
但我沒有一個可執行的呢。

1894
01:36:15,870 --> 01:36:19,550
所以想CS50庫。

1895
01:36:19,550 --> 01:36:23,070
我們已經為您提供了二進制
這CS50庫，裡面有GetString的

1896
01:36:23,070 --> 01:36:24,400
和調用getInt和所有。

1897
01:36:24,400 --> 01:36:25,700
>> 但CS50 library--

1898
01:36:25,700 --> 01:36:27,650
在itself--和不可執行。

1899
01:36:27,650 --> 01:36:29,570
它不具有一個主函數。

1900
01:36:29,570 --> 01:36:32,230
這只是一堆二進制
您可以使用。

1901
01:36:32,230 --> 01:36:41,730
所以鏈接是我們如何把所有
這些不同的二進制文件

1902
01:36:41,730 --> 01:36:43,110
成實際的可執行文件。

1903
01:36:43,110 --> 01:36:45,900
一，你可以鍵入
點斜線點出來。

1904
01:36:45,900 --> 01:36:51,660
>> 因此，這是類似於文件，你
寫道： - 無論你的程序is--

1905
01:36:51,660 --> 01:36:53,620
塞瑟C點。

1906
01:36:53,620 --> 01:36:55,100
但現在它被編譯
下降到二進制。

1907
01:36:55,100 --> 01:36:56,480
所以塞瑟點O操作。

1908
01:36:56,480 --> 01:36:59,620
這是我們CS50庫二進制。

1909
01:36:59,620 --> 01:37:02,284
而且他們正在結合
成一個單一的可執行文件。

1910
01:37:02,284 --> 01:37:02,758
是嗎？

1911
01:37:02,758 --> 01:37:04,008
>> 聽眾：[聽不清]？

1912
01:37:04,008 --> 01:37:08,800

1913
01:37:08,800 --> 01:37:12,710
>> 羅伯：所以首先包括，記住，
哈希包括實際上是一個

1914
01:37:12,710 --> 01:37:13,810
預處理器步驟。

1915
01:37:13,810 --> 01:37:14,750
但是，這是不同的。

1916
01:37:14,750 --> 01:37:20,730
如果你不使用任何函數，
是你的單文件之外，那麼，

1917
01:37:20,730 --> 01:37:26,100
不，你不需要任何鏈接
因為你擁有了一切。

1918
01:37:26,100 --> 01:37:30,310
>> 這就是說，printf的被鏈接英寸

1919
01:37:30,310 --> 01:37:32,820
如果你用printf，這東西
需要在要鏈接

1920
01:37:32,820 --> 01:37:35,740
因為你沒寫。

1921
01:37:35,740 --> 01:37:39,530
並且，實際上，printf的是自動
在聯繫。

1922
01:37:39,530 --> 01:37:42,760
你知道如何在命令行或者當
你鍵入make，你看它有

1923
01:37:42,760 --> 01:37:46,690
破折號升CS50，它有鏈接
在CS50的圖書館？

1924
01:37:46,690 --> 01:37:49,070
printf的，和類似的東西，是怎麼回事
將自動鏈接的。

1925
01:37:49,070 --> 01:37:51,730

1926
01:37:51,730 --> 01:37:53,930
在任何其它的問題嗎？

1927
01:37:53,930 --> 01:37:56,280
>> 聽眾：[聽不清]？

1928
01:37:56,280 --> 01:37:58,300
>> 羅伯：鏈接？

1929
01:37:58,300 --> 01:38:03,450
我們有一大堆
不同的二進制文件。

1930
01:38:03,450 --> 01:38:06,410
這就是典型的例子
我們用的是CS50庫。

1931
01:38:06,410 --> 01:38:09,960
我們已編制並提供給您的
二本CS50庫。

1932
01:38:09,960 --> 01:38:12,410
>> 您要使用的GetString
在你的程序。

1933
01:38:12,410 --> 01:38:14,750
所以，你去使用GetString的。

1934
01:38:14,750 --> 01:38:19,700
但是，如果沒有我的二進制代碼
GetString的，當你編譯你的代碼

1935
01:38:19,700 --> 01:38:23,140
下來，你不能真正運行
計劃，因為GetString的String是

1936
01:38:23,140 --> 01:38:25,080
尚未完全確定。

1937
01:38:25,080 --> 01:38:29,220
>> 只有當你在我的二進制鏈接
包含的GetString，現在，所有的

1938
01:38:29,220 --> 01:38:31,130
沒錯，其實我可以
執行GetString的。

1939
01:38:31,130 --> 01:38:32,330
我的文件是完整的。

1940
01:38:32,330 --> 01:38:34,208
我可以運行了。

1941
01:38:34,208 --> 01:38:34,697
是嗎？

1942
01:38:34,697 --> 01:38:37,631
>> 聽眾：是否鏈接轉換
二進制文件到可執行？

1943
01:38:37,631 --> 01:38:42,032
所以，即使你沒有其他
圖書館，是不是仍然是

1944
01:38:42,032 --> 01:38:44,477
要翻譯
在[聽不清]？

1945
01:38:44,477 --> 01:38:48,640
>> 羅伯：所以可執行
仍然是二進制。

1946
01:38:48,640 --> 01:38:51,750
它只是結合了全
一串二進制文件。

1947
01:38:51,750 --> 01:38:55,124

1948
01:38:55,124 --> 01:38:56,591
>> 聽眾：非常感謝你。

1949
01:38:56,591 --> 01:38:58,560
>> 羅伯：沒問題。

1950
01:38:58,560 --> 01:38:59,540
還有沒有其他問題？

1951
01:38:59,540 --> 01:39:02,001
否則，我們的所有設置。

1952
01:39:02,001 --> 01:39:02,690
好吧。

1953
01:39:02,690 --> 01:39:02,990
謝謝。

1954
01:39:02,990 --> 01:39:03,590
>> [掌聲]

1955
01:39:03,590 --> 01:39:04,490
>> 聽眾：謝謝。

1956
01:39:04,490 --> 01:39:05,740
>> 羅伯：是啊。

1957
01:39:05,740 --> 01:39:06,582