Hallo und willkommen zurück.
In dieser Vorlesung möchte ich über die Verwendung von Zeigern und Strukturen
sprechen, wie sie zusammenhängen.
Wir können Elemente innerhalb einer Struktur als
Zeiger haben, und dann können wir unsere Strukturen selbst zu Zeigern machen.
Zwei sehr nützliche Konzepte.
Daher ist die Struktur hier wichtig. C ermöglicht Zeiger auf zwei Strukturen.
Wenn wir also eine Variable mit Typstruktur erstellen, können wir
sie als Zeiger erstellen.
Zeiger auf Strukturen sind einfacher zu manipulieren als Strukturen selbst.
Also wieder, es ist eine Art Notationssache,
macht die Dinge viel einfacher und es ist auch effizienter.
In einigen älteren Implementierungen der Sprache c
kann eine Struktur nicht
als Argument an eine Funktion übergeben werden, aber wir
wissen, dass ein Zeiger dies kann. Dies ist ein weiterer Grund,
warum Sie möchten, dass eine Struktur ein Zeiger ist, wenn
Sie sie deklarieren, da Sie sie dann in älteren Versionen
von c als Argument an eine Funktion übergeben können.
Selbst wenn Sie eine Struktur als Argument übergeben können, ist
die Übergabe eines Zeigers effizienter.
Wir wissen, dass das effizienter ist. Wir haben in der Vergangenheit darüber
gesprochen, wie wichtig das Übergeben wichtiger sein kann.
In diesem Fall ist es sogar
noch effizienter, denn wenn Sie eine gesamte Struktur übergeben, die Struktur
groß ist und viele Elemente enthält, kopieren
Sie alle Elemente in der Struktur in diesen Parameter.
Wenn Sie einen Zeiger übergeben, kopieren Sie einfach die Adresse.
Umso wichtiger ist es, wenn Zeiger
als Argumente strukturiert sind, da Strukturen groß sein können.
So viele Datendarstellungen verwenden Strukturen, die Zeiger auf andere
Strukturen enthalten.
Sie werden dies häufig in all
Ihren c-Programmstrukturen sehen, die Zeiger sind, und aus den genannten Gründen.
Die Tatsache, dass Sie sie als Parameter in älteren Versionen übergeben können,
um sie zu sehen, und es ist auch effizienter,
weil Sie alles durch Übergeben von Werten tun, was
das Kopieren einer Adresse viel effizienter
macht als das Kopieren aller Elemente dieser großen Struktur.
Eine Struktur als Zeiger zu deklarieren ist also ziemlich einfach.
Wenn Sie eine Variable als Zeiger auf den Treffer definieren, verwenden Sie einfach dieses
Sternchen nach dem Datentyp.
Und wir sagten, dass Strukturen wirklich ein neuer Typ sind.
In diesem Fall unsere immer wichtige Datumsstruktur.
Wir sagen einfach struct date und verwenden dann den Sternchen-Datumszeiger,
und Sie möchten das wahrscheinlich auf null initialisieren.
Denken Sie daran, wenn Sie sagen, Strukturdatum Zeiger Datum Struktur
Datum Datum Zeiger, der keinen Speicher zuweist, erstellt
es Speicher zum Speichern des tatsächlichen Zeigers.
Es wird kein Speicher für die darin enthaltenen Daten erstellt.
Sie können also
entweder diesem Datumspunkt oder der Adresse eines anderen Strukturdatums zuweisen
oder einen Speicher dafür an einer anderen Stelle zuweisen
oder ihn auf diese Weise
auch mit einigen Daten initialisieren.
Damit der variable Datumszeiger genau wie andere Zeiger zugewiesen werden kann, können
Sie ihn so einstellen, dass er mit der Zuweisungsanweisung
auf das heutige Datum zeigt. Wenn wir also bereits eine Deklaration des heutigen Datums hatten.
Wir würden nur das kaufmännische Und verwenden, um die Adresse zu erhalten.
Also erstellen wir eine normale Datumsstruktur und es ist das heutige Datum.
Das würde also Speicher für die drei Elemente schaffen.
Und dann erstellen wir unseren Zeiger und weisen ihm einfach
die Adresse des anderen Datums zu.
Ziemlich einfach. Wir haben das mit regulären Datentypen gemacht,
es ist nicht anders, wenn Sie es mit Strukturen machen.
Sie können dann indirekt auf alle Mitglieder der Datenstruktur zugreifen, auf die der Datumszeiger zeigt.
Also müssten wir so etwas tun.
Wenn Sie auf das Element
der Tageszeigerstruktur zugreifen möchten, müssen Sie es zuerst de-referenzieren.
Und so wäre es wahrscheinlich nützlich, es in Klammern zu setzen, damit es sehr einfach ist.
Sie müssen den Datumszeiger de-referenzieren, um den Wert des
heutigen Datums zu erhalten,
den Wert der Adresse des heutigen Datums, auf
das er zeigt, um bestimmte Werte festzulegen.
Sie würden es also de-referenzieren
und dann Punkttag gleich 21 machen, und das würde Ihrem Tageszeiger
21 zuweisen.
Das oben Gesagte sagt nur, worauf das heutige Datum hinweist. Wir möchten
auf diesen Wert zugreifen und den Tag auf 21 setzen.
In diesem Fall sind die Klammern erforderlich, da der
Punkt eine höhere Priorität als das Sternchen hat.
Wenn Sie die Klammern dort nicht eingefügt haben, wird es vermasselt, weil es versucht, den Punkt zuerst zu
machen, bevor es tatsächlich den Zeiger auf den Zeiger bekommt, um ihn auf
die Daten zu zeigen.
Es würde also versuchen, im Wesentlichen mit einem Nullzeiger auf Daten zuzugreifen.
Wenn Sie die Referenzierung aufheben, erhalten Sie den Wert.
Wenn wir nun Strukturen verwenden, gibt es Zeiger.
Wenn wir den Wert von Monaten testen möchten, die in der Datumsstruktur gespeichert sind, auf die der Datumszeiger
zeigt, könnten wir so etwas tun.
Wir de-referenzieren den Zeiger, setzen ihn in Klammern, damit er Vorrang vor dem Punkt hat, und dann
sagen wir, dass der Punktmonat gleich 12 ist.
Es ist eine vollkommen gültige Syntax.
Aber es ist ein bisschen umständlich.
C hat also eine eigene Syntax, sodass Sie nicht alles de-referenzieren
und in eine Klammer für Strukturen setzen müssen.
Wenn Sie auf das zugreifen möchten, auf das die Struktur zeigt, müssen Sie
sie nicht auf diese Weise de-referenzieren.
In c gibt es einen speziellen Operator für Zeigerstrukturen, und der
Bindestrich ist größer als.
Es ist ein Strich, gefolgt vom Zeichen größer als.
Auf diese Weise müssen Sie den Zeiger nicht mehr de-referenzieren.
Anstatt also Stern x in Klammern und dann Punkt y zu machen,
können Sie einfach x Strich größer als y sagen.
Da x ein Zeiger ist, müssen Sie nicht darauf verweisen und möchten auf
das Element in dieser Struktur zugreifen, auf das Sie zeigen.
Sie werden diese Syntax also überall sehen. Sie werden die
Klammern und die d-Referenz nicht sehen. Es ist vollkommen gültig, aber Sie geben mehr Zeichen ein.
Es ist viel effizienter, nur x Bindestrich größer als y zu sagen.
Die vorherige if-Anweisung hier oben, anstatt in den Klammern zu de-referenzieren, müssen Sie
nur sagen, ob der Datumszeiger größer als der Monat ist.
Und es ist etwas intuitiv, weil der Strich größer ist als zu sagen, dass er auf etwas zeigt.
Und so ist der Datumsstrich größer als der Monat.
Der Datumszeiger ist also ein Zeiger, und deshalb verwenden Sie den Bindestrich größer als.
Wenn dies eine verschachtelte Struktur wäre,
würden Sie den Bindestrich größer als zur Struktur machen und danach
einen Punkt machen, um auf die Elemente der verschachtelten Struktur zuzugreifen.
Da der Tageszeiger jedoch ein Zeiger ist, müssen Sie den Bindestrich gleich oder den Bindestrich
größer als verwenden.
Hier ist ein Beispiel: Wir erstellen unser Strukturdatum. Wir
haben drei Elemente. Dann erstellen wir unseren Zeiger. Datumszeiger. Heute erstellen wir nur
eine reguläre Variable. Wir weisen unserem Zeiger
die Adresse von heute zu und um dann die tatsächlichen Elemente
der Struktur zuzuweisen, verwenden wir einfach diesen Bindestrich größer als und können ihn dann ausdrucken.
Schauen wir uns das in Codeblöcken an, um zu sehen, wie das funktioniert.
Also werde ich dieses Beispiel hier einfügen.
Wenn Sie Strukturen definieren, definieren Sie diese
normalerweise außerhalb einer Funktion, da Sie sie dann in jeder Funktion verwenden können.
Es ist wie ein globaler. Denken Sie jedoch
daran, dass Sie beim Definieren der Struktur keinen Speicher erstellen.
Sie erstellen die Variablen also weiterhin als lokale Variablen oder Zeiger, aber
die eigentliche Definition liegt außerhalb der Funktion.
Wenn Sie es also verwenden möchten, können Sie es in jeder Funktion verwenden.
Hier oben haben wir eine neue Struktur vom Typ Datum oder
Name bis heute erstellt, die drei Ganzzahlen enthält. Wir beenden sie mit einem Semikolon.
Wir erstellen dann ein paar Variablen innerhalb der Hauptvariablen.
Eines, das heute nur ein normales Datum der Variablenstruktur ist,
und eines, das ein Zeiger ist. Wir wissen, dass es sich um einen Zeiger handelt, da vor ihm das Sternchen steht.
Wir wissen, dass ein Zeiger, wenn Sie einen Zeiger erstellen, nur Speicher zuweist, um
diese Adresse für diesen Wert dieses Zeigers zu speichern.
Wir müssten ihm also tatsächlich eine Adresse zuweisen, die wir heute mit kaufmännischem Und
tun, da dadurch tatsächlich ein Speicherbericht erstellt wird.
Jetzt zeigt der Datumszeiger auf das, was heute mit
der Adresse von heute ist.
Wir können dann damit beginnen, ihm Daten zuzuweisen, indem wir diesen Bindestrich verwenden, der größer als sehr
nützlich ist, und einfach Daten zuweisen, wie jeder andere auch, nur den Zuweisungsoperator verwenden.
Und wenn wir es dann ausdrucken,
werden Sie feststellen, dass wir es nicht de-referenzieren müssen, um es auszudrucken.
Um es
auszudrucken, können wir einfach sagen, dass die Datentypen für die Formatbezeichner hier prozentual höher
sind, Prozent d gleich für ganze Zahlen, und dann verwenden wir einfach den Strichgrader,
da dies tatsächlich das De-Referenzieren von Merken bewirkt.
Jetzt könnten wir dies ändern und dies wäre gültig.
Wir müssen Klammern setzen und dann den Punktmonat sagen.
In beiden Fällen ist das in Ordnung, aber gewöhnen Sie sich an den Bindestrich, der größer ist, weil er eine bessere Syntax bietet.
Und jetzt, wenn wir dies
erstellen, werden Sie sehen, dass die Datumszeigerwerte ausgedruckt
werden und alle auf 9 25 und 2015 gesetzt sind.
Das heutige Datum lautet also 9 25 15. Es wurde formatiert, um auf diese Weise auszudrucken.
Ziemlich einfaches Zeug.
Denken Sie daran, dass der Bindestrich größer als ist. Dies ist
eine neue Syntax für Zeiger auf Strukturen.
Aber alles andere hier ist ganz normal.
Wir wissen, dass Zeiger Speicheradressen haben müssen, damit wir
wissen, dass wir entweder dynamischen Speicher zuweisen oder ihm eine vorhandene Struktur zuweisen müssen.
Lassen Sie uns zurückgehen und mehr über Strukturen und Zeiger sprechen.
Lassen Sie uns nun über Strukturen sprechen, die Zeiger enthalten.
Wir wissen, wie man einen Zeiger für eine Struktur erstellt.
Wir könnten diesem Zeiger Speicher zuweisen, wenn wir keine
vorhandene Adresse eines vorhandenen Zeigers zuweisen möchten.
Sie können aber auch Elemente in einer Struktur
haben, die selbst ein Zeiger ist. Ein Zeiger kann also auch Mitglied einer Struktur sein.
Wir müssen dieses Zeichenarray nicht verwenden.
Wir könnten also struct sagen,
wir könnten es in Zeigern benennen und dann könnten wir hier in diesem Beispiel zwei ganze Zahlen
verwenden, zwei ganzzahlige Zeiger p1 und p2, eine vollkommen gültige Syntax, um dies zu tun.
Daher wird eine Struktur, die in Zeigern aufgerufen wird, so definiert, dass sie zwei ganzzahlige Zeiger enthält.
Der erste heißt p1 und der zweite heißt p2.
Sie können eine Variable vom Typ struct in Zeigern definieren, genau wie
normal, struct, int Zeiger, Zeiger.
Die variablen Zeiger können jetzt wie andere Strukturen verwendet werden.
Zeiger ist kein Zeiger.
Es sind int Zeiger. Es enthält zwei Elemente in seinem
Treffer, die Zeiger sind, aber Zeiger selbst sind keine tatsächlichen Zeiger.
Achten Sie also darauf. Es ist eine Strukturvariable, die zwei Zeiger als Mitglieder
hat, das ist anders.
Wenn wir also auf die Elemente in der Zeigervariablen
zugreifen möchten, die sich in Zeigern befindet,
verwenden wir den Bindestrich nicht größer als weil Zeiger kein Zeiger sind, sondern eine Struktur.
Wir würden den Punkt
verwenden, um auf p1 und p2 zuzugreifen.
In diesem Beispiel erstellen wir unsere Struktur
und eine Variable. Es ist kein Zeiger, der Zeiger genannt wird.
Und dann erstellen wir zwei ganze
Zahlen, i1 gleich 100 und i2, die nicht initialisiert sind.
Jetzt sind p1 und p2 Zeiger.
Sie müssen also gültige Speicheradressen enthalten, denen die Adressen
Speicher zugewiesen wurden.
Und genau das macht i1 und i2.
Wenn Sie die Ganzzahlvariablen deklarieren, wird Speicher für diese Ganzzahlen zugewiesen.
Wenn Sie also die Adressen i1 und i2 p1 und p2 zuweisen, ist dies vollkommen in Ordnung,
da i1 und i2 Speicher zugewiesen haben, weil sie Ganzzahlen sind.
Wenn die Ganzzahlzeiger keine Ganzzahlzeiger, sondern Zeichenzeiger wären, müssten
Sie dynamischen Speicher zuweisen.
Jetzt verwenden wir nur noch Ganzzahlen, also weisen wir die Adressen der beiden Ganzzahlen p1 und p2 zu.
Wir können jetzt Sternzeiger sagen. p2 ist gleich 97, negativ
97.
Warum müssen wir es dort
wegen Zeigern de-referenzieren. p2 ist das, worauf wir uns beziehen.
Zeiger. pt p2 ist ein Zeiger.
Wir greifen nicht auf ein Element einer Struktur zu.
Wir dereferenzieren alle Zeiger. p2.
Und wir werden dem den Wert von allem zuweisen, was auf negativ 97 hinweist.
Beachten Sie also den Unterschied dort.
Wir erstellen keinen Strukturzeiger.
Wir erstellen einen regulären Variablenzeiger, der jedoch
zwei Elemente enthält, die Zeiger sind.
Wenn wir diesen beiden Elementen innerhalb der Struktur zuweisen möchten, müssen wir
sie mithilfe des Indirektionsoperators de-referenzieren, und genau das
tun wir dort.
Und dann in unseren beiden Print-Statements.
Wieder möchten wir die Werte von p1 ausdrucken, auf die p1
zeigt, damit wir sie nicht mehr
mit p2 referenzieren, und dann möchten
wir auch die Werte, auf die Zeiger zeigen, erneut ausdrucken.
In diesem ersten Fall sagen wir also, dass
i1 Prozent I Kommazeiger entspricht. p1 entspricht Prozent
I.
Der erste in den doppelten Anführungszeichen druckt also nur den eigentlichen Text
aus. Es wird nichts de-referenziert, nachdem das Komma die Stelle ist, an der die De-Referenzierung durchgeführt wird.
Wir drucken zuerst i1 aus, was 100 ist, und
drucken dann Zeiger p1 aus, die 100 wären.
I2 wird tatsächlich negativ 97
sein, nachdem wir es p2 zugewiesen haben.
Was ist also mit Zeichenarrays oder Zeichenzeigern? In der vorherigen Vorlesung haben wir
darüber gesprochen, wie Sie ein Zeichenarray als Element innerhalb eines
Zeigers erstellen können. Aber was ist mit Zeichenzeigern,
sollten wir so
etwas wie das erste und letzte
Zeichenarray tun oder sollten wir einfach so etwas wie das erste
und letzte mit Zeichenzeigern als Elementen tun. Was ist die bessere Option.
Nun, wir werden sehen. Es ist wirklich wieder eine Notationssache, aber die Verwendung der Zeiger bietet Vorteile.
Wenn wir also Zeiger auf Zeichen in unseren Elementen erstellen, ist
dies normalerweise etwas besser.
Sie müssen jedoch verstehen, was hier vor sich geht, wenn
Sie ein Array-Element char array als Element oder einen Zeiger als Element erstellen. Beide
sind gültig. Aber es gibt einen großen Unterschied.
Wenn wir also Strukturnamen veep
oder vp sagen und Talia und Summers
und dann Strukturzeigername. Denken Sie also daran, dass Strukturnamen die Zeichenarrays enthalten.
Strukturzeigernamen enthalten die Zeiger.
Und wir initialisieren hier die Zeiger, die Brad und Fallingjaw entsprechen.
Und dann drucken wir sie aus. Wir drucken das erste Element
aus, das ein Zeichen a und vp ist,
und dann das erste Element des Schatzes, das zuerst ein Zeiger ist.
Die Struktur nennt also die Variable veep.
Was hier passiert, ist, dass die Zeichenfolgen in der Struktur gespeichert sind.
Die Struktur hat insgesamt 40 Bytes für die beiden Namen zugewiesen, es
handelt sich um Zeichenarrays.
Das passiert, wenn wir Zeichenarrays innerhalb eines Zeigers erstellen.
Wir weisen 40 Bytes zu, um diese beiden Namen,
20 und 20, aufzunehmen.
Für die Zeigernamen Variable Treas, unabhängig davon, ob wir zuerst und zuletzt zwei Zeiger haben,
sind dies Zeichenfolgen, die überall dort gespeichert werden, wo der Compiler Zeichenfolgenkonstanten speichert.
Die Struktur enthält die beiden Adressen, da
es sich um Zeiger handelt. Zeiger enthalten, was, Werte, die Adressen sind.
Alles, was es tun wird, ist, zwei Zeiger innerhalb dieser Struktur zuzuweisen.
Das sind 16 Bytes für die meisten Systeme, Zeiger normalerweise 8 Bytes oder 4 Bytes.
Die Struktur p p name weist keinen Speicherplatz zum Speichern der Zeichenfolgen zu,
da nur Speicherplatz für die Zeiger selbst zugewiesen wird.
Zeiger haben Werte, die Adressen sind.
Der Adresse, auf die es zeigt, ist kein Speicher zugewiesen.
Wenn Sie diese beiden Zeiger erstellen, wird diesen beiden Zeigern kein Speicher zugewiesen.
Es wird kein Speicherplatz zugewiesen.
Daher kann es nur mit Zeichenfolgen verwendet werden, denen an anderer Stelle Speicherplatz zugewiesen wurde.
Immer wenn Sie Zeiger innerhalb einer Struktur haben, müssen
Sie malloc oder calloc verwenden.
Andernfalls könnten sie überall dort gespeichert werden, wo Zeichenfolgenkonstanten gespeichert sind.
Und das ist der große Unterschied. Daher sollten die Zeiger und die p-Namensstruktur
nur zum Verwalten von Zeichenfolgen verwendet werden, die an anderer Stelle im Programm erstellt und zugewiesen wurden.
Sie möchten dem keine
Daten zuweisen, es sei denn, Sie haben sie dynamisch zugewiesen oder sie wurden
an einer anderen Stelle zugewiesen, möglicherweise
durch eine vorhandene Struktur oder etwas anderes. Aber normalerweise möchten Sie diese Zeiger mallocieren.
Wieder ganz anders.
Sie weisen diesen beiden Zeichenarrays innerhalb der Namensstruktur 40 Bytes zu.
Für die Struktur p name haben Sie zwei Zeiger.
Dafür wird kein Speicher zugewiesen, wenn Sie eine Variable dieses Typs erstellen.
Es wird lediglich Speicher für die beiden Zeichenzeiger erstellt, die jeweils acht Byte umfassen.
Um tatsächlich Speicher für das zuzuweisen, worauf zuerst und zuletzt verweisen, müssen Sie ein Malloc ausführen.
Eine Instanz, in der es sinnvoll ist, einen Zeiger und eine Struktur zu
verwenden, besteht darin,
Zeichenfolgen zu verarbeiten, wenn Sie diesen Speicher dynamisch zuweisen.
Dies ist normalerweise der Fall,
wenn Sie es verwenden, da andere zulässige Datentypen den Speicher automatisch für Sie zuweisen.
Sie möchten also einen Zeiger verwenden, um die Adresse zu speichern.
Dies hat den Vorteil, dass Sie malloc bitten können, nur den für
eine Zeichenfolge erforderlichen Speicherplatz zuzuweisen. Wir haben über die Vorteile der dynamischen Speicherzuweisung gesprochen.
Wenn Sie Dinge zur Kompilierungszeit statisch erstellen, erstellen Sie
nur eine bestimmte Anzahl von Bytes.
Was passiert, wenn Sie mehr Bytes benötigen, geschraubt sind und Ihr Programm nicht funktioniert?
Sie müssen zurückgehen und neu kompilieren. Mit dynamisch zugewiesenen Zeichenfolgen
können Sie nachjustieren und genau so viel Speicher erstellen, wie Sie benötigen,
was das Programm wesentlich effizienter macht.
Sie werden also malloc für alle Zeiger verwenden, die innerhalb einer Struktur erstellt wurden.
In diesem Fall haben Sie also eine Struktur mit dem Namen name count.
Sie haben zwei Zeiger, Zeichenzeiger fname und Nachname.
Und dann hast du ein int, Buchstaben.
Die beiden Zeichenfolgen hier sind nicht in der Struktur gespeichert.
Wir erstellen nur Speicher für die Zeiger, die Adressen enthalten.
Wir möchten Speicher für fname und lname für das erstellen, auf das die Zeiger zeigen.
Wir möchten das also in einem Block speichern, der von einem dynamischen Speicherort verwaltet wird, der malloc verwendet.
Die Adresse der beiden Zeichenfolgen ist das, was gespeichert wird, nicht das, worauf sie zeigen.
Adressen sind also die Funktionen, mit denen Zeichenfolgenverarbeitungsfunktionen normalerweise arbeiten. Das ist
gut und deshalb möchten Sie dort Zeiger verwenden, weil
Sie das dann nicht müssen, dann können Sie sie einfach viel einfacher weitergeben.
Hier ist ein Beispiel. Wir haben eine Funktion namens get info.
Es braucht einen Zeiger.
Und wir können diesen Zeiger sehr leicht weitergeben.
Jetzt werden wir auch ein anderes
erstellen oder für unser Zeigerarray, an
das wir übergeben werden, Speicher
dafür zuweisen.
Sie werden also sehen, dass wir ein Zeichen namens temp erstellen
und dann einige Daten in diesem temp speichern.
Wir bitten den Benutzer, etwas zu bekommen. Wir sind nicht mit den Sgets vertraut, aber es ist das gleiche wie das gespeicherte Scanf ein wenig.
Dann ordnen wir fname innerhalb dieses Zeigers Speicher zu, und wir tun dies genauso, wie
wir Speicher für jedes Zeichen zuweisen. Wir nennen malloc, wir
übergeben die Anzahl der Bytes.
In diesem Fall ist die str-Länge 10 plus 1 für den Nullterminator.
Und dann denken Sie daran, Malloc verwandelt einen leeren Stern, also werfen wir ihn in einen Charakterstern.
Aber das ist genau hier entscheidend. Dieser Malloc-Aufruf ist für alle Strukturen erforderlich, die Zeiger enthalten.
Jetzt haben wir diesen Zeiger übergeben und dem Zeiger wurde nie ein
Speicher zugewiesen.
Also ordnen wir hier drinnen Speicher zu. Wir können dann unsere Kopie sehr einfach machen.
Wir können temp in fname unserer Struktur pst kopieren, die als
Parameter übergeben wurde.
Und dann können wir sie ihren Nachnamen eingeben lassen, wir können mehr Speicher für
den Nachnamen reservieren und dann in der Strukturvariablen Nachname speichern.
Dies ist, was Sie tun müssen, wenn Sie Zeiger auf Zeichen
in Ihren Strukturen haben, müssen Sie das Malloc tun.
Denn auch hier speichern diese Zeiger nur die Adresse.
Sie weisen genügend Speicher zum Speichern einer Adresse zu, nicht
genügend Speicher zum Speichern einer Zeichenfolge.
Was auch immer auf diese Adresse zeigt, Sie müssen dafür Speicher zuweisen, und Sie
tun dies wie gewohnt mit dem Malloc.
Der einzige Unterschied besteht darin, dass Sie den Bindestrich größer als das Zeichen
verwenden, um auf das tatsächliche Element in dieser Struktur zuzugreifen, das a ist Zeichenzeiger, damit Sie
ihn ihm zuweisen können, und das führt die De-Referenzierung durch.
Also wirst du mit diesem Zeug herumspielen wollen. Dies ist sehr
häufig bei Zeichenzeigern in Strukturen der Fall.
Wir werden eine Herausforderung haben, wo Sie dies tun müssen. Aber spielen Sie mit diesem Code
herum, gehen Sie in Codeblöcke, beginnen Sie, Speicher für Zeichenfolgen oder
Zeichenzeiger innerhalb von Strukturen zuzuweisen, und sehen Sie, wie
Sie dann str copy verwenden können, um tatsächlich Daten darin abzulegen, aber Sie
müssen zuerst den Speicher zuweisen, bevor Sie zuweisen .
Wenn Sie Konstanten wie im vorherigen Beispiel ausführen, wer weiß, wo dieser Speicher zugewiesen ist.
Daher wurden in dieser Vorlesung wieder viele wichtige Konzepte vorgestellt.
Diese Idee einer Struktur, die ein Zeiger in dieser
neuen Syntax ist,
in der Sie den Bindestrich verwenden können, ist größer als im Gegensatz
zur Verwendung des Indirektionsoperators, sehr schön.
Und dann tatsächlich Elemente als Zeiger haben und wie
Sie Speicher für Zeichenzeiger zuweisen müssen. Vielen Dank.