[Powered by Google Translate] [Week 2, Vervolg]
[David J. Malan, Harvard University]
[Dit is CS50. - CS50.TV]
Oke. Dit is CS50, en dit is het einde van week 2.
Als u verwacht dat honger rond deze tijd morgen,
weten dat we gaan roepen als een kleine groep morgen, donderdag, 1:15 pm.
Er is deze URL hier als u wilt RSVP.
Ruimte is beperkt, dus vergeef, indien de formulieren opgevuld door de tijd dat je dit invullen.
Een andere URL, echter dat interessant kunnen zijn is dit.
In slechts een maand tijd, is de cursus zal ter beschikking worden gesteld
de ruimer via EDX, via welke hebben op het Internet kunnen volgen zul
deelnemen aan de cursus heel actief, in feite.
Ze zullen gebruik maken van de CS50 Appliance en CS50 Bespreek
en de meeste van de verschillende software tools die we al zijn dit semester gebruikt.
En een van de initiatieven die we graag op te nemen als een experiment dit jaar
is om te zien hoeveel inhoud die we kunnen vertalen
in andere gesproken en geschreven taal.
Dus als je zou er belang bij hebben deel te nemen aan dit project
waarbij we zullen Engels transcripties en ondertiteling voor lezingen van de cursus
en korte broeken en seminars en profielen en dergelijke,
als je spreekt vloeiend of schrijven vloeiend een andere taal,
we u graag deelnemen aan dit project, waarbij je op een of meer van de video's,
vertalen in een taal die je redelijk goed kent.
>> Om u een idee van de interface, er is een web-based user interface
dat we gebruiken die in wezen een UI als deze maken.
Dit werd mij leren wat Halloween geleden,
en de rechter zijde in zwart naast deze tijdstempels
zie je de verschillende dingen die kwam uit mijn mond die dag,
en dan eronder zul je in staat om te vertalen naar een andere taal
wat de mapping tussen, in dit geval Engels en bijvoorbeeld Spaans.
Dus het is eigenlijk een zeer gebruiksvriendelijk hulpmiddel.
U kunt terugspoelen en vooruitspoelen zeer gemakkelijk met behulp van sneltoetsen.
Dus als je wilt deelnemen aan dit experiment en hebben uw woorden gezien en gelezen
door potentieel duizenden mensen die er zijn, ik aarzel dan niet om deel te nemen.
Een woord over het kitten van maandag.
Opdat wij niet hebt een overdreven enge bericht, doen beseffen dat, als kantooruren suggereren
en als secties stellen, het ontwerp van de natuurlijk zeer
aan studenten hebben samen te werken en te praten om te werken door middel van probleem sets
en problemen bij elkaar, en echt de lijn net komt neer op,
nogmaals, moet het werk dat je uiteindelijk in te dienen worden uw eigen.
En dus eerlijk gezegd, in kantooruren is het heel normaal,
Het is totaal nog te verwachten, te chatten met een aantal vrienden naast je.
>> Als hij of zij kampt met een bepaald onderwerp en je net als,
"Oh, nou, laat me je een glimp van enkele lijn van code die ik schreef:" dat is prima,
dat gebeurt, en dat is heel erg bevorderlijk, denk ik, met het proces van leren.
Wanneer de lijn wordt overschreden is wanneer het hoofd is een soort van gekanteld hier voor veel te veel seconden
of minuten voor die echt te zijn geweest op een deblokkering kans voor je vriend,
en zeker wanneer dingen krijgen uitgewisseld via e-mail en Dropbox en dergelijke,
ook daar is de lijn.
Dus met alle middelen zich gerust voelen en zich aangemoedigd voelen om te chatten met vrienden
en klasgenoten over psets en meer en gewoon beseffen dat wat je uiteindelijk in te dienen
moet echt het product van uw creatie en niet iemand anders.
En dus een van de domein-specifieke problemen voor pset2,
die zal komen laat morgenavond, is om te duiken in de wereld van de cryptografie,
dat is de kunst van het versleutelen of scrambling informatie,
en dit gaat uiteindelijk om de wereld van de beveiliging.
Nu, de veiligheid voor de meesten van ons komt in de vorm van vrij alledaagse mechanismen.
Ieder van ons heeft gebruikersnamen en wachtwoorden,
en ieder van ons hebben een zeer slechte gebruikersnamen en wachtwoorden, het meest waarschijnlijk.
>> Als uw wachtwoord is hetzelfde op meerdere websites, dat is waarschijnlijk niet het beste idee,
zoals we zullen bespreken in de richting van het einde semester.
Als uw wachtwoord is geschreven op een notitie - geen grap - op uw monitor,
dat is ook niet per se de beste ontwerp, maar een veel voorkomend fenomeen.
En als je geen gebruik maakt cryptografie om wachtwoorden te versleutelen,
ze zijn bijzonder kwetsbaar.
Dus als je denkt dat je super slim zijn door het hebben van een verborgen Word-document
ergens op uw harde schijf die is al uw wachtwoorden
maar het is in een map die niemand gaat kijken in, dat niet al te is een zeer veilige mechanisme.
En dus wat pset2 introduceert is deze kunst van cryptografie
en klauteren gegevens, zodat zaken als wachtwoorden zijn des te veiliger.
De context is hier dat met onzekere gegevens
komt een mogelijkheid om het te versleutelen en te klauteren het.
En dus bijvoorbeeld, is een voorbeeld van een gecodeerd bericht.
Dit zegt eigenlijk iets in het Engels, maar het is duidelijk niet geheel duidelijk.
En we zullen de cirkel rond vandaag te plagen elkaar wat deze geheime boodschap hier is.
Maar in de echte wereld van computers, de dingen niet eens op dat ze misschien wel Engels zinnen.
Zo, dit is wat je zou kunnen vinden op een standaard Linux of Mac of UNIX-computer
in een bestand dat was eens een tijd genaamd het wachtwoord bestand.
>> Tegenwoordig is al verplaatst naar andere plaatsen.
Maar als je kijkt op de juiste plaats op een systeem, ziet u niet alleen uw gebruikersnaam
of die van andere mensen op het systeem, maar je zult een versleutelde versie van hun wachtwoord te zien.
Inderdaad, het woord crypte is er dat de volgende dingen gecodeerd is,
en deze reeks van schijnbaar willekeurige letters en tekens en cijfers, enzovoort
kunnen worden gedecodeerd alleen door het algemeen kennis van enkele geheime -
een geheim woord, een geheim nummer -
en zo ja, om de kunst van cryptografie uiteindelijk neer vertrouwen van een soort
en weten iets dat iemand anders niet doet.
Dus we zullen het verkennen van deze in een beetje meer detail nu en in de PSET te komen.
En nu een woord over de pass / fail.
Vooral omdat sommige van jullie hebben gedoken in pset1, de Appliance,
en een heel nieuwe wereld voor jezelf, beseffen dat frustraties en verwarring
en op technische problemen zijn zeer te verwachten
vooral met de eerste PSET, waar er net zo veel nieuwe,
gewoon kennis te maken met ls en cd en al deze geheimzinnige commando's
en een nieuwe omgeving, en dat is los van de feitelijke materiaal en het programmeren zelf.
Zo ook beseffen dat er zeker kantooruren die bestaan ​​als een ondersteunende structuur.
>> Secties beginnen komende zondag.
Maar het belangrijkste is, als je je voelt gewoon dat dit niet de wereld voor u,
beseffen dat het echt gewoon niet de tijd te nemen.
En ware het niet voor deze gelegenheid jaren geleden voor mij van het nemen van een klasse pass / fail,
eerlijk gezegd, ik zou nooit hebben zelfs een voet in de klas.
En u kunt dit veranderen tot, laten we zeggen, de vijfde maandag van de cursus,
dus als je aan de rand nu realiseren dat in plaats van het hoofd in een aantal andere wateren in totaal,
er zeker overwegen alleen het veranderen van tot pass / fail.
Nogmaals, er is niet echt deze cultuur hier op Harvard van het nemen van dingen pass / fail
omdat iedereen echt wil bereiken of overtreffen,
maar eerlijk gezegd, dit is een prachtige manier om te proberen iets uit
die misschien niet bekend voor, en je zult uiteindelijk doen, in de meeste gevallen, heel fijn,
misschien wel veel tot uw verbazing.
En in meer concrete termen, wat ik denk pass / fail over het algemeen doet,
vooral omdat je misschien al hebt ervaren met pset0,
als je in 10 uur, 15 uur, 25 uur in sommige PSET
en je bent gewoon bonzen je hoofd tegen de muur en het is al super laat op de avond
maar je hebt genomen de PSET 90% van de weg en je kan het gewoon niet begrijpen een ding,
pass / fail echt neemt de rand af van een klasse als deze,
waar u kunt sorteren van gelukkig zeggen: "Oke, ik weet dat het niet perfect is,
maar ik werkte mijn kont af op dit, ik ben best tevreden met waar het uiteindelijk, "
en dat zal voldoen aan de verwachtingen voor pass / fail.
Dus hou dat in gedachten. Oke.
>> Dus degenen onder u die hebben lang naar de Harvard University Wi-Fi te gebruiken,
weten dat er een CS50 SSID, een Wi-Fi-verbinding, rondzweven
die u zou kunnen hebben meer geluk voor.
Het is een beetje ironisch dat het wachtwoord voor dit, als je zou willen proberen het aansluiten van dit
voor een betere snelheden - en laat ons weten of het niet beter - is 12345, de hele weg tot 8
omdat 8 is veiliger dan 5.
Dus als u de Wi-Fi-wachtwoord, verbinding te maken met CS50 draadloze hier, 12345678,
en post op CS50 Bespreek als u nog intermitterende problemen met de verbinding,
en we laten de bevoegdheden die worden weet voor deze ruimte. Oke.
Dus een snelle teaser, vooral voor degenen onder jullie die fan jongens of meisjes van alle dingen Apple.
Wat ik opgegraven van een paar jaar terug was dit bestand hier, iUnlock.c,
alleen maar om soort van te maken concreter en meer complexe
een aantal van de meer fundamentele C-programma's die we hebben geschreven.
Dus ik opende dit bestand, iUnlock.c. Het is beschikbaar op de pagina Lezingen voor vandaag.
Aan de linkerkant zie je een lange lijst van functies.
Dus de man die dit schreef schreef een hoop functies, meer dan alleen de belangrijkste.
Hij gebruikte een hele hoop van bibliotheken hier, en als we beginnen scrollen door,
wat dit eigenlijk is, is de eerste, geloof ik, crack voor de originele iPhone.
>> Als je wilde de originele iPhone jailbreak, wat betekent untether het van AT & T
en effectief te installeren speciale software op en dingen doen die Apple niet wil dat mensen doen,
iemand nam de tijd om erachter te komen hoe ze konden softwarefouten te exploiteren,
- iUnlock.c-fouten, bugs, in Apple-software, en dus werd geboren
dat als je gecompileerd op uw computer en geïnstalleerd op een iPhone
dat is aangesloten op uw computer via bijvoorbeeld een USB-kabel,
Dit zou u administratieve of root-privileges op je iPhone
en laat je vrij veel wat je wilt.
En dus er is al deze fascinerende kat en muis spel
tussen Apple en de rest van de wereld in het bijzonder als ze, net als veel bedrijven,
proberen om hun spullen te vergrendelen, zodat u kunt alleen doen wat ze van plan.
Maar dankzij mensen zoals deze en het begrip van low-level details -
en in dit geval C programmering - en veel van de bekende constructen
dat we begonnen te spelen met, bent u in staat om echt te maken gebruik van de hardware
op een manier die je past en niet noodzakelijk een aantal corporate entiteit.
Dus bijvoorbeeld, ik heb geen idee wat dit allemaal aan het doen is,
maar GetVersion klinkt vrij eenvoudig,
en het lijkt erop dat dit is een functie dat deze persoon heeft geschreven.
Het duurt een soort van integer als argument, geeft niets,
maar lijkt lus met een for-lus hier en een if-conditie, als voorwaarde breken,
en een of andere manier betrekking heeft op versienummers als we naar beneden scrollen,
hoewel veel van deze zoekwoorden zullen nieuw zijn.
En er is een heleboel functies in hier hebben we nog nooit eerder gezien en misschien niet altijd te zien
in de loop van het semester.
>> Aan het eind van de dag, het volgt dezelfde regels en logica dat we al het spelen met tot nu toe.
Dus dit is veel te oud om je iPhone 3s of 4s of 5s snel deze dagen te kraken,
maar weet dat het is allemaal heel erg afgeleid van deze wereld dat we doken in.
Laten we eens een kijkje nemen op een beetje meer eenvoudig voorbeeld:
deze, alleen maar om krijgen opgewarmd met een aantal syntax en ook een ander gegevenstype
dat we hebben gesproken over maar nog niet echt gezien in C.
Dit is een bestand met de naam positive1.c, en per de opmerkingen aan de top,
Dit vereist slechts dat de gebruiker een positief getal.
Dus het is een voorbeeld van een do-while-lus, dat is leuk voor de gebruiker interactieve programma's
waar je moet de gebruiker vertellen om iets te doen,
en als ze niet meewerken je schreeuwen tegen hen of verwerpen hun inbreng.
Case in point: ik ga doen lijnen 19 tot en met 24
zolang de gebruiker niet heeft gegeven mij een positief getal.
Dit detail hier op lijn 18, waarom heb ik verklaar n boven dit hele looping construeren
in tegenstelling tot direct naast lijn 22 waar ik echt om naar n te krijgen? Ja.
[Student] Scope. >> Ja, dus dit nummer van omvang.
En in termen van de leek, het toepassingsgebied zich wat vindt u?
Ja. >> [Onverstaanbaar student reactie] >> Kun je je een beetje harder?
[Student] Waar kun je die variabele te openen. >> Perfect.
Waar kun je een bepaalde variabele te openen.
En in het algemeen, de vuistregel tot nu toe is dat de omvang van een aantal variabele
wordt bepaald door de meest recente accolades die je hebt gezien.
>> En dus in dit geval, als ik de fout gemaakt te verklaren n op de lijn 22, zou die lijn werken.
Ik zou krijgen een int, en ik zou het gebracht die variabele n in lijn 22,
maar die regel code zou nu heb geen idee waar ik het over heb? >> [Student] 25.
[Malan] 25, en het blijkt dat 24 goed ook, want in dit geval is valt buiten de accolades.
Dus gewoon een beetje vervelend, maar zeer eenvoudig op te lossen door simpelweg te verklaren de variabele
buiten de functie zelf.
We zullen later vandaag zien, kunt u nog een stap verder te gaan
en je kon zelfs een beetje lui.
En dit is niet aan te bevelen in het algemeen, maar je kon zelfs lui
en wereldwijd zet een variabele zogezegd, niet in een functie, niet in een lus,
maar in het bestand zelf, buiten alle functies die je hebt geschreven, zoals ik deed hier op lijn 15.
Dit wordt over het algemeen afgekeurd, maar beseffen dat dit een oplossing is soms tot andere problemen,
zoals we zullen uiteindelijk zien.
Dus voor nu zullen we laten het zo, maar laten we eens kijken of we kunnen herschrijven deze
gewoon om te beginnen uiten onszelf een beetje anders.
Dit programma, alleen maar om duidelijk, is positive1.
Laat me hier ga je gang en in mijn terminal-venster maken positive1, Enter.
Compileert oke. Ik ga positive1 rennen, druk op Enter.
Ik eis dat je me een positief geheel getal. Ik zal -1 zeggen. Dat werkte niet.
0, 99. Dat lijkt te werken.
Misschien niet de meest rigoureuze test, maar in ieder geval is het een leuke sanity check
dat we op de goede weg.
>> Dus nu laat me gaan en open versie 2 van deze,
en wat is er anders al?
Het geeft uitvoering aan het zelfde ding, maar wat springen zo duidelijk deze keer anders?
Dit bool in het groen. Het groen is gemarkeerd, is dit zoekwoord bekend als bool, dat is een gegevenstype.
Het komt niet ingebouwd in alle versies van C.
U moet een specifieke bibliotheek op te nemen.
In ons geval, ik onder meer de CS50 bibliotheek, zodat we toegang tot bool.
Maar in lijn 18, lijken we in een Booleaanse waarde hier genoemd dankbaar zijn.
Ik had noemde dit alles, maar ik noemde het dankbaar
alleen maar om soort over te brengen wat semantische betekenis.
Dus in eerste instantie op lijn 18, ik ben blijkbaar niet dankbaar
omdat de Booleaanse waarde dankbaar wordt geïnitialiseerd op false in de lijn 18.
En dan lijkt het wat ik hier heb gedaan in lijnen 21 tot en met 23
is Ik heb gewoon een soort van herschreven mijn logica.
Dus geen functioneel verschillend, maar in lijn 22 nu ik controleren of de int de gebruiker heeft
groter is dan 0, dan heb ik gewoon de waarde van dankbaar in op true.
En waarom doe ik dat? Omdat in lijn 25, blijkbaar Ik ga een toestand te controleren.
Doe deze lus terwijl dankbaar is vals.
Dus heb ik voorgesteld dit als een alternatief voor de versie 1
want het is op zijn minst een beetje meer intuïtief misschien is het een beetje meer geaard in het Engels.
Dus het volgende doen terwijl u niet dankbaar of tijdens dankbaar is vals.
En ook deze keer ik blijkbaar niet schelen om te onthouden wat de gebruiker heeft ingevoerd in
want aankondiging er is geen variabele n, dus eigenlijk, een leugentje om bestwil is.
>> Functioneel, het programma is een beetje anders als we eenmaal op de bodem van het
want ik ben niet herinneren wat n.
Maar ik wilde hier laten zien ook dat, hoewel we hebben gezien GetInt
en GetString wordt gebruikt op de rechterkant van een gelijkteken dusver
zodat wij de waarde, technisch, dat is niet strikt noodzakelijk te herinneren.
Als u om welke reden dan ook gewoon niet schelen om de waarde op te slaan,
je wil gewoon de waarde te controleren, merken dat we gewoon kunnen dit schrijven als GetInt,
openen haakje, in de buurt haakje.
Deze functie zal een waarde te retourneren, zoals we al zeiden.
Het zal u terug te geven een int.
En dus als je mentaal denken dat dit gebeurt,
als ik typ in 99, GetInt geeft het aantal 99,
en dus conceptueel, het is alsof mijn code eigenlijk waren dit.
Als 99 inderdaad groter is dan 0, dan wordt dankbaar waar
dan lijn 25 realiseert ooh, we zijn klaar, want ik ben nu dankbaar,
en in lijn 26, we gewoon zeggen: "Bedankt voor de positieve integer!"
wat het ook toevallig.
Nu gaan we een lichte syntactische suiker hier, bij wijze van spreken.
Laten we eens kijken of we kunnen opruimen deze lijn 25 met deze derde en laatste variant in positive3.
>> Let op het enige verschil nu is wat regel code? >> [Student] 25. >> [Malan] Ja, 25.
En we hebben niet echt gezien deze truc gewoon nog niet, maar we hebben op het uitroepteken op maandag te zien,
geven, waarin vastligt wat? >> [Student] Niet. >> Niet of ontkenning.
Dus neem een ​​Booleaanse waarde en flip zijn waarde.
True false wordt, valse wordt waar.
Dus dit, ik zou willen voorstellen, is zelfs een beetje meer intuïtieve manier van schrijven van de code
omdat ik nog steeds initialiseren dankbaar valse, heb ik nog het volgende doen,
Ik dankbaar op true wanneer de tijd komt,
maar nu kun je eigenlijk alleen maar vertalen deze code verbaal van links naar rechts,
while (dankbaar!), want bang of uitroepteken duidt het begrip niet,
dus terwijl niet dankbaar.
Dus nogmaals, we hebben geen nieuwe concepten als zodanig.
We spraken over Booleans terug toen speelden we met Scratch,
maar beseffen nu kunnen we gewoon beginnen met het schrijven van onze code op veel verschillende manieren.
Dus vooral in pset1 als je soort van worstelen om erachter te komen de weg naar een programma te schrijven,
kansen zijn heb je geluk, want er kan een willekeurig aantal oplossingen
dat je kan gebeuren op.
Zo, dit is gewoon 3 voor zelfs de eenvoudigste van de programma's. Oke.
En nu terug op maandag vertrokken we op deze notitie met terugkeer waarden.
Dus voor de allereerste keer schreven we een programma dat niet alleen maar de belangrijkste;
Het heeft ook een eigen aangepaste functie die ik hier geschreven heb.
Dus in lijn 31 tot 34 heb ik geïmplementeerd een kubus functie.
Het is niet complex. Het is gewoon een * a * a in dit geval.
Maar wat belangrijk is over het is dat ik inbreng te nemen in de vorm van een
en ik terug output in de vorm van een * a * a.
Dus nu heb ik de mogelijkheid, net als ik om met prinf alleen wordt gebruikt,
Om deze functie te bellen door te bellen naar de kubus functie.
>> En de kubus functie neemt een aantal input, en de kubus functie geeft enkele uitgang.
Daarentegen printf gewoon deed iets.
Het kwam niet terug iets dat we om gaf, ook al als een terzijde het heeft een waarde te retourneren;
je gewoon in het algemeen negeren.
Printf gewoon deed iets. Het had een neveneffect van afdrukken op het scherm.
Daarentegen hier, hebben we de kubus functie, die eigenlijk terug iets.
Dus voor die bekend zijn met dit, het is een vrij eenvoudig idee.
Maar voor de minder vertrouwd zijn met dit idee van het doorgeven in in-en om terug uitgangen,
laten we proberen gewoon iets super eenvoudig.
Is er iemand comfortabele komen op het podium kort?
Je moet comfortabel met een camera op je net zo goed. Ja? Oke.
Wat is je naam? >> [Student] Ken. >> Ken. Oke. Ken, kom naar boven.
Ken zal een functie soort hier.
Laten we verder gaan en dit doen. Laten we een beetje fantasie.
Leuk u te ontmoeten. Welkom bij centraal. Oke.
Laten we hier op die knop. Oke.
Dus hier heb je een moderne schoolbord,
en wat ik ben is de belangrijkste functie, bijvoorbeeld,
en ik heb geen iPad in mijn hand.
>> Ik heb niet echt weet hoe je - Nou, ik kan dat zeggen.
Ik heb niet echt goed handschrift,
en dus daarom wil ik dat je iets op het scherm voor me af te drukken.
Daar ben ik nu het hoofdprogramma, en ik ga om u te hebben zeggen dat dit
door het schrijven van het in mijn kip scratch, waarna u voorbijgaan een ingang.
Zo dom hoewel deze oefening is, het begrip van functies en het aanroepen van een functie
en het retourneren van een functie echt neer op deze.
Ik ben de belangrijkste, ik heb net geschreven printf, quote-unquote iets op het scherm,
Ik gebruik dit programma, en zodra printf wordt aangeroepen,
het duurt een argument of een parameter soms tussen dubbele aanhalingstekens.
Hier is dat argument. Ik ben door te geven aan Ken.
Hij is een zwarte doos schriftelijke bepaald aantal jaren geleden
dat blijkbaar alleen weet hoe u kunt afdrukken wat op het scherm.
Dus voeren.
Dat is niet slecht. Heel goed.
Dus nu Ken gebeurt uitvoeren. Heeft hij nodig om mij iets terug?
Niet dat we tot nu toe gezien.
Nogmaals, printf eigenlijk terug een nummer, maar we gaan die te negeren voor nu
want we hebben het nooit gebruikt. Dus dat is het voor Ken.
En nu de belangrijkste neemt de controle over het programma opnieuw
want dat regel van de code, printf, gebeurt de uitvoering.
En we gaan over onze manier, het uitvoeren van welke andere lijnen zijn er.
Dus nu laten we proberen een iets ander voorbeeld.
Deze keer hier laten we eerst het scherm te verwijderen, en deze keer zullen we het Cubing functie te doen,
maar deze keer verwacht ik een uitgangswaarde.
>> Dus laten we verder gaan en dit doen.
Nu heb ik een regel code die zegt x krijgt kubus van x.
De regel van de code, recall, ziet er als volgt uit: x = cube (x);
Dus hoe gaat dit werken? Laten we verder gaan en geven je een wit scherm weer.
Ik ga nu schrijven de waarde van x,
die op dit moment in de tijd gebeurt te zijn, laten we zeggen, 2 het simpel te houden.
Ik heb geschreven op een stuk papier de waarde van 2, dat is mijn waarde x.
Ik geef het aan Ken. >> En ik schrijf het antwoord? >> Ja, laten we gewoon het antwoord te schrijven.
Oke. En nu heeft hij om terug te keren me iets. Perfect. Leuk segue.
Dus nu geeft hij me terug de waarde van 8 in dit geval, en wat moet ik ermee doen?
Eigenlijk - laten we eens kijken, dit goed. Wat moet ik doen?
Nu ga ik om deze waarde te nemen en eigenlijk is het op te slaan in diezelfde bits in het geheugen.
Maar let op ik ben een beetje worstelen hier.
Ik ben een beetje in de war, want waar moet ik eigenlijk schrijf de waarde van x,
want wat ik net heb gedaan is fysiek de hand Ken een stuk papier dat de waarde 2 heeft,
en dat was x, en inderdaad, dat is precies wat er gebeurde.
Zo blijkt dat wanneer je de functie aan te roepen en u passeert in een discussie
zoals hello, world of u doorgeeft in een argument als 2,
het algemeen, je passeren in een kopie van dit argument.
En dus net zoals ik schreef het nummer 2 hier en gaf het aan Ken,
dat moet betekenen dat ik nog steeds een kopie van de waarde 2 ergens
want inderdaad, nu ik heb gekregen terug de waarde 8, moet ik om terug te gaan in het RAM
en eigenlijk schrijf een daling van 8 waar ik ooit had de nummer 2.
Dus visueel, onthoud dit begrip passeren in, letterlijk, een kopie van de waarde.
>> Ken doet zijn ding, me terug overhandigt iets - in dit geval een waarde als 8 -
en dan moet ik iets doen met die waarde als ik wil om het te houden rond.
Dus dit alles zal terugkeren naar zijn maar al te bekend voor lang.
Dank je wel voor deze demo hier, Ken. [Applaus]
Heel goed gedaan.
Laten we eens kijken hoe dat uiteindelijk betrekking heeft op een deel van de functie te bellen dat we hier gedaan.
Laat me ga je gang en breng ons terug naar de Cubing voorbeeld hier.
Merk op dat als we willen om daadwerkelijk beginnen met het innemen van dit verder,
we zullen moeten houden met het feit dat het aantal x dat wordt doorgegeven in hier
is anders dan wat er daadwerkelijk wordt doorgegeven aan de functie.
Dus nogmaals, wordt deze pas door kopie gaat nogal germane worden in slechts een moment.
Laten we eens een kijkje nemen op iets dat niet helemaal werkt juist nog niet.
Ik ga om verder te gaan en een derde buggy voorbeeld, dat wordt ontsierd door de natuur te openen,
en het heet buggy3 en implementeert een swap-functie.
Hier hebben we een hoofdfunctie die willekeurig x en y geïnitialiseerd op 1 en 2 respectievelijk.
We konden gebruik maken GetInt, maar we hoeven alleen maar een eenvoudige oefening,
dus het is hard-coded als 1 en 2.
In leidingen 21 en 22, we blijkbaar printen x en y, 1 per regel.
Dan op lijn 23, ik beweer ik deze waarden swapping, puntje, puntje, puntje.
Ik blijkbaar roep een functie in regel 24 zogenaamde swap dat 2 argumenten heeft.
Het is helemaal legit voor functies tot en met 2 argumenten te nemen. We hebben gezien printf al doen.
>> Dus swap neemt blijkbaar x en y, en zoals de naam al doet vermoeden,
Ik hoop dat het gaat om deze 2 waarden te wisselen.
Dus dan moet ik zeggen on line 25 "verwisseld!" en ik herdruk x-en y-
in de veronderstelling dat ze inderdaad al verwisseld.
Maar als ik echt dit programma uitvoert - laat me open een terminal venster,
laat me buggy3 - zoals de naam al doet vermoeden, is dit niet van plan om goed af
want als ik op Enter, merken dat x is 1 hit, y 2,
en toch aan het einde van het programma zij nog in feite hetzelfde.
Dus gebaseerd op het aantonen juist nu met Ken, wat er werkelijk aan de hand is?
Laten we een duik nemen in deze swap functie. Het is super kort. Het is slechts een paar regels code lang.
Maar wat is het fundamentele probleem op basis van de eenvoudige verhaal hier met Ken?
Waarom wordt swap gebroken?
[Student] Je opslaan van een kopie, niet de variabele.
Precies. We slaan een kopie, niet de variabele zelf.
Met andere woorden, swap duurt blijkbaar 2 argumenten, een int,
en het is willekeurig A en B genoemd,
en hier heb aangenomen in x en y, die respectievelijk 1 en 2,
maar ik ben niet letterlijk passeren in x, ik ben niet letterlijk passeren in y,
Ik ben het passeren van een kopie van x en een kopie van y.
Het is bijna alsof je gekopieerd en geplakt in swap
de waarden die u wilt eigenlijk te manipuleren.
Dus als dat het geval is, als ik het programma start lijn uitvoeren van 35 dan 36,
als ik naar lijn 37, op dit punt in het verhaal, wat is de waarde van een?
Op dit punt in het verhaal, lijn 37, wat is de waarde van een op dit punt? >> [Student] 1.
[Malan] Het moet gewoon 1, rechts, want x is doorgegeven als het eerste argument,
en deze functie gewoon willekeurig roept haar eerste argument een.
Ook is y het tweede argument, en het is gewoon willekeurig te bellen naar het tweede argument b.
>> Deze tweedeling is eigenlijk vrij eenvoudig uitgelegd. Denk er eens over.
Niemand van ons heeft voldaan aan de persoon die schreef printf,
zo zeker, hij of zij heeft geen idee wat onze variabelen 30 jaar later zullen worden genoemd.
Dus er moet een onderscheid te maken tussen wat je noemt variabelen in functies die u aan het schrijven bent
en wat je noemt variabelen in functies die u belt of met behulp van.
Met andere woorden, heb ik zelf mijn variabelen x en y,
maar als iemand anders had geschreven de swap-functie, hij of zij zou zeker niet weten
wat mijn variabelen zullen worden genoemd,
zodat beseffen dat dit is de reden waarom u deze dualiteit van namen.
Technisch gezien kan ik dit doen door toeval,
maar ze zouden nog steeds worden doorgegeven als kopieën.
Het zou gewoon puur toeval esthetisch als die persoon die schreef swap
had gebruikt dezelfde namen.
Dus op dit punt in het verhaal, lijn 37, a 1, b 2, en nu ik ga om ze te verwisselen.
Allereerst wil ik eigenlijk dit te doen veel eenvoudiger.
Ik weet niet wat die 3 regels code aan het doen waren.
Laat me dit doen: b = a; a = b; gedaan.
Waarom is deze gebroken, logisch?
Het is een soort van de intuïtieve, toch?
Dus A wordt B en B wordt een,
maar het probleem is dat zodra leiding 37 wordt uitgevoerd, wat de waarde van a en b?
Hetzelfde, 1, omdat je pan gehakt, om zo te zeggen, je bent veranderd b om een ​​gelijk.
Dus zodra lijn 37 is uitgevoerd, dat is geweldig, je hebt nu 2 exemplaren van het nummer 1
binnenkant van deze functie, dus dan wanneer je zegt in de lijn 38 a = b,
je bent soort van genaaid, want je bent gewoon het toewijzen van 1 tot 1.
Je hebt soort van verloren de waarde die u gaf.
Dus in de originele versie van dit, let op wat ik deed.
Ik plaats had een derde lijn van de code die er zo uitzag.
Ik verklaar een tijdelijke variabele.
>> Tmp is een veel voorkomende naam voor een tijdelijke variabele, en het is een int
omdat het moet overeenkomen met wat ik wil een kopie van te maken.
Ik bewaar een kopie van een binnenkant van tmp, dus zodra lijn 37 heeft uitgevoerd,
de waarde van a - snel sanity check - 1, de waarde van b is 2,
en de waarde van tmp is 1.
Dus nu heb ik uitvoeren lijn 38.
Zodra lijn 38 voert een neemt de waarde van b. En b is 2, zodat een nu 2.
Dus op dit punt in het verhaal, a 2, b is 2 en tmp 1 is,
dus nu logisch, we kunnen gewoon plop tmp de waarde in b en we zijn klaar.
Dus hebben we dat probleem opgelost.
Helaas, toen ik dit programma uit te voeren in deze vorm, is het niet echt ruilen geen waarden.
Maar om duidelijk te zijn, waarom?
Ik maakte het logische probleem van zojuist,
maar nogmaals, als ik zonder dit programma, x en y blijven ongewijzigd
het eind van de uitvoering van het programma.
[Onverstaanbaar student commentaar] >> We hebben niet terug niets, dus dat is waar.
Maar het blijkt dat er een beetje een probleem hier omdat tot nu toe,
het enige wat we in staat geweest om terug te keren is een ding, en dat is een beperking van C.
Je kunt pas echt een waarde teruggeven, in welk geval ik ben een beetje hier vast
want ik kon de nieuwe waarde van x terug of ik kon de terugkeer van de nieuwe waarde van y,
maar ik wil beide terug.
Dus terug is niet de eenvoudige oplossing.
Maar het probleem is fundamenteel waarom? Wat hebben we eigenlijk verwisseld?
[Student] a en b. >> A en b.
Maar a en b zijn kopieën van x en y, wat betekent dat we gewoon al dit werk deed,
we net 3 minuten praten over de swap functie en alle 3 van deze variabelen,
en dat is geweldig, perfect juist op zichzelf,
maar a en b de reikwijdte alleen in deze lijnen hier.
>> Dus net als een for-lus, als u Ik verklaar een geheel getal in de for-lus,
op dezelfde wijze, als je verklaren a en b in een functie die u hebt geschreven,
ze zijn alleen geldig binnen van die functie, wat betekent dat zodra swap wordt gedaan het uitvoeren van
en we gaan van lijn 24 naar lijn 25, hebben x en y niet veranderd.
Je hoeft alleen verspilde heel veel tijd wisselen kopieën van variabelen.
Zo blijkt dat de oplossing voor dit eigenlijk niet duidelijk.
Het is niet helemaal voldoende om de waarden terug te keren, want we kunnen alleen terugkeren 1 waarde,
en ik wil zowel de x-en y-swap op hetzelfde moment,
dus we gaan hebben om terug te komen naar dit.
Maar nu beseffen dat het probleem fundamenteel afgeleid uit het feit dat a en b exemplaren
en ze zijn in hun eigen toepassingsgebied.
Laten we proberen dit op te lossen op een bepaalde manier.
Laat me eigenlijk scrollen hier terug en open te stellen, laten we zeggen, een vierde variant van deze, buggy4.
Hoe zit dit?
Dit is een soortgelijke, maar eenvoudiger probleem om naar te kijken voordat we een poging te nemen op het oplossen ervan.
Dit programma heet increment, en blijkbaar initialiseert een x geheel getal van 1 in lijn 18.
Vervolgens heb ik beweren x 1 is, ik dan beweren "Verhogen van ..."
Ik roep increment, maar dan in lijnen 22 en 23, ik beweer het is al opgehoogd,
Ik eis x is nu wat het ook is - 2 vermoedelijk, - maar dit programma is buggy.
Wat is het probleem?
Ja. >> [Onverstaanbaar student reactie] >> Precies.
Dus x is verklaard, uiteraard, op lijn 18.
Dat is binnen accolades belangrijkste is.
Dus het simpele antwoord is dat, terwijl x hier bestaat,
het bestaat niet in de lijn 32, zodat dit programma eigenlijk niet eens samen te stellen.
De compiler wanneer ik probeer deze code compileren gaat schreeuwen
over enkele zwart-id of iets van die strekking. In feite, laten we het proberen.
Dit is te buggy4. Daar is het.
Gebruik van 'x' aangegeven identifier in de lijn 32.
En eigenlijk, dus laten we hier meer expliciete vandaag aan dat dit nuttig is
in kantooruren en thuis.
>> Merk op dat het een beetje cryptisch geschreven.
Maar het feit dat Clang heeft schreeuwde naar ons, zeggende buggy4.c: 32:5, is eigenlijk nuttig.
Dit betekent dat de fout op lijn 32 op tekenpositie 5.
Dus 1, 2, 3, 4, 5. Dat is, in feite, waar het probleem.
En ook, ook, in gedachten te houden tijdens kantooruren en thuis, ik ben gelukkig hier.
Ik heb een fout gemaakt. Het gaat om relatief eenvoudig op te lossen.
Maar als je een heel scherm vol met overweldigende foutmeldingen,
nogmaals beseffen dat de onderste een net zou kunnen zijn symptomatisch voor de bovenste een.
Dus altijd achtervolgen je bugs van boven naar beneden
omdat er misschien wel een daisy chain effect
dat suggereert u veel meer problemen dan je eigenlijk doen.
Dus hoe kunnen we dit oplossen als mijn doel is om te hogen x? >> [Student] Zorg x mondiaal.
Oke, dus we kunnen maken x mondiaal.
Laten we de snelkoppeling die ik gewaarschuwd over vroeger, maar ach, we hoeven alleen maar een snelle oplossing,
dus laten we gewoon zeggen int x hier. Dat maakt x mondiaal.
Dus nu de belangrijkste toegang tot het en increment heeft toegang tot het,
en dus laat me ga je gang en nu slaat deze.
Maak buggy4, Enter. Lijkt nu te compileren.
Laten we lopen buggy4. En het lijkt om daadwerkelijk te werken.
Dit is een van die dingen dat is doen wat ik zeg, niet wat ik doe,
zoals ik net heb hier gedaan, omdat in het algemeen,
onze programma's gaat krijgen veel interessanter en veel langer dan dit,
en als uw oplossing voor de problemen van het leven is gewoon alle variabelen zetten op de top van uw dossier,
heel snel doen programma's te krijgen verschrikkelijk moeilijk te beheren.
Het wordt nog lastiger te bedenken nieuwe variabele namen,
het wordt nog lastiger om te begrijpen wat de variabele doet wat,
en dat in het algemeen is dit geen goede oplossing.
Dus laten we dit doen beter.
We willen niet een globale variabele gebruiken hier.
>> Ik wil wel x verhogen, dus ik kon natuurlijk -
aan het eind van de dag, dit is een soort van een dwaze verhaal, omdat we dit gewoon doen -
maar als ik nog niet wist over de exploitant, of ik was niet toegestaan ​​om het te veranderen in de belangrijkste zelf,
Hoe kon ik anders implementeren Ken hier nu niet om kubus, maar op te hogen?
Hoe kan ik hier veranderen dit ding? Ja.
[Student] Pass in x en dan terug [onverstaanbaar] >> Oke, goed.
Dus waarom niet ik pas in x en vervolgens in plaats van terug,
waarom ik niet gewoon terug x + 1.
Een paar dingen moet hier veranderen. Ik ben op de goede weg.
Wat heb ik nodig om te tweaken? Iemand anders. Ja.
[Onverstaanbaar student reactie]
Ik moet de return type van de groei te veranderen omdat het niet ongeldig maken.
Leegte betekent niets wordt geretourneerd, maar het is duidelijk nu is,
dus dit moet veranderen - >> [student] int.
int overeenstemming te zijn met alles wat ik ben eigenlijk terug.
Nu iets anders is nog steeds buggy hier. Ja.
[Onverstaanbaar student antwoord] >> [Malan] Dus ik moet x verhogen?
[Onverstaanbaar student antwoord] >> [Malan] Ah, dus ik moet x passeren.
Dus ik moet hier doen. >> [Onverstaanbaar student commentaar]
[Malan] Dus het prototype, ik moet dit veranderen hier.
Dit heeft dus te worden een int, deze is geworden tot -
hmm, ik heb eigenlijk een bug hier beneden. Laten we eerst bevestig deze.
Wat moet dit eigenlijk? Het moet een int iets.
Het zou kunnen zijn x, maar eerlijk gezegd, als je begint te bellen al je variabelen x,
het gaat steeds minder duidelijk wat wat is.
>> Dus laten we gewoon willekeurig een andere naamgevingsconventie voor mijn helper functies te kiezen,
functies die ik aan het schrijven ben. We noemen het een, of we kunnen noemen -
Laten we het nummer nog explicieter.
Dus dan moet ik om terug te keren, ongeacht het aantal is plus 1,
en nu moet ik een andere ding veranderen hier en een ander ding hier.
Wat moet ik eerst wijzigen op lijn 21? >> [Onverstaanbaar student reactie]
[Malan] Ik heb deze wordt toegekend aan x. Ik kan niet zomaar bellen increment (x).
Ik moet het antwoord onthouden door het veranderen van de waarde van x op de linkerkant.
En hoewel x nu op de links en rechts, dat is helemaal goed
omdat de rechterkant wordt eerst uitgevoerd krijgt dan plofte in de linker ding -
x in dit geval.
En dan tot slot, is dit een makkelijke oplossing nu.
Dit moet gewoon overeenkomen met wat er onder zitten, int number.
Dus een hele hoop veranderingen voor een hele domme functie
maar vertegenwoordiger van de dingen die we in toenemende mate zullen willen doen.
Dus zorg buggy4. Ik heb het verknald ergens.
Oh, mijn God. Vijf fouten in een 6-line programma.
Dus wat is er mis op lijn 18, character 5?
Dus ik moet dit, int te declareren.
Laten we eens kijken. Er zijn een hele hoop andere fouten.
Oh, mijn God - 19, 18, 21 - maar nogmaals, laten we gewoon het scherm te verwijderen, hier Control L,
en herstart Clang.
Dus 5 problemen is eigenlijk alleen maar dat 1.
Dus laten we nu lopen buggy4, Enter. Oef, is x correct opgehoogd.
Oke. Hebt u vragen over de manier waarop getallen verhogen? Ja.
[Onverstaanbaar student vraag] >> Goede vraag.
Hoe komt het dat ik kan x veranderen in aantal en het programma zal onmiddellijk weten?
>> Nogmaals, denk aan het als deze abstractie.
Dus als ik de belangrijkste en Ken is increment, eerlijk gezegd, kan me niet schelen wat Ken noemt zijn iPad.
Kan me niet schelen wat hij noemt alles wat te maken heeft met zijn uitvoering van deze functionaliteit.
Dit is een implementatie detail dat ik, de belangrijkste, geen zorgen te maken over.
En dus simpelweg het veranderen van het consequent binnenkant van de functie - nummer hier en nummer hier -
is alles wat nodig zolang ik opnieuw te compileren.
Het is een soort van leuk als je erover nadenkt velen van ons, die van u met rijbewijzen
die hebben of gereden als je hebt zelfs gereden in een auto,
de meesten van ons hebben geen idee hoe een auto werkt onder de kap.
En letterlijk, bij het openen van de motorkap, de meesten van ons - waaronder ikzelf -
zijn niet van plan om echt te weten waar we naar op,
een beetje zoals je nu misschien voelen met dingen zoals dit recht.
Maar we hoeven niet echt schelen hoe de auto werkt,
we hoeven niet te schelen wat alle stangen en zuigers en kabels in de auto
eigenlijk doen.
Dus iets als wat je noemt de zuiger maakt hier niet uit in dit geval. Hetzelfde idee.
Ja. >> [Onverstaanbaar student vraag]
Als er meer toepassingen van de variabele xa zojuist
u, de programmeur, zou moeten overal veranderen.
Of je zou kunnen letterlijk doen Bestand, Menu en vervolgens zoeken, Vervangen - zoiets -
maar je gaat te hebben om die wijzigingen zelf.
Je moet consequent zijn. >> [Student] Als er meerdere variabelen [onverstaanbaar]
Een bepaalde volgorde zoals hier, als dit was int een ander nummer? >> [Student] Correct.
[Malan] Ja. Bestel belangrijk wanneer u belt de functie.
>> Dus als ik riepen Toename hier met iets komma iets,
er is een directe mapping.
De eerste variabele, wat het ook heet, is gemaakt van een kopie van het eerste argument hier.
Sorry. Dit moet niet een haakje.
Het tweede argument een lijn staat met de tweede. Dus orde, ja, zaken. Oke.
Sorry. Ik nam de lange weg om er te komen. Andere vragen? Oke.
Dus laten we kijken of we niet een beeld schetsen van wat er werkelijk gaande is hier
onder de kap, om zo te zeggen.
Dit is een rechthoek die geheugen van uw computer zouden kunnen betekenen.
Zelfs als je geen idee hebt hoe het geheugen werkt of hoe RAM werkt,
op zijn minst aannemen dat je trossen van het hebben van deze dagen.
Je hebt megabytes kreeg het, je hebt gigabytes aan het,
en we weten uit week 0, dat een byte is precies wat? >> [Student] 8 bits.
8 bits, toch? Dus 8 nullen en 1.
Dus als uw computer is voorzien van een gig RAM, 2 optredens van RAM-geheugen van deze dag,
je hebt een miljard of 2 miljard bytes van het geheugen of ongeveer 8 miljard of 16 miljard bits
binnenkant van uw computer.
In tegenstelling tot de kleine Wooly Willy voorbeeld, het is niet magnetische deeltjes meestal meer.
In toenemende mate - in laptops althans - het is solid state drives, SSD's,
die net hebben geen bewegende delen. Het is allemaal elektronisch. Het is alle elektriciteit op basis van.
Dus denk aan deze rechthoek als gewoon die het 1 of 2 gigabyte aan geheugen die je hebt.
>> Dus het is een stuk van het geheugen.
De wereld van de informatica is soort van afgescheiden
delen van het geheugen om verschillende dingen te doen.
Bijvoorbeeld, als dit computer RAM, zoals voorgesteld door de rechthoek is,
blijkt dat volgens afspraak, dus aan de bovenkant van uw RAM-geheugen, spreken,
is over het algemeen wat heet een tekstsegment.
Dat zijn de 0s en 1s die u hebt gecompileerd.
Dus toen hebben we gekeken onder de kap naar wat a.out is,
al deze 0s en 1s, wanneer u een programma uit te voeren,
die 0s en 1s worden geladen van uw harde schijf in een zogenaamde RAM-geheugen,
en in het RAM-geheugen dat ze brengen aan de top.
Ondertussen heb je andere dingen: initialiseren gegevens, ongedaan te gegevens.
Deze 2 zwaden van het geheugen verwijzen naar globale variabelen, die u niet vaak gebruikt
maar soms als je dat doet, belanden ze daar ook.
Dan is er nog een aantal andere dingen: omgevingsvariabelen, die we niet veel tijd te besteden aan,
maar toen 2 belangrijke dingen die terugkomt in de hele semester,
stack en heap.
Dus het grootste deel van het geheugen van uw computer is gereserveerd bij het uitvoeren van een programma
voor iets genaamd de stapel en iets genaamd de heap.
We gaan niet om te praten over de hoop vandaag, maar we zullen praten over de stapel.
De stapel is bedoeld om roepen de visuele van de eetzaal maaltijd trays in Mather Huis
of waar u zich ook bevindt, waar de eetzaal personeel schoonmaken elke dag,
ze stapelen ze van de vloer op maximaal,
en evenzo in het geheugen, is er dit idee om iets op een stapel,
om iets op een stapel, om iets op een stapel.
En wat bedoelen we hiermee?
>> Laten we inzoomen op alleen de onderste helft van deze foto, van uw computer RAM-geheugen,
de volgende voorstellen.
Het blijkt dat wanneer je een programma zoals a.out of hallo te voeren -
ongeacht het programma is dat je hebt geschreven -
weer, die 0s en 1s worden geladen vanaf de harde schijf, dat is langdurige opslag,
blijft daar zelfs wanneer u aan de stekker trekken, geladen in het RAM.
RAM-geheugen is sneller dan harde schijven - het is kleiner dan harde schijven -
maar het is waar programma's leven, terwijl je draait ze.
Dus je dubbel van een programma op een Mac of pc op, het is geladen vanaf de harde schijf in het RAM.
Zodra het is geladen in het RAM, de 0s en 1s gaan op de weg boven,
de zogenaamde tekstsegment, maar dan zodra uw programma daadwerkelijk begint te lopen,
de belangrijkste functie wordt aangeroepen, en de belangrijkste, zoals we hebben gezien, heeft vaak lokale variabelen,
en het heeft ints en strijkers en tekens en dergelijke.
Dus als je het programma dat je hebt geschreven of het programma dat u dubbel hebt geklikt
gebruikte een aantal variabelen in de belangrijkste,
ze uiteindelijk op de bodem van je stack van het geheugen, om zo te zeggen.
Meer concreet, dat wil wat eigenlijk?
Dit betekent gewoon dat als we zouden gaan om het aantal bytes van RAM-geheugen in uw computer,
merken dat dit zou byte nummer 0 zijn, kan dit byte nummer 1, 2, 3, 4, 5, 6,
helemaal tot 2 miljard zou helemaal tot daar aan de top te zijn.
Met andere woorden, als het over RAM of geheugen in termen van bytes,
het betekent alleen dat iemand heeft besloten wat voor elk van deze delen van het geheugen tellen.
Dus als u 32-bits voor een int nodig of je moet 8 bits voor een char,
waar komen ze terecht in het geheugen?
>> Conceptueel, maar ze belanden op de bodem van dit ding heet de stapel.
Maar wat interessant is nu bij de belangrijkste oproepen van een functie -
Stel dat een functie genaamd foo, gewoon een willekeurige naam -
wat gebeurt belangrijkste is onderaan deze stapel geheugen;
foo nu wordt gelegd op de top van de belangrijkste in het geheugen.
Dus elke lokale variabelen die foo heeft uiteindelijk soort van conceptueel boven die in de belangrijkste.
Als foo roept een andere functie genaamd bar, die variabelen hier terecht.
Als bar noemt iets anders, hier, hier, hier.
Dus wat interessant is aan het uitvoeren van een programma is dat als je functies aanroepen
en als die functies aan te roepen functies en als die functies aan te roepen functies,
bouw je deze stapel van functies in het geheugen.
En slechts een keer per functie terugkeert begin je krijgt dat het geheugen terug.
Dus een van de makkelijkste manieren om opraken van geheugen in een computer programma
is het schrijven van functies die nooit meer terug.
Dus bijvoorbeeld, laten we zo veel aan te tonen met een opzettelijk buggy programma.
Laat me ga je gang en doen # include ,
int main (void),
en ik ga doen, terwijl (2> 1), die waarschijnlijk nooit zal veranderen op ons,
en laat me nu ga je gang en doe printf.
Eigenlijk, dat gaat minder visueel interessant. Laten we dit doen.
Voor int i = 0; i> 0 - laten we deze fout - i + +.
En laten we niet printf hier. Laten we doen wat ik predikte.
Laten we een methode hier, nietig koor, en we zullen int i say,
en dan ga ik naar printf zeggen - nee, laten we dit nog interessanter.
Laten we eigenlijk niets afgedrukt. Laten we dit doen: chorus (i).
Oke. Dus dit is buggy want waarom?
Ik verzin dit niet als ik ga, omdat het programma niet echt iets van belang.
>> Maar dat is niet het doel.
Het doel is het schrijven van een programma met als belangrijkste functie doet wat, blijkbaar?
Bel zelf. En eigenlijk hebben we niet nodig hebben de lus.
Laten we zelfs vereenvoudigen dit net zo als niet uit het oog werkelijk de fundamentele fout te verliezen.
Belangrijkste oproepen koor een aantal koor te zingen,
toen deed ik iets stoms en ik had refrein oproep koor
want ik nam aan iemand anders zou gaan misschien implementeren,
en nu deze is niet van plan om nog samen te stellen. Ik moet wat doen?
Ik moet het prototype, herinneren.
Dus ik moet hier zijn de lege chorus (int i);
Dus nu als ik ga hier beneden - in feite, laten we gebruik maken van de groter venster.
Laten we verder gaan en maken refrein.
Gebruik van niet-aangegeven identifier i.
Oh, dat was stom. We hebben geen behoefte het argument. Laten we dit doen.
Ik wou dat we op deze manier begonnen. Het zou veel gemakkelijker programma te schrijven.
Er. Laten we nu over te gaan naar mijn terminal venster, voert u Clang, en daar gaan we.
Dat was echt snel.
Wat er feitelijk gebeurde, hoewel?
Nou, nu zal ik voeg de afdruk lijn zodat we kunnen zien.
Laat ik zeggen printf ("Ik ben hier") - geen variabelen. We laten het zo.
Laat me herhaling te maken. Laat me herhaling refrein.
En ... kom op. Ga door.
Even terzijde, heeft waarom het niet neergestort nog?
De segmentatie fout gebeurd super snel voor.
[Onverstaanbaar student reactie] >> Precies. Dus het kost tijd om af te drukken, toch?
Het duurt slechts meer werk van de kant van de computer.
En daar is het: Segmentation fault.
>> Dus zien hoe snel programma's te draaien.
Als u niet aan het afdrukken iets, super snel.
Maar we hebben nog steeds deze segmentation fault omdat wat er gebeurde?
Als u denkt over de manier waarop geheugen van uw computer is aangelegd,
dit gebeurt te zijn de belangrijkste, maar hier laten we dit koor roepen, en laten we dit koor.
En als ik nu doe mijn esthetiek recht, wordt deze gewoon naar chorus, chorus, chorus zeggen,
chorus, chorus, chorus, chorus, tot vervelens toe, en uiteindelijk, wat er gaat gebeuren?
Als het grote geheel, letterlijk, is dit, wat gebeurt er gewoon conceptueel?
De stapel overschrijdingen van de heap.
Of, erger nog, je gewoon overspoeld alles, met inbegrip van de tekst segment,
dat is de 0s en 1s dat uw programma vertegenwoordigen.
Kortom, dit is gewoon super, super slecht.
Uw programma is onbeheersbaar.
Je gebruikt veel meer geheugen dan je van plan
allemaal door een domme fout in dit geval,
of in dit geval een heel bewust gedaan functie die zichzelf.
Nu, dit is niet allemaal slecht.
Functies die zichzelf heeft eigenlijk veel macht bij het gebruik van het goed.
Ik heb niet gebruikt het goed hier.
Dus dit is niet allemaal slecht, maar het feit dat ik eigenlijk nooit stoppen met bellen me
is een zwak punt hier van dit programma.
Dus waar gaan we heen met dit alles? Wat is er echt aan de hand?
Toen ik de stap functie aan te roepen dat we aan het doen waren in die voorbeelden,
Ik heb een waarde als 1 die ik pas binnen
Ik passeer in een kopie van het nummer 1, dus gebeurt het volgende.
Laten we naar de toename voorbeeld, deze man rechts over hier.
Hier is wat er daadwerkelijk gebeurt.
Toen ik increment bellen en ik passeer in x, picturaal, wat is hier aan de hand is dit.
>> Als ik de waarde van 1 hier opgeslagen en ik daadwerkelijk op te roepen increment,
die nu wordt genoemd koor - de iPad is het gooien van me af hier.
Laten we deze toename, en we weten niet wat deze volgende functie gaat worden.
Dus wat er eigenlijk gebeurt, is hier ergens in de belangrijkste heb ik een stuk van het geheugen
dat opslaan van het nummer 1.
Toen ik increment bellen, ik gebruik een andere stuk van het geheugen,
maar nu heb ik de kopie van 1.
Toen ik verhoog deze waarde, wordt dit 2,
maar wat gebeurt er dan zo spoedig Toename rendement?
Dit geheugen gewoon wordt teruggegeven aan het besturingssysteem,
wat betekent dat alles wat je hebt gedaan is niets nuttigs.
De 1 die oorspronkelijk was opgenomen in de belangrijkste is nog steeds daar feitelijk.
Waar gaan we heen?
Het blijkt dat in dit geheugen back-to-back reeks bytes
die je kunt zetten spullen in, en het blijkt dat we al iets gezien
dat inhoudt dat dingen rug aan rug aan rug aan rug.
Wat is een string op basis van week 1 en week 2 nu?
Het is gewoon een verzameling van tekens.
Zo blijkt, net zoals u kunt nummers zetten in het geheugen,
evenzo kan je er tekens in het geheugen.
En als we eenmaal beginnen met het opzetten tekens in het geheugen rug aan rug aan rug aan rug,
blijkt dat met de eenvoudige dingen zoals een for-lus of een while-lus,
we kunnen herhalen van links naar rechts over de karakters in een string
en beginnen masseren ze in verschillende karakters in totaal -
a zou kunnen worden b, kan b worden c -
zodat uiteindelijk, kunnen we een Engels zin die daadwerkelijk zinvol
en omzetten elk van deze letters een voor een
door een wandeling door het geheugen van onze computer links naar rechts om daadwerkelijk te versleutelen.
Dus laten we hier nemen onze vijf minuten pauze,
en als we terug komen, zullen we beginnen met dit proces van scrambling informatie.
>> Oke.
Voordat we een duik in een aantal crypto en deze dingen genoemd arrays,
laat me pauze voor eventuele vragen, omdat ik het gevoel dat ik echt een soort van verwarde
een aantal van deze onderwerpen. Dus laten we nu oplossen als we kunnen.
We hebben net gesproken over terugkeer waarden, hebben we gesproken over argumenten,
en we hadden het over dit idee, dat we komen terug in de komende weken,
van het bekijken van het geheugen als een hele hoop van deze gestapelde trays, om zo te zeggen,
van beneden naar boven, zodat elke lade wordt op de stack
representeert een functie die momenteel wordt gebeld.
Nog vragen?
Laat me een vraag stellen hier.
Laat ik dit terug te vereenvoudigen naar wat het was voor een aantal van onze eerdere Q & A.
Het feit dat increment open haakje, int nummer heeft, gesloten tussen haakjes -
wat doet int number vertegenwoordigen?
[Student] Een argument. >> Een argument. Oke. Maar wat is een argument?
[Onverstaanbaar student reactie] >> Wat is dat? >> [Student] Iets dat je langs inch
Oke, dus iets dat je langs inch En meer in het algemeen, het is gewoon de ingang.
Als u het schrijven van een functie en die functie doel in het leven
is om iets te doen een beetje anders elke keer dat je het gebruikt,
dan is de enige manier om dat te laten echt gebeuren lijkt te zijn om het te voorzien van input
zodat het iets anders met die ingang telkens.
>> Dus je moet twee dingen te geven wanneer een functie neemt ingang.
U moet de naam die u wilt geven op die ingang te geven
puur voor je eigen gemak, zodat u kunt verwijzen naar het
in de functie die je zelf schrijft, als ik hier in de lijn 32.
Maar je moet ook aan het type te specificeren omdat C is een programmeertaal
dat vereist alleen dat als je een variabele, moet u de computer vertellen wat data type het is,
grotendeels zodat het weet hoeveel bits toewijzen aan die variabele
want het kan 6 - me, zal het niet 6.
Het kan 16 het kan 8, kan het 32 ​​zelfs 64,
maar de computer moet weten.
Nu de int aan de linkerkant staat voor wat daarentegen?
[Onverstaanbaar student reactie] >> Wat is dat? >> [Student] Soort functie.
Het type van een functie en meer bepaald het type van de output. Juist.
Dus terwijl het ding tussen haakjes staat voor de ingang, indien van toepassing,
het ding aan de linkerkant geeft haar output.
En in dit geval, increment terug blijkbaar een int,
en zo int is de terugkeer van dit type functie.
Wat betekent het om terug te keren?
Letterlijk, gebruikt u het zoekwoord terug en dan als wat je terug
rechts van het trefwoord is een geheel getal,
dan is dat inderdaad overeen met wat we hebben beloofd.
Je kon het niet zoiets als dit - hello, world - want dat is een string.
>> Uiteraard is geen geheel getal.
Dus in het kort, de last is echt op ons, de programmeur, om precies te zijn
over wat we terug en dan eigenlijk gaan over terug te zenden.
De context hier is nu dat geheugen van uw computer is een gigabyte, 2 gigabyte -
wat dan ook - misschien is het meer, misschien is het minder,
maar de computer ziet het als het hebben van verschillende secties.
Er gaat iets daar beneden, iets anders gaat daar,
verschillende dingen gaat in het midden, en vandaag hebben we gewoon beginnen vertellen van het verhaal,
maar we zullen terugkeren naar dit na verloop van tijd.
Voor nu, het enige stuk van het geheugen hebben we echt zorgen over is het tekstsegment
want dat alleen staat voor de 0s en 1s dat Clang heeft uitgevoerd.
Dus wanneer u een opdracht bij het toetsenbord, zoals a.out
of u dubbelklikt op een pictogram op Mac OS of Windows,
uw programma wordt geladen vanaf de vaste schijf in het RAM
en het is plofte op de top van RAM-geheugen van uw computer, om zo te zeggen.
Intussen, zoals uw programma begint te lopen en de belangrijkste wordt aangeroepen
in het programma dat u heeft geschreven of het programma Microsoft of Apple schreef,
een van zijn lokale variabelen uiteindelijk daar op de bodem van het geheugen van uw computer.
Maar als belangrijkste gesprekken een andere functie die zelf variabelen of argumenten heeft, belanden ze erboven.
En als die functie die iets, ze eindigen boven, boven, boven.
>> En slechts eenmaal een functie wordt uitvoering wordt de stapel trays, zogezegd
beginnen te krijgen lager en lager.
En dit is wat dan, in een notendop, legt uit waarom als je kubus belt
of je increment belt, je passeren in een kopie van de waarde.
En wat dat betekent picturaal is dat je letterlijk je het getal 1 het schrijven van
in een ander deel van het geheugen, het veranderen dat 1 tot 2 bij increment
of een 8 bij kubus en dat het geheugen weg te gooien
zodra de toename of de kubus functie terugkeert. Vraag.
[Student] Waar globale variabelen opgeslagen?
Globale variabelen worden opgeslagen in wat er momenteel wel de geïnitialiseerd gegevens of niet-geïnitialiseerd gegevens,
het verschil is als je een globale variabele en wijst u het meteen een waarde
met de gelijk-teken, het eindigt aan de top daar,
en als je gewoon zeggen int x; zonder waarde, het eindigt iets lager in het RAM
gewoon volgens afspraak.
Andere vragen? Oke.
Dus deze foto zal terugkomen als we meer krachtige
met wat we kunnen doen met de computer,
maar voor nu, laten we eens een korte intro van cryptografie,
een specifiek type cryptografie dat niet alle problemen van de wereldproblemen
maar wel op te lossen een aantal van hen.
In dit geval hier, hebben we iets genaamd geheime sleutel cryptografie.
Secret-key cryptografie, zoals de naam al doet vermoeden, ontleent zijn beveiliging van een geheim.
>> Bijvoorbeeld, als je terug op de lagere school en je was het passeren van een klein geheim liefdesbrief
aan de jongen of het meisje dat je verpletteren op, als je wilde die nota door het publiek,
zou u waarschijnlijk niet schrijven zoals een notitie in het Engels of wat dan ook je moedertaal is.
In plaats daarvan kunt u coderen of je kan gewoon stuur ze een SMS-bericht van deze dagen.
Maar je zou eigenlijk gaan ze een briefje door het hele lokaal.
En om veilig doen dit op zo'n manier dat je vrienden en de leraar
weet niet wat je aan het schrijven bent, kun je komen met een vrij eenvoudige algoritme,
jonge hoewel je zou kunnen zijn, om gewoon versleutelen van de woorden.
Dus in plaats van het schrijven van een je zou kunnen schrijven b,
in plaats van b je zou kunnen schrijven c,
plaats van c u misschien schrijven d, enzovoort.
Of je zou kunnen komen met een meer geavanceerde vertaling
van brieven aan verschillende letters.
Maar de vangst is de jongen of het meisje aan wie u bent het verzenden van deze notitie
moet iets, dat is wat, natuurlijk weet je? >> [Student] Wat u verzendt.
Wat je geheim is, zoals wat is dat mapping tussen a's en b's en c's en d's.
Is het alleen het toevoegen van 1 tot en met elk van de letters om van a naar b, b naar c?
Is het complexer dan dat?
>> Dus jij en je geliefde moet deze geheime informatie te hebben,
maar er is een beetje een catch-22 hier.
Als dit de eerste keer dat je het verzenden van deze liefdesbrief door de klasse,
hoe is die jongen of meisje gaat om te weten wat het geheim is zelfs?
Zo geheim-key crypto lost niet alle problemen in de wereld,
en er is eigenlijk een relatie hier dat we terug komen om tegen het einde semester.
Ook hebben de meeste van ons niet weet iemand dat, werkt bijvoorbeeld bij Amazon.com,
en toch velen van ons hebben waarschijnlijk gekocht spul bij Amazon.com,
en we hebben geleerd om aan te nemen dat deze e-commerce transacties veilig zijn.
De URL zegt waarschijnlijk https, is er misschien een domme kleine hangslotpictogram ergens,
er is een soort van cryptografie beveiliging van uw creditcardgegevens
tussen u en Amazon.com.
En toch, als cryptografie gaat weten een geheim
en toch weet ik niet iedereen op Amazon en ik heb zeker niet geregeld elke vorm van geheime
met iemand op Amazon, hoe is mijn computer of mijn browser om dit te doen?
Het blijkt dat er andere vormen van cryptografie geheel dat op te lossen dat probleem.
Maar voor vandaag, zullen we ons richten op de eenvoudige
waar u kunt vooraf te regelen om een ​​geheime weten
zoals +1 of sommige mapping tussen a's en b's.
En het proces van cryptografie gaat meestal deze.
Je hebt een aantal platte tekst, hier afgebeeld aan de linkerkant,
je het door een soort van algoritme of de procedure voor het versleutelen van het -
misschien is dat gewoon een wordt b, b wordt c -
en dan eindig je met cijfertekst.
Ondertussen, zodra je geliefde ontvangt dit geheim nota,
hij of zij moet dan ontcijferen door algemeen een omkering in de algoritme
om zo terug te krijgen van de platte tekst.
Er zijn fysieke incarnaties van deze.
>> Zo, dit is een klein geheim decoder ring,
en dit is een ring in de zin dat er hier twee wijzerplaten.
Aan de buitenkant rand van dit ding, is er letters A tot en met Z,
hoewel ze in willekeurige volgorde,
en aan de binnenkant, is er eigenlijk een aantal nummers
zodanig dat met deze ring kun je soort van de buitenkant draaien niet, maar de binnenkant
om line-up nummers met letters.
Van een film genaamd A Christmas Story, zul je zien dat er weinig Ralphie
was zo enthousiast om erachter te komen wat geheime boodschap Little Orphan Annie's was om hem te
die waren doorgegeven, denk ik, in de vorm van numerieke berichten op een doos cornflakes
en je moest alle kleine kaarten die kwam in de cornflakes doos accumuleren,
je moest ze mailen in, je moest terug de geheime decoder ring
zodat u kunt eindelijk erachter te komen wat de mapping is tussen letters en cijfers
of letters en letters.
Hoe in een computer kunnen we gaan over de uitvoering of vertegenwoordigen dit soort dingen?
We hebben een manier van uitdrukken onszelf een beetje meer flexibel
dan onze variabelen tot nu toe hebben toegestaan.
We hebben ints gehad, we hebben chars gehad, we hebben praalwagens en tweepersoonskamers en een paar anderen,
maar dat zijn individuele stukken van het geheugen die niet echt ons toelaten om dingen uit te drukken
zoals woorden en zinnen en zinnen.
Inderdaad, we hebben wel zulke dingen strijkers,
maar we beloven dat dit echt is gewoon een vereenvoudiging van de CS50 bibliotheek
dat we van plan te schillen terug.
En dus laten we beginnen hier doen.
Laat me verder gaan en het openen van een bestand -
al deze bestanden zijn beschikbaar, zoals gebruikelijk, online - zogenaamde array.c
om een ​​probleem niets met strings op te lossen, maar dat een beeld schetst hier
van hoe we zouden kunnen gebruiken zoiets als een array.
>> Een array is een data type.
Het is een type van de variabele van soorten die meerdere kleinere data types binnenkant van het heeft
rug aan rug aan rug aan rug.
Dus bijvoorbeeld, als we wilden een klein programma dat geeft je je quiz gemiddelde schrijven
voor een cursus zoals 50 dat 2 quizzen heeft,
je kan heel gemakkelijk schrijven dit programma gebaseerd zelfs op een aantal van materiaal van vorige week
door gebruik te maken GetInt en een paar van variabelen: int quiz1, int quiz2.
En het is vrij eenvoudig.
Het is misschien 10, 20 regels code max uitvoering van een programma
dat de gebruiker voor 2 quiz scores vraagt ​​en vervolgens berekent het gemiddelde
door te tellen, te delen door 2 en afdrukken van de resultaten.
We kunnen waarschijnlijk wel dat mooie gemakkelijk nu na een aantal minuten niet.
Maar het probleem is dat veronderstellen dat 50 had 3 of 4 quizzen.
Stel dat je wilde hetzelfde programma gebruiken voor een klasse die per week had quizzen.
Denk na over een klasse die wekelijks heeft quizzen.
Als er 16 of zo weken in een semester, nu heb je 16 variabelen:
int quiz1, int quiz2, int quiz3, int quiz4.
Zodra u begint met het zien van deze redundantie, deze kopiëren en plakken van de code,
het moet gaan om je wou dat er een betere manier.
En gelukkig, want van arrays die er is. Dus laten we dit doen.
Ten eerste, laat me even een heel simpel ding dat we niet hebben tot nu toe gebruikt,
maar je zult af en toe ziet het in code.
>> Dit is wat algemeen een constante genoemd.
Dus het is een constante in de zin dat deze waarde nooit verandert.
De menselijke conventie bij het maken van een constante
is om alle hoofdletters te gebruiken gewoon zo dat het echt opvalt in uw code,
en het bijzonder sleutelwoord dat u gebruikt in C # te definiëren.
Dus we zeggen # en te definiëren, een spatie en dan het woord dat u wilt gebruiken voor de naam van de constante's
waarna de waarde van de constante.
Let op dit is iets anders dan het toewijzen van iets aan een variabele.
Er is geen teken gelijk is aan, er is geen puntkomma.
Dit is wat algemeen bekend als een preprocessor richtlijn,
maar daarover een andere keer.
Voor nu, creëert dit een onveranderlijke waarde genaamd QUIZZEN
waarvan de feitelijke numerieke waarde is 2.
Dus overal zie je quizzen, Quizzes, quizzes gedurende dit bestand,
dat is nog maar de nummer 2.
Als ik kijk naar de belangrijkste nu, laten we eens kijken hoe dit werkt.
Eerst ziet er een beetje cryptisch, maar het is allemaal spullen van week 1.
Vraag de gebruiker voor de rangen. Hoe gaan we dit doen?
In lijn 22 - dit is echt de sappige deel - Ik verklaar een vlotter
maar niet alleen een vlotter. Ik verklaar, in plaats van, een reeks van floating-point waarden.
Die variabele zal worden genoemd kwaliteiten zoals hier impliciet,
maar het enige stuk van de nieuwe syntaxis dan zijn deze vierkante haken.
Het feit dat ik vlotter cijfers en open beugel en dan een nummer gezegd -
merken als deze is een constante dit is net als we dit deden -
dit betekent: "He computer, geef me 2 wagens en laten we samen noemen ze rangen."
>> Dit is in tegenstelling tot een veel moeizaam proces als volgt: float Voorraad1;
Grade2 drijven, enzovoort.
Dus een reeks stelt ons in staat de uitvoering van deze idee, maar veel minder slordig,
zodanig dat we een regel code te schrijven in plaats van bijvoorbeeld 16 voor een 16-week semester.
Ik wilde niet te hard-code 2, want als je van deze nu logisch,
neem aan dat volgend jaar CS50 veranderingen tot 3 quizzen plaats
en ik het nummer 2 hier had, had ik de nummer 2 hier,
Ik had de nummer 2 hier, de nummer 2 hier.
Het wordt heel vervelend en heel gemakkelijk om het te verknallen
en een waarde ongeluk op 3 te missen en een andere waarde van 2.
Dus ik ga in plaats daarvan abstracte dit weg en gebruik deze constante die,
zoals de naam al doet vermoeden, verandert nooit.
En nu maakt niet uit of we verschillende quizzen hebben dit jaar of volgend,
Ik moet gewoon om het te veranderen in een plaats hier aan de bovenkant.
Dus dat is al een constante is.
Ondertussen de nieuwe conceptuele is dat een array.
Dus de vierkante haken geef mij dit veel praalwagens en laat me collectief noemen ze hier rangen.
Dus nu laten we eens kijken wat ik ga doen.
Hier in leiding 24 is het begin van een lus.
>> Dit is echt niks speciaals. Het is alleen met behulp van QUIZZEN in plaats van een hard-gecodeerde nummer.
Maar er is niets intellectueel anders er van vorige week.
Dit is gewoon printf, dus printf ("Quiz #% d van% d:")
want ik wil gewoon uitprinten me quiz nummer 1 van 2 en dan 2 van 2 te geven.
Dus dit is een puur esthetisch ding.
Maar het interessante deel is nu in lijn 27.
Om in een van de twee aanduidingen vullen met een drijvende komma waarde
u weer gebruik maken van vierkante haken.
In dit geval, ik gebruik ik omdat dit for-lus is begonnen met i gelijk welke waarde, blijkbaar?
[Student] 0. >> [Malan] 0.
Dus op de eerste iteratie van deze lus, het is alsof ik schreef dit in de code,
maar op de tweede iteratie van deze lus, het is alsof ik schreef dit in mijn code.
Maar het feit dat ik een variabele met behulp van perfect is, omdat, zoals de naam al doet vermoeden,
het is het variëren van de waarde op elke iteratie
dus ik ben het vullen van deze array een plek op een moment.
Wat betekent deze array eruit?
De reden dat ik de aandacht van de super eenvoudige rechthoek op het scherm hier voor was om deze reden.
Een array is gewoon een brok van het geheugen, gevolgd door een ander stuk van het geheugen
gevolgd door een stuk geheugen enzovoort.
Dus als mijn array is van grootte 2 hier in dit geval, het enige wat ik zou moeten doen
door te typen in mijn quiz scores zoals hier - Ik heb 100 op dit ene en toen kreeg ik een 99 op dit ene -
dan is dit geheugen misschien niet eens worden gebruikt, want ik heb alleen gevraagd de computer
voor een array van grootte 2.
Die pleinen zijn er nog steeds, toch?
Je hebt nog steeds 2 gigabyte aan RAM-geheugen, zelfs als je alleen vraagt ​​voor 2 wagens.
Dus het idee achter arrays is dat de computer slechts een deel van het geheugen wordt
en dan verdeelt kleinere stukken rug aan rug aan rug aan rug.
En dus dat is alles wat een array is.
>> Het is een aaneengesloten stuk geheugen in waarvan u kunt dingen.
Dit gebeurt dan doen slechts enkele saaie rekenen.
Als ik naar beneden scrollen hier, dit is waar ik dan itereren over de array.
I komen met de som van alle waarden in de array,
en dan gebruik ik de ronde functie hier om daadwerkelijk de som gedeeld door quizzen.
Maar laat me mijn hand zwaaien, dat als een soort van voldoende rekenkundige voor nu.
Maar dat alles doet voor mij uiteindelijk het berekenen van een gemiddelde.
Dus eerst quiz plus tweede quiz gedeeld door 2 en dan af te drukken het uit als een int.
Maar laten we nu de overgang naar een ander voorbeeld genoemd tekenreeks1,
die schetst een soortgelijk beeld, maar met behulp van snaren.
Laat me ga je gang en vereenvoudigen dit voor slechts een moment.
Vergeef de inspringing voor nu.
Merk op dat in lijn 19 van dit voorbeeld, krijg ik een string van de gebruiker.
Maar let op wat ik daarna doe in lijnen 22 verder.
Ik ben eigenlijk itereren van i tot en met - en dit is een nieuwe truc - strlen, tekstlengte.
Dit is een functie die wordt geleverd met C dat als je langs het een string,
het vertelt je hoeveel tekens zijn in die string. Dat is alles.
En het feit dat het strlen in plaats van de string lengte is gewoon omdat het meer beknopt.
Dertig jaar geleden, mensen graag dingen op te schrijven zo kort mogelijk te maken,
dus we hebben gehouden dat verdrag hier.
i + + betekent gewoon verhogen i in elke iteratie.
En let nu op, en dat is echt interessant.
In regel 24, zeg ik, "Computer, geef me een teken, 8 bits, en noem het c."
Maar wat is dit op de rechterkant te zeggen?
In het Engels, dat betekent wat voor?
[Student] Het eerste teken in de array.
Precies. Geef mij het eerste teken in de array.
Of, meer in het algemeen, geef me de i-teken in de array.
En nu besef dat het belangrijk is dat als informatici,
we eigenlijk lopen vanaf 0.
>> Je hoeft nu niet de bevoegdheid te hebben om te beginnen met dit te doen.
Nu heb je te gedragen in overeenstemming met de verwachtingen van de computer en van 0 te tellen
omdat [0] zal het eerste teken in een string,
[1] gaat worden de tweede, [2] gaat de derde, enzovoort.
Dus dit programma, als ik het compileren, dit weer is tekenreeks1, dus zorg tekenreeks1,
en nu heb ik lopen tekenreeks1 in mijn terminal-venster.
Het wacht op input, dus ik ga te typen in David, Enter,
en nu drukt David allemaal op verschillende lijnen, want let op wat ik doe.
Ik ben het afdrukken van een karakter per keer.
We zullen niet in detail treden vandaag op deze, maar ik verwijderde een ogenblik geleden deze controle hier.
Het blijkt dat als de gebruiker zich misdraagt, hoor en wederhoor, of gewoon in de war,
kun je eigenlijk niet aan een reeks van enige lengte te geven.
Als je op de verkeerde toets op het toetsenbord, kunt u geven geen snaar helemaal niet,
of als je kwaadaardige, kunt u proberen te plakken in de moeite waard een gigabyte van een essay
naar deze string vullen en als de computer geen geheugen,
het blijkt dat we gaan terug deze speciale waarde genaamd NULL.
Dus voor nu, weet alleen dat er deze speciale waarde met de naam NULL
die ons in staat om te controleren als we uit het geheugen, onder andere dingen.
Maar als ik open nu tekenreeks2, hier op te merken een verschil.
Hier een opzegtermijn van een verschil met string2.
Met tekenreeks2, dit for-lus is een beetje anders.
>> Laat me verwijderen van de Null-waarden, zodat we kunnen praten over die andere keer.
Wat is er anders aan de for-lus deze keer?
Ik kan terug gaan naar het vorige voorbeeld.
Dus dat is versie 2, dit is versie 1. 1, 2.
1, 2.
De strlen oproep is waar?
Het is in het eerste deel van de lus.
Elke gedachten over waarom ik dit doe? Ja.
[Student] U hoeft dus niet bellen met de functie iedere keer.
[Malan] Dus we niet bellen met de functie iedere keer. Precies.
Recall van voor loops dat ze super eenvoudig
als je eenmaal soort van begrijpen dat dit de initialisatie, de conditie en de update.
Het probleem is dat de toestand gebeurt op elke iteratie van de lus.
En dus in dit voorbeeld, wat slecht is over het feit dat dit mijn conditie?
[Student] Je noemt strlen.
[Malan] Je noemt strlen opnieuw en opnieuw en opnieuw.
Maar zodra ik heb getypt in David, de lengte van die string is 5,
en het is niet van plan om te veranderen op elke iteratie van de lus
omdat de string nog D-a-v-i-d.
Dus dit is een hint naar wat er gaat een steeds belangrijkere idee geworden
bekend als een ontwerpbeslissing waar gewoon niet maken de computer te doen onnodig werk.
>> Net zoals een sneak preview van pset2, pset2 in de standaard editie
zal je uitdagen om daadwerkelijk uitvoering van een aantal aantal cijfers,
een bepaald aantal encryptie-algoritmen, zodat u zowel coderen
en decoderen van geheime boodschappen die lijkt op degene Ralphie daar gedecodeerd.
In de hacker editie van pset2, gaan we een stapje verder te gaan.
We gaan overhandigen u een bestand van een echte computer-systeem
dat bevat een hele hoop van gebruikersnamen en feitelijke gecodeerde wachtwoorden,
en de uitdaging voor de hacker editie gaat worden om die wachtwoorden te kraken
en erachter te komen wat cryptografie of wat het geheim werd gebruikt om daadwerkelijk te genereren die wachtwoorden.
En we gaan dit doen door gebruik te maken van een nieuwe feature hier van C
dat Ik geef je gewoon een demo van zogenaamde command-line argumenten.
Het blijkt, zoals sommigen van jullie misschien hebben gezien in paragraaf of in leerboeken,
belangrijkste hoeft niet altijd nietig tussen haakjes zijn.
Het blijkt dat de belangrijkste ook geschreven kan worden als deze, met twee argumenten,
argc en argv, waar argc is het aantal woorden
die u typt na de naam van het programma op uw opdrachtregel
en argv is de werkelijke woorden.
En als de vierkante haken daar suggereren, argv is blijkbaar een array.
Het gaat om een ​​string na een reeks na een reeks in het geheugen zijn.
>> Dus wat we gaan om te kunnen doen beginnen met PSET 2 is iets als dit.
Als ik argv1, dat is een voorbeeld dat we weer terug te komen op maandag en voer het uit,
merken dat het niet lijkt te nog iets doen.
Hij drukt gewoon uit zijn eigen naam.
Maar als ik afscheid klasse, merk op dat dit programma blijkbaar herhaalt
over elk van de woorden die werden ingevoerd wordt bij het prompt.
En de manier waarop we toegang tot woorden te krijgen die de gebruiker heeft ingevoerd wordt bij het prompt
is door het veranderen van de belangrijkste dit weekend van start vanaf int main (void) to main (argc, argv) int
en dus zullen geboren worden command-line argumenten.
En als je eenmaal echt verfijnd op dit, zult u in staat om echt trippy programma's te schrijven
zoals deze hier, die verder gaat boven en buiten
deel van de functionaliteit die we tot nu toe gedaan, maar allemaal heel krachtig.
>> Dus we laten dit met deze op het scherm, en we zullen u op maandag.
>> [CS50.TV]