[Powered by Google Translate] [Review] [Viktoriin 0] [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvardi Ülikool] [See on CS50.] [CS50.TV] Hei, kõik. Tere tulemast läbivaatamise istungil viktoriin 0, mis toimub sel kolmapäeval. Mida me teeme täna, ma olen koos 3 teise TFS, ja koos me läheme läbi vaadata, mida me teinud oleme muidugi siiani. Ta ei kavatse olla 100% kõikehõlmav, kuid see peaks andma teile parema ülevaate mida sa juba maha ja mida sa ikka pead õppima enne kolmapäeva. Ja julgelt tõstke käsi küsimusi kui me läheme mööda, kuid pidage meeles, et me ka natuke aega lõpus- kui saame läbi koos paar minutit vaba-teha üldisi küsimusi, nii et hoidke seda meeles, ja nii me kavatseme alustada algusest koos 0-nädalal. [Küsitlus 0 ülevaates!] [Osa 0] [Lexi Ross] Aga enne me seda räägime logistika viktoriini. [Logistika] [viktoriin toimub kolmapäeval 10/10 asemel loeng] [(Vt http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf üksikasjad)] See on kolmapäev, 10. oktoober. See on sel kolmapäeval, ja kui sa lähed sellele link siin mis on kättesaadavad ka CS50.net-seal lingi- näete infot, kuhu minna põhinevad Teie perekonnanimi või kooli kuuluvus samuti see räägib täpselt, mida tegema katab ja tüüpi küsimusi, et sa lähed, et saada. Pea meeles, et siis on teil ka võimalus kontrollida, et viktoriin punktis, nii oma TF peaks minema üle mõned praktikas probleeme, ja see on teine ​​hea võimalus näha, kui teil on vaja veel õppida tasa tegema. Alustame algusest koos Bits n Bytes. Pea meeles, natuke on vaid 0 või 1, ja bait on kogumik 8 need bitti. Vaatame selle kogumise bitti siin. Me peaksime suutma aru saada, mitu bitti on. Kui me loota seal on ainult 8 neist kaheksa 0 või 1 tk. Ja kuna seal on 8 bitti, mis on 1 bait, ja olgem teisendada see kuueteistkümnendsüsteemis. Hexadecimal on alus 16, ja see on üsna lihtne teisendada number binaarne, mis on see, mis see on, et number kuueteistkümnendsüsteemis. Kõik me teeme, on me vaatame rühmad 4, ja me teisendada need asjakohased kuueteistkümnendsüsteemis numbrit. Alustame kõige parempoolsem grupis on 4, nii et 0011. See saab olema üks 1 ja teine ​​2, seega kokku, et teeb 3. Ja siis vaatame teiste ploki 4. 1101. See saab olema üks 1, üks 4 ja üks 8. Koos, et see saab olema 13, mis teeb D. Ja me meeles pidama, et kuueteistkümnendsüsteemis me lihtsalt ei lähe 0 kuni 9. Me läheme 0 kuni F, nii et pärast 9, 10 vastab, 11 B, jne, kus F on 15. Siin 13 on D, nii teisendada see koma kõik me teeme, on meil tegelikult ravida iga positsiooni võimsus 2. See on üks 1, üks 2, null 4s, null 8s, üks 16, jne, ja see on natuke raske arvutada oma peaga, kuid kui me minna järgmisele slaidile näeme, et vastus sellele. Sisuliselt me ​​läheme üle paremalt tagasi vasakule, ja me korrutades iga numbri vastav võimsus 2. Ja pidage meeles, Heksadesimaaliarvon me tähistavad need numbrid 0x alguses nii et me ei segi ajada kümnendmurruna. Jätkub, see on ASCII tabelis, ja mida me kasutada ASCII jaoks on kaardistada alates märki arvväärtused. Pea meeles, et krüptograafia pset me ulatuslikult kasutatud ASCII tabel et kasutada erinevaid meetodeid krüptograafia, Caesar ja Vigenère salakiri, teisendada erinevaid tähti aastal stringi järgi võtme abil kasutaja. Vaatame natuke ASCII matemaatikat. Vaadates "P" + 1 iseloomuga vorm, mis oleks Q, ja pidage meeles, et '5 '≠ 5. Ja kuidas täpselt oleks me teisendada nende vahel 2 vormi? See ei ole tegelikult liiga raske. Selleks, et saada 5 me lahutame '0 ' sest seal on 5 kohta vahel '0 'ja '5. " Selleks, et minna teist teed me lihtsalt lisada 0, nii et see on omamoodi nagu tavalisi aritmeetika. Pea meeles, et kui midagi on jutumärgid see, et see on märk ja seega vastab väärtus ASCII tabelis. Liikumine üldisem infotehnoloogia teemadel. Me õppisime mida algoritm on ja kuidas me seda kasutame programmeerimine rakendada algoritme. Mõned näited algoritmid on midagi väga lihtsat nagu kontrollida, kas arv on paaris või paaritu. Sel mäleta me mod number 2 ja vaadata, kas tulemus on 0. Kui nii, siis on isegi. Kui ei, siis see on imelik. Ja see näide tegelikult põhilised algoritm. Natuke rohkem kaasatud üks on binaarne otsing, mis me minna üle hiljem läbivaatamise istungil. Ja programmeerimine on termin, mida me kasutame, võttes algoritm ning muutes selle koodi arvuti ei loe. 2 näiteid programmeerimine on Scratch, mis on see, mida me tegime nädal 0. Isegi kui me tegelikult ei kirjuta välja koodi see on viis, kuidas rakendatakse Selle algoritmi, mis trükib numbrid 1-10, ja siin me teeme sama C-keeles. Need on funktsionaalselt võrdne, lihtsalt kirjutatud erinevates keeltes või süntaks. Siis õppinud boolean väljendeid, ja tõeväärtus on väärtus, mis on kas õige või vale, ja siin Sageli boolean väljendeid minna sees tingimused, nii et kui (x ≤ 5) noh, me juba x = 5, nii et tingimus läheb hindab true. Ja kui see on tõsi, mis iganes kood on all seisukorras läheb hindab arvuti, nii et nöör läheb trükitakse standardväljundisse, ja mõiste tingimus viitab iganes on sulgudesse, kui avalduses. Pea kõik ettevõtjad. Pea meeles, see on && ja | | kui me üritame ühendada 2 või rohkem tingimust, == Ei = et kontrollida, kas 2 asja on võrdsed. Pea meeles, et = on loovutamise arvestades == on tõeväärtus operaator. ≤, ≥ ja siis lõplik 2 on iseenesestmõistetavad. Üldkontrolli boolean loogika siin. Ja boolean väljendid on oluline ka silmad, mis me lähme nüüd möödas. Me õppinud 3 tüüpi ring seni CS50 jaoks, samal ajal, ja teha samal ajal. Ja see on oluline teada, et kui kõige eesmärkidel saame tegelikult kasutada mis tahes tüüpi silmus üldiselt on olemas teatud tüüpi eesmärkidel või ühiseid jooni programmeerimise, et nõuavad spetsiaalselt üks neist ring et muuta see kõige tõhusam või elegantne koodi see nii. Lähme üle, mida kõik need silmad kipub kasutatakse kõige sagedamini. Aastal jaoks silmus me üldiselt juba teame, mitu korda me tahame kinnitada,. See, mida me panna seisukorras. Sest, i = 0, i <10 näiteks. Teame juba, et me tahame teha midagi 10 korda. Nüüd, kui silmus, üldiselt me ​​ei pruugi tea, mitu korda me tahame silmus jooksma. Aga me teame mingi tingimus, et me tahame seda alati olla tõsi või alati olla vale. Näiteks kui on määratud. Oletame, et on tõeväärtus muutuja. Kuigi see on tõsi tahame kood hinnata, nii natuke rohkem laiendatav, natuke laiem kui loop, kuid igal jaoks silmus saab ka ümber samas silmus. Lõpuks ei samas silmuseid, mis võib olla trickiest aru kohe, kasutatakse sageli kui me tahame hinnata esimesena koodi Enne esimest korda me kontrollida seisukorda. Ühise kasutamise puhul teha samas loop on see, kui sa tahad saada kasutaja sisend, ja sa tead sa tahad paluda kasutajal sisend vähemalt üks kord, kuid kui nad ei anna teile hea sisend kohe mida soovite säilitada paludes neid, kuni nad annavad teile hea sisend. See on kõige levinum kasutada ei samas loop, ja vaatame tegelikku koostist need silmad. Nad on tavaliselt alati kipuvad järgima neid mudeleid. On jaoks silmus sees sul on 3 komponenti: käivitamise, tavaliselt midagi int i = 0, kui i on loendur, seisund, kus me tahame öelda saan selle eest silmuse nii kaua, kui see tingimus kuulub endiselt, nagu i <10, ja siis lõpuks, uuendus, mis on see, kuidas me juurdekasvu counter muutuja igas punktis silmus. Ühine asi näha on lihtsalt i + +, mis tähendab juurdekasvu i 1. iga kord. Sa võiksid ka midagi sellist i + = 2, mis tähendab, lisage 2 kuni i iga kord, kui minna läbi silmuse. Ja siis tee seda lihtsalt viitab mingi koodi, mis tegelikult töötab osana silmus. Ja samas silmus, seekord me tegelikult initsialiseerimise väljaspool loop, Nii näiteks, oletame, et me üritame teha sama tüüpi loop nagu ma just kirjeldasin. Meil oleks öelda int i = 0 enne silmus hakkab. Siis võiks öelda, et kui ma <10 tee seda, nii sama ploki koodi nagu enne, ja seekord uuendatud osa kood, näiteks i + +, tegelikult läheb sees silmus. Ja lõpuks ka teha, samas on see sarnane samas loop, kuid me peame meeles pidama, et kood hindab kord enne nõuet kontrollitakse, et ta teeb palju mõttekam kui te vaatate seda järjekorras ülevalt alla. Aastal teha samas loop koodi hindab enne kui isegi vaadata samas seisukorras, arvestades samas loop, siis kontrolli kõigepealt. Avaldused ja muutujad. Kui me tahame luua uue muutuja me esimest soovid vormindada see. Näiteks int baar käivitab muutuja baar, kuid see ei anna talle raha, siis millised on baar väärtus nüüd? Me ei tea. See võiks olla mingi prügi raha, mis varem salvestatud mälu seal, ja me ei taha seda kasutada muutuja kuni me tegelikult annab see väärtus, nii me kuulutada see siin. Siis me initsialiseerida see olema 42 allpool. Nüüd, muidugi, me teame seda saab teha ühel real, int baar = 42. Aga et asi selge oleks mitu sammu, mis toimub, deklaratsiooni ja initsialiseerimise toimuvad eraldi siin. See juhtub üks samm, ja järgmise, int Baz = baar + 1, Selle alljärgnev kinnitus, et kaupa Baz, nii lõpus see koodiestossa kui me printida väärtus Baz oleks 44 sest me kuulutame ja initsialiseerida see olema 1> baar, ja siis me juurdekasvu see veelkord + +. Käisime üle see päris lühidalt, aga see on hea, et on üldine mõista, mida niidid ja üritused. Meil peamiselt tegid seda Scratch, nii saab mõelda niidid mitu järjestused kood töötab samal ajal. Tegelikkuses see ilmselt ei tööta samal ajal, kuid omamoodi abstraktselt me ​​ei mõtle seda nii. Scratch, näiteks oli meil mitu haldjaid. Võiks täidesaatva erinevat koodi samal ajal. Võiks olla kõndides samal ajal kui teine ​​ütleb midagi teises osa ekraanist. Üritused on teine ​​viis eraldi välja loogika erinevate elementide oma koodi, ja Scratch suutsime simuleerida ürituste abil ülekanne, ja mis on tegelikult, kui saan, ei, kui kuulen, kuid sisuliselt on see võimalus edastada teavet ühest sprite teise. Näiteks võiksite edastada mängu üle, ja kui teise sprite saab mäng läbi, see reageerib teatud viisil. See on oluline mudeli mõista programmeerimisega. Lihtsalt minna üle põhilised Nädal 0, me oleme läinud üle siiani, Vaatame seda lihtsat C programm. Tekst võib olla natuke väike siit, kuid ma lähen üle ka kähku. Me sh 2 päisefaile ülaosas, cs50.h ja stdio.h. Me siis määratakse konstant nimega piir olema 100. Me seejärel rakendades meie peamine ülesanne. Kuna me ei kasuta käsurea argumente siin peame panema tühine kui argumente peamine. Me näeme int eespool peamine. See on naasmise tüüp, seega return 0 allosas. Ja me kasutame CS50 raamatukogu funktsiooni saada int küsida kasutaja sisend, ja me seda säilitada seda muutujat x, nii me kuulutame x eespool, ja me algväärtustamiseks x = GetInt. Siis vaadata, kui kasutaja andis meile hea sisend. Kui see on ≥ piirväärtus tahame tagasi veakood 1 ja veateadet. Ja lõpuks, kui kasutaja on andnud meile hea sisend me lähme ruutu arvu ja välja trükkida, et tulemus. Lihtsalt veenduge, et need kõik hit kodu näete siltide eri osade koodi siin. Mainisin pidev, päisefaile. Oh, int x. Veenduge meeles pidada, et on kohalik muutuja. See vastandub see globaalne muutuja, mida me räägime natuke hiljem läbivaatamine istungil ja kutsume raamatukogu funktsiooni printf, nii et kui me ei lisanud stdio.h päisefail me ei saaks helistada printf. Ja ma usun, nool, et sai ära lõigatud siin on suunaga% d, mis on vormingu stringi printf. Ta ütleb välja printida see muutuv number,% d. Ja see on see 0-nädalal. Nüüd Lucas läheb jätkuvalt. Hei, kutid. Minu nimi on Lucas. Ma olen üliõpilane parimal maja loengusse, Mather, ja ma lähen rääkida natuke umbes nädal 1 ja 2.1. [Nädal 1 ja 2.1!] [Lucas Freitas] Nagu Lexi ütlesin, kui me hakkasime tõlkides oma koodi nullist C Üks asi, mida me märganud, et sa ei saa lihtsalt kirjutada oma koodi ja kasutada seda kasutades roheline lipp enam. Tegelikult on teil kasutada mõningaid samme, et muuta oma C programmi saada käivitatava faili. Põhimõtteliselt, mida te teete, kui olete kirjalikult programm on, et teil tõlkida oma ideed keeles kompilaator aru saavad, Nii et kui olete kirjalikult programmi C mida sa teed on tegelikult kirjalikult midagi, et teie kompilaatori hakkab aru saama, ja siis kompilaator saab tõlkida, et kood millekski, mida arvuti saab aru. Ja asi on, arvuti on tegelikult väga loll. Arvuti saab aru ainult 0. ja 1s, nii tegelikult esimeses arvutid inimesed tavaliselt programmeeritud kasutades 0. ja 1s, kuid mitte enam, jumal tänatud. Meil ei ole vaja meeles järjestused 0. ja 1s jaoks jaoks silmus või samas loop ja nii edasi. Sellepärast on meil kompilaator. Mis kompilaator ei ole see sisuliselt tähendab C-koodi, meie puhul on keel, et arvuti aru, mis on objekti kood, ja kompilaator, mida me kasutame nimetatakse rõkkama, et see on tegelikult sümbol rõkkama. Kui olete oma programmi, mida sa pead tegema 2 asja. Esiteks, sa pead koguma oma programmi, ja siis sa lähed sõitma oma programmi. Kompileerida programm teil on palju võimalusi seda teha. Esimene neist on teha rõkkama program.c kus programm on oma programmi nime. Sel juhul näete nad lihtsalt öeldes: "Hei, koostada oma tööprogrammi." Sa ei ütle "ma tahan seda nime minu programm" või midagi. Teine võimalus on anda nime oma programmi. Võite öelda rõkkama-o ja siis nimi, mida soovite käivitatava faili nimeks ja siis program.c. Ja saate ka teha teha programm, ja näha, kuidas esimesel 2 juhtumit Panin. C ja kolmas mul on ainult programme? Jah, sa tegelikult ei tohiks panna. C, kui te kasutate teha. Vastasel koostaja on tegelikult läheb kisa sind. Ja ka, ma ei tea kas te mäletate, kuid palju kordi me ka kasutatud-lcs50 või-lm. Seda nimetatakse siduda. See lihtsalt ütleb kompilaator, et te kasutate neid raamatukogudes seal, nii et kui soovite kasutada cs50.h sa tegelikult pead kirjutama rõkkama program.c-lcs50. Kui te ei tee seda, tõlkija ei kavatse teada et te kasutate neid funktsioone cs50.h. Ja kui soovite käivitada oma programmi teil on 2 võimalust. Kui sa ei rõkkama program.c te ei andnud nime oma programmi. Sa pead käivitada kasutades. / A.out. A.out on standard nime rõkkama annab oma programmi, kui sa ei anna talle nimi. Muidu sa lähed tegema. / Programm, kui sa andsid nime oma programmi, ja ka siis kui sa ei tee programmi nimi, et programm ei hakka juba läheb programmeerida sama nimega c fail. Siis me rääkisime andmetüübid ja andmed. Põhimõtteliselt andmetüübid on sama asi nagu kastikesed nad kasutavad salvestada väärtusi, nii andmetüübid on tegelikult nagu pokemons. Nad tulevad kõik suurused ja tüübid. Ma ei tea, kas see analoogia on mõtet. Andmete suurus tegelikult sõltub masina arhitektuuri. Kõik andmed suurused, et ma lähen näitan siin on tegelikult 32-bit masin, mis on nii meie seade, aga kui sul on tegelikult kodeerimine Mac või Windows ka ilmselt sa lähed on 64-bitine masin, nii et pea meeles, et andmed suurused, et ma lähen näitan siin on mõeldud 32-bit masin. Esimene, mida me nägime oli keskmine, mis on üsna lihtne. Sa kasutad int salvestada täisarv. Me nägime ka iseloomu, char. Kui soovite kasutada kirja või vähe sümbol oled ilmselt ei kavatse kasutada char. Char on 1 bait, mis tähendab 8 bitti, nagu Lexi ütles. Põhimõtteliselt on meil ASCII tabel, mis on 256 võimalikke kombinatsioone 0. ja 1s, ja siis kui kirjutad char see saab tõlkida märk, et sisendite te arv, et teil on ASCII tabelis, nagu Lexi ütles. Meil on ka ujuki, mida me kasutame, et salvestada kümnendkraadides. Kui soovite valida 3.14, näiteks, sa lähed kasutada float või topelt, mis on rohkem täpsust. Ujuk on 4 baiti. Topelt on 8 baiti, seega ainus erinevus on täpsus. Meil on ka pikk, et kasutatakse täisarvud, ja näete 32-bit masin int ja pikk olema sama suurusega, nii see ei ole tõesti mõtet kasutada pika 32-bit masin. Aga kui te kasutate Mac ja 64-bit masin, tegelikult pikk on suurus 8, nii see tõesti sõltub arhitektuur. Sest 32-bit masin see ei ole mõtet kasutada pika tõesti. Ja siis pikk pikk, teiselt poolt, on 8 baiti, nii et see on väga hea, kui sa tahad olla enam täisarv. Ja lõpuks on meil string, mis on tegelikult char *, mis on viit char. See on väga lihtne mõelda, et suurus string saab olema nagu arvu märke, et teil on seal, kuid tegelikult char * ise on suurus kursor char, mis on 4 baiti. Suurus char * on 4 baiti. Ei ole oluline, kui teil on väike sõna või kirja või midagi. See saab olema 4 baiti. Samuti oleme õppinud natuke valu, nii nagu näete, kui teil on näiteks programm, mis ütleb, int x = 3 ja siis printf ("% d", x / 2) Kas te teate, mida see saab printida ekraanil? Keegi? >> [Õpilased] 2. 1. >> 1, jah. Kui te seda teete 02/03 see läheb aina 1.5 aga kuna me kasutame täisarv see läheb mööda komakohti, ja sa lähed on 1. Kui te ei taha, et juhtuma, mida saate teha, näiteks on kuulutada float y = x. Siis x, mis varem 3 nüüd saab olema 3,000 y. Ja siis saate printida y / 2. Tegelikult, ma peaks olema 2. seal. See saab teha 3.00/2.00, ja sa lähed, et saada 1.5. Ja meil on see .2 f lihtsalt küsida 2 kohta pärast üksuste komakohti. Kui teil on .3 f see saab olema tegelikult 1,500. Kui see on 2 see saab olema 1.50. Meil on ka antud juhul siin. Kui sa float x = 3.14 ja siis printf x sa lähed, et saada 3.14. Ja kui sa x = int x, mis tähendab raviks x kui int ja printida x nüüd sa lähed on 3.00. Kas see on loogiline? Sest sa kõigepealt puhastada x on täisarv, nii olete ignoreerides komakohti, ja siis te prindite x. Ja lõpuks, saate ka seda teha, int x = 65 ja siis kuulutada char c = x, ja siis, kui prindite c sa tegelikult hakka , Nii et põhimõtteliselt mida sa teed siin tõlgib täisarv sisse iseloomu, nagu ASCII tabel teeb. Rääkisime veel matemaatika ettevõtjad. Enamik neist on üsna lihtne, nii +, -, *, /, ja ka me rääkisime mod, mis on ülejäänud jaotus 2 numbrit. Kui sul on 10% 3 näiteks see tähendab, jagage: 10 3, ja mis on ülejäänud? See saab olema 1, nii et see on tegelikult väga kasulik palju programme. Sest Vigenère ja Caesar Ma olen päris kindel, et kõik kutid kasutada mod. Umbes matemaatika ettevõtjad, olema väga ettevaatlik, kui kombineerida * ja /. Näiteks, kui sul (3/2) * 2 Mida sa hakka? [Õpilased] 2. Jah, 2, sest 02/03 saab olema 1.5, aga kuna sa teed operatsioonide vahel 2 täisarvud sa oled tegelikult lihtsalt läheb kaaluda 1 ja siis 1 * 2 saab olema 2, et olla väga ettevaatlik kui teed aritmeetiline täisarvud, sest võite saada, et 2 = 3, sel juhul. Ja ka olema väga ettevaatlik tähtsam. Sa peaksid tavaliselt kasutada sulge, et olla kindel, et sa tead, mida sa teed. Mõned kasulikud otseteed, muidugi, üks on i + + või i + = 1 või kasutades + =. See on sama asi nagu teeme i = i + 1. Võite teha ka i - või I - = 1, mis on sama asi nagu ma = i -1, midagi, mida poisid kasutavad palju eest silmuseid, vähemalt. Samuti jaoks *, kui te kasutate * = ja kui te seda teete, näiteks i * = 2 on sama asi nagu öeldes i = i * 2, ja sama asja rajoon. Kui te seda teete i / = 2 see on sama asi nagu ma = i / 2. Nüüd umbes funktsioone. Te teada, et funktsioonid on väga hea strateegia säästa kood kui oled programmeerimine, nii et kui sa tahad seda ülesannet täita aastal kood uuesti ja uuesti, ilmselt soovite kasutada funktsiooni lihtsalt, et sa ei pea kopeeri ja kleebi kood ikka ja jälle. Tegelikult peamine on funktsioon, ja kui ma näitan sulle vormi funktsioon sa lähed, et näha, et see on päris selge. Samuti kasutame funktsioone mõned raamatukogud, näiteks printf, Getin, mis on pärit CS50 raamatukogu, ja muid funktsioone nagu toupper. Kõik need funktsioonid on tegelikult rakendatakse teiste raamatukogude, ja kui paned need lõastama faili alguses oma programmi sa räägid kas te saaksite mulle anda kood neid funktsioone nii et ma ei pea neid rakendama ise? Ja sa võid ka kirjutada oma funktsioone, nii et kui hakkate programmi sa mõistad, et raamatukogud ei ole kõiki funktsioone, mida vajate. Viimase pset, näiteks me kirjutas joonistada, rüselus ja lookup, ja see on väga oluline, et oleks võimalik kirjutada funktsioone sest nad on kasulikud, ja me kasutame neid kogu aeg programmeerimine, ja see säästab palju koodi. Vormi funktsioon on see üks. Meil on naasmise tüüp alguses. Mis on naasmise tüüp? See on lihtsalt, kui teie ülesanne läheb tagasi. Kui teil on funktsioon, näiteks faktoriaali, et läheb arvutada faktoriaali täisarv, ilmselt see läheb tagasi täisarv ka. Siis tagastab tüüp saab olema int. Printf tegelikult on tagasipöördumise tüüp tühine sest sa ei tule midagi. Sa lihtsalt printida asju ekraanil ja suitsetamisest funktsioon hiljem. Siis on funktsiooni nimi, mida saab valida. Sa peaksid olema vähe põhjendatud, nagu ei vali nime nagu xyz või nagu x2f. Proovige teha kuni nimi see on mõistlik. Näiteks, kui see on faktoriaal, ütleme faktoriaal. Kui see funktsioon, et saab teha midagi, name it juhtida. Ja siis on meil parameetrid, mida nimetatakse ka argumendid, mis on nagu vahendeid, et oma ülesannet vaja oma koodi ülesannet täita. Kui soovite arvutada faktoriaali arv Ilmselt peate arvu arvutada faktoriaali. Üks argument, et sa lähed on on arv ise. Ja siis see läheb midagi ja tagastab väärtuse lõpus kui see on tühine funktsioon. Vaatame näiteks. Kui ma tahan kirjutada funktsioon, mis võtab kõik numbrid array täisarvud, kõigepealt tagasi tüüp saab olema int sest mul on array täisarvud. Ja siis ma lähen on funktsiooni nimi nagu sumArray, ja siis ta vőtab massiiv ise, et int nums, ja siis pikkus array nii et ma tean, mitu numbrit mul summeerida. Siis on mul initsialiseerida muutuja nimega summa, näiteks 0, ja iga kord kui ma näen element massiivi Pean lisama, et see summa, nii et ma tegin jaoks silmus. Just nagu Lexi ütles, sa int i = 0, i 0, siis on see positiivne. Kui see on = 0, siis on see 0, ja kui see on <0, siis see on negatiivne. Ja teine ​​teeb kui teine, kui teine. Erinevus nende kahe vahel on, et see on tegelikult läheb kontrollida, kas> 0, <0 või = 0 kolm korda, nii et kui sul on number 2 näiteks, siis läheb siia tulla ja öelda if (x> 0), ja see saab öelda jah, et ma printida positiivne. Aga kuigi ma tean, et see on> 0 ja see ei kavatse olla 0 või <0 Ma lähen ikkagi teha, on see 0, see on <0, nii et ma olen tegelikult läheb sees IFS, et ma ei pea sest ma juba tean, et ta ei kavatse täita mis tahes nendest tingimustest. Oskan kasutada, kui teine, kui teine ​​avaldus. Sisuliselt ütleb, et kui x = 0 ma printida positiivne. Kui see ei ole, ma lähen ka testida. Kui see on 2 ei ma lähen seda tegema. Põhimõtteliselt kui mul oleks x = 2 siis ütleksin if (x> 0), jah, nii trüki. Nüüd, kui ma tean, et see on> 0 ja et ta vastab esimese kui Ma isegi ei kavatse joosta see kood. Kood jookseb kiiremini, tegelikult 3 korda kiiremini, kui te kasutate seda. Meil on ka õppinud ja ja või. Ma ei lähe läbi, sest Lexi juba rääkinud neile. See on lihtsalt && ja | | operaator. Ainuke asi, ma ütlen, on olla ettevaatlik, kui sul on 3 tingimustele. Kasuta sulgudes, sest see on väga segane, kui teil on seisund, ja veel üks või teine. Kasuta sulgudes lihtsalt olla kindel, et teie tingimustele mõtet sest sel juhul, näiteks, võite ette kujutada, et see võiks olla esimene tingimus ja üks või teine või 2 tingimuste kombineerida ja või kolmas, nii lihtsalt olla ettevaatlik. Ja lõpuks, me rääkisime lülitid. Lüliti on väga kasulik, kui teil on muutuv. Oletame, et teil on muutuja nagu n mis võib olla 0, 1 või 2, ja kõikide nimetatud juhtudel sa lähed ülesande täitmiseks. Võite öelda lüliti muutuja, ja see näitab, et väärtus siis on nagu väärtus1 ma lähen seda teed, ja siis ma murda, mis tähendab, et ma ei kavatse vaadata mõne juhtudel sest me juba veendunud, et juhul ja siis väärtus2 ja nii edasi, ja ma ka ei ole vaikimisi sisse. See tähendab, et kui ta ei vasta ühele juhtudest, et mul oli et ma teen midagi, kuid see on vabatahtlik. See on kõik minu jaoks. Nüüd aga on Tommy. Olgu, see saab olema 3. nädal-ish. Need on mõned teemad, saadame katab, krüpto, ulatus, massiivid jne. Lihtsalt kiire sõna krüpto. Me ei lähe taguma seda kodus. Me tegime seda pset 2, kuid viktoriini veenduge, sa tead erinevus vahel Caesar salakiri ja Vigenère salakiri, kuidas need mõlemad ciphers töö ja mida ta on nagu krüptida ja dekrüpteerimiseks tekst, kasutades neid 2 ciphers. Pea meeles, et Caesar salakiri lihtsalt pöörleb iga märk sama summa võrra, tagades sa mod mitmeid tähte tähestikus. Ja Vigenère salakiri, teiselt poolt, pöörleb iga märk erinev summa, nii et mitte öelda iga märgi pööramisel 3 Vigenère pöörlema ​​hakkab iga märk erinev summa olenevalt mõned märksõna kus iga täht märksõna moodustab ligikaudu teistsuguse summa pööramiseks selge teksti. Vaatame kõigepealt rääkida muutuja ulatust. Seal on 2 erinevat tüüpi muutujad. Meil on kohalikud muutujad, ja need hakkavad olema määratletud väljaspool peamist või väljaspool mis tahes funktsiooni või blokaad, ja need on kättesaadavad kõikjal oma programmi. Kui teil on funktsioon ja selle funktsioon on samas silmus suur globaalne muutuja on kättesaadav kõikjal. Kohaliku muutuja, teiselt poolt, on scoped koht, kus see on määratletud. Kui teil on funktsioon siin, näiteks, on meil see funktsioon g, ja sees g on muutuja siin nimetatakse y, ja see tähendab, et see on kohaliku muutuja. Isegi kui see muutuja on kutsutud y ja seda muutujat nimetatakse J Need 2 funktsioonid pole aimugi, mida üksteise kohalike muutujad. Teiselt poolt, siin me ütleme, int x = 5, ja see ei kuulu ühegi funktsiooni. See on väljapoole peamine, nii et see on globaalne muutuja. See tähendab, et sees nende 2 funktsiooni, kui ütlen x - või x + + Ma tutvumise sama x kusjuures see y ja see y on erinevaid muutujaid. See vahe on globaalne muutuja ja kohaliku muutuja. Niipalju kui disain on mures, mõnikord on ilmselt parem idee hoida muutujad kohalike kui te võimalik alates võttes kamp globaalsed muutujad saavad väga segane. Kui teil on hunnik funktsioone kõik muutes sama asi võite unustada mis siis, kui see funktsioon kogemata muudab seda maailma, ja see teine ​​funktsioon ei tea seda, ja see ei saa päris segane nagu saad rohkem kood. Hoiame muutujad kohalike kui te võimalik on lihtsalt hea disain. Massiivid, pea meeles, on lihtsalt nimekirjade elemendid on sama tüüpi. Toas CI saa olla nimekiri nagu 1, 2.0, tere. Me lihtsalt ei saa seda teha. Kui me kuulutame massiivi C kõik elemendid olema sama tüüpi. Siin on mul massiivi 3 täisarvud. Siin on mul pikkus array, kuid kui ma lihtsalt tunnistada selles süntaks kus ma täpsustada, mis kõik elemendid on ma ei tehniliselt vaja see 3. Koostaja on piisavalt tark, et aru saada, kui suur massiiv peaks olema. Nüüd, kui ma tahan saada või seada väärtuse massiivi see on süntaks teha. See tegelikult muuta teise elemendi massiivist sest pidage meeles, numeratsioon algab 0, mitte 1. Kui ma tahan lugeda, et raha ma ei saa öelda midagi sellist int x = array [1]. Või kui ma tahan määrata, et väärtus, nagu ma siin teen, Võin öelda, massiiv [1] = 4. See aeg tutvumise elemente oma indeks või nende seisundit või kui nad on massiiv, ja et noteerimise alguspäeva 0. Saame ka massiive massiivid ja seda nimetatakse mitmemõõtmeline massiiv. Kui meil on mitmemõõtmeline array see tähendab, et meil on midagi ridade ja veergude ja see on lihtsalt üks viis visualiseerida seda või mõelda seda. Kui mul on mitmemõõtmeline array, mis tähendab, et ma lähen alustada vajavad rohkem kui 1 pealeht sest kui mul on võre lihtsalt ütlen, mida rida sul ei anna meile arv. See on tõesti lihtsalt läheb meile nimekirja numbreid. Oletame, et mul on see massiiv siin. Mul on massiiv nimega võrku, ja ma väidan et see on 2 rida ja 3 veergu, ja nii see on üks võimalus visualiseerida seda. Kui ma ütlen, ma tahan saada osa juures [1] [2] see tähendab, et kuna need on read ja alles seejärel veerud Ma lähen hüpata 1. RIDA kuna ma ütlesin 1. Siis ma lähen siia tulla kuni 2. veerus, ja ma lähen, et saada väärtus 6. Mõtet? Mitmemõõtmeline massiivid, pea meeles, on tehniliselt lihtsalt massiivi massiivid. Me võime olla massiive massiive massiivid. Me ei saa edasi minna, kuid tegelikult üks viis mõelda kuidas seda paigaldada ja mis toimub on visualiseerida seda aastal võre niimoodi. Kui võtame massiivid funktsioone, nad ei kavatse käituda natuke teisiti kui võtame regulaarselt muutujate funktsioonid nagu möödaminnes int või veepinnal. Kui me läbima int või char või mõni neist teistest andmetüüpidest me lihtsalt vaatasin kui funktsioon muudab muutuja väärtusega, et muutus ei kavatse propageerida üles et funktsiooni. Mis array, ning teiselt poolt, et juhtub. Kui ma mööda massiivi teatud funktsiooni ja selle funktsiooni muudab mõned elemendid, kui ma tulen tagasi üles funktsioon, mis nimetas seda minu massiiv on nüüd saab olema erinev, ja sõnavara, mis on massiivid on möödas, viidates, nagu me näha hiljem. See on seotud sellega, kuidas viiteid töö, kus need põhilised andmetüübid, teiselt poolt, on vastu võetud väärtus. Me ei mõtle, et kui koopia tegemine mõned muutuja ja siis möödaminnes koopia. Ei ole oluline, mida me teeme, et muutuja. Helistaja funktsioon ei ole teadlikud, et see oli muutunud. Massiivid on lihtsalt natuke erinev selles osas. Näiteks kui me just nägime, peamine on lihtsalt funktsioon mis võib võtta 2 argumendid. Esimene argument, et peamine ülesanne on argc või mitu argumenti, ja teine ​​argument on nn argv, ja need on tegelikud väärtused nendele argumentidele vastu. Oletame, et mul on programm nimega this.c, ja ma ütlen seda, ja ma lähen jooksma seda käsurida. Nüüd läbida mõned argumendid minu programm nimega seda, Ma võiks öelda midagi sellist. / See on CS 50. See on see, mida me ette kujutada David tegema iga päev terminalis. Aga nüüd peamine funktsioon sees, et programmi on need väärtused, nii argc on 4. See võib olla veidi segadusse, sest tegelikult me ​​ainult möödaminnes on CS 50. See on ainult 3. Kuid pidage meeles, et esimene osa argv või esimene argument on funktsiooni nimi ise. See tähendab, et meil on 4 asja siin, ja esimene element saab olema. / see. Ja see on esindatud string. Siis ülejäänud elemente, mida me tipitud pärast programmi nime. Nii nagu kõrvale, nagu me ilmselt nägi pset 2 meeles pidada, et string 50 ≠ täisarv 50. Nii et me ei saa öelda midagi sellist, "int x = argv 3." See on lihtsalt ei hakka mõtet, sest see on string, ja see on täisarv. Nii et kui soovite teisendada vahel 2, pidage meeles, et me ei kavatse on see maagiline funktsioon nimega atoi. See võtab stringi ja tagastab täisarvu esindatud sees, et string. Nii et lihtne viga teha edasi viktoriin, lihtsalt mõtlesin, et see on automaatselt õige tüüp. Aga lihtsalt tean, et need on alati stringe isegi kui string sisaldab ainult täisarv või iseloomu või sularahaga. Nüüd räägime sõiduaega. Kui meil on kõik need algoritmid, et teha kõik need hullud asjad, see muutub tõesti kasulik küsida: "Kui kaua võtab aega nende?" Me esindame et midagi nimetatakse asümptootilisest märke. Nii et see tähendab, et - noh, ütleme, et me anname oma algoritmi mõned tõesti, tõesti, tõesti suur panus. Tahame küsida, "Kui kaua see aega võtab? Mitu sammu kulub meie algoritm joosta funktsioonina suurusest sisend? " Nii et esimene viisil saame kirjeldada läbijooksuaeg on suur O. Ja see on meie halvima sõiduaega. Nii et kui me soovime sortida massiivi, ja me anname oma algoritm massiivi See on järjekorras, kui see peaks olema tõusvas järjestuses, et see saab olema halvimal juhul. See on meie ülemise aastal maksimaalne aeg meie algoritm võtab. Teiselt poolt, see Ω läheb kirjeldada parimal juhul sõiduaega. Nii et kui me anname juba sorteeritud massiivi sorteerimine algoritm, Kui kaua läheb aega, et sortida? Ja see on siis kirjeldab alampiiri sõiduaega. Nii et siin on vaid mõned sõnad, et kirjeldada mõningaid ühiseid töötab korda. Need on tõusvas järjekorras. Kiireim sõiduaega meil nimetatakse samaks. See tähendab, et ükskõik kui palju elemente me anname oma algoritm, ükskõik kui suur meie massiiv on, sorteerimine või teha kõik me teeme, et massiivi alati võtta sama palju aega. Nii saame esindada et lihtsalt koos 1, mis on konstantne. Samuti vaadeldi logaritmiline läbijooksuaeg. Nii et midagi binaarne otsing on logaritmiline, kus me lõigatud probleem pooleks iga kord ja siis asjad lihtsalt saada suurem sealt. Ja kui sa kunagi kirjutamise O tahes faktoriaal algoritm, siis ilmselt ei tohiks käsitleda seda kui oma päev tööd. Kui me võrdleme töötab korda on oluline meeles pidada neid asju. Nii et kui mul on algoritm, mis on O (n), ja keegi teine on algoritm O (2n) need on tegelikult asümptootiliselt samaväärne. Nii et kui me ette kujutame n olema suur arv nagu eleventy miljardit: nii et kui me võrrelda eleventy miljardi midagi eleventy miljardit + 3 äkki et 3 ei ole tegelikult teeb suur erinevus enam. Sellepärast me ei kavatse alustada kaaluda neid asju samaväärseks. Nii et asjad peaksid neid konstante siin, seal on 2 x seda, või lisades 3, need on vaid konstandid, ja need hakkavad langema üles. Nii et miks kõik 3 neist perspektiivis ajad on sama, mis öelda, et nad O (n). Samamoodi, kui meil on 2 muud perspektiivis korda oletame, et O (n ³ + 2n ²), võime lisada + N, + 7, ja siis on meil veel üks läbijooksuaeg see on lihtsalt O (n ³). Ka need on sama asi, sest need - need ei ole samad. Need on samad asjad, vabandust. Nii et need on samad, sest see n ³ läheb domineerima see 2n ². Mis ei ole sama asi on, kui me jooksime korda nagu O (n ³) ja O (n ²) sest see n ³ on palju suurem kui see n ². Nii et kui meil on eksponendid, äkki see hakkab tähtsust, aga kui me lihtsalt tegelevad tegureid nagu me oleme siin üleval, siis ei hakka üldse, kuna nad on lihtsalt kukub välja. Võtame pilk mõned algoritmid oleme näinud nii kaugele ja rääkida oma läbijooksuaeg. Esimene viis otsite arv nimekirjas, mida me nägime, oli lineaarne otsing. Ja rakendamiseks lineaarne otsing on super lihtne. Meil on lihtsalt nimekiri, ja me ei kavatse vaadata iga element nimekirja kuni leiame arvu me otsime. See tähendab, et halvimal juhul, seda O (n). Ja halvimal juhul siin võiks olla, kui element on viimane element, siis lineaarse otsing me peame vaatama iga element kuni jõuame viimane, et teada, et see oli tegelikult nimekirjas. Me ei saa lihtsalt loobuda pooleldi ja öelda: "See pole ilmselt olemas." Lineaarse otsing me peame vaatama kogu asi. Parimal juhul sõiduaega, teiselt poolt, on pidev sest parimal juhul element me otsime, on lihtsalt esimene nimekirjas. Nii see läheb meid täpselt 1 samm, ükskõik kui suur nimekiri on kui me otsime esimese elemendi iga kord. Nii et kui te otsite, pidage meeles, et see ei nõua, et meie nimekiri sorteeritakse. Sest me lihtsalt läheb üle vaatama iga element, ja see ei ole tegelikult küsimus Millises järjekorras need elemendid on paratamatu Arukam otsing algoritm on midagi binaarne otsing. Pea meeles, rakendamise Kahendotsingupuu on, kui sa lähed hoida vaadates keset nimekirja. Ja kuna me vaatleme keskel, nõuame, et nimekiri on järjestatud või muidu me ei tea, kus keskel on, ja me peame vaatama üle kogu nimekirja leida, ja siis sel hetkel me lihtsalt raiskame aega. Nii et kui meil on järjestatud nimekiri ja leiame keskel, me võrrelda keskel element me otsime. Kui see on liiga kõrge, siis me ei suuda unustada paremal pool sest me teame, et kui meie osa on juba liiga kõrge ja kõike paremal see element on isegi suurem, siis me ei pea vaatama enam. Kui teisest küljest, kui meie osa on liiga madal, me teame kõike vasakule, et element on ka liiga madal, nii see ei ole tõesti mõtet otsida seal kas. Nii, igal sammul ja iga kord kui me vaatame keskpunktis nimekirja, me ei kavatse lõigata meie probleem pooleks, sest äkki me teame terve hunnik numbreid, mis ei saa olla see, mida me otsime. Aastal pseudokoodi see välja midagi sellist, ja kuna me Lõikame nimekiri pooleks iga kord, meie halvima läbijooksuaeg hüppab lineaarne logaritmiline. Nii et äkki meil logi samme, et leida element nimekirja. Parimal juhul sõiduaega, kuigi on ikka konstantne sest nüüd, ütleme lihtsalt, et element me otsime, on alati täpselt keset esialgses nimekirjas. Nii saame kasvada meie nimekirjas nii suur kui tahame, kuid kui element me otsime on keskel, siis see on ainult kavatse võtta meile 1 samm. Nii et miks me O (log n) ja Ω (1) või pidev. Teeme reaalselt sõita Kahendotsingupuu selles nimekirjas. Ütleme, et me otsime element 164. Esimene asi, mida me ei kavatse teha, on leida keskpunktis selles nimekirjas. See lihtsalt nii juhtub, et keskpunktis alaneb nende vahel 2 numbrit, niiet lihtsalt suvaliselt öelda, iga kord keskpunktis jääb vahemikku 2 numbrit, olgem lihtsalt ümardada. Me lihtsalt vaja veenduda, et me seda teha igal sammul teed. Nii et me ümardada, ja me ei kavatse öelda, et 161 on keset meie nimekirjas. Nii et 161 <164, ja iga element vasakule 161 Samuti on <164, nii et me teame, et see ei aita meid üldse hakata otsima üle siin, sest element me otsime saa seal olla. Mida me teha saame, on meil võimalik lihtsalt unustada, et kogu vasak pool nimekirja, ja nüüd võetakse arvesse ainult vasakust 161 aastast. Nii et jällegi, see on keskpunktis; olgem lihtsalt ümardada. Nüüd 175 on liiga suur. Nii et me teame, et see ei hakka meid otsin siit või siit, nii et me saame lihtsalt visata see ära, ja lõpuks me tabas 164. Iga küsimustele Kahendotsingupuu? Liigume edasi läbi otsida juba sorteeritud nimekirja tegelikult võttes Arvuloend suvalises järjekorras ja teha seda nimekirja kasvavas järjekorras. Esimene algoritm me vaatasime kutsuti mull sorteerida. Ja see oleks lihtsam osa algoritme nägime. Mull sorteerida ütleb, et kui mõni 2 elementi sees nimekiri on kohatu, mis tähendab, et on olemas kõrgem number vasakul väiksem arv, siis me ei kavatse vahetada neid, sest see tähendab, et nimekiri on "Rohkem järjestatud", kui see oli enne. Ja me lihtsalt läheb jätkata seda protsessi uuesti ja uuesti ja uuesti kuni lõpuks elemendid sellist mulli nende õigesse asukohta ja meil on järjestatud nimekirja. Läbijooksuaeg selle saab olema O (n ²). Miks? Noh, sest halvimal juhul me viime iga element, ja me hakkame lõpuks võrreldes seda iga teine ​​element nimekirjas. Aga parimal juhul on meil juba järjestatud nimekirja, mull sorteerida on lihtsalt lähe läbi kui, ütleme "Ei. Mul ei teinud vahetuslepingud, nii et ma olen teinud." Nii et meil on parimal juhul sõiduaega Ω (n). Lähme sõitma mull sorteerida nimekirjas. Või Esiteks, ärgem lihtsalt pilk mõned pseudokoodi tõesti kiiresti. Me tahame öelda, et me tahame jälgida, iga iteratsiooni silmus, jälgima, kas me muutnud elemente. Nii et selle põhjuseks on, me ei kavatse peatuda, kui me ei ole vahetasid mingeid elemente. Nii et alguses meie silmus me ei vahetaks midagi, seega me ütleme, et on vale. Nüüd läheme läbi nimekirja ja võrrelge element I osa i + 1 ja kui see on nii, et on suurem number vasakul väiksem number, siis me lihtsalt läheb, et vahetada neid. Ja siis me lähme meeles pidada, et me vahetaks element. See tähendab, et me peame minema läbi nimekirja vähemalt 1 rohkem aega sest seisund, mille me lõpetasime on siis kogu nimekiri on juba sorteeritud, mis tähendab, et me ei ole teinud ühtegi vahetustehingud. Nii et miks meie seisund siin all on "samas kui mõned elemendid on vahetatud." Nii et nüüd lähme lihtsalt vaata seda töötab loendist. Mul on nimekiri 5,0,1,6,4. Mull sorteerida kavatseb alustada kogu tee vasakul, ja see saab võrrelda i elemente, nii 0 kuni i + 1, mis on element 1. See saab öelda, hästi 5> 0, kuid praegu 5 on vasakule, nii mul on vaja, et vahetada 5 ja 0. Kui ma vahetada neid, äkki ma saaksin selle erinevaid nimekirja. Nüüd 5> 1, seega me ei kavatse vahetada neid. 5 ei ole> 6, nii et me ei pea midagi tegema siin. Aga 6> 4, nii et me peame vahetama. Jällegi, me peame sõitma läbi kogu nimekiri lõpuks avastada et need on rikkis; me vahetada neid, ja siinkohal peame sõitma läbi nimekirja veel 1 kord veenduda, et kõik on oma järjekorras, ja siinkohal mull sorteerida on lõppenud. Erinev algoritm võtab mõned elemendid ja sorteerimine neist on valik omamoodi. Idee valik omamoodi on see, et me ei kavatse ehitada järjestatud osa loend 1 element korraga. Ja kuidas me teeme, mis on rajades vasakul segment nimekirja. Ja põhimõtteliselt, iga - iga samm, me viime väikseim element me oleme jätnud et ei ole järjestatud veel, ja me kavatseme liikuda see, et sorteerida segmendis. See tähendab, et peame pidevalt leida minimaalne sortimata element ja siis võtma, et minimaalne element ja swap see iganes vasemmanpuolimmaista element, mis ei järjestatud. Joosta aeg see saab olema O (n ²), sest halvimal juhul meil on vaja võrrelda iga element iga teine ​​element. Sest me ütleme, et kui hakkame vasakul pool nimekirjas, me vajame läbida kogu õige segmendi leida väikseim element. Ja siis jälle, me peame minema üle kogu õige segmendi ja käiks üle, et ikka ja jälle ja jälle. See saab olema n ². Me läheme pea jaoks silmus sees teise silmuse mis viitab n ². Parimal juhul mõtte, ütleme, et me anname seda juba järjestatud loetelu; me tegelikult ei tee midagi paremat kui n ². Kuna valik omamoodi on kuidagi võimalik teada, et minimaalne element on lihtsalt üks I juhtub olema vaadates. See ikka peab veenduma, et see on tegelikult minimaalsed. Ja ainus võimalus veendumaks, et see on minimaalne, kasutades seda algoritmi, on vaadata iga element uuesti. Nii et tõesti, kui annad talle - kui sa annad valik omamoodi juba järjestatud nimekirja, ta ei kavatse teha midagi paremat kui anda see nimekiri, mis ei ole järjestatud veel. Muide, kui see juhtub olema nii, et midagi on O (midagi) ja oomega midagi, saame lihtsalt öelda veel tabavalt, et see on θ midagi. Nii et kui sa näed, et tulla kuhugi, see on, mida see tähendab lihtsalt. Kui midagi on teeta n ², on nii suur O (n ²) ja Ω (n ²). Nii et parimal juhul ja halvimal juhul see ei tee vahet, algoritmi teeme sama asja iga kord. Nii et see on see, mida pseudokoodi valiku omamoodi võiks olla. Me põhiliselt ütlen, et ma tahan kinnitada, üle nimekirja vasakult paremale ja igal iteratsiooni silmus, ma lähen liikuda minimaalne element sellesse järjestatud osa nimekirjast. Ja kui ma liigutan midagi seal, ma ei ole kunagi vaja vaadata, et element uuesti. Sest niipea kui ma vahetada element vasakule segment nimekirja, on järjestatud sest me teeme kõike kasvavas järjekorras kasutades miinimummääradeks. Nii et me ütlesime, okei, me oleme positsioonis i, ja me peame vaatama kõiki elemente paremal i, et leida minimaalne. See tähendab, me tahame vaadata alates i + 1 aasta lõpuni nimekirja. Ja nüüd, kui element, mida me praegu vaadates on väiksem kui meie miinimum seni, mis pidage meeles, et me alustame miinimum maha lihtsalt olla mis iganes element me praegu; ma eeldada, et on minimaalne. Kui ma leian element, mis on väiksem, siis ma ütlen, ok, Noh, ma olen leidnud uue minimaalne. Ma mäletan, kui see miinimum oli. Nüüd, kui olen läbi käinud, et õigus sortimata segment, Võin öelda, et ma lähen vahetada minimaalse elemendi element, mis on positsioonil i. See saab üles ehitada oma nimekirja, minu järjestatud osa nimekirjast vasakult paremale, ja me ei ole kunagi vaja vaadata element uuesti, kui see on see osa. Kui oleme vahetasin ta. Nii et olgem joosta valik omamoodi selles nimekirjas. Sinine element siin saab olema I ja punane element saab olema minimaalne element. Nii et ma algab kõik viis vasakule nimekirjas, siis kell 5. Nüüd on vaja leida minimaalse sortimata element. Nii me ütleme 0 <5, 0 jääb minu uus miinimum. Aga ma ei saa lõpetada seal, sest kuigi me ei mõista, et 0 on kõige väiksemad, peame joosta iga muu elemendi nimekirja veenduda. Seega 1 on suurem, 6 on suurem, 4 on suurem. See tähendab, et pärast vaadates kõik need elemendid, olen määratud 0 on väikseim. Ma lähen, et vahetada 5 ja 0. Kui ma vahetada, et ma lähen, et saada uus nimekiri, ja ma tean, et ma ei ole kunagi vaja vaadata, et 0 taas sest kui olen vahetasid, siis ma olen järjestatud seda ja me oleme valmis. Nüüd see lihtsalt nii juhtub, et sinine osa on jälle 5 ja me peame vaatama, 1, 6 ja 4 kindlaks, et 1 on väikseim minimaalne element, nii me swap 1 ja 5. Jällegi, me peame vaatama - võrrelge 5 6 ja 4, ja me ei kavatse vahetada 4 ja 5, ning lõpuks võrrelda need 2 numbrit ja vahetada neid kuni saame meie järjestatud nimekirja. Iga küsimustele valik omamoodi? Okei. Liigume viimase teema siin, ja see on rekursioon. Rekursioon, pidage meeles, et see on tõesti meta asi, kus funktsioon korduvalt nimetab ennast. Nii et mingil hetkel, kui meie fuction on korduvalt nõudnud ise, seal peab olema mingi koht, kus me lõpetada helistab ise. Sest kui me seda ei tee, siis me lihtsalt jätkan seda teha igavesti, ja meie programm on lihtsalt ei hakka lõpetada. Me nimetame seda tingimust tugipunkti. Ja tugipunkti ütleb, mitte helistades funktsioon uuesti, Ma lähen tagasi mingi väärtus. Nii et kui me oleme tagasi raha, me oleme lõpetanud helistaja ise, ja ülejäänud kõned oleme teinud seni ka tagasi. Vastupidine olukord aluseks on rekursiivne juhul. Ja see on see, kui me tahame võtta uue kõne funktsioon, mille me oleme praegu sisse Ja me ilmselt, kuigi mitte alati, tahavad kasutada erinevaid argumente. Nii et kui meil on funktsioon nimega f ja f just helistas võtta 1 argument, ja me muudkui helistades f (1), f (1), f (1), ja see lihtsalt nii juhtub, et argument 1 kuulub rekursiivne juhul me veel kunagi lõpetada. Isegi kui meil on alust juhul, me peame tagama, et lõpuks me ei kavatse tabanud, et tugipunkti. Me ei ole lihtsalt hoida viibiv see rekursiivne juhul. Üldiselt, kui me nimetame end, me ilmselt läheb on erinev argument iga kord. Siin on tõesti lihtne rekursiivne funktsioon. Nii et see arvutab faktoriaali arv. Up üles siin oleme meie tugipunkt. Juhul kui n ≤ 1, me ei kavatse helistada faktoriaal uuesti. Me läheme lõpetada; me lihtsalt läheb tagasi mingi väärtus. Kui see ei ole tõsi, siis me ei kavatse tabanud meie rekursiivne puhul. Teade siin, et me ei ole just kutsudes faktoriaal (n), sest see ei oleks väga kasulik. Me läheme helistada faktoriaali midagi muud. Ja nii näete, lõpuks kui võtame faktoriaal (5) või midagi, me ei kavatse helistada faktoriaal (4) ja nii edasi, ja lõpuks me ei kavatse tabanud nimetatud aluspõhimõtted. Nii et see näeb hea välja. Vaatame, mis juhtub, kui me tegelikult teha selle. See on pinu, ja oletame, et peamine läheb nimetame seda funktsiooni argument (4). Nii et kui faktoriaali näeb ja = 4 faktoriaal helistab ise. Nüüd äkki on meil faktoriaal (3). Nii et need funktsioonid ei kavatse hoida kasvab kuni lõpuks me tabanud meie tugipunkt. Sel hetkel, tagastatav väärtus on see tagasi (nx tagastatav väärtus seda), tagastatav väärtus on nx tagastatav väärtus seda. Lõpuks peame tabanud mõned number. Ülaosas siin, ütleme return 1. See tähendab, et kui me tagasi, et number, saame pop see ära pinu. Nii et see faktoriaal (1) on tehtud. Kui 1 tagastab selle faktoriaal (1) naaseb, see tagasipöördumine 1. Tagastatav väärtus see, pidage meeles, oli nx tagastatav väärtus seda. Nii et äkki see mees teab, et ma tahan tagasi 2. Seega pidage meeles, tagastatav väärtus on see lihtsalt nx tagastatav väärtus siin. Nüüd saame öelda 3 x 2, ja lõpuks, siin saame öelda see on lihtsalt saab olema 4 x 3 x 2. Ja kui see naaseb, me pikali üks täisarv sees peamine. Iga küsimustele rekursioon? Hea küll. Nii et seal on rohkem aega küsimuste lõpus, kuid nüüd Joseph katab ülejäänud teemad. [Joseph Ong] Olgu. Nüüd, et me rääkisime recursions, Räägime natuke mida ühendada sorteerida on. Merge omamoodi on põhimõtteliselt üks viis sorteerimine nimekirja numbreid. Ja kuidas see toimib on koos ühendamise omamoodi teil on loetelu, ja mida me teeme, on ütleme, olgem jagada see jagatakse 2 poolt. Me esietendus liita omamoodi jälle vasakul pool, siis me joosta liita omamoodi paremal pool, ja mis annab meile nüüd 2 poolt, mis on järjestatud ja nüüd me ei kavatse ühendada need pooleks kokku. See on natuke raske näha ilma näiteks nii me tekevinään ja vaata, mis juhtub. Nii et kui hakkate seda nimekirja, siis jagati see jagatakse 2 poolt. Me perspektiivis liita omamoodi vasakul poolel esimesena. Nii et vasakul pool ja nüüd võtame neid läbi selle nimekirja uuesti mis saab läks ühendamise sortida ja siis vaatame taas vasakul pool seda nimekirja ja võtame liita omamoodi ta. Nüüd pikali nimekirja 2 numbrit, ja nüüd vasakul pool on ainult 1 element pikk, ja me ei saa jagada loend, mis on ainult 1 element pooleks, nii me lihtsalt öelda, kui meil on 50, mis on vaid 1 element, see on juba järjestatud. Kui me ajanud, siis näeme, et me ei liikuda paremale poole sellest nimekirjast, ja 3 ka sorteeritud, ja nüüd nii, et mõlemad pooled selle nimekirja on järjestatud saame liituda need numbrid uuesti kokku. Nii et me vaatame 50 ja 3; 3 on väiksem kui 50, nii et see läheb esimesse ja siis 50 on sisse Nüüd on see tehtud; läheme tagasi kuni selle nimekirja sorteerida ning see on paremal pool. 42 on ta enda number, nii et see on juba järjestatud. Nii et nüüd me võrdleme neid 2 ja 3 on väiksem kui 42, nii et saab panna esmalt nüüd 42 saab panna, ja 50 saab panna sisse Nüüd, see on järjestatud me minna kogu tee tagasi tippu, 1337 ja 15. Noh, me nüüd vaatame vasakule poole sellest nimekirjast; 1337 on iseenesest nii see sorteeritakse ja sama 15. Nüüd me ühendame need 2 numbrit sorteerida, et esialgses nimekirjas, 15 <1337, nii läheb see esimene, siis 1337 läheb sisse Ja nüüd me järjestatud nii poolitatud esialgses nimekirjas üles tippu. Ja kõik me peame tegema, on ühendada need. Me vaatame esimesed 2 numbrit sellest lehest, 3 <15, siis see läheb omamoodi massiivi esimene. 15 <42, nii et see läheb sisse Nüüd, 42 <1337, mis läheb sisse 50 <1337, nii see läheb sisse Ja märkate, et me lihtsalt võttis 2 numbrit välja selle nimekirja. Nii et me ei ole just vaheldumisi 2 on loetletud. Me lihtsalt otsin alguses, ja me võtame osa mis on väiksemad ja siis paneb see meie massiivi. Nüüd oleme ühinenud kõik pooleks ja me oleme valmis. Küsimusi ühendada sorteerida? Jah? [Student] Kui see on osadeks jaotamine eri rühmadesse, miks ei ole nad lihtsalt jagada seda üks kord ja sul on 3 ja 2 grupiga? [Välis küsimus arusaamatult] Põhjus - nii on küsimus selles, miks me ei võiks lihtsalt ühendada neid, et esimene samm pärast meil on neid? Põhjus, miks me seda teha, alustage kõige vasakpoolsemad elemente mõlemalt poolt, ja siis võta väiksemat ja pane see, et me teame, et need üksikute nimekirjad on järjestatud tellimusi. Nii et kui ma vaatan vasemmanpuolimmaista elemente nii pooleks, Ma tean, et nad ei kavatse olla väiksemad elemendid need nimekirjad. Ma võin neid ellu väikseim element täpid selle suure nimekirja. Teiselt poolt, kui ma vaatan neid 2 on loetletud teises tasandil seal, 50, 3, 42, 1337 ja 15, need on sorteerimata. Nii et kui ma vaatan 50 ja 1337, ma panen 50 minu nimekirjas esimene. Aga see ei ole tegelikult mõtet, sest 3 on väikseim element välja kõik need. Nii et ainus põhjus, miks me seda teha ühendades samm on, sest meie nimekirjad on juba järjestatud. Mistõttu me peame maha kõik viis põhjas sest kui meil on lihtsalt ühe numbri, sa tead, et üks number ja iseenesest on juba järjestatud nimekirja. Kas on küsimusi? Ei? Keerukus? Noh, näete, et iga samm seal lõpus numbrid, ja saame jagada nimekirja pooleks log n korda, mis on koht, kus saame seda n x log n keerukus. Ja näete parimal juhul ühendamise sorteerida on n log n, ja see just nii juhtub et halvimal juhul või Ω seal on ka n log n. Midagi meeles pidada. Liikudes edasi, lähme edasi mõned superpõhiõiguseks faili I / O. Kui sa vaatasid rüselus, märkad meil oli mingisugune süsteem kuhu võiks kirjutada logifaili kui sa loed läbi koodi. Vaatame, kuidas sa võiksid seda teha. Noh, meil on fprintf, mis sa ei mõtle nagu lihtsalt printf, vaid lihtsalt faili printimiseks asemel, ja seega f alguses. Selline kood siia üles, mida ta teeb, nagu te olete näinud ka rüselus, see läheb läbi oma 2-mõõtmeline massiiv trüki välja rida-realt mis numbrid on. Sel juhul printf prindib välja oma terminali või mida me kutsume standardväljundisse punkti. Ja nüüd, sel juhul kõik me peame tegema, on asendada printf koos fprintf, öelge mida fail, mida soovite printida, ja sel juhul lihtsalt trükib välja selle faili selle asemel et lasta välja trükkida oma terminal. Noh, siis tekib küsimus: Kui me saame sellist faili, eks? Me sooritanud sisse see fprintf fuction kuid meil polnud aimugi, kus see tuli. Noh, alguses kood, mis meil oli, oli see patakas kood siia, mis põhimõtteliselt ütleb, et avatud fail nõuab log.txt. Mida me teeme pärast seda on meil veenduda, et fail on tegelikult avati edukalt. Seega ei pruugi ühtida Mitmetel põhjustel; teil ei ole piisavalt ruumi arvutis, näiteks. Nii see on alati oluline enne kui teha mingeid toiminguid failiga et me kontrollime, kas see fail avati edukalt. Mis siis, et see on argument, et fopen, noh, me avada faili mitmeti. Mida me saame teha on, me edastame selle w, mis tähendab alistada faili, kui see väljub juba, Me ei liigu, mis nad lisab faili lõppu asemel ülekaaluka see, või saame määrata r, mis tähendab, lähme avage fail ainult lugemiseks. Nii et kui programm püüab teha muudatusi faili, karju neid ja ei lase neil seda teha. Lõpuks, kui me teinud failiga, Valmis teevad operatsioone see, me peame tagama, me sulgeda fail. Ja nii lõpuks oma programmi, te ei kavatse anda need uuesti Selle faili avanud, ja kohe sulgeda. Nii et see on midagi olulist, et sa pead veenduge, et te teete. Seega pidage meeles, saate avada faili, siis võite kirjutada faili teha toiminguid faili, kuid siis sa pead sulgeda fail lõpus. Kõik küsimused üldiste faili I / O? Jah? [Student küsimus, arusaamatult] Siinsamas. Küsimus on selles, kus ei see log.txt faili ilmuvad? Noh, kui sa lihtsalt anna see log.txt, loob see samas kataloogis käivitatav. Nii et kui Sa - >> [Student küsimus, arusaamatult] Jah. Samas kaustas, või samas kataloogis, nagu sa seda nimetad. Nüüd mälu, korstnat ning hunnik. Niisiis, kuidas on mälu sätestatud arvuti? Noh, te võite ette kujutada mälu omamoodi seda plokki siin. Ja mälu on meil, mida nimetatakse hunnik ummikus seal ja korstna et seal all. Ja hunnik kasvab allapoole ja korstna kasvab ülespoole. Nii nagu Tommy mainitud - oh, hästi, ja meil on need teised 4 segmenti, mis ma saan teises - Nagu Tommy ütlesin, sa tead, kuidas oma ülesandeid nimetavad end ja kutsuvad üksteist? Nad püstitavad selline freimi. Noh, kui peamised kõned suva, suva saab panna virna. Foo nõuab, baar saada on panna virna, ja et saab panna virna pärast. Ja kui nad pöörduvad nad iga saada maha võetud pinu. Mida kõik need kohad ja mälu omada? Noh, top, mis on tekstiosa, sisaldab programm ise. Nii et masin kood, mis on seal, kui sa kompileerida programm. Järgmiseks tahes käivitub globaalsed muutujad. Nii et teil on globaalsed muutujad oma programmi, ja sa ütled nagu, = 5, et saab panna selle segmendi ja õigus all, et teil on uninitialized globaalsete andmete, mis on lihtsalt int, aga sa ei saa öelda, et see on võrdne midagi. Aru need on globaalsed muutujad, nii et nad on väljaspool peamist. Nii et see tähendab kõiki globaalseid muutujaid, mis on deklareeritud, kuid ei ole vormindatud. Mis siis on hunnik? Mälu eraldamisel kasutatakse malloc, mis me jõuame ka natuke. Ja lõpuks, kui pinu teil on lokaalsete muutujate ja kõik funktsioonid võite helistada igal oma parameetrid. Viimane asi, sa tõesti ei pea teadma, mida keskkonnamuutujaid teha, kuid kui sa jooksed programm, seal on midagi seotud, nagu see on isiku nimi, kes jooksis programm. Ja see saab olema omamoodi allosas. Seoses mälu aadressid, mis on kuueteistkümnendväärtused, väärtused ülaosas start kell 0, ja nad lähevad kõik viis alaserva. Sel juhul kui sa oled 32-bitine süsteem, aadress allosas saab olema 0x, millele järgneb automaatne teravustamine, sest see on 32 bitti, mis on 8 baiti, ja sel juhul 8 baiti vastab kuni 8 kuueteistkümnendarvudega. Nii et siin all sa lähed on, nagu, 0xffffff, ja seal sa lähed on 0. Millised on viiteid? Mõned teist ei katnud seda osa enne. kuid me ei lähe üle selle loengu, et osuti on lihtsalt andmetüüp mis kauplustes asemel mingi väärtus nagu 50, siis salvestab aadress mõned asukohta mälus. Nagu et mälu [arusaamatu]. Nii et antud juhul, mida meil on, meil on viit täisarv või int *, ja see sisaldab seda kuueteistkümnendsüsteemis aadress 0xDEADBEEF. Mis meil on, nüüd on see osuti osutab teatud asukohta mälus, ja see on lihtsalt, väärtus 50 on selles mälukohta. On mõned 32-bitised süsteemid, kõigi 32-bitiste süsteemide, viiteid asuda 32 bitti või 4 baiti. Aga näiteks 64-bitine süsteem, osuti on 64 bitti. Nii et see on midagi, mida sa tahad meeles pidada. Nii et lõpuks-bitine süsteem, osuti on lõpuks bitti pikk. Näiturid on omamoodi raske seedida ilma ekstra asju, nii lähme läbi näide dünaamiline mälu eraldamisel. Mis dünaamiline mälu eraldamise ei teile, või mida me kutsume malloc, see võimaldab teil eraldada mingi andmed väljaspool etteantud. Nii et see info on omamoodi püsivam ajaks programm. Sest nagu te teate, kui te deklareerite x sees funktsiooni, ja et tagastab funktsioon, sa ei pea enam juurdepääs andmetele, mis oli salvestatud x. Mis suunanäitajaks tehkem on nad andke meile salvestada mällu või kaupluse väärtused erinevas segmendis mälu, nimelt hunnik. Nüüd, kui me tagasi välja funktsioon, nii kaua kui meil on pointer selle asukohta mälus, siis mida me teha saame, on meil võimalik lihtsalt pilk väärtusi seal. Vaatame näiteks: See on meie mälu paigutus uuesti. Ja meil on see funktsioon, peamised. Mis see on - okei, nii lihtne, eks? - Int x = 5, see on lihtsalt muutuja korstnat peamine. Teiselt poolt, nüüd me kuulutame pointer, milles kutsutakse funktsioon giveMeThreeInts. Ja nüüd me läheme sinna see funktsioon ja me luua uue freimi ta. Kuid see freimi, me kuulutame int * temp, mis mallocs 3 täisarvud meile. Nii suurus int annab meile mitu baiti see int on, ja malloc annab meile, et paljud baiti ruumi hunnik. Nii et sel juhul oleme loonud piisavalt ruumi 3 täisarvud, ja hunnik on viis sinna, mistõttu ma olen ära, kõrgemal. Kui me oleme valmis, me tuleme tagasi siia, sa vaja ainult 3 ints tagasi, ja ta naaseb aadress, käesoleval juhul üle, kui et mälu on. Ja seadsime pointer = lüliti, ja seal on meil lihtsalt üks osuti. Aga mida see tagastab funktsioon on laotud siin ja kaob. Nii temp kaob, kuid me siiski säilitada aadress, kus need 3 täisarvud on sees vooluvõrku. Nii et selles komplektis, osuti on scoped kohalikke laotud raam, aga mälu, millele nad viitavad on hunnik. Kas see on loogiline? [Student] Kas te saaksite seda korrata? >> [Joseph] Jah. Nii et kui ma lähen tagasi natuke, näed, et temp eraldatud mõned mälu hunnik seal. Nii et kui see funktsioon, giveMeThreeInts naaseb, see korstna siin läheb kaduma. Ja see kõik muutujad, antud juhul see pointer, mis oli eraldatud laotud raam. See läheb kaduma, kuid kuna me tagasi temp ja seadsime pointer = temp, osuti on nüüd lähed juhtida sama mälu asukohta temp oli. Nüüd, kuigi me kaotame temp, et kohalikud pointer, me siiski säilitada mälu aadressi, mis see oli suunatud sissepoole selle muutuja pointer. Küsimused? See võib olla mingi segane teema, kui te ei ole läinud üle punktis. Saame, oma TF kindlasti minna sellest üle ja muidugi saame vastata küsimustele aasta lõpus läbivaatamise istungil selle eest. Aga see on omamoodi keeruline teema, ja mul on rohkem näiteid, et ei kavatse näidata üles mis aitab selgitada, mida osuti tegelikult on. Sel juhul osuti on samaväärne massiivid et ma saaks lihtsalt kasutada seda pointer kui sama asi nagu int massiiv. Nii et ma olen indekseerimise arvesse 0, ja muutes esimest täisarv 1, muutuvas teine ​​täisarv 2 ja 3. täisarv 3. Nii et rohkem viiteid. Noh, mäletate Binky. Sellisel juhul oleme eraldatud pointer, või me kuulutasime pointer, kuid esialgu, kui ma lihtsalt deklareeritud pointer, see ei osutades kuskil mälus. See on lihtsalt prügi väärtused sees on. Nii et ma ei tea, kus see osuti osutab. See on aadress, mis on lihtsalt täis 0-ja 1-ndatel, kus see algselt deklareeritud. Ma ei saa midagi teha selle kuni ma kutsun malloc peal ja siis see annab mulle vähe ruumi hunnik kus ma saan panna väärtused sees. Aga samas, ma ei tea, mis seal sees on see mälu. Nii et esimene asi, mida ma pean tegema, on vaadata, kas süsteem oli piisavalt mälu mulle tagasi 1 täisarv esiteks, mistõttu ma teen seda kontrollida. Kui osuti on null, mis tähendab, et tal ei ole piisavalt ruumi või mingi muu viga, nii et ma peaks väljuda mu programmi.  Aga kui see õnnestuks, nüüd ma saan kasutada, et osuti ja mida * pointer ei ole see järgmiselt kus aadress on et kui see väärtus on, ja see teeb ta võrdne 1. Nii siin, me uurime, kui et mälu olemas. Kui tead, see on olemas, võid panna sinna Mis väärtus, mida soovite pannakse ta, sel juhul 1. Kui me teinud seda, mida vaja vabastada, et osuti sest me peame minema tagasi süsteemi, mis mälu, et sa palusid esiteks. Kuna arvuti ei tea, kui me teinud seda. Sel juhul me selgesõnaliselt öelnud seda, okei, me oleme valmis selle mälu. Kui mõni teine ​​protsess seda vajab, mõni teine ​​programm seda vajab, võid vabalt minna ja võtta see. Mida saame teha ka ei saa me lihtsalt saada aadressile kohalike muutujate kogum. Nii int x on sees laotud raami peamine. Ja kui me kasutame seda ampersand see ja operaator, mida ta teeb on kulub x ja x on lihtsalt mõned andmed mällu, kuid see on aadress. See asub kuskil. Nii kutsudes & x, mida see teeb, on see annab meile aadressi x. Seda tehes teeme osuti punkti, kus x on mälu. Nüüd me lihtsalt ei midagi * x, me ei kavatse saada 5 tagasi. Star nimetatakse viite mahavõtmine ta. Sa järgige aadress ja sa saad väärtust see seal ladustatud. Kas on küsimusi? Jah? [Student] Kui sa ei tee 3-otsaga asi, see ikka kompileerida? Jah. Kui sa ei tee 3-pointer asi, see on ikka veel koostamisel, kuid ma näitan sulle, mis juhtub teist ja ilma tehes, see on, mida me nimetame mälu leke. Sa ei anna süsteem tagasi oma mälu, nii et mõne aja pärast programmi saab koguneda mälu, et see ei kasuta, ja ei midagi muud seda kasutada. Kui sa oled kunagi näinud Firefox 1,5 miljonit kilobaiti arvuti aastal Task Manager, mis on mis toimub. Sul on mälu leke programmis, et nad ei käitle. Niisiis, kuidas pointer aritmeetika toimib? Noh, pointer aritmeetika on omamoodi nagu indekseerimine massiivi. Sel juhul on mul pointer, ja mida ma teen on ma teha kursor punkti esimese osa Selle massiivi 3 täisarvud, et ma olen eraldatud. Nii et nüüd ma teen, täht osuti lihtsalt muutub esimene element nimekirjas. Star osuti +1 punkte siin. Nii et kursor asub siin, osuti +1 on siin, osuti 2 on siin. Nii lihtsalt lisada 1 on sama asi nagu liigub mööda seda massiivi. Mida me teeme on, kui me teeme pointer 1 saad aadress siia, ja selleks, et saada väärtus siin, paned täht alates kogu avaldis kuni dereference ta. Niisiis, sel juhul ma panen esimest asukohta selles massiivi 1 teine ​​asukoht 2 ja kolmandas kohas kuni 3. Siis mida ma teen siin on mul trükkimine meie osuti +1, mis lihtsalt annab mulle 2. Nüüd ma incrementing osuti, nii osuti võrdub osuti +1, mis liigub see edasi. Ja nii nüüd kui ma välja printida osuti +1, osuti +1 on nüüd 3, mis antud juhul prindib välja 3. Ja selleks, et tasuta midagi, pointer, et ma annan selle tuleb osutades alguses massiivi mille sain tagasi malloc. Niisiis, sel juhul kui ma kõne 3 siin, see ei ole õige, sest see on keset massiivi. Ma pean lahutama, et saada oma algsesse asukohta esialgse esimene spot enne kui ma võin vabastada ta. Nii, siin on rohkem kaasatud näiteks. Sel juhul me eraldades 7 sümbolit iseloomu massiivi. Ja sel juhul, mida me teeme on meil silmuspõletamise üle esimene neist 6, ja me milles neil Z. Niisiis, int i = 0, i> 6, i + +, Niisiis, pointer + i lihtsalt annab meile sel juhul, pointer, pointer +1, osuti +2, osuti +3, ja nii edasi ja nii edasi silmus. Mis see saab teha, on see läheb sellele aadressile, dereferences, et saada väärtus, ja muutusi, mis väärtust Z. Siis lõpus meenub see string, eks? Kõik stringid peavad lõppema null lõpetatakse märk. Niisiis, mida ma teen on osuti 6 panin null terminaator iseloomu sisse Ja nüüd, mida ma põhimõtteliselt teed siin rakendab printf jaoks string, eks? Seega, kui ei printf nüüd, kui ta on jõudnud string? Kui see tabab null lõpetatakse märk. Niisiis, sel juhul minu originaal osuti osutab alguses massiivi. Ma printida esimene märk välja. Ma seda üle ühe. Ma printida, et märk välja. Ma liigutada üle. Ja ma saan seda teha enne, kui ma jõuda lõppu. Ja nüüd lõpuks * pointer dereference see ja saada null lõpetatakse märk tagasi. Ja nii minu kui silmus jookseb ainult, et väärtus ei ole null lõpetatakse märk. Nii, nüüd ma väljuda see silmus. Ja nii kui ma lahutan 6 alates käesoleva pointer, Ma lähen tagasi kõik viis alguses. Pea meeles, et ma teen seda, sest ma pean minema algul, et vabastada ta. Niisiis, ma tean, et oli palju. Kas on küsimusi? Palun, jah? [Student küsimus arusaamatult] Kas oskate öelda, et valjem? Vabandust. [Student] Viimasel slaidil õigus enne vabanenud pointer, kus sa tegelikult muutuv väärtus pointer? [Joseph] Niisiis, siin. >> [Student] Oh, okei. [Joseph] Nii, mul on osuti miinus miinus, paremale, mis liigub asi võrra tagasi ja siis ma vaba ta, sest see pointer tuleb märkida, et alguses massiivi. [Student] Aga et ei oleks vaja olnud te lõpetasite pärast, et rida. [Joseph] Niisiis, kui ma poleks peatunud pärast seda, seda võiks pidada Mälulekke sest ma ei jooksnud tasuta. [Student] I [arusaamatu] pärast esimese kolme kuhu oli osuti 1 [arusaamatu]. [Joseph] Ja-jah. Niisiis, milline on küsimus olemas? Vabandust. Ei, ei. Mine, mine, palun. [Student] Niisiis, te ei muuda väärtus suunanäitajaks. Sa ei oleks pidanud tegema osuti miinus miinus. [Joseph] Jah, just. Niisiis, kui ma osuti +1 ja osuti +2, Ma ei tee pointer võrdub osuti +1. Niisiis, osuti lihtsalt jääb suunaga alguses massiivi. See on ainult siis, kui ma teen pluss pluss, et see seab väärtus tagasi sees osuti, et ta tegelikult liigub see mööda. Hea küll. Veel küsimusi? Jällegi, kui see on omamoodi suur, see kaetakse istung. Küsige oma õpetamise mehe about it, ja me võime vastata lõpus. Ja tavaliselt me ​​ei taha seda teha miinus asi. See on nõuda mind jälgida, kui palju ma olen kompenseerida massiiv. Nii et üldiselt see on lihtsalt selgitada, kuidas pointer aritmeetika töötab. Aga mida me tavaliselt tahaksin teha, on meile meeldib luua koopia pointer, ja siis me kasutame seda koopiat, kui me liigume ringi string. Niisiis, nendes Kui kasutate koopia printida kogu stringi, kuid me ei pea tegema nagu osuti miinus 6 või jälgida, kui palju me kolisime selles, lihtsalt sellepärast, et me teame, et meie algne mõte on ikka osutas alguses nimekirja ja kõik, mida me muuta oli see koopia. Nii et üldiselt muuda koopiad oma algse pointer. Ärge püüdke omamoodi nagu - ära muuda eksemplaris. Proovin muuta ainult koopiad oma originaal. Niisiis, te teate, kui võtame string printf sa ei pea panna täht ees on nagu me tegime kõigi teiste dereferences, eks? Niisiis, kui sa välja printida kogu string% s loodab on aadress, ja sel juhul osuti või antud juhul, nagu array tähemärki. Tegelased, char * s, ja massiivid on sama asi. Pointer on märki ja iseloomu massiivid on sama asi. Ja nii kõik me peame tegema, on läbida pointer. Me ei pea läbima nagu * pointer või midagi sellist. Niisiis, massiivid ja viiteid on sama asi. Kui sa teed midagi x [y] üle siin massiiv, mida ta teeb kapoti alla on ta ütleb, okei, see on märk massiiv, nii et see on osuti. Ja nii x on sama asi, ja mis siis see ei ole see lisab y x, mis on sama asi nagu liigub edasi mälu, et palju. Ja nüüd x + y annab meile mingi aadressi, ja me dereference aadress või Järgige noolt et kui see asukohta mälus on ja saame raha välja, et asukohta mälus. Nii, et need kaks on täpselt sama asi. See on lihtsalt süntaktiliste suhkur. Nad teevad sama asja. Nad on lihtsalt erinevad süntaktika teineteise jaoks. Niisiis, mis võib minna valesti viiteid? Nagu, väga palju. Okei. Niisiis, halbu asju. Mõned halvad asjad, mida saate teha ei kontrollida, kas teie malloc kõne tagastab null, eks? Sellisel juhul ma palun süsteem mulle - mis see number? Nagu 2 miljardit korda 4, sest suurus täisarv on 4 baiti. Ma küsin seda nagu 8 miljardit baiti. Muidugi minu arvuti ei kavatse olla võimeline andma mulle, et palju mälu tagasi. Ja me ei kontrollinud, kui see on null, nii et kui me püüame dereference see sinna - Järgige noolt, kus see läheb - me ei ole seda mälu. See on see, mida me nimetame viite mahavõtmine nullviida. Ja see sisuliselt põhjustab teile segfault. See on üks viis, kuidas saate segfault. Muud halbu asju, mida saate teha - oh well. See oli viite mahavõtmine nullviida. Okei. Muud halbu asju - noh, määrata, et sa lihtsalt panna kontrolli seal mis kontrollib, kas osuti on null ja väljuda programmist, kui juhtub, et malloc tagastab null pointer. See on XKCD koomiline. Inimesed mõistavad seda nüüd. Või midagi. Niisiis, mälu. Ja ma läksin üle selle. Me nimetame malloc tsüklina, kuid iga kord kui me kutsume malloc me kaotada jälgida, kui see osuti osutab, sest me clobbering ta. Niisiis, esimese kõne malloc annab mulle mälu siin. Minu kursor viiteid sellele. Nüüd ma ei vabastaks see, et nüüd ma kutsun malloc uuesti. Nüüd toob ta siia. Nüüd minu mälu on suunaga siia. Juhtides siin. Juhtides siin. Aga ma olen kaotanud jälgida, aadressid kõik mälu siin, et ma eraldatud. Ja nüüd ma ei pea ühtegi viidet neid enam. Niisiis, ma ei saa vabastada neid väljaspool seda ahela. Ja seda selleks, et määrata midagi sellist, kui te unustate vaba ja sa saad seda Mälulekke Sul on vaba mälu sees see silmus, kui olete teinud seda. Noh, see on, mis juhtub. Ma tean palju sa vihkad seda. Aga nüüd - jee! Sa saad nagu 44000 kilobaiti. Niisiis, sa vabastama selle aasta lõpus loop, ja mis läheb lihtsalt vaba mälu iga kord. Sisuliselt oma programmi ei ole mäluleke enam. Ja nüüd midagi, mida saate teha on vaba mõned mälu, et olete küsinud kaks korda. Sel juhul sa malloc midagi, muudad oma väärtust. You Tasuta ta kunagi, sest sa ütlesid, et sa olid teinud seda. Aga siis me vabanenud uuesti. See on midagi, mis on päris halb. Ta ei kavatse esialgu segfault, kuid mõne aja pärast, mida see on topelt vabastades see korrumpeerib oma hunnik struktuur, ja saate teada natuke rohkem sellest, kui otsustate võtta klassi nagu CS61. Aga põhiliselt mõne aja pärast arvuti ei hakka segi mida mälu kohad on, kus ja kui see on salvestatud - kus andmeid hoitakse mälus. Ja nii vabastades osuti kaks korda on halb asi, et sa ei taha seda teha. Muud asjad, mis võivad valesti minna ei kasuta sizeof. Niisiis, sel juhul te malloc 8 baiti, ja see on sama asi nagu kaks täisarvu, eks? Niisiis, see on täiesti ohutu, kuid see on? Noh, nagu Lucas rääkis erinevate arhitektuuride, täisarvud on erineva pikkusega. Niisiis, aparaat, et te kasutate, täisarvud on umbes 4 baiti, kuid mõnel teisel süsteemi nad võivad olla 8 baiti või nad võivad olla 16 baiti. Niisiis, kui ma lihtsalt kasutada seda numbrit siia, see programm võib töötada seadme kuid ta ei kavatse eraldada piisavalt mälu mõnel teisel süsteemi. Sel juhul on see, mida sizeof operaator kasutatakse. Kui me kutsume sizeof (int), mida see teeb, on  see annab meile suuruse täisarv süsteemi, et programm töötab. Niisiis, sel juhul, sizeof (int) naaseb 4 midagi seadme ja nüüd see tahe 4 * 2, mis on 8, mis on lihtsalt palju ruumi vaja kaks täisarvu. On erinevat süsteemi, kui int on nagu 16 baiti või 8 baiti, see lihtsalt läheb tagasi piisavalt baiti salvestada et summa. Ja lõpuks, structs. Niisiis, kui sa tahad säilitada sudoku pardal mälu, kuidas võiks seda teha? Võite mõelda nagu muutuja esimene asi, muutuja teine ​​asi, muutuja Kolmas asi, muutuja neljandat asi - halb, eks? Niisiis, üks paranemine saad teha peal seda on teha 9 x 9 rida. See on hea, aga kui sa tahad siduda muid asju koos sudoku pardal nagu mida on raske laual on, või näiteks, mida teie skoor on või kui palju aega see on võetud teil lahendada selle foorumi? Noh, mida saate teha, on saate luua struktuure. Mida ma põhimõtteliselt öelda on ma määratledes selle struktuuri üle siin, ja ma määratlemisel sudoku pardal, mis koosneb pardal, mis on 9 x 9. Ja mis see on see on viiteid nimi tasandil. Samuti on x ja y, mis on koordinaadid, kus ma olen praegu. Samuti on aega [arusaamatu], ja see on kokku käigud olen sisestanud nii kaugele. Ja nii sel juhul, ma ei saa rühmitada terve hunnik andmeid arvesse ainult üks struktuur selle asemel, et nagu ringi lendama nagu erinevaid muutujaid et ma ei saa tõesti jälgida. Ja see võimaldab meil on lihtsalt kena süntaks omamoodi viitamine erinevaid asju sees see struct. Ma ei lihtsalt ei board.board, ja ma saan sudoku pardal tagasi. Board.level, ma saan kui raske see on. Board.x ja board.y anna mulle koordinaadid, kus ma oleks pardal. Ja nii ma tutvumise mida me kutsume väljad struct. See määratleb sudokuBoard, mis on teatud tüüpi, et mul on. Ja nüüd me oleme siin. Mul on muutuja nimega "pardal"-tüüpi sudokuBoard. Ja nüüd ma ei pääse kõik väljad, mis moodustavad selle struktuuri üle siin. Küsimusi structs? Jah? [Student] Sest int x, y, sa deklareeritud nii ühes reas? >> [Joseph] Ja-jah. [Student] Niisiis, kas te võiksite lihtsalt teha, et neid kõiki? Sarnaselt x, y koma korda kokku? [Joseph] Jah, võid kindlasti teha, kuid põhjus panin x ja y samal joonel - ja küsimus on, miks me just seda samal joonel? Miks me lihtsalt ei pane kõiki neid samal real on x ja y on omavahel seotud, ja see on lihtsalt stilistiliselt õigem, mõnes mõttes sest see on rühmituse kaks asja samal joonel et nagu omamoodi seotud sama asi. Ja ma lihtsalt jagada need laiali. See on lihtsalt stiilis asi. See funktsionaalselt mingit vahet üldse. Muid küsimusi structs? Saate määrata Pokedex koos struktuure. Pokémon on mitmeid ja see on kirjas, omanik, tüüp. Ja siis kui sul on array Pokémon, mida saate teha kuni Pokedex, eks? Okei, lahe. Nii küsimustele structs. Need on seotud structs. Lõpuks GDB. Mis GDB lase sul teha? See võimaldab teil siluda oma programmi. Ja kui te ei ole kasutanud GDB, oleksin soovitatav vaadates lühike ja lihtsalt läheb üle, mida GDB on, kuidas te töötate koos sellega, kuidas te võite seda kasutada, ja testida seda programmi. Ja mis GDB saate teha, on see laseb paus [arusaamatu] oma programmi ja praktiline joon. Näiteks, ma tahan pausi täitmine on nagu rida 3 minu programm, ja kuigi ma olen rida 3 saan printida välja kõik väärtused, mis on seal. Ja nii me kutsume nagu pausid rida on me nimetame seda panna Katkestuspunkti et liin ja siis saame välja printida muutujad riik programmi sel ajal. Seejärel saame sealt sammu programmi kaudu rida-realt. Ja siis saame vaadata, millises seisukorras on virnas ajal. Ja seda selleks, et kasutada GDB, mida me teeme, on me kutsume rõkkama kohta C faili aga meil on edastada see-ggdb lipp. Ja kui me teinud, et me lihtsalt joosta gdb kohta saadud väljundfaili. Ja nii saad mõned nagu mass teksti niimoodi, aga tõesti kõik mida sa pead tegema, on tüüpi käske alguses. Break peamine paneb Katkestuspunkti peamine. Nimekiri 400 loetletakse rida koodi ümber liin 400. Ja nii sel juhul võid lihtsalt ringi vaadata ja öelda, oh, Ma tahan, et seada murdepunkti real 397, mis on sellel joonel, ja siis teie programm jookseb, et samm ja see läheb katki. See saab peatada seal, ja saad välja printida, näiteks väärtus on madal või kõrge. Ja nii on hunnik käske, mida pead teadma, ja see slideshow tõusevad veebilehel, nii et kui tahad lihtsalt viide neid vms panna neid oma cheat lehed, julgelt. Lahe. See oli viktoriin Review 0, ja me kinni umbes, kui teil on mingeid küsimusi. Hea küll.  [Aplaus] [CS50.TV]