Hallo en welkom. In deze lezing ga ik een
demonstratie geven van een oplossing voor onze vorige uitdaging.
Ik ga door hoe we de
karakters in een string kunnen omkeren met behulp van
de str length-functie en ook door het sorteren van strings met
behulp van str Compare en ook str Copy en
het gebruik van het bubble-algoritme.
Laten we codeblokken naar voren brengen.
En ik ga hier gewoon een enkel programma voor maken. Ik noemde in de
uitdaging dat je twee programma's maakt.
Maar voor de eenvoud en qua demonstratie ga ik er maar één maken.
Maak een
project, ik noem het
gewoon string-functies of een variatie daarop.
Laten we het een algemeen voorbeeld van
tekenreeksfuncties noemen.
Dus laten we beginnen met het omgekeerde. Het omgekeerde kan zijn eigen functie hebben of we
kunnen het gewoon in het hoofd plaatsen. Ik zou het in het hoofd plaatsen.
Dus het eerste wat ik wil doen, is een -- nou, het eerste
wat ik wil doen, is het juiste header-bestand opnemen, zodat ik deze tekenreeksfuncties
kan gebruiken, wat mijn include-reeks is. H.
Dit is waar het alle leuke tekenreeksfuncties bevat.
Nu ga ik een tekenreeks maken. Ik ga er maat 100 van maken.
Het is gewoon willekeurig,
je kunt alleen geen dingen groter dan 100 opslaan.
Ik ga een paar lokale variabelen maken die me
zullen helpen bij het ontleden. En wat ik wil doen, is dat ik
eerst wat output aan de gebruiker wil laten zien.
Dus ik ga gewoon een paar
regelfeeds zeggen, individuele,
individuele karakters van string en omgekeerde volgorde afdrukken.
Dat zal de gebruiker vertellen wat er aan de hand is en dan
ook afdrukken om het duidelijker te maken,
gewoon iets dergelijks uitprinten, zodat het gemakkelijker te lezen is.
Ik ga zeggen voer de string in. Ik ga in de string lezen.
En dan ga ik de string opslaan.
Dus ik ga
scanf, present s zeggen en ik ga str zeggen.
En ik hoef de ampersand niet door te geven om het in te lezen.
Dan ga ik de snaarlengte krijgen. Ik ga dat in mijn l lokale variabele zetten.
Dus ik kan str-link aanroepen door gewoon str-lengte in de string te zeggen, en
het geeft het aantal tekens in die string terug. Heel, heel gemakkelijk.
En dan ga ik iets uitprinten om ze te vertellen dat de karakters in omgekeerde volgorde staan.
Dus de karakters van de string
in omgekeerde r backslash n.
Dan ga ik een leuke for-lus schrijven die door
mijn array gaat en volgens de lengte en deze gewoon omkeert.
Dus ik ga zeggen dat ik gelijk is aan l.
Dus ik ga achteruit in de
eigenlijke stringarray. Ik begin bij het einde en ga vooruit.
En zeg dat I groter is dan of gelijk
is aan 0 en I min minus. En je merkt dat ik niet naar nullettertekens
hoef te kijken als ik het op deze manier doe.
Dan ga ik gewoon elk personage uitprinten als ik het tegenkom.
Om een karakter uit te printen en te zien doe je gewoon het percentage c.
En doe dat gewoon en zeg str sub-I.
En dat is het in principe.
En dan print ik gewoon een nieuwe regel uit.
En eigenlijk zal ik een heleboel dingen uitprinten om het te beëindigen,
een heleboel streepjes.
Eens kijken of dat werkt, heel gemakkelijk deze eigenlijk zoals het zou moeten
zijn, om de lengte te krijgen zou niet moeilijk moeten zijn.
En ik ben een regelinvoer vergeten, dus laten we dat oplossen.
Dus hier staat print individuele karakters van string omgekeerd of voer de string in.
Nu scanf, het gaat alleen inlezen. Dus als ik Jason Space Feden binnenga.
Scanf gaat alleen Jason en de ruimte voorlezen.
Je zou een andere functie zoals f get s willen gebruiken als je het hele ding wilde lezen.
Dus wat dit gaat doen, het gaat Jason gewoon nosaj
afdrukken, wat het doet. De karakters van string reverse zijn nosaj.
Dat is vrij eenvoudig, geen erg ingewikkelde functie
of implementatie.
Laten we het nu eens proberen met het sorteren van een string.
En dus ga ik nu iets doen. En ik ga het in het algemeen doen, denk ik voor nu.
Ik zou deze in echte functies moeten zetten, maar we
demonstreren geen functies in deze lezing, we demonstreren strings.
Laten we dus nog een paar lokale variabelen maken die we nodig hebben.
We gaan vooral een naam bedenken.
En in dit geval
zou ik een reeks strings maken. We maken een array van strings en gebruiken f get s.
Ik ga een array van strings maken. Dus dit ziet eruit als
een tweedimensionale array.
Dus wat we hier doen, is dat we 25 snaren van maat 50 maken.
Dan ga ik er ook nog een maken van slechts 25, deze
zal elke string bevatten.
En dan ga ik nog
twee variabelen toevoegen. Ik ga een n en een j toevoegen.
En dus nadat we onze omgekeerde volgorde hebben gedaan, ga ik het uitprinten.
Een ander bericht om te
zeggen wat we aan het doen zijn,
sorteert de strings van een array met behulp van bubble sort.
Ik ga je het soort bellen niet uitleggen. Want nogmaals, dat is gewoon een algoritme dat niet
relevant is voor wat we doen. Echt, het is gewoon een manier om te sorteren.
Het is eigenlijk een van de gemakkelijkste soorten, omdat je in wezen gewoon ruilt.
Maar wat we willen doen, is dat we eerst willen weten hoeveel strings ze gaan invoeren. Dus we gaan zeggen
printf invoer aantal
strings, en dan gaan we scanf zeggen.
Scanf kan hier worden gebruikt omdat het maar een getal is.
We gaan procent d zeggen, en dat gaan we opslaan in onze lokale variabele n.
Nogmaals, ik weet dat ik hier geen grote
namen gebruik, maar ik laat iets zien. Omdat het een it's is, moeten we de ampersand doorgeven.
Dan ga ik ze vragen om de strings in te voeren.
Dus hier ga
ik zeggen input string
1 2 of 3 gevolgd door een line feed.
Dit is gewoon het nummer dat ze moeten invoeren.
Snaar één, snaar twee of snaar drie.
Dan heb ik eigenlijk een lus die doorgaat en de invoer krijgt.
Dus hier zeg ik, want I is gelijk aan 0,
I is kleiner dan gelijk aan n voor het aantal strings dat
ze willen invoeren en I plus plus of plus plus I.
Hier ga ik de tekenreeks echt lezen, en ik ga een andere manier van lezen gebruiken
- ik dacht eraan om f get s te gebruiken, zodat
je een tekenreeks met spaties zou kunnen invoeren. Maar ik denk niet dat we dat nodig hadden.
We scannen f,
en we gaan scanf inlezen in onze
namenreeks.
Onthoud dat we een naam hebben en dit is een reeks reeksen van
in wezen 25 tekens.
De 50 karakters 25 woorden.
Het maximale aantal woorden dat u kunt invoeren is dus 25.
Dus we gaan dit opslaan
in onze naamreeks. Dus we gaan gewoon scanf zeggen.
We gaan een string inlezen, en we gaan het in
naam sub I zetten.
En dus hebben we onze arrays opgeslagen, we kunnen er maximaal 25 opslaan.
Nu zijn we klaar met onze lus en nu kunnen we gewoon onze bellensoort schrijven.
En dus onze bellensoort, ik ga het je niet uitleggen, ik ga je gewoon vertellen dat het
een vrij eenvoudig algoritme is met een innerlijke lus.
Dus je hebt een for-lus die door alle strings gaat, I is
gelijk aan 1.
En dan in je innerlijke lus, ga je van nul naar
alle snaren min één. En je vergelijkt die eerste string met alle andere strings.
En je blaast ze in wezen naar beneden. Maar wat
hier belangrijk is, is de str-vergelijkingsfunctie.
Laat me proberen deze inspringing correct te
krijgen in de str-kopieerfuncties, dit is echt wat belangrijk is.
U zult opmerken dat ik voor geen van beide vier haakjes heb, omdat
ze enkele uitspraken hebben.
Ook al heeft deze if iets in zijn if-lichaam, dit is slechts één verklaring.
Dus we gaan van we vergelijken elk woord met elk ander woord in
wezen nadat we er eerder een hebben vergeleken.
Dus dan zeggen we als str vergelijk naam sub
j en naam sub j sub
één, dus str vergelijk heeft
twee argumenten, twee tekenarrays,
tekenaanwijzers eigenlijk.
En als ze gelijk zijn, zal het nul opleveren.
Als de eerste parameter kleiner is
dan de tweede parameter, wordt er
minder dan nul geretourneerd.
En als de eerste parameter groter is dan de tweede
parameter, zal deze groter zijn dan nul, één.
Dit zegt dus dat als de eerste reeks groter is dan de tweede reeks,
we alles willen omwisselen. En daarom hebben we die temp.
Temp slaat eigenlijk een tijdelijke tijdelijke string op.
Dus we voeren de tijdelijke naam sub j in
en dan verwisselen we naam sub j met namen van j plus één.
Dat is hoe de bellensoort werkt. Nogmaals, wat hier belangrijk is, is str-vergelijking en str-kopie.
En als je veilig bent, zou je strn-vergelijking willen gebruiken.
En wanneer je strn vergelijkt. Nou, eigenlijk strn vergelijk, het
maakt je niet uit, want dat is alleen als je het voorvoegsel wilt vergelijken.
Voor str copy wil je eigenlijk strn copy gebruiken.
En die derde parameter is wat belangrijk is.
Dus strn copy, je wilt er alleen voor zorgen dat je niet
meer kopieert dan de grootte van temp, minus één, omdat je anders een bufferoverloop hebt.
Dus je zou dit allemaal doen, je zou ook kunnen
gebruiken -- als het geen karakterbuffer was, wil je waarschijnlijk str-lengte
gebruiken als het een aanwijzer was. Maar de grootte van zal hiervoor prima werken.
En nogmaals, dit elimineert eventuele bufferoverschrijdingen.
Het is dus altijd veiliger om strn-kopie en één
te gebruiken omdat we onze nulterminator hebben die aan het einde moet verdwijnen.
Dus hier is het gewoon de bronbestemming voor strn-kopie.
We kopiëren naam sub j naar temp en hetzelfde met namen van j plus
één en naam sub j. En als laatste, temp in namen sub
j plus één. En ik moet
deze variabelen eigenlijk bijwerken omdat ze fout zijn
omdat ze altijd de bron moeten zijn. Dus noem hier naam sub j.
En dan zou de laatste namen
zijn van j plus één, j plus één.
Dus dat is strn kopiëren en str vergelijken, zeer eenvoudig te gebruiken functies.
Nadat we ze hebben gesorteerd, willen we ze gewoon uitprinten.
Dus we willen zeggen dat de strings verschijnen na het
sorteren, deze in
line feed plaatsen en dan een lus
doorlopen om
alle strings in onze array af te drukken.
Dus we zeggen dat 4 I gelijk is aan 0.
I is kleiner dan of gelijk aan n omdat de
n aangeeft hoeveel strings we hebben gesorteerd en ingevoerd.
Dan willen we gewoon onze reeks stringarrays doornemen.
Dus we willen zeggen printf s line
feed en naam sub I.
Dus naam sub I is eigenlijk onze gesorteerde array, daarom hadden we
namen naam sub I.
Ook al hebben we de tweede niet omdat die de grootte van elk karakter vertegenwoordigt.
25 woorden van maximaal 50
Dus laten we kijken of dit werkt.
Bouw het, kreeg een paar berichten omdat ik niet weet hoe ik moet spellen.
En als we dit uitvoeren. We gaan eerst onze reverse-functie uitvoeren, zodat je dat
opnieuw kunt zien omdat we in hetzelfde programma hebben opgenomen.
Zeg Fedin en idf dat is goed.
Voer het aantal strings in dat we willen sorteren. Laten we zeggen
vijf, laten we zeggen zzzz voor de duidelijkheid,
zoiets.
Ik heb daar een beetje geknoeid, maar het lijkt erop dat het opgelost is, a b d f r z.
Dus het werkt. Ik heb echter
één bug omdat invoerstring procent d.
Ik voer het aantal strings in n in en dan zeg ik minder dan
gelijk, ik zou gewoon minder dan moeten zeggen.
Dus laten we het nog een keer uitvoeren om het te demonstreren, maar ik moet het bouwen.
Vergeet niet te bouwen nadat je dingen hebt veranderd.
Nogmaals, we zeggen hier alles en
dan cijferreeksen. Laten we
er gewoon vier doen.
Dus dan alfabetiseren ze ze en zeggen d e l z, dus ziet er goed uit.
Dus je kunt deze code zeker verbeteren, waar je alles in functies
zou willen stoppen, maak het meer modulair. Maar wat ik met deze opdracht probeer
te doorstaan, is hoe je str Compare gebruikt, hoe je strn-kopie gebruikt en
hoe je str-lengte kunt gebruiken.
Je moet ook wat spelen met de str cat,
strn cat en dat is de andere veel voorkomende functie.
Misschien wil je wat spelen met strstr, strchar om te zoeken. Die zijn echt, echt
goed of de is, upper is, lower voor het controleren van
karakters, of de atoi nad atof conversiefuncties.
Dank u. Ik hoop dat dit nuttig was.