1
00:00:07,360 --> 00:00:09,360
[Powered by Google Translate] Lassen Sie uns über Arrays.

2
00:00:09,360 --> 00:00:12,780
Also warum sollten wir jemals wollen Arrays verwenden?

3
00:00:12,780 --> 00:00:17,210
Nun lassen Sie uns sagen, Sie haben ein Programm, das bis 5 Studentenausweise speichern muss.

4
00:00:17,210 --> 00:00:21,270
Es könnte scheinen vernünftig zu 5 separate Variablen haben.

5
00:00:21,270 --> 00:00:24,240
Gründen, die wir in einer etwas sehen werden, werden wir anfangen zu zählen von 0.

6
00:00:24,240 --> 00:00:30,700
Die Variablen müssen wir werden int id0, int id1, und so weiter.

7
00:00:30,700 --> 00:00:34,870
Jede Logik wollen wir auf einem Student-ID durchführen müssen kopiert und eingefügt werden

8
00:00:34,870 --> 00:00:36,870
Für jede dieser Studentenausweise.

9
00:00:36,870 --> 00:00:39,710
Wenn wir wollen, zu prüfen, welche die Schüler in CS50 werden passieren,

10
00:00:39,710 --> 00:00:43,910
Wir müssen zunächst prüfen, ob id0 stellt den Studenten im Kurs.

11
00:00:43,910 --> 00:00:48,070
Dann das gleiche für die nächsten Schüler zu tun, müssen wir zu kopieren und den Code für id0

12
00:00:48,070 --> 00:00:54,430
und ersetzen Sie alle Vorkommen von id0 mit id1 und so weiter für id2, 3 und 4.

13
00:00:54,430 --> 00:00:57,560
>> Sobald Sie hören, dass wir zu kopieren und müssen,

14
00:00:57,560 --> 00:01:00,440
Sie sollten anfangen, darüber nachzudenken, dass es eine bessere Lösung.

15
00:01:00,440 --> 00:01:05,360
Was nun, wenn Sie merken, Sie brauchen keine 5 Studentenausweise, sondern 7?

16
00:01:05,360 --> 00:01:09,570
Sie müssen zurück in den Quellcode und fügen Sie in einem ID5, eine id6,

17
00:01:09,570 --> 00:01:14,260
und kopieren Sie die Logik für die Überprüfung, ob die IDs der Klasse für diese 2 neue IDs gehören.

18
00:01:14,260 --> 00:01:19,600
Es gibt nichts verbindet all diese ID zusammen, und so gibt es keine Möglichkeit zu fragen

19
00:01:19,600 --> 00:01:22,040
das Programm dies für IDs 0 do bis 6.

20
00:01:22,040 --> 00:01:26,120
Nun merkt man, Sie haben 100 Schüler-IDs.

21
00:01:26,120 --> 00:01:30,770
Es beginnt zu scheinen weniger als ideal, um gesondert zu erklären, jede dieser IDs,

22
00:01:30,770 --> 00:01:33,760
und kopieren Sie jede Logik für die neuen IDs.

23
00:01:33,760 --> 00:01:38,380
Aber vielleicht sind wir entschlossen, und wir tun es für alle 100 Schüler.

24
00:01:38,380 --> 00:01:42,240
Aber was, wenn Sie nicht wissen, wie viele Studenten gibt es tatsächlich?

25
00:01:42,240 --> 00:01:47,320
Es sind nur einige n Studenten und Ihr Programm den Benutzer, was das n fragen.

26
00:01:47,320 --> 00:01:50,250
Uh oh. Dies ist nicht sehr gut zu funktionieren.

27
00:01:50,250 --> 00:01:53,820
Ihr Programm funktioniert nur für eine Konstante Zahl der Studierenden.

28
00:01:53,820 --> 00:01:57,520
>> Die Lösung all dieser Probleme ist die Schönheit des Arrays.

29
00:01:57,520 --> 00:01:59,930
Also, was ist ein Array?

30
00:01:59,930 --> 00:02:04,480
In einigen Programmiersprachen ein Array-Typ könnten ein bisschen mehr zu tun,

31
00:02:04,480 --> 00:02:09,960
aber hier werden wir auf der Basis array Datenstruktur zu konzentrieren, wie Sie es in C. Stilen

32
00:02:09,960 --> 00:02:14,030
Ein Array ist nur ein großer Block von Speicher. Das war's.

33
00:02:14,030 --> 00:02:17,770
Wenn wir sagen, wir haben eine Reihe von 10 Zahlen, das bedeutet nur, wir haben einige Block

34
00:02:17,770 --> 00:02:20,740
des Speichers, der groß genug ist, um 10 separate Zahlen halten.

35
00:02:29,930 --> 00:02:33,410
Unter der Annahme, dass eine ganze Zahl 4 Bytes ist, bedeutet dies, dass ein Array von 10 Ganzzahlen

36
00:02:33,410 --> 00:02:37,180
ist ein zusammenhängender Block von 40 Bytes im Speicher.

37
00:02:42,660 --> 00:02:46,280
Selbst wenn Sie mehrdimensionale Arrays, die wir nicht in hier gehen wird,

38
00:02:46,280 --> 00:02:49,200
es ist immer noch nur ein großer Block von Speicher.

39
00:02:49,200 --> 00:02:51,840
Die mehrdimensionale Notation ist nur eine Bequemlichkeit.

40
00:02:51,840 --> 00:02:55,640
Wenn Sie eine 3 x 3 mehrdimensionales Array von ganzen Zahlen,

41
00:02:55,640 --> 00:03:00,650
dann wird Ihr Programm wirklich nur behandeln Sie dies als einen großen Block von 36 Bytes.

42
00:03:00,650 --> 00:03:05,460
Die Gesamtzahl der ganzen Zahlen gleich 3 mal 3, und jede ganze Zahl aufnimmt 4 Bytes.

43
00:03:05,460 --> 00:03:07,750
>> Werfen wir einen Blick auf ein einfaches Beispiel.

44
00:03:07,750 --> 00:03:10,660
Wir können hier sehen 2 verschiedene Arten zu erklären Arrays.

45
00:03:15,660 --> 00:03:18,580
Wir müssen davon 1 auskommentieren für das Programm zu kompilieren

46
00:03:18,580 --> 00:03:20,900
da wir erklären x zweimal.

47
00:03:20,900 --> 00:03:25,140
Wir werden einen Blick auf einige der Unterschiede zwischen diesen 2 Arten von Deklarationen in einem Bit.

48
00:03:25,140 --> 00:03:28,560
Beide Zeilen deklarieren ein Array der Größe N,

49
00:03:28,560 --> 00:03:30,740
wo wir # define N wie 10.

50
00:03:30,740 --> 00:03:34,460
Wir könnten genauso gut die Benutzer für eine positive ganze Zahl gebeten haben

51
00:03:34,460 --> 00:03:37,250
und verwendet diese Zahl als eine Anzahl von Elementen in unserem Array.

52
00:03:37,250 --> 00:03:41,960
Wie unsere Studentenausweis beispielsweise vor, ist dies eine Art, wie erklären 10 vollständig getrennte

53
00:03:41,960 --> 00:03:49,000
imaginären Variablen; x0, x1, x2, und so weiter bis xN-1.

54
00:03:57,270 --> 00:04:00,840
Ignorieren Sie die Zeilen, wo wir das Array deklarieren, bemerken die eckigen Klammern intakt

55
00:04:00,840 --> 00:04:02,090
innerhalb der for-Schleifen.

56
00:04:02,090 --> 00:04:09,660
Wenn wir etwas schreiben x [3], die ich genauso x Halterung 3 zu lesen,

57
00:04:09,660 --> 00:04:13,090
Sie können daran denken möchte fragen für die imaginäre x3.

58
00:04:13,090 --> 00:04:17,519
Bemerken als bei einer Anordnung der Größe N, bedeutet dies, dass die Anzahl innerhalb der Klammern,

59
00:04:17,519 --> 00:04:22,630
was wir den Index aufrufen, können alles von 0 bis N-1 sein,

60
00:04:22,630 --> 00:04:25,660
was eine Gesamtzahl von N-Indizes.

61
00:04:25,660 --> 00:04:28,260
>> Um darüber, wie diese tatsächlich funktioniert denke

62
00:04:28,260 --> 00:04:31,260
daran erinnern, dass das Array ein großer Block von Speicher ist.

63
00:04:31,260 --> 00:04:37,460
Unter der Annahme, dass eine ganze Zahl 4 Bytes ist, ist die gesamte Anordnung eine 40-Byte x Speicherblock.

64
00:04:37,460 --> 00:04:41,360
X0, so bezieht sich auf den ersten vier Bytes des Blocks.

65
00:04:45,810 --> 00:04:49,230
X [1] bezieht sich auf die nächsten 4 Bytes und so weiter.

66
00:04:49,230 --> 00:04:53,760
Dies bedeutet, dass der Beginn der x all das Programm jemals braucht, um zu verfolgen ist.

67
00:04:55,660 --> 00:04:59,840
Wenn Sie x [400] verwenden wollen, dann wird das Programm weiß, dass dies gleichwertig ist

68
00:04:59,840 --> 00:05:03,460
um nur 1.600 Bytes nach dem Start von x.

69
00:05:03,460 --> 00:05:08,780
Woher bekommen wir 1.600 Bytes aus? Es ist nur 400 mal 4 Bytes pro Zahl.

70
00:05:08,780 --> 00:05:13,170
>> Bevor wir fortfahren, ist es sehr wichtig zu erkennen, dass in C

71
00:05:13,170 --> 00:05:17,080
es gibt keine Durchsetzung des Index, die wir in dem Array.

72
00:05:17,080 --> 00:05:23,180
Unser großer Block ist nur 10 Zahlen lang, aber nichts wird uns anschreien, wenn wir x [20] schreiben

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

74
00:05:26,060 --> 00:05:28,240
Der Index hat noch nicht einmal eine Zahl sein.

75
00:05:28,240 --> 00:05:30,630
Es kann jede beliebige Ausdruck sein.

76
00:05:30,630 --> 00:05:34,800
Im Programm verwenden wir die Variable i von der for-Schleife Index im Array.

77
00:05:34,800 --> 00:05:40,340
Dies ist eine sehr häufige Muster, eine Schleife von i = 0 auf die Länge des Arrays,

78
00:05:40,340 --> 00:05:43,350
und dann unter Verwendung von i als Index für das Array.

79
00:05:43,350 --> 00:05:46,160
Auf diese Weise können effektiv Schleife über das gesamte Array,

80
00:05:46,160 --> 00:05:50,600
und Sie können entweder an jeder Stelle in dem Array zuweisen oder es für einige Berechnung.

81
00:05:50,600 --> 00:05:53,920
>> In der ersten for-Schleife beginnt i bei 0,

82
00:05:53,920 --> 00:05:58,680
und so wird es in die 0 Punkt in dem Array, der Wert 0 mal 2 zuordnen.

83
00:05:58,680 --> 00:06:04,370
Dann i-Schritten, und wir weisen Sie den ersten Platz in der Reihe der Wert 1 mal 2.

84
00:06:04,370 --> 00:06:10,170
Dann i Schritten wieder und so weiter, bis wir zuzuweisen bis N-1 in dem Array zu positionieren

85
00:06:10,170 --> 00:06:13,370
der Wert N-1 mal 2.

86
00:06:13,370 --> 00:06:17,810
So haben wir ein Array mit den ersten 10 geraden Zahlen erstellt.

87
00:06:17,810 --> 00:06:21,970
Vielleicht gleicht hätte ein bisschen besser Namen für die Variable als x haben,

88
00:06:21,970 --> 00:06:24,760
aber das würde die Dinge verschenkt haben.

89
00:06:24,760 --> 00:06:30,210
Die zweite for-Schleife dann nur druckt die Werte, die wir bereits in der Array gespeichert.

90
00:06:30,210 --> 00:06:33,600
>> Lassen Sie uns versuchen, das Programm mit beiden Arten von Array-Deklarationen

91
00:06:33,600 --> 00:06:36,330
und werfen Sie einen Blick auf die Ausgabe des Programms.

92
00:06:51,450 --> 00:06:57,020
Soweit wir sehen können, verhält sich das Programm auf die gleiche Weise für beide Arten von Erklärungen.

93
00:06:57,020 --> 00:07:02,230
Lassen Sie uns auch einen Blick auf, was passiert, wenn wir die erste Schleife ändern, um nicht auf N zu stoppen

94
00:07:02,230 --> 00:07:05,040
sondern sagen, 10.000.

95
00:07:05,040 --> 00:07:07,430
Weg über das Ende des Arrays.

96
00:07:14,700 --> 00:07:17,210
Oops. Vielleicht haben Sie das schon mal gesehen.

97
00:07:17,210 --> 00:07:20,440
Eine Segmentation Fault bedeutet, dass Ihr Programm ist abgestürzt.

98
00:07:20,440 --> 00:07:24,430
Sie sehen, beginnen diese, wenn Sie Bereiche des Arbeitsspeichers Sie nicht zu berühren berühren.

99
00:07:24,430 --> 00:07:27,870
Hier sprechen wir 10.000 Plätze jenseits der Beginn der x,

100
00:07:27,870 --> 00:07:31,920
was offenbar ist ein Ort in Erinnerung, die wir nicht zu berühren.

101
00:07:31,920 --> 00:07:37,690
So sind die meisten von uns wahrscheinlich nicht versehentlich 10.000 anstelle von N,

102
00:07:37,690 --> 00:07:42,930
aber was, wenn wir etwas subtiler tun, wie gesagt write weniger als oder gleich N

103
00:07:42,930 --> 00:07:46,830
in der for-Schleife Zustand, im Gegensatz zu weniger als N.

104
00:07:46,830 --> 00:07:50,100
Erinnern, dass ein Array nur Indices von 0 bis N-1,

105
00:07:50,100 --> 00:07:54,510
was bedeutet, dass Index N über das Ende des Arrays ist.

106
00:07:54,510 --> 00:07:58,050
Das Programm kann in diesem Fall nicht abstürzen, aber es ist noch ein Fehler.

107
00:07:58,050 --> 00:08:01,950
Tatsächlich ist dieser Fehler so häufig, dass es seinen eigenen Namen hat,

108
00:08:01,950 --> 00:08:03,970
eine durch 1 Fehler.

109
00:08:03,970 --> 00:08:05,970
>> Das ist es für die Grundlagen.

110
00:08:05,970 --> 00:08:09,960
Also, was sind die wichtigsten Unterschiede zwischen den 2 Arten von Array-Deklarationen?

111
00:08:09,960 --> 00:08:13,960
Ein Unterschied ist, wo das große Block des Speichers geht.

112
00:08:13,960 --> 00:08:17,660
In der ersten Erklärung, die ich rufe die Halterung-Array-Typ,

113
00:08:17,660 --> 00:08:20,300
obwohl dies keineswegs herkömmlichen Namen,

114
00:08:20,300 --> 00:08:22,480
es wird auf den Stapel.

115
00:08:22,480 --> 00:08:27,450
Während in der zweiten, die ich den Zeiger-Array-Typ nenne, wird es auf dem Heap zu gehen.

116
00:08:27,450 --> 00:08:32,480
Dies bedeutet, dass, wenn die Funktion zurückkehrt, die Halterung Array wird automatisch freigegeben werden,

117
00:08:32,480 --> 00:08:36,419
Erwägung, müssen Sie explicitily rufen die Zeigerfelds kostenlos

118
00:08:36,419 --> 00:08:38,010
sonst haben Sie einen Speicherverlust.

119
00:08:38,010 --> 00:08:42,750
Zusätzlich ist die Halterung Array nicht eigentlich eine Variable.

120
00:08:42,750 --> 00:08:45,490
Dies ist wichtig. Es ist nur ein Symbol.

121
00:08:45,490 --> 00:08:49,160
Sie können es als eine Konstante, die der Compiler wählt für Sie denken.

122
00:08:49,160 --> 00:08:52,970
Dies bedeutet, dass wir nicht etwas tun, wie x + + mit dem Bügel Art,

123
00:08:52,970 --> 00:08:56,240
obwohl dies durchaus möglich, mit dem Zeiger-Typ.

124
00:08:56,240 --> 00:08:58,270
>> Der Zeiger-Typ ist eine Variable.

125
00:08:58,270 --> 00:09:01,510
Für die Zeiger-Typ, wir haben 2 separate Blöcke des Speichers.

126
00:09:01,510 --> 00:09:06,060
Die Variable x selbst wird in dem Stapel abgelegt und ist nur einen einzigen Zeiger,

127
00:09:06,060 --> 00:09:08,620
aber der große Block des Speichers auf der Halde abgelegt.

128
00:09:08,620 --> 00:09:11,010
Die Variable x auf dem Stack speichert nur die Adresse

129
00:09:11,010 --> 00:09:14,010
der großen Block von Speicher auf dem Heap.

130
00:09:14,010 --> 00:09:17,370
Eine Folge davon ist, mit der Größe des Operators.

131
00:09:17,370 --> 00:09:22,480
Wenn Sie die Größe der Halterung array fragen, es wird Ihnen die Größe des großen Block des Speichers,

132
00:09:22,480 --> 00:09:24,620
so etwas wie 40 Bytes,

133
00:09:24,620 --> 00:09:26,920
aber wenn Sie fragen nach der Größe des Zeigers Array-Typ,

134
00:09:26,920 --> 00:09:32,740
es wird Ihnen die Größe der Variablen x selbst, die auf dem Gerät ist wahrscheinlich nur 4 Byte.

135
00:09:32,740 --> 00:09:36,530
Verwendung der Zeiger-Array-Typ, ist es unmöglich, direkt fragen

136
00:09:36,530 --> 00:09:38,530
die Größe des großen Speicherblock.

137
00:09:38,530 --> 00:09:42,530
Dies ist in der Regel nicht viel von einer Einschränkung dar, da wir wollen, sehr selten die Größe

138
00:09:42,530 --> 00:09:46,980
der große Block des Speichers, und wir können in der Regel berechnen, wenn wir es brauchen.

139
00:09:46,980 --> 00:09:51,490
>> Schließlich passiert die Halterung array, um uns mit einer Verknüpfung zur Initialisierung eines Arrays bereitzustellen.

140
00:09:51,490 --> 00:09:56,130
Lassen Sie uns sehen, wie wir die ersten 10 geraden Zahlen mit der Tastenkombination initilization schreiben.

141
00:10:11,220 --> 00:10:14,470
Mit dem Zeiger-Array, gibt es nicht eine Möglichkeit, eine Verknüpfung wie dies zu tun.

142
00:10:14,470 --> 00:10:18,120
Dies ist nur eine Einführung, was man mit Arrays zu tun.

143
00:10:18,120 --> 00:10:20,990
Sie zeigen sich in fast jedem Programm, das Sie schreiben.

144
00:10:20,990 --> 00:10:24,390
Hoffentlich können Sie jetzt einen besseren Weg die Studentenausweise beispielsweise

145
00:10:24,390 --> 00:10:26,710
vom Beginn des Videos.

146
00:10:26,710 --> 00:10:29,960
>> Mein Name ist Rob Bowden, und dies ist CS50.