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
Па рецимо да имате програм који треба да складиштите 5 ИД студената.

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

5
00:00:21,270 --> 00:00:24,240
Из разлога ћемо видети у мало, ми ћемо почети бројање од 0.

6
00:00:24,240 --> 00:00:30,700
Променљиве ћемо имати биће инт ид0, инт ид1, и тако даље.

7
00:00:30,700 --> 00:00:34,870
Свака логика желимо да изведете на студентском ИД ће морати да се копирали и налепили

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

9
00:00:36,870 --> 00:00:39,710
Ако желимо да проверите које студенти се деси да буде у ЦС50,

10
00:00:39,710 --> 00:00:43,910
прво ћете морати да проверите да ли ид0 представља студента у току.

11
00:00:43,910 --> 00:00:48,070
Онда да ураде исто за следећи студента, ми ћемо морати да копирате и налепите код за ид0

12
00:00:48,070 --> 00:00:54,430
и замените сва појављивања ид0 са ид1 и тако даље за ИД2, 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
Морате да се вратите у своју изворни код и додајте у ИД5, један ид6,

17
00:01:09,570 --> 00:01:14,260
копирате и налепите логику за проверу да ли су ИД припадају класи за ове 2 нове личне карте.

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
али овде ћемо се фокусирати на основне податке низа структура баш као што ћете видети у Ц.

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
Овде можемо видети 2 различите начине декларисању низова.

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
Ми ћемо да погледамо неке од разлика између ових 2 врсте изјава у мало.

48
00:03:25,140 --> 00:03:28,560
Оба ова линија прогласи низ величине Н,

49
00:03:28,560 --> 00:03:30,740
где смо се дефинишу # Н као 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
имагинарне варијабли; к0, к1, к2, и тако све до кн-1.

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
Када пишемо нешто попут к [3], који ћу читати као носач к 3,

57
00:04:09,660 --> 00:04:13,090
можете мислити о томе као тражећи имагинарног Кс3.

58
00:04:13,090 --> 00:04:17,519
Обратите пажњу него са низом величине Н, то значи да је број унутар заграда,

59
00:04:17,519 --> 00:04:22,630
који ћемо назвати индекса, може бити било шта од 0 до Н-1,

60
00:04:22,630 --> 00:04:25,660
што је укупно Н индекса.

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
Тако к0 односи на првих 4 бајта у блоку.

65
00:04:45,810 --> 00:04:49,230
Кс [1] се односи на наредних 4 бајта и тако даље.

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

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

68
00:04:59,840 --> 00:05:03,460
на само 1.600 бајта након почетка к.

69
00:05:03,460 --> 00:05:08,780
Одакле добијамо 1.600 бајта из? То је само 400 пута 4 бајта по цео број.

70
00:05:08,780 --> 00:05:13,170
>> Пре него што наставимо даље, то је веома важно да се схвати да у Ц

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
У програму користимо променљиву сам из петље за то индекс у низу.

77
00:05:34,800 --> 00:05:40,340
Ово је веома чест образац, петље од И = 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
Онда сам опет повећава и тако даље до издвајамо позиционирати Н-1 у низу

85
00:06:10,170 --> 00:06:13,370
вредност Н-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
Хајде да се погледамо шта се дешава ако променимо прву петљу да не заустави на Н

94
00:07:02,230 --> 00:07:05,040
већ кажу 10.000.

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 места изван почетка к,

100
00:07:27,870 --> 00:07:31,920
што очигледно је место у меморији не би требало да буде дирљиво.

101
00:07:31,920 --> 00:07:37,690
Дакле, већина нас вероватно не би случајно ставио 10.000 уместо Н,

102
00:07:37,690 --> 00:07:42,930
али шта ако урадимо нешто суптилнији попут кажу писања мање или једнако Н

103
00:07:42,930 --> 00:07:46,830
у за петље услов за разлику од мање од Н.

104
00:07:46,830 --> 00:07:50,100
Запамтите да низ има само индекса од 0 до н-1,

105
00:07:50,100 --> 00:07:54,510
што значи да је индекс Н је након краја низа.

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
искључити 1 грешке.

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

110
00:08:05,970 --> 00:08:09,960
Па шта су главне разлике између 2 врсте низа декларација?

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
То значи да када функција врати, носач низ ће аутоматски бити деаллоцатед,

117
00:08:32,480 --> 00:08:36,419
а како ви Изричито да позовете бесплатно на курсор низу

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
За курсор типа, имамо 2 одвојене блокове меморије.

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 целих бројева чак помоћу пречица инитилизатион.

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
>> Моје име је Роб Бовден, а ово је ЦС50.