Rob BOWDEN: Hi, Ako Rob Bowden, at hayaang makipag-usap tungkol sa quiz0.
>> Kaya, unang tanong.
Ito ang tanong na kung saan mo na kailangan upang code sa numero ng
127 sa binary na mga bombilya.
Kung gusto mo, maaari mo gawin ang regular na conversion
mula bi-- o, mula sa decimal sa binary.
Ngunit malamang na nangyayari upang kumuha ng maraming oras.
Ibig kong sabihin, maaari mong malaman na, OK, 1 ay nasa doon, 2 ay nasa doon,
4 ay nasa doon, 8 ay nasa doon.
Mas madaling paraan, 127 ay 128 minus isa.
Na pinakakaliwa ilaw bombilya ay ang 128-bit.
Kaya 127 ay talagang lahat lang sa iba pang mga bombilya ng ilaw,
dahil iyon ang pinakakaliwa liwanag bombilya minus 1.
Iyon lang para sa tanong na iyon.
>> Tanong isa.
Kaya may 3 piraso maaari mong kinakatawan 8 natatanging mga halaga.
Bakit, pagkatapos, ay 7 pinakamalaking hindi-negatibong decimal integer maaari mong kumatawan?
Well, kung kaya namin lamang kinakatawan 8 natatanging mga halaga,
pagkatapos ay kung ano ang namin ang pagpunta sa maging kumakatawan ay 0 sa pamamagitan ng 7.
0 tumatagal ng hanggang ang isa sa mga halaga.
>> Tanong dalawa.
Sa n bits, kung gaano karaming mga natatanging mga halaga na maaari mong kumatawan?
Kaya, na may n bits, mayroon kang 2 mga posibleng halaga para sa bawat bit.
Kaya mayroon kaming 2 posibleng halaga para sa ang unang bit, 2 posibleng halaga
para sa pangalawang, 2 posible para sa ikatlong.
At kaya na 2 beses 2 beses 2, at sa huli ang sagot ay 2 sa n.
>> Tanong tatlo.
Ano ang 0x50 sa binary?
Kaya tandaan na hexadecimal ay isang napaka prangka conversion sa binary.
Kaya dito, kailangan lang namin upang tumingin sa ang 5 at ang 0-iisa.
Kaya kung ano ang 5 sa binary?
0101, iyon ang 1 sandali at ang 4 na bit.
Ano ang 0 sa binary?
Hindi nakakalito.
0000.
Kaya ilagay lamang ang mga ito nang magkasama, at iyon ang buong numero sa binary.
01,010,000.
At kung gusto mong ma mo gumaya na pinakakaliwa zero.
Ito ay kaugnay.
>> Kaya pagkatapos ay Bilang kahalili, ano ang 0x50 sa decimal?
Kung gusto mo, could-- sa iyo kung ikaw ay higit pa kumportable sa binary,
maaari mong gawin na binary sagot at i-convert na sa decimal.
O maaari naming tandaan lamang na hexadecimal.
Kaya na 0 ay nasa ika-0 lugar, at ang 5 ay nasa 16 sa unang lugar.
Kaya dito, mayroon kaming 5 beses 16 sa una, kasama ang 0 beses 16 sa zero,
ay 80.
At kapag tiningnan mo ang mga pamagat sa tanong na,
ito ay CS 80, na kung saan ay uri ng isang Pahiwatig na ang kasagutan sa problemang ito.
>> Tanong lima.
Mayroon kaming ito sa simula script, na kung saan ay paulit-ulit na 4 na beses peanut butter halaya.
Kaya kung paano ginagawa namin ngayon ang code na nasa C?
Well, mayroon kaming here-- ang bahagi na naka-bold ay ang tanging bahagi na kayo ay nagkaroon na ipapatupad.
Kaya mayroon kaming 4 na loop na looping 4 beses, printf-ING peanut butter halaya,
gamit ang mga bagong linya ng itinatanong ang mga problema para sa.
>> Tanong anim, isa pang problema sa simula.
Nakita namin na hindi namin sa isang walang hanggan loop.
Sinasabi namin ang variable na i at pagkatapos ay i incrementing ng 1.
Ngayon gusto naming gawin iyon sa C. Mayroon ding mga maraming paraan ay maaaring tapos na namin ito.
Narito ang nangyari namin sa code ng magpakailanman loop bilang isang habang (true).
Kaya ipinahahayag namin ang variable i, lamang tulad namin ay may mga variable i sa simula.
Ipinahahayag ang variable i, at magpakailanman habang (true), sabihin namin ang mga variable i.
Kaya printf% i-- o maaaring nagamit mo na ang% d.
Sabihin namin na variable na iyon, at pagkatapos ay dinagdagan ito, i ++.
>> Tanong pitong.
Ngayon gusto naming gawin ang isang bagay na halos kapareho sa Mario tuldok c mula sa problema magtakda ng isang.
Gusto naming upang i-print ang mga hashtag, nais naming mag-print ng limang
sa pamamagitan ng tatlong parihaba ng mga hash.
Kaya paano namin pagpunta sa gawin iyon?
Well, bigyan ka namin ng isang buong bungkos ng code, at mo lamang
kailangang punan ang mga naka-print na grid function.
>> Kaya ano ang PrintGrid hitsura?
Well ikaw ay lagpas sa lapad at taas.
Kaya mayroon kaming isang panlabas 4 loop, na looping
sa ibabaw ng lahat ng mga hilera ng mga ito grid na gusto naming upang i-print out.
Pagkatapos ay mayroon kaming ang ilibing-Nested 4 loop, na pag-print sa ibabaw ng bawat haligi.
Kaya para sa bawat hilera, i-print namin para sa bawat haligi, ang isang solong hash.
Pagkatapos sa dulo ng hilera-print kami ng isang isang bagong linya upang pumunta sa susunod na hilera.
At na ito para sa buong grid.
>> Tanong walong.
Ang isang pag-andar tulad ng PrintGrid ay sinabi sa magkaroon ng epekto, ngunit hindi sa isang pabalik
halaga.
Ipaliwanag ang pagkakaiba.
Kaya ito ay nakasalalay sa iyo pagtanda kung ano ang isang side effect ay.
Well, sa isang pabalik na value-- alam namin PrintGrid hindi
may return halaga, dahil karapatan dito sinasabi nito walang bisa.
Kaya kahit ano na nagbabalik ng walang silbi Hindi talaga nagbalik ng anuman.
Kaya kung ano ang epekto?
Well, na epekto ay anumang bagay na uri ng magpapatuloy
pagkatapos ng pag-andar na hindi ibinalik lamang,
at ito ay hindi lamang mula sa input.
>> Kaya, halimbawa, maaari naming baguhin ang isang pandaigdigang variable.
Iyon ay magiging isang side effect.
Sa partikular na kasong ito, ang isang Napakahalaga na epekto
ay pag-print sa screen.
Kaya na ay isang pangalawang epekto na may PrintGrid.
-Print namin ang mga bagay na ito sa screen.
At maaari mong isipin na bilang na epekto,
dahil iyon ang isang bagay na nagpatuloy pagkatapos na magwakas ang function na ito.
Iyon ang isang bagay sa labas ng saklaw ng function na ito na ganap
ay nagbago, ang mga nilalaman ng screen.
>> Tanong siyam.
Isaalang-alang ang programa sa ibaba, na kung saan ang mga numero ng linya
naidagdag para sa ang alang-alang ng talakayan.
Kaya sa programang ito ay namin lamang pagtawag GetString, pag-imbak nito
sa variable na mga ito, at pagkatapos ay pag-print ng mga na variable.
OK.
Kaya kung bakit linya ng isa ay kasalukuyan.
#include cs50 tuldok h.
Bakit kailangan namin upang #include cs50 tuldok h?
Well namin ang pagtawag ng GetString function,
at GetString ay tinukoy sa cs50 library.
Kaya kung hindi namin ginawa magkaroon #include cs50 tuldok h,
Gusto namin na implicit deklarasyon ng error GetString function na
mula sa compiler.
Kaya kailangan namin upang isama ang library-- kailangan naming isama ang mga header ng file,
o iba pang mga compiler ay hindi makilala na ang GetString umiiral na.
>> Ipaliwanag kung bakit ang dalawang linya ay naroroon.
Kaya karaniwang IO tuldok h.
Ito ay eksaktong kapareho bilang ang nakaraang problema,
maliban sa halip ng pagharap sa GetString, pinag-uusapan natin ang tungkol sa printf.
Kaya kung hindi namin sinabi kailangan namin upang isama ang standard IO tuldok h,
pagkatapos ay hindi namin magagawang gamitin ang printf function,
dahil ang compiler hindi alam ang tungkol dito.
>> Why-- ano ang kabuluhan magpawalang-bisa ng sa apat na linya?
Kaya dito mayroon kaming int pangunahing (walang bisa).
Na lamang na nagsasabi na tayo ay hindi nakakakuha ng anumang mga command line
argumento sa main.
Tandaan na maaaring namin sabihin int pangunahing int argc string argv bracket.
Kaya dito sabihin lang namin walang bisa sasabihin namin ay binabalewala ang mga argument ng linya ng command.
>> Ipaliwanag, na may paggalang sa memorya, nang eksakto kung ano ang GetString sa linya ng anim na babalik.
GetString ay pagbabalik ng isang bloke ng memorya, ang isang hanay ng mga character.
Talaga Ito ay pagbabalik ng isang pointer sa unang character.
Tandaan na isang string ay isang pansamantalang trabaho star.
Kaya s ay isang pointer sa unang character sa anumang mga string ay
na ang gumagamit ay ipinasok sa keyboard.
At na memorya ang mangyayari sa ma-malloced, kaya na memory ay nasa kimpal.
>> Tanong 13.
Isaalang-alang ang programa sa ibaba.
Kaya ang lahat ng mga programang ito ay ginagawa ay printf-ING 1 hinati sa 10.
Kaya kapag pinagsama-sama at pinaandar, ang program na ito
output 0.0, kahit na 1 hinati sa 10 ay 0.1.
Kaya bakit ito 0.0?
Well, ito ay dahil sa ng dibisyon na integer.
Kaya 1 ay isang integer, 10 ay isang integer.
Kaya 1 na hinati sa pamamagitan ng 10, ang lahat ng bagay ay itinuturing na integer,
at sa C, kapag ginagawa namin integer division, pungusan namin ang anumang decimal point.
Kaya 1 hinati sa 10 ay 0, at pagkatapos naming sinusubukang
mag-print na bilang ng float, kaya zero-print bilang isang float ay 0.0.
At iyon ang dahilan kung bakit makuha namin 0.0.
>> Isaalang-alang ang programa sa ibaba.
Ngayon kami ay pag-print ng 0.1.
Kaya walang integer division, lamang kami sa pag-print 0.1,
ngunit kami ay pag-print ito sa 28 decimal lugar.
At makuha namin ito 0.1000, ang maramihang ng mga zero, 5 5 5, blah blah blah.
Kaya ang tanong dito ay kung bakit ang ginagawa nito -print na, sa halip na eksaktong 0.1?
>> Kaya ang dahilan dito ay ngayon lumulutang na tuldok imprecision.
Tandaan na ang isang float ay bits 32 lamang.
Kaya maaari lamang naming kumakatawan sa isang tiyak na numero ng ng mga lumulutang na halaga ng point na may mga 32
bits.
Doon na rin ang sa huli ay walang katapusan maraming mga lumulutang na halaga ng point,
at mayroong walang katapusan maraming mga lumulutang mga halaga ng point sa pagitan ng 0 at 1,
at kami ay malinaw naman magagawang kinakatawan ng higit pang mga halaga kaysa sa na.
Kaya mayroon kaming upang gumawa ng mga sakripisyo upang magagawa upang kumatawan sa karamihan ng mga halaga.
>> Kaya ng halaga tulad ng 0.1, sa malas Hindi namin maaaring kumatawan na eksaktong.
Kaya sa halip na kumakatawan sa 0.1 gawin namin ang pinakamahusay na maaari naming kumatawan ito 0.100000 5 5
5.
At na malapit sa katangian, ngunit para sa maraming mga application
mayroon kang mag-alala tungkol sa lumulutang na tuldok imprecision,
dahil kami lamang ay hindi maaaring kumatawan lahat ng mga lumulutang na eksaktong punto.
>> Tanong 15.
Isaalang-alang sa ibaba ang code.
Lamang kami sa pag-print 1 plus 1.
Kaya walang kakaibang ugali dito.
1 plus 1 sinusuri sa 2, at pagkatapos ay naka pag-print namin iyon.
Ito lamang mga Kopya 2.
>> Tanong 16.
Ngayon kami ay pag-print ng character 1 kasama ang character na 1.
Kaya bakit gumagana ito ay hindi i-print ang parehong bagay?
Well ang character 1 kasama ang character na 1, ang character 1 ay may ASCII halaga 49.
Kaya ito ay talagang sinasabi ng 49 plus 49, at sa huli ito ay pagpunta sa i-print ang 98.
Kaya ito ay hindi i-print ang 2.
>> Tanong 17.
Kumpletuhin ang pagpapatupad ng kakaiba sa ibaba sa paraang
na ang pag-andar nagbabalik totoo kung n ay kakaiba at hindi totoo kung n ay kahit.
Ito ay isang mahusay na layunin para sa mga mod operator.
Kaya isinasaalang-alang namin ang aming mga argumento n, kung n mod 2 ay katumbas ng 1, na rin
ay nangangahulugan na na hinati n sa pamamagitan ng 2 ay may natitira.
Kung n hinati sa 2 ay may natitira, na ay nangangahulugan na ang n ay kakaiba, kaya bumalik kami totoo.
Iba Pa bumalik kami false.
Maaari mo ring nagawa n mod 2 equals zero, return false, iba pa nagbabalik ng tunay.
>> Isaalang-alang ang recursive function na sa ibaba.
Kaya kung n ay mas mababa sa o katumbas ng 1, bumalik 1,
iba return n beses f ng n minus 1.
Kaya kung ano ang function na ito?
Well, ito ay isa lamang sa factorial function.
Ito ay mahusay na kinakatawan bilang n factorial.
>> Kaya tanong 19 ngayon, nais naming tumagal recursive function na ito.
Gusto naming gawin itong umuulit.
Kaya paano namin gawin iyon?
Well para sa mga tauhan solusyon, at muli naroon
maraming paraan maaari mo pa na iyon, sisimulan namin ang may ganitong produkto int
ay katumbas ng 1.
At sa buong ito para sa loop, kami ay pagpunta
na-multiply ng produkto upang sa huli napupunta sa ganap na factorial.
Kaya para sa int i katumbas 2, i ay mas mababa sa o katumbas ng n, i ++.
>> Maaaring nag-iisip ka kung bakit i ay katumbas ng 2.
Well, tandaan na dito mayroon kaming upang tiyakin na ang aming base kaso ay tama.
Kaya kung n ay mas mababa sa o katumbas sa 1, lang namin bumabalik 1.
Kaya sa paglipas dito, sisimulan namin sa katumbas i 2.
Well kung i ay 1, pagkatapos ay i-the-- o kung n ay 1, pagkatapos ay ang para sa loop
hindi maisagawa sa lahat.
At kaya kami ay lamang balik produkto, na kung saan ay 1.
Gayundin, kung ang n ay anumang bagay na mas mababa sa 1--
parang ito ay 0, negatibong 1, whatever-- Gusto pa rin ng pagbalik namin 1,
na kung saan ay kung ano mismo ang recursive bersyon ay ginagawa.
>> Ngayon, kung n ay mas malaki sa 1, pagkatapos kami ay pagpunta
gawin nang hindi bababa sa isa pag-ulit ng loop.
Kaya sabihin nating n 5, pagkatapos kami ay pagpunta sa gawin beses produkto ay katumbas ng 2.
Kaya ngayon produkto ay 2.
Ngayon kami ay pagpunta sa gawin beses na produkto ay katumbas ng 3.
Ngayon ay 6.
Beses ng produkto ay katumbas ng 4 na, ngayon, ito ay 24.
Beses ng produkto ay katumbas ng 5, ngayon ito ay 120.
Kaya pagkatapos ay sa huli, kami ay bumabalik 120, na kung saan ay tama 5 factorial.
>> Tanong 20.
Ito ang isa kung saan mayroon kang upang punan ang sa talahanayan sa anumang ibinigay na algorithm,
anumang bagay na iyong nakita namin, na umaangkop ang mga algorithmic run
mga oras ang mga asymptotic beses run.
Kaya kung ano ay isang algorithm na ay wakas na 1, ngunit malaking O ng n?
Kaya maaaring walang katapusan doon maraming mga sagot dito.
Ang isa na nasaksihan namin marahil pinaka madalas lamang ang linear paghahanap.
>> Kaya sa pinakamahusay na kaso Ang sitwasyong, ang item kami
hinahanap ay sa simula ng listahan
at sa gayon sa katapusan ng 1 hakbang, ang unang bagay na namin ang,
namin bumalik lang agad na nakita namin ang item na ito.
Sa pinakamasamang sitwasyon kaso, ang item ay sa dulo,
o ang item ay wala sa listahan sa lahat.
Kaya mayroon kaming upang maghanap ang buong listahan, ang lahat ng n
mga elemento, at iyon ang dahilan kung bakit ito o ng n.
>> Kaya ngayon ito ay isang bagay na kapwa wakas ng n log n, at malaking O ng n log n.
Well ang pinaka-may-katuturang mga bagay nasaksihan namin dito ay sumanib-uri-uriin.
Kaya sumanib-uri-uriin, tandaan, ay huli theta
ng n log n, kung saan theta ay tinukoy kung ang parehong wakas at malaking O ay pareho.
Parehong n log n.
>> Ano ang isang bagay na wakas ng n, at O ​​ng n nakalapat?
Well, muli naroon maramihang mga posibleng sagot.
Narito mangyari naming sabihin bubble-uuri.
-Uri-uriin Insertion ay din gumana dito.
Tandaan na bubble-uuri-uri May-optimize na kung saan,
kung ikaw ay maaaring makakuha ng sa pamamagitan ng buong listahan
hindi nangangailangan na gawin anumang mga swaps, pagkatapos, mahusay,
Maaari naming agad na bumalik na ang listahan ay pinagsunod-sunod sa magsimula sa.
Kaya sa pinakamahusay na sitwasyon kaso, ito ay wakas lamang ng n.
Kung ito ay hindi isang mahusay lamang pinagsunod-sunod listahan upang magsimula sa,
pagkatapos kami ay may O ng n nakalapat swaps.
At panghuli, mayroon kaming pag-uuri seleksyon para n nakalapat, parehong wakas at malaki O.
>> Tanong 21.
Ano ang integer overflow?
Well muli, katulad ng mas maaga, lamang mayroon kaming finitely maraming mga piraso
kinakatawan ang isang integer, kaya siguro 32 bit.
Sabihin nating mayroon kaming sign integer.
Pagkatapos ay sa huli ang pinakamataas na positibong numero maaari naming kumatawan
2 sa 31 minus 1.
Kaya kung ano ang mangyayari kung susubukan namin upang pagkatapos ay dinagdagan na integer?
Well, kami ay pagpunta upang pumunta mula sa 2 sa 31 minus 1, ang lahat ng mga paraan pababa sa negatibong 2
sa 31.
Kaya ito integer overflow ay kapag patuloy mong incrementing,
at sa huli hindi mo maaari makakuha ng anumang mas mataas at ito lamang
bumabalot sa lahat ng mga paraan pabalik sa paligid sa isang negatibong halaga.
>> Ano ang tungkol sa isang buffer overflow?
Kaya isang buffer overflow-- tandaan kung ano ang isang buffer ay.
Ito ay lamang ng isang tipak ng memorya.
Isang bagay tulad ng isang array ay isang buffer.
Kaya isang buffer overflow ay kapag subukan na i-access memory
nang higit sa dulo ng array na.
Kaya kung mayroon kang isang array ng laki 5 at mo
subukan na i-access array bracket 5 o bracket 6 o bracket 7,
o anumang bagay na higit pa sa pagtatapos, o kahit anumang bagay
below-- array bracket negatibong 1-- lahat ng mga ito ay buffer overflows.
Ka ng pagpindot sa memory sa masamang paraan.
>> Tanong 23.
Kaya sa isang ito kailangan mo upang ipatupad strlen.
At sabihin namin sa iyo na maaari kang ipinapalagay hindi s ay magiging walang bisa,
kaya hindi mo na kailangang mag gawin ang anumang mga tseke para sa null.
At marami ang mga paraan maaaring nagawa mo na ito.
Narito tumagal lamang namin ang prangka.
Simulan namin sa isang counter, n. n ay pagbibilang kung gaano karaming mga character mayroong.
Kaya simulan namin sa 0, at pagkatapos ay namin umulit sa buong listahan.
>> Ay mga bracket 0 katumbas ng null Terminator karakter?
Tandaan kaming naghahanap ng para sa ang null Terminator karakter
upang matukoy kung gaano katagal ang aming mga string ay.
Iyon ay pagpunta sa wakasan anumang may-katuturang string.
Kaya ang mga bracket 0 pantay sa null Terminator?
Kung hindi, pagkatapos kami ay pagpunta sa tumingin sa mga bracket 1, mga bracket 2.
Patuloy naming pagpunta hanggang namin hanapin ang null Terminator.
Sa sandaling iyong natagpuan namin ito, pagkatapos n naglalaman ng ang kabuuang haba ng string,
at maaari naming lamang bumalik iyon.
>> Tanong 24.
Kaya ito ay ang isa kung saan mo kailangang gumawa ng kalakalan-off.
Kaya ang isang bagay ay mabuti sa isa paraan, ngunit sa kung ano ang paraan ay ito masamang?
Kaya dito, pagsamahin-uri-uriin ay may gawi na maging mas mabilis kaysa sa bubble-uuri.
Ang pagkakaroon sinabi that-- mahusay, may maraming mga sagot dito.
Ngunit ang pangunahing isa ay na bubble-uuri-uri ay wakas ng n para sa isang pinagsunod-sunod na listahan.
>> Tandaan na ang talahanayan Nakita lang namin nang mas maaga.
Kaya mga uri ng bubble wakas ng n, ang pinakamahusay na sitwasyon kaso
ay nagagawa nitong pumunta lamang sa ibabaw ang listahan nang isang beses, tinutukoy
hey bagay na ito ay pinagsunod-sunod, at kita.
Pagsamahin ang mga pag-uuri, kahit na ano gagawin mo ito, ang katapusan ng n log n.
Kaya para Pinagbukud-bukod listahan, bubble -uri-uriin ang nangyayari upang maging mas mabilis.
>> Kung ano ang tungkol sa ngayon naka-link na listahan?
Kaya maaaring lumaki at pag-urong ng isang naka-link na listahan upang magkasya bilang maraming mga sangkap na kinakailangan.
Ang pagkakaroon sinabi that-- kaya karaniwang ang direct paghahambing
ay magiging isang naka-link ilista sa isang array.
Kaya kahit na array maaari madaling lumalaki at pag-urong
upang magkasya ng maraming mga elemento kung kinakailangan, ang listahan na naka-link
kumpara sa isang array-- isang array ay random na pag-access.
Maaari naming index sa anumang partikular na elemento ng array.
>> Kaya para sa isang naka-link na listahan, hindi namin maaari pumunta lamang sa ikalimang elemento,
mayroon kaming upang tumawid mula sa simula hanggang sa makuha namin sa ikalimang elemento.
At na pupuntahan pigilan kami mula sa paggawa ng isang bagay tulad ng binary paghahanap.
Nagsasalita ng binary paghahanap, binary paghahanap ay may gawi na maging mas mabilis kaysa sa linear paghahanap.
Ang pagkakaroon sinabi that-- kaya, isa sa mga posibleng bagay
ay hindi mo magagawa binary maghanap sa naka-link na mga listahan,
maaari mo lamang gawin ito sa array.
Ngunit marahil mas mahalaga, hindi mo maaaring gawin binary paghahanap
sa isang array na ay hindi pinagsunod-sunod.
Tapat maaaring kailangan mong ayusin ang array, at pagkatapos lamang maaari
gagawin mo binary paghahanap.
Kaya kung ang iyong bagay ay hindi Pinagbukud-bukod upang magsimula sa,
pagkatapos ay maaari maging mas mabilis linear paghahanap.
>> Tanong 27.
Kaya isaalang-alang ang programa sa ibaba, na magiging sa susunod na slide.
At ito ay ang isa na kung saan kami ay pagpunta sa nais na tahasang sabihin
ang mga halaga para sa iba't ibang mga variable.
Kaya tingnan natin na ipaalam.
>> Kaya line isa.
Mayroon kaming int x ay katumbas ng 1.
Iyon ay ang tanging bagay na nangyari.
Kaya sa linya ng isa, nakikita natin sa ating talahanayan, na y, a, b, at tmp ang lahat
blacked out.
Kaya kung ano ang x?
Well-set lang namin ito katumbas ng 1.
At pagkatapos ay i-line dalawa, mahusay, nakita namin na y ay nakatakda sa 2,
at ang talahanayan ay napunan para sa amin.
Kaya x ay 1 at y ay 2.
>> Ngayon, tatlong linya, hindi namin ngayon sa loob ng swap function.
Ano ang pumasa namin magpalit?
Ipinasa namin ampersand x para sa isang, at ampersand y para b.
Saan mas maaga ang problema nakasaad na ang address ng x
ay 0x10, at ang address ng y ay 0x14.
Kaya isang at b ay katumbas ng 0x10 at 0x14, ayon sa pagkakabanggit.
>> Ngayon sa tatlong linya, ano ang x at y?
Well, walang nagbago tungkol sa x at y sa puntong ito.
Kahit na ang mga ito sa loob ng isang pangunahing stack frame,
mayroon pa rin nila ang parehong mga halaga ng ginawa nila dati.
Hindi pa namin na-modify na anumang memory.
Kaya x ay 1, y ay 2.
Lahat ng karapatan.
Kaya ngayon sinabi namin int tmp katumbas ng lagyan ng star ang isang.
Kaya sa apat na mga linya, ang lahat ng bagay ay pareho maliban para sa tmp.
Hindi namin ay nagbago ng anumang mga halaga ng anumang bagay maliban sa tmp.
-Set namin ang tmp katumbas ng lagyan ng star ang isang.
Ano ang bituin ng?
Well, isang punto upang x, Kaya lagyan ng star ang isang Pupunta sa pantay na x, na kung saan ay 1.
Kaya ang lahat ng bagay ay kinopya pababa, at tmp ay nakatakda sa 1.
>> Ngayon ang susunod na linya.
Lagyan ng star ang isang katumbas ng bituin b.
Kaya sa pamamagitan ng linya five-- na rin muli, ang lahat ng bagay ay pareho maliban sa kahit anong star ng ay.
Ano ang bituin ng?
Well, sinabi lang namin star isang ay x.
Kaya naming binabago x-pantay na bituin b.
Ano ang bituin b? y. b punto sa y.
Kaya star b ay y.
Kaya namin ang pagse-set x katumbas ng y, at lahat ng iba pa ay pareho.
Kaya nakikita natin sa susunod na hilera na x na ngayon ang 2, at ang iba pa lang kinopya pababa.
>> Ngayon sa susunod na linya, bituin b ay katumbas ng tmp.
Well, sinabi lang namin star b ay y, kaya kami ay-set y katumbas ng tmp.
Lahat ng iba pa ay pareho, kaya ang lahat ng bagay ay makakakuha ng kinopya pababa.
Kami ay pagtatakda y katumbas ng tmp, na isa, at lahat ng iba pa ay pareho.
>> Ngayon sa wakas, pitong linya.
Humihingi kami pabalik sa pangunahing pag-andar.
Humihingi kami pagkatapos magpalitan ay tapos na.
Naming nawala a, b, at tmp, ngunit sa huli namin
ay hindi nagbabago ng anumang mga halaga ng anumang bagay na sa puntong ito,
kopyahin lamang namin ang x at y pababa.
At nakita namin na x at y ay ngayon 2 at 1 sa halip na 1 at 2.
Swap ay matagumpay pinaandar.
>> Tanong 28.
Ipagpalagay na nakatagpo ka ang mga mensahe ng error
sa ibaba sa panahon ng oras ng opisina sa susunod na taon bilang isang CA o tf.
Payuhan kung paano aayusin ang bawat isa sa mga error na ito.
Kaya hindi natukoy na reference sa GetString.
Bakit maaari mong makita na ito?
Well, kung ang isang mag-aaral ay gumagamit ng GetString sa kanilang mga code,
maayos ang mga ito hash kasama cs50 tuldok h isama ang cs50 library.
>> Well, ano ang ginagawa nila kailangan mong ayusin ang error na ito?
Kailangan nila upang gawin ang isang gitling lcs50 sa command line kapag sila ay kino-compile.
Kaya kung hindi sila pumasa kumalatong gitling lcs50, ang mga ito ay
Hindi pagpunta sa magkaroon ng aktwal na code na ipinapatupad ng GetString.
>> Tanong 29.
Nang kataon lamang deklarasyon strlen function ng library.
Well ngayon, ang mga ito na ito ay hindi tapos na ang tamang hash isama.
Sa partikular na kasong ito, ang header ng file kailangan nila upang isama ang string na tuldok h,
at kabilang ang string na tuldok h, ngayon ang student-- ngayon ang compiler
May access sa pagdeklara ng strlen,
at alam nito na ang iyong code ay gumagamit ng strlen tama.
>> Tanong 30.
Higit pang mga porsiyento ng mga conversion kaysa sa mga argumento ng data.
Kaya kung ano ito?
Well tandaan na ang mga porsiyento signs-- kung paano ang mga ito ay may-katuturan sa printf.
Kaya sa printf maaari naming percent-- maaari naming i-print ang isang bagay
tulad porsiyento i backslash n.
O maaari naming i-print tulad ng porsiyento i, espasyo, porsiyento i, espasyo, i porsiyento.
Kaya para sa bawat isa sa mga porsiyento palatandaan, kailangan namin
upang pumasa sa isang variable sa dulo ng printf.
>> Kaya kung sinasabi namin printf paren porsiyento i backslash n malapit paren,
mahusay, sabihin namin na hindi namin pagpunta sa i-print ang isang integer,
ngunit pagkatapos ay hindi namin pumasa printf isang integer upang aktwal na-print.
Kaya dito higit pang mga porsiyento mga conversion kaysa sa mga argumento ng data?
Na nagsasabi na mayroon kami ang maramihang mga percents,
at wala kaming sapat na mga variable upang aktwal na punan ang mga percents.
>> At pagkatapos ay talagang, para sa tanong 31, Talagang nawala 40 bytes sa isang bloke.
Kaya ito ay isang error Valgrind.
Ito ay nagsasabi na sa isang lugar sa iyong code,
mayroon kang isang paglalaan na 40 bytes malaki kaya malloced 40 bytes,
at hindi ka na kailanman napalaya ito.
Malamang na kailangan mo lamang upang mahanap ang ilang mga tulo ng memorya,
at hanapin kung saan kailangan mong palayain ang bloke ng memorya.
>> At tanong 32, di-wastong write ng laki 4.
Muli ito ay isang error Valgrind.
Ito ay walang gagawin sa memory paglabas ngayon.
Ito ay, karamihan sa likely-- ibig kong sabihin, ito ay isang uri ng di-wastong mga karapatan ng memory.
At pinaka-malamang na ito ay ilang uri ng buffer overflow.
Kung saan mayroon kang isang array, siguro isang integer array, at sabihin
sabihin ito ng laki 5, at subukang pindutin ang array bracket 5.
Kaya kung susubukan mo na magsulat sa mga iyon halaga, hindi iyon isang piraso ng memorya
na iyong aktwal na magkaroon ng access sa, at kaya ka ng pagpunta upang makakuha ng error na ito,
sinasabi ng mga di-wastong write ng laki 4.
Valgrind ay pagpunta sa makilala ka sinusubukan mong pindutin ang memorya ng hindi naaangkop.
>> At na ito para sa quiz0.
Ako ay Rob Bowden, at ito ay CS50.