Hallo und willkommen zurück. Nachdem wir die Zeiger etwas detaillierter
verstanden haben, möchte ich über Zeichenzeiger sprechen, hauptsächlich
darüber, wie Sie Zeichenzeiger zur Darstellung von Zeichenfolgen verwenden können.
Zeichenfolgen sind Zeichenarrays, mehrere Zeichen, Wörter.
So wissen wir jetzt, wie sich Arrays im Konzept der Zeigerarithmetik auf Zeiger beziehen.
Sehr, sehr nützliches Konzept.
Diese Konzepte können sehr nützlich sein, wenn sie auf
Zeichenfolgen von Zeichenarrays angewendet werden, da wir jetzt eine Zeichenfolge Zeichen für Zeichen leicht durchlaufen können.
Eine der häufigsten Anwendungen bei der Verwendung eines Zeigers auf ein Array
ist der Zeiger auf eine Zeichenfolge.
Die Gründe liegen in der Bequemlichkeit und Effizienz der Notation.
Wenn Sie also eine Variable vom Typ Zeiger auf char verwenden, um
auf eine Zeichenfolge zu verweisen, erhalten Sie viel Flexibilität.
Sie werden also versuchen,
Zeichenzeiger so oft wie möglich über
Zeichenarrays zu verwenden, insbesondere Zeichenzeiger, um Daten an eine Funktion zu übergeben.
Alle möglichen schönen Dinge.
Schauen wir uns also ein Beispiel an, bei dem ein Array zum Kopieren einer Zeichenfolge verwendet wird.
In diesem Beispiel wird unser Array-Parameter ein Zeichenarray sein.
Das sehen Sie direkt in der Funktionsdeklaration.
Ich möchte dies mit einer Funktion vergleichen, die einen
Zeichenzeiger verwendet, und Ihnen zeigen, wie die Zeichenzeigerfunktion viel effizienter ist.
In diesem Beispiel haben wir zwei Funktionen,
eine für ein Array und
eine für Zeiger.
In der ersten Funktionskopiezeichenfolge können
wir das gesamte Array mit einer for-Schleife I durchlaufen, die von Sub I
gleich Null ist, und wir gehen den ganzen Weg, bis wir die
Nullzeichenfolge sehen, und dann erhöhen wir unsere Schleifensteuervariable.
Und dann müssen Sie nur noch sagen, dass 2 Sub I gleich Sub I ist. Wir machen dort einen
direkten Auftrag.
Und dann, ganz am Ende, nachdem wir den ganzen Weg gegangen sind,
bis wir Nullzeichen sehen, fügen wir am Ende unseres to-Arrays
ein Nullzeichen hinzu, ziemlich einfach. Nun wollen wir sehen, wie wir es machen, wenn wir Zeiger verwenden.
Zuerst deklarieren wir Zeiger als Funktionsdeklaration in der Kopierzeichenfolge, indem wir
nur char star to char start from sagen.
In unserer for-Schleife müssen wir keine Variablen deklarieren,
da wir Zeiger haben und nur
iterieren möchten, bis das from den Null-Terminator trifft.
Und dann können wir sowohl die from- als auch die to-Zeiger inkrementieren.
Denn hier machen wir Punktarithmetik.
Wir fügen dem Zeiger nur einen hinzu, der seine Adresse um eins erhöht und
das nächste Zeichen erhält.
Und die nächste for-Schleifenlinie dereferenzieren wir nur auf
und von, weil wir den tatsächlichen Wert,
auf den der Zeiger zeigt, das tatsächliche Zeichen
dem Zeiger auf zuweisen möchten.
Und dann fügen wir ganz am Ende das
Nullzeichen an die Stelle ein, auf die der to-Zeiger zeigt,
die sich am Ende der letzten Adresse des Strings für from befindet, aber
jetzt in die to-Adresse zeigt.
Es sieht nicht schlecht aus. Ich meine, du hast eine for-Schleife.
Sie haben im Grunde die gleiche Anzahl von Codezeilen.
Aber Sie sehen den Unterschied in der Syntax.
Sie verwenden keine Indizes und Sie verwenden Zeiger, verwenden Sie das Sternchen.
Wieder wirklich ein Problem der Bequemlichkeit der Notation.
Sie sehen hier keinen großen Vorteil.
Sie können dies jedoch mehr optimieren, um bei
Verwendung der Zeiger sogar weniger Code zu erhalten.
Wenn Sie also ein char-Array als Zeiger
haben, wenn Sie ein Array von Zeichen haben, das als Text bezeichnet wird, können Sie
auf ähnliche Weise einen Zeiger darauf definieren und die Elemente im Text verwenden.
Hier könnte man also char star
text pointer sagen, so definieren Sie einen Zeichenzeiger.
Wenn der Textzeiger so eingestellt ist, dass er auf den Anfang des
als Text bezeichneten Zeichenarrays zeigt, können Sie
ihn mit diesen Operatoren vor und nach der Implementierung und Dekrementierung einfach um eins erhöhen.
Dieser Plus-Plus-Textzeiger oben setzt den Textzeiger auf das nächste
Zeichen im Text, nämlich Text unter 1.
Wenn wir also wie bei ganzen Zahlen im nächsten Strahl
suchen wollen, müssen wir nur 1 2 addieren und können das nächste Zeichen erhalten.
In Zeichenarrays ist dies jedoch
viel nützlicher, da Sie Zeichen leicht einzeln bearbeiten können.
Wenn Sie einen Minus-Minus-Textzeiger ausführen, bei dem es sich um den Dekrementierungsoperator
handelt, wird der Zeiger auf das vorherige Zeichen im Text
gesetzt, sofern der Textzeiger nicht auf den Textanfang zeigt.
Denn wenn es so wäre, würden Sie diese Fehler unter Grenzen haben.
Wenn es ein Plus-Plus am Ende der Zeichenfolge gibt, liegt ein Fehler außerhalb der Grenzen vor.
Sie müssen immer vorsichtig sein, genau wie bei einer Ganzzahlarithmetik, um die Grenzen eines Arrays nicht zu überschreiten.
Aber sehr einfach, es hängt sehr eng damit zusammen, wann Sie
ganzzahlige Zeigerarithmetik betreiben.
Zeichenzeigerarithmetik ist dasselbe.
Es ist nur noch nützlicher, weil Sie jetzt tatsächlich einzelne Zeichen betrachten können, ohne einen Index zu verwenden.
Wenn wir uns also das vorherige Beispiel
ansehen und es mithilfe von Zeigern ein bisschen mehr optimieren können, um
noch weniger Codezeilen zu erhalten.
In unserer Kopierzeichenfolge führen wir diese Funktionsdeklaration wie zuvor aus. Erstellen Sie
ein paar Zeiger mit dem Sternchen.
Wir verwenden jedoch keine for-Schleife mehr, da es im vorherigen Beispiel
irgendwie sinnlos war, eine for-Schleife zu
verwenden, da wir die Regelungsvariable der Schleife nicht wirklich initialisieren mussten.
Alles, was wir tun mussten, war, eine Schleife unter
einer Bedingung zu verlassen, und dann verwenden wir tatsächlich die Inkrementierungs- und Dekrementierungsoperatoren
in der for-Schleife, aber das müssen wir nicht einmal tun.
Hier wird es sogar noch viel einfacher, denn wenn wir eine while-Schleife verwenden,
müssen wir uns nur die while-Schleife ansehen und sie springt
heraus, wenn sie auf ein Nullzeichen zeigt, da das Nullzeichen tatsächlich
gleich Null ist.
Und die while-Schleife erinnert sich, dass Boolesche Werte
in c durch ganze Zahlen dargestellt werden, eins ist wahr und dann
ist Null falsch oder wirklich Null ist falsch und dann ist alles andere wahr.
In diesem Fall wird das Nullzeichen 0, das falsch ist, herausspringen.
Alles, was Sie für die Exit-Bedingung in der while-Schleife tun müssen, ist ein Sternchen von.
Was ist das für eine Dereferenzierung, um zu sehen, was der Wert dieses Charakters ist?
Wenn wir also am Ende des Strings angelangt sind, von dem wir kopieren möchten, springen wir heraus.
Ansonsten setzen wir einfach unsere Modifikation unserer
Zeiger genau dort ein, zwei plus plus von plus plus.
Dies ist ein Post-Inkrementierungsoperator.
Dies bedeutet also, dass sich das Plus-Plus auf der rechten Seite der Variablen befindet.
Und wenn Sie dies tun, bedeutet dies,
dass Sie erst nach Abschluss der Anweisung eine hinzufügen.
Also, was dies tun wird, wird sagen, dass Stern 2 gleich Start ist.
Und nachdem diese Anweisung fertig ist, wird sie zu 2 1 und von 1 zu 1 addiert.
Wenn Sie das Pluszeichen vor dem Variablennamen hätten, würde es
dieser Variablen hinzugefügt, bevor diese Anweisung ausgeführt wird, und das wäre ein Problem, da
wir im Wesentlichen das erste Element vermissen würden, das in die
Zeichenfolge kopiert wird.
Wir brauchen aber keine Codezeilen mehr. Wir führen eine tatsächliche Inkrementierungszeigerarithmetik und
-zuweisung in derselben Anweisung durch, sodass wir den
Code um eins reduzieren.
Auch hier ist die Notation sehr einfach.
Wir führen sehr einfach eine ganzzahlige arithmetische Zuordnung durch.
Und am Ende, nachdem wir alle Zeichenfolgen kopiert haben, fügen
wir am Ende einfach das Nullzeichen
zum Zeiger hinzu, den wir dereferenzieren, weil die beiden tatsächlich der Grund sind, warum
es die Schleife durchläuft, auf die es bis zum letzten zeigt Charakter.
Also ist es hier nur ein bisschen aufgeräumt.
Es zeigt Ihnen die Leistungsfähigkeit von
Zeigern und wie Sie Zeiger und Arithmetik in denselben Zeilen
verwenden können. Mit diesen Inkrementierungs- und Dekrementierungsoperatoren, diesen Plus- und Minus-Minuspunkten, wird
es noch schneller und einfacher, sodass es auch effizienter ist.
Wenn wir diese Kopierzeichenfolgenfunktionen verwenden möchten, können wir einfach zwei Zeichenarrays erstellen.
Wir können die Zeichenarrays direkt an die Kopierzeichenfolge übergeben, da die 0-Zeichenarrays
Zeiger sind.
Sie sind Zeiger, daher müssen wir sie nicht de-referenzieren
oder Adressen oder ähnliches hinzufügen. Wir könnten einfach string2, string1 sagen.
Damit wird also eine Zeichenfolge kopiert, die
in das Zeichenfolgenarray string2 kopiert werden soll, und
anschließend mit printf ausgedruckt.
Ich wollte ein Beispiel durchgehen, wie Sie Zeichenzeiger
anstelle von Zeichenarrays verwenden können und warum sie manchmal bevorzugt werden.
Wir haben erwähnt, dass es manchmal die Präferenz von Programmierern ist,
wenn Sie in früheren Sprachen wie Fortran programmiert haben,
können Sie zum Erhöhen verwendet werden. Aber wenn Sie es haben,
werden Sie die Vorteile der Verwendung von Zeigern sehen.
Hoffe das war hilfreich. Vielen Dank.