Hallo, en welkom terug. Ik wil graag een demonstratie geven van
een oplossing voor onze vorige uitdaging die te maken had met het begrijpen van karakterarrays.
We gaan voornamelijk functies schrijven om de lengte van een string te krijgen, een
functie om een string samen te voegen en een functie om te
controleren of twee strings gelijk zijn.
Dus ik ga een project maken. Ik noem het
gewoon het begrijpen van tekenreeksen.
En het eerste dat we gaan doen, is deze lengtefunctie implementeren.
We gaan
bovenaan drie functiedeclaraties maken.
We gaan de eerste string een naam geven.
We gaan camel case gebruiken voor onze naamgeving.
Dit gaat gewoon om een constante tekenreeks.
Dus hoe weten we dat het een string is, omdat het een tekenreeks is
en dan gaan we een puntkomma plaatsen. Dat zal de eerste zijn die wordt gemaakt, dus daar houden
we het nu maar mee op.
En we gaan deze functie
maken, definieer hem
hieronder, zodat je die mooie sleutelwoord const zou moeten begrijpen.
Const betekent dat het een tekenreeks is die niet kan veranderen, niet kan worden gewijzigd.
De reden dat we hier const gebruiken, is
omdat we de tekenreeks in de functie niet willen wijzigen, we
willen deze in feite ontleden en vervolgens de lengte retourneren, een geheel getal retourneren.
Deze functie is eigenlijk vrij eenvoudig te implementeren, omdat we gewoon door een array gaan.
Dus we kunnen eigenlijk zeggen dat het aantal gelijk
is aan nul. Dit is een lokale variabele.
Het kan alleen binnen deze functie worden gebruikt.
Nu kun je jezelf afvragen waarom we de operator size of niet kunnen gebruiken,
omdat de operator size ons de grootte van de tekenreeks gaat vertellen, het vertelt ons
niet hoeveel tekens er in die tekenreeks zitten.
Maar alles wat we hoeven te doen is een
lus maken en door de array gaan totdat we de nul-terminator bereiken.
Dus we kunnen naar onze string kijken. We kunnen zeggen
wow, het aantal strings is niet gelijk aan de
nul-terminator, de nul-terminator wordt weergegeven in een enkel
teken als backslash nul.
En we kunnen de operator niet is gelijk aan gebruiken omdat we vergelijken met karakters.
En we hebben maar één ding in de body van deze while-statement plus
plus count, alleen oplopende telling.
En dan willen we het retourneren, we zeggen gewoon retourtelling en dat is alles.
Dat is de volledige tekenreekslengtefunctie. Het is vrij eenvoudig omdat
de tekenreeks zich in een array bevindt
en de reeks eindigt met een null-terminator.
Dus om dit te testen, kunnen we
onze hoofdmethode starten en kunnen we een
aantal constante tekens maken, zeg
gewoon een woord
Jason.
Dus zo maak je een karakterarray in c.
Je hoeft de constante daar niet te hebben, maar dit wordt niet gewijzigd.
Gebruik het trefwoord char, het gegevenstype char, de identifier en vervolgens de haakjes.
Het is beter om de grootte niet tussen de haakjes op
te geven, omdat de c-compiler automatisch een null-terminator toevoegt.
En dan plaats je net
na de toewijzingsoperator je letterlijke tekenreeks tussen de dubbele aanhalingstekens.
We zullen hier een paar maken om er zeker van te zijn dat het werkt.
We kunnen tekenreeksen heel gemakkelijk weergeven omdat we alleen het
procent-symbool kunnen gebruiken, behalve dat we hier echt de lengtes
willen weergeven. Dus we gaan procent
d gebruiken.
Dus we gaan gewoon de links van deze drie
strings uitprinten, procent d en we zullen alleen wat spaties ertussen hebben en dan
een line feed toevoegen.
En dit gaat gewoon de stringlengte-functie voor elk woord aanroepen,
vrij eenvoudig
hier, en dat is het. Dus nu kunnen we bouwen en testen en kijken of dit echt werkt.
Wat we als output zouden moeten zien, is dat we de lengte
van Jason zouden moeten zien die 5 is, de lengte van oké die 2 is en de
lengte van wat dan ook ongeveer 8 lijkt te zijn.
Dus hier hebben we 5, 2 en 8, wat er goed uitziet.
Dus zo kun je een stringlengte schrijven. Laten we verder gaan met de aaneenschakelingsfunctie.
De aaneenschakelingsfunctie
neemt gewoon drie strings en twee constanten.
En dit levert niets op. Het gaat gewoon om
de resulterende string in de eerste parameter te plaatsen.
Dus we gaan het concat noemen. We krijgen een
resultaat, en we krijgen twee strings,
een waarvan we er twee willen samenvoegen en dan een die
we maar één string willen hebben. Dus we noemen string één, string twee.
En daar gaan we. En dat is onze functieverklaring.
Dus we kunnen overal gebruiken voordat het is gedefinieerd.
Deze zal ook door de array moeten gaan. Het zal gewoon door twee arrays moeten gaan
en als we door elk gaan, voeg het toe aan de resulterende string.
We gaan een paar lokale variabelen maken, die we alleen binnen deze functie kunnen
gebruiken, int I en j.
En dan gaan we een for-lus gebruiken om
door de array te gaan. We gaan zeggen dat I gelijk is aan 0.
Str sub 1 of sub moet ik zeggen is
niet gelijk aan de nul-terminator
en dan ook increment I.
We zijn bekend met
onze for-lus-syntaxis waar we de lus-ID als eerste hebben.
Vóór de eerste puntkomma, de voorwaarde waarin we voor de tweede
puntkomma eruit springen en vervolgens
de regelvariabele lus wijzigen om ervoor te zorgen dat we geen oneindige lus hebben.
Het enige wat we hier doen is dat we de
resultaten opslaan, sub I is gelijk aan str one sub I.
Onthoud dat dit karakters zijn, dus het is prima om hier de is gelijk aan een opdracht te gebruiken.
We kunnen dit niet
doen in tekenarrays omdat je aan tekenarrays geen array kunt toewijzen aan een array.
We zouden een str-kopie moeten gebruiken.
Dus dat is het kopiëren van de eerste string.
En nu willen we de tweede reeks samenvoegen tot resultaten,
dus we zouden iets heel erg gelijkaardigs doen, behalve dat we in de tweede
array gaan kijken en ervoor zorgen dat we het op de juiste plek in het resultaat plaatsen.
Dus we zouden zoiets doen. We zouden van j
naar nul gaan, str naar j is niet gelijk aan de nul-terminator ++j.
En je zult zien dat het resultaat gewoon I plus j zegt, dus waar ik ook mee eindigde.
Als ik tien tekens heb toegevoegd, begint het
nu bij dat tiende teken omdat het op nul is gebaseerd, en
het zal er gewoon j aan toevoegen, dus 10 plus 0, 10 plus 1 enzovoort.
En dat is het.
Een laatste ding dat je moet doen dat echt belangrijk is, is dat je die nulterminator moet toevoegen.
Dus we willen resultaat zeggen, I plus j en
dan een enkel teken toevoegen, de
null-terminator, die backslash nul is binnen een enkel aanhalingsteken.
En dat is onze functie.
We hoeven niets van deze functie terug
te geven, omdat we alleen str één naar str twee kopiëren.
Laten we dit dus testen.
Wat ik zou verwachten te kunnen doen op deze is het testen met een paar karakters.
We gebruiken de bestaande karakters die we hebben, en we gaan
er gewoon een paar samenvoegen.
Dus we moeten een ander
resultaat maken. Dus we zeggen
gewoon resultaat om het te wissen.
Hier gaan we zeggen dat
we een maat moeten specificeren voor die eerste.
En dus gaan we gewoon een maat van 50 specificeren. We gaan het beperken.
Dus deze constante karakters zouden moeten werken.
Nu gaan we gewoon printf zeggen, we
gaan een string uitprinten.
Dus we gaan procent s zeggen en dan gaan we concat
zeggen, zoals we het noemden. We geven de resultaten
door en dan woord één en woord twee.
Dus wat dit zou moeten weergeven als uitvoer,
en we zullen ervoor zorgen dat we het op een paar nieuwe regels zetten.
Dit zou als output moeten worden weergegeven. Jason oke. Dus concat retourneert eigenlijk geen gegevens, dus ik kan
het niet rechtstreeks in de printf plaatsen.
Wat ik moet doen is het noemen en vervolgens het resultaat weergeven.
Dus daar noemen we concat.
Alles wordt in het resultaat gezet en we tonen het resultaat.
Dus nogmaals, als we dit doen, zouden we Jason in
orde moeten zien en dat doen we ook.
De derde functie
die we willen implementeren is een vergelijkingsfunctie om te controleren of twee strings gelijk zijn.
Deze functie zou een boolean moeten retourneren.
Dus we willen onze standaard bool opnemen.
We kunnen dus booleaanse en true en false waarden gebruiken.
En dit wordt feitelijk gedefinieerd als gelijke strings.
Hiervoor is een constante tekenreeks nodig, s1 en nog een
om te controleren of twee
strings gelijk zijn.
Om er zeker van te zijn dat ik de juiste header heb opgenomen, ga ik
proberen die te bouwen en ik denk dat ik dat gedaan heb, want
nu kan ik het bool-sleutelwoord gebruiken omdat ik dit heb opgenomen en ik kan ook true false gebruiken.
Dus laten we deze gelijke strings implementeren.
Dit zal veel van hetzelfde zijn,
gewoon door de array gaan en elk teken controleren.
Dus we gaan een paar
lokale variabelen maken. I is gelijk aan 0 voor onze lus die is geïnitialiseerd op 0.
In een boolean vertelt dat ons
alleen of ze gelijk zijn, want dit is wat we gaan teruggeven, zoiets als is gelijk. En we zouden dit kunnen initialiseren op false.
Wat we eigenlijk eerst willen doen, is dat we de telling willen hebben.
We willen zien hoe groot deze
beide zijn. Dus we kunnen een while-lus hebben,
omdat we de telling nodig hebben om naar de grootte
te kijken, in feite om te
controleren op die null-beëindiging.
We gaan er dus van uit dat de strings die we doorgeven even groot zijn.
We kunnen dus een eenvoudige while-lus schrijven. Je zou ook if-statements kunnen schrijven.
Ik heb alles een beetje in
een while-lus opgenomen, mijn vergelijkingen met behulp van de logische operatoren.
U hoeft geen logische operatoren te gebruiken. Je zou een if-statement kunnen gebruiken en gewoon
de hele tweede string doornemen.
Maar wat ik hier deed, is dat ik zei dat
s1 sub I gelijk is aan gelijk aan s2
sub I en ze niet gelijk zijn aan nulterminators.
Omdat als ze gelijk zijn
aan nul-terminators, we eruit willen springen als een van beide een nul-terminator is.
Dus nu zeggen we plus plus I. En dan is het laatste wat we moeten
doen, gewoon controleren of dat nulterminators zijn. En als dat zo is, kunt u uw booleaanse variabele
instellen om de juiste gegevens te retourneren.
Dus hier kunnen we zeggen dat als s1 sub
I gelijk is aan een nul-terminator
en s2 sub gelijk is aan nul-terminator, onze boolean-variabele is
gelijk aan en dan willen we dat retourneren.
En dan gewoon zeggen dat rendement gelijk is.
En om dit te testen, moeten we een goede snaar en een slechte snaar testen.
Dus laten we doorgaan en zeggen gelijke snaren.
Ik ga alleen de gehele waarde van de boolean uitprinten,
dus procent d en we gaan hier zeggen gelijke strings, dit geeft iets terug
zodat we dit in
de print expression equals string kunnen zetten. Ik wil er gewoon voor zorgen
dat de snaren
gelijk zijn en dan passeren we in Jason komma Jason.
En we zullen het noemen en deze
keer zullen we Jason's zeggen.
En de eerste zou één moeten retourneren, de tweede om nul
te retourneren, één staat voor waar, nul staat voor onwaar.
Als we dit uitvoeren, zien we één
en nul. Eén voor waar en nul voor onwaar, behalve
dat het moeilijk te lezen is omdat we geen regelinvoer hebben. Dus laten we een line feed toevoegen en
gewoon om het je nog een keer te laten zien.
Nu zien we één nul,
waar onwaar. Jason Jason is gelijk aan elkaar.
Jason's Jason is niet gelijk.
Dit zijn dus enkele snelle
functies waar je nu van kunt leren, in wezen leren over de
tekenreeksen en hoe strings worden weergegeven met dit concept.
Dank u. Ik ga ook het bronbestand verstrekken, zodat je het in meer detail kunt bekijken.
Hopelijk heeft dit je geholpen bij je opdracht.