[MUSIC nagpe-play]
>> DOUG LLOYD: OK kaya ng mungkahi bago simulan dito.
Kung hindi mo pa napanood ang video sa mga payo na maaaring gusto mong gawin ito sa unang.
Dahil ang video na ito ay isa pang paraan ng mga nagtatrabaho sa mga payo.
>> Kaya ito ay pagpunta sa makipag-usap tungkol sa ilang mga concepts
na sumasaklaw namin sa Payo ng video, at hindi namin
pagpunta sa pagtakpan ang mga ito ngayon, sa pag-aakala na ang mga ito na
uri ng naiintindihan.
Kaya ito lamang ang iyong makatarungang babala na kung nakakakita ka ng video na ito
at hindi mo pa nakita ang payo video, maaaring ito ang uri ng mga
lumipad sa ibabaw ng iyong ulo ng kaunti.
At kaya ito ay maaaring maging mas mahusay na upang panoorin ang mga ito sa mga na-order.
>> Kaya namin na nakita ng isa paraan upang gumana sa mga payo,
na kung saan ay ipinahahayag natin ang isang variable, at pagkatapos namin
Ipinahahayag ng isa pang variable, isang pointer variable, na ang mga puntos sa mga ito.
Kaya ginawa namin ang isang variable sa isang pangalan, na namin
lumikha ng isang ikalawang variable na may pangalan, at ituro namin na pangalawang variable
sa na unang.
Ang uri ng mga may problema bagaman, dahil ito
nangangailangan sa amin upang malaman ang eksaktong kung magkano ang memory hindi namin
pagpunta sa kailangan ang mga sandali ang aming programa ay pinagsama-sama.
>> Bakit na?
Dahil kailangan namin upang ma-pangalan o makilala ang lahat ng posibleng mga variable
maaari nating makaharap.
Maaari naming magkaroon ng isang array na maaaring maging maaaring humawak ng isang pulutong ng mga impormasyon,
pero hindi pa rin eksakto tumpak na sapat.
Paano kung hindi namin alam, paano kung wala kaming ideya
kung magkano ang kakailanganin naming sa itala oras?
O kung ano kung ang aming mga programa ay tumakbo para sa isang tunay na matagal na panahon,
tumatanggap ng iba't-ibang user data, at hindi namin maaaring tunay
tantiyahin kung hindi namin pagpunta sa kailangan 1,000 units?
>> Ito ay hindi tulad ng aming makakaya sabihin sa command line
ipasok gaano karaming mga item sa tingin mo na kailangan mo.
Well kung ano na ang hula ay mali?
Dynamic na laang-gugulin memory uri ng nagbibigay-daan sa amin ang daan
upang makakuha ng paligid na ito partikular na problema.
At ang paraan na ito ay ito ay sa pamamagitan ng paggamit ng mga payo.
>> Maaari naming gamitin ang mga payo upang makakuha ng access sa mga dynamic na
inilalaan memory, memorya na ilaan gaya ng iyong programa ay tumatakbo.
Ito ay hindi inilalaan sa itala oras.
Kapag pabago-bago mong maglaan memory ito ay dumating mula sa isang pool
ng memorya na kilala bilang ang magbunton.
Dati lahat ng memorya na namin ay nagtatrabaho sa sa kurso
ay nagmumula sa isang pool ng memorya na kilala bilang ang stack.
Ang isang mahusay na paraan upang pangkalahatan panatilihin sa mind-- at ang patakaran na ito
ay hindi palaging hold totoo, ngunit medyo marami ang halos
laging humahawak true-- ay na ang anumang panahon na kayo ay magbigay ng isang pangalan ng variable na ito
marahil buhay sa stack.
At anumang oras wala ka magbigay ng isang variable ng isang pangalan,
na maaari mong gawin sa mga dynamic na memory laang-gugulin, ito ay nabubuhay sa magbunton.
>> Ngayon ako uri ng pagtatanghal na ito bilang kung may mga dalawang mga lawa ng memory.
Ngunit maaari mo pa nakikita ito diagram, na kung saan ay karaniwang
isang kinatawan ng kung ano ang memory kamukha,
at hindi kami ay pagpunta sa pag-aalaga tungkol sa lahat ng mga bagay-bagay sa itaas at sa ibaba.
Anong pinapahalagahan namin ang tungkol ay ang bahagi na ito sa gitna dito, magbunton at stack.
Tulad ng iyong nakikita sa pamamagitan ng naghahanap sa diagram na ito,
mga aktwal na ay hindi dalawang hiwalay na pool ng memory.
Ito ay isa sa mga shared pool ng memory kung saan ka magsimula, sa ganitong visual
magsimula ka sa ibaba at simulan ang pagpuno up
mula sa ilalim ng stack, at ikaw simulan sa itaas at simulan ang pagpuno up
mula sa tuktok pababa sa magbunton.
Ngunit ito ay tunay na ang parehong pool, ito lang
iba't-ibang lugar, iba't-ibang mga lokasyon sa memory na ay inilalaan.
At maaari kang magpatakbo ng mga memory sa pamamagitan ng alinman sa pagkakaroon
magbunton pumunta sa lahat ng paraan hanggang sa ibaba, o may
stack pumunta sa lahat ng mga paraan sa itaas, o pagkakaroon ng magbunton at ang salansan
makipagkita sa isa't isa.
Lahat ng mga maaaring maging mga kondisyon na naging sanhi ng iyong mga programa
pagka-ubos ng memory.
Kaya panatilihin na sa isip.
Kapag pinag-uusapan natin magbunton at ang salansan
ang talagang pinag-uusapan natin ang tungkol sa mga parehong pangkalahatang tipak ng memory, lamang
iba't-ibang mga bahagi ng na memory.
>> Kaya paano namin makuha magilas inilalaan memory sa unang lugar?
Paano gumagana ang aming programa makakuha ng memorya bilang tumatakbo ito?
Well C ay nagbibigay ng isang function na tinatawag na malloc, memory allocator, na
gumawa ka ng isang tawag sa, at pumasa ka sa kung ilang bytes ng memorya na gusto mo.
Kaya kung ang iyong programa ay tumatakbo at gusto mo ang isang integer runtime,
baka Mallock apat na bytes ng memory, malloc panaklong apat.
>> Mallock ay pumunta sa pamamagitan naghahanap sa pamamagitan ng magbunton,
dahil hindi namin magilas paglaan ng memorya,
at ito ay babalik sa inyo isang pointer sa na memory.
Hindi magbibigay sa iyo na na memorya ito ay hindi na bigyan ito ng isang pangalan,
ito ay nagbibigay sa iyo ng isang pointer dito.
At kaya na ang dahilan kung bakit muli sinabi ko na ito ay mahalaga sa siguro
pinapanood ang mga payo video bago namin makuha masyadong malayo sa ito.
Kaya malloc pupuntahan bigyan kayo ng isang pointer.
>> Kung hindi maaaring magbigay sa iyo Mallock anumang memory dahil mo na maubusan,
ito ay magbibigay sa iyo ng likod ng isang null pointer.
Huwag mo matandaan kung ano ang mangyayari kung namin subukan at dereference isang null pointer?
Magtiis kami ng isang seg fault, di ba?
Iyon ay marahil hindi mabuti.
>> Kaya sa bawat oras na gumawa ng isang tawag malloc ka palagi, palaging
kailangan upang suriin kung o hindi ang pointer ito ay nagbigay sa iyo ng likod ay null.
Kung ito ay, kailangan mong tapusin ang iyong programa dahil kung susubukan mo at dereference
ang null pointer ka pagpunta upang magdusa ng segmentation fault
at ang iyong programa ay pagpunta sa crash pa rin.
Kaya paano namin statically makakuha ng isang integer?
>> int x.
Marahil nagawa namin na isang grupo ng mga beses, tama?
Lumilikha ito ng isang variable na tinatawag na x na nakatira sa stack.
Paano magilas kami makakuha ng isang integer?
Int star px katumbas malloc 4.
>> O mas angkop Gusto naming sabihin int star px
ay katumbas ng malloc laki ng int, upang itapon lamang ang ilang mga mas kaunting
magic numero sa paligid ng aming programa.
Ito ay pagpunta upang makakuha ng para sa amin apat na bytes ng memorya mula sa magbunton,
at ang pointer na nakukuha namin bumalik sa mga ito ay tinatawag na px.
At pagkatapos ay tulad na namin tapos namin dati
Maaari dereference px sa access na memory.
Paano kami makakuha ng isang integer mula sa user?
Maaari naming sabihin int x ay katumbas makakuha int.
Iyan ay medyo tapat.
Paano kung gusto naming lumikha ng isang array ng x sa kamay na nakatira sa stack?
lumutang stack_array-- na ang pangalan ng ating array-- square bracket x.
Iyon ay lumikha para sa atin ng isang array ng x sa kamay na nakatira sa stack.
Maaari naming lumikha ng isang hanay ng mga kamay na nakatira sa magbunton, masyadong.
Maaaring tumingin syntax Ang isang maliit na mas mahirap,
ngunit maaari naming sabihin float star heap_array katumbas
malloc x beses ang laki ng float.
Kailangan ko ng sapat na silid na humawak x lumulutang halaga punto.
Kaya sabihin na kailangan ko 100 sa kamay, o 1,000 kamay.
Kaya sa kaso na ito ay magiging 400 bytes para sa 100 sa kamay,
o 4,000 bytes para sa 1,000 mga kamay, dahil ang bawat float ay tumatagal ng hanggang
apat na bytes ng espasyo.
>> Matapos gawin ito maaari ko bang gamitin ang square bracket syntax sa heap_array.
Tulad ng gagawin ko sa stack_array, ako Maaaring i-access elemento nito isa-isa
gamit heap_array zero, heap_array isa.
Ngunit isipin ang mga dahilan maaari naming gawin iyon ay dahil ang pangalan ng isang array sa C
ay talagang isang pointer sa unang elemento na array ni.
Kaya ang katotohanan na ay deklarasyon kami ng isang ang dami ng mga kamay sa stack dito
ay talagang isang bit nakaliligaw.
Kami ay talagang nasa pangalawang linya ng code doon
paglikha ng isang pointer sa isang tipak ng memory na pagkatapos ay gawin namin ang ilang mga trabaho sa.
>> Narito ang malaking problema sa dynamic na inilalaan memory bagaman,
at ito ang dahilan kung bakit ito ay talagang mahalaga upang bumuo ng ilang mga mahusay na mga gawi
kapag ikaw ay nagtatrabaho sa mga ito.
Hindi tulad ng statically ipinahayag memorya, ang iyong memory
ay hindi awtomatikong ibabalik sa sistema kapag ang iyong mga function ay tapos na.
Kaya kung mayroon main namin, at pangunahing tawag ng isang function
f, kapag f pagda anumang ito ay ginagawa at nagbabalik ng kontrol ng programa
bumalik sa pangunahing, ang lahat ng memory na f ginagamit ay ibinigay pabalik.
Ito ay maaaring gamitin muli sa pamamagitan ng ilang mga iba pang programa,
o ilang iba pang mga function na makakakuha ng tinatawag na sa susunod sa main.
Maaari itong gamitin ang parehong memory-ulit.
>> Kung ikaw magilas maglaan ng memorya na
ikaw ay may upang malinaw na sabihin ang sistema na tapos ka na sa mga ito.
Makikita ito hold papunta ito para sa iyo, na maaaring humantong sa isang problema ng ka nauubusan
ng memorya.
At sa katunayan minsan naming sumangguni sa ito bilang isang memory tumagas.
At kung minsan ang mga paglabas ng memorya aktwal na maaaring maging talagang nagwawasak
para sa sistema ng pagganap.
>> Kung ikaw ay isang madalas na gumagamit ng internet maaari mong gamitin ang ilang mga web browser,
at hindi ko na pangalan ng mga pangalan dito, ngunit may ilang mga web browser out doon
na kilalang-kilala sa tunay na pagkakaroon memory paglabas na hindi makakuha ng maayos.
At kung iwan mo bukas ang iyong browser para sa isang mahabang tagal ng panahon, araw
at araw, o linggo, ikaw minsan Maaaring mapansin na ang iyong system
ay tumatakbo tunay, tunay dahan-dahan.
At ang mga dahilan para sa na ay na ang browser ay inilalaan memory,
ngunit pagkatapos ay hindi sinasabi sa sistema na ito ay tapos na sa mga ito.
At upang ang mga dahon ng mas mababa memory magagamit para sa lahat ng iyong iba pang mga programa
sa may upang ibahagi, dahil ikaw ay leaking-- na web browser
program ay pagtulo memory.
Paano ako magbibigay kami memory back kapag tapos na kami sa mga ito?
Well sa kabutihang-palad ito ay isang napakadaling paraan upang gawin ito.
Magbakante lang namin ito.
May isang function na tinatawag na libre, ito ay tumatanggap ng isang pointer sa memory,
at kami ay handa na upang patakbuhin.
>> Kaya sabihin nating tayo'y nasa gitna ng aming programa,
gusto naming malloc 50 character.
Gusto naming malloc isang array na maaari kaya ng mga humahawak ng 50 mga character.
At kapag kami makakuha ng isang pointer pabalik sa na iyon, pangalan na pointer ay salita.
Ginagawa namin ang anumang hindi namin pagpunta sa gawin sa mga salita,
at pagkatapos ay kapag hindi namin tapos magbakante namin ito lamang.
At ngayon ay nagbalik kami sa mga 50 bytes ng memory pabalik sa sistema.
Maaaring gamitin ang mga ito sa ilang ibang mga function.
Hindi namin kailangang mag-alala tungkol sa paghihirap ng isang memory tumagas dahil nabakante namin salita.
Nagbigay kami ng mga memory back, kaya tapos na kami nagtatrabaho sa mga ito.
Kaya may tatlong ginintuang mga patakaran na dapat
manatili sa isip sa tuwing ikaw ay magilas paglaan memory
may malloc.
Bawat bloke ng memorya na mong malloc ay dapat na napalaya
bago ang iyong programa pagda tumatakbo.
Ngayon muli, sa appliance o sa Ang ganitong uri ng mangyayari IDE para sa iyo anyway
kapag you-- ito ay mangyayari pa rin kapag ang iyong programa ay tinapos,
lahat ng memory ay pinakawalan.
Ngunit ito ay sa pangkalahatan ay mabuti coding pagsasanay upang lagi, kapag tapos ka na,
magbakante kung ano ang iyong mallocd.
>> Sa gayon, ang mga bagay lamang na na sa iyo na mallocd dapat na napalaya.
Kung statically mong magpahayag ng isang integer, int x semi-colon,
na nakatira sa stack, ikaw hindi pagkatapos ay nais na magbakante x.
Kaya lamang ang mga bagay na na sa iyo mallocd dapat na napalaya.
>> At bilang wakas, hindi libre ang isang bagay nang dalawang beses.
Iyon ay maaaring humantong sa isa pang kakaiba sitwasyon.
Kaya lahat ng bagay na na sa iyo mallocd ay dapat napalaya.
Tanging mga bagay na na sa iyo dapat na napalaya malloc.
At gawin mo ang hindi libre ang isang bagay nang dalawang beses.
>> Kaya sabihin pumunta sa pamamagitan ng isang halimbawa dito ng kung ano ang ilang mga dynamic na inilalaan
Maaaring tumingin memory tulad mixed sa may ilang mga static memory.
Ano ang maaaring mangyari dito?
Tingnan kung maaari mong sundin ang kasama at hulaan kung ano ang
pagpunta sa mangyayari habang tayo'y sa pamamagitan ng lahat ng mga linya ng code.
>> Kaya sinasabi namin int m.
Ano ang mangyayari dito?
Well ito ay medyo direkta.
Gumawa ako ng isang variable integer tinatawag m.
Kulayan ko ito green, dahil iyon ang kulay
na gamit ko kapag ako ng pakikipag-usap tungkol sa mga variable integer.
Ito ay isang box.
Ito ay tinatawag na m, at maaari mong Tindahan ng integer sa loob ng mga ito.
>> Paano kung pagkatapos kong sabihin int star ang isang?
Well na medyo katulad.
Lumilikha ako ng isang kahon na tinatawag na a.
Ito ay kaya ng mga humahawak int bituin, mga payo sa integer.
Kaya ako pangkulay ito green-ish rin.
>> Alam ko na ito ay may isang bagay ang gagawin sa isang integer,
pero hindi ito mismo ng isang integer.
Ngunit ito ay medyo marami ang parehong ideya.
Lumikha ako ng isang box.
Pareho ng mga karapatan Live na ngayon sa stack.
Ibinigay ko sa iyo ang mga ito sa parehong mga pangalan.
>> int star b katumbas malloc laki ng int.
Maaaring maging isang maliit na nakakalito Isa na ito.
Kumuha ng isang pangalawang at isipin ang tungkol kung ano ang iyong ay inaasahan na mangyayari sa diagram na ito.
int star b katumbas malloc laki ng int.
>> Well ito ay hindi lamang lumikha ng isang kahon.
Ito ang tunay na lumilikha ng dalawang mga kahon.
At ito relasyon, ito rin ay nagtatatag isang punto sa isang relasyon.
Inilalaan namin ang isang bloke ng memory sa magbunton.
Pansinin na sa itaas na kanang box doon ay walang isang pangalan.
>> Mallocd namin ito.
Ito ay umiiral sa magbunton.
Ngunit b ay may pangalan.
Ito ay isang variable pointer na tinatawag na b.
Na nakatira sa stack.
>> Kaya ito ay isang piraso ng memory na puntos sa isa pa.
b ay naglalaman ng mga address ng na block ng memory.
Hindi nito ay may kabilang banda ng isang pangalan.
Ngunit ang mga puntos sa mga ito.
Kaya kapag sinasabi namin int star b ay katumbas ng size malloc ng int, na may karapatan,
na arrow na pop up sa kanang bahagi doon, na buong bagay,
Kukuha ako ng lumabas ito muli, ay kung ano ang mangyayari.
Lahat ng na mangyayari sa na iisang linya ng code.
Ngayon kami makakuha ng kaunti pa prangka muli.
isang katumbas ampersand m.
Natatandaan mo pa ba kung ano ang isang ay katumbas ng ampersand m ay?
Well iyon ang isang makakakuha address m.
O ilagay ang higit diagrammatically, isang punto upang m.
>> isang katumbas b.
OK kaya dito ay ang isa pa.
A ay katumbas ng b.
Ano kaya ang mangyari sa diagram oras na ito?
>> Well pagpapabalik na ang gawa assignment operator
sa pamamagitan ng pagtatalaga ng mga halaga sa mga karapatan sa halaga sa kaliwa.
Kaya sa halip ng isang pagturo sa m, isang ngayon puntos sa parehong lugar na b points.
isang ay hindi point sa b, isang puntos kung saan b points.
>> Kung ang isang matulis na b na gagawin ay isang katumbas ng ampersand b.
Ngunit sa halip na isang katumbas b lamang ay nangangahulugan na at b mga ngayon
na tumuturo sa parehong address, dahil sa loob ng b ay lamang ng isang address.
At ngayon sa loob ng isang ay ang parehong address.
m ay katumbas ng 10, malamang na ang pinaka-tapat na bagay
nagawa namin sa isang maliit na bit.
Ilagay ang 10 sa kahon.
Star b katumbas m plus 2, isipin ang mula sa ang aming mga payo video kung ano ang star b ibig sabihin nito.
Kami ay pagpunta sa dereference b at ilagay ilang mga halaga sa na lokasyon sa memorya.
Sa kasong ito 12.
>> Kaya kapag kami dereference ng isang punto ng pagpapabalik paglalakbay lamang namin down arrow.
O ilagay ang isa pang paraan, tayo pumunta sa na memory address
at manipulahin namin ito sa ilang mga paraan.
Naglaan na kami ng ilang mga halaga sa doon.
Sa ganitong kaso star b ay katumbas ng m plus 2 lang
pumunta sa variable na nakatutok sa pamamagitan b, pumunta sa memory nakatutok sa pamamagitan b,
at ilagay m plus 2 sa doon, 12.
>> Ngayon magbakante ko b.
Ano ang mangyayari kapag magbakante ko b?
Tandaan kung ano ang sinabi ko sa libreng paraan.
Ano ako sinasabi kapag magbakante ko b?
>> Tapos na akong nagtatrabaho sa mga ito, right?
Ako ay mahalagang bigyan up ang memorya.
Ako bigyan ito pabalik sa sistema.
Hindi ko kailangan ang mga ito anymore ay kung ano ang ako sinasabi sa kanila, OK?
>> Ngayon kung sinasabi ko star ang isang ay katumbas ng 11 maaari mong malamang
na sabihin na ang isang bagay masamang ang mangyayari dito, tama?
At sa katunayan kung sinubukan ko na ako ay marahil ay magdanas ng segmentation fault.
Dahil ngayon, bagama't dati na tipak ng memory
ay isang bagay na ako ay pag-access sa, sa puntong ito
ngayon ako sa pag-access ng memorya na ay hindi legal na para sa akin upang i-access.
>> At bilang ay namin marahil pagpapabalik, kapag na-access namin memory
na hindi namin ay dapat na hawakan, iyon ang pinaka-karaniwang dahilan
ng isang segmentation kasalanan. At kaya ang aking programa
ay nagka-crash kung sinubukan kong gawin ito.
Kaya muli ito ay isang magandang ideya upang makakuha ng magandang pagsasanay at mahusay na mga gawi nakatanim
kapag nagtatrabaho sa malloc at libreng, sa gayon ay hindi mo magdusa segmentation
pagkakamali, at ginagamit mo ang iyong dynamic na inilalaan
memory responsable.
>> Ako Doug Lloyd ito ay CS50.