1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Laten we praten over arrays.

2
00:00:09,360 --> 00:00:12,780
Dus waarom zouden we ooit willen arrays gebruiken?

3
00:00:12,780 --> 00:00:17,210
Nou laten we zeggen dat je een programma dat moet op te slaan 5 student-ID's.

4
00:00:17,210 --> 00:00:21,270
Het lijkt misschien redelijk om 5 afzonderlijke variabelen.

5
00:00:21,270 --> 00:00:24,240
Om redenen die we zullen zien in een beetje, zullen we beginnen te tellen vanaf 0.

6
00:00:24,240 --> 00:00:30,700
De variabelen we moeten zullen int ID0, int ID1, en ga zo maar door.

7
00:00:30,700 --> 00:00:34,870
Elke logica willen we voeren op een studentenkaart moet worden gekopieerd en geplakt

8
00:00:34,870 --> 00:00:36,870
Voor elk van deze student IDs.

9
00:00:36,870 --> 00:00:39,710
Als we willen nagaan welke studenten toevallig in CS50,

10
00:00:39,710 --> 00:00:43,910
zullen we eerst moeten controleren of ID0 vertegenwoordigt de student in de cursus.

11
00:00:43,910 --> 00:00:48,070
Dan om hetzelfde te doen voor de volgende student, moeten we om te kopiëren en de code te plakken voor ID0

12
00:00:48,070 --> 00:00:54,430
en vervangen alle voorkomens van ID0 met id1 en zo verder voor ID2, 3, en 4.

13
00:00:54,430 --> 00:00:57,560
>> Zodra je hoort dat we nodig hebben om te kopiëren en te plakken,

14
00:00:57,560 --> 00:01:00,440
moet je gaan denken dat er een betere oplossing.

15
00:01:00,440 --> 00:01:05,360
Nu, wat als je je realiseert je niet liever 5 student-id's nodig hebben, maar 7?

16
00:01:05,360 --> 00:01:09,570
Je moet om terug te gaan naar uw broncode en in een ID5 toe te voegen, een ID6,

17
00:01:09,570 --> 00:01:14,260
en kopieer en plak de logica om te controleren of de ID's behoren tot de klasse van deze 2 nieuwe ID's.

18
00:01:14,260 --> 00:01:19,600
Er is niets verbindend al deze IDs elkaar en dus is er geen manier om te vragen

19
00:01:19,600 --> 00:01:22,040
het programma om dit te doen voor ID's 0 tot en met 6.

20
00:01:22,040 --> 00:01:26,120
Nou nu je beseft dat je 100 studenten-ID's.

21
00:01:26,120 --> 00:01:30,770
Het begint te lijken minder dan ideaal om te dienen apart te verklaren elk van deze ID's,

22
00:01:30,770 --> 00:01:33,760
en kopieer en plak enige logica voor die nieuwe ID's.

23
00:01:33,760 --> 00:01:38,380
Maar misschien zijn we vastbesloten, en we doen het voor alle 100 leerlingen.

24
00:01:38,380 --> 00:01:42,240
Maar wat als je niet weet hoeveel studenten er eigenlijk?

25
00:01:42,240 --> 00:01:47,320
Er zijn slechts enkele n leerlingen en uw programma moet de gebruiker vragen wat dat n.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Dit gaat niet goed te werken.

27
00:01:50,250 --> 00:01:53,820
Het programma werkt alleen voor sommige constant aantal studenten.

28
00:01:53,820 --> 00:01:57,520
>> Het oplossen van al deze problemen is de schoonheid van arrays.

29
00:01:57,520 --> 00:01:59,930
Dus wat is een array?

30
00:01:59,930 --> 00:02:04,480
In sommige programmeertalen een array-type zou in staat zijn om een ​​beetje meer te doen,

31
00:02:04,480 --> 00:02:09,960
maar hier zullen we focussen op de basis-array data structuur net zoals u zult zien in C.

32
00:02:09,960 --> 00:02:14,030
Een array is gewoon een groot blok van het geheugen. Dat is het.

33
00:02:14,030 --> 00:02:17,770
Als we zeggen dat we een array van 10 getallen, dat betekent dat we een aantal blok

34
00:02:17,770 --> 00:02:20,740
geheugen dat groot genoeg is om 10 afzonderlijke integers houden.

35
00:02:29,930 --> 00:02:33,410
Ervan uitgaande dat een geheel getal is 4 bytes, betekent dit dat een array van 10 integers

36
00:02:33,410 --> 00:02:37,180
is een continu blok van 40 bytes in het geheugen.

37
00:02:42,660 --> 00:02:46,280
Zelfs bij het gebruik van multidimensionale arrays, die we niet gaan om hier,

38
00:02:46,280 --> 00:02:49,200
het is nog steeds gewoon een groot blok van het geheugen.

39
00:02:49,200 --> 00:02:51,840
De multidimensionale notatie is gewoon een gemak.

40
00:02:51,840 --> 00:02:55,640
Als je een 3 bij 3 multidimensionale array van integers,

41
00:02:55,640 --> 00:03:00,650
dan is uw programma eigenlijk gewoon behandelen dit als een groot blok van 36 bytes.

42
00:03:00,650 --> 00:03:05,460
Het totale aantal getallen is 3 keer 3 en elke integer neemt 4 bytes.

43
00:03:05,460 --> 00:03:07,750
>> Laten we eens een kijkje nemen op een eenvoudig voorbeeld.

44
00:03:07,750 --> 00:03:10,660
We kunnen hier zien 2 verschillende manieren te verklaren arrays.

45
00:03:15,660 --> 00:03:18,580
We moeten 1 van hen commentaar uit voor het programma samen te stellen

46
00:03:18,580 --> 00:03:20,900
omdat we twee keer verklaren x.

47
00:03:20,900 --> 00:03:25,140
We nemen een kijkje bij enkele van de verschillen tussen deze 2 soorten aangiften in een beetje.

48
00:03:25,140 --> 00:03:28,560
Beide lijnen een array declareren van grootte N,

49
00:03:28,560 --> 00:03:30,740
waar we # define N als 10.

50
00:03:30,740 --> 00:03:34,460
We konden net zo goed kunnen vragen de gebruiker om een ​​positief geheel getal

51
00:03:34,460 --> 00:03:37,250
en gebruikt dat als integer aantal elementen in onze array.

52
00:03:37,250 --> 00:03:41,960
Vóór Net als onze studentenkaart voorbeeld, dit is een soort verklaren 10 volledig gescheiden

53
00:03:41,960 --> 00:03:49,000
imaginaire variabelen x0, x1, x2, enz. tot xN-1.

54
00:03:57,270 --> 00:04:00,840
Het negeren van de lijnen waar we verklaren de array, let op de vierkante haakjes intact

55
00:04:00,840 --> 00:04:02,090
in de voor lussen.

56
00:04:02,090 --> 00:04:09,660
Als we iets schrijven als x [3], die ik lees net als x beugel 3,

57
00:04:09,660 --> 00:04:13,090
kunt u denken aan het als vragen voor de denkbeeldige x3.

58
00:04:13,090 --> 00:04:17,519
Opmerking dan met een array van grootte N betekent dit dat het aantal in de beugels,

59
00:04:17,519 --> 00:04:22,630
die we de index te bellen, kan van alles zijn van 0 tot N-1 zijn,

60
00:04:22,630 --> 00:04:25,660
die in totaal N indices.

61
00:04:25,660 --> 00:04:28,260
>> Om na te denken over hoe deze echt werkt

62
00:04:28,260 --> 00:04:31,260
vergeet niet dat de array is een groot blok van het geheugen.

63
00:04:31,260 --> 00:04:37,460
Ervan uitgaande dat een geheel getal is 4 bytes, de gehele array x een 40 byte blok geheugen.

64
00:04:37,460 --> 00:04:41,360
Dus x0 verwijst naar de allereerste 4 bytes van het blok.

65
00:04:45,810 --> 00:04:49,230
X [1] naar de volgende 4 bytes enzovoort.

66
00:04:49,230 --> 00:04:53,760
Dit betekent dat het begin van x is alle programma ooit moet bijhouden.

67
00:04:55,660 --> 00:04:59,840
Als u wilt x [400] te gebruiken, dan wordt ervan uitgegaan dat deze gelijkwaardig is

68
00:04:59,840 --> 00:05:03,460
gewoon 1600 bytes na het begin van x.

69
00:05:03,460 --> 00:05:08,780
Waar krijgen we 1.600 bytes vandaan? Het is gewoon 400 keer 4 bytes per getal.

70
00:05:08,780 --> 00:05:13,170
>> Alvorens over te gaan, is het erg belangrijk te realiseren dat in C

71
00:05:13,170 --> 00:05:17,080
is er geen handhaving van de index die we gebruiken in de array.

72
00:05:17,080 --> 00:05:23,180
Onze grote blok is slechts 10 gehele getallen lang, maar niets zal schreeuwen tegen ons als we schrijven x [20]

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

74
00:05:26,060 --> 00:05:28,240
De index heeft niet eens om een ​​nummer te zijn.

75
00:05:28,240 --> 00:05:30,630
Het kan elke willekeurige expressie.

76
00:05:30,630 --> 00:05:34,800
In het programma gebruiken we de variabele i van de for-lus te indexeren in de array.

77
00:05:34,800 --> 00:05:40,340
Dit is een veel voorkomende patroon lus van i = 0 tot de lengte van de array,

78
00:05:40,340 --> 00:05:43,350
en vervolgens met behulp van i als de index voor de array.

79
00:05:43,350 --> 00:05:46,160
Op deze manier effectief lus over de hele array,

80
00:05:46,160 --> 00:05:50,600
en u kunt toewijzen aan elk plekje in de matrix of het gebruiken voor een aantal berekeningen.

81
00:05:50,600 --> 00:05:53,920
>> In de eerste for-lus, i begint bij 0,

82
00:05:53,920 --> 00:05:58,680
en zo zal aan de 0 in de array de waarde 0 keer 2.

83
00:05:58,680 --> 00:06:04,370
Dan heb ik stappen, en wijzen we de eerste plek in de array de waarde 1 tijden 2.

84
00:06:04,370 --> 00:06:10,170
Dan heb ik stappen opnieuw en ga zo maar door tot we aan N-1 positie in de array

85
00:06:10,170 --> 00:06:13,370
de waarde N-1 tijden 2.

86
00:06:13,370 --> 00:06:17,810
Dus we hebben gemaakt een array met de eerste 10 even nummers.

87
00:06:17,810 --> 00:06:21,970
Misschien evens zou zijn geweest een beetje beter naam voor de variabele dan x,

88
00:06:21,970 --> 00:06:24,760
maar dat zou hebben gegeven dingen weg.

89
00:06:24,760 --> 00:06:30,210
De tweede lus dan gewoon drukt de waarden die we al hebben opgeslagen in de array.

90
00:06:30,210 --> 00:06:33,600
>> Laten we proberen het uitvoeren van het programma met beide soorten van array verklaringen

91
00:06:33,600 --> 00:06:36,330
en neem een ​​kijkje op de uitvoer van het programma.

92
00:06:51,450 --> 00:06:57,020
Voor zover we kunnen zien, gedraagt ​​het programma zich op dezelfde manier voor beide soorten aangiften.

93
00:06:57,020 --> 00:07:02,230
Laten we ook eens kijken naar wat er gebeurt te nemen als we de eerste lus om niet op bij N

94
00:07:02,230 --> 00:07:05,040
maar zeggen 10.000.

95
00:07:05,040 --> 00:07:07,430
Wijze voorbij het einde van de array.

96
00:07:14,700 --> 00:07:17,210
Oeps. Misschien heb je dit eerder gezien.

97
00:07:17,210 --> 00:07:20,440
Een segmentatie fout betekent dat uw programma is gecrasht.

98
00:07:20,440 --> 00:07:24,430
Je begint het zien van deze bij het aanraken van delen van het geheugen moet je niet aanraken.

99
00:07:24,430 --> 00:07:27,870
Hier zijn we het aanraken van 10.000 plaatsen buiten de start van x,

100
00:07:27,870 --> 00:07:31,920
dat is duidelijk een plaats in het geheugen moeten we niet raken.

101
00:07:31,920 --> 00:07:37,690
Dus de meesten van ons waarschijnlijk niet per ongeluk 10.000 in plaats van N,

102
00:07:37,690 --> 00:07:42,930
maar wat als we iets doen wat subtieler als zeggen schrijf kleiner dan of gelijk aan N

103
00:07:42,930 --> 00:07:46,830
in de lus staat tegenover minder dan N.

104
00:07:46,830 --> 00:07:50,100
Bedenk dat een array slechts indices van 0 tot N-1 is,

105
00:07:50,100 --> 00:07:54,510
waardoor index N is na het einde van de array.

106
00:07:54,510 --> 00:07:58,050
Het programma is mogelijk niet crashen in dit geval, maar het is nog steeds een fout.

107
00:07:58,050 --> 00:08:01,950
In feite is deze fout zo vaak voor dat het een eigen naam heeft,

108
00:08:01,950 --> 00:08:03,970
een off met 1 fout.

109
00:08:03,970 --> 00:08:05,970
>> Dat is het voor de basis.

110
00:08:05,970 --> 00:08:09,960
Dus wat zijn de belangrijkste verschillen tussen de 2 soorten van array verklaringen?

111
00:08:09,960 --> 00:08:13,960
Een verschil is waar het grote blok van het geheugen gaat.

112
00:08:13,960 --> 00:08:17,660
In de eerste verklaring I, die bel de beugel-array type,

113
00:08:17,660 --> 00:08:20,300
maar dit is geenszins een gebruikelijke naam

114
00:08:20,300 --> 00:08:22,480
het zal gaan op de stapel.

115
00:08:22,480 --> 00:08:27,450
Terwijl in het tweede, dat ik de pointer-array-type noemen, zal het gaan op de heap.

116
00:08:27,450 --> 00:08:32,480
Dit betekent dat wanneer de functie terugkeert, de beugel array automatisch worden deallocated,

117
00:08:32,480 --> 00:08:36,419
overwegende dat moet je explicitily gratis een beroep doen op de wijzer-array

118
00:08:36,419 --> 00:08:38,010
of anders moet je een geheugenlek.

119
00:08:38,010 --> 00:08:42,750
Bovendien, de beugel matrix is ​​eigenlijk een variabele.

120
00:08:42,750 --> 00:08:45,490
Dit is belangrijk. Het is gewoon een symbool.

121
00:08:45,490 --> 00:08:49,160
U kunt hierbij denken aan het als een constante die de compiler kiest voor jou.

122
00:08:49,160 --> 00:08:52,970
Dit betekent dat we niet kunnen doen iets als x + + met de beugel type,

123
00:08:52,970 --> 00:08:56,240
maar dit is perfect opgaan met de aanwijzer-type.

124
00:08:56,240 --> 00:08:58,270
>> De pointer is een variabele soort.

125
00:08:58,270 --> 00:09:01,510
Voor de aanwijzer type, hebben we 2 afzonderlijke blokken van het geheugen.

126
00:09:01,510 --> 00:09:06,060
De variabele x zelf opgeslagen in de stapel en is slechts een pointer,

127
00:09:06,060 --> 00:09:08,620
maar het grote blok geheugen wordt opgeslagen op de heap.

128
00:09:08,620 --> 00:09:11,010
De variabele x op de stack slaat alleen het adres

129
00:09:11,010 --> 00:09:14,010
van het grote blok van het geheugen op de heap.

130
00:09:14,010 --> 00:09:17,370
Een implicatie hiervan is met de grootte van de exploitant.

131
00:09:17,370 --> 00:09:22,480
Als u vragen naar de omvang van de beugel array, zal het u de grootte van het grote blok van het geheugen,

132
00:09:22,480 --> 00:09:24,620
iets als 40 bytes,

133
00:09:24,620 --> 00:09:26,920
maar als je vraagt ​​voor de grootte van de aanwijzer type array,

134
00:09:26,920 --> 00:09:32,740
het geeft je de grootte van de variabele x zelf, die op het apparaat is waarschijnlijk slechts 4 bytes.

135
00:09:32,740 --> 00:09:36,530
Met de pointer-array type, is het onmogelijk om rechtstreeks vragen

136
00:09:36,530 --> 00:09:38,530
de grootte van de grote blok geheugen.

137
00:09:38,530 --> 00:09:42,530
Dit is meestal niet veel van een beperking omdat we willen zelden de omvang

138
00:09:42,530 --> 00:09:46,980
van het grote blok van het geheugen, en we kunnen meestal berekenen als we het nodig hebben.

139
00:09:46,980 --> 00:09:51,490
>> Tot slot, de beugel serie gebeurt er met ons te voorzien van een snelkoppeling voor het initialiseren van een array.

140
00:09:51,490 --> 00:09:56,130
Laten we eens kijken hoe we de eerste 10 zelfs gehele getallen met behulp van de snelkoppeling initilization schrijven.

141
00:10:11,220 --> 00:10:14,470
Met de aanwijzer array, is er geen manier om een ​​snelkoppeling als dit te doen.

142
00:10:14,470 --> 00:10:18,120
Dit is slechts een inleiding tot wat u kunt doen met arrays.

143
00:10:18,120 --> 00:10:20,990
Ze verschijnen in bijna elk programma dat u schrijven.

144
00:10:20,990 --> 00:10:24,390
Hopelijk kun je nu een betere manier om de student-ID's voorbeeld

145
00:10:24,390 --> 00:10:26,710
vanaf het begin van de video.

146
00:10:26,710 --> 00:10:29,960
>> Mijn naam is Rob Bowden, en dit is CS50.