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
Променливи ќе имаме ќе биде int id0, int id1, и така натаму.

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
Ако сакаме да се провери која студентите се случи да биде во 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
и да копирате и залепите на логиката за проверка дали ИД припаѓаат на класата за овие 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
Постојат само некои n студентите и вашата програма треба да побара од корисникот што дека n е.

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

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

46
00:03:18,580 --> 00:03:20,900
бидејќи ние објави X двапати.

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

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

49
00:03:28,560 --> 00:03:30,740
каде што имаме # define 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-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
Кога ние пишуваме нешто како x [3], која јас само ќе прочитате како x заградата 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 бајти, целиот спектар x е 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
Ако сакате да го користите x [400], а потоа на програмата знае дека ова е еквивалент

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

69
00:05:03,460 --> 00:05:08,780
Каде да добиеме 1.600 бајти од? Тоа е само 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 броеви долг, но ништо нема да се развикам нас ако ние пишуваме x [20]

73
00:05:23,180 --> 00:05:26,060
или дури x [-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
Ова е многу честа шема, looping од 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
Можеби изедначува би биле малку подобро име за променливата од x,

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
туку велат дека 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 места надвор од почетокот на X,

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

101
00:07:31,920 --> 00:07:37,690
Па повеќето од нас веројатно не случајно ќе ја стави 10.000 наместо на N,

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

103
00:07:42,930 --> 00:07:46,830
во за телефонска линија состојба за разлика од помалку од Н

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
исклучи од 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
Ова значи дека кога функцијата се враќа, заградата низа автоматски ќе биде 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
Ова значи дека не можеме да правиме нешто како x + + со држач тип,

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
Променливата x себе се чуваат во магацинот и е само еден покажувач,

127
00:09:06,060 --> 00:09:08,620
но голем блок од меморија се чуваат на грамада.

128
00:09:08,620 --> 00:09:11,010
Променливата x на магацинот само продавници адреса

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
тоа ќе ви даде на големината на променливата x себе, што на апаратот е веројатно само 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.