>> SPEAKER 1: Hoi iedereen.
We gaan aan de slag.
Ik denk dat mensen gaan nog steeds te filteren in.
Maar in het belang van de tijd, dus we kunnen Willen jullie hier op tijd,
we gaan beginnen.
Dus welkom op de CS50 Quiz 0 beoordeling.
Voor degenen onder u die niet gerealiseerd zijn nog, je hebt een vraag op woensdag.
Woo-hoo.
>> Als u nog niet begonnen met nog studeren of hebben zich niet gerealiseerd dat dit nog bestaat,
verleden quizzen en alle informatie over uw quiz op cs50.net/quizzes.
Er is wat best goed spul op daar, verleden quizzen van de laatste 10
jaar alsmede informatie over deze quiz en onderwerpen
die zullen worden gedekt.
Dus laten we beginnen.
>> Dus jullie kunnen herinneren, de eerste lesdag David had die lampen op.
Dus in wezen, alles wat daarbij hoort onder de motorkap van een computer is
gedaan in binaire.
Binaire betekent wat het klinkt zoals, 0's en 1's.
Het heeft twee waarden kan worden weergegeven.
>> Dus net als in de eerste dag van de sectie toen David draaide op een lichte
gloeilamp te vertegenwoordigen op, of 1, onze computer begrijpt binair als 0 en
1's, aan of uit.
Basis van de Binary.
Elke plaats is vertegenwoordigd in basis twee.
Dus je 2 toe te voegen aan de 0 naar de 1 op de 2 helemaal naar boven.
>> Om te berekenen wat uw binary is te decimaal, volg gewoon deze vergelijking
soort ding.
Als je een 1 in een van die plaatsen, je het vermenigvuldigt met welke
Baseer het in, voeg het op, en je krijgt de decimaal.
Dus dit is hoe je telt tot en met 5 in binaire.
Net als wat we aan het doen waren op de laatste dia, dit is hoe je dat zou doen
1 vertegenwoordigen tot en met 5.
>> Op dezelfde manier, net als u kunt toevoegen en aftrekken in decimale of baseren 10, of
echt geen basis, op kunt toevoegen en aftrekken in het binaire.
Precies wat je zou verwachten als je Voeg de twee op, als het groter gelijk
dan 1, je draagt ​​een 1, maken het een 0, en doe de toevoeging op die manier, net
zoals je zou verwachten met regelmatige decimaal of een andere base.
Cool.
>> Dus zoals ik al eerder zei, alles wat gaat verder onder de motorkap van onze computer
gebeurt in 0 en 1's, of binair.
Dus hoe kunnen we uitdrukken, bijvoorbeeld, letters of cijfers en andere tekens?
En het antwoord daarop is ASCII.
>> ASCII is een mapping tussen de personages dat we normaal zien in de
Engels taal zoals A's, B's, C's, onderstrepen, streepjes, en
iets dergelijks.
En het brengt dat naar een ASCII-waarde.
Een ASCII-waarde is slechts een nummer dat begrepen kan worden door de computer.
En net zoals je bovendien kunt doen en aftrekken met getallen, kunt u doen
ze met ASCII waarden.
>> In dit voorbeeld, welke zal dit uitprinten?
Ja, dus gewoon een ruimte B ruimte C ruimte D. Waar is mijn muis te gaan?
Let op u kunt een int 65 definiëren.
En wanneer u afdrukt dat met behulp van procent C, zal het interpreteren dat als een
karakter en zal A. uitprinten
>> Op dezelfde manier kunt u aangeven het als een char.
En wanneer u het afdrukken met behulp procent C, zal het interpreteren dat als
procent D. En net zoals je een kunt toevoegen nummer, kunt u toevoegen tekens zijn
ASCII-waarden, in dit geval.
>> Dus een beetje wijzer voor iedereen.
5, als een string, niet eigenlijk gelijk 5.
Dus hoe kunnen we zetten de snaar 5 aan integer 5?
Het even welke ideeën?
Yeah.
>> Dus als we hebben 5 als een string, we kunnen aftrekken 0.
En dat zal ons 5.
En evenzo, als we 5 als integer, voeg dat toe aan de string 0.
En dat geeft ons de snaar 5.
Cool.
>> Nu, herinner terug naar een situatie waarin de les hebben we gesproken over algoritmen.
Dus hoe willen we eigenlijk een computer om interessante dingen te doen?
Je weet wel, gewoon optellen en aftrekken nummers en afdrukken dingen, is niet
dat spannend.
Meestal willen we onze computer te voeren wat soort algoritme.
Iets wat complexer dan alleen eenvoudige rekenkundige.
>> Een algoritme is gewoon een stap voor stap set van de instructies voor het uitvoeren van
bepaalde task--
net als een recept.
Je zou de eerste dag van herinneren klasse waar David had ons horen een kamer
van mensen en hoeveel mensen waren in de kamer.
U zou kunnen worden gebruikt om te tellen een voor een.
1, 2, 3, 4.
In dat geval kan een lineaire tijd algoritme.
>> Maar David introduceerde een algoritme voor je aan de mensen in de kamer te tellen
waar iedereen staat op, zegt u uw nummer aan een ander persoon, toe te voegen dat
nummer op, en een persoon gaat zitten.
En u dat herhalen.
Dat is een type algoritme.
Wij analyseren hoe efficiënt een algoritme is gebaseerd op het gestart tijd.
Maar we zullen een beetje praten daarover later meer.
>> Dus alle algoritmes kunnen ook worden geschreven in pseudocode.
Pseudocode is gewoon een Engels als syntax gebruikt om
een programmeertaal.
Bijvoorbeeld, als we wilden om een ​​gebruiker te vragen mijn favoriete nummer raden, we
kan pseudocode als zodanig.
>> Hier krijg je een gebruikers raden.
Als de schatting juist is, vertel hen ze correct zijn, anders vertel hen
ze zijn niet correct.
En pseudocode is een manier om gemakkelijk vertegenwoordigen een idee of een algoritme.
Dus nu hebben we misschien willen eigenlijk schrijven dit in de taal die de computer
zou kunnen begrijpen.
Dus konden we onze pseudocode schrijven en interpreteren dat in de broncode.
>> Tot nu toe moet broncode voldoen een bepaalde syntax van
een programmeertaal.
En tot nu toe, in CS50, we hebben werd met behulp van vooral c.
Dus dit kan broncode c zijn.
Later in de cursus, je 's nachts komen in contact met andere programmering
talen zoals PHP.
Of als u zelfs andere klassen, u zou kunnen doen Java, Python, of zelfs OCML.
Maar in onze c-programma taal, dit is hoe we de broncode voor zou kunnen schrijven
de pseudocode algoritme dat Ik eerder beschreef.
>> Dus hoe werkt de computer eigenlijk Begrijp je dat?
Zoals ik al eerder zei het pas echt begrijpt nullen en enen.
Dus hoe werkt het krijgen van de bron code iets dat kan worden
begrepen?
Nou, we hebben iets genoemd compiler.
>> Als je terug herinneren in de meeste van uw psets, je een soort van programma hadden
geschreven in een punt c bestand.
En dan zou je make typt.
Dus wat maakt het doen?
>> U kunt typen maak samen te stellen uw programma, omdat someone--
wie schreef je p set; Waarschijnlijk David--
creëerde een make file.
En dat zegt te maken om te weten te lopen uw compiler, genaamd clang, dat wil
dan is uw broncode te compileren om bezwaar code, die nullen en enen
dat de computer begrijpt.
Maar een beetje later, gaan we meer in de diepte over compilers.
>> Dus herinneren PSET 0, where-- ja, heb je een vraag?
>> PUBLIEK: [onverstaanbaar]?
>> SPEAKER 1: Ja.
Ik denk dat ze eigenlijk moet online zijn.
Yeah.
>> PUBLIEK: Is het als [onverstaanbaar]?
>> SPEAKER 1: Het is niet.
Het zijn op cs50.net/quizzes.
>> PUBLIEK: Slash quizzen, slash 2013 slash 0, en klik je gewoon door
quizzen 2013 en quiz 0, beoordelen sectie glijbanen.
>> SPEAKER 1: Ja, dus als jullie willen trek hem omhoog en kijk naar het op uw
eigen computer, is dat ook goed.
Zeg dat nog eens.
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Ja, [onverstaanbaar] is de dummy variabele.
Oh, ja?
>> PUBLIEK: [onverstaanbaar]?
>> SPEAKER 1: Nee, stakingen zijn niet op het examen.
Sorry, haar vraag was, was stakingen op het examen.
En is het niet.
Dus PSET 0, moeten jullie allemaal geïmplementeerd iets met scratch.
En we leerden een aantal fundamentele programmering bouwblokken met scratch.
>> Dus laten we eens een kijkje bij enkele Deze bouwstenen
die deel uitmaken van een programma.
Eerst is Booleaanse uitdrukking.
Booleaanse uitdrukkingen zijn enen en 0's of iets dat heeft
twee mogelijke waarden.
In dit geval, waar of onwaar, aan of uit, en ja of nee.
Een voorbeeld van een eenvoudige, zeer eenvoudig, programma dat gebruik maakt van een Booleaanse
uitdrukking hier.
>> Dus om voor Booleaanse expressies nuttig, we Booleaanse operatoren.
Dit zijn operatoren die kunnen worden gebruikt bepaalde waarden te vergelijken.
Dus we hebben en dan niet gelijk aan minder, dan of gelijk aan, groter dan of
gelijk aan en kleiner dan of meer.
Maar deze operatoren zijn niet erg nuttig tenzij we ze kunnen combineren tot
voorwaarden.
>> Dus jullie herinneren zich misschien nog van de grond af en van uw p stelt dat we
had voorwaarden.
Ze zijn, in wezen, zoals vorken in de logica van het programma dat
uitgevoerd naargelang een voorwaarde is voldaan.
Dus een van de voorwaarden die we hadden vele malen gebruikt in deze cursus is de
indien, anders, als, en anders voorwaarden.
>> Hier is een voorbeeld van hoe je zou kunnen gebruiken dat.
Weet iemand het verschil tussen weten alleen met behulp van if-statements alle
de weg naar beneden verzen als, anders, indien, en anders gecombineerd?
Ja?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Precies.
Dus als ik had als helemaal naar beneden deze manier, zelfs als deze aandoening terugkeert
true, zal het nog steeds het testen van de volgende twee.
Overwegende dat, met een anders-of, een ander verklaring, als de ene geeft true,
de anderen zijn niet getest.
Heeft u vragen over dat?
Cool.
>> Dus je een if-else van een anders te gebruiken statement als je weet dat het kan alleen
een van deze gevallen.
We weten als x kleiner is dan 0, is het zeker niet van plan te zijn
groter dan 0.
>> Vervolgens een andere bouwsteen dat we geleerd hebben lussen.
We hebben drie soorten lussen.
Voor loops, terwijl loops, en te doen terwijl loops.
En in het algemeen, als je gaat zitten om te schrijf iets, je moet beslissen
welke van de drie die u wilt gebruiken.
Dus hoe kunnen we beslissen welke?
>> We gebruiken over het algemeen een lus als we weten hoe vaak we willen herhalen
door iets of hoe vaak we willen een taak uit te voeren.
We gebruiken terwijl loops als we nodig hebben voorwaarde om waar te draaiende te houden zijn.
En we gebruiken doen terwijl zeer vergelijkbaar met tijdje, maar we willen onze code kan worden uitgevoerd op
minste een keer.
>> Dus doen terwijl, wat in de doe zal altijd op minstens een maal.
Overwegende dat, met de tijd, het misschien niet helemaal als het lopen
voorwaarde niet is voldaan.
Voor vragen met dat?
>> Dus de structuur van een lus.
Jullie hebben allemaal gezien.
Je initialiseren.
Je hebt een soort van aandoening.
Dus, bijvoorbeeld, kunnen we initialiseren als voor i gelijk is aan 0.
i kleiner is dan 10.
En ik ++.
Heel simpel een die we hebben gedaan.
>> Voor een tijdje loop, evenzo, je hebt om een ​​soort van initialisatie hebben,
een soort aandoening, en een soort van aanpassing.
Dus we kunnen ons ook uit te voeren voor de lus als een while lus met behulp van deze.
En ook met een do while lus, we misschien wat initialisatie hebben,
voeren iets, updaten, en controleer dan de conditie.
>> Dus nu functioneert.
We zetten alles samen.
We zouden willen wat te schrijven soort functie.
Voorkomende functie die je misschien hebben al gezien is de belangrijkste.
Belangrijkste is een functie.
Het heeft een soort terugkeer, int.
Het heeft een functie naam, de belangrijkste.
En het heeft argumenten, argc en argv.
Dus belangrijkste is gewoon een functie.
>> Andere functies die u zou kunnen hebben gebruikt, printf-- printf is een function--
GetInt, toupper.
Maar die gebeuren te zijn geweest door geïmplementeerd voor ons
een soort bibliotheek.
Als jullie niet vergeten, waaronder Dit CS50.h bibliotheek of de
standaard I / O library.
Ja, vraag?
>> PUBLIEK: Is main gewoon inherent aan c?
Is het gewoon een soort van [onverstaanbaar]?
>> SPEAKER 1: De vraag is als belangrijkste is inherent aan c.
En ja, alle functies hebben een belangrijke functie.
Het is een soort van nodig zijn voor de computer om te weten waar te beginnen
het uitvoeren van de code.
>> PUBLIEK: Dus je zou het niet [onverstaanbaar]?
>> SPEAKER 1: Nee
Een andere vragen?
Cool.
Dus net zoals je een functie kunt gebruiken dat is geschreven voor u, kunt u ook
schrijf je eigen functie.
Dit is een functie die iemand zou kunnen hebben geschreven om het volume te berekenen
van q, bijvoorbeeld.
Er is een soort terugkeer hier, in dit geval int, onze functie naam q en onze
lijst van parameters.
>> En er rekening mee dat je de gegevens te schrijven soort van de parameter die u wilt
gebruiken of anders de functie niet weten wat voor soort
parameter moet ik accepteren.
Dus, in dit geval, we willen een geheel als onze inbreng.
Dus waarom zouden we willen kunnen gebruiken?
>> Allereerst, geweldig voor de organisatie.
Ze helpen breken uw code in meer georganiseerd brokken en maken
het makkelijker om te lezen.
Vereenvoudiging.
Dit is goed voor het ontwerp.
Als je het lezen van een stukje code en de belangrijkste functie is echt,
echt lang, zou het moeilijker te zijn reden over wat er gaande is.
Dus als je het af te breken in functies, is het misschien makkelijker te lezen zijn.
En hergebruik-mogelijkheden.
Als je een stuk code dat wordt gebeld of lopen meerdere keren,
in plaats van het herschrijven van de code 10 keer in uw belangrijkste functie, zou je
wilt hergebruiken.
En dan elke keer dat je nodig hebt om dat te gebruiken stukje code, bellen met de functie.
>> Dus nu, als we terug naar het niets herinneren, hebben we ook gesproken over een aantal concepten,
waarvan wordt threading.
Draad is het concept van meerdere sequenties van code
uitvoeren tegelijk.
Dus denk terug aan de eerste dag waar David had jullie aftellen van het aantal
mensen in de kamer.
>> Wezen, wat er gaande was on is jullie allemaal jongens waren
lopen aparte threads.
En die draden werden samen komen een soort antwoord.
Ook in Scratch, als je meerdere sprites, zou je
een kat en een hond.
En ze zouden tegelijkertijd worden het runnen van hun eigen scripts.
Dit is een voorbeeld van schroefdraad.
>> En de andere concept dat was geïntroduceerd in het niets was gebeurtenissen.
En gebeurtenissen zijn wanneer er meerdere delen van uw code met elkaar communiceren.
In Scratch, was dit wanneer u gebruikt de broadcast-controle en het Toen ik
Ontvang blokken.
>> En ook, in Probleem Set 4, zagen we een beetje van evenementen.
Jullie zouden hebben gebruikt het gevent bibliotheek.
En er was een functie waitForClick waarin u zaten te wachten
voor de gebruiker om te klikken.
En uw klik, in dit geval zou zijn het evenement en wacht klik is uw
event handler.
>> En ook, gedurende het runnen van uw psets en werken aan je psets, u
misschien in contact komen met zijn gekomen sommige van deze commando's.
Dit is wat je getypt in uw terminalvenster of wat dan ook venster
dat verschijnt op uw g bewerking om, wezen, navigeer je computer.
>> Dus bijvoorbeeld, LS worden de inhoud van een directory.
Maak map een nieuwe map creëert.
CD, change directory.
RM, verwijdert, verwijdert een bestand of een directory.
En verwijder vervolgens directory verwijdert een directory.
>> PUBLIEK: [onverstaanbaar]?
>> SPEAKER 1: Ja, natuurlijk.
Sorry, de vraag was of je zou voorstellen om deze
op het spiekbriefje.
Het zou kunnen helpen.
Als u ruimte, kunt u het op.
Het is ook gewoon over het algemeen goed genoeg om te onthouden, want als je het gebruikt
wilt u misschien gewoon hebben in het geheugen.
Dat zal je leven een stuk makkelijker maken.
Heb ik je vraag beantwoord?
>> Dus nu, spraken we een beetje kort over bibliotheken.
Maar de twee belangrijkste zijn dat we geweest zijn middels dusver in de cursus
standaard I / O en CS50.
Wat voor soort dingen zijn opgenomen in de standaard I / O-bibliotheek?
>> Ja, tot nu toe die we hebben gebruikt printf.
In CS50, hebben we gebruikt getInt en GetString.
En het type data reeks gebeurt ook te worden verklaard in deze CS50 bibliotheek.
We zullen een beetje meer praten in de diepte over hoe bibliotheken werken en hoe ze
interactie met de rest van je code.
Maar dat zijn de twee belangrijkste zijn dat we in contact zijn gekomen met de tot nu toe in
de cursus.
>> Types.
Deze zijn goed om te onthouden hoeveel elk wordt voorgesteld door of hoe
veel bytes elk type requires--
int, 4 bytes; char, 1 byte.
Float is 4 bytes.
Wat is een dubbele?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Ja, dus een vlotter maar het dubbele van de grootte.
Hoe zit het met een lange?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: OK.
Wat is een lange?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Ja, het dubbele van een int.
Ja.
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Lange [onverstaanbaar].
En dan is een lange lange is het dubbele.
>> PUBLIEK: Nee, nee.
Een lang is gewoon een int.
Het hangt van de architectuur vóór de [onverstaanbaar]
en int hebben dezelfde grootte.
[Onverstaanbaar].
>> SPEAKER 1: Dus een lange en een int zijn hetzelfde.
En dan een lange lange is het dubbele van de int.
Cool.
En dan, wat is het laatste type?
>> PUBLIEK: Pointer.
>> SPEAKER 1: Ja, dus we geleerd een beetje over pointers.
En ongeacht wat een pointer is wijzen om-- het kan een char ster
of een int star--
het is altijd 4 bytes voor een pointer.
Vragen over dat?
Ja?
>> PUBLIEK: [onverstaanbaar]?
>> SPEAKER 1: Dus een lange en een int zijn hetzelfde in dit CS50 apparaat.
>> Publiek: Het apparaat is volledig verwisselbaar.
>> SPEAKER 1: Ja.
Dus dan is een lange lange is dubbel een int.
>> Publiek: Dit is de 32 bit?
>> SPEAKER 1: 32 bit, ja.
>> PUBLIEK: Dus [onverstaanbaar]?
>> SPEAKER 1: Ja, als het niet expliciet zeggen, je
moet 32 ​​bits nemen.
>> Publiek: Het zou iets te zeggen zoals uitgaande van een
architectuur, zoals het apparaat.
Voor 64 bit, de enige dingen die verandering zijn longs en pointers.
Beiden [onverstaanbaar].
>> SPEAKER 1: Ja?
>> PUBLIEK: Vraag.
Dus op een van de praktijk quizzen, het vraagt ​​over een unsigned int.
Dus hoe zou dat worden bepaald van een int [onverstaanbaar]?
>> SPEAKER 1: Een unsigned in is 4 bytes.
Maar wat anders is aan een getekend is int en een unsigned int?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Recht.
Men kan negatieve waarden vertegenwoordigen.
Maar hoe komt het dat doen?
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Ja, het bespaart 1 beetje aan het bord te vertegenwoordigen.
De ondertekende heeft een bit dat vertegenwoordigt het teken.
En unsigned gewoon alle positieven.
>> PUBLIEK: OK.
Dus je zegt dat een dubbele is twee keer de grootte van een vlotter?
>> SPEAKER 1: Dubbel is tweemaal de grootte van een vlotter, ja.
>> Publiek: Hoe werkt een pointer een lange lange [onverstaanbaar]?
>> SPEAKER 1: Dus de vraag is hoe werkt de aanwijzer om een ​​lange long--
hoe is dat slechts vier bytes bij een lange lange haar 8 bytes.
Dus onthoud wat is een pointer, wezen, aan de basis waarde.
>> PUBLIEK: [onverstaanbaar].
>> SPEAKER 1: Ja, dus een pointer is gewoon een geheugen locatie.
Dus het maakt niet uit hoeveel ruimte dat pointer wijst.
Het moet alleen 4 bytes om bij te houden van dat geheugen locatie.
Een andere vragen?
Cool.
>> Dus het laatste wat ik heb is standaard output.
Je moet ze vaak te gebruiken genoeg dat je kan herinneren.
Maar dit is wanneer we gebruik maken van printf bijvoorbeeld.
En we hebben deze placeholders die werden genoemd formaat codes.
>> Dus procent c char, procent i voor int, en we kunnen ook gebruik maken procent d.
Het is hetzelfde ding.
Maar, over het algemeen, in CS50 we probeer procent i gebruiken.
Procent f voor float.
Procent ld voor lange lange en procent s voor string.
>> Ook hebben we gebruik gemaakt van een paar van deze escape sequences.
Bijvoorbeeld, backslash n voor de nieuwe lijn.
Dit is alleen voor wanneer u formatteert uw code voor print f.
Ja?
>> Publiek: Wat procent d voor?
>> SPEAKER 1: Dus de vraag is wat is d procent voor?
Procent d is voor ints.
Percentage d en i procent zijn hetzelfde.
>> Publiek: Wat is het verschil tussen backslash n en backslash r?
>> SPEAKER 1: De vraag is dus wat is het verschil tussen speling n en
speling r?
Ik denk backslash r is--
>> PUBLIEK: Dus backslash r impliceert net terug naar het begin van de regel
zonder daadwerkelijk te gaan naar een nieuwe regel.
Dus als je een backslash r afdrukken en u ga terug naar het begin van de regel
dan heb je meer spullen af ​​te drukken, kunt overschrijven de dingen die al op
[Onverstaanbaar].
Overwegende dat, n eigenlijk gaat om een ​​nieuwe lijn en gaat naar [onverstaanbaar].
>> SPEAKER 1: Nou, nog andere vragen?
Oke.
Ik ga het de hand uit naar Dan die zullen blijven.
>> [Applaus]
>> DAN: Alle righty.
Dus ik zal het over een andere grote waaier van ideeën uit de klasse die zijn
ruwweg representatief week twee en het begin van de week drie wegrijden
met gieten, dat is gewoon een manier van behandelen van een waarde van een bepaald type als
een waarde van een ander type.
Dus we kunnen dit doen met chars naar ints, drijft naar ints, en
lange longs te verdubbelen.
>> Al deze dingen kunnen worden gebruikt als middelen behandelen van bepaalde numerieke waarde
minus char als sommige andere numerieke waarde.
Dus er zijn een aantal problemen met deze, van cursus, die komt wanneer u werpen
dingen als float naar ints.
Dus dit is een beetje raar.
We hebben een float die is 1,31.
We vermenigvuldigen met 10.000.
En dan af te drukken wij het als een int.
Wat doet deze output?
10.000 keer 1,31.
Dus 13.000, is dat de gok?
>> Publiek: Ik denk dat het 10.000.
>> DAN: Dus ik doe het vermenigvuldigen met 10.000 voordat ik het gieten.
>> PUBLIEK: Oh.
Zou er een 9 en sommige nummers 0?
>> DAN: Je zou kunnen hebben een aantal rare cijfers.
Zo goed, het is 1,3 keer 10.000.
Dus dat is 13.000.
En deze extra weird--
>> PUBLIEK: 13.100.
>> DAN: 13.100.
Dank je, Rob.
En deze extra weirdness--
dit 9,9--
is simpelweg omdat deze casting belandde afronding naar beneden waar
het moet niet.
Yeah.
>> Publiek: Het gieten gebeurt Na iets anders?
>> DAN: Dus omdat ik dit in print, het doet deze vermenigvuldiging voor het
Dit doet casting.
>> PUBLIEK: [onverstaanbaar].
>> DAN: Ik denk dat het eerst zou werpen, ja, die zou zijn 10.000.
Iets anders?
Cool.
Dus dit is 13.099.
Waarom gebeurt dit?
Onnauwkeurigheid.
>> Praalwagens zijn niet perfect.
Ze kunnen alleen nummers een vertegenwoordigen aantal significante cijfers.
Dus als we uitprinten 8 sig vijgen op Deze vlotter, krijgen we een soort van
lelijke nummer.
En dat komt omdat 1,31 kan niet nauwkeurig worden vertegenwoordigd door een eenvoudige
machten van twee in de machine.
Dus het eindigt het nemen van de dichtst raden, dat eindigt
een beetje laag.
Zinvol?
OK.
>> Nu, geschakeld zijn een andere manier van doet conditionele uitspraken waar alle
we de zorg over een enkele variabele.
Dus in dit specifieke voorbeeld, we zijn steeds een geheel getal van de gebruiker.
En dan zijn we op zoek naar wat dat integer is.
Vermoedelijk is het aantal tussen de een en vier.
Dat is wat we vragen.
>> Dus je moet een schakelaar van doen de naam van de variabele.
Dan moet je het opzetten van gevallen van mogelijke waardeert het zou kunnen zijn.
Dus het geval een, zeggen dat het laag.
En dan breek je om eruit te komen van de schakelaar staat dus
je hoeft niet door te gaan.
>> In de volgende geval--
dus geval twee en case three--
als het geval twee zakt gewoon naar beneden te de eerste regel van de code het ziet als met
case drie totdat hij ziet een pauze.
Dus de reden dat je krijgt bij een tot alleen druk laag is, omdat ik
hier hebben deze pauze.
Als ik, zeg, negeerde dit break-- als ik gooide dit breakaway--
het laag zou afdrukken, en dan zou het afdrukken midden, en dan zou het breken.
>> Dus pauzes zijn een belangrijk onderdeel van schakelen voorwaarden en
ze moeten er zijn.
Alle gevallen die niet expliciet zijn vermeld worden door de standaard
geval de schakelaar en moet worden gegoten.
>> PUBLIEK: Dus 1, 2, 3, en 4 zouden n zijn?
>> DAN: Waarden die n kan zijn.
Ja.
Yeah?
>> PUBLIEK: Dus als je dat [onverstaanbaar]?
>> DAN: Je zou laag af te drukken, en vervolgens zou het midden te drukken, en
dan zou breken.
>> PUBLIEK: Waarom zou het af te drukken midden als [onverstaanbaar]?
>> DAN: Dus alles onder een case voordat er een pauze valt onder.
Dus het geval een afdruk eronder geval men zoals deze volgende afdrukopties.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Dus dit nummer is gewoon een bijzonder waarde dat deze variabele
kan nemen, toch?
Heeft dat zin?
Yeah.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, bij twee zouden afdrukken midden en dan breken.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ik denk dat elke?
Welke andere soorten data kunt u overschakelen?
>> PUBLIEK: U kunt schakelen over een gegevenstypen.
Maar het betekent slechts iets meer dan chars en ints en dat soort dingen, want
als je dan overstapt van een pointer dat niet echt zinvol,
omschakelen belastingen, indien zelfs laten doe je dat, als gevolg van floating point
in precisie, zou je niet echt willen dat toch te doen.
Dus vrij veel, gewoon ints en chars en dat soort dingen.
>> DAN: Ja, het is als je expliciet hebt waarden die u weet, denk ik, kan zijn
dat een schakelaar is werkelijk nuttig.
Goed?
OK.
>> Scope is het bereik dat een verklaard variabele uitstrekt.
Dus in dit kleine stuk code die ik heb, het vol fouten zou zijn.
En de reden is dat ik verklaarde deze int i binnen de werkingssfeer van deze for-lus.
En dan probeer ik te verwijzen naar die ik buiten die lus scope.
>> Dus eigenlijk, kunt u na te denken over scope als iets dat je verklaren
met daarin een set van accolades alleen bestaat binnen de accolades.
En als je probeert te gebruiken die variabele buiten deze accolades, zult u
krijg een foutmelding van de compiler.
Yeah?
>> PUBLIEK: Dus dit niet werkt?
>> DAN: Dit werkt niet, ja.
Snaren.
String een char *.
Ze zijn precies hetzelfde.
Ze zijn gewoon verwijzingen naar karakters.
En alle strings die je moet eindigen met backslash nul, dat is gewoon
een c conventie.
>> Het heet de NULL terminator.
En NULL--
hoofdstad N, de hoofdstad U, hoofdstad L, hoofdstad L--
is niet hetzelfde als de NULL terminator.
Dit is een pointer.
Dit is een karakter.
Ze zijn zeer verschillend.
Onthouden.
Het zal op de quiz, waarschijnlijk.
Ik heb niet gezien dat de quiz.
Yeah?
>> Publiek: Dus NULL is, laten we zeggen, de wijzer?
>> DAN: Ja.
>> Publiek: Wat doet [onverstaanbaar]?
>> DAN: als, laten we zeggen, malloc wordt genoemd wanneer u niet genoeg geheugen om niet
ongeacht hun grootte je vraagt, malloc zal terugkeren NULL.
Het is, in principe, wanneer een functie verondersteld een pointer terug, je
moeten controleren tegen NULL omdat NULL is een mooie goed--
het is, een soort van, de vuilnis waarde.
Het is een nul zover pointers gaan.
>> Wanneer u een functie aan te roepen, dat geeft een pointer.
Je gaat te willen controleren om te zorgen dat die pointer niet NULL
omdat NULL is heel gebruikelijk.
Het is een soort van een vuilnisbak terugkeer.
Dus als er iets niet goed deed gaan, gewoon terug NULL plaats.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, en dat is dit.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Spell het als dit.
Het is de NULL terminator.
Het kleine N-U-L-L als je bent te spellen.
>> PUBLIEK: En ik ging gewoon heen en getest.
En als je probeert om een ​​floating point gezet waarde in een schakelaar, zal het tegen je schreeuwen
zeggen, verklaring vereist uitdrukking van integer type.
>> DAN: Daar ga je.
Maar ja, wat was de vraag ook alweer?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Dus hoofdstad N, de hoofdstad van U, de hoofdstad L, de hoofdstad L is een echte c ding.
Het is de NULL-pointer en zal alleen als zodanig worden behandeld.
Je zal nooit proberen en spellen het NULL karakter en zien geen
anders dan deze.
Yeah?
>> PUBLIEK: Dus terug naar char max of iets wat in de toelichting, zou het
belichamen dezelfde functie als [onverstaanbaar]?
>> PUBLIEK: Dus bent u verwijzen naar terug char max uit getchar, of
wat het ook is?
>> Publiek: Ja.
>> Publiek: Ja, dus de algemene term voor al die dingen
zijn sentinel waarden.
Dus als terugkerende int max van getInt en char max uit getchar, het is
verondersteld te zijn zoals, oke, als deze zaken zijn terug te keren naar ons,
ging er iets mis.
>> Voor tips, we hebben toevallig deze sentinel waarde die iedereen
stemt in met.
En dit is het ding dat je terugkeert als er dingen fout gaan.
Dus char max is wat we gebruiken iets vertegenwoordigen
zoals NULL of getchar.
>> PUBLIEK: Dus als u test getchar, kon je gewoon NULL?
Zou dat een verschil maken?
>> DAN: Je kon niet zomaar controleren NULL.
Je zou char max omdat de te controleren terugkeerwaarde van de functie
een personage niet een pointer.
Yeah?
>> Doelgroep: Deze vraag stelt voor de lengte van de string.
Doet dat de NULL karakter bevatten?
>> DAN: Nee
En dat is eigenlijk hoe tekenreekslengte weet stoppen omdat doorloopt
array van tekens tot hij ziet een NULL karakter.
En dan is het net als alle Goed, ik ben klaar.
>> PUBLIEK: [onverstaanbaar] vijf?
>> DAN: Hallo zou vijf zijn.
Yep.
Dus arrays continu geheugenblokken.
Ze hebben direct toegang door te zeggen dat de naam van de array en vervolgens, in krullende
bretels, welke index u wilt gaan aan, ze geïndexeerd vanaf nul tot
de lengte van de array minus 1.
>> En ze zijn verklaard door de aard van de ding dat je het opslaan in het
array, de naam van de array, en ongeacht de grootte is van die array.
Dus dit is een char array met lengte zes dat deze waarden heeft.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Als u wat er gaande in de matrix reeds.
Dus zou je dit in plaats opgeven als, zeg, char, wat ook de naam van uw
array lege haakjes geeft curly brace H komma E komma L komma L komma
O komma NULL karakter en accolade.
Dat zou ook werken als een verklaring.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Dan moet je hebben de grootte reeds.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja.
Alle righty.
Command line argumenten zijn een manier van het krijgen van input van de gebruiker als
argumenten naar hoofdpagina.
Hoofd heeft twee argumenten.
Het aantal argumenten dat wordt doorgegeven aan de command line en een
touw vector of een string-array van alle argumenten.
>> Als ik bijvoorbeeld zogenaamde functie als een punt uit 1 ruimte, 2 ruimte, drie,
argc zou zijn 4.
En de argv 0 zou een punt buiten te zijn.
Argv1 zou 1.
argv2 zou 2 argv3 zou 3, in dat specifieke geval.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Het laatste element in de array omdat de array lengte argc plus
een van aRGB, het laatste element is de NULL pointer.
Het is argc plus 1.
Dus in het geval dat ik al zei, het is gewoon zou worden argv 0 is een punt uit.
argv 1 is 1 argv2 is 2 argv 3 is 3.
argv 4, dat is een grotere dan argc NULL zou zijn.
>> En dat is de NULL-pointer.
Ja.
En dat komt omdat string een char ster is een pointer.
Dus moet hetzelfde type zijn.
Yeah?
>> PUBLIEK: Twee vragen.
Dus een, wat is het verschil tussen deze en andere dan een type GetString
in de gebruiker motor?
En twee, is het binnen opgeslagen Uw recente geschiedenis?
Dus als, GetString zou zijn [onverstaanbaar]?
>> DAN: Waar wordt het opgeslagen?
Ik weet niet waar het is opgeslagen.
>> PUBLIEK: Dus, eigenlijk, je weet hoe elke functioneren bel je het argumenten
worden opgeslagen in de stack?
Dus argc en argv zijn argumenten naar hoofdpagina en ze zijn op de stapel, of eigenlijk
net boven wat je denkt als het begin van de stack.
Wat was het andere deel van de vraag?
>> Publiek: Dus wat is het [onverstaanbaar]?
>> DAN: Ja, het is gewoon een andere manier op het krijgen van input van de gebruiker.
Deze is iets efficiënter en het is handiger voor scripts, omdat je
kan gewoon argumenten doorgeven aan uw belangrijkste functie in plaats van te moeten wachten
voor gebruikers als u niet beschikt over enige gebruikers.
>> PUBLIEK: En ja, krijgen strings zou zijn [onverstaanbaar].
Het zou de spullen die je nodig hebt op te slaan.
>> DAN: Ja?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, argv 0 bevat altijd de dot slash van de functie aan te roepen.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, elk van de argumenten zijn eindigde in NULL karakter, omdat ze
zijn strings.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, argv argc is een NULL-pointer.
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Oh ja.
Ja, sorry.
>> PUBLIEK: Dus [onverstaanbaar]?
>> DAN: Dus de vraag is als je had de opdrachtregel dot slash een punt uit 1, 2,
zou het aantal command line argumenten zijn twee of zou het drie?
>> Publiek: Ik denk het niet echt toe doen.
Ik ben geneigd om te zeggen, oh, je niet voorbij elke command line argumenten als,
natuurlijk, je de functie genaamd.
Dus heb ik de neiging om vocaal uit te sluiten van de functie vanaf de opdrachtregel
argumenten ook al is het opgenomen in argv.
>> DAN: Maar als het was op de test--
yeah-- en ook als je iets te zeggen zoals argc is gelijk aan 3,
je bent in een veilige staande.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ik denk dat als plaats van het aanroepen van deze in argc en strijkorkest argv beugels
maar hield dezelfde soorten en belde net ze iets anders zoals een
en b, zou het nog steeds werken?
En het zou nog steeds werken, je zou gewoon--
plaats van argc-- je zou gebruiken a en b.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Dus de vraag is GetString is naar geheugen in de heap
omdat GetString is char *.
Het slaat geheugen in de heap omdat vraagt ​​nu malloc binnen het feitelijke
uitvoering van GetString.
OK, over te gaan.
>> Beveiliging.
Dus om echt veilig te zijn, je vertrouwen op geen een en je niemand toegang tot staan
van uw gegevens, dat is de reden waarom iedereen bouwt hun eigen machines,
hun eigen besturingssystemen, al hun programma's van de grond af, en uiteraard
niet aansluiten op andere apparaten via het internet.
Dus computers zijn onzeker.
Ze werkelijk zijn.
We moeten andere mensen te vertrouwen.
>> En het idee van veiligheid is dat je bent proberen om de hoeveelheid te beperken
vertrouwen dat je nodig hebt.
En een van de middelen die u dat te doen is door middel van cryptografie.
Cryptografie is, in wezen, we hebben geheimen.
>> Soms moeten we onze geheimen passeren mee door, laten we zeggen, het internet of
andere dingen.
En we hebben geen mensen willen om deze geheimen te leren kennen.
Zo coderen we geheimen een manier waarvan we hopen dat niemand kan achterhalen.
>> Dus we used--
in de loop van dit class--
dingen zoals Caesar cipher en [Onverstaanbaar], die beide zeer, zeer
onveilige manieren van versleutelen dingen.
Ze zijn eenvoudig om erachter te komen wat ze zijn en wat je geheimen zijn.
De echte wereld gebruikt veel ingewikkelde encryptie schema.
En we gaan nu niet in veel meer dan dat.
>> Debuggen.
GDB is het beste.
Ik ga dit nogmaals benadrukken.
Gebruik GDB hele tijd elke keer als je een probleem hebt.
Commando's die nuttig zijn in GDB zijn breken, dat je ofwel een lijn passeren
nummer, een functienaam, in wezen waar in de code dat u wilt stoppen,
en in staat zijn om controle te nemen.
>> Print neemt een variabele en drukt wat dat ook variabel is op dat
punt in de uitvoering.
Vervolgens beweegt uw executie langs een stap.
En stap stappen in een functie in de uitvoering.
>> Andere dingen worden uitgebaat, dat is hoe u daadwerkelijk uitvoeren van uw code.
Doorgaan neemt alle stappen die nodig zijn naar de volgende onderbreking punt.
En er zijn vele, vele anderen.
Ze opzoeken.
Ze zijn geweldig.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja, dat is een debugger.
Dus een debugger is een programma dat kunt u uw programma te debuggen.
Het is niet een programma dat bugs vindt voor je zou al geweldig zijn.
>> En de laatste is voor mij zoeken.
Dus de soorten zoektocht die we gesproken over in deze klasse zijn lineaire zoeken,
dat is gewoon dat je door elke element van het zoekgebied, een
element in een tijd, totdat je wat vindt u zoekt of tot u bij
het einde van uw zoekopdracht ruimte waar wijzen u zegt dat u niet kon vinden
het element dat je zocht.
Dit duurt best constante tijd, die 0 of 1 en in het slechtste lineaire
tijd, die 0 of n.
>> Binary search, dat moet verachtelijke elementen.
Je gaat naar het midden van je elementen, zien of het element dat u zoekt
groter of kleiner is dan het element dat je in het midden.
Het het is groter, je zegt dat de bodem van uw zoekopdracht ruimte is uw
huidige locatie, in het midden, en u het proces opnieuw starten.
Als het kleiner is, je kijkt zeggen dat de-- ja, wat is er?
>> PUBLIEK: [onverstaanbaar]?
>> DAN: Ja.
Een soort van een soort die is onderwezen in de klas is eerlijk spel voor de test.
>> [Lachen]
>> DAN: En het feit dat je niet hebt gehad om het voor een probleem set te doen, het is eerlijk
spel voor de test.
>> PUBLIEK: Kunnen we gaan erover hoe om--
>> DAN: Het zal worden over gegaan.
>> SPEAKER 2: De daadwerkelijke code voor [Onverstaanbaar] is op study.cs50.net.
Dus als je kijkt naar de praktijk probleem in de merge soort pagina van
study.cs50.net, is de code voor de uitvoering samenvoegen soort.
Dus je hoeft niet te implementeren het zelf vanavond.
Maar zorg ervoor dat je het begrijpt in plaats dan onthouden is.
>> PUBLIEK: [onverstaanbaar]?
>> SPEAKER 2: De merge sort pagina op study.cs50.net er een praktijk
probleem is dat, als je door het klikken probleem, aan het einde is er een
oplossing die het samenvoegen soort implementatie.
Maar zorg ervoor dat je het begrijpt in plaats van alleen het onthouden
of kopiëren van het naar beneden.
>> PUBLIEK: En een volkomen geldig probleem voor het examen zou zijn
zoiets als hier is een lijst.
Wat doet deze lijst zien na een stap van selecties soort of
insertion sort of wat dan ook.
Een volledige iteratie van de lijst.
Dus zelfs als je uiteindelijk niet om code voor het, moet u om het te begrijpen
genoeg om te weten hoe het gaat te wijzigen van deze array.
>> DAN: Dat is het voor mij.
>> [Applaus]
>> LUCAS: Hey iedereen.
Mijn naam is Lucas.
Ik ga om te praten over recursie, alle de soorten die we hebben geleerd, en een
beetje alle pointers.
OK?
Dus in de eerste plaats, recursie.
Wat betekent het om te zeggen dat een functie is recursief?
>> PUBLIEK: Noemt zichzelf.
>> LUCAS: OK, noemt zichzelf, ja.
Dus graag deze foto, bijvoorbeeld.
Het is als het beeld van binnen van een beeld enzovoort.
Dus bijvoorbeeld, kunt u have-- als Dan die sprak over binary search.
Een manier waarop binary search is recursieve is het feit dat je bent
proberen een nummer.
Dus ga je naar het midden.
En dan moet je controleren of de nummers er in links en rechts.
>> En dan als je het nummer is gaat worden aan de linkerkant, het is hetzelfde
ding zo weer doen van de zoektocht, maar net aan de linkerkant van de lijst.
Dus dat is hoe het klinkt alsof het recursieve.
Dus dat is de reden waarom jullie hebben recursieve oplossing voor merge sort.
>> OK, dus hier is een voorbeeld.
Dus laten we zeggen dat ik wil kiezen alle getallen van 1 tot n.
Ik kan realiseren dat de som van de n nummer n plus n minus 1 tot 1.
Maar dan, als ik kijk naar n minus 1 plus n minus 2 plus 1, dat is hetzelfde
zoiets als het optellen van getallen tot n minus 1.
Dus ik kan de som van een gelijke som zeggen n gelijk plus de som van n minus 1.
Heeft dat zin?
>> En ik heb ook nog iets anders zou hebben riep het basisscenario, namelijk dat
de som van de getallen nul zou nul bedragen.
Dus zodra ik naar het nummer nul, ik stoppen met tellen.
Heeft dat zin?
>> Dus hier is een voorbeeld van hoe Ik kan implementeren die.
Dus ik heb deze functie in sommige.
Dat kost een geheel getal n.
Dus hier Ik check eerst als n minder of gelijk aan nul.
Als het minder of gelijk aan nul, I terug nul, dat is ons basisscenario.
Anders kan ik gewoon terug n plus de som van de getallen van
een tot n minus een.
Zinvol?
OK.
>> Dus hier is wat het lijkt.
Je hebt een bedrag van 2 gelijken 2 plus de som van 1.
En een aantal van 1 is 1 plus de som 0, die 0.
Zinvol?
Dus als we kijken naar de stapel van uw programma, dit is hoe het eruit ziet.
>> Ten eerste hebben we de belangrijkste functie.
En dan de belangrijkste functie genoemd bedrag 2.
En dan som 2 gaat zeggen, oh, som 2 gelijk is aan 2 plus de som van een.
Dus heb ik een bedrag van 1 toe te voegen aan de stapel.
En de som van 1 gaat naar som van bellen 0, die eveneens zal worden toegevoegd
de stack.
En dan elk van deze degenen die op elkaar moeten terugkeren
voor de anderen kunnen blijven gaan.
>> Dus bijvoorbeeld, hier, een bedrag van 0, Eerst, gaat terug 0.
En kies vervolgens een bedrag van 1.
Dan som van 1 gaat terug 1 op te sommen van 2.
En tenslotte, een bedrag van 2 gaat 3 terug naar de belangrijkste.
Heeft dat zin?
>> Het is echt belangrijk om te begrijpen hoe de stapel werkt en proberen te
te zien of het zinvol is.
OK, dus het sorteren.
Dus waarom is het sorteren van belang, Allereerst?
Waarom zouden we de zorg?
Anyone?
Geef mij een voorbeeld?
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Ja, OK.
Dus je kan efficiënter zoeken.
Dat is een goede manier.
Dus, bijvoorbeeld, hebben we veel van dingen, in feite, in ons leven, dat
gesorteerd.
Bijvoorbeeld woordenboeken.
>> Het is heel belangrijk om alle hebben woorden in een bepaalde volgorde die we
gemakkelijk toegang.
Dus dat is wat hij zei.
U kunt efficiënter zoeken.
Denk aan hoe moeilijk het zou zijn om een ​​hebben woordenboek waarin de woorden zijn in
willekeurige volgorde.
Je zult moeten kijken, vrij veel, elk woord tot u de
woord dat u zoekt.
>> Als u gebruik Facebook ook, wanneer u op zoek bent naar je vrienden, je bent
gaan om te zien dat Facebook zet je dichter vriend is op de top van degenen
dat je dat niet te doen praten veel.
Als je helemaal naar de onderkant van je vriendenlijst, je gaat om te zien
mensen die je waarschijnlijk niet eens vergeet niet dat je vrienden bent met.
En dat komt omdat Facebook soorten je vrienden op basis van hoe
sluit u zich bij hen.
>> Dus ordenen van gegevens.
Ook Pokemon.
Zo zie je dat alle Pokemons hebben nummers.
En dat is net als een makkelijk manier van toegang tot gegevens.
>> PUBLIEK: Toegang Pokemon.
>> LUCAS: Ja.
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Yep.
OK, dus selectie sorteren.
Selectie soort gaat het selecteren kleinste ongesorteerde waarde van een lijst elke
tijd in elke iteratie.
Het is net zoiets als het soort dat je doet in je hoofd als je probeert te
sorteren van een lijst bij de hand.
>> Kortom, alles wat je doet is je kijkt voor het kleinste getal.
Je zet het in de gesorteerde lijst.
En dan kijk je naar de volgende kleinste getal.
En dan houd je aan het doen die enzovoort.
>> Dus selectie soort is eigenlijk je selecteren wanneer de kleinste
ongesorteerd waarde.
Gebracht op het einde van de gesorteerde deel van de lijst.
En dat blijven doen.
Dus laten we snel kijken wat dit eruit ziet.
Dus hier is de gesorteerde en ongesorteerde lijst.
>> Dus voor de lijst van gesorteerd, Het is aanvankelijk leeg.
En dan ga ik naar de te selecteren kleinste aantal hier, dat is 2.
Dus ik krijg het nummer 2 en ik zet in de voorzijde van de lijst.
En dan kijk ik voor de volgende kleinste element, dat is 3.
Dus ik zet het op het einde van de gesorteerde lijst.
En dan houd ik dat doen.
Ik vind 4 en zet het op het einde.
Zoek 5 en zet het op het einde.
>> En kijken hoe al die keren dat Ik zeg zet het op het einde is,
principe, wisselen twee waarden.
OK?
En dan de laatste, je gewoon heb nog een element.
Dus het is al opgelost.
>> OK, dus insertion sort.
Insertion sort je gaat ook dat ding van het hebben van een gesorteerd en
een ongesorteerde lijst.
Het enige ding is dat elke keer dat je bent het toevoegen van een element aan de gesorteerde
lijst, je kies gewoon het element dat is in de voorkant van de ongesorteerde lijst.
En dan zul je wat vinden positie dient in de gesorteerde
deel van de lijst.
>> Laten we eens kijken wat dit is zo Dit heeft meer zin.
Dus in eerste instantie, bijvoorbeeld, probeer ik het nummer drie plaatsen in de
gesorteerde deel van de lijst.
Dus de lijst zegt niets te hebben.
Dus ik kan gewoon de nummer 3.
>> Nu wil ik de nummer 5 toe te voegen aan het gesorteerde deel van de lijst.
Dus ik kijk naar het nummer 5.
Ik merk dat het groter is dan 3.
Dus ik weet dat het moet zijn na 3.
Dus heb ik 3 en 5.
>> Dan wil ik de nummer 2 in te voegen.
Ik merk dat het nummer 2 is eigenlijk duren dan zowel 3 en 5.
Dus ik heb eigenlijk het hele zetten wijze het begin van de lijst.
Dus ik moet, soort, verschuiven alle elementen in de gesorteerde lijst, zodat ik kan
om ruimte te maken voor de nummer 2.
>> Dan zie ik het getal 6.
Ik zie dat het zou moeten zijn na 5.
Dus ik zet het daar.
En tot slot, ik kijk naar het nummer 4.
En ik merk het hoort tussen 3 en 5.
En dan heb ik het daar en verschuiving alle andere elementen.
Zinvol?
>> Bubble Sort.
Dus bubble sort is eigenlijk wat je bent ga doen-- we noemen het bubbel
soort omdat je door de list-- het is eigenlijk beter als ik laten zien
je dit--
en je gaat om te vergelijken aangrenzende nummers.
En je gaat wisselen hun posities als ze niet
in de juiste volgorde.
>> Dus eigenlijk, wat er gaat gebeurt is hier, bijvoorbeeld,
je hebt 8 en 6.
U weet dat de gesorteerde volgorde zal eigenlijk zijn 6 en 5, toch?
Dus je gaat om de bestellingen te wisselen.
Dan zie ik 8 en 4 hier.
En ik doe hetzelfde.
Ik swap weer.
En tenslotte, 2 en 8.
Ik ruil ze ook.
>> Het Bubble Sort omdat na genoemd elk van deze herhalingen, eigenlijk,
het grootste aantal in de lijst krijgt alle tot aan het einde van de lijst.
Heeft dat zin?
Want het houdt te verwisselen en het bewegen naar rechts.
>> OK, dus dit is de tweede iteratie.
Het zou hetzelfde zijn.
Ik zal een swap te doen en dan de laatste.
Ik dat er geen swaps en de lijst is gesorteerd.
Dus in Bubble Sort, in principe houden we gaan door de lijst en swapping
dingen totdat ik merk dat ik niet heb gedaan elke swaps doen dat iteratie, die
betekent deze lijst al gesorteerd.
Zinvol?
>> Laten we praten een beetje over het uitvoeren van de tijd.
Dus doen jullie herinneren Big O, Omega en Theta?
Yeah?
OK, wat Big O allereerst?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Ja, het is wel een worst-case runtime, die gewoon betekent dat het
hoeveel u het programma verwacht nemen lopen.
Zoals, in termen van--
in deze geval-- n.
Het aantal elementen in de lijst in het ergste geval.
Zoals, in het ergste geval.
>> Dus voor Bubble Sort bijvoorbeeld We hebben grote O van n plein.
Waarom hebben we dat?
Waarom is Bubble Sort Big O n plein?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Ja, dus het ergste geval zal zijn dat ik zal moeten n iteraties doen.
Dus elk van de iteraties zal breng het grootste element aan het einde
van de lijst.
Dus het ergste geval is dat ik om dat ding n keer doen.
En voor elk van die tijd, ik moet doe n swaps, want ik heb om te vergelijken
per twee elementen.
Dus dat is de reden waarom het is n kwadraat want het is n keer n.
>> Dan selectie soort is ook n plein want voor elke iteratie, ik moet
kijk naar elk element in de lijst.
En vinden dan de kleinste, wat betekent dat ik moet
kijk door n elementen.
En wat ik moet doen, dat n keer omdat Ik moet alle n elementen te selecteren.
>> Een insertion sort is ook n plein omdat het ergste geval zal
zijn, een, ik moet invoegen n getallen, toch?
Dus ik weet nu al dat ik ga N iteraties hebben.
Maar voor elk van deze nummers, als ik had om te kijken naar alle nummers in
de gesorteerde lijst en zet het helemaal voorin, zal dat n vierkant
Het zal immers n maal n weer.
Zinvol?
Hoe zit het met omega?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Het is het best case scenario.
Dus het is net als in een heleboel keer voor het sorteren, het best case scenario is
als de lijst al is gesorteerd.
Dus je hoeft niet echt om iets te doen.
Bubble Sort heeft de beste case scenario van n.
Weten jullie waarom?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Ja, als je bijhouden of de gegevens rantsoen had geen swaps of
niet, als je iets hebt als ingesteld op true als er een iteratie, wanneer de
lijst wordt al naargelang, in principe, wat er gaat gebeuren is dat ik ga
probeer te wisselen elke twee aangrenzende elementen.
Ik ga om te zien dat zijn er geen swaps.
En ik gewoon terug meteen.
>> Dus dat betekent dat ik moest gewoon gaan door de lijst een keer.
Dus het is n omdat ik kijk bij n elementen.
Waarom selectie soort n vierkant?
>> Ja, zelfs wanneer deze wordt gesorteerd voor elke iteratie van de selectie sorteren, I
moet de minimale element selecteren.
Dus dat betekent dat ik uit te kijken bij alle elementen in de ongesorteerde
overzicht en vind de minimale voor elke iteratie.
Heeft dat zin?
>> En insertie zwaard n omdat het geval dat ik probeer om het in te voegen
nummers en alle getallen, als ik proberen om ze in te voegen, zie ik dat ze
zijn in de juiste positie.
Ik hoef niet te gaan controleren alle andere nummers in de ongesorteerde lijst.
Dus dat is de reden waarom het n zal zijn.
Zinvol?
En wat is theta?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Wat, sorry?
Zeg het nog eens.
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Precies.
Dus je kunt dat alleen selectie te zien opgeslagen in Merge soort hebben Thetas.
En dat komt omdat je alleen maar theta als zowel Big O en Omega zijn hetzelfde.
OK.
En tot slot, samenvoegen soort is in log n.
>> En dan, als Dan zei, samenvoegen soort is net zoiets als op dezelfde manier als
je doet binair zoeken.
Dus krijg je de lijst.
En je gaat snijden in de helft.
En dan snijd ze je in kleinere helften.
En dan moet je ze samenvoegen.
Jullie herinneren dat, toch?
OK, zoals hij zei.
>> OK, pointers.
Dus wat is een pointer?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Een adres.
OK.
Ik weet dat David toont een stelletje video's van binky en dingen wijzen
elkaar.
Maar ik denk graag van pointers als slechts een adres.
Dus het is een variabele die gaat een adres op te slaan.
>> Dus het is gewoon deze speciale variabele dat vier bytes lang.
Vergeet niet, dat de wijzer iets is altijd vier bytes lang voor onze 32-bit
machine dus het geval met het apparaat.
En het heeft alleen de locatie een variabele erin.
>> OK, dus er is dit geheugen, eigenlijk.
Zodat elk blok van het geheugen heeft eigenlijk een label, het adres van de
slotty geheugen.
Dus dat betekent dat ik kan hebben een pointer die wijst naar
elk van deze adressen.
Dus de reden waarom we pointers zullen gebruiken is als ik naar de locatie te onthouden
dat een specifieke variabele een geheugen.
>> En jullie herinneren dat een van die gevallen was als ik een functie
als ik eigenlijk dat u wilt swap voor reals, ik eigenlijk
moet een pointer sturen.
Niet de variabele.
Herinneren jullie je dat?
Het verschil between--
wat is de naam?
Bellen met waarde en bellen aan de hand, toch?
>> OK, ja.
Dus bel naar waarde.
Als je stuur een variabele te functie je bent gewoon het verzenden van een waarde.
Dus je bent eigenlijk het verzenden Een kopie van de variabele.
En uw programma niet kon schelen ongeveer als dezelfde variabele eigenlijk
maakt een kopie.
>> En bellen aan de hand betekent dat Ik ben eigenlijk een kopie van de
pointer naar die variabele.
Dus dat betekent dat ik ben het verzenden van de plaats van die variabele.
Dus voel ik de locatie van de variabele, als ik roep de functie
met pointers, ik ben in staat om daadwerkelijk de gegevens die zich in hoofd veranderen.
Zinvol?
>> Hoewel, de wijzer is een kopie, het pointer nog de werkelijke adres
de variabele die ik wil veranderen.
Zinvol?
>> Dus het maken van pointers.
Vergeet niet, de wijzer altijd het type dat het wijzend
aan en dan een ster.
En dan zet je de naam.
Dus vergeet niet dat wanneer je welke ster, het is als een pointer naar
dat wat variabele typen die je had.
>> Dus hier in de ster, bijvoorbeeld, is het een pointer en een integer.
En dan char ster is een pointer char ster enzovoort.
Yeah?
>> Publiek: Wat als we een pointer naar n naar x ster.
Ik weet dat schept een pointer naar x.
Heeft het ook te verklaren x een geheel getal?
>> LUCAS: OK, dus als je zegt n ster x, je bent niet het maken van een pointer naar een
variabele x.
U bent het maken van een pointer met de naam x.
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Dus als ik zeg n ster x, ik ben zeggen, hey, in het geheugen, ik ga
krijgt een van deze drie vakken.
En ik ga om te zeggen dat dat zal x worden, hetgeen
naar een pointer.
En iets wetenswaardigs over pointers is dat we kunnen zeggen dat ze hebben
4 bytes voor een 32-bits machine.
En de reden daarvoor is omdat 4 bytes 32-bits.
>> En machines die 64 bits eigenlijk hebben pointers adressen
die 64 bits lang.
Dus het betekent alleen dat de grootte van de adressen in de machine afwijkt.
>> Dus Verwijzen en dereferentie.
Er zijn twee operators die jullie moeten onthouden.
De eerste is ampersand.
De tweede is ster.
Raak niet verward door die ster en deze ster omdat herinneren dat, in
dit geval, je hebt n ster.
>> Het is als een geheel samen.
Er is geen ruimte n ster.
Dus dat betekent dat het de soort.
Vergeet niet, dat wanneer je de variabele ster, je bent
praten over het type.
>> Als je gewoon ster en vervolgens de naam van de variabele, betekent dat
je dereferencing de aanwijzer, die betekent dat u op zoek bent naar de
wijzer, het vinden van het adres is het verwezen, naar dat adres,
en kijken naar waar je hebt daar.
Dus ik zeg tegen mijn studenten dat wanneer je ster, zou je denken dat het
de afkorting van de inhoud van.
>> Dus als je een pointer en u doen ster pointer, het is de
inhoud van de aanwijzer.
Dus ga je naar wat het ook wijzen op en kijken naar de constante inhoud.
En het is gelijk teken zoiets als het adres van.
>> Dus als ik een variabele a-- als, laten we zeggen dat ik int een evenaart 3--
als ik het adres van die vinden variabele een geheugen, kan ik gewoon doen
ampersand een.
Dus het is het adres van een.
Zinvol?
>> Dus hier is een voorbeeld.
Dit ontbreekt int b en int c.
Dus int een is gelijk aan 3 betekent dat Ik ga naar het geheugen.
En ik ga een slot vinden en zet het getal 3 hier.
>> En dan int b is gelijk aan 4.
Ik ga hetzelfde doen.
Ga naar het geheugen en zet een aantal 4 in een van de vakken.
En int gelijk aan 5.
Zoek een andere doos en zet een nummer 5.
>> Dus wat is deze lijn aan het doen? n ster pa gelijk aan een ampersand.
Dus in de eerste plaats, n ster pa.
Wat doet het?
>> PUBLIEK: [onverstaanbaar].
>> LUCAS: Ja, dus n ster pa, eerste, verklaart een pointer genaamd pa.
En dan is het toewijzen van de waarde van die pointer naar het adres van een te zijn.
Dus een ampersand.
Dan, als ik dat doe ster pb, wat is een ster pb?
>> Oh, sorry.
Dit wordt ook vermist. n ster pb.
Ik bedoel ster pc.
Het spijt me zo.
Het is hetzelfde ding.
Maar nu ben ik goed ar maken van een pointer naar b en dan een verwijzing naar c.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Ja.
Dus als je naar het geheugen en ga je naar het vak dat is aanduiding voor pa,
je in feite gaat om zie het adres van een.
OK?
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Ja, wijzer is een adres.
Vergeet nooit dat.
Het is als het belangrijkste deel over pointers.
Er opslaan en adres enkele variabele.
Iets anders?
Een andere vragen?
OK.
>> Dus Pointers en arrays.
Vergeet niet dat als ik dat doe int rij 3, in principe, wat ik doe is dat ik, soort
van, verklaren in een pointer.
Dus array is net zoiets als een pointer naar een specifieke plaats in het geheugen waar ik
drie slots toegewezen integers.
Heeft dat zin?
>> Dus als ik het doe int rij 3, wat ik ben Daarbij principe, creëert drie
sleuven in geheugen.
Dus ik vind slechts drie sleuven in het geheugen.
Dus als ik dat doe, dan een ster array, het betekent in feite de inhoud van de array,
wat betekent dat ik de pointer te wissen, ik ga naar die plaats dat het wijst naar,
en ik zet de nummer een.
>> En dan, als ik dat doe ster reeks plus 1, dat is hetzelfde als het doen scala
beugels een, die gewoon betekent dat ik ga naar de plaats die het wijzend op.
En dan de plus 1 merken me verschuiven een positie.
Dus ik ga naar deze positie, in feite, en zet de nummer twee.
>> En dan, tot slot, als ik dat doe serie plus 2, ga ik naar de plaats waar
wijzend matrix bij.
En toen ik naar het geheugen blokken.
En dan heb ik het nummer drie hier.
Yeah?
>> PUBLIEK: Dus ster array is gewoon zeggen de allereerste punt.
En u kunt toevoegen 1, alleen maar omdat we zijn pas echt
verwijzen naar dat eerste adres.
>> LUCAS: Ja.
Waarom hebben we bijvoorbeeld zeggen reeks 0, serie 1 en serie 2?
Ik zeg, waarom doe je dan 0, 1, 2, 3 in plaats van 1, 2, 3?
Een van de redenen is, een computer programmeurs beginnen het liefst
tellen vanaf 0.
Twee is want als je scala 0 doen, het is hetzelfde als het doen scala
plus 0, wat betekent dat ik ga naar die positie, en ik niet
skip elke geheugen blokken.
Dus ik weet niet verplaatst geheugen blokken.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Dus ze vraagt ​​wat is het verschil tussen doen
dit of doet malloc.
Een van de verschillen is dat int rij 3 is het creëren van een
serie op de stapel.
En toen ik malloc doen, het creëert op de heap.
Heeft dat zin?
>> Dus hoe werkt malloc eigenlijk?
Dus waarom moeten we zelfs naar malloc gebruiken?
Je compiler soort figuren uit alle de variabelen die u gedeclareerd.
En hij schept ruimte voor alle van hen in de stapel.
Dus al je variabelen gaan ergens in de stack.
Dus hier is de omgevingsvariabelen.
>> Dus eigenlijk, ruimte voor die variabelen in het geheugen is toegewezen aan
compileren.
Het betekent dus dat uw computer al die variabelen kent
vooraf.
Het hoeft niet te weten wat de waarde je gaat in hen te zetten.
Maar het moet weten hoe hoeveel geheugen je nodig hebt.
>> Maar nu laten we zeggen dat, bijvoorbeeld, je het creëren van een array of het nemen van een
snaar die je neemt van de gebruiker.
Je weet niet hoe lang de string gaat worden, bijvoorbeeld.
Dus je weet niet precies hoeveel memory blocks u wijzen, toch?
>> Dus het maakt niet echt zinvol voor je zeggen zet 100 karakters.
En wat als de gebruiker schrijft 150?
Je gaat om te worden geschroefd.
>> Dus eigenlijk kun je niet zeker zijn van hoe hoeveel geheugen je nodig hebt om te wijzen
wanneer u het programma samen te stellen.
Je weet gewoon dat op de looptijd.
Dus dat is de reden waarom u de heap.
Dus de heap gaat geheugen dat u tijdens het bent toewijzing
duur van het programma draait.
>> Dus eigenlijk, als je malloc doen, wat je doet is het toewijzen van geheugen aan
runtime, wat betekent dat je beslissen precies op dat moment dat je
moet die geheugen.
Dus dat is als je het toewijzen van het.
Heeft dat zin?
>> Dus denk eraan, de stapel heeft variabelen die zijn gemaakt op het compileren.
En dan is de hoop heeft variabelen die ontstaan ​​als je gaat
met malloc bijvoorbeeld.
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Dus GetString is naar malloc bellen.
Laat me praten over malloc, en Ik zal GetString uitleggen.
Dus malloc is hetzelfde zoals het toewijzen van geheugen.
Dus het gaat om toe te wijzen geheugen op de heap.
En het gaat om een ​​pointer terug te keren naar waar dat geheugen is toegewezen aan.
>> Dus als je doen--
hier voor example--
n ster pointer.
En dan wijzer gelijk aan malloc afmeting van 10 inch tijden.
Ik ben het creëren van een pointer.
En dan heb ik het toewijzen van die pointer naar de waarde van de pointer die malloc
geeft me.
>> Dus ik vraag malloc kunt u toewijzen space 10 integers.
Dat is wat het zegt.
En malloc geeft me weer een pointer naar die plaats.
Zinvol?
OK.
Ik En GetString is, in principe, een doen bellen om malloc zodat u kunt toewijzen
geheugen tijdens runtime.
>> Altijd onthouden om te controleren op null omdat malloc gaat null terug
indien geen geheugen kan toewijzen.
Laten we zeggen dat je vraagt ​​voor een belachelijke hoeveelheid geheugen.
Uw computer is niet van plan te zijn kunnen wijzen dat veel.
>> Dus malloc wordt gewoon om terug te keren null.
Dus altijd onthouden om te controleren of de pointer die je kreeg van malloc is
null of niet omdat, als het is, zou je worden dereferentie een pointer en
waardoor zij fouten.
En tot slot, vergeet niet uw geheugen vrij.
>> Malloc is het creëren van het geheugen in de heap.
En je moet het geheugen vrij voordat het programma is afgelopen.
OK, dat is alles voor mij.
Sorry, Rob.
Bedankt.
>> [Applaus]
>> LUCAS: Elke laatste vragen voordat Rob komt?
Nee?
Yeah?
>> Publiek: Ik zag het niet deze online.
Heb je het nog geupload?
>> LUCAS: Ik denk dat Dave is snel te uploaden.
>> DAVE: Het zal worden geplaatst.
>> LUCAS: Het zal online zijn.
>> Publiek: Het is.
>> LUCAS: It's up?
OK.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Ja, moet je bevrijden van alle geheugen die wordt gezet in de hoop.
>> PUBLIEK: [onverstaanbaar]?
>> LUCAS: Ja.
Elke keer dat je een cultuur malloc, moet je een cultuur vrij hebben
nadat u stopt met het gebruik van die variabele.
Dus malloc en gratis zijn altijd samen.
Hun beste vrienden.
Yeah.
Rob?
>> ROB: Ik zal snel gaan.
En ook de video zal worden opgemaakt.
Ik heb de microfoon op.
>> OK, dus week vijf dingen.
Het eerste wat we hebben is de stack.
Dus vergeet niet dat er maar een stapel frames per actieve functie oproep.
We zullen zien dat in een tweede.
En ook niet vergeten wat er werkelijk gaat in elk stackframe gaan worden
de lokale variabelen van onze functies de argumenten die worden doorgegeven aan onze
functies, samen met een partner andere dingen die je echt niet
zorgen te maken over.
>> Dus hier is een voorbeeld programma, waar, kennisgeving, de belangrijkste is printfing de terugkeer
waarde van foo 4.
foo is gewoon naar de terugkeer waarde van de bar 4 komma 6.
En de bar gaat om enkele lokale ingesteld variabele n gelijk aan 4 maal 6.
En dan terug n.
>> Dus laten we eens kijken naar de stapel hele de feitelijke variant van dit programma.
Dus er is de bodem van onze stack.
Vergeet niet dat de stapel opgroeit.
Dus onderaan het stack, we hebben een stack frame voor main.
Wanneer het programma start, de belangrijkste altijd zal zijn op de
bodem van het stack.
>> En wat is de binnenkant van onze stack frame voor main?
Dus hoewel er geen lokale variabelen bij de belangrijkste, zoals ik al eerder zei,
we hebben argc en RGV toegang tot de ruimte binnenzijde van de belangrijkste stack frame.
Dus main gaat nu bellen met de functie foo.
En dat betekent dat foo gaat krijgt zijn eigen stack frame.
>> Dus nu zijn we de binnenkant van de functie foo.
En wat moet er in gaan foo's stackframe?
Nou, foo heeft een argument n.
En n gelijk is aan 4 want dat is wat belangrijkste is het passeren als argument foo's.
>> Dus nu foo gaat bar noemen.
Wat is de bar gaat naar binnen te hebben van haar 'stackframe?
Het is x gelijk aan 4 y gelijk aan zes.
Dat is niet alles dat we gaan te hebben in de stackframe omdat bar
heeft ook een lokale variabele n.
En n we gaan gelijk aan 24 in te stellen.
>> Dus nu bar gaat terug n.
Dus bar keert terug naar 24 de stackframe foo.
En omdat de bar is nu terug, dat betekent dat we knallend het stackframe
voor bar af van de stapel.
Dus al het geheugen die bar was geweest gebruikt, is nu uit de stapel.
>> Nu, foo gaat ook tot 24 terug te keren naar de belangrijkste.
Dus nu dat foo terugkeert, het geheugen dat foo gebruikte in zijn '
stackframe is ook weg.
En nu, de belangrijkste gaat printf bellen.
Dus printf is gewoon een andere functie.
Toen we printf noemen, gaat het om een andere stack frame voor de printf
functie-oproep.
>> Wat zijn we passeren printf?
Dat is wat er aan de hand om te gaan op de stack frame.
Op zijn minst, we passeren dat percentage i backslash n en
het argument 24.
Het is misschien meer hebben in het stapelframe als printf gebeurt te zijn met behulp van enkele
lokale variabelen.
We weten het niet.
>> Maar dat alles gaat in printf's stack frame.
Het gaat om de printf voeren.
Dan printf gedaan.
Het zal terugkeren.
Tot slot, de belangrijkste is gedaan.
Belangrijkste zal terugkeren.
En dan is dit programma geschreven is.
Yeah?
>> PUBLIEK: Ziet u [onverstaanbaar]
argumenten [onverstaanbaar]
parameters?
>> ROB: Dus er is een subtiel verschil tussen argumenten en parameters.
En echt, gemeen spreken, mensen de neiging om gewoon meng ze de hele tijd.
Maar de parameters zijn de formele noemen van de dingen.
>> Dus argc en argv zijn de parameters bij de belangrijkste.
Argumenten zijn wat je eigenlijk passen in die parameters.
Dus er als ik bel foo van 4, 4 is het argument dat ik passeren in.
En de parameter n, binnenin foo, neemt de waarde 4
sinds 4 was het argument.
>> PUBLIEK: [onverstaanbaar]?
>> ROB: n is een lokale variabele naar bar.
n is nog steeds lokaal naar foo, maar het is een parameter om foo.
Het is niet een lokale variabele.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: foo is gewoon bellen bar en terug wat bar rendement.
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Ja, gewoon om te zien meerdere stack frames.
Yeah?
>> PUBLIEK: Waarom werd foo genoemd voordat printf?
>> ROB: Waarom was foo aangeroepen voordat printf?
Dus ik zou kunnen hebben, in plaats daarvan, iets gedaan zoals int x gelijk foo van 4
en vervolgens afgedrukt x.
Maar ik samen de functie roepen in de printf argument.
>> Maar merk op dat we kunnen eigenlijk niet de oproep om printf totdat we uitvoeren
erachter te komen wat foo van 4 is.
Dus gaan we dit evalueren.
En maar een keer dat gedaan gaan om terug te komen en te evalueren dit.
Yeah?
>> PUBLIEK: Aangezien beide bar [onverstaanbaar]
waarde, waarom hebben we niet [onverstaanbaar]?
>> ROB: Ze moeten helemaal int.
Dat werd niet gevangen dan meerdere passages.
Dus het moet int bar en int foo aangezien deze beide
keren terug integers.
Leegte is alleen als ze niet gaan de werkelijke waarden terugkeren.
Yeah?
>> PUBLIEK: Als u een lijn gehad boven het rendement, [onverstaanbaar]?
>> ROB: Een lijn boven het rendement?
>> Publiek: Ja.
Net als je dat deed printf en [onverstaanbaar], zou het twee keer af te drukken?
>> ROB: Dus binnenkant van foo?
Als we een printf hier?
>> Publiek: Ja.
>> ROB: Dus als we een printf recht Hier zou het eenmaal drukken.
Aangezien wij roepen foo keer rechts hier, dan zullen we de printf geraakt.
Dan zullen we bar noemen.
En dan zal foo terugkeren.
En dat is het.
We alleen ooit tegenkomen de printf eens.
Yeah?
>> PUBLIEK: [onverstaanbaar]
printf bellen foo omdat we eerst bellen printf en dan gaan we voorbij
de argumenten.
>> ROB: Dus in theorie, is niet printf bellen foo?
Dus geen.
Alleen de volgorde waarin c gaat voeren deze dingen is, voordat we kunnen
bel een functie alle argumenten om de functie te
volledig worden geëvalueerd.
Dus is dit volledig geëvalueerd?
Ja, het is gewoon een string.
Het is gewoon een waarde.
>> Dan moeten we helemaal evalueert deze.
Zodra dit is gebeurd, nu al haar argumenten worden geëvalueerd.
En nu kunnen we het maken bellen om printf.
Yeah?
>> Publiek: Een vraag.
Als je een leegte functie, moet je terugkeer puntkomma?
>> ROB: Je hoeft niet een terugkeer puntkomma als je een leegte functie.
OK.
Dus nu wat hoop spullen.
Dus hoop is hoe we omgaan met dynamisch geheugenbeheer.
En direct contrast met de stack die we automatisch zouden noemen
geheugenbeheer.
>> Dus op de stapel, je nooit echt hebt te behandelen hoe de lokale variabelen
worden geduwd en knalde uit alle Deze stack frames en al dat spul.
U hoeft geen zorgen te maken over het.
Het is automatisch.
Dus de hoop is handmatig.
En de [onverstaanbaar]
komt deze functies malloc en gratis.
>> Dus hier is een ander programma.
Alles wat we aan het doen zijn is mallocing een integer.
We zijn het opslaan van in ster x.
Natuurlijk, we moeten controleren om te zien of x is null.
Dan gaan we gewoon stellen wat x wijst naar 50.
Print wat x naar wijst, afdrukken x, en dan vrij x.
>> Dus hoe is dit eigenlijk gaan kijken als we kijken naar onze stack en heap?
Dus zullen we opnieuw beginnen.
De bodem van het stack als voorheen.
Vergeet niet dat u heap direct verzet zich tegen de stapel?
Dus we gaan het hebben top van onze hoop daar.
>> Dus de bodem van het stack, we onze stack frame voor main.
Het heeft de ruimte voor argc, argv, en we nu een lokale variabele x, die
is een int ster.
Dus we gaan herhalen via dit programma.
Het eerste wat we hebben is een oproep tot malloc.
>> Dus we maken een oproep tot malloc.
Malloc is een functie.
Het gaat om een ​​stackframe krijgen.
Wat moeten we doorgeven aan malloc?
Dat gaat naar binnen te gaan van de stack frame.
We passeren de grootte van n, dat is 4.
Dus dat wordt doorgegeven aan malloc.
>> Wat doet malloc doen?
Het grijpt ons wat ruimte op de heap.
Dus we gaan naar de heap.
En we gaan om te grijpen 4 bytes van de hoop.
Dus laten we gewoon dat een willekeurig adres.
0x123 Net doen alsof is een adres dat op de heap.
>> Dus wat is eigenlijk de binnenkant van dat regio van het geheugen op adres Ox123?
Garbage.
Dus hebben we niets in het opgeslagen.
Dus voor zover wij weten, het kan van alles zijn.
Je moet er niet van uitgaan dat het nul.
Het is zeer waarschijnlijk niet nul.
>> Dus nu malloc rendement.
En wat doen we als malloc terugkeert?
We stellen wat het rendement.
We stellen x gelijk is aan wat Het is terug te keren.
Dus wat is het terug?
Het is de terugkeer 0x123 want dat is de adres van het geheugenblok dat
net toegewezen in de heap.
>> Dus terug 0x123 x gaat nu vastgesteld gelijk aan 0x123 die pictorially,
we vaak trekken als x met een effectief pijl wijst naar dat blok.
Maar x is gewoon het opslaan van dat adres.
Dus nu moeten we controleren of x is null.
Het is niet null.
We doen alsof dat malloc gelukt.
>> Dus nu ster x is gelijk aan 50.
Dus ster herinnert het betekent ga naar dat adres.
Dus 0x123 We gaan ga naar dat adres.
Dus dat brengt ons daar.
Wat doen we op dat adres?
We zijn het opslaan van 50.
>> Dus na deze regel is dat wat dingen gaan uitzien.
Dus nu is het niet meer garbage daarboven.
Nu weten we dat 50 is in dat bijzonder adres, omdat
We stellen het op dat.
OK?
Dus nu gaan we om f te drukken.
>> Dus eerst gaan we ster x drukken.
Dus wat is ster x?
Nogmaals, ster x betekent ga naar het wat x wijst.
Dus x is het opslaan van 0x123 Ga naar dat.
We krijgen 50.
Dus printen f dat.
En dat betekent dat het gaat om af te drukken 50.
En dan dat terugkeert.
>> En dan hebben we het tweede printf.
We zijn nu procent p.
Als je het niet hebt gezien, dat is hoe je een pointer te drukken.
Dus we hebben procent i, procent f, en al die reeds.
Dus procent p, drukt u een pointer.
>> Dus x is een pointer.
Dus als we gaan printen x zelf, we afdrukken wat is eigenlijk binnen
x, waarvan de eerste is 0x123 dus afdruk f gaat om af te drukken 50.
De tweede druk f gaat om af te drukken 0x123 Yeah?
>> PUBLIEK: Heb jij procent gebruiken x om een ​​pointer te drukken?
>> ROB: Dus denk je procent gebruik x om een ​​pointer te drukken?
Zo kun je maar x procent is gewoon, algemeen, voor als als je wat
integer en u wilt afdrukken als een hexadecimaal.
Dat is gewoon hoe je dat doet.
>> Overwegende procent d zou afgedrukt als decimaal.
Dat waren we krijgen procent d. i is gewoon integer.
procent p specifiek voor de pointers.
>> Dus x is een pointer.
We willen procent p.
Maar procent x zou kunnen werken.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Ja.
Tenminste voor deze call-- dus niet opnemen in hier.
Maar deze twee argumenten zijn noodzakelijk binnenkant van deze stackframe
naast de lokale variabelen printf gebeurt te gebruiken.
En dan de volgende oproep om nu printf binnenkant van printf stack frame is
procent p backslash n en wat de waarde van x is, die 0x123.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Het zal iets te printen dat ziet er zo uit.
>> PUBLIEK: [onverstaanbaar].
>> ROB: het drukt het dus in de adresbalk van vorm.
Het ziet eruit als een adres.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Waarom is het wat?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Waarom is dit pointer 4 bytes?
Dus er zijn een hele hoop van 0's voor deze.
Dus het is echt 0x0000000123.
Op een 64-bits systeem, zou er een hele hoop meer nullen.
Yeah?
>> PUBLIEK: [onverstaanbaar].
>> ROB: Dus de eerste printf gaat print--
>> PUBLIEK: [onverstaanbaar].
>> ROB: Ja, het gaat om af te drukken x wat wijst.
Star zegt wat is dit ding wijst.
Pak het.
Dus wat is het verwijzen naar?
50.
Pak het.
Dat is wat we gaan om af te drukken.
Overwegende dat de volgende, we zijn gewoon afdrukken x zelf.
Wat is de binnenkant van f?
0x123.
OK.
>> En dan, ten slotte, hebben we de vrije.
Wat moeten we overgaan tot gratis?
We passeren x.
Die tijd heb ik eigenlijk getoond in de stack frame.
>> Dus we passeren van de waarde 0x123 vrij.
Dus nu gratis weet, oke, Ik moet gaan naar de heap
en gratis dat geheugen.
Het wordt niet meer gebruikt, wat is op het adres 0x123.
>> Zo vrij gaat los dat van de hoop.
Nu is onze hoop is weer leeg.
We hebben geen geheugen lekken.
Nu vrij zal terugkeren.
Merk op dat x is nog 0x123.
Maar dat is nu niet geldig geheugen.
We moeten niet langer dereferentie x.
Yeah?
>> PUBLIEK: Is return 0 overbodig?
>> ROB: Is returen 0 overbodig?
Ja.
We zetten gewoon dat er vanwege we hebben een terugkeer een voor lucht.
Dus het is net als, ja, laat onder meer de return 0.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Dus na free x, wat gebeurt er als we proberen om dereferentie de wijzer?
Het is mogelijk dat er niets mis gaat.
Het is mogelijk dat we nog steeds 50.
>> Het is mogelijk, ook, dat dat het geheugen is nu gebruikt voor iets anders.
Dus het is onbepaald gedrag.
En ongedefinieerde iets betekent kan gebeuren.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Nee, dus als je toewijzen x naar iets anders.
Dus als hier hebben we gezegd x gelijk malloc iets anders--
malloc grootte event--
dan is dat originele blok geheugen wordt niet vrijgegeven.
En wij hebben officieel kwijt.
Dat is een geheugenlek.
We hebben alle verwijzingen verloren dat geheugenblok.
Dus er is geen manier kunnen we ooit bevrijden.
OK, dus dan terug 0 middel gedaan.
>> Oke, dus stack overflow.
Wat is het idee hier?
Dus vergeet niet, is hoop naar beneden gaat.
Stack gaat omhoog.
Dus dit was het voorbeeld van lezing, Ik denk dat, waar de belangrijkste is gewoon om
noemen deze functie foo, die gaat zichzelf recursief bellen over en
opnieuw.
>> Dus stack frames gaan werken precies hetzelfde.
Dus we gaan om te beginnen met de belangrijkste de onderste stapel frame.
Dan belangrijkste gaat foo noemen, die gaat een stackframe krijgen.
>> Dan foo gaat foo noemen weer, die gaat krijgen
een andere stack frame.
En dan opnieuw, en opnieuw, en opnieuw, en weer tot, uiteindelijk, we lopen
in de heap.
Dus dit is hoe we een stack overflow.
En op dit punt, je Seg fout.
Of je zou echt seg fout voordat dit punt, maar ja.
>> PUBLIEK: Is kern dump de hetzelfde als seg fout?
>> ROB: Zo zie je segmentatie schuld kern gedumpt.
Je krijgt een core dump wanneer je Seg fout.
En het is als een dump van alle inhoud van je huidige geheugen, zodat
dat je kunt proberen en te identificeren waarom je Seg verweten.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Dus een segmentation fault middel er is een stack overflow.
Dus niet per se.
Een segmentatie fout betekent dat je bent raken geheugen wijze
moet je niet zijn.
Dus een manier dat zoiets gebeurt is, wanneer je stack overflow, we beginnen te raken
geheugen zodanig dat we niet moeten zijn.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Dus binnen van een oneindige lus.
Als, dit is als een recursieve oneindige lus en dus een ander krijgen we
stackframe elke keer.
Maar binnen van bijvoorbeeld een oneindige terwijl een--
goed, laten we het nog niet eens af te drukken F--
iets doen.
Whatever.
>> We zijn niet van plan te zijn om een andere stack frame.
We gaan gewoon looping houden meer dan deze ene instructie.
De stapel groeit niet.
Het is het feit dat elke recursieve oproep geeft ons een stapel frame.
Daarom krijgen we een stack overflow.
Yeah?
>> PUBLIEK: Dus als je tegen het krijgen while lus en dan [onverstaanbaar]?
>> ROB: Dus als binnenkant van de while loop er was een printf, je nog zou
niet seg fout.
Ik heb gewoon geen zin om dingen te verwarren.
Het zou loop.
Je zou een enkele stack krijgen Frame voor de printf.
>> Dan printf zou terugkeren.
Dan weer zou je lus.
Je zou een enkele stack krijgen Frame voor de printf.
Het zou terugkeren.
Single stack frame.
Dus je krijgt niet deze oneindige opstapelen stack frames.
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Ja.
Dus deze stack overflow gebeurt omdat geen van deze
oproepen tot foo terugkeren.
Dus als we terugkeren, dan zouden we beginnen te verliezen stack frames.
En dan zouden we niet stack overflow.
En dat is waarom je een base case nodig voor uw persoonlijke functies.
Yeah?
>> PUBLIEK: Is de potentiële omvang en de stack voor heap hetzelfde voor
alle programma's?
>> ROB: Ongeveer.
Is de potentiële omvang van de stack en de hoop hetzelfde voor alle programma's?
Ruwweg.
Er is enige randomisering waarbij de stapel begint en
waarbij de heap begint.
Als je toevallig een heleboel hebben globale variabelen en dingen, zou je
weg te nemen van wat ruimte voor uw heap.
>> Op een 64-bits systeem, u vrijwel oneindige geheugen.
Er is gewoon zo veel.
Tussen 32 bits en 64 bits, dat is een significant verschil.
>> Je gaat een heleboel meer te krijgen stack en heap ruimte op een 64-bit
systeem, want er is gewoon meer adressen die ze kunnen gebruiken.
Maar individueel systeem, zal het ruwweg evenveel stack
en hoop ruimte.
Oke.
>> Dus laatste ding is compilatie.
Dus je moet dit proces te leren kennen.
Er zijn vier grote stappen.
Dus de eerste moet men zijn gemakkelijk te onthouden.
Pre-processing.
Het heeft de prefix vooraf daarin.
Dus het gaat voor alles.
>> Het ding om te onthouden is de hash.
Dus hash definieert en hash bevat in al deze.
Dat zijn alle pre-processor richtlijnen.
Dit zijn de dingen die de pre-processor zorgt.
>> Dus wat doet een pre-processor doen?
Het is echt een dom ding.
Al is het in staat zijn al deze kopiëren en knippen en plakken operaties.
>> Dus hash bevat standaard i0 dot h.
Wat is dat nou?
Het grijpen van de standaard i0 dot h dienen en te plakken in de top
waar het zegt hash bevat standaard i0 dot h.
>> En elke hash definiëren dat we hebben gezien, wat is dat?
Het kopiëren van de waarde die de hash gedefinieerd wordt gedefinieerd als en plakken dat
waar u de waarde.
Dus de preprocessor doet gewoon echt eenvoudige tekst-gebaseerde bewerkingen.
Het doet niets slim.
Dus al het andere is ingewikkelder.
>> Dus nu dat preprocessor is gedaan, we eigenlijk samen te stellen.
Dus wat doet het compileren betekenen?
We gaan nu van C-code naar assembly code.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Ja, we gevangen dat.
Dus samenstellen.
We gaan van c naar assembly.
Dus dit is een taalverandering.
Zelf het samenstellen betekent gaande van een hogere taal
lager taal.
>> En c een hogere programmeertaal tegenover assembly.
Wat is de montage?
De instructies die zijn, vrij veel, gemaakt voor uw CPU.
Maar uw computer nog steeds doet niet begrijpen assemblage.
Hij begrijpt alleen enen en nullen.
Dus de volgende stap is het samenstellen van die brengt ons uit deze instructies dat
je CPU begrijpt en eigenlijk vertaalt deze naar
de enen en nullen.
>> Dus C tot assemblage naar binair.
Maar ik wil niet nog een uitvoerbaar zijn.
Dus denk aan de CS50 bibliotheek.
Wij hebben u een binaire voor deze CS50 bibliotheek, die GetString heeft
en getInt en zo.
>> Maar de CS50 library--
in en van itself-- is niet uitvoerbaar.
Het hoeft niet een belangrijke functie.
Het is gewoon een stelletje binaire die u kunt gebruiken.
Dus linking is hoe brengen we samen alle Deze verschillende binaire bestanden
in een werkelijke uitvoerbaar.
Een die je kunt typen dot slash een punt uit.
>> Dus dit is als het bestand dat u schreef, - ongeacht uw programma is--
Ceaser dot c.
Maar nu is het samengesteld omlaag naar binair.
Dus Ceaser dot o.
En dit is onze CS50 bibliotheken binaire.
En ze worden gecombineerd in een enkel uitvoerbaar.
Yeah?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Dus eerst opnemen, onthouden, de hash bevatten is eigenlijk een
pre-processor stap.
Maar dat is apart.
Als je geen enkele functie gebruiken die zijn buiten uw enkel bestand dan,
nee, je hoeft niet om iets te linken omdat je alles.
>> Dat gezegd hebbende, printf wordt gekoppeld.
Als je ooit gebruik printf, dat is iets dat moet worden gekoppeld
omdat je niet schrijven dat.
En in feite printf automatisch gekoppeld.
Je weet hoe op de opdrachtregel of wanneer u typt te maken, zie je het hebt
dash l CS50, dat verband heeft in de CS50 bibliotheek?
Printf, en dat soort dingen, gaat automatisch worden gekoppeld.
Andere vragen over iets?
>> PUBLIEK: [onverstaanbaar]?
>> ROB: Linking?
We hebben een hele hoop verschillende binaire bestanden.
Dit is de canonieke voorbeeld dat we gebruiken is CS50 bibliotheek.
We hebben samengesteld en aan u gegeven de binaire voor deze CS50 bibliotheek.
>> U wilt GetString gebruiken in uw programma.
Dus je gaat en gebruiken GetString.
Maar zonder mijn binaire code voor GetString, wanneer u uw code te compileren
naar beneden, kun je eigenlijk niet uitvoeren van uw programma, omdat GetString String is
nog niet volledig gedefinieerd.
>> Het is pas wanneer je een link in mijn binaire dat bevat GetString dat nu alle
recht, kan ik eigenlijk voeren GetString.
Mijn dossier volledig is.
En ik kan dit uit te voeren.
Yeah?
>> PUBLIEK: Is het linken omzetten de binaire naar uitvoerbaar?
Dus zelfs als je geen andere hebben bibliotheken, zou het nog steeds
moet vertalen de [onverstaanbaar]?
>> ROB: Dus een uitvoerbaar nog in binair.
Het is gewoon een combinatie van een hele stelletje binaries.
>> PUBLIEK: Dank je wel.
>> ROB: Geen probleem.
Een andere vragen?
Anders zijn we helemaal klaar.
Oke.
Bedankt.
>> [Applaus]
>> PUBLIEK: Dank je wel.
>> ROB: Ja.