1
00:00:00,000 --> 00:00:11,242
>> [音樂播放]

2
00:00:11,242 --> 00:00:16,630
>> DAVID J.馬蘭：好吧，這是CS50
這是5週開始。

3
00:00:16,630 --> 00:00:21,480
所以今天，坐墊底下，
你不會找到任何東西。

4
00:00:21,480 --> 00:00:24,790
但最重要的，你應該找到這些，
我們欣賞的一點小小的心意

5
00:00:24,790 --> 00:00:26,970
你把所有的工作
進入15遊戲。

6
00:00:26,970 --> 00:00:30,290
只要簡單地除去小圈上
底部開始打

7
00:00:30,290 --> 00:00:31,680
其餘類。

8
00:00:31,680 --> 00:00:38,930
>> 所以記得或知道這個問題集
四，本週末出去，

9
00:00:38,930 --> 00:00:40,340
涉及編寫另一場比賽。

10
00:00:40,340 --> 00:00:43,740
但是，這一次，它涉及到使用
實際的圖形用戶界面，而不是一個

11
00:00:43,740 --> 00:00:46,310
文本界面，如
十五的遊戲。

12
00:00:46,310 --> 00:00:50,210
而本場比賽在於你前面，
如果你還沒有見過這下，

13
00:00:50,210 --> 00:00:52,310
看起來有點像這樣的東西。

14
00:00:52,310 --> 00:00:55,170
我要進入我的終端
在GDB窗口。

15
00:00:55,170 --> 00:00:58,600
而且我要繼續前進並運行
員工的解決方案，您可以訪問

16
00:00:58,600 --> 00:01:01,010
運行update 50後，像往常一樣。

17
00:01:01,010 --> 00:01:04,090
>> 不過，我打算把它放入少許
秘密模式，一點點的復活節彩蛋，

18
00:01:04,090 --> 00:01:08,480
所謂的上帝模式，
讓上帝argv1。

19
00:01:08,480 --> 00:01:12,920
我要按照我自己的方向，
在我自己的運行

20
00:01:12,920 --> 00:01:14,220
問題設置目錄。

21
00:01:14,220 --> 00:01:19,190
所以，現在你看到一個完整的版本
的突圍的比賽。

22
00:01:19,190 --> 00:01:21,090
其實，這是沒有手模式。

23
00:01:21,090 --> 00:01:24,850
因此，它實際上是 - 

24
00:01:24,850 --> 00:01:26,470
叫絕儘管你可能會對 - 

25
00:01:26,470 --> 00:01:30,850
很容易實現上帝模式
突圍，不像十五的遊戲，

26
00:01:30,850 --> 00:01:33,590
一些你可能已經解決
黑客版。

27
00:01:33,590 --> 00:01:37,890
>> 在突圍中，只要在上帝
模式簡單地做什麼，

28
00:01:37,890 --> 00:01:41,220
直觀地與槳？

29
00:01:41,220 --> 00:01:45,630
只要使它等於不管
水平位置的球。

30
00:01:45,630 --> 00:01:49,220
所以只要你做到這一點步調一致
，球移動這個遊戲會

31
00:01:49,220 --> 00:01:53,100
永遠，永遠，永遠錯過了球
你會每次都贏。

32
00:01:53,100 --> 00:01:55,430
>> 但在本週的黑客版
有以上只是上帝模式。

33
00:01:55,430 --> 00:01:56,720
有一些其他功能。

34
00:01:56,720 --> 00:01:58,140
其中，激光器。

35
00:01:58,140 --> 00:02:01,070
所以，如果你真的不耐煩
可以擊落磚開始

36
00:02:01,070 --> 00:02:02,120
和其他幾個人。

37
00:02:02,120 --> 00:02:04,560
而對於那些你誰想要
校準標準與黑客

38
00:02:04,560 --> 00:02:08,750
版，我可以看到，本週的
黑客版故意是一個

39
00:02:08,750 --> 00:02:12,830
更可行一點，也就是說，不是神
模式是與遊戲的十五。

40
00:02:12,830 --> 00:02:15,300
>> 所以，如果你正在尋找一個舒展和
你正在尋找一些額外的樂趣

41
00:02:15,300 --> 00:02:18,400
如果感興趣的功能做潛水。

42
00:02:18,400 --> 00:02:21,280
現在更實際，讓我點
一件事。

43
00:02:21,280 --> 00:02:24,780
GDB，有些人可能還沒有
親自感動，這是很好的。

44
00:02:24,780 --> 00:02:28,530
但現在是真正的時間來習慣
這和舒適的使用這個工具

45
00:02:28,530 --> 00:02:31,510
因為它會讓你的生活
更容易，真正做到。

46
00:02:31,510 --> 00:02:34,900
>> 每羅布GDB的一對夫婦的講座
數週前，記得

47
00:02:34,900 --> 00:02:36,810
，GDB調試器。

48
00:02:36,810 --> 00:02:41,230
這是一個工具，可以讓你運行你的
程序，但運行它一步一步，線

49
00:02:41,230 --> 00:02:45,680
行，讓你可以閒逛，
所以，你看到的事情發生，所以

50
00:02:45,680 --> 00:02:47,310
您可以打印出來
變量的值。

51
00:02:47,310 --> 00:02:50,580
總之，它給了你這麼多
功率比printDef。

52
00:02:50,580 --> 00:02:52,900
>> 誠然，現在的界面
是相當神秘。

53
00:02:52,900 --> 00:02:55,180
黑色和白色的文本界面
在大多數情況下。

54
00:02:55,180 --> 00:02:57,400
命令有些艱難
記得在第一。

55
00:02:57,400 --> 00:03:01,230
但是，即使它可能需要你的一半
一個小時，一個小時，把前期

56
00:03:01,230 --> 00:03:02,940
投資的時間把它，相信我。

57
00:03:02,940 --> 00:03:06,440
當然學期的結束，這將節省
你一個數量級以上

58
00:03:06,440 --> 00:03:07,600
時間比。

59
00:03:07,600 --> 00:03:09,200
>> 所以早在本週長驅直入

60
00:03:09,200 --> 00:03:13,200
在突圍方面，知道你
能做到這一點，只要你有

61
00:03:13,200 --> 00:03:18,230
分配代碼或您自己的代碼
在建您的Pst4目錄。

62
00:03:18,230 --> 00:03:21,680
要知道，你可以運行gdb。/突破。

63
00:03:21,680 --> 00:03:23,490
>> 這將開闢
這樣的窗口。

64
00:03:23,490 --> 00:03:25,530
讓我給自己更多
一個終端窗口。

65
00:03:25,530 --> 00:03:27,770
然後呢，我要繼續前進
做的，它的不只是運行它。

66
00:03:27,770 --> 00:03:30,690
我要首先設置了一個破發點
召回，它允許你暫停

67
00:03:30,690 --> 00:03:32,500
在一個特定的地方執行。

68
00:03:32,500 --> 00:03:35,750
>> 只是為了簡單起見，我要去
只需鍵入打破行一

69
00:03:35,750 --> 00:03:37,000
頭號。

70
00:03:37,000 --> 00:03:40,080

71
00:03:40,080 --> 00:03:43,250
實際上讓我重新打開此窗口
因為它才獲得了

72
00:03:43,250 --> 00:03:45,700
有一點小。

73
00:03:45,700 --> 00:03:53,270
所以現在，我要在這裡做什麼
如果我打開終端窗口。

74
00:03:53,270 --> 00:03:53,910
來吧，我們去那裡。

75
00:03:53,910 --> 00:03:59,850
>> 所以，現在如果我回去到Dropbox，Pst4
運行gdb。/突破進入，請注意

76
00:03:59,850 --> 00:04:02,600
我要打破一個設置
一個破發點，線一條。

77
00:04:02,600 --> 00:04:04,840
現在我要去
運行前方和類型。

78
00:04:04,840 --> 00:04:07,370
而當我這樣做，注意什麼
似乎發生。

79
00:04:07,370 --> 00:04:08,120
>> 有沒有彈出。

80
00:04:08,120 --> 00:04:09,790
有沒有圖形
用戶界面。

81
00:04:09,790 --> 00:04:13,340
但是，這是可以理解的，因為我
字面上線在我的計劃之一。

82
00:04:13,340 --> 00:04:17,110
注意到我快進，
特別是現在到62，因為所有的

83
00:04:17,110 --> 00:04:20,600
在這個文件的頂部的東西是
像註釋和常量和

84
00:04:20,600 --> 00:04:22,460
現在的無趣的東西。

85
00:04:22,460 --> 00:04:25,840
>> 所以我現在的主要內，
看起來，在第62行。

86
00:04:25,840 --> 00:04:27,960
而這僅僅是分配
代碼，召回。

87
00:04:27,960 --> 00:04:33,810
如果我開這件事，同樣，
進入我的下拉框成Pst4目錄，

88
00:04:33,810 --> 00:04:35,450
到breakout.c。

89
00:04:35,450 --> 00:04:40,670
如果我向下滾動下來，下來，
並讓我繼續前進，打開

90
00:04:40,670 --> 00:04:44,990
我的行號。

91
00:04:44,990 --> 00:04:50,300
>> 我會看到什麼，如果我向下滾動到
62號線，是完全行

92
00:04:50,300 --> 00:04:50,910
我們已經暫停。

93
00:04:50,910 --> 00:04:53,720
因此，這條線在這裡，62歲，
我們是。

94
00:04:53,720 --> 00:04:57,470
所以，現在在GDB，如果我先走，然後鍵入
現在下，進入它要

95
00:04:57,470 --> 00:04:58,450
執行這條線。

96
00:04:58,450 --> 00:05:00,610
瞧，我們有
所謂的克窗口。

97
00:05:00,610 --> 00:05:02,800
如果什麼GWindow不熟悉
，不用擔心。

98
00:05:02,800 --> 00:05:05,740
該規範將為您介紹它，因為
以及大量的演練視頻

99
00:05:05,740 --> 00:05:06,830
嵌入在規範中。

100
00:05:06,830 --> 00:05:08,610
>> 但現在讓我們做一個
更有趣一點。

101
00:05:08,610 --> 00:05:10,960
讓我移動這個窗口
一邊一點點。

102
00:05:10,960 --> 00:05:13,480
讓我一點窗戶
更大，所以我可以看到更多。

103
00:05:13,480 --> 00:05:16,140
>> 現在讓我繼續
和再下一步要做。

104
00:05:16,140 --> 00:05:17,550
而且有我的磚。

105
00:05:17,550 --> 00:05:20,490
如果我再接下來鍵入
現在我看到球。

106
00:05:20,490 --> 00:05:23,520
如果我再接下來鍵入
現在我明白了槳。

107
00:05:23,520 --> 00:05:26,690
>> 幸運的是，這gedit中不
通過展示我真正合作

108
00:05:26,690 --> 00:05:27,660
我想要的一切。

109
00:05:27,660 --> 00:05:30,820
但現在如果我再下一步做，
再接下來，我只是

110
00:05:30,820 --> 00:05:32,260
聲明一些變量。

111
00:05:32,260 --> 00:05:34,750
我可以打印任何一個
這些傢伙。

112
00:05:34,750 --> 00:05:37,170
打印磚，版畫的生活。

113
00:05:37,170 --> 00:05:39,910
>> 現在如果我繼續做
接下來，請注意，我會

114
00:05:39,910 --> 00:05:40,870
裡面的這個循環。

115
00:05:40,870 --> 00:05:43,380
但是代碼執行
正是因為我的期望。

116
00:05:43,380 --> 00:05:45,810
所以，當我打這個功能，等待
按一下，它會做

117
00:05:45,810 --> 00:05:46,830
它的字面。

118
00:05:46,830 --> 00:05:48,870
所以，我似乎已經失去了控制
在節目。

119
00:05:48,870 --> 00:05:50,480
>> GDB是不給我另一個提示。

120
00:05:50,480 --> 00:05:51,500
但不用擔心。

121
00:05:51,500 --> 00:05:53,720
轉到我的遊戲，點擊的地方。

122
00:05:53,720 --> 00:05:56,270
>> 瞧，現在進行到第86行。

123
00:05:56,270 --> 00:05:59,460
再次，它是無價的，最終，
調試問題。

124
00:05:59,460 --> 00:06:03,050
因為你可以從字面上步驟通過
你的代碼，打印多東西出來，

125
00:06:03,050 --> 00:06:03,640
多少，等等。

126
00:06:03,640 --> 00:06:07,210
但現在，這些工具本身
應該讓你很遠。

127
00:06:07,210 --> 00:06:10,050
>> 因此，我們，當然，考慮看看
現在顯卡，一下子。

128
00:06:10,050 --> 00:06:12,350
現在我們的世界變得有點
更有趣。

129
00:06:12,350 --> 00:06:15,680
你知道，或許，從一些
我們這些在線視頻

130
00:06:15,680 --> 00:06:18,280
短褲，你已經看
習題集的一部分。

131
00:06:18,280 --> 00:06:20,460
>> 他們已經出手，故意
以白色背景。

132
00:06:20,460 --> 00:06:23,380
他們中的一些教學
圖紙上的某些文本研究員

133
00:06:23,380 --> 00:06:25,490
屏幕覆蓋
上側。

134
00:06:25,490 --> 00:06:27,760
不過，當然，這還不是全部，
在現實世界中有趣。

135
00:06:27,760 --> 00:06:30,520
這僅僅是一個與報告廳
白色的大屏幕和背景。

136
00:06:30,520 --> 00:06:33,330
我們驚人的生產隊排序
讓一切看上去很美

137
00:06:33,330 --> 00:06:36,620
通過裁剪後的事實
或覆蓋任何東西

138
00:06:36,620 --> 00:06:37,840
我們做什麼或不想要的。

139
00:06:37,840 --> 00:06:41,560
>> 現在只是為了激勵這個星期，
真的，你可以去，最終，

140
00:06:41,560 --> 00:06:42,560
計算機科學。

141
00:06:42,560 --> 00:06:44,260
問題後，不只是設置了四個。

142
00:06:44,260 --> 00:06:48,240
但之後其他課程或整個
課程是驚人的，你可以

143
00:06:48,240 --> 00:06:51,090
這幾天而言，
尤其是在圖形。

144
00:06:51,090 --> 00:06:53,440
>> 你們當中有些人可能已經看到了這
網上四處流淌。

145
00:06:53,440 --> 00:06:56,240
但我想我會告訴你，只是一個
兩分鐘，一窺究竟

146
00:06:56,240 --> 00:07:01,890
計算機技術和CGI
計算機圖形可以做這些天

147
00:07:01,890 --> 00:07:04,510
熟悉的歌曲
也許電影。

148
00:07:04,510 --> 00:07:05,760
>> [MUSIC  -  LANA DEL射線，
“年輕和美麗]

149
00:07:05,760 --> 00:10:50,270

150
00:10:50,270 --> 00:10:52,470
>> 揚聲器1：這只是一點點
驚人的，也許，只是如何

151
00:10:52,470 --> 00:10:52,857
無處不在 - 

152
00:10:52,857 --> 00:10:57,040
>> [掌聲]

153
00:10:57,040 --> 00:10:59,230
>> 揚聲器1：我剛下載了它。

154
00:10:59,230 --> 00:11:02,920
但它真的很神奇，我想，只要
無所不在的軟件和代碼，

155
00:11:02,920 --> 00:11:04,230
真的是這樣的工具。

156
00:11:04,230 --> 00:11:07,685
所以這是一個品味的方向
在其中，你可以走了。

157
00:11:07,685 --> 00:11:10,620
哦，沒有更多的電器。

158
00:11:10,620 --> 00:11:14,640
嗯，這實際上是悲慘的時機
點我只是試圖讓。

159
00:11:14,640 --> 00:11:18,670
>> 好吧，讓我們推出
再次融合。

160
00:11:18,670 --> 00:11:20,800
稍後提醒我。

161
00:11:20,800 --> 00:11:24,190
沒事了，你應該有一個
順便說一句，如果你確實得到了電子郵件

162
00:11:24,190 --> 00:11:25,460
類似的通知。

163
00:11:25,460 --> 00:11:29,940
好吧，所以記得，上週
我們開始剝離回

164
00:11:29,940 --> 00:11:31,380
後來被稱為串。

165
00:11:31,380 --> 00:11:34,700
>> 字符串回憶起一個數據類型
宣派CS50庫。

166
00:11:34,700 --> 00:11:37,740
它的一部分訓練輪
現在將開始起飛。

167
00:11:37,740 --> 00:11:41,280
這是一個有用的概念，早期。

168
00:11:41,280 --> 00:11:43,750
但現在它要得到更多
有趣和更強大

169
00:11:43,750 --> 00:11:48,330
實際看到的引擎蓋下，
一個字符串就是什麼，我們說的嗎？

170
00:11:48,330 --> 00:11:50,500
>> 是啊，所以這是一個所謂的char *。

171
00:11:50,500 --> 00:11:53,860
*表示有
涉及某種形式的地址。

172
00:11:53,860 --> 00:11:58,690
因此，當你說你的char *僅僅意味著
一個變量，其數據類型是一個

173
00:11:58,690 --> 00:11:59,290
指針現在。

174
00:11:59,290 --> 00:12:01,770
事實上，有星級
只是意味著你聲明

175
00:12:01,770 --> 00:12:03,020
所謂的指針。

176
00:12:03,020 --> 00:12:06,220
該指針是怎麼回事顯然
存儲的地址，

177
00:12:06,220 --> 00:12:07,810
當然，一個字符。

178
00:12:07,810 --> 00:12:08,960
>> 現在為什麼不這樣做有意義嗎？

179
00:12:08,960 --> 00:12:11,200
那麼，什麼是一個字符串
引擎蓋下？

180
00:12:11,200 --> 00:12:15,130
那麼，未來一段時間，我們一直在說
引擎蓋下是一個字符串

181
00:12:15,130 --> 00:12:18,460
只是H-E-L-L-ø，例如。

182
00:12:18,460 --> 00:12:21,585
>> 但我們已經談到這是
即，本質上，一個數組。

183
00:12:21,585 --> 00:12:25,410
陣列，然後看起來有點
類似這樣的，與這些

184
00:12:25,410 --> 00:12:26,460
咬了一口。

185
00:12:26,460 --> 00:12:28,710
然後我們說，有
一些特別的東西，回到這裡，

186
00:12:28,710 --> 00:12:31,270
反斜線0或null終止。

187
00:12:31,270 --> 00:12:35,230
>> 所以這一切的時候，在這裡
一個字符串。

188
00:12:35,230 --> 00:12:38,320
不過說真的，一串串
實際上是一個地址。

189
00:12:38,320 --> 00:12:43,210
和地址，如我們所看到的，往往是
按照慣例用0x前綴。

190
00:12:43,210 --> 00:12:44,540
0X表示什麼？

191
00:12:44,540 --> 00:12:45,970
有誰知道？

192
00:12:45,970 --> 00:12:47,320
>> 因此，它只是表示十六進制。

193
00:12:47,320 --> 00:12:52,360
所以，你可能還記得，實際上，從PST
1，我相信，一個熱身

194
00:12:52,360 --> 00:12:55,740
問題居然問
十六進制表示法中除了

195
00:12:55,740 --> 00:12:57,100
二進制和十進制。

196
00:12:57,100 --> 00:13:00,460
這裡的動機是
與十六進制你有16

197
00:13:00,460 --> 00:13:01,770
數字在您的處置。

198
00:13:01,770 --> 00:13:07,900
0，1，2，3，4，5，6，7，8，9，其次
由A，B，C，D，E，F。

199
00:13:07,900 --> 00:13:10,430
>> 如果算上所有這些向上，
你得到了總共16個。

200
00:13:10,430 --> 00:13:13,200
因此，這是在對比
小數，其中有10個

201
00:13:13,200 --> 00:13:14,690
數字0到9。

202
00:13:14,690 --> 00:13:17,750
它的對比度與二進制
我們只是0和1。

203
00:13:17,750 --> 00:13:21,450
>> 但在年底的一天，你可以
表示相同的數字，但

204
00:13:21,450 --> 00:13:22,500
有所不同。

205
00:13:22,500 --> 00:13:25,840
和十六進制是常見的，因為
事實證明 - 我們將看到這一點

206
00:13:25,840 --> 00:13:28,790
後面的課程 - 即使當我們得到
web編程的背景下，

207
00:13:28,790 --> 00:13:32,100
HTML和顏色代碼，
十六進制是好的。

208
00:13:32,100 --> 00:13:36,390
因為每一個數字，事實證明，
代表完美四位。

209
00:13:36,390 --> 00:13:39,280
因此，它只是一種很好的線
因為我們最終會看到。

210
00:13:39,280 --> 00:13:44,720
所以這可能是Ox123或東西
這樣，表示地址123

211
00:13:44,720 --> 00:13:47,050
裡面有我的地方
計算機的內存。

212
00:13:47,050 --> 00:13:50,600
>> 不過，當然，出現了一些問題
因為這一基本

213
00:13:50,600 --> 00:13:51,520
實現。

214
00:13:51,520 --> 00:13:55,930
記得我把刺在
實現這樣的功能 - 

215
00:13:55,930 --> 00:14:00,260
比較破折號0 C點上週
即使它看起來就像是

216
00:14:00,260 --> 00:14:04,270
沒錯，它根本不比較
兩個字符串正確。

217
00:14:04,270 --> 00:14:07,470
>> 我扔掉的主，我已經拋出
遠的意見只是集中在上

218
00:14:07,470 --> 00:14:08,970
代碼的興趣。

219
00:14:08,970 --> 00:14:10,660
，它是紅色的，因為它是越野車。

220
00:14:10,660 --> 00:14:11,670
什麼原因呢？

221
00:14:11,670 --> 00:14:15,890
>> 嗯，上方還有，當我宣布
一個字符串，什麼是真的

222
00:14:15,890 --> 00:14:17,260
引擎蓋下？

223
00:14:17,260 --> 00:14:19,530
那麼，就讓我走了過來的
此處的畫面和借鑒。

224
00:14:19,530 --> 00:14:23,230
所以，我再次宣布，
字符串s的GetString。

225
00:14:23,230 --> 00:14:26,640
>> 所以我要繼續前進，現在
畫為它到底是什麼。

226
00:14:26,640 --> 00:14:28,590
這將是一個正方形。

227
00:14:28,590 --> 00:14:30,490
我要去要求
那是32位。

228
00:14:30,490 --> 00:14:32,890
至少它通常是，
至少在CS50

229
00:14:32,890 --> 00:14:34,520
很多計算機的器具。

230
00:14:34,520 --> 00:14:35,980
我會打電話給它s。

231
00:14:35,980 --> 00:14:39,070
>> 但是，現在還記得我們
稱為GetString的。

232
00:14:39,070 --> 00:14:41,430
所以GetString的回報，
當然，一個字符串。

233
00:14:41,430 --> 00:14:45,790
如果H-E-L-L-Ø用戶類型進入
獲取返回字符串hello。

234
00:14:45,790 --> 00:14:51,010
而該字符串，正如我們剛才所說，結束
某處在您的計算機的內存

235
00:14:51,010 --> 00:14:53,240
在最後一個反斜杠0。

236
00:14:53,240 --> 00:14:56,650
我會得出這樣的像數組 - 
連續的字符塊 - 

237
00:14:56,650 --> 00:14:58,330
它實際上是。

238
00:14:58,330 --> 00:15:01,790
>> 而現在，則由GetString引發什麼
實際上返回？

239
00:15:01,790 --> 00:15:04,340
有什麼的GetString返回
所有這段時間呢？

240
00:15:04,340 --> 00:15:07,520
好吧，我們說，在幾週之前，
它返回一個字符串。

241
00:15:07,520 --> 00:15:10,250
但更多的技術上的，這是什麼
顯然則由GetString引發返回？

242
00:15:10,250 --> 00:15:11,610
>> 觀眾：一個地址。

243
00:15:11,610 --> 00:15:12,600
>> 揚聲器1：一個地址。

244
00:15:12,600 --> 00:15:16,630
具體來說，它返回的地址
第一口，不​​管它是什麼。

245
00:15:16,630 --> 00:15:18,830
我只是不停地用一，二，三
因為它的方便。

246
00:15:18,830 --> 00:15:21,380
>> 返回地址的第一個
字符串中的字符。

247
00:15:21,380 --> 00:15:23,510
我們上週說，
是足夠的。

248
00:15:23,510 --> 00:15:26,710
因為我們總是可以找出其中
僅僅通過結束的字符串

249
00:15:26,710 --> 00:15:30,150
遍歷它，也許，與為
循環或while循環或類似的東西

250
00:15:30,150 --> 00:15:34,990
，只是在尋找“反斜線0”，
特殊定點字符。

251
00:15:34,990 --> 00:15:37,220
>> 然後我們知道該字符串
的長度恰好是 - 

252
00:15:37,220 --> 00:15:37,980
在這種情況下 - 

253
00:15:37,980 --> 00:15:38,670
五。

254
00:15:38,670 --> 00:15:43,800
因此，技術上的GetString做什麼
是在這種情況下，它返回Ox123。

255
00:15:43,800 --> 00:15:53,670
技術上然後發生了什麼
我們存儲，裡面的s，Ox123。

256
00:15:53,670 --> 00:15:56,460
在一天結束時，儘管這
是新的概念，指針，他們

257
00:15:56,460 --> 00:15:57,350
只是變量。

258
00:15:57,350 --> 00:16:00,440
但他們碰巧存儲位
共同表示一個地址。

259
00:16:00,440 --> 00:16:03,700
所以技術上都得到
在s中存儲的是Ox123。

260
00:16:03,700 --> 00:16:04,680
>> 但我們作為人類 - 

261
00:16:04,680 --> 00:16:06,020
包括今天起 - 

262
00:16:06,020 --> 00:16:09,290
真的不會在意，通常，
實際地址是什麼

263
00:16:09,290 --> 00:16:10,520
一些大塊的內存。

264
00:16:10,520 --> 00:16:14,040
這只是低水平的細節
智力有趣。

265
00:16:14,040 --> 00:16:15,440
所以我打算撤消此。

266
00:16:15,440 --> 00:16:19,810
，而是更多的高層次，只是說
當我們在談論指針

267
00:16:19,810 --> 00:16:22,170
我要吸引更多
用戶友好的箭頭，傳達

268
00:16:22,170 --> 00:16:26,060
同樣的想法和摘要走
什麼實際的詳情

269
00:16:26,060 --> 00:16:27,700
基礎地址。

270
00:16:27,700 --> 00:16:33,290
>> 現在，如果我們回去的代碼，
上週發生，如果我們有字符串t

271
00:16:33,290 --> 00:16:34,510
等於則由GetString引發？

272
00:16:34,510 --> 00:16:38,630
好吧，如果我再次類型打招呼
這次我會得到

273
00:16:38,630 --> 00:16:40,460
另一塊內存。

274
00:16:40,460 --> 00:16:44,820
H-E-L-L-O反斜線0。

275
00:16:44,820 --> 00:16:48,320
>> 但是，因為我要求則由GetString引發
第二次 - 

276
00:16:48,320 --> 00:16:51,100
我知道這看著
GetString的源代碼 - 即使

277
00:16:51,100 --> 00:16:54,350
雖然這是巧合，打招呼
輸入兩次，GetString的是不

278
00:16:54,350 --> 00:16:55,890
要嘗試優化
和聰明。

279
00:16:55,890 --> 00:16:58,550
只是要得到另一塊
從計算機中的存儲器，這是

280
00:16:58,550 --> 00:16:59,640
要在另一個地址。

281
00:16:59,640 --> 00:17:02,330
讓我們任意只是說456。

282
00:17:02,330 --> 00:17:04,079
>> 然後它是什麼會回來？

283
00:17:04,079 --> 00:17:08,030
這將返回456
並將其存儲在t。

284
00:17:08,030 --> 00:17:12,010
那麼，什麼是真的，在
左側是我有另一塊

285
00:17:12,010 --> 00:17:14,260
內存，通常是32位。

286
00:17:14,260 --> 00:17:16,720
在那裡要去Ox456。

287
00:17:16,720 --> 00:17:20,140
不過，我沒有興趣在這些
特殊的數字了。

288
00:17:20,140 --> 00:17:23,069
我只是抽象
繪製箭頭。

289
00:17:23,069 --> 00:17:25,202
>> 所以這是現在一種新的解釋。

290
00:17:25,202 --> 00:17:28,735
但它是完全相同的想法
發生這一切的時候。

291
00:17:28,735 --> 00:17:33,150
等原因，那麼，這首
版本比較的是越野車，

292
00:17:33,150 --> 00:17:34,480
上週是為什麼呢？

293
00:17:34,480 --> 00:17:38,000
當你這樣做，如果s等於等於
什麼是你真正的噸

294
00:17:38,000 --> 00:17:40,550
引擎蓋下比較？

295
00:17:40,550 --> 00:17:41,910
>> 你的地址進行比較。

296
00:17:41,910 --> 00:17:47,950
只是直觀，清晰，Ox123
不會等於Ox456。

297
00:17:47,950 --> 00:17:49,380
這些數字，那些位
只是不同而已。

298
00:17:49,380 --> 00:17:53,220
>> 所以一致，上週說
你鍵入不同的事情，即使

299
00:17:53,220 --> 00:17:55,360
話逐字相同。

300
00:17:55,360 --> 00:17:58,770
因此，我們解決這個問題。

301
00:17:58,770 --> 00:18:00,120
通俗地說，什麼是修復？

302
00:18:00,120 --> 00:18:02,110
>> 觀眾：使用功能。

303
00:18:02,110 --> 00:18:02,870
>> 揚聲器1：使用功能。

304
00:18:02,870 --> 00:18:05,190
明星們肯定參與，
但使用功能做什麼呢？

305
00:18:05,190 --> 00:18:05,962
>> 觀眾：要比較字符串。

306
00:18:05,962 --> 00:18:07,390
>> 揚聲器1：比較字符串。

307
00:18:07,390 --> 00:18:11,030
所以這裡的根本問題是
我只是考慮

308
00:18:11,030 --> 00:18:15,870
質量被定義的字符串
他們的地址相比較。

309
00:18:15,870 --> 00:18:18,540
很顯然，這只是愚蠢的現在一次
你明白這是怎麼回事

310
00:18:18,540 --> 00:18:19,510
引擎蓋下。

311
00:18:19,510 --> 00:18:23,270
要真正比較字符串，看是否
他們是平等的，一個人的方式

312
00:18:23,270 --> 00:18:26,680
會考慮兩個字符串是否相等
我們需要對它們進行比較字符

313
00:18:26,680 --> 00:18:28,070
對於字符。

314
00:18:28,070 --> 00:18:30,020
>> 現在我可以做
這很繁瑣。

315
00:18:30,020 --> 00:18:32,240
但是，我們親熱
使用for循環。

316
00:18:32,240 --> 00:18:36,050
而只比較Ş支架
我對T支架í。

317
00:18:36,050 --> 00:18:39,590
Ş支架I加1對T支架
i加1，依此類推，裡面

318
00:18:39,590 --> 00:18:40,580
某種循環。

319
00:18:40,580 --> 00:18:44,950
如果我發現任何兩個字符
不同，或者如果我意識到，哦，S

320
00:18:44,950 --> 00:18:48,410
小於t或長於t
我可以馬上說是假的，

321
00:18:48,410 --> 00:18:49,390
他們是不一樣的。

322
00:18:49,390 --> 00:18:55,370
>> 但如果我通過s和t說
相同的，相同的，相同的，相同的，同樣，年底

323
00:18:55,370 --> 00:18:58,520
這兩個字符串，我可以說，
真的，他們都是平等的。

324
00:18:58,520 --> 00:19:01,040
那麼，令人欣慰的是，幾年前，有人
為我們寫的代碼。

325
00:19:01,040 --> 00:19:03,790
>> 他們把它稱為StrComp
字符串比較。

326
00:19:03,790 --> 00:19:11,900
即使它是一個小櫃檯
直觀，StrComp返回0，如果這些

327
00:19:11,900 --> 00:19:14,520
兩個字符串中，s和t是相同的。

328
00:19:14,520 --> 00:19:18,090
但是，如果返回負值
應該是之前按字母順序或

329
00:19:18,090 --> 00:19:20,610
它應該是正值，如果
後T字母順序排列。

330
00:19:20,610 --> 00:19:24,030
>> 所以，如果你要排序的東西，
StrComp是有用的。

331
00:19:24,030 --> 00:19:26,660
因為它不只是說
yes或no，等於或不。

332
00:19:26,660 --> 00:19:30,440
它給你一個訂貨感
喜歡字典威力。

333
00:19:30,440 --> 00:19:33,770
所以StrComp，S逗號T等於
等於0，則表示

334
00:19:33,770 --> 00:19:35,200
字符串是真正的平等。

335
00:19:35,200 --> 00:19:38,680
因為誰寫了這個功能
幾年前大概使用了一個for循環

336
00:19:38,680 --> 00:19:42,840
或一個while循環或類似的東西
再次，整合過的字符

337
00:19:42,840 --> 00:19:45,270
一遍又一遍。

338
00:19:45,270 --> 00:19:47,300
>> 但這裡出現問題2。

339
00:19:47,300 --> 00:19:48,750
這是copy0.c。

340
00:19:48,750 --> 00:19:51,680
和兩個紅色
因為它是有缺陷的。

341
00:19:51,680 --> 00:19:52,800
我們做了什麼？

342
00:19:52,800 --> 00:19:54,310
嗯，首先我叫則由GetString引發。

343
00:19:54,310 --> 00:19:56,255
我和存儲在s的返回值。

344
00:19:56,255 --> 00:20:00,260
所以這是相當多的相同
這個圖片的上部。

345
00:20:00,260 --> 00:20:01,490
>> 但之後呢？

346
00:20:01,490 --> 00:20:04,980
好吧，讓我繼續前進，擺脫
一大堆。

347
00:20:04,980 --> 00:20:09,650
我們的地方，我們只是時間會倒轉
有，這是現在一致

348
00:20:09,650 --> 00:20:10,940
線那裡。

349
00:20:10,940 --> 00:20:11,400
>> 我檢查。

350
00:20:11,400 --> 00:20:13,450
如果s等於等於0。

351
00:20:13,450 --> 00:20:18,670
現在，快速側面說明，當
可能的GetString返回0？

352
00:20:18,670 --> 00:20:19,580
有沒有足夠的內存。

353
00:20:19,580 --> 00:20:19,880
對嗎？

354
00:20:19,880 --> 00:20:22,310
>> 這是罕見的，這是將要發生，
當然這是一個計算機

355
00:20:22,310 --> 00:20:24,740
有數百兆
甚至音樂會的RAM。

356
00:20:24,740 --> 00:20:27,080
但也有可能，在理論上，返回
0，特別是如果

357
00:20:27,080 --> 00:20:28,080
用戶不配合。

358
00:20:28,080 --> 00:20:31,640
有辦法假裝像你有沒有
輸入任何東西和訣竅

359
00:20:31,640 --> 00:20:34,100
返回到則由GetString引發
0有效。

360
00:20:34,100 --> 00:20:35,470
>> 因此，它要檢查。

361
00:20:35,470 --> 00:20:39,430
因為如果你開始
已經得到的，分割故障 - 

362
00:20:39,430 --> 00:20:42,280
這可能是一個源
有些無奈 - 

363
00:20:42,280 --> 00:20:46,150
這些結果幾乎總是
內存相關的錯誤。

364
00:20:46,150 --> 00:20:50,440
不知怎的，你搞砸了，對於一個
指針，即使你沒有意識到

365
00:20:50,440 --> 00:20:51,530
有一個指針。

366
00:20:51,530 --> 00:20:55,260
所以，你可能誘發分割
早在第一個星期使用故障

367
00:20:55,260 --> 00:21:02,100
像一個循環或while
循環和陣列走得太遠的

368
00:21:02,100 --> 00:21:05,900
過去的一些陣列的邊界
宣布，在本週二

369
00:21:05,900 --> 00:21:06,690
尤其如此。

370
00:21:06,690 --> 00:21:09,220
>> 你可能已經做了，即使問題
設置四個與突圍。

371
00:21:09,220 --> 00:21:12,910
即使你可能從來沒有見過
任何恆星分佈代碼

372
00:21:12,910 --> 00:21:17,410
突圍，事實證明，那些GRect
和GOval和其他這樣的事情，

373
00:21:17,410 --> 00:21:19,650
其實這些都是指針
引擎蓋下。

374
00:21:19,650 --> 00:21:23,430
>> 但是，斯坦福大學，像我們這樣的，排序的皮革
至少詳細的庫

375
00:21:23,430 --> 00:21:26,540
的目的，就像我們做
字符串和char *。

376
00:21:26,540 --> 00:21:30,060
但GRect GOval所有這些
你們的事情或將使用

377
00:21:30,060 --> 00:21:32,630
這個星期都少不了
內存地址。

378
00:21:32,630 --> 00:21:33,650
你只是不知道這一點。

379
00:21:33,650 --> 00:21:37,240
>> 所以這是不奇怪的話，也許，
你可能會絆倒一些

380
00:21:37,240 --> 00:21:38,580
段故障。

381
00:21:38,580 --> 00:21:41,290
但是，什麼是有趣的，
如果我們檢查後我們做

382
00:21:41,290 --> 00:21:43,460
字符串t得到s。

383
00:21:43,460 --> 00:21:44,690
好吧，讓我申報噸。

384
00:21:44,690 --> 00:21:47,730
我打算把它畫一個正方形，
32位，它噸。

385
00:21:47,730 --> 00:21:49,740
然後我要做的事情，得到s。

386
00:21:49,740 --> 00:21:51,130
>> 那麼，是什麼意思呢？

387
00:21:51,130 --> 00:21:53,280
嗯，這是一個有點很難想像
關於它的想像明智的。

388
00:21:53,280 --> 00:21:55,025
但是讓我們想想
裡面的x是什麼？

389
00:21:55,025 --> 00:21:59,430
這裡面變量字面上什麼？

390
00:21:59,430 --> 00:22:01,500
價值Ox123。

391
00:22:01,500 --> 00:22:05,815
>> 所以當我說字符串t得到s，這只是
字面意思是取數

392
00:22:05,815 --> 00:22:10,070
在s，這是Ox123，並把它Ox123。

393
00:22:10,070 --> 00:22:13,740
或形象，如果我有點抽象
遠離細節，它有

394
00:22:13,740 --> 00:22:16,600
從字面上做效果
這一點。

395
00:22:16,600 --> 00:22:22,110
>> 所以，現在，回想起上週
我們進行資本主義T.我

396
00:22:22,110 --> 00:22:23,800
Ť支架0。

397
00:22:23,800 --> 00:22:27,150
那麼，T支架0，即使它是一個
指針，你可以把它彷彿

398
00:22:27,150 --> 00:22:29,220
它是一個數組，用方形
支架符號。

399
00:22:29,220 --> 00:22:31,550
>> 那麼，是T支架0？

400
00:22:31,550 --> 00:22:32,990
那麼，它的h。

401
00:22:32,990 --> 00:22:36,800
因此，當我們使用這行代碼，
兩個上，是C type.h中的

402
00:22:36,800 --> 00:22:38,460
頭文件，這就是
它的聲明。

403
00:22:38,460 --> 00:22:44,410
你把握H.但
當然，這是完全相同的h上

404
00:22:44,410 --> 00:22:46,540
s的內部，可以這麼說。

405
00:22:46,540 --> 00:22:51,930
所以現在你已經改變或
資本化的原件和

406
00:22:51,930 --> 00:22:53,120
所謂的副本。

407
00:22:53,120 --> 00:22:56,620
因為你沒有做一個副本
的方式，一個人會希望它是。

408
00:22:56,620 --> 00:22:59,710
>> 那麼，什麼是這裡的修復，
在上週copy1.c？

409
00:22:59,710 --> 00:23:03,070

410
00:23:03,070 --> 00:23:05,580
功能，所以實際上，我們可以
複製字符串。

411
00:23:05,580 --> 00:23:08,700
從根本上說，我們需要
做以複製字符串？

412
00:23:08,700 --> 00:23:12,070
>> 那麼，在我這裡這個綠色版
要做到這一點相當低的水平。

413
00:23:12,070 --> 00:23:14,260
實際上有功能
他們可以幫助這一點。

414
00:23:14,260 --> 00:23:17,710
但是最基本的，而最
熟悉的，至少會很快

415
00:23:17,710 --> 00:23:19,600
我們所熟悉的，是下面的 - 

416
00:23:19,600 --> 00:23:21,910
所以在第一行
現在代碼在綠色。

417
00:23:21,910 --> 00:23:23,970
>> 我剛剛改寫的char * s作為。

418
00:23:23,970 --> 00:23:25,250
有沒有功能
區別。

419
00:23:25,250 --> 00:23:28,790
我只是扔掉CS50庫
我打電話是什麼，它是一個char *。

420
00:23:28,790 --> 00:23:31,640
>> 現在，點，點，點，因為有
這不是一些錯誤檢查

421
00:23:31,640 --> 00:23:33,200
有趣的念叨。

422
00:23:33,200 --> 00:23:34,710
所以，現在t的聲明。

423
00:23:34,710 --> 00:23:35,780
它也是一個char *。

424
00:23:35,780 --> 00:23:38,280
所以我畫了一個小廣場上
屏幕上像前。

425
00:23:38,280 --> 00:23:41,870
>> 但在右側時，malloc
我們說的是內存分配。

426
00:23:41,870 --> 00:23:44,130
因此，分配一定的內存塊。

427
00:23:44,130 --> 00:23:48,830
和我們實際上做了多少字節
要分配，它似乎？

428
00:23:48,830 --> 00:23:50,340
>> 嗯，字符串的長度為s。

429
00:23:50,340 --> 00:23:52,310
所以，如果要打招呼，
是五。

430
00:23:52,310 --> 00:23:53,950
我們會說：H-E-L-L-O。

431
00:23:53,950 --> 00:23:55,090
因此，5個字節。

432
00:23:55,090 --> 00:23:57,960
>> 但是，再加上1，為什麼？

433
00:23:57,960 --> 00:23:58,830
0字符。

434
00:23:58,830 --> 00:24:03,640
如果我們不留有餘地，這傢伙我們
可能無意中造成這樣的局面

435
00:24:03,640 --> 00:24:05,600
字符串是H-E-L-L-O。

436
00:24:05,600 --> 00:24:08,470
那麼下一次的GetString
叫我輸入，例如，

437
00:24:08,470 --> 00:24:14,020
戴維，D-α-v型的i-ð時，計算機會
認為s是

438
00:24:14,020 --> 00:24:18,900
h-e在升升 - 鄰-D-α-v型的i-D因為有
沒有打破這些單詞之間。

439
00:24:18,900 --> 00:24:19,810
>> 因此，我們需要休息。

440
00:24:19,810 --> 00:24:20,720
所以，我們不希望五。

441
00:24:20,720 --> 00:24:22,100
我們需要6個字節。

442
00:24:22,100 --> 00:24:23,110
>> 和字節我說。

443
00:24:23,110 --> 00:24:25,220
但它是真的時大小字符。

444
00:24:25,220 --> 00:24:28,040
技術上char是幾乎
始終是一個單字節。

445
00:24:28,040 --> 00:24:31,030
>> 但是，只是為了讓我們的代碼便攜，
可以這麼說，所以它的工作原理

446
00:24:31,030 --> 00:24:33,750
不同的計算機上，即使他們可能
下方的有所不同

447
00:24:33,750 --> 00:24:36,590
油煙機，我要籠統
說尺寸的字符，所以

448
00:24:36,590 --> 00:24:37,660
我的代碼總是工作。

449
00:24:37,660 --> 00:24:40,610
我沒有重新編譯它只是
因為我的計算機升級或使用

450
00:24:40,610 --> 00:24:42,140
一些不同的平台。

451
00:24:42,140 --> 00:24:45,300
>> 所以我已經有了6倍的大小
一個字符，這恰好是1。

452
00:24:45,300 --> 00:24:47,440
因此，這意味著的malloc
給我六個月字節。

453
00:24:47,440 --> 00:24:49,140
，實際上做的是什麼？

454
00:24:49,140 --> 00:24:52,810
好吧，讓我回滾時間在這裡
我們所處的這個故事。

455
00:24:52,810 --> 00:24:57,620
>> 所以，如果我回到這裡，我已經聲明
一個char *名為t。

456
00:24:57,620 --> 00:25:00,280
我現在已經被稱為6字節的malloc。

457
00:25:00,280 --> 00:25:06,400
現在我要吸引那些六
就像字節數組同期。

458
00:25:06,400 --> 00:25:10,570
但其實我不知道什麼是
這個數組裡面。

459
00:25:10,570 --> 00:25:14,640
>> 如果你分配內存事實證明，
你可以不相信有一些

460
00:25:14,640 --> 00:25:15,810
已知值。

461
00:25:15,810 --> 00:25:18,400
它可能已被使用的東西
否則，其他的一些功能，其他一些

462
00:25:18,400 --> 00:25:19,630
你寫的代碼行。

463
00:25:19,630 --> 00:25:22,870
所以，我們一般會調用這些垃圾
價值和借鑒他們，也許，

464
00:25:22,870 --> 00:25:26,170
問號，只是表明我們
不知道什麼是實際存在的。

465
00:25:26,170 --> 00:25:30,390
這沒什麼大不了的，只要我們
有足夠的智慧來覆蓋這些

466
00:25:30,390 --> 00:25:34,550
垃圾值以數字或
我們關心的字符。

467
00:25:34,550 --> 00:25:36,340
>> 因此，在這種情況下，我該怎麼辦？

468
00:25:36,340 --> 00:25:38,670
好吧，我行代碼
接下來，我有四個。

469
00:25:38,670 --> 00:25:41,350
INT I得到0，n變
字符串s的長度。

470
00:25:41,350 --> 00:25:42,750
因此，一個熟悉的for循環。

471
00:25:42,750 --> 00:25:45,875
I小於或等於n，
這通常是上述。

472
00:25:45,875 --> 00:25:47,500
>> 但是，這一次它是經過深思熟慮的。

473
00:25:47,500 --> 00:25:51,890
我+ +，然後我只是做
噸支架我得到s。

474
00:25:51,890 --> 00:25:56,320
因為我的照片看起來像這樣
儲存在這一刻，是

475
00:25:56,320 --> 00:25:59,530
，隨機的內存塊的地址
它的值是未知的。

476
00:25:59,530 --> 00:26:03,030
但只要我做T支架
0，讓我在這裡。

477
00:26:03,030 --> 00:26:07,430
>> 什麼最終會被繪製在那裡？

478
00:26:07,430 --> 00:26:08,740
我們最終把ħ。

479
00:26:08,740 --> 00:26:11,170
，因為這是在s支架0。

480
00:26:11,170 --> 00:26:14,300
然後同樣的事情
E，和l，和l和o。

481
00:26:14,300 --> 00:26:17,930
>> N，為什麼我去通過
一個等於n？

482
00:26:17,930 --> 00:26:19,200
由於“0”字符。

483
00:26:19,200 --> 00:26:23,580
所以只要是明確的，那麼，如果我真的
清除這些垃圾

484
00:26:23,580 --> 00:26:28,870
值，然後繪製
我所期望的，這是支架1，2，

485
00:26:28,870 --> 00:26:32,440
3，4，加尾隨
新的字符。

486
00:26:32,440 --> 00:26:36,080
>> 所以，如果我們現在繼續過去的點，
點，點在這條正確的版本

487
00:26:36,080 --> 00:26:41,930
及資本化支架0我想，
當然，把握這一點

488
00:26:41,930 --> 00:26:47,050
傢伙在這裡，從概念上講，
最終的目標。

489
00:26:47,050 --> 00:26:48,040
所以這是所有的指針。

490
00:26:48,040 --> 00:26:51,430
>> 而你一直在使用他們週
現在在字符串的上下文中。

491
00:26:51,430 --> 00:26:53,530
但引擎蓋下他們
更複雜一點。

492
00:26:53,530 --> 00:26:57,520
但如果你認為他們在這
圖文並茂的形式，我建議他們

493
00:26:57,520 --> 00:27:01,720
可能不是所有的可怕，因為他們
可能先乍一看，

494
00:27:01,720 --> 00:27:04,730
尤其是這種新的語法。

495
00:27:04,730 --> 00:27:07,290
如有任何問題上的指針，
字符串或字符？

496
00:27:07,290 --> 00:27:07,580
是嗎？

497
00:27:07,580 --> 00:27:09,252
>> 觀眾：你能回去
[聽不清]？

498
00:27:09,252 --> 00:27:10,502
>> 揚聲器1：當然。

499
00:27:10,502 --> 00:27:14,058

500
00:27:14,058 --> 00:27:19,525
>> 觀眾：那麼，為什麼你最後的
行了，你沒有一個* T線

501
00:27:19,525 --> 00:27:21,513
行中的A * S？

502
00:27:21,513 --> 00:27:23,004
難道你不具有參考 - 

503
00:27:23,004 --> 00:27:24,640
>> 揚聲器1：啊，一個很好的問題。

504
00:27:24,640 --> 00:27:26,800
為什麼不我有一個* t和A * S？

505
00:27:26,800 --> 00:27:30,340
因為簡單地說，上週，像在我們的
交換功能，我沒有說，當

506
00:27:30,340 --> 00:27:33,350
你已經有了一個指針的手段
你去那裡，因為我們沒有

507
00:27:33,350 --> 00:27:36,590
身體在舞台上，實際
使用星算。

508
00:27:36,590 --> 00:27:40,570
>> 事實證明，這個方括號
符號是什麼，我們會打電話給句法

509
00:27:40,570 --> 00:27:44,190
糖，這僅僅是一個性感的方式
說這是速記符號

510
00:27:44,190 --> 00:27:45,950
正是你所描述的。

511
00:27:45,950 --> 00:27:49,385
但它更直觀一點。

512
00:27:49,385 --> 00:27:53,510
決策的風險，這似乎更
複雜，比它需要的是，

513
00:27:53,510 --> 00:27:56,990
這裡到底發生了什麼
 - 

514
00:27:56,990 --> 00:28:01,450
如果我說*噸，這意味著去
在t存儲的地址。

515
00:28:01,450 --> 00:28:04,350
>> 從字面上看，如果T是存儲
使得h的地址

516
00:28:04,350 --> 00:28:07,300
最初，* T手段去這裡。

517
00:28:07,300 --> 00:28:10,730
現在，噸支架0是什麼意思？

518
00:28:10,730 --> 00:28:11,560
完全相同的事情。

519
00:28:11,560 --> 00:28:13,510
這只是一個對用戶來說更加
友好的寫。

520
00:28:13,510 --> 00:28:14,430
>> 但我還沒有完成。

521
00:28:14,430 --> 00:28:17,800
我不能只是說* T *秒獲得。

522
00:28:17,800 --> 00:28:19,440
因為我會做什麼呢？

523
00:28:19,440 --> 00:28:22,950
我把H，H，H，H，H
在整個事情。

524
00:28:22,950 --> 00:28:22,995
對嗎？

525
00:28:22,995 --> 00:28:26,020
>> 由於* t是在t的地址。

526
00:28:26,020 --> 00:28:27,580
但是，我們是在一個循環內。

527
00:28:27,580 --> 00:28:32,150
什麼樣的價值，我在遞增，
當然，在每次迭代中嗎？

528
00:28:32,150 --> 00:28:32,690
（一）

529
00:28:32,690 --> 00:28:34,590
>> 但是，有一個機會
在這裡，對不對？

530
00:28:34,590 --> 00:28:37,870
儘管這種感覺就像它變得
更複雜一點

531
00:28:37,870 --> 00:28:40,730
方括號表示法比
我們已經用了一段時間 - 

532
00:28:40,730 --> 00:28:43,840
讓我撤消我的H有變化 - 

533
00:28:43,840 --> 00:28:48,870
即使是現在開始有點
神奇的是，基本的想法，如果* T

534
00:28:48,870 --> 00:28:53,630
這裡指的* t是剛剛
去t的地址。

535
00:28:53,630 --> 00:28:54,990
>> 但是，什麼是在t的地址？

536
00:28:54,990 --> 00:28:56,850
我們一直使用的號碼？

537
00:28:56,850 --> 00:29:00,540
像Ox456，讓帶回來
只是就事論事。

538
00:29:00,540 --> 00:29:05,380
好吧，如果我想要得到電子
噸字符串，我只是想歸想，

539
00:29:05,380 --> 00:29:06,460
從本質上講，456。

540
00:29:06,460 --> 00:29:09,230
>> 或者更確切地說，457。

541
00:29:09,230 --> 00:29:10,590
我只需要添加一個。

542
00:29:10,590 --> 00:29:11,790
但我可以做到這一點，對不對？

543
00:29:11,790 --> 00:29:14,680
因為T，即使我把圖紙
現在作為一個箭頭，它只是一個

544
00:29:14,680 --> 00:29:16,570
號，Ox456。

545
00:29:16,570 --> 00:29:21,400
而如果我添加一個，或多個
一般而言，如果我加我，我可以

546
00:29:21,400 --> 00:29:24,350
實際上，正是我想要的。

547
00:29:24,350 --> 00:29:26,260
所以，如果我真的這樣做 - 

548
00:29:26,260 --> 00:29:28,970
這就是現在被稱為
指針運算 - 

549
00:29:28,970 --> 00:29:30,375
我可以刪除這一行。

550
00:29:30,375 --> 00:29:33,550
這是，坦率地說，我覺得更清晰，
對用戶來說更加友好的閱讀。

551
00:29:33,550 --> 00:29:35,970
但是，這是不正確的。

552
00:29:35,970 --> 00:29:38,570
>> 現在這行代碼使用
指針的算術運算。

553
00:29:38,570 --> 00:29:40,920
說去
地址如下 - 

554
00:29:40,920 --> 00:29:44,670
無論噸開始，這
再加上我是，最初

555
00:29:44,670 --> 00:29:45,730
為0，這是偉大的。

556
00:29:45,730 --> 00:29:49,280
因為這意味著噸的開始
加1，加2，加3，依此類推。

557
00:29:49,280 --> 00:29:51,030
和相同的處理為s。

558
00:29:51,030 --> 00:29:52,750
>> 所以語法糖。

559
00:29:52,750 --> 00:29:55,900
但是，了解究竟發生了什麼事情
引擎蓋下，我認為，

560
00:29:55,900 --> 00:29:57,410
本身實際上是有用。

561
00:29:57,410 --> 00:30:00,620
因為這意味著現在有沒有
更魔法

562
00:30:00,620 --> 00:30:01,620
引擎蓋下。

563
00:30:01,620 --> 00:30:03,920
不會多
我們可以剝離備份你的層。

564
00:30:03,920 --> 00:30:04,810
這是c。

565
00:30:04,810 --> 00:30:06,410
這是編程。

566
00:30:06,410 --> 00:30:08,002
真是個好問題。

567
00:30:08,002 --> 00:30:11,570
>> 所有的權利，所以這是那個馬車
我指的是早期的程序。

568
00:30:11,570 --> 00:30:12,650
交換是有缺陷的。

569
00:30:12,650 --> 00:30:14,070
如果沒有似乎工作。

570
00:30:14,070 --> 00:30:17,390
回想一下，就像牛奶和
橙汁 - 我開始

571
00:30:17,390 --> 00:30:18,660
喝今天的示範。

572
00:30:18,660 --> 00:30:22,220
因此，正如橙汁和
牛奶，我們也必須使用

573
00:30:22,220 --> 00:30:26,200
臨時變量，TMP，舉行
暫時這樣，我們便可以

574
00:30:26,200 --> 00:30:28,820
改變它的值，然後更新B。

575
00:30:28,820 --> 00:30:32,870
>> 但是這個功能，我們說，這
程序中，此功能

576
00:30:32,870 --> 00:30:35,670
寫的是錯的，有缺陷的，為什麼呢？

577
00:30:35,670 --> 00:30:38,870

578
00:30:38,870 --> 00:30:39,090
是嗎？

579
00:30:39,090 --> 00:30:42,471
>> 觀眾：[聽不清]。

580
00:30:42,471 --> 00:30:44,940
>> 揚聲器1：沒錯，當
你叫掉期 - 

581
00:30:44,940 --> 00:30:47,820
或者更一般地，當你
調用任何功能最 - 

582
00:30:47,820 --> 00:30:51,210
如果該函數的參數
原始的，可以這麼說，整數和字符

583
00:30:51,210 --> 00:30:56,740
雙打和花車，萬物而不
星星，你是通過在副本

584
00:30:56,740 --> 00:30:57,540
的說法。

585
00:30:57,540 --> 00:31:01,580
因此，如果x為1，y為2，將
1和b為2。

586
00:31:01,580 --> 00:31:05,250
但他們要去不同的塊
位，不同的塊

587
00:31:05,250 --> 00:31:07,540
內存發生存儲
相同的值。

588
00:31:07,540 --> 00:31:12,160
>> 因此，這段代碼是超級完美
在交換a和b。

589
00:31:12,160 --> 00:31:13,850
這是沒有什麼好交換 - 

590
00:31:13,850 --> 00:31:15,290
在上週的例子 - 

591
00:31:15,290 --> 00:31:16,390
x和y。

592
00:31:16,390 --> 00:31:18,780
這還是因為同樣的原因，他們是
在錯誤的範圍內。

593
00:31:18,780 --> 00:31:21,310
>> 現在，我們怎麼去解決這個？

594
00:31:21,310 --> 00:31:23,140
我們不得不做出的功能
看起來有點醜陋。

595
00:31:23,140 --> 00:31:25,250
但是還要考慮什麼
這也就意味著。

596
00:31:25,250 --> 00:31:27,840

597
00:31:27,840 --> 00:31:31,500
>> 而實際上，讓我的一致性，
改變的一件事，所以這是相同的

598
00:31:31,500 --> 00:31:33,200
我們只是做了什麼。

599
00:31:33,200 --> 00:31:35,690
正如我上週提到的，它不會
無論身在何處。

600
00:31:35,690 --> 00:31:38,120
事實上，通常你會放
星級旁邊的變量名。

601
00:31:38,120 --> 00:31:40,750
但我認為這將是更容易一些
旁邊的考慮*

602
00:31:40,750 --> 00:31:44,910
這意味著它的數據類型是一個指針
在這種情況下，一個int。

603
00:31:44,910 --> 00:31:46,270
>> 所以我在這裡做什麼？

604
00:31:46,270 --> 00:31:49,590
我說不要給我一個int
其次另一個詮釋，

605
00:31:49,590 --> 00:31:50,810
稱他們為a和b。

606
00:31:50,810 --> 00:31:52,460
給我一個int的地址。

607
00:31:52,460 --> 00:31:53,960
給我地址的另一種詮釋。

608
00:31:53,960 --> 00:31:56,330
調用這些地址a和b。

609
00:31:56,330 --> 00:32:00,860
>> 然後使用*符號下降
下面，每個地址

610
00:32:00,860 --> 00:32:05,290
根據需要，以得到
或設置其價值。

611
00:32:05,290 --> 00:32:07,400
但這裡有一個例外。

612
00:32:07,400 --> 00:32:11,130
為什麼我不會有* TMP旁邊？

613
00:32:11,130 --> 00:32:15,070
為什麼我不能做到這一點，例如？

614
00:32:15,070 --> 00:32:19,370
這感覺就像我應該全力以赴
和糾正整個事情。

615
00:32:19,370 --> 00:32:19,752
是嗎？

616
00:32:19,752 --> 00:32:21,002
>> 觀眾：[聽不清]。

617
00:32:21,002 --> 00:32:23,280

618
00:32:23,280 --> 00:32:25,480
>> 揚聲器1：我還沒有宣布
tmp作為一個字符串。

619
00:32:25,480 --> 00:32:28,830

620
00:32:28,830 --> 00:32:34,950
因此，這將聲明，在這種情況下，
一個tmp目錄是一個int的地址。

621
00:32:34,950 --> 00:32:37,380
但是，這不是我想要的那種，
一對夫婦的原因。

622
00:32:37,380 --> 00:32:38,616
>> 觀眾：你不想來交換他們。

623
00:32:38,616 --> 00:32:41,800
>> 揚聲器1：沒錯，我不想要交換
任何與TMP。 tmp是剛

624
00:32:41,800 --> 00:32:42,790
本週一的東西。

625
00:32:42,790 --> 00:32:45,150
所有我想要的是一個變量
存儲一些數字。

626
00:32:45,150 --> 00:32:47,330
我什至不關心地址
在這一刻。

627
00:32:47,330 --> 00:32:50,530
>> 我只需要32位或
因此存儲一個int。

628
00:32:50,530 --> 00:32:56,690
我要把這32位
無論是不是在，可以這麼說，但

629
00:32:56,690 --> 00:33:01,260
處於什麼，只是為了更​​精確。

630
00:33:01,260 --> 00:33:06,420
因為如果是一個地址，一個表示
去那裡，並獲得價值1。

631
00:33:06,420 --> 00:33:10,560
例如，在上週的例子
或在b的情況下，得到的價值2。

632
00:33:10,560 --> 00:33:11,750
>> 所以，到底發生了什麼？

633
00:33:11,750 --> 00:33:15,070
讓我畫一幅畫，在這裡，將
只梳理除了今天的一部分。

634
00:33:15,070 --> 00:33:18,580
但是，這將繼續出現
相當長的一段時間。

635
00:33:18,580 --> 00:33:22,430
>> ，我要求，這就是您的電腦
當你運行一個內存看起來像

636
00:33:22,430 --> 00:33:24,060
程序，任何程序。

637
00:33:24,060 --> 00:33:28,340
當你運行一個程序在最高層
您的計算機的RAM  - 所以想到

638
00:33:28,340 --> 00:33:33,530
這個矩形，真正實現了，因為你的
計算機的RAM或內存，所有101

639
00:33:33,530 --> 00:33:36,920
全2億億字節，
字節，兩個千兆字節的，

640
00:33:36,920 --> 00:33:39,910
無論你有，
讓我們繪製一個矩形。

641
00:33:39,910 --> 00:33:43,260
我要求，當你運行一個程序
如Microsoft Word或Chrome

642
00:33:43,260 --> 00:33:49,220
或類似的東西，的位
微軟，谷歌寫道 - 

643
00:33:49,220 --> 00:33:50,910
在這些程序的案件 - 

644
00:33:50,910 --> 00:33:54,490
被加載到您的計算機的內存
在那裡他們可以執行

645
00:33:54,490 --> 00:33:57,520
迅速送入CPU，
是計算機大腦。

646
00:33:57,520 --> 00:34:00,940
>> 譚它們存儲非常
你的程序，可以這麼說。

647
00:34:00,940 --> 00:34:03,300
換言之，如果這是一個塊的
內存，當你雙擊

648
00:34:03,300 --> 00:34:05,740
微軟的Word，位來
關閉硬盤驅動器。

649
00:34:05,740 --> 00:34:06,680
他們得到加載到RAM中。

650
00:34:06,680 --> 00:34:10,330
我們要趕路他們在最高層
這個矩形的概念。

651
00:34:10,330 --> 00:34:13,010
>> 好吧，剩下的是你的記憶
用於不同的事情。

652
00:34:13,010 --> 00:34:16,460
在最頂端，你看到初始化
數據和未初始化的數據。

653
00:34:16,460 --> 00:34:20,500
這樣做的，在大多數情況下，
常量或全局變量

654
00:34:20,500 --> 00:34:21,340
有值。

655
00:34:21,340 --> 00:34:22,980
但那些其他時間。

656
00:34:22,980 --> 00:34:25,150
>> 然後你有堆，
我們會回來的。

657
00:34:25,150 --> 00:34:28,420
但在底部則是部分
尤其是現在有密切關係。

658
00:34:28,420 --> 00:34:30,210
這是所謂的堆棧。

659
00:34:30,210 --> 00:34:33,850
所以，就像在任何D廳
大學校園，你有那些托盤

660
00:34:33,850 --> 00:34:37,210
只是堆放在彼此頂部上
你可以把食物和諸如此類的東西。

661
00:34:37,210 --> 00:34:40,139
在計算機系統中的堆棧
是非常相似的。

662
00:34:40,139 --> 00:34:42,679
除而托盤，我們使用
食堂，當然是

663
00:34:42,679 --> 00:34:45,710
隨身攜帶的東西托盤
或框架 - 

664
00:34:45,710 --> 00:34:49,469
因為我們會打電話給他們 - 在計算機的
存儲器是用來存放

665
00:34:49,469 --> 00:34:51,610
變量和值。

666
00:34:51,610 --> 00:34:53,929
>> 那麼真正的推移
引擎蓋下？

667
00:34:53,929 --> 00:34:55,820
好吧，讓我翻轉
這裡的畫面。

668
00:34:55,820 --> 00:34:58,370
而讓剛上的重點
片刻的底部的一部分。

669
00:34:58,370 --> 00:35:02,770
如果這是我的底部
電腦的記憶體，它原來的時候我

670
00:35:02,770 --> 00:35:05,350
調用函數主 - 
發生的事情，坦率地說，

671
00:35:05,350 --> 00:35:06,950
自動為我 - 

672
00:35:06,950 --> 00:35:10,510
我得到一個內存塊
我的內存的底部可以這麼說。

673
00:35:10,510 --> 00:35:13,390
這是主要的
局部變量去。

674
00:35:13,390 --> 00:35:16,770
這是argc和argv也許
走，和我的任何變量

675
00:35:16,770 --> 00:35:18,170
主要內申報。

676
00:35:18,170 --> 00:35:20,260
他們最終在底部
我的電腦的RAM。

677
00:35:20,260 --> 00:35:25,040
>> 現在，假設主要的電話功能
像掉，像它上週？

678
00:35:25,040 --> 00:35:30,620
好吧，我們基本上是把一個新的托盤，
新的框架，到我的內存塊。

679
00:35:30,620 --> 00:35:34,160
我要形容這是
屬於交換功能。

680
00:35:34,160 --> 00:35:35,770
>> 現在裡面有什麼交換？

681
00:35:35,770 --> 00:35:39,240
嗯，根據上週的節目
我們剛才看到的一段摘錄，

682
00:35:39,240 --> 00:35:46,590
交換的框架內，或掉期
托盤，有哪些變量？

683
00:35:46,590 --> 00:35:47,970
那麼，a和b。

684
00:35:47,970 --> 00:35:51,850
因為那是其本地的參數，
加上第三，TMP。

685
00:35:51,850 --> 00:35:54,470
所以，說真的，我可以得出這樣的
一個更乾淨一點。

686
00:35:54,470 --> 00:35:56,680
讓我繼續前進，撤消標籤。

687
00:35:56,680 --> 00:35:58,520
我要求你知道是什麼嗎？

688
00:35:58,520 --> 00:36:00,560
>> 一個很可能會在這裡結束了。

689
00:36:00,560 --> 00:36:02,160
B是在這裡要結束了。

690
00:36:02,160 --> 00:36:03,810
和TMP在這裡要結束了。

691
00:36:03,810 --> 00:36:05,160
現在，順序可能
有點不同。

692
00:36:05,160 --> 00:36:06,840
但是，這是概念上的想法。

693
00:36:06,840 --> 00:36:11,490
>> 只是統稱，這是什麼
我們會打電話給交換的框架，或

694
00:36:11,490 --> 00:36:12,136
餐飲大廳托盤。

695
00:36:12,136 --> 00:36:13,150
同樣處理主要。

696
00:36:13,150 --> 00:36:14,040
但我不會重繪。

697
00:36:14,040 --> 00:36:17,810
但是，這其中argc和argv和任何
等局部變量x和y

698
00:36:17,810 --> 00:36:18,940
可能。

699
00:36:18,940 --> 00:36:22,170
>> 所以，現在考慮到底發生了什麼
當你調用掉。

700
00:36:22,170 --> 00:36:26,370
當你調用swap，執行這樣的代碼
這一點，你正在傳遞中，在

701
00:36:26,370 --> 00:36:30,670
越野車的版本，a和b;
作為x和y的副本。

702
00:36:30,670 --> 00:36:34,300
所以，如果我現在得出這樣的
在屏幕上 - 

703
00:36:34,300 --> 00:36:36,700
得到得到更好的產品 - 

704
00:36:36,700 --> 00:36:40,850
這樣的故事，我告訴我自己
在這個馬車版本，當我們

705
00:36:40,850 --> 00:36:46,130
調用交換傳遞字面上a和b
整數，到底發生了什麼？

706
00:36:46,130 --> 00:36:48,250
>> 那麼，這到底發生了什麼。

707
00:36:48,250 --> 00:36:52,850
讓我繼續前進，只是撤消
這裡明確了一些空間。

708
00:36:52,850 --> 00:36:54,720
所以這是我的電腦的內存。

709
00:36:54,720 --> 00:36:57,510
>> 所以，如果我有，例如 - 

710
00:36:57,510 --> 00:36:58,910
居然讓這樣來做 - 

711
00:36:58,910 --> 00:37:02,690
如果這是我要求的x，存儲
就像上週的值為1。

712
00:37:02,690 --> 00:37:05,930
這是Y，存儲的價值
就像上週。

713
00:37:05,930 --> 00:37:11,370
這是主要的，當我打電話交換，
從而給自己訪問和

714
00:37:11,370 --> 00:37:15,150
b和TMP，我要去聲稱
這是一個，這是1。

715
00:37:15,150 --> 00:37:16,080
>> 這是b。

716
00:37:16,080 --> 00:37:17,010
這是2。

717
00:37:17,010 --> 00:37:18,370
這就是所謂的TMP。

718
00:37:18,370 --> 00:37:23,360
>> 最初，它有一些垃圾值
直到我真正存儲在一個

719
00:37:23,360 --> 00:37:24,450
這是1。

720
00:37:24,450 --> 00:37:28,320
然後，我去動手改變
一個是什麼？

721
00:37:28,320 --> 00:37:29,720
B的值。

722
00:37:29,720 --> 00:37:31,980
>> 所以現在我這裡有兩個。

723
00:37:31,980 --> 00:37:34,050
然後我們說，B得到TMP。

724
00:37:34,050 --> 00:37:37,670
同樣，就像進行仔細的檢查，第三
這裡的代碼很簡單，就是

725
00:37:37,670 --> 00:37:39,440
一，B得到TMP。

726
00:37:39,440 --> 00:37:41,730
>> 所以最後，我該怎麼辦？

727
00:37:41,730 --> 00:37:46,800
我繼續前進，變動b是什麼
tmp的值，也就是1。

728
00:37:46,800 --> 00:37:48,390
我不碰TMP。

729
00:37:48,390 --> 00:37:54,100
>> 但是，現在的問題是盡快交換
的回報，因為它的不移交

730
00:37:54,100 --> 00:37:57,540
備份有一定的價值，不歸路
聲明中明確。

731
00:37:57,540 --> 00:37:59,080
實際上發生了什麼？

732
00:37:59,080 --> 00:38:03,480
嗯，基本上這一切的記憶 - 

733
00:38:03,480 --> 00:38:07,410
OK，顯然橡皮擦喜歡
只用一根手指在一個時間 - 

734
00:38:07,410 --> 00:38:08,180
就這樣消失。

735
00:38:08,180 --> 00:38:10,070
>> 現在，在現實中，它不是
去任何地方。

736
00:38:10,070 --> 00:38:11,810
但是，你可以把它想像
現在為問號。

737
00:38:11,810 --> 00:38:14,040
因為它不再
實際使用。

738
00:38:14,040 --> 00:38:17,470
並沒有什麼做這些值。

739
00:38:17,470 --> 00:38:21,920
>> 因此，在的情況下，綠色版的
這段代碼，而不是什麼是

740
00:38:21,920 --> 00:38:24,640
傳遞到交換？

741
00:38:24,640 --> 00:38:25,770
所以解決。

742
00:38:25,770 --> 00:38:28,520
因此，x的地址和
y的地址。

743
00:38:28,520 --> 00:38:35,790
因此，如果我們重新講述這個故事的最後一
時間，其實我畫再次交換，

744
00:38:35,790 --> 00:38:44,620
但與指針，這是一個，這
B，這是TMP，是什麼

745
00:38:44,620 --> 00:38:49,080
實際上存儲在這個綠色
我通過我的代碼版本

746
00:38:49,080 --> 00:38:52,110
在地址？

747
00:38:52,110 --> 00:38:53,780
>> 這將是一個指向x的指針。

748
00:38:53,780 --> 00:38:54,890
所以，我可以畫一個箭頭。

749
00:38:54,890 --> 00:38:57,310
但是，讓我們使用相同的任意
如前。

750
00:38:57,310 --> 00:39:01,220
比方說，這是
像Ox123。

751
00:39:01,220 --> 00:39:04,970
這是怎麼回事Ox127，因為
這四個字節，因為它是一個

752
00:39:04,970 --> 00:39:07,370
INT，所以Ox127。

753
00:39:07,370 --> 00:39:09,080
>> 再次，我採取了一些自由
數字。

754
00:39:09,080 --> 00:39:11,430
他們會比他們小得多
實際上是在不同的順序。

755
00:39:11,430 --> 00:39:14,350
但是，這是怎樣的畫面
現在不同了。

756
00:39:14,350 --> 00:39:19,060
>> 但是當我使用這個綠色的代碼
我INT TMP * A。

757
00:39:19,060 --> 00:39:25,010
*一種手段，做到以下幾點，採取
解決在去

758
00:39:25,010 --> 00:39:26,190
這是1。

759
00:39:26,190 --> 00:39:28,480
這就是我然後把tmp中。

760
00:39:28,480 --> 00:39:32,480
同時，在下一行代碼
在這裡，一個得到b，是什麼意思呢？

761
00:39:32,480 --> 00:39:36,910
>> 那麼，*，所以要在這裡得到* B，
這意味著去那裡。

762
00:39:36,910 --> 00:39:39,310
這意味著把那裡的價值。

763
00:39:39,310 --> 00:39:43,670
最後，最後一行代碼
簡單地說* B得到TMP。

764
00:39:43,670 --> 00:39:48,900
>> 所以B說去那裡，覆蓋它
tmp的，在這種情況下，將

765
00:39:48,900 --> 00:39:51,520
再次，1。

766
00:39:51,520 --> 00:39:54,920
這就是為什麼綠色版
我們的代碼工作，而紅色

767
00:39:54,920 --> 00:39:56,010
版本從來沒有。

768
00:39:56,010 --> 00:39:59,020
這一切都只是歸結到如何
內存管理，並在它的

769
00:39:59,020 --> 00:40:02,580
實際上放置在您的
計算機的RAM。

770
00:40:02,580 --> 00:40:07,270
現在來看，這是一個的事
堆棧被用於。

771
00:40:07,270 --> 00:40:09,225
>> 佈局上的問題？

772
00:40:09,225 --> 00:40:10,380
指針？

773
00:40:10,380 --> 00:40:11,630
或掉期？

774
00:40:11,630 --> 00:40:13,740

775
00:40:13,740 --> 00:40:17,043
>> 所有的權利，這樣的malloc，召回，
做這樣的事情。

776
00:40:17,043 --> 00:40:18,260
這是一個超級簡單的例子。

777
00:40:18,260 --> 00:40:20,550
這是一個賓基
向我們介紹，雖然相當

778
00:40:20,550 --> 00:40:21,870
很快，在末級。

779
00:40:21,870 --> 00:40:24,480
該死，我們又來了。

780
00:40:24,480 --> 00:40:28,780
>> 所以記得，這是例子
賓基向我們介紹，儘管

781
00:40:28,780 --> 00:40:30,360
有些快速末級。

782
00:40:30,360 --> 00:40:33,640
在這裡，我們真正使用的malloc
第二次。

783
00:40:33,640 --> 00:40:37,330
因為我們第一次用它來
創造足夠的RAM，分配足夠的RAM

784
00:40:37,330 --> 00:40:38,340
存儲字符串。

785
00:40:38,340 --> 00:40:40,250
>> 這一次賓基保持簡單。

786
00:40:40,250 --> 00:40:42,465
因此，它是只存儲
一個int，顯然。

787
00:40:42,465 --> 00:40:43,510
這是完全正常的。

788
00:40:43,510 --> 00:40:46,560
這是一個有點怪異，坦率地說，
使用malloc來分配一個int。

789
00:40:46,560 --> 00:40:50,650
但有一點是尼克的黏土動畫
真的只是講什麼樣的故事

790
00:40:50,650 --> 00:40:53,830
發生或不會發生在
你虐待內存。

791
00:40:53,830 --> 00:40:56,520
>> 因此，在這種情況下，本程序
做了幾件事。

792
00:40:56,520 --> 00:41:01,580
這裡在第一種情況下，它聲明
一個指向名為x為int類型。

793
00:41:01,580 --> 00:41:04,480
然後聲明一個指針
稱為y為一個int。

794
00:41:04,480 --> 00:41:06,150
然後，它存儲在x，什麼？

795
00:41:06,150 --> 00:41:07,110
現在別人。

796
00:41:07,110 --> 00:41:09,685
什麼被存儲在x
第三行這個程序嗎？

797
00:41:09,685 --> 00:41:12,380
>> 觀眾：[聽不清]。

798
00:41:12,380 --> 00:41:14,130
>> 揚聲器1：嗯，不太
字節，每說。

799
00:41:14,130 --> 00:41:16,760
現在更精確。

800
00:41:16,760 --> 00:41:18,325
被存儲在x什麼？

801
00:41:18,325 --> 00:41:21,000

802
00:41:21,000 --> 00:41:22,060
一個地址，我想我聽到了。

803
00:41:22,060 --> 00:41:23,570
>> 那麼，是什麼的malloc返回？

804
00:41:23,570 --> 00:41:26,030
行為上的malloc分配
一塊內存。

805
00:41:26,030 --> 00:41:27,850
但它是如何給你訪問它？

806
00:41:27,850 --> 00:41:29,460
它返回什麼？

807
00:41:29,460 --> 00:41:32,000
第一個字節的地址
在內存塊。

808
00:41:32,000 --> 00:41:33,020
>> 現在，這是超級簡單。

809
00:41:33,020 --> 00:41:35,380
這只是一個字節，這意味著
解決我們要的是

810
00:41:35,380 --> 00:41:37,300
整個事情的地址。

811
00:41:37,300 --> 00:41:42,070
因此，存儲在x，那麼，地址是
該內存塊。

812
00:41:42,070 --> 00:41:43,400
同時，接下來會發生什麼？

813
00:41:43,400 --> 00:41:45,890
因此，實際上，讓我們繼續前進，
繪製出真正的快。

814
00:41:45,890 --> 00:41:52,490
>> 因此，如果我們去到屏幕
我們玩了這一點* X和int * Y

815
00:41:52,490 --> 00:41:53,740
打算做什麼我？

816
00:41:53,740 --> 00:41:58,280
我要求它只是打算做
這樣的事情，並稱之為x，

817
00:41:58,280 --> 00:42:00,010
這Ÿ。

818
00:42:00,010 --> 00:42:03,110
同時，第三行代碼
要分配一個int的大小，

819
00:42:03,110 --> 00:42:06,160
這恰好是 - 對不起，如果我說
前一個，我的意思是一個int  - 

820
00:42:06,160 --> 00:42:08,280
一個典型的計算機上的四個字節。

821
00:42:08,280 --> 00:42:09,720
至少與CS50器具。

822
00:42:09,720 --> 00:42:11,490
>> 所以，這是怎麼回事分配
它，誰知道？

823
00:42:11,490 --> 00:42:12,800
某處在這裡。

824
00:42:12,800 --> 00:42:15,780
而這在某些存儲
地址牛，誰知道？

825
00:42:15,780 --> 00:42:18,330
但是，這是怎麼回事返回
是該地址。

826
00:42:18,330 --> 00:42:22,270
但是，我們會得出這樣的形象
只是這樣的箭頭。

827
00:42:22,270 --> 00:42:25,430
>> 現在，在下一行* x變42。

828
00:42:25,430 --> 00:42:29,400
* X是什麼意思通俗地說？

829
00:42:29,400 --> 00:42:30,040
只是去那裡。

830
00:42:30,040 --> 00:42:30,960
進入到該地址。

831
00:42:30,960 --> 00:42:35,900
或者換句話說，按照
箭頭，並有42把。

832
00:42:35,900 --> 00:42:38,140
但是壞事發生
賓基，對不對？

833
00:42:38,140 --> 00:42:43,950
>> 回想一下，行五在這裡，* Y獲取
13日，確實是一個不吉利的數字，

834
00:42:43,950 --> 00:42:44,760
做了什麼，對我們？

835
00:42:44,760 --> 00:42:47,320
那麼，* y表示去那裡。

836
00:42:47,320 --> 00:42:50,460
嗯，這還沒有得到
值，對不對？

837
00:42:50,460 --> 00:42:54,090
代碼沒有y為
初始化任何東西。

838
00:42:54,090 --> 00:42:56,120
我們照了X被初始化
一個地址。

839
00:42:56,120 --> 00:42:57,640
但Y被宣布往上頂。

840
00:42:57,640 --> 00:43:00,250
但隨後一個分號，沒有價值
實際上是把它。

841
00:43:00,250 --> 00:43:02,330
所以這是公平地調用這個
垃圾值。

842
00:43:02,330 --> 00:43:03,430
誰知道那裡有什麼？

843
00:43:03,430 --> 00:43:07,160
這是殘存使用的位
以前的一些行代碼

844
00:43:07,160 --> 00:43:08,300
我的計劃。

845
00:43:08,300 --> 00:43:13,250
>> 所以，如果我說去那裡，這是什麼樣子，
我不知道這個箭頭

846
00:43:13,250 --> 00:43:14,490
要結束了。

847
00:43:14,490 --> 00:43:17,720
這時候你通常
得到分割故障。

848
00:43:17,720 --> 00:43:22,430
如果你不小心取消引用，所以
說話，還是去這不是一個地址

849
00:43:22,430 --> 00:43:25,400
實際上是一個合法的地址，
不好的事情發生。

850
00:43:25,400 --> 00:43:27,550
>> 這到底發生了什麼
賓基認為。

851
00:43:27,550 --> 00:43:31,060
所以記得尼克的故事
這裡講的是同樣的想法什麼

852
00:43:31,060 --> 00:43:34,050
我畫的錯覺
粉筆在黑板上板。

853
00:43:34,050 --> 00:43:35,960
X和Y宣布。

854
00:43:35,960 --> 00:43:39,690
>> 然後我們分配的大小
一個int，並把它保存在x。

855
00:43:39,690 --> 00:43:42,130
然後我們所做的下一行* X。

856
00:43:42,130 --> 00:43:46,070
這是尼克的魔杖
提領。

857
00:43:46,070 --> 00:43:49,780
這把42在存儲器
指出由x。

858
00:43:49,780 --> 00:43:51,600
>> 但是，這是東西
去可怕的錯誤。

859
00:43:51,600 --> 00:43:51,820
對嗎？

860
00:43:51,820 --> 00:43:53,550
試圖取消引用Ÿ。

861
00:43:53,550 --> 00:43:55,620
但Y有一些虛假的價值，對不對？

862
00:43:55,620 --> 00:43:57,720
>> 在左下方即箭頭
角落裡，是不是

863
00:43:57,720 --> 00:43:58,950
其實都指向任何東西。

864
00:43:58,950 --> 00:44:01,520
這是一種做什麼，我
在這裡做的在黑板上。

865
00:44:01,520 --> 00:44:05,900
如此糟糕的事情發生，分割
故障時，或賓基故障，在這種情況下。

866
00:44:05,900 --> 00:44:10,800
>> 但是，如果我們再解決，通過做x
得到Ÿ的故事是如何變化的呢？

867
00:44:10,800 --> 00:44:15,760
嗯，如果我做X得到Y，這是
同樣有效的話說

868
00:44:15,760 --> 00:44:19,235
不管這是牛的東西
這裡是相同的，

869
00:44:19,235 --> 00:44:20,080
牛年的東西。

870
00:44:20,080 --> 00:44:22,970
或者形象，我們將繪製一個箭頭。

871
00:44:22,970 --> 00:44:25,530
>> 所以在這裡賓基板，
的下一行

872
00:44:25,530 --> 00:44:28,350
代碼* y表示去那裡。

873
00:44:28,350 --> 00:44:29,400
哪裡有？

874
00:44:29,400 --> 00:44:30,820
這意味著在這裡。

875
00:44:30,820 --> 00:44:36,050
>> 而當我們更新到13
它只是涉及到要和

876
00:44:36,050 --> 00:44:39,470
寫13現在在這裡。

877
00:44:39,470 --> 00:44:44,130
因此，也許不完全
乍一看簡單。

878
00:44:44,130 --> 00:44:47,740
但總括來說，並使用相同的行話
賓基是用在這裡，所以

879
00:44:47,740 --> 00:44:50,485
前兩個分配的指針，
x和y，但不是指針對象。

880
00:44:50,485 --> 00:44:54,750
指針對象是不是一個
通常使用的術語。

881
00:44:54,750 --> 00:44:56,120
但指針絕對是。

882
00:44:56,120 --> 00:44:59,200
但究竟是什麼原因被指向
在賓基命名。

883
00:44:59,200 --> 00:45:01,660
>> 這下一行，當然
分配一個int pointee的。

884
00:45:01,660 --> 00:45:04,840
所以一大塊內存 - 因為我吸引了
右手側 - 集

885
00:45:04,840 --> 00:45:06,470
x等於指向它。

886
00:45:06,470 --> 00:45:11,350
這解引用x到存儲42
內存，它的指向。

887
00:45:11,350 --> 00:45:13,380
然後，當然，這
是一件壞事。

888
00:45:13,380 --> 00:45:15,600
因為Y並不是指向
任何東西。

889
00:45:15,600 --> 00:45:16,530
這修復它。

890
00:45:16,530 --> 00:45:18,240
因此，這仍是錯誤的程序。

891
00:45:18,240 --> 00:45:21,580
只是因為我們正在吹遍
代碼一行行，並說，很不錯哦，

892
00:45:21,580 --> 00:45:22,690
讓它崩潰。

893
00:45:22,690 --> 00:45:23,420
這是一件壞事。

894
00:45:23,420 --> 00:45:26,790
賠率是程序只是要
完全中止在該行。

895
00:45:26,790 --> 00:45:30,550
但是，如果你要刪除墜毀
排隊，取而代之的是與過去兩年

896
00:45:30,550 --> 00:45:32,470
線等也有你分配 - 

897
00:45:32,470 --> 00:45:35,310
使用指針賦值 - γ
指向x作為點t。

898
00:45:35,310 --> 00:45:39,280
然後你取
y在一個非常安全的方式。

899
00:45:39,280 --> 00:45:41,520
>> 那麼，這給我們嗎？

900
00:45:41,520 --> 00:45:45,350
嗯，事實證明，引擎蓋下
的CS50庫中，指針是

901
00:45:45,350 --> 00:45:46,320
用於整個。

902
00:45:46,320 --> 00:45:48,910
實際上，我們將開始剝離
沒過多久回那層。

903
00:45:48,910 --> 00:45:51,740
但事實證明，一個表達式，
一些你可能很熟悉，

904
00:45:51,740 --> 00:45:54,580
特別是那些更舒適，
實際上是一個非常受歡迎的

905
00:45:54,580 --> 00:45:56,390
網站，或者堆棧溢出，
這些天。

906
00:45:56,390 --> 00:45:58,720
>> 但是，這實際上有很
技術含義。

907
00:45:58,720 --> 00:46:00,160
我們現在知道堆棧是什麼。

908
00:46:00,160 --> 00:46:02,550
這就像一摞托盤
內的食堂。

909
00:46:02,550 --> 00:46:05,140
>> 或您的計算機內的
內存它的那些幀

910
00:46:05,140 --> 00:46:06,900
所使用的功能。

911
00:46:06,900 --> 00:46:10,760
嗯，事實證明，正因為如此
非常簡單的實現

912
00:46:10,760 --> 00:46:14,970
所謂的存儲器和幀
疊加，實際上你可以控制

913
00:46:14,970 --> 00:46:17,050
一個計算機系統相當容易。

914
00:46:17,050 --> 00:46:22,180
你能砍成一個系統，如果人們
像我們這樣沒有寫我們的代碼

915
00:46:22,180 --> 00:46:23,300
特別好。

916
00:46:23,300 --> 00:46:26,670
>> 如果像我們這樣的人用大塊
內存或使用陣列 - 

917
00:46:26,670 --> 00:46:27,810
更常見 - 

918
00:46:27,810 --> 00:46:31,800
但有時會忘記檢查
我們的數組的邊界，你可能

919
00:46:31,800 --> 00:46:38,470
有自己的時候，迭代
路太遠結束過去的一個數組。

920
00:46:38,470 --> 00:46:40,520
在最好的情況下，你的程序
可能只是崩潰。

921
00:46:40,520 --> 00:46:42,280
分割故障，善良
尷尬的。

922
00:46:42,280 --> 00:46:45,480
不是很大，但是它不一定
一個非常糟糕的事情。

923
00:46:45,480 --> 00:46:49,480
>> 但是，如果你的程序實際上是對真實
用戶的計算機上，如果它的運行

924
00:46:49,480 --> 00:46:53,070
在網站上，實際隨機人
在互聯網上打，讓

925
00:46:53,070 --> 00:46:56,690
人們引發不好的事情，對你的代碼
一般不是一件好事，因為

926
00:46:56,690 --> 00:46:59,930
這意味著一個機會，採取
計算機的控制權。

927
00:46:59,930 --> 00:47:01,350
這是怎麼回事看
有點神秘。

928
00:47:01,350 --> 00:47:04,570
但我想我會嚇唬你
這裡最後一個例子。

929
00:47:04,570 --> 00:47:05,650
>> 下面是一個例子的代碼。

930
00:47:05,650 --> 00:47:07,370
維基百科有一個很好的
文章，走過

931
00:47:07,370 --> 00:47:08,530
這更多的細節。

932
00:47:08,530 --> 00:47:13,890
我有主的底部電話
富，1 argv中傳遞。

933
00:47:13,890 --> 00:47:15,750
而這僅僅是這樣就可以了
運行程序，並通過

934
00:47:15,750 --> 00:47:17,080
任意輸入。

935
00:47:17,080 --> 00:47:20,180
>> 然後foo被宣布往上頂
接受一個字符串，或者更

936
00:47:20,180 --> 00:47:21,700
準確地說，一個char *。

937
00:47:21,700 --> 00:47:23,860
然後聲明一個字符數組。

938
00:47:23,860 --> 00:47:27,130
緩衝液，更一般地，
大小為12。

939
00:47:27,130 --> 00:47:30,900
所以，可以裝進12個字符
該數組名為c。

940
00:47:30,900 --> 00:47:33,510
>> 然後，它使用這個新功能，
這是新的，但並不難

941
00:47:33,510 --> 00:47:34,930
理解，記憶複製。

942
00:47:34,930 --> 00:47:39,290
將內存複製吧，這是
過去的變量N，無論

943
00:47:39,290 --> 00:47:42,080
用戶輸入到argv 1到c。

944
00:47:42,080 --> 00:47:43,090
多少個字節？

945
00:47:43,090 --> 00:47:44,260
的字符串長度酒吧。

946
00:47:44,260 --> 00:47:48,380
>> 因此，換句話說，如果用戶鍵入的
H-E-L-L-o輸入字符串的長度

947
00:47:48,380 --> 00:47:49,260
你好五。

948
00:47:49,260 --> 00:47:52,790
所以五個那些字節是會得到
複製到陣列名為c，

949
00:47:52,790 --> 00:47:54,110
大小為12。

950
00:47:54,110 --> 00:47:58,710
但是，什麼類型的用戶在更長
這是13個字符或14字

951
00:47:58,710 --> 00:48:01,250
字符或100個或更多字符？

952
00:48:01,250 --> 00:48:02,660
>> 他們要去哪裡去了？

953
00:48:02,660 --> 00:48:06,090
嗯，這架，托盤
在用餐大廳堆棧，

954
00:48:06,090 --> 00:48:06,930
他們去那裡。

955
00:48:06,930 --> 00:48:10,080
它只是將開始覆蓋
其他的東西，這已經

956
00:48:10,080 --> 00:48:12,880
該堆棧上，滿溢
棧，可以這麼說。

957
00:48:12,880 --> 00:48:14,780
>> 因此，形象，認為這種方式。

958
00:48:14,780 --> 00:48:17,970
這僅僅是一個多彩版
圖片中，我們一直在畫畫。

959
00:48:17,970 --> 00:48:20,060
在底部，讓我們說，是主要的。

960
00:48:20,060 --> 00:48:24,690
和頂部，你現在看到的
的幀，顏色編碼，對於一個

961
00:48:24,690 --> 00:48:26,090
名為foo的功能。

962
00:48:26,090 --> 00:48:30,170
但是，什麼是有趣的，在這裡對
foo是，這裡是它的框架。

963
00:48:30,170 --> 00:48:32,860
所以，就像我畫
沒有，但在淡藍色的。

964
00:48:32,860 --> 00:48:35,220
現在這是
Ç支架0去。

965
00:48:35,220 --> 00:48:37,410
這是其中c支架
11要結束了。

966
00:48:37,410 --> 00:48:39,670
>> 換句話說，它發生在
被表示為一個正方形。

967
00:48:39,670 --> 00:48:42,320
但如果你只是保持撲通字節
 - 煤焦 - 他們將結束

968
00:48:42,320 --> 00:48:46,070
位置0一路上揚
0到11，因為它是建立索引。

969
00:48:46,070 --> 00:48:49,170
>> 但如果是13個字符
要結束了嗎？

970
00:48:49,170 --> 00:48:50,310
14日在哪裡？

971
00:48:50,310 --> 00:48:52,430
50字符在哪裡
要結束了嗎？

972
00:48:52,430 --> 00:48:54,070
>> 這將繼續下去。

973
00:48:54,070 --> 00:48:57,350
因為即使我們已經得出了
圖片與堆棧長大，

974
00:48:57,350 --> 00:48:59,920
事實證明，地址，從
小的地址，小

975
00:48:59,920 --> 00:49:01,830
指針，大的地址。

976
00:49:01,830 --> 00:49:03,540
因此，它只是不斷向上和向上。

977
00:49:03,540 --> 00:49:05,660
>> 因此，如果用戶鍵入
你好，這是偉大的。

978
00:49:05,660 --> 00:49:08,650
沒有錯誤，沒有問題，每個人的安全。

979
00:49:08,650 --> 00:49:11,940
但是，如果我們的用戶類型
調用對抗性的代碼，代表

980
00:49:11,940 --> 00:49:16,040
統稱為，攻擊，攻擊，
發作，發作時，會發生什麼？

981
00:49:16,040 --> 00:49:19,760
>> 好了，如果所有的輸入，用戶
鍵入不只是一些友好

982
00:49:19,760 --> 00:49:21,540
或令人反感的一串字符。

983
00:49:21,540 --> 00:49:24,050
它實際上是一個字符序列
如果你編譯它，

984
00:49:24,050 --> 00:49:26,050
它實際上是代碼。

985
00:49:26,050 --> 00:49:29,570
也許這是代碼，刪除所有
您的硬盤驅動器上的文件或發送垃圾郵件

986
00:49:29,570 --> 00:49:30,810
或類似的東西。

987
00:49:30,810 --> 00:49:35,110
請注意，這裡的關鍵是，
如果壞傢伙得到了足夠幸運

988
00:49:35,110 --> 00:49:37,830
覆蓋紅色的內存塊 - 

989
00:49:37,830 --> 00:49:41,080
我沒有畫上我的照片，但
這個維基百科的圖片在這裡 - 

990
00:49:41,080 --> 00:49:42,890
其所謂的返回地址。

991
00:49:42,890 --> 00:49:47,470
>> 當食品的回報，掉期回報時，
電腦知道如何去從

992
00:49:47,470 --> 00:49:49,790
這裡這裡？

993
00:49:49,790 --> 00:49:52,920
或者在高科技板塊上面，如何
它知道去從交換

994
00:49:52,920 --> 00:49:54,870
代碼 -  0和1的
構成掉期 - 

995
00:49:54,870 --> 00:49:56,020
回到主？

996
00:49:56,020 --> 00:50:00,450
有一個所謂的返回地址
存儲在相同的堆棧幀，在

997
00:50:00,450 --> 00:50:02,140
同一食堂盤。

998
00:50:02,140 --> 00:50:06,080
>> 因此，如果壞傢伙是足夠聰明，
把攻擊代碼，攻擊代碼，攻擊

999
00:50:06,080 --> 00:50:07,960
代碼，並獲得足夠幸運 - 

1000
00:50:07,960 --> 00:50:11,630
往往是通過試驗和錯誤 - 
覆蓋，紅色返回地址，

1001
00:50:11,630 --> 00:50:14,360
的地址和通知
極頂。

1002
00:50:14,360 --> 00:50:16,830
注意0835C080。

1003
00:50:16,830 --> 00:50:20,650
倒著寫往上頂
原因也許我們會重新審視。

1004
00:50:20,650 --> 00:50:22,050
這是這個數字。

1005
00:50:22,050 --> 00:50:25,790
>> 因此，如果壞傢伙得到足夠幸運或
足夠聰明，紅色覆蓋

1006
00:50:25,790 --> 00:50:29,480
剝離用的地址的存儲器
他或她有某種代碼

1007
00:50:29,480 --> 00:50:34,980
注入到你的電腦，你猜的
代碼將被返回到

1008
00:50:34,980 --> 00:50:38,260
富盡快執行完？

1009
00:50:38,260 --> 00:50:39,440
>> 壞傢伙的代碼。

1010
00:50:39,440 --> 00:50:43,610
因此，這種攻擊代碼，AAA，再次，可能
發送垃圾郵件，可能會刪除所有文件

1011
00:50:43,610 --> 00:50:44,500
您的硬盤驅動器上。

1012
00:50:44,500 --> 00:50:48,740
但是，這是一個真正的堆棧溢出
或緩衝區溢出，或

1013
00:50:48,740 --> 00:50:51,060
緩衝區溢出攻擊。

1014
00:50:51,060 --> 00:50:54,400
>> 這是令人難以置信的，令人難以置信的普遍
這一天，編寫的程序

1015
00:50:54,400 --> 00:50:58,220
C，C + +，甚至還有一些其他的語言。

1016
00:50:58,220 --> 00:51:02,275
在那個可怕的音符，我們將
結束一個笑話。

1017
00:51:02,275 --> 00:51:03,230
>> [笑]

1018
00:51:03,230 --> 00:51:04,550
>> 星期三見。

1019
00:51:04,550 --> 00:51:07,920

1020
00:51:07,920 --> 00:51:10,310
於下CS50  - 

1021
00:51:10,310 --> 00:51:15,920
所以，我所有的磁盤燈，但今天
等待，無脂牛奶，有一半的手機

1022
00:51:15,920 --> 00:51:17,850
書，橙汁
今天我喝。

1023
00:51:17,850 --> 00:51:20,370

1024
00:51:20,370 --> 00:51:22,780
USB連接線，一個扳手。

1025
00:51:22,780 --> 00:51:24,800
>> [音樂播放]