Tip:
Highlight text to annotate it
X
>> HÖGTALARE 1: Hej alla.
Vi kommer att komma igång.
Jag tror att folk fortfarande kommer att filtrera i.
Men till förmån för tiden, så att vi kan får ni ut härifrån i tid,
vi ska börja.
Så välkommen till CS50 Quiz 0 omdöme.
För er som inte har insett men har du en fråga på onsdag.
Woo-hoo.
>> Om du inte har börjat studera ännu eller har inte insett att det finns ännu,
tidigare frågesporter och all information om din quiz finns på cs50.net/quizzes.
Det finns några ganska bra grejer på det, senaste frågesporter från de senaste 10
år samt information om detta quiz och ämnen
som kommer att täckas.
Så låt oss komma igång.
>> Så ni kanske minns, den första dagen i klassen David hade dessa lampor på.
Så i huvudsak, allt som går på under huven på en dator är
gjort i binärt.
Binär betyder vad det låter gillar, 0 s och 1 s.
Den har två värden som kan representeras.
>> Så precis som i den första dagen av avsnitt då David vände på en ljus
lampa för att representera den, eller 1, vår dator förstår binära som 0 s och
1 s, på eller av.
Grunderna i binärt.
Varje plats är representerad i basen två.
Så du lägger till 2 till 0 till 1 till 2 hela vägen upp.
>> För att räkna ut vad din binärt är att decimal, du bara följa denna ekvation
typ sak.
Om du har en 1 i någon av de platser, du multiplicera det med vad som helst
basera det är i, lägga upp den, och du får decimal.
Så det här är hur man räknar till 5 i binärt.
Precis vad vi gjorde på sista bilden, det är hur du skulle
representerar en genom 5.
>> På samma sätt, precis som du kan lägga till och subtrahera i decimal eller bas 10, eller
verkligen någon bas, på kan lägga och subtrahera i binär.
Exakt vad du kan förvänta dig när du lägga till två upp, om det är lika med större
än 1, bära dig en 1, göra det till en 0, och gör det dessutom på det sättet, bara
som du förväntar dig med regelbunden decimal eller någon annan bas.
Cool.
>> Så som jag sa tidigare, allt som pågår under huven på vår dator
sker i 0 s och 1 s, eller binärt.
Så hur vi uttrycker till exempel bokstäver eller siffror eller tecken?
Och svaret på det är ASCII.
>> ASCII är en mappning mellan tecken som vi normalt skulle se i
Engelska språket som A: s, B: s, C: s, understreck, bindestreck, och
något liknande.
Och den visar att till en ASCII-värde.
Ett ASCII-värdet är bara ett nummer som kan förstås av datorn.
Och precis som du kan göra tillägg och subtraktion med siffror, kan du göra
dem med ASCII-värden.
>> Så i detta exempel, vad kommer detta att skriva ut?
Ja, så det är bara en plats B space C utrymme D. Vart tog min mus vägen?
Lägg märke till att du kan definiera en int vid 65.
Och när du skriver ut det med hjälp av procent C, det ska tolka det som en
karaktär och kommer att skriva ut A.
>> På samma sätt kan du deklarera det som en röding.
Och när det skrivs ut med hjälp av procent C, det ska tolka det som
procent D. Och precis som du kan lägga till en nummer, kan du lägga till tecken är
ASCII-värden, i det här fallet.
>> Så en liten pekare för alla.
5, som en sträng, inte faktiskt lika 5.
Så hur kan vi omvandla sträng 5 till heltal 5?
Några idéer?
Yeah.
>> Så om vi har 5 som en sträng, Vi kan subtrahera 0.
Och det ger oss 5.
Och på samma sätt, om vi har 5 som ett heltal, addera till strängen 0.
Och det ger oss strängen 5.
Cool.
>> Nu minns tillbaka att föreläsa en där vi pratade om algoritmer.
Så hur ska vi egentligen vill ha en dator att göra intressanta saker?
Du vet, bara att lägga till och dra ifrån siffror och utskrift saker ut är inte
det spännande.
Vanligtvis vill vi vår dator till utföra någon typ av algoritm.
Något lite mer komplex än bara enkel aritmetik.
>> En algoritm är bara ett steg för steg uppsättning av instruktioner för hur du utför
en viss uppgift -
precis som ett recept.
Du kanske minns den första dagen av klass där David hade vi räknar ett rum
av människor och hur många som var i rummet.
Du kan användas för att räkna en efter en.
1, 2, 3, 4.
I det fallet en linjär tidsalgoritm.
>> Men David införde en algoritm för dig att räkna människorna i rummet
där alla står upp, säger du din nummer till en annan person, tillägga att
nummer upp, och en person sätter sig.
Och du upprepa det.
Det är en typ av algoritm.
Vi kan analysera hur effektiv en Algoritmen bygger på det körs tid.
Men vi ska prata lite mer om det senare.
>> Så alla algoritmer kan också skrivas i pseudokod.
Pseudokod är bara en engelska som syntax används för att representera
ett programmeringsspråk.
Till exempel, om vi ville ställa en användare gissa min favorit nummer, vi
kan ha pseudokod som sådan.
>> Få en användare gissa.
Om gissning är korrekt, berätta för dem de är korrekt, annars berätta för dem
de är inte korrekt.
Och pseudokod är ett sätt att lätt representerar en idé eller en algoritm.
Så nu kanske vi vill verkligen skriva detta på det språk som datorn
kan förstå.
Så vi kunde skriva våra pseudo och tolka det i källkoden.
>> Hittills måste källkod följa till en viss syntax
ett programmeringsspråk.
Och hittills i CS50, vi har använt mestadels c..
Så detta kan vara källkoden för c.
Senare under loppet, du natten kom i kontakt med andra program
språk som PHP.
Eller om du även tar andra klasser, du kan göra Java, Python, eller till och med OCML.
Men i vår c programspråk, är detta hur vi kan skriva källkoden för
pseudokoden algoritm som Jag just beskrivit tidigare.
>> Så hur datorn faktiskt förstå det?
Som jag sa förut, det enda riktigt förstår nollor och ettor.
Så hur det får från källan kod till något som kan vara
förstått?
Tja, vi har något kallas en kompilator.
>> Om ni minns tillbaka på de flesta av dina psets, hade du någon form av program
skriven på en punkt c. fil.
Och då skulle du skriva make.
Så vad gör det?
>> Du kan skriva gör att kompilera program för att någon -
den som skrev din p set; förmodligen David -
skapas en make-fil.
Och som berättar att veta för att köra kompilator, som kallas klang, kommer att
sedan kompilera källkoden till objektet koden, som är nollor och ettor
att datorn förstår.
Men lite senare kommer vi att gå mer på djupet om kompilatorer.
>> Så minns pset 0, där - ja, du en fråga?
>> PUBLIK: [OHÖRBAR]?
>> HÖGTALARE 1: Ja.
Jag tror att de faktiskt borde vara online.
Yeah.
>> PUBLIK: Är det som [OHÖRBAR]?
>> TALARE 1: Det är inte.
Det är på cs50.net/quizzes.
>> PUBLIK: Slash frågesporter, snedstreck 2013 slash 0, och bara klicka sig
frågesporter 2013 och frågesport 0, granska sektions diabilder.
>> HÖGTALARE 1: Ja, så om ni vill dra upp den och titta på den på din
egen dator, det är bra också.
Säg det igen.
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Ja, [OHÖRBAR] är den dummyvariabel.
Oh, ja?
>> PUBLIK: [OHÖRBAR]?
>> Högtalare 1: Nej, strejk inte på tentan.
Tyvärr, hennes fråga var, var strejker på tentan.
Och det är inte.
Så pset 0, ska ni ha alla genomfört något med hjälp scratch.
Och vi lärde oss en del grundläggande programmering byggstenar med hjälp scratch.
>> Så låt oss ta en *** på några av dessa byggstenar
som utgör ett program.
Först är booleskt uttryck.
Booleska uttryck är sådana och 0 s eller något som har
två möjliga värden.
I det här fallet, sant eller falskt, på eller av, och ja eller nej.
Ett exempel på en enkel, mycket enkel, program som använder ett booleskt
uttryck här uppe.
>> Så för att booleska uttryck till vara användbart, har vi booleska operatorer.
Dessa operatörer som kan användas att jämföra vissa värden.
Så vi har och eller inte lika med, mindre än eller lika med, större än eller
lika med och mindre än eller större än.
Men dessa operatörer inte är mycket användbara om vi kan kombinera dem till
förhållanden.
>> Så ni kanske minns från grunden och från din p anger att vi
hade förhållandena.
De är, i huvudsak, som gafflar i logiken i ditt program som
exekverar beroende på om ett villkor är uppfyllt.
Så en av de förutsättningar som vi hade används många gånger i den här kursen är det
om annat, om, och annars förhållanden.
>> Här är ett exempel på hur du kan använda det.
Någon som vet skillnaden mellan bara använda om uttalanden alla
vägen ner verser om, annars, om, och annars kombineras?
Ja?
>> PUBLIK: [OHÖRBAR].
>> SPEAKER 1: Exakt.
Så om jag hade om hela vägen ner här sätt, även om detta, återgår
sant, kommer det fortfarande att fortsätta testa nästa två.
Av följande skäl, med ett annat-om, ett annat uttalande, om man returnerar true,
de andra är inte testat.
Eventuella frågor om det?
Cool.
>> Så du använder en if-else av ett annat uttalande om du vet att det bara kan
vara ett av dessa fall.
Så vi vet om x är mindre än 0, är det definitivt inte kommer att vara
som är större än 0.
>> Härnäst annan byggsten att vi lärt oss är slingor.
Vi har tre typer av slingor.
För loopar, medan slingor, och göra medan slingor.
Och i allmänhet, när du sätter dig ner för att skriva något, måste du bestämma
vilken av de tre som du vill använda.
Så hur ska vi avgöra vilken som?
>> Vi använder i allmänhet en för loop om vi vet hur många gånger vi vill iterera
genom något eller hur många gånger vi vill utföra en uppgift.
Vi använder medan loopar om vi behöver några villkoret för att vara sant att hålla igång.
Och vi använder gör samtidigt mycket lik tag, men vi vill att vår kod körs på
minst en gång.
>> Så gör samtidigt, allt som är i den gör kommer alltid köra åtminstone en gång.
I och med samtidigt, det kan inte köra alls om
villkor inte är uppfyllt.
Eventuella frågor med det?
>> Så strukturen i en for-loop.
Ni har alla sett det.
Du initiera den.
Du har någon form av tillstånd.
Så, till exempel, kan vi initiera som för mig är lika med 0.
i är mindre än 10.
Och jag + +.
Mycket enkel en som vi har gjort.
>> För en while-slinga, på samma sätt, har du att ha någon form av initiering,
någon typ av tillstånd, och någon form av uppdatering.
Så kan vi genomföra vår för loop också som en while-slinga med hjälp av denna.
Och på samma sätt med en gör while-slinga, vi kanske har lite initiering,
utföra något, uppdatera den, och sedan kontrollera tillståndet.
>> Så nu fungerar.
Vi sätter ihop allting.
Vi kanske vill skriva något typ av funktion.
Gemensam funktion som du kanske har sett redan är viktigaste.
Main är en funktion.
Den har en returtyp, int.
Den har ett funktionsnamn, huvud.
Och det har argument, argc och argv.
Så huvud är bara en funktion.
>> Andra funktioner som du kan ha använt, printf - printf är en funktion -
GetInt, toupper.
Men dessa råkar ha varit implementeras för oss
någon typ av bibliotek.
Om ni kommer ihåg, inklusive denna CS50.h biblioteket eller
standard I / O-bibliotek.
Ja, fråga?
>> PUBLIK: Är huvud bara inneboende i C?
Är det bara typ av [OHÖRBAR]?
>> SPEAKER 1: Frågan är om huvud är inneboende i c..
Och ja, alla funktioner har en huvudfunktion.
Det är ganska nödvändig för att datorn att veta var man ska börja
kör koden.
>> PUBLIK: Så du skulle inte [OHÖRBAR]?
>> HÖGTALARE 1: Nej.
Fler frågor?
Cool.
Så precis som du kan använda en funktion som är skriven för dig, du kan också
skriva en egen funktion.
Detta är en funktion för att någon kan har skrivit att beräkna volymen
av en q, till exempel.
Det finns en typ retur här, i det här fallet int, vår funktionsnamn q och vår
lista över parametrar.
>> Och observera att du måste skriva data typ av parameter du vill
Använd annars fungerar inte veta vilken typ av
parameter ska jag acceptera.
Så i detta fall vill vi att ett heltal som vår ingång.
Så varför skulle vi vilja använda funktioner?
>> Först av allt, bra för organisationen.
De hjälper till att bryta upp koden i mer organiserat bitar och göra
det lättare att läsa.
Förenkling.
Det här är bra för design.
När du läser en bit kod och den viktigaste funktionen är riktigt,
riktigt lång, kan det vara svårare att resonera om vad som händer.
Så om du dela upp det i funktioner, det kan vara lättare att läsa.
Och återanvändning-förmåga.
Om du har en bit av kod som är att vara ringt eller köra flera gånger,
istället för att skriva om den koden 10 gånger i din huvudsakliga funktion, kanske du
vill återanvända den.
Och sedan varje gång du behöver använda den bit kod, anropa funktionen.
>> Så nu om vi minns tillbaka till noll, Vi pratade också om några begrepp,
en av vilka är gängning.
Tråd är begreppet multipla sekvenser av kod
exekvera vid samma tidpunkt.
Så tänker tillbaka på dag ett, där David hade ni räkna ut hur många
personer i rummet.
>> I huvudsak vad som pågick på är alla ni var
kör separata trådar.
Och dessa trådar kom tillsammans att få något slags svar.
Även i Scratch, när du har flera sprites, kanske du
har en katt och en hund.
Och de skulle vara samtidigt driva egna skript.
Detta är ett exempel på en gängning.
>> Och det andra begrepp som var introducerades i början var händelser.
Och händelser är när flera delar av koden kommunicera med varandra.
I Scratch, var det när du använde broadcast kontroll och när jag
Receive block.
>> Och även, i Problem Set 4, såg vi lite av händelser också.
Ni kan ha använt den Gevent biblioteket.
Och det fanns en funktion waitForClick där du väntade
för användaren att klicka.
Och din klick, i detta fall skulle vara händelsen och vänta på klick är ditt
händelsehanterare.
>> Och dessutom, hela köra dina psets och arbetar på dina psets, du
kan ha kommit i kontakt med vissa av dessa kommandon.
Detta är vad du skrev in i din terminalfönster eller vad fönster
som dyker upp på din g edit till, huvudsak, navigerar din dator.
>> Så till exempel, LS listar innehållet i en katalog.
Gör katalog skapar en ny mapp.
CD, ändra katalog.
RM, ta bort, tar bort en fil eller någon katalog.
Och sedan ta bort katalogen tar bort en katalog.
>> PUBLIK: [OHÖRBAR]?
>> SPEAKER 1: Ja, visst.
Tyvärr, var frågan om du skulle föreslå att sätta detta
på fusklapp.
Det skulle kunna hjälpa till.
Om du har utrymme, kan du lägga den på.
Det är också bara allmänt bra nog att komma ihåg att när du använder den
kanske du vill bara ha det i minnet.
Det kommer att göra ditt liv mycket enklare.
Har jag svara på din fråga?
>> Så nu, pratade vi lite kort om biblioteken.
Men de två viktigaste som vi har varit med hjälp av så långt i kursen
standard I / O och CS50.
Vilka saker är inkluderade på standard I / O-bibliotek?
>> Ja, så långt vi har använt printf.
I CS50, har vi använt getInt och GetString.
Och datatypen sträng händer också deklareras i denna CS50 bibliotek.
Vi ska prata lite mer på djupet om hur biblioteken fungerar och hur de
interagera med resten av din kod.
Men de är de två viktigaste att vi har kommit i kontakt med den del i
kursen.
>> Typer.
Det är bra att komma ihåg hur mycket varje typ representeras av eller hur
många bytes varje typ kräver -
int, 4 byte, röding, 1 byte.
Float är fyra byte.
Vad är en dubbel?
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Ja, så en flottör men dubbelt så stor.
Hur är det en lång tid?
>> PUBLIK: [OHÖRBAR].
>> SPEAKER 1: OK.
Vad är en lång tid?
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Ja, dubbla en int.
Ja.
>> PUBLIK: [OHÖRBAR].
>> SPEAKER 1: Lång [OHÖRBAR].
Och sedan en lång lång är det dubbla.
>> PUBLIK: Nej, nej.
En lång är bara en int.
Det beror på arkitekturen innan [OHÖRBAR]
och int har samma storlek.
[OHÖRBAR].
>> HÖGTALARE 1: Så en lång och en int är desamma.
Och sedan en lång lång är dubbelt så int.
Cool.
Och sedan, vad är den sista typen?
>> PUBLIK: Pointer.
>> HÖGTALARE 1: Ja, så vi lärde oss lite om pekare.
Och oavsett vad en pekare är pekar på - det kan vara ett tecken stjärna
eller int stjärna -
det är alltid 4 byte för en pekare.
Frågor om det?
Ja?
>> PUBLIK: [OHÖRBAR]?
>> SPEAKER 1: Så en lång och en int är samma i denna CS50 apparat.
>> PUBLIK: Apparaten är helt utbytbara.
>> HÖGTALARE 1: Ja.
Så sedan en lång lång är dubbelt en int.
>> Publik: Detta är det 32 bitars?
>> HÖGTALARE 1: 32 bit, ja.
>> PUBLIK: Så [OHÖRBAR]?
>> HÖGTALARE 1: Ja, om det inte uttryckligen säga, du
bör ta en 32 bitars.
>> PUBLIK: Det skulle säga något som antar en
arkitektur som apparaten.
För 64 bit, det enda som förändring är längtar och pekare.
De båda [OHÖRBAR].
>> HÖGTALARE 1: Ja?
>> PUBLIK: Fråga.
Så på en av de praktiska frågor, det ber om en unsigned int.
Så hur skulle det avgöras från en int [OHÖRBAR]?
>> SPEAKER 1: En osignerad i är också 4 byte.
Men det som är annorlunda med ett undertecknat int och en osignerad int?
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Rätt.
Man kan representera negativa värden.
Men hur går det göra det?
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Ja, det sparar 1 bit för att representera tecknet.
Det undertecknade har en bit att representerar tecknet.
Och osignerade bara är alla positiva.
>> PUBLIK: OK.
Så du säger att en dubbel är två gånger storleken på en flottör?
>> HÖGTALARE 1: Double är dubbelt storleken på en flottör, ja.
>> PUBLIK: Hur fungerar en pekare till en lång lång [OHÖRBAR]?
>> HÖGTALARE 1: Så frågan är hur gör pekaren till en lång lång -
hur är det endast fyra byte när en lång lång sina 8 byte.
Så kom ihåg vad som är en pekare, väsentligen åtmin basvärde.
>> PUBLIK: [OHÖRBAR].
>> HÖGTALARE 1: Ja, så en pekare är bara en minnesplats.
Så det spelar ingen roll hur mycket utrymme att pekaren pekar på.
Den behöver endast fyra byte för att hålla reda av den minnesplatsen.
Fler frågor?
Cool.
>> Så det sista jag har är standard ut.
Du bör använda dem ofta nog att du kan komma ihåg.
Men det är när vi använder printf, till exempel.
Och vi har dessa platshållare som kallades formatkoder.
>> Så procent c röding, procent i för int, och vi kan också använda procent d..
Det är samma sak.
Men, i allmänhet, i CS50 vi försöker använda procent i..
Procent f för float.
Procent ld länge länge och procent är för sträng.
>> På samma sätt har vi använt några av dessa escape-sekvenser.
Exempelvis snedstreck n för ny rad.
Detta är bara för att när du formaterar din kod för utskrift f..
Ja?
>> PUBLIK: Vad är procent d för?
>> SPEAKER 1: Så frågan är det som är procent d för?
Procent d är för ints.
Procent d och procent i är desamma.
>> PUBLIK: Vad är skillnaden mellan backslash n och backslash r?
>> SPEAKER 1: Så frågan är vad är det Skillnaden mellan dödgång n och
backlash r?
Jag tror att backslash r är -
>> PUBLIK: Så backslash r bara innebär återgår till början av raden
utan att faktiskt gå till en ny rad.
Så om du skriver ut en backslash r och du gå tillbaka till början av raden
då du skriver ut mer saker, du skriver över de saker som redan finns på
[OHÖRBAR].
Av följande skäl: n går faktiskt till en ny linje och går till [OHÖRBAR].
>> HÖGTALARE 1: Tja, några andra frågor?
Okej.
Jag kommer att lämna bort det till Dan som kommer att fortsätta.
>> [Applåder]
>> DAN: Alla righty.
Så jag kommer att prata om en annan stor utbud av idéer från den klass som är
ungefär representativ för vecka två och i början av vecka tre man börjar
med gjutning, som är bara ett sätt att behandling av ett värde av en viss typ som
ett värde av en annan typ.
Så vi kan göra detta med tecken till ints, flöten till ints, och
långa längtar till det dubbla.
>> Alla dessa saker kan användas som sätt att behandla vissa numeriskt värde
minus röding som vissa andra numeriskt värde.
Så det finns vissa problem med detta, av kurs, som kommer när du kastar
saker som float till ints.
Så det här är lite konstigt.
Vi har en flottör som är 1.31.
Vi multiplicera det med 10.000.
Och då kan vi skriva ut den som en int.
Vad gör denna utgång?
10.000 gånger 1.31.
Så 13.000, är att gissa?
>> PUBLIK: Jag tror det är 10.000.
>> DAN: Så jag multipliceras med 10.000 innan jag kastat den.
>> PUBLIK: Åh.
Skulle inte det vara en 9 och några 0 siffror?
>> DAN: Du kanske har några konstiga siffror.
Så rätt, det är 1,3 gånger 10.000.
Så det är 13.000.
Och det extra konstigt -
>> PUBLIK: 13,100.
>> DAN: 13100.
Tack, Rob.
Och denna extra weirdness -
detta 9,9 -
är helt enkelt därför att denna gjutning hamnade avrundning där
Det borde inte ha.
Yeah.
>> PUBLIK: Gjutningen sker efter något annat?
>> DAN: Så att jag har den här i tryck, det gör denna multiplikation innan det
gör denna gjutning.
>> PUBLIK: [OHÖRBAR].
>> DAN: Jag tror att det skulle kasta först, ja, vilket skulle vara 10000.
Något annat?
Cool.
Så detta är 13.099.
Varför händer detta?
Reproducerbarhet.
>> Flyter inte är perfekt.
De kan bara representera tal till en antal signifikanta siffror.
Så om vi skriver ut 8 signifikanta siffror på denna flottör, vi får ett slags
ful ser nummer.
Och det beror på 1.31 kan inte exakt representeras av enkla
befogenheter två i maskinen.
Så det slutar tar den närmaste gissa, som hamnar
att vara lite låg.
Vettigt?
OK.
>> Nu stängs är ett annorlunda sätt att göra villkorssatser där alla
vi bryr oss om är en enda variabel.
Så i detta exempel, vi är få ett helt tal från användaren.
Och då vi tittar på vad som heltal är.
Förmodligen är det antal mellan ett och fyra.
Det är det vi ber om.
>> Så du gör ett byte av variabelnamnet.
Då du ställer in fall av möjlig värderar det kan vara.
Så skift en, säger att det är lågt.
Och sedan bryta för att få ut av omkopplaren tillstånd så
du behöver inte hålla på.
>> I nästa fall -
så fall två och fall tre -
om det är fallet två det bara sjunker ner till den första kodraden den ser som med
skift tre tills den ser en paus.
Så anledningen till att du får fråga en till endast utskrifts låg beror på att jag
har denna paus här.
Om jag, säg, ignorerade denna paus - om jag kastade denna utbrytning -
Det skulle skriva ut låg, och då skulle det skriva ut mitt, och då skulle det gå sönder.
>> Så raster är en viktig del av växlar villkor och
de borde vara där.
Alla ärenden som inte uttryckligen anges hanteras av standard
fallet i växeln och kastas.
>> Publik: So 1, 2, 3, och 4 skulle vara n?
>> DAN: Värden att n kan vara.
Ja.
Yeah?
>> PUBLIK: Så när du har att [OHÖRBAR]?
>> DAN: Du skulle skriva ut låg, och sedan Det skulle skriva ut mitt och
då det skulle gå sönder.
>> PUBLIK: Varför skulle den ut mitten om [OHÖRBAR]?
>> DAN: Så allt under ett fall innan en paus faller under.
Så fall en utskrift är nedanför fallet en som är det följande tryck.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Så det här numret är bara en viss värde att denna variabel
kan ta, eller hur?
Låter det vettigt?
Yeah.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, fall två skulle skriva ut mitten och sedan bryta.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Jag tror någon?
Vilka andra datatyper kan du växla över?
>> PUBLIK: Du kan byta över alla datatyper.
Men det betyder bara något över tecken och ints och sånt, eftersom
om du byter över en pekare det betyder verkligen inte vettigt,
omkoppling laster, om det låter till och med s du gör det, på grund av flyttal
i precision, skulle du inte riktigt vill göra det ändå.
Så ganska mycket, Ints bara och tecken och sånt.
>> DAN: Ja, det är när du har explicit värden som du vet, jag tror, kan vara
att en omkopplare är faktiskt användbart.
Bra?
OK.
>> Scope är det område som en uttalad variabel sträcker sig.
Så i denna lilla bit av kod jag har, det skulle vara full av fel.
Och anledningen är jag förklarade denna int jag inom ramen för denna för slinga.
Och så försöker jag att referera till att Jag utanför det för loop omfattning.
>> Så i princip kan du tänka på omfattningen som något som du deklarerar
med i en uppsättning av klammerparenteser endast finns inom dessa klammerparenteser.
Och om du försöker använda den variabeln utanför dessa klamrar, du ska
får ett felmeddelande från kompilatorn.
Yeah?
>> PUBLIK: Så här inte fungerar?
>> DAN: Detta fungerar inte, ja.
Strängar.
String en char *.
De är exakt samma.
De är bara pekare till tecken.
Och alla strängar som du har ska avslutas med snedstreck noll, vilket är precis
a c konvention.
>> Det kallas NULL terminator.
Och NULL -
Kapital N, huvudstad U, kapital L, huvudstad L -
inte är samma som den NULL terminator.
Detta är en pekare.
Detta är ett tecken.
De är mycket tydlig.
Kom ihåg det.
Det kommer att vara på frågesport, förmodligen.
Jag har inte sett frågesporten.
Yeah?
>> PUBLIK: Så NULL är, säg, pekaren?
>> DAN: Ja.
>> PUBLIK: Vad [OHÖRBAR]?
>> DAN: Om, säg, malloc anropas när du har inte tillräckligt med minne för att få
oavsett storlek du ber om, malloc returnerar NULL.
Det är, i grund och botten, när en funktion är tänkt att returnera en pekare, du
måste kontrollera mot NULL eftersom NULL är ett ganska bra -
det är, typ av, soporna värdet.
Det är en nolla så långt som pekare går.
>> När du ringer en funktion, som returnerar en pekare.
Du kommer att vilja kontrollera att vara Se till att det pekaren inte är NULL
eftersom NULL är mycket vanligt.
Det är en slags sopor avkastning.
Så om något inte går rätt, bara tillbaka NULL istället.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, och det är det här.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Stava det som detta.
Det är NULL terminator.
Det gemener N-U-L-L om du stava det.
>> PUBLIK: Och jag gick bara tillbaka och testade den.
Och om du försöker sätta ett flyttal värdesätter i en växel, det ska skrika på dig
säger, kräver uttalande uttryck av heltal typ.
>> DAN: Varsågod.
Men ja, vad var frågan nu igen?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Så kapital N, huvudstad U, kapital L, huvudstad L är en verklig c. sak.
Det är NULL-pekare och kommer endast behandlas som sådana.
Du kommer aldrig att försöka stava NULL karaktär och se någon
annat sätt än detta.
Yeah?
>> PUBLIK: Så återvänder till char max eller något i noterna, skulle det
förkroppsligar samma funktion som [OHÖRBAR]?
>> PUBLIK: Så är du hänvisar till åter röding max från getchar, eller
vad det nu är?
>> PUBLIK: Ja.
>> PUBLIK: Ja, så det allmänna term för alla dessa saker
är indikatorvärden.
Så som återvänder int max från getInt och röding max från getchar, är det
tänkt att vara som, okej, om dessa saker återvänder till oss,
något gick fel.
>> För tips, vi råkar bara ha detta sentinel värde som alla
håller med om.
Och detta är vad du kommer tillbaka när saker går fel.
Så röding max är vad vi använder att representera något
som NULL eller getchar.
>> PUBLIK: Så om du testar getchar, kan du bara sätta NULL?
Skulle det göra någon skillnad?
>> DAN: Du kan inte bara kolla NULL.
Du skulle behöva kontrollera röding max eftersom Returvärdet från funktionen är
en karaktär inte en pekare.
Yeah?
>> PUBLIK: Den här frågan gäller för stränglängd.
Betyder det inkluderar NULL karaktär?
>> DAN: Nej.
Och det är faktiskt hur stränglängd vet att sluta eftersom det går igenom
din samling av tecken tills den ser en NULL karaktär.
Och då är det som om, allt rätt, jag är klar.
>> PUBLIK: [OHÖRBAR] fem?
>> DAN: Hej skulle bli fem.
Yep.
Så arrayer är kontinuerliga minnesblock.
De har omedelbar tillgång genom att säga det namn av arrayen och sedan, i lockigt
hängslen, oavsett index du vill gå till, de är indexerade från noll till
längden av arrayen minus 1.
>> Och de deklarerats av den typ av sak som du lagrar i
array, namnet på uppsättningen och sedan oavsett storleken är på den arrayen.
Så detta är en char array med längden sex, som har dessa värden.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Om du har vad som händer i arrayen som redan gjorts.
Så du kan ange detta i stället som, säga, röding, oavsett namnet på din
array är, tomma parentes är lika lockigt brace H kommatecken E kommatecken L kommatecken L kommatecken
O kommatecken NULL karaktär och klammer.
Det skulle också fungera som en förklaring.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Då måste du ha storleken som redan gjorts.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja.
Alla righty.
Kommandoradsargument är ett sätt att få inmatning från användaren som
argument till main.
Huvud tar två argument.
Antalet argument som håller på att skickas vidare kommandoraden och en
strängvektor eller en sträng array av alla argument.
>> Så om jag, säg, som kallas en funktion som a dot ut 1 rum, 2 rum, tre,
argc skulle vara 4.
Och det argv 0 skulle vara en prick ute.
Argv1 skulle vara 1.
argv2 skulle vara 2. argv3 skulle vara 3, i det specifika fallet.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Det sista elementet i arrayen eftersom matrisen är längden argc plus
en av ARGB, det sista elementet Detta är ett NULL-pekare.
Det är argc plus ett.
Så i det fallet som jag sa, det skulle argv 0 är en prick ute.
argv 1 är en. argv2 är 2. argv 3 är tre.
argv 4, som är ett större än argc skulle vara NULL.
>> Och det är NULL-pekare.
Ja.
Och det beror på att strängen är en röding stjärna är en pekare.
Så det måste vara av samma typ.
Yeah?
>> PUBLIK: Två frågor.
Så en, vad är skillnaden mellan detta och annat än en typ GetString
i användar motor?
Och två, lagras det i ditt senaste minne?
Så liksom, GetString skulle vara [OHÖRBAR]?
>> DAN: Var lagras den?
Jag vet inte var den finns.
>> PUBLIK: Så, faktiskt, du vet hur något funktion du kallar det argument
är lagrade i stapeln?
Så argc och argv är argument till huvud och de är på stacken, eller egentligen
strax över vad du tycker så starten av stapeln.
Vad var den andra delen av frågan?
>> PUBLIK: Så vad är det [OHÖRBAR]?
>> DAN: Ja, det är bara ett annat sätt att få inmatning från användaren.
Den här är lite mer effektiv och det är smidigare för skript för att du
kan bara passera argument till din huvudsakliga funktion i stället för att behöva vänta
för användare, om du inte har någon användare.
>> PUBLIK: Och ja, få strängar skulle vara [OHÖRBAR].
Det skulle spara de saker du behöver.
>> DAN: Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, argv 0 innehåller alltid den dot slash av funktionsanropet.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, vart och ett av argumenten är slutade i NULL karaktär eftersom de
är strängar.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, är argv argc en NULL-pekare.
>> PUBLIK: [OHÖRBAR]?
>> DAN: Oh yeah.
Ja, förlåt.
>> PUBLIK: Så [OHÖRBAR]?
>> DAN: Så frågan är om du hade kommandorad dot slash en prick ut 1, 2,
skulle antalet kommandoraden argument vara två eller skulle det vara tre?
>> PUBLIK: Jag tror att det gör det inte egentligen ingen roll.
Jag brukar säga, åh, du klarade inte alla kommandoradsargument när,
självklart, ringde du funktionen.
Så jag brukar högljutt utesluta funktionen från kommandoraden
argument även om det är ingår i argv.
>> DAN: Men om det var på testet -
ja - och även om du säger något liknande argc motsvarar 3,
du är säker stående.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Jag tror att om istället för att ringa det i argc och snöre argv parentes
men höll samma typer och bara kallas dem något annat som en
och b, skulle det fortfarande fungera?
Och det skulle ändå fungera, du skulle bara -
istället för att använda argc - du skulle använda a och b.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Så frågan är GetString är kommer att lagra minne i högen
eftersom GetString är char *.
Den lagrar minnet i högen eftersom det kallar nu malloc inom själva
genomförande av GetString.
OK, vi går vidare.
>> Säkerhet.
Så för att vara riktigt säker, du lita på någon en och du tillåter ingen tillgång till någon
av din information, varför alla bygger sina egna maskiner,
sina egna operativsystem, all deras program från scratch, och självklart
Anslut inte till några andra maskiner via internet.
Så datorer är osäkra.
De är verkligen.
Vi måste lita på andra människor.
>> Och tanken på att säkerheten är att du är försöker att begränsa mängden
litar på att du behöver.
Och ett av de medel som du gör att är genom kryptografi.
Kryptering är, i huvudsak, vi har hemligheter.
>> Ibland måste vi passera våra hemligheter tillsammans genom exempelvis Internet eller
andra saker.
Och vi vill inte att folk att veta dessa hemligheter.
Så vi kryptera våra hemligheter till ett sätt att vi hoppas att ingen kan räkna ut.
>> Så vi använde -
genom loppet av denna klass -
saker som Caesar chiffer och [OHÖRBAR], som båda är mycket, mycket
osäkra sätt att kryptera saker.
De är lätt att räkna ut vad de är och vad dina hemligheter.
Den verkliga världen använder mycket mer komplicerade krypteringssystem.
Och vi kommer inte att komma in i mycket mer än så.
>> Debugging.
GDB är bäst.
Jag kommer att betona detta igen.
Använd GDB hela tiden varje gång du har ett problem.
Kommandon som är användbara i GDB är sönder, som du passerar antingen en linje
nummer, ett funktionsnamn, i huvudsak var i koden du vill sluta,
och kunna ta kontroll.
>> Print tar en variabel och skriver ut oavsett vad den variabeln är på det
pekar i din avrättning.
Nästa flyttar din avrättning längs ett steg.
Och steg steg inuti en funktion i ditt utförande.
>> Andra saker sköts, vilket är hur du faktiskt köra din kod.
Fortsätt tar alla steg som behövs för att komma till nästa brytpunkt.
Och det finns många, många andra.
Slå upp dem.
De är bra.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja, vilket är en debugger.
Så en debugger är ett program som kan du felsöka program.
Det är inte ett program som hittar buggar för er, även om det skulle vara bra.
>> Och sist för mig är sökning.
Så vilken typ av sökning som vi talat om i denna klass är linjär sökning,
vilket är precis som du tittar igenom varje beståndsdel av sökrymden, en
element i taget, tills du hittar det du letar efter, eller tills du når
slutet av din sökning utrymme där Point du säger att du inte kunde hitta
det element som du söker.
Och detta tar i bästa fall konstant tid, vilket är 0 av 1 och i värsta linjär
tid, vilket är 0 n.
>> Binär sökning, som behöver simpla element.
Du går till mitten av dina element, se om det element du söker
är större eller mindre än det element att du är i mitten.
Det är det större, säger du att botten av din sökning utrymme är din
nuvarande plats, mitt, och du startar processen.
Om det är mindre, ser du säger att den - ja, vad är det?
>> PUBLIK: [OHÖRBAR]?
>> DAN: Ja.
Alla slags sort som har undervisats i klassen är lovligt byte för testet.
>> [LAUGHTER]
>> DAN: Och det faktum att du inte har haft att göra det till ett problem set, är det rättvist
lek för testet.
>> PUBLIK: Kan vi gå över den hur -
>> DAN: Det kommer att vara borta över.
>> TALARE 2: Den faktiska koden för [OHÖRBAR] är på study.cs50.net.
Så om du tittar på praxis problemet i kopplingen sorteringssida
study.cs50.net, det är koden för att genomföra merge sort.
Så du behöver inte genomföra det själv ikväll.
Men se till att du förstår det ganska än att bara memorera det.
>> PUBLIK: [OHÖRBAR]?
>> TALARE 2: merge sort sida på study.cs50.net, det finns en praxis
problem som, om du klickar igenom problem, i slutet finns en
lösning, som är sammanfogningen sorterings genomförande.
Men se till att du förstår det snarare än att bara memorera det
eller kopiera den.
>> PUBLIK: Och ett fullvärdigt problem för testet skulle vara
något som här är en lista.
Vad innebär den här listan ser ut efter ett steg för val sort eller
insättnings sortera eller vad.
En fullständig upprepning av listan.
Så även om du inte slutar att behöva koden för det, måste du förstå det
tillräckligt för att veta hur det går att ändra denna samling.
>> DAN: Det är det för mig.
>> [Applåder]
>> LUCAS: Hej alla.
Mitt namn är Lucas.
Jag ska prata om rekursion, alla de slag som vi har lärt oss, och en
lite av alla pekare.
OK?
Så först av allt, rekursion.
Vad innebär det att säga att en funktion är rekursiv?
>> PUBLIK: Kallar sig.
>> LUCAS: OK, kallar sig, ja.
Så gillar den här bilden, till exempel.
Det är som på bilden inuti av en bild och så vidare.
Så till exempel kan du ha - som Dan som talade om binär sökning.
Ett sätt på vilket binär sökning är rekursiva är det faktum att du är
att försöka hitta ett nummer.
Så du går till mitten.
Och sedan kontrollera om siffrorna där i den vänstra och i den högra.
>> Och sedan om du ta reda på numret är kommer att vara till vänster, det är samma
sak som att göra sökningen igen men precis till vänster i listan.
Så det är hur det låter som det är rekursiv.
Så det är därför ni har rekursiv lösning för merge sort.
>> OK, så här är ett exempel.
Så låt oss säga att jag vill välja alla nummer från 1 till n.
Jag kan inse att summan av n nummer är n plus n minus 1 till 1.
Men sedan, om jag tittar på n minus 1 plus n minus 2 plus 1, det är samma
sak som att summera tal upp till n minus 1.
Så jag kan säga att summan av en lika stor summa är lika med n plus summan av n minus 1.
Låter det vettigt?
>> Och jag också skulle ha något annat kallade basfallet, vilket är att
summan av talen upp till noll skulle vara noll.
Så fort jag får till det antal noll, jag sluta räkna.
Låter det vettigt?
>> Så här är ett exempel på hur Jag kan genomföra det.
Så jag har denna funktion i vissa.
Det tar ett heltal n.
Så här är jag kolla först om n är mindre eller lika med noll.
Så om det är mindre eller lika med noll, jag returnera noll, vilket är vår bas fallet.
Annars kan jag bara gå tillbaka n plus summan av talen från
en till n minus ett.
Vettigt?
OK.
>> Så här är vad det ser ut.
Du har summan av två jämlikar 2 plus ett belopp på 1.
Och en del av 1 är 1 plus summan av 0, som är 0.
Vettigt?
Så om vi tittar på högen av din program, det är vad det ser ut.
>> Först har vi den viktigaste funktionen.
Och så den viktigaste funktionen kallas summa 2.
Och sedan summan 2 kommer att säga, oh, summa 2 lika med 2 plus summan av en.
Så jag lägger till summan av 1 till stacken.
Och summan av 1 kommer att ringa summan av 0, vilken också kommer att tillsättas
till stacken.
Och sedan var och en av dessa de som är ovanpå varandra måste återvända
innan de andra som kan hålla igång.
>> Så till exempel, här, summan av 0, första, kommer att returnera 0.
Och välj sedan summan av 1.
Då summan av 1 kommer att återgå 1 till summan av 2.
Och slutligen, är summan av 2 går att återvända 3 till huvud.
Låter det vettigt?
>> Det är verkligen viktigt att förstå hur stapeln fungerar och försöka
se om det är vettigt.
OK, så sortering.
Så varför är sortering viktigt, först av allt?
Varför ska vi bry oss?
Någon?
Ge mig ett exempel?
Yeah?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Ja, OK.
Så du kan söka mer effektivt.
Det är ett bra sätt.
Så, till exempel, har vi en hel del saker, faktiskt, i våra liv som
är sorterade.
Exempelvis ordböcker.
>> Det är väldigt viktigt att ha alla ord i någon slags ordning som vi
kan komma åt lätt.
Så det är vad han sade.
Du kan söka mer effektivt.
Tänk på hur svårt det skulle vara att ha en ordlista där orden finns i
slumpmässig ordning.
Du måste titta på, ganska mycket, varje ord tills du hittar den
ord som du letar efter.
>> Om du använder Facebook också, när du tittar på dina vänner, du är
kommer att se att Facebook lägger din närmare vän är på toppen av de
att du inte prata så mycket.
Om man går hela vägen till botten av din vänlista, du kommer att se
människor som du gör antagligen inte ens kom ihåg att du är vän med.
Och det beror på att Facebook sorterar dina vänner baserat på hur
nära du är till dem.
>> Så organisera data.
Också Pokemon.
Så du ser att alla Pokemons har siffror.
Och det är som en lätt sätt att komma åt data.
>> PUBLIK: Åtkomst Pokemon.
>> LUCAS: Ja.
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Japp.
OK, så urvalet sortera.
Urval sort kommer att välja minsta osorterade värdet på en lista varje
tiden i varje iteration.
Det är ungefär som den typ som du gör i ditt huvud när du försöker
sortera en lista i handen.
>> I grund och botten är allt du gör att du ser för det minsta antalet.
Du sätter den i den sorterade listan.
Och om du tittar på Nästa minsta talet.
Och då du fortsätter att göra det och så vidare.
>> Så val slag är i princip att du väljer varje gång de minsta
osorterat värde.
Sätt i slutet av den sorterade del av listan.
Och fortsätta att göra det.
Så låt oss snabbt se vad detta ser ut.
Så här är den sorterade och osorterad lista.
>> Så för den sorterade i listan, det är initialt tomma.
Och då kommer jag att välja minsta antal här, vilket är 2.
Så jag får nummer 2 och jag satte i den främre delen av listan.
Och så ser jag för nästa mindre elementet, vilket är tre.
Så jag satte den i slutet av den sorterade listan.
Och då jag fortsätter att göra det.
Jag tycker 4 och lägga den i slutet.
Hitta 5 och lägga den i slutet.
>> Och titta på hur alla dessa tider som Jag säger lägga den i slutet är,
i grund och botten, byta två värden.
OK?
Och sedan den sista, du bara har ytterligare en faktor.
Så det är redan sorterade.
>> OK, så inför sort.
Inför sort du ska ha också det där med att ha en sorterad och
en osorterad lista.
Det enda är att varje gång du lägger till ett element i den sorterade
lista, du bara välja det element som är framför osorterad lista.
Och då du kommer att hitta det positionera det bör vara i den sorterade
del av listan.
>> Låt oss se vad detta är så detta är mer förnuftigt.
Så till en början, till exempel, jag försöker för in nummer tre i
sorterade delen av listan.
Så listan inte har något.
Så jag kan bara sätta nummer 3.
>> Nu vill jag lägga till numret 5 till den sorterade delen av listan.
Så jag tittar på antalet 5.
Jag märker att det är större än 3.
Så jag vet att det måste vara efter 3.
Så jag satte 3 och 5.
>> Då vill jag in numret 2.
Jag märker att antalet 2 är faktiskt varar sedan både 3 och 5.
Så jag har faktiskt lägga det hela sätt i början av listan.
Så jag måste, typ av, flytta alla elementen i den sorterade listan så jag kan
göra plats för antalet två.
>> Sedan ser jag siffran 6.
Jag ser att det ska vara efter 5.
Så jag satte den där.
Och slutligen, jag tittar på antalet 4.
Och jag märker det ska vara mellan 3 och 5.
Och då jag lagt det där och skift alla andra element.
Vettigt?
>> Bubble Sort.
Så bubbla slag är i princip vad du är ska göra - vi kallar det bubbla
sortera eftersom du går igenom listan - det är faktiskt bättre om jag visar bara
du gillar denna -
och du kommer att jämföra angränsande nummer.
Och du kommer att byta sin positioner om de inte
i rätt ordning.
>> Så i princip, vad som kommer att hända är här, till exempel,
du har 8 och 6.
Du vet att den sorterad ordning kommer faktiskt vara 6 och 5, eller hur?
Så du kommer att byta order.
Sen ser jag 8 och 4 här.
Och jag gör samma sak.
Jag byter igen.
Och slutligen, 2 och 8.
Jag byta dem också.
>> Det kallas Bubble Sort för efter var och en av dessa upprepningar, faktiskt,
det största antalet i listan får alla vägen till slutet av listan.
Låter det vettigt?
Eftersom det håller att byta det och flytta den till höger.
>> OK, så det här är den andra iterationen.
Det skulle vara samma sak.
Jag ska göra en swap och sedan den sista.
Jag att det inte finns några swappar och listan är sorterad.
Så i Bubble Sort, vi i princip hålla att gå igenom listan och byta
saker tills jag märker att jag inte gjorde alla swappar gör att iteration, vilket
innebär att listan redan sorteras.
Vettigt?
>> Låt oss prata lite om gångtid.
Så gör ni minns Big O, Omega, och Theta?
Yeah?
OK, vad är Big O, först av allt?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Ja, det kallas ett värsta fall runtime, vilket bara innebär att det är
hur mycket du räknar med att programmet att vidta för att köra.
Liksom i fråga om -
i det här fallet - n.
Antalet element i lista i det värsta fallet.
Liksom, i värsta fall.
>> Så för Bubble Sortera, exempelvis Vi har Big O n kvadrat.
Varför har vi det?
Varför är Bubble Sort Big O n kvadrat?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Ja, så värsta fall blir att jag måste göra n iterationer.
Så var och en av de iterationer kommer att bringa det största elementet i slutet
i listan.
Så det värsta är att jag har att göra det där n gånger.
Och för var och en av dessa gånger, måste jag göra n swappar för att jag har att jämföra
vardera två delar.
Så det är därför det är n kvadrat eftersom det är n gånger n.
>> Då är valet sortera också n torg därför att, för varje iteration, måste jag
titta på varje enskilt element i listan.
Och sedan hitta den minsta, vilket betyder att jag måste
titta igenom n element.
Och jag måste göra det n gånger eftersom Jag måste välja alla n element.
>> En insättnings sort är också n torg eftersom det värsta scenariot kommer
vara, en, jag måste sätta in n nummer, eller hur?
Så jag vet redan att jag kommer att ha n iterationer.
Men för var och en av dessa siffror, om jag hade att titta på alla nummer i
den sorterade listan och lägga det hela vägen i fronten, kommer att bli n kvadrat
eftersom det kommer att vara n gånger n igen.
Vettigt?
Hur är omega?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Det är det bästa scenariot.
Så det är som i en *** gånger för sortering, är det bästa scenariot
När listan är redan sorterade.
Så du har egentligen inte att göra någonting.
Bubble Sort har den bästa scenariot n.
Vet ni varför?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Ja, om du håller koll på om data ranson hade några swappar eller
inte, om du har något som satt till sant om det inte fanns en iteration, om den
lista är redan sorterade, i princip, vad som kommer att hända är jag ska
Försök att byta varje två intilliggande element.
Jag ska se till att det finns inga swappar.
Och jag återvänder bara en gång.
>> Så det betyder att jag bara var tvungen att gå igenom listan en gång.
Så det är n eftersom jag ser hos n element.
Varför urval sorterar n Square?
>> Ja, även om listan är sorterad, för varje iteration av urval sortera, jag
måste välja det minsta elementet.
Så det betyder att jag måste ut för att titta på alla element i den osorterade
listan och hitta det lägsta för varje iteration.
Låter det vettigt?
>> Och insättnings svärd är n grund i så att jag försöker sätta in
nummer och alla nummer, när jag Försök att sätta in dem, ser jag att de
är i rätt position.
Jag behöver inte gå kolla alla andra nummer i osorterad lista.
Så det är därför det blir n.
Vettigt?
Och vad är theta?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Vad, om ursäkt?
Säg det igen.
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Exakt.
Så du kan se att endast val lagras i Merge sort har thetas.
Och det beror på att du bara har teta om både Big O och Omega är desamma.
OK.
Och till sist, sammanfoga sortera säga i log n.
>> Och sedan, som Dan sa, Merge sort är ungefär som på samma sätt som
du gör binär sökning.
Så du får listan.
Och du kommer att halveras.
Och då du skär dem i mindre delar.
Och sedan slå ihop dem.
Ni kommer ihåg det, eller hur?
OK, som han sa.
>> OK, pekare.
Så vad är en pekare?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: En adress.
OK.
Jag vet att David visar ett gäng videor av binky och saker som pekar
varandra.
Men jag gillar att tänka på pekare som bara en adress.
Så det är en variabel som kommer att lagra en adress.
>> Så det är bara denna speciella variabel som är fyra byte lång.
Kom ihåg, att pekare till någonting är alltid fyra byte lång för vår 32-bitars
maskinen så är fallet med apparaten.
Och det bara har plats av en rörlig inne i den.
>> OK, så det är det här minnet, i grund och botten.
Så varje block av minne som faktiskt har en etikett, som är adressen till den
slotty minne.
Så det betyder att jag kan ha en pekare som pekar på
någon av dessa adresser.
Så anledningen till att vi kommer att använda pekare är om jag måste komma ihåg platsen
att en viss variabel är ett minne.
>> Och ni kommer ihåg att en av dem fall var om jag har en funktion
Om jag har faktiskt vill att du ska swap för reals, jag faktiskt
måste skicka en pekare.
Inte variabeln.
Har ni ihåg det?
Skillnaden mellan -
Vad är namnet?
Ringa i värde och ringer genom hänvisning, eller hur?
>> OK, ja.
Så ring av värde.
När du bara skicka en variabel till funktion du bara skicka ett värde.
Så du verkligen skickar en kopia av variabeln.
Och ditt program kunde inte bry sig mindre ungefär om samma variabel faktiskt
gör en kopia.
>> Och ringer genom hänvisning innebär att Jag är faktiskt att skicka en kopia av
pekaren till den variabeln.
Så det betyder att jag skickar den Placeringen av denna variabel.
Så känner jag platsen för variabel, när jag ringer funktionen
med pekare, jag kan faktiskt ändra uppgifter som var i huvud.
Vettigt?
>> Även om, är pekaren en kopia, det pekaren fortfarande har den verkliga adressen till
variabeln som jag vill ändra.
Vettigt?
>> Så skapar pekare.
Kom ihåg att pekaren alltid den typ som den pekar
till och sedan en stjärna.
Och då du sätter namnet.
Så kom ihåg att när du har oavsett stjärna, det är som en pekare till
att oavsett variabel skriver att du hade.
>> Så här i stjärna, till exempel, är det en pekare och ett heltal.
Och sedan röding stjärnan är en pekare röding stjärna och så vidare.
Yeah?
>> PUBLIK: Vad händer om vi har en pekare till n till stjärn x.
Jag vet som skapar en pekare till x.
Är det också förklara x ett heltal?
>> LUCAS: OK, så när du säger n stjärna x, du är inte att skapa en pekare till en
variabeln x.
Du skapar en pekare som heter x.
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Så när jag säger n stjärna x, jag är säga, hej, i minnet, kommer jag att
få en av dessa tre lådor.
Och jag ska säga att det kommer att vara x, vilket är
kommer att bli en pekare.
Och något intressant om pekare är att vi säger att de har
4 bytes för en 32-bitars maskin.
Och anledningen till detta är att 4-bytes är 32-bitar.
>> Och maskiner som är 64 bitar faktiskt har pekare adresser
som är 64 bitar långa.
Så det betyder bara att storleken på adresser i maskinen är annorlunda.
>> Så Referera och dereferencing.
Det finns två operatörer som ni bör komma ihåg.
Den första är et-tecken.
Den andra är stjärna.
Bli inte förvirrad av att stjärnan och detta stjärniga därför komma ihåg att, i
det här fallet, har du n stjärna.
>> Det är som en hela saken tillsammans.
Det finns ingen n Space Star.
Så det betyder att det är den typen.
Kom ihåg att när du har den variabla stjärnan, är du
talar om vilken typ.
>> När du precis har stjärnan och sedan namnet på variabeln, betyder det att
du dereferencing pekaren, vilket innebär att du tittar på den
pekare, hitta adressen är det pekar på, går till den adressen,
och titta på när du har där.
Så jag säger till mina elever att när du har stjärna, bör du tänka på att det är
förkortning av innehåll.
>> Så om du har en pekare och du gör stjärniga pekare, det är
innehållet i pekaren.
Så du går till vad det pekar på och titta på den konstanta innehåll.
Och et-tecknet är samma sak som adress.
>> Så om jag har en variabel a - som, låt oss säga att jag gjorde int a är lika med 3 -
om jag vill hitta adressen till det variabel ett minne, jag kan bara göra
et-tecken en.
Så det är adressen till en.
Vettigt?
>> Så här är ett exempel.
Detta saknas int b och int c..
Så int en lika 3 innebär att Jag kommer att gå till minnet.
Och jag kommer att hitta en kortplats och uppskattar antalet 3 här.
>> Och då int b är 4.
Jag kommer att göra samma sak.
Gå till minnet och sätta ett antal 4 i en av lådorna.
Och INT lika 5.
Hitta en annan låda och sätta ett nummer 5.
>> Så vad är denna linje gör ute? n stjärna pa lika med-tecken en.
Så först av allt, n stjärn pa.
Vad gör det?
>> PUBLIK: [OHÖRBAR].
>> LUCAS: Ja, så n stjärna pa, först, deklarerar en pekare som heter pa.
Och då är det tilldelar värdet av att pekaren att vara adressen till en.
Så et-tecken en.
Sedan, om jag gör stjärn pb, vad som är en stjärna pb?
>> Åh, förlåt.
Det saknas också. n stjärna pb.
Jag menar stjärn pc.
Jag är så ledsen.
Det är samma sak.
Men nu är jag bra ar att skapa en pekare till b och sedan en pekare till c..
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Ja.
Så om du går till minnet och du går till rutan som är beteckning för pa,
du faktiskt kommer att se en adress till en.
OK?
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Ja, det är en adress pekare.
Glöm aldrig det.
Det är som det viktigaste delen om pekare.
Det är lagring och adress till viss variabel.
Något annat?
Fler frågor?
OK.
>> Så Pekare och arrayer.
Kom ihåg att när jag gör int array 3, i grund och botten, det jag gör är jag, typ
av, förklarar i en pekare.
Så array är ungefär som en pekare till en specifik plats i minnet där jag
tilldelats tre kortplatser för heltal.
Låter det vettigt?
>> Så när jag gör int array 3, vad jag är göra, i princip, är att skapa tre
slitsarna i minnet.
Så jag tycker bara tre kortplatser i minnet.
Så om jag gör, då, en stjärna array, det i princip innebär att innehållet i matrisen,
vilket betyder att jag raderar pekaren, går jag till den platsen som det pekar på,
och jag satte nummer ett.
>> Och sedan, om jag gör stjärn matris plus 1, det är samma sak som att göra array
konsoler en, som just betyder att jag går till den plats som den pekar på.
Och sedan plus ett märken mig skifta en position.
Så jag går till detta läge, faktiskt, och satte nummer två.
>> Och så, till sist, när jag gör matris plus 2, jag går dit
array s pekar på.
Och då jag flyttar till minnesblock.
Och sedan satte jag nummer tre här.
Yeah?
>> PUBLIK: Så stjärn array är helt enkelt säger den första punkten.
Och du kan lägga till 1, bara för att vi är egentligen bara
refererar den första adressen.
>> LUCAS: Ja.
Varför vill vi, till exempel, säger array 0, matris 1 och matris 2?
Jag menar, varför gör du 0, 1, 2, 3 i stället för 1, 2, 3?
En av anledningarna är, en, dator programmerare föredrar att starta
räkna från 0.
Två beror på att när du gör array 0, det är samma sak som att göra array
plus 0, vilket betyder att jag går till den positionen, och jag gör inte
hoppa över några minnesblock.
Så jag inte flytta någon minnesblock.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Så hon frågar vad som är skillnaden mellan att göra
detta eller gör malloc.
En av skillnaderna är att int array 3 är att skapa en
array på stacken.
Och när jag gör malloc, det skapar på högen.
Låter det vettigt?
>> Så hur malloc egentligen?
Så varför behöver vi även använda malloc?
Din kompilator slags siffror ut alla de variabler som du deklarerat.
Och han skapar utrymme för alla av dem i stacken.
Så alla dina variabler går att vara någonstans i stapeln.
Så här är de miljövariabler.
>> Så i princip utrymme för dessa variabler i minne allokeras på
kompilera tid.
Så det betyder att datorn har känna alla dessa variabler
förhand.
Det behöver inte veta vilket värde du ska sätta in dem.
Men det behöver veta hur mycket minne du behöver.
>> Men nu ska vi säga att, till exempel, du skapar en array eller ta en
sträng som du tar från användaren.
Du vet inte hur länge strängen kommer att vara, till exempel.
Så du vet inte exakt hur många minnesblock du fördela, eller hur?
>> Så det är inte riktigt vettigt för dig att säga sätta 100 tecken.
Och vad om användaren skriver 150?
Du kommer att skruvas.
>> Så i princip kan du inte vara säker på hur mycket minne som du behöver för att fördela
när du kompilerar programmet.
Du vet bara att om körtid.
Så det är därför du har högen.
Så högen kommer att ha minne att du fördela under
tid programmet körs.
>> Så i grund och botten, när du gör malloc, vad du gör är att fördela minne på
runtime, vilket innebär att du är avgöra rätt i det ögonblicket som du
bör ha detta minne.
Så det är när du fördela det.
Låter det vettigt?
>> Så kom ihåg, stapeln har variablerna som är skapade på kompileringen.
Och sedan högen har variablerna som skapas när du går
med malloc, till exempel.
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Så GetString är kommer att kalla malloc.
Låt mig tala om malloc, och Jag ska förklara GetString.
Så malloc är samma sak som minnesallokering.
Så det kommer att fördela minne på högen.
Och det kommer att returnera en pekare till där det minnet tilldelades vid.
>> Så när du gör -
till exempel här -
n stjärna pekare.
Och sedan pekaren är lika med malloc storlek tum gånger 10.
Jag skapar en pekare.
Och sedan jag tilldela det pekare till värdet av den pekare som malloc
är att ge mig.
>> Så jag ber malloc kan du tilldela utrymme för 10 heltal.
Det är vad det säger.
Och malloc ger mig tillbaka en pekaren till den platsen.
Vettigt?
OK.
Jag Och GetString är, i grunden, göra en ringa till malloc så att du kan tilldela
minne under körning.
>> Kom ihåg att alltid kontrollera null eftersom malloc kommer att returnera null
om den inte kan allokera minne.
Låt oss säga att du ber om en löjlig mängd minne.
Datorn kommer inte att bli kunna fördela så mycket.
>> Så malloc är bara att gå att returnera null.
Så kom ihåg att alltid kontrollera om pekare som du fick från malloc är
null eller inte, för om det är, kanske du vara dereferencing en pekare och
orsakar sido fel.
Och till sist, glöm inte din gratis minne.
>> Malloc skapar minne i högen.
Och du måste frigöra minne innan programmet avslutas.
OK, det är allt för mig.
Tyvärr, Rob.
Tack.
>> [Applåder]
>> LUCAS: Några sista frågorna innan Rob kommer?
Nej?
Yeah?
>> PUBLIK: Jag såg inte här på nätet.
Har du laddat upp den än?
>> LUCAS: Jag tror att Dave är ladda upp det snart.
>> Dave: Det ska läggas upp.
>> LUCAS: Det ska vara på nätet.
>> PUBLIK: Det är upp.
>> LUCAS: Det är upp?
OK.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Ja, bör du frigöra all minne som läggs i högen.
>> PUBLIK: [OHÖRBAR]?
>> LUCAS: Ja.
Varje gång du har en kultur malloc, du bör ha en kultur fri
efter att du slutat använda den variabeln.
Så malloc och free är alltid tillsammans.
Deras bästa vänner.
Yeah.
Rob?
>> ROB: Jag ska gå snabbt.
Och även videon kommer att sättas upp.
Jag har mic på.
>> OK, så vecka fem grejer.
Första var vi har är stacken.
Så kom ihåg att det finns bara en stapel frame per samtal aktiv funktion.
Vi ser att i en sekund.
Och även komma ihåg vad som faktiskt går i varje stapel ramen kommer att vara
de lokala variabler i våra funktioner, de argument som skickas in i vår
funktioner, tillsammans med ett par andra saker du egentligen inte
behöver oroa dig.
>> Så här är ett exempel på program där, varsel, huvud är printfing avkastningen
värdet av foo 4.
foo är bara att returnera värde på bar 4 kommatecken 6.
Och bar kommer att ställa vissa lokala Variabeln n är lika med 4 gånger 6.
Och sedan tillbaka n.
>> Så låt oss titta på stapeln under hela själva upprepningen av detta program.
Så det finns i botten av vår stack.
Kom ihåg att stacken växer upp.
Så i botten av vår stack, vi ha en stack ram för main.
När programmet startas, huvud kommer alltid att vara på
ner på vår stack.
>> Och vad som finns i vår stack ram för huvud?
Så även om det inte finns någon lokal variabler till huvud, som jag sa tidigare,
Vi har argc och rgv tar upp plats insidan av huvud stack ramen.
Så viktigaste är nu att anropa funktionen foo.
Och det innebär foo kommer att få en egen stack ram.
>> Så nu är vi inne i funktionen foo.
Och vad som behöver gå in foo stack ram?
Tja, har foo ett argument n.
Och n är lika med 4, eftersom det är vad Huvud passerar som foo argument.
>> Så nu foo kommer att ringa bar.
Vad bar kommer att ha inne av dess "stack ram?
Den har x lika med 4 y lika med sex.
Det är inte allt som vi ska ha i stacken ramen eftersom bar
också har en lokal variabel n.
Och n vi kommer att ställa lika med 24.
>> Så nu bar kommer att återvända n.
Så bar återvänder 24 till stacken ramen foo.
Och eftersom baren är nu återvänder, att betyder att vi poppar stacken ramen
för Stapel av i bunten.
Så allt det minne som baren hade varit använder är nu av stapeln.
>> Nu är foo också gå för att återgå 24 till huvud.
Så nu när foo är tillbaka, minnet att foo använde i sin "
stack ram är också borta.
Och nu är huvud kommer att kalla printf.
Så printf är bara en annan funktion.
När vi kallar printf, det kommer att bli annan stack ram för printf
funktionsanrop.
>> Vad är det vi passerar printf?
Det är vad som kommer att gå på dess stack ram.
Åtminstone, vi passerar som procent i backslash n och
argumentet 24.
Det kanske har mer i det stack ram om printf råkar använda vissa
lokala variabler.
Vi vet inte.
>> Men allt som går i printf s stapla ram.
Det kommer att utföra printf.
Då printf är gjort.
Den kommer tillbaka.
Slutligen, huvud görs.
Huvud kommer tillbaka.
Och så vårt program är gjort.
Yeah?
>> PUBLIK: Ser du [OHÖRBAR]
argument [OHÖRBAR]
parametrar?
>> ROB: Så det finns en subtil skillnad mellan argument och parametrar.
Och egentligen, gemensamt tala, människor tenderar att bara blanda upp dem hela tiden.
Men parametrarna är de formella Namn på saker.
>> Så argc och argv är de parametrar till main.
Argument är vad du faktiskt passera som dessa parametrar.
Så det när jag ringer foo av 4, 4 är argumentet jag passerar i.
Och parametern n, inuti foo, tar på värdet 4
sedan 4 var argumentet.
>> PUBLIK: [OHÖRBAR]?
>> ROB: n är en lokal variabel till bar.
n är fortfarande lokal till foo, men det är en parameter att foo.
Det är inte en lokal variabel.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: foo är bara ringa bar och vänder oavsett bar avkastning.
>> PUBLIK: [OHÖRBAR]?
>> ROB: Ja, bara för att se flera stapla ramar.
Yeah?
>> PUBLIK: Varför var foo kallades innan printf?
>> ROB: Varför var foo anropas innan printf?
Så jag kunde ha, i stället, gjort något som int x är lika foo av 4
och sedan skrivas x.
Men istället, jag kombinerade funktionen ringa till printf argumentet.
>> Men märker att vi inte kan faktiskt exekvera anropet till printf tills vi
räkna ut vad foo av 4 är.
Så vi kommer att utvärdera detta.
Och bara en gång det är gjort går att komma tillbaka och utvärdera detta.
Yeah?
>> PUBLIK: Eftersom både bar [OHÖRBAR]
värde, varför har vi inte [OHÖRBAR]?
>> ROB: De helt borde vara int.
Det var inte fångas över flera passager.
Så det borde vara int bar och int foo eftersom båda dessa
återvänder heltal.
Void är bara om de inte tänker att återvända ärvärden.
Yeah?
>> PUBLIK: Om du hade en linje ovan avkastningen, [OHÖRBAR]?
>> ROB: En linje över returen?
>> PUBLIK: Ja.
Som om du gjorde printf och [OHÖRBAR], skulle det skrivas ut två gånger?
>> ROB: Så insidan av foo?
Om vi hade en printf just här?
>> PUBLIK: Ja.
>> ROB: Så om vi hade en printf rätt Här skulle det skrivas ut en gång.
Eftersom vi kallar foo gång rätt här, då ska vi träffa printf.
Sedan ska vi kalla bar.
Och då foo kommer tillbaka.
Och det är det.
Vi bara skulle stöta printf gång.
Yeah?
>> PUBLIK: [OHÖRBAR]
printf ringer foo eftersom vi är först ringer printf och då vi passerar
argumenten.
>> ROB: Så i teorin, är inte printf anropa foo?
Så nej.
Bara för att C ska utföra dessa saker är, innan vi kan
anropa en funktion, alla av argumenten till funktionen måste
vara fullständigt utvärderats.
Så är det helt utvärderas?
Ja, det är bara en sträng.
Det är bara ett värde.
>> Då måste vi helt utvärdera detta.
När detta är gjort, nu alla sina argument utvärderas.
Och nu kan vi göra det ringa till printf.
Yeah?
>> PUBLIK: En fråga.
Om du har ett tomrum funktion, måste du har retursemikolon?
>> ROB: Du gör inte en återgång semikolon om du har ett tomrum funktion.
OK.
Så nu några högen grejer.
Så hög är hur vi ska hantera med dynamisk minneshantering.
Och detta kontrasterar direkt med stack som vi skulle kalla automatisk
minneshantering.
>> Så på stacken, du aldrig riktigt har att ta itu med hur de lokala variabler
skjuts och flög av alla Dessa stack ramar och allt det där.
Du behöver inte oroa dig för det.
Den är automatisk.
Så högen är manuell.
Och det [OHÖRBAR]
kommer från dessa funktioner malloc och free.
>> Så här är ett annat program.
Allt vi gör är mallocing ett heltal.
Vi lagrar den i stjärn x.
Naturligtvis måste vi kontrollera för att se om x är noll.
Då ska vi bara ställa in vad x pekar på att 50.
Skriv vad x pekar på, print x, och därefter fri x.
>> Så hur är det faktiskt kommer att se ut om vi tittar på vår stack och heap?
Så vi börjar igen.
I botten av vår stack som tidigare.
Kom ihåg att thee upplag direkt motsätter bunten?
Så vi kommer att ha högst upp på vår högen uppe.
>> Så ner på vår stack, vi har vår stack ram för main.
Den har utrymmet för argc, argv och vi nu har en lokal variabel x, vilket
är en int stjärna.
Så vi kommer att iterera genom detta program.
Första vi har är ett anrop till malloc.
>> Så vi gör ett anrop till malloc.
Malloc är en funktion.
Det kommer att få en stack ram.
Vad är det vi går till malloc?
Det kommer att gå in av stapeln ramen.
Vi passerar storlek n, vilket är 4.
Så som skickas till malloc.
>> Vad gör malloc gör?
Det tar tag i oss lite utrymme på högen.
Så vi kommer att gå till högen.
Och vi kommer att ta tag i 4 byte från högen.
Så låt oss bara ge att en godtycklig adress.
0x123 låtsas Bara det är en adress som är på högen.
>> Så vad är faktiskt inne på att regionen i minnet på adress Ox123?
Garbage.
Så vi har inte lagrat något i det.
Så så vitt vi vet, det kan vara vad som helst.
Du ska inte tro att det är noll.
Det är sannolikt inte noll.
>> Så nu malloc avkastning.
Och vad gör vi när malloc returnerar?
Vi satt vad den returnerar.
Vi satt x lika med vad den återvänder.
Så vad är det att återvända?
Det åter 0x123 eftersom det är den adressen för minnesblock som det
bara fördelas i högen.
>> Så tillbaka 0x123 x kommer nu att ställas in lika med 0x123 som, pictorially,
vi drar ofta som x med en verklig arrow pekar på det blocket.
Men x är bara lagra den adressen.
Så nu har vi att kontrollera om x är noll.
Det är inte null.
Vi låtsas att det malloc lyckades.
>> Så nu stjärniga x är lika med 50.
Så stjärnan minns det betyder gå till den adressen.
Så 0x123 Vi ska gå till den adressen.
Så att för oss där uppe.
Vad gör vi på den adressen?
Vi lagrar 50.
>> Så efter denna linje, det är vad saker kommer att se ut.
Så nu är det inte längre skräp där uppe.
Nu vet vi att 50 är i det viss adress eftersom
vi ställa in den på det.
OK?
Så nu ska vi ut f..
>> Så först ska vi ut stjärn x.
Så vad är stjärn x?
Återigen, stjärna x medel går till sak som x pekar på.
Så x lagrar 0x123 Gå till det.
Vi får 50.
Så ut f det.
Och det betyder att det kommer att skriva ut 50.
Och då återvänder.
>> Och sedan har vi den andra printf.
Vi är nu procent sid.
Om du inte har sett det, det är hur du skriver ut en pekare.
Så vi har procent i, procent f, och alla de som redan.
Så procent p, skriva ut en pekare.
>> Så x är en pekare.
Så om vi ska skriva ut x själv, Vi skriver ut vad som faktiskt inne
x, som är 0x123 Så den första print f kommer att skriva ut 50.
Det andra trycket f kommer att skriva ut 0x123 Yeah?
>> PUBLIK: Använder du procent x för att skriva ut en pekare?
>> ROB: Så använder du procent x för att skriva ut en pekare?
Så kan du men procent x är bara, generellt, för som om du har några
heltal och du vill skriva ut det som ett hexadecimalt.
Det är bara hur du gör det.
>> Mot procent d skulle ut som decimala.
Det är var vi får procent d. i är bara heltal.
procent p är specifikt för pekare.
>> Så x är en pekare.
Vi vill använda procent sid.
Men procent x skulle kunna fungera.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Ja.
Åtminstone för detta samtal - så jag tog inte med det här.
Men dessa två argument är nödvändigtvis Insidan av detta stackram
tillsammans med några lokala variabler printf råkar använda.
Och sedan nästa anrop till printf nu insidan av printf stackram är
procent p backslash n och oavsett värdet på x är, som är 0x123.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Det kommer ut något som ser ut så här.
>> PUBLIK: [OHÖRBAR].
>> ROB: Så det skriver det i adressformuläret.
Det ser ut som en adress.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Varför är det?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Varför är denna pekare 4 byte?
Så det finns en hel *** av 0-talet i framför denna.
Så det är verkligen 0x0000000123.
Till ett 64-bitars system, skulle det finnas en hel *** fler nollor.
Yeah?
>> PUBLIK: [OHÖRBAR].
>> ROB: Så den första printf kommer att skriva ut -
>> PUBLIK: [OHÖRBAR].
>> ROB: Ja, det kommer att skriva ut vad x pekar på.
Star säger vad är det här sak pekar på.
Ta det.
Så vad är det som pekar på?
50.
Ta det.
Det är vad vi ska skriva ut.
Mot nästa, vi är bara skriver ut x själv.
Vad är inne i f?
0x123.
OK.
>> Och då, äntligen, har vi den gratis.
Vad är det vi går för att frigöra?
Vi passerar x.
Den gången jag faktiskt visas det i stapeln ramen.
>> Så vi passerar värdet 0x123 till gratis.
Så nu gratis vet, okej, Jag måste gå upp till högen
och gratis som minne.
Det är inte längre använda det som är på adress 0x123.
>> Så fri kommer att släppa att från högen.
Nu är vår högen är tom igen.
Vi har inga minnesläckor.
Nu fri kommer att återvända.
Lägg märke till att x är fortfarande 0x123.
Men det är nu inte giltig minne.
Vi bör inte längre avreferering x.
Yeah?
>> PUBLIK: Är tillbaka 0 överflödig?
>> ROB: Är Returen 0 överflödig?
Ja.
Vi sätter bara att det därför vi har en retur ett för luft.
Så det är som, ja, låter inkludera retur 0.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Så efter fri x, vad som händer om Vi försöker avreferera pekaren?
Det är möjligt att ingenting går fel.
Det är möjligt att vi fortfarande kommer att få 50.
>> Det är möjligt, också, att detta minne är nu används för något annat.
Så det är odefinierat beteende.
Och undefined betyder något kan hända.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Nej, så om du tilldelar x till något annat.
Så om just här sa vi x är lika med malloc något annat -
malloc storlek händelse -
då som ursprungliga blocket minne är inte befriad.
Och vi har officiellt förlorat det.
Det är en minnesläcka.
Vi har förlorat alla referenser till det minnesblock.
Så det finns inget sätt vi någonsin kan frigöra den.
OK, så då åter 0 betyder gjort.
>> Okej, så stack overflow.
Vad är tanken här?
Så kom ihåg, heap är på väg ner.
Stack är på väg upp.
Så detta var exemplet från föreläsningen, Jag tror, där huvud är bara att
kallar denna funktion foo, som kommer att kalla sig rekursivt över och
om igen.
>> Så stack ramar kommer att fungerar exakt samma.
Så vi kommer att börja med huvud som bottenstackramen.
Sedan huvud ska ringa foo, vilket kommer att få en stack ram.
>> Sen foo kommer att ringa foo igen, vilket kommer att få
annan stapel ramen.
Och sedan igen, och igen, och igen, och igen tills, slutligen, vi kör
in i högen.
Så det här är hur vi får en stack overflow.
Och vid denna punkt, Seg du fel.
Eller skulle du verkligen SEG fel innan denna punkt, men ja.
>> PUBLIK: Är kärna dumpa samma som seg fel?
>> ROB: Så ser du segmente fel kärna dumpad.
Du får en core dump när du SEG fel.
Och det är som en dump av alla de innehållet i nuvarande minnet så
att du kan försöka identifiera varför du SEG klandras.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Så en segmentering fel innebär det finns en stack overflow.
Så inte nödvändigtvis.
En segmentering fel innebär att du är gripande minne på ett sätt
du bör inte vara.
Så ett sätt för att det ska hända är när du stack overflow, vi börjar röra
minne på ett sätt som vi inte borde vara.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Så inne i en oändlig loop.
Liksom, detta är som en rekursiv oändlig loop och så vi får en annan
stackramen varje gång.
Men precis innanför en regelbunden oändlig medan en -
väl, låt oss inte ens skriva ut f -
göra något.
Oavsett vad.
>> Vi kommer inte att få annan stapel ramen.
Vi ska bara hålla looping över denna instruktion.
Stacken är inte växer.
Det är det faktum att varje rekursiva Samtalet ger oss en stack ram.
Det är därför vi får en stack overflow.
Yeah?
>> PUBLIK: Så om du sa att få while-slinga och sedan [OHÖRBAR]?
>> ROB: Så om insidan av while-slingan det fanns en printf, du fortfarande skulle
inte seg fel.
Jag bara inte vill blanda ihop saker och ting.
Det skulle slingan.
Du skulle få en enda stack rama för printf.
>> Då skulle printf återvända.
Då du skulle loop igen.
Du skulle få en enda stack rama för printf.
Det skulle återvända.
Single stack ram.
Så du inte får denna oändliga hopar sig stackramar.
>> PUBLIK: [OHÖRBAR]?
>> ROB: Ja.
Så här stackspill inträffar eftersom ingen av dessa
samtal till foo återvänder.
Så om vi återvänder, då skulle vi börja tappa stack ramar.
Och då vi inte skulle stapla spill.
Och det är därför du behöver ett basfall för dina personliga funktioner.
Yeah?
>> PUBLIK: Är den potentiella storleken och stapla för högen samma för
alla program?
>> ROB: Ungefär.
Är den potentiella storleken på stapeln och högen samma för alla program?
Ungefär.
Det finns en viss randomisering till där stack startar och
där högen startar.
Om du råkar ha en hel del globala variabler och saker, kanske du
ta bort från en del utrymme för hög.
>> På en 64-bitars system, du nästan har oändligt minne.
Det är bara så mycket.
Mellan 32 bitar och 64 bitar, som är en signifikant skillnad.
>> Du kommer att få en hel del mer stack och heap utrymme på en 64-bitars
systemet för det finns bara mer adresser som de kan använda.
Men om ett enskilt system, kommer det vara ungefär samma mängd stack
och heap-utrymme.
Okej.
>> Så sista är sammanställning.
Så du bör känna denna process.
Det finns fyra stora steg.
Så det första en bör vara lätt att komma ihåg.
Pre-processing.
Den har prefixet före i den.
Så det går före allt annat.
>> Det sak att komma ihåg är hash.
Så hash definierar och hash innehåller i alla dessa.
De är alla pre-processor direktiven.
Dessa är de saker som pre-processorn tar hand om.
>> Så vad gör en pre-processor gör?
Det är en riktigt dum sak.
Allt det är i stånd att är alla dessa kopiera och klippa och klistra in.
>> Så hash innehåller standarden i0 dot h..
Vad är att göra?
Det är att ta tag i standard i0 dot h fil och klistra in den i toppen
överallt där det står hash innehåller standard i0 prick h..
>> Och någon hash definierar att vi har sett, vad är att göra?
Dess kopiera det värde som hash definieras definieras som och klistra in som
var du än är med hjälp av värdet.
Så preprocessorn gör bara riktigt enkla textbaserade verksamheter.
Det gör inget smart.
Så allt annat är mer komplicerat.
>> Så nu när Preprocessor är gjort, vi faktiskt kompilera.
Så vad betyder sammanställa detta?
Vi ska nu gå från C-kod till assemblerkod.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Ja, fångade vi det.
Så kompilerar.
Vi går från C till montering.
Så det här är en verklig förändring språk.
Kompilera själv innebär att gå från en högre nivå språk till
ett språk lägre nivå.
>> Och c är ett högnivåspråk jämfört med monteringen.
Vad är monteringen?
Dess instruktioner som är nätt mycket, gjord för din processor.
Men datorn fortfarande gör inte förstår montering.
Den förstår bara ettor och nollor.
Så nästa steg är montering, vilket tar oss från dessa instruktioner som
din processor förstår och faktiskt översätter dem, till
ettor och nollor.
>> Så C till montering till binärt.
Men jag vill inte ha en körbar ännu.
Så tänk på CS50 biblioteket.
Vi har försett dig med en binär för denna CS50 bibliotek, som har GetString
och getInt och allt det där.
>> Men CS50 biblioteket -
i och för sig - är inte körbar.
Den har inte en huvudfunktion.
Det är bara en *** binär som du kan använda.
Så länka är hur vi sammanför alla av dessa olika binära filer
till en verklig körbar.
En som du kan skriva dot slash en prick ute.
>> Så det här är som den fil som du skrev, - oavsett ditt program är -
Ceaser prick c.
Men nu har det sammanställts ned till binär.
Så Ceaser prick o.
Och det här är vår CS50 bibliotek binär.
Och de kombineras i en enda körbar.
Yeah?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Så först inkludera, kom ihåg, hash innehålla är egentligen en
pre-processorn steget.
Men det är separata.
Om du inte använder någon funktion som är utanför ditt enda fil då,
nej, behöver du inte koppla något eftersom du har allt.
>> Som sagt, är printf är kopplade i.
Om du någonsin använder printf, det är något som måste länkas i
eftersom du inte skrev det.
Och, faktum är printf automatiskt länkade i.
Du vet hur på kommandoraden eller när du skriver gör, ser du det har
dash l CS50, som har samband i CS50 biblioteket?
Printf, och sånt, går ska kopplas in automatiskt.
Alla andra frågor om vad som helst?
>> PUBLIK: [OHÖRBAR]?
>> ROB: Länka?
Vi har en hel *** olika binära filer.
Detta är den kanoniska exemplet som vi använder är CS50 bibliotek.
Vi har sammanställt och ges till dig binär för CS50 bibliotek.
>> Du vill använda GetString i ditt program.
Så du går och använda GetString.
Men utan min binär kod för GetString, när du bygger din kod
ner, kan du inte faktiskt köra din programmet eftersom GetString String är
ännu inte är helt definierad.
>> Det är bara när du länkar i mitt binära som innehåller GetString som nu, allt
rätt, jag kan faktiskt exekvera GetString.
Min fil är klar.
Och jag kan köra detta.
Yeah?
>> PUBLIK: Har länka konvertera det binära till körbar?
Så även om du inte har andra bibliotek, skulle det fortfarande vara
krävs för att översätta den [OHÖRBAR]?
>> ROB: Så en körbar är fortfarande i binärt.
Det är bara att kombinera en hel gäng binärer.
>> PUBLIK: Tack så mycket.
>> ROB: Inga problem.
Fler frågor?
Annars är vi alla satt.
Okej.
Tack.
>> [Applåder]
>> PUBLIK: Tack.
>> ROB: Ja.