Hallo und willkommen zurück.
In dieser Vorlesung möchte ich über den Zugriff auf den Wert
sprechen, auf den ein
Zeiger zeigt. Denken Sie also daran, dass Zeiger Speicheradressen speichern.
Diese Speicheradresse enthält tatsächlich den Wert irgendwo.
Und so zeigen Zeiger auf diese Speicheradresse. Ich möchte den Wert dessen
erhalten, worauf es zeigt.
Da ich nur den Wert eines Zeigers ausdrucken würde, der eine Adresse wäre, aber ich möchte die Adresse erhalten, möchte
ich den Wert der Adresse erhalten.
Mit dem Indirektionsoperator können Sie also auf den Wert einer Adresse
zugreifen, auf die ein Zeiger zeigt. Der Indirektionsoperator ist das Sternchen.
Wir haben also gelernt, wie man das Sternchen verwendet, um einen Zeiger
zu deklarieren. Wir werden auch das Sternchen verwenden, um den Wert zu finden, auf den ein Zeiger zeigt.
Daher wird es auch als Dereferenzierungsoperator bezeichnet, da
Sie damit einen Zeiger dereferenzieren.
Wenn Sie beispielsweise eine Zahl haben, die gleich 15 ist, deklarieren Sie den Zeiger
vom Typ int, der auf ein int zeigt, und weisen ihm die Adresse der Zahl mit dem kaufmännischen Und zu.
Wie erhalten Sie nun den Wert, auf den der Zeiger zeigt?
Sie können die Referenzierung aufheben.
Grundsätzlich können Sie festlegen, dass der Wert, auf den der
Zeiger zeigt, 15 ist, da er auf die Adresse der Nummer zeigt, die 15 ist.
Die Zeigervariable enthält also die Adresse der Variablennummer.
Sie können dies in einem Ausdruck verwenden, um einen neuen Wert für das Ergebnis zu berechnen.
Angenommen, wir wollten ein Ergebnis erzielen, das dem Wert entspricht,
auf den der Zeiger zeigt, plus fünf. Sie würden das Sternchen dafür
vor dem Namen des Zeigers verwenden.
Das würde also im Grunde sagen, auf was die Zeigervariable
zeigt, es zeigt auf 15 und fügt fünf hinzu.
Es ist die Adresse,
auf die der Zeiger zeigt, was der Wert dieser Adresse ist.
Das Sternchen des Indirektionsoperators, das Sie
beachten sollten, ist also auch das Symbol, das für die Multiplikation verwendet wird, und es
wird auch verwendet, wenn Sie Zeigertypen deklarieren. Das kann also sehr verwirrend werden.
Woher wissen Sie unbedingt, was los ist oder wie der Compiler funktioniert?
Nun, es geht nur um den Kontext. Dies hängt davon ab, wann Sie dieses Sternchen verwenden und wo Sie es verwenden.
Wenn Sie das Sternchen verwenden, wenn Sie einen Zeiger direkt nach
dem Typ
des Zeigers deklarieren, wird offensichtlich eine Deklaration verwendet.
Wenn Sie das Sternchen zwischen zwei Zahlen
verwenden, wird es zur Multiplikation verwendet. Und wenn es beispielsweise
direkt vor dem Zeigernamen auf der rechten Seite oder auf der linken Seite verwendet
wird, wird ein Wert zugewiesen oder auf einen Wert zugegriffen.
Wenn Sie diesen Indirektionsoperator verwenden, dreht sich alles um
den Kontext.
Und so funktioniert es.
So wird der Compiler es interpretieren.
Wann immer Sie es in diesem Beispiel sehen, Sternzeiger und
Sie haben noch keinen Datentyp oder Sie haben nicht zwei Zahlen auf
jeder Seite, dann wissen Sie, dass es sich um einen Indirektionszeiger handelt, der dereferenziert.
Gehen wir also ein Beispiel durch. Hier ist ein
weiteres Beispiel, in dem wir eine
Ganzzahl von 10 erstellen. Wir werden auch eine Ganzzahl vom Typ x eine andere Variable erstellen.
Wir initialisieren count auf 10, x wird auf nichts initialisiert.
Wir erstellen dann einen int-Zeiger. Wir wissen, dass es sich um
einen int-Zeiger handelt, da wir das Sternchen nach dem
Datentyp haben und ihn dann int-Zeiger genannt haben.
Wir werden diesem int-Zeiger jetzt die Zähladresse zuweisen.
Denken Sie daran, Zeiger enthalten nur Adressen als Werte, aber
sie zeigen auch auf etwas.
Wir können dann die Variable x zuweisen, auf die der int-Zeiger zeigt,
auf welchen Wert die im Zeiger enthaltene Adresse lautet.
X zeigt also tatsächlich 10 an.
10. Wenn wir also fortfahren und das Sprichwort
count Prozent d ird x Prozent ird anzeigen, ist count gleich 10, x gleich 10.
Auf diese Weise können Sie einen Zeiger dereferenzieren und den Wert erhalten, der. Es zeigt darauf, ob Sie
die Werte des Zeigers anzeigen möchten, da ein Zeiger
einen Wert im Speicher hat, sondern
nur eine Adresse. Was ist, wenn
Sie den Zeigerwert anzeigen möchten, der durch eine
Hexadezimalzahl, eine Ganzzahl und eine Adresse dargestellt wird?
Nun, Sie können den Formatbezeichner Prozent p verwenden. Wir haben schon darüber gesprochen.
Dadurch wird ein Zeigerwert als Speicheradresse in hexadezimaler Form ausgegeben.
Wenn wir also so etwas tun,
deklarieren wir unsere Nummer, deklarieren
unseren Zeiger und initialisieren ihn auf null, da dies eine gute Vorgehensweise ist. Wir möchten dies immer dann
tun, wenn Sie dem Zeiger nichts in einer Deklaration zuweisen Stellen Sie sicher, dass Sie es
auf null initialisieren.
Wir weisen dann unsere Zahlenvariable 10 zu.
Und dann weisen wir unseren Zeiger der Adresse der Nummer zu.
Der Wert von p number wird also tatsächlich eine Adresse sein.
eine Adresse. Wenn wir also versuchen würden, es auszudrucken, würden wir Prozent p verwenden, und das wäre der Wert der Adresse.
Wenn wir ausdrucken möchten, worauf es zeigt, müssten
wir es mit dem Indirektionsoperator de-referenzieren.
Wenn Sie die Adresse ausdrucken, wird sie hexadezimal ausgedruckt,
und Zeiger belegen 8 Byte im Speicher,
und Adressen haben 16
hexadezimale Ziffern. Wie funktioniert das?
Nun, es hängt davon ab, ob Ihr Computer 64-Bit- oder 32-Bit-Adressen unterstützt.
Wenn Ihr Computer über ein 64-Bit-Betriebssystem verfügt,
werden 16 hexadezimale Ziffern angezeigt.
Wenn Ihr Computer oder Ihr Betriebssystem nur
über eine 32-Bit-Adressierung verfügt, wird die Hexadezimalzahl als 8 Hexadezimalziffern dargestellt.
Was ist nun, wenn Sie eine Adresse anzeigen möchten?
Sie können sagen, was der Unterschied ist, weil der Zeiger einen Wert hat.
Sie können die Adresse aber auch mit der Adresse des Bedieners anzeigen.
In diesem Beispiel möchten wir also die Adresse der Nummer anzeigen.
Zahl ist kein Zeiger. Zahl ist nur eine ganze Zahl.
Wenn wir die Adresse davon erhalten möchten, verwenden wir das kaufmännische Und.
Wenn wir die Adresse davon anzeigen möchten, verwenden Sie einfach wieder Prozent p.
Sie wenden einfach das kaufmännische Und an.
Wenn wir also das kaufmännische Und mit der Zeigervariablen versorgen, würden
wir tatsächlich die Adresse dieses Zeigers anzeigen,
nicht den Wert des Punktes. Denken Sie daran, dass die Adresse des Zeigers eine Adresse im Speicher ist.
Der Zeigerwert ist eine Adresse, auf die er zeigt.
Und der Wert, auf den es zeigt, befindet sich an einer anderen Stelle im Speicher.
Denken Sie also an diese Abbildung,
in der wir gezeigt haben, wie Zeiger funktionieren.
Wenn Sie einen Zeiger deklarieren, wird ein Speicher für diesen Zeiger mit
8 Byte erstellt.
Der Wert dieses Zeigers ist eine Adresse.
Und dann ist alles, auf das dieser
Zeiger zeigt, ein Wert, normalerweise von dem Typ, den Sie angegeben haben.
Aber denken Sie daran, dass es wirklich drei Teile davon gibt.
Wenn Sie die Adresse mit den p-Nummern ausdrucken möchten, verwenden Sie erneut das kaufmännische Und.
Das wäre die Adresse des eigentlichen Zeigers.
Und Sie müssten den leeren Stern verwenden, um eine Warnung zu umgehen.
Denken Sie also daran, dass ein Zeiger selbst wie jede andere Variable eine
Adresse hat, die beim Deklarieren zugewiesen wird.
Sie verwenden Prozent p als Konvertierungsspezifizierer, um Adressen anzuzeigen.
Sie verwenden das kaufmännische Und die Adresse des Operators, um auf die Adresse zu
verweisen, die die Variable p number belegt.
Das ist die Adresse des Zeigers. Andererseits hat der Zeiger den
Wert einer Adresse.
Die Umwandlung einer Leere soll eine Warnung des Compilers
verhindern, insbesondere erwartet die prozentuale p-Spezifikation, dass der Wert eine Art Zeigertyp ist.
Die Art der kaufmännischen Und-Zahl ist jedoch ein Zeiger auf einen Zeiger davon.
Und so muss man es besetzen.
Anzeigen der Anzahl der von einem Zeiger verwendeten Bytes.
Eine andere Möglichkeit, Informationen über einen Zeiger abzurufen.
Hier können Sie den Operator sizeof verwenden. Wir haben gelernt, wie groß
der Operator ist, um verschiedene Datentypen Bytes anzuzeigen. Sie können dasselbe mit einem Zeiger tun.
Auf einem Computer, den ich verwende, belegt dies 8 Bytes.
Die Maschinenadresse hat 64 Bit, da es
sich um ein 64-Bit-Betriebssystem handelt.
Wenn Sie sizeof auf diese Weise verwenden, wird möglicherweise eine Compiler-Warnung
angezeigt. Sizet ist ein implementierungsdefinierter Integer-Typ.
Um die Warnung zu verhindern, können Sie das Argument in einen Typ int wie diesen umwandeln.
Was Sie also tun würden, wäre, Sie würden p-Zahlengröße, Prozent d Bytes sagen.
Und du würdest int sagen, wirf es auf eine Zollgröße von p Zahl.
Das gibt Ihnen die Größe des Zeigers im Speicher, die Größe des Zeigers dieser
Adresse, die auf den meisten Systemen wiederum acht Bytes beträgt.
Weil das nur eine Adresse enthält.
Ein weiteres Beispiel hier. Dies wird eine Reihe von Dingen anzeigen.
Und wir werden dieses Beispiel ausführen, um die Ausgabe zu zeigen.
Aber kurz bevor wir es laufen lassen, möchte ich ein wenig beschreiben, was hier los ist. Wir haben eine Nummer, die deklariert ist.
Wir haben einen Zeiger, der die Null initialisiert.
Wir setzen den Wert der Zahl auf 10.
Und dann wollen wir die Adresse der Ganzzahl
ausdrucken, und wir wollen den Wert der Zahl ganz einfach ausdrucken, indem wir
die Adresse des Operators und dann nur die Variable verwenden.
Wenn wir die Adresse des Betreibers eingeben, geben wir Prozent p an.
Wir werden dann unserem Zeiger die Adresse der Nummer zuweisen.
Wir werden dann einige Zeigerinformationen ausdrucken.
Wir wollen die Adresse des Zeigers selbst ausgeben.
Wir können nur Prozent p, Leerzeichen und kaufmännisches Und verwenden.
Wir wollen sehen, wie viele Bytes dieser Zeiger im Speicher hat. Wir können sizeof sagen.
Wir wollen den tatsächlichen Wert des Zeigers sehen,
der eine Adresse ist. Wir können einfach p-Zahl ohne
zusätzliche Informationen sagen und dann verwenden wir Prozent p.
Wenn wir den Wert sehen wollen, auf den
der Zeiger zeigt, den Wert an der Adresse, dann
machen wir die Sternzahl p, wir verwenden den Indirektionsoperator.
Und wir wissen, dass die p-Zahl auf ein In zeigt, also können wir Prozent d sagen.
Schauen wir uns dieses Beispiel in Codeblöcken an, um zu sehen, wie es tatsächlich angezeigt wird.
Was wir sehen werden, sind einige hexadezimale
Zahlen für Adressen, wenn wir Adressen anzeigen, und in anderen Fällen werden wir Werte sehen.
Das sollte also vertraut aussehen. Dies ist nur ein Programm,
das Ihnen zeigt, wie Sie auf verschiedene Teile eines Zeigers zugreifen können.
Wir haben also wieder einen regulären Zahlendatentyp int und wir haben
unseren Zeiger. Wir initialisieren es auf null.
Wir werden zuerst unsere Nummer anzeigen, die 10 ist. Hier wird also die Adresse der Nummer
und dann der Wert der Nummer in den Zeilen 10 und 11 angezeigt.
Wir werden dann unseren Zeiger zuweisen, die Adresse der Nummer.
Wenn wir die tatsächliche Adresse unseres Zeigers sehen möchten, verwenden wir einfach das kaufmännische Und, die
Adresse des Operators, und setzen es in void void um.
Wir verwenden Prozent p.
Wenn wir sehen wollen, wie viele Bytes sich der Zeiger im Speicher befindet, machen wir Prozent d sizeof.
Wenn wir sehen wollen, dass die Adresse den Wert von Erdnuss als Zeiger hat, machen
wir Prozent p und sagen nur p-Nummer, weil p-Nummer eine Adresse ist.
Wenn wir sehen wollen, auf was der Zeiger zeigt, mit dem Wert
der Adresse, die im Wert des Zeigers enthalten ist, sagen wir
einfach Sternchen p Nummer, wir dereferenzieren ihn, den Indirektionsoperator.
Also lass uns das machen.
Wenn ich dies ausführe, sehen Sie die ersten
beiden Dinge, die ausgedruckt werden, die
Zahlenadresse in Zeile sechs und eine hexadezimale Zahl, 0060ff0c.
Und hier wird tatsächlich ein 32-Bit-Programm ausgeführt, sodass Sie sehen, dass es nur 8
Bit sind.
die Zahlenvariable, die 10 ist.
Wir drucken dann die Adresse des tatsächlichen Zeigers auf den zugewiesenen Speicher aus.
Es ist eine andere Adresse als die Nummer.
Weil dies die Adresse ist, die dem Zeiger zugewiesen wurde.
Die Zeigernummerngröße beträgt 4 Byte, was bedeutet, dass
es sich um eine 32-Bit-Adressierung handelt.
Der Wert des Zeigers, bei dem es
sich um die Adresse der Nummer handelt, sollte identisch sein und lautet 0060ff0c.
Und Sie sehen, dass Sie die Nummernadresse tatsächlich erhalten
können, indem Sie nur den Namen verwenden, den Zeiger mit Prozent p.
Wir haben die Größe des Operators 4 Bytes gesehen.
Wenn Sie den Wert erhalten möchten, auf den die p-Nummer zeigt, der
10 ist, müssen Sie ihn mit dem Indirektionsoperator de-referenzieren, und Sie sehen, dass er mit 10 gedruckt ist.
Sie sehen jedoch, dass Sie Prozent p verwenden, wenn Sie
Adressen anzeigen. Verwenden Sie Prozent e, wenn Sie Werte des Ganzzahlzeigers oder die
Anzahl der Bytes anzeigen.
Dies ist also die grundlegende Syntax für den Zugriff auf Zeigerwerte.
Adresse des Zeigers, kaufmännisches Und, Wert,
auf den der Punkt zeigt, nur der Name der
Variablen und der Wert des Zeigers selbst ist nur der Name der Variablen, dann
der Wert, auf den der Zeiger zeigt, um den Indirektionsoperator zu verwenden.
Vielen Dank. Hoffe das hilft. Studieren Sie dies, führen Sie dies durch.