Hallo und willkommen zurück. Ich möchte einer Demonstration eine Lösung
für unsere vorherige Herausforderung bieten, die mit dem Verständnis von Zeichenarrays zu tun hat.
Hauptsächlich werden wir Funktionen schreiben, um die Länge einer Zeichenfolge zu ermitteln,
Funktionen zum Verketten einer Zeichenfolge und eine Funktion zum Überprüfen,
ob zwei Zeichenfolgen gleich sind.
Also werde ich ein Projekt erstellen. Ich werde es nur
so nennen, dass ich Zeichenketten verstehe.
Als erstes implementieren wir diese Längenfunktion.
Wir werden
oben drei Funktionsdeklarationen erstellen.
Wir werden die erste Länge einer Zeichenfolge benennen.
Wir werden Kamelhülle für unsere Benennung verwenden.
Dies erfordert nur eine konstante Zeichenfolge.
Woher wissen wir also, dass es sich um eine Zeichenfolge handelt, weil es sich um ein
Zeichenarray handelt, und dann setzen wir ein Semikolon. Das wird das erste sein, das erstellt wird, also hören
wir erst einmal dort auf.
Und wir werden diese
Funktion erstellen und
unten definieren, damit Sie das nette Schlüsselwort const verstehen.
Const bedeutet, dass es sich um eine Zeichenfolge handelt, die sich nicht ändern kann und nicht geändert werden kann.
Der Grund, warum wir const hier verwenden,
ist, dass wir die Zeichenfolge innerhalb der Funktion nicht ändern möchten,
sondern sie nur analysieren und dann die Länge und eine Ganzzahl zurückgeben möchten.
Diese Funktion ist eigentlich ziemlich einfach zu implementieren, da wir nur ein Array durchlaufen.
Wir können also tatsächlich sagen, dass in count
gleich null ist. Dies ist eine lokale Variable.
Es kann nur innerhalb dieser Funktion verwendet werden.
Jetzt fragen Sie sich vielleicht, warum wir die Größe des Operators nicht
verwenden können, da die Größe des Operators uns die Größe der Zeichenfolge und nicht
die Anzahl der Zeichen in dieser Zeichenfolge angibt.
Wir müssen jedoch nur eine Schleife erstellen
und das Array durchlaufen, bis wir den Null-Terminator erreichen.
So können wir uns unsere Saite ansehen. Wir können sagen,
wow, die Anzahl der Zeichenfolgen ist nicht gleich dem
Nullterminator, der Nullterminator wird in einem einzelnen Zeichen
als Backslash Null dargestellt.
Und wir können den Operator ungleich verwenden, weil wir mit Zeichen vergleichen.
Und wir haben nur eine Sache im Hauptteil dieser while-Anweisung plus plus count,
nur die Anzahl zu erhöhen.
Und dann wollen wir es zurückgeben, wir sagen nur Return Count und das wars.
Das ist die gesamte Stringlängenfunktion. Es ist ziemlich einfach, da
sich die Zeichenfolge innerhalb eines Arrays befindet
und die Zeichenfolge mit einem Nullterminator endet.
Um dies zu testen, können wir
unsere Hauptmethode starten und einige konstante
Zeichen erstellen. Sagen Sie
einfach Wort eins,
Jason.
So erstellen Sie ein Zeichenarray in c.
Sie müssen die Konstante dort nicht haben, aber dies wird nicht geändert.
Verwenden Sie das Schlüsselwort char, den Datentyp char, den Bezeichner und dann die Klammern.
Es ist besser, die Größe nicht in Klammern anzugeben,
da der c-Compiler automatisch einen Nullterminator hinzufügt.
Und dann setzen Sie
direkt nach dem Zuweisungsoperator Ihr Zeichenfolgenliteral in doppelte Anführungszeichen.
Wir werden hier ein paar erstellen, um sicherzustellen, dass es funktioniert.
Wir können Zeichenketten sehr einfach anzeigen, da wir nur das Prozent-Symbol
verwenden können, außer was wir hier wirklich anzeigen möchten, sind
die Längen. Also werden wir Prozent
d verwenden.
Also drucken wir einfach die Links dieser drei
Zeichenfolgen aus, Prozent d, und wir haben nur ein paar Leerzeichen dazwischen und fügen
dann einen Zeilenvorschub hinzu.
Und dies wird nur die Zeichenfolgenlängenfunktion für jedes Wort aufrufen,
hier ziemlich
einfach, und das ist es. Jetzt können wir bauen und testen, ob dies tatsächlich funktioniert.
Was wir als Ausgabe sehen sollten, ist, dass wir die Länge
von Jason sehen sollten, die 5 ist, die Länge von okay, die 2 ist, und die
Länge von allem, was ungefähr 8 zu sein scheint.
Hier haben wir also 5, 2 und 8, was richtig aussieht.
So können Sie eine Zeichenfolgenlänge schreiben. Fahren wir mit der Verkettungsfunktion fort.
Die Verkettungsfunktion
benötigt nur drei Zeichenfolgen und zwei Konstanten.
Und das wird nichts zurückgeben. Es wird nur die
resultierende Zeichenfolge in den ersten Parameter eingefügt.
Also nennen wir es concat. Wir werden ein
Ergebnis haben, und wir werden zwei
Zeichenfolgen haben, eine, die wir zwei verketten wollen, und eine, die wir
nur eine einzelne Zeichenfolge haben wollen. Also nennen wir String eins, String zwei.
Und los geht's. Und das ist unsere Funktionsdeklaration.
So können wir überall verwenden, bevor es definiert ist.
Dieser muss auch das Array durchlaufen. Es müssen nur zwei Arrays durchlaufen werden, und
während wir die einzelnen Arrays durchlaufen, fügen Sie sie der resultierenden Zeichenfolge hinzu.
Wir werden ein paar lokale Variablen erstellen, die wir nur innerhalb dieser Funktion verwenden
können, int I und j.
Und dann werden wir eine for-Schleife verwenden,
um das Array zu durchlaufen. Wir werden sagen, dass ich gleich 0 bin.
Str sub 1 oder sub sollte ich sagen, ist
nicht gleich dem Nullterminator und
erhöht dann auch I.
Wir sind mit unserer for-Schleifensyntax
vertraut, bei der wir als erstes die Schleifenkennung haben.
Vor dem ersten Semikolon die Bedingung, bei der wir vor
dem zweiten Semikolon herausspringen
und dann die Regelungsvariable ändern, um sicherzustellen, dass wir keine Endlosschleife haben.
Alles, was wir hier tun, ist, dass wir
Ergebnisse speichern. Sub I entspricht str einem Sub I.
Denken Sie daran, dies sind Zeichen, daher ist es vollkommen in Ordnung, hier die gleiche Zuordnung zu verwenden.
Dies ist in
Zeichenarrays nicht möglich, da Sie einem Array kein Array zuordnen können.
Wir müssten eine str-Kopie verwenden.
Das ist also das Kopieren der ersten Zeichenfolge.
Und jetzt wollen wir die zweite Zeichenfolge mit den
Ergebnissen verketten, also würden wir etwas sehr sehr Ähnliches tun, außer dass wir
uns das zweite Array ansehen und sicherstellen, dass wir es an der richtigen Stelle im Ergebnis platzieren.
Also würden wir so etwas machen. Wir würden von j
nach null gehen, str nach j ist nicht gleich dem Nullterminator ++ j.
Und Sie werden sehen, dass das Ergebnis nur I plus j sagt, also was auch immer ich endete.
Wenn ich zehn Zeichen hinzugefügt habe, beginnt
es jetzt mit dem zehnten Zeichen, da es auf Null basiert, und
es fügt nur j hinzu, also 10 plus 0, 10 plus 1 und so weiter.
Und das ist es.
Eine letzte Sache, die Sie tun müssen, die wirklich wichtig ist, ist, dass Sie diesen Nullterminator hinzufügen müssen.
Wir wollen also Ergebnis sagen, I plus j, und
dann ein einzelnes Zeichen hinzufügen, den
Nullterminator, der in einem einfachen Anführungszeichen Backslash Null ist.
Und das ist unsere Funktion.
Wir müssen nichts von dieser Funktion zurückgeben,
da wir nur in Str eins nach Str zwei kopieren.
Also lasst uns das testen.
Was ich erwarten würde, um dies zu tun, ist es mit ein paar Charakteren zu testen.
Wir werden die vorhandenen Zeichen verwenden, die wir haben, und wir
werden nur ein paar verketten.
Wir müssen also ein anderes
Ergebnis erstellen. Also sagen wir
einfach Ergebnis, nur um es zu löschen.
Hier werden wir sagen, dass
wir für diese erste eine Größe angeben müssen.
Und so werden wir nur eine Größe von 50 angeben. Wir werden es begrenzen.
Diese konstanten Zeichen sollten also funktionieren.
Jetzt sagen wir nur printf, wir
drucken eine Zeichenfolge aus.
Also sagen wir Prozent s und dann Concat, wie
wir es genannt haben. Wir werden die Ergebnisse
weitergeben und dann Wort eins und Wort zwei.
Also, was dies als Ausgabe angezeigt werden soll,
und wir werden sicherstellen, dass wir es in ein paar neue Zeilen setzen.
Dies sollte als Ausgabe angezeigt werden. Jason okay. Concat gibt also eigentlich keine Daten zurück, daher kann
ich sie nicht direkt in den printf einfügen.
Was ich tun muss, ist es aufzurufen und dann das Ergebnis anzuzeigen.
Also nennen wir dort concat.
Alles wird in das Ergebnis eingefügt und wir zeigen das Ergebnis an.
Also, wenn wir das laufen lassen, sollten wir Jason
in Ordnung sehen und wir tun es.
Die dritte Funktion,
die wir implementieren möchten, ist eine Vergleichsfunktion, um zu überprüfen, ob zwei Zeichenfolgen gleich sind.
Diese Funktion sollte einen Booleschen Wert zurückgeben.
Deshalb möchten wir unseren Standard-Bool einbeziehen.
Wir können also boolesche und wahre und falsche Werte verwenden.
Und dies wird tatsächlich als gleiche Zeichenfolge definiert.
Dies erfordert ein konstantes Zeichenarray, s1 und ein anderes, um
zu überprüfen, ob zwei Zeichenfolgen
gleich sind.
Um sicherzugehen, dass ich den richtigen Header eingefügt habe, werde ich versuchen, das zu
erstellen, und ich glaube, ich habe es getan, weil ich jetzt
das Schlüsselwort bool verwenden kann, weil ich dies eingefügt habe und auch true false verwenden kann.
Implementieren wir also diese gleichen Zeichenfolgen.
Dies wird sehr ähnlich sein, wenn
man nur das Array durchläuft und jedes Zeichen überprüft.
Also werden wir ein paar
lokale Variablen erstellen, die für unsere Schleife, die mit 0 initialisiert wurde, gleich 0 sind.
In einem Booleschen Wert sagt uns
das nur, ob sie gleich sind, denn das werden wir zurückgeben, so etwas ist gleich. Und wir könnten dies tatsächlich auf false initialisieren.
Was wir zuerst tun wollen, ist, dass wir die Zählung bekommen wollen.
Wir wollen sehen, wie groß
beide sind. Wir können also eine while-Schleife haben,
da wir die Anzahl benötigen, um die Größe zu
betrachten und nur nach dieser
Nullterminierung zu suchen.
Wir gehen also davon aus, dass die Zeichenfolgen, die wir übergeben, dieselbe Größe haben.
So können wir eine einfache while-Schleife schreiben. Sie könnten auch if-Anweisungen schreiben.
Ich habe alles in eine
while-Schleife integriert, um meine Vergleiche mithilfe der logischen Operatoren durchzuführen.
Sie müssen keine logischen Operatoren verwenden. Sie können eine if-Anweisung verwenden und einfach die
gesamte zweite Zeichenfolge durchgehen.
Aber hier habe ich gesagt, während s1
sub I gleich s2 sub I ist
und sie nicht gleich Nullterminatoren sind.
Denn wenn sie gleich Nullterminatoren
sind, möchten wir herausspringen, wenn einer von beiden ein Nullterminator ist.
Also sagen wir jetzt plus plus I. Und als letztes müssen wir nur
prüfen, ob dies Nullterminatoren sind. Wenn dies der Fall ist, können Sie Ihre boolesche Variable
so einstellen, dass die richtigen Daten zurückgegeben werden.
Hier können wir also sagen, ob s1 sub I
gleich einem Nullterminator und s2 sub
gleich null terminator ist, setzen Sie unsere boolesche Variable
gleich und dann wollen wir das zurückgeben.
Und dann sagen Sie einfach, dass die Rendite gleich ist.
Und um dies zu testen, müssen wir eine gute und eine schlechte Zeichenfolge testen.
Also lasst uns weitermachen und gleiche Saiten sagen.
Ich werde nur den ganzzahligen Wert des Booleschen Werts ausdrucken,
also Prozent d, und wir werden hier gleiche Zeichenfolgen sagen, dies gibt etwas zurück,
damit wir dies
in den Druckausdruck gleich Zeichenfolge einfügen können. Ich möchte nur sicherstellen, dass
die Zeichenfolgen gleich
sind, und dann geben wir das Jason-Komma Jason ein.
Und wir werden es nennen und dieses
Mal werden wir Jasons sagen.
Und der erste sollte eins zurückgeben, der zweite null,
eins steht für wahr, null steht für falsch.
Wenn wir dies ausführen, sehen wir eins
und null. Eins für wahr und null für falsch,
außer es ist schwer zu lesen, weil wir keinen Zeilenvorschub haben. Fügen wir also einen Zeilenvorschub
hinzu und zeigen Sie ihn erneut.
Jetzt sehen wir eine Null,
wahr falsch. Jason Jason ist einander gleich.
Jasons Jason ist nicht gleich.
Dies sind also einige schnelle
Funktionen, von denen Sie jetzt lernen können, die Sie grundsätzlich über die Zeichenarrays
und die Darstellung von Zeichenfolgen mit diesem Konzept lernen.
Vielen Dank. Ich werde auch die Quelldatei bereitstellen, damit Sie sie genauer betrachten können.
Hoffentlich hat dies bei Ihrer Aufgabe geholfen.