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

2
00:00:11,280 --> 00:00:13,650
>> 揚聲器1：所有權利。

3
00:00:13,650 --> 00:00:14,390
歡迎回來。

4
00:00:14,390 --> 00:00:19,260
這是第二週的CS50，我們有
迄今已使用的功能，但

5
00:00:19,260 --> 00:00:20,830
很大程度上他們是理所當然的。

6
00:00:20,830 --> 00:00:23,430
其中有，我們用printf
印刷的副作用

7
00:00:23,430 --> 00:00:24,110
在屏幕上的東西。

8
00:00:24,110 --> 00:00:25,790
我們已經用得到詮釋，獲得浮動。

9
00:00:25,790 --> 00:00:29,230
>> 但是如果你要創建
你自己的功能，因為有些

10
00:00:29,230 --> 00:00:31,740
你可能已經開始
做習題集，雖然

11
00:00:31,740 --> 00:00:33,140
不嚴格要求？

12
00:00:33,140 --> 00:00:37,150
好吧，讓我們繼續前進，並重新
只是要求用戶問題

13
00:00:37,150 --> 00:00:40,660
他們的名字和印刷上的東西
屏幕上，但嘗試分解出一些

14
00:00:40,660 --> 00:00:44,000
我們的共性
迄今為止，在我們的代碼中看到。

15
00:00:44,000 --> 00:00:45,120
所以，我的意思是下面。

16
00:00:45,120 --> 00:00:47,315
>> 我要繼續前進，並創建
一個新的程序，只需調用

17
00:00:47,315 --> 00:00:49,320
它HELLO.C像往常一樣。

18
00:00:49,320 --> 00:00:53,730
我要繼續前進，給自己
包括標準io.h在頂部。

19
00:00:53,730 --> 00:00:57,040
我打算也給自己
先發製人CS50庫，以便

20
00:00:57,040 --> 00:00:59,080
我不會在由編譯器大叫。

21
00:00:59,080 --> 00:01:02,400
現在我要繼續前進
聲明I​​NT為主，無效。

22
00:01:02,400 --> 00:01:09,020
>> 然後在這裡，這是我想要的地方
開始外包功能

23
00:01:09,020 --> 00:01:12,090
我本人的一些其他功能
會寫，但不

24
00:01:12,090 --> 00:01:13,820
目前存在。

25
00:01:13,820 --> 00:01:19,210
例如，假設我想
寫一個函數，讓我

26
00:01:19,210 --> 00:01:23,830
打印出來打招呼，逗號和
然後一些用戶的名稱。

27
00:01:23,830 --> 00:01:29,010
而不是繼​​續做的printf
你好，％，豈不是很好，如果

28
00:01:29,010 --> 00:01:33,380
只是有一個函數調用
printf的，但打印的名字嗎？

29
00:01:33,380 --> 00:01:36,600
>> 所以，換句話說，我希望能夠
寫一個程序，確實有點

30
00:01:36,600 --> 00:01:37,710
這樣的事情。

31
00:01:37,710 --> 00:01:42,070
首先，我要去說的printf
名，從而提示用戶

32
00:01:42,070 --> 00:01:46,150
他或她的名字給我，然後我
使用熟悉的字符串s

33
00:01:46,150 --> 00:01:47,290
聲明一個字符串。

34
00:01:47,290 --> 00:01:50,420
給我一個字符串類型的變量，
它s，存儲在該

35
00:01:50,420 --> 00:01:52,120
導致調用get字符串。

36
00:01:52,120 --> 00:01:56,060
但是，現在在過去的幾週，我將不得不
有些不厭其煩地做了個招呼，S / N。

37
00:01:56,060 --> 00:01:58,630

38
00:01:58,630 --> 00:02:02,570
>> 換句話說，我們已經看到了這
例如一堆的時候，它是一個

39
00:02:02,570 --> 00:02:05,280
簡單的例子，因為只存在一個
行代碼，所以它真的不是一個

40
00:02:05,280 --> 00:02:06,860
大不了再次鍵入。

41
00:02:06,860 --> 00:02:09,990
但是，假如這行代碼
實際上成為一種負擔，而

42
00:02:09,990 --> 00:02:12,900
它不是一個代碼行，但它的10
行代碼從現在開始的幾個星期，

43
00:02:12,900 --> 00:02:15,190
你只是累
複製和粘貼或

44
00:02:15,190 --> 00:02:17,180
重新輸入相同的代碼。

45
00:02:17,180 --> 00:02:22,100
那豈不是很好的，而不是做
printf的招呼，％s和等等，

46
00:02:22,100 --> 00:02:26,500
那豈不是很好，如果有剛
一個函數調用打印名稱

47
00:02:26,500 --> 00:02:27,560
需要一個參數 - 

48
00:02:27,560 --> 00:02:29,120
換句話說，它需要輸入 - 

49
00:02:29,120 --> 00:02:30,620
然後分號。

50
00:02:30,620 --> 00:02:33,240
所以這個功能，它不會
是很好，如果存在？

51
00:02:33,240 --> 00:02:36,690
然後，我就不必擔心
printf是什麼，％s和所有

52
00:02:36,690 --> 00:02:39,400
這些複雜
不是所有的，有趣的。

53
00:02:39,400 --> 00:02:40,570
它們是有用的。

54
00:02:40,570 --> 00:02:44,700
>> 因此，打印的名字，可惜，是不是
發明了40多年以前。

55
00:02:44,700 --> 00:02:45,980
沒有人想到把它寫。

56
00:02:45,980 --> 00:02:48,300
但是，這有一個美
編程語言，就像在

57
00:02:48,300 --> 00:02:52,930
從頭開始，您可以自定義塊，所以
在C和大部分的語言，你能

58
00:02:52,930 --> 00:02:57,260
定義自己的功能，
您可以定義自己的函數。

59
00:02:57,260 --> 00:03:01,710
因此，即使我們得到主要由
自動免費的，我們可以聲明

60
00:03:01,710 --> 00:03:02,730
我們自己的函數。

61
00:03:02,730 --> 00:03:05,670
>> 所以我要在這裡做出一些房間
向上頂，我要聲明我

62
00:03:05,670 --> 00:03:08,210
自己的功能，去尋找一個
有點奇怪，但我們還會回來

63
00:03:08,210 --> 00:03:09,400
回此之前長。

64
00:03:09,400 --> 00:03:12,310
我會說作廢，從而
說明這個函數的

65
00:03:12,310 --> 00:03:16,040
的東西，會產生副作用，但是它
不回我的東西在

66
00:03:16,040 --> 00:03:18,810
同樣的方式，得到int或
得到字符串本身。

67
00:03:18,810 --> 00:03:22,450
我要去給這個函數
命名打印的名字，我要

68
00:03:22,450 --> 00:03:26,470
這傢伙是要採取指定
一個字符串，我要那個叫

69
00:03:26,470 --> 00:03:27,600
字符串名稱。

70
00:03:27,600 --> 00:03:32,100
我可以打電話給我想要的任何東西，但我
希望我的代碼是自我描述。

71
00:03:32,100 --> 00:03:34,770
換句話說，如果一個你
打開這個文件，讀它，你可以

72
00:03:34,770 --> 00:03:39,020
由此推斷那名排序
輸入它應該扮演什麼樣的角色。

73
00:03:39,020 --> 00:03:42,270
>> 低於現在，我要打開
大括號和封閉的大括號，

74
00:03:42,270 --> 00:03:47,140
等注意到我一直遵循相同的
圖案上線四到七個

75
00:03:47,140 --> 00:03:51,622
我一直在關注一個好星期加
現在之間，說，行九

76
00:03:51,622 --> 00:03:53,400
14這主要組成。

77
00:03:53,400 --> 00:03:56,160
換句話說，打印名稱
是另一種功能。

78
00:03:56,160 --> 00:03:58,990
現在，編譯器是不會知道的
自動調用這個事情，

79
00:03:58,990 --> 00:04:02,670
因為我真的只是發明了它，
但它仍然會知道調用main

80
00:04:02,670 --> 00:04:08,710
自動，然後當然是在
13號線，我要求我自己的函數。

81
00:04:08,710 --> 00:04:12,805
因為我已經聲明了函數
上四個主前行，

82
00:04:12,805 --> 00:04:16,579
這是怎麼回事教編譯器
什麼報價，引文結束，“打印名稱”

83
00:04:16,579 --> 00:04:18,140
意味著它應該做的。

84
00:04:18,140 --> 00:04:22,700
所以我給它一個新的自定義排序
阻塞的背景下，說，劃傷。

85
00:04:22,700 --> 00:04:27,240
>> 所以在這裡，我可以把這些很常見
或反复出現的模式的代碼，我把

86
00:04:27,240 --> 00:04:32,300
寫在課堂上的printf
％s的招呼，S / N“ - 

87
00:04:32,300 --> 00:04:36,720

88
00:04:36,720 --> 00:04:37,590
我希望把這裡什麼呢？

89
00:04:37,590 --> 00:04:39,200
S·

90
00:04:39,200 --> 00:04:41,420
所以我想在此上下文中。

91
00:04:41,420 --> 00:04:43,440
因此，發現這裡有點二分法。

92
00:04:43,440 --> 00:04:47,680
因為我聲明我自己的函數
我已經有點隨意地被稱為

93
00:04:47,680 --> 00:04:50,880
它打印的名稱，因為我
括號中指定

94
00:04:50,880 --> 00:04:55,035
函數有一個參數的類型
這是一個字符串 - 所以它是一個字

95
00:04:55,035 --> 00:05:00,010
或短語或類似的東西 - 
我打電話來，這樣的說法的名字，那

96
00:05:00,010 --> 00:05:04,770
意味著這是唯一的變量
範圍，可以這麼說，是名。

97
00:05:04,770 --> 00:05:07,780
>> S只之間存在著哪兩個
花括號，當然？

98
00:05:07,780 --> 00:05:12,990
真是好啊，就像10號線通過
14，所以只是想在週一不能使用

99
00:05:12,990 --> 00:05:17,650
S，但是我能做的就是傳遞
將S打印的名字。

100
00:05:17,650 --> 00:05:21,030
打印的名字，只是恰巧給它
一個別名，同義詞，一個綽號，

101
00:05:21,030 --> 00:05:24,400
調用它的名稱，現在
在此行中使用它。

102
00:05:24,400 --> 00:05:26,840
所以，現在讓我再去救，縮小。

103
00:05:26,840 --> 00:05:31,250
>> 讓我繼續前進，使打招呼。

104
00:05:31,250 --> 00:05:32,400
看起來不錯。

105
00:05:32,400 --> 00:05:36,110
也吐不出來任何錯誤。
/你好輸入。

106
00:05:36,110 --> 00:05:37,020
我叫什麼名字？

107
00:05:37,020 --> 00:05:38,060
大衛。

108
00:05:38,060 --> 00:05:39,270
和打招呼大衛。

109
00:05:39,270 --> 00:05:41,820
所以，不是所有的精彩，
只是覺得現在。

110
00:05:41,820 --> 00:05:44,310
現在你有相同的成分
就像我們在划痕

111
00:05:44,310 --> 00:05:45,420
使我們自己的函數。

112
00:05:45,420 --> 00:05:46,770
>> 但有一點的疑難雜症。

113
00:05:46,770 --> 00:05:50,620
假設我真的沒有想過
這，其實我沒有

114
00:05:50,620 --> 00:05:54,250
真正思考它寫道：
該功能在這裡。

115
00:05:54,250 --> 00:05:55,420
感覺完全合理的。

116
00:05:55,420 --> 00:05:58,440
划痕有沒有概念
在腳本中的位置。

117
00:05:58,440 --> 00:06:00,670
你可以把一個在這裡，一起來這裡，
一起來這裡，它可能會開始

118
00:06:00,670 --> 00:06:03,310
看起來有點混亂，如果你不這樣做
整齊地躺在它，但它不

119
00:06:03,310 --> 00:06:05,910
無論身在何處，身體的腳本
屏幕上。

120
00:06:05,910 --> 00:06:09,660
不幸的是，在C  - ，這一點不像
Java和Python等語言

121
00:06:09,660 --> 00:06:13,600
和別人，你可能很熟悉
 - 不幸的是在C語言中，為了不

122
00:06:13,600 --> 00:06:15,830
不要緊，因為手錶是什麼
現在將要發生。

123
00:06:15,830 --> 00:06:19,010
>> 默認功能是怎麼回事
執行，當然是主力。

124
00:06:19,010 --> 00:06:22,290
主要是要調用print名
線八條，但遺憾的是，

125
00:06:22,290 --> 00:06:26,660
編譯器甚至不知道該打印名稱
存在，直到它到達11號線，

126
00:06:26,660 --> 00:06:28,520
不幸的是，
將是為時已晚。

127
00:06:28,520 --> 00:06:30,660
因此，讓我們做你好。

128
00:06:30,660 --> 00:06:32,950
該死的，產生的兩個錯誤。

129
00:06:32,950 --> 00:06:36,050
所以，現在讓我向上滾動到非常
首先，我們應該總是做，

130
00:06:36,050 --> 00:06:39,560
注意到我大喊大叫，
“隱式聲明函數

131
00:06:39,560 --> 00:06:40,540
打印的名字。“

132
00:06:40,540 --> 00:06:43,860
>> 因此，我們已經看到了這條消息之前，
隱函數聲明。

133
00:06:43,860 --> 00:06:48,080
當我們看到這樣的錯誤呢？

134
00:06:48,080 --> 00:06:49,180
當我沒有包括一個圖書館。

135
00:06:49,180 --> 00:06:53,470
如果我忘記的cs50.h，我會得到
大聲呵斥在字符串或詮釋。

136
00:06:53,470 --> 00:06:56,880
但是，在這種情況下，該功能的打印
名字是不是在圖書館，對不對？

137
00:06:56,880 --> 00:07:00,230
嚴格地講，它在這個文件中，所以
什麼是真正的問題嗎？

138
00:07:00,230 --> 00:07:04,660
>> 不幸的是，在C語言中，它需要你
如此令人難以置信的字面意思，如果你

139
00:07:04,660 --> 00:07:08,640
要調用的函數的名稱打印
存在，你要么必須實現

140
00:07:08,640 --> 00:07:11,940
該功能在最上方，
代碼，以便降低它的訪問

141
00:07:11,940 --> 00:07:15,070
功能，但坦率地說，這將成為
草率的速度非常快。

142
00:07:15,070 --> 00:07:18,160
就個人而言，我喜歡把主第一
因為那是非常清楚這是什麼

143
00:07:18,160 --> 00:07:19,890
乍一看程序做。

144
00:07:19,890 --> 00:07:23,290
再加上，你可以進入奇怪的角落
情況下，如果x要調用

145
00:07:23,290 --> 00:07:27,530
y，但y進行調用，你只是
身體不能真正把一個

146
00:07:27,530 --> 00:07:28,540
在另一個的上面。

147
00:07:28,540 --> 00:07:31,230
>> 但事實證明，在C語言中，我們可以
解決這個問題很簡單。

148
00:07:31,230 --> 00:07:34,010
我要放一點點的空間
這裡，我只是去

149
00:07:34,010 --> 00:07:38,170
先發製人，儘管有些
冗餘，要教

150
00:07:38,170 --> 00:07:42,320
存在一個函數的編譯器
稱為打印名稱，它需要一個字符串，

151
00:07:42,320 --> 00:07:46,330
我要打電話
它命名分號。

152
00:07:46,330 --> 00:07:50,220
>> 所以現在第四行，這是我們
以前沒有見過，是一個聲明

153
00:07:50,220 --> 00:07:53,940
功能打印的名稱，但它是唯一的
一個承諾，這個函數會

154
00:07:53,940 --> 00:07:56,620
最終被定義，最終
得到實施。

155
00:07:56,620 --> 00:08:00,180
現在我可以獨自離開，因為
現在是這樣定義，

156
00:08:00,180 --> 00:08:04,090
實施，排序最後一公里
執行本

157
00:08:04,090 --> 00:08:05,130
特定的功能。

158
00:08:05,130 --> 00:08:08,450
所以，坦率地說，它是愚蠢的，這很煩人，
但是這是C的方式，它是

159
00:08:08,450 --> 00:08:12,050
因為它需要你很誇張
並且，作為一個計算機坦率地說應，

160
00:08:12,050 --> 00:08:16,020
只有不正是你告訴它
做什麼，因此，順序是很重要的。

161
00:08:16,020 --> 00:08:18,940
>> 所以記住這一點，並再次啟動
通知復發圖案。

162
00:08:18,940 --> 00:08:21,850
賠率是你願意，如果你還沒有
已經開始遇到消息

163
00:08:21,850 --> 00:08:24,700
這樣，乍一看似乎
完全隱秘的，但如果你開始

164
00:08:24,700 --> 00:08:29,000
看這些關鍵詞像
“隱式聲明”提到的

165
00:08:29,000 --> 00:08:32,380
在這種情況下，功能 - 坦率地說，你
有時甚至可以得到一個小綠

166
00:08:32,380 --> 00:08:35,010
胡蘿蔔符號，告訴你在哪裡
這個問題可能是 - 

167
00:08:35,010 --> 00:08:40,980
你就可以開始通過自己的方式工作
但看不見的錯誤消息。

168
00:08:40,980 --> 00:08:45,860
任何書面問題
這樣的功能？

169
00:08:45,860 --> 00:08:47,540
>> 讓我們做一些事情，這是一個
更引人注目的一點。

170
00:08:47,540 --> 00:08:51,760
而不是僅僅做的東西，有
打印的副作用，讓我去

171
00:08:51,760 --> 00:08:55,340
提前並保存新的文件，我們將
調用這positive.c，即使它是

172
00:08:55,340 --> 00:08:57,600
要有點不同
而最後一次。

173
00:08:57,600 --> 00:09:01,910
而這個時候，我想重新實現
最後一次的positive.C例如，

174
00:09:01,910 --> 00:09:04,430
強制用戶給
我的一個正整數。

175
00:09:04,430 --> 00:09:07,280
但我有使用INT一次。

176
00:09:07,280 --> 00:09:10,780
那豈不是一直很好，如果有
一個函數叫做正整數

177
00:09:10,780 --> 00:09:13,610
我可以只外包
一塊功能？

178
00:09:13,610 --> 00:09:16,480
所以，這裡的區別是，我們將
實施獲得正整數，但不像

179
00:09:16,480 --> 00:09:20,330
打印的名字，有一個副作用 - 
沒有返回的東西對我來說，

180
00:09:20,330 --> 00:09:21,710
一個數字或一個字符串 - 

181
00:09:21,710 --> 00:09:25,510
正整數，當然，要
，希望返回一個正整數。

182
00:09:25,510 --> 00:09:26,170
>> 因此，讓我們做到這一點。

183
00:09:26,170 --> 00:09:30,840
包括cs50.h，包括標準io.h.

184
00:09:30,840 --> 00:09:33,520
INT主要無效。

185
00:09:33,520 --> 00:09:42,160
現在在這裡，我要繼續前進
讓我們說，整型，叫它N，等於

186
00:09:42,160 --> 00:09:44,270
獲得正整數。

187
00:09:44,270 --> 00:09:49,080
就像INT已經存在
因為工作人員寫的，我要去

188
00:09:49,080 --> 00:09:53,950
承擔的那一刻得到
存在正整數，現在我要去

189
00:09:53,950 --> 00:09:57,730
繼續前進，說的printf，
％I / N“，N感謝。

190
00:09:57,730 --> 00:10:02,940

191
00:10:02,940 --> 00:10:07,770
>> 所以，現在如果我編這程序，
事情發生在我的終端

192
00:10:07,770 --> 00:10:09,075
在屏幕下方的窗口？

193
00:10:09,075 --> 00:10:11,580

194
00:10:11,580 --> 00:10:13,900
我去可能會得到，
像以前的同樣的錯誤。

195
00:10:13,900 --> 00:10:14,570
因此，讓我們試試這個。

196
00:10:14,570 --> 00:10:16,450
做出積極的。

197
00:10:16,450 --> 00:10:19,900
再次，隱式聲明
功能，正整數。

198
00:10:19,900 --> 00:10:21,970
因此，我們可以解決這個問題
一對夫婦的方式。

199
00:10:21,970 --> 00:10:27,310
我要保持它的簡單，只是
在這裡把我的聲明，並得到

200
00:10:27,310 --> 00:10:28,120
正整數。

201
00:10:28,120 --> 00:10:29,720
我需要的是所謂的簽名。

202
00:10:29,720 --> 00:10:32,410
簽名只是指
美學

203
00:10:32,410 --> 00:10:34,090
程序的第一行。

204
00:10:34,090 --> 00:10:37,420
所以，你應該得到積極
int返回？

205
00:10:37,420 --> 00:10:37,970
>> 所以一個int。

206
00:10:37,970 --> 00:10:41,540
我的意思是在理想情況下，它會返回
像正整數，但

207
00:10:41,540 --> 00:10:42,160
不存在。

208
00:10:42,160 --> 00:10:45,280
我們從來沒見過，在我們的數據
類型，所以我們必須要處理

209
00:10:45,280 --> 00:10:47,170
事實上，我們很少有
數據類型。

210
00:10:47,170 --> 00:10:50,360
但是，我們可以返回一個int和公正
我們相信，這將是積極的。

211
00:10:50,360 --> 00:10:52,690
這將被稱為
獲得正整數。

212
00:10:52,690 --> 00:10:55,122
>> 現在它的參數如何？

213
00:10:55,122 --> 00:10:56,440
是否採取任何輸入？

214
00:10:56,440 --> 00:10:58,280
是否需要任何輸入？

215
00:10:58,280 --> 00:11:00,900
因此，它並不需要知道
事先什麼。

216
00:11:00,900 --> 00:11:03,220
獲取字符串不，不詮釋。

217
00:11:03,220 --> 00:11:06,430
printf的 - 它需要有一定的
輸入傳遞給它 - 和打印名稱

218
00:11:06,430 --> 00:11:09,020
需要一些投入，但得到
沒有正整數。

219
00:11:09,020 --> 00:11:11,530
所以，我要明確地
告訴編譯器無效。

220
00:11:11,530 --> 00:11:13,470
虛空是沒有別的。

221
00:11:13,470 --> 00:11:17,990
因此，虛空裡面意味著什麼
這些括號，分號。

222
00:11:17,990 --> 00:11:20,840
>> 而現在在底部的我的文件 - 
再次，我只是一種肛門

223
00:11:20,840 --> 00:11:23,640
這裡將主要在頂部，
是很好的做法，因為這樣一來，

224
00:11:23,640 --> 00:11:26,220
任何時候你或其他人
打開你的文件，

225
00:11:26,220 --> 00:11:27,400
功能是正確的。

226
00:11:27,400 --> 00:11:29,660
您可以下潛從方。

227
00:11:29,660 --> 00:11:34,190
所以，現在我要重複這一點，
正整數無效，但我不

228
00:11:34,190 --> 00:11:35,430
打算現在打分號。

229
00:11:35,430 --> 00:11:38,280
我要打開大括號，
現在我需要借

230
00:11:38,280 --> 00:11:39,700
一些想法從週一。

231
00:11:39,700 --> 00:11:44,450
>> 所以當你還記得，我們​​做了一些
喜歡做以下，而

232
00:11:44,450 --> 00:11:45,830
東西是真實的。

233
00:11:45,830 --> 00:11:46,630
和我做了什麼？

234
00:11:46,630 --> 00:11:51,540
像給我做了一件
我的一個正整數，

235
00:11:51,540 --> 00:11:52,430
點點提示。

236
00:11:52,430 --> 00:11:53,540
我想，我可以用任何詞語。

237
00:11:53,540 --> 00:11:54,960
然後，我用什麼？

238
00:11:54,960 --> 00:11:59,530
INT N等於得到詮釋，
它沒有參數。

239
00:11:59,530 --> 00:12:00,550
>> 並注意到其中的差別。

240
00:12:00,550 --> 00:12:04,680
當你調用一個函數，當您使用
一個函數，你不把無效。

241
00:12:04,680 --> 00:12:08,570
你只有這樣做，當聲明
功能，教學的編譯器

242
00:12:08,570 --> 00:12:09,780
它應該期望。

243
00:12:09,780 --> 00:12:11,650
所以你不需要把
喪失自己有。

244
00:12:11,650 --> 00:12:12,940
>> 現在我的條件是什麼？

245
00:12:12,940 --> 00:12:19,670
中，n為不等於正，
但是這只是偽代碼。

246
00:12:19,670 --> 00:12:22,530
所以，我怎麼表達這種更乾淨？

247
00:12:22,530 --> 00:12:24,090
因此，小於或等於零。

248
00:12:24,090 --> 00:12:26,250
如此反复，發現你可以做
小於或等於。

249
00:12:26,250 --> 00:12:28,100
儘管這是兩個單獨的
符號，你可以做

250
00:12:28,100 --> 00:12:29,350
您的鍵盤等。

251
00:12:29,350 --> 00:12:33,950
>> 但仍然有一個缺陷，
我搞砸了最後一次了。

252
00:12:33,950 --> 00:12:36,950
我必須聲明 - 

253
00:12:36,950 --> 00:12:37,460
究竟。

254
00:12:37,460 --> 00:12:39,640
我必須聲明Ñ外
循環。

255
00:12:39,640 --> 00:12:44,180
因此，我需要n放在這裡，我不
想在這裡重新申報

256
00:12:44,180 --> 00:12:46,480
免得我得到了新的變數。

257
00:12:46,480 --> 00:12:48,860
我只是想在這裡指定一個值。

258
00:12:48,860 --> 00:12:54,320
>> 現在我不太在這裡完成。

259
00:12:54,320 --> 00:12:57,290
讓我提前獲得自己
和假裝我所做的。

260
00:12:57,290 --> 00:13:01,220
做出積極的，現在
有一個新的錯誤。

261
00:13:01,220 --> 00:13:04,550
控制已盡
非虛空功能。

262
00:13:04,550 --> 00:13:07,760
因此，新的錯誤消息，但如果你有種
梳理分開的話，

263
00:13:07,760 --> 00:13:09,620
可能暗示了什麼是錯的。

264
00:13:09,620 --> 00:13:11,240
>> 控制。

265
00:13:11,240 --> 00:13:14,250
控制只是意味著訂單
在程序的操作。

266
00:13:14,250 --> 00:13:16,510
在計算機的控制和
出事了。

267
00:13:16,510 --> 00:13:18,510
因此，到達結束
非void的函數。

268
00:13:18,510 --> 00:13:21,760
什麼樣的功能是它顯然
指什麼？

269
00:13:21,760 --> 00:13:24,790
非void什麼樣的功能？

270
00:13:24,790 --> 00:13:27,400
所以正整數，和一點點
混亂中那麼好，

271
00:13:27,400 --> 00:13:29,010
它是一種無效的。

272
00:13:29,010 --> 00:13:33,070
它有一個規範其無效
參數，但它的輸出要

273
00:13:33,070 --> 00:13:34,540
是n型。

274
00:13:34,540 --> 00:13:37,260
因此，在左邊的字是
所謂的返回類型。

275
00:13:37,260 --> 00:13:40,320
這裡的內側上的字
零個或多個參數

276
00:13:40,320 --> 00:13:41,970
一個函數具有。

277
00:13:41,970 --> 00:13:44,060
>> 所以，我需要做什麼？

278
00:13:44,060 --> 00:13:47,650
在這一點上，在我的代碼中，線21在那裡
閃爍提示現在是，我

279
00:13:47,650 --> 00:13:51,430
裡面有一個正整數
的變量名為N。

280
00:13:51,430 --> 00:13:55,200
我怎麼給它回到主？

281
00:13:55,200 --> 00:13:55,960
從字面上看。

282
00:13:55,960 --> 00:13:59,320
返回N分號。

283
00:13:59,320 --> 00:14:04,090
>> 因此，正如一塊科爾頓返回
我的答案紙，下降

284
00:14:04,090 --> 00:14:07,020
在小黑裙的那張紙
盒子放在桌子上，做到這一點

285
00:14:07,020 --> 00:14:10,100
代碼，你從字面上只寫，返回
N，彷彿科爾頓

286
00:14:10,100 --> 00:14:12,140
交給我東西物理回來。

287
00:14:12,140 --> 00:14:15,870
在這種情況下，發生了什麼
正整數是要交還

288
00:14:15,870 --> 00:14:19,220
什麼是大概是一個積極的
整數給誰呢？

289
00:14:19,220 --> 00:14:21,380
這價值在哪裡結束？

290
00:14:21,380 --> 00:14:29,080
在此變量中，結束了，正和
然後我們繼續與九號線。

291
00:14:29,080 --> 00:14:31,920
>> 因此，換句話說，為了
操作，這個程序將啟動

292
00:14:31,920 --> 00:14:34,430
執行和編譯器的實現，
哦，你希望庫？

293
00:14:34,430 --> 00:14:36,310
讓我去裡面搶什麼。

294
00:14:36,310 --> 00:14:37,750
哦，你要標準的IO庫？

295
00:14:37,750 --> 00:14:39,660
讓我去裡面搶什麼。

296
00:14:39,660 --> 00:14:44,510
編譯器對自己說什麼
當它擊中四線？

297
00:14:44,510 --> 00:14:47,980
哦，你答應落實
函數調用得到積極的，但

298
00:14:47,980 --> 00:14:50,820
我們會回來，後來，
沿著這些線路的東西。

299
00:14:50,820 --> 00:14:53,450
>> 詮釋主作廢只是意味著這裡
我的程序的膽量。

300
00:14:53,450 --> 00:14:54,990
7號線僅僅是一個大括號。

301
00:14:54,990 --> 00:14:59,540
八線是說在左，給
我的32位整數，叫了N。

302
00:14:59,540 --> 00:15:02,160
在右手側，它的
並稱獲得正整數。

303
00:15:02,160 --> 00:15:07,120
現在，讓我們暫停的故事，因為現在
我不要讓我的光標向下移動。

304
00:15:07,120 --> 00:15:11,720
我現在光標在這裡，因為下山
現在正整數執行。

305
00:15:11,720 --> 00:15:13,100
INT N聲明。

306
00:15:13,100 --> 00:15:14,040
做到以下幾點。

307
00:15:14,040 --> 00:15:16,090
printf的給了我一個正整數。

308
00:15:16,090 --> 00:15:19,740
>> 從用戶獲取一個int，它存儲在N，
也許這樣做一遍又一遍。

309
00:15:19,740 --> 00:15:23,010
這個循環意味著，這段代碼可能
執行向上和向下再這樣

310
00:15:23,010 --> 00:15:25,810
了，但最後，當用戶
合作，給了我一個積極的

311
00:15:25,810 --> 00:15:31,750
INT，我打了21號線，在這一點上
號交還，哪一個

312
00:15:31,750 --> 00:15:34,280
現在我應該突出？

313
00:15:34,280 --> 00:15:35,070
九。

314
00:15:35,070 --> 00:15:39,010
控制，可以這麼說，返回
九號線。

315
00:15:39,010 --> 00:15:40,650
這行現在負責。

316
00:15:40,650 --> 00:15:43,250
>> 所以，這就是已經發生的所有
引擎蓋下，但這次

317
00:15:43,250 --> 00:15:46,480
當我們使用的功能，如printf
或什至得到別人的串

318
00:15:46,480 --> 00:15:50,600
為你寫的，被移交控制
去別人的代碼行

319
00:15:50,600 --> 00:15:51,290
通過一行一行。

320
00:15:51,290 --> 00:15:53,770
這只是我們不能看到它，我們
真的無法描繪它在這

321
00:15:53,770 --> 00:15:57,620
在其他一些計劃，因為它
硬盤上的文件

322
00:15:57,620 --> 00:16:00,000
我們不知道。

323
00:16:00,000 --> 00:16:02,100
因此，讓我們實際編譯
並運行此。

324
00:16:02,100 --> 00:16:03,890
>> 做出積極的。

325
00:16:03,890 --> 00:16:05,260
編譯，這就是進步。

326
00:16:05,260 --> 00:16:06,650
/陽性。

327
00:16:06,650 --> 00:16:08,020
給我一個正整數。

328
00:16:08,020 --> 00:16:08,800
讓困難。

329
00:16:08,800 --> 00:16:10,430
負1。

330
00:16:10,430 --> 00:16:11,360
為零。

331
00:16:11,360 --> 00:16:13,370
讓我們給它50。

332
00:16:13,370 --> 00:16:18,100
感謝為50，所以控制
現在已回來了。

333
00:16:18,100 --> 00:16:21,750
任何問題，那麼，是什麼？

334
00:16:21,750 --> 00:16:23,180
是嗎？

335
00:16:23,180 --> 00:16:25,630
>> [聽不清]。

336
00:16:25,630 --> 00:16:26,130
>> 再說。

337
00:16:26,130 --> 00:16:27,860
哦，好問題。

338
00:16:27,860 --> 00:16:31,100
因此，您可能會注意到這裡的並行
我是那種上切割一個角落的。

339
00:16:31,100 --> 00:16:35,420
在第12行，我說，正整數
返回一個int，而是由相同的

340
00:16:35,420 --> 00:16:39,660
邏輯，按理說，在
六，行我說，主要的回報

341
00:16:39,660 --> 00:16:44,040
int，但是我們從來沒有什麼
在我們的節目呢？

342
00:16:44,040 --> 00:16:46,470
我們從來沒有提
這個關鍵字回報。

343
00:16:46,470 --> 00:16:49,970
>> 因此，原來，在C，至少
我們使用的版本

344
00:16:49,970 --> 00:16:55,750
在1999年，在技術上，這是
自動為您發生。

345
00:16:55,750 --> 00:16:59,300
每當你執行一個程序，你
實現一個叫做main的函數，

346
00:16:59,300 --> 00:17:04,230
該函數將返回零
默認情況下，如果你不說，否則，

347
00:17:04,230 --> 00:17:05,849
和零僅僅是一個慣例。

348
00:17:05,849 --> 00:17:09,430
世界返回零，從而
表示，一切都很好，

349
00:17:09,430 --> 00:17:13,040
有效地離開我們四億元
可能的事情，可以去

350
00:17:13,040 --> 00:17:17,530
錯了，所以，如果我們回到一個，那
可能意味著一個代碼，這意味著

351
00:17:17,530 --> 00:17:18,310
事情出了錯。

352
00:17:18,310 --> 00:17:20,589
我們可以返回兩個，這意味著
這個其他的東西出了問題。

353
00:17:20,589 --> 00:17:23,440
我們可以回到四億元，
這意味著其他的事情出了錯。

354
00:17:23,440 --> 00:17:27,170
>> 而如果你現在想想你自己
PC或Mac，你可能還記得，

355
00:17:27,170 --> 00:17:29,610
有時你會得到神秘的錯誤信息
從你的軟件

356
00:17:29,610 --> 00:17:32,650
使用，有時它也有一個人
友好的描述，但有

357
00:17:32,650 --> 00:17:35,265
通常是一個代碼或數
在屏幕上？

358
00:17:35,265 --> 00:17:37,800
如果這不浮現在腦海中，
只要保持眼睛。

359
00:17:37,800 --> 00:17:40,790
這是典型的這是什麼意思
代碼。

360
00:17:40,790 --> 00:17:44,200
他們包括在Microsoft Word和
其他程序，因此，如果你提交

361
00:17:44,200 --> 00:17:48,850
與該公司的錯誤報告，你可以
告訴他們，哦，我得到了錯誤號碼45。

362
00:17:48,850 --> 00:17:51,750
一些程序員在公司後面
可以看一下，在他或她

363
00:17:51,750 --> 00:17:54,940
代碼和說，哦，那是因為我做了
這個錯誤，這就是為什麼用戶

364
00:17:54,940 --> 00:17:56,240
得到這個消息。

365
00:17:56,240 --> 00:17:59,490
>> 但坦率地說，它只是一個小
分心和有點乏味

366
00:17:59,490 --> 00:18:02,130
得出這樣的結論，至少在我們的
前幾個節目，所以我們

367
00:18:02,130 --> 00:18:02,970
被省略它。

368
00:18:02,970 --> 00:18:07,450
但是，這一切的時候你的每一個
功能主要有偷偷

369
00:18:07,450 --> 00:18:11,600
行自動為你添加
編譯器，只是按照慣例

370
00:18:11,600 --> 00:18:13,172
為您節省一些時間。

371
00:18:13,172 --> 00:18:14,620
>> [聽不清]。

372
00:18:14,620 --> 00:18:16,250
>> 你不需要把它包括在主。

373
00:18:16,250 --> 00:18:16,700
這很好。

374
00:18:16,700 --> 00:18:20,260
你需要包括它，如果你是
實現這樣的功能。

375
00:18:20,260 --> 00:18:22,850
否則，函數平面
出是行不通的。

376
00:18:22,850 --> 00:18:24,480
但在主要的，這是沒有必要的。

377
00:18:24,480 --> 00:18:28,450
在一個或兩個星期，我們會開始得到
這種習慣一旦我們要開始

378
00:18:28,450 --> 00:18:29,690
標誌著錯誤。

379
00:18:29,690 --> 00:18:32,550
真是個好問題。

380
00:18:32,550 --> 00:18:36,880
>> 這麼快口頭休息一提的是
這個星期五​​，我們不會吃午飯

381
00:18:36,880 --> 00:18:39,980
本身，而是我們將有一起吃飯
一些學生和工作人員。

382
00:18:39,980 --> 00:18:42,940
如果您想加入我們，感受
自由去cs50.net/rsvp。

383
00:18:42,940 --> 00:18:45,030
這個星期五​​下午6:00。

384
00:18:45,030 --> 00:18:47,990
空間總是有限的，但我們會
繼續做這些近

385
00:18:47,990 --> 00:18:51,420
每週的基礎上，如果空間
用完這個星期。

386
00:18:51,420 --> 00:18:56,160
>> 所以峭壁吊鉤，我們離開
週一是字符串實際上

387
00:18:56,160 --> 00:19:00,520
被索引到，這只是意味著你
可以得到的第一個字符，

388
00:19:00,520 --> 00:19:03,770
第二個字符，第三個字符
等等，因為你可以

389
00:19:03,770 --> 00:19:07,860
有效想到一個字符串，如
你好，在這種情況下，五

390
00:19:07,860 --> 00:19:09,670
箱子裡面的字母。

391
00:19:09,670 --> 00:19:13,370
你可以在每個人
箱子用什麼語法我們

392
00:19:13,370 --> 00:19:15,230
上週一推出？

393
00:19:15,230 --> 00:19:16,760
這些方括號
鍵盤上的。

394
00:19:16,760 --> 00:19:18,980
只是到零的位置。

395
00:19:18,980 --> 00:19:22,840
>> 我們開始計數為零，所以支架
零標誌著支架一小時，

396
00:19:22,840 --> 00:19:25,170
標誌著E，等等。

397
00:19:25,170 --> 00:19:28,490
等等一切的時候，我們已經
使用字符串，輸入“你好”

398
00:19:28,490 --> 00:19:31,250
和“世界”和其他的東西
屏幕上，它被存儲

399
00:19:31,250 --> 00:19:32,820
這樣在箱子裡。

400
00:19:32,820 --> 00:19:33,370
並採取了猜測。

401
00:19:33,370 --> 00:19:37,470
每個方塊代表什麼物理
您的計算機內？

402
00:19:37,470 --> 00:19:38,250
>> [聽不清]。

403
00:19:38,250 --> 00:19:39,150
>> 對不起？

404
00:19:39,150 --> 00:19:39,580
>> 字符。

405
00:19:39,580 --> 00:19:44,760
>> 因此，一個字符肯定的情況下，
的字符串和一個字符是否是剛

406
00:19:44,760 --> 00:19:46,800
8位或一個字節。

407
00:19:46,800 --> 00:19:49,550
所以，你可能至少有隱約
熟悉的事實，

408
00:19:49,550 --> 00:19:50,500
計算機內存。

409
00:19:50,500 --> 00:19:52,110
至少有兩種類型的存儲器。

410
00:19:52,110 --> 00:19:54,810
一個是硬盤保存
永久的東西，那就是

411
00:19:54,810 --> 00:19:57,400
通常大的，所以你可以有電影
和聽音樂等等。

412
00:19:57,400 --> 00:20:04,010
>> 然後你有另一種類型的內存
被稱為RAM，R-A-M，隨機存取

413
00:20:04,010 --> 00:20:07,510
記憶，這是內存類型的
您的計算機時所使用的

414
00:20:07,510 --> 00:20:11,520
運行，但如果你失去動力或
電池模具，任何存儲

415
00:20:11,520 --> 00:20:15,300
在RAM中消失，如果你失去權力
完全是因為它不是

416
00:20:15,300 --> 00:20:16,060
執著。

417
00:20:16,060 --> 00:20:19,120
您通常，這些天，
演出的演出，也許更多。

418
00:20:19,120 --> 00:20:23,490
RAM的上攻是它的許多
以更快的速度比硬盤

419
00:20:23,490 --> 00:20:27,390
甚至是固態硬盤，這些天，
但它通常更加昂貴，所以

420
00:20:27,390 --> 00:20:28,480
你有少。

421
00:20:28,480 --> 00:20:32,400
>> 因此，今天的談話真的是指
到RAM中，這些不同的存儲器

422
00:20:32,400 --> 00:20:35,270
只存在而出現的電力
被送入您的計算機。

423
00:20:35,270 --> 00:20:40,530
所以，當你鍵入H-E-L-L-Ø輸入
鍵盤，H是將在一個

424
00:20:40,530 --> 00:20:44,550
字節的RAM，E是去
另一個字節的RAM，

425
00:20:44,550 --> 00:20:45,800
字的其餘部分。

426
00:20:45,800 --> 00:20:49,010
所以回想一下，我們能夠
做最後的時間是這樣的。

427
00:20:49,010 --> 00:20:53,940
讓我繼續前進，打開文件
我們稱為string.c，並召回

428
00:20:53,940 --> 00:20:56,860
它看起來有點兒
這樣的事情。

429
00:20:56,860 --> 00:20:59,860
讓我實際上回滾和改變
它究竟是什麼樣子，

430
00:20:59,860 --> 00:21:02,654
字符串s的長度。

431
00:21:02,654 --> 00:21:04,560
>> 所以看這裡的程序。

432
00:21:04,560 --> 00:21:08,530
我們包括CS50圖書館，所以
我們可以用得到的字符串。

433
00:21:08,530 --> 00:21:11,400
我們包括標準io.h
這樣我們就可以使用printf。

434
00:21:11,400 --> 00:21:13,580
我們為什麼包括string.h中？

435
00:21:13,580 --> 00:21:16,980
上週一，這是新的。

436
00:21:16,980 --> 00:21:18,230
所以，我們想要的字符串的長度。

437
00:21:18,230 --> 00:21:19,090
STR楞。

438
00:21:19,090 --> 00:21:21,470
人民決定多年前，
我們只是簡潔。

439
00:21:21,470 --> 00:21:24,290
而是叫它“字符串的長度，”
讓我們把它稱為“STR楞”，讓

440
00:21:24,290 --> 00:21:28,540
世界數字表示出來，所以這是
我們獲得與string.h中。

441
00:21:28,540 --> 00:21:29,390
>> 這是熟悉的。

442
00:21:29,390 --> 00:21:30,320
這是熟悉的。

443
00:21:30,320 --> 00:21:31,450
這是熟悉的。

444
00:21:31,450 --> 00:21:32,370
這是一個小新。

445
00:21:32,370 --> 00:21:35,420
在第22行 - 我們會回來的
這一點，但現在知道了 - 

446
00:21:35,420 --> 00:21:37,880
你只知道這個從有
閱讀文檔，或者如果

447
00:21:37,880 --> 00:21:39,010
你知道C處已經 - 

448
00:21:39,010 --> 00:21:41,510
串有時會搞砸。

449
00:21:41,510 --> 00:21:45,130
如果用戶是真的對抗性或
不合作，他或她只是

450
00:21:45,130 --> 00:21:49,450
不輸入任何內容或鍵盤
類型這麼多在鍵盤上，

451
00:21:49,450 --> 00:21:53,760
它淹沒了計算機的內存，
從理論上講，字符串可以返回

452
00:21:53,760 --> 00:21:56,270
以外的東西
字符串中的字符。

453
00:21:56,270 --> 00:22:01,930
它可以返回一個特殊值，稱為
在全部大寫，N-U-L-L，這是NULL

454
00:22:01,930 --> 00:22:03,390
只是一個所謂的警戒值。

455
00:22:03,390 --> 00:22:08,010
這是一個特殊的價值，標誌著
在這種情況下，一些不好的事情發生了。

456
00:22:08,010 --> 00:22:10,520
它是一個字符串的情況下。

457
00:22:10,520 --> 00:22:16,190
>> 所以我簡單的檢查，以便空，
長話短說，STR楞

458
00:22:16,190 --> 00:22:20,230
等功能，配有C​​，如果
他們期望一個字符串，但它們傳遞

459
00:22:20,230 --> 00:22:23,630
字符串的情況下，如果你傳遞
他們NULL，計算機或程序

460
00:22:23,630 --> 00:22:25,000
只是徹底的崩潰。

461
00:22:25,000 --> 00:22:25,610
它會一直掛。

462
00:22:25,610 --> 00:22:27,250
它會拋出一些錯誤信息。

463
00:22:27,250 --> 00:22:28,690
不好的事情會發生。

464
00:22:28,690 --> 00:22:31,130
因此，儘管這仍是
不明確 - 

465
00:22:31,130 --> 00:22:33,730
這將使更多的意義，在一個星期或
 - 第22行中，這僅僅是一個

466
00:22:33,730 --> 00:22:38,790
例如，自我防禦的錯誤檢查
以防萬一時間

467
00:22:38,790 --> 00:22:42,040
百萬出錯，
至少我的程序不會崩潰。

468
00:22:42,040 --> 00:22:45,960
>> 所以，如果s不等於壞的東西，
我有這樣的循環，這是

469
00:22:45,960 --> 00:22:47,710
在那裡我們有其他
新語法。

470
00:22:47,710 --> 00:22:51,580
我有一個循環從
零s的長度。

471
00:22:51,580 --> 00:22:56,140
然後，在這裡，我是一個打印輸出S
支架，但為什麼我用％C

472
00:22:56,140 --> 00:23:00,770
突然而不是％s甚至
雖然s是一個字符串？

473
00:23:00,770 --> 00:23:02,110
這是一個字符，對不對？

474
00:23:02,110 --> 00:23:06,560
S是一個字符串，但S支架的東西，
Ş支架其中i是零

475
00:23:06,560 --> 00:23:10,380
或一個或兩個，這是一個個人
字符串中的字符，所以對於

476
00:23:10,380 --> 00:23:14,970
printf的需要通知
它確實是一個字符期望。

477
00:23:14,970 --> 00:23:18,096
>> 然後記得，這樣做什麼
程序實際上做什麼？

478
00:23:18,096 --> 00:23:19,848
>> 在列打印出來。

479
00:23:19,848 --> 00:23:21,120
>> 是的，沒錯。

480
00:23:21,120 --> 00:23:24,990
它只是印的字，我鍵入
一列，每行的一個字符。

481
00:23:24,990 --> 00:23:26,190
因此，讓我們再次看到這個。

482
00:23:26,190 --> 00:23:27,810
所以字符串。

483
00:23:27,810 --> 00:23:30,200
編譯OK。 。/串。

484
00:23:30,200 --> 00:23:35,560
讓我輸入H-E-L-L-ø，回車，
事實上，我得到它，每行一個。

485
00:23:35,560 --> 00:23:37,280
>> 因此，讓我在這裡做一個優化。

486
00:23:37,280 --> 00:23:40,240
如果你仔細想想，特別是如果
你編程之前，還有

487
00:23:40,240 --> 00:23:43,340
可以說是一個低效率在24行。

488
00:23:43,340 --> 00:23:46,160
換句話說，它不一定
最好的設計。

489
00:23:46,160 --> 00:23:50,200
簡單，至少一次
記住STR楞是什麼，但它是

490
00:23:50,200 --> 00:23:52,640
潛在的做了愚蠢的事情。

491
00:23:52,640 --> 00:23:54,863
可能是什麼？

492
00:23:54,863 --> 00:23:56,280
>> [聽不清]。

493
00:23:56,280 --> 00:23:56,800
>> 沒錯。

494
00:23:56,800 --> 00:24:00,340
它檢查s的長度
每一個時間，即使

495
00:24:00,340 --> 00:24:02,980
H-E-L-L-O總是會
五個字符。

496
00:24:02,980 --> 00:24:05,490
每次通過這個循環，
五個不改變。

497
00:24:05,490 --> 00:24:08,750
我可能會遞增，但什麼
是s的長度在每個

498
00:24:08,750 --> 00:24:09,690
這個循環迭代？

499
00:24:09,690 --> 00:24:15,810
五，五，五，
但我仍然要求

500
00:24:15,810 --> 00:24:18,320
再次提出質疑，並一遍又一遍。

501
00:24:18,320 --> 00:24:20,750
坦率地說，現在的電腦是如此該死
速度快，沒有人會注意到一個

502
00:24:20,750 --> 00:24:23,780
在這種情況下的差異，但這些種
可憐的設計決策能

503
00:24:23,780 --> 00:24:28,330
如果編譯器本身開始增加
並不試圖解決這個問題，

504
00:24:28,330 --> 00:24:30,630
通常不會，
至少在家電。

505
00:24:30,630 --> 00:24:31,540
>> 所以我要做到這一點。

506
00:24:31,540 --> 00:24:34,580
我要後添加一個逗號
我的第一個變量。

507
00:24:34,580 --> 00:24:37,310
我要去給自己的另一
變量，調用N，僅僅通過

508
00:24:37,310 --> 00:24:41,330
約定為數字，然後我
分配n的字符串值

509
00:24:41,330 --> 00:24:42,530
s的長度。

510
00:24:42,530 --> 00:24:46,060
然後我要改變
我的條件是什麼？

511
00:24:46,060 --> 00:24:51,960
我要改變我的病情
而i是小於n。

512
00:24:51,960 --> 00:24:55,700
>> 所以，現在，我多少次
檢查s的長度？

513
00:24:55,700 --> 00:25:00,110
一旦，但它是確定檢查我反對
Ñ​​一遍又一遍，因為現在那些

514
00:25:00,110 --> 00:25:03,170
值實際上並沒有發生變化。

515
00:25:03,170 --> 00:25:06,020
現在，現在，任何時候，你只知道
調用一個函數，有一個位

516
00:25:06,020 --> 00:25:09,930
開銷，沒有足以阻止你
真正從使用過的功能，但

517
00:25:09,930 --> 00:25:12,750
肯定有一行代碼
 - 線將得到

518
00:25:12,750 --> 00:25:15,490
更有趣過不了多久 - 
有一個機會去思考，如果我

519
00:25:15,490 --> 00:25:18,320
輸入這個代碼，有多少
時間會執行嗎？

520
00:25:18,320 --> 00:25:20,950
你將開始看到隨著時間的推移
你的程序的性能

521
00:25:20,950 --> 00:25:21,660
的確改變。

522
00:25:21,660 --> 00:25:24,110
>> 事實上，這個問題我們已經設置
在過去幾年裡做涉及

523
00:25:24,110 --> 00:25:27,600
實施，你可能還記得
週為零，一個拼寫檢查器，但

524
00:25:27,600 --> 00:25:31,380
拼寫檢查，旨在支持
150,000加的字典

525
00:25:31,380 --> 00:25:32,860
也就是說，我們給你們。

526
00:25:32,860 --> 00:25:37,100
你將不得不編寫代碼加載
到RAM中，所以進的那些話

527
00:25:37,100 --> 00:25:40,700
盒子，就像我們看到在屏幕上瞬間
前，然後盡可能快地

528
00:25:40,700 --> 00:25:43,740
可以，你必須能夠回答
的形式問題，是這個詞

529
00:25:43,740 --> 00:25:44,280
拼寫錯誤？

530
00:25:44,280 --> 00:25:45,420
這是單詞拼寫錯誤？

531
00:25:45,420 --> 00:25:46,770
這是單詞拼寫錯誤？

532
00:25:46,770 --> 00:25:49,525
>> 的東西，像我們什麼
在過去幾年裡做的是把它變成，

533
00:25:49,525 --> 00:25:53,500
儘管上的選擇，在選擇基準，
各種各樣的競爭，據此，

534
00:25:53,500 --> 00:25:59,470
使用較少的RAM和學生誰
時間，更少的CPU週期，落得

535
00:25:59,470 --> 00:26:02,640
冒泡到頂部的一點點
領導板或排名，我們把

536
00:26:02,640 --> 00:26:04,770
當然我們的網頁
在過去的幾年中完成。

537
00:26:04,770 --> 00:26:08,100
如此反复，完全可選的，但是這
講的設計機會

538
00:26:08,100 --> 00:26:11,250
處於領先地位，一旦我們開始
建築頂上一些

539
00:26:11,250 --> 00:26:14,010
基本構建塊。

540
00:26:14,010 --> 00:26:16,780
>> 因此，讓我回到這個圖
只是片刻，露出一點

541
00:26:16,780 --> 00:26:17,610
更多的東西。

542
00:26:17,610 --> 00:26:21,400
這的確是一個字符串，我們已經採取了
利用幾個庫

543
00:26:21,400 --> 00:26:25,150
標準io.h  - 

544
00:26:25,150 --> 00:26:26,110
>> printf的。

545
00:26:26,110 --> 00:26:27,860
>> printf的，在其他的事情。

546
00:26:27,860 --> 00:26:31,540
cs50.h，這已經得到int和得到字符串
等等，string.h中，

547
00:26:31,540 --> 00:26:32,570
有STR楞。

548
00:26:32,570 --> 00:26:34,800
但事實證明，那裡的又一。

549
00:26:34,800 --> 00:26:38,540
坦率地說，有很多很多的頭
文件聲明函數

550
00:26:38,540 --> 00:26:43,320
圖書館，但這個文件ctype.h
實際上是要有點

551
00:26:43,320 --> 00:26:46,900
有利的，因為我要去
繼續前進，實現一個

552
00:26:46,900 --> 00:26:48,120
這裡的其他程序。

553
00:26:48,120 --> 00:26:52,420
>> 讓我去進取，不斷開拓的東西
提前叫我寫

554
00:26:52,420 --> 00:26:55,750
capitalize.c，讓我們
看看這是如何工作的。

555
00:26:55,750 --> 00:27:00,340
請注意，我使用，在這個版本
，三個熟悉的文件。

556
00:27:00,340 --> 00:27:04,110
請注意，我在第18行，
獲取一行文本。

557
00:27:04,110 --> 00:27:07,660
注意，在第21行，我聲稱
下面的代碼是怎麼回事

558
00:27:07,660 --> 00:27:12,170
把握，無論用戶輸入
，我怎麼做？

559
00:27:12,170 --> 00:27:13,300
好吧，我考慮 - 

560
00:27:13,300 --> 00:27:14,750
從上一次的教訓 - 

561
00:27:14,750 --> 00:27:18,370
我聲明我n和迭代
在字符串中的字符。

562
00:27:18,370 --> 00:27:22,720
然後這是塊什麼
在24到27行的代碼

563
00:27:22,720 --> 00:27:24,550
做外行的條款嗎？

564
00:27:24,550 --> 00:27:27,766

565
00:27:27,766 --> 00:27:29,730
>> 小寫字母。

566
00:27:29,730 --> 00:27:30,430
>> 沒錯。

567
00:27:30,430 --> 00:27:35,920
如果s支架 - 因此，如果第i個
為s的字符，這是一個特定的

568
00:27:35,920 --> 00:27:40,220
字符串中的字符，大於
或等於小寫a  - 

569
00:27:40,220 --> 00:27:42,670
記得雙符號
表示 - 

570
00:27:42,670 --> 00:27:46,810
與人品同在支架I，S，
小寫的Z小於或等於

571
00:27:46,810 --> 00:27:50,600
這意味著它的一個或B或C或
點，點，點，或Z，這意味著

572
00:27:50,600 --> 00:27:51,340
它是小寫。

573
00:27:51,340 --> 00:27:52,900
在這種情況下，我想要做的是什麼？

574
00:27:52,900 --> 00:27:55,010
好吧，我可以做這個有點
若有所思，但

575
00:27:55,010 --> 00:27:56,160
讓逗除此之外。

576
00:27:56,160 --> 00:28:00,210
>> 我要調用printf打印％C
因為我要轉載本

577
00:28:00,210 --> 00:28:01,580
字符在屏幕上。

578
00:28:01,580 --> 00:28:06,650
然後，我要採取Ş支架I，
第i個字符，那麼為什麼

579
00:28:06,650 --> 00:28:12,330
我在這裡做這個小動作，
小寫a減大寫字母A？

580
00:28:12,330 --> 00:28:16,352
那是什麼要給
我，一般來說？

581
00:28:16,352 --> 00:28:18,600
>> [聽不清]。

582
00:28:18,600 --> 00:28:19,390
>> 沒錯。

583
00:28:19,390 --> 00:28:20,860
我真的不記得 - 

584
00:28:20,860 --> 00:28:24,390
65資本A.我真的不
記得什麼小寫一個是，

585
00:28:24,390 --> 00:28:25,540
但不管。

586
00:28:25,540 --> 00:28:26,580
計算機知道。

587
00:28:26,580 --> 00:28:30,380
所以說，小寫a減號
大寫字母A，是它的怪異

588
00:28:30,380 --> 00:28:33,530
從另一個減去一個字符，但
引擎蓋下的字符是什麼？

589
00:28:33,530 --> 00:28:34,520
他們只是數字。

590
00:28:34,520 --> 00:28:36,980
所以，無論這些數字，
讓電腦記住它

591
00:28:36,980 --> 00:28:38,240
人類，而不是我。

592
00:28:38,240 --> 00:28:41,710
>> 因此，A是小寫a減去資本
要給我一個差異。

593
00:28:41,710 --> 00:28:45,370
這恰好是32，這將是
的情況小寫b和資本的乙

594
00:28:45,370 --> 00:28:45,930
等等。

595
00:28:45,930 --> 00:28:47,710
它保持一致，謝天謝地。

596
00:28:47,710 --> 00:28:51,930
所以我基本上說，
小寫字母，減去該

597
00:28:51,930 --> 00:28:55,340
標準的差異，
有效地改變小號支架I

598
00:28:55,340 --> 00:28:59,400
，當然小寫，大寫，
沒有我真的有想

599
00:28:59,400 --> 00:29:03,040
或請記住，什麼是那些
數字，我們談到八時

600
00:29:03,040 --> 00:29:04,800
志願者來到舞台上嗎？

601
00:29:04,800 --> 00:29:08,800
同時，在其他的，如果它不
確定一個小寫字母

602
00:29:08,800 --> 00:29:10,400
由24行，只是把它打印出來。

603
00:29:10,400 --> 00:29:12,590
我只想觸摸
字符

604
00:29:12,590 --> 00:29:14,410
實際上原先小寫。

605
00:29:14,410 --> 00:29:15,150
>> 所以，讓我們來看看這個。

606
00:29:15,150 --> 00:29:17,400
使利用。

607
00:29:17,400 --> 00:29:18,470
編譯後，“確定”。

608
00:29:18,470 --> 00:29:19,730
/利用。

609
00:29:19,730 --> 00:29:23,530
並讓我輸入H-E-L-L-Ø
小寫字母，回車。

610
00:29:23,530 --> 00:29:26,370
並注意該轉換
轉換為大寫。

611
00:29:26,370 --> 00:29:27,940
讓我這樣做再次
不同的字。

612
00:29:27,940 --> 00:29:32,720
怎麼樣D-A-V-I-D與第一D
資本化，作為一個名字，通常是什麼？

613
00:29:32,720 --> 00:29:33,560
回車鍵。

614
00:29:33,560 --> 00:29:34,870
請注意，它仍然是正確的。

615
00:29:34,870 --> 00:29:40,250
它只是輸出，第一個D不變
通過該else結構。

616
00:29:40,250 --> 00:29:42,170
>> 所以記住，於是，
夫婦的東西在這裡。

617
00:29:42,170 --> 00:29:45,060
一，如果你想檢查兩個
一次的情況下，你可以和他們

618
00:29:45,060 --> 00:29:46,500
我們一起預測。

619
00:29:46,500 --> 00:29:49,900
以這種方式可以比較字符
有效治療字符

620
00:29:49,900 --> 00:29:53,050
數字，但坦率地說，這是如此該死
神秘的，我永遠會記住

621
00:29:53,050 --> 00:29:56,510
如何想出這個從頭開始
而通過它的推理相當

622
00:29:56,510 --> 00:29:57,140
時間一點點。

623
00:29:57,140 --> 00:30:00,590
>> 那豈不是一直很好，如果有人
在那裡寫一個函數調用是

624
00:30:00,590 --> 00:30:05,390
降低可以回答我真或
假的，這個人物是小寫？

625
00:30:05,390 --> 00:30:09,350
令人欣慰的好，誰寫
ctype.h中確實做到了。

626
00:30:09,350 --> 00:30:15,540
讓我上去這裡的ctype為c
類型，現在讓我去這裡，

627
00:30:15,540 --> 00:30:18,820
重寫此行如下。

628
00:30:18,820 --> 00:30:27,510
>> 因此，如果這就是所謂的低，我要求，S
支架，然後我要刪除

629
00:30:27,510 --> 00:30:29,400
這兩條線完全。

630
00:30:29,400 --> 00:30:32,570
所以，現在別人的，我希望，寫
一個函數調用較低，並且

631
00:30:32,570 --> 00:30:36,250
原來他們做了，他們宣布
它裡面ctype.h的。

632
00:30:36,250 --> 00:30:39,480
現在，我要離開27號線
孤獨，我要離開31號線

633
00:30:39,480 --> 00:30:41,890
孤單，但看到我多少
收緊了我的代碼。

634
00:30:41,890 --> 00:30:42,690
現在它的清潔劑。

635
00:30:42,690 --> 00:30:47,250
少，難以期待通過
因為現在的功能，而且，是

636
00:30:47,250 --> 00:30:50,080
如此奇妙只是把它命名為
做什麼它說。

637
00:30:50,080 --> 00:30:51,520
>> 所以現在我要保存這個。

638
00:30:51,520 --> 00:30:52,930
我要縮小。

639
00:30:52,930 --> 00:30:56,650
就像在Scratch你可以有
布爾值，布爾值true或

640
00:30:56,650 --> 00:31:01,530
假的，那到底是什麼
有效降低回報。

641
00:31:01,530 --> 00:31:02,960
讓我重新編譯。

642
00:31:02,960 --> 00:31:04,500
讓我重新運行。

643
00:31:04,500 --> 00:31:07,350
現在讓我們再次嘗試，
H-E-L-L-O，回車。

644
00:31:07,350 --> 00:31:07,970
這是相當不錯的。

645
00:31:07,970 --> 00:31:10,150
然後再試一次，確保我
沒有螺絲的東西。

646
00:31:10,150 --> 00:31:11,670
這是資本。

647
00:31:11,670 --> 00:31:14,190
>> 但是，這是不夠好，因為
其他的事情，我從來沒有去

648
00:31:14,190 --> 00:31:19,090
記住，除非我真的通過它的工作
仔細，說，紙

649
00:31:19,090 --> 00:31:19,920
這該死的線。

650
00:31:19,920 --> 00:31:23,450
那豈不是很好，如果有
一個功能叫上？

651
00:31:23,450 --> 00:31:26,930
那麼它原來有
ctype.h中。

652
00:31:26,930 --> 00:31:30,150
我要繼續前進，並鍵入 - 

653
00:31:30,150 --> 00:31:31,340
讓我帶回到該行。

654
00:31:31,340 --> 00:31:36,430
而不是在這裡，讓我繼續前進
並說，替換為％C

655
00:31:36,430 --> 00:31:42,110
調用這個函數的結果
上的s的第i個字符。

656
00:31:42,110 --> 00:31:45,430
現在發現它越來越
一點點的平衡。

657
00:31:45,430 --> 00:31:48,870
我必須繼續跟踪有多少
括號，我打開和關閉。

658
00:31:48,870 --> 00:31:50,050
>> 所以現在更清潔。

659
00:31:50,050 --> 00:31:53,460
現在，這個程序是越來越好
更好的設計，可以說是，因為它是

660
00:31:53,460 --> 00:31:56,450
很多，很多更具可讀性，但
它沒有讓我們糾正。

661
00:31:56,450 --> 00:31:57,600
使利用。

662
00:31:57,600 --> 00:31:58,930
/利用。

663
00:31:58,930 --> 00:32:03,220
H-E-L-L-O。讓我們再次運行它，
D-A-V-I-D。 OK，所以我們仍然在

664
00:32:03,220 --> 00:32:04,250
相當良好。

665
00:32:04,250 --> 00:32:06,030
>> 但是，現在上。

666
00:32:06,030 --> 00:32:09,720
我建議，還有一個更
我們可以做出細化，這將是

667
00:32:09,720 --> 00:32:12,820
真的很不錯，真的可以收緊
了這個代碼，而真正給我們五個

668
00:32:12,820 --> 00:32:15,150
的五設計，例如。

669
00:32:15,150 --> 00:32:16,510
什麼將是很好的擺脫？

670
00:32:16,510 --> 00:32:20,770
好吧，看如何該死的長塊
代碼只是簡單做一下。

671
00:32:20,770 --> 00:32:23,850
>> 現在，順便說一句，你可能有
過去的這個超大斷面

672
00:32:23,850 --> 00:32:27,570
週末，你不嚴格需要
當你只是有一個大括號

673
00:32:27,570 --> 00:32:32,180
一行代碼，儘管我們提出
保持他們，以便使其多

674
00:32:32,180 --> 00:32:36,190
更清晰，像在划痕的U形
塊，裡面有什麼分支。

675
00:32:36,190 --> 00:32:40,170
但不會是很好，如果上，
其輸入時，把它變成

676
00:32:40,170 --> 00:32:44,730
大寫的，如果它不是，會是什麼
是美好的，在相反的情況下，如果

677
00:32:44,730 --> 00:32:47,210
它已經是大寫嗎？

678
00:32:47,210 --> 00:32:49,620
只需將它穿過
離開單幹。

679
00:32:49,620 --> 00:32:50,660
>> 所以，或許是這樣做的。

680
00:32:50,660 --> 00:32:52,990
我可以嘗試，只是希望
這不，但讓我

681
00:32:52,990 --> 00:32:54,450
引進另一件事。

682
00:32:54,450 --> 00:32:57,440
而不是使用內置終端
窗口在這裡，記得，

683
00:32:57,440 --> 00:33:01,130
這個廣場的黑色圖標給你一個
更大的終端窗口，我可以滿

684
00:33:01,130 --> 00:33:02,260
篩選，如果我想要的嗎？

685
00:33:02,260 --> 00:33:05,820
因此，原來他們是那種奇怪
命名，但有這些東西叫做

686
00:33:05,820 --> 00:33:10,970
手冊頁，手冊頁，男子短，
我可以訪問這些由

687
00:33:10,970 --> 00:33:14,515
鍵入man  - 

688
00:33:14,515 --> 00:33:15,570
我想輸入什麼？

689
00:33:15,570 --> 00:33:17,830
人上。

690
00:33:17,830 --> 00:33:21,090
>> 現在發現，如果存在
函數裡面的電腦，

691
00:33:21,090 --> 00:33:23,970
這種情況下的設備，這僅僅是
Linux操作系統，它是怎麼回事

692
00:33:23,970 --> 00:33:27,920
給我一個略帶神秘的組
輸出，但你會發現隨著時間的推移，

693
00:33:27,920 --> 00:33:31,720
它總是相當多的格式化
相同的，所以，你開始習慣它。

694
00:33:31,720 --> 00:33:35,130
注意在頂部上​​，
顯然是同一文檔

695
00:33:35,130 --> 00:33:35,680
為降低。

696
00:33:35,680 --> 00:33:38,740
這是誰寫切割一些
角落，並把它在一個頁面上。

697
00:33:38,740 --> 00:33:40,720
這些東西的目的
生活是轉換

698
00:33:40,720 --> 00:33:42,780
字母大寫或小寫。

699
00:33:42,780 --> 00:33:46,290
>> 請注意，根據劇情介紹，該男子頁面
教我我有什麼樣的文件

700
00:33:46,290 --> 00:33:48,130
包括用這個東西。

701
00:33:48,130 --> 00:33:51,320
它給我的這些簽名
功能，其中，即使

702
00:33:51,320 --> 00:33:53,510
雖然我們現在只
關心一個。

703
00:33:53,510 --> 00:33:54,730
現在這裡是一個描述。

704
00:33:54,730 --> 00:33:58,800
上轉換信
c到大寫，如果可能的話。

705
00:33:58,800 --> 00:34:02,280
>> 還不啟發，但讓我
現在看起來下返回值，這件事

706
00:34:02,280 --> 00:34:03,520
交回。

707
00:34:03,520 --> 00:34:08,600
因此，返回的值是，
如果轉換的字母或c

708
00:34:08,600 --> 00:34:09,870
轉換是不可能的。

709
00:34:09,870 --> 00:34:11,202
什麼是C？

710
00:34:11,202 --> 00:34:12,560
>> 原來的字符。

711
00:34:12,560 --> 00:34:15,370
>> 原來的字符，我們知道
，通過再次上升到

712
00:34:15,370 --> 00:34:19,179
故事大綱，誰寫了這
功能決定的輸入

713
00:34:19,179 --> 00:34:22,909
到上，以降低僅僅是
隨意名為c。

714
00:34:22,909 --> 00:34:24,909
他們可以把它叫做什麼最
他們想要的，但他們保持了

715
00:34:24,909 --> 00:34:26,270
簡單為c。

716
00:34:26,270 --> 00:34:27,880
所以，我已經諮詢手冊頁。

717
00:34:27,880 --> 00:34:31,870
這句話安慰我說，如果
它不是一個小寫字母，這是

718
00:34:31,870 --> 00:34:34,969
只是給我C，這是
完美，這意味著我可以擺脫

719
00:34:34,969 --> 00:34:36,199
我的其他條件。

720
00:34:36,199 --> 00:34:39,679
>> 因此，讓我回去gedit中，
現在讓我這樣做。

721
00:34:39,679 --> 00:34:41,960
我要我的printf語句複製。

722
00:34:41,960 --> 00:34:45,969
我要繼續前進，右內
循環打印出來，並得到

723
00:34:45,969 --> 00:34:48,760
擺脫目前整個if結構。

724
00:34:48,760 --> 00:34:51,860
是不是一個壞主意，這是非常
多正確，符合

725
00:34:51,860 --> 00:34:54,100
我們所鼓吹的一切，
只是沒有必要的。

726
00:34:54,100 --> 00:34:57,070
只要你意識到一些庫
函數存在別人

727
00:34:57,070 --> 00:35:01,340
寫道，或者你在其他地方寫的
文件，你可以使用它，真正

728
00:35:01,340 --> 00:35:02,690
開始收緊代碼。

729
00:35:02,690 --> 00:35:06,080
>> 而當我說的東西，如良好的作風，
一個事實，即這個人被稱為

730
00:35:06,080 --> 00:35:11,490
功能上，或以前是
低奇妙的是有用的，因為

731
00:35:11,490 --> 00:35:12,900
他們非常的描述。

732
00:35:12,900 --> 00:35:16,120
你不會想打電話給你的職能
x和y和z，其中有

733
00:35:16,120 --> 00:35:19,620
多了，少得多的意義。

734
00:35:19,620 --> 00:35:25,160
該系列的任何問題
改進？

735
00:35:25,160 --> 00:35:28,010
>> 所以我只想說一個
外賣店甚至是你自己的問題

736
00:35:28,010 --> 00:35:30,960
 - 也許問題集，但
肯定P設定兩年以後，即使

737
00:35:30,960 --> 00:35:34,380
當他們不一定正確
意味著他們是完美的只是

738
00:35:34,380 --> 00:35:36,155
還特別精心設計的。

739
00:35:36,155 --> 00:35:38,420
這是其他軸
開始思考。

740
00:35:38,420 --> 00:35:41,730
因此，這是一個字符串在你的
計算機的內存，但如果你有一個

741
00:35:41,730 --> 00:35:46,180
一大堆的字符，如H-E-L-L-ø
裡面的RAM，並假設

742
00:35:46,180 --> 00:35:51,330
你在你的程序中調用得到的字符串
多次這樣的，你

743
00:35:51,330 --> 00:35:54,200
一次調用get字符串，那麼你
再次調用get字符串。

744
00:35:54,200 --> 00:35:55,880
嗯，什麼事情
隨著時間的推移發生？

745
00:35:55,880 --> 00:35:59,170
>> 換句話說，如果你有一個線
代碼，雖然脫離了上下文，像

746
00:35:59,170 --> 00:36:02,120
字符串s得到 - 

747
00:36:02,120 --> 00:36:02,960
讓我們做到這一點。

748
00:36:02,960 --> 00:36:05,270
字符串名稱等於串。

749
00:36:05,270 --> 00:36:08,590
因此，假設該行代碼是
要求用戶為他或她的名字。

750
00:36:08,590 --> 00:36:14,580
下一行代碼是問
用戶輸入他或她的學校，和

751
00:36:14,580 --> 00:36:15,920
這下一行，依此類推。

752
00:36:15,920 --> 00:36:18,150
假設我們不斷地問
另一個用戶，並

753
00:36:18,150 --> 00:36:19,750
又和另一個字符串。

754
00:36:19,750 --> 00:36:22,390
他們會留在內存
在同一時間。

755
00:36:22,390 --> 00:36:24,280
不會撞。

756
00:36:24,280 --> 00:36:26,420
學校沒有其他覆蓋。

757
00:36:26,420 --> 00:36:28,520
但他們都
結束了在內存中？

758
00:36:28,520 --> 00:36:32,030
>> 那麼，如果我們開始在屏幕上繪製，
我們可以用這個東西

759
00:36:32,030 --> 00:36:35,800
這裡就像一個黑板上，如果這個黑色
矩形代表我的電腦

760
00:36:35,800 --> 00:36:39,800
內存，我要隨意地開始
將其分割成小方塊，

761
00:36:39,800 --> 00:36:42,120
其中每一個代表
一個字節的存儲器。

762
00:36:42,120 --> 00:36:46,560
坦率地說，如果你有1GB內存
這些天來，你有一個億字節

763
00:36:46,560 --> 00:36:49,540
在您的計算機的內存，所以
一個10億這些廣場。

764
00:36:49,540 --> 00:36:52,110
所以我只想說，這
是不是真的到規模。

765
00:36:52,110 --> 00:36:58,250
>> 但是，我們可以繼續繪製所有這些
顯然不按比例的平方，而這

766
00:36:58,250 --> 00:37:01,260
集體代表
我的電腦的內存。

767
00:37:01,260 --> 00:37:03,136
現在我們只是做點，點，點。

768
00:37:03,136 --> 00:37:06,260
所以換句話說，我現在提示
用戶獲取字符串給我一個

769
00:37:06,260 --> 00:37:07,350
字符串，會發生什麼？

770
00:37:07,350 --> 00:37:14,270
如果用戶鍵入“你好”，結束
在H-E-L-L-O。但是，假設

771
00:37:14,270 --> 00:37:15,720
然後用戶類型 - 

772
00:37:15,720 --> 00:37:17,250
其實，我不應該這樣做
你好，因為我們要求

773
00:37:17,250 --> 00:37:18,330
他們為自己的名字。

774
00:37:18,330 --> 00:37:20,580
因此，讓我們回去，如果我能做到這一點。

775
00:37:20,580 --> 00:37:26,130
>> 所以，如果我為我的名D-A-V-I-D型，
但記得，第二行

776
00:37:26,130 --> 00:37:29,220
代碼串再次
得到他們的學校。

777
00:37:29,220 --> 00:37:32,090
這個詞在哪裡，用戶
要去旁邊的類型？

778
00:37:32,090 --> 00:37:38,290
好吧，也許它打算進入
H-A-R-V-A-R-D。因此，即使我

779
00:37:38,290 --> 00:37:41,560
繪製為兩行，這僅僅是
在你的一大堆字節

780
00:37:41,560 --> 00:37:42,710
計算機的RAM。

781
00:37:42,710 --> 00:37:46,560
現在有一個問題，因為現在如果我
這是非常合理的使用RAM

782
00:37:46,560 --> 00:37:49,910
但那種幼稚的方式，你能
沒有明顯區別？

783
00:37:49,910 --> 00:37:52,640

784
00:37:52,640 --> 00:37:54,680
一開始和
一端，對不對？

785
00:37:54,680 --> 00:37:55,860
他們有點模糊起來。

786
00:37:55,860 --> 00:37:57,920
>> 因此，原來的電腦
沒有做到這一點。

787
00:37:57,920 --> 00:38:04,720
居然讓我在時間上向後滾動
幾個字符，而不是哈佛

788
00:38:04,720 --> 00:38:09,570
後立即用戶的名稱，
用戶實際得到的，後面

789
00:38:09,570 --> 00:38:12,000
的場景，一個特殊字符
插入的

790
00:38:12,000 --> 00:38:13,885
為他或她的計算機。

791
00:38:13,885 --> 00:38:19,470
/ 0，否則被稱為空字符
煩人稱為N-U-L時，未

792
00:38:19,470 --> 00:38:22,190
N-U-L-L，但你把它寫為/ 0。

793
00:38:22,190 --> 00:38:27,130
這只是所有的零位是一個標記
之間的第一個字，用戶的

794
00:38:27,130 --> 00:38:28,290
被鍵入和第二。

795
00:38:28,290 --> 00:38:33,020
>> 因此，哈佛實際上現在結束了
的字符序列，因為這

796
00:38:33,020 --> 00:38:36,110
1/0。

797
00:38:36,110 --> 00:38:41,690
因此，換句話說，通過讓這些
定點值，8個連續的零

798
00:38:41,690 --> 00:38:45,220
位，你現在可以開始區分
從另一個的一個字符。

799
00:38:45,220 --> 00:38:49,720
所以這一切的時候，什麼是“你好”是
實際上是“你好”/ 0

800
00:38:49,720 --> 00:38:53,580
同時，有可能很好
相當多的RAM

801
00:38:53,580 --> 00:38:56,400
裡面的電腦。

802
00:38:56,400 --> 00:38:57,810
>> 讓我現在做另一件事。

803
00:38:57,810 --> 00:39:01,800
事實證明，所有這些廣場
我們一直在畫畫，他們是：

804
00:39:01,800 --> 00:39:06,140
字符串，但更一般地，
這些東西都是陣列。

805
00:39:06,140 --> 00:39:10,590
數組只是一塊內存
背靠背背靠背，

806
00:39:10,590 --> 00:39:15,130
您通常使用數組方式
本方括號。

807
00:39:15,130 --> 00:39:18,210
因此，我們要看到這些頗有幾分
隨著時間的推移，但讓我繼續前進，

808
00:39:18,210 --> 00:39:21,160
開拓，我們姑且稱之為它的年齡。

809
00:39:21,160 --> 00:39:23,920
並且注意到我們能做些什麼
這些相同的招數，一點點

810
00:39:23,920 --> 00:39:25,750
多一點這裡的語法。

811
00:39:25,750 --> 00:39:29,270
>> 所以這個程序的第17行 - 
其實，讓我先運行程序

812
00:39:29,270 --> 00:39:30,770
所以我們可以看到，這件事情做什麼。

813
00:39:30,770 --> 00:39:33,530
讓我叫年齡
編譯這個程序。

814
00:39:33,530 --> 00:39:34,950
/年齡。

815
00:39:34,950 --> 00:39:36,480
在房間裡有多少人？

816
00:39:36,480 --> 00:39:38,020
3。

817
00:39:38,020 --> 00:39:39,575
時代的第一人嗎？

818
00:39:39,575 --> 00:39:42,710
18，19，和20。

819
00:39:42,710 --> 00:39:46,770
現在有些可笑的是，我只是
有一個程序，青睞那些

820
00:39:46,770 --> 00:39:47,740
三個人。

821
00:39:47,740 --> 00:39:50,390
>> 因此，有明確的機會
這裡一些有趣的算術。

822
00:39:50,390 --> 00:39:51,560
值得慶幸的是，數學是正確的。

823
00:39:51,560 --> 00:39:54,720
18至19日，19去
至20，等等。

824
00:39:54,720 --> 00:39:58,510
但是，什麼是真正的意思是
說明這裡是我們如何存儲

825
00:39:58,510 --> 00:40:00,190
這三個人的年齡。

826
00:40:00,190 --> 00:40:02,370
什麼讓我放大
怎麼回事。

827
00:40:02,370 --> 00:40:06,240
>> 因此，首先，這些前幾行應該
得到相當熟悉。

828
00:40:06,240 --> 00:40:08,770
我只是提示用戶
房間裡的人的數量。

829
00:40:08,770 --> 00:40:11,490
然後我使用int和做一會兒
再這樣做一遍又一遍。

830
00:40:11,490 --> 00:40:15,780
我們已經看到了這種模式，但
第27行是新的，其實挺

831
00:40:15,780 --> 00:40:18,160
有用的，將成為
越來越有用。

832
00:40:18,160 --> 00:40:21,620
請注意，在第27行有什麼不同
是我聲明

833
00:40:21,620 --> 00:40:23,960
INT稱為年齡，但等待。

834
00:40:23,960 --> 00:40:27,140
這不只是詮釋年齡。

835
00:40:27,140 --> 00:40:30,130
這些方括號，
在其內部是n。

836
00:40:30,130 --> 00:40:35,150
>> ，使托​​架n在這種情況下，不
裡面的一個printf語句，在這裡，但

837
00:40:35,150 --> 00:40:44,370
在這唯一的第27行，這條線是
說，給我Ñ整數，其中每個

838
00:40:44,370 --> 00:40:46,080
是int類型。

839
00:40:46,080 --> 00:40:49,870
因此，這是一桶水，可以這麼說，，
在這種情況下，三個整數回

840
00:40:49,870 --> 00:40:52,770
背靠背，讓我有效
有三個變量。

841
00:40:52,770 --> 00:40:54,890
替代方案中，是
清楚，應該是這樣的。

842
00:40:54,890 --> 00:40:57,400
>> 如果我想第一個學生
年齡，我可能做到這一點。

843
00:40:57,400 --> 00:40:59,520
如果我想第二個學生
年齡，我可能做到這一點。

844
00:40:59,520 --> 00:41:01,860
如果我想第三個學生
年齡，我可能做到這一點。

845
00:41:01,860 --> 00:41:04,320
上帝保佑我們需要大家的
年齡在這個房間裡 - 

846
00:41:04,320 --> 00:41:07,670
我的意思是，這是一個了不起的大量複製，
粘貼一遍又一遍。

847
00:41:07,670 --> 00:41:10,870
加一次我編這程序，
如果另一名學生走在了

848
00:41:10,870 --> 00:41:14,200
那扇門，現在我的電話號碼
變量不正確。

849
00:41:14,200 --> 00:41:17,450
>> 所以有關陣列不錯
一旦你開始感覺自己

850
00:41:17,450 --> 00:41:20,190
複製和粘貼，賠率是這
不是最好的方法。

851
00:41:20,190 --> 00:41:22,240
數組是動態可能。

852
00:41:22,240 --> 00:41:24,610
我不知道提前多少人
將要在房間裡，

853
00:41:24,610 --> 00:41:28,670
但我知道我需要他們的n，，我會
找出n當時間一到。

854
00:41:28,670 --> 00:41:35,500
現在這行代碼意味著，給我一個
像這樣的內存塊

855
00:41:35,500 --> 00:41:40,380
其中在屏幕上的盒數
是完全依賴於n

856
00:41:40,380 --> 00:41:42,010
用戶輸入

857
00:41:42,010 --> 00:41:44,850
>> 所以，現在這個程序的其餘部分是
什麼，我們實際上是非常相似

858
00:41:44,850 --> 00:41:46,860
只是做的字符。

859
00:41:46,860 --> 00:41:49,970
請注意，我有一個for循環
在第30行開始。

860
00:41:49,970 --> 00:41:54,920
所以，正確後，我得到的數組，我
迭代y等於0到n。

861
00:41:54,920 --> 00:41:58,890
我只是有這個指導性的printf
消息說，給我的年齡

862
00:41:58,890 --> 00:42:03,690
＃％我的人，所以，
數二，數三。

863
00:42:03,690 --> 00:42:04,730
我為什麼這樣做呢？

864
00:42:04,730 --> 00:42:08,870
坦率地說，人類更喜歡從一數
起來，而計算機科學家，

865
00:42:08,870 --> 00:42:09,620
零就到了。

866
00:42:09,620 --> 00:42:11,700
計算機科學家都不會
使用這種程序，所以我們

867
00:42:11,700 --> 00:42:13,990
剛開始計數
在一個正常的人一樣。

868
00:42:13,990 --> 00:42:17,630
>> 現在在第33行，請注意咯
不同的語法一塊。

869
00:42:17,630 --> 00:42:23,710
在該類型的變量i個年齡
陣列是會得到一個int。

870
00:42:23,710 --> 00:42:25,770
最後，現在，這僅僅是
這裡算術下來。

871
00:42:25,770 --> 00:42:29,200
我決定在一個單獨的循環，權利要求
一些時間的推移，現在在這

872
00:42:29,200 --> 00:42:31,400
單獨的循環，這些行執行。

873
00:42:31,400 --> 00:42:35,810
>> 從現在起一年，我將是我
歲，但注意到這一點是不

874
00:42:35,810 --> 00:42:36,500
變量i。

875
00:42:36,500 --> 00:42:38,390
現在，這是我為int％。

876
00:42:38,390 --> 00:42:43,210
第一個佔位符通知我
插上i加1，所以我們指望像

877
00:42:43,210 --> 00:42:44,250
正常的人。

878
00:42:44,250 --> 00:42:49,190
然後的價值，他們的年齡，
i年的時候，我採取年齡支架

879
00:42:49,190 --> 00:42:52,980
 - 為什麼我這裡加一做？

880
00:42:52,980 --> 00:42:53,760
他們只是年齡。

881
00:42:53,760 --> 00:42:55,030
這是我愚蠢的選擇方案。

882
00:42:55,030 --> 00:42:56,810
他們只是賬齡為一年。

883
00:42:56,810 --> 00:42:59,770
我可以輸入任何數字
其實我是想在那裡。

884
00:42:59,770 --> 00:43:02,430
>> 那麼什麼是居然全部
這裡的相關？

885
00:43:02,430 --> 00:43:07,610
好吧，讓我居然向後滾動
在這裡，畫一幅畫

886
00:43:07,610 --> 00:43:10,830
什麼樣的景象。

887
00:43:10,830 --> 00:43:15,720
我們將與我們的未來做什麼
習題集二是涉足

888
00:43:15,720 --> 00:43:17,070
密碼學的世界。

889
00:43:17,070 --> 00:43:22,500
所以這是一個字符串中的字符，所以
多個字符序列，

890
00:43:22,500 --> 00:43:23,750
不這樣說？

891
00:43:23,750 --> 00:43:28,530

892
00:43:28,530 --> 00:43:30,600
這不是在網上版本
幻燈片。

893
00:43:30,600 --> 00:43:35,880
>> 因此，我要求這等於這一點，
從多年的愚蠢廣告

894
00:43:35,880 --> 00:43:39,950
以前，實際上可能還記得
它的起源之一。

895
00:43:39,950 --> 00:43:42,740
因此，這是一個例子，加密
或加密。

896
00:43:42,740 --> 00:43:46,150
事實證明，如果你想
實際上發送信息或股份

897
00:43:46,150 --> 00:43:49,310
信息與別人牢固，
像類似這樣的消息，你可以

898
00:43:49,310 --> 00:43:50,500
爭奪字母。

899
00:43:50,500 --> 00:43:53,170
但通常情況下，話
不炒隨機。

900
00:43:53,170 --> 00:43:56,365
他們以某種方式置換或改變
在某種程度上，這樣 - 哎呀。

901
00:43:56,365 --> 00:43:59,040
這是一個有趣的攪局下一次。

902
00:43:59,040 --> 00:44:04,390
>> 所以，你可以映射顯然是什麼
O到B.通知行

903
00:44:04,390 --> 00:44:05,420
資本明智的。

904
00:44:05,420 --> 00:44:07,960
顯然，R變為E。

905
00:44:07,960 --> 00:44:14,000
顯然F-H-E-R變為S-ü-R-E。所以
它原來是一個映射，並在

906
00:44:14,000 --> 00:44:18,720
這種情況下，有一個非常愚蠢的
映射，如果有人已經想通了？

907
00:44:18,720 --> 00:44:21,440
這是一種叫做
腐13，旋轉13。

908
00:44:21,440 --> 00:44:24,760
這是最愚蠢的加密
機制，因為它真的只是

909
00:44:24,760 --> 00:44:29,160
增加了13到每一個字母，
愚蠢在這個意義上，如果你只是

910
00:44:29,160 --> 00:44:31,890
有一點空閒時間，在你的手中
和一支鉛筆，或者你只是覺得它

911
00:44:31,890 --> 00:44:35,260
通過在你的頭上，你可以試試
所有可能的補充 - 一，二，

912
00:44:35,260 --> 00:44:38,470
三，點，點，點，25只是
旋轉整個字母表，

913
00:44:38,470 --> 00:44:40,860
最終，你會找出
這個消息是什麼。

914
00:44:40,860 --> 00:44:43,700
所以，如果你做了這樣的事情在
小學傳遞訊息給您

915
00:44:43,700 --> 00:44:46,830
最好的朋友，如果你的小學
老師簡單地通讀

916
00:44:46,830 --> 00:44:50,320
消息和蠻力強行解決方案，
你可能得到

917
00:44:50,320 --> 00:44:52,550
的答案。

918
00:44:52,550 --> 00:44:54,970
>> 現在，當然，在現實世界中，
密碼學是更複雜的。

919
00:44:54,970 --> 00:45:00,120
這是一個從文本片段
計算機系統，用戶名和

920
00:45:00,120 --> 00:45:03,630
密碼，幾乎所有我們做，
這就是你的密碼可能

921
00:45:03,630 --> 00:45:07,260
如果存儲在硬盤樣子
開車，但以加密的形式。

922
00:45:07,260 --> 00:45:11,050
這不只是一個字母旋轉，
A是B和B是C，這是

923
00:45:11,050 --> 00:45:15,620
更為複雜的，但它使用
一般被稱為秘密密鑰

924
00:45:15,620 --> 00:45:16,690
加密。

925
00:45:16,690 --> 00:45:20,210
這幅畫告訴
故事與幾個圖標。

926
00:45:20,210 --> 00:45:22,250
>> 在左側，我們有什麼
我們會打電話給純文本。

927
00:45:22,250 --> 00:45:25,420
在世界上的密碼，平原
文本只是原始消息

928
00:45:25,420 --> 00:45:29,050
寫在英語或法語
或因任何語言。

929
00:45:29,050 --> 00:45:32,405
如果你想對它進行加密，我們將通過
它形象地通過一個掛鎖，所以

930
00:45:32,405 --> 00:45:35,580
一些類型的算法，一些功能
或程序，有人寫道：

931
00:45:35,580 --> 00:45:39,880
希望，打亂字母
更複雜的不僅僅是增加13

932
00:45:39,880 --> 00:45:40,980
每個人。

933
00:45:40,980 --> 00:45:43,780
>> 你擺脫這一進程
中間還有被稱為密文。

934
00:45:43,780 --> 00:45:44,850
這麼樣一個性感的字。

935
00:45:44,850 --> 00:45:47,630
它只是意味著它的加密
純文本版本。

936
00:45:47,630 --> 00:45:52,570
如果你有同樣的秘密，
13或減13，你是否能夠

937
00:45:52,570 --> 00:45:54,970
解密，這樣的消息。

938
00:45:54,970 --> 00:45:57,770
>> 因此，在問題設置兩個之間的事情，
你會做，如果在黑客

939
00:45:57,770 --> 00:46:01,860
版，你將不得不寫代碼
破解這些密碼，搞清楚

940
00:46:01,860 --> 00:46:05,170
他們是什麼，他們是如何
加密的，雖然我們不給你有點

941
00:46:05,170 --> 00:46:06,460
指引前進的道路。

942
00:46:06,460 --> 00:46:09,320
在標準版中，我們將介紹
一對夫婦的密碼，加密

943
00:46:09,320 --> 00:46:12,400
機制，一個叫凱撒，一
稱為VIGENERE，仍然

944
00:46:12,400 --> 00:46:16,100
其中A成為旋轉密碼
的東西，B變成的東西，但

945
00:46:16,100 --> 00:46:18,820
你必須做編程
因為確實是有一個秘密

946
00:46:18,820 --> 00:46:22,840
重點涉及的是一個典型的數字
或關鍵字，只有

947
00:46:22,840 --> 00:46:26,420
這些發送者和接收者
消息應該明白。

948
00:46:26,420 --> 00:46:28,660
>> 現在，這實際上已經變身
在現實世界中。

949
00:46:28,660 --> 00:46:32,910
舉例來說，這是小孤兒
安妮的秘密解碼環，

950
00:46:32,910 --> 00:46:35,180
實際上可以實現​​這些
旋轉密碼 - 

951
00:46:35,180 --> 00:46:37,930
B成為A成為的東西，
東西 - 一對夫婦的車輪，

952
00:46:37,930 --> 00:46:40,840
一個在外面，在裡面
例如，如果你旋轉滾輪或

953
00:46:40,840 --> 00:46:44,170
戒指，你實際上可以排隊的
字母與字母不同，

954
00:46:44,170 --> 00:46:45,430
得到一個秘密代碼。

955
00:46:45,430 --> 00:46:48,110
所以作為扣人心弦的今天，
我想我會做什麼，是有點

956
00:46:48,110 --> 00:46:52,170
倒退，如果你打開電視
12月24日，你可以看

957
00:46:52,170 --> 00:46:55,390
電影廣告nauseum
24小時成一排。

958
00:46:55,390 --> 00:47:06,030
但今天，我會打開它在這裡
短短兩分鐘的，給我們

959
00:47:06,030 --> 00:47:13,493
與教學相關的聖誕故事
一個名為拉爾夫的小傢伙。

960
00:47:13,493 --> 00:47:14,400
>> [視頻回放]

961
00:47:14,400 --> 00:47:17,420
>> 是向所有人，
拉爾夫·帕克現獲委任為

962
00:47:17,420 --> 00:47:20,650
成員小孤兒安妮秘密
圓和有權

963
00:47:20,650 --> 00:47:23,460
榮譽和利益
發生於此。

964
00:47:23,460 --> 00:47:25,990
>> 簽名，小孤兒安妮。

965
00:47:25,990 --> 00:47:30,100
會簽，皮埃爾·安德烈·墨。

966
00:47:30,100 --> 00:47:34,270
榮譽和利益已經
九歲。

967
00:47:34,270 --> 00:47:39,440
>> [喊RADIO]

968
00:47:39,440 --> 00:47:40,770
>> 來吧，讓我們得到它。

969
00:47:40,770 --> 00:47:44,965
我不需要所有的爵士樂有關
走私和海盜。

970
00:47:44,965 --> 00:47:48,270
>> 聽明天晚上
結論冒險的黑色

971
00:47:48,270 --> 00:47:49,650
海盜船。

972
00:47:49,650 --> 00:47:53,320
現在，它的時間安妮的秘密
各位成員的留言

973
00:47:53,320 --> 00:47:55,720
秘密圈。

974
00:47:55,720 --> 00:47:56,580
請記住，孩子。

975
00:47:56,580 --> 00:48:01,720
只有安妮的秘密圈的成員
可以解碼安妮的秘密消息。

976
00:48:01,720 --> 00:48:05,872
請記住，伊能靜得靠你了。

977
00:48:05,872 --> 00:48:08,670
設置引腳到B2。

978
00:48:08,670 --> 00:48:11,000
這裡的消息。

979
00:48:11,000 --> 00:48:12,335
12，11，2  - 

980
00:48:12,335 --> 00:48:14,670
>> 我在我的第一次秘密會晤。

981
00:48:14,670 --> 00:48:19,720
>> -25，14，11，18，16  - 

982
00:48:19,720 --> 00:48:21,650
>> 皮埃爾是在今晚大聲音。

983
00:48:21,650 --> 00:48:24,830
我可以告訴今晚的消息
是非常重要的。

984
00:48:24,830 --> 00:48:26,400
>> -3，25。

985
00:48:26,400 --> 00:48:28,540
這是一個消息從安妮自己。

986
00:48:28,540 --> 00:48:30,086
記住，不要告訴任何人。

987
00:48:30,086 --> 00:48:34,370

988
00:48:34,370 --> 00:48:38,710
>> -90秒後，我唯一的房間
在房子裡，一個九歲的孩子

989
00:48:38,710 --> 00:48:42,668
可以坐在隱私和解碼。

990
00:48:42,668 --> 00:48:47,628
啊哈，B.我去到下一個。

991
00:48:47,628 --> 00:48:53,060
E.的第一個字是“是”。 S.
它現在更容易。

992
00:48:53,060 --> 00:48:54,980
U. 25。

993
00:48:54,980 --> 00:48:55,940
這就是R。

994
00:48:55,940 --> 00:48:56,900
>> 來吧，拉爾夫。

995
00:48:56,900 --> 00:48:57,860
我得走了。

996
00:48:57,860 --> 00:48:59,780
>>  - 我會被降權，馬。

997
00:48:59,780 --> 00:49:01,030
哎呀。

998
00:49:01,030 --> 00:49:04,300

999
00:49:04,300 --> 00:49:08,220
>> -T。 O.一定要。

1000
00:49:08,220 --> 00:49:09,500
可以肯定的是什麼？

1001
00:49:09,500 --> 00:49:11,660
什麼是小孤兒
伊能靜想說的？

1002
00:49:11,660 --> 00:49:12,844
可以肯定的是什麼？

1003
00:49:12,844 --> 00:49:14,732
>> 拉爾夫，蘭迪得走了。

1004
00:49:14,732 --> 00:49:16,148
請你出來？

1005
00:49:16,148 --> 00:49:17,092
>> 所有權利，馬。

1006
00:49:17,092 --> 00:49:18,510
我馬上就出來。

1007
00:49:18,510 --> 00:49:20,270
>> 我到現在越來越近了。

1008
00:49:20,270 --> 00:49:21,823
張力是可怕的。

1009
00:49:21,823 --> 00:49:23,045
它是什麼？

1010
00:49:23,045 --> 00:49:26,510
地球命運
掛在平衡。

1011
00:49:26,510 --> 00:49:28,985
>> 拉爾夫，蘭迪得走了。

1012
00:49:28,985 --> 00:49:32,680
>>  - 我就出來
哭出聲來。

1013
00:49:32,680 --> 00:49:33,956
>> 幾乎。

1014
00:49:33,956 --> 00:49:35,140
我的手指飛了起來。

1015
00:49:35,140 --> 00:49:36,880
我的心是鋼的陷阱。

1016
00:49:36,880 --> 00:49:38,010
每一個毛孔振動。

1017
00:49:38,010 --> 00:49:39,878
這幾乎是明確的。

1018
00:49:39,878 --> 00:49:43,210
是的，是的，是的，是的，是的。

1019
00:49:43,210 --> 00:49:49,030
>>  - 務必喝阿華田。

1020
00:49:49,030 --> 00:49:50,280
阿華田？

1021
00:49:50,280 --> 00:49:53,980

1022
00:49:53,980 --> 00:49:55,230
一個照出商用？

1023
00:49:55,230 --> 00:49:58,572

1024
00:49:58,572 --> 00:50:00,694
王八蛋。

1025
00:50:00,694 --> 00:50:01,900
>> [END視頻播放]

1026
00:50:01,900 --> 00:50:04,260
>> 音箱1：這是CS50，而
將習題集兩個。

1027
00:50:04,260 --> 00:50:06,305
下週見。

1028
00:50:06,305 --> 00:50:08,800
>> 揚聲器2：在接下來的
CS50，發生這種情況。

1029
00:50:08,800 --> 00:50:11,060
>> 揚聲器1：一個主題，我們沒有
看著迄今

1030
00:50:11,060 --> 00:50:12,220
函數指針。

1031
00:50:12,220 --> 00:50:14,540
現在，僅僅是一個函數指針
一個公共的地址

1032
00:50:14,540 --> 00:50:17,000
功能，但很像 - 

1033
00:50:17,000 --> 00:50:18,250
兒子 - 

1034
00:50:18,250 --> 00:50:19,670