Tip:
Highlight text to annotate it
X
>> Tagapagsalita 1: Hi sa lahat.
Pagpunta Kami ay upang makapagsimula.
Sa tingin ko ang mga tao ay pumunta pa rin na pag-filter in
Ngunit sa interes ng panahon, upang aming makakaya makakakuha ka guys out sa dito sa oras,
kami ay pagpunta upang simulan.
Kaya maligayang pagdating sa CS50 Pagsusulit 0 pagsusuri.
Para sa mga ng sa iyo na hindi na maisasakatuparan pa, mayroon kang tanong sa Miyerkules.
Woo-hoo.
>> Kung hindi pa nagsisimulang pa nag-aaral o hindi na maisasakatuparan na pang ito ay umiiral,
nakalipas na mga pagsusulit at ang lahat ng impormasyon tungkol sa ang iyong pagsusulit ay nasa cs50.net/quizzes.
Mayroong ilang mga medyo magagandang bagay-bagay sa doon, nakaraang mga pagsusulit mula sa huling 10
taon pati na rin ang impormasyon tungkol sa pagsusulit at mga paksa
iyon ay sakop.
Kaya sabihin makapagsimula.
>> Kaya maaaring tandaan mo guys, ang unang araw ng klase David ay may mga lamp sa.
Kaya't mahalagang, ang lahat ng bagay na napupunta sa ilalim ng hood ng isang computer ay
tapos na sa binary.
Binary ay nangangahulugang kung ano ang tunog nito tulad ng, 0 at 1 ni.
Mayroon itong dalawang halaga na maaaring katawanin.
>> Kaya tulad ng sa unang araw ng seksyon kapag naka David sa isang liwanag
bombilya upang kumatawan sa, o 1, ang aming mga computer na Naiintindihan ng binary bilang 0 at
1, ang on o off.
Mga Pangunahing Kaalaman ng binary.
Ang bawat lugar ay kinakatawan sa base ng dalawa.
Kaya magdagdag ka ng 2 sa 0 upang ang 1 sa 2 ang lahat ng mga paraan up.
>> Upang kalkulahin kung ano ang iyong binary ay upang decimal, sundin mo lamang ang equation na ito
type bagay.
Kung mayroon kang isang 1 sa alinman sa mga lugar na ito, mo i-multiply ito sa pamamagitan ng kahit anupamang
ibabase ito ay nasa, magdagdag ng hanggang nito, at mong makuha ang decimal.
Kaya ito ay kung paano bilangin mo hanggang 5 sa binary.
Tulad ng kung ano ang aming ginagawa sa huling slide, ito ay kung paano gagawin mo
kumakatawan sa 1 hanggang 5.
>> Katulad nito, gusto lamang maaari kang magdagdag at ibawas sa decimal o base 10, o
talaga anumang base, sa maaaring magdagdag at ibawas sa binary.
Kung ano mismo ang nais mong asahan kapag ikaw magdagdag ng dalawang up, kung ito ay katumbas ng mas malaki
sa 1, dalhin mo ang isang 1, gawin itong isang 0, at gawin ang mga karagdagan na paraan, lamang
tulad ng gusto mong asahan sa regular na decimal o anumang iba pang base.
Cool.
>> Kaya tulad ng sinabi ko bago, lahat ng bagay na napupunta sa ilalim ng hood ng aming mga computer na
ay tapos na sa 0 at 1, o binary.
Kaya paano ipahayag namin, halimbawa, mga titik, o numero, o character?
At ang kasagutan sa na ASCII.
>> ASCII ay isang pagma-map sa pagitan ng mga character na normal na namin nais makita sa
Ingles na wika tulad ng A, ang B, C ni, salungguhit, mga gitling, at
anumang bagay tulad na.
At maps ito na sa isang halaga na ASCII.
Ang isang halaga na ASCII ay isang numero lamang na maaaring maunawaan ng iyong computer.
At tulad ng maaari mong gawin pa rito at palabawasan na may mga numero, maaari mong gawin
ang mga ito gamit ang mga ASCII.
>> Kaya sa halimbawang ito, kung ano ay i-print out ito?
Oo, kaya lamang ng isang space B espasyo C espasyo D. Saan mo aking mouse pumunta?
Pansinin maaari mong tukuyin ang isang int sa 65.
At kapag nag-i-print na out gamit porsiyento C, magkakaroon ito bigyang-kahulugan na bilang isang
karakter at ay i-print out A.
>> Gayundin, maaari mong idedeklara ito bilang isang pansamantalang trabaho.
At kapag i-print mo ito out gamit porsiyento C, ito ay bigyang-kahulugan na bilang
porsiyento D. At lamang tulad ng maaari kang magdagdag ng numero, maaari mong idagdag ang mga character ay
Mga halaga ng ASCII, sa kasong ito.
>> Kaya isang maliit na pointer para sa lahat ng tao.
5, bilang isang string, ay hindi talaga kasing-halaga 5.
Kaya kung paano maaaring convert namin ang string 5 sa integer 5?
Ang anumang mga ideya?
Oo.
>> Kaya kung mayroon kaming 5 bilang isang string, Maaari ibabawas namin ang 0.
At makikita na bigyan kami ng 5.
At katulad, kung kami ay may 5 bilang isang integer, magdagdag ng mga iyon sa mga string 0.
At iyon ay nagbibigay sa amin ng string 5.
Cool.
>> Ngayon, isipin ang pabalik sa panayam isa kung saan usapan natin ang tungkol sa mga algorithm.
Kaya paano talaga namin nais sa isang computer gawin kagiliw-giliw na mga bagay-bagay?
Alam mo yun, pagdaragdag lamang at pagbabawas mga numero at pag-print out ng mga bagay ay hindi
na kapana-panabik.
Karaniwan, gusto namin ang aming mga computer upang gumanap ng ilang mga uri ng algorithm.
Isang bagay na medyo mas kumplikado pa sa simpleng aritmetika.
>> Ang isang algorithm ay isa lamang hakbang-hakbang na hanay ng mga tagubilin para sa kung paano gumanap
isang tiyak na gawain -
nais lamang isang recipe.
Maaaring tandaan mo sa unang araw ng class na kung saan si David ay amin bilangin ng kuwarto
ng mga tao at kung gaano karaming mga tao ay sa kuwarto.
Maaari mong magamit upang nadaragdagan pa isa-isa.
1, 2, 3, 4.
Sa kasong iyon, isang linear oras algorithm.
>> Ngunit David ipinakilala ng isang algorithm para sa sa iyo upang mabilang ang mga tao sa kuwarto
kung saan lahat ng tao ay nakatayo up, sabihin mo ang iyong bilang sa isa pang tao, idagdag na
numero up, at isang tao nakapatong pababa.
At ulitin mo na.
Iyan ay isang uri ng algorithm.
Maaari naming pag-aralan kung paano mahusay na isang algorithm ay batay sa ito patakbuhin ang oras.
Ngunit masisiyahan kaming makipag-usap nang kaunti higit pa tungkol sa na mamaya.
>> Kaya lahat ng mga algorithm maaari ring ay maisulat sa pseudocode.
Pseudocode ay isang Ingles lamang tulad ng syntax ginamit upang kumatawan
isang programming language.
Halimbawa, kung gusto naming itanong sa isang user hulaan ang aking paboritong numero, namin
maaaring mayroon pseudocode bilang naturang.
>> Maging isang user hulaan.
Kung ang mga hula ay tama, sabihin mo sa kanila Ikinalulungkot tama ang mga ito, iba sabihin sa kanila
ang mga ito ay hindi tama.
At pseudocode ay isang paraan ng madali na kumakatawan sa isang ideya o isang algorithm.
Kaya ngayon maaari naming gusto upang aktwal na magsulat ito sa wikang iyon sa computer
maaaring pag-unawa.
Kaya maaari naming isulat ang aming pseudocode at bigyang-kahulugan na sa source code.
>> Sa ngayon, dapat na sumunod ang source code sa isang tiyak na syntax ng
isang programming language.
At ngayon, sa CS50, hindi namin ginagamit nakararami c.
Kaya ito ay maaaring maging source code para sa c.
Mamaya sa sa kurso, gabi ka dumating sa pakikipag-ugnay sa iba pang mga programming
mga wika tulad ng PHP.
O kung sa iyo kahit na magsagawa ng iba pang mga klase, mo maaaring gawin ng Java, Python, o kahit OCML.
Ngunit sa aming wika c programa, ito ay paano namin maaaring isulat ang source code para sa
ang pseudocode algorithm na Lamang Inilarawan ko mas maaga.
>> Kaya kung paano gumagana ang iyong computer talaga Nauunawaan na?
Tulad ng sinabi ko bago, ito lamang talaga Naiintindihan ng mga zero at bago.
Kaya paano nito makuha mula sa pinagmulan code sa isang bagay na maaaring maging
nauunawaan?
Well, mayroon kaming isang bagay na tinatawag na isang tagatala.
>> Kung isipin mo pabalik sa karamihan ng iyong psets, nagkaroon ka ng ilang mga uri ng programa
nakasulat sa isang tuldok c file.
At pagkatapos ay nais mong i-type make.
Kaya kung ano ang gumawa ng mga ginagawa?
>> Maaari kang mag-type make upang ipunin ang iyong programa dahil may -
kung sinuman na sinulat iyong p hanay; marahil David -
nilikha ng make file.
At ang sinasabi sa gawing malaman upang patakbuhin ang iyong mga tagatala, na tinatawag na kumalatong, na kalooban
pagkatapos ay i-compile ang iyong source code sa bagay code, na kung saan ay mga zero at mga bago
na naiintindihan ng iyong computer.
Ngunit ng kaunti sa paglaon, magpapatuloy kami mga mas malalalim na tungkol sa compiler.
>> Kaya isipin ang pset 0, kung saan - oo, may tanong ka?
>> Madla: [hindi marinig]?
>> Tagapagsalita 1: Oo.
Sa tingin ko sila talaga Dapat na online.
Oo.
>> Madla: Ito ba ay tulad ng [hindi marinig]?
>> Tagapagsalita 1: Hindi ito.
Ang ay nasa cs50.net/quizzes.
>> Madla: slash mga pagsusulit, iwa 2013, iwa 0, at mag-click lamang sa pamamagitan ng
mga pagsusulit 2013 at pagsusulit 0, suriin ang seksyon ng mga slide.
>> Tagapagsalita 1: Oo, kaya kung ikaw guys nais na hilahin ito pataas at tumingin sa ito sa iyong
sariling computer, na fine masyadong.
Sabihing na muli.
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Oo, [hindi marinig] ay ang dummy variable.
Oh, yes?
>> Madla: [hindi marinig]?
>> Tagapagsalita 1: Hindi, strike wala sa eksaminasyon.
Paumanhin, ang kanyang tanong ay, ay strike sa eksaminasyon.
At hindi.
Kaya pset 0, ka guys ay dapat magkaroon ng lahat ipinatupad ng isang bagay gamit ang mga scratch.
At natutunan namin ang ilang pangunahing programming bloke gusali gamit ang mga scratch.
>> Kaya ipaalam sa tumagal ng isang pagtingin sa ilan ng mga bloke ng gusali
na bumubuo ng isang program.
Una ay Boolean expression.
Boolean expression ay mga at 0 o anumang bagay na may
dalawang posibleng mga halaga.
Sa kasong ito, tama o mali, on o off, at oo o hindi.
Isang halimbawa ng isang simple, napaka-simple, programa na gumagamit ng Boolean
expression up dito.
>> Kaya sa order para sa Boolean expression upang maging kapaki-pakinabang, mayroon kaming Boolean operator.
Ito ang mga operator na maaaring magamit upang ihambing ang ilang mga halaga.
Kaya mayroon at o hindi namin katumbas ng, mas mababa sa o katumbas ng, mas malaki kaysa sa o
katumbas, at mas mababa sa o mas mataas kaysa.
Ngunit mga operator na ito ay hindi masyadong kapaki-pakinabang maliban kung maaari naming pagsamahin ang mga ito sa
kundisyon.
>> Kaya maaaring tandaan mo guys mula sa simula at mula sa iyong p Nagtatakda na namin
Nagkaroon kundisyon.
Ang mga ito ay, mahalagang, tulad ng tinidor sa ang logic ng iyong programa na
executes depende sa kung isang kondisyon ay nakamit.
Kaya isa sa mga kundisyon na namin ay may ginamit nang maraming beses sa kursong ito ay ang
kung, tao, mga kondisyon kung, at iba pa.
>> Narito ang isang halimbawa ng kung paano maaari mong gamitin iyon.
Sinuman Alam ba ng mga pagkakaiba sa pagitan ng lamang gamit ang mga salaysay kung ang lahat ng
ang paraan down na verses kung, tao, kung, at iba pa pinagsama?
Oo?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Mismong.
Kaya kung mayroon ako kung ang lahat ng mga paraan down na ito paraan, kahit na ang kundisyong ito babalik ang
Totoo, ito ay pa rin magpatuloy pagsubok ng susunod na dalawang.
Sapagkat, may isang tao-kung, ang isang tao statement, kung ang isa ay nagbabalik totoo,
ang iba pa ay hindi nasubok.
Ang anumang mga katanungan tungkol sa na?
Cool.
>> Kaya mong gamitin ang isang kung-iba ng isang tao pahayag kung alam mo na ito maaari lamang
maging isa sa mga kasong ito.
Kaya alam namin kung x ay mas mababa kaysa sa 0, ito ay Talagang hindi pagpunta sa maging
higit sa 0.
>> Susunod, isa pang bloke gusali na aming natutunan ay mga loop.
Mayroon kaming tatlong mga uri ng mga loop.
Para sa mga loop, habang loop, at gawin habang loop.
At sa pangkalahatan, kapag umupo ka pababa upang sumulat ng isang bagay, mayroon kang magpasya
kung alin sa mga tatlong na gusto mong gamitin.
Kaya paano namin magpasya kung aling isa?
>> Karaniwan naming gamitin ang isang para sa loop kung alam namin kung gaano karaming beses namin nais na umulit
sa pamamagitan ng isang bagay o kung gaano karaming beses nais namin upang magsagawa ng isang gawain.
Ginagamit namin habang loop kung kailangan namin ng ilang kalagayan upang maging totoo upang panatilihing tumakbo.
At ginagamit namin gawin habang halos kapareho sa habang, ngunit gusto namin ang aming mga code upang tumakbo sa
hindi bababa sa isang oras.
>> Kaya huwag habang, kahit anong ay nasa do habilin palaging patakbuhin ang hindi bababa sa isang oras.
Sapagkat, na may habang, ito Maaaring hindi tumakbo sa lahat kung ang
kondisyon ay hindi nasiyahan.
Ang anumang mga katanungan na may na?
>> Kaya istraktura ng isang para sa loop.
Ikaw guys na ang lahat nakita ito.
Initialize mo ito.
Mayroon kang ilang mga uri ng kondisyon.
Kaya, halimbawa, maaari naming simulan ang tulad ng para sa katumbas i 0.
i Mas mababa sa 10.
At i + +.
Napakasimpleng isa na nagawa namin.
>> Para sa isang habang loop, katulad, mayroon kang upang magkaroon ng ilang mga uri ng Pinasimulan,
ang ilang mga uri ng kondisyon, at ang ilang mga uri ng pag-update.
Kaya maaari naming ipatupad ang aming para sa loop din bilang isang habang loop gamit ito.
At katulad sa isang do habang loop, maaaring mayroon namin ang ilang Pinasimulan,
isakatuparan ang isang bagay, i-update ito, at pagkatapos suriin ang kalagayan.
>> Kaya ngayon function.
Ilagay namin ang lahat ng bagay nang magkakasama.
Maaaring gusto naming sumulat ng ilang uri ng function.
Mga karaniwang function na puwede mong nakita na ang pangunahing.
Main ay isang function.
Mayroon itong uri ng return, int.
Mayroon itong pangalan ng function, ang mga pangunahing.
At ito ay may mga argumento, argc at argv.
Kaya pangunahing ay isang katangian lamang.
>> Iba pang mga pag-andar na maaaring ginamit, printf - printf ay isang pagpapaandar -
GetInt, toupper.
Ngunit ang mga mangyayari sa naging ipinapatupad para sa amin sa pamamagitan ng
ang ilang mga uri ng library.
Kung ikaw guys tandaan kabilang ang ito CS50.h library o ang
standard I / O library.
Oo, tanong?
>> Madla: Ay pangunahing likas lamang sa c?
Gumagana ba ito lamang ang uri ng [hindi marinig]?
>> Tagapagsalita 1: Ang tanong ay kung main ay likas na taglay ng c.
At oo, lahat ng mga function magkaroon ng isang pangunahing pag-andar.
Ito ay uri ng kailangan para sa computer na malaman kung saan magsisimula
tumatakbo ang code.
>> Madla: Kaya mo ay hindi [hindi marinig]?
>> Tagapagsalita 1: Hindi.
Anumang iba pang mga katanungan?
Cool.
Kaya tulad ng maaari mong gamitin ang isang pagpapaandar na isinulat para sa iyo, maaari mo ring
isulat ang iyong sariling mga function.
Ito ay isang function na ang isang tao lakas isinulat upang makalkula ang lakas ng tunog
ng isang q, halimbawa.
Mayroong isang uri balik dito, sa kasong ito int, ang aming mga pangalan ng function q at ang aming
listahan ng mga parameter.
>> At tandaan na mayroon ka upang isulat ang data uri ng parameter na gusto mong
gamitin o iba ang function ay hindi alam kung anong uri ng
parameter na dapat kong tanggapin.
Kaya, sa kasong ito, nais naming isang integer bilang aming mga input.
Kaya kung bakit maaaring gusto naming gamitin ang function?
>> Una sa lahat, mahusay para sa samahan.
Tulungan masira ang mga up ang iyong code sa higit pa nakaayos chunks at gumawa ng mga
ito mas madaling basahin.
Pagpapagaan.
Ito ay mabuti para sa disenyo.
Kapag tapos ka nagbabasa ng isang piraso ng code at ang pangunahing function ay talaga,
talaga ang haba, maaari itong maging mas mahirap dahilan tungkol sa kung ano ang nangyayari sa.
Kaya kung masira ito down sa mga pag-andar, maaari itong maging mas madaling basahin.
At muling paggamit-kakayahan.
Kung mayroon kang isang tipak ng code na pagiging tinatawag o patakbuhin nang maraming beses,
sa halip ng muling pagsusulat ng code na 10 beses sa iyong pangunahing pag-andar, maaari mong
nais na muling gamitin ang mga ito.
At pagkatapos ay sa bawat oras na kailangan mong gamitin na piraso ng code, tawagan ang function.
>> Kaya ngayon kung tandaan namin pabalik sa simula, usapan din namin ang tungkol sa ilang mga konsepto,
isa na kung saan ay threading.
Thread ay ang konsepto ng maramihang pagkakasunud-sunod ng code
e-execute sa parehong oras.
Kaya sa tingin bumalik sa isang araw na may kung saan nagkaroon David bilangin mo guys off ang bilang ng mga
mga tao sa kuwarto.
>> Mahalaga, kung ano ang pagpunta sa ay ang lahat ng ka guys ay
tumatakbo hiwalay na mga thread.
At yaong mga thread ay magkasama darating upang makakuha ng ilang mga uri ng sagot.
Katulad nito, sa simula, kapag mayroon kang maramihang mga sprites, maaari mong
magkaroon ng isang pusa at isang aso.
At sila ay maging sabay-sabay patakbuhin ang kanilang mga sariling mga script.
Iyon ay isang halimbawa ng threading.
>> At ang iba pang mga konsepto na noon ay ipinakilala sa scratch ay mga kaganapan.
At kaganapan ay kapag ang maramihang mga bahagi ng ang iyong code makipag-komunikasyon sa bawat isa.
Sa simula, ito ay kapag ginamit mo ang broadcast ng kontrol at ang Kailan ko
Tumanggap ng mga bloke.
>> At din, sa Problema Set 4, nakita natin Medyo ng mga kaganapan pati na rin.
Ikaw guys maaaring na ginamit ang Gevent library.
At nagkaroon ng isang function waitForClick na kung saan ikaw ay naghihintay
para sa gumagamit na i-click.
At ang iyong mga pag-click, sa kasong ito, ay magiging ang kaganapan at maghintay para sa pag-click ay ang iyong
handler ng kaganapan.
>> At din, sa buong pagtakbo ang iyong mga psets at ang pagtatrabaho sa inyong psets, mo
maaaring dumating sa contact na may ang ilan sa mga utos.
Ito ay kung ano ang nai-type mo sa iyong terminal na window o kahit anong window
na nagpapakita up sa iyong g-edit sa, talaga, mag-navigate sa iyong computer.
>> Kaya halimbawa, ay naglilista ng LS ang mga nilalaman ng isang direktoryo.
Gumawa ng direktoryo ay lumikha ng isang bagong folder.
CD, pagbabago direktoryo.
RM, alisin, tinatanggal ang isang file o ilang mga direktoryo.
At pagkatapos ay tanggalin ang directory na Inaalis ng isang direktoryo.
>> Madla: [hindi marinig]?
>> Tagapagsalita 1: Oo, sigurado.
Paumanhin, ang tanong ay kung Gusto iminumungkahi paglalagay ito
sa impostor sheet.
Maaaring ito makatulong.
Kung mayroon kang kuwarto, maaari mo itong ilagay sa.
Ito ay lamang sa pangkalahatan ay mabuti sapat na rin matandaan dahil kapag ginamit mo ito
baka gusto mong lamang pa ito kabisado.
Na kailangan gawin ang iyong buhay ng maraming mas madali.
Ako Nasagot ba ang iyong katanungan?
>> Kaya ngayon, usapan natin ang kaunti sa madaling sabi tungkol sa mga aklatan.
Ngunit ang dalawang pangunahing mga bago na nakapunta namin gamit sa ngayon sa kurso ay
standard I / O at cs50.
Anong uri ng mga bagay ay kasama sa standard I / O library?
>> Oo, sa ngayon ginagamit namin ang printf.
Sa cs50, ginamit namin ang GetInt at GetString.
At ang uri ng data string mangyayari rin na ipinahayag sa cs50 library.
Susubukan naming makipag-usap ng kaunti pa sa malalim na tungkol sa paano aklatan gumagana at kung paano sila
makipag-ugnayan sa natitirang bahagi ng iyong code.
Ngunit ang mga ay ang dalawang pangunahing mga bago na kami na dumating sa contact na may sa ngayon sa
ang kurso.
>> Mga Uri ng.
Ang mga ito ay handa na upang matandaan kung magkano sa bawat uri ay kinakatawan ng o kung paano
maraming bytes bawat isa sa uri ay nangangailangan ng -
int, 4 bytes; pansamantalang trabaho, 1 byte.
Float ay 4 bytes.
Ano ang isang double?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Oo, kaya isang float pero double ang laki.
Paano ang tungkol sa isang mahaba?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: OK.
Ano ang isang mahaba?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Oo, i-double sa isang int.
Oo.
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Long [hindi marinig].
At pagkatapos ay mahaba mahaba ay isang double na.
>> Madla: Hindi, hindi.
Ang isang mahabang lamang sa isang int.
Depende ito sa arkitektura bago ang [hindi marinig]
at mayroon int ang parehong laki.
[Hindi marinig].
>> Tagapagsalita 1: Kaya isang mahaba at isang int ay pareho.
At pagkatapos ng mahabang mahaba ay double ang int.
Cool.
At pagkatapos ay, kung ano ay ang huling uri?
>> Madla: Pointer.
>> Tagapagsalita 1: Oo, kaya nalaman namin kaunti tungkol sa payo.
At nang walang kinalaman sa kung ano ang isang pointer ay na tumuturo sa - ito ay maaaring isang pansamantalang trabaho star
o isang int star -
laging 4 bytes para sa isang pointer.
Mga tanong tungkol sa na?
Oo?
>> Madla: [hindi marinig]?
>> Tagapagsalita 1: Kaya isang mahaba at isang int ay parehong sa cs50 appliance.
>> Madla: appliance Ang ay ganap na mapaghahalinhinan.
>> Tagapagsalita 1: Oo.
Kaya pagkatapos ng mahabang mahaba ay double sa isang int.
>> Madla: Ito ang 32 bit?
>> Tagapagsalita 1: 32 bit, oo.
>> Madla: Kaya [hindi marinig]?
>> Tagapagsalita 1: Oo, kung hindi tahasang sabihin, mo
Dapat ipinapalagay ng 32 bit.
>> Madla: Ito sabihin ng isang bagay tulad ng pag-aako ng isang
arkitektura tulad ng appliance.
Para sa 64 bit, ang tanging bagay na pagbabago ay longs at payo.
Kapwa nila [hindi marinig].
>> Tagapagsalita 1: Oo?
>> Madla: Tanong.
Kaya sa isa sa mga pagsusulit pagsasagawa, ito nagtatanong tungkol sa isang wala pang kontratang int.
Kaya kung paano na matukoy mula sa isang int [hindi marinig]?
>> Tagapagsalita 1: Ang isang unsigned sa 4 na bytes din.
Ngunit ano ang iba't ibang tungkol sa isang naka-sign int at isang wala pang kontratang int?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: I-right.
Maaari One kumakatawan negatibong halaga.
Ngunit paano nito gawin iyon?
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Oo, tinitipid ito 1 bit upang kumatawan sa pag-sign.
Ang sign ay may isa bit na ay kumakatawan sa pag-sign.
At wala pang kontratang lamang ay ang lahat ng mga positibo.
>> Madla: ang OK.
Kaya sabihin mo na ang isang double ay dalawang beses ang laki ng isang float?
>> Tagapagsalita 1: Double ay dalawang beses ang laki ng isang float, oo.
>> Madla: Paano gumagana ang isang pointer sa isang mahaba mahaba [hindi marinig]?
>> Tagapagsalita 1: Kaya ang tanong ay kung paano gumagana ang ang pointer sa isang mahabang mahaba -
paano ay na bytes apat lamang kapag ng mahabang mahaba nito 8 bytes.
Kaya tandaan kung ano ay isang pointer, talaga, sa pinakadulo base ng halaga.
>> Madla: [hindi marinig].
>> Tagapagsalita 1: Oo, kaya isang pointer lamang ang isang lokasyon sa memorya.
Kaya ito ay hindi mahalaga kung gaano kalaki ang espasyo na pointer ay tumuturo sa.
Kailangan lamang ito ng 4 bytes subaybayan ng na lokasyon memorya.
Anumang iba pang mga katanungan?
Cool.
>> Kaya ang huling bagay Mayroon akong ay karaniwang output.
Dapat mong gamitin ang mga ito madalas sapat na maaari mong matandaan.
Ngunit ito ay kapag ginagamit namin printf, halimbawa.
At mayroon kaming mga placeholder na ay tinawag na format ng code.
>> Kaya porsiyento c pansamantalang trabaho, porsiyento i para sa int, at maaari din namin ang porsiyento d.
Ito ay ang parehong bagay.
Subalit, sa pangkalahatan, sa CS50 namin subukang gamitin porsiyento i.
Porsyento f para sa float.
Porsyento ld para mahaba mahaba at porsiyento s para sa string.
>> Katulad nito, kami ang paggamit ng ilang ng mga escape sequence.
Halimbawa, backslash n para sa mga bagong linya.
Ito ay para lamang sa kung kailan ka formatting ang iyong code para sa print f.
Oo?
>> Madla: Ano ang porsyento d para sa?
>> Tagapagsalita 1: Kaya ang tanong ay kung ano ang porsyento d para sa?
Porsyento d ay para sa ints.
Porsyento d at porsyento ay i pareho.
>> Madla: Ano ang pagkakaiba sa pagitan ng backslash n at backslash r?
>> Tagapagsalita 1: Kaya ang tanong ay kung ano ang mga pagkakaiba sa pagitan ng sumasagot na hampas n at
sumasagot na hampas r?
Sa tingin ko backslash r ay -
>> Madla: Kaya backslash r lamang nagpapahiwatig babalik sa simula ng linya
nang hindi aktwal na pagpunta sa isang bagong linya.
Kaya kung mag-print ka ng isang backslash r at mo bumalik sa simula ng linya
pagkatapos ay i-print ka ng higit pang mga bagay-bagay, mo patungan ang mga bagay na iyan ay nasa
[Hindi marinig].
Sapagkat, n talaga ang papunta sa isang bagong linya at pupunta sa [hindi marinig].
>> Tagapagsalita 1: Well, ang anumang iba pang mga tanong?
Ayos lang.
Pupunta ako sa ipasa ito off upang Dan sino ay magpapatuloy.
>> [Palakpakan]
>> Dan: Lahat ng righty.
Kaya makikita ay pakikipag-usap ko tungkol sa isa pang malawak hanay ng mga ideya mula sa klase na
halos kinatawan ng linggo ng dalawa at simula ng linggo tatlong nagsisimula off
may paghahagis, na kung saan ay lamang ng isang paraan ng pagpapagamot ng isang halaga ng isang tiyak na uri ng bilang
isang halaga ng isang iba't ibang mga uri.
Kaya maaari naming gawin ito gamit ang mga char sa ints, sa kamay upang ints, at
mahaba longs i-double.
>> Ang lahat ng mga bagay na ito ay maaaring gamitin bilang paraan ng pagpapagamot ng ilang mga halaga ng pang-numero
minus pansamantalang trabaho bilang ilang mga iba pang numerong halaga.
Kaya mayroong ilang mga isyu sa ito, ng Siyempre, na kung saan ay kapag nagsumite ka
mga bagay tulad ng float sa ints.
Kaya ito ay isang maliit na kakaiba.
Mayroon kaming float na ay 1.31.
Multiply namin ito sa pamamagitan ng 10,000.
At pagkatapos ay i-print namin ito bilang isang int.
Ano ang output na ito?
10,000 beses 1.31.
Kaya 13,000, ay ang hula?
>> Madla: Sa tingin ko ito ay 10,000.
>> Dan: Kaya ako ng pag-multiply ito sa pamamagitan ng 10,000 bago ako paghahagis ito.
>> Madla: Oh.
Hindi Gusto ba ng isa 9 at ang ilan 0 mga numero?
>> Dan: Maaaring mayroon kang ilang mga kakatwang mga digit.
Kaya karapatan, ito ay 1.3 beses na 10,000.
Kaya na 13,000.
At sa mga sobrang kakaiba -
>> Madla: 13,100.
>> Dan: 13,100.
Salamat sa iyo, Rob.
At ito dagdag weirdness -
ito 9,9 -
ay dahil lamang ito paghahagis napunta rounding down na kung saan
hindi ito dapat magkaroon.
Oo.
>> Madla: paghahagis Ang mangyayari pagkatapos ng ano pa man?
>> Dan: So dahil mayroon akong ito sa print, ito Ginagawa ito pagpaparami bago ito
Ginagawa ito paghahagis.
>> Madla: [hindi marinig].
>> Dan: Sa tingin ko gusto ito nagsumite ng una, oo, na magiging 10,000.
Ano pa?
Cool.
Kaya ito ay 13,099.
Bakit ang nangyari ito?
Imprecision.
>> Sa kamay Hindi perpekto.
Maaari lang ang mga ito ay kumakatawan sa mga numero sa isang tiyak na bilang ng mga makabuluhang mga numero.
Kaya kung i-print out namin 8 sig igos sa ito float, makakakuha tayo ng isang uri ng
pangit naghahanap numero.
At iyon ay dahil hindi 1.31 maaari tumpak katawanin sa pamamagitan ng simpleng
kapangyarihan ng dalawang sa machine.
Kaya ito ay nagtatapos up pagkuha ang pinakamalapit hulaan, na nagtatapos up
pagiging isang maliit na mababa.
Magkaroon ng kahulugan?
OK.
>> Ngayon, lumipat ay isang iba't ibang mga paraan ng paggawa kondisyon na pahayag kung saan lahat
pinapahalagahan namin tungkol sa ay isang solong variable.
Kaya sa partikular na halimbawa, kami ay pagkuha ng isang integer mula sa user.
At pagkatapos kaming naghahanap sa ano na integer ay.
Siguro, ito ay bilang sa pagitan ng isa at apat.
Iyon ay kung ano ang hinihingi namin para sa.
>> Kaya gawin mo ang isang paglipat ng ang pangalan ng variable.
Pagkatapos mong i-set up ang mga kaso ng mga posibleng halaga, values, maaaring ito ay.
Kaya sensitibo sa laki ng isa, sabihin ito ay mababa.
At pagkatapos ay magpapalit upang makakuha ng out ng mga kondisyon switch kaya
hindi mo panatilihin ang pagpunta.
>> Sa susunod na kaso -
kaya kaso ng dalawa at tatlong kaso -
kung ito ay kaso ng dalawang bumaba down na ito lamang sa ang unang linya ng code ang nakakakita nito bilang may
case tatlong hanggang nakikita ito ng pahinga.
Kaya ang dahilan kung makakuha ka kaso isa sa mababang-print lamang ay dahil ako
mayroon dito ito break.
Kung ako, sabihin nating, binabalewala ito ng break - kung threw ko ito breakaway -
Gusto ito i-print mababa, at pagkatapos ay ginagawa ito i-print gitna, at pagkatapos ay magdudulot ito masira.
>> Kaya break ay isang mahalagang bahagi ng lumipat kundisyon at
dapat silang maging doon.
Anumang mga kaso na hindi nakasaad tahasan ay hinahawakan ng mga default
case sa switch at dapat maging cast.
>> Madla: Kaya 1, 2, 3, at 4 ay magiging n?
>> Dan: Halaga na n maaaring maging.
Oo.
Oo?
>> Madla: Kaya kapag mayroon kang na [hindi marinig]?
>> Dan: Gusto mong i-print mababa, at pagkatapos ay Gusto ito i-print gitna, at
pagkatapos ay magdudulot ito masira.
>> Madla: Bakit ito i-print gitna kung [hindi marinig]?
>> Dan: Kaya lahat ng bagay sa ilalim ng kaso bago ng pahinga ay bumaba sa ilalim.
Kaya kaso isa-print ay sa ilalim kaso isa bilang ay ang mga sumusunod na pag-print.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Kaya ang bilang na ito ay isa lamang sa isang partikular na halaga na ito variable
Maaaring tumagal, tama?
Ba na magkaroon ng kahulugan?
Oo.
>> Madla: [hindi marinig]?
>> Dan: Oo, kaso dalawang gusto i-print gitna at pagkatapos ay masira.
>> Madla: [hindi marinig]?
>> Dan: Sa tingin ko ang anumang?
Ano pang ibang mga uri ng data maaari kang lumipat sa ibabaw?
>> Madla: Maaari kang lumipat sa paglipas ng anumang uri ng data.
Ngunit nangangahulugan lamang ito ng kahit ano sa paglipas ng char at ints at bagay-bagay tulad na, dahil
kung lilipat ka sa isang pointer na hindi talaga magkaroon ng kahulugan,
lumilipat sa ibabaw na naglo-load, kung ito kahit na sabihin gawin mo na, dahil sa mga lumulutang na tuldok
sa katumpakan, gagawin mo hindi talaga nais na gawin pa rin iyon.
Kaya halos, ints lamang at char at bagay-bagay tulad na.
>> Dan: Oo, ito ay kapag mayroon kang tahasang mga halaga na alam mo, sa palagay ko, maaaring maging
na ang isang paglipat ay talagang kapaki-pakinabang.
Magandang?
OK.
>> Saklaw ay ang saklaw na iyon ng ipinahayag variable na umaabot.
Kaya sa ito maliit na tipak ng code mayroon akong, magiging puno ng mga error.
At ang dahilan ay ipinahayag ko ito int i loob ng saklaw ng ito para sa loop.
At pagkatapos ay sinusubukan ko na banggitin ang mga iyon i labas ng na para sa loop na saklaw.
>> Kaya isa lamang, maaari mong isipin ang tungkol saklaw bilang anumang bagay na ipinahahayag ninyo
may loob ng isang hanay ng mga kulot tirante lamang umiiral sa loob ng mga kulot tirante.
At kung susubukan mo at gamitin ang variable na sa labas ng mga kulot tirante, makakakuha ka
nakakakuha ng error mula sa tagatala.
Oo?
>> Madla: Kaya ang isang ito ay hindi gumagana?
>> Dan: ito ay hindi gumagana, oo.
Mga string.
String ng isang pansamantalang trabaho *.
Ang mga ito ay eksaktong kapareho.
Sila lamang ang pointer sa character.
At anumang string na mayroon kang dapat magtapos may backslash zero, na kung saan ay lamang
isang c convention.
>> Ito ay tinatawag na null Terminator.
At null -
capital N, kabisera U, kabisera L, capital L -
ay hindi kapareho ng Null Terminator.
Ito ay isang pointer.
Ito ay isang character.
Ang mga ito ay masyadong naiiba.
Alalahanin ito.
Ito ay magiging sa pagsusulit, marahil.
Hindi ko pa nakita ang pagsusulit.
Oo?
>> Madla: Kaya null ay, sabihin nating, ang pointer?
>> Dan: Oo.
>> Madla: Ano ang [hindi marinig]?
>> Dan: Kung, halimbawa, ang malloc ay tinatawag na kapag nag- ay walang sapat na memorya upang makakuha ng
kahit anong laki ka humihingi, malloc ay magbabalik null.
Ito ay, talaga, tuwing may function ay dapat na magbalik ng pointer, mo
kailangan upang suriin laban null dahil Null ay isang medyo magandang -
ito, uri ng, ang halaga ng basura.
Ito ay isang zero na kasing layo ng pointer pumunta.
>> Tuwing tumawag ka ng isang function, na nagbabalik ng isang pointer.
Ikaw ay pagpunta sa nais na tingnan upang Siguraduhin na na pointer ay hindi null
dahil walang bisa ay napaka-pangkaraniwan.
Ito ay uri ng isang basura return.
Kaya kung ang isang bagay ay hindi pumunta karapatan, bumalik lamang null sa halip.
>> Madla: [hindi marinig]?
>> Dan: Oo, at iyon ito.
>> Madla: [hindi marinig]?
>> Dan: Spell ito bilang ito.
Ito ay ang null Terminator.
Ito ay maliit na mga N-U-L-L kung ka sa pagbaybay ito.
>> Madla: At ko lang ang pinuntahan bumalik at nasubok ito.
At kung susubukan mo *** maglagay ng mga lumulutang na tuldok Pinahahalagahan sa isang paglipat, ito ay sumigaw sa iyo
na nagsasabi, pahayag ay nangangailangan ng expression ng integer uri.
>> Dan: May pumunta ka.
Ngunit oo, ano ang muli ay ang tanong?
>> Madla: [hindi marinig]?
>> Dan: So capital N, kabisera U, kabisera L, capital L ay isang aktwal na c bagay.
Ito ay ang null pointer at magpo lamang ituring bilang ganito.
Hindi mo kailanman subukan at pagbaybay sa Null karakter at makita ang anumang mga
iba pang mga paraan kaysa ito.
Oo?
>> Madla: Kaya pagbalik sa pansamantalang trabaho max o isang bagay sa mga tala, gagawin ito
magsama ang parehong pag-andar ng [mga hindi marinig]?
>> Madla: Kaya mo nagre-refer sa bumabalik na pansamantalang trabaho max mula getchar, o
kahit ano ito ay?
>> Madla: Oo.
>> Madla: Oo, kaya ang mga pangkalahatang termino para sa lahat ng mga bagay
ay nagbabantay halaga.
Kaya tulad ng mga bumabalik na int max mula GetInt at pansamantalang trabaho max mula getchar, ito ay
dapat na maging tulad ng, ang lahat ng karapatan, kung mga bagay na ito ay bumabalik sa amin,
may nangyaring mali.
>> Para sa mga paalala, namin mangyari lamang na magkaroon ang halaga na ito nagbabantay na lahat ng tao
Sumasang-ayon ang oras.
At ito ang bagay na ikaw ay bumalik kapag bagay pumunta mali.
Kaya pansamantalang trabaho max ay kung ano ang aming ginagamit upang kumatawan ng isang bagay
tulad null o getchar.
>> Madla: Kaya't kung sinusubukan mo getchar, maaaring ilagay mo lamang null?
Gusto na gumawa ng isang pagkakaiba?
>> Dan: Ikaw ay hindi maaaring lamang suriin null.
Ang kailangan mong i-tsek pansamantalang trabaho max dahil ang balik na halaga mula sa function ay
isang character na hindi isang pointer.
Oo?
>> Madla: Humihingi ang tanong na ito para ang haba string.
Ba na isama ang null character na?
>> Dan: Hindi.
At iyon ang aktwal na haba paano string nakakaalam upang itigil dahil ito napupunta sa pamamagitan ng
ang iyong mga array ng mga character hanggang nakikita ito ng isang null character.
At pagkatapos ito ay tulad ng, ang lahat ng kanan, ako tapos na.
>> Madla: [hindi marinig] limang?
>> Dan: Kamusta ay magiging lima.
Yep.
Kaya array ay tuloy-tuloy na mga bloke ng memorya.
Ang mga ito ay agad na access sa pamamagitan ng sinasabi ng pangalanan ng array at pagkatapos, sa kulot
tirante, kahit anong index na gusto mong pumunta sa, sila ay na-index mula sa zero sa pamamagitan ng
ang haba ng array minus 1.
>> At ang mga ito ay ipinahayag sa pamamagitan ng mga uri ng bagay na kayo ay ang pag-iimbak sa
array, ang pangalan ng array, at pagkatapos ay anuman ang laki ay ng na array.
Kaya ito ay isang pansamantalang trabaho array ng haba anim na may mga halagang ito.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Oo.
>> Madla: [hindi marinig]?
>> Dan: Kung mayroon kang kung ano ang pagpunta sa array na ginawa.
Kaya maaari mong tukuyin ito sa halip bilang, sabihin, pansamantalang trabaho, anuman ang pangalan ng iyong
array ay, walang laman ang mga bracket ay katumbas ng kulot suhay H pinaghihiwalay ng kuwit E L pinaghihiwalay ng kuwit L
O kuwit null karakter at kulot suhay.
Iyon ay din gumana tulad ng isang deklarasyon.
>> Madla: [hindi marinig]?
>> Dan: Pagkatapos kailangan mong magkaroon na ginawa sa laki.
>> Madla: [hindi marinig]?
>> Dan: Oo.
Ang lahat ng mga righty.
Mga argumento command line ay paraan ng pagkuha ng input mula sa gumagamit na ito bilang
argumento sa main.
Main tumatagal ng dalawang argumento.
Ang dami ng mga argument na pagiging pumasa sa kahabaan ng command line at isang
string ng vector o isang string array ng lahat ng mga argumento.
>> Kaya kung ako, sabihin nating, na tinatawag na isang function tulad ng isang dot out 1 espasyo, 2 espasyo, tatlo,
argc ay magiging 4.
At ang argv 0 ay magiging out ng isang tuldok.
Argv1 ay magiging 1.
argv2 magiging 2. argv3 ay magiging 3, sa partikular na kaso.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Ang huling elemento sa array dahil ang array ay haba argc plus
isa sa argb, ang huling elemento ay ang null pointer.
Ito ay argc plus 1.
Kaya sa kaso na ko lang ang sinabi, ito ay argv 0 ay isang tuldok out.
argv 1 ay 1. argv2 ay 2. argv 3 ay 3.
argv 4, na isang mas malaking kaysa argc ay magiging walang bisa.
>> At iyon ang null pointer.
Oo.
At iyon ay dahil sa string ay isang pansamantalang trabaho bituin ay isang pointer.
Kaya ito ay dapat na parehong uri.
Oo?
>> Madla: Dalawang mga katanungan.
Kaya isa, ano ang pagkakaiba sa pagitan ng ito at iba pang mga GetString sa isang uri
sa gumagamit engine?
At dalawang, ay ito na naka-imbak sa loob iyong kamakailang memory?
Kaya tulad ng, GetString gagawin maging [hindi marinig]?
>> Dan: Saan ay ito na naka-imbak?
Hindi ko alam kung saan naka-imbak ito.
>> Madla: Kaya, talaga, alam mo kung ilang mga Ang function na tawagan ka nito ng mga argumento
ay naka-imbak sa stack?
Kaya argc at argv mga argumento sa main at sila ay nasa stack, o talaga
lamang sa itaas kung ano sa tingin mo bilang sa simula ng stack.
Ano ang iba pang mga bahagi ng mga tanong?
>> Madla: Kaya ano ang [hindi marinig]?
>> Dan: Oo, ito ay lamang ng isang iba't ibang mga paraan ng pagkuha ng input mula sa user.
Bahagyang mas mahusay at isa na ito ito ay handier para sa mga script dahil sa iyo
Maaari lamang pumasa sa mga argumento sa iyong pangunahing pag-andar kaysa sa maghintay
para sa mga gumagamit kung wala kang anumang mga gumagamit.
>> Madla: At oo, kumuha ng mga string ay magiging [hindi marinig].
Ito-imbak ang mga bagay na kailangan mo.
>> Dan: Oo?
>> Madla: [hindi marinig]?
>> Dan: Oo, argv 0 palaging kasama ang tuldok slash ng pag-andar ng tawag.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Oo, ang bawat isa sa mga argument ay Tinapos sa null karakter dahil sila
ay mga string.
>> Madla: [hindi marinig]?
>> Dan: Oo, argv argc ay isang null pointer.
>> Madla: [hindi marinig]?
>> Dan: Oh oo.
Oo, paumanhin.
>> Madla: Kaya [hindi marinig]?
>> Dan: Kaya ang tanong ay kung mayroon kang mga command line tuldok iwa isang tuldok out 1, 2,
gagawin ang bilang ng mga linya ng command argumento maging dalawa o magiging tatlong?
>> Madla: Sa tingin ko hindi talagang mahalaga.
May posibilidad kong sabihin, oh, ikaw ay hindi pumasa anumang mga argumento command line kapag,
malinaw naman, na tinatawag na sa iyo ang pag-andar.
Kaya may posibilidad kong vocally ibukod ang pag-andar mula sa command line
argumento kahit na ito ay kasama sa argv.
>> Dan: Ngunit kung ito ay sa test -
oo - at din kung sabihin mo ng isang bagay tulad ng argc ay katumbas ng 3,
ikaw ay nasa ligtas na kalagayan.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Sa tingin ko kung sa halip na tumawag ito sa argc at string argv bracket
ngunit iningatan ang parehong uri at tinawag na lamang ang mga ito ng isang bagay na iba't ibang tulad ng isang
at b, magdudulot ito pa rin gumagana?
At gusto pa rin gumana, gagawin mo lang -
sa halip ng paggamit argc - nais mong gamitin ang isang at b.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Kaya ang tanong ay GetString ay pagpunta sa mag-imbak ng memory sa magbunton
dahil GetString ay pansamantalang trabaho *.
Nag-iimbak ito ng memory sa kimpal dahil ito tawag ngayon malloc sa loob ng aktwal na
pagpapatupad ng GetString.
OK, gumagalaw sa.
>> Security.
Kaya upang maging tunay na secure, umasa ka sa walang isa at daan sa iyo walang access sa anumang
ng iyong impormasyon, na ang dahilan kung bakit Bumubuo ang lahat ng tao ng kanilang sariling mga machine,
kanilang sariling mga operating system, ang lahat ng kanilang mga programa mula sa simula, at nang walang alinlangan
huwag kumonekta sa anumang iba pang mga makina sa pamamagitan ng internet.
Kaya mga computer ay hindi secure.
Sila talaga ay.
Mayroon kaming pagkatiwalaan ibang mga tao.
>> At ang ideya ng seguridad ay na ikaw ay sinusubukang upang limitahan ang halaga ng
pinagkakatiwalaan na kailangan mo.
At isa sa mga paraan gagawin mo na ay sa pamamagitan ng cryptography.
Cryptography ay, mahalagang, mayroon kaming mga lihim.
>> Minsan mayroon kaming upang pumasa sa aming mga lihim kasama sa pamamagitan ng, sabihin nating, sa internet o
iba pang mga bagay.
At hindi namin gusto mga tao upang malaman ang mga lihim.
Kaya i-encrypt namin ang aming mga lihim sa isang paraan na inaasahan namin na maaari tayahin walang sinuman.
>> Kaya ginamit namin -
sa pamamagitan ng kurso ng klase na ito -
mga bagay tulad ng Caesar cipher at [Hindi marinig], na ay parehong napaka, napaka
hindi secure na paraan ng pag-encrypt bagay.
Ang mga ito ay madaling upang malaman kung ano ang kanilang at kung ano ang iyong mga lihim ay.
Ang tunay na mundo ay gumagamit ng higit pa kumplikadong mga scheme ng pag-encrypt.
At hindi namin makuha sa magkano ang higit sa na.
>> Pag-debug.
GDB ay ang pinakamahusay na.
Pupunta ako sa Stress muli ito.
Gamitin GDB sa lahat ng oras bawat oras mayroon kang problema.
Command na kapaki-pakinabang sa GDB ay masira, kung saan ka pumasa alinman sa isang linya
numero, ang isang pangalan ng function, mahalagang kung saan ang iyong code na gusto mong ihinto,
at magagawang kontrolin.
>> I-print tumatagal ng isang variable at mga Kopya out kahit anong variable na hindi na
ituro sa iyong pagpapatupad.
Susunod na gumagalaw ang iyong pagpapatupad sa kahabaan ng isang hakbang.
At hakbang na hakbang sa loob ng isang function sa iyong pagpapatupad.
>> Iba pang mga bagay ay tatakbo, kung saan ay kung paano aktwal mong patakbuhin ang iyong mga code.
Magpatuloy tumatagal ng lahat ng mga hakbang na kinakailangan upang makapunta sa susunod na bakasyon point.
At doon ay marami, marami pang iba.
Hanapin ang mga ito.
Ang mga ito ay mahusay.
Oo?
>> Madla: [hindi marinig]?
>> Dan: Oo, na isang debugger.
Kaya isang debugger ay isang programa na Hinahayaan ka ng i-debug mo ang iyong programa.
Ito ay hindi isang programa na hinahanap ng mga bug para sa sa iyo, bagaman na magiging mahusay.
>> At huling para sa akin ay paghahanap.
Kaya ang mga uri ng paghahanap na aming usapan tungkol sa class na ito ay linear paghahanap,
na kung saan ay lamang na tumingin ka sa bawat elemento ng puwang ng paghahanap, ang isa
elemento sa isang panahon, hanggang sa mahanap kung ano hinahanap mo o hanggang sa maabot mo
sa dulo ng iyong espasyo sa paghahanap sa kung saan Ituro ang sinasabi mo na hindi mo mahanap
ang elemento na iyong hinahanap.
At ito tatagal sa pinakamahusay na pare-pareho ang oras, na kung saan ay 0 ng 1 at sa pinakamalala linear
oras, na kung saan ay 0 ng n.
>> Binary paghahanap, na nangangailangan ng mukhang salapi elemento.
Pumunta ka sa gitna ng iyong mga elemento, makita kung ang sangkap na iyong hinahanap para sa
ay mas malaki o mas maliit kaysa sa elemento na ikaw ay nasa gitna.
Ito ito ay mas malaki, sinasabi mo na ang ilalim ng iyong mga puwang ng paghahanap ay ang iyong
kasalukuyang lokasyon, sa gitna, at i-restart mo ang proseso.
Kung ito ay mas maliit, tumingin ka sabihin na ang - oo, ano ang up?
>> Madla: [hindi marinig]?
>> Dan: Oo.
Ang anumang uri ng pag-uuri na hindi itinuro sa ang klase ay patas na laro para sa pagsubok.
>> [Tawa]
>> Dan: At ang katotohanan na hindi mo pa nagkaroon upang gawin ito para sa isang problema set, ito ay makatarungan
laro para sa pagsubok.
>> Madla: Puwede ba namin sa paglipas ng ito kung paano -
>> Dan: Ito ay nawala sa ibabaw.
>> Tagapagsalita 2: Ang aktwal na code para sa [Hindi marinig] ay nasa study.cs50.net.
Kaya't kung tiningnan mo ang mga problema kasanayan sa pahina uriin pagsanib ng
study.cs50.net, doon ay ang code para sa pagpapatupad ng pag-uuri-merge.
Kaya hindi mo na kailangang ipatupad ito sa iyong sarili ngayong gabi.
Ngunit tiyaking nauunawaan mo ito sa halip kaysa memorizing lamang ito.
>> Madla: [hindi marinig]?
>> Tagapagsalita 2: Ang pahina ng uri pagsanib sa study.cs50.net, mayroong isang kasanayan
problema na, kung nag-click ka sa pamamagitan ng problema, sa dulo napaka mayroong isang
solusyon, kung saan ay ang pagsanib pagpapatupad uri.
Ngunit tiyaking nauunawaan mo ito sa halip na memorizing lang ito
o pagkopya ito pababa.
>> Madla: At isang perpektong wastong problema para sa pagsusulit ay magiging
ang isang bagay tulad narito ang isang listahan.
Ano ang listahang ito hitsura pagkatapos isang hakbang ng mga seleksyon-uri-uriin o
uri pagpapasok o kahit anong.
Isang ganap na pag-ulit ng listahan.
Kaya kahit na hindi ka humantong sa nangangailangang code para dito, kailangan mong maunawaan ito
sapat upang malaman kung paano ito ng pagpunta na ang pagbabago na ito ng array.
>> Dan: Iyon lang para sa akin.
>> [Palakpakan]
>> Lucas: Hey sa lahat.
Ang pangalan ko ay Lucas.
Pupunta ako sa pag-usapan ang recursion, lahat ang uri na natutunan, at isang
Medyo ng lahat ng mga payo.
OK?
Kaya una sa lahat, recursion.
Ano ang ibig sabihin ng sabihin na isang function ay recursive?
>> Madla: Libre ang mga tawag mismo.
>> Lucas: OK, tawag mismo, oo.
Kaya tulad ang larawang ito, halimbawa.
Ito ay tulad ng larawan sa loob ng isang litrato at iba pa.
Kaya halimbawa, maaari kang magkaroon - bilang Dan na pakikipag-usap tungkol sa binary paghahanap.
Ang isang paraan kung saan binary paghahanap ay recursive ay ang katotohanan na ikaw ay
sinusubukan mong hanapin ang isang numero.
Kaya kang pumunta sa gitna.
At pagkatapos mong suriin kung ang mga numero doon sa kaliwa at sa kanan.
>> At pagkatapos ay kung mong malaman kung ang bilang na ito ay pagpunta sa maging sa kaliwa, ito ay ang parehong
bagay tulad ng paggawa ng muli ang paghahanap ngunit lamang sa kaliwa ng listahan.
Kaya na kung paano ito tunog tulad ng ito ay recursive.
Kaya na ang dahilan kung bakit ka guys mayroon recursive solusyon para sa pag-uuri-merge.
>> OK, kaya narito ang isang halimbawa.
Kaya sabihin nating na gusto kong piliin ang ang lahat ng mga numero mula 1 hanggang n.
Maaari ko mapagtanto na ang kabuuan ng n bilang na ito ay n plus n minus 1 hanggang 1.
Ngunit pagkatapos, kung tiningnan ko sa n minus 1 plus n minus 2 plus 1, iyon ang parehong
bagay bilang summing mga numero hanggang n minus 1.
Kaya ang maaari kong sabihin ang kabuuan ng isang katumbas sum ay katumbas n plus ang kabuuan ng n minus 1.
Ba na magkaroon ng kahulugan?
>> At Gusto ko ring magkaroon ng ibang bagay tinatawag na base kaso, na kung saan ay na
ang kabuuan ng mga numero up sa zero ay magiging zero.
Kaya sa lalong madaling makakuha ako sa numero zero, itigil ko ang pagbibilang.
Ba na magkaroon ng kahulugan?
>> Kaya narito ang isang halimbawa kung paano Maaari ko *** ipatupad na.
Kaya Mayroon akong na ito function na sa ilang.
Iyon kumukuha ng isang integer n.
Kaya dito muna ako suriin kung n ay mas mababa o katumbas ng zero.
Kaya kung ito ay mas mababa o katumbas ng zero, ako bumalik sa zero, na kung saan ay ang aming base kaso.
Kung hindi man, maaari ba akong bumalik lamang n plus ang kabuuan ng mga numero mula sa
isa sa n minus isa.
Magkaroon ng kahulugan?
OK.
>> Kaya narito kung ano ang mukhang.
Mayroon kang kabuuan ng 2 Kapantay 2 plus ang kabuuan ng 1.
At ang ilan sa 1 ay 1 plus ang kabuuan ng 0, na kung saan ay 0.
Magkaroon ng kahulugan?
Kaya kung tinitingnan namin ang stack ng iyong programa, ito ay kung ano ang mukhang.
>> Una, mayroon kaming ang pangunahing pag-andar.
At pagkatapos ay ang pangunahing pag-andar tinatawag kabuuan 2.
At pagkatapos ay suma 2 ay pagpunta sa sabihin, oh, suma 2 ay katumbas ng 2 plus ang kabuuan ng isa.
Kaya idagdag ko kabuuan ng 1 sa stack.
At ang kabuuan ng 1 ay pagpunta sa tumawag sa kabuuan ng 0, na kung saan ay pagpunta din na idaragdag
sa stack.
At pagkatapos bawat isa sa mga buhay na sa tuktok ng isa pang mayroon upang bumalik
bago maaaring panatilihin ang pagpunta sa iba pang mga bago.
>> Kaya halimbawa, narito, kabuuan ng 0, una, ay pagpunta upang bumalik sa 0.
At pagkatapos ay piliin ang kabuuan ng 1.
Pagkatapos kabuuan ng 1 ay pagpunta sa bumalik 1 sa kabuuan ng 2.
At sa wakas, kabuuan ng 2 ay pagpunta upang bumalik sa 3 pangunahing.
Ba na magkaroon ng kahulugan?
>> Ito ay talagang mahalaga na maunawaan kung paano ang stack ay gumagana at subukan upang
makita kung ito ang akma.
OK, kaya pag-uuri.
Kaya bakit ay pag-uuri mahalaga, una sa lahat?
Bakit dapat naming pinapahalagahan?
Sinuman?
Bigyan mo ako ng isang halimbawa?
Oo?
>> Madla: [hindi marinig].
>> Lucas: Oo, ang OK.
Kaya maaari kang maghanap nang mas mahusay.
Iyon ay isang mahusay na paraan.
Kaya, halimbawa, mayroon kaming ng maraming bagay, talaga, sa ating mga buhay na
ay pinagsunod-sunod.
Halimbawa, mga diksyunaryo.
>> Ito ay napakahalaga na magkaroon ng lahat ng mga mga salita sa ilang mga uri ng order na kami
Maaaring i-access madali.
Kaya na kung ano ang sinasabi niya.
Maaari kang maghanap nang mas mahusay.
Isipin kung paano mahirap magiging upang magkaroon ng isang diksyunaryo kung saan ang mga salita ay nasa
random na order.
Magkakaroon ka upang tumingin sa, halos, bawat solong salita hanggang sa mahanap mo ang
salita na iyong hinahanap.
>> Kung gumagamit ka ng Facebook din, kapag tumitingin ka sa iyong mga kaibigan, ikaw ay
pagpunta upang makita na ilagay ang iyong mga Facebook mas malapit na kaibigan ang nasa tuktok ng mga bago
na hindi mo makipag-usap sa na magkano.
Kung pumunta ka sa lahat ng mga paraan sa ibaba ng iyong listahan ng kaibigan, ka pagpunta upang makita ang
mga tao na malamang na hindi kahit na tandaan na ikaw ay may mga kaibigan.
At iyon ay dahil sa uri Facebook ang iyong mga kaibigan batay sa kung paano
isara ay sa iyo sa kanila.
>> Kaya pag-aayos ng data.
Gayundin Pokemon.
Kaya tingnan mo na ang lahat ng Pokemons may mga numero.
At iyon ay tulad ng isang madaling paraan ng pag-access ng data.
>> Madla: Pag-access sa Pokemon.
>> Lucas: Oo.
>> Madla: [hindi marinig].
>> Lucas: yep.
OK, sa gayon uri pagpili.
-Uri-uriin ang Pinili ay pagpunta upang piliin ang pinakamaliliit unsorted halaga ng isang listahan ng bawat
oras sa bawat pag-ulit.
Ito ay uri ng tulad ng pag-aayos na ginawa mo sa iyong ulo kapag sinusubukan mong i-
-uri-uriin ang listahan sa kamay.
>> Talaga, lahat ng gagawin mo ay tumingin ka para sa pinakamaliliit na numero.
Inilagay mo ito sa pinagsunod-sunod listahan.
At pagkatapos ay tumingin ka para sa susunod pinakamaliliit na numero.
At pagkatapos ay panatilihin ang iyong ginagawa na at iba pa.
>> Kaya uri seleksyon ay isa lamang sa iyo pumili sa bawat oras na ang pinakamaliit na
unsorted halaga.
Ilagay sa dulo ng pinagsunod-sunod bahagi ng listahan.
At panatilihin ang paggawa na.
Kaya sabihin mabilis na makita kung ano ito kamukha.
Kaya narito ang pinagsunod-sunod at unsorted listahan.
>> Kaya para sa pinagsunod-sunod ng mga listahan, ito ay una walang laman.
At pagkatapos ay ako pupunta upang piliin ang pinakamaliliit na numero dito, na kung saan ay 2.
Kaya nakukuha ko ang numero 2 at ilagay ko sa harap ng listahan.
At pagkatapos ay tumingin ako para sa susunod na pinakamaliit elemento, na kung saan ay 3.
Kaya ko *** ilagay ito sa dulo ng pinagsunod-sunod listahan.
At pagkatapos ay panatilihing ako ginagawa iyon.
Ako makahahanap ng 4 at ilagay ito sa dulo.
Maghanap ng 5 at ilagay ito sa dulo.
>> At tingnan natin kung paano ang lahat ng mga oras na iyon na Ako na nagsasabi ilagay ito sa dulo ay,
talaga, pagpapalit ng dalawang mga halaga.
OK?
At pagkatapos ay ang huli, ikaw lamang may isa pang elemento.
Kaya ito na pinagsunod-sunod.
>> OK, sa gayon uri pagpapasok.
Insertion uri ka ng pagpunta sa mayroon din na bagay ng pagkakaroon ng pinagsunod-sunod at
isang unsorted listahan.
Ang tanging bagay ay na sa bawat oras na nagdadagdag ka ng isang elemento sa pinagsunod-sunod
listahan, piliin mo lamang ang sangkap na Nasa harapan ng unsorted listahan.
At pagkatapos ay ka pagpunta upang malaman kung ano iposisyon ito ay dapat sa pinagsunod-sunod
bahagi ng listahan.
>> Ni makita kung ano ito ay kaya Hayaang ito ay ginagawang higit pang kahulugan.
Kaya sa simula, halimbawa, sinusubukan ko upang ipasok ang numero ng tatlong sa
pinagsunod-sunod bahagi ng listahan.
Kaya ang listahan ay walang kahit ano.
Kaya maaari ko *** ilagay lamang ang bilang 3.
>> Ngayon, gusto kong magdagdag ng mga numero ng 5 hanggang ang pinagsunod-sunod bahagi ng listahan.
Kaya tumingin ako sa numero 5.
Napansin ko na ito ay mas malaki kaysa sa 3.
Kaya alam ko na ito ay dapat na pagkatapos ng 3.
Kaya ko *** ilagay ang 3 at 5.
>> Pagkatapos Gusto kong ipasok ang numero 2.
Napansin ko na ang numero 2 ay ang tunay tatagal pagkatapos ay parehong 3 at 5.
Kaya talaga akong magkaroon upang ilagay nito ang lahat ng paraan sa simula ng listahan.
Kaya kailangan kong, uri ng, shift ang lahat ng mga mga elemento sa pinagsunod-sunod listahan sa gayon maaari ko
gumawa ng room para sa bilang 2.
>> Pagkatapos makita ko ang bilang 6.
Nakikita ko na ito ay dapat pagkatapos ng 5.
Kaya ko *** ilagay ito doon.
At sa wakas, tumingin ako sa numero 4.
At napansin ko dapat ito nasa pagitan ng 3 at 5.
At pagkatapos ko *** ilagay ito doon at shift lahat ng iba pang mga elemento.
Magkaroon ng kahulugan?
>> Bubble-uri-uriin.
Kaya bubble-uri ay isa lamang kung ano ang iyong pagpunta sa gawin - tawagan namin ito bubble
uri dahil pumunta ka sa mga listahan - ito ay talagang mas mahusay na kung ako ipakita lamang
gusto mo ito -
at tapos ka ng pagpunta sa ihambing Katabi numero.
At ka ng pagpunta magpalit ng kanilang mga posisyon kung wala ang mga ito
sa kanang order.
>> Kaya talaga, kung ano ang pagpunta sa mangyari ay dito, halimbawa,
mayroon kang 8 at 6.
Alam mo na ang pinagsunod-sunod-sunod habilin talagang maging 6 at 5, tama?
Kaya ka pagpunta sa magpalit ng mga order.
Pagkatapos nakakakita ako ng 8 at 4 dito.
At gagawin ko ang parehong bagay.
Magpalit ako muli.
At sa wakas, 2 at 8.
Magpalit din ako sa kanila.
>> Ito ay tinatawag na Bubble-uri-uriin dahil pagkatapos ng bawat isa sa mga iterations, talaga,
ang pinakamalaking bilang sa listahan ay makakakuha ng lahat ang daan sa dulo ng listahan.
Ba na magkaroon ng kahulugan?
Dahil iniingatan nito ang pagpapalit ito at paglipat ito sa kanan.
>> OK, kaya ito ay ang pangalawang pag-ulit.
Mas ang parehong bagay.
Kukunin ko gawin ang isa swap at pagkatapos ay ang huli.
Ako na walang mga swaps at ang listahan ay pinagsunod-sunod.
Kaya sa Bubble-uri-uriin, talaga naming panatilihin pagdaan sa listahan at pagpapalit
bagay hanggang sa mapansin ko na hindi ko ginawa anumang swaps paggawa na iteration, na
Ibig sabihin nito na listahan ay naka-pinagsunod-sunod.
Magkaroon ng kahulugan?
>> Usapan natin ng kaunting Hayaan tungkol sa pagpapatakbo ng oras.
Kaya naaalala mo guys Big O, Omega, at Theta?
Oo?
OK, ano ang una sa lahat ng Big O,?
>> Madla: [hindi marinig].
>> Lucas: Oo, ito ay tinatawag na isang pinakamasama kaso runtime, na lamang ay nangangahulugan na ito ay
kung magkano ang mong asahan ang programa upang gawin upang tumakbo.
Tulad ng, sa mga tuntunin ng -
sa kasong ito - n.
Ang bilang ng mga elemento sa ilista sa pinakamasama kaso.
Tulad ng, sa pinakamasama posibleng kaso.
>> Kaya para sa Bubble-uri-uriin, halimbawa, mayroon kaming Big O ng n square.
Bakit mayroon namin iyon?
Bakit Bubble-uri-uriin Big O n square?
>> Madla: [hindi marinig].
>> Lucas: Oo, kaya ang pinakamasama kaso ay magiging na kukunin ko na gawin n iterations.
Kaya bawat isa sa mga iterations ay pagpunta sa dalhin ang pinakamalaking elemento sa dulo
ng listahan.
Kaya ang pinakamasama kaso ay na mayroon akong upang gawin iyon bagay n ulit.
At para sa bawat isa sa mga oras na iyon, mayroon akong upang gawin n swaps dahil mayroon akong upang ihambing
bawat dalawang mga elemento.
Kaya na ang dahilan kung bakit n ito ay nakalapat dahil ito ay n beses n.
>> Pagkatapos, uri seleksyon ding n parisukat dahil, para sa bawat pag-ulit, mayroon akong upang
tumingin sa bawat solong elemento sa listahan.
At pagkatapos ay hanapin ang pinakamaliit, na nangangahulugan na mayroon akong upang
tingnan ng masinsinan n elemento.
At kailangan kong gawin na beses n dahil Kailangan ko *** piliin ang lahat ng mga elemento n.
>> Isang uri pagpapasok ding n parisukat dahil ang pinakamasama kaso sitwasyong habilin
ay, isa, mayroon akong upang ipasok n numero, tama?
Kaya alam ko na na pupuntahan ko magkaroon n iterations.
Ngunit para sa bawat isa sa mga numero, kung mayroon ako upang tumingin sa lahat ng mga numero sa mga
ang pinagsunod-sunod listahan at ilagay ito sa lahat ng paraan nasa harap, na magiging n parisukat
dahil ito ay beses n muli n.
Magkaroon ng kahulugan?
Paano ang tungkol sa wakas?
>> Madla: [hindi marinig].
>> Lucas: Ito ang pinakamahusay na sitwasyon kaso.
Kaya ito ay tulad, ng maraming beses para sa pag-uuri, ang pinakamahusay na kaso sitwasyon ay
kapag ang listahan ay naka-pinagsunod-sunod.
Kaya huwag talaga mayroon kang gumawa ng kahit ano.
Bubble-uri-uriin ay ang pinakamahusay na kaso sitwasyon ng n.
Ka guys Alam ba kung bakit?
>> Madla: [hindi marinig].
>> Lucas: Oo, kung kang subaybayan ang mga kung takdang kabahagi data ay nagkaroon ng anumang swaps o
Hindi, kung mayroon kang isang bagay tulad ng hanay sa totoo kung nagkaroon ng iteration, kung ang
listahan ay naka-pinagsunod-sunod, talaga, kung ano ang mangyayari ay pupuntahan ko
subukan magpalit ng bawat dalawang Katabi elemento.
Pupunta ako upang makita na walang mga swaps.
At ako bumalik lang agad-agad.
>> Kaya ibig sabihin nito na ako lang ang kinailangan pumunta sa pamamagitan ng listahan ng isang oras.
Kaya n dahil Inaasahan ko sa n elemento.
Bakit pagpili ng uri n Square?
>> Oo, kahit na ang listahan ay pinagsunod-sunod, para sa bawat pag-ulit ng uri seleksyon, ako
may upang piliin ang mga minimum na elemento.
Kaya ibig sabihin nito ay na mayroon akong out upang tumingin sa lahat ng mga elemento sa unsorted
ilista at hanapin ang minimum para sa bawat pag-ulit.
Ba na magkaroon ng kahulugan?
>> At tabak pagpapasok ay N dahil sa kaso na sinusubukan ko upang ipasok ang
mga numero at ang lahat ng mga numero, kapag ako subukan upang ipasok ang mga ito, nakikita ko na sila
ay nasa kanan posisyon.
Hindi ko na kailangang pumunta suriin ang lahat ng iba pang mga numero sa unsorted listahan.
Kaya na ang dahilan kung bakit ito ang magiging n.
Magkaroon ng kahulugan?
At ano ang theta?
>> Madla: [hindi marinig].
>> Lucas: Ano, paumanhin?
Sabihin itong muli.
>> Madla: [hindi marinig].
>> Lucas: Mismong.
Kaya maaari mong makita na lamang seleksyon naka-imbak sa Pagsamahin ang uri mayroon thetas.
At iyon ay dahil sa mayroon theta mo lamang kung pareho Big O at Omega ay pareho.
OK.
At sa wakas, pagsamahin uri ay kung log-in n.
>> At pagkatapos, bilang sinasabi Dan, Pagsamahin ang uri ay uri ng tulad ng sa parehong paraan na
mong gawin binary paghahanap.
Kaya makuha mo ang listahan.
At ka pagpunta upang i-cut sa kalahati.
At pagkatapos mo i-cut ang mga ito sa mas maliit na halves.
At pagkatapos mong pagsamahin ang mga ito.
Ikaw guys tandaan na, i-right?
OK, pati na sinasabi niya.
>> OK, mga payo.
Kaya kung ano ay isang pointer?
>> Madla: [hindi marinig].
>> Lucas: Isang address.
OK.
Alam ko na si David ay nagpapakita ng grupo ng video ng binky at mga bagay na tumuturo
isa't isa.
Pero gusto kong isipin na pointer bilang lamang ng isang address.
Kaya ito ay isang variable na ay pagpunta mag-imbak ng isang address.
>> Kaya lamang ito espesyal na variable na apat na bytes mahaba.
Tandaan, na pointer sa anumang bagay ay laging apat na bytes mahaba para sa aming 32-bit
machine kaya ang kaso sa ang appliance.
At ito lamang ay ang lokasyon ng isang variable sa loob nito.
>> OK, kaya walang ito memorya, talaga.
Kaya ang bawat bloke ng memorya talagang ay may label, kung saan ay ang address ng
slotty memorya.
Kaya ibig sabihin nito ay na maaari akong magkaroon isang pointer pagturo sa
anuman sa mga address na ito.
Kaya ang dahilan kung bakit gagamitin namin ang mga payo ay kung mayroon akong tandaan ang lokasyon
na ang isang tiyak na variable ay isang memory.
>> At guys tandaan na ang isa sa mga mga kaso ay kung mayroon akong isang function
kung talagang ko na gusto mong magpalitan para sa reals, ako talaga
may upang magpadala ng isang pointer.
Hindi ang variable.
Huwag mo guys tandaan na?
Ang pagkakaiba sa pagitan ng -
ano ang pangalan mo?
Tumatawag sa pamamagitan ng halaga at pagtawag sa pamamagitan ng sanggunian, tama?
>> OK, oo.
Kaya tumawag sa pamamagitan ng halaga.
Kapag nagpadala ka lamang sa isang variable sa function na lamang ka sa pagpapadala ng isang halaga.
Kaya mo talaga Ipinapadala isang kopya ng variable.
At iyong programa ay hindi mai-aalaga mas kaunti tungkol sa kung ang parehong mga variable na talaga
gumagawa ng isang kopya.
>> At sa pagtawag sa pamamagitan ng sanggunian ay nangangahulugan na Talaga ako sa pagpapadala ng kopya ng
pointer sa variable na iyon.
Kaya ibig sabihin nito na ako sa pagpapadala ng lokasyon ng variable na iyon.
Kaya pakiramdam Mayroon akong ang lokasyon ng variable, kapag tumawag ako ang function
may mga payo, ako makakapag-talaga baguhin ang data na noon ay sa pangunahing.
Magkaroon ng kahulugan?
>> Kahit na, ang pointer ay isang kopya, ang pointer pa rin ang may tunay na address ng
ang variable na gusto kong baguhin.
Magkaroon ng kahulugan?
>> Kaya paglikha ng mga payo.
Tandaan, ang pointer ay laging may ang uri na ito ng pagturo
sa at pagkatapos ay isang bituin.
At pagkatapos mong ilagay ang pangalan.
Kaya tandaan na sa tuwing mayroon kang kahit anong bituin, ito ay tulad ng isang pointer upang
na kung ano ang variable type na mayroon kang.
>> Kaya dito sa bituin, halimbawa, ito ay isang pointer at isang integer.
At pagkatapos ay pansamantalang trabaho bituin ay isang pointer pansamantalang trabaho bituin at iba pa.
Oo?
>> Madla: Paano kung mayroon kaming pointer sa n sa star x.
Alam ko na lumilikha ng isang pointer sa x.
Ito rin idedeklara ba x isang integer?
>> Lucas: OK, kaya kapag sinabi mong n star x, hindi lumilikha ka ng isang pointer sa isang
variable na x.
Lumilikha ka ng isang pointer na may pangalang x.
>> Madla: [hindi marinig].
>> Lucas: Kaya kapag sinabi ko n star x, ako na nagsasabi, hey, sa memory, pupuntahan ko
makakuha ng isa sa mga tatlong mga kahon.
At pupuntahan ko sabihin na iyon ay magiging x, na kung saan ay
pagpunta sa maging isang pointer.
At isang bagay na kawili-wiling tungkol sa mga payo ay na sabihin namin na mayroon sila
4 bytes para sa isang 32-bit na machine.
At ang mga dahilan para sa na ay dahil 4 bytes ay 32-bit.
>> At machine na 64 bits talaga may mga payo address
na 64 bits mahaba.
Kaya nangangahulugan lang ito na ang sukat ng mga address sa makina ay iba.
>> Kaya na tumutukoy at Dereferencing.
Mayroong dalawang mga operator na ka guys dapat tandaan.
Ang unang ay ampersand.
Pangalawa ay bituin.
Huwag makakuha ng malito sa pamamagitan ng na ang pagbuo at ito lagyan ng star dahil tandaan na, sa
kasong ito, mayroon kang n bituin.
>> Ito ay tulad ng isang buong bagay nang magkakasama.
Walang n puwang bituin.
Kaya ibig sabihin nito na ito ang uri.
Tandaan, na kapag mayroon kang ang variable na bituin, ikaw ay
pakikipag-usap tungkol sa mga uri.
>> Kapag nakapag-lagyan ng star lamang at pagkatapos ay ang pangalan ng variable, nangangahulugan ito na
ka dereferencing ang pointer, na ay nangangahulugan na ang iyong hinahanap sa
pointer, paghahanap ng mga address ito na tumuturo sa, pagpunta sa address na iyon,
at tumitingin sa tuwing mayroon kang doon.
Kaya sinasabi ko sa aking mga mag-aaral na kapag mayroon kang star, dapat mong isipin na ito
ang pagpapaikli ng nilalaman ng.
>> Kaya kung mayroon kang isang pointer at mo gawin star pointer, ito ay ang
nilalaman ng pointer.
Kaya kang pumunta sa kahit anong ito ay tumuturo sa at tumingin sa pare-pareho ang nilalaman.
At ang ampersand ay pareho bagay tulad ng address ng.
>> Kaya kung mayroon akong isang variable - tulad ng, sabihin sabihin na ginawa ko int isang katumbas ng 3 -
kung gusto kong hanapin ang address ng na variable ng memorya, maaari lamang kong gawin
ampersand isang.
Kaya ito ay address ng isang.
Magkaroon ng kahulugan?
>> Kaya narito ang isang halimbawa.
Ito ay nawawala int b at c int.
Kaya int isang katumbas ng 3 paraan na Pupunta ako upang pumunta sa memorya.
At ako pagpunta sa makahanap ng isang puwang at ilagay ang numero ng 3 dito.
>> At pagkatapos int b ay katumbas ng 4.
Pupunta ako sa gawin ang parehong bagay.
Pumunta sa memorya at maglagay ng numero 4 sa isa sa mga kahon.
At int ay katumbas ng 5.
Maghanap ng isa pang kahon at maglagay ng numero 5.
>> Kaya kung ano ang line paggawa out ay? n star pa ay katumbas ng isang ampersand.
Kaya una sa lahat, n star pa.
Ano ay ito ginagawa?
>> Madla: [hindi marinig].
>> Lucas: Oo, kaya n star pa, una, declares isang pointer tinatawag pa.
At pagkatapos ito ay nagtatalaga ang halaga ng na pointer upang maging ang address ng isang.
Kaya ampersand isang.
Pagkatapos, kung gagawin ko star PB, kung ano ay isang bituin PB?
>> Oh, paumanhin.
Ito ay nawawala din. n star PB.
Ibig kong sabihin bituin pc.
Ako kaya paumanhin.
Ito ay ang parehong bagay.
Ngunit ngayon ako magandang ar paglikha ng isang pointer upang b at pagkatapos ay isang pointer sa c.
Oo?
>> Madla: [hindi marinig]?
>> Lucas: Oo.
Kaya kung pupunta ka sa memorya at pumunta ka sa ang kahon na designator para pa,
aktwal na pagpunta sa makakita ng isang address ng isang.
OK?
Oo?
>> Madla: [hindi marinig]?
>> Lucas: Oo, pointer ay isang address.
Huwag kailanman kalimutan na.
Ito ay tulad ng mga pinaka-mahalaga bahagi tungkol sa mga payo.
Mayroong ang pag-iimbak at address sa ilang mga variable.
Ano pa?
Anumang iba pang mga katanungan?
OK.
>> Kaya payo at mga array.
Tandaan na kapag gagawin ko int array 3, talaga, ano ako paggawa ay Ako, uri
ng, deklarasyon sa isang pointer.
Kaya array ay uri ng tulad ng isang pointer sa isang partikular na lugar sa memorya kung saan ako
inilalaan ng tatlong mga puwang para sa integer.
Ba na magkaroon ng kahulugan?
>> Kaya kapag ako int array 3, ano ako paggawa, talaga, ay ang paggawa ng tatlong
puwang sa memorya.
Kaya lang nakahanap ako ng tatlong mga puwang sa memorya.
Kaya kung gagawin ko, pagkatapos, isang bituin array, ito talaga ay nangangahulugan na ang nilalaman ng array,
na nangangahulugan ko *** burahin ang pointer, pumunta ako upang ang lugar na iyon na ito ay nagtuturo sa,
at ko *** ilagay ang numero ng isa.
>> At pagkatapos ay, kung gagawin ko star array plus 1, iyon ang parehong bagay bilang paggawa ng array
bracket isa, na kung saan ay nangangahulugan lamang pumunta ako sa ang lugar na ito ay tumuturo sa.
At pagkatapos ay ang plus 1 Ginagawang sa akin shift isang posisyon.
Kaya pumunta ako sa posisyong ito, talaga, at ilagay ang numero ng dalawang.
>> At pagkatapos, sa wakas, kapag gagawin ko array plus 2, pumunta ako sa kung saan
pagturo ng array ay sa.
At pagkatapos ay ilipat ko sa mga bloke ng memorya.
At pagkatapos ko *** ilagay ang numero ng tatlo dito.
Oo?
>> Madla: Kaya star array ay simpleng sinasabi pinakadulo unang punto.
At maaari kang magdagdag ng 1, dahil lang lamang kami talaga
na tumutukoy na unang address.
>> Lucas: Oo.
Bakit namin, halimbawa, sabihin natin na array 0, array 1, at array 2?
Ako na nagsasabi, bakit ang gagawin mo 0, 1, 2, 3 sa halip na 1, 2, 3?
Isa sa mga dahilan ay, isa, computer Mas gusto programmer upang magsimulang
pagbibilang mula sa 0.
Dalawang ay dahil kapag ginawa mo array 0, ito ay ang parehong bagay bilang paggawa ng array
plus 0, na nangangahulugang pumunta ako sa posisyon na iyon, at kong gawin hindi
laktawan ang anumang mga bloke ng memorya.
Kaya hindi ko ilipat ang anumang mga bloke ng memorya.
Oo?
>> Madla: [hindi marinig]?
>> Lucas: So ay nagtatanong siya kung ano ang ang pagkakaiba sa pagitan ng paggawa
ito o paggawa ng malloc.
Isa sa mga pagkakaiba ay na int array 3 ay ang paglikha ng isang
array sa stack.
At kapag gagawin ko malloc, ito Lumilikha sa magbunton.
Ba na magkaroon ng kahulugan?
>> Kaya paano ito malloc talagang gumagana?
Kaya bakit kailangang kahit naming gamitin ang malloc?
Ang iyong tagatala uri ng mga figure out lahat ang mga variable na iyong ipinahayag.
At siya ay lumilikha ng puwang para sa lahat ng mga ito sa stack.
Kaya lahat ng iyong mga variable ay pumunta sa upang maging sa isang lugar sa stack.
Kaya dito ay ang mga variable na kapaligiran.
>> Kaya talaga, puwang para sa mga variable sa memory ay inilalaan sa
compile oras.
Kaya ang ibig sabihin nito na ang iyong computer ay may upang malaman ang lahat ng mga variable
sa simula pa.
Hindi nito kailangang malaman kung ano ang halaga ka pagpunta upang ilagay sa mga ito.
Ngunit kailangan nito upang malaman kung paano maraming memorya na kailangan mo.
>> Ngunit ngayon sabihin nating, halimbawa, lumilikha ka ng isang array o pagkuha ng
string na kayo ay pagkuha mula sa user.
Hindi mo alam kung gaano katagal ang string ay magiging, halimbawa.
Kaya hindi mo alam ang eksaktong kung gaano karaming bloke memory maglaan ka, i-right?
>> Kaya ito ay hindi talagang magkaroon ng kahulugan para sa iyong sasabihin ilagay sa 100 mga character.
At pagkatapos ano kung writes gumagamit ang 150?
Ikaw ay pagpunta sa ay screwed.
>> Kaya talaga, hindi ka maaaring maging sigurado kung paano maraming memorya kailangan mong magtalaga ng
kapag compile mo ang program.
Alam mo lang na sa run oras.
Kaya na ang dahilan kung bakit mayroon kang magbunton.
Kaya ang kimpal ay pagpunta sa may memory na kayo ay paglaan ng panahon ng
tagal ng running program.
>> Kaya talaga, kapag gumawa ka malloc, kung ano ginagawa mo ay paglaan ng memory sa
runtime, na nangangahulugan na ikaw ay ang pagpapasya sa kanan sa sandaling iyon na iyong
dapat magkaroon na memorya.
Kaya na kapag tapos ka paglaan ito.
Ba na magkaroon ng kahulugan?
>> Kaya tandaan, may mga variable ng stack na nilikha sa compile oras.
At pagkatapos ay may mga variable sa magbunton na ay nilikha bilang pumunta ka
may malloc, halimbawa.
>> Madla: [hindi marinig]?
>> Lucas: So GetString ay pagpunta sa tumawag sa malloc.
Hayaan akong makipag-usap tungkol sa malloc, at Ipapaliwanag ko kung GetString.
Kaya malloc ay ang parehong bagay bilang memory laang-gugulin.
Kaya ito ay pagpunta sa maglaan memory sa magbunton.
At ito ang nangyayari upang magbalik ng pointer sa kung saan na memorya ay inilalaan sa.
>> Kaya kapag gumawa ka -
dito halimbawa -
n star pointer.
At pagkatapos pointer ay katumbas ng malloc laki ng inch beses 10.
Lumilikha ako ng isang pointer.
At pagkatapos ay ako magtatalaga na pointer sa ang halaga ng pointer na malloc
ay nagbibigay sa akin.
>> Kaya ako nagtatanong malloc maaari kang magtalaga ng espasyo para sa 10 integer.
Iyon ay kung ano ang sinasabi nito.
At nagbibigay ako pabalik malloc isang pointer sa lugar na iyon.
Magkaroon ng kahulugan?
OK.
At ako GetString ay, talaga, ang paggawa ng tumawag sa malloc sa gayon maaari mong maglaan
memory sa oras ng runtime.
>> Laging tandaan upang suriin para sa null dahil malloc ay pagpunta upang bumalik null
kung hindi ito maaaring magtalaga ng memory.
Sabihin nating magtanong sa iyo para sa isang katawa-tawa halaga ng memorya.
Ang iyong computer ay hindi pagpunta sa maging magagawang magtalaga na magkano.
>> Kaya malloc ay lamang ng pagpunta upang bumalik null.
Kaya laging tandaan upang suriin kung ang pointer na iyong nakuha mula sa malloc ay
null o hindi dahil, kung ito ay, maaari mong ay dereferencing isang pointer at
nagiging sanhi ng bahagi faults.
At sa wakas, huwag kalimutan ang iyong libreng memorya.
>> Malloc ay ang paglikha ng memory sa magbunton.
At mayroon kang upang palayain ang memorya bago nagtatapos sa programa.
OK, na ang lahat ay para sa akin.
Paumanhin, Rob.
Salamat.
>> [Palakpakan]
>> Lucas: Anumang huling tanong bago Rob pagdating?
Walang?
Oo?
>> Madla: hindi ko nakita ang isang ito online.
Nakarating na-upload na ito pa?
>> Lucas: Sa tingin ko Dave ay upload nito sa lalong madaling panahon.
>> Dave: Makikita itong i-post.
>> Lucas: Makikita ito ay online na.
>> Madla: Ito ay up.
>> Lucas: Ito ay up?
OK.
Oo?
>> Madla: [hindi marinig]?
>> Lucas: Oo, dapat mong palayain ang lahat ng mga memory na ilalagay sa magbunton.
>> Madla: [hindi marinig]?
>> Lucas: Oo.
Anumang oras na ikaw ay may isang kultura malloc, Dapat kang magkaroon ng isang kultura ng libreng
pagkatapos mong itigil ang paggamit ng variable na iyon.
Kaya malloc at libreng ay laging magkasama.
Ang kanilang pinakamahusay na mga kaibigan.
Oo.
Rob?
>> Rob: Makikita ko pumunta mabilis.
At din ay ilagay ang video up.
Mayroon akong ang mic sa.
>> OK, kaya linggo limang bagay-bagay.
Unang bagay na mayroon kami ay ang stack.
Kaya tandaan na mayroon lamang isang stack frame sa bawat aktibong function ng tawag.
Susubukan naming makita na sa isang segundo.
At din matandaan kung ano ang aktwal na napupunta sa bawat stack frame ay pagpunta sa maging
ang lokal na mga variable ng aming mga pag-andar, ang argument na ang nakapasa sa aming
mga function, kasama ng ilang iba pang mga bagay hindi mo talaga
kailangang mag-alala tungkol sa.
>> Kaya narito ang isang halimbawa kung saan ang programa, paunawa, ang mga pangunahing ay printfing ang pagbalik
halaga ng foo 4.
foo ay lamang pagpunta upang ibalik ang halaga ng bar 4 kuwit 6.
At bar ay pagpunta upang i-set ang ilang mga lokal na variable n katumbas ng 4 na beses 6.
At pagkatapos ay bumalik n.
>> Kaya tingnan natin ang stack sa buong ipaalam ang aktwal na pag-ulit ng programang ito.
Kaya mayroong ibaba ng aming stack.
Tandaan na lumalaki up ng stack.
Kaya sa ibaba ng aming mga stack, kami magkaroon ng isang stack frame para sa pangunahing.
Kapag nagsisimula ang programa, ang mga pangunahing ay palaging magiging sa
ilalim ng aming stack.
>> At kung ano ay nasa loob ng aming stack frame para sa main?
Kaya kahit na walang mga lokal na mga variable sa pangunahing, tulad ng sinabi ko bago,
mayroon kaming argc at paglalaan ng espasyo rgv sa loob ng pangunahing stack frame.
Kaya pangunahing Mawawala na ngayon sa tawagan ang function foo.
At nangangahulugan na ang foo ay pagpunta sa kumuha ng sarili nitong stack frame.
>> Kaya ngayon ikaw loob ng namin ang function foo.
At ano ang mga kailangan upang pumunta sa stack frame foo ni?
Well, foo ay may isang argument n.
At n ay katumbas ng 4 dahil iyon ang pangunahing ay pagpasa bilang argument foo ni.
>> Kaya ngayon foo ay pagpunta sa tumawag sa bar.
Ano ang bar ng pagpunta sa mayroon sa loob ng nito 'stack na frame?
Mayroon itong x katumbas ng 4 y katumbas ng anim.
Iyan ay hindi lahat na aming pagpunta sa may sa stack frame dahil bar
Mayroon ding isang lokal na n variable.
At n kami ng pagpunta sa set patas sa 24.
>> Kaya ngayon bar ay pagpunta upang bumalik n.
Kaya bar ay bumabalik sa 24 ang stack frame foo.
At dahil bar ay bumabalik na ngayon, na Ang ibig sabihin namin popping ng stack frame
para sa bar-off ng stack.
Kaya lahat ng memory bar na ito ay hindi naging gamit Naka-off ang stack ngayon.
>> Ngayon, foo Pupunta rin upang bumalik 24 sa main.
Kaya ngayon na foo ay bumabalik, ang memorya na foo na ginagamit sa sarili '
stack frame ay nawala din.
At ngayon, ang mga pangunahing ay pagpunta sa tumawag sa printf.
Kaya printf ay isa lamang function.
Kapag tinatawag naming printf, ito ay magiging isa pang stack na frame para sa printf
function na tawag.
>> Ano na tayo dumadaan printf?
Iyon ay kung ano ang nangyayari upang pumunta sa stack na frame nito.
Sa pinakadulo hindi bababa sa, kami ay pagpasa na porsiyento backslash i n at
ang argument 24.
Maaaring magkaroon ng higit sa ito ay stack frame kung printf ang mangyayari sa mga gumagamit sa ilang mga
lokal na mga variable.
Hindi namin alam.
>> Ngunit ang lahat na napupunta sa printf ni stack frame.
Ito ay pagpunta sa gawin ang printf.
Pagkatapos printf tapos na.
Ay magbabalik dito.
Sa wakas, ang mga pangunahing ay tapos na.
Ay magbabalik Main.
At pagkatapos ay aming programa ay tapos na.
Oo?
>> Madla: Sigurado ka nakakakita ng [hindi marinig]
mga argument [hindi marinig]
mga parameter?
>> Rob: Kaya doon ay isang banayad na pagkakaiba sa pagitan ng mga argumento at mga parameter.
At talagang, sa karaniwan magsalita, ang mga tao ay may posibilidad upang makihalubilo lamang sa kanila up sa lahat ng oras.
Ngunit mga parameter ay ang mga pormal pangalanan ng mga bagay.
>> Kaya argc at argv ay ang mga mga parameter sa main.
Mga argument ay kung ano ang iyong aktwal na pumasa sa bilang ng mga parameter.
Kaya doon kapag tumawag ako foo ng 4, 4 ay ang argumento ako pagpasa in
At ang mga parameter n, sa loob ng foo, tumatagal sa ang halaga ng 4
dahil 4 ay ang argumento.
>> Madla: [hindi marinig]?
>> Rob: n ay isang lokal na variable sa bar.
n ay lokal sa foo pa rin, ngunit ito ay isang parameter sa foo.
Ito ay hindi isang lokal na variable.
Oo?
>> Madla: [hindi marinig]?
>> Rob: foo Tinatawagan lamang bar at bumabalik na ang kahit anong pagbalik ng bar.
>> Madla: [hindi marinig]?
>> Rob: Oo, upang makita lamang ang maramihang stack frame.
Oo?
>> Madla: Bakit foo tinatawag na bago printf?
>> Rob: Bakit foo tinatawag na bago printf?
Kaya ko sana, sa halip, tapos isang bagay tulad ng int x ay katumbas ng foo ng 4
at pagkatapos ay naka-print na x.
Ngunit sa halip, na sinamahan ko ang pag-andar tumawag sa argumento printf.
>> Ngunit napansin na hindi namin makakaya talaga maisagawa ang pagtawag sa printf hanggang namin
malaman kung anong foo ng 4 ay.
Kaya kami ay pagpunta upang pag-aralan ito.
At nang isang beses lamang na tapos pupunta upang bumalik at suriin ito.
Oo?
>> Madla: Dahil ang parehong mga bar [hindi marinig]
halaga, bakit hindi namin mayroon [hindi marinig]?
>> Rob: Sila lahat-lahat ay dapat na int.
Iyon ay hindi nahuli sa ibabaw maramihang pass.
Kaya ito ay dapat int bar at int foo dahil pareho ng mga
ay bumabalik integer.
Walang bisa lamang kung hindi sila pupunta upang bumalik aktwal na mga halaga.
Oo?
>> Madla: Kung nagkaroon ka ng isang line sa itaas ang balik, [hindi marinig]?
>> Rob: Isang linya sa itaas ng balik?
>> Madla: Oo.
Tulad ng kung ikaw mismo ang printf at [hindi marinig], Gusto ito i-print nang dalawang beses?
>> Rob: Kaya sa loob ng foo?
Kung nagkaroon kami ng isang printf dito mismo?
>> Madla: Oo.
>> Rob: Kaya kung nagkaroon kami ng isang printf karapatan dito, mas mag-print nang isang beses.
Dahil ay pagtawag namin foo isang beses pakanan dito, pagkatapos ay gagamitin namin pindutin ang printf.
Pagkatapos ay magpapadala kami tumawag sa bar.
At pagkatapos ay magbabalik foo.
At na ito.
Nakakaapekto lamang namin nakatagpo ang printf-sabay.
Oo?
>> Madla: [hindi marinig]
printf foo pagtawag dahil kami muna pagtawag printf at pagkatapos kami ay pagpasa
ang mga argumento.
>> Rob: Kaya sa teorya, ay hindi printf pagtawag foo?
Kaya hindi.
Ang pagkakasunud-sunod lang na c ay pagpunta sa isakatuparan ang mga bagay ay, bago makakaya namin
tumawag sa isang function, ang lahat ng mga argumento sa pagpapaandar na kailangang mag-
ganap na sinusuri.
Kaya ay ito ganap na masuri?
Oo, ito ay isang string lang.
Ito ay isang halaga lamang.
>> Pagkatapos ay mayroon kaming upang ganap suriin ito.
Sa sandaling tapos na, ngayon ang lahat ng mga argument nito ay sinusuri.
At ngayon maaari naming gawin ang mga tumawag sa printf.
Oo?
>> Madla: Isa-uusapan.
Kung mayroon kang isang walang bisa function, dapat mayroon kang return tuldok-kuwit?
>> Rob: Ikaw ay hindi isang pabalik na tuldok-kuwit kung mayroon kang isang walang bisa function.
OK.
Kaya ngayon ang ilang mga bagay-bagay magbunton.
Kaya kimpal ay kung paano kami ay pagpunta sa haharapin may pamamahala dynamic na memorya.
At ito nang direkta contrasts sa stack na magiging kami tatawag sa awtomatikong
pamamahala ng memorya.
>> Kaya sa stack, hindi mo talaga magkaroon humarap sa kung paano ang lokal na mga variable
Sini-hunhon at pop-off ang lahat mga stack frame at lahat ng bagay na iyon.
Hindi mo na kailangang mag-alala tungkol dito.
Ito ay awtomatikong.
Kaya ang kimpal ay manu-mano.
At ang [hindi marinig]
ay nagmumula sa mga pag-andar malloc at libre.
>> Kaya narito ang isa pang programa.
Ang lahat ng aming ginagawa ay mallocing isang integer.
Kami ay pag-imbak nito sa star x.
Siyempre, mayroon kaming upang suriin upang makita kung ang x ay walang bisa.
Pagkatapos kami ay pagpunta upang i-set lamang kung ano x ay tumuturo sa sa 50.
I-print kung ano ang x ay tumuturo sa, x-print, at pagkatapos libreng x.
>> Kaya kung paano ito talagang pagpunta ay upang tumingin kung tinitingnan namin ang aming mga stack at magbunton?
Kaya magsisimula kaming muli.
Ang ibaba ng aming mga stack na tulad ng dati.
Tandaan na direkta sa iyo magbunton opposes ng stack?
Kaya kami ay pagpunta sa may tuktok ng aming magbunton up doon.
>> Kaya sa ibaba ng aming mga stack, mayroon kami ang aming stack na frame para sa pangunahing.
Ito ay may mga puwang para sa argc, argv, at kami Sa ngayon ay isang lokal na variable x, na
ay isang int bituin.
Kaya kami ay pagpunta upang umulit sa pamamagitan ng programang ito.
Unang bagay na mayroon kami ay ang tawag sa malloc.
>> Kaya ginagawa namin ang tawag sa malloc.
Malloc ay isang function.
Ito ay pagpunta upang makakuha ng isang stack frame.
Ano na tayo dumadaan sa malloc?
Iyon pupuntahan pumunta sa loob ng stack na frame.
Kami ay pagpasa sa laki ng n, na kung saan ay 4.
Kaya na Lumipas sa malloc.
>> Ano ang malloc gawin?
Grabs kami ng ilang espasyo sa magbunton.
Kaya kami ay pagpunta sa pumunta sa magbunton.
At kami ay pagpunta sa grab 4 bytes mula sa magbunton.
Kaya ipaalam bigyan lamang na isang arbitrary na address.
0x123 magpanggap lang na iyon ay isang tugunan iyon ay nasa magbunton.
>> Kaya kung ano ay nasa loob ng na aktwal na rehiyon ng memory sa address na Ox123?
Basura.
Kaya hindi pa namin na naka-imbak ng anumang bagay sa loob nito.
Kaya bilang malayo bilang alam namin, ito maaaring maging kahit ano.
Hindi mo dapat ipalagay ito ay zero.
Ito ay pinaka-malamang na hindi zero.
>> Kaya malloc ngayon babalik.
At kung ano ang gagawin namin kapag malloc babalik?
Itinakda namin kung ano ito ay nagbabalik.
Itinakda namin x katumbas ng kung ano ito ay bumabalik.
Kaya kung ano ay ito bumabalik?
Ito ay bumabalik 0x123 dahil iyon ang address ng bloke ng memorya na ito
lamang na inilaan sa magbunton.
>> Kaya bumalik 0x123 x Mawawala na ngayon upang maitakda katumbas ng 0x123 na, pictorially,
madalas naming gumuhit bilang x pagkakaroon ng isang aktwal na arrow na nakaturo sa mga iyon block.
Ngunit x ay ang pag-iimbak lamang address na iyon.
Kaya ngayon ay mayroon kaming upang suriin kung x ay walang bisa.
Ito ay hindi null.
Magpanggap namin na nagtagumpay na malloc.
>> Kaya ngayon star x ay katumbas ng 50.
Kaya star Naaalala ang ibig sabihin nito pumunta sa address na iyon.
Kaya 0x123 Kami ay pagpunta sa pumunta sa address na iyon.
Kaya na madadala sa amin up doon.
Ano ang mga namin paggawa sa address na iyon?
Kami ay nag-iimbak ng 50.
>> Kaya pagkatapos ng linyang ito, iyon ay kung ano ang mga bagay ay pagpunta sa hitsura.
Kaya ngayon na hindi na ito basura up doon.
Ngayon alam namin na 50 ay nasa na partikular na address dahil
set namin ito upang iyon.
OK?
Kaya ngayon kami ay pagpunta sa i-print ang f.
>> Kaya unang kami ay pagpunta sa i-print ang star x.
Kaya kung ano ang bituin x?
Muli, bituin x paraan pumunta sa bagay na x ay tumuturo sa.
Kaya x ay ang pag-iimbak 0x123 Go upang iyon.
Kumuha kami ng 50.
Kaya i-print f iyon.
At nangangahulugan na ito ay pagpunta sa i-print 50.
At pagkatapos na nagbabalik.
>> At pagkatapos ay mayroon kaming ang pangalawang printf.
Humihingi kami ngayon porsiyento p.
Kung hindi mo pa nakita ito, na lamang kung paano mo i-print ang isang pointer.
Kaya mayroon kaming porsiyento i, porsiyento f, at lahat ng mga ito nagagawa.
Kaya porsiyento p, mag-print ng pointer.
>> Kaya x ay isang pointer.
Kaya kung kami ay pagpunta sa i-print ang x mismo, kami ay nagpi-print ng kung ano ang aktwal na loob
x, na kung saan ay 0x123 Kaya ang unang naka-print na f ay pagpunta sa i-print 50.
Ang ikalawang pag-print f ay pagpunta i-print 0x123 Oo?
>> Madla: Huwag gumamit ka ng porsiyento x upang mag-print ng pointer?
>> Rob: Kaya ko gagamitin mo porsiyento x upang mag-print ng pointer?
Kaya maaari mong ngunit porsiyento x lamang, Sa pangkalahatan, para sa katulad kung mayroon kang ilang mga
integer at gusto mong i-print ito bilang isang hexadecimal.
Iyon lang ang kung paano ito gawin iyon.
>> Sapagkat, porsiyento d gagawin i-print ang bilang decimal.
Iyon ay makuha namin porsiyento d. i ay integer lamang.
porsiyento p ay partikular na para sa mga payo.
>> Kaya x ay isang pointer.
Gusto naming gamitin porsiyento p.
Ngunit porsiyento x maaaring gumana.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Oo.
Hindi bababa sa para sa tawag - kaya ko ay hindi maisama ito sa dito.
Ngunit ang dalawang argumento ay kinakailangang sa loob ng ito stack frame
kasama ng anumang lokal na mga variable printf ang mangyayari sa mga gumagamit.
At pagkatapos ay ang susunod na tawag sa printf ngayon sa loob ng printf stack frame ay
porsiyento p backslash n at anuman ang halaga ng x ay, na kung saan ay 0x123.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Makikita ito ng i-print ang isang bagay na ganito ang hitsura.
>> Madla: [hindi marinig].
>> Rob: Kaya ito ng mga kopya nito sa form na address.
Mukhang isang address.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Bakit ano?
>> Madla: [hindi marinig]?
>> Rob: Bakit ito pointer 4 bytes?
Kaya mayroong isang buong bungkos ng 0 sa unahan ng mga ito.
Kaya ito ay talagang 0x0000000123.
Sa isang 64-bit na sistema, mayroong ay magiging isang buong grupo ng mga zero.
Oo?
>> Madla: [hindi marinig].
>> Rob: Kaya ang unang printf ay pagpunta sa i-print -
>> Madla: [hindi marinig].
>> Rob: Oo, ito ay pagpunta sa pag-print ano ang x ay tumuturo sa.
Sabi ni Star kung ano ito bagay na tumuturo sa.
Grab ito.
Kaya ano ito na tumuturo sa?
50.
Grab ito.
Iyon ay kung ano ang pagpunta namin i-print.
Sapagkat, ang susunod na isa, kami ay lamang sa pagpi-print x mismo.
Ano ang nasa loob ng f?
0x123.
OK.
>> At pagkatapos, sa wakas, mayroon kaming ang libre.
Ano na tayo dumadaan sa libreng?
Kami ay pagpasa sa x.
Iyon oras ko talaga ipinapakita ito sa stack frame.
>> Kaya kami ay pagpasa sa halaga 0x123 sa libreng.
Kaya ngayon libreng nakakaalam, lahat ng karapatan, Kailangan ko *** pumunta ng hanggang sa ang magbunton
at libre na memory.
Hindi na gumagamit ito ano ay sa address 0x123.
>> Kaya libreng ay pagpunta upang palabasin na mula sa magbunton.
Ngayon ang aming kimpal ay walang laman muli.
Wala kaming memory paglabas.
Ngayon libreng ay magbabalik.
Pansinin na x ay 0x123 pa rin.
Ngunit iyon ay hindi wasto memory ngayon.
Dapat naming hindi na dereference x.
Oo?
>> Madla: Ay bumalik 0 kalabisan?
>> Rob: Ay returen 0 kalabisan?
Oo.
Ilagay lang namin na doon dahil mayroon kaming isang pabalik na isa para sa mga naka.
Kaya ito ay tulad, oo, hinahayaan isama ang return 0.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Kaya pagkatapos libreng x, ano ang mangyayari kung sinusubukan naming dereference ang pointer?
Posible na walang napupunta mali.
Posible na makikita pa rin namin makakuha ng 50.
>> Posible, din, na na memorya ay ngayon ginagamit para sa ibang bagay.
Kaya ito ay hindi natukoy na pag-uugali.
At hindi natukoy na nangangahulugan ng kahit ano Maaari itong mangyari.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Hindi, kaya kung mong italaga x sa ibang bagay.
Kaya kung dito mismo sinabi namin x ay katumbas ng malloc ibang bagay -
laki malloc kaganapan -
pagkatapos na orihinal na bloke ng memorya ay hindi napalaya.
At opisyal na namin nawala ito.
Iyon ay isang tumagas memory.
Nawala namin ang lahat ng mga sanggunian sa na bloke ng memorya.
Kaya walang paraan na maaari naming kailanman palayain ito.
OK, kaya pagkatapos ay bumalik 0 paraan tapos na.
>> Ang lahat ng mga karapatan, kaya stack overflow.
Ano ang ideya dito?
Kaya tandaan, kimpal ay pagpunta pababa.
Stack ay pagpunta up.
Kaya ito ay ang halimbawa mula sa panayam, Sa tingin ko, kung saan pangunahing Mawawala lamang sa
tumawag ito ng function foo, na kung saan ay pagpunta upang tawagan mismo recursively sa ibabaw at
sa ibabaw muli.
>> Kaya stack frame ng pagpunta sa gumana ang eksaktong pareho.
Kaya kami ay pagpunta sa magsimula sa mga pangunahing bilang ibaba stack frame.
Pagkatapos ay pangunahing ay pagpunta sa tumawag sa foo, na Pupunta upang makakuha ng isang stack frame.
>> Pagkatapos foo ay pagpunta sa tumawag sa foo muli, na kung saan ay pagpunta upang makakuha ng
isa pang stack na frame.
At pagkatapos ay muli, at muli, at muli, at muli hanggang sa, sa kalaunan, tumakbo kami
sa magbunton.
Kaya ito ay kung paano namin makuha isang stack overflow.
At sa puntong ito, seg mo kasalanan.
O gusto mo ba talagang seg fault bago puntong ito ngunit oo.
>> Madla: Ay core dump ang katulad ng seg fault?
>> Rob: Kaya makikita mo ang pagse-segment fault core dumped.
Nakakuha ka ng core dump kapag seg mo kasalanan.
At ito ay tulad ng isang dump ng lahat ng mga mga nilalaman ng iyong kasalukuyang memorya kaya
na maaari mong subukan at kilalanin bakit seg mo faulted.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Kaya ng segmentation fault ay nangangahulugan mayroong isang stack overflow.
Kaya hindi kinakailangan.
Isang segmentation fault ay nangangahulugan na ikaw ay makabagbag-damdamin memorya sa isang paraan
hindi ka dapat maging.
Kaya isang paraan ng na nangyayari ay, kapag stack mo overflow, sisimulan namin ang makabagbag-damdamin
memorya sa isang paraan na hindi namin ay dapat na.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Kaya sa loob ng isang walang-katapusang loop.
Tulad ng, ito ay tulad ng isang recursive walang katapusan loop at sa gayon makuha namin ang isa pang
stack frame sa bawat oras.
Ngunit sa loob lamang ng isang regular na walang katapusan na habang isa -
well, ni hindi man lamang i-print f ipaalam -
gawin ang isang bagay.
Anuman.
>> Hindi namin pagpunta sa nakukuha isa pang stack na frame.
Lamang kami ng pagpunta sa panatilihin looping sa ibabaw ito solong pagtuturo.
Stack ay hindi lumalaki.
Ito ay ang katunayan na ang bawat recursive tawag ay nagbibigay sa amin ng isang stack frame.
Iyon ang dahilan kung bakit nakakakuha kami ng isang stack overflow.
Oo?
>> Madla: Kaya kung sinabi sa iyo upang makuha ang habang loop at pagkatapos ay [hindi marinig]?
>> Rob: Kaya kung nasa loob ng loop habang nagkaroon ng printf, ka pa rin ng ginagawa
hindi seg fault.
Ko lang ay hindi nais upang lituhin ang mga bagay.
Ginagawa ito ng loop.
Nais mong makakuha ng isang solong stack i-frame para sa printf.
>> Pagkatapos printf ay magbabalik.
Pagkatapos mo nais muli loop.
Nais mong makakuha ng isang solong stack i-frame para sa printf.
Ito bumalik.
Single stack frame.
Kaya hindi nakukuha mo ang walang katapusang pagtatambak up stack frame.
>> Madla: [hindi marinig]?
>> Rob: Oo.
Kaya ito stack overflow ang mangyayari dahil wala sa mga ito
tawag sa foo ay bumabalik.
Kaya kung ibabalik namin, pagkatapos kami ay simulan ang pagkawala ng stack na frame.
At pagkatapos ay hindi namin malalaman stack overflow.
At iyon ang dahilan kung bakit kailangan mo ng isang base ng kaso para sa iyong personal na pag-andar.
Oo?
>> Madla: ba ang mga potensyal na laki at ang stack para sa kimpal ang parehong para sa
lahat ng programa?
>> Rob: pahapyaw na.
Ay ang mga potensyal na laki ng stack at ang magbunton pareho sa lahat ng mga programa?
Sa pahapyaw na.
Mayroong ilang mga randomization sa kung saan ang stack ng mga pagsisimula at
kung saan ang kimpal ay nagsisimula.
Kung mangyari sa iyo na magkaroon ng isang buong maraming mga pangkalahatang variable at mga bagay, maaari mong
tumagal ang layo mula sa ilang mga puwang para sa iyong magbunton.
>> Sa isang 64-bit na sistema, halos ka may walang hangganang memorya.
Mayroon lamang kaya magkano.
Sa pagitan ng 32 bit at 64 bit, na ay isang makabuluhang pagkakaiba.
>> Ikaw ay pagpunta upang makakuha ng isang buong maraming higit pa stack at magbunton space sa isang 64-bit
sistema dahil mayroong lamang nang higit pa address na maaari nilang gamitin.
Ngunit sa isang indibidwal na sistema, ay ito maging halos ang parehong dami ng stack
at magbunton espasyo.
Ayos lang.
>> Kaya huling bagay ay compilation.
Kaya dapat mong malaman ang prosesong ito.
May apat na malaking hakbang.
Kaya ang una dapat maging madaling matandaan.
Pre-processing.
Ito ay may prefix na pre sa loob nito.
Kaya pagdating bago lahat ng iba pa.
>> Ang bagay upang tandaan ay ang hash.
Kaya hash tumutukoy at hash Kasama sa lahat ng mga iyon.
Iyon ang lahat ng pre-processor mga kautusan.
Ito ang mga bagay na ang pre-processor na tumatagal ng pag-aalaga ng.
>> Kaya kung ano ang isang pre-processor gawin?
Ito ay isang talagang pipi bagay.
Ang lahat ng mga ito ay may kakayahang ay ang lahat ng mga kopyahin, at hiwa, at i-paste ang pagpapatakbo.
>> Kaya hash Kasama standard i0 tuldok h.
Ano ang paggawa?
Ito ay daklot ang standard i0 tuldok h mag-file at i-paste ito sa tuktok
kahit saan sinasabi nito hash Kasama karaniwang i0 tuldok h.
>> At anumang hash tukuyin na hindi namin nakita, ano na ginagawa?
Ang pagkopya ng halaga na ang hash tinukoy ay tinukoy bilang at pag-paste na
kahit saan ginagamit mo ang halaga.
Kaya ang ginagawa lamang ang Preprocessor talaga simpleng teksto batay pagpapatakbo.
Ito ang walang smart.
Kaya lahat ng iba pa ay higit pang kumplikado.
>> Kaya ngayon na Preprocessor ay tapos, talaga naming mag-compile.
Kaya kung ano ang ibig sabihin ng kino-compile?
Ngayon kami ng pagpunta mula sa c code sa assembly code.
Oo?
>> Madla: [hindi marinig]?
>> Rob: Oo, naabutan ka namin na iyon.
Kaya kino-compile.
Kami ay pagpunta mula sa c sa pagpupulong.
Kaya ito ay isang aktwal na baguhin ang wika.
Kino-compile ang sarili nito ay nangangahulugan ng pagpunta mula sa isang wika mas mataas na antas sa
isang wika mas mababang antas.
>> At c ay isang wika mataas na antas kumpara sa pagpupulong.
Ano ang assembly?
Mga tagubilin nito na, medyo magkano, ginawa para sa iyong CPU.
Pero ginagawa pa rin ang iyong computer hindi maunawaan assembly.
Nauunawaan lamang nito ang mga bago at mga zero.
Kaya ang susunod na hakbang ay assembling, na Dinadala sa amin mula sa mga tagubiling ito na
naiintindihan ng iyong CPU at tunay tina-translate ang mga ito, upang
ang mga bago at mga zero.
>> Kaya C upang assembly sa binary.
Ngunit hindi pa akong isang executable.
Kaya sa tingin ng cs50 library.
Nagbigay kami sa iyo ng isang binary para sa ito cs50 library, na may GetString
at GetInt at ang lahat ng iyon.
>> Ngunit ang cs50 library -
in at ng mismo - ay hindi maipapatupad.
Hindi nito ay may pangunahing pag-andar.
Ito ay lamang ng grupo ng mga binary na maaari mong gamitin.
Kaya sa pag-link ay kung paano namin tipunin ang lahat ng ng mga iba't ibang mga binary file
sa isang aktwal na executable.
Ang isa na maaari mong i-type tuldok iwa out ang dot.
>> Kaya ito ay tulad ng mga file na sa iyo Sinulat ni, - kahit anong iyong programa ay -
Ceaser tuldok c.
Ngunit ngayon itong ma-pinagsama-sama pababa sa binary.
Kaya Ceaser tuldok o.
At ito ang aming cs50 aklatan binary.
At ang mga ito ay ini-pinagsama sa iisang executable.
Oo?
>> Madla: [hindi marinig]?
>> Rob: So unang isama, alalahanin, isama ang hash ay talagang isang
hakbang pre-processor.
Ngunit iyon lamang ang hiwalay.
Kung hindi ka gumagamit ng anumang mga pag-andar na nasa labas ng iyong solong file pagkatapos,
hindi, hindi mo kailangang i-link ang anumang bagay dahil mayroon kang lahat ng bagay.
>> Iyon ay sinabi, printf ay naka-link in
Kung kailanman ginamit mo ang printf, na isang bagay na kailangang mai-link sa
dahil hindi mo isulat iyon.
At, sa katunayan, printf ay awtomatikong naka-link in
Alam mo kung paano sa command line o kapag nagta-type ka gumawa, makikita mo mayroon ito
gitling l cs50, na mayroong link sa cs50 library?
Printf, at bagay-bagay tulad na, ay pagpunta upang mai-link sa awtomatikong.
Anumang iba pang mga katanungan sa anumang bagay?
>> Madla: [hindi marinig]?
>> Rob: Pag-uugnay?
Mayroon kaming ang maramihang mga iba't ibang mga binary file.
Ito ang canonical halimbawa na ginagamit namin ay cs50 library.
Kami ay pinagsama-sama at naibigay na sa iyo ang binary para sa cs50 library.
>> Gusto mong gamitin GetString sa iyong program.
Kaya kang pumunta at gamitin GetString.
Ngunit nang wala ang aking binary code para sa GetString, kapag compile mo ang iyong code
down na, maaari mong hindi talaga tumakbo ang iyong mga programa dahil GetString String ay
Hindi pa ganap na natukoy.
>> Ito ay lamang kapag nag-ugnay ka sa aking binary na naglalaman GetString na ngayon, lahat
karapatan, maaari ko talaga isakatuparan GetString.
Aking mga file ay kumpleto na.
At maaari kong patakbuhin ito.
Oo?
>> Madla: ba ang pag-link ng convert ang binary sa mga maipapatupad na?
Kaya kahit na wala kang iba pang mga mga aklatan, Gusto hindi ito pa rin
kinakailangan upang isalin ang [hindi marinig]?
>> Rob: Kaya isang executable ay nasa binary pa rin.
Lamang Ito ay pagsasama-sama ng isang buo tungkos ng binaries.
>> Madla: Salamat sa iyo kaya magkano.
>> Rob: Walang problema.
Anumang iba pang mga katanungan?
Kung hindi man, lahat kami ay nakatakda.
Ayos lang.
Salamat.
>> [Palakpakan]
>> Madla: Salamat sa iyo.
>> Rob: Oo.