[Powered by Google Translate] [Arvostelu] [Quiz 0]
>> [Lexi Ross, Tommy MacWilliam, Lucas Freitas, Joseph Ong] [Harvardin yliopisto]
>> [Tämä on CS50.] [CS50.TV]
>> Hei, kaikki.
Tervetuloa tarkastelun istuntoon Quiz 0, joka tapahtuu tänä keskiviikkona.
Mitä me teemme tänään, olen 3 muuta TF,
ja yhdessä olemme menossa läpi katsaus mitä olemme tehneet aikana toistaiseksi.
Se ei tule olemaan 100% kattava, mutta se pitäisi antaa sinulle paremman käsityksen
mitä sinulla jo on alas ja mitä vielä tutkia ennen keskiviikkona.
Ja vapaasti nostaa käden kysymyksiä kuin menemme eteenpäin,
mutta pitää muistaa, että me myös vähän aikaa lopussa,
jos saamme läpi muutaman minuutin vara-tehdä yleisiin kysymyksiin,
niin pitää tämä mielessä, ja niin aiomme aloittaa alusta kanssa viikolla 0.
>> [Quiz 0 arvostelu!] [Part 0] [Lexi Ross] Mutta ennen kuin teemme, että puhutaanpa
logistiikka tietovisa.
>> [Logistics] [Tietovisa tapahtuu keskiviikkona 10/10 sijasta luento]
>> [(Katso http://cdn.cs50.net/2012/fall/quizzes/0/about0.pdf lisätietoja)] on keskiviikkona, Lokakuu 10th.
>> Se on tänä keskiviikkona, ja jos menet tätä URL täällä,
joka pääsee myös CS50.net-siellä linkki siihen,
näet tietoja minne mennä perustuvat
sukunimesi tai koulun kuuluminen sekä
Se kertoo, mitä Quiz kattaa sekä tyyppisiä kysymyksiä, että olet menossa.
Muista, että sinulla on myös mahdollisuus tarkistaa ja tietokilpailu jaksossa,
joten TF pitäisi mennä yli joitakin käytännön ongelmia,
ja se on toinen hyvä mahdollisuus nähdä, missä sinun pitää vielä opiskella varten tietokilpailu.
Aloitetaan alusta kanssa Bits 'n' Bytes.
Muista vähän on vain 0 tai 1,
ja tavu on kokoelma 8 näiden bittiä.
Katsotaanpa tämä kokoelma bittejä täällä.
Meidän pitäisi pystyä selvittää, kuinka monta bittiä on.
Jos me laskemme siellä on vain 8 niistä kahdeksan 0 tai 1 kpl.
Ja koska siellä on 8 bittiä, joka on 1 tavu,
ja mennään muuntaa sen heksadesimaalinen.
Heksadesimaali on pohja 16, ja se on melko helppo muuntaa
numeron binary, joka on mitä se on, että numero heksadesimaalimuodossa.
Kaikki mitä teemme on katsomme ryhmien 4,
ja me muuntaa ne sopivaan heksadesimaaliluku.
Aloitamme äärimmäisenä oikealla ryhmä 4, niin 0011.
Se tulee olemaan yksi 1 ja yksi 2, niin yhdessä joka tekee 3.
Ja sitten katsokaamme muut lohkon 4.
1101. Tämä tulee olemaan yksi 1, yksi 4 ja yksi 8.
Yhdessä, että tulee olemaan 13, mikä tekee D.
Ja me muistamme, että heksadesimaali emme vain mene 0 kautta 9.
Käymme 0 F, niin sen jälkeen 9, 10 vastaa,
11 B, jne. missä F on 15.
Tässä 13 on D,
niin muuntaa sen desimaalin kaikki mitä teemme on oikeastaan
Kohtelemme asema teho 2.
Se on yksi 1 yksi 2, nolla 4s, nolla 8s, yksi 16, jne.,
ja se on hieman vaikea laskea oman pään, mutta jos menemme seuraavaan diaan
Voimme nähdä vastauksen tuohon.
>> Pohjimmiltaan olemme menossa poikki oikealta takaisin vasemmalle,
ja me kertomalla kunkin numeron vastaavalla voimalla 2.
Ja muistakaa, heksadesimaaliluvussa merkitsemme näitä numeroita 0x alussa
joten älä sekoita sitä desimaaliluku.
Jatkuu, tämä on ASCII-taulukko,
ja mitä käytämme ASCII on kartan merkkejä numeerisia arvoja.
Muistakaa salakirjoituksessa PSET teimme laajaa käyttöä ASCII taulukon
voidakseen käyttää erilaisia ​​menetelmiä salaus,
Caesar ja Vigenère cipher, muuntaa eri kirjaimia
in merkkijono mukaan avain käyttäjän antamien.
Katsotaanpa hieman ASCII matematiikka.
Tarkasteltaessa P + 1, luonteeltaan muodossa olisi Q,
ja muista, että '5 '≠ 5.
Ja miten tarkalleen voisimme muuntaa nuo 2 lomakkeita?
Se ei ole oikeastaan ​​liian kova.
Jotta saat 5 vähennämme '0 '
koska on olemassa 5 paikkoja välillä '0 'ja '5. "
Jotta mennä toiseen suuntaan me vain lisätä 0,
joten se on tavallaan kuin säännöllistä aritmeettinen.
Vain muistaa, että kun jotain on lainausmerkkejä sen ympärille on merkki
ja näin ollen vastaa arvoa ASCII-taulukossa.
Muutto yleisempi tietojenkäsittelytiede aiheita.
Opimme mitä algoritmi on ja miten käytämme ohjelmointi
toteuttaa algoritmeja.
Joitakin esimerkkejä algoritmit ovat jotain todella yksinkertaisia, kuten
tarkistetaan, onko numero on parillinen tai pariton.
Tästä muistan me mod numero 2 ja tarkista jos tulos on 0.
Jos näin on, se on jopa. Jos ei, se on outoa.
Ja se on esimerkki todella perus algoritmi.
>> Vähän enemmän mukana yksi binäärihakupuu,
jonka me mennä yli myöhemmin tarkistaa istuntoon.
Ja ohjelmointi on termi käytämme ottaen algoritmin
ja muuntamalla se koodata tietokone voi lukea.
2 Esimerkkejä ohjelmointi on Scratch,
joka on mitä teimme Viikko 0.
Vaikka emme oikeastaan ​​kirjoita ulos koodin se tapa toteuttaa
Tämän algoritmin, joka tulostaa numerot 1-10,
ja täällä teemme sama C-ohjelmointikielellä.
Nämä ovat toiminnallisesti samanarvoisia, vain kirjoitettu eri kielillä tai syntaksia.
Sitten oppivat boolean ilmaisuja,
ja boolean on arvo, joka on joko tosi tai epätosi,
ja tässä Usein Boolen
mennä sisälle edellytykset, joten jos (x ≤ 5),
No, me jo x = 5, niin että ehto tulee arvioida todellista.
Ja jos se on totta, mitä koodi on alla ehto
aiotaan arvioida tietokoneella, niin että merkkijono aiotaan tulostaa
vakiotulosteeseen, ja termi kunnossa
viittaa mikä on sulkeiden sisällä, jos ilmoitus.
Muista kaikki toimijat.
Muistakaa se && ja | | kun yritämme yhdistää 2 tai useampia ehtoja,
== Ei = tarkistaa, onko 2 asiat ovat yhtä.
Muista, että = on tehtävä taas == on boolean operaattorin.
≤, ≥ ja sitten lopullinen 2 ovat itsestään selviä.
Yleinen katsaus Boolen logiikkaa täällä.
Ja boolean ilmaisut ovat myös tärkeitä silmukoita,
joka menemme ohi.
Opimme noin 3 tyyppisiä silmukoita toistaiseksi CS50 varten, kun taas, ja tehdä samalla.
Ja se on tärkeää tietää, että vaikka useimpiin tarkoituksiin
voimme itse käyttää mitä tahansa silmukan yleensä
olemassa tiettyjä tarkoituksia tai yhteisiä kuvioita
ohjelmatyössä että nimenomaan vaativat näistä silmukoista
jotka tekevät sen tehokkainta tai tyylikäs koodaamaan sitä sillä tavalla.
Mennään yli, mitä kukin näistä silmukoita yleensä käytetään useimmiten.
>> Vuonna varten silmukka me yleensä jo tietää, kuinka monta kertaa haluamme toistaa.
Sitähän me laittaa kunnossa.
Varten, i = 0, i <10, esimerkiksi.
Tiedämme jo, että haluamme tehdä jotain 10 kertaa.
Nyt, kun silmukka, yleensä emme välttämättä
tietää, kuinka monta kertaa me haluamme silmukan ajaa.
Mutta me tiedämme jonkinlainen edellytyksellä, että haluamme sen
aina totta tai aina väärä.
Esimerkiksi, kun on asetettu.
Sanotaan, että on Boolen muuttuja.
Vaikka se on totta haluamme koodin arvioida,
joten hieman enemmän laajeneva, hieman yleisempää kuin on silmukka,
mutta mitä tahansa for-silmukka voi myös muuntaa samalla silmukan.
Lopuksi, tehdä, kun silmukoita, jotka voivat olla hankalin ymmärtää heti,
käytetään usein, kun halutaan arvioida koodin ensimmäinen
ennen ensimmäistä kertaa tarkista kunnossa.
Yhteiseen käyttöön tapauksessa tehdä, kun silmukka
on kun haluat saada käyttäjä syöttää, ja tiedät haluat kysyä käyttäjälle
syötteen ainakin kerran, mutta jos he eivät anna sinulle hyvä syöttää heti
haluat pitää pyytää heitä kunnes he antavat sinulle hyvän tulon.
Se yleisin käyttö ei taas silmukka,
ja katsokaamme todellista rakennetta näiden silmukoita.
Ne yleensä aina taipumus seurata näitä kuvioita.
>> Käytössä on silmukan sisäpuolella sinulla on 3 osaa:
Alustuksen tyypillisesti jotain int i = 0, missä i on laskuri,
tila, jossa haluamme sanoa suorittaa tätä silmukka niin kauan kuin tämä ehto on edelleen voimassa
kuten i <10, ja sitten lopuksi, päivitys, joka on, miten kasvattaa
laskinmuuttuja jokaisessa vaiheessa silmukka.
Yhteinen asia nähdä siellä on vain i + +,
mikä tarkoittaa kasvattaa I 1 joka kerta.
Voit myös tehdä jotain i + = 2,
mikä tarkoittaa lisätään 2 i aina mennä läpi silmukan.
Ja sitten tehdä tämän vain tarkoittaa mitä tahansa koodia, joka todella toimii osana silmukan.
Ja vaikka silmukka, tällä kertaa meillä on todellakin alustuksen ulkopuolella silmukan,
niin esimerkiksi sanokaamme me yritämme tehdä samantyyppisiä kaareen juuri kuvattu.
Sanoisimme int i = 0 ennen silmukan alkua.
Silloin voisimme sanoa, kun i <10 tehdä tämän,
joten sama koodilohko kuin ennen,
ja tällä kertaa päivitys osa koodia, esimerkiksi i + +,
todellisuudessa menee sisälle silmukan.
Ja lopuksi tehdä samalla, se on samanlainen kun silmukka,
mutta meidän on muistettava, että koodi arvioi kerran
ennen ehdon täyttymistä valvotaan, joten se tekee paljon enemmän järkeä
jos tarkastellaan sitä luokkaa ylhäältä alas.
Vuonna do while-silmukka koodi arvioi ennen kuin edes katsomaan taas kunnossa,
taas kun silmukka, se tarkistaa ensin.
Lausunnot ja muuttujia.
Kun haluamme luoda uusi muuttuja haluamme ensin alustaa sen.
>> Esimerkiksi int baari alustaa muuttujan bar,
mutta se ei anna sitä arvoa, joten mikä on baarin arvo nyt?
Emme tiedä.
Se voisi olla joitakin roska-arvo, joka oli aiemmin tallennettu muistiin siellä,
ja emme halua käyttää tätä muuttujaa
kunnes me oikeastaan ​​antaa sille arvoa,
joten julistaa sen täällä.
Sitten alustaa sen olevan 42 alle.
Nythän me tiedämme tämä voidaan tehdä yhdellä rivillä, int bar = 42.
Mutta vain tehdä selväksi useita vaiheita, jotka ovat meneillään,
ilmoitus ja alustus tapahtuu tässä erikseen.
Se tapahtuu yksi askel, ja seuraava, int Baz = bar + 1,
Tässä lausumassa todetaan, että kerrallaan Baz, joten lopussa tämän koodieston
jos me tulostaa arvon Baz olisi 44
sillä me julistamme ja alustaa sen olevan 1> bar,
ja sitten kasvattaa sitä vielä kerran + +.
Meillä meni tässä melko lyhyesti, mutta se on hyvä olla yleistä
ymmärtää mitä kierteet ja tapahtumat ovat.
Olemme pääasiassa teki tämän Scratch,
joten voit ajatella viestiketjut moninkertaiset sekvenssit koodia
käynnissä samaan aikaan.
Tosiasiassa se luultavasti ei ole käynnissä samaan aikaan,
mutta tavallaan abstractly voimme ajatella sitä sillä tavalla.
>> Scratch Esimerkiksi meillä oli useita sprites.
Se voitaisiin suorittamalla eri koodi samaan aikaan.
Yksi voisi kävelet ja muut sanoo jotain
eri näytön osasta.
Tapahtumat ovat toinen tapa erottamista logiikka
eri osien koodisi,
ja Scratch pystyimme simuloida tapahtumia käyttäen Broadcast,
ja se on oikeastaan ​​kun saan, ei kun kuulen,
mutta pohjimmiltaan se on tapa välittää tietoa
yhdestä sprite toiseen.
Esimerkiksi, saatat haluta lähettää game over,
ja kun toinen sprite saa pelin aikana,
se vastaa tietyllä tavalla.
On tärkeää malli ymmärtää ohjelmoinnin.
Vain mennä yli perus Viikko 0, mitä olemme menneet yli niin pitkälle,
Katsotaanpa tätä yksinkertaista C-ohjelma.
Tekstin voi olla hieman pieni täältä, mutta menen aikana se todella nopeasti.
Olemme lukien 2 header tiedostoja yläosassa, cs50.h ja stdio.h.
Olemme sitten määritellään vakio nimeltään rajan olevan 100.
Olemme toteuttaa sitten meidän päätehtävä.
Koska emme käytä komentoriviargumentteja täällä meidän laittaa void
koska perustelut tärkein.
Näemme int edellä main. Se palautuva, joten palauta 0 alareunassa.
Ja käytämme CS50 kirjaston funktion saada int
pyytää käyttäjältä syötettä, ja me tallentaa sen tämän muuttujan x,
niin me julistamme x edellä, ja me alustaa se x = GetInt.
>> Me sitten tarkistaa onko käyttäjä antoi meille hyvän tulon.
Jos se on ≥ RAJA haluamme palauttaa virhekoodin 1 ja tulostaa virheilmoituksen.
Ja lopuksi, jos käyttäjä on antanut meille hyvän tulo
aiomme sovittaa numero ja tulostaa tämä tulos.
Vain varmista, että ne kaikki osui
näet tarroja eri osien koodi tähän.
Mainitsin vakio, header-tiedostot.
Voi, int x. Varmista muistaa, että on paikallinen muuttuja.
Joka eroaa sen globaali muuttuja, jonka me puhumme
hieman myöhemmin tarkistaa istuntoon,
ja pyydämme kirjaston funktion printf,
joten jos emme olisi mukana stdio.h otsikkotiedosto
emme voi soittaa printf.
Ja uskon nuolta katkesi täällä on osoittaa% d,
mikä on muotoilun merkkijono printf.
Se sanoo tulostaa tämän muuttujan numero,% d.
Ja tämä on se viikko 0.
Nyt Lucas tulee jatkumaan.
Hei, kaverit. Nimeni on Lucas.
Olen toisen vuoden opiskelija parhaiten talon kampuksella, Mather,
ja aion puhua hieman siitä Viikko 1 ja 2,1.
[Viikko 1 ja 2.1!] [Lucas Freitas]
Kuten Lexi sanoi, kun aloimme kääntää koodi tyhjästä C
yksi asioista, huomasimme, että et voi vain
kirjoita koodi ja aja se käyttäen vihreää lippua enää.
Oikeastaan, sinun täytyy käyttää joitakin toimia voit tehdä C-ohjelma
tullut suoritettavan tiedoston.
Periaatteessa mitä teet, kun olet kirjoittamassa ohjelmassa on, että
käännät ideasi kieli kääntäjä voi ymmärtää,
joten kun kirjoitat ohjelman C
mitä teet on todella kirjoittaa jotain, että kääntäjä tulee ymmärtää,
ja sitten kääntäjä on menossa kääntämään että koodia
jotain, että tietokone ymmärtää.
>> Ja asia on, tietokone on todella tyhmä.
Tietokone voi vain ymmärtää 0s ja 1s,
niin oikeastaan ​​ensimmäiset tietokoneet ihmiset yleensä ohjelmoitu
käyttäen 0s ja 1s, mutta ei enää, kiitos Jumalalle.
Meillä ei ole muistaa sekvenssit 0s ja 1s
ja for-silmukka tai kun silmukka ja niin edelleen.
Siksi meillä on kääntäjä.
Mitä kääntäjä tekee se pohjimmiltaan kääntää C-koodia,
meidän tapauksessamme, on kieli, että tietokone ymmärtää,
joka on kohdekoodin, ja kääntäjä, että käytämme
kutsutaan clang, joten tämä on todella symboli clang.
Kun sinulla on ohjelma, sinun täytyy tehdä 2 asioita.
Ensinnäkin, sinun täytyy kääntää ohjelma, ja sitten olet menossa ajaa ohjelmaa.
Voit kääntää ohjelma sinulla on paljon vaihtoehtoja tehdä niin.
Ensimmäinen on tehdä clang program.c
jossa ohjelmassa on nimi ohjelman.
Tällöin näet he vain sanovat "Hei, kääntää minun ohjelma."
Et sano "Haluan tämän nimen minun ohjelma" tai jotain.
>> Toinen vaihtoehto on antaa nimen omaan ohjelmaan.
Voit sanoa clang-o ja sitten haluamasi nimi
suoritettava tiedosto nimetään ja sitten program.c.
Ja voit myös tehdä tehdä ohjelman, ja nähdä miten ensimmäisen 2 tapausta
Laitoin. C, ja kolmas minulla on vain ohjelmia?
Joo, te todella pitäisi laittaa. C Kun käytät tehdä.
Muutoin kääntäjä on todella menossa huutaa sinulle.
Ja myös, en tiedä jos te muistatte,
mutta paljon kertaa olemme myös käytetty-lcs50 tai-lm.
Tätä kutsutaan yhdistää.
Se vain kertoo kääntäjälle, että voit käyttää niitä kirjastoja oikeassa,
joten jos haluat käyttää cs50.h sinun todella täytyy kirjoittaa
clang program.c-lcs50.
Jos et tee sitä, kääntäjä ei aio tiedä
että käytät näitä toimintoja cs50.h.
Ja kun haluat ajaa ohjelman sinulla on 2 vaihtoehtoa.
Jos et clang program.c et anna nimen omaan ohjelmaan.
Sinun täytyy käyttää sitä käyttämällä. / A.out.
A.out on tavallinen nimi clang antaa ohjelman, jos et anna sille nimi.
Muuten aiot tehdä. / Ohjelma jos annoit nimen omaan ohjelmaan,
ja jos et tee ohjelma nimi ohjelma on menossa
on jo menossa ohjelmoitava sama nimi kuin C-tiedoston.
Sitten puhuimme tietotyypit ja tiedon.
>> Pohjimmiltaan tietotyypit ovat sama asia kuin vähän laatikoita ne käyttävät
tallentaa arvoja, joten tietotyypit ovat oikeastaan ​​aivan Pokemons.
Ne tulevat kaikki koot ja tyypit.
En tiedä, jos se vastaavasti järkevää.
Datan koko todella riippuu koneen arkkitehtuuri.
Kaikki tiedot koot aion näyttää tässä
ovat itse asiassa 32-bittinen kone, joka on osalta meidän laite,
mutta jos olet todella koodaus Macin tai Windowsin myös
luultavasti olet menossa on 64-bittinen kone,
Muista siis, että tiedot koot aion näyttää tässä
ovat 32-bittinen kone.
Ensimmäinen että näimme oli int-
joka on melko yksinkertainen.
Voit käyttää int tallentaa kokonaisluku.
Näimme myös merkki, char.
Jos haluat käyttää kirjain tai hieman symboli olet todennäköisesti aio käyttää char.
Char on 1 tavu, mikä tarkoittaa, 8 bittiä, kuten Lexi mainittu.
Periaatteessa meillä on ASCII taulukon, joka on 256
mahdollisia yhdistelmiä 0 ja 1s,
ja sitten kun kirjoitat char se tulee kääntää
merkki siitä, että tulot sinulla useita, että sinulla on ASCII taulukon, kuten Lexi sanoi.
Meillä on myös uimuri, jota käytämme tallentaa desimaalilukuja.
Jos haluat valita 3,14, esimerkiksi aiot käyttää float
tai kaksinkertainen, jossa on enemmän tarkkuutta.
Float on 4 tavua.
Kaksinkertainen on 8 tavua, joten ainoa ero on tarkkuus.
Meillä on myös pitkä, että käytetään kokonaislukuja,
ja voit nähdä 32-bittinen kone int ja pitkä on sama koko,
joten se ei todellakaan järkevää käyttää pitkään 32-bittinen kone.
>> Mutta jos käytät Mac ja 64-bittinen kone, todella pitkä on koko 8,
niin se riippuu oikeastaan ​​arkkitehtuuriin.
Sillä 32-bittinen kone se ei ole järkevää käyttää pitkää todella.
Ja sitten pitkä pitkä, toisaalta, on 8 tavua,
joten se on erittäin hyvä, jos haluat olla pidempi kokonaisluku.
Ja lopuksi, meillä on merkkijono, joka on oikeastaan ​​char *,
joka on osoitin char.
Se on hyvin helppo ajatella, että koko merkkijono tulee olemaan kuten
merkkien määrä että olet siellä,
mutta todellisuudessa char * itse
on koko osoittimen char, joka on 4 tavua.
Koko char * on 4 tavua.
Sillä ei ole väliä, jos sinulla on pieni sana tai kirjain tai mitään.
Se tulee olemaan 4 tavua.
Opimme myös hieman siitä valu,
niin näet, jos sinulla on esimerkiksi ohjelma, joka kertoo
int x = 3 ja sitten printf ("% d", x / 2)
Tiedättekö mitä se tulee tulostaa näytölle?
>> Joku? >> [Opiskelijat] 2.
1. >> 1, joo.
Kun teet 3/2 se tulee saada 1,5,
mutta koska käytämme kokonaisluku se tulee jättää desimaaliosan,
ja olet menossa on 1.
Jos et halua, että tapahtuu mitä voit tehdä, esimerkiksi
on julistaa float y = x.
Sitten x että aiemmin 3 nyt olemaan 3,000 y.
Ja sitten voit tulostaa y / 2.
Oikeastaan ​​minun pitäisi olla 2. tuolla.
Se tulee tehdä 3.00/2.00,
ja aiot saada 1,5.
Ja meillä on tämä .2 f vain pyytää 2 desimaalin yksiköitä desimaaliosan.
Jos sinulla on .3 f se tulee olemaan todella 1,500.
Jos se on 2 se tulee olemaan 1,50.
Meillä on myös tässä asiassa.
Jos et float x = 3,14 ja sitten printf x
aiot saada 3,14.
Ja jos et x = int x,
mikä tarkoittaa kohdella x kuten int ja tulostat x nyt
olet menossa on 3,00.
Onko siinä järkeä?
Koska olet ensimmäinen käsittelemällä x kuin kokonaisluku, niin olet unohdetaan desimaaliosan,
ja sitten olet tulostat x.
Ja lopuksi, voit myös tehdä tämän,
int x = 65, ja sitten julistaa char c = x,
ja sitten jos tulostat c olet todella menossa
, Joten periaatteessa mitä teet täällä
on kääntää kokonaisluvun merkki,
aivan kuten ASCII taulukossa ei.
Olemme myös puhuneet matemaattisia operaattoreita.
Useimmat niistä ovat melko suoraviivaista, niin +, -, *, /,
ja myös puhuimme mod, joka on jäljellä jako 2 numeroa.
Jos on 10% 3, esimerkiksi
se tarkoittaa jakaa 10 3, ja mikä on jäljellä?
Se tulee olemaan 1, joten se on oikeastaan ​​erittäin hyödyllinen paljon ohjelmia.
Saat Vigenère ja Caesar olen melko varma, että te kaikki kaverit käyttää mod.
Tietoja matematiikka toimijoiden olla hyvin varovainen, kun yhdistetään * ja /.
>> Esimerkiksi, jos teet (3/2) * 2, mitä aiot saada?
[Opiskelijat] 2.
Niin, 2, koska 3/2 tulee olemaan 1,5,
mutta koska teet toimintojen välillä 2 kokonaislukujen
olet todella vain menossa harkitsemaan 1,
ja sitten 1 * 2 tulee olemaan 2, niin hyvin, hyvin varovainen
kun teet aritmeettinen kokonaisluvuilla koska
saatat saada että 2 = 3, tässä tapauksessa.
Ja myös olla hyvin varovainen edelle.
Sinun tulisi yleensä käyttää sulkeita olla varma, että tiedät mitä olet tekemässä.
Joitakin hyödyllisiä pikakuvakkeita, tietenkin yksi on i + + tai i + = 1
tai käyttämällä + =.
Se on sama asia kuin teet i = i + 1.
Voit myös tehdä i - tai i - = 1,
joka on sama asia kuin i = i -1,
jotain kaverit käyttää paljon silmukoita, ainakin.
Myös, *, jos käytät * = ja jos et esimerkiksi
i * = 2 on sama asia kuin sanomalla i = i * 2,
ja sama asia jako.
Jos et i / = 2 se on sama asia kuin i = i / 2.
>> Nyt noin toiminnoista.
Te oppineet, että toiminnot ovat erittäin hyvä strategia säästää code
kun olet ohjelmoinnin, joten jos haluat suorittaa saman tehtävän
koodin uudestaan ​​ja uudestaan, luultavasti haluat käyttää toimintoa
vain niin sinun ei tarvitse kopioida ja liittää koodi uudestaan ​​ja uudestaan.
Oikeastaan ​​tärkein on tehtävä, ja kun minä näytän sinulle muotoa funktion
te tulette näkemään, että se on aika selvää.
Käytämme myös toimintoja joistakin kirjastoista,
Esimerkiksi, printf, GetIn, joka on peräisin CS50 kirjastosta,
ja muita toimintoja, kuten toupper.
Kaikki nämä toiminnot on tosiasiallisesti täytäntöön muissa kirjastoissa,
ja kun laitat ne lieka tiedostot alussa ohjelma
sanot voitteko antaa minulle koodin näitä toimintoja
joten minun ei tarvitse toteuttaa niitä itse?
Ja voit myös kirjoittaa omia funktioita, joten kun aloitat ohjelmoinnin
huomaat, että kirjastot eivät ole kaikki toiminnot, joita tarvitset.
Viimeisen PSET esimerkiksi kirjoitimme piirtää, ryntäily, ja lookup,
ja se on hyvin, hyvin tärkeää pystyä kirjoittamaan toiminnot
koska ne ovat hyödyllisiä, ja käytämme niitä kaiken aikaa ohjelmointi,
ja se säästää paljon koodia.
Muoto toiminto on tämä.
Meillä on palautuva alussa. Mikä on palautuva?
Se on vain kun toiminto on palaamassa.
Jos sinulla on toiminto, esimerkiksi kertoma,
, joka on menossa laskemaan kertoman kokonaisluku,
luultavasti se tulee palauttaa kokonaisluvun myös.
Sitten palautuva tulee olemaan Int.
Printf todella on palautuva void
koska et palaa mitään.
Olet vain tulostaa asioita näytön
ja lopetus-toiminto jälkeenpäin.
Sitten sinulla on funktion nimi, että voit valita.
Sinun pitäisi olla hieman kohtuullinen, kuten eivät valitse nimi kuten xyz
tai kuten x2f.
Yritä keksiä nimi järkeä.
>> Esimerkiksi, jos se on kertoma, sano kertoma.
Jos se on toiminto, joka on menossa tekemään jotain, nimeä se piirtää.
Ja sitten meillä on parametrit, joita kutsutaan myös väitteitä,
jotka ovat kuin resursseja, että toiminto tarvitsee
mistä koodi hoitamaan tehtäväänsä.
Jos haluat laskea luvun kertoman
luultavasti sinun täytyy olla numero laskea kertoma.
Yksi väitteistä, että olet menossa on on numero itse.
Ja sitten se tulee tehdä jotain ja palauttaa arvon lopussa
ellei se mitätön tehtävä.
Katsotaanpa esimerkki.
Jos haluan kirjoittaa funktio, joka summaa kaikki numerot joukko kokonaislukuja,
ensinnäkin, että palautuva tulee olemaan int
koska minulla on joukko kokonaislukuja.
Ja sitten aion olla funktion nimi kuten sumArray,
ja sitten se tulee viemään array itse on int nums,
ja sitten pituus array joten tiedän, kuinka monta numeroa minun täytyy tiivistää.
Sitten minun täytyy alustaa muuttuja nimeltä summan, esimerkiksi 0,
ja joka kerta näen alkio Lisäisin sen summan, joten tein varten silmukka.
Aivan kuten Lexi sanoi, et int i = 0, i <pituus ja i + +.
Ja jokainen alkio tein summa + = nums [i]
ja sitten palasin summa, joten se on hyvin yksinkertainen, ja se säästää paljon koodia
Jos käytät tätä toimintoa paljon kertaa.
Sitten otimme tarkastella olosuhteissa.
Meillä on if, else, ja else if.
Katsotaan, mitä eroa näiden.
Katsokaa näitä 2 koodeja. Mikä on ero niiden välillä?
Ensimmäinen on, pohjimmiltaan koodit haluaa sinun kertovan
jos numero on +, - tai 0.
Ensimmäinen sanoo, jos se on> 0, se on positiivista.
Jos se on = 0 niin se on 0, ja jos se on <0 niin se on negatiivinen.
>> Ja toinen on tekemässä, jos muuta, jos muuta.
Ero näiden kahden välillä on se, että tämä on todella menossa
tarkista> 0, <0 tai = 0 kolme kertaa,
joten jos sinulla on numero 2, esimerkiksi, se tulee tänne ja sanovat
if (x> 0), ja se tulee sanoa kyllä, niin voin tulostaa positiivinen.
Mutta vaikka tiedän, että se on> 0 ja se ei tule olemaan 0 tai <0
Aion silti tehdä, on se 0, on se <0,
joten olen todella menossa sisälle IFS, etten tarvitse
koska tiedän jo, että se ei aio täytä mitään näistä edellytyksistä.
Voin käyttää, jos if, else selvitys.
Se pohjimmiltaan sanoo, että jos x = 0 voin tulostaa positiivinen.
Jos se ei ole, aion myös testata tätä.
Jos se on 2 ei aion tehdä tämän.
Periaatteessa jos olisin x = 2 sanoisit
if (x> 0), kyllä, niin tulosta tämä.
Nyt tiedän, että se on> 0 ja että se täyttää ensin, jos
En edes aio suorittaa tämän koodin.
Koodi toimii nopeammin, jopa 3 kertaa nopeammin, jos käytät tätä.
Olemme myös oppineet ja ja tai.
En aio käydä läpi tämän takia Lexi jo puhui heille.
Se on vain && ja | | operaattori.
>> Ainoa asia sanon on oltava varovainen, kun sinulla on 3 edellytykset.
Käytä suluissa koska se on hyvin hämmentävää, kun olet kunnossa
ja toinen tai toinen.
Käytä sulkeita vain olla varma, että olosuhteet järkeä
koska siinä tapauksessa, esimerkiksi, voitte kuvitella, että
se voisi olla ensimmäinen ehto ja yksi tai muiden
tai 2 edellytykset yhdistetään ja
tai kolmas, joten vain olla varovainen.
Ja lopuksi, puhuimme kytkimet.
Kytkin on erittäin hyödyllinen, kun sinulla on vaihteleva.
Oletetaan, että sinulla on vaihteleva kuten n
, joka voi olla 0, 1 tai 2, ja kukin näistä tapauksista
aiot suorittaa tehtävän.
Voit sanoa vaihtaa muuttuja, ja se osoittaa, että
arvo sitten on kuin arvo1 aion tehdä tämän,
ja sitten rikkoa, mikä tarkoittaa, en aio katsoa mitään muita tapauksia
koska olemme jo tyytyväisiä, että asia
ja sitten arvo2 ja niin edelleen, ja olen myös voi olla oletuksena kytkin.
Tämä tarkoittaa, että jos se ei täytä mitään niistä asioista, jotka olin
että aion tehdä jotain muuta, mutta se on vapaaehtoista.
Siinä kaikki minulle. Nyt on Tommy.
Okei, tämä tulee olemaan viikon 3-ish.
Nämä ovat joitakin aiheita me voidaan kattaa, Crypto, laajuus, taulukot, jne..
Just a quick sanaa salauksen. Emme aio vasara tämän kotiin.
>> Teimme tämän PSET 2, mutta tietokilpailu varmista, että tiedät eron
välillä Caesar cipher ja Vigenère cipher,
miten molemmat näistä ciphers työn ja millaista salata
ja purkaa tekstiä nuo 2 ciphers.
Muista, Caesar cipher yksinkertaisesti kiertää jokaisen merkin saman verran,
tekee varmasti mod useissa kirjaimia.
Ja Vigenère salakirjoituksen, toisaalta, pyörii kunkin merkin
jonka eri määrällä, joten mieluummin kuin sanomalla
jokainen merkki käännetään 3 Vigenère pyörii kunkin merkin
jonka eri summan riippuen joitakin avainsanan
jossa jokainen kirjain avainsanan edustaa hieman eri määrä
kiertää selkeää tekstiä.
Katsotaanpa ensin puhua muuttuja soveltamisalasta.
On 2 erilaisia ​​muuttujia.
Meillä on paikallisia muuttujia, ja nämä ovat aiotaan määritellä
ulkopuolella pää-tai ulkopuolella mitään toimintoa tai estää,
ja nämä ovat käytettävissä missä tahansa ohjelmassa.
Jos sinulla on tarkoituksensa ja että toiminto on taas silmukka
iso globaali muuttuja on käytettävissä kaikkialla.
Paikallisen muuttujan, toisaalta, on scoped paikkaan, jossa se on määritetty.
>> Jos sinulla on funktio esimerkiksi täällä meillä on tämä toiminto g,
ja sisältä g on muuttuja tässä kutsutaan y,
ja se tarkoittaa, että tämä on paikallinen muuttuja.
Vaikka tämä muuttuja on nimeltään y
ja tämä muuttuja on nimeltään y nämä 2 tehtävät
ei ole aavistustakaan mitä toistensa paikallisia muuttujia ovat.
Toisaalta, täällä sanomme int x = 5,
ja tämä on kuulu mitään toimintoa.
Se ulkopuolelle tärkein, joten tämä on globaali muuttuja.
Tämä tarkoittaa, että sisällä näitä 2 toimii kun sanon x - tai x + +
Olen käyttää samaa x, jolloin tämä y ja tämä y ovat erilaisia ​​muuttujia.
Se ero globaali muuttuja ja paikallinen muuttuja.
Sikäli kuin suunnittelun osalta, joskus se on luultavasti parempi idea
pitää muuttujien paikalliseen aina kun mahdollista
koska ottaa kasan globaaleja muuttujia voi saada todella sekava.
Jos sinulla on nippu toimii kaikkien muuttaa samaa
saatat unohtaa mitä jos tämä toiminto vahingossa muuttaa tämän maailmanlaajuisen,
ja tämä toinen toiminto ei tiedä siitä,
ja se saada melko sekava saat enemmän koodia.
Keeping muuttujia paikallisten aina kun mahdollista
On vain hyvää suunnittelua.
Arrays, muistakaa, ovat yksinkertaisesti luettelot elementtejä samaa tyyppiä.
Sisällä CI ei voi olla luettelossa, kuten 1, 2,0, hei.
Emme vain voi tehdä sitä.
>> Kun me julistamme array C kaikilla elementeillä on oltava samaa tyyppiä.
Tässä olen valikoima 3 kokonaislukuja.
Tässä olen pituus array, mutta jos olen vain toteavan tämän syntaksin
missä voin määrittää, mitä kaikki elementit En ole teknisesti tarvitse tätä 3.
Kääntäjä on fiksu selvittää, miten suuri joukko olisi.
Nyt kun haluan saada tai asettaa arvon taulukon
Tässä on syntaksi tehdä niin.
Tämä todella muuttaa toista alkiota, koska muistan,
numerointi alkaa 0, ei 1.
Jos haluan lukea, että arvo voin sanoa jotain int x = array [1].
Tai jos haluan asettaa tämän arvon, kuten olen täällä,
Voin sanoa array [1] = 4.
Tuo aika päästä elementit niiden indeksin
tai asemansa tai jos ne ovat array,
ja että listaus alkaa 0.
Voimme myös paneelit paneelit,
ja tätä kutsutaan moni-ulotteinen taulukko.
Kun meillä on moniulotteinen array
se tarkoittaa, että voimme saada jotain rivejä ja sarakkeita,
ja tämä on vain yksi tapa visualisoida tätä tai ajatellut sitä.
Kun minulla on moniulotteinen array joka tarkoittaa aion aloittaa tarvitseville
yli 1 indeksiä, koska jos minulla on ruudukko
vain sanoa mitä rivillä olet ei anna meille numero.
Se on oikeastaan ​​vain antaa meille listan numeroita.
Sanotaan olen tätä array täällä.
Olen array nimeltään grid, ja sanon sen 2 riviä ja 3 saraketta,
ja niin tämä on yksi tapa katsella sitä.
Kun sanon haluan saada elementti [1] [2]
tämä tarkoittaa, että koska nämä ovat rivit ensin ja sitten sarakkeita
Aion hypätä rivin 1 jälkeen sanoin 1.
>> Sitten aion tulla tänne 2 sarakkeessa, ja aion saada arvoa 6.
Järkeä?
Moniulotteinen taulukot, muistakaa, ovat teknisesti vain joukko matriiseja.
Voimme olla ryhmät ryhmät matriiseja.
Voimme jatkaa, mutta todella yksi tapa ajatella
miten tämä on aseteltu ja mitä tapahtuu on visualisoida sitä
in grid näin.
Kun ohitamme matriiseja toimintoihin, he aikovat käyttäytyä
hieman eri tavalla kuin silloin, kun välitämme säännölliset muuttujia toiminnot
kuin ohimennen int tai float.
Kun me kulkea int tai char tai näistä muista tietotyyppien
me vain otti katsomaan jos toiminto muuttaa
arvo, että muuttuja, että muutos ei tule levittää ylös
kutsuvaan toiminto.
Jossa joukko, toisaalta, että näin tapahtuu.
Jos minä kulkea array jokin funktio ja funktio muuttaa joitakin elementtejä,
kun tulen takaisin ylös toiminto kutsui
minun array nyt olemaan erilainen, ja sanastoa, että
on paneelit ovat läpäisseet viitataan, kuten näemme myöhemmin.
Tämä liittyy siihen, miten viitteitä työtä, jossa nämä perustiedot tietotyypit,
Toisaalta, johdetaan arvosta.
>> Voimme ajatella, että tehdään kopio joidenkin muuttujan ja sitten ohimennen kopio.
Sillä ei ole väliä, mitä me teemme, että vaihteleva.
Soittamalla toiminto ei ole tietoinen siitä, että se on muuttunut.
Taulukot ovat vain hieman erilainen tässä suhteessa.
Esimerkiksi, kuten juuri näki, tärkein on yksinkertaisesti funktio
joka voi toteuttaa 2 väitteitä.
Ensimmäinen argumentti päätehtävä on argc tai useita väitteitä,
ja toinen argumentti on nimeltään argv,
ja ne ovat todellisia arvoja nämä väitteet.
Sanotaan Minulla on ohjelma nimeltä this.c,
ja sanon tekevät tätä, ja aion suorittaa tämän komentoriviltä.
Nyt siirtää joidenkin väitteiden minun ohjelma nimeltä tätä,
Voisin sanoa jotain. / Tämä on CS 50.
Tämä on mitä me kuvitella Daavid tehdä joka päivä terminaalista.
Mutta nyt päätehtävä sisällä että ohjelman
on näitä arvoja, joten argc on 4.
Se voi olla hieman sekava, koska oikeastaan ​​olemme vain ohimennen on CS 50.
Se on vain 3.
Mutta muista, että ensimmäinen osa argv tai ensimmäisen argumentin
on funktion nimi itse.
Joten se tarkoittaa, että meillä on 4 asioita täällä,
ja ensimmäisen elementin tulee olemaan. / tätä.
Ja tämä on edustettuina merkkijono.
Sitten loput elementit ovat mitä kirjoitit jälkeen ohjelman nimi.
Eli aivan kuten syrjään, koska me luultavasti näimme PSET 2,
Muista, että merkkijono 50 ≠ kokonaisluku 50.
Joten emme voi sanoa jotain, 'int x = argv 3. "
>> Se vain ei ole järkeä, koska tämä on merkkijono, ja tämä on kokonaisluku.
Joten jos haluat muuntaa 2, muistakaa, me aiomme
on tämä maaginen toiminto nimeltään atoi.
Se vie merkkijono ja palauttaa kokonaisluvun oli sisällä merkkijonon.
Niin, että helppo virhe tehdä siitä tietokilpailu,
vain ajatella, että tämä tulee automaattisesti oikean tyyppinen.
Mutta juuri tietää, että nämä ovat aina merkkijonoja
vaikka merkkijono sisältää vain kokonaisluku tai merkin tai float.
Joten nyt Puhutaan käyntiaika.
Kun meillä on kaikki nämä algoritmit tehdä kaikki nämä hulluja asioita,
se on todella hyödyllistä kysyä, "Kuinka kauan ne kestää?"
Me edustamme, että jotain kutsutaan asymptoottinen merkintä.
Joten tämä tarkoittaa, että - no, sanokaamme annamme algoritmi
todella, todella, todella iso panos.
Haluamme kysyä, "Kuinka kauan se vie?
Kuinka monta askelta kestää meidän algoritmi ajaa
funktiona koko panos? "
Eli ensimmäinen tapa voimme kuvata ajoaika on iso O.
Ja tämä on meidän pahin ajoaika.
Jos siis haluat lajitella taulukon, ja annamme algoritmi array
se laskevassa järjestyksessä, kun sen pitäisi olla nousevassa järjestyksessä,
että tulee olemaan pahin.
Tämä on meidän yläraja on maksimiaika meidän algoritmi vie.
Toisaalta, tämä Ω tulee kuvaamaan parhaassa tapauksessa ajoaikaan.
Joten jos annamme jo lajiteltu array lajittelu algoritmin,
kuinka kauan kestää lajitella?
Ja tämän jälkeen, kuvataan alaraja ajoaikaan.
Joten tässä on vain muutamia sanoja, jotka kuvaavat joitakin yhteisiä käyntiaikoja.
Nämä ovat nousevassa järjestyksessä.
Nopein käyntiaika meillä kutsutaan jatkuvasti.
>> Tämä tarkoittaa ei väliä kuinka monta elementtiä annamme algoritmi,
ei väliä kuinka iso meidän array on, lajittelu se
tai tekee mitä teemme on array ottaa aina saman verran aikaa.
Joten meillä voi edustaa, että pelkästään 1, joka on vakio.
Olemme myös katsoi logaritminen ajoaika.
Eli jotain binäärihakupuu on logaritminen,
jossa leikataan ongelman puoli aina
ja sitten kaikki menee enemmän sieltä.
Ja jos olet joskus kirjallisesti O tahansa kertoma algoritmin,
luultavasti ei pitäisi harkita tätä teidän päivä työtä.
Kun vertaamme käyntiaikoja on tärkeää pitää mielessä nämä asiat.
Joten jos minulla on algoritmi, joka on O (n), ja joku muu
on algoritmi O (2n), että nämä ovat asymptoottisesti vastaavat.
Joten jos me kuvittelemme n: n iso numero kuten Eleventy miljardia:
joten kun olemme vertaamalla Eleventy miljardin jotain Eleventy miljardia + 3,
yhtäkkiä että +3 ei oikeastaan ​​tee suurta eroa enää.
Siksi aiomme alkaa harkita näitä asioita vastaaviksi.
Joten asiat kuten nämä vakiot täällä, siellä on 2 x tämän, tai lisäämällä 3,
nämä ovat vain vakioita, ja nämä ovat menossa pudota ylös.
Joten siksi kaikki 3 näistä ajoajat ovat samat kuin sanomalla he O (n).
Vastaavasti jos meillä on 2 muuta ajoajat, sanokaamme O (n ³ + 2n ²), voimme lisätä
+ N, + 7, ja sitten meillä on toinen ajoaika, joka on vain O (n ³).
kerran, nämä ovat sama asia, koska nämä - nämä eivät ole samoja.
Nämä ovat samoja asioita, sorry. Nämä ovat siis samat, koska
tämä n ³ tulee hallitsemaan tätä 2n ².
>> Mikä ei ole sama asia on, jos olemme ajaa aikoina O (n ³) ja O (n ²)
koska tämä n ³ on paljon suurempi kuin tämän n ².
Eli jos meillä on potensseja, yhtäkkiä tämä alkaa merkitystä,
mutta kun olemme juuri tekemisissä tekijät kuin me olemme täällä,
niin se ei tule väliä, koska he ovat juuri menossa pudota pois.
Otetaan katsomaan joitakin algoritmeja olemme nähneet tähän mennessä
ja puhuvat käyntiaika.
Ensimmäinen tapa on etsiä numeron luettelosta, että näimme, oli lineaarinen haku.
Ja täytäntöönpano lineaarinen etsintä on super yksinkertainen.
Meillä on vain listan, ja aiomme tarkastella jokaisen elementti luettelossa
kunnes löydämme määrä etsimme.
Niin se tarkoittaa, että pahimmassa tapauksessa, tämä O (n).
Ja pahimmassa tapauksessa tässä voisi olla, jos elementti on
viimeinen elementti, sitten käyttämällä lineaarista hakua meidän täytyy tarkastella jokaisen elementin
kunnes saamme viimeinen jotta tietää, että se oli todella luettelossa.
Emme voi vain antaa periksi puolitiehen ja sanoa: "Se ei todennäköisesti ole olemassa."
Lineaarinen haku meidän täytyy tarkastella koko juttu.
Parhaassa tapauksessa käynnissä ajan, toisaalta, on vakio
koska parhaassa tapauksessa elementin etsimme on vain ensimmäinen luettelossa.
Joten se vie meidät tasan 1 vaihe, ei väliä kuinka suuri luettelo on
jos etsimme ensimmäinen elementti joka kerta.
>> Joten kun haet, muistakaa, se ei vaadi, että luettelo voidaan lajitella.
Koska me yksinkertaisesti menossa katsomaan yli jokaisen elementin, ja se ei ole väliä
missä järjestyksessä näitä tekijöitä ovat tuumaa
Enemmän älykkäitä hakualgoritmi on jotain binäärihakupuu.
Muista, täytäntöönpano binäärihakupuu on, kun olet menossa
pitää etsiä keskelle luettelosta.
Ja koska me tarkastelemme keskellä, vaadimme, että luettelo on järjestetty
tai muuten emme tiedä missä keskellä on, ja meidän on katsottava yli
koko lista löytää se, ja sitten siinä vaiheessa olemme vain tuhlaa aikaa.
Eli jos meillä on lajiteltu lista ja löydämme keskellä, aiomme verrata keskelle
sen elementin etsimme.
Jos se on liian korkea, niin voimme unohtaa oikea puoli
koska tiedämme, että jos meidän osa on jo liian suuri
ja kaikki oikealle tämä elementti on vielä suurempi,
meidän ei tarvitse katsoa sinne enää.
Jos toisaalta, jos meidän elementti on liian alhainen,
tiedämme kaiken vasemmalla että elementti on myös liian alhainen,
joten se ei oikeastaan ​​järkeä katsoa sinne, joko.
Näin jokaisella askeleella ja joka kerta katsomme keskipisteessä luettelon
aiomme leikata meidän ongelma puoli, sillä yhtäkkiä tiedämme
koko joukko numeroita, jotka eivät voi olla yksi etsimme.
>> Pseudokoodilla tämä näyttää tältä,
ja koska olemme leikkaus luettelon puoli joka ikinen kerta,
meidän pahin käyntiaika hyppää lineaarisesta logaritminen.
Joten yhtäkkiä meillä on log-vaiheissa, jotta löydettäisiin elementti luettelosta.
Paras tapaus käyntiaika, vaikka on vielä vakio
koska nyt haluan vain sanoa, että elementti etsimme on
aina tarkka keskellä alkuperäisen luettelon.
Joten voimme kasvattaa luetteloa yhtä suuri kuin haluamme, mutta jos elementti etsimme on keskellä,
niin se vain vie meidät 1 askeleen.
Joten siksi olemme O (log n) ja Ω (1) tai vakio.
Mennään todella ajaa binäärihakupuu tällä listalla.
Joten sanoa, että me etsimme elementin 164.
Ensimmäinen asia aiomme tehdä, on löytää midpoint luettelon.
Se vain on niin, että keskipiste on menossa laskevan näiden 2 numeroiden
joten katsotaanpa vain mielivaltaisesti sanoa, joka kerta keskipiste osuu 2 numeroa,
Haluan vain pyöristää ylöspäin.
Meidän täytyy vain varmistaa teemme tämän joka askeleella.
Joten menemme pyöristää ylöspäin, ja aiomme sanoa, että 161 on keskellä meidän listan.
Joten 161 <164, ja jokainen elementti vasemmalle 161
On myös <164, joten tiedämme, että se ei auta meitä lainkaan
lähteä etsimään tänne koska osa etsimme voi olla siellä.
Joten mitä voimme tehdä on, voimme vain unohtaa, että koko vasen puoli luettelon,
ja nyt vain katsoa pois oikeus 161 eteenpäin.
>> Joten jälleen, tämä on keskipiste, mennään vain pyöristää ylöspäin.
Nyt 175 on liian iso.
Joten me tiedämme se ei auta meitä etsivät täällä tai täällä,
joten voimme vain heittää sen pois, ja lopulta me osuma 164.
Mahdolliset kysymykset binäärihakupuu?
Siirrytään etsimisestä kautta jo lajitellaan luettelossa
todella ottaa listan numerot tahansa järjestyksessä
ja antaa tämän luettelon nousevassa järjestyksessä.
Ensimmäinen algoritmi me katsoimme oli nimeltään Bubble sort.
Ja tämä olisi yksinkertaisempi ja algoritmien näimme.
Bubble sort sanoo, että kun jokin 2 Sisällä luetteloon ovat paikallaan,
siten on olemassa suurempi määrä vasemmalla puolella on pienempi määrä,
Sitten aiomme vaihtaa niitä, koska se tarkoittaa, että luettelo on
"Enemmän lajiteltu" kuin se oli ennen.
Ja olemme juuri menossa jatkaa tätä prosessia uudestaan ​​ja uudestaan ​​ja uudestaan
kunnes lopulta elementit sellainen kupla niiden oikeaan paikkaan, ja meillä on järjestetty luettelo.
>> Käyntiaika Tämän tulee olla O (n ²). Miksi?
No, koska pahimmassa tapauksessa aiomme ryhtyä jokaisen elementin, ja
aiomme päätyä vertaamalla sitä joka toinen elementti luettelossa.
Mutta parhaassa tapauksessa meillä on jo järjestetty luettelo, kupla sort n
juuri menossa läpi kerran, sano "Ei. en tee mitään swapit, joten olen valmis."
Joten meillä on parhaassa tapauksessa käyntiaika Ω (n).
Katsotaanpa ajaa kupla lajitella luettelon.
Tai ensin, mennään katsokaa joitakin pseudokoodilla todella nopeasti.
Haluamme sanoa haluamme seurata, joka iterointia silmukan,
pitää kirjaa vai ei muutimme mitään elementtejä.
Eli syy siihen on, me aiomme lopettaa, kun emme ole vaihtanut mitään osia.
Joten alussa meidän silmukan emme ole vaihtanut mitään, joten sanomme että on väärä.
Nyt aiomme käydä listan läpi ja vertaa elementti I osa i + 1
ja jos se on totta, että on olemassa suurempi määrä vasemmalla puolella pienempi määrä,
Sitten olemme juuri menossa vaihtaa niitä.
>> Ja sitten me aiomme muistaa, että me vaihdettu elementti.
Tämä tarkoittaa, että meidän täytyy mennä läpi listan vähintään 1 enemmän aikaa
koska tila, jossa pysähdyimme on kun koko lista on jo järjestetty,
eli emme ole tehneet mitään swapit.
Joten siksi tilaamme tänne on "taas jotkut elementit on vaihdettu."
Joten nyt mennään Katsokaapa tätä käynnissä luettelossa.
Minulla on lista 5,0,1,6,4.
Bubble sort aikoo aloittaa aina vasemmalla, ja se tulee verrata
i elementtejä, joten 0-i + 1, joka on elementin 1.
Se tulee sanoa, hyvin 5> 0, mutta nyt 5 on vasemmalla,
joten minun täytyy vaihtaa 5 ja 0.
Kun minä vaihtaa niitä, yhtäkkiä saan tämän eri luettelo.
Nyt 5> 1, joten aiomme vaihtaa niitä.
5 ei> 6, joten meidän ei tarvitse tehdä mitään täällä.
Mutta 6> 4, joten meidän täytyy vaihtaa.
Jälleen meidän käydä läpi koko luetteloa lopulta löytää
että nämä ovat epäkunnossa, me vaihtaa niitä,
ja tässä vaiheessa meidän käydä läpi listan 1 enemmän aikaa
varmistaa, että kaikki on sen järjestyksessä, ja tässä vaiheessa kupla lajitella on päättynyt.
Eri algoritmi ottaa joitakin osia ja lajittelu on valinta tavallaan.
Ideana valinta sort että aiomme rakentaa lajiteltu osan luettelossa
1 elementti kerrallaan.
>> Ja miten aiomme tehdä se on luomalla vasemmalla segmentin listan.
Ja pohjimmiltaan jokainen - on jokainen askel, aiomme ottaa pienimmän alkion meillä on jäljellä
jota ei ole lajiteltu vielä, ja me aiomme siirtää sen että lajiteltu segmenttiin.
Tämä tarkoittaa, että meidän on jatkuvasti löytää pienin lajittelemattoman elementti
ja sitten ottaa sen pienin alkio ja vaihtaa sen kanssa, mitä
Vasemmassa elementti, jota ei ole lajiteltu.
Ajoaika Tämän tulee olla O (n ²), koska pahimmassa tapauksessa
meidän vertailla jokainen elementti joka toinen elementti.
Koska sanomme, että jos aloitamme vasemmalla puolella luettelon, tarvitsemme
käydä läpi koko oikea segmentti löytää pienin alkio.
Ja sitten taas, meidän on mentävä koko oikea segmentti ja
jatkakaa yli että yhä uudestaan ​​ja uudestaan.
Tämä tulee olemaan n. ². Olemme menossa varten silmukan sisällä toinen silmukka
mikä viittaa n ².
Parhaassa tapauksessa ajatus, sanokaamme annamme sen jo järjestetty luettelo;
emme oikeastaan ​​tee mitään parempaa kuin n ².
Koska valinta sort ei voi mitenkään tietää, että
pienin elementti on vain yksi Satun katsot.
Se vielä varmistaa, että tämä on todella pienin.
>> Ja ainoa tapa varmistaa, että se on vähintään käyttämällä tämän algoritmin
on tarkastella jokaisen elementin uudelleen.
Siis todella, jos annat sen - jos annat valinta lajitella jo järjestetty luettelo,
se ei aio tehdä mitään paremmin kuin antaa sille luettelon, joka ei ole lajiteltu vielä.
Muuten, jos se sattuu olemaan siinä tapauksessa, että jotain on O (jotain)
ja omega jotain, voimme vain sanoa lyhyemmin, että se on θ jotain.
Joten jos näet että keksiä missään, sitähän se juuri tarkoittaa.
>> Jos jotain on theta n ², se on niin iso O (n ²) ja Ω (n ²).
Joten paras asia ja pahimmassa tapauksessa se ei tee eroa,
algoritmi aikoo tehdä saman joka kerta.
Joten tämä on mitä pseudokoodi valinnassa tavallaan voisi näyttää.
Olemme periaatteessa aio sanoa, että haluan toistaa yli luettelo
vasemmalta oikealle, ja kunkin iterointia silmukan, aion siirtyä
pienin elementti tähän lajitellaan osaan luettelosta.
Ja kun minä liikkua jotain siellä, en koskaan tarvitse katsoa, ​​että osa uudelleen.
Koska heti kun vaihtaa osa vasemmalla segmentin listan, se on lajiteltu
koska teemme kaiken nousevassa järjestyksessä käyttämällä minimit.
Joten sanoimme, okei, me olemme asennossa I, ja meidän on tarkasteltava kaikkia tekijöitä
oikealle i, jotta löydettäisiin minimiin.
Niin se tarkoittaa, että haluamme katsoa alkaen i + 1 loppuun luettelosta.
Ja nyt, jos elementti me tarkastelee parhaillaan on pienempi kuin meidän pienin tähän mennessä,
joka, muistakaa, me aloitamme minimi pois vain olla
mitä elementti olemme parhaillaan; Oletan että se minimi.
Jos löydän elementti, joka on pienempi kuin, niin aion sanoa, okei,
No, olen löytänyt uuden minimi.
Aion muistaa missä se minimi oli.
>> Joten nyt, kun olen käynyt läpi, että oikeus lajittelemattoman segmentti,
Voin sanoa aion vaihtaa pienin elementti elementti, joka on asennossa I.
Se tulee rakentaa oma lista, minun lajiteltu osa listan vasemmalta oikealle,
ja me ei koskaan tarvitse katsoa elementin uudelleen, kun se on tuossa osassa.
Kun olemme vaihtanut sitä.
Joten ajaa valinta lajitella tällä listalla.
Sininen tekijä tässä tulee olemaan minä, ja punainen elementti tulee olemaan pienin alkio.
Joten minä alkaa aina vasemmalla puolella listan, niin kello 5.
Nyt meidän on löydettävä minimi lajittelemattoman elementti.
Niinpä sanomme 0 <5, niin 0 on minun uusi minimi.
>> Mutta en voi lopettaa tähän, sillä vaikka voimme tunnustaa, että 0 on pienin,
meidän läpi joka toinen elementti luettelosta varmistaa.
Joten 1 on isompi, 6 on isompi, 4 on isompi.
Tämä tarkoittaa, että kun tarkastellaan kaikkia näitä elementtejä, olen määritelty 0 on pienin.
Joten aion vaihtaa 5 ja 0.
Kun olen swap, että aion saada uuden listan, ja tiedän, että minun ei tarvitse katsoa, ​​että 0 uudestaan
koska kerran olen vaihtanut sen, olen lajitellaan, ja olemme tehneet.
Nyt se vain niin, että sininen elementti on jälleen 5,
ja meidän on tarkasteltava 1, 6 ja 4 määrittää, että 1
on pienin pienin alkio, niin me vaihtaa 1 ja 5.
Jälleen meidän täytyy tarkastella - vertaa 5 6 ja 4,
ja aiomme vaihtaa 4 ja 5, ja lopuksi vertailla
nuo 2 numerot ja vaihtaa niitä kunnes saamme lajiteltu luettelo.
Kaikki kysymykset valintaan lajitella?
Okei. Mennään siirtyä viimeiseen viestiin täällä, ja se on rekursion.
>> Rekursio, muistakaa, on tämä todella meta juttu jos toiminto
toistuvasti kutsuu itseään.
Joten jossain vaiheessa, kun meidän fuction on toistuvasti itseään kutsuva,
siellä on oltava jossain vaiheessa, jossa pysähdymme vaaditaan itseämme.
Koska jos emme tee sitä, niin olemme juuri menossa jatkaa tehdä tätä ikuisesti,
ja meidän ohjelma ei vain aio lopettaa.
Kutsumme tätä edellytystä perustapaus.
Ja perustapauksen sanoo, eikä soittaa taas toiminnassa,
Aion palata jotain arvoa.
Joten kun olemme takaisin arvoon, olemme lopettaneet itseämme,
ja loput puhelujen olemme tehneet tähän mennessä myös palata.
Vastakohta perustapaus on rekursiivinen tapauksessa.
Ja tämä on, kun haluamme tehdä toisen puhelun toiminto, että olemme tällä hetkellä tuumaa
Ja me varmaan, mutta ei aina, haluat käyttää eri argumentteja.
>> Eli jos meillä on toiminto nimeltään F-ja F soitti juuri ottaa 1 väitettä,
ja me vain pitää soittaa f (1), f (1), f (1), ja se vain niin, että
argumentti 1 putoaa rekursiivinen tapauksessa emme vielä koskaan lopeta.
Vaikka meillä on pohja tapauksessa meidän täytyy varmistaa, että lopulta me aiomme lyödä että perustapaus.
Emme vain pitää pysyä tässä rekursiivinen tapauksessa.
Yleensä, kun me kutsumme itseämme, emme luultavasti olemaan erilainen argumentti joka kerta.
Täällä on todella yksinkertainen rekursiivinen funktio.
Joten tämä laskee luvun kertoman.
Ylös täällä meillä perustapaus.
Siinä tapauksessa, että n ≤ 1, emme aio soittaa kertoma uudelleen.
Aiomme lopettaa, olemme juuri menossa takaisin jotain arvoa.
Jos tämä ei ole totta, niin aiomme iski rekursiivinen tapauksessa.
Huomaa, että me emme vain soittamalla factorial (n), koska se ei olisi kovin hyödyllinen.
Aiomme soittaa kertoma jotain muuta.
>> Ja niin näette, lopulta jos ohitamme factorial (5) tai jotain,
aiomme soittaa factorial (4) ja niin edelleen, ja lopulta aiomme iskeä perustapauksen.
Joten tämä näyttää hyvältä. Katsotaan mitä tapahtuu, kun me todella ajaa tätä.
Tämä on pino, ja sanotaan, että tärkein aikoo kutsua tätä toimintoa argumentti (4).
Joten kun kertoma näkee ja = 4, kertoma soittaa itse.
Nyt, yhtäkkiä meillä on factorial (3).
Joten nämä toiminnot ovat menossa kasvamistaan ​​kunnes lopulta me iski perustapaus.
Tässä vaiheessa paluuta arvo on paluuta (nx paluuarvo tämän),
Return arvo on nx palauttaa arvon tämän.
Lopulta meidän osuma joitakin numero.
Huipulla täällä sanomme paluu 1.
Tämä tarkoittaa, että kun palaamme, että määrä, voimme pop tästä pinosta.
Joten tämä kertoma (1) on tehty.
Kun 1 palaa, tämä factorial (1) palaa, tätä paluuta 1.
Paluuarvo tätä, muista, oli nx palauttaa arvon tämän.
Joten yhtäkkiä, tämä kaveri tietää, että haluan palata 2.
>> Joten muistakaa, palauta arvo on vain NX paluuarvo täällä.
Joten nyt voimme sanoa 3 x 2, ja lopuksi, täällä voimme sanoa
tämä on vain olemaan 4 x 3 x 2.
Ja kun tämä palaa, pääsemme yhden kokonaisluvun sisällä tärkein.
Kysyttävää rekursio?
Selvä. Joten siellä on enemmän aikaa kysymysten lopussa,
mutta nyt Joseph kattaa loput aiheet.
>> [Joseph Ong] Selvä. Joten nyt olemme puhuneet rekursioiden,
Puhutaan vähän mitä yhdistää sort on.
Yhdistä sort on periaatteessa toinen tapa lajittelu numeroiden luettelosta.
Ja miten se toimii on, jossa merge sort sinulla on luettelo, ja mitä teemme, on
sanomme, hajaannutaan tämän huomioon 2 puolikasta.
Me ensin suorittaa sulautua järjestä uudelleen vasemmalla puoli,
Sitten me ajaa yhdistää lajitella oikealla puoli,
ja se antaa meille nyt 2 puolikasta että lajitellaan, ja nyt aiomme yhdistää nämä puoliskot yhteen.
Se on hieman vaikea nähdä ilman esim. niin menemme läpi liikkeet ja katso mitä tapahtuu.
Joten aloitat tämän luettelon me jakaa sen 2 puolikasta.
Otamme yhdistää lajitella vasemmalla puoli ensin.
Niin, että vasen puoli, ja nyt me ajaa ne läpi tämän listan uudelleen
joka saa siirtyi merge lajitella, ja sitten katsomme, jälleen,
vasemmalla puolella tämän luettelon ja otamme yhdistää sort sitä.
Nyt pääsemme luettelon 2 numeroa,
ja nyt vasen puoli on vain 1 elementti pitkä, ja emme voi
jakaa luettelo, joka on vain 1 elementin puoli, joten voimme vain sanoa, kun meillä on 50,
joka on vain 1 elementti, se on jo lajiteltu.
>> Kun olemme tehneet sen, voimme nähdä, että voimme
siirtyä oikealla puolella tämän luettelon
ja 3 on myös lajitellaan, ja niin nyt, että molemmat puoliskot luettelon lajitellaan
Voimme liittyä näihin numeroihin takaisin yhteen.
Joten katsomme 50 ja 3, 3 on pienempi kuin 50, niin se menee sisään ensin ja sen jälkeen 50 tulee sisään
Nyt se on tehty, palaamme tuohon luetteloon ja lajitella se oikea puoli.
42 on se oma numero, joten se on jo lajiteltu.
Nyt siis verrata näitä 2 ja 3 on pienempi kuin 42, niin että saa laittaa ensimmäiseen,
nyt 42 saa laittaa, ja 50 saa laittaa sisään
Nyt se lajitellaan, menemme aina takaisin alkuun, 1337 ja 15.
No, nyt tarkastelemme vasen puoli luettelo, 1337 on itsessään niin se lajitellaan ja sama 15.
Joten nyt me yhdistää nämä 2 numeroa lajitella että alkuperäisessä luettelossa, 15 <1337,
niin se menee ensin, sitten 1337 menee sisään
Ja nyt me lajitellaan molemmat puoliskot alkuperäisen listan ylös.
Ja meidän täytyy tehdä, on yhdistää nämä.
Katsomme 2 ensimmäistä numeroa tämän luettelon 3 <15, niin se menee tavallaan array ensin.
15 <42, niin se menee sisään nyt, 42 <1337, joka menee sisään
50 <1337, niin se menee sisään ja huomaa, että me vain otti 2 numeroa pois tästä luettelosta.
Joten emme vain vuorotellen 2 luetellaan.
Olemme vain etsivät alussa, ja viemme elementti
joka on pienempi ja sitten laitat sen meidän array.
Nyt olemme yhdisti kaikki puolikkaat ja olemme tehneet.
>> Kysyttävää yhdistää tavallaan? Kyllä?
[Student] Jos se jakaminen eri ryhmiin, miksi he eivät vain jakaa sitä kerran
ja sinulla on 3 ja 2 ryhmässä? [Ulkomaat kysymyksen käsittämätön]
Syy - joten kysymys kuuluu, miksi emme voi vain yhdistää ne, jotka ensimmäisessä vaiheessa kun me ne?
Syy voimme tehdä tämän, aloita äärimmäisenä vasemmalla elementtejä molemmin puolin,
ja sitten ottaa pienempi ja laita se, että tiedämme, että nämä
yksittäiset luettelot ovat lajiteltu tilauksia.
Joten jos Etsin äärimmäisenä vasemmalla elementtejä molemmat puoliskot,
Tiedän, että he aikovat olla pienin osa näistä listoista.
Voin siis laittaa ne pienin osa täplät tämän suuren luettelon.
Toisaalta, jos katson noita 2 luetellaan toisen tason tuolla,
50, 3, 42, 1337 ja 15, jotka eivät ole lajiteltu.
Joten jos katson 50 ja 1337, aion laittaa 50 otetaan listallani ensin.
Mutta se ei ole oikeastaan ​​mitään järkeä, koska 3 on pienin osa pois kaikki nämä.
Joten ainoa syy voimme tehdä yhdistämällä askel on, koska meidän luettelot ovat jo lajiteltu.
Sen takia meidän täytyy saada alas kaikki pohjaan
koska kun meillä on vain yksi numero, te tiedätte, että yhden numeron
itsessään on jo lajiteltu luettelo.
>> Kysyttävää? Ei?
Monimutkaisuus? No, voit nähdä, että kussakin vaiheessa siellä lopussa numeroita,
ja voimme jakaa luettelon puoli log n kertaa,
mikä on kun saamme tämän n x log n monimutkaisuutta.
Ja näet paras asia Yhdistämisen tavallaan on n log n, ja aivan sattumalta
että pahimmassa tapauksessa, tai Ω siellä, on myös N log N.
Jotain pitää mielessä.
Liikettä, mennään edelleen joitakin super perus tiedoston I / O.
Jos katsoisit Scramble, huomaat meillä oli jonkinlainen järjestelmä
jossa voisit kirjoittaa lokitiedostoon, jos luet läpi koodin.
Katsotaanpa, miten voit tehdä sen.
No, meillä on fprintf, jonka voit ajatella kuin vain printf,
mutta vain tulostat tiedoston sijaan, ja siten f alussa.
Tällainen koodin tänne, mitä se tekee on, kuten ehkä nähneet Scramble,
se menee läpi 2-ulotteinen taulukko tulostamisen rivi riviltä mitä numerot ovat.
Tällöin printf tulostaa omaan terminaaliin tai mitä kutsumme vakiotulosteeseen §.
>> Ja nyt, tässä tapauksessa, meidän täytyy tehdä, on korvata printf kanssa fprintf,
kertoa, mitä tiedosto, jonka haluat tulostaa, ja tässä tapauksessa se vain tulostaa sen ulos, että tiedosto
sijaan tulostaa sen ulos puhelimesi.
No, niin että herää kysymys: Mistä saamme tällaisen tiedoston, eikö?
Ohitimme kirjautumaan sisään tähän fprintf fuction mutta meillä ei ollut aavistustakaan mistä se tuli.
No, alussa koodin, mikä meillä oli tämä kimpale koodin tänne,
joka pohjimmiltaan sanoo, että avoin tiedosto kutsuu log.txt.
Mitä teemme sen jälkeen on meidän on varmistettava, että tiedosto on todella avattu onnistuneesti.
Joten se voi epäonnistua useista syistä, sinulla ei ole tarpeeksi tilaa tietokoneen, esimerkiksi.
Joten se on aina tärkeää ennen kuin teet mitään toimintoja tiedoston mukana
että voimme tarkistaa onko tiedosto avattiin onnistuneesti.
Joten mitä se, joka on argumentti fopen, hyvin, voimme avata tiedoston monin tavoin.
Mitä voimme tehdä on, voimme siirtää sen paino, mikä tarkoittaa ohittaa tiedoston, jos se poistuu jo,
Voimme siirtää, ne liittää tiedoston loppuun eikä pakottavista sitä,
tai voimme määrittää r, mikä tarkoittaa, katsotaanpa avata tiedoston vain luku-.
Joten jos ohjelma yrittää tehdä muutoksia tiedostoon,
huutaa niitä ja älä anna heidän tehdä sitä.
Lopuksi, kun olemme tehneet tiedosto Done tekee toimintansa sitä,
Meidän täytyy varmistaa, suljemme tiedoston.
Ja niin lopussa oman ohjelman, aiot siirtää ne uudelleen
Tämä tiedosto avataan ja sulje se.
Joten tämä on jotain tärkeää, että olet varmasti tehdä.
Joten muistakaa voit avata tiedoston, voit kirjoittaa tiedostoon,
tehdä toimintaa tiedoston, mutta sitten sinun täytyy sulkea tiedoston lopussa.
>> Kaikki kysymykset perusterveydenhuoltoon tiedoston I / O? Kyllä?
[Student kysymys, käsittämättömällä]
Täällä. Kysymys on, mistä tämä log.txt tiedosto näyttää?
No, jos vain antaa sen log.txt, se luo sitä samassa hakemistossa kuin suoritettavan.
Joten jos Sinä - >> [Student kysymys, käsittämättömällä]
Kyllä. Samassa kansiossa, tai samassa hakemistossa, kuten sitä kutsut.
Nyt muistin, pino, ja kasaan.
Joten miten on muisti säädettyihin tietokoneen?
No, voitte kuvitella muistissa tavallaan tämän lohkon täältä.
Ja muistin meillä on ns kasan jumissa siellä, ja pino se siellä.
Ja kasa kasvaa alaspäin ja pino kasvaa ylöspäin.
Niin Tommy mainittiin - No, ja meillä on nämä muut 4 segmentit menen toiseen -
Kuten Tommy sanoi aiemmin, tiedät miten hän toimii kutsuvat itseään ja kutsuvat toisiaan?
Ne rakentaa tällainen pinokehys.
No, jos tärkeimmät puhelut foo foo saa laittaa pinoon.
Foo kutsuu, baari saada n laittaa pinon, ja että saa laittaa pinon jälkeen.
Ja kun he palaavat, he kukin saavat ottaa pinosta.
Mitä kukin näistä paikoista ja muistin pidä?
No, alkuun, joka on tekstiä segmentti, joka sisältää itse ohjelmaa.
Joten kone koodia, joka on olemassa, kun käännät ohjelman.
Seuraavaksi kaikki alustetaan globaalien muuttujien.
>> Joten sinulla on globaaleja muuttujia ohjelmassa, ja sanot kaltaiset = 5,
että saa laittaa kyseisen segmentin, ja oikeutta siitä,
teillä alustamattoman maailmanlaajuisia tietoja, mikä on vain int-
mutta et sano se vastaa mitään.
Toteuta nämä ovat globaaleja muuttujia, joten he ulkopuolella tärkein.
Joten tämä tarkoittaa globaalien muuttujien jotka on ilmoitettu, mutta eivät nollaudu.
Joten mitä kasaan? Varatun muistin avulla malloc, jonka me saamme vuonna hieman.
Ja lopuksi, joissa pinon teillä paikallisia muuttujia
ja kaikki toiminnot saatat soittaa mitään niiden parametrit.
Viimeinen asia, et todellakaan tarvitse tietää, mitä ympäristömuuttujat tehdä,
mutta kun ajaa ohjelmaa, siellä on jotain liittyy, kuten
tämä on käyttäjätunnus henkilön juoksi ohjelman.
Ja se tulee olemaan eräänlainen alareunassa.
Kannalta muistin osoitteet, jotka ovat heksadesimaalilukujen
arvot huipulla alussa 0, ja ne menevät kaikki alas pohjaan.
Tässä tapauksessa, jos olet 32-bittinen järjestelmä,
osoite alareunassa tulee olemaan 0x, jota seurasi af, koska se on 32 bittiä,
joka on 8 tavua, ja tässä tapauksessa 8 tavua vastaa 8 heksadesimaalilukua.
Joten tänne olet menossa on, kuten, 0xffffff, ja siellä olet menossa on 0.
Mitkä ovat osoittimia? Jotkut teistä eivät välttämättä kattaneet tämän jakson ennen.
mutta meillä ei mennä yli sen luento, joten osoitin on vain tietotyyppi
joka tallentaa sen sijaan, että jonkinlainen arvo kuin 50, se tallentaa osoitteen noin paikkaan muistissa.
Kuten että muisti [käsittämättömällä].
Joten tässä tapauksessa, mitä meillä on, meillä on osoitin kokonaisluku tai int *
ja se sisältää tämän heksadesimaaliluvut osoitteen 0xDEADBEEF.
>> Joten mitä meillä on nyt, tämä osoitin jossain paikassa muistissa,
ja se on vain, arvo 50 on tällä muistipaikka.
Joissakin 32-bittisissä järjestelmissä, kaikki 32-bittisissä järjestelmissä, osoittimet vievät 32 bittiä tai 4 tavua.
Mutta, esimerkiksi 64-bittisessä järjestelmässä, osoittimet ovat 64 bittiä.
Niin, että on jotain sinun kannattaa pitää mielessä.
Joten pää-bittisessä järjestelmässä, osoitin on lopussa bittiä pitkä.
Osoittimet ovat tavallaan vaikea sulattaa ilman ylimääräisiä asioita,
joten mennään läpi esimerkki dynaamisen muistin jakamista.
Mitä dynaaminen muisti jakaminen tekee sinulle, vai mitä kutsumme malloc,
sen avulla voit jakaa jonkinlainen tietojen ulkopuolelle asetettu.
Joten tämä tieto on tavallaan enemmän pysyväksi ohjelman keston ajaksi.
Sillä kuten tiedätte, jos julistaa x sisällä funktion, ja että funktio palaa,
sinulla ei enää ole pääsyä tietoihin, jotka on tallennettu x.
Mitä viitteitä tehkäämme on ne meidän tallentaa muistiin tai tallentaa arvot
eri segmentin muistia, eli kasaan.
Nyt kun palaamme pois toiminnon, niin kauan kuin meillä on osoitin
kyseiseen paikkaan muistissa, niin mitä voimme tehdä on, voimme vain katsoa arvoja siellä.
Katsotaanpa esimerkki: Tämä on muistia layout uudelleen.
Ja meillä on tämä toiminto, tärkein.
Mitä se on - okei, niin yksinkertaista, eikö? - Int x = 5, se on vain muuttuja pinon tärkein.
>> Toisaalta, nyt julistaa osoittimen, joka kutsuu funktiota giveMeThreeInts.
Ja nyt me menemme toiminnon ja luomme uuden pinokehys sitä.
Kuitenkin tässä pinokehys, me julistamme int * temp-
joka mallocs 3 kokonaislukuja meille.
Joten koko int antaa meille kuinka monta tavua tämä int on,
ja malloc antaa meille, että monta tavua tilaa kasaan.
Joten tässä tapauksessa, olemme luoneet tarpeeksi tilaa 3 kokonaislukuja,
ja keko asti olemassa, minkä vuoksi olen laatinut sen ylemmäksi.
Kun olemme valmiita, palaamme tänne, sinun tarvitsee vain 3 ints palasi,
ja se palaa osoite, tässä tapauksessa yli kun tämä muisti on.
Ja asetamme osoittimen = kytkin, ja siellä meillä on vain yksi osoitin.
Mutta mitä se funktio palauttaa kasataan tänne ja katoaa.
Joten temp katoaa, mutta silti säilyttää osoite, jossa
ne 3 kokonaisluvut ovat sisällä sähköverkkoon.
Joten tämä asettaa, osoittimet ovat scoped paikallisesti pinottu runko,
mutta muisti, johon ne viittaavat on kasaan.
>> Onko siinä järkeä?
[Opiskelija] Voisitko toistaa? >> [Joseph] Kyllä.
Joten jos menen vain vähän, huomaat että temp jaettu
muistia kasaan siellä.
Joten kun tämä toiminto, giveMeThreeInts palaa, tämä pino täällä on häviämässä.
Ja sen kanssa mitä tahansa muuttujien, tässä tapauksessa, tämä osoitin, joka on myönnetty pinottu kehyksessä.
Tämä on häviämässä, mutta koska palasimme temp
ja asetamme osoittimen = lämpötila, osoittimen nyt menossa osoittamaan samaa muistia sijainnin temp oli.
Joten nyt, vaikka menetämme temp, että paikalliset osoitin,
meillä on edelleen muistiosoite mitä se osoittaa sisällä että muuttujan osoitin.
Kysymyksiä? Se voi olla sellainen sekava viesti, jos et ole mennyt yli sen osassa.
Voimme, sinun TF varmasti mennä sen yli ja tietenkin voimme vastata kysymyksiin
lopussa tarkastelun istunnon tämän.
Mutta tämä on eräänlainen monimutkainen aihe, ja minulla on enemmän esimerkkejä, jotka tulevat näkyviin
joka auttaa selvittämään, mitä viitteitä todellisuudessa ovat.
>> Tässä tapauksessa osoittimet ovat vastaavat ryhmät,
joten en voi vain käyttää tätä osoitinta samaa kuin int array.
Joten olen indeksointivaiheen 0, ja muuttamalla ensimmäinen kokonaisluku 1,
muuttamalla toinen kokonaisluku 2, ja kolmas kokonaisluku 3.
Joten enemmän viitteitä. No, muistaa Binky.
Tässä tapauksessa olemme varattu osoitin tai me julisti osoitin,
mutta aluksi, kun olen vain julisti osoittimen, se ei osoita minnekään muistiin.
Se on vain roskaa arvoja sen sisälle.
Joten minulla ei ole aavistustakaan, missä tämä osoitin osoittaa.
Se on osoite, joka on vain täynnä 0: n ja 1: n, jossa se alun perin ilmoitettu.
En voi tehdä mitään tätä kunnes pyydän malloc sitä
ja sitten se antaa minulle hieman tilaa kasaan jossa voin laittaa arvot sisälle.
Sitten taas, en tiedä mitä on sisällä tämän muistin.
Joten ensimmäinen asia minun täytyy tehdä, on tarkistaa, onko järjestelmä oli riittävästi muistia
antaa minulle takaisin 1 kokonaisluku ensimmäinen paikka, joka on miksi teen tätä tarkista.
Jos osoitin on nolla, mikä tarkoittaa, että se ei ole tarpeeksi tilaa tai jokin muu virhe,
joten minun pitäisi poistua ulos ohjelmasta.
Mutta jos se ei onnistu, nyt voin käyttää että osoitin
ja mitä * osoitin ei se seuraa missä osoite on
missä se arvo on, ja siinä se on 1.
Joten tänne, me tarkistaa jos muisti olemassa.
>> Kun tiedät sen olemassa, voit ottaa sen
Mitä arvoa haluat laittaa siihen; tässä tapauksessa 1.
Kun olemme tehneet sen, sinun täytyy vapauttaa että osoitin
koska meidän täytyy saada takaisin järjestelmän muistin pyysit ensiksi.
Koska tietokone ei tiedä milloin olemme tehneet sen.
Tässä tapauksessa me nimenomaan kertoa sen, okei, olemme tehneet, että muistia.
Jos jokin muu prosessi tarvitsee, jokin muu ohjelma tarvitsee sitä rohkeasti mennä eteenpäin ja ottaa sen.
Mitä voimme myös tehdä on, voimme vain saada osoitteen paikalliset muuttujat päälle.
Joten int x sisällä pinottu kehyksen tärkeimpien.
Ja kun käytämme tätä et-merkki, tämä ja operaattori, mitä se tekee on
se vie x, ja x on vain joitakin tietoja muistissa, mutta se on osoite.
Se sijaitsee jossain. Joten soittamalla & x, mitä tämä tekee se antaa meille osoitteen x.
Tekemällä tämän, Teemme osoitin kohtaan, johon x on muistissa.
Nyt me vain tehdä jotain * x, aiomme saada 5 takaisin.
Tähti on nimeltään dereferencing sitä.
Seuraat osoite ja saat arvoa se tallennetaan siellä.
>> Kysyttävää? Kyllä?
[Opiskelija] Jos et tee 3-huomautti juttu, ei se vielä koota?
Kyllä. Jos et tee 3-osoittimen juttu, se on vielä menossa kääntää,
mutta minä näytän sinulle, mitä tapahtuu toisessa, eikä tee sitä,
sitähän me kutsumme muistivuoto. Et anna järjestelmän
varmuuskopioida sen muisti, niin sen jälkeen, kun ohjelma on menossa kerääntyä
muistin että se ei käytä, ja mikään muu ei voi käyttää sitä.
Jos olet koskaan nähnyt Firefox 1500000 kilotavua tietokoneeseen,
Tehtävienhallinnan, että mitä tapahtuu.
Sinulla muistivuoto ohjelmassa, että he eivät käsittele.
Joten miten osoittimen aritmeettinen työtä?
No, osoitin aritmeettinen on tavallaan kuin indeksointi osaksi array.
Tässä tapauksessa minulla on osoitin, ja mitä teen, on tehtävä osoitin pisteen ensimmäisen osan
Tämän joukon 3 kokonaislukujen että olen varattu.
Mitä nyt teen, tähti osoitin vain muuttaa ensimmäinen elementti luettelossa.
Star osoitin +1 pistettä tänne.
Joten osoitin on täällä, osoitin +1 on täällä, osoitin +2 on täällä.
>> Joten lisäämällä 1 on sama asia kuin liikkuvat pitkin array.
Mitä teemme, kun teemme osoitin +1 saat osoitteen tänne,
ja saadakseen arvo täällä, laitat tähti alkaen koko lauseke
ja dereference sitä.
Joten tässä tapauksessa, olen jossa ensimmäinen sijainnin tässä array 1,
toisessa paikassa 2, ja kolmannen sijainnin 3.
Sitten mitä teen täällä on olen tulostamista meidän osoitin +1,
joka vain antaa minulle 2.
Nyt olen mukaa osoitin, joten osoitin vastaa osoitin +1,
joka liikkuu eteenpäin.
Ja nyt jos tulostaa osoitin +1, osoitin +1 on nyt 3,
joka tässä tapauksessa tulostuu 3.
Ja jotta vapaa jotakin, osoitin, että annan sen
tulee osoittaa alussa array jonka sain takaisin malloc.
Eli tässä tapauksessa, jos olisin soittaa 3 täällä, tämä ei olisi oikein,
koska se on keskellä jono.
Minun on vähennettävä päästä alkuperäiseen sijaintiin
ensimmäinen ensimmäinen piste ennen kuin voin vapauttaa sen.
Joten, tässä on enemmän mukana esimerkki.
Tässä tapauksessa me jaetaan 7 merkkiä luonteeltaan array.
>> Ja tässä tapauksessa mitä teemme on me silmukoiden yli 6 ensimmäisen niistä,
ja me asettamalla ne Z.
Joten int i = 0, i> 6, i + +,
Joten, osoitin + Annan meille, tässä tapauksessa,
osoitin, osoitin +1, osoitin +2, osoitin +3, ja niin edelleen, ja niin edelleen silmukka.
Mitä se aikoo tehdä, on se saa kyseiseen osoitteeseen, dereferences sitä saada arvon,
ja muutoksia, jotka arvoa Z.
Sitten lopussa muistaa tämä on merkkijono, eikö?
Kaikki jouset on päättyä null päättämisestä luonnetta.
Joten, mitä teen on osoittimen 6 Laitoin null terminaattori merkki tuumaa
Ja nyt, mitä minä olen periaatteessa tekemässä täällä toteuttaa printf varten merkkijonon, eikö?
>> Joten, kun ei printf nyt kun se pääsi loppuun merkkijonon?
Kun se osuu null päättämisestä luonnetta.
Eli tässä tapauksessa minun alkuperäinen osoitin osoittaa alussa array.
Olen tulostaa ensimmäinen merkki pois. En siirrä se yli.
Olen tulostaa kyseisen merkin pois. Ehdotan sen yli.
Ja pidän tätä kunnes pääsen loppuun.
Ja nyt loppu * osoitin epäviittausongelman tätä ja saada nolla päättämisestä merkin taakse.
Ja niin minun kun silmukka suoritetaan vain, kun kyseistä arvoa ei ole nolla päättämisestä luonnetta.
Joten, nyt suljen pois tästä silmukan.
Ja niin jos en vähennä 6 tästä osoitin,
Palaan aina alkuun.
Muista, teen tämän, koska minun täytyy mennä alkuun, jotta sen vapauttamiseksi.
>> Joten tiedän, että oli paljon. Onko kysyttävää?
Pyydän, kyllä?
[Student kysymys käsittämättömällä]
Voitteko sanoa että kovempaa? Anteeksi.
[Opiskelija] On viimeisen dian juuri ennen vapautti osoitin,
missä olit todella muuttuu arvo osoittimen?
[Joseph] Niin, täällä. >> [Student] Ai, okei.
[Joseph] Joten olen osoitin miinus miinus, oikealle,
joka liikkuu asia takaisin, ja sitten minä vapauttaa sitä,
koska tämä osoitin on korostettava alkuun jono.
[Opiskelija] Mutta ei tarvittaisi oli lopetit sen jälkeen linja.
[Joseph] Joten, jos olisin lopettanut tämän jälkeen, se katsotaan muistivuoto,
koska en juosta vapaasti.
[Student] I [käsittämättömiä] jälkeen kolme ensimmäistä riviä, jos sinulla on ollut osoitin +1 [käsittämättömällä].
[Joseph] Uh-huh. Joten, mitä kysymys siellä?
Anteeksi. Ei, ei. Mene, mene, kiitos.
[Student] Niin, et muuttaa arvoa viitteitä.
Et olisi pitänyt tehdä osoitin miinus miinus.
[Joseph] Kyllä, täsmälleen.
Joten, kun en osoitin +1 ja osoitin +2,
En tee osoitin vastaa osoitin +1.
Niin, osoitin vain pysyy osoittaa alussa jono.
Vasta kun minä plus plus että se asettaa arvon takaisin sisälle osoitin,
että se todella liikkuu tämän mukana.
Selvä.
Lisää kysymyksiä?
>> Jälleen, jos tämä on tavallaan ylivoimainen, tämä katetaan istunto.
Kysy opetus stipendiaatti siitä, ja voimme vastata kysymyksiin lopussa.
Ja yleensä me halua tehdä tätä miinus juttu.
Tämä on vaatia minua pitää kirjaa siitä, kuinka paljon olen siirtymän array.
Niin, yleensä, tämä on vain selittää, miten osoittimen aritmeettinen toimii.
Mutta mitä me yleensä haluavat tehdä on haluamme luoda kopion osoitin,
ja sitten me käyttää kyseistä kopiota kun olemme liikkuu merkkijono.
Eli näissä tapauksessa käytät kopioida tulostaa koko merkkijonon,
mutta meillä ei ole tehdä kuten osoitin miinus 6 tai seurata, kuinka paljon muutimme tähän,
vain koska tiedämme, että alkuperäinen piste on edelleen viittasivat listan alkuun
ja kaikki me muuttaneet oli tämä kopio.
Niin, yleensä muuttaa kopioita alkuperäisen osoittimen.
Älä yritä tavallaan kuin - älä muuta alkuperäistä kappaletta.
Yritetään muuttaa vain kopioita alkuperäisistä.
Joten, huomaat kun ohitamme merkkijono printf
sinun ei tarvitse laittaa tähti edessä kuin teimme kaikkien muiden dereferences, eikö?
Joten, jos tulostaa koko merkkijono% s odottaa on osoite,
ja tässä tapauksessa osoitin tai tässä tapauksessa, kuten erilaisia ​​merkkejä.
>> Hahmot, char * s, ja ryhmät ovat sama asia.
Pointer on merkkejä, ja merkki ryhmät ovat sama asia.
Ja niin, meidän täytyy tehdä, on kulkea osoitin.
Meillä ei tarvitse kulkea kuin * osoitin tai mitään sellaista.
Niin, taulukot ja osoittimet ovat sama asia.
Kun teet jotain x [y] yli täällä array,
mitä se tekee konepellin alle on se sanoo, okei, se on merkki array,
joten se on osoitin.
Ja niin x on sama asia,
ja niin mitä se tekee on se lisää y x,
joka on sama asia kuin eteenpäin muistiin, että paljon.
Ja nyt x + y antaa meille jonkinlaisen osoitteen,
ja me dereference osoite tai seuraa nuolta
missä se paikkaan muistissa on ja saamme arvo pois, että sijainti muistissa.
Joten, joten nämä kaksi ovat täsmälleen sama asia.
Se on vain syntaktinen sokeri.
He tekevät samaa. He vain eri syntactics toisilleen.
>> Joten, mikä voi mennä vikaan viitteitä? Like, paljon. Okei. Joten, pahoja asioita.
Joitakin huonoja asioita voit tehdä ole tarkistaa jos malloc puhelu palautuu null, eikö?
Tässä tapauksessa pyydän järjestelmä antaa minulle - mikä on se määrä?
Kuten 2000000000 kertaa 4, koska koko kokonaisluku on 4 tavua.
Pyydän sitä kuten 8000000000 tavua.
Tietenkin minun tietokone ei pystynyt antamaan minulle paljon muistia takaisin.
Ja me ei tarkista, onko se tyhjä, joten kun yritämme dereference se tuonne -
seuraa nuolta minne se menee - meillä ei ole, että muisti.
Tämä on mitä me kutsumme dereferencing nollaosoittimen.
Ja tämä lähinnä aiheuttaa voit segfault.
Tämä on yksi tavoista, joilla voit segfault.
Muita huonoja asioita voit tehdä - noh.
Se oli dereferencing nollaosoittimen. Okei.
Muita huonoja asioita - hyvin, vahvistaa, että olet vain laittaa sekin siellä
joka tarkistaa, onko osoitin on null
ja lähteneet ohjelmaan, jos käy niin, että malloc palauttaa nollaosoittimen.
Se xkcd koominen. Ihmiset ymmärtävät nyt. Tavallaan.
>> Niin, muistin. Ja menin tämän.
Olemme soittamalla malloc vuonna silmukka, mutta joka kerta kun soittaa malloc
menetämme raidan jos osoitin on osoittaa,
koska olemme clobbering sitä.
Joten, ensimmäinen puhelu malloc antaa minulle muistiin tänne.
Minun osoitin viitteitä tähän.
Nyt en vapauttaa sitä, joten nyt kutsun malloc uudelleen.
Nyt se osoittaa tänne. Nyt minun muisti osoittaa tänne.
Pointing tänne. Pointing tänne.
Mutta olen kadottaa osoitteet kaikkien muistin tänne, että olen varattu.
Ja nyt minulla ei ole mitään viittausta niihin enää.
Joten en voi vapauttaa heidät ulkopuolelle tämän silmukan.
Ja niin jotta korjata jotain tällaista,
Jos unohdat vapaata muistia ja saat tämän muistivuoto,
Sinun täytyy vapauttaa muistia, tämän silmukan kun olet tehnyt sen kanssa.
No, tämä on mitä tapahtuu. Tiedän paljon vihaat tätä.
Mutta nyt - yay! Saat kuten 44000 kilotavua.
Niin, et vapauttaa sen lopussa silmukan,
ja että menee vain vapauttaa muistia aina.
Pohjimmiltaan, sinun ohjelma ei muistivuoto enää.
>> Ja nyt jotain muuta voit tehdä on vapauttaa muistia, että olet pyytänyt kahdesti.
Tässä tapauksessa sinun malloc jotain, muutat sen arvoa.
Voit vapauttaa sen kerran, koska sanoit tehnyt sitä.
Mutta sitten vapautti sen taas.
Tämä on jotain, joka on aika paha.
Se ei tule aluksi segfault,
mutta sen jälkeen, kun Mikä tämä on kaksinkertainen vapauttaa tämä turmelee keon rakenteeseen,
ja opit hieman enemmän tästä, jos haluat ottaa luokkaa kuin CS61.
Mutta pohjimmiltaan jälkeen, kun tietokone on menossa sekaisin
mitä muistipaikkaa missä ja mihin se on tallennettu -
jossa data tallennetaan muistiin.
Ja niin vapauttaa osoitin kahdesti on huono asia, että et halua tehdä.
>> Muita asioita, jotka voivat mennä pieleen ei käytä sizeof.
Eli tässä tapauksessa sinun malloc 8 tavua,
ja se on sama asia kuin kaksi kokonaislukua, eikö?
Niin, se on täysin turvallista, mutta onko se?
No, kuten Lucas puhui eri arkkitehtuurit,
kokonaisluvut ovat eripituisia.
Niin, laite, käytät, kokonaisluvut ovat noin 4 tavua,
mutta jokin muu järjestelmä ne voivat olla 8 tavua tai ne voivat olla 16 tavua.
Joten, jos vain käyttää tätä numeroa tänne,
tämä ohjelma voi työskennellä laitteen
mutta se ei aio käyttää riittävästi muistia jonkin muun järjestelmän.
Tässä tapauksessa, tämä on mitä sizeof operaattori käytetään.
Kun me kutsumme sizeof (int), mitä tämä tekee, on
se antaa meille koko kokonaisluku järjestelmän, että ohjelma on käynnissä.
Eli tässä tapauksessa, sizeof (int) palauttaa 4 jotain laitetta,
ja nyt tämä tahto 4 * 2, joka on 8,
joka on vain paljon tilaa tarvitaan kaksi kokonaislukua.
Toisella koneella, jos int on kuin 16 tavua tai 8 tavua,
se vain tulee palata tarpeeksi tavua tallentaa tätä määrää.
>> Ja lopuksi, tietueet.
Joten, jos halusi tallentaa sudoku hallituksen muistissa, miten voisi teemme tämän?
Saatat ajatella kuin muuttuja ensimmäinen asia,
muuttuja toinen asia, muuttuja kolmas asia,
muuttuja Neljäs asia - paha, eikö?
Niin, yksi parannus voit tehdä tämän päälle on tehdä 9 x 9 array.
Se on hienoa, mutta mitä jos halusi liittää muita asioita sudoku hallituksen
kuten mitä vaikeus lauta on,
tai esimerkiksi mitä pisteet on, tai kuinka paljon aikaa se on vienyt sinua ratkaisemaan tämän hallituksen?
No, mitä voit tehdä, on voit luoda struct.
Mitä olen periaatteessa sanonta on olen määritellään tämä rakenne tänne,
ja olen määrittelemällä sudoku hallituksen, joka koostuu aluksella, joka on 9 x 9.
>> Ja mitä se on se on viitteitä nimen tasolle.
Se on myös x ja y, jotka ovat koordinaatit missä olen juuri nyt.
Se on myös aika [käsittämättömiä], ja se on määrä liikkuu olen syötetään tähän mennessä.
Ja niin tässä tapauksessa voin ryhmitellä koko joukko dataa vain yksi rakenne
sen sijaan, niin kuin lentävät ympäriinsä kuin eri muuttujien
että en todellakaan voi seurata.
Ja tämä antaa meille on vain mukavaa syntaksi tavallaan viitataan eri asioita sisällä tämän struct.
Voin vain tehdä board.board, ja saan sudoku hallituksen takana.
Board.level, saan kuinka kova se on.
Board.x ja board.y anna minulle koordinaatit missä voisin olla aluksella.
Ja niin olen päästä kutsumme kentät struct.
Tämä määrittää sudokuBoard, joka on tyyppi, joka minulla on.
Ja nyt olemme täällä. Olen muuttuja nimeltä "board" tyyppi sudokuBoard.
Ja nyt voin käyttää kaikkia kenttiä, jotka muodostavat tämän rakenteen tänne.
>> Kysyttävää tietueet? Kyllä?
[Student] For int x, y, te julisti molemmat yhdellä rivillä? >> [Joseph] Uh-huh.
[Student] Joten, voisitko tehdä, että ne kaikki?
Kuten x, y pilkku kertaa yhteensä?
[Joseph] Kyllä, voit varmasti tehdä, mutta esittämäni x ja y samalla linjalla -
ja kysymys on, miksi voimme vain tehdä tämän samalla linjalla?
Miksi emme vain laittaa kaikki nämä samalla rivillä on
x ja y ovat sukua toisilleen,
ja tämä on vain tyylillisesti oikeampi, tavallaan
koska se ryhmittelyä kaksi asiaa samalla linjalla
että kuten tavallaan liittyy sama asia.
Ja minä vain jakaa nämä toisistaan. Se on vain tyyli juttu.
Se toiminnallisesti ole väliä millään.
Kaikki muut kysymykset tietueet?
Voit määrittää Pokedex jossa struct.
Pokémon on numero ja se on kirje, omistaja, tyyppi.
Ja sitten jos sinulla on joukko Pokémon, voit tehdä jopa Pokedex, eikö?
Okei, viileä. Joten kysymyksiä tietueet. Nämä liittyvät tietueet.
>> Lopuksi, GDB. Mitä GDB voit tehdä? Sen avulla voit debug ohjelman.
Ja jos et ole käyttänyt GDB, olisin suositellut katsomassa lyhyt
ja juuri menee yli mitä GDB on, miten työskennellä sen kanssa, miten voit käyttää sitä,
ja testata sitä ohjelmaa.
Ja niin mitä GDB voit tehdä on se antaa tauko [käsittämätön] oman ohjelman
ja käytännön linjan.
Esimerkiksi haluan keskeyttää suorituksen kuten linja 3 minun ohjelma
ja kun olen rivillä 3 voin tulostaa kaikki arvot, jotka ovat siellä.
Ja niin me kutsumme kuin pysähtyen linjassa
on me kutsumme tätä asettaa keskeytyskohdan että linja
ja sitten voimme tulostaa muuttujien tilan ohjelman tuolloin.
>> Voimme sitten sieltä selata ohjelman rivi riviltä.
Ja sitten voimme tarkastella tilaa pinon tuolloin.
Ja niin, jotta voit käyttää GDB, mitä teemme, on me kutsumme clang on C-tiedosto,
mutta meidän on kuljettava se-ggdb lippua.
Ja kun olemme tehneet, että me vain ajaa GDB on tuloksena tuotoksen tiedosto.
Ja niin saat joitakin kuten massa tekstiä näin,
mutta oikeastaan ​​kaikki sinun tarvitsee vain kirjoittaa komentoja alussa.
Rikkoa tärkein asettaa keskeytyskohdan tärkein.
Luettelo 400 luettelee koodia noin rivin 400.
Ja niin tässä tapauksessa voit vain katsella ympärilleen ja sanoa, OH,
Haluan asettaa keskeytyskohdan linja 397, joka on tätä linjaa,
ja sitten käynnistyy tuohon vaiheeseen ja se tulee katkaista.
Se tulee keskeyttää siellä, ja voit tulostaa, esimerkiksi arvo matala tai korkea.
Ja niin on olemassa joukko komentoja, sinun täytyy tietää,
ja tämä diaesitys menee ylös verkkosivuilla,
joten jos haluat vain viitata näihin tai haluat laittaa ne huijata lakanat, rohkeasti.
>> Cool. Se oli Quiz arvostelu 0, ja me kiinni noin, jos sinulla on kysyttävää.
Selvä.
>> [Aplodit]
>> [CS50.TV]