Hallo und willkommen zurück. Das Letzte, worüber ich in Bezug
auf Strukturen sprechen möchte, ist, wie sie mit Funktionen zusammenhängen,
wie Sie Strukturen als Argument an einen Parameter und eine Funktion übergeben können und
wie dies auch effizienter ist.
Also Strukturen als Argumente für Funktionen.
Nach dem Deklarieren einer
Struktur namens Family. In diesem Beispiel erstellen wir eine
benannte Familie. Wie übergeben wir diese Struktur als Argument an eine Funktion?
Wir haben also diese Struktur namens Familie.
Wir haben eine Reihe von Charakter-Arrays in
diesem Namen, Vater und Mutter, und dann haben wir ein int-Alter.
Das ist unsere Strukturdefinition.
Wir wissen, dass es sich um eine Struktur handelt, da dort das Schlüsselwort struct steht, gefolgt von dem
Tag-Namen, für den wir unsere geschweiften Klammern usw. haben.
Wie übergeben wir diese Struktur tatsächlich an
eine Funktion namens Geschwister?
Nun, Sie würden es genauso machen, wie Sie die Struktur
deklarieren, Sie würden den Typ als Parameternamen sagen.
Es ist wirklich einfach. In diesem Fall haben wir also boolesche Geschwister.
Geschwister geben einen Booleschen Wert zurück.
Und es braucht zwei Parameter, zwei Strukturparameter.
Sie müssen den Strukturtyp identifizieren, bei dem es sich um die Typstrukturfamilie handelt.
In fortgeschrittenem c könnten Sie tatsächlich eine
typedf für diese Struktur ausführen und sie anders benennen, und Sie könnten den Namen
hier kürzen, aber wir haben nicht über typeds gesprochen.
Das wäre wahrscheinlich besser.
Aber so müssten Sie es wirklich machen. Sie müssten wie bei jedem anderen Parameter
den gesamten Typ definieren, bei dem es sich um die Strukturfamilie und dann den Variablennamen handelt.
Hier übergeben wir also zwei Parameter, Mitglied eins und Mitglied zwei.
Sie sind beide vom Typ Strukturfamilie.
Wenn wir dann innerhalb unserer Funktion auf Mitglieder zugreifen möchten, greifen wir
wie gewohnt auf Mitglieder zu.
Mitglied eins und Mitglied zwei, sie sind keine Zeiger, daher verwenden wir den Bindestrich nicht größer als. Wir machen
das nur für die Zeiger, weil wir sie de-referenzieren müssen, um zu sehen, auf was sie zeigen.
Da es sich nicht um Zeiger handelt, können wir nur Punkte machen. Also Mitglied eine Punktmutter, Mitglied zwei Punktmutter.
Mitglied eine Punktmutter und Mutter zwei
Punktmutter sind Zeichenarrays, und Zeichenarrays sind im Wesentlichen Zeiger.
So können wir sie an den str-Vergleich weitergeben. Str compare wird gleich zurückgeben, wenn sie gleich sind.
Was wir hier also tun, ist zu überprüfen, ob Mitglied
eine Mutter und Mitglied zwei Mutter gleich sind. Und wenn ja, werden wir wahr zurückkehren.
Denn wenn beide den gleichen Namen haben und
das wirklich der Nachname wäre, dann sind sie Geschwister.
Ziemlich einfach.
Einfache Übergabe von Argumenten
an Funktionen, solange die Funktionsdeklaration diese Typstruktur enthält.
Also diese Funktion wieder zwei Parameter, von denen jeder eine Struktur der
Typfamilie ist.
Was ist, wenn wir Zeiger auf Strukturen als Funktionsargumente haben wollen?
Und ich habe bereits erwähnt, dass dies besser ist, weil
wir Wert und c übergeben.
Wenn Sie den Wert übergeben, kopieren Sie.
Wenn Sie eine Struktur haben, die viele Daten
enthält, viele große Strukturen als Argumente,
müssen Sie alles in dieser Struktur in
die eigentliche Funktion kopieren.
Das könnte einige Zeit dauern, um
diese großen Strukturen zu kopieren.
Wenn Sie einen Zeiger haben, müssen Sie nur die Adresse
kopieren, was viel schneller ist. Daher werden Zeiger auf
Strukturen als Parameter und Funktionen verwendet, um den Speicherverbrauch und die
Zeit zu vermeiden, die zum Kopieren aller Strukturen benötigt wird.
Wenn Sie nun eine kleine Struktur haben, keine große
Sache, aber auf jeden Fall Zeiger und Strukturen verwenden möchten, die groß sind.
Also, in diesem Fall, was machen Sie, geben Sie immer noch den Namen der Strukturtypen
an, Sie setzen einfach das Sternchen
vorher, sehr einfach. Und wenn Sie nicht
möchten, dass sich die Daten in der Struktur ändern, können Sie eine Konstante vor dem Strukturtyp verwenden.
Wenn Sie nicht möchten, dass sich die Adresse ändert, setzen Sie die Konstante nach den Zeiger der Strukturfamilie.
Aber hier machen wir das Gleiche. Aber jetzt werden wir anders darauf
zugreifen, da wir jetzt, da es sich um einen Zeiger handelt, den Bindestrich verwenden können,
der größer ist als das neue Symbol, um darauf zuzugreifen, anstatt den Punkt zu verwenden.
Wir müssen den Punkt hier nicht verwenden. Denken Sie daran,
Zeiger, die Sie zuerst de-referenzieren müssen, damit Sie sie in Klammern setzen müssen. Es
ist mehr Syntax, den Zeiger zu de-referenzieren, als den Punkt außerhalb der Klammern zu setzen, da
er viel höhere Priorität hat einfacher, den Bindestrich zu verwenden als größer als.
Strich und größer als Mutter, Strich
und größer als Mutter sind beide Zeiger, sie können im Str-Vergleich übergeben werden.
Wenn sie gleich sind, geben Sie true zurück. Andernfalls geben Sie false zurück, ziemlich unkompliziert.
Sie können auch den Const-Modifikator verwenden, wie ich bereits
erwähnt habe, wenn Sie keine Änderung der Mitglieder der Struktur zulassen möchten.
Auf was die Struktur zeigt, setzen Sie die Konstante vor den Zeiger.
Sie könnten die Konstante auch tatsächlich vor die Familie stellen.
In diesem Fall hat die Familie einen Typ.
Hier wäre
es also wirklich eine Konstruktionsfamilie oder ein Konstruktionsfamilienkonstantenzeiger.
Und dann wieder auf die gleiche Weise zugreifen, Sie ändern nichts. Also bist du gut zu gehen.
Der Compiler wird sich nicht beschweren.
Sie können auch den Konstanten-Modifikator verwenden, wenn Sie keine Änderung der
Adresse selbst zulassen möchten.
Jeder Versuch, diese Strukturen zu ändern, führt beim Kompilieren zu einer Fehlermeldung.
Hier würden Sie also
Familienstar sagen und die Konstante nach dem Stern setzen.
Und das heißt, Sie können den Wert
von p-member, den Wert des Zeigers, der eine Adresse ist, nicht ändern.
Dies ist jedoch wiederum nicht sehr nützlich, da Sie
beim Übergeben eines Werts tatsächlich eine Kopie der Adresse in einer Kopie übergeben.
Das ist also überflüssig, Sie müssen dies nicht tun, aber Sie können.
Und auch hier möchten Sie in der Lage sein, die Adresse des p-Mitglieds zu ändern.
In diesem Fall greifen Sie sowieso nur auf die Daten zu, um festzustellen, ob sie gleich sind.
Der Indirektionsoperator in jeder Parameterdefinition steht jetzt
vor dem Schlüsselwort constant.
Dieses Sternchen steht nicht vor dem Parameternamen.
Sie können die in den Zeigern gespeicherte Adresse nicht ändern, da sie nach dem Sternchen steht.
Wenn es sich vor dem Parameternamen-Typ befand, möchten Sie in
der Lage sein, das tatsächliche Element zu ändern, auf das es zeigt.
Wenn wir diesen Indirektionsoperator vor dem Parameternamen hätten, was das in der Konstante davor bedeuten würde,
würde dies bedeuten, dass Sie in der
Lage sein möchten, das zu ändern, worauf es zeigt. Dies sagt nur die Adresse.
Sie können also die in den Zeigern gespeicherte Adresse nicht ändern.
Es sind die Zeiger, die hier geschützt sind, nicht
die Strukturen, auf die sie zeigen, genau wie konstante und andere Zeigerparameter, kein Unterschied zu Strukturen.
Wenn Sie eine Struktur von einer Funktion zurückgeben möchten,
die ein Zeiger ist, muss der Funktionsprototyp diesen Rückgabewert in der Deklaration
auf normale Weise angeben.
Also hier müsste man sagen, dass mein lustiger Zeiger
auf den neuesten Stand gebracht
wurde oder nicht, es spielt keine Rolle. Dies ist ein Prototyp für eine Funktion, die keine Argumente akzeptiert und eine
Struktur vom Typ Datum zurückgibt. Es ist sehr einfach, eine Struktur von einer Funktion zurückzugeben. Und was ist der Wert davon?
Nun können wir mehr als
ein Element oder ein Datenelement von einer Funktion zurückgeben.
Wenn Sie eine Struktur zurückgeben, können Sie 10 Werte und 10 verschiedene Datenelemente zurückgeben.
Wie cool ist das. Mit der Struktur können Sie mehrere von einer Funktion zurückgeben.
Sehr, sehr wertvoll.
Daher ist es oft bequemer, einen Zeiger auf eine Struktur zurückzugeben, als nur auf die Struktur.
Wenn Sie einen Zeiger auf die Struktur zurückgeben, wird er auf dem Heap erstellt, da
alle Zeiger auf dem Heap erstellt werden.
Dies bedeutet, dass es etwas länger dauern wird.
Dies bedeutet, dass Sie es zu beliebigen Zeiten löschen und verwalten können.
In diesem Beispiel erstellen wir eine Struktur mit dem Namen "Fonds".
Es enthält ein Zeichenarray mit
dem Namen bank, enthält ein Double und ein anderes Zeichen mit
dem Namen save von einer bestimmten Länge. Die gerade angenommene Spaßlänge beträgt 50.
Und dann hat es eine doppelt gespeicherte.
Wir haben eine Funktion namens sum, die diese Struktur als Parameter verwendet.
Und alles, was wir tun, ist, dass wir a zurückgeben
- den Bankfonds aus der ersten Struktur plus den Sparfonds, und das wird
den Betrag zurückgeben, den sie auf ihrer Bank haben.
In diesem Beispiel ist die Summe nur ein Doppel.
Wir geben keinen Zeiger zurück. Wir nehmen nur einen Zeiger als Parameter.
In unserer Hauptfunktion erstellen wir daher eine Strukturvariable
namens Stan vom Typ Strukturfonds.
Wir initialisieren es mit einigen Werten und drucken dann die Gesamtsumme
der aufrufenden Summe aus. Und wir übergeben diese Struktur einfach so, wie wir eine Variable übergeben.
Wir müssen nicht de-referenzieren, es ist kein Zeiger. Wir müssen nichts Besonderes tun.
Wir stellen nur sicher, dass wir in der Funktionsdeklaration diesen Strukturtyp haben, aber
alles andere sieht normal aus.
Ein paar Erinnerungen.
Ich habe bereits erwähnt, dass Sie beim Übergeben von Strukturen an eine Funktion immer Zeiger verwenden sollten.
Warum? Denken Sie daran, dass in
älteren Versionen
von c keine Strukturen übergeben werden können, aber Zeiger.
So können Sie jede Art von Abwärtskompatibilität vermeiden.
Wenn Sie eine ältere Version von c verwenden, funktioniert Ihr Programm.
Das Übergeben dieser einzelnen Adresse ist
daher aufgrund des zeitlichen Kopierens auch effizienter.
Wenn Sie dies jedoch tun und einen Parameter übergeben, der ein
Zeiger auf eine Struktur innerhalb einer Funktion ist, sind Ihre Daten weniger geschützt.
Einige Operationen in der aufgerufenen Funktion können sich also versehentlich auf die Daten in
der ursprünglichen Struktur auswirken.
Und hier möchten Sie das const-Qualifikationsmerkmal verwenden.
Und Sie würden die Konstante vor dem
eigentlichen Typ verwenden, nicht nach dem Sternchen und vor
dem Parameternamen, vor dem Typ.
Der Vorteil der Übergabe von Strukturen sind Argumente,
die Funktion arbeitet mit Kopien der Originaldaten.
Es ist sicherer als mit den Originaldaten zu arbeiten.
Das ist also wirklich das einzige Mal, dass Sie eine Struktur als Argument übergeben möchten, das kein Zeiger ist.
Und der Programmierstil ist tendenziell etwas klarer.
Die Hauptnachteile der Übergabe von Strukturen als Argumente im Gegensatz zur Übergabe
eines strukturierten Zeigers als Argument sind, dass
ältere Implementierungen den Code möglicherweise nicht verarbeiten, Zeit
und Platz verschwenden und es besonders
verschwenderisch ist, wenn Sie große Strukturen haben, für die wir viel
kopieren müssen Mitglied. Denken Sie also daran.
Zum größten Teil möchten Sie Zeiger
auf Strukturen übergeben, viel effizienter und spart Zeit.
Programmierer verwenden aus Effizienzgründen Strukturzeiger als Funktionsargumente und verwenden
bei Bedarf Konstanten. Und das ist die Kombination, die Sie machen möchten.
Wenn Sie sich Sorgen um den Schutz machen, verwenden Sie einfach
den Funktionszeiger für die Effizienz und verwenden
Sie dann die const const, damit innerhalb der Funktion
nichts durcheinander gerät, genau wie bei normalen Zeigern
mehr oder weniger, aber bei Zeigern ist dies bei der Effizienz noch wichtiger,
weil von großen Strukturen.
Das Übergeben von Strukturen nach Wert erfolgt meistens für kleine Strukturen. Dies sind
die Regeln, über die Sie nachdenken möchten.
Okay, um eine Struktur zu übergeben, die kein Zeiger ist, solange sie klein ist.
Wiederum einige wichtige Konzepte, die sich auf Strukturen
und das Übergeben von Zeigern als Parameter, Argumente
und Rückgabe von Zeigern beziehen. Jetzt können wir tatsächlich damit beginnen,
einige davon umzusetzen. Wir bieten viele Beispiele. Wir verstehen die Konzepte. Wir verstehen die Syntax.
Jetzt möchte ich Ihnen ein paar Herausforderungen vorstellen, bei denen Sie dies tatsächlich tun. Haben Sie sich in
der Syntax gemerkt, dass Sie jetzt, wenn Sie jemals eine Struktur im Programm erstellen möchten, wissen, wie
man es wie mit dem Handrücken macht.
Daher werden wir in unseren nächsten Vorträgen einige Herausforderungen haben, um
Sie mit all den Dingen vertraut zu machen, über die wir in Bezug auf Strukturen gesprochen haben.
Vielen Dank.