[Powered by Google Translate] [Linggo 4]
[David J. Malan] [Harvard University]
[Ito ay CS50.] [CS50.TV]
>> Karapatan lahat, ito ay CS50, at ito ay ang simula ng linggo 4,
at ito ay isa sa pinakamabagal na posibleng pag-uuri algorithm.
Aling isa ay ito na lang namin pinanood doon?
Na-uri-uriin ng bubble, upang malaki O (n ^ 2) + kabuuan,
at sa katunayan ay hindi lang kami ang mga sa mundong ito mukhang malaman
ano bubble-uuri o nito tumatakbo oras.
Sa katunayan, ito ay isang pakikipanayam sa Eric Schmidt ng Google
at dating senador Barack Obama ng ilang taon na ang nakakaraan.
>> Ngayon, Senator, ikaw dito sa Google,
at gusto kong mag-isip ng pagkapangulo bilang isang pakikipanayam sa trabaho.
Ngayon, mahirap upang makakuha ng isang trabaho bilang pangulo, at ikaw ay pagpunta sa pamamagitan ng mga kahirapan sa ngayon.
Ring mahirap upang makakuha ng trabaho sa Google.
Mayroon kaming mga tanong, at hinihiling namin ang aming mga katanungan kandidato,
at ang isang ito ay mula sa Larry Schwimmer.
Mong guys tingin ko kidding? Dito mismo.
Ano ang pinaka-mahusay na paraan upang pag-uri-uriin ang isang milyong 32-bit integer?
[Tawa]
Well-
Ikinalulungkot ko. >> Hindi, hindi, hindi, hindi.
Tingin ko ang bubble-uuri ay maling paraan upang pumunta.
>> Halika sa, na sinabi sa kanya na ito?
Huling linggo na manariwa sa diwa namin kinuha ng pahinga mula sa code, hindi bababa sa para sa isang araw,
at nagsimulang tumutuon sa ilang mga mas mataas na mga antas ng ideya at problema sa paglutas sa mas pangkalahatang
sa konteksto ng paghahanap at pag-uuri-uri,
at ipinakilala namin ang isang bagay na hindi namin sampal ang pangalan na ito sa nakaraang linggo,
ngunit asymptotic notation, ang Big O, ang Big Omega,
at kung minsan ang Big pagtatanda Theta, at mga ito ay simpleng paraan
naglalarawan ang oras ng mga algorithm,
kung gaano karaming oras na aabutin para sa isang algorithm upang tumakbo.
>> At maaari mong isipin ang na uusapang mo tungkol sa ang oras sa mga tuntunin ng laki
ng input, na namin pangkalahatan tumawag n, anumang ang problema ay maaaring,
kung saan ang n ay ang bilang ng mga tao sa room,
ang bilang ng mga pahina sa isang libro ng telepono, at nagsimula kaming na magsulat ng mga bagay ang
tulad ng O (n ^ 2) o O (n) o O (n log n),
at kahit na ang matematika ay hindi pa ehersisyo ang kaya perpektong
at n ² - n / 2 o isang bagay tulad na
gusto namin sa halip lang itapon ilang ng mas mababang mga tuntunin ng order,
at ang pagganyak sa may namin talagang gusto
uri ng layunin na paraan ng pagsusuri ng
ang pagganap ng mga programa o ang pagganap ng mga algorithm
na sa pagtatapos ng araw ay walang kinalaman sa, halimbawa,
ang bilis ng iyong computer ngayon.
>> Halimbawa, kung ikaw ipatupad ang bubble-uuri,
o ipatupad-sumanib-uuri o pagpili-uuri sa computer ngayon,
ng 2 computer na GHz, at patakbuhin mo ito,
at ito ay tumatagal ng ilang bilang ng mga segundo, sa susunod na taon may 3 GHz
o 4 na computer GHz, at maaaring pagkatapos claim na "Wow, algorithm aking
ngayon ay dalawang beses nang mas mabilis, "kapag sa katotohanan na malinaw naman hindi kaso.
Lang hardware na nakuha ng mas mabilis, ngunit ang iyong computer
ay hindi, at sa gayon ba talagang itapon ang mga bagay tulad ng
multiple ng 2 o multiple ng 3 pagdating sa naglalarawan
kung gaano kabilis o kung paano mabagal algorithm ang isang at talagang lamang tumuon
sa n o ilang mga kadahilanan nito,
ilang kapangyarihan nito tulad ng sa kaso ng uri mula sa nakaraang linggo.
At isipin ang na sa tulong ng pagsasama-uuri
nagawa naming upang gawin ito mas mas mahusay kaysa sa bubble-uuri at pagpili-uuri
at kahit pagpapasok ng-uuri.
>> Nakuha namin pababa sa n log n, at muli,
isipin ang na log n sa pangkalahatan ay tumutukoy sa isang bagay na lumalaki
mas mabagal pagkatapos n, kaya n log n sa gayon ay malayo ay mabuti
dahil ito ay mas mababa kaysa sa n ².
Ngunit upang makamit n log n sa pagsasama-uuri
kung ano ang pangunahing mikrobiyo ng isang ideya na nagkaroon kami pakikinabangan
na rin naming magagamit sa linggo 0?
Paano mo cleverly namin na matugunan ang mga problema ng pag-uuri-uri sa pagsasama-uuri?
Ano ang key na pananaw, marahil?
Sinuman sa lahat.
Okay, sabihin tumagal ng isang hakbang pabalik.
Ilarawan ang sumanib-uuri sa iyong sariling mga salita.
Paano ito gumagana?
Okay, makikita namin ang hilera pabalik sa linggo 0.
Okay, oo.
[Hindi marinig na mag-aaral]
Okay, mahusay, kaya hinati namin ang hanay ng mga numero sa 2 piraso.
Pinagsunod-sunod namin sa bawat ng mga piraso, at pagkatapos Pinagsama namin ang mga ito,
at nakakita kami ng ideya na ito bago ng paglalaan ng problema na ito malaki
at pagpuputol ito sa isang problema na ito malaki o ito malaki.
>> Manariwa sa diwa ang halimbawa ng aklat ng telepono.
Manariwa sa diwa ang self-nadaragdagan algorithm mula sa linggo na nakalipas,
kaya sumanib-uuri ay summarized sa pamamagitan ng ito pseudocode dito.
Kapag binibigyan ka n elemento, unang ito ay katinuan suriin.
Kung n <2 pagkatapos ay hindi gawin sa lahat
dahil kung n <2 pagkatapos n malinaw naman sa 0 o 1,
at kaya kung ito ay alinman sa 0 o 1 may walang kinalaman upang ayusin.
Tapos ka na.
Ang iyong listahan ay trivially pinagsunod-sunod.
Ngunit kung hindi man ay kung mayroon kang 2 o higit pang mga elemento sige at hatiin ang mga ito
sa 2 halves, kaliwa at kanan.
-Uri-uriin ang bawat isa sa mga halves, at pagkatapos ay sumanib ang pinagsunod-sunod halves.
Ngunit ang problema dito ay na sa unang tingin ito nararamdaman tulad namin ay punting.
Ito ay isang pabilog na kahulugan sa na kung tatanungin ko ang mong upang pag-uri-uriin ang mga elemento ng n
at ikaw ay nagsasabi sa akin "Ang lahat ng mga karapatan, fine, magpapadala kami-uri-uriin ang mga elementong iyon n / 2 at mga n / 2,"
pagkatapos ay ang aking susunod na tanong ay pagpunta sa "Fine, kung paano mo ayusin ang n / 2 elemento?"
>> Ngunit dahil sa ang istraktura ng programang ito,
dahil may base kaso na ito, kaya na magsalita,
ito espesyal na kaso na nagsasabing kung n <ilang nakapirming halaga tulad ng 2 return agad.
Huwag tumugon kasama na parehong pabilog na sagot.
Ang prosesong ito, ang cyclicity ito ay malaon magtapos.
Kung hihilingin ko sa iyo "-uri-uriin ang mga ito n mga elemento," at sabihin mo, "Fine, uri-uriin ang mga n / 2,"
sinabi mong, "Fine,-uri-uriin ang mga n / 4, n / 8, n/16,"
kalaunan mong hatiin sa pamamagitan ng isang malaking sapat na bilang
na magkakaroon ka lamang 1 kaliwa ng elemento, kung saan maaari mong sabihin,
"Narito, narito ang isang pinagsunod-sunod na single na elemento."
Pagkatapos ang kinang ng algorithm na ito up dito upang makakuha ng mula sa katotohanang
na sa sandaling mayroon ka ng lahat ng mga indibidwal pinagsunod-sunod na listahan,
lahat ng mga ito ng laki 1, na tila na maging walang silbi,
sa sandaling sinimulan mo pinagsasama ang mga ito at pinagsasama ang mga ito
bumuo ka wakas bilang Rob ginawa sa video ng wakas pinagsunod-sunod sa listahan.
>> Ngunit ideya na ito ay umaabot malayo sa pag-uuri.
May ay ang ideya na ito na naka-embed sa programang ito na kilala bilang recursion,
ang ideya na kung saan ikaw ay isang programa,
at upang malutas ang ilang mga problema tawagan mo ang iyong sarili,
o ilagay sa konteksto ng mga wika ng programming ikaw ay isang function,
at upang malutas ang isang problema, ang function na tawagan ang iyong sarili
muli at muli at muli, ngunit mo ang function na
hindi maaaring tumawag ang iyong sarili walang hanggan maraming beses.
Kalaunan mayroon kang ibaba ang, kaya na magsalita,
at ilang mga hard-code base kondisyon na nagsasabing
sa puntong ito tumigil sa pagtawag sa iyong sarili kaya na ang buong proseso
sa wakas ay sa katunayan itigil.
Ano ang talagang ibig sabihin, sa recurse?
>> Natin makita, kung maaari naming gawin ang isang simple, trivia Halimbawa, sabihin nating,
3 tao sa akin hanggang dito sa entablado, kung ang isang tao ay kumportable.
1, ay sa up, 2 at 3.
Kung ikaw 3 gusto upang makabuo dito.
Kung nais mong tumayo sa tabi mismo sa akin dito sa isang linya, ipagpalagay na ang mga problema sa kamay
ay napaka trivially bilangin ang bilang ng mga tao na dito.
Subalit lantaran, ako pagod ng lahat ng mga pagbibilang halimbawa.
Ito ay pagpunta sa tumagal ng ilang oras, 1, 2, at tuldok, tuldok, tuldok.
Ito ay pagpunta sa tumagal magpakailanman.
Gusto ko na lamang tumikin ang problema na ito nang sama-sama sa tulong ng kung ano ang iyong pangalan?
Sara. >> Sara, ang lahat ng karapatan.
Kelly. >> Kelly at?
>> Willy. >> Willy, Sara, Kelly, at Willy.
Sa ngayon ako ay tanungin ang tanong ng isang tao
kung gaano karaming mga tao ay sa yugtong ito, at mayroon akong mga ideya.
Ito ay isang talagang mahabang listahan, at kaya sa halip ako pagpunta sa gawin ito nanlilinlang.
Ako pagpunta sa hilingin sa tao na susunod sa akin upang gawin ang karamihan ng trabaho,
at sa sandaling siya ay tapos na paggawa ng karamihan ng trabaho
Ako pagpunta sa gawin ang hindi bababa sa halaga ng trabaho na posibleng at magdagdag ng 1
sa anumang kanyang sagot, kaya dito namin pumunta.
Ko na tinanong kung gaano karaming mga tao sa entablado.
Gaano karaming mga tao sa entablado sa kaliwa ng sa iyo?
Sa kaliwa ko? >> Okay, ngunit hindi impostor.
Iyon ay mabuti, na tama, ngunit kung gusto naming ipagpatuloy ang logic
sabihin ipinapalagay na gusto mo katulad sa tumikin ang problemang ito sa kaliwa ng,
kaya sa halip na sagot nang direkta sige at lang makapasa sa pera.
Oh, kung gaano karaming mga tao ang sa kaliwa ko?
Gaano karaming mga tao ang sa kaliwa?
1.
[Tawa]
Okay, kaya 0, kaya kung ano ngayon Willy nagawa
ay ibinalik iyong sagot direksyon na ito sinasabi 0.
Ngayon, kung ano ang dapat mong gawin? >> 1.
Okay, kaya ikaw ang 1, kaya sabihin mo, "Lahat ng karapatan, ako na magdagdag ng 1
sa anumang Willy ng count ay, "kaya 1 + 0.
Ka na ngayon ng 1 sa gayon ang iyong sagot sa kanan na ngayon ang
1. >> At minahan ay 2.
Mabuti, kaya ka paglalaan ng nakaraang sagot ng 1,
sa pagdaragdag ng kaunting halaga ng trabaho na gusto mong gawin, na +1.
Mayroon ka na ngayong 2, at pagkatapos mo ipasa sa akin kung aling halaga?
3, Ibig kong sabihin, paumanhin, 2.
Mabuti.
>> Well, nagkaroon kami 0 sa kaliwa.
Pagkatapos namin ay may 1, at pagkatapos namin magdagdag ng 2,
at ngayon ka handing sa akin ang bilang 2,
at sa gayon ako sinasabi, okay, +1, 3.
Mayroong sa katunayan 3 tao nakatayo sa tabi sa akin sa yugtong ito,
kaya maaaring malinaw naman namin nagawa ito napaka linearly,
Sobra sa halatang paraan, ngunit kung ano ang namin talagang gawin?
Kinuha namin simula ng problema ng laki 3.
Pagkatapos namin sinira ito sa isang problema ng laki 2,
pagkatapos ng problema ng 1 laki, at pagkatapos ay sa wakas ang base kaso
ay talaga, oh, walang isa doon,
sa puntong Willy ibinalik epektibong isang hard-code answer ng ilang beses,
at ang pangalawang isa ay pagkatapos bubbled up, bubbled up, bubbled up,
at pagkatapos ay sa pamamagitan ng pagdaragdag sa isang karagdagang 1
naipatupad namin ang pangunahing ideya ng recursion.
>> Ngayon, sa kasong ito ay hindi ito talagang malutas ang isang problema
anumang mas epektibo pagkatapos ay nasaksihan namin sa gayon malayo.
Ngunit sa tingin tungkol sa mga algorithm na ginawa namin sa entablado sa gayon ngayon.
Nagkaroon kami ng 8 piraso ng papel sa Chalkboard,
sa video kapag Sean ay naghahanap para sa bilang 7, at kung ano ay siya talagang gawin?
Well, hindi siya ginawa anumang uri ng hatiin at lupigin.
Hindi niya gawin ang anumang uri ng recursion.
Sa halip siya lang ginawa ito linear algorithm.
Ngunit kapag ipinakilala namin ang ideya ng pinagsunod-sunod na mga numero sa entablado nakatira noong nakaraang linggo
pagkatapos namin ay ang likas na ugali na ito ng pagpunta sa gitna,
sa puntong kami ay may isang mas maliit na listahan ng mga laki 4 o isa pang listahan ng mga laki 4,
at pagkatapos namin ay ang eksaktong parehong problema, kaya namin paulit-ulit, paulit-ulit, paulit-ulit.
Sa ibang salita, hindi namin recursed.
Maraming salamat sa inyo sa aming 3 boluntaryo dito para sa nagpapakita ng recursion sa amin.
>> Natin makita kung hindi namin ito ng kaunti pa kongkreto na ngayon,
paglutas ng problema na muli kami maaaring gawin medyo madali,
ngunit gagamitin namin ang mga ito bilang isang stepping bato sa pagpapatupad ng pangunahing ideya na ito.
Kung gusto ko upang makalkula ang kabuuan ng isang bungkos ng mga numero,
halimbawa, kung pumasa ka sa numero 3,
Gusto kong upang ibigay sa iyo ang halaga ng palatandaan 3,
kaya ang kabuuan ng 3 + 2 + 1 + 0.
Gusto ko upang makabalik ang sagot 6,
kaya makikita namin ipatupad ito palatandaan na ang function, ito pagbubuo function na
na, muli, tumatagal sa input, at pagkatapos ay bumalik ang pagbubuo
ng numerong iyon ang lahat ng mga paraan down sa 0.
Maaari naming gawin ito medyo lamang, i-right?
Maaari naming gawin ito na may ilang mga uri ng looping istraktura,
kaya hayaan mo akong magpatuloy at makakuha ng ito nagsimula.
>> Isama stdio.h.
Hayaan akong makakuha ng aking sarili sa pangunahing gumagana sa dito.
Sabihin i-save ang bilang sigma.c.
Pagkatapos ako pagpunta sa pumunta sa dito, at ako pagpunta upang idedeklara isang int n,
at ako pagpunta sa gawin ang mga sumusunod habang ang gumagamit ay hindi makikipagtulungan.
Habang ang gumagamit ay hindi ibinigay sa akin ng isang positibong numero
hayaan mo akong magpatuloy at prompt ang mga ito para sa n = GetInt,
at hayaan mo akong bigyan sila ng ilang mga tagubilin kung ano ang gagawin,
kaya printf ("Positibong integer mangyaring").
Lamang ng isang bagay na medyo simple tulad nito kaya ng oras namin maabot ang linya 14
namin ngayon ay isang positibong integer baka sa n.
>> Ngayon sabihin gawin ang isang bagay dito.
Hayaan akong magpatuloy at compute ang pagbubuo, kaya int sum = palatandaan (n).
Sigma lamang ang kabuuan, kaya lang Sumusulat ako ito sa ang may interes na paraan.
Lang namin tumawag ito palatandaan doon.
Iyon ang kabuuan, at ngayon ako pagpunta sa i-print ang resulta,
printf ("kabuuan ay% d, \ n", kabuuan).
At pagkatapos ay kukunin ko na bumalik ng 0 para sa mahusay na sukatan.
Gawin namin ang lahat na ito ay nangangailangan ng programa maliban sa mga kawili-wiling bahagi,
na sa aktwal na ipatupad ang palatandaan function na.
>> Ipaalam sa akin pumunta down dito hanggang sa ibaba, at ipaalam sa akin na idedeklara ang function na palatandaan.
Ito ay nakuha sa isang variable na ng uri ng integer,
at kung anong uri ng data ang gusto ko upang bumalik baka mula palatandaan?
Int, dahil gusto ko ito upang tumugma sa aking mga inaasahan sa linya 15.
In dito hayaan mo akong magpatuloy at ipatupad ang
sa isang medyo tapat na paraan.
>> Natin sige at sabihin int sum = 0,
at ngayon ako pagpunta sa pumunta magkaroon ng isang maliit na para sa loop dito
na sabihin na ang isang bagay tulad nito,
para sa (int i = 0; ko <= numero; i + +) kabuuan + = i.
At pagkatapos ay ako pagpunta upang bumalik sa kabuuan.
Ko ipinapatupad ito sa anumang bilang ng mga paraan.
Ko ay gumamit ng isang habang loop.
Ko nilaktawan gamit ang kabuuan variable kung ko talagang gusto,
ngunit sa maikling salita, namin lamang magkaroon ng isang function na kung ako ay hindi loko declares kabuuan ay 0.
Pagkatapos ito iterates mula 0 sa up sa pamamagitan ng numero,
at sa bawat pag-ulit nagdadagdag na kasalukuyang halaga sa kabuuan at pagkatapos ay bumalik kabuuan.
>> Ngayon, may kaunting pag-optimize dito.
Marahil ito ay isang nasayang na hakbang, ngunit kaya ito. Iyon ay pinong sa ngayon.
Humihingi kami ng hindi bababa sa pagiging maingat at pagpunta 0 ang lahat ng mga paraan sa up.
Hindi napakahirap at medyo direkta,
ngunit ito lumiliko out na may function na palatandaan kami ay may pare-parehong pagkakataon
namin ginawa dito sa entablado.
Sa entablado binibilang lang namin kung gaano karaming mga tao ang tabi sa akin,
ngunit sa halip kung gusto naming bilangin ang bilang 3 + 2 + 1
sa down sa 0 maaari naming parehong tumikin sa isang function
na ko sa halip ilarawan bilang recursive.
Dito sabihin ay isang mabilis katinuan suriin at tiyakin ako hindi loko.
>> Alam ko mayroong hindi bababa sa isang bagay sa programang ito na aking ginawa mali.
Kapag ako ay pindutin ang enter ako pagpunta upang makakuha ng anumang uri ng sumisigaw sa akin?
Ano ako pagpunta na yelled sa tungkol sa?
Oo, nakalimutan ko ang prototype, kaya gumagamit ako ng isang function na tinatawag na palatandaan sa linya 15,
ngunit hindi ito ipinahayag hanggang linya 22, kaya ko mahusay na maagap na pumunta dito
at ipinapahayag ng prototype, at Sasabihin kong int palatandaan (int numero), at na ito.
Ito ay ipinatupad sa ibaba.
>> O isa pang paraan na maaari kong malutas ito,
Maaari ko bang ilipat ang function na up doon, na kung saan ay hindi masama,
ngunit hindi bababa sa kapag ang iyong mga programa ay magsisimulang upang makakuha ng mahaba, lantaran,
Tingin ko ang ilang halaga sa palaging pagkakaroon ng pangunahing sa tuktok
sa gayon ikaw sa reader buksan ang file at pagkatapos ay agad na makita
kung ano ang programa ay ginagawa nang hindi na kinakailangang upang maghanap dito
naghahanap para sa pangunahing function na.
Natin pumunta pababa sa aking terminal na window dito, subukan ang paggawa ng palatandaan gumawa ng mga palatandaan,
at screwed ko dito.
Implicit deklarasyon ng function na GetInt ay nangangahulugan nakalimutan ko na ang gawin ano pa?
[Hindi marinig na mag-aaral]
Mabuti, kaya tila ng isang pangkaraniwang pagkakamali, kaya sabihin ilagay ito up dito,
cs50.h, at ngayon sabihin bumalik sa aking terminal na window.
>> Kukunin ko na i-clear ang screen, at makikita ko muling palabas ng pelikula gumawa ng palatandaan.
Mukhang na pinagsama-sama. Hayaan akong ngayon patakbuhin ang palatandaan.
Kukunin ko na-type sa bilang 3, at ako ay makakuha ng 6, kaya hindi isang mahigpit na check,
ngunit hindi bababa sa tila nagtatrabaho sa unang tingin, ngunit ngayon sabihin punitin-hatiin ang mga ito,
at sabihin aktwal na magamit ang ideya ng recursion, muli,
sa isang napaka-simpleng konteksto upang sa ng ilang linggo 'oras
kapag nagsimula kami tuklasin may interes istraktura ng data kaysa sa array
kami ay may isa pang tool sa toolkit kung saan
manipulahin ang mga istraktura ng data bilang makikita namin makita.
Ito ang umuulit diskarte, ang mga loop diskarteng batay sa.
>> Hayaan akong sa halip ngayon gawin ito.
Hayaan akong sa halip sabihin na ang pagbubuo ng numero
pababa sa 0 talaga ang parehong bagay tulad ng
bilang + palatandaan (numero - 1).
Sa ibang salita, tulad ng sa entablado ko punted sa bawat isa ng ang mga tao na susunod sa akin,
at sila ay pinananatiling punting hanggang sa wakas namin bottomed out sa Willy,
na nagkaroon upang bumalik ang isang hard-code na sagot tulad 0.
Dito ngayon katulad namin ang punting sa palatandaan
ang parehong function na bilang ay orihinal na tinatawag na, ngunit ang key pananaw dito
na hindi namin pagtawag palatandaan identically.
Hindi namin pagpasa sa n.
Malinaw kami ng pagpasa sa numero - 1,
kaya bahagyang mas maliit problema, bahagyang mas maliit na problema.
>> Sa kasamaang-palad, ito ay hindi pa isang solusyon, at bago maayos namin
kung ano ang maaaring paglukso na halata sa ilan sa inyo
hayaan mo akong magpatuloy at muling patakbuhin ang gumawa.
Mukhang upang makatipon okay.
Hayaan akong muling palabas ng pelikula ang palatandaan na may 6.
Whoops, hayaan mo akong muling palabas ng pelikula ang palatandaan na may 6.
Nasaksihan namin ito dati, kahit na aksidenteng huling beses pati na rin.
Bakit ako nakakuha ito misteriyoso segmentation fault? Oo.
[Hindi marinig na mag-aaral]
Walang base kaso, at higit na partikular, kung ano ang malamang na nangyari?
Ito ay isang sintomas ng kung ano ang pag-uugali?
Ito sinasabi ng kaunti louder.
[Hindi marinig na mag-aaral]
Ito ay isang walang-katapusang loop epektibo, at ang mga problema sa walang-katapusang loop
kapag sangkot na sila ng recursion sa kasong ito, ang function na ng pagtawag mismo,
kung ano ang mangyayari bawat oras na tumawag ka ng isang function?
Well, sa tingin pabalik sa kung paano namin inilatag ang memory sa isang computer.
Sinabi namin na may ito tipak ng memory na tinatawag na stack na sa ibaba,
at sa bawat oras na tawagan ka ng isang function ng kaunti pa sa memory ay makakakuha ng ilagay
sa tinatawag na stack na naglalaman ng mga lokal na mga variable na function na o mga parameter,
kaya kung ang tawag ng palatandaan ang mga tawag palatandaan palatandaan tawag palatandaan
tawag palatandaan kung saan ang kuwentong ito ng pagtatapos?
>> Well, kalaunan overruns ang kabuuang halaga
ng memorya na mayroon kang magagamit sa iyong computer.
Malatagan ang segment na kayo ay dapat manatili sa loob,
at makakakuha ka ng segmentation fault na ito, core dumped,
at kung ano ang core dumped ay nangangahulugan na ako ngayon ay isang file na tinatawag na core
kung saan ay isang file na naglalaman ng mga zero at mga
na aktwal na sa hinaharap ay diagnostically kapaki-pakinabang.
Kung ito ay hindi halata sa iyo kung saan ay ang iyong bug
Maaari aktwal mong gawin ang isang bit ng forensic pagtatasa, kaya na magsalita,
sa ang file na ito ng core dump, na, muli, lamang ng buong bungkos ng mga zero at mga
na mahalagang kumakatawan sa estado ng iyong programa sa memorya
sandali ang nag-crash sa ganitong paraan.
>> Ang aayos dito ay na hindi lamang namin maaaring nang walang taros bumalik palatandaan,
ang bilang + palatandaan ng isang bahagyang mas maliit problema.
Kailangan namin na magkaroon ng ilang mga uri ng base kaso dito,
at ano ang dapat marahil ang pangunahing kaso?
[Hindi marinig na mag-aaral]
Okay, kaya mahaba bilang numero ay positibo dapat naming aktwal na bumalik ito,
o ilagay ang isa pang paraan, kung ang numero, sabihin nating, <= sa 0
alam mo kung ano, kukunin ko na magpatuloy at bumalik 0,
magkano tulad Willy ginawa, at iba pa, ako pagpunta sa magpatuloy
at ibalik ang, kaya ito ay hindi na mas maikli
kaysa sa umuulit bersyon na namin whipped unang gamit ang isang para sa loop,
ngunit mapapansin na ang ganitong uri ng kagandahan nito.
Sa halip na bumabalik ilang numero at magsagawa ng lahat ng ito matematika
at pagdaragdag ng mga bagay sa mga lokal na mga variable
sa halip ka sinasabi "Okay, kung ito ay isang napakadaling problema,
tulad ng numero ng <0, hayaan mo akong agad na bumalik sa 0. "
>> Hindi namin pagpunta sa abala ang pagsuporta ng mga negatibong numero,
kaya ako pupunta sa hard code ang halaga ng 0.
Ngunit kung hindi man, upang ipatupad ang ideya ng summing
lahat ng mga bilang na ito ay sama-sama mabisa mong kumuha ng isang maliit na kagat
ng problema, tulad ng ginawa namin dito sa entablado,
pagkatapos tumikin ang lahat ng problema sa susunod na tao,
ngunit sa kasong ito ang susunod na tao ay ang iyong sarili.
Identically na pinangalanang function na.
Lamang pumasa ito sa isang mas maliit at mas maliit at mas maliit na problema sa bawat oras,
at kahit na mayroon kaming hindi pa formalized na bagay sa code dito
ito ay eksakto kung ano ang nangyayari sa linggo 0 sa mga libro ng telepono.
Ito ay eksakto kung ano ang nangyayari sa nakaraang linggo na may Sean
at sa aming mga demonstrations ng paghahanap para sa mga numero.
Ito ay paglalaan ng problema at paghahati itong muli at muli.
>> Sa ibang salita, may isang paraan ngayon ng sa pagsalin
ito real bumuo ng mundo, ang mas mataas na antas bumuo
ng hatiin at lupigin at paggawa ng isang bagay muli at muli
sa code, kaya ito ay isang bagay na namin makita muli sa paglipas ng panahon.
Ngayon, bilang isang bukod, kung ikaw ay bago sa recursion ay dapat kang hindi bababa sa maunawaan ngayon
kung bakit ito ay nakatatawa.
Ako pagpunta sa pumunta sa google.com,
at ako pagpunta upang maghanap para sa ilang mga tip at trick sa recursion, ipasok.
Sabihin ang mga tao na susunod sa iyo kung hindi sila ay tumatawa ngayon lang.
Ibig mo bang sabihin recursion?
Ibig mo bang sabihin ah, doon kami.
Okay, ngayon na ang kabuuan ng lahat.
Ang isang maliit na Easter itlog naka-embed sa isang lugar doon sa Google.
Bilang isang bukod, isa ng ang mga link na inilalagay namin sa website ng kurso
para sa araw na lamang ang grid na ito ng iba't-ibang mga pag-uuri algorithm,
ilan sa kung saan namin tumingin sa nakaraang linggo, ngunit kung ano ang magaling tungkol sa visualization
habang sinusubukan mong I-wrap ang iyong isip sa paligid ng iba't-ibang mga bagay na may kaugnayan sa algorithm
alam na maaari mong napaka madali na ngayong magsimula sa iba't ibang mga uri ng mga input.
Ang input lahat ng reverse, ang mga input sa karamihan pinagsunod-sunod, ang input random at iba pa.
Habang sinusubukan mong, muli, makilala ang mga bagay na ito sa iyong isip
Napag-alaman na ang URL na ito sa website ng kurso sa pahina ng aralin
maaaring makatulong sa iyo dahilan sa pamamagitan ng ilan sa mga.
>> Ngayon namin sa wakas makakuha upang malutas ang problemang ito mula sa isang habang pabalik,
kung saan ay na makipagpalitan ng function na ito ay hindi gumagana,
at kung ano ang pangunahing problema sa function na ito makipagpalitan ng,
ang layunin ng kung saan ay, muli, upang makipagpalitan ng halaga dito at dito
tulad na ito mangyayari?
Ito ay hindi aktwal na gumana. Bakit?
Oo.
[Hindi marinig na mag-aaral]
Eksakto, ang paliwanag para sa bugginess
lamang ay dahil kapag tumawag ka ng mga function sa C
at mga function tumagal ng mga argumento, tulad ng isang at b dito,
ikaw ay pagpasa sa mga kopya ng anumang halaga nagbibigay ka ng na function na.
Hindi mo pagbibigay ng mga orihinal na halaga ang kanilang mga sarili,
kaya nakita namin ito sa konteksto ng buggyc,
buggy3.c, na mukhang isang maliit na bagay tulad nito.
>> Manariwa sa diwa na nagkaroon kami x at y nasimulan sa 1 at 2, ayon sa pagkakasunud-sunod.
Pagkatapos namin naka-print kung ano sila ay.
Pagkatapos ay inaangkin ko na ako pagpapalit ito sa pamamagitan ng pagtawag makipagpalitan ng x, y.
Ngunit ang problema ay na ang pagpapalit nagtrabaho,
ngunit lamang sa saklaw ng makipagpalitan gumana mismo.
Sa lalong madaling namin maabot ang linya 40 mga swapped halaga
ay itinapon ang layo, at kaya walang
sa orihinal na function na pangunahing ay talagang nagbago sa lahat,
kaya kung sa tingin mo bumalik sa kung ano ang mukhang sa mga tuntunin ng aming memory
kung ito kaliwang bahagi ng board kumakatawan-
at makikita ko ang aking makakaya para sa lahat upang makita ito-kung ang kaliwang bahagi ng board
kumakatawan sa, sabihin nating, iyong RAM, at stack ang binabalak na palaguin sa up sa ganitong paraan,
at tawagan kami ng isang function na tulad ng pangunahing, at pangunahing may 2 lokal na variable, x at y,
sabihin ilarawan ang mga bilang x dito, at sabihin ilarawan ang mga ito bilang y dito,
at ipaalam sa ay ilagay sa ang halaga 1 at 2, kaya ito dito ay pangunahing,
at kapag ang pangunahing tawag sa makipagpalitan ng function na operating system
nagbibigay sa makipagpalitan ng function na sarili nitong swath ng memory sa stack,
sarili nitong frame sa stack, kaya na magsalita.
Din ito allocates 32 bit para sa mga ints.
Ito ay nangyayari na tumawag sa kanila at b, ngunit na lubos na arbitrary.
Maaaring tinatawag kanila anumang ito nais, ngunit kung ano ang mangyayari kapag pangunahing
tawag makipagpalitan ng ito ay tumatagal ito 1, Inilalagay ng isang kopya doon, naglalagay ng kopya doon.
>> May 1 iba pang lokal na variable sa makipagpalitan ng, bagaman, na tinatawag na ano? >> Tmp.
Tmp, kaya hayaan mo akong bigyan ang aking sarili ng isa pang 32 bit dito,
at kung ano ang gagawin ko sa function na?
Sinabi ko int tmp nakakakuha ng, kaya may 1, kaya ginawa ko ito kapag namin huling play sa halimbawang ito.
Pagkatapos nai-b, kaya b ay 2, kaya ngayon ito ay magiging 2,
at ngayon b nakakakuha ng Temp, kaya Temp ay 1,
ito ngayon b nagiging ito.
Mabuti iyan. Ito nagtrabaho.
Ngunit sa lalong madaling bilang ang return ng function na
memory makipagpalitan ng epektibong mawala sa gayon ay maaari itong reused
sa pamamagitan ng ilang mga iba pang mga function sa hinaharap, at pangunahing ay malinaw naman ganap na hindi nabago.
Kailangan namin ang isang paraan ng sa panimula paglutas sa problemang ito,
at ngayon makikita namin sa wakas may isang paraan ng paggawa nito kung saan
maaari naming ipakilala ng isang bagay na tinatawag na pointer.
Ito lumiliko out na maaari naming malutas ang problemang ito
hindi sa pamamagitan ng pagpasa sa mga kopya ng x at y
ngunit sa halip sa pamamagitan ng pagpasa sa kung ano ang, ang iyong tingin, sa function na makipagpalitan ng?
Oo, kung ano ang tungkol sa mga address?
Hindi namin talagang uusapang tungkol sa mga address sa maraming detalye,
ngunit kung ang pisara ito ay kumakatawan sa memorya ng aking computer
maaari kaming tiyak na simulan ang numero ang mga bytes sa aking RAM
at sabihin ito ay byte # 1, ito ay byte # 2, byte # 3,
byte # 4, byte # ... 2 bilyong kung mayroon akong 2 gigabytes ng RAM,
sa gayon ay maaari kaming tiyak na may ilang arbitrary na numero scheme
para sa lahat ng mga indibidwal na bytes sa memorya ng aking computer.
>> Paano kung sa halip kapag tumawag ako makipagpalitan ng
kaysa pass sa mga kopya ng x at y
bakit hindi ko sa halip pumasa sa address ng x dito,
ang address ng y dito, mahalagang ang postal address
ng x at y dahil pagkatapos magpalitan, kung siya ay alam
ng address sa memorya ng x at y,
pagkatapos magpalitan, kung sinanay namin siya ng kaunti,
maaaring siya potensyal na humimok sa address na iyon, kaya na magsalita,
x, at baguhin ang bilang doon, pagkatapos ay humimok sa address ng y,
baguhin ang numero doon, kahit habang hindi aktwal na pagkuha ng mga kopya ng mga halaga sa kanyang sarili,
kaya kahit usapan natin ang tungkol ito bilang pangunahing ng memory
at ang memorya ng ito bilang makipagpalitan ng makapangyarihang at sa mapanganib na bahagi ng C
ay na ang anumang mga function na maaaring hawakan ng memory saanman sa computer,
at ito ay malakas na sa na maaari mong gawin ang mga napaka magarbong mga bagay na may mga programa sa computer sa C.
Ito ay mapanganib dahil maaari ka ring magtaas napaka madaling.
Sa katunayan, ang isa sa mga pinaka-karaniwang paraan para sa mga programa sa mga araw na ito na pinagsamantalahan
pa rin ay para sa isang programmer hindi mapagtanto
na siya ay nagpapahintulot sa data
nakasulat sa isang lokasyon sa memorya na hindi nilayon.
>> Halimbawa, siya declares isang hanay ng mga laki 10
ngunit pagkatapos aksidenteng sinusubukan upang ilagay ang 11 bytes sa na array ng memorya,
at simulan mo ng pagpindot ng mga bahagi ng memorya na hindi na wasto.
Lamang sa contextual ito, ang ilan sa inyo ay maaaring malaman na
software ay madalas prompt para sa mga serial number o mga susi sa pagpaparehistro,
Photoshop at Salita at mga programang tulad nito.
May umiiral basag, ng ilan sa inyo alam, online na kung saan maaari kang magpatakbo ng isang maliit na programa,
at voila, walang karagdagang kahilingan para sa isang serial number.
Paano ay na gumagana?
Sa maraming mga kaso ang mga bagay na ito ay simpleng paghahanap sa computer
segment ng teksto sa aktwal na mga zero ng computer at mga
kung saan ay na function na kung saan ang mga serial number ay hiniling,
at patungan mo sa puwang na iyon, o habang tumatakbo ang programa
maaari mong malaman kung saan ang key ay aktwal na naka-imbak
paggamit ng isang bagay na tinatawag debugger, at maaari mong magpahaginit software na paraan.
Na ito ay hindi sabihin na ito ay ang aming layunin para sa susunod na ilang mga araw,
ngunit ito ay napaka-real-mundo na ramifications.
Na ang isa ang mangyayari sa sangkot ang pagnanakaw ng software,
ngunit mayroon ding kompromiso ng buong machine.
>> Sa katunayan, kapag ang mga website mga araw na ito ay pinagsamantalahan
at nakompromiso at ang data ay leaked at password ninakaw
ito napakadalas nauugnay sa mahihirap na pamamahala ng isang memory,
o, sa kaso ng mga database, hindi inaasahan
adversarial input, kaya higit pa sa na sa linggo darating,
ngunit sa ngayon lamang sneak preview ng uri ng pinsala na maaari mong gawin
sa pamamagitan ng hindi masyadong-unawa kung paano gumagana ang mga bagay sa ilalim ng hood.
Natin ang tungkol sa pag-unawa sa kung bakit ito ay nasira
gamit ang isang tool na ay magiging mas at mas kapaki-pakinabang
ng aming mga programa makakuha ng mas kumplikadong.
Kaya malayo kapag nagkaroon ka ng isang bug sa iyong programa
kung paano mo nawala tungkol sa pag-debug ito?
Ano ang iyong diskarte ay sa gayon ngayon, kung itinuro ng iyong tf
o self-itinuro?
[Mag-aaral] Printf.
Printf, kaya printf ay marahil iyong kaibigan sa na kung nais mong makita ang
ano ang nangyayari sa loob ng iyong programa
mo lang ilagay printf dito, printf dito, printf dito.
Pagkatapos mong patakbuhin ito, at makakakuha ka ng isang buong grupo ng mga bagay-bagay sa screen
na maaari mong gamitin upang pagkatapos mahulo kung ano ang aktwal na pagpunta mali sa iyong programa.
>> Printf may kaugaliang na maging isang makapangyarihang bagay,
ngunit ito ay isang mano-manong proseso.
Mayroon kang maglagay ng printf dito, printf dito,
at kung ilagay mo ito sa loob ng isang loop maaari kang makakuha ng 100 na linya
ng output na pagkatapos mo magbistay pamamagitan.
Ito ay hindi isang napaka-user-friendly o interactive na mekanismo para sa pag-debug ng mga programa,
ngunit thankfully mayroong umiiral na mga alternatibo.
May isang programa, halimbawa, na tinatawag na GDB, ang GNU Debugger,
kung saan ay isang maliit na arcane sa kung paano mo ito gamitin.
Ito ay isang maliit na kumplikado, ngunit lantaran,
ito ay isa sa mga bagay na kung saan kung inilagay mo sa linggong ito at sa tabi
ang dagdag na oras upang maunawaan ang isang bagay tulad ng GDB
ito ay i-save ang mga malamang sampu-sampung ng mga oras sa katagalan,
ito na iyon, hayaan mo akong bigyan ka ng isang teaser ng kung paano gumagana ang bagay na ito.
>> Ako sa aking terminal na window.
Hayaan akong magpatuloy at ipunin ang programang ito, buggy3.
Nang hanggang sa petsa.
Hayaan akong patakbuhin ito lamang tulad ng ginawa namin habang pabalik, at sa katunayan, ito ay pinaghiwa.
Ngunit bakit ito? Siguro ako screwed ang makipagpalitan ng function na.
Siguro ito at b. Hindi ako medyo gumagalaw ito nang tama.
Hayaan akong magpatuloy at gawin ito.
Sa halip na lamang patakbuhin buggy3 ipaalam sa akin sa halip na patakbuhin ang program na ito GDB,
at ako pagpunta upang sabihin dito na tumakbo buggy3,
at ako pagpunta upang isama ang isang linya ng argumento ng utos, na tui,
at maglalagay kami ng ito sa hinaharap na mga problema sa spec ipaalala sa.
At ngayon ang black and white na interface pop up na, muli,
ng kaunti napakalaki sa unang dahil mayroong lahat ng ito
warranty impormasyon pababa dito, ngunit hindi bababa sa isang bagay na pamilyar.
Sa tuktok ng window ang aking aktwal na code,
at kung mag-scroll ko dito ipaalam sa akin na mag-scroll sa pinakatuktok ng aking mga file,
at sa katunayan, may buggy3.c, at abiso sa ibaba ng window na ito
Mayroon akong ang ang GDB prompt na ito.
>> Ito ay hindi ang parehong bilang aking normal John Harvard prompt.
Ito ay isang prompt na upang payagan ang sa akin upang makontrol GDB.
GDB ay isang debugger.
Debugger ay isang program na nagbibigay-daan sa kang maglakad sa pamamagitan
pagpapatupad ng iyong linya ng programa sa pamamagitan ng linya sa pamamagitan ng linya,
sa kahabaan ng paraan sa paggawa ng anumang nais mo sa programa,
kahit pagtawag ng mga function, o naghahanap, mas mahalaga,
sa halaga ng iba't-ibang variable.
Natin magpatuloy at gawin ito.
Ako pagpunta sa magpatuloy at i-type sa run sa GDB ng prompt,
kaya mapapansin sa ibabang kaliwa ng screen na nai-type ko patakbuhin ang,
at ako pindutin ang enter, at kung ano ang na gawin?
Tumakbo ito literal aking programa, ngunit hindi ko ay aktwal na makita ang mas pumunta sa dito
dahil hindi ko aktwal na sinabi sa debugger
i-pause sa isang partikular na sandali sa oras.
Lang mag-type run tumatakbo sa programa.
Hindi ko aktwal na makita ang anumang. Hindi ko maaaring manipulahin ang mga ito.
>> Sa halip ipaalam sa akin gawin ito.
Sa ang GDB prompt na ito, ipaalam sa akin sa halip na i-type ang pahinga, ipasok.
Iyon ay hindi kung ano ang ko nilalayong i-type.
Natin sa halip type break na pangunahing.
Sa ibang salita, gusto kong i-set ng isang bagay na tinatawag na breakpoint,
kung saan ay aptly na may pangalang dahil ito ay masira o i-pause
pagpapatupad ng iyong programa sa partikular na lugar.
Main ang pangalan ng aking function na.
Pansinin na GDB medyo na smart.
Ito ay naisip na ang pangunahing mangyayari upang simulan ang halos sa linya 18
ng buggy3.c, at pagkatapos ay mapansin dito sa kaliwang tuktok
b + sa tabi mismo sa linya 18.
Na nagpapaalala sa akin na-set ko ang isang breakpoint sa linya 18.
Oras na ito kapag ako ay nag-type run, ako pagpunta sa patakbuhin ang aking programa
hanggang mga hit na breakpoint,
kaya ang programa ay i-pause para sa akin sa linya 18.
Narito kami, patakbuhin.
Walang lumilitaw na nangyari, ngunit paunawa sa ibaba ang natitira
simula ng programa, buggy3, breakpoint 1 sa pangunahing sa buggy3.c linya 18.
Ano ang maaari kong gawin ngayon?
>> Mapansin ang maaari kong simulan ang pag-type ng mga bagay tulad ng naka-print,
hindi printf, x ng naka-print, at ngayon na kakaiba.
Ang $ 1 ay-usisa, dahil kakailanganin namin nakikita
sa bawat oras na-print ka ng isang bagay na makakakuha ka ng isang bagong $ halaga.
Na sa gayon ay maaari kang sumangguni bumalik sa nakaraang halaga kung sakali,
ngunit sa ngayon kung ano ang naka-print ay nagsasabi sa akin na ang halaga ng x sa puntong ito sa kuwento
ay tila 134,514,032.
Ano? Saan na kahit nanggaling?
[Hindi marinig na mag-aaral]
Sa katunayan, ito ay kung ano ang makikita namin tumawag sa isang halaga ng basura, at hindi kami uusapang tungkol sa,
ngunit ang dahilan na initialize variable
malinaw naman kaya na mayroon silang ilang mga halaga na gusto mo ang mga ito upang magkaroon ng.
Subalit catch ay isipin ang na maaari mong ipinapahayag ang mga variable
tulad ng ginawa ko ng ilang sandali ang nakalipas sa aking palatandaan halimbawa
nang hindi aktwal na nagbibigay sa kanila ng halaga.
Manariwa sa diwa kung ano ang ginawa ko sa paglipas dito sa palatandaan.
Ko ipinahayag n, ngunit kung ano ang halaga ay ko bigyan ito?
Wala, dahil ako alam na sa susunod na ilang mga linya
Ay tumagal ng GetInt-aalaga ng problema ng paglalagay ng halaga sa loob ng n.
>> Ngunit sa puntong ito sa kuwento ng linya 11
at line 12 at linya 13 at linya 14
buong mga ilang linya kung ano ang halaga ng n?
Sa C mo lamang ay hindi alam.
Ito ang pangkalahatang ilang mga halaga ng basura, ang ilang mga ganap na random na numero
na natira mahalagang mula sa ilang nakaraang function na
pagkakaroon ng pag-tumakbo, kaya habang tumatakbo ang iyong programa
isipin ang na function na ay nakakakuha ng function, function, ang function.
Lahat ng mga frame makapag ilagay sa memory, at pagkatapos ay mga function return,
at tulad ng iminungkahing ko na may pambura ang kanilang memorya ay malaon reused.
Well, ito ay kaya mangyayari na ito variable x sa programang ito
mukhang naglalaman ng ilang mga halaga ng basura tulad 134514032
mula sa ilang nakaraang function na, hindi na aking sinulat ni.
Ito ay maaaring maging isang bagay ay epektibo na may operating system,
ilang function na sa ilalim ng hood.
>> Okay, na fine, ngunit sabihin ngayon advance sa susunod na linya.
Kung type ko "sa tabi ng" sa aking GDB prompt at ako pindutin ang enter,
mapapansin na ang mga highlight gumagalaw pababa sa linya 19,
ngunit ang lohikal na implikasyon ay na linya 18
na ngayon tapos execute, kaya kung type ko muli "print x"
Dapat kong makita ngayon ang 1, at sa katunayan, gagawin ko.
Muli, ang $ bagay ay isang paraan ng GDB nagpapaalala sa iyo
kung ano ang kasaysayan ng mga print na nagawa mo na.
Ngayon ipaalam sa akin sige at i-print ang y, at sa katunayan, y ay ilang mabaliw halaga pati na rin,
ngunit hindi sang-ayon dahil sa linya 19 kami upang italaga ito
ang halaga 2, kaya hayaan mo akong i-type ang "susunod" muli.
At ngayon kami sa printf linya.
Hayaan ang gawin sa akin ng mga x naka-print.
Hayaan ang gawin sa akin ng naka-print na y. Lantaran, nakakakuha ako ng isang maliit na pagod ng pag-print ito.
Hayaan akong sa halip na i-type ang "display x" at "display y,"
at ngayon tuwing type ko sa isang utos sa hinaharap
Ako mapaalalahanan ng kung ano ang x at y, ano ang x at y, kung ano ang x at y.
>> Ko na din, bilang isang bukod, i-type sa "lokal impormasyon."
Info ay isang espesyal na command.
Lokal ay nangangahulugan na ito ay nagpapakita sa akin ang mga lokal na variable.
Kung sakaling kakailanganin ko kalimutan o ito ay isang mabaliw, kumplikadong function na
na ako o ibang tao sinulat ni lokal impormasyon ay magsasabi sa iyo
kung ano ang lahat ng mga lokal na mga variable sa loob ng lokal na function na
na maaari kang pakialam tungkol sa kung nais mong sundutin sa paligid.
Ngayon, printf ay tungkol sa upang maisagawa, kaya ipaalam sa akin sige at lamang uri "sa tabi."
Dahil hindi namin sa environment na ito hindi namin aktwal na nakikita ang mga ito
execute pababa dito, ngunit mapansin nakakakuha ito ng isang maliit na luray dito.
Ngunit mapansin ito override screen doon,
kaya hindi isang perpektong programa dito, ngunit na okay lang dahil ko laging sundutin sa paligid
gamit ang naka-print kung gusto ko.
>> Ipaalam sa akin type susunod muli, at ngayon dito ang mga kawili-wiling bahagi.
Sa puntong ito sa kuwento y ay 2, at x 1,
bilang iminungkahing dito, at muli,
ang dahilan na ito ay awtomatikong ipinapakita ngayon ay dahil ginamit ko ang command
display x at display y, kaya sandali type ko sa tabi
sa teorya x at y ay dapat maging swapped.
Ngayon, alam namin na na hindi ang kaso,
ngunit gagamitin namin makita sa isang sandali kung paano namin sumisid ng mas malalim upang malaman kung bakit na totoo.
Susunod, at sa kasamaang-palad, y pa rin ang 2 at x ay 1 pa rin, at maaari ko makukumpirma ng mas maraming.
Print x, naka-print y.
Sa katunayan, walang pagpapalit ay aktwal na naganap, kaya sabihin simulan ito sa paglipas ng.
Malinaw makipagpalitan ay nasira.
Natin sa halip na i-type ang "run" muli.
Hayaan akong sabihin ninyo ang oo, gusto kong i-restart ang mga ito mula sa simula, ipasok.
>> Ngayon ako back up sa linya 18.
Ngayon mapansin x at y ang mga halaga ng basura muli.
Susunod, susunod, susunod, susunod.
Kung nakukuha ko nababato ko din i-type lamang n para sa susunod.
Maaari mong pagpapaiksi dito sa pinakamaikling posibleng pagkakasunud-sunod ng mga character.
Swap ngayon nasira.
Natin makisalamuha, kaya sa halip na i-type ang susunod,
ngayon ako pagpunta sa type ng hakbang upang ang ako stepping sa loob ng function na ito
sa gayon ay maaari ba akong maglakad sa pamamagitan nito, kaya ko pindutin hakbang at pagkatapos ay ilagay.
Pansinin na highlight jumps down na mas mababa sa aking programa sa linya 36.
Ngayon kung ano ang mga lokal na mga variable?
Info lokal.
Wala pa dahil hindi namin nakuha na linya,
kaya sabihin sige at sabihin "sa tabi."
Ngayon mukhang namin tmp, naka-print tmp.
Basura halaga, i-right? Tingin ko ito.
Paano tungkol-print, naka-print na b, 1 at 2?
Sa isang sandali, sa lalong madaling ko type susunod muli
tmp ay pagpunta sa isang halaga ng 1, sana,
dahil tmp ay pagpunta sa itinalaga ang halaga ng isang.
>> Ngayon sabihin ko i-print ang a, b naka-print,
ngunit ngayon ay i-print ang tmp, at sa katunayan 1.
Hayaan ang gawin sa akin susunod. Hayaan ang gawin sa akin susunod.
Tapos ko na makipagpalitan ng function na.
Ako pa rin sa loob nito sa linya 40, kaya hayaan mo akong mag-print ng,
naka-print na b, at hindi ko pakialam kung ano ang tmp ay.
Mukhang makipagpalitan ng tama pagdating sa pagpapalit at b.
Ngunit kung ako ngayon type susunod, tumalon ako pabalik sa linya 25,
at siyempre, kung nagta-type ako sa x at naka-print na y
sila pa rin hindi nagbabago, kaya hindi namin maayos ang problema.
Ngunit diagnostically ngayon marahil na may GDB programa na ito
namin ang hindi bababa sa nakuha ng isang hakbang na mas malapit sa unawa
kung ano ang nangyayari mali nang hindi kinakailangang magkalat ang aming code sa pamamagitan ng paglalagay ng printf dito,
printf dito, printf dito at pagkatapos ay tumatakbo itong muli at muli
pagsubok upang malaman kung ano ang nangyayari mali.
>> Ako pagpunta sa sige at mag-quit ng ito nang sama-sama na may mag-quit.
Ito ay pagpunta sa pagkatapos ay sabihin, "Mag-quit pa rin?" Oo.
Ngayon ako pabalik sa aking normal prompt, at tapos ako na gamit GDB.
Bilang isang bukod, hindi mo na kailangang gamitin ang-tui bandila.
Sa katunayan, kung ligtaan mo ito makakakuha ka ng mahalagang ang ibabang kalahati ng screen.
Kung ako pagkatapos ay i-type pahinga pangunahing at pagkatapos patakbuhin
Ko pa rin patakbuhin ang aking mga programa, ngunit kung ano ito ay mas textually
lamang ipakita sa akin ang kasalukuyang isang linya sa isang pagkakataon.
Ang-tui, tekstuwal user interface,
lamang nagpapakita sa iyo ng higit pa ng programa nang sabay-sabay, na kung saan ay marahil ng isang bit conceptually madali.
Ngunit sa katunayan, maaari ko lang gawin susunod, susunod, susunod,
at ako pagpunta upang makita ang isang linya sa isang pagkakataon, at kung gusto ko talagang upang makita kung ano ang nangyayari sa
Ang maaari kong i-type ang listahan at makita ang isang buong grupo ng mga kalapit na mga linya.
>> May isang video na namin ang hiniling mong panoorin para sa problema nagtatakda 3
kung saan Nate sumasaklaw sa ilang ng intricacies ng GDB,
at ito ay isa sa mga bagay, totoo lang, kung saan ang ilang di-trivia porsyento ng sa iyo
hindi kailanman ay pindutin GDB, at iyon ay isang masamang bagay
dahil literal ay magtapos paggastos mas maraming oras sa ibang pagkakataon ito semestre
habol pababa bug pagkatapos ay sa iyo kung inilagay mo sa oras na kalahati / oras
ito linggo at susunod na pag-aaral upang makakuha ng komportable sa GDB.
Printf iyong kaibigan.
GDB dapat ngayon ang iyong kaibigan.
>> Anumang mga katanungan sa GDB?
At narito ang isang mabilis na listahan ng ilan sa ang pinaka-makapangyarihang at kapaki-pakinabang na mga utos.
Oo. >> Maaari mong i-print ang isang string?
Maaari mong i-print ang isang string? Ganap.
Ito ay hindi lamang na ang mga integer.
Kung ang isang variable s ay lamang ng uri sa naka-print na mga string.
Ito ay ipakita sa iyo kung ano na ang variable ng string ay.
[Hindi marinig na mag-aaral]
Ito ay magbibigay sa iyo ang address at ang string mismo.
Ito ay ipakita sa iyo ang parehong.
At isa huling bagay, dahil lang sa ito ay mahusay na malaman masyadong.
Backtrace at frame, hayaan mo akong sumisid sa ito isang huling oras,
parehong eksaktong programa sa GDB.
Hayaan akong magpatuloy at patakbuhin ang tekstuwal bersyon ng interface ng gumagamit,
lumalabag sa pangunahing.
Hayaan akong magpatuloy at patakbuhin muli. Narito Ako.
Ngayon hayaan mo akong pumunta susunod, susunod, susunod, susunod, susunod, hakbang, ipasok.
>> At ngayon, ipagpalagay na ako ngayon sa makipagpalitan sadyang, ngunit ako tulad ng "mapahamak, kung ano ang halaga ng x?"
Hindi ko maaaring gawin x ito.
Hindi ko maaaring gawin y dahil hindi nila hindi sa saklaw.
Ang mga ito ay hindi sa konteksto, ngunit walang problema.
Ang maaari kong i-type ang backtrace.
Na nagpapakita sa akin ang lahat ng mga pagpapaandar na maisakatuparan hanggang sa puntong ito sa panahon.
Pansinin na ang isa sa ibaba, pangunahing, ang mga linya na may pangunahing
pagiging sa ilalim ng aming mga larawan dito.
Ang katotohanan na makipagpalitan sa itaas ng mga ito linya up may makipagpalitan ng pagiging nasa itaas nito sa memory dito,
at kung gusto ko upang makabalik sa pangunahing pansamantalang ko sabihin ang "frame."
Ano number? Main frame # 1.
Ako pagpunta sa sige at sabihin ang "frame 1."
>> Ngayon ako pabalik sa pangunahing, at ang maaari kong i-print x, at ang maaari kong i-print y,
ngunit hindi ako makapag-print o b.
Ngunit maaari ko kung sinasabi ko, "Okay, maghintay ng isang minuto. Saan ang makipagpalitan?"
Hayaan akong magpatuloy at sabihin ang "frame 0."
Ngayon ako pabalik kung saan gusto kong maging, at bilang isang tabi,
may iba pang mga utos masyadong, tulad ng kung ikaw talaga ka nakakakuha nababato pagta-type susunod, susunod, susunod, susunod,
maaari mong pangkalahatang sabihin ng mga bagay tulad ng "susunod na 10," at na hakbang sa pamamagitan ng susunod na 10 na linya.
Maaari mo ring isulat ang "magpatuloy" kapag ikaw ay talagang makapag-fed up sa stepping sa pamamagitan nito.
Magpatuloy patakbuhin ang iyong programa nang tuluy-tuloy hanggang ito hit sa isa pang breakpoint,
kung sa isang loop o babaan sa iyong programa.
>> Sa kasong ito na namin ipinagpatuloy sa dulo, at programa ang lumabas normal.
Ito ay isang magarbong paraan, bulok na proseso.
Lamang ang iyong programa lumabas normal.
Higit pa sa na sa video at sa pag-debug ng mga sesyon sa darating.
Na ng maraming.
Sabihin ang aming 5-minutong break na dito, at magbabalik kami sa mga structs at mga file.
>> Kung ikaw ay dived sa pset sa linggong ito na
malalaman mo na ginagamit namin sa code ng pamamahagi,
pinagmulan ng code na nagbibigay kami sa iyo bilang isang panimulang punto, ang ilang mga bagong diskarte.
Sa partikular, ipinakilala namin ang bagong keyword na ito na tinatawag na struct, istraktura,
upang maaari naming lumikha ng na-customize na mga variable ng uri.
Din namin ipinakilala ang paniwala ng file I / O, file input at output,
at ito ay upang maaari naming i-save ang estado
ng iyong mang-uayabit board sa isang file sa disc
sa gayon ay ang mga Fellows ng pagtuturo at ako ay maaaring maunawaan
kung ano ang nangyayari sa loob ng iyong programa nang hindi na kinakailangang upang mano-manong i-play
dose-dosenang ng mga laro ng mang-uayabit.
Maaari naming gawin ito mas automatedly.
>> Ito ideya ng isang struct malulutas nito ang patas nakapanghihimok problema.
Ipagpalagay na gusto naming ipatupad ng ilang programa
na sa paanuman Sinusubaybayan ng impormasyon sa mga mag-aaral,
at ang mga mag-aaral ay maaaring magkaroon ng, halimbawa, ng isang ID, pangalan
at ng bahay sa isang lugar tulad ng Harvard, kaya ito ay 3 piraso ng impormasyon
gusto naming panatilihin sa paligid, kaya ipaalam sa akin sige at simulan ang pagsusulat ng isang maliit na programa dito,
isama stdio.h.
Hayaan ang gawin sa akin isama cs50.h.
At pagkatapos ay simulan ang aking pangunahing function na.
Hindi ko ay abala sa anumang argumento command line,
at dito ay nais kong magkaroon ng isang mag-aaral, kaya ako pagpunta sa sabihin
ang mag-aaral ay may isang pangalan, kaya ako pagpunta sa sabihin "string ang pangalan."
Pagkatapos ako pagpunta sa sabihin natin na ang mag-aaral ay mayroon ding isang ID, kaya int id,
at ang mag-aaral ay may isang bahay, kaya din ako pagpunta sa sabihin "string bahay."
Pagkatapos ay kukunin ko na mag-order ng mga ito ng kaunti pa nang malinis tulad nito.
Okay, ngayon mayroon akong 3 variable na kumakatawan sa isang mag-aaral, kaya "isang mag-aaral."
>> At ngayon, gusto kong i-populate ang mga halagang ito, kaya hayaan mo akong magpatuloy at sabihin ang isang bagay tulad ng
"Id = 123."
Pangalan ay pagpunta upang makakuha ng David.
Sabihin nating bahay ay pagpunta upang makakuha ng Mather,
at pagkatapos ay ako pagpunta sa gawin ang isang bagay mang tulad printf ("% s,
na ang ID ay% d, nakatira sa% s.
At ngayon, ano ang gusto kong plug in dito, isa pagkatapos ng isa?
Pangalan, id, bahay; return 0.
Okay, maliban kung ako screwed up sa isang lugar dito
Tingin ko kami ay may isang medyo magandang programa na nag-iimbak ng isang mag-aaral.
Siyempre, ito ay hindi lahat na kawili-wili. Paano kung gusto kong 2 mga mag-aaral?
Na hindi sang-ayon. Maaari kong suportahan ang 2 tao.
Hayaan akong magpatuloy at i-highlight ito at pumunta dito,
at maaari ba akong sabihin "id = 456" para sa isang tao tulad ng Rob nakatira sa Kirkland.
>> Okay, maghintay, ngunit Hindi ko matawagan ang mga ito ang parehong bagay,
at mukhang ako pagpunta upang kopyahin ito,
kaya hayaan sabihin sa akin na ang mga ito ay ni David ang variable,
at hayaan mo akong makakuha ng ilang mga kopya sa mga ito para sa Rob.
Kami tatawag sa mga Rob ngunit ito ay hindi pagpunta sa trabaho ngayon
dahil ko-maghintay, sabihin baguhin sa akin sa mga id1, NAME1 at house1.
Rob ay 2, 2.
Mayroon akong upang baguhin ito dito, dito, dito, dito, dito, dito.
Maghintay, kung ano ang tungkol sa Tommy? Natin gawin ito muli.
Malinaw kung sa tingin mo pa rin na ito ay isang mahusay na paraan ng paggawa nito, hindi,
kaya kopyahin / ilagay masamang.
Ngunit malulutas namin ito sa isang linggo na ang nakalipas.
>> Ano ang aming solusyon kapag gusto naming magkaroon ng maramihang mga kaso ng ang parehong uri ng data?
[Mag-aaral] isang array.
Array isang, kaya hayaan mo akong subukan upang linisin ito up.
Hayaan akong gumawa ng ilang mga kuwarto para sa aking sarili sa tuktok, at ipaalam sa akin sa halip gawin ito dito.
Susubukan naming tawagan ang mga taong ito, at sa halip ako pagpunta sa sabihin "int id,"
at ako pagpunta upang suportahan ang 3 sa atin sa ngayon.
Ako pagpunta upang sabihin ang "pangalan ng string," at makikita ko sinusuportahan 3 sa atin,
at pagkatapos ay ako na sabihing "bahay string," at ako pagpunta upang suportahan ang 3 sa atin.
Ngayon in dito sa halip ng David nakakakuha ng kanyang sariling lokal na mga variable
maaari naming makakuha ng mapupuksa ng mga.
Iyon nararamdaman mahusay na namin ang paglilinis up ito.
Ko sabihin David ay pagpunta sa [0] at pangalan [0]
at bahay [0].
At pagkatapos Rob maaari naming parehong i-save sa.
Natin ilagay ito down na dito, kaya siya ay pagpunta sa mang id [1].
Ang kanyang pagpunta sa maging ang mga pangalan [1],
at pagkatapos ay bilang wakas, ang mga bahay [1].
>> Pa rin ng kaunti nakakapagod, at ngayon ay mayroon akong upang malaman ito,
kaya sabihin nating "pangalan [0], id [0], bahay [0],
at sabihin gawing maramihan ito.
Mga id, id, id.
At muli, ako ginagawa ito, kaya muli, na ako resorting upang kopyahin / ilagay muli,
kaya ang mga logro ay ang isa pang solusyon dito.
Maaari ko marahil linisin ito up pa sa isang loop o ng isang bagay tulad na,
kaya sa maikling salita, ito ay isang maliit na mas mahusay na ngunit pa rin nararamdaman tulad ng
Ako resorting kopyahin / ilagay, ngunit kahit na ito, inaangkin ko,
ay hindi talagang sa panimula ang tamang solusyon dahil
paano kung minsan magpasya namin alam mo kung ano?
Dapat namin talagang na-sa pag-iimbak ng mga email address para sa David at Rob
at ang iba sa programang ito.
Dapat din namin iimbak ang mga numero ng telepono.
Dapat din namin-imbak ang mga numerong pang-emergency contact.
Mayroon kaming lahat ng mga piraso ng data na gusto namin na mag-imbak,
kaya kung paano mo pumunta tungkol sa paggawa na?
>> Idedeklara ka ng isa pang hanay sa itaas, at pagkatapos mong mano-manong magdagdag ng
ng isang email address [0], email address [1]
para sa David at Rob at iba pa.
Ngunit mayroong talagang lamang ng isang palagay pinagbabatayan ito disenyo
na ako gamit ang karangalan system upang malaman na
[I] sa bawat isa ng ilang array
lamang kaya ang mangyayari sumangguni sa parehong tao,
kaya [0] sa id ay numero 123,
at ako pagpunta sa ipagpalagay na ang pangalan [0]
pangalan ng parehong tao at bahay [0]
bahay ang parehong tao at iba pa para sa lahat ng iba't-ibang mga array na ako lilikha.
Ngunit mapansin na walang saligan Linkage
kabilang ang mga 3 piraso ng impormasyon, id, pangalan at bahay,
kahit ang entity na sinusubukan naming modelo sa programang ito ay hindi array.
Array ito program na paraan ng paggawa nito.
Ano talaga namin nais na modelo sa aming programa ay isang tao
tulad ng David, isang tao tulad ng Rob sa loob kung saan
o encapsulating ay isang pangalan at ID at ng bahay.
>> Maaari namin sa paanuman ipahayag ito ideya ng encapsulation
kung saan ang isang tao ay may isang ID, pangalan at ng bahay
at hindi resort talaga ito paupahang karomata kung saan lang namin
pinagkakatiwalaan na isang bagay na bracket
tumutukoy sa parehong tao na entity sa bawat isa ng mga disparate array?
Maaari naming aktwal na gawin ito.
Ipaalam sa akin pumunta sa itaas pangunahing sa ngayon, at hayaan mo akong lumikha ng aking sariling uri ng data
para talagang sa unang pagkakataon.
Ginamit namin sa diskarteng ito sa mang-uayabit,
ngunit dito ako pagpunta upang magpatuloy at lumikha ng isang uri ng data,
at alam mo kung ano, ako na tumawag ito ng mag-aaral o tao,
at ako pagpunta sa gamitin typedef para tukuyin ang isang uri.
Ako pagpunta upang sabihin na ito ay isang istraktura,
at pagkatapos ay ang istraktura na ito ay ng uri ng mag-aaral, namin sabihin,
kahit na ito ay isang maliit na napetsahan ngayon para sa akin.
Susubukan naming sabihin ang "int id."
Susubukan naming sabihin ang "string ang pangalan."
Pagkatapos ay magpapadala kami sabihin ang "string bahay,"
na ito ngayon sa pamamagitan ng pagtatapos ng mga ilang linya ng code
Ko itinuro kumalatong na may umiiral
isang uri ng data bukod ints, bukod sa mga string, bukod sa doubles, bukod sa kamay.
>> Ng panahon na ito sa time line 11, ngayon ay isang bagong uri ng data na tinatawag na mga mag-aaral,
at ngayon ko ipinapahayag ng isang mag-aaral variable kahit saan gusto kong,
kaya hayaan mag-scroll pababa sa akin dito sa mga tao.
Ngayon ay maaari ko mapupuksa ng ito, at maaari ba akong bumalik down sa David dito,
at para sa David ko talagang sabihin na David,
maaari naming literal pangalanan ang variable pagkatapos aking sarili,
pagpunta sa ng uri ng mag-aaral.
Ito ay maaaring tumingin ng kaunti kakaiba, ngunit ito ay hindi ang lahat ng iba't-ibang
mula sa deklarasyon ng isang bagay bilang isang int o isang string o isang Float.
Ito lang kaya ang mangyayari sa tinatawag na mag-aaral sa ngayon,
at kung gusto ko upang ilagay ang isang bagay sa loob ng istrakturang ito
Ako ay mayroon na ngayong gumamit ng isang bagong piraso ng syntax, ngunit medyo direkta,
david.id = 123, david.name = "David" sa kabisera D,
at david.house = "Mather,"
at ngayon ako makakakuha ng mapupuksa ng mga bagay na ito dito.
Mapansin ngayon Binago namin ang disenyo ng aming programa sa talagang isang mas mas mahusay na paraan
in na ngayon ang aming programa salamin sa tunay na mundo.
>> May isang real-world na paniwala ng isang tao o ng isang mag-aaral.
Narito mayroon kami ngayon ng C bersyon ng isang tao o higit na partikular ng isang mag-aaral.
Sa loob ng taong iyon ang mga may-kaugnay na mga katangian,
ID, pangalan at bahay, kaya Rob mahalagang magiging ang parehong bagay dito,
kaya mag-aaral pagnakawan, at ngayon rob.id = 456,
rob.name = "Rob."
Ang katotohanan na variable ay tinatawag na Rob uri ng walang kahulugan.
Namin ang tinatawag na ito x o y o z.
Lamang namin na may pangalang Rob ito sa magkakahulugang mga pare-pareho,
ngunit talagang pangalan sa loob ng patlang na iyon mismo,
kaya ngayon ay mayroon akong ito.
Ito masyadong ay hindi pakiramdam tulad ng ang pinakamahusay na disenyo na mahirap ko ang code David.
Mahirap ko na code Rob.
At Mayroon pa akong sa resort sa ilang kopya at i-paste sa bawat oras na gusto ko ng bagong variable.
Dagdag pa rito, mayroon akong tila bigyan ang bawat isa sa mga variable na ito ng pangalan,
kahit gusto ko magkano sa halip na ilarawan ang mga variable na ito
mas generically bilang mga mag-aaral.
>> Ngayon ay maaari naming pagsamahin ang mga ideya na mahusay na gumagana para sa amin
at sa halip ay sabihin, "alam mo kung ano, ibigay sa akin ang isang variable na tinatawag na mga mag-aaral,
at sabihin ito ng laki 3, "kaya ngayon ko pinuhin ito nang higit pa,
mapupuksa ng nang manu-mano ang ipinahayag David,
at maaari ko sa halip sabihin ang isang bagay tulad ng mga mag-aaral [0] dito.
Ko sabihin ang mga mag-aaral [0] dito,
mag-aaral [0] dito, at iba pa, at ako ay maaaring pumunta sa paligid
at linisin na para sa Rob.
Maaaring ko ring pumunta tungkol sa ngayon marahil pagdaragdag ng isang loop
at gamit ang GetString at GetInt sa aktwal na makakuha ng mga halagang ito mula sa user.
Maaari kong pumunta tungkol sa pagdaragdag ng isang pare-pareho dahil ito ay masamang kasanayan
sa hard code ilang arbitrary na numero tulad ng 3 dito mismo
at pagkatapos lamang tandaan na dapat mong ilagay ang hindi hihigit sa 3 mga mag-aaral sa loob nito.
Marahil ito ang mas mahusay na gamitin ang # tukuyin sa tuktok ng aking mga file
at salik na out, kaya sa katunayan, hayaan mo akong magpatuloy at magbigay ng tuntuning panlahat na ito.
>> Hayaan akong buksan ang isang halimbawa na kabilang ngayon
halimbawa nang maaga, structs1.
Ito ay isang mas kumpletong program na gumagamit ng # tukuyin dito
at sabi namin ay pagpunta sa may 3 mga mag-aaral sa pamamagitan ng default.
Narito ako deklarasyon nagkakahalaga ng isang klase ng mga mag-aaral,
kaya ng isang silid-aralan ng mga mag-aaral, at ngayon gumagamit ako ng isang loop
lamang ang code ng kaunti pa sa eleganteng, populate ng klase
sa input ng user, kaya umulit mula sa i = 0 sa hanggang sa mag-aaral, na kung saan ay 3.
At pagkatapos ko prompt ang user sa ang bersyon na ito
kung ano ang ID ng mag-aaral, at nakukuha ko ito sa GetInt.
Ano ang pangalan ng mag-aaral, at pagkatapos ay ako makakakuha ng ito sa GetString.
Ano ang bahay ng mag-aaral? Nakukuha ko may GetString.
At pagkatapos ay sa ibaba dito ko lang nagpasya upang baguhin
kung paano pag-print ako ng mga out at aktwal na gumamit ng loop,
at kung sino ako pag-print?
Ayon sa komento ako pag-print ng sinuman sa Mather,
at na ito kaya Rob at Tommy at iba pa-aktwal Tommy sa Mather.
Tommy at David ay ipi-print sa kasong ito, ngunit paano ito gumagana?
Hindi namin nakita ang function na ito bago, ngunit tumagal ng hula sa kung ano ang ginagawa.
Inihahambing string.
>> Ito ay isang maliit na hindi-halata kung paano ito ikinukumpara string dahil ito ay lumiliko out
kung ito nagbabalik 0 ito ay nangangahulugan na ang mga string ay katumbas.
Kung ito ay nagbabalik ng -1 na nangangahulugang ang isa ay ayon sa alpabeto bago ang isa,
at kung ito nagbabalik +1 na nangangahulugang ang iba pang mga salita ay ayon sa alpabeto
bago ang isa, at maaari kang tumingin sa online o sa tao ng pahina
upang makita ang eksakto kung aling paraan ay kung saan, ngunit ang lahat ng ito ay ngayon paggawa ay ito sinasabi
kung ang [i]. bahay ay katumbas ng "Mather"
pagkatapos ay magpatuloy at i-print ang kaya at kaya sa Mather.
Ngunit narito ang isang bagay na hindi namin nakita bago, at magpapadala kami bumalik sa.
Hindi ko isipin ang na kinakailangang gawin ito sa anumang ng aking mga programa.
Libreng ay tila tumutukoy sa memory, pagbabakante memory,
ngunit kung ano ang memory ako tila pagbabakante sa loop sa ilalim ng programang ito?
Mukhang ako pagbabakante ng pangalan ng isang tao
at bahay ng isang tao, ngunit kung bakit ay na?
>> Lumiliko out sa lahat ng mga linggo na na ginagamit mo GetString
namin ang uri ng nagpapakilala ng isang bug sa bawat isa ng iyong mga programa.
GetString sa pamamagitan ng disenyo allocates memory upang maaari itong bumalik sa iyo ng isang string,
tulad ng David, o Rob, at pagkatapos ay gawin ang anumang nais mong
may na string sa iyong programa dahil kami ay reserbado memory para sa iyo.
Ang problema ay lahat oras na ito sa bawat oras na tawagan ka GetString
namin, ang mga may-akda ng GetString, ay humihiling sa operating system
upang bigyan kami ng isang bit ng RAM para sa string.
Bigyan kami ng isang bit ng RAM para sa susunod na string.
Bigyan kami ng ilang karagdagang RAM para sa susunod na string.
Ano, programmer, hindi pa ginagawa
pagbigay sa amin na memory likod,
ito para sa mga ilang linggo ang lahat ng programa na nakasulat
nagkaroon ng kung ano ang tinatawag na memory hakbang kung saan sila panatilihin gamit
higit pa at higit pa memory sa bawat oras na tumawag ka GetString, at na fine.
Gawin namin sadyang na sa unang linggo dahil ito ay hindi na kawili-wili
upang mag-alala tungkol sa kung saan string ay nagmumula sa.
Ang gusto mo ay salita Rob upang bumalik kapag ang user ang mga uri ito.
>> Ngunit gumagalaw pasulong na namin ngayon upang simulan ang pagkuha ng mas sopistikadong tungkol sa.
Anumang oras na maglaan namin memorya mas mahusay naming kalaunan ay ipasa ang mga ito pabalik.
Kung hindi man sa tunay na mundo sa iyong Mac o PC na maaaring mayroon ka paminsan-minsan karanasan
sintomas kung saan ang iyong computer ay paggiling sa isang pagagil kalaunan
o bobo Umiikot na bola beach lamang sumasakop sa computer
buong pansin at hindi ka maaaring gumawa ng mga bagay.
Na maaaring ipinaliwanag sa pamamagitan ng anumang bilang ng mga bug, ngunit kabilang sa mga posibleng bug
ay mga bagay na tinatawag na memory paglabas kung saan ang isang tao na sinulat ni na piraso ng software
na iyong ginagamit ay hindi tandaan na libreng memorya
na siya nagtanong ang operating system para sa,
hindi gumagamit ng GetString, dahil na CS50 bagay, ngunit ang paggamit ng mga katulad na function
na magtanong ang operating system para sa memory.
Kung ikaw o sila magtaas at hindi aktwal na ibalik na memory
isang sintomas ng na maaaring na ang programa ng slows at slows at slows down na
maliban kung tandaan mo na tumawag sa libreng.
>> Darating kami pabalik sa kung kailan at bakit gusto mong tumawag libreng,
ngunit sabihin magpatuloy para sa mabuting panukala at subukang patakbuhin ang partikular na programa.
Ito ay tinatawag na structs1, ipasok.
Hayaan akong magpatuloy at patakbuhin structs1, 123, David Mather,
456, Rob Kirkland, 789,
Tommy Mather, at nakikita namin ang David sa Mather, Tommy sa Mather.
Ito ay lamang ng kaunti katinuan check na gumagana ang programa.
Ngayon, sa kasamaang-palad, ang program na ito ay isang maliit na nakakabigo sa na
Ko ang lahat ng mga gawa na, ako type sa 9 iba't ibang string, pindutin ang enter,
ay sinabi na sa Mather, gayon pa man malinaw naman alam ko na sa Mather na dahil-type ko ito.
Ito ay hindi bababa sa gandang kung ang programa ito ay higit pa tulad ng isang database
at aktwal Naaalala kung ano ang nai-type ko sa
kaya hindi ko muling i-input ang mga talaan ng mag-aaral na ito.
Siguro ito tulad ng isang registrarial system.
>> Maaari naming gawin ito gamit ang diskarteng na kilala bilang file I / O, file input at output,
generic na paraan ng sinasabi ng anumang oras na nais mo upang basahin ang mga file o sumulat ng mga file
maaari mong gawin ito na may isang tiyak na hanay ng mga function.
Hayaan akong sige at buksan ito halimbawa structs2.c,
na kung saan ay halos magkakahawig, ngunit sabihin makita kung ano ito ngayon.
Sa tuktok ng file idedeklara ko ang isang klase ng mga mag-aaral.
Pagkatapos ko-populate ang klase sa input ng user,
kaya ang mga linya ng code ay eksakto bang bago.
Pagkatapos kung mag-scroll down na ko dito-print ko ang lahat na sa Mather mang bang bago,
ngunit ito ay isang kawili-wiling bagong tampok.
Mga linya ng code bago, at ipakilala sila ng isang bagay dito,
FILE, ang lahat ng mga caps, at ito ay may * in dito pati na rin.
Hayaan ang ilipat sa akin ito sa paglipas dito, isang * sa paglipas dito pati na rin.
>> Function na ito ay hindi namin nakita bago, fopen,
ngunit ito ay nangangahulugan na file bukas, kaya sabihin sagap sa pamamagitan ng mga,
at ito ay isang bagay na makikita namin bumalik sa hinaharap psets,
ngunit ang line dito mahalagang ay nagbukas ng isang file na tinatawag na database,
at partikular na ito ay bubukas ito sa isang paraan na maaari itong gawin kung ano ito?
[Hindi marinig na mag-aaral]
Karapatan, kaya "w" lamang ay nangangahulugan na ito ay nagsasabi sa operating system
buksan ang file na ito sa isang paraan na maaari kong isulat dito.
Hindi ko nais na basahin ang mga ito. Hindi ko nais na tingnan lamang ito.
Gusto kong baguhin ang mga ito at magdagdag ng mga bagay-bagay potensyal nito,
at ang file ay pagpunta sa tinatawag na database.
Ma-tinatawag na kahit ano.
Ito ay maaaring database.txt. Ito ay maaaring. Db.
Maaaring ito ay isang salita tulad ng foo, ngunit pinili ko mang pangalanan ang file database.
Ito ay isang kaunti katinuan check na namin bumalik sa mahusay na detalye sa paglipas ng panahon,
kung fp, para sa file pointer, hindi katumbas null na nangangahulugang lahat na rin.
>> Long kuwento maikli, ang mga function tulad fopen minsan mabibigo.
Siguro ang file ay hindi umiiral. Siguro nasa labas ka ng disc space.
Siguro hindi mo pahintulot sa folder na iyon,
kaya kung fopen nagbabalik null isang bagay masamang nangyari.
Sa kabaligtaran, kung fopen ay hindi nagbabalik ng null lahat na rin
at ang maaari kong simulan ang pagsusulat sa file na ito.
Narito ang isang bagong nanlilinlang.
Ito ay isang para sa loop na iterating sa paglipas ng bawat ng aking mga mag-aaral,
at ito hitsura kaya katulad sa kung ano ang ginawa namin bago,
ngunit ang function na ito ay isang pinsan ng printf tinatawag fprintf para sa file printf,
at mapansin ang mga ito naiiba sa 2 paraan lamang.
Isa, nagsisimula ito sa f halip ng p,
ngunit pagkatapos ay ang unang argumento nito ay tila kung ano?
[Mag-aaral] File. >> Ito ay isang file.
Ito bagay na tinatawag na fp, na makikita namin kalaunan manunudyo bukod sa kung ano ang isang file pointer ay,
ngunit sa ngayon fp lamang kumakatawan sa file na binuksan ko,
fprintf dito ay sinasabi na i-print ang ID ng gumagamit na ito sa ang file, hindi sa screen.
I-print ang pangalan ng user sa file, hindi sa screen,
bahay sa file, hindi sa screen, at pagkatapos ay down na dito, malinaw naman,
isara ang file, at pagkatapos ay down na dito libreng ang memorya.
>> Ang tanging pagkakaiba sa pagitan ng ito sa bersyon 2 at bersyon 1
ay ang pagpapakilala ng fopen at ang FILE na ito ng *
at ito paniwala ng fprintf, kaya sabihin makita kung ano ang resulta.
Hayaan akong pumunta sa aking terminal na window.
Hayaan akong patakbuhin ang structs2, ipasok.
Mukhang lahat na rin. Natin muling palabas ng pelikula structs2.
123, David Mather, 456, Rob Kirkland,
789, Tommy Mather, ipasok.
Mukhang ito sumusunod sa parehong, ngunit kung gawin ko ngayon ls
mapansin kung ano ang file ay in dito kabilang ang lahat ng aking code, database,
kaya sabihin buksan na, gedit ng database, at pagtingin sa na.
Ito ay hindi ang sexiest ng mga format ng file.
Ito talaga ay isang piraso ng data na linya sa bawat linya sa bawat linya,
ngunit ang mga mo na gumagamit ng mga file sa Excel o CSV, comma separated values,
Maaaring ko tiyak na ginagamit fprintf sa halip maaaring gawin ang isang bagay tulad nito
sa gayon na maaari kong aktwal na lumikha ng katumbas ng isang Excel file
sa pamamagitan ng naghihiwalay ng mga bagay na may mga kuwit, hindi lamang mga bagong linya.
>> Sa kasong ito kung sa halip ko gumamit ng kuwit sa halip ng mga bagong linya
Maaaring literal ko mabuksan ang database file sa Excel kung sa halip ay ginawa ko ito ganito ang hitsura.
Sa maikli, ngayon na kami ay may kapangyarihan na magsulat sa mga file
Maaari namin ngayon simulan Patuloy ang data, nang pinapanatili ito sa disc
upang maaari naming panatilihin ang impormasyon sa paligid muli at muli.
Mapansin ng ilang mga iba pang mga bagay na ngayon ng kaunti pang pamilyar.
Sa tuktok ng file na ito C mayroon kaming typedef
dahil gusto naming lumikha ng isang uri ng data na kumakatawan sa isang salita,
kaya ang uri na ito ay tinatawag na salita, at sa loob ng istrakturang ito
medyo may interes ngayon.
Bakit ang isang salita binubuo ng tila isang array?
Ano ang isang salita lamang intuitively?
>> Ang isang hanay ng mga character.
Ito ay isang pagkakasunud-sunod ng mga character bumalik upang i-back upang i-back.
Mga titik sa lahat ng caps mangyayari na namin mang sabihin sa maximum na haba
ng anumang salita sa diksyunaryo na ginagamit namin para mang-uayabit.
Bakit ako magkaroon ng +1?
Ang null karakter.
Manariwa sa diwa kapag ginawa namin ang Bananagrams Halimbawa kinailangan naming ng isang espesyal na halaga
sa dulo ng salita upang subaybayan
kung saan aktwal na natapos ang mga salita, at ng problema detalye ng set sabi
dito kami ay uugnay sa isang ibinigay na salita sa isang boolean na halaga,
bandila, kaya na magsalita, totoo o hindi.
Nakita mo ang salitang ito ay, dahil Napagtanto namin
kailangan namin talagang isang paraan ng pag-alala hindi lamang kung ano ang isang salita sa mang-uayabit
ngunit mo man o hindi, ang mga tao, ay natagpuan ito
upang kung nahanap mo ang salitang "ng" hindi lamang mo maaaring i-type ang mga, ipasok, ang, ipasok, ang, ipasok
at makakuha ng 3 puntos, 3 puntos, 3 puntos, 3 puntos.
Nais naming sa talaang-itim na salita sa pamamagitan ng pagtatakda ng isang bool
sa true kung natagpuan ito, at sa gayon ay ang dahilan kung bakit namin
encapsulated ito sa istraktura na ito.
>> Ngayon, pababa dito sa mang-uayabit may ito sa iba pang struct na tinatawag na diksyunaryo.
Absent dito ay ang salitang typedef dahil sa kasong ito
kailangan namin upang encapsulate ang ideya ng isang diksyunaryo,
at diksyunaryo ay naglalaman ng isang buong grupo ng mga salita,
bilang ipinahiwatig sa pamamagitan ng array na ito, at kung gaano karaming ng mga salitang iyon ay doon?
Well, anumang Sinasabi ng ito variable na tinatawag na laki.
Ngunit kailangan lang namin ng isang diksyunaryo.
Hindi namin kailangan ang isang uri ng data na tinatawag diksyunaryo.
Kailangan lang namin ang isa sa mga ito, kaya lumiliko out sa C
na kung hindi mo sasabihin ng typedef, sabihin mo lang struct, pagkatapos ay sa loob ng mga kulot tirante
inilagay mo ang iyong mga variable, at pagkatapos ay inilagay mo ang pangalan.
Ito ay deklarasyon isang variable na tinatawag na diksyunaryo
na ganito ang hitsura.
Sa pamamagitan ng kaibahan, ang mga linya na ito ay lumilikha ng isang magagamit muli istraktura ng data na tinatawag na salita
na maaari kang lumikha ng maramihang kopya ng, tulad ng aming ginawa ang
maramihang mga kopya ng mga mag-aaral.
>> Ano ang huli-daan sa amin upang gawin?
Hayaan akong bumalik sa, sabihin nating, ng isang mas simpleng halimbawa mula sa simple beses,
at hayaan mo akong magbukas ng, sabihin nating, compare1.c.
Ang problema dito sa kamay sa aktwal na alisan ng balat pabalik
ang layer ng isang string at simulan ang pagkuha off ang mga gulong ng pagsasanay
dahil ito ay lumiliko na isang string lahat oras na ito
ay bilang aming ipinangako sa linggo 1 sa talagang lamang ng isang palayaw,
isang kasingkahulugan mula sa CS50 library para sa isang bagay na mukhang ng kaunti pa misteriyoso,
magpasinda *, at kami nakikita star na ito bago.
Nakita namin ito sa konteksto ng mga file.
>> Natin na ngayong makita kung bakit kami ay itinatago ang detalye na ito para sa ilang oras na ngayon.
Narito ang isang file na tinatawag na compare1.c,
at tila nagtatanong ng user para sa 2 string, s at t,
at pagkatapos sinusubukan upang ihambing ang mga string para sa pagkakapantay-pantay sa linya 26,
at kung sila ay pantay-pantay ang sinasabi nito, "Ikaw-type ang parehong bagay,"
at kung sila ay hindi katumbas sinasabi nito, "Ikaw-type iba't ibang mga bagay."
Hayaan akong magpatuloy at patakbuhin ang program na ito.
Hayaan akong pumunta sa aking pinagmulan direktoryo, gumawa ng compare1. Ito inipon okay.
Hayaan akong magpatakbo ng compare1.
Kong mag-zoom in, ipasok.
Sabihing isang bagay. HELLO.
Sasabihin kong ang isang bagay muli. HELLO.
Tiyak ko ay hindi type iba't-ibang mga bagay.
>> Hayaan akong subukan ito muli. Bye bye.
Talagang hindi ibang, kaya kung anong nangyayari sa dito?
Well, kung ano ang talagang na kumpara sa linya 26?
[Hindi marinig na mag-aaral]
Oo, kaya lumiliko na ang isang string, uri ng data, uri ng isang maliit na kasinungalingan.
String ay isang pansamantalang trabaho *, ngunit kung ano ay isang pansamantalang trabaho *?
Ang isang pansamantalang trabaho *, bilang sinasabi nila, ay isang pointer,
at ang pointer ng epektibong ng isang address,
isang kabuuan ng lokasyon sa memorya, at kung mangyari mo nai-type sa isang salita tulad ng HELLO,
isipin ang mula sa mga nakaraang talakayan ng string
ito ay tulad ng salita HELLO.
Tandaan na maaaring katawanin ang isang salita tulad ng HELLO
bilang isang hanay ng mga character tulad nito
at pagkatapos gamit ang isang espesyal na character sa dulo tinatawag na null karakter,
bilang ang \ Nagpapahiwatig.
Ano ang aktwal na string ng?
Pansinin na ito ay maramihang mga chunks ng memory,
at sa katunayan, ang mga dulo ng lamang kilala sa sandaling tumingin ka sa pamamagitan ng ang buong string
naghahanap para sa mga espesyal na character null.
Ngunit kung ito ay isang tipak ng memorya mula sa memorya ng aking computer,
sabihin mang sabihin na ang string na ito Naging masuwerteng,
at Nakakuha ito ilagay sa pinakadulo simula ng RAM ng aking computer.
Ito ay byte 0, 1, 2, 3, 4, 5, 6 ...
>> Kapag sinabi ko ng isang bagay tulad ng GetString at gawin ko ang string s = GetString
kung ano talaga ang ibinalik?
Para sa mga nakalipas na ilang linggo, kung ano ang talagang na naka-imbak sa mga
hindi ang string na ito per se, ngunit sa kasong ito kung ano ang naka-imbak
ang numero ng 0 dahil sa kung ano ang GetString sa aktwal na ginagawa
ay hindi ito ay pisikal bumalik ng isang string.
Na hindi kahit na talagang gumawa ng haka-haka kahulugan.
Ano ang ginagawa nito return ay isang numero.
Na numero ay ang address ng HELLO sa memorya,
at string s pagkatapos, kung namin pamalikaskasan bumalik ang layer na ito, string ay hindi talaga umiiral.
Lamang ng pagpapagaan sa CS50 library.
>> Ito ay talagang isang bagay na tinatawag na magpasinda *.
Magpasinda saysay dahil kung ano ang isang salita, tulad ng HELLO?
Well, ito ay isang serye ng mga karakter, ang isang serye ng mga character.
Magpasinda * ay nangangahulugang ang address ng isang character,
kaya kung ano ang ibig sabihin upang bumalik ng isang string?
Ang isang magaling, simpleng paraan ng ibinabalik ang isang string
ay sa halip na subukan upang malaman kung paano ako bumalik sa 5 o 6 iba't ibang mga byte
hayaan mo akong bumalik sa address kung saan byte?
Ang unang isa.
Sa ibang salita, hayaan mo akong ibigay sa iyo ang address ng isang character sa memory.
Iyon ay kung ano ang magpasinda * ay kumakatawan, ang address ng isang solong character sa memory.
Tumawag na variable s.
Store sa mga na partikular na address, na sinabi ko mang ay 0,
lamang upang panatilihing simple ang mga bagay, ngunit sa katotohanan ito ay sa pangkalahatan ng mas malaking bilang.
>> Maghintay ng isang minuto.
Kung ka lamang pagbibigay sa akin ang address ng unang character, paano ko malalaman kung ano ang address
ng ikalawang karakter, ang ikatlong, ang ika-apat at ikalimang?
[Hindi marinig na mag-aaral]
Mo lamang malaman kung saan ang dulo ng string ay sa pamamagitan ng paraan ng ito madaling gamiting nanlilinlang,
kaya kapag gumamit ka ng isang bagay tulad ng printf, ano printf literal tumatagal ng bilang nito argument,
isipin ang na ginagamit namin placeholder na ito% s, at pagkatapos ay ka pumasa sa
ang variable na pag-iimbak ng isang string.
Ano ikaw talaga ang pagpasa ang address ng unang character ng na string.
Printf pagkatapos ay gumagamit ng para sa loop o habang loop sa oras ng pagtanggap ng address na iyon,
halimbawa, 0, kaya ipaalam sa gawin sa akin ito ngayon,
printf ("% s \ n");
Kapag tumawag ako printf ("% s \ n" s); kung ano talaga ako nagbibigay ng printf may
ang address ng unang character sa mga, na sa kasong ito arbitrary H.
>> Paano gumagana ang printf malaman kung ano ang eksaktong upang ipakita sa screen?
Ang taong ipinatupad printf ipinatupad ng habang loop o para sa loop
na nagsasabing ang mga character na ito ay katumbas ng espesyal na character null?
Kung hindi, i-print ito. Paano tungkol sa isang ito?
Kung hindi i-print ito, i-print ito, i-print ito, i-print ito.
Oh, ang isang ito ay espesyal. Ihinto ang pag-print at bumalik sa gumagamit.
At na ang lahat ng literal na nangyayari sa ilalim ng hood,
at na ng maraming digest sa unang araw ng klase,
ngunit sa ngayon talaga ang gusali bloke ng lahat ng pang-unawa
na nangyayari sa loob ng memory ng aming computer,
at kalaunan makikita namin manunudyo ito bukod na may kaunting tulong
mula sa isa sa aming mga kaibigan sa Stanford.
>> Propesor Nick Parlante sa Stanford ay gawin ito kahanga-hangang sequence ng video
mula sa lahat ng mga uri ng mga iba't ibang mga wika na ipinakilala
ito maliit Claymation karakter Binky.
Ang tinig na ikaw ay tungkol sa upang marinig sa loob lamang ng ilang segundo sneak preview
ay ng isang Stanford propesor, at nakakakuha ka ng
lamang sa 5 o 6 na segundo ng karapatang ito ngayon,
ngunit ito ay tandaan kung saan makikita namin pagtibayin ngayon
at magsimula sa Miyerkules.
Bigyan mo ako ng pointer Kasayahan na may Binky, ang preview.
[♪ Music ♪] [Propesor Parlante] Hey, Binky.
Wake up. Oras para sa pointer masaya.
[Binky] Ano iyan? Alamin ang tungkol sa mga payo?
Oh, mabait!
>> Makikita natin sa Miyerkules.
[CS50.TV]