>> JASON HIRSCHHORN: Welkom A5, iedereen.
We hebben een spannende week voor de boeg, vooral omdat er zo veel nieuwe
gezichten in deze kamer.
Het is prachtig.
Veel van jullie zijn hier per ongeluk, dat is nog beter.
Dus hopelijk je zult blijven bij ons.
>> Deze week gaan we besteden het grootste deel van de sectie
de voorbereiding voor de quiz.
Dus per onze agenda, we gaan praten een beetje over de middelen voor de klas,
maar ook voor de quiz, en daarna, weer, het grootste deel van de klas te praten door te brengen
over vragen.
Zodra we klaar zijn beantwoording van uw vragen, of als uw vragen
natuurlijk leiden ons naar een aantal codering, ik hebben monster problemen van tentamens
verleden dat we live zal coderen in paragraaf samen die brengen ook op een andere plaats
goede onderwerpen te dekken.
>> Dus eerst, als we door zijn gegaan voor de afgelopen paar weken om u eraan te herinneren
jongens, zijn er een ton van de middelen beschikbaar voor deze cursus.
Velen van hen zullen ongelooflijk nuttig zijn aan u als u doorgaat met
studeren voor quiz 0, omdat Het is dinsdagmiddag.
Dus ieder van jullie zijn geweest studeren voor een beetje.
>> Er zijn dictaten en bron code die je moet
zeker uitchecken.
Bekijk de korte broek.
Check out study.cs50.net.
En dan, hieronder vermeld, een aantal van andere hulpmiddelen.
>> Nogmaals, quiz 0 is morgen bij 01:00.
Als u nog niet hebt gedaan, kijk maar uit de over Quiz 0 document op de
Natuurlijk homepage te achterhalen waar je met de quiz.
De quiz begint om 01:10 en eindigt 70 minuten later.
Dus als u te laten zien na 01:10, je bent gaat dat veel minder minuten te krijgen
dan 70 om de quiz te nemen.
Dus zorg dat je er op tijd bent.
Als je een extensie student of hebben sommige andere testen overwegingen
misschien niet bij 1:00 morgen.
Maar nogmaals, check het over Quiz 0 documenteren om ervoor te zorgen dat u weet wanneer
je neemt de quiz.
Ik schreef 75 minuten hier.
Ik denk dat dat klopt, niet 70.
>> Het heeft betrekking op al het materiaal van een week 0 tot lezing van vorige week op woensdag.
En nogmaals, voor deze quiz, die per document, krijg je een dubbelzijdig en 8
1/2 met 11 vel papier dat u te gebruiken als notities tijdens de quiz.
Veel mensen, zo niet de meeste mensen, hebben vond dat de meest handige manier
om te studeren voor de quiz is om maak een studie blad, een
one-sider, van hun eigen.
Dus kijk naar het verleden die indien je hebt het verleden modellen gezien.
Zoek je vrienden op om te zien wat ze zetten op hen.
>> Maar hands-down, de beste manier dan ook studie is om te gaan door alles en
Whittle het neer op wat wel en wat niet thuis op dat vel
papier, want dat is gewoon een heel handige manier voor u om ervoor te zorgen
je gaat door alles en enige vertrouwdheid met het.
De meeste mensen vinden we, hoewel ze hebben het vel papier zitten recht
naast hen op de quiz, niet inschakelen het, omdat wederom, dat zeer
proces van het gaan door de informatie heeft hen geholpen leren.
>> Heeft iemand enig vragen over quiz 0?
Heeft iedereen -
Ik ga niet naar een show van de handen doen.
Maakt niet uit.
Ik was van plan om die vragen gaan studeren.
Maar ik wil niet dat je te maken al niet je hand op te steken.
Dus zoals ik al zei - ja, Avi, ga je gang.
>> AVI: Wat zou een nuttige zaak zijn op een pager zetten?
>> STUDENT: Dat is aan jou.
>> JASON HIRSCHHORN: U krijgt om je verstand te gebruiken.
Nuttige dingen op de een-pager te zetten, als je verward over de grote O
looptijd van verschillende soorten zoekopdrachten en sorteert, zet dat op er op een
handige dandy grafiek.
Op die manier, als je vroeg bent dat op de quiz, hoeft u niet te proberen en figuur
het uit of reden door de runtime.
Je kunt gewoon kopiëren naar beneden.
Als je kijkt naar quizzen verleden, veel tijden, er loopt tijd vragen.
Dat zou een voorbeeld van een goed ding op uw one-pager te zetten.
>> Andere goede dingen op te zetten, als je verward over hoe te verklaren een
functie of wat de verschillende delen van de functie verklaring zijn, schrijven
dat daar, een generieke versie en dan misschien een voorbeeld.
Als u verward over pointers bent, een diagram van hoe pointers werken is
waarschijnlijk echt nuttig.
Als u verward over recursie, een bent proeven recursieve functie op daar
zou ook blijken echt nuttig te zijn.
Betekent dat u een aantal ideeën?
>> AVI: U moet begrijpen de hele compilatie proces, zoals
hoe dat allemaal werkt?
>> JASON HIRSCHHORN: Everything dat bedekt kan
weergegeven op de quiz.
Vragen -
maar nogmaals, sommige dingen zullen zwaarder gewogen dan andere.
Sommige dingen zijn weer gekomen en opnieuw in de klas, in
lezing, en sectie.
Andere dingen hebben niet komen dat vaak.
>> We hebben veel gesproken over # include en -L iets en wat die betekenen in
het compilatie proces.
We hebben veel gesproken over GDB, vastklampen, deze verschillende vlaggen die wij gebruiken bij
we iets samen te stellen, en wat make15, bijvoorbeeld, echt
betekent en echt doet.
We hebben niet zo veel over praten elke stap in
het compilatie proces.
We hebben nog steeds over gesproken.
Dus het is nog steeds iets dat je moeten kennen.
Maar nogmaals, we gaan niet te zijn -
dingen die komen vaker in de klas hebben meer kans om meer te komen
vaak en worden zwaarder gewogen op de quiz.
>> Cool.
Andere vragen heeft over quiz 0?
>> OK, dus heb ik een lijst van onderwerpen op het bord.
Ik ging door de syllabus.
Ik ging door de review sectie van gisteravond en deze dia's te komen
met een niet-exhaustieve lijst van onderwerpen dat we tot nu toe in CS50 hebben afgelegd
en dingen die zouden kunnen verschijnen op de quiz.
Dus ik ben niet van plan om door te gaan elk van deze.
Dat zou veel meer rekening tijd dan we nu hebben.
Maar ik zet dit hier hopelijk jog je geheugen als om dingen die kunnen
of misschien niet zo vertrouwd zijn met je.
>> En ik zou graag het grootste deel van door te brengen sectie beantwoorden van uw vragen over
deze onderwerpen, onderwerpen die worden hier niet behandeld.
We kunnen pseudo-code te schrijven.
We kunnen echte code te schrijven om ervoor te zorgen dat u -
Ik kan uw vraag te beantwoorden en te helpen iedereen fundamenteel begrijpen
Veel van deze onderwerpen, zodat je voelt voorbereid en comfortabel in te gaan op
de quiz morgen.
Dus lees over de lijst.
Hopelijk zijn gekomen om deel met enkele vragen ook.
Als je klaar bent, steek je hand en wij zullen aan de slag.
>> Houd in gedachten, de vragen die je hebt, er zijn geen domme vragen.
We hebben dat een veel gehoord.
En de vragen die je hebt, ik ben bereid om in te zetten, veel andere mensen, zowel
hier zitten en kijken online te hebben.
Dus je kan alleen maar helpen mensen door vragen te stellen.
Marcus.
>> MARCUS: Tussen de stapel en de hoop, is er een pre-toegewezen
percentage van het geheugen dat is gedefinieerd als dit is voor de stack of voor de hoop?
Of hoe werkt dat precies?
>> JASON HIRSCHHORN: Goede vraag.
Ik ga terug traceren een beetje.
Doet iedereen -
hier eerlijk te zijn.
Ik weet dat ik je vraag te verhogen uw hand voor uw collega's.
Maar zijn er mensen die het gevoel hebben ongemakkelijk met de stack en heap
en wil graag gaan over dat en wat die betekenen?
Steek je hand op als -
OK.
Dank u.
Dus we gaan te gaan over de stapel en de hoop heel snel en dan
verplaatsen in het beantwoorden van uw vraag.
>> Dus als we trekken uit een doos te vertegenwoordigen geheugen op uw computer, wat zijn sommige
dingen die verder gaan in dit vak?
Main.
Een hoofdfunctie.
Waar komt belangrijkste heen?
>> STUDENT: [onverstaanbaar].
>> JASON HIRSCHHORN: Dus we zet hier beneden belangrijkste.
Wat gaat in dit vak?
>> STUDENT: De functies die u belt.
>> JASON HIRSCHHORN: De functies we noemen.
En waar gaan ze naartoe?
>> STUDENT: In de stapel.
>> JASON HIRSCHHORN: Ze gaan in de stack.
Dus we gaan op dit verzoek ding hier beneden de stapel.
En tot boven, we hebben de hoop.
Dus geheugen is niet een doos net als dit.
Maar het is eigenlijk vrij gelijkaardig.
Het gaat om een ​​heleboel dozen worden over en dan, afhankelijk van hoe groot uw
computer is of hoe groot je geheugen is.
>> Aan het citaat-unquote "bottom" is de stack.
En er zijn meerdere dingen dat op de stapel.
En die is afhankelijk van de functies je hebt in je code.
Je hebt altijd een functie in uw code genaamd main, dus er is altijd een
sectie hier beneden in de stack gewijd aan de belangrijkste.
>> Deze secties in de stapel stack frames worden genoemd.
Wanneer u een andere functie aan te roepen, zeggen de belangrijkste noemt een binary search functie,
zetten we een ander frame op de stapel.
Meer specifiek, gaan we doneren een deel van het geheugen op onze
computer op te slaan binary search lokale variabelen en de binaire draaien
zoekcode.
>> Dus noemen we binary search.
In dit stuk van het geheugen, gaan we zijn lokale variabelen op te slaan.
We gaan haar printf oproepen opslaan.
Wat er ook gebeurt, die functie is zal daar worden opgeslagen.
Binary search gaat voeren.
Het gaat om de uitvoering te voltooien.
Wat is het woord in C, dat betekent dat een functie moet
voltooien de uitvoering ervan?
>> STUDENT: Return.
>> JASON HIRSCHHORN: Return.
Dus wanneer je een return-statement, de functie eindigt
als het hits dat.
Dus binary search zal zijn terugkeer raken.
Dit deel van het geheugen zal wezen worden vrijgemaakt.
En de belangrijkste terug naar uitvoering te gaan.
Dus belangrijkste pauzeert waar was, oproep binary search, nog wat return waarde,
en verder uitvoering.
Dit stackframe weg zal gaan.
>> Als we een recursieve functie, bel die is een functie die zichzelf aanroept dan
en dan zouden we krijgen - zeggen dat we deed binary search recursief.
Misschien krijgen we binary search versie een, binary search twee, binary search
drie, binary search vier, binary search vijf.
En dan is dit laatste binaire zoekopdracht vijf zal de base case, en de stapel raken
frames terug zal gaan en blijven sluiten tot we terug naar de hoofdpagina.
We kunnen gaan over recursie in een beetje.
Maar dit alles wil zeggen, als je Met meerdere functies tegelijk,
er zullen meerdere stack frames op de stapel.
>> De heap, anderzijds, op Hier is niet te functies
niet voor lokale variabelen.
Het is voor dynamisch toegewezen variabelen.
Dit zijn variabelen die kunnen worden geïnitialiseerd in zowel hoofd-of een
functioneren dat de belangrijkste gesprekken.
Overal in uw code, ze kunnen worden geïnitialiseerd.
En een dynamisch initialiseren toegekende variabele.
Welke functie in C gebruiken we?
>> STUDENT: Malloc.
>> JASON HIRSCHHORN: Malloc.
U belt malloc.
Je krijgt een ruimte van het geheugen.
En die ruimte van het geheugen is op de heap.
En die ruimte van herinnering blijft daar staan ​​totdat u gratis bellen.
>> Dus dynamisch toegewezen variabelen in heap zal bestaan ​​voor zo lang als je
willen dat ze bestaan, en zij zullen niet ga weg totdat u expliciet
vertel hen om weg te gaan.
Je kunt ze maken in een functie.
Stack die functie kader zal verdwijnen.
Maar dat variabele blijft bestaan in de hoop tot het wordt vrijgemaakt,
mogelijk door de functie die genoemd binary search of wat dan ook.
>> Dus die hoop variabelen blijven er voor zo lang als je wilt
hen om daar te blijven.
En krijgen ze hier plaatsen.
En dan de volgende krijgt men daar te zetten.
Ze houden steeds gevuld in, en ze daar blijven totdat u gratis bellen.
>> En in wezen, de hoop en de stapel, om naar Marcus de vraag,
groeien naar elkaar toe.
En als ze lopen in elkaar over, je hebt opgebruikt al het geheugen in uw
computer, en uw programma zal stoppen want je hebt geen geheugen meer
links te gebruiken.
Tussen hen er mogelijk andere dingen.
Maar voor de omvang van deze cursus, u geen zorgen te maken over dat.
>> Dus dat was het antwoord op uw vraag.
Zit u er niet over in.
Maar dat was het lange antwoord.
Alles wat je moet weten is de en de stack zal -
een vanaf de bodem.
De stack doet.
De hoop is daarboven.
Zij dichter bij elkaar groeien.
>> En als ze aanraken, dat is een probleem.
Je liep uit het geheugen.
Maar ook naast weten waar zij worden, wat opgeslagen in zowel de
stack en heap.
Curtis.
>> CURTIS: Als ze botsen, is dat een stack overflow?
>> JASON HIRSCHHORN: Als ze botsen, dat is niet een stack overflow.
Een stack overflow is een ander gebied dat we dan kunnen gaan als je wilt.
OK, we komen terug naar die komen in een beetje.
>> STUDENT: Wat is het woord genaamd als ze elkaar raken, de
stack en de heap?
>> JASON HIRSCHHORN: Voor nu, maak je geen zorgen over.
Gewoon weten -
Ik zal die vraag te beantwoorden na de les.
Als ze lopen in elkaar over, liep je uit van het geheugen, omdat er geen meer
ruimte is er.
>> STUDENT: Sorry, wat is een seg fout?
>> JASON HIRSCHHORN: A-segment fout kan worden opgeroepen -
het hangt af waarom de seg fout heet.
Soms, je stack overflow, het zal zeggen seg fout als de fout.
>> STUDENT: Hoe zit dereferentie een null variabele?
Is dat een seg schuld?
>> JASON HIRSCHHORN: dereferentie een null pointer -
OK, dus als je een pointer die je ingesteld die gelijk is aan null, pointers, rappel,
winkel geheugenadressen hun waarden.
En een null pointer is in wezen het opslaan van 0, de 0-ste
pakken in die variabele.
Dus 0x, 0, 0, 0, 0, et cetera.
Dat 0-th adres in het geheugen dat is niet in onze foto, dat is daarboven
ergens, dat is voorbehouden voor de computer.
We mogen het niet aanraken.
>> Dus als je programma's uitvoeren, indien iets probeert naar het geheugen
adres 0, weet dat dat een lege waarde.
Het weet niets moet er zijn.
Dus als je er te proberen en gebruik iets en als er iets te behandelen of
proberen om naar die locatie, je bent gaan naar een seg fout of een foutmelding krijgt.
Is dat een antwoord op je vraag?
>> En nu gaan we terug te gaan overflow stapelen.
Dingen in de stack, zoals jullie hebben eerder gezien, in - laten we trekken een nauwe
up van een stapel frame.
Kan iedereen zien dat?
Dus hebben we onze stack frame.
We zijn het opslaan van een array in een lokale variabele in deze functie.
Dat zeggen ons aanbod heeft vijf plekken.
Alle vijf van deze worden opgeslagen in die stack frame.
>> Als we beginnen met het schrijven van buiten de grenzen van deze array -
dus als we beginnen met het schrijven in, laten we zeggen dat is 0.
Dat zijn de vijf indexen van onze array.
Als we beginnen te schrijven in index 5, die we hebben niet als we een
scala van maat 5, beginnen we schrijven in index 6, 7, 8, 9, we kunnen een Stack krijgen
Overflow error.
>> Over het algemeen is het niet -
zal je waarschijnlijk in de problemen als je dan gaan voor een.
Maar in het algemeen, zal je in de de meeste problemen als je over te gaan door veel
en je zo ver over dat je schrijft gaan over de terugkeer adres van die
functie, die is gelegen op de onderop de stapel frame.
>> Omdat, toch?
Je - in de - sorry.
Niet "omdat rechts."
>> In de stack frame, je hebt uw lokale variabelen.
Aan de onderkant van de stapel frame is het retouradres.
Dat is waar de functie gaat als het voorbij is.
En als je dat rendement overschrijven adres, dan wanneer dit stackframe,
wanneer je gaat door de stapel kaderen en uitvoeren van elke lijn, je bent
ga naar uw nieuwe retouradres dat is er geschreven in plaats van de
huidige.
En dat is hoe we hebben gezien sommige inbreuken op de beveiliging
kan gebeuren met computers.
>> Dus stack overflow, kortom, is wanneer u het deel overschrijven in de stapel
je zou moeten gebruiken, de lokale variabele je zou moeten gebruiken, en
in het bijzonder wanneer u begint met het overschrijven belangrijke zaken als de
retouradres.
En dat is waar je een foutmelding krijgt.
Of misschien zelfs kan je beginnen zelfs schrijven in -
zeggen binary search was recht boven belangrijkste.
Als je overschreef veel, je kon schrijven in de belangrijkste.
Maar over het algemeen krijg je een foutmelding voordat Vervolgens, omdat de computer weet
dat je iets doet je niet zou moeten doen.
Yeah.
>> STUDENT: Wat is het verschil tussen een stack overflow
en een buffer overflow?
>> JASON HIRSCHHORN: Buffer overflow is een meer algemene vorm van
wat ik net heb beschreven.
>> STUDENT: Dus een stack overflow is een voorbeeld van een buffer overflow.
>> JASON HIRSCHHORN: Precies.
Dit is een serie die we kunnen bedenken als een buffer, een ruimte voor de dingen naar binnen
Dit is een stack buffer overflow.
We konden een heap buffer overflow te hebben.
Als er een buffer, waarvoor vaak is een array de hoop, en we
overschreven die grenzen, dan zouden we hebben een heap buffer overflow.
>> En buiten het bestek van deze cursus, ze ontdekt een beetje anders.
De compiler heeft speciale de opsporing van elke.
Maar een buffer overflow is een meer generieke type wat ik beschreef,
dat was een stack buffer overflow.
Heeft dat uw vraag beantwoord?
Sweet.
>> Waren er nog andere vragen over om de stapel of de hoop?
Yeah.
>> STUDENT: Ik weet dat je moet gratis strings omdat ze in de hoop
en je wilt niet het geheugen lekken.
Maar heb je om globale variabelen te bevrijden en dat soort dingen?
Of worden ze automatisch bevrijd?
>> JASON HIRSCHHORN: Goede vraag.
Dus in CS50.H, creëren we dit ding voor u een string genaamd.
Een string is echt wat?
>> STUDENT: Char ster.
>> JASON HIRSCHHORN: Een char ster, een pointer om een ​​teken, een pointer naar
een reeks tekens.
Dat is wat de string is.
Dus we moeten bevrijden, omdat getString, die we veel gebruikt -
string naam gelijk getString -
dat mallocs voor ons deel van het geheugen op de hoop en dan geeft een pointer naar de
eerste teken van die koord, een char ster.
>> Dus schijnbaar, als je nog niet geweest vrij schrijven op een van uw snaren
dat je tot nu toe hebt genoemd, je hebt gelekt wat geheugen.
Natuurlijk hebben we niet gesproken over , dus niemand heeft gekregen in
moeite voor doen.
Maar de toekomst, ja.
Wanneer u getString belt, je bent mallocing wat ruimte op de heap.
En als je niet gratis bellen later op die snaar, je hebt een geheugenlek.
Dat antwoord op uw vraag?
>> Ja
>> STUDENT: Dus om dat te doen, gebruiken we gratis vlak voor terug?
Net als in het kader van, denk ik zo we zeggen, als, int main, binnen de
werkingssfeer van de code die binnen die accolades, vlak voor -
je weet waar je zou doorgaans op terugkeer.
Zet je vrij daarvoor?
>> JASON HIRSCHHORN: Dus je kunt vrij zetten waar je vrij wilt zetten.
Omdat deze dynamisch toegewezen variabelen, omdat ze kunnen
leven buiten het kader van een bepaalde functie, als je malloc bellen in een
aparte functie, bijvoorbeeld, getString, kunt u gratis bellen in de belangrijkste.
U hoeft niet te noemen de specifieke functie
waar malloc wordt genoemd.
Maar je moet het ook noemen voordat belangrijkste rendement.
>> En het is echt afhankelijk.
Het hangt af van de reden waarom u dat malloced ruimte in de eerste plaats.
Sommige mensen zullen noemen vrij snel bevrijden.
Sommige mensen zullen niet gratis bellen tot het einde van het programma.
En ze gaan door en gratis alles.
Het hangt af van de reden waarom u malloc genoemd.
>> STUDENT: En wat zou je zeggen als je gebruik getString genoemd?
Je zou zeggen dat vrij wat?
>> JASON HIRSCHHORN: Dus de syntaxis voor gratis is gewoon gratis, open Paren, dicht
Paren, en de naam van de aanwijzer.
Dus als je schrijft tekenreeksnaam gelijken getString, zet je naam hier.
Dat is de naam van de aanwijzer.
En hij weet dat het geheugen vrij te maken.
>> STUDENT: Dus als het bevrijdt dat het geheugen, de wijzer wijst nog steeds naar die plaats
in het geheugen?
Of is het wijzer ook ontdaan van het adres dat het wijst op.
>> JASON HIRSCHHORN: We moeten proberen dat.
We moeten coderen dat.
Laten we terugkomen als we in codering, en laten we coderen dat.
En als je wilt weten het antwoord aan dat, kunt u ook de code die
in de tussentijd.
Maar dat is een grote vraag.
>> STUDENT: Is het mogelijk om gratis iets te snel?
Dus je moet nog steeds het voor uw programma, en je dat geheugenruimte vrijgemaakt?
>> JASON HIRSCHHORN: Ja.
Het is mogelijk, als je gratis iets en vervolgens opnieuw te gebruiken heb, zal je
lopen in een fout.
Maar dat is op je, omdat je bevrijd iets en dan noemde het later.
Dus dat was een vergissing programmeur.
Maar ja.
Je kon schrijven dat.
>> Meer vragen op -
Ja.
>> STUDENT: Dus als je wordt verondersteld om gewoon bevrijden in het algemeen voor de
programma eindigt, betekent dat, indien de programma eindigt en je niet bevrijden,
dat geheugen is nog steeds toegewezen?
>> JASON HIRSCHHORN: Als uw programma eindigt en je vergeet om iets te bevrijden, dan
dat het geheugen werd gedurende toegewezen de levensduur van uw programma.
Wanneer uw programma wordt afgesloten geheel, dat geheugen is niet van plan
om daar voor altijd blijven.
De computer is slim genoeg om te weten dat wanneer het programma wordt afgesloten, het
dient zich te ontdoen van al het geheugen dat werd geassocieerd met dat programma.
>> Echter, er zijn tools die u kunt uitvoeren op een programma om te detecteren of, wanneer de
programma afgewerkt, je vergat om wat geheugen vrij te maken.
En voor uw volgende probleem stellen waar je zult gebruiken malloc en het gebruik van
pointers, zult u het uitvoeren van dit programma op uw programma om te zien of,
als belangrijkste rendement, je had een aantal dingen die unfreed werden achtergelaten.
>> Dus ze gaan niet malloced blijven voor altijd in uw computer.
Dat zou verspilling zijn, omdat zeer snel, computers
zou onvoldoende geheugen.
Maar als ze lopen tot het einde van uw programmeren en ze zijn niet bevrijd en uw
programma wordt afgesloten, dat is nog steeds een probleem dat deze tool zal u helpen aanpakken.
>> STUDENT: Is dat Valgrind?
>> JASON HIRSCHHORN: Het is genoemd Valgrind.
En je zult -
>> STUDENT: Maar we hoeven niet te weten dat voor de quiz, hoewel?
Ik bedoel, werd gesproken over een beetje in collegezaal.
>> JASON HIRSCHHORN: Dus Valgrind is de naam van dat gereedschap.
Weten wat het doet is genoeg voor de quiz.
Maar je hebt het nog niet gebruikt op uw probleem stellen, omdat we hebben niet een
probleem set die uitdrukkelijk heeft behandeld met malloc of u met behulp van malloc.
Dus je hebt nog niet gebruikt Valgrind.
Maar je zal het gebruik eerder eerder dan later.
>> STUDENT: Kan je herhalen wat Valgrind is?
>> JASON HIRSCHHORN: Sorry?
>> STUDENT: Kan je wat herhalen het doel van Valgring is?
>> JASON HIRSCHHORN: Valgrind heet -
zoals GDB helpt je je programma debuggen, Valgrind helpt je erachter te komen of
dingen zijn niet bevrijd wanneer het programma wordt afgesloten.
Dus je zult het uit te voeren op uw programma.
En uw programma wordt afgesloten, en het zal zeggen: uw programma genaamd malloc dit veel
tijden voor deze vele bytes, en u alleen gratis noemde dit vele malen.
En dus je deze vele bytes links zonder te worden bevrijd.
Of het zal zeggen dat je alles hebt bevrijd.
Goed gedaan.
>> STUDENT: OK.
En het is Valgring genoemd?
>> JASON HIRSCHHORN V-A-L-G-R-I-N-D.
>> STUDENT: Een vraag over pointers.
Dus zeggen dat je hebt n ster x gelijk is aan iets.
Dat is gelijk aan, wat je zetten daar, is dat wat er wordt binnen zetten
x wat wijst op, of de wijzer van x?
>> JASON HIRSCHHORN: Kunt u herhaal de vraag?
Kunnen we trekken terwijl je het zegt?
>> STUDENT: In de quiz, eigenlijk, de degene die je ons gestuurd, het was, char
ster waarheid gelijk CS50 rotsen, toch?
Betekent dat dan dat die CS50 rotsen is wat de waarheid wijst naar?
>> JASON HIRSCHHORN: Dus je praat over een char ster in een string, hoe
dat werkt?
Yeah.
OK.
Laten we trekken deze hier.
>> [SIDE GESPREK]
>> JASON HIRSCHHORN: Dus deze variabele gaat van het type char ster te zijn.
Hoe groot is een variabele van het type char ster?
Hoeveel bytes?
>> STUDENTEN: Vier.
>> JASON HIRSCHHORN: Het is vier bytes.
Hoeveel rechten is een variabele van het type int ster?
>> STUDENTEN: Vier.
>> JASON HIRSCHHORN: vier bytes.
Als het een pointer, dan is het altijd vier bytes, omdat pointers hun
waarde is een geheugen adres.
En geheugen adressen op de CS50 apparaat zijn vier bytes lang.
Dus toen we getString, of wanneer we noemen zeg, stringname gelijk, en vervolgens in
dubbele aanhalingstekens zet een string, we zetten -
nou, dat is een beetje anders.
We doen getString als voorbeeld.
Of char ster iets is gelijk aan de string.
Sorry, geef mij het voorbeeld dat je leest?
>> STUDENT: char ster waarheid gelijk "CS50 rocks" dubbele aanhalingstekens.
>> JASON HIRSCHHORN: Dus deze ster, dit we zullen deze variabele x bellen voor onze
algemene doeleinden.
We hebben een variabele genaamd x gemaakt.
Het is het type char ster.
Het is een pointer naar een reeks karakters.
Dus hier beneden -
>> Dus dit is hoe dit zou werken in het geheugen.
Dit zou een geheugen adres op te slaan.
Het zou het geheugen adres van slaan het eerste teken in de array.
En dan wanneer je gevolgd de aanwijzer, zou je
krijgen de eerste letter.
>> En als je dit leest zoiets een string, uw computer is slim
genoeg om te weten, lees dit hele ding totdat het bij een terugslag 0.
Maar als je dit leest het een teken op een tijd, dus je itereren door
deze string, dan zul je net hebt gelezen een karakter per keer tot u bij
backslash 0.
Dat is misschien niet het antwoord op uw vraag, dat wel.
>> STUDENT: Ja, maar je hebt niet malloced die ruimte
nog voor dat pointer.
>> JASON HIRSCHHORN: Dus ik ben niet helemaal zeker precies wat u zoekt op,
omdat ik niet die quiz maken.
Dat zou een nuttig te zijn deze bij een andere TF.
Als u een string op de stack of als een lokale variabele, het zal
net scala aan kosten in plaats van zijn algemeen een char ster wijst naar
andere string.
Maar ik weet het niet.
Dat kan een pointer naar de andere string op de stapel ook.
Yeah.
>> STUDENT: Ik weet dat je nodig hebt om geheugen toewijzen als de aanwijzer
krijgen binnen verklaard van een andere functie.
Heb je nodig om hetzelfde te doen als het binnenkant van de belangrijkste wordt verklaard,
je gebruikt het binnen van de belangrijkste?
>> JASON HIRSCHHORN: Dus ja.
U kunt een pointer verklaren aan een geheugen adres in het geheugen.
Het kan het geheugen adres van een lokaal zijn variabel, maar vaak,
mensen niet geheugenadressen verklaren om lokale variabelen, omdat ze gaan
weg zodra die functie geeft, die Daarom hebben we malloc algemeen dingen.
Maar ja, je kon een pointer verklaren een andere lokale variabele.
Het is gewoon in het algemeen niet gedaan.
Maar ik kan een kijkje nemen op die rekening specifiek ding na de les.
Yeah.
>> STUDENT: Ik denk dat dit soort van wat er wordt gevraagd.
Het lijkt vreemd om te initialiseren een pointer niet als
adres, maar als wat lijkt een waarde.
Het lijkt alsof de CS50 is wat erin zit het ding wordt gewezen op en
niet de feitelijke adres, toch?
>> JASON HIRSCHHORN: Dus dat is niet het geval, dat wel.
Dat is niet wat er gebeurt.
Wanneer u verklaren een char ster, het is een geheugen adres.
Pointers zijn alle geheugenadressen wijzend naar iets anders.
Dat er iets anders zou kunnen zijn op de stack, maar bijna altijd op de
hoop in de manier waarop we zullen zien het gebruikt.
Maar stringname evenaart double-citaat "GetString," kunnen we dat zien en we
kunnen kijken door die en coderen dat.
getString snaar wordt niet in wordt opgeslagen die variabele of ongeacht de tekenreeks
naam is niet in die gered variabele, want dat is niet hoe
pointers werken.
Is dat logisch?
>> STUDENT: Ja.
>> JASON HIRSCHHORN: OK.
Hopelijk, dat was niet verwarrend voor iedereen.
Maar als het was, kunnen we weer kijken in een beetje, omdat we eigenlijk aan de hand
om iets dat hopelijk zal coderen werken met strijkers en helpen voelen
meer comfortabel met hen.
>> Andere vragen met betrekking tot deze onderwerpen of andere onderwerpen die
Ik kom terug zetten?
En -
nu.
Ja, Alden.
>> ALDEN: Dus dit is helemaal los, maar we kunnen alleen gaan over
heel snel wat we moeten weten over het verschil tussen 32 en
64-bit machine?
>> JASON HIRSCHHORN: Ja.
Dus 32 bits is hoeveel bytes?
>> ALDEN: Het is vier bytes.
>> JASON HIRSCHHORN: Het is vier bytes.
En 64 bits is hoeveel bytes?
>> STUDENT: Acht.
>> JASON HIRSCHHORN: Acht bytes.
Dus nogmaals, acht bits is een byte.
Uw CS50 apparaat een 32-bit machine.
Dus geheugenadressen zijn vier bytes lang.
Er zijn 2 van de 32 geheugenadressen.
0 tot 2 tot de 32 min 1.
En ik ben niet positief, maar dat is waarschijnlijk de omvang van wat je nodig hebt om
weet voor een 32-bit machine, dat het geheugen adressen zijn, nogmaals, vier bytes lang,
en dat is het maximumbedrag van geheugenadressen.
>> Ook gegevenstypen -
dit kan iets zijn Nou dat is vermeldenswaard.
De grootte van een gegevenstype afhangt de machine waarmee u werkt.
Dus een char, een karakter, is hoe veel bytes op onze CS50 apparaat?
Een byte.
En het is eigenlijk een byte als goed op een 64-bit machine.
>> En de meeste data types zijn hetzelfde nummer bytes op beide machines.
Maar sommige soorten data zal anders zijn op beide machines.
Dat zou potentieel de enige wat je moet weten.
>> Maar zelfs dat, denk ik, is buiten de grenzen -
Ik ben bijna zeker, als je terugkijkt bij oude quizzen, zegt het, aannemen
codering problemen die u gebruikt een 32-bit machine.
Maar er zijn, om mee te gaan met die in Mocht je geïnteresseerd zijn, zijn er
gegevenstypen die hetzelfde zijn grootte op alle machines.
>> Als je zoiets hebt gezien uint32_t, kunt u of kan
niet hebben gezien dat.
Dat is een soort data.
Dat is te zeggen, zijn 32 bits niet uit wat machine dit is op.
Dus als mensen schrijven draagbaar code, zullen zij waarschijnlijk niet ints gebruiken.
Ze zullen in plaats daarvan gebruik maken van deze andere gegevens types waarvan ze weten dat hetzelfde zal zijn
grootte op elke machine.
Madhu.
>> Madhu: Ik had een vraag over het compilatie proces.
Dus als je het schrijven van een programma dat gebruik maakt van een bibliotheek zoals CS50 of iets
als dat, ik weet dat die bibliotheek moet, op enig moment, worden
gecompileerd en gekoppeld inch
Maar hoeveel van dat gebeurt tijdens het samenstellen van uw programma?
Welk deel van die bibliotheek proces treedt op wanneer u bent
het samenstellen van je eigen programma?
>> JASON HIRSCHHORN: Dus laten we gaan over algemeen de stappen van dit proces.
Je schrijft je. C-bestand.
In je. C bestand, je # include uw header bibliotheken, bijvoorbeeld cs50.h.
Wat doet dat scherp onder lijn doen om uw programma?
Akchar.
>> AKCHAR: Het voegt de prototypes van de functies van de kop
bestanden in de bibliotheken.
>> JASON HIRSCHHORN: Precies.
Het voegt deze functie prototypes aan uw code.
Dus wanneer uw code wordt in gecompileerde de vroege stadia, de compiler weet
dat deze functies echt bestaan, en dat zij ergens zijn gedefinieerd.
Het. H bestanden omvatten niet de definities voor deze functies of hoe
zij feitelijk werken.
Cs50.h bevat gewoon iets dat zegt getString is een echte ding dat
kan gebeuren.
En standardio.h zegt printf is een echte ding dat kan gebeuren.
>> Header zodat je c taal met dit. bestand wordt omgezet in een aantal
machineleesbare code die uiteindelijk wordt omgezet in binaire
code, 0 en 1's.
En dat is de code die uiteindelijk wordt uitgevoerd.
De-l CS50 lijn - bijvoorbeeld, wanneer je het schrijven van Clang -
en dan moet je onder-l CS50, je dat type inch
En je ziet dat.
Als je schrijft te maken, zul je zien dat line-up hier.
En we zullen zien dat in een tweede toen We coderen of later, als we code.
>> Maar dat-l CS50 lijn doet iets een beetje anders dan
de # include cs50.h.
Wat betekent dat-l CS50 lijn doen?
Avi?
>> AVI: Ik wil zeggen dat het linkt de bibliotheek van de functie
noemen, zoals de. o bestanden.
>> JASON HIRSCHHORN: Zo erg dicht, zo niet spot-on.
De-l CS50 neemt het binaire bestand en fuseert met uw binair bestand.
Dus cs50.h, er is geen punt in het draaien cs50.h van C-taal voor elke binaire
keer weer het wordt gebruikt.
Dat zou dom zijn, want dat zou een hoop tijd te verspillen.
Zo is reeds samengesteld en omgezet in een uitvoerbaar.
En nu zal samengevoegd worden met uw dossier aan het eind.
Dus die 1's en 0's gaan te fuseren met uw degenen
en 0 bij het einde.
Dus nu ga je eigenlijk de werkelijke 1's en 0's die hoe getString definiëren,
bijvoorbeeld, werkt, of hoe printf, bijvoorbeeld, werkt.
>> En voor meer informatie, er is een korte compilers dat Nate geeft dat
je zou moeten controleren dat gaat door middel van deze stappen.
Maar -
Ja.
>> STUDENT: Zijn ze altijd in o-bestanden. als ze in de bibliotheek vorm,
klaar om te worden samengevoegd, verbonden - zoals ze zijn in de binaire code?
>> JASON HIRSCHHORN: OK.
Wat -
>> STUDENT: Is dat altijd het geval voor de bibliotheken als je ze koppelen?
>> JASON HIRSCHHORN: Ja.
Dus er is. S-bestanden, die zal worden machine code, die ook zal worden
cryptisch aan u.
U hoeft geen zorgen te maken over die.
Maar in het algemeen, ja, zullen ze in. o-bestanden klaar om te gaan.
>> STUDENT: Dus als je het schip naar een bibliotheek, hoeft u alleen het schip
het. h en de. o?
Je hoeft niet het schip van de. C of de. S.
>> JASON HIRSCHHORN: Dus -
en dat is in dit kort ook, als Deze informatie lijkt te komen een
beetje snel.
Maar de korte over compilers praat over dit zo goed.
Als je schip een bibliotheek, als je schip het. h, de header file, die
functie prototypes, en de 1 en 0's, dat is alles wat je nodig hebt om te geven.
U hoeft niet op te geven hoe de functie werkt, de c-bestand..
Omdat de punt van abstractie, of wijzen API's, het punt deze SPL,
de Stanford draagbare bibliotheek, het is voor u om geen zorgen te maken over hoe de nieuwe
GRect werkt, of hoe werkt bewegen, of hoe werkt voegen.
Alles wat je moet weten is dat add is een functie die u kunt
gebruikt, en het dit doet.
Zodat je echt niet nodig om te weten hoe het is geschreven in C. Je hoeft alleen maar te
weten, hier zijn de functies, wat ze doen, en hier zijn de de 1 en 0
als je echt wilt om ze te gebruiken.
>> Cool.
Nog meer vragen over compilers of andere onderwerpen op het bord?
>> STUDENT: Ik heb een vraag van uitvoering van recursieve functies.
Een vraag over recursie.
Ik had een gevoel dat zou komen.
Dus laten we snel gaan door recursie met specifieke
bijvoorbeeld een faculteit-functie.
Omdat dit een voorbeeld dat vaak komt of wordt gebruikt
te illustreren recursie.
>> Zo "4!" wordt gelezen als 4 faculteit.
En wat betekent 4 faculteit betekenen?
Wat doet dat?
Hoe doe je 4 faculteit berekenen?
4 maal 3 maal 2 maal 1.
>> Dus een andere manier om 4 faculteit schrijven is om dit te schrijven.
4 keer 3 faculteit.
Omdat 3 faculteit is 3 maal 2 maal 1.
Dus 4 keer 3 faculteit is 4 tijden 3 keer 2 keer 1.
Dit is de reden waarom faculteit is een geweldige kandidaat voor recursie, omdat het
duidelijk dat er iets is dat gebeurt over en over en over op een
kleiner aantal dingen tot je het einde bereikt.
Wanneer u 1 te bereiken, 1 faculteit is 1.
Je kunt niet veel verder.
0 factoriële wordt ook gedefinieerd als 1.
Dus als je naar 1 of 0, je bent aan het eind, en u kunt
start gaan back-up.
Dus als we wilden een recursieve schrijven functie om een ​​factorial berekenen,
we gaan wat schrijven pseudocode voor dat nu.
Voordat we schrijven dat pseudo -
Ik zal jullie geven een paar minuten aan de pseudo-code schrijven of denk gewoon
over het - er zijn twee dingen elke recursieve functie nodig heeft.
Wat zijn die twee dingen?
>> JACK: Het heeft zichzelf noemen.
>> JASON HIRSCHHORN: Noah?
Oh, Jack.
Ga je gang.
>> JACK: Het heeft zichzelf noemen.
>> JASON HIRSCHHORN: Dus een recursieve functie vereist een recursieve aanroep, een
op zichzelf te vestigen.
Dat is een.
En wat is het andere ding?
>> JACK: Een base case.
>> JASON HIRSCHHORN: Een base case.
Een base case is, hier is als we stoppen.
Dus uw functie wordt aangeroepen.
Het nulalternatief komt eerst.
Je wilt weten of je op het einde.
En als je niet aan het eind, u maak uw recursieve aanroep.
En je door deze functie opnieuw, controleer je base case weer.
Als je niet het einde, je maakt een recursieve aanroep,
et cetera, et cetera.
>> Daarom recursieve functies altijd die base gevallen en die moeten
recursieve oproepen.
Als je niet een recursieve aanroep hebben, zou een recursieve functie.
Als je een base case had, je voor altijd zou gaan en
geen einde zijn.
En het basisscenario komt altijd op de eerste, omdat je altijd wilt controleren
als je aan het eind eerste.
Dus voordat we doen wat pseudocode, waarom ga je niet even de tijd nemen om na te denken over
hoe een recursieve faculteit-functie worden geschreven?
>> Ook, zo veel als je aan het doen bent, het schrijven het uit op een vel papier is
wat je gaat te hebben om doen op de quiz morgen.
Dus waarschijnlijk goede praktijken te maken ervoor dat de code die u aan het schrijven bent
neer op een vel papier -
of kun je dat doen.
Je weet waar de puntkomma zijn.
Herinnert u zich de syntaxis.
Omdat je niet in staat zijn om een compiler vertellen dat je een fout maakte.
>> Ook volgens die lijnen, morgen, wanneer je hebt codering problemen, als u
gehaast voor tijd, of als je heel verward hoe je zou moeten
schrijf de bijzonder ding in c, het zou behoove u pseudo-code te schrijven
of schrijf commentaar in ook.
Omdat er gedeeltelijke krediet voor een Veel van de vragen over de quiz.
Dus je zou kunnen worden gehaast, of u misschien worden verward.
Schrijven in commentaar of pseudo-code zijn vaak manieren die u
kan gedeeltelijk krediet te krijgen.
>> Dus niet iets laten leeg op de quiz.
Er is geen sancties voor zetten dingen in
In feite, de invoering van pseudo-code of reacties gaat de grader helpen
erachter te komen of je eigenlijk wel wat je het over hebt, en misschien award
u een aantal gedeeltelijke credit voor.
>> Ook langs die lijnen, duidelijk schrijven.
Als we kunnen niet echt wat je aan het schrijven bent, we gaan niet om u te bellen
om middernacht morgen figuur wat je schreef.
We gaan gewoon opstijgen punten.
Schrijf duidelijk zodat we kunnen horen, of liever, we kunnen lezen wat je schreef.
>> En als het zegt twee zinnen, niet een paragraaf niet schrijven.
Volg de instructies.
Schrijf duidelijk.
En schrijf in die commentaar of pseudocode voor vragen die kunnen
award gedeeltelijke credit.
>> OK, laten we naar faculteit.
We hebben dus een functie faculteit.
Als ik dit ook daadwerkelijk te schrijven in C, wat heb ik nodig voor de naam te zetten
van de functie?
De return type, die in dit geval is, zullen we het geven int.
En vervolgens binnen de accolades, is wat er binnen de accolades voor
een functie?
>> STUDENTEN: argument type.
>> JASON HIRSCHHORN: Haar argumenten.
Dus faculteit zal waarschijnlijk met een extra argument.
Het zal het waarschijnlijk slechts een argument.
En we zeggen het duurt x een geheel getal genoemd.
En nogmaals, bij het schrijven van het prototype van een functie of beschreven functie
in uw code voor het definiëren, je schrijf de gegevenstype en naam
die variabele alleen die functie.
Zo kunt u een getal overgaan in deze functie, zal het worden aangeduid als x
intern.
>> Wij hebben onze faculteit-functie.
We moeten twee dingen, een base case en een recursieve aanroep.
Wat is het basisscenario voor faculteit?
Iemand die schreef het uit en wie niet nog gesproken, wat is de basis
geval voor faculteit?
>> STUDENT: Als n kleiner is dan 2, retour 1.
>> JASON HIRSCHHORN: Als n minder dan 2, retour 1.
Dat vind ik leuk, want dat zorgt 0 en 1.
Dus we doen x <2, retour 1.
Als we krijgen doorgegeven 0, als we afgelopen 1, zal deze functie
onmiddellijk terug te keren 1.
Als we voorbij een getal groter dan of gelijk aan 2, gaan we
hebben onze recursieve aanroep.
>> En dus hoe is dat gaat werken?
Kan iemand anders die op dit werkte die heeft nog niet gesproken mij de
recursieve aanroep voor deze functie in pseudocode?
Als we krijgen doorgegeven in een aantal x en het is groter dan 2, welke
willen we doen?
We hebben ook een voorbeeld geschreven over de kant die je een hint zou kunnen geven.
>> STUDENT: Call x maal de faculteit van x min 1?
>> JASON HIRSCHHORN: Precies goed.
We gaan x keer terug de faculteit van x minus 1.
En dat, hoewel ik schreef, Kortom, wat je zei in het Engels,
deze faculteit-functie zal weer gecalled.
Het zal voeren op x minus 1.
Het zal terug te keren met een aantal integer en dan is het wel deze twee vermenigvuldigen
elkaar en die waarde zal terug naar wat het ook heet
faculteit-functie, die macht zijn een ander voorbeeld van
deze faculteit-functie.
>> Dat is een voorbeeld van een recursieve functie een zeer
eenvoudige recursieve functie.
Maar de meeste van hen zal zijn als dit.
Als u graag een goede recursieve uitdaging voor de quiz, proberen codering
binary search recursief.
Want als je binaire zoektocht naar deed probleem set drie, heb je waarschijnlijk deed het
iteratief in een while-lus.
>> Maar het kan ook worden geschreven recursief.
Je gaat nodig hebben om uw eigen schrijven aparte functie die sommige neemt
verschillende command-line argumenten - of geen command-line argumenten, sommige
anders gewoon normale argumenten.
Maar je kon binary search schrijven recursief ook.
>> STUDENT: Dus kan je ook hebben geschreven, in plaats van x minus 1, u
kunnen ook geschreven x min minus, of je zou kunnen hebben
geschreven minus minus x.
Kun je uitleggen heel snel waarom die zouden verschillende dingen zijn,
zoals wat het verschil is tussen x minus minus en minus minus x?
>> JASON HIRSCHHORN: Nee, ik ben niet in te gaan op dat om te gaan.
Maar ik zal met je praten over het na klasse. x minus minus minus minus x
verlagen x door 1.
Maar ze doen het een beetje anders.
Maar ik wil niet op ingaan.
Andere vragen over recursie of deze functie?
Dat is niet echt eens pseudocode.
Dat is eigenlijk de code in C U zou schrijven voor dit.
>> OK, andere vragen over onderwerpen die hier?
Yeah.
>> STUDENT: Ik heb een kort overzicht van floating point en precisie.
>> JASON HIRSCHHORN: Drijvende punt en precisie.
Kan iemand echt snel geef me een overzicht van
floating point en precisie?
Jullie moesten dit voor uw doen probleem te stellen, dus je bent helemaal
vertrouwd mee.
Of toch niet allemaal.
Iedereen?
Geef me een slag plek.
Floating point en precisie.
Wat is het probleem?
Ja.
Victoria?
>> VANESSA: Vanessa.
>> JASON HIRSCHHORN: Vanessa.
Sorry.
>> VANESSA: Er is maar een eindig aantal getallen kunnen worden weergegeven
omdat je op een, in onze geval een 32-bits systeem.
Dus je soort te make-up een aantal nummers.
>> JASON HIRSCHHORN: Dus dat is precies goed.
Er zijn maar een beperkt aantal nummers die kunnen worden weergegeven.
Als u vermenigvuldigen twee zeer grote aantallen, kan het bedrag overstromen
van ruimten moet je vertegenwoordigen een geheel getal.
Daarom soms gebruiken we een lange lange in plaats van een int.
Dat heeft meer ruimte.
Dat kan een groter aantal houden.
>> Floating point precisie heeft te maken met , maar heeft ook te maken met de
Dat decimale getallen niet vast vertegenwoordigd.
Sorry.
Laat ik deze back-up.
Het decimale getal 1.0 is niet altijd vertegenwoordigd zoals je zou verwachten,
1,000000000.
Soms wordt voorgesteld als 1,000000001 of 0,999999999.
Het kan ook 89 worden geworpen daar ergens.
Dus die decimale getallen zijn niet vertegenwoordigd precies zoals je zou
verwachten dat ze vertegenwoordigd worden.
>> Dus probleem set -
was het twee? -
probleem set twee, waar we behandeld floating point getallen, toen we wilden
hen te vertegenwoordigen precies wat we wilden hen te vertegenwoordigen het aantal
van centen, of het aantal centen, we ze vermenigvuldigen met 100.
We rond hen.
En dan snijden we alles af achter de komma.
Dat was om ervoor te zorgen dat ze zouden eigenlijk gelijk precies wat we wilden
ze gelijk.
>> Want als je iets nemen dat een vlotter en zet hem in een int, u
afgesneden alles naar rechts van de komma.
Omdat er een aantal floating point onnauwkeurigheid, 100.000 zou kunnen zijn
weergegeven als 99,999999999.
En als je gewoon afgesneden alles de juiste meteen, je gaat
krijgen het verkeerde nummer.
Yeah.
>> STUDENT: Ik had een vraag over casting.
Welke volgorde komt het voor in?
Indien u vlotter zou doen, beugels, 1 gedeeld met 10, doet het 1 gedeeld door 10,
dan krijg 0.1, zet het in een float?
>> JASON HIRSCHHORN: Als je dat doet vlotter 1 gedeeld door 10 -
>> STUDENT: Ja, en daarna gelijk aan -
goed, het zou normaal heb het gelijk in -
Yeah.
Wil je het een float te maken, toch?
>> JASON HIRSCHHORN: OK, dus we gaan dat gebruiken om overgaan in het uitzoeken
de antwoorden op deze vragen door codering.
Omdat je waarschijnlijk een hoop deze minuut vragen, en een goede manier
op te lossen is door middel van codering.
Dus we gaan dit nu te coderen, en dan gaan we terug te gaan en
Code De vraag die je had.
>> Dus de eerste regel -
Ik had het niet hebben geschreven - wat is het eerste wat we willen doen als we
het openen van een nieuw bestand in gedit?
>> STUDENT: Opnemen.
>> JASON HIRSCHHORN: Neem wat?
>> STUDENT: CS50 bibliotheek.
>> JASON HIRSCHHORN: OK.
Wat moeten we nemen?
We gaan gewoon om te controleren wat er gebeurt als je iets naar een float werpen.
Maar wat hebben we nodig op te nemen indien we gaat om een ​​C programma te schrijven?
>> STUDENT: Standaard I / O.
>> JASON HIRSCHHORN: stdio.h.
We eigenlijk niet nodig, want dit programma, cs50.h, ook al is het
altijd nuttig op te nemen.
Maar we hebben altijd stdio.h nodig.
>> STUDENT: Bij het coderen in C?
>> JASON HIRSCHHORN: Bij het coderen in C.
>> Dus ik sla het op als dit. C bestand.
Ik krijg een aantal leuke syntax highlighting.
Ik schreef leegte in main.
Wat betekent leegte betekenen?
>> STUDENT: Vereist geen rekening command-line argumenten.
>> JASON HIRSCHHORN: Void betekent in dit geval is het belangrijkste niet nemen
command-line argumenten.
In andere gevallen is de betreffende functie geen command-line argumenten nemen.
Of de functie, als ik leegte schrijven main (void), dat zou zeggen voornaamste's
niets terug.
Dus leegte betekent gewoon niets.
Wat zou ik schrijven als ik neem command-line argumenten?
>> STUDENT: int boog c touwtje boog v.
>> JASON HIRSCHHORN: int argc snaar argv.
Is dat zo?
>> STUDENT: Het is char ster argv haakjes.
>> JASON HIRSCHHORN: Dus kan je schrijven snaar argv beugels of char ster argv
haakjes, maar je moet de beugels.
Omdat argv is een array snaren, herinneren.
Het is niet alleen een string.
Dus snaar argv is, hier is een snaar genoemd argv.
String argv haakjes, hier is een array van strings.
Dus int argc snaar argv beugels zou iets zijn dat ik
zou waarschijnlijk te schrijven.
>> Dus u wilde opslaan in een geheel getal?
>> STUDENT: Ja, integer.
Of in een float.
>> JASON HIRSCHHORN: In een vlotter?
Zoals, float x gelijk is aan 1 gedeeld door 10.
>> JASON HIRSCHHORN: OK.
Hoe print ik een vlotter in printf?
Wat?
>> STUDENT:% f.
>> JASON HIRSCHHORN:% f.
Wat is een geheel getal?
d of i.
Wat is een string?
>> STUDENT: s.
>> JASON HIRSCHHORN: s.
Hoe krijg ik een nieuwe lijn?
>> STUDENT: Backslash n.
>> JASON HIRSCHHORN: Wat moet ik terugkeren als belangrijkste runs correct?
>> STUDENT: 0.
Moet ik die lijn te schrijven, hoewel?
>> STUDENT: Nee.
OK, we zullen niet schrijven, dan.
Kan iedereen lezen dat?
Het ziet er een beetje klein.
Kan iedereen zien, of moet Ik maak het groter?
Ik denk dat voor de camera, zorgen wij ervoor het een beetje groter, dat wel.
>> JASON HIRSCHHORN: Als ik wil kan ik dit uitschakelen . C bestand in een uitvoerbaar, wat
schrijf ik?
>> STUDENT: Maak test.
>> JASON HIRSCHHORN: Sorry?
>> STUDENT: Maak test.
>> JASON HIRSCHHORN: Maak test.
We hadden het over deze lijn eerder.
Clang.
Wat is clang?
De naam van de compiler.
Wat is de lijn?
>> STUDENT: Stelt het voor het gebruik van GDB.
>> JASON HIRSCHHORN: Sets het voor het gebruik van GDB.
Deze lijn, wat is dat?
>> STUDENT: Broncode.
>> JASON HIRSCHHORN: Dat is de bronbestand, de c-bestand..
Wat hebben deze twee lijnen doen?
Of deze twee niet lijnen.
>> STUDENT: Het namen het te testen.
>> JASON HIRSCHHORN: Dus het dashboard o zegt: noem het iets anders.
En hier je belt het test.
Als ik had dat niet in, wat zou het noemen dit?
>> STUDENT: a.out.
>> JASON HIRSCHHORN: a.out.
Wat betekent dit?
>> STUDENT: Links de wiskunde bibliotheek.
>> JASON HIRSCHHORN: Het verbindt in de wiskunde bibliotheek.
We hadden niet de wiskunde bibliotheek, maar want dat is zo gewoon, ze hebben
schriftelijke maken om altijd de wiskunde bibliotheek.
En ook, dit omvat de CS50 bibliotheek.
>> OK, dus als we een lijst hebben we nu een uitvoerbaar bestand genaamd test.
Om het uit te voeren, ik schrijf test.
Ik zie dat mijn floating point, zoals verwacht, gelijk aan 0.
Doet dat -
zo -
>> STUDENT: Dan drijven als je nu, zoals je het gecast als float -
>> JASON HIRSCHHORN: Zet de 1 om een ​​vlotter?
>> STUDENT: Nee, werpe de volledige ding -
ja.
Als je net deed dat, zou die het 0.1?
>> JASON HIRSCHHORN: OK, dus echt snel, 1 gedeeld door 10, die zijn
integers verdeeld.
Dus als je gehele getallen verdelen, ze zijn 0, en je bespaart dat 0 in een
drijven, omdat de schuine streep gewoon integer divisie.
Dus nu zijn we iets te draaien in een float.
>> Laten we eens kijken wat er gebeurt.
We zullen testen maken.
Dus nu zien we dat die slash was niet integerdeling werd zweven
punt divisie.
Omdat een van de argumenten was geworpen om een ​​float.
Dus nu is het zei, behandel deze divisie alsof we te maken hebben met
zwevende punten niet met gehele getallen.
En zo krijgen we het antwoord dat we verwachten.
>> Laten we eens kijken wat er gebeurt -
oops.
Als ik wilde meer decimale afdrukken vlekken, hoe zou ik dat doen?
>> STUDENT: Point punt f, of zoveel decimalen als u wilt.
>> JASON HIRSCHHORN: Dus ik afdrukken 10 decimale plaatsen.
En we zien nu krijgen we sommige rare dingen.
En dat gaat terug naar je vraag over floating point onnauwkeurigheid.
Er is raar spul opgeslagen in hier.
>> OK, Is dat een antwoord op je vraag?
Wat heb je nog wilt om snel te coderen?
>> STUDENT: Ik wilde alleen maar om te zien of niet, als je vrijgemaakt wat wijzer,
of die pointer nog had opgeslagen in daarin het adres van wat het was geweest
wijst eerder.
>> JASON HIRSCHHORN: OK, dus laten we dat doen.
Char ster ptr, creëert dit een variabele riep PTR van het type char ster.
Hoe schrijf ik malloc?
Alden?
>> ALDEN: Just malloc.
Maar dan moet de grootte van, en in dit geval, ik denk dat je zou
wijzen naar char.
Dus het zou zijn char.
>> JASON HIRSCHHORN: OK, dus meer generiek, Inside -
laten we bewerken.
Binnen malloc, je wilt het nummer van bytes op de heap.
Over het algemeen, wat we hebben gezien dat we te doen is gaan we malloc
koorden, bijvoorbeeld, of arrays van integers.
Dus als we willen 10 gehele getallen, of 10 chars, zal 10 ons 10 geven.
En dan de grootte van chars zou geven ons dat de grootte van tekens, die
dit geval is 1 byte.
We krijgen 10 bytes.
Als we schrijven grootte van int, dat zou ons 40 bytes.
>> Dus meer algemeen, de binnenkant van malloc is het aantal bytes dat u wilt.
In dit geval, we krijgen 1 byte.
Die lijkt een rare gebruik van malloc, maar voor onze
doeleinden zinvol.
Dus er is dat.
>> We gaan bellen gratis.
We ontdoen van het en we weer gebruiken ptr.
En wat heb je wilt controleren?
>> STUDENT: Ik wilde alleen maar om te controleren of was of niet er iets
binnenkant van het.
>> JASON HIRSCHHORN: Dus of hij wees naar iets?
>> STUDENT: Ja, precies, of het had nog een geheugen adres.
>> JASON HIRSCHHORN: Dus je wilt om de waarde van ptr controleren?
>> STUDENT: Ja, precies.
>> JASON HIRSCHHORN: Wat moet ik hier schrijven als ik wil de waarde van de te controleren
punt - wat is, Jordanië gezegd, de waarde?
Of wat is opgeslagen in van ptr?
>> STUDENT: Een geheugenadres.
>> JASON HIRSCHHORN: Een geheugenadres.
Dus als ik schrijf alleen dit, het zal geef mij de waarde van ptr.
En hoe kan ik uitprinten een geheugen-adres?
Wat is de format string voor een geheugen-adres?
>> STUDENT:% p.
>> JASON HIRSCHHORN:% p.
% S is een string.
% P voor pointer.
Is dat zo?
Dat klopt.
Dus ptr gelijk -
het heeft nog iets in.
Dit is waarschijnlijk een meer interessante vraag.
Wat doet die lijn doen?
>> STUDENT: Seg fouten.
>> JASON HIRSCHHORN: Wat?
>> STUDENT: Ik denk dat het Seg fouten.
>> JASON HIRSCHHORN: Hm?
>> STUDENT: Ik denk dat het zal fout Seg.
>> JASON HIRSCHHORN: Dus deze lijn code, ster ptr, wat
betekent de ster betekenen?
>> STUDENT: Inhoud van.
>> JASON HIRSCHHORN: Yeah.
Toegang tot de inhoud te krijgen.
Dus dit gaat naar het geheugen pakken daar en geef me dat.
Ik gebruikte% c hier omdat er zijn personages daar opgeslagen.
Dus we gaan naar dat adres wij net zag - of het zal waarschijnlijk een
beetje anders dit keer dat we het programma uit te voeren.
Maar we gaan naar dat adres waarvan we weten nog steeds bestaat
en te zien wat er staat.
>> Zodat het niet Seg fout.
Dat het gewoon niet geven ons niets.
Het zou hebben ons eigenlijk gegeven iets, we kunnen gewoon niet zien.
En dat gaat terug tot dit idee -
en we gaan niet te veel in te krijgen dit, want dat is buiten de
omvang van deze cursus.
Maar we spraken over hier, als we ging verder dan de grenzen van de array
1, kunnen we niet in de problemen komen.
>> Soms, als je gewoon af te gaan op 1, dat je iets verkeerd doet, en u
kon krijgen in de problemen.
Maar je hoeft niet altijd in de problemen.
Het hangt ervan af hoeveel van een slechte zaak u weet, je gaat in de problemen te komen.
Wat niet wil zeggen, zijn slordig met uw code.
Maar het is te zeggen, het programma op geen altijd stoppen, zelfs als je ergens heen
je bent niet de bedoeling om te gaan.
>> Een goed voorbeeld daarvan is, veel mensen in hun probleem set 3, die
15, inspecteerden het was niet grenzen van het bord.
Dus je keek naar links, keek naar de recht, keek naar boven, keek
naar de bodem.
Maar je hebt niet te zien als de top was eigenlijk gaat worden op het bord.
En een heleboel mensen die dat deden en bleek dat in hun programma werkte
perfect, want waar die raad was opgeslagen in het geheugen, als je ging een
erboven of gecontroleerd dat het geheugen adres, er was niets
vooral verschrikkelijk over dat, zodat het programma niet was
ga je schreeuwt.
>> Maar we zouden toch opstijgen punten als u hebben daarom niet dat, omdat je
waren iets wat je niet doen waren verondersteld wordt te doen, en je zou kunnen hebben
gekregen in de problemen.
Odds zijn, hoewel, je waarschijnlijk niet.
Dus dit is te zien dat, ja, kunnen we nog naar het.
En we krijgen niet in problemen in dit geval.
Als we proberen te doen lezen volgende 100 tekens, zouden we
waarschijnlijk in de problemen komen.
En je kunt coderen lezen van de volgende 100 tekens als u wilt door wat voeten
soort van lus.
Yeah.
>> STUDENT: Aangezien we waren toegewezen dat ruimte een werkelijke waarde, zouden we niet
daadwerkelijk in staat zijn om iets te zien.
Moeten we proberen het met de instelling dat gelijk aan zoals C of zo?
>> JASON HIRSCHHORN: Goede vraag.
Hoe stel ik die waarde -
welke regel code schrijf ik op lijn zeven om te doen wat je zei?
>> STUDENT: Star ptr gelijk enkele citaat c eindigen enkele aanbieding.
>> JASON HIRSCHHORN: Dus dan druk een karakter, c, op die plaats,
want nogmaals, dat ster betekent ga naar daar.
En bij gebruik op de linkerkant van een opdracht operator, dat gelijk is aan
ondertekenen, we gaan niet te krijgen dat waarde zoveel als die waarde ingesteld.
Laten we nu eens kijken wat er gebeurt.
>> We hebben daar iets en het was er.
We noemden gratis.
Sommige dingen gebeurde waarschijnlijk op de heap.
Dus het is er niet meer.
Maar nogmaals, we zijn niet krijgen in de problemen voor er heen te gaan.
>> Ik doe dit in code om te illustreren dat veel van deze
vragen die je hebt, zijn ze echt interessant
beantwoordt veel tijd.
En ze zijn echt goede vragen.
En je kunt ze uit te zoeken op meenemen als, bijvoorbeeld,
we zijn niet in doorsnede.
Yeah.
>> STUDENT: Omdat je niet het verzenden van de pointer waar dan ook, heb je nodig om
gebruiken malloc?
>> JASON HIRSCHHORN: Dus dit gaat terug om uw eerste vraag.
[? ?]
Is het gewoon een lokale variabele?
Malloc hier is niet zo overtuigend.
Het gebruik van malloc hier niet dat dwingende omdat het
slechts een lokale variabele.
>> STUDENT: Dus kan je char doen ster ptr gelijk gedag?
>> JASON HIRSCHHORN: Oh.
Dus we gaan nu weer terug om uw eerste vraag.
Ik denk dat je niet tevreden waren met mijn antwoord.
OK?
Als dat?
>> STUDENT: Ja.
Wacht.
>> JASON HIRSCHHORN: En waar wil je om uit te printen?
Dus gaan we een string als die uit te printen?
>> STUDENT: Interessant.
>> JASON HIRSCHHORN: Dus dit zegt dit argument is het type van een karakter.
Dus dit een teken zou moeten zijn.
>> STUDENT: neemt gewoon de eerste.
>> JASON HIRSCHHORN: Dus dit is wat ik al eerder zei.
Zoals ik al zei, het is niet het opslaan van de snaar binnen variabele pointer.
Het opslaan -
>> STUDENT: De eerste waarde van de snaar.
>> JASON HIRSCHHORN: Het adres van de eerste waarde van de tekenreeks.
Als we uitprint, we zijn om de waarde binnen aanwijzer.
En we zullen zien is het inderdaad een geheugen adres.
>> Is dat logisch?
Sorry.
Wacht, is dat antwoord op je vraag, hoewel?
>> STUDENT: Ja.
>> JASON HIRSCHHORN: Deze regel code is het creëren van een string en dan nog
variabele wijzer dat is wijzende dat tekenreeks, die array.
Yeah.
>> STUDENT: Dus als we een geheugen gingen pakken verder, zouden we de h?
Is het al opgeslagen als een string?
>> JASON HIRSCHHORN: Zoals, we deden -
dus is dit waardevol te doen.
Dit is point berekeningen, die jullie eerder hebben gezien en moeten
relatief comfortabel met.
Dit is verwant aan het schrijven -
als we deze regel code te schrijven, we hebben reeks notatie eerder gezien.
Dit zou ons de tweede geven waarde in deze matrix, h.
>> Als we dit deden, dient dit ook te geven ons de tweede waarde in die array.
Want het gaat niet om het geheugen adres van de eerste ding, maar de
geheugenadres van het ding een over.
En dan is de ster operator dereferences dat pointer.
En nogmaals, laten we eens kijken.
We krijgen h weer.
>> STUDENT: Wat doet dereferentie betekenen?
>> JASON HIRSCHHORN: Verwijzing van is een duur woord voor gaan.
Ga naar die en krijgen wat is er is dereference een pointer.
Het is gewoon een duur woord voor.
>> STUDENT: Als we wilden afdrukken de hele reeks, konden we
doen ampersand wijzer?
>> JASON HIRSCHHORN: OK, we zijn ga hier even pauzeren.
We gaan hier eindigen.
Ampersand geeft u het adres van een locatie, dus als je ampersand van doen
een variabele, het geeft je het adres wanneer deze waarde wordt opgeslagen.
Ampersand wijzer zal u het geven adres van ptr waar ptr is in het geheugen.
>> We gaan niet om verder te gaan dit voorbeeld.
Je kunt achterhalen deze dingen op je eigen.
Maar nogmaals, dit zou zelfs op het randje van een beetje verder dan wat je moet weten voor
het toepassingsgebied van deze mid-term -
of deze quiz plaats.
Sorry.
>> We gaan om verder te gaan, want ik zou graag een codering probleem doen
voordat de tijd om is.
En we gaan coderen wat ik denk is de meest dwingende van deze
voorbeelden, atoi.
Dus dit was een vraag op een quiz twee jaar geleden.
En ik heb het op het bord hier.
>> Mensen werd gevraagd op de quiz -
ze kregen een beetje meer tesxt in de vraag, maar ik elimineerde de
tekst omdat het niet nodig was voor nu onze doeleinden.
Het was gewoon wat achtergrond over wat atoi deed.
Maar jullie weten en zijn zeer vertrouwd met atoi.
>> Ik stel voor dat je deze code op een vel papier.
Ik stel ook voor u de strategie te gebruiken dat we hebben laten zien
veel in onze rubriek.
Zorg eerst dat je begrijpt wat atoi's doen.
Maak een tekening of komen met een aantal mentaal beeld van het in je hoofd.
Vervolgens uitschrijven pseudocode voor dit.
Op de quiz, als alles wat je krijgt is pseudocode, in ieder geval je
zet iets neer.
En dan in kaart dat pseudocode op C. Als je een cheque in uw
pseudocode, zoals controleren als er iets is 1, dat kaarten op een if
conditie enzovoort.
En tot slot, de code van het programma in C.
>> Dus ga terug naar atoi en nemen vijf minuten Om deze code op een vel
papier, wat waarschijnlijk de hoeveelheid tijd die je op een zou nemen
quiz om code atoi.
Vijf 15 minuten, vijf tot 12, vijf tot 10 minuten is de hoeveelheid
tijd die je zou besteden aan deze vraag in de quiz.
Dus neem nu vijf minuten, alstublieft.
En als je vragen hebt, verhogen je hand en ik zal rond komen.
>> [SIDE CONVERSATIONS]
>> JASON HIRSCHHORN: OK, dus Dat was vijf minuten.
Dat was waarschijnlijk over de hoeveelheid tijd die je zou besteden aan dat op een quiz,
misschien de lage kant van die tijd.
We zullen samen te vatten in een beetje.
Laten we beginnen te coderen dit.
En als we niet helemaal door te krijgen, de antwoorden op deze en deze
quizvraag beschikbaar zijn, opnieuw, Het najaar van 2011 is bij deze vraag
verscheen op de quiz.
>> En het was acht punten waard op de quiz dan.
Acht punten op de bovenkant van de aantal punten iets waard is.
De meeste vragen zijn in het bereik met een tot zes punten.
Dit is dus een uitdagende vraag, zeker.
Kan iemand mij begon?
>> In het algemeen, wat gaan we te willen doen met deze
functioneren atoi, logisch?
Wat willen we doen?
Dus we gaan om te schrijven wat pseudocode.
>> STUDENT: Convert tekens in gehele getallen.
>> JASON HIRSCHHORN: Convert tekens in gehele getallen.
OK.
Dus hoeveel tekens zijn wij gaat nodig hebben om door te gaan?
>> STUDENT: Allemaal.
>> STUDENT: Alle personages in de string.
>> JASON HIRSCHHORN: Alle tekens in de tekenreeks.
Dus als we wilden gaan door elke teken in een string, wat is een ding
in C we hebben gezien dat heeft toegestaan we gaan door elke
teken in een string?
>> STUDENTEN: Een lus.
>> JASON HIRSCHHORN: Een lus.
Dus we gaan doorlussen elk karakter in s.
>> Dan wat gaan we willen doen als we een bepaald personage?
Zeggen wij worden langs een 90.
We krijgen de 9.
Het is een personage.
Wat willen we doen met dat personage 9?
>> STUDENT: Trek het van karakter 0?
>> STUDENT: Add 0?
>> JASON HIRSCHHORN: Aftrekken het van karakter 0?
>> STUDENT: Ja.
>> JASON HIRSCHHORN: Waarom doen wilt u dat doen?
>> STUDENT: [onverstaanbaar]
waarde.
Zijn int waarde.
>> JASON HIRSCHHORN: OK, dus nemen we de karakter 9, aftrekken van
karakter 0 op een te krijgen werkelijke integer 9.
Sweet.
En hoe weet je dat personage 9 min 0 karakter is 9?
Wat grafiek heb je kijken?
>> STUDENT: Er zijn logisch negen plaatsen tussen 9 en 0.
Of je zou kunnen kijken naar de ASCII-tabel.
>> JASON HIRSCHHORN: ASCII-tabel.
Maar ja, je hebt gelijk bent ook.
Dus trekken we 0.
Dus nu hebben we het gehele getal 9.
En wat willen we mee te maken hebben?
Als we 90, het is de eerste integer we hebben, wat we willen doen?
>> STUDENT: Ik zou in een tijdelijke integer zetten array, dan doen wiskunde om het
later om het te maken tot een eindproduct.
>> JASON HIRSCHHORN: OK.
>> STUDENT: U kunt beginnen aan het einde van de array en dan vooruit zodat
dat elke keer dat je vooruit, je vermenigvuldigen met 10.
>> JASON HIRSCHHORN: OK.
Dat klinkt als een mooie aansprekend idee.
We kunnen beginnen aan het einde van ons aanbod, en we kunnen gebruiken strleng.
We kunnen strleng gebruiken hier.
We zullen de lengte van onze reeks te krijgen.
We beginnen bij het einde.
En + de eerste, we nemen dat integer, en misschien maken we als een
nieuwe integer variabele up top waar we zijn alles op te slaan.
Dus we lus door elke char in s uit achter naar voren trekken we 0, en
dan nemen we, en afhankelijk waar het is, vermenigvuldigen we het
met een vermogen van 10.
Omdat de eerste, wat doen we vermenigvuldig het meest rechtse teken van?
>> STUDENT: 10 naar de 0.
>> JASON HIRSCHHORN: 10 naar de 0.
Wat doen we vermenigvuldigen de tweede meest rechtse teken van?
>> STUDENT: [onverstaanbaar].
>> JASON HIRSCHHORN: Wat?
>> STUDENT: 10 naar de 1.
>> JASON HIRSCHHORN: 10 naar de 1.
De derde meest rechtse teken?
>> STUDENT: 10 naar de 2.
>> JASON HIRSCHHORN: 10 naar de 2.
>> STUDENT: Sorry, ik begrijp het niet wat we hier doen.
>> JASON HIRSCHHORN: OK, Laten we terug gaan, dan.
Dus we gaan krijgen aangenomen in een string.
Omdat we aan het schrijven bent atoi.
Dus krijgen we passeerden in een string.
Zeggen wij worden doorgegeven in de tekenreeks 90.
>> Het eerste wat we gaan doen is een nieuwe integer variabele die we
gewoon gaan maken als onze nieuwe integer.
Dat is wat we gaan terug eind.
We moeten gaan door elk karakter in de string want we hebben vastgesteld
die we nodig hebben om een ​​ieder te raken en voeg deze dan naar onze nieuwe integer.
>> Maar we kunnen niet zomaar toe te voegen als een nummer.
We kunnen niet zomaar 9 en voeg 9 aan onze integer.
Het hangt af van welke plaats het in de string.
We gaan nodig hebben om te vermenigvuldigen door een kracht van 10.
Want dat is hoe base 10 werken.
>> Dus we gaan naar de werkelijke krijgen karakter of de feitelijke integer
aantal, door het aftrekken van karakter 0 van karakter 9 zoals we deden met
aftrekken karakter hoofdletter A uit wat karakter hadden we in een van
deze problemen.
Dus we eigenlijk een getal van 0 tot 9 opgeslagen als een reëel getal, en we zullen
vermenigvuldigen met een macht van 10, afhankelijk op waar we zijn in de string.
En dan gaan we het opnieuw toevoegen in onze nieuwe integer variabele.
>> Dus wat dit eruit zou zien zou worden - we zullen hier trekken voorbij.
Als we krijgen doorgegeven in de string 90 -
>> STUDENT: [onverstaanbaar].
>> JASON HIRSCHHORN: Maar atoi neemt een string.
Dus we gaan door te gaan het bedrijf.
We zullen krijgen doorgegeven in 90.
We gaan van de achterkant naar de voorkant.
We nemen de 0.
>> STUDENT: Het spijt me.
Misschien is dit dom.
Als wij worden aangenomen in een string, waarom is 90 wat we
krijgen gepasseerd in?
Omdat 90 een geheel getal.
>> JASON HIRSCHHORN: Omdat atoi neemt een string en verandert het in de integer
vertegenwoordiging van die string.
Maar de snaar 90 is de integer 90 of het nummer 90.
De string 90 is een serie van twee, of drie karakters, eerder de 9
karakter, de 0 karakter, en de backslash 0 karakter.
>> En we schrijven atoi want voor Bijvoorbeeld, wanneer je het commando te nemen
line argument, en het is opgeslagen in argv, het is opgeslagen als een string.
Maar als je wilt om het te behandelen als een nummer, je nodig hebt om het te converteren naar een
werkelijke integer.
Wat we gedaan hebben een van ons probleem sets.
Wat we gedaan hebben in een aantal van ons probleem sets.
Iedereen die een integer nam als een command line argument.
Dus dat is waarom onze atoi functie neemt een string.
>> Dus nogmaals, in ons voorbeeld hier, we zijn naar de laatste nemen.
We gaan naar het karakter aftrekken 0 uit, want de cijfers 0
afgetrokken door het karakter 0 geeft u het werkelijke aantal 0, volgens
de ASCII wiskunde die we doen.
>> Omdat karakters worden weergegeven als anders dan hun werkelijke - de
een karakter, bijvoorbeeld, kleine letter a is 97.
Het is niet - oops!
Het is niet wat je zou verwachten het is, 0, bijvoorbeeld.
Dus je moet aftrekken van de karakter een te krijgen 0.
>> Dus gaan we dat hier doen de werkelijke nummer.
En dan gaan we vermenigvuldigen met een vermogen van 10 afhankelijk van waar het
is in de string, en dan dat toevoegen aan onze place holder
variabele zodat we kunnen komen met onze laatste nieuwe integer.
Is dat zinvol voor iedereen?
>> Dus we gaan niet om deze code op dit moment, omdat we
krijgen weinig tijd.
Ik verontschuldig me voor de timing van dat.
Maar dit is wat, hopelijk, zou je kunnen doen aan de quiz - bij de
minst, krijg deze pseudocode uitgeschreven.
>> En dan, als we schrijven de pseudocode, eigenlijk, we konden dit doen
vrij snel.
Elke regel van de opmerkingen die we schreven we hier vertaalt naar ongeveer
een regel C-code.
Het uitroepen van een nieuwe variabele, schrijven een lus, een aantal aftrekken, sommige
vermenigvuldiging, en enkele opdracht.
We zouden waarschijnlijk ook willen schrijf een retourleiding.
We zouden ook willen zetten sommige controles in hier.
Yeah.
>> STUDENT: Dus we kunnen behandelen s als in de string?
Omdat ik weet dat het is gewoon een adres.
Zoals, hoe zou je de lengte van de string wordt doorgegeven?
>> JASON HIRSCHHORN: Dus hoe heeft de lengte van een string?
Strlen.
>> STUDENT: strlen, ja.
Maar kun je s als de argument voor?
>> JASON HIRSCHHORN: Dus strlen neemt een char ster.
En volgt dat char ster, en houdt tellen totdat het bij een
backslash 0. strlen was eigenlijk een van de andere programma's die we
gingen code.
Dat is nog een mooi voorbeeld om code.
Die ene is een beetje makkelijker, want als je gaat denken dat
conceptueel -
Ik zei het gewoon hardop - strlen volgt een pointer en blijft gaan en
tellen en bijhouden tot u een backslash 0 te bereiken.
>> STUDENT: OK, heb het.
>> JASON HIRSCHHORN: Dus beste van geluk op quiz 0 morgen.
Als je vragen hebt, ik zal buiten daarna.
Voel je vrij om me te mailen.
Reik uit naar uw eigen TF als je niet in mijn sectie, of mijn
mailen als u dat wilt.
>> Als u wilt freak out en stuur me een email, een freakout e-mail, ik zal
stuur je terug, net als een smiley, of, zoals, een grap of zo.
Dus voel je vrij om dat te doen ook.
Veel succes weer, en ik zal zie jullie allemaal volgende week.