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