[Zenelejátszási]
>> DOUG LLOYD: OK, így egy javaslat megkezdése előtt itt.
Ha még nem nézte a videót mutatókat érdemes megtenni az első.
Mivel ez a videó egy másik munkamódszer a mutató.
>> Így fog beszélni néhány fogalmak
hogy fedezze a pointerek videó, és mi vagyunk
megy elkendőz őket most, feltételezve, hogy ők már
fajta érteni.
Szóval ez csak a tisztességes figyelmeztetést hogy ha látja ezt a videót
és akkor még nem látta a mutatók videó, talán valamiféle
repülnek a feje fölött egy kicsit.
És ez így talán jobb nézni, hogy ebben a sorrendben.
>> Így már láttuk az egyik munkába mutatókkal,
ami azt nyilvánítja változó, és akkor
Kijelentem, egy másik változó, egy mutatót változó, hogy pont azt.
Szóval írtunk egy változó névvel, most már
létrehozott egy második változó névvel, és akkor pont, hogy a második változó
abban az első.
Ez a fajta van probléma azonban, mert
megköveteli tőlünk, hogy pontosan tudja, mennyi memóriát vagyunk
Szükségünk lesz a pillanatot A program összeállítása.
>> Miert van az?
Mert kell, hogy képes megnevezni, vagy azonosíthatja a lehetséges változókat
mi is találkozhat.
Talán van egy tömbben, hogy lehet tudja tartani a sok információ,
de ez még mindig nem Pontosan elég pontos.
Mi van, ha nem tudjuk, mi van, ha fogalmunk sincs,
mennyit kell majd fordításkor?
Vagy mi van, ha a program futni egy nagyon hosszú idő,
elfogadó különböző felhasználói adatokat, és nem tudjuk igazán
megbecsülni, hogy mi vagyunk Szükségünk lesz 1000 egység?
>> Nem olyan, mint tudjuk mondjuk a parancssorban
írja, hogy hány elem Ön szerint lesz szüksége.
Hát mi van, ha hisz van baj?
Memória dinamikus fajta lehetővé teszi számunkra az utat
kap körül ezt a problémát.
És ahogy ez meg a segítségével mutatók.
>> Tudjuk használni mutatókat kap hozzáférést dinamikusan
memóriát, memória, amely felosztani a program fut.
Ez nem osztottak fordításkor.
Ha dinamikusan osztja memória jön egy medencében
memória néven ismert a kupac.
Korábban az összes memóriát voltunk óta dolgozik során
már jön a pool memória néven ismert verem.
Egy jó módja annak, hogy általában tartsd mind-- és ez a szabály
nem mindig igaz, de elég sok szinte
Mindig tartja true-- az, hogy minden időt adsz egy változó nevét
Valószínűleg él a verem.
És minden alkalommal, amikor nem hogy a változó nevét,
amit tehetünk a dinamikus memória elosztása, hogy él a kupac.
>> Most én vagyok ilyen bemutató ezt ha van a két medence a memória.
De lehet, hogy látta ezt diagram, amely általában
ábrázolását milyen memória néz ki,
és mi nem fog törődni az összes A cucc a tetején és az alján.
Mi törődünk az a részt középen van, halomból és verem.
Mint látható a nézi ezt a diagramot,
ezek valójában nem két külön medencék a memória.
Ez egy megosztott medence memória ahol elkezdi, ezen a vizuális
elkezdi alján és elkezd kitöltésével
alulról a verem, és indítsa el a felső és elkezd kitöltésével
felülről lefelé, a kupac.
De ez tényleg a tudatban, hogy ez csak
különböző helyeken, különböző helyeken a memóriában, hogy a jelenleg kiosztott.
És akkor elfogy a memória, vagy úgy,
a kupac megy végig az alsó, vagy
A verem menni egészen a csúcsra, vagy amelynek a halomból és a veremből
találkozhatnak egymással.
Az összes ilyen lehet feltételei hogy okozhat a programban
hogy elfogy a memória.
Tehát hogy tartsa szem előtt.
Amikor arról beszélünk, A halomból és a veremből
mi valóban beszél a Ugyanez az általános darab memóriát, csak
különböző részeit, hogy a memória.
>> Szóval hogyan jutunk dinamikusan memóriát az első helyen?
Hogyan tud a programunk kap memória, ez fut?
Nos C nyújt olyan függvény is malloc, memóriafoglaló, amely
egy hívást, hogy, és adja át a hány bájt memóriát, amit akar.
Tehát, ha a program futása és szeretne egy egész szám runtime,
lehet, hogy Mallock négy bájt memória, malloc zárójelben négy.
>> Mallock megy keresztül átnéz a kupac,
mert mi vagyunk dinamikusan memórialefoglalás,
és ez vissza fog térni hozzád egy mutató, hogy az emlékezet.
Nem adja azt a memory-- nem adja meg a nevét,
ez ad egy mutatót hozzá.
És ez az, amiért újra azt mondtam hogy ez fontos lehet,
nézte a mutató videó mielőtt túl messzire ebbe.
Tehát malloc fog kapsz vissza a mutató.
>> Ha Mallock nem ad semmiféle memóriát, mert már elfogyott,
ez ad vissza egy null pointer.
Emlékszel, mi történik, ha megpróbálja hivatkozás feloldási egy null pointer?
Szenvedünk egy seg hiba, ugye?
Ez talán nem jó.
>> Tehát minden alkalommal, amikor hívást malloc mindig, mindig
ellenőriznie kell, függetlenül attól, hogy a pointer ez adta vissza null.
Ha igen, meg kell, hogy vessen véget a program, mert ha megpróbálod dereference
A null pointer fogsz szenvedni szegmens hiba
és a program fog zuhanni egyébként.
Szóval hogyan statikusan szerezni egy egész szám?
>> int x.
Mi már valószínűleg megtette egy csomó idő, ugye?
Ez létrehoz egy változót nevű x él a verem.
Hogyan dinamikusan kap egy egész szám?
Int csillagos px egyenlő malloc 4.
>> Vagy megfelelőbben azt mondanám, int csillagos px
egyenlő malloc mérete int, Csak nem árt néhány kevesebb
mágikus számok körül a programunk.
Ez fog szerezni nekünk négy bájt memóriát a kupac,
és a mutatót kapunk vissza az úgynevezett px.
Aztán ahogy voltunk korábban megtették azt
lehet követéssel px, hogy elérheti, hogy a memória.
Hogyan jutunk értéke a felhasználó?
Elmondhatjuk, int x = int kap.
Ez elég egyértelmű.
Mi van, ha azt akarjuk, hogy hozzon létre egy tömböt Az X úszók, hogy él a stack?
lebegnek stack_array-- ez a neve a mi array-- szögletes zárójelben x.
Amely megteremti számunkra egy tömböt Az X úszók, hogy él a verem.
Mi is létrehozhatunk egy tömböt az úszók hogy él a kupac is.
A szintaxis tűnhet egy kicsit nehézkes,
de azt mondhatjuk, úszó csillagos heap_array egyenlő
malloc x-szer akkora, mint az úszó.
Szükségem van elég hely, hogy tartsa x lebegőpontos értékek.
Tehát mondjuk van szükségem 100 úszók, vagy 1000 úszik.
Tehát ebben az esetben nem lenne 400 bájt 100 úszók,
vagy 4000 byte 1000 úszik, mert minden úszó vesz fel
négy bájt területet.
>> Miután ezt tudom használni a szögletes zárójel szintaxist heap_array.
Mint ahogy azt tenné stack_array, én elérheti az elemeit egyenként
segítségével heap_array nulla, heap_array egyet.
De emlékszem az oka, amit tehetünk, hogy azért van, mert a tömb neve a C
valóban egy mutató, tömb első eleme.
Tehát az a tény, hogy mi nyilvánító tömb úszik a verem itt
valójában egy kicsit félrevezető.
Mi tényleg a második sor kódot ott
is létre mutató egy darab memória, amit majd némi munkát.
>> Itt van a nagy probléma dinamikusan lefoglalt memória ellenére,
és ez az, amiért ez tényleg Fontos, hogy dolgozzon ki jó szokások
amikor dolgozik vele.
Ellentétben statikusan deklarált memória, a memória
automatikusan nem tért vissza a rendszer, ha a funkciót történik.
Tehát ha van a fő és Fő meghív egy függvényt
f, ha f befejezi, amit csinál és visszaadja a vezérlést a program
vissza a fő, mind a memória hogy az alkalmazott f adják vissza.
Ezt fel lehet használni újra valamilyen másik program,
vagy valami más, meghívásra kerül később a fő.
Meg tudja használni, hogy ugyanaz a memória újra.
>> Ha dinamikusan memóriát lefoglalni bár
akkor erre figyelmeztetnünk kell a rendszer, hogy te mit kezdeni vele.
Ez lesz kapaszkodj meg az Ön számára, ami vezethet probléma akkor fogy
a memória.
És valóban néha olvassa hogy ezt a memóriavesztés.
És néha ezek a memóriavesztés is lehet igazán megsemmisítő
a rendszer teljesítményét.
>> Ha Ön gyakori internet felhasználó lehet használni bizonyos böngészők,
és nem fogok neveket itt, de van néhány böngészők odakinn
hogy a hírhedt, hogy ténylegesen memóriavesztés, hogy soha nem lesz újra.
És ha hagyjuk nyitva a böngészőt egy nagyon hosszú ideig, napok
és napok, vagy hetek, néha Előfordulhat, hogy a rendszer
fut nagyon, nagyon lassan.
És az oka, hogy az, hogy a A böngésző memóriát,
de aztán nem mondtam a rendszer hogy kell ezt csinálni vele.
És úgy, hogy kevesebb memória rendelkezésre álló összes többi program
hogy meg kell osztanom, mert te leaking-- hogy webböngésző
programot szivárog a memória.
Hogyan adjuk memória vissza ha végeztünk vele?
Nos szerencsére ez egy nagyon könnyű utat megtenni.
Mi csak kiszabadítani.
Van egy funkció úgynevezett szabad, elfogadja a mutatót a memória,
és mi még jól jöhet.
>> Tehát mondjuk mi vagyunk a közepén a programunk,
akarunk malloc 50 karakter.
Azt akarjuk, hogy malloc egy tömb, amely képes a gazdaság 50 karakter.
És ha eljutunk egy mutatót vissza hogy ez a mutató neve szó.
Mindent megteszünk azért vagyunk fog csinálni szó,
majd mikor vagyunk tenni mi csak kiszabadítani.
És most vissza azokat a 50 byte memóriát vissza a rendszer.
Néhány egyéb funkció is használja őket.
Nem kell aggódnia szenvedett memóriavesztés, mert már felszabadult szó.
Már adott a memóriát vissza, így készen vagyunk vele dolgozni.
Szóval van három aranyszabálya, hogy amennyiben
Szem előtt kell tartani, amikor te dinamikusan memórialefoglalás
a malloc.
Minden blokk memória Ön malloc kell szabadítani
mielőtt a programot lefutott.
Most ismét a készüléket, vagy a IDE ez a fajta történik veled
ha you-- ez meg fog történni egyébként amikor a program befejeződik,
az összes memóriát fog megjelenni.
De ez általában jó kódolás gyakorlatot, hogy mindig, ha végeztél,
felszabadítani, amit mallocd.
>> Igaz, egyetlen dolog, ami akkor már mallocd meg kell szabadítani.
Ha statikusan hirdessen integer, int x pontosvessző,
hogy él a verem, akkor Nem akkor szeretne felszabadítani x.
Tehát csak a dolgok, hogy már mallocd meg kell szabadítani.
>> És végül, nem szabad valamit kétszer.
Ez ahhoz vezethet, hogy Egy másik furcsa helyzet.
Szóval mindent, hogy már mallocd kell szabadítani.
Csak a dolgok, hogy már malloc meg kell szabadítani.
És ne szabad valamit kétszer.
>> Szóval menjünk át egy példa itt amit néhány dinamikusan kiosztott
memória nézhet vegyes A néhány statikus memória.
Mi fog történni itt?
Nézd meg, hogy kövesse mentén, és kitalálni, mi van
fog történni, ahogy haladunk végig ezeket a sorokat a kód.
>> Tehát azt mondjuk int m.
Mi történik itt?
Hát ez elég egyértelmű.
Én hozzon létre egy egész változó nevű m.
Én színt is zöld, mert ez a szín
hogy tudom használni, amikor hozzád beszélek mintegy integer.
Ez egy dobozban.
Úgy hívják m, és akkor áruház egész belsejébe.
>> Mit tegyek, ha majd azt mondják int csillag?
Hát ez elég hasonló.
Hozok létre egy doboz úgynevezett.
Ez képes a gazdaság int csillagok, mutatókat egészek.
Úgyhogy színezés meg a zöld-szerű is.
>> Tudom, hogy van valami köze egy egész szám,
de ez önmagában nem egész szám.
De ez nagyjából ugyanaz a gondolat.
Létrehoztam egy dobozban.
Mindkét jobbra most él a verem.
Én adtam nekik mindkét nevet.
>> int csillagos b egyenlő malloc mérete int.
Ez az egyik lehet egy kicsit trükkös.
Vegyünk egy második és gondolni, amire elvárná, hogy történni ezen rajz.
int csillagos b egyenlő malloc mérete int.
>> Hát ez nem csak készíts egy dobozban.
Ez tulajdonképpen létrehoz két doboz.
És ez köti, ez is megállapítja egy pont egy kapcsolatban.
Már kiosztott egy blokk A memória a kupac.
Figyeljük meg, hogy a jobb felső mezőben ott nem volt neve.
>> Mi mallocd meg.
Létezik, a kupac.
De b van neve.
Ez egy mutató változó nevű b.
Hogy él a verem.
>> Tehát ez egy darab memória rámutat, hogy a másikat.
b tartalmazza a cím hogy a blokk memória.
Ez nem volt neve különben.
De az mutat rá.
Tehát amikor azt mondjuk int csillagos b egyenlő malloc mérete int, hogy ott,
hogy nyílra bukkant fel a jobb oldalon van, az az egész dolog,
Meglesz jelennek meg újra, hogy mi történik.
Minden, ami történik hogy egy sor kódot is.
Most mi lesz kicsit több egyszerű újra.
Egy egyenlő jelet m.
Emlékszik, milyen egyenlő jelet m?
Hát ez egy kap m címét.
Vagy hogy még több vázlatosan, Egy pont a m.
>> Egy egyenlő b.
OK így itt van még egy.
A egyenlő B.
Mi fog történni A rajz ebben az időben?
>> Nos emlékeztetnek arra, hogy a értékadó operátor munkák
értékét hozzárendeljük a jogot, hogy az érték a bal oldalon.
Így ahelyett, hogy egy mutató m, a most rámutat, hogy ugyanazon a helyen, hogy b pont.
Egy nem jellemző a B, a rámutat, ahol b pont.
>> Ha egy hegyes, hogy b, amely már egy egyenlő jelet b.
De ahelyett, hogy egy egyenlő b csak azt jelenti, hogy a és b most
rámutatva, hogy ugyanaz a címe, mert belsejében B mindössze egy címet.
És most belsejében egy azonos címet.
m = 10, valószínűleg a legegyszerűbb dolog
tettünk egy kicsit.
Tegye a 10 a dobozban.
Csillagok b egyenlő m plusz 2, előhívni a mutatók videó, amit csillagos b jelenti.
Fogunk követéssel, b, és tegye bizonyos értéket, hogy memóriába.
Ebben az esetben a 12.
>> Tehát amikor követéssel, egy pont a emlékszem mi csak utazik le a nyíl.
Vagy másképpen fogalmazva, mi megy, hogy a memória cím
és mi manipulálni, hogy valamilyen módon.
Azt hogy néhány érték ott.
Ebben az esetben a csillag b egyenlő m plusz 2 csak
megy a változó által mutatott b, megy a memória által mutatott b,
és tedd m plusz 2 odabent, 12.
>> Most ingyen b.
Mi történik, ha szabad b?
Emlékszel, mit mondtam ingyenes eszközöket.
Mit mondok mikor szabad b?
>> Végeztem vele dolgozni, ugye?
Én alapvetően adja fel a memóriát.
Azt adja vissza a rendszer.
Nem kell többé ezt a amit mondok nekik, OK?
>> Most, ha azt mondom, csillag egyenlő 11 akkor talán
már mondani, hogy valami rossz fog történni itt, ugye?
És valóban, ha megpróbáltam, hogy én valószínűleg szenvedne szegmens hiba.
Mert most, bár korábban, hogy darab memória
Volt valami, ami volt hozzáférést, ezen a ponton
most én vagyok a memóriakártya elérésekor, hogy nem legális számomra eléréséhez.
>> És ahogy valószínűleg emlékszem, amikor elérheti memória
hogy nem kéne, hogy megérintse, ez a leggyakoribb oka
A szegmentáció hibája. És így a programot
lezuhan, ha megpróbáltam csinálni.
Tehát ismét egy jó ötlet, hogy jó gyakorlatot és a jó szokások beleivódott
ha dolgozik, malloc és free, úgy, hogy nem szenvednek szegmentáció
hibák, és hogy használjon A dinamikusan kiosztott
memória felelősségteljesen.
>> Én Doug Lloyd ez CS50.