1
00:00:00,000 --> 00:00:06,030
>> [音樂播放]

2
00:00:06,030 --> 00:00:08,390
>> DOUG LLOYD：指針，我們在這裡。

3
00:00:08,390 --> 00:00:11,080
這可能會
是最困難的話題

4
00:00:11,080 --> 00:00:12,840
我們在這裡討論的CS50。

5
00:00:12,840 --> 00:00:15,060
如果你讀過
關於指針什麼

6
00:00:15,060 --> 00:00:19,080
之前，你可能會有點
恐嚇進入這部影片。

7
00:00:19,080 --> 00:00:21,260
這是真的指針
不要讓你的能力

8
00:00:21,260 --> 00:00:23,740
到也許搞砸了
當你很厲害

9
00:00:23,740 --> 00:00:27,450
與變量和數據的工作，
並導致程序崩潰。

10
00:00:27,450 --> 00:00:30,490
但他們實際上是非常有用的
他們讓我們一個真正偉大的方式

11
00:00:30,490 --> 00:00:33,340
通過數據備份和
第四功能之間，

12
00:00:33,340 --> 00:00:35,490
我們是否則無法做到。

13
00:00:35,490 --> 00:00:37,750
>> 還等什麼，我們真的
想在這裡做的是火車

14
00:00:37,750 --> 00:00:41,060
你有很好的指針紀律，所以
你可以有效地使用指針

15
00:00:41,060 --> 00:00:43,850
讓你的程序要好得多。

16
00:00:43,850 --> 00:00:48,220
正如我所說的三分球給我們一個不同的
辦法函數之間傳遞數據。

17
00:00:48,220 --> 00:00:50,270
現在，如果你還記得
較早的視頻，當

18
00:00:50,270 --> 00:00:53,720
我們談論
變量的作用域，我提到

19
00:00:53,720 --> 00:01:00,610
所有我們傳遞的數據
在C函數是按值傳遞。

20
00:01:00,610 --> 00:01:03,070
我可能沒有使用的
看，我的意思有

21
00:01:03,070 --> 00:01:07,170
是我們傳遞數據的副本。

22
00:01:07,170 --> 00:01:12,252
當我們通過一個變量的函數，
我們沒有真正傳遞變量

23
00:01:12,252 --> 00:01:13,210
的功能，對不對？

24
00:01:13,210 --> 00:01:17,670
我們傳遞的一個副本
該數據的功能。

25
00:01:17,670 --> 00:01:20,760
該函數做的事情會
並計算出一定的價值，

26
00:01:20,760 --> 00:01:23,180
也許大家使用該值
當它給它回來。

27
00:01:23,180 --> 00:01:26,700
>> 有一個例外
這條規則按值傳遞的，

28
00:01:26,700 --> 00:01:31,210
我們會回來的是什麼
有一點後來在這部影片。

29
00:01:31,210 --> 00:01:34,880
如果我們用指針來代替
使用變量的，

30
00:01:34,880 --> 00:01:38,180
或者使用替代的變量
本身或變量的副本，

31
00:01:38,180 --> 00:01:43,790
我們現在可以通過周圍的變量
之間以不同的方式的功能。

32
00:01:43,790 --> 00:01:46,550
這意味著，如果我們使
在一種功能的變化，

33
00:01:46,550 --> 00:01:49,827
這一變化實際上會
在不同的功能的影響。

34
00:01:49,827 --> 00:01:52,160
再次，這是一件
我們以前無法做到，

35
00:01:52,160 --> 00:01:56,979
如果你曾經嘗試交換
在函數兩個變量的值，

36
00:01:56,979 --> 00:01:59,270
你已經注意到了這個問題
排序攀升，對不對？

37
00:01:59,270 --> 00:02:04,340
>> 如果我們想交換的X和Y，和我們
他們通過一個叫交換功能，

38
00:02:04,340 --> 00:02:08,680
該函數內部交換
變量做交換價值。

39
00:02:08,680 --> 00:02:12,600
一變二，二變
，但我們實際上並不

40
00:02:12,600 --> 00:02:16,890
在原有的任何改變
功能，在呼叫者。

41
00:02:16,890 --> 00:02:19,550
因為我們不能，我們只
與他們一起工作的副本。

42
00:02:19,550 --> 00:02:24,760
隨著指針雖然，我們可以
實際上通過X和Y的一個函數。

43
00:02:24,760 --> 00:02:26,960
這個函數可以做
一些與他們。

44
00:02:26,960 --> 00:02:29,250
而那些變量的值
其實可以改變。

45
00:02:29,250 --> 00:02:33,710
所以這是在相當長的變化
我們處理數據的能力。

46
00:02:33,710 --> 00:02:36,100
>> 在我們深入
三分球，我認為這是值得

47
00:02:36,100 --> 00:02:38,580
花幾分鐘到
回到基礎在這裡。

48
00:02:38,580 --> 00:02:41,000
同時你也可以看看如何
計算機存儲作品

49
00:02:41,000 --> 00:02:45,340
因為這兩個科目會
實際上是非常相關的。

50
00:02:45,340 --> 00:02:48,480
正如你可能知道，
您的計算機系統

51
00:02:48,480 --> 00:02:51,310
你有一個硬盤驅動器或
也許是固態硬盤，

52
00:02:51,310 --> 00:02:54,430
某種形式的文件存儲位置。

53
00:02:54,430 --> 00:02:57,950
它通常某處
250千兆字節附近

54
00:02:57,950 --> 00:02:59,810
也許到了幾個TB的現在。

55
00:02:59,810 --> 00:03:02,270
而這也正是所有的
文件最終活，

56
00:03:02,270 --> 00:03:04,870
即使您的計算機關閉
關閉，你可以將其重新打開

57
00:03:04,870 --> 00:03:09,190
你會發現你的文件存在
再次當您重新啟動您的系統。

58
00:03:09,190 --> 00:03:14,820
但是磁盤驅動器，像一個硬盤驅動器，
一個硬盤驅動器或固態硬盤，固態硬盤，

59
00:03:14,820 --> 00:03:16,050
只是存儲空間。

60
00:03:16,050 --> 00:03:20,400
>> 我們實際上不能做任何與
該數據是在硬盤，

61
00:03:20,400 --> 00:03:22,080
或固態驅動器。

62
00:03:22,080 --> 00:03:24,950
為了真正改變
數據或移動它，

63
00:03:24,950 --> 00:03:28,800
我們必須把它移到
RAM的隨機存取存儲器。

64
00:03:28,800 --> 00:03:31,170
現在RAM，你有很多
少在您的計算機。

65
00:03:31,170 --> 00:03:34,185
您可能有某處
512兆附近

66
00:03:34,185 --> 00:03:38,850
如果你有一個舊的電腦，
到也許兩個，四個，八個，十六

67
00:03:38,850 --> 00:03:41,820
甚至可能是一點點
此外，4GB的內存。

68
00:03:41,820 --> 00:03:46,390
所以這是非常小，但是這
其中所有的易失性數據的存在。

69
00:03:46,390 --> 00:03:48,270
這就是我們可以改變的事情。

70
00:03:48,270 --> 00:03:53,350
但是，當我們把自己的電腦關閉，
所有在RAM中的數據被破壞。

71
00:03:53,350 --> 00:03:57,150
>> 所以這就是為什麼我們需要硬盤
對於它的更穩定的位置，

72
00:03:57,150 --> 00:03:59,720
這樣它exists-它會
是真的不好，如果我們每次都

73
00:03:59,720 --> 00:04:03,310
把我們的電腦關閉，每
在我們的系統文件被抹殺。

74
00:04:03,310 --> 00:04:05,600
因此，我們的RAM裡面工作。

75
00:04:05,600 --> 00:04:09,210
而每一次，我們正在談論的
內存，相當多，在CS50，

76
00:04:09,210 --> 00:04:15,080
我們談論的RAM，而不是硬盤。

77
00:04:15,080 --> 00:04:18,657
>> 所以，當我們搬東西到內存中，
它佔用一定的空間。

78
00:04:18,657 --> 00:04:20,740
所有的數據類型的
我們一直在與

79
00:04:20,740 --> 00:04:23,480
採取了不同的
量的RAM空間。

80
00:04:23,480 --> 00:04:27,600
所以，每次創建一個整數
可變的，四個字節的存儲器

81
00:04:27,600 --> 00:04:30,750
被擱置在RAM中，所以你
可以與整數工作。

82
00:04:30,750 --> 00:04:34,260
可以聲明整數，
改變它，為它分配

83
00:04:34,260 --> 00:04:36,700
一個值10增加
由一個，等等等等。

84
00:04:36,700 --> 00:04:39,440
所有需要發生在
RAM，你會得到四個字節

85
00:04:39,440 --> 00:04:42,550
一起工作的每一個
整數創建的。

86
00:04:42,550 --> 00:04:45,410
>> 每個字符您
創建得到一個字節。

87
00:04:45,410 --> 00:04:48,160
這就是空間到底有多少是
存儲一個字符需要的。

88
00:04:48,160 --> 00:04:51,310
每個浮動，一個真正的
數，得到四個字節

89
00:04:51,310 --> 00:04:53,390
除非它是一個雙
精度浮點

90
00:04:53,390 --> 00:04:56,510
號，它可以讓你
有更精確或多個數字

91
00:04:56,510 --> 00:04:59,300
小數點後
又不失精確，

92
00:04:59,300 --> 00:05:01,820
它佔用八個字節的內存。

93
00:05:01,820 --> 00:05:06,730
長期多頭，真正的大整數，
還佔用八個字節的內存。

94
00:05:06,730 --> 00:05:09,000
有多少字節的內存
做字符串佔用？

95
00:05:09,000 --> 00:05:12,990
好吧，讓我們把一根鋼釘這個問題
現在，但我們會回來的。

96
00:05:12,990 --> 00:05:17,350
>> 所以回到這一想法的內存
字節大小的單元的大數組。

97
00:05:17,350 --> 00:05:20,871
這真的是這樣，它的
只是一個巨大的數組細胞，

98
00:05:20,871 --> 00:05:23,370
就像任何其他的陣列
你熟悉和觀望，

99
00:05:23,370 --> 00:05:26,430
除了每一個元素是一個字節寬。

100
00:05:26,430 --> 00:05:30,030
就如同一個數組，
每個單元都有一個地址。

101
00:05:30,030 --> 00:05:32,120
數組中的每個元素
有索引，並且我們

102
00:05:32,120 --> 00:05:36,302
可以使用該索引做所謂的
陣列上隨機接入。

103
00:05:36,302 --> 00:05:38,510
我們沒有開始在
數組的開始，

104
00:05:38,510 --> 00:05:40,569
遍歷每個
其單個元件

105
00:05:40,569 --> 00:05:41,860
找到我們所要尋找的。

106
00:05:41,860 --> 00:05:45,790
我們只能說，我想要得到的
第十五元件或100元件。

107
00:05:45,790 --> 00:05:49,930
而且你可以通過該號碼
並得到你要尋找的價值。

108
00:05:49,930 --> 00:05:54,460
>> 同樣每一個位置
在存儲器都有一個地址。

109
00:05:54,460 --> 00:05:57,320
所以，你的記憶可能
是這個樣子。

110
00:05:57,320 --> 00:06:01,420
這裡是一個非常小的大塊
存儲器，這是20個字節的存儲器。

111
00:06:01,420 --> 00:06:04,060
前20個字節，因為我
地址有在底部

112
00:06:04,060 --> 00:06:08,890
是0，1，2，3，依此
在一路攀升至19。

113
00:06:08,890 --> 00:06:13,190
而當我宣布變量，
當我開始與他們合作，

114
00:06:13,190 --> 00:06:15,470
該系統將要設置
我預留一些空間

115
00:06:15,470 --> 00:06:17,595
在該存儲器中的工作
我的變量。

116
00:06:17,595 --> 00:06:21,610
所以我可以說，炭c等於資本
H.什麼事情發生？

117
00:06:21,610 --> 00:06:23,880
那麼該系統會
拋開對我來說一個字節。

118
00:06:23,880 --> 00:06:27,870
在這種情況下，它選擇字節數目
四，在涉及到四個字節，

119
00:06:27,870 --> 00:06:31,310
並且它要保存
在信中有大寫的H我。

120
00:06:31,310 --> 00:06:34,350
如果我那麼說INT速度
極限等於65，這是

121
00:06:34,350 --> 00:06:36,806
要預留4
記憶對我來說字節。

122
00:06:36,806 --> 00:06:39,180
它是怎麼回事治療那些
四個字節作為一個單位

123
00:06:39,180 --> 00:06:41,305
因為我們正在努力
用在這裡是一個整數。

124
00:06:41,305 --> 00:06:44,350
而且它要存儲65在裡面。

125
00:06:44,350 --> 00:06:47,000
>> 現在已經我有點
告訴你有點騙人的，

126
00:06:47,000 --> 00:06:50,150
對的，因為我們知道，
計算機二進制工作。

127
00:06:50,150 --> 00:06:53,100
他們不明白
一定就是一個大寫的H是

128
00:06:53,100 --> 00:06:57,110
或者什麼是65，他們只
懂二進制，零和的。

129
00:06:57,110 --> 00:06:59,000
所以實際上是什麼
我們要存儲在那裡

130
00:06:59,000 --> 00:07:03,450
是不是字母H和65號，
而是二進制表示法

131
00:07:03,450 --> 00:07:06,980
物，它看起來
有點這樣的事情。

132
00:07:06,980 --> 00:07:10,360
並且特別是在
整型變量的情況下，

133
00:07:10,360 --> 00:07:13,559
它不會只是吐了進去，
它不會把它當作四位一體

134
00:07:13,559 --> 00:07:15,350
字節塊必然，
它實際上是

135
00:07:15,350 --> 00:07:19,570
把它當作四分之一的字節塊，
這可能會是這個樣子。

136
00:07:19,570 --> 00:07:22,424
即使這不是
完全正確要么，

137
00:07:22,424 --> 00:07:24,840
因為一種叫
字節排列順序，這我們不

138
00:07:24,840 --> 00:07:26,965
要進入了，但
如果你好奇，

139
00:07:26,965 --> 00:07:29,030
你可以少讀了
與大字節序。

140
00:07:29,030 --> 00:07:31,640
但為了這個說法，
為了這個視頻，

141
00:07:31,640 --> 00:07:34,860
讓我們姑且認為，在
事實上，如何在65號會

142
00:07:34,860 --> 00:07:36,970
在代表
每個內存的系統上，

143
00:07:36,970 --> 00:07:38,850
儘管這不是完全正確的。

144
00:07:38,850 --> 00:07:41,700
>> 但是，讓我們實際上只是獲得
去掉所有的二進制完全，

145
00:07:41,700 --> 00:07:44,460
而只是想想為：H
65，這是一個容易得多

146
00:07:44,460 --> 00:07:47,900
想想它像
，作為一個人。

147
00:07:47,900 --> 00:07:51,420
好吧，所以它似乎也可能是
有點亂了I've-我的系統

148
00:07:51,420 --> 00:07:55,130
沒給我個字節5，6，7，
和圖8來存儲整數。

149
00:07:55,130 --> 00:07:58,580
還有一個理由，同樣，這
我們不會進入的權利，但足夠了

150
00:07:58,580 --> 00:08:00,496
我要說的是什麼
計算機在這裡做什麼

151
00:08:00,496 --> 00:08:02,810
可能是它的一部分，一個很好的舉措。

152
00:08:02,810 --> 00:08:06,020
給不給我的內存是
一定背靠背。

153
00:08:06,020 --> 00:08:10,490
雖然它現在打算怎麼辦呢
如果我想獲得另一個字符串，

154
00:08:10,490 --> 00:08:13,080
所謂的姓，我想
把勞合社在那裡。

155
00:08:13,080 --> 00:08:18,360
我將需要添加1
性格，那每個字母的

156
00:08:18,360 --> 00:08:21,330
將需要一個
字符，存儲器的一個字節。

157
00:08:21,330 --> 00:08:26,230
所以，如果我可以把勞合社進入我的數組
這樣的我很不好走，對不對？

158
00:08:26,230 --> 00:08:28,870
缺少了什麼？

159
00:08:28,870 --> 00:08:31,840
>> 請記住，每一個字符串我們的工作
用C語言結尾反斜杠零，

160
00:08:31,840 --> 00:08:33,339
我們不能忽略，在這裡，無論是。

161
00:08:33,339 --> 00:08:36,090
我們需要預留一個字節
內存來保存，所以我們

162
00:08:36,090 --> 00:08:39,130
知道什麼時候我們的字符串已經結束。

163
00:08:39,130 --> 00:08:41,049
所以，再一次這樣的安排
事物的方式

164
00:08:41,049 --> 00:08:42,799
出現在內存中的威力
有點亂，

165
00:08:42,799 --> 00:08:44,870
但它實際上是多麼的
大多數系統的設計。

166
00:08:44,870 --> 00:08:48,330
要它們對齊的倍數
四，原因再次

167
00:08:48,330 --> 00:08:50,080
我們並不需要
進入現在。

168
00:08:50,080 --> 00:08:53,060
不過這一點，所以我只想說的
這三行代碼後，

169
00:08:53,060 --> 00:08:54,810
這是記憶是什麼樣子。

170
00:08:54,810 --> 00:08:58,930
如果我需要的存儲位置
4，8，和12來保存我的數據，

171
00:08:58,930 --> 00:09:01,100
這是我的記憶是什麼樣子。

172
00:09:01,100 --> 00:09:04,062
>> 而就特別
迂腐這裡，當

173
00:09:04,062 --> 00:09:06,020
我們談論的記憶
地址我們通常

174
00:09:06,020 --> 00:09:08,390
這樣做使用十六進制符號。

175
00:09:08,390 --> 00:09:12,030
那麼，我們為什麼不把所有這些
從十進制轉換為十六進制

176
00:09:12,030 --> 00:09:15,010
只是因為這是一般
我們如何參考存儲器。

177
00:09:15,010 --> 00:09:17,880
因此，而不是為0〜
19，我們有什麼是零

178
00:09:17,880 --> 00:09:20,340
x零到零X1三種。

179
00:09:20,340 --> 00:09:23,790
這些是20個字節的內存，我們
也或者我們正在尋找在這個圖片

180
00:09:23,790 --> 00:09:25,540
就在這裡。

181
00:09:25,540 --> 00:09:29,310
>> 因此，所有的他這樣說，讓我們
從內存一步之遙了第二

182
00:09:29,310 --> 00:09:30,490
和背部的指針。

183
00:09:30,490 --> 00:09:32,420
這裡最重要的
事情要記住

184
00:09:32,420 --> 00:09:34,070
當我們開始與指針的工作。

185
00:09:34,070 --> 00:09:36,314
指針是什麼
不是一個地址了。

186
00:09:36,314 --> 00:09:38,230
我會再次因為說出來
它是那麼重要，

187
00:09:38,230 --> 00:09:42,730
一個指針是什麼
不是一個地址了。

188
00:09:42,730 --> 00:09:47,760
指針是地址位置
在內存中的變量住。

189
00:09:47,760 --> 00:09:52,590
知道它有望成為一個
稍微容易一些與他們合作。

190
00:09:52,590 --> 00:09:54,550
另一件事我喜歡
這樣做是有排序

191
00:09:54,550 --> 00:09:58,510
的圖表直觀代表什麼
發生與各行的代碼。

192
00:09:58,510 --> 00:10:00,660
我們會做這樣的夫妻
在指針的時候，

193
00:10:00,660 --> 00:10:03,354
當我們談論動態
內存分配也是如此。

194
00:10:03,354 --> 00:10:06,020
因為我認為，這些圖
可以是特別有幫助。

195
00:10:06,020 --> 00:10:09,540
>> 所以，如果我說，例如，時int k
在我的代碼，發生了什麼事？

196
00:10:09,540 --> 00:10:12,524
那麼什麼是主要發生在
我得到的內存預留給了我，

197
00:10:12,524 --> 00:10:14,690
但我甚至不喜歡
想想這樣的，我

198
00:10:14,690 --> 00:10:16,300
喜歡去想它像一個盒子。

199
00:10:16,300 --> 00:10:20,090
我有一個盒子，它的
顏色為綠色，因為我

200
00:10:20,090 --> 00:10:21,750
可以把整數綠框。

201
00:10:21,750 --> 00:10:23,666
如果這是一個角色，我
可能有一個藍色的盒子。

202
00:10:23,666 --> 00:10:27,290
但是，我總是說，如果我創建
一箱，可容納整數

203
00:10:27,290 --> 00:10:28,950
該框為綠色。

204
00:10:28,950 --> 00:10:33,020
我拿一個永久性標記
而我寫鉀對的這一邊。

205
00:10:33,020 --> 00:10:37,590
所以，我有一個盒子叫做K，
到了我可以把整數。

206
00:10:37,590 --> 00:10:41,070
所以當我說INT K，這是
在我的腦海會發生什麼。

207
00:10:41,070 --> 00:10:43,140
如果我說k等於五，我在做什麼？

208
00:10:43,140 --> 00:10:45,110
好吧，我把5
在框中，正確的。

209
00:10:45,110 --> 00:10:48,670
這是非常簡單的，如果
我說INT K，創建一個盒子叫做K。

210
00:10:48,670 --> 00:10:52,040
如果我說k等於5，
投入五成箱。

211
00:10:52,040 --> 00:10:53,865
我希望這不是一個太大的飛躍。

212
00:10:53,865 --> 00:10:55,990
這就是事情走
有趣的一點，雖然。

213
00:10:55,990 --> 00:11:02,590
如果我說INT * PK，以及即使我不
知道這必然意味著，

214
00:11:02,590 --> 00:11:06,150
這顯然是得到的東西
做的整數。

215
00:11:06,150 --> 00:11:08,211
所以，我要色
這個盒子的綠色十歲上下，

216
00:11:08,211 --> 00:11:10,210
我知道它有什麼
做的整數，

217
00:11:10,210 --> 00:11:13,400
但它不是一個整數本身，
因為它是一個int明星。

218
00:11:13,400 --> 00:11:15,390
有一些稍微
不同吧。

219
00:11:15,390 --> 00:11:17,620
因此，一個整數的參與，
但除此之外，它的

220
00:11:17,620 --> 00:11:19,830
從沒有太多不同
我們都在談論。

221
00:11:19,830 --> 00:11:24,240
這是一個盒子，它有一個標籤，
它穿著標籤PK，

222
00:11:24,240 --> 00:11:27,280
而且它能夠容納
INT明星，不管那些。

223
00:11:27,280 --> 00:11:29,894
他們有事可做
與整數，清晰。

224
00:11:29,894 --> 00:11:31,060
這裡的最後一行，雖然。

225
00:11:31,060 --> 00:11:37,650
如果我說PK =＆K，哇，
剛剛發生了什麼，對不對？

226
00:11:37,650 --> 00:11:41,820
所以這個隨機數，看似隨意
數，被扔進了箱子那裡。

227
00:11:41,820 --> 00:11:44,930
所有也就是說，是峰
得到k的地址。

228
00:11:44,930 --> 00:11:52,867
所以我會繼續其中k內存裡，
其地址，其字節的地址。

229
00:11:52,867 --> 00:11:55,200
我做的是我的話
該值就是我要去

230
00:11:55,200 --> 00:11:59,430
把我的箱子叫做PK的內部。

231
00:11:59,430 --> 00:12:02,080
而且，由於這些東西都是
指針，因為找

232
00:12:02,080 --> 00:12:04,955
在像無×字符串
八零Ç7四八

233
00:12:04,955 --> 00:12:07,790
兩個零可能
意義不大。

234
00:12:07,790 --> 00:12:12,390
當我們通常想像的指針，
我們實際上這樣做的指針。

235
00:12:12,390 --> 00:12:17,000
PK給我們的信息
我們需要找到K的內存​​。

236
00:12:17,000 --> 00:12:19,120
因此，基本上峰中有一個箭頭。

237
00:12:19,120 --> 00:12:21,670
如果我們走的長度
那個箭頭，想像

238
00:12:21,670 --> 00:12:25,280
這件事情，你可以走，如果我們
沿箭頭的長度行走，

239
00:12:25,280 --> 00:12:29,490
在該箭頭的最前端，我們
會發現在存儲器中的位置

240
00:12:29,490 --> 00:12:31,390
其中k生活。

241
00:12:31,390 --> 00:12:34,360
這真的很重要
因為一旦我們知道其中k生活，

242
00:12:34,360 --> 00:12:37,870
我們可以開始與數據進行工作
裡面的內存位置。

243
00:12:37,870 --> 00:12:40,780
雖然我們得到的蠅頭
有點超前了現在。

244
00:12:40,780 --> 00:12:42,240
>> 那麼，什麼是指針？

245
00:12:42,240 --> 00:12:45,590
指針是它的一個數據項
值是一個存儲器地址。

246
00:12:45,590 --> 00:12:49,740
這是零個八零的東西
怎麼回事，這是一個內存地址。

247
00:12:49,740 --> 00:12:52,060
那是在存儲器中的位置。

248
00:12:52,060 --> 00:12:55,080
和指針的類型
描述的那種

249
00:12:55,080 --> 00:12:56,930
數據，你會發現在
該存儲器地址。

250
00:12:56,930 --> 00:12:58,810
因此，有整型明星的部分權利。

251
00:12:58,810 --> 00:13:03,690
如果我按照箭頭，它的
要帶領我的位置。

252
00:13:03,690 --> 00:13:06,980
而那個位置，我
會發現有在我的例子，

253
00:13:06,980 --> 00:13:08,240
是一個綠色的盒子。

254
00:13:08,240 --> 00:13:12,650
這是一個整數，這就是我
會發現如果我去這個地址。

255
00:13:12,650 --> 00:13:14,830
的數據類型
指針描述了

256
00:13:14,830 --> 00:13:17,936
你會發現在這個內存地址。

257
00:13:17,936 --> 00:13:19,560
因此，這裡的很酷的事情雖然。

258
00:13:19,560 --> 00:13:25,090
指針允許我們傳遞
功能之間的變量。

259
00:13:25,090 --> 00:13:28,520
而實際上傳遞變量
而不是通過他們的副本。

260
00:13:28,520 --> 00:13:32,879
因為如果我們確切地知道在哪裡
在存儲器找到的變量，

261
00:13:32,879 --> 00:13:35,670
我們並不需要作出的副本
它，我們可以去到那個位置

262
00:13:35,670 --> 00:13:37,844
和與該可變工作。

263
00:13:37,844 --> 00:13:40,260
因此，在本質指針排序
做出一個計算機環境

264
00:13:40,260 --> 00:13:42,360
很多更像是真正的世界吧。

265
00:13:42,360 --> 00:13:44,640
>> 因此，這裡是一個比喻。

266
00:13:44,640 --> 00:13:48,080
比方說，我有一個筆記本，
對了，這是充滿了筆記。

267
00:13:48,080 --> 00:13:50,230
我希望你能更新。

268
00:13:50,230 --> 00:13:53,960
你是一個函數，
更新注意事項，正確的。

269
00:13:53,960 --> 00:13:56,390
在路上，我們一直
到目前為止的工作，有什麼

270
00:13:56,390 --> 00:14:02,370
偏偏是你將採取我的筆記本，
你會去到複印店，

271
00:14:02,370 --> 00:14:06,410
你會做的影印件
筆記本的每一頁。

272
00:14:06,410 --> 00:14:09,790
你會離開我的筆記本背
我的辦公桌上時，你就大功告成了，

273
00:14:09,790 --> 00:14:14,600
你會去交掉的東西在我的
筆記本電腦，過時或錯誤的，

274
00:14:14,600 --> 00:14:19,280
然後你就會傳回
我施樂頁堆疊

275
00:14:19,280 --> 00:14:22,850
這是我的筆記本電腦與副本
你做了它的變化。

276
00:14:22,850 --> 00:14:27,040
在這一點上，它給我，
調用函數，作為呼叫者，

277
00:14:27,040 --> 00:14:30,582
決定把你的筆記和
它們整合回我的筆記本電腦。

278
00:14:30,582 --> 00:14:32,540
因此，有很多步驟
這裡涉及到了吧。

279
00:14:32,540 --> 00:14:34,850
就像那豈不是更好
如果我只是說，哎，你

280
00:14:34,850 --> 00:14:38,370
更新我的筆記本
我，交給你我的筆記本，

281
00:14:38,370 --> 00:14:40,440
你拿的東西，
從字面上跨出來

282
00:14:40,440 --> 00:14:42,810
並更新我的筆記在我的筆記本。

283
00:14:42,810 --> 00:14:45,140
然後給我我的筆記本電腦了。

284
00:14:45,140 --> 00:14:47,320
這是什麼樣的
指針允許我們這樣做，

285
00:14:47,320 --> 00:14:51,320
他們做出這樣的環境中有很多
更像是我們如何運作的現實。

286
00:14:51,320 --> 00:14:54,640
>> 所有這樣的權利是什麼
一個指針，讓我們來談談

287
00:14:54,640 --> 00:14:58,040
關於指針在C中是如何工作的，並
我們如何開始與他們合作。

288
00:14:58,040 --> 00:15:02,550
所以這是一個非常簡單的指針
稱為C中的空指針。

289
00:15:02,550 --> 00:15:04,830
空指針指向什麼。

290
00:15:04,830 --> 00:15:08,310
這可能看起來像它的
其實不是一個非常有用的東西，

291
00:15:08,310 --> 00:15:10,500
但正如我們將看到一個
過了一會兒上，其實

292
00:15:10,500 --> 00:15:15,410
這個空指針存在
居然真的能派上用場。

293
00:15:15,410 --> 00:15:19,090
每當你創建一個指針，
你不將其值設置立即─

294
00:15:19,090 --> 00:15:21,060
設置的一個例子
其價值立即

295
00:15:21,060 --> 00:15:25,401
將一對夫婦滑回
在這裡我說的PK等於＆K，

296
00:15:25,401 --> 00:15:28,740
PK獲得K公司的地址，
我們將看到這意味著什麼，

297
00:15:28,740 --> 00:15:32,990
我們將看到如何編碼的shortly-
如果我們不將其值設置為某事

298
00:15:32,990 --> 00:15:35,380
馬上有意義的，
你應該總是

299
00:15:35,380 --> 00:15:37,480
設置你的指針指向空。

300
00:15:37,480 --> 00:15:40,260
你應該把它設置為指向什麼。

301
00:15:40,260 --> 00:15:43,614
>> 這比很大的不同
正要離開的價值，因為它是

302
00:15:43,614 --> 00:15:45,530
然後聲明
指針，只是假設

303
00:15:45,530 --> 00:15:48,042
這是零，因為那是很少如此。

304
00:15:48,042 --> 00:15:50,000
所以，你應該總是設置
一個指針的值

305
00:15:50,000 --> 00:15:55,690
為空，如果你不將其值設置
立即有意義的事。

306
00:15:55,690 --> 00:15:59,090
您可以檢查是否指針的值
為null使用等於運算符

307
00:15:59,090 --> 00:16:05,450
（==），就像你比較任意整數
值或使用字符值（= =）

308
00:16:05,450 --> 00:16:06,320
為好。

309
00:16:06,320 --> 00:16:10,994
這是一種特殊的恆
值，你可以用它來測試。

310
00:16:10,994 --> 00:16:13,160
所以這是一個非常簡單的
指針，空指針。

311
00:16:13,160 --> 00:16:15,320
另一種方式來創建
一個指針是提取

312
00:16:15,320 --> 00:16:18,240
一個變量的地址
你已經創建，

313
00:16:18,240 --> 00:16:22,330
而你做到這一點使用的＆
運營商地址提取。

314
00:16:22,330 --> 00:16:26,720
對此我們已經先前看到的
在第一個圖的例子我發現。

315
00:16:26,720 --> 00:16:31,450
因此，如果x是，我們的變量
已創建的整數類型，

316
00:16:31,450 --> 00:16:35,110
然後＆x是一個指向一個整數。

317
00:16:35,110 --> 00:16:39,810
＆X是 - 記住，和將要提取
的右邊的事情的地址。

318
00:16:39,810 --> 00:16:45,350
並且由於一個指針只是一個地址，
比＆x是一個指向整數

319
00:16:45,350 --> 00:16:48,560
它的值就是在存儲器X的生活。

320
00:16:48,560 --> 00:16:50,460
這是X的地址。

321
00:16:50,460 --> 00:16:53,296
所以與x是x的地址。

322
00:16:53,296 --> 00:16:55,670
讓我們這一步
進一步連接到一些東西

323
00:16:55,670 --> 00:16:58,380
我暗示在一先前視頻。

324
00:16:58,380 --> 00:17:06,730
如果ARR是double數組，然後
與改編括號我是一個指針

325
00:17:06,730 --> 00:17:08,109
一個雙。

326
00:17:08,109 --> 00:17:08,970
確定。

327
00:17:08,970 --> 00:17:12,160
常用3方括號我，如果
ARR是雙打的陣列，

328
00:17:12,160 --> 00:17:19,069
那麼常用3括號我是
該數組的第i個元素，

329
00:17:19,069 --> 00:17:29,270
並與常用3方括號我就是在
存儲器改編的第i個元素的存在。

330
00:17:29,270 --> 00:17:31,790
>> 那麼，有什麼含義嗎？

331
00:17:31,790 --> 00:17:34,570
一個數組名，寓意
這整個事情，

332
00:17:34,570 --> 00:17:39,290
是，陣列的名稱是
其實本身就是一個指針。

333
00:17:39,290 --> 00:17:41,170
你一直工作
與所有的指針沿著

334
00:17:41,170 --> 00:17:45,290
每次你使用一個數組的時間。

335
00:17:45,290 --> 00:17:49,090
還記得本例
可變範圍，

336
00:17:49,090 --> 00:17:53,420
不久我目前的視頻結束
一個例子，我們有一個函數

337
00:17:53,420 --> 00:17:56,890
所謂集合int和一個
函數調用集陣列。

338
00:17:56,890 --> 00:18:00,490
而你的挑戰，以確定
無論是否，或什麼

339
00:18:00,490 --> 00:18:03,220
我們打印出值
該函數結束，

340
00:18:03,220 --> 00:18:05,960
在主程序的末尾。

341
00:18:05,960 --> 00:18:08,740
>> 如果從這個例子召回
或者，如果你看過視頻，

342
00:18:08,740 --> 00:18:13,080
你知道你 - 在調用的時候
集INT有效地不執行任何操作。

343
00:18:13,080 --> 00:18:16,390
但調用設置陣列一樣。

344
00:18:16,390 --> 00:18:19,280
我幾分掩飾為什麼
這是在該時間的情況下。

345
00:18:19,280 --> 00:18:22,363
我剛才說了，那麼它的一個數組，它的
特別的，你知道，有一個原因。

346
00:18:22,363 --> 00:18:25,020
其原因是，陣列的
名字其實只是一個指針，

347
00:18:25,020 --> 00:18:28,740
這裡面的這個特殊的
方括號語法

348
00:18:28,740 --> 00:18:30,510
使事情很多更好的工作。

349
00:18:30,510 --> 00:18:34,410
並且他們做的想法
指針少了很多恐嚇，

350
00:18:34,410 --> 00:18:36,800
這就是為什麼他們排序
呈現的那樣。

351
00:18:36,800 --> 00:18:38,600
但實際上數組只是指針。

352
00:18:38,600 --> 00:18:41,580
這就是為什麼當我們
做出了改變到陣列，

353
00:18:41,580 --> 00:18:44,880
當我們傳遞了一個數組作為參數
到函數或作為參數

354
00:18:44,880 --> 00:18:50,110
陣列的一個功能時，內容
在這兩個被叫方實際改變

355
00:18:50,110 --> 00:18:51,160
並且在調用者。

356
00:18:51,160 --> 00:18:55,846
這對於所有其他類型的
我們看到變量，情況並非如此。

357
00:18:55,846 --> 00:18:58,970
所以，這只是要保持
當你使用指針介意，

358
00:18:58,970 --> 00:19:01,610
是，一個名
數組實際上是一個指針

359
00:19:01,610 --> 00:19:04,750
該陣列的第一個元素。

360
00:19:04,750 --> 00:19:08,930
>> OK，現在我們有所有這些
事實，讓我們繼續前進吧。

361
00:19:08,930 --> 00:19:11,370
我們為什麼要關心
其中，一些住。

362
00:19:11,370 --> 00:19:14,120
那麼就像我說的，這是相當
要知道一些有用的生活

363
00:19:14,120 --> 00:19:17,240
所以你可以去那裡並改變它。

364
00:19:17,240 --> 00:19:19,390
使用它，實際上
有件事，你

365
00:19:19,390 --> 00:19:23,710
要做到這個變量生效，
而不是採取一些它的複印效果。

366
00:19:23,710 --> 00:19:26,150
這被稱為間接引用。

367
00:19:26,150 --> 00:19:28,690
我們去參考和
我們改變價值在那裡。

368
00:19:28,690 --> 00:19:32,660
因此，如果我們有一個指針，它被稱為
電腦，它指向一個字符，

369
00:19:32,660 --> 00:19:40,610
那麼我們可以說，* PC和* PC是
什麼，我們會發現，如果我們去的名字

370
00:19:40,610 --> 00:19:42,910
到的地址的PC。

371
00:19:42,910 --> 00:19:47,860
我們會發現有一個字符，
* PC是我們參考的數據，在該

372
00:19:47,860 --> 00:19:48,880
位置。

373
00:19:48,880 --> 00:19:54,150
因此，我們可以這樣說：
* PC = D或類似的東西，

374
00:19:54,150 --> 00:19:59,280
這意味著，無論
在內存地址的電腦，

375
00:19:59,280 --> 00:20:07,040
無論角色是以前
在那裡，現在是研發，如果說* PC = D。

376
00:20:07,040 --> 00:20:10,090
>> 所以在這裡，我們又來了與
一些怪異的Ç的東西，對吧。

377
00:20:10,090 --> 00:20:14,560
因此，我們已經看到了*以前作為
莫名其妙的數據類型的一部分​​，

378
00:20:14,560 --> 00:20:17,160
而現在它在被使用
一個稍微不同的上下文

379
00:20:17,160 --> 00:20:19,605
在一個位置，以訪問數據。

380
00:20:19,605 --> 00:20:22,480
我知道這是一個有點混亂，
這實際上是這個整體的一部分

381
00:20:22,480 --> 00:20:25,740
喜歡，為什麼指針有這個神話
他們周圍的是如此複雜，

382
00:20:25,740 --> 00:20:28,250
是那種語法問題，說實話。

383
00:20:28,250 --> 00:20:31,810
但*用在這兩種情況下，
既作為類型名稱的一部分，

384
00:20:31,810 --> 00:20:34,100
我們會看到一個小
後來別的東西。

385
00:20:34,100 --> 00:20:36,490
而現在是
引用操作。

386
00:20:36,490 --> 00:20:38,760
如此這般到參考，
它訪問數據

387
00:20:38,760 --> 00:20:43,000
在指針的位置，並
可以讓你隨意操縱它。

388
00:20:43,000 --> 00:20:45,900
>> 現在，這是非常相似的
訪問你的鄰居吧。

389
00:20:45,900 --> 00:20:48,710
如果你知道你的
鄰居的生活，你

390
00:20:48,710 --> 00:20:50,730
未掛出與你的鄰居。

391
00:20:50,730 --> 00:20:53,510
你知道你恰巧
知道他們住在哪裡，

392
00:20:53,510 --> 00:20:56,870
但是，這並不意味著，通過
憑藉具有知識

393
00:20:56,870 --> 00:20:59,170
你與他們的互動。

394
00:20:59,170 --> 00:21:01,920
如果你想與他們進行互動，
你必須去他們家，

395
00:21:01,920 --> 00:21:03,760
你必須去他們住的地方。

396
00:21:03,760 --> 00:21:07,440
一旦你做到這一點，
那麼你可以互動

397
00:21:07,440 --> 00:21:09,420
他們就像你想要。

398
00:21:09,420 --> 00:21:12,730
而同樣有變數，
你需要去他們的地址

399
00:21:12,730 --> 00:21:15,320
如果你想交互他們，
你不能只知道地址。

400
00:21:15,320 --> 00:21:21,495
而你去這個地址的方法是
使用*，則引用操作。

401
00:21:21,495 --> 00:21:23,620
你覺得會發生
如果我們試圖和反引用

402
00:21:23,620 --> 00:21:25,260
一個指針，它的值是空？

403
00:21:25,260 --> 00:21:28,470
回想一下，空
指針指向什麼。

404
00:21:28,470 --> 00:21:34,110
所以，如果你嘗試取消引用
沒事還是去到一個地址什麼都沒有，

405
00:21:34,110 --> 00:21:36,800
你覺得會發生什麼？

406
00:21:36,800 --> 00:21:39,630
那麼，如果你猜分割
故障，你是對的。

407
00:21:39,630 --> 00:21:41,390
如果您嘗試取消引用
一個空指針，

408
00:21:41,390 --> 00:21:43,140
你受苦分割
故障。別急，

409
00:21:43,140 --> 00:21:45,820
我沒有告訴你，
如果你不打算

410
00:21:45,820 --> 00:21:49,220
設置你的價值你
指針到一些有意義的事情，

411
00:21:49,220 --> 00:21:51,000
你應該設置為null？

412
00:21:51,000 --> 00:21:55,290
我沒有和實際的分割
故障是怎麼樣的一個很好的行為。

413
00:21:55,290 --> 00:21:58,680
>> 你有沒有聲明的變量和
沒有立即指派它的價值？

414
00:21:58,680 --> 00:22:02,680
所以，你剛才說INT X;你不
實際上它分配給什麼

415
00:22:02,680 --> 00:22:05,340
再後來就在你的代碼，
你打印出x的值，

416
00:22:05,340 --> 00:22:07,650
有還是沒有
其分配到任何東西。

417
00:22:07,650 --> 00:22:10,370
你經常會得到
零，但有時你

418
00:22:10,370 --> 00:22:15,000
可能會得到一些隨機數，並
你不知道它是從哪裡來的。

419
00:22:15,000 --> 00:22:16,750
同樣的事情可以
發生在三分球。

420
00:22:16,750 --> 00:22:20,110
在聲明指針
INT * PK為例，

421
00:22:20,110 --> 00:22:23,490
你不將它分配一個值，
你得到四個字節的內存。

422
00:22:23,490 --> 00:22:25,950
任何四個字節的
存儲器系統可以

423
00:22:25,950 --> 00:22:28,970
發現有一些有意義的價值。

424
00:22:28,970 --> 00:22:31,760
還有可能是
已經存在的東西了

425
00:22:31,760 --> 00:22:34,190
不再需要由另一
功能，所以你只要有

426
00:22:34,190 --> 00:22:35,900
不管數據在那裡。

427
00:22:35,900 --> 00:22:40,570
>> 如果你試圖做提領
你沒有 - 也有一些地址

428
00:22:40,570 --> 00:22:43,410
已經字節和信息
在那裡，這是現在在你的指針。

429
00:22:43,410 --> 00:22:47,470
如果您嘗試取消引用該指針，
你可能會和一些內存來搞亂

430
00:22:47,470 --> 00:22:49,390
你不打算
惹這一切。

431
00:22:49,390 --> 00:22:51,639
而事實上，你可以做
一些真正毀滅性的，

432
00:22:51,639 --> 00:22:54,880
像打破另一個程序，
或打破另一項功能，

433
00:22:54,880 --> 00:22:58,289
或者做一些惡意的
你不打算做的。

434
00:22:58,289 --> 00:23:00,080
所以這就是為什麼它是
實際上是一個好主意

435
00:23:00,080 --> 00:23:04,030
設置你的指針，如果你為null
不要將它們設置為有意義的事。

436
00:23:04,030 --> 00:23:06,760
它可能會更好的
當天的程序結束

437
00:23:06,760 --> 00:23:09,840
崩潰，然後為它做
一些螺絲了

438
00:23:09,840 --> 00:23:12,400
另一個程序或其他功能。

439
00:23:12,400 --> 00:23:15,207
這種行為很可能是連
不僅僅是崩潰不太理想。

440
00:23:15,207 --> 00:23:17,040
所以這就是為什麼它是
實際上是一個好習慣

441
00:23:17,040 --> 00:23:20,920
進入設置你的指針
為空，如果你不將它們

442
00:23:20,920 --> 00:23:24,540
一個有意義的值
馬上，你知道的值

443
00:23:24,540 --> 00:23:27,260
並且您可以安全地取消引用。

444
00:23:27,260 --> 00:23:32,240
>> 現在讓我們再來看一看
在整體局勢的語法。

445
00:23:32,240 --> 00:23:37,400
如果我說INT * P;，你有什麼我剛才做了什麼？

446
00:23:37,400 --> 00:23:38,530
我所做的就是這一點。

447
00:23:38,530 --> 00:23:43,290
我知道p的值是一個地址
因為所有指針都只是

448
00:23:43,290 --> 00:23:44,660
地址。

449
00:23:44,660 --> 00:23:47,750
我可以提領p
使用*運算符。

450
00:23:47,750 --> 00:23:51,250
在這方面這裡，在最
頂部召回*是類型的一部分​​。

451
00:23:51,250 --> 00:23:53,510
為int *是數據類型。

452
00:23:53,510 --> 00:23:56,150
但我可以提領
p使用*運營商，

453
00:23:56,150 --> 00:24:01,897
如果我這樣做，如果我去這個地址，
什麼都會，我覺得在這個地址？

454
00:24:01,897 --> 00:24:02,855
我會找到一個整數。

455
00:24:02,855 --> 00:24:05,910
因此，為int * p是基本
話說，p是一個地址。

456
00:24:05,910 --> 00:24:09,500
我可以取消引用p和當
我這樣做，我會找到一個整數

457
00:24:09,500 --> 00:24:11,920
在該存儲器位置。

458
00:24:11,920 --> 00:24:14,260
>> 行，所以我說還有一個
惱人的事情與明星

459
00:24:14,260 --> 00:24:17,060
而這裡的地方了
可氣的星星是。

460
00:24:17,060 --> 00:24:21,640
你有沒有試過聲明
相同類型的多個變量

461
00:24:21,640 --> 00:24:24,409
在相同的代碼行？

462
00:24:24,409 --> 00:24:27,700
因此，對於第二，假裝線，
我的代碼實際上有綠色

463
00:24:27,700 --> 00:24:29,366
是不存在的，它只是說：INT X，Y，Z ;.

464
00:24:29,366 --> 00:24:31,634

465
00:24:31,634 --> 00:24:34,550
什麼，會做實際創建是
為你三個整數變量，

466
00:24:34,550 --> 00:24:36,930
一個叫X，一個叫
y和一個叫ž。

467
00:24:36,930 --> 00:24:41,510
這是一個辦法做到這一點不
不必分割成三行。

468
00:24:41,510 --> 00:24:43,890
>> 這裡就是星星得
再煩人不過，

469
00:24:43,890 --> 00:24:49,200
因為*實際上是部分
兩者的類型名稱和部分

470
00:24:49,200 --> 00:24:50,320
變量名。

471
00:24:50,320 --> 00:24:56,430
所以，如果我說INT * PX，PY，PZ，我
實際上得到的是一個指向整數

472
00:24:56,430 --> 00:25:01,650
所謂PX和兩個整數，PY和PZ。

473
00:25:01,650 --> 00:25:04,950
而這可能不是什麼
我們希望，這並不好。

474
00:25:04,950 --> 00:25:09,290
>> 所以，如果我想創建多個指針
相同類型的在同一行上，

475
00:25:09,290 --> 00:25:12,140
和星星，我真的需要
做的是說INT * PA，* PB，* PC。

476
00:25:12,140 --> 00:25:17,330

477
00:25:17,330 --> 00:25:20,300
現在剛剛說，
現在告訴你這個，

478
00:25:20,300 --> 00:25:22,170
你可能永遠不會做到這一點。

479
00:25:22,170 --> 00:25:25,170
它可能是一個好東西說實話，
因為您可能會在不經意間

480
00:25:25,170 --> 00:25:26,544
省略明星，類似的東西。

481
00:25:26,544 --> 00:25:29,290
這可能是最好的，也許聲明
個別行的指針，

482
00:25:29,290 --> 00:25:31,373
但它只是一個又一個
那些煩人的語法

483
00:25:31,373 --> 00:25:35,310
星星東西，使
三分球這麼難的工作。

484
00:25:35,310 --> 00:25:39,480
因為它只是這個語法
惹你有工作，通過。

485
00:25:39,480 --> 00:25:41,600
通過練習它
真正成為第二天性。

486
00:25:41,600 --> 00:25:45,410
我仍然犯錯誤它仍然
編程後10年，

487
00:25:45,410 --> 00:25:49,630
所以不要生氣，如果有事
給你，這是很常見的誠實。

488
00:25:49,630 --> 00:25:52,850
這是一種真正的
語法的缺陷。

489
00:25:52,850 --> 00:25:54,900
>> 樣的行，所以我答應
我們會重新審視

490
00:25:54,900 --> 00:25:59,370
如何大的概念，是一個字符串。

491
00:25:59,370 --> 00:26:02,750
那麼，如果我告訴你，一個
字符串，我們真的有種

492
00:26:02,750 --> 00:26:04,140
在騙你的全部時間。

493
00:26:04,140 --> 00:26:06,181
有沒有所謂的數據類型
字符串，而事實上我

494
00:26:06,181 --> 00:26:09,730
在一提到這個我們
最早的視頻數據類型，

495
00:26:09,730 --> 00:26:13,820
該字符串是一個數據類型
在CS50.h.為您創建

496
00:26:13,820 --> 00:26:17,050
你必須＃包括
CS50.h以便使用它。

497
00:26:17,050 --> 00:26:19,250
>> 那麼字符串真的只是
別名的東西

498
00:26:19,250 --> 00:26:23,600
所謂的字符*，一
指針指向字符。

499
00:26:23,600 --> 00:26:26,010
好了三分球，召回，
只是解決了。

500
00:26:26,010 --> 00:26:28,780
那麼，什麼是大小
在一個字符串的字節？

501
00:26:28,780 --> 00:26:29,796
那麼它的四個或八個。

502
00:26:29,796 --> 00:26:32,170
而我之所以這麼說四
八成是因為實際上它

503
00:26:32,170 --> 00:26:36,730
取決於系統，如果你使用
CS50 IDE，字符*是一個字符的大小

504
00:26:36,730 --> 00:26:39,340
*是8，它是一個64位的系統。

505
00:26:39,340 --> 00:26:43,850
在內存中的每個地址是64位長。

506
00:26:43,850 --> 00:26:48,270
如果您使用的是CS50家電
或使用任何32位機，

507
00:26:48,270 --> 00:26:51,640
你聽說過這個詞32位
機，什麼是32位機？

508
00:26:51,640 --> 00:26:56,090
那麼它只是意味著每
在存儲器地址是32位長。

509
00:26:56,090 --> 00:26:59,140
因此32位是四個字節。

510
00:26:59,140 --> 00:27:02,710
所以，一個char *為四個或八個
根據你的系統字節。

511
00:27:02,710 --> 00:27:06,100
實際上，任何數據類型，
的指針和指向的任何數據

512
00:27:06,100 --> 00:27:12,030
類型，因為所有指針都只是
地址，是四個或八個字節。

513
00:27:12,030 --> 00:27:14,030
因此，讓我們重新審視這個
圖，讓我們得出結論：

514
00:27:14,030 --> 00:27:18,130
該視頻在這裡一點點的鍛煉。

515
00:27:18,130 --> 00:27:21,600
因此，這裡是我們離開了與圖
在視頻的開始。

516
00:27:21,600 --> 00:27:23,110
那麼現在會發生什麼，如果我說* PK = 35？

517
00:27:23,110 --> 00:27:26,370

518
00:27:26,370 --> 00:27:30,530
所以，這是什麼意思，當我說，* PK = 35？

519
00:27:30,530 --> 00:27:32,420
拿第二。

520
00:27:32,420 --> 00:27:34,990
*峰。

521
00:27:34,990 --> 00:27:39,890
在這裡背景下，*是
引用操作。

522
00:27:39,890 --> 00:27:42,110
因此，當提領
操作者的情況下，

523
00:27:42,110 --> 00:27:48,520
我們去的地址指向
通過PK，我們改變我們發現。

524
00:27:48,520 --> 00:27:55,270
因此，* PK = 35有效
這樣做是為了在照片。

525
00:27:55,270 --> 00:27:58,110
因此，它基本上是語法
相同的具有所述k = 35。

526
00:27:58,110 --> 00:28:00,740

527
00:28:00,740 --> 00:28:01,930
>> 一個。

528
00:28:01,930 --> 00:28:05,510
如果我說INT男，創建
一個稱為M的新變量。

529
00:28:05,510 --> 00:28:08,260
一個新的盒子，這是因為一個綠色的盒子
它會舉行一個整數，

530
00:28:08,260 --> 00:28:09,840
和它的標記微米。

531
00:28:09,840 --> 00:28:14,960
如果我說M = 4，我把
整裝進盒子。

532
00:28:14,960 --> 00:28:20,290
如果說PK =＆M，怎麼做
此圖的變化？

533
00:28:20,290 --> 00:28:28,760
PK =＆M，你還記得什麼
與操作者或者叫什麼名字？

534
00:28:28,760 --> 00:28:34,430
請記住，與一些變量名
是變量名的地址。

535
00:28:34,430 --> 00:28:38,740
所以，我們在說什麼是
PK得到m的地址。

536
00:28:38,740 --> 00:28:42,010
所以，有效地會發生什麼
圖是pk的不再指向

537
00:28:42,010 --> 00:28:46,420
以K，但點到m。

538
00:28:46,420 --> 00:28:48,470
>> 此外指針是非常
棘手一起工作

539
00:28:48,470 --> 00:28:50,620
他們採取了很多
實踐中，但因為

540
00:28:50,620 --> 00:28:54,150
他們的能力，讓您
傳遞函數之間的數據

541
00:28:54,150 --> 00:28:56,945
居然有那些
更改生效，

542
00:28:56,945 --> 00:28:58,820
圍繞讓你的頭
是非常重要的。

543
00:28:58,820 --> 00:29:02,590
這可能是最複雜
主題中，我們在CS50討論，

544
00:29:02,590 --> 00:29:05,910
但值你
使用指針獲得

545
00:29:05,910 --> 00:29:09,200
遠遠超過了並發症
這來自於學習他們。

546
00:29:09,200 --> 00:29:12,690
所以，我希望你最好的
運氣了解指針。

547
00:29:12,690 --> 00:29:15,760
我是道格·勞埃德，這是CS50。

548
00:29:15,760 --> 00:29:17,447