1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [第2週，續]

2
00:00:02,270 --> 00:00:04,220
戴維·J·馬蘭，哈佛大學]

3
00:00:04,220 --> 00:00:06,880
[這是CS50。 -  CS50.TV]

4
00:00:06,880 --> 00:00:10,990
好的。這是CS50，這是第2週的結束。

5
00:00:10,990 --> 00:00:14,410
如果你是餓了明天的這個時候左右，

6
00:00:14,410 --> 00:00:18,620
知道我們要召開會議，明天一小群，週四，下午1:15。

7
00:00:18,620 --> 00:00:21,360
這個URL，在這裡，如果你想回覆。

8
00:00:21,360 --> 00:00:26,740
空間是有限的，所以請原諒的時候，你填這張表的形式填補了。

9
00:00:26,740 --> 00:00:29,300
另一個URL，雖然，您可能會感興趣的就是這個。

10
00:00:29,300 --> 00:00:32,369
在短短的一個月的時間，當然是要提供

11
00:00:32,369 --> 00:00:36,890
更廣泛的通過EDX，通過在互聯網上的人將能跟著​​，

12
00:00:36,890 --> 00:00:39,380
從事的過程相當積極，其實。

13
00:00:39,380 --> 00:00:42,270
他們將使用CS50電器和CS50討論

14
00:00:42,270 --> 00:00:45,490
而且，我們已經一直在使用這個學期的各種軟件工具。

15
00:00:45,490 --> 00:00:48,710
而其中一項措施，我們希望作為一個實驗，今年

16
00:00:48,710 --> 00:00:51,930
是我們可以看到多少內容翻譯

17
00:00:51,930 --> 00:00:53,960
成其他語言文字。

18
00:00:53,960 --> 00:00:57,500
所以，如果你有興趣參與該項目的

19
00:00:57,500 --> 00:01:02,270
據此，我們將提供英文成績單和字幕的課程的講座

20
00:01:02,270 --> 00:01:05,450
和短褲研討會和節之類的，

21
00:01:05,450 --> 00:01:08,200
如果你會講一口流利的或寫流利一些其他語言，

22
00:01:08,200 --> 00:01:12,290
我們很想吸引你，讓你在這個項目中的一個或多個視頻，

23
00:01:12,290 --> 00:01:15,200
將其轉化為一個語言，你知道得很好。

24
00:01:15,200 --> 00:01:18,700
>> 為了讓你的界面感，還有這個基於Web的用戶界面

25
00:01:18,700 --> 00:01:22,090
我們將使用，將創建基本上是這樣的一個UI。

26
00:01:22,090 --> 00:01:24,290
這是我教一些萬聖節前，

27
00:01:24,290 --> 00:01:27,390
和右手側有黑色旁邊的這些時間戳記，

28
00:01:27,390 --> 00:01:31,210
你會看到不同的東西，我的嘴裡說出來的那一天，

29
00:01:31,210 --> 00:01:34,850
然後在下面它，你就能夠翻譯成其他一些語言

30
00:01:34,850 --> 00:01:38,690
之間的映射是什麼，在這種情況下，英語，並說，西班牙語。

31
00:01:38,690 --> 00:01:40,440
因此，它實際上是一個非常用戶友好的工具。

32
00:01:40,440 --> 00:01:43,370
您可以倒帶，快進，很容易與鍵盤快捷鍵。

33
00:01:43,370 --> 00:01:47,490
所以，如果你想參加這個實驗，並有看到和閱讀你的話，

34
00:01:47,490 --> 00:01:51,850
有可能有成千上萬的人，請不要隨意參加。

35
00:01:51,850 --> 00:01:54,350
一個字的小貓從週一。

36
00:01:54,350 --> 00:02:00,350
過於可怕的消息發送，免得我們認識到，作為辦公時間建議

37
00:02:00,350 --> 00:02:03,300
和部分建議，在設計的過程是非常

38
00:02:03,300 --> 00:02:07,360
讓學生協作和談話工作，通過問題集

39
00:02:07,360 --> 00:02:11,260
和問題，真正的行僅僅歸結為，

40
00:02:11,260 --> 00:02:16,010
再次，最終提交你的工作應該是你自己。

41
00:02:16,010 --> 00:02:18,860
因此，坦白地說，這是完全正常的辦公時間，

42
00:02:18,860 --> 00:02:22,240
它完全可以預期的，甚至，你旁邊的一些朋友聊天。

43
00:02:22,240 --> 00:02:24,370
>> 如果他或她掙扎著一些話題和你一樣，

44
00:02:24,370 --> 00:02:27,940
“哦，好吧，讓我給你一個瞥見的，我寫了一些代碼行，”這是罰款，

45
00:02:27,940 --> 00:02:31,250
出現這種情況，這是非常有利的，我認為，學習的過程。

46
00:02:31,250 --> 00:02:36,750
是在哪裡得到的行交叉時，頭是有點歪了太多秒

47
00:02:36,750 --> 00:02:41,160
或真正分鐘，剛剛無障礙機會給你的朋友，

48
00:02:41,160 --> 00:02:44,160
當然，當事情會通過電子郵件和Dropbox和交換，

49
00:02:44,160 --> 00:02:45,640
也有就行了。

50
00:02:45,640 --> 00:02:48,620
因此，通過各種手段感到舒適，感到鼓舞，與朋友聊天

51
00:02:48,620 --> 00:02:52,810
有關pset和，只是和同學們認識到，你最終提交

52
00:02:52,810 --> 00:02:57,340
真的是你的創造，而不是別人的產品。

53
00:02:57,340 --> 00:03:00,490
因此，一個特定於域的為pset2問題，

54
00:03:00,490 --> 00:03:04,740
遲到明天晚上出來，是潛入世界的加密，

55
00:03:04,740 --> 00:03:08,970
這是藝術的加密和擾碼信息，

56
00:03:08,970 --> 00:03:12,600
這最終涉及到世界的安全。

57
00:03:12,600 --> 00:03:16,560
現在對於大多數人來說，安全性是相當平凡的機制的形式。

58
00:03:16,560 --> 00:03:19,050
我們所有的用戶名和密碼，

59
00:03:19,050 --> 00:03:23,450
我們所有的人都非常糟糕的用戶名和密碼，最有可能的。

60
00:03:23,450 --> 00:03:28,240
>> 如果您在多個網站上的密碼是相同的，這可能不是最好的主意，

61
00:03:28,240 --> 00:03:30,070
我們將討論向學期的結束。

62
00:03:30,070 --> 00:03:34,720
如果您的密碼是寫在一個便簽 - 可不是鬧著玩的 - 在您的顯示器，

63
00:03:34,720 --> 00:03:38,350
那也是不一定是最好的設計，而是一個相當普遍的現象。

64
00:03:38,350 --> 00:03:42,470
而且，如果你不使用加密技術來加密您的密碼，

65
00:03:42,470 --> 00:03:44,210
他們特別容易受到傷害。

66
00:03:44,210 --> 00:03:47,270
所以，如果你認為你是超級聰明，有一個隱藏的Word文檔

67
00:03:47,270 --> 00:03:49,910
在您的硬盤驅動器上的某個地方，有你所有的密碼

68
00:03:49,910 --> 00:03:53,670
但它在一個文件夾，沒有人會看的，也不是一個非常安全的機制。

69
00:03:53,670 --> 00:03:56,990
還等什麼pset2將介紹的是密碼學這門藝術

70
00:03:56,990 --> 00:04:02,010
和擾碼信息，如密碼，這樣的事情是更安全的。

71
00:04:02,010 --> 00:04:05,790
這裡的背景是不安全的數據

72
00:04:05,790 --> 00:04:07,930
來加密和爭奪它的機會。

73
00:04:07,930 --> 00:04:11,470
等，例如，是一個加密的消息的一個例子。

74
00:04:11,470 --> 00:04:14,700
這實際上說的是英語，但很明顯，這是不完全明顯。

75
00:04:14,700 --> 00:04:18,279
我們將兜了一圈，今天捉弄除了這個秘密的訊息是什麼。

76
00:04:18,279 --> 00:04:23,490
但在現實世界中的電腦，事情並不顯得像他們可能是英語短語。

77
00:04:23,490 --> 00:04:28,430
例如，這是一個標準的Linux或Mac或UNIX計算機上你可能會發現

78
00:04:28,430 --> 00:04:32,070
在一個文件中，曾經有段時間被稱為密碼文件。

79
00:04:32,070 --> 00:04:34,200
>> 如今，它已經搬到別的地方。

80
00:04:34,200 --> 00:04:39,210
但是，如果你的系統上，在正確的地方，你會看到不僅是你的用戶名

81
00:04:39,210 --> 00:04:43,400
或系統上的其他人，但你會看到他們的密碼的加密版本。

82
00:04:43,400 --> 00:04:47,980
事實上，這個詞地下室有以下的東西是加密的，

83
00:04:47,980 --> 00:04:52,680
這一系列看似隨機字母和字符和數字等等

84
00:04:52,680 --> 00:04:56,480
可解密僅由一般知道的一些秘密 - 

85
00:04:56,480 --> 00:04:58,840
一個秘密的話，一個秘密數字 - 

86
00:04:58,840 --> 00:05:03,160
事實上，藝術的加密技術最終都歸結到信任的某種

87
00:05:03,160 --> 00:05:05,650
，別人不知道的東西。

88
00:05:05,650 --> 00:05:10,090
因此，我們將探討這方面更詳細一點今天在pset中來。

89
00:05:10,090 --> 00:05:12,200
而現在通過/失敗的一個詞。

90
00:05:12,200 --> 00:05:15,360
特別是作為一些你跳入pset1移動設備的，

91
00:05:15,360 --> 00:05:19,080
和為自己是一個非常新的世界，認識到挫折和困惑

92
00:05:19,080 --> 00:05:21,700
只是技術上的困難是相當可以預期的，

93
00:05:21,700 --> 00:05:24,180
特別是與第一pset中，那裡有這麼多新的，

94
00:05:24,180 --> 00:05:27,730
剛剛熟悉的ls和cd，所有這些神秘的命令

95
00:05:27,730 --> 00:05:33,050
一個新的環境，這就是從實際材料和編程本身分開。

96
00:05:33,050 --> 00:05:36,940
所以實現也有一定的支撐結構存在的辦公時間。

97
00:05:36,940 --> 00:05:38,880
>> 節本星期日開始。

98
00:05:38,880 --> 00:05:42,960
但最重要的是，如果你覺得這是不是只是你的世界，

99
00:05:42,960 --> 00:05:44,710
認識到，它確實只是需要時間。

100
00:05:44,710 --> 00:05:48,600
，它不給我這個機會年前我一類的合格/不合格，

101
00:05:48,600 --> 00:05:50,990
說實話，我永遠不會甚至踏上在教室裡。

102
00:05:50,990 --> 00:05:53,690
你可以改變這件事，直到說，第五次週一的課程，

103
00:05:53,690 --> 00:05:58,280
所以，如果你現在上的優勢，完全實現，而不是頭部到一些其他水域，

104
00:05:58,280 --> 00:06:01,260
我肯定會考慮轉變為通過/失敗。

105
00:06:01,260 --> 00:06:04,570
同樣，有沒有真的這種文化在哈佛考慮的事情通過/失敗

106
00:06:04,570 --> 00:06:08,670
因為每個人都希望實現或超額完成，

107
00:06:08,670 --> 00:06:11,130
但坦率地說，這是一個美妙的方式嘗試了

108
00:06:11,130 --> 00:06:16,720
可能不很熟悉的，到頭來你會做什麼，在大多數情況下，相當精細，

109
00:06:16,720 --> 00:06:18,210
也許是很多給您驚喜。

110
00:06:18,210 --> 00:06:20,980
更具體的，我覺得通過/失敗一般不，

111
00:06:20,980 --> 00:06:22,940
尤其是當你可能會經歷與pset0，

112
00:06:22,940 --> 00:06:26,560
10小時，15小時，25小時，如果你把一些pset的

113
00:06:26,560 --> 00:06:29,920
你撞你的頭靠在牆上，它的超級深夜

114
00:06:29,920 --> 00:06:33,950
但你在pset 90％的方式，你就不能弄清楚一件事，

115
00:06:33,950 --> 00:06:36,520
通過/失敗真的需要這樣的一類邊緣，

116
00:06:36,520 --> 00:06:39,100
在那裡你可以排序，高興地說：“好吧，我知道這是不完美的，

117
00:06:39,100 --> 00:06:42,350
但我的工作我的屁股上，就結束了，我很高興。“

118
00:06:42,350 --> 00:06:44,850
，這將滿足期望通過/失敗。

119
00:06:44,850 --> 00:06:47,540
所以千萬記住這一點。好的。

120
00:06:47,540 --> 00:06:50,520
>> 因此，那些你一直在努力使用哈佛大學的Wi-Fi，

121
00:06:50,520 --> 00:06:54,780
我知道，有一個CS50 SSID，通過Wi-Fi連接，漂浮

122
00:06:54,780 --> 00:06:56,490
你可能有更好的運氣。

123
00:06:56,490 --> 00:07:00,130
這是一個有點諷刺的密碼，如果你想嘗試連接到該

124
00:07:00,130 --> 00:07:08,350
為更好的速度 - 讓我們知道，如果沒有更好的 - 是12345，一直到8

125
00:07:08,350 --> 00:07:10,910
因為8比5更安全。

126
00:07:10,910 --> 00:07:16,910
因此，如果你需要的Wi-Fi密碼，連接到CS50無線在這裡，12345678，

127
00:07:16,910 --> 00:07:20,380
發表於CS50討論，如果你仍然有間歇性的連接問題，

128
00:07:20,380 --> 00:07:25,420
我們將讓權力知道這個空間。好的。

129
00:07:25,420 --> 00:07:32,230
所以簡單的玩笑話，尤其是對於那些你們誰是所有蘋果的的風扇男孩或女孩的。

130
00:07:32,230 --> 00:07:37,460
我從幾年前挖了這個文件，iUnlock.c，

131
00:07:37,460 --> 00:07:39,930
只是種更具體，更複雜

132
00:07:39,930 --> 00:07:42,560
一些更基本的C程序，我們一直都在寫。

133
00:07:42,560 --> 00:07:46,910
於是，我打開了這個文件，iUnlock.c。這是今天的講座頁。

134
00:07:46,910 --> 00:07:49,810
在左側，您會看到一個長長的清單功能。

135
00:07:49,810 --> 00:07:53,230
因此，研究員，這是誰寫的寫了一個功能很多，以上只是主。

136
00:07:53,230 --> 00:07:57,340
他用一大堆的庫，在這裡，如果我們開始滾動，

137
00:07:57,340 --> 00:08:04,890
這實際上是的，是的，我相信，原來的iPhone破解。

138
00:08:04,890 --> 00:08:09,830
>> 當你想原來的iPhone越獄，這意味著untether從AT＆T

139
00:08:09,830 --> 00:08:13,710
實際安裝特殊的軟件就可以了，做的事情，蘋果不希望人們做，

140
00:08:13,710 --> 00:08:18,480
有人花時間弄清楚他們是如何利用軟件漏洞，

141
00:08:18,480 --> 00:08:22,690
錯誤，錯誤，蘋果軟件，並由此誕生iUnlock.c  - 

142
00:08:22,690 --> 00:08:26,760
如果你編譯它，您的計算機上安裝了一個iPhone上

143
00:08:26,760 --> 00:08:29,430
說，通過USB電纜連接到您的計算機，

144
00:08:29,430 --> 00:08:32,450
這將給你的行政或root權限在您的iPhone

145
00:08:32,450 --> 00:08:34,620
讓你做幾乎任何你想要的。

146
00:08:34,620 --> 00:08:36,400
所以這個迷人的貓捉老鼠的遊戲

147
00:08:36,400 --> 00:08:39,340
蘋果與世界其他地區，特別是他們，很多企業一樣，

148
00:08:39,340 --> 00:08:43,350
試圖鎖定自己的東西，所以，你只能用它做什麼，他們打算。

149
00:08:43,350 --> 00:08:47,360
但是，由於這樣的低級別的細節和理解的人 - 

150
00:08:47,360 --> 00:08:50,830
在這種情況下C語言編程 - 和很多熟悉的結構

151
00:08:50,830 --> 00:08:55,280
我們已經開始玩，你能夠真正利用硬件

152
00:08:55,280 --> 00:08:59,250
在您認為合適的方式，而不一定是一些企業實體。

153
00:08:59,250 --> 00:09:01,600
因此，舉例來說，我不知道這是做，

154
00:09:01,600 --> 00:09:03,580
但的GetVersion聽起來很簡單，

155
00:09:03,580 --> 00:09:05,710
看起來這是一個函數，這個人寫的。

156
00:09:05,710 --> 00:09:09,250
這需要某種整數作為參數，不返回任何東西，

157
00:09:09,250 --> 00:09:13,710
但似乎循環用一個for循環和if條件，如果條件中斷，

158
00:09:13,710 --> 00:09:16,770
並以某種方式涉及到的版本號，如果我們向下滾動，

159
00:09:16,770 --> 00:09:19,650
儘管很多這些關鍵字將是新的。

160
00:09:19,650 --> 00:09:22,590
有一個整體的功能在這裡，我們從來沒有見過，可能不會看到很多

161
00:09:22,590 --> 00:09:24,350
在本學期課程。

162
00:09:24,350 --> 00:09:29,160
>> 在一天結束的時候，它遵循相同的規則和邏輯，我們一直在玩迄今。

163
00:09:29,160 --> 00:09:34,340
因此，這是破解你的iPhone 3S或4S或很快5S這些天太舊，

164
00:09:34,340 --> 00:09:38,830
但要知道，這一切都非常來源於這個世界上，我們已經潛入。

165
00:09:38,830 --> 00:09:42,280
讓我們來看看一個更簡單一點的例子：

166
00:09:42,280 --> 00:09:46,260
這一塊，只是熱身的一些語法，還有一些其他的數據類型

167
00:09:46,260 --> 00:09:48,910
我們已經討論過，但還沒有真正看到在C

168
00:09:48,910 --> 00:09:53,670
這是一個的文件名為positive1.c，每在上面的評論，

169
00:09:53,670 --> 00:09:56,070
這只是要求用戶提供一個正數。

170
00:09:56,070 --> 00:09:59,910
所以這是一個例子，一個do-whil​​e循環，這是很好的用戶互動節目

171
00:09:59,910 --> 00:10:02,070
當你需要告訴用戶做一些事情，

172
00:10:02,070 --> 00:10:05,530
如果他們不配合你罵他們，或拒絕他們的意見。

173
00:10:05,530 --> 00:10:10,480
舉個例子：我會做19至24行

174
00:10:10,480 --> 00:10:14,620
只要用戶還沒有給我一個正數。

175
00:10:14,620 --> 00:10:21,340
這個細節在這裡的​​第18行，為什麼我聲明Ň高於整個循環結構

176
00:10:21,340 --> 00:10:26,870
而不是到第22行旁邊，我真正關心得到n？是啊。

177
00:10:26,870 --> 00:10:29,330
[學生]範圍。 “是啊，所以這個問題的範圍。

178
00:10:29,330 --> 00:10:31,770
通俗地說，是什麼範圍是指什麼？

179
00:10:34,880 --> 00:10:41,560
是啊。 >> [聽不見的學生回應] >>你說大聲一點好嗎？

180
00:10:41,560 --> 00:10:45,440
[學生]在這裡您可以訪問該變量。 >>完美。

181
00:10:45,440 --> 00:10:47,610
在這裡你可以訪問一個特定的變量。

182
00:10:47,610 --> 00:10:50,990
而且一般的經驗法則迄今為止一直認為某些變量的範圍

183
00:10:50,990 --> 00:10:56,140
最近你見過的花括號定義。

184
00:10:56,140 --> 00:11:03,070
>> 因此，在這種情況下，如果我犯了個錯誤的聲明n在第22行，該行會的工作。

185
00:11:03,070 --> 00:11:10,840
我會得到一個int，我會把它到第22行中的變量n，

186
00:11:10,840 --> 00:11:17,060
但哪一行代碼，現在已經不知道我在說什麼嗎？ >> [學生] 25。

187
00:11:17,060 --> 00:11:23,840
[馬蘭] 25和24，因為在這種情況下，它不屬於花括號。

188
00:11:23,840 --> 00:11:28,550
因此，只要一點點的滋擾，但很容易解決，通過簡單地聲明的變量

189
00:11:28,550 --> 00:11:30,700
外本身的功能。

190
00:11:30,700 --> 00:11:32,760
稍後我們將看到今天你可以多走一步

191
00:11:32,760 --> 00:11:34,940
你甚至可以得到一個有點懶惰。

192
00:11:34,940 --> 00:11:39,660
這是一般不被推薦，但你甚至可以偷懶

193
00:11:39,660 --> 00:11:44,150
並把一個全局變量，可以這麼說，而不是在函數，而不是內部的循環，

194
00:11:44,150 --> 00:11:49,800
但在文件本身以外的所有功能，你寫了，我在這裡的第15行。

195
00:11:49,800 --> 00:11:55,220
這是令人難以接受的，但意識到這是一個解決方案，有時其他的問題，

196
00:11:55,220 --> 00:11:56,910
我們最終會看到的。

197
00:11:56,910 --> 00:11:59,500
所以現在我們將離開這個樣子，但讓我們看看我們可以重寫此

198
00:11:59,500 --> 00:12:02,360
剛開始表達自己有點不同。

199
00:12:02,360 --> 00:12:05,550
這個方案，僅僅是明確的，是陽性。

200
00:12:05,550 --> 00:12:11,980
讓我繼續在這裡，在我的終端窗口陽性，回車。

201
00:12:11,980 --> 00:12:15,080
編譯沒問題。我要去，運行positive1，按下回車鍵。

202
00:12:15,080 --> 00:12:19,250
我要求你給我一個正整數。我會說：-1。沒有工作。

203
00:12:19,250 --> 00:12:22,340
0，99。這似乎工作。

204
00:12:22,340 --> 00:12:25,310
也許不是最嚴峻的考驗，但至少它是一個不錯的完整性檢查

205
00:12:25,310 --> 00:12:27,100
我們在正確的軌道上。

206
00:12:27,100 --> 00:12:29,570
>> 所以，現在讓我繼續前進，打開第2版，

207
00:12:29,570 --> 00:12:32,800
有什麼不同了嗎？

208
00:12:32,800 --> 00:12:39,030
它實現了同樣的事情，但什麼是跳出清楚地不同，這一次呢？

209
00:12:40,790 --> 00:12:47,090
這BOOL綠色。它的顯示為綠色，這被稱為布爾值，它是一種數據類型的關鍵字。

210
00:12:47,090 --> 00:12:50,510
它不內置於所有版本的C

211
00:12:50,510 --> 00:12:52,650
您需要包括一個特定的庫。

212
00:12:52,650 --> 00:12:56,460
在我們的例子中，我的CS50庫，使我們有機會為bool。

213
00:12:56,460 --> 00:12:59,860
但在第18行，我們似乎有一個布爾值，這裡所謂的感謝。

214
00:12:59,860 --> 00:13:02,190
我可以叫什麼，但我把它叫做感謝

215
00:13:02,190 --> 00:13:04,750
只是一種傳達一些語義上的意義。

216
00:13:04,750 --> 00:13:07,700
因此，最初的第18行，我顯然不是感謝

217
00:13:07,700 --> 00:13:12,230
因為在第18行初始化為false的布爾值感謝。

218
00:13:12,230 --> 00:13:16,500
然後，似乎我做了什麼，在21行〜23

219
00:13:16,500 --> 00:13:19,200
我只是一種重寫我的邏輯。

220
00:13:19,200 --> 00:13:26,100
因此，沒有在功能上不同，但在第22行現在我如果int用戶提供了

221
00:13:26,100 --> 00:13:31,360
大於0，那麼我簡單地改變感謝真正的價值。

222
00:13:31,360 --> 00:13:35,590
我為什麼這樣做呢？因為在第25行，顯然我要檢查的條件。

223
00:13:35,590 --> 00:13:39,760
做這個循環，同時感謝是假的。

224
00:13:39,760 --> 00:13:42,960
所以，我提出作為替代第1版

225
00:13:42,960 --> 00:13:47,050
因為它至少有一點也許更直觀的，這是一個有點植根於英語。

226
00:13:47,050 --> 00:13:51,980
因此，請執行以下操作，而你不感謝，同時感謝是假的。

227
00:13:51,980 --> 00:13:56,220
而這個時候，我也顯然不關心記住用戶輸入的

228
00:13:56,220 --> 00:14:00,050
因為通知中，沒有任何變量n，所以實際上，有一個善意的謊言。

229
00:14:00,050 --> 00:14:03,290
>> 在功能上，該方案是一個有點不同的，一旦我們得到它的底部

230
00:14:03,290 --> 00:14:04,960
因為我不記得n是什麼。

231
00:14:04,960 --> 00:14:09,120
但我想在這裡展示我們已經看到過，即使調用getInt

232
00:14:09,120 --> 00:14:13,780
和GetString正在使用的右手邊的等號，迄今為止，

233
00:14:13,780 --> 00:14:17,310
讓我們記住它們的價值，從技術上講，這不是絕對必要的。

234
00:14:17,310 --> 00:14:20,290
如果因為任何原因，你只是不小心保存的價值，

235
00:14:20,290 --> 00:14:25,540
你只是要檢查的值，請注意，我們可以簡單地這樣寫調用getInt，

236
00:14:25,540 --> 00:14:27,320
開括號，括號接近。

237
00:14:27,320 --> 00:14:30,570
該函數會返回一個值，因為我們一直在說。

238
00:14:30,570 --> 00:14:32,220
這將會給你一個int。

239
00:14:32,220 --> 00:14:34,460
所以，如果你在精神上認為這種情況發生，

240
00:14:34,460 --> 00:14:38,190
當我輸入99，調用getInt返回99號，

241
00:14:38,190 --> 00:14:41,840
因此從理論上講，它雖然我的代碼實際上是這個。

242
00:14:41,840 --> 00:14:45,950
因此，如果99的確是大於0的，然後感謝成為真正的，

243
00:14:45,950 --> 00:14:50,810
第25行實現哦，我們正在做的，因為我現在感謝，

244
00:14:50,810 --> 00:14:53,970
第26行，我們簡單地說，“謝謝你正整數！”

245
00:14:53,970 --> 00:14:55,960
不管它發生。

246
00:14:55,960 --> 00:14:59,140
現在，讓我們在這裡做輕微的語法糖，可以這麼說。

247
00:14:59,140 --> 00:15:04,670
讓我們來看看如果我們能清理這條線25在positive3這第三個和最後的變體。

248
00:15:04,670 --> 00:15:13,600
>> 請注意，唯一不同的是哪一行代碼？ >> [學生] 25。 >> [馬蘭]是啊，25。

249
00:15:13,600 --> 00:15:17,680
我們還沒有真正看到這一招只是還沒有，但我們沒有看到1月21日的感嘆號，

250
00:15:17,680 --> 00:15:21,070
這表示什麼呢？ >> [學生]。 >>或否定。

251
00:15:21,070 --> 00:15:23,510
因此，需要一個布爾值，，並翻轉它的價值。

252
00:15:23,510 --> 00:15:25,810
真亦假，假的變成真的。

253
00:15:25,810 --> 00:15:30,420
所以，我建議，即使是一點點更直觀的方式編寫代碼

254
00:15:30,420 --> 00:15:33,430
因為我仍然會初始化為false感謝，我還是做到以下幾點，

255
00:15:33,430 --> 00:15:36,010
我感謝設置為true，在時機成熟時，

256
00:15:36,010 --> 00:15:40,880
但現在你可以真的只是翻譯代碼口頭左到右，

257
00:15:40,880 --> 00:15:45,630
（感謝）;因為爆炸或感嘆號表示不的概念，

258
00:15:45,630 --> 00:15:47,580
因此，雖然不感謝。

259
00:15:47,580 --> 00:15:49,900
所以，再一次，我們沒有引入任何新的概念本身。

260
00:15:49,900 --> 00:15:53,730
我們談論布爾值，當我們從頭打了，

261
00:15:53,730 --> 00:15:56,720
但現在認識到，我們就可以開始寫我們的代碼在許多不同的方式。

262
00:15:56,720 --> 00:16:01,060
因此，尤其是在pset1移動，如果你是那種掙扎的方式來編寫一些程序，

263
00:16:01,060 --> 00:16:04,340
賠率是你很幸運，因為可以有任意數量的解決方案

264
00:16:04,340 --> 00:16:06,110
您可以在發生。

265
00:16:06,110 --> 00:16:10,500
舉例來說，這僅僅是3，即使是最簡單的方案。好的。

266
00:16:10,500 --> 00:16:14,200
現在還記得上週一，我們在此說明離開與返回值。

267
00:16:14,200 --> 00:16:18,450
因此，對於第一次，我們寫了一個程序，不只是有主;

268
00:16:18,450 --> 00:16:22,550
它也有它自己的自定義函數，我寫在這裡。

269
00:16:22,550 --> 00:16:26,810
因此，在第31行到34，我已經實現了一個多維數據集函數。

270
00:16:26,810 --> 00:16:30,240
這並不複雜。這只是一個* A * A在這種情況下。

271
00:16:30,240 --> 00:16:34,750
但是，重要的是它是我輸入的形式

272
00:16:34,750 --> 00:16:39,180
我回A * A * A的形式輸出。

273
00:16:39,180 --> 00:16:43,560
所以，現在我有能力，就像我單獨與prinf，

274
00:16:43,560 --> 00:16:47,240
調用該函數調用的立方體函數。

275
00:16:47,240 --> 00:16:51,970
>> 和多維數據集函數需要一定的投入，和多維數據集函數返回一些輸出。

276
00:16:51,970 --> 00:16:56,960
與此相反，輸出只是做了一些事情。

277
00:16:56,960 --> 00:17:00,840
它沒有返回任何東西，我們關心的，順便說一句，即使它返回一個值;

278
00:17:00,840 --> 00:17:03,110
你只是籠統地忽略它。

279
00:17:03,110 --> 00:17:06,510
的printf只是做了一些事情。它有打印到屏幕上的副作用。

280
00:17:06,510 --> 00:17:11,770
通過對比在這裡，我們有多維數據集函數，它實際上返回的東西。

281
00:17:11,770 --> 00:17:15,520
因此，對於那些熟悉的，這是一個非常簡單的想法。

282
00:17:15,520 --> 00:17:19,640
但對於那些不太熟悉這個想法傳遞的投入，並取回輸出，

283
00:17:19,640 --> 00:17:21,950
讓我們嘗試只是超級簡單的東西。

284
00:17:21,950 --> 00:17:25,490
是任何人都舒服了舞台上簡單嗎？

285
00:17:25,490 --> 00:17:28,040
你有舒適與你的相機。是嗎？好吧。

286
00:17:28,040 --> 00:17:31,240
你叫什麼名字？ >> [學生]肯。 “肯。好的。肯，就到了。

287
00:17:31,240 --> 00:17:35,050
肯將是各種各樣的功能，在這裡。

288
00:17:35,050 --> 00:17:38,720
讓我們繼續前進，並做到這一點。讓我們一點點花哨。

289
00:17:38,720 --> 00:17:42,260
認識你很高興。歡迎來到舞台中央。好的。

290
00:17:42,260 --> 00:17:46,640
讓打這個按鈕，在這裡。好的。

291
00:17:46,640 --> 00:17:49,820
所以，在這裡你有一個現代化的黑板上，

292
00:17:49,820 --> 00:17:53,470
我的主要功能是，例如，

293
00:17:53,470 --> 00:17:56,460
我沒有一台iPad拿在手中。

294
00:17:56,460 --> 00:17:59,710
>> 我真的不記得怎麼樣 - 好了，我不能說。

295
00:17:59,710 --> 00:18:02,480
我真的不具有良好的手寫，

296
00:18:02,480 --> 00:18:05,520
因此，我想你打印的東西對我來說在屏幕上。

297
00:18:05,520 --> 00:18:12,040
我的主程序，我要你說這

298
00:18:12,040 --> 00:18:16,720
它在我的雞從頭開始寫，然後通過您的輸入。

299
00:18:16,720 --> 00:18:20,400
雖然這項工作是太傻了，功能和調用一個函數的概念

300
00:18:20,400 --> 00:18:22,400
並返回一個函數真的歸結到這。

301
00:18:22,400 --> 00:18:26,260
我主，我剛才寫的printf，報價享有的東西在屏幕上，

302
00:18:26,260 --> 00:18:29,110
我運行這個程序，一旦被調用的printf，

303
00:18:29,110 --> 00:18:32,880
它需要一個參數一個參數，有時在雙引號之間。

304
00:18:32,880 --> 00:18:35,880
這裡有這樣的說法。我把它傳遞給肯。

305
00:18:35,880 --> 00:18:39,020
寫了一些數年前，他是一個黑盒子

306
00:18:39,020 --> 00:18:41,510
顯然只知道如何打印在屏幕上的東西。

307
00:18:41,510 --> 00:18:43,150
所以執行。

308
00:18:49,280 --> 00:18:51,280
這是不壞的。非常好。

309
00:18:51,280 --> 00:18:55,510
所以，現在肯執行。他遞給我任何東西嗎？

310
00:18:55,510 --> 00:18:57,470
這並不是說我們迄今為止見過的。

311
00:18:57,470 --> 00:19:00,460
同樣，printf並實際上返回一個數字，但我們忽略，現在

312
00:19:00,460 --> 00:19:03,470
因為我們從來沒有用過它。所以這是它為肯。

313
00:19:03,470 --> 00:19:08,580
因此，現在主要需要控制的程序

314
00:19:08,580 --> 00:19:11,060
因為這行代碼，輸出，完成執行。

315
00:19:11,060 --> 00:19:14,050
我們去我們的方式，執行任何其他線。

316
00:19:14,050 --> 00:19:17,320
現在讓我們嘗試一個稍微不同的例子。

317
00:19:17,320 --> 00:19:24,940
這一次在這裡讓我們先來清除屏幕，這時候我們會做的魔方功能，

318
00:19:24,940 --> 00:19:27,080
但是這一次，我期望的輸出值。

319
00:19:27,080 --> 00:19:29,180
>> 因此，讓我們繼續前進，並做到這一點。

320
00:19:29,180 --> 00:19:35,790
現在，我必須說，X獲取立方體的x行的代碼。

321
00:19:41,370 --> 00:19:46,370
這行代碼，召回，看起來像這樣：X =立方體（X）;

322
00:19:46,370 --> 00:19:50,930
所以，這是怎麼去上班？讓我們繼續前進，並給你一個白色的屏幕。

323
00:19:50,930 --> 00:19:54,070
我要寫下x的值，

324
00:19:54,070 --> 00:20:01,400
在這個時候，恰好是，比方說，保持它的簡單。

325
00:20:01,400 --> 00:20:06,150
我已經寫在一張紙的價值，這是我的x值。

326
00:20:06,150 --> 00:20:10,920
我把它肯。 “我只寫答案是什麼？呀，讓我們只寫答案。

327
00:20:12,760 --> 00:20:18,940
好吧。現在他已經回到我的東西。完美的。尼斯SEGUE。

328
00:20:18,940 --> 00:20:23,120
所以，現在他遞給我回值8，在這種情況下，我用它做什麼？

329
00:20:23,120 --> 00:20:28,250
其實 - 讓我們來看看，得到這個權利。我會用它做什麼呢？

330
00:20:28,250 --> 00:20:33,440
現在，我要藉此價值和實際存儲在內存中在這些相同的位。

331
00:20:33,440 --> 00:20:35,170
但是請注意，我是那種掙扎在這裡。

332
00:20:35,170 --> 00:20:38,210
我有點困惑，因為我在哪裡寫x的值，

333
00:20:38,210 --> 00:20:43,150
因為我剛剛做的是需要親自肯一張紙的值是2，

334
00:20:43,150 --> 00:20:46,590
這是X，而事實上，這恰恰發生了什麼事。

335
00:20:46,590 --> 00:20:50,210
因此，原來，當你調用該函數，並傳遞參數

336
00:20:50,210 --> 00:20:53,290
喜歡Hello，世界傳遞的參數，如2，

337
00:20:53,290 --> 00:20:57,110
一般情況下，你通過在副本這樣的說法。

338
00:20:57,110 --> 00:21:00,730
所以，正如我寫下的2號這裡，並把它交給肯，

339
00:21:00,730 --> 00:21:04,720
必須說我的地方仍然有一份價值2

340
00:21:04,720 --> 00:21:08,890
因為事實上，現在我已經得到了值8，我需要回去RAM

341
00:21:08,890 --> 00:21:12,130
寫下我曾經有過的數字2。

342
00:21:12,130 --> 00:21:16,950
因此，在視覺上，請記住這個概念，從字面上看，一個副本的價值。

343
00:21:16,950 --> 00:21:20,780
>> 肯做他的東西，遞給我的東西 - 在這種情況下，這樣的值8  - 

344
00:21:20,780 --> 00:21:24,980
然後，我必須做一些與該值，如果我要保持它的周圍。

345
00:21:24,980 --> 00:21:29,650
因此，所有的一切都會回來不久是所有太熟悉了。

346
00:21:29,650 --> 00:21:34,920
非常感謝你在這裡演示，肯。 [掌聲]

347
00:21:34,920 --> 00:21:36,920
非常好。

348
00:21:36,920 --> 00:21:42,690
讓我們來看看如何，最終涉及到的一些函數調用，我們一直在這裡做。

349
00:21:42,690 --> 00:21:47,910
讓我繼續前進，把我們帶回了魔方的例子在這裡。

350
00:21:47,910 --> 00:21:53,300
請注意，如果我們要真正開始採取進一步

351
00:21:53,300 --> 00:21:57,570
我們必須考慮到一個事實，即數x的傳遞在這裡

352
00:21:57,570 --> 00:22:01,530
從實際被傳遞給函數的是不同的。

353
00:22:01,530 --> 00:22:05,880
所以，再一次，通過複製傳遞將成為相當有密切關係，在短短的時刻。

354
00:22:05,880 --> 00:22:09,580
讓我們來看看的東西，不工作的權利，但。

355
00:22:09,580 --> 00:22:13,250
我要繼續前進，打開第三個車為例，這是有缺陷的性質，

356
00:22:13,250 --> 00:22:18,550
這就是所謂的buggy3，它實現了一個交換的功能。

357
00:22:18,550 --> 00:22:25,110
在這裡，我們有一個主要功能，x和y任意初始化為1和2，分別。

358
00:22:25,110 --> 00:22:27,700
我們可以使用調用getInt，但我們只需要一個簡單的練習，

359
00:22:27,700 --> 00:22:30,170
所以它是硬編碼為1和2。

360
00:22:30,170 --> 00:22:35,340
在第21行和22行，我們似乎打印出x和y，每行1。

361
00:22:35,340 --> 00:22:39,720
然後在第23行，我要求我交換這些值，點，點，點。

362
00:22:39,720 --> 00:22:44,170
顯然，我在第24行所謂的交換，需要兩個參數，調用一個函數。

363
00:22:44,170 --> 00:22:48,300
這是完全合法的功能，需要兩個參數。我們已經看到輸出已經做到這一點了。

364
00:22:48,300 --> 00:22:51,830
>> 所以交換顯然需要x和y，正如它的名字所暗示的，

365
00:22:51,830 --> 00:22:54,670
我希望它會交換這兩個值。

366
00:22:54,670 --> 00:23:00,090
因此，我要求在第25行“換！”我和轉載的X和Y

367
00:23:00,090 --> 00:23:03,070
的假設下，他們已經確實被交換。

368
00:23:03,070 --> 00:23:06,080
但是，如果我運行這個程序 - 讓我打開一個終端窗口，

369
00:23:06,080 --> 00:23:09,860
讓我buggy3  - 顧名思義，這是沒有好下場的

370
00:23:09,860 --> 00:23:15,770
因為當我按下Enter鍵，注意x是1，y是2，

371
00:23:15,770 --> 00:23:19,420
尚未在程序結束時，它們仍然是，實際上，相同的。

372
00:23:19,420 --> 00:23:22,960
因此，根據示範與肯，剛才到底發生了什麼？

373
00:23:22,960 --> 00:23:28,710
我們來看看這個交換功能。它的超級短。這是只有幾行代碼長。

374
00:23:28,710 --> 00:23:34,520
但是，什麼是最根本的問題的基礎上簡單的故事與肯在這裡告訴嗎？

375
00:23:34,520 --> 00:23:36,670
交換為什麼壞了？

376
00:23:36,670 --> 00:23:39,660
[學生]你存儲的副本，而不是變量。

377
00:23:39,660 --> 00:23:43,980
沒錯。我們存儲的副本，而不是變量本身。

378
00:23:43,980 --> 00:23:47,170
換句話說，交換顯然需要兩個參數，一個int，

379
00:23:47,170 --> 00:23:49,370
和它的任意稱為a和b，

380
00:23:49,370 --> 00:23:54,420
這裡我已經通過在x和y分別為1和2，這是

381
00:23:54,420 --> 00:23:58,770
但我不是真的通過在x，我不從字面上通過在y

382
00:23:58,770 --> 00:24:01,450
我是通過x和y的副本的副本。

383
00:24:01,450 --> 00:24:04,510
這幾乎就好像你複製並粘貼到交換

384
00:24:04,510 --> 00:24:07,810
你希望它是實際操作的值。

385
00:24:07,810 --> 00:24:14,480
所以，如果是這樣的話，當我的程序開始執行第35行，然後36，

386
00:24:14,480 --> 00:24:18,650
當我到37行，在這一點上的故事，是什麼值呢？

387
00:24:21,040 --> 00:24:25,050
在這一點上的故事，37號線，在這一點上的價值是什麼？ >> [學生] 1。

388
00:24:25,050 --> 00:24:29,280
[馬蘭它應該只是1，正確的，因為x的第一個參數中傳遞，

389
00:24:29,280 --> 00:24:33,080
此功能只是任意調用它的第一個參數。

390
00:24:33,080 --> 00:24:38,200
同樣是Y的第二個參數，它只是隨意調用的第二個參數b。

391
00:24:38,200 --> 00:24:40,990
>> 這種兩分法其實是相當簡單的解釋。想想吧。

392
00:24:40,990 --> 00:24:43,320
我們沒有見過的人誰寫輸出，

393
00:24:43,320 --> 00:24:50,770
因此可以肯定，他或她不知道30年後，我們的變量來調用。

394
00:24:50,770 --> 00:24:56,650
因此，必須有區分你叫什麼變量的功能，你寫的

395
00:24:56,650 --> 00:25:02,080
你叫什麼功能，你打電話或使用的變量。

396
00:25:02,080 --> 00:25:05,340
所以，換句話說，我寫了我的變量x和y，

397
00:25:05,340 --> 00:25:08,890
但如果別人已經寫了交換功能，他或她肯定會不知道

398
00:25:08,890 --> 00:25:10,690
我的變量來調用，

399
00:25:10,690 --> 00:25:13,830
所以認識到，這就是為什麼你有這種二元性的名稱。

400
00:25:13,830 --> 00:25:16,750
從技術上講，我可以做到這一點巧合，

401
00:25:16,750 --> 00:25:20,080
但他們仍然可以通過為副本。

402
00:25:20,080 --> 00:25:23,650
這僅僅是一個純粹的巧合，美觀，如果人誰寫的交換

403
00:25:23,650 --> 00:25:26,150
曾使用相同的名稱。

404
00:25:26,150 --> 00:25:32,370
所以在這一點上故事中的第37行，一個是1，B是2，現在我進行交換。

405
00:25:32,370 --> 00:25:34,900
首先，讓我真正做到這一點簡單得多。

406
00:25:34,900 --> 00:25:36,690
我不知道這3行代碼做什麼。

407
00:25:36,690 --> 00:25:41,210
讓我這樣做：B = A; A = B;完成。

408
00:25:41,210 --> 00:25:44,690
為什麼是這個破碎的，邏輯上嗎？

409
00:25:46,490 --> 00:25:48,900
這是一種直觀的東西，對不對？

410
00:25:48,900 --> 00:25:52,560
因此，一個變為b和b成為一個

411
00:25:52,560 --> 00:25:57,730
但問題是，只要線37執行，什麼是a和b的值？

412
00:25:57,730 --> 00:26:03,410
相同的是，1，因為你已經篡改，可以這麼說，你已經改變了b為一個。

413
00:26:03,410 --> 00:26:08,890
因此，一旦線路37條的執行，這是偉大的，你現在有2份1號

414
00:26:08,890 --> 00:26:13,350
裡面的這個函數，你說這樣的話時，在第38行A = B，

415
00:26:13,350 --> 00:26:17,640
你因為你只是指定1到1種旋。

416
00:26:17,640 --> 00:26:20,580
你失去了你關心的價值。

417
00:26:20,580 --> 00:26:23,220
因此，在原始版本，請注意，我就是這樣做的。

418
00:26:23,220 --> 00:26:26,850
我不是有三分之一的代碼看起來是這樣的。

419
00:26:26,850 --> 00:26:28,580
我聲明了一個臨時變量。

420
00:26:28,580 --> 00:26:32,170
>> tmp是一個臨時變量，一個很常見的名字，它是一個int

421
00:26:32,170 --> 00:26:34,580
因為它符合我要的副本。

422
00:26:34,580 --> 00:26:39,770
我的tmp目錄內的存儲複製，所以一旦已經執行了37行，

423
00:26:39,770 --> 00:26:45,860
的值是 - 快速完整性檢查 -  1，b的值是2，

424
00:26:45,860 --> 00:26:48,970
TMP的價值也是1。

425
00:26:48,970 --> 00:26:52,060
所以，現在我執行第38行。

426
00:26:52,060 --> 00:27:00,540
一旦執行第38行，需要的b的值。和B是2，所以現在是2。

427
00:27:00,540 --> 00:27:05,210
所以在這一點上的故事，一個是2，B 2，tmp是1，

428
00:27:05,210 --> 00:27:11,060
所以現在從邏輯上講，我們只是撲通TMP到b的值，我們就大功告成了。

429
00:27:11,060 --> 00:27:12,800
因此，我們已經解決了這個問題。

430
00:27:12,800 --> 00:27:17,720
不幸的是，當我運行這個程序，在這種形式，它並不實際交換的任何值。

431
00:27:17,720 --> 00:27:20,100
但要清楚，為什麼呢？

432
00:27:23,660 --> 00:27:26,450
我剛才固定的邏輯問題，

433
00:27:26,450 --> 00:27:31,020
但話又說回來，如果我運行這個程序，X和Y保持不變

434
00:27:31,020 --> 00:27:33,310
結束程序的執行。

435
00:27:33,310 --> 00:27:37,220
[聽不見的學生評論] >>我們還沒有返回任何東西，所以這是真的。

436
00:27:37,220 --> 00:27:39,670
但事實證明，這裡有一個有點問題，因為到目前為止，

437
00:27:39,670 --> 00:27:44,170
唯一的事情，我們已經能夠返回一個東西，這是有限制的C.

438
00:27:44,170 --> 00:27:49,070
你可以只返回一個真正的價值，在這種情況下，我有點堅持在這裡

439
00:27:49,070 --> 00:27:53,310
因為我可以返回新的x值，或者我可以返回新的y值，

440
00:27:53,310 --> 00:27:55,190
但我既要回來了。

441
00:27:55,190 --> 00:27:58,650
於是久違這裡沒有簡單的解決方案。

442
00:27:58,650 --> 00:28:01,710
但問題的根本是為什麼呢？我們有什麼實際交換？

443
00:28:01,710 --> 00:28:04,190
[學生]：a和b。 >> a和b。

444
00:28:04,190 --> 00:28:08,230
但是A和B是x和y，這意味著我們只是做了所有的工作副本，

445
00:28:08,230 --> 00:28:11,650
我們只用了3分鐘，談論交換功能，所有這些變量，

446
00:28:11,650 --> 00:28:15,420
這是偉大的，完全正確的隔離，

447
00:28:15,420 --> 00:28:20,740
但A和B的範圍是在這些行。

448
00:28:20,740 --> 00:28:24,790
>> 就像一個for循環，如果你聲明一個整數，我在for循環中，

449
00:28:24,790 --> 00:28:28,760
同樣，如果你​​聲明a和b裡面的一個函數，你寫的，

450
00:28:28,760 --> 00:28:33,320
該函數的內部，他們是唯一有效的，這意味著只要交換是執行

451
00:28:33,320 --> 00:28:38,470
和我們去從第24行到第25行中，x和y沒有被改變在所有。

452
00:28:38,470 --> 00:28:42,790
你只是浪費了大量的時間交換的變量的副本。

453
00:28:42,790 --> 00:28:47,010
所以，事實證明，要解決這個實際上是不很明顯。

454
00:28:47,010 --> 00:28:50,670
這不是很充足的返回值，因為我們只能返回1的值，

455
00:28:50,670 --> 00:28:53,470
我真的想交換x和y都在相同的時間，

456
00:28:53,470 --> 00:28:55,210
所以我們要回來這。

457
00:28:55,210 --> 00:29:01,020
但現在，意識到該問題，a和b的副本的事實從根本上來自

458
00:29:01,020 --> 00:29:03,630
他們是在自己的範圍內。

459
00:29:03,630 --> 00:29:05,050
讓我們以某種方式設法解決這個。

460
00:29:05,050 --> 00:29:11,250
讓我真正滾動回到這裡打開了，讓我們說，第四個變種，buggy4。

461
00:29:11,250 --> 00:29:13,370
這個怎麼樣？

462
00:29:13,370 --> 00:29:17,810
這是類似的，但簡單的問題，看之前，我們需要解決它的刺。

463
00:29:17,810 --> 00:29:24,190
這項計劃被稱為增量，很顯然初始化一個X 1線18之間的整數。

464
00:29:24,190 --> 00:29:28,150
然後，我x是1，然後我要求“遞增...”

465
00:29:28,150 --> 00:29:33,730
然後我叫增量，但在22日和23行，我要求它已經增加，

466
00:29:33,730 --> 00:29:40,220
我要求x現在不管它是什麼 -  2，據推測 - 這是越野車的計劃。

467
00:29:40,220 --> 00:29:42,610
有什麼問題嗎？

468
00:29:43,440 --> 00:29:50,160
是啊。 >> [聽不見的學生回應] >>沒錯。

469
00:29:50,160 --> 00:29:52,490
因此X已經宣布，很明顯，第18行。

470
00:29:52,490 --> 00:29:54,700
這是內主要的大括號中。

471
00:29:54,700 --> 00:29:58,440
所以，簡單的答案是x存在，在這裡，

472
00:29:58,440 --> 00:30:03,930
它不存在，在第32行，因此這個方案甚至不會編譯。

473
00:30:03,930 --> 00:30:07,940
我嘗試編譯代碼時，編譯器會罵我

474
00:30:07,940 --> 00:30:14,100
一些未聲明的標識符或東西的效果。事實上，讓我們嘗試。

475
00:30:14,100 --> 00:30:18,470
這是使buggy4。在那裡，它是。

476
00:30:18,470 --> 00:30:22,110
使用未聲明的標識符“X”的第32行。

477
00:30:22,110 --> 00:30:25,580
而實際上，讓我們更明確的今天，這是非常有用的

478
00:30:25,580 --> 00:30:27,580
在辦公時間和在家裡。

479
00:30:27,580 --> 00:30:29,300
>> 請注意，這是一個有點神秘的書面。

480
00:30:29,300 --> 00:30:37,270
但事實上，鏗鏘有對我們大吼大叫，說buggy4.c：32:5，實際上是有用的。

481
00:30:37,270 --> 00:30:42,050
這意味著，該錯誤是在第5字符位置的線32上。

482
00:30:42,050 --> 00:30:46,700
因此，1，2，3，4，5。這是，事實上，問題出在哪裡。

483
00:30:46,700 --> 00:30:49,790
此外，也記住在辦公時間，在家裡，我很幸運在這裡。

484
00:30:49,790 --> 00:30:52,990
我有一個錯誤。這將是比較容易解決的。

485
00:30:52,990 --> 00:30:55,990
但是，如果你得到了整個畫面充滿壓倒性的錯誤消息，

486
00:30:55,990 --> 00:31:00,330
再次，實現最底層的人可能只是最上面的症狀。

487
00:31:00,330 --> 00:31:03,450
因此，總是追逐你的錯誤，從上而下

488
00:31:03,450 --> 00:31:05,820
因為有可能只是一個菊花鏈效應

489
00:31:05,820 --> 00:31:09,240
建議你有比你實際做的方式更多的問題。

490
00:31:09,240 --> 00:31:15,150
那麼，我們怎麼能解決這個問題，如果我的目標是增加x？ >> [學生] X全局。

491
00:31:15,150 --> 00:31:17,060
好了，我們可以使X全球。

492
00:31:17,060 --> 00:31:20,480
讓我們以快捷，我先前警告，但心裡很不舒服，我們只需要一個快速解決方案，

493
00:31:20,480 --> 00:31:25,730
所以讓我們只說在這裡詮釋x。這使X全球。

494
00:31:25,730 --> 00:31:31,800
所以，現在主要有訪問和增量訪問，

495
00:31:31,800 --> 00:31:34,110
所以讓我繼續前進，現在編譯這個。

496
00:31:34,110 --> 00:31:37,630
，輸入使buggy4。似乎現在編譯。

497
00:31:37,630 --> 00:31:41,230
讓運行buggy4。看來，以實際工作。

498
00:31:41,230 --> 00:31:45,150
這是一個，按我說的這些東西，還不如我呢，

499
00:31:45,150 --> 00:31:47,010
我剛剛在這裡完成的，因為在一般情況下，

500
00:31:47,010 --> 00:31:50,440
我們的計劃會得到更有趣，比這更長的時間，

501
00:31:50,440 --> 00:31:56,390
如果您解決生活中的問題，只是把所有的變量在文件的開頭，

502
00:31:56,390 --> 00:31:59,690
做節目非常迅速獲得驚人，難以管理。

503
00:31:59,690 --> 00:32:02,190
它變得很難想出新的變量名，

504
00:32:02,190 --> 00:32:05,240
它會更難明白變量是做什麼的，

505
00:32:05,240 --> 00:32:08,460
所以在一般，這是不是一個好的解決方案。

506
00:32:08,460 --> 00:32:10,030
因此，讓我們做到這一點。

507
00:32:10,030 --> 00:32:12,160
我們不想在這裡使用一個全局變量。

508
00:32:12,160 --> 00:32:16,240
>> 我想增加x，所以我可以很明顯 - 

509
00:32:16,240 --> 00:32:18,670
在一天結束的時候，這是一個愚蠢的故事，因為我們只要做到這一點 - 

510
00:32:18,670 --> 00:32:24,450
但是，如果我不知道，運營商或我是不允許改變它在主本身，

511
00:32:24,450 --> 00:32:30,730
我還能實現肯在這裡沒有對多維數據集，但增加？

512
00:32:31,380 --> 00:32:33,190
我該如何改變這件事情嗎？是啊。

513
00:32:33,190 --> 00:32:38,480
[學生] PASS x，然後返回[聽不清] >>好，好。

514
00:32:38,480 --> 00:32:41,900
那麼，為什麼不我通過在x和，而不是返回，

515
00:32:41,900 --> 00:32:44,870
我為什麼不只是返回x + 1。

516
00:32:44,870 --> 00:32:47,710
一對夫婦更多的事情必須改變。我在正確的軌道上。

517
00:32:47,710 --> 00:32:49,770
還有什麼我需要調整嗎？別人。是啊。

518
00:32:49,770 --> 00:32:51,740
[聽不見的學生反應]

519
00:32:51,740 --> 00:32:54,730
我需要改變返回類型的增量，因為它沒有失效。

520
00:32:54,730 --> 00:32:57,780
被返回無效意味著什麼，但清楚的是，

521
00:32:57,780 --> 00:32:59,830
所以這需要改變 -  >> [學生]詮釋。

522
00:32:59,830 --> 00:33:02,740
int類型是一致的，無論我返回。

523
00:33:02,740 --> 00:33:05,180
現在別的東西，是大聲喧嘩。是啊。

524
00:33:05,180 --> 00:33:08,400
[聽不見的學生反應] >> [馬蘭]所以，我需要增加x？

525
00:33:08,400 --> 00:33:12,080
[聽不見的學生反應] >> [馬蘭啊，所以我需要傳遞X。

526
00:33:12,080 --> 00:33:16,660
所以我需要在這裡做到這一點。 >> [聽不見的學生評論]

527
00:33:16,660 --> 00:33:20,050
[馬蘭]的原型，我必須要改變這個在這裡。

528
00:33:20,050 --> 00:33:22,930
因此，這已經成為一個int，成為 - 

529
00:33:22,930 --> 00:33:25,620
嗯，我其實有一個錯誤在這裡。讓我們來解決這個第一次。

530
00:33:25,620 --> 00:33:29,590
應該是什麼內容究竟是什麼？它是一個int的東西。

531
00:33:29,590 --> 00:33:32,700
這可能是X，但坦率地說，如果你開始調用所有的變量x，

532
00:33:32,700 --> 00:33:35,390
它會得到越來越不清晰哪個是哪個。

533
00:33:35,390 --> 00:33:39,560
>> 因此，讓我們任意選擇一個不同的命名約定為我的助手功能，

534
00:33:39,560 --> 00:33:41,940
我寫的功能。我們會打電話給它，或者我們可以把它稱為 - 

535
00:33:41,940 --> 00:33:45,010
讓我們把它數更明確。

536
00:33:45,010 --> 00:33:47,560
於是我返回任何數加1，

537
00:33:47,560 --> 00:33:50,740
現在我要改變的事情，在這裡，一個其他的東西在這裡。

538
00:33:50,740 --> 00:33:54,350
我有什麼改變第21行第一次嗎？ >> [聽不見的學生反應]

539
00:33:54,350 --> 00:33:57,610
[馬蘭]我有把它分配給x。我可以不叫增量（X）。

540
00:33:57,610 --> 00:34:01,960
我需要記住的答案，通過改變x的值的左側。

541
00:34:01,960 --> 00:34:04,680
即使x是現在的左，右，這是完全正常

542
00:34:04,680 --> 00:34:08,860
因為右手邊先被執行，然後得到一屁股到左手的事情 - 

543
00:34:08,860 --> 00:34:10,600
x在這種情況下。

544
00:34:10,600 --> 00:34:12,159
最後，這是一個簡單的辦法。

545
00:34:12,159 --> 00:34:17,230
這應該只是匹配下，INT編號。

546
00:34:17,230 --> 00:34:20,570
因此，一大堆的一個非常愚蠢的功能

547
00:34:20,570 --> 00:34:24,420
但具有代表性，我們將越來越多地想要做的事情。

548
00:34:24,420 --> 00:34:27,090
因此，請buggy4。我搞砸了的地方。

549
00:34:27,090 --> 00:34:30,139
哦，我的上帝。五6行程序中的錯誤。

550
00:34:30,139 --> 00:34:35,690
那麼，什麼是錯的第18行，字符？

551
00:34:35,690 --> 00:34:39,610
所以，我必須聲明，詮釋。

552
00:34:39,610 --> 00:34:41,920
讓我們來看看。有一大堆其他錯誤。

553
00:34:41,920 --> 00:34:47,010
哦，我的上帝 -  19，18，21  - 但同樣，讓我們清除屏幕，控制L，

554
00:34:47,010 --> 00:34:49,380
並重新運行鏗鏘。

555
00:34:49,380 --> 00:34:51,340
因此，5個問題是，1。

556
00:34:51,340 --> 00:34:57,520
所以，現在讓我們來運行buggy4，回車。哇，x已經被正確地增加。

557
00:34:57,520 --> 00:35:02,720
好的。如何增加數字的任何問題？是啊。

558
00:35:02,720 --> 00:35:09,870
[聽不見的學生問題] >>很好的問題。

559
00:35:09,870 --> 00:35:14,220
它是如何，我可以只改變x的數量，程序將立即知道嗎？

560
00:35:14,220 --> 00:35:16,200
>> 同樣，認為它是這個抽象。

561
00:35:16,200 --> 00:35:21,600
所以，我主要和Ken是增量，坦率地說，我不關心，什麼肯稱，他的iPad。

562
00:35:21,600 --> 00:35:26,570
我不在乎他所說的任何有跟他實現這個功能。

563
00:35:26,570 --> 00:35:33,340
這是一個實現細節，我主，不關心。

564
00:35:33,340 --> 00:35:38,250
因此，簡單地改變它一貫裡面的功能 - 數字和數量在這裡 - 

565
00:35:38,250 --> 00:35:40,960
都需要只要我重新編譯。

566
00:35:40,960 --> 00:35:44,180
這是有點像，如果你認為我們很多人，你的駕駛執照

567
00:35:44,180 --> 00:35:46,770
驅動或如果你甚至驅動的汽車，

568
00:35:46,770 --> 00:35:50,950
我們大多數人不知道如何汽車引擎蓋下的。

569
00:35:50,950 --> 00:35:54,970
從字面上看，如果你打開引擎蓋，我們大多數人 - 包括我自己 - 

570
00:35:54,970 --> 00:35:56,940
不會真正了解我們正在尋找，

571
00:35:56,940 --> 00:35:59,220
就像你可能會覺得現在的東西，如這項權利的一種。

572
00:35:59,220 --> 00:36:01,480
但是，我們真的不關心的汽車是如何工作的，

573
00:36:01,480 --> 00:36:05,970
我們不必關心的所有的汽車內的桿和活塞和電纜

574
00:36:05,970 --> 00:36:08,160
實際上這樣做。

575
00:36:08,160 --> 00:36:12,770
所以像你所說的在這裡並不重要，在這種情況下，活塞的東西。同樣的想法。

576
00:36:12,770 --> 00:36:25,300
是啊。 >> [聽不見的學生問題]

577
00:36:25,300 --> 00:36:29,180
如果還有更多的用途可變的舍的時刻前，

578
00:36:29,180 --> 00:36:32,150
作為程序員，你將不得不改變他們無處不在。

579
00:36:32,150 --> 00:36:36,600
或者你可以從字面上文件，菜單，然後查找，替換 - 類似的東西 - 

580
00:36:36,600 --> 00:36:39,170
但你會擁有自己的這些變化。

581
00:36:39,170 --> 00:36:47,450
你必須是一致的。 >> [學生]如果有多個變量[聽不清]

582
00:36:47,450 --> 00:36:53,100
喜歡這裡，如果這是一個特定的順序int的另一個電話號碼嗎？ >> [學生]正確。

583
00:36:53,100 --> 00:36:56,590
[馬蘭]是啊。順序很重要，當你調用該函數。

584
00:36:56,590 --> 00:37:00,050
>> 所以，如果我在這裡呼籲增加的東西逗號東西，

585
00:37:00,050 --> 00:37:01,680
有一個直接的映射。

586
00:37:01,680 --> 00:37:05,690
第一個變量，不管它的名字，在這裡的第一個參數的副本。

587
00:37:05,690 --> 00:37:07,760
抱歉。這不應該是一個括號。

588
00:37:07,760 --> 00:37:11,490
第二個參數與第二個。 ，是的，所以，為了事宜。好的。

589
00:37:11,490 --> 00:37:17,020
抱歉。我花了很長的路到那裡。其他問題嗎？好的。

590
00:37:17,020 --> 00:37:20,610
因此，讓我們來看看，如果我們不能畫一幅畫，居然會在這裡發生了什麼

591
00:37:20,610 --> 00:37:23,090
引擎蓋下的，可以這麼說。

592
00:37:23,090 --> 00:37:26,640
這是一個矩形，可能代表你的計算機的內存。

593
00:37:26,640 --> 00:37:30,970
即使你不知道如何記憶或RAM作品如何，

594
00:37:30,970 --> 00:37:33,940
至少，假設你有束，這些天。

595
00:37:33,940 --> 00:37:36,280
你必須兆的，你有GB的，

596
00:37:36,280 --> 00:37:40,870
我們知道，從0週，一個字節是什麼？ >> [學生] 8位。

597
00:37:40,870 --> 00:37:42,950
8位的，對不對？因此，8個零和1。

598
00:37:42,950 --> 00:37:45,880
所以，如果你的計算機有一個演出的RAM，2音樂會的RAM，這些天，

599
00:37:45,880 --> 00:37:55,030
你有一個億或2億字節的內存或大約8億或16億位

600
00:37:55,030 --> 00:37:56,890
您的計算機內。

601
00:37:56,890 --> 00:38:00,590
與毛茸茸的小威利例如，它沒有磁性粒子通常會了。

602
00:38:00,590 --> 00:38:04,450
越來越多的 - 至少在筆記本電腦 - 它的固態硬盤，固態硬盤，

603
00:38:04,450 --> 00:38:08,580
只是沒有可移動部件。這是所有的電子。這一切都基於電力。

604
00:38:08,580 --> 00:38:14,060
因此，認為這個​​矩形代表1或2 GB的內存，你必須。

605
00:38:14,060 --> 00:38:16,020
>> 因此，它是一個內存塊。

606
00:38:16,020 --> 00:38:19,830
世界計算機科學排序分區

607
00:38:19,830 --> 00:38:22,950
內存塊做不同的事情。

608
00:38:22,950 --> 00:38:27,190
舉例來說，如果這是您的計算機的RAM，有建議由矩形，

609
00:38:27,190 --> 00:38:31,130
事實證明，按照慣例，在您的RAM的頂部，可以這麼說，

610
00:38:31,130 --> 00:38:33,660
一般是什麼所謂的文本段。

611
00:38:33,660 --> 00:38:36,740
這些都是“0”和“1編譯了。

612
00:38:36,740 --> 00:38:39,020
所以，當我們已經看到引擎蓋底下的a.out是什麼，

613
00:38:39,020 --> 00:38:41,980
所有這些0和1，當你運行一個程序，

614
00:38:41,980 --> 00:38:46,290
那些“0”和“1”從您的硬盤驅動器加載到一些所謂的RAM，

615
00:38:46,290 --> 00:38:49,320
在RAM中，他們把在頂部。

616
00:38:49,320 --> 00:38:52,770
同時，你還有其他的事情：初始化數據，未初始化的數據。

617
00:38:52,770 --> 00:38:57,510
這些大片的內存是指為全局變量，你不經常使用

618
00:38:57,510 --> 00:39:00,760
但有時如果你這樣做，他們結束了在那裡為好。

619
00:39:00,760 --> 00:39:04,260
此外，還有一些其他的東西：環境變量，我們不會花太多的時間，

620
00:39:04,260 --> 00:39:06,860
但隨後2個重要的事情，這將回來，整個學期，

621
00:39:06,860 --> 00:39:08,550
堆棧和堆。

622
00:39:08,550 --> 00:39:12,210
因此，大多數在運行程序時，您的計算機的內存被保留

623
00:39:12,210 --> 00:39:15,370
一些所謂的堆棧，稱為堆的東西。

624
00:39:15,370 --> 00:39:18,840
我們不會談論今天的堆，但我們將討論有關堆棧。

625
00:39:18,840 --> 00:39:24,600
該協議棧是為了喚起了視覺的食堂餐托盤Mather中樓

626
00:39:24,600 --> 00:39:28,110
無論你發生的地方，食堂的工作人員清理他們的每一天，

627
00:39:28,110 --> 00:39:30,180
它們堆疊起來，從地板上起來，

628
00:39:30,180 --> 00:39:34,550
同樣，在內存中，這種想法將在棧上的東西，

629
00:39:34,550 --> 00:39:36,860
把堆棧上的東西，將東西在棧上。

630
00:39:36,860 --> 00:39:38,240
是什麼意思呢？

631
00:39:38,240 --> 00:39:41,860
>> 讓我們放大只是這張照片的下半部分，您的計算機的RAM，

632
00:39:41,860 --> 00:39:44,330
提出以下建議。

633
00:39:44,330 --> 00:39:48,170
事實證明，當你運行一個程序，如a.out或你好 - 

634
00:39:48,170 --> 00:39:50,100
無論程序是你寫的 - 

635
00:39:50,100 --> 00:39:54,020
再次，這些從您的硬盤驅動器，這是長期存儲，加載“0”和“1”

636
00:39:54,020 --> 00:39:57,230
在那裡停留，甚至當你拔出插頭，加載到RAM中。

637
00:39:57,230 --> 00:40:00,610
RAM的速度比硬盤驅動器 - 它是小於硬盤驅動器 - 

638
00:40:00,610 --> 00:40:03,300
但它的節目直播，當你運行它們。

639
00:40:03,300 --> 00:40:08,230
所以，你雙擊一個Mac或PC上的程序，它的硬盤驅動器加載到RAM中。

640
00:40:08,230 --> 00:40:11,520
只要它加載到RAM中去的方式上，“0”和“1，

641
00:40:11,520 --> 00:40:16,610
所謂的文本段，但只要你的程序實際開始運行，

642
00:40:16,610 --> 00:40:21,360
的主要功能是打電話，主，正如我們已經看到的那樣，經常有局部變量，

643
00:40:21,360 --> 00:40:24,870
它有整型和字符串和字符之類的。

644
00:40:24,870 --> 00:40:29,180
所以，如果你的程序，你寫的程序，你已經雙擊

645
00:40:29,180 --> 00:40:32,970
使用的主要內部的一些變量，

646
00:40:32,970 --> 00:40:37,240
他們結束了在你的內存堆棧的底部，可以這麼說。

647
00:40:37,240 --> 00:40:39,410
更具體地說，這究竟是什麼意思？

648
00:40:39,410 --> 00:40:48,450
這也就意味著，如果我們要在您的計算機數量的字節RAM，

649
00:40:48,450 --> 00:40:55,750
注意到，這可能會對字節號0，字節數1，2，3，4，5，6，這可能會對

650
00:40:55,750 --> 00:41:01,480
一路攀升至2億美元將一路攀升，在頂部。

651
00:41:01,480 --> 00:41:05,880
所以，換句話說，當我們談論RAM或內存中的字節，

652
00:41:05,880 --> 00:41:11,500
它只是意味著有人已經決定什麼號每個這些內存塊。

653
00:41:11,500 --> 00:41:16,650
所以，當你需要32位的int或者您需要一個字符的8位，

654
00:41:16,650 --> 00:41:18,840
他們在哪裡結束在內存中嗎？

655
00:41:18,840 --> 00:41:22,350
>> 從概念上講，他們剛剛結束了這個東西叫做堆棧的底部。

656
00:41:22,350 --> 00:41:25,870
但現在什麼有趣的是，當主調用一個函數 - 

657
00:41:25,870 --> 00:41:28,750
假設有一個名為foo的功能，只是一個任意的名稱 - 

658
00:41:28,750 --> 00:41:32,330
會發生什麼更主要的是在這個堆棧的內存的底部;

659
00:41:32,330 --> 00:41:35,680
美孚現在被放置在頂部的主內存中。

660
00:41:35,680 --> 00:41:40,990
因此，任何局部變量foo的結束形式的概念上高於主。

661
00:41:40,990 --> 00:41:47,070
如果foo調用另一個函數調用酒吧，這些變量在這裡結束。

662
00:41:47,070 --> 00:41:50,120
如果酒吧調用別的東西，在這裡，這裡，這裡。

663
00:41:50,120 --> 00:41:53,830
那麼，在運行了一個程序很有意思的是，當你調用函數

664
00:41:53,830 --> 00:41:57,750
那些函數調用的函數，這些函數調用功能，

665
00:41:57,750 --> 00:42:01,470
你建立了這個堆棧在內存中的功能。

666
00:42:01,470 --> 00:42:06,890
而只有一個函數返回後，你開始，內存。

667
00:42:06,890 --> 00:42:10,860
因此，一個最簡單的方法在計算機程序中運行的內存

668
00:42:10,860 --> 00:42:14,360
編寫函數從不返回。

669
00:42:14,360 --> 00:42:18,900
因此，舉例來說，讓盡可能多的展示與故意錯誤的程序。

670
00:42:18,900 --> 00:42:22,230
讓我繼續做＃包括<stdio.h>的，

671
00:42:22,230 --> 00:42:25,000
詮釋的主要（無效），

672
00:42:25,000 --> 00:42:32,940
，我該怎麼辦（2​​> 1），這可能會不會改變我們，

673
00:42:32,940 --> 00:42:37,560
讓我繼續做輸出。

674
00:42:37,560 --> 00:42:40,700
事實上，這將是在視覺有趣的。讓我們這樣做。

675
00:42:40,700 --> 00:42:50,240
對於INT I = 0; I> 0  - 讓我們犯這樣的錯誤 - 我+ +。

676
00:42:50,240 --> 00:42:52,720
讓我們在這裡不是printf。我們的做法是我的說教。

677
00:42:52,720 --> 00:43:00,190
讓我們有一個方法，在這裡，無效合唱，我們會說INT I，

678
00:43:00,190 --> 00:43:06,830
然後我會說printf的 - 不，讓我們使這更有趣。

679
00:43:06,830 --> 00:43:15,790
讓實際不打印任何東西，在所有。讓我們只是這樣做：合唱團（I）。

680
00:43:15,790 --> 00:43:20,390
好的。因此，這是越野車，因為為什麼呢？

681
00:43:20,390 --> 00:43:23,380
我正在做這件事，因為我去，因為該計劃實際上並沒有做任何事情的興趣。

682
00:43:23,380 --> 00:43:25,320
>> 但是，這不是目標。

683
00:43:25,320 --> 00:43:29,630
我們的目標是編寫一個程序，做什麼，顯然，其主要功能？

684
00:43:30,720 --> 00:43:32,860
調用自身。實際上，我們並不需要循環。

685
00:43:32,860 --> 00:43:37,200
讓我們甚至簡化，從而不能忽視的真正的根本錯誤。

686
00:43:37,200 --> 00:43:39,640
主要調用合唱團唱一些合唱團，

687
00:43:39,640 --> 00:43:41,440
然後我做了一些愚蠢的事情，我不得不合唱團的呼叫合唱團

688
00:43:41,440 --> 00:43:43,760
因為我以為別人要實現它，也許，

689
00:43:43,760 --> 00:43:47,210
現在這是不會還來編譯。我需要做什麼？

690
00:43:47,210 --> 00:43:49,970
我需要的原型，記住了。

691
00:43:49,970 --> 00:43:56,110
所以我需要在這裡無效合唱團（int i）的;

692
00:43:56,110 --> 00:43:59,210
所以，現在如果我去了 - 實際上，讓我們用更大的窗口。

693
00:43:59,210 --> 00:44:01,980
讓我們繼續前進，並合唱。

694
00:44:01,980 --> 00:44:06,490
讓我們繼續前進，並合唱。

695
00:44:06,490 --> 00:44:08,370
使用未聲明的標識符我。

696
00:44:08,370 --> 00:44:12,500
哦，那是愚蠢的。我們並不需要的參數。我們只要做到這一點。

697
00:44:12,500 --> 00:44:16,370
我想我們已經開始這樣。這本來是一個更簡單的程序編寫。

698
00:44:16,370 --> 00:44:25,590
有。現在，讓我們去到我的終端窗口，重新運行鐺，在這裡，我們走。

699
00:44:25,590 --> 00:44:28,460
這是真快。

700
00:44:28,460 --> 00:44:31,150
究竟剛發生時，有關係嗎？

701
00:44:31,150 --> 00:44:33,730
好了，現在我將添加打印線，這樣我們就可以看到。

702
00:44:33,730 --> 00:44:43,490
讓我說printf（“請我在這裡”） - 不變量。我們會留下這樣說。

703
00:44:43,490 --> 00:44:47,480
讓我重新運行。讓我重新運行合唱團。

704
00:44:47,480 --> 00:44:57,380
而且......來。繼續下去。

705
00:44:57,380 --> 00:44:59,930
順便說一句，為什麼它沒有崩潰嗎？

706
00:44:59,930 --> 00:45:02,080
分割故障發生前超級快。

707
00:45:02,080 --> 00:45:06,570
[聽不見的學生回應] >>沒錯。因此，需要一定的時間進行打印，對不對？

708
00:45:06,570 --> 00:45:08,610
它只是需要更多的工作在計算機的一部分。

709
00:45:08,610 --> 00:45:10,620
還有，它是：分割故障。

710
00:45:10,620 --> 00:45:12,340
>> 因此，發現是多麼快的程序運行。

711
00:45:12,340 --> 00:45:14,130
如果你沒有打印任何東西，超級快。

712
00:45:14,130 --> 00:45:18,770
但是，我們仍然得到了該段故障，因為發生了什麼事？

713
00:45:18,770 --> 00:45:21,210
如果你仔細想想你的計算機的內存中的佈局如何，

714
00:45:21,210 --> 00:45:28,740
這恰好是主要的，但在這裡，我們只需要調用這個合唱，讓我們這個合唱團。

715
00:45:28,740 --> 00:45:34,550
現在，如果我做我的美學，這只是要說的合唱團，合唱團，合唱團，

716
00:45:34,550 --> 00:45:40,550
合唱團，合唱團，合唱團，合唱團，廣告不厭其煩，最終會發生什麼？

717
00:45:40,550 --> 00:45:45,630
如果大的畫面，從字面上看，是這樣的，這是發生在概念上嗎？

718
00:45:46,520 --> 00:45:48,630
該協議棧溢出堆。

719
00:45:48,630 --> 00:45:51,940
或者，更糟糕的是，你只是溢出的一切，包括文本段，

720
00:45:51,940 --> 00:45:54,590
這是“0”和“1”，代表你的程序。

721
00:45:54,590 --> 00:45:57,080
總之，這僅僅是超級，超級壞。

722
00:45:57,080 --> 00:45:58,830
你的程序已失去控制。

723
00:45:58,830 --> 00:46:01,220
您使用的是比你預期的方式更多的內存

724
00:46:01,220 --> 00:46:03,960
因為一個愚蠢的錯誤，在這種情況下，

725
00:46:03,960 --> 00:46:08,040
在這種情況下，故意做函數調用本身。

726
00:46:08,040 --> 00:46:09,500
現在，這並不全是壞事。

727
00:46:09,500 --> 00:46:13,800
調用自己的函數實際上有很大的權力，當你正確地使用它。

728
00:46:13,800 --> 00:46:15,800
我還沒有正確地使用它在這裡。

729
00:46:15,800 --> 00:46:19,780
因此，這並不全是壞事，但事實上，我從來沒有真正停止稱自己

730
00:46:19,780 --> 00:46:23,520
這個方案是一個根本的弱點在這裡。

731
00:46:23,520 --> 00:46:26,400
那麼，我們要與所有這一切嗎？到底發生了什麼？

732
00:46:26,400 --> 00:46:30,340
當我打電話的增值功能，如在那些例子中，我們正在做，

733
00:46:30,340 --> 00:46:33,420
我有一個值，如1，我傳進去

734
00:46:33,420 --> 00:46:37,570
我通過在1號的副本，所以發生以下情況。

735
00:46:37,570 --> 00:46:44,240
讓我們進入增量的例子，這傢伙就在這裡。

736
00:46:44,240 --> 00:46:46,870
下面是實際發生的事情。

737
00:46:46,870 --> 00:46:53,400
當我打電話的增量，和我通過在x，形象地，在這裡發生了什麼事情是這樣的。

738
00:46:53,400 --> 00:46:59,520
>> 如果我有1的值存儲在這裡和其實我打電話增量，

739
00:46:59,520 --> 00:47:04,330
現在被稱為合唱團 -  iPad是扔我在這裡下車。

740
00:47:04,330 --> 00:47:09,760
讓我們把這個增量，我們不知道這是什麼功能將是。

741
00:47:09,760 --> 00:47:14,840
那麼，什麼是實際發生的事情是這裡的某個地方主，我有一個內存塊，

742
00:47:14,840 --> 00:47:17,000
存儲數字1。

743
00:47:17,000 --> 00:47:19,380
當我打電話給增量，我使用其他的內存塊，

744
00:47:19,380 --> 00:47:21,230
但現在我有副本1。

745
00:47:21,230 --> 00:47:26,660
當我增加值，這將成為2

746
00:47:26,660 --> 00:47:30,560
但後​​來發生了什麼，盡快增加收益？

747
00:47:30,560 --> 00:47:33,630
內存只是被交還給操作系統，

748
00:47:33,630 --> 00:47:37,450
這意味著你所做的一切是沒有什麼用處的。

749
00:47:37,450 --> 00:47:43,120
1，最初是包含在主實際上仍然存在。

750
00:47:43,120 --> 00:47:44,890
所以，我們要這個嗎？

751
00:47:44,890 --> 00:47:49,770
事實證明，在內存中，你有這回的字節序列

752
00:47:49,770 --> 00:47:53,050
你可以把東西，事實證明，我們已經看到的東西

753
00:47:53,050 --> 00:47:55,390
把事情背靠背背靠背。

754
00:47:55,390 --> 00:47:59,860
什麼是基於字符串的第1週，現在2週？

755
00:48:00,020 --> 00:48:01,980
這只是一個字符集合。

756
00:48:01,980 --> 00:48:04,310
所以，就像你可以把號碼在內存中，

757
00:48:04,310 --> 00:48:06,990
同樣，你可以把字符在內存中。

758
00:48:06,990 --> 00:48:10,530
一旦我們開始把字符在內存中背靠背背靠背，

759
00:48:10,530 --> 00:48:13,620
事實證明，用最簡單的事情，比如一個for循環或while循環，

760
00:48:13,620 --> 00:48:17,170
我們可以遍歷一個字符串中的字符從左至右

761
00:48:17,170 --> 00:48:20,600
並開始按摩完全不同的字符 - 

762
00:48:20,600 --> 00:48:23,370
一個可能成為B，B可能成為C  - 

763
00:48:23,370 --> 00:48:27,780
所以，歸根結底，我們可以採取一個英語句子，其實是有道理的

764
00:48:27,780 --> 00:48:30,310
和轉換每個那些字母1在一個時間

765
00:48:30,310 --> 00:48:34,400
通過步行通過我們的計算機的內存中，左到右，實際上是加密。

766
00:48:34,400 --> 00:48:35,810
因此，讓我們在這裡把我們五分鐘的休息時間，

767
00:48:35,810 --> 00:48:40,730
當我們回來時，我們將​​啟動這一進程的擾碼信息。

768
00:48:42,020 --> 00:48:43,520
>> 好的。

769
00:48:43,520 --> 00:48:48,070
在我們深入到一些加密，這些東西稱為“陣列”，

770
00:48:48,070 --> 00:48:51,470
有任何問題，讓我停下來，因為我覺得我是那種混亂的

771
00:48:51,470 --> 00:48:54,080
一些主題。所以現在，如果我們可以讓我們來解決。

772
00:48:54,080 --> 00:48:58,700
我們剛才談到的返回值，我們談論的參數，

773
00:48:58,700 --> 00:49:03,250
我們談到這個概念，我們會回來的幾個星期來，

774
00:49:03,250 --> 00:49:08,720
查看內存一大堆的這些堆疊托盤，可以這麼說，

775
00:49:08,720 --> 00:49:12,660
從底部起來，這樣會在棧上，每個托盤

776
00:49:12,660 --> 00:49:16,530
這是目前被稱為代表一個函數。

777
00:49:17,900 --> 00:49:20,260
有什麼問題嗎？

778
00:49:20,260 --> 00:49:22,640
讓我在這裡問一個問題。

779
00:49:22,640 --> 00:49:27,890
讓我簡化這回它是什麼之前，我們早期的Q＆A.

780
00:49:27,890 --> 00:49:35,570
事實上，增加開括號，整型數，封閉括號 - 

781
00:49:35,570 --> 00:49:39,110
整數數字代表什麼？

782
00:49:39,110 --> 00:49:42,790
[學生]的說法。 >>的說法。好吧。但是，什麼是參數？

783
00:49:42,790 --> 00:49:46,370
[聽不見的學生回應] >>那是什麼？ >> [學生]：這件事你傳入

784
00:49:46,370 --> 00:49:49,940
好了，這樣的東西，你傳進去，更普遍的是，這僅僅是輸入。

785
00:49:49,940 --> 00:49:52,450
如果你正在寫一個函數，該函數的目的在生活中

786
00:49:52,450 --> 00:49:55,770
是做的東西有點不同，每次你使用它，

787
00:49:55,770 --> 00:50:00,110
要做到這一點真的那麼唯一的辦法似乎是為它提供輸入

788
00:50:00,110 --> 00:50:03,510
以便它可以做不同的東西每次與該輸入信號。

789
00:50:03,510 --> 00:50:06,650
>> 所以，你需要指定兩件事情，當一個函數需要輸入。

790
00:50:06,650 --> 00:50:09,590
您需要指定的名稱，你想給的輸入

791
00:50:09,590 --> 00:50:12,700
純粹是為了自己的方便，使您可以參考

792
00:50:12,700 --> 00:50:16,540
在功能，你寫，我在這裡的第32行。

793
00:50:16,540 --> 00:50:20,800
但是，你還需要指定它的類型，因為C是一種編程語言

794
00:50:20,800 --> 00:50:25,940
只需要，如果你想要一個變量，你必須告訴計算機它是什麼樣的數據類型，

795
00:50:25,940 --> 00:50:30,200
在很大程度上，所以它知道有多少位分配給該變量

796
00:50:30,200 --> 00:50:33,020
因為它可能是6  - 對不起，不會是6。

797
00:50:33,020 --> 00:50:37,080
它也可以是16，它可以是8，它可以是32，甚至64，

798
00:50:37,080 --> 00:50:39,130
但電腦需要知道的。

799
00:50:39,130 --> 00:50:43,180
現在，在左手側的int代表什麼，相比之下？

800
00:50:46,350 --> 00:50:48,850
[聽不見的學生回應] >>那是什麼？ >> [學生]類型的功能。

801
00:50:48,850 --> 00:50:53,610
一個函數的類型，並且更具體的是，它的輸出的類型。右。

802
00:50:53,610 --> 00:50:57,380
因此，而括號中的東西代表的輸入，如果有的話，

803
00:50:57,380 --> 00:50:59,660
到左的東西它的輸出。

804
00:50:59,660 --> 00:51:03,530
在這種情況下，增量顯然是返回一個int，

805
00:51:03,530 --> 00:51:07,690
所以int是這個函數的返回類型。

806
00:51:07,690 --> 00:51:09,340
要返回的是什麼意思？

807
00:51:09,340 --> 00:51:15,090
從字面上看，您可以使用關鍵字return，然後如果你正在返回

808
00:51:15,090 --> 00:51:18,600
關鍵字右側的是一個整數，

809
00:51:18,600 --> 00:51:21,660
這確實是符合我們所承諾的。

810
00:51:21,660 --> 00:51:26,410
你不能做這樣的事情 - 你好，世界 - 因為這是一個字符串。

811
00:51:26,410 --> 00:51:28,860
>> 顯然，這是不是一個整數。

812
00:51:28,860 --> 00:51:33,140
因此，在短，真的是對我們的負擔，程序員，要具體

813
00:51:33,140 --> 00:51:37,770
我們回國，然後返回。

814
00:51:37,770 --> 00:51:43,440
這裡的背景是，現在你的電腦的內存是技嘉，2 GB的 - 

815
00:51:43,440 --> 00:51:45,920
什麼 - 也許是更重要的，也許是少了，

816
00:51:45,920 --> 00:51:49,050
但電腦的看法有不同的部分。

817
00:51:49,050 --> 00:51:51,200
出現在那裡，別的東西在那裡，

818
00:51:51,200 --> 00:51:54,290
不同的東西在中間，今天我們剛開始講的故事，

819
00:51:54,290 --> 00:51:56,340
但我們會回來到這個隨著時間的推移。

820
00:51:56,340 --> 00:51:59,980
現在，唯一的一塊內存中，我們真正關心的是文本段

821
00:51:59,980 --> 00:52:03,360
因為這只是代表了0和1鐺輸出。

822
00:52:03,360 --> 00:52:06,050
所以，當你運行一個命令在鍵盤上一樣的a.out

823
00:52:06,050 --> 00:52:09,110
你雙擊一個圖標在Mac OS或Windows，

824
00:52:09,110 --> 00:52:11,880
從您的硬盤驅動器程序被加載到RAM

825
00:52:11,880 --> 00:52:16,330
它的屁股在您的計算機的RAM的頂部，可以這麼說。

826
00:52:16,330 --> 00:52:20,450
同時，為您的程序開始運行，並主要被調用

827
00:52:20,450 --> 00:52:23,640
在你的程序寫或寫的程序微軟和蘋果，

828
00:52:23,640 --> 00:52:27,860
任何局部變量結束了在那裡降落的底部，您的計算機的內存中。

829
00:52:27,860 --> 00:52:33,230
但是，如果本身有變量或參數主要調用另一個函數，他們結束了在它的上面。

830
00:52:33,230 --> 00:52:36,680
如果該函數調用的東西，他們結束了在它上面，在它上面，在它的上面。

831
00:52:36,680 --> 00:52:41,460
>> 只有一次函數完成執行，托盤堆疊，可以這麼說，

832
00:52:41,460 --> 00:52:43,240
開始越來越低。

833
00:52:43,240 --> 00:52:48,250
這是什麼話，概括地說，解釋了為什麼當你調用立方體

834
00:52:48,250 --> 00:52:51,550
還是你打的增量，你在副本的價值傳遞。

835
00:52:51,550 --> 00:52:55,520
是什麼意思形象地是，你從字面上寫數字1

836
00:52:55,520 --> 00:53:00,460
的存儲器的另一部分中，改變一個1至2中的情況下，增量

837
00:53:00,460 --> 00:53:04,820
或8在多維數據集的情況下，然後投擲該內存

838
00:53:04,820 --> 00:53:09,140
只要增量或多維數據集函數返回。問題。

839
00:53:09,140 --> 00:53:12,900
[學生]：全局變量存儲在哪裡？

840
00:53:12,900 --> 00:53:18,100
現稱為初始化的數據或者未初始化的數據都存儲在全局變量，

841
00:53:18,100 --> 00:53:21,920
區別在於，如果你有一個全局變量，並為它指定一個值就

842
00:53:21,920 --> 00:53:24,640
與等號，它結束了在頂部有，

843
00:53:24,640 --> 00:53:29,200
，如果你只是說詮釋x;沒有價值，最終小幅低RAM

844
00:53:29,200 --> 00:53:31,710
簡單的約定。

845
00:53:31,710 --> 00:53:34,940
其他問題嗎？好的。

846
00:53:34,940 --> 00:53:37,340
因此，這幅畫會回來的，因為我們獲得更強大

847
00:53:37,340 --> 00:53:39,170
我們能做些什麼與電腦，

848
00:53:39,170 --> 00:53:42,720
但現在，讓我們有一個簡短的介紹了密碼學，

849
00:53:42,720 --> 00:53:46,080
特定類型的加密技術並沒有解決所有的世界問題的

850
00:53:46,080 --> 00:53:47,720
但不解決其中的一些。

851
00:53:47,720 --> 00:53:51,700
在這種情況下，在這裡，我們有一些所謂的密鑰加密。

852
00:53:51,700 --> 00:53:56,410
密鑰加密，顧名思義，源於它從一個秘密的安全。

853
00:53:56,410 --> 00:54:00,690
>> 例如，如果你是在小學和你是通過一個小秘密情書

854
00:54:00,690 --> 00:54:04,850
男孩或女孩，你被粉碎，如果你想通過貫穿全場的注意，

855
00:54:04,850 --> 00:54:08,380
你可能不會寫英語中的註釋，或任何你的母語是。

856
00:54:08,380 --> 00:54:13,340
相反，你可能會對其進行加密，或者您可能只是給他們一個文本消息，這些天。

857
00:54:13,340 --> 00:54:15,460
但你實際上可能會通過他們在教室。

858
00:54:15,460 --> 00:54:18,700
而要做到這以這樣的方式安全地，您的朋友和老師

859
00:54:18,700 --> 00:54:22,650
不知道你寫的東西，你可能會想出一個相當簡單的算法，

860
00:54:22,650 --> 00:54:25,920
年輕，當然，你可能只是爭奪的話。

861
00:54:25,920 --> 00:54:28,130
因此，而不是寫一個你可能會寫，

862
00:54:28,130 --> 00:54:30,220
而不是B，你可能會寫，

863
00:54:30,220 --> 00:54:32,140
，而不是C，你可能會寫D，等等。

864
00:54:32,140 --> 00:54:34,360
或者，你能想出一個更複雜的翻譯

865
00:54:34,360 --> 00:54:36,720
不同的字母字母。

866
00:54:36,720 --> 00:54:39,740
但美中不足的是男孩還是女孩，你發送此說明

867
00:54:39,740 --> 00:54:45,020
需要知道的東西，這是什麼，很明顯嗎？ >> [學生]：您所發送的。

868
00:54:45,020 --> 00:54:49,720
你的秘訣是什麼，喜歡什麼是A和B的和C和D的之間的映射。

869
00:54:49,720 --> 00:54:54,650
難道僅僅是加1，每個字母從A到B，從B到C的嗎？

870
00:54:54,650 --> 00:54:56,670
它是比這更複雜嗎？

871
00:54:56,670 --> 00:55:01,540
>> 所以，你和你的美眉需要有這樣的秘密信息，

872
00:55:01,540 --> 00:55:03,190
但有一個catch-22在這裡種。

873
00:55:03,190 --> 00:55:06,830
如果這是第一次，你通過類，這封情書

874
00:55:06,830 --> 00:55:10,720
的是男孩還是女孩是如何知道的秘密，即使是嗎？

875
00:55:10,720 --> 00:55:13,930
所以密鑰加密並不能解決世界上所有的問題，

876
00:55:13,930 --> 00:55:16,320
有實際上是一個關係在這裡，我們再回過頭來朝學期的結束。

877
00:55:16,320 --> 00:55:25,110
同樣我們大多數人不知道別人的作品，例如，在Amazon.com，

878
00:55:25,110 --> 00:55:28,190
，但我們很多人可能買的東西在Amazon.com，

879
00:55:28,190 --> 00:55:31,990
我們一直被教導要承擔這些電子商務交易的安全性。

880
00:55:31,990 --> 00:55:36,470
HTTPS URL可能說，有可能是愚蠢的小掛鎖圖標的地方，

881
00:55:36,470 --> 00:55:39,930
有某種形式的加密技術保護您的信用卡信息

882
00:55:39,930 --> 00:55:42,160
你和亞馬遜（Amazon.com）之間。

883
00:55:42,160 --> 00:55:45,430
但如果密碼學需要知道一些秘密

884
00:55:45,430 --> 00:55:48,620
，但我不知道在亞馬遜的人，我當然沒有安排什麼樣的秘密

885
00:55:48,620 --> 00:55:52,710
與亞馬遜的人，怎麼會是我的電腦或瀏覽器這樣做嗎？

886
00:55:52,710 --> 00:55:55,720
事實證明，有其他類型的加密技術完全解決這個問題。

887
00:55:55,720 --> 00:55:57,670
但是今天，我們將重點放在簡單的一

888
00:55:57,670 --> 00:56:00,290
在這裡，你可以安排提前知道一些秘密

889
00:56:00,290 --> 00:56:03,760
如+1或一些A和B之間的映射。

890
00:56:03,760 --> 00:56:05,840
和加密過程一般涉及這一點。

891
00:56:05,840 --> 00:56:08,620
你有一些簡單的文字，描繪在左，

892
00:56:08,620 --> 00:56:12,930
你運行它通過某種算法或過程進行加密 - 

893
00:56:12,930 --> 00:56:15,100
也許這只是一個變成B，B變成C  - 

894
00:56:15,100 --> 00:56:17,490
那麼你最終的密文。

895
00:56:17,490 --> 00:56:20,380
同時，一旦你的美眉接收這個秘密紙條，

896
00:56:20,380 --> 00:56:24,200
他或她，然後將其解密一般扭轉這一算法

897
00:56:24,200 --> 00:56:27,190
這樣才能得到純文本。

898
00:56:27,190 --> 00:56:28,960
有物理的化身。

899
00:56:28,960 --> 00:56:31,680
>> 舉例來說，這是一個小秘密的解碼器環，

900
00:56:31,680 --> 00:56:35,110
這是在這個意義上，在這裡兩個錶盤的環。

901
00:56:35,110 --> 00:56:38,490
在這件事情的外週，有字母A到Z，

902
00:56:38,490 --> 00:56:40,340
雖然他們在隨機的順序，

903
00:56:40,340 --> 00:56:42,880
在裡面，其實有一些數字

904
00:56:42,880 --> 00:56:46,620
這樣，這個戒指，你可以種翻在外面，但不是內

905
00:56:46,620 --> 00:56:49,140
在排隊的數字與字母。

906
00:56:49,140 --> 00:56:53,020
從一部電影叫聖誕故事，你會看到那個小拉爾夫

907
00:56:53,020 --> 00:56:58,000
要弄清楚什麼小孤兒安妮的秘密消息是他是如此渴望

908
00:56:58,000 --> 00:57:02,570
已溝通，我認為，在麥片盒上的數字信息的形式

909
00:57:02,570 --> 00:57:07,220
你有積聚的麥片盒中附帶的小卡片，

910
00:57:07,220 --> 00:57:09,770
你不得不將它們郵寄中，你必須回到秘密的解碼器環

911
00:57:09,770 --> 00:57:13,910
所以，你終於可以弄清楚什麼是字母和數字之間的映射

912
00:57:13,910 --> 00:57:15,550
或字母和字母。

913
00:57:15,550 --> 00:57:19,520
如何在一台計算機實施或代表這樣的事情，我們可以去嗎？

914
00:57:19,520 --> 00:57:22,560
我們需要一種方式表達自己一點更靈活

915
00:57:22,560 --> 00:57:25,080
因此，我們的變量不允許的。

916
00:57:25,080 --> 00:57:29,000
我們已經有整數，我們有個字符，我們已經有花車和雙打和其他幾個人，

917
00:57:29,000 --> 00:57:34,200
但這些都是個人的內存並不真正允許我們表達的東西

918
00:57:34,200 --> 00:57:36,440
如單詞和句子和短語。

919
00:57:36,440 --> 00:57:38,630
事實上，我們稱這樣的事情串，

920
00:57:38,630 --> 00:57:42,660
但我們保證這是真的只是一個簡化的CS50庫中

921
00:57:42,660 --> 00:57:45,540
我們打算剝離。

922
00:57:45,540 --> 00:57:47,500
讓我們開始做，在這裡。

923
00:57:47,500 --> 00:57:49,840
讓我繼續前進，打開一個文件 - 

924
00:57:49,840 --> 00:57:54,100
所有這些文件，像往常一樣，在線 - 所謂的array.c的

925
00:57:54,100 --> 00:57:58,960
要解決的問題無關字符串，但在這裡描繪了

926
00:57:58,960 --> 00:58:01,520
怎麼樣，我們可能會使用稱為數組的東西。

927
00:58:01,520 --> 00:58:04,050
>> 數組是一種數據類型。

928
00:58:04,050 --> 00:58:10,730
這是一個類型的變量有多個較小的數據類型，它裡面的各種

929
00:58:10,730 --> 00:58:12,680
背靠背背靠背。

930
00:58:12,680 --> 00:58:16,980
因此，舉例來說，如果我們想要寫一個小程序，讓你的測驗平均

931
00:58:16,980 --> 00:58:19,780
像50，有2個測驗為一療程，

932
00:58:19,780 --> 00:58:23,450
你可以很容易地編寫這個程序，即使在上週的一些材料

933
00:58:23,450 --> 00:58:28,830
通過調用getInt和一對夫婦的變量：quiz1，quiz2。

934
00:58:28,830 --> 00:58:30,550
這是很簡單的。

935
00:58:30,550 --> 00:58:33,500
這也許是10，20行的代碼最大的實施方案

936
00:58:33,500 --> 00:58:38,940
，要求用戶為2個測驗分數，然後計算它們的平均

937
00:58:38,940 --> 00:58:42,020
通過將它們添加在一起，除以2，然後打印結果。

938
00:58:42,020 --> 00:58:46,400
我們或許可以做到這一點很容易現在後一些的分鐘數。

939
00:58:46,400 --> 00:58:49,450
但問題是，假設50 3測驗或4。

940
00:58:49,450 --> 00:58:52,830
假設你想使用相同的程序為一類，每週測驗。

941
00:58:52,830 --> 00:58:55,100
想想一個類時，每週測驗。

942
00:58:55,100 --> 00:58:58,840
如果在一個學期有16週了，現在你有16個變量：

943
00:58:58,840 --> 00:59:03,030
quiz1，詮釋quiz2，詮釋第quiz3，詮釋quiz4。

944
00:59:03,030 --> 00:59:06,870
只要你開始看到這種冗餘，複製和粘貼的代碼，

945
00:59:06,870 --> 00:59:09,810
它應該開始讓你希望有一個更好的辦法。

946
00:59:09,810 --> 00:59:13,610
幸運的是，因為數組。因此，讓我們做到這一點。

947
00:59:13,610 --> 00:59:16,700
首先，讓我介紹一個非常簡單的事情，我們到目前為止還沒有使用，

948
00:59:16,700 --> 00:59:18,820
但偶爾你會看到它的代碼。

949
00:59:18,820 --> 00:59:21,270
>> 這就是通常被稱為一個常數。

950
00:59:21,270 --> 00:59:24,410
所以在這個意義上，這個值不會改變，它是一個常數。

951
00:59:24,410 --> 00:59:26,450
人的慣例，當創建一個常數

952
00:59:26,450 --> 00:59:30,420
是全部使用大寫字母，使其真正站出來，在你的代碼，

953
00:59:30,420 --> 00:59:34,270
特殊的關鍵字，您使用的C＃定義。

954
00:59:34,270 --> 00:59:39,970
所以我們說的＃define，然後一個空格，然後這個詞，您要使用的常量的名稱

955
00:59:39,970 --> 00:59:41,730
，然後該值的常數。

956
00:59:41,730 --> 00:59:44,710
請注意，這是一個變量分配的東西不同。

957
00:59:44,710 --> 00:59:46,430
有沒有等號，別無分號。

958
00:59:46,430 --> 00:59:49,140
這是通常被稱為一個預處理器指令，

959
00:59:49,140 --> 00:59:50,840
但更多的是另一個時間。

960
00:59:50,840 --> 00:59:56,350
就目前而言，這將創建一個不變的值，稱為測驗

961
00:59:56,350 --> 00:59:58,290
其實際的數值為2。

962
00:59:58,290 --> 01:00:02,180
因此，任何地方，你看到測驗，測驗，測驗整個文件，

963
01:00:02,180 --> 01:00:04,230
這只是數字2。

964
01:00:04,230 --> 01:00:06,550
如果我看主要現在，讓我們來看看它是如何工作的。

965
01:00:06,550 --> 01:00:09,770
首先，它看起來有點神秘，但它的所有東西，從第1週。

966
01:00:09,770 --> 01:00:12,210
詢問用戶的等級。如何才能做到這一點呢？

967
01:00:12,210 --> 01:00:17,350
第22行 - 這是真正的多汁的一部分 - 我聲明了一個浮動

968
01:00:17,350 --> 01:00:23,240
但不只是一個單一的浮動。我聲明，而是一個浮點值數組。

969
01:00:23,240 --> 01:00:27,700
該變量將被稱為等級，此處所暗示的，

970
01:00:27,700 --> 01:00:31,420
但唯一的一塊新的語法，那麼這些方括號。

971
01:00:31,420 --> 01:00:37,280
事實上，我已經說過了浮動等級，然後打開支架，然後一個數字 - 

972
01:00:37,280 --> 01:00:40,980
請注意，如果這是一個常數，這僅僅是像我們這樣做 - 

973
01:00:40,980 --> 01:00:46,840
這意味著，“嘿，電腦，給我2漂浮，讓我們共同給他們打電話等級。”

974
01:00:46,840 --> 01:00:51,780
>> 這是更繁瑣的過程是這樣的：浮法級1;

975
01:00:51,780 --> 01:00:54,580
浮動grade2等等。

976
01:00:54,580 --> 01:00:58,310
因此，一個陣列，使我們能夠實現這個想法，但要少得多亂七八糟，

977
01:00:58,310 --> 01:01:04,560
在這樣一種方式，我們可以寫一行代碼，而不是，比方說，16為期16週的學期。

978
01:01:04,560 --> 01:01:09,060
我不想硬編碼到2，因為如果你覺得這個邏輯，

979
01:01:09,060 --> 01:01:12,560
假設明年CS50更改為3，而不是測驗

980
01:01:12,560 --> 01:01:15,010
我有2號，在這裡，我有2號

981
01:01:15,010 --> 01:01:17,210
我有這裡的數量2，數字2這裡。

982
01:01:17,210 --> 01:01:19,890
它變得非常乏味，很容易搞砸了

983
01:01:19,890 --> 01:01:26,550
意外更改值設置為3，錯過了一些其他值2。

984
01:01:26,550 --> 01:01:30,660
所以我要這個距離，而不是抽象的和使用這個常數，

985
01:01:30,660 --> 01:01:32,520
正如它的名字所暗示的，永遠不會改變。

986
01:01:32,520 --> 01:01:35,870
現在，無論我們有不同的測驗今年年底或明年，

987
01:01:35,870 --> 01:01:39,380
我只需要改變它在一個地方，在這裡頂部。

988
01:01:39,380 --> 01:01:41,230
所以這是一個常數。

989
01:01:41,230 --> 01:01:47,100
同時，新概念的特點是一個數組。

990
01:01:47,100 --> 01:01:55,030
因此，在方括號給我這麼多的花車，讓我共同呼籲他們的成績。

991
01:01:55,030 --> 01:01:56,720
所以，現在讓我們來看看我會做什麼。

992
01:01:56,720 --> 01:01:59,220
在這裡，在第24行是一個for循環的開始。

993
01:01:59,220 --> 01:02:03,380
>> 這實在是沒有任何幻想。這只是使用測驗，而不是硬編碼的數字。

994
01:02:03,380 --> 01:02:06,740
但也有是沒有從上週智力有不同的。

995
01:02:06,740 --> 01:02:11,650
這僅僅是printf的，因此我們知道printf（“測驗＃％d的％d”）

996
01:02:11,650 --> 01:02:16,670
因為我只是想打印出來給我測驗第1號和2 2。

997
01:02:16,670 --> 01:02:18,480
因此，這是一個純粹審美的東西。

998
01:02:18,480 --> 01:02:21,000
但是，現在最有趣的部分是在第27行。

999
01:02:21,000 --> 01:02:27,840
為了填補的兩個佔位符，一個浮點值，

1000
01:02:27,840 --> 01:02:29,640
你再使用方括號。

1001
01:02:29,640 --> 01:02:35,170
在這種情況下，我使用的是我，因為for循環已開始與我等於什麼樣的價值，顯然是嗎？

1002
01:02:35,170 --> 01:02:36,670
[學生] 0。 >> [馬蘭] 0。

1003
01:02:36,670 --> 01:02:40,990
因此，在這個循環的第一次迭代，這是我寫的代碼，

1004
01:02:40,990 --> 01:02:46,310
但在這個循環中的第二次迭代，這是我寫在我的代碼。

1005
01:02:46,310 --> 01:02:49,970
但事實上，我使用一個變量是完美的，因為顧名思義，

1006
01:02:49,970 --> 01:02:52,600
它改變它的值在每次迭代，

1007
01:02:52,600 --> 01:02:55,900
所以我填充這個數組一個地方的時間。

1008
01:02:55,900 --> 01:02:57,380
陣列看看這是什麼樣的呢？

1009
01:02:57,380 --> 01:03:01,570
我畫的超級簡單的屏幕上的矩形前的原因是因為這個原因。

1010
01:03:01,570 --> 01:03:05,590
數組是另一塊內存的內存塊

1011
01:03:05,590 --> 01:03:08,570
其次由另一個的內存塊，等等。

1012
01:03:08,570 --> 01:03:13,120
所以，如果我的數組大小​​為2，在這種情況下，在這裡，我會做

1013
01:03:13,120 --> 01:03:20,200
通過輸入我的測驗分數，喜歡上了這裡 - 我就這一個，然後我得到了99這個 - 

1014
01:03:20,200 --> 01:03:24,970
那麼這個內存可能甚至沒有被使用，因為我只要求電腦

1015
01:03:24,970 --> 01:03:26,840
數組大小為2。

1016
01:03:26,840 --> 01:03:28,600
這些廣場仍然存在，對嗎？

1017
01:03:28,600 --> 01:03:32,670
你還有2 GB的RAM，即使你只要求2漂浮。

1018
01:03:32,670 --> 01:03:36,840
因此，陣列背後的想法是，計算機只需要一個內存塊的

1019
01:03:36,840 --> 01:03:41,340
然後分給更小的碎片背靠背背靠背。

1020
01:03:41,340 --> 01:03:43,310
因此，這是所有的數組。

1021
01:03:43,310 --> 01:03:47,350
>> 這是一個連續的塊的內存裡面的，你可以把事情。

1022
01:03:47,350 --> 01:03:50,700
發生這種情況，然後做一些無聊的算術。

1023
01:03:50,700 --> 01:03:54,640
如果我向下滾動在這裡，這是我然後遍歷數組中。

1024
01:03:54,640 --> 01:03:58,020
我拿出所有的數組中的值的總和，

1025
01:03:58,020 --> 01:04:02,470
然後，我在這裡使用ROUND函數的總和除以測驗。

1026
01:04:02,470 --> 01:04:06,320
但是，讓我揮揮手，作為足夠的算術現在的排序。

1027
01:04:06,320 --> 01:04:08,370
但是，所有為我做的最終計算平均值。

1028
01:04:08,370 --> 01:04:13,580
因此，第一次測驗加第二個測驗除以2，然後把它打印出來作為一個int。

1029
01:04:13,580 --> 01:04:17,280
但現在，讓我們叫字符串轉換到一個不同的例子，

1030
01:04:17,280 --> 01:04:20,700
它描繪了一個類似的畫面，但使用​​字符串。

1031
01:04:20,700 --> 01:04:23,940
讓我繼續前進，簡化這只是一個瞬間。

1032
01:04:23,940 --> 01:04:27,090
現在原諒縮進。

1033
01:04:27,090 --> 01:04:30,870
請注意，在這個例子中的第19行，我收到了來自用戶的字符串。

1034
01:04:30,870 --> 01:04:34,640
但是請注意，我在22日線下做。

1035
01:04:34,640 --> 01:04:41,250
實際上，我遍歷從我 - 這是一個新的絕招 -  STRLEN，字符串的長度。

1036
01:04:41,250 --> 01:04:44,880
這是一個與C的功能，如果你傳遞一個字符串，

1037
01:04:44,880 --> 01:04:47,730
它會告訴你如何在該字符串中的字符數。這就是全部。

1038
01:04:47,730 --> 01:04:51,550
而事實上，它是strlen的，而不是字符串的長度，僅僅是因為它更簡潔。

1039
01:04:51,550 --> 01:04:55,100
30年前，人們喜歡寫東西盡量簡潔，

1040
01:04:55,100 --> 01:04:57,630
所以在這裡，我們已經把該公約。

1041
01:04:57,630 --> 01:05:00,660
我+ +只是意味著我在每次迭代中增加。

1042
01:05:00,660 --> 01:05:02,990
而現在注意到這一點，這是非常有趣的。

1043
01:05:02,990 --> 01:05:09,180
在第24行，我說，“電腦，給我一個字符，8位，並稱之為C”。

1044
01:05:09,180 --> 01:05:12,630
不過這到底是上右手邊說？

1045
01:05:13,490 --> 01:05:16,530
在英語中，什麼代表什麼呢？

1046
01:05:16,530 --> 01:05:18,730
[學生]數組中的第一個字符。

1047
01:05:18,730 --> 01:05:20,790
沒錯。給我的第一個字符數組中的。

1048
01:05:20,790 --> 01:05:24,090
或者，更一般地，給我在數組中的第i個字符。

1049
01:05:24,090 --> 01:05:26,100
而意識到這一點是很重要的，現在的計算機科學家，

1050
01:05:26,100 --> 01:05:27,890
我們實際上是從0開始計數。

1051
01:05:27,890 --> 01:05:29,720
>> 您沒有自由裁量權，現在就開始這樣做。

1052
01:05:29,720 --> 01:05:34,160
現在，你必須按照電腦的期望的行為，從0數

1053
01:05:34,160 --> 01:05:38,180
因為[0]將是第一個字符在字符串中，

1054
01:05:38,180 --> 01:05:42,150
[1]將是第二個，[2]，將是第三個，等等。

1055
01:05:42,150 --> 01:05:49,720
所以這個程序，如果我編譯它，這又是字符串，所以字符串，

1056
01:05:49,720 --> 01:05:54,670
現在我已經在我的終端窗口中執行字符串。

1057
01:05:54,670 --> 01:05:58,330
它在等待輸入，所以我要輸入大衛，輸入，

1058
01:05:58,330 --> 01:06:02,540
現在它打印通知大衛在不同線路上，因為我在做什麼。

1059
01:06:02,540 --> 01:06:05,820
我一次打印一個字符。

1060
01:06:05,820 --> 01:06:10,100
我們不會詳細進入今天這個，但我刪除剛才在這裡檢查。

1061
01:06:10,100 --> 01:06:15,480
事實證明，如果用戶出現異常的，對抗性的，或只是困惑，

1062
01:06:15,480 --> 01:06:20,210
實際上，你可以不給一些長度字符串。

1063
01:06:20,210 --> 01:06:22,860
如果你按錯鍵盤上的鍵，你可以給沒有在所有的字符串，

1064
01:06:22,860 --> 01:06:26,950
如果你是惡意的，你可以嘗試將其粘貼在一千兆字節的一篇文章的價值

1065
01:06:26,950 --> 01:06:29,290
來填補這個字符串，如果計算機運行的內存，

1066
01:06:29,290 --> 01:06:32,710
事實證明，我們要獲得這個特殊的值NULL。

1067
01:06:32,710 --> 01:06:35,580
因此，就目前而言，只知道有這個特殊的值NULL

1068
01:06:35,580 --> 01:06:39,580
這將允許我們來檢查時，我們的記憶，在其他的事情。

1069
01:06:39,580 --> 01:06:45,630
但是，如果我現在打開字符串，請注意區別就在這裡。

1070
01:06:45,630 --> 01:06:48,210
看到一個與字符串的區別就在這裡。

1071
01:06:48,210 --> 01:06:51,340
對於字符串，這個for循環是一個有點不同。

1072
01:06:51,340 --> 01:06:55,010
>> 讓我刪除的NULL，這樣我們就可以談論其他時間的。

1073
01:06:55,010 --> 01:06:57,800
的for循環有什麼不同呢？

1074
01:06:59,620 --> 01:07:01,670
我可以回到前面的例子。

1075
01:07:01,670 --> 01:07:08,580
所以這是第2版，這是第1版。 1，2。

1076
01:07:08,580 --> 01:07:11,980
1，2。

1077
01:07:13,520 --> 01:07:16,660
strlen的呼叫是在哪裡呢？

1078
01:07:16,660 --> 01:07:18,860
這是在for循環的第一部分。

1079
01:07:18,860 --> 01:07:21,830
任何想法，為什麼我這樣做？是啊。

1080
01:07:21,830 --> 01:07:24,560
[學生]：所以，你不必每一次調用該函數。

1081
01:07:24,560 --> 01:07:26,440
[馬蘭所以我們不每一次調用該函數。沒錯。

1082
01:07:26,440 --> 01:07:28,300
回想一下，他們是超級簡單的for循環

1083
01:07:28,300 --> 01:07:31,770
一旦你明白，這是初始化，條件，和更新。

1084
01:07:31,770 --> 01:07:34,750
的問題是，在條件上發生的每一個循環的迭代。

1085
01:07:34,750 --> 01:07:40,010
因此，在這個例子中，什麼是壞的事實，這是我的病情嗎？

1086
01:07:40,010 --> 01:07:41,830
[學生]你調用strlen。

1087
01:07:41,830 --> 01:07:44,340
[馬蘭]你調用strlen再，再而三。

1088
01:07:44,340 --> 01:07:47,410
但是，一旦我輸入的大衛，該字符串的長度是5，

1089
01:07:47,410 --> 01:07:49,650
它不會改變在每次迭代循環

1090
01:07:49,650 --> 01:07:51,670
因為該字符串是D-A-V-I-D。

1091
01:07:51,670 --> 01:07:55,320
因此，這將成為一個越來越重要思想是一個提示

1092
01:07:55,320 --> 01:08:00,410
被稱為一個設計決定，只是不要讓計算機做不必要的工作。

1093
01:08:00,410 --> 01:08:03,920
>> 正如先睹為快的pset2，pset2的標準版

1094
01:08:03,920 --> 01:08:07,030
會向你挑戰，真正實現一些數字的密碼，

1095
01:08:07,030 --> 01:08:10,410
一定數量的加密算法，這樣就可以同時加密

1096
01:08:10,410 --> 01:08:13,840
和解密的秘密信息非常相似，拉爾夫解碼。

1097
01:08:13,840 --> 01:08:16,810
在黑客版pset2，我們要去遠一點。

1098
01:08:16,810 --> 01:08:19,649
我們要交給你一個文件從一個實際的計算機系統

1099
01:08:19,649 --> 01:08:23,479
包含一大堆的用戶名和加密的密碼，

1100
01:08:23,479 --> 01:08:26,939
的黑客版所面臨的挑戰將是破解這些密碼

1101
01:08:26,939 --> 01:08:33,200
並找出產生這些密碼加密或使用的是什麼秘密。

1102
01:08:33,200 --> 01:08:36,109
我們要做到這一點，採用了全新的功能，在這裡的C

1103
01:08:36,109 --> 01:08:40,630
我會給你只是一個演示被稱為命令行參數。

1104
01:08:40,630 --> 01:08:44,229
事實證明，你們有些人可能已經看到在部分或教科書中，

1105
01:08:44,229 --> 01:08:48,260
主並不總是括號中是無效的。

1106
01:08:48,260 --> 01:08:52,430
事實證明，主也可以這樣寫，有兩個參數，

1107
01:08:52,430 --> 01:08:56,870
argc和argv，argc是單詞的數量

1108
01:08:56,870 --> 01:09:00,020
您鍵入程序的名稱後，在命令行上

1109
01:09:00,020 --> 01:09:03,420
而argv是實際的話。

1110
01:09:03,420 --> 01:09:07,540
的方括號，顯然，argv是一個數組。

1111
01:09:07,540 --> 01:09:12,210
這將是一個字符串後的字符串後，內存中的字符串。

1112
01:09:12,210 --> 01:09:16,010
>> 那麼，我們將能夠做的pset 2這樣的事情。

1113
01:09:16,010 --> 01:09:21,350
，如果我做argv1的，這是一個例子，我們會回來（星期一），並運行它，

1114
01:09:21,350 --> 01:09:23,370
注意，它似乎並沒有做任何事情。

1115
01:09:23,370 --> 01:09:25,490
它只是打印出自己的名字。

1116
01:09:25,490 --> 01:09:31,479
但是，如果我說再見類，請注意，這個方案顯然迭代

1117
01:09:31,479 --> 01:09:35,479
在每一個的話，在提示符下輸入。

1118
01:09:35,479 --> 01:09:41,630
和手段，我們將有機會獲得的的話用戶已鍵入的

1119
01:09:41,630 --> 01:09:49,160
是通過改變主要詮釋的主要（無效）從本週末開始INT主（ARGC，ARGV）

1120
01:09:49,160 --> 01:09:52,050
從而將誕生的命令行參數。

1121
01:09:52,050 --> 01:09:57,100
而一旦你得到真正的成熟，你就可以寫真正的迷幻程序

1122
01:09:57,100 --> 01:09:59,610
像這樣的人在這裡，這超出

1123
01:09:59,610 --> 01:10:03,940
我們已經做了一些功能迄今為止，所有功能相當強大。

1124
01:10:03,940 --> 01:10:08,950
>> 因此，我們將離開這個在屏幕上，我們將看到你在週一。

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]