Hallo und willkommen zurück.
Da Punktarithmetik ein schwer zu verstehendes und zu verstehendes Konzept ist,
wollte ich ein letztes Beispiel durchgehen,
das dieses Konzept wirklich demonstriert. Es macht einen guten Job.
Und wenn Sie dieses Beispiel verstehen, werden Sie
kein Problem mit der Punktarithmetik haben.
Das erste Beispiel, das ich Ihnen zeigen möchte, ist der
Effekt des Hinzufügens eines ganzzahligen Werts zu einem Zeiger.
Wenn wir also Zeigerarithmetik mit Addition durchführen, können wir
tatsächlich sehen, wie es in Bezug auf die Adressen funktioniert.
Hier in diesem Programm erstelle ich lediglich eine Zeichenfolge, ein
Zeichenarray, das als Zeichenfolge bezeichnet wird.
Und dann erstelle ich einen Zeichenzeiger namens p.
Ich gehe die gesamte Länge der Zeichenfolge durch, die
mehrfach ist. Also gehe ich das gesamte Array durch.
Nennen Sie einfach basic für die Länge der Schleifen mit mehreren Größen und mehreren.
Und dann drucke ich jede tatsächliche
Zeichenfolge oder jedes Zeichen in diesem Array aus.
Und was ich tue, ist, dass ich die
Adresse und dann
die Adresse mit der tatsächlichen Nummer anzeige, die ich hinzugefügt habe.
Schauen wir uns also nur die Ausgabe an, denn die
Ausgabe zeigt ein wirklich gutes Beispiel für Punktarithmetik.
Gehen wir also zu Codeblöcken und führen diese aus.
Hier sind wir also in Codeblöcken. Ich habe den Code ein wenig aufgeräumt.
Ich benutze str Länge, setze eine strn Länge, weil es extra include ist.
Und ich möchte das einfach ausführen.
Wenn ich dies ausführe, werden Sie feststellen, dass es Ihnen zeigt, wie
Sie sich daran erinnern, wie Speicher aussieht, und dass es Ihnen die Werte
zeigt, die die Punktarithmetik ausführen. Wenn Sie also mehrere Sub-0 sagen,
denken Sie daran, dass Multiple nur eine Zeichenfolge enthält.
Aber wenn wir uns das ansehen und sagen, wir schauen uns den Inhalt
des Arrays an, Vielfache von 0 ist ein, Vielfaches von 1 ist ein Leerzeichen und dann ist der Rest ein String.
Das ist das Array.
Gleich daneben ist dasselbe wie das Hinzufügen von 0 zum Zeiger und
das Dereferenzieren, Zeigen von 1 und Hinzufügen von 2.
Und es zeigt Ihnen, wie Sie Zeigerarithmetik ausführen können, indem Sie
den Zeiger selbst dereferenzieren und ihm Zahlen hinzufügen.
Also der Zeiger plus sieben Dereferenzierungen, die Sie erhalten g.
Dann zeige ich Ihnen in der dritten Spalte die
tatsächlichen Adressen, während wir inkrementieren. Wenn also die Adressen jedes
Elements im Array das kaufmännische Und nur auf dem Zeichenarray
verwenden, sehen wir die Adresse 060feff für Element 0 und so weiter.
Und dann schauen wir uns die Adressen an, wenn wir nur
den Zeiger selbst hinzufügen, ohne ihn zu dereferenzieren, und Sie werden sehen,
wie die Adressen in einer Reihe stehen.
Dann können wir uns die Syntax ansehen, um zu sehen, was hier vor sich
geht. Das erste, was wir tatsächlich anzeigen, ist der Index im Array, der nur ein Zähler ist.
Und dann zeigen wir ein Prozent c an, das das
Zeichen im Array ist.
Das nächste, was wir anzeigen, ist die
Dereferenzierung des Zeigers plus I.
Hier zeigen wir also I an und dann
die Dereferenzierung von Zeiger plus I, dem
tatsächlichen Wert.
Wir
zeigen also als
d nur den tatsächlichen Zähler an und dann ist
Punkt c unsere Dereferenzierung. Also ist p unser Zeiger.
Wir sagen nur p plus I, Zeigerarithmetik, und dann
dereferenzieren wir es.
Und um dann die Adressen
zu erhalten, müssen wir nur das kaufmännische Und-Vielfache und dann
den Index angeben, um die Array-Adresse zu erhalten.
Um die erste Adresse des Zeigers hier zu erhalten, sagen wir einfach
p plus
I, um den tatsächlichen Zähler zu
erhalten, der Ihnen zeigt, wie wir dieses p erhöhen.
Wir machen einfach ein p plus Prozent d.
Es zeigt jedoch auf gute
Weise, wie der Speicher, auf den wir auf
die Adressen verweisen, tatsächlich
angezeigt wird und wie sie den
verschiedenen Indizes in einem Array und den tatsächlichen Zeigern entsprechen.
Ich dachte, das hat gute Arbeit geleistet.
Ich möchte noch ein Beispiel anschauen, das einen weiteren guten Job
in Bezug auf Zeigerarithmetik mit Longs macht. Denn hier sind das
ganze Zahlen. Alles was wir tun müssen, ist eins
hinzuzufügen und geht automatisch zum nächsten Byte und so weiter. Schauen wir uns an, was wir tun, wir machen Sehnsüchte.
In diesem Beispiel wollte ich auch nur zeigen, wie Sie dasselbe mit einem
langen und einem langen Zeiger tun können.
Mit dem Zeichenzeiger war es nur ein Zeichenfolgenarray.
Aber auch für lange Arrays mit unterschiedlichen Größen können wir
sie mit einem Zeiger durchlaufen, und Sie können
sehen, wie sich die Anzahl der Bytes tatsächlich ändert.
Obwohl wir sagen, wir haben einen langen Zeiger und fügen einen hinzu, fügen wir tatsächlich 4 Bytes
hinzu, da ein langer etwas größer ist, und das werden wir in diesem Beispiel sehen.
Lassen Sie uns nun dieses Beispiel in Codeblöcken ausführen.
Hier ist unser Beispiel. Wieder haben wir einen ganzzahligen Zähler, einen Schleifenzähler.
Wir haben eine lange Reihe 15l.
Wir geben l an, indem wir das Suffix setzen, dann geben wir ihre
ls an, ihre longs wir haben einen langen Zeiger, der auf mehrere zeigt.
Da es sich um ein Array handelt, müssen wir die Adresse des Operators nicht verwenden.
Wir werden die ganze Zeit durchmachen. Hier können wir keine Rührlänge verwenden, deren Größe
wir verwenden müssen, und wir müssen sie tatsächlich durch jeden Punkt im Array teilen.
Wenn also die Gesamtgröße durch den einzelnen Punkt im Array geteilt
wird, möchten wir herausspringen, da diese
sich an unsere Adressen erinnern, die jeweils um 4 Byte erhöht werden.
Und wieder zeigen wir hier sowohl den Zeiger als auch
das Array an und zeigen Ihnen, wie sie zusammenhängen,
und dann zeigen wir die tatsächliche Gesamtzahl der
Bytes an, die sich auf unserem System befinden.
Dies zeigt erneut, wie Arrays mit
Zeigern zusammenhängen.
Wenn wir dies ausführen,
werden wir eine ähnliche Ausgabe sehen. Was hier jedoch etwas anders ist,
ist die Adressgröße, die um 4 Bytes erhöht wird. Also werden wir die Adresse und den Zeiger ausdrucken.
Für die Adresse und den Zeiger plus
0 ist dies also gleich dem
Array sub 0, das die Adresse 6356728 ist.
Und um den Zeiger zu dereferenzieren, erhalten wir den Wert 15.
Also wird p plus 0 immer noch gleich dem Array sub 0 sein.
Und dann machen wir dasselbe für p plus ein p plus 2 und
p plus 3, die alle den richtigen Stellen im Array für den Index entsprechen.
Die Adressen steigen um 4 Bytes, aber wir können immer noch nur 2 und 3 hinzufügen
und sehen, dass die Werte gleich sind.
Und dann sagt es uns, dass diese lange 4 Bytes belegt und deshalb die Adressen um 4 steigen.
Was hier wichtig ist, ist, dass wir noch eine hinzufügen können und
der Compiler weiß, dass er zur nächsten Adresse gehen muss.
Unabhängig davon, ob wir ein langes oder ein Zeichen haben oder
welcher Datentyp sich auch immer im System befindet, wird durch Hinzufügen
von einem oder zwei die richtige Anzahl von Bytes hinzugefügt.
Nur ein weiteres cooles Beispiel, das ich
Ihnen zeigen wollte, weil diese Zeigerarithmetik wirklich wichtig ist und
beim Iterieren oder Durchlaufen eines
Arrays sehr nützlich ist. Sie macht sie viel sauberer und effizienter.
Ich hoffe das hat geholfen. Vielen Dank.