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
ДАГ 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
что мы называем PO коробку.

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
Таким образом, если массив состоит из п элементов,
первый элемент этого массива

48
00:02:28,730 --> 00:02:32,960
находится по индексу 0, и
последний элемент массива

49
00:02:32,960 --> 00:02:36,610
находится в индексом п минус 1.

50
00:02:36,610 --> 00:02:43,160
Опять же, если есть п элементов в наших
Массив, последний индекс п минус 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
С очень мягкими здесь.

55
00:02:56,170 --> 00:02:59,480
Это не помешает вам
выходя за пределы своего массива.

56
00:02:59,480 --> 00:03:03,080
Вы можете получить доступ к минус
3 элемент вашего массива

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
>> Так, например, INT оценки студентов 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 Booleans.

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
если (== 7 truthtable
истинно), который должен сказать,

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
Так, что я делаю здесь правовой С,
но не обязательно лучший ход.

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
Bool 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
Это создает массив
Размер три называется 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
Если вы поставили четыре, это было бы
дал вам таблицу истинности размера четыре;

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
Можно сказать, Bool
линкор квадратная скобка 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
думать о Tic-Tac-Toe
доска в линии девяти

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
значение Правда некоторым Booleans
или их тестирования в условных.

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
Это не юридическое С.

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
и мы только что описали
что это не законно С.

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
У нас есть цикл, который идет
от 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
Но С, к сожалению, мы
Не допускается, чтобы сделать это.

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 или 10000 элементов,

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
Мы объявляем целочисленную переменную
называется и назначить ей значение 10.

259
00:13:02,730 --> 00:13:07,080
Мы заявляем, массив из четырех чисел
В называется и назначить элементы 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
Я распечатки содержимого и
содержимое B квадратные скобки. 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