>> [Muziek]
>> DAVID J. Malan: Oke.
>> [Lachen]
>> Welkom terug.
Dit is CS50.
En dit het einde van de week vijf.
En tot nu toe, we hebben vrij veel het nemen van uit dat er
bestaat deze compiler, Clang, dat je hebt zijn beroep via deze
andere tool genaamd Zorg dat een of andere manier magisch zet uw broncode
in object code, de nullen en enen dat uw computers CPU, centrale
verwerkingseenheid daadwerkelijk begrijpt.
Maar het blijkt dat er een aantal dat is gaande onder de motorkap in
tussen ingang en uitgang.
>> En ik zou willen dat we vlees voorstellen dat in iets meer detail in
deze vier stappen, hebben iets genaamd pre-processing, iets
genaamd compileren, hetgeen wij gezien hebben, iets genaamd assembleren, en
iets genaamd koppelen.
Dus tot nu toe in sommige van onze programma's, we hebben gehad scherpe omvat.
Meer recent hebben we een aantal scherpe definieert voor constanten.
Dus het blijkt dat die dingen die worden voorafgegaan door de hekje of
het symbool dat zijn pre-processor richtlijnen.
Dat is gewoon een mooie manier om te zeggen dat het een regel code die eigenlijk
omgezet in iets anders voordat de computer probeert zelfs om te zetten uw
programma in nullen en enen.
>> Bijvoorbeeld, scherpe bevat standaard I / O. H, vrij veel betekent gewoon gaan
vooruit, de inhoud van de bestanden grijpen stdio.h en plak ze daar.
Dus geen nullen en enen op nog dat punt.
Het is eigenlijk gewoon een wissel.
En dat is gebeurd tijdens de zogenaamde pre-processing fase, wanneer u
eigenlijk Clang rennen of specifiek Maken in de meeste gevallen.
Dus dit alles is gebeurd eerst automatisch tot nu toe.
>> Dan komt de compilatie stap.
Maar we hebben oversimplified compilatie.
Het samenstellen van een programma werkelijk betekent om neem het van iets als C, de
broncode hebben we schrijven, omlaag om iets te heet montage.
Assembler is een lager niveau taal die, gelukkig, zullen wij niet
hebben veel gelegenheid om schrijft dit semester.
Maar het is op het laagste niveau in de zin dat je letterlijk begint te schrijven
optellen en aftrekken en vermenigvuldigen en te laden uit het geheugen en het geheugen op te slaan, de
zeer eenvoudige instructies die een computer, onder de motorkap,
daadwerkelijk begrijpt.
>> Tenslotte assembleren neemt die taal de nullen en enen die we geweest
tot nu toe beschreven.
En echt tot slot, is er de zogenaamde koppelen fase, die we zullen
zien in slechts een moment, dat combineert je nullen en enen met nullen en
die andere mensen voor u hebt gemaakt.
>> Dus beschouw dit super eenvoudig programma.
Het was van week 1.
Het zei alleen, Hello World, op het scherm.
We liepen deze via Clang.
Of we liepen het door Make die Clang liep.
En uitgevoerd op het moment waar aantal nullen en enen.
Maar het blijkt dat er een tussenstap.
Als ik ga hierheen - oeps, niet wil hem nog zien.
Als ik ga hier naar mijn toestel en ik open hello.c, hier
is dat hetzelfde programma.
En wat ik ga doen in mijn terminal raam hier wordt ik ga
run Clang plaats maken, die automatiseert alle vier van
die stappen voor ons.
En ik ga clang-S te doen en dan hello.c en voer.
>> En ik krijg een knipperende prompt nogmaals, dat is goed.
En nu in een iets groter scherm, Ik ga openstellen gedit in hier.
En ik ga het openen van een bestand dat, blijkt, wordt hello.s dit heet
bevat dat assembler Ik verwees naar eerder.
En dit is wat er aan de assemblage genoemd taal, vrij laag niveau
instructies die uw Intel-processor of wat het ook is dat er in zit
begrijpt.
En mov is voor de verhuizing. oproep is voor bellen, een zeer laag niveau functioneren.
sub is voor aftrekken.
>> Dus als je een bepaalde CPU binnen van uw computer, wat maakt het
onderscheiden, versus andere CPU's op de markt, is die instructies het
begrijpt en vaak hoe efficiënt het is, hoe snel het is bij het uitvoeren van een aantal
van deze instructies.
Nu voor meer informatie over deze, kunt u volgende Fall CS61 bij het college.
Maar hier hebben we, bijvoorbeeld, een paar identifiers die bekend zou kunnen zien.
hello.c is de naam van het programma.
>> . Tekst -
er is niet veel van belang zijn juist nu, herinneren dat de tekst
segment vanaf maandag, is die waarbij in geheugen van uw programma daadwerkelijk eindigt.
Dus dat is op zijn minst vaag vertrouwd zijn.
Hier is natuurlijk een vermelding van onze functie.
Scrollen naar beneden, deze verwijzen naar zaken zogenaamde registers, zeer kleine stukjes
geheugen binnenkant van uw werkelijke CPU.
En als ik naar beneden scrollen zelfs verder, zie ik een soort
indirecte vermelding van ASCII.
En daar, inderdaad, is die string, hello, komma, wereld.
>> Dus lang verhaal kort, dit is gebeurt voor u, automatisch,
onder de motorkap al die tijd.
En wat er gebeurt is echt een keer je heb geen Clang, of door middel van
Zorg, dat je eerst krijgt, uit de broncode, de
zogenaamde assembler.
Dan Clang wordt deze vergadering omzetten taal naar nullen en enen.
En dit is de dia die we begonnen onze discussie in week 0 op -
en dan week 1 op.
En dan tot slot, die nullen en enen gecombineerd met nullen en enen
van die bibliotheken hebben we zo voor lief zoals Standard I / O of de
String Library of zelfs de CS50 bibliotheek.
>> Dus om deze foto meer te schilderen visueel, hebben we hello.c.
En, natuurlijk, gebruikt printf functioneren te zeggen, hallo wereld.
De compilatie stap duurt het naar beneden om dat bestand we net zagen hello.s, zelfs
maar dat is meestal verwijderd automatisch voor u.
Maar dat is de assembly code in het midden stap.
En toen we monteren de montage taal, om zo te zeggen, dat is wanneer je
krijgen die nullen en enen.
Dus we hebben ingezoomd effectief vandaag wat we hebben als vanzelfsprekend,
betekent gaat broncode de objectcode.
>> Maar ten slotte, nu dat hetzelfde beeld - laten we schuiven het over aan
de linkerkant.
En merken dat in de top is er Ik noemde stdio.h.
Dat is een bestand dat we hebben opgenomen in bijna alle
programma's die we hebben geschreven.
En dat is het bestand waarvan de inhoud word geplakt exemplaar,
effectief bovenop uw code.
Maar het blijkt dat, op een computer systeem ergens, is er vermoedelijk een
stdio.c bestand dat iemand jaren schreef geleden dat alle van de uitvoering
functies die werden verklaard in stdio.h.
>> Nu in werkelijkheid is het waarschijnlijk niet op je Mac of je PC of zelfs in de
CS50 apparaat is een rauwe C-code.
Iemand het al samengesteld en opgenomen . O-bestand voor objectcode of. Een
bestand, dat verwijst naar een gedeelde bibliotheek dat is al vooraf geïnstalleerd en
vooraf voor u samengesteld.
Maar stel dat er inderdaad sprake op onze computer stdio.c parallel
met Clang.
Uw code is gecompileerd en gemonteerd.
code stdio.c 's wordt samengesteld en geassembleerd, waardoor deze laatste
stap, hier beneden, we moeten een of andere manier koppeling, om zo te zeggen, je nullen en enen
met zijn of haar nullen en enen in een eenvoudig programma dat uiteindelijk is
riep net Hallo.
>> Dus dat is al de magie die is tot nu toe is gebeurd.
En zal blijven om deze te nemen processen voor verleend, maar besef
er is een hoop sappige details gaande eronder daar.
En dit is wat maakt uw computer met Intel inside
bijzonder onderscheiden.
>> Zodat op die opmerking, als je wilt bij ons voor de lunch deze vrijdag, doen gaan
aan de gebruikelijke plaats cs50.net/rsvp, 13:15 deze vrijdag.
En nu een paar mededelingen.
Dus we hebben goed nieuws.
En we hebben slecht nieuws.
Begin met wat goed nieuws hier.
>> [Kreunen]
>> Oke.
Nou, het is technisch gezien een vakantie, dus het is niet zozeer een gift van ons.
Maar dan het slechte nieuws natuurlijk.
>> [Kreunen]
>> Ik besteed veel tijd Op deze animaties.
>> [Lachen]
>> Er zal een evaluatie sessie deze komende maandag.
Het zal worden op 5:30.
Wij zullen u eraan herinneren van al deze gegevens via e-mail op de cursus
website in slechts een paar dagen tijd.
Het zal worden gefilmd en beschikbaar gesteld kort daarna.
Dus als je niet kunt maken dat maandag nacht-slot, maak je geen zorgen.
Secties deze komende week zal ook richten op review voor de quiz.
Als uw afdeling is op maandag, dat is inderdaad universiteit vakantie, zullen we
nog steeds voldoen in paragraaf.
Als je gewoon niet kunt maken dat sectie want je gaat
weg, dat is prima.
Woon een zondag of dinsdag sectie of om tune-in paragraaf Jason's, dat is
online beschikbaar.
>> Dus, meer slecht nieuws.
Dus volgens de syllabus, we hebben lezing volgende week vrijdag.
Maar het goede nieuws -
duidelijk, ik heb te veel tijd aan deze.
>> [Lachen]
>> We zullen volgende week vrijdag de colleges te annuleren.
Dus dat zal een geschenk voor ons zijn, dus je kan echt een leuke onderbreking in
tussen deze week en twee weken later plaatsvindt.
Dus geen lezingen volgende week, maar een klein kleine quiz, waarvoor u moet zijn
raken steeds meer opgewonden.
>> Dus laten we nu onze aandacht richten op iets dat inderdaad visuele
en nog veel meer spannende en om het podium voor wat gaat worden op de horizon
in slechts een paar weken tijd.
Na de eerste quiz, gaan we over de richten van ons probleem sets naar een andere
domeinspecifieke probleem, dat van de forensics of veiligheid meer in het algemeen.
>> In feite, de traditie met dit probleem set is voor mij een van de
onderwijzen collega of CA's te lopen over campus nemen van enkele foto's van
herkenbaar maar niet voor de hand liggende mensen, plaatsen of dingen, dan is ieder jaar I
een of andere manier in slagen om per ongeluk verwijderen of corrupt de digitale mediakaart
dat is de binnenkant van onze camera.
Maar geen big deal.
Ik kan gaan en stekker dat in mijn computer.
Ik kan een forensisch afbeelding van te maken, zodat te spreken, door het kopiëren van de nullen en
degenen off van dat de geheugenkaart, of zijn van een SD-kaart of een compact flash kaart of
wat je bent vertrouwd met.
En dan kunnen we de hand dat uit.
>> En dus de komende uitdaging, onder andere dingen voor je, zal zijn om te schrijven
C code die een hele hoop herstelt JPEG's voor mij en geopenbaard zal worden
die mensen, plaatsen of dingen.
En we zullen het ook hebben, in dit probleem ingesteld en in de dagen te komen, over
graphics meer in het algemeen.
We hebben ze gebruikt, een cursus, voor uitbreken.
Maar je hebt soort van vanzelfsprekendheid bestaat deze begrippen hoog niveau
rechthoeken en ovalen.
Maar onder de motorkap Er zijn pixels.
En je hebt gehad om te beginnen denken over die.
Of je zal voor p-set 4 moeten nadenken over de spleet tussen de stenen, hoe
snel je bal beweegt over het scherm voor het uitbreken.
Dus er is dit begrip van de puntjes op het scherm dat is
komen in het spel reeds.
>> Nu wat je ziet, is echter wat krijg je op een computerscherm.
Als je ooit hebt gekeken wat goed of slechte TV, kansen zijn ze vrij veel
trakteren het publiek als technofoben die niet echt
weet veel over computers.
En dus is het zeer gemakkelijk voor de politie detective te zeggen, kunt u
schoon dat voor mij?
Of verbeteren, toch?
Verbeteren is als de buzz woord in vrijwel elke misdaad gerelateerde tonen.
En de realiteit is als je een heel nemen onscherpe foto van een verdachte te doen
iets slecht, je kan niet gewoon verbeter het.
U kunt niet inzoomen oneindig.
Je kunt niet zien in de glinstering van iemands oog die dat gepleegd
bijzonder misdaad, ondanks de prevalentie van deze op tv.
>> En dus met dat laten we motiveren dat aankomende probleem set met een blik op
sommige shows waarmee je misschien wel bekend voor.
>> [VIDEO AFSPELEN]
>> -OK.
Nu, laten we een goede blik op jou.
>> -Wacht.
Lopen die terug.
>> -Wacht even.
Ga naar rechts.
>> -Er.
Bevriezen dat.
>> -Full screen.
>> -OK.
Bevriezen dat.
>> -Draai op dat, zal ya?
>> -Vector in op die vent door het achterwiel.
>> -Zoom in hier op deze plek.
>> -Met de juiste apparatuur, de afgebeelde kan worden vergroot en verscherpt.
>> -Wat is dat?
>> -Het is een verhoging programma.
>> -Kun je duidelijk dat je geen?
>> -Ik weet het niet.
Laten we verbeteren het.
>> -Verbeter sectie A-6.
>> -Ik verbeterde de detail-en -
>> -Ik denk dat er genoeg te verbeteren.
Laat het aan mijn scherm.
>> -Verbeteren van de bezinning in haar ogen.
>> -Laten we lopen deze door video enhancement.
>> -Edgar, kunt u dit verbeteren?
>> -Hang on.
>> -Ik heb gewerkt aan dit reflectie.
>> -Iemand reflectie's.
>> -Reflectie.
>> -Er is een reflectie van de man's gezicht.
>> -De reflectie.
>> -Er is een reflectie.
>> -Zoom in op de spiegel.
>> -U kunt een reflectie zien.
>> -Kun je de afbeelding verbeteren van hier?
>> -Kun je hem verbeteren hier?
>> -Kun je het te verbeteren?
>> -Kunnen we dit verbeteren?
>> -Kun je het te verbeteren?
>> -Wacht even, ik zal verbeteren.
>> -Zoom in op de deur.
>> -X10.
>> -Zoom.
>> [Lachen]
>> -Beweeg inch
>> -Wacht, stop.
>> -Stoppen.
>> -Pauzeer het.
>> -Draai een 75 graden rond de verticale alstublieft.
>> [Lachen]
>> -Stop, en terug naar het gedeelte over de deur weer.
>> -Kreeg een afbeelding enhancer dat kan bitmap?
>> -Misschien kunnen we gebruik maken van de Pradeep Sen methode om te zien in de ramen.
>> -Deze software is state of the art.
>> -Het pictogram waarde is uitgeschakeld.
>> -Met de juiste combinatie van algoritmen.
>> -Hij heeft algoritmen verlichting genomen om het volgende niveau en ik kan ze gebruiken om
versterken deze foto.
>> Lock-on en vergroten de z-as.
>> -Verbeteren.
>> -Freeze en verbeteren.
>> [END VIDEO AFSPELEN]
>> DAVID J. Malan: So Probleemverzameling 5 is wat ons te wachten daar.
Dus zullen we binnenkort krijgen een beter inzicht van wanneer en waarom je
en ons niet kunnen verbeteren op die manier.
Maar laten we eerst terugkeren onze aandacht om een ​​deel van de bouwstenen zullen we
moeten in staat zijn om dat verhaal te vertellen.
>> Zodat herinneren dat we trok dit beeld op Maandag en een beetje van vorige week.
En dit beschrijft de lay-out van de dingen in het geheugen van uw computer wanneer
draaien van een programma.
De tech segment tot boven, recall, verwijst de werkelijke nullen en enen
dat uw programma samenstellen.
Er is, onder dat, sommige geïnitialiseerd of geïnitialiseerde data, die typisch
verwijst naar zaken als constanten of strings of globale variabelen die moeten
vooraf werd aangegeven.
Er is de hoop, maar we komen terug naar dat in een beetje.
>> En dan is er de stack.
Net als een stapel trays in de cafetaria, dit is waar het geheugen wordt
gelaagd en gelaagd wanneer je doet wat in een programma?
Wat is de stack gebruikt voor?
>> Yeah?
>> Noemen van de functie.
Elke keer dat je een functie noemt, het is gegeven lont geheugen voor de
lokale variabelen en de parameters.
En picturaal, zien we dat met elkaar opeenvolgende functie aangeroepen wanneer A
oproepen B oproepen C oproepen D, zij krijgen gelaagd op de stapel.
En binnen elk van deze plakjes geheugen is in wezen een uniek scope
voor die functie, die, uiteraard, is problematisch als je wilt bij de hand
van de ene functie naar de andere Een stuk van de gegevens die u wilt
te muteren of te wijzigen.
>> Dus wat was onze oplossing voor zodat Een functie vertegenwoordigd door een stapel
omlijsten het geheugen binnen te veranderen van een andere stackframe?
Hoe werken die twee met elkaar kunnen?
Dus door middel van pointers of adressen, die, nogmaals, net beschrijven in
geheugen, via een specifieke beet nummer, de specifieke
waarde kan worden gevonden.
Dus roepen laatste tijd ook bleven we het verhaal en keek naar een
vrij buggy programma.
En dit programma is buggy voor een paar redenen, maar de meest zorgwekkende is
omdat het niet te controleren wat?
>> Ja, zij niet aan de ingang controleren.
Sorry?
>> Als het meer dan 12 tekens.
Dus heel slim, bij het bellen memcopy, die, zoals de naam al doet vermoeden, net
kopieën geheugen van zijn tweede argument in zijn eerste argument.
Het derde argument, heel slim, is gecontroleerd om ervoor te zorgen dat u niet
Kopieer dan, in dit geval de lengte van de bar, aantal tekens,
in de bestemming, dat is dit matrix C. Maar het probleem is dat wat
Als C zelf is niet groot genoeg te hanteren dat?
Je gaat naar het aantal te kopiëren bytes die je hebt gekregen.
Maar wat doe je eigenlijk meer hebt bytes dan heb je ruimte voor?
>> Nou, dit programma erg dom gewoon blindelings opbrengst te nemen wat het is
gegeven, hello backslash 0 is geweldig als tekenreeks is kort
genoeg, net als vijf tekens.
Maar als het is eigenlijk 12 tekens of 1.200 tekens, vorige keer zagen we
dat je gewoon gaat volledig overschrijven geheugen dat
hoort niet bij jou.
En het ergste geval, als u overschrijven dat rode gedeelte daar dat we wel de
het terug -
Dit is precies waar de computer automatisch, voor u, achter de
scènes, plooien weg een 32-bits waarde die herinnert het aan welk adres het moet
terugkeren wanneer foo, deze andere functie, gebeurt uitvoeren.
Het is een broodkruimel van soorten waarbij het terugkeert.
Als u overschrijven dat, potentieel, als je de bad guy, kan kon
potentieel over te nemen iemands computer.
En je zult zeker crashen in de meeste gevallen.
>> Nu dit probleem is alleen verergerd als we begonnen te praten over het geheugen
beheer meer in het algemeen.
En malloc, voor het toewijzen van geheugen, is een functie die we kunnen gebruiken om te wijzen
geheugen als we niet van tevoren weten dat we nodig zou kunnen hebben een aantal.
Dus, bijvoorbeeld, als ik terug het apparaat hier.
En ik openstellen van de vorige keer hello2.c, herinneren hier dit programma, dat zag er
een beetje zoiets als dit, slechts drie lijnen -
vermelding van uw naam, dan naam touwtje, aan de linkerkant, is gelijk aan getString.
En vervolgens uit te printen we het uit, naam van de gebruiker.
>> Dus dit was een super eenvoudig programma.
Om duidelijk te zijn, laat me ga je gang en maak hello-2.
Ik ga doen dot slash hello-2.
Vermeld uw naam -
David.
Enter.
Hallo David.
Het lijkt te werken op OK.
Maar wat er werkelijk aan de hand eronder hood hier?
Laten we het eerst pellen sommige lagen.
String is gewoon een synoniem we hebben gerealiseerd voor wat?
Char ster.
Dus laten we het een beetje meer geheimzinnige maar meer technisch juist dat deze
is een char ster, waardoor naam, ja, is een variabele.
Maar welke naam winkels is het adres van de een char, dat voelt een beetje vreemd
want ik krijg weer een string.
Ik krijg weer meerdere chars niet een char.
>> Maar natuurlijk, u alleen de eerste nodig adres char's te herinneren waar de
hele reeks is want waarom?
Hoe kom je erachter waar het einde van de string is te weten het begin?
De backslash nul.
Dus met die twee aanwijzingen je uitzoeken vóór het begin en het einde van
elke string zijn, zolang ze goed gevormd met dat null
terminator, dat backslash nul.
>> Maar dit roept getString.
En het blijkt dat getString al die tijd is zo vriendelijk geweest van
vreemdgaan voor ons.
Het is gedaan deze arbeid, om zeker te zijn, om een ​​string van de gebruiker.
Maar waar is dat het geheugen komen al uit?
Als we terug gaan naar de foto en toepassing van de definitie van slechts een
daarnet, dat de stapel is waar geheugen gaat wanneer functies worden genoemd,
door die logica, wanneer je getString noemen, en typ ik in
D-A-V-I-D Voer, waar is D-A-V-I-D backslash nul opgeslagen, in de
verhaal dat we ons ver verteld?
>> Het lijkt in de stack, toch?
Als u belt krijgt touwtje krijg je een klein stukje van het geheugen op de stack.
Dus het spreekt vanzelf dat D-A-V-I-D backslash nul wordt opgeslagen
er in de stapel.
Maar wacht eens even, getString rendement dat koord, om zo te zeggen, waardoor
het is lade uit de kantine wordt genomen uit de stapel.
En we vorige keer zei dat zodra een functie terugkeert, en je neemt dat
lade, om zo te zeggen, uit de stapel, wat kunt u ervan uitgaan over de restanten van
dat het geheugen?
Ik soort van belangrijke vormgever hen als vraagtekens omdat ze effectief worden
onbekende waarden.
Ze kunnen worden hergebruikt bij sommige volgende functie wordt aangeroepen.
>> Met andere woorden, als we toevallig te slaan -
Ik zal snel een foto te trekken hier van de stapel.
Als we toevallig te trekken van de bodem van mijn geheugen segment, en we zullen zeggen
dat dit de plek van het geheugen bezet door de belangrijkste en misschien arg c en
arg v en iets anders in het programma, wanneer getString wordt genoemd,
vermoedelijk getString krijgt een stuk van het geheugen hier.
En vervolgens D-A-V-I-D ergens komt in deze functie.
En ik ga te eenvoudig.
Maar laten we aannemen dat de D-A-V-I-D backslash nul.
Dus zoveel bytes worden gebruikt het frame voor getString.
>> Maar zodra getString terugkeert, we zei vorige keer dat dit geheugen op
hier allemaal wordt - woops! -
alle daadwerkelijk wordt gewist.
En we kunnen nu denken dat dit als vraag merken want wie weet
wat er gaat worden van dat geheugen.
Sterker nog, ik roep heel vaak functies dan getString.
En zodra ik noem een ​​aantal andere functie dan getString, misschien niet in
dit specifieke programma we gewoon gekeken op maar een aantal andere, zeker een aantal andere
functie zou kunnen eindigen wordt gegeven deze volgende plek in de stapel.
>> Dus het kan niet zo zijn dat getString winkels D-A-V-I-D op de stapel, want ik zou
direct toegang tot het te verliezen.
Maar we weten dat ze getString alleen wat terug?
Het is niet terug te keren naar me zes tekens.
Wat is het echt terug had concluderen we vorige keer?
Het adres van de eerste.
Dus een of andere manier, als je getString genoemd, het is de toewijzing van een stuk van het geheugen voor
de tekenreeks die het type gebruikers en vervolgens terugkerende adres ervan.
En het blijkt dat wanneer je wilt functie om geheugen in deze toewijzen
manier en terug te keren naar de persoon die heeft gebeld die functie, het adres van de
dat stuk van het geheugen, je absoluut kan het niet in de stapel bij de
bodem, want functioneel is het gewoon ga niet heel de jouwe
snel, dus je kunt waarschijnlijk wel raden waar we waarschijnlijk gaan om het te gooien
in plaats daarvan, de zogenaamde heap.
>> Dus tussen de onderkant van je geheugen lay-out en de bovenkant van uw geheugen
lay-out zijn een heleboel segmenten.
Een is de stack en rechts boven de heap.
En hoop is gewoon een ander stuk van geheugen dat niet wordt gebruikt voor functies
wanneer ze worden opgeroepen.
Het wordt gebruikt voor de langere termijn geheugen, wanneer U wilt een functie om wat te pakken
geheugen en in staat zijn om op te hangen aan het zonder verlies van controle over.
>> Nu heb je misschien meteen zou kunnen zien dat dit niet
noodzakelijk een perfect design.
Als uw programma toegewezen geheugen op de stapel, of als u belt meer en
meer functies, of als u toe te wijzen geheugen op de heap met malloc af als
getString doet, wat duidelijk lijkt onvermijdelijk probleem?
>> Rechts.
Zoals het feit dat deze pijlen wijzen naar elkaar
voorspelt niet veel goeds.
En inderdaad, konden we heel snel crashen een programma op een aantal manieren.
Sterker nog, ik denk dat we kunnen hebben dit per ongeluk een keer gedaan.
Of indien niet, laten we het doen doelbewust nu.
Laat me ga je gang en schrijf super snel een programma genaamd dontdothis.c.
En nu zal ik hier binnen te gaan en geen scherpe omvatten stdio.h.
Laten we verklaren functie foo neemt geen argumenten, dat is
aangeduid alsook door leegte.
>> En het enige wat foo gaat doen is oproep foo, dat is waarschijnlijk niet de
slimste idee, maar het zij zo.
Ent belangrijkste leegte.
Nu is het enige belangrijkste gaat te doen is bellen foo ook.
En gewoon voor de kick, ik ga om te gaan vooruit hier en zeggen: printf "Hello from
foo. "
>> OK.
Dus als ik geen fouten maakte, Maak dontdothis dot slash.
En laten we het doen in een groter venster -
dot slash, dontdothis.
Kom op.
Uh oh.
Blijkbaar, kunt u dit doen.
Verdomme.
OK.
Wachten.
Stand-by.
Deden we -
We hebben gebruik het met Zorg.
>> [SIGHS]
>> Ik weet het, maar ik denk dat we gewoon verwijderd dat.
Uh, ja.
Verdomme.
Los deze Rob.
Wat?
Het is heel simpel.
Ja, we draaide optimalisatie uitgeschakeld.
OK, stand bye.
Nu voel ik me beter.
OK.
Oke.
>> Dus laten we opnieuw compileren deze -
Maak je dontdothis.
Je zou kunnen hebben om deze te hernoemen naar dothis.c in slechts een moment.
Daar gaan we.
Dank u.
OK.
Dus het feit dat ik werd afgedrukt iets uit was eigenlijk gewoon
het vertragen van het proces waarbij we zou dat punt hebben bereikt.
OK.
Phew!
>> Dus wat er eigenlijk aan de hand?
De reden dat er, net als een terzijde, is iets te doen in termen van input en
uitgang heeft de neiging langzamer te zijn, omdat je moeten de tekens schrijven
scherm, Het heeft te scrollen.
Dus lang verhaal kort, had ik eigenlijk gebeurde zo ongeduldig, zouden we
gezien dit eindresultaat ook.
Nu ik kreeg rit van de afdruk-ups, zien we het meteen.
Waarom is dit zo gebeurt.
Nou, de eenvoudige verklaring, natuurlijk, is dat foo waarschijnlijk niet te
worden die zichzelf.
>> Nu in algemene termen, Dit is recursie.
En we dachten dat een paar weken geleden recursieve is goed.
Recursie is deze magische manier van jezelf uitdrukken super kort en bondig.
En het werkt gewoon.
Maar er is een belangrijk kenmerk van alle de recursieve programma's die we hebben gesproken
over en keek tot nu toe, die was dat ze wat?
Een referentiemodel, dat was wat hard coded geval dat genoemde in sommige situaties
denk foo, die duidelijk niet bellen hier niet het geval.
>> Dus wat er werkelijk gebeurt in termen van deze foto?
Nou, als belangrijkste noemt foo, het krijgt een stukje van het geheugen.
Wanneer foo noemt foo, het wordt een stukje van het geheugen.
Wanneer foo noemt foo, krijgt het een slice.
Het krijgt een stukje.
Omdat foo is nooit terug te keren.
We zijn nooit wist een van die kaders van de stapel.
Dus we waait door de heap, niet te vermelden wie weet wat nog meer, en
we overschrijden de grenzen van onze zogenaamde segment van het geheugen.
Fout gaan segmentatie vals.
>> Dus de oplossing is duidelijk doen dit niet.
Maar de grotere implicatie is dat, ja, Er is absoluut een bepaalde grens,
zelfs als het niet goed gedefinieerd, hoe vele functies u kunt bellen in een
programma, hoe vaak een functie kan zelf bellen.
Dus hoewel we prediken recursie als deze potentieel magische ding een
paar weken geleden voor de sigma functie, en wanneer krijgen we de data
structuren en CS50, zult u meer zien toepassingen voor het, het is niet
noodzakelijkerwijs het beste ding.
Want als een functie noemt zichzelf, noemt zichzelf, zelfs als er een basis
geval, als je niet raken dat base case voor 1.000 oproepen of 10.000 oproepen, door
die keer dat je van de kamer zou zijn leeg op je zogenaamde stack en hit
andere segmenten van het geheugen.
Dus het is ook een ontwerp trade-off tussen elegantie en tussen
robuustheid van uw specifieke implementatie.
>> Dus er is nog een nadeel of andere gotcha aan wat we hebben
tot nu toe gedaan.
Toen ik belde getString -
Laat me teruggaan naar hello-2.
Merk op dat ik bel getString, die is terug een adres.
En we vandaag beweren dat adres is van de hoop.
En nu ben ik het afdrukken van de snaar op dat adres.
Maar we hebben nooit opgeroepen de tegenovergestelde van getString.
We zijn nooit naar een functie als calll ungetstring, waar je hand heen
dat geheugen.
Maar eerlijk gezegd we waarschijnlijk had moeten zijn.
Want als we blijven vragen de computer voor het geheugen, bij wijze van iemand als
getString maar geef het nooit meer terug, zeker ook dat is gebonden leiden tot
problemen waarbij we opraken van het geheugen.
>> En in feite, kunnen we kijken naar deze problemen met de nieuwe tool waarvan gebruik
is een beetje cryptisch te typen.
Maar laat me gaan en spatten omhoog op het scherm in slechts een moment.
Ik ga om te gaan en uit te voeren Valgrind met parameter wiens eerste commando
line argument is de naam van dat programma hello-2.
En helaas is het uitgang is gruwelijk
complex voor geen goede reden.
Zo zien we al die rotzooi.
David is vermeld mijn naam.
Dus dat is het programma werkelijk aan het draaien.
En nu krijgen we deze uitgang.
>> Dus Valgrind vergelijkbaar in de geest naar GDB.
Het is niet een debugger per se.
Maar het is een herinnering checker.
Het is een programma dat je zal lopen programmeren en u vertellen of u gevraagd een
computer voor het geheugen en nooit gaf het terug, waardoor betekent dat je hebt
een geheugenlek.
En geheugen lekken neiging om slecht te zijn.
En u is gebruikers van de computers Waarschijnlijk voelde dit, of je hebt een
Mac of een PC.
Heb je ooit gebruikt uw computer voor terwijl en niet opnieuw opgestart in verschillende
dagen, of je hebt net een stuk van programma's draaien, en het verdomde ding
vertraagt ​​tot stilstand, althans het super vervelend te gebruiken, omdat
alles net super traag.
>> Nu dat kan een aantal redenen te zijn.
Het kan een oneindige lus, een bug in zijn iemands code, of, eenvoudiger, het
zou kunnen betekenen dat u gebruikt meer geheugen, of proberen om, dan je
computer heeft eigenlijk.
En misschien is er een bug in een programma die blijven vragen voor het geheugen.
Browsers voor jaren waren berucht voor dit, vragen om meer en meer geheugen
maar nooit overhandigen het terug.
Zeker, als je alleen maar een eindige hoeveelheid geheugen, kan je niet vragen
oneindig vaak voor sommige van dat geheugen.
>> En dus wat je hier ziet, ook al opnieuw uitgang Valgrind's is
onnodig ingewikkelde blik op eerste, dit is het interessante deel.
Heap -
in gebruik bij afslag.
Dus hier is hoeveel geheugen was gebruikt in de heap de
tijd mijn programma verlaten -
blijkbaar zes bytes in een blok.
Dus ik ga mijn handen zwaaien naar wat een blok is.
Denken van het is gewoon een brok, een meer technische woord voor chunk.
Maar zes bytes -
wat zijn de zes bytes die waren nog in gebruik?
>> Precies.
D-A-V-I-D backslash nul, vijf letters naam plus de null-terminator.
Dus dit programma Valgrind gemerkt dat ik vroeg om zes bytes, blijkbaar, door
manier getString, maar nooit gaf ze terug.
En in feite, kan dit niet worden duidelijk als mijn programma is niet drie
lijnen, maar het is 300 lijnen.
Dus we kunnen eigenlijk geven een andere opdracht lijn argument Valgrind aan
maken het meer breedsprakig.
Het is een beetje vervelend om te onthouden.
Maar als ik dat doe -
laten we eens kijken.
Lek -
Werd het lek -
zelfs ik weet het niet meer wat het is uit de hand.
>> - Lek-check gelijk vol.
Yep, dank je.
- Lek-check gelijk vol.
Enter.
Hetzelfde programma wordt uitgevoerd.
Typ in David weer.
Nu zie ik wat meer detail.
Maar minder dan de heap samenvatting, die is gelijk aan vier - ah,
dit is wel leuk.
Nu Valgrind is eigenlijk op zoek een beetje harder in mijn code.
En het is te zeggen dat, blijkbaar, malloc op lijn -
we uitzoomen.
Op lijn -
we niet zien welke lijn het is.
Maar malloc is de eerste boosdoener.
Er is een blog in malloc.
>> Oke?
OK, nee.
Rechts?
Ik belde getString.
getString roept blijkbaar malloc.
Dus wat regel code is blijkbaar schuld voor het feit dat
toegewezen dit geheugen?
Laten we aannemen dat wie malloc schreef heeft al lang genoeg dat het
niet hun schuld.
Dus het is waarschijnlijk de mijne.
getString in cs50.c - dus dat is een bestand ergens op de computer -
in lijn 286 lijkt de boosdoener zijn.
Laten we nu eens aannemen dat CS50 is geweest rond voor behoorlijke hoeveelheid tijd, dus
ook wij zijn onfeilbaar.
En dus het is waarschijnlijk niet in getString dat de bug ligt, maar in
hello-2.c lijn 18.
>> Dus laten we eens een kijkje nemen op wat dat lijn 18 was.
Oh.
Een of andere manier deze lijn is niet noodzakelijk buggy, per se, maar het is de reden
achter dat geheugenlek.
Zo super gewoon, wat zou intuïtief zijn hier de oplossing?
Als we vragen voor het geheugen, waren nooit waardoor het terug, en dat lijkt te zijn van een
probleem, want na verloop van tijd mijn computer zou opraken van het geheugen, kunnen vertragen
neer, misschien slechte dingen gebeuren, nou ja, wat is de eenvoudige en intuïtieve oplossing?
Geef het gewoon terug.
>> Hoe doe je vrij dat het geheugen?
Nou ja, gelukkig is het heel simpel om gewoon te zeggen vrij naam.
En we hebben dit nog nooit gedaan.
Maar je kunt wezen bedenken vrij als het tegenovergestelde van malloc.
gratis is het tegenovergestelde van toewijzen van geheugen.
Dus nu laat ik deze opnieuw compileren.
Maak hello-2.
Laat ik het nogmaals uit te voeren. hello-2 David.
Dus het lijkt te werken in dezelfde manier.
Maar als ik terug naar Valgrind en re-run dat hetzelfde commando op mijn nieuw
gecompileerde programma, het typen in mijn naam als voorheen -
nice.
Heap samenvatting -
in gebruik bij afslag -
nul bytes in nul blokken.
En dit is super leuk, allemaal heap blokken werden bevrijd.
Geen lekken zijn mogelijk.
>> Dus komen, niet met Probleemverzameling 4, maar met Probleemverzameling 5, de forensische
en verder, ook dit zal een maat voor de juistheid van uw
programma, of u hebt of hebben geen geheugen lekken.
Maar gelukkig, niet alleen kan je redeneren door hen intuïtief dat
is, misschien wel, makkelijk voor kleine programma's maar moeilijker voor grotere programma's,
Valgrind, voor die grotere programma's, herkent u
het specifieke probleem.
>> Maar er is een ander probleem die zich kunnen voordoen.
Laat ik hier open dit bestand, dat is, weer een enigszins eenvoudig voorbeeld.
Maar laten we focussen op wat Dit programma doet.
Dit memory.c genoemd.
We zullen post dit later vandaag in de zip van de huidige broncode.
En merken dat ik een functie genaamd f dat er geen argumenten en neemt
keert niets.
In lijn 20, ben ik blijkbaar waarbij een pointer naar een int en noemde het x.
Ik ben het toewijzen is de terugkeer waarde van malloc.
En alleen maar om duidelijk, hoeveel bytes am Ik waarschijnlijk krijgen terug van malloc
in deze situatie?
>> Waarschijnlijk 40.
Waar haal je dat vandaan?
Nou, als je eraan herinneren dat een int is vaak 4 bytes, het is tenminste in de
apparaat 10 keer 4 is duidelijk 40.
Dus malloc is terug te keren van een adres van een stuk van het geheugen en het opslaan van die
pakken uiteindelijk in x.
Dus om duidelijk te zijn, wat dan gebeurt?
Nou, laat me terug te schakelen om onze foto hier.
Laat me niet alleen trekken de bodem van mijn geheugen van de computer, laat mij ga je gang en
trek de hele rechthoek die vertegenwoordigt al mijn RAM.
>> We zeggen dat de stapel op de bodem.
En er is een tekst-segment in de geïnitialiseerde data.
Maar ik ga gewoon abstracte die andere dingen weg als dot, dot dot.
Ik ga gewoon om te verwijzen naar dit de heap bovenaan.
En dan aan de onderkant van deze foto, tot belangrijkste vertegenwoordigen, ik ga
om het een plakjes geheugen geven op de stack.
Voor f, ga ik het een stukje geven van het geheugen op de stack.
Nu, ik moet mijn raadplegen broncode opnieuw.
Wat zijn de lokale variabelen voor de belangrijkste?
Blijkbaar niets, zodat slice is effectief leeg of zelfs niet zo groot
zoals ik getekend heb het.
Maar in f, ik heb een lokale variabele, waarin x is genoemd.
Dus ik ga om verder te gaan en geef f een stuk van het geheugen, noemde het x.
>> En nu malloc van 10 maal 4, Dus malloc 40, waar is dat
geheugen vandaan?
We hebben een foto niet getekend als dit al eerder.
Maar laten we veronderstellen dat het effectief vanuit hier, dus een,
twee, drie, vier, vijf.
En nu heb ik 40 van deze.
Dus ik zal gewoon doen puntje, puntje, puntje te suggereren dat er nog meer geheugen
komt terug van de hoop.
Nu, wat is het adres?
Laten we kiezen voor onze willekeurige aanpakken zoals altijd -
Ox123, ook al is het waarschijnlijk gaat iets heel anders te zijn.
Dat is het adres van de eerste byte in geheugen dat ik vraag malloc voor.
>> Dus in het kort, een keer lijn 20 uitvoert, wat is letterlijk
opgeslagen binnenkant van x hier?
Ox123.
En de Os is oninteressant.
Het betekent alleen hier is een hexadecimaal getal.
Maar wat is belangrijk is dat wat ik heb winkel in x, die een lokale variabele.
Maar het data type, nogmaals, is een adres van een int.
Nou, ik ga slaan Ox123.
Maar nogmaals, als dat een beetje te onnodig ingewikkeld, als ik het scrollen
terug, kunnen we abstracte deze weg vrij redelijk en gewoon zeggen dat x een
pointer naar dat stuk van het geheugen.
>> OK.
Nu is de vraag bij de hand is de volgende -
lijn 21, zo blijkt, is buggy.
Waarom?
>> Sorry?
Het hoeft niet -
Zeg dat nog eens.
Nou, het doet niet gratis.
Dus dat is de tweede maar.
Dus er is een andere, maar specifiek op lijn 21.
>> Precies.
Deze eenvoudige regel code is slechts een buffer overflow, een bufferoverloop.
Een buffer betekent gewoon een stuk van het geheugen.
Maar dat stuk van het geheugen is van omvang 10, 10 gehele getallen, wat betekent dat als we
index in het gebruik van de syntactische suiker van de array notatie, het plein
haakjes, heb je toegang tot hebt x beugel 0 x beugel 1 x,
beugel puntje, puntje, puntje.
x beugel 9 is de grootste.
Dus als ik doe x beugel 10, waar Ik ben eigenlijk aan de hand in het geheugen?
>> Nou, als ik 10 int -
laten we eigenlijk trekken alle van deze hier.
Dus dat was de eerste vijf.
Hier is de andere vijf ints.
Dus x beugel 0 is hier. x beugel 1 is hier. x beugel 9 is hier. x beugel
10 is hier, wat betekent dat ik zeg, in lijn 21, de computer aan het zetten
nummer waar?
Het getal 0, waar?
Nou, het is 0, ja.
Maar het feit dat de 0 is een soort van toeval.
Het zou de nummer 50, voor zover we schelen.
Maar we proberen om het te zetten op x beugel 10, waar de
vraagteken wordt getrokken, die is geen goede zaak.
Dit programma zou heel goed crash als gevolg.
>> Laten we nu verder gaan en zien of dit is inderdaad wat er gebeurt.
Voeg geheugen, omdat het bestand memory.c wordt genoemd.
Laten we verder gaan en uitvoeren het programma geheugen.
Dus we hebben geluk, eigenlijk, het lijkt.
We hebben geluk gehad.
Maar laten we eens kijken of we lopen nu Valgrind.
Op het eerste gezicht, mijn programma zou lijken te zijn volkomen juist.
Maar laat me lopen Valgrind met de - Lek-check gelijk vol op het geheugen.
>> En nu wanneer ik dit -
interessant.
Ongeldige schrijven van grootte 4 bij lijn 21 van memory.c.
Lijn 21 van memory.c is welke?
Oh, interessant.
Maar wacht.
Maat 4, wat is dat verwijst naar?
Ik alleen heb een schrijven, maar het is van grootte 4.
Waarom is het 4?
Het is omdat het is een int, die is wederom vier bytes.
Dus Valgrind vond een bug die ik, blik op mijn code, niet.
En misschien je TF wel of niet zou.
Wat Maar Valgrind zeker gevonden dat we hebben een fout gemaakt daar, zelfs
hoewel we geluk, en de computer besloten, eh, ik ga niet crashen
alleen maar omdat je een byte, een aangeraakt int de moeite waard van het geheugen dat je dat niet deed
eigenlijk zelf.
>> Nou, wat anders buggy is hier.
Adres -
dit is een gek op zoek adres hexadecimaal.
Dat betekent gewoon ergens in de heap is nul bytes na een blok van maat 40
wordt toegewezen.
Laat me hier uit te zoomen en te kijken of Dit is een beetje meer behulpzaam.
Interessant.
40 bytes zijn zeker verloren in verliesverslag 1 van 1.
Ook meer woorden dan hier bruikbaar.
Maar gebaseerd op de gemarkeerde lijnen, waar moet ik waarschijnlijk richten mijn
aandacht voor een andere bug?
Ziet eruit als een lijn 20 van memory.c.
>> Dus als we terug gaan naar lijn 20, dat is de een die je eerder geïdentificeerd.
En het is niet per se buggy.
Maar we hebben dit omgekeerd zijn gevolgen.
Dus hoe kan ik corrigeren tenminste een van die fouten?
Wat kan ik doen na lijn 21?
Ik kon vrij van x doen, dus wordt terug te geven die het geheugen.
En hoe kan ik deze bug oplossen?
Ik moet zeker gaan niet verder dan 0.
Dus laat me proberen en re-run deze.
Sorry, zeker gaan niet verder dan 9.
Maak geheugen.
Laat me nog even Valgrind in een groter venster.
En kijk nu.
Leuk.
Alle hoop blokken werden bevrijd.
Geen lekken zijn mogelijk.
En boven hier, er is geen melding nog meer van de ongeldige recht.
>> Gewoon om hebzuchtig te krijgen, en laten we zien of een andere demonstratie
gaat niet zo bedoeld -
Ik heb geluk een moment geleden.
En het feit dat dit is wellicht 0 onnodig misleidend.
Laten we het gewoon doen 50, een enigszins arbitrair nummer, maak geheugen dot slash geheugen -
nog geluk.
Niets crashen.
Stel dat ik gewoon iets echt dwaas, en ik doe 100.
Laat me geheugen remake, dot slash geheugen -
heb weer geluk.
Hoe zit het met 1000?
ints voorbij, ruwweg, waar ik zou moeten zijn?
Maak geheugen -
damn it.
>> [Lachen]
>> OK.
Laten we niet meer prutsen.
Rerun geheugen.
Daar gaan we.
Oke.
Dus blijkbaar je index 100.000 ints dan waar je in had moeten zijn
geheugen, slechte dingen gebeuren.
Dus dit is natuurlijk niet een harde, snelle regel.
Ik was een soort van het gebruik van proef en error om er te komen.
Maar dit is omdat, lang verhaal kort, geheugen van uw computer wordt ook verdeeld
in deze dingen genoemd segmenten.
En soms de computer daadwerkelijk je een beetje meer geheugen heeft gegeven
dan je vraagt.
Maar voor efficiency, het is gewoon makkelijker om krijgen meer geheugen, maar alleen vertellen
dat je krijgt van een deel ervan.
>> En als je geluk soms, dus, zou je in staat zijn om aan te raken
geheugen dat niet van jou is.
Heb je geen garantie dat wat waarde je zet er zal daar blijven, omdat
de computer denkt nog steeds dat het niet jou, maar het is niet per se te gaan
naar een ander segment van het geheugen hit in de computer en het induceren van een dergelijke fout
deze hier.
Oke.
Heeft u vragen dan op het geheugen?
>> Oke.
Laten we eens een kijkje hier, vervolgens, bij iets wat we al nemen voor
verleend voor geruime tijd, die is in dit dossier genoemd cs50.h.
Dus dit is een bestand.
Dit zijn slechts een hele hoop van reacties up top.
En je zou hebben gekeken naar deze indien je prikte rond op het toestel.
Maar het blijkt dat de hele tijd, toen we naar een string te gebruiken als een
synoniem, het middel waardoor wij verklaard dat synoniem is met dit
trefwoord typedef, voor type-definitie.
En we zijn in wezen zeggen, maken rijgen een synoniem voor char ster.
Dat de wijze waarop de stapel gemaakt van deze zijwieltjes bekend als
de string.
>> Nu hier is slechts een prototype voor getchar.
We zouden hebben het al eerder gezien, maar dat is inderdaad wat het doet. getchar
neemt geen argumenten, retourneert een char.
getdouble neemt geen argumenten, retourneert een dubbele.
getfloat neemt geen argumenten, rendement a float, enzovoort.
getint is in hier. getlonglong is in hier.
En getString is in hier.
En dat is het.
Deze paarse lijn is een andere preprocessor richtlijn vanwege de
hashtag aan het begin ervan.
>> Oke.
Dus nu laat me gaan in cs50.c.
En we zullen niet te lang praten over dit.
Maar om u een glimp van wat er te geven er aan de hand dit alles
tijd, laat me gaan naar -
laten we het doen getchar.
Dus getchar is vooral opmerkingen.
Maar het lijkt erop dat dit.
Dus dit is de eigenlijke functie getchar dat we geweest zijn
nemen als vanzelfsprekend aanwezig.
En ook al hebben we geen gebruik van deze ene dat vaak, of nooit, het is in ieder geval
relatief eenvoudig.
Dus het is de moeite waard een snelle blik op hier.
>> Dus getchar heeft een oneindige lus, opzettelijk zo blijkbaar.
Het roept dan - en dit is een soort van een nice hergebruik van code die we onszelf schreven.
Het roept getString.
Want wat doet het betekenen voor een char te krijgen?
Nou, kan je net zo goed proberen om een ​​te krijgen hele lijn van de tekst van de gebruiker en
dan kijk maar naar een van deze tekens.
In lijn 60, hier is een kleine beetje een sanity check.
Als getString terug null, laten we niet gaan.
Er is iets misgegaan.
>> Nu is dit een beetje vervelend, maar conventioneel C. char max waarschijnlijk
staat voor wat net op basis van zijn naam?
Het is een constante.
Het is net als de numerieke waarde van de grootste char u kan vertegenwoordigen met
een hap, wat waarschijnlijk het aantal 255, dat is de grootste nummer dat u
vertegenwoordigen acht bits, vanaf nul.
Zo heb ik gebruik deze, in deze functie, wanneer het schrijven van deze code, alleen omdat
als er iets mis gaat in getchar maar haar doel in het leven is om een ​​terugkeer
char, moet je een of andere manier te kunnen kunnen waarschuwen de gebruiker dat
ging er iets mis.
We kunnen niet terugkeren null.
Het blijkt dat null is een pointer.
En nogmaals, getchar heeft een char terug.
>> Dus de conventie, als er iets gaat verkeerde, is u, de programmeur, of in
dit geval, mij met de bibliotheek, had ik een gewoon beslissen willekeurig, indien
er iets fout gaat, ga ik keren het getal 255, dat is echt
betekent dat we kunnen niet, de gebruiker kan niet typen het teken weergegeven door de
nummer 255, want we hadden een stelen als zogenaamde sentinel waarde
een probleem vormen.
Nu blijkt dat het karakter 255 is niet iets wat je kunt typen op
uw toetsenbord, dus het is geen big deal.
De gebruiker merkt niet dat Ik heb dit karakter gestolen.
Maar als je ooit in de man-pagina's op een computersysteem een ​​verwijzing naar een
alle doppen constant als deze die zegt, in geval van een fout deze constante kracht
worden teruggegeven, dat is alles wat de mens gedaan jaar geleden werd willekeurig beslist om
terug deze bijzondere waarde en noem het een constante in het geval
er iets fout gaat.
>> Nu de magie gebeurt hier beneden.
Ten eerste, ik ben te verklaren in de lijn 67 twee personages, C1 en C2.
En vervolgens in lijn 68, is er eigenlijk een regel code die doet denken aan
onze vriend printf, gezien het feit dat het heeft wel procent Cs tussen aanhalingstekens.
Maar let op wat er hier gebeurt. sscanf betekent touwtje scan -
betekent scannen een geformatteerde koord, ergo sscanf.
Wat betekent dat?
Het betekent dat u doorgeeft aan een string sscanf.
En lijn is wat de gebruiker typt inch
U passeert een format string als sscanf dit dat scanf vertelt wat zijn
hoop je de gebruiker heeft getypt inch
Je vervolgens doorgeven in de adressen van twee delen van het geheugen, in casu
want ik heb twee tijdelijke aanduidingen.
Dus ik ga het het adres geven van C1 en het adres van de C2.
>> En herinneren dat u een functie te geven de adres van enkele variabele, wat is
de implicatie?
Wat kan die functie doen als gevolg het te geven het adres van een
variabele tegenover de variabele zelf?
Het kan veranderen, toch?
Als je iemand een kaart aan een fysieke gehad adres, kunnen ze daar heen te gaan en te doen
wat ze willen op dat adres.
Hetzelfde idee hier.
Als we doorgeven aan sscanf, het adres van de twee delen van het geheugen, zelfs deze kleine
kleine delen van het geheugen, C1 en C2, maar We vertellen het adres van hen,
sscanf kan veranderen.
>> Dus sscanf's doel in het leven, als we lezen de man pagina, is te lezen wat de
gebruiker ingetypt, hoop voor de gebruiker met getypt in een personage en misschien
een ander karakter, en wat de gebruiker getypt, het eerste teken gaat
hier, het tweede karakter gaat hier.
Nu, als een terzijde, dit, en je zou Alleen weten dit uit de documentatie,
het feit dat ik er een lege ruimte betekent gewoon dat ik niet schelen als
de gebruiker de spatiebalk raakt een paar keer voordat hij of zij neemt een
karakter, ik ga negeren geen witte ruimte.
Zodat, ik weet uit de documentatie.
>> Het feit dat er een tweede% c gevolgd door een spatie is eigenlijk
weloverwogen.
Ik wil in staat zijn om te detecteren of de gebruiker screwed up of geen medewerking verleenden.
Dus ik hoop dat de gebruiker alleen getypt in een personage, dus ik hoop
dat sscanf alleen gaat om het terug te keren waarde 1 omdat, nogmaals, als ik lees
de documentatie, sscanf's doel in het leven te keren naar het aantal
variabelen die werden gevuld met gebruikersinvoer.
>> Ik passeerde in twee variabelen adressen, C1 en C2.
Ik hoop echter dat slechts een van ze wordt vermoord omdat als sscanf
rendement 2, wat is vermoedelijk de implicatie logisch?
Dat de gebruiker niet geef me een karakter zoals ik vertelde hem of haar.
Ze waarschijnlijk getypt op tenminste twee tekens.
Dus als ik in plaats daarvan niet de tweede hebben % C, ik had net een, die
eerlijk gezegd zou meer intuïtief aanpak, ik denk dat een eerste blik,
je bent niet van plan om te kunnen detecteren Als de gebruiker is waardoor u meer
ingang dan je eigenlijk wilde.
Dus dit is een impliciete vorm van foutcontrole.
>> Maar let op wat ik hier doe.
Zodra ik ben er zeker van dat de gebruiker gaf me een karakter, Ik bevrijd de lijn, doet
het tegenovergestelde van getString, waardoor maakt gebruik van malloc, en toen ik terug
C1, het personage dat ik hoopte dat de gebruiker verstrekt en slechts verstrekt.
Dus een snelle glimp alleen, maar Voor vragen over getchar?
We komen terug naar een aantal van de anderen.
>> Nou, laat me ga je gang en doe dit - veronderstel nu, gewoon om te motiveren ons
discussie in een week plus tijd, dit is een bestand met de naam structs.h.
En nogmaals, dit is slechts een voorproefje van iets dat voor ons ligt.
Maar merken dat veel Dit heeft opmerkingen.
Dus laat me benadrukken alleen de interessante deel voor nu.
typedef -
er is dat hetzelfde zoekwoord weer.
typedef we gebruiken om touwtje te verklaren als een speciaal datatype.
U kunt typedef gebruiken om nieuwe te creëren soorten gegevens die niet bestonden toen
C werd uitgevonden.
Bijvoorbeeld, int geleverd met C. char wordt geleverd met C. dubbel geleverd met C. Maar
is er geen notie van een student.
En toch is het vrij nuttig te zijn zou zijn in staat om een ​​programma dat opslaat schrijven
in een variabele, het ID-nummer van een student, hun naam en hun huis.
Met andere woorden, drie stukken van data, zoals een int en een
string en andere string.
>> Met typedef, wat is vrij krachtig over dit en het zoekwoord sturct voor
structuur, u, de programmeur in 2013, kan eigenlijk definieer uw eigen de
soorten gegevens die niet bestonden jaar geleden, maar dat past bij uw doeleinden.
En dus hier, in lijnen 13 tot 19, we zijn waarbij een nieuw type gegevens, zoals
een int, maar noemde het student.
En de binnenkant van deze variabele gaat zijn drie dingen - een int, een string,
en een string.
Dus je kunt bedenken wat echt hier gebeurd is, ook al is dit een
beetje een vereenvoudiging voor vandaag, een student is in wezen gaat
om te kijken als deze.
Het gaat om een ​​stuk van zijn geheugen met een ID, een naam
veld, en een huis veld.
En we zullen in staat zijn om die stukjes te gebruiken geheugen en toegang tot hen als volgt.
>> Als ik in struct0.c, hier is een relatief lang, maar na een
patroon, van de code die gebruikt deze nieuwe truc.
Dus laat me eerst uw aandacht om de interessante delen boven.
Scherpe definieert studenten 3, verklaart een constante riep studenten en rechtverkrijgenden
het willekeurig het getal 3, maar dus ik heb drie studenten met behulp van
dit programma voor nu.
Hier komt Main.
En let, hoe kan ik verklaar een array van studenten?
Nou, ik gebruik gewoon dezelfde syntaxis.
Het woord student is natuurlijk nieuw.
Maar student, klasse, beugel studenten.
>> Dus helaas er is een hoop van hergebruik van termen hier.
Dit is maar een getal.
Dus dit is hetzelfde als zeggen drie.
Klasse is precies wat ik wil om de variabele te bellen.
Ik kon noemen studenten.
Maar class, dit is geen klasse een object georiënteerde Java soort manier.
Het is gewoon een klasse van studenten.
En het gegevenstype van elk element in die matrix is ​​student.
Dit is een beetje anders dus en naar iets te zeggen
als dit, het is gewoon -
Ik zeg geef me drie studenten en bel die array klasse.
>> Oke.
Nu hier is een vier lus.
Deze vent is bekend - iterate van nul tot drie.
En hier is het nieuwe stuk van de syntax.
Het programma gaat me prompt, de mens, om het een student geven
ID, die een int.
En hier is de syntax waarmee u kunt iets opslaan in het ID veld
locatie klasse beugel I. So Deze syntax is niet nieuw.
Dit betekent geef me de achtste leerling in de klas.
Maar dit symbool is nieuw.
Tot nu toe hebben we niet kunnen gebruiken dot, althans in code als volgt.
Dit betekent naar de structuur bekend als een student en zet daar iets.
Ook in deze volgende regel, 31, gaat vooruit en zetten wat soorten van de gebruiker
voor een naam hier en wat ze doen voor een huis, het zelfde ding, ga je gang en
zet het in. house.
>> Dus wat heeft dit programma uiteindelijk doen?
U kunt een kleine teaser daar te zien.
Laat me ga je gang en doen maken structs 0 dot slash struct 0, student ID 1,
zegt David Mather, student ID 2.
Rob Kirkland, student ID 3.
Lauren Leverit -
en het enige wat dit programma deed, dat is gewoon volkomen willekeurig, wordt
Ik wilde iets doen met deze gegevens, nu dat ik ons ​​heb geleerd hoe
Gebruik structs, is dat ik had net deze extra lus hier.
Ik itereren over de vele studenten.
Ik gebruikte onze, misschien nu vertrouwd vriend, string vergelijker, stircomp te
check is huis 8 student gelijk Mather?
En zo ja, gewoon iets af te drukken willekeurig als, ja, het is.
Maar nogmaals, alleen het geven van me kansen te gebruiken en hergebruiken en
hergebruiken deze nieuwe puntnotatie.
>> Dus who cares, toch?
Coming up met een student programma is enigszins arbitrair, maar het blijkt
dat we nuttige dingen kunnen doen met dit bijvoorbeeld als volgt.
Dit is een veel ingewikkelder struct in C. Het heeft een dozijn of meer velden,
enigszins cryptisch vernoemd.
Maar als je ooit hebt gehoord van een grafische bestandsformaat genaamd bitmap, BMP, het
blijkt dat de bitmap bestandsformaat vrij veel lijkt op dat dit.
Het is een beetje dom gezicht Smiley.
Het is een kleine afbeelding die ik heb ingezoomd op vrij groot, zodat ik kon elke zien
van de individuele puntjes of pixels.
Nu, het blijkt dat we kunnen vertegenwoordigen een zwarte stip met bijvoorbeeld het getal 0.
En een witte stip met het nummer 1.
>> Dus met andere woorden, als je wilt een te tekenen Smiley gezicht en slaan die op in een
computer volstaat de nullen slaan en degenen die er uitzien als deze, waar,
nogmaals, degenen zijn wit en nullen zijn zwart.
En samen, als je effectief hebt een omgorden van enen en nullen, je hebt een
raster van pixels, en als je lay ze uit, je hebt een leuke
weinig Smiley gezicht.
Nu, bitmap, BMP, is effectief dat onder de motorkap,
maar met meer pixels sot dat u kan eigenlijk kleuren vertegenwoordigen.
>> Maar als je meer geavanceerde bestandsformaten zoals BMP en JPEG en GIF
waarmee je misschien wel bekend, die bestanden op een schijf typisch niet alleen
hebben nullen en enen van de pixels, maar ze hebben een aantal metadata alsook -
meta in die zin dat niet echt gegevens, maar het is handig om te hebben.
Dus deze velden hier zijn impliceren, en we zullen dit in meer detail in P-set
5, dat voor de nullen en enen dat vertegenwoordigen de pixels in een beeld,
Er is een bos van metadata zoals de grootte van de afbeelding en de
breedte van het beeld.
En let ik plukken uit een aantal willekeurige dingen hier -
breedte en hoogte.
Aantal bits en een aantal andere dingen.
Dus er is een aantal metagegevens in een bestand.
>> Maar door te begrijpen hoe de bestanden worden gelegd op deze manier, kun je eigenlijk
dan beelden te manipuleren, het herstellen van afbeeldingen van schijf, resize images.
Maar je kunt niet per se verbeter ze.
Ik had een foto.
Dus ging ik terug naar RJ hier, die je zag op het scherm al geruime tijd geleden.
En als ik open Keynote hier, dit is wat gebeurt er als je probeert in te zoomen en
verbeteren RJ.
Hij is niet beter krijgen echt.
Nu Keynote is een soort van vervaging het een klein beetje, gewoon om te verdoezelen de
feit dat RJ niet bijzonder krijgt versterkt wanneer u vergroten
En als het op deze manier, Zie de pleinen?
Ja, je kunt zeker zien de vierkanten op een projector.
>> Dat is wat je krijgt als je te verbeteren.
Maar om te begrijpen hoe onze RJ of de Smiley gezicht is geïmplementeerd zal ons laten
eigenlijk code die manipuleert schrijven deze dingen.
En ik dacht dat ik zou eindigen op deze nota, met 55 seconden een verbetering die,
Ik durf zeggen nogal misleidend.
>> [VIDEO AFSPELEN]
>> -Hij liegt.
Over wat, weet ik niet.
>> -Dus wat weten we?
>> -Dat op 9:15 Ray Santoya was de ATM.
>> -Dus de vraag is wat deed hij op 9:16?
>> -Opnamen van de negen millimeter op iets.
Misschien zag hij de sluipschutter.
>> -Of werkte met hem.
>> -Wacht.
Ga terug een.
>> -Wat zie je?
>> -Breng zijn gezicht, volledig scherm.
>> -Zijn bril.
>> -Er is een reflectie.
>> -Dat is het Neuvitas honkbalteam.
Dat is hun logo.
>> -En hij praat aan wie is het dragen van die jas.
>> [END VIDEO AFSPELEN]
>> DAVID J. Malan: Dit zal zijn Probleemverzameling 5.
We zullen je volgende week.
>> MALE SPEAKER: Bij de volgende CS50.
>> [Getjilp van krekels]
>> [Muziek]