[Powered by Google Translate] [Suriin] [Quiz 0]
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvard University]
>> [Ito ay CS50.] [CS50.TV]
>> Uy, lahat.
Maligayang pagdating sa pagsusuri session para sa Quiz 0, na kung saan ay nagaganap ito Miyerkules.
Ano kami ay pagpunta sa gawin ngayong gabi, ako ay may 3 iba pang mga TFs,
at sama-sama namin ay pagpunta sa pumunta sa pamamagitan ng pagsusuri ng kung ano ang ginawa namin sa kurso sa ngayon.
Hindi ito 100% komprehensibong, ngunit dapat itong bigyan ka ng isang mas mahusay na ideya
ng kung ano ang mayroon ka nang down at kung ano ang kailangan mo pa rin upang pag-aralan bago Miyerkules.
At huwag mag-atubiling upang taasan ang iyong kamay sa mga tanong namin ay pagpunta sa kahabaan,
ngunit tandaan na gagamitin din namin ng kaunting panahon sa dulo-
kung makuha namin sa pamamagitan ng ilang minuto upang ekstrang-upang gawin ang mga pangkalahatang mga katanungan,
kaya panatilihin na sa isip, at kaya kami ay pagpunta sa magsimula sa na nagsisimula sa Linggo 0.
>> [Pagsusulit 0 Review!] [Bahagi 0] [Lexi Ross] Ngunit bago ang ginagawa namin na natin pag-usapan ang
ang logistik ng pagsusulit.
>> [Logistics] [Quiz ay tumatagal ng lugar sa Miyerkules 10/10 sa halip ng panayam]
>> [(Tingnan ang http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf para sa mga detalye)] sa Miyerkules, Oktubre ika-10.
>> Na ito Miyerkules, at kung pumunta ka sa URL na ito dito,
na ring ma-access mula CS50.net-may ni isang link papunta dito
maaari mong makita ang impormasyon tungkol sa kung saan pumunta batay sa
ang iyong huling pangalan o kaugnayan sa paaralan pati na rin
ito ay nagsasabi sa tungkol sa kung ano mismo ang pagsusulit ay masaklawan at ang mga uri ng mga katanungan na kayo ay pagpunta upang makakuha ng.
Isaisip na ang makikita mo ring magkaroon ng isang pagkakataon upang suriin para sa pagsusulit sa seksyon,
sa gayon ang iyong mga TFs dapat pagpunta sa paglipas ng ilang mga problema ng kasanayan,
at ang isa pang magandang pagkakataon upang makita kung saan kailangan mo pa ring mag-aral up para sa pagsusulit.
Simulan natin sa simula may Bits 'n' Bytes.
Alalahanin isang bit lamang ng 0 o 1,
at isang byte ay isang koleksyon ng 8 ng mga bits.
Tingnan natin sa koleksyon na ito ng mga bits dito mismo.
Dapat namin upang malaman kung gaano karaming mga bits may.
Saan umaasa kami lang 8 sa kanila, walong 0 o 1 yunit ng.
At dahil may 8 bits, na 1 byte,
at sabihin convert ito sa hexadecimal.
Hexadecimal ay base 16, at ito ay medyo madaling i-convert
isang numero sa binary, na kung ano iyon ay, sa isang numero sa hexadecimal.
Ang ginagawa namin ay tinitingnan namin ang mga grupo ng 4,
at convert namin ang mga ito sa naaangkop na digit na hexadecimal.
Simulan namin ang i-right-pinaka-grupo ng 4, kaya 0011.
Na pagpunta sa isang 1 at isang 2, kaya sama-sama na ginagawang 3.
At pagkatapos ay tingnan natin sa iba pang mga bloke ng 4.
1101. Na isa 1, isang 4, at isang 8.
Sama-sama na pagpunta sa 13, na ginagawang D.
At kami na tandaan na sa hexadecimal hindi namin pumunta lamang 0 hanggang 9.
Pumunta kami 0 sa pamamagitan ng F, kaya pagkatapos ng 9, 10 ay tumutugon sa A,
11 sa B, at iba pa na kung saan ang F ay 15.
Narito 13 D,
kaya i-convert ito sa decimal ang ginagawa namin ay namin ang aktwal na
tinatrato ang bawat posisyon bilang isang kapangyarihan ng 2.
Iyon ay isang 1, isang 2, zero 4s, zero 8s, isang 16, at iba pa,
at ito ay isang maliit na mahirap upang makalkula sa iyong ulo, ngunit kung pumunta kami sa susunod na slide
maaari naming makita ang mga sagot na iyon.
>> Mahalaga kami ng balagtas mula kanan pabalik sa kaliwa,
at kami ay multiply bawat digit ng kaukulang kapangyarihan ng 2.
At tandaan, para sa hexadecimal magpakilala namin ang mga numerong ito may 0x sa simula
kaya hindi namin lituhin ang mga ito na may isang decimal na numero.
Patuloy sa, ito ay isang ASCII Table,
at kung ano ang ginagamit namin ASCII para sa ay upang i-map mula sa mga character sa numerical na halaga.
Tandaan sa pset cryptography ginawa namin ang malawak na paggamit ng ASCII Table
upang gamitin ang iba't ibang mga pamamaraan ng cryptography,
ang Caesar at ang Vigenère cipher, i-convert ang iba't ibang mga titik
sa isang string na ayon sa ang susi na ibinigay ng user.
Tingnan natin ng kaunting ASCII matematika.
Pagtingin sa 'P' + 1, sa character na form na Q,
at tandaan na '5 '≠ 5.
At kung paano eksaktong-convert namin sa pagitan ng mga 2 form?
Ito ay hindi tunay na masyadong matigas.
Upang makakuha ng 5 ibabawas namin ang '0 '
dahil may 5 lugar sa pagitan ng mga '0 'at ang '5.'
Upang pumunta sa iba pang mga paraan naming idagdag lamang ang 0,
kaya ito ay uri ng tulad ng sa regular na pang-aritmetika.
Tandaan lamang na kapag ang isang bagay ay may mga panipi sa paligid nito ng character
at samakatuwid ay kumakatawan sa isang halaga sa ASCII table.
Paglipat sa higit pang mga pangkalahatang paksa computer science.
Natutunan namin kung ano ang algorithm ng at kung paano namin ginagamit mga programa
ipatupad algorithm.
Ang ilang mga halimbawa ng mga algorithm ng isang bagay na talagang simple tulad ng
pagsuri kung ang isang numero ay kahit o kakaibang.
Para na tandaan namin mod ang numero sa pamamagitan ng 2 at suriin kung ang resulta ay 0.
Kung gayon, kahit. Kung hindi, kakaiba.
At na ang isang halimbawa ng isang talagang pangunahing algorithm.
>> Isang kaunti ng isang mas kasangkot isa ay binary paghahanap,
na ipagpapatuloy namin sa paglipas mamaya sa session ng pagsusuri.
At programming ay ang termino na ginagamit namin para sa pagkuha ng isang algorithm
at nagko-convert ito sa code sa computer ay maaaring basahin.
2 halimbawa ng programming simula,
na kung ano ang ginawa namin sa Linggo 0.
Kahit na hindi namin aktwal type ang code ito ay isang paraan ng pagpapatupad
ito algorithm, na kung saan ay pag-print ang mga numero 1-10,
dito gawin namin ang pareho sa C programming wika.
Ito ay katumbas pagtakbo, lamang ng nakasulat sa iba't ibang wika o syntax.
Pagkatapos namin natutunan tungkol sa boolean expression,
at ang boolean ng isang halaga na maaaring totoo o hindi,
at dito malimit boolean expression
pumunta sa loob ng mga kundisyon, kaya kung (x ≤ 5),
mahusay, namin x = 5, kaya kondisyon na upang pag-aralan sa true.
At kung ito ay totoo, anumang code ay sa ilalim ng mga kundisyon
ay pagpunta sa nasuri ng computer, kaya ang string na ay pagpunta sa ipi-print
sa standard na output, at ang terminong kundisyon
ay tumutukoy sa anumang sa loob ng panaklong ng kung pahayag.
Tandaan ang lahat ng mga operator.
Tandaan ito ay && at | | kapag sinusubukan naming pagsamahin 2 o higit pang mga kundisyon,
== Hindi = upang suriin kung ang 2 bagay ay pantay-pantay.
Tandaan na = para sa pagtatalaga samantalang == ay isang boolean operator.
≤, ≥ at pagkatapos ay ang panghuling 2 ay maliwanag.
Isang pangkalahatang pagsusuri ng boolean logic dito.
At boolean expression ay mahalaga din sa loop,
na ipagpapatuloy namin sa paglipas ngayon.
Namin natutunan ang tungkol sa 3 uri ng mga loop sa ngayon sa CS50,, habang, at gawin habang.
At ito ay mahalagang malaman na habang para sa karamihan ng mga layunin ng
maaari naming aktwal na gamitin ang anumang uri ng loop sa pangkalahatan
may ilang mga uri ng mga layunin o mga karaniwang pattern
programming na partikular na tumawag para sa isa ng mga loop
na gawin itong ang pinaka-mahusay o eleganteng code na ito sa paraan na.
Natin pumunta sa kung ano ang bawat isa sa mga loop ay may kaugaliang upang gamitin para sa madalas.
>> Sa isang para sa loop namin sa pangkalahatan na malaman kung gaano karaming beses ang nais namin upang umulit.
Iyon ay kung ano ang inilalagay namin sa kundisyon.
Para sa, i = 0, i <10, halimbawa.
Na namin alam na gusto naming gawin ang isang bagay na 10 beses.
Ngayon, para sa isang habang loop, pangkalahatan, hindi namin kinakailangang
malaman kung gaano karaming beses ang gusto naming loop na tumakbo.
Ngunit ginagawa namin malaman ang ilang mga uri ng mga kondisyon na gusto namin ito
palaging totoo o palaging maling.
Halimbawa, habang naka-set.
Sabihin natin na ang isang boolean variable.
Habang na ang tunay na gusto naming code upang pag-aralan,
kaya ng kaunti mas extensible, isang kaunti mas pangkalahatang kaysa sa isang loop,
subalit ang anumang para sa loop ay maaari ring ma-convert sa isang loop habang.
Panghuli, gawin habang loop, na maaaring maging trickiest naiintindihan kaagad,
ay madalas na ginagamit kapag gusto namin upang pag-aralan muna ang code
bago ang unang pagkakataon namin suriin ang kalagayan.
Ang isang karaniwang kaso ng paggamit para sa isang gawin habang loop
kapag gusto mo upang makuha ang input ng user, at alam mo na nais mong hilingin sa user
para sa input ng hindi bababa sa isang beses, ngunit kung hindi sila magbibigay sa iyo ng magandang input kaagad
Nais mo bang panatilihin ang pagtatanong sa kanila hanggang sila ay magbibigay sa iyo ng mahusay na input.
Iyon ay ang pinaka-karaniwang paggamit ng isang habang loop,
at tingnan natin sa aktwal na istraktura ng mga loop.
Sila ay karaniwang palaging ay may posibilidad upang sundin ang mga pattern.
>> Sa para sa loop sa loob mayroon kang 3 bahagi:
Pinasimulan, karaniwang isang bagay tulad ng int i = 0 kung saan ay i counter,
kondisyon, kung saan nais naming sabihin patakbuhin ang para sa loop hangga't bilang kundisyon hold pa rin ito,
tulad ng i <10, at pagkatapos ay sa wakas, i-update, na kung saan ay kung paano namin dagdagan
ang counter variable sa bawat punto sa loop.
Ang isang karaniwang bagay upang makita doon ay i + +,
na nangangahulugan na i dagdagan sa pamamagitan ng 1 sa bawat oras.
Maaari mo ring gawin ang isang bagay tulad ng i + = 2,
na nangangahulugan na magdagdag ng 2 sa i bawat oras na pumunta ka sa pamamagitan ng loop.
At pagkatapos ay gawin ito lamang ay tumutukoy sa anumang code na aktwal na tumatakbo bilang bahagi ng loop.
At para sa isang habang loop, oras na ito namin aktwal ay ang Pinasimulan sa labas ng loop,
kaya halimbawa, sabihin nating sinusubukan naming gawin ang parehong uri ng loop bilang ko na inilarawan.
Gusto namin sabihin int i = 0 bago loop nagsisimula.
Pagkatapos ay maaari naming sabihin habang i <10 gawin ito,
kaya ang parehong bloke ng code tulad ng dati,
at oras na ito ang bahagi ng update ng code, halimbawa, i + +,
aktwal na napupunta sa loob ng loop.
At sa wakas, para sa isang gawin habang, katulad sa loop habang,
ngunit mayroon kaming tandaan na ang code ay suriin sabay-sabay
bago ang kundisyon ay naka-check, kaya gumagawa ng maraming higit pang mga kahulugan
kung tiningnan mo ang mga ito sa pagkakasunud-sunod ng sa itaas hanggang sa ibaba.
Sa isang gawin habang loop code ng sinusuri bago mo ring tingnan ang kundisyon ng habang,
kung saan isang habang loop, sumusuri unang.
Pahayag at variable.
Kapag gusto naming upang lumikha ng isang bagong variable gusto muna namin ang pagsisimula ito.
>> Halimbawa, int na bar initializes ang variable bar,
ngunit hindi ito bigyan ito ng isang halaga, kaya kung ano ang bar ng halaga ngayon?
Hindi namin alam.
Ito ay maaaring maging ng ilang mga halaga ng basura na ay dati nang naka-imbak sa memorya doon,
at hindi namin gusto mong gamitin na variable
hanggang sa aktwal na namin bigyan ito ng isang halaga,
kaya ipinapahayag namin ito dito.
Pagkatapos naming nakapagsimula ito sa 42 sa ibaba.
Ngayon, siyempre, alam namin na ito ay maaaring gawin sa isang linya, int bar = 42.
Ngunit lamang na i-clear ang maraming mga hakbang na nangyayari sa,
ang deklarasyon at ang Pinasimulan nangyayari hiwalay dito.
Ito ay nangyayari sa isang hakbang, at sa susunod, int baz = bar + 1,
ang pahayag na ito sa ibaba, na palugit baz, kaya sa dulo ng block ng code na ito
kung kami ay upang i-print ang halaga ng baz ito ng 44
dahil ipinapahayag namin at initialize ito sa 1> bar,
at pagkatapos naming dagdagan ang mga ito nang isa pang beses sa + +.
Nagpunta kami sa paglipas itong maganda panandaliang, ngunit ito ay mahusay na upang magkaroon ng isang pangkalahatang
pag-unawa kung ano ang mga thread at kaganapan.
Pangunahing ginawa namin ito sa simula,
sa gayon ay maaari mong isipin ng mga thread sa bilang ng maramihang mga pagkakasunud-sunod ng code
na tumatakbo sa parehong oras.
Sa katunayan, marahil ito ay hindi tumatakbo sa parehong panahon,
ngunit uri ng abstractly maaari naming tingin ito sa paraan na.
>> Sa simula, halimbawa, nagkaroon kami ng maramihang mga sprites.
Maaaring execute ang ibang code sa parehong oras.
Maaaring isa-maigsing habang ang iba pa ay sinasabi ng isang bagay
sa isang iba't ibang mga bahagi ng screen.
Kaganapan ay isa pang paraan ng paghihiwalay ng ang logic
sa pagitan ng mga iba't ibang mga elemento ng iyong code,
at sa simula kami ay upang gayahin ang mga kaganapan sa gamit ang Broadcast,
at na aktwal Kapag Tumanggap ko, hindi Kapag Pakinggan ko,
ngunit mahalagang ito ay isang paraan upang magpadala ng impormasyon
mula sa isang engkanto sa ibang.
Halimbawa, maaaring gusto mong magpadala laro sa paglipas ng,
at kapag ang isa pang engkanto na natatanggap ng laro sa paglipas ng,
tumugon sa isang tiyak na paraan.
Ito ay isang mahalagang modelo upang maunawaan para sa programming.
Lamang upang pumunta sa ibabaw ng pangunahing Linggo 0, kung ano ang namin ang nawala sa paglipas ng sa ngayon,
tingnan natin ito simpleng programa C.
Teksto ay maaaring kaunti na maliit mula dito, ngunit ko pumunta sa paglipas ng ito talagang mabilis.
Kami ay kabilang ang 2 file ng header sa tuktok, cs50.h at stdio.h.
Kami ng pagtukoy sa isang pare-pareho na tinatawag na limitasyon na 100.
Kami ay pagpapatupad ng aming pangunahing function na.
Dahil hindi namin gamitin ang mga argumento sa command line dito kailangan namin upang ilagay ang walang bisa
bilang ng mga argumento para sa pangunahing.
Nakikita namin int itaas pangunahing. Iyon ang return uri, samakatuwid bumalik 0 sa ibaba.
At ginagamit namin CS50 library function na makakuha int
tanungin ang user para sa input, at hindi namin iimbak ito sa ito variable x,
kaya namin idedeklara x sa itaas, at initialize namin ito may x = GetInt.
>> Pagkatapos namin suriin upang makita kung ang user ay nagbigay sa amin ng magandang input.
Kung ≥ LIMIT gusto naming ibalik ng isang error code na 1 at i-print ang isang mensahe ng error.
At sa wakas, kung ang gumagamit ay nagbigay sa amin ng mahusay na input
kami ay parisukat ang numero at i-print na resulta.
Lamang upang matiyak na ang mga lahat ng tahanan hit
maaari mong makita ang mga label ng mga iba't ibang mga bahagi ng code dito.
Nabanggit ko pare-pareho, header file.
Oh, int x. Tiyakin na tandaan na ang isang lokal na variable.
Na contrasts ito mula sa isang global na variable, kung saan ipapakita namin makipag-usap tungkol sa
kaunti mamaya sa pagsusuri ng session,
at kami ay pagtawag sa library function na printf,
kaya kung hindi namin kasama ang stdio.h file ng header
hindi namin magagawang tawagan printf.
At naniniwala ko ang arrow na Nakakuha putol dito ay tumuturo sa d%,
na-format na string sa printf.
Sabi ni i-print ang variable na ito bilang isang numero,% d.
At na ito para sa Linggo 0.
Ngayon Lucas ay pagpunta upang magpatuloy.
Hey, guys. Ang pangalan ko ay Lucas.
Ako isang sopomor sa pinakamahusay na bahay sa campus, Mather,
at ako makipag-usap ng kaunti tungkol sa Linggo 1 at 2.1.
[Linggo 1 at 2.1!] [Lucas Freitas]
Bilang Lexi ay sinasabi, kapag nagsimula kaming pagsalin ng iyong code mula sa simula sa C
isa ng mga bagay na napansin namin na maaari mong hindi lamang
isulat ang iyong code at patakbuhin ang mga ito gamit ang isang berdeng bandila ito.
Aktwal na, mayroon kang upang gamitin ang ilang mga hakbang upang gawin ang iyong programa sa C
maging isang executable file.
Talaga kung ano ang ginagawa mo kapag sumusulat ka ng isang program na
mong isalin ang iyong ideya sa isang wika na maunawaan na ang tagatala ng,
kaya kapag sumusulat ka ng isang programa sa C
kung ano ang iyong ginagawa ay aktwal na pagsusulat ng isang bagay na ang iyong tagatala ay upang maunawaan,
at pagkatapos tagatala ay pagpunta sa isalin ang code na iyon
sa isang bagay na ang iyong computer ay maunawaan.
>> At bagay, ang iyong computer ay talagang napaka pipi.
Iyong computer ay maaari lamang maunawaan 0s at 1s,
kaya aktwal na sa unang computer mga tao na karaniwang program
paggamit ng 0s at 1s, ngunit hindi ito, salamat sa Diyos.
Hindi namin kabisaduhin ang mga pagkakasunud-sunod para 0s at 1s
para sa isang para sa loop o para sa isang habang loop at iba pa.
Iyon ay kung bakit mayroon kaming isang tagatala.
Ano tagatala ng nagagawa ng isang ito talaga isinasalin ang C code,
sa aming kaso, sa isang wika na ang iyong computer ay maunawaan,
na ang bagay na code, at ang tagatala na ginagamit namin
ay tinatawag na kumalatong, kaya ito ay talagang ang simbolo para sa kumalatong.
Kapag mayroon ka ng iyong programa, mayroon kang gawin ang 2 bagay.
Una, mayroon kang upang ipunin ang iyong programa, at pagkatapos ka upang patakbuhin ang iyong programa.
Upang ipunin ang iyong programa mayroon kang maraming mga pagpipilian upang gawin ito.
Ang unang isa ay upang gawin kumalatong program.c
kung saan ang programa ay ang pangalan ng iyong programa.
Sa kasong ito, maaari mong makita lamang ang sinasabi nila "Uy, makatipon ang aking programa."
Hindi mo sinasabi na "Gusto ko ang pangalan na ito para sa aking programa" o anumang.
>> Ang ikalawang opsyon ay pagbibigay ng pangalan sa iyong programa.
Maaari mong sabihin kumalatong-o at pagkatapos ay ang pangalan na gusto mo
executable file na pinangalanang bilang at pagkatapos program.c.
At maaari ka ring gumawa ng programa, at makita kung paano sa unang 2 kaso
Ko bang ilagay. C, at sa ikatlong isa ko lang ng mga programa?
Oo, aktwal mo ay hindi dapat ilagay. C kapag gumamit ka ng gumawa.
Kung hindi man ang tagatala ay talagang pagpunta sa sumigaw sa iyo.
At din, hindi ko alam kung ikaw guys tandaan,
ngunit maraming ng beses na namin ginagamit din-lcs50 o-lm.
Na tinatawag na pagli-link.
Ito lamang ay nagsasabi sa ang tagatala na gagamitin mo sa mga aklatan doon,
kaya kung gusto mong gamitin ang cs50.h iyong aktwal na i-type ang
kumalatong program.c-lcs50.
Kung hindi mo gawin iyon, ang tagatala ay hindi malaman
na gumagamit ka ng mga function sa cs50.h.
At kapag gusto mong patakbuhin ang iyong programa Mayroon kang 2 pagpipilian.
Kung ginawa mo kumalatong program.c hindi mo magbigay ng pangalan sa iyong programa.
Mayroon kang upang patakbuhin ito gamit. / A.out.
Ang A.out ay isang karaniwang pangalan na kumalatong ay nagbibigay ng iyong programa kung hindi mo bigyan ito ng isang pangalan.
Kung hindi ka pagpunta sa gawin. / Programa kung ikaw ay nagbigay ng pangalan sa iyong programa,
at din kung ang programa ang pangalan na programa ng upang makakuha ng
na na program ang parehong pangalan tulad ng file c.
Pagkatapos usapan natin ang tungkol sa mga uri ng data at ang data.
>> Isa lamang uri ng data ay ang mga parehong bagay bilang maliit na kahon ginagamit nila
upang mag-imbak ng mga halaga, kaya ang mga uri ng data ay talagang tulad ng Pokémons.
Mga ito sa lahat ng mga laki at uri.
Hindi ko alam kung ang pagkakatulad na saysay.
Ang laki ng data sa aktwal ay depende sa architecture machine.
Ang lahat ng data laki na ako pagpunta upang ipakita dito
ay talagang para sa isang 32-bit na machine, na kung saan ay ang kaso ng aming appliance,
ngunit kung aktwal mong coding sa iyong Mac o sa isang Windows din
marahil ka upang magkaroon ng isang 64-bit na machine,
kaya tandaan na ang laki ng data na ako pupunta upang ipakita dito
para sa 32-bit na machine.
Ang unang isa na nakita natin ay isang int,
na medyo direkta.
Gumamit ka ng int upang mag-imbak ng isang integer.
Din kami nakakita ng character, ang pansamantalang trabaho.
Kung nais mong gumamit ng isang titik o isang maliit na simbolo marahil ka na gumamit ng isang pansamantalang trabaho.
Magpasinda A ay 1 byte, na nangangahulugan ng 8 bits, tulad Lexi sinabi.
Talaga mayroon kaming isang ASCII Table na may 256
posibleng mga kumbinasyon ng 0s at 1s,
at pagkatapos ay kapag nag-type ka ng isang pansamantalang trabaho ito upang isalin ang
karakter ang na input sa iyo ng isang numero na mayroon ka sa ASCII table, tulad Lexi sinabi.
Mayroon din kaming Float, na ginagamit namin upang mag-imbak ng mga numero ng decimal.
Kung nais mong pumili ng 3.14, halimbawa, ikaw ay pagpunta sa gumamit ng Float
o isang double na may higit pang katumpakan.
Float A ay may 4 bytes.
Double A ay may 8 bytes, kaya ang pagkakaiba lamang ay ang katumpakan.
Mayroon din kaming isang mahabang na ginagamit para sa mga integer,
at maaari mong makita para sa isang 32-bit na machine isang int at isang mahabang may parehong laki,
kaya hindi ito ay talagang magkaroon ng kahulugan na gumamit ng isang mahaba sa 32-bit na machine.
>> Ngunit kung gumagamit ka ng Mac at 64-bit na machine, talagang isang mahabang laki 8,
kaya talagang depende sa architecture.
Para sa 32-bit na machine hindi ito gumawa ng kahulugan upang gumamit ng isang mahabang talagang.
At pagkatapos ng isang mahabang mahabang, sa kabilang banda, ay may 8 bytes,
kaya ito ay isang magandang kung nais mong magkaroon ng isang na integer.
At panghuli, mayroon kaming string, na kung saan ay talagang isang pansamantalang trabaho *,
na isang pointer sa isang pansamantalang trabaho.
Napakadaling mag-isip na ang laki ng string ay magiging tulad ng
ang bilang ng mga character na mayroon ka doon,
pero sa totoo magpasinda * mismo
ay ang laki ng isang pointer sa isang pansamantalang trabaho, na 4 bytes.
Ang laki ng isang pansamantalang trabaho * 4 bytes.
Hindi mahalaga kung mayroon kang isang maliit na salita o ng sulat o anumang.
Ito ay pagpunta sa 4 bytes.
Din namin natutunan ng kaunti tungkol sa Casting,
sa gayon ay maaari mong makita, kung mayroon kang, halimbawa, isang programa na nagsasabing
int x = 3 at pagkatapos ay printf ("% d", x / 2)
ka guys malaman kung ano ang pagpunta sa i-print sa screen?
>> May? >> [Mga mag-aaral] 2.
1. >> 1, oo.
Kapag ginawa mo 3/2 ito upang makakuha ng 1.5,
ngunit dahil kami ay gumagamit ng isang integer ito upang balewalain ang decimal bahagi,
at ikaw ay pagpunta sa may 1.
Kung hindi mo nais na mangyari kung ano ang maaari mong gawin, halimbawa,
ay ipinapahayag ng Float y = x.
Pagkatapos x na ginamit na 3 na ngayon na 3.000 sa y.
At pagkatapos ay maaari mong i-print ang y / 2.
Aktwal na, ang dapat kong magkaroon ng 2. doon.
Ito ay pagpunta sa gawin 3.00/2.00,
at ikaw ay pagpunta upang makakuha ng 1.5.
At mayroon kaming ito .2 f lamang humingi para sa 2 decimal unit sa decimal bahagi.
Kung mayroon kang 0.3 f ito pagpunta sa aktwal na magkaroon ng 1.500.
Kung ito ay 2 ng pagpunta sa 1.50.
Mayroon din kaming kasong ito dito.
Kung gagawin mo Float x = 3.14 at pagkatapos mo printf x
ka pagpunta upang makakuha ng 3.14.
At kung gagawin mo x = ang int ng x,
na nangangahulugan na ituturing ng x bilang isang int at i-print mo x ngayon
ka pagpunta sa 3.00.
Ba na magkaroon ng kahulugan?
Dahil unang ka pagpapagamot ng x bilang isang integer, kaya ka pagbalewala sa decimal bahagi,
at pagkatapos ka pag-print x.
At sa wakas, maaari mo ring gawin ito,
int x = 65, at pagkatapos ay ipinapahayag ng isang pansamantalang trabaho c = x,
at pagkatapos ay kung-print ang c aktwal ka upang makakuha ng
A, kaya talaga kung ano ang ginagawa mo dito
ay nagta-translate ang integer sa ng character,
lamang tulad ng ASCII Table ginagawa.
Uusapang din kami tungkol sa mga operator matematika.
Karamihan sa kanila ay medyo direkta, kaya +, -, *, /,
at din usapan natin ang tungkol sa mod, kung saan ay ang natitira sa isang sangay ng 2 numero.
Kung mayroon kang 10% 3, halimbawa,
ibig sabihin nito ay hatiin ang 10 sa pamamagitan ng 3, at kung ano ang natitira?
Ito ay pagpunta sa 1, kaya ito ay aktwal na lubhang kapaki-pakinabang para sa maraming mga programa.
Para Vigenère at Caesar ako ay medyo sigurado na lahat ng ka guys ginamit mod.
Tungkol sa operator sa matematika, maging maingat kapag pinagsasama-sama ng * at /.
>> Halimbawa, kung gagawin mo (3/2) * 2 kung ano ang iyong pagpunta upang makakuha ng?
[Mag-aaral] 2.
Oo, 2, dahil 3/2 pagpunta sa 1.5,
ngunit dahil ikaw ay gumagawa ng mga operasyon sa pagitan ng 2 integer
tunay ka lamang na isaalang-alang ang 1,
at pagkatapos ay ang 1 * 2 na 2, kaya maging napaka, napaka-ingat
kapag ginagawa ng aritmetika may integer dahil
maaari kang makakuha na 2 = 3, sa kasong iyon.
At ring maging maingat tungkol sa mangingibabaw.
Dapat na karaniwan mong gamitin mga panaklong upang matiyak na alam mo kung ano ang iyong ginagawa.
Ilang kapaki-pakinabang na mga shortcut, siyempre, isa i + + o i + = 1
o paggamit + =.
Na ang parehong bagay bilang paggawa i = i + 1.
Maaari mo ring gawin i - o i - = 1,
kung saan ay ang parehong bagay bilang i = i -1,
isang bagay ka guys ay gumagamit ng maraming sa para sa mga loop, hindi bababa sa.
Gayundin, *, kung gumamit ka ng * = at kung gagawin mo ito, halimbawa,
i * = 2 ay ang parehong bagay bilang sinasabi i = i * 2,
at ang parehong bagay para sa division.
Kung gagawin mo ang i / = 2 ang parehong bagay bilang i = i / 2.
>> Ngayon tungkol sa mga function.
Mong natutunan ang mga guys na function ay isang napakagandang diskarte upang i-save ang code
habang naka-programa, kaya kung gusto mong gawin ang parehong gawain
sa code sa muli at muli, marahil nais mong gamitin ang isang function
lang kaya hindi mo na kailangang kopyahin at i-paste ang code nang paulit-ulit.
Aktwal na, ang pangunahing ay isang function, at kapag ipakita ko sa iyo ang format ng isang function
ka pagpunta upang makita na na medyo halata.
Rin naming gamitin ang mga function mula sa ilang mga aklatan,
halimbawa, printf, GetIn, na mula sa library ng CS50,
at iba pang mga function tulad toupper.
Ang lahat ng mga function ay talagang ipinapatupad sa iba pang mga aklatan,
at kapag inilagay mo ang mga file na iyon ng ma-tether sa simula ng iyong programa
ka sinasabi Maaari ninyo bang bigyan ako ang code para sa mga function
kaya hindi ko ipatupad ang mga ito sa pamamagitan ng aking sarili?
At maaari mo ring isulat ang iyong sariling mga function, kaya kapag sinimulan mo ang programming
Napagtanto mo na aklatan ay hindi ang lahat ng mga function na kailangan mo.
Para sa huling pset, halimbawa, sinulat ni namin gumuhit, mang-uayabit, at paghahanap,
at ito ay napaka, napakahalaga na magsulat function
dahil ang mga ito ay kapaki-pakinabang, at ginagamit namin ang mga ito ang lahat ng oras sa programming,
at sine-save ng maraming ng code.
Ang format ng isang function ng isang ito.
Mayroon kaming ang uri ng return sa simula. Ano ang uri ng return?
Lang kapag ang iyong function ay upang bumalik.
Kung mayroon kang isang function, halimbawa, factorial,
na upang kalkulahin ang factorial ng isang integer,
marahil ito upang bumalik din ang isang integer.
Pagkatapos ay ang uri ng return ay pagpunta sa int.
Printf aktwal ay isang uri ng return void
dahil hindi ka bumabalik kahit ano.
Ka pag-print ng mga bagay sa screen
at sa pagtigil sa pag-andar pagkatapos.
Pagkatapos mayroon kang ang pangalan ng function na maaari mong piliin.
Dapat kang maging isang maliit na makatwirang, tulad ng hindi pumili ng isang pangalan tulad ng xyz
o tulad ng x2f.
Subukang gumawa ng isang pangalan na saysay.
>> Halimbawa, kung ito ang factorial, sabihin factorial.
Kung ito ay isang function na ay pagpunta sa gumuhit ng isang bagay, pangalanan ito gumuhit.
At pagkatapos ay mayroon namin ang mga parameter, na tinatawag din na argumento,
na tulad ng mga mapagkukunan na ang iyong function na nangangailangan ng
mula sa iyong code upang isagawa ang gawain.
Kung nais mong upang makalkula ang factorial ng isang numero
malamang na kailangan mong magkaroon ng isang numero upang kalkulahin ang factorial.
Isa ng argumento na kayo ay pagpunta sa may ang bilang mismo.
At pagkatapos ito ay pagpunta sa gawin ang isang bagay at ibalik ang halaga sa dulo
maliban kung ito ay isang walang bisa function na.
Natin makita ang isang halimbawa.
Kung gusto ko upang magsulat ng isang function na sums ang lahat ng mga numero sa isang array ng mga integer,
una sa lahat, ang uri ng return ay pagpunta sa int
dahil mayroon akong isang array ng mga integer.
At pagkatapos ay ako pagpunta sa function na pangalan tulad ng sumArray,
at pagkatapos ito ang array mismo, sa int nums,
at pagkatapos ay ang haba ng array upang malaman ko kung gaano karaming mga numero na mayroon akong sabihin sa ilang.
Pagkatapos Mayroon akong upang simulan ang isang variable na tinatawag kabuuan, halimbawa, sa 0,
at sa bawat oras na makita ko ang isang elemento sa array ang dapat kong idagdag ito sa kabuuan, kaya ginawa ko para sa loop.
Lamang tulad ng sinabi Lexi, gawin mo int i = 0, i <haba at i + +.
At para sa bawat elemento sa array na aking ginawa sum + = nums [i],
at pagkatapos ay ibinalik ko ang kabuuan, kaya ito ay napaka-simpleng, at sine-save ng maraming ng code
kung ginagamit mo ang function na ito ng maraming beses.
Pagkatapos namin kinuha ng pagtingin sa mga kundisyon.
Mayroon kaming kung, tao, at iba pa kung.
Natin makita kung ano ang pagkakaiba sa pagitan ng mga.
Tingnan sa mga 2 code. Ano ang pagkakaiba sa pagitan ng mga ito?
Ang unang-isa lamang ang code na nais mong sabihin sa
kung ang numero ng +, -, o 0.
Ang unang isa sabi kung> 0 pagkatapos ito ay positibong.
Kung = sa 0 pagkatapos ito ay 0, at kung ito <0 ito negatibong.
>> At ang iba pang isa ay kung, tao kung, iba pa.
Ang pagkakaiba sa pagitan ng dalawang na ito ay aktwal na pagpunta sa
suriin kung> 0, <0 o = 0 ng tatlong beses,
kaya kung mayroon kang ang bilang 2, halimbawa, ito ay pagpunta sa dumating dito at sabihin
kung (x> 0), at ito ay pagpunta sa sabihin ninyo ang oo, kaya-print ko positibong.
Ngunit kahit alam ko na ito> 0 at hindi ito magiging 0 o <0
Pa rin ako pagpunta sa gawin ito 0, ito <0,
kaya tunay ako pagpunta sa loob ng ifs na hindi ako mag-
dahil alam ko na na hindi ito masunod ang anumang ng mga kondisyon.
Maaari ko bang gamitin ang kung, tao kung, tao pahayag.
Ito talaga sabi kung x = 0-print ko ang positibong.
Kung ito ay hindi, ako pagpunta sa ring subukan ang.
Kung ito ay 2 hindi ako pagpunta sa gawin ito.
Talaga kung ako ay may x = 2 gusto mong sabihin
kung (x> 0), oo, kaya i-print ito.
Ngayon na alam ko na ito> 0 at na nasiyahan sa unang kung
Hindi ako pagpunta upang patakbuhin ang code na ito.
Code ay nagpapatakbo ng mas mabilis, aktwal na, 3 beses nang mas mabilis kung gagamitin mo ito.
Natutunan din kami tungkol sa at o.
Hindi ako pagpunta upang pumunta sa pamamagitan na ito dahil Lexi na uusapang tungkol sa mga ito.
Lang ang && at | | operator.
>> Ang tanging bagay na Sasabihin kong maging maingat kapag mayroon kang 3 kundisyon.
Gamitin ang mga panaklong dahil napaka-nakalilito kapag mayroon kang isang kundisyon
at isa pa o isa pa.
Gamitin ang mga panaklong lamang upang siguraduhin na ang iyong mga kondisyon kabuluhan
dahil sa kasong iyon, halimbawa, maaari mong isipin na ang
maaaring ito ay ang unang kondisyon at isa o ang iba
o ang 2 mga kondisyon na pinagsama sa isang at
o sa ikatlong isa, kaya maging maingat lamang.
At sa wakas, usapan natin ang tungkol sa mga switch.
Lumipat ay lubos na kapaki-pakinabang kapag mayroon kang isang variable.
Sabihin natin na mayroon kang isang variable tulad n
na maaaring maging 0, 1, o 2, at para sa bawat isa sa mga kasong iyon
ka upang magsagawa ng gawain.
Maaari mong sabihin ilipat ang variable, at ito ay nagpapahiwatig na ang
ang halaga pagkatapos ay tulad ng VALUE1 ako pagpunta sa gawin ito,
at pagkatapos ko masira, na nangangahulugan na hindi ako pagpunta sa tumingin sa anumang ng iba pang mga kaso
sapagkat hindi namin na nasiyahan kaso na
at pagkatapos VALUE2 at iba pa, at ako din ay maaaring magkaroon ng isang default na lumipat.
Iyon ay nangangahulugang kung hindi ito masunod ang anumang ng mga kaso na ako ay may
na ako pagpunta sa gawin ang iba pa, ngunit na opsyonal.
Na ang lahat para sa akin. Ngayon sabihin mayroon Tommy.
Lahat ng karapatan, ito ay pagpunta sa Linggo 3-ish.
Ito ang ilang ng paksa namin na sumasaklaw, crypto, saklaw, array, at iba pa.
Lamang ng isang mabilis na salita sa crypto. Hindi namin ay pagpunta sa martilyo ito sa bahay.
>> Ginawa namin ito sa pset 2, ngunit para sa pagsusulit tiyakin na alam mo ang pagkakaiba
sa pagitan ng Caesar cipher at sa Vigenère cipher,
kung paano parehong ng mga trabaho ciphers at kung ano ito ay tulad ng upang i-encrypt
at i-decrypt teksto gamit ang mga 2 ciphers.
Tandaan, ang Caesar cipher lamang umiikot sa bawat character ng parehong halaga,
siguraduhin mo mod sa pamamagitan ng bilang ng mga titik sa alpabeto.
At ang Vigenère cipher, sa kabilang banda, umiikot sa bawat karakter
ng isang iba't ibang mga halaga, kaya sa halip na sinasabi
bawat pinihit ng character sa pamamagitan ng 3 Vigenère ikutin bawat karakter
ng isang iba't ibang mga halaga depende sa ilang mga keyword
kung saan ang bawat titik sa keyword kumakatawan sa ilang ibang halaga
ikutin ang malinaw na teksto sa pamamagitan ng.
Natin ang unang usapan variable na saklaw.
May 2 iba't ibang mga uri ng variable.
Mayroon kaming mga lokal na variable, at ang mga ito ay pagpunta sa ay tinukoy
sa labas ng pangunahing o sa labas ng anumang function na o bloke,
at ang mga ito ay maa-access kahit saan sa iyong programa.
Kung mayroon kang isang function at sa na function na ay isang habang loop
ang malaking pandaigdigang variable ay naa-access sa lahat ng dako.
Ang isang lokal na variable, sa kabilang banda, ay scoped sa lugar na kung saan ito ay tinukoy.
>> Kung mayroon kang isang function dito, halimbawa, mayroon kaming g ang pagpapaganang ito,
at sa loob ng g may isang variable na dito tinatawag y,
at na nangangahulugan na ito ay isang lokal na variable.
Kahit na ang variable na ito ay tinatawag na y
at ang variable na ito ay tinatawag na y mga 2-andar
walang ideya kung ano ang bawat isa lokal na variable.
Sa kabilang banda, hanggang dito sinasabi namin int x = 5,
at ito ay sa labas ng saklaw ng anumang function na.
Ito ay sa labas ng saklaw ng pangunahing, kaya ito ay isang pandaigdigang variable.
Nangangahulugan iyon sa loob ng mga 2-andar kapag sinasabi ko x - o x + +
Ako-access ang parehong x kung saan ito y at ito y iba't ibang mga variable.
Na ang pagkakaiba sa pagitan ng isang global variable at isang lokal na variable.
Bilang malayo bilang disenyo ay nababahala, minsan ito ay maaring isang mas mahusay na ideya
upang panatilihin ang mga variable lokal tuwing maaari mo posibleng
dahil pagkakaroon ng grupo ng mga global variable ay maaaring makakuha ng talagang nakakalito.
Kung mayroon kang isang bungkos ng mga function lahat ng mga pagbabago ng parehong bagay
baka nakalimutan mo kung ano ang kung ang function na ito aksidenteng binabago ito global,
at iba pang mga function na ito ay hindi alam tungkol dito,
at ito ay makakuha ng medyo nakakalito makakakuha ka ng higit pang mga code.
Pagpapanatiling variable lokal tuwing maaari mo posibleng
ay lamang magandang disenyo.
Array, Tandaan, simpleng listahan ng mga elemento ng parehong uri.
Loob ng CI ay hindi maaaring magkaroon ng isang listahan tulad ng 1, 2.0, kumusta.
Lamang namin ay hindi maaaring gawin iyon.
>> Kapag idedeklara namin ang isang array sa C ang lahat ng mga elemento ng parehong uri.
Narito Mayroon akong isang array ng 3 integer.
Narito ko ang haba ng array, ngunit kung ako deklarasyon ito sa ang syntax na ito
kung saan ko tukuyin kung ano ang lahat ng mga elemento ay hindi ko technically kailangan ang 3.
Tagatala na smart sapat upang malaman kung gaano kalaki ang array ay dapat na.
Ngayon kapag gusto ko upang makakuha o itakda ang halaga ng isang array
ito ang syntax upang gawin iyon.
Ito ay aktwal na baguhin ang pangalawang elemento ng array dahil, tandaan,
pagnunumero nagsisimula sa 0, hindi sa 1.
Kung gusto kong basahin na halaga ang maaari kong sabihin na ang isang bagay tulad ng int x = array [1].
O kung gusto kong mag-set na halaga, tulad ng ako ginagawa dito,
Maaari kong sabihin array [1] = 4.
Oras na iyon sa pag-access ng mga elemento sa pamamagitan ng kanilang index
o kanilang mga posisyon o kung saan ang mga ito sa array,
at ang listahan na nagsisimula sa 0.
Mayroon din kaming ang mga array ng array,
at ito ay tinatawag na isang multi-dimensional array.
Kapag kami ay may isang multi-dimensional array
na nangangahulugan na maaari naming magkaroon ng isang bagay tulad ng mga hanay at haligi,
at ito ay isang paraan lamang ng pagtingin sa ito o pag-iisip tungkol dito.
Kapag mayroon akong isang multi-dimensional array na ay nangangahulugan na ang ako pagpunta upang simulan ang nangangailangan
higit sa 1 index dahil kung mayroon akong isang grid
lang na nagsasabi kung ano ang hilera ikaw ay nasa ay hindi nagbibigay sa amin ng isang numero.
Na talagang lamang upang bigyan kami ng isang listahan ng mga numero.
Ipagpalagay natin na mayroon akong dito ang array na ito.
Mayroon akong isang array na tinatawag na grid, at ako sinasabi ito ng 2 mga hilera at 3 haligi,
at kaya ito ay isang paraan ng pagtingin sa ito.
Kapag sinabi ko na gusto kong makuha ang elemento sa [1] [2]
na nangangahulugan na dahil ito ay hilera muna at pagkatapos haligi
Ako pagpunta sa tumalon sa hilera ng 1 dahil sinabi ko 1.
>> Pagkatapos ako pagpunta sa darating sa paglipas dito sa haligi 2, at ako pagpunta upang makuha ang halaga 6.
Kabuluhan?
Multi-dimensional array, Tandaan, technically lamang ng isang hanay ng mga array.
Maaari kaming magkaroon ng mga array ng mga array ng mga array.
Namin ang pagpunta, ngunit talagang isang paraan upang isipin ang tungkol
kung paano ito ay inilatag at kung anong nangyayari sa ay upang mailarawan ito
sa isang grid tulad nito.
Kapag pumasa namin array sa function, sila ay pagpunta sa kumilos
Medyo naiiba kaysa sa kapag pumasa kami ng mga regular na variable sa function
tulad ng pagpasa sa isang int o isang Float.
Kapag pumasa kami sa isang int o pansamantalang trabaho o anumang ng iba pang mga data na uri
lang namin kinuha ng isang pagtingin sa kung binabago ang function na
ang halaga ng variable na ang pagbabagong iyon ay hindi upang palaganapin up
sa pagtawag sa function na.
Sa pamamagitan ng isang array, sa kabilang banda, na ang mangyayari.
Kung pumasa ako sa isang array sa ilang function na at ang function na nagbabago ang ilan sa mga elemento,
kapag dumating ako pabalik sa function na tinatawag na ito
aking array ay pagpunta sa iba, at ang bokabularyo para sa
ay array ay naipasa sa pamamagitan ng reference, dahil kakailanganin namin makita mamaya.
Ito ay may kaugnayan sa kung paano payo ng trabaho, kung saan ang mga pangunahing uri ng data,
sa kabilang banda, ay naipasa sa pamamagitan ng halaga.
>> Maaari naming isipin na bilang ng paggawa ng isang kopya ng ilang mga variable at pagkatapos pagpasa sa kopya.
Hindi mahalaga kung ano ang ginagawa namin sa na variable.
Ang pagtawag sa function na ay hindi magkaroon ng kamalayan na ito ay binago.
Array ay lamang ng kaunti ibang sa na-alang.
Halimbawa, bilang lamang namin nakita, pangunahing ay lamang ng isang function
na maaaring tumagal ng sa 2 argumento.
Ang unang argumento sa pangunahing function na ay argc, o ang dami ng mga argument,
at ang pangalawang argumento ay tinatawag na argv,
at ang mga ay ang aktwal na halaga ng mga argumento.
Ipagpalagay natin na mayroon akong isang programa na tinatawag na this.c,
at sinasabi ko ito, at ako pagpunta upang patakbuhin ito sa command line.
Ngayon upang pumasa sa ilang mga argumento sa aking programa na tinatawag na ito,
Maaari kong sabihin ang isang bagay tulad ng. / Ito ay cs 50.
Ito ay kung ano ang namin isipin ang David na gawin ang araw-araw sa terminal.
Ngunit ngayon ang pangunahing function na sa loob ng programang iyon
may mga halagang ito, kaya argc ay 4.
Maaaring maging isang maliit na nakakalito dahil talagang lamang kami ng pagpasa ay cs 50.
Iyon lamang 3.
Ngunit tandaan na sa unang elemento ng argv o ang unang argumento
ang pangalan ng function na mismo.
Sa gayon ay nangangahulugan na mayroon kaming 4 na bagay dito,
at ang unang elemento ay pagpunta sa. / ito.
At ito ay kinakatawan bilang isang string.
Pagkatapos ang mga natitirang mga elemento ay kung ano ang aming nai-type sa pagkatapos ng pangalan ng programa.
Kaya tulad ng bukod, bilang namin marahil nakita sa pset 2,
tandaan na ang string 50 ≠ ang integer 50.
Kaya hindi namin maaaring sabihin na ang isang bagay tulad ng, 'int x = 3 argv.'
>> Na lang hindi kabuluhan, dahil ito ay isang string, at ito ay isang integer.
Kaya kung nais mong i-convert sa pagitan ng 2, Tandaan, kami ay pagpunta sa
ito magic function na tinatawag na atoi.
Na tumatagal ng isang string at nagbalik ang integer na kinakatawan sa loob ng na string.
Kaya na ang isang madaling pagkakamali upang gumawa sa pagsusulit,
lamang ang pag-iisip na ito ay awtomatikong ang tamang uri ng.
Ngunit lamang malaman na ang mga ito ay palaging magiging string
kahit na kung string ay naglalaman lamang ng isang integer o isang character o isang Float.
Kaya ngayon sabihin makipag-usap tungkol sa pagpapatakbo ng oras.
Kapag mayroon kaming ang lahat ng mga algorithm na gawin sa lahat ng mga nakatutuwang mga bagay,
ito ay magiging talagang kapaki-pakinabang upang tanungin ang tanong, "Gaano katagal ang kanilang tumagal?"
Kumakatawan namin na may isang bagay na tinatawag na asymptotic pagtatanda.
Kaya ito ay nangangahulugan na - mahusay, sabihin nating naming bigyan ang aming algorithm
ilang talaga, talagang, talagang malaking input.
Gusto naming hilingin sa tanong, "Gaano katagal ito pagpunta sa tumagal?
Gaano karaming mga hakbang na ito ay tumagal ng aming algorithm upang tumakbo
bilang isang katangian ng laki ng input? "
Kaya ang unang paraan maaari naming ilarawan ang magpatakbo ng oras ay may malaking O.
At ito ay aming pinakamasama-case tumatakbo oras.
Kaya kung nais namin upang pag-uri-uriin ang isang array, at naming bigyan ang aming mga algorithm sa isang array
na sa pababang ayos kapag ito ay dapat sa pataas-sunod,
na ang pinakamasama kaso.
Ito ang aming itaas na sumunod sa maximum na haba ng oras na aming algorithm ay magdadala.
Sa kabilang banda, ito Ω upang ilarawan ang pinakamahusay na-case tumatakbo oras.
Kaya kung bigyan kami ng isang array na pinagsunod-sunod sa isang pag-uuri algorithm,
kung gaano katagal ang aabutin upang pag-uri-uriin ito?
At ito, pagkatapos, ay naglalarawan ng isang mas mababang bound sa tumatakbo oras.
Kaya narito ang ilang mga salita na naglalarawan ng ilang mga karaniwang panahon ng pagtakbo.
Mga ito sa pataas na pagkakasunod-sunod.
Ang pinakamabilis na tumatakbo ang oras na mayroon kami ay tinatawag na pare-pareho.
>> Nangangahulugan iyon na hindi mahalaga kung gaano karaming mga elemento bigyan namin ang aming mga algorithm,
kahit gaano kalaki ang aming array, pag-uuri-uri ito
o paggawa ng kahit anong ginagawa namin sa array ay palaging gawin ang parehong halaga ng oras.
Upang maaari naming kumatawan na lang na may 1, na kung saan ay patuloy na.
Tumingin din kami sa logarithmic run oras.
Kaya ang isang bagay tulad ng binary paghahanap ay logarithmic,
kung saan namin kunin ang mga problema sa kalahati sa bawat oras
at pagkatapos ay bagay lamang makakuha ng mas mataas na mula doon.
At kung sakaling sumusulat ka ng O ng anumang factorial algorithm,
marahil ay hindi dapat isaalang-alang ito bilang iyong araw ng trabaho.
Kapag ihambing namin ang mga panahon ng pagtakbo mahalaga upang tandaan ang mga bagay na ito.
Kaya kung mayroon akong isang algorithm na ang O (n), at iba pang tao
ay isang algorithm ng O (2n) mga ito ay aktwal asymptotically katumbas.
Kaya kung namin isipin n isang malaking bilang tulad eleventy bilyong:
kaya kapag kami ay naghahambing eleventy bilyon sa isang bagay tulad ng eleventy bilyong + 3,
biglang +3 na hindi talaga gumawa ng isang malaking pagkakaiba ito.
Iyon ay kung bakit kami ay pagpunta upang simulan ang isinasaalang-alang ang mga bagay na ito upang maging katumbas.
Kaya sa mga bagay tulad ng mga constants dito, 2 x na ito, o pagdaragdag ng isang 3,
ito lamang ang constants, at ito ay pagpunta sa drop up.
Kaya na ang dahilan kung bakit ang lahat ng 3 ng mga oras na ito na pinapatakbo ang parehong bilang na nagsasabi sila O (n).
Katulad nito, kung kami ay may 2 iba pang mga beses sa run, sabihin nating O (n ³ + 2n ²), maaari naming magdagdag
+ N, + 7, at pagkatapos kami ay may isa pang run oras na lang O (n ³).
muli, ito ay ang parehong bagay dahil ang mga - ito ay hindi ang parehong.
Ito ay ang parehong mga bagay, paumanhin. Kaya ito ay ang parehong dahil
ito n ³ ay upang dominahin ito 2n ².
>> Ano ang hindi ang parehong bagay ay kung tumakbo kami ng mga oras tulad ng O (n ³) at O ​​(n ²)
dahil ito n ³ ay mas malaki kaysa ito n ².
Kaya kung kami ay may exponents, biglang ito ay nagsisimula sa mahalaga,
ngunit kapag lamang namin ang pagharap sa mga kadahilanan habang kami dito,
hindi ito mahalaga dahil lamang sila ay pagpunta sa drop out.
Natin tumagal ng isang pagtingin sa nasaksihan namin sa ngayon ang ilan sa mga algorithm
at makipag-usap tungkol sa kanilang mga oras ng run.
Ang unang paraan ng naghahanap para sa isang bilang sa isang listahan, na nakita natin, linear paghahanap.
At ang pagpapatupad ng linear paghahanap sobrang direkta.
Lang namin ay may isang listahan, at kami ay pagpunta upang tumingin sa bawat solong elemento sa listahan
hanggang sa nakita namin ang bilang namin na iyong hinahanap.
Sa gayon ay nangangahulugan na sa pinakamasama kaso, ito O (n).
At ang pinakamasama kaso dito kung ang elemento ay
ang huling elemento, pagkatapos gamit ang linear paghahanap namin upang tumingin sa bawat solong elemento
hanggang namin makuha ang huling isa upang malaman na ito ay aktwal na sa listahan.
Hindi lamang namin magbigay ng kalahating at sabihin, "Ito ay malamang na hindi doon."
Sa linear paghahanap namin upang tingnan ang buong bagay.
Ang pinakamahusay na tumatakbo sa oras ng kaso, sa kabilang banda, ay pare-pareho
dahil sa ang pinakamahusay na kaso ang elemento kaming naghahanap ng mga lamang ang unang isa sa listahan.
Kaya pagpunta sa amin eksakto 1 hakbang, hindi mahalaga kung gaano kalaki ang listahan
kung kaming naghahanap ng para sa unang elemento sa bawat oras.
>> Kaya kapag hinanap mo, tandaan, hindi ito nangangailangan pinagsunod-sunod na ang aming listahan.
Dahil lamang namin ay pagpunta upang tumingin sa bawat solong elemento, at hindi ito ay talagang mahalaga
anong pagkakasunud-sunod ang mga elementong iyon.
Mas intelligent na algorithm sa paghahanap ng isang bagay tulad ng binary paghahanap.
Tandaan, ang pagpapatupad ng binary paghahanap ay kapag ikaw ay pagpunta sa
panatilihin ang hinahanap sa gitna ng listahan.
At dahil naghahanap kami sa gitna, kinakailangan namin na listahan ay pinagsunod-sunod
o kung hindi namin alam kung saan ay ang gitna, at kailangan namin upang tumingin sa paglipas ng
ang buong listahan upang hanapin ito, at pagkatapos ay sa puntong iyon kami ay aksaya ng panahon.
Kaya kung kami ay may isang pinagsunod-sunod na listahan at nakita namin sa gitna, kami ay upang ihambing sa gitna
sa elemento na namin na iyong hinahanap.
Kung ito ay masyadong mataas, maaari naming kalimutan ang kanang kalahati
dahil alam namin na kung ang aming elemento ay masyadong mataas
at lahat sa kanan ng elemento na ito ay mas mataas,
hindi namin kailangan upang tumingin doon ngayon.
Saan sa kabilang banda, kung ang aming elemento ay masyadong mababa,
Alam namin din ang lahat sa kaliwa ng na elemento ay masyadong mababa,
kaya hindi ito ay talagang magkaroon ng kahulugan upang tumingin doon, alinman.
Sa ganitong paraan, sa bawat hakbang at tuwing hahanapin namin sa Gitnang ng listahan,
kami ay upang kunin ang aming problema sa kalahati dahil biglang alam namin
buong bungkos ng mga numero na hindi kaming naghahanap ng mga.
>> Pseudocode ito ang magiging hitsura ng isang bagay tulad nito,
at dahil kami ay paggupit ang listahan sa kalahati bawat solong oras,
aming pinakamasama-case run oras jumps mula sa linear sa logarithmic.
Kaya biglang mayroon kaming-log-in hakbang upang mahanap ang isang elemento sa isang listahan.
Ang pinakamahusay na tumatakbo sa oras ng kaso, bagaman, pa rin ang pare-pareho
dahil ngayon, sabihin lamang sabihin na ang elemento kaming naghahanap ng mga
laging ang eksaktong gitna ng orihinal na listahan.
Upang maaari naming palaguin ang aming listahan bilang malaking bilang gusto namin, ngunit kung ang elemento kaming naghahanap ng mga sa gitna,
pagkatapos lamang ito pagpunta sa tumagal kami ng 1 hakbang.
Kaya na ang dahilan kung bakit hindi namin O (log n) at Ω (1) o pare-pareho.
Natin ang aktwal na patakbuhin ang binary paghahanap sa listahang ito.
Kaya sabihin nating na kaming naghahanap ng mga elemento 164.
Ang unang bagay na kami ay pagpunta sa gawin ay hanapin ang Gitnang ng listahang ito.
Lang kaya ang mangyayari na ang Gitnang ang pagpunta sa mahulog sa pagitan ng mga 2 numero,
kaya sabihin lang mang sabihin, sa tuwing Gitnang Nabibilang ang pagitan ng 2 numero,
sabihin paglilikom lang.
Kailangan lang namin upang matiyak na gawin namin ito sa bawat hakbang ng paraan.
Kaya kami ay upang tipunin, at kami ay sabihin na 161 sa gitna ng aming listahan.
Kaya 161 <164, at ang bawat elemento sa kaliwa ng 161
din <164, kaya alam namin na hindi ito upang makatulong sa amin sa lahat
upang simulan ang naghahanap sa paglipas dito dahil ang elemento namin ang iyong hinahanap ay hindi maaaring may.
Kaya kung ano ang maaari naming gawin ay maaari naming lamang kalimutan tungkol na buong kaliwang kalahati ng listahan,
at ngayon ay isinasaalang-alang lamang mula sa kanan ng 161 pasulong.
>> Kaya muli, ito ay sa Gitnang; sabihin paglilikom lang.
Ngayon 175 ay masyadong malaki.
Kaya alam naming hindi ito upang matulungan kaming naghahanap dito o dito,
upang maaari naming lamang magtapon na ang layo, at kalaunan namin pindutin ang 164.
Anumang mga katanungan sa binary paghahanap?
Sabihin lumipat sa mula sa paghahanap sa pamamagitan ng na-pinagsunod-sunod na listahan
sa aktwal na pagkuha ng isang listahan ng mga numero sa anumang pagkakasunud-sunod
at paggawa na listahan sa pataas na pagkakasunod-sunod.
Ang unang algorithm na itinuturing namin ang tinatawag na bubble-uuri.
At ito ay simple ng algorithm na namin nakita.
Bubble-uuri ay sinasabi na kapag ang anumang 2 elemento sa loob ng listahan ng lugar,
ibig sabihin may isang mas mataas na numero sa kaliwa ng isang mas mababang numero,
pagkatapos kami ay pagpunta sa swap sa kanila, dahil nangangahulugan iyon na listahan ay
"Higit pinagsunod-sunod" kaysa ito ay bago.
At kami ay muling ipagpatuloy ang prosesong ito at muli at muli
hanggang sa kalaunan ang mga elemento ng uri ng bubble sa kanilang wastong lokasyon at kami ay may pinagsunod-sunod listahan.
>> Ang run oras ng ito ay pagpunta sa O (n ²). Bakit?
Well, dahil sa ang pinakamasama kaso, kami ay pagpunta sa tumagal ng bawat elemento, at
kami ay pagpunta sa paghahambing nito sa bawat iba pang mga elemento sa listahan.
Ngunit sa ang pinakamahusay na kaso, mayroon kaming isang na pinagsunod-sunod sa listahan, bubble-uuri ng
lamang upang pumunta sa pamamagitan ng sabay-sabay, sabihin ang "Nope hindi ako gumawa ng anumang mga swaps, kaya tapos ako na."
Kaya mayroon kami ng pinakamahusay na-case na oras ng paggana ng Ω (n).
Natin patakbuhin ang bubble uri sa isang listahan.
O unang, sabihin lamang tumingin sa ilang pseudocode talagang mabilis.
Gusto naming sabihin gusto naming subaybayan ang mga, sa bawat pag-ulit ng loop,
subaybayan man o hindi ay nagbago namin ang anumang elemento.
Kaya ang mga dahilan para sa na, kami ay pagpunta upang itigil kapag hindi namin swapped anumang mga elemento.
Kaya sa simula ng aming loop hindi namin swapped anumang, kaya makikita namin sabihin na maling.
Ngayon, kami ay pagpunta sa pumunta sa pamamagitan ng listahan at ihambing ang elemento i elemento ng i + 1
at kung ito ay ang kaso na may mas malaking numero sa kaliwa ng isang mas maliit na bilang,
pagkatapos lamang namin ay pagpunta sa swap sa kanila.
>> At pagkatapos kami ay tandaan na namin swapped isang elemento.
Iyon ay nangangahulugan na kailangan namin upang pumunta sa pamamagitan ng listahan ng hindi bababa sa 1 pang oras
dahil ang kundisyon kung saan kami huminto kapag ang buong listahan pinagsunod-sunod,
ibig sabihin hindi kami gumawa ng anumang mga swaps.
Kaya na ang dahilan kung bakit ang aming kundisyon pababa dito ay 'habang ang ilang mga elemento ay swapped.'
Kaya ngayon sabihin lang tumingin sa ito tumatakbo sa isang listahan.
Mayroon akong listahan 5,0,1,6,4.
Bubble-uuri upang simulan ang lahat ng mga paraan sa kaliwa, at upang ihambing
ang i elemento, kaya 0 sa i + 1, na elemento 1.
Ito ay pagpunta sa sabihin, na rin 5> 0, ngunit ngayon 5 sa kaliwa,
kaya kailangan kong i-swap ang 5 at ang 0.
Kapag swap ko ang mga ito, biglang ako makakakuha ng ibang listahan na ito.
Ngayon 5> 1, kaya kami ay pagpunta sa swap sa kanila.
5 ay hindi> 6, kaya hindi namin kailangang gawin dito.
Ngunit 6> 4, kaya kailangan namin upang magpalitan.
Muli, kailangan namin upang tumakbo sa pamamagitan ng buong listahan sa kalaunan matuklasan
na ang mga ito ay sira; swap namin sa kanila,
at sa puntong ito kailangan namin upang tumakbo sa pamamagitan ng listahan 1 mas maraming oras
upang tiyakin na ang lahat ay sa order, at sa puntong ito-uri-uriin ng bubble tapos.
Ang isang iba't ibang mga algorithm para sa pagkuha ng ilang mga elemento at pag-uuri-uri ang mga ito ay pagpili-uuri.
Ang ideya sa likod ng pagpili-uuri ay na kami ay pagpunta upang bumuo ng pinagsunod-sunod bahagi ng listahan
1 elemento sa isang pagkakataon.
>> At ang paraan na kami ay pagpunta upang gawin iyon ay sa pamamagitan ng pagbuo ng hanggang sa kaliwa segment ng listahan.
At isa lamang, ang bawat - sa bawat hakbang, kami ay ang pinakamaliit na elemento na namin ang natitira
na hindi pa na pinagsunod-sunod, at kami ay pagpunta upang ilipat ito sa na pinagsunod-sunod na segment.
Nangangahulugan iyon na kailangan namin upang patuloy na hanapin ang minimum unsorted elemento
at pagkatapos ay dadalhin na minimum na elemento at magpalitan ang mga ito sa anumang
kaliwa-pinaka-elemento na hindi nakaayos.
Ang patakbuhin ang oras ng ito ay pagpunta sa O (n ²) dahil sa ang pinakamasama kaso
kailangan namin upang ihambing ang bawat solong elemento sa bawat iba pang mga elemento.
Dahil kami ay nagsasabi na kung sinimulan namin sa kaliwang kalahati ng listahan, kailangan namin
upang pumunta sa pamamagitan ng buong karapatan segment upang mahanap ang pinakamaliit na elemento.
At pagkatapos, muli, kailangan namin upang pumunta sa buong kanan segment at
panatilihin ang pagpunta sa paglipas na muli nang paulit-ulit at mahigit.
Na n ². Kami ay pagpunta sa kailangan para sa loob ng loop ng isa pa para sa loop
na nagmumungkahi n ².
Ang pinakamahusay na pag-iisip ng kaso, sabihin nating namin bigyan ito ng isang na pinagsunod-sunod sa listahan;
namin ang aktwal na hindi gawin anumang mas mahusay kaysa sa n ².
Dahil ang pagpili-uuri ay walang paraan ng alam na
ang minimum na elemento ay mangyari ko sa pagtingin sa.
Pa rin ito ay kinakailangan upang matiyak na ito ay talagang ang minimum.
>> At ang tanging paraan upang matiyak na ang minimum, gamit ang algorithm,
upang tumingin muli sa bawat solong elemento.
Kaya talaga, kung ikaw ay bigyan ito - kung magbibigay sa iyo ng pagpili-uuri ng na pinagsunod-sunod sa listahan,
hindi ito gawin ang anumang mas mahusay kaysa sa na nagbibigay sa ito sa isang listahan na hindi pa nakaayos.
Sa pamamagitan ng paraan, kung ito ang mangyayari ang kaso na ang isang bagay ay O (isang bagay)
at ang wakas ng isang bagay, maaari naming lamang sabihin mas succinctly na θ ng isang bagay.
Kaya kung nakita mo na makabuo kahit saan, na sa kung ano ay nangangahulugan lamang na.
>> Kung may isang bagay theta ng n ², ito ay parehong malaki O (n ²) at Ω (n ²).
Kaya ang pinakamahusay na kaso at ang pinakamasama kaso, hindi ito gumawa ng isang pagkakaiba,
algorithm ay pagpunta sa gawin ang parehong bagay sa bawat oras.
Kaya ito ay kung ano ang pseudocode para sa pagpili-uuri ay maaaring magmukhang.
Talaga namin ay upang sabihin na gusto ko upang umulit sa listahan
mula kaliwa sa kanan, at sa bawat pag-ulit ng loop, ako pagpunta sa ilipat
ang minimum na elemento sa ito pinagsunod-sunod na bahagi ng listahan.
At sa sandaling ko bang ilipat ang isang bagay doon, hindi ko kailangan upang tumingin muli sa na elemento.
Dahil sa lalong madaling swap ko ang isang elemento sa sa kaliwa segment ng listahan, pinagsunod-sunod
dahil ginagawa namin ang lahat sa pataas na pagkakasunod-sunod sa pamamagitan ng paggamit ng mga minimum.
Kaya't sinabi namin, okay, hindi namin sa posisyon i, at kailangan namin upang tumingin sa lahat ng mga elemento
sa kanan ng i upang hanapin ang minimum.
Sa gayon ay nangangahulugan na gusto naming tingnan mula sa i + 1 sa dulo ng listahan.
At ngayon, kung ang elemento na kasalukuyan kaming naghahanap sa ay mas mababa kaysa sa aming minimum na sa ngayon,
kung saan, Tandaan, kami ay simulan ang minimum off lamang na
anumang elemento na hindi namin kasalukuyang sa, kukunin ko na ipinapalagay na ang minimum.
Kung nakita ko ang isang elemento na mas maliit kaysa sa, pagkatapos ay ako pagpunta sa sabihin, okay,
maayos, Nakakita ako ng isang bagong minimum.
Ako pagpunta sa tandaan kung saan ay ang minimum na.
>> Kaya ngayon, kapag nawala ko na sa pamamagitan ng na karapatan unsorted segment,
Maaari kong sabihin ako pagpunta sa swap ang minimum na elemento sa mga elemento na sa posisyon i.
Na upang bumuo ng aking listahan, aking pinagsunod-sunod na bahagi ng listahan mula kaliwa hanggang kanang,
at hindi namin kailangan upang tumingin muli sa isang elemento sa sandaling ito ay sa na bahagi.
Kapag kami swapped ito.
Kaya natin patakbuhin ang pagpili ng uri sa listahang ito.
Ang bughaw na elemento dito ay pagpunta sa i, at ang pulang elemento ay ang minimum na elemento.
Kaya i nagsisimula ang lahat ng mga paraan sa kaliwa ng listahan, kaya sa 5.
Ngayon kailangan namin upang mahanap ang minimum unsorted elemento.
Kaya sinasabi namin 0 <5, kaya 0 ang aking bagong minimum.
>> Ngunit hindi ko maaaring tumigil doon, dahil kahit na maaari naming nakikilala na 0 ang pinakamaliit,
kailangan namin upang tumakbo sa pamamagitan ng bawat iba pang mga elemento ng listahan upang matiyak na.
Kaya 1 ay mas malaki, 6 ay mas malaki, 4 ay mas malaki.
Iyon ay nangangahulugan na pagkatapos ng pagtingin sa lahat ng mga sangkap na ito, Napag-alaman ko 0 ang pinakamaliit.
Kaya ako pagpunta sa swap ang 5 at ang 0.
Kapag swap ko na, ako pagpunta upang makakuha ng isang bagong listahan, at alam ko na hindi ko kailangan upang tumingin muli sa na 0
dahil sabay-sabay ko na swapped ito, ko na pinagsunod-sunod ito at tapos na kami.
Ngayon lang ito kaya mangyayari na ang mga asul na elemento ay muli ang 5,
at kailangan namin upang tumingin sa 1, ang 6 at ang 4 upang matukoy na 1
ay ang pinakamaliit na elemento ng minimum, kaya namin swap sa 1 at ang 5.
Muli, kailangan namin upang tumingin sa - ihambing ang 5 sa 6 at ang 4,
at kami ay pagpunta sa swap sa 4 at ang 5, at sa wakas, ihambing
mga 2 numero at swap sa kanila hanggang sa makuha namin ang aming pinagsunod-sunod listahan.
Anumang mga katanungan sa pagpili-uuri?
Okay. Natin lumipat sa huling paksa dito, at na recursion.
>> Recursion, Tandaan, ito talagang bagay meta kung saan ang isang function
paulit-ulit na mga tawag mismo.
Kaya sa isang punto, habang ang aming fuction ay paulit-ulit na pagtawag mismo,
kailangang ilang mga punto kung saan itigil namin ang pagtawag sa ating sarili.
Dahil kung hindi namin gawin iyon, pagkatapos lamang kami ay pagpunta sa patuloy na gawin ito magpakailanman,
at ang aming programa ay hindi pagpunta sa wakasan.
Tinatawag namin itong kundisyon base kaso.
At ang pangunahing kaso sabi, kaysa sa pagtawag muli ang isang function,
Lamang ako pagpunta sa ibalik ang ilang mga halaga.
Kaya kapag ibinalik namin na ang halaga, itinigil namin ang pagtawag sa ating sarili,
at ang lahat ng mga tawag na ginawa naming sa ngayon ay maaari ring ibalik.
Ang tapat ng kaso ng base ang recursive kaso.
At ito ay kapag gusto naming gumawa ng isa pang tawag sa function na hindi namin kasalukuyan.
At hindi na namin marahil, bagaman hindi laging, nais na gumamit ng iba't ibang mga argumento.
>> Kaya kung kami ay may isang function na tinatawag na f, at lamang na tinatawag na f 1 argumento,
at panatilihin namin lamang pagtawag sa f (1), f (1), f (1), at ito lamang ang kaya mangyayari na
argument 1 Nabibilang ang sa recursive kaso, pa namin ay hindi kailanman upang ihinto.
Kahit na mayroon kami ng base kaso, kailangan namin upang matiyak na kalaunan namin ay pagpunta sa hit na base kaso.
Hindi namin lamang panatilihin ang naglalagi sa kasong ito recursive.
Sa pangkalahatan, kapag tinatawag naming ating sarili, marahil kami ay pagpunta sa ng ibang argumento sa bawat oras.
Narito ang isang talagang simpleng recursive function na.
Kaya ito ay kino-compute ang factorial ng isang numero.
Up itaas dito namin ang aming base kaso.
Sa kaso na n ≤ 1, hindi namin ay pagpunta sa tumawag muli ang factorial.
Kami ay pagpunta sa itigil; lang kami upang ibalik ang ilang mga halaga.
Kung ito ay hindi totoo, at pagkatapos namin ay pagpunta upang maabot ang aming recursive kaso.
Mapansin dito na hindi namin lamang pagtawag factorial (n), dahil hindi kapaki-pakinabang.
Kami ay pagpunta sa tumawag factorial ng iba pa.
>> At sa gayon ay maaari mong makita, kalaunan kung pumasa kami ng factorial (5) o isang bagay,
kami ay pagpunta sa tumawag factorial (4) at iba pa, at kalaunan namin upang maabot ang na base kaso.
Kaya ito mukhang mahusay. Natin makita kung ano ang mangyayari kapag aktwal namin patakbuhin ang.
Ito ay ang stack, at sabihin natin na ang pangunahing ay upang tawagan ang function na ito na may isang argumento (4).
Kaya sabay-sabay factorial nakikita at = 4, factorial ay tumawag mismo.
Ngayon, biglang, mayroon kaming factorial (3).
Kaya ang mga function na ito ay pagpunta upang panatilihin ang lumalaking hanggang kalaunan namin pindutin ang aming base kaso.
Sa puntong ito, ang return halaga ng return (nx return halaga ng),
ang return halaga ng nx ang return halaga ng.
Sa paglaon kailangan namin upang maabot ang ilang mga numero.
Sa tuktok dito, sinasabi namin return 1.
Iyon ay nangangahulugan na ang sabay-sabay naming ibalik na numero, maaari naming pop ito off ng stack.
Kaya ito factorial (1) tapos na.
Kapag 1 babalik, ito factorial (1) return, ang return na ito sa 1.
Ang return halaga ng mga ito, Tandaan, ay nx ang return halaga ng mga ito.
Kaya biglang, ang tao na ito ay alam na gusto ko upang bumalik 2.
>> Kaya tandaan, bumalik halaga ng mga ito lamang nx return halaga dito.
Kaya ngayon maaari naming sabihin 3 x 2, at sa wakas, narito maaari naming sabihin
ito ay 4 x 3 x 2.
At sa sandaling ito babalik, namin pababa ng isang integer sa loob ng pangunahing.
Anumang mga katanungan sa recursion?
Ayos lang. Kaya mas maraming oras para sa mga tanong sa dulo,
ngunit ngayon Joseph ay masaklawan ang natitirang mga paksa.
>> [Joseph Ong] Lahat ng karapatan. Kaya ngayon na kami uusapang tungkol recursions,
sabihin makipag-usap ng kaunti tungkol sa kung ano ang bumaybay-uuri ay.
Pagsamahin-uuri ay isa lamang ng isa pang paraan ng pag-uuri-uri ng isang listahan ng mga numero.
At kung paano ito gumagana ay, sa pagsasama-uuri mayroon kang isang listahan, at ano ang ginagawa namin ay
sabihin namin, sabihin hatiin ito sa 2 halves.
Ipapakita muna namin patakbuhin sumanib-uuri muli sa kaliwang kalahati,
magpapadala kami magpatakbo sumanib uri sa kanang kalahati,
at na nagbibigay sa amin ngayon 2 halves na pinagsunod-sunod, at ngayon kami ay upang pagsamahin ang mga halves.
Ng kaunti mahirap upang makita nang walang isang halimbawa, kaya kami sa pamamagitan ng mga galaw at makita kung ano ang mangyayari.
Kaya simulan mo sa listahang ito, hatiin namin ito sa 2 halves.
Nagpapatakbo kami sumanib uri sa kaliwang kalahati muna.
Kaya na ang kaliwang kalahati, at ngayon namin patakbuhin ang mga ito muli sa pamamagitan ng listahang ito
na maipo pumasa sa sa pagsasama-uuri, at pagkatapos ay tinitingnan namin, muli,
sa kaliwang bahagi ng listahan na ito at magpatakbo namin sumanib ang uri dito.
Ngayon, makuha namin pababa sa isang listahan ng mga 2 numero,
at ngayon ang kaliwang kalahati 1 elemento lamang mahaba, at hindi namin maaari
hatiin ang isang listahan na lamang ang 1 elemento sa kalahati, kaya lang namin sabihin, sa sandaling kami ay may 50,
na lamang ang 1 elemento, na ito pinagsunod-sunod.
>> Sandaling namin tapos ka na, maaari naming makita na aming makakaya
lumipat sa kanang kalahati ng listahang ito,
at 3 din ang pinagsunod-sunod, at kaya ngayon na ang parehong halves ng listahang ito ay pinagsunod-sunod
maaari naming sumali ang mga numerong ito pabalik sama-sama.
Kaya tinitingnan namin sa 50 at 3; 3 ay mas maliit sa 50, kaya ito napupunta sa unang at pagkatapos ay 50 ay.
Ngayon, na nagawa, pumunta namin pabalik hanggang sa na listahan at-uri-uriin kanang kalahati.
42 ito ng sariling numero, kaya na ito pinagsunod-sunod.
Kaya ngayon namin ihambing ang mga 2 at 3 ay mas maliit kaysa sa 42, kaya na ay makakakuha ng ilagay sa unang,
ngayon 42 ay makakakuha ng ilagay sa, at 50 ay makakakuha ng ilagay.
Ngayon, na pinagsunod-sunod, pumunta namin ang lahat ng mga paraan pabalik sa tuktok, 1337 at 15.
Well, ngayon namin tumingin sa kaliwang kalahati ng listahang ito, 1337 ay sa pamamagitan ng mismo kaya pinagsunod-sunod at parehong may 15.
Kaya ngayon naming pagsamahin ang 2 numero upang pag-uri-uriin na ang orihinal na listahan, 15 <1337,
kaya pupunta sa unang, pagkatapos 1337 pupunta.
At ngayon, pinagsunod-sunod namin parehong halves ng orihinal na listahan up tuktok.
At lahat kami ay may sa gawin ay pagsamahin ang mga.
Inaasahan naming sa unang 2 numero ng listahang ito, 3 <15, kaya pupunta sa array-uuri sa unang.
15 <42, kaya mangyaring in Ngayon, 42 <1337, na naging.
50 <1337, kaya pupunta. At mapansin na lang namin kinuha 2 numero ng listahang ito.
Kaya hindi namin ka lamang alternating sa pagitan ng 2 listahan.
Kami ay naghahanap sa simula, at namin ang paglalaan ng elemento
na mas maliit at pagkatapos ng paglalagay ito sa aming array.
Ngayon Pinagsama namin ang lahat ng mga halves at tapos na kami.
>> Anumang mga katanungan tungkol bumaybay-uuri? Oo?
[Mag-aaral] Kung ito ang paghahati ng pang sa iba't ibang mga, bakit hindi nila lang hatiin ito sa sandaling
at mayroon kang 3 at 2 sa isang grupo? [Rest ng tanong hindi maunawaan]
Ang dahilan - kaya tanong ay, kung bakit hindi lang namin pagsamahin ang mga ito na unang hakbang pagkatapos mayroon kaming ang mga ito?
Ang dahilan kung bakit maaari naming gawin ito, simulan sa kaliwang pinaka elemento ng magkabilang panig,
at pagkatapos ay gawin ang mga mas maliit na isa at ilagay ito sa, na alam namin na ang mga
indibidwal na listahan ay pinagsunod-sunod order.
Kaya kung Naghahanap ako sa kaliwang pinakamaraming mga elemento ng parehong halves,
Alam ko sila na ang pinakamaliit na elemento ng mga listahan.
Sa gayon ay maaari ko bang ilagay ang mga ito sa pinakamaliit na spot ng elemento ng ang malaking listahan.
Sa kabilang banda, kung tiningnan ko sa mga 2 listahan sa ikalawang antas banda roon,
50, 3, 42, 1337 at 15, ang mga ay hindi pinagsunod-sunod.
Kaya't kung tiningnan ko sa 50 at 1337, ako pagpunta upang ilagay ang 50 sa aking listahan sa unang.
Ngunit iyon ay hindi talagang magkaroon ng kahulugan, dahil 3 ay ang pinakamaliit na elemento out sa lahat ng mga.
Kaya ang tanging dahilan maaari naming gawin ito hakbang ng pagsasama-sama ay dahil ang aming mga listahan ay pinagsunod-sunod.
Alin ang kung bakit mayroon kaming upang makakuha ng down ang lahat ng mga paraan sa ibaba
dahil kapag mayroon kami ng isang numero, alam mo na ang isang solong numero
sa loob at ng sarili nito ay pinagsunod-sunod listahan.
>> Anumang mga katanungan? Hindi?
Pagiging kumplikado? Well, maaari mong makita na sa bawat hakbang may pagtatapos numero,
at maaari naming hatiin ang isang listahan sa kalahati log n beses,
na kung saan nakukuha namin ito log n x n kumplikado.
At makikita mo ang pinakamahusay na kaso para sa pagsasama-uuri n log n, at ito lamang kaya ang mangyayari
na ang pinakamasama kaso, o Ω banda roon, ay din n log n.
Isang bagay na dapat tandaan.
Paglipat sa, sabihin pumunta sa ilang mga sobrang pangunahing file ako / O.
Kung tumingin ka sa mang-uayabit, mapapansin mo nagkaroon kami ng ilang mga uri ng sistema
kung saan maaari kang sumulat sa isang file ng log kung mong basahin sa pamamagitan ng code.
Natin makita kung paano mo maaaring gawin na.
Well, mayroon kaming fprintf, na maaari mong isipin ng bilang lamang printf,
ngunit lamang ang pag-print sa isang file sa halip, at samakatuwid ay ibinigay ang f sa simula.
Ang ganitong uri ng code hanggang dito, kung ano ang ginagawa nito, bilang na nakita mo sa mang-uayabit,
napupunta sa pamamagitan ng iyong pag-print sa 2-dimensional array out hilera sa pamamagitan ng hilera kung ano ang mga numero ay.
Sa kasong ito, printf mga Kopya sa iyong terminal o kung ano ang tinatawag naming ang standard na output ng seksyon.
>> At ngayon, sa kasong ito, lahat kami ay may sa gawin ay palitan printf may fprintf,
sabihin dito kung ano ang file na nais mong i-print, at sa kasong ito lamang ito ng mga Kopya ito sa file na iyon
sa halip ng pag-print ito sa iyong terminal.
Well, pagkatapos na begs ang tanong: Saan kami makakuha ng ganitong uri ng file mula sa, i-right?
Ipinasa namin mag-log in sa ito fprintf fuction ngunit kami ay walang ideya na kung saan ito ay nagmula sa.
Well, maagang sa code, ano nagkaroon kami ito tipak ng code sa paglipas dito,
na talaga sabi na bukas ang file tawag log.txt.
Ano ang ginagawa namin matapos na namin upang matiyak na ang file ay talagang binuksan matagumpay.
Kaya maaaring ito mabibigo para sa maraming mga kadahilanan, wala kang sapat na espasyo sa iyong computer, halimbawa.
Kaya laging mahalaga bago mo ito gawin ang anumang mga pagpapatakbo sa mga file
na namin suriin kung ang file na ay matagumpay na binuksan.
Kaya kung ano na ang, na ang isang argumento sa fopen, maayos, maaari naming buksan ang isang file sa maraming paraan.
Ano ang maaari naming gawin ay, maaari naming ipasa ito w, na nangangahulugan na-override ang file kung ito labasan na,
Maaari naming makapasa ng isang, na ikabit ang sila sa dulo ng file sa halip ng override ito,
o maaari naming tukuyin ang r, na nangangahulugan na, sabihin buksan ang file bilang read-only.
Kaya kung ang programa ay sinusubukan upang gumawa ng anumang mga pagbabago sa file,
sumigaw sa kanila at huwag hayaan silang gawin ito.
Sa wakas, sa sandaling kami ay tapos ka na sa ang file, tapos ginagawa pagpapatakbo dito,
kailangan namin upang matiyak na naming isara ang file.
At kaya sa dulo ng iyong programa, ikaw ay ipasa ang mga ito muli
ang file na ito na binuksan mo, at isara ito.
Kaya ito ay isang bagay na mahalaga na mayroon kang upang tiyakin na gagawin mo.
Kaya tandaan maaari mong buksan ang isang file, pagkatapos ay maaari kang sumulat sa file,
gawin ang mga pagpapatakbo sa file, ngunit mayroon kang upang isara ang file sa dulo.
>> Anumang mga katanungan sa pangunahing file I / O? Oo?
[Estudyante tanong, hindi maintindihan]
Dito mismo. Ang tanong ay, kung saan ito log.txt file?
Well, kung mo lamang bigyan ito ng log.txt, lumilikha ito ng ito sa parehong directory bilang executable.
Kaya kung you're - >> [Estudyante tanong, hindi maintindihan]
Oo. Sa parehong folder, o sa parehong directory, na tawagan ka.
Ngayon memory, stack, at magbunton.
Kaya kung paano ay memory inilatag sa computer?
Well, maaari mong isipin ang memory bilang uri ng sa block na ito dito.
At sa memory mayroon kaming kung ano ang tinatawag na ang magbunton natigil banda roon, at ang stack na pababa doon.
At magbunton lumalaki ang pababang at stack ang lumalaki paitaas.
Kaya bilang Tommy nabanggit - oh, mahusay, at kami ay may iba pang mga 4 segment na ako makakakuha ng sa isang segundo -
Bilang Tommy sinabi mas maaga, alam mo kung paano ang kanyang mga function tumawag sa kanilang sarili at tumawag sa bawat isa?
Bumuo sila ang ganitong uri ng stack na frame.
Well, kung pangunahing tawag foo, foo ay makakakuha ng ilagay sa stack.
Foo tawag bar, bar makakuha ng ilalagay sa stack, at na maipo ilagay sa stack pagkatapos.
At bilang bumalik sila, sila bawat makapag kinuha off ang stack ang.
Ano ang bawat isa sa mga lokasyon na ito at memory pindutin nang matagal?
Well, sa tuktok, na kung saan ay ang teksto ng segment, naglalaman sa programa mismo.
Kaya ang machine code, na doon, sa sandaling ipunin ang iyong programa.
Susunod, anumang nasimulan pangkalahatang variable.
>> Kaya mayroon ka ng mga global variable sa iyong programa, at sabihin tulad, isang = 5,
na ay makakakuha ng ilagay sa segment na iyon, at kanang ilalim na,
mayroon kang anumang uninitialized global data, na lang int ng,
ngunit hindi mo sabihin ito ay katumbas sa anumang bagay.
Napagtanto mga ito ay mga pangkalahatang variable, kaya sila sa labas ng pangunahing.
Kaya ito ay nangangahulugan na ang anumang mga pangkalahatang variable na ipinahayag ngunit hindi nasimulan.
Kaya kung ano ang sa magbunton? Memory inilalaan gamit ang malloc, na magpapadala kami makakuha ng sa ilang sandali.
At sa wakas, na may stack mayroon kang anumang mga lokal na variable
at anumang function maaari kang tumawag sa anumang ng kanilang mga parameter.
Ang huling bagay, hindi mo talaga malaman kung ano ang kapaligiran variable gawin,
ngunit kapag nagpatakbo ka ng programa, may isang bagay na nauugnay, tulad ng
ito ay ang username ng tao na tumakbo sa programa.
At na uri ng sa ibaba.
Sa mga tuntunin ng mga address ng memorya, na hexadecimal halaga,
ang mga halaga sa tuktok simula sa 0, at sila ay pumunta sa lahat ng mga paraan pababa sa ilalim.
Sa kasong ito, kung ikaw ay sa 32-bit na sistema,
ang address sa ibaba ay magiging 0x, sinusundan ng af, dahil na 32 bit,
na 8 bytes, at sa kasong ito 8 bytes tumutugma sa 8 digit hexadecimal.
Kaya down na dito ka na magkaroon, i, 0xffffff, at hanggang doon ka pagpunta sa mayroon kang 0.
Kaya ano ang payo? Ang ilan sa inyo ay maaaring sakop ito sa seksyon bago.
ngunit kami ay pumunta sa paglipas ng ito sa panayam, kaya isang pointer ay isang uri ng data
kung aling mga tindahan, sa halip ng ilang mga uri ng halaga tulad ng 50, nag-iimbak ang address ng ilang mga lokasyon sa memorya.
Tulad na memory [hindi maintindihan].
Kaya sa kasong ito, kung ano ang namin ay, mayroon kaming isang pointer sa isang integer o isang int *,
at naglalaman ito hexadecimal address ng 0xDEADBEEF.
>> Kaya kung ano ang mayroon kami, ngayon, ang mga ito ng mga puntos ng pointer sa ilang mga lokasyon sa memorya,
at na lamang, ang halaga 50 ay sa lokasyon na ito ng memorya.
Sa ilang mga 32-bit na system, sa lahat ng 32-bit system, payo tumagal ng hanggang 32 bit o 4 bytes.
Ngunit, halimbawa, sa isang 64-bit na sistema, mga payo 64 bit.
Kaya, na ang isang bagay na nanaisin mong tandaan.
Kaya sa isang end-bit na sistema, ang pointer ng pagtatapos bit mahaba.
Payo uri ng mahirap digest nang walang dagdag na mga bagay,
kaya sabihin pumunta sa pamamagitan ng isang halimbawa ng dynamic na paglalaan ng memory.
Ano dynamic na paglalaan ng memory ang para sa iyo, o kung ano ang tinatawag naming malloc,
ito ay nagbibigay-daan sa iyo upang magtalaga ng ilang mga uri ng data sa labas ng hanay.
Kaya ang data na ito ay uri ng mas permanenteng para sa tagal ng programa.
Dahil bilang alam mo, kung ikaw ay ipinapahayag ng mga x sa loob ng isang function, at ang function na babalik,
hindi ka na magkakaroon ng access sa data na naka-imbak sa x.
Ang payo ipaalam gawin sa amin ay ipaalam sa amin nila iimbak ang halaga ng memorya o tindahan
sa isang iba't ibang mga segment ng memory, lalo na ang magbunton.
Ngayon sabay-sabay namin bumalik ng function na, hangga't mayroon kami ng pointer
na lokasyon sa memorya, pagkatapos ay kung ano ang maaari naming gawin ay maaari naming lamang tingnan ang mga halaga sa doon.
Tingnan natin ang isang halimbawa: Ito ang aming memory layout muli.
At mayroon kaming ang function na ito, pangunahing.
Ano ang ginagawa nito - okay, kaya simpleng, i-right -? Int x = 5, na lamang sa isang variable sa stack sa pangunahing.
>> Sa kabilang banda, ngayon namin ipinapahayag ng pointer na tawag sa mga giveMeThreeInts function na.
At kaya namin ngayon pumunta sa function na ito at lumikha kami ng bagong stack frame para dito.
Gayunpaman, sa stack frame na ito, idedeklara namin int * Temp,
na mallocs 3 integer para sa amin.
Kaya ang laki ng int ay magbibigay sa amin kung gaano karaming mga byte int ito,
at nagbibigay sa amin ng malloc na maraming byte ng espasyo sa magbunton.
Kaya sa kasong ito, lumikha kami ng sapat na espasyo para sa 3 integer,
at magbunton ay paraan up doon, na kung bakit ko na iginuhit ito nang mas mataas na hanggang.
Sa sandaling tapos na kami, dumating kami back up dito, kailangan mo lamang 3 ints ibinalik,
at ito ay magbabalik ng mga address, sa kasong ito sa kung saan na ang memory.
At kami ng pointer = lumipat, at hanggang doon kami ay may isa lamang pointer.
Ngunit ano na ang mga function na babalik ay isinalansan dito at mawala.
Kaya Temp mawala, ngunit pinapanatili pa rin namin ang address kung saan
3 integer na iyon sa loob ng mains.
Kaya sa set na ito, ang mga payo scoped lokal para sa nakasalansan na frame,
ngunit ang memorya kung saan tumutukoy ang mga iyon sa magbunton.
>> Ba na magkaroon ng kahulugan?
[Mag-aaral] Puwede mong ulitin na? >> [Joseph] Oo.
Kaya kung pumunta ako pabalik ng kaunti lamang, makikita mo na ang Temp inilalaan
ilang memory sa magbunton doon.
Kaya kapag ang function na ito, giveMeThreeInts babalik, ito stack dito ay pagpunta sa mawala.
At sa ito sa anumang ng mga variable, sa kasong ito, ang pointer na inilalaan sa nakasalansan frame.
Na ay pagpunta sa mawala, ngunit dahil ibinalik namin Temp
at kami ng pointer = Temp, pointer sa ngayon upang ituro ang parehong memorya ng lokasyon bilang Temp ay.
Kaya ngayon, kahit na mawala namin ang Temp, na lokal na pointer,
mapanatili pa rin namin ang memory address ng kung ano ito ay nagtuturo sa loob ng pointer na variable.
Mga tanong? Na uri ng isang nakalilito paksa kung hindi mo pa nawala sa paglipas ng ito sa seksyon.
Maaari naming, ang iyong tf talagang pumunta sa paglipas ng ito at siyempre maaari naming sagutin ang mga katanungan
sa dulo ng review session para sa.
Ngunit ito ay uri ng isang kumplikadong paksa, at mayroon akong higit pang mga halimbawa na upang ipakita up
na makakatulong sa linawin kung ano ang mga payo aktwal ay.
>> Sa kasong ito, ang mga payo ay katumbas ng array,
sa gayon ay maaari ko lang gamitin ang pointer na ito bilang ang parehong bagay bilang isang int array.
Kaya ako pag-i-index sa 0, at pagbabago sa unang integer sa 1,
pagbabago ng pangalawang integer sa 2, at ang 3rd integer sa 3.
Kaya higit pa sa mga payo. Well, isipin ang Binky.
Sa kasong ito na inilalaan namin pointer ng, o ipinahayag namin ng pointer,
ngunit simula, kapag ko lang ipinahayag ng pointer, hindi ito na tumuturo sa kahit saan sa memorya.
Ito ay basura lamang ang mga halaga sa loob nito.
Kaya Mayroon akong walang ideya kung saan ang pointer ito ay tumuturo sa.
Ito ay may isang address na lang puno ng 0 at 1 kung saan simula ito ay ipinahayag.
Hindi ko maaaring gawin na ito hanggang tumawag ako malloc dito
at pagkatapos ay nagbibigay sa akin ang maliit na puwang sa magbunton kung saan Maaari ko bang ilagay ang halaga sa loob.
Pagkatapos muli, hindi ko alam kung ano ang sa loob ng memory na ito.
Kaya ang unang bagay na kailangan kong gawin ay suriin kung ang sistema ang may sapat na memorya
upang bigyan ako ng 1 integer sa unang lugar, na kung saan ay kung bakit ako ginagawa ito suriin.
Kung ang pointer ay null, na nangangahulugan na hindi ito sapat na espasyo o ilang iba pang mga naganap na error,
kaya dapat kong lumabas ng aking programa.
Ngunit kung ito ay ginawa magtagumpay, ngayon ko gamitin na pointer
at kung ano ang * pointer ginagawa ito ay sumusunod kung saan ay ang address
sa kung saan ang halaga na hindi, at nagtatakda katumbas ng 1.
Kaya sa paglipas dito, Sinusuri namin kung ang memory na umiral.
>> Sandaling alam mo na umiiral na ito, maaari mong ilagay ito
kung ano ang halaga na nais mong ilagay ito, sa kasong ito 1.
Sa sandaling tapos na kami dito, kailangan mo upang magbakante na pointer
dahil kailangan namin upang makakuha muli ng system na memory na iyong hiniling para sa unang lugar.
Dahil ang computer ay hindi alam kapag tapos na kami dito.
Sa kasong ito tahasang sinasabi kami ay sa ito, okay, kami ay tapos na na memory.
Kung ang ilang iba pang mga proseso ay kailangang ito, ang ilang iba pang mga programa ay kailangang ito, huwag mag-atubiling upang magpatuloy at dalhin ito.
Ano ang maaari rin naming gawin ay maaari naming makuha ang address ng lokal na mga variable sa set.
Kaya int x sa loob ng nakasalansan frame ng pangunahing.
At kapag ginagamit namin ito ampersand, ito at operator, kung ano ang ginagawa nito ay
ito ay tumatagal ng x, at x lamang ang ilang mga data sa memory, ngunit ito ay may isang address.
Ito ay matatagpuan sa isang lugar. Ito sa pamamagitan ng pagtawag at x, kung ano ang ginagawa ng ito ay nagbibigay sa amin ang address ng x.
Sa pamamagitan ng paggawa nito, ginagawa namin pointer punto sa kung saan ang x ay sa memorya.
Ngayon lang namin ang isang bagay tulad ng * x, kami ay upang makakuha ng 5 likod.
Bituin ay tinatawag na dereferencing ito.
Sundin mo ang address at makakakuha ka ng ang halaga nito na nakaimbak doon.
>> Anumang mga katanungan? Oo?
[Mag-aaral] Kung hindi mo gawin ang 3-tulis na bagay, ay pa rin ito makatipon?
Oo. Kung hindi mo gawin ang 3-pointer bagay, pa rin ito upang makatipon,
ngunit kukunin ko na ipakita sa iyo kung ano ang mangyayari sa isang segundo, at nang hindi ginagawa na,
na kung ano ang tinatawag naming isang memory mahayag. Hindi mo pagbibigay ng system
-back ang memory nito, kaya matapos ang isang habang ang programa upang makaipon ng
memorya na hindi ito ginagamit, at walang sinuman ang maaaring gamitin ito.
Kung nakita mo ang Firefox na may 1.5 milyong kilobytes sa iyong computer,
sa tagapamahala ng gawain, na kung anong nangyayari sa.
Mayroon kang isang memory mahayag sa programa na hindi sila paghawak.
Kaya kung paano gumagana ang pointer ng aritmetika trabaho?
Well, aritmetika ng pointer ay uri ng tulad ng pag-i-index sa isang array.
Sa kasong ito, mayroon akong pointer, at kung ano ang gagawin ko ako makagawa ng pointer punto sa unang elemento
ng ang array na ito ng 3 integer na aking inilalaan.
Kaya ngayon kung ano ang gagawin ko, star pointer lang nagbabago sa unang elemento sa listahan.
Star pointer +1 puntos sa paglipas dito.
Kaya ang pointer ay sa paglipas dito, pointer +1 ay higit sa dito, pointer +2 sa paglipas dito.
>> Kaya lamang pagdaragdag ng 1 ay ang parehong bagay bilang gumagalaw sa kahabaan ng array na ito.
Ano ang ginagawa namin ay, kapag ginagawa namin pointer +1 sa makuha mo ang address sa paglipas dito,
at upang makuha ang halaga in dito, kang maglagay ng star sa mula sa buong expression
dereference ito.
Kaya, sa kasong ito, ako pagtatakda ng unang lokasyon sa array na ito sa 1,
pangalawang lokasyon sa 2, at ikatlong lokasyon sa 3.
Pagkatapos kung ano ang ako ginagawa sa paglipas dito ay ako ang pag-print ng aming pointer +1,
na nagbibigay sa akin lang 2.
Ngayon ako incrementing pointer, kaya pointer katumbas pointer +1,
na gumagalaw ito pasulong.
At kaya ngayon kung-print ko pointer +1, pointer +1 na ngayon ang 3,
kung saan sa kasong ito mga Kopya ang 3.
At upang libreng isang bagay, ang pointer na bigyan ko ito
ay dapat na tumuturo sa simula ng array na Nakatanggap ako mula sa malloc.
Kaya, sa kasong ito, kung ako ay upang tawagan ang 3 dito mismo, hindi ito magiging karapatan,
dahil ito sa gitna ng array.
Ko bang ibawas upang makakuha ng sa orihinal na lokasyon
paunang unang puwesto bago ko magbakante ito.
Kaya, narito ang isang mas kasangkot halimbawa.
Sa kasong ito, kami ay paglaan ng 7 character sa isang array ng character.
>> At sa kasong ito kung anong ginagawa namin ay namin ang looping sa ibabaw ng unang 6 sa kanila,
at kami ay pagtatakda ng mga ito sa Z.
Kaya, para sa int i = 0, i> 6, i + +,
Kaya, pointer + ay i lamang bigyan kami ng, sa kasong ito,
pointer, pointer +1, pointer +2, pointer +3, at iba pa at iba pa sa loop.
Ano ito gawin ay nakakakuha ng address na iyon, dereferences ito upang makuha ang halaga,
at mga pagbabago na halaga sa isang Z.
Pagkatapos sa dulo tandaan na ito ay isang string, i-right?
Ang lahat ng mga string ay may magtapos sa null pagwawakas ng character.
Kaya, kung ano ang gagawin ko sa pointer 6 ko bang ilagay ang null Terminator karakter.
At ngayon kung ano talaga ako ginagawa sa paglipas dito ay pagpapatupad ng printf para sa isang string, i-right?
>> Kaya, kapag ang printf ngayon kapag ito ay naabot ang dulo ng isang string?
Kapag pinindot niya ang null pagwawakas ng character.
Kaya, sa kasong ito, ang aking orihinal na pointer mga puntos sa simula ng array na ito.
-Print ko ang unang character out. Ilipat ko ito sa paglipas ng isa.
-Print ko na karakter out. Ko ilipat ito sa paglipas ng.
At patuloy ko ginagawa ito hanggang maabot ko ang katapusan.
At ngayon sa dulo ng pointer * dereference ito at makakuha null pagwawakas ng character.
At sa gayon ang aking loop habang tumatakbo lamang kapag ang halaga na hindi null pagwawakas ng character.
Kaya, ngayon ko lumabas sa labas ng loop na ito.
At kaya kung ko ibawas 6 mula sa pointer,
Pumunta ko bumalik ang lahat ng mga paraan sa simula.
Tandaan, ako ginagawa ito dahil mayroon akong pumunta sa simula upang magbakante ito.
>> Kaya, alam ko na ng maraming. Mayroon bang anumang mga katanungan?
Mangyaring, yes?
[Tanong hindi maunawaan Estudyante]
Maaari mong sabihin na louder? Sorry.
[Mag-aaral] Sa huling slide kanan bago napalaya mo ang pointer,
kung saan ang iyong aktwal na pagbabago sa halaga ng pointer?
[Joseph] Kaya, dito mismo. >> [Mag-aaral] Oh, okay.
[Joseph] Kaya, mayroon akong isang pointer minus minus, kanan,
na gumagalaw ang mga bagay sa likod ng isa, at pagkatapos magbakante ko ito,
dahil ang pointer na ito ay may tulis sa simula ng array.
[Mag-aaral] Ngunit iyon ay hindi na kailanganin ay huminto ka pagkatapos na linya.
[Joseph] Kaya, kung huminto ako pagkatapos nito, ito ay itinuturing na isang memory mahayag,
dahil hindi ko patakbuhin ang libreng.
[Mag-aaral] ko [hindi maintindihan] pagkatapos ng unang tatlong linya na kung saan mayroon kang ang pointer +1 [hindi maintindihan].
[Joseph] Uh-huh. Kaya, ano ang pinag-uusapan doon?
Sorry. Hindi, hindi. Pumunta, pumunta, mangyaring.
[Mag-aaral] Kaya, hindi mo binabago ang halaga ng mga payo.
Hindi mo ay nagkaroon upang gawin ang pointer minus minus.
[Joseph] Oo, eksakto.
Kaya, kapag gagawin ko ang pointer +1 at pointer +2,
Hindi ako ginagawa pointer katumbas pointer +1.
Kaya, ang pointer lamang ang pananatili na tumuturo sa simula ng array.
Lamang ito kapag gagawin ko plus plus na ito ay nagtatakda ng halaga pabalik sa loob ng pointer,
na ito ay aktwal na gumagalaw ito sa kahabaan ng.
Ayos lang.
Higit pang mga tanong?
>> Muli, kung ito ay uri ng napakatinding, ito ay sakop sa session.
Tanungin ang iyong kapwa ng pagtuturo tungkol dito, at maaari naming sagutin ang mga tanong sa dulo.
At karaniwang hindi namin bang gawin ito minus bagay.
Na ito ay nangangailangan sa akin pagpapanatiling track kung magkano ko na offset sa array.
Kaya, sa pangkalahatan, ito ay lamang sa kung paano gumagana ang pointer aritmetika.
Ngunit kung ano ang gusto namin karaniwang gawin ay gusto namin upang lumikha ng isang kopya ng pointer,
at pagkatapos ay gagamitin namin na kopya kapag kami ay gumagalaw sa paligid sa string.
Kaya, sa mga kaso gumamit ka ng kopya upang i-print ang buong string,
ngunit hindi namin na gawin tulad ng pointer minus 6 o subaybayan kung magkano namin inilipat sa,
dahil lang alam namin na ang aming orihinal na punto ay pa rin tulis sa simula ng listahan
at ang lahat na namin binago ang kopya na ito.
Kaya, sa pangkalahatan, baguhin ang mga kopya ng iyong orihinal na pointer.
Huwag subukan upang pag-uri-uriin ng tulad - don't baguhin ang orihinal na kopya.
Sinusubukang upang baguhin lamang ang mga kopya ng iyong orihinal na.
Kaya, napansin mo kapag pumasa namin ang string sa printf
hindi mo na kailangang maglagay ng star sa harap ng mga ito tulad ng ginawa namin sa lahat ng iba pang dereferences, i-right?
Kaya, kung print ka buong string% s inaasahan ng isang address,
at sa kasong ito ng isang pointer o sa kasong ito tulad ng isang array ng mga character.
>> Character, magpasinda * s, at array ay ang parehong bagay.
Pointer ay ang mga character, at character na array ang mga parehong bagay.
At iba pa, ang lahat kami ay may sa gawin ay pumasa sa pointer.
Hindi namin upang pumasa sa tulad ng * pointer o anumang bagay tulad na.
Kaya, ang mga array at pointer ang mga parehong bagay.
Kapag ikaw ay paggawa ng isang bagay tulad ng x [y] sa paglipas dito para sa isang array,
kung ano ang ginagawa sa ilalim ng hood ito sinasabi, okay, ito ay isang character array,
kaya ang isang pointer.
At kaya x ang mga parehong bagay,
at kaya kung ano ang ginagawa nito ay nagdadagdag ito y sa x,
kung saan ay ang parehong bagay bilang sumusulong sa memory na mas.
At ngayon x + y ay nagbibigay sa amin ng ilang mga uri ng address,
at dereference namin ang address o sundin ang mga arrow
kung saan na lokasyon sa memorya at makuha namin ang halaga ng na lokasyon sa memorya.
Kaya, kaya dalawang mga eksaktong parehong bagay.
Lamang sintaktik asukal.
Ginagawa nila ang parehong bagay. Lang nila ibang syntactics para sa bawat isa.
>> Kaya, kung ano ang maaaring magkamali sa mga payo? Tulad, ng maraming. Okay. Kaya, ang masamang bagay.
Ang ilang mga masamang mga bagay na maaari mong gawin ay hindi-check kung ang iyong malloc tawag nagbabalik null, i-right?
Sa kasong ito, ako na humihiling ang sistema upang bigyan ako - kung ano ang number na?
Tulad 2 bilyong beses 4, dahil ang laki ng isang integer 4 bytes.
Ako humihingi ang mga ito para sa tulad ng 8 bilyong bytes.
Siyempre ang aking computer ay hindi ninyo ako na magkano likod ng memory.
At hindi namin ginawa suriin kung ito ay null, kaya kapag sinubukan namin sa dereference ito banda roon -
sundin ang mga arrow sa kung saan ito ay pagpunta sa - hindi namin na memorya.
Ito ay kung ano ang tinatawag naming dereferencing null pointer.
At ito nagiging sanhi ng mahalagang mong segfault.
Ito ay isa sa mga paraan na maaari mong segfault.
Iba pang masamang mga bagay na maaari mong gawin - oh din.
Na dereferencing null pointer. Okay.
Iba pang mga masamang - na rin, upang ayusin mo lamang maglagay ng check doon
na sumusuri kung ang pointer sa ay null
at lumabas ng programa kung ito ang mangyayari malloc na nagbabalik ng isang null pointer.
Iyon ang xkcd comic. Mga tao na maunawaan ito ngayon. -Uri-uriin ng.
>> Kaya, memory. At nagpunta ako sa paglipas ng ito.
Pagtawag malloc kami sa isang loop, ngunit ang bawat oras na tinatawag naming malloc
namin ay mawala ang track kung saan ang pointer ito ay tumuturo sa,
dahil kami ay clobbering ito.
Kaya, ang unang tawag sa malloc ay nagbibigay sa akin memory sa paglipas dito.
Aking pointer pointer na ito.
Ngayon, hindi ko magbakante ito, kaya ngayon Tinatawag kong malloc muli.
Ngayon ito POINTS sa paglipas dito. Ngayon ang aking memorya ay pagturo sa paglipas dito.
Pagturo sa paglipas dito. Pagturo sa paglipas dito.
Ngunit nawala ko ang track ng address ng lahat ng memory sa dito na ko inilalaan.
At ito ngayon hindi ko kailangang anumang reference sa kanila na ito.
Kaya, hindi ko magbakante mga ito sa labas ng loop na ito.
At iba pa upang ayusin ang isang bagay tulad nito,
kung nakalimutan mo ang libreng memorya at makakakuha ka ng memory mahayag na ito,
Mayroon kang upang magbakante ang memory sa loob ng loop na ito sa sandaling tapos ka na dito.
Well, ito ay kung ano ang mangyayari. Alam ko maraming mo mapoot ito.
Ngunit ngayon - Yay! Nakukuha mong tulad ng 44,000 kilobytes.
Kaya, magbakante mo ito sa dulo ng loop,
at na magbakante lang ang memory sa bawat oras.
Mahalaga, ang iyong programa ay hindi magkaroon ng isang memory mahayag ito.
>> At ngayon ibang bagay na maaari mong gawin ay magbakante ilang memory na hiniling mo para sa dalawang beses.
Sa kasong ito, malloc isang bagay, baguhin mo ang halaga nito.
Magbakante mong ito sabay-sabay dahil sinabi mo ikaw ay tapos na gamit ito.
Ngunit pagkatapos namin napalaya itong muli.
Ito ay isang bagay na medyo masamang.
Hindi ito simula segfault,
ngunit matapos ang isang habang kung ano ito ay ay double pagbabakante ito corrupts iyong magbunton istraktura,
at matutunan mo ng kaunti ang nalalaman tungkol sa kung pinili mo ang isang klase tulad ng CS61.
Ngunit mahalagang matapos ang isang habang ang iyong computer ay pagpunta upang nalilito
tungkol sa kung ano ang memory lokasyon kung saan at kung saan naka-imbak ito -
kung saan ang data ay naka-imbak sa memorya.
At kaya pagbabakante isang pointer nang dalawang beses ay isang masamang bagay na hindi mo nais na gawin.
>> Iba pang mga bagay na maaaring magkamali ay hindi gumagamit ng sizeof.
Kaya, sa kasong ito malloc kang 8 bytes,
at na ang parehong bagay bilang dalawang integer, i-right?
Kaya, perpektong ligtas, ngunit ito?
Well, bilang Lucas uusapang tungkol sa iba't ibang mga architectures,
integer ay ng iba't-ibang haba.
Kaya, sa appliance na ginagamit mo, integer 4 bytes,
ngunit sa ilang iba pang mga system sila na 8 bytes o maaaring sila ay 16 bytes.
Kaya, kung ko lang gamitin ang numerong ito sa paglipas dito,
Ang program na ito ay maaaring gumana sa appliance,
ngunit hindi ito upang maglaan ng sapat na memorya sa ilang iba pang mga sistema.
Sa kasong ito, ito ay kung ano ang sizeof operator ay ginagamit para sa.
Kapag tinatawag naming sizeof (int), kung ano ang ginagawa ay
ito ay nagbibigay sa amin ang laki ng isang integer sa system na programa ay tumatakbo.
Kaya, sa kasong ito, sizeof (int) ay magbabalik 4 sa isang bagay tulad ng appliance,
at ngayon ito kalooban 4 * 2, na kung saan ay 8,
na ang halaga ng puwang na kinakailangan para sa dalawang integer.
Sa ibang system, kung ang isang int tulad ng 16 bytes o 8 bytes,
lamang ito upang bumalik sapat byte-imbak na halaga.
>> At sa wakas, structs.
Kaya, kung gusto mo upang mag-imbak ng sudoku board sa memory, kung paano namin gawin ito?
Maaari mong isipin na tulad ng isang variable para sa unang bagay na,
isang variable para sa ikalawang bagay, sa isang variable para sa ikatlong bagay,
isang variable para sa ika-apat na bagay - masamang, i-right?
Kaya, ang isang pagpapabuti na maaari kang magsagawa ng sa itaas ng ay upang makagawa ng isang 9 x 9 array.
Iyon ay pinong, ngunit kung ano kung nais mong iugnay ang iba pang mga bagay sa sudoku board
bang kung ano ang kahirapan ng board,
o, halimbawa, kung ano ang iyong iskor ay, o kung gaano karaming oras na ito kinuha sa iyo upang malutas ang board na ito?
Well, kung ano ang maaari mong gawin ay maaari kang lumikha ng isang struct.
Ano talaga ako sinasabi ng pagtukoy ako istrakturang ito sa paglipas dito,
at ako ng pagtukoy sa isang sudoku board na binubuo ng isang board na 9 x 9.
>> At kung ano ang mayroon itong mga ito ay may mga payo sa pangalan ng antas.
Mayroon din itong x at y, kung saan ang mga coordinate kung nasaan ako ngayon.
Din ito ay oras na ginugol [hindi maintindihan], at ito ay ang kabuuang bilang ng mga gumagalaw na ko na inputted sa ngayon.
At kaya sa kasong ito, maaari ko grupo ng isang buong grupo ng mga data sa isang istraktura lamang
sa halip ng pagkakaroon ng ito tulad ng lumilipad sa paligid tulad ng ibang mga variable
na hindi talaga ako makapag-subaybayan ng.
At ito ay nagbibigay-daan sa amin lang magaling syntax para sa uri ng tumutukoy sa iba't ibang bagay sa loob ng struct na ito.
Maaari ko lamang gawin board.board, at nakukuha ko ang sudoku board sa likod.
Board.level, nakukuha ko kung paano matigas ito ay.
Board.x at board.y magbigay sa akin ang mga coordinate ng kung saan maaari ko sa board.
At kaya ako-access sa kung ano ang tinatawag naming mga patlang sa struct.
Ito ay tumutukoy sudokuBoard, na kung saan ay isang uri na mayroon akong.
At ngayon kami dito. Mayroon akong isang variable na tinatawag na "board" ng uri sudokuBoard.
At kaya ngayon ko ma-access ang lahat ng mga field na bumubuo istrakturang ito sa paglipas dito.
>> Anumang mga katanungan tungkol sa mga structs? Oo?
[Mag-aaral] Para sa int x, y, ipinahayag mo pareho sa isang linya? >> [Joseph] Uh-huh.
[Mag-aaral] Kaya, maaari mo lamang gawin iyon sa lahat ng mga ito?
Gusto sa x, y mga kuwit beses na kabuuang?
[Joseph] Oo, maaari mong tiyak gawin iyon, ngunit ang dahilan ko bang ilagay x at y sa parehong linya -
at ang tanong ay kung bakit maaari naming lamang gawin ito sa parehong linya?
Bakit hindi namin lamang ilagay ang lahat ng mga ito sa parehong linya ay
x at y ay may kaugnayan sa bawat isa,
at ito lamang ang stylistically mas tama, sa isang kahulugan,
dahil ito pagpangkat dalawang bagay sa parehong linya
na tulad ng uri ng nauugnay sa parehong bagay.
At ko lang hatiin ang mga bukod. Ito ay lamang ng isang bagay ng estilo.
Mayroon pagtakbo ay hindi gumagawa ng mga pagkakaiba sa kung ano pa man.
Anumang iba pang mga tanong sa mga structs?
Maaari mong tukuyin ang isang Pokédex na may struct.
Isang Pokémon ay may numero at ito ay isang sulat, isang may-ari, isang uri.
At pagkatapos ay kung mayroon kang isang array ng Pokémon, maaari kang gumawa ng isang Pokédex, i-right?
Okay, cool. Kaya, ang mga tanong sa mga structs. Yaong ay may kaugnayan sa structs.
>> Panghuli, GDB. Ano ang ginagawa ng ng GDB hayaan mong gawin? Ay nagbibigay-daan sa iyo upang i-debug ang iyong programa.
At kung hindi mo pa ginagamit GDB, Gusto ko inirerekomenda nanonood ng maikling
at pagpunta sa kung ano ang GDB ay, kung paano gumagana ang dito, kung paano mo maaaring gamitin ito,
at subukan ito sa isang programa.
At kaya kung ano ang GDB ay nagbibigay-daan sa gawin mo ito ay nagbibigay-daan sa i-pause ang [hindi maintindihan] up sa programa ng iyong
at praktikal na linya.
Halimbawa, gusto kong i-pause ang pagpapatupad sa tulad ng linya 3 ng aking mga programa,
at habang ako sa linya 3 ang maaari kong i-print ang lahat ng mga halaga na doon.
At kaya kung ano ang tinatawag naming tulad ng pag-pause sa isang linya
ay namin tumawag ito ng paglalagay ng breakpoint sa linya na
at pagkatapos ay maaari naming i-print ang mga variable sa estado ng programa sa oras na iyon.
>> Maaari naming pagkatapos ay mula doon hakbang sa pamamagitan ng programa ng line-by-line.
At pagkatapos ay maaari naming tingnan ang estado ng stack sa oras.
At ito upang gamitin ang GDB, ano ang ginagawa namin kami tatawag kumalatong sa file C,
ngunit mayroon kaming upang pumasa ito sa-ggdb bandila.
At sa sandaling tapos na kami na namin lamang patakbuhin ang gdb sa resultang output file.
At kaya makakakuha ka ng ilang mga tulad ng masa ng teksto tulad nito,
ngunit talagang lahat ng kailangan mong gawin ay i-type sa mga utos sa simula.
Masira pangunahing naglalagay ng breakpoint sa pangunahing.
Listahan ng 400 ay naglilista ng mga linya ng code sa buong line 400.
At kaya sa kasong ito ay maaaring mo lamang tumingin sa paligid at sabihin, oh,
Gusto kong mag-set ng breakpoint sa linya 397, na ang linyang ito,
at pagkatapos ay tumatakbo ang iyong programa sa hakbang na iyon at ito ay pagpunta sa masira.
Ito ay pagpunta sa i-pause doon, at maaari mong i-print, halimbawa, ang halaga ng mababa o mataas.
At kaya may mga ng grupo ng mga utos na kailangan mong malaman,
at ang slideshow na ito ay pumunta sa website,
kaya kung gusto mo lang na banggitin ang mga ito o bang ilagay ang mga ito sa iyong mga impostor sheet, huwag mag-atubiling.
>> Cool. Na Quiz Suriin ang 0, at kami na dumikit sa paligid kung mayroon kang anumang mga katanungan.
Ayos lang.
>> [Palakpakan]
>> [CS50.TV]