1
00:00:00,000 --> 00:00:11,320

2
00:00:11,320 --> 00:00:13,260
>> DAVID馬蘭：你好，
歡迎回到CS50。

3
00:00:13,260 --> 00:00:14,860
因此，這是本週四結束。

4
00:00:14,860 --> 00:00:16,680
剛一公佈第一。

5
00:00:16,680 --> 00:00:19,600
因此，所謂的第五個星期一是
上來今年下星期一。

6
00:00:19,600 --> 00:00:22,800
這是改變的機會
SAT / UNSAT一個字母等級，還是從

7
00:00:22,800 --> 00:00:24,130
字母等級SAT / UNSAT。

8
00:00:24,130 --> 00:00:27,130
煩人，這個過程確實需要一個
簽名，因為你必須填寫

9
00:00:27,130 --> 00:00:28,770
出那些粉紅色的分/插形式之一。

10
00:00:28,770 --> 00:00:31,680
>> 因為從技術上說，SAT / UNSAT
版本和信級版本

11
00:00:31,680 --> 00:00:33,320
有不同的目錄編號。

12
00:00:33,320 --> 00:00:34,240
但沒什麼大不了的。

13
00:00:34,240 --> 00:00:36,620
只是過來跟我搶
或在任何點的勞倫。

14
00:00:36,620 --> 00:00:39,550
或給我們發電子郵件，如果你沒有那種
你需要的文書工作的今天，我們

15
00:00:39,550 --> 00:00:43,410
一定會幫助您
週一前的護理。

16
00:00:43,410 --> 00:00:45,780
>> 所有權利，所以今天 - 

17
00:00:45,780 --> 00:00:47,630
其實，有一點回音。

18
00:00:47,630 --> 00:00:51,070
我們能否音我倒有幾分？

19
00:00:51,070 --> 00:00:51,730
確定。

20
00:00:51,730 --> 00:00:54,850
因此，我們今天介紹一個主題
被稱為指針。

21
00:00:54,850 --> 00:00:57,770
我承認，這是一個
更複雜的主題，我們傾向於

22
00:00:57,770 --> 00:01:00,960
在這個類中覆蓋，或任何真正的
入門課程使用C.

23
00:01:00,960 --> 00:01:05,510
>> 但我的話，特別是
如果你的頭腦感覺有點彎曲

24
00:01:05,510 --> 00:01:07,100
今天，在今後幾個星期。

25
00:01:07,100 --> 00:01:10,340
這不是你得到的代表
任何在這個糟糕的，那只是意味著

26
00:01:10,340 --> 00:01:13,360
這是一個特別複雜的話題
我答應，幾個星期

27
00:01:13,360 --> 00:01:17,610
因此，會顯得太驚人
回想起來簡單。

28
00:01:17,610 --> 00:01:18,720
>> 我還記得這一天。

29
00:01:18,720 --> 00:01:22,190
我坐在食堂埃利奧特，
坐在旁邊我的TF尼沙特梅塔，

30
00:01:22,190 --> 00:01:24,070
誰是居民埃利奧特房子。

31
00:01:24,070 --> 00:01:26,340
出於某種原因，這
只要點擊主題。

32
00:01:26,340 --> 00:01:29,430
這是說，我也掙扎
與一定量的時間，但我

33
00:01:29,430 --> 00:01:33,610
會盡我所能來幫助避免任何此類
一個話題，最終的鬥爭

34
00:01:33,610 --> 00:01:34,580
是相當強大的。

35
00:01:34,580 --> 00:01:37,350
>> 事實上，我們將討論的話題之一
在未來幾週內，

36
00:01:37,350 --> 00:01:41,130
的安全性，以及如何才能真正
利用機器的方式

37
00:01:41,130 --> 00:01:42,320
並不打算。

38
00:01:42,320 --> 00:01:45,850
而那些剝削通常
錯誤，錯誤的結果，我們

39
00:01:45,850 --> 00:01:49,740
人們不理解一些使
底層的實現

40
00:01:49,740 --> 00:01:52,250
通過哪些程序。

41
00:01:52,250 --> 00:01:55,410
>> 現在這個問題似乎更多的用戶
友好的，我想我會打10

42
00:01:55,410 --> 00:01:59,680
一個小的黏土動畫的第二個預覽
數字命名賓基被帶到

43
00:01:59,680 --> 00:02:03,020
在斯坦福大學生活，我們的一個朋友，
教授尼克Parlante。

44
00:02:03,020 --> 00:02:06,753
所以，請允許我把這個給你
這裡傳情賓基。

45
00:02:06,753 --> 00:02:09,520
>> [視頻回放]

46
00:02:09,520 --> 00:02:10,380
>> 嘿，賓基。

47
00:02:10,380 --> 00:02:11,050
醒來。

48
00:02:11,050 --> 00:02:13,610
它的時間的指針樂趣。

49
00:02:13,610 --> 00:02:14,741
>>  - 那是什麼？

50
00:02:14,741 --> 00:02:16,440
了解指針？

51
00:02:16,440 --> 00:02:17,928
哦，滿載而歸。

52
00:02:17,928 --> 00:02:18,920
>> [END視頻播放]

53
00:02:18,920 --> 00:02:20,670
>> 國寶馬蘭：這是斯坦福
計算機科學。

54
00:02:20,670 --> 00:02:23,194
所以來。

55
00:02:23,194 --> 00:02:24,930
>> [掌聲]

56
00:02:24,930 --> 00:02:26,660
>> 國寶MALAN：對不起，尼克。

57
00:02:26,660 --> 00:02:30,680
>> 因此，記得我們最後一次止
這真是令人興奮的吊人胃口

58
00:02:30,680 --> 00:02:32,960
據此，此功能
只是沒有工作。

59
00:02:32,960 --> 00:02:34,960
至少憑直覺，感覺
像它應該工作。

60
00:02:34,960 --> 00:02:37,600
簡單地交換值
為兩個整數。

61
00:02:37,600 --> 00:02:40,915
但記得，當我們打印出
在主，一個原始值

62
00:02:40,915 --> 00:02:44,210
二，他們仍然是一個和
兩個，而不是2個和1個。

63
00:02:44,210 --> 00:02:46,070
>> 因此，讓我真正切換
超過家電。

64
00:02:46,070 --> 00:02:50,180
我寫了一個骨架代碼位
推進在這裡，我要求使得x

65
00:02:50,180 --> 00:02:52,500
1，y將是2。

66
00:02:52,500 --> 00:02:54,810
然後，我打印出他們的兩個
值打印為f。

67
00:02:54,810 --> 00:02:57,540
>> 然後，我要求在這裡，
我們要交換他們。

68
00:02:57,540 --> 00:03:00,800
我們這裡給我留下了空白點
填寫今天在短短的時刻。

69
00:03:00,800 --> 00:03:03,380
然後，我會要求
已交換兩個變量。

70
00:03:03,380 --> 00:03:04,770
然後，我要打印
他們出來了。

71
00:03:04,770 --> 00:03:07,090
所以我希望，我應該看到1，2。

72
00:03:07,090 --> 00:03:07,380
2，1。

73
00:03:07,380 --> 00:03:09,830
這是超級簡單
現在目標。

74
00:03:09,830 --> 00:03:12,430
>> 那麼，我們如何去交換
兩個變量？

75
00:03:12,430 --> 00:03:17,220
恩，如果我在這裡提出，這些杯子
可能代表一台計算機的存儲器中。

76
00:03:17,220 --> 00:03:19,070
這是了幾口，這
是另幾叮咬。

77
00:03:19,070 --> 00:03:23,260
我們有一個志願者和
混合一些飲料，如果熟悉嗎？

78
00:03:23,260 --> 00:03:23,920
上來吧。

79
00:03:23,920 --> 00:03:24,815
你叫什麼名字？

80
00:03:24,815 --> 00:03:25,260
>> JESS：傑西。

81
00:03:25,260 --> 00:03:25,690
>> 國寶MALAN：傑斯？

82
00:03:25,690 --> 00:03:26,540
上來吧，傑西。

83
00:03:26,540 --> 00:03:29,180
如果你不介意的話，我們必須把
谷歌的玻璃上，所以我們可以

84
00:03:29,180 --> 00:03:30,430
不朽。

85
00:03:30,430 --> 00:03:32,800

86
00:03:32,800 --> 00:03:34,670
OK，玻璃。

87
00:03:34,670 --> 00:03:37,250
錄製視頻。

88
00:03:37,250 --> 00:03:43,103
OK，我們是很好的
這裡去與傑斯。

89
00:03:43,103 --> 00:03:43,810
好的。

90
00:03:43,810 --> 00:03:45,120
認識你很高興。

91
00:03:45,120 --> 00:03:47,720
>> 所以，我想什麼你在這裡做 - 
如果你能，相當迅速 - 

92
00:03:47,720 --> 00:03:51,040
只是我們倒一杯橙汁一半
果汁和一杯牛奶的一半，

93
00:03:51,040 --> 00:03:55,710
較有效的數字1
1杯和2個其他杯中。

94
00:03:55,710 --> 00:04:01,380

95
00:04:01,380 --> 00:04:02,630
>> 這將是很好的素材。

96
00:04:02,630 --> 00:04:04,910

97
00:04:04,910 --> 00:04:05,860
>> JESS：對不起。

98
00:04:05,860 --> 00:04:06,330
>> 國寶馬蘭：沒有，沒有。

99
00:04:06,330 --> 00:04:08,703
這是確定的。

100
00:04:08,703 --> 00:04:10,120
尼斯。

101
00:04:10,120 --> 00:04:12,950
所有的權利，所以我們有四個字節
值得橙汁。

102
00:04:12,950 --> 00:04:14,460
我們將它稱為值1。

103
00:04:14,460 --> 00:04:16,579
現在另外四個字節價值的牛奶。

104
00:04:16,579 --> 00:04:18,519
將調用它的價值2。

105
00:04:18,519 --> 00:04:20,440
因此，x和y分別。

106
00:04:20,440 --> 00:04:23,450
>> 所有權利，所以現在如果手頭的任務 - 
你，傑西，眼前的一切

107
00:04:23,450 --> 00:04:24,270
你的同學 - 

108
00:04:24,270 --> 00:04:28,510
是交換的值的x和y這樣的
我們希望在橙汁

109
00:04:28,510 --> 00:04:32,070
其他杯和這杯牛奶，如何
你可能會 - 之前，你居然做

110
00:04:32,070 --> 00:04:34,020
 - 去這樣做呢？

111
00:04:34,020 --> 00:04:35,220
>> OK，明智的決定。

112
00:04:35,220 --> 00:04:36,340
所以，你需要多一點的內存。

113
00:04:36,340 --> 00:04:38,190
因此，讓我們分配一個臨時的
杯，如果你願意。

114
00:04:38,190 --> 00:04:40,540
現在進行交換x和y。

115
00:04:40,540 --> 00:04:52,950

116
00:04:52,950 --> 00:04:53,530
>> 優秀的。

117
00:04:53,530 --> 00:04:54,420
所以做得非常​​好。

118
00:04:54,420 --> 00:04:55,670
謝謝你這麼多，傑西。

119
00:04:55,670 --> 00:04:59,520

120
00:04:59,520 --> 00:05:00,020
給你。

121
00:05:00,020 --> 00:05:01,950
一個小紀念品。

122
00:05:01,950 --> 00:05:04,350
>> OK，所以很明顯，超簡單的想法。

123
00:05:04,350 --> 00:05:07,500
完全直觀，我們需要一點點
更多的存儲空間 - 在這種形式中，

124
00:05:07,500 --> 00:05:09,750
一杯 - 如果我們真的要
交換這兩個變量。

125
00:05:09,750 --> 00:05:11,110
因此，讓我們做。

126
00:05:11,110 --> 00:05:14,330
在這裡，我要求我之間上升
我會做一些交換，

127
00:05:14,330 --> 00:05:15,720
走並宣布溫度。

128
00:05:15,720 --> 00:05:17,980
我會設置它等於說，X。

129
00:05:17,980 --> 00:05:21,110
>> 然後，我要改變的價值
x剛剛像傑斯這裡

130
00:05:21,110 --> 00:05:23,200
牛奶和橙汁
等於y。

131
00:05:23,200 --> 00:05:27,460
我要改變將y等於
而不是x，因為現在我們將

132
00:05:27,460 --> 00:05:29,530
停留在一個圓圈，而是溫度。

133
00:05:29,530 --> 00:05:33,170
我暫時 - 傑斯
暫時把橙汁

134
00:05:33,170 --> 00:05:35,460
前重挫，
一杯牛奶。

135
00:05:35,460 --> 00:05:37,250
>> 所以，讓我繼續前進，使這個。

136
00:05:37,250 --> 00:05:39,210
它稱為noswap.c。

137
00:05:39,210 --> 00:05:41,190
現在讓我們我運行沒有交換。

138
00:05:41,190 --> 00:05:43,910
事實上，我看到的，如果我擴大
窗口一點點，

139
00:05:43,910 --> 00:05:45,160
x為1時，y是2。

140
00:05:45,160 --> 00:05:47,230
然後，x是2，y是1。

141
00:05:47,230 --> 00:05:51,910
>> 但記得，上週一，我們做的事情
一點點不同，讓我

142
00:05:51,910 --> 00:05:56,760
而不是實現一個輔助函數，
如果你願意，這實際上是無效的。

143
00:05:56,760 --> 00:05:58,010
我把它叫做交換。

144
00:05:58,010 --> 00:06:01,600
我給它兩個參數，我叫
他們，我叫他們b。

145
00:06:01,600 --> 00:06:04,380
>> 坦白說，我可以給他們打電話x和y。

146
00:06:04,380 --> 00:06:06,040
有什麼能夠阻止
我這樣做。

147
00:06:06,040 --> 00:06:08,140
不過，我會認為它是那麼
有點曖昧。

148
00:06:08,140 --> 00:06:11,910
因為週一召回我們
權利，這些參數是

149
00:06:11,910 --> 00:06:13,650
值的副本傳入

150
00:06:13,650 --> 00:06:15,640
因此，它只是弄亂你
記住，我覺得，如果你使用

151
00:06:15,640 --> 00:06:17,370
完全相同的變量。

152
00:06:17,370 --> 00:06:20,150
>> 所以，我會打電話給他們，而不是一個
B，僅僅是為了清楚。

153
00:06:20,150 --> 00:06:21,840
但是，我們可以給他們打電話最
我們想要的東西。

154
00:06:21,840 --> 00:06:26,280
我要去複製和粘貼
有有效代碼

155
00:06:26,280 --> 00:06:27,170
下來到這裡。

156
00:06:27,170 --> 00:06:29,110
因為我剛看到它的工作原理。

157
00:06:29,110 --> 00:06:30,790
所以這是相當不錯的形狀。

158
00:06:30,790 --> 00:06:37,390
我會改變我，我的x x到
，我的Y b和我的Y到b。

159
00:06:37,390 --> 00:06:39,130
>> 所以換句話說，相同的邏輯。

160
00:06:39,130 --> 00:06:40,850
確切的同樣的事情，傑斯做。

161
00:06:40,850 --> 00:06:44,350
然後我必須做的一件事
這裡，當然，現在調用當前

162
00:06:44,350 --> 00:06:45,990
函數或調用這個函數。

163
00:06:45,990 --> 00:06:50,430
因此，我會調用這個函數有兩個
輸入，X和Y，並點擊保存。

164
00:06:50,430 --> 00:06:52,300
>> 所有權利，所以從根本上
同樣的事情。

165
00:06:52,300 --> 00:06:55,570
事實上，我可能已經作出計劃
不必要的複雜

166
00:06:55,570 --> 00:07:00,820
寫一個函數，這只是服用
約6行代碼，而我

167
00:07:00,820 --> 00:07:02,970
此前實施
這個只有三歲。

168
00:07:02,970 --> 00:07:06,230
>> 因此，讓我先走，現在改造
這一點，沒有掉。

169
00:07:06,230 --> 00:07:07,920
好吧，我搞砸了這裡。

170
00:07:07,920 --> 00:07:11,290
這應該是一個錯誤，你可能
看到越來越普遍作為

171
00:07:11,290 --> 00:07:12,380
程序變得更加複雜。

172
00:07:12,380 --> 00:07:13,470
但有一個簡單的辦法。

173
00:07:13,470 --> 00:07:15,650
讓我向後滾動在這裡。

174
00:07:15,650 --> 00:07:18,190
>> 什麼是我看到的第一個錯誤？

175
00:07:18,190 --> 00:07:19,520
隱式聲明。

176
00:07:19,520 --> 00:07:21,466
通常什麼指示？

177
00:07:21,466 --> 00:07:22,830
哦，我忘了原型。

178
00:07:22,830 --> 00:07:26,900
我忘了教的編譯器，交換
會存在，即使他

179
00:07:26,900 --> 00:07:28,920
在開始時不存在
的方案。

180
00:07:28,920 --> 00:07:35,780
所以，我只是說無效，交換，
INT，一個int B，分號。

181
00:07:35,780 --> 00:07:37,280
>> 所以我不打算重新實現它。

182
00:07:37,280 --> 00:07:39,140
但現在它匹配這裡。

183
00:07:39,140 --> 00:07:42,530
和通知，沒有一個分號
這裡，這是沒有必要的時候

184
00:07:42,530 --> 00:07:43,200
實施。

185
00:07:43,200 --> 00:07:46,010
>> 因此，讓我重拍，沒有掉。

186
00:07:46,010 --> 00:07:46,910
好得多。

187
00:07:46,910 --> 00:07:48,130
運行沒有交換。

188
00:07:48,130 --> 00:07:48,740
該死的。

189
00:07:48,740 --> 00:07:51,650
現在我們回到我們上週一，
那裡的東西也不會掉。

190
00:07:51,650 --> 00:07:55,410
>> 有什麼直觀的解釋
為什麼是這種情況呢？

191
00:07:55,410 --> 00:07:56,380
是嗎？

192
00:07:56,380 --> 00:07:57,630
>> 學生：[聽不清]。

193
00:07:57,630 --> 00:08:04,140

194
00:08:04,140 --> 00:08:05,230
>> DAVID馬蘭：沒錯。

195
00:08:05,230 --> 00:08:07,330
因此，a和b是x和y的副本。

196
00:08:07,330 --> 00:08:10,680
而事實上，任何時候，你已經
迄今為止，調用一個函數

197
00:08:10,680 --> 00:08:12,540
通過像整數變量 - 

198
00:08:12,540 --> 00:08:14,470
只是作為交換期待 - 

199
00:08:14,470 --> 00:08:16,270
你們已經通過副本。

200
00:08:16,270 --> 00:08:19,150
>> 現在，這意味著它需要一點點
的時間內，第二次分裂，

201
00:08:19,150 --> 00:08:23,270
計算機從一個複製位
變到另一個位。

202
00:08:23,270 --> 00:08:24,610
但是，這不是什麼大不了的。

203
00:08:24,610 --> 00:08:25,920
但是，他們卻一個副本。

204
00:08:25,920 --> 00:08:30,020
>> 所以現在，在交換的背景下，
事實上，我在成功

205
00:08:30,020 --> 00:08:31,180
改變a和b。

206
00:08:31,180 --> 00:08:33,000
事實上，讓我們做一個快速
完整性檢查。

207
00:08:33,000 --> 00:08:36,830
打印F A％，新生產線。

208
00:08:36,830 --> 00:08:38,770
讓我們插上了。

209
00:08:38,770 --> 00:08:41,830
現在讓我們做同樣的事情，用b。

210
00:08:41,830 --> 00:08:43,640
讓我們在這裡做同樣的事情。

211
00:08:43,640 --> 00:08:47,260
>> 現在，讓我複製這些相同的行
再次在底部的功能

212
00:08:47,260 --> 00:08:51,250
後，我的三個有趣的線
可以執行，

213
00:08:51,250 --> 00:08:53,270
再次打印a和b。

214
00:08:53,270 --> 00:08:56,030
所以，現在讓我們做，沒有掉。

215
00:08:56,030 --> 00:08:58,430
讓我一個終端窗口
高一點，這樣我們就可以看到

216
00:08:58,430 --> 00:08:59,520
它一次。

217
00:08:59,520 --> 00:09:00,860
>> 和運行沒有交換。

218
00:09:00,860 --> 00:09:04,000
x為1時，y是2。 a是1，b是2。

219
00:09:04,000 --> 00:09:06,070
然後，a為2，b是1。

220
00:09:06,070 --> 00:09:09,390
因此，它是工作，就像傑西
在這裡做過內部的交換。

221
00:09:09,390 --> 00:09:13,090
不過，當然，它不具有效果
主要變量。

222
00:09:13,090 --> 00:09:15,360
>> 於是，我們看到了一招，讓我們
可以解決這個問題，對不對？

223
00:09:15,360 --> 00:09:19,560
當你面對這個範圍
的問題，你可能只是平底船，使X

224
00:09:19,560 --> 00:09:22,400
和y變量，而不是什麼樣的呢？

225
00:09:22,400 --> 00:09:23,390
>> 你可以讓他們在全球範圍。

226
00:09:23,390 --> 00:09:27,560
把他們在最高層的文件
我們這樣做，甚至在比賽中15。

227
00:09:27,560 --> 00:09:28,890
我們使用一個全局變量。

228
00:09:28,890 --> 00:09:32,420
但是在遊戲15的上下文中，
有一個全球性的，這是合理的

229
00:09:32,420 --> 00:09:37,170
變量，代表董事會，因為
15.C全部是所有

230
00:09:37,170 --> 00:09:38,650
關於實施的那場比賽。

231
00:09:38,650 --> 00:09:41,470
這就是該文件存在。

232
00:09:41,470 --> 00:09:44,170
>> 但是，在這種情況下，在這裡，我
調用函數swap。

233
00:09:44,170 --> 00:09:45,380
我想交換兩個變量。

234
00:09:45,380 --> 00:09:48,950
它應該開始覺得只是馬虎
如果我們所有的解決方案

235
00:09:48,950 --> 00:09:51,300
當我們碰上範圍的問題
問題是使其全球。

236
00:09:51,300 --> 00:09:54,730
因為速度非常快，我們的計劃是
要成為相當混亂。

237
00:09:54,730 --> 00:09:57,760
我們這樣做絕少
作為一個結果15.c.

238
00:09:57,760 --> 00:10:00,470
>> 但事實證明，有一個
完全有更好的辦法。

239
00:10:00,470 --> 00:10:05,600
實際上，讓我回去，並刪除
打印F的，只是為了簡化代碼。

240
00:10:05,600 --> 00:10:09,160
讓我提出，
這確實是壞的。

241
00:10:09,160 --> 00:10:15,990
但是，如果我不是在一些星號
和星星，我反而可以把這個

242
00:10:15,990 --> 00:10:18,670
成一個功能
實際運作。

243
00:10:18,670 --> 00:10:25,020
>> 因此，讓我回到這裡，並承認說
星號總是很困難，

244
00:10:25,020 --> 00:10:26,170
所以我會說星星。

245
00:10:26,170 --> 00:10:27,660
我就明說那個。

246
00:10:27,660 --> 00:10:28,190
好的。

247
00:10:28,190 --> 00:10:30,190
而現在，我該怎麼
做什麼呢？

248
00:10:30,190 --> 00:10:34,130
>> 所以首先，我要指定
，而不是通過一個int

249
00:10:34,130 --> 00:10:37,980
交換功能，而不是我
去，說INT星級。

250
00:10:37,980 --> 00:10:39,170
現在的明星，什麼指示？

251
00:10:39,170 --> 00:10:41,970
這是一個指針，該概念
賓基，黏土動畫人物，

252
00:10:41,970 --> 00:10:43,465
指一時年前。

253
00:10:43,465 --> 00:10:47,610
>> 所以，如果我們說詮釋明星的意思
現在，不打算要

254
00:10:47,610 --> 00:10:49,110
通過在其價值。

255
00:10:49,110 --> 00:10:50,350
它不會被複製英寸

256
00:10:50,350 --> 00:10:54,700
的地址的情況相反，是
將要傳遞的。

257
00:10:54,700 --> 00:10:57,840
>> 因此，記得您的計算機內
一大堆的內存，否則

258
00:10:57,840 --> 00:10:58,760
被稱為RAM。

259
00:10:58,760 --> 00:11:00,520
而且，RAM僅僅是一個
一大堆字節。

260
00:11:00,520 --> 00:11:03,320
所以，如果你的Mac或PC
兩個千兆字節，你有2個

261
00:11:03,320 --> 00:11:05,760
十億字節的內存。

262
00:11:05,760 --> 00:11:08,440
>> 現在，讓我們假設只是為了
保持美好的東西，有序的，我們

263
00:11:08,440 --> 00:11:09,450
分配一個IP地址 - 

264
00:11:09,450 --> 00:11:10,170
一個數字 - 

265
00:11:10,170 --> 00:11:12,270
在您的計算機上的每一個字節的RAM。

266
00:11:12,270 --> 00:11:15,410
那些2的第一個字節
億元是由多少個零。

267
00:11:15,410 --> 00:11:18,572
下一個是字節數一數
二，所有的方式起來，點點

268
00:11:18,572 --> 00:11:20,530
點，約2億元。

269
00:11:20,530 --> 00:11:23,640
>> 所以，你可以的字節數
在您的計算機的內存。

270
00:11:23,640 --> 00:11:26,460
因此，讓我們假設，這是什麼
我們所說的地址。

271
00:11:26,460 --> 00:11:31,360
所以，當我看到INT星級一個，這是怎麼回事
要通過期現掉換是

272
00:11:31,360 --> 00:11:32,830
地址。

273
00:11:32,830 --> 00:11:37,150
不是它的價值，但不論其郵政
地址，可以這麼說 - 

274
00:11:37,150 --> 00:11:38,810
它的位置在RAM中。

275
00:11:38,810 --> 00:11:41,250
>> 同樣為b，我要去
說同樣的事情。

276
00:11:41,250 --> 00:11:42,720
詮釋，星級，B。

277
00:11:42,720 --> 00:11:46,350
順便說一句，技術上的明星
在其他地方可以去。

278
00:11:46,350 --> 00:11:50,140
但是，我們將標準化星級
旁邊的數據類型。

279
00:11:50,140 --> 00:11:54,080
>> 因此，交換簽名意味著現在，給我
一個int的地址和呼叫

280
00:11:54,080 --> 00:11:55,400
地址一個。

281
00:11:55,400 --> 00:11:58,690
並給我的另一個地址
INT和調用該地址b。

282
00:11:58,690 --> 00:12:01,120
>> 但現在這裡有我的代碼改變。

283
00:12:01,120 --> 00:12:03,470
因為如果我聲明INT溫度 - 

284
00:12:03,470 --> 00:12:05,580
這仍然是int類型的 - 

285
00:12:05,580 --> 00:12:08,700
但我存儲在它，
什麼樣的價值？

286
00:12:08,700 --> 00:12:12,870
要清楚，我把一個一個
現在寫的代碼？

287
00:12:12,870 --> 00:12:14,360
>> 我將在一個位置。

288
00:12:14,360 --> 00:12:16,500
但我不關心
現在的位置，對不對？

289
00:12:16,500 --> 00:12:21,940
溫度存在只是傑斯第三杯
存在，目的是什麼？

290
00:12:21,940 --> 00:12:23,090
要存儲一個值。

291
00:12:23,090 --> 00:12:24,830
牛奶或橙汁。

292
00:12:24,830 --> 00:12:28,520
不實際存儲的地址
那些東西，感覺

293
00:12:28,520 --> 00:12:31,200
在這個現實有點無厘頭
全球上下文反正。

294
00:12:31,200 --> 00:12:34,990
>> 所以真的，我希望把溫度
的地址的情況，但

295
00:12:34,990 --> 00:12:36,180
內容。

296
00:12:36,180 --> 00:12:41,930
因此，如果a是一個數（如123），這是
123字節的內存，一個公正的

297
00:12:41,930 --> 00:12:45,090
恰好是佔領，該值
在一個恰好是佔領。

298
00:12:45,090 --> 00:12:49,040
>> 如果我想去到該地址，
我需要說一個明星。

299
00:12:49,040 --> 00:12:52,610
同樣，如果我要改變什麼
地址，我改變

300
00:12:52,610 --> 00:12:53,570
這開始。

301
00:12:53,570 --> 00:12:58,185
如果我要存儲在什麼
什麼位置的位置

302
00:12:58,185 --> 00:13:02,180
B，明星B星。

303
00:13:02,180 --> 00:13:05,340
>> 因此，在短，即使這是不太
下沉還沒有 - 我不希望

304
00:13:05,340 --> 00:13:06,560
它會如此之快 - 

305
00:13:06,560 --> 00:13:11,100
意識到，我做的是前綴
這些星星我的變量，

306
00:13:11,100 --> 00:13:13,350
說不要搶值。

307
00:13:13,350 --> 00:13:14,520
不要改變值。

308
00:13:14,520 --> 00:13:17,600
而是去到這些地址
和得到的價值。

309
00:13:17,600 --> 00:13:21,430
轉到該地址和變化
存在的價值。

310
00:13:21,430 --> 00:13:25,500
>> 所以，現在讓我回滾動到頂部，
只是為了解決這條線，在這裡，

311
00:13:25,500 --> 00:13:27,690
改變相匹配的原型。

312
00:13:27,690 --> 00:13:30,280
但我現在需要做的另一件事情。

313
00:13:30,280 --> 00:13:35,500
直觀地說，如果我已經改變了類型
論點交換期待，

314
00:13:35,500 --> 00:13:37,245
我需要做什麼
在我的代碼改變？

315
00:13:37,245 --> 00:13:39,750

316
00:13:39,750 --> 00:13:40,840
>> 當我打電話掉。

317
00:13:40,840 --> 00:13:43,340
因為現在，我是什麼
我仍然通過交換嗎？

318
00:13:43,340 --> 00:13:47,450
x的值和y的值，或
牛奶和橙汁。

319
00:13:47,450 --> 00:13:48,510
但我不想這樣做。

320
00:13:48,510 --> 00:13:51,060
我不是要傳遞什麼？

321
00:13:51,060 --> 00:13:53,050
的位置x和
y的位置。

322
00:13:53,050 --> 00:13:55,300
什麼是他們的郵政地址，
可以這麼說。

323
00:13:55,300 --> 00:13:57,600
>> 因此，要做到這一點，有一個符號。

324
00:13:57,600 --> 00:13:59,260
與符號那種聽起來地址。

325
00:13:59,260 --> 00:14:03,240
因此n＆符號，地址
為x，y的地址。

326
00:14:03,240 --> 00:14:06,790
因此，它是故意的，我們使用
＆符號調用函數時，

327
00:14:06,790 --> 00:14:10,230
和恆星時，聲明和當
執行的功能。

328
00:14:10,230 --> 00:14:14,220
>> 符號，只是覺得作為
地址運算符，明星的

329
00:14:14,220 --> 00:14:15,490
去那裡運營商 - 

330
00:14:15,490 --> 00:14:18,640
，或更確切地說，
引用操作

331
00:14:18,640 --> 00:14:23,480
所以這是一個整體的很多話只是
說，現在希望，交換是怎麼回事

332
00:14:23,480 --> 00:14:24,440
是正確的。

333
00:14:24,440 --> 00:14:26,550
>> 讓我繼續前進，使 - 

334
00:14:26,550 --> 00:14:30,940
其實，讓我們重命名文件，以免
這個程序仍然可以稱為無交換。

335
00:14:30,940 --> 00:14:33,240
我要求我們叫它swap.c的現在。

336
00:14:33,240 --> 00:14:35,670
所以，交換。

337
00:14:35,670 --> 00:14:37,520
點，斜線，交換。

338
00:14:37,520 --> 00:14:40,210
>> 現在確實，x為1時，y是2。

339
00:14:40,210 --> 00:14:44,040
然後，x是2，y是1。

340
00:14:44,040 --> 00:14:46,500
好吧，讓我們來看看，如果我們不能做到這
有點什麼不同

341
00:14:46,500 --> 00:14:47,180
怎麼回事。

342
00:14:47,180 --> 00:14:51,250
首先，讓我放大我們
這裡繪製屏幕。

343
00:14:51,250 --> 00:14:54,160
讓我提出了一會兒 - 
每當我在這裡畫將被鏡像

344
00:14:54,160 --> 00:14:58,660
那裡現在 - 讓我提出，
這裡有一大堆的內存，或

345
00:14:58,660 --> 00:15:00,540
RAM，在我的電腦裡面。

346
00:15:00,540 --> 00:15:04,140
>> 這將是咬號碼，
比方說，1。

347
00:15:04,140 --> 00:15:05,720
這將是字節數2。

348
00:15:05,720 --> 00:15:08,220
，我會盡一大堆，
然後一堆點點點

349
00:15:08,220 --> 00:15:10,880
表明有是2億美元
這些東西。

350
00:15:10,880 --> 00:15:13,520
4，5，等等。

351
00:15:13,520 --> 00:15:17,055
>> 因此，有前5個字節
我的計算機的內存。

352
00:15:17,055 --> 00:15:17,560
沒事吧？

353
00:15:17,560 --> 00:15:19,060
很少有人出2億美元。

354
00:15:19,060 --> 00:15:21,120
但現在我要建議
以下。

355
00:15:21,120 --> 00:15:27,490
我要建議，x是要
存儲數字1，和y會

356
00:15:27,490 --> 00:15:29,690
來存儲數字2。

357
00:15:29,690 --> 00:15:35,000
讓我去現在領先，並代表
這些值如下所示。

358
00:15:35,000 --> 00:15:41,510
>> 讓我們做如下。

359
00:15:41,510 --> 00:15:42,870
給我一秒。

360
00:15:42,870 --> 00:15:44,150
一秒鐘。

361
00:15:44,150 --> 00:15:45,680
確定。

362
00:15:45,680 --> 00:15:47,560
我想這一點 - 

363
00:15:47,560 --> 00:15:50,440
讓我們再次做到這一點。

364
00:15:50,440 --> 00:15:53,250
否則我要使用
相同的號碼，無意中，

365
00:15:53,250 --> 00:15:54,230
多次。

366
00:15:54,230 --> 00:15:57,320
>> 所以只是讓我們有不同的電話號碼，
說說，讓這個字節

367
00:15:57,320 --> 00:16:03,391
123，124，125，126，
點點點。

368
00:16:03,391 --> 00:16:08,400
讓我要求現在我要去
把值1，值2

369
00:16:08,400 --> 00:16:11,990
這裡，否則稱為x和y。

370
00:16:11,990 --> 00:16:15,300
因此，它只是恰巧
這是X，這是Y。

371
00:16:15,300 --> 00:16:18,180
>> 只是一些隨機的機會，
計算機，操作系統，

372
00:16:18,180 --> 00:16:21,890
碰巧把x的位置
123號。

373
00:16:21,890 --> 00:16:25,590
和Y位置124  - 

374
00:16:25,590 --> 00:16:26,330
該死的。

375
00:16:26,330 --> 00:16:28,700
我應該已經解決了這個問題。

376
00:16:28,700 --> 00:16:34,040
哦，男人，我真的想這樣做嗎？

377
00:16:34,040 --> 00:16:37,340
是的，我想解決這個問題和
b今天這個約是恰當的。

378
00:16:37,340 --> 00:16:39,950
很抱歉，在這個新的。

379
00:16:39,950 --> 00:16:45,020
>> 127，131，我不希望是這樣的
複雜，但為什麼我改變

380
00:16:45,020 --> 00:16:46,340
有數字嗎？

381
00:16:46,340 --> 00:16:48,360
因為我想的整數
實際上是四個字節。

382
00:16:48,360 --> 00:16:49,810
因此，讓的這超肛門。

383
00:16:49,810 --> 00:16:53,800
這樣，如果發生要處理的
123 2將是在地址

384
00:16:53,800 --> 00:16:55,730
127，因為它是距離酒店僅有4輪空。

385
00:16:55,730 --> 00:16:56,210
這就是全部。

386
00:16:56,210 --> 00:16:58,640
我們會忘記所有
在世界的其他地址。

387
00:16:58,640 --> 00:17:03,320
>> 所以x是在123的位置，
y是在位置127。

388
00:17:03,320 --> 00:17:05,770
而現在，其實我做什麼
想幹什麼？

389
00:17:05,770 --> 00:17:10,099
當我打電話期現掉換，有什麼
實際上是怎麼回事呢？

390
00:17:10,099 --> 00:17:14,920
好吧，我調用swap時，我傳遞
的地址x和y的地址。

391
00:17:14,920 --> 00:17:18,540
因此，例如，如果這兩個條
現在的紙張代表兩個

392
00:17:18,540 --> 00:17:23,510
參數A和B交換，我是什麼
打算寫第一，

393
00:17:23,510 --> 00:17:27,720
我要打電話給作為？

394
00:17:27,720 --> 00:17:30,610
>> 沒錯，123。

395
00:17:30,610 --> 00:17:31,905
因此，我要求的是一個。

396
00:17:31,905 --> 00:17:32,955
這是參數a。

397
00:17:32,955 --> 00:17:35,856
我把x的地址在那裡。

398
00:17:35,856 --> 00:17:38,152
>> 那是什麼？

399
00:17:38,152 --> 00:17:40,890
>> 那是什麼？

400
00:17:40,890 --> 00:17:41,190
>> 沒有，沒有。

401
00:17:41,190 --> 00:17:41,720
這是確定的。

402
00:17:41,720 --> 00:17:42,570
還是不錯的，還是不錯的。

403
00:17:42,570 --> 00:17:43,530
所以這是一個。

404
00:17:43,530 --> 00:17:46,240
現在，在第二張紙，
這將是B，我是什麼

405
00:17:46,240 --> 00:17:49,010
要編寫上
一張紙嗎？

406
00:17:49,010 --> 00:17:50,080
127。

407
00:17:50,080 --> 00:17:53,720
>> 因此，唯一的改變，因為
這個故事我們以前有說服力的是，

408
00:17:53,720 --> 00:17:58,590
而不是字面上的1和2，我
要通過123和127。

409
00:17:58,590 --> 00:18:02,130
我現在打算把這些內部
這個盒子，所有的權利？

410
00:18:02,130 --> 00:18:04,640
所以，現在黑盒子代表
交換功能。

411
00:18:04,640 --> 00:18:07,230
>> 同時，讓我們現在有一個人
實現交換功能。

412
00:18:07,230 --> 00:18:09,090
會有人在這裡
喜歡做義工？

413
00:18:09,090 --> 00:18:09,560
上來吧。

414
00:18:09,560 --> 00:18:11,080
你叫什麼名字？

415
00:18:11,080 --> 00:18:11,460
查理。

416
00:18:11,460 --> 00:18:12,080
好吧，查理。

417
00:18:12,080 --> 00:18:14,810
上來吧。

418
00:18:14,810 --> 00:18:17,310
>> 因此，查理是要發揮
我們黑匣子的作用。

419
00:18:17,310 --> 00:18:21,460
查理，我想請你做什麼
現在以這樣的方式實現交換

420
00:18:21,460 --> 00:18:25,320
的是，由於這兩個地址，
你實際上會

421
00:18:25,320 --> 00:18:26,330
改變值。

422
00:18:26,330 --> 00:18:28,290
我會在你耳邊低語
如何運行這裡的電視。

423
00:18:28,290 --> 00:18:29,930
>> 所以先走了，你的黑盒子。

424
00:18:29,930 --> 00:18:30,920
到達那裡。

425
00:18:30,920 --> 00:18:34,054
你看到什麼樣的價值觀，
為B你看什麼樣的價值觀？

426
00:18:34,054 --> 00:18:36,740
>> 查理：一個是123，b是127。

427
00:18:36,740 --> 00:18:37,530
>> 國寶馬蘭：OK，正好。

428
00:18:37,530 --> 00:18:38,940
現在停在那裡只是一瞬間。

429
00:18:38,940 --> 00:18:41,680
第一件事，你現在打算怎麼辦，
根據代碼 - 

430
00:18:41,680 --> 00:18:43,220
現在我會拉在屏幕上 - 

431
00:18:43,220 --> 00:18:46,750
將是分配一點
位的內存稱為溫度。

432
00:18:46,750 --> 00:18:48,850
所以，我要繼續前進，
給你的記憶。

433
00:18:48,850 --> 00:18:52,210
>> 因此，這將是第三個變量
你有訪問

434
00:18:52,210 --> 00:18:54,080
你名為溫度。

435
00:18:54,080 --> 00:18:57,120
你有什麼打算寫
上臨時紙上？

436
00:18:57,120 --> 00:19:02,524

437
00:19:02,524 --> 00:19:03,470
>> 查理：指針，對不對？

438
00:19:03,470 --> 00:19:04,790
>> 國寶MALAN：“確定”，遠的不
一定指針。

439
00:19:04,790 --> 00:19:07,230
所以我的代碼行
上突出顯示在右手邊，

440
00:19:07,230 --> 00:19:07,900
我們從這裡開始。

441
00:19:07,900 --> 00:19:08,890
一個明星說。

442
00:19:08,890 --> 00:19:11,670
所以目前保存
數字123。

443
00:19:11,670 --> 00:19:16,660
只是直覺，什麼
星級123是什麼意思？

444
00:19:16,660 --> 00:19:21,630
>> 但是，具體地，如果a是
123，一個明星意味著什麼？

445
00:19:21,630 --> 00:19:22,560
a的值。

446
00:19:22,560 --> 00:19:24,580
或者更隨意，去那裡。

447
00:19:24,580 --> 00:19:28,620
因此，我建議，持有中
你的手，繼續和治療

448
00:19:28,620 --> 00:19:29,430
就好像它是一個地圖。

449
00:19:29,430 --> 00:19:32,940
走自己電腦的
內存，並找到我們的是什麼

450
00:19:32,940 --> 00:19:36,520
在123的位置。

451
00:19:36,520 --> 00:19:37,720
沒錯。

452
00:19:37,720 --> 00:19:41,100
>> 所以我們看到在位置123
是什麼，很明顯嗎？

453
00:19:41,100 --> 00:19:44,240
OK，所以什麼樣的價值現在是你
去付諸溫度？

454
00:19:44,240 --> 00:19:44,750
沒錯。

455
00:19:44,750 --> 00:19:45,600
因此，繼續前進，並做到這一點。

456
00:19:45,600 --> 00:19:51,280
寫數字1片
紙的溫度題為。

457
00:19:51,280 --> 00:19:53,540
>> 而現在的下一個步驟即
你要實現

458
00:19:53,540 --> 00:19:54,310
會是什麼。

459
00:19:54,310 --> 00:19:57,820
以及，在右手側的
下一行代碼是星級住宿。 ，，

460
00:19:57,820 --> 00:19:59,260
當然，存儲一個地址。

461
00:19:59,260 --> 00:20:02,270
地址127。

462
00:20:02,270 --> 00:20:06,620
星b表示什麼，隨便說嗎？

463
00:20:06,620 --> 00:20:08,700
>> 進入到該位置。

464
00:20:08,700 --> 00:20:14,988
因此，繼續前進，並找到我們什麼
在127的位置。

465
00:20:14,988 --> 00:20:15,480
確定。

466
00:20:15,480 --> 00:20:19,170
當然，在位置127，
仍然是值2。

467
00:20:19,170 --> 00:20:24,060
那麼你現在店
無論是在上面的位置？

468
00:20:24,060 --> 00:20:26,860
所以明星的手段去的位置。

469
00:20:26,860 --> 00:20:29,770
是什麼位置？

470
00:20:29,770 --> 00:20:30,430
>> 沒錯。

471
00:20:30,430 --> 00:20:34,190
所以，現在，如果你想改變
什麼是在那個位置 - 

472
00:20:34,190 --> 00:20:36,470
我會繼續運行
橡皮擦都在這裡。

473
00:20:36,470 --> 00:20:37,760
現在把它刷上。

474
00:20:37,760 --> 00:20:42,190
你打算寫什麼號碼
在該空白框現在呢？

475
00:20:42,190 --> 00:20:42,850
>> 沒錯。

476
00:20:42,850 --> 00:20:46,470
所以這行代碼，要明確 - 讓
我暫停了查理的做

477
00:20:46,470 --> 00:20:51,730
這裡指出，他剛剛做了什麼
寫入那個盒子位置123

478
00:20:51,730 --> 00:20:55,150
以前在b的值。

479
00:20:55,150 --> 00:20:59,140
所以我們現在確實實施
這第二行代碼。

480
00:20:59,140 --> 00:21:01,920
>> 不幸的是，現在有
還有一個剩餘行。

481
00:21:01,920 --> 00:21:04,900
現在是什麼溫度，從字面上看？

482
00:21:04,900 --> 00:21:06,200
這顯然是頭號。

483
00:21:06,200 --> 00:21:07,020
這不是一個地址。

484
00:21:07,020 --> 00:21:09,380
這只是一個號碼，排序
從本週一的變量。

485
00:21:09,380 --> 00:21:13,520
>> 而現在，當你說星級B，這意味著
去的地址b，這對

486
00:21:13,520 --> 00:21:15,090
當然在這裡。

487
00:21:15,090 --> 00:21:16,020
所以，一旦你到達那裡 - 

488
00:21:16,020 --> 00:21:18,320
我會繼續前進，抹去了實際上
 - 你是什麼

489
00:21:18,320 --> 00:21:20,820
去現在寫地點127？

490
00:21:20,820 --> 00:21:22,010
>> 查理：溫度，這是一種。

491
00:21:22,010 --> 00:21:23,430
>> DAVID馬蘭：溫度，是其中一個。

492
00:21:23,430 --> 00:21:25,670
和溫度到底發生了什麼？

493
00:21:25,670 --> 00:21:26,600
好了，我們真的不知道。

494
00:21:26,600 --> 00:21:27,420
我們不在乎。

495
00:21:27,420 --> 00:21:31,090
任何時候，我們已經實現了一個功能
到目前為止，你有任何局部變量

496
00:21:31,090 --> 00:21:31,890
確實是本地的。

497
00:21:31,890 --> 00:21:33,060
他們只是消失。

498
00:21:33,060 --> 00:21:35,040
他們回收經營
最終系統。

499
00:21:35,040 --> 00:21:39,800
>> 因此，溫度的事實，仍然有
數值1是一種從根本上

500
00:21:39,800 --> 00:21:41,150
無趣我們。

501
00:21:41,150 --> 00:21:43,100
好吧，讓掌聲雷動
如果我們能為查理。

502
00:21:43,100 --> 00:21:46,400
非常出色。

503
00:21:46,400 --> 00:21:51,520
>> 好，那麼還有什麼不
這意味著我們可以做的嗎？

504
00:21:51,520 --> 00:21:54,400
所以，事實證明，我們已經
告訴一些善意的謊言

505
00:21:54,400 --> 00:21:55,540
相當長的一段時間。

506
00:21:55,540 --> 00:21:59,990
事實上，它變成了一個字符串，
這段時間，是不是真的

507
00:21:59,990 --> 00:22:02,190
本身的字符序列。

508
00:22:02,190 --> 00:22:03,980
樣的，直觀的。

509
00:22:03,980 --> 00:22:08,270
>> 但是從技術上來說，字符串是一個
數據類型，我們內部聲明

510
00:22:08,270 --> 00:22:12,170
CS50庫簡化了世界
類的頭幾個星期。

511
00:22:12,170 --> 00:22:20,130
字符串真的是地址是
一個字符在RAM中的某個地方。

512
00:22:20,130 --> 00:22:25,530
一個字符串，是一個真正的號碼，如123
或127，出現這種情況劃定

513
00:22:25,530 --> 00:22:28,420
字符串開始
您的計算機的內存。

514
00:22:28,420 --> 00:22:31,870
>> 不過，這並不代表
字符串，每se，本身。

515
00:22:31,870 --> 00:22:33,460
我們可以看到如下。

516
00:22:33,460 --> 00:22:35,980
讓我去進取，不斷開拓
一些代碼之間

517
00:22:35,980 --> 00:22:38,340
今天的源代碼示例。

518
00:22:38,340 --> 00:22:42,225
而且我要繼續前進，並打開
，讓我們說，比較0.C。

519
00:22:42,225 --> 00:22:44,830

520
00:22:44,830 --> 00:22:48,790
這是一個錯誤的程序會
以如下方式實現。

521
00:22:48,790 --> 00:22:49,040
>> 第一。

522
00:22:49,040 --> 00:22:50,420
我要說什麼。

523
00:22:50,420 --> 00:22:52,660
然後，我要繼續前進，
從用戶得到一個字符串

524
00:22:52,660 --> 00:22:53,750
在該下一行。

525
00:22:53,750 --> 00:22:55,370
然後，我要再說一遍。

526
00:22:55,370 --> 00:22:57,540
然後我會得到另一個
來自用戶的字符串。

527
00:22:57,540 --> 00:23:00,390
>> 通知，我展示之一
字符串中的變量稱為S，

528
00:23:00,390 --> 00:23:03,040
另一個這些字符串
在一個變量名為t。

529
00:23:03,040 --> 00:23:07,480
現在，我要索賠，非常
合理，如果s等於等於T，

530
00:23:07,480 --> 00:23:08,940
字符串是相同的。

531
00:23:08,940 --> 00:23:09,970
你鍵入同樣的事情。

532
00:23:09,970 --> 00:23:11,830
否則，琴弦
不一樣的東西。

533
00:23:11,830 --> 00:23:15,440
>> 畢竟，如果我們輸入兩個整數，兩
字符，兩個浮筒，兩個雙打，任何

534
00:23:15,440 --> 00:23:18,400
我們談過的數據類型
迄今為止對它們進行比較 - 

535
00:23:18,400 --> 00:23:22,070
記得我們前一陣子很清楚
你不這樣做，因為一個

536
00:23:22,070 --> 00:23:25,840
當然是一個等號
賦值運算符。

537
00:23:25,840 --> 00:23:26,820
因此，這將是一個錯誤。

538
00:23:26,820 --> 00:23:29,260
>> 我們用平等等號，
這確實比較

539
00:23:29,260 --> 00:23:31,050
事情真正的平等。

540
00:23:31,050 --> 00:23:32,275
不過，我要求這是越野車。

541
00:23:32,275 --> 00:23:37,400
如果我繼續前進，使比較零，
然後做點斜線比較為零。

542
00:23:37,400 --> 00:23:39,700
我輸入，讓我們說，你好。

543
00:23:39,700 --> 00:23:41,590
然後讓我們再次問好。

544
00:23:41,590 --> 00:23:46,040
從字面上看同樣的事情，電腦
索賠我打不同的事情。

545
00:23:46,040 --> 00:23:47,640
>> 現在，也許我只是打錯了。

546
00:23:47,640 --> 00:23:49,910
這個時候，我會輸入我的名字。

547
00:23:49,910 --> 00:23:52,580
我的意思是，你好。

548
00:23:52,580 --> 00:23:54,770
你好。

549
00:23:54,770 --> 00:23:57,360
這是不同的，每一次。

550
00:23:57,360 --> 00:23:58,430
>> 那麼，這是為什麼？

551
00:23:58,430 --> 00:24:00,140
到底發生了什麼
引擎蓋下？

552
00:24:00,140 --> 00:24:03,270
那麼，什麼是真正回事下方
引擎蓋然後是字符串

553
00:24:03,270 --> 00:24:07,410
我輸入的，例如首次
這個詞打招呼，當然。

554
00:24:07,410 --> 00:24:11,660
但是，如果我們代表這底下
引擎蓋，回想一下，

555
00:24:11,660 --> 00:24:13,470
字符串是在一個數組中。

556
00:24:13,470 --> 00:24:15,040
我們已經說了這麼多了過去。

557
00:24:15,040 --> 00:24:20,200
>> 所以，如果我畫這樣的數組，我
要代表的東西相當

558
00:24:20,200 --> 00:24:23,030
類似剛才我們所做的事情。

559
00:24:23,030 --> 00:24:25,390
並有實際的東西
特別在這裡，太。

560
00:24:25,390 --> 00:24:28,090
我們什麼確定
每一個字符串的結尾？

561
00:24:28,090 --> 00:24:30,760
是啊，這反斜杠零，這是
只是表示方式，

562
00:24:30,760 --> 00:24:33,610
從字面上看，00000000。

563
00:24:33,610 --> 00:24:35,680
八0位成一排。

564
00:24:35,680 --> 00:24:37,610
>> 我不知道，坦白說，
什麼是在這之後。

565
00:24:37,610 --> 00:24:40,090
那只是一堆更多的RAM
我的電腦裡面。

566
00:24:40,090 --> 00:24:40,970
但是，這是一個數組。

567
00:24:40,970 --> 00:24:42,260
我們談到陣列。

568
00:24:42,260 --> 00:24:45,010
我們通常談論數組
作為零的位置，

569
00:24:45,010 --> 00:24:46,580
再一個，然後兩個。

570
00:24:46,580 --> 00:24:47,950
但是，這只是為了方便。

571
00:24:47,950 --> 00:24:49,380
而這完全是相對的。

572
00:24:49,380 --> 00:24:53,010
>> 當你實際上得到內存
電腦，當然，任何

573
00:24:53,010 --> 00:24:55,450
2十億一些奇怪的字節，有可能。

574
00:24:55,450 --> 00:24:59,100
所以，真正的引擎蓋下方，
這一切的時候，是的。

575
00:24:59,100 --> 00:25:01,670
這很可能是支架為零。

576
00:25:01,670 --> 00:25:04,780
但是，如果你挖更深下方
油煙機，這是真的

577
00:25:04,780 --> 00:25:07,000
解決123號。

578
00:25:07,000 --> 00:25:09,150
這是地址124。

579
00:25:09,150 --> 00:25:11,040
這是地址125。

580
00:25:11,040 --> 00:25:12,540
>> 而且我沒有搞砸這個時候。

581
00:25:12,540 --> 00:25:15,840
這些都是現在一個字節
除了由於什麼原因？

582
00:25:15,840 --> 00:25:17,930
一個char有多大？

583
00:25:17,930 --> 00:25:19,170
一個char是只是一個字節。

584
00:25:19,170 --> 00:25:20,570
一個int通常是四個字節。

585
00:25:20,570 --> 00:25:24,850
所以這就是為什麼我做了它123，
127，131，等等。

586
00:25:24,850 --> 00:25:27,560
現在，我可以保持簡單的數學
只是做加1。

587
00:25:27,560 --> 00:25:30,510
這是現在到底發生了什麼
引擎蓋下。

588
00:25:30,510 --> 00:25:37,760
>> 所以，當你宣布這樣的事情，
字符串s，這其實是 - 

589
00:25:37,760 --> 00:25:39,170
原來 - 

590
00:25:39,170 --> 00:25:41,190
字符的明星。

591
00:25:41,190 --> 00:25:44,640
明星，當然，這意味著
地址，又名指針。

592
00:25:44,640 --> 00:25:46,200
因此，它的東西的地址。

593
00:25:46,200 --> 00:25:47,510
這是什麼地址？

594
00:25:47,510 --> 00:25:47,760
>> 那麼 - 

595
00:25:47,760 --> 00:25:51,680
我是唯一一個誰可以看到非常
重要的一點，我在做，還是覺得

596
00:25:51,680 --> 00:25:52,560
我做。

597
00:25:52,560 --> 00:25:55,270
所以字符串 - 

598
00:25:55,270 --> 00:25:57,180
可悲的是，我有一個監視器
那裡我

599
00:25:57,180 --> 00:25:58,100
能看到的是。

600
00:25:58,100 --> 00:26:00,990
>> 所有的權利，所以字符串s是什麼
我先前聲明。

601
00:26:00,990 --> 00:26:04,600
但事實證明，由於一個小
神奇的的CS50庫中，這一切都

602
00:26:04,600 --> 00:26:08,780
從字面上有時間字符串
一直字符星級。

603
00:26:08,780 --> 00:26:11,310
明星再次表示
指針或地址。

604
00:26:11,310 --> 00:26:14,180
事實上，它的側翼
字字符意味著它的

605
00:26:14,180 --> 00:26:15,970
一個字符的地址。

606
00:26:15,970 --> 00:26:23,100
>> 所以，如果字符串被調用，然後我輸入
在H-E-L-L-Ø，現在建議已得到

607
00:26:23,100 --> 00:26:27,330
字串返回
這個時候，即使我們已經相當

608
00:26:27,330 --> 00:26:29,980
過於簡單化的世界嗎？

609
00:26:29,980 --> 00:26:33,310
沒有得到什麼實際字符串
作為它的返回值返回？

610
00:26:33,310 --> 00:26:35,830

611
00:26:35,830 --> 00:26:38,720
>> 123在這種情況下，例如。

612
00:26:38,720 --> 00:26:42,630
我們以前說過，得到的字符串
只是返回一個字符串，一個序列

613
00:26:42,630 --> 00:26:43,300
字符。

614
00:26:43,300 --> 00:26:44,790
但是，這是一個有點白色的謊言。

615
00:26:44,790 --> 00:26:48,010
的方式得到真正起作用的字符串
引擎蓋下是它得到

616
00:26:48,010 --> 00:26:48,930
來自用戶的字符串。

617
00:26:48,930 --> 00:26:51,530
它撲通一聲的字符
他或她在內存中。

618
00:26:51,530 --> 00:26:54,680
它把一個反斜杠零結尾
這些字符序列。

619
00:26:54,680 --> 00:26:57,310
>> 但後​​來沒有得到什麼字符串
從字面上返回？

620
00:26:57,310 --> 00:27:02,710
它的字面返回的地址
的第一個字節在RAM中的

621
00:27:02,710 --> 00:27:04,130
它用於這種力量。

622
00:27:04,130 --> 00:27:07,500
而事實證明，僅僅通過返回
一個單一的地址的

623
00:27:07,500 --> 00:27:12,120
第一個字符串中的字符，那就是
足以查找的全部

624
00:27:12,120 --> 00:27:12,630
的字符串。

625
00:27:12,630 --> 00:27:16,930
>> 換言之，得到的字符串沒有
返回123，124和125。

626
00:27:16,930 --> 00:27:19,950
它沒有給我一個長
列表中所有的字節

627
00:27:19,950 --> 00:27:20,740
我的字符串使用。

628
00:27:20,740 --> 00:27:22,670
因為，他們都是背靠背。

629
00:27:22,670 --> 00:27:28,160
和兩個，是根據第一個地址，我
可以計算出字符串結束。

630
00:27:28,160 --> 00:27:29,910
怎麼樣？

631
00:27:29,910 --> 00:27:33,490
>> 特殊的空字符，
結束，反斜線零。

632
00:27:33,490 --> 00:27:35,430
因此，換句話說，如果
你傳遞 - 

633
00:27:35,430 --> 00:27:36,530
內部變量 - 

634
00:27:36,530 --> 00:27:41,300
一個字符的地址，並承擔
，任何字符串結束時，任何

635
00:27:41,300 --> 00:27:45,040
作為我們人類的字符序列
想到的字符串，如果你假設

636
00:27:45,040 --> 00:27:48,600
在有任何這樣的字符串的末尾
一個反斜杠零，你的黃金。

637
00:27:48,600 --> 00:27:52,430
因為你總是可以找到
字符串的結尾。

638
00:27:52,430 --> 00:27:54,870
>> 現在，什麼是真正然後去
在這個程序？

639
00:27:54,870 --> 00:27:59,990
為什麼是這樣的程序，
比較0.C，越野車？

640
00:27:59,990 --> 00:28:01,690
什麼是真正被比較？

641
00:28:01,690 --> 00:28:02,420
是嗎？

642
00:28:02,420 --> 00:28:05,000
>> 學生：[聽不清]。

643
00:28:05,000 --> 00:28:05,730
>> DAVID馬蘭：沒錯。

644
00:28:05,730 --> 00:28:08,350
它的位置比較
的字符串。

645
00:28:08,350 --> 00:28:12,420
因此，如果用戶已鍵入招呼一次，
像我一樣，內存可能會結束

646
00:28:12,420 --> 00:28:13,430
這樣看。

647
00:28:13,430 --> 00:28:18,210
然後，如果用戶類型招呼再次
但再次調用get字符串，c是

648
00:28:18,210 --> 00:28:21,800
不特別聰明，除非你教
它是巧妙地編寫代碼。

649
00:28:21,800 --> 00:28:22,430
>> C  - 

650
00:28:22,430 --> 00:28:23,860
和計算機更普遍 - 

651
00:28:23,860 --> 00:28:27,370
如果你輸入單詞再打招呼，
你知道你要得到什麼。

652
00:28:27,370 --> 00:28:31,480
你只是會得到第二個數組
內存，是的，發生

653
00:28:31,480 --> 00:28:35,510
存儲H-E-L-L-O和等等。

654
00:28:35,510 --> 00:28:38,240
>> 看起來是一樣的，這是怎麼回事
我們人類，但這個地址

655
00:28:38,240 --> 00:28:39,460
可能不是123。

656
00:28:39,460 --> 00:28:42,470
所以它可能只是發生
操作系統具有一些可用的

657
00:28:42,470 --> 00:28:45,430
空間實例在位置 - 

658
00:28:45,430 --> 00:28:49,820
比方說，任意東西，
像這樣的位置200。

659
00:28:49,820 --> 00:28:51,620
這是201的位置。

660
00:28:51,620 --> 00:28:53,060
這是位置202。

661
00:28:53,060 --> 00:28:55,730
我們不知道這
要存在於內存中。

662
00:28:55,730 --> 00:28:59,110
>> 但是，這是什麼意思是，什麼是
將最終被存儲在s？

663
00:28:59,110 --> 00:29:00,750
123。

664
00:29:00,750 --> 00:29:04,860
這是怎麼回事存儲在T，
在這種武斷的例子嗎？

665
00:29:04,860 --> 00:29:06,300
200號。

666
00:29:06,300 --> 00:29:11,410
那麼這意味著是顯而易見的，
123不等於200。

667
00:29:11,410 --> 00:29:14,940
所以如果條件不
計算結果為true。

668
00:29:14,940 --> 00:29:18,430
由於獲取字符串使用不同
每次的內存塊。

669
00:29:18,430 --> 00:29:20,360
>> 現在，我們可以再次看到這個
在另一個實例中。

670
00:29:20,360 --> 00:29:23,764
讓我去進取，不斷開拓複製0.C的。

671
00:29:23,764 --> 00:29:28,770
我要求這個例子是要
嘗試 - 失敗 - 複製兩個字符串

672
00:29:28,770 --> 00:29:29,910
如下所示。

673
00:29:29,910 --> 00:29:31,730
>> 我要說點什麼
給用戶。

674
00:29:31,730 --> 00:29:34,490
然後，我會得到一個
串並調用它s。

675
00:29:34,490 --> 00:29:36,400
而現在，我做這個檢查。

676
00:29:36,400 --> 00:29:37,990
我們提到這一段時間回來。

677
00:29:37,990 --> 00:29:42,490
但是，當可能會返回空字符串，
另一個特殊字符，或特殊

678
00:29:42,490 --> 00:29:45,050
符號讓說。

679
00:29:45,050 --> 00:29:45,900
如果它的內存。

680
00:29:45,900 --> 00:29:48,970
>> 例如，如果用戶是真的
難以和一個窮凶極惡的類型

681
00:29:48,970 --> 00:29:51,220
上面的的字符數
鍵盤和點擊輸入。

682
00:29:51,220 --> 00:29:54,580
如果這個數字的字符就不能
適合在RAM中，不管是任何瘋狂

683
00:29:54,580 --> 00:29:57,820
原因，以及字符串可能
很好返回null。

684
00:29:57,820 --> 00:30:01,080
>> 或者，如果你的程序本身是做了很多
其他的事情，而且也只是

685
00:30:01,080 --> 00:30:03,790
沒有足夠的內存來獲取字符串
要取得成功，它可能結束

686
00:30:03,790 --> 00:30:05,240
向上返回null。

687
00:30:05,240 --> 00:30:07,160
但是，讓我們更精確
這是什麼。

688
00:30:07,160 --> 00:30:10,280
s的數據類型，什麼是真的嗎？

689
00:30:10,280 --> 00:30:11,610
字符明星。

690
00:30:11,610 --> 00:30:14,560
>> 因此，原來現在我們可以剝離
回空層。

691
00:30:14,560 --> 00:30:17,500
原來，null是 - 是的，很明顯
一個特殊的符號。

692
00:30:17,500 --> 00:30:19,190
但什麼是真的？

693
00:30:19,190 --> 00:30:25,220
真的，空，我們只是一個符號
人類使用的代表零。

694
00:30:25,220 --> 00:30:29,010
>> 因此，作者的C，電腦
更一般地，決定年前

695
00:30:29,010 --> 00:30:30,010
這一點，你知道是什麼。

696
00:30:30,010 --> 00:30:34,850
為什麼我們不確保沒有用戶
數據是永遠，永遠，永遠

697
00:30:34,850 --> 00:30:36,730
存儲再見零？

698
00:30:36,730 --> 00:30:39,610
事實上，即使是在我任意的例子
之前，我並沒有開始編號

699
00:30:39,610 --> 00:30:40,390
在零字節。

700
00:30:40,390 --> 00:30:41,540
我開始在一個。

701
00:30:41,540 --> 00:30:44,950
因為我知道，人在世界上
已決定預定的零

702
00:30:44,950 --> 00:30:47,970
在任何人的RAM作為字節
一些特別的東西。

703
00:30:47,970 --> 00:30:52,020
>> 原因是，任何時候你想
信號出了毛病

704
00:30:52,020 --> 00:30:55,960
地址中，返回
空 - 否則被稱為零 - 

705
00:30:55,960 --> 00:30:59,410
因為你知道，有沒有
合法的數據地址零，顯然

706
00:30:59,410 --> 00:31:00,400
這意味著一個錯誤。

707
00:31:00,400 --> 00:31:04,080
這就是為什麼，按照慣例，我們檢查
空和返回的東西

708
00:31:04,080 --> 00:31:06,260
就像一個在這些情況下。

709
00:31:06,260 --> 00:31:09,300
>> 因此，如果我們現在向下滾動，這只是
然後一些錯誤檢查，以防萬一

710
00:31:09,300 --> 00:31:10,610
[出事了？保釋？]

711
00:31:10,610 --> 00:31:13,470
完全退出程序
通過提前回國。

712
00:31:13,470 --> 00:31:19,030
現在這條線可以改寫
因為這，這意味著什麼呢？

713
00:31:19,030 --> 00:31:23,155
在左側，再給我一次
指針指向一個字符，並調用它噸。

714
00:31:23,155 --> 00:31:26,935
我是什麼存儲裡面的t，根據
這一行代碼？

715
00:31:26,935 --> 00:31:30,950

716
00:31:30,950 --> 00:31:32,170
>> 我存儲的位置。

717
00:31:32,170 --> 00:31:34,742
具體來說，位置
這是在s。

718
00:31:34,742 --> 00:31:39,000
因此，如果用戶已鍵入招呼，
你好，第一恰好結束

719
00:31:39,000 --> 00:31:42,567
在這裡，然後數123
要回來得到

720
00:31:42,567 --> 00:31:43,810
串並儲存 - 

721
00:31:43,810 --> 00:31:44,780
正如我們前面所說 - 

722
00:31:44,780 --> 00:31:45,440
在s。

723
00:31:45,440 --> 00:31:50,560
>> 當我現在宣布另一個指針
一個char並調用它的T，什麼號碼

724
00:31:50,560 --> 00:31:53,940
從字面上去結束在
噸的故事？

725
00:31:53,940 --> 00:31:55,420
所以123。

726
00:31:55,420 --> 00:32:00,310
>> 所以現在技術上s和
T是指向的確切

727
00:32:00,310 --> 00:32:02,410
相同的內存塊。

728
00:32:02,410 --> 00:32:06,140
所以通知我要現在做什麼
證明，此計劃是馬車。

729
00:32:06,140 --> 00:32:08,820
>> 首先，我稍後會要求，
打印F，資本化

730
00:32:08,820 --> 00:32:10,080
拷貝的字符串。

731
00:32:10,080 --> 00:32:11,660
然後我會做一個小小的
錯誤檢查。

732
00:32:11,660 --> 00:32:12,160
我要確保。

733
00:32:12,160 --> 00:32:16,710
讓我們確保該字符串t是
至少大於零的長度，

734
00:32:16,710 --> 00:32:19,190
所以有一些字符
實際利用。

735
00:32:19,190 --> 00:32:22,840
>> 然後你可能還記得這個
從前面的例子。

736
00:32:22,840 --> 00:32:25,630
2上 - 這是在
ctype.h的文件。

737
00:32:25,630 --> 00:32:30,800
Ť支架零給我零
字符的字符串t。

738
00:32:30,800 --> 00:32:34,360
和2上相同的值，
當然，將其轉換為大寫。

739
00:32:34,360 --> 00:32:38,230
>> 所以憑直覺，這突出顯示的行
代碼是資本化的第一

740
00:32:38,230 --> 00:32:40,250
在T字母。

741
00:32:40,250 --> 00:32:44,485
但它不直觀，轉增股本，
在s的第一個字母。

742
00:32:44,485 --> 00:32:48,130
但是，如果你超前的思維，我是什麼
看當我運行這個程序

743
00:32:48,130 --> 00:32:54,220
並打印出原來，
s，而所謂的副本，T？

744
00:32:54,220 --> 00:32:55,350
>> 他們實際上是相同的。

745
00:32:55,350 --> 00:32:56,600
他們為什麼會是一樣的嗎？

746
00:32:56,600 --> 00:32:58,970

747
00:32:58,970 --> 00:33:01,020
他們都指向
完全一樣的東西。

748
00:33:01,020 --> 00:33:01,610
因此，讓我們做到這一點。

749
00:33:01,610 --> 00:33:03,160
>> 使副本為零。

750
00:33:03,160 --> 00:33:04,070
編譯OK。

751
00:33:04,070 --> 00:33:06,500
讓我跑副本為零。

752
00:33:06,500 --> 00:33:10,110
讓我鍵入類似您好
全部小寫，然後按Enter鍵。

753
00:33:10,110 --> 00:33:16,520
它聲稱原來的S
副本的確是相同的。

754
00:33:16,520 --> 00:33:17,920
>> 所以，這裡到底發生了什麼？

755
00:33:17,920 --> 00:33:20,100
讓我重繪此圖片
在講故事

756
00:33:20,100 --> 00:33:21,340
稍微不同的方式。

757
00:33:21,340 --> 00:33:26,060
到底發生了什麼下方
當我聲明類似罩

758
00:33:26,060 --> 00:33:30,410
字符開始，或字符串s
我得到一個指針 - 

759
00:33:30,410 --> 00:33:33,090
這恰好是四個字節
的CS50器具中

760
00:33:33,090 --> 00:33:34,410
和很多計算機。

761
00:33:34,410 --> 00:33:36,008
我要調用這個S。

762
00:33:36,008 --> 00:33:39,810
而這目前有
一些未知的值。

763
00:33:39,810 --> 00:33:43,900
>> 當你聲明一個變量，除非你
自己把一個價值在那裡，誰

764
00:33:43,900 --> 00:33:44,570
知道那裡有什麼。

765
00:33:44,570 --> 00:33:48,110
這可能是一些隨機序列的
位從以前的執行。

766
00:33:48,110 --> 00:33:52,490
所以，當我在我行的代碼做
字符串，然後存儲返回

767
00:33:52,490 --> 00:33:54,800
價值得到字符串s中不知何故 - 

768
00:33:54,800 --> 00:33:58,520
我們最終會剝離怎麼弄
字符串的作品，以某種方式分配

769
00:33:58,520 --> 00:34:00,480
可能看起來的陣列
這有點像。

770
00:34:00,480 --> 00:34:05,390
H-E-L-L-O，反斜杠零。

771
00:34:05,390 --> 00:34:09,510
>> 讓我們假設這是地址
123只是第一次一致性。

772
00:34:09,510 --> 00:34:13,000
因此，獲得字符串返回，在
有突出顯示的行，它返回

773
00:34:13,000 --> 00:34:15,000
我們說的號碼，123。

774
00:34:15,000 --> 00:34:17,420
那麼什麼真正走進這裡的s？

775
00:34:17,420 --> 00:34:26,590
>> 嗯，真的什麼
裡面的s是123。

776
00:34:26,590 --> 00:34:29,250
但坦率地說，我開始有點
所有這些地址混淆，

777
00:34:29,250 --> 00:34:30,320
所有這些任意數字。

778
00:34:30,320 --> 00:34:32,290
123，124，127。

779
00:34:32,290 --> 00:34:34,570
因此，讓我們簡化
世界一點點。

780
00:34:34,570 --> 00:34:38,800
>> 當我們談論指針，坦率地說，
我們人類，他們到底在乎

781
00:34:38,800 --> 00:34:39,870
事情是在內存中？

782
00:34:39,870 --> 00:34:41,080
這完全是任意的。

783
00:34:41,080 --> 00:34:43,370
這將取決於如何
多少內存的用戶。

784
00:34:43,370 --> 00:34:46,590
這將依賴於在白天的時候
你運行的程序，也許和

785
00:34:46,590 --> 00:34:48,250
輸入用戶給你。

786
00:34:48,250 --> 00:34:50,060
我們居住不重要的細節上。

787
00:34:50,060 --> 00:34:54,230
>> 因此，讓我們抽象掉，並說，
當你運行一個像這樣的代碼行，

788
00:34:54,230 --> 00:34:57,320
字符明星就會越來越回報
獲取字符串值。

789
00:34:57,320 --> 00:35:02,720
為什麼我們不而是畫什麼，我們
保持通話就好像它是一個指針

790
00:35:02,720 --> 00:35:04,140
指著東西？

791
00:35:04,140 --> 00:35:07,000
因此，我要求現在到了
有一個指針指向 - 

792
00:35:07,000 --> 00:35:08,480
引擎蓋下，它是一個地址。

793
00:35:08,480 --> 00:35:11,330
但它只是指向
第一個字節

794
00:35:11,330 --> 00:35:12,780
字符串，被退回。

795
00:35:12,780 --> 00:35:16,710
>> 如果我現在回到這裡的代碼，
在這條線是怎麼回事？

796
00:35:16,710 --> 00:35:20,020
那麼，在現在這個突出的線路，
我聲明顯然是另一個

797
00:35:20,020 --> 00:35:21,070
變量名為t。

798
00:35:21,070 --> 00:35:25,700
但它也是一個指針，所以我要去
畫，從理論上講，確切的

799
00:35:25,700 --> 00:35:26,710
同樣大小的方塊。

800
00:35:26,710 --> 00:35:28,160
我要調用它噸。

801
00:35:28,160 --> 00:35:33,500
>> 現在，如果我們去回到代碼，
當我存儲裡面的T，

802
00:35:33,500 --> 00:35:36,920
技術上我是什麼
把裡面的t？

803
00:35:36,920 --> 00:35:39,350
那麼從技術上說，這
是數字123。

804
00:35:39,350 --> 00:35:42,270
所以，我真的應該寫
有數字123。

805
00:35:42,270 --> 00:35:43,900
但是，讓我們把它更高的水平。

806
00:35:43,900 --> 00:35:48,090
T，如果它僅僅是一個指針，
直觀的，就是這樣。

807
00:35:48,090 --> 00:35:49,800
這是所有被
存儲在那裡。

808
00:35:49,800 --> 00:35:54,970
>> 所以，現在在最後一個有趣的線
代碼，當我真正去了解

809
00:35:54,970 --> 00:36:00,680
資本化零字符
T，是怎麼回事？

810
00:36:00,680 --> 00:36:06,310
那麼，T支架零現在指向
什麼樣的性格，想必？

811
00:36:06,310 --> 00:36:07,460
>> 它指向到h。

812
00:36:07,460 --> 00:36:08,870
因為T支架零 - 

813
00:36:08,870 --> 00:36:12,490
記得，這是舊的語法。噸支架
只是意味著，如果t是一個字符串，T零

814
00:36:12,490 --> 00:36:15,590
支架零意味著零
在這種力量的人物。

815
00:36:15,590 --> 00:36:18,650
所以，真正意味著什麼
到這個數組 - 

816
00:36:18,650 --> 00:36:21,520
是的，這可能是123，
這可能是124。

817
00:36:21,520 --> 00:36:22,790
但它是相對的，記不清了。

818
00:36:22,790 --> 00:36:25,640
每當談論一個數組，我們有
談論的優勢

819
00:36:25,640 --> 00:36:27,000
相對指標。

820
00:36:27,000 --> 00:36:31,120
>> 所以現在我們可以假設
那件T支架零小時。

821
00:36:31,120 --> 00:36:35,090
所以，如果我叫2上就可以了，那是什麼
真正做的是資本

822
00:36:35,090 --> 00:36:38,290
大寫小寫h H.
不過，當然，什麼是S？

823
00:36:38,290 --> 00:36:41,010
它指向相同織補字符串。

824
00:36:41,010 --> 00:36:44,200
>> 因此，這是已經發生
在這段代碼中至今。

825
00:36:44,200 --> 00:36:45,960
那麼什麼寓意？

826
00:36:45,960 --> 00:36:48,300
我們如何解決這兩個問題呢？

827
00:36:48,300 --> 00:36:50,870
我們如何比較實際的字符串？

828
00:36:50,870 --> 00:36:53,720
>> 直觀地好了，怎麼會
你去比較兩個

829
00:36:53,720 --> 00:36:55,090
真正的平等的字符串？

830
00:36:55,090 --> 00:36:58,920

831
00:36:58,920 --> 00:37:00,750
>> 是什麼意思，如果兩個
字符串相等？

832
00:37:00,750 --> 00:37:04,330
顯然不是，他們的地址是
等於在內存中，因為這是一個低

833
00:37:04,330 --> 00:37:06,590
一級執行細節。

834
00:37:06,590 --> 00:37:08,360
所有的字符是相同的。

835
00:37:08,360 --> 00:37:12,810
所以我建議，讓我介紹一下
在一個compare.c版本

836
00:37:12,810 --> 00:37:14,970
在這裡，所以比較1.C。

837
00:37:14,970 --> 00:37:19,590
>> 最後，我提議，我們仍然獲得了
指針，和存儲在它

838
00:37:19,590 --> 00:37:20,610
獲取字符串返回值。

839
00:37:20,610 --> 00:37:21,750
讓我們做同樣的事情與t。

840
00:37:21,750 --> 00:37:23,230
因此，沒有代碼是不同的。

841
00:37:23,230 --> 00:37:25,420
我要加少許
更多錯誤檢查現在。

842
00:37:25,420 --> 00:37:29,390
所以，現在我們有點脫皮
這層CS50什麼字符串

843
00:37:29,390 --> 00:37:33,520
實際上，我們需要更肛門
關於如何確保我們不要濫用

844
00:37:33,520 --> 00:37:35,330
無效的值，如空。

845
00:37:35,330 --> 00:37:36,440
>> 所以我只是去檢查。

846
00:37:36,440 --> 00:37:41,490
如果s不等於空，T不
等於空，這意味著我們確定。

847
00:37:41,490 --> 00:37:44,460
獲取字符串沒有搞砸得到
無論是這些字符串。

848
00:37:44,460 --> 00:37:51,270
你也許可以猜到現在，
STR CMP也許可以做到嗎？

849
00:37:51,270 --> 00:37:52,000
字符串比較。

850
00:37:52,000 --> 00:37:55,470
>> 所以，如果你已經在Java程序之前，
這是像equals方法

851
00:37:55,470 --> 00:37:56,490
string類。

852
00:37:56,490 --> 00:37:57,890
但是，對於那些你們誰沒有
編程之前，

853
00:37:57,890 --> 00:37:59,320
這僅僅是一個C函數。

854
00:37:59,320 --> 00:38:02,180
它發生在
文件名為string.h中。

855
00:38:02,180 --> 00:38:03,830
這就是它的聲明。

856
00:38:03,830 --> 00:38:05,110
>> 和字符串比較 - 

857
00:38:05,110 --> 00:38:07,530
我居然忘記了它的用法，
但從來沒有介意。

858
00:38:07,530 --> 00:38:10,470
回想一下，我們可以做
人，攪勻比較。

859
00:38:10,470 --> 00:38:12,590
這是怎麼回事，彈出
Linux程序員手冊。

860
00:38:12,590 --> 00:38:14,060
和它的，坦率地說，有點神秘。

861
00:38:14,060 --> 00:38:15,270
但我可以在這裡看到，沒錯。

862
00:38:15,270 --> 00:38:17,570
我必須包括string.h中。

863
00:38:17,570 --> 00:38:20,590
>> 這裡說下描述，“
字符串比較功能比較

864
00:38:20,590 --> 00:38:24,560
兩個字符串S1和S2。而S1
和S2是顯然是兩個

865
00:38:24,560 --> 00:38:26,120
參數傳入。

866
00:38:26,120 --> 00:38:28,650
我真的不記得什麼
const是，但現在發現 - 

867
00:38:28,650 --> 00:38:31,480
你可能已經看到了這一點時，已經
你使用的手冊頁，如果你

868
00:38:31,480 --> 00:38:32,390
擁有這一切 - 

869
00:38:32,390 --> 00:38:36,220
字符星級只是代名詞
字符串。

870
00:38:36,220 --> 00:38:40,440
>> 因此，比較這兩個字符串S1和
S2，並返回一個整數減

871
00:38:40,440 --> 00:38:44,930
於或等於或大於零的
如果發現S1，分別是

872
00:38:44,930 --> 00:38:47,450
小於或匹配，或者
大於S2。

873
00:38:47,450 --> 00:38:51,220
這只是一個非常複雜的方式說
字符串比較回報

874
00:38:51,220 --> 00:38:55,760
零，如果兩個字符串，可以直觀地
相同的字符

875
00:38:55,760 --> 00:38:57,120
對於字符。

876
00:38:57,120 --> 00:38:59,970
>> 它返回一個負數，如果
，按字母順序排列，應該是

877
00:38:59,970 --> 00:39:01,010
來之前噸。

878
00:39:01,010 --> 00:39:05,300
或者返回一個正數，如果
s是應該來後t

879
00:39:05,300 --> 00:39:06,170
按字母順序排列。

880
00:39:06,170 --> 00:39:08,360
因此，這個簡單的函數，可以
例如，排序

881
00:39:08,360 --> 00:39:09,770
一大堆的話嗎？

882
00:39:09,770 --> 00:39:13,984
>> 因此，在這個新版本中，我要去
繼續前進，做比較。

883
00:39:13,984 --> 00:39:15,750
點斜線比較。

884
00:39:15,750 --> 00:39:18,030
我會全部小寫鍵入打招呼。

885
00:39:18,030 --> 00:39:20,300
我要鍵入你好的
再在全部小寫。

886
00:39:20,300 --> 00:39:23,340
幸好現在實現
我輸入了同樣的事情。

887
00:39:23,340 --> 00:39:27,520
>> 同時，如果我輸入打招呼較低
情況和Hello大寫

888
00:39:27,520 --> 00:39:29,710
對它們進行比較，我打
不同的事情。

889
00:39:29,710 --> 00:39:32,530
不僅是因為地址
不同的，但我們比較

890
00:39:32,530 --> 00:39:35,350
不同的字符一遍又一遍。

891
00:39:35,350 --> 00:39:37,320
>> 那麼讓我們去修復一個
現在其他問題。

892
00:39:37,320 --> 00:39:41,590
讓我打開一個版本
複製，現在解決

893
00:39:41,590 --> 00:39:42,900
這個問題如下。

894
00:39:42,900 --> 00:39:45,650
而這個人會看
更複雜一點。

895
00:39:45,650 --> 00:39:49,320
但是，如果你想想什麼問題，我們
需要解決，希望這將是

896
00:39:49,320 --> 00:39:51,870
現在只是一瞬間清除。

897
00:39:51,870 --> 00:39:57,280
>> 因此，這第一線，燒焦啟動T，在
通俗地說可能有人提出

898
00:39:57,280 --> 00:39:59,450
這條線在這裡是指什麼？

899
00:39:59,450 --> 00:40:01,050
字符明星T，這樣做是什麼？

900
00:40:01,050 --> 00:40:06,660

901
00:40:06,660 --> 00:40:07,210
>> 好。

902
00:40:07,210 --> 00:40:09,500
創建一個指針，指向某些
現貨在內存中。

903
00:40:09,500 --> 00:40:10,930
讓我提煉它一點點。

904
00:40:10,930 --> 00:40:17,180
聲明一個變量將存儲
一些字符在內存中的地址，只是

905
00:40:17,180 --> 00:40:18,480
要適當多一點。

906
00:40:18,480 --> 00:40:21,210
>> 好了，現在在右手側，我
從來沒有見過這些功能之一

907
00:40:21,210 --> 00:40:22,660
之前，malloc的。

908
00:40:22,660 --> 00:40:26,980
但是，什麼意思呢？

909
00:40:26,980 --> 00:40:28,050
分配的內存。

910
00:40:28,050 --> 00:40:29,410
內存分配。

911
00:40:29,410 --> 00:40:33,050
>> 因此，原來，到現在為止，我們
還沒有真正有強大的方式

912
00:40:33,050 --> 00:40:36,210
要求的操作系統，
給我一些內存。

913
00:40:36,210 --> 00:40:39,980
相反，我們現在有一個函數調用
malloc的正是這麼做的。

914
00:40:39,980 --> 00:40:42,960
儘管這是一個有點
現在分心，注意到，在

915
00:40:42,960 --> 00:40:46,200
兩個括號之間是
只是要一個數字。

916
00:40:46,200 --> 00:40:48,510
我輸入問題
商標可以是一個數字。

917
00:40:48,510 --> 00:40:51,020
>> 而且這個數字意味著，
給我10個字節​​。

918
00:40:51,020 --> 00:40:52,320
給我20個字節。

919
00:40:52,320 --> 00:40:53,820
給我100個字節。

920
00:40:53,820 --> 00:40:56,500
和malloc將盡最大努力
要求操作系統 - 

921
00:40:56,500 --> 00:40:57,630
Linux中，在這種情況下 - 

922
00:40:57,630 --> 00:40:59,630
哎，他們的100個字節
可用的RAM？

923
00:40:59,630 --> 00:41:04,320
如果是這樣，我返回這些字節
返回的地址中的哪一種

924
00:41:04,320 --> 00:41:06,610
這些字節，也許？

925
00:41:06,610 --> 00:41:07,610
第一個。

926
00:41:07,610 --> 00:41:10,460
>> 因此，這裡太 - 這是佔主導地位
在C中，任何時候你

927
00:41:10,460 --> 00:41:11,680
處理地址？

928
00:41:11,680 --> 00:41:15,830
你幾乎總是處理
第一個這樣的地址，不管有多大

929
00:41:15,830 --> 00:41:19,490
你被一塊內存
傳回，可以這麼說。

930
00:41:19,490 --> 00:41:20,880
>> 因此，讓我們在這裡潛水。

931
00:41:20,880 --> 00:41:23,940
我想怎麼分配
多少個字節，到底是什麼？

932
00:41:23,940 --> 00:41:24,080
嘛。

933
00:41:24,080 --> 00:41:26,090
字符串的長度為S  - 讓
做一個具體的例子。

934
00:41:26,090 --> 00:41:30,700
如果你好s是，H-E-L-L-O，什麼是
字符串的長度，顯然？

935
00:41:30,700 --> 00:41:32,010
因此，它是五。

936
00:41:32,010 --> 00:41:34,590
但我在做加1，為什麼呢？

937
00:41:34,590 --> 00:41:37,700
為什麼我要六個字節
而不是五個？

938
00:41:37,700 --> 00:41:38,790
空字符。

939
00:41:38,790 --> 00:41:41,210
>> 我不想離開這
特殊的空字符。

940
00:41:41,210 --> 00:41:45,160
因為如果我做一個副本您好
只是做H-E-L-L-O，但我不把

941
00:41:45,160 --> 00:41:50,160
特別字符，電腦
可能沒有，一次偶然的機會，一個反斜杠

942
00:41:50,160 --> 00:41:51,730
零對我有。

943
00:41:51,730 --> 00:41:55,570
所以，如果我試圖找出
副本的長度，我可能會認為

944
00:41:55,570 --> 00:41:59,360
這是20個字符長，或者一百萬
如果我只是從來沒有發生字符

945
00:41:59,360 --> 00:42:01,050
打反斜線零。

946
00:42:01,050 --> 00:42:05,780
>> 因此，我們需要6個字節來存儲
H-E-L-L-O，反斜杠零。

947
00:42:05,780 --> 00:42:07,870
然後，這僅僅是
是超肛門。

948
00:42:07,870 --> 00:42:10,700
假設，我忘了什麼
一個char的大小。

949
00:42:10,700 --> 00:42:12,020
我們一直說這是一個字節。

950
00:42:12,020 --> 00:42:12,860
它通常是。

951
00:42:12,860 --> 00:42:15,425
從理論上講，它可能是一些
不同，在不同的Mac或

952
00:42:15,425 --> 00:42:16,250
不同的PC。

953
00:42:16,250 --> 00:42:19,650
>> 因此，原來有這個操作符
叫的sizeof，如果你傳遞給它

954
00:42:19,650 --> 00:42:22,680
名稱的數據類型 - 像
char或int或浮 - 

955
00:42:22,680 --> 00:42:26,930
它會告訴你，動態的，有多少
字節一個字符佔用

956
00:42:26,930 --> 00:42:28,090
特定的計算機。

957
00:42:28,090 --> 00:42:31,360
>> 因此，這是有效的只是
好像是說次1或

958
00:42:31,360 --> 00:42:32,440
時間什麼都沒有。

959
00:42:32,440 --> 00:42:36,340
但我這樣做只是為了超級肛門，
，一個char以防萬一不同

960
00:42:36,340 --> 00:42:40,610
在您的計算機與礦山，這樣一來
數學總是要退房。

961
00:42:40,610 --> 00:42:43,720
>> 最後，這裡我檢查null
這始終是很好的做法 - 再

962
00:42:43,720 --> 00:42:44,920
任何時候，我們正在處理的指針。

963
00:42:44,920 --> 00:42:47,520
如果malloc是不是能夠給
我6輪空 - 這是

964
00:42:47,520 --> 00:42:49,210
可能性不大，但以防萬一 - 

965
00:42:49,210 --> 00:42:50,730
馬上返回一個。

966
00:42:50,730 --> 00:42:53,290
而現在，接著複製
的字符串，如下所示。

967
00:42:53,290 --> 00:42:57,240
這是熟悉的語法，
儘管在不同的角色。

968
00:42:57,240 --> 00:43:01,210
>> 我要繼續前進，讓字符串
s的長度，並將其存儲在n。

969
00:43:01,210 --> 00:43:06,620
然後，我要循環從i等於
零和包括正，

970
00:43:06,620 --> 00:43:08,410
大於或等於。

971
00:43:08,410 --> 00:43:13,540
因此，在每次迭代中，我把
在第i個字符的第i個

972
00:43:13,540 --> 00:43:15,380
字符的t。

973
00:43:15,380 --> 00:43:18,190
>> 所以，到底發生了什麼，上下方
這裡的引擎蓋？

974
00:43:18,190 --> 00:43:22,140
好吧，如果這樣，例如，S  - 

975
00:43:22,140 --> 00:43:26,400
我已經輸入字H-E-L-L-O
並有一個反斜杠零。

976
00:43:26,400 --> 00:43:29,020
再次強調，這是這裡的指點。

977
00:43:29,020 --> 00:43:30,830
這裡現在是t。

978
00:43:30,830 --> 00:43:34,860
>> 這是現在指向
副本內存，對不對？

979
00:43:34,860 --> 00:43:37,340
malloc函數有給我一個完整
的內存塊。

980
00:43:37,340 --> 00:43:41,440
我不知道最初是什麼
在所有這些位置。

981
00:43:41,440 --> 00:43:44,340
所以我打算把它們看作
一大堆問號。

982
00:43:44,340 --> 00:43:50,190
>> 但只要我一開始從零循環
向上穿過的長度，噸

983
00:43:50,190 --> 00:43:52,790
支架零和t支架1  - 

984
00:43:52,790 --> 00:43:55,080
我會立即把這個
上的開銷 - 

985
00:43:55,080 --> 00:44:04,190
零噸支架和s支架零的意思
我要複製

986
00:44:04,190 --> 00:44:09,875
迭代ħ在這裡，E-L-L-O。
另外，因為我做的加

987
00:44:09,875 --> 00:44:12,370
，反斜線零。

988
00:44:12,370 --> 00:44:19,060
>> 所以現在比較1.C的情況下，
在年底，如果我打印出來的

989
00:44:19,060 --> 00:44:24,760
資本的t，我們應該
看到，s是不變的。

990
00:44:24,760 --> 00:44:26,090
讓我現在繼續做這個。

991
00:44:26,090 --> 00:44:28,630
所以COPY1。

992
00:44:28,630 --> 00:44:30,860
點斜線副本1。

993
00:44:30,860 --> 00:44:33,670
我打招呼，輸入要輸入。

994
00:44:33,670 --> 00:44:37,430
現在注意到，只有副本
已被資本化。

995
00:44:37,430 --> 00:44:40,890
因為我確實有兩個
內存塊。

996
00:44:40,890 --> 00:44:44,390
>> 不幸的是，你可以做一些漂亮的
這裡壞，相當危險的事情。

997
00:44:44,390 --> 00:44:49,290
讓我拉起一個例子現在在這裡，
為我們提供了一個例子，幾個

998
00:44:49,290 --> 00:44:51,540
不同的線路。

999
00:44:51,540 --> 00:44:56,040
所以只是憑直覺在這裡，第一行
碼，詮釋星級的x，正在申報

1000
00:44:56,040 --> 00:44:57,340
一個變量x。

1001
00:44:57,340 --> 00:44:58,810
，什麼是數據類型
該變量？

1002
00:44:58,810 --> 00:45:01,820

1003
00:45:01,820 --> 00:45:04,290
該變量的數據類型是什麼？

1004
00:45:04,290 --> 00:45:06,980
這不是吊人胃口。

1005
00:45:06,980 --> 00:45:08,350
>> 的數據類型為int的明星。

1006
00:45:08,350 --> 00:45:12,600
那麼，到底是什麼意思呢？ X的
一個int存儲地址。

1007
00:45:12,600 --> 00:45:13,520
就這麼簡單。

1008
00:45:13,520 --> 00:45:16,220
Y為要存儲
一個int地址。

1009
00:45:16,220 --> 00:45:18,390
第三行是什麼
代碼做什麼呢？

1010
00:45:18,390 --> 00:45:21,850
它的分配多少
字節，最有可能？

1011
00:45:21,850 --> 00:45:22,350
四。

1012
00:45:22,350 --> 00:45:25,460
由於一個int的大小是
一般四，四的malloc給

1013
00:45:25,460 --> 00:45:29,950
我回了一大塊地址
內存的字節的第一個是

1014
00:45:29,950 --> 00:45:32,110
現在存儲在x。

1015
00:45:32,110 --> 00:45:34,410
>> 現在，我們正在一點點迅速。

1016
00:45:34,410 --> 00:45:35,760
星x表示什麼？

1017
00:45:35,760 --> 00:45:38,480

1018
00:45:38,480 --> 00:45:42,590
這意味著進入該地址
並提出有什麼號碼？

1019
00:45:42,590 --> 00:45:43,870
將有數字42。

1020
00:45:43,870 --> 00:45:47,590
星y表示在y
把有13號。

1021
00:45:47,590 --> 00:45:48,600
>> 但是且慢。

1022
00:45:48,600 --> 00:45:51,640
y中的那一刻是什麼？

1023
00:45:51,640 --> 00:45:54,950
什麼地址為y存儲？

1024
00:45:54,950 --> 00:45:55,770
我們不知道，對不對？

1025
00:45:55,770 --> 00:45:59,230
我們從來沒有一次使用賦值
運營商涉及Ÿ。

1026
00:45:59,230 --> 00:46:03,370
所以y在第二行的聲明
代碼只是一些垃圾值，大

1027
00:46:03,370 --> 00:46:04,760
問號可以這麼說。

1028
00:46:04,760 --> 00:46:07,230
它可以指向隨機
在內存中的任何事情，這

1029
00:46:07,230 --> 00:46:08,340
普遍不好。

1030
00:46:08,340 --> 00:46:13,540
>> 所以只要我們在那裡打線，
星級y等於13，壞的東西，

1031
00:46:13,540 --> 00:46:17,220
太差的東西大約是
發生賓基。

1032
00:46:17,220 --> 00:46:25,810
因此，讓我們看看會發生什麼結束
發生在這一分鐘賓基

1033
00:46:25,810 --> 00:46:26,200
左右的樣子。

1034
00:46:26,200 --> 00:46:26,490
>> [視頻回放]

1035
00:46:26,490 --> 00:46:26,745
>> 嘿，賓基。

1036
00:46:26,745 --> 00:46:27,000
醒來。

1037
00:46:27,000 --> 00:46:29,296
它的時間的指針樂趣。

1038
00:46:29,296 --> 00:46:30,680
>>  - 那是什麼？

1039
00:46:30,680 --> 00:46:31,980
了解指針？

1040
00:46:31,980 --> 00:46:34,010
哦，滿載而歸。

1041
00:46:34,010 --> 00:46:37,220
>> 好吧，上手，我想我們
將需要一對夫婦的指針。

1042
00:46:37,220 --> 00:46:37,930
>>  - 確定。

1043
00:46:37,930 --> 00:46:41,650
該代碼分配兩個指針
它可以指向整數。

1044
00:46:41,650 --> 00:46:43,760
>> OK，好了，我看到兩個指針。

1045
00:46:43,760 --> 00:46:45,850
但他們似乎沒有要
指向任何東西。

1046
00:46:45,850 --> 00:46:46,490
>> 這是正確的。

1047
00:46:46,490 --> 00:46:48,630
最初，指針不
指向任何東西。

1048
00:46:48,630 --> 00:46:51,700
它們指向的東西被稱為
指針對象，設置起來是一個

1049
00:46:51,700 --> 00:46:52,850
單獨的步驟。

1050
00:46:52,850 --> 00:46:53,740
>> 哦，對，沒錯。

1051
00:46:53,740 --> 00:46:54,500
我知道。

1052
00:46:54,500 --> 00:46:56,270
指針對象是分開的。

1053
00:46:56,270 --> 00:46:58,553
那麼你是怎麼分配一個pointee的？

1054
00:46:58,553 --> 00:46:59,480
>>  - 確定。

1055
00:46:59,480 --> 00:47:03,707
那麼，這個代碼分配一個新的整數
指針對象，而這部分集合X

1056
00:47:03,707 --> 00:47:05,520
指向它。

1057
00:47:05,520 --> 00:47:06,760
>> 嘿，這看起來更好。

1058
00:47:06,760 --> 00:47:08,520
所以，讓它做點事。

1059
00:47:08,520 --> 00:47:09,530
>>  - 確定。

1060
00:47:09,530 --> 00:47:14,110
我會取消引用指針x到存儲
42號及其指針。

1061
00:47:14,110 --> 00:47:17,660
對於這一招，我需要我的魔法
魔杖提領。

1062
00:47:17,660 --> 00:47:20,695
>> 你的魔杖提領？

1063
00:47:20,695 --> 00:47:22,632
呃，這是偉大的。

1064
00:47:22,632 --> 00:47:24,620
>> 這是什麼樣的代碼看起來像。

1065
00:47:24,620 --> 00:47:27,526
我剛剛設立的數量，以及 - 

1066
00:47:27,526 --> 00:47:28,250
>> 嘿，看。

1067
00:47:28,250 --> 00:47:29,680
就這樣吧。

1068
00:47:29,680 --> 00:47:34,520
這樣算下來，反引用X服從
箭頭訪問及其指針。

1069
00:47:34,520 --> 00:47:36,690
在這種情況下，在那裡存儲42。

1070
00:47:36,690 --> 00:47:40,890
嘿，嘗試用它來存儲數字
13通過其他指針，Y。

1071
00:47:40,890 --> 00:47:42,125
>>  - 確定。

1072
00:47:42,125 --> 00:47:46,810
我就在這裡為y，並且
13號成立。

1073
00:47:46,810 --> 00:47:50,890
然後拿魔杖
提領，只是 - 

1074
00:47:50,890 --> 00:47:52,430
哇！

1075
00:47:52,430 --> 00:47:53,030
>> 哦，嘿嘿。

1076
00:47:53,030 --> 00:47:54,610
這沒有奏效。

1077
00:47:54,610 --> 00:47:58,200
賓基說，我不認為
提領y是一個不錯的主意，

1078
00:47:58,200 --> 00:48:01,370
因為設立的pointee，
是一個獨立的步驟。

1079
00:48:01,370 --> 00:48:03,460
我不認為我們曾經做到了。

1080
00:48:03,460 --> 00:48:03,810
>> 嗯。

1081
00:48:03,810 --> 00:48:05,160
好點。

1082
00:48:05,160 --> 00:48:07,410
>> 是的，我們分配的指針y。

1083
00:48:07,410 --> 00:48:10,045
但是，我們從來沒有將其設置為
指向的pointee。

1084
00:48:10,045 --> 00:48:10,490
>> 嗯。

1085
00:48:10,490 --> 00:48:12,170
非常細心。

1086
00:48:12,170 --> 00:48:13,790
>> 嘿，你看
好，賓基。

1087
00:48:13,790 --> 00:48:16,920
你可以解決它，使y點
到相同的指針對象為x？

1088
00:48:16,920 --> 00:48:17,810
>>  - 當然。

1089
00:48:17,810 --> 00:48:20,300
我會用我的魔杖
指針賦值。

1090
00:48:20,300 --> 00:48:22,240
>> -IS將是一個
像以前一樣的問題？

1091
00:48:22,240 --> 00:48:22,665
>> 沒有。

1092
00:48:22,665 --> 00:48:24,300
這不觸摸指針對象。

1093
00:48:24,300 --> 00:48:27,880
它只是改變了一個指針指向
作為另一個同樣的事情。

1094
00:48:27,880 --> 00:48:28,970
>> 哦，我明白了。

1095
00:48:28,970 --> 00:48:31,730
y點為x到同一個地方。

1096
00:48:31,730 --> 00:48:32,450
所以等待。

1097
00:48:32,450 --> 00:48:33,490
現在y的固定。

1098
00:48:33,490 --> 00:48:34,630
它有一個指針對象。

1099
00:48:34,630 --> 00:48:36,520
所以，你可以嘗試魔杖
再次提領

1100
00:48:36,520 --> 00:48:39,200
送13以上。

1101
00:48:39,200 --> 00:48:39,840
>>  - 確定。

1102
00:48:39,840 --> 00:48:41,570
這裡去。

1103
00:48:41,570 --> 00:48:42,870
>> 嘿，看看那。

1104
00:48:42,870 --> 00:48:44,320
現在提領工程對y。

1105
00:48:44,320 --> 00:48:47,020
而且，由於指針共享
那一個指針對象，他們

1106
00:48:47,020 --> 00:48:48,585
看到13。

1107
00:48:48,585 --> 00:48:49,040
>> 呀。

1108
00:48:49,040 --> 00:48:49,670
共享。

1109
00:48:49,670 --> 00:48:50,380
不管。

1110
00:48:50,380 --> 00:48:52,290
所以我們現在去開關的地方嗎？

1111
00:48:52,290 --> 00:48:52,970
>> 哦，看。

1112
00:48:52,970 --> 00:48:54,150
我們沒時間了。

1113
00:48:54,150 --> 00:48:55,200
>> 但是 - 

1114
00:48:55,200 --> 00:48:57,060
>> 只要記住三個
指針規則。

1115
00:48:57,060 --> 00:49:00,100
數一，基本結構
就是你有一個指針。

1116
00:49:00,100 --> 00:49:02,170
它指向指針對象。

1117
00:49:02,170 --> 00:49:04,160
但是，指針和指針對象
是分開的。

1118
00:49:04,160 --> 00:49:06,460
常見的錯誤是
設立一個指針，但到

1119
00:49:06,460 --> 00:49:08,540
忘了給定的指針對象。

1120
00:49:08,540 --> 00:49:12,460
>> 兩個指針引用開始
上面的指針和如下

1121
00:49:12,460 --> 00:49:14,570
箭頭的訪問及其指針。

1122
00:49:14,570 --> 00:49:18,640
正如我們都知道，這只是工作，如果有
指針對象，回來

1123
00:49:18,640 --> 00:49:19,790
排除頭號。

1124
00:49:19,790 --> 00:49:23,670
>> 三，需要指針賦值
一個指針，它指向的變化

1125
00:49:23,670 --> 00:49:25,850
作為另一個指針的指針對象。

1126
00:49:25,850 --> 00:49:27,840
因此，在轉讓之後，
兩個指針

1127
00:49:27,840 --> 00:49:29,430
指向相同的pointee。

1128
00:49:29,430 --> 00:49:31,600
有時候，這就是所謂的共享。

1129
00:49:31,600 --> 00:49:33,430
而這一切就是這麼簡單，真的。

1130
00:49:33,430 --> 00:49:33,840
再見了。

1131
00:49:33,840 --> 00:49:34,300
>> [END視頻播放]

1132
00:49:34,300 --> 00:49:36,940
>> 國寶馬蘭：因此，更多的三分球，
更下週賓基上。

1133
00:49:36,940 --> 00:49:38,190
我們會看到你在星期一。

1134
00:49:38,190 --> 00:49:42,187