Hallo, en welkom terug. Nu we pointers een beetje meer in
detail begrijpen, wil ik het hebben over character pointers,
vooral hoe je character pointers kunt gebruiken om strings weer te geven.
Strings zijn tekenreeksen, meerdere tekens, woorden.
Dus we weten nu hoe arrays zich verhouden tot pointers in het concept van pointer-rekenkunde.
Zeer, zeer nuttig concept.
Deze concepten kunnen erg handig zijn wanneer ze
worden toegepast op tekenreeksen, omdat we nu gemakkelijk een tekenreeks teken voor teken kunnen doorlopen.
Een van de meest voorkomende toepassingen van het gebruik van een aanwijzer naar een array
is als een aanwijzer naar een tekenreeks.
De redenen zijn een van notatie gemak en efficiëntie.
Dus het gebruik van een variabele van het type pointer to char om
naar een string te verwijzen, geeft je veel flexibiliteit.
Dus je gaat proberen om
zoveel mogelijk karakteraanwijzers te gebruiken over karakterarrays,
in het bijzonder door karakteraanwijzers te gebruiken om gegevens door te geven aan een functie.
Allemaal van dat soort leuke dingen.
Laten we dus eens kijken naar een voorbeeld dat een array gebruikt om een string te kopiëren.
In dit voorbeeld wordt onze array-parameter een tekenarray.
Dat zie je meteen in de functiedeclaratie.
Ik wil dit vergelijken met een functie die een karakteraanwijzer
nodig heeft en u laten zien hoe de karakteraanwijzerfunctie een stuk efficiënter is.
Dus in dit voorbeeld hebben we twee functies, een
die een array nodig heeft en een
die pointers nodig heeft.
In de eerste functiekopiereeks kunnen
we de hele array doorlopen met een for-lus I is gelijk aan
nul van sub I en we gaan helemaal totdat we de
null-tekenreeks zien en dan verhogen we onze lusbesturingsvariabele.
En dan hoef je alleen maar te zeggen dat 2 sub I gelijk is aan sub I. We doen daar een
directe opdracht.
En dan helemaal aan het einde, nadat we helemaal zijn gegaan totdat we
null-tekens zien, voegen we een null-teken toe aan het einde
van onze to-array, vrij eenvoudig. Laten we nu eens kijken hoe we het doen als we aanwijzers gebruiken.
Eerst declareren we pointers als de functiedeclaratie in de kopieerreeks door
gewoon char star te zeggen tegen char start from.
In onze for-lus hoeven we eigenlijk geen variabelen te
declareren omdat we pointers hebben en we
willen gewoon herhalen totdat de from de nul-terminator raakt.
En dan kunnen we zowel de van als de naar-wijzers verhogen.
Omdat we hier puntberekeningen doen.
We voegen er gewoon een toe aan de aanwijzer die het adres met één verhoogt, die
het volgende teken krijgt.
En de volgende for-luslijn verwijzen we naar zowel
naar als de van omdat we de
werkelijke waarde willen toewijzen waarnaar de aanwijzer verwijst, het
werkelijke teken aan de aanwijzer.
En dan helemaal aan het einde voegen we
het null-teken toe aan waar de aanwijzer naar verwijst, die
aan het einde van het laatste adres van de tekenreeks zou zijn voor van
maar nu naar het adres wijst.
Het ziet er niet slecht uit. Ik bedoel, je hebt een for-lus.
Je hebt in principe hetzelfde aantal regels code.
Maar je ziet het verschil in syntaxis.
Je gebruikt geen subscripts en je gebruikt pointers, gebruik de asterisk.
Nogmaals, echt een kwestie van notatie gemak.
Je ziet hier geen groot voordeel.
Maar je kunt dit zelfs meer optimaliseren om zelfs
minder code te gebruiken wanneer je de aanwijzers gebruikt.
Dus als je een char-array als aanwijzer
hebt, als je een reeks tekens hebt die tekst wordt genoemd, kun je er op dezelfde
manier een aanwijzer naar toe definiëren en de elementen in de tekst gebruiken.
Dus hier zouden we kunnen zeggen
char star tekstaanwijzer, zo definieer je een karakteraanwijzer.
Als de tekstaanwijzer naar het begin wijst van de reeks
tekens die tekst wordt genoemd, kunt
u deze met één verhogen met behulp van deze pre- en postimplementatie- en decrementeringsoperatoren.
Dus dit hierboven, deze plus plus tekstaanwijzer zal de tekstaanwijzer naar het volgende
teken in de tekst laten wijzen, namelijk tekst sub 1.
Dus als we in de volgende straal willen kijken, net als voor gehele
getallen, hoeven we alleen maar 1 2 op te tellen en we kunnen het volgende teken krijgen.
Het is echter veel nuttiger in
tekenarrays, omdat je tekens gemakkelijk één voor één kunt manipuleren.
Als u een minus minus tekstaanwijzer doet, wat de decrementeringsoperator is, wordt de aanwijzer
naar het vorige teken in de tekst geplaatst, ervan uitgaande dat
de tekstaanwijzer niet naar het begin van de tekst wees.
Want als dat zo was, heb je deze fouten onder de limieten.
Als het een plus plus aan het einde van de string zou doen, zou je een out-of-bounds-fout hebben.
Je moet altijd voorzichtig zijn, net als bij een rekenkundig geheel getal, om niet voorbij de grenzen voor een array te gaan.
Maar heel eenvoudig, het heeft heel veel te maken met wanneer je met
integer aanwijzers rekent.
Tekenaanwijzer rekenkunde is hetzelfde.
Het is gewoon nog handiger omdat je nu echt naar individuele karakters kunt kijken zonder een subscript te gebruiken.
Dus als we naar dat vorige voorbeeld kijken
en we kunnen het eigenlijk een beetje meer optimaliseren met behulp van aanwijzers om
het nog minder regels code te maken.
Dus nu in onze kopieerreeks, doen we deze functiedeclaratie hetzelfde als voorheen, maak een
paar verwijzingen met behulp van de asterisk.
Maar we gebruiken geen for-lus meer omdat het in het vorige
voorbeeld nogal zinloos was om een for-lus
te gebruiken, omdat we de regelvariabele lus eigenlijk niet hoefden te initialiseren.
Het enige dat we hoefden te doen, was een
lus afsluiten onder een voorwaarde en dan gebruiken we eigenlijk de incrementatie- en decrementeringsoperatoren
in de for-lus, maar dat hoeven we niet eens te doen.
Het wordt hier zelfs nog veel eenvoudiger, want als we een while-lus gebruiken, hoeven
we alleen maar naar de while-lus te kijken en deze zal
eruit springen als deze naar een null-teken wijst, omdat het nul-teken eigenlijk
gelijk is aan nul.
En de while-lus onthoud dat Booleans in c
worden weergegeven door gehele getallen, één is waar en dan is
nul onwaar of echt nul is onwaar en dan is al het andere waar.
In dit geval, null-teken 0 dat onwaar is, springt het eruit.
Dus alles wat je hoeft te doen voor de exit-voorwaarde in de while-lus is een asterisk van.
Wat doet dat waar men afstand van neemt om te zien wat de waarde van dat personage is.
Dus als we aan het einde van de string zijn waarvan we willen kopiëren, springen we eruit.
Anders plaatsen we gewoon onze wijziging van
onze wijzers daar, twee plus plus van plus plus.
Dit is een post-incrementatie-operator.
Dit betekent dus dat de plus plus aan de rechterkant van de variabele staat.
En wanneer u dit doet, betekent dit dat
u er pas een toevoegt nadat de verklaring is voltooid.
Dus wat dit gaat doen, het gaat zeggen dat ster 2 gelijk is aan starten vanaf.
En dan nadat die verklaring is gedaan, gaat het optellen bij 2 1 en het gaat optellen bij van 1.
Als je de plus plus voor de naam van de variabele
had, zou het aan die variabele worden toegevoegd voordat het die instructie uitvoert en dat zou
een probleem zijn omdat we in wezen het eerste element dat in de tekenreeks
wordt gekopieerd, zouden missen.
Maar we hebben geen regels code meer nodig. We doen een daadwerkelijke rekenkundige en
toewijzing van de incrementatiewijzer in dezelfde instructie, dus we
verminderen de code met één.
Nogmaals, de notatie is heel eenvoudig.
We doen heel gemakkelijk een rekenkundige opdracht voor gehele getallen.
En aan het einde, nadat we klaar zijn, met het kopiëren
van alle tekenreeksen, voegen we aan het
einde gewoon het nulteken toe aan de aanwijzer die we verwijzen, omdat de twee eigenlijk de reden
zijn waarom het door de lus gaat, het zal naar de laatste wijzen karakter.
Dus het is hier maar een beetje opgeruimd.
Het laat je de kracht van aanwijzers
zien en hoe je aanwijzers en rekenkunde in dezelfde regels kunt gebruiken
en met deze ophogings- en decrementeringsoperatoren, deze plus plus en min minnen, maakt
het het nog sneller en gemakkelijker, dus het is ook efficiënter.
Als we deze kopieerreeksfuncties willen gebruiken, kunnen we gewoon twee tekenreeksen maken.
We kunnen de tekenarrays rechtstreeks doorgeven aan de kopieerreeks omdat de 0-tekenarrays
pointers zijn.
Het zijn verwijzingen, dus we hoeven ze niet echt te de-refereren of
adressen toe te voegen of iets dergelijks. We kunnen gewoon zeggen string2, string1.
En wat dit dus gaat doen, is dat het
een string kopieert die moet worden gekopieerd naar de tekenreeks string2
en deze vervolgens afdrukt met printf.
Ik wilde een voorbeeld doornemen van hoe je tekenaanwijzers kunt
gebruiken in plaats van tekenreeksen en waarom ze soms de voorkeur hebben.
We zeiden dat het soms de voorkeur van een programmeur is dat
als je in eerdere talen zoals Fortran hebt geprogrammeerd, je
misschien gewend bent om te verhogen. Maar als je het hebt,
zie je de voordelen van het gebruik van aanwijzers.
Ik hoop dat dit nuttig was. Dank u.