1 00:00:00,000 --> 00:00:00,499 2 00:00:00,499 --> 00:00:01,395 [MUSIC SPILLE] 3 00:00:01,395 --> 00:00:05,590 4 00:00:05,590 --> 00:00:07,940 >> DOUG LLOYD: OK så et forslag før du starter her. 5 00:00:07,940 --> 00:00:11,660 Hvis du ikke har sett videoen på tips du kanskje ønsker å gjøre det først. 6 00:00:11,660 --> 00:00:15,860 Fordi denne videoen er en annen måte å arbeide med pekere. 7 00:00:15,860 --> 00:00:17,574 >> Så det kommer til å snakke om noen begreper 8 00:00:17,574 --> 00:00:19,490 at vi dekker i pekere video, og vi er 9 00:00:19,490 --> 00:00:21,948 kommer til å glatte over dem nå, forutsatt at de er allerede 10 00:00:21,948 --> 00:00:23,090 liksom forstått. 11 00:00:23,090 --> 00:00:25,440 Så det er bare din rettferdig advarsel at hvis du ser denne videoen 12 00:00:25,440 --> 00:00:27,814 og du har ikke sett den pekere video, det kan liksom 13 00:00:27,814 --> 00:00:29,610 fly over hodet ditt litt. 14 00:00:29,610 --> 00:00:32,080 Og så kan det være bedre å se det i den rekkefølgen. 15 00:00:32,080 --> 00:00:34,710 >> Så vi har allerede sett en måte å arbeide med pekere, 16 00:00:34,710 --> 00:00:37,810 som er vi erklære en variabel, og da er vi 17 00:00:37,810 --> 00:00:42,160 erklærer en annen variabel, en peker variabel, påpeker at til det. 18 00:00:42,160 --> 00:00:44,870 Derfor har vi laget en variabel med et navn, vi har 19 00:00:44,870 --> 00:00:48,480 opprettet en ekstra variabel med et navn, og vi påpeke at andre variable 20 00:00:48,480 --> 00:00:50,220 på det første. 21 00:00:50,220 --> 00:00:52,370 Denne typen har en problem, fordi det 22 00:00:52,370 --> 00:00:54,650 krever at vi vet nøyaktig hvor mye minne vi er 23 00:00:54,650 --> 00:00:57,600 kommer til å trenge i øyeblikket Vårt program er kompilert. 24 00:00:57,600 --> 00:00:58,220 >> Hvorfor det? 25 00:00:58,220 --> 00:01:03,338 Fordi vi må være i stand til å navngi eller identifisere alle de mulige varianter 26 00:01:03,338 --> 00:01:04,129 vi kan støte på. 27 00:01:04,129 --> 00:01:07,910 Vi kan ha en matrise som kan være stand til å holde mye informasjon, 28 00:01:07,910 --> 00:01:10,110 men det er fortsatt ikke akkurat presise nok. 29 00:01:10,110 --> 00:01:12,640 Hva om vi ikke vet, hva om vi har ingen anelse 30 00:01:12,640 --> 00:01:14,370 hvor mye vi trenger ved kompilering? 31 00:01:14,370 --> 00:01:17,020 Eller hva om vårt program vil kjøre for en veldig lang tid, 32 00:01:17,020 --> 00:01:19,810 akseptere ulike bruker data, og vi kan egentlig ikke 33 00:01:19,810 --> 00:01:23,170 anslå om vi er kommer til å trenge 1.000 enheter? 34 00:01:23,170 --> 00:01:26,060 >> Det er ikke som vi kan si på kommandolinjen 35 00:01:26,060 --> 00:01:28,040 angir hvor mange elementer du tror du trenger. 36 00:01:28,040 --> 00:01:31,100 Vel hva om at gjetning er galt? 37 00:01:31,100 --> 00:01:34,300 Dynamisk minne allokering slags tillater oss veien 38 00:01:34,300 --> 00:01:36,867 å komme rundt dette problemet. 39 00:01:36,867 --> 00:01:38,700 Og måten den gjør det er ved hjelp av pekere. 40 00:01:38,700 --> 00:01:42,140 >> Vi kan bruke pekere til få tilgang til dynamisk 41 00:01:42,140 --> 00:01:45,710 allokert minne, minne som er disponeres som programmet kjører. 42 00:01:45,710 --> 00:01:48,290 Det er ikke avsatt ved kompilering. 43 00:01:48,290 --> 00:01:51,570 Når du dynamisk tildele minne det kommer fra en pool 44 00:01:51,570 --> 00:01:53,795 minne som kalles haugen. 45 00:01:53,795 --> 00:01:56,420 Tidligere alt minnet vi har jobbet med i løpet 46 00:01:56,420 --> 00:01:59,920 har kommet fra en pool minne som kalles stabelen. 47 00:01:59,920 --> 00:02:02,470 En god måte å generelt holde mind-- og denne regelen 48 00:02:02,470 --> 00:02:04,720 ikke alltid holder sant, men ganske mye nesten 49 00:02:04,720 --> 00:02:09,940 alltid holder true-- er at enhver gang du gir en variabel name it 50 00:02:09,940 --> 00:02:12,090 lever sannsynligvis på stakken. 51 00:02:12,090 --> 00:02:14,650 Og når du ikke gjør det gi en variabel et navn, 52 00:02:14,650 --> 00:02:19,160 som du kan gjøre med dynamisk minne tildeling, det lever på haugen. 53 00:02:19,160 --> 00:02:22,190 >> Nå er jeg litt å presentere dette som hvis det er disse to bassenger minne. 54 00:02:22,190 --> 00:02:24,740 Men du kan ha sett dette diagram, som vanligvis 55 00:02:24,740 --> 00:02:27,290 en representasjon av hva minnet ser ut, 56 00:02:27,290 --> 00:02:30,373 og vi ikke kommer til å bry seg om alt ting på toppen og bunnen. 57 00:02:30,373 --> 00:02:33,580 Hva vi bryr oss om er denne delen i midten her, heap og stakk. 58 00:02:33,580 --> 00:02:35,570 Som du kan se av ser på dette diagrammet, 59 00:02:35,570 --> 00:02:38,390 disse faktisk er ikke to separate bassenger minne. 60 00:02:38,390 --> 00:02:42,757 Det er en felles pool av minne hvor du starter, i denne visuelle 61 00:02:42,757 --> 00:02:44,590 du starter på bunnen og begynne å fylle opp 62 00:02:44,590 --> 00:02:48,040 fra bunnen sammen med stabelen, og du start øverst og begynner å fylle seg 63 00:02:48,040 --> 00:02:50,072 ovenfra og ned med haugen. 64 00:02:50,072 --> 00:02:51,780 Men det virkelig er samme basseng, det er bare 65 00:02:51,780 --> 00:02:56,050 forskjellige steder, forskjellige steder i minnet som blir tildelt. 66 00:02:56,050 --> 00:02:59,060 Og du kan kjøre ut av minne ved å enten ha 67 00:02:59,060 --> 00:03:01,240 haugen gå hele veien til bunnen, eller ha 68 00:03:01,240 --> 00:03:05,440 stabelen gå hele veien til toppen, eller å ha haugen og stakken 69 00:03:05,440 --> 00:03:06,740 møte opp mot hverandre. 70 00:03:06,740 --> 00:03:09,500 Alle disse kan være forhold som forårsaker programmet 71 00:03:09,500 --> 00:03:11,030 å kjøre ut av minnet. 72 00:03:11,030 --> 00:03:11,952 Så hold det i tankene. 73 00:03:11,952 --> 00:03:13,660 Når vi snakker om haugen og stakken 74 00:03:13,660 --> 00:03:17,880 vi egentlig snakker om samme generelle del av minnet, bare 75 00:03:17,880 --> 00:03:21,930 ulike deler av at minnet. 76 00:03:21,930 --> 00:03:24,910 >> Så hvordan får vi dynamisk allokert minne i første omgang? 77 00:03:24,910 --> 00:03:27,740 Hvordan få vårt program minne som det kjører? 78 00:03:27,740 --> 00:03:32,660 Vel C gir en funksjon som heter malloc, minne tildeler, som 79 00:03:32,660 --> 00:03:36,810 du ringer til, og du passerer i hvor mange byte minne som du ønsker. 80 00:03:36,810 --> 00:03:39,940 Så hvis programmet kjører og du vil ha et heltall runtime, 81 00:03:39,940 --> 00:03:46,040 du kan Mallock fire byte minne, parenteser malloc fire. 82 00:03:46,040 --> 00:03:48,540 >> Mallock vil gå gjennom ser gjennom haugen, 83 00:03:48,540 --> 00:03:50,750 fordi vi er dynamisk tildele minne, 84 00:03:50,750 --> 00:03:53,500 og det vil komme tilbake til deg en peker til at minnet. 85 00:03:53,500 --> 00:03:56,180 Det gir deg ikke at memory-- det gir ikke det et navn, 86 00:03:56,180 --> 00:03:57,950 det gir deg en peker til det. 87 00:03:57,950 --> 00:04:00,780 Og så det er derfor igjen sa jeg at det er viktig å kanskje 88 00:04:00,780 --> 00:04:03,770 har sett pekere video før vi kommer for langt inn i dette. 89 00:04:03,770 --> 00:04:05,940 Så malloc kommer til å gi deg tilbake en peker. 90 00:04:05,940 --> 00:04:08,950 >> Hvis Mallock ikke kan gi deg noe minne fordi du har kjørt ut, 91 00:04:08,950 --> 00:04:10,645 det vil gi deg tilbake en nullpeker. 92 00:04:10,645 --> 00:04:15,282 Husker du hva som skjer hvis vi prøve og dereference en nullpeker? 93 00:04:15,282 --> 00:04:17,019 Vi lider en SEG feil, ikke sant? 94 00:04:17,019 --> 00:04:18,060 Det er nok ikke bra. 95 00:04:18,060 --> 00:04:21,579 >> Så hver gang du ringer til malloc du alltid, alltid 96 00:04:21,579 --> 00:04:25,270 trenger å sjekke hvorvidt pekeren det ga deg tilbake er null. 97 00:04:25,270 --> 00:04:28,800 Hvis det er, må du avslutte programmet fordi hvis du prøver og dereference 98 00:04:28,800 --> 00:04:31,360 nullpeker du kommer å lide en segmentering feil 99 00:04:31,360 --> 00:04:34,380 og programmet er kommer til å krasje uansett. 100 00:04:34,380 --> 00:04:37,190 Så hvordan gjør vi statisk få et heltall? 101 00:04:37,190 --> 00:04:37,730 >> int x. 102 00:04:37,730 --> 00:04:40,010 Vi har sikkert gjort det en haug med ganger, ikke sant? 103 00:04:40,010 --> 00:04:43,480 Dette skaper en variabel kalt x som lever på stakken. 104 00:04:43,480 --> 00:04:46,190 Hvordan kan vi dynamisk å bli tildelt et heltall? 105 00:04:46,190 --> 00:04:50,010 Int stjerners px tilsvarer malloc fire. 106 00:04:50,010 --> 00:04:53,050 >> Eller mer hensiktsmessig vi vil si int stjerners px 107 00:04:53,050 --> 00:04:57,680 tilsvarer malloc størrelsen på int, bare for å kaste litt færre 108 00:04:57,680 --> 00:04:59,740 magiske tall rundt vårt program. 109 00:04:59,740 --> 00:05:04,140 Dette kommer til å få for oss fire byte minne fra haugen, 110 00:05:04,140 --> 00:05:06,720 og pekeren vi får tilbake til det kalles px. 111 00:05:06,720 --> 00:05:08,430 Og så akkurat som vi har gjort tidligere vi 112 00:05:08,430 --> 00:05:13,966 kan dereference px til tilgang til dette minnet. 113 00:05:13,966 --> 00:05:15,590 Hvordan får vi et tall fra brukeren? 114 00:05:15,590 --> 00:05:17,970 Vi kan si int x lik få int. 115 00:05:17,970 --> 00:05:19,930 Det er ganske grei. 116 00:05:19,930 --> 00:05:24,030 Hva om vi ønsker å skape en matrise av x flyter som lever på stakken? 117 00:05:24,030 --> 00:05:28,210 flyte stack_array-- det er navnet av våre array-- hakeparenteser x. 118 00:05:28,210 --> 00:05:32,419 Som vil skape for oss en matrise av x flyter som lever på stakken. 119 00:05:32,419 --> 00:05:34,960 Vi kan lage en rekke flyter som lever på haugen, også. 120 00:05:34,960 --> 00:05:37,330 Syntaksen kan se en litt mer tungvint, 121 00:05:37,330 --> 00:05:41,740 men vi kan si float stjerners heap_array lik 122 00:05:41,740 --> 00:05:44,360 malloc x ganger størrelsen av flottøren. 123 00:05:44,360 --> 00:05:48,160 Jeg trenger nok plass til å holde x flyt verdier. 124 00:05:48,160 --> 00:05:51,560 Så sier jeg trenger 100 flyter, eller 1.000 flyter. 125 00:05:51,560 --> 00:05:54,810 Så i så fall ville det være 400 byte for 100 flyter, 126 00:05:54,810 --> 00:05:59,080 eller 4000 byte for 1000 flyter, fordi hver flottør tar opp 127 00:05:59,080 --> 00:06:01,230 fire byte av plass. 128 00:06:01,230 --> 00:06:05,110 >> Når du har gjort dette kan jeg bruke hakeparentes syntaks på heap_array. 129 00:06:05,110 --> 00:06:08,970 Akkurat som jeg ville gjort på stack_array, jeg kan få tilgang til sine elementer enkeltvis 130 00:06:08,970 --> 00:06:11,590 bruker heap_array null, heap_array en. 131 00:06:11,590 --> 00:06:15,800 Men husker grunnen til at vi kan gjøre det er fordi navnet på en matrise i C 132 00:06:15,800 --> 00:06:19,990 er egentlig en peker til denne matrisen første element. 133 00:06:19,990 --> 00:06:23,480 Så det faktum at vi erklære en rekke flyter på stakken her 134 00:06:23,480 --> 00:06:24,810 er faktisk litt misvisende. 135 00:06:24,810 --> 00:06:27,600 Vi er i andre kodelinje der 136 00:06:27,600 --> 00:06:32,360 også lage en peker til en del av minne om at vi da gjøre noe arbeid med. 137 00:06:32,360 --> 00:06:35,620 >> Her er det store problemet med dynamisk allokert minne om, 138 00:06:35,620 --> 00:06:38,360 og dette er grunnen til at det er virkelig viktig å utvikle noen gode vaner 139 00:06:38,360 --> 00:06:39,800 når du jobber med det. 140 00:06:39,800 --> 00:06:43,060 I motsetning til statisk erklært minne, minne 141 00:06:43,060 --> 00:06:46,790 ikke automatisk tilbake til systemet når funksjonen er ferdig. 142 00:06:46,790 --> 00:06:49,280 Så hvis vi har hoved, og Hoved kaller en funksjon 143 00:06:49,280 --> 00:06:53,860 f, når f ferdig hva det gjør og returnerer kontroll av programmet 144 00:06:53,860 --> 00:06:58,810 tilbake til hovedsiden, hele minnet som f brukes er gitt tilbake. 145 00:06:58,810 --> 00:07:01,250 Den kan brukes igjen av et annet program, 146 00:07:01,250 --> 00:07:04,250 eller en annen funksjon som blir kalt senere i main. 147 00:07:04,250 --> 00:07:06,970 Det kan bruke den samme minne om igjen. 148 00:07:06,970 --> 00:07:09,620 >> Hvis du dynamisk allokere minne om 149 00:07:09,620 --> 00:07:14,380 Du må uttrykkelig fortelle system som du er ferdig med det. 150 00:07:14,380 --> 00:07:18,370 Det vil holde på det for deg, som kunne føre til et problem med å gå tom dere 151 00:07:18,370 --> 00:07:19,290 minne. 152 00:07:19,290 --> 00:07:22,179 Og faktisk vi noen ganger refererer til dette som en minnelekkasje. 153 00:07:22,179 --> 00:07:24,970 Og noen ganger disse minnelekkasjer faktisk kan være veldig ødeleggende 154 00:07:24,970 --> 00:07:27,020 for systemytelse. 155 00:07:27,020 --> 00:07:31,120 >> Hvis du er en hyppig Internett-bruker du kan bruke enkelte nettlesere, 156 00:07:31,120 --> 00:07:35,630 og jeg vil ikke nevne navn her, men er det noen nettlesere der ute 157 00:07:35,630 --> 00:07:39,150 som er beryktet for faktisk å ha minnelekkasjer som ikke får løst. 158 00:07:39,150 --> 00:07:44,570 Og hvis du lar din nettleser åpen for en svært lang tid, dager 159 00:07:44,570 --> 00:07:48,060 og dager, eller uker, du noen ganger kanskje merke at systemet 160 00:07:48,060 --> 00:07:49,790 er å kjøre veldig, veldig sakte. 161 00:07:49,790 --> 00:07:54,640 Og grunnen til det er at leseren har bevilget minne, 162 00:07:54,640 --> 00:07:57,320 men da ikke fortalt systemet at det er gjort med det. 163 00:07:57,320 --> 00:08:01,000 Og så blir det mindre minne tilgjengelig for alle dine andre programmer 164 00:08:01,000 --> 00:08:04,480 til å dele, fordi du er leaking-- som nettleser 165 00:08:04,480 --> 00:08:06,755 Programmet er lekker minne. 166 00:08:06,755 --> 00:08:08,880 Hvordan gir vi minne tilbake når vi er ferdig med det? 167 00:08:08,880 --> 00:08:10,838 Vel heldigvis er det en veldig enkel måte å gjøre det. 168 00:08:10,838 --> 00:08:11,710 Vi bare frigjøre den. 169 00:08:11,710 --> 00:08:15,020 Det er en funksjon som heter gratis, den godtar en peker til minnet, 170 00:08:15,020 --> 00:08:16,010 og vi er godt å gå. 171 00:08:16,010 --> 00:08:18,310 >> Så la oss si at vi er i midt i vårt program, 172 00:08:18,310 --> 00:08:21,970 vi ønsker å malloc 50 tegn. 173 00:08:21,970 --> 00:08:25,710 Vi ønsker å malloc en matrise som kan stand til å holde 50 tegn. 174 00:08:25,710 --> 00:08:29,109 Og når vi får en peker tilbake til det, at pekeren navn er ordet. 175 00:08:29,109 --> 00:08:30,900 Vi gjør hva vi er kommer til å gjøre med ord, 176 00:08:30,900 --> 00:08:33,440 og når vi er gjort vi bare frigjøre den. 177 00:08:33,440 --> 00:08:37,460 Og nå har vi kommet tilbake de 50 bytes minne tilbake til systemet. 178 00:08:37,460 --> 00:08:40,147 Noen andre funksjoner kan bruke dem. 179 00:08:40,147 --> 00:08:43,480 Vi trenger ikke å bekymre deg for å ha fått en minnelekkasje fordi vi har frigjort ord. 180 00:08:43,480 --> 00:08:46,639 Vi har gitt minnet tilbake, så vi er ferdig med å jobbe med det. 181 00:08:46,639 --> 00:08:48,430 Så det er tre gylne regler som bør 182 00:08:48,430 --> 00:08:51,700 holdes i bakhodet når du er dynamisk tildele minne 183 00:08:51,700 --> 00:08:52,990 med malloc. 184 00:08:52,990 --> 00:08:56,480 Hver blokk med minne som du malloc må frigjøres 185 00:08:56,480 --> 00:08:58,430 før programmet er ferdig utført. 186 00:08:58,430 --> 00:09:02,029 Nå igjen, i apparatet eller i IDE denne typen skjer for deg uansett 187 00:09:02,029 --> 00:09:04,820 når you-- dette vil skje uansett når programmet er avsluttet, 188 00:09:04,820 --> 00:09:06,880 alt minnet vil bli utgitt. 189 00:09:06,880 --> 00:09:10,750 Men det er generelt god koding praksis å alltid, når du er ferdig, 190 00:09:10,750 --> 00:09:13,810 frigjøre hva du har mallocd. 191 00:09:13,810 --> 00:09:16,690 >> Når det er sagt, eneste som du har mallocd bør bli frigjort. 192 00:09:16,690 --> 00:09:19,880 Hvis du statisk erklære en heltall, int x semikolon, 193 00:09:19,880 --> 00:09:23,500 som lever på stakken, du ikke så lurt å frigjøre x. 194 00:09:23,500 --> 00:09:25,970 Så bare ting som du har mallocd bør bli frigjort. 195 00:09:25,970 --> 00:09:28,960 >> Og til slutt, ikke gratis noe to ganger. 196 00:09:28,960 --> 00:09:31,170 Som kan føre til annen merkelig situasjon. 197 00:09:31,170 --> 00:09:33,530 Så alt du har mallocd må bli frigjort. 198 00:09:33,530 --> 00:09:36,000 Bare ting som du har malloc bør bli frigjort. 199 00:09:36,000 --> 00:09:38,730 Og ikke gratis noe to ganger. 200 00:09:38,730 --> 00:09:43,660 >> Så la oss gå gjennom et eksempel her av hva noen dynamisk allokert 201 00:09:43,660 --> 00:09:46,122 minne kan se ut som blandet på med litt statisk minne. 202 00:09:46,122 --> 00:09:47,080 Hva kan skje her? 203 00:09:47,080 --> 00:09:48,913 Se om du kan følge sammen og gjett hva som er 204 00:09:48,913 --> 00:09:51,720 kommer til å skje når vi går gjennom alle disse linjer med kode. 205 00:09:51,720 --> 00:09:53,980 >> Så vi sier int m. 206 00:09:53,980 --> 00:09:54,840 Hva skjer her? 207 00:09:54,840 --> 00:09:56,339 Vel, dette er ganske grei. 208 00:09:56,339 --> 00:09:59,650 Jeg oppretter et heltall variabel kalt m. 209 00:09:59,650 --> 00:10:01,400 Jeg farge det grønt, fordi det er den fargen 210 00:10:01,400 --> 00:10:03,730 som jeg bruker når jeg snakker ca heltallsvariabler. 211 00:10:03,730 --> 00:10:05,160 Det er en boks. 212 00:10:05,160 --> 00:10:08,400 Det kalles m, og du kan lagre heltall innsiden av det. 213 00:10:08,400 --> 00:10:12,400 >> Hva om jeg da si int stjerne en? 214 00:10:12,400 --> 00:10:13,530 Vel det er ganske lik. 215 00:10:13,530 --> 00:10:15,780 Jeg oppretter en boks kalt en. 216 00:10:15,780 --> 00:10:19,100 Det er stand til å holde int stjerner, pekere til heltall. 217 00:10:19,100 --> 00:10:21,570 Så jeg fargelagt det grønn-ish også. 218 00:10:21,570 --> 00:10:24,140 >> Jeg vet det har noe å gjøre med et heltall, 219 00:10:24,140 --> 00:10:25,852 men det er ikke i seg selv et heltall. 220 00:10:25,852 --> 00:10:27,310 Men det er ganske mye den samme ideen. 221 00:10:27,310 --> 00:10:28,101 Jeg har laget en boks. 222 00:10:28,101 --> 00:10:30,070 Begge disse rett nå bor på stakken. 223 00:10:30,070 --> 00:10:32,520 Jeg har gitt dem begge navnene. 224 00:10:32,520 --> 00:10:36,750 >> int stjerners b tilsvarer malloc størrelsen på int. 225 00:10:36,750 --> 00:10:38,560 Dette kan være litt vanskelig. 226 00:10:38,560 --> 00:10:44,110 Ta et øyeblikk og tenke over hva du forventer å skje på dette diagrammet. 227 00:10:44,110 --> 00:10:50,210 int stjerners b tilsvarer malloc størrelsen på int. 228 00:10:50,210 --> 00:10:51,940 >> Vel, dette betyr ikke bare lage en boks. 229 00:10:51,940 --> 00:10:53,800 Dette skaper faktisk to bokser. 230 00:10:53,800 --> 00:10:58,670 Og det bånd, det også etablerer et punkt i et forhold. 231 00:10:58,670 --> 00:11:02,240 Vi har tildelt en blokk minne på haugen. 232 00:11:02,240 --> 00:11:05,940 Legg merke til at den øverste høyre boksen det har ikke et navn. 233 00:11:05,940 --> 00:11:06,760 >> Vi mallocd det. 234 00:11:06,760 --> 00:11:08,050 Den eksisterer på haugen. 235 00:11:08,050 --> 00:11:10,090 Men b har et navn. 236 00:11:10,090 --> 00:11:11,950 Det er en peker variabel kalt b. 237 00:11:11,950 --> 00:11:13,910 Som lever på stakken. 238 00:11:13,910 --> 00:11:18,250 >> Så det er et stykke minne som peker til en annen. 239 00:11:18,250 --> 00:11:21,840 b inneholder adressen av den minneblokk. 240 00:11:21,840 --> 00:11:23,757 Det har ikke et navn på annen måte. 241 00:11:23,757 --> 00:11:24,590 Men det peker på stedet. 242 00:11:24,590 --> 00:11:29,760 Så når vi sier int stjerners b lik malloc størrelsen på int, at akkurat der, 243 00:11:29,760 --> 00:11:33,490 at pilen som dukket opp på høyre side er det, at hele greia, 244 00:11:33,490 --> 00:11:36,740 Jeg vil ha det vises igjen, er hva som skjer. 245 00:11:36,740 --> 00:11:39,341 Alt dette skjer i som eneste linje med kode. 246 00:11:39,341 --> 00:11:41,340 Nå får vi litt mer grei igjen. 247 00:11:41,340 --> 00:11:43,330 en lik tegnet m. 248 00:11:43,330 --> 00:11:46,280 Husker du hva en lik tegnet m er? 249 00:11:46,280 --> 00:11:48,920 Vel det er en får m adresse. 250 00:11:48,920 --> 00:11:54,150 Eller sagt mer skjematisk en peker til m. 251 00:11:54,150 --> 00:11:56,360 >> a er lik b. 252 00:11:56,360 --> 00:11:57,560 OK så her er en annen. 253 00:11:57,560 --> 00:11:59,230 A er lik b. 254 00:11:59,230 --> 00:12:02,260 Hva kommer til å skje til diagrammet denne gangen? 255 00:12:02,260 --> 00:12:04,330 >> Vel husker at Oppdraget operatør verk 256 00:12:04,330 --> 00:12:08,960 ved å tildele verdien på rett til verdien på venstre side. 257 00:12:08,960 --> 00:12:14,820 Så i stedet for en peker til m, en nå peker til samme sted som b poeng. 258 00:12:14,820 --> 00:12:18,900 en peker ikke til b, en påpeker hvor b poeng. 259 00:12:18,900 --> 00:12:25,280 >> Hvis en spiss til B som ville har vært en lik-tegnet b. 260 00:12:25,280 --> 00:12:28,150 Men i stedet en lik b bare betyr at og b er nå 261 00:12:28,150 --> 00:12:31,770 peker til samme adresse, fordi Innsiden av b er bare en adresse. 262 00:12:31,770 --> 00:12:35,004 Og nå inne i en er den samme adressen. 263 00:12:35,004 --> 00:12:37,170 m er lik 10, sannsynligvis den enkleste ting 264 00:12:37,170 --> 00:12:38,690 vi har gjort i en liten bit. 265 00:12:38,690 --> 00:12:40,460 Sett 10 i boksen. 266 00:12:40,460 --> 00:12:45,640 Stjerne b er lik m pluss to, husker fra vår pekere video hva star b betyr. 267 00:12:45,640 --> 00:12:50,230 Vi kommer til å deferanseoperasjon b og put viss verdi i den minnelokasjon. 268 00:12:50,230 --> 00:12:51,860 I dette tilfelle 12. 269 00:12:51,860 --> 00:12:55,300 >> Så når vi deferanseoperasjon et poeng av husker vi bare reise ned pilen. 270 00:12:55,300 --> 00:12:58,205 Eller sagt på en annen måte, vi gå til at minneadresse 271 00:12:58,205 --> 00:12:59,580 og vi manipulere det på noen måte. 272 00:12:59,580 --> 00:13:00,830 Vi satt noen verdi i det. 273 00:13:00,830 --> 00:13:03,960 I dette tilfellet stjerners b lik m pluss to er bare 274 00:13:03,960 --> 00:13:08,230 gå til variabelen peker til b, gå til minne peker til b, 275 00:13:08,230 --> 00:13:11,750 og sette m pluss to der inne, 12. 276 00:13:11,750 --> 00:13:14,970 >> Nå har jeg fri b. 277 00:13:14,970 --> 00:13:16,490 Hva skjer når jeg fri b? 278 00:13:16,490 --> 00:13:18,800 Husk hva jeg sa frie midler. 279 00:13:18,800 --> 00:13:21,920 Hva er det jeg sier når jeg fri b? 280 00:13:21,920 --> 00:13:23,410 >> Jeg er ferdig med å jobbe med det, ikke sant? 281 00:13:23,410 --> 00:13:25,702 Jeg egentlig gi opp minnet. 282 00:13:25,702 --> 00:13:26,910 Jeg gir den tilbake til systemet. 283 00:13:26,910 --> 00:13:33,010 Jeg trenger ikke dette lenger er hva jeg forteller dem, OK? 284 00:13:33,010 --> 00:13:37,390 >> Nå hvis jeg sier stjerne en tilsvarer 11 kan du sannsynligvis 285 00:13:37,390 --> 00:13:40,460 allerede si at noe dårlig kommer til å skje her, ikke sant? 286 00:13:40,460 --> 00:13:44,160 Og ja hvis jeg prøvde at jeg sannsynligvis ville lide en segmentering feil. 287 00:13:44,160 --> 00:13:47,140 Fordi nå, selv om tidligere at mengde minne 288 00:13:47,140 --> 00:13:50,220 var noe som jeg hadde adgang til, på dette punktet 289 00:13:50,220 --> 00:13:54,590 nå er jeg tilgang til minne som er ikke lovlig for meg å få tilgang. 290 00:13:54,590 --> 00:13:57,330 >> Og som vi vil sannsynligvis husker, når vi tilgang til minnet 291 00:13:57,330 --> 00:14:00,000 at vi ikke er ment å berøre, det er den vanligste årsaken 292 00:14:00,000 --> 00:14:01,860 av en segmentering utsette. Og så mitt program 293 00:14:01,860 --> 00:14:05,170 ville krasje hvis jeg prøvde å gjøre dette. 294 00:14:05,170 --> 00:14:09,910 Så igjen er det en god idé å få god praksis og gode vaner inngrodd 295 00:14:09,910 --> 00:14:12,920 når du arbeider med malloc og gratis, slik at du ikke lider segmentering 296 00:14:12,920 --> 00:14:15,310 feil, og at du bruker din dynamisk allokert 297 00:14:15,310 --> 00:14:17,370 minne ansvarlig. 298 00:14:17,370 --> 00:14:20,300 >> Jeg er Doug Lloyd dette er CS50. 299 00:14:20,300 --> 00:14:21,947