[Mūzikas atskaņošanai]
>> Doug LLOYD: Labi, tāpēc ieteikums pirms sākas šeit.
Ja neesat noskatījos video norādes jūs varētu vēlēties darīt vispirms.
Tāpēc, ka šis video ir vēl viens veids, kā strādāt ar norādes.
>> Tātad, tas notiek, lai runātu par dažiem jēdzieniem
ka mēs apdrošināt norādes video, un mēs esam
gatavojas spīdums pār viņiem tagad, pieņemot, ka viņi jau
veida saprata.
Tātad tas ir tikai jūsu godīgi brīdinājums ka, ja jūs redzēt šo video
un neesat redzējuši norādes video, tas varētu veida
lidot virs galvas mazliet.
Un tā tas varētu būt labāks skatīties tā minētajā secībā.
>> Tātad mēs jau esam redzējuši vienu veids, kā strādāt ar norādes,
kas ir mēs deklarēt mainīgs, un tad mēs
atzīt citu mainīgo, rādītāju mainīgais, kas norāda uz to.
Tāpēc mēs esam izveidojuši mainīgs ar nosaukumu, mēs esam
izveidoja otru mainīgo ar nosaukumu, un mēs norāda, ka otrais mainīgais
Tajā pirmo reizi.
Šī veida has a problēma, lai gan, jo tas
prasa, lai mēs precīzi zinātu cik daudz atmiņas mēs esam
būs nepieciešama mirkli Mūsu programma ir apkopota.
>> Kāpēc ir tā, ka?
Jo mums ir jāspēj nosaukt vai identificēt visus iespējamos mainīgajiem
mēs varētu saskarties.
Mēs varētu būt masīva, kas varētu būt spēj turēt daudz informācijas,
bet tas vēl nav tieši pietiekami precīza.
Ko darīt, ja mēs nezinām, Ko darīt, ja mums nav ne jausmas
cik daudz mums būs nepieciešams kompilēšanas laikā?
Vai ko, ja mūsu programma būs palaist patiešām ilgu laiku,
pieņemot dažādām lietotāju dati, un mēs nevaram īsti
novērtēt, vai mēs esam būs nepieciešama 1000 vienības?
>> Tas nav tāpat kā mēs varam saka pie komandrindas
ievadiet, cik daudz priekšmetus Jūs domājat, ka jums ir nepieciešams.
Nu ko tad, ja tas minējums ir nepareizi?
Dinamiskā atmiņas sadali veida ļauj mums ceļu
lai iegūtu ap šo konkrēto problēmu.
Un kā tas tiek darīts ir, izmantojot norādes.
>> Mēs varam izmantot norādes uz piekļūt dinamiski
piešķirti atmiņas, atmiņas, kas ir piešķirti kā jūsu programma darbojas.
Tas nav piešķirts kompilēšanas laikā.
Kad jūs dinamiski piešķirt atmiņu tas nāk no baseina
atmiņas pazīstams kā kaudzes.
Agrāk visi atmiņas mēs esam strādājusi ar gaitā
ir nāk no baseina atmiņas pazīstams kā kaudze.
Labs veids, kā parasti paturiet mind-- un šā noteikuma
ne vienmēr būt taisnība, bet diezgan daudz gandrīz
vienmēr uzskata true-- ir tas, ka jebkurš laiks jūs piešķirat mainīgā nosaukums it
iespējams, dzīvo uz skursteņa.
Un jebkurā laikā jums nav dot dažādu nosaukumu,
ko jūs varat darīt ar dinamisko atmiņu sadali, tas dzīvo uz kaudzes.
>> Tagad es esmu veida uzrādot to kā ja tur ir šie divi baseini atmiņas.
Bet jums var būt redzējis šo diagramma, kas ir parasti
pārstāvību kāda atmiņa izskatās,
un mēs nebrauksim, lai rūpētos par visiem sīkumi augšā un apakšā.
Ko mēs rūpējamies par to ir šī daļa vidū šeit, kaudze un kaudze.
Kā jūs varat redzēt, ko meklē šajā diagrammā,
tie faktiski nav divi atsevišķi baseini atmiņas.
Tā ir viena kopīga baseins atmiņas kur jūs sākat, šajā vizuālā
sākat apakšā un sākt iepildot
no apakšas ar krāvuma, un jums sākas augšā un sākt iepildot
no augšas uz leju ar kaudzes.
Bet tas tiešām ir pats baseins, tas ir tikai
dažādās vietās, dažādās vietās atmiņā, kas tiek piešķirti.
Un jūs varat palaist no atmiņa vai nu ar
kaudze iet visu ceļu uz leju, vai ir
kaudze iet visu ceļu uz augšu, vai kam ir kaudze un kaudze
satiekas pret otru.
Visi no tiem var būt apstākļi kas izraisa savu programmu
palaist no atmiņas.
Lai saglabātu, ka prātā.
Kad mēs runājam par kaudze un kaudze
mēs tiešām runājam par pats vispār rieciens atmiņas, tikai
dažādas porcijas šīs atmiņas.
>> Tātad, kā mēs dinamiski piešķirti atmiņu pirmajā vietā?
Kā mūsu programma nokļūt atmiņa kā tas darbojas?
Nu C nodrošina funkciju sauc malloc, atmiņas dalītāju, kas
Jūs piezvanītu, un jums iet uz cik daudz atmiņas baiti, ko vēlaties.
Tātad, ja jūsu programma darbojas un jūs vēlaties skaitlim runtime,
jūs varētu mallock četri baiti atmiņa, malloc iekavas četri.
>> mallock iet cauri skatoties caur kaudzes,
jo mēs esam dinamiski piešķirot atmiņu,
un tas atgriezīsies pie jums rādītājs uz šo atmiņu.
Tas nedod jums, ka memory-- tas nav arī tā nosaukumu,
tas dod jums rādītāju uz to.
Un tā tas ir iemesls, kāpēc atkal es teicu ka tas ir svarīgi varbūt
ir noskatījos norādes video pirms mēs pārāk tālu šis.
Tātad malloc gatavojas jums atpakaļ rādītāju.
>> Ja mallock nevar sniegt jums jebkādu atmiņas, jo jūs esat izsīkšanai,
tas došu jums atpakaļ null rādītāju.
Vai atceraties, kas notiek, ja mēs mēģināt un dereference null rādītāju?
Mēs cieš SEG vaina, vai ne?
Tas ir iespējams, nav labs.
>> Tātad, katru reizi, kad jūs veicat zvanu lai malloc tevi vienmēr, vienmēr
nepieciešams, lai pārbaudītu, vai rādītājs tas deva jums atpakaļ ir nulle.
Ja tā ir, jums ir nepieciešams, lai izbeigtu savu programmu jo, ja jūs mēģināt un dereference
Nulles rādītājs jūs gatavojas ciest segmentāciju vaina
un jūsu programma ir gatavojas crash anyway.
Tātad, kā mēs statiski iegūt vesels skaitlis?
>> int x.
Mēs, iespējams, esam darījuši ķekars reizes, vai ne?
Tas rada mainīgo sauc x, kas dzīvo uz skursteņa.
Kā mēs dinamiski iegūt skaitli?
Int zvaigzne px vienāds malloc 4.
>> Vai pareizāk mēs teiktu int zvaigzne px
vienāds malloc lielumu int, tikai mest daži mazāk
burvju numurus ap mūsu programmā.
Tas ir gatavojas saņemt par mums četri baiti atmiņas no kaudzes,
un rādītāju mēs atpakaļ uz to sauc px.
Un tad tāpat kā mēs esam iepriekš darīts mēs
var dereference px uz piekļūt šo atmiņu.
Kā mēs varam iegūt veselu skaitli no lietotājs?
Mēs varam teikt, int x vienāds saņemt int.
Tas ir diezgan vienkārši.
Ko darīt, ja mēs gribam izveidot masīvu X plosti, kas dzīvo uz skursteņa?
peldēt stack_array-- tas ir vārds Mūsu array-- kvadrātiekavās x.
Tas radīs mums masīva X plosti, kas dzīvo uz skursteņa.
Mēs varam izveidot masīvu pludiņi kas dzīvo uz kaudzes, too.
Sintakse varētu izskatīties nedaudz vairāk apgrūtinoša,
bet mēs varam teikt pludiņu star heap_array vienāds
malloc x reizes lielāka pludiņa.
Man vajag pietiekami daudz vietas, lai noturētu x peldošā punkta vērtības.
Tā teikt, man ir nepieciešams 100 pludiņiem, vai 1000 pludiņi.
Tātad, šajā gadījumā tas būtu 400 baiti par 100 pludiņiem,
vai 4000 baiti par 1000 pludiņiem, jo katra float aizņem
četri baiti telpā.
>> Pēc darot es varu izmantot kvadrātiekava sintakse uz heap_array.
Tāpat kā es darītu stack_array, es var piekļūt tās elementus atsevišķi
izmantojot heap_array nulle, heap_array viens.
Bet atgādināt iemeslu, mēs varam darīt, ka ir tāpēc, ka nosaukums masīva C
ir patiešām rādītājs šī masīva pirmais elements.
Tātad tas, ka mēs esam atzīts par masīvs pludiņiem uz skursteņa šeit
ir faktiski mazliet maldinošs.
Mēs patiešām esam Otrajā rindā kodu tur
arī radot rādītāju uz rieciens Atmiņas ka mēs tad darīt kādu darbu ar.
>> Lūk liela problēma ar dinamiski piešķirta atmiņu, lai gan,
un tas ir iemesls, kāpēc tas ir patiešām svarīgi attīstīt dažas labas ieradumus
ja jūs strādājat ar to.
Atšķirībā statiski deklarēta atmiņa, atmiņas
netiek automātiski atpakaļ uz Sistēma, kad jūsu funkcija tiek darīts.
Tātad, ja mums ir galvenais, un Galvenais aicina funkciju
f, kur f apdari kāds tas dara un atgriež programmas kontroles
atpakaļ uz galveno, visi no atmiņas ka f lieto tiek dota atpakaļ.
To var izmantot atkārtoti ar kādu citu programmu,
vai kādu citu funkciju, kas izpaužas sauc vēlāk pamatdarbā.
To var izmantot to pašu atmiņu atkal.
>> Ja jums dinamiski piešķirt atmiņu though
Jums ir skaidri pateikt sistēma, kas esat pabeidzis ar to.
Tas būs turēt uz to, lai jūs, kas varētu novest pie problēmai jūs pietrūkt
atmiņas.
Un patiesībā mēs dažreiz atsaukties uz to kā atmiņas noplūde.
Un reizēm šie atmiņas noplūdes patiesībā var būt ļoti postoša
par sistēmas veiktspēju.
>> Ja jūs bieži interneta lietotājs jūs varētu izmantot dažus tīmekļa pārlūkprogrammas,
un es nenosaukšu vārdus šeit, bet ir dažas tīmekļa pārlūkprogrammas, kas tur
kas ir pazīstami faktiski ņemot atmiņas noplūdes, kas nesaņem fiksēto.
Un, ja jūs atstāt jūsu pārlūkprogramma atvērts uz ļoti ilgu laiku, dienas
un dienās, vai nedēļas, jūs dažreiz ievērosiet, ka jūsu sistēmā
darbojas ļoti, ļoti lēni.
Un iemesls tam ir tas, ka pārlūks ir piešķīrusi atmiņu,
bet tad nav teicis sistēmu ka tas ir darīts ar to.
Un tā tas atstāj mazāk atmiņas pieejams visiem jūsu citām programmām
ir dalīties, jo tu esi leaking-- ka tīmekļa pārlūkprogrammu
Programma ir sūce atmiņu.
Kā mēs dot atmiņu atpakaļ kad mēs esam darījuši ar to?
Nu par laimi tas ir ļoti vienkāršs veids, kā to darīt.
Mēs vienkārši atbrīvot to.
Tur ir funkcija sauc bezmaksas, tā pieņem rādītāju uz atmiņu,
un mēs esam labi iet.
>> Tātad pieņemsim, ka mēs esi vidū mūsu programmas,
mēs gribam malloc 50 rakstzīmes.
Mēs vēlamies, lai malloc masīvu, kas var spēj noturēt 50 rakstzīmes.
Un, kad mēs rādītāju atpakaļ ka šīs rādītājs vārds ir vārds.
Mēs darām visu, mēs esam darīsim ar vārdu,
un tad, kad mēs esam darīts mēs vienkārši atbrīvot to.
Un tagad mēs esam atgriezušies tiem 50 atmiņas baiti atpakaļ sistēmai.
Dažas citas funkcijas var tos izmantot.
Mums nav jāuztraucas par ciešanas atmiņas noplūde tāpēc, ka mēs esam atbrīvojušies vārdu.
Mēs esam rūpīgi atmiņu atpakaļ, tāpēc mēs esam darīts strādāt ar to.
Tātad ir trīs zelta likumi, kas būtu
jāpatur prātā, kad jūs esat dinamiski piešķirot atmiņu
ar malloc.
Katrs atmiņas bloks, kas Jums malloc jānoņem
pirms savu programmu beidz darboties.
Tagad atkal, ierīces vai arī IDE šāda veida notiek Jums vienalga
kad you-- tas notiks vienalga ja jūsu programma ir izbeigta,
visi atmiņas tiks atbrīvota.
Bet tas parasti ir labs kodēšana prakse, lai vienmēr, kad tas ir paveikts,
atbrīvotu ko esat mallocd.
>> Tas nozīmē, ka tikai lietas, jūs esat mallocd būtu jāatbrīvo.
Ja jūs statiski pasludināt skaitlis, int x semikols,
kas dzīvo uz steku, jūs nav, tad gribu bezmaksas X.
Tātad tikai lietas, ko jūs esat mallocd būtu jāatbrīvo.
>> Un visbeidzot, nav brīvu kaut divreiz.
Tas var novest pie cits dīvaini situācija.
Tātad viss, kas jūs esat mallocd ir jāatbrīvo.
Tikai lietas, kas jūs esat malloc būtu jāatbrīvo.
Un nav brīvu kaut divreiz.
>> So iesim cauri piemēru šeit no tā, ko daži dinamiski piešķirta
atmiņa varētu izskatīties jaukts ar kādu statisko atmiņu.
Kas varētu notikt šeit?
Skat, ja jūs varat sekot kopā un uzminēt, kas ir
notiks, kā mums iet cauri visām šīm līnijām kodu.
>> Tāpēc mēs sakām int m.
Kas notiek šeit?
Nu tas ir diezgan vienkārši.
Es izveidot veselu mainīgo sauc m.
Es krāsu tā zaļa, jo tas ir krāsu
ka es izmantot, kad es runāju Par skaitlim mainīgie.
Tas ir kaste.
To sauc m, un jūs varat veikals skaitļu iekšpusē no tā.
>> Ko darīt, ja es tad saku int zvaigznīti?
Nu tas ir diezgan līdzīgs.
Es veidoju kastē sauc.
Tas spēj noturēt int zvaigznes, norādes uz veseliem skaitļiem.
Tāpēc es esmu krāsošana to zaļo ish, kā arī.
>> Es zinu, tas ir kaut kas darīt ar veselam skaitlim,
bet tas pats par sevi nav vesels skaitlis.
Bet tas ir diezgan daudz to pašu ideju.
Esmu izveidojis lodziņu.
Abas šīs tiesības tagad dzīvo uz skursteņa.
Es esmu devis viņiem abiem nosaukumiem.
>> int zvaigzne b vienāds malloc lielumu int.
Tas varētu būt nedaudz grūts.
Paņem otru un domāt par to, ko jūs varētu gaidīt, lai notiktu šajā diagrammā.
int zvaigzne b vienāds malloc lielumu int.
>> Nu tas nav tikai izveidot vienu kasti.
Tas patiesībā rada divas kastes.
Un tā saista, tas arī nosaka punkts attiecībās.
Mēs esam piešķirts viens bloks atmiņas par kaudzes.
Ievērojiet, ka augšējā labajā box tur nav vārdu.
>> Mēs mallocd to.
Tā pastāv uz kaudzes.
Bet b ir nosaukums.
Tas ir rādītājs mainīgais sauc b.
Kas dzīvo uz skursteņa.
>> Tātad, tas ir gabals atmiņas kas norāda uz citu.
b satur adresi Minētā bloka atmiņas.
Tas nav vārds citādi.
Bet tas norāda uz to.
Tātad, kad mēs sakām int zvaigzne b vienāds malloc lielums int, ka tieši tur,
ka bulta, kas popped up uz labajā pusē tur, ka viss,
Es ņemšu to, šķiet atkal, ir tas, kas notiek.
Visi, kas notiek ka nevienu koda rindu.
Tagad mēs nokļūt mazliet vairāk vienkārši vēlreiz.
vienāds aizvieto & zīmes m.
Vai jūs atceraties, ko vienāds Ampersand m ir?
Nu tas ir izpaužas M adresi.
Vai nodot vairāk shematiski, A līdz m.
>> vienāds b.
Labi, tāpēc šeit ir vēl viens.
Vienāds b.
Kas notiks diagrammā, šoreiz?
>> Nu atgādināt, ka Piešķiršanas operators darbi
uzticot šo vērtību Tiesības uz šādu vērtību pa kreisi.
Tāpēc tā vietā, lai, kas vērsta uz M, A tagad norāda uz to pašu vietu, ka B punktiem.
nenorāda uz B, A norāda kur B punktus.
>> Ja norādīja uz B, kas būtu bijis vienāds aizvieto & zīmes b.
Bet tā vietā vienāds b tikko nozīmē, ka un b ir tagad
norādot uz to pašu adresi, jo iekšā B ir tikai adrese.
Un tagad iekšpusē no a ir tāda pati adrese.
m ir 10, iespējams, visvienkāršākais lieta
mēs esam darīts mazliet.
Ielieciet 10 lodziņā.
Star b vienāds m plus 2, atsaukt no Mūsu norādes video, ko zvaigzne b nozīmē.
Mēs ejam, lai dereference b un nodot daži vērtība šajā atmiņas vietā.
Šajā gadījumā 12.
>> Tātad, kad mēs dereference kādu vietu atgādināt mēs vienkārši ceļot uz leju bultiņu.
Vai citiem vārdiem sakot, mēs iet uz šo atmiņas adresi
un mēs manipulēt ar to kaut kādā veidā.
Mēs ieliekam kādu vērtību tur.
Šajā gadījumā zvaigžņu b vienāds m plus 2 ir tikai
iet uz mainīgo norādīja uz B, iet uz atmiņas norādīja uz B,
un nodot m plus 2 tur, 12.
>> Tagad es bez b.
Kas notiek, kad es bez b?
Atceries, ko es teicu bezmaksas līdzekļus.
Ko es esmu sevi saprotams, kad es bez b?
>> Esmu beidzis strādāt ar to, labi?
Es būtībā atmest atmiņu.
Es dodu to atpakaļ uz sistēmu.
Man nevajag tas vairs nav ko es esmu stāsta viņiem, OK?
>> Tagad, ja es saku zvaigznīti vienāds 11 jūs varat droši
jau pateikt, ka kaut kas slikts notiks šeit, vai ne?
Un tiešām, ja es mēģināju, ka es, iespējams, ciestu segmentāciju vaina.
Jo tagad, lai gan iepriekš ka rieciens atmiņas
bija kaut kas man bija piekļuve, šajā brīdī
tagad es esmu piekļuvei atmiņa, kas nav juridiska man piekļūt.
>> Un kā mēs, iespējams, atceros, kad mēs piekļūt atmiņas
ka mēs neesam vajadzēja pieskarties, kas ir visbiežākais
no segmentācijas vaina. Un tā mana programma
būtu crash ja es centos to darīt.
Tātad vēlreiz, tā ir laba ideja, lai saņemtu labu prakses un labas paradumiem iesakņojusies
strādājot ar malloc un bez maksas, tā, ka jums nav jācieš segmentāciju
defekti, un ka jūs izmantojat Jūsu dinamiski piešķirta
atmiņa atbildīgi.
>> Es esmu Doug Lloyd tas ir CS50.