[REPRODUCCIÓ DE MÚSICA] DOUG LLOYD: OK pel que un suggeriment abans de començar aquí. Si no has vist el vídeo en Punters és possible que vulgueu fer-ho primer. Com que aquest és un altre vídeo manera de treballar amb punters. 

Així que va a parlar sobre alguns conceptes que cobrim en el punters de vídeo, i estem passarà per sobre d'ells ara, assumint que ja estan tipus d'entès. Així que això és només la seva advertència justa que si vostè està veient aquest vídeo i no s'ha vist el vídeo punters, podria mena de volar sobre el seu cap una mica. I pel que podria ser millor al veure-ho en aquest ordre. 

Així que ja hem vist cap manera de treballar amb els punters, que és declarem 1 variables, i després declarar una altra variable, un punter variable que apunta a la mateixa. Per això hem creat una variable amb un nom, tenim creat una segona variable amb un nom, i vam assenyalar que la segona variable en aquest primer. Aquest tipus de compte amb un problema, però, pel fet que ens obliga a saber exactament la quantitat de memòria que estem necessitarà el moment nostre programa és compilat. 

Perquè és això? Perquè hem de ser capaços de nomenar o identificar totes les possibles variables podríem trobar. Pot ser que tinguem una sèrie que podria ser capaç de mantenir una gran quantitat d'informació, però encara no és exactament prou precís. Què passa si no sabem, ¿I si no tenim ni idea quant necessitarem en temps de compilació? O què si el nostre programa ho farà córrer per un temps molt llarg, acceptant diversos usuaris de dades, i no podem realment Estimem si som necessitarà 1.000 unitats? 

No és que puguem dir en la línia d'ordres introduir el nombre d'articles vostè pensa que vostè necessita. Bé, i si aquesta suposició no és correcta? Assignació de memòria dinàmica tipus de ens permet el camí per evitar aquest problema en particular. I la forma en què ho fa és mitjançant l'ús de punters. 

Podem utilitzar punters a accedir a dinàmicament memòria assignada, la memòria que és assignat com el seu programa s'està executant. No és assignat en temps de compilació. En assignar dinàmicament memòria es tracta d'una pila de la memòria conegut com el munt. Anteriorment tota la memòria que hem estat treballant amb en el curs ha estat venint d'una piscina de la memòria coneguda com la pila. Una bona manera de general tenir en mente-- i aquesta regla no sempre ser veritat, però gairebé gairebé Sempre val cert-- és que qualsevol vegada que fas un nom de variable que probablement viu a la pila. I en qualsevol moment que no ho fan donar a una variable un nom, que es pot veure amb la memòria dinàmica l'assignació, que viu en el munt. 

Ara estic una mica de presentar això com si hi ha aquestes dues piscines de memòria. Però és possible que hagi vist aquest diagrama, que és generalment una representació de el que la memòria s'assembla, i no anem a preocupar-se per tot les coses a la part superior i la part inferior. El que ens importa és aquesta part de el medi aquí, pila i pila. Com es pot veure per mirant aquest diagrama, aquests en realitat no són dos piscines separades de la memòria. És una piscina compartida de la memòria on s'inicia, en aquest visual s'inicia a la part inferior i començar a omplir des del fons amb la pila, i es començar a la part superior i començar a omplir de dalt a baix amb el munt. Però el que realment és la mateix grup, és només diferents punts, diferents ubicacions en la memòria que s'estan assignat. I vostè pot quedar-se sense memòria ja sigui per tenir el munt d'anar tot el camí a la part inferior, o tenen la pila d'anar tot el camí fins al cim, o que tinguin el heap i la pila reunir-se cara a cara. Tots els que pot haver condicions que fan que el seu programa que es quedi sense memòria. Així que tingues-ho en compte. Quan parlem de la pila i la pila realment estem parlant de la mateix tros general de la memòria, simplement diferents porcions d'aquesta memòria. 

Llavors, com fem perquè de forma dinàmica assignat memòria en el primer lloc? Com funciona el nostre programa arribar la memòria com s'està executant? Bé C proporciona una funció anomenada malloc, assignador de memòria, el que vostè fa una crida a, i es passa a quants bytes de memòria que desitgi. Així que si el seu programa s'està executant i vols un temps d'execució d'enters, és possible que Mallock quatre octets de memòria, malloc parèntesi 04:00. 

Mallock passarà per mirant a través de la pila, perquè som dinàmicament l'assignació de memòria, i tornarà a vostè un punter a la memòria. No et dóna que memory-- no dóna un nom, que li dóna un punter a ell. I per això una altra vegada he dit que és important que potser han vist el vídeo punters abans d'arribar massa lluny en això. Així malloc va va retornar un punter. 

Si Mallock no pot donar-li cap memòria perquè se li han acabat, que vaig a donar volta un punter nul. Te'n recordes del que passa si tractar d'eliminar la referència a un punter nul? Patim una fallada seg, oi? Això probablement no és bo. 

Així que cada vegada que faci una trucada a malloc que sempre, sempre, de comprovar si el punter hi va donar volta és nul. Si és així, vostè necessita per posar fi al seu programa perquè si tractes d'eliminar la referència el punter nul vas Hi va haver un error de segmentació i el seu programa és anant a estavellar totes maneres. Llavors, com fer que estàticament obtenir un nombre enter? 

int x. Probablement ens hem fet un munt de vegades, oi? Això crea una variable anomenada X que viu a la pila. Com obtenim dinàmicament un nombre enter? Int estrelles px equival malloc 4. 

O més apropiadament diríem int estrelles px mateixa mida malloc de int, només per donar una mica menys números màgics de tot el nostre programa. Això va a obtenir per a nosaltres 4 bytes de memòria de la pila, i el punter obtenim de nou a ell es diu px. I a continuació, igual que nosaltres hem fet prèviament ens pot eliminar la referència a px accedir a aquesta memòria. Com aconseguim un nombre enter d'usuari? Podem dir int x és igual a arribar int. Això és bastant senzill. Què passa si volem crear una matriu de x carrosses que viuen a la pila? surar stack_array-- aquest és el nom dels nostres claudàtors array-- x. Això crearà per a nosaltres un array de x carrosses que viuen a la pila. Podem crear una matriu de carrosses que viu en el munt, també. La sintaxi pot semblar un poc més molest, però podem dir flotador heap_array estrelles és igual temps malloc x la mida del flotador. Necessito espai suficient per emmagatzemar x valors de punt flotant. Així que dic que necessito 100 carrosses, o 1.000 flotadors. Així que en aquest cas seria 400 bytes per a 100 carros alegóricos, o 4.000 bytes per a 1.000 flotadors, perquè cada flotador ocupa 4 bytes d'espai. 

Després de fer això que puc utilitzar el sintaxi de claudàtor a heap_array. De la mateixa manera que ho faria en stack_array, I pot accedir als seus elements individualment utilitzant heap_array zero, un heap_array. Però recordar la raó per la qual podem fer això es deu al fet que el nom d'una matriu en C és realment un punter a primer element de la matriu. Així que el fet que estem declarant una varietat de carrosses a la pila aquí en realitat és una mica enganyós. Realment estem en el segona línia de codi que hi ha També la creació d'un punter a un tros de memòria que a continuació fem una mica de treball amb. 

Aquí està el gran problema amb assignada dinàmicament memòria, però, i és per això que és molt important desenvolupar alguns bons hàbits quan es treballa amb ell. A diferència estàticament declarada la memòria, la memòria no es torna automàticament al sistema quan la seva funció es fa. Així que si tenim principal, i principal crida a una funció f, quan f acabats el que està fent i retorna el control del programa tornar al principal, tota la memòria que f utilitzada es retorna. Es pot utilitzar de nou per algun altre programa, o alguna altra funció que es torna a trucar més tard a la principal. Podeu utilitzar aquesta mateixa memòria una altra vegada. 

Si dinàmicament assignar memòria encara vostè ha de dir-li explícitament la sistema que hagi acabat amb ell. Es va a aferrar-se a ell per a vostè, el que podria conduir a un problema de vostès corrent de la memòria. I, de fet, de vegades ens referim a això com una pèrdua de memòria. I de vegades aquestes pèrdues de memòria en realitat pot ser molt devastador per al rendiment del sistema. 

Si vostè és un usuari freqüent d'Internet podria utilitzar certs navegadors web, i no donaré noms aquí, però hi ha alguns navegadors web per aquí que són coneguts per tenir realment pèrdues de memòria que no et fixes. I si vostè deixa el seu navegador oberta per a un període molt llarg de temps, dia i dies, o setmanes, de vegades podria donar-se compte que el seu sistema està funcionant molt, molt lentament. I la raó d'això és que el navegador ha assignat memòria, però llavors no li va dir al sistema que es fa amb ella. I pel que deixa menys memòria disponible per a tots els seus altres programes a haver de compartir, perquè ets leaking-- que navegador web programa té una fuita de memòria. Com ens donem memòria de nou quan hàgim acabat amb ella? Bé, afortunadament, és un manera molt fàcil de fer-ho. Ens alliberem ella. Hi ha una funció anomenada gratuïta, accepta un punter a la memòria, i estem a punt per sortir. 

Així que diguem que estem en el mitjà del nostre programa, volem malloc 50 caràcters. Volem malloc una matriu que pot capaç de contenir 50 caràcters. I quan arribem a un punter de nou a que, el nom d'aquest punter és la paraula. Fem el que som va a fer amb la paraula, i després, quan estem fet que només alliberem ella. I ara que hem tornat els 50 bytes de la memòria de tornada al sistema. Alguna altra funció pot utilitzar-los. Nosaltres no hem de preocupar-nos per tenir una pèrdua de memòria, ja hem alliberat paraula. Hem donat a la memòria de nou, així que hem acabat de treballar amb ell. Així que hi ha tres regles d'or que han s'ha de tenir en compte sempre que estigui assignació dinàmica de memòria amb malloc. Cada bloc de memòria que que malloc ha de ser alliberat abans del seu programa acaba de córrer. Ara, de nou, en l'aparell o al IDE aquest tipus de passa per a vostè de totes maneres quan usted-- això va a succeir de totes maneres quan s'acaba el programa, tota la memòria es donarà a conèixer. Però és en general bona codificació la pràctica de sempre, quan hagi acabat, alliberar el que has mallocd. 

Dit això, les úniques coses que tens mallocd ha de ser alliberat. Si es declara estàticament 1 nombre sencer, int x punt i coma, que viu a la pila, que no llavors voler alliberar x. Així úniques coses que vostè ha mallocd ha de ser alliberat. 

I finalment, no fer alguna cosa lliure dues vegades. Això pot conduir a una altra situació estranya. Així que tot el que has mallocd ha de ser alliberat. Només les coses que vostè ha malloc ha de ser alliberat. I no fer alguna cosa lliure dues vegades. 

Així que anem a anar a través d'un exemple aquí del que alguns assignen dinàmicament la memòria podria ser similar mixta en amb una mica de memòria estàtica. Què podria passar aquí? Vegi si pot seguir al llarg i endevinin què és ocorrerà a mesura que avancem a través de totes aquestes línies de codi. 

Per això diem int m. Què passa aquí? Bé, això és bastant senzill. Crec una variable sencera anomenada m. Acoloreixo és verd, perquè aquest és el color que utilitzo quan estic parlant sobre variables senceres. És una caixa. Es diu m, i es pot emmagatzemar sencers a l'interior de la mateixa. 

I si després dir int estrelles 1? Bé, això és bastant similar. Estic creant una caixa trucada. És capaç de celebració int estrelles, els punters a enters. Així que estic pintar de verd-ish també. 

Sé que té alguna cosa a veure amb un sencer, però ella mateixa no és un enter. Però és més o menys la mateixa idea. He creat una caixa. Tots dos dret ara viuen a la pila. Jo els he donat dos noms. 

int estrelles b és igual grandària malloc de int. Aquest podria ser una mica difícil. Tome un segon i pensar en el que seria esperar que passi en aquest diagrama. int estrelles b és igual grandària malloc de int. 

Bé, això no es limita a crear una caixa. En realitat, això crea dues caixes. I es vincula, també estableix un punt en una relació. Hem assignat un bloc de la memòria en el munt. Observi que el quadre de dalt a la dreta allà no té un nom. 

Ens mallocd ella. Existeix en el munt. Però b té un nom. És una variable punter anomenat b. Que viu a la pila. 

Així que és un tros de la memòria que apunta a un altre. b conté l'adreça d'aquest bloc de memòria. No té un nom en cas contrari. Però apunta a la mateixa. Així que quan diem int estrelles b és igual a mida malloc de int, que allà mateix, aquesta fletxa que va aparèixer en la costat dret hi ha, tota aquesta cosa, Vaig a haver de sembli de nou, és el que passa. Tot això succeeix en aquesta sola línia de codi. Ara anem a arribar poc més senzill de nou. un signe igual a m. Recordes el que és un és igual signe m és? Bé, això és una obté la direcció del m. O dit més esquemàtica, uns punts a m. 

1 és igual a b. Acceptar així que aquí està un altre. A és igual a b. ¿Què passarà el diagrama d'aquest temps? 

Bo recordar que el treballa l'operador d'assignació assignant el valor al dret a la valor a l'esquerra. Així que en lloc d'un senyalador per m, una empresa apunta al mateix lloc que els punts b. 1 no apunta a B, A assenyala els punts on b. 

Si una punta a B que faria han estat un símbol d'unió és igual a b. Però en lloc d'una és igual a b just vol dir que aib són ara apuntant a la mateixa direcció, perquè a l'interior de b és només una direcció. I ara a l'interior d'un és la mateixa direcció. m és igual a 10, probablement el cosa més senzilla que hem fet en una mica. Poseu el 10 en el quadre. Estrella b és igual a m més 2, recorden des la nostra punters de vídeo disponible què l'estrella b significa. Anem a eliminar la referència b i put algun valor en aquesta posició de memòria. En aquest cas 12. 

Així que quan ens dereference un punt de Recordem que només viatgem per la fletxa. O dit d'una altra manera, anar a aquesta adreça de memòria i manipulem d'alguna manera. Posem algun valor en allà. En aquest cas l'estrella b és igual a m més 2 és només anar a la variable apuntada per b, anar a la memòria apuntada per b, i posar m més 2 aquí, 12. 

Ara allibero b. Què passa quan gratuït B? Recordeu el que vaig dir mitjans lliures. Què estic dient quan m'allibero b? 

Ja he acabat de treballar amb ell, no? Jo essencialment renunciar a la memòria. M'adono volta al sistema. No necessito més això és el que els estic dient, ¿d'acord? 

Ara bé, si jo dic una estrella és igual a 11 és probable que pugui ja dir-li que una cosa dolenta que passarà aquí, oi? I de fet si ho intentés que probablement patiria un error de segmentació. Perquè ara, tot i que prèviament que tros de memòria era una cosa que tenia l'accés a, en aquest punt ara estic accedir a la memòria que no és legal perquè tingui accés. 

I a mesura que probablement recordar, quan accedim a la memòria que no se suposa que tocar, aquesta és la causa més comuna d'una segmentació criticar. I així el meu programa s'estavellaria si tractava de fer això. Així que de nou és una bona idea per obtenir bona pràctiques i els bons hàbits arrelats quan es treballa amb malloc i lliure, de manera que vostè no pateix segmentació falles, i que s'utilitzen seva assignats dinàmicament memòria de forma responsable. 

Sóc Doug Lloyd això és CS50.