[Powered by Google Translate] [Review] [Quiz 0]
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvard Egyetem]
>> [Ez a CS50.] [CS50.TV]
>> Hé, mindenki.
Üdvözöljük a felülvizsgálati ülésen Quiz 0, ami zajlik e szerdán.
Mit fogunk csinálni ma este, én vagyok a 3 másik TF,
és együtt fogunk átmenni felülvizsgálatát mit tettünk folyamán eddig.
Ez nem lesz 100%-os átfogó, de meg kell adni egy jobb ötletem
, amit már le, és mit is kell tanulni, mielőtt szerdán.
És bátran emelje fel a kezét kérdések megyünk végig,
de ne feledje, hogy mi is van egy kis idő a végén
ha átjutni egy pár percet, hogy tartalék-to do általános kérdések,
úgy, hogy tartsa szem előtt, és így fogunk kezdeni az elején a 0. héten.
>> [Kvíz 0 Review!] [Part 0] [Lexi Ross] De mielőtt ezt tesszük beszéljünk
A logisztika a kvíz.
>> [Logistics] [Quiz kerül sor, szerdán 10/10 helyett Előadás]
>> [(Lásd http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf részletek)] Ez a szerda, október 10.
>> Ez szerdán, és ha megy az URL itt,
amely szintén elérhető a CS50.net-Van egy linket it-
látható információkat hol alapuló
Az utolsó név vagy az iskola helye, valamint a
azt mondja, hogy pontosan mi a kvíz fedezi, és a fajta kérdés, hogy fogsz kapni.
Ne feledje, hogy akkor is van esélye, hogy vizsgálja felül a kvíz szakaszban,
így a TF kell megy át néhány gyakorlatot problémák,
és ez egy jó esély arra, hogy hol is kell tanulni fel a kvíz.
Kezdjük az elején a Bits 'n' Bytes.
Ne feledje, egy kicsit csak 0 vagy 1,
és egy byte van egy gyűjtemény a 8 e bit.
Nézzük meg ezt a gyűjteményt bitek itt.
Meg kell tudnia, hogy kitaláljuk, hogy hány bit van.
Ahol számít ott csak 8 közülük nyolc 0 vagy 1 db.
És mivel ott van 8 bit, ez 1 byte,
és menjünk átalakítani, hogy hexadecimális.
Hexadecimális a 16 alap, és ez elég könnyű konvertálni
egy számot bináris, ami, hogy mi az, hogy egy számot hexadecimális.
Minden, amit tennie nézzük csoportok 4,
, és átalakítani őket, hogy a megfelelő hexadecimális számjegyet.
Kezdjük a jobb szélső csoport 4, így a 0011.
Ez lesz egy 1 és egy 2, így együtt, ami 3.
És akkor nézzük meg a többi blokk a 4.
1101. Ez lesz az egyik 1, egy 4 és egy 8.
Együtt ez lesz 13, ami D.
És akkor ne feledjük, hogy a hexadecimális mi nem csak go 0 és 9 között.
Mi megy 0-tól F, így azután 9, 10 felel meg,
11 B, satöbbi ahol F 15.
Itt 13 jelentése D,
úgy átalakítani, hogy a tizedes minden, amit tennie, hogy mi valójában
kezelik minden egyes pozíció, mint a hatalom a 2.
Ez egy 1, egy 2, nulla 4s, 8s nulla, egy 16, et cetera,
és ez egy kicsit nehéz, hogy kiszámolja a fejedben, de ha megyünk a következő diára
láthatjuk a választ.
>> Lényegében megyünk át jobbról balra vissza,
és mi megszorozzuk az egyes számjegy a megfelelő 2-hatvány.
És ne feledd, a hexadecimális mi jelöljük ezeket a számokat 0x elején
így nem keverjük össze, hogy egy decimális szám.
Folytatva, ez egy ASCII táblázat,
és mire használjuk az ASCII hogy térképet karakterek numerikus értékek.
Ne feledje, a kriptográfia Pset tettünk széles körben használják az ASCII táblázat
annak érdekében, hogy használjon különféle módszereket kriptográfia,
A Caesar és a Vigenère titkosítást, átalakítására, különböző betűk
egy string szerint a kulcs a felhasználó által megadott.
Nézzünk egy kicsit ASCII matek.
Keresi a 'P' + 1, jellegű formában lenne Q,
és ne feledjük, hogy '5 '≠ 5.
És pontosan hogyan tudnánk konvertálni között 2 nyomtatványok?
Ez valójában nem túl nehéz.
Annak érdekében, hogy 5 levonjuk '0 '
mert van 5 hely a '0 'és az '5.'
Annak érdekében, hogy menj a másik irányba már csak hozzá a 0,
így ez a fajta, mint a rendszeres számtani.
Ne feledd, hogy ha valami van idézőjelek körül ez a karakter
és így értéknek felel meg az ASCII táblázatban.
Költözünk általános számítógép-tudomány témák.
Megtanultuk, mi az az algoritmus, és hogyan használjuk programozás
végrehajtására algoritmusok.
Néhány példa az algoritmusok valami igazán egyszerű, mint
annak ellenőrzése, hogy a szám páros vagy páratlan.
Erre emlékszem, mod a számot 2 és ellenőrizze, hogy az eredmény 0.
Ha igen, ez még. Ha nem, ez furcsa.
És ez egy példa egy nagyon alap algoritmus.
>> Egy kicsit a nagyobb részt az egyik bináris keresés,
amely megyünk át később a felülvizsgálat során.
És a programozás a kifejezést használja az olyan algoritmust
és átkonvertálja a kódot a számítógép olvasni.
2 példát programozás Scratch,
amit mi tette Hét 0.
Annak ellenére, hogy valójában nem írja ki a kódot, ez egy módja a végrehajtási
ezt az algoritmust, amely kinyomtatja a számok 1-10,
és itt nem ugyanaz a C programozási nyelv.
Ezek funkcionálisan egyenértékű, csak írt különböző nyelveken, vagy szintaxist.
Ezután értesült boolean kifejezéseket,
és egy boolean olyan érték, hogy ez igaz vagy hamis,
és itt sokszor logikai kifejezések
bemenni a feltételek, így ha (x ≤ 5),
nos, már meg x = 5, tehát ez a feltétel fogja értékelni, hogy igaz.
És ha ez igaz, bármi kód alatt a feltétel
fogja értékelni kell a számítógép, így húr fog nyomtatni
a szabványos kimenetre, és a kifejezés feltétel
utal, amit a zárójelben az if.
Ne feledje, a piaci szereplők.
Ne feledd, hogy a && és | | amikor próbálunk össze 2 vagy több feltételt,
== Nem = ellenőrizni, hogy 2 dolgot egyenlő.
Ne feledje, hogy = Az hozzárendelés mivel == egy logikai operátort.
≤, ≥ majd az utolsó 2 magától értetődő.
Az általános felülvizsgálatát boolean logika itt.
És boolean kifejezések is fontos hurkok,
amely megyünk át most.
Megismertük 3 típusú hurkok eddigi CS50, for, while, és nem kicsit.
És ez fontos tudni, hogy míg a legtöbb célra
tudjuk ténylegesen használni bármilyen típusú hurok általában
vannak bizonyos célra, vagy közös mintákat
programozás, amelyek kifejezetten szükségessé egy ilyen hurok
hogy hogy ez a leghatékonyabb vagy elegáns kódolni azt az említett módon.
Menjünk át mi minden egyes ilyen hurkok általában használt leggyakrabban.
>> A for ciklus általában azt már tudjuk, hogy hányszor akarjuk navigálhat.
Ez az, amit teszünk a feltételt.
A, i = 0, i <10, például.
Azt már tudjuk, hogy tenni akarnak valamit 10-szer.
Most egy darabig hurok, általában nem feltétlenül
tudom, hányszor szeretnénk a hurkot futtatni.
De tudjuk, hogy valamilyen feltétellel, hogy azt akarjuk, hogy
mindig igaz, vagy mindig hamis.
Például, míg a be van állítva.
Tegyük fel, hogy ez egy logikai változó.
Bár ez igaz akarjuk a kódot, hogy értékelje,
így egy kicsit jobban bővíthető, egy kicsit általánosabb, mint a for ciklus,
de bármely a hurok is átalakíthatók a közben hurok.
Végül, do while ciklusok, amely lehet a legnehezebb megérteni azonnal,
gyakran használják, ha azt akarjuk, hogy értékelje az első megfelelő kód
mielőtt az első alkalom, hogy ellenőrizze az állapotát.
Közös használata esetén egy do while
amikor azt szeretnénk, hogy felhasználói, és tudod, azt szeretnénk, hogy felkéri a felhasználót,
a bemeneti legalább egyszer, de ha nem adnak Önnek jó input azonnal
meg akarja tartani kérve őket, amíg el nem adja meg a helyes bemenet.
Ez a leggyakoribb használata nem while ciklus,
és nézzük meg a tényleges szerkezetét e hurkok.
Ezek jellemzően mindig hajlamosak követni ezeket a mintákat.
>> A for ciklus belsejében van 3 részből áll:
inicializálás, jellemzően valami hasonlót int i = 0, ahol i a számláló,
állapot, ahol szeretnénk mondani futtatni ezt a for ciklus, amíg ez az állapot még fennáll,
mint i <10, és végül, frissítés, amely hogyan növelni
a számláló változót minden ponton a hurok.
A közös dolog, hogy ott is csak i + +,
ami azt jelenti, növeljük i 1-jéig minden alkalommal.
Te is valami ilyesmit i + = 2,
ami azt jelenti, adjunk hozzá 2-i minden egyes alkalommal, amikor átmegy a hurok.
És akkor az ezt csak kifejezés bármely olyan kód, amely ténylegesen fut részeként a hurok.
És egy ideig hurok, ezúttal ténylegesen az inicializálás kívül a hurok,
így például, mondjuk mi próbálunk tenni az azonos típusú hurok, ahogy csak le.
Azt mondanám, int i = 0, mielőtt a ciklus kezdődik.
Akkor mondhatnánk, míg én <10 Ehhez,
így ugyanazt a blokk-kód, mint korábban,
és ezúttal a frissítés része a kód, például, i + +,
valóban megy belsejében a hurok.
És végül, egy do while, ez hasonló a while ciklus,
de meg kell emlékezni, hogy a kód értékelni fogja, ha
mielőtt a feltétel meg van jelölve, így teszi sokkal több értelme
ha nézzük sorrendjében fentről lefelé.
A do while ciklus a kódot, értékeli, mielőtt még nézd meg a közben feltétel,
mivel a while ciklus, ellenőrzi először.
Nyilatkozatok és változókat.
Ha azt akarjuk, hogy hozzon létre egy új változót először szeretnénk inicializálni azt.
>> Például, int bar inicializálja a változót bár,
de nem adja meg egy értéket, akkor mi van bár értékét most?
Nem tudjuk.
Lehet, hogy valami szemetet értéket, amelyet korábban a memóriában tárolt ott,
és nem akarjuk használni, hogy a változó
amíg mi valójában, hogy ez egy érték,
így állapítsa meg itt.
Aztán inicializálni, hogy legyen 42 alatt.
Most, persze, tudjuk, hogy ez lehet tenni egy sorban, int bar = 42.
De csak, hogy törölje a több lépésben folynak,
a nyilatkozatot és az inicializáló történnek külön van.
Ez történik egy lépés, és a következő egy, int baz = bar + 1,
ez a kijelentés alatt, hogy a BAZ lépésekben, így a végén ezt a kódot mondat
ha volt, hogy nyomtassa ki az értékét BAZ lenne 44
mert nyilvánítja és inicializálni legyenek az 1> bar,
és akkor mi megnöveljük még egyszer a + +.
Mentünk át ezt a szép röviden, de jó, hogy van egy általános
megértésének szálak és események.
Mi elsősorban tette ezt Scratch,
így gondolja, a szálak a többszörös szekvenciák kód
fut egyszerre.
A valóságban valószínűleg nem fut egyszerre,
hanem valami elvont tudjuk gondolni rá ilyen módon.
>> A Scratch, például, mi volt a több sprite.
Meg lehetne végrehajtó különböző kód egy időben.
Az egyik lehet gyaloglás, míg a másik mond valamit
egy másik részén a képernyőn.
Az események másik módja különválasztja a logikai
különböző elemei a kódot,
és a Scratch tudtuk szimulálni események a Broadcast,
és ez tulajdonképpen Mikor kapom, nem amikor hallom,
de lényegében ez egy módja annak, hogy az információ átadása
egyik sprite a másik.
Például érdemes lehet továbbítani vége a játéknak,
és ha egy másik sprite kap game over,
válaszol egy bizonyos módon.
Ez egy fontos modell, hogy megértsék a programozáshoz.
Csak, hogy menjen át az alap 0. héten, amit mi már ment át eddig,
nézzük meg ezt az egyszerű C program.
A szöveg lehet egy kicsit kicsi innen, de megyek rajta igazán gyors.
Mi ilyenek például a 2 header fájlokat a tetején, és cs50.h stdio.h.
Mi majd meghatározó állandó nevű határérték 100 fő.
Mi majd végrehajtása a fő funkciója.
Mivel mi nem használjuk parancssori argumentumok itt kell tenni void
az érvek fő.
Látjuk int fent fő. Ez a visszatérési típusa, ezért vissza 0 alján.
És mi a CS50 könyvtári funkciót kap int
hogy felkéri a felhasználót a bemeneti, és tárolja ezt a változót x,
így állapítsa x fent, és inicializálja azt x = getInt.
>> Ezután ellenőrizze, hogy ha a felhasználó adott nekünk jó bemenet.
Ha ez ≥ LIMIT szeretnénk visszatérni hibakód 1 és nyomtassa ki egy hibaüzenetet.
És végül, ha a felhasználó által adott nekünk jó bemenet
megyünk tér a számot, és nyomtassa ki az eredményt.
Csak, hogy győződjön meg arról, hogy ezek minden hit otthon
láthatjuk a címkéket különböző részei a kód itt.
Már említettem állandó header fájlokat.
Oh, int x. Ügyeljen arra, hogy ne feledje, hogy ez egy lokális változó.
Ez ellentétben ez egy globális változó, amely fogunk beszélni
Egy kicsit később a felülvizsgálat ülésen,
és mi hív a könyvtár printf függvény,
tehát ha nem tartalmazza a stdio.h header file
akkor nem lesz képes hívni printf.
És azt hiszem, a nyilat, hogy van vágva itt rámutatni, hogy a% d,
amely formázási string printf.
Azt mondja, nyomtassa ki ezt a változót, mint egy szám,% d.
És ez azt Week 0.
Most Lucas fog folytatni.
Hé, srácok. A nevem Lucas.
Vagyok másodéves a legjobb ház a kampuszon, Mather,
és fogok beszélni egy kicsit hét 1 és 2,1.
[Hét 1 és 2,1!] [Lucas Freitas]
Ahogy Lexi mondtam, amikor elkezdtük fordítani a kódot a Scratch-C
az egyik dolog, amit észrevettem, hogy nem lehet csak a
írjuk meg a kódot, és futtatni egy zöld zászló többé.
Igazából, meg kell használni néhány lépést, hogy a C program
válik egy futtatható fájl.
Alapvetően mit csinálsz, ha írsz egy programot, hogy a
Ön lefordítani a te ötleted egy nyelvet, hogy a fordító tudja megérteni,
így amikor írsz egy programot C
mit csinálsz valójában ír valamit, hogy a fordító fog megérteni,
majd a fordító fogja fordítani, hogy a kódex
valami, hogy a számítógép meg fogja érteni.
>> És a dolog, a számítógép valójában nagyon buta.
A számítógép csak megértsék 0s és 1s,
így valójában az első számítógépek az emberek általában programozott
használatával 0s és 1s, de már nem, hála Istennek.
Nem kell megjegyeznie a szekvenciákat 0s és 1s
egy for ciklus vagy egy ideig hurok és így tovább.
Ezért van egy fordító.
Milyen fordító csinál, alapvetően átalakítja a C kód,
a mi esetünkben, hogy egy nyelvet, hogy a számítógép meg fogja érteni,
amely a tárgykód, és a fordító, hogy mi a
hívják csenget, így ez valójában a szimbólum csenget.
Amikor a program, nem kell mást tennie 2 dolog.
Először is, meg kell fordítani a programot, és akkor fogod futtatni a programot.
Ha le szeretnéd fordítani a programot, hogy van egy csomó lehetőség erre.
Az első az, hogy nem csenget program.c
amely program a neve a program.
Ebben az esetben láthatjuk ők csak azt mondom: "Hé, lefordítja a programot."
Ugye nem azt mondja: "Azt akarom, ezt a nevet a program", vagy ilyesmi.
>> A második opció ad egy nevet a program.
Azt lehet mondani, csengés-o, majd a kívánt nevet
a futtatható fájlt nevezzük majd program.c.
És akkor is megcsináljuk program, és látom, hogy az első 2 esetben
Tettem. C, és a harmadik, akit csak a programok?
Igen, tényleg nem kellene. C használatakor tenni.
Ellenkező esetben a fordító valóban fog kiabálni veled.
És azt is, nem tudom, ha a srácok emlékszel,
de sokszor mi is használták-lcs50 vagy-lm.
Ezt hívják össze.
Csak mondja a fordító fogja használni ezeket a könyvtárak ott,
így ha szeretnénk használni cs50.h valóban kell beírni
zengés program.c-lcs50.
Ha nem teszed, a fordító nem fog tudni
hogy az Ön által használt e funkciók cs50.h.
És ha szeretné futtatni a programot, van 2 lehetőség.
Ha nem csenget program.c Ön nem adott nevet a program.
Meg kell futtatni a. / A.out.
A.out egy szabványos név csenget ad a program, ha nem adja meg a nevet.
Egyébként fogsz tenni. / Programot, ha adott egy nevet a program,
és akkor is, ha te make programot a név egy program fog kapni
már megy programozható ugyanazt a nevet, mint a c fájlt.
Aztán beszéltünk adattípusok és adatok.
>> Alapvetően adattípusok ugyanaz, mint a kis dobozok az általuk használt
tárolni értékek, így adattípusok ténylegesen mint pokemons.
Jönnek minden méretben és típusban.
Nem tudom, ha ez analógia értelme.
Az adat mérete valójában függ a gépen architektúrára.
Minden adat méretek fogok mutatni itt
valójában a 32-bites gép, ez a helyzet a mi készülék,
de ha valóban kódolás a Mac vagy a Windows is
Valószínűleg fogsz egy 64-bites gép,
úgy emlékszem, hogy az adatok méretek fogok mutatni itt
vannak a 32-bites gép.
Az első az, hogy láttunk egy int,
ami elég egyértelmű.
Ön használja int tárolni egy egész.
Azt is látta, hogy a karakter, a karakter.
Ha szeretné használni egy levelet vagy egy kis jel, amit valószínűleg fogja használni a kar.
A char van 1 byte, ami azt jelenti, 8 bit, mint Lexi mondta.
Alapvetően van egy ASCII táblázat, amely 256
lehetséges kombinációját 0s és 1s,
majd amikor egy char ez lesz lefordítani
A karaktert bemenetek egy szám van az ASCII tábla, mint Lexi mondta.
Mi is az úszót, amit használ, hogy tárolja decimális számokat.
Ha szeretné választani 3,14, például fogod használni float
vagy kettős, amely több pontossággal.
Az úszó a 4 bájt.
A kettős már 8 bájt, így az egyetlen különbség a pontosság.
Mi is van egy hosszú, hogy használnak egész szám,
és láthatjuk a 32-bites gép int és egy hosszú azonos méretű,
így nem igazán van értelme használni a hosszú 32-bites gép.
>> De ha egy Mac és 64-bites gép, valójában egy hosszú van 8-as méret,
így valójában attól függ, az építészet.
A 32-bites gépen nincs értelme, hogy egy hosszú igazán.
És azután egy hosszú, hosszú, a másik viszont már 8 bájt,
ezért nagyon jó, ha azt szeretnénk, hogy egy hosszabb egész.
És végül, van húr, ami valójában a char *,
amely egy mutató char.
Nagyon könnyű azt gondolni, hogy a méret a string lesz, mint
karakterek számát, hogy van ott,
de valójában a char * maga
van akkora, mint egy mutató egy char, ami 4 bájt.
Akkora, mint egy char * 4 bájt.
Nem számít, ha van egy kis szó vagy írni, vagy ilyesmi.
Ez lesz 4 bájt.
Azt is megtanultam egy kicsit casting,
így láthatja, ha, például, egy program, amely azt mondja,
int x = 3, majd printf ("% d", x / 2)
nem tudjátok, mit fog nyomtatni a képernyőn?
>> Valaki? >> [Students] 2.
1. >> 1, igen.
Ha ezt 3/2 ez lesz, hogy 1,5,
de mivel mi használ integer ez lesz figyelmen kívül hagyni a tizedes rész,
és mész van 1.
Ha nem akarja, hogy megtörténjen, mit lehet tenni, például,
A nyilvánítja a float y = x.
Ekkor x, hogy régen 3 most lesz 3,000 y.
És akkor kinyomtathatja a y / 2.
Igazából kellett volna a 2. ott.
Ez fog tenni 3.00/2.00,
és fogsz kapni 1.5.
És mi van a .2 f csak kérni, 2 tizedes egység a tizedes rész.
Ha van .3 f ez megy, hogy ténylegesen 1.500.
Ha ez 2, akkor lesz 1.50.
Mi is ez a helyzet.
Ha nem float x = 3,14 és akkor printf x
fogsz kapni 3.14.
És ha x = int x,
ami azt jelenti, x kezelik, mint egy int, és a nyomtatás x most
mész, hogy a 3,00.
Van ennek értelme?
Mert először kezeljék x egészként, szóval figyelmen kívül hagyja a tizedes rész,
majd te nyomtatás x.
És végül, akkor is ezt,
int x = 65, és akkor nyilvánítja a char c = x,
majd ha kinyomtatja a c te tényleg fog kapni
Az, hogy alapvetően mit csinálsz itt
A fordításának értéke a karakter,
csakúgy, mint az ASCII táblázat nem.
Mi is beszéltünk matematikai operátorok.
Legtöbbjük nagyon egyszerű, így a +, -, *, /,
és mi is beszélgettünk mod, amely a fennmaradó egy részlege 2 szám.
Ha a 10%-ot 3, például,
ez azt jelenti, osztani 10-3, és mi a maradék?
Ez lesz 1, tehát ez valóban nagyon hasznos, sok a programokat.
A Vigenère Caesar és biztos vagyok benne, hogy minden ti használt mod.
A matematikai operátorok, legyen nagyon óvatos, amikor kombinálja * és /.
>> Például, ha nem (3/2) * 2 mit fog kapni?
[Diákok] 2.
Igen, 2, mert a 3/2 lesz 1,5,
de mivel csinálsz műveletek között 2 egész szám
te tényleg csak úgy, hogy fontolja meg 1,
majd az 1 * 2 lesz 2, ezért legyen nagyon óvatos
amikor egy számtani egészek, mert
lehet hogy kapsz egy 2 = 3, ebben az esetben.
És azt is nagyon óvatos elsőbbséget.
Akkor általában használ zárójeleket kell arról, hogy tudod, mit csinálsz.
Néhány hasznos hivatkozások, persze, az egyik i + + vagy az i + = 1
vagy használ + =.
Ez ugyanaz, mint ennek i = i + 1.
Azt is tudom - vagy i - = 1,
ami ugyanaz, mint i = i -1,
valami srácok használja sokat a hurkok, legalább.
Is, a *, ha használja a * = és ha igen, például,
i * = 2, az ugyanaz, mint a mondás i = i * 2,
és ugyanezt alá.
Ha nem i / = 2 ez ugyanaz, mint i = i / 2.
>> Most körülbelül funkciók.
Srácok, megtudta, hogy a funkciók egy nagyon jó stratégia, hogy mentse-kód
közben programozása, ezért ha azt szeretnénk, hogy végezze el ugyanazt a feladatot
kódot újra és újra, valószínűleg használni kívánt funkció
Csak így nem kell másolni és beilleszteni a kódot újra és újra.
Valójában, a fő egy olyan funkció, és amikor megmutatom a formátum egy függvény
fogod látni, hogy ez elég nyilvánvaló.
Arra is használjuk a funkciók bizonyos könyvtárak,
például printf, GetIn bonyolódik, a CS50 könyvtár,
és egyéb funkciók, mint például toupper.
Az összes említett funkció ténylegesen megvalósított más könyvtárak,
és ha fel azokat hevederrögzítési fájlok elején a program
azt mondod, legyen szíves add meg a kódot ezeket a funkciókat
így nem kell végrehajtani őket magam?
És te is írni a saját funkcióját, így amikor elindítja programozás
rájössz, hogy a könyvtárak nem rendelkeznek az összes funkciót, hogy szükség van.
Az utolsó Pset, például írtunk dolgozzon, tülekedés, és keresési,
és ez nagyon-nagyon fontos, hogy képes legyen írni funkciók
mert hasznos, és mi használjuk őket minden alkalommal a programozás,
és ez ment egy csomó kódot.
A formátum a funkció ez.
Van visszatérési típus az elején. Mi a visszatérési típus?
Csak, ha a funkció megy vissza.
Ha van egy funkció, például a faktoriális,
hogy fog számítani a faktoriálisát egész szám,
Valószínűleg ez lesz, hogy visszatérjen egy egész is.
Ezután a visszatérési típus lesz int.
Printf valójában egy visszatérési típusa void
azért, mert te nem küldött vissza semmit.
Te csak nyomtat dolgokat a képernyőn
és kilépés a funkció utána.
Akkor a nevét a funkció közül választhat.
Meg kell egy kicsit elfogadható, mint a nem, válasszon egy nevet, mint xyz
vagy hasonló x2F.
Próbáld ki, hogy egy nevet, hogy van értelme.
>> Például, ha ez faktoriális, mondjuk faktoriális.
Ha ez a funkció, hogy megy, hogy készítsen valamit, nevezd meg rajzolni.
És akkor mi van a paraméterek, amelyek szintén nevezik érveket,
amelyek olyanok, mint a források, hogy a funkció szüksége
saját kód feladatát elvégezze.
Ha szeretné kiszámítani Egy szám faktoriálisát
Valószínűleg szükség van egy sor kiszámításához faktoriális.
Az egyik érv, hogy te megy, hogy a szám maga.
És akkor fog valamit csinálni, és visszatér az értéket a végén
kivéve, ha ez egy void függvény.
Nézzünk egy példát.
Ha akarok írni egy függvényt, amely összegzi a számokat egy tömbben egész számok,
Először is, a visszatérési típus lesz int
mert van egy sor egészek.
És akkor megyek, ha a függvény neve, mint a sumArray,
és akkor fog tartani magát a tömböt, hogy int nums,
majd a hossza a tömb, így tudom, hány szám van összefoglalni.
Aztán kell inicializálni egy változó hívott összeg, például a 0,
és minden alkalommal látok egy elemet a tömb hozzá kell tennem, hogy összeget, ezért csináltam egy for ciklus.
Ahogy Lexi azt mondta, te int i = 0, i <hossz és az I + +.
És minden egyes elem a tömbben tettem összeg + = nums [i],
és aztán vissza az összeget, így nagyon egyszerű, és ez ment egy csomó kód
ha ezt a funkciót használja sokszor.
Aztán vett egy pillantást a feltételeket.
Van, ha más, és más, ha.
Lássuk, mi a különbség a között.
Vessen egy pillantást a 2 kódok. Mi a különbség a kettő között?
Az első már-alapvetően a kódokat akarom, hogy mondd
ha a szám +, -, vagy 0.
Az első azt mondja, ha ez> 0, akkor ez pozitív.
Ha ez az = 0, akkor ez 0, és ha ez <0, akkor ez negatív.
>> És a másik csinál, ha mást, ha mást.
A különbség a kettő között az, hogy ez a most éppen fog
ellenőrizze,> 0, <0 vagy = 0 háromszor,
így ha a 2-es szám, például ez lesz, hogy jöjjön ide, és mondja
if (x> 0), és ez fogja mondani, hogy igen, úgyhogy nyomtatni pozitív.
De annak ellenére, hogy tudom, hogy ez> 0, és ez nem lesz 0 vagy <0
Én még mindig csinálni ez 0, ez <0,
úgyhogy tényleg lesz benne az IFS, hogy nem kell
mert már tudom, hogy ez nem fog kielégíteni minden ilyen feltételeket.
Tudom használni, ha else if, else utasítás.
Ez alapvetően azt mondja, ha x = 0 I nyomtatása pozitív.
Ha ez nem, megyek is tesztelni ezt.
Ha ez 2 nem fogom ezt tenni.
Alapvetően ha már x = 2, akkor azt mondanám,
if (x> 0), igen, így kinyomtatni.
Most, hogy tudom, hogy ez> 0 és hogy teljesülnek az első, ha
Én nem is fogja futtatni ezt a kódot.
A kód gyorsabban fut, valójában 3-szor gyorsabb, ha ezt használja.
Mi is tanultunk és és vagy.
Én nem megyek át, mert Lexi már beszéltem róluk.
Ez csak a && és | | operátor.
>> Az egyetlen dolog, azt mondom ez legyen óvatos, ha van 3 feltételeket.
Használj zárójeleket, mert ez nagyon zavaró, ha van egy állapot
és egy másik, vagy egy másikat.
Használj zárójeleket, csak hogy biztos, hogy a feltételek értelme
mert ebben az esetben például, el lehet képzelni, hogy a
ez lehet az első feltétel, és egy vagy a másik
vagy a 2 feltételek kombinált egy és
illetve a harmadik, úgyhogy légy óvatos.
És végül, beszélgettünk kapcsolók.
A kapcsoló nagyon hasznos, ha van egy változó.
Tegyük fel, hogy van egy változó, mint n
amely lehet 0, 1, vagy 2, és minden egyes ilyen esetek
fogsz egy feladatot.
Azt lehet mondani, kapcsoljuk be a változó, és azt jelzi, hogy
az érték, akkor olyan, mint érték1 fogom ezt tenni,
és aztán szünet, ami azt jelenti, nem fogom nézni bármely más esetben
mert már meggyőződtek arról, hogy az esetben
majd érték2, és így tovább, és én is egy alapértelmezett kapcsoló.
Ez azt jelenti, ha az nem felel meg olyan esetekben, hogy volt
hogy fogok csinálni valami mást, de ez nem kötelező.
Ennyi nekem. Most vessünk Tommy.
Rendben, ez lesz a héten 3-ish.
Ezek közül néhány a témák fogunk kiterjedő, crypto, hatály, tömbök, satöbbi.
Csak egy gyors szót crypto. Nem megyünk a kalapács e haza.
>> Tettük ezt Pset 2, de a kvíz győződjön meg arról, mi a különbség
között a Caesar titkosítás és a Vigenère titkosítást,
milyen e két titkosítási munka és milyen érzés, hogy titkosítja
és dekódolja szöveget E 2 titkosítást.
Ne feledje, a Caesar titkosítás egyszerűen elfordul minden karaktert az azonos mennyiségű,
ügyelve arra, hogy mod száma betűk az ábécé.
És a Vigenère rejtjel, másrészt, forog az egyes karakterek
egy másik összeget, így ahelyett, mondván:
minden karakter forgatható 3 Vigenère forogni fog minden egyes karakter
egy másik összeget, attól függően néhány kulcsszó
ahol minden egyes levél a kulcsszó jelentése néhány eltérő összeg
forgatni a tiszta szöveget.
Nézzük először beszélni változó hatályát.
Vannak 2 különböző típusú változók.
Van lokális változók, és ezek fogják meghatározni
ezen kívül a fő vagy azon kívül minden olyan funkciót, vagy blokk,
és ezek lesz elérhető bárhol a programban.
Ha van egy funkció, és ezzel a feladattal a while
A nagy globális változó elérhető mindenhol.
Egy helyi változót, a másik viszont hatókörű arra a helyre, ahol meg van határozva.
>> Ha van egy funkciója van, például, van ez a funkció g,
és belső A g-van egy változó itt nevű y,
és ez azt jelenti, hogy ez egy helyi változó.
Annak ellenére, hogy ez a változó neve y
és ez a változó neve y e 2 funkció
Fogalmam sincs, mi egymás lokális változók.
Másrészt, fel itt azt mondjuk, int x = 5,
és ez kívül esik minden funkciót.
Ez hatályán kívül legfontosabb, így ez egy globális változót.
Ez azt jelenti, hogy a belső e 2 akkor működik, ha azt mondom, x - x vagy + +
Én éri el ugyanazt x amely e y és y e különböző változók.
Ez a különbség egy globális változó, és egy helyi változót.
Ami a design illeti, néha talán jobb ötlet
tartani a helyi változók, amikor csak lehetséges
mivel tekintettel egy csomó globális változók igazán zavaró.
Ha van egy csomó funkció valamennyi módosító ugyanazt
lehet elfelejteni mi van, ha ezt a funkciót véletlenül módosítja ezt a globális,
és ez az egyéb funkció nem tud róla,
és nem kap elég zavaró, ahogy minél több kódot.
Tartása változók helyi amikor csak lehetséges
csak a jó design.
Tömbök, ne feledd, egyszerűen listák elemeinek az azonos típusú.
Belül CI nem lehet a listán, mint 1, 2,0, hello.
Csak nem tehetjük.
>> Amikor állapítsa tömb C-ben minden elemet kell lennie, azonos típusú.
Itt van egy sor 3 egészek.
Itt van a hossza a tömb, de ha én csak megállapító e szintaxis
ahol nevezze meg az összes elem tudom technikailag nem kell ebben a 3.
A fordító elég okos ahhoz, hogy kitaláljuk, milyen nagy a tömb kell.
Most, amikor akarok, vagy állítsa az értéket egy tömb
ez a szintaxis erre.
Ez valóban módosítja a második eleme a tömb, mert emlékszem,
számozás 0-tól indul, nem pedig 1.
Ha azt szeretnénk, hogy olvastam, hogy értéket tudok mondani valamit, mint int x = array [1].
Vagy ha azt szeretnénk beállítani ezt az értéket, mint csinálok itt,
Azt lehet mondani, array [1] = 4.
Ez az idő elérése elemeket azok index
vagy pozíció vagy ha azok a tömbben,
és hogy a tőzsdei 0-tól indul.
Azt is, hogy tömbök tömbök,
és ezt hívják multi-dimenziós tömb.
Ha van egy több dimenziós tömb
azt jelenti, hogy mi is van valami hasonló sorok és oszlopok
és ez csak az egyik módja a vizualizációs ez vagy rágondolok.
Ha van egy több dimenziós tömb azt jelenti, hogy fogok kezdeni szüksége
Több mint 1 index, mert ha van egy rács
csak azt mondom, amit a sorban vagyunk, nem ad nekünk egy számot.
Ez tényleg csak fog adni nekünk egy listát a számok.
Tegyük fel, hogy van ez a tömb van.
Van egy sor úgynevezett grid, és azt mondom, hogy a 2 sort és 3 oszlopot,
és így ez az egyik módja a megjelenítésére is.
Amikor azt mondom, azt akarom, hogy az elem a [1] [2]
azt jelenti, hogy mivel ezek a sorok, majd az első oszlop
Fogok ugrani 1 sor, mert én mondtam 1.
>> Akkor fogok gyere ide, hogy a 2. oszlopban, és megyek, hogy az érték 6.
Értelme?
Többdimenziós tömbök, ne feledd, technikailag csak egy sor tömbök.
Mi lehet tömbök tömbök tömbök.
Mi folyamatosan megy, de valóban az egyik módja annak, hogy gondolni
hogyan kerül megállapított, és mi van, hogy elképzelni is
egy rács, mint ez.
Amikor át tömbök a funkciókat, ők fognak viselkedni
egy kicsit másképp, mint amikor át rendszeres változók funkciók
mint a tompított int vagy float.
Amikor át egy int vagy char vagy ezek más adattípusok
épp most vett egy pillantást, ha a funkció módosítja
értékét a változó, hogy a változás nem fog terjeszteni up
a hívó funkciót.
Egy sor, másrészt, hogy a fog történni.
Ha elmegyek egy tömbben néhány funkció és a funkció megváltoztatja egyes elemei,
mikor jön vissza a funkció nevezték
a tömb most lesz más, és a szókincs az adott
a tömbök kerülnek átadásra való hivatkozással, mint látni fogjuk később.
Ez összefügg azzal, hogy a munka mutatókat, amennyiben ezeket az alapvető adattípusok,
másrészt, szerint adódnak át érték.
>> Azt gondolni, hogy mivel a másolás néhány változó, majd halad a másolatot.
Nem számít, hogy mit teszünk, hogy változó.
A hívó függvény nem lesz tisztában azzal, hogy megváltozott.
Tömbök csak egy kicsit más ebben a tekintetben.
Például, amint azt most láttuk, a fő-egyszerűen egy függvény
amely át tudja venni a 2 érveket.
Az első érv, hogy a fő funkciója argc, vagy a számos érvet,
és a második argumentum neve argv,
és ezek a pillanatnyi értékeket ezen érvek.
Tegyük fel, hogy van egy program neve this.c,
és azt mondom, hogy ez, és én fogom futtatni ezt a parancsot.
Most, hogy át néhány érvet a saját nevű program ezt
Tudnék mondani valamit, mint a. / Ez cs 50.
Ez az, amit elképzelni David csinálni minden nap a terminált.
De most a fő funkciója belsejében, hogy a program
vannak ezek az értékek, így argc 4 lehet.
Lehet, hogy egy kicsit zavaró, mert tényleg mi csak halad a cs 50.
Ez csak 3.
De ne feledjük, hogy az első eleme argv vagy az első argumentum
a neve a funkció is.
Tehát ez azt jelenti, hogy 4 dolog van,
és az első elem lesz. / ezt.
És ez lesz képviseli, mint egy húr.
Ezután a többi elem, amit beírt neve után a program.
Tehát csak mint egy félre, ahogy valószínűleg látta Pset 2,
ne feledjük, hogy a szöveg 50-≠ az egész 50.
Tehát nem lehet azt mondani valamit, mint a "int x = argv 3.
>> Ez egyszerűen nem megy, hogy értelme, mert ez egy string, és ez egy egész szám.
Tehát, ha szeretné konvertálni a 2, ne feledd, fogunk
ezt a mágikus nevezett funkció atoi.
Hogy vesz egy karakterláncot, és visszaadja az egész képviselő belül az adott string.
Szóval ez egy egyszerű hiba, hogy a kvíz,
Csak arra gondoltam, hogy ez automatikusan a megfelelő típusú.
De tudjuk, hogy ezek mindig karakterláncok
még akkor is, ha a húr csak tartalmaz egy egész, vagy egy karakter vagy egy úszó.
És most beszéljünk működési idő.
Amikor minden ilyen algoritmusok mindent megtesz ezek az őrült dolgokat,
válik igazán hasznos feltenni a kérdést: "Mennyi ideig nem vesznek?"
Azt kijelenti, hogy valami úgynevezett aszimptotikus jelöléssel.
Tehát ez azt jelenti, hogy - nos, mondjuk azt, hogy mi a algoritmust
Néhány nagyon, nagyon, nagyon nagy bemenet.
Szeretnénk feltenni a kérdést: "Meddig fog ez tartani?
Hány lépést fog tartani a mi algoritmus futtatásához
függvényében a méret a bemenet? "
Tehát az első lehetőség, hogy írni fut az idő a nagy O.
És ez a mi legrosszabb futás idő.
Tehát, ha azt akarjuk, hogy rendezni egy tömb, és hogy mi algoritmus egy tömb
ez csökkenő sorrendben, amikor kell lennie növekvő sorrendben,
ez lesz a legrosszabb esetben.
Ez a mi felső határa a maximális időtartamot algoritmusunk fog.
Másrészt, ez Ω fog leírni legjobb eset működési idő.
Tehát, ha adunk egy már rendezett tömbben egy válogató algoritmus,
mennyi ideig fog tartani, hogy rendezni ez?
És ez, majd leír egy alsó korlátot a működési idő.
Tehát itt van, csak néhány szót, amelyek leírják néhány gyakori üzemidő.
Ezek növekvő sorrendben.
A leggyorsabb futási idő van az úgynevezett állandó.
>> Ez azt jelenti, nem számít, hány elemet adunk meg algoritmus,
nem számít, milyen nagy a tömb, válogatás az
avagy bármit csinálunk a tömb mindig ugyanannyi idő alatt.
Így tudjuk képviselt, hogy csak egy 1, amely egy konstans.
Mi is nézett logaritmikus futási időben.
Tehát valami hasonló bináris keresés logaritmikus,
ha vágjuk a probléma felében minden alkalommal
és akkor a dolgok csak kap magasabb onnan.
És ha valaha is írt egy O minden faktoriális algoritmus,
akkor valószínűleg nem kell figyelembe ezt, mint a napi munkát.
Ha összevetjük üzemidő fontos szem előtt tartani ezeket a dolgokat.
Tehát, ha van egy olyan algoritmust, ami O (n), és valaki más
már egy algoritmus O (2n) ezek valójában aszimptotikusan ekvivalens.
Tehát, ha azt képzeljük, n, hogy egy nagy szám, mint eleventy milliárd:
így amikor mi összehasonlítjuk eleventy milliárd ilyesmit eleventy milliárd + 3,
hirtelen, hogy 3 nem igazán egy nagy különbség többé.
Ezért fogjuk kezdeni tekintve ezek a dolgok, hogy egyenértékűek.
Így a dolgok, mint ezek itt állandók, van 2 x e, vagy hozzáadásával a 3,
ezek csak állandók, és ezek fognak dobni fel.
Szóval ezért mind a 3 ilyen futási idők ugyanaz, mint azt ők O (n).
Hasonlóképpen, ha van 2 másik futási idő, mondjuk O (n ³ + 2n ²), adjuk hozzá
+ N, + 7, és akkor van egy másik futási időben ez csak O (n ³).
ismét, ezek az ugyanaz dolog, mert ezek - ezek nem azonosak.
Ezek ugyanazok a dolgok, sajnálom. Tehát ezek az ugyanaz, mert
ez n ³ fog uralni ezt a 2n ².
>> Mi nem ugyanaz a dolog, ha már fut időkben O (n ³) és az O (n ²)
mert ez N ³ jelentése sokkal nagyobb, mint ez az NZ.
Tehát, ha van kitevő, hirtelen ez kezd számít,
de ha mi csak foglalkozunk tényezők, mint mi itt,
akkor ez nem lesz baj, mert ők csak lesz lemorzsolódás.
Vessünk egy pillantást néhány algoritmusok láttuk eddig
és beszélni a futási időt.
Az első módszer a keresett számot a listán, hogy láttuk, volt lineáris keresés.
És végrehajtása lineáris keresés szuper egyszerű.
Csak van egy lista, és megyünk nézni minden egyes elem a listán
amíg meg nem találjuk a számot keresünk.
Tehát ez azt jelenti, hogy a legrosszabb esetben ez O (n).
És a legrosszabb esetben is lehetne, ha az elem
Az utolsó elem, akkor lineáris keresést meg kell nézni minden egyes elemét
addig, amíg eljutunk az utolsó ahhoz, hogy tudjuk, hogy ez valójában a listában.
Egyszerűen nem adja fel félúton, és azt mondják: "Valószínűleg nincs ott."
A lineáris keresés van, hogy nézd meg az egészet.
A legjobb esetben működési idő, a másik viszont konstans
mert a legjobb esetben is az elem keresünk, csak az első a listán.
Így fog vinni bennünket pontosan 1 lépés, nem számít, milyen nagy a lista
ha keresünk, az első elemet minden alkalommal.
>> Tehát, ha keres, ne feledd, hogy nem követeli meg, hogy a listát rendezve.
Mert mi csak megy, hogy nézd át minden egyes elemét, és ez nem igazán számít,
Milyen sorrendben ezek az elemek be
Egy intelligens keresési algoritmus olyasmi, mint a bináris keresés.
Ne feledje, a végrehajtás a bináris keresés, ha mész
nézz a közepén a listán.
És mert éppen a közepén, azt követeli meg, hogy a lista rendezve
vagy pedig nem tudjuk, hogy hol a középső van, és van, hogy nézd át
A teljes lista, hogy megtalálja, majd ezen a ponton mi csak időpocsékolás.
Tehát ha van egy rendezett listát, és megtaláljuk a középső, fogjuk összehasonlítani a középső
az elem keresünk.
Ha ez túl magas, akkor tudjuk elfelejteni a jobb felét
mert tudjuk, hogy ha a mi elem már túl magas
és minden jobbra ez az elem még magasabb,
akkor nem kell nézni ott többé.
Amennyiben másrészt, ha a mi elem túl alacsony,
tudjuk, hogy mindent a bal oldalon ez az elem is túl alacsony,
így nem igazán értelme nézni ott sem.
Így minden lépést, és minden alkalommal, amikor megnézzük a felezőpontja a lista
fogunk vágni mi problémánk a felére, mert hirtelen tudjuk
egy csomó szám, hogy nem lehet az, amit keresünk.
>> Ebben pszeudokód ez valahogy így néz ki,
és mert mi vágás a listát felében minden egyes alkalommal,
a legrosszabb futási ugrik lineáris logaritmikus.
Olyan hirtelen van bejelentkezés lépéseket annak érdekében, hogy megtalálják egy elemet a listán.
A legjobb eset futás időben, bár még mindig állandó
mert most, mondjuk, hogy az elem keresünk a
mindig a pontos közepén az eredeti lista.
Így nőhet a listán olyan nagy, mint szeretnénk, de ha az elemet keresünk, van a közepén,
akkor ez csak akkor fog minket 1 lépés.
Szóval ezért vagyunk O (log n) és Ω (1) vagy állandó.
Nézzük ténylegesen megtett bináris keresés ezen a listán.
Szóval azt mondják, hogy amit keresünk az elem 164.
Az első dolog, fogunk tennie, hogy megtalálja a felezőpontja ezt a listát.
Ez csak azért történik, hogy a középpont fog esni közötti 2 szám,
úgyhogy csak önkényesen mondjuk, minden alkalommal, amikor a középpont esik a 2 számot,
mondjuk csak felhajt.
Csak meg kell győződjön meg róla, tesszük ezt minden lépésnél.
Szóval megy felhajt, és fogjuk azt mondani, hogy 161 a középső a mi listáját.
So 161 <164, és minden eleme balra 161
is <164, így tudjuk, hogy ez nem fog segíteni nekünk egyáltalán
kezdeni ide, mert az elem keresünk, nem lehet ott.
Szóval mit tehetünk mi, csak felejtsd el, hogy az egész bal fele a lista
és most csak úgy a jobb a 161 kezdve.
>> Tehát még egyszer, ez a középpont, mondjuk csak felhajt.
Most 175 túl nagy.
Tehát tudjuk, hogy ez nem fog segíteni nekünk keres itt vagy itt,
így tudjuk csak dobja azt el, és végül mi nyomja a 164.
Bármilyen kérdésre bináris keresés?
Menjünk el az kereső segítségével egy már rendezett lista
ténylegesen figyelembe számok listájának bármilyen sorrendben
és hogy ezt a listát növekvő sorrendben.
Az első algoritmust néztük hívták bubble sort.
És ez lenne egyszerűbb az algoritmus, amit láttunk.
Bubble sort azt mondja, hogy ha bármelyik 2 elem belsejében a listán a helyén,
vagyis van egy nagyobb számú balra egy kisebb számú,
akkor fogunk cserélni őket, mert ez azt jelenti, hogy a lista lesz
"Több rendezett", mint korábban volt.
És mi csak folytatjuk ezt a folyamatot újra és újra és újra
amíg végül az elemek milyen buborék azok megfelelő helyre, és van egy rendezett listát.
>> A futási idő ennek lesz O (n ²). Miért?
Nos, azért, mert a legrosszabb esetben, megyünk, hogy minden elem, és
fogunk a végén összehasonlítva minden más elemet a listában.
De a legjobb esetben, van egy már rendezett lista, bubble sort a
Csak megy, hogy menjen át egyszer mondja: "Nem. Én nem semmi swap, ezért kész vagyok."
Tehát van egy best-case futási ideje Ω (n).
Fussunk buborék rendezés a listán.
Vagy az első, nézzük csak meg néhány pszeudokód nagyon gyorsan.
Azt akarjuk mondani szeretnénk nyomon követni, minden iteráció a hurok,
nyomon követni e vagy sem mi változott olyan elemeket.
Tehát az oka, hogy, mi fog megállni, ha még nem cserélték olyan elemeket.
Tehát az elején a mi hurok még nem cserélt semmit, úgyhogy mondhatjuk, hogy ez hamis.
Most megyünk végig a listát, és hasonlítsa össze elem i elem i + 1
és ha ez az eset, hogy van egy nagyobb szám balra egy kisebb szám,
akkor mi csak fogja cserélni őket.
>> És akkor fogunk emlékezni, hogy cserélték egy elem.
Ez azt jelenti, hogy meg kell, hogy menjen át a listát legalább 1 több időt
mert az állapot, amelyben álltunk, amikor a teljes lista már rendezve,
ami azt jelenti, nem tettek semmilyen swap.
Szóval ezért a feltétel itt lent van ", miközben bizonyos elemei már cseréltek."
És most nézzük csak ezt nézd meg fut egy listán.
Megvan a lista 5,0,1,6,4.
Bubble sort fog kezdeni végig a bal oldalon, és ez lesz összehasonlítani
az i elemeket, így 0 és i + 1, ami az 1 elem.
Ez fogja mondani, jól 5> 0, de most 5-ös a baloldalt,
így kell cserélni az 5 és a 0-ra.
Amikor cserélni őket, hirtelen én kap ez a különböző listát.
Most 5> 1, így fogunk cserélni őket.
5 nem> 6, így nem kell semmit itt.
De 6> 4, ezért meg kell cserélni.
Ismét meg kell végigmenni a teljes lista, hogy végül felfedezze
hogy ezek elromlott, mi cserélni őket,
és ezen a ponton meg kell végigmenni az 1-lista több időt
meggyőződni arról, hogy minden a saját érdekében, és ezen a ponton bubble sort befejeződött.
Egy másik algoritmust vesz bizonyos elemeit és rendezési őket kiválasztás sort.
Az ötlet mögött kiválasztás sort, hogy fogunk felépíteni egy rendezett részét a lista
1 elem egy időben.
>> És ahogy fogjuk csinálni egyáltalán kiépítése bal szegmense a listán.
És tulajdonképpen, minden - minden lépés, megyünk, hogy a legkisebb elem hagytuk
amelyet még nem rendezett még, és fogjuk mozgatni ebbe a rendezett szegmensben.
Ez azt jelenti, meg kell, hogy folyamatosan megtalálják a minimum rendezetlen elem
majd vegye, hogy a minimális elemet, és cserélni azt bármilyen
bal szélső elem, amely nincs rendezve.
A futási idő ennek lesz O (n ²), mert a legrosszabb esetben
kell összehasonlítani minden egyes elem az összes többi elem.
Mert azt mondjuk, hogy ha indul a bal felét a lista, szükségünk van
hogy menjen át az egész jogot szegmens, hogy megtalálják a legkisebb elem.
És akkor ismét el kell menni az egész jobb szegmens és
folyamatosan megy át, hogy újra és újra és újra.
Ez lesz n ². Mi lesz szükségünk a for ciklus belsejében egy másik a loop
ami azt sugallja, n ².
A legjobb esetben gondolat, nézzük azt mondjuk, hogy ez egy már rendezett listát;
valójában nem tesszük jobban, mint n ².
Mivel a kiválasztás sort nem tudhatja, hogy
a minimális elem csak az egyik én történetesen nézi.
Meg kell még, hogy győződjön meg arról, hogy ez valójában a minimum.
>> És az egyetlen módja annak, hogy győződjön meg arról, hogy ez a minimum, ezt az algoritmust,
hogy nézd meg minden egyes elemét újra.
Szóval tényleg, ha megadja, hogy - ha adsz kiválasztás sort egy már rendezett lista
ez nem fog csinálni jobban, mint hogy ez a lista nem rendezett még.
By the way, ha ez történik, hogy a helyzet, hogy valami O (valamit)
és az omega valami, akkor csak annyit látna tömören, hogy ez θ valamit.
Tehát, ha úgy látja, hogy jön sehova, ez az, amit ez csak jelent.
>> Ha valami theta n ², ez mind a nagy O (n ²) és Ω (n ²).
Így a legjobb esetben, és legrosszabb esetben, hogy nem tesz különbséget,
az algoritmus fog nem ugyanaz a dolog minden alkalommal.
Szóval ez az, amit pszeudokód kiválasztás sort is néz ki.
Mi alapvetően fogja mondani, hogy akarom navigálhat át a listát
balról jobbra, és minden iteráció a hurok, fogok mozogni
a minimális elem ebbe rendezett részét a lista.
És ha mozgok valamit ott, soha nem kell nézni, hogy az elemet újra.
Mert amint csere egy elemet a bal oldali szegmens a lista, ez rendezve
mert mi csinálunk mindent, növekvő sorrendben használatával minimumok.
Tehát azt mondta, rendben vagyunk pozícióban i, és meg kell nézni az összes elemet
jobbra az i-ben annak érdekében, hogy megtalálják a legkisebb.
Tehát ez azt jelenti, hogy meg akarom nézni, i + 1-től az a lista végére.
És most, ha az elem, hogy mi jelenleg keresi a kevesebb, mint a minimális eddig,
amely ne feledd, kezdünk a minimális le, hogy csak
bármilyen elem vagyunk jelenleg, fogom feltételezni, hogy ez a minimum.
Ha találok egy elem, ami kisebb, akkor fogok mondani, oké,
nos, én találtam egy új minimum.
Fogok emlékezni, ha a minimális volt.
>> Tehát most, ha egyszer már ment keresztül ez a jog rendezetlen szegmensben,
Azt lehet mondani, megyek, hogy a csere a legkisebb elem az elem, hogy a helyén van i.
Ez fogja felépíteni a listámon, a rendezett része a lista balról jobbra,
és mi soha nem kell nézni egy elemet még egyszer, hogy ez az adott rész.
Amint már cserélni azt.
Szóval futni kiválasztás sort ezen a listán.
A kék elem itt lesz az én, és a piros elem lesz a legkisebb elem.
Tehát én kezdődik, egészen a bal oldalán a listán, így az 5.
Most arra van szükség, hogy megtalálják a legkisebb rendezetlen elem.
Tehát mondjuk 0 <5, tehát a 0 az új minimum.
>> De nem áll meg ott, mert bár mi is elismerik, hogy a 0 a legkisebb,
meg kell végigmenni minden más eleme a lista, hogy megbizonyosodjon arról.
Tehát 1 nagyobb, 6 nagyobb, 4 nagyobb.
Ez azt jelenti, hogy miután nézi az összes ezeket az elemeket, amit meghatározott 0 a legkisebb.
Szóval fogom cserélni az 5 és a 0-ra.
Amint csere, hogy megyek, hogy egy új listát, és tudom, hogy soha nem kell nézni, hogy a 0 ismét
mert egyszer én már cserélték, én már rendezett, és készen vagyunk.
Most már csak azért történik, hogy a kék elem ismét a 5,
és meg kell nézni a 1, a 6 és a 4 annak megállapítására, hogy az 1
a legkisebb minimum elem, úgyhogy majd cserélni az 1 és az 5.
Ismét meg kell nézni - hasonlítsa össze az 5 és a 6 és a 4,
és mi fogjuk cserélni a 4 és az 5, és végül hasonlítsa össze
E 2 számok és cserélni őket, amíg megkapjuk a rendezett lista.
Van még kérdése kiválasztási sort?
Oké. Menjünk az utolsó téma itt, és ez rekurziót.
>> Rekurziót, ne feledd, ez tényleg meta dolog, ha egy funkciót
többször nevezi magát.
Tehát egy bizonyos ponton, míg a fuction többször nevezte magát,
van szükség, hogy néhány ponton, ahol megállunk hívó magunkat.
Mert ha nem tesszük ezt, akkor mi csak folytatjuk ezt örökké,
és a program, csak nem fog felmondani.
Nevezzük ezt a feltételt az alapeset.
És az alapeset szerint ahelyett, hogy hív egy függvényt újra,
Én csak megy vissza valamilyen értéket.
Tehát, ha mi már vissza egy értéket, már megállt hívó magunkat,
és a többi a hívások tettük eddig is visszatérhet.
Ennek az ellenkezője az alapeset a rekurzív helyzet.
És ez az, amikor azt szeretnénk, hogy egy másik hívást a funkció, hogy mi vagyunk a jelenleg be
És valószínűleg, bár nem minden esetben, a használni kívánt különböző érveket.
>> Tehát ha van egy függvény neve f, és f hívott vegyél be 1 érvet,
és mi csak hívogatnak f (1), f (1), f (1), és ez csak azért történik, hogy
az érvelés 1 beleesik rekurzív ügyben, még mindig soha nem fog megállni.
Még ha van egy alapesetet, meg kell, hogy győződjön meg arról, hogy végül mi lesz a hit, hogy az alapeset.
Mi nem csak tartsa tartózkodik ebben rekurzív ügyben.
Általában, ha hívjuk magunkat, mi valószínűleg megy, hogy egy másik érv minden alkalommal.
Itt van egy nagyon egyszerű rekurzív függvény.
Tehát ez lehet kiszámítani a faktoriálisát egy számot.
Up tetejére Itt megvan a alapeset.
Abban az esetben, ha n ≤ 1, nem fogunk hívni faktoriális újra.
Fogunk állítani, mi csak megy vissza valamilyen értéket.
Ha ez nem igaz, akkor fogunk ütni a rekurzív ügyben.
Figyeljük meg, hogy itt mi nem csak hívja faktoros (n), mert az nem lenne nagyon hasznos.
Fogunk hívni faktoriálisát valami mást.
>> És látod, végül ha átadjuk a faktoriális (5) vagy valami,
fogunk hívni faktoros (4), és így tovább, és végül meg fogjuk ütni ez az alapeset.
Szóval ez jól néz ki. Lássuk, mi történik, ha a ténylegesen megtett ezt.
Ez a verem, és mondjuk, hogy fő fogja hívni ezt a funkciót egy argumentum (4).
Tehát, ha látja és faktoriális = 4, faktoriális hívja magát.
Most, hirtelen, már faktoriális (3).
Tehát ezek a funkciók fognak nőni, amíg végül elérjük bázisunkat ügyben.
Ezen a ponton, a visszatérési értéke ez a visszatérés (nx a visszatérési értékét),
a visszatérési értéke ez nx a visszatérési értéke.
Végül meg kell hit néhány számot.
A tetején van, mondjuk vissza 1.
Ez azt jelenti, hogy ha egyszer visszatér ez a szám, akkor pop ezt le a köteget.
Tehát ez a faktoriális (1) történik.
Ha 1 visszatér, ez a faktoriális (1) visszatér, ez a visszatérés 1-re.
A visszatérési értékét, ne feledd, volt nx a visszatérési értéke.
Olyan hirtelen, ez a srác tudja, hogy szeretnék visszatérni 2.
>> Úgy emlékszem vissza értéke ez csak nx a visszatérési érték itt.
Így most azt mondhatjuk, 3 x 2, és végül, itt elmondhatjuk
ez csak lesz 4 x 3 x 2.
És ha ez visszatér, akkor feküdj egyetlen egész belsejében fő.
Bármilyen kérdésre rekurzió?
Rendben van. Tehát több időt a kérdésekre a végén,
de most Joseph fedezi a fennmaradó témaköröket.
>> [Joseph Ong] Rendben. Tehát most, hogy már beszéltünk recursions,
beszéljünk egy kicsit arról, hogy mi egyesítése rendezés.
Merge rendezés alapvetően másik módja a válogatás a számok listája.
És hogyan működik ez, a merge sort van egy lista, és mit teszünk
mondjuk, menjünk szét ezt a 2 fél.
Majd első indításakor merge sort ismét a bal felét,
akkor fogjuk futtatni egyesítése sort a jobb felét,
és ez ad nekünk most 2 fél amelyek rendezve, és most fogunk kombinálni ezeket felét együtt.
Ez egy kicsit nehéz látni anélkül, hogy példát, így megyünk át a mozgás, és meglátjuk, mi történik.
Így kezdődik ez a lista, akkor osztott be 2 fél.
Futunk egyesítése sort a bal felén először.
Szóval ez a bal fele, és most fut őket ezen a listán újra
amelyek egyre vezetünk egyesítése sort, majd megnézzük újra,
a bal oldalon a listában, és futunk egyesítése sort rajta.
Most kap le egy listát a 2 szám,
és most a bal fele csak 1 elem hosszú, és nem tudunk
szét egy listát, hogy csak 1 elemet a fele, így csak azt mondom, ha van 50,
amely mindössze 1 elem, ez már rendezve.
>> Ha végeztünk vele, azt látjuk, hogy tudjuk
lépni a jobb oldalán ezen a listán,
és 3 is válogatni, és így most, hogy mindkét felét ezen a listán vannak rendezve
tudunk csatlakozni ezeket a számokat újra együtt.
Így néz ki a 50 és 3, 3 kisebb, mint 50, így megy az első, majd 50 bejön
Most, hogy kész, megyünk vissza a lista és a rendezés ez jobb felét.
42 van saját száma, így ez már rendezve.
Tehát most összehasonlítjuk ezeket 2 és 3 kisebb, mint 42, úgy, hogy kap fel az első,
Most 42 gets hozott, és 50 lesz helyezze be
Nos, ez válogatni, menjünk egészen vissza a csúcsra, 1337 és 15.
Nos, most nézd meg a bal oldali felét listán; 1337 jelentése önmagában így ez válogatni és ugyanaz a 15.
Tehát most kombináljuk ezeket 2 szám rendezni, hogy az eredeti listán, 15 <1337,
így megy az első, majd 1337 bemegy
És most sorrendje mindkét felét az eredeti lista top up.
És minden, amit meg kell tennie, hogy kombinálni ezeket.
Nézzük az első 2 szám ez a lista, 3 <15, így megy az a fajta tömb első.
15 <42, így megy be most, 42 <1337, hogy megy be
50 <1337, így megy be És észre, hogy mi csak volt 2 szám le ezt a listát.
Szóval nem csak felváltva a 2 listákat.
Mi csak nézte az elején, és szedi az elem
ez a kisebb, majd helyezze be a tömb.
Most már összevonták az összes fél, és készen vagyunk.
>> Bármilyen kérdése merge sort? Igen?
[Student] Ha ez felosztása különböző csoportok, miért nem ők csak osztott egyszer
és van 3 és 2 a csoportban? [Külföld kérdés értelmetlen]
Az ok - így a kérdés az, hogy miért nem tudunk csak egyesíteni őket, hogy az első lépés után már őket?
Az ok, meg tudjuk csinálni, kezdje a bal szélső elemeit mindkét oldalon,
majd megteszi a kisebb és tedd, hogy mi tudjuk, hogy ezek
az egyes listák vannak rendezve megrendeléseket.
Tehát, ha nézem a bal szélső elemeit mindkét felét,
Tudom, hogy ők lesznek a legkisebb elemeit a listákra.
Szóval lehet őket a legkisebb eleme foltok e nagy lista.
Másrészt, ha megnézzük azokat 2 lista a második szinten ott,
50, 3, 42, 1337 és 15, ezek nem válogatják szét.
Tehát, ha ránézek 50 és 1337, fogok tenni 50-listámon az első.
De ez nem igazán értelme, mivel 3 a legkisebb eleme az összes ilyen.
Tehát az egyetlen oka annak, hogy megteheti ezt ötvözi a lépés, mert a listák már rendezve.
Éppen ezért van, hogy le egészen az aljára
mert amikor már csak egy szám, tudod, hogy egy szám
önmagában már rendezett listát.
>> Van még kérdése? Nem?
A komplexitás? Nos, akkor láthatjuk, hogy minden egyes lépés van vége számok,
és mi lehet osztani a listát a felére log n-szer,
ami ha megkapjuk ezt a n x log n összetettségét.
És látni fogja a legjobb esetben a merge sort n log n, és ez csak azért történik,
hogy a legrosszabb eset, vagy az Ω ott, is n log n.
Valami, hogy tartsa szem előtt.
Továbblépve, menjünk be néhány szuper alapvető file I / O.
Ha nézett Scramble, észre fogod venni, volt valami rendszer
ahol meg lehet írni egy log fájlt, ha olvassa el a kódot.
Lássuk, hogyan lehet csinálni.
Hát, van fprintf, amit lehet gondolni, mint csak printf,
de csak a nyomtatás helyett egy fájlba, és így az f elején.
Ez a fajta kód ide, mit csinál az, ahogy azt láttuk Scramble,
megy át a 2-dimenziós tömb Nyomtatásra ki egy sorral, amit a számok.
Ebben az esetben a printf kinyomtatja a terminálhoz vagy hívjuk a standard kimenetre szakasz.
>> És most, ebben az esetben, minden, amit meg kell tennie, hogy cserélje ki a printf fprintf,
megmondani, hogy mit kívánt fájlt nyomtatni, és ebben az esetben csak kinyomtatja az adott fájl
nyomtatás helyett ki a terminál.
Nos, akkor ez felveti a kérdést: Hol kap ez a fajta fájl, igaz?
Mentünk be az e fprintf fuction de fogalmam sem volt, honnan jött.
Nos, korai a kódot, amit az volt a kódrészletet ide,
amely lényegében azt mondja, hogy nyissa meg a fájlt hív log.txt.
Mit teszünk utána, hogy van, hogy győződjön meg arról, hogy a fájl valójában nyitva sikeresen.
Tehát lehet, hogy nem több okból, akkor nincs elég hely a számítógépen, például.
Szóval ez mindig fontos, mielőtt tegye műveleteket a fájl
hogy ellenőrizze, hogy a fájl megnyílt sikeresen.
Tehát mi, hogy egy, ez az érvelés a fopen, nos, akkor nyisson meg egy fájlt több módon is.
Mit tehetünk, mi is add w, ami felülírja a fájlt, ha kilép már,
Mi lehet át egy olyan, amit csatolnia a végén a fájl helyett kényszerítő azt,
vagy mi megadhatja r, ami azt jelenti, hadd nyissa meg a fájlt csak olvasható.
Tehát, ha a program megpróbál, hogy bármilyen változás a fájlt,
kiabálni, és ne hagyd, hogy csináljuk.
Végül, miután végeztünk a fájl, befejezte ezt műveleteket rajta,
meg kell, hogy győződjön meg arról, zárjuk be a fájlt.
És így a végén a program, akkor megy át őket újra
ezt a fájlt, amit megnyitott, és csak zárja be.
Tehát ez valami fontos, amit meg kell győződjön meg róla csinálni.
Úgy emlékszem, meg tudja nyitni a fájlt, akkor írj a fájlt,
do műveleteket a fájlt, de akkor meg kell zárja be a fájlt a végén.
>> Van még kérdése az alapvető fájl I / O? Igen?
[Student kérdés, érthetetlen]
Itt van. A kérdés az, ha ez log.txt fájl jelenik meg?
Nos, ha csak add log.txt, hogy létrehozza ugyanabban a könyvtárban a futtatható.
Tehát ha Te - >> [Student kérdést, érthetetlen]
Igen. Ugyanebben a mappában, vagy ugyanabban a könyvtárban, ahogy te nevezed.
Most memória, verem, és a kupac.
Hogy van memória lefektetett a számítógép?
Nos, el lehet képzelni, memória fajta a blokk itt.
És a memóriában van az úgynevezett a halom ragadt ott, és a köteget, hogy van ott lent.
És a halom nő lefelé, és a köteget nő felfelé.
Így például Tommy említettük - ó, nos, és mi van az egyéb 4 szegmens, amit kapsz, hogy a második -
Ahogy korábban is mondtam Tommy, tudod, hogy ellátja nevezik magukat, és hívja egymást?
Építik fel ezt a fajta stack frame.
Nos, ha a fő kéri ize ize kap fektetni a verem.
Foo hív, bár kap a fektetni a verem, és hogy kap fektetni a stack után.
És ahogy visszatérnek, mindegyikük kap levették a verem.
Mi minden ezeken a helyeken és memória tartani?
Nos, a felső, amely a szöveg szegmens tartalmazza a program maga.
Tehát a gépi kód, ez van, ha egyszer fordítsa le a program.
Ezután minden inicializált globális változókat.
>> Szóval globális változók a program, és azt mondod, mint, a = 5,
hogy lesz be ebben a szegmensben, és jobbra az említett,
Ha bármilyen inicializált globális adatok, ami csak int a,
de nem mondom, hogy ez egyenlő a semmit.
Ismerd fel, ezek a globális változókat, ezért ők kívül fő.
Tehát ez azt jelenti, olyan globális változók, amelyek deklarált, de nem inicializálva.
Szóval, mi van a kupac? Memory felosztása egy malloc, amit kapsz, hogy egy kicsit.
És végül, a stack bármilyen lokális változók
és minden funkciót lehet hívni, hogy egyes paramétereket.
Az utolsó dolog, nem igazán tudni, hogy mi a környezeti változókat nem,
de ha futtatni programot, van valami jár, mint a
ez a felhasználónevét, aki futott a program.
És ez lesz valami az alján.
Ami a memória címek, amelyek hexadecimális értékek,
az értékek a felső 0-val kezdődnek, és mennek egészen az aljára.
Ebben az esetben, ha a 32-bites rendszer,
a cím alján lesz 0x, majd af, mert ez 32 bit,
ami 8 bájt, és ebben az esetben a 8 bájt megfelel 8 hexadecimális számjegy.
Szóval itt lent mész van, mint, 0xffffff, és ott fogsz hogy 0-ra.
Tehát mi a mutatókat? Néhányan lehet, hogy nem vonatkozik ez a szakasz előtt.
de nem megy át rajta az előadás, így a mutató csak egy adattípus
amely tárolja, ahelyett, hogy valamilyen érték, mint a 50, tárolja a címét egy olyan helyszín a memóriában.
Mint az a memória [érthetetlen].
Tehát ebben az esetben, amit nem, van egy mutató egy egész szám vagy egy int *
és tartalmazza ezt a hexadecimális címét 0xDEADBEEF.
>> Szóval mi van, az, most ez a mutató néhány helyen a memóriában,
és ez csak egy, az érték az 50 most ezt a memóriahelyet.
Néhány 32-bites rendszerek, az összes 32-bites rendszerek, pointerek vegye fel 32 bites vagy 4 bájt.
De például, egy 64-bites rendszer, pointers 64 bit.
Szóval ez valami, akkor szeretné, hogy tartsa szem előtt.
Szóval vége bites rendszeren, a mutató vége bit hosszú.
Mutatók a fajta nehéz megemészteni nélkül extra dolgokat,
úgyhogy menjünk át egy példa a dinamikus memória kiosztás.
Milyen dinamikus memória kiosztás tesz Önnek, vagy mit nevezünk malloc,
ez lehetővé teszi, kiosztani valamilyen adatot kívül a készlet.
Szóval, ez az adat a fajta tartósabb az a program időtartama alatt.
Mert mint tudjuk, ha kijelentem x egy függvényen belül, és hogy a függvény,
már nem férhetnek hozzá az adatokhoz, hogy tárolták x.
Milyen mutatók tegyük ők azok, ossza meg velünk tárolni memóriájában vagy boltban értékek
egy más területén emlékezet, azaz a halom.
Most, ha egyszer vissza out funkció, mindaddig, amíg van egy mutató
arra a helyre a memóriában, akkor mit tehetünk mi csak nézd meg az értékeket is.
Nézzünk egy példát: Ez a mi memória elrendezés újra.
És mi van ezt a funkciót, a fő.
Mit csinál ez - oké, olyan egyszerű, igaz? - Int x = 5, ez csak egy változót a verem a fő.
>> Másrészt, most nyilvánítja egy mutató, amely felhívja a funkciót giveMeThreeInts.
És most menj be ezt a funkciót, és hozzon létre egy új verem keret is.
Azonban ebben stack frame kijelentjük, int * temp,
amely mallocs 3 egész számunkra.
Tehát mérete int ad nekünk, hogy hány bájt ez int az,
és malloc ad nekünk, hogy hány bájt helyet a kupac.
Tehát ebben az esetben, hoztunk létre elegendő helyet a 3 egész szám,
és a kupac felfelé van, ezért én lehívott feljebb.
Ha készen vagyunk, akkor gyere vissza ide, csak akkor kell 3 ints vissza,
és visszatér a cím, ebben az esetben, ha több mint hogy az emlékezet.
És mi meg pointer = kapcsolót, és ott van csak egy mutató.
De mi van, hogy a függvény egymásra itt és eltűnik.
Szóval temp eltűnik, de még mindig fenntartja a címét, ahol a
a 3 egészek belső hálózatra.
Tehát ez meg az pointers hatókörű helyileg a halmozott keret,
de a memória, amelyre azok vonatkoznak van a kupac.
>> Van ennek értelme?
[Student] Megismételné? >> [Joseph] Igen.
Szóval ha visszamegyek egy kicsit, akkor láthatjuk, hogy temp kiosztott
némi memóriát a heap odafent.
Tehát, ha ezt a funkciót, giveMeThreeInts visszatér, ez a verem itt fog tűnni.
És azzal bármely változó, ebben az esetben, ez a mutató, amit osztják fel egymásra keretben.
Ez fog tűnni, de amióta visszatért temp
és mi meg pointer = temp, pointer van most megy pont ugyanolyan emlékét helyen temp volt.
Tehát most, még ha elveszítjük temp, hogy a helyi mutató,
még mindig fenntartják a memória cím, hogy mit mutatott a belsejében a változó mutató.
Kérdései vannak? Ez lehet egyfajta zavaros téma, ha még nem ment rajta szakaszban.
Tudjuk, a TF biztosan megy át, és persze tudunk válaszolni a kérdésekre
végén a felülvizsgálat ülés erre.
De ez a fajta egy összetett téma, és én már több példa, hogy fog megjelenni
, ami segít tisztázni, mi pointers valójában.
>> Ebben az esetben a pointerek egyenértékűek a tömbök,
így tudom csak használni ezt a mutatót, mint ugyanaz a dolog, mint egy int tömb.
Szóval indexálásának a 0, és megváltoztatja az első értéke 1,
megváltoztatja a második integer 2-re, és a 3. egész szám 3-ra.
Tehát inkább a mutatók. Nos, emlékszem Muci.
Ebben az esetben is kiosztott egy mutató, vagy mi nyilvánítsák mutató,
de kezdetben, amikor csak nyilvánítsák mutatót, ez nem mutat bárhol a memóriában.
Ez csak szemét értékei benne.
Szóval fogalmam sincs, hol ez a mutató mutat.
Meg van egy cím, amely éppen tele 0-val és 1-es, ahol azt eredetileg bejelentették.
Nem tudok mit kezdeni ezzel, amíg nem hívja malloc rajta
és akkor ad nekem egy kis hely a heap ahol tudok tenni értékeket belül.
Aztán megint, nem tudom, mi van benne a memória.
Tehát az első dolog, amit meg kell tennie, hogy ellenőrizze, hogy a rendszer már elég memória
hogy adjon nekem vissza 1 egész az első helyen, ezért csinálom ezt ellenőrizze.
Ha a mutató nulla, ami azt jelenti, hogy nem volt elég hely, vagy más hiba lépett fel,
úgyhogy kell lépni az én program.
De ha mégis sikerül, most már tudom használni, hogy a pointer
és mi * mutató csinál, ebből az következik, ha a cím
, ahol ez az érték, és ez határozza meg, hogy 1-gyel egyenlő.
Szóval ide, mi ellenőrizni kell, hogy a memória létezett.
>> Ha már tudja, hogy létezik, akkor tegye bele
milyen értéket akarsz tenni bele, ebben az esetben 1.
Ha végeztünk vele, meg kell szabadítani, hogy a mutató
mert vissza kell mennem a rendszerbe, hogy az emlékezet, amit kértek, az első helyen.
Mivel a számítógép nem tudja, mikor végeztünk vele.
Ebben az esetben mi kifejezetten mondom, oké, készen vagyunk ezzel a memória.
Ha más folyamat szüksége van, egy másik program szüksége van rá, nyugodtan menjen előre, és vedd el.
Amit mi is tennie, hogy mi csak kap címét lokális változók a forgatáson.
Szóval int x belül van egymásra keret fő.
És amikor ezt a jelet, ez és az üzemeltető, hogy mit csinál,
tart x, x, mindössze néhány adatot a memóriában, de van egy cím.
Ez található valahol. Tehát hívás és x, hogy ez mire jó ez ad nekünk a címét x.
Ezáltal tesszük mutató pont, ahol x a memóriában.
Most már csak valami ilyesmit * x, fogunk kap 5 vissza.
A csillag neve dereferencing meg.
Azt követi a cím és a kap az értékét, hogy az ott tárolt.
>> Van még kérdése? Igen?
[Student] Ha nem teszed a 3-hegyes dolog, nem is mindig összeállításához?
Igen. Ha nem teszed a 3-as mutató dolog, ez még mindig tart összeállítására,
de én megmutatom, hogy mi történik a második, és anélkül, hogy, hogy a
ez az, amit nevezünk memóriavesztés. Te nem így a rendszer
vissza a memóriába, így egy idő után a program fog felhalmozni
memóriát, hogy ez nem használ, és semmi más nem tudja használni.
Ha valaha is látott Firefox 1,5 millió kilobyte-os számítógép,
A feladatkezelő, ez az, ami folyik itt.
Van egy memóriavesztés a program, hogy ők nem szállítanak.
Szóval, hogyan működik pointer aritmetikai munkát?
Nos, pointer aritmetika fajta, mint indexelő egy tömb.
Ebben az esetben van egy mutatót, és amit csinálok teszek mutató pont az első elemet
E tömb 3-egészek, hogy én már kiosztották.
Akkor most mit csináljak, star mutató csak megváltoztatja az első elem a listában.
Csillagok pointer +1 pont ide.
Szóval mutató ide, mutató 1 fölött van itt, pointer 2 van itt.
>> Szóval, csak hogy 1 ugyanaz a dolog, mint mozgó mentén tömbben.
Mit teszünk akkor, amikor mi pointer 1 megkapod a címet ide,
és annak érdekében, hogy az érték itt, hogy egy csillag az egész kifejezés
A dereference meg.
Tehát ebben az esetben én amelyben az első helyen ebben a tömbben 1,
második helyen a 2, és a harmadik hely 3-ra.
Akkor mit csinálok ide az én nyomtat a mutató +1,
ami csak ad nekem 2.
Most növelésének mutató, így a mutató értéke mutató +1,
ami mozog előre.
És most, ha ki kell nyomtatni mutató +1, 1 mutató most 3,
ami ebben az esetben kinyomtatja 3.
És annak érdekében, hogy szabad valamit, a mutatót, hogy én, hogy ez
kell mutatniuk elején a tömbben, mely kaptam vissza malloc.
Tehát ebben az esetben, ha én hívni 3 itt, ez nem lehet igaz,
mert a közepén a tömbben.
El kell levonni, hogy az eredeti helyére
A kezdeti első helyre, mielőtt szabadíthat meg.
Szóval, itt van egy nagyobb szerepet példa.
Ebben az esetben, mi elosztása 7 karakter egy karakter tömbben.
>> És ebben az esetben, hogy mit csinálunk a mi hurok az első 6 őket,
és mi beállítás, hogy Z.
Így int i = 0, i> 6, i + +,
Szóval, pointer + én majd csak nekünk, ebben az esetben,
mutató, mutató +1, mutató +2, mutató 3, és így tovább, és így tovább a hurok.
Mit fog csinálni ez lesz ezt a címet, dereferences azt, hogy az érték,
és módosításokat értéket a Z.
Aztán a végén emlékszik ez egy string, ugye?
Minden strings kell, hogy vessen véget a lezáró null karaktert.
Szóval, mit csinálok a mutató 6 tettem a null terminátor karakter be
És most mit csinál itt tulajdonképpen hajt végre printf egy string, ugye?
>> Tehát, ha nem printf most, amikor ez elérte a végét a húr?
Amikor eléri a lezáró null karaktert.
Tehát ebben az esetben az eredeti mutató a tömb elején.
Én kinyomtatni az első karakter ki. Úgy helyezze át egy.
Nyomtatásakor a karakter ki. Úgy helyezze át.
És én csinálom ezt, amíg azt elérjük a végét.
És most a végén * pointer lesz dereference ezt, és kap a null lezáró karakter vissza.
És így a while ciklus fut, csak akkor, ha ez az érték nem null lezáró karaktert.
Szóval, most lépjen ki ebből a hurok.
És ha kell vonni 6 e mutató,
Megyek vissza egészen az elején.
Ne feledje, hogy én csinálom ezt, mert el kell menni az elején annak érdekében, hogy kiszabadítsa azt.
>> Szóval, tudom, hogy volt egy csomó. Van kérdés?
Kérlek, ugye?
[Student kérdés értelmetlen]
Tudsz mondani, hogy hangosabban? Bocsánat.
[Student] Az utolsó dia jobbra, mielőtt kiszabadította a mutatót,
ahol arra valóban értékének megváltoztatásáról a mutató?
[Joseph] Szóval, itt van. >> [Student] Ó, oké.
[Joseph] Szóval, van egy mutató mínusz mínusz, igaz,
ami mozog a dolog hát egyet, és aztán szabad azt,
mert ez a mutató ki kell emelni, hogy az elején a tömbben.
[Student] De ez nem szükséges már abbahagyta ezt követően sor.
[Joseph] Szóval, ha én már nem ez után, ez tekinthető memóriavesztés,
mert nem fut az ingyenes.
[Student] I [érthetetlen], miután az első három sor, ahol meg kellett mutató +1 [érthetetlen].
[Joseph] Uh-huh. Szóval, mi a kérdés ott van?
Bocsánat. Nem, nem. Menj, menj, kérlek.
[Student] Szóval, te nem változó értékét mutató.
Akkor nem kellett volna tennie mutató mínusz mínusz.
[Joseph] Igen, pontosan.
Szóval, amikor én mutató +1 és mutató +2,
Nem csinálok mutató értéke mutató +1.
Így a mutató csak marad mutatott elején a tömbben.
Ez csak akkor tudom, plusz, plusz, hogy meghatározza az értéket vissza a házba a mutatót,
hogy ténylegesen mozog ezen mentén.
Rendben van.
További kérdések?
>> Ismét, ha ez a fajta elsöprő, ez fedezi az ülésen.
Kérdezze meg a tanítás más róla, és mi lehet válaszolni a kérdésekre a végén.
És általában mi nem tetszik, hogy ezt mínusz dolgot.
Ez megkövetelni számomra, hogy nyomon követhetőek, mennyi, amit ellensúlyozott a tömbben.
Szóval, általában ez csak megmagyarázni, hogyan mutató számtani működik.
De mi van, mi általában szeretnénk tennie szeretnénk létrehozni egy példányt a mutatót,
és aztán ezt a példányt használhatja, amikor mi mozog a húr.
Szóval, ezek az esetben, ha a másolat felhasználásával nyomtassa ki a teljes szöveget,
de nem kell tennie, mint a mutató mínusz 6, illetve nyomon követhetjük, hogy mennyire mozgott ebben,
csak azért, mert tudjuk, hogy az eredeti pontot is rámutatott, hogy az elején a lista
és minden, amit megváltoztatni volt ez a példány.
Tehát általában megváltoztathatja másolatot az eredeti mutató.
Ne próbálja meg rendezni a hasonló - ne változtassa eredeti példányban.
Próbálok változtatni csak a másolatot az eredeti.
Szóval, azt veszi észre, amikor átadjuk a string printf
nem kell, hogy egy csillag előtte, mint tettük az összes többi dereferences, ugye?
Tehát, ha nyomtassa ki az egész szöveget% s vár egy cím,
és ebben az esetben egy mutató vagy ebben az esetben, mint egy sor karakter.
>> Színészek, char * s, és a tömbök ugyanaz a dolog.
Pointer, hogy karakter, és a karakter tömbök ugyanaz a dolog.
És így minden, amit meg kell tennie, hogy adja át a mutató.
Nem kell átadni, mint a * mutató, vagy ilyesmi.
Szóval, tömbök és mutatók is ugyanaz a dolog.
Ha csinálsz valami ilyesmit x [y] ide egy tömb,
mit csinál a motorháztető alatt van mondja, oké, ez egy karakter tömb,
így ez a mutató.
És így x is ugyanaz a dolog,
és így mit csinál ez növeli y az x,
ami ugyanaz, mint halad előre a memóriában, hogy sok.
És most x + y ad valamiféle cím,
és mi dereference a címet, vagy kövesse a nyíl
hogy ha ez a hely a memória, és megkapjuk az értéket ki ezen a helyen a memóriában.
Szóval, így ez a két pontosan ugyanaz a dolog.
Ez csak egy szintaktikai cukor.
Ez nem ugyanaz a dolog. Ők csak más syntactics egymásnak.
>> Szóval, mi baj a mutató? Mint sok. Oké. Szóval, a rossz dolgokat.
Vannak rossz dolgok, amit tehetünk, nem ellenőrzi, ha a malloc hívás visszatér null, igaz?
Ebben az esetben, azt kérem, hogy a rendszer ad nekem - mi ez a szám?
Mint a 2 milliárd alkalommal 4, mert a mérete egész szám 4 bájt.
Azt kérdeztem azt mint 8 milliárd bájt.
Természetesen a számítógép nem lesz képes adni nekem, hogy sok memóriát vissza.
És mi nem ellenőrizte, ha ez nulla, így amikor megpróbáljuk dereference hogy ott -
kövesse a nyilat, ahol ez lesz - nincs, hogy a memória.
Ezt hívjuk dereferencing egy null pointer.
És ez lényegében azt okozza, hogy segfault.
Ez az egyik módja lehet segfault.
További rossz dolog, amit tehetünk - hát igen.
Ez volt dereferencing egy null pointer. Oké.
Egyéb rossz dolgok - nos, hogy rögzíti, hogy az imént egy csekket ott
hogy ellenőrzi, hogy a mutató értéke null
és lépjen ki a program, ha ez történik, hogy a malloc vissza null pointer.
Ez a xkcd képregény. Az emberek megértik most. Olyasmi.
>> Szóval, memória. És mentem át ezt.
Mi hívja malloc egy hurok, de minden alkalommal hívjuk malloc
vagyunk vesztes pályán, ahol ez a mutató mutat,
mert mi felülírja azt.
Szóval, az első hívás malloc ad nekem memória ide.
Erre mutató mutatókat ezt.
Nos, én nem szabadít meg, így most hívom malloc újra.
Most mutat ide. Most a memóriát mutat ide.
Egér ide. Egér ide.
De elvesztettem pályán a címeket az összes memóriát ide, hogy én különítettek el.
És így most nem kell semmiféle utalást rájuk többé.
Szóval, nem tudom kiszabadítani őket kívül a hurok.
Így annak érdekében, hogy rögzítse ilyesmit,
Ha elfelejtette a szabad memória és megkapod ezt memóriavesztés,
Meg kell szabadítani a memória belsejében loop miután végeztél vele.
Nos, ez az, ami történik. Tudom, hogy sok utálod ezt.
De most - yay! Kapsz mint 44.000 kilobyte.
Szóval szabad a végén a hurok,
és ez megy, csak szabad a memória minden alkalommal.
Lényegében a program nincs memóriavesztés többé.
>> És most valami más, amit tehetünk, szabadítson fel memóriát, amit kért kétszer.
Ebben az esetben, ha malloc valamit, meg nem változtatja az értékét.
Ingyen egyszer, mert azt mondta, hogy végeztem vele.
De aztán kiszabadította újra.
Ez olyan dolog, hogy elég rossz.
Ez nem fog kezdetben segfault,
de egy idő után, hogy ez mit jelent a kettős szabadít ezt megrontja a kupac szerkezetét,
és akkor tanulni egy kicsit többet erről, ha úgy dönt, hogy egy osztály, mint a CS61.
De lényegében egy idő után a számítógép megy összezavarodnak
mi memória helyek, ahol és amennyiben ez tárolják -
ahol az adatok a memóriában tárolódnak.
És így felszabadítva egy mutatót kétszer olyan rossz dolog, amit nem akarsz.
>> Más dolog, hogy a rosszra nem használja sizeof.
Tehát ebben az esetben malloc 8 byte,
és ez ugyanaz, mint a két egész szám, ugye?
Szóval, ez tökéletesen biztonságos, de ez?
Nos, mint Lucas beszélt különböző architektúrák,
egészek különböző hosszúságú.
Szóval, az a készülék, hogy az Ön által használt, egészek mintegy 4 byte,
de más rendszerben ezek lehetnek 8 byte vagy azok lehetnek 16 bájt.
Tehát, ha csak ezt a számot ide,
ez a program is működik a készülék,
de ez nem lesz elegendő memóriát valamilyen más rendszer.
Ebben az esetben, ez az, amit a sizeof operátor használják.
Mikor hívjuk sizeof (int), hogy ez mire is
ad nekünk a mérete integer a rendszer, hogy a program fut.
Tehát ebben az esetben, sizeof (int) ad vissza 4 valami, mint a készülék,
és most ez az akarat 4 * 2, amely 8,
ami csak meg, mekkora hely szükséges a két egész szám.
Egy másik rendszer, ha egy int, mint 16 bájt vagy 8 bájt,
ez csak fog visszatérni ahhoz byte tárolni ezt az összeget.
>> És végül, struktúrákat.
Tehát, ha akarta, hogy tárolja a sudoku tábla a memória, hogyan lehet ezt megtenni?
Azt hihetnénk, hogy olyan, mint egy változó, az első dolog,
változó a második dolog, egy változó a harmadik dolog,
változó a negyedik dolog - rossz, igaz?
Szóval, egy javulás akkor lehet, hogy a tetején ez, hogy egy 9 x 9 tömb.
Ez rendben van, de mi van, ha akarta társítani más dolgokat a sudoku tábla
tetszik, amit nehéz a tábla,
vagy például, mi a pontszám, vagy mennyi idő ez hozott megoldani ezen a fórumon?
Nos, hogy mit tehetünk, akkor létrehozhat egy struct.
Amit tulajdonképpen mondani, én ezt a struktúrát meghatározó ide,
és én vagyok meghatározása sudoku tábla, amely egy fórumon, hogy a 9 x 9.
>> És mi van azt mutatókat a nevét a szintet.
Azt is x és y, amelyek a koordinátái, ahol én most.
Azt is időt [érthetetlen], és azt a teljes számú mozog, amit bevisszük eddig.
És ebben az esetben, tudok csoportosítani egy csomó adatot csak egy szerkezet
ahelyett, hogy, mint a repülő körül, mint a különböző változók
hogy nem tudok igazán nyomon követni.
És ez lehetővé teszi számunkra, hogy csak szép szintaxist fajta hivatkozás különböző dolgok belsejében struct.
Én csak ezt board.board, és megkapom a sudoku tábla vissza.
Board.level, értem, milyen kemény ez.
Board.x board.y és add nekem a koordinátáit, ahol lehet a fórumon.
És így én hozzáférés hívjuk a mezőket struct.
Ez határozza meg sudokuBoard, amely egy olyan típusú, hogy van.
És most itt vagyunk. Nekem van egy változó úgynevezett "board" típusú sudokuBoard.
És így most már hozzáférhet az összes mezőt, hogy töltsük fel ezt a struktúrát ide.
>> Bármilyen kérdése struktúrákat? Igen?
[Student] Az int x, y, akkor kijelentette, mind egy sorban? >> [Joseph] Uh-huh.
[Student] Szóval, lehet csak megtenni az összes velük?
Mint x, y vessző-szor, hogy a teljes?
[Joseph] Igen, akkor biztosan nem, de azért tettem x és y ugyanabban a sorban -
és az a kérdés, hogy miért mi csak ezt ugyanabban a sorban?
Miért nem az imént mindezen ugyanabban a sorban van
x és y kapcsolódnak egymáshoz,
és ez még csak stilisztikailag inkább helyes, abban az értelemben,
mert ez csoportosítására két dolgot ugyanabban a sorban
hogy mint egyfajta kapcsolódnak a ugyanaz a dolog.
És én csak megosztani ezeket egymástól. Ez csak egy stílus dolog.
A funkcionálisan nincs különbség nélkül.
Bármely más kérdésre struktúrákat?
Megadhatunk egy Pokédex egy struct.
A Pokémon egy számot, és azt a levelet, a tulajdonos, a típus.
És ha van egy sor Pokémon, tudod, hogy egy Pokédex, ugye?
Oké, király. Szóval, kérdések struktúrákat. Ezek kapcsolatos struktúrákat.
>> Végül a GDB. Mit jelent a GDB engedi csinálni? Ez lehetővé teszi, hibakeresés a program.
És ha még nem használta GDB, azt javasolta nézni a rövid
és csak megy, hogy mit GDB, hogyan dolgozik vele, hogyan lehet használni,
és tesztelni azt a program.
És mi GDB segítségével tennie, ez lehetővé teszi, szüneteltetheti a [érthetetlen]-ig a program
és gyakorlati vonal.
Például, azt akarom szüneteltetni végrehajtást, mint 3-as vonal az én program,
és míg én vagyok a 3. sorban tudom kinyomtatni az összes értékek vannak.
És amit mi, mint szüneteltetése sorban
A hívjuk ezt amivel egy töréspont az adott vonal
és akkor nyomtassa ki a változók állapotát a program abban az időben.
>> Tudunk majd onnan végig a programot line-by-line.
És akkor nézd meg az állam a stack idején.
És így használata érdekében GDB, mit teszünk, hívjuk csenget a C fájlt,
de van, hogy adja át a-ggdb zászló.
És ha mi történik, hogy csak fut gdb a kapott kimeneti fájl.
És így kapsz néhány hasonló tömegű szövegben, mint ez,
de tényleg csak annyit kell tennie, hogy írja be a parancsokat az elején.
Szünet fő helyez töréspont a fő.
List 400 felsorolja a sornyi kódot körül sor 400.
És ebben az esetben, ha csak körülnézel, és azt mondják, ó,
Szeretném beállítani a töréspont sorban 397, ami ezen a vonalon,
majd a program fut be ezt a lépést, és ez fog törni.
Ez lesz szünet van, és akkor ki kell nyomtatni, például értéke alacsony vagy magas.
És van egy csomó parancsok, amit tudnod kell,
és ez a diavetítés megy fel a honlapon,
így ha csak azt, hogy hivatkozni ilyen, vagy hasonló tedd a cheat lapok, nyugodtan.
>> Cool. Ez volt Quiz Beszámoló 0, és mi sehova, ha bármilyen kérdése van.
Rendben van.
>> [Taps]
>> [CS50.TV]