1
00:00:00,000 --> 00:00:03,395
>> [音樂播放]

2
00:00:03,395 --> 00:00:11,031

3
00:00:11,031 --> 00:00:13,280
DAVID J.馬蘭：這就像
一個新生研討會今天。

4
00:00:13,280 --> 00:00:14,060
確定。

5
00:00:14,060 --> 00:00:15,024
因此大雨了。

6
00:00:15,024 --> 00:00:17,690
這往往發生在星期三，
但所有的更多機會

7
00:00:17,690 --> 00:00:18,700
對於今天的問題。

8
00:00:18,700 --> 00:00:22,210
因此，讓我們開始實際
有一會兒就好了這部電影。

9
00:00:22,210 --> 00:00:24,560
但是，我們將隆重啟動一如既往。

10
00:00:24,560 --> 00:00:28,000
>> 這是CS50，這
是4週結束。

11
00:00:28,000 --> 00:00:30,820
所以，如果你曾經看過
電視或電影，其中

12
00:00:30,820 --> 00:00:34,690
有一些計算機專家，
警察，或者FBI，或者一些機構

13
00:00:34,690 --> 00:00:36,930
試圖捕捉一些
對手，嗯，你已經

14
00:00:36,930 --> 00:00:40,850
大概聽過這句話“提升”
因此該技術人員不知何故

15
00:00:40,850 --> 00:00:44,750
神奇地放大無限
遠遠的看到歹徒

16
00:00:44,750 --> 00:00:48,640
身份或車牌號
在鏡子連微光

17
00:00:48,640 --> 00:00:50,390
或某人的眼睛閃閃發光。

18
00:00:50,390 --> 00:00:55,196
因此，我們確實，讓我們一起來看看
一些這樣的場景從好萊塢。

19
00:00:55,196 --> 00:00:55,862
[視頻回放]

20
00:00:55,862 --> 00:00:59,243
 - 確定了，現在讓我們好好看看你。

21
00:00:59,243 --> 00:01:06,488

22
00:01:06,488 --> 00:01:07,415
>> -hold它。

23
00:01:07,415 --> 00:01:08,267
運行該回來了。

24
00:01:08,267 --> 00:01:09,121
>> -Wait一分鐘。

25
00:01:09,121 --> 00:01:11,300
向右走。

26
00:01:11,300 --> 00:01:12,209
>> -there，凍結。

27
00:01:12,209 --> 00:01:12,750
 - 全屏幕。

28
00:01:12,750 --> 00:01:13,558
 - 確定，凍結。

29
00:01:13,558 --> 00:01:14,820
向上擰得過緊上，你會？

30
00:01:14,820 --> 00:01:16,530
 - 矢量在上
小伙的後輪。

31
00:01:16,530 --> 00:01:19,400
-zoom在這裡在這一點上。

32
00:01:19,400 --> 00:01:22,846
 - 隨著合適的設備，圖像
可以擴大和激化。

33
00:01:22,846 --> 00:01:24,065
 - 什麼事？

34
00:01:24,065 --> 00:01:25,600
 - 它是一個提升計劃。

35
00:01:25,600 --> 00:01:26,860
 - 你能清楚地表明了沒有？

36
00:01:26,860 --> 00:01:27,890
 - 我不知道。

37
00:01:27,890 --> 00:01:29,050
讓我們增強了。

38
00:01:29,050 --> 00:01:31,575
>>  - 增強部分A6。

39
00:01:31,575 --> 00:01:33,642
>> -I增強了細節，
而且 - 我認為有

40
00:01:33,642 --> 00:01:35,433
足以提升，
它釋放到我的屏幕。

41
00:01:35,433 --> 00:01:37,080
-I增強了她的眼睛反射。

42
00:01:37,080 --> 00:01:38,830
>>  - 讓我們通過運行此
視頻增強。

43
00:01:38,830 --> 00:01:40,100
-Edgar，你可以加強這方面的？

44
00:01:40,100 --> 00:01:41,875
>> -hang上。

45
00:01:41,875 --> 00:01:44,010
>> -I've這方面的工作思考。

46
00:01:44,010 --> 00:01:44,995
>> -Someone的反思。

47
00:01:44,995 --> 00:01:45,495
 - 反射。

48
00:01:45,495 --> 00:01:47,399
 - 存在就是男人的臉的反映。

49
00:01:47,399 --> 00:01:48,065
-The反映。

50
00:01:48,065 --> 00:01:48,981
 - 存在的一種反映。

51
00:01:48,981 --> 00:01:50,600
 - 放大上鏡。

52
00:01:50,600 --> 00:01:52,712
 - 你可以看到一個反映。

53
00:01:52,712 --> 00:01:54,350
 - 你能在這裡提升形象？

54
00:01:54,350 --> 00:01:55,370
 - 你能提高他在這裡？

55
00:01:55,370 --> 00:01:56,210
 - 你能提升呢？

56
00:01:56,210 --> 00:01:56,900
你能提升呢？

57
00:01:56,900 --> 00:01:57,870
>>  - 能，我們加強這方面的？

58
00:01:57,870 --> 00:01:58,717
>>  - 你能提升呢？

59
00:01:58,717 --> 00:02:00,050
-hold在第二，我會提高。

60
00:02:00,050 --> 00:02:00,924
 - 放大在門上。

61
00:02:00,924 --> 00:02:01,700
-Times 10。

62
00:02:01,700 --> 00:02:02,586
-zoom。

63
00:02:02,586 --> 00:02:03,490
-move研究。

64
00:02:03,490 --> 00:02:03,990
 - 更多。

65
00:02:03,990 --> 00:02:04,690
-Wait，停止。

66
00:02:04,690 --> 00:02:05,190
-Stop。

67
00:02:05,190 --> 00:02:05,970
-pause它。

68
00:02:05,970 --> 00:02:09,460
-rotate我們75度
繞垂直，請。

69
00:02:09,460 --> 00:02:10,962
-Stop。

70
00:02:10,962 --> 00:02:14,040
返回到部分
關於門，再一次。

71
00:02:14,040 --> 00:02:15,860
>> -Got圖像增強器，可以位圖？

72
00:02:15,860 --> 00:02:18,776
>>  - 嘿，也許我們可以使用普拉迪普
森方法來查看到窗口。

73
00:02:18,776 --> 00:02:20,372
 - 此軟件是最先進的。

74
00:02:20,372 --> 00:02:21,845
>> -The特徵值是關閉的。

75
00:02:21,845 --> 00:02:24,300
>>  - 隨著權
算法 - 組合

76
00:02:24,300 --> 00:02:26,755
>>  - 他的採取淘汰
算法，以一個新的水平，

77
00:02:26,755 --> 00:02:28,730
我可以用它們來
加強這方面的照片。

78
00:02:28,730 --> 00:02:31,286
>> -lock上和放大z軸。

79
00:02:31,286 --> 00:02:32,560
>>  - 增強。

80
00:02:32,560 --> 00:02:33,100
>>  - 增強。

81
00:02:33,100 --> 00:02:33,600
>>  - 增強。

82
00:02:33,600 --> 00:02:34,960
-freeze和提高。

83
00:02:34,960 --> 00:02:37,180
>> [結束播放]

84
00:02:37,180 --> 00:02:41,160
>> DAVID J.馬蘭：所有的權利，所以
所有這些實際上都是字。

85
00:02:41,160 --> 00:02:44,450
他們只是串聯繫在一起，
的方式，實際上不是明智的。

86
00:02:44,450 --> 00:02:48,400
而且，事實上，CS50和課程喜歡它
往往會毀了很多電視和電影

87
00:02:48,400 --> 00:02:48,900
為您服務。

88
00:02:48,900 --> 00:02:52,330
因為當這些電腦專家
在劍拔弩張關條款，並說

89
00:02:52,330 --> 00:02:56,860
喜歡花哨的東西
特徵向量，和z軸，

90
00:02:56,860 --> 00:02:59,572
和任何數量的其它的
其實更多的技術術語，

91
00:02:59,572 --> 00:03:02,030
他們真的只是串起
字聯太頻繁。

92
00:03:02,030 --> 00:03:05,020
那是我們的希望之一是，
作為療程服用的副作用

93
00:03:05,020 --> 00:03:08,245
像這樣，將更多的人在
世界上居然能權衡

94
00:03:08,245 --> 00:03:12,040
而只是非常輕微影響
質量和這些膜的準確性？

95
00:03:12,040 --> 00:03:14,350
>> 事實上，讓我們來看看現實。

96
00:03:14,350 --> 00:03:18,070
因此，這裡的工作人員合影
瑪利亞，我們的教學研究員之一。

97
00:03:18,070 --> 00:03:20,050
而假設她是
懷疑的東西。

98
00:03:20,050 --> 00:03:23,730
然而，還有一絲
一些的證據在她的眼睛，

99
00:03:23,730 --> 00:03:25,480
還是在她的眼鏡的反映。

100
00:03:25,480 --> 00:03:30,760
那麼，如果我們這樣做完全一樣的電影
建議，其中，我們縮放和“提升”，

101
00:03:30,760 --> 00:03:34,080
這是多少信息
在瑪麗的臉上

102
00:03:34,080 --> 00:03:36,795
當你拍攝圖像
與原始分辨率。

103
00:03:36,795 --> 00:03:39,120
>> 而且，事實上，你可以看到這些點。

104
00:03:39,120 --> 00:03:41,900
這些都是什麼
稱為像素，P-I-X-E-L-S，

105
00:03:41,900 --> 00:03:45,740
這僅僅是一個典型的方
這是一個圓點組成的圖像。

106
00:03:45,740 --> 00:03:49,200
而早在一天，居然連
今天與當今一些LED電視

107
00:03:49,200 --> 00:03:51,950
或液晶電視，如果你有
一個在你的房間或在家裡，

108
00:03:51,950 --> 00:03:55,100
如果你去了超級靠近它，
尤其是如果它是一個有些舊的電視，

109
00:03:55,100 --> 00:03:58,760
你甚至可能看到這些點
而這正是構成的圖像。

110
00:03:58,760 --> 00:04:00,980
>> 並且沒有更多的
信息莫過於此。

111
00:04:00,980 --> 00:04:05,400
我們可以“提高”，在感
平滑的事情了排序和

112
00:04:05,400 --> 00:04:09,040
推斷那種類型的，什麼
顏色應該是旁邊的Mary的眼睛

113
00:04:09,040 --> 00:04:10,910
因此，它實際上不是這樣的像素化。

114
00:04:10,910 --> 00:04:14,510
但是，如果我繼續放大，有
是個壞傢伙在她的眼睛。

115
00:04:14,510 --> 00:04:16,600
就像是所有的
我們掌握的。

116
00:04:16,600 --> 00:04:18,920
您不能創建
信息無中生有。

117
00:04:18,920 --> 00:04:20,790
這裡只有一個有限
位存在的數目。

118
00:04:20,790 --> 00:04:22,873
>> 因此，在習題集4，其中
你有一個機會

119
00:04:22,873 --> 00:04:24,580
用這種世界玩。

120
00:04:24,580 --> 00:04:27,610
在習題4，你會探索
圖形和取證的世界，

121
00:04:27,610 --> 00:04:30,870
實際上編寫代碼
即恢復丟失的圖像。

122
00:04:30,870 --> 00:04:33,510
你會寫代碼，
操縱現有圖像

123
00:04:33,510 --> 00:04:36,120
最終明白什麼是
怎麼回事引擎蓋下。

124
00:04:36,120 --> 00:04:38,540
>> 而且，事實證明，它實際上
不是所有的那麼複雜。

125
00:04:38,540 --> 00:04:41,320
舉例來說，如果我們想
代表笑臉的地方

126
00:04:41,320 --> 00:04:44,160
這些黑色像素，
或者這些黑點，

127
00:04:44,160 --> 00:04:47,230
好了，我們可以簡單地表示
他們作為一個真正的位圖。

128
00:04:47,230 --> 00:04:50,040
如果你曾經聽說過
表達位圖，也許

129
00:04:50,040 --> 00:04:52,330
現在開始做一個
一點更有意義的今天。

130
00:04:52,330 --> 00:04:53,580
>> 我們已經知道什麼是位。

131
00:04:53,580 --> 00:04:54,160
它是0或1。

132
00:04:54,160 --> 00:04:56,201
而地圖只是一些
像一張紙

133
00:04:56,201 --> 00:04:59,180
，讓你的方向，並具有
也許x和y坐標的網格。

134
00:04:59,180 --> 00:05:00,540
因此，這裡是一個位圖。

135
00:05:00,540 --> 00:05:03,680
它是比特的地圖
由此1是顯然

136
00:05:03,680 --> 00:05:07,857
要代表白色像素和
0是要表示黑像素。

137
00:05:07,857 --> 00:05:09,440
但是，我們當然可以翻轉它周圍。

138
00:05:09,440 --> 00:05:11,648
它並不真正的問題等等
只要我們是一致的。

139
00:05:11,648 --> 00:05:15,570
這裡是怎麼回事，在binary--內
計算機的存儲器中，或甚至內部

140
00:05:15,570 --> 00:05:18,160
在您的硬盤的文件
drive--你能存儲

141
00:05:18,160 --> 00:05:20,240
的笑臉圖像的簡單。

142
00:05:20,240 --> 00:05:23,990
但當然，我們是什麼，
缺乏這一形象？

143
00:05:23,990 --> 00:05:24,610
顏色，對不對？

144
00:05:24,610 --> 00:05:28,220
這是一個明顯的下一個步驟或
增強的色彩改善這一點。

145
00:05:28,220 --> 00:05:32,230
所以，不幸的是，只是一個單一
位，0或1，我們可以表示的顏色。

146
00:05:32,230 --> 00:05:36,100
這可能是紅色或藍色，或
黑或白，或綠，或粉紅色，

147
00:05:36,100 --> 00:05:37,420
或對顏色。

148
00:05:37,420 --> 00:05:40,860
但是，為了簡單起見，我們將
姑且黑色和白色。

149
00:05:40,860 --> 00:05:45,930
>> 那麼在邏輯上我們需要，如果我們
要實現彩色圖像中的？

150
00:05:45,930 --> 00:05:49,080
什麼是我們必須做的？

151
00:05:49,080 --> 00:05:51,900
就像如果這裡的限制因素
是與一位你只能

152
00:05:51,900 --> 00:05:55,977
表示兩個狀態，0或1，白
或黑色的，你有什麼想幹什麼？

153
00:05:55,977 --> 00:05:56,810
聽眾：更多的數據。

154
00:05:56,810 --> 00:05:58,813
DAVID J.馬蘭：更多位，
耶更多的數據，更多的比特。

155
00:05:58,813 --> 00:06:01,440
而且，事實上，這也正是如何
彩色圖像表示。

156
00:06:01,440 --> 00:06:05,120
而不是使用單個比特，一
0或1對於每個像素，每個點，

157
00:06:05,120 --> 00:06:06,170
你只需要使用多個。

158
00:06:06,170 --> 00:06:09,660
也許使用8，也許，更常見
使用24，而事實上，在習題集

159
00:06:09,660 --> 00:06:13,300
4，將你的文件播放
使用24位典型的格式。

160
00:06:13,300 --> 00:06:15,430
>> 但大多數你可能
熟悉的JPEG文件。

161
00:06:15,430 --> 00:06:17,460
如果你曾經拍攝
照片在手機上，

162
00:06:17,460 --> 00:06:20,360
或者上載或看到的東西
Facebook或Flickr的，任何數量

163
00:06:20,360 --> 00:06:24,882
照片為基礎的網站，你
之前可能看到一個JPEG圖像。

164
00:06:24,882 --> 00:06:27,840
而事實證明，這是文件
格式我們會在PSET 4使用，

165
00:06:27,840 --> 00:06:30,340
因此你要
要恢復圖像

166
00:06:30,340 --> 00:06:35,160
我不小心從已刪除
在攝像機損壞的存儲卡，

167
00:06:35,160 --> 00:06:35,800
如果你願意。

168
00:06:35,800 --> 00:06:38,490
>> 而事實證明，即使
JPEG是相當sophisticated--

169
00:06:38,490 --> 00:06:40,906
它的更複雜
比黑和白點

170
00:06:40,906 --> 00:06:44,480
我們看到剛才，因為有
實際上看中的算法，

171
00:06:44,480 --> 00:06:47,410
被用於壓縮為JPEG，所以
你可以有一個非常好的，

172
00:06:47,410 --> 00:06:49,832
高質量的圖像，但使用
相當少的比特。

173
00:06:49,832 --> 00:06:51,790
我們再回過頭來
不久壓縮。

174
00:06:51,790 --> 00:06:56,280
事實證明，在第一
在一個JPEG image--三個字節

175
00:06:56,280 --> 00:07:02,750
無論你所拍攝的照片
of--是值255，216，255。

176
00:07:02,750 --> 00:07:05,990
>> 換句話說，如果你只是
看到位的模式，

177
00:07:05,990 --> 00:07:09,180
這裡為三
字節或24比特合計，

178
00:07:09,180 --> 00:07:13,810
高概率，你可以推斷，
你看它這前三

179
00:07:13,810 --> 00:07:15,230
一個JPEG字節。

180
00:07:15,230 --> 00:07:18,040
這是什麼是已知的
為JPEG的簽名。

181
00:07:18,040 --> 00:07:20,540
大量的文件格式
在那裡往往開始

182
00:07:20,540 --> 00:07:23,735
用0和1的某些模式，
因此，Windows和Mac OS，和iOS，

183
00:07:23,735 --> 00:07:28,272
和Android知道什麼樣的文件，他們
是，除了所謂的文件

184
00:07:28,272 --> 00:07:29,730
擴展了很多文件都有。

185
00:07:29,730 --> 00:07:32,590
如果您的.jpg，這是
另一線索到計算機。

186
00:07:32,590 --> 00:07:35,310
>> 現在讓我們看看這個
多一點技術。

187
00:07:35,310 --> 00:07:37,390
我們知道小數
系統是0到9。

188
00:07:37,390 --> 00:07:38,740
我們知道二進制是0和1。

189
00:07:38,740 --> 00:07:41,842
如果你覺得回到PSET
0，我們有你角力，

190
00:07:41,842 --> 00:07:43,800
一點點，東西
所謂的十六進制，

191
00:07:43,800 --> 00:07:47,320
在這裡你有16位數字，
而不是10或代替2-。

192
00:07:47,320 --> 00:07:50,405
而這些數字，按照慣例，
為0至9，然後一個

193
00:07:50,405 --> 00:07:55,040
通過f，其中f代表什麼
十進制數，只是作為一個快速神智

194
00:07:55,040 --> 00:07:56,640
檢查？

195
00:07:56,640 --> 00:07:57,610
這樣，15。

196
00:07:57,610 --> 00:08:01,390
而一個必須代表10，只憑
我已經給訂貨的性質。

197
00:08:01,390 --> 00:08:04,350
這只是一個任意的約定，
但是它是相當標準。

198
00:08:04,350 --> 00:08:06,870
>> 因此，如果我們看一下這個模式
三bytes--我們

199
00:08:06,870 --> 00:08:09,620
剛開始看它
用怎樣的方式

200
00:08:09,620 --> 00:08:12,450
計算機科學家一般
看待和思考的文件。

201
00:08:12,450 --> 00:08:15,580
你當然可以考慮一下
在0文件，和1，和小數，

202
00:08:15,580 --> 00:08:19,340
但在現實中，我們往往會使用二進制
或更典型地hexadecimal--

203
00:08:19,340 --> 00:08:20,760
回程從PSET 0。

204
00:08:20,760 --> 00:08:25,857
因此，讓我提出，255，216，255
是0和1的只是這些模式。

205
00:08:25,857 --> 00:08:28,440
你可以，如果檢查這個你
想從第0週做數學題。

206
00:08:28,440 --> 00:08:30,810
不過，就目前來看，只是假設
這確實是正確的。

207
00:08:30,810 --> 00:08:33,850
我剛剛改寫三個小數
數字作為3的二進制值。

208
00:08:33,850 --> 00:08:36,100
現在我所要做的就是
只需添加一些白色的空間，

209
00:08:36,100 --> 00:08:37,266
只是可讀性的緣故。

210
00:08:37,266 --> 00:08:39,940
而通知，我只是去
搬東西分開。

211
00:08:39,940 --> 00:08:43,090
所以前，後，前，後。

212
00:08:43,090 --> 00:08:46,180
我在做什麼有趣其他
不僅僅是傳播的東西出這麼

213
00:08:46,180 --> 00:08:50,380
該通知每組八
位現在是兩組四比特。

214
00:08:50,380 --> 00:08:54,920
這是因為，十六進制有用
特別時尚

215
00:08:54,920 --> 00:09:00,930
因為每一個十六進制數字0〜
f或者更具體地為0到15，

216
00:09:00,930 --> 00:09:03,430
可以表示
恰好有四位。

217
00:09:03,430 --> 00:09:07,960
換句話說，在十六進制如果
想表示一個0，它只是0000，

218
00:09:07,960 --> 00:09:08,780
四個零。

219
00:09:08,780 --> 00:09:13,997
如果你要代表15，
它是1111，這是4位。

220
00:09:13,997 --> 00:09:16,080
如果你做數學題，
如果這是個位，

221
00:09:16,080 --> 00:09:18,210
這是16S的地方，
那將會給你 - 

222
00:09:18,210 --> 00:09:19,960
而這回事
用於：對不起，二進制，

223
00:09:19,960 --> 00:09:23,660
那將會給你15，個位，
三三兩兩的地方，四肢和八分的地方。

224
00:09:23,660 --> 00:09:26,821
因此，讓我提議說
在左側設置四個比特的

225
00:09:26,821 --> 00:09:28,070
就是我們要調用F。

226
00:09:28,070 --> 00:09:30,110
這是最大的號碼，你
可以用四位表示。

227
00:09:30,110 --> 00:09:33,300
我們已經從十六進制知道，
f是十六進制的最大數字。

228
00:09:33,300 --> 00:09:36,020
我們已經有了另一個F那裡，
兩個在那邊。

229
00:09:36,020 --> 00:09:38,980
而現在，只需要信仰
我已經做了數學向右

230
00:09:38,980 --> 00:09:41,890
並且左半
那些位，1101，

231
00:09:41,890 --> 00:09:43,980
是同樣的事情為d十六進制。

232
00:09:43,980 --> 00:09:46,490
而右手，1000，僅僅是8。

233
00:09:46,490 --> 00:09:48,140
>> 而一個人的易見，對吧？

234
00:09:48,140 --> 00:09:51,670
8 represents--是正確的
下面的八分地方。

235
00:09:51,670 --> 00:09:56,040
所以我們有一個在八分列
並沒有在四肢著地，三三兩兩或1。

236
00:09:56,040 --> 00:09:59,830
所以現在更多的傳統，人們往往
寫十六進制這樣的數字，

237
00:09:59,830 --> 00:10:03,000
你剛才壓碎在一起，
然後以0x前綴他們。

238
00:10:03,000 --> 00:10:05,920
這意味著什麼比其他
視覺線索一human--

239
00:10:05,920 --> 00:10:10,350
又來了一個十六進制value--因為
它可能沒有另外明顯。

240
00:10:10,350 --> 00:10:13,629
>> 這就是說，最終，
零和一的圖案，

241
00:10:13,629 --> 00:10:16,170
或十六進制的模式
數字等價的你

242
00:10:16,170 --> 00:10:18,990
要開始尋找
在習題集4 this--

243
00:10:18,990 --> 00:10:22,120
和習題集4規範將走
您通過本更detail--

244
00:10:22,120 --> 00:10:25,344
但作為實現某種神秘的作為
這可能看起來乍一看，

245
00:10:25,344 --> 00:10:27,010
你將開始看到這個有很多。

246
00:10:27,010 --> 00:10:30,320
而事實上，即使是在GDB中，
調試器，我們推出了週一

247
00:10:30,320 --> 00:10:35,440
和丹介紹了PSET 3，是怎麼回事
經常告訴你的十六進制值

248
00:10:35,440 --> 00:10:39,910
只是因為他們往往更
傳統不是十進制或二進制

249
00:10:39,910 --> 00:10:41,157
在計算機的世界。

250
00:10:41,157 --> 00:10:42,490
現在，讓我們把這個的來龍去脈。

251
00:10:42,490 --> 00:10:48,040
你們中許多人可能還記得這個
圖片瀏覽，它來自什麼？

252
00:10:48,040 --> 00:10:51,240
Vista的，所以還要早
認為，Windows XP這樣做首次亮相。

253
00:10:51,240 --> 00:10:52,620
因此，這是一道亮麗的風景。

254
00:10:52,620 --> 00:10:55,940
而事實上，如果你閒逛online--
我認為這是一個維基百科的文章，

255
00:10:55,940 --> 00:11:00,110
其中有人很令人驚訝出去
發現這個位置在世界上成立

256
00:11:00,110 --> 00:11:02,240
他或她的在相機
恰到好處的place--

257
00:11:02,240 --> 00:11:06,510
這看起來今天like--但
它是完全一樣的設置。

258
00:11:06,510 --> 00:11:10,060
這個圖像，不過，是在一個文件中
格式稱為位圖，B-M-頁。

259
00:11:10,060 --> 00:11:12,910
而且我們要採取超
快速瀏覽一下這是什麼意思。

260
00:11:12,910 --> 00:11:17,770
>> 但是，位圖是只是用不同的方式
代表圖像仍然採用像素

261
00:11:17,770 --> 00:11:19,580
在0和1，最終。

262
00:11:19,580 --> 00:11:23,282
但在快速瀏覽，它有
一個更有趣的簽名

263
00:11:23,282 --> 00:11:24,490
在文件的開頭。

264
00:11:24,490 --> 00:11:26,670
這不是短短三年
字節，而還有

265
00:11:26,670 --> 00:11:30,770
一大堆的字節模式
已經預定義。

266
00:11:30,770 --> 00:11:34,490
例如，某處
位圖圖像的前幾個字節

267
00:11:34,490 --> 00:11:37,440
將是的大小
圖像時，圖像的寬度，

268
00:11:37,440 --> 00:11:40,390
圖像的高度，因此
有用的元數據，如果你願意。

269
00:11:40,390 --> 00:11:43,940
有用信息的Photoshop
或任何圖形您正在使用編程

270
00:11:43,940 --> 00:11:45,180
也許真的在乎。

271
00:11:45,180 --> 00:11:47,170
>> 因此，更多的關於這方面
問題集4中，但此

272
00:11:47,170 --> 00:11:49,220
只說
在一天結束時

273
00:11:49,220 --> 00:11:52,390
你一直在使用的文件格式
對於years-- Microsoft Word文件，

274
00:11:52,390 --> 00:11:55,820
數字文件，Excel文件，
任意數量的文件格式

275
00:11:55,820 --> 00:11:57,770
可能有一些
已知文件擴展名

276
00:11:57,770 --> 00:12:00,130
只是0和1的引擎蓋下。

277
00:12:00,130 --> 00:12:02,970
而人類已經決定
什麼樣的約定，

278
00:12:02,970 --> 00:12:08,340
什麼樣的0和1的模式代表
一個Word文件與一個Excel文件，

279
00:12:08,340 --> 00:12:10,322
與任意數量的其他文件格式。

280
00:12:10,322 --> 00:12:12,780
因此，在PSET 4，你就會有一個
機遇與發揮。

281
00:12:12,780 --> 00:12:14,405
>> 但是，什麼意思有一個結構。

282
00:12:14,405 --> 00:12:18,012
這實際上是一個很好的SEGUE現在
成C，它只有一對夫婦

283
00:12:18,012 --> 00:12:20,220
附加功能
我們還沒看呢。

284
00:12:20,220 --> 00:12:24,230
這是一個非常小的語言之一
關於C的不錯的功能，是一個結構。

285
00:12:24,230 --> 00:12:27,300
例如，如果你
想represent--我們

286
00:12:27,300 --> 00:12:33,690
說你想有一個變量
代表一個學生的一些計劃。

287
00:12:33,690 --> 00:12:37,330
也許你正在寫一門課程
註冊程序，或核心購物

288
00:12:37,330 --> 00:12:38,870
工具，或者類似的東西。

289
00:12:38,870 --> 00:12:42,922
什麼是數據塊相關
一個學生浮現在腦海？

290
00:12:42,922 --> 00:12:44,880
就像一個學生
代表有什麼樣的價值觀？

291
00:12:44,880 --> 00:12:45,732
是嗎？

292
00:12:45,732 --> 00:12:46,940
你有一個名字作為一個學生。

293
00:12:46,940 --> 00:12:48,900
還有什麼不典型的學生有哪些？

294
00:12:48,900 --> 00:12:49,320
>> 聽眾：[聽不清]

295
00:12:49,320 --> 00:12:50,200
>> DAVID J.馬蘭：所以，對不起。

296
00:12:50,200 --> 00:12:50,660
>> 聽眾：年齡。

297
00:12:50,660 --> 00:12:52,980
>> DAVID J.馬蘭：一個時代或
生日等效，是的。

298
00:12:52,980 --> 00:12:53,557
還有什麼？

299
00:12:53,557 --> 00:12:54,390
聽眾：身份證號碼？

300
00:12:54,390 --> 00:12:57,460
DAVID J.馬蘭：所以一個ID號，也許
一個電話號碼，也許是一個宿舍，或房子，

301
00:12:57,460 --> 00:12:58,670
或學院，或類似的東西。

302
00:12:58,670 --> 00:13:01,820
任何數目的數據段是
你可能在你的聯繫人列表

303
00:13:01,820 --> 00:13:03,890
是可以定義一個學生。

304
00:13:03,890 --> 00:13:08,490
因此，如果我們要做到這一點，在代碼中，
我們可以做一些簡單的像這樣。

305
00:13:08,490 --> 00:13:15,670
我們可能有一個程序，
有讓我們說，詮釋主要（無效）。

306
00:13:15,670 --> 00:13:18,920
如果我想代表
學生，我可能有，比如，

307
00:13:18,920 --> 00:13:24,330
一個名為名字的學生字符串，
一個名為宿舍為學生串，

308
00:13:24,330 --> 00:13:26,900
也許一個int稱為ID為學生。

309
00:13:26,900 --> 00:13:30,840
而且因為我使用的字符串，我
需要回去並提出了CS50.h.

310
00:13:30,840 --> 00:13:33,300
也許我會需要stdio.h中。

311
00:13:33,300 --> 00:13:38,190
因此，讓我搶先做那些和我
要調用這個student.c現在

312
00:13:38,190 --> 00:13:40,080
並保存。

313
00:13:40,080 --> 00:13:44,206
>> 現在我能做些什麼
這些變量。

314
00:13:44,206 --> 00:13:46,830
而我們只是寫
隨著偽代碼中的註釋，

315
00:13:46,830 --> 00:13:48,829
因為它不是有趣
我們做什麼現在。

316
00:13:48,829 --> 00:13:51,242
好了，這是一個程序，
不知何故存儲的學生。

317
00:13:51,242 --> 00:13:53,450
什麼是我想要做的，如果我
要存儲兩位學生？

318
00:13:53,450 --> 00:13:55,991
所以，我的第一反應是怎麼回事
就可以了吧，等一下，

319
00:13:55,991 --> 00:14:01,920
如果我有一個學生，為什麼不要我
只是做字符串名稱2，串宿舍2，

320
00:14:01,920 --> 00:14:04,190
INT ID2。

321
00:14:04,190 --> 00:14:06,540
而我們所做的走了
下來之前，這條道路

322
00:14:06,540 --> 00:14:10,890
什麼是我們的解決方案似乎什麼
是怎樣的一個hackish的複製粘貼的

323
00:14:10,890 --> 00:14:11,555
在這裡工作？

324
00:14:11,555 --> 00:14:12,346
聽眾：數組。

325
00:14:12,346 --> 00:14:13,830
DAVID J.馬蘭：是啊，
我們可以使用的陣列。

326
00:14:13,830 --> 00:14:15,620
右鍵這個速度非常快
就不明智了。

327
00:14:15,620 --> 00:14:18,453
你要排序的任意
開始命名所有這些變量。

328
00:14:18,453 --> 00:14:22,190
而你，人類，必須保持
跟踪該行名2對應

329
00:14:22,190 --> 00:14:25,060
與dorm2對應ID2。

330
00:14:25,060 --> 00:14:26,200
它只是變得一團糟。

331
00:14:26,200 --> 00:14:29,350
所以這是一個容易得多，
從幾個星期前還記得，

332
00:14:29,350 --> 00:14:34,300
只是不得不叫字符串名稱
也許給我們其中的三個。

333
00:14:34,300 --> 00:14:36,940
然後，也許我們有
串宿舍和有

334
00:14:36,940 --> 00:14:41,900
三個，或具有恆定，
詮釋ID和有三個那些。

335
00:14:41,900 --> 00:14:45,250
但即便是現在這樣的感覺
一個有點草率了吧。

336
00:14:45,250 --> 00:14:49,440
我們談論的是學生，但
我真的沉湎於低水平

337
00:14:49,440 --> 00:14:50,470
實施細則。

338
00:14:50,470 --> 00:14:52,790
學生是一個名稱，一個宿舍和ID。

339
00:14:52,790 --> 00:14:59,814
>> 為什麼我不能只是聲明一個變量
所謂的學生，稱之為秒。

340
00:14:59,814 --> 00:15:02,230
如果我想另一名學生，
為什麼不讓我只是把它噸。

341
00:15:02,230 --> 00:15:05,260
或者，如果我想要一大堆
學生，為什麼不讓我

342
00:15:05,260 --> 00:15:09,740
說我有一整類
同學們，這是他們三個。

343
00:15:09,740 --> 00:15:12,470
換句話說，為什麼不能我來了
與我自己的數據類型，稱為

344
00:15:12,470 --> 00:15:15,641
學生，其內部是
一個名字，是一個ID，是一個宿舍，

345
00:15:15,641 --> 00:15:16,890
任何數量等領域。

346
00:15:16,890 --> 00:15:19,030
而事實證明，你
可正是這樣做的。

347
00:15:19,030 --> 00:15:21,850
>> 所以C有這個功能叫做結構。

348
00:15:21,850 --> 00:15:24,700
這是一個語言功能，
讓我們做的正是這一點。

349
00:15:24,700 --> 00:15:28,370
我要繼續前進
並開闢structs.h

350
00:15:28,370 --> 00:15:32,299
在這裡，我們將看到的
以下是學生的定義。

351
00:15:32,299 --> 00:15:35,215
事實證明 - 而這其中甚至
比一個涉及ID簡單

352
00:15:35,215 --> 00:15:36,080
剛才。

353
00:15:36,080 --> 00:15:39,120
如果你要來了
自製的數據類型，

354
00:15:39,120 --> 00:15:42,750
而除了int和char和
浮起並所有這些其他人的存在，

355
00:15:42,750 --> 00:15:45,810
你可以從字面上這樣做
寫typedef結構，

356
00:15:45,810 --> 00:15:47,880
然後一些大括號，
這裡面你

357
00:15:47,880 --> 00:15:51,460
列出你想要的變量
這一新的自定義數據相關聯

358
00:15:51,460 --> 00:15:55,670
像鍵入一個名稱和宿舍，
再經過大括號

359
00:15:55,670 --> 00:15:57,860
你給一個名稱為新的數據類型。

360
00:15:57,860 --> 00:15:59,220
因此，例如，學生。

361
00:15:59,220 --> 00:16:03,247
>> 什麼是好的關於這個現在是，
如果我們看一下相應的代碼，

362
00:16:03,247 --> 00:16:05,080
該公約，第一
所有的人，是把這個

363
00:16:05,080 --> 00:16:08,230
在一個名為什麼點H，
一個頭文件，我們有沒有

364
00:16:08,230 --> 00:16:09,780
開始使用自己太多。

365
00:16:09,780 --> 00:16:12,120
但是，我們要開始
使用相當多的現在。

366
00:16:12,120 --> 00:16:18,650
而且我們可以用這個做的，
最終，在這幾行代碼

367
00:16:18,650 --> 00:16:22,130
正是如此聲明
數據類型，一個學生。

368
00:16:22,130 --> 00:16:23,230
現在，讓我們使用它。

369
00:16:23,230 --> 00:16:27,274
>> 我要現在進入
一個名為structs1.c。

370
00:16:27,274 --> 00:16:29,440
讓我們來看看一個
幾個特點在這裡。

371
00:16:29,440 --> 00:16:32,250
所以的東西在這裡是
大多是熟悉的，我們會

372
00:16:32,250 --> 00:16:35,040
回過頭來究竟是不是
熟悉一會兒就好了。

373
00:16:35,040 --> 00:16:39,880
當然，這是包括我自己
頭文件，它是新的，以及，

374
00:16:39,880 --> 00:16:42,580
除了PSET 3，其中，
回想一下，我們有helpers.h。

375
00:16:42,580 --> 00:16:45,150
所以，你可能還記得的#include helpers.h。

376
00:16:45,150 --> 00:16:49,381
>> 但為什麼我使用引號
而不是尖括號？

377
00:16:49,381 --> 00:16:50,630
我什麼時候他們之間做出選擇？

378
00:16:50,630 --> 00:16:52,310
幾乎總是我似乎
使用尖括號。

379
00:16:52,310 --> 00:16:55,040
然後，突然之間就
六號線我使用雙引號。

380
00:16:55,040 --> 00:16:55,860
為什麼會這樣呢？

381
00:16:55,860 --> 00:16:56,700
是嗎？

382
00:16:56,700 --> 00:16:57,725
>> 聽眾：[聽不清]

383
00:16:57,725 --> 00:16:59,350
DAVID J.馬蘭：這是一個實際的，是什麼？

384
00:16:59,350 --> 00:17:00,559
聽眾：這是在你的IDE。

385
00:17:00,559 --> 00:17:02,475
DAVID J.馬蘭：是啊，
這是在我的實際IDE。

386
00:17:02,475 --> 00:17:05,690
而且我們不要對IDE糾纏，因為
這只是我使用的工具。

387
00:17:05,690 --> 00:17:08,119
那是在我目前
目錄，明確。

388
00:17:08,119 --> 00:17:11,647
所以structs.h是我自己的文件
沒有安裝IDE，

389
00:17:11,647 --> 00:17:14,480
在操作系統本身，
而它在我的當前目錄。

390
00:17:14,480 --> 00:17:16,910
所以，如果你想要的約定
包括您自己的頭文件，

391
00:17:16,910 --> 00:17:18,200
你只需要使用雙引號。

392
00:17:18,200 --> 00:17:23,290
>> 什麼是我們所說的這個東西
8號線，一般來講？

393
00:17:23,290 --> 00:17:25,200
這是什麼？

394
00:17:25,200 --> 00:17:28,220
＃定義的東西。

395
00:17:28,220 --> 00:17:31,040
這代表常數，對不對？

396
00:17:31,040 --> 00:17:33,140
如果你想有一個
在你的程序價值

397
00:17:33,140 --> 00:17:35,110
您使用一個整體
一堆的時候，它的

398
00:17:35,110 --> 00:17:39,330
良好的約定因素出來，
聲明它，用井號

399
00:17:39,330 --> 00:17:43,340
定義的話，按照慣例，在所有
大寫word--儘管它不是

400
00:17:43,340 --> 00:17:45,320
絕對必要的，但
這是人類的約定

401
00:17:45,320 --> 00:17:47,210
充分利用常數
使他們跳出

402
00:17:47,210 --> 00:17:50,380
你visually--空間
那麼你想要的值是

403
00:17:50,380 --> 00:17:52,250
相當於恆定的名字。

404
00:17:52,250 --> 00:17:56,110
別無分號，但是你根本
按照該模式存在。

405
00:17:56,110 --> 00:17:57,770
>> 那麼，我在此實際代碼執行。

406
00:17:57,770 --> 00:18:00,660
因此，讓我們一起來看看
這裡的主要程序。

407
00:18:00,660 --> 00:18:04,080
在第12行，因為我
已包括structs.h，

408
00:18:04,080 --> 00:18:06,492
我現在已經奇蹟般地在我
處置一個新的數據類型。

409
00:18:06,492 --> 00:18:09,200
我不只是有機會獲得INT，
和炭，和float和字符串，

410
00:18:09,200 --> 00:18:10,060
和藍色等。

411
00:18:10,060 --> 00:18:12,470
我現在有機會獲得
一個學生的數據類型。

412
00:18:12,470 --> 00:18:17,740
因此，在第12行，我將兩個
ideas--一項所述的自定義數據類型和兩個，

413
00:18:17,740 --> 00:18:18,940
使用陣列。

414
00:18:18,940 --> 00:18:21,700
所以，在這個項目中，如果
我想實際支持

415
00:18:21,700 --> 00:18:24,320
三個不同的學生
在我的計劃，我

416
00:18:24,320 --> 00:18:30,480
可以簡單地說，給我一個變量
稱為學生，其每一個

417
00:18:30,480 --> 00:18:32,970
是類型的學生，哪個
是我的自定義數據類型。

418
00:18:32,970 --> 00:18:35,890
而且，具體而言，給我
其中三個在我的陣列。

419
00:18:35,890 --> 00:18:37,750
>> 所以，現在我們做這個節目在哪？

420
00:18:37,750 --> 00:18:40,670
這裡只是一個for循環迭代
從0到3，因為這是

421
00:18:40,670 --> 00:18:42,110
什麼樣的學生的價值。

422
00:18:42,110 --> 00:18:44,420
我只是提示用戶
給我的學生的名字。

423
00:18:44,420 --> 00:18:48,090
然後在第17行，我們
有大多熟悉線路。

424
00:18:48,090 --> 00:18:50,370
我們有我們的老朋友
GetString的右側。

425
00:18:50,370 --> 00:18:52,345
什麼一塊語法
顯然是新的，

426
00:18:52,345 --> 00:18:55,130
如果你以前從來沒有編入C，
並且從未使用過的結構？

427
00:18:55,130 --> 00:18:55,510
是嗎？

428
00:18:55,510 --> 00:18:56,417
>> 聽眾：本。名稱。

429
00:18:56,417 --> 00:18:57,500
DAVID J.馬蘭：本。名稱。

430
00:18:57,500 --> 00:19:01,220
但是，這不是一個太大的飛躍，
因為現在的學生括號我

431
00:19:01,220 --> 00:19:02,590
為您提供了第i個學生。

432
00:19:02,590 --> 00:19:04,730
如果你想潛水
該結構的內部，

433
00:19:04,730 --> 00:19:09,490
你只需要使用一個週期，
那麼變量內的名稱，

434
00:19:09,490 --> 00:19:11,900
或內部的財產
你想獲得訪問。

435
00:19:11,900 --> 00:19:14,816
同樣的話，如果我再提示
用戶，給我的學生的宿舍，

436
00:19:14,816 --> 00:19:18,390
你同樣可以存儲
字符串裡面的宿舍變量

437
00:19:18,390 --> 00:19:19,940
那學生結構。

438
00:19:19,940 --> 00:19:21,410
>> 現在事情變得有點奇特。

439
00:19:21,410 --> 00:19:24,420
這是要去看看
在或許很多太快了。

440
00:19:24,420 --> 00:19:27,970
但是你會看到這麼遠更PSET
4，所以我們只在它一眼吧。

441
00:19:27,970 --> 00:19:33,364
事實證明，在第23行至
38，你覺得什麼我可能做什麼？

442
00:19:33,364 --> 00:19:35,530
我已經刪除了評論
今天，但版本

443
00:19:35,530 --> 00:19:38,660
網上的代碼的
參考已全部評論。

444
00:19:38,660 --> 00:19:40,171
我似乎在做？

445
00:19:40,171 --> 00:19:42,530
>> 聽眾：保存所有文件
該用戶輸入的信息。

446
00:19:42,530 --> 00:19:44,530
>> DAVID J.馬蘭：是啊，
準確地說，這是一種新的方式

447
00:19:44,530 --> 00:19:46,370
我們現在看到的二，
的C另一個特徵，

448
00:19:46,370 --> 00:19:48,700
因此我可以創建自己的文件。

449
00:19:48,700 --> 00:19:51,580
到目前為止，幾乎每一個程序
你寫的是無狀態的。

450
00:19:51,580 --> 00:19:53,334
一旦它完成運行，僅此而已。

451
00:19:53,334 --> 00:19:55,000
有沒有記憶或它的回憶。

452
00:19:55,000 --> 00:19:56,110
有沒有保存的文件。

453
00:19:56,110 --> 00:19:58,120
但是，如果你想
節約投入，有

454
00:19:58,120 --> 00:20:02,100
事情發生了，就像在遊戲或程序
這樣，事實證明我們可以做到這一點。

455
00:20:02,100 --> 00:20:04,360
你會看到這更
在PSET 4節。

456
00:20:04,360 --> 00:20:08,661
但是，這條線23實質上
創建一個名為students.csv文件。

457
00:20:08,661 --> 00:20:10,160
你可能已經看到過這一點。

458
00:20:10,160 --> 00:20:14,250
即使你以前從來沒有學CS，
CSV是逗號分隔的變量。

459
00:20:14,250 --> 00:20:19,000
這就像一個非常貧窮的人的
版本的Excel文件，

460
00:20:19,000 --> 00:20:22,270
這意味著它可以打開
在Excel和蘋果的數字，

461
00:20:22,270 --> 00:20:23,830
它具有的行和列。

462
00:20:23,830 --> 00:20:26,485
但它不是一個專有
格式如微軟或蘋果。

463
00:20:26,485 --> 00:20:29,840
它只是逗號分隔
價值觀，我們將看到一個時刻。

464
00:20:29,840 --> 00:20:31,010
>> 而只是採取一種猜測。

465
00:20:31,010 --> 00:20:33,480
在第23行，在最
最後，我的第二個參數

466
00:20:33,480 --> 00:20:37,700
這個所謂的新功能
F打開文件打開是瓦特

467
00:20:37,700 --> 00:20:39,430
什麼可能W¯¯表示？

468
00:20:39,430 --> 00:20:40,022
是嗎？

469
00:20:40,022 --> 00:20:41,260
>> 聽眾：它可以讓你寫文件？

470
00:20:41,260 --> 00:20:42,630
>> DAVID J.馬蘭：它可以讓
你寫入文件。

471
00:20:42,630 --> 00:20:44,810
因此，有幾個變種
我們可以在這裡插上研究。

472
00:20:44,810 --> 00:20:47,184
但如果你只是想讀
該文件，也就是看它

473
00:20:47,184 --> 00:20:50,010
並讀入內存，
只需使用報價引文結束“R”。

474
00:20:50,010 --> 00:20:53,110
如果你想要寫的
文件，可以使用報價引文結束“W”。

475
00:20:53,110 --> 00:20:55,190
還有追加和
幾個其他的事情

476
00:20:55,190 --> 00:20:57,356
如果要修改現有的文件。

477
00:20:57,356 --> 00:21:00,480
現在，我們將繼續看到這
的東西，那麼我們會回來到線24。

478
00:21:00,480 --> 00:21:02,640
NULL，它的出現，是
一個特殊值，

479
00:21:02,640 --> 00:21:06,070
可以通過某些功能被返回
如果事情已經wrong--

480
00:21:06,070 --> 00:21:08,490
如果該文件不存在，
如果你耗盡內存，

481
00:21:08,490 --> 00:21:09,620
或一堆其他錯誤。

482
00:21:09,620 --> 00:21:13,470
但現在，讓我們姑且認為這
僅僅是傳統的錯誤檢查。

483
00:21:13,470 --> 00:21:17,090
在這裡，在第26行，我遍歷
從0到3在所有我的學生。

484
00:21:17,090 --> 00:21:20,470
這是一種排序
一個新的功能，fprintf中，

485
00:21:20,470 --> 00:21:21,460
而只是採取一種猜測。

486
00:21:21,460 --> 00:21:24,370
如果printf的只是打印
一個格式化字符串，

487
00:21:24,370 --> 00:21:26,507
是什麼fprintf中大概是什麼意思？

488
00:21:26,507 --> 00:21:27,590
聽眾：打印到文件中。

489
00:21:27,590 --> 00:21:29,290
DAVID J.馬蘭：打印
格式化字符串到一個文件中。

490
00:21:29,290 --> 00:21:31,180
這就是另外的
F表示是文件。

491
00:21:31,180 --> 00:21:36,420
而新的第一個參數必須是
這表示您的文件中的變量。

492
00:21:36,420 --> 00:21:38,866
然後，我們只是有一個格式
就像printf的字符串。

493
00:21:38,866 --> 00:21:40,740
即使這
語法是新的，這只是

494
00:21:40,740 --> 00:21:44,610
是指插在學生的姓名，
插件在學生宿舍，然後

495
00:21:44,610 --> 00:21:47,160
用fclose函數，關閉文件。

496
00:21:47,160 --> 00:21:49,730
然後lastly--這是新的
我們會回來的這

497
00:21:49,730 --> 00:21:53,240
long--我釋放前
學生的原因

498
00:21:53,240 --> 00:21:54,860
發生了上面有。

499
00:21:54,860 --> 00:21:56,820
但是，我們會回來的
該前long--

500
00:21:56,820 --> 00:21:59,820
這是因為GetString的是如何
實際工作引擎蓋下。

501
00:21:59,820 --> 00:22:01,280
>> 因此，讓我們快速瀏覽一下這裡。

502
00:22:01,280 --> 00:22:04,380
如果我在目錄中輸入ls，
請注意，我不

503
00:22:04,380 --> 00:22:09,360
有一個名為students.csv文件，
只是不存在，不存在。

504
00:22:09,360 --> 00:22:14,965
所以，如果我現在編譯這個程序，
使結構-1。 /結構-1，

505
00:22:14,965 --> 00:22:20,570
而且我要繼續前進，鍵入
岸堤，誰住在伯克利，耶魯。

506
00:22:20,570 --> 00:22:26,350
我們將不得不搶誰
住在塞耶這些天。

507
00:22:26,350 --> 00:22:33,760
而且，我們拿出其中，
是的，我想，瑪麗亞是在馬瑟

508
00:22:33,760 --> 00:22:35,100
如果我沒記錯。

509
00:22:35,100 --> 00:22:36,460
>> 所以好像沒有什麼改變。

510
00:22:36,460 --> 00:22:40,680
但是，如果我現在輸入ls，
有students.csv。

511
00:22:40,680 --> 00:22:43,080
讓我們繼續和開放的students.csv。

512
00:22:43,080 --> 00:22:46,050
這又是一個非常
輕巧的文件格式。

513
00:22:46,050 --> 00:22:49,570
但我只是通過了一項約定
我有兩行和列在這裡。

514
00:22:49,570 --> 00:22:52,020
第一列是
人的名字。

515
00:22:52,020 --> 00:22:55,740
第二列是學生的
宿舍，或學院，或房子，或諸如此類的東西。

516
00:22:55,740 --> 00:22:57,900
而現在我已經保存在此
永久在文件中。

517
00:22:57,900 --> 00:22:59,280
>> 因此，它不是那麼有趣。

518
00:22:59,280 --> 00:23:02,980
但是，這只是一個敲門磚，現在
要能堅持信息

519
00:23:02,980 --> 00:23:04,040
久治不愈。

520
00:23:04,040 --> 00:23:08,340
所以，讓我們來看看現在還有什麼我們可以
如何處理這些和其它特徵。

521
00:23:08,340 --> 00:23:10,729
但首先，什麼問題嗎？

522
00:23:10,729 --> 00:23:12,145
這是一個很多，而且非常快。

523
00:23:12,145 --> 00:23:16,131
但是，你會看到很多
更PSET 4，也是如此。

524
00:23:16,131 --> 00:23:16,630
是嗎？

525
00:23:16,630 --> 00:23:19,360
>> 聽眾：有沒有一種方法來
繼續添加名稱到該文件？

526
00:23:19,360 --> 00:23:19,880
>> DAVID J.馬蘭：好問題。

527
00:23:19,880 --> 00:23:21,800
有沒有辦法繼續
將名稱添加到該文件？

528
00:23:21,800 --> 00:23:22,340
是。

529
00:23:22,340 --> 00:23:24,630
而且，事實上，如果你最終
最多再打開文件，

530
00:23:24,630 --> 00:23:26,780
你會使用報價
引文結束“一”進行追加，

531
00:23:26,780 --> 00:23:31,090
這只會增加一個新的線，
新的生產線連連，完全吻合。

532
00:23:31,090 --> 00:23:32,010
好問題。

533
00:23:32,010 --> 00:23:32,950
其他的問題嗎？

534
00:23:32,950 --> 00:23:33,450
是嗎？

535
00:23:33,450 --> 00:23:35,580
聽眾：如果您運行了
再次程序現在，

536
00:23:35,580 --> 00:23:38,000
它會不斷增加名字的
文件或將它打開了一個新的文件？

537
00:23:38,000 --> 00:23:38,740
>> DAVID J.馬蘭：啊，好問題。

538
00:23:38,740 --> 00:23:41,448
如果再次正確運行程序
現在，也許在輸入新的名稱，

539
00:23:41,448 --> 00:23:44,820
將其添加到文件
或覆蓋文件？

540
00:23:44,820 --> 00:23:47,420
後者，因為我
不使用追加模式。

541
00:23:47,420 --> 00:23:49,930
而且因為我只是一味地
打開該文件進行寫入，

542
00:23:49,930 --> 00:23:51,310
它只是將覆蓋該文件。

543
00:23:51,310 --> 00:23:54,570
所以，我的確需要做的是追加，
如果我想確實有一個長期的

544
00:23:54,570 --> 00:23:55,350
數據庫。

545
00:23:55,350 --> 00:23:58,220
>> 現在，CSV是有用的，坦率地說，即使
像如果你writing--

546
00:23:58,220 --> 00:24:00,100
我們最終會看到這個
後來在學期時，

547
00:24:00,100 --> 00:24:01,455
我們使用的CSV用於其他目的。

548
00:24:01,455 --> 00:24:04,920
如果你想存儲所有的人
誰已經註冊了一些事件，

549
00:24:04,920 --> 00:24:07,420
或者註冊了您的學生
組，或者類似的東西，

550
00:24:07,420 --> 00:24:10,330
將數據存儲在這種
格式是超級方便。

551
00:24:10,330 --> 00:24:12,580
因為從字面上看，如果我
要下載此文件。

552
00:24:12,580 --> 00:24:14,540
我可以double--和
讓我們真正嘗試這

553
00:24:14,540 --> 00:24:16,720
如果我有Excel或數字放在這裡。

554
00:24:16,720 --> 00:24:19,130
>> 我要右擊
或控制單擊我的檔案。

555
00:24:19,130 --> 00:24:20,020
哎呦。

556
00:24:20,020 --> 00:24:21,830
用鼠標右鍵單擊或控制單擊我的檔案。

557
00:24:21,830 --> 00:24:24,960
來吧，我的鼠標是不是合作。

558
00:24:24,960 --> 00:24:32,694
Download--我要去
下載的所有文件，在這裡，所以

559
00:24:32,694 --> 00:24:33,860
只是這樣我就可以抓住這一個。

560
00:24:33,860 --> 00:24:37,850
而讓我們看看，如果這個工程
students.csv--第一次

561
00:24:37,850 --> 00:24:39,310
我已激活。

562
00:24:39,310 --> 00:24:41,360
現在，他們希望看到我的聯繫人。

563
00:24:41,360 --> 00:24:44,310
現在，我需要註冊。

564
00:24:44,310 --> 00:24:47,620
看到它是多麼容易使用的CSV？

565
00:24:47,620 --> 00:24:50,840
是的，保持最新。

566
00:24:50,840 --> 00:24:52,375
好了，現在我們已經準備好上課。

567
00:24:52,375 --> 00:24:58,750

568
00:24:58,750 --> 00:25:00,370
OK，哦，有什麼新的？

569
00:25:00,370 --> 00:25:02,920
OK，關閉。

570
00:25:02,920 --> 00:25:04,750
這是不可思議的。

571
00:25:04,750 --> 00:25:07,280
好了，現在我們必須更新。

572
00:25:07,280 --> 00:25:10,890
而現在，它忘記了什麼
文件我原來開了，

573
00:25:10,890 --> 00:25:13,090
但什麼A--我們走吧。

574
00:25:13,090 --> 00:25:16,341
好了，現在我們有一個Excel文件。

575
00:25:16,341 --> 00:25:18,290
謝謝。

576
00:25:18,290 --> 00:25:20,764
>> 好了，我做的是一件容易的事。

577
00:25:20,764 --> 00:25:23,930
當然，我可以預裝
Excel或數字，或其他程序。

578
00:25:23,930 --> 00:25:25,846
但是，這是很好的，因為
現在我可以操縱

579
00:25:25,846 --> 00:25:28,090
在標準格式中的數據。

580
00:25:28,090 --> 00:25:30,294
>> 所以，現在我們的上下文
切換到我們離開

581
00:25:30,294 --> 00:25:32,710
最後的時間，這是開始
起飛訓練車輪。

582
00:25:32,710 --> 00:25:34,543
但首先，你沒有
看到這個前面的午餐

583
00:25:34,543 --> 00:25:38,150
再次發生在這裡的消防和
冰在劍橋，西塔在紐黑文。

584
00:25:38,150 --> 00:25:43,150
註冊在CS50s網站盡快
加入CS50的學生和工作人員。

585
00:25:43,150 --> 00:25:46,090
>> 因此，我們採取了輔助輪
關閉週一follows--

586
00:25:46,090 --> 00:25:49,120
串已被宣布
CS50s庫一段時間。

587
00:25:49,120 --> 00:25:52,650
而且這是不錯的，因為它允許
我們談論的變量作為

588
00:25:52,650 --> 00:25:54,660
完整的單詞和句子等。

589
00:25:54,660 --> 00:25:56,710
但事實證明字符串不存在。

590
00:25:56,710 --> 00:26:00,200
這僅僅是同義詞，或別名，
我們已經對一些創建

591
00:26:00,200 --> 00:26:03,780
其實是多一點
技術稱為一個char *。

592
00:26:03,780 --> 00:26:07,900
>> 事實上，我們看到了一個例子
週一計劃

593
00:26:07,900 --> 00:26:11,200
這並沒有表現得如我們預期。

594
00:26:11,200 --> 00:26:13,630
這是文件，比較-0。

595
00:26:13,630 --> 00:26:17,910
而記得比較-0，如果
我重新編譯週一的節目

596
00:26:17,910 --> 00:26:22,670
並運行比較-0與2型糖尿病的媽媽
小寫，媽媽用小寫了。

597
00:26:22,670 --> 00:26:25,320
該方案堅持我
輸入不同的東西，

598
00:26:25,320 --> 00:26:29,210
即使媽媽，都在
小寫的，是一樣的視覺。

599
00:26:29,210 --> 00:26:31,990
那麼，什麼是簡單的答案
為什麼電腦認為

600
00:26:31,990 --> 00:26:34,500
這兩個字符串是不同的？

601
00:26:34,500 --> 00:26:35,250
是嗎？

602
00:26:35,250 --> 00:26:36,534
>> 聽眾：[聽不清]

603
00:26:36,534 --> 00:26:37,450
DAVID J.馬蘭：沒錯。

604
00:26:37,450 --> 00:26:39,600
所以，媽媽，第一次
我在鍵入它，正在

605
00:26:39,600 --> 00:26:42,710
地方保存在我的電腦
存儲器但在不同的位置

606
00:26:42,710 --> 00:26:44,690
比我第二次輸入的媽媽。

607
00:26:44,690 --> 00:26:46,580
現在，它肯定可以優化。

608
00:26:46,580 --> 00:26:49,205
計算機可以是聰明，
實現這兩個字符串，哎，

609
00:26:49,205 --> 00:26:49,954
他們是相同的。

610
00:26:49,954 --> 00:26:51,520
讓我沒有冗餘存儲。

611
00:26:51,520 --> 00:26:54,229
但是，計算機不這樣做
優化，除非你告訴他們。

612
00:26:54,229 --> 00:26:56,061
因此，在默認情況下，他們是
只是要結束了

613
00:26:56,061 --> 00:26:57,670
在內存中的兩個不同的地方。

614
00:26:57,670 --> 00:27:01,570
所以更清晰，當
我們比較兩個字符串，

615
00:27:01,570 --> 00:27:03,950
第一個被稱為S，
第二個被稱為

616
00:27:03,950 --> 00:27:08,530
T，具體什麼是我
這裡比較第13行？

617
00:27:08,530 --> 00:27:09,494
是啊。

618
00:27:09,494 --> 00:27:12,390
>> 聽眾：這是在內存中的位置
該變量將指向。

619
00:27:12,390 --> 00:27:14,900
>> DAVID J.馬蘭：沒錯，我是
比較在存儲器中的位置

620
00:27:14,900 --> 00:27:16,300
這些變量指向。

621
00:27:16,300 --> 00:27:20,560
因此，特別是，如果媽媽是在
字節號1，和2和3，

622
00:27:20,560 --> 00:27:24,020
和4--因為記住的反斜杠
0需要是一路在末端。

623
00:27:24,020 --> 00:27:29,420
和媽媽，M-O-M的另一個實例，
是在地址10，11，12，和13。

624
00:27:29,420 --> 00:27:33,100
我是比較1，該地址，
在存儲器中的位置，

625
00:27:33,100 --> 00:27:35,160
對10，這是
明顯不一樣。

626
00:27:35,160 --> 00:27:36,260
1不是10。

627
00:27:36,260 --> 00:27:39,620
>> 因此，這是很好的在
這是非常簡單的。

628
00:27:39,620 --> 00:27:42,870
但它是有問題的，只要
我們似乎無法比較字符串。

629
00:27:42,870 --> 00:27:44,930
所以fundamentally--
並且在該低的水平，

630
00:27:44,930 --> 00:27:47,300
如果你想實現
方案比較

631
00:27:47,300 --> 00:27:50,270
兩個獨立的詞了
用戶鍵入的質量，

632
00:27:50,270 --> 00:27:53,944
做自己排隊字符為
炭，只是條件一般，

633
00:27:53,944 --> 00:27:55,360
我們需要什麼做的，顯然是？

634
00:27:55,360 --> 00:27:57,940
這是不夠的只是
看看這兩個地址。

635
00:27:57,940 --> 00:27:58,860
什麼是我們需要做什麼？

636
00:27:58,860 --> 00:27:59,360
是嗎？

637
00:27:59,360 --> 00:28:01,120
>> 聽眾：遍歷
字符串[聽不清]。

638
00:28:01,120 --> 00:28:02,600
>> DAVID J.馬蘭：是啊，讓我們
遍歷字符串。

639
00:28:02,600 --> 00:28:05,808
讓我們用一個for循環，while循環，或
無論你是最舒服的。

640
00:28:05,808 --> 00:28:08,840
如果我們有兩個字符串的地方
在內存中，讓我們來看看各的

641
00:28:08,840 --> 00:28:11,770
第一個字符，那麼每個第二
字符，則第三和第四，

642
00:28:11,770 --> 00:28:15,206
第五，直到我們打
有什麼特殊的標記值？

643
00:28:15,206 --> 00:28:16,080
聽眾：[聽不清]

644
00:28:16,080 --> 00:28:18,800
DAVID J.馬蘭：是啊，反斜線
零，在該點在任一字符串

645
00:28:18,800 --> 00:28:20,100
我們可以決定就是這樣。

646
00:28:20,100 --> 00:28:21,970
我們有沒有匹配的每一個人物？

647
00:28:21,970 --> 00:28:22,990
如果不是，返回false。

648
00:28:22,990 --> 00:28:24,770
如果是的話，返回true。

649
00:28:24,770 --> 00:28:28,800
所以這正是這個版本
該方案的比較-1.C一樣。

650
00:28:28,800 --> 00:28:31,677
它等同於我們
看了看，除了週一，我已經

651
00:28:31,677 --> 00:28:34,760
擺脫了字string--的，雖然
有沒有功能impact--所有

652
00:28:34,760 --> 00:28:37,450
我現在做的是消除
一些視覺輔助輪，

653
00:28:37,450 --> 00:28:40,880
但要清醒地看到，
s和t地址。

654
00:28:40,880 --> 00:28:43,020
這就是明星，
星號代表

655
00:28:43,020 --> 00:28:46,690
是一個地址，或稱為
更多技術上的一個指針。

656
00:28:46,690 --> 00:28:49,880
>> 所以，當我在申報小號
第9行，說的char * S，

657
00:28:49,880 --> 00:28:52,160
這並不意味著給我一個字符串。

658
00:28:52,160 --> 00:28:56,360
這意味著給我一個變量，其
生活目的是存儲一個地址。

659
00:28:56,360 --> 00:29:00,400
因為我即將把
字符串轉換成它的地址。

660
00:29:00,400 --> 00:29:03,500
事實上，GetString的，是
清晰，不返回一個字符串。

661
00:29:03,500 --> 00:29:06,110
它不返回的媽媽
反斜杠零，本身。

662
00:29:06,110 --> 00:29:10,005
什麼是GetString的具體
而恰恰回來嗎？

663
00:29:10,005 --> 00:29:10,880
聽眾：[聽不清]

664
00:29:10,880 --> 00:29:14,080
DAVID J.馬蘭：一個地址，
第一個字符的地址

665
00:29:14,080 --> 00:29:16,070
在一些字符串就已經得到了。

666
00:29:16,070 --> 00:29:19,250
所以現在我們所看到的
一個特殊的關鍵字了。

667
00:29:19,250 --> 00:29:20,640
而且，我提到這點。

668
00:29:20,640 --> 00:29:23,620
這將是好習慣
我們會一次又一次地看到了。

669
00:29:23,620 --> 00:29:27,540
我檢查，以確保
s是不為空，t為不為空。

670
00:29:27,540 --> 00:29:30,100
因為根據我真的
快速提早些時候，

671
00:29:30,100 --> 00:29:35,510
什麼可能意味著，如果GetString的返回不
一個地址，但N-二U-L-L，這是再一次，

672
00:29:35,510 --> 00:29:36,990
一些特殊的價值？

673
00:29:36,990 --> 00:29:37,890
>> 聽眾：錯誤。

674
00:29:37,890 --> 00:29:38,600
>> DAVID J.馬蘭：這是一個錯誤。

675
00:29:38,600 --> 00:29:39,550
出事了。

676
00:29:39,550 --> 00:29:41,341
什麼一般
可能發生的事情，尤其是

677
00:29:41,341 --> 00:29:45,162
與strings--可能
未知長度advance--的

678
00:29:45,162 --> 00:29:46,870
也許是電腦“
內存不足，可能

679
00:29:46,870 --> 00:29:49,280
你在這種類型的
長字或句子

680
00:29:49,280 --> 00:29:51,880
或粘貼這樣一個龐大的作文
那裡只是沒有足夠的內存。

681
00:29:51,880 --> 00:29:55,340
所以GetString的不能返回
整個事情的地址，

682
00:29:55,340 --> 00:29:56,620
所以它只是沒有返回值。

683
00:29:56,620 --> 00:30:00,580
它說，一個錯誤已經發生
通過返回特殊的NULL值。

684
00:30:00,580 --> 00:30:02,890
這是零地址，可以這麼說。

685
00:30:02,890 --> 00:30:06,157
>> 現在事實證明，C提供一
函數，它的迭代。

686
00:30:06,157 --> 00:30:09,240
我們沒有一起實現這個
一個for循環或while循環自己。

687
00:30:09,240 --> 00:30:11,150
我們可以用一個函數，
所謂的簡潔，

688
00:30:11,150 --> 00:30:15,400
攪拌補償，或字符串比較，其
人生目標是做這一點。

689
00:30:15,400 --> 00:30:19,990
你給它兩個指針，兩個地址，
它會去到這些地址

690
00:30:19,990 --> 00:30:23,130
然後比較信
信信的質量，

691
00:30:23,130 --> 00:30:26,610
停止，只有當什麼是真的嗎？

692
00:30:26,610 --> 00:30:31,540
當直覺上應該挑起補償
停止迭代，只是要清楚嗎？

693
00:30:31,540 --> 00:30:35,400
當它擊中一個反斜杠0在任
串，在這一點上，它可以決定

694
00:30:35,400 --> 00:30:38,910
擁有一切匹配，或
以前有差異？

695
00:30:38,910 --> 00:30:42,740
>> 所以，如果我們運行這個現在嘗試
我們的小市值的比賽，

696
00:30:42,740 --> 00:30:49,260
因此要比較-1，./compare-1和
鍵入小寫字母媽媽兩次。

697
00:30:49,260 --> 00:30:50,560
現在，同樣的事情。

698
00:30:50,560 --> 00:30:54,080
如果我再這樣做有
小寫再大寫的可能。

699
00:30:54,080 --> 00:30:56,720
現在，它的確與眾不同
之間大寫和小寫。

700
00:30:56,720 --> 00:31:00,440
所以，不是所有的硬或
神奇，但它現在解釋

701
00:31:00,440 --> 00:31:03,140
這是怎麼回事引擎蓋下。

702
00:31:03,140 --> 00:31:07,640
>> 那麼，我們還能提取
從這種教訓？

703
00:31:07,640 --> 00:31:08,980
因此，讓我們來看看這個。

704
00:31:08,980 --> 00:31:15,380
我要繼續前進，寫一個
快速程序這裡所說的複製0。

705
00:31:15,380 --> 00:31:21,594
現在讓我們繼續前進，實際上
讓我們做this--複製 -  0，

706
00:31:21,594 --> 00:31:23,010
看看我在這裡得到了什麼。

707
00:31:23,010 --> 00:31:24,712
我首先告訴用戶，說些什麼。

708
00:31:24,712 --> 00:31:26,420
然後，我得到一個字符串
我將其存儲在s中。

709
00:31:26,420 --> 00:31:29,810
然後我檢查如果s等於
等於NULL，只返回1。

710
00:31:29,810 --> 00:31:31,590
因此，這僅僅是標準的錯誤檢查。

711
00:31:31,590 --> 00:31:33,112
沒有什麼有趣的事情發生了。

712
00:31:33,112 --> 00:31:36,320
而事實上，如果我們擺脫錯誤
檢查，這看起來像本週1碼

713
00:31:36,320 --> 00:31:36,985
的時刻。

714
00:31:36,985 --> 00:31:39,110
但是我已經開始獲得
稍微好有關。

715
00:31:39,110 --> 00:31:43,340
>> 現在，在第16行，一個星期前，也許
甚至幾天或分鐘前，

716
00:31:43,340 --> 00:31:46,720
你可能會說行16
創建一個變量稱為T

717
00:31:46,720 --> 00:31:48,219
和複製s轉換它。

718
00:31:48,219 --> 00:31:50,010
這是一個完美的
合理的外賣。

719
00:31:50,010 --> 00:31:51,560
但更準確了。

720
00:31:51,560 --> 00:31:54,190
什麼是發生在第16行？

721
00:31:54,190 --> 00:31:56,170
什麼是得到複製
從右到左？

722
00:31:56,170 --> 00:31:56,669
是嗎？

723
00:31:56,669 --> 00:31:58,490
聽眾：為T獲得第一個地址？

724
00:31:58,490 --> 00:32:01,220
>> DAVID J.馬蘭：沒錯，T
越來越s的地址。

725
00:32:01,220 --> 00:32:05,170
所以，現在要清楚，如果我去
回到那個前面的例子

726
00:32:05,170 --> 00:32:08,520
我抽出我已經輸入了的事情。

727
00:32:08,520 --> 00:32:11,640
而我所鍵入的
in--這裡的s和這裡

728
00:32:11,640 --> 00:32:15,830
是我所鍵入的某處
內存，媽媽再一個反斜杠

729
00:32:15,830 --> 00:32:17,840
0了加我。

730
00:32:17,840 --> 00:32:23,060
我存放在這裡，回想一下，
這是在位置1，2，3，4，

731
00:32:23,060 --> 00:32:24,655
這是何等的當前秒。

732
00:32:24,655 --> 00:32:29,220
因此，如果第16行，我說給我
另一個變量稱為T和存儲

733
00:32:29,220 --> 00:32:33,590
在s的值，什麼
在這裡獲取存儲不會媽

734
00:32:33,590 --> 00:32:35,480
而是僅僅數字1。

735
00:32:35,480 --> 00:32:38,520
>> 因此，如果我們向前看這個程序中
現在，有什麼事情發生？

736
00:32:38,520 --> 00:32:40,690
所以發現有
這個功能你可能

737
00:32:40,690 --> 00:32:44,410
已經前段時間用這個凱撒，
或的Vigenere，或者根本沒有。

738
00:32:44,410 --> 00:32:48,170
我要求我的printf，我
要利用複製噸。

739
00:32:48,170 --> 00:32:51,616
首先在第19行，快速神智
檢查，T的strlen的檢查長度。

740
00:32:51,616 --> 00:32:53,740
因為我不希望
盡量利用的東西

741
00:32:53,740 --> 00:32:55,104
如果沒有串存在。

742
00:32:55,104 --> 00:32:57,520
如果用戶只需要敲擊回車，
沒有什麼把握。

743
00:32:57,520 --> 00:33:01,100
所以，我不想做線21。

744
00:33:01,100 --> 00:33:05,758
因此，第21行正在利用
這封信，顯然，在T？

745
00:33:05,758 --> 00:33:06,514
>> 聽眾：M？

746
00:33:06,514 --> 00:33:08,722
DAVID J.馬蘭：它看起來
喜歡它的拷貝哪一個？

747
00:33:08,722 --> 00:33:09,486
聽眾：M。

748
00:33:09,486 --> 00:33:10,450
DAVID J.馬蘭：嗯，男。

749
00:33:10,450 --> 00:33:12,685
好了，第一個男，
因為通知說我

750
00:33:12,685 --> 00:33:14,935
傳遞給TOUPPER，這
如果你從來沒有見過它的

751
00:33:14,935 --> 00:33:16,980
只是一個函數來
利用作為其輸入。

752
00:33:16,980 --> 00:33:20,240
Ť支架零意味著放棄
我T的零字符。

753
00:33:20,240 --> 00:33:22,550
所以，如何做到這一點
畫面切換，要清楚嗎？

754
00:33:22,550 --> 00:33:25,490

755
00:33:25,490 --> 00:33:29,160
需要得到什麼重寫或者改變
相對於s和t和媽媽

756
00:33:29,160 --> 00:33:30,097
反斜線零。

757
00:33:30,097 --> 00:33:31,470
>> 聽眾：[聽不清]

758
00:33:31,470 --> 00:33:34,030
>> DAVID J.馬蘭：是啊，
所以這一塊在這裡簡單地

759
00:33:34,030 --> 00:33:40,860
需要得到改變用於：修復this--
需要得到改為大寫M。

760
00:33:40,860 --> 00:33:44,330
但現在，在後來的看
程序，如果我打印出來

761
00:33:44,330 --> 00:33:49,800
S和T為我打掃這裡，看什麼
事情發生打印出s和t。

762
00:33:49,800 --> 00:33:54,310
因此，請複製0，./copy-0。

763
00:33:54,310 --> 00:33:57,140
讓我繼續前進，鍵入
在媽媽的全部小寫。

764
00:33:57,140 --> 00:34:00,140
注意原始和
該副本已資本化。

765
00:34:00,140 --> 00:34:00,850
為什麼呢？

766
00:34:00,850 --> 00:34:04,431
那麼，S和T都指向，
如果你願意，相同的內存塊。

767
00:34:04,431 --> 00:34:06,930
坦率地說，這是越來越
真正uninteresting--事實

768
00:34:06,930 --> 00:34:09,150
我們使用零地址在這裡。

769
00:34:09,150 --> 00:34:11,719
我的意思是，我真的不關心
那裡的東西是在內存中。

770
00:34:11,719 --> 00:34:13,550
對不起，我抹去一點也不為過。

771
00:34:13,550 --> 00:34:15,674
但我真的不關心
那裡的東西都在內存中。

772
00:34:15,674 --> 00:34:18,510
所以，確實是
程序員傾向於考慮

773
00:34:18,510 --> 00:34:21,080
就是當你談論
一個地址，或者一個指針，

774
00:34:21,080 --> 00:34:22,679
誰在乎它是在內存中。

775
00:34:22,679 --> 00:34:24,989
我不關心，如果它在
字節一或一十億。

776
00:34:24,989 --> 00:34:27,920
我只關心這個
變量是有效的

777
00:34:27,920 --> 00:34:29,620
指向的內存塊。

778
00:34:29,620 --> 00:34:33,350
所以，從今以後，而不是狡辯
在任意的內存地址，讓我們

779
00:34:33,350 --> 00:34:36,710
剛開始繪製指針
作為指針，為箭頭。

780
00:34:36,710 --> 00:34:39,340
那麼，S和T真的，
根據這一計劃，

781
00:34:39,340 --> 00:34:42,130
因為我是如何創建的T，
這只是兩個獨立的變量

782
00:34:42,130 --> 00:34:43,840
指向相同的內存塊。

783
00:34:43,840 --> 00:34:45,215
我們不關心他們在哪裡。

784
00:34:45,215 --> 00:34:47,130
所以我們可以抽​​象掉的細節。

785
00:34:47,130 --> 00:34:48,780
>> 那麼，如何解決這一問題？

786
00:34:48,780 --> 00:34:54,120
如果我想編寫一個版本的副本
項目實際的字符串複製

787
00:34:54,120 --> 00:34:56,840
只有大寫
副本，只是憑直覺，

788
00:34:56,840 --> 00:34:59,766
真實得到了什麼是一個
成份，我們的解決方案？

789
00:34:59,766 --> 00:35:00,640
聽眾：[聽不清]

790
00:35:00,640 --> 00:35:01,420
DAVID J.馬蘭：我們需要什麼？

791
00:35:01,420 --> 00:35:01,820
聽眾：內存塊。

792
00:35:01,820 --> 00:35:03,280
DAVID J.馬蘭：我們需要
內存另一塊，對不對？

793
00:35:03,280 --> 00:35:05,360
我們不知道如何
做到這一點的是，不一定。

794
00:35:05,360 --> 00:35:11,330
但我有種需要做到這一點，以便
在小寫原媽

795
00:35:11,330 --> 00:35:14,170
在額外的內存塊結束。

796
00:35:14,170 --> 00:35:19,770
然後當我改變的副本，我
不想在這裡改變此副本。

797
00:35:19,770 --> 00:35:26,020
我不是想改變僅此
副本使原來的不變。

798
00:35:26,020 --> 00:35:27,980
>> 那麼，讓我們看看我們如何做到這一點。

799
00:35:27,980 --> 00:35:31,800
在copy-1，它已經
被剝奪了評論，

800
00:35:31,800 --> 00:35:33,250
但網上評論道。

801
00:35:33,250 --> 00:35:36,710
我們不是做following--這些
線是相同的，給我一個字符串

802
00:35:36,710 --> 00:35:38,340
並稱之為秒。

803
00:35:38,340 --> 00:35:43,500
但是，現在讓我們來看看我們的最多一個
複雜的，但在過去的複雜性

804
00:35:43,500 --> 00:35:47,340
一段時間，第16行正是這一點。

805
00:35:47,340 --> 00:35:49,400
因此，如果與您的舒適
圖片我們只是drew--

806
00:35:49,400 --> 00:35:51,790
給我一個新的內存塊，
所有內容複製到它，

807
00:35:51,790 --> 00:35:53,730
讓我們看看如何把這種代碼。

808
00:35:53,730 --> 00:35:59,400
>> 因此線16，在左手側，
字符* T給我這個盒子在這裡。

809
00:35:59,400 --> 00:36:00,230
這就是它。

810
00:36:00,230 --> 00:36:03,240
在右手側，
米ALLOC，或malloc的，

811
00:36:03,240 --> 00:36:06,480
是內存分配，超花哨，
只是說，一個神秘的方式

812
00:36:06,480 --> 00:36:07,640
給我一個內存塊。

813
00:36:07,640 --> 00:36:09,290
多少內存，我們需要什麼？

814
00:36:09,290 --> 00:36:10,910
那麼，是怎樣的一個大的表現。

815
00:36:10,910 --> 00:36:12,570
但是讓我們看看它說在這裡。

816
00:36:12,570 --> 00:36:15,940
因此，這當然是給
我s的字符串長度。

817
00:36:15,940 --> 00:36:19,094
因此，母親應該是什麼呢？

818
00:36:19,094 --> 00:36:21,010
所以只有三個，對嗎？
媽媽是三個大字。

819
00:36:21,010 --> 00:36:22,830
你不要指望了
反斜杠零，當你

820
00:36:22,830 --> 00:36:25,960
談論一個字符串它的長度
其實人類可見的字母。

821
00:36:25,960 --> 00:36:28,020
所以媽媽，所以這給了我3。

822
00:36:28,020 --> 00:36:31,170
但是且慢，我現在加1。

823
00:36:31,170 --> 00:36:34,861
為什麼我真的想
分配4個字節，而不僅僅是3？

824
00:36:34,861 --> 00:36:35,360
是嗎？

825
00:36:35,360 --> 00:36:36,910
>> 顧客：定點價值？

826
00:36:36,910 --> 00:36:38,951
>> DAVID J.馬蘭：沒錯，
該標記值。

827
00:36:38,951 --> 00:36:40,840
對於反斜杠零，
我需要總共4個字節。

828
00:36:40,840 --> 00:36:42,870
所以，我需要的長度
字符串加1。

829
00:36:42,870 --> 00:36:45,400
然後就是好measure--
即使在這個系統上，

830
00:36:45,400 --> 00:36:49,390
它總是將是1--我說
通過一個char的大小乘這一點。

831
00:36:49,390 --> 00:36:51,552
原來的sizeof是
C中的運算符

832
00:36:51,552 --> 00:36:53,260
只是告訴你的
字節數這

833
00:36:53,260 --> 00:36:54,700
所需的一定的數據類型。

834
00:36:54,700 --> 00:36:57,740
它不會對數組工作，
典型地，有時它。

835
00:36:57,740 --> 00:36:59,210
但在一般情況下，沒有。

836
00:36:59,210 --> 00:37:02,330
但是，它會告訴我有多少字節
char是，這原來是始終為1。

837
00:37:02,330 --> 00:37:04,080
所以，這就像乘以1。

838
00:37:04,080 --> 00:37:05,900
>> 因此，超級神秘的期待一行代碼。

839
00:37:05,900 --> 00:37:09,320
但它是所有給出
我的內存塊。

840
00:37:09,320 --> 00:37:13,590
但它似乎是複製
任何東西到了內存？

841
00:37:13,590 --> 00:37:14,560
還沒有。

842
00:37:14,560 --> 00:37:22,040
所以，我該怎麼上線22和
23，24，25，好了，我只是做到這一點。

843
00:37:22,040 --> 00:37:23,760
這是排序
老同學現在的東西。

844
00:37:23,760 --> 00:37:26,010
這就好比PSET 2，其中
你只是搬東西

845
00:37:26,010 --> 00:37:28,620
各地在內存中，或者說在字符串中。

846
00:37:28,620 --> 00:37:31,920
>> 所以，我從0迭代到
的串s的長度。

847
00:37:31,920 --> 00:37:37,820
而我複製第i個字符
以s成噸的第i個字符。

848
00:37:37,820 --> 00:37:41,820
而且因為我，程序員，做
一定要準確地分配盡可能多的字節

849
00:37:41,820 --> 00:37:44,600
因為我需要，這是完美的
一對一的關係。

850
00:37:44,600 --> 00:37:47,060
我複製的媽媽在
小寫的新的。

851
00:37:47,060 --> 00:37:50,170
然後，最後，我做這行。

852
00:37:50,170 --> 00:37:54,637
等的效果只有
在這裡利用這件T。

853
00:37:54,637 --> 00:37:56,470
因此，大量吸納，但
如果你只是考慮

854
00:37:56,470 --> 00:37:58,220
到底發生了什麼
在發動機罩下方

855
00:37:58,220 --> 00:38:00,880
只是將這些
字節左右，所有的

856
00:38:00,880 --> 00:38:06,617
是需要解決這個問題是
只給我們這一塊內存。

857
00:38:06,617 --> 00:38:08,450
現在的風險
鋪天蓋地，讓我告訴

858
00:38:08,450 --> 00:38:13,200
另外一個例子，幾乎
相同的，除了這一個

859
00:38:13,200 --> 00:38:14,350
一行代碼。

860
00:38:14,350 --> 00:38:18,870
因此，這是黑客版
這個方案的，如果你願意。

861
00:38:18,870 --> 00:38:21,050
但是，我們只是提取
它變成了什麼事情。

862
00:38:21,050 --> 00:38:28,920
24號線使用的是這件T
支架我得到小號支架我。

863
00:38:28,920 --> 00:38:33,370
現在，我改變了這
在更神秘的星牛逼

864
00:38:33,370 --> 00:38:36,280
加1等於歌星般加1。

865
00:38:36,280 --> 00:38:38,702
>> 所以發生了什麼以及為什麼
我們有一個明星人物？

866
00:38:38,702 --> 00:38:41,410
我們已經看到的明星面前，
它被用於不同的位置。

867
00:38:41,410 --> 00:38:45,490
我們之前看到的字符*，現在我看到
阿星在一開始，這就是確定。

868
00:38:45,490 --> 00:38:48,190
因為事實證明我們
可以種推斷只是

869
00:38:48,190 --> 00:38:50,280
從這些第一
原則是怎麼回事。

870
00:38:50,280 --> 00:38:53,860
所以，僅僅是明確的，什麼是S'

871
00:38:53,860 --> 00:38:55,052
上週，它是一個字符串。

872
00:38:55,052 --> 00:38:56,260
這並不足夠了。

873
00:38:56,260 --> 00:38:57,690
什麼是S，具體一點嗎？

874
00:38:57,690 --> 00:38:58,590
>> 聽眾：[聽不清]

875
00:38:58,590 --> 00:38:59,881
>> DAVID J.馬蘭：這是一個指針。

876
00:38:59,881 --> 00:39:02,610
它的地址
第一個字符我們輸入研究。

877
00:39:02,610 --> 00:39:04,780
OK，什麼為t？

878
00:39:04,780 --> 00:39:05,660
>> 聽眾：[聽不清]

879
00:39:05,660 --> 00:39:07,950
>> DAVID J.馬蘭：本
的第一個字節的地址

880
00:39:07,950 --> 00:39:10,490
在T，該內存塊重新分配。

881
00:39:10,490 --> 00:39:14,720
所以，事實證明，當我們
從0迭代，一直到字符串

882
00:39:14,720 --> 00:39:17,424
length--首先，我
從0開始關閉，因為

883
00:39:17,424 --> 00:39:18,840
這個老同學for循環的事情。

884
00:39:18,840 --> 00:39:22,400
因此，只是為了簡單起見，我們
假設的代碼，所述第一線

885
00:39:22,400 --> 00:39:23,760
真的只是這樣，對吧。

886
00:39:23,760 --> 00:39:26,080
如果i為零，加零
的東西想必

887
00:39:26,080 --> 00:39:27,540
是不會有效果。

888
00:39:27,540 --> 00:39:28,560
>> 那麼，這是什麼意思嗎？

889
00:39:28,560 --> 00:39:31,600
事實證明，明星
操作者在這樣的背景下

890
00:39:31,600 --> 00:39:33,700
是取消引用
操作者，這僅僅是

891
00:39:33,700 --> 00:39:37,530
說法去一個奇特的方式
到以下地址。

892
00:39:37,530 --> 00:39:42,080
因此，如果s是第一的地址
字符在這個組塊的存儲器，

893
00:39:42,080 --> 00:39:43,630
* S表示去那裡。

894
00:39:43,630 --> 00:39:45,630
因為我們已經開
圖像以這種方式，

895
00:39:45,630 --> 00:39:47,430
您可以採用
下面的心智模式。

896
00:39:47,430 --> 00:39:51,030
如果這是S，和你說* S，* S
有點像槽和梯子，

897
00:39:51,030 --> 00:39:54,540
如果你從童年記憶的比賽中，
就像按照箭頭，去

898
00:39:54,540 --> 00:39:55,570
到的地址。

899
00:39:55,570 --> 00:39:57,080
>> * t是同樣的事情。

900
00:39:57,080 --> 00:39:59,855
所以從這裡開始，去它的塊。

901
00:39:59,855 --> 00:40:03,350
我不能只是借鑒
該屏幕的方式。

902
00:40:03,350 --> 00:40:05,560
* T手段去這裡。

903
00:40:05,560 --> 00:40:08,830
然後，for循環僅僅是
這裡說動這個角色，

904
00:40:08,830 --> 00:40:11,330
這裡將這個人物，
搬到這裡來這個角色。

905
00:40:11,330 --> 00:40:12,890
但我怎麼做增量？

906
00:40:12,890 --> 00:40:15,430
我要撤銷我剛剛刪除。

907
00:40:15,430 --> 00:40:18,140
這是什麼一般稱為
指針運算，這

908
00:40:18,140 --> 00:40:20,040
意味著數學與地址。

909
00:40:20,040 --> 00:40:22,460
>> 如果在此for循環，
我不斷遞增我，

910
00:40:22,460 --> 00:40:26,880
且s是一個地址，而t是一個
地址，如果我只是不斷增加1，

911
00:40:26,880 --> 00:40:31,406
這只是意味著不斷前進，
轉發和轉發在內存中。

912
00:40:31,406 --> 00:40:34,030
這就像牛津大街，
街道，政務司司長建設上。

913
00:40:34,030 --> 00:40:36,490
在CS建築物是在33牛津街。

914
00:40:36,490 --> 00:40:39,870
所以，如果你是做33
牛津街加1，

915
00:40:39,870 --> 00:40:42,870
，帶你到34牛津
街道，35個牛津街，

916
00:40:42,870 --> 00:40:46,380
那麼牛津街36，不管這些
建築居然是 - 如果它們存在。

917
00:40:46,380 --> 00:40:50,540
所以，這就是我們正在做的
這裡有指針運算。

918
00:40:50,540 --> 00:40:53,820
>> 所以這是一個非常神秘的方式
的表達自己。

919
00:40:53,820 --> 00:40:56,160
但是，所有發生的事情
引擎蓋下

920
00:40:56,160 --> 00:40:59,330
只是下面的這些地址，
就像下面的地圖，如果你願意，

921
00:40:59,330 --> 00:41:02,692
或以下似箭
我們已經在屏幕上繪製。

922
00:41:02,692 --> 00:41:04,910
OK，很多消化。

923
00:41:04,910 --> 00:41:10,410
對語法有任何問題，概念，
指針，malloc或類似物。

924
00:41:10,410 --> 00:41:11,480
是啊，在這裡第一次。

925
00:41:11,480 --> 00:41:13,755
>> 聽眾：那麼，這
說* T等於TOUPPER * T，

926
00:41:13,755 --> 00:41:15,575
就是要利用
所有的字母或just--

927
00:41:15,575 --> 00:41:17,283
>> DAVID J.馬蘭：啊，
非常好的問題。

928
00:41:17,283 --> 00:41:19,805
因此，在這條線在這裡，31，
這是怎麼回事充分利用

929
00:41:19,805 --> 00:41:21,430
第一個字母或所有字母。

930
00:41:21,430 --> 00:41:23,460
因此，讓我們回答這個問題通過去
回到第一個原則。

931
00:41:23,460 --> 00:41:26,168
在這裡，第一個原則，我的意思是
剛去的基本定義

932
00:41:26,168 --> 00:41:27,000
一個什麼樣的參與。

933
00:41:27,000 --> 00:41:29,770
所以TOUPPER是一個功能
這一個大寫字符。

934
00:41:29,770 --> 00:41:30,530
這就是全部。

935
00:41:30,530 --> 00:41:36,740
* t表示進入first--
去T中的地址。

936
00:41:36,740 --> 00:41:40,350
所以，在圖像，如果這是塊
內存我們使用malloc分配，

937
00:41:40,350 --> 00:41:43,310
這是T，* T手段去這裡。

938
00:41:43,310 --> 00:41:46,710
>> 同時，你傳遞
該值，小寫字母m

939
00:41:46,710 --> 00:41:50,040
到TOUPPER，你要回
外資併購，你在哪裡把它？

940
00:41:50,040 --> 00:41:52,410
你把它在同一位置。

941
00:41:52,410 --> 00:41:55,540
所以那些對這種邏輯
基本的定義，這只是

942
00:41:55,540 --> 00:41:58,792
大寫的第一個字母
除非你用迭代我或

943
00:41:58,792 --> 00:42:02,000
for循環或while循環，它不會
做任何事情比你問吧。

944
00:42:02,000 --> 00:42:02,583
好問題。

945
00:42:02,583 --> 00:42:03,237
是嗎？

946
00:42:03,237 --> 00:42:05,369
>> 聽眾：你為什麼使用
取消引用的方法，而不是

947
00:42:05,369 --> 00:42:05,979
數組？

948
00:42:05,979 --> 00:42:07,395
>> DAVID J.馬蘭：啊，好問題。

949
00:42:07,395 --> 00:42:10,672
為什麼你會使用反引用
方法，而不是在陣列的方法？

950
00:42:10,672 --> 00:42:12,130
沒有特別的原因，是誠實的。

951
00:42:12,130 --> 00:42:15,290
而且，事實上，對於這種
樣的例子吧，

952
00:42:15,290 --> 00:42:17,556
我只是爭論使得
程序比較複雜，

953
00:42:17,556 --> 00:42:19,680
更多的目光都呆滯，
人們退房

954
00:42:19,680 --> 00:42:22,830
因為這看起來超級神秘，但是
即使它在做同樣的事情。

955
00:42:22,830 --> 00:42:26,695
所以，坦率地說，這是一個
不必要的視覺複雜的解決方案

956
00:42:26,695 --> 00:42:27,320
到的問題。

957
00:42:27,320 --> 00:42:29,580
>> 它仍然是良好的設計，
五個五的設計，

958
00:42:29,580 --> 00:42:33,140
無論是在支架
符號或指針符號。

959
00:42:33,140 --> 00:42:36,299
但是 - 特別是當我們得到
在以後的過程中PSET 5

960
00:42:36,299 --> 00:42:39,340
當我們執行該字典，
我已經提到了幾個times--的

961
00:42:39,340 --> 00:42:42,300
我們真正關心的
低級別的內存地址

962
00:42:42,300 --> 00:42:44,140
我們真正理解
這是怎麼回事。

963
00:42:44,140 --> 00:42:48,300
>> 不過，就目前而言，事實證明，這
的代碼在這裡方括號線

964
00:42:48,300 --> 00:42:49,900
真的不存在。

965
00:42:49,900 --> 00:42:52,230
他們就是被稱為
語法糖，這

966
00:42:52,230 --> 00:42:58,390
僅僅是一個古怪爽說的方式
編譯器會將方括號是

967
00:42:58,390 --> 00:43:00,420
該數學表達式。

968
00:43:00,420 --> 00:43:02,660
所以這是一個人的約定
要能只寫

969
00:43:02,660 --> 00:43:04,220
這些非常人性化的支架。

970
00:43:04,220 --> 00:43:06,850
但是，編譯器，鐺，
真的做任何時間

971
00:43:06,850 --> 00:43:10,970
你寫什麼在網上突出
24，引擎蓋下它真的

972
00:43:10,970 --> 00:43:12,330
將其轉換為此。

973
00:43:12,330 --> 00:43:16,200
這只是作為一個人更愉快
讀取和寫入的代碼如線路24。

974
00:43:16,200 --> 00:43:18,530
但最終這些
培訓輪子太脫落

975
00:43:18,530 --> 00:43:21,780
當一個人的自己的舒適性變得更強。

976
00:43:21,780 --> 00:43:27,240
>> 好吧，所以記得那麼這
是最大的問題的排序

977
00:43:27,240 --> 00:43:27,807
我們碰上了。

978
00:43:27,807 --> 00:43:30,640
而這正是引發這整個
關於指針該死的談話，

979
00:43:30,640 --> 00:43:32,340
和地址，以及複製的東西。

980
00:43:32,340 --> 00:43:35,410
這是因為我們絆倒
這個愚蠢的，愚蠢的問題，即

981
00:43:35,410 --> 00:43:38,830
我實現logically--與勞倫
在這裡的演示和橙汁

982
00:43:38,830 --> 00:43:43,770
在milk--完美
算法正確的函數

983
00:43:43,770 --> 00:43:47,010
用於交換兩個變量“
值，但該死的東西

984
00:43:47,010 --> 00:43:50,550
沒有任何持續性，或
永久的，對我的代碼。

985
00:43:50,550 --> 00:43:51,820
>> 為什麼是？

986
00:43:51,820 --> 00:43:54,650
簡而言之，這是為什麼
實施互換

987
00:43:54,650 --> 00:43:58,740
邏輯上是正確的，但沒有任何影響
在傳遞給它的變量，

988
00:43:58,740 --> 00:44:01,119
像X和Y的主？

989
00:44:01,119 --> 00:44:02,410
什麼是問題的要點？

990
00:44:02,410 --> 00:44:02,909
是嗎？

991
00:44:02,909 --> 00:44:05,532
聽眾：因為變量進行的
變量中通副本

992
00:44:05,532 --> 00:44:06,240
通過功能。

993
00:44:06,240 --> 00:44:09,060
>> DAVID J.馬蘭：沒錯，當你通過
變量成一個函數，或參數

994
00:44:09,060 --> 00:44:11,030
到一個函數，它們是
通過複製，通過這

995
00:44:11,030 --> 00:44:14,770
意味著你得到一個相同的期待
位x和y的模式，

996
00:44:14,770 --> 00:44:15,955
這裡所謂的a和b。

997
00:44:15,955 --> 00:44:18,080
你可以做任何事情
你想與這些副本，

998
00:44:18,080 --> 00:44:20,657
但他們將不得不無
在呼叫功能的影響。

999
00:44:20,657 --> 00:44:22,990
而且，事實上，我們制定了
畫面在屏幕上，召回

1000
00:44:22,990 --> 00:44:25,520
最後一次，如果你由此
真正思考什麼

1001
00:44:25,520 --> 00:44:28,570
怎麼回事下方的hood--如果
這是你的計算機的內存，

1002
00:44:28,570 --> 00:44:31,650
而這兒是塊
被用於主存儲器，

1003
00:44:31,650 --> 00:44:34,020
這是對組塊
被用於交換內存，

1004
00:44:34,020 --> 00:44:37,090
所以即使主要有
兩個變量，x和y，

1005
00:44:37,090 --> 00:44:41,840
掉期可能具有相同的期待
值，這兩者都是1和2，

1006
00:44:41,840 --> 00:44:44,520
但他們完全
不同的塊的存儲器。

1007
00:44:44,520 --> 00:44:46,130
>> 因此，我們需要一個解決這個。

1008
00:44:46,130 --> 00:44:51,580
坦率地說，似乎我們現在
有一個解決這個問題吧。

1009
00:44:51,580 --> 00:44:55,760
如果我們現在有能力
通過地址的方式處理事情

1010
00:44:55,760 --> 00:44:59,310
排序和，滑道和梯子
樣式，請按照這些箭頭

1011
00:44:59,310 --> 00:45:02,820
而且去任何地方，我們希望
在內存中，難道我們

1012
00:45:02,820 --> 00:45:06,220
解決這個問題由
從主要通過交換

1013
00:45:06,220 --> 00:45:09,650
不是值，我們要
交換，而只是憑直覺

1014
00:45:09,650 --> 00:45:11,630
什麼可能我們通過交換呢？

1015
00:45:11,630 --> 00:45:12,620
>> [插入VOICES]

1016
00:45:12,620 --> 00:45:15,244
>> DAVID J.馬蘭：為什麼我們不只是
通過它的地址，對吧？

1017
00:45:15,244 --> 00:45:17,470
我們為什麼不給換一個
藏寶圖，如果你願意，

1018
00:45:17,470 --> 00:45:20,950
導致它的
實際值x和y。

1019
00:45:20,950 --> 00:45:24,340
讓我們交換，真正改變
這些原始比特，而不是

1020
00:45:24,340 --> 00:45:26,797
剛好路過的位份。

1021
00:45:26,797 --> 00:45:29,130
因此，事實上，這是什麼
將是該溶液中。

1022
00:45:29,130 --> 00:45:31,899
這裡這個版本
顯然不好，有缺陷的。

1023
00:45:31,899 --> 00:45:35,190
而現在，乍一看，它只是看起來
就像我們增加了一堆明星隨機

1024
00:45:35,190 --> 00:45:37,106
並越過我們的手指
它將編譯。

1025
00:45:37,106 --> 00:45:38,460
但是，它現在將彙編。

1026
00:45:38,460 --> 00:45:40,090
>> 但是，讓我們看看這些東西的意思。

1027
00:45:40,090 --> 00:45:43,990
和，遺憾的是，作者
把C選擇另一個符號

1028
00:45:43,990 --> 00:45:46,380
使這一點
更清晰，但星運營商

1029
00:45:46,380 --> 00:45:48,610
有不同的含義
兩個不同的上下文。

1030
00:45:48,610 --> 00:45:50,890
我們已經看到了兩個，
但讓​​我們分辨。

1031
00:45:50,890 --> 00:45:55,310
>> 所以向上在那裡的頂部，
當我已經改變a和b

1032
00:45:55,310 --> 00:46:00,470
被廉政局在惡劣
版本為int明星，a和b，

1033
00:46:00,470 --> 00:46:01,740
以前，都是整數。

1034
00:46:01,740 --> 00:46:05,752
什麼是a和b現在在
好，綠色版？

1035
00:46:05,752 --> 00:46:06,900
他們的地址。

1036
00:46:06,900 --> 00:46:09,610
什麼的，地址是明確的？

1037
00:46:09,610 --> 00:46:10,770
整數地址。

1038
00:46:10,770 --> 00:46:12,520
因此，事實上，我
他說INT星級手段

1039
00:46:12,520 --> 00:46:15,440
這是的地址
的整數，具體而言。

1040
00:46:15,440 --> 00:46:19,120
>> 所以，現在的代碼行通知，
別的東西也​​發生了變化。

1041
00:46:19,120 --> 00:46:22,770
tmp中保持不變，因為
這只是暫時的整數，

1042
00:46:22,770 --> 00:46:24,110
沒有記憶的魔法存在。

1043
00:46:24,110 --> 00:46:26,370
但現在需要一個明星。

1044
00:46:26,370 --> 00:46:28,560
而且，事實上，每一個
其他提及的a和b，

1045
00:46:28,560 --> 00:46:31,780
請注意，所有的
由紅色變為綠色

1046
00:46:31,780 --> 00:46:34,209
是，我的前綴
這些變量的星星。

1047
00:46:34,209 --> 00:46:35,750
因為我不想要複製a和b。

1048
00:46:35,750 --> 00:46:40,350
因為如果我只是複製a和b和交換
A和B，那我其實交換？

1049
00:46:40,350 --> 00:46:43,760
只是地址，我想交換
什麼是這些地址。

1050
00:46:43,760 --> 00:46:44,860
我想去那裡。

1051
00:46:44,860 --> 00:46:48,000
這樣一來，星運營商
我的函數中，

1052
00:46:48,000 --> 00:46:51,700
不參數列表內，
意味著你去到這些地址

1053
00:46:51,700 --> 00:46:54,490
而真正改變這些值。

1054
00:46:54,490 --> 00:46:56,500
>> 那麼，是什麼圖片
現在的樣子吧。

1055
00:46:56,500 --> 00:47:03,250
好吧，如果不是我傳遞
在A和B不1和2--

1056
00:47:03,250 --> 00:47:05,790
其實，我需要添加
這裡另外一個定義。

1057
00:47:05,790 --> 00:47:09,030
因此，假設這個塊
內存是在位置10。

1058
00:47:09,030 --> 00:47:12,960
>> 這是在位置11，但是這
是有點簡化，

1059
00:47:12,960 --> 00:47:18,900
我現在有兩個選擇做我傳遞X
和Y或者我通過他們的地址？

1060
00:47:18,900 --> 00:47:22,500
如果我通過他們的地址
就是這樣，我只是

1061
00:47:22,500 --> 00:47:25,390
現在需要實施
每綠色代碼交換

1062
00:47:25,390 --> 00:47:29,080
因此，它認為當一個，當它
看到B，它不只是複製a和b

1063
00:47:29,080 --> 00:47:30,540
並移動牛奶和橙汁。

1064
00:47:30,540 --> 00:47:32,664
牛奶和橙汁
比喻現在壞了，

1065
00:47:32,664 --> 00:47:35,060
因為那些都是杯具
的液體，而不是地圖。

1066
00:47:35,060 --> 00:47:37,750
我們反而需要去
解決10，我們

1067
00:47:37,750 --> 00:47:42,420
需要去解決11，和
然後執行交換邏輯。

1068
00:47:42,420 --> 00:47:45,580
>> 所以邏輯是相同的，但
我們需要一個稍微不同的方式

1069
00:47:45,580 --> 00:47:47,160
對訪問這些變量。

1070
00:47:47,160 --> 00:47:52,400
所以在最後，是什麼
程序有樣子是這樣的。

1071
00:47:52,400 --> 00:47:56,610
在swap.c逐字複製
並粘貼綠色版。

1072
00:47:56,610 --> 00:47:58,450
但我需要做一個改變。

1073
00:47:58,450 --> 00:48:00,180
這是不夠的只是改變掉。

1074
00:48:00,180 --> 00:48:03,830
什麼其他代碼行
我是否需要改變？

1075
00:48:03,830 --> 00:48:04,330
是嗎？

1076
00:48:04,330 --> 00:48:05,770
>> 聽眾：當它需要的參數。

1077
00:48:05,770 --> 00:48:07,603
>> DAVID J.馬蘭：在哪裡
它需要它的參數。

1078
00:48:07,603 --> 00:48:09,985
所以，如果我向上滾動到主，我
不能僅僅通過在x和y，

1079
00:48:09,985 --> 00:48:12,820
而且，我答應，最後
一塊新的語法今天。

1080
00:48:12,820 --> 00:48:17,200
我需要傳遞的不是X和
年，但x和y的地址。

1081
00:48:17,200 --> 00:48:20,400
而事實證明，符號
即C的作者選擇

1082
00:48:20,400 --> 00:48:23,860
是，如果你在這裡使用的符號，不
可與按位符號相混淆，

1083
00:48:23,860 --> 00:48:27,130
如果您使用的符號
這裡和這裡的符號，

1084
00:48:27,130 --> 00:48:29,570
這個數字為你，
什麼是x的地址，

1085
00:48:29,570 --> 00:48:31,740
也許是10，有什麼
Y的地址，也許是

1086
00:48:31,740 --> 00:48:35,400
11，並傳遞的那些代替。

1087
00:48:35,400 --> 00:48:37,210
>> 因此，大量吸納的一次。

1088
00:48:37,210 --> 00:48:40,190
但是，讓我們現在快速的看到
我們剩下的4分鐘

1089
00:48:40,190 --> 00:48:42,150
那裡的東西可能會出現偏差。

1090
00:48:42,150 --> 00:48:45,120
而作為一個不談，實際上
我拍下了這張照片，

1091
00:48:45,120 --> 00:48:46,920
TF一年或兩年前拍下了這張照片。

1092
00:48:46,920 --> 00:48:49,190
因此，這是後面的角落
艾略特食堂。

1093
00:48:49,190 --> 00:48:52,310
指針也許是最難
話題，我們將在CS50。

1094
00:48:52,310 --> 00:48:54,810
所以，如果你擔心的那種
坡就像是也許是

1095
00:48:54,810 --> 00:48:56,770
更多的是曲棍球棒
這樣，實現了

1096
00:48:56,770 --> 00:49:00,160
樣的，我們正在接近一個高峰
術語的概念複雜性。

1097
00:49:00,160 --> 00:49:02,300
>> 我提出這個
照片，因為我發誓

1098
00:49:02,300 --> 00:49:05,920
上帝，在1996年秋季，當我把
CS50與我的助教，

1099
00:49:05,920 --> 00:49:09,620
尼沙特梅塔，他在讓我坐下
角落艾略特D.廳在午餐時，

1100
00:49:09,620 --> 00:49:12,330
或晚餐，或一些嘗試
幫助我理解指針。

1101
00:49:12,330 --> 00:49:16,520
而這正是我在幾個星期後，
它在演講時介紹

1102
00:49:16,520 --> 00:49:18,170
我終於明白了三分球。

1103
00:49:18,170 --> 00:49:20,590
而且我希望這
點擊將遠遠早於你。

1104
00:49:20,590 --> 00:49:23,540
但是，認識到這一點絕對間
在更複雜的主題

1105
00:49:23,540 --> 00:49:24,420
我們已經看了。

1106
00:49:24,420 --> 00:49:25,819
但是，這其中最強大的。

1107
00:49:25,819 --> 00:49:28,860
而當你得到它，這就是全部
剛準備終於走到了一起。

1108
00:49:28,860 --> 00:49:31,460
所以放心它不會
需要在今天所有的水槽。

1109
00:49:31,460 --> 00:49:32,980
>> 因此，這裡的最後一個程序
我們要去看看。

1110
00:49:32,980 --> 00:49:35,605
而我們將結束與
快速3分鐘粘土動畫的

1111
00:49:35,605 --> 00:49:37,030
我們的朋友，尼克Parlante進行。

1112
00:49:37,030 --> 00:49:41,440
這裡有一個程序，即在前兩名
行聲明變量x和y。

1113
00:49:41,440 --> 00:49:44,780
這兩者都是地址
整數，AKA指針。

1114
00:49:44,780 --> 00:49:48,125
然後我們分配足夠的
內存來存儲一個int

1115
00:49:48,125 --> 00:49:51,344
並存儲地址
以x那個存儲器。

1116
00:49:51,344 --> 00:49:53,260
所以，這是更簡單
比以前的例子中

1117
00:49:53,260 --> 00:49:56,100
給我4個字節的內存，
這是一個int的大小，

1118
00:49:56,100 --> 00:49:58,000
並把該地址x中。

1119
00:49:58,000 --> 00:50:01,070
這條線在這裡的意思
去x中的地址

1120
00:50:01,070 --> 00:50:05,270
並把意義
生活中，數字42那裡。

1121
00:50:05,270 --> 00:50:07,710
不過，此行讓我擔心。

1122
00:50:07,710 --> 00:50:12,620
星y表示去的地址Y，
並把不吉利的數字13出現。

1123
00:50:12,620 --> 00:50:15,780
為什麼是危險的，在這一點上
在story--雖然迅速告知

1124
00:50:15,780 --> 00:50:17,980
在我們的減弱分鐘
這裡 - 為什麼是壞

1125
00:50:17,980 --> 00:50:19,660
我說，去y中的地址？

1126
00:50:19,660 --> 00:50:21,077
>> 聽眾：你有沒有[聽不清]。

1127
00:50:21,077 --> 00:50:22,910
DAVID J.馬蘭：我沒有
放任何東西在年。

1128
00:50:22,910 --> 00:50:25,520
那麼，什麼是y的值，
在這一點上的故事？

1129
00:50:25,520 --> 00:50:26,570
我們不知道。

1130
00:50:26,570 --> 00:50:29,190
這是一些垃圾值
並且也不賓基知道。

1131
00:50:29,190 --> 00:50:32,532
如果我們能夠結束這一點。

1132
00:50:32,532 --> 00:50:34,832
>> [視頻回放]

1133
00:50:34,832 --> 00:50:36,500
>>  - 嘿，賓基，醒了。

1134
00:50:36,500 --> 00:50:39,140
現在是時候為指針樂趣。

1135
00:50:39,140 --> 00:50:40,210
>>  - 什麼事？

1136
00:50:40,210 --> 00:50:41,690
了解指針？

1137
00:50:41,690 --> 00:50:43,570
哦，好極了。

1138
00:50:43,570 --> 00:50:46,600
>>  - 嗯，上手的，我想我們
將需要一對夫婦指針。

1139
00:50:46,600 --> 00:50:47,380
>>  - 確定。

1140
00:50:47,380 --> 00:50:51,120
此代碼分配兩個指針
它可以指向整數。

1141
00:50:51,120 --> 00:50:53,557
>>  - 確定，以及我見
兩個指針，但他們

1142
00:50:53,557 --> 00:50:55,140
似乎並沒有指向任何東西。

1143
00:50:55,140 --> 00:50:55,970
>>  - 那是正確的。

1144
00:50:55,970 --> 00:50:58,100
最初，指針
不指向任何東西。

1145
00:50:58,100 --> 00:51:00,950
他們指出，事情
被稱為指針對象並設置為

1146
00:51:00,950 --> 00:51:02,330
是一個獨立的步驟。

1147
00:51:02,330 --> 00:51:03,210
>> 哦，對，對。

1148
00:51:03,210 --> 00:51:03,940
我知道這一點。

1149
00:51:03,940 --> 00:51:05,730
所述指針對象是分開的。

1150
00:51:05,730 --> 00:51:08,310
那麼，你如何分配一個指針對象？

1151
00:51:08,310 --> 00:51:11,960
>>  - 確定，以及這段代碼中分配
一個新的整數指針對象，

1152
00:51:11,960 --> 00:51:15,050
而這部分設置x為指向它。

1153
00:51:15,050 --> 00:51:16,240
>>  - 嘿，這看起來更好。

1154
00:51:16,240 --> 00:51:17,743
所以讓它做一些事情。

1155
00:51:17,743 --> 00:51:23,580
>>  - 確定，我會取消引用指針x可
數字42存入及其指針。

1156
00:51:23,580 --> 00:51:27,130
對於這一招，我需要我的
提領魔杖。

1157
00:51:27,130 --> 00:51:30,200
>> 提領的 - 你的魔杖？

1158
00:51:30,200 --> 00:51:32,310
呃，那個，這是偉大的。

1159
00:51:32,310 --> 00:51:34,270
>>  - 這是什麼樣的代碼如下所示。

1160
00:51:34,270 --> 00:51:35,970
我會剛剛成立的數量還有 - 

1161
00:51:35,970 --> 00:51:37,070
>> [POP音]

1162
00:51:37,070 --> 00:51:39,140
>>  - 嘿，看那裡去。

1163
00:51:39,140 --> 00:51:43,980
所以，做一個解引用在X如下
箭頭訪問及其指針。

1164
00:51:43,980 --> 00:51:46,150
在這種情況下，為了存儲42在那裡。

1165
00:51:46,150 --> 00:51:50,700
嘿，嘗試用它來存儲號碼
13通過另一個指針，Y。

1166
00:51:50,700 --> 00:51:51,840
>>  - 確定。

1167
00:51:51,840 --> 00:51:56,270
我只是去在這裡為y，
並獲得了13號的設置。

1168
00:51:56,270 --> 00:52:00,380
再取的魔杖
提領和just--

1169
00:52:00,380 --> 00:52:01,646
>> [蜂鳴聲]

1170
00:52:01,646 --> 00:52:04,080
>> 哦，嘿嘿，沒有工作。

1171
00:52:04,080 --> 00:52:06,470
再說了，呃，賓基，我不
想提領

1172
00:52:06,470 --> 00:52:10,850
y是一個好主意，因為設置
向上指針對象是一個獨立的步驟。

1173
00:52:10,850 --> 00:52:12,480
而且我不認為我們曾經做到了。

1174
00:52:12,480 --> 00:52:14,620
>> -Hmm，好點。

1175
00:52:14,620 --> 00:52:19,810
>> 是啊，我們分配的指針，Y，但
我們從來沒有將其設置為指向一個指針對象。

1176
00:52:19,810 --> 00:52:21,590
>> -Hmm，非常細心。

1177
00:52:21,590 --> 00:52:23,215
 - 嘿，你在尋找好的有，賓基。

1178
00:52:23,215 --> 00:52:26,390
你能解決這個問題，從而y點
到相同的指針對象為x。

1179
00:52:26,390 --> 00:52:29,290
>> -sure，我用我的魔杖
的指針賦值。

1180
00:52:29,290 --> 00:52:31,970
>> -is這將是一個
問題，像以前一樣？

1181
00:52:31,970 --> 00:52:33,790
>> 不，這不碰指針對象。

1182
00:52:33,790 --> 00:52:35,840
它只是變化為一指針
向指向同一件事 - 

1183
00:52:35,840 --> 00:52:36,465
>> [爆裂聲]

1184
00:52:36,465 --> 00:52:37,450
--as另一回事。

1185
00:52:37,450 --> 00:52:38,440
>> 哦，我明白了。

1186
00:52:38,440 --> 00:52:41,200
現在Ÿ指向同一個地方為x。

1187
00:52:41,200 --> 00:52:42,950
因此，等待，現在y的固定。

1188
00:52:42,950 --> 00:52:44,110
它有一個指針對象。

1189
00:52:44,110 --> 00:52:47,779
所以，你可以嘗試的魔杖
再次提領送13以上。

1190
00:52:47,779 --> 00:52:51,110
>> 哦，好了，在這裡不用。

1191
00:52:51,110 --> 00:52:52,330
>>  - 嘿，看那個。

1192
00:52:52,330 --> 00:52:53,570
現在提領Y上的作品。

1193
00:52:53,570 --> 00:52:57,900
而由於指針共享
一個指針對象，他們都看到了13。

1194
00:52:57,900 --> 00:52:59,952
>>  - 是的，共享的，呃，等等。

1195
00:52:59,952 --> 00:53:01,535
所以，我們要現在進行切換的地方？

1196
00:53:01,535 --> 00:53:03,730
>> 哦，看我們沒時間了。

1197
00:53:03,730 --> 00:53:04,660
>> -But--

1198
00:53:04,660 --> 00:53:06,520
>>  - 僅僅記住三個指針規則。

1199
00:53:06,520 --> 00:53:09,550
號1，基本結構
是你有一個指針，

1200
00:53:09,550 --> 00:53:11,630
它指向了一個指針對象。

1201
00:53:11,630 --> 00:53:13,740
但指針和
指針對象是分開的。

1202
00:53:13,740 --> 00:53:15,620
與常見的錯誤
是建立一個指針

1203
00:53:15,620 --> 00:53:18,000
但忘了給它一個指針對象。

1204
00:53:18,000 --> 00:53:21,170
>> 2號，指針廢棄
開始於指針

1205
00:53:21,170 --> 00:53:24,020
並遵循其箭頭以上
訪問及其指針。

1206
00:53:24,020 --> 00:53:27,815
大家都知道，這只是如果有工作
為指針對象，哪一種回來

1207
00:53:27,815 --> 00:53:29,260
排除1號。

1208
00:53:29,260 --> 00:53:31,990
>> 3號，指針
任務需要一個指針

1209
00:53:31,990 --> 00:53:35,330
並將其更改為指向
相同的指針對象為另一個指針。

1210
00:53:35,330 --> 00:53:37,150
因此，在轉讓之後，
兩個指針

1211
00:53:37,150 --> 00:53:40,927
將指向相同的指針對象，
有時這就是所謂的共享。

1212
00:53:40,927 --> 00:53:42,510
而這一切就是這麼簡單，真的。

1213
00:53:42,510 --> 00:53:43,130
再見了。

1214
00:53:43,130 --> 00:53:43,475
>> [結束播放]

1215
00:53:43,475 --> 00:53:44,830
>> DAVID J.馬蘭：這就是它的CS50。

1216
00:53:44,830 --> 00:53:46,246
由於尼克Parlante教授。

1217
00:53:46,246 --> 00:53:47,730
我們會看到你下週。

1218
00:53:47,730 --> 00:53:51,706

1219
00:53:51,706 --> 00:53:56,435
>> [電子音樂播放]

1220
00:53:56,435 --> 00:57:22,775