1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Да поговорим за масиви.

2
00:00:09,360 --> 00:00:12,780
Така че, защо бихме някога искате да използвате масиви?

3
00:00:12,780 --> 00:00:17,210
Добре, нека кажем, че имате програма, която трябва да се съхранява пет студентски документи за самоличност.

4
00:00:17,210 --> 00:00:21,270
Тя може да изглежда разумно да има пет отделни променливи.

5
00:00:21,270 --> 00:00:24,240
По причини, които ще видим в малко, ние ще започнем да броим от 0.

6
00:00:24,240 --> 00:00:30,700
Променливи, ще имаме, ще бъде INT id0, вътр ID1 и така нататък.

7
00:00:30,700 --> 00:00:34,870
Каквато и да е логика, ние искаме да се изпълнява на един студент ID, ще трябва да се копира и

8
00:00:34,870 --> 00:00:36,870
за всяка една от тези студентски документи за самоличност.

9
00:00:36,870 --> 00:00:39,710
Ако искаме да се провери кои студенти се случи да бъде в CS50,

10
00:00:39,710 --> 00:00:43,910
ние ще трябва първо да се провери дали id0 представлява студент в курса.

11
00:00:43,910 --> 00:00:48,070
След това, за да направим същото и за следващата студент, ние ще трябва да копирате и поставите кода за id0

12
00:00:48,070 --> 00:00:54,430
и замени всички срещания на id0 с ID1 и така нататък за ID2, 3 и 4.

13
00:00:54,430 --> 00:00:57,560
>> Веднага след като чуят, че ние трябва да копирате и поставите,

14
00:00:57,560 --> 00:01:00,440
трябва да започнем да мислим, че има по-добро решение.

15
00:01:00,440 --> 00:01:05,360
Сега какво, ако ти осъзнаваш, не е нужно 5 студентски документи за самоличност, а по-скоро 7?

16
00:01:05,360 --> 00:01:09,570
Вие трябва да се върнете в изходния си код и добавете в ID5, id6

17
00:01:09,570 --> 00:01:14,260
и да копирате и поставите логика за проверка, ако идентификатори принадлежат към класа за тези две нови документи за самоличност.

18
00:01:14,260 --> 00:01:19,600
Няма нищо свързване на всички тези документи за самоличност, така че няма начин да поискат от

19
00:01:19,600 --> 00:01:22,040
програмата да направи това за документи за самоличност 0 до 6.

20
00:01:22,040 --> 00:01:26,120
Е, сега, че сте 100 студентски документи за самоличност.

21
00:01:26,120 --> 00:01:30,770
Започва да изглежда по-малко от идеални, за да е необходимо да декларират всяка отделно от тези документи за самоличност,

22
00:01:30,770 --> 00:01:33,760
и да копирате и поставите каквато и да е логика за тези нови документи за самоличност.

23
00:01:33,760 --> 00:01:38,380
Но може би ние се определят и ние го правим за всички 100 ученици.

24
00:01:38,380 --> 00:01:42,240
Но какво, ако не знаете колко студенти са в действителност?

25
00:01:42,240 --> 00:01:47,320
Има само някои н студенти и вашата програма трябва да поиска ползвателят какво н е.

26
00:01:47,320 --> 00:01:50,250
Ъ-ъ о. Това няма да работят много добре.

27
00:01:50,250 --> 00:01:53,820
Програмата работи само за някои постоянен брой на студентите.

28
00:01:53,820 --> 00:01:57,520
>> Решаването на всички тези проблеми е красотата на масиви.

29
00:01:57,520 --> 00:01:59,930
И така, какво е масив?

30
00:01:59,930 --> 00:02:04,480
В някои езици за програмиране тип масив може да бъде в състояние да направи малко повече,

31
00:02:04,480 --> 00:02:09,960
но тук ние ще се съсредоточим върху основния масив структурата на данните, точно както ще го видите в C.

32
00:02:09,960 --> 00:02:14,030
Масивът е просто един голям блок от паметта. Това е всичко.

33
00:02:14,030 --> 00:02:17,770
Когато казваме, че имаме масив от 10 числа, това просто означава, че ние имаме някои блок

34
00:02:17,770 --> 00:02:20,740
на паметта, която е достатъчно голяма да побере 10 отделни числа.

35
00:02:29,930 --> 00:02:33,410
Ако приемем, че е цяло число е 4 байта, това означава, че масив от 10 числа

36
00:02:33,410 --> 00:02:37,180
е непрекъснат блок от 40 байта в паметта.

37
00:02:42,660 --> 00:02:46,280
Дори когато използвате многомерни масиви, които ние няма да вляза тук,

38
00:02:46,280 --> 00:02:49,200
тя все още е просто един голям блок от паметта.

39
00:02:49,200 --> 00:02:51,840
Разностранният нотация е само за удобство.

40
00:02:51,840 --> 00:02:55,640
Ако имате 3 от 3 многомерен масив от цели числа,

41
00:02:55,640 --> 00:03:00,650
тогава вашата програма ще наистина само лечение на това като голям блок от 36 байта.

42
00:03:00,650 --> 00:03:05,460
Общият брой на числа е 3 пъти по 3, и всяко число заема 4 байта.

43
00:03:05,460 --> 00:03:07,750
>> Нека да разгледаме основен пример.

44
00:03:07,750 --> 00:03:10,660
Ние можем да видим тук два различни начина за обявяване на масиви.

45
00:03:15,660 --> 00:03:18,580
Ще трябва да се коментира 1 от тях за програмата за съставяне на

46
00:03:18,580 --> 00:03:20,900
тъй като ние заявяваме два пъти.

47
00:03:20,900 --> 00:03:25,140
Ние ще разгледаме някои от разликите между тези два вида декларации в малко.

48
00:03:25,140 --> 00:03:28,560
И на тези редове декларира масив с размер N,

49
00:03:28,560 --> 00:03:30,740
където сме # определят N 10.

50
00:03:30,740 --> 00:03:34,460
Ние можем просто толкова лесно да попита потребителя за положително число

51
00:03:34,460 --> 00:03:37,250
и се използва това число като броя на елементите в нашата масив.

52
00:03:37,250 --> 00:03:41,960
Както нашия пример студентска карта преди, това е нещо като обявяване на 10 напълно отделен

53
00:03:41,960 --> 00:03:49,000
въображаеми променливи; x0, x1, x2, и така нататък до едно XN.

54
00:03:57,270 --> 00:04:00,840
Пренебрегването на линии, където ние заявяваме масива, забележете квадратни скоби непокътнати

55
00:04:00,840 --> 00:04:02,090
вътре за вериги.

56
00:04:02,090 --> 00:04:09,660
Когато пиша нещо подобно X [3], което аз просто ще чете като х скоба 3,

57
00:04:09,660 --> 00:04:13,090
можете да мислите за него, все едно да питаш за въображаема x3.

58
00:04:13,090 --> 00:04:17,519
Известие от масив с размер N, това означава, че вътре в скобите,

59
00:04:17,519 --> 00:04:22,630
които ние ще се обадя на индекса, може да бъде нещо от 0 до N-1,

60
00:04:22,630 --> 00:04:25,660
което е общо N на индексите.

61
00:04:25,660 --> 00:04:28,260
>> Да се ​​мисли за това как всъщност работи

62
00:04:28,260 --> 00:04:31,260
не забравяйте, че масивът е голям блок от паметта.

63
00:04:31,260 --> 00:04:37,460
Ако приемем, че е цяло число е 4 байта, цялата х масив е 40 байт блок на паметта.

64
00:04:37,460 --> 00:04:41,360
Така че x0 се отнася до първите 4 байта на блока.

65
00:04:45,810 --> 00:04:49,230
X [1] се отнася до следващите 4 байта и така нататък.

66
00:04:49,230 --> 00:04:53,760
Това означава, че началото на X е програмата някога трябва да следите.

67
00:04:55,660 --> 00:04:59,840
Ако искате да използвате [400], след което програмата се знае, че това е еквивалентно

68
00:04:59,840 --> 00:05:03,460
до 1600 байта след началото на х.

69
00:05:03,460 --> 00:05:08,780
Откъде получавате 1600 байта от? Това е само 400 пъти по 4 байта на цяло число.

70
00:05:08,780 --> 00:05:13,170
>> Преди да преминем, това е много важно да се осъзнае, че в C

71
00:05:13,170 --> 00:05:17,080
не е изпълнението на индекса, който ние използваме в масива.

72
00:05:17,080 --> 00:05:23,180
Нашият голям блок е само на 10 числа, но нищо няма да крещи по нас, ако напишете [20]

73
00:05:23,180 --> 00:05:26,060
или дори [-5].

74
00:05:26,060 --> 00:05:28,240
Индексът дори не трябва да бъде число.

75
00:05:28,240 --> 00:05:30,630
Тя може да бъде произволна израз.

76
00:05:30,630 --> 00:05:34,800
В програмата ние използваме променлива I от цикъл да се индекс в масива.

77
00:05:34,800 --> 00:05:40,340
Това е много често срещан модел, примка от I = 0 до дължината на масива,

78
00:05:40,340 --> 00:05:43,350
и след това да използвате, след като индексът за масив.

79
00:05:43,350 --> 00:05:46,160
По този начин ефективно линия за цялата решетка,

80
00:05:46,160 --> 00:05:50,600
и вие може да възложи на всяко място в масива или да го използвате за някои изчисления.

81
00:05:50,600 --> 00:05:53,920
>> В първата за контур, аз започва от 0,

82
00:05:53,920 --> 00:05:58,680
и така той ще възложи на място 0 в масива, стойността 0 пъти 2.

83
00:05:58,680 --> 00:06:04,370
Тогава аз стъпки, и ние определяме първо място в масива на стойност 1 пъти 2.

84
00:06:04,370 --> 00:06:10,170
Тогава стъпки отново и така нататък, докато ние определяме позиция N-1 в масива

85
00:06:10,170 --> 00:06:13,370
стойността на N-1 пъти 2.

86
00:06:13,370 --> 00:06:17,810
Така че, ние създадохме масив с първите 10 четни числа.

87
00:06:17,810 --> 00:06:21,970
Може би изравнява щеше да е малко по-добро име за променливата от х

88
00:06:21,970 --> 00:06:24,760
но това би дало нещата далеч.

89
00:06:24,760 --> 00:06:30,210
Секунда за контур и след това се извеждат стойностите, че вече сме се съхраняват във вътрешността на масива.

90
00:06:30,210 --> 00:06:33,600
>> Нека се опитаме да стартирате програмата с двата вида на масива декларации

91
00:06:33,600 --> 00:06:36,330
и да погледнем на изхода на програмата.

92
00:06:51,450 --> 00:06:57,020
Що се отнася, както можем да видим, програмата се държи по същия начин и за двата вида декларации.

93
00:06:57,020 --> 00:07:02,230
Нека също така да погледнете какво се случва, ако променим първа линия, за да не спре на N

94
00:07:02,230 --> 00:07:05,040
, а по-скоро се каже, 10000.

95
00:07:05,040 --> 00:07:07,430
Път след края на масива.

96
00:07:14,700 --> 00:07:17,210
Опа. Може би сте виждали преди.

97
00:07:17,210 --> 00:07:20,440
Сегментация вина означава, че програмата ви е разбил.

98
00:07:20,440 --> 00:07:24,430
Можете да започнете да виждате, когато ви докосва области на паметта не трябва да се докосват.

99
00:07:24,430 --> 00:07:27,870
Тук ние се докосват 10 000 места отвъд началото на X,

100
00:07:27,870 --> 00:07:31,920
което очевидно е място в паметта, не трябва да се докосват.

101
00:07:31,920 --> 00:07:37,690
Така че повечето от нас вероятно не би случайно постави 10000 вместо N

102
00:07:37,690 --> 00:07:42,930
но какво, ако ние не направим нещо по-фино като казват, пишат по-малка или равна на N

103
00:07:42,930 --> 00:07:46,830
в контур състояние, за разлика от по-малко от N.

104
00:07:46,830 --> 00:07:50,100
Не забравяйте, че масив има само индекси от 0 до N-1,

105
00:07:50,100 --> 00:07:54,510
което означава, че индекс N е след края на масива.

106
00:07:54,510 --> 00:07:58,050
Програмата не може да се срине в този случай, но тя все още е грешка.

107
00:07:58,050 --> 00:08:01,950
В действителност, тази грешка е толкова общ, че тя разполага със собствено име,

108
00:08:01,950 --> 00:08:03,970
на разстояние от една грешка.

109
00:08:03,970 --> 00:08:05,970
>> Това е за основите.

110
00:08:05,970 --> 00:08:09,960
Така че какви са основните разлики между два типа на масива декларации?

111
00:08:09,960 --> 00:08:13,960
Една от разликите е мястото, където големия блок на паметта отива.

112
00:08:13,960 --> 00:08:17,660
В първата декларация, която ще се обадя на конзолата масив тип,

113
00:08:17,660 --> 00:08:20,300
макар че това в никакъв случай не означава условно название,

114
00:08:20,300 --> 00:08:22,480
тя ще отиде на стека.

115
00:08:22,480 --> 00:08:27,450
Като има предвид, че втората, която ще се обадя показалеца Типът масив, тя ще отиде на куп.

116
00:08:27,450 --> 00:08:32,480
Това означава,, че когато функцията връща, на конзолата масив ще бъде автоматично deallocated,

117
00:08:32,480 --> 00:08:36,419
като има предвид, че трябва да explicitily обаждате безплатно на показалеца масив

118
00:08:36,419 --> 00:08:38,010
или пък имате изтичане на памет.

119
00:08:38,010 --> 00:08:42,750
Освен това, на конзолата масив всъщност не е променлива.

120
00:08:42,750 --> 00:08:45,490
Това е важно. Това е просто символ.

121
00:08:45,490 --> 00:08:49,160
Можете да мислите за него като за постоянно, че компилаторът избира за вас.

122
00:08:49,160 --> 00:08:52,970
Това означава, че не можем да направим нещо като х + + със скоба тип,

123
00:08:52,970 --> 00:08:56,240
въпреки че това е напълно валидно с показалеца тип.

124
00:08:56,240 --> 00:08:58,270
>> Показалеца тип е променлива величина.

125
00:08:58,270 --> 00:09:01,510
За показалеца тип, имаме две отделни блокове памет.

126
00:09:01,510 --> 00:09:06,060
Променливата х се съхраняват в стека и е само един указател,

127
00:09:06,060 --> 00:09:08,620
но големия блок на паметта се съхранява на куп.

128
00:09:08,620 --> 00:09:11,010
Променливата х в стека само съхранява адрес

129
00:09:11,010 --> 00:09:14,010
на големия блок на паметта на куп.

130
00:09:14,010 --> 00:09:17,370
Един от изводите на това е с размера на оператора.

131
00:09:17,370 --> 00:09:22,480
Ако питате за размера на конзолата масив, тя ще ви даде размера на големия блок на паметта,

132
00:09:22,480 --> 00:09:24,620
нещо като 40 байта,

133
00:09:24,620 --> 00:09:26,920
но ако питаш за размера на показалеца тип масив,

134
00:09:26,920 --> 00:09:32,740
тя ще ви даде размера на променливата х, върху уреда е вероятно само на 4 байта.

135
00:09:32,740 --> 00:09:36,530
Използването на тип показалеца масив, е невъзможно да се обърнат пряко

136
00:09:36,530 --> 00:09:38,530
размера на големия блок на паметта.

137
00:09:38,530 --> 00:09:42,530
Това обикновено не е много на ограничение, тъй като ние много рядко искате размерът

138
00:09:42,530 --> 00:09:46,980
памет на големия блок, и ние обикновено може да се изчисли, ако имаме нужда от него.

139
00:09:46,980 --> 00:09:51,490
>> И накрая, на конзолата масив се случва, да ни предоставите пряк път за инициализиране на масив.

140
00:09:51,490 --> 00:09:56,130
Нека да видим как бихме могли да пишат първите 10 четни числа, използвайки контекстното initilization.

141
00:10:11,220 --> 00:10:14,470
С показалеца масив, няма начин да се направи пряк път по този начин.

142
00:10:14,470 --> 00:10:18,120
Това е само въведение към какво можете да направите с масиви.

143
00:10:18,120 --> 00:10:20,990
Те се появи в почти всяка програма, която пиша.

144
00:10:20,990 --> 00:10:24,390
Надяваме се, сега може да види по-добър начин за правене на студентски документи за самоличност например

145
00:10:24,390 --> 00:10:26,710
от началото на видеото.

146
00:10:26,710 --> 00:10:29,960
>> Моето име е Роб Боудън, и това е CS50.