1
00:00:00,000 --> 00:00:03,388
>> [Musikwiedergabe]

2
00:00:03,388 --> 00:00:05,104

3
00:00:05,104 --> 00:00:06,020
DOUG LLOYD: Alles klar.

4
00:00:06,020 --> 00:00:07,680
Arbeiten mit Einzel
Variablen ist ziemlich lustig.

5
00:00:07,680 --> 00:00:09,500
Aber was, wenn wir wollen, um zu arbeiten
mit einer Menge von Variablen,

6
00:00:09,500 --> 00:00:12,760
aber wir wollen nicht einen Haufen haben
verschiedene Namen um unseren Code fliegen?

7
00:00:12,760 --> 00:00:15,980
In diesem Fall sind Arrays
wird kommen in wirklich praktisch.

8
00:00:15,980 --> 00:00:19,510
Arrays sind eine wirklich fundamentale Daten
Struktur für jede Programmiersprache

9
00:00:19,510 --> 00:00:20,260
dass Sie verwenden.

10
00:00:20,260 --> 00:00:24,450
Und sie sind wirklich sehr, sehr nützlich,
besonders, wie wir sehen werden, in CS 50.

11
00:00:24,450 --> 00:00:27,870
>> Wir verwenden Arrays zu halten
Werte desselben Datentyps

12
00:00:27,870 --> 00:00:29,830
an zusammenhängenden Speicherplätzen.

13
00:00:29,830 --> 00:00:32,430
Das heißt, es ist ein
so können wir Gruppe

14
00:00:32,430 --> 00:00:35,430
ein Haufen von ganzen Zahlen zusammen
Speicher oder eine Gruppe von Zeichen

15
00:00:35,430 --> 00:00:38,270
oder schwimmt im Speicher wirklich
nah zusammen und arbeiten

16
00:00:38,270 --> 00:00:41,930
mit ihnen ohne jede geben
hat seinen eigenen eindeutigen Namen, denen

17
00:00:41,930 --> 00:00:44,500
zu umständlich nach einer Weile.

18
00:00:44,500 --> 00:00:48,130
>> Nun, ein Weg, um Arrays analogize
ist es, zu Ihrem örtlichen Post denken

19
00:00:48,130 --> 00:00:49,000
Büro für eine Sekunde.

20
00:00:49,000 --> 00:00:51,820
So Schritt weg von der Programmierung
und nur die Augen zu schließen

21
00:00:51,820 --> 00:00:54,120
und Visualisierung in Ihrem Verstand
Ihrem örtlichen Postamt.

22
00:00:54,120 --> 00:00:57,160
Normalerweise in den meisten post
Büros, es gibt eine große Bank

23
00:00:57,160 --> 00:01:00,490
ein Postfächer an der Wand.

24
00:01:00,490 --> 00:01:03,510
>> Ein Array ist ein riesiger Block
zusammenhängenden Speicher,

25
00:01:03,510 --> 00:01:06,120
in der gleichen Weise, dass eine E-Mail
Bank in Ihrem Postamt

26
00:01:06,120 --> 00:01:11,230
ist ein großer Raum auf der
Wand der Post.

27
00:01:11,230 --> 00:01:15,750
Arrays haben in kleine unterteilt worden ist,
gleich großen Blöcken von Raum,

28
00:01:15,750 --> 00:01:19,930
von denen jedes eine genannte Element,
auf die gleiche Weise, daß die Wand des Pfostens

29
00:01:19,930 --> 00:01:23,840
Büro hat in kleine unterteilt worden ist,
gleich großen Blöcken von Raum,

30
00:01:23,840 --> 00:01:27,560
dem ein Postfach nennen wir.

31
00:01:27,560 --> 00:01:31,650
Jedes Element des Arrays
speichern eine bestimmte Datenmenge,

32
00:01:31,650 --> 00:01:37,540
so wie jedes Postfach in der Lage ist
um eine bestimmte Menge von Postsendungen zu halten.

33
00:01:37,540 --> 00:01:41,540
>> Was in jedem Element gespeichert werden
das Array-Variablen des gleichen Daten

34
00:01:41,540 --> 00:01:45,300
Typ wie int oder char, nur
wie in Ihrem Postfach,

35
00:01:45,300 --> 00:01:47,300
können Sie nur die Dinge passen
eines ähnlichen Typs,

36
00:01:47,300 --> 00:01:50,430
wie Briefe oder Päckchen.

37
00:01:50,430 --> 00:01:55,050
Schließlich können wir jedes Element zugreifen
das Array direkt nach Indexnummer,

38
00:01:55,050 --> 00:01:59,770
so wie wir unsere Post-Office zugreifen kann
Box von zu wissen, seine Mailbox-Nummer.

39
00:01:59,770 --> 00:02:02,750
Ich hoffe, dass analog
hilft Ihnen, den Kopf zu bekommen

40
00:02:02,750 --> 00:02:05,540
um die Idee des Arrays
Analogisierung etwas anderes

41
00:02:05,540 --> 00:02:08,400
dass Sie wahrscheinlich sind
bereits mit.

42
00:02:08,400 --> 00:02:13,182
>> In C, die Elemente eines Arrays
indiziert ausgehend von 0, nicht 1.

43
00:02:13,182 --> 00:02:14,390
Und das ist wirklich wichtig.

44
00:02:14,390 --> 00:02:18,530
Und in der Tat ist der Grund, warum wir in CS 50,
und warum Informatiker häufig

45
00:02:18,530 --> 00:02:22,150
wird von 0 zu zählen, ist
weil C die Arrays

46
00:02:22,150 --> 00:02:24,660
Indexierung, die stets bei 0 beginnt.

47
00:02:24,660 --> 00:02:28,730
Also, wenn ein Array aus n Elementen,
das erste Element des Arrays

48
00:02:28,730 --> 00:02:32,960
wird bei Index 0 liegt, und
das letzte Element des Arrays

49
00:02:32,960 --> 00:02:36,610
wird bei Index n minus 1 entfernt.

50
00:02:36,610 --> 00:02:43,160
Auch wenn es n Elemente in unserer
Array, ist die letzte Index n minus 1.

51
00:02:43,160 --> 00:02:46,820
>> Also, wenn unser Angebot hat 50 Elemente, die
erste Element bei Index 0 liegt,

52
00:02:46,820 --> 00:02:51,060
und das letzte Element
wird bei Index 49 entfernt.

53
00:02:51,060 --> 00:02:53,940
Leider oder zum Glück,
je nach Perspektive,

54
00:02:53,940 --> 00:02:56,170
C ist hier sehr nachsichtig.

55
00:02:56,170 --> 00:02:59,480
Es wird nicht verhindern, dass Sie
gehen außerhalb der Grenzen des Arrays.

56
00:02:59,480 --> 00:03:03,080
Sie konnten die minus zugreifen
3 Element Ihrer Array

57
00:03:03,080 --> 00:03:07,400
oder das 59. Element des Array,
wenn Ihr Array hat nur 50 Elemente.

58
00:03:07,400 --> 00:03:11,060
Es wird nicht Ihr Programm aus zu stoppen
Kompilieren, aber während der Laufzeit,

59
00:03:11,060 --> 00:03:14,350
Sie stoßen könnten ein
gefürchtete Segmentation Fault

60
00:03:14,350 --> 00:03:17,460
wenn Sie beginnen, Speicher zugreifen
dh außerhalb der Grenzen, was

61
00:03:17,460 --> 00:03:19,260
Sie aufgefordert Ihr Programm, um Ihnen.

62
00:03:19,260 --> 00:03:21,250
Also seien Sie vorsichtig.

63
00:03:21,250 --> 00:03:23,120
>> Was bedeutet ein Array
Erklärung aus?

64
00:03:23,120 --> 00:03:26,940
Wie kommen wir zu codieren eine Reihe ins Leben
wie wir andere variable Code?

65
00:03:26,940 --> 00:03:31,250
Es gibt drei Teile zu einer Anordnung
declaration-- einen Typ, ein Name,

66
00:03:31,250 --> 00:03:31,880
und eine Größe.

67
00:03:31,880 --> 00:03:34,088
Dies ist sehr ähnlich zu einem
Variablendeklaration, die

68
00:03:34,088 --> 00:03:36,970
ist nur ein Typ und ein Name,
wobei die Größe Element

69
00:03:36,970 --> 00:03:39,860
der Spezialfall für ein Array,
denn wir werden immer ein paar von ihnen

70
00:03:39,860 --> 00:03:41,830
gleichzeitig.

71
00:03:41,830 --> 00:03:45,560
>> Also der Typ ist, welche Art von Variablen, die Sie
soll jedes Element der Anordnung ist.

72
00:03:45,560 --> 00:03:47,150
Sie wollen, dass es auf ein Array von ganzen Zahlen?

73
00:03:47,150 --> 00:03:49,010
Dann sollten Sie Ihre Datentyp int sein.

74
00:03:49,010 --> 00:03:51,760
Haben Sie wollen, dass es eine sein,
Array von Double oder schwimmt?

75
00:03:51,760 --> 00:03:54,545
Datentyp sollte doppelt so hoch sein oder schweben.

76
00:03:54,545 --> 00:03:56,420
Der Name ist, was Sie
möchten Ihre Array nennen.

77
00:03:56,420 --> 00:04:00,970
Was sagen Sie zu diesen Riesen nennen wollen
Bank von ganzen Zahlen oder Schwimmern oder chars

78
00:04:00,970 --> 00:04:03,250
oder Doppel, oder was auch immer Sie haben?

79
00:04:03,250 --> 00:04:04,700
Was wollen Sie es nennen?

80
00:04:04,700 --> 00:04:06,110
Ziemlich selbsterklärend.

81
00:04:06,110 --> 00:04:08,610
>> Schließlich Größe, die geht
Innenseite der eckigen Klammern,

82
00:04:08,610 --> 00:04:12,180
ist, wie viele Elemente würden Sie,
wie Ihr Array enthalten.

83
00:04:12,180 --> 00:04:13,530
Wie viele Zahlen wollen Sie?

84
00:04:13,530 --> 00:04:15,570
Wie viele Schwimmer wollen Sie?

85
00:04:15,570 --> 00:04:19,070
>> So zum Beispiel, int Schülergrade 40.

86
00:04:19,070 --> 00:04:26,020
Dies erklärt, ein Array namens Studenten
Typen, die aus 40 Zahlen besteht.

87
00:04:26,020 --> 00:04:28,180
Ziemlich selbsterklärend, hoffe ich.

88
00:04:28,180 --> 00:04:29,330
Hier ein weiteres Beispiel.

89
00:04:29,330 --> 00:04:31,560
Doppel Menü Preise 8.

90
00:04:31,560 --> 00:04:34,610
Dadurch entsteht ein Array mit dem Namen
Menüpreise, die aus

91
00:04:34,610 --> 00:04:38,300
Platz im Speicher für acht Doppelzimmer.

92
00:04:38,300 --> 00:04:42,000

93
00:04:42,000 --> 00:04:45,750
>> Wenn Sie jedes Element zu denken
von einem Array vom Typ Datentyp,

94
00:04:45,750 --> 00:04:49,860
so zum Beispiel ein einzelnes Element
ein Array vom Typ int, die gleiche Weise

95
00:04:49,860 --> 00:04:52,770
würde jedes anderen denken
Variable vom Typ int,

96
00:04:52,770 --> 00:04:56,440
alle bekannten Operationen, dass wir
zuvor in den Operationen diskutiert

97
00:04:56,440 --> 00:04:58,270
Video wird sinnvoll.

98
00:04:58,270 --> 00:05:01,620
So, hier konnten wir ein Array deklarieren
von Booleans genannte Wahrheitstabelle,

99
00:05:01,620 --> 00:05:05,590
der aus Raum für 10 Booleans.

100
00:05:05,590 --> 00:05:09,650
>> Und dann, so wie wir nur zuweisen könnte
ein Wert, der jedem anderen Variablen des Typs

101
00:05:09,650 --> 00:05:13,470
Boolean, könnten wir etwas sagen
wie Wahrheitstabelle eckige Klammer

102
00:05:13,470 --> 00:05:18,040
2, das ist, wie wir zeigen,
das Element der Wahrheitstabelle?

103
00:05:18,040 --> 00:05:20,350
Das dritte Element der
Wahrheitstabelle, denn denken Sie daran,

104
00:05:20,350 --> 00:05:21,800
wir sind von 0 zu zählen.

105
00:05:21,800 --> 00:05:25,690
Also das ist, wie wir zeigen die
dritte Element der Wahrheitstabelle.

106
00:05:25,690 --> 00:05:28,680
Wahrheitstabelle 2 ist gleich falsch,
so wie wir declare-- könnte

107
00:05:28,680 --> 00:05:33,560
oder wir könnten zuzuweisen, statt jede
Typ Boolean Variable falsch sein.

108
00:05:33,560 --> 00:05:35,050
>> Wir können auch in Bedingungen verwenden.

109
00:05:35,050 --> 00:05:39,000
if (Wahrheitstabelle 7 ==
true), das heißt,

110
00:05:39,000 --> 00:05:42,370
wenn das achte Element
der Wahrheitstabelle ist wahr,

111
00:05:42,370 --> 00:05:46,760
vielleicht werden wir um eine Nachricht zu drucken möchten
dem Benutzer, printf ("TRUE! n") ;.

112
00:05:46,760 --> 00:05:50,290
Das bewirkt, dass wir sagen, Wahrheitstabelle
10 ist gleich wahr, oder?

113
00:05:50,290 --> 00:05:53,590
Nun, ich kann, aber es ist ziemlich
gefährlich, weil daran erinnern,

114
00:05:53,590 --> 00:05:56,260
Wir haben eine Reihe von 10 Booleans.

115
00:05:56,260 --> 00:06:02,340
So der höchste Index, der die
Compiler hat uns ist 9.

116
00:06:02,340 --> 00:06:06,010
>> Dieses Programm wird kompiliert, aber
wenn etwas anderes im Speicher

117
00:06:06,010 --> 00:06:09,110
vorhanden ist, wo wir
erwarten Wahrheitstabelle 10 zu gehen,

118
00:06:09,110 --> 00:06:13,980
wir könnten einen Segmentation Fault zu leiden. Wir
vielleicht weg mit ihm, aber im Allgemeinen,

119
00:06:13,980 --> 00:06:14,710
ziemlich gefährlich.

120
00:06:14,710 --> 00:06:19,759
Also, was ich hier mache ist legal C,
aber nicht notwendigerweise der beste Zug.

121
00:06:19,759 --> 00:06:22,300
Nun, wenn Sie zu erklären und
gleichzeitig initialisiert ein Array,

122
00:06:22,300 --> 00:06:23,960
gibt es eigentlich ein ziemlich
spezielle Syntax, die Sie

123
00:06:23,960 --> 00:06:26,250
verwenden können, um füllen Sie das Array
mit ihren Startwerten.

124
00:06:26,250 --> 00:06:30,130
Es kann mühsam zu bekommen
erklären, eine Reihe von Größe 100,

125
00:06:30,130 --> 00:06:33,430
und dann haben zu sagen, Element 0
entspricht dies; Element 1 entspricht dies;

126
00:06:33,430 --> 00:06:34,850
Element 2 entspricht, daß.

127
00:06:34,850 --> 00:06:36,370
Was ist der Sinn, nicht wahr?

128
00:06:36,370 --> 00:06:39,470
>> Wenn es ein kleines Array, Sie
könnte so etwas wie dies zu tun.

129
00:06:39,470 --> 00:06:44,360
Bool Wahrheitstabelle 3 gleich öffnen
geschweifte Klammer und dann Komma

130
00:06:44,360 --> 00:06:48,060
trennen Sie die Liste der Elemente
dass Sie in dem Feld setzen möchten.

131
00:06:48,060 --> 00:06:50,520
Dann schließen Sie geschweifte Klammer Semikolon.

132
00:06:50,520 --> 00:06:53,910
Dies schafft eine Anordnung von
Größe drei genannten Wahrheitstabelle,

133
00:06:53,910 --> 00:06:56,090
mit Elementen false, true, und wahr.

134
00:06:56,090 --> 00:06:59,270
Und in der Tat ist die Instanziierung
Syntax Ich habe hier

135
00:06:59,270 --> 00:07:03,350
genau das gleiche wie das zu tun
Einzelelementsyntax unten.

136
00:07:03,350 --> 00:07:09,380
Diese beiden Arten der Codierung daher
erzeugen die exakt gleiche Array.

137
00:07:09,380 --> 00:07:11,740
>> In ähnlicher Weise haben wir durchlaufen könnte
über alle Elemente

138
00:07:11,740 --> 00:07:15,400
von einem Array mit einer Schleife, die in
Tatsächlich ist ein sehr stark empfohlen

139
00:07:15,400 --> 00:07:16,790
at-home Übung.

140
00:07:16,790 --> 00:07:20,720
Wie kann man ein Array zu erstellen
von 100 Zahlen, wobei

141
00:07:20,720 --> 00:07:23,477
jedes Element des Arrays ist sein Index?

142
00:07:23,477 --> 00:07:26,560
So zum Beispiel, haben wir eine Reihe von 100
ganze Zahlen sind, und in dem ersten Element,

143
00:07:26,560 --> 00:07:27,790
wir wollen, auf 0 gesetzt.

144
00:07:27,790 --> 00:07:29,810
In dem zweiten Element, möchten wir 1 gesetzt.

145
00:07:29,810 --> 00:07:33,319
Im dritten Element, wir wollen
zu 2 gesetzt; und so weiter und so fort.

146
00:07:33,319 --> 00:07:35,360
Das ist eine wirklich gute
at-home Übung, um das zu tun.

147
00:07:35,360 --> 00:07:38,190

148
00:07:38,190 --> 00:07:40,220
>> Hier ist es nicht aussieht
wie zu viel hat sich geändert.

149
00:07:40,220 --> 00:07:44,170
Aber beachten Sie, dass zwischen dem
eckige Klammern, diesmal,

150
00:07:44,170 --> 00:07:45,830
Ich habe tatsächlich verzichtet die Nummer.

151
00:07:45,830 --> 00:07:48,000
Wenn Sie mit diesem sehr
Sonder Instanziierung

152
00:07:48,000 --> 00:07:50,380
Syntax, um eine zu erstellen
Arrays, die Sie tatsächlich nicht

153
00:07:50,380 --> 00:07:53,491
müssen die Größe anzuzeigen
des Arrays voraus.

154
00:07:53,491 --> 00:07:55,740
Der Compiler ist intelligent genug,
tatsächlich zu wissen, dass Sie

155
00:07:55,740 --> 00:07:58,980
möchten ein Array der Größe 3,
weil Sie drei Elemente setzen

156
00:07:58,980 --> 00:08:00,640
auf der rechten Seite des Gleichheitszeichens.

157
00:08:00,640 --> 00:08:04,140
Wenn Sie vier gesetzt hatte, sie hätte
gegeben Sie eine Wahrheitstabelle der Größe vier;

158
00:08:04,140 --> 00:08:06,270
und so weiter und so fort.

159
00:08:06,270 --> 00:08:09,380
>> Arrays sind nicht auf eine einzige beschränkt
Dimension, die ziemlich cool ist.

160
00:08:09,380 --> 00:08:12,000
Sie können tatsächlich so viele
Seitenbezeich wie Sie möchten.

161
00:08:12,000 --> 00:08:16,470
So zum Beispiel, wenn Sie erstellen möchten
ein Forum für das Spiel Schlachtschiff, das,

162
00:08:16,470 --> 00:08:20,910
wenn Sie jemals gespielt wird, ist ein Spiel, das ist
mit Zapfen auf der 10 mal 10 Gitter gespielt,

163
00:08:20,910 --> 00:08:22,450
Sie könnte ein Array wie folgt erstellen.

164
00:08:22,450 --> 00:08:26,030
Man könnte sagen, Bool
Schlachtschiff eckige Klammer 10

165
00:08:26,030 --> 00:08:29,590
geschlossene eckige Klammer Quadrat
Klammer 10 geschlossen eckige Klammer.

166
00:08:29,590 --> 00:08:32,710
>> Und dann können Sie wählen,
interpretieren dies im Kopf als 10

167
00:08:32,710 --> 00:08:35,576
von 10 Raster von Zellen.

168
00:08:35,576 --> 00:08:37,409
Nun in der Tat, in einem Speicher,
es funktioniert wirklich einfach

169
00:08:37,409 --> 00:08:42,440
bleiben ein 100-Element,
eindimensionale Array.

170
00:08:42,440 --> 00:08:46,070
Und dies in der Tat, geht für, wenn Sie
haben drei Dimensionen oder vier oder fünf.

171
00:08:46,070 --> 00:08:49,420
Es ist wirklich einfach nicht vermehren
alle der indices--

172
00:08:49,420 --> 00:08:51,130
oder alle der Größe
specifiers-- zusammen,

173
00:08:51,130 --> 00:08:53,480
und du nur eine eindimensionale
Array dieser Größe.

174
00:08:53,480 --> 00:08:57,090
>> Aber in Bezug auf Organisation und
Visualisierung und die menschliche Wahrnehmung,

175
00:08:57,090 --> 00:08:59,240
es viel einfacher sein kann,
mit einem Gitter zu arbeiten

176
00:08:59,240 --> 00:09:02,980
wenn Sie an einem Spiel arbeitest
wie Tic-Tac-Toe oder Schlachtschiff,

177
00:09:02,980 --> 00:09:05,179
oder etwas ähnliches.

178
00:09:05,179 --> 00:09:06,970
Es ist eine große Abstraktion,
anstatt

179
00:09:06,970 --> 00:09:09,340
um eine Tic-Tac-Toe denken
Board als eine Linie von neun

180
00:09:09,340 --> 00:09:13,810
Quadrate oder ein Schlachtschiff Brett
als eine Linie von 100 Plätzen.

181
00:09:13,810 --> 00:09:16,010
Ein 10 x 10 Raster oder einem Drei
um drei Gitter ist wahrscheinlich

182
00:09:16,010 --> 00:09:17,225
viel mehr leicht zu erkennen.

183
00:09:17,225 --> 00:09:19,820

184
00:09:19,820 --> 00:09:22,280
>> Nun, etwas wirklich
Wichtiges über Arrays.

185
00:09:22,280 --> 00:09:25,950
Wir können jede einzelne Behandlung
Element des Arrays als eine Variable.

186
00:09:25,950 --> 00:09:27,700
Wir sahen, dass früher
als wir die Zuordnung

187
00:09:27,700 --> 00:09:32,240
den Wert True, um bestimmte Booleans
oder testen sie in conditionals.

188
00:09:32,240 --> 00:09:35,960
Aber wir können nicht behandeln gesamte
Arrays sich als Variablen.

189
00:09:35,960 --> 00:09:41,760
Wir können nicht, zum Beispiel, weisen Sie einem Array
zu einem anderen Array mit dem Zuweisungs

190
00:09:41,760 --> 00:09:42,930
Operator.

191
00:09:42,930 --> 00:09:44,640
Es ist nicht legal C.

192
00:09:44,640 --> 00:09:47,920
>> Wenn wir wollen, was für example--
wir in diesem Beispiel tut werden

193
00:09:47,920 --> 00:09:50,200
wäre eine Anordnung in eine andere zu kopieren.

194
00:09:50,200 --> 00:09:53,810
Wenn wir, dass wir eigentlich machen wollen
müssen Sie eine Schleife über die zu kopier

195
00:09:53,810 --> 00:09:56,550
jedes Einzelelement eine zu einem Zeitpunkt.

196
00:09:56,550 --> 00:09:58,700
Ich weiß, es ist ein wenig zeitaufwendig.

197
00:09:58,700 --> 00:10:04,022
>> So zum Beispiel, wenn wir diese paar
von Zeilen Code, würde das funktionieren?

198
00:10:04,022 --> 00:10:05,230
Nun, nein, wäre es nicht, oder?

199
00:10:05,230 --> 00:10:07,860
Da wir versuchen,
um Nahrung zu bar zuweisen.

200
00:10:07,860 --> 00:10:09,860
Das ist nicht zur Arbeit gehen,
denn es ist ein Array,

201
00:10:09,860 --> 00:10:13,130
und wir gerade beschrieben
, dass das nicht legal C.

202
00:10:13,130 --> 00:10:15,580
>> Stattdessen, wenn wir wollen
den Inhalt von Lebensmitteln kopieren

203
00:10:15,580 --> 00:10:18,070
in bar, was was ist
wir versuchen, hier zu tun,

204
00:10:18,070 --> 00:10:19,970
wir eine Syntax wie folgt benötigen würde.

205
00:10:19,970 --> 00:10:24,170
Wir haben eine for-Schleife das geht
von J gleich 0 bis 5,

206
00:10:24,170 --> 00:10:28,390
und wir inkrementieren J an jeder Iteration
die Schleife und weisen Elemente so.

207
00:10:28,390 --> 00:10:33,360
Dies würde in bar auch zur Folge haben
wobei ein, zwei, drei, vier, fünf,

208
00:10:33,360 --> 00:10:36,730
aber wir wollen es dieses sehr zu tun haben
langsame Element für Element Weise

209
00:10:36,730 --> 00:10:40,009
statt nur um
Kopieren des gesamten Arrays.

210
00:10:40,009 --> 00:10:42,050
In anderen Programmiersprachen
Sprachen, modernere,

211
00:10:42,050 --> 00:10:45,610
Sie können in der Tat tun, nur
So einfach ist gleich Syntax.

212
00:10:45,610 --> 00:10:49,620
Aber C, leider sind wir
nicht erlaubt, das zu tun.

213
00:10:49,620 --> 00:10:52,026
>> Jetzt gibt es einen weiteren
Sache, die ich erwähnen möchte,

214
00:10:52,026 --> 00:10:54,650
über Arrays, die ein wenig sein kann,
etwas schwierig das erste Mal

215
00:10:54,650 --> 00:10:55,990
mit ihnen arbeiten.

216
00:10:55,990 --> 00:10:59,860
Wir in einem Video diskutiert
über den Geltungsbereich von Variablen,

217
00:10:59,860 --> 00:11:04,940
dass die meisten Variablen in C, wenn Sie anrufen
sie in Funktionen als Wert übergeben.

218
00:11:04,940 --> 00:11:08,620
Erinnerst du dich, was es bedeutet,
um etwas von Wert zu übergeben?

219
00:11:08,620 --> 00:11:12,570
Es bedeutet, wir machen eine Kopie der
Variable, die in weitergegeben.

220
00:11:12,570 --> 00:11:16,290
Die aufgerufene Funktion die Funktion
daß angenommen, der das variable,

221
00:11:16,290 --> 00:11:17,730
nicht die Variable selbst zu bekommen.

222
00:11:17,730 --> 00:11:20,850
Es hat seinen eigenen lokalen
Kopie davon, mit zu arbeiten.

223
00:11:20,850 --> 00:11:24,070
>> Arrays, natürlich, zu tun
dieser Regel nicht folgt.

224
00:11:24,070 --> 00:11:27,600
Vielmehr, was wir nennen dies
wird Übergabe als Referenz.

225
00:11:27,600 --> 00:11:31,360
Der Angerufene tatsächlich
hat empfangen das Array.

226
00:11:31,360 --> 00:11:34,207
Sie empfängt ihre
eigene lokale Kopie davon.

227
00:11:34,207 --> 00:11:36,040
Und wenn Sie darüber nachdenken,
es, ist dies sinnvoll.

228
00:11:36,040 --> 00:11:39,750
Wenn Arrays sind wirklich groß, es
nimmt so viel Zeit und Mühe

229
00:11:39,750 --> 00:11:44,470
eine Kopie eines Arrays von machen
100 oder 1.000 oder 10.000 Elementen,

230
00:11:44,470 --> 00:11:48,290
dass es nicht wert für ein
Funktion, um eine Kopie davon zu erhalten,

231
00:11:48,290 --> 00:11:51,037
einige Arbeit mit ihm, und dann
nur mit der Kopie durchgeführt werden;

232
00:11:51,037 --> 00:11:53,120
es muss nicht zu haben,
sie hängen mehr da.

233
00:11:53,120 --> 00:11:54,710
>> Da Arrays sind einige
sperrig und umständlich,

234
00:11:54,710 --> 00:11:56,001
wir gerade vorbeiziehen Referenz.

235
00:11:56,001 --> 00:12:01,210
Wir vertrauen darauf, genau das zu Funktions
zu, nicht alles zu brechen.

236
00:12:01,210 --> 00:12:03,010
So dass es tatsächlich das Array.

237
00:12:03,010 --> 00:12:05,290
Es wird nicht seine eigene lokale Kopie davon.

238
00:12:05,290 --> 00:12:07,170
>> Also, was bedeutet das,
Dann, wenn der Angerufene

239
00:12:07,170 --> 00:12:08,970
manipuliert Elemente des Arrays?

240
00:12:08,970 --> 00:12:10,780
Was ist passiert?

241
00:12:10,780 --> 00:12:13,210
Denn jetzt werden wir beschönigen
über warum genau dieses

242
00:12:13,210 --> 00:12:15,320
der Fall ist, warum Arrays
werden als Referenz übergeben

243
00:12:15,320 --> 00:12:17,810
und alles andere wird als Wert übergeben.

244
00:12:17,810 --> 00:12:20,470
Aber ich verspreche Ihnen, werden wir
zurückzukehren und geben Ihnen die Antwort

245
00:12:20,470 --> 00:12:23,750
Um dies in einer späteren Video.

246
00:12:23,750 --> 00:12:28,110
>> Hier ist eine weitere Übung für Sie
bevor wir einpacken Dinge auf Arrays.

247
00:12:28,110 --> 00:12:31,400
Die Reihe von Code hier, das ist,
nicht besonders guten Stil,

248
00:12:31,400 --> 00:12:33,400
nur Ich werde diese Einschränkung zu machen.

249
00:12:33,400 --> 00:12:36,660
Es gibt keine Kommentare hier,
was ziemlich schlechte Form.

250
00:12:36,660 --> 00:12:39,750
Aber es ist nur, weil ich sein wollte
in der Lage, alles, was auf den Bildschirm passen.

251
00:12:39,750 --> 00:12:44,360
>> An der Spitze, können Sie sehen, dass ich
zwei Funktionsdeklarationen für Set-Array

252
00:12:44,360 --> 00:12:45,820
und setzen int.

253
00:12:45,820 --> 00:12:49,680
Set Array dauert offenbar ein Array
von vier ganzen Zahlen als ihre Eingabe.

254
00:12:49,680 --> 00:12:52,767
Und setzen int anscheinend dauert
eine einzelne ganze Zahl als Eingabe.

255
00:12:52,767 --> 00:12:54,350
Aber beide haben keine ausgegeben.

256
00:12:54,350 --> 00:12:57,689
Die Ausgabe, die Rückkehr
Typ, der jeder ist nichtig.

257
00:12:57,689 --> 00:12:59,480
In Main, haben wir einen
paar Zeilen Code.

258
00:12:59,480 --> 00:13:02,730
Wir erklären, eine Integer-Variable
genannt A und weisen Sie ihm den Wert 10.

259
00:13:02,730 --> 00:13:07,080
Wir erklären, eine Reihe von vier Ganzzahlen
genannt B und ordnen Sie die Elemente 0, 1,

260
00:13:07,080 --> 00:13:08,730
2 und 3.

261
00:13:08,730 --> 00:13:12,190
Dann, einen Anruf zu setzen müssen wir
int und ein Aufruf zum Array festlegen.

262
00:13:12,190 --> 00:13:15,910
Die Definitionen der Satz-Array und Set
int sind da unten, am Boden.

263
00:13:15,910 --> 00:13:17,640
>> Und so wieder, bitte ich Sie, die Frage.

264
00:13:17,640 --> 00:13:20,770
Was wird ausgedruckt
Hier am Ende der Main?

265
00:13:20,770 --> 00:13:23,020
Es gibt einen Ausdruck col. Ich bin
Ausdrucken von zwei ganzen Zahlen.

266
00:13:23,020 --> 00:13:28,010
Ich Ausdrucken der Inhalte von A und
der Inhalt des B eckige Klammer 0.

267
00:13:28,010 --> 00:13:29,880
Halten Sie das Video hier und nehmen Sie eine Minute.

268
00:13:29,880 --> 00:13:35,482
Kannst du herausfinden, was diese
Funktion wird am Ende zu drucken?

269
00:13:35,482 --> 00:13:38,190
Hoffentlich, wenn Sie sich erinnern, die
Unterscheidung zwischen vorbei Wert

270
00:13:38,190 --> 00:13:41,680
und Übergabe als Referenz, diese
Problem war nicht allzu schwierig für Sie.

271
00:13:41,680 --> 00:13:44,130
Und die Antwort würden Sie,
haben festgestellt, ist diese.

272
00:13:44,130 --> 00:13:47,660
Wenn Sie sich nicht, um wirklich sicher,
, warum das der Fall ist, nehmen Sie einen zweiten,

273
00:13:47,660 --> 00:13:50,620
gehen Sie zurück, zu überprüfen, was ich gerade war,
Diskussion über die Weitergabe Arrays

274
00:13:50,620 --> 00:13:53,450
durch Bezugnahme versus vorbei
andere Variablen nach Wert,

275
00:13:53,450 --> 00:13:56,680
und hoffentlich werden es machen
ein wenig mehr Sinn.

276
00:13:56,680 --> 00:13:59,760
>> Ich bin Doug Lloyd, und dies ist CS50.

277
00:13:59,760 --> 00:14:01,467