[Powered by Google Translate] Lassen Sie uns über Arrays.
Also warum sollten wir jemals wollen Arrays verwenden?
Nun lassen Sie uns sagen, Sie haben ein Programm, das bis 5 Studentenausweise speichern muss.
Es könnte scheinen vernünftig zu 5 separate Variablen haben.
Gründen, die wir in einer etwas sehen werden, werden wir anfangen zu zählen von 0.
Die Variablen müssen wir werden int id0, int id1, und so weiter.
Jede Logik wollen wir auf einem Student-ID durchführen müssen kopiert und eingefügt werden
Für jede dieser Studentenausweise.
Wenn wir wollen, zu prüfen, welche die Schüler in CS50 werden passieren,
Wir müssen zunächst prüfen, ob id0 stellt den Studenten im Kurs.
Dann das gleiche für die nächsten Schüler zu tun, müssen wir zu kopieren und den Code für id0
und ersetzen Sie alle Vorkommen von id0 mit id1 und so weiter für id2, 3 und 4.
>> Sobald Sie hören, dass wir zu kopieren und müssen,
Sie sollten anfangen, darüber nachzudenken, dass es eine bessere Lösung.
Was nun, wenn Sie merken, Sie brauchen keine 5 Studentenausweise, sondern 7?
Sie müssen zurück in den Quellcode und fügen Sie in einem ID5, eine id6,
und kopieren Sie die Logik für die Überprüfung, ob die IDs der Klasse für diese 2 neue IDs gehören.
Es gibt nichts verbindet all diese ID zusammen, und so gibt es keine Möglichkeit zu fragen
das Programm dies für IDs 0 do bis 6.
Nun merkt man, Sie haben 100 Schüler-IDs.
Es beginnt zu scheinen weniger als ideal, um gesondert zu erklären, jede dieser IDs,
und kopieren Sie jede Logik für die neuen IDs.
Aber vielleicht sind wir entschlossen, und wir tun es für alle 100 Schüler.
Aber was, wenn Sie nicht wissen, wie viele Studenten gibt es tatsächlich?
Es sind nur einige n Studenten und Ihr Programm den Benutzer, was das n fragen.
Uh oh. Dies ist nicht sehr gut zu funktionieren.
Ihr Programm funktioniert nur für eine Konstante Zahl der Studierenden.
>> Die Lösung all dieser Probleme ist die Schönheit des Arrays.
Also, was ist ein Array?
In einigen Programmiersprachen ein Array-Typ könnten ein bisschen mehr zu tun,
aber hier werden wir auf der Basis array Datenstruktur zu konzentrieren, wie Sie es in C. Stilen
Ein Array ist nur ein großer Block von Speicher. Das war's.
Wenn wir sagen, wir haben eine Reihe von 10 Zahlen, das bedeutet nur, wir haben einige Block
des Speichers, der groß genug ist, um 10 separate Zahlen halten.
Unter der Annahme, dass eine ganze Zahl 4 Bytes ist, bedeutet dies, dass ein Array von 10 Ganzzahlen
ist ein zusammenhängender Block von 40 Bytes im Speicher.
Selbst wenn Sie mehrdimensionale Arrays, die wir nicht in hier gehen wird,
es ist immer noch nur ein großer Block von Speicher.
Die mehrdimensionale Notation ist nur eine Bequemlichkeit.
Wenn Sie eine 3 x 3 mehrdimensionales Array von ganzen Zahlen,
dann wird Ihr Programm wirklich nur behandeln Sie dies als einen großen Block von 36 Bytes.
Die Gesamtzahl der ganzen Zahlen gleich 3 mal 3, und jede ganze Zahl aufnimmt 4 Bytes.
>> Werfen wir einen Blick auf ein einfaches Beispiel.
Wir können hier sehen 2 verschiedene Arten zu erklären Arrays.
Wir müssen davon 1 auskommentieren für das Programm zu kompilieren
da wir erklären x zweimal.
Wir werden einen Blick auf einige der Unterschiede zwischen diesen 2 Arten von Deklarationen in einem Bit.
Beide Zeilen deklarieren ein Array der Größe N,
wo wir # define N wie 10.
Wir könnten genauso gut die Benutzer für eine positive ganze Zahl gebeten haben
und verwendet diese Zahl als eine Anzahl von Elementen in unserem Array.
Wie unsere Studentenausweis beispielsweise vor, ist dies eine Art, wie erklären 10 vollständig getrennte
imaginären Variablen; x0, x1, x2, und so weiter bis xN-1.
Ignorieren Sie die Zeilen, wo wir das Array deklarieren, bemerken die eckigen Klammern intakt
innerhalb der for-Schleifen.
Wenn wir etwas schreiben x [3], die ich genauso x Halterung 3 zu lesen,
Sie können daran denken möchte fragen für die imaginäre x3.
Bemerken als bei einer Anordnung der Größe N, bedeutet dies, dass die Anzahl innerhalb der Klammern,
was wir den Index aufrufen, können alles von 0 bis N-1 sein,
was eine Gesamtzahl von N-Indizes.
>> Um darüber, wie diese tatsächlich funktioniert denke
daran erinnern, dass das Array ein großer Block von Speicher ist.
Unter der Annahme, dass eine ganze Zahl 4 Bytes ist, ist die gesamte Anordnung eine 40-Byte x Speicherblock.
X0, so bezieht sich auf den ersten vier Bytes des Blocks.
X [1] bezieht sich auf die nächsten 4 Bytes und so weiter.
Dies bedeutet, dass der Beginn der x all das Programm jemals braucht, um zu verfolgen ist.
Wenn Sie x [400] verwenden wollen, dann wird das Programm weiß, dass dies gleichwertig ist
um nur 1.600 Bytes nach dem Start von x.
Woher bekommen wir 1.600 Bytes aus? Es ist nur 400 mal 4 Bytes pro Zahl.
>> Bevor wir fortfahren, ist es sehr wichtig zu erkennen, dass in C
es gibt keine Durchsetzung des Index, die wir in dem Array.
Unser großer Block ist nur 10 Zahlen lang, aber nichts wird uns anschreien, wenn wir x [20] schreiben
oder sogar x [-5].
Der Index hat noch nicht einmal eine Zahl sein.
Es kann jede beliebige Ausdruck sein.
Im Programm verwenden wir die Variable i von der for-Schleife Index im Array.
Dies ist eine sehr häufige Muster, eine Schleife von i = 0 auf die Länge des Arrays,
und dann unter Verwendung von i als Index für das Array.
Auf diese Weise können effektiv Schleife über das gesamte Array,
und Sie können entweder an jeder Stelle in dem Array zuweisen oder es für einige Berechnung.
>> In der ersten for-Schleife beginnt i bei 0,
und so wird es in die 0 Punkt in dem Array, der Wert 0 mal 2 zuordnen.
Dann i-Schritten, und wir weisen Sie den ersten Platz in der Reihe der Wert 1 mal 2.
Dann i Schritten wieder und so weiter, bis wir zuzuweisen bis N-1 in dem Array zu positionieren
der Wert N-1 mal 2.
So haben wir ein Array mit den ersten 10 geraden Zahlen erstellt.
Vielleicht gleicht hätte ein bisschen besser Namen für die Variable als x haben,
aber das würde die Dinge verschenkt haben.
Die zweite for-Schleife dann nur druckt die Werte, die wir bereits in der Array gespeichert.
>> Lassen Sie uns versuchen, das Programm mit beiden Arten von Array-Deklarationen
und werfen Sie einen Blick auf die Ausgabe des Programms.
Soweit wir sehen können, verhält sich das Programm auf die gleiche Weise für beide Arten von Erklärungen.
Lassen Sie uns auch einen Blick auf, was passiert, wenn wir die erste Schleife ändern, um nicht auf N zu stoppen
sondern sagen, 10.000.
Weg über das Ende des Arrays.
Oops. Vielleicht haben Sie das schon mal gesehen.
Eine Segmentation Fault bedeutet, dass Ihr Programm ist abgestürzt.
Sie sehen, beginnen diese, wenn Sie Bereiche des Arbeitsspeichers Sie nicht zu berühren berühren.
Hier sprechen wir 10.000 Plätze jenseits der Beginn der x,
was offenbar ist ein Ort in Erinnerung, die wir nicht zu berühren.
So sind die meisten von uns wahrscheinlich nicht versehentlich 10.000 anstelle von N,
aber was, wenn wir etwas subtiler tun, wie gesagt write weniger als oder gleich N
in der for-Schleife Zustand, im Gegensatz zu weniger als N.
Erinnern, dass ein Array nur Indices von 0 bis N-1,
was bedeutet, dass Index N über das Ende des Arrays ist.
Das Programm kann in diesem Fall nicht abstürzen, aber es ist noch ein Fehler.
Tatsächlich ist dieser Fehler so häufig, dass es seinen eigenen Namen hat,
eine durch 1 Fehler.
>> Das ist es für die Grundlagen.
Also, was sind die wichtigsten Unterschiede zwischen den 2 Arten von Array-Deklarationen?
Ein Unterschied ist, wo das große Block des Speichers geht.
In der ersten Erklärung, die ich rufe die Halterung-Array-Typ,
obwohl dies keineswegs herkömmlichen Namen,
es wird auf den Stapel.
Während in der zweiten, die ich den Zeiger-Array-Typ nenne, wird es auf dem Heap zu gehen.
Dies bedeutet, dass, wenn die Funktion zurückkehrt, die Halterung Array wird automatisch freigegeben werden,
Erwägung, müssen Sie explicitily rufen die Zeigerfelds kostenlos
sonst haben Sie einen Speicherverlust.
Zusätzlich ist die Halterung Array nicht eigentlich eine Variable.
Dies ist wichtig. Es ist nur ein Symbol.
Sie können es als eine Konstante, die der Compiler wählt für Sie denken.
Dies bedeutet, dass wir nicht etwas tun, wie x + + mit dem Bügel Art,
obwohl dies durchaus möglich, mit dem Zeiger-Typ.
>> Der Zeiger-Typ ist eine Variable.
Für die Zeiger-Typ, wir haben 2 separate Blöcke des Speichers.
Die Variable x selbst wird in dem Stapel abgelegt und ist nur einen einzigen Zeiger,
aber der große Block des Speichers auf der Halde abgelegt.
Die Variable x auf dem Stack speichert nur die Adresse
der großen Block von Speicher auf dem Heap.
Eine Folge davon ist, mit der Größe des Operators.
Wenn Sie die Größe der Halterung array fragen, es wird Ihnen die Größe des großen Block des Speichers,
so etwas wie 40 Bytes,
aber wenn Sie fragen nach der Größe des Zeigers Array-Typ,
es wird Ihnen die Größe der Variablen x selbst, die auf dem Gerät ist wahrscheinlich nur 4 Byte.
Verwendung der Zeiger-Array-Typ, ist es unmöglich, direkt fragen
die Größe des großen Speicherblock.
Dies ist in der Regel nicht viel von einer Einschränkung dar, da wir wollen, sehr selten die Größe
der große Block des Speichers, und wir können in der Regel berechnen, wenn wir es brauchen.
>> Schließlich passiert die Halterung array, um uns mit einer Verknüpfung zur Initialisierung eines Arrays bereitzustellen.
Lassen Sie uns sehen, wie wir die ersten 10 geraden Zahlen mit der Tastenkombination initilization schreiben.
Mit dem Zeiger-Array, gibt es nicht eine Möglichkeit, eine Verknüpfung wie dies zu tun.
Dies ist nur eine Einführung, was man mit Arrays zu tun.
Sie zeigen sich in fast jedem Programm, das Sie schreiben.
Hoffentlich können Sie jetzt einen besseren Weg die Studentenausweise beispielsweise
vom Beginn des Videos.
>> Mein Name ist Rob Bowden, und dies ist CS50.