>> [Muziek]
>> DOUG LLOYD: Pointers, hier zijn we.
Dit is waarschijnlijk gaan om de meest moeilijke onderwerp
dat we praten over in CS50.
En als je hebt gelezen iets over pointers
voordat u een beetje zou kunnen zijn intimiderend te gaan op deze video.
Het is waar de pointers toestaan ​​dat u de capaciteit
tot misschien verknallen vrij slecht als je
werken met variabelen, en data, en het veroorzaken van het programma crasht.
Maar ze zijn eigenlijk heel nuttig en ze ons echt een geweldige manier toe
om gegevens terug te passeren en weer tussen functies
die we anders niet in staat zijn te doen.
>> En dus wat we echt hier wil doen is de trein
u goede pointer discipline, dus dat je pointers effectief kan gebruiken
om uw programma's die veel beter te maken.
Zoals ik al zei pointers geven ons een andere manier om gegevens tussen functies passeren.
Nu als je herinneren van een eerdere video, als
we hadden het over variabele reikwijdte, ik noemde
dat alle gegevens die we passeren tussen functies in C wordt doorgegeven door de waarde.
En ik mag niet gebruikt dat term, wat ik daar betekende
was dat we passeren exemplaren van gegevens.
Toen we langs een variabele aan een functie, we zijn niet echt het passeren van de variabele
om de functie, toch?
We passeren een kopie van die gegevens naar de functie.
De functie doet wat het wil en berekent een bepaalde waarde,
en misschien gebruiken we die waarde wanneer geeft het weer.
>> Er was één uitzondering deze regel van het doorgeven van de waarde,
en we zullen terug naar wat die komen is een beetje verderop in deze video.
Als we gebruik maken van pointers plaats gebruik van variabelen,
of plaats van de variabelen zelf of kopieën van de variabelen,
kunnen we nu langs de variabelen rond tussen functies op een andere manier.
Dit betekent dat als we een verandering in een functie,
die verandering ook daadwerkelijk te nemen effect in een andere functie.
Nogmaals, dit is iets dat we konden niet eerder doen,
en als je ooit hebt geprobeerd om de swap waarde van twee variabelen in functie,
u dit probleem hebt gemerkt soort omhoog kruipen, toch?
>> Willen we X en Y, en we wisselen geef ze een functie genaamd swap,
binnenkant van de functie van de swap variabelen doen uitwisseling waarden.
Men wordt twee, twee wordt één, maar we eigenlijk niet
iets veranderen in de oorspronkelijke functie van de beller.
Want we kunnen niet, we zijn alleen werken met kopieën van hen.
Met verwijzingen hoewel, we kunnen eigenlijk passeren X en Y om een ​​functie.
Die functie kan doen iets mee.
En die variabelen waarden daadwerkelijk kan veranderen.
Dus dat is nogal een verandering in ons vermogen om te werken met data.
>> Voordat we een duik in pointers, ik denk dat het de moeite waard
het nemen van een paar minuten om ga terug naar de basis hier.
En hebben een blik op hoe computergeheugen werken
omdat deze twee onderwerpen gaan eigenlijk behoorlijk met elkaar verbonden.
Zoals u waarschijnlijk weet, op uw computersysteem
heb je een harde schijf of misschien een solid state drive,
een soort van opslag van bestanden locatie.
Het is meestal ergens in de nabijheid van 250 gigabyte
om misschien een paar terabytes nu.
En het is waar al je bestanden uiteindelijk wonen,
zelfs wanneer de computer wordt afgesloten off, kunt u het weer inschakelen
en u vindt uw bestanden er weer wanneer u uw systeem opnieuw op te starten.
Maar harde schijven, zoals een harde schijf, een harde schijf of een solid state drive, een SSD,
zijn slechts opslagruimte.
>> We kunnen niet echt iets te doen met de gegevens die op de harde schijf,
of in een solid state drive.
Om daadwerkelijk veranderen gegevens of het rond bewegen,
we hebben om het te verplaatsen naar RAM, random access memory.
Nu RAM, heb je een heleboel minder op je computer.
U kunt ergens in het hebben nabijheid van 512 megabytes
als je een oudere computer, tot misschien twee, vier, acht, 16,
misschien zelfs een beetje meer, gigabytes aan RAM.
Dus dat is veel kleiner, maar dat is waarbij alle vluchtige gegevens bestaan.
Dat is waar we dingen kunnen veranderen.
Maar wanneer we onze computer uit, alle data in het RAM wordt vernietigd.
>> Dus dat is waarom we nodig hebben om de harde schijf hebt voor de meer permanente locatie ervan,
zodat het zou exists- echt slecht als elke keer als we
draaide onze computer uit, elke bestand in ons systeem werd uitgewist.
Dus werken we binnen RAM.
En elke keer als we het over geheugen, vrij veel, in CS50,
we praten over RAM, geen harde schijf.
>> Dus als we de dingen te verplaatsen in het geheugen, neemt hij een bepaalde hoeveelheid ruimte.
Alle data types die We hebben gewerkt met
nemen verschillende hoeveelheid ruimte in RAM.
Dus elke keer dat u een integer maken variabele vier bytes geheugen
zijn gereserveerd in het RAM-geheugen, zodat u kan met die integer.
U kunt de integer verklaren, veranderen, toe te wijzen
tot een waarde 10 opgehoogd een, enzovoort, enzovoort.
Alles wat moet gebeuren RAM, en je krijgt vier bytes
werken voor elke integer die u maakt.
>> Elk teken dat u maken krijgt één byte.
Dat is gewoon hoeveel ruimte nodig om een ​​teken te slaan.
Elke vlotter, een echte nummer, krijgt vier bytes
tenzij het een double precision floating point
nummer, die u toelaat om hebben meer nauwkeurige of meer cijfers
na de komma zonder verlies van precisie,
die nemen acht bytes aan geheugen.
Lange longs, echt grote getallen, nemen ook acht bytes aan geheugen.
Hoeveel bytes geheugen do strijkers nemen?
Nou laten we een speld in die vraag voor nu, maar we zullen terug te komen.
>> Dus terug naar het idee van het geheugen een groot scala aan byte-sized cellen.
Dat is echt alles wat het is, het is gewoon een enorm scala aan cellen,
net als elke andere array je bekend bent en te zien,
met uitzondering van elk element is een byte breed.
En net als een array, elk element heeft een adres.
Elk element van een array heeft een index, en we
kan die index gebruiken doen zogenoemde willekeurige toegang op de array.
We hoeven niet te beginnen bij het begin van de array,
doorloopt elke enkel element daarvan,
om te vinden wat we zoeken.
We kunnen alleen maar zeggen, ik wil het te krijgen 15 element of de 100-element.
En je kunt gewoon passeren in dat nummer en ontvang de waarde die u zoekt.
>> Evenzo elke locatie in het geheugen heeft een adres.
Zodat uw geheugen macht kijken iets als dit.
Hier is een zeer klein deel van geheugen, dat is 20 bytes geheugen.
De eerste 20 bytes omdat mijn richt daar onderaan
zijn 0, 1, 2, 3, enzovoort Op de weg naar 19.
En toen ik verklaar variabelen en als ik begin te werken met hen,
het systeem gaat ingesteld wat ruimte gereserveerd voor mij
in dit geheugen werkt mijn variabelen.
Dus ik zou zeggen, char c is gelijk aan het kapitaal H. En wat gaat er gebeuren?
Goed het systeem gaat gereserveerd voor mij een byte.
In dit geval gekozen bytenummer vier, de byte op het adres van vier,
en het gaat om het op te slaan letter hoofdletter H daar voor mij.
Als ik dan zeg int snelheid limiet bedraagt ​​65, het
gaat om vernietiging van vier bytes van het geheugen voor mij.
En het gaat om die te behandelen vier bytes als een eenheid
want wat we werken met een geheel getal in.
En het gaat te slaan 65 in.
>> Nu al ben ik soort vertel je een beetje een leugen,
recht, omdat we weten dat computers werken in binaire.
Ze begrijpen niet noodzakelijk wat een hoofdletter H is
of wat een 65 is, maar ze begrijpen binair, nullen en enen.
En dus eigenlijk wat we opslaan daar
niet de letter H en nummer 65, maar de binaire voorstellingen
daarvan, die ziet er een iets als dit.
Met name in het context van de integer variabele
het gaat niet om gewoon spuug het in, het gaat niet om het te behandelen als een vier
byte brok per se, het is eigenlijk gaat
te behandelen als een vier byte stukken, die zoiets zou kunnen zien.
En zelfs dit is niet helemaal waar ofwel,
vanwege iets genaamd een endianness, die we niet
van plan om in nu, maar Als je benieuwd bent,
u kunt lezen op kleine en grote endianness.
Maar omwille van dit argument terwille van de video,
laten we aannemen dat is, in feit, dat het getal 65 zou
in worden vertegenwoordigd geheugen op elk systeem,
maar het is niet helemaal waar.
>> Maar laten we eigenlijk gewoon ontdoen van alle binaire geheel,
en denk maar als H en 65, het is een stuk makkelijker
na te denken over het als die als mens.
Oké, dus het lijkt ook misschien een kleine willekeurige dat I've- mijn systeem
gaf me geen bytes 5, 6, 7, en 8 op de integer slaan.
Er is een reden voor dat ook, die zullen we niet krijgen op dit moment, maar het volstaat
te zeggen dat wat de computer is hier aan het doen
is waarschijnlijk een goede zet op zijn kant.
Om niet geven me geheugen dat is noodzakelijkerwijs rug aan rug.
Hoewel het gaat om het nu te doen als ik wil andere string te krijgen,
riep achternaam, en ik wil Lloyd in daar te zetten.
Ik ga nodig hebben om een ​​fit karakter, elke letter van die
gaat naar een vereisen karakter, een byte geheugen.
Dus als ik Lloyd in mijn reeks kon zetten als deze Ik ben er vrij goed om te gaan, toch?
Wat ontbreekt er?
>> Vergeet niet dat elke snaar we werken met in C eindigt met een backslash nul,
en we kunnen hier niet weg te laten die, hetzij.
We moeten opzij één byte ingesteld van het geheugen zo houden we dat
weten wanneer onze reeks is beëindigd.
Dus nogmaals deze regeling van de gang van zaken
verschijnen in het geheugen macht een beetje willekeurig,
maar eigenlijk is hoe de meeste zijn ontworpen.
Om hen line-up op een veelvoud vier, om redenen weer
dat we niet hoeven te krijgen nu.
Maar dit, zodat het volstaat om te zeggen dat Na deze drie regels code,
dit is wat het geheugen eruit zou kunnen zien.
Als ik het nodig het geheugen locaties 4, 8 en 12 om mijn gegevens te houden,
dit is wat mijn geheugen eruit zou kunnen zien.
>> En gewoon bijzonder zijn pedant hier, wanneer
we praten over het geheugen adressen we meestal
dit doen met behulp van hexadecimale notaties.
Dus waarom niet we zetten al deze van decimaal naar hexadecimale notatie
gewoon omdat dat is over het algemeen hoe verwijzen we naar het geheugen.
Dus in plaats van 0 tot 19, wat we hebben is nul
x nul tot nul x1 drie.
Dat zijn de 20 bytes geheugen die we hebben of we kijken naar in dit beeld
hier.
>> Dus al dat gezegd zijnde, laten we stap weg van het geheugen voor een tweede
en terug naar pointers.
Hier is het belangrijkste om te onthouden
als we beginnen werken met pointers.
Een pointer is niets meer dan een adres.
Ik zal het nogmaals zeggen, want Het is zo belangrijk,
een pointer is niets meer dan een adres.
Pointers zijn adressen aan locaties in het geheugen waar de variabelen wonen.
Wetende dat het wordt hopelijk een beetje gemakkelijker om te werken met hen.
Een ander ding dat ik graag te doen is om een ​​soort hebben
diagrammen visueel vertegenwoordigen wat gebeurt met diverse regels code.
En we zullen dit een paar te doen keer in pointers,
en als we praten over dynamische toewijzing van het geheugen ook.
Omdat ik denk dat deze diagrammen kan bijzonder nuttig.
>> Dus als ik zeg bijvoorbeeld, int k in mijn code, wat gebeurt er?
Nou wat er eigenlijk gebeurt is Ik krijg het geheugen gereserveerd voor mij,
maar ik weet niet eens graag denken als dat, ik
graag over na te denken als een doos.
Ik heb een doos en het gekleurde groen omdat ik
kan integers in groene vakjes te zetten.
Als het een karakter I misschien een blauw vak.
Maar ik zeg altijd, als ik het creëren een doos die getallen kan houden
die doos is groen gekleurd.
En ik neem een ​​permanent marker Ik schrijf k aan de kant ervan.
Dus ik heb een doos genoemd k, waarin ik integers kan zetten.
Dus als ik zeg int k, dat is wat gebeurt er in mijn hoofd.
Als ik zeg dat k gelijk aan vijf, wat doe ik?
Nou, ik ben om vijf in het vak, rechts.
Dit is vrij eenvoudig, als Ik zeg int k, maak een doos genoemd k.
Als ik zeg dat k gelijk aan 5, zet vijf in de doos.
Hopelijk is dat niet te veel van een sprong.
Hier is waar de dingen gaan een weinig interessant hoor.
Als ik zeg int * pk, goed, zelfs als ik niet weet wat dit noodzakelijkerwijs betekent,
het is duidelijk iets te maken met een integer.
Dus ik ga om te kleuren dit vakje groen-ish,
Ik weet dat het iets te maken met een integer,
maar het is niet een geheel getal zelf, want het is een int ster.
Er is iets lichtjes anders over.
Dus in een geheel getal is, maar anders is
niet te verschillend van waar we het over hadden.
Het is een doos, het heeft een label, Het draagt ​​een label pk,
en het is in staat van het bedrijf int sterren, welke dat zijn.
Ze hebben iets te doen met getallen, duidelijk.
Hier is de laatste regel wel.
Als ik zeg pk = & k, whoa, wat er net gebeurd, toch?
Dus dit willekeurig getal, schijnbaar willekeurige nummer, wordt geworpen in de doos daar.
Dat alles is, is pk krijgt het adres van k.
Dus ik ben steken waarbij k woont in het geheugen, zijn adres, het adres van haar bytes.
Alles wat ik doe is wat ik zeg die waarde is wat ik ga
binnenkant van mijn doos genoemd pk te zetten.
En omdat deze dingen zijn pointers en omdat kijken
in een string als nul x acht nul c zeven vier acht
twee nul is waarschijnlijk niet erg zinvol.
Toen we over het algemeen te visualiseren pointers, we eigenlijk doen als pointers.
Pk geeft ons de informatie moeten we k vinden in het geheugen.
Dus eigenlijk pk heeft een pijl in.
En als we lopen de lengte van die pijl, stel
het is iets wat je kunt lopen, als we wandelen langs de lengte van de pijl,
op het uiterste puntje van die pijl, we zal de locatie in het geheugen vinden
waarbij k woont.
En dat is echt belangrijk want zodra we weten waar k woont,
kunnen we beginnen te werken met de data binnenkant van dat geheugen locatie.
Hoewel we krijgen een piepklein beetje vooruit onszelf voor nu.
>> Dus wat is een pointer?
Een pointer is een data-item waarvan waarde is een geheugen adres.
Dat was dat nul x acht nul stuff er aan de hand, dat was een geheugen adres.
Dat was een locatie in het geheugen.
En het type van een pointer beschrijft het soort
van de gegevens die u kunt vinden op dat het geheugen adres.
Dus er is de int ster deel rechts.
Als ik volg dat de pijl, het is gaat me te leiden naar een locatie.
En die locatie, wat ik vindt er in mijn voorbeeld,
is een groen gekleurd vak.
Het is een geheel getal, dat is wat ik zal vinden als ik naar dat adres.
De data type van een wijzer beschrijft wat
vindt u op dat het geheugen adres.
Dus hier is het echt cool ding.
Pointers ons toelaten te passeren variabelen tussen functies.
En eigenlijk passeren variabelen en niet kopieën van hen passeren.
Want als we precies weten waar geheugen naar een variabele vinden
we hoeven niet om een ​​kopie van te maken , kunnen we gewoon naar die locatie
en werken met die variabele.
Dus in wezen pointers soort te maken van een computer-omgeving
veel meer als de echte wereld, rechts.
>> Dus hier is een analogie.
Laten we zeggen dat ik een notebook, rechts, en het is vol met aantekeningen.
En ik zou graag willen dat u te werken.
Je bent een functie die updates notities, rechts.
In de manier waarop we hebben geweest dusver werken, wat
gebeurt wordt u mijn notebook te nemen, ga je naar de kopie op te slaan,
je een Xerox kopie van maken elke pagina van de notebook.
Je zal mijn laptop terug te verlaten op mijn bureau als je klaar bent,
je zult gaan en doorhalen dingen in mijn notebook die verouderd zijn of fout,
en dan zul je terug te geven aan me de stapel Xerox pagina's
dat is een replica van mijn notebook de wijzigingen die u hebt aangebracht.
En op dat moment, het is aan mij als de roeping functie, als de beller,
om te beslissen om uw notities te nemen en integreren ze terug in mijn notebook.
Dus er is veel trappen hier gaat, rechts.
Als zou het niet beter zijn als ik alleen maar zeggen, hey, kunt u
update mijn notebook voor me, geef je mijn notebook,
en je dingen te nemen en ze letterlijk doorhalen
en update mijn aantekeningen in mijn notebook.
En dan geef ik mijn notebook terug.
Dat is een soort van wat pointers ons in staat om te doen,
ze maken deze omgeving veel meer zoals hoe we in werkelijkheid opereren.
>> Oké dus dat is wat een pointer is, laten we praten
hoe pointers werken C, en hoe we kunnen beginnen te werken met hen.
Dus er is een zeer eenvoudige pointer in C genaamd de null pointer.
De null pointer verwijst naar niets.
Dit waarschijnlijk lijkt alsof het eigenlijk niet een zeer nuttig ding,
maar zoals we zullen zien een even later, het feit
dat dit null pointer bestaat eigenlijk echt kan van pas komen.
En wanneer u een wijzer te maken, en u niet de waarde immediately- ingesteld
een voorbeeld van de instelling onmiddellijk de waarde
zal een paar dia's terug waar ik zei pk evenaart & K,
pk krijgt adres k, zoals we zullen zien wat dat betekent,
we zullen zien hoe de code die shortly- als we niet de waarde om iets te stellen
onmiddellijk zinvol, Je moet altijd
stel je pointer te wijzen op null.
Je moet instellen om te wijzen op niets.
>> Dat is heel anders dan verlaat de waarde is
en waarbij een pointer en gewoon in de veronderstelling
het is null, want dat is zelden waar.
Dus je moet altijd ingesteld de waarde van pointer
op null als u niet de waarde in te stellen om iets zinvols onmiddellijk.
U kunt controleren of de waarde van een pointer's null is met behulp van de operator gelijkheid
(==), Net als je het vergelijkt elke integer waarden of karakter waarden met (==)
ook.
Het is een speciale soort van constante waarde die u kunt gebruiken om te testen.
Dus dat was een zeer eenvoudige wijzer, de null pointer.
Een andere manier voor het creëren een pointer te extraheren
het adres van een variabele u al hebt gemaakt,
en je doet dit met behulp van de & operator adres extractie.
Die hebben we al eerder gezien in het eerste diagram voorbeeld toonde ik.
Dus als x een variabele die we hebben al gemaakt van het type integer,
dan en x een pointer naar een integer.
& x is- herinneren, en gaat te extraheren het adres van het ding aan de rechterkant.
En omdat een pointer is gewoon een adres, dan en x een pointer naar een integer
waarvan de waarde is waar in het geheugen x leven.
Het is het adres x's.
Dus is en x het adres van x.
Laten we dit een stap verder en verbinding iets
Ik gezinspeeld in een eerdere video.
Als arr is een array van doubles, dan & arr square bracket i is een pointer
om een ​​dubbele.
OK.
arr vierkante haak ik, als arr is een array van doubles,
dan arr square bracket i het i-de element van de matrix,
en & arr vierkante haken i is waar in geheugen van de i-de element van arr bestaat.
>> Dus wat is de implicatie hier?
Een arrays naam, de implicatie van dit hele ding,
is dat de naam van een array is in feite zelf een pointer.
Je hebt gewerkt met verwijzingen langs
elke keer dat u een array hebt gebruikt.
Vergeet niet uit het voorbeeld op variabele reikwijdte,
in de buurt van het einde van de video presenteer ik een voorbeeld waar we een functie
riep set int en een functie genaamd set array.
En uw uitdaging om te bepalen of, of welke
waarden die we uitgeprint het einde van de functie,
aan het einde van het hoofdprogramma.
>> Misschien herinner je je van dat voorbeeld of als u de video hebt bekeken,
je weet dat wanneer je- de oproep om set int effectief doet niets.
Maar het gesprek op te zetten serie doet.
En ik soort van verbloemd waarom dat het geval op dat moment.
Ik zei gewoon, nou het is een array, het is speciale, weet je, er is een reden.
De reden is dat een array naam is eigenlijk gewoon een pointer,
en er is deze speciale syntax beugel plein dat
dingen veel leuker om mee te werken.
En ze maken het idee van een pointer een stuk minder intimiderend,
en dat is waarom ze sorteren van gepresenteerd op die manier.
Maar echt arrays zijn pointers.
En dat is waarom wanneer we een wijziging aan de array
toen we voorbij een array als parameter een functie of als argument
een functie van de inhoud van de array in zowel de aangeroepene eigenlijk veranderd
en de beller.
Die voor elke andere vorm van variabele we zagen was niet het geval.
Dus dat is gewoon iets om in te houden geest als je werkt met pointers,
is de naam van een serie eigenlijk een pointer
het eerste element van de matrix.
>> OK dus nu hebben we al deze feiten, laten we gaan, rechts.
Waarom hebben we de zorg over waar iets leeft.
Nou zoals ik al zei, het is vrij handig om te weten waar iets leeft
dus je kunt er naartoe te gaan en te wijzigen.
Ermee werken en eigenlijk hebben het ding dat je
willen doen om die variabele take effect, en geen effect op sommige kopie ervan.
Dit heet dereferentie.
We gaan naar de referentie en we de waarde te wijzigen daar.
Dus als we een pointer en het heet pc, en het wijst op een teken,
dan kunnen we zeggen * PC en * pc is de naam van wat we vinden als we gaan
het adres pc.
Wat zullen we daar vinden is een karakter en * pc is hoe we verwijzen naar de gegevens op dat
locatie.
Dus konden we iets zeggen * PC = D of iets dergelijks,
en dat betekent dat wat was in het geheugen adres pc,
welke aard was eerder er is nu D, als we zeggen dat * st = D.
>> Dus hier gaan we weer met wat rare C spullen, rechts.
Dus hebben we eerder gezien * als ergens deel van het gegevenstype,
en nu is het gebruikt in een iets andere context
om de gegevens op een locatie.
Ik weet dat het een beetje verwarrend en dat is eigenlijk een deel van dit hele
zoals, waarom pointers hebben dit mythologie om hen als zo complex,
is een soort van een syntax probleem, eerlijk gezegd.
Maar * wordt gebruikt in zowel contexten zowel als onderdeel van het type naam
en we zullen zien wat later iets anders, ook.
En op dit moment is de dereference operator.
Zo gaat de verwijzing, het toegang Gegevens
ter plaatse van de aanwijzer en stelt u in staat om het te manipuleren naar believen.
>> Nu is deze vergelijkbaar met het bezoeken van uw buurman, rechts.
Als u weet wat uw buurman woont, je bent
niet opknoping uit met je buurman.
Je weet dat je toevallig weten waar ze wonen,
maar dat betekent niet dat door Krachtens hebben die kennis
je interactie met hen.
Als u wilt communiceren met hen, je moet naar hun huis,
je moet gaan naar de plaats waar ze wonen.
En zodra je dat doet, dan kunt u communiceren
met hen net zoals je zou willen.
En ook met variabelen je nodig hebt om naar hun adres
Als je ze wilt communiceren, je kunt niet zomaar kennen het adres.
En de manier waarop je naar het adres te gebruiken *, de dereference operator.
Wat denk je dat er gebeurt als we proberen en dereferentie
een pointer waarvan de waarde is nul?
Bedenk dat de null pointer verwijst naar niets.
Dus als je probeert en dereferentie niets of ga naar een adres niets,
wat denk je dat er gebeurt?
Nou als je raadt segmentatie fout, zou je gelijk hebben.
Als je probeert en dereferentie een null pointer,
u last heeft van een segmentatie fout. Maar wacht,
heb ik niet vertellen, dat als je niet van plan
uw waarde van uw set pointer naar iets zinvols,
je moet instellen op nul?
Ik deed en eigenlijk de segmentatie fout is een soort van een goed gedrag.
>> Heb je ooit uitgeroepen tot een variabele en de waarde niet onmiddellijk toegekend?
Dus je gewoon int x zeggen; je dat niet doet het eigenlijk niets toewijzen
en dan later in uw code, u uitprinten de waarde van x,
die nog steeds niet toegewezen aan iets.
Vaak krijg je nul, maar soms moet je
misschien nog wat willekeurig getal, en je hebt geen idee waar het vandaan kwam.
Op dezelfde manier kunnen dingen gebeuren met pointers.
Wanneer u verklaren een pointer int * pk bijvoorbeeld,
en je het niet toewijzen aan een waarde, je krijgt vier bytes voor het geheugen.
Wat vier bytes het geheugen van het systeem kan
vinden dat sommige zinvolle waarde hebben.
En er zou zijn geweest iets wat er al die
niet langer nodig een andere functie, dus je hoeft alleen
welke gegevens er was.
>> Wat als je probeerde te dereferentie doen sommige-mailadres dat u don't- er
al bytes en informatie in er zijn, dat is nu in uw pointer.
Als u probeert en dereferentie dat wijzer, je zou kunnen knoeien met wat geheugen
dat u niet van plan te knoeien met het allemaal.
En in feite je zou kunnen doen iets echt verwoestende,
zoals breken een ander programma, of breken een andere functie,
of iets kwaadaardige doen u niet van plan om helemaal te doen.
En dus dat is waarom het eigenlijk een goed idee
om uw pointers ingesteld op null als u ze niet ingesteld op iets zinvols.
Het is waarschijnlijk beter in de eind van de dag van uw programma
te crashen dan voor het te doen iets dat verknoeit
ander programma of een andere functie.
Dat gedrag is waarschijnlijk zelfs minder ideaal dan crashen.
En dus dat is waarom het eigenlijk een goede gewoonte
te krijgen in uw pointers set null als je ze niet instellen
een zinvolle waarde onmiddellijk, een waarde die je kent
en dat kunt u veilig de dereference.
>> Dus laten we komen nu terug en neem een ​​kijkje de algemene syntax van de situatie.
Als ik zeg int * p ;, wat heb ik net gedaan?
Wat ik heb gedaan is dit.
Ik weet dat de waarde van p is een adres omdat alle aanwijzingen zijn
adressen.
Ik kan dereference p * met de operator.
In dit verband hier op zijn top herinneren aan de * is onderdeel van het type.
Int * is het type data.
Maar ik kan dereference p het gebruik van de * operator,
en als ik dat doe, als ik naar dat adres, wat zal ik op dat adres?
Ik zal een integer vinden.
Dus int * p fundamenteel zeggende: p is een adres.
Ik kan dereference p en als Ik doe, zal ik een integer vinden
op dat het geheugen locatie.
>> OK, dus ik zei dat er was een andere vervelende met sterren
en hier is waar dat vervelende met sterren is.
Heb je ooit geprobeerd te verklaren meerdere variabelen van hetzelfde type
op dezelfde lijn van code?
Dus voor een tweede, beweren dat de lijn, de code die ik heb er eigenlijk in het groen
is er niet en zegt het enkel int x, y, z ;.
Wat dat zou doen is eigenlijk te creëren drie integer variabelen voor u,
een zogenaamde x, een zogenaamde y, en een zogenaamde z.
Het is een manier om het te doen zonder hoeven te splitsen op drie lijnen.
>> Hier is waar sterren krijgen vervelend weer wel,
omdat de * is eigenlijk een deel van zowel de naam en een deel het type
van de variabele naam.
En dus als ik zeg int * px, py, pz, wat ik eigenlijk is een pointer naar een integer
riep px en twee getallen, py en pz.
En dat is waarschijnlijk niet wat we willen, dat is niet goed.
>> Dus als ik wil meerdere pointers maken op dezelfde lijn, van hetzelfde type,
en sterren, wat ik eigenlijk nodig te doen is zeggen int * pa, pb *, * pc.
Nu alleen dat gezegd hebbende en nu vertel je dit,
zal je waarschijnlijk nooit doen.
En het is waarschijnlijk een goede zaak eerlijk, omdat je misschien per ongeluk
weglaten een ster, zoiets.
Het is waarschijnlijk het beste om misschien te verklaren tips over individuele lijnen,
maar het is gewoon een ander van die vervelende syntaxis
dingen met sterren die te maken pointers zo moeilijk om mee te werken.
Want het is gewoon dit syntactische puinhoop je doorheen moet werken.
Met de praktijk doet echt een tweede natuur geworden.
Ik fouten maken nog steeds met het nog steeds Na programmering voor 10 jaar,
dus wees niet boos worden als er iets gebeurt aan u, het is vrij normaal eerlijk.
Het is echt een soort van een fout van de syntaxis.
>> OK dus ik soort beloofd dat we zouden terugkomen
het begrip van hoe groot een tekenreeks.
Nou als ik je vertelde dat er een touwtje, hebben we echt een soort van
gelogen om u de hele tijd.
Er is geen datatype genoemd snaar, en in feite I
vertelde dit in een van onze vroegste video's op data types,
dat koord een gegevenstype dat is gemaakt voor u in CS50.h.
Je moet #include CS50.h om het te gebruiken.
>> Nou reeks is eigenlijk gewoon een alias iets
genaamd de char *, een pointer naar een karakter.
Nou pointers, recall, zijn slechts adressen.
Dus wat is de grootte in bytes van een string?
Nou het is vier of acht.
En de reden dat ik zeg vier of acht omdat het eigenlijk
afhankelijk van het systeem, Als u CS50 ide, char * is de grootte van een char
* Acht, het is een 64-bits systeem.
Elk adres in het geheugen is 64 bits lang.
Als u gebruik CS50 apparaat of het gebruik van een 32-bit machine,
en je hebt die term 32-bit gehoord machine, wat is een 32-bit machine?
Nou, het betekent alleen dat elke adres in het geheugen is 32 bits lang.
En dus 32 bits is vier bytes.
Dus een char * is vier of acht bytes afhankelijk van uw systeem.
En inderdaad alle data types, en een pointer naar gegevens
typt, omdat alle aanwijzingen zijn adressen, vier of acht bytes.
Dus laten we dit opnieuw diagram en laten we concluderen
deze video met een kleine oefening hier.
Dus hier is het schema we gebleven met aan het begin van de video.
Dus wat gebeurt er nu als ik zeg * pk = 35?
Dus wat betekent het als ik zeg, * pk = 35?
Neem een ​​tweede.
* pk.
In verband hier, * is dereference operator.
Dus toen de dereference operator wordt gebruikt,
we gaan naar het adres wees op door pk, en we veranderen wat we vinden.
Dus * pk = 35 effectief doet dit om de afbeelding.
Dus het is eigenlijk syntactisch identiek is aan die van de genoemde k = 35.
>> Nog een.
Als ik zeg int m, ik maak een nieuwe variabele genaamd m.
Een nieuwe doos, het is een groene doos, omdat het gaat om een ​​geheel getal te houden,
en het is gelabeld m.
Als ik zeg m = 4, heb ik een integer in die box.
Als we zeggen pk = & m, hoe werkt dit diagram verandering?
Pk = & m, heb je herinneren aan wat de & Operator doet of wordt genoemd?
Vergeet niet dat en een aantal variabele naam is het adres van een variabele naam.
Dus wat we zeggen is pk krijgt het adres van m.
En zo effectief wat er gebeurt de diagram is dat niet meer punten pk
k, maar wijst op m.
>> Weer pointers zijn zeer lastig om mee te werken
en ze nemen veel praktijk, maar omdat
van hun vermogen om u te laten om gegevens tussen functies passeren
en eigenlijk degenen wijzigingen van kracht,
krijgen van uw hoofd rond is echt belangrijk.
Het is waarschijnlijk de meest ingewikkelde onderwerp bespreken we in CS50,
maar de waarde die u krijgen van het gebruik pointers
veel zwaarder weegt dan de complicaties die afkomstig zijn van het leren van hen.
Dus ik wens u het beste van geluk leren over pointers.
Ik ben Doug Lloyd, dit is CS50.