1
00:00:00,000 --> 00:00:01,110
>> [音樂播放]

2
00:00:01,110 --> 00:00:10,567

3
00:00:10,567 --> 00:00:11,650
戴維·J·馬蘭：好吧。

4
00:00:11,650 --> 00:00:15,610
這是CS50，這
是第四週的結束。

5
00:00:15,610 --> 00:00:19,420
今天的話題之一
是數字取證的，

6
00:00:19,420 --> 00:00:20,989
藝術恢復信息。

7
00:00:20,989 --> 00:00:22,780
事實上，即使
你在中間

8
00:00:22,780 --> 00:00:25,070
現在和平就在三
和突圍，下週，

9
00:00:25,070 --> 00:00:27,880
重點將放在
正是這個領域。

10
00:00:27,880 --> 00:00:30,686
>> 因此，最酷的工作之一，我曾經
不得不回來讀研究生，

11
00:00:30,686 --> 00:00:33,560
當我工作的地方
米德爾塞克斯縣地區檢察官

12
00:00:33,560 --> 00:00:34,950
辦公，做取證工作。

13
00:00:34,950 --> 00:00:37,450
所以基本上，馬薩諸塞州
國家警察，有時，

14
00:00:37,450 --> 00:00:40,100
在案件工作時，會
帶來的東西像硬盤驅動器

15
00:00:40,100 --> 00:00:42,185
和軟盤和
存儲卡等。

16
00:00:42,185 --> 00:00:44,060
他們會交給他們
我和我的導師，

17
00:00:44,060 --> 00:00:48,070
我們的目標是要找到證據，
如果有可能對這些媒體。

18
00:00:48,070 --> 00:00:50,700
現在，你可能已經看到一瞥
這個世界取證的

19
00:00:50,700 --> 00:00:53,000
在媒體，電視和電影。

20
00:00:53,000 --> 00:00:55,730
但這份工作，我曾和
敢說這世界上，

21
00:00:55,730 --> 00:00:57,550
是不是很喜歡，你會看到它。

22
00:00:57,550 --> 00:01:00,794
讓我們來看看有哪些
你可能已經看到了。

23
00:01:00,794 --> 00:01:01,460
[視頻回放]

24
00:01:01,460 --> 00:01:02,930
 - 確定。

25
00:01:02,930 --> 00:01:05,380
現在，讓我們好好看看你。

26
00:01:05,380 --> 00:01:06,850
>> [音樂播放]

27
00:01:06,850 --> 00:01:12,260

28
00:01:12,260 --> 00:01:12,932
>> -hold它。

29
00:01:12,932 --> 00:01:13,657
跑了回來。

30
00:01:13,657 --> 00:01:14,733
>>  - 等待一分鐘。

31
00:01:14,733 --> 00:01:15,233
向右走。

32
00:01:15,233 --> 00:01:16,371

33
00:01:16,371 --> 00:01:16,870
-There。

34
00:01:16,870 --> 00:01:17,369
凍結。

35
00:01:17,369 --> 00:01:17,930
 - 全屏幕。

36
00:01:17,930 --> 00:01:18,376
>>  - 確定。

37
00:01:18,376 --> 00:01:18,875
凍結。

38
00:01:18,875 --> 00:01:20,160
向上擰得過緊上，你願意嗎？

39
00:01:20,160 --> 00:01:22,126
>> -Vector在上
小伙的後輪。

40
00:01:22,126 --> 00:01:24,435
>> -zoom在這裡在這一點上。

41
00:01:24,435 --> 00:01:28,580
>>  - 帶有合適的設備中，
圖像可以放大和激化。

42
00:01:28,580 --> 00:01:29,330
>>  - 什麼是什麼？

43
00:01:29,330 --> 00:01:30,780
>>  - 它是一個提升計劃。

44
00:01:30,780 --> 00:01:32,170
>>  - 你能清楚了沒有？

45
00:01:32,170 --> 00:01:33,070
>>  - 我不知道。

46
00:01:33,070 --> 00:01:34,150
讓我們增強了。

47
00:01:34,150 --> 00:01:35,440
>>  - 增強部分A6。

48
00:01:35,440 --> 00:01:36,570

49
00:01:36,570 --> 00:01:38,562
í增強的細節，還有 - 

50
00:01:38,562 --> 00:01:40,020
 - 我認為有足夠的提升。

51
00:01:40,020 --> 00:01:40,976
它釋放到我的屏幕。

52
00:01:40,976 --> 00:01:42,559
>>  - 我增強了她的眼睛反射。

53
00:01:42,559 --> 00:01:44,322
 - 讓我們通過運行這個
視頻增強。

54
00:01:44,322 --> 00:01:45,210
>> -Edgar，可以加強這方面的？

55
00:01:45,210 --> 00:01:45,710
>> -hang上。

56
00:01:45,710 --> 00:01:47,570

57
00:01:47,570 --> 00:01:49,458
>> -I've一直在研究這種反映。

58
00:01:49,458 --> 00:01:50,402
>> -There的人的反思。

59
00:01:50,402 --> 00:01:50,902
>>  - 反射。

60
00:01:50,902 --> 00:01:52,870
-There是男人的臉的反映。

61
00:01:52,870 --> 00:01:53,694
>> -The反思！

62
00:01:53,694 --> 00:01:54,610
-There的一個反映。

63
00:01:54,610 --> 00:01:55,880
-zoom在上鏡。

64
00:01:55,880 --> 00:01:57,860
你可以看到一個反映。

65
00:01:57,860 --> 00:01:59,630
>>  - 你能在這裡提升形象？

66
00:01:59,630 --> 00:02:00,377

67
00:02:00,377 --> 00:02:01,210
 - 你能提高嗎？

68
00:02:01,210 --> 00:02:02,190
 - 你能提高嗎？

69
00:02:02,190 --> 00:02:03,066
 - 可我們加強這方面的？

70
00:02:03,066 --> 00:02:03,898
 - 你能提高嗎？

71
00:02:03,898 --> 00:02:04,740
-hold在第二。

72
00:02:04,740 --> 00:02:05,281
我會加強。

73
00:02:05,281 --> 00:02:06,470
-zoom在門上。

74
00:02:06,470 --> 00:02:06,970
-Times 10。

75
00:02:06,970 --> 00:02:08,009
-zoom。

76
00:02:08,009 --> 00:02:08,509
-Move英寸

77
00:02:08,509 --> 00:02:09,340
 - 更多。

78
00:02:09,340 --> 00:02:10,094
-wait，停止。

79
00:02:10,094 --> 00:02:10,750
-stop。

80
00:02:10,750 --> 00:02:11,250
-pause它。

81
00:02:11,250 --> 00:02:13,542
-rotate我們75度
繞垂直，請。

82
00:02:13,542 --> 00:02:14,750

83
00:02:14,750 --> 00:02:16,127
>> -stop。

84
00:02:16,127 --> 00:02:19,330
回去的一部分
關於門了。

85
00:02:19,330 --> 00:02:21,420
>> -Got圖像增強器，可以位圖？

86
00:02:21,420 --> 00:02:24,420
>>  - 也許我們可以使用普拉迪普·辛格
方法看進窗戶。

87
00:02:24,420 --> 00:02:25,902
>> -The軟件是最先進的。

88
00:02:25,902 --> 00:02:26,866
>> -The特徵值是關閉的。

89
00:02:26,866 --> 00:02:29,758
>>  - 隨著權
algorithms--組合

90
00:02:29,758 --> 00:02:32,168
>>  - 他的拍攝照明
算法，以一個新的水平，

91
00:02:32,168 --> 00:02:34,110
我可以用它們來
加強這方面的照片。

92
00:02:34,110 --> 00:02:36,840
>> -lock上並放大的z軸。

93
00:02:36,840 --> 00:02:37,351
>>  - 增強。

94
00:02:37,351 --> 00:02:37,850
增強。

95
00:02:37,850 --> 00:02:38,720
 - 增強。

96
00:02:38,720 --> 00:02:40,070
-freeze和提高。

97
00:02:40,070 --> 00:02:43,420
[完視頻回放]

98
00:02:43,420 --> 00:02:45,830
戴維·J·馬蘭：所以這些都是
所有的話，但他們並不

99
00:02:45,830 --> 00:02:47,870
句子中的正確使用。

100
00:02:47,870 --> 00:02:52,370
而事實上，在未來，任何時候
拜託，你聽到有人說一句話，

101
00:02:52,370 --> 00:02:54,250
“提升，”輕笑只是一點點。

102
00:02:54,250 --> 00:02:57,190
因為當你試圖提升，
舉例來說，這是發生了什麼。

103
00:02:57,190 --> 00:02:58,580
>> 因此，這裡是一個美麗的照片。

104
00:02:58,580 --> 00:02:59,720
這是CS50自己Daven。

105
00:02:59,720 --> 00:03:03,740
並假設我們想
聚焦於眨了一下眼睛，

106
00:03:03,740 --> 00:03:05,870
或的反射
壞傢伙，顯然是

107
00:03:05,870 --> 00:03:07,820
由安全攝像機拍攝的。

108
00:03:07,820 --> 00:03:10,330
這是發生了什麼時
你放大圖像上

109
00:03:10,330 --> 00:03:14,060
只有數量有限
與它相關聯的位。

110
00:03:14,060 --> 00:03:15,420
>> 這是你會得到什麼。

111
00:03:15,420 --> 00:03:19,190
事實上，在Daven的眼睛
不過是4，也許6個像素

112
00:03:19,190 --> 00:03:22,110
這構成什麼
在若隱若現的存在。

113
00:03:22,110 --> 00:03:25,890
所以，習題集四將最終有
你探索這個世界上，特別是

114
00:03:25,890 --> 00:03:28,090
由一些性質
我們所說的文件I / O，其中

115
00:03:28,090 --> 00:03:31,000
I / O是只是一種奇特的方式
說的輸入和輸出。

116
00:03:31,000 --> 00:03:34,280
>> 所以到目前為止，所有的相互作用
我們已經與一台電腦

117
00:03:34,280 --> 00:03:36,770
已在很大程度上與
鍵盤和屏幕

118
00:03:36,770 --> 00:03:40,770
但沒有這麼多的硬盤，
或保存文件的超越了那些你

119
00:03:40,770 --> 00:03:41,620
自己寫的。

120
00:03:41,620 --> 00:03:44,570
你的計劃迄今有
未建立和保存，

121
00:03:44,570 --> 00:03:46,270
並更新自己的文件。

122
00:03:46,270 --> 00:03:47,150
>> 那麼，什麼是文件？

123
00:03:47,150 --> 00:03:48,105
嗯，有點像JPEG格式。

124
00:03:48,105 --> 00:03:50,520
這是一個形象，你可能
有或上傳至Facebook，

125
00:03:50,520 --> 00:03:51,690
或者看到在網絡上的任何地方。

126
00:03:51,690 --> 00:03:54,460
事實上，那張照片我們只是
Daven的看到的是JPEG格式。

127
00:03:54,460 --> 00:03:57,570
而有趣
關於類似的JPEG文件

128
00:03:57,570 --> 00:04:02,170
是，它們可以被識別，
典型地，通過比特某些型態。

129
00:04:02,170 --> 00:04:05,200
>> 換句話說，它是什麼，
區分JPEG格式從一個GIF

130
00:04:05,200 --> 00:04:08,109
從一個Word一個PING
從Excel文件中的文件？

131
00:04:08,109 --> 00:04:09,900
好吧，這只是不同
比特模式。

132
00:04:09,900 --> 00:04:12,820
而這些不同的圖案
通常，在這些文件的開始處。

133
00:04:12,820 --> 00:04:18,200
>> 所以，當您的計算機打開一個Word
DOC，或當計算機打開一個JPEG，

134
00:04:18,200 --> 00:04:20,940
它的外觀通常是在
第一數位的文件中。

135
00:04:20,940 --> 00:04:24,059
如果它識別出模式，
它說，哦，這是一個形象。

136
00:04:24,059 --> 00:04:25,850
讓我展示給
用戶為圖形。

137
00:04:25,850 --> 00:04:27,870
或者說，哦，這看起來像一個Word文檔。

138
00:04:27,870 --> 00:04:30,480
讓我展示給用戶的一篇文章。

139
00:04:30,480 --> 00:04:33,020
>> 因此，例如，JPEG文件，
事實證明，有

140
00:04:33,020 --> 00:04:35,460
相當複雜
引擎蓋下方。

141
00:04:35,460 --> 00:04:40,140
但在大多數每前三字節
JPEG開始與這三個數字。

142
00:04:40,140 --> 00:04:44,680
這樣字節零個，一個，另外兩個是，在
最每JPEG，255，則該數

143
00:04:44,680 --> 00:04:46,675
216，然後是電話號碼255。

144
00:04:46,675 --> 00:04:48,990
>> ，你就可以什麼
開始做下週

145
00:04:48,990 --> 00:04:52,920
其實底下戳
文件的引擎蓋像JPEG圖片

146
00:04:52,920 --> 00:04:57,210
而像位圖文件，並查看
什麼是一直存在的，只要

147
00:04:57,210 --> 00:04:58,650
當你使用計算機已經。

148
00:04:58,650 --> 00:05:01,860
>> 但是，什麼是不存在一般
寫的十進制數是這樣的。

149
00:05:01,860 --> 00:05:04,620
計算機科學家不
往往在小數點說話。

150
00:05:04,620 --> 00:05:06,139
他們沒有真正的二進制說話。

151
00:05:06,139 --> 00:05:07,930
通常，當我們想
來表達數字，

152
00:05:07,930 --> 00:05:10,710
我們實際使用十六進制，
您可能還記得

153
00:05:10,710 --> 00:05:13,027
，比如說，從習題集
一，它挑戰

154
00:05:13,027 --> 00:05:14,610
你想想不同的系統。

155
00:05:14,610 --> 00:05:17,170
>> 當然，我們都是熟悉的
與小數，0至9。

156
00:05:17,170 --> 00:05:18,215
我們談到了二進制。

157
00:05:18,215 --> 00:05:20,710
我們真的沒有
用這麼多在這裡

158
00:05:20,710 --> 00:05:22,470
對了，因為電腦會使用它。

159
00:05:22,470 --> 00:05:24,900
但是，程序員會很
常常，但不總是，

160
00:05:24,900 --> 00:05:29,360
用十六進制，這只是意味著
你有你的字母表16個字母，

161
00:05:29,360 --> 00:05:31,330
相對於兩個或兩個10。

162
00:05:31,330 --> 00:05:34,530
>> 那麼，你如何指望更高
比十六進制9？

163
00:05:34,530 --> 00:05:41,120
你去0，1，2，3，4，5，6，7，8，9，
A，B，C，D，E，F，只是約定。

164
00:05:41,120 --> 00:05:43,540
但是，什麼是關鍵的是，每個
這是一個象徵。

165
00:05:43,540 --> 00:05:44,340
有沒有10。

166
00:05:44,340 --> 00:05:48,400
有沒有11本身，因為每
你的數字，就像在小數

167
00:05:48,400 --> 00:05:51,940
而就像在二進制，應該只是
是單個字符，按照約定。

168
00:05:51,940 --> 00:05:55,280
>> 所以這則是我們的字母表
我們所掌握的十六進制數。

169
00:05:55,280 --> 00:05:58,600
那麼什麼是JPEG格式的樣子，如果你
要寫出那些前三

170
00:05:58,600 --> 00:06:01,980
不是字節為十進制但是，
例如，為十六進制？

171
00:06:01,980 --> 00:06:03,640
而為什麼是十六進制，甚至所有有用嗎？

172
00:06:03,640 --> 00:06:05,290
>> 好了，快看一個例子。

173
00:06:05,290 --> 00:06:09,030
所以，如果我寫出來的比特
代表這些小數numbers--

174
00:06:09,030 --> 00:06:12,450
這可能是一個有點生疏
現在從幾個星期前，

175
00:06:12,450 --> 00:06:14,820
但左1和
合適的人是很容易。

176
00:06:14,820 --> 00:06:17,990
255是最大的數字，我們
可以代表與八位。

177
00:06:17,990 --> 00:06:18,820
這是所有的人。

178
00:06:18,820 --> 00:06:21,320
因此，只有一個是輕度
有趣的是中間的一個。

179
00:06:21,320 --> 00:06:24,700
善良的，如果你做出來的
數學，你會推斷出，事實上，

180
00:06:24,700 --> 00:06:27,949
一個是模式，
零代表216。

181
00:06:27,949 --> 00:06:30,240
所以我們只訂定
現在，這些都是正確的。

182
00:06:30,240 --> 00:06:31,730
但為什麼這很有趣？

183
00:06:31,730 --> 00:06:33,970
>> 好了，一個字節，當然，為8位。

184
00:06:33,970 --> 00:06:38,980
而事實證明，如果你認為
一個字節的四位兩個大塊，

185
00:06:38,980 --> 00:06:39,500
像這樣。

186
00:06:39,500 --> 00:06:41,000
讓我補充一些空間。

187
00:06:41,000 --> 00:06:42,550
所以在後。

188
00:06:42,550 --> 00:06:46,520
我只是添加了一些空白
可視化的緣故這裡。

189
00:06:46,520 --> 00:06:51,840
我們怎麼可能現在代表，
比方說，十六進制位各四，

190
00:06:51,840 --> 00:06:52,880
每個四位組？

191
00:06:52,880 --> 00:06:56,420
>> 因此，例如，在左側
現在，我們有1111的二進制文件。

192
00:06:56,420 --> 00:07:00,420
什麼是十進制的數字，
如果你做出來的數學？

193
00:07:00,420 --> 00:07:03,780
你有那些地方，三三兩兩的地方，
四肢著地的地方，和八分的地方。

194
00:07:03,780 --> 00:07:04,341
>> 聽眾：15。

195
00:07:04,341 --> 00:07:05,340
戴維·J·馬蘭：這是15。

196
00:07:05,340 --> 00:07:08,340
因此，如果我們做的八加4
加二加一，得到15。

197
00:07:08,340 --> 00:07:11,790
所以，我可以寫下15以下
1111，但這裡的整點

198
00:07:11,790 --> 00:07:13,190
是十六進制，十進制沒有。

199
00:07:13,190 --> 00:07:17,310
所以不是寫下15，1-5，
我要編寫十六進制，

200
00:07:17,310 --> 00:07:22,311
而如果你想回來，如果你有
零到f，什麼15將是？

201
00:07:22,311 --> 00:07:22,810
聽眾：F。

202
00:07:22,810 --> 00:07:24,434
戴維·J·馬蘭：那麼原來它的F。

203
00:07:24,434 --> 00:07:29,140
而且你可以工作了這一點說，
還有，如果是10，然後單擊OK，f為15。

204
00:07:29,140 --> 00:07:33,250
所以事實上，我們可以重寫
同一組數字為F F的。

205
00:07:33,250 --> 00:07:35,750
然後，如果我們做數學的一點，
我們推斷，該公司的D。

206
00:07:35,750 --> 00:07:38,650
八是很容易的，因為我們
有一個在八分地方。

207
00:07:38,650 --> 00:07:40,620
然後，我們有一對夫婦更多的F F的。

208
00:07:40,620 --> 00:07:44,669
>> 那麼，人類傾向於做了約定
當他們用十六進制是他們只是

209
00:07:44,669 --> 00:07:47,710
更簡潔地寫這一點，
擺脫大部分的空白。

210
00:07:47,710 --> 00:07:50,890
和剛需超清晰
讀者，這是十六進制，

211
00:07:50,890 --> 00:07:54,670
中簡單的約定
人類是你寫零

212
00:07:54,670 --> 00:07:58,000
x，它是沒有意義的其他
比的視覺識別，

213
00:07:58,000 --> 00:07:59,590
又來了一個十六進制數。

214
00:07:59,590 --> 00:08:04,210
>> 然後，你把兩個數字，F
f單位這種情況下，則d a，則F F。

215
00:08:04,210 --> 00:08:06,700
所以長話短說，
十六進制剛剛趨於

216
00:08:06,700 --> 00:08:11,990
是有用的，因為它的每一個
數字，零到F，完美線條

217
00:08:11,990 --> 00:08:13,880
了四個比特的圖案。

218
00:08:13,880 --> 00:08:18,080
>> 所以，如果你有兩個十六進制數字，
零到F，一遍又一遍，

219
00:08:18,080 --> 00:08:20,256
，讓你完美
8位或1字節。

220
00:08:20,256 --> 00:08:22,380
所以這就是為什麼它往往
通常是有用的。

221
00:08:22,380 --> 00:08:24,990
有沒有智慧
內容真的除此之外，

222
00:08:24,990 --> 00:08:27,010
比其實際效用等。

223
00:08:27,010 --> 00:08:29,310
>> 現在JPEG文件不是唯一
文件格式的圖形。

224
00:08:29,310 --> 00:08:33,230
您可能還記得，有
像這樣的文件在世界上，

225
00:08:33,230 --> 00:08:34,830
至少從幾年前。

226
00:08:34,830 --> 00:08:37,580
>> 因此，這實際上是
安裝在Windows XP中

227
00:08:37,580 --> 00:08:39,960
對數以百萬計的世界各地的個人電腦。

228
00:08:39,960 --> 00:08:43,000
這是一個位圖文件，BMP。

229
00:08:43,000 --> 00:08:47,690
和位圖文件，你會看到下一個
本週，只是意味著圓點的圖案，

230
00:08:47,690 --> 00:08:51,710
因為他們是所謂的像素，
一張地圖上的位，真的。

231
00:08:51,710 --> 00:08:55,160
>> 那麼，什麼是有趣的，但是，
這個文件格式，BMP，是

232
00:08:55,160 --> 00:08:58,590
該發動機罩的下面，它
已經不僅僅是三個字節

233
00:08:58,590 --> 00:09:01,020
，組成它的頭，所以
可以說，最初的幾個叮咬。

234
00:09:01,020 --> 00:09:03,330
實際上，它看起來有點
乍看複雜。

235
00:09:03,330 --> 00:09:04,704
你會看到這個在P組。

236
00:09:04,704 --> 00:09:06,810
和得到的東西
特別是出了現在這個

237
00:09:06,810 --> 00:09:10,720
不那麼重要，因為只是事實
即在每一個位圖的開始

238
00:09:10,720 --> 00:09:13,823
文件以圖形格式，
還有一大堆數字。

239
00:09:13,823 --> 00:09:14,980

240
00:09:14,980 --> 00:09:16,720
>> 現在，微軟，
這種格式的作家，

241
00:09:16,720 --> 00:09:18,820
往往那些打電話
事情不是整數和字符

242
00:09:18,820 --> 00:09:22,259
和花車，但文字和D
單詞和長和字節。

243
00:09:22,259 --> 00:09:23,800
所以，他們只是不同的數據類型。

244
00:09:23,800 --> 00:09:25,170
他們是不同的名字
同樣的事情。

245
00:09:25,170 --> 00:09:26,740
但你會看到，在P設定四。

246
00:09:26,740 --> 00:09:31,450
>> 但是這僅僅是說，如果一個人的
雙擊某些文件.BMP他

247
00:09:31,450 --> 00:09:35,015
或她的硬盤驅動器，並打開一個窗口
一個顯示他或她的形象，

248
00:09:35,015 --> 00:09:38,500
發生因為操作
系統想必注意到，不僅

249
00:09:38,500 --> 00:09:41,460
.BMP文件擴展名
在文件名中，

250
00:09:41,460 --> 00:09:45,010
而且事實上，有一些
公約比特模式

251
00:09:45,010 --> 00:09:47,490
在開始的時候
位圖文件。

252
00:09:47,490 --> 00:09:50,270
>> 但是，讓我們現在專注於
這樣一個複雜的文件，

253
00:09:50,270 --> 00:09:52,120
而是對這樣的事情。

254
00:09:52,120 --> 00:09:55,190
這裡假設gedit中，我
只是開端

255
00:09:55,190 --> 00:09:57,070
的程序，非常簡單。

256
00:09:57,070 --> 00:09:58,860
我有一些包括向上頂。

257
00:09:58,860 --> 00:10:02,120
現在我已經得到了＃包括“structs.h”，但
我會回來的，在一個時刻。

258
00:10:02,120 --> 00:10:03,974
但是，該方法適用於現在。

259
00:10:03,974 --> 00:10:05,890
因此，這是一個程序
那將實施

260
00:10:05,890 --> 00:10:07,335
如處長的數據庫。

261
00:10:07,335 --> 00:10:09,710
因此，學生的數據庫，
和每一個學生在世界

262
00:10:09,710 --> 00:10:13,190
有一個名字和一個房子，可能是一些
其他的東西，但我們會保持它的簡單。

263
00:10:13,190 --> 00:10:15,140
每一個學生都有一個名字和一個房子。

264
00:10:15,140 --> 00:10:17,700
>> 所以，如果我想寫一個
計劃，其目的在生活中

265
00:10:17,700 --> 00:10:19,860
剛剛從循環
零上最多三個，

266
00:10:19,860 --> 00:10:22,070
如果有三名學生
在哈佛大學。

267
00:10:22,070 --> 00:10:25,350
我只是想，用GetString的，
每個學生的名字和房子，

268
00:10:25,350 --> 00:10:26,600
然後只是打印出來的那些。

269
00:10:26,600 --> 00:10:28,630
>> 這有點像週
其中，第二週的東西，現在，

270
00:10:28,630 --> 00:10:30,810
在這裡我只想對
環或類似的東西。

271
00:10:30,810 --> 00:10:34,500
我想打電話給GetString的幾
次，然後打印為f的幾十倍。

272
00:10:34,500 --> 00:10:37,340
所以，我怎麼可以這樣做，但是，
當這兩個名字和房子

273
00:10:37,340 --> 00:10:39,070
所涉及的每一個學生？

274
00:10:39,070 --> 00:10:42,830
>> 所以，我的第一反應可能
可以做這樣的事情。

275
00:10:42,830 --> 00:10:49,620
我會先說，好了，給我，
說，叫名字的字符串數組。

276
00:10:49,620 --> 00:10:51,530
我不想硬編碼3在這裡。

277
00:10:51,530 --> 00:10:53,064
我想要什麼就放那裡？

278
00:10:53,064 --> 00:10:55,730
所以學生們，因為這只是
在頂部聲明一個常數，

279
00:10:55,730 --> 00:10:57,860
就這樣我就不必硬編碼
3在多個地方。

280
00:10:57,860 --> 00:11:00,859
這樣一來，我可以改變它一個地方，
它影響的變化隨處可見。

281
00:11:00,859 --> 00:11:04,470
然後，我可能會做
串安置學生。

282
00:11:04,470 --> 00:11:10,250
>> 而現在，我可能會做這樣的事情
為（int i = 0;我<學生，我有用。

283
00:11:10,250 --> 00:11:14,390
所以，我打字快​​，但這是
可能熟悉的語法了。

284
00:11:14,390 --> 00:11:17,030
>> 而現在，這是更近一些。

285
00:11:17,030 --> 00:11:22,890
如果我想要把在第i個
學生的名字，我想我做到這一點。

286
00:11:22,890 --> 00:11:26,480
然後，沒有名字
但房子級別I。

287
00:11:26,480 --> 00:11:29,930
我這樣做，GetString的，並讓
我回去和修復這條線。

288
00:11:29,930 --> 00:11:30,430
同意嗎？

289
00:11:30,430 --> 00:11:31,200
不同意？

290
00:11:31,200 --> 00:11:32,366
這不是很人性化。

291
00:11:32,366 --> 00:11:33,890
我還沒有告訴用戶該怎麼做。

292
00:11:33,890 --> 00:11:36,520
>> 但現在，如果我還
希望以後，我們

293
00:11:36,520 --> 00:11:40,060
比如，打印這些東西
out--所以TODO後。

294
00:11:40,060 --> 00:11:42,330
我會做更多的
this--這無疑就是

295
00:11:42,330 --> 00:11:45,970
正確實施
越來越名字和房子，三

296
00:11:45,970 --> 00:11:48,870
它們的總的每一個，從用戶。

297
00:11:48,870 --> 00:11:51,280
>> 但是，這不是很好的設計，對不對？

298
00:11:51,280 --> 00:11:55,220
如果學生已經不僅僅是一個名字
和一所房子，但也是一個ID號，

299
00:11:55,220 --> 00:11:57,770
和一個電話號碼，
和一個電子郵件地址，

300
00:11:57,770 --> 00:12:00,280
也許一個主頁，並
也許是Twitter的手柄，

301
00:12:00,280 --> 00:12:03,730
和任意數量的其他細節
一個學生或一個人有關，

302
00:12:03,730 --> 00:12:04,610
更普遍。

303
00:12:04,610 --> 00:12:07,720
我們該如何開始添加
功能，這個程序？

304
00:12:07,720 --> 00:12:14,080
>> 嗯，我覺得最簡單的方法可能
可以做這樣的事情，比方說，

305
00:12:14,080 --> 00:12:16,490
詮釋IDS學生。

306
00:12:16,490 --> 00:12:18,380
這樣我就可以把所有的標識在了那裡。

307
00:12:18,380 --> 00:12:22,240
然後，對於一些
如電話號碼，

308
00:12:22,240 --> 00:12:24,400
我不知道如何
代表了，只是還沒有。

309
00:12:24,400 --> 00:12:30,280
因此，讓我們繼續前進，只需要調用
這個Twitter的學生，其中

310
00:12:30,280 --> 00:12:33,550
是有點怪，但 - 
和一幫更多的領域。

311
00:12:33,550 --> 00:12:36,360
>> 我已經開始有效
複製並粘貼在這裡。

312
00:12:36,360 --> 00:12:39,416
這是要相當長
笨拙的很快，對不對？

313
00:12:39,416 --> 00:12:42,290
那豈不是很好，如果有
在世界的數據結構稱為

314
00:12:42,290 --> 00:12:45,600
而不是整數或字符串，但一些
較高的水平，一個抽象，所以

315
00:12:45,600 --> 00:12:47,570
可以說，被稱為是學生嗎？

316
00:12:47,570 --> 00:12:50,220
Ç沒有配備內置
對學生的功能，

317
00:12:50,220 --> 00:12:52,260
但如果我想給它這樣的？

318
00:12:52,260 --> 00:12:55,640
>> 嗯，事實證明，我要去
打開一個名為structs.h這裡的文件，

319
00:12:55,640 --> 00:12:57,090
你可以準確的做。

320
00:12:57,090 --> 00:12:58,290
我們打算從現在開始這樣做。

321
00:12:58,290 --> 00:13:01,490
和P組三個的引擎蓋下面，
你已經這樣做了。

322
00:13:01,490 --> 00:13:05,920
有沒有這樣的事，作為一個克矩形或
在編程語言C的克橢圓形

323
00:13:05,920 --> 00:13:10,570
>> 人們在斯坦福實現這些
由此處使用這種方法的數據類型，

324
00:13:10,570 --> 00:13:13,900
宣布自己的新數據
使用new關鍵字類型

325
00:13:13,900 --> 00:13:16,744
所謂的結構，另一個
一個叫的typedef。

326
00:13:16,744 --> 00:13:19,660
而事實上，即使語法
看上去從東西有點不同

327
00:13:19,660 --> 00:13:23,550
我們已經看到過，在
原則上，這是超級簡單。

328
00:13:23,550 --> 00:13:25,297
>> 這只是意味著“定義一個類型。”

329
00:13:25,297 --> 00:13:27,255
這將是一個
結構和結構

330
00:13:27,255 --> 00:13:29,400
就像是一個容器
多重的東西。

331
00:13:29,400 --> 00:13:31,780
而這個結構是怎麼回事
有一個名為name的字符串，

332
00:13:31,780 --> 00:13:33,210
和一個字符串名為房子。

333
00:13:33,210 --> 00:13:37,520
而且，我們打電話，只是為了方便，
這整個數據結構的學生。

334
00:13:37,520 --> 00:13:40,320
>> 所以，此刻你到
分號，你現在有

335
00:13:40,320 --> 00:13:43,280
創建您自己的數據
類型稱為學生

336
00:13:43,280 --> 00:13:46,420
現在站在旁邊詮釋，
和float和char和字符串，

337
00:13:46,420 --> 00:13:50,270
和g矩形，和g橢圓形，以及任何數目的
其他的事情人發明的。

338
00:13:50,270 --> 00:13:53,340
>> 那麼什麼是這個有用
現在，如果我回去

339
00:13:53,340 --> 00:13:57,430
為結構0，完成本
實施，這是我寫的

340
00:13:57,430 --> 00:14:02,080
提前在這裡，請注意，所有的
不可避免的雜亂的

341
00:14:02,080 --> 00:14:05,490
即將開始發生，因為我加入
電話號碼和鳥鳴和所有

342
00:14:05,490 --> 00:14:07,370
這些其他的事情
學生的定義，

343
00:14:07,370 --> 00:14:11,810
現在它簡潔地包裹起來
因為只有一個陣列的學生。

344
00:14:11,810 --> 00:14:15,500
>> 而每個學生的現在
擁有它裡面多的東西。

345
00:14:15,500 --> 00:14:16,930
因此，僅僅留下一個問題。

346
00:14:16,930 --> 00:14:19,700
你怎麼看名字搞定，
和房子，和ID，

347
00:14:19,700 --> 00:14:21,640
和任何其他的
裡面的學生？

348
00:14:21,640 --> 00:14:22,930
超級簡單的，也是如此。

349
00:14:22,930 --> 00:14:25,730
新的語法，但一個簡單的想法。

350
00:14:25,730 --> 00:14:29,239
>> 您只需索引數組，
正如我們上週和這一樣。

351
00:14:29,239 --> 00:14:31,030
什麼是明確的
新片語法？

352
00:14:31,030 --> 00:14:32,590

353
00:14:32,590 --> 00:14:35,880
只是，，意為“進去了
結構，並得到現場叫

354
00:14:35,880 --> 00:14:39,030
名，拿到所謂的房子現場，
讓學生稱為該領域。“

355
00:14:39,030 --> 00:14:41,940
>> 因此，在P設定三，如果你
還在努力的，

356
00:14:41,940 --> 00:14:44,020
和大多數人仍
是，要認識到你

357
00:14:44,020 --> 00:14:46,130
開始使用類似的東西
克rects和g橢圓形

358
00:14:46,130 --> 00:14:50,201
和其他的東西似乎沒有了
來自週零個，一個或兩個，

359
00:14:50,201 --> 00:14:52,950
意識到這是因為斯坦福大學
宣布了一些新的數據類型。

360
00:14:52,950 --> 00:14:56,160
>> 事實上，這也正是我們將
什麼時候，以及在P設定四，

361
00:14:56,160 --> 00:14:59,880
我們先來處理事情
像的圖像，位圖，等等。

362
00:14:59,880 --> 00:15:02,882
所以，這只是一個玩笑話和
心智模式是什麼來。

363
00:15:02,882 --> 00:15:04,590
現在，我一拖再拖
有些今天上午。

364
00:15:04,590 --> 00:15:09,560
我是那種好奇，想看看是什麼
其實微軟壁紙

365
00:15:09,560 --> 00:15:10,310
貌似今天。

366
00:15:10,310 --> 00:15:15,200
而事實證明，一個人在2006年
居然跑到幾乎一樣，

367
00:15:15,200 --> 00:15:19,210
在同一地點，以在現實中拍攝
什麼樣子的，這些天。

368
00:15:19,210 --> 00:15:21,380
本場現在是有點雜草叢生。

369
00:15:21,380 --> 00:15:24,850
>> 因此，圖像的現在來講，
讓我們帶回Daven這裡

370
00:15:24,850 --> 00:15:26,890
屏幕和Nicholas上，
而只是提醒你

371
00:15:26,890 --> 00:15:30,540
如果你想和我們一起吃午飯
本週五，頭我們平常網址

372
00:15:30,540 --> 00:15:31,440
這裡。

373
00:15:31,440 --> 00:15:33,530
>> 那麼，我們曾在週一離開了嗎？

374
00:15:33,530 --> 00:15:35,140
我們推出了這個問題，對不對？

375
00:15:35,140 --> 00:15:37,610
這看似是一個正確的
實現交換的，

376
00:15:37,610 --> 00:15:40,460
因此你要帶兩個整數，
一個叫A，一個叫B，

377
00:15:40,460 --> 00:15:44,130
交換它們，就像勞拉在這裡做
在與牛奶和水的階段，

378
00:15:44,130 --> 00:15:46,820
通過使用臨時
變量或空杯，

379
00:15:46,820 --> 00:15:50,540
這樣我們就可以把B，在和中
b移動，而不做亂七八糟的東西。

380
00:15:50,540 --> 00:15:51,560
我們用一個變量。

381
00:15:51,560 --> 00:15:52,870
這就是所謂的溫度。

382
00:15:52,870 --> 00:15:55,520
>> 但是，什麼是根本
問題在週一這個代碼？

383
00:15:55,520 --> 00:15:57,700

384
00:15:57,700 --> 00:15:58,870
是什麼問題就在這裡？

385
00:15:58,870 --> 00:16:00,106

386
00:16:00,106 --> 00:16:00,605
是啊。

387
00:16:00,605 --> 00:16:01,970
>> 聽眾：它佔用更多的空間。

388
00:16:01,970 --> 00:16:04,719
>> 戴維·J·馬蘭：佔用更多
空間，因為我使用的是可變的，

389
00:16:04,719 --> 00:16:05,400
那沒關係。

390
00:16:05,400 --> 00:16:07,300
這是事實，但我
會說沒關係。

391
00:16:07,300 --> 00:16:10,030
這只是32大位
物聯網方案，所以沒什麼大不了的。

392
00:16:10,030 --> 00:16:10,655
其他的想法？

393
00:16:10,655 --> 00:16:12,572
聽眾：這只是交換
這些變量在本地。

394
00:16:12,572 --> 00:16:13,571
戴維·J·馬蘭：沒錯。

395
00:16:13,571 --> 00:16:15,090
它只能在本地交換的變量。

396
00:16:15,090 --> 00:16:18,173
因為任何時候你調用一個函數 - 
當我從安嫩伯格托盤

397
00:16:18,173 --> 00:16:19,840
最後一次，你主要在底部。

398
00:16:19,840 --> 00:16:23,560
只要您撥打一個叫做函數
掉期，掉期沒有得到x和y，

399
00:16:23,560 --> 00:16:24,400
原來的值。

400
00:16:24,400 --> 00:16:26,392
什麼交換的GET，我們什麼要求？

401
00:16:26,392 --> 00:16:27,100
聽眾：複製。

402
00:16:27,100 --> 00:16:28,090
戴維·J·馬蘭：所以他們的副本。

403
00:16:28,090 --> 00:16:31,120
所以它得到一個和兩個，如果
記得上次的例子，

404
00:16:31,120 --> 00:16:34,730
但是一個和兩個副本
被成功交換。

405
00:16:34,730 --> 00:16:38,550
但不幸的是，最終，
這些值仍然是相同的。

406
00:16:38,550 --> 00:16:41,880
因此，我們可以看到這與我們的
新朋友，希望廣發行，

407
00:16:41,880 --> 00:16:45,180
您或轉錄因子和Ca的有
在指導你走向如下。

408
00:16:45,180 --> 00:16:51,210
>> 因此，沒有掉召回看起來like--我們
開拓this--看起來像這樣。

409
00:16:51,210 --> 00:16:54,160
我們初始化X要1，Y兩。

410
00:16:54,160 --> 00:16:55,620
有一堆打印F公司。

411
00:16:55,620 --> 00:16:58,080
但隨後，該按鍵通話
這裡是交換，這

412
00:16:58,080 --> 00:17:00,260
正是我們的代碼
就是剛才看到的。

413
00:17:00,260 --> 00:17:03,180
這是正確的，在第一
一目了然，但在功能上，

414
00:17:03,180 --> 00:17:06,800
這個方案行不通，因為
它不會永久交換x和y。

415
00:17:06,800 --> 00:17:10,190
>> 因此，讓我們看到這個，咋暖
在這裡用GDB中，./noswap。

416
00:17:10,190 --> 00:17:11,867

417
00:17:11,867 --> 00:17:15,200
一堆鋪天蓋地的信息
我會擺脫與控制L現在。

418
00:17:15,200 --> 00:17:17,516
而現在，我要
繼續並運行它。

419
00:17:17,516 --> 00:17:19,349
不幸的是，這
是沒有多大用處的。

420
00:17:19,349 --> 00:17:22,355
它運行的程序這裡面
程序調用GDB，調試器，

421
00:17:22,355 --> 00:17:23,730
但它並沒有讓我閒逛。

422
00:17:23,730 --> 00:17:26,229
>> 所以，我怎麼能真正暫停
執行這個程序裡面？

423
00:17:26,229 --> 00:17:27,410

424
00:17:27,410 --> 00:17:28,329
因此打破。

425
00:17:28,329 --> 00:17:32,340
我可以打破任何
行數，1，10，15。

426
00:17:32,340 --> 00:17:35,530
但我也可以打破象徵
說休息為主。

427
00:17:35,530 --> 00:17:38,980
這就是要設置一個斷點
點，顯然在主線16。

428
00:17:38,980 --> 00:17:40,050
而其中的16行？

429
00:17:40,050 --> 00:17:42,960
讓我們去到的代碼
並上升到noswap。

430
00:17:42,960 --> 00:17:46,930
事實上，第16行是
第一個在程序中。

431
00:17:46,930 --> 00:17:52,130
>> 所以，現在，如果我繼續和類型
運行這個時候，回車，就暫停。

432
00:17:52,130 --> 00:17:53,080
因此，讓我們閒逛。

433
00:17:53,080 --> 00:17:55,716
打印x--為什麼是X為零？

434
00:17:55,716 --> 00:17:56,705

435
00:17:56,705 --> 00:17:57,830
而忽略了美元符號。

436
00:17:57,830 --> 00:17:59,725
這還只是票友
使用的程序的。

437
00:17:59,725 --> 00:18:00,780

438
00:18:00,780 --> 00:18:03,140
為什麼為x為零的時刻？

439
00:18:03,140 --> 00:18:03,640
是啊。

440
00:18:03,640 --> 00:18:07,061
>> 聽眾：它暫停前的權利
線16，而不是實際的線16。

441
00:18:07,061 --> 00:18:08,060
戴維·J·馬蘭：沒錯。

442
00:18:08,060 --> 00:18:11,630
廣發行，在默認情況下，已暫停
只是線16日前執行。

443
00:18:11,630 --> 00:18:14,820
因此它沒有執行，其中
意味著x是一些不知名的價值。

444
00:18:14,820 --> 00:18:17,150
我們很幸運，它的
乾淨的東西像為零。

445
00:18:17,150 --> 00:18:20,310
所以，如果我輸入下一個，現在，
現在執行16。

446
00:18:20,310 --> 00:18:22,000
它等待我去執行17。

447
00:18:22,000 --> 00:18:23,400
讓我繼續前進，打印的X.

448
00:18:23,400 --> 00:18:24,094
這是之一。

449
00:18:24,094 --> 00:18:25,260
讓我繼續前進，印刷年。

450
00:18:25,260 --> 00:18:26,176
我現在應該看到了什麼？

451
00:18:26,176 --> 00:18:27,660

452
00:18:27,660 --> 00:18:28,560
>> 聽眾：[聽不清]

453
00:18:28,560 --> 00:18:29,165
>> 戴維·J·馬蘭：大聲一點。

454
00:18:29,165 --> 00:18:30,040
>> 聽眾：[聽不清]

455
00:18:30,040 --> 00:18:30,537

456
00:18:30,537 --> 00:18:32,120
戴維·J·馬蘭：不太一致。

457
00:18:32,120 --> 00:18:34,760
所以，是的，我們看到一些垃圾值。

458
00:18:34,760 --> 00:18:37,862
現在，y是134514064那裡。

459
00:18:37,862 --> 00:18:39,320
好吧，這只是一些垃圾值。

460
00:18:39,320 --> 00:18:41,350
我的程序使用內存
為不同的目的。

461
00:18:41,350 --> 00:18:42,350
還有其他功能。

462
00:18:42,350 --> 00:18:44,040
別人寫我的電腦裡面。

463
00:18:44,040 --> 00:18:46,789
所以這些位已經被用於
其他的價值觀，我所看到的

464
00:18:46,789 --> 00:18:49,470
是一些殘餘
在先使用該內存。

465
00:18:49,470 --> 00:18:53,350
>> 所以，沒什麼大不了的，因為一旦
我鍵入下一個，然後打印Y，

466
00:18:53,350 --> 00:18:55,640
它的初始化
我想要的價值。

467
00:18:55,640 --> 00:18:57,400
所以，現在，讓我們繼續快一點。

468
00:18:57,400 --> 00:18:58,540
n轉到下一個。

469
00:18:58,540 --> 00:18:59,570
讓我們再做一次。

470
00:18:59,570 --> 00:19:00,530
讓我們再做一次。

471
00:19:00,530 --> 00:19:02,404
但我不想打
在這裡，因為如果我

472
00:19:02,404 --> 00:19:05,110
想看看裡面有什麼事情
掉，有什麼命令？

473
00:19:05,110 --> 00:19:05,520
>> 聽眾：步驟。

474
00:19:05,520 --> 00:19:06,436
>> 戴維·J·馬蘭：步驟。

475
00:19:06,436 --> 00:19:09,800
所以這個步驟我變成了
功能，而不是通過它。

476
00:19:09,800 --> 00:19:12,270
而現在，這是一個有點神秘
說實話，但是這僅僅是

477
00:19:12,270 --> 00:19:14,581
告訴我，我在第33行了。

478
00:19:14,581 --> 00:19:15,580
讓我們再次做到這一點。

479
00:19:15,580 --> 00:19:16,080
打印溫度。

480
00:19:16,080 --> 00:19:17,129

481
00:19:17,129 --> 00:19:20,170
垃圾值，負此時，
但是這仍然只是一個垃圾值。

482
00:19:20,170 --> 00:19:22,810
因此，讓我們做下一個，打印溫度。

483
00:19:22,810 --> 00:19:27,130
它初始化為1，這
是x的值，也叫做。

484
00:19:27,130 --> 00:19:29,110
>> 現在，這裡是我們的a和從X來了嗎？

485
00:19:29,110 --> 00:19:32,510
好吧，注意主，我們
所謂的這些值x和y。

486
00:19:32,510 --> 00:19:34,740
然後，我們通過他們交換如下。

487
00:19:34,740 --> 00:19:37,010
點¯x排在第一位，逗號年。

488
00:19:37,010 --> 00:19:40,020
然後，交換可以稱他們為x和y。

489
00:19:40,020 --> 00:19:42,630
但為清楚起見，這是
稱他們為A和B。

490
00:19:42,630 --> 00:19:45,970
但a和b是現在將要
x和y分別的拷貝。

491
00:19:45,970 --> 00:19:50,660
>> 所以，如果我回去GDB，溫度
現在是一年，現在1。

492
00:19:50,660 --> 00:19:56,130
但是，如果我做一個和現在做的打印
A，A已經搬了過來。

493
00:19:56,130 --> 00:20:00,030
牛奶已經倒入前
橙汁的玻璃，或者反之亦然。

494
00:20:00,030 --> 00:20:04,750
>> 如果我下一次再這樣做了，現在
如果我打印出來作為一個全面的檢查，

495
00:20:04,750 --> 00:20:07,687
一是仍然是兩個，但是B現在之一。

496
00:20:07,687 --> 00:20:08,770
坦率地說，它仍然存在。

497
00:20:08,770 --> 00:20:10,670
我不在乎什麼溫度的。

498
00:20:10,670 --> 00:20:16,850
但只要我現在打字，讓我們說，
繼續回去，現在我在最後

499
00:20:16,850 --> 00:20:17,480
該程序。

500
00:20:17,480 --> 00:20:20,730
不幸的是，x是
還是1和y仍然是2。

501
00:20:20,730 --> 00:20:22,272
>> 那麼，什麼是有GDB的效用？

502
00:20:22,272 --> 00:20:23,980
它沒有幫我解決
該問題本身，

503
00:20:23,980 --> 00:20:26,265
但它希望能幫助我
理解它通過實現

504
00:20:26,265 --> 00:20:30,000
，是的，我的邏輯是對的，但
我的代碼是不是最終有

505
00:20:30,000 --> 00:20:31,450
產生長遠的影響。

506
00:20:31,450 --> 00:20:34,570
所以這是一個問題，我們
要解決現在今天。

507
00:20:34,570 --> 00:20:37,870
>> 但是，讓我們以這種方式到達那裡。

508
00:20:37,870 --> 00:20:39,230
String是一個謊言。

509
00:20:39,230 --> 00:20:41,860
它也沒有一種數據類型
存在於C.它是

510
00:20:41,860 --> 00:20:44,750
是一個代名詞一些
時間的東西，

511
00:20:44,750 --> 00:20:47,300
我們可以揭示如下。

512
00:20:47,300 --> 00:20:53,282
>> 讓我去進取，不斷開拓
一個名為比0。

513
00:20:53,282 --> 00:20:56,240
而非鍵入此一出來，
我們將開始遍歷代碼

514
00:20:56,240 --> 00:20:58,040
我已經寫了，但
這是只有幾行。

515
00:20:58,040 --> 00:20:59,570
所以這是比較-0。

516
00:20:59,570 --> 00:21:02,380
的第一件事情我做
越來越一行文本。

517
00:21:02,380 --> 00:21:05,610
>> 但是要注意什麼，我
做第一次。

518
00:21:05,610 --> 00:21:07,910
什麼是明確約21行有什麼不同？

519
00:21:07,910 --> 00:21:10,020

520
00:21:10,020 --> 00:21:11,402
其實，等一下。

521
00:21:11,402 --> 00:21:12,110
這是一份2。

522
00:21:12,110 --> 00:21:13,568
這甚至不是正確的程序。

523
00:21:13,568 --> 00:21:14,780
好吧，擾流器警報。

524
00:21:14,780 --> 00:21:16,890
好了，所以從不介意。

525
00:21:16,890 --> 00:21:18,520
這就是答案，未來的問題。

526
00:21:18,520 --> 00:21:21,450
>> 這裡是比較-0，和我
要得到一個文本行。

527
00:21:21,450 --> 00:21:22,435
程序要簡單得多。

528
00:21:22,435 --> 00:21:23,560
因此，這很簡單。

529
00:21:23,560 --> 00:21:28,070
這就好比第一週，第二週的東西
眼下。字符串s = GetString的。

530
00:21:28,070 --> 00:21:29,700
現在，我再說一遍下來這裡。

531
00:21:29,700 --> 00:21:31,830
串T = GetString的。

532
00:21:31,830 --> 00:21:35,300
然後，在該過去的事
程序，正如它的名字所暗示的，

533
00:21:35,300 --> 00:21:37,090
是我要嘗試對它們進行比較。

534
00:21:37,090 --> 00:21:40,709
>> 因此，如果S，第一個字符串，
等於= T，那麼我

535
00:21:40,709 --> 00:21:42,250
要說你輸入同樣的事情。

536
00:21:42,250 --> 00:21:44,291
否則，我會說
你輸入不同的事情。

537
00:21:44,291 --> 00:21:45,880
因此，讓我們編譯並運行這個程序。

538
00:21:45,880 --> 00:21:48,481
所以要比較為零。

539
00:21:48,481 --> 00:21:48,980
看起來不錯。

540
00:21:48,980 --> 00:21:50,490
沒有編譯錯誤。

541
00:21:50,490 --> 00:21:52,386
>> 現在讓我繼續前進
並鍵入./compare-0。

542
00:21:52,386 --> 00:21:55,230

543
00:21:55,230 --> 00:21:59,220
讓我繼續前進，說些什麼
：Daven和東西：羅伯。

544
00:21:59,220 --> 00:22:00,450
與I型不同的東西。

545
00:22:00,450 --> 00:22:01,250
到目前為止，一切都很好。

546
00:22:01,250 --> 00:22:02,680
程序似乎是正確的。

547
00:22:02,680 --> 00:22:03,880
>> 但是，讓我們再次運行它。

548
00:22:03,880 --> 00:22:05,800
說些什麼：加布。

549
00:22:05,800 --> 00:22:07,140
說些什麼：加布。

550
00:22:07,140 --> 00:22:08,520

551
00:22:08,520 --> 00:22:09,020
好吧。

552
00:22:09,020 --> 00:22:10,851
也許我打空格鍵
什麼時髦。

553
00:22:10,851 --> 00:22:11,600
讓我們再做一次。

554
00:22:11,600 --> 00:22:13,020
所以Zamyla。

555
00:22:13,020 --> 00:22:13,970

556
00:22:13,970 --> 00:22:14,470
Zamyla。

557
00:22:14,470 --> 00:22:15,740

558
00:22:15,740 --> 00:22:17,330
不同的東西。

559
00:22:17,330 --> 00:22:19,430
那麼到底是怎麼回事？

560
00:22:19,430 --> 00:22:23,200
>> 因此，我們有以下兩行
代碼的GetString被調用兩次。

561
00:22:23,200 --> 00:22:25,760
然後，我只是
試圖比較s和t。

562
00:22:25,760 --> 00:22:28,370
但真正那麼是怎麼回事？

563
00:22:28,370 --> 00:22:31,180
嗯，我的手寫的要
屠夫這個例子有點。

564
00:22:31,180 --> 00:22:34,630
而且，我們居然丟
這件事在這裡，也是如此。

565
00:22:34,630 --> 00:22:37,390

566
00:22:37,390 --> 00:22:45,712
>> 因此，我們必須像一條線
字符串s = GetString的。

567
00:22:45,712 --> 00:22:48,295
所以，這只是第一
有趣的線從該計劃中。

568
00:22:48,295 --> 00:22:49,920

569
00:22:49,920 --> 00:22:52,974
但是，這段時間一直
正在進行的引擎蓋底下？

570
00:22:52,974 --> 00:22:55,890
以及，在左手側是字符串，
這是某種類型的變量，

571
00:22:55,890 --> 00:22:56,785
而且它稱為S。

572
00:22:56,785 --> 00:23:00,019
所以，我知道，這是使用的內存，
或RAM，在我的電腦不知何故。

573
00:23:00,019 --> 00:23:02,060
所以，我要抽象
繪製一個正方形。

574
00:23:02,060 --> 00:23:04,820
32位的，它的出現，但
更多的是在未來。

575
00:23:04,820 --> 00:23:06,410
然後，這是怎麼回事了嗎？

576
00:23:06,410 --> 00:23:08,700
>> 那麼，很明顯的GetString
從用戶獲取的字符串。

577
00:23:08,700 --> 00:23:11,360
和GetString了
Zamyla或加布或Daven。

578
00:23:11,360 --> 00:23:14,640
因此，讓我們選擇第一
那些的，這是Daven。

579
00:23:14,640 --> 00:23:19,174
所以，有效，什麼的GetString了
我在第一種情況是D-A-V-E-N。

580
00:23:19,174 --> 00:23:22,690

581
00:23:22,690 --> 00:23:25,045
然後，還有什麼做
它給我的秘密？

582
00:23:25,045 --> 00:23:25,920
聽眾：[聽不清]

583
00:23:25,920 --> 00:23:28,720
戴維·J·馬蘭：是啊，
在/ 0或空字符。

584
00:23:28,720 --> 00:23:30,550
因此，有效地給了我一個字符串。

585
00:23:30,550 --> 00:23:34,550
但是，我們已經知道，從以前的
看著一個字符串只是一個數組

586
00:23:34,550 --> 00:23:37,895
字符，它的終止
這個特殊的標記字符，/ 0。

587
00:23:37,895 --> 00:23:39,220

588
00:23:39,220 --> 00:23:42,310
>> 但是，如果這是真
這是一個正方形，

589
00:23:42,310 --> 00:23:44,160
這顯然是一個更大的矩形。

590
00:23:44,160 --> 00:23:46,830
事實上，這是，
我要求中，只有32位。

591
00:23:46,830 --> 00:23:49,500
而這顯然超過32
位，因為這很可能是

592
00:23:49,500 --> 00:23:51,583
八加八加8
加八加八，

593
00:23:51,583 --> 00:23:53,320
只是因為在ASCII碼的字節。

594
00:23:53,320 --> 00:23:57,030
到底如何我們要適應
Daven到這裡這個小盒子？

595
00:23:57,030 --> 00:23:59,880
>> 那麼，什麼是GetString的真正在做什麼？

596
00:23:59,880 --> 00:24:03,680
好了，該網格在這裡代表
我的電腦的內存或RAM。

597
00:24:03,680 --> 00:24:07,564
因此，讓我們武斷地說，如果
每一個都代表一個字節，

598
00:24:07,564 --> 00:24:09,730
那麼，我們能想到的每一個
字節為具有一個地址，

599
00:24:09,730 --> 00:24:13,830
像33牛津街，或34
牛津街，或35牛津街。

600
00:24:13,830 --> 00:24:16,700
>> 所以就像家庭有地址
和建築物有地址，

601
00:24:16,700 --> 00:24:19,810
這樣做的單個字節
記憶有地址或號碼

602
00:24:19,810 --> 00:24:21,042
唯一地識別它們。

603
00:24:21,042 --> 00:24:22,000
現在，這是任意的。

604
00:24:22,000 --> 00:24:25,370
但要保持簡單，我要
用十六進制只是按照慣例，

605
00:24:25,370 --> 00:24:28,200
但0X意味著什麼等
比“，這是十六進制。”

606
00:24:28,200 --> 00:24:31,030
而我要去聲稱，
“D”結束於字節的一個存儲器中。

607
00:24:31,030 --> 00:24:34,210
>> 我沒有什麼其他的事情
內存，所以Daven拿到了第一個景點

608
00:24:34,210 --> 00:24:35,509
在字節之一。

609
00:24:35,509 --> 00:24:36,800
那麼，這將是0X2。

610
00:24:36,800 --> 00:24:37,831

611
00:24:37,831 --> 00:24:38,705
這會為0x3。

612
00:24:38,705 --> 00:24:39,840

613
00:24:39,840 --> 00:24:41,800
這將是為0x4。

614
00:24:41,800 --> 00:24:43,025
這是要為0x5。

615
00:24:43,025 --> 00:24:44,025
這將是為0x6。

616
00:24:44,025 --> 00:24:45,560

617
00:24:45,560 --> 00:24:48,290
>> 但是，一旦你開始思考
什麼電腦做的

618
00:24:48,290 --> 00:24:50,710
引擎蓋下方，
你就可以開始來推斷

619
00:24:50,710 --> 00:24:54,960
怎麼啦，幾年前，會
有C本身實現的。

620
00:24:54,960 --> 00:24:58,360
什麼是可能的GetString
returning--因為它

621
00:24:58,360 --> 00:25:00,946
感覺這不是
返回Daven，本身

622
00:25:00,946 --> 00:25:03,320
因為他肯定不會
適合在這個小box--

623
00:25:03,320 --> 00:25:05,090
那麼，什麼是可能的GetString返回？

624
00:25:05,090 --> 00:25:07,958

625
00:25:07,958 --> 00:25:08,920
>> 聽眾：[聽不清]

626
00:25:08,920 --> 00:25:10,540
>> 戴維·J·馬蘭：Daven的位置。

627
00:25:10,540 --> 00:25:12,770
而且它已經這樣做
自從第一週。

628
00:25:12,770 --> 00:25:16,150
什麼GetString的是真的
返回不是字符串，本身。

629
00:25:16,150 --> 00:25:17,780
那是善意的謊言之一。

630
00:25:17,780 --> 00:25:22,520
它返回的地址
串在存儲器中，唯一的地址。

631
00:25:22,520 --> 00:25:24,820
Daven住在33牛津街。

632
00:25:24,820 --> 00:25:29,310
但更簡潔，加文·生活
在為0x1，地址一號。

633
00:25:29,310 --> 00:25:32,280
>> 那麼，被放在這個
小盒子那麼，要清楚，

634
00:25:32,280 --> 00:25:35,930
是字符串的僅僅是地址。

635
00:25:35,930 --> 00:25:38,110
所以這一切的時候，這
已經持續。

636
00:25:38,110 --> 00:25:41,650
但是，這暗示
現在，如果所有S有

637
00:25:41,650 --> 00:25:44,710
是一個數字，它裡面，誰的
阻止你，程序員，

638
00:25:44,710 --> 00:25:47,970
從把任何數目的
任何變量，只是跳

639
00:25:47,970 --> 00:25:49,080
到的內存塊？

640
00:25:49,080 --> 00:25:51,320
事實上，我們可以看到
這是一個威脅下一次。

641
00:25:51,320 --> 00:25:53,500
>> 但現在，這種感覺不足。

642
00:25:53,500 --> 00:25:55,630
如果我說，讓我
字符串，你給我Daven。

643
00:25:55,630 --> 00:25:57,230
但是，你真的不給我Daven。

644
00:25:57,230 --> 00:25:59,310
所有你給我的是Daven的地址。

645
00:25:59,310 --> 00:26:04,310
我怎麼那麼肯定知道
其中Daven開始和ends--

646
00:26:04,310 --> 00:26:07,140
故事的越來越weird--
其中Daven的開始和結束，

647
00:26:07,140 --> 00:26:10,435
然後，下一個
字符串在內存中開始？

648
00:26:10,435 --> 00:26:11,520

649
00:26:11,520 --> 00:26:13,620
>> 好吧，如果你遞過
我Daven的開始，

650
00:26:13,620 --> 00:26:17,230
基本上，我怎麼知道
在那裡他的名字到底是？

651
00:26:17,230 --> 00:26:20,550
特別空字符，這
是更重要的，現在

652
00:26:20,550 --> 00:26:23,040
如果下面的字符串
引擎蓋只是確定

653
00:26:23,040 --> 00:26:25,820
通過唯一地在存儲器中的位置。

654
00:26:25,820 --> 00:26:28,130
所以這一切的時候，那是
什麼是怎麼回事。

655
00:26:28,130 --> 00:26:32,470
>> 所以，當我們現在看
這裡的代碼，解釋

656
00:26:32,470 --> 00:26:35,790
如果你會在第26行的錯誤。

657
00:26:35,790 --> 00:26:39,560
為什麼Zamyla和Zamyla有什麼不同？

658
00:26:39,560 --> 00:26:41,330
為什麼加布和加布有什麼不同？

659
00:26:41,330 --> 00:26:42,154
是的，在後面。

660
00:26:42,154 --> 00:26:43,390
>> 聽眾：他們有不同的地址。

661
00:26:43,390 --> 00:26:45,931
>> 戴維·J·馬蘭：很簡單，因為
他們有不同的地址。

662
00:26:45,931 --> 00:26:48,820
當你調用GetString的，因為
再次，我會盡快在這裡，

663
00:26:48,820 --> 00:26:52,870
如果這是第二行，串
T，因為我在該程序中一樣，

664
00:26:52,870 --> 00:26:55,030
等於另一個電話給GetString。

665
00:26:55,030 --> 00:26:56,370

666
00:26:56,370 --> 00:26:58,670
下一次我打電話
GetString的，我要去

667
00:26:58,670 --> 00:27:00,190
以得到不同的塊的內存。

668
00:27:00,190 --> 00:27:02,220
>> GetString的允許
問工作

669
00:27:02,220 --> 00:27:03,800
系統越來越多的內存。

670
00:27:03,800 --> 00:27:07,894
它不會重複使用相同的
六個字節每一次。

671
00:27:07,894 --> 00:27:09,810
這將得到一個新的
塊的存儲器，其中

672
00:27:09,810 --> 00:27:12,780
裝置噸是會得到
其他一些價值在這裡。

673
00:27:12,780 --> 00:27:15,380
>> 所以，當我做s等於=
T，你不比較

674
00:27:15,380 --> 00:27:17,880
ð對這個和A對
這和V反對這一點。

675
00:27:17,880 --> 00:27:19,588
你這個比較
針對這一點，這

676
00:27:19,588 --> 00:27:24,020
坦率地說是相當useful-- useless--
沒什麼用，因為誰真正

677
00:27:24,020 --> 00:27:25,830
關心那裡的字符串在內存中？

678
00:27:25,830 --> 00:27:26,850
>> 事實上，我們還沒有。

679
00:27:26,850 --> 00:27:28,980
我們不是要
啟動特別關懷。

680
00:27:28,980 --> 00:27:34,180
只是在某種程度上，錯誤可能出現
與安全的威脅可能會出現意志

681
00:27:34,180 --> 00:27:36,100
我們真正開始關心這個。

682
00:27:36,100 --> 00:27:37,230
因此，讓我們解決這個問題。

683
00:27:37,230 --> 00:27:39,650
事實證明，你解​​決它超級簡單。

684
00:27:39,650 --> 00:27:42,600
>> 而且，我們其實之前，我
再次表明，會是什麼

685
00:27:42,600 --> 00:27:47,170
怎麼做，如果在CS50類，
你不得不實施

686
00:27:47,170 --> 00:27:48,600
對兩個字符串進行比較。

687
00:27:48,600 --> 00:27:51,440
你顯然不能僅僅用s等於= T。

688
00:27:51,440 --> 00:27:54,090
但是，僅僅從邏輯上講，如何
你比較這串

689
00:27:54,090 --> 00:27:56,370
不要使用C代碼這個字符串？

690
00:27:56,370 --> 00:27:56,880
是啊。

691
00:27:56,880 --> 00:27:58,780
>> 聽眾：剛才做的
for循環[聽不清]

692
00:27:58,780 --> 00:28:00,670

693
00:28:00,670 --> 00:28:01,670
戴維·J·馬蘭：完美。

694
00:28:01,670 --> 00:28:02,900
聽眾：[聽不清]

695
00:28:02,900 --> 00:28:03,310
戴維·J·馬蘭：是的。

696
00:28:03,310 --> 00:28:05,390
只需使用一個for循環或
while循環或什麼的。

697
00:28:05,390 --> 00:28:08,710
但就應用的基本想法，如果
這是內存或陣列的塊

698
00:28:08,710 --> 00:28:11,590
這就是，遍歷
二者在同一時間。

699
00:28:11,590 --> 00:28:12,960
而只比較字母。

700
00:28:12,960 --> 00:28:14,260
>> 而且你必須是一個
小心一點，因為你

701
00:28:14,260 --> 00:28:16,247
不想一個手指
晃過對方

702
00:28:16,247 --> 00:28:18,080
因為一個字符串
比其他的長。

703
00:28:18,080 --> 00:28:21,380
所以你會想檢查
在年底這個特殊的值，則返回null。

704
00:28:21,380 --> 00:28:24,017
但它確實是，在
最後，就這麼簡單。

705
00:28:24,017 --> 00:28:26,100
坦率地說，我們不需要
重新發明了車輪。

706
00:28:26,100 --> 00:28:27,960
下面是兩個版本。

707
00:28:27,960 --> 00:28:32,910
什麼我要在這裡說的是，
而不是比較s等於= T，

708
00:28:32,910 --> 00:28:38,964
我反而要說，如果字符串
第逗號噸相比等於= 0。

709
00:28:38,964 --> 00:28:40,130
現在，什麼是字符串比較？

710
00:28:40,130 --> 00:28:43,046
>> 事實證明，這是一個函數，
帶有C，其目的在生活中

711
00:28:43,046 --> 00:28:44,650
要比較兩個字符串。

712
00:28:44,650 --> 00:28:48,300
攪拌相比，如果我們讀了
手冊頁或文檔或CS50

713
00:28:48,300 --> 00:28:50,630
參考，它會
簡單的告訴你，攪

714
00:28:50,630 --> 00:28:55,730
比較收益或者負
數或正數或零，

715
00:28:55,730 --> 00:28:57,660
其中零表示他們是平等的。

716
00:28:57,660 --> 00:28:58,570
>> 所以只是猜測。

717
00:28:58,570 --> 00:29:00,390
可能是什麼意思，如果
攪拌收益比較

718
00:29:00,390 --> 00:29:02,110
負值或正值？

719
00:29:02,110 --> 00:29:02,785

720
00:29:02,785 --> 00:29:04,285
聽眾：大於或小於。

721
00:29:04,285 --> 00:29:05,570
戴維·J·馬蘭：是啊，
大於或小於。

722
00:29:05,570 --> 00:29:08,640
所以，如果你想整個排序
在dictionary--一串字符串

723
00:29:08,640 --> 00:29:12,975
因為我們最終會下來road--
完善的功能，潛在的使用，

724
00:29:12,975 --> 00:29:15,850
因為它要做到這一點
比較字符串給你，並告訴

725
00:29:15,850 --> 00:29:20,060
你做了來自前B，或不
b來之前，按字母順序排列。

726
00:29:20,060 --> 00:29:21,490
我們正是這樣做。

727
00:29:21,490 --> 00:29:23,620
>> 而且請注意，我沒有一個其他
在本實施例中的事情。

728
00:29:23,620 --> 00:29:26,870
什麼改變了更高的
在這個主要的功能？

729
00:29:26,870 --> 00:29:28,500

730
00:29:28,500 --> 00:29:29,350
char *的。

731
00:29:29,350 --> 00:29:31,150
而這是其他善意的謊言。

732
00:29:31,150 --> 00:29:33,750
這一切的時候，當你
在寫字符串，

733
00:29:33,750 --> 00:29:38,350
我們一直在偷偷改寫
字符串為char *，這樣實際上鏗鏘

734
00:29:38,350 --> 00:29:39,270
理解你。

735
00:29:39,270 --> 00:29:42,450
>> 換句話說，在CS50.h
當我們最終會看到，

736
00:29:42,450 --> 00:29:45,950
我們做了一個代名詞叫做字符串
這是同樣的事情為char *。

737
00:29:45,950 --> 00:29:49,910
而現在，只有在知道
*，在這種情況下，至少

738
00:29:49,910 --> 00:29:51,286
裝置的地址。

739
00:29:51,286 --> 00:29:52,210
>> 什麼樣的報告？

740
00:29:52,210 --> 00:29:56,390
嗯，事實上，我說的
char *的，而不是int *或浮動*

741
00:29:56,390 --> 00:30:00,820
也就是說char *的是
一個字符的地址。

742
00:30:00,820 --> 00:30:06,770
所以這裡這個小盒子，又名
字符串，是真的char *類型，

743
00:30:06,770 --> 00:30:10,490
這是說只是一個奇特的方式，
在此框中會去的地址。

744
00:30:10,490 --> 00:30:12,430
並且這是什麼地址是指？

745
00:30:12,430 --> 00:30:13,780
顯然，一個char。

746
00:30:13,780 --> 00:30:16,410
>> 但是，我們絕對可以
必須是int *和其他的東西。

747
00:30:16,410 --> 00:30:20,790
但現在，char *的是最真的
直接的和感興趣的。

748
00:30:20,790 --> 00:30:23,310
所以這個問題是要
上升，不過，一次。

749
00:30:23,310 --> 00:30:24,830
>> 假設我打開了這個節目。

750
00:30:24,830 --> 00:30:27,670
讓我們來看看現在我們可以預測
有什麼不對的代碼。

751
00:30:27,670 --> 00:30:31,140
所以這個方案，複製0，我
要繼續前進，並再次呼籲

752
00:30:31,140 --> 00:30:34,190
GetString的並存儲在s的值。

753
00:30:34,190 --> 00:30:38,800
>> 然後，我為什麼這樣做，
只是從過去幾週的提醒？

754
00:30:38,800 --> 00:30:40,960
我們確實說的GetString
有時，則返回null。

755
00:30:40,960 --> 00:30:42,793
是什麼意思，如果
的形式返回空值？

756
00:30:42,793 --> 00:30:45,040

757
00:30:45,040 --> 00:30:46,034
出事了。

758
00:30:46,034 --> 00:30:48,950
這可能意味著該字符串是太
大，計算機的內存不足。

759
00:30:48,950 --> 00:30:51,724
它發生超，超，超
很少，但它可能發生。

760
00:30:51,724 --> 00:30:53,890
我們要檢查它，
這就是我們所做的。

761
00:30:53,890 --> 00:30:57,910
>> 因為我們現在看到的，如果你不這樣做
開始檢查習慣性的東西

762
00:30:57,910 --> 00:31:00,870
像空，你可能
真正開始去

763
00:31:00,870 --> 00:31:03,106
到存儲器中的地址是無效的。

764
00:31:03,106 --> 00:31:05,980
而你要開始誘導
越來越多的細分故障。

765
00:31:05,980 --> 00:31:08,360
或者在Mac還是PC，只要
使計算機掛起

766
00:31:08,360 --> 00:31:10,340
或程序凍結，有可能。

767
00:31:10,340 --> 00:31:14,930
>> 所以，現在，我要求在複製0.c，我
現在要通過的方式來複製這些字符串

768
00:31:14,930 --> 00:31:15,685
線28。

769
00:31:15,685 --> 00:31:16,850

770
00:31:16,850 --> 00:31:18,750
然後，我會
如權利要求在底部

771
00:31:18,750 --> 00:31:21,430
在這裡，我要
改變其中之一。

772
00:31:21,430 --> 00:31:22,330
>> 所以注意到這一點。

773
00:31:22,330 --> 00:31:24,370
我打電話是我們的老朋友strlen的。

774
00:31:24,370 --> 00:31:28,960
而在英語只是解釋
這行34是幹什麼的？

775
00:31:28,960 --> 00:31:32,480
什麼噸支架0
表示在左邊。

776
00:31:32,480 --> 00:31:32,980
是啊。

777
00:31:32,980 --> 00:31:34,339
>> 聽眾：T的第一個字符？

778
00:31:34,339 --> 00:31:35,880
戴維·J·馬蘭：T的第一個字符。

779
00:31:35,880 --> 00:31:36,379
就是這樣。

780
00:31:36,379 --> 00:31:40,024
噸的第一個字母，我想
指定的大寫版本

781
00:31:40,024 --> 00:31:41,190
在噸的第一個字符。

782
00:31:41,190 --> 00:31:43,200
因此，這是資本
第一個字母。

783
00:31:43,200 --> 00:31:46,340
然後，在最後一件事，我做的
在這個計劃是我要求這裡的

784
00:31:46,340 --> 00:31:50,340
原來，S，和這裡的副本，T。

785
00:31:50,340 --> 00:31:54,610
>> 但根據故事我們只是
說什麼串真的是，

786
00:31:54,610 --> 00:31:57,520
什麼是28行真的
做的，什麼是

787
00:31:57,520 --> 00:31:59,405
所產生的錯誤會
要在屏幕上？

788
00:31:59,405 --> 00:32:01,300

789
00:32:01,300 --> 00:32:03,500
>> 因此，首先，第一個問題，28。

790
00:32:03,500 --> 00:32:09,040
什麼是串T = S真的在做什麼？

791
00:32:09,040 --> 00:32:16,430
如果我們有在左手
這裡邊串T = S;

792
00:32:16,430 --> 00:32:19,400
這給了我一個盒子
在這裡，一個盒子在這裡。

793
00:32:19,400 --> 00:32:25,530
並假設該地址是0X，
比方說，50這時候，隨意。

794
00:32:25,530 --> 00:32:28,847
什麼串T = S
做引擎蓋底下？

795
00:32:28,847 --> 00:32:30,340
>> 聽眾：[聽不清]

796
00:32:30,340 --> 00:32:34,100
>> 戴維·J·馬蘭：它存儲在內存中
有地址，所以為0x50去那裡。

797
00:32:34,100 --> 00:32:37,980
所以，如果現在我去的第一個
字符T和大寫的，

798
00:32:37,980 --> 00:32:39,535
我是什麼切實做送？

799
00:32:39,535 --> 00:32:41,300

800
00:32:41,300 --> 00:32:43,450
我真的做同樣的事情，對不對？

801
00:32:43,450 --> 00:32:47,680
因為如果地址0x50--，只是，我
沒有太多空間在黑板上這裡，

802
00:32:47,680 --> 00:32:51,750
但假設這是0X50到這裡，
某處在我的電腦的內存中。

803
00:32:51,750 --> 00:32:55,825
>> 而我，比如，加布
在這裡小寫，這樣。

804
00:32:55,825 --> 00:32:57,120

805
00:32:57,120 --> 00:33:01,980
我已經說過噸支架
0被資本化。

806
00:33:01,980 --> 00:33:04,860
嗯，T支架0
T中的第一個字母。

807
00:33:04,860 --> 00:33:07,840
所以，小克將要
成為大灣但是問題

808
00:33:07,840 --> 00:33:09,410
是，是什麼而是也指向？

809
00:33:09,410 --> 00:33:10,300
>> 聽眾：相同。

810
00:33:10,300 --> 00:33:11,841
>> 戴維·J·馬蘭：同樣的事情。

811
00:33:11,841 --> 00:33:16,342
因此，一個簡單的解釋或許是，
即使語法是有點怪異。

812
00:33:16,342 --> 00:33:17,050
因此，讓我們做到這一點。

813
00:33:17,050 --> 00:33:20,210
使複製的0，然後./copy-0。

814
00:33:20,210 --> 00:33:21,820

815
00:33:21,820 --> 00:33:24,110
說些什麼：加布。

816
00:33:24,110 --> 00:33:26,760
不幸的是，這兩個
他們現在已經被資本化，

817
00:33:26,760 --> 00:33:29,500
但對於基本
原因是我們根本

818
00:33:29,500 --> 00:33:32,350
現在要處理的地址。

819
00:33:32,350 --> 00:33:36,470
>> 那麼，我們如何開始
address--沒有雙關語intended--

820
00:33:36,470 --> 00:33:39,270
我們該如何著手解決
這方面的問題？

821
00:33:39,270 --> 00:33:44,400
那麼，在copy1.c，事情進展
變得有點複雜。

822
00:33:44,400 --> 00:33:49,310
但我會要求
概念上很簡單的解決方案。

823
00:33:49,310 --> 00:33:50,852
>> 所以很難得到乍一看。

824
00:33:50,852 --> 00:33:53,560
不是一件容易的事為先
一次打出來，也許，

825
00:33:53,560 --> 00:33:57,440
但是，如果該問題是
簡單地做T =的只有我

826
00:33:57,440 --> 00:33:59,694
複製地址什麼的，
再次，如果我可以選擇你，

827
00:33:59,694 --> 00:34:02,110
將是解決方案
在實際拷貝的字符串？

828
00:34:02,110 --> 00:34:04,906

829
00:34:04,906 --> 00:34:06,770
>> 聽眾：我們可能會
再次使用一個循環。

830
00:34:06,770 --> 00:34:06,890
>> 戴維·J·馬蘭：是的。

831
00:34:06,890 --> 00:34:08,390
所以，我們要再次需要一個循環。

832
00:34:08,390 --> 00:34:11,800
而且，因為如果我們想複製
一個字符串s轉換另一個字符串，

833
00:34:11,800 --> 00:34:14,120
我們可能想這樣做
逐字符。

834
00:34:14,120 --> 00:34:17,199
但問題是，如果
這本來是S，

835
00:34:17,199 --> 00:34:22,159
現在我們需要明確啟動
在t分配內存。

836
00:34:22,159 --> 00:34:24,320
>> 換句話說，讓我們
重繪這是最後一次。

837
00:34:24,320 --> 00:34:28,659
如果是字符串s = GetString的。

838
00:34:28,659 --> 00:34:30,956

839
00:34:30,956 --> 00:34:32,455
讓我們把這個在這裡，也是如此。

840
00:34:32,455 --> 00:34:36,639

841
00:34:36,639 --> 00:34:37,420
這是GetString的。

842
00:34:37,420 --> 00:34:39,070

843
00:34:39,070 --> 00:34:43,860
然後，畫面的東西
像將是象以前那樣

844
00:34:43,860 --> 00:34:44,360
G-A-B-E-/ 0。

845
00:34:44,360 --> 00:34:47,294

846
00:34:47,294 --> 00:34:48,960
這看起來有點像這樣。

847
00:34:48,960 --> 00:34:53,650
和S因此，我們稱這種為0x50，
那將是51，52。

848
00:34:53,650 --> 00:34:54,409
>> 因此，這是為0x50。

849
00:34:54,409 --> 00:34:55,679

850
00:34:55,679 --> 00:34:59,690
然後，我做的串T。

851
00:34:59,690 --> 00:35:02,450
在內存方面，這只是將
給我這樣一個小廣場。

852
00:35:02,450 --> 00:35:04,080
那麼什麼是關鍵的一步呢？

853
00:35:04,080 --> 00:35:09,870
如果我想複製s轉換T，什麼
空白，我們需要在這裡填寫？

854
00:35:09,870 --> 00:35:12,050
或者是什麼，我們需要
做在一個較高的水平？

855
00:35:12,050 --> 00:35:14,101

856
00:35:14,101 --> 00:35:14,600
是嗎？

857
00:35:14,600 --> 00:35:16,200

858
00:35:16,200 --> 00:35:17,020
有人在嗎？

859
00:35:17,020 --> 00:35:17,690
是啊。

860
00:35:17,690 --> 00:35:19,214
>> 聽眾：我們需要[聽不清]。

861
00:35:19,214 --> 00:35:21,380
戴維·J·馬蘭：是的，我們
需要填寫這個空白。

862
00:35:21,380 --> 00:35:24,340
我不能複製，然後
利用Gabe的名字

863
00:35:24,340 --> 00:35:28,120
直到我問操作系統
對於內存另一塊

864
00:35:28,120 --> 00:35:30,640
這至少一樣大的原稿。

865
00:35:30,640 --> 00:35:32,130
所以這給我們留下了一個問題。

866
00:35:32,130 --> 00:35:36,080
>> 我如何向操作系統不
只是一個簡單的小pointer--

867
00:35:36,080 --> 00:35:38,530
因為這是所謂的，一個
地址，pointer--不

868
00:35:38,530 --> 00:35:40,980
一個簡單的小盒子
像這樣所謂的一個字符串？

869
00:35:40,980 --> 00:35:44,200
我怎麼問工作
系統內存一大塊？

870
00:35:44,200 --> 00:35:48,430
到目前為止，我只得到了回
間接調用GetString的。

871
00:35:48,430 --> 00:35:50,740
因此，如何的GetString
即使得到它的內存？

872
00:35:50,740 --> 00:35:53,430
>> 嗯，事實證明，有
這個其他的功能在這裡

873
00:35:53,430 --> 00:35:55,160
那我們現在就開始使用。

874
00:35:55,160 --> 00:35:59,780
現在，這種方式看起來更神秘than--
我是誰可以看到它 - 唯一一個

875
00:35:59,780 --> 00:36:03,150
這條線看上去方式更隱蔽
那麼就應該第一眼。

876
00:36:03,150 --> 00:36:04,650
但是，讓我們逗它拆開。

877
00:36:04,650 --> 00:36:07,950
>> 在左邊，我的char *噸。

878
00:36:07,950 --> 00:36:13,280
因此，在英語，讓我們開始制定
正確的句子中的技術術語。

879
00:36:13,280 --> 00:36:19,757
因此，這是分配
char類型的變量*稱為T。

880
00:36:19,757 --> 00:36:21,090
現在，這究竟意味著什麼？

881
00:36:21,090 --> 00:36:23,881
>> 那麼，這意味著，我該怎麼
把這個變量稱為T？

882
00:36:23,881 --> 00:36:24,780

883
00:36:24,780 --> 00:36:26,402
一個字符的地址。

884
00:36:26,402 --> 00:36:28,360
所以，這僅僅是簡單的，
更合理的方式

885
00:36:28,360 --> 00:36:29,930
的說明的左手側。

886
00:36:29,930 --> 00:36:32,890
因此，創建這個盒子在這裡只。

887
00:36:32,890 --> 00:36:34,760
這樣的右手側，
據推測，是怎麼回事

888
00:36:34,760 --> 00:36:37,170
分配的大
內存塊是如何？

889
00:36:37,170 --> 00:36:38,340
因此，讓我們取笑這個分開。

890
00:36:38,340 --> 00:36:41,131
>> 它壓倒性的第一眼，
但是這是怎麼回事裡面嗎？

891
00:36:41,131 --> 00:36:43,740
首先，有malloc的，這
顯然是我們的新朋友，

892
00:36:43,740 --> 00:36:45,450
“內存分配”。

893
00:36:45,450 --> 00:36:49,560
因此，這是傳遞的參數
進去，所以這是一個相當大的爭論。

894
00:36:49,560 --> 00:36:50,970
因此，讓我們取笑這個分開。

895
00:36:50,970 --> 00:36:53,410
>> 當然，第strlen的，代表the--

896
00:36:53,410 --> 00:36:54,142

897
00:36:54,142 --> 00:36:55,600
聽眾：字符數。

898
00:36:55,600 --> 00:36:56,710
戴維·J·馬蘭：就在
s中的字符數。

899
00:36:56,710 --> 00:36:59,040
所以s的長度，原來的字符串。

900
00:36:59,040 --> 00:37:00,350
因此，G-A-B-E。

901
00:37:00,350 --> 00:37:02,320
因此，它可能是在這裡為四個。

902
00:37:02,320 --> 00:37:05,485
之後我為什麼要做1
調用第strlen的？

903
00:37:05,485 --> 00:37:06,360
聽眾：[聽不清]

904
00:37:06,360 --> 00:37:07,590
戴維·J·馬蘭：對於
特殊的空字符。

905
00:37:07,590 --> 00:37:11,260
如果你問我什麼是長度
Gabe的名字，我會說，四名。

906
00:37:11,260 --> 00:37:14,480
在系統底層，不過，我需要
在第五個字節的空字符。

907
00:37:14,480 --> 00:37:16,100
所以這就是為什麼我做了1。

908
00:37:16,100 --> 00:37:21,730
>> 現在，以防萬一你運行這個
程序的計算機比其他的，說，

909
00:37:21,730 --> 00:37:24,610
在CS50家電，
其中一個字符的大小

910
00:37:24,610 --> 00:37:26,350
可能是不同
從我自己的computer--

911
00:37:26,350 --> 00:37:30,590
事實證明，我可以把這個
運營商的sizeof，只是問了電腦，

912
00:37:30,590 --> 00:37:32,870
什麼是a的大小
char的這台電腦上？

913
00:37:32,870 --> 00:37:37,400
>> 並通過在此乘以5
例如，通過一個字符的大小，這

914
00:37:37,400 --> 00:37:40,440
在大多數計算機上會
僅僅是一個，malloc的

915
00:37:40,440 --> 00:37:44,830
是要分配給我這個大
內存塊在這裡就對了。

916
00:37:44,830 --> 00:37:47,140
而這將return--
它是一個函數 - 所以它的

917
00:37:47,140 --> 00:37:48,265
要回到我身邊嗎？

918
00:37:48,265 --> 00:37:50,914

919
00:37:50,914 --> 00:37:51,830
聽眾：地址？

920
00:37:51,830 --> 00:37:53,709
戴維·J·馬蘭：什麼樣的報告？

921
00:37:53,709 --> 00:37:55,250
聽眾：內存是分配呢？

922
00:37:55,250 --> 00:37:56,450
戴維·J·馬蘭：的
它的內存分配。

923
00:37:56,450 --> 00:37:59,189
所以，我不知道，坦白地說，
這是怎麼回事結束了。

924
00:37:59,189 --> 00:38:01,480
我要建議
這將結束在均為0x88。

925
00:38:01,480 --> 00:38:02,770

926
00:38:02,770 --> 00:38:06,009
完全是任意的，但
什麼地方比其他的0x50，

927
00:38:06,009 --> 00:38:08,800
因為操作系統，什麼
Windows和Mac OS為我做的，是

928
00:38:08,800 --> 00:38:11,230
請確保它給
我的內存不同的塊。

929
00:38:11,230 --> 00:38:14,210
>> 因此，這是價值所在今
內存塊可能最終。

930
00:38:14,210 --> 00:38:16,060
原來這就是在這裡，均為0x88結束。

931
00:38:16,060 --> 00:38:17,480

932
00:38:17,480 --> 00:38:21,570
所以，現在清楚了，我能理解
這是不一樣的，因為這，

933
00:38:21,570 --> 00:38:23,960
因為他們指著
不同組塊的存儲器。

934
00:38:23,960 --> 00:38:29,980
所以，如果我現在真的想複製此
在，讓我們做你的建議的解決方案。

935
00:38:29,980 --> 00:38:36,870
>> 讓我們只是去創建一個for循環，
和做T支架í得到Š支架島

936
00:38:36,870 --> 00:38:39,760
因為現在我可以使用
這陣般的符號，

937
00:38:39,760 --> 00:38:43,390
因為即使非常的malloc
一般我分配內存，

938
00:38:43,390 --> 00:38:45,290
內存只是連續的字節。

939
00:38:45,290 --> 00:38:47,240
字節，字節，字節，回背靠背。

940
00:38:47,240 --> 00:38:50,030
>> 我可以肯定，作為一個程序員
把它當作一個數組，其中

941
00:38:50,030 --> 00:38:55,090
意味著我可以用這個終於熟悉
符號只是一些方括號。

942
00:38:55,090 --> 00:38:56,462

943
00:38:56,462 --> 00:39:00,020
>> 因此，讓我停在那裡，因為
這是很多一次性全部，甚至

944
00:39:00,020 --> 00:39:03,530
雖然基本思路重溫
是字符串，這一切的時候，

945
00:39:03,530 --> 00:39:05,550
是不是一個新的數據類型本身。

946
00:39:05,550 --> 00:39:10,150
這只是一個所謂的指針，
一個字符的地址，

947
00:39:10,150 --> 00:39:12,650
這只是意味著它是一個數字
由人約定

948
00:39:12,650 --> 00:39:15,350
我們傾向於寫為0X的東西。

949
00:39:15,350 --> 00:39:18,590
>> 但是，這只是一個數字，
像33牛津街，

950
00:39:18,590 --> 00:39:20,530
這恰好是
政務司司長建築物的地址。

951
00:39:20,530 --> 00:39:22,000

952
00:39:22,000 --> 00:39:23,545
對這些細節有問題嗎？

953
00:39:23,545 --> 00:39:24,790

954
00:39:24,790 --> 00:39:25,289
是嗎？

955
00:39:25,289 --> 00:39:28,530
>> 聽眾：我們為什麼檢查
在t等於null？

956
00:39:28,530 --> 00:39:30,740
>> 戴維·J·馬蘭：為什麼我們
檢查噸等於null？

957
00:39:30,740 --> 00:39:33,250
如果我們讀了documentation--
對malloc的偉大question--，

958
00:39:33,250 --> 00:39:37,020
它會在印刷精美的說，
有時候可能的malloc返回null，

959
00:39:37,020 --> 00:39:38,080
就像GetString的。

960
00:39:38,080 --> 00:39:41,820
事實上，形式返回空值
如果反過來，malloc的返回null，

961
00:39:41,820 --> 00:39:43,130
因為GetString的使用的malloc。

962
00:39:43,130 --> 00:39:46,400
>> 和可能，如果操作系統發生，
的Mac OS，Windows中，無論是簡單的

963
00:39:46,400 --> 00:39:48,130
出內存給你。

964
00:39:48,130 --> 00:39:49,820
所以，這就是發生在那裡。

965
00:39:49,820 --> 00:39:52,910
>> 並且讓我發現一件事
這可能只是打擊你的心

966
00:39:52,910 --> 00:39:55,100
或者完全是太遠了就行了。

967
00:39:55,100 --> 00:39:59,770
不過，讓我拉起來
同樣的for循環複製，

968
00:39:59,770 --> 00:40:05,480
其中，剛才被召回
這個。噸級別I得到Š支架島

969
00:40:05,480 --> 00:40:06,740
>> 尼斯和用戶友好。

970
00:40:06,740 --> 00:40:09,330
再次感覺就像第二週。

971
00:40:09,330 --> 00:40:14,920
但這個版本其實是可以
寫成這樣，看起來神秘。

972
00:40:14,920 --> 00:40:18,280
這是一個技術，稱為指針
算術，地址運算。

973
00:40:18,280 --> 00:40:19,600
但是為什麼這工作？

974
00:40:19,600 --> 00:40:22,220
>> 現在煩人的
的C筆者決定使用

975
00:40:22,220 --> 00:40:25,070
*符號為不同的目的。

976
00:40:25,070 --> 00:40:29,020
我們已經看到了使用一次已，
char *的，意思是“給我一個變量

977
00:40:29,020 --> 00:40:31,210
那將包含
一個字符的地址。“

978
00:40:31,210 --> 00:40:33,990
在這方面如此的char *
意思是“給我一個變數。”

979
00:40:33,990 --> 00:40:40,050
>> 不幸的是，如果您使用不帶*
在它前面的單詞，如焦炭，

980
00:40:40,050 --> 00:40:41,905
它現在被稱為
引用操作。

981
00:40:41,905 --> 00:40:43,530
我們會看到更多這樣用不了多久。

982
00:40:43,530 --> 00:40:44,930
但它只是意味著“去那裡。”

983
00:40:44,930 --> 00:40:49,070
這就像說，如果有人遞給我
在一張紙“33牛津街”

984
00:40:49,070 --> 00:40:53,830
如果我做“* 33牛津街，”這意味著
“走在路上到CS的建設。”

985
00:40:53,830 --> 00:40:57,220
>> 因此，*的意思只是去那裡，如果
還有就是在它前面沒有字。

986
00:40:57,220 --> 00:40:59,100
那麼，什麼是T，要清楚？

987
00:40:59,100 --> 00:41:03,250
t是該塊的地址
這是還給我的記憶。

988
00:41:03,250 --> 00:41:06,650
s是什麼，要明確的地址，
在這個例子中，我們一直在討論，

989
00:41:06,650 --> 00:41:07,500
小寫加布？

990
00:41:07,500 --> 00:41:08,990

991
00:41:08,990 --> 00:41:10,005
s是地址of--

992
00:41:10,005 --> 00:41:11,585

993
00:41:11,585 --> 00:41:12,460
聽眾：字符串。

994
00:41:12,460 --> 00:41:14,126
作者加布的原名：戴維·馬蘭。

995
00:41:14,126 --> 00:41:16,660
所以它的地址
這個塊的存儲器。

996
00:41:16,660 --> 00:41:22,220
所以，如果我說T +我 - 我的通知，
只是我們的老朋友了。

997
00:41:22,220 --> 00:41:24,770
這只是一個索引變量
這是從零上了迭代

998
00:41:24,770 --> 00:41:26,960
到的字符串s的長度。

999
00:41:26,960 --> 00:41:30,367
因此，這將是零，再一個，
然後二，然後三天，4。

1000
00:41:30,367 --> 00:41:33,200
因此，讓我們組裝這些新
從無到有，就像拼圖遊戲一樣，如果你​​願意，

1001
00:41:33,200 --> 00:41:36,140
即使再次，語法
遠比划痕更晦澀難懂。

1002
00:41:36,140 --> 00:41:39,522
因此，t是一個地址+
i的要給我

1003
00:41:39,522 --> 00:41:42,480
數，因為這些都是
我們已經制訂為十六進制數。

1004
00:41:42,480 --> 00:41:43,560
但他們只是數字。

1005
00:41:43,560 --> 00:41:49,960
>> 因此，如果T的地址，我們說
為均為0x88，什麼均為0x88加零。

1006
00:41:49,960 --> 00:41:51,564

1007
00:41:51,564 --> 00:41:53,980
即使你不舒服
用十六進制然而，以此來猜測。

1008
00:41:53,980 --> 00:41:54,410
>> 聽眾：原來。

1009
00:41:54,410 --> 00:41:55,850
>> 戴維·J·馬蘭：仍然均為0x88。

1010
00:41:55,850 --> 00:41:58,910
那麼，是什麼*均為0x88是什麼意思？

1011
00:41:58,910 --> 00:42:02,670
這意味著，“去那裡”，這意味著
有效，“把你的手指在這裡。”

1012
00:42:02,670 --> 00:42:06,930
和現在的右手側
該表達式中，*，然後在括號，

1013
00:42:06,930 --> 00:42:11,586
S + i表示s，這是
這裡的小克解決了。

1014
00:42:11,586 --> 00:42:16,220
S + 0，當然，S，不管s是。

1015
00:42:16,220 --> 00:42:21,230
>> 所以，現在，它的* s，這就像* 33
牛津街是指去的地址

1016
00:42:21,230 --> 00:42:22,010
第

1017
00:42:22,010 --> 00:42:24,170
因此，這裡的這個手指，右手。

1018
00:42:24,170 --> 00:42:26,050
那我要複製到什麼？

1019
00:42:26,050 --> 00:42:30,260
在右側的​​事情，這是
加布，在這裡，小克，到這裡。

1020
00:42:30,260 --> 00:42:32,750
>> 那等的影響
在循環的第一次迭代中，

1021
00:42:32,750 --> 00:42:36,200
如你提出，儘管它看起來
瘋狂的比什麼都更複雜

1022
00:42:36,200 --> 00:42:42,110
我們已經看到過，只是說
到這裡，並在這裡複製該字符。

1023
00:42:42,110 --> 00:42:44,700
它給你一張地圖兩個位置。

1024
00:42:44,700 --> 00:42:46,130
>> 我們將看到更為了這一點。

1025
00:42:46,130 --> 00:42:50,600
但現在，希望僅僅是
介紹其中的一些基本思路。

1026
00:42:50,600 --> 00:42:53,550
事實上，讓我們來看看
最後一個節目在這裡，

1027
00:42:53,550 --> 00:42:57,480
然後承諾的粘土動畫，
這將使得一切都還好嗎。

1028
00:42:57,480 --> 00:42:57,980
好吧。

1029
00:42:57,980 --> 00:43:01,680
因此，讓我開up--我們走吧。

1030
00:43:01,680 --> 00:43:02,850

1031
00:43:02,850 --> 00:43:05,440
因此，讓我 - 我們會回來的
到不久這張圖片。

1032
00:43:05,440 --> 00:43:08,360
讓我開了這個最後的例子在這裡。

1033
00:43:08,360 --> 00:43:09,440

1034
00:43:09,440 --> 00:43:12,710
>> 因此，這裡是一個超級，超級
程序完成

1035
00:43:12,710 --> 00:43:15,050
沒有在生活中，做了以下幾點。

1036
00:43:15,050 --> 00:43:18,740
它首先聲明兩個變量，X
和y即不是數字此時，

1037
00:43:18,740 --> 00:43:19,240
本身。

1038
00:43:19,240 --> 00:43:20,448
他們不是整數，本身。

1039
00:43:20,448 --> 00:43:22,899
他們顯然是int *。

1040
00:43:22,899 --> 00:43:25,690
所以只要任何人，這是什麼意思
如果你的數據類型，你的變量，

1041
00:43:25,690 --> 00:43:26,860
是的類型是int *星？

1042
00:43:26,860 --> 00:43:30,240
這是一個int的地址。

1043
00:43:30,240 --> 00:43:31,990
>> 所以，我不知道它在哪兒呢。

1044
00:43:31,990 --> 00:43:35,150
它只是意味著“最終，
這裡的int的地址。“

1045
00:43:35,150 --> 00:43:38,340
為0x50，均為0x88，無論它是在
存儲器中，地址是要在那裡。

1046
00:43:38,340 --> 00:43:40,200
而這正是y是
將要，以及。

1047
00:43:40,200 --> 00:43:44,920
>> 如果我現在說，X =的malloc（sizeof運算（INT）），
這是說，一個奇特的方式，

1048
00:43:44,920 --> 00:43:49,000
哎操作系統通過malloc，
給我足夠的內存的大小

1049
00:43:49,000 --> 00:43:52,370
一個int，這可能是
將是32位或4個字節。

1050
00:43:52,370 --> 00:43:53,680
>> 那麼，是什麼的malloc返回？

1051
00:43:53,680 --> 00:43:55,250
malloc的返回地址。

1052
00:43:55,250 --> 00:43:57,020
那麼，什麼會得到存放在X？

1053
00:43:57,020 --> 00:44:00,600
的組塊的地址
存儲器，四個字節，該malloc的

1054
00:44:00,600 --> 00:44:03,360
剛發現我問
操作系統。

1055
00:44:03,360 --> 00:44:08,240
>> 現在同時在線
4在此，* X = 42。

1056
00:44:08,240 --> 00:44:09,990
只是要清楚，
這是怎麼回事那裡？

1057
00:44:09,990 --> 00:44:11,530
在左手側，* X。

1058
00:44:11,530 --> 00:44:13,610
這就像* 33牛津街。

1059
00:44:13,610 --> 00:44:15,523
因此，* X意味著什麼？

1060
00:44:15,523 --> 00:44:16,450
>> 聽眾：去。

1061
00:44:16,450 --> 00:44:17,908
>> 戴維·J·馬蘭：進入該地址。

1062
00:44:17,908 --> 00:44:20,466
無論那一塊
記憶，去它。

1063
00:44:20,466 --> 00:44:21,979
放什麼在那裡，很明顯？

1064
00:44:21,979 --> 00:44:22,520
聽眾：42。

1065
00:44:22,520 --> 00:44:23,580
戴維·J·馬蘭：42。

1066
00:44:23,580 --> 00:44:25,650
好吧，* Y，同樣的想法。

1067
00:44:25,650 --> 00:44:26,860
轉到Y中的地址。

1068
00:44:26,860 --> 00:44:31,740
把13號在那裡，
但為y的時刻？

1069
00:44:31,740 --> 00:44:33,172

1070
00:44:33,172 --> 00:44:34,630
聽眾：有沒有記憶的年。

1071
00:44:34,630 --> 00:44:35,710
戴維·J·馬蘭：有
對Y沒有記憶。

1072
00:44:35,710 --> 00:44:38,215
那麼什麼是ÿ可能
包含，因為我們一直在說什麼？

1073
00:44:38,215 --> 00:44:38,520
>> 聽眾：垃圾。

1074
00:44:38,520 --> 00:44:39,480
>> 戴維·J·馬蘭：一些垃圾值。

1075
00:44:39,480 --> 00:44:41,320
現在，垃圾的價值仍然是一個數字。

1076
00:44:41,320 --> 00:44:43,160
它仍然可以被誤認為是一個地址。

1077
00:44:43,160 --> 00:44:45,160
就好像一個人
潦草的東西了，

1078
00:44:45,160 --> 00:44:48,002
我誤解了它的意思
一些建築在街上。

1079
00:44:48,002 --> 00:44:50,460
如果你只是試圖進入
一些建築物不屬於您，

1080
00:44:50,460 --> 00:44:53,710
或一些內存塊，你有沒有
已經給出不好的事情可能會發生。

1081
00:44:53,710 --> 00:44:57,740
計算機可能會崩潰，或者一些其他的
未確定的行為可能會發生。

1082
00:44:57,740 --> 00:45:01,310
>> 所以，前奏的話，要賓基是這樣的。

1083
00:45:01,310 --> 00:45:04,290
我還記得，20
一些多年後，

1084
00:45:04,290 --> 00:45:07,200
我在那裡的時候，我終於
理解指針。

1085
00:45:07,200 --> 00:45:09,520
>> 這就是說，如果
離開這裡在三分鐘

1086
00:45:09,520 --> 00:45:12,170
而以為我不
理解指針，實現

1087
00:45:12,170 --> 00:45:14,410
我記得20
年，一些瘋狂的原因

1088
00:45:14,410 --> 00:45:17,140
何時以及為什麼它最後沉沒
中，坐在我的教學

1089
00:45:17,140 --> 00:45:19,501
老鄉，尼沙特梅塔在
艾略特食堂回來。

1090
00:45:19,501 --> 00:45:21,250
現在，我想起了
這是因為，這是

1091
00:45:21,250 --> 00:45:23,920
的主題時，我在一個
特別是，掙扎。

1092
00:45:23,920 --> 00:45:26,470
然後，它最後點擊，
像我敢說很多話題

1093
00:45:26,470 --> 00:45:27,460
最終會的。

1094
00:45:27,460 --> 00:45:32,590
而現在，以使該感到所有的
更快樂，更讓人信服，

1095
00:45:32,590 --> 00:45:35,360
讓我們在最後我們看一下
最後三分鐘，在這裡賓基，

1096
00:45:35,360 --> 00:45:37,675
從我們的朋友，尼克
Parlante來自斯坦福大學。

1097
00:45:37,675 --> 00:45:38,910

1098
00:45:38,910 --> 00:45:41,580
>> [視頻回放]

1099
00:45:41,580 --> 00:45:42,750
>> 嘿，賓基。

1100
00:45:42,750 --> 00:45:43,500
醒來！

1101
00:45:43,500 --> 00:45:45,960
現在是時候為指針樂趣。

1102
00:45:45,960 --> 00:45:47,012
>>  - 什麼是什麼？

1103
00:45:47,012 --> 00:45:48,723
了解指針？

1104
00:45:48,723 --> 00:45:50,580
噢，好極了！

1105
00:45:50,580 --> 00:45:53,563
>>  - 嗯，上手的，我想我們
將需要幾個三分球。

1106
00:45:53,563 --> 00:45:54,390
>>  - 確定。

1107
00:45:54,390 --> 00:45:57,930
此代碼分配兩個三分球，
它可以指向整數。

1108
00:45:57,930 --> 00:45:58,430
 - 確定。

1109
00:45:58,430 --> 00:46:02,140
嗯，我看到兩個三分球，但他們
似乎並沒有被指向任何東西。

1110
00:46:02,140 --> 00:46:02,980
>>  - 這就是正確的。

1111
00:46:02,980 --> 00:46:05,100
最初，指針
不指向任何東西。

1112
00:46:05,100 --> 00:46:08,030
他們指出，被稱為東西
指針對象，並設置他們的

1113
00:46:08,030 --> 00:46:09,370
一個單獨的步驟。

1114
00:46:09,370 --> 00:46:10,220
>> 哦，對，對。

1115
00:46:10,220 --> 00:46:10,950
我知道這一點。

1116
00:46:10,950 --> 00:46:12,385
該指針對象是分開的。

1117
00:46:12,385 --> 00:46:14,315
呃，那麼你如何分配指針對象？

1118
00:46:14,315 --> 00:46:15,340

1119
00:46:15,340 --> 00:46:15,960
>>  - 確定。

1120
00:46:15,960 --> 00:46:18,970
那麼，這個代碼分配
一個新的整數指針對象，

1121
00:46:18,970 --> 00:46:20,950
而這部分設置x指向它。

1122
00:46:20,950 --> 00:46:22,050

1123
00:46:22,050 --> 00:46:23,230
>> 嘿，這看起來更好。

1124
00:46:23,230 --> 00:46:25,060
因此，利用它做些什麼。

1125
00:46:25,060 --> 00:46:25,990
>>  - 確定。

1126
00:46:25,990 --> 00:46:30,455
我將間接引用指針x可
數字42存入及其指針。

1127
00:46:30,455 --> 00:46:32,830
對於這一招，我需要我的
提領的魔術棒。

1128
00:46:32,830 --> 00:46:34,130

1129
00:46:34,130 --> 00:46:36,080
>> 解引用的 - 你的魔術棒？

1130
00:46:36,080 --> 00:46:37,357

1131
00:46:37,357 --> 00:46:38,190
That--這是偉大的。

1132
00:46:38,190 --> 00:46:39,340

1133
00:46:39,340 --> 00:46:41,080
>>  - 這是什麼樣的代碼如下所示。

1134
00:46:41,080 --> 00:46:44,110
我會剛剛成立的號碼，[流行]

1135
00:46:44,110 --> 00:46:44,700
>> 嘿，快看。

1136
00:46:44,700 --> 00:46:46,140
就這樣吧。

1137
00:46:46,140 --> 00:46:50,980
>> -so做一個提領在X如下
箭頭訪問及其指針。

1138
00:46:50,980 --> 00:46:53,160
在這種情況下，存儲器42在那裡。

1139
00:46:53,160 --> 00:46:57,710
嘿嘗試使用它來存儲數
13穿過另一個指針，Y。

1140
00:46:57,710 --> 00:46:58,760
>>  - 確定。

1141
00:46:58,760 --> 00:47:03,270
我就投奔這裡Y，
並獲得了13號成立。

1142
00:47:03,270 --> 00:47:07,930
然後，採取的魔杖
非關聯化和公正[叮咚]

1143
00:47:07,930 --> 00:47:08,960
>>  - 哦！

1144
00:47:08,960 --> 00:47:09,500
>> 哦，嘿嘿！

1145
00:47:09,500 --> 00:47:11,090
沒有工作。

1146
00:47:11,090 --> 00:47:15,630
說，賓基，我不認為提領
y是一個好主意，因為你知道，

1147
00:47:15,630 --> 00:47:17,850
建立指針對象
是一個獨立的步驟。

1148
00:47:17,850 --> 00:47:20,450
而且我不認為我們曾經做到了。

1149
00:47:20,450 --> 00:47:21,480
>>  - 良好的點。

1150
00:47:21,480 --> 00:47:21,980
是啊。

1151
00:47:21,980 --> 00:47:25,680
我們分配的指針，Y，但我們
從來沒有把它設置為指向一個指針對象。

1152
00:47:25,680 --> 00:47:27,190

1153
00:47:27,190 --> 00:47:28,616
>>  - 非常細心。

1154
00:47:28,616 --> 00:47:30,240
嘿，你看起來好有，賓基。

1155
00:47:30,240 --> 00:47:33,400
你可以解決它，從而y點
到相同的指針對象為x？

1156
00:47:33,400 --> 00:47:34,000
>> -sure。

1157
00:47:34,000 --> 00:47:36,780
我會用我的魔杖
的指針賦值。

1158
00:47:36,780 --> 00:47:38,740
>> -is那將是
像以前一樣的問題嗎？

1159
00:47:38,740 --> 00:47:39,240
 - 沒有。

1160
00:47:39,240 --> 00:47:40,660
這不碰指針對象。

1161
00:47:40,660 --> 00:47:44,450
它只是改變了自己的指針
指向同樣的事情又。

1162
00:47:44,450 --> 00:47:45,450
>> 哦，我明白了。

1163
00:47:45,450 --> 00:47:48,200
現在Ÿ指向同一個地方為x。

1164
00:47:48,200 --> 00:47:48,910
所以等待。

1165
00:47:48,910 --> 00:47:49,950
現在，Y是固定的。

1166
00:47:49,950 --> 00:47:51,120
它有一個指針對象。

1167
00:47:51,120 --> 00:47:54,510
所以，你可以嘗試的魔杖
提領一次送13以上。

1168
00:47:54,510 --> 00:47:56,510
>> -Uh，確定。

1169
00:47:56,510 --> 00:47:58,160
在這裡不言而喻。 [流行]

1170
00:47:58,160 --> 00:47:59,340
>> 嘿，看看這個。

1171
00:47:59,340 --> 00:48:00,750
現在提領Y上的作品。

1172
00:48:00,750 --> 00:48:04,991
而由於指針分享
一個指針對象，他們都看到了13。

1173
00:48:04,991 --> 00:48:05,490
是啊。

1174
00:48:05,490 --> 00:48:06,870
共享，等等。

1175
00:48:06,870 --> 00:48:08,820
那麼，我們現在要切換的地方？

1176
00:48:08,820 --> 00:48:09,440
>> 哦，你看。

1177
00:48:09,440 --> 00:48:10,830
我們沒時間了。

1178
00:48:10,830 --> 00:48:11,570
>> -But--

1179
00:48:11,570 --> 00:48:13,530
>>  - 只是記住三個指針的規則。

1180
00:48:13,530 --> 00:48:16,560
第一，基本結構
是你有一個指針，

1181
00:48:16,560 --> 00:48:18,680
它指出了一個指針對象。

1182
00:48:18,680 --> 00:48:20,640
但指針和
指針對象是分開的，

1183
00:48:20,640 --> 00:48:22,610
和常見的錯誤
是要建立一個指針，

1184
00:48:22,610 --> 00:48:25,000
但忘了給它一個指針對象。

1185
00:48:25,000 --> 00:48:28,170
>> 第二，指針廢棄
開始於指針

1186
00:48:28,170 --> 00:48:31,050
並沿用其在箭頭
訪問及其指針。

1187
00:48:31,050 --> 00:48:33,400
大家都知道，這
只有當有

1188
00:48:33,400 --> 00:48:36,270
指針對象，哪一種
變回規則一。

1189
00:48:36,270 --> 00:48:39,000
>> 第三，指針
任務需要一個指針

1190
00:48:39,000 --> 00:48:42,320
並將其更改為指向
同樣的指針對象作為另一個指針。

1191
00:48:42,320 --> 00:48:44,160
因此，在轉讓之後，
這兩個指針

1192
00:48:44,160 --> 00:48:45,910
將指向同一個指針對象。

1193
00:48:45,910 --> 00:48:47,990
有時候，這就是所謂的共享。

1194
00:48:47,990 --> 00:48:49,740
而這一切就是這麼簡單，真的。

1195
00:48:49,740 --> 00:48:50,277
再見了。

1196
00:48:50,277 --> 00:48:51,110
[完視頻回放]

1197
00:48:51,110 --> 00:48:52,568
戴維·J·馬蘭：這就是它的CS50。

1198
00:48:52,568 --> 00:48:55,110
我們會看到你下週。

1199
00:48:55,110 --> 00:48:56,064