Hallo, en welkom terug. In deze
lezing wil ik het hebben over het maken van een string, in
het bijzonder hoe je dit in c kunt doen met behulp van een tekenreeks.
Ik heb de neiging om de termen string en tekenreeksen door elkaar te gebruiken.
Maar echt een tekenreeks is de char-array waar we het over gaan hebben.
Het is een heel belangrijk concept.
We kunnen nu woorden en tekst in ons programma gebruiken om allerlei dingen te doen.
Nu heeft c zelf geen gegevenstype dat een tekenreeks vertegenwoordigt.
Er is niets daar. Veel talen ondersteunen een
object of een gegevenstype van het type string.
Omdat er geen gegevenstype c in string is, kunt u geen
van de operators in de string gebruiken.
Dus wat we uiteindelijk zullen doen, is dat we uiteindelijk de standaardbibliotheek gaan gebruiken en er zijn allerlei
soorten tekenreeksfuncties waar we het over gaan hebben.
We hebben drie lezingen gewijd aan de verschillende snaarfuncties die u kunt gebruiken.
En dit zal ons helpen de snaren te manipuleren, informatie te krijgen over de snaren.
Maar je kunt geen operatoren op strings gebruiken, geen
plus- of mintekenreeksen, zoiets niet.
Strings in c worden opgeslagen in een array van het type char.
We weten wat een array is. We weten wat een type char is.
Een type char is een enkel teken, een array waar je gewoon
meerdere elementen in dezelfde naam kunt opslaan.
Het is dus logisch dat een tekenreeks zich in een tekenreeks
bevindt, omdat een tekenreeks veel tekens bevat.
Dus karakters van een string worden opgeslagen in aangrenzende geheugencellen, één karakter per cel.
Je hebt er toegang toe, net zoals je ook toegang hebt tot een array.
Maar hoe je eigenlijk een string zou declareren en zien, is dat je gewoon het char-type en vervolgens de
haakjes zou gebruiken om de grootte aan te geven, net als een normale array als
je het van een ander type zou maken.
Char en dan wat je naam ook is en dan de grootte
van de tekenreeks tussen vierkante haken.
Zo kun je een string declareren in c.
Als je nu de tekenreeks in c op deze manier declareert,
zijn er geen daadwerkelijke gegevens aan gekoppeld. Je geeft alleen de maat op.
Dat is de eenvoudigste manier.
De variabele is dus geschikt voor een tekenreeks die maximaal 19 tekens bevat.
Onthoud dit nulteken.
Als je zegt dat je stringgrootte 20 wordt, betekent dat dat er maar 19
tekens kunnen worden opgeslagen omdat je
dat ene extra teken voor de null moet hebben.
Houd dat in gedachten, het declareren van een tekenreeks is 20 betekent
dat er 19 tekens kunnen worden opgeslagen.
Als u de afmeting opgeeft van een array die u vóór een tekenreeks wilt gebruiken - om een
tekenreeks op te slaan, moet
deze ten minste één groter zijn dan het aantal tekens in de tekenreeks dat u wilt opslaan.
De compiler voegt automatisch de null-terminator toe aan het einde van elke stringconstante.
Dus wat u echt moet doen, is wanneer u
deze tekenreeksen maakt, u ze moet initialiseren.
U kunt dus een stringvariabele initialiseren, net zoals u een array kunt initialiseren.
Je plaatst elk personage tussen deze haakjes.
Dus dit lijkt erg op het initialiseren van elementen in een integer-array.
Maar als je het woord char zegt en
dan binnen de kronkelige haakjes zet je elk afzonderlijk teken
dat een tekenreeks zou creëren.
Het is dus hetzelfde als elke andere array-initialisatie.
Als de grootte niet wordt ingevoerd, berekent
de c-compiler automatisch het aantal elementen in de array en voegt er vervolgens één toe voor de nul-terminator.
Het is dus gebaseerd op het aantal initializers dat je tussen de haakjes
hebt staan, accolades.
Deze verklaring gaat ruimte en geheugen reserveren voor precies zeven
karakters, h-e-l-l-o uitroepteken en dan
de nul-terminator, en dit kleine diagram aan de rechterkant laat je dat zien.
Automatisch en die nulterminator toevoegen. Nu zou het
echt vervelend zijn als je je karakterarrays
altijd moest initialiseren met enkele aanhalingstekens gevolgd door komma's.
Dus wat je kunt doen is zelfs steno-notatie, je kunt er gewoon dubbele aanhalingstekens omheen zetten.
Dus je kunt de string expliciet specificeren, zoals in dat eerste voorbeeld, en
dan zou je eigenlijk een stringfunctie moeten gebruiken om er
gegevens op toe te passen,
of je kunt de compiler het voor je laten doen.
Het probleem met het expliciet doen is dat je altijd moet onthouden om dat extra teken voor de
null toe te voegen.
Dus wat je echt moet doen, is dat je de compiler het voor je moet laten uitzoeken.
Zet dus geen cijfers tussen die haakjes voor de maat.
Omdat als de opgegeven grootte te klein is, de compiler niet in het
afsluitende null-teken aan het einde van de array past en er geen plaatst en u
ook niet vertelt dat hij er geen heeft geplaatst.
Dus je krijgt een bug in je programma waarvan je het niet eens merkt.
De beste praktijk is wanneer u een letterlijke tekenreeks gebruikt
en u een tekenreeks initialiseert om de compiler de grootte voor u te laten bepalen.
Maak het een grotere maat of zoiets en stop het er gewoon in en het zal de maat voor je bepalen.
Geef dus niet de maat op. Laat de compiler het uitzoeken.
Zo weet je zeker dat het klopt.
Laat die haakjes gewoon als lege haakjes en
wijs het toe met de toewijzingsoperator en dan kun je het
gewoon tussen dubbele aanhalingstekens plaatsen. Je hebt de vierkante haken niet eens nodig.
Dit is de beste praktijk. We zullen een voorbeeld doornemen.
U kunt ook slechts een deel van een
reeks elementen van het type char initialiseren met een tekenreeks.
Dus als je echt een groot formaat hebt gemaakt en je
hebt maar een paar tekens toegewezen, dan is dat
ook goed, je initialiseert slechts enkele tekens. Alle andere karakters zullen gewoon
leeg zijn.
Dus wat hier zal gebeuren, is dat de compiler de eerste vijf elementen initialiseert.
Str nul tot str vier, al die
karakters van stringconstante en dan string sub 5 zullen
het null-teken bevatten.
Er zal nog steeds ruimte worden toegewezen voor alle
40 elementen in de array, maar slechts vijf daarvan zullen worden gebruikt, vier plus het nulteken.
Dus nogmaals, je best practice specificeert niet echt een getal binnen de grootte, maar
wijs het gewoon een letterlijke tekenreeks toe met dubbele aanhalingstekens.
Dat is wat je uiteindelijk gaat zien.
Als je nu niet hebt geïnitialiseerd en je hebt zojuist de
tekenreeks met een grootte gemaakt, hoe zet je dan de datum erin.
Omdat het een array is, kun je niet zomaar gegevens toewijzen.
We weten dat als we een integer-array hadden, we een
integer-array niet zomaar het getal vijf kunnen toewijzen,
het heeft geen zin. U moet de feitelijke elementen specificeren.
U moet de indexen specificeren.
Je kunt dus niet zoiets doen als een tekenreeks met 100 tekens declareren en dan zeggen dat
s gelijk is aan hallo. Dat gaat niet werken.
Omdat, nogmaals, s een array is. Ook al is het een string tussen dubbele aanhalingstekens, het is nog steeds een array in het geheugen.
Dus als u een toewijzingsbewerking uitvoert, kunt u de ene reeks
tekens niet toewijzen aan een andere reeks tekens zoals hierboven.
Als u gegevens aan een tekenreeks wilt
toewijzen nadat u deze hebt gedeclareerd en nadat u deze hebt geïnitialiseerd,
moet u een speciale functie gebruiken, genaamd str copy.
En daar gaan we het in een andere lezing over hebben.
Dus tot nu toe, wanneer je je strings aanmaakt, zullen het letterlijke tekenreeksen zijn,
ze zullen tussen dubbele aanhalingstekens staan en je zult ze nooit wijzigen.
Dit is dus ook volkomen terecht. Je zou eigenlijk gewoon toegang kunnen krijgen
tot dit karakter of elk element in de array door de index en elk teken specificeren.
Dus s sub 0, s sub 1 en plaats dan een enkel teken tussen enkele aanhalingstekens.
Je zou het zo kunnen toewijzen. Maar stel je voor dat je een string had van 100 bytes.
Dit gaat veel regels code kosten. Dat wil je dus niet doen.
Wat u wilt doen, is het initialiseren wanneer u
het zonder grootte declareert en vervolgens specificeert of
u het ooit wilt wijzigen, u kopieert.
Wat betreft het weergeven van een string als uitvoer, we gaan nog steeds die printf-functie gebruiken.
Als je ergens in je programma naar een string wilt verwijzen, gebruik
je alleen de arraynaam.
U hoeft geen indexen op te geven.
Omdat indices in de array een enkel teken gaan specificeren.
Als je de hele string wilt, gebruik je gewoon de arraynaam.
Dus als u de printf-functie gebruikt om de uitvoer weer te
geven, doet u het volgende. Binnen de dubbele aanhalingstekens
zou je een procent s gebruiken als formaatspecificatie en dan alleen de naam van de tekenreeks.
U behandelt het dus niet als andere arrays wanneer u er toegang toe wilt hebben. Als u er toegang toe wilt hebben, alleen de
naam, geen echte indexen of haakjes.
En het percentage als formaatspecificatie is voor het uitvoeren
van een null-beëindigde string. Onthoud dat voordat we procent d gebruikten
voor gehele getallen, je procent c kunt gebruiken voor tekens.
Voor strings gebruik je procent s, en dat zijn tekenreeksen.
Het verwacht een null-beëindigde string.
Dus je initialiseert de string echter als je het zonder grootte hebt gedaan en null-terminator wordt
automatisch toegevoegd of als je het met
een specifieke grootte hebt gemaakt en je hebt het toegevoegd of als je het
expliciet hebt toegevoegd, het maakt niet uit. Het moet gewoon null worden beëindigd.
De printf-functie gaat ervan uit dat men de indelingsspecificatie procent s tegenkomt
dat het corresponderende argument een tekenreeks is die wordt afgesloten met een null-teken.
Dat is wat het verwacht, dus het moet zo zijn.
Om een string in te voeren, weten we hoe
we andere sets gegevens via het toetsenbord moeten invoeren met scanf.
We gaan hetzelfde doen voor het invoeren van strings.
We gaan een scanf-functie gebruiken. Met de scanf-functie gaat
het op dezelfde manier, behalve dat je een andere formaatspecificatie gaat gebruiken.
Dus voor strings ga je een procent s gebruiken als invoer.
En dat wordt gebruikt voor het invoeren van een string.
Het andere dat hier moet worden opgemerkt, is dat er geen ampersand is voor de naam van
de variabele, omdat het een teken is. Onthoud dat we hebben gezegd dat u alleen
de ampersand het adres van de operator op strings hoeft op te geven.
De reden hiervoor is dat wanneer we het over pointers hebben, het duidelijker zal zijn.
Maar char-invoer, ook al is het een tekenarray,
het is een aanwijzer en scanf als het tweede argument een aanwijzer nodig heeft.
En daarom hoef je het niet te doen. Wanneer u gehele getallen en verdubbelingen declareert, zijn dat
geen pointers en. Dus als
u invoer van het toetsenbord wilt lezen met scanf, verwacht het tweede argument een aanwijzer die
u in een adres moet doorgeven.
Nu, met de scanf wanneer je een
string doet, zal scanf alleen lezen tot de spatie.
Dus als je scanf en je typt in, is
Jason een instructeur.
Het enige dat in invoer wordt opgeslagen, is Jason. Want als het eenmaal die spatie
raakt, zal het de rest van de string niet lezen.
Er zijn dus andere functies die u kunt gebruiken om de hele string te lezen.
Sommige van de voorbeelden die we gaan gebruiken, zullen dat waarschijnlijk doen. Je kunt dingen doen als f get s,
wat een andere manier is om invoer van het toetsenbord te lezen en die de hele
string zal lezen, ongeacht spaties.
Maar er is er nog een waarvan ik denk
dat het underscore s voor C11 wordt
genoemd, maar daar zullen we het meer over hebben, maar dat is slechts één
ding om te onthouden als je invoer voor strings leest. Het leest alleen helemaal tot aan de spatie.
Hoe zit het met het testen of twee strings gelijk zijn.
Welnu, tot nu toe hebben we alle variabelen getest
om te zien of ze gelijk zijn, we gebruiken gewoon is gelijk aan is.
Maar met snaren gaat dit niet werken.
De gelijkheidsoperator, onthoud, we zeiden dat strings karakterarrays zijn, dus je kunt er geen operators op gebruiken.
En de gelijkheidsoperator kan alleen worden toegepast op ints en doubles
of floats of karakters.
Het werkt niet op structuren of arrays. Je kunt twee arrays niet vergelijken.
Dus met snaren gaat het niet werken. Als u wilt bepalen of twee
tekenreeksen gelijk zijn, moet u de twee tekenreeksen expliciet per teken vergelijken.
U moet dus elk element in de array
index voor index bekijken.
Maar dat is echt een groot probleem, want dat zou erg vervelend zijn.
Dus we gaan het hebben over hoe je het heel
gemakkelijk kunt doen met een str-vergelijkingsfunctie uit de standaardbibliotheek, maar je
kunt de equals equals niet gebruiken, onthoud dat.
En nogmaals, ter herinnering, ik heb het een paar keer gezegd, ik wil het
nog een keer zeggen, de tekenreeksconstante x tussen
dubbele aanhalingstekens is niet hetzelfde als de tekenconstante x tussen enkele aanhalingstekens.
X tussen enkele aanhalingstekens is een basistype, het is gewoon char
of care.
X tussen dubbele aanhalingstekens is een schijftype, het is een array van het type char.
X tussen dubbele aanhalingstekens bestaat in feite uit twee tekens, de
x en de null-terminator, het null-teken, dus houd daar rekening mee.
Hier is een voorbeeld
van hoe we strings kunnen maken door ze
met een grootte te declareren of ze op dezelfde regel te initialiseren.
Dit is nu de beste praktijk. Als je letterlijke tekenreeksen gaat
gebruiken, zou ik
doen wat hier staat, de tekenreeks maken, geen grootte
specificeren en dan rechts van de toewijzingsoperator dubbele aanhalingstekens gebruiken.
De compiler maakt automatisch de juiste string en voegt er een null-terminator aan toe.
Als u een grootte opgeeft en u heeft niet genoeg tekens, wordt deze niet opgeslagen.
Maak dus gewoon letterlijke tekenreeksen door het gegevenstype
char, de naam van de
variabele en vervolgens lege haakjes te gebruiken.
Dit programma gaat denk ik de karakters in een array
tellen, dus het gaat in wezen om de lengte van de string.
Wat we hier doen, is dat we een variabele maken met de naam count in arrays van twee
tekens met twee verschillende strings, te zijn of niet te zijn
en dan komma's, dat is de vraag.
Char str one krijgt een dynamo na b, en
str krijgt een alternatief na vraag.
Dus we hebben hier een lus die door de
eerste array gaat, van het aantal is gelijk aan nul tot we een nul-terminator zien.
En we kunnen in dit geval de niet gelijken gebruiken omdat we een karakter vergelijken.
Null-terminator als personage. Het is prima om karakters te vergelijken.
Dus onze while-lus gaat helemaal door totdat we een nul-terminator zien.
Zodra we een nulterminator zien, springen we eruit.
Het aantal is gelijk aan het aantal tekens in die string.
Dus het is de lengte van die string.
We doen het voor beide snaren. En je zult merken dat in
principe beide snaren de juiste lengte hebben, omdat we ze gewoon doornemen.
Naar b of niet naar b wordt zoiets als
18 tekens.
Nu hoef je zoiets nooit meer te doen, want
we hebben een leuke helperfunctie met str-lengte om lengtes van strings te vinden.
Maar nogmaals, wat dit aantoont, is het feit dat het een array is.
En als je de lengte van een string wilt vergelijken of vinden, kun je
de niet gelijken gebruiken en naar het teken kijken, de nul-terminator.
Ik hoop dat dit nuttig was. Dit is hoe we letterlijke tekenreeksen gaan definiëren en initialiseren.
Dank u.