Hallo, en welkom terug.
We zitten in een nieuwe rubriek. Deze sectie heet pointers.
Dit is waarschijnlijk het belangrijkste onderdeel van de cursus.
Het is waarschijnlijk ook het moeilijkste deel van de cursus. Het concept van
pointers en c is een lastig, lastig concept.
Maar we gaan er heel langzaam doorheen.
We gaan veel lezingen geven en stap voor stap te werk gaan.
We gaan op het hoogste niveau beginnen en gaan steeds meer in detail.
U moet pointers begrijpen als u ten volle wilt profiteren
van de c-taal. Het is dus heel belangrijk.
Dus laten we bovenaan beginnen en praten over dit concept van indirectheid, dat
in wezen hetzelfde concept is als een aanwijzer.
Dus pointers lijken erg op het concept van indirectheid.
U gebruikt indirectheid in uw dagelijks leven. Dus als ik bijvoorbeeld
beschrijf wat indirectie betekent, zou het zijn alsof
je iets nieuws, een nieuw product, bij je bedrijf zou moeten kopen.
Stel dat u bijvoorbeeld een nieuwe inktcartridge voor uw printer moest kopen.
Als je bij een groot bedrijf werkt, zou je waarschijnlijk
door een bepaalde afdeling moeten gaan om
nieuwe aankopen te doen. Dus je zou waarschijnlijk naar de inkoopafdeling gaan.
U zou waarschijnlijk iemand bij de aankoop opbellen
en vragen om de nieuwe cartridge voor u te bestellen.
Het zou hun taak zijn om vervolgens een lokale winkel
te vinden die het daadwerkelijke artikel levert dat u wilt bestellen.
En wat dit betekent, is dat je dat artikel niet direct zelf gaat bestellen.
Je vraagt iemand om het voor je te doen.
En dan door hun expertise en hun kennis van wie
dat product in voorraad heeft, krijgen ze het
terug naar jou.
Dit is dus een mate van indirectheid die u aangaat. Je gaat niet door en gaat
gewoon naar de winkel om het te kopen. Je gaat naar de inkoopafdeling, de afdeling
van die persoon weet dat het gaat en doet alles voor je.
Dit is hetzelfde concept van een aanwijzer bij het programmeren.
In programmeertalen is indirectheid de mogelijkheid om naar iets te verwijzen met een naam
of referentie of container in plaats van de waarde zelf.
We gebruiken een vorm van interactie door variabelenamen te gebruiken.
We gebruiken het geheugenadres niet om toegang te krijgen tot gegevens.
We gebruiken een variabelenaam.
De meest voorkomende vorm van indirectheid is het manipuleren van een
waarde via het geheugenadres.
Dus naast een heel kleine beschrijving
van indirectie waarbij een variabelenaam wordt gebruikt om een geheugenadres weer te geven, manipuleert
u ook een waarde via het geheugenadres met behulp van het adres zelf.
het adres zelf.
Een aanwijzer biedt dus een indirecte manier om toegang te krijgen tot de waarde van een bepaald gegevensitem.
Het is een variabele waarvan de waarde een geheugenadres is, en
dit is essentieel om te begrijpen.
We hebben tot nu toe variabelen geleerd die
bepaalde soorten gegevens, getallen,
karakters, doubles, floats met rationale getallen bevatten.
Nu hebben we een variabele
die dit soort gegevens niet opslaat.
Het type gegevensopslag is een geheugenadres.
Het geheugenadres wordt weergegeven als een geheel getal, een
hexadecimaal getal, maar
het blijft een geheugenadres.
Het wordt dus de waarde
van een adres en een andere geheugenlocatie als het een bestaande variabele
is of een nieuwe locatie die u dynamisch toewijst.
Dus net zoals er redenen zijn waarom het zinvol is om langs
de inkoopafdeling te gaan om nieuwe cartridges te
bestellen, hoeft u bijvoorbeeld niet te weten bij welke winkel de cartridges worden besteld.
Er zijn ook goede redenen waarom het zinvol is om pointers
te gebruiken en c Om deze variabelen te gebruiken die een adres vertegenwoordigen, een geheugenadres.
Aan het begin van de cursus hadden we het over geheugenadressen.
En hoe wanneer u een programma uitvoert en u variabelen maakt, deze in het geheugen worden opgeslagen.
En dat geheugen heeft een bepaald adres. Je moet het adres weten om die gegevens
terug te krijgen, net zoals je het adres van een huis moet weten als je ergens heen gaat rijden of
een adres van een locatie.
Dus het gebruik van pointers in je programma is een van de krachtigste tools die beschikbaar zijn in de c-taal.
Daarom is het belangrijk om het te begrijpen.
Elk programma in c dat inhoudelijk is, gaat pointers gebruiken.
Dus je moet dit concept begrijpen.
En voor programmeurs die modernere talen zoals java of of
c sharp hebben geprogrammeerd, hoef je je hier niet
per se zorgen over te
maken omdat alle geheugentoewijzing en er is geen
echt concept van aanwijzers.
Ook al gebruikt Java
onder de motorkap pointers omdat ze kopieën van referenties hebben.
Het is hetzelfde soort concept. Maar in c heb
je expliciet een variabele die een adres vertegenwoordigt.
Pointers zijn ook een van de meest verwarrende concepten van de c-taal.
Ze worden vaak misbruikt
en worden meestal niet volledig begrepen, vooral door nieuwe programmeurs.
Het is dus belangrijk dat u dit concept aan het begin
doorgrondt en een duidelijk idee hebt van wat er
gebeurt als u ingaat op het steeds geavanceerdere c en het meer en meer geavanceerde pointers-concept.
Dus als je dit in het begin
niet begrijpt, studeer, studeer, oefen het schrijven van code met wijzers.
De compiler moet het type gegevens weten dat is opgeslagen
in de variabele waarnaar het verwijst. Het is dus net als een
gewone variabele en dat u het gegevenstype moet specificeren wanneer u de aanwijzer maakt.
De reden dat de compiler dit moet weten, is dezelfde reden voor variabelen,
hij moet weten hoeveel gegevens hij moet toewijzen, zelfs als je naar bepaalde gegevens verwijst.
Elke aanwijzer wordt geassocieerd met een specifiek type variabele.
Het kan alleen worden gebruikt om naar variabelen van dat type te
verwijzen, we zullen hiervan een voorbeeld geven als we het hebben over het definiëren van een aanwijzer.
Dus bijvoorbeeld pointers van het type
pointer ernaar kunnen alleen verwijzen naar variabelen van het type int.
Nogmaals, een variabele heeft de
waarde van een adres, dat is een pointer.
Dat adres kan ergens in het geheugen een waarde bevatten.
Pointers van het type pointer to float kunnen alleen verwijzen naar variabelen van het type float.
Dus hier is een illustratief
idee dat je het concept van een aanwijzer geeft.
Maak je hier geen zorgen over de syntaxis.
We hebben het in eerdere colleges al kort besproken dit ampersand en dit sterretje daar hoef je je
niet per se zorgen over te maken. Waar ik hier op
wil letten, is hoe een aanwijzer een adres heeft, en dat adres
kan een waarde bevatten, maar ergens anders in het geheugen zijn.
Dus in dit voorbeeld maken we een normaal getal, we
hebben het een miljoen keer gemaakt, dan zie je deze syntaxis met de asterisk die
aangeeft dat het een aanwijzer is. We gaan dat in detail doornemen.
Je ziet ook het ampersand, wat aangeeft dat het een adres is.
Dus in dit voorbeeld, wanneer we deze aanwijzer van het type int p-nummer maken,
wijzen we een adres toe. Want onthoud, pointers kunnen alleen adressen opslaan.
En hoe dit feitelijk in het geheugen is ingedeeld,
is dat je een variabele naamnummer
hebt en nummer heeft een waarde van 99.
Nummer heeft ook een adres in het geheugen.
Dat adres in het geheugen is de waarde van de aanwijzer.
Dus p-nummer is een aanwijzer die naar adres 1008 wijst.
1008 heeft een waarde van 99, bevat ook
het variabele nummer.
Dit is dus echt waar we naar toe gaan. Als dit niet duidelijk is, moet je hier een
uur naar kijken en ervoor zorgen dat je het begrijpt.
Nogmaals, het punt is dat een aanwijzer een waarde heeft naar
een adres, dat is wat het opslaat.
En dan heb je daadwerkelijk toegang tot de waarde in dat adres met behulp van een bepaalde syntaxis.
Dus waarom pointers gebruiken, waarom zelfs dit concept aansnijden, waarom kunnen we
niet gewoon bestaande gegevenstypen gebruiken
die we gebruiken en de tekenreeks gebruiken als we strings willen gebruiken.
Welnu, toegang tot gegevens door middel van alleen variabelen is zeer beperkend.
Met aanwijzers heb je toegang tot elke locatie, kun je elke geheugenpositie
als een variabele behandelen en dan kun je ook met
aanwijzers rekenen, wat het allemaal gemakkelijker maakt.
Pointers in c maken het gemakkelijker om arrays en strings
te gebruiken, en dat gaan we ook doornemen, dat is nog een voordeel om pointers te gebruiken.
Met aanwijzers kunt u met meerdere locaties naar dezelfde ruimte en hetzelfde geheugen verwijzen.
Dit betekent dus dat u het geheugen op één locatie kunt
bijwerken en dat de wijziging vervolgens vanaf een andere locatie in uw programma te zien is.
Het is een manier om globale gegevens te gebruiken, maar nog steeds ingekapselde interne functies te hebben.
U kunt ook veel geheugenruimte besparen door componenten in uw datastructuren
te kunnen delen.
Dus onthoud, toen c werd uitgevonden, werd c uitgevonden in de jaren '70.
Het idee van c was om zeer efficiënt en laag niveau te zijn.
Het idee om direct toegang te krijgen tot het geheugen via pointers
is zeer efficiënt,
en het is ook erg snel.
Met aanwijzers kunnen functies ook gegevens wijzigen die als variabelen aan
hen zijn doorgegeven. Dit wordt doorgegeven door middel van verwijzing. We gaan hier een lezing over houden.
Dit is waar je argumenten kunt doorgeven aan een functie met je pointers.
En dan binnen de functie, wanneer u die gegevens
wijzigt, wordt de verandering buiten die functie weerspiegeld.
We hoeven dus geen globale data meer te gebruiken.
We kunnen gegevens binnen een functie gebruiken, die gegevens
doorgeven als een aanwijzer en dan worden die gegevens
buiten die functie toegewezen. Het heeft dus niet het nadeel
om globale variabelen te gebruiken waar alles nauw met elkaar verbonden is, je
kunt dat beperken tot alleen de gegevens die nodig zijn tot alleen de functies die die gegevens moeten kennen.
Zoals ik al zei, kan het ook worden gebruikt om het programma te
optimaliseren om sneller te werken en minder
geheugen te gebruiken dan anders,
wat een belangrijk concept is, vooral in ingebedde realtime-programma's.
Aanwijzers stellen ons ook in staat om meerdere waarden uit een functie te halen.
We hebben het gehad over functies over hoe u gegevensfuncties kunt doorgeven.
We hebben het ook gehad over hoe u gegevens kunt retourneren.
We weten dat je op dit moment maar één waarde uit een functie kunt retourneren.
Maar als u pointers gebruikt, kunt u meerdere waarden van een functie retourneren.
En daar gaan we het over hebben. Dat is een groot voordeel.
We gaan het ook hebben over dynamische geheugentoewijzing.
Op dit moment, wanneer we geheugen voor een programma maken, wordt dit
impliciet gedaan door de compiler wanneer u een variabele declareert.
Als u een int-variabele declareert, maakt het bijvoorbeeld automatisch 4 bytes voor die variabele.
Wanneer u arrays gebruikt en u de grootte van een
array opgeeft, wordt die grootte toegewezen tijdens het compileren.
Dus als je meer data probeert op te slaan, dan ben je de
klos, je programma zal niet werken.
Maar als je de mogelijkheid zou hebben om
tijdens runtime zoveel geheugen te creëren als je nodig hebt,
zou dat enorm zijn. En met wijzers kunt u dit doen.
Hiermee kunt u tijdens runtime dynamische geheugentoewijzing creëren.
We gaan het hier ook allemaal over hebben.
Pointers stellen ons in staat om complexere datastructuren te ontwerpen en te ontwikkelen.
En datastructuur is iets dat gegevens opslaat.
Voorbeelden van datastructuren zijn stack a cue of een linked list.
En we kunnen die veel gemakkelijker maken met behulp van aanwijzers.
Pointers bieden directe geheugentoegang, nogmaals, efficiënt en snel.
Dus pointers worden een groot concept. We gaan veel lezingen houden over wijzers.
Ik wil dat jullie je concentreren, en ik wil dat jullie opletten als ik over al
deze concepten praat, omdat het belangrijk en essentieel is om de programmeertaal c te begrijpen.
Dus veel succes, en laten we beginnen. Dank u.