>> DAVID MALAN: Hej, och välkommen tillbaka till CS50.
Så detta är slutet på vecka fyra.
Bara ett meddelande först.
Så den så kallade femte måndag är kommer upp denna kommande måndag.
Detta är den möjlighet att byta från SAT / UNSAT till ett brev klass, eller från
brev klass SAT / UNSAT.
Irriterande, gör att processen kräver en signatur, eftersom du måste fylla
ut en av dessa rosa add / drop former.
>> Eftersom tekniskt, SAT / UNSAT version och brev klass version
har distinkt katalognummer.
Men ingen big deal.
Bara komma upp till mig eller till Rob eller till Lauren som helst.
Eller maila oss om du inte har den sortens pappersarbete du behöver idag, och vi
kommer säkert att hjälpa dig att ta hand om det innan måndag.
>> Okej, så idag -
faktiskt, det är lite av ett eko.
Kan vi tona ner mig lite?
OK.
Så idag introducerar vi ett ämne kallas pekare.
Och jag ska erkänna att detta är en av de mer komplexa ämnen som vi tenderar att
täcka i denna klass, eller egentligen någon introduktionskurs som använder C.
>> Men ta mitt ord för det, särskilt Om ditt sinne känns lite mer böjd
idag och i de kommande veckorna.
Det är inte representativ för att du får värre på detta det betyder bara att
det är en särskilt sofistikerad ämne jag lovar, några veckor
därmed kommer att verka alltför påfallande okomplicerad i efterhand.
>> Jag minns fortfarande till denna dag.
Jag satt i Elliott Dining Hall, sitter bredvid min TF Nishat Mehta,
som var bosatt i Elliott huset.
Och av någon anledning, detta ämne klickar bara.
Vilket är att säga att även jag kämpade med den för en viss tid, men jag
kommer att göra mitt bästa för att hjälpa till att undvika en sådan kämpar med ett ämne som i slutändan
är ganska kraftfull.
>> I själva verket ett av de ämnen som vi kommer att diskutera i de kommande veckorna är att
av säkerhet, och hur du kan faktiskt utnyttja maskinerna på sätt
som inte var avsedda.
Och dessa exploateringar är typiskt resultatet av buggar, misstag som vi
människor gör genom att inte förstå några av den underliggande genomförandet
information via vilka program görs.
>> Nu för att göra detta verkar allt mer användarvänliga vänlig, trodde jag att jag skulle spela en 10
andra förhandsvisning av en liten claymation Figuren heter Binky som fördes till
livet av en vän till oss på Stanford, professor Nick Parlante.
Så låt mig ge dig det här teaser av Binky här.
>> [VIDEO SPELA]
>> -Hej, Binky.
Vakna.
Det är dags för pekaren kul.
>> -Vad är det?
Läs om pekare?
Åh, goodie.
>> [END VIDEOAVSPELNING]
>> DAVID MALAN: Det är Stanford datavetenskap.
Så mer om detta framöver.
>> [Applåder]
>> DAVID MALAN: Tyvärr, Nick.
>> Så minns att förra gången vi slutade på detta verkligen spännande cliffhanger
varigenom denna funktion bara fungerade inte.
Åtminstone intuitivt, det kändes som det borde fungera.
Enkelt att byta ut värdena av två heltal.
Men minns att när vi skrev ut ursprungliga värdena i huvud, en och
två, var de fortfarande en och två och inte två och en.
>> Så låt mig faktiskt byta över till apparaten.
Och jag skrev upp lite av skelett kod i avancera här, där jag hävdar att x
kommer att vara ett, kommer y vara 2.
Jag skriver ut sedan ut båda sina värden med tryck f.
>> Jag hävdar då här nere att vi kommer att byta dem.
Jag lämnade en tom plats här för oss att fyll i dag på bara ett ögonblick.
Sedan kommer jag att hävda att två variabler har bytts.
Sedan kommer jag att skriva ut ut dem igen.
Och så förhoppningsvis ska jag se 1, 2.
2, 1.
Det är super enkelt Målet just nu.
>> Så hur går vi om att byta två variabler?
Tja, om jag föreslår här att dessa koppar kan representera minne i en dator.
Detta är några tuggor, detta är ytterligare några tuggor.
Kan vi ha en volontär Kom upp och blanda oss några drinkar, om bekant?
Kom upp.
Vad är ditt namn?
>> JESS: Jess.
>> DAVID MALAN: Jess?
Kom upp, Jess.
Om du inte gör något, måste vi sätta Google Glass på dig så att vi kan
föreviga detta.
OK, glas.
Spela in en video.
Och OK, är vi bra att gå med Jess hit.
Okej.
Trevligt att träffas.
>> Så vad jag vill att du gör här - om du kunde, ganska snabbt -
bara häller oss ett halvt glas apelsin juice och ett halvt glas mjölk,
företräder effektivt siffrorna 1 i en kopp och två i den andra koppen.
>> Detta kommer att bli bra film.
>> JESS: Förlåt.
>> DAVID MALAN: Nej, nej.
Det är OK.
Trevligt.
Okej, så vi har fyra bytes värt apelsinjuice.
Vi kallade det värdet 1.
Nu ytterligare fyra bytes värde av mjölk.
Kommer att kalla det värde 2.
Så x och y, respektive.
>> Okej, så nu om uppgiften - för dig, Jess, framför allt
av dina klasskamrater -
är att byta värden på x och y sådana att vi vill ha apelsinjuice i
andra kopp och mjölk i denna cup, hur kanske du - innan du faktiskt gör
det - gå om att göra detta?
>> OK, klokt beslut.
Så du behöver lite mer minne.
Så låt oss fördela en tillfällig cup, om ni så vill.
Och nu fortsätter att byta x och y.
>> Utmärkt.
Så mycket bra gjort.
Tack så mycket, Jess.
Varsågod.
En liten souvenir.
>> OK, så självklart, super enkel idé.
Helt intuitivt att vi behöver lite mer lagringsutrymme - i denna form,
en kopp - om vi verkligen vill byta dessa två variabler.
Så låt oss göra precis det.
Här uppe i mellan där jag hävdar jag kommer att göra något byte, jag ska
gå vidare och förklara temp.
Och jag ska sätta den lika med, säg, x.
>> Sedan kommer jag att ändra värdet på x precis som Jess gjorde här med
mjölk och apelsinjuice vara lika med y.
Och jag kommer att ändra y vara lika att inte x, eftersom vi nu skulle vara
fastnat i en cirkel, utan snarare temp.
Där jag tillfälligt - eller när Jess tillfälligt sätta apelsinjuice
innan dunkardags att kopp med mjölken.
>> Så låt mig gå vidare nu och göra detta.
Det kallas noswap.c.
Och låt mig nu köra utan swap.
Och ja, jag ser, om jag expandera fönstret lite, som
x är 1, y är 2.
Och då x är 2, y är 1.
>> Men minns att på måndag vi gjorde saker lite annorlunda där jag
istället genomfört en hjälpare funktion, om du vill, var som faktiskt ogiltigt.
Jag kallade det byta.
Jag gav det två parametrar, och jag ringde dem en och jag kallade dem b..
>> Ärligt talat, skulle jag kalla dem x och y.
Det finns ingenting som hindrar mig från att göra det.
Men jag skulle vilja hävda att det är då lite tvetydig.
Eftersom återkallelse för måndag som vi hävdade att dessa parametrar var
kopior av de värden som gått i.
Så det bud bara med din sinne, tror jag, om du använder
exakt samma variabler.
>> Så jag ska istället kalla dem en och b, bara för tydlighetens skull.
Men vi kan kalla dem mest vad vi vill.
Och jag kommer att kopiera och klistra in effektivt denna kod från uppe
ner i här.
Eftersom jag såg bara att det fungerar.
Så det är i ganska bra form.
Och jag ska ändra min x till en, mitt x till en, min y till b och min y till b..
>> Så med andra ord, exakt samma logik.
Exakt samma sak som Jess gjorde.
Och så en sak som jag måste göra upp här, är naturligtvis åberopa nu detta
funktion, eller ring denna funktion.
Så jag kommer att kalla denna funktion med två ingångar, x och y, och hit Spara.
>> Okej, så fundamentalt samma sak.
I själva verket har jag förmodligen gjort programmet onödigt komplicerad genom
skriva en funktion som bara tar cirka sex rader kod medan jag
tidigare hade genomfört detta på bara tre.
>> Så låt mig gå vidare nu och remake detta, gör ingen swap.
Okej, skruvade jag upp här.
Detta borde vara ett fel som du kanske se alltmer vanligt som din
program blir allt mer komplexa.
Men det finns en enkel fix.
Låt mig rulla tillbaka upp hit.
>> Och vad är det första felet jag ser?
Implicit deklaration.
Vad indikerar det typiskt?
Åh, glömde jag prototypen.
Jag glömde att lära kompilator som swap kommer att existera även om han
finns inte i början av programmet.
Så jag ska bara säga ogiltig, swap, int, en int b, semikolon.
>> Så jag tänker inte reimplement det.
Men nu det matchar vad är här nere.
Och lägg märke till avsaknaden av ett semikolon här, vilket inte är nödvändigt när
genomförande.
>> Så låt mig göra om detta, gör ingen swap.
Mycket bättre form.
Kör ingen swap.
Och damn it.
Nu är vi tillbaka där vi var på måndagen, där saken inte byta.
>> Och vad är den intuitiva förklaringen för varför detta är fallet?
Yeah?
>> STUDENT: [OHÖRBAR].
>> DAVID MALAN: Exakt.
Så a och b är kopior av x och y.
Och faktiskt, när du har varit anropa en funktion så långt att
passerar variabler som ints -
precis som swap väntar här -
ni har passerat i kopiorna.
>> Nu som innebär att det tar lite av tiden, en bråkdels sekund, för
dator för att kopiera bitar från en variabel i bitarna i en annan.
Men det är inte en så stor sak.
Men de är ändå en kopia.
>> Och så nu, inom ramen för swap, Jag är faktiskt framgångsrikt
ändrar a och b.
I själva verket, låt oss göra en snabb sanity check.
Skriv f a är% i, ny rad.
Och låt oss koppla in en.
Nu ska vi göra samma sak med b..
Och låt oss göra samma sak här.
>> Och nu, låt mig kopiera samma linjer igen vid botten av funktionen
efter mina tre rader av intressant skulle ha utförts, och
skriva ut a och b ännu en gång.
Så nu ska vi göra det här, gör ingen swap.
Låt mig göra terminalfönstret en lite längre, så att vi kan se
mer av det på en gång.
>> Och kör ingen swap.
x är 1, y är 2. a är 1, b är 2.
Och sedan, är en 2, b är 1.
Så det fungerar, precis som Jess gjorde här inne för swap.
Men naturligtvis, det har ingen effekt på variablerna i main.
>> Så såg vi ett trick där vi kunde fixa det här, eller hur?
När du står inför denna avgränsning fråga, kan du bara punt och göra x
och y vilken typ av variabler i stället?
>> Du kan göra dem globalt.
Sätt dem i toppen av filen som vi gjorde, även i omgång 15.
Vi använder en global variabel.
Men inom ramen för spelet en 15, det är rimligt att ha en global
variabel som representerar styrelsen, eftersom helheten av 15.c är alla
om genomförandet av det spelet.
Det är vad filen finns att göra.
>> Men i det här fallet, är jag anropa en funktion swap.
Jag vill byta två variabler.
Och den bör börja känna bara slarviga Om lösningen på alla våra
problem när vi kör in i omfattning frågor är att göra det globalt.
Eftersom mycket snabbt vårt program är kommer att bli ganska rörigt.
Och vi gjorde det mycket sparsamt som ett resultat i 15.c.
>> Men det visar sig att det finns en bättre sätt helt och hållet.
Låt mig faktiskt gå tillbaka och radera ut f: s, bara för att förenkla koden.
Och låt mig föreslå att detta verkligen är dåligt.
Men om jag lägger istället in några asterisker och stjärnor, kan jag vända istället detta
funktion till en som är faktiskt operativt.
>> Så låt mig gå tillbaka hit och erkänna att säga asterisker är alltid svårt,
så jag ska säga stjärnor.
Jag ska bara fess upp till den.
Okej.
Och nu, vad ska jag att göra istället?
>> Så först av allt, jag kommer att ange att i stället för att passera en int in
swap-funktion, jag är istället att gå att säga int stjärna.
Nu, vad stjärnan indikerar?
Detta är att föreställningen om en pekare som Binky, den claymation karaktär var
hänvisa till för en stund sedan.
>> Så om vi säger int stjärna, innebörden av detta nu är att en inte kommer att vara
passeras i med sitt värde.
Det kommer inte att kopieras i.
Snarare är adressen till en kommer att föras in
>> Så minns att insidan av din dator är en hel massa minne, annars
känd som RAM.
Och att RAM är bara en massa byte.
Så om din Mac eller din PC har två gigabyte, har du 2
miljard byte minne.
>> Nu ska vi bara anta att bara för att hålla saker trevligt och välordnat, vi
tilldela en adress -
ett nummer -
till varje byte RAM i din dator.
Den allra första byten av dessa två miljarder med siffran noll.
Nästa gång det är byte nummer ett, nummer två, hela vägen vidare upp, dot dot
prick, till cirka 2 miljarder kronor.
>> Så du kan antalet bytes minne i din dator.
Så låt oss anta att det är vad vi menar med en adress.
Så när jag ser int stjärna en, vad som händer att föras in i swap nu är det
adressen för en.
Inte dess värde, men oavsett postal adress är, så att säga -
dess plats i RAM.
>> Och på samma sätt för b, jag kommer att säga samma sak.
Int, stjärna, b..
Som en parentes, tekniskt stjärnan kunde gå på andra ställen.
Men vi ska standardisera på stjärnan är intill datatypen.
>> Så byta signatur nu betyder, ge mig adressen till en int, och samtal
som adress en.
Och ge mig en annan adress för en int och kallar den adressen b..
>> Men nu min kod här måste förändras.
För om jag förklarar int temp -
som fortfarande är av typen int -
men jag lagra i det, vilken typ av värde?
För att vara tydlig, jag sätter ett a med Koden som skrivits just nu?
>> Jag sätter på plats i en.
Men jag bryr mig inte om platsen nu, eller hur?
Temp existerar bara Jess 'tredje cup funnits, i vilket syfte?
För att lagra ett värde.
Mjölk eller apelsinjuice.
Inte att faktiskt lagra adress någon av dessa saker, känns som en
lite meningslösa i denna verkliga globala sammanhang ändå.
>> Så egentligen, vad jag vill sätta i temp är inte adressen till en, men den
innehållet i ett.
Så om en är ett tal som 123, är detta den 123: e byte av minne som en bara
råkar vara ockuperar, att värdet i en råkar vara ockuperar.
>> Om jag vill gå till den adressen, Jag måste säga stjärna en.
Likaså om jag skulle ändra vad på adressen a, byter jag
detta att starta en.
Om jag vill spara i vad som finns på plats en med vad som finns på platsen
vid b, stjärna B stjärna.
>> Så kort sagt, även om detta inte är helt sjunka in ännu - och jag skulle inte förvänta sig
att det skulle så snabbt -
inser att allt jag gör är prefix dessa stjärnor till mina variabler,
säger inte tag värdena.
Ändra inte värdena.
Utan snarare, går till de adresser och få värdet.
Gå till den adressen och förändring värdet där.
>> Så nu låt mig rulla tillbaka upp till toppen, bara för att fixa denna linje här, till
ändra prototypen för att matcha.
Men jag måste nu göra en annan sak.
Intuitivt, om jag har ändrat de typer argument som swap väntar,
vad mer behöver jag ändra i min kod?
>> När jag pendling.
Eftersom just nu, vilken förmiddag Jag går att byta ändå?
Värdet x och värdet på y, eller mjölk och apelsinjuice.
Men jag vill inte göra det.
Jag vill i stället för att passera i vad?
Placeringen av x och platsen för y.
Vilka är deras postadresser, så att säga.
>> Så för att göra det, det finns ett &-tecken.
Ampersand slags låter som adress.
så N, et tecken, adress av x, och adressen y..
Så det är avsiktligt att vi använder et-tecken vid anrop av funktioner,
och stjärnor när du deklarerar och när genomföra funktionen.
>> Och tänk bara på et-tecken som adress, och stjärnan som
gå dit operatör -
eller, mer korrekt, den dereference operatör.
Så det är en hel del ord bara för att säga att nu, förhoppningsvis, är swap går
vara korrekt.
>> Låt mig gå vidare och göra -
låt oss faktiskt byta namn på filen, lest detta program fortfarande kallas ingen swap.
Jag hävdar att vi ska kalla det swap.c nu.
Så gör, byta.
Dot, snedstreck, byta.
>> Och nu faktiskt, är x 1, y 2.
Och sedan, är x 2, y är ett.
Nåväl låt oss se om vi inte kan göra detta en lite annorlunda om vad som är
pågår här.
Låt mig först zooma in på vår ritning skärm här.
Och låt mig föreslå ett ögonblick - och när jag drar här kommer att speglas
uppe nu - Låt mig föreslå att Här finns en massa minne, eller
RAM, insidan av min dator.
>> Och detta kommer att bli bite nummer, låt oss säga, 1.
Detta kommer att bli byte nummer 2.
Och jag kommer att göra en hel massa mer, och då ett gäng dot dot punkter till
tyder på att det finns 2 miljarder av dessa saker.
4, 5, och så vidare.
>> Så det är de första fem bytes av datorns minne.
Okej?
Mycket få av 2 miljarder.
Men nu ska jag föreslå följande.
Jag kommer att föreslå att x ska lagra numret 1, och y går
att lagra numret 2.
Och låt mig gå vidare nu och representerar dessa värden enligt följande.
>> Låt oss göra detta på följande sätt.
Ge mig bara en sekund.
En sekund.
OK.
Jag vill göra detta lite -
låt oss göra det igen.
Annars kommer jag till och använda Samma siffror, oavsiktligt,
flera gånger.
>> Så bara så att vi har olika antal att prata om, låt oss kalla detta byte
nummer 123, 124, 125, 126, och dot dot dot.
Och låt mig nu hävdar att jag ska sätta värdet 1 här, och värdet 2
här, annars känd som x och y.
Så det råkar vara så att detta är x, detta är y.
>> Och bara genom några slumpen, den dator, operativsystem,
råkade sätta x på plats nummer 123.
Och y hamnade på plats 124 -
fan det.
Jag borde ha fixat detta.
Oh man, jag vill verkligen göra det här?
Ja, jag vill fixa detta och b riktigt om detta idag.
Tyvärr, ny på detta.
>> 127, 131, och jag ville inte vara här komplex, men varför jag ändrar
siffror där?
Eftersom jag vill att ints till faktiskt vara fyra bytes.
Så låt oss vara super anal om detta.
Så att om en råkar åtgärdas 123 är 2 kommer att vara på adress
127 eftersom det är bara 4 byes bort.
Det är allt.
Och vi ska glömma alla de andra adresser i världen.
>> Så x är vid plats 123, y är vid plats 127.
Och nu, vad gör jag egentligen vill göra?
När jag ringer swap nu, vad egentligen som händer?
Jo, när jag ringer swap, jag går i adressen för x och adressen till y.
Så till exempel, om dessa två bitar av papper nu representerar två
argument a och b för att byta, vad är jag kommer att skriva på den första av dessa,
som jag kommer att kalla kallar en?
>> Exakt, 123.
Så här jag hävdar är en.
Detta är parametern ett.
Jag sätter adressen till x där.
>> Vad är det?
>> Nej, nej.
Det är OK.
Fortfarande bra, fortfarande bra.
Så det här är ett.
Och nu på andra papper, detta kommer att bli b, och vad är jag
kommer att skriva på detta papper?
127.
>> Så det enda som har förändrats sedan vår tidigare träffande i denna historia är,
snarare än bokstavligen 1 och 2, är jag kommer att passera i 123 och 127.
Och jag kommer nu att sätta dessa insida av denna box, okej?
Så att svarta lådan står nu swap-funktion.
>> Under tiden, låt oss nu ha någon implementera swap-funktionen.
Skulle någon här uppe vilja volontär?
Kom upp.
Vad är ditt namn?
Charlie.
Okej, Charlie.
Kom upp.
>> Så Charlie kommer att spela rollen av vår svarta låda.
Och Charlie, vad jag vill att du ska göra nu genomföra swap på ett sådant sätt
att, med tanke på dessa två adresser, du faktiskt gå
att ändra värdena.
Och jag ska viska i ditt öra hur du kör TV här.
>> Så sätt igång, och du är den svarta lådan.
Nå in där.
Vilka värden ser du för en, och vilka värden ser du för b?
>> CHARLIE: a är 123 och b är 127.
>> DAVID MALAN: OK, exakt.
Nu paus där för bara ett ögonblick.
Det första du ska göra nu, enligt koden - som
Jag ska nu dra upp på skärmen -
kommer att vara att avsätta lite bit av minnet som kallas temp.
Så jag kommer att gå vidare och ge dig det minnet.
>> Så detta kommer att bli en tredje variabel att du har tillgång till
du ringde temp.
Och vad ska du skriva på temp papper?
>> CHARLIE: pekare, eller hur?
>> DAVID MALAN: OK, ja inte nödvändigtvis pekare.
Så kodrad som jag har markerat på höger sida,
Låt oss börja där.
Det säger stjärnan en.
Så en just nu lagrar numret 123.
Och bara intuitivt, vad gjorde stjärna 123 detta?
>> Men specifikt, om a är 123, betyder stjärnan en vad?
Värdet av en.
Eller mer nonchalant, gå dit.
Så låt mig föreslå att du håller en i din hand, gå vidare och behandla det
som om det är en karta.
Och gå själv över till datorns minne, och hitta oss vad som är
vid stället 123.
Exakt.
>> Så vi ser på plats 123 är vad, naturligtvis?
OK, så vad värdet nu är du kommer att tas i temp?
Exakt.
Så gå vidare och göra det.
Och skriv numret 1 om bit papper som för närvarande är titeln temp.
>> Och nu är nästa steg att du kommer att genomföra
kommer att bli vad.
Tja, på höger sida av nästa kodrad är stjärnan b.. b, av
Naturligtvis lagrar en adress.
Det tar 127.
Star B betyder vad, nonchalant sett?
>> Gå till den platsen.
Så gå vidare och hitta oss vad vid stället 127.
OK.
Naturligtvis, vid stället 127, är fortfarande värdet 2.
Så vad ska du nu förvara vid vad är den plats i en?
Så stjärniga ett medel gå till platsen en.
Vad är läget ett?
>> Exakt.
Så nu, om du vill ändra vad är på den platsen -
Jag ska gå vidare och köra radergummit är här.
Och nu lägger tillbaka på borsten.
Vilket nummer ska du skriva i den tomma rutan nu?
>> Exakt.
Så här kodraden, att vara tydlig - låt mig paus vad Charlies gör och
påpeka, vad han just gjort är skriv in den rutan på plats 123
det värde som tidigare fanns på B.
Och så har vi nu genomfört faktiskt denna andra kodrad.
>> Nu tyvärr, det finns fortfarande en rad kvar.
Nu vad är i temp, bokstavligen?
Det är naturligtvis nummer ett.
Det är inte en adress.
Det är bara ett nummer, typ av en variabel från vecka ett.
>> Och nu när du säger stjärnan B, som innebär gå till adressen b, är vilken av
kurs här.
Så när du dit -
Jag ska gå vidare och radera vad är egentligen det - och vad är du
ska skriva nu på plats 127?
>> CHARLIE: Temp, som är ett.
>> DAVID MALAN: Temp, som är ett.
Och vad händer med temp i slutet?
Tja, vet vi inte riktigt vet.
Vi bryr mig egentligen inte.
Varje gång vi har implementerat en funktion hittills, några lokala variabler du har
är verkligen lokal.
Och de försvinner bara.
De är återtas av operativsystemet systemet så småningom.
>> Så det faktum att temp fortfarande har värdet 1 är slags fundamentalt
ointressant för oss.
Okej, så en applåd om vi kunde för Charlie.
Mycket bra gjort.
>> Okej, så vad mer gör Detta betyder att vi kan göra?
Så visar det sig att vi har varit berätta några vita lögner
under ganska lång tid.
I själva verket visar det sig att en sträng, all denna tid, är egentligen inte en
sekvens av tecken i sig.
Det slags är det intuitivt.
>> Men tekniskt sett är sträng en datatyp som vi deklarerade inuti
den CS50 biblioteket för att förenkla världen under de första veckorna av klass.
Vilken sträng egentligen är adressen av en karaktär någonstans i RAM.
En sträng är verkligen ett nummer, som 123 eller 127, det händer att avgränsa
där en sträng börjar i datorns minne.
>> Men om den inte motsvarar den string, per se,. självt
Och vi kan se detta på följande sätt.
Låt mig gå vidare och öppna upp del kod som finns bland
dagens källkod exempel.
Och jag ska gå vidare och öppna upp, låt oss säga, jämför-0.c.
Detta är en buggy program som kommer skall genomföras enligt följande.
>> First.
Jag ska säga något.
Sedan kommer jag att gå vidare och få en sträng från användaren
i det nästa rad.
Sedan kommer jag att säga det igen.
Sedan kommer jag att få en annan strängen från användaren.
>> Och varsel, visar jag en av de strängar i en variabel som heter s, och
en annan av dessa strängar i en variabel som heter t.
Och nu ska jag hävda, mycket rimligt, att om s är lika med lika t,
strängarna är desamma.
Du skriver samma sak.
Else, strängarna är inte samma sak.
>> Trots allt, om vi ingången två ints, två tecken, två flottar, två dubbelrum, några av
de datatyper som vi har pratat om hittills för att jämföra dem -
minns att vi gjorde mycket klart för ett tag sedan att du inte gör detta, eftersom en
enda likhetstecknet är naturligtvis tilldelningsoperatorn.
Så det skulle vara en bugg.
>> Vi använder lika likhetstecknet, som faktiskt jämför
saker för verklig jämställdhet.
Men jag hävdar att detta är buggig.
Om jag går vidare och gör jämföra noll, och gör sedan jämföra dot slash noll.
Och jag skriver i, låt oss säga, hej.
Och låt oss säga hej igen.
Bokstavligen samma sak, datorn påstår att jag skrivit olika saker.
>> Nu kanske jag stavat fel bara något.
Jag kommer att skriva mitt namn den här gången.
Jag menar, hallå.
Hej.
Det är olika varje gång.
>> Tja, varför är det?
Vad som verkligen händer under huven?
Tja, vad är det egentligen som pågår under huven är strängen sedan
Jag skrev i den första gången till exempel är ordet hej, förstås.
Men om vi företräder här nedanför huven, minns att en
Strängen är i en array.
Och vi har sagt så mycket i det förflutna.
>> Så om jag drar den arrayen så här, jag kommer att representera något helt
liknar vad vi gjorde för en stund sedan.
Och det är faktiskt något speciellt här, också.
Vad gjorde vi bestämmer var på I slutet av varje sträng?
Ja, denna backslash noll, vilket är bara sätt att representera,
bokstavligen, 00000000.
Åtta 0 bitar i rad.
>> Jag vet inte, ärligt talat, Vad är det efter detta.
Det är bara en massa mer RAM-minne insidan av min dator.
Men detta är en array.
Vi pratade om matriser innan.
Och vi talar vanligen om arrayer som läge noll,
sedan en, sedan två.
Men det är bara för bekvämlighet.
Och det är helt släkting.
>> När du faktiskt få minnet från datorn, det är naturligtvis något
2 miljard några udda byte, potentiellt.
Så egentligen under huven, all denna tid, ja.
Detta kan mycket väl vara fästet noll.
Men om du gräver ännu djupare under huven, det är verkligen
itu med nummer 123.
Detta är adressen 124.
Detta är adressen 125.
>> Och jag inte skruva upp den här gången.
Dessa är nu ett byte isär för vilken anledning?
Hur stor är en char?
En röding är bara ett byte.
En int är vanligtvis fyra bytes.
Så det är därför jag gjorde det 123, 127, 131 och så vidare.
Nu kan jag hålla matten enklare och bara göra plus 1.
Och det är nu vad som verkligen händer på under huven.
>> Så när du deklarerar något som detta, string s, är detta faktiskt -
visar det sig -
röding stjärna.
Star, innebär naturligtvis adress, aka pekare.
Så det är adressen till något.
Vad är det för adress?
>> Well -
Jag är den enda som kan se mycket viktig punkt jag gör, eller tror
Jag gör.
Så string -
det tråkiga är att jag har en bildskärm precis där jag
kunde ha sett det.
>> Okej, så string s är vad Jag förklarade tidigare.
Men det visar sig, tack vare ett litet magi i CS50 biblioteket, allt detta
tidssträng har bokstavligen varit röding stjärna.
Stjärnan innebär återigen pekare eller adress.
Det faktum att det är flankerar Ordet röding betyder att det är den
adress för ett tecken.
>> Så om få strängen kallas, och jag skriver i H-E-L-L-O, föreslår nu vad som får
string bokstavligen varit återvänder alla den här gången, även om vi har ganska
förenklad världen?
Vad får strängen faktiskt återvända som dess returvärde?
>> 123 i detta fall, till exempel.
Vi har tidigare sagt att få strängen helt enkelt returnerar en sträng, en sekvens av
tecken.
Men det är lite av en vit lögn.
Sättet att få strängen verkligen fungerar under huven är det blir en
strängen från användaren.
Det plops de tecken som han eller hon skriver i minnet.
Det sätter en backslash noll vid slutet av dem sekvens av tecken.
>> Men vad blir sträng bokstavligen tillbaka?
Den returnerar bokstavligen adressen till allra första byte i RAM som
Det används för att styrka.
Och det visar sig att bara genom att returnera en enda adress för
första tecknet i strängen, är att tillräcklig för att hitta helheten av
strängen.
>> Med andra ord får strängen inte har att återvända 123 och 124 och 125.
Det behöver inte ge mig en lång förteckning över alla byte som
min sträng använder.
Eftersom en, de är alla rygg mot rygg.
Och två, baserad på den första adressen, jag kan räkna ut var strängen slutar.
Hur?
>> Den speciella null karaktär, Omvänt snedstreck noll i slutet.
Så med andra ord, om du passerar runt -
insidan av variabler -
adressen till en röding, och du tar att i slutet av varje sträng, varje
sekvens av tecken som vi människor tänker på strängar, om man antar att
i slutet av en sådan sträng finns ett omvänt snedstreck nolla, du är gyllene.
Eftersom du kan alltid hitta i slutet av en sträng.
>> Nu vad som egentligen sedan gå på i det här programmet?
Varför är det här programmet, jämför-0.c, buggy?
Vad som faktiskt jämförs?
Yeah?
>> STUDENT: [OHÖRBAR].
>> DAVID MALAN: Exakt.
Det är att jämföra platser av strängarna.
Så om användaren har skrivit in hello gång, som jag gjorde, kanske minne hamna
ser ut så här.
Om användaren sedan slag i Hej igen, men genom att ringa får strängen igen, är c
inte särskilt smart om du undervisar det att vara smart genom att skriva kod.
>> C -
och datorer i allmänhet -
Om du skriver in ordet Hej igen, du vet vad du kommer att få.
Du kommer bara att få en andra uppsättning minne som, ja, råkar vara
lagring av H-E-L-L-O och så vidare.
>> Det kommer att se likadant till oss människor, men denna adress
kanske inte är 123.
Det kanske bara så hända att operativsystem har några tillgängliga
utrymme till exempel på plats -
låt oss säga något godtyckligt, som detta är platsen 200.
Och detta är platsen 201.
Och detta är platsen 202.
Vi har ingen aning om var det är kommer att vara i minnet.
>> Men vad det betyder är att det är kommer att lagras slutligen i s?
Antalet 123.
Vad kommer att lagras i t, i denna godtyckliga exempel?
Numret 200.
Och allt det betyder då är självklart, 123 inte är lika 200.
Och så här om villkoret aldrig utvärderas till true.
Eftersom hämta sträng använder olika bitar av minne varje gång.
>> Nu kan vi se detta igen i ett annat exempel.
Låt mig gå vidare och öppna upp copy-0.c.
Jag hävdar att detta exempel kommer att prova - men misslyckas - att kopiera två strängar
enligt följande.
>> Jag ska säga något till användaren.
Jag sedan kommer att få en string och kallar det är.
Och nu, jag gör denna kontroll här.
Vi nämnde detta för ett tag sedan.
Men när kan få null string avkastning, annan speciell karaktär, eller särskilda
symbol låt oss säga.
Om det är slut på minne.
>> Till exempel, om användaren är verkligen vara svårt och typ en avskyvärd
antal tecken på tangentbord och träffar Enter.
Om detta antal tecken kan bara inte passa i RAM för oavsett galen
skäl, får väl sträng kanske mycket väl returnera null.
>> Eller om ditt program i sig gör mycket andra saker och det finns bara
inte tillräckligt med minne för hämta sträng att lyckas, kan det sluta
up återvänder null.
Men låt oss vara mer exakt vad detta är.
Vad är s datatyp egentligen?
Char stjärna.
>> Så visar det sig nu att vi kan skala backa skiktet av null.
Vänder ut, är null - ja, självklart en speciell symbol.
Men vad är det egentligen?
Egentligen är null bara en symbol som vi människor använder för att representera noll liksom.
>> Så författarna av C, och datorer mer allmänt, bestämde år sedan
det, vet du vad.
Varför inte vi garantera att ingen användare uppgifter är någonsin, någonsin, någonsin
förvaras vid bye noll?
Faktum är att även i min godtyckliga exempel innan, det gjorde jag inte börja numreringen av
byte vid noll.
Jag började på en.
Eftersom jag visste att människorna i världen har beslutat att reservera noll
byte i någons RAM som något speciellt.
>> Orsaken är, när du vill signalera att något har gått fel
beträffande adresser, återvände du null - annars känd som noll -
och eftersom du vet att det inte finns någon legit uppgifter vid adress noll, klart
som innebär ett fel.
Och det är därför vi, enligt konvention, kolla för null och retur något
som en i dessa fall.
>> Så om vi rulla ner nu, det är bara sedan några felkontroll, utifall
något gick fel med [? borgen?]
helt och hållet och avsluta programmet genom att returnera tidigt.
Denna linje nu skulle kunna skrivas om eftersom detta, vilket betyder vad?
På vänster sida, ge mig en annan pekare till en karaktär, och kalla det t.
Vad jag lagra inuti t, baserad På denna kodrad?
>> Jag lagrar en plats.
Specifikt platsen som var i er.
Så om användaren har skrivit in hälsningar och som först inträffar hej hamna
här, då antalet 123 är kommer att komma tillbaka från att få
sträng och lagras -
som vi sa tidigare -
i ar.
>> När jag förklarar nu en annan pekare till en röding och kalla det t, vilken siffra är
bokstavligen kommer att hamna i t enligt berättelsen?
Så 123.
>> Så tekniskt nu både s och t pekar på den exakta
samma bitar av minnet.
Så märker vad jag ska göra nu bevisa att detta program är buggigt.
>> Först kommer jag att hävda, med en utskrift f, kapitalisera
kopian av strängen.
Sedan kommer jag att göra lite felkontroll.
Jag ska se till.
Låt oss se till att strängen t är på åtminstone större än noll i längden,
så det finns vissa tecken finns att faktiskt utnyttja.
>> Och då kanske du minns detta från tidigare exempel.
2 övre - vilket är i den ctype.h filen.
T fäste noll ger mig noll tecknet i strängen t.
Och 2 övre av samma värde, för Naturligtvis, omvandlar den till versaler.
>> Så intuitivt, här raden är markerad av koden kapitalisera den första
brev t.
Men det är inte kapitalisera, intuitivt, den första bokstaven i er.
Men om du tänker framåt, vad är jag om att se när jag kör det här programmet
och skriva ut både den ursprungliga, s, och den så kallade kopiera, t?
>> De är faktiskt kommer att vara densamma.
Och varför ska de vara samma?
De är båda pekar på exakt samma sak.
Så låt oss göra det här.
>> Gör kopia noll.
Den sammanställer OK.
Låt mig köra kopia noll.
Låt mig skriva något liknande hello i gemener slog sedan Enter.
Och det hävdar att både den ursprungliga s och kopian verkligen är identiska.
>> Så vad hände egentligen här?
Låt mig rita den här bilden bara att berätta historien på ett
något annorlunda sätt.
Vad som verkligen händer under huva när jag förklarar något liknande
röding start s, eller string s, Jag får en pekare -
som råkar vara fyra bytes i CS50 apparaten
och i många datorer.
Och jag kommer att kalla denna s..
Och detta har för närvarande något okänt värde.
>> När du deklarerar en variabel, såvida du själv sätta ett värde där, som
vet vad som finns där.
Det kan vara någon slumpmässig sekvens av bitar från tidigare utförande.
Så när jag, i min kodrad gör få sträng, och sedan lagra avkastning
värde i oss få strängen på något sätt -
och vi kommer så småningom skal tillbaka hur får string verk, på något sätt allokerar en
array som förmodligen ser lite såhär.
H-E-L-L-O, omvänt snedstreck noll.
>> Låt oss anta att detta är adressen 123 bara första konsistens.
Så får sträng avkastning, i markerad linje där, returnerar den
Antalet vi sa, 123.
Så vad går egentligen inuti är här?
>> Tja, vad som verkligen händer insidan av s är 123.
Men ärligt talat, jag får lite förvirrad av alla dessa adresser,
alla dessa godtyckliga nummer.
123, 124, 127.
Så låt oss faktiskt förenkla världen lite.
>> När vi talar om pekare, ärligt talat, att oss människor, vem fan bryr sig om
saker är i minnet?
Det är helt godtyckligt.
Det kommer att bero på hur mycket RAM-minne som användaren har.
Det kommer att bero på när på dagen du kör programmet, kanske, och
vilken ingång användaren ger.
Vi bor på oviktiga detaljer.
>> Så låt oss abstract bort och säga att, när du kör en kodrad som denna,
röding stjärnan s får returen värde hämta sträng.
Varför inte vi istället bara rita vad vi hålla ringer en fingervisning om det är
pekar på något?
Så jag hävdar nu att s upp det finns en pekare -
under huven är det en adress.
Men det är bara att peka på den första bitgruppen i
sträng som har återlämnats.
>> Om jag återvänder nu till den koden här, vad som händer på den här linjen?
Nåväl, i denna markerad linje nu, Jag förklarar tydligen en annan
variabel som heter t.
Men det är också en pekare, så jag kommer att rita den som, i teorin, det exakta
samma storlek låda.
Och jag kommer att kalla det t.
>> Och nu när vi går tillbaka till koden igen, när jag lagrar s insidan av t,
vad är jag tekniskt sätta inne i t?
Nåväl tekniskt, detta var antalet 123.
Så egentligen jag borde skriva numret 123 där.
Men låt oss ta det högre nivå.
t, om det bara är en pekare, intuitivt, är just det.
Det är allt det är att vara lagras i det.
>> Så nu under de senaste intressanta linjer av kod, när jag går faktiskt om
kapitalisera nolltecknet it, vad händer?
Tja, är t fäste noll pekar nu vad karaktär, förmodligen?
>> Det pekar på h..
Eftersom t bracket noll -
minns, är denna gamla syntax. t bracket noll betyder bara om t är en sträng, t
fäste noll innebär att få noll karaktär i den styrkan.
Så vad som verkligen betyder är att gå till denna array -
och ja, det kan vara 123, detta kan vara 124.
Men det är alla relativa, minns.
När man talar om en array, har vi fördelen av att tala om
relativa index.
>> Och så nu kan vi bara anta som t fäste noll timmar.
Så om jag kallar två övre på det, vad det är egentligen gör är att kapitalisera
den gemena h till versaler H. Men naturligtvis, vad är er?
Det är som pekar på samma darn strängen.
>> Så detta är allt som har hänt i denna kod hittills.
Så vad är då innebörden?
Hur fixar vi dessa två problem?
Hur jämför vi till faktiska strängar?
>> Nå intuitivt, hur skulle du går om att jämföra två
strängar för verklig jämställdhet?
>> Vad betyder det om två strängarna är lika?
Uppenbarligen inte att deras adresser är lika i minnet, eftersom det är en låg
nivå genomförande detalj.
Alla tecken är densamma.
Så låt mig föreslå, och låt mig presentera i version ett av compare.c
här, så jämför-1.c.
>> Låt mig föreslå att vi ändå får en pekare kallas s, och förvara i det
returvärdet hämta sträng.
Låt oss göra samma sak med t.
Så ingen av koden är annorlunda.
Jag kommer att lägga till lite mer felkontroll nu.
Så nu när vi är typ av peeling tillbaka detta skikt i CS50 av vad en sträng
egentligen är, måste vi vara mer anal om att se till att vi inte missbrukar
ogiltiga värden som null.
>> Så jag ska bara kolla.
Om s inte är lika noll och t inte lika null, innebär att vi är OK.
Få strängen inte skruva upp att få någon av dessa strängar.
Och du kanske kan gissa nu, vad gör STR CMP förmodligen?
String jämföra.
>> Så om du har program i java innan, detta är som lika metoden i
string klassen.
Men för er som inte har programmeras innan,
detta är bara en c-funktion.
Det händer att komma i en fil som heter string.h.
Det är där det deklareras.
>> Och string jämför -
Jag faktiskt glömmer dess användning, men strunt i det.
Minns att vi kan göra människa, rör jämföra.
Och detta kommer att ta upp Linux programmerare manual.
Och det är, ärligt talat, lite kryptiskt.
Men jag kan se här att, yep.
Jag måste inkludera string.h.
>> Och det står här under beskrivningen "den string compare funktionen jämför
de två strängarna S1 och S2. "Och S1 och S2 är tydligen de två
argument som skickas på i.
Jag minns inte riktigt vad konst är, men nu märker -
och du kanske har sett detta redan när har du använd man-sidor om du
har allt -
att röding stjärna är bara synonymt med snöre.
>> Så det jämför de två strängar, S1 och S2, och den returnerar ett heltal mindre
än eller lika med eller större än noll om S1 hittas, respektive, för att vara
mindre än, eller matcha, eller vara större än S2.
Det är bara ett mycket komplext sätt att säga att strängen jämför avkastning
noll om två strängar är intuitivt identiska, tecknet för
tecken för tecken.
>> Den returnerar ett negativt tal om s, alfabetiskt, är tänkt
att komma före t.
Eller returnerar ett positivt tal om s är tänkt att komma efter t
alfabetiskt.
Så med denna enkla funktion, kan du till exempel sortera en
massa ord?
>> Så i denna nya version, kommer jag att gå vidare och göra compare1.
Dot snedstreck jämför en.
Jag ska skriva in hello i alla gemener.
Jag kommer att skriva in hello i gemener igen.
Och tack och lov nu inser Jag har skrivit samma sak.
>> Under tiden, om jag skriver in hello i lägre fallet och HEJ i versaler och
jämföra dem, skrev jag olika saker.
Eftersom inte bara är de adresser annorlunda, men vi jämför
olika karaktärer och om igen.
>> Nåväl låt oss gå och fixa en andra problem nu.
Låt mig öppna upp version en av kopia, som nu behandlar
denna fråga enligt följande.
Och detta kommer att se ut lite mer komplex.
Men om du tänker på vad problemet vi måste lösa, förhoppningsvis kommer detta att vara
klart på bara ett ögonblick nu.
>> Så denna första raden, röding start t, i lekmannaspråk kan någon föreslå
vad denna linje här betyder?
Char stjärnan t, vad är det som gör?
>> Bra.
Skapa en pekare till några plats i minnet.
Och låt mig förfina det lite.
Deklarera en variabel som kommer att lagra den adress för vissa röding i minnet, bara
att vara lite mer korrekt.
>> OK, så nu på höger sida, har jag aldrig sett någon av dessa funktioner
tidigare, malloc.
Men vad kan det betyda?
Tilldelning av minne.
Memory allocation.
>> Så visar det sig, fram tills nu, vi har inte riktigt haft ett kraftfullt sätt
frågar operativsystemet, ge mig lite minne.
Snarare har vi nu en funktion som kallas malloc som gör exakt det.
Även om detta är lite av en distraktion just nu, märker att i
mellan de två parentes är bara kommer att vara ett nummer.
Där jag har skrivit i fråga märken kan vara ett tal.
>> Och den siffran betyder, ge mig 10 bytes.
Ge mig 20 bytes.
Ge mig 100 byte.
Och malloc kommer att göra sitt bästa för att be operativsystemet -
Linux, i detta fall -
hej, är deras 100 bytes RAM-minne?
Om så, tillbaka dessa bytes till mig av återvänder vars adress av
dessa bytes, kanske?
Den allra första.
>> Så här också - och detta är dominerande i C, helst du är
hantera adresser?
Du är nästan alltid att göra med första sådan adress, oavsett hur stor
en bit av minnet du vara lämnas tillbaka, så att säga.
>> Så låt oss dyka in här.
Jag försöker att fördela hur många bytes, exakt?
Well.
Sträng längd s - låt oss göra ett konkret exempel.
Om s är hej, H-E-L-L-O, vad är det sträng längd s, självklart?
Så det är fem.
Men jag gör ett plus 1 på det, varför?
Varför vill jag sex bytes istället för fem?
Den null karaktär.
>> Jag vill inte lämna ut detta speciella null karaktär.
För om jag gör en kopia av Hej och bara göra H-E-L-L-O, men jag inte sätta
den speciella karaktär, datorn kanske inte har, av en slump, ett omvänt snedstreck
noll där för mig.
Och så om jag försöker räkna ut längd kopian, skulle jag tro att
det är 20 tecken långt, eller en miljon tecken om jag bara aldrig hända
att träffa en backslash noll.
>> Så vi behöver sex byte för att lagra H-E-L-L-O, omvänt snedstreck noll.
Och då är detta bara vara super anal.
Antag att jag glömmer vad storleken på en röding är.
Vi fortsätter att säga att det är en byte.
Och det är oftast.
I teorin kan det vara något annorlunda, på en annan Mac eller en
annan dator.
>> Så visar det sig att det är det här operatör kallas sizeof att om du klarar det
namnet på en datatyp - som röding, eller int eller float -
Det kommer att säga, dynamiskt, hur många bytes en röding tar upp detta
viss dator.
>> Så detta är ett effektivt sätt bara som att säga gånger 1 eller
gånger ingenting alls.
Men jag gör det bara för att vara super anal, att ifall en röding skiljer
på din dator kontra mine, på detta sätt matten kommer alltid att kolla in.
>> Slutligen, här nere jag kontrollera null, vilket alltid är bra metoder - igen,
helst vi har att göra med pekare.
Om malloc inte kunde ge me sex avsked - vilket är
osannolikt, men bara i fallet -
återvända en omedelbart.
Och nu, gå vidare och kopiera strängen enligt följande.
Och detta är välbekant syntax, om än i en annan roll.
>> Jag ska gå vidare och få strängen längd av s och lagra den i n.
Jag sedan kommer att iterera från i lika noll till och med n,
större än eller lika med.
Så att det på varje iteration, ställde jag te karaktär är i: te
karaktär t.
>> Så vad som verkligen händer under huven här?
Även om detta, till exempel, är s -
och jag har skrivit in ordet H-E-L-L-O och det finns ett omvänt snedstreck noll.
Och återigen, detta s pekar här.
Och här nu är t.
>> Och detta pekar nu en kopia av minne, eller hur?
Malloc har gett mig en hel bit av minnet.
Jag vet inte från början vad som är i någon av dessa platser.
Så jag kommer att tänka på dessa som en hel massa frågetecken.
>> Men så fort jag börjar kretsa från noll vidare upp genom längden på s, t
fäste noll och t bracket 1 -
och jag ska sätta detta nu på overhead -
t fäste noll och s fäste noll betyder att jag kommer att kopiera
iterativt h in här, E-L-L-O. Plus, eftersom jag gjorde det plus
1, omvänt snedstreck noll.
>> Så nu i fallet med jämför-1 c, i slutändan, om jag skriver ut
aktivering av T, ska vi se till att s är oförändrat.
Låt mig gå vidare nu och göra detta.
Så gör copy1.
Dot snedstreck copy1.
Jag kommer att skriva in hello, Enter.
Och nu märker, bara kopian har aktiverats.
Eftersom jag har verkligen två bitar av minnet.
>> Tyvärr, kan du göra några ganska dåliga och ganska farliga saker här.
Låt mig dra upp ett exempel här nu, som ger oss ett exempel på ett fåtal
olika linjer.
Så bara intuitivt här, den första raden av koden, är int stjärnan x, förklara
en variabel som heter x.
Och vad är datatypen av denna variabel?
Vad är datatypen för den variabeln?
Det var inte cliffhanger.
>> Datatypen är int stjärna.
Så vad betyder det? x kommer lagra adressen till en int.
Så enkelt är det.
Y kommer att lagra adressen till en int.
Vad är den tredje raden av koden gör det?
Det fördela hur många byte, mest troligt?
Fyra.
På grund av storleken på en int är generellt fyra, ger malloc av fyra
mig tillbaka adressen till en bit av minne, är den första i vars byte
lagras nu i x.
>> Nu ska vi flytta lite snabbt.
Star x betyder vad?
Det innebär att gå till denna adress och sätta vad numret dit?
Sätt nummer 42 där.
Star y betyder att gå till vad som finns på y och uppskattar antalet 13 där.
>> Men vänta en minut.
Vad är y just nu?
Vilken adress är y lagring?
Vi vet inte, eller hur?
Vi har aldrig en gång använd uppdraget operatör involverar y.
Så y deklarerade på den andra raden i koden är bara några sopor värde, en stor
frågetecken så att säga.
Det skulle kunna peka slumpvis till något i minnet, vilket
är generellt dåliga.
>> Så snart som vi slår den linjen där, stjärniga y är lika med 13, något dåligt,
något mycket hemskt är på väg att hända med Binky.
Så låt oss se vad som kommer att hamna händer Binky här i denna minut
eller så leta.
>> [VIDEO SPELA]
>> -Hej, Binky.
Vakna.
Det är dags för pekaren kul.
>> -Vad är det?
Läs om pekare?
Åh, goodie.
>> -Jo, för att komma igång, jag antar att vi är kommer att behöva ett par pekare.
>> -OK.
Denna kod tilldelar två pekare vilket kan peka till heltal.
>> -OK, bra, ser jag de två pekare.
Men de verkar inte vara pekar på någonting.
>> -Det stämmer.
Inledningsvis pekare inte peka på någonting.
De saker de pekar på kallas pointees, och bygga upp dem är en
separat steg.
>> -Åh, höger, höger.
Jag visste det.
De pointees är separata.
Så hur tilldela dig en pointee?
>> -OK.
Nåväl, tilldelar denna kod nytt heltal pointee, och denna del beskrivs x
att peka på den.
>> -Hej, ser det bättre.
Så gör det gör något.
>> -OK.
Jag ska avreferera pekaren x för att lagra numret 42 i sin pointee.
För detta trick, jag behöver min magi wand av dereferencing.
>> -Din trollstav av dereferencing?
Eh, det är bra.
>> -Det här är vad koden ser ut.
Jag ska bara ställa in antalet, och -
>> -Hej, titta.
Där det går.
Så gör en dereference på x följer pilen för att komma åt dess pointee.
I detta fall, för att lagra 42 i där.
Hej, prova att använda den för att lagra numret 13 genom den andra pekaren, y.
>> -OK.
Jag ska bara gå hit till y och få nummer 13 inrättas.
Och sedan ta trollspö dereferencing och just -
whoa!
>> -Åh, hej.
Det fungerade inte.
Säg, Binky, jag tror inte det dereferencing y är en bra idé,
eftersom att inrätta pointee är ett separat steg.
Och jag tror inte att vi någonsin gjorde det.
>> -Hmm.
Bra poäng.
>> -Yeah, fördelade vi pekaren y.
Men vi satt aldrig till peka på en pointee.
>> -Hmm.
Mycket observant.
>> -Hej, du letar bra där, Binky.
Kan du fixa det så att y poäng till samma pointee som x?
>> -Visst.
Jag ska använda min magiska trollspö pekare uppdrag.
>> -Kommer det att bli en problem som förut?
>> -Nej.
Detta berör inte pointees.
Det förändrar bara en pekare att peka till samma sak som en annan.
>> -Åh, ser jag.
Nu y pekar på samma plats som x.
Så vänta.
Nu y är fast.
Den har en pointee.
Så du kan prova staven av dereferencing igen
att skicka 13 över.
>> -OK.
Här går.
>> -Hej, titta på det.
Nu dereferencing fungerar på y.
Och eftersom pekarna delar att en pointee, de
både se 13.
>> -Ja.
Delning.
Oavsett.
Så ska vi byta platser nu?
>> -Åh, titta.
Vi är ute i tid.
>> -Men -
>> -Kom bara ihåg de tre pointer regler.
Nummer ett, den grundläggande strukturen är att du har en pekare.
Och det pekar över till en pointee.
Men pekaren och pointee är separata.
Och det vanligt fel är att inrätta en pekare, men för att
glömmer att ges en pointee.
>> Nummer två, börjar pekaren dereferencing vid pekaren och följer dess
pil ned för att komma sin pointee.
Som vi alla vet, detta fungerar endast om det är en pointee, som kommer tillbaka till
regel nummer ett.
>> Nummer tre, tar pekaren uppdrag en pekare och förändringar det att peka på
samma pointee som en annan pekare.
Så efter överlåtelsen, de två pekare kommer
peka på samma pointee.
Ibland kallas delning.
Och det är allt som finns till den, egentligen.
Bye bye nu.
>> [END VIDEOAVSPELNING]
>> DAVID MALAN: Så mer om pekare, mer om Binky nästa vecka.
Vi ses på måndag.