1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [第4條] [舒適]

2
00:00:02,000 --> 00:00:04,000
內特 - 哈迪森] [哈佛大學]

3
00:00:04,000 --> 00:00:07,000
這是CS50。[CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> 好了，歡迎回款。

5
00:00:10,000 --> 00:00:13,000
在本週的部分中，我們要做的幾件事情。

6
00:00:13,000 --> 00:00:17,000
我們將首先回顧一下習題集2，

7
00:00:17,000 --> 00:00:20,000
這是在的凱撒和維瓊內爾問題集。

8
00:00:20,000 --> 00:00:23,000
然後，我們將潛入測驗0個評論

9
00:00:23,000 --> 00:00:26,000
並花一點點的時間，扼要我們所談論的

10
00:00:26,000 --> 00:00:30,000
的講座中，到目前為止，我們還會做的幾個問題

11
00:00:30,000 --> 00:00:32,000
從上一年度的測驗。

12
00:00:32,000 --> 00:00:36,000
這樣，你們有一個很好的方式準備。

13
00:00:36,000 --> 00:00:40,000
>> 首先，我已經啟動了一對夫婦的良好的解決方案，

14
00:00:40,000 --> 00:00:45,000
對於前一個問題集，習題集2，進入這個空間。

15
00:00:45,000 --> 00:00:48,000
如果你們打這個環節，

16
00:00:48,000 --> 00:00:53,000
如果你點擊我的名字，然後單擊“我的第一次修訂

17
00:00:53,000 --> 00:00:56,000
，你會看到caesar.c的，而這正是我在尋找。

18
00:00:56,000 --> 00:01:00,000
讓我們來談談這真的很快。

19
00:01:00,000 --> 00:01:02,000
這僅僅是一個樣品溶液。

20
00:01:02,000 --> 00:01:05,000
這不一定是最完美的解決方案。

21
00:01:05,000 --> 00:01:08,000
有許多不同的方法來寫這個，

22
00:01:08,000 --> 00:01:10,000
但也有幾件事情，我想強調

23
00:01:10,000 --> 00:01:13,000
我看到了，因為我是分級的，常見的錯誤，我認為

24
00:01:13,000 --> 00:01:18,000
這個解決方案做了很好的處理工作。

25
00:01:18,000 --> 00:01:22,000
>> 第一的是，在頂部具有某種頭註釋。

26
00:01:22,000 --> 00:01:25,000
在第1行至第7，你看到的細節，

27
00:01:25,000 --> 00:01:28,000
究竟是什麼程序在做什麼。

28
00:01:28,000 --> 00:01:32,000
當你寫C代碼的一個很好的標準做法

29
00:01:32,000 --> 00:01:35,000
不管你的程序是包含在一個單一的文件或

30
00:01:35,000 --> 00:01:38,000
無論是拆分到多個文件中是有某種

31
00:01:38,000 --> 00:01:40,000
定向開頭處的註釋。

32
00:01:40,000 --> 00:01:43,000
這也為走出去寫代碼​​，在現實世界中的人。

33
00:01:43,000 --> 00:01:47,000
這是他們會把版權信息。

34
00:01:47,000 --> 00:01:50,000
下面是＃包括。

35
00:01:50,000 --> 00:01:55,000
第16行有這樣的定義，我們會回來的，在短短位。

36
00:01:55,000 --> 00:01:59,000
，然後再次啟動的功能，一旦主開始，

37
00:01:59,000 --> 00:02:03,000
因為這個程序已經都包含在一個單一的功能

38
00:02:03,000 --> 00:02:09,000
第一件事發生這種情況，這是很慣用的，典型的C程序

39
00:02:09,000 --> 00:02:14,000
，它的命令行參數的是，它會立即檢查

40
00:02:14,000 --> 00:02:18,000
>> 計數參數是argc。

41
00:02:18,000 --> 00:02:24,000
在這裡，我們看到，這個程序需要2個參數完全相同。

42
00:02:24,000 --> 00:02:27,000
記得有，第一個參數的特殊

43
00:02:27,000 --> 00:02:29,000
這是永遠的正在運行的程序的名稱，

44
00:02:29,000 --> 00:02:31,000
的可執行文件的名稱。

45
00:02:31,000 --> 00:02:36,000
因此，這是什麼做的是，它可以防止用戶運行該程序

46
00:02:36,000 --> 00:02:42,000
更多或更少的參數。

47
00:02:42,000 --> 00:02:44,000
究其原因是因為我們要檢查這項權利了

48
00:02:44,000 --> 00:02:52,000
我們實際上無法訪問此argv數組，這裡可靠

49
00:02:52,000 --> 00:02:55,000
直到我們檢查，看它有多大。

50
00:02:55,000 --> 00:02:58,000
>> 我看到了常見的錯誤之一是，人們馬上會去

51
00:02:58,000 --> 00:03:01,000
和抓斗的argv [1]。

52
00:03:01,000 --> 00:03:06,000
他們會抓住關鍵參數的數組，並做一個我檢查它，

53
00:03:06,000 --> 00:03:11,000
然後，他們會做的測試為argc以及接下來的測試，

54
00:03:11,000 --> 00:03:16,000
不是第一個參數是否確實是在相同的時間的整數，

55
00:03:16,000 --> 00:03:20,000
不工作，因為的情況下，沒有提供參數

56
00:03:20,000 --> 00:03:26,000
你會被抓住的參數是不存在，或試圖抓住一個不存在的。

57
00:03:26,000 --> 00:03:29,000
>> 其他大的事情，你應該注意到的是，

58
00:03:29,000 --> 00:03:32,000
你總是希望打印出某種有用的錯誤信息

59
00:03:32,000 --> 00:03:34,000
定位他們的用戶。

60
00:03:34,000 --> 00:03:37,000
我敢肯定，你的所有運行程序，所有的突然崩潰，

61
00:03:37,000 --> 00:03:41,000
你這是荒謬的小對話框彈出，並說

62
00:03:41,000 --> 00:03:44,000
一些可怕的神秘，也許給你一個錯誤的代碼，或類似的東西

63
00:03:44,000 --> 00:03:47,000
那是沒有意義的。

64
00:03:47,000 --> 00:03:50,000
這是你真正想要提供一些有益

65
00:03:50,000 --> 00:03:54,000
並針對用戶，這樣當他們運行它，他們“哦，”面對手掌。

66
00:03:54,000 --> 00:03:58,000
“我知道該怎麼做，我知道如何解決這個問題。”

67
00:03:58,000 --> 00:04:01,000
>> 如果你不打印一條消息，那麼你最終實際

68
00:04:01,000 --> 00:04:04,000
讓用戶去檢查你的源代碼

69
00:04:04,000 --> 00:04:07,000
出了什麼錯。

70
00:04:07,000 --> 00:04:11,000
也有一些時候，你會使用不同的錯誤代碼。

71
00:04:11,000 --> 00:04:14,000
在這裡，我們只是說有一個錯誤，

72
00:04:14,000 --> 00:04:16,000
有一個錯誤，出現了錯誤。

73
00:04:16,000 --> 00:04:20,000
更大的程序，通常被稱為由其他程序的程序，

74
00:04:20,000 --> 00:04:25,000
在不同的情況下，將返回某種特殊的錯誤代碼

75
00:04:25,000 --> 00:04:28,000
以編程方式溝通，​​否則你會

76
00:04:28,000 --> 00:04:32,000
只使用一個好聽的英文消息。

77
00:04:32,000 --> 00:04:35,000
酷。

78
00:04:35,000 --> 00:04:37,000
當我們的工作，你可以看到我們拉的關鍵了。

79
00:04:37,000 --> 00:04:40,000
我們測試一下，看看如果鑰匙和。

80
00:04:40,000 --> 00:04:42,000
我們從用戶得到一個消息。

81
00:04:42,000 --> 00:04:46,000
我們之所以這樣做，在這個do while循環，這是什麼，我們將覆蓋

82
00:04:46,000 --> 00:04:50,000
一點點，但事實證明，如果你輸入控制D

83
00:04:50,000 --> 00:04:54,000
當你在終端上的提示，GetString的

84
00:04:54,000 --> 00:04:59,000
實際上做的是，它發送一個特殊字符

85
00:04:59,000 --> 00:05:01,000
到該程序。

86
00:05:01,000 --> 00:05:05,000
這就是所謂的ELF文件結束符。

87
00:05:05,000 --> 00:05:08,000
在這種情況下，我們的消息字符串，是空的，

88
00:05:08,000 --> 00:05:14,000
所以這不是我們檢查中的問題，為自己的東西。

89
00:05:14,000 --> 00:05:17,000
>> 但是，當我們去，現在我們已經開始談論指針

90
00:05:17,000 --> 00:05:21,000
和動態內存分配在堆上，

91
00:05:21,000 --> 00:05:25,000
檢查是否為空，只要你有一個功能，可能

92
00:05:25,000 --> 00:05:30,000
返回null值是在做的習慣，你會希望得到的東西。

93
00:05:30,000 --> 00:05:33,000
這是在這裡主要是為例證。

94
00:05:33,000 --> 00:05:36,000
但是，當你看到的GetString在未來，

95
00:05:36,000 --> 00:05:41,000
所以從習題集4上，你要記住這一點。

96
00:05:41,000 --> 00:05:44,000
再次，這是不是一個問題，問題3，因為我們沒有遮蓋。

97
00:05:44,000 --> 00:05:53,000
最後，我們得到的這部分，我們得到的主要加密循環，

98
00:05:53,000 --> 00:05:57,000
有一對夫婦的事情在這裡。

99
00:05:57,000 --> 00:06:02,000
首先，我們遍歷整個消息字符串本身。

100
00:06:02,000 --> 00:06:07,000
在這裡，我們已經把strlen的要求的條件，

101
00:06:07,000 --> 00:06:12,000
一些你所指出的，是不是一個偉大的方式去。

102
00:06:12,000 --> 00:06:15,000
事實證明，在這種情況下，它也沒有很大的，

103
00:06:15,000 --> 00:06:20,000
部分原因是因為我們要修改的消息本身的內容

104
00:06:20,000 --> 00:06:27,000
在fo​​r循環中，所以，如果我們有10個字符長的消息，

105
00:06:27,000 --> 00:06:32,000
我們第一次啟動，strlen的循環，將返回什麼呢？

106
00:06:32,000 --> 00:06:35,000
10。

107
00:06:35,000 --> 00:06:40,000
>> 但是，如果我們再修改的消息，說我們修改它的第5個字符，

108
00:06:40,000 --> 00:06:46,000
我們扔在一個\ 0字符在第5位，

109
00:06:46,000 --> 00:06:49,000
在隨後的迭代中的strlen（消息）將不會返回它的所作所為

110
00:06:49,000 --> 00:06:52,000
我們第一次迭代，

111
00:06:52,000 --> 00:06:56,000
但是，它會直接返回5，因為我們扔在了空終止，

112
00:06:56,000 --> 00:06:59,000
定義字符串的長度

113
00:06:59,000 --> 00:07:03,000
由位置，\ 0。

114
00:07:03,000 --> 00:07:09,000
在這種情況下，這是一個偉大的路要走，因為我們修改它。

115
00:07:09,000 --> 00:07:13,000
但是你注意，這實際上是出奇的簡單加密

116
00:07:13,000 --> 00:07:16,000
如果你能得到正確的數學。

117
00:07:16,000 --> 00:07:19,000
所有這一切需要的是檢查是否或不信你看

118
00:07:19,000 --> 00:07:21,000
是大寫還是小寫。

119
00:07:21,000 --> 00:07:24,000
>> 究其原因，我們只需要檢查，我們並不一定要檢查

120
00:07:24,000 --> 00:07:27,000
是α的情況下是因為

121
00:07:27,000 --> 00:07:30,000
如果一個字符是大寫的，或者如果它是小寫

122
00:07:30,000 --> 00:07:33,000
這絕對是一個字母，

123
00:07:33,000 --> 00:07:38,000
因為我們沒有大寫和小寫的數字。

124
00:07:38,000 --> 00:07:41,000
我們做其他的事情，這是一個小技巧 - 

125
00:07:41,000 --> 00:07:45,000
我們已經修改了標準的愷撒密碼式

126
00:07:45,000 --> 00:07:49,000
我們給問題集規範。

127
00:07:49,000 --> 00:07:52,000
這裡有什麼不同的是，我們減去

128
00:07:52,000 --> 00:07:58,000
A，大寫的情況下，資本，然後我們增加了大寫字母A

129
00:07:58,000 --> 00:08:02,000
備份結束時。

130
00:08:02,000 --> 00:08:05,000
>> 我知道一些你在你的代碼中已經這樣做了。

131
00:08:05,000 --> 00:08:09,000
有沒有你這樣做您提交的嗎？

132
00:08:09,000 --> 00:08:13,000
你這樣做。你能解釋一下這是什麼做的，Sahb？

133
00:08:13,000 --> 00:08:18,000
通過減去它，因為你做了一個mod後，

134
00:08:18,000 --> 00:08:21,000
你必須把它拿出來，這樣一來你[咳嗽]位置。

135
00:08:21,000 --> 00:08:25,000
然後加入回來後移了過來，你想。

136
00:08:25,000 --> 00:08:27,000
是的，沒錯。

137
00:08:27,000 --> 00:08:32,000
什麼Sahb說的是，當我們要添加

138
00:08:32,000 --> 00:08:36,000
我們的信息和我們的鍵

139
00:08:36,000 --> 00:08:42,000
然後國防部稱，國防部，的NUM_LETTERS，

140
00:08:42,000 --> 00:08:50,000
如果我們不擴大我們的信息到相應的0至25的範圍內，第一，

141
00:08:50,000 --> 00:08:54,000
那麼，我們可能最終得到一個非常奇怪的數字

142
00:08:54,000 --> 00:08:59,000
因為，我們正在尋找時，我們期待在消息[I]的值，

143
00:08:59,000 --> 00:09:03,000
當我們看到我們的純文本消息在第i個字符，

144
00:09:03,000 --> 00:09:08,000
在這65至122的範圍內，是一種價值的地方

145
00:09:08,000 --> 00:09:13,000
通過小寫字母z的大寫字母A的ASCII值的基礎上。

146
00:09:13,000 --> 00:09:18,000
因此，當我們mod這26或由NUM_LETTERS的，

147
00:09:18,000 --> 00:09:23,000
因為那是我們的＃define在這裡的右上角，

148
00:09:23,000 --> 00:09:28,000
這給我們一個值，在0至25的範圍內，

149
00:09:28,000 --> 00:09:30,000
我們需要一個方法，然後，備份擴展

150
00:09:30,000 --> 00:09:32,000
並在適當的ASCII範圍。

151
00:09:32,000 --> 00:09:36,000
做到這一點最簡單的方法是，只是規模都記錄下來

152
00:09:36,000 --> 00:09:39,000
到0至25的範圍內，首先，

153
00:09:39,000 --> 00:09:43,000
然後改變一切結束時。

154
00:09:43,000 --> 00:09:46,000
>> 另一個常見的錯誤，我看到了人碰上的是，

155
00:09:46,000 --> 00:09:50,000
實際上，如果你不這樣做縮放馬上

156
00:09:50,000 --> 00:09:53,000
和你添加消息和關鍵，你將它們添加，也就是說，

157
00:09:53,000 --> 00:09:58,000
到一個char變量，問題與

158
00:09:58,000 --> 00:10:01,000
既然這個消息[i]是一個比較大的數量開始

159
00:10:01,000 --> 00:10:05,000
記得至少65，如果它是一個大寫字符

160
00:10:05,000 --> 00:10:09,000
如果你有一個大的關鍵，說，像100，

161
00:10:09,000 --> 00:10:13,000
和你添加那些連成一個符號的字符，你將得到一個溢出。

162
00:10:13,000 --> 00:10:17,000
你會得到一個值，該值大於127，

163
00:10:17,000 --> 00:10:22,000
這是一個char變量可以容納的最大價值。

164
00:10:22,000 --> 00:10:26,000
同樣的，這就是為什麼你會想要做那種事情開始。

165
00:10:26,000 --> 00:10:29,000
有些人得到了解決這種情況下做的，如果其他測試

166
00:10:29,000 --> 00:10:33,000
在這之前，看看它會溢出，

167
00:10:33,000 --> 00:10:36,000
但這種方式得到解決的。

168
00:10:36,000 --> 00:10:40,000
然後在此解決方案中，我們打印出整個字符串在最後。

169
00:10:40,000 --> 00:10:45,000
其他人打印出一個字符的時間。真棒。

170
00:10:45,000 --> 00:10:51,000
在這一點上，你們有任何問題，任何意見？

171
00:10:51,000 --> 00:10:56,000
你喜歡的東西，你不喜歡的東西嗎？

172
00:10:56,000 --> 00:10:58,000
>> 我有一個問題。

173
00:10:58,000 --> 00:11:01,000
也許我錯過了在你的解釋，但如何做這個節目

174
00:11:01,000 --> 00:11:07,000
跳過空格連接的關鍵文本的長度嗎？

175
00:11:07,000 --> 00:11:10,000
這僅僅是愷撒密碼。哦，對不起，是的。

176
00:11:10,000 --> 00:11:13,000
是的，我們會看到這一點。

177
00:11:13,000 --> 00:11:16,000
在愷撒密碼，我們得到了解決，因為

178
00:11:16,000 --> 00:11:18,000
我們只翻個字符。

179
00:11:18,000 --> 00:11:27,000
我們只旋轉他們，如果他們是大寫或小寫。

180
00:11:27,000 --> 00:11:32,000
你們感覺還不錯，對這個嗎？

181
00:11:32,000 --> 00:11:34,000
感覺自由複製這個家，把它，

182
00:11:34,000 --> 00:11:37,000
給你們寫了什麼。

183
00:11:37,000 --> 00:11:42,000
肯定會覺得免費發送關於它的問題。

184
00:11:42,000 --> 00:11:46,000
再次，認識到這裡的目標與您的問題集

185
00:11:46,000 --> 00:11:50,000
不要讓你們來編寫完美的代碼為您的問題集。

186
00:11:50,000 --> 00:11:57,000
這是一個學習的經驗。是啊。

187
00:11:57,000 --> 00:12:01,000
>> 返回的do while循環，如果它等於空，

188
00:12:01,000 --> 00:12:06,000
所以空只是意味著什麼，他們只投中輸入？

189
00:12:06,000 --> 00:12:12,000
null是一個特殊的指針的值，

190
00:12:12,000 --> 00:12:17,000
我們使用空當我們想要說

191
00:12:17,000 --> 00:12:23,000
我們有一個指針變量，它指向沒有。

192
00:12:23,000 --> 00:12:28,000
因此，它通常意味著這個變量，這個消息變量

193
00:12:28,000 --> 00:12:35,000
是空的，在這裡，因為我們使用的是CS50特殊的字符串類型，

194
00:12:35,000 --> 00:12:37,000
的CS50的字符串類型是什麼？

195
00:12:37,000 --> 00:12:42,000
你見過它是什麼，當大衛拉了回來罩在演講嗎？

196
00:12:42,000 --> 00:12:44,000
這是一個時髦的，它是一個指針，對不對？

197
00:12:44,000 --> 00:12:48,000
好吧，是的。>>這是一個char *。

198
00:12:48,000 --> 00:12:52,000
因此，我們真的可以取代

199
00:12:52,000 --> 00:12:56,000
在這裡用char *的消息，

200
00:12:56,000 --> 00:13:04,000
等GetString函數，如果它沒有成功地得到一個字符串的用戶，

201
00:13:04,000 --> 00:13:08,000
它不能解析的字符串，在一種情況下，它不能解析的字符串

202
00:13:08,000 --> 00:13:11,000
是，如果用戶鍵入文件結束字符，控制D，

203
00:13:11,000 --> 00:13:17,000
這是不是你通常做的事情，但如果出現這種情況

204
00:13:17,000 --> 00:13:20,000
然後該函數將返回為空值的一種說法

205
00:13:20,000 --> 00:13:23,000
“嘿，我沒有得到一個字符串。”

206
00:13:23,000 --> 00:13:27,000
會發生什麼，如果我們不把消息= 0，

207
00:13:27,000 --> 00:13:30,000
這是一件好事，我們還沒有做呢？

208
00:13:30,000 --> 00:13:32,000
為什麼會是這樣一個問題在這裡嗎？

209
00:13:32,000 --> 00:13:38,000
因為我知道，我們談了一點點的內存洩漏演講。

210
00:13:38,000 --> 00:13:42,000
是啊，讓我們做到這一點，讓我們看看會發生什麼。

211
00:13:42,000 --> 00:13:44,000
>> 羅勒的問題是會發生什麼，如果我們實際上並沒有

212
00:13:44,000 --> 00:13:48,000
此消息= NULL測試？

213
00:13:48,000 --> 00:13:51,000
讓我們來滾動到頂部。

214
00:13:51,000 --> 00:13:53,000
你們可以評論了這一點。

215
00:13:53,000 --> 00:13:55,000
其實，我將它保存在一個修訂。

216
00:13:55,000 --> 00:13:58,000
這將是第三次修訂版。

217
00:13:58,000 --> 00:14:02,000
你必須運行此程序是，你必須點擊齒輪圖標，在這裡，

218
00:14:02,000 --> 00:14:04,000
你就必須給它添加一個參數。

219
00:14:04,000 --> 00:14:10,000
你必須給它的主要論點，因為我們要通過在命令行中的參數。

220
00:14:10,000 --> 00:14:13,000
在這裡，我要去給它的數量3。我喜歡3。

221
00:14:13,000 --> 00:14:19,000
現在放大，運行該程序。

222
00:14:19,000 --> 00:14:24,000
它的運行，編譯，構建。

223
00:14:24,000 --> 00:14:27,000
在這裡，我們走了。它的等待提示。

224
00:14:27,000 --> 00:14:33,000
如果我輸入的東西，喜歡Hello哪裡去了？

225
00:14:33,000 --> 00:14:38,000
哦，我的程序運行時間太長。我jawing太長時間。

226
00:14:38,000 --> 00:14:40,000
在這裡不言而喻。

227
00:14:40,000 --> 00:14:43,000
現在，我輸入你好。

228
00:14:43,000 --> 00:14:46,000
我們看到它加密適當。

229
00:14:46,000 --> 00:14:52,000
現在會發生什麼，如果我們這樣做迅速的GetString返回null？

230
00:14:52,000 --> 00:14:57,000
請記住，我說，我們這樣做，同時按控制D。

231
00:14:57,000 --> 00:14:59,000
在這裡，我會向上滾動。我們將再次運行。

232
00:14:59,000 --> 00:15:01,000
建設中。就這樣吧。

233
00:15:01,000 --> 00:15:04,000
現在，當我打控制D

234
00:15:04,000 --> 00:15:12,000
我說opt/sandbox50/bin/run.sh，這條線分割故障。

235
00:15:12,000 --> 00:15:15,000
你們有沒有看到過嗎？

236
00:15:15,000 --> 00:15:17,000
>> [學生]：為什麼沒有“對不起？

237
00:15:17,000 --> 00:15:20,000
[學生]：為什麼在這種情況下，是沒有核心轉儲？

238
00:15:20,000 --> 00:15:26,000
核心轉儲的問題是，為什麼沒有核心轉儲這裡嗎？

239
00:15:26,000 --> 00:15:29,000
問題是有可能，但核心轉儲的文件

240
00:15:29,000 --> 00:15:31,000
被存儲在硬盤驅動器。

241
00:15:31,000 --> 00:15:34,000
在這種情況下，我們已禁用核心轉儲

242
00:15:34,000 --> 00:15:37,000
運行服務器上，所以我們沒有人段斷層

243
00:15:37,000 --> 00:15:40,000
建立核心轉儲噸。

244
00:15:40,000 --> 00:15:46,000
但你可能會得到一個。

245
00:15:46,000 --> 00:15:48,000
核心內存轉儲文件之類的事情，你經常可以禁用，

246
00:15:48,000 --> 00:15:52,000
有時你做的。

247
00:15:52,000 --> 00:15:55,000
分割故障，回答你的問題，羅勒，

248
00:15:55,000 --> 00:16:00,000
是說，在我們試圖訪問一個指針

249
00:16:00,000 --> 00:16:05,000
沒有被設置為指向任何。

250
00:16:05,000 --> 00:16:09,000
視頻的時候Binky試圖記住Binky

251
00:16:09,000 --> 00:16:12,000
去訪問的指針沒有指向什麼？

252
00:16:12,000 --> 00:16:16,000
在這種情況下，我想技術上的指針指向的東西。

253
00:16:16,000 --> 00:16:20,000
它指向空，這在技術上是0，

254
00:16:20,000 --> 00:16:25,000
但是這被定義為在一個段是無法訪問的

255
00:16:25,000 --> 00:16:28,000
你的程序，你會得到一個分割故障

256
00:16:28,000 --> 00:16:31,000
因為你不訪問內存中一個有效的段

257
00:16:31,000 --> 00:16:38,000
像堆段或堆棧段或數據段。

258
00:16:38,000 --> 00:16:40,000
酷。

259
00:16:40,000 --> 00:16:48,000
任何更多的問題，凱撒？

260
00:16:48,000 --> 00:16:51,000
>> 讓我們繼續前進。讓我們來看看在第二次修訂真的很快。

261
00:16:51,000 --> 00:17:00,000
這是維瓊內爾。

262
00:17:00,000 --> 00:17:04,000
在這裡，維瓊內爾

263
00:17:04,000 --> 00:17:06,000
我們將步行通過這個很快，因為再次，

264
00:17:06,000 --> 00:17:10,000
維瓊內爾和凱撒是非常相似的。

265
00:17:10,000 --> 00:17:12,000
頭註釋之前，

266
00:17:12,000 --> 00:17:17,000
＃define的前避免使用這些神奇的數字。

267
00:17:17,000 --> 00:17:21,000
這種做法的好處是說，我們希望遷移到

268
00:17:21,000 --> 00:17:23,000
不同的字母或類似的東西。

269
00:17:23,000 --> 00:17:26,000
而不是去手動更改所有的26個代碼中的

270
00:17:26,000 --> 00:17:30,000
我們可以改變這27或砸下來

271
00:17:30,000 --> 00:17:34,000
如果我們使用不同的字母表，不同的語言。

272
00:17:34,000 --> 00:17:38,000
同樣，我們已經得到了這個檢查計數參數，

273
00:17:38,000 --> 00:17:42,000
真的是你幾乎可以作為一個模板。

274
00:17:42,000 --> 00:17:46,000
幾乎每一個你寫的程序應該有

275
00:17:46,000 --> 00:17:50,000
如果需要命令行參數的一些序列的線

276
00:17:50,000 --> 00:17:55,000
在開始的時候是這樣的。

277
00:17:55,000 --> 00:17:59,000
這是一個你想要做的第一次完整性測試。

278
00:17:59,000 --> 00:18:03,000
>> 這裡，我們所做的只是我們確信，

279
00:18:03,000 --> 00:18:06,000
關鍵字是有效的，那就是，我們做了第二次檢查。

280
00:18:06,000 --> 00:18:11,000
再次注意，我們分開argc和2。

281
00:18:11,000 --> 00:18:14,000
請注意，在這種情況下，我們需要做的是一件事，而不是

282
00:18:14,000 --> 00:18:18,000
使用我，我們想驗證的整個字符串，

283
00:18:18,000 --> 00:18:21,000
在為了做到這一點，你確實有去逐個字符

284
00:18:21,000 --> 00:18:23,000
在字符串。

285
00:18:23,000 --> 00:18:29,000
有沒有很好的方法來調用一下就可以了

286
00:18:29,000 --> 00:18:31,000
因為即使，例如，一個我將返回0

287
00:18:31,000 --> 00:18:37,000
如果它不能解析一個整數，所以，甚至不工作。

288
00:18:37,000 --> 00:18:42,000
同樣，不錯的消息，告訴用戶究竟發生了什麼事。

289
00:18:42,000 --> 00:18:45,000
那麼在這裡，再次，我們也處理的情況下，

290
00:18:45,000 --> 00:18:50,000
用戶控制三維隨機字符類型。

291
00:18:50,000 --> 00:18:54,000
>> 然後夏洛特有一個問題，我們如何管理跳過空格

292
00:18:54,000 --> 00:18:57,000
在我們的字符串。

293
00:18:57,000 --> 00:19:00,000
這是一種類似我們所做的Myspace程序

294
00:19:00,000 --> 00:19:04,000
我們所做的部分，工作的方式，這

295
00:19:04,000 --> 00:19:08,000
是我們跟踪的數量，我們看到的字母。

296
00:19:08,000 --> 00:19:13,000
當我們走在消息字符串，因為我們逐個字符地走了過來，

297
00:19:13,000 --> 00:19:16,000
我們跟踪的指數的一部分，我們的for循環，然後我們也跟踪

298
00:19:16,000 --> 00:19:21,000
數量的字母，所以非特殊字符，非數字，非空白

299
00:19:21,000 --> 00:19:27,000
我們看到在單獨的變量。

300
00:19:27,000 --> 00:19:33,000
然後，該解決方案修改的關鍵

301
00:19:33,000 --> 00:19:41,000
得到一個實際的的關鍵整數，它確實是在飛行中，

302
00:19:41,000 --> 00:19:47,000
右，然後到實際的消息字符進行加密。

303
00:19:47,000 --> 00:19:50,000
有一些解決方案，是完全

304
00:19:50,000 --> 00:19:58,000
將修改鍵時，關鍵的有效性進行測試。

305
00:19:58,000 --> 00:20:01,000
除，以確保該字符和關鍵字

306
00:20:01,000 --> 00:20:05,000
是按字母順序排列的字符也變成為一個整數

307
00:20:05,000 --> 00:20:13,000
在0至25的範圍內，然後跳過做到這一點後來在for循環。

308
00:20:13,000 --> 00:20:18,000
同樣，你在這裡看到的，這真的是完全一樣的代碼

309
00:20:18,000 --> 00:20:22,000
在這一點上，我們在凱撒。

310
00:20:22,000 --> 00:20:25,000
你這樣做完全一樣的東西，所以真正的關鍵是搞清楚

311
00:20:25,000 --> 00:20:30,000
如何把關鍵字轉換為整數。

312
00:20:30,000 --> 00:20:35,000
>> 有一件事，我們在這裡做的是有點晦澀難懂

313
00:20:35,000 --> 00:20:39,000
是我們重複這句話，我想你可以稱它，

314
00:20:39,000 --> 00:20:45,000
3個獨立的上線58，59和61倍。

315
00:20:45,000 --> 00:20:52,000
有人可以解釋這句話究竟是什麼做的嗎？

316
00:20:52,000 --> 00:20:55,000
訪問的是一個字符，像你說的。

317
00:20:55,000 --> 00:20:59,000
是的，這是聽不見的字符的關鍵字，

318
00:20:59,000 --> 00:21:04,000
所以它的數量，因為你只沿著看到的字母

319
00:21:04,000 --> 00:21:06,000
關鍵字，一旦你已經看到了這封信，

320
00:21:06,000 --> 00:21:10,000
因此，要有效地跳過空格之類的東西。

321
00:21:10,000 --> 00:21:12,000
是的，沒錯。

322
00:21:12,000 --> 00:21:16,000
然後，一旦你已經看到了你剛模的關鍵字空白，所以你搬回左右。

323
00:21:16,000 --> 00:21:18,000
沒錯。這是一個完美的解釋。

324
00:21:18,000 --> 00:21:23,000
凱文說的是，我們要索引關鍵字。

325
00:21:23,000 --> 00:21:28,000
我們希望得到字符的num_letters_seen，如果你願意，

326
00:21:28,000 --> 00:21:32,000
，但如果num_letters_seen超過關鍵字的長度，

327
00:21:32,000 --> 00:21:37,000
到適當的範圍內，我們得到的是我們用mod運算符

328
00:21:37,000 --> 00:21:40,000
有效地環繞。

329
00:21:40,000 --> 00:21:43,000
例如，如在短期內，我們的關鍵詞是臘肉，

330
00:21:43,000 --> 00:21:46,000
和它的5個字母長。

331
00:21:46,000 --> 00:21:50,000
但在這一點上，我們已經看到了6個字母在我們的純文本

332
00:21:50,000 --> 00:21:52,000
和加密。

333
00:21:52,000 --> 00:21:57,000
我們最終將訪問num_letters_seen，

334
00:21:57,000 --> 00:22:00,000
這是模的長度的關鍵字，5，6，

335
00:22:00,000 --> 00:22:04,000
，所以我們會得到1，而我們要做的是，我們將

336
00:22:04,000 --> 00:22:14,000
在這一點上，我們的關鍵字內部訪問的第一個字符。

337
00:22:14,000 --> 00:22:21,000
>> 所有的權利，任何上維瓊內爾的問題

338
00:22:21,000 --> 00:22:26,000
在我們繼續之前嗎？

339
00:22:26,000 --> 00:22:31,000
你們感覺還不錯，對這個嗎？

340
00:22:31,000 --> 00:22:35,000
酷，太棒了。

341
00:22:35,000 --> 00:22:38,000
我想，以確保你們有機會看到代碼

342
00:22:38,000 --> 00:22:48,000
我們認為看起來不錯，有機會向它學習。

343
00:22:48,000 --> 00:22:53,000
這將是最後一次，我們將使用空間的時間是，

344
00:22:53,000 --> 00:22:59,000
我們要轉變目前，，我去cs50.net/lectures的

345
00:22:59,000 --> 00:23:06,000
所以我們可以做一點點的測驗審查。

346
00:23:06,000 --> 00:23:10,000
我認為最好的方式，開始做測驗複習

347
00:23:10,000 --> 00:23:15,000
是來此講座頁，cs50.net/lectures

348
00:23:15,000 --> 00:23:20,000
下一周的標題，所以，如果我在這裡看在第0週，

349
00:23:20,000 --> 00:23:27,000
我看到我們有一個列表的主題，我們討論了在0週。

350
00:23:27,000 --> 00:23:31,000
>> 如果任何這些主題似乎你不熟悉的

351
00:23:31,000 --> 00:23:34,000
你一定要回去和沖刷的講義，並可能

352
00:23:34,000 --> 00:23:39,000
即使撇去通過講座，觀看他們，如果你想要的

353
00:23:39,000 --> 00:23:44,000
這是怎麼回事每個主題的的感覺。

354
00:23:44,000 --> 00:23:49,000
另外，我會說今年的一個很酷的資源，我們已經得到了

355
00:23:49,000 --> 00:23:55,000
是，我們已經創建了這些短褲，如果你看一下在第0週，

356
00:23:55,000 --> 00:24:00,000
我們並沒有覆蓋所有的主題，但我們已經有了相當多的，

357
00:24:00,000 --> 00:24:03,000
一些棘手的，所以再次看著這些短褲

358
00:24:03,000 --> 00:24:08,000
是一個很好的辦法讓你加快速度。

359
00:24:08,000 --> 00:24:15,000
特別是，我要在一個插件為3的底部，因為我做了那些。

360
00:24:15,000 --> 00:24:20,000
但是，如果你掙扎二進制位，十六進制，這樣的東西，

361
00:24:20,000 --> 00:24:22,000
二進制是一個偉大的地方開始。

362
00:24:22,000 --> 00:24:25,000
ASCII是另外一個，這是很好的查看過。

363
00:24:25,000 --> 00:24:31,000
你甚至可以看我在1.5倍的速度太慢了，如果我要去。

364
00:24:31,000 --> 00:24:35,000
由於它的檢討，覺得要做到這一點。

365
00:24:35,000 --> 00:24:40,000
>> 剛開始真的很快，我們要通過一對夫婦的這些測驗的問題

366
00:24:40,000 --> 00:24:44,000
只是通過這些流失。

367
00:24:44,000 --> 00:24:50,000
例如，讓我們來看看，我有問題16在黑板上。

368
00:24:50,000 --> 00:24:54,000
我們有以下計算以二進制，

369
00:24:54,000 --> 00:24:56,000
我們想要顯示的任何工作。

370
00:24:56,000 --> 00:24:59,000
好吧，我想給這一個鏡頭。

371
00:24:59,000 --> 00:25:01,000
你們應該跟隨紙，

372
00:25:01,000 --> 00:25:04,000
我們會做到這一點真的很快。

373
00:25:04,000 --> 00:25:06,000
我們要的二進制執行下列計算。

374
00:25:06,000 --> 00:25:16,000
我有00110010。

375
00:25:16,000 --> 00:25:27,000
我要添加它00110010。

376
00:25:27,000 --> 00:25:30,000
對於數學天才，在家裡，

377
00:25:30,000 --> 00:25:35,000
這是有效地乘以2。

378
00:25:35,000 --> 00:25:37,000
讓我們開始。

379
00:25:37,000 --> 00:25:39,000
我們要遵循相同的加法運算，我們做

380
00:25:39,000 --> 00:25:43,000
當我們添加的十進制數。

381
00:25:43,000 --> 00:25:46,000
真的是這裡唯一的區別是，我們回圈周圍

382
00:25:46,000 --> 00:25:51,000
一旦我們擁有了1 + 1，而不是一旦我們得到10個。

383
00:25:51,000 --> 00:25:53,000
>> 如果我們從右邊開始，真的很快，第一個數字嗎？

384
00:25:53,000 --> 00:25:55,000
[學生]：0。>> [內特H.] 0。

385
00:25:55,000 --> 00:25:58,000
大，第二個數字嗎？

386
00:25:58,000 --> 00:26:00,000
[學生]：1。

387
00:26:00,000 --> 00:26:02,000
[內特H.]它是一個1？ 1 + 1是什麼？

388
00:26:02,000 --> 00:26:04,000
[學生]：10。

389
00:26:04,000 --> 00:26:08,000
[內特H.]沒錯，那麼什麼是數字，我寫的正下方加在一起呢？

390
00:26:08,000 --> 00:26:11,000
[學生] 1，0，0，然後再進行1。

391
00:26:11,000 --> 00:26:15,000
[內特H.] 0和1，攜帶完全。

392
00:26:15,000 --> 00:26:18,000
接下來一起來，羅勒，該你了。

393
00:26:18,000 --> 00:26:20,000
什麼是第三個呢？>> [羅勒] 1。

394
00:26:20,000 --> 00:26:23,000
內特H.] 1，完善。凱文？

395
00:26:23,000 --> 00:26:27,000
[凱文] 0。>> [內特H.] 0，夏洛特？

396
00:26:27,000 --> 00:26:30,000
[山貓] 0。>> [內特H.]是啊，我該怎麼辦？

397
00:26:30,000 --> 00:26:32,000
[學生]：1。

398
00:26:32,000 --> 00:26:34,000
[內特H.]我該怎麼辦？然後，我攜帶1。

399
00:26:34,000 --> 00:26:36,000
完美，Sahb >> [Sahb]現在你有1個。

400
00:26:36,000 --> 00:26:40,000
[內特H.]我在這裡做什麼？

401
00:26:40,000 --> 00:26:43,000
[Sahb]，然後在你下一次有1個，因為你結轉1。

402
00:26:43,000 --> 00:26:49,000
內特H.大，所以在這裡我們就可以完成了。

403
00:26:49,000 --> 00:26:51,000
酷。

404
00:26:51,000 --> 00:26:54,000
[學生]：0 + 0 = 0？

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0。

406
00:26:56,000 --> 00:27:01,000
1 + 1，像你說的，是10個或1，0，而。

407
00:27:01,000 --> 00:27:07,000
10是用詞不當，因為我的10是指10號，

408
00:27:07,000 --> 00:27:12,000
這是我們如何代表它時，我們正在編寫的怪癖。

409
00:27:12,000 --> 00:27:20,000
我們代表數字2，1，0，和10號是略有不同的。

410
00:27:20,000 --> 00:27:23,000
>> 是一種不錯的關於二進制是什麼，真的沒有那麼多的

411
00:27:23,000 --> 00:27:25,000
情況下，你需要學習。

412
00:27:25,000 --> 00:27:30,000
有0 + 0 = 0，0 + 1 = 1，

413
00:27:30,000 --> 00:27:34,000
1 + 1為0，然後再進行1，

414
00:27:34,000 --> 00:27:37,000
然後你可以在這裡看到第三列從右邊

415
00:27:37,000 --> 00:27:40,000
我們有這個1，1，和1。

416
00:27:40,000 --> 00:27:43,000
和1 + 1 + 1是1，則

417
00:27:43,000 --> 00:27:45,000
攜帶其他1。

418
00:27:45,000 --> 00:27:48,000
當你做二進制加法，很簡單。

419
00:27:48,000 --> 00:27:51,000
完整性檢查自己，我做了這些夫婦更

420
00:27:51,000 --> 00:27:54,000
在你走之前，因為這是

421
00:27:54,000 --> 00:28:00,000
或許我們會看到的測驗。

422
00:28:00,000 --> 00:28:03,000
現在，讓我們做下一個。

423
00:28:03,000 --> 00:28:06,000
讓我們做的問題17。

424
00:28:06,000 --> 00:28:12,000
我們將以下二進制數轉換為十進制。

425
00:28:12,000 --> 00:28:28,000
我有10100111001。

426
00:28:28,000 --> 00:28:33,000
請記住，在我做的二進制視頻

427
00:28:33,000 --> 00:28:36,000
我走過一對夫婦的例子，我展示了如何

428
00:28:36,000 --> 00:28:41,000
一切正常，當你這樣做是在十進制。

429
00:28:41,000 --> 00:28:45,000
當你在工作中的十進制表示，我認為，我們

430
00:28:45,000 --> 00:28:48,000
這一點在我們的生活中，流利的

431
00:28:48,000 --> 00:28:53,000
這是很容易掩飾它是如何工作的機制。

432
00:28:53,000 --> 00:28:59,000
>> 但是，要做到快速回顧一下，如果我有137

433
00:28:59,000 --> 00:29:06,000
這實際上意味著再次，這是在十進制表示

434
00:29:06,000 --> 00:29:19,000
十進制的137，我有1×100 + 3×10 + 7×1。

435
00:29:19,000 --> 00:29:22,000
這一切都停留在屏幕上。

436
00:29:22,000 --> 00:29:29,000
然後，如果你看看這些數字就在這裡，

437
00:29:29,000 --> 00:29:34,000
100，10，1，你看，它們實際上是一切權力的10。

438
00:29:34,000 --> 00:29:43,000
我有10 2，10 1，和10到零。

439
00:29:43,000 --> 00:29:48,000
我們有一個相類似的事情在二進制，

440
00:29:48,000 --> 00:29:55,000
除了我們的基地，我們把它稱為是2，而不是10。

441
00:29:55,000 --> 00:29:58,000
這些10秒，我在這裡寫下的底部，

442
00:29:58,000 --> 00:30:02,000
這10 2，10 1，10到零，10是我們的基地，

443
00:30:02,000 --> 00:30:08,000
和指數，0，1，或2，

444
00:30:08,000 --> 00:30:14,000
是隱含的數量，我們寫的數字的位置。

445
00:30:14,000 --> 00:30:21,000
1，如果我們看一下吧，這是在第二的位置。

446
00:30:21,000 --> 00:30:27,000
圖3是在第一位置，和圖7是在第0個位置。

447
00:30:27,000 --> 00:30:35,000
這就是我們得到的各種指數，以下為我們的基地。

448
00:30:35,000 --> 00:30:40,000
>> 在此我們將實際，你知道嗎？

449
00:30:40,000 --> 00:30:43,000
我們會盡我撤消“按鈕去了？

450
00:30:43,000 --> 00:30:45,000
就這樣吧。

451
00:30:45,000 --> 00:30:47,000
我喜歡這撤消事情。

452
00:30:47,000 --> 00:30:51,000
在此，我認為至少對我來說

453
00:30:51,000 --> 00:30:54,000
最簡單的方法開始將二進制數轉換

454
00:30:54,000 --> 00:30:57,000
或十六進制數，其中的鹼是16

455
00:30:57,000 --> 00:31:02,000
而不是10或2繼續前進，寫出來的

456
00:31:02,000 --> 00:31:09,000
我在上面的二進制數中的數字的基準和指數。

457
00:31:09,000 --> 00:31:14,000
如果我們開始從左至右再次，

458
00:31:14,000 --> 00:31:17,000
這是一種違反直覺的，

459
00:31:17,000 --> 00:31:23,000
我會重新變回黑色在這裡，我們有2至第0個位置，

460
00:31:23,000 --> 00:31:27,000
然後我們有2 1，2 2，

461
00:31:27,000 --> 00:31:33,000
然後2 3，2 4，2 5，6，

462
00:31:33,000 --> 00:31:39,000
7，8，9和10。

463
00:31:39,000 --> 00:31:41,000
我已經寫了這些數字是所有的指數。

464
00:31:41,000 --> 00:31:48,000
我只寫了基地在第3的空間。

465
00:31:48,000 --> 00:31:50,000
>> 在這一點上，我要繼續前進，我要刪除

466
00:31:50,000 --> 00:31:53,000
的東西，我們在小數，如果那也沒關係。

467
00:31:53,000 --> 00:31:57,000
你都明白了。

468
00:31:57,000 --> 00:32:05,000
你看網上我敢肯定，將能夠倒帶我，如果你想。

469
00:32:05,000 --> 00:32:07,000
切換回筆。

470
00:32:07,000 --> 00:32:12,000
現在，我們可以做的，如果你們不完全取決於你的權力，以加快2，

471
00:32:12,000 --> 00:32:15,000
這是很酷。

472
00:32:15,000 --> 00:32:18,000
它發生。我明白了。

473
00:32:18,000 --> 00:32:23,000
我曾經有一個面試時，有人告訴我，我應該知道的一切權力2

474
00:32:23,000 --> 00:32:26,000
通過2的30。

475
00:32:26,000 --> 00:32:29,000
這不是我的工作。

476
00:32:29,000 --> 00:32:32,000
總之，你們可以繼續在這裡做數學題，

477
00:32:32,000 --> 00:32:35,000
但與二進制文件，它沒有真正意義的，

478
00:32:35,000 --> 00:32:38,000
它也不有意義的十進制或十六進制，

479
00:32:38,000 --> 00:32:43,000
做數學題，你在哪裡有零。

480
00:32:43,000 --> 00:32:49,000
你可以看到我有0在這裡，這裡的0，0在這裡，在這裡，在這裡，在這裡。

481
00:32:49,000 --> 00:32:52,000
為什麼它可能沒有任何意義，做實際的數學

482
00:32:52,000 --> 00:32:56,000
該位置計算出相應的功率為2？

483
00:32:56,000 --> 00:32:59,000
沒錯，像夏洛特說，這將是0。

484
00:32:59,000 --> 00:33:05,000
還不如節省自己的時間，如果計算2的冪是不是你的強項。

485
00:33:05,000 --> 00:33:10,000
在這種情況下，我們只需要計算它的0-2？

486
00:33:10,000 --> 00:33:12,000
[學生]：1。

487
00:33:12,000 --> 00:33:14,000
[內特H.] 1，2到3是-？

488
00:33:14,000 --> 00:33:16,000
[學生] >> [內特H.] 8。

489
00:33:16,000 --> 00:33:18,000
2到4？

490
00:33:18,000 --> 00:33:21,000
[學生]：2。對不起，1。

491
00:33:21,000 --> 00:33:26,000
[內特H.] 2至4是16的，沒錯。

492
00:33:26,000 --> 00:33:28,000
2到5，凱文？>> 32。

493
00:33:28,000 --> 00:33:32,000
[內特H.] 32，2到8？

494
00:33:32,000 --> 00:33:38,000
[學生]：32×8，256。

495
00:33:38,000 --> 00:33:41,000
[內特H.]完美。

496
00:33:41,000 --> 00:33:43,000
和2至10嗎？

497
00:33:43,000 --> 00:33:45,000
[學生] 1024。

498
00:33:45,000 --> 00:33:49,000
[內特H.]是啊，1024。

499
00:33:49,000 --> 00:33:57,000
>> 一旦我們得到這些數字，我們可以總結他們所有。

500
00:33:57,000 --> 00:34:01,000
這是它做的幾件事情是非常重要的。

501
00:34:01,000 --> 00:34:07,000
一個緩慢，並檢查您的工作。

502
00:34:07,000 --> 00:34:10,000
在年底這個數字，你可以告訴大家有一個1，

503
00:34:10,000 --> 00:34:15,000
我的結果，所以我一定要得到一個奇數，

504
00:34:15,000 --> 00:34:18,000
因為所有其他的人都將是偶數

505
00:34:18,000 --> 00:34:21,000
因為，這是一個二進制數。

506
00:34:21,000 --> 00:34:24,000
其他的事情是，如果你得到這一點在測試

507
00:34:24,000 --> 00:34:27,000
你寫的這一步

508
00:34:27,000 --> 00:34:30,000
和你的時間不多了

509
00:34:30,000 --> 00:34:33,000
看的點的數量，此問題是值得的。

510
00:34:33,000 --> 00:34:40,000
這個問題，你可以看到，如果我迅速翻轉回我的筆記本電腦真的，

511
00:34:40,000 --> 00:34:44,000
這個問題是值得2分，所以這不是那種此外

512
00:34:44,000 --> 00:34:47,000
你應當經歷的，如果你真的時間緊迫。

513
00:34:47,000 --> 00:34:52,000
但我們會切換到iPad上，我們將通過它真的很快。

514
00:34:52,000 --> 00:34:54,000
>> 我喜歡做的小數字第一

515
00:34:54,000 --> 00:34:56,000
因為我發現，更容易。

516
00:34:56,000 --> 00:35:00,000
我喜歡32和8，因為他們走在一起很容易，我們得到50。

517
00:35:00,000 --> 00:35:03,000
16和1得到17。

518
00:35:03,000 --> 00:35:05,000
在那裡，我們得到57，

519
00:35:05,000 --> 00:35:14,000
然後，我們可以做的其餘部分，所以我們可以做的57，156。

520
00:35:14,000 --> 00:35:16,000
來吧。

521
00:35:16,000 --> 00:35:19,000
人，好了，讓我們來看看。

522
00:35:19,000 --> 00:35:27,000
我們有57，256和1024。

523
00:35:27,000 --> 00:35:31,000
在這一點上，我寧願去。

524
00:35:31,000 --> 00:35:35,000
我不知道。我清楚地讀了。

525
00:35:35,000 --> 00:35:40,000
7，6，和4中，您可以在17。

526
00:35:40,000 --> 00:35:42,000
1，5，5，2，13。

527
00:35:42,000 --> 00:35:45,000
然後，我們得到了3，然後我們得到1。

528
00:35:45,000 --> 00:35:52,000
1337年。

529
00:35:52,000 --> 00:35:55,000
復活節彩蛋，任何人？

530
00:35:55,000 --> 00:35:59,000
任何人都承認這個數字嗎？

531
00:35:59,000 --> 00:36:02,000
克里斯識別數字。是什麼意思，克里斯？

532
00:36:02,000 --> 00:36:04,000
[克里斯] LEET。

533
00:36:04,000 --> 00:36:11,000
LEET，所以如果你看看這個，它看起來像利特。

534
00:36:11,000 --> 00:36:15,000
黑客的東西。注意在期中考試或測驗，而這樣的東西。

535
00:36:15,000 --> 00:36:19,000
如果你看到這樣的東西，你想知道“咦”

536
00:36:19,000 --> 00:36:22,000
這可能意味著什麼。

537
00:36:22,000 --> 00:36:24,000
我不知道。大衛喜歡它。

538
00:36:24,000 --> 00:36:26,000
這是一個好辦法，完整性檢查。

539
00:36:26,000 --> 00:36:30,000
像好吧，我可以看看會發生什麼。

540
00:36:30,000 --> 00:36:34,000
>> 這是週0/Week東西。

541
00:36:34,000 --> 00:36:39,000
如果我們切換到我們的筆記本電腦，現在，

542
00:36:39,000 --> 00:36:46,000
縮小，和一些其他的事情。

543
00:36:46,000 --> 00:36:50,000
有ASCII，這是我們已經做了很多的問題集。

544
00:36:50,000 --> 00:36:55,000
A.資本這個概念什麼是真的嗎？

545
00:36:55,000 --> 00:36:57,000
知道它的十進制整數。

546
00:36:57,000 --> 00:37:00,000
65是它被映射到ASCII表中，

547
00:37:00,000 --> 00:37:03,000
因此，這是電腦如何寫，

548
00:37:03,000 --> 00:37:06,000
這就是我們已經越來越遠，其實寫

549
00:37:06,000 --> 00:37:09,000
字符大寫字母A和字符小寫的a

550
00:37:09,000 --> 00:37:14,000
在一些你一直在做的這些解決方案和習題集。

551
00:37:14,000 --> 00:37:16,000
一對夫婦的其他東西。

552
00:37:16,000 --> 00:37:25,000
我們有報表，布爾表達式，條件，循環，變量和線程。

553
00:37:25,000 --> 00:37:29,000
>> 這些都似乎最有意義嗎？

554
00:37:29,000 --> 00:37:35,000
這個術語有時是有點時髦的。

555
00:37:35,000 --> 00:37:46,000
我喜歡的一份聲明中認為，大部分的東西，以一個分號結束。

556
00:37:46,000 --> 00:37:51,000
報表如x = 7，設置一個變量，

557
00:37:51,000 --> 00:37:54,000
想必稱為x = 7。

558
00:37:54,000 --> 00:38:01,000
據推測x是一個類型，可以存儲數字7，

559
00:38:01,000 --> 00:38:05,000
因此它可能是一個int或float或短或一個字符，

560
00:38:05,000 --> 00:38:07,000
類似的東西。

561
00:38:07,000 --> 00:38:12,000
布爾表達式是使用這些雙等號

562
00:38:12,000 --> 00:38:17,000
爆炸等於或不等於，小於，大於，

563
00:38:17,000 --> 00:38:22,000
小於或等於，所有這樣的東西。

564
00:38:22,000 --> 00:38:28,000
條件是if else語句。

565
00:38:28,000 --> 00:38:32,000
我會記住，你不能有別的沒有相應的如果。

566
00:38:32,000 --> 00:38:37,000
同樣，你可以沒有其他，如果沒有相應的如果。

567
00:38:37,000 --> 00:38:40,000
循環，召回的3種循環已經被錘打成

568
00:38:40,000 --> 00:38:43,000
特別是最近幾個部分和習題集。

569
00:38:43,000 --> 00:38:46,000
使用，而當你獲取用戶輸入，

570
00:38:46,000 --> 00:38:51,000
使用whil​​e循環，直到特定的條件是真實的，

571
00:38:51,000 --> 00:38:56,000
然後利用這些循環，如果你需要的

572
00:38:56,000 --> 00:39:01,000
你知道循環迭代目前是我想想。

573
00:39:01,000 --> 00:39:07,000
或者，如果你做了我想要做的事情在一個字符串中的每個字符，

574
00:39:07,000 --> 00:39:15,000
我想要做的事，該元素在數組中的每個元素。

575
00:39:15,000 --> 00:39:18,000
>> 線程和事件。

576
00:39:18,000 --> 00:39:21,000
這些我們還沒有涉及到明確在C中，

577
00:39:21,000 --> 00:39:23,000
但是請記住這個從頭開始。

578
00:39:23,000 --> 00:39:26,000
這是概念具有不同的腳本。

579
00:39:26,000 --> 00:39:32,000
廣播事件，這也是這個概念。

580
00:39:32,000 --> 00:39:37,000
有些人不使用廣播最初在自己的項目，

581
00:39:37,000 --> 00:39:40,000
這是很酷的，

582
00:39:40,000 --> 00:39:46,000
但這些都被稱為並發兩種不同的方式處理這個更大的問題，

583
00:39:46,000 --> 00:39:49,000
這是你如何讓程序執行

584
00:39:49,000 --> 00:39:54,000
或看似同時執行？

585
00:39:54,000 --> 00:39:59,000
不同的任務運行，而其他任務同時運行。

586
00:39:59,000 --> 00:40:01,000
這是你的操作系統是如何工作的。

587
00:40:01,000 --> 00:40:04,000
這就是為什麼，即使，例如，

588
00:40:04,000 --> 00:40:10,000
我有我的瀏覽器中運行，我也可以將Spotify的，播放一首歌曲。

589
00:40:10,000 --> 00:40:14,000
這是一個概念性的東西了解。

590
00:40:14,000 --> 00:40:17,000
我想看一看線程的短

591
00:40:17,000 --> 00:40:21,000
如果您想了解更多關於。

592
00:40:21,000 --> 00:40:26,000
>> 讓我們來看看，我認為有可能是

593
00:40:26,000 --> 00:40:31,000
其中的一個一個問題，在這個問題上。

594
00:40:31,000 --> 00:40:35,000
同樣，我認為是不是線程和事件，我們將介紹在C

595
00:40:35,000 --> 00:40:41,000
只是因為它的顯著更多的困難比在Scratch。

596
00:40:41,000 --> 00:40:44,000
你不應該擔心它有，但絕對明白的概念，

597
00:40:44,000 --> 00:40:47,000
明白發生了什麼事情。

598
00:40:47,000 --> 00:40:52,000
在我們繼續之前，任何問題上0週材料？

599
00:40:52,000 --> 00:40:55,000
每個人都感覺還不錯呢？

600
00:40:55,000 --> 00:41:03,000
了解變量，什麼是變量？

601
00:41:03,000 --> 00:41:08,000
>> 移動。每週1次。

602
00:41:08,000 --> 00:41:12,000
一對夫婦的事情，在這裡，沒有覆蓋

603
00:41:12,000 --> 00:41:21,000
在測驗審查必要的，也有更多的概念性的東西，去思考。

604
00:41:21,000 --> 00:41:30,000
首先是這個概念的源代碼，編譯代碼和目標代碼是什麼。

605
00:41:30,000 --> 00:41:32,000
任何人？羅勒。

606
00:41:32,000 --> 00:41:37,000
是對象的代碼，我的意思是源代碼是什麼，你把鐺，

607
00:41:37,000 --> 00:41:42,000
代碼和目標代碼是什麼鐺放出來，讓您的計算機可以讀取的程序。

608
00:41:42,000 --> 00:41:44,000
沒錯。

609
00:41:44,000 --> 00:41:47,000
源代碼是C代碼，您輸入。

610
00:41:47,000 --> 00:41:50,000
目標代碼是你得到了什麼鐺。

611
00:41:50,000 --> 00:41:54,000
這是“0”和“1，二進制格式。

612
00:41:54,000 --> 00:41:59,000
那會發生什麼情況是，當你有一大堆的目標文件，

613
00:41:59,000 --> 00:42:04,000
說你要編譯一個項目或程序使用多個源代碼文件，

614
00:42:04,000 --> 00:42:09,000
按照慣例給定的文件擴展名。

615
00:42:09,000 --> 00:42:13,000
那為什麼我們caesar.c，vigenère.c。

616
00:42:13,000 --> 00:42:18,000
如果你正在編寫Java程序，你給他們的。java擴展名。

617
00:42:18,000 --> 00:42:24,000
Python程序。py擴展名通常。

618
00:42:24,000 --> 00:42:26,000
>> 一旦你有多個c文件，編譯它們。

619
00:42:26,000 --> 00:42:29,000
鐺吐出了這一切二進制垃圾。

620
00:42:29,000 --> 00:42:33,000
然後，因為你只需要1個程序

621
00:42:33,000 --> 00:42:37,000
你有鏈接器鏈接所有這些對象文件一起

622
00:42:37,000 --> 00:42:40,000
為1可執行文件。

623
00:42:40,000 --> 00:42:45,000
這也是發生了什麼，當你使用的CS50庫，例如。

624
00:42:45,000 --> 00:42:50,000
CS50庫既h頭文件。

625
00:42:50,000 --> 00:42:53,000
您閱讀，＃includecs50.h。

626
00:42:53,000 --> 00:42:58,000
那麼它也是一個特殊的二進制庫文件

627
00:42:58,000 --> 00:43:02,000
被編譯的，是“0”和“1，

628
00:43:02,000 --> 00:43:08,000
和-L標誌，因此，如果我們回到我們的空間，我們期待真的很快

629
00:43:08,000 --> 00:43:11,000
在這裡發生了什麼事情，當我們看我們的鐺命令，

630
00:43:11,000 --> 00:43:15,000
我們得到的是在這裡，這是我們的源代碼文件。

631
00:43:15,000 --> 00:43:18,000
這是一群編譯器的標誌。

632
00:43:18,000 --> 00:43:22,000
然後在最後，這些在-l標誌鏈接

633
00:43:22,000 --> 00:43:30,000
實際的二進制文件，這2個庫，的CS50庫，然後數學庫。

634
00:43:30,000 --> 00:43:35,000
>> 了解每種類型的文件的目的

635
00:43:35,000 --> 00:43:38,000
在編譯過程中，你要的東西能夠

636
00:43:38,000 --> 00:43:43,000
至少給一個高層次的概述。

637
00:43:43,000 --> 00:43:46,000
源代碼的原因。目標代碼出來。

638
00:43:46,000 --> 00:43:53,000
目標代碼文件鏈接在一起，你會得到一個美麗的，可執行文件。

639
00:43:53,000 --> 00:43:55,000
酷。

640
00:43:55,000 --> 00:43:58,000
這也是在那裡你可以得到的錯誤在多點

641
00:43:58,000 --> 00:44:00,000
在編譯過程中。

642
00:44:00,000 --> 00:44:04,000
這是在哪裡，例如，如果你把這個連接的標誌，

643
00:44:04,000 --> 00:44:10,000
CS50標誌，你忽略它在空間，或當你運行你的代碼，

644
00:44:10,000 --> 00:44:13,000
這是在那裡你會得到一個錯誤的鏈接階段，

645
00:44:13,000 --> 00:44:18,000
和鏈接器會說：“嘿，你調用一個函數的GetString

646
00:44:18,000 --> 00:44:20,000
這是在的CS50庫。“

647
00:44:20,000 --> 00:44:25,000
“你告訴我是在CS50庫，我無法找到它的代碼。”

648
00:44:25,000 --> 00:44:28,000
這就是你有鏈接，這就是獨立的

649
00:44:28,000 --> 00:44:33,000
從一個編譯錯誤，因為編譯器的語法和諸如此類的東西。

650
00:44:33,000 --> 00:44:38,000
知道發生了什麼事情的時候，這是很好的。

651
00:44:38,000 --> 00:44:42,000
>> 其他的事情了解。

652
00:44:42,000 --> 00:44:49,000
我會說，你一定要來看看短的類型轉換通過約旦

653
00:44:49,000 --> 00:44:55,000
了解整數是什麼引擎蓋下，

654
00:44:55,000 --> 00:44:58,000
引擎蓋下的是什麼字符。

655
00:44:58,000 --> 00:45:02,000
當我們談論的ASCII和我們其實看的ASCII表，

656
00:45:02,000 --> 00:45:07,000
什麼做的是給了我們一個引擎蓋下的樣子

657
00:45:07,000 --> 00:45:13,000
如何在計算機實際上代表了資本和數字7

658
00:45:13,000 --> 00:45:17,000
一個逗號和問號。

659
00:45:17,000 --> 00:45:20,000
電腦還具有特殊的方式來表示

660
00:45:20,000 --> 00:45:23,000
為一個整數的數目7。

661
00:45:23,000 --> 00:45:27,000
它有一個特殊的方式來表示一個浮點數7號，

662
00:45:27,000 --> 00:45:29,000
有很大的不同。

663
00:45:29,000 --> 00:45:32,000
類型轉換是如何告訴計算機“嘿，我想你轉換

664
00:45:32,000 --> 00:45:37,000
從一個表示的另一種表示。“

665
00:45:37,000 --> 00:45:40,000
我們為什麼不來看看在那。

666
00:45:40,000 --> 00:45:44,000
>> 我也來看看在短庫和短期的編譯器上。

667
00:45:44,000 --> 00:45:47,000
那些談論編譯的過程中，

668
00:45:47,000 --> 00:45:53,000
圖書館是什麼，並去了其中的一些問題，你可能會問。

669
00:45:53,000 --> 00:45:55,000
上一周1材料？

670
00:45:55,000 --> 00:46:03,000
在這裡，令人望而生畏你想覆蓋的任何話題？

671
00:46:03,000 --> 00:46:07,000
我企圖炸毀通過這些早期的主題，因此，我們可以得到

672
00:46:07,000 --> 00:46:13,000
指針和做一點點的遞歸。

673
00:46:13,000 --> 00:46:15,000
思考？

674
00:46:15,000 --> 00:46:19,000
凡是有哪些？

675
00:46:19,000 --> 00:46:21,000
一些巧克力可能的時間？

676
00:46:21,000 --> 00:46:23,000
你們正在通過它。

677
00:46:23,000 --> 00:46:26,000
我要在我的咖啡喝著。

678
00:46:26,000 --> 00:46:31,000
第2週。

679
00:46:31,000 --> 00:46:34,000
良好的通話，良好的通話。

680
00:46:34,000 --> 00:46:38,000
在第2週，我們談了一點點更多的功能。

681
00:46:38,000 --> 00:46:43,000
>> 在最初的幾個問題集，我們並沒有真正寫在所有的任何功能

682
00:46:43,000 --> 00:46:45,000
以外的功能嗎？

683
00:46:45,000 --> 00:46:47,000
[學生]主。>>主，準確。

684
00:46:47,000 --> 00:46:51,000
所以，我們看到了不同的服飾，主要穿。

685
00:46:51,000 --> 00:46:54,000
它不帶任何參數，

686
00:46:54,000 --> 00:46:58,000
我們只說在括號之間的空白，

687
00:46:58,000 --> 00:47:01,000
然後有另外一個我們要採取命令行參數，

688
00:47:01,000 --> 00:47:08,000
正如我們所看到的，這就是你有int argc和字符串argv數組

689
00:47:08,000 --> 00:47:13,000
現在我們實際上已經暴露字符串的char *，它是

690
00:47:13,000 --> 00:47:20,000
我們要開始寫為char * argv和括號。

691
00:47:20,000 --> 00:47:22,000
習題集3，你們看到了一堆的功能，

692
00:47:22,000 --> 00:47:27,000
實施了一堆的功能，畫畫，看後，爭奪戰。

693
00:47:27,000 --> 00:47:31,000
的原型都寫在你身邊。

694
00:47:31,000 --> 00:47:33,000
>> 我想在這裡談論與功能真的很快

695
00:47:33,000 --> 00:47:38,000
有3個部分，只要你寫一個函數。

696
00:47:38,000 --> 00:47:43,000
你必須指定返回類型的函數。

697
00:47:43,000 --> 00:47:46,000
你必須指定一個函數名稱，然後你必須指定

698
00:47:46,000 --> 00:47:51,000
參數列表參數列表。

699
00:47:51,000 --> 00:47:57,000
例如，如果我寫一個函數來匯總了一堆的整數

700
00:47:57,000 --> 00:48:03,000
然後回到我這裡來的總和，這將是我的返回類型

701
00:48:03,000 --> 00:48:06,000
如果我想總結的整數，然後返回的總和嗎？

702
00:48:06,000 --> 00:48:12,000
然後的函數名。

703
00:48:12,000 --> 00:48:27,000
如果我繼續寫在綠色，這部分是返回類型。

704
00:48:27,000 --> 00:48:34,000
這部分的名稱。

705
00:48:34,000 --> 00:48:40,000
然後在括號之間的

706
00:48:40,000 --> 00:48:46,000
是我給的參數，

707
00:48:46,000 --> 00:48:56,000
通常縮寫為args，有時也被稱為參數的參數的。

708
00:48:56,000 --> 00:49:00,000
如果你有一個，您只需指定一個。

709
00:49:00,000 --> 00:49:06,000
如果您有多個，用逗號分開，每一個。

710
00:49:06,000 --> 00:49:13,000
為每一個參數，你給它兩件事情是凱文？

711
00:49:13,000 --> 00:49:18,000
[凱文]你有給類型及名稱。

712
00:49:18,000 --> 00:49:21,000
然後的名稱的名稱是您要使用的名稱

713
00:49:21,000 --> 00:49:25,000
的金額範圍內功能是指這樣的說法，

714
00:49:25,000 --> 00:49:27,000
在函數內，您目前正在編寫的。

715
00:49:27,000 --> 00:49:32,000
>> 您不必例如，如果我要總結，

716
00:49:32,000 --> 00:49:41,000
也就是說，一個數組的整數 - 我們將做的int數組，

717
00:49:41,000 --> 00:49:46,000
我給自己一些花括號

718
00:49:46,000 --> 00:49:51,000
然後，當我傳遞一個數組的總和功能

719
00:49:51,000 --> 00:49:55,000
我把它的參數列表中的第一個位置。

720
00:49:55,000 --> 00:49:59,000
但傳遞的數組，我不必有名字改編。

721
00:49:59,000 --> 00:50:07,000
到達將是我指的是身體內的功能，參數。

722
00:50:07,000 --> 00:50:10,000
其他的事情，我們需要考慮到，

723
00:50:10,000 --> 00:50:14,000
，這是從功能略有不同，但我認為這是一個很重要的一點，

724
00:50:14,000 --> 00:50:20,000
是，在C，當我在寫一個這樣的函數

725
00:50:20,000 --> 00:50:29,000
我怎麼知道這個數組有多少元素？

726
00:50:29,000 --> 00:50:31,000
這是有點一個棘手的問題。

727
00:50:31,000 --> 00:50:35,000
我們談到這一點在上週的部分。

728
00:50:35,000 --> 00:50:40,000
我怎麼知道在C數組裡面的元​​素的數量？

729
00:50:40,000 --> 00:50:44,000
有沒有辦法呢？

730
00:50:44,000 --> 00:50:49,000
>> 事實證明，有沒有辦法知道。

731
00:50:49,000 --> 00:50:52,000
你必須通過它分別。

732
00:50:52,000 --> 00:50:55,000
有一個技巧，你可以做

733
00:50:55,000 --> 00:51:00,000
如果你在相同的陣列功能，其中已申報，

734
00:51:00,000 --> 00:51:04,000
你正在使用的堆棧陣列。

735
00:51:04,000 --> 00:51:06,000
但是，這只是工作，如果你在相同的功能。

736
00:51:06,000 --> 00:51:09,000
一旦你將數組傳遞給另一個函數，或者，如果你已經聲明數組

737
00:51:09,000 --> 00:51:12,000
你把該數組在堆上，你使用的malloc

738
00:51:12,000 --> 00:51:15,000
 和這樣的東西，那麼所有的賭注都關閉。

739
00:51:15,000 --> 00:51:18,000
然後，你必須通過左右

740
00:51:18,000 --> 00:51:21,000
一個特殊的參數或其他參數

741
00:51:21,000 --> 00:51:23,000
告訴你有多大的數組。

742
00:51:23,000 --> 00:51:28,000
在這種情況下，對不起，這是怎麼回事了屏幕在這裡，我想使用一個逗號，我

743
00:51:28,000 --> 00:51:32,000
我會通過另一種說法

744
00:51:32,000 --> 00:51:40,000
 ，詮釋萊恩的長度。

745
00:51:40,000 --> 00:51:44,000
>> 有一件事可能遇到的測驗

746
00:51:44,000 --> 00:51:49,000
要求你寫或執行特定的功能叫什麼。

747
00:51:49,000 --> 00:51:54,000
如果我們不給你的原型，所以這整個事情在這裡，

748
00:51:54,000 --> 00:51:58,000
這全亂了調用該函數的聲明或函數原型，

749
00:51:58,000 --> 00:52:01,000
這是一個的第一件事情，你會想要確定下來，如果它不給

750
00:52:01,000 --> 00:52:03,000
你馬上測驗。

751
00:52:03,000 --> 00:52:06,000
我已經學會的技巧是：

752
00:52:06,000 --> 00:52:11,000
說，我們給你一個函數的原型，和我們說，“嘿，你得把它寫。”

753
00:52:11,000 --> 00:52:16,000
在大括號中，你必須在測驗

754
00:52:16,000 --> 00:52:20,000
如果您發現有一個返回類型，你注意到的返回類型

755
00:52:20,000 --> 00:52:25,000
是無效，這意味著該函數不返回任何東西以外的東西，

756
00:52:25,000 --> 00:52:28,000
然後一件事，你一定要做到的是寫

757
00:52:28,000 --> 00:52:33,000
某種類型的return語句在最後的功能。

758
00:52:33,000 --> 00:52:40,000
返回，在這種情況下，我們會把一個空白，因為我們要填補的空白。

759
00:52:40,000 --> 00:52:44,000
但是，這可以讓你想以正確的方式，我要如何解決這個問題呢？

760
00:52:44,000 --> 00:52:49,000
它提醒你，你要返回一個值

761
00:52:49,000 --> 00:52:51,000
該函數的調用者。

762
00:52:51,000 --> 00:52:54,000
>> 是啊。>> [學生]：風格當我們編寫代碼的測驗？

763
00:52:54,000 --> 00:52:58,000
如縮進和這樣的東西嗎？>> [學生]：是的。

764
00:52:58,000 --> 00:53:00,000
不，沒有那麼多。

765
00:53:00,000 --> 00:53:09,000
我想了很多，這是我們的日子會澄清的測驗，

766
00:53:09,000 --> 00:53:15,000
但通常擔心的＃include，這樣的東西，它是一種外。

767
00:53:15,000 --> 00:53:17,000
[學生]：你需要回應你的手寫代碼？

768
00:53:17,000 --> 00:53:19,000
你需要回應你的手寫代碼嗎？

769
00:53:19,000 --> 00:53:24,000
談到始終是一件好事，如果你擔心部分信貸

770
00:53:24,000 --> 00:53:29,000
或者你想傳達你的意圖，平地機。

771
00:53:29,000 --> 00:53:33,000
但是，我再次將澄清的測驗和測驗的一天，

772
00:53:33,000 --> 00:53:39,000
但我不相信你會被要求寫評論，沒有。

773
00:53:39,000 --> 00:53:42,000
通常不會，但它絕對是諸如此類的事情，

774
00:53:42,000 --> 00:53:45,000
你可以傳達你的意圖，想：“嘿，這是我要去的地方用它。”

775
00:53:45,000 --> 00:53:49,000
有時，可以幫助部分信貸。

776
00:53:49,000 --> 00:53:51,000
酷。

777
00:53:51,000 --> 00:53:53,000
>> 羅勒。

778
00:53:53,000 --> 00:53:56,000
[羅勒]聲明說，INT郎之間的區別是什麼

779
00:53:56,000 --> 00:54:03,000
在與聲明一個變量，在函數中的參數或參數？

780
00:54:03,000 --> 00:54:05,000
哇，咖啡去了氣管。

781
00:54:05,000 --> 00:54:07,000
[羅勒]喜歡的事情，我們希望把在參數。

782
00:54:07,000 --> 00:54:09,000
是啊，這是一個很大的問題。

783
00:54:09,000 --> 00:54:11,000
你會選擇什麼樣的事情，你要投入的參數

784
00:54:11,000 --> 00:54:17,000
對你應該做的事裡面的功能是什麼？

785
00:54:17,000 --> 00:54:24,000
在這種情況下，我們這兩個參數

786
00:54:24,000 --> 00:54:29,000
因為他們的東西，不管是誰去使用SUM函數

787
00:54:29,000 --> 00:54:32,000
需要指定這些事情。

788
00:54:32,000 --> 00:54:35,000
>> 和功能，像我們談到了，有沒有辦法知道

789
00:54:35,000 --> 00:54:40,000
有多大的數組是得到它的調用者或任何人使用SUM函數。

790
00:54:40,000 --> 00:54:44,000
它沒有辦法知道這個數組有多大。

791
00:54:44,000 --> 00:54:48,000
我們之所以在這裡通過這個長度作為參數

792
00:54:48,000 --> 00:54:51,000
是因為在這個時候，我們基本上是告訴來電者的功能，

793
00:54:51,000 --> 00:54:55,000
誰是將要使用SUM函數，“嘿，不僅你得給我們一個數組

794
00:54:55,000 --> 00:54:59,000
整數，你也必須告訴我們有多大的數組，你已經給了我們。“

795
00:54:59,000 --> 00:55:03,000
[羅勒這些都將是命令行參數？

796
00:55:03,000 --> 00:55:06,000
沒有，這些都是實實在在的，你會傳遞給函數的參數。

797
00:55:06,000 --> 00:55:10,000
>> 讓我在這裡做了新的一頁。

798
00:55:10,000 --> 00:55:13,000
[羅勒]喜歡的名字將傳遞

799
00:55:13,000 --> 00:55:24,000
[內特H.]如果我有詮釋的主要（無效），

800
00:55:24,000 --> 00:55:27,000
我要把我返回0，在這裡的底部，

801
00:55:27,000 --> 00:55:31,000
並說我要打電話功能的總和。

802
00:55:31,000 --> 00:55:42,000
我想說的詮釋x = SUM（）;

803
00:55:42,000 --> 00:55:46,000
使用SUM函數，我想總結的，我必須要通過在陣列

804
00:55:46,000 --> 00:55:51,000
和陣列的長度，所以這是

805
00:55:51,000 --> 00:55:54,000
假設我有一個整型數組，

806
00:55:54,000 --> 00:56:12,000
說我有numbaz [] = 1，2，3，

807
00:56:12,000 --> 00:56:16,000
種使用砍死語法正確，

808
00:56:16,000 --> 00:56:21,000
然後我會做什麼，總之，我希望通過

809
00:56:21,000 --> 00:56:27,000
兩個numbaz和3號

810
00:56:27,000 --> 00:56:30,000
告訴SUM函數“好了，在這裡我要你總結的陣列。”

811
00:56:30,000 --> 00:56:34,000
“這是它的大小。”

812
00:56:34,000 --> 00:56:39,000
這是否有意義嗎？回答你的問題嗎？

813
00:56:39,000 --> 00:56:42,000
>> 在許多方面，它平行的就是我們正在做的主要

814
00:56:42,000 --> 00:56:44,000
當我們有命令行參數。

815
00:56:44,000 --> 00:56:47,000
像愷撒密碼的程序，例如，需要

816
00:56:47,000 --> 00:56:53,000
命令行參數將無法做任何事情。

817
00:56:53,000 --> 00:56:57,000
不知道如何進行加密，如果你沒有告訴它使用什麼鍵

818
00:56:57,000 --> 00:57:03,000
或者，如果你沒有告訴它你想加密的字符串。

819
00:57:03,000 --> 00:57:08,000
提示輸入，這是我們已經有2個不同的機制

820
00:57:08,000 --> 00:57:14,000
用於輸入來自用戶的，在來自用戶的信息採取。

821
00:57:14,000 --> 00:57:19,000
對於問題1，我們看到這個調用getInt，GetString的，GetFloat的方式

822
00:57:19,000 --> 00:57:26,000
提示輸入，這就是所謂的使用標準輸入流。

823
00:57:26,000 --> 00:57:28,000
這是稍有不同。

824
00:57:28,000 --> 00:57:31,000
這件事情，你可以做一次，而不是

825
00:57:31,000 --> 00:57:35,000
當你調用程序，當您啟動程序的運行。

826
00:57:35,000 --> 00:57:41,000
所有的命令行參數指定當您啟動程序運行。

827
00:57:41,000 --> 00:57:47,000
我們已經將兩個。

828
00:57:47,000 --> 00:57:52,000
當我們使用參數的函數，這是非常類似的命令行參數主要。

829
00:57:52,000 --> 00:57:56,000
這是當你調用這個函數，你需要告訴它

830
00:57:56,000 --> 00:58:05,000
它究竟是什麼的需要，以執行其任務。

831
00:58:05,000 --> 00:58:08,000
另一個好處看，我就讓你看看它在你的空餘時間，

832
00:58:08,000 --> 00:58:11,000
它覆蓋在測驗是這個概念的範圍

833
00:58:11,000 --> 00:58:15,000
與全局變量和局部變量。

834
00:58:15,000 --> 00:58:18,000
千萬要注意。

835
00:58:18,000 --> 00:58:23,000
>> 現在，我們要對這個其他的東西，

836
00:58:23,000 --> 00:58:27,000
第3週，我們開始談到的搜索和排序。

837
00:58:27,000 --> 00:58:32,000
檢索和排序，CS50，至少在

838
00:58:32,000 --> 00:58:39,000
非常多介紹一些計算機科學的理論部分。

839
00:58:39,000 --> 00:58:42,000
的問題的搜索，排序的問題

840
00:58:42,000 --> 00:58:46,000
是大的，規範的問題。

841
00:58:46,000 --> 00:58:52,000
你怎麼找到的數十億美元的整數數組中的一個特定的數字嗎？

842
00:58:52,000 --> 00:58:55,000
你如何找到一個特別的名字裡面的電話簿

843
00:58:55,000 --> 00:58:59,000
是存儲在您的筆記本電腦嗎？

844
00:58:59,000 --> 00:59:04,000
因此，我們提出這個概念的漸近運行時間

845
00:59:04,000 --> 00:59:11,000
要真正量化多久，這些問題是如何努力，

846
00:59:11,000 --> 00:59:14,000
他們需要多長時間來解決。

847
00:59:14,000 --> 00:59:20,000
我相信，在2011年的測驗有一個問題，我認為這是值得的

848
00:59:20,000 --> 00:59:27,000
覆蓋速度非常快，這是一個問題12。

849
00:59:27,000 --> 00:59:32,000
哦，不，這是歐米茄。

850
00:59:32,000 --> 00:59:41,000
>> 在這裡，我們談論以最快的速度運行時

851
00:59:41,000 --> 00:59:46,000
對於一個特定的算法，然後最慢的可能的運行時間。

852
00:59:46,000 --> 00:59:52,000
歐米茄（Omega）和O這是真的只是快捷方式。

853
00:59:52,000 --> 00:59:55,000
他們的符號的快捷鍵說

854
00:59:55,000 --> 00:59:59,000
如何快速在最好的情況下，我們的算法來看，

855
00:59:59,000 --> 01:00:06,000
如何在最壞的情況下緩慢將我們的算法運行？

856
01:00:06,000 --> 01:00:10,000
讓我們做一對夫婦這些，而這些，也包括了

857
01:00:10,000 --> 01:00:13,000
在短期漸近符號，這是我極力推薦的。

858
01:00:13,000 --> 01:00:17,000
傑克遜做了很好的工作。

859
01:00:17,000 --> 01:00:23,000
二進制搜索，我們談論二進制搜索算法，

860
01:00:23,000 --> 01:00:28,000
我們通常談論它，其大澳

861
01:00:28,000 --> 01:00:30,000
大O是什麼？

862
01:00:30,000 --> 01:00:34,000
什麼是運行時的二進制搜索速度最慢的可能嗎？

863
01:00:34,000 --> 01:00:36,000
[學生] N²？

864
01:00:36,000 --> 01:00:41,000
關閉，我想類似的。

865
01:00:41,000 --> 01:00:43,000
這是快了很多。

866
01:00:43,000 --> 01:00:45,000
[學生]：二進制嗎？是的，二進制搜索。

867
01:00:45,000 --> 01:00:47,000
[學生]：這是日誌n。

868
01:00:47,000 --> 01:00:49,000
登錄n，所以日誌N意味著什麼？

869
01:00:49,000 --> 01:00:51,000
它一半在每次迭代。

870
01:00:51,000 --> 01:00:56,000
沒錯，所以在最慢的情況下，

871
01:00:56,000 --> 01:01:00,000
說，如果你有一個排序的數組

872
01:01:00,000 --> 01:01:08,000
你正在尋找一百萬整數，

873
01:01:08,000 --> 01:01:14,000
是第一個元素的數組或數組中的最後一個元素。

874
01:01:14,000 --> 01:01:18,000
請記住，二進制搜索算法的工作原理是在中間的元素，

875
01:01:18,000 --> 01:01:21,000
如果是這樣的比賽，你要尋找的。

876
01:01:21,000 --> 01:01:23,000
如果是，那麼偉大，你發現了它。

877
01:01:23,000 --> 01:01:27,000
>> 在最好的情況下，二進制搜索運行的速度有多快？

878
01:01:27,000 --> 01:01:29,000
[學生] 1。

879
01:01:29,000 --> 01:01:32,000
1，這是恆定的時間，大O 1。是啊。

880
01:01:32,000 --> 01:01:36,000
[學生]：我有一個問題。當你說的n登錄，您的意思是與基地2，對不對？

881
01:01:36,000 --> 01:01:40,000
是的，所以其他的事情。

882
01:01:40,000 --> 01:01:44,000
我們說為log N，我想，當我在高中

883
01:01:44,000 --> 01:01:48,000
我一直認為日誌基數為10。

884
01:01:48,000 --> 01:01:57,000
是啊，這樣的話，2為底通常我們使用的是什麼。

885
01:01:57,000 --> 01:02:02,000
再次，要回二進制搜索，如果你正在尋找無論是

886
01:02:02,000 --> 01:02:05,000
在最後元素或元素在開始的時候，

887
01:02:05,000 --> 01:02:08,000
因為你開始在中間，然後丟棄

888
01:02:08,000 --> 01:02:13,000
取其一半不符合標準，你要尋找的，

889
01:02:13,000 --> 01:02:15,000
你去下一半，下一半，下半。

890
01:02:15,000 --> 01:02:19,000
如果我在尋找萬整數數組中的最大元素

891
01:02:19,000 --> 01:02:25,000
在100萬次的日誌，我要減半

892
01:02:25,000 --> 01:02:28,000
之前，我終於測試，看看，我要找的元素

893
01:02:28,000 --> 01:02:33,000
是在最大或指數最高的陣列中，

894
01:02:33,000 --> 01:02:38,000
將日誌的n，記錄的100萬次。

895
01:02:38,000 --> 01:02:40,000
>> 冒泡排序。

896
01:02:40,000 --> 01:02:43,000
你們是否還記得冒泡排序算法？

897
01:02:43,000 --> 01:02:47,000
凱文，你能不能給我一個快速回顧中，冒泡排序算法發生了什麼事嗎？

898
01:02:47,000 --> 01:02:50,000
[凱文]，基本上它通過在列表中的一切。

899
01:02:50,000 --> 01:02:52,000
它著眼於前兩個。

900
01:02:52,000 --> 01:02:55,000
如果第一個比第二個它掉期將是更大的。

901
01:02:55,000 --> 01:02:58,000
然後比較第二和第三，同樣的事情，掉期，

902
01:02:58,000 --> 01:03:00,000
第三和第四，一路下跌。

903
01:03:00,000 --> 01:03:03,000
更大的數字會跟進的。

904
01:03:03,000 --> 01:03:07,000
然而，許多循環後，你就大功告成了。

905
01:03:07,000 --> 01:03:11,000
沒錯，凱文說的是，我們會看更大的數字

906
01:03:11,000 --> 01:03:15,000
泡沫結束的數組。

907
01:03:15,000 --> 01:03:19,000
例如，你不介意走我們通過這個例子，如果這是我們的數組？

908
01:03:19,000 --> 01:03:21,000
[凱文]你會需要2個和3個。

909
01:03:21,000 --> 01:03:23,000
3大於2，所以你換。

910
01:03:23,000 --> 01:03:29,000
內特H.]右，所以我們交換這些，和這樣我們就得到2，3，6，4，和9。

911
01:03:29,000 --> 01:03:31,000
[凱文]那麼你就比較3和6。

912
01:03:31,000 --> 01:03:33,000
3小於6，所以你離開他們，

913
01:03:33,000 --> 01:03:37,000
6和4，你會交換他們，因為4小於6。

914
01:03:37,000 --> 01:03:42,000
[內特H.]對，所以我得到2，3，4，6，9。

915
01:03:42,000 --> 01:03:46,000
[凱文]和9大於6，所以你離開它。

916
01:03:46,000 --> 01:03:48,000
你通過它回去了。

917
01:03:48,000 --> 01:03:50,000
>> [內特H.]在這一點上我做了嗎？凱文號

918
01:03:50,000 --> 01:03:52,000
我為什麼要在這一點上沒有這樣做呢？

919
01:03:52,000 --> 01:03:54,000
因為它看起來像我的數組進行排序。我看著它。

920
01:03:54,000 --> 01:03:57,000
[凱文]再經歷一遍，確保沒有更多的掉期

921
01:03:57,000 --> 01:04:00,000
才可以完全停止。

922
01:04:00,000 --> 01:04:04,000
沒錯，所以你仍然需要繼續通過並確保不存在交換

923
01:04:04,000 --> 01:04:06,000
在這一點上，你可以使。

924
01:04:06,000 --> 01:04:08,000
這真的只是幸運，就像你說的，我們結束了

925
01:04:08,000 --> 01:04:12,000
只有1通過我們排序。

926
01:04:12,000 --> 01:04:16,000
但要做到這在一般情況下，我們實際上要做到這一點，一遍又一遍。

927
01:04:16,000 --> 01:04:20,000
而事實上，這是一個可能的情況下最好的例子，

928
01:04:20,000 --> 01:04:24,000
像我們所看到的問題。

929
01:04:24,000 --> 01:04:28,000
我們看到，最好的可能的情況下為N。

930
01:04:28,000 --> 01:04:32,000
我們經歷了陣列1次。

931
01:04:32,000 --> 01:04:35,000
最壞的情況下，該算法是什麼？

932
01:04:35,000 --> 01:04:37,000
[凱文] N“。

933
01:04:37,000 --> 01:04:41,000
而且，看起來像什麼？數組的樣子，取n²時間嗎？

934
01:04:41,000 --> 01:04:43,000
[凱文] [聽不清]排序。

935
01:04:43,000 --> 01:04:51,000
沒錯，所以如果我有數組9，7，6，5，2，

936
01:04:51,000 --> 01:04:54,000
第9泡沫一路。

937
01:04:54,000 --> 01:04:59,000
1次迭代後，我們就會有7，6，5，2，9。

938
01:04:59,000 --> 01:05:07,000
7將泡漲，6，5，2，7，9，等等等等。

939
01:05:07,000 --> 01:05:13,000
>> 我們不得不去整個數組n次，

940
01:05:13,000 --> 01:05:16,000
實際上，你可以得到比這更精確的

941
01:05:16,000 --> 01:05:23,000
因為一旦我們已經提出9一路到最後可能的位置

942
01:05:23,000 --> 01:05:26,000
我們知道，我們永遠都不會擁有再次反對該元素比較。

943
01:05:26,000 --> 01:05:29,000
一旦我們開始冒泡7

944
01:05:29,000 --> 01:05:35,000
我們知道，我們可以停止後，7是正​​確的前9

945
01:05:35,000 --> 01:05:37,000
因為我們已經比較9。

946
01:05:37,000 --> 01:05:46,000
如果你這樣做一個聰明的方式，它並不是真正的，我想，那麼多的時間。

947
01:05:46,000 --> 01:05:49,000
你不是要比較所有可能的[聽不清]組合

948
01:05:49,000 --> 01:05:55,000
每一次你通過每一次迭代。

949
01:05:55,000 --> 01:05:59,000
但儘管如此，當我們談論這個上限，我們說，

950
01:05:59,000 --> 01:06:04,000
您正在尋找在n²通過比較所有方式。

951
01:06:04,000 --> 01:06:12,000
>> 讓我們回去了，因為我們已經開始得到一點點的時間短

952
01:06:12,000 --> 01:06:15,000
我會說，你一定要通過此表，其餘的，

953
01:06:15,000 --> 01:06:17,000
填補了這一切。

954
01:06:17,000 --> 01:06:20,000
想想例子。想想具體的例子。

955
01:06:20,000 --> 01:06:22,000
這是非常方便的和做的。

956
01:06:22,000 --> 01:06:25,000
畫出來。

957
01:06:25,000 --> 01:06:28,000
這是排序的表，當你通過在計算機科學

958
01:06:28,000 --> 01:06:32,000
你應該開始知道這些由心。

959
01:06:32,000 --> 01:06:34,000
這是你在接受採訪時的各種問題。

960
01:06:34,000 --> 01:06:36,000
這些都是各種各樣的東西，是很好的了解，

961
01:06:36,000 --> 01:06:41,000
想想那些邊緣的情況下，真正搞清楚如何思考

962
01:06:41,000 --> 01:06:45,000
知道冒泡排序可能出現的最壞的陣列的

963
01:06:45,000 --> 01:06:52,000
進行排序的，是一個以相反的順序。

964
01:06:52,000 --> 01:06:58,000
>> 指針。讓我們來談談關於指針一點點。

965
01:06:58,000 --> 01:07:03,000
在過去的幾年時間裡，我們這裡有

966
01:07:03,000 --> 01:07:11,000
我知道這是與文件I / O，是相當新的東西。

967
01:07:11,000 --> 01:07:19,000
當我們談論指針的原因，我們要談論的指針

968
01:07:19,000 --> 01:07:24,000
是因為，當我們工作在C

969
01:07:24,000 --> 01:07:33,000
我們真的是在一個相當低的水平相比，大多數現代編程語言。

970
01:07:33,000 --> 01:07:38,000
我們實際上能夠操縱內存中的變量，

971
01:07:38,000 --> 01:07:43,000
他們實際上是在我們的RAM。

972
01:07:43,000 --> 01:07:46,000
一旦你到了操作系統類，你會看到

973
01:07:46,000 --> 01:07:48,000
，，，種一個抽象的概念。

974
01:07:48,000 --> 01:07:50,000
這是事實並非如此。

975
01:07:50,000 --> 01:07:52,000
我們的隱藏這些細節，我們已經得到了虛擬內存。

976
01:07:52,000 --> 01:07:58,000
>> 但現在，你可以假設你有一個程序時，

977
01:07:58,000 --> 01:08:02,000
例如，當您開始您的愷撒密碼程序

978
01:08:02,000 --> 01:08:06,000
我會切換回我的iPad真的很快

979
01:08:06,000 --> 01:08:12,000
在一開始你的程序，如果你有，說，

980
01:08:12,000 --> 01:08:15,000
4 GB的RAM您的筆記本電腦，

981
01:08:15,000 --> 01:08:21,000
你得到拋開這一塊，我們把它稱為RAM。

982
01:08:21,000 --> 01:08:25,000
在一個地方，我們要調用0開始，

983
01:08:25,000 --> 01:08:30,000
它結束的地方，我們會打電話給4千兆字節。

984
01:08:30,000 --> 01:08:37,000
我真的可以不寫。人，被黑客攻擊。

985
01:08:37,000 --> 01:08:40,000
當你的程序執行

986
01:08:40,000 --> 01:08:44,000
操作系統瓜分RAM，

987
01:08:44,000 --> 01:08:51,000
它規定了不同的細分為不同的部分，你的程序的居住環境。

988
01:08:51,000 --> 01:08:58,000
到這裡，這方面是怎麼樣的無人區。

989
01:08:58,000 --> 01:09:02,000
當你去了稍遠一點這裡

990
01:09:02,000 --> 01:09:05,000
你已經得到了實際的地方

991
01:09:05,000 --> 01:09:09,000
你的程序的代碼生活。

992
01:09:09,000 --> 01:09:13,000
實際的二進制代碼，可執行文件實際上被加載到內​​存中

993
01:09:13,000 --> 01:09:17,000
當你運行一個程序，它住在代碼段。

994
01:09:17,000 --> 01:09:22,000
你的程序執行的處理器看起來在這個代碼段

995
01:09:22,000 --> 01:09:24,000
要弄清楚什麼是下一個指令？

996
01:09:24,000 --> 01:09:27,000
我需要執行的下一行代碼是什麼？

997
01:09:27,000 --> 01:09:31,000
>> 還有一個數據段，這是這些字符串常量

998
01:09:31,000 --> 01:09:34,000
獲取存儲，你一直在使用。

999
01:09:34,000 --> 01:09:42,000
再遠些了這個地方稱為堆。

1000
01:09:42,000 --> 01:09:46,000
我們在那裡存取記憶體使用malloc，

1001
01:09:46,000 --> 01:09:49,000
然後向你的程序的最頂端

1002
01:09:49,000 --> 01:09:52,000
有堆棧，

1003
01:09:52,000 --> 01:09:57,000
而這也正是我們一直在玩的最開始。

1004
01:09:57,000 --> 01:09:59,000
這是沒有規模或任何東西。

1005
01:09:59,000 --> 01:10:03,000
這是很多非常依賴於機器，

1006
01:10:03,000 --> 01:10:10,000
依賴於操作系統，但是這是比較如何得到分塊。

1007
01:10:10,000 --> 01:10:17,000
當你運行一個程序，你聲明一個變量名為x-

1008
01:10:17,000 --> 01:10:27,000
我要畫一個框下方，這將是RAM以及。

1009
01:10:27,000 --> 01:10:29,000
我去看看。

1010
01:10:29,000 --> 01:10:34,000
我們將繪製鋸齒線來表示，這僅僅是一小部分的RAM

1011
01:10:34,000 --> 01:10:38,000
不是所有的為我們繪製在上面。

1012
01:10:38,000 --> 01:10:43,000
>> 如果我聲明了一個整數變量x，

1013
01:10:43,000 --> 01:10:49,000
其實我得到的是一個映射

1014
01:10:49,000 --> 01:10:54,000
我的程序被存儲在符號表中的

1015
01:10:54,000 --> 01:11:00,000
連接這個區域的記憶，我畫的名字x

1016
01:11:00,000 --> 01:11:03,000
在這裡之間的豎線。

1017
01:11:03,000 --> 01:11:08,000
如果我有一個在我的計劃，說X = 7的代碼行

1018
01:11:08,000 --> 01:11:15,000
處理器知道“哦，好吧，我知道在這個位置在內存中的x生活。”

1019
01:11:15,000 --> 01:11:25,000
“我要繼續前進，並寫了7。”

1020
01:11:25,000 --> 01:11:28,000
它是如何知道什麼位置，這是在內存中嗎？

1021
01:11:28,000 --> 01:11:30,000
那麼，這一切都在編譯時完成。

1022
01:11:30,000 --> 01:11:34,000
編譯器負責分配中的每一個變量都去

1023
01:11:34,000 --> 01:11:40,000
創建一個特殊的映射，或者更確切地說，點與點之間

1024
01:11:40,000 --> 01:11:43,000
一個符號，到哪裡去，一個變量的名稱

1025
01:11:43,000 --> 01:11:46,000
到哪裡去住在內存中。

1026
01:11:46,000 --> 01:11:50,000
但事實證明，我們實際上可以訪問它在我們的程序中。

1027
01:11:50,000 --> 01:11:55,000
這得到重要的，當我們開始談論一些數據結構，

1028
01:11:55,000 --> 01:11:58,000
這是一個概念，我們將在後​​面介紹。

1029
01:11:58,000 --> 01:12:09,000
>> 但是現在，你可以知道的是，我可以創造一個指針，指向這個位置，X。

1030
01:12:09,000 --> 01:12:12,000
例如，我可以創建一個指針變量。

1031
01:12:12,000 --> 01:12:16,000
當我們創建一個指針變量，我們使用星符號。

1032
01:12:16,000 --> 01:12:21,000
在這種情況下，說，我要創建一個指向整數的指針。

1033
01:12:21,000 --> 01:12:24,000
這是一個類型，就像任何其他。

1034
01:12:24,000 --> 01:12:27,000
我們給它一個變量，如Y，

1035
01:12:27,000 --> 01:12:32,000
然後，我們將它的地址，地址。

1036
01:12:32,000 --> 01:12:38,000
在這種情況下，我們可以設置y以指向到x

1037
01:12:38,000 --> 01:12:43,000
通過x的地址，這是我們做這個符號，

1038
01:12:43,000 --> 01:12:55,000
然後我們設置y來指向它。

1039
01:12:55,000 --> 01:12:59,000
這基本上是不是，如果我們看一下我們的RAM

1040
01:12:59,000 --> 01:13:02,000
這將創建一個獨立的變量。

1041
01:13:02,000 --> 01:13:04,000
這將調用它的Ÿ，

1042
01:13:04,000 --> 01:13:06,000
而當這行代碼執行

1043
01:13:06,000 --> 01:13:13,000
它實際上是要創建一個小的指針，我們通常畫一個箭頭，

1044
01:13:13,000 --> 01:13:15,000
點為x和y置。

1045
01:13:15,000 --> 01:13:17,000
是。

1046
01:13:17,000 --> 01:13:19,000
[學生]：如果x是一個指針，你會做

1047
01:13:19,000 --> 01:13:22,000
詮釋* Y = X代替的符號？

1048
01:13:22,000 --> 01:13:24,000
是。

1049
01:13:24,000 --> 01:13:27,000
如果x是一個指針，然後就可以設置兩個指針彼此相等，

1050
01:13:27,000 --> 01:13:30,000
在這種情況下，y的設置將不會為x，

1051
01:13:30,000 --> 01:13:34,000
但它會指向到任何x被指向。

1052
01:13:34,000 --> 01:13:37,000
不幸的是，我們沒有時間了。

1053
01:13:37,000 --> 01:13:44,000
>> 我想說在這一點上，我們可以談論這個脫機，

1054
01:13:44,000 --> 01:13:49,000
但我要說的開始工作，通過這個問題，＃14。

1055
01:13:49,000 --> 01:13:53,000
你可以看到已經有一點點充滿在你這裡。

1056
01:13:53,000 --> 01:13:57,000
您可以看到，當我們聲明了兩個指針，* X * Y，

1057
01:13:57,000 --> 01:14:01,000
注意，指向的變量*的東西，是去年。

1058
01:14:01,000 --> 01:14:05,000
原來，這是類似的，以我們正在做的這一年。

1059
01:14:05,000 --> 01:14:11,000
不要緊，你寫的*當你聲明的指針。

1060
01:14:11,000 --> 01:14:17,000
但是，我們已經寫了旁邊的類型*

1061
01:14:17,000 --> 01:14:24,000
因為這使得它很清楚，你聲明一個指針變量。

1062
01:14:24,000 --> 01:14:27,000
你可以看到，申報2個三分球，為我們提供了2盒。

1063
01:14:27,000 --> 01:14:31,000
在這裡，當我們設置x等於對malloc

1064
01:14:31,000 --> 01:14:34,000
這是什麼說的預留內存在堆中。

1065
01:14:34,000 --> 01:14:41,000
這個小盒子在這裡，這個圈子裡，位於堆。

1066
01:14:41,000 --> 01:14:43,000
X是指向它。

1067
01:14:43,000 --> 01:14:46,000
需要注意的是Y還沒有指向任何東西。

1068
01:14:46,000 --> 01:14:50,000
要獲得內存來存儲數字42到x

1069
01:14:50,000 --> 01:14:55,000
我們將使用什麼樣的符號？

1070
01:14:55,000 --> 01:14:59,000
[學生] * X = 42。

1071
01:14:59,000 --> 01:15:01,000
沒錯，* X = 42。

1072
01:15:01,000 --> 01:15:06,000
這意味著按照箭頭，並在那裡罰42。

1073
01:15:06,000 --> 01:15:09,000
在這裡我們設置y和x有y指向為x。

1074
01:15:09,000 --> 01:15:13,000
同樣，這就像凱文說什麼，我們設y等於x。

1075
01:15:13,000 --> 01:15:15,000
Y不指向為x。

1076
01:15:15,000 --> 01:15:19,000
相反，它指向x是指向以及。

1077
01:15:19,000 --> 01:15:24,000
>> 然後終於在這最後一箱有2種可能，我們可以做的事情。

1078
01:15:24,000 --> 01:15:28,000
其中之一是，我們可以說X = 13。

1079
01:15:28,000 --> 01:15:33,000
另一件事是，我們可以說，亞歷克斯，你知道，我們可以在這裡做什麼？

1080
01:15:33,000 --> 01:15:37,000
你可以說* X = 13

1081
01:15:37,000 --> 01:15:41,000
[學生]：你可以說詮釋什麼。

1082
01:15:41,000 --> 01:15:45,000
內特H.]如果這被稱為一個int變量，我們能做到這一點。

1083
01:15:45,000 --> 01:15:49,000
我們還可以說* Y = 13，因為它們都指向同一個地方，

1084
01:15:49,000 --> 01:15:51,000
這樣我們就可以使用任一變量到那裡。

1085
01:15:51,000 --> 01:15:56,000
是啊。>> [學生]：會是什麼樣子，如果我們只說INT x是13嗎？

1086
01:15:56,000 --> 01:16:00,000
這將宣告一個新的變量x，它是行不通的。

1087
01:16:00,000 --> 01:16:04,000
我們希望有一個碰撞，因為我們聲明x是一個指針。

1088
01:16:04,000 --> 01:16:10,000
[學生]：如果我們只是有這樣的聲明本身會是什麼樣子的圓嗎？

1089
01:16:10,000 --> 01:16:14,000
如果我們有X = 13，那麼我們就會有一個盒子，而不是箭頭

1090
01:16:14,000 --> 01:16:16,000
開箱即用的，我們得出它只是一個13。

1091
01:16:16,000 --> 01:16:19,000
[學生]：在“名稱”框中。好吧。

1092
01:16:19,000 --> 01:16:24,000
>> 感謝您的收看，祝你好運測驗0。

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]