>> JASON HIRSCHHORN: Welkom, iedereen, en met week 6.
Ik ben blij om u allen levend zien en goed na Quiz 0, omdat ik weet dat
was een beetje ruw.
Maar gelukkig, u allen deed ongelooflijk goed.
En dus dat is geweldig.
Als je in mijn sectie, heb ik het meest gegeven van je back uw quizzen reeds.
>> Een paar van jullie, ik ontmoeten na de les.
En als je een extensie student en u nog niet uw quiz terug ontvangen
nog, wordt uw TF waarschijnlijk bezig en sorteren het, en zal het terug te krijgen
om u binnenkort.
Dus mijn extensie studenten die nu kijken - hopelijk wonen -
Ik zal uw quizzen krijgen kort ook.
>> Onze agenda voor vandaag is als volgt.
Ten eerste gaan we gaan over een aantal middelen die CS50 biedt aan u.
We gaan gaan over Quiz 0, en Ik zal uw vragen te beantwoorden iedereen
heeft over specifieke problemen.
En dan zullen we gaan over file I / O en probleem set 5.
Die laatste twee onderwerpen zal nemen het grootste deel van sectie vandaag.
>> Ik heb deze lijst elke week als een herinnering aan u allen, maar van de kern
sectie hebben we maar 90 minuten - we zijn niet in staat om alles te dekken dat ik
zou graag dekken voor jullie.
Maar we hebben een ton van de middelen voor u om uit te putten als je te weten
het materiaal en werk door uw probleem stelt.
>> Een herinnering die ik heb online een tekst doos, opgezet voor u in te vullen als u
nog feedback voor mij, zowel positieve als
constructief, over sectie.
Dat URL ligt hier recht naar beneden.
Dus alsjeblieft, neem een ​​moment als u een feedback, of het nu tijdens sectie,
of na, of nadat u de video bekijken online, om mij uw mening.
Ik waardeer alle van.
>> Dus ik heb met kleine conversaties met veel van mijn
studenten over de hele week - als ik de hand terug quizzen, praten over de
Natuurlijk zien hoe je het doet.
En een thema heeft zich langs te komen en meer dan in het praten over - in
name -
probleem stelt.
En ik heb dat thema ingekapseld op het bord nu.
>> Wezen, er is een verschil tussen het draaien in iets dat
correct en iets gedaan dat is goed gedaan.
De meeste mensen hebben gedaan fantastisch in termen van juistheid -
5 of 4 op alle psets.
De meeste mensen krijgen die alle van de tijd.
>> Echter, alleen omdat je hebt gedaan iets wat niet het recht dat je hebt
iets gedaan als elegant, of efficiënt en zo schoon je
het zou hebben gedaan.
En dat is wat het ontwerp -
en in mindere mate, stijl -
assen voor.
Dus Ik duw jullie allemaal, en andere TFs duwen jullie, niet alleen beurt
in dingen die juist zijn, maar zet in de dingen die goed zijn gecodeerd.
>> Niet doen onnodig voor loops, niet de herberekening variabelen als
je niet hoeft te doen.
Bijvoorbeeld, terugkijkend naar probleem stellen 4, bij het plaatsen van stenen op de
scherm, elke toer - elke steen in een bepaalde rij heeft dezelfde y-coordinaat -
dezelfde hoogte coördineren.
>> Zodat y-coördinaat niet hoefde te berekend in de binnenruimte
geneste FOR-lus die je waarschijnlijk gebruikt die stenen op het scherm gezet.
Alleen moet elk berekenen keer dat u een rij geschakeld, of
bewoog een rij naar beneden.
Dus zeggen dat als er 10 stenen in een rij, kan elke steen dezelfde hebben
y-coördinaat, en dat y-coordinaat kan gewoon worden berekend
eens en voor altijd van die.
>> Het hoeft niet te worden berekend 10 tijden, evenmin deze berekening nodig
gebeuren in de werkelijke functie aan te roepen -
de nieuwe gracked functie oproep.
Dus als dat was een beetje verwarrend voor u, meer algemeen, dingen die
niet nodig om elke keer weer gebeuren je door een FOR-lus mag niet
gezet in de FOR-lus, en mag niet gebeuren elke keer dat je gaat
door de FOR-lus.
>> Een ander goed ontwerp voorbeeld zagen we in week 3 voor 15, kon je houden
spoor van de nul.
Dus als je het bord initialiseren, u opslaan - in een globale variabele, misschien -
de x en y-coördinaat van het nulpunt.
En dan wanneer je -
in uw verhuizing functie, wanneer u te maken een succesvolle zet, u een update van de
locatie van de nul.
>> Dat zou je redden van die te maken hebben passen voor een loop om te kijken door de
boord van elk moment in je move functie en vind de nul, of vind de tegel,
en dan kijken wat het ernaast.
In plaats daarvan, heb je de locatie van de nul, kun je gewoon kijken boven, onder,
en links en rechts ervan, te vinden de tegel die je zocht.
>> Dus in termen van de programma's zijn we schrijven, ze zijn nooit groot genoeg
dat sommige van deze ontwerpbeslissingen werkelijk gaan belemmeren uw
programma, of maak het langzamer draaien, of misschien zelfs onvoldoende geheugen.
Maar we zijn nog steeds te duwen jullie te schrijven als elegant en
efficiënte code mogelijk.
>> Dus als je eindigen met het schrijven dingen dat een aanzienlijk groter zijn
reikwijdte zullen zij goede geschreven ontwerpen naast juistheid.
Dus een aantal van jullie hebben bracht dat uit.
Dat is iets wat we zoeken - iets wat we zullen blijven
duw je jongens op.
>> Als je ooit nog vragen hebben over de ontwerp van uw programma, voel je vrij
om uit te reiken naar mij, en ik ben blij om lopen door uw programma met u,
en wijzen op een aantal van de ontwerpen beslissingen die je gemaakt, en geven u een aantal
suggesties over hoe om zelfs betere ontwerpbeslissingen.
>> Dus we gaan om verder te gaan om te praten over Quiz 0.
Voordat we dat doen, doet niemand Voor vragen over wat
Ik heb tot nu toe gedekt?
>> [Geritsel NOISE]
>> JASON HIRSCHHORN: Zeven seconden.
OK.
Laten we praten over Quiz 0 voor een beetje.
De meeste van jullie hebben je Quiz 0 terug.
Als je dat niet doet, hopelijk Herinner je je het een beetje.
Maar als je Quiz 0, dan heb je genomen hebben ook toegang tot de PDF online in
de sample oplossingen.
>> Heeft iemand nog vragen voordat We springen in de week van materiaal over
een bepaald probleem op Quiz 0 -
waarom is het antwoord wat het is?
Is er iemand in de war over iets?
Zelfs als u hebt het probleem recht, maar zou gewoon willen dat ik het uit te leggen een beetje
meer, ik ben blij dat nu gebeuren.
>> Dus ik heb jullie gevraagd om kom bereid met een aantal
gedachten over Quiz 0.
Dus die willen ons begon met een vraag of
opmerking over Quiz 0?
>> [PAPIER RITSELENDE]
>> JASON HIRSCHHORN: Niet iedereen deed perfect.
Dus ik weet [Lacht]
er moet een aantal vragen worden over Quiz 0.
OK.
Ja.
Ompica.
>> OMPICA: Nummer 10.
>> JASON HIRSCHHORN: Nummer 10.
Welke was nummer 10?
>> OMPICA: The -
>> JASON HIRSCHHORN: I haven't -
>> OMPICA: De include -
>> JASON HIRSCHHORN: Nummer 10 was acht i - het schrijven van acht tot i?
>> OMPICA: Ja.
>> JASON HIRSCHHORN: OK.
Dus nog een vraag die je zou kunnen hebben vroeg was ik vooruitziende blik?
Het antwoord is ja.
In hoofdstuk voordat de quiz, vroeg ik jullie om zowel Sterling coderen en
acht i.
Beiden overkomen verschijnen op de quiz.
Dus hopelijk, je betaald aandacht aan.
>> En als je had, dan zou je waarschijnlijk goed gedaan op die twee.
Maar acht tot ik, hebben we niet echt code in klasse, maar het was, wederom,
gevraagd op de quiz.
Dus een paar dingen rekening Let bij het coderen van acht tot i.
Het eerste ding, per de vraag, was dat je nodig had om te controleren of de string
was gelijk aan null.
>> Een paar mensen probeerden later controleren in het programma als 's beugel ik was -
dus een specifiek karakter in dat snaar - was gelijk aan null.
Maar vergeet niet, dat null is in wezen - het is goed om te denken aan
null als een nul pointer - een pointer naar nul -
ergens in het geheugen waar je kunt nooit toegang.
>> Dus als er iets is gelijk aan nul, u weten dat het niet is geïnitialiseerd,
of er is niets daar.
Dus s is een char ster, s beugel i is een char.
Dus is het zinvol om te vergelijken en op null, maar niet s beugel ik op null.
Maar nogmaals - dus dat was het eerste wat dat je moest doen -
controleren om ervoor te zorgen dat u daadwerkelijk kreeg een echte string.
>> Vervolgens moet je wilde gaan door elk teken in de string.
En dat zou hetzelfde zijn als een s beugel Ik, bijvoorbeeld, als ik uw iterator.
En neem dat karakter, en krijgen de werkelijke waarde.
Je heb het opgeslagen als een char, maar de ASCII-waarde voor nul -
nul als een karakter -
is eigenlijk het getal nul.
Het is een ander nummer dat u kunt opzoeken in de ASCII-tabel.
>> Dus een manier te corrigeren voor - Waarschijnlijk de beste manier te corrigeren
dat - is af te trekken van het het karakter waarde -
nul als een karakter.
Dus minus enkel aanhalingsteken, nul, nog een enkele offerte.
Dat zal het aantal u hebt als een char, en krijgen die gelijk is aan
het nummer als een echte integer.
>> En dat is zeer vergelijkbaar met de aanpak veel mensen namen in de
probleem set 2, met Caesar en Viginere -
die cijfers, als je werden ze draaien.
Dus nadat je het hebt als een nummer uit nul tot negen, dan - afhankelijk
waar het gaat in het uiteindelijke aantal - je nodig hebt om het te vermenigvuldigen
met een vermogen van 10.
>> Sommige mensen verplaatst van de achterzijde naar de voorkant, en vermenigvuldigd het individu
getal met een macht van 10.
Sommige mensen verplaatst van de voor naar achter -
en dus nam de hoogste bestellen nummers eerst -
en zou redden die in een globale teller variabele.
En dan elke keer door de FOR lus, vermenigvuldig dit reusachtige mondiale
variabele teller met 10, te maken ruimte voor de volgende char.
>> Dus dat was een beetje verwarrend zonder mij te schrijven op het bord.
Maar de monsteroplossing is voor u beschikbaar.
Maar dat waren de grote dingen we zochten.
Ook een controle om ervoor te zorgen dat elke individuele karakter was inderdaad een
karakter tussen nul en negen, en niet enkele andere karakter, zoals een A,
bijvoorbeeld.
>> Dat waren de dingen die we zochten in die vraag.
Is dat een antwoord op je vraag?
>> OMPICA: Ja.
>> JASON HIRSCHHORN: OK.
Zijn er nog andere vragen over Quiz 0?
Wat over het compileren?
Iedereen samenstellen toch?
Nee.
Er waren -
[Lacht]
Heeft u vragen over de compilatie proces?
Wow.
>> [PAPIER RITSELENDE]
>> JASON HIRSCHHORN: Ja.
Michael.
>> MICHAEL: Is nummer 7 - willekeurig?
>> JASON HIRSCHHORN: Nummer 7.
Nummer 7 was krijgen een willekeurig getal.
Excellent.
Dus je krijgt een geheel getal een en een integer b, en u wilt een willekeurige
integer tussen a en b.
We kunnen eigenlijk schrijven deze op het bestuur, omdat deze een
was een regel code -
een manier om het te doen.
>> Dus we krijgen drand als een functie die we konden gebruiken.
En wat doet drand -
ervan uitgaande dat het is al gezaaid -
wat doet drand terug?
>> MICHAEL: Een float tussen 0,0 en 1,0.
>> JASON HIRSCHHORN: Een aantal - ja.
Een getal tussen 0 en 1.
En dus hebben we B en A.
En dan hebben we onze willekeurig getal tussen 0 en 1 aan ons gegeven door drand.
Sommige mensen probeerden b zetten, of b minus een, of iets in die
haakjes.
Dat zou betekenen dat ze argumenten voor deze functie.
>> drand geen argumenten hebben - zoals getString doet
geen argumenten nemen.
Dus het is gewoon geopend Paren, dicht Paren - en dat zelf is
de functie aan te roepen.
En dat geeft je een aantal tussen 0 en 1.
Natuurlijk, we hebben een hele reeks die nummers kunnen worden inch
>> Zeggen, als b is 10 en een 5 is, hebben we echt wil een nummer met een bereik van 5.
Dus het volgende wat we moeten doen is vermenigvuldig dit met het bereik b minus een.
Dus de veronderstelling dat is vermenigvuldigd.
En dat zal ons een aantal binnen een bepaald bereik.
En dat specifiek bereik zijnde de verschil tussen b minus een.
>> En ten slotte, dat zal alleen geef het uit - zeggen dat het bereik tussen b minus een
wordt 5, dat zal ons een geven getal van 0 tot 5.
Maar als er een is in feite 5, moeten we stimuleren Dit bereik tot waar het
eigenlijk hoort te zijn, door het toevoegen van een.
Zodat krijgt de logica rechts.
En dan, zou je nog een vraag?
>> MICHAEL: Nee.
Ik voel me echt dom nu.
[Lacht]
>> JASON HIRSCHHORN: Nee.
Voel je niet echt dom.
Een aantal mensen moeite met deze vraag.
En dan, de andere vraag is, drand, je zei, geeft je een float -
retourneert een float.
Maar deze functie inderdaad gevraagd een integer worden geretourneerd.
>> U hoeft niet om dit expliciet werpen een integer, omdat deze
operaties behandelen alle een drijven - als een floating point nummer.
Als deze zal - ook als dit een geheel getal is, zal dit
correct vermenigvuldigd.
Alle vermenigvuldiging werkt.
U hoeft niet om het hier uit te brengen.
In feite moet je niet wierp hem.
>> Dat zou -
als je een nummer zou werpen die tussen 0 en 1 -
een willekeurig getal, een floating point -
dan zal het ofwel alleen 0 of 1 zijn, dus je zult al die precisie te verliezen.
Maar aan het eind, als je terugkomt, het automatisch krijgt
teruggestuurd als een geheel.
Zodat u niet hoeft te doen dat casting jezelf.
>> Dus dit was het antwoord op die vraag, nummer 7.
Andere vragen op Quiz 0?
Ja, Annie.
>> ANNIE: Wanneer gaan we gebruik maken van recursieve -
wanneer gebruiken we iteratieve loops?
>> JASON HIRSCHHORN: Wanneer gebruik je recursieve - dus meer in het algemeen, de
voors en tegens van recursie versus een iteratieve aanpak.
Kan iemand bieden een pro of een con?
Alsjeblieft?
Niet kan iedereen het.
Wie kan een pro of een con te bieden?
>> [PAPIER RITSELENDE]
>> STUDENT 1: recursieve minder codering - minder te typen?
>> JASON HIRSCHHORN: Dus over het algemeen, recursie vooral, een functie -
of een algoritme zoals samenvoegen soort - die zich leent
een recursieve benadering -
zou eenvoudiger zijn recursief coderen.
En net meer zin het recursief doen.
Dus dat zou een pro recursie zijn.
Anderen?
Yeah?
>> STUDENT 2: Con recursie -
Het maakt gebruik van meer geheugen.
>> JASON HIRSCHHORN: Dus precies goed.
Een recursieve functie zal blijven toevoegen stack frames om de stapel.
Dus als je werkt op een hoop getallen en moeten deze bellen
functioneren veel, dan zal je zeker nemen meer geheugen, terwijl
een iteratieve aanpak zal alleen zet een stack frame op de stack, omdat
het allemaal gebeurt binnen een functie.
>> Iedere andere voor-en nadelen?
Yeah.
>> STUDENT 3: Voordelen voor recursie.
Je hoeft niet te bepalen in vooraf hoe vaak de
code moest worden herhaald.
Je kan een vooraf bepaald aantal hebben tijden die je moet herhalen, dan
recursie is beter, omdat duurt dat resultaat.
>> JASON HIRSCHHORN: Ik denk dat het waar is.
Maar ik denk dat in beide gevallen Je zou nooit -
zou je waarschijnlijk wat te krijgen input van de gebruiker.
Of deze functie zou wat input hebben dat zou bepalen hoe vaak het
moet worden uitgevoerd.
Dus over het algemeen, zou je niet moeilijk code - zelfs in een iteratieve benadering - hoe
vele malen dat lus moet worden uitgevoerd.
>> Hebt u een ander je hebt denken, Annie?
OK.
Dus dat zijn waarschijnlijk de twee -
de grootste pro en de grootste con een recursieve versus
een iteratieve aanpak.
OK.
Iets anders op Quiz 0?
>> Laten we verder gaan.
File I / O. Er is een prachtige korte deze week op file I / O die hopelijk
u meerdere hebt bekeken tijden, en bewonderd.
Een hoop werk ging in dat, en ik heb hoorde het is waanzinnig nuttig.
Ik heb ook de link op deze dia, in het geval je dat nog niet had een
kans om hem te bekijken 10 keer.
>> Dus, gaan we kort gaan over de belangrijke stappen om het openen en werken
met bestanden, en dan gaan we duik in een codering probleem voordat
het onderzoeken van het probleem te stellen.
Dus nogmaals, ik ga dit opgemaakt op het scherm, maar ik ga praten
slechts een minuut over wat we doet hier met bestand I/O--
Wat betekent dat?
>> Dat betekent dat we kunnen creëren onze programma's, en dan hebben onze programma's
exit, en geen enkele invloed op hebben gemaakt de wereld buiten ons programma.
Maar als we beginnen werken met bestanden - zowel hen in het lezen en het creëren van
hen - kunnen we enig effect hebben op de wereld buiten ons programma.
>> Net zoals als Microsoft Word niet in staat was aan een Word-documenten te maken, dan
zodra Microsoft Word afsluit, al uw werk zou zijn gegaan, en het zou
echt nutteloos.
We uiteindelijk willen in staat zijn om programma's schrijven die kunnen invloed hebben op de
wereld om hen heen, zowel door het nemen van complexe inputs - in termen van dossiers en
via bestanden, en ook het creëren van interessante en meeslepend uitgangen -
in termen van verschillende soorten bestanden.
>> Dus dat is de reden waarom we beginnen te leren hoe te werken met bestanden.
Meer specifiek, wat wij als volgt.
Het is heel simpel.
Er zijn slechts een paar stappen, en ze zijn hier vermeld op deze code.
Dus we gaan door te gaan deze code regel voor regel.
>> Ten eerste, zie je gemarkeerd -
wanneer u werkt met een bestand, ongeacht het type bestand het is,
je nodig hebt om het te openen.
En dat is met een oproep om fopen -
hier.
U de naam van het bestand.
Als het bestand niet in uw telefoonboek, of de map waarin het programma
leven, dan moet je ook op te nemen een pad naar de plaats waar dat bestand is.
>> We gaan ervan uit dat deze bestand genaamd "text.txt" -
een eenvoudig tekstdocument - is in de dezelfde map als dit programma is.
Dus dat is een ander ding om in te houden geest - dat als u een bestand wilt openen
ergens anders, je eigenlijk nodig hebt de locatie omvatten.
>> Ten tweede kunt u een argument doorgeven aan fopen, en dat is wat u wilt doen
met het bestand.
Er zijn drie belangrijke argumenten die je gaat doorgeven aan fopen.
Wie kan mij die drie?
Wie kan mij een van hen?
Ja.
>> STUDENT 4: De bestandsnaam?
>> JASON HIRSCHHORN: Sorry.
De drie belangrijkste argumenten die je kunt doorgeven als tweede argument aan fopen.
Je hebt gelijk - de bestandsnaam is het eerste argument.
Maar het tweede argument om fopen zijn algemeen drie snaren, en - ja.
Aleja.
>> Aleja: A voor append.
>> JASON HIRSCHHORN: A, als je wilt toevoegen aan een bestand dat al bestaat.
>> STUDENT 5: R voor lezen.
>> JASON HIRSCHHORN: R, als je wilt lezen uit een bestand.
>> STUDENT 6: W voor schrijven.
>> JASON HIRSCHHORN: En w, als je wilt schrijven naar een bestand.
Dus in dit geval, we schrijven naar het bestand, dus we hebben w.
Als je ze opent, moet je ook opslaan bestand ergens, en dat is met de
code aan de linkerkant van de opdracht operator -
Ik ben het creëren van een pointer naar een bestand genoemd, in dit geval, bestand.
>> We gaan niet te maken wat dit alles caps FILE ding is.
Het volstaat te zeggen, het is een lange stroom van nullen en enen.
En dat is hoe we gaan bedienen en te begrijpen.
>> Het volgende wat we moeten doen - en dit is ongelooflijk belangrijk -
wanneer u een bestand opent -
in feite, wanneer je malloc noemen, voor voorbeeld, en nog wat geheugen en probeer
en sla het op in een pointer, je altijd willen controleren om ervoor te zorgen dat die
functie niet null terug.
>> Dus in dit geval, we controleren om ervoor ervoor dat we eigenlijk opende de
correct in te dienen, en er was geen fout in ons programma.
Vervolgens, als we eenmaal gecontroleerd om ervoor te zorgen dat dat we een werkende file, kunnen we
schrijven naar of gelezen van de of toevoegen aan het bestand.
In dit geval ben ik gewoon afdrukken de ene regel naar dit bestand.
>> Hoe weet ik dat?
Nou, ik gebruik deze functie genoemd fprintf.
Alle functies die u gaat gebruiken bij het schrijven naar of het lezen van, of
het manipuleren van bestanden zullen vergelijkbaar zijn functies die u eerder hebt gezien, maar
beginnen met de letter F, staat voor file.
En fprintf, in tegenstelling tot onze normale druk app, neemt een extra argument,
en dat is het bestand waar u deze lijn wilt afdrukken.
>> Ik heb niets te het recht van ohai.
Ik heb niet de derde argument printf -
of het tweede argument printf, de derde argument om fprintf, omdat ik
hebben geen placeholders hier.
Ik ben niet met inbegrip van alle variabelen.
Maar nogmaals, fprintf en al deze file functies die werken met bestanden
zijn over het algemeen gaat het bestand nodig waarop ze werken.
>> Ten slotte is de laatste belangrijke ding om te doen is om het dossier te sluiten, net als
met - wanneer we iets malloc, we iets willen bevrijden, opdat wij niet
een geheugen lek - we willen om ons dossier te sluiten.
Als dit programma verlaten zonder afsluiting het bestand, kansen zijn niets zou gaan
verkeerd, vooral als het was een klein bestand.
>> Maar het is zeker een goede stijl van coderen en oefenen om altijd uw dossier af te sluiten
als je klaar bent het te gebruiken.
Dus dat is de basis van het dossier van I / O. U heeft waarschijnlijk gezien dat vóór of
zag het in die fantastische kort.
Heeft iemand nog vragen hebben, voordat we gaan in wat oefening codering
problemen, over het dossier van I / O of de stappen die ik ging net over?
>> [TYPEN SOUNDS]
>> JASON HIRSCHHORN: Heeft u een vraag, Avi?
>> AVI: Nee.
>> JASON HIRSCHHORN: OK.
Ik ga naar een ander wachten zeven seconden.
[Lacht]
Dat is echt een goede tip.
Jullie hou niet het stellen van vragen.
Dat is prima.
OK.
Dus onze eerste training probleem is, we zijn naar de functie dupliceren
een command-line tool die u waarschijnlijk gebruikt voor - kopiëren -
de kopie tool.
Als je cp typt en vervolgens doorgeven twee argumenten in uw terminal, kunt u
een kopie van een bestand.
En dat is wat we gaan om nu te schrijven.
>> Dus nogmaals, het aflezen van deze dia, zou ik u naar een programma dat duurt te schrijven
twee en slechts twee command-line argumenten -
een bronbestand en een doelbestand -
en kopieert de inhoud van de bron bestand naar het doelbestand
een byte tegelijk.
Dus dat is een veel gevraagd voor.
>> Weer een goede benadering is om niet rechtstreeks naar de C-code, maar
breken in een paar stappen.
Eerste, na te denken over de logica in - precies wat ik je vraag te doen -
en begrijp alle van de stappen om dit probleem.
Niet in C, maar in sommige pseudocode, of zelfs een mentaal model van
wat er gaande is.
>> Vervolgens, als je eenmaal de pseudocode naar beneden, erachter te komen hoe de pseudocode
kaarten op gereedschappen en dingen die we hebben geleerd voor gebruik in C.
>> En tenslotte, als je eenmaal al die samen, kunt u het probleem te coderen.
5 tot 10 minuten te werken aan dit probleem.
Ik zal de instructies zetten back-up in een tweede.
En dan gaan we voorbij gaan de pseudocode en code
leven als een groep.
>> Als u vragen hebt, terwijl je werken aan dit, voel je vrij om te verhogen
je hand, en ik zal komen rond en beantwoord ze.
>> STUDENT 7: Kan ik vegen een stuk papier?
>> JASON HIRSCHHORN: What's up?
>> [TYPEN SOUNDS]
>> JASON HIRSCHHORN: OK.
Laten we gaan over de pseudocode eerste, en dan zal ik je een paar meer geven
minuten te eindigen codering.
>> Wie wil ik beginnen met met de eerste regel van
pseudocode voor deze functie?
>> STUDENT 8: Controleer dat jullie kregen twee bestanden.
>> JASON HIRSCHHORN: OK.
En als wij niet?
>> STUDENT 8: Ik zou 0 terugkeren.
>> JASON HIRSCHHORN: Moeten we 0 terugkeren?
>> STUDENT 8: Geeft een -
blanking.
Sorry.
>> JASON HIRSCHHORN: Yeah.
Waarschijnlijk niet 0.
Omdat 0 betekent alles was goed.
OK.
Dus dat is de eerste regel van pseudocode.
Wie heeft de tweede regel van pseudocode?
>> STUDENT 9: Open beide bestanden?
>> JASON HIRSCHHORN: Open beide bestanden.
OK?
>> STUDENT 10: Controleer als het bestand is NULL?
>> JASON HIRSCHHORN: Controleer zeker ook niet NULL.
Even terzijde -
slash 0 -
is dat NULL?
>> STUDENT 11: Nee.
>> JASON HIRSCHHORN: Dat is niet NULL.
Dat heet de NULL terminator.
Het is eigenlijk gespeld met slechts een l.
Dus controleren iets tegen dat - dat is eigenlijk een personage -
dus controleren iets tegen dat niet hetzelfde als controle om te zien of het
is gelijk aan NULL.
>> En sommige mensen -
op hun quizzen en hun probleem sets - heb de
twee van deze verward.
Maar de twee daarvan zijn in feite verschillend.
Men eindigt een string -
een is een pointer naar 0.
>> STUDENT 12: Waarom zou je niet controleren zorg ervoor dat de bestanden niet NULL
voordat u ze opent?
>> JASON HIRSCHHORN: Dus geopend bespaart iets in dat bestand.
En als je hier terug -
dus deze lijn - fopen -
zal je een adres en op te slaan geven dat adres in het dossier of het werkt.
Als het niet werkt, het zal NULL opslaan -
>> STUDENT 12: Oh.
OK.
Heb je.
>> JASON HIRSCHHORN: In bestand.
Dus je kunt niet controleren op NULL voordat je ze hebt geopend.
NULL betekent iets niet deed goed werken.
OK.
Check dus zeker niet wil maken?
Of zijn?
Wat vinden we?
We gaan met dat.
>> STUDENT 13: Is.
>> JASON HIRSCHHORN: Is?
Evenmin is?
>> STUDENT 13: Is.
>> JASON HIRSCHHORN: OK.
We lijken sommige hebben consensus over dat.
Evenmin is NULL.
OK, volgende regel van pseudocode.
Wie heeft mij nog niet gegeven een lijn?
We zullen op je wachten.
Yeah.
>> STUDENT 14: Je moet lezen van het eerste bestand?
>> JASON HIRSCHHORN: OK.
>> STUDENT 14: Of we gebruiken fscanf of zoiets het eerste bestand?
>> JASON HIRSCHHORN: Dus we willen lezen uit het eerste bestand en -
laten we deze hier.
Lees uit het bronbestand.
En dan, wat doen we nadat we lezen van het bronbestand?
Iemand anders?
>> STUDENT 15: Schrijf in het doelbestand?
>> JASON HIRSCHHORN: Wij schrijven het doelbestand, en -
OK.
Wat missen we?
Iemand anders die heeft mij niet een bepaalde regel code nog - van pseudocode.
Yeah.
>> STUDENT 16: Misschien kan je altijd controleren of er is iets te lezen voor,
als de volgende regel?
Die zijn als de volgende regel, zien of het bestaat.
>> [ELEKTRONISCHE TOON]
>> JASON HIRSCHHORN: Oeps.
Dat is mijn journaling software.
Yeah?
>> STUDENT 16: Ja.
>> JASON HIRSCHHORN: Dus geef het me nog een keer.
>> STUDENT 16: Controleer of er voldoende nog een volgende lijn van de
bronbestand te lezen.
>> JASON HIRSCHHORN: OK.
Zodat we niet lezen van regels - werden hier lezen bytes -
maar je bent juist bent.
We willen lezen en schrijven tot er niet meer bytes.
OK.
En dus deze moet echt ingesprongen zijn een beetje, omdat ze onder daar.
Rechts?
Totdat we uit bytes, gaan we lezen van het bronbestand en schrijf
naar het doelbestand.
>> En dan, wat is het laatste lijn van pseudocode?
Iemand die niet gegeven me nog iets.
>> STUDENT 17: Sluit de bestanden?
>> JASON HIRSCHHORN: Precies.
Sluit de bestanden.
Dus er is pseudocode.
Ik ga naar de pseudocode in kunt plaatsen gedit, en in een paar minuten zijn we
zal dit samen te coderen.
>> OK.
Laten we aan de slag als groep.
Nishant, ik heb mijn nieuwe bestand.
Ik heb dit net geopend.
Untitled document 1.
Wat is het eerste wat ik moet doen?
>> Nishant: Voeg bibliotheken?
>> JASON HIRSCHHORN: OK.
Wat bibliotheken?
>> Nishant: stdio.h, stdlib.h, geloof ik?
>> JASON HIRSCHHORN: OK.
Wat is stdlib voor?
>> Nishant: Ik vergat.
>> JASON HIRSCHHORN: OK.
Dus omvatten stdio.
Wat moet ik doen, zelfs voordat Ik begin te coderen?
>> Nishant: Schrijf een header?
>> JASON HIRSCHHORN: Hoe krijg ik het gekleurd?
>> [Onderbreekt hem VOICES]
>> Nishant: Hoe krijg je het gekleurd?
>> JASON HIRSCHHORN: Hoe ik kleurcodering?
>> Nishant: Ik weet het niet.
Oh.
Besparen.
>> JASON HIRSCHHORN: Save.
Ja.
Ik moet het opslaan als een. C.
Dus sla het op het bureaublad als cp.c.
Sweet.
En als ik wil volledige stijl te krijgen punten, wat moet ik
onder meer aan de top?
>> Nishant: U kon uw naam, naam schrijven van het programma, en het doel
van het programma ook?
>> JASON HIRSCHHORN: Ziet er goed uit.
Excellent.
Dus je hebt ons perfect begonnen.
# Include -
zullen we ook schrijven -
OK.
Dus ik denk dat ik ben klaar om te gaan.
Wie heeft de eerste regel van de code voor mij - of de eerste regels code die
het zal duren om te voldoen aan onze eerste commentaar in pseudocode?
Je.
>> STUDENT 18: Moet het niet int argc, en dan char * argv?
>> JASON HIRSCHHORN: Ik denk je hebt gelijk.
Laten we veranderen in de belangrijkste open Paren int, int argc, komma, char * argv?
Als dat?
>> STUDENT 18: Beugels.
>> JASON HIRSCHHORN: Beugels.
Open beugel, haakje sluiten, dicht ouder.
Perfect.
Nu kan ik command-line argumenten nemen.
OK.
Zorgen we krijgen twee bestanden.
Je kan me dat ook geven.
>> STUDENT 18: Als argc -
dit men niet gelijk 3.
>> JASON HIRSCHHORN: Als geopend Paren argc niet gelijk 3?
>> STUDENT 18: Ja, u terug 1 of iets.
>> JASON HIRSCHHORN: Sorry.
>> STUDENT 18: Return 1 of iets.
>> JASON HIRSCHHORN: Terug 1.
OK?
Geweldig.
Open beide bestanden.
Wie kan mij helpen beide bestanden openen?
Wie heeft mij nog niet gegeven code?
Kurt?
>> KURT: Dus alle doppen F-I-L-E ster bron.
>> JASON HIRSCHHORN: Ik ga tot het afsluiten van de klinkers.
Die zijn cool.
Het is net als Tumblr.
>> STUDENT 18: Is gelijk fopen -
>> JASON HIRSCHHORN: Is gelijk fopen?
>> STUDENT 18: Open Paren, argv, haakje openen.
>> JASON HIRSCHHORN: Wacht.
Sorry.
Open Paren.
OK.
>> STUDENT 18: Ja.
Argv sub 1.
>> JASON HIRSCHHORN: Sub 1?
>> STUDENT 18: Ja.
Argv geopend beugel 1 -
Ja.
En dan komma, en dan dubbele open citaat, r, dubbel aanhalingsteken,
dicht Paren, puntkomma.
>> JASON HIRSCHHORN: Zoet.
En hoe zit het met de andere?
>> STUDENT 18: Zeer vergelijkbaar, maar in plaats daarvan van S-R-C, zou je het ook noemt D-S-T.
>> JASON HIRSCHHORN: Oo!
Dat vind ik leuk.
>> STUDENT 18: Just D-S-T. Yeah.
En dan argv, haakje openen, 2.
Yeah.
En dan w plaats van r.
Yeah.
>> JASON HIRSCHHORN: Great.
Volgende paar regels.
Ook als iemand heeft dingen toe te voegen aan lijnen die we hebben gedaan, voel je vrij om
toe te voegen die ook.
Controleer of geen van beide is NULL.
Wie kan mij de code die ik moet geven aan voldoen aan die lijn van pseudocode?
Archer.
>> Boogschutter: Als src gelijk gelijken NULL of dst gelijk gelijken
NULL, dan keert u terug -
>> JASON HIRSCHHORN: Wat?
>> ARCHER: Return 2?
>> JASON HIRSCHHORN: Return 2.
Dus als geopend Paren src gelijk gelijk is aan NULL, of -
wat dat thing's - pijp?
Pijp?
We noemen het pijp.
Pijp, pijp, dst gelijk gelijken NULL, terug 2.
OK?
Tot we bytes -
we soort overgeslagen deze stap uit de pseudocode deel aan het gaan naar hier.
>> Maar tot we bytes - wat klinkt dat?
Welk type C structuur -
maar ik heb niet het woord structuur te gebruiken, want we gaan aan de slag met
dat in andere gevallen -
maar C instrument klinkt dat?
>> STUDENT 19: Een lus.
>> JASON HIRSCHHORN: Een lus.
Klinkt als een lus.
Dus wie kan me de eerste lijn geven van de lus code hier?
U kunt ook kiezen wat voor soort loop je wilt, als je me
deze lijn van code.
Er zijn drie soorten.
Je krijgt te plukken.
Ik stel voor een van die.
Avi.
Welke wil je?
>> AVI: VOOR.
>> JASON HIRSCHHORN: VOOR.
>> AVI: int i gelijk is aan nul.
>> JASON HIRSCHHORN: OK.
>> AVI: Dit deel ik ben niet zeker over.
Maar i kleiner dan de grootte van ster bron?
Ik ben niet zeker van dat.
>> JASON HIRSCHHORN: OK.
>> AVI: Omdat u wilt dat de grootte van een bestand, toch?
>> JASON HIRSCHHORN: Dus dit zal waarschijnlijk niet Geef ons de grootte van de werkelijke
bestand in bytes.
Dus wat kunnen we doen?
Wat is een ander type lus?
Of moeten we vasthouden aan de FOR-lus?
>> STUDENT 20: Kunt u een WHILE lus doen?
En dan, wat je zou doen is you'd -
want we hebben een char * voor het bestand.
Dus als we gewoon blijven ophogen dat totdat we de nul karakter aan zou vinden
het einde van het?
Of nee, is dat niet hoe de bestanden werken?
>> JASON HIRSCHHORN: Dus we kunnen houden het verhogen van de char *
totdat we de NULL -
>> STUDENT 20: In wezen blijven gaan teken voor teken totdat we raken
het einde van het bestand.
>> JASON HIRSCHHORN: Ja.
Dus dat is wat we willen doen.
We willen lezen, karakter houden door karakter, tot we bij
het einde van het bestand.
>> STUDENT 20: Ja.
Vinden -
wat is het einde of stopteken aan het einde van een tekstbestand.
>> JASON HIRSCHHORN: OK.
Dus toen we bij het einde van het bestand - Hoe weten we dat we hebben bereikt
het einde van een bestand?
Als ik bel -
dus laten we een stap terug.
Wat is een functie?
Laten we deze lijn hier.
Lees uit het bronbestand.
Wie kan mij dat regel code geven?
>> STUDENT 21: fscanf?
>> JASON HIRSCHHORN: fscanf.
OK.
Wat als ik wil lezen, zeer specifiek een byte?
>> STUDENT 21: Ik weet het niet.
>> JASON HIRSCHHORN: OK.
Zelfs eenvoudiger dan fscanf - wat is een -
Ik wil lezen uit een bronbestand?
Lezen van een bronbestand.
Wat is een functie - ja.
>> STUDENT 22: Het is fread?
>> JASON HIRSCHHORN: fread.
Ik denk dat laten we vasthouden aan dat een voor nu.
Wat voor argumenten doet fread nemen?
>> STUDENT 22: Waarschijnlijk het bestandstype, en vervolgens locatie in het bestand?
>> JASON HIRSCHHORN: Wat kan ik hier typen om erachter te komen wat voor soort argumenten
fread neemt?
>> MEERDERE STUDENTEN: Man fread.
>> JASON HIRSCHHORN: Man fread en fwrite.
Ziet eruit alsof ze hangen samen.
Dus fread neemt hoeveel argumenten?
>> STUDENT 23: Vier.
>> JASON HIRSCHHORN: Het duurt vier argumenten.
Het duurt een pointer, een maat, en dat ding, dat is raar, en een bestand.
OK?
Laten we lezen over het hier.
"De functie fread leest n memb elementen van gegevens, elke maat bytes
lang, van de stroom naar wijst streamen, ze op te slaan op de locatie
van de aanwijzer. "
>> Dus vier argumenten.
Waarom heb ik niet kopiëren dit gewoon, en plak het hier.
OK.
Dus wie kan beginnen invullen deze argumenten voor mij?
Avi.
>> AVI: Haal de leegte.
Zet gewoon src.
Neem pointer en de ster.
Put src.
Dan -
>> JASON HIRSCHHORN: Dus ik ga stoppen je daar, want dat is ingevuld.
Je hebt gelijk met src, maar waar moet src gaan?
>> [Onderbreekt hem VOICES]
>> JASON HIRSCHHORN: het moet ga hierheen.
Dat is het src - onze src is een type.
Laten we eens kijken hier.
Dit vraagt ​​om een ​​bestandstype *, we eigenlijk meestal ze te zien als dat.
Dus dit vraagt ​​om een ​​argument van bestandstype * genaamd stroom die is src.
OK?
>> Welke maat van dingen te doen we willen lezen?
Ik je dit gaf in de beschrijving van het probleem.
>> STUDENT 24: een byte tegelijk.
>> JASON HIRSCHHORN: Een byte.
Hoe groot is een byte?
Zijn grootte is in bytes, dus wat kan ik daar?
>> STUDENT 25: One.
>> JASON HIRSCHHORN: One.
Rechts.
Zijn grootte is in eenheid byte, dus 1 is 1 byte.
Hoeveel wil ik lezen op een moment.
>> STUDENT 26: One?
>> JASON HIRSCHHORN: Éen ding.
Ik wil een ding van formaat lezen 1, een beet tegelijkertijd.
En waar kan ik het, zodra ik het lezen?
>> STUDENT 27: Bestemming?
>> JASON HIRSCHHORN: Dus ik kan het niet het recht in bestemming.
>> STUDENT 28: Je gaat put het in een derde pointer?
>> STUDENT 27: Als u de bestemming.
>> JASON HIRSCHHORN: OK.
Yeah.
>> STUDENT 29: Je kan iets verklaren als tijdelijk opslag eerder.
>> JASON HIRSCHHORN: OK.
Geef me dat.
>> STUDENT 29: Een ander bestand wijzer, misschien?
>> JASON HIRSCHHORN: OK.
Dus dit is nietig ster -
het is een soort leegte ster, zodat het niet moeten een bestands pointer zijn.
En als ik lees een byte, waar een goede plek zou zijn
om een ​​byte te slaan?
>> STUDENT 29: Een array?
>> JASON HIRSCHHORN: Een array.
OK.
En wat is iets dat alleen grootte van een byte?
>> STUDENT 30: Een char *?
>> STUDENT 29: Ja.
>> JASON HIRSCHHORN: A char * is een byte.
>> STUDENT 29: Een char.
>> JASON HIRSCHHORN: Een char is een byte.
Rechts?
Dus laten we noemen deze buffer is een generieke naam voor deze dingen op te slaan
iets tijdelijk.
Dus ik maak een buffer.
Rechts?
Maar het vergt wel een leegte *.
Dus misschien heb je gelijk, dat het moet een buffer van maat 0 zijn.
Het slaat dus een -
rechts.
>> Omdat dit recht hier - char buffer is een teken, maar
dit duurt een leegte * -
een pointer.
Dus ik kon doen en nu buffer is een pointer.
Wat kan ik doen?
>> STUDENT 31: Zet een ster naast char.
>> JASON HIRSCHHORN: ik kon hebt gemaakt het char *.
OK.
Wat is een ander ding dat ik kan doen?
Of laten we gaan met deze.
Char * buffer, dus wat zet ik hier?
>> STUDENT 31: Buffer.
>> JASON HIRSCHHORN: Buffer.
Buffer is een pointer naar een char.
En op die locatie, we zetten een byte van iets wat we lezen.
Yeah.
Avi.
>> AVI: Gewoon een snelle vraag.
Wil je buffer malloc?
>> JASON HIRSCHHORN: Wie kan die vraag te beantwoorden?
>> STUDENT 32: Nou, Het maakt eigenlijk niet punt om iets nu, dus -
>> JASON HIRSCHHORN: Maar doen we willen het malloc?
>> STUDENT 32: Als je om het te doen dat Trouwens, ik denk, ja, omdat je nodig hebt
een plaats voor het te wijzen.
>> JASON HIRSCHHORN: Hebben we moet het malloc?
>> STUDENT 33: Als je gaat gebruiken buiten de lus.
>> JASON HIRSCHHORN: Gaan we gebruiken buiten de lus?
>> STUDENT 34: Ja.
>> STUDENT 35: Wacht.
Willen we het te verklaren in de lus naar buiten?
>> JASON HIRSCHHORN: Dus ik denk dat we moeten sommige pseudo WHILE lus hier dat we
proberen te achterhalen, dat hebben wij nog niet aan gekregen.
We hoeven niet te malloc.
We zijn actief in de belangrijkste, het is alleen maar voor gebruik binnen deze lus.
Het hoeft niet te bestaan buiten dit.
>> Zo kan een lokale variabele.
Je hebt een pointer naar een lokale variabele.
>> STUDENT 36: Maar het is niet wijst naar iets.
>> JASON HIRSCHHORN: Nee, het is niet geïnitialiseerd tot niets.
Maar we zijn niet van plan om het ook te gebruiken.
We gaan iets in te zetten het de eerste keer dat we het gebruiken.
Dus dat lijkt OK.
Zodat we niet malloc hier nodig.
En ik denk dat het goed is zoals het is.
OK.
Wij hebben de fread lijn.
Laten we de volgende regel.
>> Als we willen schrijven naar een bestand, wat is een goede functie te gebruiken om dat te doen?
>> STUDENT 37: fwrite?
>> STUDENT 38: Fprintf?
>> JASON HIRSCHHORN: Fprintf is een.
Wat is er nog een?
>> STUDENT 39: fwrite.
>> JASON HIRSCHHORN: fwrite.
En voor onze doeleinden, fwrite, die we hier zagen, is
waarschijnlijk de betere keuze.
Het duurt vier argumenten ook.
Nishant, kunt u me de argumenten?
>> Nishant: De eerste gaat er gewoon buffer zijn.
>> JASON HIRSCHHORN: OK.
>> Nishant: De tweede is gewoon naar zijn 1.
Derde een gaat worden 1.
En de vierde men gaat dst zijn.
>> JASON HIRSCHHORN: Heeft iemand vragen over die lijn?
Dat ziet er goed uit.
OK.
Dus nu lijkt het alsof het een ding zijn we vermist - eigenlijk, laten we schrijven
deze laatste regel.
Sluit de bestanden.
Wie kan ons eindigen schrijven deze laatste twee regels?
Ja.
Sorry, wat is uw naam?
>> LUCY: Lucy.
>> JASON HIRSCHHORN: Lucy.
>> LUCY: FSluit src en vervolgens fclose bestemming.
>> JASON HIRSCHHORN: FSluit open Paren, src, dicht Paren, puntkomma.
En fclose -
ja?
>> LUCY: Open haakjes, dst en dan puntkomma.
>> JASON HIRSCHHORN: Great.
En wat moet ik onder andere aan het eind?
>> LUCY: Return 0.
>> JASON HIRSCHHORN: Return 0.
Moet ik?
Gewoon een vraag.
Moeten we return 0 omvatten?
>> MEERDERE STUDENTEN: Nee.
>> JASON HIRSCHHORN: Nee.
Belangrijkste doet het automatisch als je naar het einde.
Maar ik vind het leuk om omvatten het expliciet.
Vooral als we andere gaan terug dingen door het programma.
OK.
Dit is wat we missen -
TERWIJL wat?
Wie kan denken aan een -
heeft een aantal gevoel van wat dingen kon binnen gaan?
Zelfs al is het maar in sommige pseudocode zoals taal?
>> Wat zijn we echt - wat willen we gaan tot?
Ja, Lucy.
>> LUCY: Het einde van het bestand.
>> JASON HIRSCHHORN: Het einde van het bestand.
Dus wat bedoel je met het einde van het bestand?
>> LUCY: Zodra u bij de einde van het bestand, te stoppen.
>> JASON HIRSCHHORN: OK.
Dus zodra bereiken we het einde van het bestand.
Hoe weten we wanneer we hebt bereikt het einde van het bestand?
>> STUDENT 40: Ik denk buffer wordt ingesteld op NULL.
>> STUDENT 41: Buffer wordt verklaard in de lus.
>> JASON HIRSCHHORN: Dus je denkt buffer wordt ingesteld op NULL.
Waarom zou buffer worden ingesteld op NULL?
>> STUDENT 40: Want als je fread, je probeert te zetten
niets in de buffer.
>> JASON HIRSCHHORN: OK.
Dus je denkt fread -
wanneer we het einde van het hebt bereikt file, wat fread gaat doen?
Ik denk dat is de vraag we moeten uitzoeken.
Wat doet fread doen?
Is het zetten NULL in buffer, of doet het iets anders doen?
Hoe kunnen we achterhalen wat het doet?
>> STUDENT 42: Man.
>> JASON HIRSCHHORN: Man.
Dus laten we eens kijken hier.
Return waarde.
Op succes, fread en fwrite terug de aantal artikelen gelezen of geschreven.
Dit aantal is gelijk aan het aantal bytes pas over, indien de grootte is 1.
Als er een fout optreedt, of het einde van de bestand is bereikt, is de geretourneerde waarde een
korte telling artikel of 0.
>> Dus voor onze doeleinden, indien fread bereikt het einde van het bestand, en leest uit
het einde van het bestand, is er niets meer om te lezen, wat gaat het om terug te keren?
>> STUDENT 43: Zero?
>> JASON HIRSCHHORN: Wat?
>> STUDENT 43: Zero?
>> JASON HIRSCHHORN: Zero.
Het gaat terug op nul komen.
Dus we weten dat fread, toen we hebben aan het einde van het bestand, gaat
nul terug.
Hoe kunnen we dat in ons voordeel?
>> AVI: U kunt buiten een variabele declareert van de lus genoemd cheque.
Als check gelijk -
voor nu - een.
>> JASON HIRSCHHORN: OK.
>> AVI: En dan kun je een IF zetten verklaring direct na fread zeggen als
fread gelijk aan nul -
nee.
>> JASON HIRSCHHORN: Wie kan helpen Avi uit?
>> AVI: Wat is de waarde geretourneerd door fread?
>> JASON HIRSCHHORN: We hebben net ging meer dan dat.
>> AVI: Hoe doe je het voor?
>> JASON HIRSCHHORN: Dus het terugkeert - laten we kijk omhoog hier - het geeft een
size_t, die in wezen een geheel getal.
Zo geeft een geheel.
En in dit geval, zal het return 1 of 0 -
1 als het lezen een ding - een byte, en 0 als we het einde bereikt.
Dus als fread -
ja?
>> STUDENT 45: Kun je niet gewoon de volledige fread (buffer, 1, 1, src) in de
while loop?
>> JASON HIRSCHHORN: Dus u voorstelt dit te doen in daar?
>> [Onderbreekt hem VOICES]
>> JASON HIRSCHHORN: Wacht even.
Dus we bevrijden van dat.
Dus je voorstelt zetten fread in daar?
Wat moeten we gaan ook als je dat willen doen?
>> STUDENT 45: De buffer buiten.
>> JASON HIRSCHHORN: We moeten ook verplaatsen deze hier.
>> STUDENT 45: Maar doet dat voortdurend vooruit het?
>> [Onderbreekt hem VOICES]
>> JASON HIRSCHHORN: OK.
Dus dit is wat Okshar voorgesteld.
We creëren onze buffer.
We TERWIJL fread, dan fwrite we.
Gedachten over dit?
>> STUDENT 46: Mijn enige vraag is, zou het eigenlijk de opdracht fread voeren?
>> JASON HIRSCHHORN: Goede vraag.
Als je het aantrekken van een functie aan te roepen binnenkant van een aandoening, doet dat
functie-oproep te voeren?
We hebben eerder gezien voorbeelden van.
Rechts?
>> STUDENT 46: OK.
Yeah.
Dus het doet uitvoeren.
>> JASON HIRSCHHORN: We hebben dingen gezien zoals dat vóór, waar we een
functie oproep binnen van een aandoening.
Betekent dat de functie oproep te voeren?
Ja.
Dus het antwoord is ja.
Deze functie oproep zal uitvoeren.
Maar nogmaals, het is wat we willen?
>> Wat is een manier waarop we konden achterhalen te komen of het is wat we willen?
>> MEERDERE STUDENTEN: Run it?
>> JASON HIRSCHHORN: We kunnen het uit te voeren.
Maar voordat we dat doen, kunnen we ook redeneren doorheen.
Als -
zeggen dat we een byte in onze bestand, wij hier krijgt,
we krijgen aan deze code.
Deze zal lopen.
fread zal een byte terugkeren en opslaan in de buffer.
En dit zal evalueren om 1, rechts, nadat hij terugkeert 1.
>> Dus terwijl 1.
Betekent dit dat de code binnen De while-lus zal uitvoeren?
>> STUDENT 47: Ja.
Het is waar.
>> JASON HIRSCHHORN: Ja.
1 waar.
Het is niet 0.
Dus de code binnen hier zal uitvoeren.
Dus we zullen schrijven dat.
We komen terug naar deze te gaan lijn weer.
Nu hebben we -
we zijn aan het einde van ons bestand.
We lezen uit het einde van ons bestand, want we hadden maar een byte in.
>> Fread geeft 0, winkels iets buffer.
Ik weet eerlijk gezegd niet wat het slaat in buffer.
We kunnen waarschijnlijk opzoeken om te zien wat het doet.
Dat ik eerlijk gezegd niet weten.
We weten niet, wie wat cares het slaat in buffer?
Maar het doet terugkeren 0.
En zal terwijl 0 uitvoeren?
>> TERWIJL 0 zullen niet worden uitgevoerd.
Dus dan gaan we hier beneden bewegen.
Dus laten we een show van de handen als dit is de code die we moeten lopen, of als we
moet eerst veranderingen doen.
Dus als je denkt - je moet stemmen.
Als u denkt dat we deze code zou moeten lopen zo is, neem dan steek je hand.
>> OK.
Er is een -
heb je een vraag, zorg?
Yeah.
>> STUDENT 48: Na buffer gaan we buiten de lus, doen we
moet het malloc?
>> JASON HIRSCHHORN: Goede vraag.
Nadat we verhuizen buffer buiten de lus, moeten we het malloc?
Dit is een scope vraag.
Als we initialiseren buffer buiten van deze lus, zal het bestaan
binnenzijde van de lus?
>> MEERDERE STUDENTEN: Ja.
>> JASON HIRSCHHORN: Ja.
Het toepassingsgebied omvat binnenkant van de lus, en, eigenlijk, iets minder dan het binnen
van deze code, met inbegrip van de dingen binnen hier.
Dus we hoeven niet te malloc.
Het is een lokale variabele, en het toepassingsgebied bevat nog steeds de lus.
>> STUDENT 49: Moeten we het gratis?
>> JASON HIRSCHHORN: Hebben we moeten vrije buffer?
>> STUDENT 49: Ja, als we niet malloc.
>> JASON HIRSCHHORN: Hebben we moeten vrije buffer?
Dat doen we niet.
Nogmaals, het is een lokale variabele, dus we hoeven niet te bevrijden.
OK.
Laten we eens kijken wat er gebeurt.
Het is dus niet-geïnitialiseerd.
Dat was wat iets dat Marcus eerder voorgesteld.
Dus we hebben die fout, variabele buffer wordt uninitialized wanneer hier gebruikt.
>> Hoe kunnen we dit oplossen?
>> STUDENT 50: malloc het?
>> STUDENT 51: Is gelijk aan NULL?
>> STUDENT 52: Zeg buffer is gelijk aan NULL.
>> JASON HIRSCHHORN: OK.
Ziet er goed uit.
We hebben het nu.
Laten we iets te kopiëren proberen te creëren.
Dus hebben we onze tekstbestand.
Hoe kunnen we dit programma uit te voeren?
Yeah.
>> STUDENT 53: U kunt dot doen slash cp, test.txt.
En dan kun je een ander bestand een naam waarin het zal opslaan in.
>> JASON HIRSCHHORN: OK.
We noemen het out.txt.
Cool?
Seg schuld.
Gedachten over de seg schuld?
Dit is geweldig.
Hoe kunnen we te weten komen waar de seg fout is?
Wat?
>> STUDENT 54: Gdb.
>> JASON HIRSCHHORN: Gdb.
We lopen door het schrijven van gdb gdb dot slash, de naam van ons programma.
Geen command line argumenten daar.
We gaan een set breekpunt bij de belangrijkste.
Als ik wil gdb beginnen, wat moet ik doen?
>> STUDENT 55: R.
>> JASON HIRSCHHORN: R. En dan?
>> STUDENT 55: De argumenten?
>> JASON HIRSCHHORN: Dan de command-line argumenten.
Laten we lopen door.
N is gewoon het nemen van me regel voor regel.
Ik ga om te gaan tot Ik krijg mijn seg fout.
Daar is mijn seg fout.
Het ziet eruit als fread veroorzaakt mijn seg fout.
Ik weet fread veroorzaakt mijn seg schuld, want dat was de
lijn we gewoon uitgevoerd.
>> En het enige dat was gebeurt in die lijn -
twee dingen gebeurden.
Fread ging, en toen waren we het doen van wat tijdens het controleren.
Ik durf te wedden dat de TERWIJL de controle werd niet veroorzaakt mijn seg fout.
Het meest waarschijnlijk, fread was waardoor mijn seg fout.
Ook zie ik hier iets, memcopy.
>> Geheugen kopie.
Klinkt als het verplaatsen van het geheugen van ene locatie naar de andere.
Klinkt als iets dat zou gebeuren in fread, misschien wat geheugen
het verplaatsen van hier naar hier.
Laten we weer meemaken.
Hoe start ik het over en voer het weer?
Yeah.
>> STUDENT 56: Heeft u behoefte aan zet een ampersand voor buffer?
>> JASON HIRSCHHORN: Dus ampersand vóór buffer zou mij het adres geven van
buffer, die een char *.
Laten we lopen door dit nog een keer.
Hoe voer ik door het nog een keer?
>> STUDENT 57: Kan je gewoon typ Uitvoeren weer?
>> JASON HIRSCHHORN: Typ gewoon run weer.
Dus we gaan niet deze lijn uit te voeren.
Dus buffer is een NULL-pointer.
Correct?
Het wijst naar - laten we eens kijken.
Als we onze -
trekken snel een foto van deze.
Kan iedereen zien of Ik schrijf hier dan?
>> Dus in de stapel, we hebben een lokale variabele en het is buffer genoemd, en
het is een pointer naar een char.
Welk adres is dit char op?
>> STUDENT 58: 0x0.
>> JASON HIRSCHHORN: Juist.
Dat is wat dit is.
In hier, binnen buffer wordt opgeslagen 0x0.
Dat is wat we hebben - de setup we nu hebben.
Dus deze lijn, fread, zet iets van de bron waar?
In dit vak of deze doos?
Welke doos?
Links of rechts doos doos?
Dit recht doos.
>> Het volgt de aanwijzer, en zet het in hier.
Wanneer we proberen contact geheugen op locatie 0, wat krijgen we?
Een segmentation fault.
Dat is de fout die we nu hebben.
Yeah.
>> STUDENT 59: Heb je niet tot ster buffer te zetten?
Of nee?
Voor fread?
>> JASON HIRSCHHORN: Dus fread neemt een pointer.
Het gaat zo in buffer.
En dan zal het de-verwijzing het ergens binnen fread.
Maar nogmaals, we zagen, het duurt een pointer.
We hoeven niet te passeren ster buffer.
Dat zou passeren het wat is hier.
En dat zou waarschijnlijk geven ons een fout omdat we de-vermeld wordt.
>> Rechts?
Wanneer we de-referentie deze pointer, wanneer we proberen om toegang te krijgen tot deze plaats,
we krijgen een foutmelding - onze segmentation fault.
Dus -
oops.
We gaan om te stoppen uit gdb.
Onze lijn -
ons probleem - rechts is hier op deze lijn.
En het is een probleem omdat van deze lijn.
>> Hoe kunnen we een vak dat is toegankelijk in fread.
Rechts?
We moeten een vak dat is een te maken byte groot, de grootte van een char.
Maar we moeten die doos om toegankelijk te zijn Als deze functie wordt uitgevoerd.
Dus waar -
ja.
Het even welke ideeën?
>> STUDENT 60: Stel gewoon het als een willekeurig karakter.
Gewoon doen char buffer gelijken het karakter.
En dan, als je buffer er -
>> JASON HIRSCHHORN: Wacht.
Char buffer?
Dus geen ster?
>> STUDENT 60: Ja.
Haal de ster.
Gelijk aan een willekeurig karakter.
>> JASON HIRSCHHORN: OK.
Dus geef me een.
>> STUDENT 60: Als een of zoiets.
En dan als je buffer daar, een gebruikt u -
>> STUDENT 61: Star?
Oh nee, de ampersand.
>> STUDENT 60: Gebruik de ampersand.
>> JASON HIRSCHHORN: OK.
En hoe zit het in fwrite?
>> STUDENT 60: Gebruik de ampersand weer.
>> JASON HIRSCHHORN: Oke.
Dus jouw idee is, creëren we een char en zet iets in, en dan
schrijven dat char.
>> STUDENT 60: Ja.
>> JASON HIRSCHHORN: Wat denken de mensen?
>> STUDENT 62: Het is ingewikkeld.
>> JASON HIRSCHHORN: OK.
Laten we trekken het uit.
Dus deze keer, ik ga dit tekenen in rood op de stapel hier, en dan hebben we
zal hebben -
ooh!
Sorry.
Dus deze keer hebben we iets te noemen buffer, en het is op de stapel.
Correct?
En we besparen in het een, in eerste instantie.
>> Dan hebben we onze oproep om fread.
Wat fread doet is het duurt een byte uit ons bestand en zet het ergens.
Het zet ze in welke de ding wijst naar.
Nou, voordat we hadden dit adres -
0x0.
Nu, wat adres hebben we?
>> STUDENT 63: Whatever adres buffer is.
>> JASON HIRSCHHORN: Whatever adres buffer is.
Het gaat waarschijnlijk zijn zoiets.
Waarschijnlijk gaat om te beginnen met een b en een f, en vervolgens zes andere
hexadecimale cijfers.
Maakt niet uit.
Sommige adres.
En we terloops op dat adres in
>> En we gaan ons een zetten byte ding op dat adres.
Dus we gaan ons een zetten byte ding in hier.
En dan gaan we schrijven vanuit wat er ooit in hier.
Heeft iemand enig vragen over dat?
Wie denkt deze code zal werken?
>> Steek je hand op als je denkt Deze code zal werken.
Je moet een standpunt in te nemen.
En wie denkt dat deze code werkt niet?
Steek je hand op.
Iedereen moet zijn het verhogen van hun hand.
OK.
Michael, waar sta je?
>> MICHAEL: Ik kan niet beslissen.
Soort in het midden.
>> JASON HIRSCHHORN: Je bent in het midden.
Kies er een.
>> MICHAEL: Ik geloof en zeggen dat het zal werken.
>> JASON HIRSCHHORN: OK.
Je zult geloven en zeggen dat het werkt?
Wat is er gebeurd?
>> [Onderbreekt hem VOICES]
>> JASON HIRSCHHORN: Geen seg fout.
Hoe kunnen we controleren om te zien of twee dingen gelijk zijn?
Twee bestanden zijn gelijk.
>> STUDENT 64: Verschil.
>> JASON HIRSCHHORN: Diff.
Diff controles voor de verschillen tussen twee bestanden, en als het weer
niets, ze zijn identiek.
En als we open te stellen, krijgen we ons bestand.
Dus dat was de juiste oplossing.
Laten we eens kijken terug op het nog een keer.
We deden eigenlijk niet eens nodig om het te initialiseren.
>> Het zou waarschijnlijk lijken een beetje schoner als je niet zet
iets willekeurigs in.
Het punt is, je moest maken wat ruimte om iets uit te slaan
fread en neem iets uit fwrite.
En dat ding moest ofwel een lokaal zijn variabele op de stack - u
wat ruimte had kunnen malloc'd.
>> Dus we konden eigenlijk hebben geschreven malloc hier, en
dat zou hebben gewerkt.
En dan zouden we zijn het opslaan onze spullen ergens op de heap.
Maar dit is eigenlijk, waarschijnlijk, de meest elegante oplossing.
Je maakt gewoon wat ruimte op de stapel voor deze dingen om te gaan.
>> Ik zou twee andere opmerkingen.
Als je aan de beurt te nemen aan deze, en dan krijg scoorde op deze, mijn commentaar
zou als volgt.
Deze 1 is hier, voor mij, kijk zoals magische getallen.
Deze 1, in termen van fread, zinvol.
Dat is het aantal dingen lezen of schrijven.
>> Maar deze hier moet waarschijnlijk iets anders.
Dus wat is een oplossing?
>> STUDENT 65: Grootte van de byte.
>> JASON HIRSCHHORN: Net als dat?
>> STUDENT 65: Grootte van de char.
>> JASON HIRSCHHORN: Grootte van de char.
Ja, byte is niet een soort.
Dus grootte van char werken.
We konden, bovenaan onze code, # gedefinieerd dat.
Riep iets BYTE en het is echt een char.
Eigenlijk, een nog betere benadering dit zou kunnen geweest zijn -
uint.
Weet iemand wat dat is?
>> Sorry.
Ik heb het naar achteren.
Wacht, nee.
Welke kant gaat het naartoe?
Weet iemand wat dat is?
Yeah.
>> STUDENT 67: moeten helpen standaardiseren tussen systemen dingen die
hebben - zoals unsigned integers dat 8 bytes?
>> JASON HIRSCHHORN: Dat is precies goed.
Op verschillende machines, de grootte van een char -
meestal niet een char.
Chars zijn meestal een byte.
Maar de grootte van andere gegevenstypen verschillende grootte op een 32-bit machine
versus een 64-bit machine.
Een uint8_t is altijd 8 bits -
altijd een byte.
>> En ik moet omvatten dat standaard int header file.
Dus nu, zou dit zijn waarschijnlijk de beste manier om deze code te schrijven.
Dus ik af van de magische getallen.
En ik heb ook een meer logische Typ voor de buffer.
Het is niet alleen een char, het is een byte, dat is wat we verwachten dat het is.
>> En hier, hebben we eigenlijk een beetje meer robuust.
We hebben het niet noemen het een char, die -
misschien, wie weet - kan een andere zijn grootte op verschillende machines.
We zijn eigenlijk te zeggen dit is precies een byte, altijd, wat er ook gebeurt.
En als we hier kijken, maken we cp.
Uh-oh.
Wat is er gebeurd?
>> STUDENT 68: Het kan worden geschakeld.
>> JASON HIRSCHHORN: Wat?
>> STUDENT 69: Is het?
>> STUDENT 70: Dat heb je niet definiëren als een type.
>> STUDENT 71: Maar het moet worden overeenkomstig de norm.
>> STUDENT 72: Wat gebeurt er?
>> STUDENT 73: Moet definiëren hoofdletters?
>> JASON HIRSCHHORN: Dus het is niet # define.
Eigenlijk, in dit geval, ben ik gaat typedef gebruiken.
Omdat we gebruiken het als een soort op een locatie.
Dus in dit geval, we eigenlijk willen typedef alsof we het afdrukken van een nieuw type
byte, en het is in wezen dit.
Het is een beetje anders dan # define.
>> En nu, onze code werkt perfect.
Dus nogmaals, # define neemt iets, vervangt het overal
met de andere zaak.
Het is gewoon een macro -
steno om zich te ontdoen van magische getallen.
Maar in dit geval, omdat we gebruiken als een soort -
hier -
in om dat te werken, moeten we naar typedef wat byte.
>> En we zijn het definiëren van hier.
Het is geen structuur, het is eigenlijk gewoon een unsigned integer.
Het is een byte lang.
Deze code zal online beschikbaar zijn, en jullie moeten het nu hebben.
>> Dus hebben we -
perfect -
13 minuten te gaan over probleem set 5.
Ik wil lopen door copy.c samen, en dan gaan we even praten
de rest het probleem stellen.
Dus laat me omhoog trekken copy.c.
En het leuke is, we hebben eigenlijk al veel van deze code geschreven.
>> De code die we letterlijk schreef net kwam hier toen ik
schrijf dit op mijn eigen.
Maar dit is copy.c, vormt de basis de eerste twee delen van
de voor whodunit.c, probleem dat je nodig hebt om te schrijven, en resize.c.
Recover.c, dat is de derde en laatste deel van het probleem set, is niet
gebaseerd off van dit bestand.
>> Je gaat nodig hebben om dat bestand te schrijven, geven wij u een sjabloon voor dat
bestand, maar het heeft niets te maken met copy.c.
Maar omdat copy.c is de basis voor de eerste twee delen, we gaan
nu doorheen lopen, dus je hebt een goed gevoel voor wat het doet.
>> En de commentaren geven wat van weg.
We hebben al een aantal van dit geschreven.
Ten eerste, we maken zeker krijgen we drie argumenten.
Vervolgens gaan we onthouden van de bestandsnaam.
Dus we overgeslagen deze stap als we gecodeerde ons ding -
toen onze cp.
Maar hier, ze maken het een beetje schoner.
>> Ze controleren om ervoor te zorgen beide bestanden zijn goed, in
Naast ze te openen.
We schreven al deze code gewoon nu, dus ik ben niet van plan om stil te staan ​​bij deze code.
Vervolgens is een aantal dingen die specifiek zijn voor de soorten bestanden die we gebruiken, die
zijn bitmap-bestanden.
Bitmap-bestanden hebben een aantal metadata met hen verbonden.
>> Dus de eerste paar bytes je vertellen over het bestand.
Ze zijn niet de kleuren van de pixel in die afbeelding.
Ze vertellen je over het bestand.
En als je leest door het probleem set, heb je veel meer informatie
Op welke soorten metadata structuren zijn opgenomen met bitmaps.
>> Maar dat is de reden waarom we hebben deze eerste set van - deze code hier.
We lezen de metadata -
twee stukken van metadata - het bestand header en de info header.
En we zijn het controleren van sommige delen van het aan zorg ervoor dat het een echte bitmap-bestand
voordat u verder gaat.
>> En nogmaals, dit zijn details die we niet nodig om nu in.
Als u lezen via het probleem set, u zult begrijpen deze.
Lang verhaal kort, deze zijn gewoon te zeggen, dit is een bitmap-bestand, en
bevestigt dat.
>> Vervolgens gaan we het schrijven van die aan de file.
We zien dat hier.
We schrijven naar de aanwijzer.
Vervolgens gaan we het bepalen van padding.
Dus nogmaals, net als bijzonderheid met een bitmap-bestand, sommige lijnen omvatten
padding aan het eind.
En als je leest door het probleem set, u meer over padding leren.
Dit is de formule om vulling te vinden.
>> Belangrijk om te onthouden -
wanneer u de grootte van een bitmap wijzigen bestand, de opvulling verandert.
Wanneer u de grootte van een te wijzigen bestand, de opvulling verandert.
Het zal nooit worden groter dan 3 -
het zal 0 tot en met 3, inclusief.
Maar als je de grootte van de te wijzigen iets, de opvulling verandert.
>> Als ik maar een pixel in die rij, ik moeten drie bytes van padding, omdat
elke rij veelvouden van vier te bytes lang in een bitmap-bestand.
Maar als ik verdubbel het, om van een pixel twee pixels, die elk,
laten we zeggen, is een byte, dan moet ik twee bytes van de vulling te maken
die gelijk is aan vier.
>> Dus toen ik de grootte van iets, Ik moet het bedrag wijzigen
padding ik heb.
Is dat zinvol voor iedereen?
Vervolgens herhalen we op elke rij, of door alle rijen.
En dan herhalen we door elke kolom in elke rij.
We behandelen dit als bitmap een rooster, zoals we hebben behandeld
het bestuur in 15.
>> Zoals we behandeld de stenen wanneer we gedrukt hen op het scherm.
Een raster van rijen en kolommen.
Dan - we zagen dit.
We eigenlijk dit gewoon gecodeerd.
We creëerden een aantal tijdelijke opslag.
We lezen daar, en dan schrijven we het uit.
Dit is precies wat we net gedaan.
>> Vervolgens, omdat ik zei elke lijn eindigt in sommige padding, we
overslaan die padding -
de oude vulling.
En dan voegen we het terug.
In dit geval, creëren we exact dezelfde file.
We zijn gewoon te kopiëren.
Dus deze lijn is een beetje dom.
We konden letterlijk net zet de vulling binnen
>> Maar als je de grootte van het bestand te veranderen, wil je nog deze lijn?
Dus als we de grootte van een bestand, doen we nog steeds wilt overslaan
over de oude vulling?
>> STUDENT 74: Ja.
>> JASON HIRSCHHORN: Dus we doen.
Omdat dit, nogmaals, deals met het bronbestand.
We geven niet om de opvulling uit het bronbestand.
We willen naar de volgende regel.
Maar we hebben niet alleen terug te zetten de oude hoeveelheid opvulling.
We moeten weer terug de nieuwe hoeveelheid opvulling.
>> Dus als we de grootte van een nu veranderen bestand, willen we nog steeds over te slaan
opvulling in het oude bestand - wat we lezen in uit.
Maar wat we schrijven naar, we gaan nodig hebben om terug wat anders zetten
aantal opvulling die we hebben vastgesteld.
Yeah.
>> STUDENT 75: De volgorde van deze twee lijnen maakt niet uit, toch?
Omdat je omgaan verschillende bestanden.
>> JASON HIRSCHHORN: Precies.
De volgorde van deze twee regels maakt niet uit.
We schrijven deze lijn.
Dit is hier voor het bestand we schrijven naar.
Dat is belangrijk, zodat we de juiste hoeveelheid vulling.
Dit heeft te maken met de in het bestand.
We willen juist overslaan over de vulling.
>> We willen niet te lezen -
als we het lezen van een byte in een tijd, we niet de zorg over die padding bytes.
We willen naar de volgende regel.
Eindelijk net als Lucy gaf voor ons, sluiten we de bestanden en terug 0.
Dus dit is copy.c.
En we eigenlijk schreven - we de meeste van sectie schrijven van dit wezen.
>> Heb jij dit gemaakt.
Dus hopelijk heb je een goed gevoel van wat er aan de hand hier.
Het grote verschil, eerlijk gezegd, is gewoon dit eerste deel dat zich bezighoudt met
eigenaardigheden van bitmap-bestanden.
Dus ik heb zo mijn volgende dia wat moeten we doen?
Nou, laten we nadenken over whodunit.
>> En voor iemand die door te lezen het probleem te stellen, wat doen we
moeten doen in whodunit?
Gewoon.
Aleja.
>> Aleja: Kun je uit het deel van elke pixel die rode geeft.
En dan -
soort?
>> JASON HIRSCHHORN: OK.
Dus neem het deel van elke pixel die rood geeft.
Dat is dichtbij, maar niet alles.
>> STUDENT 76: Nou, er is verschillende manieren om het te doen.
>> JASON HIRSCHHORN: OK.
Geef me een manier.
>> STUDENT 76: Haal alle rode en Vervolgens benadrukken het blauw en groen.
>> JASON HIRSCHHORN: OK.
Dus gezien deze beide manieren -
het klinkt alsof we geven het een pixel, het heeft een rode, blauwe en groene niveau.
We willen de relatieve niveaus van veranderen rood, blauw en groen, afhankelijk
op die pixel.
Waar in deze code moeten we veranderen de relatieve rood, blauw en groen
niveaus van een bepaalde pixel.
Nadat we het heb gelezen -
voordat we schrijven?
Geef me het lijnnummer.
>> MEERDERE STUDENTEN: 83.
>> JASON HIRSCHHORN: 83.
Dus hier.
Voor whodunit, de code die u nodig hebt om write moeten allemaal gaan daar.
En dat is de enige code je nodig hebt om te schrijven.
Want, zoals wij hoorden, alles wat je nodig hebt om doen is verandering deze relatieve blauw,
rode en groene niveaus van elke pixel.
>> Je hebt gelezen dat in, en nu ben je gaan om het uit te schrijven.
Hoe krijg ik - als ik dit ding genaamd triple, hier, en het is van
Typ RGBTRIPLE -
goed, als we keken in bmp.h, wat is RGBTRIPLE?
>> STUDENT 77: Het is een structuur.
>> JASON HIRSCHHORN: RGBTRIPLE is een structuur.
We zien dat hier recht naar beneden.
En dus als ik wilde toegang, bijvoorbeeld de rode niveau van de structuur, hoe kan ik
toegang tot de rode niveau van deze structuur?
>> [KLASSE mompelt]
>> STUDENT 78: RGBTRIPLE.rgbtred?
>> JASON HIRSCHHORN: Klopt dat?
>> STUDENT 79: Het moet triple worden dot, in plaats van RGBTRIPLE dot?
>> JASON HIRSCHHORN: Triple.
Triple is de lokale variabele, dus hier, is er geen aanwijzingen hier.
Dus gebruiken we gewoon de puntnotatie.
Dit zal me het niveau van rood geven.
Als ik wil om het te veranderen, ik stel gewoon dat gelijk is aan iets anders.
Dus nogmaals, deze lijn van code toegang deze variabele in deze structuur, en
kunnen we deze ingesteld op iets nieuws.
>> Dus voor whodunit, nogmaals, dit is, in wezen, wat we moeten doen.
Heel simpel.
Verander gewoon een aantal relatieve niveaus, en dit is waar die code gaat.
Resize, aan de andere kant, is een beetje lastiger.
In feite, resize is waarschijnlijk de lastigste deel van dit probleem te stellen.
We hebben drie minuten te gaan over.
>> Maar nogmaals, we hebben al geschreven de meeste van deze code, zodat we
moet redelijk bekend zijn.
Wat zijn sommige dingen die we willen doen in resize, als je hebt gelezen over de
probleem ingesteld?
Als je ze aan mij, we kan praten over hen.
Wat zijn sommige dingen die we willen doen?
>> STUDENT 80: Verticaal -
dus je moet horizontaal formaat wijzigen, maar verticaal resize het ook?
>> JASON HIRSCHHORN: Dus als we krijgen een pixel, en we willen het wijzigen door een
factor twee, het moet nu worden horizontaal verkleind en vergroot of verkleind
verticaal.
Is dat logisch?
Yeah.
Dus dat is waarschijnlijk de grootste uitdaging.
En we praten over dat in een sec.
Yeah.
>> STUDENT 81: De manier waarop ik dacht er werd u print het uit moest -
>> JASON HIRSCHHORN: Wacht.
Vertellen ons niet wat je gedaan hebt.
We gaan in de logica te praten.
>> STUDENT 81: OK.
Wat was de vraag?
>> JASON HIRSCHHORN: Je hebt net opgeheven hand.
Er was geen sprake.
Laat me presenteren.
Laat ik alleen dit bespreken kort.
Dus we hebben een pixel, we willen repliceren, zowel horizontaal als
verticaal.
Dus ideaal wat we hier doen is, we gelezen in onze pixel, we schrijven het
echter vele malen.
>> Maar dan hebben we onze truc hier, omdat dan willen we doorgaan naar de
volgende regel en schrijf het op de het begin van de volgende regel.
Dus als we willen beide repliceren horizontaal en verticaal, wat
een goede manier om dat te doen -
men wel goed om dat te doen?
Dus we hoeven niet voortdurend zoeken rond ons bestand om de dingen te plaatsen.
>> Die vraag misschien niet logisch, maar ik denk dat een
antwoord op het zal helpen.
>> STUDENT 82: Maak een array?
>> JASON HIRSCHHORN: Dus laten we denken van elk bestand als een rij.
Laten we denken in termen van rijen.
Als we onze eerste rij van onze kleine beeld kunnen we die rij maken
in een grote rij van een grote foto, en dan repliceren die rij echter
vele malen moet worden herhaald, plaats van te gaan pixel voor pixel,
die verwarrend wanneer krijgt omgaan met bestanden.
>> Want als we hadden -
Ik heb bijna geen ruimte.
Als dit ons bestand, en we hebben dat een pixel daar, en we willen om het te zetten
daar hebben we nog een aantal dingen die moeten daar als we gaan
schrijven en het creëren van onze nieuwe bestand -
ons bestand dat is twee keer zo groot.
>> Maar het is echt moeilijk met bestandsfuncties om rond te slaan om nieuwe lijnen
als dat, en ga dan terug hier en zet dingen in.
Het is bijna onmogelijk om iets te doen als dat, als dat zinvol is.
Dus als we denken in termen van rijen, kunnen we nemen onze rij, en dan zet het -
repliceren rijen verticaal.
>> En dat is hoe we omgaan met resizen verticaal in plaats van horizontaal.
Dat was een beetje snel, en een beetje verwarrend.
Helaas is onze tijd om is.
Ik zal buiten staan ​​voor die van u hier die vragen hebben over het hebben
probleem set, inclusief herstellen.
>> Dus laten we verdagen voor nu.
En nogmaals, als je vragen hebt, we kunnen buiten praten.