[Powered by Google Translate] [Week 4, Vervolg]
[David J. Malan - Harvard University]
[Dit is CS50. - CS50.TV]
>> Dit is CS50, en dit is het einde van week 4.
Dus goed nieuws en slecht nieuws.
Geen lezing op maandag, geen enkel probleem stellen volgende week. [Studenten juichen]
Je gaat niet leuk vinden waar dit naartoe gaat.
Maar we hebben dit in plaats volgende week woensdag,
en er is ook conform de syllabus 1 Vrijdag lezing volgende week vrijdag, zodat we op schema blijven.
Maar alles wordt gefilmd zoals gewoonlijk, dus geen zorgen te maken.
>> En met betrekking tot 0 quiz wat we zullen doen in de richting van het einde week
wordt bericht op de homepage van de cursus cs50.net een uitleg
van wat voor soort verwachtingen die u moet hebben als het gaat om de eerste quiz.
In het algemeen zal het multiple choice, waar-onwaar, kort antwoord, korte codering problemen.
Je gaat niet te verwachten tot het equivalent te implementeren
van een probleem dat je zou zien op een PSET, waarvoor u een computer hebt
en een debugger en dergelijke, maar er zullen kleine codering problemen.
>> En inderdaad, de beste gids om een ​​gevoel van wat CS50 quizzen te krijgen zijn als
is naar cs50.net, ga naar de Quizzen link,
en zie je de afgelopen jaren ter waarde van quizzen.
Gewoon beseffen dat het curriculum niet altijd hetzelfde geweest door de jaren heen.
Soms voegen we, soms aftrekken,
dus als je ziet wat onderwerp op een van die oude quizzen
dat je geen idee wat het is het over hebben, het is of dat we bedekken
of dat we niet te bedekken.
Maar in de vorm van reviews, deze zondag, maandag en dinsdag
alsmede een cursus-brede beoordeling sessie op zondagavond -
tijd en locatie worden aangekondigd op de homepage van de cursus -
hebben jullie allemaal de kans om samen met het onderwijs de cursus de medemens
Het materiaal voor deze jaren, zowel in doorsnede en een volledige klasse
en die zal worden gefilmd zoals gewoonlijk ook.
>> Oke. Dus zonder verder oponthoud, een commentaar op pass / fail en voeg / drop.
Je hebt misschien gezien mijn aantekeningen gisteravond, en dit is eigenlijk gewoon wat extra geruststelling
dat als je onder die in het bijzonder minder comfortabel of ergens daar tussenin
en je voelt je net een beetje in over uw hoofd,
beseffen dat inderdaad heel normaal, en er is een ruime ondersteunende structuur op zijn plaats,
waarvan kantooruren van plan waren op het verbeteren van de meer per e-mail mijn laatste nacht,
en te beseffen dat een optie als pass / fail voor een klasse als deze
echt is bedoeld als een mechanisme om de rand opstijgen van een cursus als deze,
zodat weer als je de uitgaven die 10, 15, 20 uur
gewoon proberen om wat PSET de slag te gaan en je weet dat je er 90-95% van de wijze waarop
maar u niet kunt vinden wat verdomd insect, in een pass / fail-model dat is een soort van goed.
>> Het idee is dat met dit mechanisme kunt u vervolgens gericht gaan op uw andere psets
of slapen of wat het ook is dat je wilt scherpstellen.
Dus beseffen dat je hebt tot deze komende dinsdag - technisch de 5e maandag,
maar het is een vakantie, dus deze komende dinsdag - om te schakelen van goed / fout aan graded of vice versa.
En als je echt op de afgrond en denken uit te vallen in totaal,
gelieve me vangen na lezing of me een briefje te laten vallen.
We willen graag op zijn minst chatten voordat je een bod adieu.
Oke. Dus we begonnen met de opleiding wielen van de vorige keer.
In het bijzonder hebben we ons gericht op string.
String is iets dat aangegeven in de CS50 bibliotheek,
in het bijzonder in dat bestand met de naam cs50.h die we beginnen te kijken naar deze en volgende week.
Maar string is eigenlijk gewoon een vereenvoudiging van iets
dat is een beetje meer arcanely omschreven als char *.
Char we kennen. Het is gewoon een teken.
Maar * vanaf maandag aangeduid wat? >> [Student] Een aanwijzer.
Een pointer. En wat is een pointer? >> [Student] Een adres.
>> Het is als een adres, een plaats in het geheugen.
Wat is een adres of locatie of geheugen?
Nogmaals, we hebben allemaal laptops met een optreden of 2 gigabyte aan RAM-geheugen het meest waarschijnlijk deze dagen,
en dat betekent dat je een miljard of 2 miljard bytes waarde van het geheugen.
En het maakt niet echt uit wat het fysiek eruit ziet,
maar iets te geloven dat u alle kunt het nummer van de individuele bytes dat uw eigen laptop -
dit is byte 0, byte 1 is, dit byte 2 miljard -
en dat is precies wat een computer doet.
Wanneer u ruimte toewijzen voor een teken, bijvoorbeeld,
Het moet natuurlijk ergens wonen in het geheugen van uw computer,
en misschien is het bij byte nummer 12345,
en dat is ergens hier in het geheugen van uw computer.
En het adres dan van dat karakter is 12345.
>> Nu, in week 0 tot en met nu tot nu toe, hebben we niet echt iets kon schelen
waar in het geheugen dingen worden opgeslagen, omdat we meestal gebruik van symbolen,
variabelen en arrays om daadwerkelijk te krijgen op onze gegevens.
Maar vanaf maandag en des te meer nu, je bent nu gaat hebben
des te meer expressieve mogelijkheden met het schrijven van programma's
om echt te manipuleren van een computer geheugen maar je ziet passen,
voor zowel de goede doelen en slecht,
bugs zijn een veel voorkomende resultaat op dit punt in het leren van dit spul.
Maar wat betekent het eigenlijk om een ​​char * zijn?
Laten we terug gaan naar - en we komen terug naar Binky zoals beloofd vandaag.
Laten we naar een eenvoudig voorbeeld hier.
Laat me slaan dit bestand als compare.c, en laat mij slechts enkele template code hier te komen
zo zijn stdio.h, laat me ook mezelf geven omvatten cs50.h. Ik zal inzoomen daar.
Laat ik beginnen met het schrijven belangrijkste int, main (void), en nu wil ik iets als dit te doen:
printf ("Geef me een string:") en dan zal ik gebruik maken van string s wordt getString
om een ​​string te krijgen van de gebruiker, dan ga ik aan de gebruiker voor een ander te vragen.
("Geef me nog een string:") en ik ga om hen te vragen via getString om dat te krijgen.
Ik bel het t omdat t komt na s en s is een mooie naam voor een string als het is vrij generiek.
Dus GetString, en nu ik wil gewoon een sanity check te doen en ik ga zeggen
if (s == t) dan ga ik gewoon naar de gebruiker printf vertellen ("U getypt hetzelfde \ n");
anders ga ik het afdrukken van iets als ("Je typte iets anders! \ n")
of wat dan ook het vonnis zal zijn. Dus zoiets.
Dan zoals gewoonlijk, zal ik terug 0 die net betekende dat er niets ergs is gebeurd,
en ik ga om verder te gaan en en compileren uitvoeren van dit programma.
>> Maar op maandag liepen we dit programma,
en eigenlijk werd verteld dat HELLO HELLO niet is en afscheid is geen vaarwel.
Het gedrag dat we zagen was een beetje meer als dit.
Laat me gaan in mijn source directory, zoom in hier, en laten we het doen maken vergelijken.
Goed samengesteld. Laat me lopen te vergelijken. Geef me een string: HELLO.
Geef me nog een string: HELLO.
U hebt getypt iets anders!
Nou, laat me proberen iets eenvoudiger als 50, 50. U hebt getypt iets anders!
hi, hi. Dus duidelijk, is iets aan de hand hier.
Maar wat was de verklaring voor waarom?
Blijkbaar, lijn 12 is volledig disfunctioneel.
Wat is het fundamentele probleem hier? Ja. >> [Student] Het is het vergelijken van de adressen.
Ja, precies. Het is eigenlijk een vergelijking van de adressen
waarin HELLO HELLO en worden opgeslagen.
Het is niet het vergelijken van de letters HELLO opnieuw en opnieuw,
want wat er echt gebeurd is, al die tijd hebben we gebruik gemaakt van GetString -
Dit bord is weer onze computer het geheugen,
en laten we zeggen dat ik noem GetString na waarbij een variabele s.
Hoe ziet mijn geheugen eruit?
Laten we zeggen dat willekeurig is er zo uitziet. Het is een vierkant.
En vrijwel elke keer dat ik getekend heb een stukje van het geheugen op het scherm
als het 32 ​​bits Ik heb al getekend pleinen als deze, omdat inderdaad in het apparaat,
een pointer, een adres, is 32 bits. Het is hetzelfde als een int.
Dat kan variëren op basis computersysteem.
Degenen onder jullie die vaag bekend met het feit dat je Mac of pc is 64 bits,
dat geeft eigenlijk dat uw computer is 64-bits pointers gebruikt,
64-bit adressen, en een van de positieve kanten van die uw computers
kunnen veel meer RAM dan weleer.
Lang verhaal kort, terug in de dag dat computers alleen gebruikt 32 bits
naar adressen vertegenwoordigen, het grootste aantal bytes dat u zou kunnen vertegenwoordigen
in dat geval was wat als je 32 bits hebben?
Dus 4 miljard, gelijk, want 2 op de 32 is 4 miljard.
Dit aantal is terugkerende in de cursus.
>> Dus als je alleen maar 32 bits, het hoogste aantal dat u kunt rekenen op ongeveer 4 miljard.
Maar dat was een fundamentele beperking van computers tot een paar jaar geleden
want als je alleen zo hoog tellen als 4 miljard,
Het maakt niet uit of je koopt 8 gigabyte aan RAM-geheugen of zelfs 5 gigabyte aan RAM-geheugen;
kun je niet tellen zo hoog, dus het was nutteloos.
Je kon alleen toegang tot de eerste 3 of 4 gigabyte geheugen van uw computer.
Dat is minder een probleem nu, en je kunt kopen MacBook Pro's en Dells
met 8 gigabyte aan RAM-geheugen of zelfs meer van deze dagen.
Maar als ik toewijzen gewoon in dit programma een pointer, een pointer genaamd s,
Het kan er zo uitzien op het scherm, omdat we inderdaad moeten schillen terug deze laag.
Ik blijf zeggen string, maar vanaf maandag, string is echt char *,
het adres van wat karakter.
Dus laten we opstijgen dat de opleiding wiel, ook al zullen we blijven gebruiken GetString voor nu.
Dus ik heb verklaard s, en dit is een stuk van het geheugen, 32 bits.
Wat zit er in hier in het geheugen standaard? >> [Onverstaanbaar student reactie]
Wat is dat? >> [Student] Garbage. >> Garbage. Precies.
Als je de programmeur geen waarde in een variabele, die weet wat het is?
Soms heb je geluk te krijgen en het is 0, wat is een soort van een mooie, schone standaardwaarde,
maar zoals we zagen maandag, soms is het complete onzin,
een aantal echt grote positieve of negatieve getal dat vandaan kwam, waar?
Ja. >> [Student] De functie voor. >> Ja.
>> Vaak is de functie die werd aangeroepen voordat want vergeet niet,
als je functies in het geheugen bellen, ze nemen meer en meer ruimte van beneden naar boven,
en zodra de functie terugkeert, wordt dat geheugen hergebruikt
door de volgende kerel die wordt aangeroepen, wordt die met behulp van uw zelfde stukje van het geheugen.
En als je hebt links vuilnis er, eerdere waarden,
wij zou kunnen verwarren s als het hebben van een waarde wanneer we echt hebben er niet om het even wat.
Dus onze RAM op dit punt ziet er zo uit.
Nu op de rechterkant van de lijn 7 we bellen GetString,
die we al nu aan het doen voor weken, maar wat wordt getString eigenlijk aan het doen?
GetString geschreven door de CS50 personeel is een beetje intelligent
in dat zodra de gebruiker begint typen sleutels en hits Enter
GetString cijfers hoeveel toetsaanslagen heeft de gebruiker hit,
hoeveel tekens heb ik nodig om RAM-geheugen toe te wijzen voor.
En waar dat het RAM vandaan komt, wie weet?
Het is ergens in 2 van uw computer gigabyte of wat van het geheugen.
Maar laten we aannemen dat de computer ruimte voor het woord HELLO gevonden hier.
Het woord dat ik getypt was H-E-L-L-O.
En als we deze tekenen als een reeks tekens, kunnen we trekken het zo.
Maar ik moet 1 extra ding te doen. Wat hoort bij het einde van een string in C?
De nul-karakter, die we schrijven als \ 0.
Het is technisch gezien het getal 0, maar de backslash maakt het duidelijker
dat dit letterlijk het getal 0 het gehele getal 0;
het is bijvoorbeeld niet, quote-unquote 0 die u zou kunnen typen op het toetsenbord.
Dus dit is HELLO.
>> En wat hebben we gezegd op maandag dat een functie als GetString
eigenlijk terug al deze weken?
Het is niet terug te keren een string per se omdat dat niet echt een betekenis hebben
omdat strings bestaan ​​niet. Ze zijn een soort van een verzinsel van de CS50 bibliotheek.
Wat is echt een string, meer technisch? >> [Student] Het is het eerste teken.
Precies. Het is simpelweg het adres van het eerste teken dat de gebruiker intikt:
Dus als mijn woord HELLO het eindigt bij byte nummer 123 en vervolgens bij byte nummer 124,
125, 126, enzovoort, als ik gewoon mijn nummer bytes van 0 op maximaal,
wat echt GetString terugkeert is letterlijk het getal 123.
Dus wat wordt gezet in s is het nummer 123, niet de letter H, niet het woord HELLO,
gewoon het adres waar ik kan vinden van de eerste letter van HELLO.
Maar dat lijkt niet genoeg. Ik vroeg je om een ​​string, geen karakter.
Dus hoe kunnen we of de computer weet dat ELLO soort mee te gaan met de H?
Wat is het soort overeenkomst die we hebben? Ja.
[Student] Het blijft vertellen zelf wat meer tekens te zoeken. >> Precies.
>> Er is een mens-computer conventie waarbij wanneer u te maken met strijkers,
ook wel bekend nu als char sterren, hoeft u alleen maar om erachter te komen
waar het einde van elke snaar in het leven is door eigenlijk gewoon itereren over het met een for-lus,
een lus while, wat dan ook, zodat wanneer je het einde van de string
nu kun je afleiden van dat, oh, het hele woord was HELLO.
Degenen onder jullie met voorafgaande ervaring met programmeren zou kunnen weten in Java
u kunt gewoon bellen. lengte en in andere talen kunt u de lengte of soortgelijke bellen.
Dat komt omdat in veel talen, in het bijzonder wat de naam objectgeoriënteerde talen,
de lengte van iets is een soort van ingekapseld binnenkant van het stuk van de gegevens zelf,
graag we ingekapseld ID's en namen en huizen binnen van een student op maandag.
Maar C is veel lager niveau. Er zijn geen objecten of klassen, als je hebt gehoord die termen voor.
Alles wat je hebt is echt geheugenadressen.
Dus dit is een soort van de ouderwetse manier te vertegenwoordigen interessante datastructuren.
Je hebt een startwaarde, zoals het adres van het eerste teken
en dan gewoon een aantal willekeurige conventie dat iedereen het eens volgen.
Dus hoe is lengte van het touw uitgevoerd, hebben wij voor?
Strlen, strlen, die nu een aantal van jullie hebben een paar keer gebruikt. Het is vrij simpel, toch?
Het is net als 2 regels code.
Het is vrij veel een for-lus van een soort, misschien met een extra lokale variabele.
Maar strlen moet gewoon een pointer dan te nemen en op zoek naar \ 0 beginnen.
>> En zodra hij vaststelt, kan het terug het totaal aantal stappen dat is genomen in de snaar.
Dus we kunnen afleiden uit dit wat er op de volgende.
Stel dan verklaar ik t zoals ik heb gedaan in de lijn 10.
Dit is een vuilnis waarde. Wie weet in het begin?
Maar aan de rechterkant van de lijn van 10 Ik bel getString weer.
Wie weet waar dit eindigt?
Laten we willekeurig zeggen dat het besturingssysteem ruimte voor het weg hier gevonden.
Ik ben toevallig toevallig typen H-E-L-L-O weer,
en dus kunnen we trekken het zelfde soort beeld.
Maar het feit dat ik opnieuw getekend deze foto heb is een bewuste
want dat is een ander HELLO dan deze.
Hier kan de locatie 456, is 457, enzovoort.
Dus wat wordt gezet waar het vraagteken ooit was?
In dit geval 456.
We plukken van deze nummers willekeurig, want echt na vandaag
we gaan niet zo veel schelen wat het adres van alles is.
Alles wat we zorg over is dat we kunnen achterhalen van het adres van een stukje van gegevens zoals HELLO.
>> Dus echt wat de meeste mensen doen in de informatica als het over geheugenadressen
en praten over pointers specifiek,
in plaats van de moeite uitzoeken 123 - who cares waar dit spul eigenlijk is,
we weten dat het op een bepaald numeriek adres -
vereenvoudigen we de wereld en gewoon zeggen dat s wijst naar dat personage
en t wijst naar dat personage.
En het feit dat het een pijl is heel bewust
omdat nu letterlijk s wijst naar H t en wijst naar de andere H
omdat aan het einde van de dag, maakt het niet uit welke het adres,
maar het maakt wel uit dat we de mogelijkheid om dat adres te drukken met een stuk code te hebben.
We hebben niet echt gemanipuleerd deze adressen gewoon nog niet
dus we zullen zien waar we kunnen tussenbeide komen en sorteren van dingen doen met pointers,
maar voor nu in lijn 12 letterlijk welke waarden we vergelijken
Volgens dit verhaal in de lijn 12?
We zeggen is 123 gelijk gelijk aan 456? En dat is zeker niet het geval.
En zelfs conceptueel, deze pointer is zeker niet hetzelfde als dit
omdat je belde getString twee keer, en GetString niet proberen te zijn super slim,
het niet proberen te realiseren, o, u HELLO getypt 5 minuten geleden;
laat me je dezelfde pointer als ik je gaf voor,
het kent gewoon een nieuwe brok van het geheugen elke keer dat u het noemen.
>> Dus hoe kunnen we dit probleem oplossen?
Als hoger niveau wil ik de snaren HELLO HELLO en vergelijken -
Kan me niet schelen over de pointers - hoe ga ik over het beantwoorden van de vraag,
heeft de gebruiker typt u het zelfde ding? Wat is nodig hier? Ja.
[Student] Gebruik een functie. >> Ik kan een functie uit de doos.
Ik kan een functie genaamd strcmp, s-t-r-c-m-p,
alleen de verkorte versie van te zeggen snaar te vergelijken.
En als we naar bijvoorbeeld Vergelijk 2, die tot handouts vandaag
Ik doe precies dat.
Ik bleef alles hetzelfde van lijn 1 naar beneden tot 26 of zo,
en nu merk dit deel is net een klein beetje veranderd.
Laten we negeren lijn 28 voor een moment en alleen richten op dit ene.
Wat hebben we zeggen maandag dat str compare doet?
Het behandelt het proces waarbij 2 pointers, s en t in dit geval
soort van vrijwel zetten de vinger op die 2 letters,
en wat het moet doen, is zoiets als een while-lus of een for-lus,
en het zegt zijn deze hetzelfde? Als dat zo is, beweegt de vingers of de wijzers vooruit.
Zijn deze hetzelfde, deze hetzelfde, deze dezelfde,
deze dezelfde, deze hetzelfde? En ooh, ik ben aan het eind van de string op zowel s en t.
Ik heb niet gevonden geen tegenstrijdigheden. Ja, deze snaren zijn hetzelfde.
En wat betekent str vergelijken terugkeer als 2 strings hetzelfde zijn, blijkbaar? Zero.
Dus 0 is goed in dit geval, want als het weer -1 of +1,
dat betekent dat het gewoon toevallig komen voordat t alfabetisch of na t.
En waarom zou dat nuttig zijn om een ​​functie die u vertelt welke snaar komt eerder hebben
of na in een woordenboek?
[Student] met zoeken. >> Zoeken en sorteren.
>> Dus je kan dingen doen zoals binary search of bubble sort of samenvoegen sorteren
waar je moet dingen vergelijken.
Tot nu toe hebben we soort van snijden sommige bochten en alleen gesproken over het sorteren
in het kader van de nummers, want het is leuk en makkelijk om te praten over,
maar je kan zeker vergelijken strings, appel en banaan,
want als appel bekend is komen voor bananen evenzo
kunt u naar strings rond in het geheugen, net als Rob deed met merge sort in de video
en we hebben hier op het podium met selectie sorteren, insertion sort, en bubble sort.
Dus waar anders kunnen we dit? Laten we proberen dit.
Laten we soort van vergeten dat les voor een ogenblik en probeer nu en kopieer 1.c het volgende doen.
In lijn 21 Ik zeg print iets,
dan ben ik het krijgen van een string van de gebruiker,
dan ben ik het controleren van deze.
We hebben niet echt gekregen in deze gewoonte nog niet, maar laten we nu dit te doen.
Eigenlijk Laten schil terug deze laag. Dit is echt char *. Deze man is echt char *.
Dus wat betekent het om te controleren of s == NULL?
Het blijkt dat wanneer u belt een functie als GetString
of meer in het algemeen gewoon vragen een computer om u wat geheugen,
iets mis kan gaan.
Je zou wel gek zijn en vraag de computer voor een terabyte aan geheugen
door te vragen voor miljarden bytes van het geheugen dat gewoon niet bestaan ​​in de computer,
maar GetString en andere functies nodig hebben of andere manier van schreeuwen tegen je
als je gevraagd hebt te veel.
En de manier waarop GetString dit doet is als u hebben gevraagd om meer geheugen
dan er beschikbaar is in de computer, zelfs als dat is super, super lage waarschijnlijkheid
omdat niemand van ons gaan een biljoen tekens te typen en vervolgens op Enter te raken,
maar kleine kans maar het kan zijn, ik wil nog steeds om te controleren of het in het geval,
en de speciale waarde die GetString, antwoord, en andere functies terug
als er iets mis is gegaan is NULL in hoofdletters.
>> En wat is NULL? NULL gewoon zo gebeurt te vertegenwoordigen een pointer. Het is het geheugen adres 0.
De wereld besloten dat willekeurig, als dit mijn computer het geheugen - weet je wat? -
we gaan slechts 1 byte van het geheugen elke computer te stelen, en dit is meetpunt 0.
We gaan om het een bijnaam van NULL, en we gaan beloven
dat zullen we nooit echt daar te zetten echte gegevens
omdat we gewoon willekeurig behoefte aan een speciale waarde, 0, aka NULL,
zodat wij schreeuwen tegen gebruikers als er iets misgaat.
Anders zou je misschien niet weet is 0 betekent hier zet iets
of betekent het iets mis gegaan?
We moeten allemaal over eens dat NULL betekent niets was teruggekeerd,
geen werkelijke adres was teruggekeerd.
Nu, hier ben ik gewoon de aanneming van mijn menselijke conventie van I return 1 van de belangrijkste
als er iets misgaat.
Dat komt omdat de belangrijkste terugkeer van conventie is om terug te keren 0 als goed,
1 of een andere waarde als de slechte.
Maar GetString en elke functie die zich bezighoudt in het geheugen terug NULL als er iets ergs gaat.
>> Oke. Dus helaas, lijn 27, super simpel het ook is, niet volledig te kopiëren de string.
Waarom? We zien dit als volgt.
Ik ben beweren in de lijn 27 tot en met het maken van een kopie van s en noemde het t.
Dus ik ben niet de gebruiker vragen om 2 strings dit keer, ik zeg alleen dat de waarde in s
moeten worden gebracht in t ook.
Dus nu gewoon om te laten zien hoe gebroken is, in lijn 29 verder wat doe ik?
Eerst Ik controleer of de lengte van t groter is dan 0.
Er is een stukje tekst daar. De gebruiker heeft ingevoerd iets binnen
Wat is lijn 32 doet, blijkbaar?
[Onverstaanbaar student reactie] >> Klopt. U kunt soort afleiden uit wat ik zei dat het aan het doen is.
Maar technisch gezien, is wat dit doet? t [0] staat voor wat?
[Student] De nulde karakter. >> [Malan] De nulde karakter.
Of, meer mensachtige, het eerste teken in t, wat dat ook is, H misschien in dit geval.
En toupper doet wat het zegt. Het speelt in de nulde karakter van t en het verandert het.
Dus dit betekent dat neemt de nulde karakter van t, maken het hoofdletters,
en plaats deze weer in dezelfde locatie.
Dus als ik typ hallo in kleine letters, dit moet de kleine letters h veranderen in een hoofdletter H.
Maar het probleem is dat in de regels 35 en 36 wat ik ga doen is uit te printen voor ons s en t.
En wat is jouw gevoel?
Wat moet ik eigenlijk aan de hand om te zien of ik getypt in hallo in alle kleine letters?
Wat gaat er om te drukken? >> [Onverstaanbaar student reactie] >> Wat is dat?
[Student] Big H en de rest klein. >> De grote H en de rest klein voor die, s of t?
[Student] Beide. >> Beide. Precies. Dus laten we eens kijken wat er aan de hand is.
>> Laat me gaan, en slaat deze. Dit is kopie1, dus zorg kopie1. Oke.
Zoomen Laat me ga je gang en lopen kopie1, Enter, Zeg iets: hello in kleine letters.
Het geactiveerde de kopie, maar blijkbaar geactiveerd de oorspronkelijke als goed,
want wat er nu gebeurt in dit verhaal?
In lijn 27 Ik niet echt lijken te kopiëren van de string,
maar zelfs al zou je intuïtief gehoopt dat het geval te zijn,
Als u denkt over dit beeld, wat echt heb ik gedaan?
Helft van het beeld hetzelfde.
Dus laten we roll terug in de tijd, zodat t nog niet bestaat in het verhaal.
S kan bestaan ​​in het verhaal, maar laten we kleine letters hallo deze tijd.
Dus laat me vast wat ik eigenlijk getypt inch
In dit geval hebben we hier h-e-l-l-o.
We zullen het te tekenen als een reeks tekens, hier zet mijn scheidingslijnen en mijn \ 0.
Dus dit is waar we zijn, zodra lijn 1 tot en met 24-ish, geven of te nemen, hebben uitgevoerd.
Dit is het beeld van mijn geheugen.
Als ik bij lijn 27, wat gebeurt er?
Net als vroeger, krijg ik een pointer, die ik zal trekken dit plein.
Het heet t. En wat is de waarde standaard? Wie weet? Sommige vuilnis waarde.
>> Dus ik zal abstract dat weg als een vraagteken.
En zodra de rechterzijde van lijn 27 wordt uitgevoerd, ben ik zet binnenkant van t?
Hetzelfde wat in s.
Dus als we een ogenblik te verwijderen deze abstractie van de pijl en wij zeggen,
oh, dit is het geheugen belasting-adres 123, als je zegt t krijgt s, puntkomma,
je letterlijk zetten 123 hier.
Als we nu soort weer te vereenvoudigen onze wereld met foto's,
wat je hebt echt gedaan is gewoon voegde een andere pijl op uw wereld
dat is gericht van t tot exact dezelfde string.
Dus toen in de lijn 31 en 32 ik eigenlijk gaan over het veranderen van t [0],
wat is t [0] blijkbaar synoniem met nu? s [0]
Dus dat is alles wat er gebeurt.
En hoewel dit soort voelt een beetje laag niveau en geheimzinnige
en dit soort voelt misschien intuïtief moet dit gewoon hebben gewerkt -
Ik heb kopieën van de dingen voor en het is gewoon werkte -
als je echt nadenken over wat een string is echt, het is een char *.
Nou, wat is dat? Het is het adres van een aantal karakter.
Dan misschien is het zinvoller dat wanneer je probeert om iets te doen
super schijnbaar eenvoudige als dit, alles wat je doet is het kopiëren van een geheugenadres.
U bent niet echt iets te doen met de string zelf.
Dus zelfs als je geen idee hebt hoe je een oplossing voor dit probleem in de code,
hoog niveau, conceptueel, wat we moeten doen om ervoor te zorgen ta gewaarmerkt afschrift van s, blijkbaar?
Ja. >> [Student] Geef het een nieuwe locatie? >> Precies.
>> Wij moeten t een gloednieuwe locatie.
We moeten een of andere manier een wereld creëren waarin we een nieuwe brok van het geheugen,
die alleen voor de duidelijkheid zal ik trek net onder deze, maar het is niet nodig om daar te zijn.
Maar het moet even groot zijn, dus ik zal trekken deze verticale lijnen op dezelfde plaats.
Het is prima als dit allemaal afval in eerste instantie. Wie weet wat er was?
Maar stap 1 zal me moeten worden geven zoveel geheugen als ik nodig heb
om een ​​kopie van hallo passen, dan erachter te komen hoe je de h hier te kopiëren, de e hier,
de hier l enzovoort.
Maar dit al moet je een beetje voor de hand liggend, zelfs als sommige van de details zijn nog abstract.
Om deze string te kopiëren naar deze, het is gewoon een for-lus of een while-lus
of iets waar je hebt des te meer vertrouwd.
Dus laten we dit proberen. Laat me gaan in copy2.c.
In copy2.c hebben we bijna hetzelfde programma met uitzondering van lijn 27.
Het ziet er een beetje ingewikkeld, maar als we af te breken stuk voor stuk,
de linkerkant is hetzelfde.
Char * t schept dit ding in het geheugen, zij het met een vraagteken
want we hebben geen idee wat er standaard.
Aan de rechterkant hebben we nu de invoering van een nieuwe functie, malloc,
voor geheugen toe te wijzen, geef mij het geheugen,
en het duurt blijkbaar hoeveel argumenten, hoeveel dingen tussen haakjes?
Ik hoorde murmureringen van 1 en 2, maar het is gewoon 1.
Er is geen komma, wat betekent dat er slechts 1 ding tussen de haakjes.
Ook al is er andere haakjes, laat me benadrukken
wat er in de buitenste haakjes, en het is deze uitdrukking:
(Strlen (s) + 1) * sizeof (char).
Dus als we echt denken dat dit door middel van, is dit woord geef me de lengte van s.
Waarom ben ik, hoewel, het toevoegen van 1 op de lengte? >> [Onverstaanbaar student reactie]
Precies. We hebben ruimte nodig voor deze man bij de staart, het zesde teken dat er geen Engels betekenis heeft
maar heeft wel speciale programmatische betekenis.
>> Dus we moeten een + 1 voor dat, omdat strlen rendement van de menselijke verwachting van lengte,
hallo of 5, is het niet geven u de extra nul karakter.
Dus ik handmatig toe te voegen dit met + 1.
En dan dit, * grootte van de (char), hebben we dit niet eerder gezien.
Dit technisch functie.
Het is een bijzonder sleutelwoord dat precies vertelt u wat de grootte is van een aantal data type op een computer
want in werkelijkheid, sommige van ons hebben 32-bits computers.
Ik heb een mooie oude computer thuis, en het alleen gebruik maakt van 32-bits te vertegenwoordigen pointers.
En dus als ik dat deed grootte van een data type, is het misschien 32 bits.
Maar als ik met behulp van mijn nieuwe, fraaie computer, zou ik terug te krijgen een waarde van 64 bits
voor iets als een adres.
Dus in dit geval gewoon tot super veilig, we gaan niet naar de harde code iets als -
goed, wat is de grootte van een char op basis van wat we tot nu toe gezegd?
We hebben vrij veel gezegd verbaal dat het 1 byte, en dat is vrij veel waar over de gehele linie.
Maar nogmaals, veronderstellingen hebben de neiging om slecht te zijn.
Ze leiden tot buggy software als iemand op uw software te gebruiken op manieren die je niet van plan was.
Dus laten we abstracte dit weg en gewoon meer in het algemeen zeggen
Ik heb dit vele delen van het geheugen
en elk blok geheugen moet overeenkomen met de grootte van een karakter,
die in feite gelijk aan 1 in dit geval, maar het is een generieke manier van schrijven.
Dus als het woord hallo, hoeveel bytes malloc blijkbaar toe te wijzen voor hello?
[Student] Zes. >> Zes. Precies zo veel als we vraagtekens op het scherm te hebben.
En neem dan een gok nu op basis van uw kennis van GetString
wat doet malloc waarschijnlijk terug? >> [Student] Een adres.
Een adres van wat? Van de eerste deel van het geheugen.
>> We hebben geen idee wat er is, omdat een andere functie
kon worden gebruikt dit geheugen eerder.
Maar malloc zoals GetString, geeft het adres van de eerste byte van het geheugen
dat het gereserveerd voor u.
Het is echter wat het niet doet in te vullen dit leeg met een backslash null karakter
want het blijkt dat je kunt gebruiken malloc om iets toe te wijzen: ints, strings, arrays,
drijvers, student structuren.
U kunt gebruik maken van malloc volledig generiek.
Het maakt niet uit of moet weten wat je geheugen toewijzen voor.
Dus het zou voorbarig zijn om malloc om een ​​\ 0 zetten
aan het einde van elk deel van het geheugen het geeft u
omdat dit \ 0 ding is gewoon een conventie voor strijkers.
Het is niet gebruikt voor ints, het niet wordt gebruikt voor praalwagens, het is niet gebruikt voor studenten.
En dus is de gotcha met malloc is dat de last volledig op u de programmeur
om te onthouden hoeveel bytes u toegewezen en niet om ooit een te gebruiken voor lus
of een while loop en ga voorbij de grens van het stuk van het geheugen die je hebt gekregen.
Anders gezegd, zodra je het geheugen toe te wijzen,
je kunt niet het besturingssysteem vraagt, oh, door de manier, hoe groot van een stuk van het geheugen was dit?
Het is helemaal aan jou om te onthouden als u die waarde.
>> Dus laten we eens kijken hoe ik verder met dit geheugen te gebruiken.
In lijn 28 en 29 waarom doe ik dit?
Gewoon totaal sanity check.
Gewoon voor het geval er iets mis ging, vraag ik om wat gekke hoeveelheid geheugen
of ik heb zo veel dingen die op de computer dat er gewoon niet genoeg geheugen,
zoiets, ik in ieder geval wilt controleren op null.
In werkelijkheid zullen de meeste computers geeft je de illusie dat elk programma
kan het geheel van uw RAM-geheugen te gebruiken,
maar zelfs dan, als de gebruiker typt in sommige gekke lange reeks misschien omdat ze een slechterik
en ze eigenlijk proberen om uw programma of hack crashen in het,
u wilt in ieder geval controleer de return waarde van malloc en of het gelijk is aan null.
En als dat zo is, laten we gewoon stoppen nu, want ik weet niet wat te doen in dat geval.
Hoe kopieer ik de string? Er zijn een paar manieren om dit te doen.
Er zijn str kopiëren van functies in C, maar het is super eenvoudig voor ons om dit te doen op de ouderwetse manier.
>> Laat me eerst uit te zoeken wat de lengte van s is.
Ik had dit in de lus, maar in plaats daarvan ik zet ze gewoon hier voor de duidelijkheid.
Zo n slaat nu de lengte van de oorspronkelijke string, die blijkbaar 5.
Dan in mijn for loop ik itereren van 0 op maximaal n,
en elke iteratie Ik zet s [i] binnenzijde van t [i].
Dus dat is wat ik impliciet met mijn 2 vingers wijzend naar de snaren eerder.
Omdat deze for loop als deze, ga ik te kopiëren h in hier,
e in hier in l hier omdat dit s, is t.
En dan tot slot, in lijn 35 waarom doe ik dit?
Ik moet ervoor zorgen dat ik de string t einde.
En ik deed het op deze manier te worden super expliciet.
Maar stel, iemand, als je zou kunnen, een andere manier om dit te doen.
Ik heb het niet echt nodig lijn 35. Er is een andere manier om dit te doen.
Ja. >> [Onverstaanbaar student reactie] >> Zeg het luider.
[Student] Minder dan of gelijk aan. >> Precies.
We zeggen minder dan of gelijk aan n, die in het algemeen slecht was
omdat bijna altijd wanneer wij gaan op naar een die gelijk is aan het ding we rekenen
gaan we een stap te ver.
Maar vergeet niet, we hebben hoeveel bytes toe te wijzen?
We toegewezen strlen van s, dus 5 + 1 voor een totaal van 6.
Dus in dit geval kunnen we iets doen als dit
zodat we het kopiëren van niet alleen de gedag, maar ook de \ 0 helemaal aan het eind.
Als alternatief kunnen we gebruik maken van een functie genaamd str kopiëren, strcpy,
maar dat zou niet zo leuk.
Maar dat is alles wat het doet onder de kap.
Dan tot slot, doen we hetzelfde als voorheen.
Ik kapitaliseren t en toen ik beweer dat de originele ziet er zo uit en de kopie er zo.
Dus laten we nu proberen. Laat me gaan hier. Maak COPY2. We zoomen in en uit te voeren COPY2.
Ik ga in hallo typen in kleine letters, en inderdaad ik kleine letters gedag te krijgen als het origineel
maar het kapitaal Hallo voor de kopie.
Maar ik ben niet alleen nog niet klaar. Ik moet een laatste ding doen hier.
46 en 47 is duidelijk het vrijmaken van geheugen, maar wat betekent dat eigenlijk?
Wat doe ik, denk je, door te bellen naar lijn 46 en lijn 47?
Welk effect heeft dat? Ja.
[Onverstaanbaar student reactie] >> Precies.
>> U bent vertel het besturingssysteem, hey, bedankt voor dit geheugen.
U kunt nu gebruik maken van het voor iemand anders.
En hier is een perfect voorbeeld van vuilnis waarden.
Ik heb net gebruikt dit geheugen op te schrijven het woord Hallo in 2 plaatsen,
hier, hier, hier en hier.
Dit is dus h-e-l-l-o-\ 0.
Maar dan noem ik lijn 46 en lijn 47, en weet je wat er gebeurt op het gebied van de foto?
Eigenlijk, wacht, de foto is de oude.
Zodra we de kopie, is deze man eigenlijk wijst hier,
dus laten we verwijderen van de nummers en slechts abstracte weer weg als onze pijlen.
Wat gebeurt er in deze foto als ik bel gratis?
[Onverstaanbaar student reactie] >> Zelfs niet.
Als ik bel gratis s en t - soort van een strikvraag - dit beeld niet veranderen helemaal
want bellen s en bellen t vertelt alleen het besturingssysteem,
hey, kunt u weer gebruik maken van dit geheugen, maar het verandert niets aan deze op null
of een speciaal teken, is het niet veranderen,
Het verandert niets aan de h of de e of de l of de l of de o in een van beide plaats om iets anders.
In termen van het beeld, zodra u gratis, verandert er niets noemen.
En daarin ligt de oorsprong van vuilnis waarden, want als ik dan later in dit programma
die vragen het besturingssysteem voor meer geheugen met GetString of malloc of iets dergelijks
en het besturingssysteem zegt zeker, ik 12 bytes van het geheugen net bevrijd uit maximaal,
gebruik maken van deze, wat ga je worden overhandigd?
Je gaat worden ingeleverd een stuk van het geheugen dat we zouden in het algemeen trekken
met vraagtekens, maar wat zijn die vraagtekens?
Zij zich bevinden h-e-l-l-o, h-e-l-l-o.
Dit zijn onze nieuwe vuilnis waarden zodra je vrij te maken dat het geheugen.
>> Er is een echte wereld implicatie hier ook.
Dit gebeurt te maken met RAM-geheugen, maar uw computers
eigenlijk hetzelfde doen met schijf.
We praten over dit in het bijzonder met het toekomstig probleem set die zich richt op forensisch onderzoek.
Maar wat gebeurt er eigenlijk als je een aantal gevoelige financiële bestand op uw bureaublad
of een schetsmatige JPEG en u sleept het in uw prullenbak,
wat er gebeurt als je sleep deze naar de prullenbak of de prullenbak?
Je wist wat ik het over had. [Gelach]
Wat gebeurt er als je hebt gesleept dat bewijs in de prullenbak of prullenmand?
[Onverstaanbaar student reactie]
Nou ja, zo voorzichtig. Wat gebeurt er als je dat doet?
Het korte antwoord is niets, toch?
Sketchy of gevoelige bestanden nog gewoon zitten ergens op uw harde schijf.
De meesten van ons op zijn minst hebben geleerd op de harde manier dat je nodig hebt om uw prullenbak legen
of uw prullenbak om daadwerkelijk verwijderen van bestanden.
En inderdaad, als je rechts klikt of Ctrl-klik op uw prullenbak
of kies Bestand, Prullenbak legen of wat dan ook
en je eigenlijk het legen van de prullenbak of prullenmand, wat er eigenlijk gebeurt er dan met deze foto?
Meer niets. Zodat er niets gebeurt eigenlijk op de harde schijf.
>> En als we gewoon tijdelijk afdwalen en schrijf - Ik zal gewoon gebruik maken van de achterkant van deze.
Dus nu het verhaal verandert van RAM-geheugen, dat is waar programma's bestaan
terwijl je draait ze, op de harde schijf, dat is waar ze zijn opgeslagen op lange termijn
zelfs wanneer de stroom uitvalt, voor nu - en we zullen terugkeren naar dit in de toekomst -
laten we gewoon doen alsof dit de harde schijf binnenkant van uw computer vertegenwoordigt
want in de dag dat ze vroeger ronde schijven, net als diskettes.
Dus als je een aantal gevoelige Excel-bestand, kan het maken van deze brok van het geheugen
op schijf van uw computer, en ik ben gewoon tekenen dezelfde willekeurige 1s en 0s.
Wanneer u het bestand als dat slepen naar uw prullenbak of prullenbak,
letterlijk gebeurt er niets omdat Apple en Microsoft hebben net besloten
de prullenbak en de prullenbak is eigenlijk gewoon een tijdelijke plaatsaanduiding.
Misschien uiteindelijk de OS zal legen het voor u, maar meestal is het niets doet,
in ieder geval totdat je echt weinig ruimte.
>> Echter, als je naar lege prullenbak of lege prullenbak,
op dezelfde wijze, gebeurt er niets om deze foto.
Alles wat er gebeurt is elders op de computer, is er een soort van tafel.
Het is een soort van als een klein spiekbriefje dat zegt dat, laten we zeggen, RESUME.DOC,
zodat uw CV in een Microsoft Word-bestand dat wordt gebruikt om te wonen op de locatie 123 op de harde schijf,
niet in het geheugen en niet in het RAM, maar op de harde schijf,
en uw schetsmatige JPEG woont op 456, en uw Excel-bestand woont op 789 of waar dan ook.
Wanneer u bestanden verwijdert door daadwerkelijk het legen van de prullenbak of de prullenbak,
deze afbeelding verandert niet. De 0s en 1s op uw harde schijf niet overal te gaan.
Maar deze tabel, deze kleine database van soorten, verandert wel.
Bij het verwijderen van uw CV, het is alsof het bestand is verwijderd in zekere zin,
maar alle computer doet is vergeten waar dat ding leeft op uw harde schijf.
De 0s en 1s dat je CV of een van deze andere bestanden samen te stellen zijn nog steeds intact.
>> Dus als je dit deed per ongeluk, er is nog steeds een niet-nul kans
dat je kunt herstellen van uw gegevens met behulp van Norton Utilities of een commerciële software
waarvan het doel in het leven is het vinden van 0s en 1s die soort wees zijn geworden,
hier vergeten maar liet hier, zodat je terug kunt krijgen van uw gegevens.
Of forensische onderzoekers bij de politie of FBI zou eigenlijk nemen een harde schijf
en eigenlijk op zoek naar patronen van 0s en 1s die er uitzien als JPEG's, lijken Excel-bestanden,
en herstellen ze op die manier, zelfs als de computer is ze daar vergeten.
Dus de enige manier echt om gegevens te verwijderen, zoals we zullen bespreken in de toekomst,
is te schrobben of vegen het bestand of de harde schijf door -
Je kunt niet echt te ontdoen van de 0s en 1s
want anders zou je beginnen met een gigabyte harde schijf
en je zou eindigen met een megabyte harde schijf als je constant het verwijderen was,
letterlijk, 0s en 1s.
Dus wat zou je doen als je echt wilde je sporen uit te wissen
en het fundamentele probleem is dat er nog steeds 0s en 1s op de schijf?
Ik zie iemand gebarend dat je fysiek zou het apparaat breken. Dat zal werken.
[Gelach] Maar als dat is een soort van een dure oplossing, wat zou het zijn meer redelijk?
Ja. >> [Student] Overschrijven hen. >> Overschrijven ze met wat? >> [Student] Overige gegevens.
Andere gegevens. U kunt uw schijf gewoon overschrijven met 0s of 1s of alle 0s, alle 1s.
>> En dat is inderdaad wat sommige van de software doet.
U kunt kopen software of zelfs gratis software,
en zelfs ingebouwd in Mac OS deze dagen, minder in Windows,
is de mogelijkheid om veilig te wissen.
Eigenlijk, als je wilt draaien allemaal naar huis vandaag de dag als je een Mac hebt en doen dit,
als je hebt een paar dingen in je prullenbak, kunt u Leeg prullenmand veilig,
die doet precies dat.
In plaats van alleen te wissen bestanden hier, is het niet wist de 0s en 1s hier,
eerder verandert gewoon allemaal, bijvoorbeeld om 0s en dot, dot, dot.
Dus een van uw toekomstige psets daadwerkelijk zijn om dat doel gegevens te herstellen -
foto's die we hebben genomen van mensen, plaatsen en dingen op de campus
waarvoor we maken een forensisch beeld van het geheugen van een digitale camera,
dat is precies hetzelfde idee - en u zult moeten worden uitgedaagd om daadwerkelijk vinden
de patronen die JPEG-bestanden vertegenwoordigen op uw harde schijf,
net als dat oud-student van wie e-mail las ik een paar weken geleden deed
naar zijn zus foto's te herstellen.
Waarom gaan we niet hier nemen een 5-minuten pauze, en we zullen hergroeperen met meer geheugen.
Dus hier is waar de dingen een beetje breinbrekende, maar dit is een zeer krachtige stap
naar het begrijpen van dit des te meer.
Hier is een programma genaamd pointers.c.
Het is een van sample vandaag code.
Merk op dat in de eerste paar regels, 19 tot en met 22, alles wat we aan het doen bent is zoiets als GetString
en terug te keren van een adres, op te slaan in s.
Voortaan voor PSET zelfs 3 als je wilt, maar PSET 4 en op
waar u kunt beginnen met deze opleiding wielen van uzelf te maken,
is er geen reden om te doen alsof dat strings meer bestaat.
Het is zeker goed om gewoon beginnen met te zeggen char *.
>> Even terzijde, in online referenties en in boeken kunt u vaak zien de ster naast de variabele.
Je zou zelfs ruimte rond beide zijden van het.
Al deze zijn functioneel correct.
Voorlopig echter, zullen we standaardiseren op deze aanpak te maken super helder
dat char * is hetzelfde als zeggen karakter pointer.
Dat is het gegevenstype.
En vervolgens de naam van de variabele s in dit geval.
Dus we hebben gekregen een string en we hebben noemde het s.
En dan hier beneden ziet dat ik eigenlijk een beetje bedrog doen.
Dit is de zogenaamde pointers, dat is een soort van super eenvoudig.
Het betekent gewoon toe te voegen en getallen aftrekken tot pointers.
Maar dit werkt eigenlijk.
Dit programma drukt blijkbaar de string s 1 karakter per regel zodanig dat het eindresultaat -
Zodat we kunnen bederven waar dit gaat, zorg pointers, rennen pointers, laat me zoomen
Laat me nu typ in iets als HELLO en op Enter drukt
en het drukt een karakter per regel.
Tot een tweede geleden, zouden we dit gedaan hebben met vierkante haken notatie.
We zouden een for-lus en we zouden doen printf van s [i] en we zouden dat doen opnieuw en opnieuw en opnieuw
een backslash n aan het eind van elke regel.
Maar dit programma is anders. Dit programma wordt gebruikt, letterlijk, rekenen.
Dus wat is hier aan de hand?
Allereerst voordat deze lus nog uitgevoerd, wat, om duidelijk is eigenlijk s?
S? >> [Student] Een adres. >> Een adres.
>> En het is het adres van, bij hello, het eerste teken in dat woord, dat h.
Dus s is in dit voorbeeld, het adres van h.
Dus wat betekent het om het doen + i?
Nou, ik begint bij 0 in deze for-lus. Dat hebben we gedaan vele malen.
Ik zal gaan tot de lengte van de tekenreeks, blijkbaar.
Dus op de eerste iteratie van deze lus, i is natuurlijk 0.
Dus deze uitdrukking zegt s + i - in plaats van, s +0, dat is natuurlijk gewoon s.
Dus wat is * s hier?
Nu zijn we met behulp van de ster in een iets andere manier.
Laat me gaan en zich te ontdoen van t omdat we uitgepraat over t en kopieën van s.
Nu we willen gewoon een verhaal met s vertellen.
En dus op dit moment, na type string, ziet onze wereld er heel leuk deed voor
met alleen s opslaan van het adres van h en meer in het algemeen te wijzen op de string hello.
Als ik nu doen een regel als * (s + i), laten we dit uit te proberen.
Dus * (s + i). Laat me vereenvoudigen dit want dit is 0, dus dit is * (s +0).
Nou, wacht eens even. Nog verder te vereenvoudigen. Dit is * (s).
Nou, nu de haakjes zijn een beetje dom, dus laten we nu gewoon doen * s.
Dus in de eerste iteratie van deze lus, die lijn die is gemarkeerd, 26,
is vrij veel overeen met het afdrukken van dit.
Wat is het gegevenstype van * s?
In dit verband, omdat de ster toevallig naast de s zelf,
maar meer in het bijzonder, omdat we niet langer verklaren s,
we zijn niet een variabele meer het creëren, is er geen melding gemaakt van char * in lijn 26,
Er is geen melding gemaakt van het trefwoord string, zijn we alleen met behulp van een variabele genaamd s,
Het blijkt nu de ster heeft iets anders en toegegeven,, verwarrend betekenis.
* S betekent hier naar het adres in s en print alles wat er is.
Dus s hier is, * s is - soort van Chutes en Ladders, volg de pijl - hier.
Dit is dus * s.
>> Dus wat wordt afgedrukt op de eerste iteratie van die lus in de lijn 26?
Print ik% c, dat is de standaard pagina voor een karakter,
dan is een \ n voor een nieuwe lijn. * (S + i) waarbij i 0 is juist dit.
Dus wat char plaats ik in voor% c? H.
In de volgende iteratie van de lus - kun je waarschijnlijk zien waar dit naartoe gaat -
de volgende iteratie i is natuurlijk 1, dat betekent dus s +1,
en dan nu heb ik hoef de haakjes omdat nu de ster moet zeggen
naar geheugenadres s +1.
Wat is s? Laten we terug rollen in de tijd en zeggen dat deze pijl nu niet daadwerkelijk doet ons geen gunsten.
Laten we meer in het bijzonder zeggen dat dit is het nummer 123 opslaan
omdat de start van deze string hello, dit adres 123, is 124, enzovoort.
Dus op de tweede iteratie als ik s +1 zeggen, dat is hetzelfde als zeggen 123 +1,
ook wel bekend als 124, dus wat char wordt afgedrukt op de tweede iteratie?
E op geheugenadres 124.
Dan + weer, 125, 126, 127, en deze lus stopt gelukkig voordat we hier
want ik ben met behulp van strlen om ervoor te zorgen dat ik niet telt te hoog.
Dus ook dat is het.
Nogmaals, dit is net alsof we hadden een week geleden gedaan.
Ik schrijf het op de lijn hieronder ook al hebben we niet willen om beide te doen.
Dit is identiek nu dit.
>> Dus ook al is een string is, zoals we al noemde het al weken, en is echt een char *.
Dus als we willen super anaal te zijn, het is echt een goede om te schrijven het specifieke karakter
op de i-de locatie met behulp van deze numerieke adressen en deze ster operator,
maar eerlijk gezegd, dit is gewoon zo veel schoner. Dus dit is niet slecht.
Geen reden om te stoppen met het doen van lijn 27 hier, maar 26 is functioneel hetzelfde,
en het is functioneel hetzelfde voor precies de redenen die we hebben tot nu toe besproken.
En tot slot, 29 is gewoon goede praktijk.
Bellen vrij van s betekent dat nu ben je terug te geven het geheugen dat GetString je gaf
want nogmaals, zoals ik al zei maandag getString weken
is de invoering van een bug in je code.
Uw code voor weken heeft geheugenlekken
waarbij u gevraagd GetString voor het geheugen, maar je hebt nooit het geven van het terug.
En dat was bewust gekozen door ons pedagogisch
want het is gewoon te veel na te denken over vroeg op.
Maar nu moeten we meer symmetrie.
Als u de computer om geheugen, zoals het geval is voor GetString,
zoals het geval is blijkbaar voor malloc,
moet u nu voor PSET 4 en volgende ook gratis een dergelijk geheugen.
Let op dit is iets anders dan te zeggen int n.
U hoeft niet om dit te bevrijden, omdat je niet gebeld GetString
en je niet te bellen malloc.
>> En zelfs als je wel GetInt zoals we zullen uiteindelijk zien,
GetInt heeft geen geheugen toewijzen voor u, want je kunt eigenlijk pas rond integers
en praalwagens en chars gewoon de manier waarop we hebben gedaan voor de week.
Snaren, hoewel, zijn speciaal omdat ze echt zijn de aaneenschakeling van meerdere tekens.
Dus ze zijn gewoon verschillend van chars en praalwagens en ints en dergelijke.
Maar we zullen terug te komen op dat duurde niet lang.
Hebt u vragen dan op dit begin van pointers? Ja.
[Onverstaanbaar student vraag]
Ah, goede vraag.
Een van de weinige dingen die C eigenlijk voor je doet, wat handig is,
is het cijfers uit voor wat de grootte is van het gegevenstype
en dan doet dat soort vermenigvuldiging voor u.
Dit is irrelevant bij tekens omdat bijna altijd een karakter is 1 byte,
dus dit werkt gewoon.
Maar ter wille van de discussie, als je daadwerkelijk afdrukt gehele getallen
en je probeert af te drukken enkele waarde is dat wees naar een integer,
je eveneens zou niet nodig om + 4 doen * i, alleen maar omdat een int is 4 bytes.
Pointers betekent dat C en de compiler al dat wiskunde voor u doen.
Alles wat je moet zorgen te maken over is het tellen in een soort van het menselijk verstand. Ja.
[Student] Als je een string te verklaren in een for-lus, moet je later bevrijden?
Goede vraag.
>> Als u verklaarde een string binnenkant van de for-lus, heb je nodig om later bevrijden?
U hoeft alleen maar op om geheugen vrij, wat je met GetString of met malloc.
Dus als je gewoon iets wilt - laat me nu zet accolades zodat alle code betrekking heeft.
Als je iets deed, zij het buggily, zoals dit, char * t = s,
je hoeft niet om gratis t omdat t geen sprake was van enige vermelding van malloc of GetString.
Als daarentegen je dit gedaan hebt, GetString, dan ja, zou je nodig hebt om gratis t.
En in feite, je enige kans om dat te doen is nu binnen deze lus, voor hetzelfde probleem van reikwijdte
dat we hebben besproken in het verleden.
Anders zou je het toewijzen van geheugen, het toewijzen van geheugen, het toewijzen van geheugen,
en aan het eind van het programma omdat je buiten die lus,
t bestaat niet, maar je nooit verteld het besturingssysteem
die je niet meer nodig dat het geheugen.
En het duurde niet lang, want PSET 4 of 5 zullen we u voorzien van een programma genaamd Valgrind,
die vergelijkbaar is in de geest van GDB in zoverre dat het iets heeft van een geheimzinnige interface,
maar zijn doel in het leven is om u te helpen.
En Valgrind is een programma dat zal in de toekomst zoeken in uw programma's
op zoek naar geheugenlekken, zowel van GetString of malloc,
die we zullen gaan gebruiken des te meer als we stoppen met het gebruik van de CS50 bibliotheek zo veel.
We hebben eindelijk hebben nu soort van de woordenschat en de soort van mentale model in theorie
waarmee deze gebroken programma op te lossen.
>> Dus in deze gebroken programma, swap werkt binnen swap,
maar het nooit echt gewerkt in de belangrijkste, omdat de belangrijkste aangenomen in x en y, recall,
en die werden doorgegeven in door waarden, om zo te zeggen.
Kopieën van hen werden gegeven om te wisselen.
Tegen het einde van swap, had a en b inderdaad uitgewisseld,
maar natuurlijk x en y, zoals we op maandag niet was.
Dus ik hier stel in het groen dat dit eigenlijk hier de oplossing.
En eigenlijk, laat me gaan mijn sterren alleen consistent te zijn
hoewel, nogmaals, functioneel dit doet er niet toe.
In de komende weken zullen we uitleggen wanneer en waarom het er wel toe doet.
Dus in groene nu een oplossing.
Eerlijk gezegd, het ziet er een stuk rommeliger, want ik heb al deze sterren.
Ik wil erop wijzen een ding.
De bovenste regel hier, waar het zegt int * a en int * b
is fundamenteel hetzelfde te doen als altijd.
Het is te verklaren 2 argumenten of parameters te wisselen,
waarvan de eerste is een int pointer genaamd,
waarvan de tweede is een int pointer b genoemd.
Het enige dat nieuwe Op dit punt is het feit dat er daar een ster.
>> Wat betekent dat? A is geen int, b is geen int.
A is het adres van een int en b is het adres van een ander int.
Hierna, dit is waar ik toegeven C verwarrend wordt.
Nu zijn we met behulp van een ster, maar het heeft andere betekenis in deze context.
Omdat we niet verklaren pointers als wij hier,
hier zijn we dereferentie dingen.
Dus technisch gezien, de ster in deze context van de eerste, tweede en derde lijn binnenkant van swap
wordt de dereference operator, wat gewoon betekent er heen gaan.
Dus net als mijn vinger volgde de pijl naar h,
* Een middel naar dat adres en vind ik het int dat er.
* B middelen naar het adres en geef me wat er staat.
Dus laten we de foto opnieuw te tekenen van maandag nu met behulp van een stapel van frames,
de bodem waarvan zal worden main,
de bovenste waarvan er een zal worden swap,
zodat onze wereld eruit ziet, net als maandag, op deze manier.
Hier is een deel van het geheugen dat de belangrijkste gaat gebruiken.
>> Recall van maandag dat het programma slechts 2 variabelen hadden,
een zogenaamde x-en een zogenaamde y, en ik had de nummers 1 en 2 is er.
Nu als ik roep ruilen zoals ik deed op maandag,
voorheen toen ik de rode versie van dit programma gebruikt, die er zo uitziet,
Ik heb 2 parameters, a en b, en wat hebben we schrijven hier en hier?
Gewoon 1 en 2, letterlijk kopieert van x en y.
Vandaag hebben we dat veranderen.
Vandaag de dag in plaats van het doorgeven in ints a en b we gaan passeren in 2 adressen.
Deze adressen toevallig wijzen op ints, maar die adressen worden niet ints zelf.
Ze zijn adressen. Het is als een postadres in plaats daarvan.
Dus nu moeten we gewoon mezelf een beetje meer detail op het scherm.
Dit is mijn computer het geheugen, want het is al de hele dag.
Nu moeten we een aantal willekeurige nummering.
Dus laten we zeggen, gewoon bij toeval, dat dit geheugenadres 123, 124.
Laten we zeggen dat dit is 125, dit is 126, enzovoort, maar dat is volkomen willekeurig.
We hoeven alleen maar een paar nummeringsschema in mijn geheugen.
Dus als ik nu eigenlijk pas in x en y, ik ga niet te passeren in x en y;
Ik ga nu in het postadres, om zo te zeggen, van x en van y
zodat wat wordt hier en bewaard is 1 en 2,
maar als je mijn kleine tekst te bekijken, wordt wat er in hier en hier?
[Onverstaanbaar student reactie] >> Precies. 123 wordt hier plaatsen en 124 wordt hier plaatsen.
>> Nu, omdat ik de ster in deze allereerste regel weg hier boven,
mijn programma weet alleen dat 123 en 124, ook al zijn ze natuurlijk zijn gehele getallen
dat een mens zou kunnen opmerken, moeten ze worden geïnterpreteerd als adressen, numerieke adressen.
Ze zijn niet in en van zichzelf ints, ze zijn adressen,
en dat is omdat ik expliciet daar te zetten de sterren.
Dus nu in mijn eerste, tweede en derde lijn van de werkelijke code wat hier gebeurt?
Laten we de aandacht van de rest van de foto.
Tmp is net als het was op maandag. Niets bijzonders aan tmp.
Het is gewoon een lokale 32 bits variabele, en de binnenkant van dat ik blijkbaar het opslaan van de waarde van * een.
Nu, als ik net zei tmp = a, wat zou ik hier plaatsen? >> [Student] 123.
123. Maar dat is niet wat ik doe.
Ik zeg tmp = * a. Star middelen er heen gaan.
Dus hier is een, 123. Hoe ga ik daar? Doen alsof er een pijl.
Nou, daar is het, 1. Dus wat wordt opgeslagen in tmp, blijkbaar? Slechts 1.
Met andere woorden, tmp * a, * een middel naar het adres dat momenteel in een,
die blijkbaar 123.
>> Oke, hier zijn we dan op locatie 123, zie ik de nummer 1,
dus ik ga naar de nummer 1 daar te stellen.
Wat moet ik nu doen in lijn 2, * a = * b?
Dit is een beetje meer betrokken want nu wat is een? Het is 123.
Dus * een is waar? Precies waar ik vroeger was. Dus ga daar. Oke.
Nu, ten slotte, en dan uiteindelijk deze zal beginnen te zin te maken, hopelijk,
* B betekent wat er in b? 124. Dus ik moet er naartoe te gaan, dat is 2.
Dus wat doe ik waar?
2 gaat in hier omdat * b * gaat in een. Dus ik zal dat doen.
En je kunt misschien al zien, dat we zo veel dichter
aan het oplossen van deze dom, simpel probleem correct voor de eerste keer
want nu hebben we nog een herinnering van wat x was,
we hebben 2 exemplaren, weliswaar, van y,
maar lijn 3 zegt nu * b.
Dus hier is b. * B middelen er heen gaan. Dus waar is locatie 124?
Het is blijkbaar hier. Dus wat moet ik hier zetten? Uiteraard tmp.
Dus nu doe ik dit. Dus ik heb een hier en 2 hier.
En nu, wat over dit alles, de 123, de 124, en de 1?
Zodra swap rendement dit geheugen is zo goed als verloren
want zodra swap terug, het besturingssysteem
vrij dat geheugen weer in de toekomst.
Enige grote geheugen onderaan deze zogenaamde stack stokken rond.
>> En dus hebben we eindelijk nu een werkende versie.
Laat me gaan in swap.c, en let op het volgende.
Aan de bovenkant van het programma dat ik heb mijn prototype te zijn int * a en int * b.
Dus het enige wat ik veranderd te gaan van rood, wat slecht was, naar groen, wat goed is,
wordt voegde ik deze sterren vandaag.
Maar dan hier in te wisselen zich moest ik kopiëren, plakken wat was net op de dia.
Ik heb een ster hier, ster hier - dat overeenkomt met het prototype -
en dan al deze dingen hebben nu sterren, behalve voor tmp
omdat het gebruik van een tijdelijke variabele, er is niets nieuws.
Ik moet alleen tijdelijke opslag voor een int.
Dus we daar geen behoefte aan een ster.
We hoeven alleen maar de ster, zodat we dit soort willekeurige grens te overschrijden
tussen deze 2 frames in het geheugen van mijn computer.
Maar een ding moet veranderen, en je zou een glimp hebben opgevangen het al.
Welke andere lijn is natuurlijk nu anders? >> [Student] & x.
>> Ja, dus 25 is de laatste regel van code die ik moet veranderen om dit te laten werken.
Een week geleden en zelfs op maandag lijn 25 zag er als volgt, ruilen x en y,
en dit was gewoon kapot, want als je zegt swap (x, y)
je geeft exemplaren van x en y te ruilen, dan is het aan het doen is zijn ding,
maar je bent nooit echt veranderen x en y zelf.
Dus zelfs als je nog nooit hebt gezien dit karakter voor met de ampersand in de code,
gewoon een gok. Wat doet het en-teken blijkbaar doen,?
[Student] stelt zich op het adres. >> Neemt het adres.
Dus de ampersand zegt geef me het adres van x.
Wie weet waar het is? Het gebeurt te zijn 123. Kan me niet schelen. Geef me het adres van x.
& Y betekent geef me het adres van y.
En op dat punt het verhaal is geheel in overeenstemming met het beeld dat we trokken even geleden.
>> Dus ik geef toe pointers, zeker voor mij toen ik voor het eerst begonnen met het leren van deze,
waren zeker een van de moeilijkste dingen in mijn ogen rond te wikkelen.
Maar te realiseren, vooral omdat we blijven spelen met dit soort dingen,
als je af te breken om deze super eenvoudige soort van intellectueel oninteressante problemen
van slechts bewegende nummers rond, het antwoord op een hoop verwarring met verwijzingen
echt kan worden afgeleid uit deze zeer eenvoudige mechanica.
Hier is een adres. Ga er met de ster.
Of omgekeerd, hier is een ampersand. Zoek uit wat het adres eigenlijk is.
Oke.
Dus waar is dit allemaal herinnering vandaan?
We hebben getekend dit beeld een paar keer, en ik blijf veelbelovende komen we terug om het te,
maar hier is de vertegenwoordiging van het geheugen van uw computer
dat is een beetje meer gemerkte dan onze krijtbord hier is.
De tekst segment boven vertegenwoordigt wat met betrekking tot uw programma?
[Onverstaanbaar student reactie] >> Sorry? Zeg het nog eens.
[Student] Het eigenlijke programma. >> Het actuele programma.
>> Dus de 0s en 1s die u hebt samengesteld na het schrijven van C-code en vervolgens draait Clang
en het genereren van 0s en 1s eindigt omhoog krijgend er verscholen in het geheugen
want als u dubbelklikt op een pictogram op uw Mac of PC
of uitvoeren van een commando als mario op uw prompt, uw 0s en 1s van schijf
raken in het geheugen geladen, zodat de computer kan manipuleren
en uitvoeren sneller.
Dus geïnitialiseerd gegevens en niet-geïnitialiseerde data, zullen we niet veel praten over die,
maar dat zijn slechts globale variabelen.
Geïnitialiseerd betekent globale variabelen dat je waarden gaf aan;
geïnitialiseerde betekent globale variabelen die u nog niet over waarden geven.
Dan is er nog deze omgevingsvariabelen die ik mijn hand helemaal zwaaien op,
maar ze zijn er en dat slaat dingen als uw gebruikersnaam
en andere soort van lager niveau details.
Maar de sappigste stukjes van lay-out uw geheugen is dit ding heet de stack en de heap.
De stapel weer, om duidelijk te zijn, is het geheugen dat wordt gebruikt wanneer functies worden genoemd,
wanneer er lokale variabelen
en wanneer er parameters worden doorgegeven rond.
Dat alles gebeurt in de stapel.
De hoop dat we nog niet over gesproken, maar neem een ​​gok die gebruik maakt van de heap.
Gewoon een ander stuk van het geheugen.
Het gebeurt hier worden getrokken aan de top, maar dat is een willekeurige picturale conventie.
Wie heeft blijkbaar zijn met behulp van het geheugen van de hoop voor weken?
Het is technisch gezien je maar indirect. >> [Student] GetString.
GetString en malloc. Dus hier is het fundamentele verschil.
>> Je weet wel voor de laatste paar weken, dat als u het geheugen gewoon een variabele te verklaren.
Als u veel geheugen, een array declareren recht binnenkant van je functie.
Maar het probleem dat we hebben gehouden met uitzicht is als je variabelen op lokaal binnenkant van functies,
zodra de functie terugkeert, wat gebeurt er met het geheugen en die variabelen?
Gewoon soort van het is niet meer van jou, toch? Het verdwijnt gewoon soort van conceptueel.
Het is nog steeds fysiek aanwezig, natuurlijk, maar het is niet langer een recht van gebruik.
Dit is natuurlijk een probleem als je wilt functies in het leven schrijven
die daadwerkelijk geheugen toewijzen en geef het niet onmiddellijk terug.
Case in point: GetString's doel in het leven is dat er geen idee van te voren
hoe groot van een string Ik ga te typen op het toetsenbord,
maar het moet in staat zijn om geheugen toe te wijzen aan David of hallo te houden
of een hele essay dat de gebruiker zou kunnen hebben getypt inch
Dus GetString is met behulp van malloc.
Malloc moet dus worden met behulp van niet de stapel;
in plaats daarvan is het gebruik van dit ding genaamd de heap.
Er is niets anders aan het geheugen. Het is niet sneller of langzamer of iets dergelijks.
Het is gewoon fysiek op een andere locatie.
>> Maar de regel is dat het geheugen dat is toegewezen op de heap
zal nooit worden genomen van u af totdat je belt - neem een ​​gok - gratis.
Daarentegen zou de eventuele geheugen je vragen om op de stapel door gewoon te verklaren een array
of waarbij een variabele zoals we hebben gedaan voor weken,
dat standaard belandt op de stapel.
En dat werkt geweldig 90% van de tijd, maar op die zeldzamer gelegenheden
waar u wilt geheugen toe te wijzen en te houden rond,
dan moet je een functie als malloc gebruikt.
Of hebben we een functie zoals GetString, die op zijn beurt malloc.
Laten we eens kijken waar dit zou kunnen breken en neem dan een kijkje op Binky.
We komen terug naar dat in de toekomst.
Hier is een super eenvoudig programma dat in de eerste 2 lijnen doet wat?
In het Engels, wat deze eerste 2 regels code doen binnen van de belangrijkste?
[Onverstaanbaar student reactie]
Voorzichtig. Het maakt me niet het adres van x of y.
[Student] Geeft verwijzingen naar ints. >> Goed. Geef me 2 pointers naar gehele getallen.
Met andere woorden, geef me 2 delen van het geheugen dat ik blijf tekenen vandaag de dag,
hoewel ik gewist het nu, als pleinen.
Geef me 2 delen van het geheugen, een x genoemd, een naam y -
eerder noemde ik ze s en t - en wat is het type van dat stuk van het geheugen?
Het gaat om een ​​adres op te slaan.
Het is van het type int *.
>> Dus het adres van een int zal uiteindelijk wonen in x,
het adres van een int uiteindelijk leven y,
maar in eerste instantie, wat er in x en y? Wie weet? Garbage waarden.
Het heeft niets te maken met pointers.
Als we niet plaatsen daar iets, wie weet wat is er eigenlijk?
Nu x. Wat gebeurt er hier? Dit is legit nu omdat x is een pointer. Het is een int *.
Dus dat betekent dat ik kan zetten in x het adres van sommige brok van het geheugen.
Wat doet malloc terug? Perfect, keert het terug adressen,
het adres van de eerste byte in een heel blok geheugen.
Hoeveel bytes deze schijnbaar verdeling bijvoorbeeld in het apparaat?
Wat is de grootte van een int? 4.
Als je terugdenkt aan week 1, het is niet super belangrijk om altijd onthouden dat,
maar in dit geval is het nuttig te weten 4 bytes.
Dit is dus de verdeling op de heap 4 bytes
en het is terug te keren het adres van de eerste die mij willekeurig.
Nu, wat is x aan het doen?
A * x = 42 doet wat?
Als op dit punt in het verhaal hebben we x, die ongeveer zo uitziet met een aantal vuilnis waarde,
dit is nu y met een aantal vuilnis waarde, nu in regel 3 Ik heb 4 bytes toegewezen.
Deze foto ziet er in wezen als volgt.
Of meer specifiek, als dit is willekeurig adres 123, dit is wat ons verhaal nu eruit ziet.
* X = 42 betekent nu wat? Dat betekent dat naar het adres 123 en zet de nummer 42 daar.
Ik hoef niet om deze lijnen te trekken omdat we niet doen snaren.
>> Ik had net geschreven als dit, en net voor de demonstratie ter wille,
42 als een soort int neemt veel ruimte 4 bytes.
Dus dat is wat er gebeurd is, maar er is een probleem nu.
* Y = 13. Wat gaat er hier gebeuren?
Het probleem is * y in onze vereenvoudigde wereld betekent gewoon naar het adres in y.
Wat zit er in y? Het is wat vuilnis waarde.
Dus laten we aannemen dat die troep waarde is 5551212, iets geks dergelijks.
* Y middelen gaan naar 5551212 te pakken.
Dat is hier graag over. Het niet bestaat bijvoorbeeld.
Dus * y krijgt 13 betekent dat ik ben op zoek naar hier te trekken 13. Het bestaat niet.
Ik heb meer dan het segment van het bord. Wat krijg ik?
Dat cryptische boodschap segmentation fault omdat ik probeer te zetten in het geheugen
een waarde als 13 op een plaats die niet bestaat.
De rest van het programma kan oke, maar werken tot dat moment niet.
Dus laten we proberen om dit verhaal te vertellen.
We komen terug naar dat zodra we over gesproken hebben hex.
Laten we terug gaan naar dit en sluiten met dit ding heet Binky,
die recall is een Stanford professor om thuis te zitten spelen met claymation,
om het verhaal van precies dat hetzelfde programma vertellen.
Het is gewoon ongeveer 3 minuten lang. Hier hebben we Binky.
[Mannelijke spreker op video] Hey Binky, wakker worden. Het is tijd voor pointer plezier.
[Binky] Wat is dat? Meer informatie over pointers? Oh, goody!
[Mannelijke spreker] Nou, om te beginnen, ik denk dat we gaan een paar pointers nodig hebben.
>> [Binky] Oke. Deze code wijst 2 pointers die kunnen wijzen op gehele getallen.
[Mannelijke spreker] Oke. Nou, ik zie de 2 pointers, maar ze lijken niet te wijzen naar iets.
[Binky] Dat klopt. In eerste instantie denk pointers wijzen niet op iets.
De dingen die ze wijzen op heten pointees, en de inrichting daarvan is een aparte stap.
[Mannelijke spreker] Oh, rechts, rechts. Ik wist dat. De pointees zijn gescheiden.
Eh, dus hoe weet je kennen een pointee?
[Binky] Oke. Deze code wijst een nieuwe integer pointee, en dit deel stelt x daarnaar verwijzen.
[Mannelijke spreker] He, dat ziet er beter uit.
Dus maak er iets doen. >> [Binky] Oke.
Ik zal dereference de aanwijzer x om het nummer 42 te slaan in zijn pointee.
Voor deze truc heb ik nodig mijn toverstaf van dereferentie.
[Mannelijke spreker] Uw toverstaf van dereferentie? Dat is geweldig.
[Binky] Dit is wat de code eruit ziet. Ik zal gewoon het opzetten van de aantal en ... [Knallend geluid]
[Mannelijke spreker] kijken He, daar gaat.
Dus het doen van een dereference op x volgt de pijl om toegang te krijgen haar pointee,
in dit geval tot 42 slaan daar.
He, probeer dan met behulp van het aan de nummer 13 op te slaan door de andere wijzer, y.
[Binky] Oke. Ik zal gewoon hier gaan over naar y en krijg het nummer 13 opgericht
en neem de staf van dereferentie en gewoon ... [Zoemend geluid] Whoa!
[Mannelijke spreker] Oh hey, dat werkte niet.
>> Binky Zeg, ik denk niet dat dereferentie y is een goed idee
omdat het opzetten van de pointee is een aparte stap
en ik denk niet dat we ooit deden.
[Binky] Hmm, goed punt.
[Mannelijke spreker] Ja. We toegewezen de aanwijzer y maar we nooit stel deze te wijzen op een pointee.
[Binky] Hmm, zeer oplettend.
[Mannelijke spreker] He, je ziet er goed uit daar, Binky.
Kunt u dit oplossen dat y verwijst naar dezelfde pointee als x? >> [Binky] Tuurlijk.
Ik gebruik mijn toverstaf van pointer opdracht.
[Mannelijke spreker] Is dat gaat een probleem als voorheen zijn?
[Binky] Nee, dit is niet aan de pointees.
Het verandert slechts een pointer te wijzen op hetzelfde als een ander. [Knallend geluid]
[Mannelijke spreker] Oh, ik zie. Nu y wijst op dezelfde plaats als x.
Dus wacht. Nu y staat vast. Het heeft een pointee.
Dus je kunt proberen de staf van dereferentie weer naar de 13 over te sturen.
[Binky] Uh, oke. Hier gaat. [Knallend geluid]
[Mannelijke spreker] He, kijk daar eens. Nu dereferentie werken op y.
En omdat de wijzers van het delen van die ene pointee, ze beide zien de 13.
[Binky] Ja, het delen. Het zal wel.
>> Dus gaan we nu overschakelen plaatsen?
[Mannelijke spreker] Oh kijk, we hebben geen tijd meer. >> [Binky] Maar -
[Mannelijke spreker] Vergeet de 3 pointer regels.
Nummer 1, de basisstructuur is dat je een pointer hebben en het wijst naar een pointee.
Maar de aanwijzer en pointee zijn gescheiden, en de veel voorkomende fout is het opzetten van een pointer
maar om te vergeten om het een pointee.
Nummer 2, wijzer dereferentie begint bij de aanwijzer en volgt de pijl boven
zijn pointee openen.
Zoals we allemaal weten, dit werkt alleen als er een pointee,
wat voor soort komt terug naar regel nummer 1.
Nummer 3, wijzer opdracht neemt een pointer en verandert het
om naar dezelfde pointee als een pointer.
Dus na de opdracht, zal de 2 pointers naar dezelfde pointee.
Soms is dat heet delen.
>> En dat is alles wat er is het echt. Bye-bye nu.
Dit is Binky. Dit is CS50. We zien je volgende week. [Applaus]
>> [CS50.TV]