[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 <pikkuse ja i + +.
Ja iga element massiivi tegin summa + = nums [i]
ja siis ma tagasi summa, nii et see on väga lihtne, ja see säästab palju koodi
kui te kasutate seda funktsiooni palju kordi.
Siis võtsin pilk tingimused.
Meil on, kui teine, ja teine, kui.
Vaatame, milline on erinevus nende vahel.
Heitke pilk nende 2-koodid. Mis on erinevus nende vahel?
Esimene on-põhiliselt koodid tahad sa öelda
kui number on +, -, või 0.
Esimene ütleb, kas see on> 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]