Hallo und willkommen
zurück In dieser Vorlesung möchte ich unsere Herausforderung
für die Zeigerarithmetik und die Verwendung des Konstantenmodifikators demonstrieren.
Lassen Sie uns Codeblöcke aufrufen. Ich werde ein neues Projekt erstellen. Wir werden dieses
Beispiel mit einem Zeigerarithmetik nennen.
Wir werden hier also die
Länge eines Strings mithilfe der Punktarithmetik bestimmen.
Als erstes möchte ich meine Funktionsdeklaration erstellen.
Dies gibt die Länge der Zeichenfolge zurück. Es wird also int
als Rückgabetyp haben. Ich werde es Stringlänge nennen, und
dies wird nur einen Zeiger nehmen, aber es wird ein konstanter Zeiger sein.
Wir wollen den Wert dessen, worauf wir zeigen, nicht ändern.
Das heißt, wir würden die Konstante als erstes Schlüsselwort verwenden und dann den
Typ angeben, bei dem es sich um ein Zeichen handelt.
Und wir würden Stern sagen, und wir können es benennen, was wir wollen, Zeichenfolge.
Noch einmal, um es noch einmal zu wiederholen: Wenn wir stattdessen die Konstante hier gesetzt hätten, würde
dies bedeuten, dass sich die Adresse des Zeigers und der
Wert des Zeigers nicht ändern können.
Aber auch hier ist es irgendwie überflüssig und es muss
nicht wirklich gemacht werden, weil wir Pass-by-Value-Pass-by-Copy machen.
Sie haben also trotzdem eine Kopie der Adresse, sodass es keine Rolle spielt, ob Sie sie dort ändern.
Es ist jedoch wichtig zu ändern, auf was Sie zeigen. Wenn Sie nicht möchten, dass sich der
Wert dessen, worauf Sie zeigen, ändert, möchten Sie dies auf jeden Fall ständig tun, und
das ist wichtig.
Jetzt müssen wir nur noch unsere Hauptleitung erstellen.
Erstellen Sie unsere Haupt. Alles, was wir in
unserer Hauptsache tun werden, ist, die
Stringlänge aufzurufen, eine Stringlängenfunktion mit verschiedenen Strings.
Drucken wir also aus und denken Sie daran, dass eine Ganzzahl zurückgegeben wird, sodass wir Prozent d sagen können,
und wir werden nur die Länge einiger Zeichenfolgen ausdrucken, die wir übergeben.
Wir werden also die Länge der Zeichenfolge aufrufen
und nur einige konstante Zeichenfolgen übergeben, damit wir die Dinge hier
einfach in doppelte Anführungszeichen setzen können. Wir müssen nicht einmal Zeiger erstellen.
Sie könnten einen Zeiger erstellen und ihn zuweisen und dann übergeben, aber Sie müssen
nur sicherstellen, dass es sich um eine Konstante handelt.
Da es jedoch mit weniger Code einfacher ist, können wir einfach den Stringlängentest sagen.
Auch das ist eine konstante Literalzeichenfolge.
Wir werden es mit etwas mehr testen.
Wir werden ein Leerzeichen danach setzen. Fügen wir einige Zeilenvorschübe hinzu.
Hier nennen wir Stringlänge. Und nennen wir es tatsächlich mit der leeren Zeichenfolge.
Stellen Sie sicher, dass wir Null werden. Und dann
sagen wir bei unserer dritten Saitenlänge,
wir sagen nur Jason.
Wenn Sie diese erstellen und diese Zeichenfolgenlängenverknüpfungen übergeben,
wird ihnen übrigens automatisch der Nullterminator hinzugefügt.
Das lernen wir, wenn wir Zeiger deklarieren.
Das ist einer der Vorteile. Wenn Sie einen Zeiger erstellen und es sich
um ein Literal handelt, möchten Sie die Größe nicht angeben.
Sie möchten so etwas wie ein Zeichen ausführen, wenn es sich um ein Array
handelt, da ein Array ein Zeiger ist. Aber wenn
wir die Größe nicht angeben möchten,
können wir Zeichen p und hier drinnen einfach Jason sagen.
Denken Sie an diese Lektion, in der, wenn wir die Größe für Zeichenarrays nicht
angeben, automatisch ein Nullterminator hinzugefügt und die Größe für Sie erstellt wird.
Auf diese Weise machen Sie keine Fehler. Wenn Sie die Größe in das Array
einfügen, haben Sie möglicherweise nicht genug vom Null-Terminator.
Es ist dasselbe, wenn wir das Literal an die Zeichenfolgenlänge
übergeben, wird der Nullterminator am Ende hinzugefügt.
Wir hätten diese Variablen also
zunächst erstellen und so etwas tun und
dann jede übergeben können.
Aber ich wollte keine Zeit damit verschwenden, Variablen zu erstellen. Also mache ich das einfach.
Was für diesen Code wirklich wichtig ist, ist die Funktion.
Also werden wir unsere Stringlänge erstellen. Denken Sie noch einmal daran, es wird eine Ganzzahl
zurückgegeben, und es wird eine Konstante sein. Wir können also einfach konstante Char-Star-Zeichenfolge sagen.
Außerdem stellen Sie fest, dass der Name
der Funktionsdeklarationsvariablen nicht übereinstimmen muss. Ich könnte das als Zeichenfolge setzen und das ist auch in Ordnung.
Jetzt müssen wir innerhalb dieser Funktion einen lokalen Zeiger erstellen, da der lokale Zeiger
auf das Ende der Zeichenfolge zeigt. Und sobald wir die Adresse für das Ende
der Zeichenfolge haben, können wir die Adresse für den Anfang der Zeichenfolge abziehen.
Die Adresse für den Anfang der Zeichenfolge ist die übergebene Adresse.
Die Zeichenfolge zeigt automatisch auf das erste Element im Array oder
die erste Adresse des Arrays.
Wenn wir also einen lokalen Zeiger
erstellen und einfach wieder einen konstanten Zeichenstern erstellen
möchten, sagen wir einfach die letzte Adresse, wie wäre es.
Und dies wird gleich der Anfangsadresse der Zeichenfolge sein, und dann werden
wir sie jedes Mal in unserer Schleife erhöhen.
Jetzt haben wir also die letzte Adresse. Auch dies ist eine lokale
Variable, die die Adresse direkt vor dem Nullterminator speichert.
Jetzt können wir unsere while-Schleife schreiben.
Und unsere while-Schleife wird beendet, wenn wir den Null-Terminator sehen.
Jetzt können wir dies auf zwei verschiedene Arten tun.
Wir könnten Charaktere vergleichen. Wir könnten also so etwas wie
"while star last address" sagen, weil wir de-referenzieren müssen, dass
es nicht gleich "Backslash
Zero" ist. Das könnte so etwas tun, aber
das ist eine Menge Code. Alles, was wir wirklich tun müssen, ist
nur zu sagen, während wir
bei der letzten Adresse die Hauptrolle spielen. Denn wenn Sie
einen Nullterminator dereferenzieren, ist er gleich
Null und Null ist gleich Falsch.
Wir wissen, dass Boolesche Werte Eins haben. Null ist falsch.
Wenn es also falsch ist, wird es herausspringen. Alles, was Sie tun müssen,
ist in Ihrem Zustand, in dem die letzte Adresse des Sterns angegeben ist.
Auch dies wird den Zeiger dereferenzieren.
Und sobald es auf die letzte Adresse zeigt, zeigt es auf den Nullterminator.
Jetzt müssen wir sicherstellen, dass wir die letzte Adresse ändern, damit sie schließlich auf den Nullterminator verweist.
Hier können wir nur plus plus letzte Adresse sagen.
Bei jeder Iteration dieser while-Schleife wird die Adresse erhöht, bis eine
Null angezeigt wird.
Eine Null steht für den Nullterminator.
Das Endergebnis, nachdem die Schleife ausgeführt
wurde, zeigt die letzte Adresse auf die Adresse des Nullterminators.
Wir können dann die Adresse des Null-Terminators von der
übergebenen Adresse, unserer Zeichenfolge, subtrahieren, und das gibt uns unsere Länge.
Das ist alles, was wir in der nächsten Zeile tun müssen. Wir können einfach sagen, dass wir
unsere letzte Adresse
zurückgeben möchten, und wir möchten
die Adresse tatsächlich abziehen, sodass wir nichts de-referenzieren oder den
Indirektionsoperator, letzte Adresse minus Zeichenfolge, verwenden müssen. Der String wird also übergeben,
wir ändern ihn überhaupt nicht.
Das zeigt auf das erste Zeichen. Das würde auf j zeigen.
Das wäre die Adresse oder zum ersten Mal in Zeile acht, das wäre die Adresse von s.
Die letzte Adresse zeigt auf die Adresse dieses letzten t.
Eigentlich eins mehr als das, der Nullterminator. Wenn wir die letzte Adresse abzüglich
der Adresse von s sagen, erhalten wir die Länge.
Und das werden wir zurückgeben.
Ich hoffe das macht Sinn.
Wiederum erstellen wir in Zeile 17 eine lokale
Variable, da wir die letzte Adresse, die Adresse des
Nullterminators, verfolgen müssen.
Nachdem diese Schleife ausgeführt wurde, zeigt die letzte Adresse nach
dem t, dem Nullterminator.
Dann können wir einfach die letzte Adresse von der Zeichenfolge subtrahieren. Die Adresse der
Zeichenfolge zeigt auf s, wenn sie eingeht. Wir ändern das nicht.
Mal sehen, was passiert, wenn dies uns die richtige Länge zurückgibt.
Wenn wir dies ausführen, sollten wir die Länge für die Zeichenfolgen sehen, die wir übergeben haben.
Wir sehen also 17 0 und 5.
Mal sehen 1 2 3 4 5 6 7 8 9
10 11 12 13, Sie müssen das Leerzeichen zählen, 14
15 16 17. Das ist richtig, wir
setzen doppelte Anführungszeichen, die leer sind, also sollte das Null sein und
dann sollte Jason 5 sein, also 17 0 und 5, das ist richtig.
Was wir hier gemacht haben, war, dass wir
Zeigerarithmetik verwendet haben, um die letzte Adresse plus plus den Inkrementierungsoperator zu
erhalten, und dann unsere Arithmetik gezeigt haben,
um die Länge zu erhalten, indem wir die letzte Adresse minus der Zeichenfolge minutiert haben.
Ziemlich ordentlich. Ich versuche, die Kraft der
Punktarithmetik und die Bequemlichkeit der Notation zu demonstrieren.
Wie Sie einfach inkrementieren, dekrementieren können, um
zu verschiedenen Stellen in einem Zeichenarray zu
gelangen und die Zeichen herauszuholen. In diesem Fall erhalten wir nur die Adressen und verwenden dann
die Adressen, um sich gegenseitig zu minusieren, um die Länge zu erhalten.
Ich hoffe das war hilfreich. Stellen Sie sicher, dass Sie alles verstehen, was ich gerade erwähnt habe.
Wiederum ist das Konzept einer Konstante, das Konzept von Plus plus, das Konzept
der Bedingung, wenn Sie eine Adresse dereferenzieren und
das auf einen Nullterminator hinweist, eine Null, also springt sie dann heraus und dann
dieses Konzept, zwei Adressen zu minusen. Vielen Dank.