>> [MUSIIKKIA]
>> DAVID J. MALAN: Selvﾃ､.
Tﾃ､mﾃ､ on CS50 ja tﾃ､mﾃ､n on alku Viikko 2.
Ja te muistaa, ettﾃ､ yli parin viime viikon aikana,
olemme esitelleet tietokoneella tiede ja puolestaan 窶銀黍hjelmointi.
>> Ja aloitimme tarinan Poiketen Scratch, ettﾃ､ graafinen kieli
MIT: N Media Lab.
Ja sitten viimeksi viime viikolla, teki meidﾃ､n
kﾃ､yttﾃｶﾃｶn higher-- alemman tason kieli tiedossa
kuten C, jotain, joka on puhtaasti tekstimuodossa.
Ja todellakin, viimeinen kerta tutkia niihin liittyvistﾃ､
useita kﾃ､sitteitﾃ､.
>> Tﾃ､mﾃ､ muistuttaa, oli hyvin Ensimmﾃ､inen ohjelma tarkastelimme.
Ja tﾃ､mﾃ､ ohjelma, yksinkertaisesti, tulostaa, "hei, maailma."
Mutta on niin paljon nﾃ､ennﾃ､isestﾃ､ magic meneillﾃ､ﾃ､n.
Ei tﾃ､mﾃ､ include Nﾃ､iden Kulmasulkeet.
On int.
On (void).
On sulkuja, aaltosulkeita, puolipistettﾃ､, ja niin paljon enemmﾃ､n.
>> Ja niin, muistaa, ettﾃ､ otimme kﾃ､yttﾃｶﾃｶn Scratch
jotta voisimme ihannetapauksessa nﾃ､hdﾃ､ ohi ettﾃ､ syntaksi, tavaraa, joka ei todellakaan ole
kaikki ettﾃ､ ﾃ､lyllisesti mielenkiintoinen, mutta jo varhain
on, ehdottomasti, vﾃ､hﾃ､n hankala kﾃ､ﾃ､riﾃ､ mielesi ympﾃ､rille.
Ja, todellakin, yksi yleisimmistﾃ､ asiat varhaisessa ohjelmointi luokan,
erityisesti niille vﾃ､hemmﾃ､n mukava, on saada turhautuvat
katkaisemaan jopa tiettyjen syntaktinen virheet, puhumattakaan loogisia virheitﾃ､.
Ja niin keskuudessa tavoitteemme tﾃ､nﾃ､ﾃ､n, todella, tulee
olla varustaa sinulle joitakin ongelmanratkaisu tekniikoita, miten
paremmin ratkaista ongelmia itse muodossa virheenkorjaus.
Ja voit muistaa myﾃｶs, ettﾃ､ ympﾃ､ristﾃｶ ettﾃ､ otimme kﾃ､yttﾃｶﾃｶn
Edellisen kerran kutsuttiin CS50 IDE.
Tﾃ､mﾃ､ on web-pohjainen ohjelmisto, joka voidaan ohjelmoida pilvessﾃ､,
niin sanotusti, pitﾃ､en kaikki tiedostot yhteen, kuten olemme jﾃ､lleen tulee tﾃ､nﾃ､ﾃ､n.
Ja muistaa, ettﾃ､ me revisited nﾃ､istﾃ､ aiheista tﾃ､ﾃ､llﾃ､,
joukossa toimintoja, ja silmukoita, ja muuttujia, ja Boolen operaattoreilla,
ja olosuhteet.
Ja itse asiassa vielﾃ､ muutama ettﾃ､ olemme kﾃ､ﾃ､nnetty maailmasta Scratch
maailmaan C.
>> Mutta perusongelma rakennus lohkot, niin sanotusti,
olivat todella edelleen sama viime viikolla.
Itse asiassa olemme todella vain oli eri palapelin pala, jos haluatte.
Sen sijaan, ettﾃ､ violetti tallentaa lohko, me sen sijaan
oli printf, joka on Tﾃ､tﾃ､ toimintoa C ettﾃ､
voit tulostaa jotain ja alustaa sen ruudulla.
Otimme CS50 Kirjasto, jossa
on nyt kﾃ､ytettﾃ､vissﾃ､nne get_char, ja get_int, ja get_string,
ja muutamia muita toimintoja hyvin, jonka kautta voi saada syﾃｶttﾃ､ﾃ､
kﾃ､yttﾃ､jﾃ､n omalla nﾃ､ppﾃ､imistﾃｶllﾃ､.
Ja me myﾃｶs katsoimme asioita kuten these- bool, ja nieriﾃ､,
ja kaksinkertainen, kellua, int, long_long merkkijono.
Ja siellﾃ､ on jopa muita tietotyyppejﾃ､ C.
>> Toisin sanoen, kun julistaa muuttuja tallentaa jotain arvoa,
tai kun toteuttaa funktion joka palauttaa jotain arvoa,
voit mﾃ､ﾃ､rittﾃ､ﾃ､, mitﾃ､ tyyppinen arvo on.
Onko se merkkijono, kuten merkkijono?
Onko se numero, kuten kokonaisluku?
Onko se liukuluku arvo, tai vastaavaa?
Joten C, toisin kuin Scratch, me todellakin alkoi mﾃ､ﾃ､rittﾃ､ﾃ､, millaisia 窶銀逆ietoja
olimme palaamassa tai kﾃ､yttﾃ､mﾃ､llﾃ､.
>> Mutta tietysti myﾃｶs tﾃｶrmﾃ､si joitakin perustavanlaatuisia rajoja computing.
Ja erityisesti, tﾃ､llﾃ､ kielellﾃ､ C, recall
ettﾃ､ me katsoimme kokonaisluvun ylivuoto, todellisuus
ettﾃ､ jos sinulla on vain rajallinen mﾃ､ﾃ､rﾃ､ muistia
tai, erityisesti, rajallinen mﾃ､ﾃ､rﾃ､ bittejﾃ､, voi vain laskea niin korkea.
Ja niin me katsoimme tﾃ､tﾃ､ esimerkkiﾃ､ tﾃ､stﾃ､ jolloin laskuri lentokoneella,
todella, jos kﾃ､ynnissﾃ､ tarpeeksi kauan olisi ylivuoto ja johtaa ohjelmistojen
todelliseen fyysiseen mahdollinen virhe.
>> Me tarkasteltiin myﾃｶs kelluva piste epﾃ､tﾃ､smﾃ､llisyys, todellisuus
ettﾃ､ vain rajallinen mﾃ､ﾃ､rﾃ､ bittien, onko se 32 tai 64,
voit vain mﾃ､ﾃ､rittﾃ､ﾃ､ niin monta numeroa jﾃ､lkeen desimaalierottimen jonka jﾃ､lkeen
alkaa saada epﾃ､tarkka.
Niinpﾃ､ esimerkiksi kolmasosa on maailma tﾃ､ﾃ､llﾃ､, meidﾃ､n ihmisten maailmassa,
tiedﾃ､mme vain ﾃ､ﾃ､retﾃｶn mﾃ､ﾃ､rﾃ､ 3s desimaalipisteen jﾃ､lkeen.
Mutta tietokone ei voi vﾃ､lttﾃ､mﾃ､ttﾃ､ edustavat ﾃ､ﾃ､retﾃｶn mﾃ､ﾃ､rﾃ､ numeroita
jos vain antaa sille joitakin rajallinen mﾃ､ﾃ､rﾃ､ tietoa.
>> Joten ei ainoastaan 窶銀砧e varustaa voit enemmﾃ､n valtaa suhteen
miten voit ilmaista itseﾃ､si nﾃ､ppﾃ､imistﾃｶ ohjelmatyﾃｶn,
me myﾃｶs rajoitettu mitﾃ､ voit itse tehdﾃ､.
Ja todellakin, bugeja ja virheitﾃ､ voi syntyvﾃ､t tuollaiset asiat.
Ja todellakin, joukossa aiheista tﾃ､nﾃ､ﾃ､n tulevat olemaan aiheita kuten virheenkorjaus
ja todella etsivﾃ､t alla huppu kuinka asiat esiteltiin viime viikolla
todella toteutetaan jotta voit paremmin
ymmﾃ､rtﾃ､ﾃ､ sekﾃ､ ominaisuuksia ja rajoitukset kielen kuten C.
>> Ja itse asiassa, me kuori takaisin kerroksia yksinkertaisin tietorakenne,
jotain kutsutaan joukko, joka Scratch sattuu soittaa "lista."
Se on hieman Eri tﾃ､ssﾃ､ yhteydessﾃ､.
Ja sitten me myﾃｶs esitellﾃ､ yksi Ensimmﾃ､inen meidﾃ､n domain-erityisongelmat
in CS50, maailma salaus, taidetta muokkaamisella
tai salausinformaatioon niin ettﾃ､ voit lﾃ､hettﾃ､ﾃ､ salaisia 窶銀久iestejﾃ､
ja purkaa salaisia 窶銀久iestejﾃ､ kahden henkilﾃｶn vﾃ､lillﾃ､, A ja B.
>> Joten ennen kuin siirtyminen kyseiseen uuteen maailmaan,
koetamme varustaa sinulle joitakin tekniikoita, jolla voit poistaa
tai vﾃ､hentﾃ､ﾃ､ ainakin joitakin turhautumista
ettﾃ､ olet todennﾃ､kﾃｶisesti kohdannut viime viikon yksin.
Itse asiassa, ennen olet such-- joitakin ensimmﾃ､inen ongelmat C. Ja kertoimet ovat,
jos olet kuten minﾃ､, ensimmﾃ､istﾃ､ kertaa yritﾃ､t kirjoittaa ulos ohjelma,
vaikka luulet loogisesti ohjelma on melko yksinkertainen,
saatat hyvinkin osui seinﾃ､ﾃ､n, ja kﾃ､ﾃ､ntﾃ､jﾃ､ ei aio tehdﾃ､ yhteistyﾃｶtﾃ､.
Tee tai Clang ei aio todella tehdﾃ､ oman hinnoittelu.
>> Ja miksi se voisi olla?
No, katsomaan, ehkﾃ､ yksinkertainen ohjelma.
Aion mennﾃ､ eteenpﾃ､in ja tallenna tﾃ､mﾃ､ Tiedoston tarkoituksella nimeltﾃ､ buggy0.c,
koska tiedﾃ､n sen olla virheellinen etukﾃ､teen.
Mutta en ehkﾃ､ ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ jos tﾃ､mﾃ､ on ensimmﾃ､inen tai toinen tai kolmas ohjelma
ettﾃ､ olen todella tehdﾃ､ itse.
Joten aion mennﾃ､ eteenpﾃ､in ja kirjoittamiseen, int main (void).
Ja sitten sisﾃ､llﾃ､ minun aaltosulkeita, hyvin tuttu ( "Hei, world--
backslash, n ") - ja puolipisteellﾃ､.
>> Olen tallentanut tiedoston.
Nyt aion mennﾃ､ alas minun pﾃ､ﾃ､teikkuna
ja tyyppi tehdﾃ､ buggy0, koska, jﾃ､lleen, nimi tiedoston nykyﾃ､ﾃ､n buggy0.c.
Joten kirjoitan tehdﾃ､ buggy0, Enter.
>> Ja oi, gosh, muistaa viime kerran ettﾃ､ ei virheilmoitukset on hyvﾃ､ asia.
Joten ei ulostulo on hyvﾃ､ asia.
Mutta tﾃ､ﾃ､llﾃ､ minulla on selvﾃ､sti jotkut mﾃ､ﾃ､rﾃ､ virheitﾃ､.
>> Joten ensimmﾃ､inen rivi ulostulo kirjoittamisen jﾃ､lkeen tehdﾃ､ buggy0, recall,
on Clang n melko laveasti.
Alapuolella huppu, CS50 IDE on konfiguroitu
kﾃ､yttﾃ､ﾃ､ koko joukko vaihtoehtoja tﾃ､mﾃ､n kﾃ､ﾃ､ntﾃ､jﾃ､
jotta sinun ei tarvitse ajatella niitﾃ､.
Ja siinﾃ､ kaikki, ettﾃ､ ensimmﾃ､inen rivi keinot, joka alkaa Clang.
>> Mutta sen jﾃ､lkeen, ongelmia alkaa tehdﾃ､ niiden ulkonﾃ､kﾃｶﾃ､.
Buggy0.c rivillﾃ､ 3, character 5, on suuri, punainen virhe.
Mikﾃ､ tuo on?
Epﾃ､suorasti julistaa kirjaston funktion printf tyypin int (const char *,
...) [-Werror].
Siis, se hyvin nopeasti saa hyvin vaikeaselkoisia.
Ja varmasti, ensin silmﾃ､yksellﾃ､, me emme tahdo
odottavat sinua ymmﾃ､rtﾃ､mﾃ､ﾃ､n kokonaisuudessaan kyseisen viestin.
Ja niin yksi opetuksista tﾃ､nﾃ､ﾃ､n on menossa
olla yrittﾃ､ﾃ､ huomata kuvioita, tai samanlaisia 窶銀蟻sioita,
virheisiin saatat olla kohdannut aikaisemmin.
Joten kiusaa toisistaan 窶銀久ain ne sanat, jotka tutulta.
Suuri punainen virhe on selvﾃ､sti symbolinen jotain on vialla.
>> epﾃ､suorasti julistamisesta kirjaston funktion printf.
Joten vaikka en oikein ymmﾃ､rrﾃ､, mitﾃ､ epﾃ､suorasti julistaa kirjaston funktion
keinoin, ongelma varmasti koskee printf jotenkin.
Ja lﾃ､hde tﾃ､stﾃ､ asiasta on tekemistﾃ､ julistaa sen.
>> Julistamisesta toiminto on mainita sitﾃ､ ensimmﾃ､istﾃ､ kertaa.
Ja kﾃ､ytimme terminologiaa viime viikolla julistaa funktion prototyyppi,
joko yhden rivin ylﾃ､reunassa oma tiedosto tai ns header-tiedosto.
Ja mitﾃ､ tiedostoa teki sanomme viime viikolla, ettﾃ､ printf on lainaus,
lainaus, julisti?
Missﾃ､ tiedosto on sen prototyyppi?
>> Joten jos muistatte, aivan ensimmﾃ､inen asia, I konekirjoitettu, lﾃ､hes jokainen ohjelma viime time--
ja vahingossa hetki sitten alkanut kirjoittamalla myself-- oli tﾃ､mﾃ､ here--
hash-- #include <stio-- varten tulo / output-- piste h Ja todellakin,
kun nyt tallentaa tﾃ､mﾃ､n tiedoston, aion mennﾃ､ eteenpﾃ､in ja tyhjentﾃ､ﾃ､ nﾃ､ytﾃｶn,
joka voi tehdﾃ､ kirjoittamalla Kirkas, tai voit pitﾃ､ﾃ､ Ohjaus L,
vain tyhjentﾃ､ﾃ､ pﾃ､ﾃ､teikkunaan vain poistamaan joitakin sotkua.
>> Aion mennﾃ､ eteenpﾃ､in ja re-tyyppinen merkki buggy0, Enter.
Ja voila, olen edelleen nﾃ､hdﾃ､, ettﾃ､ pitkﾃ､ komento Clang,
mutta ei ole mitﾃ､ﾃ､n virheilmoitusta tﾃ､llﾃ､ kertaa.
Ja todellakin, jos en ./buggy0, aivan kuten viime kerralla,
missﾃ､ piste tarkoittaa tﾃ､mﾃ､ hakemisto, Slash vain tarkoittaa,
tﾃ､ssﾃ､ tulee ohjelman nimi ja ettﾃ､ ohjelman nimi on buggy0,
Enter, "hei, maailma."
>> Nyt miten voisi olet poimittu tﾃ､mﾃ､ ratkaisu
ilman vﾃ､lttﾃ､mﾃ､ttﾃ､ tunnustaa niin monta sanaa
kuten tein, varmasti, joilla tehnyt tﾃ､mﾃ､n niin monta vuotta?
No, ymmﾃ､rtﾃ､ﾃ､ per ensimmﾃ､inen ongelma set, esittelemme komentoon
ettﾃ､ CS50 oma henkilﾃｶkunta kirjoitti kutsutaan help50.
Ja todellakin, C tekee mﾃ､ﾃ､rittelyn ongelma asetettu, miten kﾃ､yttﾃ､ﾃ､ tﾃ､tﾃ､.
>> Mutta help50 on olennaisesti ohjelma, joka CS50 henkilﾃｶstﾃｶ
kirjoitti, ettﾃ､ voit ajaa komennon tai suorita ohjelma,
ja jos et ymmﾃ､rrﾃ､ sen ulostulo, siirtﾃ､ﾃ､ tuotannostaan 窶銀吃elp50,
jolloin ohjelmisto ettﾃ､ kurssin henkilﾃｶkunta kirjoitti
tarkastellaan ohjelman ulostulo rivi riviltﾃ､, 窶銀砧erkki kerrallaan.
Ja jos me, henkilﾃｶkunta, tunnistaa virheilmoituksen, joka sinulla on,
yritﾃ､mme provosoida teille joitakin retorisia kysymyksiﾃ､, joitakin neuvoja,
paljon kuin TF tai CA tai itse tekisi henkilﾃｶkohtaisesti virka.
>> Niin katso help50 jos et vﾃ､lttﾃ､mﾃ､ttﾃ､ tunnista ongelma.
Mutta eivﾃ､t ole riippuvaisia 窶銀虐iitﾃ､ liian paljon kuin kainalosauva.
Varmasti yrittﾃ､ﾃ､ ymmﾃ､rtﾃ､ﾃ､ sen lﾃ､htﾃｶ ja sitten oppia siitﾃ､
niin ettﾃ､ vain kerran tai kahdesti sinﾃ､ koskaan ajaa help50 tietylle virhe
viesti.
Tﾃ､mﾃ､n jﾃ､lkeen sinun pitﾃ､isi olla paremmat itse
selvittﾃ､ﾃ､, mitﾃ､ se todellisuudessa on.
>> Tehdﾃ､ﾃ､n yksi muu tﾃ､ﾃ､llﾃ､.
Anna minun mennﾃ､ eteenpﾃ､in, ja toiseen tiedosto me kutsumme tﾃ､tﾃ､ buggy1.c.
Ja tﾃ､hﾃ､n tiedostoon olen menossa deliberately--
mutta teeskennellﾃ､ ettﾃ､ en ymmﾃ､rtﾃ､ﾃ､, mitﾃ､ virheen olen tehnyt.
>> Aion mennﾃ､ eteenpﾃ､in ja tehdﾃ､ this-- # include, koska olen
oppinut lﾃ､ksynsﾃ､ hetki sitten.
Int main (void), kuten aiemmin.
Ja sitten tﾃ､ﾃ､llﾃ､ aion tehdﾃ､ string s - get_string.
Ja muistaa viime kerran Tﾃ､mﾃ､ tarkoittaa, hei, tietokone,
antaa minulle muuttuja, soita se s, ja tehdﾃ､ tyypin muuttujan merkkijonon
joten en voi tallentaa yhden tai useamman sanan sitﾃ､.
>> Ja sitten oikeanpuoleisessa puolella yhtﾃ､lﾃ､isyysmerkin
on get_string, joka on toiminto CS50 kirjastosta
ettﾃ､ juuri nﾃ､in.
Se saa funktio ja sitten kﾃ､siﾃ､ sen oikealta vasemmalle.
Joten tﾃ､mﾃ､ yhtﾃ､lﾃ､isyysmerkki ei tarkoita "On yhtﾃ､ kuin" kuten voisi luulla matematiikasta.
Se tarkoittaa toimeksianto oikealta vasemmalle.
Joten tﾃ､mﾃ､ tarkoittaa, ottaa merkkijonon kﾃ､yttﾃ､jﾃ､ ja tallentaa sen sisﾃ､llﾃ､ s.
>> Nyt kﾃ､yttﾃ､ﾃ､ sitﾃ､.
Anna minun mennﾃ､ eteenpﾃ､in nyt ja toisena line, anna minun mennﾃ､ eteenpﾃ､in ja sanoa "hei" -
ei "maailman", mutta "Hei,% S-- joka on meidﾃ､n paikkamerkki, pilkku s,
joka on meidﾃ､n vaihteleva, ja sitten puolipisteellﾃ､.
Joten jos en tyriﾃ､ liikaa tﾃ､ﾃ､llﾃ､, tﾃ､mﾃ､ nﾃ､yttﾃ､ﾃ､ oikean koodin.
>> Ja vaistoni ovat nyt niiden kerﾃ､ﾃ､miseksi.
Tiedosto on nimeltﾃ､ﾃ､n buggy1.c.
Joten aion tehdﾃ､ tehdﾃ､ buggy1, Enter.
Ja hiton-, jos se ei ole vielﾃ､kin enemmﾃ､n virheitﾃ､ kuin ennen.
Siis, ei enempﾃ､ﾃ､ virheilmoituksia se olisi
nﾃ､yttﾃ､vﾃ､t kuin todellinen riviﾃ､ tﾃ､ssﾃ､ ohjelmassa.
>> Mutta takeaway tﾃ､ssﾃ､, vaikka olet hukkua
joissa on kaksi tai kolme tai neljﾃ､ enemmﾃ､n virheilmoituksia,
keskittyvﾃ､t aina hyvin Ensimmﾃ､inen nﾃ､istﾃ､ viesteistﾃ､.
Tarkasteltaessa Ylimmﾃ､ssﾃ､ yksi, rullata takaisin ylﾃｶs kuin tarvetta on.
Joten tﾃ､ssﾃ､ olen kirjoittanut make buggy1.
Tﾃ､ssﾃ､ ettﾃ､ Clang tuotanto odotetusti.
>> Ja tﾃ､ssﾃ､ on ensimmﾃ､inen punainen virhe.
Kﾃ､ytﾃ､ pimeﾃ､n tunnisteen string, minﾃ､ tarkoitan vakiona?
Joten standardi on todella jotain muuta.
Se viittaa kﾃ､yttﾃ､jﾃ､n nﾃ､ppﾃ､imistﾃｶ, lﾃ､hinnﾃ､.
>> Mutta se ei ole mitﾃ､ tarkoitin.
Tarkoitin merkkijono, ja tarkoitin get_string.
Mikﾃ､ siis on se, ettﾃ､ minﾃ､ unohti tehdﾃ､ tﾃ､llﾃ､ kertaa?
Mitﾃ､ puuttuu tﾃ､llﾃ､ kertaa?
Minulla on # include, joten Olen pﾃ､ﾃ､sy printf.
>> Mutta mitﾃ､ minﾃ､ ole pﾃ､ﾃ､sy vain vielﾃ､?
No, aivan kuten viime kerralla, Minun tﾃ､ytyy kertoa kﾃ､ﾃ､ntﾃ､jﾃ､
Kalahtaa mitﾃ､ nﾃ､mﾃ､ toiminnot ovat.
Get_string ei tule C. Ja erityisesti, se
ei tulla header tiedosto,.
Se sijaan tulee jotain henkilﾃｶkunta kirjoitti,
joka on eri tiedosto nimetﾃ､ mutta osuvasti nimetty.
>> Joten yksinkertaisesti lisﾃ､ﾃ､mﾃ､llﾃ､, ettﾃ､ yhdellﾃ､ rivillﾃ､ of code-- hae viimeksi
ettﾃ､ kun Clang kulkee, se tulee katsomaan minun koodi ylhﾃ､ﾃ､ltﾃ､ alas,
vasemmalta oikealle.
Se tulee huomata, oh, haluat.
Anna minun mennﾃ､ ja huomaavat, missﾃ､ se on palvelimella,
Kopioi ja liitﾃ､ se pﾃ､ﾃ､asiallisesti, ylﾃ､osaan oman tiedoston
jotta tﾃ､ssﾃ､ vaiheessa tarinan, rivi 1, loput ohjelman
voi todellakin kﾃ､yttﾃ､ﾃ､ mitﾃ､ tahansa toimintoja siinﾃ､ joukossa get_string.
Joten aion sivuuttaa loput nﾃ､istﾃ､ virheistﾃ､,
koska olen todellakin epﾃ､illﾃ､, ettﾃ､ vain ensimmﾃ､inen todella vﾃ､liﾃ､.
Ja aion mennﾃ､ eteenpﾃ､in ja uusinta, tallennuksen jﾃ､lkeen minun arkistoida tehdﾃ､ buggy1.
Ja voila, se teki tyﾃｶtﾃ､.
Ja jos en ./buggy1 ja kirjoita varten Esimerkiksi Zamyla, en nyt saa hei,
Zamyla sijasta hei, maailma.
>> Selvﾃ､.
Joten takeaways tﾃ､ﾃ､llﾃ､ sitten ovat, yksi, yrittﾃ､ﾃ､ poimia niin paljon kuin voit
alkaen virheilmoitukset yksin, etsii joitakin tunnistettavia sanoja.
Esto, ettﾃ､ kﾃ､yttﾃ､vﾃ､t help50 per ongelma asettaa erittely.
Mutta esto ettﾃ､ myﾃｶs aina etsiﾃ､ ylﾃ､osassa virhe vain, vﾃ､hintﾃ､ﾃ､n
aluksi, mitﾃ､ tietoja se voisi todella tuottaa.
Mutta nﾃ､yttﾃ､ﾃ､ siltﾃ､ siellﾃ､ n vielﾃ､kin enemmﾃ､n toimintoja rakennettu
osaksi CS50 Library auttaa te varhaisessa lukukausi
ja varhaisessa vaiheessa ohjelmointi selvittﾃ､ﾃ､, mitﾃ､ on vialla.
Tehdﾃ､ﾃ､npﾃ､ toinen esimerkki tﾃ､stﾃ､.
Aion kutsua tﾃ､tﾃ､ buggy2, joka, taas aiotaan virheellinen ulos
portin suunnittelun.
>> Ja aion mennﾃ､ eteenpﾃ､in ja tehdﾃ､ # include.
Ja sitten aion tehdﾃ､ int main (void).
Ja sitten aion tehdﾃ､ silmukka.
For (int i _ 0.
i on pienempi tai yhtﾃ､ suuri kuin 10.
i ++, ja sitten aaltosulkeita, aion tulostaa vain hashtagia symboli tﾃ､ﾃ､llﾃ､
ja uusi rivi merkki.
>> Joten tahallisuus tﾃ､mﾃ､n Ohjelma on yksinkertaisesti
kerrata 10 kertaa ja jokaisen iteraation
Tﾃ､mﾃ､n silmukan kerta lﾃ､pi sykli,
tulostaa hashtagia, hashtagia, hashtagia.
Yksi per rivi, koska olen on uusi linja siellﾃ､.
Ja muistuttaa, ettﾃ､ varten silmukka, kohti viime week--
ja saat enemmﾃ､n perehtynyt syntaksia
kﾃ､yttﾃ､mﾃ､llﾃ､ sitﾃ､ kﾃ､ytﾃ､ntﾃｶﾃ､ ennen long-- tﾃ､mﾃ､ antaa minulle
muuttuja nimeltﾃ､ i ja asettaa sen 0.
>> Tﾃ､mﾃ､ kasvattaa i pﾃ､ﾃ､lle jokainen iteraatio 1.
Joten i menee 1-2 ja 3 vastaan.
Ja sitten tﾃ､stﾃ､ ehdosta keskimmﾃ､inen vﾃ､lillﾃ､ puolipisteet
saa tarkastaa jokaisen iteraation tekemﾃ､ﾃ､n Varmista, ettﾃ､ olemme edelleen kuuluvuusalueella.
Joten haluan kerrata 10 kertaa, joten en on erﾃ､ﾃ､nlainen hyvin intuitiivisesti juuri
laittaa 10 minun ylﾃ､raja siellﾃ､.
>> Ja kuitenkin, kun kﾃ､ytﾃ､n tﾃ､mﾃ､n jﾃ､lkeen kokoamisessa make buggy2--
ja se koota OK.
Joten en ole syntaksivirhe tﾃ､llﾃ､ kertaa.
Anna minun mennﾃ､ eteenpﾃ､in nyt ja ajaa buggy2, Enter.
Nyt selaa ylﾃｶspﾃ､in.
Ja haluaisin lisﾃ､tﾃ､ koko ikkunan.
>> Olen ilmeisesti on 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11.
Joten ei 11 hashtags, vaikka Olen selvﾃ､sti laittaa 10 sisﾃ､lle tﾃ､mﾃ､n silmukan.
Nyt jotkut teistﾃ､ ehkﾃ､ nﾃ､hdﾃ､ heti mikﾃ､ virhe johtuu siitﾃ､, ettﾃ､ itse asiassa, tﾃ､mﾃ､
ei ole kovin vaikea virhe tehdﾃ､.
Mutta se on hyvin yleisesti teki hyvin varhain.
>> Haluan huomauttaa kuitenkin, on, miten voisi minﾃ､ kuva tﾃ､stﾃ､?
No, kﾃ､y ilmi, ettﾃ､ CS50 kirjasto tulee
ei ainoastaan 窶銀吉et_string ja get_int ja get_float ja muita toimintoja.
Sen mukana tulee myﾃｶs erityinen toiminto nimeltﾃ､ﾃ､n eprintf, tai virhe printf.
Ja se on olemassa ainoastaan 窶銀逆ehdﾃ､ se hieman helpompaa
kun virheenkorjaus koodi vain tulosta virheilmoitus ruudulla
ja tietﾃ､ﾃ､, mistﾃ､ se tuli.
>> Niinpﾃ､ esimerkiksi yksi asia voisin tehdﾃ､ tﾃ､ﾃ､llﾃ､ tﾃ､llﾃ､ toiminnolla on this--
eprintf, ja sitten aion mennﾃ､ eteenpﾃ､in ja sanoa i on nyt% i, kenoviiva n.
Ja aion kytkeﾃ､ arvon i.
Ja ylﾃｶs, koska tﾃ､mﾃ､ on CS50 Library,
Aion mennﾃ､ eteenpﾃ､in ja sisﾃ､ltﾃ､vﾃ､t
joten minun tﾃ､ytyy kﾃ､yttﾃ､ﾃ､ tﾃ､tﾃ､ toimintoa.
Mutta Tarkastellaan mitﾃ､ linjaa 9 on tarkoitus olla tekemﾃ､ssﾃ､.
Aion poistaa tﾃ､mﾃ､n lopulta.
Tﾃ､llﾃ､ ei ole mitﾃ､ﾃ､n tekemistﾃ､ minun yleisenﾃ､ tavoitteena.
Mutta eprintf, virhe printf, on vain tarkoitus antaa minulle joitakin diagnostisia tietoja.
Kun olen suorittanut minun ohjelma, haluan nﾃ､hdﾃ､ tﾃ､mﾃ､n nﾃ､ytﾃｶn vﾃ､liaikaisesti
yhtﾃ､ hyvin ymmﾃ､rtﾃ､ﾃ､ mitﾃ､ tapahtuu.
>> Ja, todellakin, kullakin iterointia here linjan 9
Haluan nﾃ､hdﾃ､, mikﾃ､ on arvo i?
Mikﾃ､ on arvo i?
Ja toivottavasti minun pitﾃ､isi vain nﾃ､hdﾃ､, ettﾃ､ viestin, myﾃｶs 10 kertaa.
>> Joten anna minun mennﾃ､ eteenpﾃ､in ja kﾃ､ﾃ､ntﾃ､ﾃ､ minun ohjelma,
koska minun tﾃ､ytyy tehdﾃ､ tahansa I tehdﾃ､ muutoksia. ./buggy2.
Ja now-- OK.
Siellﾃ､ on paljon enemmﾃ､n tekeillﾃ､.
Haluan siis vierittﾃ､ﾃ､ ylﾃｶspﾃ､in vielﾃ､ suurempi ikkuna.
>> Ja nﾃ､et, ettﾃ､ jokainen hashtags on edelleen tulostuksen.
Mutta jokaisen niistﾃ､ on nyt tﾃ､mﾃ､ diagnostiikkalﾃ､htﾃｶ muotoiltu seuraavasti.
Nimi minun ohjelma tﾃ､ssﾃ､ buggy2.
Nimi tiedosto on buggy2.c.
Linjan numero, josta tﾃ､mﾃ､ painettiin on viiva 9.
Ja sitten oikealla joka on virheilmoituksen, Odotan.
>> Ja mitﾃ､ mukavaa tﾃ､stﾃ､ on, ettﾃ､ nyt en tarvitse vﾃ､lttﾃ､mﾃ､ttﾃ､ laskea
pﾃ､ﾃ､hﾃ､ni mitﾃ､ minun ohjelma tekee.
Nﾃ､en, ettﾃ､ on ensimmﾃ､inen iterointi i on 0,
Sitten 1, sitten 2, sitten 3 ja sitten 4, niin 5, sitten 6, sitten 7, niin 8, sitten 9, sitten
10.
Joten odota hetki.
Mitﾃ､ tﾃ､ﾃ､llﾃ､ tapahtuu?
Olen edelleen nﾃ､yttﾃ､vﾃ､t laskenta aiotulla jopa 10.
>> Mutta mistﾃ､ aloittaa?
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10.
Joten 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10-- 11. sormi
on osoitus ongelmasta.
Olen ilmeisesti lasketa virheellisesti minun silmukka.
Eikﾃ､ mennﾃ､ 10 toistojen, Olen alkaen 0,
Olen pﾃ､ﾃ､ttyy ja kautta 10.
Mutta koska, kuten tietokone, Olen alkanut laskenta 0,
Olisin laskemalla ylﾃｶs sen, mutta ei lﾃ､pi, 10.
>> Ja niin korjata, I lopulta toteutunut tﾃ､ﾃ､llﾃ､, on yksi kaksi asiaa.
Voisin hyvin yksinkertaisesti sanoa laskea jopa alle 10.
Joten 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, joka on todellakin oikea,
vaikka se kuulostaa vﾃ､hﾃ､n vﾃ､ﾃ､rin.
Tai sitten voisi tehdﾃ､ pienempi tai yhtﾃ､ suuri 9, niin kauan kuin minﾃ､ alkavat 0.
Tai jos todella eivﾃ､t pidﾃ､ siitﾃ､, et laskea lﾃ､pi 10 mutta alkavat 1.
Mutta jﾃ､lleen kerran, tﾃ､mﾃ､ vain ei ole kovin yleistﾃ､.
In programming-- vaikkakin ei niinkﾃ､ﾃ､n Scratch--
mutta ohjelmointi C ja muita kieliﾃ､,
kuten JavaScript ja Python ja muut, se on
vain hyvin yleinen keskustelumme binary
vain alkaa laskea tﾃ､llﾃ､ pienin mﾃ､ﾃ､rﾃ､ voit, joka on 0.
Selvﾃ､.
Niin, ettﾃ､ eprintf.
Ja vielﾃ､, nyt kun olen tajunnut minun ongelma, ja aion palata 0
kautta alle 10, aion mennﾃ､ ja poistaa eprintf.
>> Sen ei pitﾃ､isi olla siellﾃ､, kun alus minun koodi tai lﾃ､hetﾃ､ oma koodi
tai nﾃ､yttﾃ､ﾃ､ sitﾃ､ kenellekﾃ､ﾃ､n muulle.
Se on oikeastaan 窶銀久ain tarkoitti voidaan kﾃ､yttﾃ､ﾃ､ vﾃ､liaikaisesti.
Mutta nyt olen korjannut Erityisenﾃ､ ongelmana samoin.
>> No, tehdﾃ､ﾃ､n yksi esimerkki tﾃ､stﾃ､ ettﾃ､ aion lietsoa seuraavasti.
Aion mennﾃ､ eteenpﾃ､in ja #sisﾃ､ltﾃ､ﾃ､ . $ 50
Ja aion mennﾃ､ eteenpﾃ､in ja # include.
>> Ja aion sﾃ､ﾃ､stﾃ､ﾃ､ tﾃ､mﾃ､ kuva buggy3.c.
Ja aion mennﾃ､ eteenpﾃ､in ja julistaa int main (void).
Ja sitten sisﾃ､llﾃ､ siellﾃ､ Aion tehdﾃ､ int i _ -
Haluan toteuttaa ohjelman kanssa get_negative_int.
Tﾃ､mﾃ､ ei ole funktio, joka on olemassa vielﾃ､.
Joten aiomme toteuttaa se vain hetken.
Mutta me tulemme nﾃ､kemﾃ､ﾃ､n miksi se viallisista ensin omille.
Ja kun olen saanut int kﾃ､yttﾃ､jﾃ､ltﾃ､,
Olen juuri menossa painoon% i on negatiivinen kokonaisluku, kenoviiva, n, pilkku, i.
Toisin sanoen, kaikki I haluavat ohjelman tehdﾃ､
on saada negatiivinen int alkaen kﾃ､yttﾃ､jﾃ､ ja sitten tulostaa
ettﾃ､ tﾃ､llainen ja tﾃ､llainen on negatiivinen int.
>> Nyt minun tﾃ､ytyy toteuttaa tﾃ､tﾃ､ toimintoa.
Joten myﾃｶhemmin minun tiedoston, aion mennﾃ､ eteenpﾃ､in ja julistaa toiminto nimeltﾃ､ﾃ､n
get_negative_int (void) - ja me palata mitﾃ､ tﾃ､mﾃ､ linja tarkoittaa jﾃ､lleen
joka moment-- int n; do-- do following-- printf n on :.
Ja sitten aion tehdﾃ､ n - get_int, ja tehdﾃ､ tﾃ､mﾃ､, kun n on suurempi kuin 0.
Ja palata sitten n ;.
>> Joten siellﾃ､ on paljon meneillﾃ､ﾃ､n Tﾃ､ssﾃ､ mutta mikﾃ､ﾃ､n jota emme
katsokaa viime viikolla, ainakin hetkeksi.
Joten rivillﾃ､ 10 tﾃ､ﾃ､llﾃ､ olen julistettu toiminto nimeltﾃ､ﾃ､n get_negative_int,
ja Laitoin (void), vuonna sulkuja, syy on tﾃ､hﾃ､n
ei ota tulo.
En ohimennen mitﾃ､ﾃ､n Tﾃ､mﾃ､n toiminnon.
Olen vain saada jotain takaisin siitﾃ､.
>> Ja mitﾃ､ olen haluavat saada takaisin on kokonaisluku.
Ei ole tietoa tyyppi C kutsutaan negative_int.
Se on vain int, joten se menee olla meille varmista
ettﾃ､ arvo, joka on itse asiassa Palautetut on paitsi int
mutta on myﾃｶs negatiivinen.
>> On line 12 Olen julistaa muuttuja nimeltﾃ､ﾃ､n n ja tehden tyyppiﾃ､ int.
Ja sitten linjan 13 kautta 18 Olen tekemﾃ､ssﾃ､ jotain vaikka jokin on totta.
Aion eteenpﾃ､in ja tulostus n on, paksusuoli, ja sitten tilaan,
kuten nopea kﾃ､yttﾃ､jﾃ､lle.
>> Olen silloin kutsuvan get_int ja tallentamiseen sen niin sanottu palautusarvo
ettﾃ､ muuttujan n.
Mutta aion pitﾃ､ﾃ､ tehdﾃ､ Tﾃ､mﾃ､n kun n on suurempi kuin 0.
Toisin sanoen, jos kﾃ､yttﾃ､jﾃ､ antaa minulle int ja ettﾃ､ mﾃ､ﾃ､rﾃ､ on suurempi kuin 0,
ergo, positiivinen, aion vain pitﾃ､ﾃ､ reprompting kﾃ､yttﾃ､jﾃ､lle,
pitﾃ､ﾃ､ reprompting, pakottamalla yhteistyﾃｶtﾃ､ ja antaa minulle negatiivinen int.
>> Ja kun n on todella negative-- Oletetaan kﾃ､yttﾃ､jﾃ､ lopulta tyyppejﾃ､ -50,
niin tﾃ､mﾃ､ taas silmukka ei ole enﾃ､ﾃ､ totta koska -50 ei ole suurempi kuin 0.
Joten me murtautua ulos ettﾃ､ loop loogisesti ja palauttaa n.
>> Mutta on olemassa yksi muu asia minun tﾃ､ytyy tehdﾃ､.
Ja voin vain tehdﾃ､ tﾃ､mﾃ､n kopioimalla ja liittﾃ､mﾃ､llﾃ､
yhtﾃ､ riviﾃ､ koodia ylﾃ､reunassa tiedoston.
Minun tﾃ､ytyy opettaa Clang, tai lupaus kalahtaa,
nimenomaisesti, ettﾃ､ minﾃ､, todellakin, mene ja toteuttaa
Tﾃ､mﾃ､n toiminnon get_negative_int.
Voisi vain pienempi tiedosto.
Jﾃ､lleen muistaa, ettﾃ､ Clang lukee asioita ylhﾃ､ﾃ､ltﾃ､ alas,
vasemmalta oikealle, joten et voi soittaa toiminto, jos Clang
ei tiedﾃ､ sitﾃ､ tulee olla olemassa.
>> Nyt valitettavasti tﾃ､tﾃ､ ohjelmaa, kuten jotkut teistﾃ､ ehkﾃ､ huomannut,
on jo buginen.
Anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ buggy3.
Se kokoaa, joten minun ongelmani nyt ei ole syntaksivirhe, kuten sanallisesti virhe,
se todella tulee olemaan looginen virhe, ettﾃ､ olen tarkoituksella
teki mahdollisuutena selata mitﾃ､ tapahtuu.
>> Aion mennﾃ､ eteenpﾃ､in nyt ja ajaa buggy3.
Ja aion mennﾃ､ eteenpﾃ､in ja tee yhteistyﾃｶtﾃ､.
Aion antaa sen numero 1.
Se ei pidﾃ､ siitﾃ､, niin se kehotukset minua uudelleen.
>> Miten noin 2?
3?
50?
Mikﾃ､ﾃ､n nﾃ､istﾃ､ toimivat.
Miten noin -50?
Ja ohjelma nﾃ､yttﾃ､ﾃ､ toimivan.
>> Yritﾃ､n vielﾃ､ kerran.
Yritﾃ､n -1, tuntuu toimivan.
Yritﾃ､n -2, tuntuu toimivan.
Yritﾃ､n 0.
Huh, se on virheellinen.
Nyt olemme nyt hieman pikkutarkka tﾃ､ﾃ､llﾃ､.
Mutta se on todellakin niin, ettﾃ､ 0 ei ole myﾃｶnteinen eikﾃ､ kielteinen.
Ja niin, ettﾃ､ minun ohjelma on sanomalla, ettﾃ､ 0 on negatiivinen kokonaisluku,
se ei ole teknisesti oikein.
>> Nyt miksi se tekee nﾃ､in?
No, se voisi olla ilmeinen.
Ja, todellakin, ohjelma on tarkoitus olla melko yksinkertainen
joten meillﾃ､ on jotain tutkia.
>> Mutta perehdymme kolmannen virheenkorjaus tekniikkaa tﾃ､ssﾃ､ kutsutaan debug50.
Eli tﾃ､mﾃ､ on ohjelma ettﾃ､ olemme juuri luonut
tﾃ､nﾃ､ vuonna nimeltﾃ､ﾃ､n debug50 jonka avulla voit
kﾃ､yttﾃ､ﾃ､ mitﾃ､ kutsutaan sisﾃ､ﾃ､nrakennettu graafinen debuggeri CS50 IDE.
Ja debugger on vain ohjelma, joka yleensﾃ､ voit ajaa ohjelmaa
mutta askel askeleelta askeleelta, linja jonka rivi riviltﾃ､, 窶銀逆auot, tﾃｶnﾃ､isi
noin, katsomalla muuttujia, jotta ohjelma ei ole vain puhaltaa ohi
ja nopeasti tulostaa jotain tai ei tulosta jotain.
Se antaa sinulle mahdollisuuden, at ihmisen nopeus, olla vuorovaikutuksessa sen kanssa.
>> Ja tehdﾃ､ tﾃ､mﾃ､n, sinun yksinkertaisesti toimi seuraavasti.
Sen jﾃ､lkeen koota koodin, joka Olen jo tehnyt, buggy3,
mennﾃ､ eteenpﾃ､in ja ajaa debug50 ./buggy.
Niin paljon kuin help50 on juokset help50 ja sitten komento,
debug50 on juokset debug50 ja Sitten nimi komennon.
>> Nyt katsoa mitﾃ､ tapahtuu tietokoneen nﾃ､ytﾃｶllﾃ､, oikealla puolella erityisesti.
Kun osuin Run, kaikki ﾃ､killinen tﾃ､mﾃ､ oikeanpuoleinen paneeli
avaa nﾃ､ytﾃｶlle.
Ja siellﾃ､ on paljon menossa on ensi silmﾃ､yksellﾃ､.
Mutta ei ole liian paljon murehtia vielﾃ､.
>> Tﾃ､mﾃ､ osoittaa minulle kaiken joka on meneillﾃ､ﾃ､n sisﾃ､llﾃ､ minun ohjelman
nyt ja kautta nﾃ､mﾃ､ painikkeet ylﾃｶs sitten
ettﾃ､ saan selata minun koodi lopulta askel askel askeleelta.
Mutta ei aivan vielﾃ､.
Huomaa, mitﾃ､ tapahtuu.
Minun pﾃ､ﾃ､teikkuna Minua kehotetaan n.
Ja aion mennﾃ､ eteenpﾃ､in ja yhteistyﾃｶhﾃｶn tﾃ､llﾃ､ kertaa ja kirjoita -1.
Ja vaikkakin hieman arvoituksellisesti, -1 on negatiivinen kokonaisluku, kuten odotettua.
>> Ja sitten lapsi poistui tila 0 GDBserver poistumista.
GDB, GNU Debugger, on nimi perustana olevien ohjelmistojen
joka toteuttaa tﾃ､mﾃ､n debugger.
Mutta kaikki tﾃ､mﾃ､ todella tarkoittaa, debuggeri meni pois, koska minun ohjelma lopettaa
ja kaikki oli hyvin.
Jos haluan todella testaan 窶銀黍hjelma, Minun tﾃ､ytyy ennaltaehkﾃ､isevﾃ､sti kertoa debug50,
minne haluan aloittaa askelletaan lﾃ､pi koodia?
>> Ja ehkﾃ､ yksinkertaisin tapa tehdﾃ､ se on seuraava.
Jos minﾃ､ viemﾃ､llﾃ､ hiiri kouru minun toimittaja tﾃ､ﾃ､llﾃ､,
joten oikeastaan 窶銀久ain sivupalkissa tﾃ､ﾃ､llﾃ､, vasemmalle linjan numero,
Huomaa ettﾃ､ jos minﾃ､ klikkaa kerran, Laitoin pieni punainen piste.
Ja ettﾃ､ pieni punainen piste, kuten stop-merkin, tarkoittaa, hei,
debug50, tauko suorittamisen minun koodi tuolla kun olen ohjelman suorittamiseen.
>> Joten tehdﾃ､ﾃ､n se.
Anna minun mennﾃ､ eteenpﾃ､in ja ajaa minun ohjelma jﾃ､lleen debug50 ./buggy3, Enter.
Ja nyt, ilmoitusta, jotain eri on tapahtunut.
En sitﾃ､ pyydettﾃ､essﾃ､ vielﾃ､ omassa pﾃ､ﾃ､teikkunaan
mitﾃ､ﾃ､n, koska en ole saanut siellﾃ､ vielﾃ､ omassa ohjelmassa.
Huomaa, ettﾃ､ rivillﾃ､ 8 joka on nyt korostettu,
ja siellﾃ､ on pieni nuoli vasen sanonta, olet keskeytetty tﾃ､ﾃ､llﾃ､.
Koodirivin, linja 8, ei ole vielﾃ､ toteutettu.
>> Ja mikﾃ､ utelias, jos katson tﾃ､nne oikealla puolella,
huomaa, ettﾃ､ i on paikallinen muuttuja, paikallinen siinﾃ､ mielessﾃ､
ettﾃ､ se on sisﾃ､llﾃ､ olevan toiminnon.
Ja sen arvo, ilmeisesti oletuksena, ja tavallaan sopivasti, on 0.
Mutta en kirjoita 0.
Se vain sattuu olemaan sen oletusarvo tﾃ､llﾃ､ hetkellﾃ､.
>> Joten anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ tﾃ､tﾃ､ nyt.
Anna minun mennﾃ､ eteenpﾃ､in ja ylﾃ､kulmassa tﾃ､ﾃ､llﾃ､, olen
menossa eteenpﾃ､in ja valitse tﾃ､mﾃ､ ensimmﾃ､inen kuvake, joka
tarkoittaa askel yli, mikﾃ､ tarkoittaa, ﾃ､lﾃ､ ohita se kuitenkin askel yli koodirivin,
suorittamalla se matkan varrella.
>> Ja nyt, huomaa, minun nopea juuri muuttunut.
Miksi niin?
Olen kertonut debug50, suorita koodirivin.
Mitﾃ､ tﾃ､mﾃ､ rivi koodia tehdﾃ､?
Kysyy minua int.
OK.
Saanen yhteistyﾃｶtﾃ､.
Anna minun mennﾃ､ eteenpﾃ､in nyt ja kirjoita -1, Enter.
Ja nyt huomaa, mikﾃ､ on muuttunut.
Oikealla puolella, oman paikallisen muuttujan i
arvellaan olevan noin -1 nyt.
Ja se on edelleen tyyppiﾃ､ int.
>> Ja ilmoitus, myﾃｶs minun niin kutsuttu soittaa pino, missﾃ､ minﾃ､ keskeyttﾃ､ﾃ､?
Me puhua enemmﾃ､n tﾃ､tﾃ､ tulevaisuudessa.
Mutta kutsupino juuri viittaa mihin toiminnot ovat tﾃ､llﾃ､ hetkellﾃ､ liikkeessﾃ､.
Juuri nyt se on vain tﾃ､rkeimmﾃ､t.
Ja juuri nyt ainoa paikallinen muuttuja on i, jonka arvo on 1.
>> Ja kun lopulta askel yli tﾃ､mﾃ､n linjan tﾃ､ﾃ､llﾃ､, ettﾃ､ sama kuvake oikeassa ylﾃ､kulmassa,
-1 On negatiivinen kokonaisluku.
Nyt se on pysﾃ､htyen yli ettﾃ､ kihara ahdin.
Annetaan sen tehdﾃ､ sen asian.
Astun yli ettﾃ､ linja, ja voila.
>> Joten kaikki, ettﾃ､ hirveﾃ､n valaiseva vielﾃ､,
mutta se ei anna minun keskeyttﾃ､ﾃ､ ja miettiﾃ､ loogisesti
mitﾃ､ tﾃ､mﾃ､ ohjelma tekee.
Mutta se ei ollut virheellinen asia.
Tehdﾃ､ﾃ､n tﾃ､mﾃ､ uudelleen seuraavasti.
>> Aion lﾃ､hteﾃ､ ettﾃ､ keskeytyskohta rivillﾃ､ 8 kanssa red dot.
Aion uusintana debug50.
Se automaattisesti keskeytetty tﾃ､ﾃ､llﾃ､.
Mutta tﾃ､llﾃ､ kertaa sen sijaan, tehostamalla tﾃ､mﾃ､n rajan ylﾃ､puolella,
anna minun itse mennﾃ､ sisﾃ､lle get_negative_int ja selvittﾃ､ﾃ､,
miksi se hyvﾃ､ksyﾃ､ 0 kelvolliseksi vastaus?
>> Joten sen sijaan klikkaamalla Step Over.
Aion mennﾃ､ eteenpﾃ､in ja valitse Step Into.
Ja huomaa, ettﾃ､ linja 8, joka on nyt korostettu nyt yhtﾃ､kkiﾃ､
tulee linja 17.
>> Nyt, se ei ole niin debugger on ohitettu linjat 14 ja 15 ja 16.
Se on vain ei ole mitﾃ､ﾃ､n nﾃ､yttﾃ､mﾃ､ﾃ､n siellﾃ､.
Ne ovat vain julistaa muuttujia, Ja sitten on sana Do
ja sitten avoin kihara ahdin.
Ainoa toimiva linja, joka on mehukas todella on tﾃ､mﾃ､ yksi tﾃ､ﾃ､llﾃ､, 17.
Ja siellﾃ､ olemme keskeytetty automaattisesti.
>> Niin printf ( "n.is:") ;, niin joka ei ole vielﾃ､ tapahtunut.
Joten mene eteenpﾃ､in ja valitse Step Over.
Nyt nopea, todellakin, muutettu ( "n on:").
Nyt get_int, en ole menossa vaivata astumassa,
koska toiminta oli tekemﾃ､t CS50 kirjastossa.
Se on oletettavasti oikein.
>> Joten aion mennﾃ､ eteenpﾃ､in ja tavallaan yhteistyﾃｶtﾃ､ antamalla sille
int, mutta ei negatiivinen int.
Joten anna minun mennﾃ､ eteenpﾃ､in ja osui 0.
Ja nyt, mitﾃ､ tapahtuu tﾃ､ﾃ､llﾃ､ kun saan alas linja 21?
En ole iteroidaan uudelleen.
En nﾃ､ytﾃ､ olevan jumissa, ettﾃ､ silmukka.
Toisin sanoen, tﾃ､mﾃ､ keltainen bar ei jatka ympﾃ､rillﾃ､,
ja ympﾃ､ri ja ympﾃ､ri.
>> Nyt Miksi?
No, n, mikﾃ､ on n juuri nyt?
Voin katsoa paikallisen muuttujat virheenkorjauksen.
n on 0.
Selvﾃ､, mikﾃ､ oli tilani?
>> 20-- linja 20 on hyvin, 0 on suurempi kuin 0.
Tuo ei ole totta.
0 ei ole suurempi kuin 0.
Ja niin minﾃ､ puhkesi tﾃ､stﾃ､.
>> Ja joten siksi linjalla 21, jos olen itse edelleen,
Aion palata 0, jopa vaikka en olisi pitﾃ､nyt hylﾃ､tﾃ､ 0
sillﾃ､ ei oikeastaan 窶銀黍le negatiivisia.
Joten nyt, en oikein edes vﾃ､litﾃ､ virheenkorjauksen.
Sain sen, en tarvitse tietﾃ､vﾃ､t, mitﾃ､ enemmﾃ､n on tekeillﾃ､.
>> Joten aion mennﾃ､ eteenpﾃ､in ja klikkaa Play-painiketta,
ja olkoon tﾃ､mﾃ､ viimeistely ylﾃｶs.
Nyt olen ymmﾃ､rtﾃ､nyt, ettﾃ､ minun bug on ilmeisesti linjalla 20.
Se on minun looginen virhe.
>> Ja niin mitﾃ､ haluanko tehdﾃ､ muuttaa tﾃ､tﾃ､?
Jos ongelma on ettﾃ､ en ole pyydystﾃ､miseen 0, se on vain looginen virhe.
Ja voin sanoa, kun n on suurempi tai yhtﾃ､ suuri kuin 0,
pitﾃ､ﾃ､ kehottaa kﾃ､yttﾃ､jﾃ､ﾃ､ uudestaan 窶銀桔a uudestaan.
>> Joten, jﾃ､lleen, yksinkertainen virhe, ehkﾃ､ vaikka esiin, kun nﾃ､it minut
kirjoittaa se vain muutama minuutti sitten.
Mutta takeaway tﾃ､ﾃ､llﾃ､ on, ettﾃ､ debug 50,
ja virheenkorjaus ohjelmisto yleisemmin
olet tﾃ､mﾃ､n uuden lﾃｶytyi voimaa kﾃ､ydﾃ､ lﾃ､pi oman koodin, katso
kautta, ettﾃ､ oikea kﾃ､si paneeli mitﾃ､ muuttujia arvot.
Joten et vﾃ､lttﾃ､mﾃ､ttﾃ､ tﾃ､ytyy kﾃ､yttﾃ､ﾃ､ jotain
kuten sinﾃ､ eprintf tulostaa nﾃ､itﾃ､ arvoja.
Voit itse nﾃ､hdﾃ､ ne visuaalisesti nﾃ､ytﾃｶllﾃ､.
>> Nyt pidemmﾃ､lle, on syytﾃ､ huomata, ettﾃ､ on olemassa toinen tekniikka, joka on
todella Super yhteinen.
Ja ehkﾃ､ ihmetellﾃ､, miksi tﾃ､mﾃ､ pieni kaveri tﾃ､ﾃ､llﾃ､ on istunut lavalla.
Joten on tﾃ､mﾃ､ tekniikka, yleensﾃ､ tunnetaan kumiankka virheenkorjaus,
joka oikeastaan 窶銀黍n vain osoitus siitﾃ､,
ettﾃ､ usein kun ohjelmoijat kirjoittavat koodia,
he eivﾃ､t vﾃ､lttﾃ､mﾃ､ttﾃ､ yhteistyﾃｶssﾃ､ muiden kanssa,
tai tyﾃｶskentelevﾃ､t jaetussa ympﾃ､ristﾃｶssﾃ､.
>> He tavallaan kotona.
Ehkﾃ､ se on myﾃｶhﾃ､ﾃ､n illalla.
He yrittﾃ､vﾃ､t hahmo joitakin vian koodiaan.
Ja he vain nﾃ､e sitﾃ､.
>> Ja ei ole kﾃ､mppﾃ､kaveri.
Ei ole mitﾃ､ﾃ､n TF.
Ei ole CA ympﾃ､rillﾃ､.
Kaikki ne on heidﾃ､n hyllylle on tﾃ､mﾃ､ pieni kumiankalla.
>> Ja niin kumiankka virheenkorjaus on juuri tﾃ､mﾃ､ kutsu
ajatella jotain niin typerﾃ､ koska tﾃ､mﾃ､ on todellinen olento,
ja itse kﾃ､vellﾃ､ lﾃ､pi koodin suullisesti tﾃ､mﾃ､n eloton objekti.
Niinpﾃ､ esimerkiksi, jos tﾃ､mﾃ､ on minun esimerkki here--
ja muistuttavat, ettﾃ､ aikaisemmin ongelma oli tﾃ､mﾃ､,
jos en poistaa tﾃ､mﾃ､n ensimmﾃ､isen rivin koodia, ja minﾃ､ mennﾃ､ eteenpﾃ､in ja tehdﾃ､ buginen 0 jﾃ､lleen,
muistaa, ettﾃ､ sain nﾃ､mﾃ､ virheilmoitukset tﾃ､ﾃ､llﾃ､.
Joten ajatus tﾃ､ﾃ､llﾃ､, naurettava vaikka en tuntea tﾃ､llﾃ､ hetkellﾃ､ teet tﾃ､mﾃ､n julkisesti,
on, ettﾃ､ virhe.
>> OK, joten minun ongelmani on, ettﾃ､ olen epﾃ､suorasti julisti kirjaston funktion.
Ja ettﾃ､ kirjaston funktion on printf.
Declare-- OK, julistaa mieleeni prototyyppejﾃ､.
>> Se tarkoittaa, ettﾃ､ minun tﾃ､ytyy itse kertoa kﾃ､ﾃ､ntﾃ､jﾃ､ etukﾃ､teen, mitﾃ､
toiminto nﾃ､yttﾃ､ﾃ､.
Odota hetki.
En ole vakio io.h.
Paljon kiitoksia.
>> Joten tﾃ､ssﾃ､ prosessissa soita nﾃ､in te ei tarvitse itse olla ankka.
Mutta tﾃ､mﾃ､ ajatus kﾃ､vely itse kautta oman koodin
niin ettﾃ､ te edes kuulla itse, jotta voit
ymmﾃ､rtﾃ､ﾃ､ puutteita omassa huomautukset, on yleensﾃ､ ajatus.
>> Ja ehkﾃ､ enemmﾃ､n loogisesti, ei niin paljoa, ettﾃ､ yksi, mutta enemmﾃ､n mukana
Esimerkiksi me vain teki buginen 3.c, saatat kﾃ､vellﾃ､ itse lﾃ､pi
seuraavasti.
Joten kunnossa, kumia ducky, DDB, jos haluatte.
Tﾃ､ssﾃ､ meillﾃ､ on minun pﾃ､ﾃ､tehtﾃ､vﾃ､, Soitan saada negatiivinen int.
>> Ja Saan palauttaa arvon.
Olen tallentamalla sen vasemmalla puolella rivillﾃ､ 8 muuttujaan nimeltﾃ､ i.
OK, mutta odottaa, kuinka teki ettﾃ､ tuon arvon?
Saanen tarkastella toiminto linjassa 12.
>> Linjassa 12, meillﾃ､ on saada negatiivinen int.
Ei ota mitﾃ､ﾃ､n tuloa, ei palaa int, OK.
Vakuutan linjan 14 muuttujan n.
Se tulee tallentaa kokonaisluku.
Se on, mitﾃ､ haluan.
>> Joten tee alla n is-- let minulle kumoa mitﾃ､ fix olen jo tehnyt.
Joten kun n on suurempi kuin 0, tulostaa N, OK.
Ja sitten soittaa saada int tallennettu n.
Ja sitten tarkistaa, jos n on 0, n on not-- siellﾃ､ se on.
Joten, jﾃ､lleen, et tarvitsevat todellinen ankka.
Mutta vain kﾃ､vely itseﾃ､si koodi kuin henkinen harjoitus
usein auttaa ymmﾃ､rtﾃ､ﾃ､, mitﾃ､ on tekeillﾃ､,
toisin kuin juuri tekemﾃ､ssﾃ､ jotain nﾃ､in, tuijottaen nﾃ､yttﾃｶﾃ､,
ja ei puhu itseﾃ､si se, mikﾃ､ rehellisesti ei ole
lﾃ､hes yhtﾃ､ tehokas tekniikka.
Siinﾃ､pﾃ､ se, joka on useita erilaisia 窶銀逆ekniikoita
kapasiteetin varsinaisen virheenkorjaus koodi ja lﾃｶytﾃ､ﾃ､ vika, jotka kaikki
pitﾃ､isi olla vﾃ､lineitﾃ､ oman tyﾃｶkalupakin niin ettﾃ､ et ole myﾃｶhﾃ､ﾃ､n illalla,
varsinkin, olet ruokailu hallit, tai toimistossa tuntia,
hakkaa pﾃ､ﾃ､tﾃ､si seinﾃ､, yrittﾃ､ﾃ､ ratkaista joitakin ongelmia.
Ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ on olemassa ohjelmistotyﾃｶkaluja.
On kumiankka tyﾃｶkaluja.
Ja siellﾃ､ on koko henkilﾃｶkunta tukea odottaa lainata kﾃ､si.
>> Joten nyt, sana ongelmasta asetetaan, ja mitﾃ､ toivomme teille
pﾃ､ﾃ､stﾃ､ ulos niistﾃ､, ja miten osaamme arvioida.
Per kurssin oppimﾃ､ﾃ､rﾃ､n, CS50 ongelma sarjaa
arvioidaan neljﾃ､n ensisijaisen akseleilla, niin ja speak-- laajuus, oikeellisuudesta, suunnittelu,
ja tyyli.
Ja laajuus vain tarkoittaa sitﾃ､, kuinka paljon pala olet purrut pois?
Kuinka suuri ongelma olet kokeillut?
Mikﾃ､ rasitustaso olet ilmenee?
>> Oikeellisuutta on, tekee ohjelma tyﾃｶtﾃ､ sen pitﾃ､isi per CS50 toiveiden
Kun annat tiettyjﾃ､ panoksia tai tietyt lﾃ､htﾃｶihin?
Suunnittelu on kaikkein subjektiivinen niistﾃ､.
Ja se on se, joka tulee ottaa pisin oppia
ja pisin opettaa, vuonna sikﾃ､li kuin se kuihtuu,
kuinka hyvin kirjoitettu on koodi?
>> Se on yksi asia vain tulostaa oikea lﾃ､htﾃｶjen tai palauttaa oikeat arvot.
Mutta teet sen mahdollisimman tehokkaasti?
Teetkﾃｶ sitﾃ､ kuilua ja valloittaa, tai binary
search kuten tulemme pian nﾃ､hdﾃ､, ettﾃ､ me teimme kaksi viikkoa sitten kanssa puhelinluettelosta?
Onko parempia tapoja ratkaista ongelma kuin sinulla on tﾃ､ﾃ､llﾃ､?
Se mahdollisuus parempaan suunnitteluun.
>> Ja sitten style-- miten aika on koodi?
Huomaat, ettﾃ､ olen aika erityisesti siitﾃ､ sisennys oma koodi,
ja varmista minun muuttujat kohtuudella nimetty. n,
vaikka lyhyt, on hyvﾃ､ nimi varten numero, i laskenta kokonaisluku,
s merkkijono.
Ja voimme olla pidempi muuttujanimiin tyyli.
Tyyli on, kuinka hyvﾃ､ ei koodin nﾃ､yttﾃ､ﾃ､?
Ja miten luettavissa on se?
>> Ja ajan mittaan, mitﾃ､ avustajat ja TF: t tekevﾃ､t kurssin
on tarjota sinulle, ettﾃ､ sellaista laadullista palautetta
jotta saat paremman noita eri nﾃ､kﾃｶkohtia.
Ja siinﾃ､, miten me arvioi jokaisen nﾃ､istﾃ､ akseleista,
se on tyypillisesti hyvin vﾃ､hﾃ､n kauhat niin ettﾃ､ te, yleensﾃ､,
Saat kﾃ､sityksen siitﾃ､, miten hyvin teet.
Ja todellakin, jos saat pisteet mitﾃ､ﾃ､n nﾃ､istﾃ､ axes-- oikeellisuuden, suunnittelu
ja tyyli especially-- ettﾃ､ mﾃ､ﾃ､rﾃ､ on yleensﾃ､ vﾃ､lillﾃ､ 1 ja 5.
Ja kirjaimellisesti, jos saat 3: n alussa lukukauden,
tﾃ､mﾃ､ on erittﾃ､in hyvﾃ､ asia.
Se tarkoittaa, ettﾃ､ on vielﾃ､ tilaa parannuksille,
johon voisi toivoa vuonna ottaen luokan ensimmﾃ､istﾃ､ kertaa.
On toivottavasti joitakin vﾃ､hﾃ､n katto johon olet pyrkivﾃ､ pﾃ､ﾃ､semiseksi.
Ja niin saaminen 3: n pﾃ､ﾃ､lle aikaisintaan kappaletta,
jos ei joitakin 2: n ja 4: n, on todellakin hyvﾃ､ asia.
Se on hyvin ulottuvilla, reilusti odotukset.
>> Ja jos mielesi on kilpa, odota minuutti, kolme viidestﾃ､.
Se on todella 6 10.
Se on 60%.
Luoja, tuo on F.
>> Se ei ole.
Se ei ole, itse asiassa, ettﾃ､.
Pikemminkin se mahdollisuuden parantaa aikana lukukauden.
Ja jos saat joitakin Poors, nﾃ､mﾃ､ ovat mahdollisuus
hyﾃｶdyntﾃ､ﾃ､ virka, varmasti kohdat ja muita resursseja.
>> Paras on mahdollisuus, todella, olla ylpeﾃ､, kuinka pitkﾃ､lle olet
tulevat aikana lukukauden.
Joten ﾃ､lﾃ､ ymmﾃ､rrﾃ､, jos mitﾃ､ﾃ､n muuten, kolme on hyvﾃ､.
Ja se mahdollistaa tilaa kasvulle ajan.
>> Siitﾃ､, miten nﾃ､mﾃ､ akselit ovat painotettu, realistisesti olet
aikoo viettﾃ､ﾃ､ suurimman osan aikaa saada asioita tyﾃｶtﾃ､, puhumattakaan oikein.
Ja niin oikeellisuus on taipumus painotetaan eniten, kuten
tﾃ､mﾃ､ monikertaisesti kolme.
Design on myﾃｶs tﾃ､rkeﾃ､ﾃ､, mutta jotain, et vﾃ､lttﾃ､mﾃ､ttﾃ､
viettﾃ､vﾃ､t kaikki nﾃ､mﾃ､ tuntia yrittﾃ､ﾃ､ saada asiat vain tﾃｶihin.
>> Ja niin se on painotettu hieman kevyemmin.
Ja sitten tyyli painotetaan vﾃ､hiten.
Vaikka se ei ole yhtﾃ､ tﾃ､rkeﾃ､ pohjimmiltaan,
se on vain, kenties helpointa oikealle,
matkien esimerkeissﾃ､ do luento ja osassa,
asioita mukavasti sisennetty ja kommentoi,
ja niin edelleen on yksi helpoin asioita ja saada oikea.
Joten sinﾃ､nsﾃ､, ymmﾃ､rtﾃ､ﾃ､ ettﾃ､ ne ovat pistettﾃ､
jotka ovat suhteellisen helppo ymmﾃ､rtﾃ､ﾃ､.
>> Ja nyt muutaman sanan this-- akateemisen rehellisyys.
Joten kohti kurssin oppimﾃ､ﾃ､rﾃ､, nﾃ､et
ettﾃ､ kurssi on melko bittinen kielen ympﾃ､rillﾃ､.
Ja tietenkin ottaa kysymys akateeminen rehellisyys melko vakavasti.
>> Meillﾃ､ on eroa, parempaan tai huonompaan,
ettﾃ､ on lﾃ､hettﾃ､nyt vuosittain enemmﾃ､n opiskelijat kurinpitotoimista
kuin useimmat muita Tietenkin, ettﾃ､ olen tietoinen.
Tﾃ､mﾃ､ ei vﾃ､lttﾃ､mﾃ､ttﾃ､ ole osoituksena siitﾃ､,
ettﾃ､ CS opiskelijoita, tai CS50 opiskelijoita, ovat mitﾃ､ﾃ､n vﾃ､hemmﾃ､n rehellinen kuin luokkatoverit.
Mutta tosiasia, ettﾃ､ tﾃ､ssﾃ､ maailma, sﾃ､hkﾃｶisesti, me vain
on teknologinen keino havaita tﾃ､mﾃ､n.
>> On tﾃ､rkeﾃ､ﾃ､ meille oikeudenmukaisuus poikki luokka
ettﾃ､ teemme tunnistaa tﾃ､mﾃ､n, ja nosta ongelma kun nﾃ､emme asiat.
Ja vain maalata kuvan, ja oikeastaan auttamaan jotain tﾃ､llaista uppoavat,
nﾃ､mﾃ､ ovat ne opiskelijat yli viimeisten 10 vuoden aikana
jotka ovat olleet mukana joissakin tﾃ､llaiset asiat akateemisen rehellisyys,
joidenkin 32 opiskelijoille syksystﾃ､ 2015, mikﾃ､
on sanoa, ettﾃ､ otamme asiaan erittﾃ､in vakavasti.
Ja lopulta, nﾃ､mﾃ､ luvut sﾃ､veltﾃ､ﾃ､, viimeksi noin 3%, 4% tai niin
luokan.
>> Joten mﾃ､ﾃ､rﾃ､enemmistﾃｶ opiskelijoiden nﾃ､yttﾃ､ﾃ､ siltﾃ､, 窶銀菊ttﾃ､ viivat ovat selkeitﾃ､.
Mutta ﾃ､lﾃ､ pitﾃ､ﾃ､ tﾃ､mﾃ､ vﾃ､litﾃ､, varsinkin myﾃｶhﾃ､ﾃ､n
yﾃｶllﾃ､, kun kamppailee Joissakin ratkaisu ongelmaan asettaa,
ettﾃ､ kﾃ､ytﾃｶssﾃ､ on mekanismit saada itseﾃ､si paremmin
tukea kuin voisi ajatella, vaikka sillﾃ､ hetkellﾃ､.
Ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ kun saamme opiskelija vﾃ､ittﾃ､ﾃ､, ylitﾃ､mme
vertailla kaikkia lﾃ､hetyksiﾃ､ tﾃ､nﾃ､ vuonna vastaan 窶銀橘aikkia lﾃ､hetyksiﾃ､ viime vuonna,
vastaan 窶銀橘aikkia lﾃ､hetyksiﾃ､ vuodesta 2007, ja koska, katsomalla, samoin,
koodi -tietovarastoja verkossa, keskustelufoorumit, tyﾃｶmailla.
Ja me mainita, todella, kaikki vuoksi
kaikkien tietojen, ettﾃ､ jos joku muu voi lﾃｶytﾃ､ﾃ､ sen verkossa,
varmasti, joten voimme kurssin.
Mutta, todella, henki Kurssin kuihtuu
Tﾃ､mﾃ､n lausekkeen oppimﾃ､ﾃ､rﾃ､n.
Se on todellakin vain, kohtuullinen.
>> Ja jos meidﾃ､n oli tarkentaa, ettﾃ､ vain hieman kieltﾃ､,
ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ pohjimmiltaan kaikki teoksesta, jota esittﾃ､ﾃ､ tﾃ､mﾃ､n kurssin
tﾃ､ytyy olla oma.
Mutta sisﾃ､llﾃ､, ettﾃ､ on varmasti mahdollisuuksia, ja rohkaisua,
ja pedagoginen arvo kﾃ､ﾃ､ntyen others-- itse, TF: ien, CAS,
TAS, ja muut luokassa, tukea, saati ystﾃ､viﾃ､
ja kﾃ､mppﾃ､kaverini jotka ovat opiskelleet CS ja ohjelmointi ennen.
Ja niin on olemassa korvaus siitﾃ､.
Ja Nyrkkisﾃ､ﾃ､ntﾃｶnﾃ､ on this-- kun pyytﾃ､ﾃ､ apua,
voit nﾃ､yttﾃ､ﾃ､ koodin muille, mutta et voi katsella omaansa.
Joten vaikka olet toimistossa tuntia, tai D sali, tai jossain muualla
tyﾃｶskennellyt joitakin osainen sarja, yksikﾃｶiden kanssa ystﾃ､vﾃ､, joka
on tﾃ､ysin hieno, klo Lopussa pﾃ､ivﾃ､n tyﾃｶsi
olisi viime kﾃ､dessﾃ､ kuuluvat kunkin teistﾃ､ vastaavasti, eikﾃ､
jonkin verran yhteistﾃ､ ponnistusta, paitsi opinnﾃ､ytetyﾃｶn jossa
se on sallittua ja suositeltavaa.
>> Tiedﾃ､, ettﾃ､ jos olet kamppailevat jotain
ja ystﾃ､vﾃ､si vain sattuu paremmaksi tﾃ､ssﾃ､ sinun,
tai parempi tuohon ongelma kuin te, tai vﾃ､hﾃ､n kauemmaksi eteenpﾃ､in kuin te,
se on tﾃ､ysin jﾃ､rkevﾃ､ﾃ､ kﾃ､ﾃ､ntyﾃ､ ystﾃ､vﾃ､si ja sanoa, hei,
Haittaako katsot minun koodi tﾃ､ﾃ､llﾃ､, auttaa minua spot mitﾃ､ minun ongelma on?
Ja toivottavasti vuonna edun pedagogista arvoa
ettﾃ､ ystﾃ､vﾃ､ ei ole vain sanovat, oi, tee tﾃ､tﾃ､, vaan pikemminkin,
mitﾃ､ puuttuu verkossa 6, tai jotain?
Ratkaisu ei kuitenkaan ole ettﾃ､ ystﾃ､vﾃ､ vieressﾃ､si
sanoa, No, tﾃ､ﾃ､llﾃ､, anna minun vetﾃ､ﾃ､ tﾃ､hﾃ､n asti, ja nﾃ､yttﾃ､ﾃ､ minun ratkaisu sinulle.
Niin, ettﾃ､ on linja.
Nﾃ､ytﾃ､t koodia toiset, mutta et saa
katsella omaansa, jollei muuta rajoitteet kurssin oppimﾃ､ﾃ､rﾃ､n.
>> Joten ﾃ､lﾃ､ pitﾃ､ﾃ､ mielessﾃ､ tﾃ､mﾃ､ niin sanottu pahoillani lauseke
in kurssin oppimﾃ､ﾃ､rﾃ､n samoin, ettﾃ､ jos sitoutua joitakin asiakirjalla
ei ole jﾃ､rkevﾃ､ﾃ､, vaan tuo se huomiota kurssin pﾃ､ﾃ､t
72 tunnin kuluessa, kurssin voivat asettaa paikallisia seuraamuksia ettﾃ､
voi kuulua epﾃ､tyydyttﾃ､vﾃ､ tai muussa arvosana tyﾃｶstﾃ､ toimitettu.
Mutta tietenkﾃ､ﾃ､n ei viitata asia edelleen kurinpitotoimia,
lukuun ottamatta toistuvia tekoja.
Toisin sanoen, jos et tehdﾃ､ joitakin tyhmﾃ､, varsinkin myﾃｶhﾃ､ﾃ､n yﾃｶllﾃ､, pﾃ､ﾃ､tﾃｶs
ettﾃ､ seuraavana aamuna tai kaksi pﾃ､ivﾃ､ﾃ､ myﾃｶhemmin, herﾃ､ﾃ､t ja ymmﾃ､rtﾃ､ﾃ､,
mitﾃ､ minﾃ､ ajattelin?
Teet CS50 nﾃ､illﾃ､ on markkinat vahvistamisesta, ettﾃ､ ongelma
ja omistavat jopa se, ettﾃ､ me tavata puolitiehen ja kﾃ､sitellﾃ､
sen kanssa asiassa, joka on sekﾃ､ koulutus- ja arvokkaita sinulle,
mutta silti rankaiseva jollakin tavalla.
Ja nyt, ottaa terﾃ､n, tﾃ､mﾃ､.
>> [VIDEOTOISTOSTA]
>> [MUSIIKKIA]
>> [END TOISTO]
DAVID J. MALAN: Selvﾃ､, olemme takaisin.
Nyt katsomme yhdessﾃ､ Ensimmﾃ､inen meidﾃ､n reaalimaailman verkkotunnuksia
in CS50, taiteen salakirjoituksen, taiteen lﾃ､hettﾃ､vﾃ､n ja vastaanottavan
salaisuus viestejﾃ､, salattu viestit, jos haluatte,
joita voidaan deciphered jos olet joitakin keskeisiﾃ､ ainesosa, ettﾃ､ lﾃ､hettﾃ､jﾃ､ on
yhtﾃ､ hyvin.
Joten motivoida tﾃ､hﾃ､n otamme Katso tﾃ､mﾃ､ asia tﾃ､ﾃ､llﾃ､,
joka on esimerkki salaisuus dekooderi rengas, joka
voidaan kﾃ､yttﾃ､ﾃ､, jotta selvittﾃ､ﾃ､ mitﾃ､ salaista todellisuudessa on.
Itse takaisin pﾃ､ivﾃ､ alakoulussa,
jos koskaan lﾃ､hettﾃ､nyt salaisia 窶銀久iestejﾃ､ jotkut ystﾃ､vﾃ､ tai jonkin murskaa luokassa,
saattaisi kuvitella olitte taitava
by oman paperille muuttuvat, kuten A-B, ja B C ja C D,
ja niin edelleen.
Mutta olit todella salaamalla tietosi, vaikka
jos se oli hieman triviaali, ei ollut ettﾃ､ vaikea opettaja ymmﾃ､rtﾃ､ﾃ､,
hyvin, jos vain vaihtaa B ja C B,
todella selvittﾃ､ﾃ､ mitﾃ､ viesti oli,
mutta olit salausinformaatioon.
>> Olit juuri tekemﾃ､ssﾃ､ sitﾃ､ yksinkertaisesti, aivan kuten Ralphie tﾃ､ﾃ､llﾃ､
kuuluisassa elokuvan, joka toimii melko paljon loputtomiin joka talvi.
[VIDEOTOISTOSTA]
-Ole Se tiedetﾃ､ﾃ､n kaiken Ralph Parker on tﾃ､ten
nimitetty jﾃ､seneksi Little Orphan Annie Secret Circle
ja on oikeutettu kaikkiin kunnianosoitukset ja hyﾃｶdyt ilmenevﾃ､t siihen.
>> -Signed, Little Orphan Annie, counter-allekirjoitettu Pierre Andre, musteella.
Honors ja hyﾃｶdyt, jo yhdeksﾃ､n vuoden iﾃ､ssﾃ､.
>> [HUUTAMINEN]
-Come Pﾃ､ﾃ､lle.
Mennﾃ､ﾃ､n sen kanssa.
En tarvitse kaikki muu noin salakuljettajia ja merirosvoja.
>> : Kuuntele huomenna yﾃｶ solmittaessa seikkailu
musta merirosvolaiva.
Nyt on aika Annien salainen viesti
sinulle jﾃ､senille Secret Circle.
Muista, lapset, vain jﾃ､senille Annie Secret Circle
pystyy purkamaan Annien salainen viesti.
>> Muista, Annie on riippuvainen teitﾃ､.
Aseta nastat B2.
Tﾃ､ssﾃ､ on viesti.
12, 11--
>> -Olen In, ensimmﾃ､inen salainen kokous.
>> -14, 11, 18, 16.
>> -Pierre Oli suuren ﾃ､ﾃ､nen tﾃ､nﾃ､ﾃ､n.
Voisin sanoa, ettﾃ､ illan Viesti oli todella tﾃ､rkeﾃ､.
>> -3, 25, joka on viesti alkaen Annie itse.
Muista, ﾃ､lﾃ､ kerro kenellekﾃ､ﾃ､n.
>> -90 Sekuntia myﾃｶhemmin, olen ainoa huoneeseen, jossa poika yhdeksﾃ､n
voisi istua rauhassa ja purkaa.
Aha, B!
Menin seuraavaan, E.
>> Ensimmﾃ､inen sana on olla.
S, mitﾃ､ oli tulossa helpompaa nyt, U, 25--
>> -Voi, Tule, Ralphie, minun tﾃ､ytyy mennﾃ､!
>> -Otan Olla alas, Ma!
Jannu hurahtaa!
>> -T, O, varmista to-- varmasti mitﾃ､?
Mikﾃ､ oli pieni Orphan Annie yrittﾃ､ﾃ､ sanoa?
Muista mitﾃ､?
>> -Ralphie, Andy on saanut mennﾃ､, voisitko tulla ulos?
>> -Kaikki Oikea, Ma!
Tulen ulos!
>> -I Lﾃ､hestyi nyt.
Jﾃ､nnitys oli kauhea.
Mitﾃ､ se oli?
Kohtalo planeetan voi vaakalaudalla.
>> -Ralphie!
Andyn mentﾃ､vﾃ､!
>> -Otan Olla oikealle ulos, itkeﾃ､ ﾃ､ﾃ､neen!
>> Muodostaen miltei siellﾃ､, sormet lensi, mieleni oli terﾃ､s ansa, joka huokosten vibrated.
Se oli melkein selvﾃ､, kyllﾃ､, kyllﾃ､, kyllﾃ､.
>> -Ole Muista juoda Ovaltine.
Ovaltine?
Crummy kaupallinen?
Paskiainen.
[END TOISTO]
DAVID J. MALAN: OK, niin ettﾃ､ oli hyvin pitkﾃ､ matka
ottaa kﾃ､yttﾃｶﾃｶn salakirjoituksen, ja myﾃｶs Ovaltine.
Itse asiassa tﾃ､stﾃ､ vanha mainos tﾃ､ﾃ､llﾃ､, miksi Ovaltine niin hyvﾃ､?
Se on keskittynyt louhinta kypsiﾃ､ ohramallas, puhdas kermaista lehmﾃ､nmaito,
ja erityisesti valmistettu kaakao, yhdessﾃ､ luonnon fosfatidien ja vitamiineja.
Se on lisﾃ､ksi tﾃ､ydennetty lisﾃ､vitamiineja B ja D, yum.
Ja voit silti saada sen, ilmeisesti, Amazon, kuten teimme tﾃ､ﾃ､llﾃ､.
>> Mutta motivaatio tﾃ､ﾃ､llﾃ､ oli esitellﾃ､ salakirjoitusta, erityisesti
erﾃ､ﾃ､nlainen salakirjoituksen tiedossa salaisiksi avaimen salausta.
Ja kuten nimestﾃ､ voi pﾃ､ﾃ､tellﾃ､, koko turvallisuus salainen avain salakirjoitusjﾃ､rjestelmﾃ､,
jos haluatte, menetelmﾃ､ﾃ､ vain muokkaamisella
tiedot kahden ihmisen vﾃ､lillﾃ､, on se, ettﾃ､ vain lﾃ､hettﾃ､jﾃ､ ja vain vastaanottaja
tietﾃ､ﾃ､ salaisuuden key-- jotain arvoa, jotkut salainen lause, jotkut salainen numero, joka
ansiosta ne molemmat salata ja purkaa tiedot.
Ja salaus, oikeastaan, on vain tﾃ､llﾃ､ viikolla 0.
>> Se on ongelma, missﾃ､ on tuloa, kuten todelliset viestisi Englanti
tai mitﾃ､ kielen mukaan haluat lﾃ､hettﾃ､ﾃ､ jollekulle luokassa,
tai Internetin kautta.
On olemassa jonkin verran lﾃ､htﾃｶ, joka on menossa olla salattu viesti, jota
haluat vastaanottajan vastaan.
Ja vaikka joku keskimmﾃ､inen saa sitﾃ､ liian,
et halua niitﾃ､ vﾃ､lttﾃ､mﾃ､ttﾃ､ voi purkaa sen,
koska sisﾃ､llﾃ､ tﾃ､tﾃ､ musta laatikko, tai algoritmi,
on jonkinlainen jﾃ､rjestelmﾃ､, jotkut askel askeleelta ohjeet, ottamiseen ettﾃ､ panos
ja muuntamalla se osaksi tulos on toivottavasti turvallisella tavalla.
>> Ja itse asiassa, on jonkin verran sanastoa tﾃ､ssﾃ､ maailmassa seuraavasti.
Vain teksti on sanaan tietojenkﾃ､sittelytieteessﾃ､ olisi
kﾃ､yttﾃ､ﾃ､ kuvaamaan tuloon sanoma, kuten Englanti
tai mitﾃ､ kieltﾃ､ sitten itse haluaa lﾃ､hettﾃ､ﾃ､ jollekin toiselle ihmiselle.
Ja sitten salakieli on scramble ettﾃ､ salakoodattu, tai salattu,
versio siitﾃ､.
>> Mutta on yksi muu ainesosa tﾃ､ﾃ､llﾃ､.
On yksi muu tulo salainen avaimen salausta.
Ja se on avain itse, joka on yleensﾃ､
kuten nﾃ､emme, useita, tai kirjain tai sana riippumatta
algoritmi on todella odottaa.
>> Ja miten purkaa tietoa?
Miten purkaa sitﾃ､?
No, juuri kﾃ､ﾃ､ntﾃ､ﾃ､ lﾃ､hdﾃｶt ja tulot.
>> Toisin sanoen, kun joku vastaanottanut salatun viestin,
hﾃ､nellﾃ､ yksinkertaisesti on tietﾃ､ﾃ､, ettﾃ､ sama avain.
He ovat saaneet salakieli.
Ja kytkemﾃ､llﾃ､ nﾃ､iden kahden panoksina salakirjoitusjﾃ､rjestelmﾃ､,
algoritmi, tﾃ､mﾃ､ musta laatikko, ulos pitﾃ､isi tulla alkuperﾃ､isen selvﾃ､kielisenﾃ､.
Ja niin se on erittﾃ､in korkea nﾃ､kemys siitﾃ､, mikﾃ､ salaustekniikan on oikeastaan
kaikki.
>> Joten sinne.
Tarkastellaan alla huppu jotain
olemme saaneet selvinﾃ､ viime viikolla, ja tﾃ､ssﾃ､ istunnossa
here-- merkkijono.
Merkkijono lopussa pﾃ､ivﾃ､n on vain joukko merkkejﾃ､.
>> Voisi olla Hello World, tai hei Zamyla, tai mitﾃ､ tahansa.
Mutta mitﾃ､ se merkitsee olla jono merkkejﾃ､?
Itse asiassa, CS50 kirjasto antaa meille tietotyyppiﾃ､ kutsutaan merkkijono.
>> Mutta ei oikeastaan 窶銀黍le sellaista kuin merkkijono C.
Se on todellakin vain jono merkki, merkki, merkki,
merkki, takaisin, takaisin, jotta takaisin, takaisin, takaisin sisﾃ､lle
tietokoneen muistiin, tai RAM.
Ja me katsoa syvemmﾃ､lle, ettﾃ､ tulevaisuudessa kun katsomme muistin itse,
ja hyﾃｶdyntﾃ､minen, ja uhat, jotka ovat mukana.
>> Mutta Tarkastellaan merkkijonon Zamyla.
Joten vain nimi ihmisen tﾃ､ﾃ､llﾃ､, Zamyla,
joka on sekvenssi merkkiﾃ､, Z-A-M-Y-L-A.
Nyt oletetaan, ettﾃ､ Zamyla nimi on tallennettu tietokoneen
ohjelmoida.
>> No, on aivan selvﾃ､ﾃ､, ettﾃ､ meidﾃ､n pitﾃ､isi pystyﾃ､ katsomaan ne merkit
erikseen.
Joten olen juuri menossa vetﾃ､ﾃ､ hieman box noin Zamyla nimi tﾃ､hﾃ､n.
Ja se on asia C ettﾃ､ kun on merkkijono, kuten Zamyla-- ja ehkﾃ､
ettﾃ､ jono on palannut funktio kuin get merkkijonon,
voit itse manipuloida se merkki kerrallaan.
>> Nyt tﾃ､mﾃ､ on germane varten keskustelu kﾃ､sillﾃ､, koska
salakirjoituksessa jos haluat muuttaa A B, ja B C ja C D,
ja niin edelleen, sinun tﾃ､ytyy pystyﾃ､ tarkastella yksittﾃ､isten merkkien
merkkijono.
Sinun tﾃ､ytyy pystyﾃ､ muuttamaan Z jotain muuta, A
jotain muuta, M jotain muuta, ja niin edelleen.
Ja niin me tarvitaan tapa, ohjelmallisesti, joten
puhua, C pystyﾃ､ muuttamaan ja tarkastella yksittﾃ､isiﾃ､ kirjaimia.
Ja voimme tehdﾃ､ tﾃ､mﾃ､n seuraavasti.
>> Anna minun mennﾃ､ suunnata takaisin CS50 IDE.
Ja anna minun mennﾃ､ eteenpﾃ､in ja luoda uuden tiedoston
ettﾃ､ Soitan tﾃ､llﾃ､ kertaa string0, koska meidﾃ､n ensimmﾃ､inen esimerkki, piste c.
Ja aion mennﾃ､ eteenpﾃ､in ja piiska sitﾃ､ seuraavasti.
>> Joten kuuluvat CS50.h, ja Sitten ovat standardin io.h,
joka Olen melkein aina menossa kﾃ､yttﾃ､ﾃ､ minun ohjelmia, ainakin
ensin.
int main mitﾃ､tﾃｶn, ja sitten tﾃ､ﾃ､llﾃ､ olen aikoo tehdﾃ､ jouset saa pﾃ､ﾃ､stﾃ､ merkkijono.
Ja sitten aion mennﾃ､ eteenpﾃ､in ja tehdﾃ､ tﾃ､tﾃ､.
Haluan mennﾃ､ eteenpﾃ､in ja, kuten jﾃ､rki tarkistaa,
vain sanoa, hei, prosenttia s, puolipisteitﾃ､ tekee merkkijono 0.
Ohoh, mitﾃ､ teen tﾃ､ﾃ､llﾃ､?
Voi, en kytke se.
Joten opetus, ettﾃ､ ollut tarkoituksellista.
>> Joten virhe, enemmﾃ､n prosenttia tuloksia kuin data argumentteja.
Ja tﾃ､mﾃ､ on, vuonna line 7-- ok, joten minulla on,
lainaus lainaus pﾃ､ﾃ､ttyy, se minun merkkijono printf.
Minulla on prosenttimerkki.
Mutta olen puuttuu toinen argumentti.
>> Olen puuttuu pilkku s, mikﾃ､ En ole aiemmissa esimerkeissﾃ､.
Joten hyvﾃ､ tilaisuus korjata yksi virhe, vahingossa.
Ja nyt minﾃ､ juoksen string0, kirjoita Zamyla.
OK, hei Zamyla.
>> Joten olemme ajaa tﾃ､llaista ohjelmaa muutamia eri kertaa nyt.
Mutta Tehdﾃ､ﾃ､n jotain hieman erilainen tﾃ､llﾃ､ kertaa.
Sen sijaan vain tulostus Zamyla n Koko nimi ulos printf,
Tehdﾃ､ﾃ､n se merkki kerrallaan.
>> Aion kﾃ､yttﾃ､ﾃ､ silmukka.
Ja aion antaa itselleni laskenta muuttuja, nimeltﾃ､ﾃ､n i.
Ja aion pitﾃ､ﾃ､ iteroimalla, niin kunhan i on pienempi kuin pituus s.
>> On kﾃ､ynyt ilmi, emme Tﾃ､tﾃ､ viimeistﾃ､ kertaa,
ettﾃ､ c mukana toiminto nimeltﾃ､ﾃ､n Stirling.
Takaisin seuraavana pﾃ､ivﾃ､nﾃ､, ja yleensﾃ､kin edelleen toteutettaessa toimintoja,
ihmisillﾃ､ usein valita hyvin ytimekﾃ､s nimet tuollainen ﾃ､ﾃ､ni
kuten mitﾃ､ haluat, vaikka se on puuttuu muutamia vokaaleja tai kirjaimia.
Joten Stirling on nimi on toiminto,
vie argumentti vﾃ､lillﾃ､ Suluissa ettﾃ､ pitﾃ､isi olla merkkijono.
Ja se vain palauttaa kokonaisluvun, pituus merkkijonon.
>> Joten tﾃ､mﾃ､ silmukka rivillﾃ､ 7 on menossa aloittaa laskemisen i on yhtﾃ､ suuri kuin 0.
Se tulee kasvattaa i on jokaisen iteraation
1, kun olemme tehneet muutaman kerran.
Mutta se tulee vain tehdﾃ､ Tﾃ､mﾃ､n asti pisteeseen
kun i on pituus merkkijonon itse.
>> Joten tﾃ､mﾃ､ on tapa, lopulta, iteroimalla yli merkkiﾃ､
merkkijono sellaisenaan seuraavasti.
Aion tulostaa ole Koko merkkijono, mutta prosenttia c,
yhden merkin jonka jﾃ､lkeen uusi rivi.
Ja sitten aion mennﾃ､ eteenpﾃ､in, ja tarvitsen
sanoa haluat tulostaa nteen luonnetta s.
>> Joten jos i on muuttuja, joka ilmaisee indeksi merkkijono, jossa
olet siinﾃ､, minun tﾃ､ytyy pystyﾃ､ sanoa, anna minulle nnen luonnetta s.
Ja c on tapa tehdﾃ､ Tﾃ､mﾃ､n hakasulkeilla.
Sinﾃ､ yksinkertaisesti sanoa nimen merkkijono, joka tﾃ､ssﾃ､ tapauksessa on s.
Sitten kﾃ､ytﾃ､t hakasulkeita, jotka ovat yleensﾃ､ vain ylﾃ､puolella rivinvaihtonﾃ､ppﾃ､intﾃ､
nﾃ､ppﾃ､intﾃ､.
Ja sitten laitat indeksi merkki, ettﾃ､ haluat tulostaa.
Joten indeksin olemaan number-- 0 tai 1, tai 2, tai 3, tai piste,
piste, piste, joitakin muita numero.
>> Ja voimme varmistaa, ettﾃ､ se tulee olla oikea mﾃ､ﾃ､rﾃ､, koska olen
alkaa laskea 0.
Ja oletuksena, ensimmﾃ､inen merkki merkkijono on sovitun kﾃ､ytﾃ､nnﾃｶn 0.
Ja toinen merkki on teline 1.
Ja kolmas merkki on kiinnike 2.
Ja et halua mennﾃ､ liian pitkﾃ､lle, mutta emme, koska olemme
menossa vain kasvattaa i kunnes se on yhtﾃ､ suuri kuin langan pituutta.
Ja jossa vaiheessa, Tﾃ､mﾃ､n silmukan pysﾃ､htyy.
>> Joten anna minun mennﾃ､ eteenpﾃ､in ja tallentaa tﾃ､mﾃ､n ohjelma, ja ajaa tehdﾃ､ jono 0.
Mutta minﾃ､ mokasin.
Epﾃ､suorasti julistaa kirjaston funktion Stirling tyypin niin ja such-- nyt,
tﾃ､mﾃ､ kuulostaa tutulta.
Mutta se ei ole printf.
Ja se ei saa merkkijono.
>> En tyriﾃ､ vuonna samalla tavalla tﾃ､llﾃ､ kertaa.
Mutta huomaa tﾃ､ﾃ､llﾃ､ hieman alaspﾃ､in lisﾃ､ksi, kuuluu otsikon string.h,
mﾃ､ﾃ､rﾃ､yksiﾃ､ tarvittavista ilmoitus Stirling.
Joten on todella vihje siellﾃ､.
>> Ja todellakin se osoittautuu on toinen otsikkotiedoston
ettﾃ､ olemme ei kﾃ､ytetﾃ､ luokassa vielﾃ､, mutta se on
joukossa kﾃ､ytettﾃ､vissﾃ､ teille, nimeltﾃ､ﾃ､n string.h.
Ja kyseisen tiedoston, string.h on Stirling ilmoitettu.
Joten anna minun mennﾃ､ eteenpﾃ､in ja tallentaa, tehdﾃ､ jono
0-- mukava, ei virheilmoitukset tﾃ､llﾃ､ kertaa.
>> ./string0 Zamyla, ja Olen aikeissa Enter,
jossa vaiheessa getstring on menossa palauttaa merkkijonon, laita se s.
Sitten, ettﾃ､ silmukka on menossa kerrata yli S: n merkit yksi kerrallaan,
ja tulostaa ne yksi per rivi, koska Jouduin ettﾃ､ kenoviiva n lopussa.
Joten en voinut jﾃ､ttﾃ､ﾃ､ ettﾃ､ kenoviiva n, ja sitten vain tulostaa Zamyla kaikki
samassa linjassa, tehokkaasti reimplementing
printf, joka ei ole kovin hyﾃｶdyllistﾃ､.
Mutta tﾃ､ssﾃ､ tapauksessa, en ole tehnyt sitﾃ､.
Olen itse painettu yksi merkin kerrallaan, yksi per rivi,
jotta voimme itse nﾃ､hdﾃ､ vaikutuksen.
>> Mutta minun pitﾃ､isi huomata yksi asia tﾃ､ﾃ､llﾃ､.
Ja me palaamme Tﾃ､ssﾃ､ tulevassa viikossa.
Osoittautuu, ettﾃ､ tﾃ､mﾃ､ koodi on mahdollisesti buginen.
>> On kﾃ､ynyt ilmi, ettﾃ､ get merkkijono ja joitakin muita toimintoja elﾃ､mﾃ､ssﾃ､
eivﾃ､t vﾃ､lttﾃ､mﾃ､ttﾃ､ aina palata mitﾃ､ odotat.
Tiedﾃ､mme luokan viimeinen kerran tﾃ､ssﾃ､, jotka saavat
merkkijono on tarkoitus palauttaa merkkijono.
Mutta mitﾃ､ jos kﾃ､yttﾃ､jﾃ､ kirjoittaa tﾃ､llaista pitkﾃ､ sana, tai kohta, tai essee
ettﾃ､ ei vain ole tarpeeksi tietokoneen muistin sopivaksi sitﾃ､.
>> Kuten, mitﾃ､ jos jotain menee vﾃ､ﾃ､rﾃ､ alla huppu?
Se ei ehkﾃ､ tapahdu usein, mutta se voisi tapahtua kerran
tﾃ､llﾃｶin, hyvin harvoin.
Ja niin kﾃ､y ilmi, ettﾃ､ get merkkijono ja toimintoja, kuten se ei vﾃ､lttﾃ､mﾃ､ttﾃ､
aina palata jouset.
He saattavat palauttaa jokin virhe arvo, Joissakin Sentinel arvo niin sanotusti,
joka osoittaa, ettﾃ､ jotain on mennyt vikaan.
Ja te vain tiedﾃ､ tﾃ､tﾃ､ maasta on oppinut sen luokassa nyt,
tai ovat lukea lisﾃ､ﾃ､ asiakirjoja.
On kﾃ､ynyt ilmi, ettﾃ､ get merkkijono voi palauttaa arvon nimeltﾃ､ null.
Null on erityinen arvo, ettﾃ､ me will palata tulevassa viikossa.
Mutta nyt, juuri tietﾃ､ﾃ､, ettﾃ､ jos haluan olla todella asiallista eteenpﾃ､in
kﾃ､yttﾃ､en get string, I ei pitﾃ､isi vain kutsua sitﾃ､,
ja sokeasti kﾃ､yttﾃ､ﾃ､ paluuarvon, luottaen siihen, ettﾃ､ se on merkkijono.
>> Haluan ensin sanoa, hei, hetkinen, vain
toteuttaa, jos s ei ole sama kuin null, jos null, jﾃ､lleen,
on vain joitakin erityisiﾃ､ arvoa.
Ja se on ainoa erityinen arvon tarvitse pelﾃ､tﾃ､ varten get merkkijono.
Hanki merkkijonon joko menossa palauttaa merkkijono tai null.
>> Ja tﾃ､mﾃ､ huutomerkki yhtﾃ､lﾃ､isyysmerkki saatat tietﾃ､ﾃ､ ehkﾃ､ matematiikka luokka
ettﾃ､ saatat piirtﾃ､ﾃ､ yhtﾃ､lﾃ､isyysmerkki kanssa linjan lﾃ､pi osoittamaan ole samanarvoisia.
Se ei ole yleensﾃ､ luonteeltaan voit kirjoittaa nﾃ､ppﾃ､imistﾃｶllﾃ､.
Ja niin useimmissa ohjelmointikieliﾃ､, kun haluat sanoa erisuuri,
kﾃ､ytﾃ､t huutomerkki, muuten kutsutaan Bang.
Joten sanot bang yhtﾃ､ kuin, mikﾃ､ ei tarkoita yhtﾃ､ kuin loogisesti.
Se on aivan kuin siellﾃ､ ei ole suurempi kuin, tai yhtﾃ､ suuri tai pienempi kuin
tai yhtﾃ､ nﾃ､ppﾃ､imistﾃｶn joka tekee kaiken yhdessﾃ､ symbolin.
Joten siksi, aikaisemmissa esimerkeissﾃ､, teit avoin teline, ja sitten
yhtﾃ､lﾃ､isyysmerkki, voidakseen tehdﾃ､ suurempi tai vaikkapa alle.
>> Joten mitﾃ､ takeaway tﾃ､ﾃ､llﾃ､?
Tﾃ､mﾃ､ on yksinkertaisesti tapa nyt on Kyseisellﾃ､ syntaksi, tﾃ､mﾃ､ ominaisuus,
iteroimalla yksilﾃｶllisiin merkkijonon merkkien.
Ja aivan kuten ne neliﾃｶ suluissa voit saada niitﾃ､,
pitﾃ､ﾃ､ nﾃ､itﾃ､ neliﾃｶ suluissa Tﾃ､llainen vihjaten tﾃ､mﾃ､n taustalla
suunnittelu, jolloin jokainen luonnetta sisﾃ､llﾃ､ merkkijono
on erﾃ､ﾃ､nlainen pakattuna jossain alla huppu tietokoneen muistiin.
>> Mutta Tehdﾃ､ﾃ､n muunnelmaa.
Osoittautuu, ettﾃ､ tﾃ､mﾃ､ Ohjelma on oikea.
Joten per CS50 kirveille arvioimiseksi koodi, tﾃ､mﾃ､ on oikea nyt.
Erityisesti nyt, ettﾃ､ olen tarkistanut null, tﾃ､mﾃ､ ohjelma pitﾃ､isi koskaan kaatua.
Ja minﾃ､ vain tiedﾃ､n, ettﾃ､ kokemuksesta.
Mutta ei ole mitﾃ､ﾃ､n muuta, voimme todella mennﾃ､ pieleen.
Mutta se ei ole kovin hyvin suunniteltu, koska mennﾃ､ﾃ､n takaisin perusasioihin.
>> Ensimmﾃ､inen, principles-- Mitﾃ､ for-silmukka tehdﾃ､?
A silmukka tekee kolme asiaa.
Se alustaa joitakin arvoa, jos kysyt sitﾃ､.
Se tarkistaa ehdon.
Ja sitten jokaisen iteraation, jokaisen jakson,
se kasvattaa joitakin arvo tai arvot, tﾃ､ﾃ､llﾃ､.
>> Mitﾃ､ tﾃ､mﾃ､ tarkoittaa?
Me alustaa i 0.
Tarkistamme ja varmista i on pienempi kuin pituus s, joka on Z-A-M-Y-L-A,
niin, joka on pienempi kuin 6.
Ja, todellakin, 0, kun vﾃ､hemmﾃ､n kuin 6.
>> Me tulostaa Z pﾃ､ﾃ､ssﾃ､ Zamyla nimi.
Sitten kasvattaa i 0-1.
Me sitten tarkistaa, on 1 vﾃ､hemmﾃ､n kuin pituus s?
Pituus s on 6.
Kyllﾃ､ se on.
>> Joten me tulostaa in Zamyla nimi, ZA.
Me kasvattaa i 0, 1, 2.
Me sitten tarkistaa, on 2 alle pituus Zamyla nimi.
6- joten 2 on alle 6.
Kyllﾃ､, nyt tulostaa nyt M Zamyla nimi, kolmas merkki.
>> Tﾃ､rkeintﾃ､ tﾃ､ssﾃ､ on, ettﾃ､ kullakin iterointia tarina, olen tarkkailun,
on i pienempi kuin pituus Zamyla?
Mutta saalis on, ettﾃ､ Stirling ei ole omaisuutta.
Ne teistﾃ､, jotka ovat ohjelmoitu ennen Java tai muilla kielillﾃ､
tunteakseen merkkijonon pituuden on ominaisuus, vain joitakin lukea vain arvoa.
>> C tﾃ､ssﾃ､ tapauksessa, jos tﾃ､mﾃ､ on funktio, joka on kirjaimellisesti
lukumﾃ､ﾃ､rﾃ､n laskemisen merkkiﾃ､ Zamyla joka kerta
kutsumme tﾃ､tﾃ､ toiminnallisuutta.
Joka kerta kun pyytﾃ､ﾃ､ tietokoneen kﾃ､yttﾃ､mﾃ､ﾃ､n Stirling, se vilkaisemalla Zamyla,
ja sanomalla Z-A-M-Y-L-A, 6.
Ja se palaa 6.
Seuraavan kerran kun soittaa se sisﾃ､llﾃ､ ettﾃ､ silmukka,
se tulee katsomaan Zamyla jﾃ､lleen, sanovat Z-A-M-Y-L-A, 6.
Ja se tulee palauttaa 6.
Joten mitﾃ､ tyhmﾃ､ tﾃ､stﾃ､ suunnittelu?
>> Miksi koodia ole 5 out of 5 suunnittelu juuri nyt, niin sanotusti?
No, minﾃ､ kysyy kysymys tarpeettomasti.
Teen enemmﾃ､n tyﾃｶtﾃ､ kuin minun tﾃ､ytyy.
>> Joten vaikka vastaus on oikea, olen
kysyy tietokone, mikﾃ､ on pituus Zamyla uudelleen,
ja uudestaan, ja uudestaan, ja uudestaan?
Ja vastaus on koskaan muutu.
Se on aina olemaan 6.
>> Joten parempi ratkaisu kuin tﾃ､mﾃ､ olisi tﾃ､mﾃ､n seuraavan version.
Anna minun mennﾃ､ eteenpﾃ､in ja laita se erillinen tiedosto nimeltﾃ､ string1.c,
vain pitﾃ､ﾃ､ se erillﾃ､ﾃ､n.
Ja se osoittautuu on varten silmukka, voit itse
julistaa useita muuttujia kerralla.
>> Joten aion pitﾃ､ﾃ､ i ja aseta se 0.
Mutta minﾃ､ myﾃｶs menossa lisﾃ､tﾃ､ pilkku, ja sanoa,
antaa minulle muuttuja nimeltﾃ､ n, jonka arvo on merkkijonon pituus s.
Ja nyt, tee tilani kunhan i on pienempi kuin n.
>> Joten tﾃ､llﾃ､ tavalla, logiikka on identtiset lopussa pﾃ､ivﾃ､n.
Olen kuitenkin muistaen arvo 6, tﾃ､ssﾃ､ tapauksessa.
Mikﾃ､ on pituus Zamyla nimi?
Ja olen laskemisesta sitﾃ､ n.
>> Ja olen edelleen tarkkailun ehto joka kerta.
On 0 vﾃ､hintﾃ､ﾃ､n 6?
On 1 vﾃ､hemmﾃ､n kuin 6?
On 2 alle 6, ja niin edelleen?
>> Mutta en pyydﾃ､ tietokonetta uudestaan, ja uudestaan, mikﾃ､
pituus Zamyla nimi?
Mitﾃ､ pituus Zamyla nimi?
Mitﾃ､ pituus tﾃ､mﾃ､n Zamyla nimi?
Olen kirjaimellisesti muistaa, ettﾃ､ ensimmﾃ､inen ja vain vastata tﾃ､ssﾃ､ toisessa muuttujan n.
Joten tﾃ､mﾃ､ nyt olisi paitsi oikea, mutta myﾃｶs hyvin suunniteltu.
>> Nyt entﾃ､ tyyli?
Olen Nimesin muuttujat melko hyvin, sanoisin.
He Super ytimekﾃ､s juuri nyt.
Ja se on tﾃ､ysin kunnossa.
>> Jos sinulla on vain yksi merkkijono ohjelmassa,
voit yhtﾃ､ hyvin kutsua sitﾃ､ s jousikvartetille.
Jos sinulla on vain yksi muuttuja laskemiseksi ohjelmassa,
voit yhtﾃ､ hyvin kutsua sitﾃ､ i.
Jos on pituus, n on super yhteinen samoin.
Mutta en ole kommentoinut mitﾃ､ﾃ､n minun koodia.
>> En ole ilmoittanut reader-- onko se minun TF, tai TA,
tai vain colleague-- mitﾃ､ on oletettu on kﾃ､ynnissﾃ､ tﾃ､ssﾃ､ ohjelmassa.
Ja niin saada hyvﾃ､ tyyli, mitﾃ､ haluaisi tehdﾃ､
on this-- jotain kuten pyytﾃ､ﾃ､ kﾃ､yttﾃ､jﾃ､ltﾃ､ syﾃｶtettﾃ､.
Voisin kirjoittaa Tﾃ､mﾃ､n monin tavoin.
>> Varmista S-- varmista get merkkijono palautetaan merkkijono.
Ja sitten here-- ja tﾃ､mﾃ､ on ehkﾃ､ tﾃ､rkein comment-- toistaa
yli merkkiﾃ､ s kerrallaan.
Ja voisin kﾃ､yttﾃ､ﾃ､ mitﾃ､ tahansa valikoima Englanti kielen
tﾃ､ssﾃ､ kuvaamaan kukin Nﾃ､iden paloina koodia.
>> Huomaa, ettﾃ､ en ole laittaa kommentoida jokainen rivi koodia,
oikeastaan 窶銀久ain on mielenkiintoinen niitﾃ､, ne jotka
on joitakin merkitys etten tekisi haluamme tehdﾃ､ Super selvﾃ､ksi jonkun
kﾃ､sittelyssﾃ､ minun koodi.
Ja miksi soitat saat string pyytﾃ､ﾃ､ kﾃ､yttﾃ､jﾃ､ltﾃ､ syﾃｶttﾃ､ﾃ､?
Jopa, ettﾃ､ yksi ei vﾃ､lttﾃ､mﾃ､ttﾃ､ kaiken kuvaileva.
Mutta se auttaa kertoa tarinan, koska toinen rivi tarina on, varmista
saada merkkijono palautetaan merkkijono.
>> Ja kolmas rivi tarina on, kerrata yli merkkiﾃ､ s yhteen
kerrallaan.
Ja nyt vain hyvﾃ､ toimenpide, Aion mennﾃ､ eteenpﾃ､in ja lisﾃ､tﾃ､
yhden huomautuksen, ettﾃ､ vain sanoo print i: nnen hahmo s.
Nyt, mitﾃ､ olen tehnyt pﾃ､ivﾃ､n pﾃ､ﾃ､tteeksi?
>> Olen lisﾃ､nnyt joitakin Englanti sanojen muodossa kommentteja.
Kautta-slash symboli tarkoittaa, hei, tietokone tﾃ､mﾃ､ on ihmisen,
ei teille, tietokone.
Niinpﾃ､ he huomiotta loogisesti.
Ne ovat vain siellﾃ､.
>> Ja todellakin, CS50 IDE nﾃ､yttﾃ､ﾃ､ niitﾃ､ harmaa, koska ne ovat hyﾃｶdyllisiﾃ､, mutta ei avain
ohjelmaan.
Huomaa mitﾃ､ voit nyt tehdﾃ､.
Onko tiedﾃ､t C ohjelmointi tai ei,
voi vain seistﾃ､ takaisin tﾃ､hﾃ､n ohjelma, ja kuoria kommentteja.
Pyydﾃ､ kﾃ､yttﾃ､jﾃ､ syﾃｶttﾃ､ﾃ､, varmista saada merkkijono palautetaan merkkijono,
kerrata yli merkkiﾃ､ s yksi kerrallaan, tulostaa merkki
i: nnen merkin S-- et edes tarvitse katsoa koodia
ymmﾃ､rtﾃ､ﾃ､, mitﾃ､ tﾃ､mﾃ､ ohjelma tekee.
Ja mikﾃ､ vielﾃ､ parempaa, jos itse nﾃ､yttﾃ､ﾃ､ Tﾃ､mﾃ､n ohjelman viikon tai kaksi,
tai kuukauden tai vuoden, tekin ei ole
tuijottaa koodia, yrittﾃ､ﾃ､ muistaa,
mitﾃ､ minﾃ､ yrittﾃ､nyt tehdﾃ､ tﾃ､tﾃ､ koodia?
>> Sinﾃ､ olet kertonut itse.
Olet kuvattu sitﾃ､ itse, tai jotkut kollegansa, tai TA tai TF.
Ja niin tﾃ､mﾃ､ olisi nyt oikea, ja hyvﾃ､ muotoilu,
ja lopulta hyvﾃ､ tyyli samoin.
Niin pitﾃ､ﾃ､ tﾃ､mﾃ､ mielessﾃ､.
>> Joten on olemassa yksi muu asia aion tehdﾃ､ tﾃ､ﾃ､llﾃ､
joka voi nyt paljastaa, mitﾃ､ on meneillﾃ､ﾃ､n alla huppu.
Joten ei tﾃ､tﾃ､ ominaisuutta C, ja muita kieliﾃ､,
kutsutaan tyypittely ettﾃ､ joko epﾃ､suorasti
tai eksplisiittisesti voit muuntaa yhdestﾃ､ tietotyyppi toiseen.
Olemme tekemisissﾃ､ niin pitkﾃ､lle tﾃ､nﾃ､ﾃ､n jousille.
>> Ja jouset ovat merkkejﾃ､.
Mutta muistaa viikosta 0, mitﾃ､ merkkejﾃ､?
Merkit ovat vain abstraktio pﾃ､ﾃ､lle numbers-- desimaalin numeroita,
ja desimaaliluvuilla ovat todella vain abstraktio pﾃ､ﾃ､lle binﾃ､ﾃ､riluvut,
koska me mﾃ､ﾃ､ritelty sitﾃ､.
>> Joten merkit ovat numeroita.
Ja numerot ovat merkkejﾃ､, vain asiayhteydestﾃ､ riippuen.
Ja kﾃ､y ilmi, ettﾃ､ sisﾃ､llﾃ､ tietokoneohjelman,
voit mﾃ､ﾃ､rittﾃ､ﾃ､, miten haluat etsiﾃ､ at bitit sisﾃ､llﾃ､ kyseisen ohjelman?
>> Recall viikolla 0, ettﾃ､ meillﾃ､ oli Ascii, joka on vain tﾃ､mﾃ､n koodin
kartoitus kirjeitﾃ､ numeroita.
Ja sanoimme, pﾃ､ﾃ､oma A on 65.
Pﾃ､ﾃ､oma B on 66, ja niin edelleen.
>> Ja ilmoitus, meillﾃ､ lﾃ､hinnﾃ､ on merkkiﾃ､ siitﾃ､ ylﾃ､rivin tﾃ､ﾃ､llﾃ､, kuten C kutsuisi heitﾃ､,
merkkejﾃ､, ja sitten ints toisella rivillﾃ､.
Ja se osoittautuu voit muuntaa saumattomasti vﾃ､lillﾃ､, tyypillisesti.
Ja jos me haluamme tehdﾃ､ Tﾃ､mﾃ､n tarkoituksella, me
kannattaa puuttua jotain tﾃ､llaista.
>> Meidﾃ､n kannattaa muuntaa isoja alentaa
tapauksessa, tai pienet kirjaimet isoiksi.
Ja se osoittautuu siellﾃ､ n oikeastaan 窶銀橘uvio tﾃ､ﾃ､llﾃ､
voimme omaksua vain hetken.
Mutta Katsotaanpa ensin klo Esimerkkinﾃ､ Nﾃ､in yksiselitteisesti.
>> Aion mennﾃ､ takaisin CS50 IDE.
Aion luoda tiedosto nimeltﾃ､ Ascii 0.c.
Ja aion mennﾃ､ eteenpﾃ､in ja lisﾃ､tﾃ､ minun standardi io.h huipulla, int main void
ylﾃ､reunassa tehtﾃ､vﾃ､ni.
Ja sitten olen juuri menossa tekemﾃ､ﾃ､n following-- for-silmukka i on yhtﾃ､ suuri kuin,
sanokaamme, 65.
>> Ja sitten minﾃ､ tulee olemaan pienempi kuin 65, plus 26 kirjaimia.
Joten minﾃ､ anna tietokoneen tehdﾃ､ matematiikka minua siellﾃ､.
Ja sitten sisﾃ､lle silmukan, mitﾃ､ olen menossa tulostaa?
>> % C on% i backslash n.
Ja nyt haluan kytkeﾃ､ kaksi arvoa.
Olen tilapﾃ､isesti laittaa kysymyksen merkitsee siellﾃ､ kutsua kysymykseen.
>> Haluan kerrata 65 lﾃ､htien 26 kirjaimet,
tulostus pois jokaisen iteraation ettﾃ､ hahmon kiinteﾃ､ vastaava.
Toisin sanoen, haluan kerrata yli 26 numerot tulostus
mitﾃ､ ASCII on, kirjain, ja mitﾃ､ vastaava mﾃ､ﾃ､rﾃ､ is--
oikeastaan 窶銀久ain uudestaan kaaviota ettﾃ､ dia.
Joten mitﾃ､ pitﾃ､isi nﾃ､mﾃ､ kysymysmerkkejﾃ､ olla?
>> No, kﾃ､y ilmi, ettﾃ､ toinen pitﾃ､isi olla vain muuttuja i.
Haluan nﾃ､hdﾃ､, ettﾃ､ lukuna.
Ja keskellﾃ､ argumentti tﾃ､ﾃ､llﾃ､, voin kertoa tietokoneen
hoitoon ettﾃ､ kokonaisluku i kuten merkki, niin kuin
korvata sen tﾃ､stﾃ､ prosenttia C.
>> Toisin sanoen, jos minﾃ､, ihmisen ohjelmoija, tietﾃ､ﾃ､
nﾃ､mﾃ､ ovat vain numeroita pﾃ､ivﾃ､n pﾃ､ﾃ､tteeksi.
Ja tiedﾃ､n, ettﾃ､ 65 olisi karttaa joitakin luonnetta.
Tﾃ､mﾃ､n nimenomaisen valettu, jossa on suluissa,
nimi tietotyypin haluat muuntaa, ja suljettu suluissa,
voit kertoa tietokone, hei, tietokone,
muuntaa tﾃ､mﾃ､n kokonaisluku char.
>> Joten kun kﾃ､ytﾃ､n tﾃ､tﾃ､ Ohjelman jﾃ､lkeen kokoamiseen,
katsotaanpa mitﾃ､ minﾃ､ get-- tehdﾃ､ ASCII 0.
Hiivatti, mitﾃ､ tein vﾃ､ﾃ､rin tﾃ､ﾃ､llﾃ､?
Kﾃ､ytﾃ､ pimeﾃ､n tunnisteen, kunnossa, ei tahallinen,
mutta katsotaan, jos emme voi Syy kautta.
>> Joten viiva five-- joten en saanut kovin pitkﾃ､lle ennen ruuvaamalla ylﾃｶspﾃ､in.
Se on okei.
Joten linja 5 i on yhtﾃ､ kuin 65-- nﾃ､en.
Niin muista, ettﾃ､ C, toisin kuin jotkut kieliﾃ､ jos olet etukﾃ､teen ohjelmointi
kokemus, olet kertoa tietokoneen,
toisin Scratch, mitﾃ､ tyyppinen muuttuja on.
>> Ja unohdin hokeman tﾃ､ﾃ､llﾃ､.
Linjassa viisi, olen alkanut kﾃ､yttﾃ､ﾃ､ i.
Mutta en ole kertonut C mitﾃ､ tietotyyppi se on.
Joten aion mennﾃ､ tﾃ､ﾃ､llﾃ､ ja sanovat, ah, tee se kokonaisluku.
>> Nyt aion mennﾃ､ eteenpﾃ､in ja kﾃ､ﾃ､ntﾃ､ﾃ､.
Tﾃ､mﾃ､ kiinteﾃ､nﾃ､.
./ascii0 Anna, joka on erﾃ､ﾃ､nlainen jﾃ､ﾃ､htyﾃ､.
Ei vain se huippunopea kysyﾃ､ tietokone tﾃ､tﾃ､ kysymystﾃ､,
ennemmin kuin sen nyt dia, se tulostaa yksi per rivi, A on 65,
B on 66, aina down-- koska olen teki tﾃ､mﾃ､n 26 times-- kirjaimia z,
joka on 90.
Ja, itse asiassa, hieman ﾃ､lykkﾃ､ﾃ､mpiﾃ､ olisi
ovat olleet minulle ei luottaa tietokoneen lisﾃ､tﾃ､ 26.
Voisin juuri tehneet 90 samoin, niin kauan
sillﾃ､ en tee samaa virhettﾃ､ kahdesti.
Haluan mennﾃ､ lﾃ､pi z, ei vain lﾃ､pi y.
>> Niin, ettﾃ､ nimenomainen valettu.
Osoittautuu, ettﾃ､ tﾃ､mﾃ､ ei ole edes tarpeen.
Anna minun mennﾃ､ eteenpﾃ､in ja uusintana tﾃ､mﾃ､n kﾃ､ﾃ､ntﾃ､jﾃ､, ja suorita ASCII 0.
On kﾃ､ynyt ilmi, ettﾃ､ C on aika fiksu.
>> Ja printf, erityisesti, on aika fiksu.
Jos vain lﾃ､pﾃ､istﾃ､vﾃ､ i kahdesti molemmille paikkamerkit, printf
huomaavat, oi, hyvin Tiedﾃ､n antoi minulle integer-- joitakin numero,
kuten 65, tai 90, tai mitﾃ､ tahansa.
Mutta nﾃ､en, ettﾃ､ haluat minun muotoilla ettﾃ､ mﾃ､ﾃ､rﾃ､ kuin merkin.
Ja niin printf voi epﾃ､suorasti heittﾃ､ﾃ､ Int char sinulle samoin.
Joten se ei ole ongelma lainkaan.
>> Mutta huomaa, koska tﾃ､mﾃ､ vastaavuus voimme itse tehdﾃ､ tﾃ､mﾃ､n myﾃｶs.
Anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ yhden muut versio this-- Ascii 1.c.
Ja sen sijaan iteroimalla yli kokonaislukuja, voi todella puhaltaa mieltﾃ､si
iteroimalla yli merkkiﾃ､.
Jos char c saa pﾃ､ﾃ､omaa A, I haluavat mennﾃ､ eteenpﾃ､in ja tehdﾃ､ tﾃ､mﾃ､n,
niin kauan kuin C on pienempi tai yhtﾃ､ suuri kuin pﾃ､ﾃ､oman Z. Ja jokaisen iteraation
Haluan kasvattaa C, voin Nyt minun Printf linjan tﾃ､ﾃ､llﾃ､
vaikkapa prosenttia C on prosenttia uudelleen i, pilkku C.
>> Ja nyt, voin mennﾃ､ toiseen suuntaan, valu merkki nimenomaisesti
kokonaisluvuksi.
Joten jﾃ､lleen, miksi teet tﾃ､mﾃ､n?
Se on vﾃ､hﾃ､n outo tavallaan laskea kannalta merkkiﾃ､.
>> Mutta jos ymmﾃ､rrﾃ､t mitﾃ､ meneillﾃ､ﾃ､n alla huppu,
siellﾃ､ oikeastaan 窶銀砧itﾃ､ﾃ､n taikuutta.
Sinﾃ､ vain sanoa, hei, tietokone antaa minulle muuttuja nimeltﾃ､ C tyypin char.
Alustaa sen pﾃ､ﾃ､oman A. And huomaa heittomerkkeihin asia.
>> Sillﾃ､ merkkejﾃ､ C, muistan viime viikolla, kﾃ､ytﾃ､t heittomerkkien.
Jousille, sanoja, lauseita, kﾃ､ytﾃ､t lainausmerkkejﾃ､.
OK, tietokone, pitﾃ､ﾃ､ tehdﾃ､ tﾃ､mﾃ､, niin kunhan merkki on alle
tai yhtﾃ､ suuri kuin z.
Ja tiedﾃ､n ASCII taulukosta ettﾃ､ kaikki Nﾃ､iden ASCII-koodit ovat vierekkﾃ､in.
>> Ei ole aukkoja.
Joten se on vain A-Z, erottaa yksi numero kunkin.
Ja sitten voin kasvattaa char, jos en todellakaan halua.
Pﾃ､ivﾃ､n pﾃ､ﾃ､tteeksi, se on vain numero.
Tiedﾃ､n tﾃ､mﾃ､n.
Voin siis vain olettaa lisﾃ､tﾃ､ 1 siihen.
>> Ja sitten tﾃ､llﾃ､ kertaa, voin tulostaa c, ja sitten kiinteﾃ､ vastaava.
Enkﾃ､ edes tarvitse nimenomaista valettu.
Voin antaa printf ja tietokone selvittﾃ､ﾃ､ asioita,
niin ettﾃ､ nyt jos juoksen tehdﾃ､ Ascii1./ascii1,
Saan tﾃ､smﾃ､lleen sama asia kuin hyvin.
>> Hyﾃｶdytﾃｶn ohjelma, though-- kukaan tulee todella kirjoittaa ohjelmisto
jotta selvittﾃ､ﾃ､, mikﾃ､ oli numero, joka kuvaa A, B, tai Z?
Olet juuri menossa googlettaa, tai etsiﾃ､ sen verkossa, tai etsi se
levyllﾃ､, tai vastaavalla.
Joten mistﾃ､ tﾃ､mﾃ､ itse saada hyﾃｶtyﾃ､?
>> No, puhutaan ettﾃ､ dia, huomaa siellﾃ､
todellinen kuvio tﾃ､ﾃ､llﾃ､ isojen ja pienet joka ei ollut sattumaa.
Huomaa, ettﾃ､ pﾃ､ﾃ､oma A on 65.
Lowercase a on 97.
Ja kuinka kaukana on alempi tapauksessa?
>> Joten 65 on, kuinka monta askeleen pﾃ､ﾃ､ssﾃ､ 97?
Joten 97 miinus 65 on 32.
Joten pﾃ､ﾃ､oma a on 65.
Jos lisﾃ､ﾃ､t 32 ettﾃ､, saat pienet kirjaimet a.
Ja vastaavasti, jos vﾃ､hennﾃ､ 32, saat takaisin pﾃ､ﾃ､omaa A-- sama B
pikku b, iso C pikku c.
>> Kaikki nﾃ､mﾃ､ puutteet ovat 32 toisistaan.
Nyt tﾃ､mﾃ､ nﾃ､yttﾃ､isi jotta voisimme tehdﾃ､ jotain Microsoft Word,
tai Google Docs ominaisuus, jossa voi valita kaiken ja sitten sanoa,
muuttaa kaikki pieniksi, tai muuttaa kaikki isoiksi,
tai muuttaa vain ensimmﾃ､inen sana lauseen isoiksi.
Voimme todella tehdﾃ､ jotain niin itse.
>> Anna minun mennﾃ､ eteenpﾃ､in ja tallentaa tiedostoa tﾃ､ssﾃ､ kutsutaan hyﾃｶdyntﾃ､ﾃ､ 0.c.
Ja mennﾃ､ﾃ､n eteenpﾃ､in ja lietsoa ohjelma ettﾃ､ juuri nﾃ､in seuraavasti.
Joten sisﾃ､ltﾃ､vﾃ､t CS50 kirjasto.
Ja kuuluu vakio I / O.
>> Ja tiedﾃ､n tﾃ､mﾃ､ on tulossa pian.
Joten aion laittaa sen siellﾃ､ jo, string.h,
joten Olen pﾃ､ﾃ､sy asioita, kuten Stirling,
ja sitten int main mitﾃ､tﾃｶn, kuten tavallista.
Ja sitten aion mennﾃ､ eteenpﾃ､in ja tehdﾃ､ jouset saa pﾃ､ﾃ､stﾃ､ string,
vain saada merkkijonon kﾃ､yttﾃ､jﾃ､ltﾃ､.
Ja sitten aion teen jﾃ､rki tarkistaa.
Jos jono ei ole sama null, niin se on turvallista jatkaa.
Ja mitﾃ､ haluan tehdﾃ､?
Aion kerrata vﾃ､lillﾃ､ i on yhtﾃ､ suuri kuin 0, ja n asti merkkijonon pituus s.
>> Ja aion tehdﾃ､ niin kauan kuin i on pienempi kuin n, ja i plus plus.
Toistaiseksi olen oikeastaan 窶銀久ain lainanotto ideoita ennen.
Ja nyt aion esitellﾃ､ haara.
>> Joten muistelen Scratch, missﾃ､ meillﾃ､ oli nuo haarautuu tie,
ja viime viikolla C. aion sanoa, jos i: nnen hahmo s
on suurempi tai yhtﾃ､lﾃ､inen alentaa tapauksessa,
and-- Scratch olisit kirjaimellisesti sanoa ja, mutta C sanot et-merkki,
ampersand-- ja i: nnen merkki s on pienempi tai yhtﾃ､ suuri kuin alempi tapauksessa z,
Tehdﾃ､ﾃ､n jotain mielenkiintoista.
Katsotaan todella tulostaa merkki ilman rivinvaihto
ettﾃ､ on merkin merkkijono, i: nnen merkin merkkijonon.
>> Mutta mennﾃ､ﾃ､n eteenpﾃ､in ja vﾃ､hennﾃ､ 32 siitﾃ､.
Else jos hahmo merkkijonon etsimme
ei vﾃ､lillﾃ､ pikku ja pikku z, mennﾃ､ eteenpﾃ､in
ja vain tulostaa sen ulos muuttumattomana.
Niinpﾃ､ olemme ottaneet kﾃ､yttﾃｶﾃｶn Tﾃ､mﾃ､n haarukoitua merkintﾃ､tapa
meidﾃ､n jousille saada aikaa i: nnen merkin merkkijonon.
>> Olen lisﾃ､nnyt joitakin ehdollinen logiikka, kuten Scratch viime viikon viikolla yksi, jossa
Olen vain kﾃ､yttﾃ､ﾃ､ minun perustavanlaatuinen kﾃ､sitys siitﾃ､, mitﾃ､ on
meneillﾃ､ﾃ､n alla huppu.
On i: nnen luonne s suurempi tai yhtﾃ､ suuri kuin?
Kuten, on se 97 tai 98, tai 99, ja niin edelleen?
>> Mutta se on myﾃｶs pienempi tai yhtﾃ､ suuri kuin arvoon pieniﾃ､ z?
Ja jos on, mitﾃ､ tﾃ､mﾃ､ linja tarkoittaa?
14, tﾃ､mﾃ､ on tavallaan alkiot koko ajatus,
isolla kirje yksinkertaisesti vﾃ､hentﾃ､mﾃ､llﾃ､ 32 siitﾃ､,
Tﾃ､ssﾃ､ tapauksessa, koska tiedﾃ､n, per se kaavio, miten omat numerot ovat edustettuina.
Joten mene eteenpﾃ､in ja suorittaa tﾃ､mﾃ､n, jﾃ､lkeen kootaan hyﾃｶdyntﾃ､ﾃ､ 0.c,
ja ajaa isolla 0.
>> Katsotaan kirjoita jotain Zamyla in pienillﾃ､ tulevat.
Ja nyt meillﾃ､ on Zamyla isoilla.
Katsotaan kirjoita Rob pienillﾃ､.
Yritetﾃ､ﾃ､n Jason pienillﾃ､.
Ja pidﾃ､mme saada pakko-arvo.
On pieni vika, ettﾃ､ olen Tﾃ､llainen ei ennakoida.
Huomatkaa uusi nopea pﾃ､ﾃ､tyy samalla rivillﾃ､ kuin heidﾃ､n nimensﾃ､,
joka tuntuu hieman sotkuinen.
>> Joten aion mennﾃ､ tﾃ､ﾃ､llﾃ､, ja todella lopussa tﾃ､mﾃ､n ohjelman
tulostaa Rivinvaihtomerkkiﾃ､.
Siinﾃ､ kaikki.
Kanssa printf, sinun ei tarvitse pass muuttujia tai muodossa koodin.
Voit kirjaimellisesti vain tulostaa jotain rivinvaihto.
>> Joten mene eteenpﾃ､in ja tehdﾃ､ hyﾃｶtymﾃ､ﾃ､n 0 jﾃ､lleen, uusintana se, Zamyla.
Ja nyt se on hieman kauniimpi.
Nyt minun nopea on omalla uuden rivin.
Niin, ettﾃ､ kaikki hyvﾃ､ ja hieno.
Niin se on hyvﾃ､ esimerkki.
Mutta en edes vﾃ､lttﾃ､mﾃ､ttﾃ､ tﾃ､ytyy kovaa koodia 32.
Tiedﾃ､tkﾃｶ mitﾃ､?
Voisin say-- en koskaan muistaa, mikﾃ､ ero on.
>> Mutta tiedﾃ､n, ettﾃ､ jos olen on pientﾃ､,
En olennaisesti halua vﾃ､hentﾃ､ﾃ､ pois riippumatta etﾃ､isyys vaihtelee hieman
A ja iso, sillﾃ､ jos oletan, ettﾃ､ kaikki muut kirjaimet ovat samat,
ettﾃ､ pitﾃ､isi saada tyﾃｶtﾃ､ tehnyt.
Mutta sen sijaan tehdﾃ､ sitﾃ､, tiedﾃ､tkﾃｶ mitﾃ､?
On toinenkin tapa edelleen.
>> Jos tﾃ､mﾃ､ on hyﾃｶdyntﾃ､ﾃ､ 1.c-- jos olisin esittﾃ､ﾃ､, ettﾃ､ erilliseen tiedostoon.
Tehdﾃ､ﾃ､n hyﾃｶdyntﾃ､ﾃ､ 2.c seuraavasti.
Aion todella puhdista tﾃ､ﾃ､llﾃ､.
Ja sen sijaan, ettﾃ､ edes tietﾃ､ﾃ､ tai vﾃ､litﾃ､ niistﾃ､ alhainen
toteutuksen yksityiskohdat, olen sen sijaan juuri menossa tulostaa merkin,
lainaus lainaus, prosenttia C, ja soita toinen toiminto,
olemassa joka vie argumentti, joka on luonteeltaan, kuten tﾃ､mﾃ､.
>> On kﾃ､ynyt ilmi C, siellﾃ､ toinen toiminto puhelun
ylﾃ､-, joka nimensﾃ､ ehdottaa vie hahmo
ja tekee sen isoiksi vastaava, ja sitten palauttaa sen
jotta printf voi ampua sitﾃ､ siellﾃ､.
Ja niin tehdﾃ､ tﾃ､mﾃ､n, vaikka olen otettava kﾃ､yttﾃｶﾃｶn yksi muu tiedosto.
On kﾃ､ynyt ilmi, on olemassa toinen tiedosto ettﾃ､ te vain tietﾃ､ﾃ､ luokasta,
tai oppikirja tai online viite, jota kutsutaan C type.h.
>> Jos siis lisﾃ､tﾃ､, ettﾃ､ kesken minun header tiedostoja, ja nyt uudelleen kﾃ､ﾃ､ntﾃ､ﾃ､ ohjelman,
capitalize2, ./capitalize2 Enter.
Katsotaan kirjoita Zamyla kaikissa pieniﾃ､, toimii edelleen sama.
Mutta tiedﾃ､tkﾃｶ mitﾃ､?
On kﾃ､ynyt ilmi, ettﾃ､ ylemmﾃ､n on joitakin muita toimintoja.
>> Ja haluan esitellﾃ､ tﾃ､mﾃ､n komento tﾃ､ﾃ､llﾃ､, tavallaan kangerrellen
nimeltﾃ､ﾃ､n, mutta ihminen manuaaliseen.
On kﾃ､ynyt ilmi, ettﾃ､ useimmat Linux-tietokoneet, koska kﾃ､ytﾃ､mme here-- Linux-kﾃ､yttﾃｶjﾃ､rjestelmﾃ､
system-- hallitse nimeltﾃ､ﾃ､n mies, joka sanoo,
hei, tietokone, anna minulle tietokoneen kﾃ､sikirja.
Mitﾃ､ haluat etsiﾃ､ ettﾃ､ opasta?
>> Haluan etsiﾃ､ toiminnon kutsuttu ylempi, Enter.
Ja se on hieman arvoituksellisesti lukea joskus.
Mutta huomaa me olemme Linux ohjelmoijan kﾃ､sikirja.
Ja kaikki teksti.
Ja huomaa, ettﾃ､ siellﾃ､ on toiminnon nimi tﾃ､ﾃ､llﾃ､.
On kﾃ､ynyt ilmi siinﾃ､ on serkku nimeltﾃ､ﾃ､n alentaa, mikﾃ､ tekee pﾃ､invastoin.
Ja ilmoituksen alle synopsis, kﾃ､yttﾃ､ﾃ､ tﾃ､tﾃ､ toimivat miehen sivun, niin sanotusti,
kertoo minulle, ettﾃ､ minﾃ､ tﾃ､ytyy sisﾃ､llyttﾃ､ﾃ､ c type.h.
Ja tiesin, ettﾃ､ kﾃ､ytﾃ､ntﾃｶﾃｶn.
>> Tﾃ､ﾃ､llﾃ､, se osoitti minulle kaksi prototyyppejﾃ､ toiminto,
niin ettﾃ､ jos joskus haluat kﾃ､yttﾃ､ﾃ､ tﾃ､tﾃ､ En tiedﾃ､, mitﾃ､ he ottaa syﾃｶtteenﾃ､
ja mitﾃ､ he palaavat tuotokseksi.
Ja sitten jos luen kuvausta, nﾃ､en
tarkemmin mitﾃ､ toiminto tekee.
Mutta vielﾃ､ tﾃ､rkeﾃ､mpﾃ､ﾃ､, jos Odotan alle tuottoarvo,
se sanoo palautettu arvo on vaihdettavien kirjeen,
tai C, alkuperﾃ､isen tulo, jos muuntaminen ei ollut mahdollista.
>> Toisin sanoen ylempi yrittﾃ､ﾃ､ muuntaa kirjeen isoiksi.
Ja jos on, se tulee palauttaa sen.
Mutta jos se ei voi jostain reason-- ehkﾃ､ se on jo isoiksi,
ehkﾃ､ se on huutomerkki tai jokin muu punctuation--
se juuri menossa palauttaa alkuperﾃ､isen C,
mikﾃ､ tarkoittaa, ettﾃ､ voin tehdﾃ､ minun koodi parempi rakenne on seuraavanlainen.
>> En tarvitse kaikkia nﾃ､mﾃ､ hiton riviﾃ､ koodia.
Kaikki linjat olen vain korosti voi
luhistuneilta osaksi vain yksi yksinkertainen linja, joka on this-- printf prosenttia
c ylempﾃ､ﾃ､n S kiinnikkeen i.
Ja tﾃ､mﾃ､ olisi Esimerkkinﾃ､ paremman suunnittelun.
>> Miksi toteuttaa 7 tai 8 riviﾃ､ koodia, mitﾃ､ se oli Sain
poistetaan, kun voit sen sijaan romahtaa kaikki tﾃ､mﾃ､ logiikka ja pﾃ､ﾃ､tﾃｶksenteko
yhdeksi linja, 13 nyt, ettﾃ､ tukeutuu kirjasto function--
toiminnon, joka tulee C, mutta se tekee mitﾃ､ haluat sen tehdﾃ､.
Ja rehellisesti, vaikka se ei tullut C,
voit toteuttaa sen itse, koska olemme nﾃ､hneet, jossa saat negatiivinen int
ja saada positiivinen int viime viikolla samoin.
>> Tﾃ､mﾃ､ koodi on nyt paljon enemmﾃ､n luettavissa.
Ja todellakin, jos selaa ylﾃｶspﾃ､in, katso kuinka paljon kompaktimpi
Tﾃ､mﾃ､ versio minun ohjelma on.
Se on vﾃ､hﾃ､n ylhﾃ､ﾃ､ltﾃ､ raskas nyt, kaikki nﾃ､mﾃ､ kuuluvat.
Mutta se on OK, koska nyt seison harteille ohjelmoijat
ennen minua.
Ja joka se oli joka toteutetaan ylempi todella
teki minulle palveluksen, aivan kuten kuka tﾃ､ytﾃ､ntﾃｶﾃｶn Stirling todella
teki minulle palveluksen jokin aika sitten.
Ja niin nyt meillﾃ､ on parempi suunnitteluohjelma
joka toteuttaa tﾃ､smﾃ､lleen samaa logiikkaa.
>> Puhuminen Stirling, anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ tﾃ､tﾃ､.
Anna minun mennﾃ､ eteenpﾃ､in ja tallenna tﾃ､mﾃ､ kuva stirling.c.
Ja se osoittautuu, voimme kuoria takaisin yksi toinen kerros melko yksinkertaisesti nyt.
Aion mennﾃ､ eteenpﾃ､in ja piiska up toinen ohjelma main
tﾃ､ssﾃ､ ettﾃ､ yksinkertaisesti uudelleen tyﾃｶkoneiden merkkijonon pituus seuraavasti.
Joten tﾃ､ssﾃ､ on koodiriviﾃ､ ettﾃ､ saa minut merkkijono kﾃ､yttﾃ､jﾃ､ltﾃ､.
Pidﾃ､mme kﾃ､yttﾃ､mﾃ､llﾃ､ tﾃ､tﾃ､ uudestaan 窶銀桔a uudestaan.
Annan itselleni muuttuja nimeltﾃ､ n tyyppiﾃ､ int, joka tallentaa useita.
>> Ja anna minun mennﾃ､ eteenpﾃ､in ja tee seuraava logiikka.
Vaikka nnen hahmo s tekee erisuuri backslash 0, mennﾃ､ eteenpﾃ､in
ja kasvu n.
Ja sitten tulostaa printf prosenttia i n.
Vﾃ､itﾃ､n, ettﾃ､ tﾃ､mﾃ､ ohjelma tﾃ､ﾃ､llﾃ､, kﾃ､ymﾃ､ttﾃ､ merkkijonon pituus,
keksii pituus merkkijono.
>> Ja taika on tﾃ､ysin kapseloitu linja 8
tﾃ､ﾃ､llﾃ､ mitﾃ､ nﾃ､yttﾃ､ﾃ､ uudet syntaksin, Tﾃ､mﾃ､n kenoviiva 0 heittomerkkeihin.
Mutta miksi?
No, miettiﾃ､, mitﾃ､ on ollut jatkunut koko tﾃ､mﾃ､n ajan.
>> Ja Sivuhuomautuksena ennen kuin unohdan, ymmﾃ､rtﾃ､ﾃ､ myﾃｶs, ettﾃ､ sen lisﾃ､ksi, ettﾃ､ ihminen sivuille
jotka tulevat tyypillinen Linux-jﾃ､rjestelmﾃ､n kuten CS50 IDE,
ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ me, kurssin henkilﾃｶkunta, on myﾃｶs
teki verkkosivusto versio Tﾃ､mﾃ､n saman ajatuksen nimeltﾃ､ﾃ､n
reference.cs50.net, joka on kaikki nﾃ､mﾃ､ samassa man-sivuja,
kaikki saman dokumentointi, sekﾃ､
pieni laatikko huipulla, joka mahdollistaa voit muuntaa kaikki melko
arcane Kielestﾃ､ vﾃ､hemmﾃ､n mukavaksi tilassa, jossa, opetushenkilﾃｶstﾃｶn,
ovat menneet lﾃ､pi ja pyrkinyt yksinkertaistamaan jotkut kielen pitﾃ､ﾃ､ asiat
keskittyi ajatuksia, eikﾃ､ joitakin teknisiﾃ､.
Joten pitﾃ､ﾃ､ mielessﾃ､, reference.cs50.net kuin toinen resurssi samoin.
>> Mutta miksi merkkijonon pituus tyﾃｶtﾃ､ Muuten olen ehdottanut hetki sitten?
Tﾃ､ssﾃ､ Zamyla nimi uudelleen.
Ja tﾃ､ssﾃ､ Zamyla nimi boxed, kuten minﾃ､ pitﾃ､ﾃ､ tehdﾃ､,
maalata kuvan siitﾃ､ ettﾃ､, oikeastaan 窶銀久ain merkkijono.
Mutta Zamyla ei ole olemassa eristyksissﾃ､ ohjelmassa.
>> Kun kirjoittaa ja kﾃ､ynnistﾃ､ﾃ､ ohjelman kﾃ､ytﾃ､t Mac tai PC
muistin tai RAM niin sanotusti.
Ja voit ajatella tietokoneen olevan
paljon gigatavua muistia nﾃ､inﾃ､ pﾃ､ivinﾃ､.
Ja keikka tarkoittaa miljardeja, joten miljardeja tavua.
>> Mutta katsotaan taaksepﾃ､in ajassa.
Ja olettaa, ettﾃ､ kﾃ､ytﾃ､mme todella vanha tietokone, joka
vain 32 tavua muistia.
Voisin, minun tietokoneen nﾃ､ytﾃｶllﾃ､, yksinkertaisesti vetﾃ､ﾃ､ tﾃ､tﾃ､ seuraavasti.
>> Voisin vain sanoa, ettﾃ､ tietokone on kaikki tﾃ､mﾃ､ muisti.
Ja tﾃ､mﾃ､ on kuin tikku muistia, jos muistatte meidﾃ､n kuva edellisen kerran.
Ja jos vain jakaa tﾃ､tﾃ､ riittﾃ､vﾃ､n monta kertaa,
Vﾃ､itﾃ､n, ettﾃ､ minulla on 32 tavua muistin ruudulla.
>> Nyt todellisuudessa, voin vain piirtﾃ､ﾃ､ toistaiseksi tﾃ､llﾃ､ nﾃ､ytﾃｶllﾃ､ tﾃ､ﾃ､llﾃ､.
Joten aion mennﾃ､ eteenpﾃ､in, ja vain sopimuksen mukaan,
kiinnittﾃ､ﾃ､ tietokoneeni muistissa ruudukko, eikﾃ､ vain yksi suora viiva.
Erityisesti Vﾃ､itﾃ､n nyt ruudukkoon, tﾃ､mﾃ､ 8 4 ruudukko,
vain edustaa kaikkia 32 tavua muistia saatavilla Mac,
tai saatavilla tietokoneeseen.
Ja he kﾃ､ﾃ､re on kaksi riviﾃ､, vain
koska se sopii paremmin ruudulle.
Mutta tﾃ､mﾃ､ on ensimmﾃ､inen tavu.
Tﾃ､mﾃ､ on toinen tavu.
Tﾃ､mﾃ､ on kolmas tavu.
>> Ja tﾃ､mﾃ､ on 32. tavu.
Tai, jos ajattelemme kuin tietokone tutkija, tﾃ､mﾃ､ on tavu 0, 1, 2, 3, 31.
Joten sinun tﾃ､ytyy 0-31, jos te alkaa laskea 0.
>> Jos siis kﾃ､yttﾃ､ﾃ､ ohjelmaa ettﾃ､ puhelut saavat merkkijono,
ja saamme merkkijono ihmisen kuten tein kutsutaan Zamyla, Z-A-M-Y-L-A,
miten maailmassa tekee tietokone seurata joka tavun,
joka kimpale muistia, kuuluu mihinkin merkkijono?
Toisin sanoen, jos siirrymme Kirjoita toinen nimi tietokoneeseen,
nﾃ､in Andi kutsuen saada merkkijono toisen kerran,
A-N-D-I on pﾃ､ﾃ､tyﾃ､ tietokoneen muistiin samoin.
Mutta miten?
>> No, kﾃ､y ilmi, ettﾃ､ alla huppu, mitﾃ､ C tekee sﾃ､ilytettﾃ､essﾃ､ jouset
ettﾃ､ ihmisen tyypit, tai ettﾃ､ tulevat muusta lﾃ､hteestﾃ､, on se
rajataan lopussa niitﾃ､ erityinen character-- kenoviiva
0, joka on vain erityinen tapa sanomalla 80 bittiﾃ､ perﾃ､kkﾃ､in.
>> Joten A-- tﾃ､mﾃ､ on numero 97 muistaa.
Siksi jotkut kuvio 8 bittiﾃ､ edustaa desimaaliluku 97.
Tﾃ､mﾃ､ kenoviiva 0 on kirjaimellisesti mﾃ､ﾃ､rﾃ､ 0, alias nul, N-U-L, toisin kuin aikaisemmin,
N-U-L-L, joka puhuttiin.
Mutta nyt, vain tietﾃ､ﾃ､, ettﾃ､ tﾃ､mﾃ､ kenoviiva 0 on vain 80 bittiﾃ､ perﾃ､kkﾃ､in.
>> Ja se on vain tﾃ､mﾃ､ rivi hiekka, joka sanoo mitﾃ､ﾃ､n vasemmalle
kuuluu yksi merkkijono, tai yksi tietotyyppi.
Ja kaiken oikealla kuuluu jotain muuta.
Andi nimi puolestaan joka vain visuaalisesti
sattuu kﾃ､ﾃ､riﾃ､ kiinni toisella linjalla, mutta se on vain esteettinen yksityiskohta,
Samoin on NUL lopetetaan.
>> Se on merkkijono A-N-D-I merkkejﾃ､, plus viidesosa salainen luonne,
kaikki 0 bitit, ettﾃ､ vain rajataan lopussa Andi nimi samoin.
Ja jos me kutsumme saada merkkijono kolmannen kerran tietokone saada kielen kaltaisen
Maria, M-A-R-I-A, samoin on Marian name nul lopetettiin kenoviivaan 0.
>> Tﾃ､mﾃ､ on tﾃ､ysin erilainen siitﾃ､, miten tietokone tyypillisesti
tallentaa kokonaisluku tai float, tai muita tietotyypit edelleen, koska muistaa,
kokonaisluku on yleensﾃ､ 32 bittiﾃ､, tai 4 tavua, tai ehkﾃ､ jopa 64 bittiﾃ､,
tai kahdeksan tavua.
Mutta monet primitives tietokoneella ohjelmointikielellﾃ､
on kiinteﾃ､ mﾃ､ﾃ､rﾃ､ tavua alla hood--
ehkﾃ､ 1, ehkﾃ､ 2, ehkﾃ､ 4, ehkﾃ､ 8.
>> Mutta jouset, jonka muotoilu, on dynaaminen mﾃ､ﾃ､rﾃ､n merkkejﾃ､.
Et tiedﾃ､ etukﾃ､teen, kunnes Ihmisen tyypit Z-A-M-Y-L-A,
tai M-A-R-I-A tai A-N-D-I. Et tiedﾃ､ kuinka monta kertaa kﾃ､yttﾃ､jﾃ､ tulee iskemﾃ､ﾃ､n
nﾃ､ppﾃ､imistﾃｶ.
Siksi et tiedﾃ､ miten monta merkkiﾃ､ etukﾃ､teen
olet menossa tarvitsevat.
>> Ja niin C juuri sellainen lﾃ､htee kuin salainen linkkipolku alla huppu
lopussa merkkijonon.
Tallennettuasi Z-A-M-Y-L-A muistiin, se myﾃｶs vain asettaa vastaava
ajanjaksolta.
Lopussa lauseen, se asettaa 80 bittiﾃ､, niin kuin
muistaa, missﾃ､ Zamyla alkaa ja loppuu.
>> Mikﾃ､ siis yhteys, Sitten, tﾃ､mﾃ､n ohjelman?
Tﾃ､mﾃ､ ohjelma tﾃ､ﾃ､llﾃ､, Stirling, on yksinkertaisesti mekanismi
saada merkkijono kﾃ､yttﾃ､jﾃ､ltﾃ､, rivi 6.
Linja 7, julistan muuttuja nimeltﾃ､ﾃ､n n ja aseta se yhtﾃ､ suuri kuin 0.
>> Ja sitten linjassa 8, en yksinkertaisesti pyytﾃ､nyt kysymys, kun taas n: nnen merkki ei
erisuuri kaikki 0 bits-- Toisin sanoen, ei ole
yhtﾃ､lﾃ､iset tﾃ､mﾃ､ erityinen merkki, kenoviivan 0, joka
oli vain, ettﾃ､ erityistﾃ､ nul character-- mennﾃ､ eteenpﾃ､in ja vain kasvattaa n.
>> Ja pitﾃ､ﾃ､ tehdﾃ､ se, ja pitﾃ､ﾃ､ tee sitﾃ､, ja pitﾃ､ﾃ､ tehdﾃ､ se.
Ja niin vaikka Aiemmin olemme kﾃ､yttﾃ､neet i,
se on tﾃ､ysin kunnossa semanttisesti kﾃ､yttﾃ､ﾃ､ n,
jos olet vain yrittﾃ､ﾃ､ laskea tﾃ､llﾃ､ kertaa tarkoituksella,
ja haluavat vain kutsua sitﾃ､ n.
Joten tﾃ､mﾃ､ vain pitﾃ､ﾃ､ kysyvﾃ､t, on n: nnen luonne on kaikki 0s?
Jos ei, katso seuraavaan ilmeen, katso seuraavaan, katso seuraavaan,
katso seuraavaan.
>> Mutta heti kun nﾃ､et backslash 0, Tﾃ､mﾃ､n loop-- linjan 9 kautta 11-- pysﾃ､htyy.
Rikot ulos samalla silmukka, jﾃ､ttﾃ､en sisﾃ､llﾃ､ ettﾃ､ muuttujan n
yhteen laskettu kaikkien merkkejﾃ､ merkkijonon nﾃ､it,
siten tulostamalla.
Joten kokeile tﾃ､tﾃ､.
>> Anna minun mennﾃ､ eteenpﾃ､in ja ilman kﾃ､yttﾃ､mﾃ､llﾃ､ Stirling toimintoa,
mutta vain kﾃ､yttﾃ､mﾃ､llﾃ､ omaa paljasjalkainen versio tﾃ､ssﾃ､ kutsutaan Stirling, anna minun mennﾃ､ eteenpﾃ､in
ja ajaa Stirling, kirjoita jotain kuten Zamyla, jonka tiedﾃ､n etukﾃ､teen
on kuusi merkkiﾃ､.
Katsotaan, se toimii.
Itse asiassa se on kuusi.
Yritetﾃ､ﾃ､n Rob kolme merkkiﾃ､, kolme merkkiﾃ､ samoin, ja niin edelleen.
Niin, ettﾃ､ kaikki se menee on alla huppu.
Ja huomaa yhteydet, Sitten, jossa ensimmﾃ､isellﾃ､ viikolla
luokan, jossa puhuimme jotain abstraktio,
joka on juuri tﾃ､mﾃ､ Kerrostaa ideoita, tai monimutkaisuus, pﾃ､ﾃ､lle perusperiaatteista.
Tﾃ､ﾃ､llﾃ､, me tavallaan etsivﾃ､t alla huppu Stirling,
niin sanotusti selvittﾃ､ﾃ､, miten se voidaan toteuttaa?
>> Ja voisimme uudestaan 窶銀逆oteuttaa sen itse.
Mutta emme koskaan menossa uudelleen toteuttaa Stirling.
Olemme juuri menossa kﾃ､yttﾃ､ﾃ､ Stirling jﾃ､rjestyksessﾃ､
todella saada joitakin jouset pituus.
>> Mutta ei ole maaginen alla huppu.
Jos tiedﾃ､t, ettﾃ､ alla huppu, merkkijono
on vain joukko merkkejﾃ､.
Ja ettﾃ､ merkkijono kaikki voidaan numeerisesti kﾃ､siteltﾃ､vﾃ､
jossa kannatin 0, kannatin 1, kannatin 2, ja te
tietﾃ､vﾃ､t, ettﾃ､ lopussa merkkijono on erikoismerkki, voit selvittﾃ､ﾃ､
miten useimmat mitﾃ､ vain ohjelma, koska kaikki se kiehuu
lukee ja kirjoittaa muistiin.
Eli muuttumassa ja etsimﾃ､ssﾃ､ at muisti, tai liikkuvat asiat
noin muistiin, tulostus asiat ruudulla, ja niin edelleen.
>> Joten nyt kﾃ､yttﾃ､ﾃ､ tﾃ､tﾃ､ newfound ymmﾃ､rtﾃ､minen mitﾃ､ kieliﾃ､ tosiasiassa
ovat alla huppu, ja Taitat yksi toinen kerros
ettﾃ､ tﾃ､hﾃ､n asti olemme ollut vﾃ､littﾃ､mﾃ､ttﾃ､ kokonaan.
Erityisesti tahansa Olemme toteuttaneet ohjelman,
meillﾃ､ on ollut koodirivin ylﾃ､osassa julistaa tﾃ､rkein.
Olemme myﾃｶs mﾃ､ﾃ､ritelty int main mitﾃ､tﾃｶn.
>> Ja ettﾃ､ mitﾃ､tﾃｶn sisﾃ､llﾃ､ suluissa on sanonut koko ajan, ettﾃ､ tﾃ､rkeimmﾃ､t
itse ei ota argumentteja.
Kaikki tulo ettﾃ､ tﾃ､rkein on menossa kﾃ､yttﾃ､jﾃ､lle
on tultava muulla mekanismi, kuten get int,
tai saada float tai saada merkkijono, tai jokin muu toiminto.
Mutta kﾃ､y ilmi, ettﾃ､ kun kirjoittaa ohjelma,
voit itse mﾃ､ﾃ､rittﾃ､ﾃ､ ettﾃ､ tﾃ､mﾃ､ ohjelma on
ottaa tuotantopanokset ihmisen komentoriviltﾃ､ itse.
>> Toisin sanoen, vaikka me tﾃ､hﾃ､n mennessﾃ､ on ollut kﾃ､ynnissﾃ､ vain ./hello hei
tai vastaavia ohjelmia, kaikki muut ohjelmat, jotka olemme kﾃ､yttﾃ､neet,
ettﾃ､ me itse ei kirjoittanut, ovat saaneet, nﾃ､yttﾃ､ﾃ､ siltﾃ､,
komentorivi arguments-- asioita, kuten make.
Sanot jotain tehdﾃ､, ja sitten toinen sana.
Tai kalahtaa, sanot clang, ja sitten toinen sana, nimi tiedoston.
>> Tai jopa RM tai CP, kuten saatat nﾃ､hnyt tai kﾃ､ytetty jo
poistaa tai kopioida tiedostoja.
Kaikki nﾃ､mﾃ､ ottaa niin sanottuja komentorivi arguments--
lisﾃ､sanoja terminaalissa nopea.
Mutta tﾃ､hﾃ､n asti, me itse ei ole ollut
tﾃ､mﾃ､ ylellisyys ottaa panosta kﾃ､yttﾃ､jﾃ､ kun hﾃ､n todella toimii
itse ohjelman komentoriviltﾃ､.
>> Mutta voimme tehdﾃ､ sen uudestaan 窶銀喫lmoittamalla Tﾃ､rkein eteenpﾃ､in, ei olevan
mitﾃ､tﾃｶidﾃ､ suluissa, mutta nﾃ､mﾃ､ kaksi argumenttia
instead-- ensimmﾃ､inen kokonaisluku, ja toinen jotain
uusi, jota me aiomme soittaa array, jotain vastaavaa hengessﾃ､
mitﾃ､ nﾃ､imme Scratch luettelona, 窶銀砧utta merkkijonojen joukko, kuten tulemme pian nﾃ､hdﾃ､.
Mutta katsotaanpa tﾃ､mﾃ､n Esimerkiksi, ennen kuin
erottaa mitﾃ､ se tarkoittaa.
>> Joten jos menen CS50 IDE tﾃ､ﾃ､llﾃ､, olen mennyt eteenpﾃ､in
ja ilmoitettu niminen tiedosto argv0.c seuraavat mallin.
Ja huomaa ainoa asia se on erilaista toistaiseksi
on, ettﾃ､ olen muuttunut mitﾃ､tﾃｶn int argc string argv alkusulkumerkki lﾃ､hellﾃ､
kiinnike.
Ja huomaa nyt, siellﾃ､ mitﾃ､ﾃ､n sisﾃ､llﾃ､ nﾃ､istﾃ､ suluissa.
>> Ei ole numero.
Eikﾃ､ ole i, tai n, tai mikﾃ､ tahansa muu kirjain.
Olen vain kﾃ､yttﾃ､mﾃ､llﾃ､ hakasulkeissa nyt,
syistﾃ､ tulemme takaisin vain hetken.
>> Ja nyt, mitﾃ､ aion tehdﾃ､, on tﾃ､mﾃ､.
Jos argc yhtﾃ､ kuin yhtﾃ､ kuin 2-- ja muistuttavat, ettﾃ､ on yhtﾃ､ tasavertaisia
on yhtﾃ､suuruusoperaattorin vertaamalla vasen ja oikea tasa-arvoa.
Se ei ole toimeksianto operaattori, joka on
yhden yhtﾃ､lﾃ､isyysmerkki, mikﾃ､ tarkoittaa kopio oikealta vasemmalle jotain arvoa.
>> Jos argc yhtﾃ､ kuin yhtﾃ､ kuin 2, haluan vaikkapa printf, hei, prosentteja, uusi linja,
ja sitten kytke in-- ja tﾃ､ssﾃ､ uudessa trick-- argv kiinnike 1 syistﾃ､
ettﾃ､ me palaamme hetken.
Else if argc ei equal 2, tiedﾃ､tkﾃｶ mitﾃ､?
Mennﾃ､ﾃ､n eteenpﾃ､in ja, kuten tavallista, tulostaa out Hello World ilman korvaamista.
>> Joten nﾃ､yttﾃ､ﾃ､ siltﾃ､, 窶銀菊ttﾃ､ jos argc, joka sanoista argumentti count, on 2,
Aion tulostaa hei jotain tai muuta.
Muussa tapauksessa oletuksena, olen menossa painoon Hello World.
Mitﾃ､ tﾃ､mﾃ､ tarkoittaa?
>> No, anna minun mennﾃ､ eteenpﾃ､in ja tallenna tﾃ､mﾃ､n tiedoston, ja sitten eivﾃ､t tee argv0,
ja sitten ./argv0, Enter.
Ja se sanoo Hello World.
Nyt Miksi?
>> No, se kﾃ､ﾃ､ntyy pois milloin vain suorittaa ohjelman komentoriviltﾃ､,
tﾃ､ytﾃ､t Mitﾃ､ me yleensﾃ､ soittaa argumenttivektorin.
Toisin sanoen, automaattisesti tietokone, kﾃ､yttﾃｶjﾃ､rjestelmﾃ､,
on menossa kﾃ､si ohjelmaasi itse listan kaikista sanoista
ettﾃ､ ihmisen kirjoitettuna kehotteen siltﾃ､ varalta,
ohjelmoija haluavat tehdﾃ､ jotain tﾃ､mﾃ､n tiedon.
Ja tﾃ､ssﾃ､ tapauksessa ainoa sana Olen kirjoittanut kehoitteessa on ./argv0.
>> Ja niin useita vﾃ､itteitﾃ､, jotka on siirrellﾃ､ﾃ､n minun ohjelma on vain yksi.
Toisin sanoen, argumentti count, joka tunnetaan myﾃｶs argc
tﾃ､ﾃ､llﾃ､ kokonaisluku, on vain yksi.
Yksi tietenkﾃ､ﾃ､n ei ole sama kahden.
Ja niin tﾃ､mﾃ､ on mitﾃ､ tulostaa, Hello World.
>> Mutta minﾃ､pﾃ､ ottaa tﾃ､mﾃ､n jonnekin.
Saanen sanoa, argv0.
Ja sitten miten Maria?
Ja sitten Enter.
>> Ja huomaa, mitﾃ､ maagisesti tapahtuu tﾃ､ﾃ､llﾃ､.
Nyt sen sijaan Hello World, olen muuttanut kﾃ､yttﾃ､ytymistﾃ､ ohjelman
ottamalla tulo eikﾃ､ get merkkijono tai jokin muu toiminto,
mutta ilmeisesti minun komento itse, mitﾃ､ alun perin kirjoitettu.
Ja voin pelata tﾃ､tﾃ､ peliﾃ､ uudelleen muuttamalla sen Stelios, esimerkiksi.
>> Ja nyt nﾃ､en toinen nimi vielﾃ､.
Ja tﾃ､ssﾃ､, sanoisin Andi.
Ja voisin sanoa Zamyla.
Voimme pelata tﾃ､tﾃ､ peliﾃ､ koko pﾃ､ivﾃ､n, vain kytkemﾃ､llﾃ､ eri arvoja,
niin kauan kuin minﾃ､ antaa tarkalleen kaksi sanaa kehotteeseen,
niin ettﾃ､ argc, minun argumentti laskea, on 2.
>> Nﾃ､en ettﾃ､ nimi kytketty printf, per tﾃ､mﾃ､ ehto tﾃ､ﾃ､llﾃ､?
Joten meillﾃ､ nﾃ､yttﾃ､ﾃ､ nyt ilmaisuvoimainen ominaisuus
ottaa panos toinen mekanismi, alkaen ns komentorivin,
eikﾃ､ tarvitse odottaa kunnes kﾃ､yttﾃ､jﾃ､ kﾃ､ynnistﾃ､ﾃ､ ohjelman,
ja kehottaa sitten hﾃ､nelle kﾃ､yttﾃ､mﾃ､llﾃ､ jotain get merkkijono.
>> Joten mitﾃ､ tﾃ､mﾃ､ on?
Argc, jﾃ､lleen, on vain kokonaisluku, mﾃ､ﾃ､rﾃ､ words-- arguments--
ettﾃ､ kﾃ､yttﾃ､jﾃ､ on aikaansaatu nopea kello pﾃ､ﾃ､teikkunaa
mukaan lukien ohjelman nimen.
Joten meidﾃ､n ./argv0 on tehokkaasti, ohjelman nimen,
tai miten ajaa ohjelman.
>> Se lasketaan sana.
Joten argc olisi 1.
Mutta kun kirjoitan Stelios, tai Andi, tai Zamyla tai Maria,
se tarkoittaa, ettﾃ､ vﾃ､ite mﾃ､ﾃ､rﾃ､ on kaksi.
Ja niin nyt on kaksi sanaa hyvﾃ､ksyttiin.
>> Ja ilmoitus, voimme jatkaa tﾃ､tﾃ､ logiikkaa.
Jos minﾃ､ oikeastaan 窶銀虐anoa jotain Zamyla Chan,
tﾃ､ydellinen nimi, nﾃ､in ohimennen kolme vﾃ､itettﾃ､ yhteensﾃ､,
Nyt se sanoo oletuksena uudelleen, koska tietenkin, 3 ei ole sama 2.
>> Ja niin tﾃ､llﾃ､ tavalla, minulla on tulotie argv tﾃ､mﾃ､ uusi vﾃ､ite
ettﾃ､ voisimme teknisesti soittaa mitﾃ､ haluamme.
Mutta sopimuksen mukaan, se on argv ja argc, vastaavasti.
Argv, argumenttivektorin, on erﾃ､ﾃ､nlainen of synonyymi ohjelmointi
ominaisuus C kutsutaan jono.
>> Valikoima on luettelo vastaavista arvoista takaisin, takaisin, takaisin, takaisin.
Toisin sanoen, jos yksi on tﾃ､ﾃ､llﾃ､ RAM, seuraava on aivan sen vieressﾃ､,
ja aivan sen vieressﾃ､.
Ne eivﾃ､t ole koko paikka.
Ja ettﾃ､ viimeksi mainittu skenaario, jossa asiat ovat koko paikka muistiin,
voi todella olla tehokas ominaisuus.
Mutta palaamme asiaan, kun me puhua harrastaja tietorakenteita.
Nyt joukko on vain kimpale yhtenﾃ､istﾃ､ muistia,
jokainen jonka alkiot ovat takaisin, takaisin, takaisin, takaisin,
ja yleensﾃ､ samaa tyyppiﾃ､.
>> Joten jos ajattelee, mistﾃ､ hetki sitten, mikﾃ､ on merkkijono?
No, merkkijono, kuten Zamyla, Z-A-M-Y-L-A, on teknisesti,
vain joukko.
Se on joukko merkkejﾃ､.
>> Ja niin jos todella vetﾃ､ﾃ､ tﾃ､mﾃ､n, koska olen aiemminkin, koska kimpale muistia,
kﾃ､y ilmi, ettﾃ､ jokainen nﾃ､istﾃ､ merkkiﾃ､ vie tavu.
Ja sitten on, ettﾃ､ erityistﾃ､ Sentinel luonne, kenoviivan 0,
tai kaikki kahdeksan 0 bittiﾃ､, ettﾃ､ rajataan loppuun merkkijonon.
Joten merkkijono, se muuttuu out, lainata lainaus pﾃ､ﾃ､ttyy merkkijono,
on vain joukko chara-- char on todellinen tietotyyppi.
>> Ja nyt argv, meanwhile-- mennﾃ､ﾃ､n takaisin ohjelmaan.
Argv, vaikka nﾃ､emme sanan string tﾃ､ﾃ､llﾃ､, ei ole merkkijono itse.
Argv, argumenttivektorin, on joukko merkkijonoja.
>> Joten kun voit olla erilaisia merkkiﾃ､, voit olla korkeampi,
joukko strings-- niin, esimerkiksi, kun olen kirjoittanut hetki sitten ./argv0
argv0, tila Z-A-M-Y-L-A, I vﾃ､itti, ettﾃ､ argv oli kaksi jousille it-- ./argv0,
ja Z-A-M-Y-L-A. Sisﾃ､ﾃ､n Toisin sanoen, argc oli 2.
Miksi niin?
>> No, tehokkaasti, mitﾃ､ tapahtuu siitﾃ､, ettﾃ､ kukin nﾃ､istﾃ､ jouset
on tietenkin joukko merkkejﾃ､ kuten ennen, jonka jokainen merkkiﾃ､
vie yhden tavun.
Ja ﾃ､lﾃ､ sekoita todellista 0 ohjelman nimen kanssa 0,
mikﾃ､ tarkoittaa kaikkia 80 bittiﾃ､.
Ja Zamyla puolestaan 窶銀黍n edelleen myﾃｶs joukko merkkejﾃ､.
>> Joten lopussa pﾃ､ivﾃ､, se todella nﾃ､yttﾃ､ﾃ､ tﾃ､ltﾃ､ alla huppu.
Mutta argv, luonteeltaan kuinka tﾃ､rkeimmistﾃ､ tyﾃｶt, avulla voin paketoida kaikki tﾃ､mﾃ､
ylﾃｶs, jos haluatte, isompi array ettﾃ､ jos me hieman yksinkertaistaa
mitﾃ､ kuva nﾃ､yttﾃ､ﾃ､ eivﾃ､tkﾃ､ melko piirtﾃ､ﾃ､ mittakaavassa jopa siellﾃ､,
Tﾃ､mﾃ､ joukko on vain koko 2, ensimmﾃ､inen elementti, joka sisﾃ､ltﾃ､ﾃ､ merkkijonon,
toinen elementti joka sisﾃ､ltﾃ､ﾃ､ merkkijonon.
Ja puolestaan 窶銀桔os Tﾃ､llainen zoomata kussakin
nﾃ､istﾃ､ jouset, mitﾃ､ katso alla huppu
on, ettﾃ､ jokainen merkkijono on vain erilaisia 窶銀砧erkkejﾃ､.
>> Nyt aivan kuten jouset, pystyimme pﾃ､ﾃ､stﾃ､ kﾃ､siksi
on i: nnen merkin merkkijono kﾃ､yttﾃ､mﾃ､llﾃ､ ettﾃ､ hakasulku merkintﾃ､tapa.
Vastaavasti, paneelit yleensﾃ､, voimme
kﾃ､yttﾃ､ﾃ､ hakasulje merkintﾃ､ﾃ､ saada milloin tahansa mﾃ､ﾃ､rﾃ､n merkkijonojen joukko?
Esimerkiksi haluan mennﾃ､ eteenpﾃ､in ja tehdﾃ､ tﾃ､tﾃ､.
>> Anna minun mennﾃ､ eteenpﾃ､in ja luoda argv1.c, joka on hieman erilainen tﾃ､llﾃ､ kertaa.
Sen sijaan, ettﾃ､ tarkistamalla argc2, Aion sen sijaan tehdﾃ､ tﾃ､mﾃ､n.
Sillﾃ､ int saan 0, I on vﾃ､hemmﾃ､n kuin argc, I plus plus,
ja sitten tulostaa sisﾃ､llﾃ､ tﾃ､stﾃ､, prosentin s, uusi rivi, ja sitten
argv kiinnike i.
>> Eli toisin sanoen, en ole tekemisissﾃ､ yksittﾃ､isiﾃ､ merkkejﾃ､ tﾃ､llﾃ､ hetkellﾃ､.
Argv, kuten epﾃ､suorasti tyhjﾃ､ﾃ､n ruutuun olkaimet oikealla nimen argv,
tarkoittaa argv on Merkkijonotaulukko.
Ja argc on vain int.
>> Tﾃ､mﾃ､ linja tﾃ､ﾃ､llﾃ､, 6, on sanomalla asettaa i yhtﾃ､ suuri kuin 0.
Laske kaikki asti, mutta ei, argc.
Ja sitten jokaisen iteraation, tulostaa merkkijonon.
Mikﾃ､ merkkijono?
>> I: nnen merkkijono argv.
Joten kun ennen olin kﾃ､yttﾃ､en hakasulku
merkintﾃ､tapa saada i: nnessﾃ､ merkin merkkijono, nyt
Olen kﾃ､yttﾃ､en hakasulku merkintﾃ､tapa saada aikaa nnen merkkijonon array.
Joten se on erﾃ､ﾃ､nlainen yhden kerroksen edellﾃ､, kﾃ､sitteellisesti.
>> Ja niin mitﾃ､ siisti tﾃ､stﾃ､ ohjelma nyt, jos en koota argv1,
ja sitten tehdﾃ､ ./argv1, ja kirjoita sitten moisesta foo bar baz,
jotka ovat kolme oletuksena sanaa, ettﾃ､ tietojenkﾃ､sittelytieteessﾃ､ kurottaa tahansa
hﾃ､n tarvitsee jonkin paikkamerkki sanoja, ja Enter, kullakin sanalla,
kuten ohjelman nimen, joka on argv ensimmﾃ､isessﾃ､ paikassa,
pﾃ､ﾃ､tyy painetaan yksi kerrallaan.
Ja jos minﾃ､ muuttaa tﾃ､tﾃ､, ja sanon jotain argv1 Zamyla Chan,
saamme kaikki kolme nﾃ､istﾃ､ sanoja, joka on argv0,
argv1, argv2, koska tﾃ､ssﾃ､ tapauksessa argc, count, on 3.
>> Mutta mikﾃ､ on siisti on jos ymmﾃ､rrﾃ､t ettﾃ､ argv on vain joukko jouset,
ja ymmﾃ､rrﾃ､t, ettﾃ､ merkkijono on joukko merkkejﾃ､,
voimme todella sellaista kﾃ､yttﾃ､vﾃ､t tﾃ､tﾃ､ hakasulje merkintﾃ､tapa useita kertoja
valita merkkijono ja valitse merkin sisﾃ､llﾃ､ merkkijono,
sukellus syvemmﾃ､lle seuraavasti.
Tﾃ､ssﾃ､ esimerkissﾃ､ anna minun mennﾃ､ eteenpﾃ､in ja kutsuvat tﾃ､tﾃ､ argv2.c.
Ja tﾃ､ssﾃ､ esimerkissﾃ､, anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ following-- varten int saan 0,
i on pienempi kuin argc, i plus plus, aivan kuten ennenkin.
Eli toisin words-- ja nyt tﾃ､mﾃ､ on saada monimutkainen tarpeeksi.
Sitten aion sanoa kerrata yli jousille argv,
kommenttina itselleni.
Ja sitten aion olla sisﾃ､kkﾃ､isiﾃ､ silmukka, joka luultavasti
ovat tehneet, tai katsotaan teet, Scratch, jossa
Aion sanoa int-- olen aio kﾃ､yttﾃ､ﾃ､ i uudelleen,
koska en halua varjo, tai tavallaan korvata olemassa olevan i.
>> Aion sen sijaan, sanovat j, koska se on minun mennﾃ､ muuttuja jﾃ､lkeen i,
kun olen vain yrittﾃ､ﾃ､ laskea yksinkertaisen numeroita.
J saa 0-- ja myﾃｶs, n, on menossa saada perﾃ､ pituus argv kiinnike i,
kunhan j on pienempi kuin m, j plus plus, toimi seuraavasti.
Ja tﾃ､ssﾃ､ on mielenkiintoinen osa.
>> Tulosta merkin ja uusi linja, kytkemﾃ､llﾃ､ argv kannatin i, kannatin j.
OK, joten haluan lisﾃ､tﾃ､ joitakin kommentteja tﾃ､ﾃ､llﾃ､.
Kerrata yli merkkiﾃ､ nykyisessﾃ､ string,
print j: nnen hahmo i: nnelle merkkijono.
Joten nyt Tarkastellaan mitﾃ､ nﾃ､mﾃ､ kommentit tarkoittaa.
>> Kerrata yli jouset in argv-- montako
jouset ovat argv, joka on taulukko?
Argc monta, joten olen iteroimalla alkaen i = 0, jopa argc.
Samaan aikaan, kuinka monta merkkiﾃ､ ovat i: nnen merkkijonon argv?
>> No, saada, ettﾃ､ vastaus, Olen juuri soittaa merkkijonon pituus
nykyisestﾃ､ string I care noin, mikﾃ､ on argv kiinnike i.
Ja aion vﾃ､liaikaisesti varastoida ettﾃ､ arvo n, vain vﾃ､limuistiin tarkoituksiin,
muistaa sen tehokkuutta.
Ja sitten aion alustaa j 0, pitﾃ､ﾃ､ kﾃ､ynnissﾃ､ niin kauan kuin j on pienempi kuin n,
ja jokaisen iteraation lisﾃ､yksen j.
>> Ja sitten tﾃ､ﾃ､llﾃ､, kohti minun kommentoida linja 12,
tulostaa merkin, jonka jﾃ､lkeen uusi rivi,
Erityisesti argv kiinnike i antaa minulle i: nnen string
in argv-- joten ensimmﾃ､inen sanaa, toinen sana, kolmas sana riippumatta.
Ja sitten j sukellusta syvemmﾃ､lle, ja saa me j: nnen luonne tuo sana.
Ja niin, itse asiassa, voit hoitaa argv niin moniulotteinen,
kuten kaksiulotteinen, array, jolloin jokainen sana sellainen nﾃ､yttﾃ､ﾃ､
kuten tﾃ､mﾃ､ mielesi silmﾃ､, ja jokainen merkki
on sellainen muodostetaan sarake, jos se auttaa.
>> Todellisuudessa kun kiusaa Tﾃ､mﾃ､n lisﾃ､ksi tulevaisuudessa viikkoja,
se tulee olemaan hieman kehittyneempiﾃ､ kuin.
Mutta voit todella ajatella, ettﾃ､ nyt,
koska juuri tﾃ､mﾃ､ kaksiulotteinen array, jolloin yksi taso sen
on kaikki jouset.
Ja sitten jos sukeltaa syvemmﾃ､lle, te voi saada aikaa yksittﾃ､isten merkkien
taavaa kﾃ､yttﾃ､mﾃ､llﾃ､ tﾃ､tﾃ､ merkintﾃ､ﾃ､ tﾃ､ﾃ､llﾃ､.
>> Joten mikﾃ､ on nettovaikutus?
Anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ argv2-- hiton sitﾃ､.
Tein virheen tﾃ､ﾃ､llﾃ､.
Epﾃ､suorasti ilmoittamisessa kirjaston funktion Stirling.
Joten koko tﾃ､mﾃ､n ajan, se on ehkﾃ､ aiheellista
ettﾃ､ olemme tavallaan viimeistely missﾃ､ aloitimme.
>> Mokasin implisiittisesti julistaa kirjaston funktion Stirling.
OK, odota hetki.
Muistan, ettﾃ､ varsinkin koska se on tﾃ､ﾃ､llﾃ､.
Minun tﾃ､ytyy sisﾃ､llyttﾃ､ﾃ､ string.h vuonna tﾃ､mﾃ､ versio ohjelmasta.
>> Anna minun mennﾃ､ eteenpﾃ､in ja sisﾃ､ltﾃ､vﾃ､t string.h, paitsi ettﾃ､, mennﾃ､ eteenpﾃ､in
ja kﾃ､ﾃ､ntﾃ､ﾃ､ argv2.
Ja nyt, tﾃ､ssﾃ､ sitﾃ､ mennﾃ､ﾃ､n, tee argv2, Enter.
Ja vaikka se on hieman arvoituksellinen ensi silmﾃ､yksellﾃ､,
huomata, todellakin, mitﾃ､ tulostetaan on piste argv2.
>> Mutta jos kirjoitan joitakin sanoja jﾃ､lkeen nopea, kuten argv2 Zamyla Chan,
Anna, myﾃｶs hieman arvoituksellinen ensi silmﾃ､yksellﾃ､.
Mutta jos me vierittﾃ､ﾃ､ takaisin ylﾃｶs, ./argv2 Z-A-M-Y-L-A C-H-A-N.
Siksi olemme iterated yli jokaista sanaa.
Ja puolestaan 窶銀黍lemme iterated yli jokainen kirjaimen sanan.
>> Nyt, kun kaikki tﾃ､mﾃ､, ymmﾃ､rtﾃ､ﾃ､, ettﾃ､ on olemassa
yksi muu yksityiskohtaisesti olemme olleet erﾃ､ﾃ､nlainen unohdetaan koko tﾃ､mﾃ､n ajan.
Me vain kiusoitteli toisistaan 窶銀砧itﾃ､ Tﾃ､rkeimmﾃ､t n tulot voivat olla?
Entﾃ､ tﾃ､rkeimmﾃ､t tuotannosta?
>> Kaikki tﾃ､mﾃ､ aika, olemme olleet vain kopioimalla
sana int edessﾃ､ tﾃ､rkein, vaikka et voi nﾃ､hdﾃ､ verkossa,
joskus virheellisesti vanhemmissa versioissa C ja kﾃ､ﾃ､ntﾃ､jﾃ､t, ettﾃ､ he sanovat mitﾃ､tﾃｶn,
tai ei mitﾃ､ﾃ､n.
Mutta todellakin, ettﾃ､ version C, ettﾃ､ kﾃ､ytﾃ､mme,
C 11, tai 2011, ymmﾃ､rtﾃ､ﾃ､ ettﾃ､ sen pitﾃ､isi olla int.
Ja sen pitﾃ､isi olla joko mitﾃ､tﾃｶn tai argc ja argv tﾃ､ﾃ､llﾃ､.
>> Mutta miksi int main?
Mikﾃ､ on se todella palaamassa?
No, se kﾃ､ﾃ､ntyy pois kaiken tﾃ､mﾃ､n ajan, tahansa olet kirjoittanut ohjelman pﾃ､ﾃ､asiallinen
on aina palaa jotain.
Mutta se on ollut nﾃ､in salaa.
>> Se jokin on int, koska rivi 5 ehdottaa.
Mutta mitﾃ､ int?
No, on tﾃ､mﾃ､ sopimus ohjelmointi,
jolloin jos mitﾃ､ﾃ､n on mennyt pieleen ja kaikki on hyvin,
ohjelmat ja toiminnot yleisesti return-- hieman counterintuitively--
0.
0 yleensﾃ､ merkitsee kaikki on hyvin.
Joten vaikka ajatella se vﾃ､ﾃ､rinﾃ､ monissa yhteyksissﾃ､,
se itse asiassa tarkoittaa yleensﾃ､ hyvﾃ､ asia
>> Samaan aikaan, jos ohjelma palauttaa 1, tai negatiivinen 1, tai 5, tai negatiivinen 42,
tai ei-0-arvo, ettﾃ､ yleensﾃ､ merkitsee
ettﾃ､ jotain on mennyt vikaan.
Itse omalla Mac- tai PC, olet ehkﾃ､ nﾃ､hneet
virheilmoituksen, jolloin se sanoo jotain tai muuta, virhe
koodi negatiivinen 42 tai virhekoodi 23, tai jotain sellaista.
Tﾃ､mﾃ､ numero on yleensﾃ､ vain aavistuksen ohjelmoija tai yritys
joka teki ohjelmisto, mikﾃ､ meni pieleen ja miksi,
jotta he voivat kﾃ､ydﾃ､ lﾃ､pi asiakirjansa tai koodi,
ja selvittﾃ､ﾃ､, mitﾃ､ virhe todella tarkoittaa.
Se on yleensﾃ､ ole hyﾃｶdyllistﾃ､ meille loppukﾃ､yttﾃ､jille.
>> Mutta kun tﾃ､rkein palauttaa 0, kaikki on hyvin.
Ja jos et mﾃ､ﾃ､ritﾃ､ mitﾃ､ tﾃ､rkein pitﾃ､isi palata,
se vain automaattisesti palata 0 sinulle.
Mutta palaavat jotain muu on todella hyﾃｶdyllinen.
>> Tﾃ､ssﾃ､ lopullinen ohjelma, haluan mennﾃ､ eteenpﾃ､in ja kutsuvat tﾃ､tﾃ､ exit.c,
ja ottaa viimeisen pﾃ､ivﾃ､n aiheita, tunnettu virhekoodi.
Anna minun mennﾃ､ eteenpﾃ､in ja sisﾃ､ltﾃ､ﾃ､ myﾃｶs tuttu tiedostoja ylﾃｶs, tee int main.
Ja tﾃ､llﾃ､ kertaa, tehdﾃ､ﾃ､n int argc, string argv, ja minun suluissa
vihjata, ettﾃ､ se on jono.
Ja sitten haluan vain tehdﾃ､ jﾃ､rki tarkistaa.
Tﾃ､llﾃ､ kertaa, jos argc ei equal 2, niin tiedﾃ､t mitﾃ､?
Unohda.
Aion sanoa, hei, kﾃ､yttﾃ､jﾃ､, olet puuttuu komentorivillﾃ､
backslash n.
>> Ja sitten se on siinﾃ､.
Haluan poistua.
Aion ennaltaehkﾃ､isevﾃ､sti, ja ennenaikaisesti todella, paluu
jotain muuta kuin numero 1.
Go to arvoa ensimmﾃ､istﾃ､ virhe, joka voi tapahtua on 1.
Jos sinulla on jokin muu virheellinen tilanne, joka saattaa ilmetﾃ､,
voisi sanoa paluu 2 tai palauttaa 3, tai ehkﾃ､ jopa negatiivinen 1 tai negatiivinen 2.
>> Nﾃ､mﾃ､ ovat vain exit koodeja jotka ovat yleensﾃ､
hyﾃｶtyﾃ､ vain ohjelmoija, tai yritys, joka on merenkulun ohjelmisto.
Mutta se, ettﾃ､ se on ei 0 on, mikﾃ､ on tﾃ､rkeﾃ､ﾃ､.
Joten jos tﾃ､ssﾃ､ ohjelmassa, haluan taata, ettﾃ､ tﾃ､ssﾃ､ ohjelmassa ainoastaan
toimii, jos kﾃ､yttﾃ､jﾃ､ antaa minulle argumenttia lasken kaksi,
nimi ohjelman, ja joitakin muita sana, voin valvoa niin paljon kuin seuraava,
Yell kﾃ､yttﾃ､jﾃ､lle printf sanonta, puuttuva komentorivillﾃ､,
palata 1.
Se tulee vain vﾃ､littﾃｶmﾃ､sti lopettaa ohjelman.
>> Vain jos argc = 2 saamme alas tﾃ､ﾃ､llﾃ､, jossa vaiheessa aion sanoa,
hei prosenttia s, kenoviiva n, argv1.
Toisin sanoen, olen aio jﾃ､lkeen argv 0,
joka on vain ohjelman nimi.
Haluan tulostaa hei, pilkku, toinen sana, ettﾃ､ ihmisen kirjoitetaan.
Ja tﾃ､ssﾃ､ tapauksessa linja 13, kaikki on hyvin.
>> Tiedﾃ､n, ettﾃ､ argc on 2 loogisesti tﾃ､stﾃ､ ohjelmasta.
Aion mennﾃ､ eteenpﾃ､in ja palauttaa 0.
Sivuhuomautuksena, pitﾃ､ﾃ､ mielessﾃ､, ettﾃ､ Tﾃ､mﾃ､ pﾃ､tee Scratch samoin.
>> Loogisesti, voisin tehdﾃ､ tﾃ､tﾃ､ ja kiteyttﾃ､ﾃ､ nﾃ､mﾃ､ rivit
koodia tﾃ､ssﾃ､ muu lauseke tﾃ､ﾃ､llﾃ､.
Mutta se on erﾃ､ﾃ､nlainen tarpeettomasti sisennys minun koodi.
Ja Haluan tehdﾃ､ Super selvﾃ､ﾃ､, ettﾃ､ mitﾃ､ tahansa,
oletuksena, hei jotain saavat painettu,
niin kauan kuin kﾃ､yttﾃ､jﾃ､ tekee yhteistyﾃｶtﾃ､.
>> Joten on hyvin tavallista kﾃ､yttﾃ､ﾃ､ ehdon, vain jos,
pyydystﾃ､mﾃ､ﾃ､n virheellinen tilanne, ja sitten poistu.
Ja sitten, niin kauan kaikki on hyvin, ei ole muuta,
mutta vain koodia ulkopuolella ettﾃ､ jos, koska se on
vastaava tﾃ､ssﾃ､ erityistapauksessa, loogisesti.
Joten olen palaamassa 0, vain nimenomaisesti merkitsevﾃ､t kaikki on hyvin.
>> Jos minﾃ､ pois paluuta 0, se olisi automaattisesti olettaa minulle.
Mutta nyt kun palaan yksi ainakin tﾃ､ssﾃ､ tapauksessa
Aion, kaupanpﾃ､ﾃ､llisiksi ja selkeys, palauttaa 0 tﾃ､ssﾃ､ tapauksessa.
Nyt anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ exit, joka on tﾃ､ydellinen segue vain lﾃ､hteﾃ､.
>> Mutta varmista exit, ja anna minun mennﾃ､ eteenpﾃ､in ja tehdﾃ､ ./exit, Enter.
Ja ohjelma huusi minulle, puuttuva komentorivillﾃ､.
OK, anna minun tehdﾃ､ yhteistyﾃｶtﾃ､.
>> Saanen sen sijaan tehdﾃ､ ./exit, David, Enter.
Ja nyt se sanoo, hei David.
Ja et normaalisti nﾃ､e tﾃ､tﾃ､.
>> Mutta nﾃ､yttﾃ､ﾃ､ siltﾃ､, 窶銀菊ttﾃ､ on olemassa erityisellﾃ､ tavalla Linux todella nﾃ､hdﾃ､
mitﾃ､ exit koodin ohjelma poistui.
Joskus graafinen maailmaa, kuten Mac OS tai Windows,
nﾃ､et vain nﾃ､itﾃ､ numeroita, kun virheilmoitus ponnahtaa nﾃ､ytﾃｶlle
ja ohjelmoija nﾃ､yttﾃ､ﾃ､, ettﾃ､ numeron.
Mutta jos haluamme nﾃ､hdﾃ､, mitﾃ､ virhe viesti on, voimme tehdﾃ､ sen here--
niin ./exit, Enter, tulostaa puuttuva komentorivillﾃ､.
>> Jos minﾃ､ nyt tehdﾃ､ echo $ ?, joka on naurettavan arvoituksellinen nﾃ､kﾃｶinen.
Mutta $?
on maaginen loitsu joka sanoo, hei, tietokone,
kerro mitﾃ､ edellisessﾃ､ Ohjelman exit-koodi oli.
Ja osuin Enter.
Nﾃ､en 1, koska se mitﾃ､ kertonut pﾃ､ﾃ､tehtﾃ､vﾃ､ palata.
>> Samaan aikaan, jos en ./exit David, ja Enter, nﾃ､en, hei David.
Ja jos minﾃ､ nyt tehdﾃ､ echo $ ?, nﾃ､en hei 0.
Ja niin tﾃ､mﾃ､ todella olla arvokasta tietoa
yhteydessﾃ､ debuggeri, ei niin paljon, ettﾃ､ te, ihmisen, ei vﾃ､littﾃ､isi.
Mutta debuggerin ja muut ohjelmat kﾃ､ytﾃ､mme tﾃ､mﾃ､n lukukauden
usein tarkastellaan, ettﾃ､ mﾃ､ﾃ､rﾃ､, vaikka se tavallaan piilossa
ellet etsiﾃ､ sitﾃ､, mﾃ､ﾃ､rittﾃ､ﾃ､, onko ohjelman
suorittamisen oikea vai vﾃ､ﾃ､rﾃ､.
>> Ja niin tﾃ､mﾃ､ tuo meidﾃ､t Tﾃ､mﾃ､n lopussa pﾃ､ivﾃ､n.
Aloitimme tﾃ､nﾃ､ﾃ､n katsomalla virheenkorjaus, ja vuorotellen kurssin
itse, ja sitten enemmﾃ､n kiinnostavaa, Teknisesti alla huppu
mitﾃ､ jouset ovat, jotka kestﾃ､vﾃ､t viikolla vain otti itsestﾃ､ﾃ､nselvyytenﾃ､,
ja varmasti vei heidﾃ､t selvﾃ､nﾃ､ Scratch.
>> Sitten tarkasteltiin, kuinka voimme kﾃ､yttﾃ､ﾃ､ yksittﾃ､isiﾃ､ merkkejﾃ､ merkkijonon,
ja sitten taas otti korkeammalle tasolle katsomaan asioita, katsomalla miten well--
jos haluamme saada yksittﾃ､isiﾃ､ elementtiﾃ､ yhdessﾃ､ listassa kuten rakenne,
ei voi teemme ettﾃ､ useita jouset?
Ja voimme kanssa komentoriviargumentteja.
Mutta tﾃ､mﾃ､ kuva tﾃ､ﾃ､llﾃ､ vain laatikoiden on demonstratiivipronominit tﾃ､mﾃ､ yleinen ajatus
array, tai lista, tai vektori.
Ja riippuen yhteydessﾃ､, kaikki nﾃ､mﾃ､ sanat
tarkoittaa hieman eri asioita.
Joten C, olemme vain menossa puhua array.
Ja joukko on murikka muistia, joista kukin on
elementit ovat vierekkﾃ､isiﾃ､, takaisin, takaisin, takaisin, takaisin.
>> Ja nﾃ､mﾃ､ seikat ovat yleensﾃ､ samat tiedot tyyppi, merkki,
merkki, merkki, merkki, tai string, string, string, string, tai int,
int, int, mitﾃ､ se on yritﾃ､mme sﾃ､ilyttﾃ､ﾃ､.
Mutta lopussa pﾃ､ivﾃ､, tﾃ､mﾃ､ on miltﾃ､ se nﾃ､yttﾃ､ﾃ､ kﾃ､sitteellisesti.
Olet ottaen oman tietokoneen muistin tai RAM.
Ja olet veistﾃ､mﾃ､llﾃ､ sen ulos samankokoisia laatikoita, jotka kaikki
takaisin, takaisin, jotta takaisin, takaisin tﾃ､llﾃ､ tavalla.
>> Ja mitﾃ､ mukavaa noin Tﾃ､mﾃ､ ajatus, ja se
ettﾃ､ voimme ilmaista arvoja tﾃ､llﾃ､ tavoin ensimmﾃ､isen meidﾃ､n tietorakenteiden
luokassa, tarkoittaa voimme aloittaa ongelmien ratkaisemiseksi koodilla
joka tuli niin intuitiivisesti viikolla 0.
Saat muistaa puhelimen kirjaesimerkkiin, jossa
kﾃ､ytimme hajoita ja hallitse, tai puolitushaku,
kﾃ､ydﾃ､ lﾃ､pi koko nippu nimiﾃ､ ja numeroita.
Mutta oletimme, muistuttaa, ettﾃ､ puhelinluettelo on jo jﾃ､rjestetty,
ettﾃ､ joku muu oli jo tajunnut out-- annetaan luettelo nimiﾃ､
ja numbers-- miten aakkostaa niitﾃ､.
Ja nyt, ettﾃ､ C me, Myﾃｶs on kyky
antaa asioita, ei fyysisesti puhelinluettelosta
mutta kﾃ､ytﾃ､nnﾃｶssﾃ､ on tietokoneen muisti, voimme ensi viikolla
esitellﾃ､ uudelleen this-- ensimmﾃ､isen meidﾃ､n tietorakenteiden kﾃ､ytettﾃ､essﾃ､ array--
mutta vielﾃ､ tﾃ､rkeﾃ､mpﾃ､ﾃ､, todellinen tietokone tiede algoritmit toteutetaan
koodin, jolla voimme varastoida data rakenteissa, kuten tﾃ､mﾃ､,
ja sitten alkaa kﾃ､sitellﾃ､ sitﾃ､, ja todella ratkaista ongelmia sen kanssa,
ja rakentaa sen pﾃ､ﾃ､lle, lopulta, ohjelmia C,
Python, JavaScript, kyselyitﾃ､ tietokantoja SQL?
>> Ja nﾃ､emme, ettﾃ､ kaikki nﾃ､mﾃ､ erilaisia 窶銀蟻jatuksia lukitus.
Mutta nyt, muistaa, ettﾃ､ verkkotunnuksen ettﾃ､ otimme kﾃ､yttﾃｶﾃｶn tﾃ､nﾃ､ﾃ､n
oli tﾃ､mﾃ､ asia tﾃ､ﾃ､llﾃ､, ja maailmaan salakirjoituksen.
Ja joukossa seuraavan ongelmat itse ratkaisee on taidetta salakirjoituksen,
scrambling ja vastahajotus tietoa, ja salauksen
ja deciphering tekstiﾃ､, ja olettaen lopulta
ettﾃ､ te nyt tietﾃ､ﾃ､, mitﾃ､ on alla huppu
niin ettﾃ､ kun nﾃ､et tai vastaanottaa tﾃ､llaisen viestin, te
itse voi tulkita sitﾃ､.
Kaikki tﾃ､mﾃ､, ja enemmﾃ､n ensi kerralla.
>> [VIDEOTOISTOSTA]
>> -Mover Juuri saapunut.
Aion mennﾃ､ vierailun hﾃ､nen yliopiston professori.
Jep.
Moi.
Se olet sinﾃ､.
Odota!
David.
Olen vain yrittﾃ､nyt selvittﾃ､ﾃ､ mitﾃ､ sinulle tapahtui.
Ole hyvﾃ､, mitﾃ､ tahansa voi auttaa.
Olit hﾃ､nen college kﾃ､mppﾃ､kaveri, vai mitﾃ､?
Olit siellﾃ､ hﾃ､nen kanssaan, kun hﾃ､n sijoittui CS50 hanke?
>> [MUSIIKKIA]
>> -Se Oli CS50.
>> Rakastan tﾃ､tﾃ､ paikkaa.
>> -Syﾃｶdﾃ､.
Menemme ulos liiketoimintaa.
>> [END TOISTO]