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

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
DOUG LLOYD：好吧。

4
00:00:06,020 --> 00:00:07,680
單工作
變量是蠻好玩的。

5
00:00:07,680 --> 00:00:09,500
但是，如果我們想要什麼工作
有很多變數，

6
00:00:09,500 --> 00:00:12,760
但我們不希望有一堆
不同的名字到處亂飛我們的代碼？

7
00:00:12,760 --> 00:00:15,980
在這種情況下，數組是
要來非常方便。

8
00:00:15,980 --> 00:00:19,510
數組是一個真正的基礎數據
結構任何編程語言

9
00:00:19,510 --> 00:00:20,260
你會使用。

10
00:00:20,260 --> 00:00:24,450
他們是真的，真的很有用，
特別是，正如我們所看到的，在CS 50。

11
00:00:24,450 --> 00:00:27,870
>> 我們使用數組來保存
同一數據類型的值

12
00:00:27,870 --> 00:00:29,830
在連續的存儲單元。

13
00:00:29,830 --> 00:00:32,430
這就是說，它是一個
這樣我們就可以組

14
00:00:32,430 --> 00:00:35,430
一堆整數在一起
內存或一串字符

15
00:00:35,430 --> 00:00:38,270
或者在內存中漂浮真的
併攏工作

16
00:00:38,270 --> 00:00:41,930
與他們，而不必給每個
它的一個自己獨特的名稱，它可以

17
00:00:41,930 --> 00:00:44,500
獲得過一小會兒繁瑣。

18
00:00:44,500 --> 00:00:48,130
>> 現在，一種方式來類推陣列
是考慮當地郵局

19
00:00:48,130 --> 00:00:49,000
辦公室一秒鐘。

20
00:00:49,000 --> 00:00:51,820
因此，從編程一步之遙
而只是閉上眼睛

21
00:00:51,820 --> 00:00:54,120
和可視化在你的心中
您當地的郵局。

22
00:00:54,120 --> 00:00:57,160
通常，在大多數崗位
辦公室，有一個大的銀行

23
00:00:57,160 --> 00:01:00,490
一個郵政信箱在牆上。

24
00:01:00,490 --> 00:01:03,510
>> 數組是一個巨大的塊
連續內存，

25
00:01:03,510 --> 00:01:06,120
相同的方式，一個郵件
在郵政銀行

26
00:01:06,120 --> 00:01:11,230
是在一個大的空間
牆上的郵局。

27
00:01:11,230 --> 00:01:15,750
陣列被劃分成小的，
相同的空間大小的塊，

28
00:01:15,750 --> 00:01:19,930
其中的每一個叫做一個元件，在
同樣的方式，該職位的牆

29
00:01:19,930 --> 00:01:23,840
辦公室已經被劃分成小的，
相同的空間大小的塊，

30
00:01:23,840 --> 00:01:27,560
我們稱之為一個郵政信箱。

31
00:01:27,560 --> 00:01:31,650
陣列的每個元素可以
存儲一定量的數據，

32
00:01:31,650 --> 00:01:37,540
就像每個郵政信箱能
持有一定量的郵件。

33
00:01:37,540 --> 00:01:41,540
>> 什麼可以存儲在的每個元素
該陣列是相同的數據的變量

34
00:01:41,540 --> 00:01:45,300
類型，如int或字符，只
就像在你的郵政信箱，

35
00:01:45,300 --> 00:01:47,300
你可以只適用的東西
相似類型的，

36
00:01:47,300 --> 00:01:50,430
如字母或小包裝。

37
00:01:50,430 --> 00:01:55,050
最後，我們可以訪問的每個元素
數組直接索引號，

38
00:01:55,050 --> 00:01:59,770
正如我們可以訪問我們的郵局
通過了解其郵箱號碼框中。

39
00:01:59,770 --> 00:02:02,750
我們希望，這個比喻
幫助你得到你的頭

40
00:02:02,750 --> 00:02:05,540
圍繞陣列的想法
類比到別的

41
00:02:05,540 --> 00:02:08,400
你可能
已經熟悉了。

42
00:02:08,400 --> 00:02:13,182
>> 在C語言中，數組的元素
索引從0開始，而不是從1。

43
00:02:13,182 --> 00:02:14,390
這是非常重要的。

44
00:02:14,390 --> 00:02:18,530
而事實上，這就是為什麼我們在CS 50，
為什麼計算機科學家頻繁

45
00:02:18,530 --> 00:02:22,150
會從0計數，是
因為C的數組

46
00:02:22,150 --> 00:02:24,660
索引，它總是從0開始。

47
00:02:24,660 --> 00:02:28,730
因此，如果一個數組由n個元素，
該數組的第一元素

48
00:02:28,730 --> 00:02:32,960
位於索引0，
所述陣列的最後一個元素

49
00:02:32,960 --> 00:02:36,610
位於索引n減去1。

50
00:02:36,610 --> 00:02:43,160
此外，如果有n個元素我們
陣，最後的指數為n減1。

51
00:02:43,160 --> 00:02:46,820
>> 所以，如果我們的陣列有50個元素，在
第一元件被設在索引0，

52
00:02:46,820 --> 00:02:51,060
和最後一個元素
位於指數49。

53
00:02:51,060 --> 00:02:53,940
遺憾的是，還是幸運的是，
這取決於你的觀點，

54
00:02:53,940 --> 00:02:56,170
C是非常寬鬆這裡。

55
00:02:56,170 --> 00:02:59,480
它不會阻止你
走出去陣列的界限。

56
00:02:59,480 --> 00:03:03,080
你可以訪問減
你的數組的三要素

57
00:03:03,080 --> 00:03:07,400
或者你的數組的第59件，
如果你的數組只有50個元素。

58
00:03:07,400 --> 00:03:11,060
它不會停止你的程序
編譯，但在運行時，

59
00:03:11,060 --> 00:03:14,350
你可能會遇到一個
可怕的分段錯誤

60
00:03:14,350 --> 00:03:17,460
如果你開始訪問內存
這是一個什麼樣的邊界之外

61
00:03:17,460 --> 00:03:19,260
你問你的程序給你。

62
00:03:19,260 --> 00:03:21,250
所以千萬要小心。

63
00:03:21,250 --> 00:03:23,120
>> 什麼數組
聲明是什麼樣子？

64
00:03:23,120 --> 00:03:26,940
我們如何編寫一個數組存在
就像我們代碼的任何其他變量？

65
00:03:26,940 --> 00:03:31,250
有三個部分到一個數組
declaration--一個類型，名稱，

66
00:03:31,250 --> 00:03:31,880
和一個大小。

67
00:03:31,880 --> 00:03:34,088
這是非常相似的一個
變量聲明，這

68
00:03:34,088 --> 00:03:36,970
僅僅是一個類型和名稱，
大小元素是

69
00:03:36,970 --> 00:03:39,860
的特殊情況為陣列，
因為我們已經看到了一群人

70
00:03:39,860 --> 00:03:41,830
在同一時間。

71
00:03:41,830 --> 00:03:45,560
>> 因此，類型是什麼樣的變化，你
希望成為該陣列的每個元素。

72
00:03:45,560 --> 00:03:47,150
不要希望它整數數組？

73
00:03:47,150 --> 00:03:49,010
然後，你的數據類型應該是int。

74
00:03:49,010 --> 00:03:51,760
你希望它是一個
雙打或浮筒的陣列？

75
00:03:51,760 --> 00:03:54,545
數據類型應該是雙重或浮動。

76
00:03:54,545 --> 00:03:56,420
這個名字就是你
想打電話給你的陣列。

77
00:03:56,420 --> 00:04:00,970
你想命名這個巨人
整數或浮點數或字符銀行

78
00:04:00,970 --> 00:04:03,250
還是雙打，或任何有你嗎？

79
00:04:03,250 --> 00:04:04,700
那你怎麼稱呼它？

80
00:04:04,700 --> 00:04:06,110
漂亮的自我解釋。

81
00:04:06,110 --> 00:04:08,610
>> 最後，大小，它進入
方括號內，

82
00:04:08,610 --> 00:04:12,180
多少個元素是你會
喜歡你的陣列遏制。

83
00:04:12,180 --> 00:04:13,530
多少個整數，你要不要？

84
00:04:13,530 --> 00:04:15,570
多少花車你想要什麼？

85
00:04:15,570 --> 00:04:19,070
>> 因此，例如，詮釋學生成績40。

86
00:04:19,070 --> 00:04:26,020
該聲明呼籲學生數組
等級，其中包括40的整數。

87
00:04:26,020 --> 00:04:28,180
漂亮的自我解釋，我希望。

88
00:04:28,180 --> 00:04:29,330
這裡是另外一個例子。

89
00:04:29,330 --> 00:04:31,560
雙菜單上的價格8。

90
00:04:31,560 --> 00:04:34,610
這將創建稱為陣列
菜單上的價格，其中包括

91
00:04:34,610 --> 00:04:38,300
房間在內存中為八對雙打。

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> 如果你覺得每一個元素
類型的數據類型的陣列，

94
00:04:45,750 --> 00:04:49,860
因此，例如，一個單一的元素
int類型的數組，相同的方式，

95
00:04:49,860 --> 00:04:52,770
會想到其他
int類型的變量，

96
00:04:52,770 --> 00:04:56,440
所有熟悉的操作，我們
在操作前面討論

97
00:04:56,440 --> 00:04:58,270
視頻將是有意義的。

98
00:04:58,270 --> 00:05:01,620
所以在這裡，我們可以聲明數組
布爾叫Truthtable的，

99
00:05:01,620 --> 00:05:05,590
其中包括空間10布爾值。

100
00:05:05,590 --> 00:05:09,650
>> 然後，就像我們可以只分配
一個值類型的任何其它可變

101
00:05:09,650 --> 00:05:13,470
布爾，我們可以說些什麼
像Truthtable括號

102
00:05:13,470 --> 00:05:18,040
2，這是我們如何表示，
該真值表的元素？

103
00:05:18,040 --> 00:05:20,350
的第三個要素
真值表，因為記得，

104
00:05:20,350 --> 00:05:21,800
我們計數為0。

105
00:05:21,800 --> 00:05:25,690
所以，這就是我們如何指示
真值表的第三個要素。

106
00:05:25,690 --> 00:05:28,680
Truthtable 2等於假，
就像我們可以declare--

107
00:05:28,680 --> 00:05:33,560
或者我們可以指定，相反，任何
布爾類型變量是假的。

108
00:05:33,560 --> 00:05:35,050
>> 我們也可以用它的條件。

109
00:05:35,050 --> 00:05:39,000
如果（truthtable 7 ==
真），這是說，

110
00:05:39,000 --> 00:05:42,370
如果第八元素
Truthtable是真實的，

111
00:05:42,370 --> 00:05:46,760
也許我們要打印一個信息
給用戶，輸出（“真！N”）;

112
00:05:46,760 --> 00:05:50,290
這使我們說Truthtable
10等於真的吧？

113
00:05:50,290 --> 00:05:53,590
好吧，我可以，但它是相當
危險的，因為記得，

114
00:05:53,590 --> 00:05:56,260
我們有10布爾數組。

115
00:05:56,260 --> 00:06:02,340
所以指數最高的
編譯器已經給我們的是9。

116
00:06:02,340 --> 00:06:06,010
>> 這一計劃將編譯，但
如果其他內存

117
00:06:06,010 --> 00:06:09,110
存在在那裡我們將
預計Truthtable 10去，

118
00:06:09,110 --> 00:06:13,980
我們可能遭受分割故障。我們
可能逃脫它，但在一般情況下，

119
00:06:13,980 --> 00:06:14,710
相當危險。

120
00:06:14,710 --> 00:06:19,759
所以，我在這裡做是合法的C，
但不一定是最好的舉措。

121
00:06:19,759 --> 00:06:22,300
現在，當你聲明和
同時初始化一個數組，

122
00:06:22,300 --> 00:06:23,960
實際上有一個漂亮
特殊的語法，您

123
00:06:23,960 --> 00:06:26,250
可以用它來填滿陣列
它的開始值。

124
00:06:26,250 --> 00:06:30,130
它可以變得很麻煩
申報大小100的陣列，

125
00:06:30,130 --> 00:06:33,430
然後不得不說，元素0
等於這一點;元1等於這一點;

126
00:06:33,430 --> 00:06:34,850
單元2等於這一點。

127
00:06:34,850 --> 00:06:36,370
這有什麼意義，不是嗎？

128
00:06:36,370 --> 00:06:39,470
>> 如果它是一個小陣，你
可以做這樣的事情。

129
00:06:39,470 --> 00:06:44,360
布爾truthtable 3等於開
大括號，然後逗號

130
00:06:44,360 --> 00:06:48,060
分離元素列表
你想要把數組中開始。

131
00:06:48,060 --> 00:06:50,520
然後關閉大括號分號。

132
00:06:50,520 --> 00:06:53,910
這產生的陣列
大小的3名為Truthtable，

133
00:06:53,910 --> 00:06:56,090
與元素假的，真實的，真實的。

134
00:06:56,090 --> 00:06:59,270
而事實上，所述實例化
語法我這裡是

135
00:06:59,270 --> 00:07:03,350
完全一樣做
下面的各個元素語法。

136
00:07:03,350 --> 00:07:09,380
編碼的這兩種方式將
產生完全相同的陣列。

137
00:07:09,380 --> 00:07:11,740
>> 同樣的，我們可以遍歷
以上所有的元素

138
00:07:11,740 --> 00:07:15,400
使用循環的陣列，其中，在
事實上，是一個非常強烈推薦

139
00:07:15,400 --> 00:07:16,790
在家裡鍛煉。

140
00:07:16,790 --> 00:07:20,720
你如何創建一個數組
的100個整數，其中

141
00:07:20,720 --> 00:07:23,477
數組中的每一個元素是其指數？

142
00:07:23,477 --> 00:07:26,560
因此，例如，我們有100陣列
整數，並且在第一元件，

143
00:07:26,560 --> 00:07:27,790
我們希望把0。

144
00:07:27,790 --> 00:07:29,810
在第二個元素，我們希望把1。

145
00:07:29,810 --> 00:07:33,319
在第三個元素，我們希望
把2;等等等等。

146
00:07:33,319 --> 00:07:35,360
這是一個非常好的
在家裡練習做。

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> 在這裡，它不看
喜歡太多改變。

149
00:07:40,220 --> 00:07:44,170
但是請注意，在之間
方括號中，這一次，

150
00:07:44,170 --> 00:07:45,830
其實我已經省略了一些。

151
00:07:45,830 --> 00:07:48,000
如果你使用這個非常
特殊實例

152
00:07:48,000 --> 00:07:50,380
語法創建
數組，你居然不

153
00:07:50,380 --> 00:07:53,491
需要指出的大小
陣列的預先。

154
00:07:53,491 --> 00:07:55,740
編譯器是足夠聰明
要知道，你其實

155
00:07:55,740 --> 00:07:58,980
希望大小3的陣列，
因為你把三個要素

156
00:07:58,980 --> 00:08:00,640
等號的右邊。

157
00:08:00,640 --> 00:08:04,140
如果你已經把四，那就得
給你的尺碼4的真值表;

158
00:08:04,140 --> 00:08:06,270
等等等等。

159
00:08:06,270 --> 00:08:09,380
>> 數組不局限於單一
維度，這是很酷。

160
00:08:09,380 --> 00:08:12,000
實際上，你可以有很多
側面說明符如你所願。

161
00:08:12,000 --> 00:08:16,470
因此，舉例來說，如果你想創建
董事會為遊戲戰艦，其中，

162
00:08:16,470 --> 00:08:20,910
如果你玩過，是一種遊戲，是
10格玩弄於10釘，

163
00:08:20,910 --> 00:08:22,450
你可以創建一個這樣的數組。

164
00:08:22,450 --> 00:08:26,030
你可以說布爾
戰艦括號10

165
00:08:26,030 --> 00:08:29,590
封閉括號廣場
支架10關閉方括號。

166
00:08:29,590 --> 00:08:32,710
>> 然後，你可以選擇
在你的心中解釋為一個10

167
00:08:32,710 --> 00:08:35,576
10網格單元。

168
00:08:35,576 --> 00:08:37,409
現在，實際上，在存儲器中
它確實只是

169
00:08:37,409 --> 00:08:42,440
仍然是100元，
一維陣列。

170
00:08:42,440 --> 00:08:46,070
而這，其實也適用於你
有三個維度，四個或五個。

171
00:08:46,070 --> 00:08:49,420
這真的只是不乘
所有的indices--的

172
00:08:49,420 --> 00:08:51,130
或所有的大小
specifiers--在一起，

173
00:08:51,130 --> 00:08:53,480
而你只得到一個一維
數組的大小。

174
00:08:53,480 --> 00:08:57,090
>> 但在組織方面和
可視化和人類感知，

175
00:08:57,090 --> 00:08:59,240
它可以是一個容易得多
用電網工作

176
00:08:59,240 --> 00:09:02,980
如果你工作在一個遊戲
像井字棋或戰艦，

177
00:09:02,980 --> 00:09:05,179
或者類似的東西。

178
00:09:05,179 --> 00:09:06,970
這是一個偉大的抽象，
代替具有

179
00:09:06,970 --> 00:09:09,340
想想一個井字棋
板作為線九

180
00:09:09,340 --> 00:09:13,810
廣場或戰艦板
作為一行的100個正方形。

181
00:09:13,810 --> 00:09:16,010
10×10格或三
通過三格可能

182
00:09:16,010 --> 00:09:17,225
很多更容易察覺。

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> 現在，一些真正
重要的有關數組。

185
00:09:22,280 --> 00:09:25,950
我們可以把每一個人
數組作為可變的元件。

186
00:09:25,950 --> 00:09:27,700
我們看到，前面
當我們分配

187
00:09:27,700 --> 00:09:32,240
真值一定布爾
或者測試他們的條件句。

188
00:09:32,240 --> 00:09:35,960
但是，我們不能把整個
數組本身作為變量。

189
00:09:35,960 --> 00:09:41,760
我們不能，例如，分配一個陣列
使用分配另一個數組

190
00:09:41,760 --> 00:09:42,930
運營商。

191
00:09:42,930 --> 00:09:44,640
這是不合法的C.

192
00:09:44,640 --> 00:09:47,920
>> 如果我們想，對於example--什麼
我們會做的那個例子

193
00:09:47,920 --> 00:09:50,200
將複製一個陣列到另一個。

194
00:09:50,200 --> 00:09:53,810
如果我們要做到這一點，我們實際上
需要使用一個循環來拷貝過來

195
00:09:53,810 --> 00:09:56,550
每個單獨的元件一次一個。

196
00:09:56,550 --> 00:09:58,700
我知道這是一個有點費時。

197
00:09:58,700 --> 00:10:04,022
>> 因此，例如，如果我們有這些夫婦
行的代碼，將這項工作？

198
00:10:04,022 --> 00:10:05,230
哦，不，它不會，對不對？

199
00:10:05,230 --> 00:10:07,860
因為我們正在努力
糧食分配給吧。

200
00:10:07,860 --> 00:10:09,860
這是行不通的，
因為它是一個數組，

201
00:10:09,860 --> 00:10:13,130
而我們剛才所描述
這，這不是法律C.

202
00:10:13,130 --> 00:10:15,580
>> 相反，如果我們希望
複製食物的內容

203
00:10:15,580 --> 00:10:18,070
進入酒吧，這是什麼
我們想在這裡做，

204
00:10:18,070 --> 00:10:19,970
我們需要這樣的語法。

205
00:10:19,970 --> 00:10:24,170
我們有一個for循環去
從J是等於0到5，

206
00:10:24,170 --> 00:10:28,390
我們增加J於每一個迭代
循環，這樣分配的元素。

207
00:10:28,390 --> 00:10:33,360
這將導致酒吧還
是一，二，三，四，五，

208
00:10:33,360 --> 00:10:36,730
但我們必須這樣做，這很
慢元素乘元素的方式，

209
00:10:36,730 --> 00:10:40,009
而不是由跟
複製整個陣列。

210
00:10:40,009 --> 00:10:42,050
在其他編程
語言，更現代的，

211
00:10:42,050 --> 00:10:45,610
你可以，事實上，做到這
這麼簡單等於語法。

212
00:10:45,610 --> 00:10:49,620
但是，C，不幸的是，我們
不允許這樣做。

213
00:10:49,620 --> 00:10:52,026
>> 現在，有一個其他
的事情，我要提

214
00:10:52,026 --> 00:10:54,650
有關陣列可以是一個小
有些棘手的第一次

215
00:10:54,650 --> 00:10:55,990
與他們合作。

216
00:10:55,990 --> 00:10:59,860
我們在視頻中討論
有關變量的作用域，

217
00:10:59,860 --> 00:11:04,940
大多數變量在C中，當你調用
它們的功能，是按值傳遞。

218
00:11:04,940 --> 00:11:08,620
你還記得這是什麼意思
通過一些由價值？

219
00:11:08,620 --> 00:11:12,570
這意味著我們正在做的一個副本
這正在被傳遞的變量。

220
00:11:12,570 --> 00:11:16,290
被調用函數，該函數
該真實接收變量，

221
00:11:16,290 --> 00:11:17,730
沒有得到變量本身。

222
00:11:17,730 --> 00:11:20,850
它得到了自己的地方
它的副本一起工作。

223
00:11:20,850 --> 00:11:24,070
>> 當然，數組，做
不遵循這個規則。

224
00:11:24,070 --> 00:11:27,600
相反，我們所說的這個
是通過引用傳遞。

225
00:11:27,600 --> 00:11:31,360
實際上被調用者
確實接收陣列。

226
00:11:31,360 --> 00:11:34,207
它不接收其
它自己的本地副本。

227
00:11:34,207 --> 00:11:36,040
如果你想
它，這是有道理的。

228
00:11:36,040 --> 00:11:39,750
如果數組是真的很大，
需要這麼多的時間和精力

229
00:11:39,750 --> 00:11:44,470
使陣列的一個拷貝
100或1000或10,000元，

230
00:11:44,470 --> 00:11:48,290
這是不值得的
函數接收的一個副本，

231
00:11:48,290 --> 00:11:51,037
做一些工作吧，然後
只是在複印完成;

232
00:11:51,037 --> 00:11:53,120
它並不需要有
它遊逛了。

233
00:11:53,120 --> 00:11:54,710
>> 因為數組是一些
笨重，麻煩且

234
00:11:54,710 --> 00:11:56,001
我們只是通過引用傳遞。

235
00:11:56,001 --> 00:12:01,210
我們只相信功能
要，不要破壞任何東西。

236
00:12:01,210 --> 00:12:03,010
因此，它實際獲得的數組。

237
00:12:03,010 --> 00:12:05,290
它沒有得到它自己的本地副本。

238
00:12:05,290 --> 00:12:07,170
>> 所以，這是什麼意思，
然後，在被叫時

239
00:12:07,170 --> 00:12:08,970
操縱數組中的元素？

240
00:12:08,970 --> 00:12:10,780
會發生什麼？

241
00:12:10,780 --> 00:12:13,210
現在，我們將光澤
在到底為什麼這

242
00:12:13,210 --> 00:12:15,320
發生，為什麼數組
按引用傳遞

243
00:12:15,320 --> 00:12:17,810
和其他一切是按值傳遞。

244
00:12:17,810 --> 00:12:20,470
但我向你保證，我們將
返回並給你答案

245
00:12:20,470 --> 00:12:23,750
此在後面的視頻。

246
00:12:23,750 --> 00:12:28,110
>> 這裡有一個多運動對你
之前，我們總結了東西陣列。

247
00:12:28,110 --> 00:12:31,400
這裡的代碼串，這是
不是特別的好作風，

248
00:12:31,400 --> 00:12:33,400
只是我會作出這樣的警告。

249
00:12:33,400 --> 00:12:36,660
有沒有意見在這裡，
這是非常不好的形式。

250
00:12:36,660 --> 00:12:39,750
但是，這只是因為我想成為
能夠在屏幕上容納一切。

251
00:12:39,750 --> 00:12:44,360
>> 在頂部，你可以看到，我有
二元函數聲明為一組陣列

252
00:12:44,360 --> 00:12:45,820
並設置INT。

253
00:12:45,820 --> 00:12:49,680
設置陣列顯然需要一個數組
四個整數作為它的輸入。

254
00:12:49,680 --> 00:12:52,767
並設置INT顯然需要
一個整數作為其輸入。

255
00:12:52,767 --> 00:12:54,350
但他們都沒有輸出。

256
00:12:54,350 --> 00:12:57,689
輸出，返回
類型，每一個都是無效的。

257
00:12:57,689 --> 00:12:59,480
在主，我們有一個
幾行代碼。

258
00:12:59,480 --> 00:13:02,730
我們聲明一個整數變量
稱為A和分配值10。

259
00:13:02,730 --> 00:13:07,080
我們申報的四個整數數組
稱為B並分配元件0,1

260
00:13:07,080 --> 00:13:08,730
2，和3中。

261
00:13:08,730 --> 00:13:12,190
然後，我們有一個調用設置
int和調用設置陣列。

262
00:13:12,190 --> 00:13:15,910
集陣列和組的定義
INT是向下跌破，在底部。

263
00:13:15,910 --> 00:13:17,640
>> 所以，再一次，我問你的問題。

264
00:13:17,640 --> 00:13:20,770
什麼被打印出來
在這裡主要的結束？

265
00:13:20,770 --> 00:13:23,020
有一個打印山坳。我
打印出兩個整數。

266
00:13:23,020 --> 00:13:28,010
我打印出A的內容和
的乙括號0的內容。

267
00:13:28,010 --> 00:13:29,880
在這裡暫停視頻，並採取一分鐘。

268
00:13:29,880 --> 00:13:35,482
你能弄清楚這是什麼
功能將在最後打印？

269
00:13:35,482 --> 00:13:38,190
我們希望，如果你還記得
路過的價值之間的區別

270
00:13:38,190 --> 00:13:41,680
並引用傳遞，這
問題是不是太棘手的適合你。

271
00:13:41,680 --> 00:13:44,130
而答案，你會
發現是這樣的。

272
00:13:44,130 --> 00:13:47,660
如果你真的不知道，以
為什麼是這樣的話，拿第二，

273
00:13:47,660 --> 00:13:50,620
回去後，我回顧了一下剛才
討論有關傳遞數組

274
00:13:50,620 --> 00:13:53,450
作為參考，與傳遞
其他變量按值，

275
00:13:53,450 --> 00:13:56,680
並希望，它會讓
多一點點感覺。

276
00:13:56,680 --> 00:13:59,760
>> 我是道格·勞埃德，這是CS50。

277
00:13:59,760 --> 00:14:01,467