1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Poďme hovoriť o pole.

2
00:00:09,360 --> 00:00:12,780
Tak prečo by sme chceli použiť pole?

3
00:00:12,780 --> 00:00:17,210
No povedzme, že máte program, ktorý potrebuje na uloženie 5 študentov ID.

4
00:00:17,210 --> 00:00:21,270
Mohlo by sa zdať rozumné, aby 5 samostatných premenných.

5
00:00:21,270 --> 00:00:24,240
Z dôvodov, ktoré uvidíme v trochu, začneme počítať od 0.

6
00:00:24,240 --> 00:00:30,700
Premenné budeme mať bude int ID0, int ID1, a tak ďalej.

7
00:00:30,700 --> 00:00:34,870
Akékoľvek logika chceme vykonávať na študentské ID bude potrebné skopírovať a vložiť

8
00:00:34,870 --> 00:00:36,870
pre každú z týchto študentských ID.

9
00:00:36,870 --> 00:00:39,710
Ak chceme zistiť, ktoré študenti stalo, že sa v CS50,

10
00:00:39,710 --> 00:00:43,910
budeme musieť najprv skontrolovať, či ID0 predstavuje študenta v kurze.

11
00:00:43,910 --> 00:00:48,070
Potom urobiť to isté pre ďalšie študentov, budeme musieť skopírovať a vložiť kód pre ID0

12
00:00:48,070 --> 00:00:54,430
a nahradiť všetky výskyty ID0 s ID1 a tak pre ID2, 3, a 4.

13
00:00:54,430 --> 00:00:57,560
>> Keď počujete, že musíme skopírovať a vložiť,

14
00:00:57,560 --> 00:01:00,440
mali by ste začať premýšľať, že je lepšie riešenie.

15
00:01:00,440 --> 00:01:05,360
Tak čo, ak si uvedomíte, že nepotrebujete 5 študentské ID, ale 7?

16
00:01:05,360 --> 00:01:09,570
Musíte sa vrátiť do zdrojového kódu a pridať v ID5, k ID6,

17
00:01:09,570 --> 00:01:14,260
a kopírovať a vložiť logiku pre kontrolu v prípade, že ID patrí do triedy pre tieto 2 nové ID.

18
00:01:14,260 --> 00:01:19,600
Nie je nič spájajúcej všetky tieto identifikátory dohromady, a tak tam nie je žiadny spôsob, ako sa pýtať

19
00:01:19,600 --> 00:01:22,040
program to pre ID 0 až 6.

20
00:01:22,040 --> 00:01:26,120
No teraz si uvedomíte, že máte 100 študentov ID.

21
00:01:26,120 --> 00:01:30,770
Začína to vyzerať menej než ideálne musieť samostatne vyhlásiť každý z týchto ID,

22
00:01:30,770 --> 00:01:33,760
a kopírovať a vkladať žiadnu logiku pre tieto nové ID.

23
00:01:33,760 --> 00:01:38,380
Ale možno sme odhodlaní, a robíme to pre všetkých 100 študentov.

24
00:01:38,380 --> 00:01:42,240
Ale čo keď neviete, koľko študentov je v skutočnosti sú?

25
00:01:42,240 --> 00:01:47,320
Tam sú len niektoré n študenti a váš program musí požiadať užívateľa, čo to n je.

26
00:01:47,320 --> 00:01:50,250
Uh oh. To nebude fungovať veľmi dobre.

27
00:01:50,250 --> 00:01:53,820
Váš program funguje len pre nejakú konštantu počtu študentov.

28
00:01:53,820 --> 00:01:57,520
>> Riešenie všetkých týchto problémov je krása polí.

29
00:01:57,520 --> 00:01:59,930
Takže to, čo je pole?

30
00:01:59,930 --> 00:02:04,480
V niektorých programovacích jazykoch pole typ by mohol byť schopní urobiť trochu viac,

31
00:02:04,480 --> 00:02:09,960
ale tu budeme sústrediť na základnú štruktúru pole dát, rovnako ako uvidíte to v C.

32
00:02:09,960 --> 00:02:14,030
Pole je len veľký blok pamäte. To je všetko.

33
00:02:14,030 --> 00:02:17,770
Keď hovoríme, že majú rad 10 celých čísel, že práve znamená, že máme nejaký blok

34
00:02:17,770 --> 00:02:20,740
pamäte, ktorá je dostatočne veľká pre uloženie 10 samostatných celé čísla.

35
00:02:29,930 --> 00:02:33,410
Za predpokladu, že celé číslo je 4 bajty, to znamená, že rad 10 celých čísel

36
00:02:33,410 --> 00:02:37,180
je kontinuálny blok 40 bajtov v pamäti.

37
00:02:42,660 --> 00:02:46,280
Dokonca aj pri použití viacrozmerných polí, ktoré nebudeme ísť do tu,

38
00:02:46,280 --> 00:02:49,200
je to stále len veľký blok pamäte.

39
00:02:49,200 --> 00:02:51,840
Multidimenzionálne zápis je len pohodlie.

40
00:02:51,840 --> 00:02:55,640
Ak máte 3 od 3 multidimenzionálne pole celých čísel,

41
00:02:55,640 --> 00:03:00,650
potom sa váš program bude naozaj len zaobchádzať s týmto ako veľký blok 36 bajtov.

42
00:03:00,650 --> 00:03:05,460
Celkový počet celých čísel je 3 krát 3, a každý z nich celé číslo zaberá 4 bajty.

43
00:03:05,460 --> 00:03:07,750
>> Poďme sa pozrieť na základné príklad.

44
00:03:07,750 --> 00:03:10,660
Vidíme tu 2 rôzne spôsoby, ako deklarujú polí.

45
00:03:15,660 --> 00:03:18,580
Budeme musieť komentár 1 z nich sa pre program zostaviť

46
00:03:18,580 --> 00:03:20,900
pretože sme vyhlásiť x dvakrát.

47
00:03:20,900 --> 00:03:25,140
My sa pozrieme na niektoré z rozdielov medzi týmito 2 typy vyhlásenia v trochu.

48
00:03:25,140 --> 00:03:28,560
Oba týchto liniek deklarovať pole veľkosti N,

49
00:03:28,560 --> 00:03:30,740
kde sme # define N ako 10.

50
00:03:30,740 --> 00:03:34,460
Mohli by sme rovnako ľahko požiadala užívateľa o kladné číslo

51
00:03:34,460 --> 00:03:37,250
a používa, že celé číslo ako radu prvkov v našom poli.

52
00:03:37,250 --> 00:03:41,960
Rovnako ako náš študentský preukaz príklad skôr, toto je ako deklarovaní 10 úplne samostatnú

53
00:03:41,960 --> 00:03:49,000
imaginárny premenné; x0, x1, x2, a tak ďalej až do XN-1.

54
00:03:57,270 --> 00:04:00,840
Ignorovanie riadky, kde deklarujeme pole, zistíte, že hranaté zátvorky neporušené

55
00:04:00,840 --> 00:04:02,090
vnútri pre slučky.

56
00:04:02,090 --> 00:04:09,660
Keď sme napísať niečo ako x [3], ktorý som si len čítať ako x držiaku 3,

57
00:04:09,660 --> 00:04:13,090
môžete si na to, ako žiadať o imaginárny x3.

58
00:04:13,090 --> 00:04:17,519
Všimnite než s radom veľkosti N, to znamená, že sa počet vnútri držiakov,

59
00:04:17,519 --> 00:04:22,630
ktoré budeme nazývať index, môže byť čokoľvek, od 0 do N-1,

60
00:04:22,630 --> 00:04:25,660
ktorý je celkom indexov N.

61
00:04:25,660 --> 00:04:28,260
>> Ak chcete premýšľať o tom, ako to skutočne funguje

62
00:04:28,260 --> 00:04:31,260
na pamäti, že pole je veľký blok pamäte.

63
00:04:31,260 --> 00:04:37,460
Za predpokladu, že číslo je 4 bajty, celé pole x je 40 byte bloku pamäte.

64
00:04:37,460 --> 00:04:41,360
Takže x0 odkazuje na prvých 4 bytov bloku.

65
00:04:45,810 --> 00:04:49,230
X [1] odkazuje na ďalšie 4 bajty a tak ďalej.

66
00:04:49,230 --> 00:04:53,760
To znamená, že začiatok x je všetko program niekedy potrebuje sledovať.

67
00:04:55,660 --> 00:04:59,840
Ak chcete použiť x [400], potom program vie, že je to rovnaké

68
00:04:59,840 --> 00:05:03,460
na iba 1600 bajtov od začiatku x.

69
00:05:03,460 --> 00:05:08,780
Kde získame 1600 bytov z? Je to len 400 krát 4 bytov na integer.

70
00:05:08,780 --> 00:05:13,170
>> Pred tým, než, že je to veľmi dôležité si uvedomiť, že v C

71
00:05:13,170 --> 00:05:17,080
nie je výkon indexu že používame v poli.

72
00:05:17,080 --> 00:05:23,180
Náš veľký blok je iba 10 celých čísel dlhý, ale nič sa kričať na nás, ak budeme písať x [20]

73
00:05:23,180 --> 00:05:26,060
alebo dokonca x [-5].

74
00:05:26,060 --> 00:05:28,240
Index ani nemusí byť číslo.

75
00:05:28,240 --> 00:05:30,630
To môže byť akákoľvek ľubovoľná výraz.

76
00:05:30,630 --> 00:05:34,800
V programe používame premennú aj od slučky for a indexu do poľa.

77
00:05:34,800 --> 00:05:40,340
To je veľmi časté vzor, ​​opakovanie od i = 0 k dĺžke poľa,

78
00:05:40,340 --> 00:05:43,350
a potom sa za použitie aj ako index pre pole.

79
00:05:43,350 --> 00:05:46,160
Týmto spôsobom sa účinne slučky cez celé pole,

80
00:05:46,160 --> 00:05:50,600
a vy môžete buď priradiť každom mieste v poli alebo ho použiť k nejakej výpočet.

81
00:05:50,600 --> 00:05:53,920
>> V prvej pre sláčiky, aj začína 0,

82
00:05:53,920 --> 00:05:58,680
a tak to bude priradiť 0 mieste v poli, hodnota 0 krát 2.

83
00:05:58,680 --> 00:06:04,370
Potom aj prírastky, a priradíme prvé miesto v poli Hodnota 1 krát 2.

84
00:06:04,370 --> 00:06:10,170
Potom aj prírastky znovu a tak ďalej, až by sme priradiť do polohy N-1 v poli

85
00:06:10,170 --> 00:06:13,370
hodnota N-1 krát 2.

86
00:06:13,370 --> 00:06:17,810
Takže sme vytvorili pole s prvými 10 párnych čísel.

87
00:06:17,810 --> 00:06:21,970
Možno vyrovnáva by bolo trochu lepšie meno pre premennú ako x,

88
00:06:21,970 --> 00:06:24,760
ale to by rovnako veci preč.

89
00:06:24,760 --> 00:06:30,210
Druhý cyklus for potom vytlačí len hodnoty, ktoré sme už uložené vnútri poľa.

90
00:06:30,210 --> 00:06:33,600
>> Skúsme spustenie programu s oboma typmi polí vyhlásenie

91
00:06:33,600 --> 00:06:36,330
a pozrite sa na výstupe programu.

92
00:06:51,450 --> 00:06:57,020
Ak, ako môžeme vidieť, program sa chová rovnako pre obidva typy vyhlásení.

93
00:06:57,020 --> 00:07:02,230
Poďme sa tiež pozrieť na to, čo sa stane, keď zmeníme prvé slučku nezastaví na N

94
00:07:02,230 --> 00:07:05,040
ale hovoria 10000.

95
00:07:05,040 --> 00:07:07,430
Cesta za koncom poľa.

96
00:07:14,700 --> 00:07:17,210
Chybička sa vlúdila. Možno ste videli predtým.

97
00:07:17,210 --> 00:07:20,440
Segmentation fault znamená, že máte program havaroval.

98
00:07:20,440 --> 00:07:24,430
Začnete vidieť tieto, keď sa dotknete oblasti pamäte, ktorú by nemal byť dotýkajú.

99
00:07:24,430 --> 00:07:27,870
Tu sme sa dotýkajú 10.000 miest mimo začiatku x,

100
00:07:27,870 --> 00:07:31,920
ktoré evidentne je miesto v pamäti by sme nemali dotýkať.

101
00:07:31,920 --> 00:07:37,690
Takže väčšina z nás by asi nebolo náhodou dal 10.000 miesto N,

102
00:07:37,690 --> 00:07:42,930
ale čo keď to urobíme niečo jemnejšie ako povedať, písať menej než alebo sa rovno k n

103
00:07:42,930 --> 00:07:46,830
v pre slučke stave, na rozdiel od menej ako N.

104
00:07:46,830 --> 00:07:50,100
Pamätajte si, že pole má iba indexy od 0 do N-1,

105
00:07:50,100 --> 00:07:54,510
, Čo znamená, že index n je za koncom poľa.

106
00:07:54,510 --> 00:07:58,050
Program nemusí zlyhanie v tomto prípade, ale je to stále chyba.

107
00:07:58,050 --> 00:08:01,950
V skutočnosti, táto chyba je tak bežné, že to má svoj vlastný názov,

108
00:08:01,950 --> 00:08:03,970
preč 1 chybe.

109
00:08:03,970 --> 00:08:05,970
>> To je to pre základy.

110
00:08:05,970 --> 00:08:09,960
Takže aké sú hlavné rozdiely medzi 2 typy polí vyhlásenie?

111
00:08:09,960 --> 00:08:13,960
Jeden rozdiel je tam veľké blok pamäte ide.

112
00:08:13,960 --> 00:08:17,660
V prvom vyhlásení, ktoré budem volať držiak-typ poľa,

113
00:08:17,660 --> 00:08:20,300
aj keď je to v žiadnom prípade konvenčné meno,

114
00:08:20,300 --> 00:08:22,480
že pôjde na stack.

115
00:08:22,480 --> 00:08:27,450
Zatiaľ čo v druhom, ktorý budem volať ručičkový typ poľa, bude to ísť na halde.

116
00:08:27,450 --> 00:08:32,480
To znamená, že keď sa funkcia vráti, držiak poľa automaticky vrátený,

117
00:08:32,480 --> 00:08:36,419
vzhľadom k tomu, musíte explicitily volať zadarmo na ukazovateľ poľa

118
00:08:36,419 --> 00:08:38,010
inak máte pretečeniu pamäte.

119
00:08:38,010 --> 00:08:42,750
Navyše držiak pole nie je v skutočnosti premenná.

120
00:08:42,750 --> 00:08:45,490
To je dôležité. Je to len symbol.

121
00:08:45,490 --> 00:08:49,160
Môžete si ju predstaviť ako konštantu, ktorá kompilátor vyberie pre vás.

122
00:08:49,160 --> 00:08:52,970
To znamená, že nemôžeme urobiť niečo ako x + + s držiakom typu,

123
00:08:52,970 --> 00:08:56,240
aj keď je to úplne platí pri typ ukazovateľa.

124
00:08:56,240 --> 00:08:58,270
>> Ukazovateľ typu je premenná.

125
00:08:58,270 --> 00:09:01,510
Pre typ ukazovatele, máme 2 oddelené bloky pamäte.

126
00:09:01,510 --> 00:09:06,060
Premenná x sám je uložený v zásobníku a je len jeden ukazovateľ,

127
00:09:06,060 --> 00:09:08,620
ale veľký blok pamäte je uložená na halde.

128
00:09:08,620 --> 00:09:11,010
Premenná x na zásobníku len uloží adresu

129
00:09:11,010 --> 00:09:14,010
veľkého bloku pamäte na halde.

130
00:09:14,010 --> 00:09:17,370
Jedným z dôsledkov tohto je s veľkosťou prevádzkovateľa.

131
00:09:17,370 --> 00:09:22,480
Ak sa spýtate pre veľkosť držiaka pole, bude vám veľkosť veľkého bloku pamäte,

132
00:09:22,480 --> 00:09:24,620
niečo ako 40 bajtov,

133
00:09:24,620 --> 00:09:26,920
ale ak sa spýtate na veľkosti ukazovatele typu poľa,

134
00:09:26,920 --> 00:09:32,740
to vám dá veľkosť premennej x sám, ktorý na spotrebič je pravdepodobne len 4 bajty.

135
00:09:32,740 --> 00:09:36,530
Pomocou ručičkový typu pole, to je nemožné priamo požiadať o

136
00:09:36,530 --> 00:09:38,530
veľkosť veľkého bloku pamäte.

137
00:09:38,530 --> 00:09:42,530
To zvyčajne nie je moc obmedzenia, pretože sme veľmi zriedka chceme veľkosť

138
00:09:42,530 --> 00:09:46,980
z veľkých blok pamäte, a my môžeme zvyčajne spočítať, ak ju potrebujeme.

139
00:09:46,980 --> 00:09:51,490
>> Konečne, držiak pole sa stane, aby nám poskytli zástupca pre inicializáciu poľa.

140
00:09:51,490 --> 00:09:56,130
Poďme sa pozrieť, ako by to mohlo písať prvý 10 dokonca celých čísel pomocou zástupcu initilization.

141
00:10:11,220 --> 00:10:14,470
S ukazovateľom pole, nie je spôsob, ako to urobiť zástupcu takého.

142
00:10:14,470 --> 00:10:18,120
To je len úvodom do toho, čo môžete robiť s poľami.

143
00:10:18,120 --> 00:10:20,990
Sa objaví v takmer každom programe píšete.

144
00:10:20,990 --> 00:10:24,390
Dúfajme, že si teraz môžete vidieť lepší spôsob, ako robiť študentský ids príklad

145
00:10:24,390 --> 00:10:26,710
od začiatku videa.

146
00:10:26,710 --> 00:10:29,960
>> Moje meno je Rob Bowden, a to je CS50.