[Muziek]
>> DAVID J. MALAN: Oke.
Dit is CS50.
En dit is het begin van week 5.
En zoals je misschien al gemerkt hebt, deel van het materiaal
wordt steeds een beetje meer complex, de kleine dichter.
>> En het is heel makkelijk, vooral als u in de gewoonte geweest voor enige tijd,
te proberen om de meeste opschrijven alles wat we doen, we zeggen in de klas.
Maar beseffen, dat is misschien niet de ideale pedagogische aanpak
om het leren van dit soort materiaal, en materiaal meer in het algemeen.
En dus zijn we blij om kondigen eigen Gheng dat CS50
Gong begonnen te bereiden een canonieke verzameling van opmerkingen
voor de cursus, de hoop van namelijk dat men deze
niet alleen als een referentie en een bron
voor de herziening van materiaal en gaan terug door materiaal dat misschien
ontsnapt de eerste keer, maar ook, zodat uw hoofd kan meer
omhoog dan omlaag, wanneer tijd is om de les te lezen,
zodat je zou kunnen gaan meer bedachtzaam, als
tegenstelling tot meer scribbly.
>> Met dat gezegd, wat je zult vinden op de website is dergelijke documenten als dit.
En let, linksboven, is er niet alleen een inhoudsopgave,
maar ook tijd codes die krijgt u meteen te springen
naar de juiste onderdeel in de video online.
En wat Chang hier heeft gedaan wordt, in essentie, gedocumenteerd
wat er in deze bijzondere lezing.
En veel van de lezingen zijn al online nu met deze URL.
En we zullen doorgaan met de rest te posten van die tegen het einde van deze week,
dus profiteren van die bron.
>> Dus zonder verder oponthoud, we begonnen om terug te pellen
de laag die is koord enige tijd.
En wat hebben we zeggen een string eigenlijk is de afgelopen week?
Dus char ster.
En char ster, goed, wat ging dat eigenlijk?
Nou, al die tijd, als we hebben is het aanroepen van een functie,
zoals getString en opslaan de zogenaamde return
waarde van getString in een variable-- het heet
s soort string-- we al schrijven de regel van de code daar boven.
En het is pas als ik zie mijn handschrift hier uitvergroot
moet ik beseffen hoe afschuwelijk dit is.
>> Echter, laten we aannemen dat, aan de rechterzijde
is niettemin een redelijke voorstelling van wat er
er aan de hand dit alles tijd met getString.
getString natuurlijk krijgt een tekenreeks.
Maar wat betekent dat eigenlijk?
Het betekent het krijgt een brok van geheugen van het besturingssysteem
door te bellen naar een functie, genaamd malloc.
Maar daarover later meer.
En dan is het bevolkt dat stuk van het geheugen
met de brieven van de gebruiker heeft ingetypt, gevolgd door natuurlijk
een nul, of een backslash nul op het einde.
>> Ondertussen, aan de linkerkant van dit verhaal, al die tijd,
we hebben declareren van een variabele, zoals s.
En die variabele is wat nu zal beginnen bellen een pointer.
Het is niet een doos binnen van die we zetten de string, Daven, per se,
maar zetten we in dat plein vak aan de linkerzijde wat precies?
Yeah?
>> Publiek: Het adres van waar het is gelegen in het geheugen.
>> DAVID J. MALAN: Precies.
Het adres van waar Daven bevindt zich in het geheugen.
En niet waar alle Daven is gevestigd, per se, maar specifiek adres
van wat?
Yeah?
>> PUBLIEK: Eerste karakter.
>> DAVID J. MALAN: Het eerste teken in Daven, die in dit geval
Ik heb voorgesteld was willekeurig en onrealistisch 1, OX1,
waardoor alleen de hexadecimaal getal van 1.
Maar het gaat waarschijnlijk een veel grotere getal zijn
opdat wij zouden trekken met een 0x als voorvoegsel,
wat neerkomt op een hexadecimaal karakter.
En omdat we niet nodig om te weten waar de rest van de karakters van Daven
zijn, door wat eenvoudig ontwerp beslissing dat was vele jaren geleden gemaakt?
Yeah?
>> PUBLIEK: Backslash 0.
DAVID J. MALAN: Ja, precies.
De backslash 0 kunt u, zij het in lineaire tijd, om de string doorkruisen,
lopen van links naar rechts, met een lus, of een tijdje
lus, of iets dergelijks dat, en te bepalen, oh, hier
is het einde van dit koord.
Dus met alleen het adres op het begin van een tekenreeks,
Wij hebben toegang tot het geheel van , want dit alles terwijl,
een string is net een char ster.
>> Dus het is zeker goed te blijven gebruiken de CS50 bibliotheek en deze abstractie,
zo te zeggen, maar we zullen gaan precies zien
wat is er aan de hand onder deze hele tijd.
Dus je kan dit voorbeeld herinneren, Ook van de vorige keer, vergelijk 0,
die eigenlijk niet te vergelijken.
Maar we begonnen om dit op te lossen.
>> Maar als misschien wel een opfriscursus, zou ik iemand interesseren
in een roze olifant vandaag, ook gemaakt door Chang?
Hoe zit je aan de voorkant? [Onverstaanbaar].
Kom maar naar boven.
>> En in de tussentijd, als je komen, laten we
overwegen voor slechts een moment wat deze code is werkelijk te doen.
Het verklaren van twee variabelen op top, s en t, en bellen getString.
Dit is niet een zeer gebruiksvriendelijk programma, omdat het je niet vertellen wat je moet doen.
Maar laten we aannemen dat we gericht op het sappige gedeelte.
En dan doen we, als s gelijk is aan t gelijk moet printf zeggen
je hetzelfde getypt.
Hello.
Wat is je naam?
>> JANELLE: Janelle.
DAVID J. MALAN: Janelle, leuk je te ontmoeten.
Dus uw uitdaging bij hand voor deze olifant
is om eerst te tekenen ons een beeld van wat er worden voorgesteld in de eerste twee
lijnen.
Zo s en t misschien vertegenwoordigd hoe op het scherm?
En je kunt gewoon tekenen met uw vinger op dit grote scherm.
>> Dus er is twee helften aan elke zijde van die vergelijking.
Dus er is s aan de linkerkant, en de Vervolgens getString aan de rechterkant.
En dan is er nog t aan de linkerkant, en dan getString aan de rechterkant.
Dus hoe kunnen we beginnen het tekenen van een beeld dat
weergeeft wat er aan de hand hier in het geheugen, zou je dan zeggen?
En laat me laten uitleggen wat je doet als je gaat.
>> JANELLE: OK.
Nou, ten eerste, het zou moeten vragen u naar de input string te krijgen.
En het zou store-- oh, sorry.
DAVID J. MALAN: OK.
Goed.
En dit is wat heet?
Oh, OK.
Blijf doorgaan.
Ik wilde je niet storen.
JANELLE: Sorry.
Dus het zou ingang het in het adres van-- niet zeker.
Ik kan me niet precies herinneren het nummer, maar ik denk dat het begon met 0.
>> DAVID J. MALAN: Dat is in orde, omdat ik de getallen,
dus er is geen juist antwoord.
>> JANELLE: Te beginnen met de 0 arc.
>> DAVID J. MALAN: OK, dus element 0.
Tuurlijk.
>> JANELLE: En dan, als was als slechts een twee-letter--
>> DAVID J. MALAN: OK, terug naar jou.
>> JANELLE: Dus element 0 en dan 1 element of element 2.
DAVID J. MALAN: En welk stuk van de foto ben je nu aan het tekenen?
De oproep tot getString?
Of de verklaring van s?
>> JANELLE: De verklaring van s, geloof ik.
Oh, de getString omdat het zou worden ingevoerd in elke [? gebied. ?]
>> DAVID J. MALAN: Goed.
Precies.
Hoewel dit effectief geeft een array, recall,
als we terug een string, we kunnen index in die string met 01 en 2.
Technisch gezien, zijn dit waarschijnlijk vertegenwoordigd door individuele adressen,
maar dat is prima.
>> Dus stel, als ik kan alleen snel doorsturen naar waar we gebleven
laatste keer als een van de snaren was g a b e,
backslash 0, zijn aldus Gabe's input, hoe zouden wij vertegenwoordigen en nu?
Als dit het geheugen dat geretourneerd door getString?
>> JANELLE: Zou het vertegenwoordigd door een boog?
>> DAVID J. MALAN: Door een boog?
Nou, nee.
Laten we zeggen, picturaal, laat me gewoon doorgaan
en voor dat, indien dit is s, dit is de return waarde van getString.
En je hebt dit getekend als 0, 1, 2, die is heel redelijk, omdat we
kan indexeren in de string, als zodanig.
Maar gewoon om te stroken met laatste keer, laat me ga je gang
en willekeurig voor te stellen dat deze is het adres 1, dit is het adres 2,
dit adres 3, enzovoort.
En dus, gewoon om super te zijn duidelijk, wat is er
gaan in s als gevolg van die eerste regel van de code, zou je dan zeggen?
>> JANELLE: Adres 1?
>> DAVID J. MALAN: Precies.
Dus pakken 0x1.
En ondertussen, laat me gaan en dupliceren veel van wat je hebt gedaan
en voeg hier mijn eigen t.
Als ik te typen in Gabe nogmaals, een tweede keer,
wanneer daarom wordt gevraagd met getString, waar, Natuurlijk is gabe ga?
Nou, presumably--
>> JANELLE: Net als hier?
DAVID J. MALAN: Ja.
JANELLE: Of het is ook in dezelfde dozen?
DAVID J. MALAN: Laat me voorstellen, ja, precies, zodat in het andere vakken.
Maar wat is nu belangrijk is dat, zelfs hoewel ik deze aardig in de buurt hebt getekend
together-- 0x1, dit wordt 0x2-- in werkelijkheid,
dit nu zou kunnen adres 0x10 zijn, bijvoorbeeld, en 0x11 en 0x12,
enzovoort.
En dus, als dat het geval is, wat er gaat hier uiteindelijk in t?
>> JANELLE: 0x10?
DAVID J. MALAN: Precies.
Dus 0x10.
En nu, de laatste vraag.
Je hebt, veruit, moest het werk moeilijkste voor een olifant tot nu toe.
Door nu, als ik trek de code weer, wanneer ik, in lijn drie,
als s gelijk is gelijk aan t, wat ben ik eigenlijk vergelijken van dat we hier hebben getrokken?
>> JANELLE: De twee adressen?
DAVID J. MALAN: Precies.
Dus ik zeg is s gelijk is gelijk aan t?
Met andere woorden, 1 gelijk gelijk aan 10?
En natuurlijk de voor de hand liggende antwoord is nu, nee.
En dus dit programma is uiteindelijk ter perse gaan wat, zou je dan zeggen?
>> JANELLE: Zou het, je hetzelfde getypt?
>> DAVID J. MALAN: Dus als s 1 is en t 10?
>> JANELLE: Je getypt verschillende dingen.
>> DAVID J. MALAN: Precies.
U hebt getypt verschillende dingen.
Oke.
Dus een applaus, als we konden, hier.
[Applaus]
Dat was pijnlijk.
Ik weet het.
Mooi gedaan.
Dus laten we nu eens kijken of we niet kunnen plagen elkaar wat de oplossing was.
En natuurlijk, als we vast dit-- die ik nu te vertegenwoordigen in green--
we hebben een paar verbeteringen hier.
Ten eerste, zoals een gezond verstand kijk, ik ben eerst te controleren
als s gelijk is aan nul en t is gelijk aan nul.
En alleen maar om duidelijk te zijn, wanneer zou s of t nul in code als deze?
Wanneer zou s of t null zijn.
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Precies.
Als de tekenreeks die de gebruiker ingetypt is veel te lang
te passen in het geheugen, of een rare hoek geval als dat,
getString, zoals we zullen zien, letterlijk vandaag, in de documentatie,
zegt dat het zal null zo terug een speciale sentinel waarde,
of gewoon een soort van een speciaal symbool dat betekent dat er iets mis is gegaan.
Dus we willen controleren dat, aangezien het blijkt
dat null is een zeer gevaarlijke waarde.
>> Vaak, als je probeert om iets te doen met null met een function-- door te geven
als input voor instance-- die functie misschien erg zal crashen en, met het,
take down je hele programma.
Dus deze derde lijn is nu slechts een sanity controleren, foutcontrole, als je wil.
Dat is nu een goede gewoonte voor ons op te nemen in een tijd dat we
proberen om een ​​waarde te gebruiken die kon, in potentie, van nul.
>> Nu, hier de vierde regel, "Als strcmp (s, t)," goed,
wat is dat een verwijzing naar?
Nou, wij vonden dat dit een zeer beknopt benoemde functie voor string vergelijking.
En haar doel in het leven is om te vergelijken haar eerste argument tegen het tweede,
maar niet in termen van hun adressen, zoals wij gedaan hebben onbedoeld een moment
geleden met de rode code, maar veeleer vergelijken deze twee
strings in het menselijk intuïtieve manier door het vergelijken van dit, tegen deze,
tegen dit, tegen deze, en dan stoppen indien en wanneer een
of beide van mijn vingers raakt een backslash 0.
Dus iemand die jaren geleden geïmplementeerd strcmp uitvoer te leggen voor ons de functionaliteit
dat we gehoopt dat we zouden hebben gekregen met slechts twee eenvoudige vergelijking van waarden.
>> Nu eerlijk gezegd, ik blijf tekenen al deze verschillende getallen.
Maar de realiteit is, ik ben geweest waardoor deze de hele tijd.
En dus laat me gewoon doorgaan en krabbel deze uit
om een ​​punt dat aan het einde van de dag en vooruit,
we zijn niet echt zorgen te maken over welke adressen dingen eigenlijk
in het geheugen.
Dus ik ben niet van plan om deze te tekenen soorten nummers zo veel meer,
Ik ben gewoon een abstract deze weg een beetje meer vriendelijk met slechts pijlen.
>> Met andere woorden, als s een pointer, goed, laten we gewoon tekenen, letterlijk,
als een pointer, een pijl uit zichzelf naar iets anders,
en niet te veel zorgen meer over de minutia van deze adressen
die, nogmaals, ik heb bedacht toch.
Maar we zullen deze adressen te zien, Soms, bij het oplossen van code.
>> Nu ondertussen, dit programma hier fixes, natuurlijk,
dat probleem door vergelijking die twee strings.
Maar we liepen tegen een ander probleem.
Dit was van de kopie programmeren laatste keer,
waarbij, ik probeerde te kapitaliseren alleen het eerste teken in een string.
Maar wat was het symptoom we vorige keer toen zag
een gebruiker heeft ingevoerd in een waarde, zoals gabe in kleine letters, voor s,
vervolgens toegewezen we s naar t, zoals in het derde line,
en dan heb ik geprobeerd om kapitaliseren t beugel 0?
Wat was het effect van veranderende t beugel 0 hier?
>> Publiek: Het veranderde s.
>> DAVID J. MALAN: Ja, Ik veranderde s, ook.
Want wat er werkelijk aan de hand?
Nou, laat me zien of ik kan schoonmaken op deze foto, als volgt.
>> Als s, wederom, het woord g, a, b, e, backslash, 0, en s
we zullen doorgaan met tekenen als een doos here, maar niet meer adressen.
Laten we stoppen met het maken van dingen.
Laten we gewoon een tekening maken de wereld vereenvoudigen.
>> Als ik verklaar t met string t, dat schept dat stuk van het geheugen.
Plein gebeurt te zijn 32 bits in de meeste computers.
In feite, als je ooit gehoord van een computer met een 32-bit architectuur,
echt fancy-spreken, die net middelen gebruikt 32-bit adressen.
En als technisch terzijde, Als je ooit hebt afgevraagd
waarom oudere computers, als u daadwerkelijk probeerde soep ze met veel RAM,
kan slechts een maximum hebben van vier gigabyte aan RAM-geheugen,
Nou dat is omdat, letterlijk, uw oude computer kon alleen
tellen zo hoog als 4 miljard, 4 miljard bytes,
omdat het 32-bits nummers adressen.
>> Maar in elk geval, in deze Bijvoorbeeld, het verhaal van veel eenvoudiger.
t is gewoon een andere aanwijzer, of echt een char ster, aka string.
En hoe kan ik deze foto wilt updaten nu met die tweede regel van de code,
na de dot, dot, dot?
Als ik dat doe touw t de waarde s puntkomma, hoe verhoudt dit beeld te veranderen?
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Ja.
Precies.
Ik heb net een pijl uit de t box naar hetzelfde adres,
dezelfde eerste letter in gaf.
Of technisch, als dit man nog op 0x1,
het is alsof ik had 0x1 hier en 0x1 hier.
Maar nogmaals, who cares de adressen?
Het is gewoon het idee dat het nu doet.
Dus dit is wat er hier gebeurt.
Dus natuurlijk, als je dat doet t beugel 0: de matrix notatie,
van course-- en eerlijk gezegd, het ziet er alsof er een scala hier,
maar nu is er een raar ding.
Weten dat de programmeertaal, C, biedt u deze mogelijkheid,
waarbij, zelfs als t een wijzer, of s een pointer,
kunt u nog steeds gebruik maken van die vertrouwd zijn, comfortabele vierkante haak
notatie naar het eerste element, of het tweede element, of een element
dat pointer wijst om omdat vermoedelijk het
is, zoals in casu, wijst op een array.
>> Dus hoe kunnen we dit oplossen?
Eerlijk gezegd, dit is waar het werd een beetje overweldigend op het eerste gezicht.
Maar hier is een nieuwe en verbeterde versie.
>> Dus eerst, ik krijg ontdoen van de CS50 bibliotheek,
gewoon bloot dat s inderdaad een char ster, maar een synoniem.
En t is ook een char ster.
Maar wat er gaande is op de rechterzijde van die lijn
waarbij t een waarde is toegekend?
>> Wat is malloc?
Wat het strlen?
Wat is sizeof (char)?
Waarom de heck doet dit lijn blik zo complex?
Wat doet het op een hoog niveau?
Hoe is het opslaan van in t?
Yeah?
Publiek: Het toewijzen van een bepaalde hoeveelheid geheugen ruimte.
Het is op te slaan, denk ik, brieven [onverstaanbaar].
>> DAVID J. MALAN: Perfect.
Perfect.
Het toekennen van een bepaalde hoeveelheid geheugenruimte
opslaan vermoedelijk toekomst letters.
En met name malloc Daarom terug wat?
>> PUBLIEK: Terugkerende de [onverstaanbaar]?
DAVID J. MALAN: Precies.
Terugzending van het adres van dat geheugen, Dit is een ingewikkelde manier om te zeggen,
geeft het adres van de eerste byte van dat geheugen.
Het is aan mij om te onthouden hoeveel geheugen ik eigenlijk
toegewezen of gevraagd malloc voor.
>> Nu hoeveel is dat?
Nou, ook al is er veel haakjes here,
malloc duurt slechts een enkel argument.
En ik ben het specificeren strlen van s, dus geef me zoveel bytes als er in s,
maar voeg een.
Waarom?
Yeah?
>> Publiek: De backslash 0.
DAVID J. MALAN: Precies.
We moeten een beetje het huishouden doen.
Dus omdat er een backslash 0, zouden we beter onthouden.
Anders gaan we om een ​​string te maken dat
niet over die speciale terminator.
>> Ondertussen, alleen maar om super te zijn anaal, ik heb sizeof (char),
voor het geval dat iemand loopt mijn code niet op de CS50 apparaat,
maar misschien een andere computer helemaal waar chars
zijn een byte, volgens afspraak, maar twee bytes, of iets groter dan dat.
Het is gewoon super zijn, super vies van fouten.
Alhoewel, in werkelijkheid is het het meest waarschijnlijk zal een 1 zijn.
>> Nu, ondertussen, ik ga je gang en kopieer de reeks, t beugel i is gelijk aan t beugel s.
En ik zal uitstellen tot vorige week broncode om te zien wat er gaande is.
Maar de sleutel mee te nemen, en de reden dat ik de code nu in het groen,
Want dat laatste lijn, t beugel 0 evenaart toupper,
heeft tot gevolg kapitaliseren die reeks?
t en / of s?
Die laatste regel code.
>> Gewoon t, want wat is gebeurde dit keer,
als ik iets ongedaan te maken die laatste stap, wat is er gebeurd, als ik bel malloc,
Ik wezen krijgen een stuk van het geheugen dat is hetzelfde formaat als het origineel,
want dat is het rekenkundig ik deed.
Ik ben het opslaan van in t het adres van dat deel van het geheugen.
Hoewel dit ziet er leuk uit en mooi, mooi en leeg,
de realiteit is dat er, wat we zullen blijven bellen, vuilnis waarden in hier.
Dat stuk van het geheugen zou zeer goed hebben al eerder gebruikt,
een paar seconden, een paar minuten geleden.
Dus er absoluut kan zijn nummers of letters er, net per ongeluk.
Maar ze zijn niet geldig, totdat ik mezelf bevolken dit stuk van het geheugen
met de werkelijke tekens, zoals ik doen in die lus daar.
Goed?
>> Dus nu, de climax van Deze drie voorbeelden
die schijnbaar gebroken waren de vorige keer, deze Swap voorbeeld van deze functie
werkzaam in de zin dat verwisseld a en b.
Maar het werkte niet in welke andere zin?
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Precies.
Als ik deze functie aan te roepen van another-- bijvoorbeeld
van een functie als main, waar Ik heb een variabele, x en y, zoals ik
vorige week deed, dezelfde code, en ik pas in de x en y
naar Wisselen en neem contact Swap-- dit, Uiteraard is de juiste versie
is wat we gaan see-- het werkte niet.
Dus wat is de oplossing?
>> Nou ja, zo gewoon te zijn duidelijk, laat me ga je gang
en-- geef me een seconde hier, en zie als ik je kan laten zien de laatste, die
zal in-- eens kijken of ik kan vinden deze echte fast-- OK, [onverstaanbaar].
OK, daar is het.
Dus negeer de commando's ik ben gewoon te typen.
Ik wil het op te halen bij het laatste moment een voorbeeld
van de laatste tijd, die heet nu geen Swap.
>> Dus geen Swap is waar we gebleven waren de vorige keer,
waarbij, geïnitialiseerd I x op 1 en y 2.
Ik roep dan Swap, passeren in 1 en 2.
En dan is deze functie werkte in zekere zin
maar het had geen permanente Effect op de x en y.
Dus de vraag aan de hand is, hoe nu weten we eigenlijk dit probleem op te lossen?
Wat is de oplossing bij de hand?
>> Nou, in swap.c, die nieuw is vandaag de dag, merken een paar verschillen.
x en y gelijk.
Maar wat duidelijk anders over lijn 25?
Wat is er nieuw, als je nog hoe het eruit zag als een tweede geleden?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Ja.
Dus de ampersands zijn een nieuw stuk van syntax, niet alleen in dit programma,
maar ook meer in het algemeen in de CS50.
Tot op heden, ik denk niet dat We hebben voorbeelden gezien
of echt gesproken over hen op enigerlei detail, andere dan, misschien, preemptively
in doorsnede, een ampersand als deze.
Nou, het blijkt ampersand is een van de laatste stukken van nieuwe syntaxis
we gaan om te leren.
Het betekent alleen de adres van een variabele.
Op welk adres hoeft x leven?
Maar wat het adres doet y leven?
Want als de fundamentele probleem voor
werd dat x en y werden doorgegeven zoals kopieën, wat we echt willen doen
wordt voorzien Swap met als een schat map die leidt waar x en y eigenlijk
in RAM, zodat Swap kan die kaart volgen
en ga naar de plaats waar x of y markeert de plek en verander de werkelijke waarden 1 en 2
er.
>> Dus Swap moet ook iets veranderen.
En op het eerste gezicht, deze macht lijkt een beetje vergelijkbaar met char ster.
En inderdaad het is.
Dus een is een pointer naar wat voor soort data, op basis van deze gemarkeerde gedeelte?
Dus het is een int.
>> Dus een is niet langer een int, het is het adres van een int.
En evenzo b gaat nu het adres van een int.
Dus als ik bel nu Swap van Main, Ik ben niet van plan om Swap 1 en 2 geven.
Ik ga om het te geven als Ox-iets en Ox-iets,
twee adressen die zal leiden Swap hun werkelijke locaties
in het geheugen van mijn computer.
>> Dus nu mijn resterende implementatie moet een beetje veranderen.
Wat is uiteraard anders nu in deze drie regels code?
Er is die verdomde sterren alle over de plaats, goed?
Dus wat is hier aan de hand?
Yeah?
>> Publiek: Het is natuurlijk [onverstaanbaar].
>> DAVID J. MALAN: Precies.
Dus in dit context-- en dit niet was het beste ontwerp beslissing, toegegeven,
jaar geleden.
In deze context, waar hoef je alleen maar een ster,
en je hoeft niet een datatype, zoals int, onmiddellijk naar links,
in plaats daarvan heb je een gelijk teken, duidelijk, in deze context, als je zegt dat een ster,
betekent naar de adres dat is in een.
Volg de schatkaart, bij wijze van spreken.
>> En ondertussen, in lijn 37, het betekent hetzelfde.
Ga naar het adres van een, en doe wat er?
Wat er ook aan de locatie die b specificeert.
Met andere woorden, ga naar b.
Krijgen die waarde.
Ga naar een en, per gelijke ondertekenen, de opdracht operator,
zet daar die waarde.
>> Ook int temp is gewoon een int.
Er hoeft niets te veranderen over temp.
Het is gewoon een extra glas uit Annenberg voor wat melk of jus d'orange.
Maar ik moet wel zeggen, ga naar b.
Ga naar die bestemming en zet de waarde in temp daar.
Dus wat gebeurt er dan?
Toen ik daadwerkelijk op te roepen Swap dit moment, als deze eerste bak hier vertegenwoordigt Main,
deze tweede lade vertegenwoordigt Swap, wanneer Ik passeer ampersand x en y ampersand
van Main naar Wisselen, gewoon om duidelijk te zijn, wat is dit stackframe ontvangen?
Yeah?
>> PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Precies.
Het adres van x en het adres van y.
En u kunt denken van deze zoals postadressen.
33 Oxford Street en 35 Oxford Street, en u
willen de twee gebouwen te verplaatsen die op die locaties.
>> Het is een soort van een belachelijk idee, maar dat is alles wat we bedoelen met het adres.
Waar in de wereld kan je die twee ints vinden?
Waar in de wereld kun je die twee gebouwen te vinden?
Dus als eindelijk, na al die tijd I gaan in de huidige broncode en compileren
Swap en run ./swap, ten slotte, voor de eerste keer dat we echt zien dat
mijn waarden inderdaad succesvol verwisseld.
En nu kunnen we zelfs Noteer dit in, zeg, gdb.
>> Dus laat me gaan in hetzelfde bestand.
Laat me ga je gang en lopen gdb van ./swap.
En nu, in Swap, ik ga om te gaan vooruit en stel een breekpunt in de Main.
En nu ga ik om te gaan vooruit en start het programma.
En nu zien we mijn code gepauzeerd op die lijn.
>> Als ik ga je gang en printen x, wat moet ik hier zie?
Het is een vraag.
Weer zeggen?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Dus willekeurige getallen, misschien.
Misschien krijg ik geluk, en het is lekker simpel, net als 0.
Maar misschien is het wat willekeurig getal.
In dit geval, ik heb geluk gehad.
Het gebeurt gewoon te zijn 0.
Maar het is inderdaad geluk, omdat niet totdat ik
typt volgende en vervolgens afdrukken x heeft dat regel code, lijn 19, is uitgevoerd.
>> Ondertussen, naast opnieuw als ik typ, en nu uitprinten y, ik ga om te zien 2.
Nu, als ik typ volgend, gaat het om een beetje verwarrend, want nu,
de printf gaat over lijken het scherm, zoals zij heeft gedaan. x is 1.
>> Laten we dit nog een keer doen.
En nu, hier is waar dingen interessant.
Voordat ik noem Wisselen of zelfs stap in het, laten we een beetje peek.
x is, weer 1.
Y is natuurlijk snel verstand controleren, 2, zodat er hard.
Maar wat is het en-teken x?
Antwoord, het is soort van funky zoekt.
Maar de int ster tussen haakjes is gewoon bbp's manier om te zeggen dit is een adres.
Het is niet een int, het is een pointer naar een int, of ook wel bekend als een adres.
>> Wat is dit gekke ding?
We hebben nog nooit iets gezien heel graag dat vóór.
Dus dit is het adres in mijn computer geheugen van waar x gebeurt te leven.
Het is Ox-iets.
En dit is, eerlijk gezegd, waarom Ik ben begonnen met het tekenen pijlen,
plaats van nummers, omdat die echt cares
dat je int is op een bepaald adres dat is zo groot.
Maar bffff0c4, het zijn allemaal inderdaad hexadecimale cijfers,
die 0 zijn door f.
>> Dus we zijn niet van plan om te wonen lang over wat die dingen zijn.
Maar als ik print y, Natuurlijk zie ik 2.
Maar ampersand y, zie ik dit adres.
En bericht, voor de nieuwsgierigen, hoe ver zijn x en y?
U kunt het grootste deel van het adres negeren.
Vier bytes.
En dat is in overeenstemming met onze eerder beweren dat hoe groot is een int?
Vier bytes.
Zodat het lijkt alsof voering alles omhoog mooi, als je zou hopen, in het geheugen.
>> Dus nu, laten we gewoon snel vooruit aan het einde van dit verhaal.
Laten we verder gaan en typ stap, om te duiken in de functie Swap.
Let nu op, als ik typ een, het is gelijk aan het adres van x.
Als ik typ b, het is identiek aan het adres van y.
Dus wat moet ik zien of ik zeg, ga dan naar het adres van een?
Dus print star een.
Dus ster betekent dat er naartoe te gaan, in deze context.
Ampersand betekent wat is het adres van.
Dus ster een middel 1.
En print star b geeft me 2.
>> En laat me nemen, voor het moment, dat althans de beveiligingscode
gaat nu voeren kan door met redenen omkleed op die manier.
Maar we zullen dit idee opnieuw het duurde niet lang.
Dus deze versie van Swap nu correct en maakt
ons voor dit specifieke type data uitwisselen.
>> Dus vragen dan op Swap?
Op ster?
Op het adres van?
En je zult zien, met probleem set 4, soort,
maar probleem set 5, zeker, hoe deze dingen zijn nuttig en krijgt veel meer
comfortabel met hen, als gevolg.
Helemaal niets?
Oke.
Dus malloc is, nogmaals, deze functie die net wijst geheugen, het geheugen
allocatie.
En waarom is dit nuttig?
Nou, al die tijd, je hebt door hiervan gebruik.
Als je nu hoe overwegen getString werken vermoedelijk het
gevraagd iemand voor een brok van geheugen, wanneer de gebruiker typt een string
in, omdat we zeker wist niet, als CS50 personeel,
hoe groot die strings die de mens zullen typen kunnen zijn.
>> Dus laten we, voor de eerste keer, beginnen te schil terug hoe de CS50 bibliotheek werken,
door middel van een aantal voorbeelden dat zal ons daar leiden.
Dus als ik het openstellen gedit en open scanf 0,
we gaan naar de volgende code te zien.
Scanf 0, beschikbaar op de website voor vandaag de dag, heeft relatief weinig regels code
here, 14 tot 20.
En laten we zien wat het doet.
Het verklaart een int, genaamd x.
Het zegt iets als, nummer aub.
En nu zegt, scanf% i, & x.
Dus er is een heleboel nieuwe dingen daar.
>> Maar scanf, kun je soort van denken van als het tegenovergestelde van printf.
printf natuurlijk drukken om het scherm.
scanf soort scans van de gebruiker toetsenbord iets wat hij of zij heeft getypt.
>> % I is net als printf.
Dit betekent verwachten gebruiker naar een int typen.
En nu, waarom denk je dat ik misschien passeren scanf & x?
Als het doel in het leven van scanf is iets van de gebruiker te krijgen,
wat is de betekenis van de door te geven, en x, nu?
Yeah?
>> PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Precies.
Wat ik, de mens, typt, mijn inbreng zal gered worden op die locatie.
Het is niet voldoende, te herinneren, om gewoon passeren in x, omdat we al hebben gezien,
elke keer als je langs slechts een ruwe variabele, als een int, naar een andere functie,
zeker, het kan dat veranderen variabele, maar niet permanent.
Het kan een effect op de Main niet hebben.
Het kan alleen zijn eigen lokale kopie.
Maar als je daarentegen niet geef mij de werkelijke int,
maar je geeft me een routebeschrijving naar dat int, ik nu, dat scanf,
zeker, kan ik volgen dat pakken en zet er een aantal
zodat je er toegang toe hebben als goed.
>> Dus toen ik dit programma uit te voeren, laten we eens kijken.
Maak scanf 0 dot slash, Scanf 0.
En als ik nu typ een nummer zoals 50, bedankt voor de 50.
Als ik nu een getal als negatieve 1, de negatieve 1.
Ik heb nu een getal zoals 1.5, hm.
Waarom heeft mijn programma negeren me?
Nou, omdat simpelweg, ik vertelde het naar een int alleen verwachten.
Oke.
Dus dat is een versie van deze.
Laten we de dingen nemen een inkeping en stellen dat dit niet goed is.
En hierin ligt een heel eenvoudig voorbeeld van hoe we het schrijven van code kan beginnen
dat andere mensen kunnen exploiteren of compromitteren door het doen van slechte dingen.
Dus lijn 16, dus vergelijkbaar in geest vóór,
maar ik ben niet te verklaren dat int deze tijd.
Ik verklaar het char ster, aka string.
>> Maar wat betekent dat eigenlijk?
Dus als ik niet een address-- specificeren en Ik willekeurig noemde het, buffer,
maar ik zou kunnen noemen het s, simple-- te zijn en dit dan doen ik, mij uitleggen,
als je zou kunnen, op basis van de vorige logica, wat scanf doen op lijn 18,
Als pas% s en buffer, dat is een adres?
Wat is scanf, als u van toepassing zijn de exact dezelfde logica als versie 0,
ga proberen om hier te doen, wanneer de types gebruiker iets in?
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Precies.
Scanf door de logica eerder gaat de string te
dat het menselijk getypte in-- het is nu een string,
het is niet een aantal, vermoedelijk, als hij of zij cooperates--
en het gaat om te proberen om dat te zetten tekenreeks in het geheugen op welk adres
buffer specificeert.
En dit is geweldig, omdat buffer inderdaad bedoeld om een ​​adres.
>> Maar ik beweren dat dit programma is buggy in een zeer serieuze manier, want wat waarde is
buffer standaard?
Wat heb ik geïnitialiseerd in?
Welke brok van geheugen?
Ik heb niet, toch?
>> Dus ook al heb ik toegewezen een char ster die niet meer heet s,
het is in plaats daarvan riep, buffer-- dus laten we trekken de naam van de variabele
nu als buffer-- als ik niet riep getString of malloc hier,
die effectief betekent dat buffer is slechts enkele garbage waarde.
>> Nu, wat betekent dat?
Het betekent dat ik scanf heb verteld om een ​​string van de gebruiker verwacht.
En weet je wat?
Wat dit ding wijst om-- en ik teken een vraagteken,
maar in werkelijkheid gaat het om iets als OX1, 2, 3, toch?
Het is een aantal nep-waarde die net gebeurt er van tevoren.
Dus met andere woorden, het is alsof buffer net
naar iets in het geheugen.
Ik heb geen idee wat.
>> Dus als ik typ in Gabe nu, het gaat om te proberen om de g-a-b-e / 0 daar te zetten.
Maar wie weet wat dat is?
En in het verleden, elk keer dat we hebben geprobeerd aan te raken
geheugen dat niet van voor ons, wat is er gebeurd?
Of bijna elke keer.
Segmentatie fout, toch?
>> Deze pijl, ik heb geen idee waar het is wijzen. het is gewoon wat willekeurige waarde.
En natuurlijk, als je interpreteren een willekeurige waarde als een adres,
je gaat naar wat willekeurige bestemming.
Dus gabe zou inderdaad crash mijn programma in dit geval hier.
>> Dus wat kunnen we doen, dat is bijna net zo erg?
Beschouw dit derde en laatste voorbeeld van scanf.
Deze versie is beter in welke zin?
Als u vertrouwd bent met het zijn previous probleem, dit is beter.
Waarom?
>> PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Goed.
Dus dit geval leiding 16 beter, in de zin
dat we expliciet toewijzen van wat geheugen.
We zijn niet door hiervan gebruik, we gebruiken de week 2
aanpak waarbij slechts een array.
En we hebben al eerder gezegd dat een string is gewoon een reeks van tekens,
dus dit is volkomen legitiem.
Maar het is natuurlijk, als u er rekening mee, vaste grootte, 16.
>> Dus dit programma is volkomen veilig, als ik typ
in een tekenreeksen, twee karakter strings, 15 tekenreeksen.
Maar zodra ik begin te typen 16, 17, 18, 1000 tekenreeksen,
waar is die string gaat eindigen?
Het zal uiteindelijk deels hier.
Maar dan wie weet wat nog meer is buiten de grenzen
van dit matrix?
>> Het is alsof ik heb 16 dozen hier verklaard.
Dus in plaats van te trekken uit alle 16, zullen we net doen alsof dat ik getekend heb 16.
Maar als ik dan proberen om een ​​string te lezen dat is veel langer, zoals 50 tekens,
Ik ga om te beginnen met het opzetten a, b, c, d, x, y, z.
En dit is vermoedelijk sommige andere geheugen-segment
dat weer kan leiden mijn programma crasht,
want ik heb niet gevraagd om iets meer dan 16 bytes.
>> Dus who cares?
Nou, hier is de CS50 bibliotheek.
En de meeste van deze is gewoon zoals instructies boven.
De CS50 bibliotheek, al die tijd, heeft deze regel in regel 52 had.
We hebben typedef gezien, of je zult typedef zien
in PSET 4, die net creëert een synoniem waarbij char ster meer kan zijn
simpelweg aangeduid als string.
Dit is een van de paar zijwieltjes
we hebben in het geheim gebruikt onder de motorkap.
>> Ondertussen, hier is de functie, getchar.
Nu blijkbaar is er geen lichaam aan.
En in feite, als ik blijf scrollen, dat doe ik eigenlijk niet
zie geen implementaties van deze functies.
Als een sanity check, waarom is dat?
>> PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Ja.
Dus dit is de header file.
En header bestanden bevatten prototypes, plus een aantal andere dingen, zo lijkt het,
zoals typedefs.
Maar in CS50.c, die we hebben je nooit ronduit gegeven,
maar is in de CS50 apparaat alle deze keer diep in de mappen
merken dat er een hele bos van functies in hier.
>> In feite, laten we naar beneden scrollen.
Laten we negeren de meeste van hen, voor nu.
Maar scroll naar beneden naar getInt en zie hoe getInt werkt.
Dus hier is getInt.
En als je ooit echt om hoe krijgen int werkt, hier is de documentatie.
En onder de dingen het zegt is het u vertelt
wat de reeksen van waarden kan terugkeren.
Het is in wezen negatief 2000000000 om positieve 2 miljard, geven of nemen.
>> En het blijkt, dit alles tijd, ook al hebben we nog nooit
had u controleren op het, als er iets misgaat,
het blijkt dat alle deze keer getInt heeft
terug te keren speciale constant, niet nul,
maar INT_MAX, die conventie slechts een programmeur.
Het betekent dat hier een bijzondere waarde.
Zorg ervoor om te controleren of deze, net in het geval er iets misgaat.
Maar we hebben nooit de moeite genomen met dat tot op heden,
want nogmaals, dit is bedoeld te vereenvoudigen.
>> Maar hoe werkt getInt krijgen geïmplementeerd?
Nou ja, een, het heeft geen argumenten.
We weten dat.
Het geeft een int.
We weten dat.
Dus hoe werkt het onder de motorkap?
>> Dus er is blijkbaar een oneindige lus, ten minste erop lijken.
Merk op dat we gebruiken getString.
Dus dat is interessant. getInt noemt onze eigen functie, getString.
En nu, wat zou dit het geval zijn?
Waarom ben ik defensief here in lijn 165?
Wat er kan gebeuren in de lijn 164, voor de duidelijkheid?
Het is hetzelfde antwoord als voorheen.
Misschien wel uit het geheugen.
Er iets mis gaat met getString, we moeten in staat zijn om te behandelen dat.
En de reden dat ik niet terug null is dat, technisch gezien, null is een pointer.
getInt moet een int terug.
Dus ik heb willekeurig besloten, in wezen,
dat 2 miljard, geven of te nemen, gaat een bijzondere waarde zijn, dat kan ik nooit
daadwerkelijk te krijgen van de gebruiker.
Het is gewoon de ene waarde ik ga te verspillen om een ​​foutcode te vertegenwoordigen.
>> Dus nu, dingen een beetje fantasie.
En het is niet helemaal dezelfde functie als voorheen, maar het is zeer vergelijkbaar.
Dus merken, verklaar ik hier, in lijn 172, beide een int n en een char c.
En dan dit funky lijn gebruik ik, sscanf, dat blijkt
scant niet een string van het toetsenbord.
Het staat een bestaande string die de gebruiker al heeft getypt.
Dus ik al getString, genaamd die betekent dat ik een string in het geheugen.
sscanf is wat je zou bel een parsing functie.
Er wordt gekeken naar de string Ik heb ingetypt, teken voor teken,
en doet iets nuttigs.
Deze reeks wordt opgeslagen in lijn.
En ik weet dat alleen door te gaan een back-up hier en zeggen: oh, OK,
Ik noemde het niet en deze keer, maar lijn.
>> En nu dit is een beetje anders.
Maar dit in feite betekent, om redenen we enigszins zwaaien handen om vandaag,
dat we de controle te of de gebruiker getypt
en int en misschien een ander karakter.
Als de gebruiker heeft ingevoerd in een int, is het zal worden opgeslagen in n, omdat ik
langs deze op adres, de nieuwe truc die we hebben gezien vandaag.
Als de gebruiker ook getypt in als 123x, dat x
gaat uiteindelijk een brief in teken c.
>> Nu blijkt dat sscanf zal mij zeggen, intelligent,
hoeveel variabelen werd sscanf succesvol kunnen vullen.
Dus deze logica, als de functie Ik uitvoering wordt getInt,
maar ik ben het controleren, potentieel voor de gebruiker
in een int te hebben getypt gevolgd door iets anders,
wat wil ik sscanf's return waarde echt te zijn?
Als het doel is om gewoon een int van de gebruiker?
>> Dus als sscanf rendement 2, wat betekent dat?
De gebruiker heeft ingevoerd in iets als, letterlijk,
123x, dat is gewoon onzin.
Het is een fout, en Ik wil controleren dat.
>> Als de gebruiker dit type in, door deze logica, wat doet sscanf terugkeren,
zou je dan zeggen?
Dus het gaat om terug te keren 2, omdat de 123 gaat hier naar binnen gaan,
en de x gaat eindigen in hier.
Maar ik wil niet dat de x om te laten vullen.
Ik wil sscanf alleen slagen in vullen van de eerste van de variabelen.
En dat is dus de reden waarom ik willen sscanf om terug te keren 1.
>> En als dit een beetje over het hoofd voor het moment, dat is helemaal prima.
Realiseer je echter dat een van de waarden van getInt en getString
is dat we doen een deurklink van een Veel foutcontrole als dit zo
dat tot op heden, kan je vrij veel typt iets op je toetsenbord,
en wij zullen het op te vangen.
En we hebben zeker de personeel, zal zeker niet
als bron van een bug in de programma, omdat we defensief
het controleren van alle van de domme dingen die een gebruiker zou kunnen doen,
zoals het typen van een koord, wanneer je echt wilde int.
Dus voor nu-- we komen terug naar deze vóór long--
maar deze tijd, getString en getInt hebben
onder de kap met deze geweest basisidee van adressen van geheugen.
>> Dus nu, laten we de dingen een weinig meer gebruiksvriendelijk.
Zoals u zich wellicht herinnert, van Binky laatste tijd-- als mijn muis zal dus cooperate--
we hadden deze code, die eerlijk gezegd, is tamelijk onzinnig.
Deze code haalt niets nuttig, maar het was het voorbeeld
dat professor Parlante gebruikt om te vertegenwoordigen
wat er gaande was in een programma met het geheugen.
>> Dus laten we dit navertellen verhaal super kort.
Deze eerste twee regels, in Engels, doe wat, zou je dan zeggen?
Gewoon in redelijk mens, maar enigszins technische termen, neem een ​​steek.
PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: OK, je bent tot oprichting van adressen voor x en y variabelen.
Niet helemaal omdat x en y niet variabelen in de traditionele betekenis.
x en y adressen of zal het adres op te slaan.
Dus laten we proberen dit eens te meer.
Geen slecht begin, dat wel.
Yeah?
>> PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Goed.
Ik denk dat dat een beetje schoner.
Verklaren van twee pointers, twee gehele getallen.
En we bellen ze x en y.
Of als we waren te stellen dit als een foto, weer,
herinneren simpelweg dat alle we doen met die eerste lijn
is het tekenen van een doos als deze, met garbage waarde in,
en noemde het x, en dan een andere doos als dit,
met garbage waarde in het, noemde het y.
We hebben verklaard twee pointers die uiteindelijk
het adres van een int slaan.
Dus dat is er allemaal.
>> Dus toen Binky deed dit, de klei net zo uitzag.
En Nick gewoon een soort van verpakt de pijlen,
alsof ze nergens te wijzen in het bijzonder, want ze zijn gewoon
garbage waarden.
Ze zijn niet expliciet geïnitialiseerd overal in het bijzonder.
>> Nu de volgende regel code, recall, was dit.
Dus in redelijk gebruiksvriendelijk, maar enigszins technisch Engels,
wat is deze regel code aan het doen?
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> DAVID J. MALAN: Perfect.
Het toewijzen van de brok van de geheugen dat is de grootte van een int.
En dat is de helft van het antwoord.
U antwoordde de rechter helft van de expressie.
Wat er gebeurt op de linkerkant van het gelijk-teken?
Yeah?
PUBLIEK: En rechtverkrijgenden het aan de variabele x?
>> DAVID J. MALAN: En rechtverkrijgenden aan de variabele x.
Dus om samen te vatten, rechterzijde toewijst voldoende geheugen om een ​​int slaan.
Maar malloc specifiek geeft het adres
van dat deel van het geheugen, die je hebt net voorgesteld wordt opgeslagen in x.
>> Dus wat Nick deed de vorige keer met Binky is hij sleepte die wijzer uit, de klei,
Tot nu toe wijzen op een wit stuk van het geheugen die gelijk is aan de grootte van een int.
En inderdaad, dat is bedoeld vier bytes vertegenwoordigen.
>> Nu, de volgende regel code dit deed, ster x krijgt 42.
Dus 42 is eenvoudig op de rechterzijde, betekenis van het leven.
Linkerkant, ster x betekent wat?
Ook dat zou kunnen hebben gone-- dat is OK.
OK.
>> PUBLIEK: In principe, ga naar de [onverstaanbaar]
DAVID J. MALAN: Goed.
PUBLIEK: [onverstaanbaar].
DAVID J. MALAN: Precies.
Linkerkant betekent ga naar x.
x is het adres.
Het is net als 33 Oxford Street, of OX1.
En ster x betekent naar die aan te pakken en zetten wat daar?
42.
>> Dus inderdaad, dat is precies wat Nick deed.
Hij begon met door, wezen, mentaal
wijst een vinger naar x, na de pijl
naar de witte doos op de rechter kant, en zetten het nummer 42 er.
Maar toen kreeg de dingen een beetje gevaarlijk, toch?
Binky's over zijn hoofd te verliezen.
>> Star y is gelijk aan 13, pech, betekent wat?
Dus ster y middelen gaan naar het adres in y.
Maar wat is het adres in y?
Oke, het is garbage waarde, toch?
Ik trok het als een vraagteken.
Nick trok het als een opgerold pijl.
En zodra je probeert te doen ster y, zeggen ga er,
maar er is geen legitieme adres, het is een nep-locatie,
het programma gaat crashen.
En Binky's hoofd gaat om hier weg te vliegen, zoals zij heeft gedaan.
>> Dus op het einde, dit programma was ronduit fout.
Het was een buggy programma.
En het moest worden opgelost.
En de enige manier, echt, om het te repareren zou bijvoorbeeld deze regel,
die we niet eens aan, omdat het programma crashte te vroeg.
Maar als we dit op te lossen, wat effect heeft doen y gelijk x hebben?
Nou, het wijst in wezen y op welke waarde x wijst.
>> Dus in Nick's verhaal, of Binky's verhaal, zowel
x en y werden wijzend op het witte deel van het geheugen,
zo dat, ten slotte, wanneer u denk ster y is gelijk aan 13 weer,
je uiteindelijk zetten 13 in de juiste locatie.
Dus al deze lijnen zijn perfect legitiem, behalve deze ene,
toen het gebeurde voordat u werkelijk toegekende y een waarde.
>> Nu gelukkig, je doet niet moeten redeneren door alle
van dit soort problemen op uw eigen.
Laat me gaan en openen een terminal-venster hier
en open te stellen, voor een ogenblik, een super kort programma dat
Ook is een soort van zinloos.
Het is lelijk.
Het hoeft niet iets nuttigs te bereiken.
Maar het toont wel aan problemen van het geheugen, dus laten we een kijkje nemen.
>> Belangrijkste, super eenvoudig.
Het roept blijkbaar een functie, f, en dan is het resultaat 0.
Het is een beetje moeilijk te verpesten.
Dus Hoofd is vrij goed, tot nu toe.
>> Dus f is problematisch.
En gewoon niet veel zetten inspanning in het benoemen van het
hier, om de focus op de code te houden.
f heeft twee lijnen.
En laten we eens kijken wat er nu gaande is.
Dus enerzijds hier-- en laat me
Dit strookt met de vorige example-- enerzijds,
de linkerkant is doet wat, in het Engels?
Het is--
Publiek: Het creëren van een pointer.
DAVID J. MALAN: Het maken van een pointer naar een int en noemde het x.
Dus het is het creëren van een van die dozen Ik blijf het tekenen op het aanraakscherm.
En nu, op de rechter zijde malloc natuurlijk
wordt de toewijzing van een deel van het geheugen.
En alleen maar om duidelijk te zijn, hoe veel geheugen is het blijkbaar
toewijzen, als je gewoon soort van de wiskunde hier?
>> Dus het is 40 bytes.
En ik weet dat alleen omdat ik weet dat een int op CS50 apparaat tenminste
vier bytes.
Dus 10 keer 4 is 40.
Dus dit is het opslaan van een x, het adres van de eerste van de 40 ints dat
zijn toegewezen ruimte terug, naar achter, naar achter, naar achteren.
>> En dat is wat er sleutel over malloc.
Het hoeft niet een beetje geheugen nemen hier, een beetje hier, een beetje hier.
Het geeft je een stuk van het geheugen, aansluitend, van de operationele
systeem.
>> Nu wat over deze, x beugel 10 is gelijk aan 0?
Arbitraire regel code.
Het hoeft niet iets nuttigs te bereiken.
Maar het is interessant, omdat x beugel 10--?
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAVID J. MALAN: x beugel 10 hoeft niet nul te zijn.
De null detail komt pas in het spel strijkers aan het einde van een koord.
Maar een goede gedachte.
>> Hoe groot is deze array, zelfs hoewel ik 40 bytes heb toegewezen?
Het is 0 tot en met negen, toch?
Het is 10 ints, totaal.
40 bytes, maar 10 ints, geïndexeerd 0 tot 0.
>> Dus wat is dat x beugel 10?
Het is eigenlijk een aantal onbekend garbage waarde.
Het is het geheugen dat niet van mij.
Ik moet niet te raken dat byte nummer 41, 42, 43, 44.
Ik ben een beetje te ver gaan.
>> En inderdaad, als ik zonder deze programma, kan het heel goed crashen.
Maar soms hebben we geluk.
En dus gewoon om aan te tonen dit-- en eerlijk gezegd,
je weet maar nooit voordat u denk het-- laten we dit uit te voeren.
Het maakte eigenlijk niet crashen.
>> Maar als ik dit wijzigen voor Zo zijn zoals 1000,
om dit echt te maken weloverwogen, laten we eens kijken
als we kunnen krijgen om deze tijd te crashen.
OK, het niet crashen.
Hoe zit het met 100.000?
Laten we remake, en nu start het opnieuw op.
OK.
Oef.
Oke.
Dus lijkt, weer, deze segmenten geheugen zogezegd,
zijn redelijk groot, dus we kunnen krijgen opnieuw en opnieuw geluk.
Maar uiteindelijk, als je eenmaal belachelijk krijgen en echt ver uit op het scherm,
u het geheugen aanraakt dat echt, echt niet van jou is.
>> Maar eerlijk gezegd, deze allerlei bugs gaan
harder en harder om erachter te komen op uw eigen.
Maar gelukkig, zoals programmeurs, hebben we tools die ons toelaten om dit voor ons te doen.
Dus dit is misschien een van de lelijkste programma's,
nog lelijker dan uitgang gdb's.
Maar het heeft altijd een lijn of twee die super nuttig.
>> Valgrind is een programma dat helpt niet debuggen programma, zodanig,
maar vind het geheugen-gerelateerde problemen bijzonder.
Het zal automatisch uw code uit te voeren voor u en op zoek naar ten minste twee dingen.
Een, heb je iets te doen ongeluk zoals aanraking geheugen
dat niet van jou is?
Het zal u helpen vinden die gevallen.
>> En twee, zal het helpen je iets genaamd vinden
memory leaks, die we hebben volledig genegeerd, naïef,
voor enige tijd en zalig.
Maar het blijkt, alle deze keer wanneer
je getString in moeten bellen zo veel van onze programma's,
U bent de operationele vragen voor geheugen,
maar je moet elke herinnering van ooit waardoor het
terug, doet UNALLOC, of gratis, zoals dat heet.
Nee, want we hebben nooit gevraagd om dit te doen.
>> Maar al die tijd, de programma's heb je geschreven in C
zijn lekkende geheugen, het stellen van de operationele
systeem voor meer en meer geheugen voor strijkers en wat al niet,
maar nooit inlevert terug.
En nu is dit een beetje van een oversimplificatie,
maar als je ooit hebt draaien op je Mac of uw pc al geruime tijd, opening
veel programma's, misschien is het sluiten van programma's,
en zelfs al is uw computer is niet gecrasht,
het wordt zo veel langzamer, alsof het is echt
met veel geheugen of middelen, hoewel,
als je niet eens aanraken van het toetsenbord,
dat kan be-- maar niet always-- konden zijn dat de programma's die je draait
hebben zelf memory leaks.
En ze blijven vragen van de OS voor meer en meer geheugen, maar vergeet het,
eigenlijk niet te gebruiken, maar Daarom nemen geheugen weg
vanuit andere programma's zou willen dat het.
Dus dat is een gemeenschappelijke verklaring.
Nu hier is waar Valgrind's output volledig
afschuwelijk om die minder en comfortabeler gelijk.
Maar het interessante spul is hier rechts boven.
Het is me te vertellen een ongeldige schrijven van grootte vier gebeurt in dit programma,
in het bijzonder, op regel 21 van memory.c.
>> Als ik ga naar lijn 21, hm, er inderdaad is een ongeldig schrijven van grootte vier.
Waarom grootte vier?
Nou, dit number-- en het anything-- zou kunnen zijn is een int.
Dus het is vier bytes.
Dus ik ben om vier bytes waar ze niet thuishoren.
Dat is wat Valgrind is me eigenlijk te vertellen.
Bovendien zal ook vertel me, zoals we zullen zien,
als je dit uitvoeren in een toekomstige PSET, indien en als je hebt gelekt geheugen, dat inderdaad
Ik heb, want ik heb genoemd malloc, maar ik heb niet echt
genoemd, in dit geval, vrij, waar we uiteindelijk zien
is het tegenovergestelde van malloc.
>> Dus nu, denk ik, een laatste voorbeeld.
Dus dit is een beetje meer geheimzinnige, maar het is misschien
de belangrijkste reden Wees voorzichtig met het geheugen,
en de reden dat vele programma en / of webservers, zelfs tot op de dag,
worden overgenomen door slechteriken ergens op het internet die ergens
het verzenden van valse pakketten naar uw server proberen om uw rekeningen compromis,
of neem uw gegevens, of gewoon algemeen gedurende een zekere machine.
Buffer overflow, zoals de naam al doet vermoeden, middelen
overlopen geen int, maar een buffer.
En een buffer is gewoon een mooie manier om te zeggen het is een stelletje van het geheugen.
>> En inderdaad, ik belde een string voordat buffer, in plaats van s.
Want als het een buffer, net als in de YouTube zin,
of wanneer je aan het kijken bent een video, je zou het woord buffering hebben gezien,
dot, dot, dot.
Het is ongelooflijk vervelend.
En dat betekent dat je videospeler
probeert om veel te downloaden bytes, veel bytes
van een video van het internet.
Maar het is traag, dus het is het proberen om een ​​bos van hen te downloaden
een buffer, een container, zodat vullen je hebt genoeg bytes dat het kan dan
tonen u de video, zonder te pauzeren voortdurend.
Maar het blijkt, je kan een buffer om zo groot.
Maar probeer dit zoveel data in te zetten het, en zeer slechte dingen kunnen gebeuren.
Dus bijvoorbeeld, laten we eens kijken naar deze laatste teaser een voorbeeld.
Dit is een ander programma die, op het eerste gezicht,
doet niets super handig doen.
Het heeft een Hoofd functie dat noemt die functie, f.
En die functie, f, hier, heeft een char array, genaamd c, van maat 12.
En dan is het gebruik van dit nieuwe functie genaamd strncpy.
>> Het blijkt dat met deze eenvoudige, eenvoudige regel code, slechts twee lijnen,
we hebben mijn hele programma gemaakt, en daarom, mijn hele computer,
en mijn gebruikersaccount, en mijn harde rijden mogelijk kwetsbaar voor iedereen
die weet en goed genoeg draaien dit programma een bepaald opdrachtregel
argument.
Met andere woorden, als deze slechte guy zet binnenkant van argvargv [1] door te typen
op het toetsenbord van een zeer speciaal vervaardigd koord, niet abc, 123, maar in wezen,
binaire symbolen die uitvoerbare vertegenwoordigen code, een programma dat hij of zij schreef,
met dit eenvoudig programma, dat vertegenwoordiger van duizenden programma
die zijn eveneens kwetsbaar zijn, durf te zeggen, hij kan uiteindelijk Wissen
de bestanden op mijn harde schijf, krijgen een knipperende prompt zodat hij of zij kan
typen commando's op hun eigen, e-mail van alle bestanden bij mezelf.
Alles wat ik kan doen, hij of ze kan doen met deze code.
>> We zullen nog niet helemaal dit op te lossen.
En in feite gaat het om betrekken een kleine afbeelding
als dit, waar we zullen snel komen alle beter te begrijpen.
Maar voor vandaag, laten we eindigen op wat is er, hopelijk, een iets meer
begrijpelijk XKCD grap, tot we weer de volgende keer.
Oke.
Tot ziens op woensdag.
>> [Muziek]
>> Spreker: En nu, diep gedachten, door Daven Farnham.
Geheugen is als het springen in een stapel gouden bladeren op een zondagmiddag.
Wind waait, gooien uw hair-- oh, ik mis de dagen when--
>> [Lachen]