>> [Zenelejátszó]
>> DAVIN: Rendben, srácok.
Tehát ez a felülvizsgálat az első teszt.
Mindenki készen áll A teszt szerdán?
ALLISON: Woo!
Diák: Woo!
DAVIN: Igen.
ALLISON: Igen!
DAVIN: Ez a fickó kész.
Az a srác, két kézzel, szép.
Így kvíz felülvizsgálat ma, ez lesz hogy körülbelül egy óra és fél.
Megyünk, hogy menjen át az összes jelentős fogalom, amit érdemes tudni a kvíz.
Fogunk menjen át bizonyos kódolást kéz példák, amelyek minden teszt.
Ha kérdésed van, nyugodtan hogy emelje fel a kezét, és minden
mint azt.
Nos, körülbelül logisztika A kvíz online.
Így fogunk megosztani az embereket fel különböző helyiségek.
Ez alapján a nevüket.
Tehát, ha bármilyen kérdése van arról, hogy hol hogy menjen, vagy arról, hogy mi az anyag, mint a,
A hivatalos szó, hogy mi folyik hogy a kvíz, ellenőrizze online.
És ez minden naprakész.
Tehát, ha nincsenek kérdések Kezdjük azzal, hogy fogunk kezdeni.
És itt Allison.
>> [Tapsol]
>> ALLISON: OK, köszönöm, Rob.
Értékelem.
Davin kellett volna lapozott ezt.
Ez a nem kimerítő listája témák, mint mindig, ahogy Davin mondott.
Tekintse meg a dokumentáció Online kvíz körülbelül nulla.
De ez elég much-- ez a tananyag
mindent, amit ment át eddig.
Itt minden tisztességes játék, valamint minden más
amely már említett előadás.
>> My rész, itt, csak egy csomó felülvizsgálat.
Van egy pár gyakorlatok hogy ti is dolgozni.
De a legtöbb, valóban akar eljutni Davin e kód
kézzel gyakorlatok.
>> Így fogok repülni ezzel.
Ha bármilyen kérdése van, megállítani.
Emelje fel a kezét.
Ígérem, talán találkozunk.
Ha nem, csak hullám körül.
Fogok beszélni gyorsan.
Remélem, mindenki rendben van, hogy.
>> OK, különleges szó, nyilvánvalóan Davin Elfelejtettem a flip keresztül ezeket a diákat.
[Nevet] Te bajban, ember.
Így tippek kvíz nulla, gyakorlat kódolási papíron.
Srácok lesz, hogy bizonyos gyakorolni, hogy most Davin,
így nem lesz teljesen egyedül.
Azt hiszem, valóban megy át a két funkciót.
Így lesz jól felkészült ott.
>> Legyen tisztában az Önre probléma készletek.
Voltak kérdések korábbi vetélkedők
hogy meg fogja kérdezni, például, a kódot valamit nagyon hasonlít a Mario.
Tehát, hogy nagyon jól ismeri a a problémát állítja, valamint
mivel a kérdések azt kérjük, az elején az űrlap
hogy töltse ki, majd szolgálni nagyon jól.
>> Van egy korábbi teszt alatt az idő rövidsége.
Ezek a vetélkedők hosszú.
Az idő megy nagyon gyorsan.
És gyakran, akkor nem veszik észre, milyen gyorsan megy, amíg ténylegesen
tedd magad alá ezek a korlátok.
Tehát, ha csak faragni, tudod, 75 perc, vagy ma este vagy holnap
hogy egy ilyen vetélkedők alatt hogy akkor sokkal jobb állapotban.
>> És azt is, ami a referencia lemez.
Ne feledje, hogy kap egy oldal elöl és hátul
referenciaként a kvíz szerdán.
Létrehozása, amely egy nagyszerű módja annak, hogy tanulni.
Bármi, gondjai akadtak A felvenni kívánt ott.
Bármi, ami a TF volt, tetszik, ez nagyon fontos.
Tudnia kell ezt a talán dolgokat, akkor ott
ha nem kell őket megjegyzett.
Akkor is, ha tudom őket igazán nos, néha azonban az ott
csak egyfajta kényelem az Ön számára, ami tudom, vetélkedők stresszt.
Szóval minden kényelem kapsz segíthet.
Rendben, is, kap alvás és enni, és szeretem a normális dolog
hogy azt mondjuk nektek, a vetélkedők.
>> Így kezdés egyszerű, adattípusok és méretben.
Mint mondtam, ez csak megy kell nekem dobott egy csomó dolog
itt, amit tudnia kell.
Tehát a karakter amelyek egy bájt, ints
hogy négy bájt hosszú hosszú, amelyek nyolc byte.
Alapvetően, csak te kíván tartani a nagyobb egészek.
Úszók, amelyek négy, páros, amelyek a nyolc.
Ismét, csak ad még helyet a úszók.
Majd írja csillag, így minden mutató 32 bites gép,
amely minden, amire szüksége van srácok tudni, négy bájt.
>> Tehát az összes dolgot, amit kellene tudom, talán a dolgok
azt szeretné, hogy a A referencia lap.
OK, bináris átalakítás bináris, átalakítás
a hexadecimális, oda-vissza, mindent, amit tudnia kell.
Tehát bináris decimális.
Akartok egy gyors perc és megpróbálja kitalálni, mindegyik
majd mondd el, mit ők?
>> Nekem is van cukorka a táskámban, így bárki aki válaszol kap édességet, mellesleg.
És van rengeteg.
Hadd fogd ezt.
Fogom adni ezt a Gabe.
Így viszont ki édességet aki kedves és együttműködő.
>> OK, láttam egy kéz ott hátul.
>> Diák: Igen, az első 42.
>> ALLISON: Igen, először az egyik 42, a helyes.
Diák: [hallható].
[Nevetés]
ALLISON: Second egy, ott vissza sárga?
STUDENT: 110.010.
ALLISON: helyes, és ez utolsó, itt lent az alján?
Továbbá, igen, tudod akar?
Csak dobd ki cukorkát.
Mit szólnál édességet mindenki számára?
>> Diák: [hallható], amikor kész.
>> ALLISON: Pszt.
És akkor az utolsó.
Ki akar válaszolni?
Ott van.
>> STUDENT: 11100-.
>> ALLISON: 11.100, nézd meg ezt.
Gratulálok, remek munka, mindenki.
OK, mindenki egyfajta érthető az eljárás ezt?
Ön, megy a bináris decimális ahogy én inkább csinálni, ír ki
hatáskörét 2.
Szóval azt mondom, OK, 0 alkalommal 2-0, így ez 0, 1 alkalommal 2 az első,
2-től megy így.
Akar valaki engem kifejezetten megy keresztül egy példa a bináris?
OK, hűvös.
>> Tizedes bináris nagyon hasonló.
Én inkább, hogy írjon ki a 2 hatványai.
Kezdje az egyik, hogy a legnagyobb, de nem megy a tizedes
amit keres.
És akkor milyen a munka az utat hátra összeadjuk a dolgokat, ha szükséges.
>> És akkor kívül, ez mint a normál mellett.
Ha valaha is az esetben, ha Ön hozzátéve, két 1s, nyilvánvalóan lesz 2.
2. bináris jelenleg 1 0, így meg kell folytatni a 1 a következő oszlopra.
Cool.
>> Hexadecimális, ez lehet, hogy valami hogy valamivel kevésbé ismert.
Szóval mint Rob épp azt mondta nekem előzetesen, a trükk erre
az, hogy csak feldarabolja négy byte darabokat, OK?
Bits, sajnálom.
Látod?
Köszönöm Rob.
Ez az oka annak, hogy itt vagy. [NOISE] OK, így csak törni fel
négy bit darabokban.
Tehát bináris hexadecimális, nézzük az első 4,
ami ha van négy 1-esek a sor, mit jelent, hogy szimbolizálja szám?
>> STUDENT: F.
>> ALLISON: Tehát ebben az esetben, mi 11111111 or-- igen?
STUDENT: FF.
ALLISON: Tökéletes, FF.
Olyan nagy, édességet az Ön számára.
Most, hogyan hexadecimális bináris, mi Csak gondolj bele milyen fordított.
Minden szám vagy betű mi van a mi hexadecimális,
csak átalakítani, hogy a négy bit [Nevet], hogy a négy bit konverzió.
Így 5, ebben az esetben, ha mi 5 mi képviselő a négy bit?
>> Diák: 010?
Mm-hm.
És akkor A, amely tulajdonképpen a 10, lenne?
1010.
Tehát, hogy itt.
Így átváltására hexadecimális és bináris valójában nem is olyan rossz.
Ha megnézi azt a négy bit darabokat, lesz arany.
Everyone-- igen?
>> ROB: Ez butaság, de én mindig emlékezni
A, mert A feltételezett, hogy 10.
És csak bináris 10 10, so--
>> ALLISON: Ah, ott megyünk.
>> ROB: Hey.
>> ALLISON: Hé, cukorka Rob.
Van nem csokoládé cucc ott.
Így van néhány.
Így ASCII matek.
Viselkedj.
Szóval ASCII matek, ahogy ti Valószínűleg jól emlékszem
p beállított 2 Visioneer és Caesar, te sok ez.
Ne feledje, hogy a karakterek alapvetően csak számok.
Így nem tehetünk matek velük, mint mi a matek ints.
>> Tehát csak egy kicsit egyszerű dolog itt.
Van néhány, ami az A inicializálja 65.
És B egyenlő ASCII értéke A plusz 1, char C egyenlő D mínusz 1,
és faszén D egyenlő 68.
Akkor fogunk print mindegyiket, mint látjuk itt.
És valaki meg tudja mondani nekem mi ez nyomtassa ki?
Diák: [hallható].
ALLISON: Pontosan, így egy dolog, hogy észre is
hogy nyomtat ki karakterek minden alkalommal itt.
Mi kijelölő noha az A és a B a ints amikor kijelentette fölé.
Mi nyomtatni őket karakter A százalékos C és a printf nyilatkozat,
így azok minden nyomtatni, mint karaktert.
És persze, az ASCII érték 65 akaratát kinyomtatni A. ASCII értéke A plusz 1
lenne 66 között, ami büszke arra, hogy B. Tehát valójában, mi
kap A B C D Mindenki jól van?
Van még kérdése?
Félelmetes.
>> OK, hatály.
Tehát hatály nyilvánvalóan nagyon Fontos dolog, hogy megértsük, itt.
Sok van, ha Van összeállítása hibák,
és azt mondja, nem kell hozzáférést néhány változó,
ez valószínűleg azért, mert határozta meg egy hurok
majd megpróbált hozzáférni belőle, vagy fordítva.
>> Így körbe a fő, ez csak határozza meg,
mondjuk a változó létezik, ahol lehet változtatni, ahol tudunk hozzáférni.
Ez csak egyfajta tartja azokat Az egyetlen hely, ahol lehetőséged van
hogy ezt a változót.
>> Így a két körök, hogy beszélünk órákon globális és lokális.
Így a globális változók beszélünk ha meghatározzák azokat a fő felett.
Ez azt jelenti, hogy a teljes program hozzáférést,
és létezik, ameddig a program fut, OK?
Helyi azt jelenti, hogy inkább korlátozódik a régióban.
Tehát, ha van speciális funkciók mint csere, mindig beszélünk.
Mindig beszélünk csere A és B. A és B léteznek ezt a funkciót.
Nem létezik sehol máshol.
>> Valamint, ha van, ha nyilatkozatok vagy hurkok.
Amikor mi, például a a for ciklus van int I értéke 0.
Van néhány feltétel, és frissíti azt.
Én csak azért létezik, a nadrágtartó az, hogy hurok.
Ha megpróbálja elérni máshol, a fordító azt kiabálni veled.
Olyan, mintha, mit akar csinálni?
Ez nem létezik.
Szóval ez a két különböző hatály.
Van ennek értelme mindenki?
>> Így például itt, ez csak néhány egyszerű program.
Mit gondolsz, srácok fog történni minden ponton
hogy próbáljon nyomtatni?
Tehát ez itt, mi fog történni?
DIÁK: Ez nyomtatni három.
ALLISON: Így van.
Nem lesz nyomtatni három.
Mi van itt?
DIÁK: Ez nem fog működni.
ALLISON: Ez nem fog működni.
Te ki a hatálya alól, igaz?
A helyi változó nem létezik kívül ezek nadrágtartó, rendben?
És akkor mi van itt?
>> Diák: [hallható].
>> ALLISON: Mi?
Rob, menj.
>> ROB: Én csak azt mondta.
A globális változók legyen globális aláhúzás változó.
>> ALLISON: Ah, igen, sajnálom.
Köszönöm, Rob.
Rob, mint a rezidens fordító.
Majd csak kiabálni nekünk, amikor szüksége van rá. [Nevet] Igen,
legyen globális aláhúzás változó.
Tehát feltételezve, hogy ez a volt globális aláhúzás
változó, mi fog történni itt?
Diák: Erről fog működni.
ALLISON: Ez lesz a munka.
Így fog nyomtatni, így csak egy nagyon egyszerű példát.
OK, prototípusok.
Tehát nyilvánvaló, hogy valóban hangsúlyozzák a srácok
hogy működik, ha az értelme a programokban.
De persze, ha hogy a saját funkcióját,
általában akkor határozza meg, ezek után a fő.
És megpróbálom felhívni őket fő.
És ha nem használ a prototípus, A fordító kiabálni veled.
>> Prototype alapvetően csak mondja a fordító
hogy én ezt a funkciót az alábbi fő.
Fogom hívni mielőtt meghatározni.
Csak tarts ki.
Megígérem, hogy ez határozza meg, és majd mindent, amire szüksége van.
>> Tehát az, ahogy mi is csak a visszatérés típusát, a függvény nevét, a bemenet
lista.
Ez alapvetően az első sorban a függvény nyilatkozat.
Ez tényleg minden van.
De ez csak egy általános fajta formátumot.
>> Így a példánkban itt, amely srácok kellene
láttam szakaszban egy bizonyos ponton, mi
néhány kocka int, hogy némi int bemenet.
És mi van a fő funkció, amely felszólítja kocka.
És kocka meghatározása után a tényt.
>> Tehát, ha nem is int kocka bemenet tetején, amikor az úgynevezett kocka
belül a fő, a fordítóprogram akkor dühös ránk.
Olyan, mintha mi beszél?
Kocka nem létezik.
Nem tudom, mit kér.
És én csak úgy megáll.
>> De mivel mi a prototípus A felső, azt mondtam,
tudod, ha látod kocka, ne aggódj.
Ígérem, ez határozza meg később.
És ez lesz hadd tegye, amit akar.
Tehát, ha valaha is egy függvény hogy a bejelentett után hívják
az első alkalommal, meg kell hogy azt prototípusa a tetején.
>> Igen?
>> ROB: Ez a négyzeten, nem kocka.
>> ALLISON: Istenem.
Nem have-- Gabe, azt hittem, voltál a lektor.
OK srácok, medve velem, itt.
Remélem, mindenki kezd az ötlet.
OK, ez van lett faragva, nem CubeD.
De az ötlet ugyanaz marad.
Minden olyan funkció, hogy mi hívás után az a tény, kell egy prototípus.
Mindenki jó ez?
Minden más elírás?
OK.
Minden elírás itt mielőtt elkezdjük, Rob?
[Nevet] OK, így struktúrákat.
Alapvetően, struktúrákat lehetővé teszi hogy saját adattípus.
Annyi, mint egy int vagy char vagy úszó, ez csak egy másik típusú.
Szeretek úgy gondolni rá, mint, például, létre saját adattípus.
Így lehetővé teszi, hogy ezt tegyük.
És ez tart a különböző típusú adatok.
>> Tehát, ha eszébe jut, hogy egy tömb, mi csak tartani a dolgokat a hasonló típusú.
Struktúrák lehetővé teszi számunkra, hogy tartsa több dolgok különböző.
Tehát ebben az esetben itt, mi Van egy struct Student nevű,
megnevezett itt alul.
És van néhány int id és néhány karakterlánc nevét.
Szóval ez is csak egy adat típusát.
Most már van egy adat típusú úgynevezett Student.
>> Így, mivel tudunk gondolni ez csak egy újabb adattípus,
kijelenthetjük változókat ahogy bármely más.
Tehát ahelyett, hogy csak úgy, mint egy int diák, csak van egy diák,
diák 1.
Ó, nézd.
Ez Rob.
Tehát itt vagyunk nyilvánításáról a struct, vagy a változó
az úgynevezett diák 1. típusú diák.
Szóval ez megy, hogy id és neve társul hozzá.
>> És ahogy mi hozzá ezekhez elemei a struktúra
van az a pont operátor, itt.
Így ebben az esetben, mi kijelentette, néhány diák 1.
Mi rendelt az azonosító értékét 1.
És mi rendelt a nevét, hogy Rob.
OK, mindenki jó ez?
Használja csak like-- igen?
>> Diák: Igen, amikor typedef-- van szükségünk kezelhető typedef?
>> ALLISON: Szóval csak typedef mondja hogy-- Rob, te
korrigálni tudja nekem ezt, ha én vagyok wrong-- de valójában csak typedef nyilvánításáról
azt a típust, hogy tudod használni, ugye?
>> ROB: Igen, alapvetően, így ez csak létre
egy alias, vagy becenevet típus.
Így írja, hogy a [hallható].
Tehát [hallható] létezik, és most már csak meg
[Hallható] eszközök pontosan ugyanaz a dolog.
És így van, mi gépelt, azt hiszem, néhány struct típus 2 [hallható].
Szóval ez csak egy becenév egy adott típusát.
>> Diák: String [hallható] könyvtár beírt fel, mint char csillag.
>> ALLISON: A mi szempontunkból itt, ha nyilvánító struct,
csak nem typedef struct.
OK, így előzetesen, ez csak egy normális változó itt.
Mi hozzáférhet egy ponttal.
ha van egy mutatót a struct, tudjuk valójában
használjon egy nyíl, ami elég jó.
>> Tehát ebben az esetben van egy mutatót egy diák, amely 1-típusú diák.
Ne feledje, hogy az Ön mutató építés,
azt szeretné, amit írja a mutatót mutat, hogy az elején.
Tehát van néhány diák 1, itt.
És mivel ez a diák 1. most egy hegyes,
akkor valóban megy hallgató 1 arrow név pont helyett, mert ez egy mutató,
és rendeljen Rob.
És most, ha azt akarjuk, hogy Rob változik a Davin,
ez csak megmutatja másképp kell csinálni.
>> Így ahelyett, hogy a nyíl, akkor lehet also-- fogom befejezni ezt majd
hogy ezt meg tudná question-- is csinál referencia diák 1.
Ezt mondja szeret menni bármi van diák 1, amely
lenne a hallgatói struktúra.
Kapcsolódás az egy pont és az elem amit akar, és akkor újra ki kell jelölni.
Volt egy kérdés.
Diák: Igen, tehát hogy hogy van használni [nem hallható], ha éppen
Ennek hallgató csillag nélkül [Hallható] diák?
ALLISON: Mivel ez a teremt a mutató.
ROB: fogunk beszélni róla.
ALLISON: fogunk beszélni erről később a felülvizsgálat.
Szóval, csak kapaszkodni a gondolatot.
Ha még mindig zavar a Végül jön beszéljen egy közülünk.
>> Tehát ezek nem pontosan ugyanaz a dolog.
Mi csak mutatja meg két különböző módon kell csinálni.
Diák 1 most egy mutató, így el tudja érni a Név elem
a struct egy nyíllal.
Vagy akkor a mutató hivatkozás feloldási, és akkor hozzáférhet a szokásos módon.
Van ennek értelme mindenki?
Ha az egész mutató dolgok egy kicsit zavaros, Gabe fog beszélni, hogy
és akkor talán ez sokkal jobban fogja érteni.
Igen?
>> Diák: Igen, így hogyan ez eltér a?
ALLISON: az előzőt?
Így a diák 1 e esetben nem a mutató.
Ez csak a tényleges struktúra.
>> STUDENT: OK.
>> ALLISON: mivel ez egy egy mutató a struct.
>> Diák: OK, de nem ez a fajta végén ugyanazokon a [hallható].
>> ALLISON: Hatékonyan működik ugyanaz.
A szintaxis csak más.
STUDENT: OK.
>> ALLISON: Igen, vannak hatékonyan ugyanaz.
Ez csak attól a környezettől, érdemes egyik a másik fölött.
Igen?
>> DIÁK: Ha nem hivatkozás a 1--
ALLISON: Mm-hm?
DIÁK: Miért van a zárójelben?
ALLISON: Mivel diák 1 a mutató.
Így meg kell, hogy győződjön meg róla, csak dereferencing a mutató.
>> STUDENT: OK.
>> ALLISON: Tehát ebben az esetben itt, a zárójelek körül
azt jelenti, te dereferencing diák 1.
Szóval megy, ahol a diákok 1. pont, ami a struktúra.
Így most már tudod gondolja róla, mint hogy struct,
így tudjuk használni a normális működés pontot.
Más kérdés?
Cool, félelmetes.
>> Szóval az utolsó dolog, azt hiszem, az utolsó slide, woo!
OK, tehát lebegőpontos pontatlanság.
Beszéltünk röviden ez alatt előadás.
Alapvetően, mi végtelen sok valós számok.
És ha a srácok szerelem matek, van
mindenféle jó dolgok velünk.
>> De vannak végtelen sok valós számok.
De ők csak véges sok bitet, hogy van.
Szóval mindig lesz van pontatlanság, ez minden.
És ez az, hogy csak ilyen mint valami, amit tudnia kell.
Olyan, mint a mi lehet kérdezni, hogy miért nem lebegőpontos pontatlanság létezik?
Szóval, csak valami, amit tudnia kell.
És, hogy én fordult át a mutatók.
>> Muci: Helló, srácok.
A nevem Muci.
Fogok beszélni mutatók.
Igen, így mutatók valójában kedvencem ez a tanfolyam.
Szóval csak azért, hogy világos, hogy mi Allison beszélt itt, így az ok
why-- az egyetlen különbség, A nagy különbség volt az út
kijelentjük dolgokat.
Így hallgató csillag: ez a egy mutató egy diák.
Mivel a csúszda előtt, diák az tényleges struct, mint a tényleges hallgatói,
tartalmaz semmilyen olyan dolog.
>> És hogy miért is akar to-- igen, Davin?
>> DAVIN: Mit jelent a nyíl?
>> Muci: A nyíl eszköz pontosan ugyanaz, mint ezt.
Szóval nem igazán kell a nyíl.
Mint, ha csak a program C, akkor csak ezt használja.
Sajnálom, én nem, hogy mi az.
Tudod csak használja ezt a szintaxist.
>> De néhány ember, amikor azok tervezése C,
úgy gondoltam, hogy az emberek használta ezt a szintaxis annyira,
hogy tetszeni fog csak jön szintaktikai struktúrát is.
És ez került sor a formájában ez a nyíl.
És ez nagyon jó, mert jelképezi valami
mint mi valójában a következő A nyílra, ez a mutató,
felé némi helyet a memóriában.
És amikor odaérünk, azt akarjuk, hogy látod a nevét, hogy a hallgató,
ha van értelme.
OK?
>> Tehát ez pontosan ugyanaz.
Ez pontosan ugyanaz, mint ez.
Kapnak össze pontosan ugyanaz, OK?
És az ok, amiért itt malloc valami, azért van, mert ebben az esetben,
a változó valójában Csak egy pointer változó.
Tehát csak néhány hely memória, ami tartja a mutató.
Nem igazán van olyan hely hogy tartja a tényleges struct.
>> Tehát ezt meg kell tenni két lépésben.
Meg kell teremtenünk a memória, hogy a struct a.
És mi van, hogy megteremtse a memória, hogy a mutatót.
Így ők alapvetően két különböző változók itt.
Ezek közül az egyik típusú diák, kivéve, hogy nem igazán van neve.
És a másik típusú hallgató csillag.
Aztán diák 1 pont ott, ha van értelme.
OK?
>> Szóval, hogy miért is használjuk mutatók azért van, mert minden
egy számítógépes, minden változó Egy számítógép két dolgot.
Ez megvan a maga értéke.
És azt a címét.
És egy jó módja annak, hogy fogalmat, ez van
sok probléma, ha próbálja használni funkciókat.
És fogunk megpróbálni vizsgálja meg egy ilyen.
Nevezetesen, ez lesz a gondolom, memória dobozok.
>> Mindig gondoltam változók amikor azt mondja, na = 5.
Azt hiszem, az üzembe 5 egy dobozba.
Mi van, ha azt szeretné, hogy adja át hogy int egy függvény?
Csak pass-- én nem tudom-- x egy függvény.
De mi történik, általában, mint az emberek, akkor
azt hiszem, valami hasonló vagyok halad a dobozt egy személy.
És ez nem igazán történik a számítógépek.
Mi történik, másolja az értéket A doboz a személy mezőbe.
>> Szóval, mit akarok mondani, hogy ha van egy function-- sorry-- itt,
ha van egy függvény, mint öt fel ott, ha megpróbálja átadni a változó,
ez csak fog másolni.
Ha inicializálása nx = 3, ez lesz másolni ezt az értéket, hogy a változó a
ott.
OK, és ez a fajta az oka Ezért szeretnénk használni mutatók.
Mert ahelyett, hogy így csak az érték,
ahelyett, hogy csak múló csak az értéket a függvény,
szeretnénk átadni a referencia.
Mit nevezünk szerint átadott kedves hogy megszerezze a mezőbe funkció,
annak érdekében, hogy a funkció is Az értékek módosításával belül a dobozt.
>> OK, így csak néhány alapvető mutató dolog az, hogy létrehozzanak mutatók,
csak nyilváníthatja a típusát, és tesz egy csillag után is.
És a típus csak amit mutatott.
Tehát, ha ez egy int csillag, te mutatva egy int.
Ha ez egy char csillag, te mutatott a chart.
És ha ez egy diák csillag, te mutatott egy diák.
OK?
>> És ők mind a 4 bájt hosszú.
Mivel ez a változó ez valójában nem
kell tartani a char, int, vagy a diák.
Csak meg kell tartani egy címet.
Ezért ők a 4 bájt hosszú a normál 32 bites gép.
OK?
Tehát itt, x egy változó, amely egy int. y pontokat a karakter. z pontok
Egy úszó.
Bármilyen kérdése van?
Cool.
És van két különböző szimbólumok vannak
szem előtt tartani, amikor jön a mutató.
Így referenciái és dereferencing a nagyok.
Így a jelet a változó nevét adja az?
STUDENT: cím.
Muci: cím.
Tehát, ha kijelentem, int a = 5, akkor ampersand
Egy fog adni a címet.
És akkor valóban megpróbál nyomtatni, és látni, hogy a
milyen cím a memóriában A változó.
És akkor dereferencing-- így volt hivatkozó,
szerzés a address-- dereferencing pont az ellenkezője.
OK, csak mint az idők szemben a szétválás,
csillag az ellentéte jelet.
Így dereferencing eszközök ott.
Tehát, ha adsz star-- I Nem tudom-- 50, ez
megpróbálom menni címére száma 50 számítógép belsejében.
OK, és miért nem látjuk hogy ezek az ellentétek?
Mert mi történik, ha nem olyasmi, mint a csillag-jel?
Nos, egy jelet ad a címet egy változó, a címét.
De csillag azt jelenti, hogy ott.
>> És mi történik, ha megy a címét?
Csak kap egy, igaz?
Így lesz a címe Egy az ugyanaz, mint a.
Ezért ők általában hivatkozott a same-- ezt
és ezt nevezzük mivel ellentétes piaci szereplők.
OK?
Így jó.
>> A motorháztető alatt, például, ha kijelentjük int x = 5,
van egy változó.
És ne feledjük, hogy azt mondta, minden változó-- és ez egy jó dolog
tartani mind-- van két különböző dolgokat társítva.
Meg van egy címzett és egy értéket.
OK?
>> Így az érték ebben az esetben 5.
És a cím ez-- mondjuk, én vagyok hogy valami up-- hogy 0x04.
És az egyetlen oka annak, hogy általában képviseli címek hexadecimális
az egyik, mert ez olyan, mint a jó.
Ez jól megy a bináris.
Könnyen konvertálni és bináris.
És ez nem lesz túl nagy, ha van egy nagyon nagy szám.
Tehát szeretném használni hexadecimális nyomtatás címeket.
De jelenthet ez egy egész szám.
Ez rendben van.
>> És ez így van egy cím 4 és 5 érték.
És akkor azt mondtam int csillag mutató.
Tehát ez egy más típusú, értesítés.
Int csillag mutató értéke az x címét.
Tehát mi lesz az értéke a ptr?
Ez lesz az címét x, idelent.
OK, így az érték fog ugyanaz, mint a címet.
Ez a feladat működik csinálok.
És akkor ptr megy, hogy a saját címét, ami kiderül,
ebben az esetben a 8, OK?
>> Aztán egy új egész példányt.
És én azt mondom int másolat megegyezik menni.
Így megy mi ptr mutat.
Nos, mi ez a ptr van?
PTR 0x04.
Mi történik, ha megpróbálok menni oda?
Meg fogom találni a fickót, aki cím x és aki 4. cím.
És aki négy, x.
Van ennek értelme?
Igen?
>> DIÁK: Ebben az esetben, az a mutató a verem?
>> Muci: Ebben az esetben, it's-- jó kérdés.
Nem igazán hiszem, ezt a ha így fel ezeket a címeket.
De ha ez, mint, minden ezek lokális változók,
akkor x fog élni in-- mindent fog élni a verem.
Tehát minden rendben van hogy mutat verem.
Csak akkor kap a kupac, ha elkezdi használni malloc, ugye?
>> Tehát, ha emlékszem köteg minden alkalommal hívás funkció a programban,
mint, a fő például, vagy bármely más funkció, mint a printf.
Minden helyi változók lesz, hogy betesz egy verem keret.
És ők fognak kapni mint halmoztak fel a verem.
Ezt hívják a verem.
És azok a lokális változók lesznek ott.
És heap-- és megyünk beszélni többet erről later--
A halom, ahol minden dinamikusan lefoglalt memória életét.
Cool?
>> Mi megy ez a dia.
Igen?
>> Diák: Miért nem int másolat visszatér 0x04?
>> Muci: Miért nem int másolat visszatér 0x04?
>> Diák: Miért nem az, hogy [hallható]?
>> Muci: Mert mi az értéke ptr?
>> STUDENT: 0x04.
>> Muci: 0x04.
Mi történik, ha megy a 0x04?
Mit kap cserébe?
>> Diák: Oh, OK.
Muci: Látod?
Diák: Igen.
Muci: Így kapsz 5.
Így másolat megy, hogy 5, ha van értelme.
Igen?
>> Diák: Lehet mi ütött 5. Az érték dobozban [hallható]
ha teszünk int másolni [hallható].
>> Muci: Int-- mi lenne, igen.
Ez volna nagyjából ugyanaz a dolog.
De ez így, akkor át foglalkozik a funkciókat.
És ez a jó dolog fogunk csinálni most.
>> Tehát ez a fajta gyakorlat mindig jön fel on-- igen akkor jön fel vetélkedők.
Szóval nagyon jó, hogy megpróbálja Ehhez a fajta dolog magad.
Így próbálja nyomon követni, hogy mi a címe van, és szeretné, hogy a változók értékét
a minden ponton.
Tehát ez pontosan mit fogunk csinálni.
Itt van lépések, az egyik, két, három, négy, öt.
Egy, kettő, három, négy, öt.
És megyünk, hogy nyomon követhesse Az x értékei és a.
>> Szóval mi ez csinál, ha ez a hibás kód, próbálunk csinálni öt.
Szóval próbálok egy változó értékének megváltoztatása 5-re.
És ne feledd, az én analógiát, amelynek doboz és átnyújtotta a dobozt valakinek?
Így van ez a legfontosabb az úgynevezett doboz x.
És ez tartalmazza a 3 értéket.
És próbálom átadni ezt a rovatot, hogy az öt.
>> És azt akarom, hogy öt változtatni az értéke doboz 5.
És akkor én csak nyomtatni az x értékét.
Ez az, amit én function-- ez az, amit próbálok csinálni.
Csak próbálom frissíteni az x értéke 5-re.
Ez világos, hogy mi a függvény?
>> OK, akkor mi is lesz a az x és az itt,
az első sorban, jobbra, mielőtt az első line-- Szeretném say-- a program?
>> Diák: Valószínűleg szemét.
>> Muci: csak szemét dolog.
Szóval csak hogy N / A. Így nem igazán tudom.
Mint, a nem is létezik még, mert még nem hívott, hogy öt.
Int a nem bejelentett.
X és fog létezni itt, de még nem igazán
kijelölt bármely értéket, így rendben van?
>> És akkor, mi is lesz az az x és a második számú?
>> Diák: [hallható].
>> Muci: Szóval x lesz 3.
Ez egyszerű, mert mi hozzárendelése 3 rá.
És még mindig nem létezik mert csak él az öt.
Szóval megyek, hogy a 3 és semmi.
vagy mint a szemét, bármi, nem igazán definiált.
És most ez a fontos vonal.
Itt fogunk valóban hívja öt.
És ne feledd, mit mondtam.
Soha nem adja át a dobozban.
Csak értékének másolása A doboz egy másik doboz.
Ez minden számítógépen nem, másolja dolgok egyik helyről a másikra.
>> Tehát öt, hogy valójában mire ez másolatot az x értéke egy.
Szóval, mi lesz itt?
X értékei és a.
3 és 3, akkor csak másolja át az x a.
Cool.
>> Most, hogy itt vagyunk.
És most megyünk frissíteni a = 5.
Mi fog történni a sorban négy?
>> Diák: [hallható].
>> Muci: a frissül, de x nem frissülnek.
Mivel még mindig él x fő, ez a teljesen más blokk memória.
Ez egy másik változót.
Egy másik változó.
Úgy történik, hogy a ugyanazt az értéket, mert
másoltuk át az x értéke egy.
De most, amikor én a = 5, akkor nem igazán befolyásolja x semmilyen módon.
Ez a trükkösebb rész.
Van-e értelme a mindenki?
Igen?
DIÁK: Még egy kérdés, van 3.
Miért van already-- ó, nem, ez 3.
Sajnáljuk, de sebaj.
Olvastam 5.
>> Muci: Igen, 3, 3.
>> Diák: [hallható], igen.
Muci: És akkor rendelni 5 a, de nem igazán változik x.
Jó?
Diák: Igen.
Muci: Igen?
El tudod magyarázni újra, hogy Egy lesz másolva [hallható]?
>> Muci: OK, így amikor telefonál, hogy öt x, tehát ezt a kódsort itt.
öt, x, x, mi?
x mindössze 3 ezen a ponton, igaz?
Szóval lehet, gondoljunk csak üzembe 3 ide, és elfelejti x.
Csak hogy egy 3 itt.
Mint, megyünk másold át a x értéke az int egy, ami ott.
OK?
>> Így az x értéke 3 lehet.
Fogunk másolni 3. át a.
És ez a másik blokk memória, a másik változó
úgynevezett lesz 3, is.
Van ennek értelme?
Igen?
>> DIÁK: Ha adsz öt hasonló van ez, mint egész x helyett,
azt, hogy mindent megold?
>> Muci: Ha ez egy integer-- nem, hogy nem mindent megold.
Szóval ez egy nagyon jó kérdés.
Nem igazán számít, hogy mit hívja azokat a változókat.
Ismét lesz kérdés hatály, mert ők nem ugyanazokat az x.
Ők teljesen különböző terek a memóriában.
Diák: [hallható].
Muci: Tehát ez nem igazán számít, hogy hívják őket.
Ez nem oldja meg a dolgokat, oké?
Több kérdés?
Igen?
>> Diák: Hogyan vissza szám öt [hallható]?
Muci: OK, mi nem történt meg, hogy még.
Menjünk Number Five, majd.
>> Diák: [hallható]?
>> Muci: Mi?
>> DIÁK: Van egy visszatérés egyáltalán?
Muci: Nincs visszatérés, nem fő.
De a fő tér vissza 0-ra ha nem tér vissza semmit.
Igen?
>> DIÁK: Tudna csinál main-- vagy tudná, hogy öt a visszatérés?
>> Muci: Mi volna öt vissza, igen.
De akkor mi lenne hozzárendelni x megegyezik a visszatérési értéke öt,
ami egy kissé különböző programot.
Ez működik.
De mit akarunk csinálni az, ami hívott valami változás a helyén.
Ezért szeretnénk, hogy valóban változtatni doboz, és ne aggódj
amiatt, hogy visszatérjen értékeket, vagy ilyesmi.
OK?
>> Ez olyan, mint a csere funkció David mutatott előadás, kivéve vagyok
Csak kezeléséhez változó.
És két használt, így int a és b és akkor az átmeneti változó és miegymás.
OK?
Tehát mi az utolsó sor?
Miután öt visszatér, akkor csak az a fog menni.
Mi nem lesz többé, és csak x továbbra is él.
>> És tudod mit? x nem változik az értéke,
elvégre, mert vagyunk csak a változó értékét.
Ezért x 3 volt az egész.
OK?
Jó.
Szóval ez a program nem elérni, amit akartunk.
Most nézzük megjavítani.
>> És a fix program segítségével mutatók.
Mit csinálunk a mi három vonalak, amelyek különböző.
Az elsők a mi nem halad x.
Mi halad az x címét.
Tehát ahelyett, másolás felett a mező értéke,
Én még mindig tart másolni át valamit.
De én átmásoltad a címe a doboz.
>> Tehát, ha elmegyek a címét doboz az öt, majd öt
lesz képes megtalálni, hogy memória és változtassa meg az értéket.
>> Így aztán ott, én hogy a nem int többé.
a egy int kategóriájú.
Ez egy mutató egy egész.
És akkor, mert én halad a címet ide, és akkor mit csinálok
nem egyenlő 5, mert Egy, aki olyan címet.
Szóval, mit akarok csinálni az menjen oda, és frissíti a tartalmát a cím
5.
>> OK, menjünk át összes vonalak egyenként.
Tehát amikor elkezdem itt, én még N / A, N / A, N / A
mindent az első sor, mert én még nem igazán
bejelentett dolog még.
Aztán sorban két, már x = 3.
Egy csillag int a nem léteznek, ugyanaz, mint korábban.
>> Most lesz érdekes.
Szóval megyek át.
És tegyük fel, hogy a cím x 12 hexadecimális.
Nézzük csak feltételezzük ezt.
Tettem fel.
Szóval mit is halad itt egy öt.
Én halad a 12.
>> Szóval, milyen értéket jelent a van?
>> Diák: [hallható].
>> Muci: Tessék?
>> Diák: [hallható].
Muci: Igen, mint, hogy hagyja, hogy a Feltételezem, hogy itt vagyunk, most.
Kérek.
>> Diák: [hallható].
>> Muci: Ez kezdeményeztek.
>> Diák: [hallható].
Muci: Mert át valamit a funkció.
Igen?
>> Diák: Cím x.
Muci: Meg fog van az x címét.
És a címe x 12, jó.
Így x lesz 3, mert már nem igazán változtak x még.
És akkor egy lesz 0x12, így az x címét, mert ez
amit átadott öt.
>> És akkor mi történik ha megpróbáljuk ott?
Mit fogunk találni?
Tehát, ha próbál nyomtatni egy csillag, mi fogja követni ezt a címet
és hogy az érték benne.
És az érték csak ugyanazt az értéket, hogy x
van, mert ez a x címét, melyik lesz 3.
Vagyunk jó?
>> OK, és akkor most mi tényleg ott.
És frissíteni bármi Ebben a 12 címet.
Azt, hogy az 5.
Tehát most X és csillag 5.
>> Miért van ez?
Mivel az x címét 12.
És szintén a 12, mint az értékét.
Tehát, ha követjük a 12., vagyunk csak fog találni x.
Tehát bármit teszünk csillag fog történni
az x, mert tartalmaz az x címét.
OK?
>> És ez olyan, mint a kritikus pontja az fix.
Tehát most már tudjuk, tól öt, valójában
hozzáférés memória élt fő.
Szóval ez a memória nem él a öt, mint korábban, ezt a címet a 12.
És tudtuk, hogy ott értékének megváltoztatása 5-re.
>> Aztán amikor visszatérünk, elfelejtjük a.
Azt felejtsd el a csillag.
És x még öt.
Tehát, ha azt akarjuk, végre a csere funkció,
akkor csak nem pontosan ugyanaz a dolog, kivéve, ha kell int csillagok itt,
és így tovább és így tovább.
OK?
Vagyunk jó?
Cool.
>> Így pointer aritmetika.
Ez egy kissé kényes téma.
Így kiderül, hogy a mutatók csak egész számok.
Azt hiszem őket egész.
Mivel a memóriában, akkor tetszik memóriacím nulla, egy, kettő, három,
négy, öt.
Így tudjuk összefoglalni memória címeket.
>> És ez általában mit csinálsz, ha te és tömb, pl.
Egy sor olyan, mint egy szomszédos blokk memória, a rengeteg karakter,
Például sok ints.
Tehát ha azt akarjuk, hogy menjen a második int vagy a harmadik int,
ha csak összefoglalni valamit az első cím, és fogsz eljutni oda.
Szóval ez tényleg hasznos, hogy.
>> És a dolog, hogy tartsa szem előtt tartva, de az,
hogy ez nem csak, mint normál aritmetikai abban az értelemben,
hogy ha van dolgunk, azt mondják, egy int csillag, és adjunk hozzá 1-et,
akkor nem mész hozzá az 1-es címre,
fogsz hozzá 4 címre.
Mivel az int 4 bájt.
>> Tehát ez olyan, mint séta egy tömb.
Ha van egy sor sok ints és akkor igyekszünk menni a második,
ez alapvetően csak az összegző címe az első plusz 1.
De ez nem csak be-- mondjuk hogy a címe az első 4 lehet.
Itt, ebben az esetben.
Ha összegezzük, így ez a az, hogy mi történik.
Van egy int.
Int x = 5.
X értéke 5.
És Inicializálni mutató, int y int csillag y egyenlő az x címét.
>> Tegyük fel, hogy az x címét 4.
Mi fog történni most ha összegzem hozzá 1 y?
Meg fog ténylegesen összege 4 helyett csak 1.
Szóval hozzá egy 1, de ez valójában hozzáadunk 4, mert a számítógép okos.
Így fog ténylegesen hozzá az i-szer a méret a típusát a mutatót.
OK?
>> Tehát, ha ez a karakter, például, ha ez a csillag char y,
és ha hozzáadunk 1, akkor ez lenne legyen 5, mert char 1 byte hosszú.
Jó?
>> És végül, mi van, hogy mutatók és tömbök.
Kiderül, hogy minden alkalommal van dolgunk, egy sor,
te tényleg foglalkozik a mutató.
A nagyon szép elvi oka az, hogy a tömbök igen nagy.
Úgy emlékszem, hogy azt mondta, hogy Minden alkalommal, amikor át dolog körül,
másolni mindent.
Tehát, ha van egy tömb ez tényleg nagyon nagy,
nem igazán akar másolni mindent minden alkalommal
adja át körül a másik funkciót, mert ez csak
hatalmas mennyiségű munkát.
Szóval, mit csinálsz, csak múlt a címe az első byte.
És akkor a függvény férhet az összes elemet a tömbben.
Szóval át a tömböt a címe, így a címe az első byte.
>> Tehát, ha kijelentjük int tömb 3, itt, tudjuk,
hogyan lehet hozzáférni az első elem a konzol jelölést.
Ha emlékszik a konzol jelölés, tömb tartó 0értéke 1.
Nos, ez pontosan az ugyanaz, mint most menj oda, és tegye 1.
OK, ez pontosan ugyanaz a dolog.
Így a konzol jelölés itt ugyanaz lesz, mint ezen a vonalon.
>> És tudod mit a konzol jelölés A tömb konzol 1 lesz?
Ez csak ugyanaz a dolog, mint ez.
Így hozzá egy tömb.
Mozgás egy végig a memóriában.
Menj oda, és tedd 2.
OK?
Ez a vonal ugyanaz a dolog.
Azt akarom, hogy a harmadik doboz, így tömb plusz 2.
Menj oda, és tedd 3.
Tehát a memóriában, mi fog történni vagyunk
megy, hogy az 1., 2., és 3-as a három eleme ennek a tömb.
>> Tudtuk volna ezt a ismerős konzol jelöléssel.
Csak azt akarom tudni, hogy a srácok hogy ezek az ugyanaz.
OK, ez kérdéseket?
Szép.
Most megyek, hogy kézzel át a Hannah,
>> HANNAH: Yay, Yee-galagonya.
>> Muci: Beszélgetés memória és a cikk dolgokat.
[Taps]
>> HANNAH: Szia, hűvös, így vagyunk fog beszélni egy kicsit
körülbelül memória, amit csak foglalkozott a mutatók.
Tehát két fő része memória vagyunk érintett.
Megvan a stack, amely növekszik fel az alsó, és a kupac, ami
megy le a tetején.
És verem fog tartani Minden példány változók.
Így mindegyik felhívja a funkciót kap saját kis keretben a verem.
Szóval mint Gabe korábban említettük, ha A funkciót újra és újra,
megyünk verem dolgokat a verem.
>> És hasonlóképpen, a kupac, kezdődik meg a felső
fog tartani az összes memóriát hogy dinamikusan osztja.
És ahogy dinamikusan memóriát kiosztani,
ez jön le az alja felé.
Pár dolog, hogy tudatában legyünk, ha mi a verem és a halom,
a verem, ha van is many-- nézzük say-- rekurzív hívások,
és mi a hívás funkció újra, és újra, és újra, és újra,
és ez anyagmozgató fel, anyagmozgató fel, anyagmozgató fel.
És ez megy, hogy összeomlik a kupac.
Fogunk elfogy a memória.
Ez fog okozni a probléma a számítógép.
És hogy hívják a verem túlcsordulás.
Szóval ez biztosan valami, amit tisztában kell lenniük, és próbálja elkerülni.
És a kupac, meg kell emlékezni Nem véletlenül szivárog a memória.
Minden alkalommal, amikor a malloc, nem elfelejtette, hogy szabad memóriát.
Ellenkező esetben, akkor csak legyen a kupac kárba,
és a számítógép nem tudja, hogy ez szabad használni, hogy a memóriát.
Tehát ezek a dolgok pár hogy legyen nagyon óvatos, ha
van dolgunk a verem és a kupac.
Bármilyen kérdése van ezzel?
Félelmetes.
>> OK, hűvös.
Így ez a fajta ugyanaz ötlet stack túlcsordulás, ahol
megyünk túl a keretein milyen memória
A mi kéne, hogy képes legyen használni.
Így veszi, például egy puffer, vagy Lehet, hogy csak gondol rá, mint egy tömb.
És mi azt mondtuk, rendben, megyünk létre ez a szép kis tömb.
Ez lesz a húr.
Vagy ez meg fog tárolni karaktereket.
És ez csak fog köszönni.
És ez határozatlan.
Ennyi.
>> De ha én lennék valaki gonosz, és azt akarta, hogy csinál valami rosszat ez a tömb, amit
Tehettem az megpróbál írni múlt a végén a húr.
És látni fogod, ha Írok elég messze,
Én ténylegesen befolyásolja a feladó címét.
És ha elkezdek befolyásolja a feladó címét,
Én befolyásolják a program valóban fut.
És ahelyett, hogy visszatért, akkor Tudod, egy boldog, mint a húr hello, én
tehetne valami rossz, mint menni máshol a számítógép, még mindig
memória, változtatni, amit én akarok.
Szóval, ez az, amit ez fog kinézni , ha én csak ilyen töltött fel
véletlenszerű szemét érték, ebben az esetben csak egy.
Aztán amikor tényleg van, hogy a memória cím,
Elkezdtem feltöltése valami hogy azt tette, amit én akartam csinálni.
Bármilyen kérdése a puffer túlcsordulás?
Félelmetes, repülő jobb keresztül ez a cucc.
>> OK, így sokat beszélgettünk a körülbelül pointer Gabe.
Hogyan tényleg kap egy mutatót?
Hogyan jutunk cím memóriában?
Nos, tudjuk használni ezt a szép függvényhívás malloc, amely
fog kapni a kis darab memória,
különösen a kupac, ahogy megbeszéltük,
és ez megy, hogy vissza a mutatót a címet a memóriában.
És az az érv, hogy kell adni malloc
hogy mennyi hely a memóriában akarunk.
>> Így látja a méretét byte.
Mondjuk, például, vagy valójában, ebben a példában,
osztjuk elég hely, 10 egész.
Tehát valószínűleg mi fogunk akar , hogy itt van egy sor 10 egész számok.
Szóval, hogy ez a méret ints, amely Megtanultuk, volt, hogy hány bájt?
STUDENT: 4.
HANNAH: 4, gyönyörű, és mi akar 10 e egy sorban,
így van elég hely, hogy tárolja mind a 10 egész szám, ebben az esetben.
Valami szuper fontos, bármikor hívja malloc,
van, hogy ellenőrizze a null.
Ha nem ellenőrzi null, nos, malloc ha elfogy a hely
és már nem ad semmiféle több memóriát, akkor vissza null.
Tehát, ha nem ellenőrzi, malloc visszatérhet null.
És aztán, ha megpróbáljuk követéssel, a null pointer,
megyünk, hogy egy szegmentációs hibát, amely fogunk beszélni most.
Félelmetes.
>> OK, kérdéseket malloc?
Igen?
>> Diák: Van ellenőrzése null [Hallható] ne csináld a kvízt?
>> HANNAH: Persze, a kérdés az volt, nem is matter-- a kvíz,
kapsz pontot, ha le Ön nem ellenőrzi null?
Igen, akkor kap pontot le ha nem ellenőrzi null.
Minden alkalommal, amikor hívást malloc, mind a kvíz, és a psets és a való életben,
van, hogy ellenőrizze a null.
Jó kérdés.
>> GABE: Mit tegyek, ha nem szabad?
HANNAH: Gabe akarja tudni, mi lenne, ha nem szabad.
Akkor mi lesz a memóriavesztés mi kupac.
Más kérdés?
Igen?
>> Diák: Lehet you-- megy át puffer túlcsordulás tényleg gyorsan újra?
>> HANNAH: Persze.
A kérdés az volt, mehetünk át puffer túlcsordulás nagyon gyors.
Térjünk vissza az említett diák.
Tehát egy puffer, akkor csak gondolok rá, mint egy tömb, ugye?
Van néhány hely a memóriában.
És amikor először létre a tömböt, tudjuk tömbök fix méret,
vagy a puffer mérete rögzített.
>> Mondjuk ebben az esetben már csak elég hely, hogy írjon a húr helló.
Ha megy, hogy a kötött, ha megy mi tömb mondtuk tarthatna,
A ténylegesen kezdeni írás a memóriába
hogy a számítógép nem azt akarják, hogy ültesse át.
És különösen, ha elérünk olyasmi, mint a visszatérés
foglalkozik a funkció, amely, mint bármely más darab memória,
csak valahol a számítógép, akkor valójában
változtatni, és elkezdi csinálni a gonoszokat.
Választ a kérdésére?
Félelmetes, bármi mást?
Igen?
>> Diák: Így verem [hallható], akkor mondta megy alulról felfelé megy.
Belül verem tartomány, nem a memória megy, mint,
felülről lefelé vonatkozó minden szünet?
>> HANNAH: Hogyan you-- elhalasztja a Rob ez.
>> ROB: Növekedni fog az azonos irányba, mint a stack növekszik.
HANNAH: OK.
ROB: Szóval összezavarodnak.
Ez lesz absztrakció.
HANNAH: OK.
ROB: Ez helyes.
Tehát, ha a verem növekszik fel, akkor azt generally--
nem kell így lennie. de akkor nyilvánítja int x.
Akkor állapítsa int y.
Majd int x általában alacsonyabb, mint a stack int y.
De ez csak egy tény.
Ez nem olyan, mint egy fontos dolog mag.
>> ROB: Tehát a kérdés megint csak mi történik az egyes frame épít fel.
Így minden funkciót kap kis darab a verem.
És ahogy megy fel, ezen belül a kis darab, belül, hogy a keret,
azt fogjuk mondani, hogy a változók belül, hogy a keret is feljebb.
Kérdés?
>> ROB: Csak lenni mikrofon.
HANNAH: Ó, igen.
ROB: Beszélek beléd.
HANNAH: Ó, igen, az OK gombra.
ROB: A kivétel A tömbök és struktúrákat,
ahol tömbök, alacsonyabb index a tömbben,
és struktúrákat nagyobb területen a struktúrákat
garantáltan alacsonyabb címek mint a későbbi érték a tömbben.
Tehát azok garantált.
De minden egyes változók belül, mint int x és y int egy függvényen belül,
nincs szükség kapcsolat között a címüket.
HANNAH: Egy másik kérdés itt?
Diák: Így puffer flow, csak a puffer-túlcsordulás
Csak akkor történt, amikor is, mint kijelölt
mennyiségben egy tömb hogy akkor a nagyobb?
Mint, ugye?
Tehát, ha kér valamit a user--
>> HANNAH: Mm-hm.
Diák: Can ők erőszakkal kapsz valamit vissza
ez nagyobb, mint bármi amit számukra biztosított?
HANNAH: Persze, így a kérdés alapvetően,
tudja a felhasználó adja meg többet, mint amennyit kér?
Diák: Igen.
HANNAH: Nos, megakadályozhatja a felhasználó csinálja.
Lehet mondani, különösen nem adj több mint x szám byte
Én csak adtam szoba x szám bájt, x karakterek számát.
Szóval ez az, amit szeretnénk elkerülni.
Igen?
Mi a különbség a között verem túlcsordulás és puffer túlcsordulás?
>> HANNAH: OK, így a verem overflow-- ó, milyen
a különbség a verem túlcsordulás és puffer túlcsordulás?
Ezért szeretnénk gondolni verem túlcsordulás történik, ha mi vagyunk valójában
anyagmozgató ezeket függvény hívások.
Tegyük fel, hogy van egy rekurzív függvény, mert tudjuk, hogy minden egyes alkalommal, amikor
hívja a funkció, ez lesz saját keret a verem.
>> Így verem túl magas, és akkor kezdjük túlcsordulás.
És túl sok memóriát használnak, és Nincs sehol maradt.
Azt kapjuk, hogy hiba.
>> Buffer túlcsordulás a programon belül.
Azt akarjuk, hogy nem feltétlenül elfogy a memória ugyanúgy
hogy talán ha már stack fel annyi függvényhívás,
de írni már a memória hogy tudjuk, tudjuk használni.
És ez lehetővé teszi számunkra, hogy rosszat tenni a dolgokat.
Igen?
>> ROB: Igen, érdemes hogy csak ismételd ezt,
de akkor is úgy gondolja, A verem túlcsordulás
úgy, mint egy bizonyos típusú puffer túlcsordulás.
Vagy gondoljunk csak a verem, mint egy igazán nagy puffer.
Akkor, amikor verem túlcsordulás, ez olyan, mint egy puffer túlcsordulás.
De egy verem túlcsordulás csak egy speciális kifejezést használják, ha a stack
maga túlcsordul.
>> HANNAH: Rendben, így ismételje meg a videót,
azt lehet gondolni, mint a verem túlcsordulás egy bizonyos típusú puffer túlcsordulás.
Cool?
Minden további kérdést, mielőtt megyünk tovább?
Félelmetes.
>> OK, hűvös, úgyhogy beszéljünk Néhány gyakori hiba üzenet.
Ez olyan dolog, hogy van mutatott fel több vetélkedők,
így valami, amit érdemes hogy egy második pillantást.
Biztos vagyok benne, hogy már találkozott legalább néhány ilyen
ahogy csinálod a problémát állítja.
Ügyeljen arra, hogy tud beszélni róluk a kvíz.
>> Tehát az első az a szegmentációs hiba.
És ez minden alkalommal, amikor megpróbálja elérni memória
hogy mi nem férhetnek hozzá.
Szóval migh látta ezt, például, a kitörés.
Ha észleli ütközés vissza null, és akkor
próbáltam csinálni valamit azzal, hogy a null értéket,
a számítógép adna Ön a szegmentációs hibát.
Tehát az egyik fontos dolog, hogy tenni annak érdekében, hogy megpróbálják elkerülni ezt
hogy mindig ellenőrizze a null.
>> Lehet is látni implicit nyilatkozat funkciót.
Szóval, ez az, ami történik amikor Allison mutatta meg
hogyan csinál egy prototípus, ugye?
Mondjuk van egy kis függvény, hogy meghatározzuk.
Tegyük fel, hogy kocka.
És hogy megy az alján mi funkció alatt fő.
>> Ha elfelejtette mondani a számítógépnek kocka, amikor a fő megpróbálja felhívni kocka,
a számítógép lesz, mint, oh istenem.
Fogalmam sincs, hogy ez mit jelent.
Nem tudom, mit tegyek, itt.
Így a prototípus mondja ne aggódj.
Meg fogom mondani.
>> Ez fog jönni.
Ne kiabálj velem.
Ne adj nekem egy implicit nyilatkozat függvény.
Tehát, ha ez a hiba, egy dolog, amit szeretne majd csinálni
az győződjön meg róla, hogy a prototípus.
OK?
>> És végül, de nem utolsósorban, be nem jelentett azonosító
lényegében amikor megpróbálja használni a változó, még nem bejelentett.
Így hirtelen elkezd mondván, mint n plus plus.
És a számítógép azt mondja, mi n?
Soha nem mondta, n volt a dolog.
>> Tehát az egyik dolog, amit meg kell győződjön meg róla, nem is mondja a számítógép, mi n.
Így például, az n egy egész szám lehet.
És akkor a hiba elkerülésére.
Minden kérdésre gyakori hibák?
Igen?
>> Diák: Az implicit nyilatkozat függvény,
lehet azt is, hogy kihagyott egy A könyvtárak azt is el kellett
hogy tartalmazza, nem pedig a prototípus?
>> HANNAH: Rendben, tehát a kérdés volt, tudnád
is kap ez a hiba, ha elfelejtettem, hogy könyvtár.
>> Diák: Igen.
>> HANNAH: Abszolút, mert ugyanúgy
hogy azt akarjuk, hogy a prototípusok mielőtt a fő funkciója,
ha van egy könyvtár, azok mennek lényegében magában foglalja a prototípusok,
között meghatározta a funkciókat.
Nagy kérdés.
>> DIÁK: Egy szegmentáció hiba lenne azt is
történik, ha mi, mint, próbáltam elérni egy változó,
mint például, egy másik [nem hallható] mint azt hirdettek?
HANNAH: Persze, így tennénk kap egy szegmentációs hiba
ha megpróbáltuk elérni a változó közül hatály?
Volt, hogy a kérdés?
Diák: Igen.
HANNAH: Beautiful.
Tehát valószínűleg, fogsz kapni egy be nem jelentett azonosító helyett tévedésből.
Szóval ez csak fog mondani Nem tudom, mi az.
Cool, bármi mást?
Ja, OK, gyönyörű.
>> Rendicsek, így rekurzió.
Szóval említettem egy-két alkalommal hogy lehet, hogy a verem túlcsordulás
mert mi vagyunk a hívás rekurzív függvény oly sokszor.
Mi megvagyunk mindezen stack keretek, bla, bla, bla.
Mi még a rekurzív függvény?
Nos, a rekurzív függvény minden olyan funkciót, amely magát.
>> Néhány dolog, hogy tudatában legyünk, ha hajtják végre rekurzív függvény,
ne felejtsd el, hogy tartalmaz egy alapeset.
A alapeset az a pont, ahol a végén.
Így például, ha már kódoló, , Mondjuk, Fibonacci rekurzív,
azt szeretnénk, hogy győződjön meg arról, hogy amikor megkapjuk a 0 vagy az első Fibonacci-szám,
E két szám van ezekben az esetekben, mert ezek nem függnek
a dolgokat, hogy elé került.
Ezek a saját értékeit.
>> Néhány előnye a rekurzió, amely egy kérdés láttunk a korábbi vetélkedők.
Vezethetnek, hogy több tömör, elegáns kódot.
És egy csomó funkció, a sok különböző algoritmusok,
valójában adnak arra, hogy a rekurzió.
A definíció lehet rekurzív önmagában.
Tehát Fibonacci egy.
Faktoriális egy.
Merge rendezés one-- összes dolog, akkor nézd meg.
OK, kérdés?
Igen?
>> Diák: Van egy sarok ügy hasonló a bázis ügy?
Vagy az, hogy valamilyen más fajta [hallható]?
>> HANNAH: Persze, így a sarok eset any-- olyan
a sarok esetében ugyanaz, mint alapeset?
A sarok eset van valami, hogy a kód viselkedhetnek egy kicsit másképp.
Alap esetben egyfajta kapcsolódó, a hogy ők, mint egyes esetekben
hogy szeretne nézni.
De az ötlet egy alapeset az, hogy szeretné, hogy a rekurzív függvény
megállítani egy bizonyos ponton.
Ez nem tart örökké nevezte magát.
Meg kell, hogy egy bizonyos ponton megáll.
>> ROB: Igen, gyakran, a bázis ügyek Lehet példákat sarok bázisok.
>> HANNAH: Jobb, hűvös, valami?
>> DIÁK: Meg tudná magyarázni alapozza, egy kicsit?
Én nem egészen értem [Hallható] alap esetben.
>> HANNAH: Az alap esetben?
>> Diák: Base esetben igen.
>> HANNAH: Ja, biztos.
Lássuk.
Nem mi kréta itt?
Igen, mi.
OK, így nagyon gyorsan, én megpróbál írni elég nagy
így láthatja a képernyőn.
Beszéljünk, tényleg gyorsan, Fibonacci.
Szóval kapsz a Fibonacci-sorozat.
Akkor nézz fel a meghatározás.
>> Lényegében minden szám a sorozat összege az előző két számot.
OK, így az is, hogy én imént leírt Fibonacci,
akkor lehetett hallani a rekurziót, ugye?
Amikor azt mondtam, minden szám a összege az előző két számot,
mondhatnánk az OK gombra.
Nos, az n-edik Fibonacci number-- úgyhogy
mondjuk, hogy ezt a funkciót úgynevezett fib-- fib n
lesz egyenlő fib n mínusz 1 plus-- sajnálom,
mi folyik a következő sorba felett here-- FIB n mínusz 2.
>> OK, így ez remekül működik, ha nézi, például, a nulla, egy,
két, három, négy, ötödik Fibonacci szám,
ahol lehet mondani, hogy 5 egyenlő 2 + 3.
De mi van, ha te vagy az elején?
Mi van, ha csak most üti az első két érték?
>> Ahhoz, hogy ez 1, akkor nem mondjuk hozzá az előző két,
mert ez nulla és-- nem tudom.
Tehát egy bizonyos ponton, meg kell állnunk.
Egy bizonyos ponton, meg kell mondani, hogy ezek a Csak két saját meghatározásokat.
A Fibonacci szám 0 0.
És az első Fibonacci szám 1.
>> Szóval, ahogy én is ezt a kódot, én azt mondják, ha az n érték kevesebb, mint két,
akkor csak vissza n.
És ez lenne az alapeset.
Így tudom, hogy hagyja abba egy rekurzív függvény.
Világos?
Félelmetes.
Még valami rekurzív?
Gyönyörű.
>> Menjünk gyorsan beszéljünk keresés és rendezés futási időket.
És akkor adok némi Davin ideje, hogy beszéljünk kódolási példák.
Tehát itt van a kereső és fajta, amit tudni kell.
Guarantee-- Nem tudom garantálni, mert én még nem láttam a quiz--
de ez jön ki a kvízt miután kvíz után kilép.
Tehát feltétlenül használja ezt a táblázatot.
Mint ezt a chart.
Tedd rá a puskát.
Nem lesz boldog ember.
>> Ez azt mondja a futási idő az egyes Az ilyen fajta és keresési algoritmusok.
Szóval lineáris keresés, láthatjuk futás idő, és ugyanaz a bináris keresés.
Menj át mi ezeket az algoritmusokat igen, az alapötlet.
Nézd meg néhány pszeudokódja, ha nem kódot is.
>> Látni fogod, hogy buborék van egy fajta felső kötve a legrosszabb esetben, ha n négyzeten.
Tehát, ha a tömb teljesen visszafelé mielőtt akartunk rendezni,
azt mondanánk, hogy ez megy, hogy n négyzetes lépéseket.
De a legjobb esetben, így a alsó, a legjobb esetben
lesz, ha ez már tökéletesen rendezve.
Akkor minden, amit meg kell tennie, hogy ellenőrizze, hogy ez rendezett.
Van kérdés itt?
>> DIÁK: Ha lenne használni kívánt sort?
A sort.
Csak kíváncsi vagyok.
>> HANNAH: Ha azt szeretné használni kiválasztás sort?
Ez az?
Az egyik, hogy az n-négyzet mindkét esetben?
>> Diák: [hallható].
>> HANNAH: Tehát ez nagyon más.
Ha konkrét követelmények a program
mint a dolgok, mint ha csak azt mondta: végrehajtása search-- sorry--
végre egy sort, akkor érdemes menni
az egyik az is, hogy van egy legjobb esetben, ha n,
vagy az alsó határát a legjobb esetben n.
De lehet Bizonyos dolgok, mint, mondjuk,
swap tényleg drága valamilyen okból.
Akkor, amit szeretne csinálni buborék sort, mert
kell olyan sok csereügyletek, ilyesmi.
Minden other-- igen?
>> Diák: lenne [hallható] azt jelenti, hogy [hallható]?
HANNAH: Ez az egyik dolog hogy megmondja,
ha ránézünk a végrehajtás.
Az, hogy én valójában gondolni, hogy miért ez n
squared az, hogy meg kell futtatni keresztül tömb n hosszúságú,
minden egyes alkalommal, hogy legfeljebb n swap.
És mi van, hogy ezt a folyamat n-szer.
>> Tehát, ha van, hogy a legtöbb, n csereügyletek és n végigfut a tömb,
ott lesz, hogy n négyzeten.
De igen, ez látható lesz ezen keresztül a kettős hurok,
mivel a kérdés asked-- vagy egymásba ágyazott for ciklus, azt kell mondanom.
OK?
>> Aztán egyesíteni sort, amely a leggyorsabb fajta most,
vagy, hogy már tárgyalt CS50, tudjuk, hogy a legfontosabb algoritmus
ez az ötlet betörni rendezett darabokat, majd
összevonásával ezek sorrendje bit.
És lesz velünk log n log n.
Minden kérdésre keres és fajta mielőtt elmegyek azt?
Lássuk.
>> Oh, kapcsolt listák.
Bocsánat, én még egy témát.
OK, félelmetes, láncolt listák.
Probléma a tömbök, hogy van egy rögzített mérettel.
Tehát, ha nem tudod, milyen nagy A bemenet lesz,
nem szeretne létrehozni egy tömböt.
Mert ha létrehozunk egy tömb, hogy túl kicsi,
talán befut puffer túlcsordulás.
>> Tehát ahelyett, tudnánk tenni valamit A kapcsolt listák, amelyek
lehetővé teszi számunkra, hogy a dinamikusan méretű adatstruktúra
amely lehetővé teszi számunkra, hogy tárolja a rugalmasabb mennyiségű adat.
Így minden egyes csomópont a mi láncolt lista, van két darab.
Megvan a tényleges értéket tárolja.
Szóval ez csak a dolog, amit lásd a tömbben, például.
És akkor mi is nyomon követni a mutató a következő dolog a memóriában.
>> Ellentétben a tömbök, amely tudjuk, minden fog
a be-- tömb elemeit mind egy a másik után memory-- kapcsolódó
listák bárhol lehet a memóriában.
Ők tetszőleges helyre.
Tehát, ha mi voltunk a valóban megy megtalálni őket,
kell nyomon követni a következő dolog a listánkon.
>> És akkor, hogy megismerjék ha ez a lista egészében,
minden meg kell nyomon követni a első eleme a láncolt lista.
És hogy majd lehetővé teszik számunkra, hogy végigvigye.
>> Szóval, ez az, hogyan lehet meghatározni egy mód.
Ez egy nagyszerű lehetőség hogy kihasználják a struktúrákat.
Mert ezt az ötletet, nos, egy adott csomópont, van két darab.
Én a tényleges érték is.
És akkor van egy mutató a következő elem a láncolt lista.
Tudod, van egy n egész szám, ami lesz a tényleges érték,
majd a mutatót a csomópont, az úgynevezett a következő.
Annak érdekében, hogy ez lesz a következő eleme a láncolt lista.
Diák: Igen?
Van, hogy meghatározza, hogy a csillag, mint egy struktúra?
>> HANNAH: Igen, így van, mivel ez a majdnem olyan, mint egyfajta,
úgy tűnik, mint egy rekurzív definíció, hogy mi
kell, hogy mi a csomópont belül megtalálása csomópont.
Mivel ez nem a ténylegesen tudja, mi az a csomópont teljesen
amíg nem kap a végére this-- és ezt követően tudjuk csak nevezni
a node-- belül ennek a meghatározásnak, meg kell nevezni a struct csomópont.
Nagy kérdés.
Bármi más?
Igen?
>> Diák: Miért kell, hogy mondjam node kétszer?
Mert amikor mi voltunk [hallható] mi csak meg kellett csinálni a pontosvessző,
de most meg kell találni, hogy a struct csomópont? [Hallható].
HANNAH: Szóval azt hiszem Az utolsó példa,
mi csak létre, amikor csak szerette volna használni egy diák után, hogy
kellett használnia struct node-- Én sorry-- struct diák.
Ez lehetővé tette számunkra, hogy, miután az a tény, csak használat csomópont egy új típusú, lényegében.
Van ennek értelme?
Szóval mi lenne, hogy menjen vissza, és nézd meg a kódot, mielőtt.
De azt hiszem, mi nem éltünk typedef.
És feltette a kérdést, miért kell használni typedef?
Typedef lehetővé teszi, hogy elkerüljék a szó struktúra az elején.
Igen?
DIÁK: Milyen kérdéssel jön
szempontjából tekintve csomópontok és a kapcsolt listák?
>> HANNAH: Tehát az egyik dolog, azt mondhatjuk, hogy milyen Lehet, hogy keressen egy láncolt lista?
OK, mert ez egy kicsit bonyolultabb
mint ha keres a tömb.
Mi csak nézd elem nulla, elem egy, két elem, bla, bla,
bla.
Ha meg akarjuk keresni egy láncolt lista,
mi lenne valójában követni ez a kis labirintus mutatók.
Szóval tényleg megy ezen keresztül nagyon gyorsan.
Mit tudnánk tenni kötelezze to-- mondjuk mi
akarom, hogy csak halad végig mi teljesen láncolt lista.
Szeretnénk kezdődik a fejét.
És akkor, hogy lépjen a következő elem,
ahelyett, hogy csak egy növekvõ mint mi talán megy keresztül egy tömb,
mi valóban lesz kövesse a következő mutató,
így találunk, ahol memória a következő elem.
Szóval tudom, hogy nem elég, hogy vegye mindezt most,
de akkor ezeket a diákat.
Így megy át ez egy kicsit lassabban.
De lényegében, hogy mit akarunk kell tennie, hogy a következő mutatók
át teljes egészében a láncolt lista.
Tehát ez a kérdés lehet kérni.
>> Valami észre a beillesztés, mondjuk
akartuk, hogy egy új elem elején a láncolt lista.
Van, hogy nagyon óvatosnak kell a sorrendet, amelyben mi
újraosztani a mutatók.
Mert mondjuk én csak azt mondtuk, rendben.
Győződjön fej pont ez az új elem.
Csak hogy pont 1 Akkor, most már lényegében elvesztette a többi a mi lista
mert én nem emlékszem, hol 2 él.
>> Tehát meg kell tenni a igen, meghatározott sorrendben.
Először is azt, hogy az új elem pont a fejét.
Aztán, hogy a fej pont az új elemet.
Szóval lássuk, mi hogy néz ki, mint a A arrows-- csak úgy.
Szóval először az új elem pont a régi fejét.
És most, mi van a fej pont az új első elemet.
Bármilyen kérdése van ezzel?
>> OK itt van néhány kód újra, valami nézni egy kicsit később.
És most térek át a Davin A GDB és egy kis gyakorlás
kódolási papíron.
Gyönyörű.
>> ROB És Rob.
>> HANNAH: Ó, Davin és Rob.
Sajnálom.
>> Diák: Woo!
>> ROB: Köszönöm.
>> DAVIN: Azt akarom mondani, minden igazi gyors?
ROB: Igen, igen.
DAVIN: Egyszer vagyok fel.
OK, míg Rob helyezi a mikrofon, akkor mi a GDB?
Mindenkinek kellett volna a GDB osztály, valamint a munkaidő.
És ha kell, használja.
Tehát mi GDB?
Valaki?
>> DIÁK: Ez egy debugger.
>> DAVIN: Ez egy debugger.
És mit jelent ez lehetővé teszi, hogy nem?
Mint, miért szeretjük a GDB?
DIÁK: Az lassítja a programot.
DAVIN: Rendben, így járni keresztül, mint egy ember ütemben.
És akkor mi van néhány parancsok meg tudod csinálni?
Nos, szünet valószínűleg kedvenc parancs.
Mert lehetővé teszi, hogy megtöri a programot, és tulajdonképpen ez a séta
soronként.
>> Run segítségével futtatni.
Ezután, mint lépett át.
Mi a következő között és a lépés?
Várj, azt mondják, hogy ki hangosan.
Ez volt a helyes.
>> Diák: [hallható].
>> DAVIN: Igen, félelmetes.
Szóval, mint, a következő lépés, és, ha you're-- mondjuk van egy funkció
határozza meg.
Tegyük fel, hogy valami a fő funkciója, és te csak üti next, next,
következő.
Te tényleg megy hajtja végre azt a funkciót,
de fogsz ugrani rajta.
Ha bejön lépés, vagy s vagy bármi, te
fog valójában ugrani bele ezt a funkciót,
és akkor megüt következő hogy a különböző hívások
belül az adott funkció.
Igen?
>> Diák: Van-e mód ugrani, mint visszacsinálni?
DAVIN: Befejezés, igen, befejezni ugrik téged.
Így fog befejezni, hogy a funkció, és akkor már
lesz újra a fő, például.
Nyomtatás nyomtat ki egy időben.
Valami, amit mindig is látható.
Kijelző nyomtassa ki folyamatosan egész teljes
a program.
>> Például, ha egy for ciklus, és
szeretné látni, hogyan változik valami, és nem akar, mint, folyamatosan
csinál, mint a nyomtatás, nyomtatás, nyomtatás, kijelző
jelenik meg, hogy a változó folyamatosan, minden alkalommal, amikor megüt a Tovább gombra.
És továbbra is.
Szóval GBD, ez GDB.
>> Diák: Mi az az egy ahol [hallható]?
DAVIN: Mi ez?
>> Diák: Mi a-- a lokális változók.
ROB: Van valami valójában mint a helyiek, vagy valami.
I can't--
>> DAVIN: Lehet, valami ilyesmi, igen.
>> HANNAH: A helyiek?
>> DAVIN: Ennyi.
Ez az egyik.
ROB: Beautiful.
>> DAVIN: Igen.
>> DIÁK: Mit is csinál?
>> DAVIN: Ez continues-- így csak folytatódik a programokat.
Tehát, ha szünet és hit tovább, ez lesz
hogy csak futtatni a programot, amíg eléri, hogy a szünet megint.
Így például, ha a tört egy függvény,
és fogsz csinálni, mint a hurok vagy valami ilyesmi,
és bejön is, ez lesz a tovább, és menj vissza a szünet.
Vagy nincs szünet, ez lesz a folytatni és befejezni a programot.
>> ROB: Szóval csak azt szeretném futtatni leáll az első töréspont
bejön, ha majd hit is, meg fogjuk tartani
egészen addig, amíg ez a következő töréspont.
És akkor is fog menni a következő töréspont.
DAVIN: Bármilyen más kérdésre GDB?
Szóval azt hiszem, az elmúlt, mi már megkérdezte, hogy mi
GDB és adjon Például néhány dolgot
lehet csinálni GDB, így igazi egyszerű, de igen.
Tessék.
És csomópontok?
>> ROB: Igen, igen, melyik irányba volt?
DIÁK: Ez volt az.
DAVIN: Várj.
ROB: Ez a fickó?
DAVIN: Ez az egyik.
ROB: Ez a fickó, ó, nem vettem észre.
Tehát nem volt egyértelmű hogy mit a-- én nem
tudom, ki ez, de a kérdés was--.
Nem tudjuk pontosan, mit arra kérdezett rá, így csak a
tisztázni valamit.
Tehát az első, mint már mondtam, typedef te mindig használ csak
hozzon létre egy becenevet típus.
Tehát itt, a becenév vagyunk crea- az ilyen típusú struct csomópont.
>> Tehát az első, figyelmen kívül hagyva ez a csomópont typedef, így ez a struktúra csomópont göndör
melles le a következő göndör zárójel a struct csomópont típusát.
És meg kell, hogy a csomópont ott, mert
kell hivatkozni node itt.
Tehát ez a fajta rekurzív struct, meg kell adni A struktúra egy nevet,
vagy mást, amit nem sikerült mondjuk struct csomópont van.
Míg korábban a diákok amikor mi voltunk gépelt, azt hiszem,
mi nem kell, hogy mondjam diák ott, mert
Nem kell, hogy mondjam struktúra diák belül a struct is.
Tehát a rekurzív hogy kényszerít bennünket, hogy mondjuk csomópontban.
>> Ez a csomópont csak a név vagyunk amely csomópont a typedef.
Annak érdekében, hogy csomópont nem ugyanaz, mint a csomópont.
De ez struct csomópont a ugyanaz, mint a struct csomópont.
DAVIN: Tehát ha hívod, mint csomópont a fő funkciója,
akkor nem fog kell mondanom struct csomópont.
Akkor csak annyit csomópont, mert csomópont egy different-- alapvetően
azt mondod, OK.
Ahelyett, hogy hívja struct csomópont a kód,
Csak azt akarom, hogy nevezze át a csomópont, hogy könnyebb.
>> ROB: Ha mindig használja typedef, akkor ez a
az egyetlen hely, fogsz, hogy arra, hogy egy változó struct csomópont
csillag, igen.
>> DAVIN: OK, így az utolsó rész nehéz tanítani because--
ROB: Mi?
>> DAVIN: Mert ez kódolási papíron.
Így minden évben van kód papíron kérdéseket.
Szóval azt hiszem, tavaly 12 ből 80 pont volt kód papíron.
Évvel korábban, hogy 10-ből 80, évvel azelőtt, hogy a 20 100,
így jó néhány ezek közül.
Szóval megy, hogy képes kódolni ezeket a funkciókat kézzel.
>> Szóval gondoltam talán megy át pár, és látom, hogy az emberek,
fajta séta őket lassan az emberek.
Így általában, és strlen atoi már nagyon népszerű.
Tavaly, azt hiszem, volt GetPositiveInt és RandomInt.
De pow, így erő is egy pozitív is.
Menjünk át talán egy vagy két ilyen együtt.
Mit az emberek látni akarnak?
>> STUDENT: atoi.
Diák: Igen.
DAVIN: atoi?
Diák: [hallható].
DAVIN: OK, megyek csinálni a táblán.
Van egy előnyben ha én itt vagy ott?
Ott, Gabe azt mondja.
>> ROB: És ez általános gondolatok e kódolási kérdéseket.
Próbálj meg írni valamit.
Ne hagyja üresen.
>> DAVIN: Igen.
ROB: Ha kap a vissza típus helyes,
vagy talán mi is, hogy ez a te, de ha lehet, például,
írja az általános funkció aláírás, Ha lehet kapni az alap esetben helyes,
vagy sarok esetek, vagy emlékezve csekket null,
amíg van néhány dolgok, akkor talán
adhat egy pár rámutat a problémára.
Ne hagyja üresen.
>> DAVIN: Igen, és ha csak teljesen
kivágott, hogyan lehet valójában alakulnak kódot.
Ha írsz pszeudokódja, ez nagyon jó is.
Szóval, ez olyan, mint, hogy ez a hat pont kérdés, és írsz a helyes pszeudokód,
kapsz legalább két pont.
Tehát ne hagyja üresen.
Próbálj tenni valamit.
>> ROB: Meg kell a helyes pszeudokódja, mégis.
>> DAVIN: Igen.
ROB: Tehát általában kevésbé engedékeny hibákat pszeudokód.
DAVIN: OK, így srácok látni akarta atoi.
OK, így csak really-- így mit akarsz csinálni
A te leszel adott valamilyen számot.
De ez a szám nem lesz, int, ugye?
Milyen érzés lesz?
>> Diák: [hallható].
>> DAVIN: Ez lesz a húr, ugye?
Tehát, ha kaptak a string-- nézzük say--
>> ROB: Kell húzza fel egy szerkesztő?
Tudom húzni up--
>> DAVIN: Ó, akarsz csinálni on--
>> ROB: Szeretné, ha a fórumon?
>> DAVIN: Mit akarsz csinálni?
Úgy értem, nem akarsz csinálni kézzel?
Vagy akarsz csinálni számítógéppel?
>> ROB: Csináld kézzel.
>> DAVIN: [nevet]
ROB: Csináld kézzel.
>> DAVIN: OK, így lesz atoi.
Tehát mi it-- gondolok, akkor talán hogy ez neked.
De mit fog ez vissza?
>> STUDENT: Int.
>> DAVIN: Meg fog visszatérni int, ugye?
So-- Én nem akarom, hogy ott.
Majd én itt.
>> ROB: Akkor húzza le majd nyomja fel rá.
>> DAVIN: igen.
[Nevet] Játék változás.
OK, így lesz int atoi, és mi fog ez tartani?
A char csillag, így csak a húr, s csillag, ilyesmi.
>> ROB: Szép csillag, szép.
DAVIN: Ez lehet, hogy nem lesz ott, OK.
ROB: Igen.
DAVIN: OK, így az első dolog, amit akarok do-- I
Nem tudom, ha valaki nézett A gyakorlat solutions--
de mit akarsz hogy akarok a te
szeretne majd, hogy a hurok, mert te
szeretne majd ténylegesen menj végig ezt a fonalat.
Így helpful-- így mondjuk megyünk a for ciklus,
és fogunk lépkedni minden eleme a húr.
Milyen hosszú ez?
Hányszor megyünk segítségével navigálhat az, hogy hurok?
Diák: Sterln?
DAVIN: Sterln, igen.
Tehát mondjuk int hossz eléri sterln s.
És csak kíváncsi, miért van mindig kedves jobb, hogy ezt külső hurkok?
Mint, miért jobb, hogy hívja ez a funkció egy cikluson kívül?
Csak egy gyors józanság ellenőrizni?
Igen?
DIÁK: Szóval nem kell, hogy nézz rá.
Tudod csak [hallható].
>> DAVIN: Pontosan, így igen, pontosan mit mondott.
Tehát nem kell, hogy nézz rá.
Így például, ha hívom Ez a funkció a hurok belsejében,
akkor fogok tartani hívás Ezt a funkciót többször.
És hogy fog csökkenni hatékonyságát a program.
Tehát mindig hasznos nyilatkozni kívülre.
>> ROB: Ez azt mondta, a bármelyik ezeket a problémákat,
nagyon sokat, amíg kap egy dolgozó megoldás, akkor kap a teljes hitelt.
Szóval ne aggódj, ha a tervezési teljesen borzasztó.
Lehet, hogy nekünk ideges olvasó a kódot.
De amíg ez működik, kapsz pontokat.
>> DAVIN: Igen.
OK, így akkor megyek állapítsa meg néhány változó.
Ez csak fog hívni int összeg.
És én fogom be ezt nullával egyenlő, mint ezt.
És ez csak fog hogy egy helykitöltő.
Annak érdekében, hogy ez lesz mit fogok visszatérni.
Szóval megyek végül vissza összege ki ezt a programot.
Szóval van ez a két változó.
Van hossz.
Van összeg.
És most ugorjunk át a húr.
>> Így lehetővé teszi, hogy a hurok.
Tehát négy int I értéke 0 w, míg I-nél kisebb hosszúságú én plus plus.
És now--
ROB: Szép.
DAVIN: OK, és most itt jön a hús a kód.
Így valójában ez alapvetően egy sorban.
Tehát nincs valaki van egy ötlete hogy mit fogunk csinálni?
OK, ez rendben van.
Ezért csinálunk mondani összeg equals-- hadd rohan ez over-- összeg
egyenlő összeg 10 alkalommal plus-- vagyunk fog tartani s én mínusz egy
quote 0 egy idézet tenni, mint ezt.
ROB: Nagyon intuitív.
>> DAVIN: Zúzott azt.
OK, így someone-- megvan, megvan.
OK, így ez egyértelműen megy fel.
Mit jelent ez?
Szóval tudja valaki, hogy mit jelent ez?
Lehet mindenki látja ezt?
Nem, senki nem látja ezt, OK.
Megyek to--
>> ROB: Meg fogom írni a formula csak itt.
DAVIN: OK, Rob fog csinálni A számítógép, ami szórakoztató.
ROB: Istenem.
Vagy én nem.
DAVIN: Készenlét.
Diák: Van egy kérdésem.
DAVIN: Igen, biztos.
Diák: [hallható]?
DAVIN: OK, így valójában, tetszik, csak általában,
Ha úgy döntesz, hogy fel, mint például, ebben nyilatkozatban int
I értéke 0 vessző hossza egyenlő sterln, hogy--
>> Diák: [hallható].
>> DAVIN: Ez rendben van, mert hogy--
DIÁK: Miért te még kell használni hossz?
Miért ne lehetne csak [hallható] sterln s, mint az egész idő [hallható]?
>> DAVIN: Mármint itt?
>> Diák: Igen.
DAVIN: Mivel minden amikor ez a ciklus fut,
ez fogja értékelni ezt a feltételt.
Diák: Igen.
DAVIN: És ha sterln ott, akkor ez
lesz, hogy valóban hívja ez a funkció minden egyes alkalommal.
Tehát ahelyett, hogy csak a összehasonlítva azt egy int,
fogsz szólítani a funkciót, majd összehasonlítja
a visszatérési érték.
Igen, így ez csak, igen.
>> Szép, OK, így most már mindenki láthatja.
Mi does-- ez olyan, mint, ez az.
Ez a lekvár, itt van.
Mit jelent ez?
Mit csinálok?
Ja, egy ötlet?
Igen?
>> Diák: Hát, amikor adsz meg egy tömb,
fogsz, hogy lesz balról jobbra,
így leszel megy tizedes származó le a [hallható].
DAVIN: Pontosan.
DIÁK: Tehát mindegyik meg kell szorozni
amit látott az értéke int által Mire eljut mozgatni, hogy több mint egy.
>> DAVIN: Tökéletes, tökéletes, így például, hadd
mondjuk adtam you-- vagyok fog írni ide.
Nem, nem vagyok.
Fogok írni ide.
Tegyük fel, hogy én adtam neked 76, ugye?
Tegyük fel, hogy kapsz 76.
Ez egy string kezdeni, OK?
>> Szóval, hossz, az mi?
2, ugye?
Összeg 0.
Akkor ugorj be a hurok.
OK, az első iteráció ez, mi is lesz?
Ez lesz összeg 0.
Tehát összefoglalva alkalommal 10 0.
Ez értelmetlen.
Akkor mit jelent ez csinálni?
Diák: [hallható].
>> DAVIN: Meg fog fordulni, hogy karakter egy egész szám, ugye?
Ez olyan, mint az Ön probléma set-- ez light--
ez olyan, mint a probléma állítva Visioneer.
Te foglalkozó ASCII értékeket.
Tehát, ha adok, mint egy hét, de ez a karakter,
és szeretné tudni, OK, mi az, hogy a számjegy?
Igen, lehetett, igen.
Tehát mi az, hogy a számjegy?
Lehet kivonni 0. belőle, de kell kivonni 0 a karakter.
>> És hol néhány ember kap megbotlott fel, ők
mint, OK, nos, nem tudom, hogy tudja Az ASCII értékei kvíz?
Nem, biztosan nem kell tudni az ASCII
értékek, mint a kisbetűs Egy, nagybetűs A, nulla.
>> ROB: Nincs ok arra, hogy soha hogy ezt a puskát.
>> DAVIN: Határozottan nem pazarolja a helyet ezzel.
Akkor csak literally-- helyette mondván, a 48, mint egészen
van, amely egyenértékű mondván: egy, egy aposztróf,
mint, hogy pontosan ugyanaz.
>> ROB: Azt hiszem, szinte róla, mint if-- Istenem, szükségem van a,
oops-- akkor szinte belegondolok mintha valami ilyesmi hash
határozza meg 0 48.
Ez nem fog működni.
De gondolj rá, mint egy idézet 0 egy idézet, és az összes karaktert.
Gondolj rá úgy, mint egy állandó, amely kijelenti, hogy ASCII értéket.
>> DAVIN: Igen.
OK, így az első alkalom, így A 76-- így először át,
ez csak a karakter 7. mínusz a karakter 0,
és ezek hét integers-- jól, azok
Hét terek távol minden más az ASCII táblázat vagy bármi.
Annak érdekében, hogy ez vissza fog térni egy int 7.
Szóval most, összeg eléri a 7..
>> OK, nos, hadd ugrás ebbe a hurok újra.
OK, most már 10-szer összeg.
Szóval hatékonyan mozog a 7 balra.
Van ennek értelme?
Te hatékonyan mozgatása balra.
>> És akkor ezt add-- lesz 6 mínusz 0-ra.
Ez 6.
Így lesz a 70 plusz 6.
76., hogy a száma.
Tehát függetlenül attól, hogy milyen számot Adtam neked, ez csak lassan
fog váltani a nagyobb érték balra, 1 10-es faktorral
minden alkalommal az a hurok, majd adja hozzá a szükséges.
>> A vissza?
Diák: Nem kell csinálni bármely ellenőrzi a programban?
>> ROB: Tehát amennyire ellenőrzése megy a program,
mi lenne mondani, nagyon sok mit kell ellenőrizni.
Ha nem mondom semmit, akkor általában
Feltételezem, hogy ellenőrizze a legtöbb dolgot.
Mint te is, csak a biztonság kedvéért, akkor kéne ellenőrizni hé, s null?
Aztán fogalmam sincs, mi a visszatérésre.
De azt mondani, ez a fajta dolog.
0, nem tudom.
>> DAVIN: És miért akarnál hogy ellenőrizze, ha s értéke nulla?
Diák: [hallható].
DAVIN: Mivel char csillag.
Ez egy mutató.
Tehát egy tökéletesen elfogadható nyilatkozat, azt is mondhatnám, OK,
s értéke null, mert lehet mutató null.
Tehát, ha van mutatókat a pályát, mint ez,
akkor valószínűleg ellenőrizni.
Mert ha nem ellenőrzi ezt, és akkor majd megy be a hurok,
és te doing-- rohan le.
Rohan le.
>> ROB: Sajnálom, hogy ez az.
>> DAVIN: És így, mint, ha ez null, és akkor
Ehhez mi a hiba Ön fog kapni?
Diák: fogsz kapni egy sor hibát.
DAVIN: Fogsz beállítása hiba, igaz, mert te
próbál index a null.
Szóval megpróbálom index a memóriába, hogy nem saját.
Tehát ez, ha ez nulla, és ezt megteszi, akkor ciklust.
>> ROB: Én is úgy gondolom, a vizsgán, ahol mi feltette ezt a kérdést, azt mondjuk nektek,
hogy ha csak feltételezni ez egy pozitív szám.
Mivel atoi is várható kezelni a negatív számok,
így meg kellett volna speciális eset.
Hé, az első karakter kötőjelet, ebben az esetben, OK,
most ez egy negatív egész szám.
Azt fogja mondani, ezek a dolgot.
Azt fogja mondani, hogy mit kell kezelni.
DAVIN: Igen.
Szóval biztos vagyok benne, egyesek have-- Ha elkezdtem keresgélni a régi vizsgák,
láttad sterln.
Ez egy népszerű ember.
És azt hiszem, sterln, meg kellett Ehhez csekket null, a visszatérés
0 vagy valami ilyesmi.
Mint, meg kellett, hogy ellenőrizze a null.
És ha nem, hogy pont volt ki a kvízt.
Mindegy, nem mindenki úgy érzi, rendben atoi?
Van valaki akar megy át alkatrészeket újra?
ROB: Ó, igen, azt hiszem, azt is megmondja, hogy
Feltételezhetjük, hogy minden ez-- hogy ők valójában szám bevitele,
hogy nem kell aggódnia, mint, hogy a levelek a húr, így.
DAVIN: Igen.
Igen?
DIÁK: Tud megy több mint egy több, amikor
használja idézőjel és aposztróf?
>> DAVIN: Persze, így idézőjelek, nagyon egyszerűen dupla idézőjelek füzér.
Tehát, ha idézőjel semmit, ez egy húr.
Szóval, mint, ha már ez a 0 itt, és én ezt, hogy egy húr.
Ez már nem egy karaktert.
Szóval nem találom ezt az értéket az én ASCII chart, mert egy sor, igen.
>> OK, bármilyen egyéb kérdése?
Igen?
>> DIÁK: Tehát neked van már választ adott erre,
de mint, mikor vagyunk valójában írásban ezt a kvízt,
nem szeretné, hogy írjon vágás nullák [hallható]?
DAVIN: Nem.
A kérdés az volt, kéne hogy egy perjel a nulla
jelzi, ha ők nullák?
Nem fogjuk kitalálni.
Igen, köszönöm, ők jó.
OK, valami mást?
Van valaki akar to-- ezért úgy gondolom, mi már fut egy kis idővel.
Szeretné, hogy egy másik ember, vagy?
STUDENT: RandomInt.
>> DAVIN: RandomInt, OK, pontosan.
Tehát lássuk RandomInt.
Én megteszem itt.
Tehát RandomInt valójában sokkal egyszerűbb.
Azt hiszem, atoi talán a legnehezebb egy hogy már kérte a korábbi években.
Diák: [hallható].
>> DAVIN: Mi?
ROB: látok, ha ez a fajta A megtekinthető itt.
DAVIN: Vajon?
ROB: Én nem hiszem, hogy ez azt hiszem going-- ez fog futni ki a jobb.
DAVIN: OK, úgyhogy én megteszem ezt.
És akkor te csak tedd a képernyőn.
>> ROB: Rendben.
>> DAVIN: Azt akarod, hogy én írástudó?
>> ROB: Igen.
>> DAVIN: Szép.
OK, tudom törölni ezt?
>> Diák: Igen.
>> DAVIN: Ez annyira nehéz.
(Ének) csinálja mit csinálsz.
És mit csinál, ha nem.
Rendben van.
>> OK, ha jól emlékszem, a a teszt a RandomInt volt, mint,
OK, fogok adni a két számokat, mint egy a és a b.
És azt akarom, hogy adjon nekem egy RandomInt között ezek a számok.
Így RandomInt megy hogy két numbers--
így RandomInt-- és ez fog visszatérni egy int.
>> Szóval mi a visszatérési érték?
Most mondtam.
Int, ugye?
Mint ez, és akkor itt megy, hogy két ints.
Így fog tartani int a és b int, ilyesmi.
Tehát mi is RandomInt eredménye, hogy ez lesz
vissza néhány véletlenszerű érték A két érték között.
Szóval ez lesz a nagyobb mint a kevesebb, mint b.
Szóval azt hiszem, talán feltételezhetjük, hogy Egy pont a kisebb a két érték.
Tehát, ha van dolgunk véletlenszerű, hogy milyen funkciót
láttunk, hogy a ad random dolgokat?
STUDENT: Drand.
DAVIN: Drand, pontosan.
Szóval lesz valószínűleg szeretné használni a drand.
Szóval lehet mondani int véletlen, és mi Csak azt mondják, hogy értéke 0 most.
És ők fogunk mondani, OK, random egyenlő drand 48.
És mit jelent ez vissza?
Mit jelent ez a funkciót adni?
>> Diák: 0 és 1.
>> DAVIN: Igen, 0 és 1 között.
Így fog be--
>> ROB: És azt hiszem ez-- mi lenne mondani.
Mint használhatja drand 48.
Ezt úgy ellenőrizheti a múlt vizsga.
De azt mondod, hogy talán Használhatja drand 48, amely
visszaad egy úszó 0 és 1 közötti.
>> DAVIN: Igen, igen, én vagyok benne a vizsgán
azt mondja, valószínűleg szeretné használni drand, igen.
Szóval ez fog visszatérni bizonyos érték 0 és 1 között.
És akkor te mi vagy szeretne majd csinálni?
Nos, azt szeretnénk, hogy sokszorozza meg by-- várj, azt hiszem, ez olyan, mint ez, sajnálom.
Én csak ezt.
Nem tudom.
>> Így b mínusz.
Akkor miért b mínusz?
Tehát mondjuk drand ad vissza egy int-- OK, én csak a többit,
így plusz egy.
Tehát mi does-- y b mínusz egy.
Tehát mondjuk, hogy drand ad vissza a maximális érték, esetleg
kapsz.
Mi az, hogy lesz?
STUDENT: 1.
>> DAVIN: 1, ugye?
Szóval, ha ez az 1., és te szorzással b mínusz egy,
nos, ez csak a közötti különbség mínusz A.
És ha majd adjunk hozzá, hogy a vissza rá egy, ez az, amit?
Ez alapvetően b.
Van ennek értelme?
>> Diák: Igen.
>> DAVIN: Szóval, ha ez a maximum érték, esetleg lehet,
ez lesz az 1..
És akkor ez még csak a különbség a kettő között.
Hozzáadása egy, így ez fog visszatérni véletlen.
És a sarokban esetben, drand ad vissza 1,
véletlen majd csak a ténylegesen b.
De ez a maximum lehet.
Tehát, ha ez kevesebb lesz, mint a hogy így mondjuk, hogy ez olyan, mint 0,9,
így akkor 0,9-szer b mínusz egy lesz kevésbé
mint a különbség mínusz a b.
>> És akkor, ha hozzáteszem, hogy be egy, akkor ez az érték
lesz nagyobb, mint egy, mert te hozzá valamit rá,
de ez kevesebb lesz, mint a b.
Szóval megy, hogy a véletlen szám, mert hívsz drand.
És ez rand, hogy véletlen szám lesz valahol a kettő között a
és b.
Van ennek értelme?
>> ROB: Csak tedd a konkrét számokat, így
mondjuk szeretnénk felvenni a véletlen szám 7 és 10 közötti.
Így b mínusz egy a kínálatunkban.
Így van egy sor három számokat akarunk választani.
És akkor szorozni hogy 0 és 1 1,
ha ez akkor ad nekünk some-- mondjuk, hogy ad 1.5.
>> Ezután 1,5, szeretnénk menni 7 és 10.
Így 1,5 és 7 bennünket vissza a 7 és 10 tartományban.
És akkor mi tárolás belsejében egy egész szám, így csonkítva le 8.
És akkor már csak vissza, hogy a.
Így b mínusz egy a kínálatunkban.
Egy tolódik fel a számokat hogy akarunk e tartományon belül.
Így 7 és 10 közötti, és aztán visszatérhet, amit a végén.
>> DAVIN: Igen, szép.
>> ROB: Köszönöm.
>> DAVIN: Igen, mi a helyzet?
>> Tanítvány: rohanunk, hogy bármilyen ASCII hibák we're-- ha drand van
vissza a float [hallható].
>> ROB: Szóval, mint Rob azt mondta, mert véletlen nem int,
így drand lesz úszó.
Így aztán megsokszorozza ki.
És lehet, hogy néhány fajta úszó számok.
És akkor ez meg fog vágjon.
>> STUDENT: OK.
DAVIN: Igen.
ROB: És ha a fordító volt, hogy figyelmeztesse Önt, mint veszteség pontosság,
csak dobott egy int ott, és akkor jó.
DAVIN: Igen?
>> Diák: lenne-e a azonos valószínűséggel szerzés,
mint b vagy a [hallható]?
>> ROB: Szóval ez-- vagyok valójában wondering-- az RandomInt feltételezett
hogy egy szám a kevesebb, mint b?
Mint, ha ez a 7 és 10, mik a lehetőségek?
7., 8., és 9., vagy 7, 8, 9, 10?
DAVIN: elfelejtem.
A probléma set--
>> ROB: Azt hiszem, a 7., 8., 9..
>> DAVIN: Ez konkrétan azt mondja, az ember befogadó és egy exkluzív.
>> ROB: Igen.
>> DAVIN: De én vagyok nem-- nem--
>> ROB: Szóval azt hiszem, ezek nem szerepel, ebben az esetben,
van egy egyenlő valószínűsége 7., 8., és 9..
Nincs valószínűsége 10.
DAVIN: Igen?
Diák: Van egy kérdésem.
Azt akarjuk, hogy határozza meg a függvény vissza nem egyetlen érték, hanem egy tömb.
Akkor mi lenne a szintaxis után vissza?
>> DAVIN: OK, így akkor would-- után visszatérés?
Tehát mondjuk nyilvánította tömb valahol odafent.
Akkor is csak vissza a tömb nevét.
>> Diák: OK, köszönöm.
Akkor csak vissza az a--
DAVIN: Ó, várj, annyira sajnálom.
A kérdés az volt, hogy Mit tömböt ad vissza.
>> ROB: Bár nem tudta kell egy tömb nyilvánítani
a verem, vagy ilyesmi.
Úgy kellene, hogy legyen valami malloced, mert malloc
az, hogy hogyan lehet megkerülni automatikus memória kiosztás.
>> DAVIN: Igen.
ROB: Hogyan kap körül helyi körét.
>> DAVIN: de azt csak vissza a name--
>> Diák: [hallható] ez nem egy érték, például, két szám, így
[Hallható].
>> DAVIN: nem lehet visszatérni a több szám.
Nem lehet, mint, return--
>> Diák: beszéltem visszatérő tömb vagy valami ilyesmi.
>> DAVIN: Igen, így az a kérdés, tudok vissza több értéket.
Nem lehet visszatérni több értéket.
Nem lehet, mint, majd vissza vissza b vagy valami ilyesmi.
Mert miután visszatér, akkor vissza ki a funkciót.
És akkor a függvény történik, és mint Rob azt mondta, a verem.
>> Tehát minden, ami a memória egyre csak visszatért a számítógéphez.
Mindent elfelejtett lesz, alapvetően.
Tehát, ha vissza akar térni a több értékeket, akkor vissza kell térnie egy tömb,
És ahogy ezt ez mallocing.
És akkor vissza fog térni x ilyesmi.
Alapvetően, ha csak vissza a nevét.
És ha visszatér valami ilyesmi, akkor
valójában nem vissza az értéket.
>> Tehát mondjuk a tárolt Az értékeket egy tömbben.
Te valójában nem visszatérő ezeket az értékeket.
Mint, ha én vissza int, én vagyok tényleg visszatérő példányban az értékeket.
De ha én is vissza valami, mint ez,
Én visszatérő hivatkozás hogy ezeket az értékeket.
Szóval visszatérve, alapvetően a memóriacím az értékeket.
Van ennek értelme?
Diák: Igen.
DAVIN: Szép.
Igen?
>> DIÁK: Ha a drand ide,
Mit kell tenni srand előtt?
>> DAVIN: Nem, nem, én nem hiszem.
>> ROB: Igen, így van- mondani semmit srand?
Az alapértelmezett soha nem mondja srand egyáltalán az, hogy csak nem srand nulla.
Így drand saját akaratát munkáját.
És ez automatikusan a vetőmag az aktuális idő, amit használ.
DAVIN: Igen?
Tanítvány: [hallható] a számok?
DAVIN: Igen, akkor.
DIÁK: így lehet mondani, mint, 4-szer 2.
Az a helyzet, akkor nem vállal akkor egy int négy bájt.
A only--
>> DAVIN: Úgy értem, hogy a teszt csak tudsz.
[Nevet]
>> ROB: Mm, nem.
DAVIN: Igen, igen, igen.
Ha kérdezni, hogy milyen nagy is int, akkor nem lehet, mint négy vagy nyolc.
ROB: Ó, így ha a kérdés kifejezetten,
mint például, ha ez egy kódolási probléma, meg kell mondani méretű int.
Ha ez egy táblázat, vagy azt mondja, hogy hány bájt,
ne töltse ki méretének ints.
>> DIÁKOK: [nevet]
>> DAVIN: Jobb, vajon miért mérete int fontos itt?
Szóval, mint, ha mi megyünk a 32 bites processzor, vagy valami ilyesmi,
akkor lesz négy bájt.
De a néhány újabb dolog, lehet, hogy mi?
Ez lehet nyolc, ugye?
Tehát, ha csak this-- kemény kód négy, majd néhány gép, működni fog.
Egyes gépek, nem fog működni.
De ha a teszt vagyunk mint mekkora egy int?
Tedd a négy.
ROB: Így van.
DAVIN: Igen?
Diák: Így, mivel mi nyilvánításáról [Hallható] egy függvényen belül,
kellene tenni, hogy a 3 belső funkció?
Vagy tudjuk használni ezen kívül?
DAVIN: Használhatja kívül ezt a funkciót.
Szóval ő kér ingyen.
>> Diák: Lose pálya hol [hallható].
>> ROB: Ó, az nem szabad happen-- ez is része a varázsa malloc
az, hogy te nem korlátozott helyi hatályát.
Önnek teljes mértékben ellenőrzése alatt milyen hosszú a változók él.
Így hívjuk malloc itt, talán egy teljesen külön funkció.
Lehet, hogy 10 óra múlva hogy végre hívás ingyenes.
>> DAVIN: Így például, mint egy pár hét múlva, amikor végre
nem a szótár helyesírás psets, mész
hogy néhány funkciót, amely teremt tonna csomópontok.
Szóval mallocing tonna A csomópontok ebben a funkcióban.
Aztán később a külön funkció, te
szeretne majd felszabadítani valamennyi csomópont.
Így szó szerint csak át szabad a mutató, így a memória cím
hogy mit malloced.
És ez rendben lesz.
Nem kell a szabad, hasonlók, ugyanazt a funkciót.
Igen?
>> DIÁK: Tehát a malloc változó [hallható] kívül?
Ez az, amit mondasz?
DAVIN: Várj, azt mondják, hogy?
Bocsánat.
>> Diák: Ha a malloc változó lehet szabadon bárhol a kódot,
akkor lehet őket elérhetők bárhol a kódot?
Meg tudja tartani azokat a helyi?
>> DAVIN: Ó, azt kérdezte, mint a változó, like--
>> ROB: Szóval még mindig szükség van, hogy van valamilyen referencia
A malloc blokk memória.
Tehát itt, mi visszatérő x.
STUDENT: Oh.
ROB: Ha nem vissza x itt, és ez még csak semmis,
akkor nem lenne hozzáférése a mutató, amit malloced,
és ez kiszivárgott memória.
>> STUDENT: OK.
>> DAVIN: Szóval, mint, mondjuk, ezt, mint itt.
ROB: Nem.
DAVIN: Az én fő funkciója, nem tudom csak hívja ezt x, és, mint, OK,
ebben a funkcióban, tettem ezt.
>> ROB: Így van.
>> DAVIN: Így fogok hívni x, mint fő, vagy valami ilyesmi.
Ezt nem tehetem.
Fogsz vissza valamit.
De mit fog visszatérni?
Fogsz visszatérni a memória cím.
És azért, mert visszatér a memória cím, hogy lehet elérni máshol.
Még kérdése?
Igen?
>> DIÁK: A függvény fenti leellenőrzik az [hallható]?
>> DAVIN: Miért nem kell csinálni?
Diák: [hallható].
DAVIN: Mert Nem mallocing semmit.
Szóval ez nem-- igen, ez Nem olyan, mint egy húr s.
Ez egy mutató valahol.
Ezek csak értékeket.
STUDENT: OK.
DAVIN: Igen.
Bármi más?
ROB: Igen?
DIÁK: De ha [hallható]?
>> ROB: Tehát annak érdekében, hogy a szabad memória, mi lenne mondjuk itt.
Tehát x a mutató a a blokk memória.
Azt, hogy a szabad mutató.
És nem feltétlenül csinálni itt.
Meg tudod csinálni bárhol.
De csak a hívás ingyen amit malloc visszatér.
Tehát malloc, itt, visszatért mit tárolnak x.
Így tudjuk hívni ingyenes x.
Minden az utolsó kérdés?
>> DAVIN: Minden utolsó kérdése?
Igen?
>> Diák: Sajnálom, meg tudja magyarázni újra miért lenne szabad ott?
Miért [nem hallható]?
>> DAVIN: Mert itt?
>> Diák: Igen, mint után.
DAVIN: Valószínűleg nem akar szabad itt.
ROB: Valószínűleg nem.
DAVIN: Igen, ez nem csinál semmit.
Ez, mint, teremt memória, csinálni dolgokat, hogy azt,
majd azonnal felejtsd el, igen.
>> ROB: De talán nem, mint, itt valamilyen okból.
Azt mondhatnánk int csillag y egyenlő return array.
Van néhány dolog az y, talán nyomtassa ki a tartalmát.
És akkor végül, végünk.
Mi lehet szabad y.
Diák: [hallható].
DAVIN: Kell lépjünk le?
Köszönöm.
ROB: Szép.
>> DAVIN: OK, ez az.
ROB: Rendben, jó.
Sok szerencsét.
>> DAVIN: Ha kérdése van, írjon nekünk.
Sok szerencsét.