[Powered by Google Translate] Lassen Sie uns über Strukturen sprechen.
Strukturen bieten uns einen Weg, um eine Reihe von Variablen gruppieren
in ein schönes Paket.
Es ist wohl am einfachsten, um ein Beispiel sofort sehen,
so sagen wir struct,
dann öffnenden geschweiften Klammer,
und in dieser Struktur, wir haben einen int Alter,
a char * name,
und das ist es.
Es mag mit einem Semikolon komisch nach einer geschweiften Klammer,
aber es ist in der Tat notwendig mit Strukturen.
Jede gültige Typ kann innerhalb des struct-Definition gehen.
Hier haben wir ein int und char * verwendet,
Sie können aber auch ein Array, von, sagen wir, 100 Elemente
oder sogar eine andere Struktur.
Wenn Sie mit Strukturen in C,
Sie erstellen neue Arten
aus einer Sammlung von anderen Typen.
Hier machen wir eine neue Art
aus einer ganzen Zahl und einer char *.
Wie wir später sehen werden, eine Struktur geben
ist in vielerlei Hinsicht äquivalent zu einem anderen Typ, den Sie gewohnt sind.
Normalerweise werde ich vergleichen, wie ein struct-Typ
ist ähnlich einer Integer-Typ.
Während der Code schrieben wir gilt C,
es ist nicht sehr nützlich,
und Klang wird uns eine Warnung.
Erinnere dich, wie Strukturen und ihre ähnlich sind?
Nun, wir im Grunde nur gesagt
int,
was nicht sehr hilfreich Linie.
Lassen Sie uns also tatsächlich eine Variable dieses Typs
indem sie ihm einen Namen vor dem Semikolon.
Wir rufen die Variable Schüler.
Jetzt haben wir eine Variable deklariert genannte Student
mit der Art der Struktur gegeben.
Wie reagieren wir auf die Variablen innerhalb der Struktur zu bekommen?
Technisch sind die Namen für diese Variablen
Mitglieder sind.
Um ein bestimmtes Element in einer studentischen struct zugreifen,
Sie fügen einen Punkt an den Namen der Variablen,
gefolgt von dem Namen des Mitglieds Sie wollen.
Also hier sind die einzigen 2 gültig Möglichkeiten
sind student.age
und student.name.
Und wir können etwas tun
student.age = 12
und student.name = Student.
Was nun, wenn wir eine zweite Student machen wollte?
Man könnte denken, zu kopieren und diese Zeilen
und ändern Sie Schüler zu Schüler 2 oder so etwas,
und das wird funktionieren,
aber technisch, Schüler und Studenten 2
nicht über den gleichen Typ.
Siehe, werden Sie nicht in der Lage sein, um sie miteinander zuweisen.
Dies liegt daran, so weit,
Ihre Struktur ist anonym.
Wir müssen ihm einen Namen geben.
Um dies zu tun, legen wir den Namen der Struktur
nach dem Wort struct.
Schüler,
gefolgt von der Definition.
Wir können immer noch sofort eine Variable vom Typ
struct Student, wie wir früher.
Wir nennen es S1
Indem die Struktur einen Namen,
Wir können jetzt struct student
in fast genau der gleichen Weise würden wir verwenden int.
So können wir eine Variable vom Typ struct Student,
wie
struct student S2.
Wie Arrays bieten structs eine Verknüpfung Initialisierungssyntax,
so können wir sagen, struct student S2
gleich
geschweiften Klammer 3, S2.
Hier wird S2.age 3 sein kann,
und S2.name wird auf S2 weisen.
Denken Sie an all die Dinge, die Sie tun können, mit einem int-Typ
und die meisten von ihnen können mit einem struct student Typ zu tun.
Wir können eine struct Schüler als Typ einer Funktion Parameter verwenden.
Wir können struct student Inneren einer neuen Struktur zu verwenden.
Wir können einen Zeiger auf eine struct student.
Wir können Größe struct student.
Struct Studenten ist eine Art
wie int ist ein Typ.
Wir können auch S1 bis S2 zuordnen
da beide vom gleichen Typ sind, so können wir tun
S1 = S2.
Was passiert, wenn wir tun
S1.age = 10?
Hat S2 Veränderung überhaupt?
Auch der Strukturen ebenso wie regelmäßige Zahlen denken.
Wenn wir weisen einige int X bis zu einem gewissen int Y,
wie X = Y
und ändern Sie dann X,
wie in X + +,
ist Y überhaupt ändern?
Y hier nicht ändern, und so auch nicht S2 oben.
S2.age noch 3.
Aber beachten Sie, dass bei der Vergabe ein struct zum anderen,
alle Zeiger immer noch auf die gleiche Sache,
da sie nur kopiert.
Wenn Sie nicht wollen, dass die Zeiger auf geteilt werden,
Sie müssen manuell behandeln, dass
vielleicht durch malicking ein Speicherblock für einen der Zeiger auf, darauf
und Kopieren der Daten über.
Es ist zwar lästig zu müssen struct student überall schreiben.
Mit einer Art def, können wir tun,
Typ def
struct
und wir nennen es Schüler.
Jetzt können wir Studenten überall verwenden
dass wir zur struct student verwenden.
Diese Art def ist eine anonyme struct
und nennt es Schüler.
Aber wenn wir auch halten die Schüler Kennung
neben dem Wort struct, wie in typedef struct Student,
konnten wir sowohl struct Student und Schüler synonym verwenden jetzt.
Sie haben nicht einmal den gleichen Namen haben.
Wir könnten def struct Student Bob geben
und dann struct Student und Bob
würde austauschbaren Typen sein.
Unabhängig von der Art def,
wir brauchen die Kennung neben struct
wenn die Definition der Struktur
rekursiv ist.
Beispielsweise
Typ def struct node
und es wird als int val definiert werden
und es wird über einen Zeiger, dass zu einem anderen struct node verweist.,
wie in struct node * next.
Und dann werden wir es nennen Knoten.
Diese Struktur ist rekursiv,
da die Definition von struct node enthält in sich
ein Zeiger auf eine struct Knoten.
Beachten Sie, dass wir sagen, struct node * next haben
Innenseite der Definition der Struktur Knoten
da die Art def wurde noch zu erlauben uns fertig zu vereinfachen diese
nur node * next.
Sie lernen mehr über Strukturen ähnlich wie diese
beim Umgang mit verknüpften Listen und Bäumen.
Was Strukturen in einer Funktion?
Dies ist auch völlig in Ordnung.
Wir könnten
void func
die als Argument,
Student s
und tut etwas mit diesem Schüler.
Und dann können wir es als Student struct vergehen wie so.
Func der S1 von früher.
Die Struktur verhält
genau wie eine ganze Zahl würde, wenn an eine Funktion übergeben.
Func erhält eine Kopie der S1
und so kann nicht geändert werden S1;
sondern nur die Kopie das ist in S. gespeichert
Wenn Sie die Funktion in der Lage sein S1 zu ändern,
Funktionen müssen ein Student * S zu nehmen,
und Sie haben die S1 nach Adresse übergeben, wie so.
Student * S, Funk & S1.
Es gibt einen weiteren Grund, nach Adresse hier vorbei.
Was, wenn unser struct 100 Felder enthalten?
Jedes einzelne Mal passieren wir einen Schüler, func,
unser Programm muss alle diese 100 Felder in Funktion das Argument S kopieren,
auch wenn es nie verwendet die überwiegende Mehrheit von ihnen.
Also selbst wenn Funktionen nicht über eine Änderung der Studenten planen,
wenn immer noch wertvoll sein, um nach Adresse weitergeben.
Okay, was ist, wenn wir einen Zeiger auf eine struct erstellen möchten?
Wir könnten etwas tun
Studenten * S
gleich malloc
Größe der Schüler.
Beachten Sie, dass die Größe der funktioniert immer noch hier.
Wie können wir also nun auf das Alter Mitglied
des Blocks, S Punkte?
Man könnte zunächst denken zu tun
* S.age = 4,
aber das wird nicht ganz funktioniert.
Da dies wirklich so interpretiert werden
* S.age in Klammern = 4,
die nicht einmal kompilieren,
da S ist kein struct oder eher ein Zeiger auf eine Struktur,
und so der Punkt wird hier nicht funktionieren.
Wir könnten
(* S). Age = 4
aber die Klammern kann man ärgerlich und verwirrend.
Zum Glück haben wir eine besondere Pfeiloperators
das sieht so etwas wie
S-> age = 4.
Diese 2 Arten der Referenzierung Alter
äquivalent
und wir wissen nicht wirklich jemals brauchen den Pfeil-Operator,
aber es macht die Dinge schöner aussehen.
Da S ist ein Zeiger auf eine Speicherblock, der die Struktur enthält,
Sie können S> Alter denken die Verfolgung der Mauspfeil
und greifen Sie das Alter Mitglied.
Also warum sollten wir jemals Structs verwenden?
Es ist definitiv möglich, sich mit nur den primitiven Ganzzahlen
Zeichen, Zeiger und dergleichen
dass wir zur;
anstelle von S1 und S2 vor,
wir hätten age1, age2, name1 und name2
alle auf separate Variablen.
Dies ist mit nur 2 Studenten in Ordnung,
aber was, wenn wir 10 von ihnen hatten?
Und was, wenn statt nur 2 Felder,
der Student struct hatte 100 Felder?
GPA, Kurse, Haarfarbe, Geschlecht und so weiter.
Statt nur 10 Strukturen, brauchen wir 1.000 separate Variablen.
Bedenken Sie außerdem, eine Funktion
das dauert, dass struct mit 100 Feldern mit seinen einziges Argument
und druckt alle Felder aus.
Wenn wir nicht mit einem struct,
jedes einzelne Mal, wir nennen diese Funktion,
Wir müssen auf allen 100 Variablen übergeben
und wenn wir 100 Variablen für Schüler 1,
und 100 Variablen für Schüler 2,
Wir müssen sicher sein, wir nicht versehentlich passieren einige Variablen aus student 1
und einige Variablen aus Studenten 2.
Es ist unmöglich, diesen Fehler mit einem struct machen,
da alle 100 Variablen in einem einzigen Paket besteht.
Nur ein paar abschließende Bemerkungen:
Wenn Sie alles bis zu diesem Punkt, große verstanden.
Der Rest des Videos ist nur der Vollständigkeit halber.
Da Strukturen können jede Art von Zeiger zu halten,
sie können auch Hold-Funktion Zeiger.
Wenn Sie vertraut mit der objektorientierten Programmierung,
Diese bietet die Möglichkeit, Strukturen zu bedienendes Programm in einer objektorientierten Stil.
Mehr über Funktionszeiger zu einer anderen Zeit.
Auch, manchmal müssen Sie möglicherweise zwei Strukturen
deren Definitionen sind voneinander abhängig.
Beispielsweise
wir hätten struct A,
welches definiert ist als
ein Zeiger auf eine struct B,
struct B * X,
und jetzt können wir einen struct B
Welches ist als Zeiger definiert
zu einem struct A,
struct A * Y.
Aber das wird nicht kompiliert,
Da struct B nicht zu dem Zeitpunkt, struct A wird kompiliert existieren.
Und wenn wir tauschen struct A und struct B,
dann würden wir nur mit dem gleichen Problem überlassen werden;
diesmal mit struct A nicht vorhanden.
Um dieses Problem zu lösen, können wir schreiben
struct B;
vor der Definition von struct A.
Dies ist eine vorausschauende Erklärung genannt.
Dies nur erlaubt der Compiler wissen, dass
struct B ist ein gültiger Typ, vollständig definiert wird später oder anderswo.
Mein Name ist Rob Bowden, und dies ist CS50.
[CS50.TV]