Hallo, en welkom terug. Weer een boeiende lezing. In deze lezing
gaan we het hebben over strings en
stringfuncties, voornamelijk de mogelijkheid om tokenize te zoeken en strings te analyseren.
Laten we dus nog wat stringfuncties bespreken. Een string zoeken.
Een string zoeken.
Al deze functies zullen in de stringheader staan.
Er zijn enkele tekenreekszoekfuncties die bijzonder nuttig zijn, waar u
een specifiek teken of een subtekenreeks kunt vinden.
De naam van die functies zijn strchr
en strstr.
Een enkel teken of subtekenreeks binnen een tekenreeks zoeken.
We zullen daar enkele voorbeelden van geven.
Er zijn ook enkele mogelijkheden voor het tokeniseren van een tekenreeks.
Je zou kunnen zeggen wat een tekenreeks tokeniseert. Eerst moet u definiëren wat een token is.
Een token is een reeks tekens binnen een tekenreeks die wordt begrensd door een scheidingsteken.
Een scheidingsteken is iets dat in de tekenreeks staat dat u opmerkt
en dat een speciale betekenis heeft.
Dus een token zou zijn als je een complete string had, dit
is Jason en het werd gescheiden door spaties.
Een teken zou dit kunnen zijn, een andere zou kunnen zijn, een andere zou Jason kunnen zijn.
Het is een manier om een hele reeks te nemen en deze in bepaalde
grenzen te splitsen op basis van een scheidingsteken.
En u wilt ervoor zorgen dat uw scheidingsteken niet iets
is dat geldig is in de eigenlijke tekenreeks. Dus je gebruikt ook scheidingstekens
als je uit bestanden leest, hetzelfde type concept.
Waar je een zin in woorden breekt, heet dat tokenizing. We gaan deze functie
genaamd strtok gebruiken.
Ik wil het ook hebben over enkele analysereeksen. Er zijn er
heel veel, veel verschillende om te controleren of
tekens kleine letters of hoofdletters of alfanumerieke
tekens of cijfers zijn.
Deze worden voornamelijk gedaan op karakters, maar karakters in zijstrings en je
kunt ze ook toepassen op hele strings.
Nu gaan we in op wat meer details over snaren.
En om sommige van deze functies te begrijpen, moeten we het even hebben over pointers.
Pointers zijn een enorm concept in c.
We gaan een hele sectie gewijd aan pointers hebben.
Waarschijnlijk de volgende of de volgende.
En er is veel discussie. Het is waarschijnlijk het meest verwarrende onderwerp van de taal.
Ik wil daar nu niet in detail op ingaan, omdat het niet relevant is.
Ik wil er alleen even op ingaan, ik geef je een klein voorproefje van wat een aanwijzer is,
zodat je enkele van deze functies kunt begrijpen die we gaan gebruiken.
Dat is het enige doel hiervan. Dus maak je geen zorgen als je
de aanwijzingen op dit punt na dit paar dia's niet volledig begrijpt.
Dus het concept van een aanwijzer, nogmaals, we gaan het later in detail bespreken.
Maar om enkele van deze tekenreeksfuncties te begrijpen, wil ik je een snelle blik geven.
C biedt een opmerkelijk nuttig type variabele, het wordt een pointer genoemd.
Ik heb het erover gehad. Het heeft te maken met geheugen en geheugentoewijzing.
Sommige talen, als je al eerder hebt geprogrammeerd en
niet helemaal nieuw bent in programmeren, sommige talen zullen automatisch het geheugen voor je beheren.
Ze zullen geheugen voor je toewijzen en het verwijderen, taal zoals java doet dit.
Het heet de vuilnisman. Een taal als c doet dit niet.
Dus wanneer u geheugen maakt voor het gebruik van
aanwijzers, moet u dat geheugen verwijderen.
Maar wat een aanwijzer is, het is erg handig
en wat het is, is een variabele die een adres opslaat.
Een adres, onthoud, is iets in het geheugen.
Het is meestal hexadecimaal.
De waarde in het adres bevindt zich op een andere locatie in het geheugen.
De aanwijzer wijst alleen naar een adres dat een waarde bevat.
En we hebben in het verleden adressen gebruikt met de scanf-functie.
Onthoud dat dat ampersand-symbool dat we hebben gebruikt, het adres is van de operator.
De Scanf-functie als tweede parameter zou
een variabele moeten opnemen waarin u de gegevens
wilt opslaan, die variabele moet een aanwijzer zijn.
En dus verwachtte de scanf-functie een aanwijzer.
Om zelf een geheel getal te maken, is het geen aanwijzer, maar
als je het adres ervan krijgt, wordt het nu een aanwijzer.
Dus we gebruiken de ampersand om het adres van een primitief gegevenstype te krijgen.
U bent dus een beetje bekend met het adresconcept.
Onthoud dat je vanaf nu met pointers
een int-nummer maakt en dat is geen
pointer en is gelijk aan 25.
Maar als je het ampersand ervan krijgt, wat het adres is, kun je het aan een aanwijzer toewijzen.
Een aanwijzer heeft een speciale syntaxis in c, de asterisk vertegenwoordigt een aanwijzer.
Dus hebben we een variabel getal gedeclareerd met de waarde 25 en vervolgens
hebben we een aanwijzer gedeclareerd met de asterisk genaamd pNumber, die
het adres van het nummer bevat.
En nogmaals, de asterisk wordt gebruikt om de aanwijzer te declareren, zo weet
je dat het een aanwijzergegevenstype is.
Om de waarde van de variabele p-getal te krijgen
omdat p-getal wat is? Het is een aanwijzer die naar een adres in het geheugen wijst.
Als je gewoon naar de waarde van het p-nummer probeert te kijken, zal het je het adres geven.
Als u de waarde wilt weten van waarnaar het adres verwijst, moet u het de-refereren.
Er is dus een
speciale syntaxis die c gebruikt, het heet de asterisk en de naam van de variabele,
zo kun je daadwerkelijk toegang krijgen tot de geheugenlocatie die de waarde bevat.
Dus als je gegevens aan die geheugenlocatie wilt toewijzen, moet je ster p-nummer zeggen.
Nogmaals, het effect is dat het toegang heeft tot de gegevens die zijn opgeslagen op het adres dat door de aanwijzer is opgegeven.
Het wordt dus erg verwarrend als we het over pointers hebben, omdat je dit concept niet gewend bent.
Je denkt dat een variabele een waarde heeft, that's it. Maar een variabele kan een adres hebben en
het adres kan dan een waarde hebben.
Deze dia probeert te illustreren wat ik zojuist heb genoemd.
Ik vond dit in een boek dat ik heb gelezen.
Het is een dia die je het concept van een aanwijzer in het geheugen laat
zien en hoe dingen werken met adressen.
Dus ik herhaal wat ik net zei.
Maar de waarde van het ampersand-nummer is het adres waar het nummer zich bevindt.
Dus als je twee variabelen hebt, getal en
p getal, p getal is een aanwijzer, getal is een
int, dan moet je trouwens ook het type aanwijzer specificeren.
Hoewel de aanwijzer een adres is,
geeft u nog steeds het type op of waar het adres naar verwijst.
Dus het int star p-nummer zal gelijk zijn aan het adres van het nummer.
Nummer staat in het geheugen en verwijst naar
een adres van bijvoorbeeld duizend en heeft een waarde van 25.
P-nummer heeft een adres van 105 voor
dat werkelijke p-nummer, maar de
waarde van dat adres is 1000 adres.
Om de waarde van p-getal te krijgen, zou je de 1000 moeten dereferenteren, wat
je 25 geeft.
De reden dat ik dit alles over
pointers noem, is omdat veel tekenreeksfuncties pointers gaan retourneren.
Het zal niet zo heel veel uitmaken.
Het is alleen belangrijk als u wilt begrijpen hoe u een bepaald teken in een array krijgt.
Maar ik wilde ze toch even kort noemen.
Het is prima als het concept nu niet tot je doordringt, want we gaan
het in een later gedeelte uitgebreid bespreken.
Maar begrijp dat de stringfuncties die we nu gaan gebruiken pointers zullen retourneren en
dat je die return misschien gaat gebruiken om iets nuttigs te doen.
In het verleden, toen we de str-kopieën gebruikten en de str vergelijkt, gaven
we pointers door, maar het gaf nooit pointers terug, we hoefden die pointer nooit te gebruiken.
Nu we de aanwijzer moeten gebruiken, wil ik een kleine beschrijving geven van wat dat betekent.
Pointer gaat gewoon naar een adres wijzen.
En dan kun je dat adres gebruiken om te parseren of wat je ook moet doen.
Dus hopelijk heeft dit je niet overweldigd. Nogmaals, maak je geen zorgen als je het niet helemaal begrijpt.
We zullen nu enkele voorbeelden
doornemen van het analyseren, tokeniseren en zoeken naar strings.
Om naar een string te zoeken, zeiden we, ga je de strchr of de strstr gebruiken.
De strchr zoekt in een gegeven tekenreeks naar een enkel teken.
Het eerste argument voor de functie is de tekenreeks die moet worden
doorzocht, wat het adres van een tekenreeks zal zijn.
Het tweede argument is het karakter dat u zoekt.
We zullen zo meteen een voorbeeld geven. Dus de functie gaat de
tekenreeks zoeken vanaf het begin en een
aanwijzer terugsturen naar de eerste positie in de tekenreeks waar het teken wordt gevonden.
Dit is de reden waarom de aanwijzer nu belangrijk is,
omdat we geen volledige waarde retourneren, we retourneren een aanwijzer naar
een teken in een
tekenreeks en dat adres vertegenwoordigt in wezen de index van een array.
Dus het adres van deze positie in het geheugen, het is een ster van het type karakter
en het wordt beschreven als een
aanwijzer naar een char, wat eigenlijk maar een enkel teken in het geheugen is.
Om de geretourneerde waarde op te slaan, moet u een variabele maken die het adres van een teken kan
opslaan, dus u moet een aanwijzer maken.
Als het teken nu wordt gevonden, retourneert de functie een speciale waarde, namelijk null.
Null betekent dat de aanwijzer nergens naar wijst.
We gebruiken null als we het over pointers hebben, en null
zegt alleen maar dat het niets heeft gevonden. Het wijst dus nergens op.
Als het naar iets wijst, wijst het naar het adres waar je dat teken hebt gevonden
en dan kun je vanaf daar beginnen met ontleden.
Want onthoud uit de eerdere lezingen
dat wanneer u een tekenreeks in het geheugen
maakt, u elk teken gewoon als een byte laat zien.
En als je een string aan
het ontleden bent en je wilt zien waar een bepaald teken in die string begint,
geef je die byte terug en dan kun je vanaf daar gaan zoeken.
Dus str char, hoe je het gebruikt is dit.
Je zegt dat je een tekenreeks maakt en we initialiseren
deze hier met een snelle bruine vos.
We maken dan een enkel karakter en we initialiseren dat met q.
Dan maken we een aanwijzer omdat we een aanwijzer moeten maken, want dat is wat wordt geretourneerd uit de str char, dat is wat
ons in staat stelt om te zien waar in die tekenreeks we een teken hebben gevonden.
We gaan onze aanwijzer naar null initialiseren. Want op dit moment gaat het nergens op wijzen.
Dan gaan we str char noemen, we gaan onze string doorgeven die de snelle bruine vos is, en
we gaan ons enkele karakter doorgeven dat q is.
Wat er gaat gebeuren is dat hij in de snelle bruine vos gaat kijken.
En de eerste keer dat het een q vindt, zal het het adres van die q retourneren.
Dus p got char
gaat echt naar de vierde index van str wijzen.
Omdat t onder nul is, is h onder één, e onder
twee, ruimte onder drie, q onder vier.
Dus p got char wijst naar q in de snelle bruine vos.
En zo kun je precies zien waar dat teken in die string begint.
Dus het eerste argument voor str char is het adres van de eerste locatie die moet worden
doorzocht, dat is de zoekreeks.
Het tweede argument is het karakter dat wordt gezocht, het karakter waarnaar u wilt zoeken,
een enkel karakter.
Het verwacht dat het tweede argument van het type int is.
Dus technisch gezien str char, het tweede argument neemt in.
Maar de c-compiler converteert de grafiek automatisch naar een int.
Het krijgt in wezen de ASCII-waarde.
Dus je zou eigenlijk het q enkele teken kunnen definiëren
in plaats van een enkele char, je zou het kunnen definiëren als een int.
Dat is meer een technisch detail waarvan ik wilde dat je het wist.
Maar p got char wijst naar de waarde quick brown fox omdat
het begint bij q en dan gaat het naar de nulterminator als je het probeert af te drukken.
Dus het wordt eigenlijk een snelle bruine vos als je dit voorbeeld uitvoert.
Op deze manier kunt u zoeken naar een enkel teken in een hele tekenreeks.
Gebruik str char, gebruik vervolgens de aanwijzer en geef vervolgens de aanwijzer weer.
En hoe geef je die aanwijzer weer? Op dezelfde manier waarop u andere tekens weergeeft, gebruikt u printf, procent s.
Dit is dus een mooi mechanisme om te zoeken naar karakters in een hele string.
Als je wilt zoeken naar een string in een string, wat een substring zou
zijn, gebruik je strstr.
Dit is waarschijnlijk de handigste van alle zoekfuncties.
Het zoekt in één string naar het voorkomen van een substring.
En het retourneert een aanwijzer naar de positie in de eerste tekenreeks waar de subtekenreeks wordt
gevonden, zeer vergelijkbaar met str char, maar het doorzoekt een hele tekenreeks. Als het geen overeenkomst heeft gevonden, retourneert het null.
Het eerste argument is de string die moet worden doorzocht, net als str char.
Ten tweede is de substring die je zoekt, een andere string. Dus hier is een voorbeeld.
Het lijkt erg op het andere, behalve dat we in plaats van te zoeken naar
een enkel teken, we op zoek zijn naar een woord, een tekenreeks.
Dus we hebben woord, wat gelijk is aan hond.
En we hebben tekst waarin staat dat elke hond zijn dag heeft.
We maken onze aanwijzer opnieuw omdat het moet - dit is wat de functie retourneert.
Als we strstr aanroepen, geven we in de tekst de string door waar we naar willen kijken.
En dan is het tweede argument het woord dat we in die string willen kijken.
Dus het gaat naar de tekst zoeken als de eerste keer dat de tekenreeks in woord voorkomt.
De tekenreekshond verschijnt bij het zevende teken in de tekst.
Als je naar tekst kijkt.
Tekst sub 6 wordt gelijk aan hond, daar begint het mee.
Dus de aanwijzer wijst naar het adres van tekst plus 6 hond, en
het begint daar, en dan gaat het naar de nulterminator.
Dus p gevonden wordt hond heeft zijn dag.
En wees ook voorzichtig, want de zoekopdracht is hoofdlettergevoelig.
Als je daadwerkelijk een hoofdletter D-O-G hebt opgegeven, zul je niets vinden, het
gaat alleen op zoek naar het juiste geval.
Maar dit wordt gebruikt om substrings en strings te vinden, erg handig
omdat je in een programma vaak zegt dat deze string in deze string zit,
omdat het bijna hetzelfde is als een grep als je ooit grep op Linux hebt gebruikt.
Ik hoop dat dit zinvol is. Tokeniseren van een string.
Een token is een opeenvolging van karakters waarvan een string die wordt begrensd door een scheidingsteken, dat weten we.
Een scheidingsteken kan van alles zijn, maar het moet iets unieks zijn voor die tekenreeks.
Gebruik geen scheidingsteken als "A", want nu gaat het in die string iets vinden
dat geldig is in een woord.
Maak er iets unieks van, zoals een spatie of een komma. Dit wordt wederom gebruikt als grens voor
woorden in een enkele string.
Dus het breekt een zin op in woorden, het wordt tokeniseren genoemd.
Deze strtok-functie wordt gebruikt voor het tokeniseren van een string.
Het vereist twee argumenten.
De tekenreeks die moet worden getokeniseerd. Dit is de hele tekenreeks met spaties en scheidingstekens.
En dan de string die alle positief gelimiteerde karakters bevat.
U kunt aangeven wat u als grens wilt instellen.
Dus hier is een voorbeeld.
We maken een karakterarray 80.
Het zegt hallo, hoe gaat het, je bent dash mijn naam is dash Jason.
Vervolgens maken we een constante tekenreeks die het scheidingsteken vertegenwoordigt,
de min, het streepje. Het ziet er een beetje anders uit, maar het is nog steeds het minteken,
het streepje, het zijn beide streepjes.
En dan maken we onze aanwijzer die token is.
Omdat strtok ons elk
token teruggeeft.
Dus als we onze strtok noemen en we geven string door
en we geven onze scheidingstekens s door,
dan zal token gelijk zijn aan het eerste dat het vindt.
Dus de eerste keer dat je strtok roept, zal het gelijk zijn aan hallo hoe gaat
het met je ruimte en dan vindt het de match met het streepje.
En als je voor
de tweede keer belt, wordt mijn naam afgedrukt.
Als je het een derde keer
noemt, wordt Jason afgedrukt omdat het door de streepjes gaat.
Daarom hebben we hier een while-lus. We zeggen dat terwijl het token niet gelijk is aan null,
het token moet worden afgedrukt.
En dan krijgen we het volgende token door strtok aan te roepen.
En we zeggen null als onze eerste parameter en
s is onze tweede parameter en
dan geven we weer. Dus laten we dit
in codeblokken bekijken, omdat het het begrijpelijker zal maken.
Dus laten we dit bouwen. We hebben dit voorbeeld net doorgenomen.
Ik wil je laten zien wat de output is, zodat het duidelijk is wat hier aan de hand is.
Dus hier zul je zien dat er staat dat
het de eerste token afdrukt, hallo hoe gaat het.
Het eerste wat het doet is
het eerste token vinden, het uitprinten, hallo hoe gaat het, mijn naam is en dan Jason.
Dus nu hebben we hallo, hoe gaat het,
vindt het eerste streepje, print het uit. Mijn naam is de volgende token
en de derde is Jason. Maar je moet het token drie
keer bellen om elk token te krijgen.
De eerste gaat tokeniseren op de str.
Zie de volgende die je in null kunt doorgeven omdat je niet opnieuw wilt kijken, je wilt gewoon de volgende token krijgen.
En dus passeer je een nul de tweede en je passeert gewoon een s.
Het geeft je het volgende token van de str al tok.
Dus zo kun je strtok gebruiken. Het helpt enorm bij het parseren.
Je kunt iets ontleden en bepaalde grenzen eruit halen.
De laatste functies waar ik het over wil hebben, zijn deze analyserende tekenreeksfuncties.
Er zijn er een heleboel, dus ik heb hier een tafeltje voorzien.
Is lager, is hoger. Het doet precies wat je denkt dat het zou doen.
Het test om te zien of een teken kleine letters of hoofdletters is.
We testen bepaalde karakters, maar ze worden binnen strings gebruikt.
En dus is het argument voor elk van deze functies het teken waarnaar u wilt zoeken.
En dan retourneren al deze functies een niet-nulwaarde van het
type int als het teken binnen de set valt die wordt getest.
Dus we gaan int-tekens doorgeven aan de binnenkant op zoek naar inside-woorden.
Als we een hoofdletter in een woord hebben, zal het ons dat vertellen en kunnen
we het ook gebruiken voor het ontleden van individuele elementen op een karaktermanier.
Dus de geretourneerde waarden worden geconverteerd naar waar of onwaar, zodat
je ze ook als Booleans kunt gebruiken, wat leuk is.
Dus is lager zal waar opleveren
als een woord of teken een kleine letter heeft.
Nou, hier is een mooi voorbeeld dat
ik wilde doornemen, dat het aantal letters cijfers in een hele reeks zal tellen.
Dus laten we dit uitvoeren, want dit zal
duidelijk zijn, maar wat je zou moeten opmerken, is dat we
een buffer maken, onze invoerbuffer, en dan creëren we drie gehele getallen om te tellen.
We vertellen de gebruiker dat hij een reeks van
minder dan zoveel tekens moet invoeren, waarna we deze inlezen.
We gaan dan naar die string kijken om te
zien of deze bepaalde karakters bevat.
En dus gaan we die string doorlopen door naar
elke index in de array te kijken.
Dus hier is ons voorbeeld.
Nogmaals, buffer is onze tekenreeks die
invoer gaat opslaan. We gaan scanf gebruiken om dat in te vullen.
We moeten onze string typen zonder spaties, het is een enkele string.
We gaan het doornemen, door elk element in de buffer gaan en dan de
functies is alpha, is digit of is punct aanroepen om te zien of
die karakters daar staan, en dan zal
het op basis daarvan toenemen, of dat nu wel of niet is. geeft waar of onwaar
terug en dan wordt weergegeven hoeveel letters, cijfers en leestekens er in die tekenreeks zitten.
Laten we dit uitvoeren.
Ik ga gewoon iets invoeren met een heleboel
hoofdletters, misschien wat cijfers.
Als ik dan op Return druk, wordt alles geteld. Dus er
staat dat mijn stuur 24 letters, 4 cijfers en
1 leesteken, de dubbele punt, bevatte.
Leuk klein leuk programma dat deze karakterfuncties gebruikt, maar
handig is bij het analyseren van een string, want dat is
wat je doet, je analyseert de string, maar je
gaat gewoon karakter voor karakter door. Dank u.