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