[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.