[Powered by Google Translate] [2. hét, folytatás]
[David J. Malan, Harvard University]
[Ez CS50. - CS50.TV]
Rendben van. Ez CS50, és ez a vége a 2. héten.
Ha azt várod, hogy éhes ez idő tájt holnap,
tudom, hogy fogunk összehívni, mint egy kis csoport holnap, csütörtökön, 13:15.
Van egy URL-t ide, ha szeretné RSVP.
Tér korlátozott, ezért kérlek bocsáss meg, ha az űrlap töltötte fel az időt, töltse ki ezt.
Egy másik URL azonban, hogy érdekes lehet ez.
Alig egy hónap múlva, a tanfolyam lesz bocsátani
annál is inkább, nagyjából keresztül EDX, amelyen keresztül emberek az interneten lesz képes követni mentén,
vegyenek részt a tanfolyam elég aktívan, sőt.
Fogják használni a gép és a CS50 CS50 Fórum
és a legtöbb a különböző szoftver eszközök, hogy mi már használ ebben a félévben.
És az egyik kezdeményezések szeretnénk vállalni, mint egy kísérlet ebben az évben
is, hogy lásd, mennyi tartalom tudunk fordítani
más beszélt és írott nyelv.
Tehát, ha lehet, hogy érdekeltek a projektben résztvevő
amellyel mi fog angol nyelvű átirata és a feliratok a tanfolyam előadásait
és rövidnadrág és szemináriumok és szakaszok és hasonlók,
ha beszél folyékonyan, vagy írjon folyékonyan egy másik nyelven,
mi szívesen részt Önnek ebben a projektben, amelynek során az előírtnál egy vagy több, a videók,
fordítani őket egy nyelvet tudsz elég jól.
>> Ahhoz, hogy te egyfajta a felület, itt van ez a web-alapú felhasználói felület
hogy mi fog használni, hogy létre fog hozni lényegében egy UI, mint ez.
Ezt nekem tanítás néhány Halloween napja,
és a jobb oldalon van a fekete mellett e időbélyegeket,
látni fogja a különböző dolgokat, hogy jött ki a számat, hogy a nap,
majd alatta leszel képes lefordítani más nyelven
pontosan mi a leképezés között, ebben az esetben, az angol és, mondjuk, spanyol.
Tehát ez valójában egy nagyon felhasználóbarát eszköz.
Akkor hátra és előre-nagyon könnyen a billentyűparancsokat.
Tehát, ha azt szeretné, hogy vegyen részt ebben a kísérletben, és a szavakat látható és olvasható
az esetleg ezer emberek odakinn, kérjük ne habozzon részt.
Egy szó, ami a kiscicát hétfő.
Nehogy küldtünk túlságosan ijesztő üzenet ezt észre, hogy mivel munkaidőn sugallják
és szakaszok arra utalnak, a design a tanfolyam nagyon
hogy a diákok együttműködő és beszélt a munka a probléma készletek
és a problémák együtt, és tényleg csak a vonal jön le, hogy,
ismét a munkát, amit végül be kell tenni a saját.
És őszintén, a munkaidőn ez teljesen normális,
ez teljesen várható még, hogy beszélgetni néhány ismerősként melletted.
>> Ha ő küzd néhány téma, és te, mint
"Oh, nos, hadd adjak egy pillantást néhány sort, hogy én írtam, hogy" jól van,
ez megtörténik, és ez nagyon kedvező, azt hiszem, a tanulási folyamat.
Amennyiben a sor kerül át, amikor a fej a fajta döntve ide a túl sok másodperc
vagy perc, hogy tényleg, hogy csak volt egy feloldási lehetőség a barátod,
és természetesen, amikor a dolgok cserélt e-mailben és Dropbox és hasonlók,
is ott van a vonalban.
Szóval minden eszközzel érzik magukat, és úgy érzik, ösztönözni kell beszélgetni a barátokkal
és osztálytársai mintegy psets és egyre csak észre, hogy amit végül kattintson
tényleg olyan termék, a teremtés, és nem valaki más.
És így az egyik terület-specifikus problémák pset2,
ami ki fog jönni késő holnap este, hogy belevetik magukat a világ a kriptográfia,
amely a művészet titkosítására vagy kódolási információkat,
és ez végül kapcsolódik a világ biztonságát.
Most, a biztonság a legtöbben formájában érkezik a meglehetősen világi mechanizmusok.
Mindannyiunk felhasználónevek és jelszavak,
és mindannyiunknak nagyon rossz felhasználónevek és jelszavak, valószínűleg.
>> Ha a jelszó megegyezik több webhelyen, ez talán nem a legjobb ötlet,
ahogy megbeszéljük felé félév végén.
Ha a jelszó van írva egy ragadós jegyzet - nem vicc - a monitoron,
ez is, nem feltétlenül a legjobb design, de elég gyakori jelenség.
És ha nem használ titkosítást titkosítja a jelszavakat,
ők különösen veszélyeztetettek.
Tehát, ha azt hiszed, hogy szuper okos azáltal, hogy egy rejtett Word-dokumentum
valahol a merevlemezen, hogy az összes a jelszavakat
de ez egy mappába, hogy senki nem fog nézni, ez is nem egy nagyon biztonságos mechanizmus.
És mi pset2 fog bevezetni ez a művészet a kriptográfia
és kódolási információt, hogy a dolgok, mint például jelszavak annál biztonságosabb.
A kontextus itt az, hogy a bizonytalan adatokkal
jön a lehetőséget, hogy titkosítja, és összekeveri azt.
És így ez, például, egy példa a titkosított üzenet.
Ez tényleg mond valamit angolul, de ez nyilvánvalóan nem teljesen nyilvánvaló.
És mi jön teljes kört ma ugratni kívül, amit ez titkos üzenetet itt.
De a valóságban a számítógépek, a dolgok nem is néz ki, mint esetleg az angol kifejezéseket.
Például, ez az, amit lehet, hogy talál egy szabványos Linux vagy Mac vagy UNIX számítógép
egy aktában volt egyszer régen az úgynevezett jelszó fájl.
>> Manapság ez már költözött más helyeken.
De ha megnézi a megfelelő helyre a rendszer, akkor látni nem csak a felhasználónevét
vagy hogy más emberek a rendszer, de meglátja, titkosított változata a jelszó.
Valóban, a szó kripta ott azt javasolja, hogy a következő cucc titkosított,
és ez a sorozat látszólag véletlenszerű betűk és karakterek és számok, és így tovább
lehet visszafejteni csak általánosságban ismeretében valami titkos -
egy titkos szót, egy titkos szám -
és így valóban a művészet kriptográfia végső soron attól függ, hogy bízik valamilyen
és annak tudatában, amit valaki más nem.
Így fogjuk felfedezni ezt egy kicsit részletesebben ma és a Pset jönni.
És most egy szó a pass / fail.
Különösen, mint néhány már lebukott pset1, a készülék,
, és egy teljesen új világot magadnak, rájönnek, hogy frusztrációt és zavart
és csak technikai nehézségek nagyon várható,
különösen az első Pset, ahol csak annyi az új,
csak arra, hogy ismerik a ls, CD és mindezek misztikus parancsokat
és egy új környezet, és ez független a tényleges anyagi és programozás is.
Tehát észre azt is, hogy vannak biztosan munkaidőn, hogy létezik egy támogatási struktúra.
>> Szakasza kezdődik a jövő vasárnap.
De ami a legfontosabb, ha érzel most, hogy nem ez a világ van,
észre, hogy ez tényleg nem csak időt vesz igénybe.
És ha nem lettek volna ezt a lehetőséget évvel ezelőtt engem vesz egy osztály / nem felelt meg,
őszintén, soha nem lett volna, még a lábát az osztályteremben.
És tudod változtatni ezt-ig, mondjuk, az ötödik hétfőn persze,
így ha a szélén most észre, hogy ahelyett, hogy fejét valami más vizeken teljesen,
nem biztos, csak úgy változik át / nem felelt meg.
Ismét ott nem igazán ez a kultúra itt Harvard figyelembe dolgok megfelelt / nem
hiszen mindenki nagyon szeretne elérni, vagy túl is,
de őszintén szólva, ez egy csodálatos módon próbál valamit
hogy esetleg nem ismerős neked, és akkor a végén csinál, a legtöbb esetben meglehetősen finom,
Talán sok a meglepetés.
És Konkrétabban, mit gondolok megfelelt / nem felelt általában nem,
különösen azért, mert lehet, hogy tapasztalt pset0,
ha tesz, 10 óra, 15 óra, 25 óra a néhány Pset
és te csak beverte a fejét a falnak, és ez egyre szuper késő este
de már megtette a Pset 90%-át az utat, és nem tudod kitalálni egy dolog,
megfelelt / nem igazán úgy élét egy osztály, mint ez,
ahol egyfajta boldogan mondja: "Oké, tudom, hogy nem tökéletes,
de én dolgoztam a seggem ebben, vagyok boldog, ha végül "
és amelyek megfelelnek a vonatkozó várakozások / nem felelt meg.
Szóval, hogy tartsa szem előtt. Rendben van.
>> Tehát azok, akik küzdöttek, hogy használja a Harvard Egyetem Wi-Fi,
tudja, hogy van egy CS50 SSID, a Wi-Fi kapcsolat, lebeg
hogy lehet, hogy jobb szerencse.
Ez egy kicsit ironikus, hogy a jelszó az, ha azt szeretné, hogy próbáljon meg csatlakozni az e
a jobb sebesség -, és tudassa velünk, ez nem jobb - 12345, egészen akár 8
mert a 8 sokkal biztonságosabb, mint 5.
Tehát, ha szükség van a Wi-Fi jelszavát, csatlakoztassa a CS50 vezeték nélküli itt, 12345678,
és post CS50 Beszéljétek ha még időszakos kapcsolódási problémák,
és mi hagyja, hogy a hatalom lehet tudni, ezen a helyen. Rendben van.
Tehát egy gyors teaser, különösen azok számára, akik rajongó fiú vagy lány minden dolgok Apple.
Amit kiásták a néhány évvel ezelőtt volt, ezt a fájlt itt, iUnlock.c,
csak ilyen, hogy több konkrét és bonyolultabb
Néhány a több alap C programok voltunk írásban.
Szóval nyitni ezt a fájlt, iUnlock.c. Ez elérhető a Lectures oldalon ma.
A bal oldalon látható egy hosszú listát a funkciók.
Szóval a fickó, aki írta ezt írta egy csomó funkciók, több, mint fő.
Valaha egy csomó könyvtárak itt, és ha elkezdünk lapozást,
mi ez tulajdonképpen a legelső, azt hiszem, repedés az eredeti iPhone.
>> Ha akarta jailbreak az eredeti iPhone, ami azt jelenti, untether hogy az AT & T
és ténylegesen telepíteni speciális szoftver, és a dolgok, hogy az Apple nem akarta az embereket,
valaki volt az ideje, hogy kitaláljuk, hogy pontosan hogyan tudnák kihasználni szoftver hibák,
hibák, bugok, az Apple szoftver, és így született meg iUnlock.c--
hogy ha össze azt a számítógépet, és telepítettem rá egy iPhone
hogy az csatlakoztatva volt a számítógéphez, mondjuk, egy USB kábelt,
ez ad közigazgatási vagy root jogosultságokkal az iPhone
és hagyja, hogy te elég sok, amit akarsz.
És így volt ez a csodálatos macska-egér játék
között az Apple és a világ többi része, különösen azok, mint sok vállalat,
próbálja lezárni a dolgot le úgy, hogy csak akkor lehet vele csinálni, amit kívánt.
De hála az emberek, mint ez, és a megértése alacsony szintű adatai -
és ebben az esetben a C programozás - és egy csomó ismerős konstrukciók
hogy már elkezdett játszani, meg tudja-e valóban kihasználhatják a hardver
olyan módon, ahogy jónak látod, és nem feltétlenül egyes vállalati egység.
Így például, fogalmam sincs, mi ez csinál,
de GetVersion hangzik elég egyértelmű,
és úgy néz ki, mint ez a funkció, hogy ez a személy írta.
Beletelik valami egész, mint egy érvet, nem ad vissza semmit,
de úgy tűnik, hogy egy hurok a hurok itt és ha a feltétel, ha a feltétel törés,
és valahogy kapcsolódik verziószámok ha lapozzunk lefelé,
bár sok ilyen kulcsszavak lesznek új.
És van egy csomó funkció van itt még sosem láttam, és talán soha nem lát
során a félév.
>> Végén a nap, ebből az következik, ugyanazokat a szabályokat és logikát, hogy mi már játszott eddig.
Szóval ez túl öreg ahhoz, hogy kiváló az iPhone 3s vagy 4s vagy hamarosan 5s ezekben a napokban,
de tudjuk, hogy ez mind nagyon származik a világ, hogy már lebukott.
Vessünk egy pillantást egy kicsit több egyszerű példát:
ezt, csak azért, hogy felmelegedett néhány szintaktikai és még néhány más adattípust
hogy már beszéltünk, de még nem igazán látott C.
Ez a fájl neve positive1.c, és a per a megjegyzéseket a tetején,
ez csak azt követeli, hogy a felhasználó egy pozitív szám.
Szóval ez egy példa a do-while ciklus, ami szép és jó a felhasználó interaktív programok
ahol meg kell mondani a felhasználónak, hogy tegyen valamit,
és ha nem működik együtt te kiabálsz, vagy elutasítja a bemenet.
Case pont: fogok csinálni sorok 19 keresztül 24
amíg a felhasználó nem adott nekem egy pozitív szám.
Ez a részlet itt a 18 vezetéken, miért kijelentem n fent ez az egész loop konstrukcióval
szemben közvetlenül a 22 vonal, ahol tényleg érdekel, hogy n? Igen.
[Hallgató] kör. >> Igen, ezt a kérdést a hatályát.
És a laikus szempontból, mit hatálya utal?
Igen. >> [Hallhatatlan tanulói válasz] >> Tudsz beszélni egy kicsit hangosabban?
[Hallgató] Hol lehet hozzáférni a változó. >> Tökéletes.
Ha el tudja érni egy adott változó.
És általában, a ökölszabály eddig az volt, hogy a körét egyes változó
határozza meg a legutóbbi kapcsos zárójelek, amit látott.
>> És ebben az esetben, ha elkövette azt a hibát nyilvánító n on-line 22, hogy a vonal fog működni.
Szeretnék kap egy int, és azt helyezze be, hogy az n változó sorban 22,
de kódsor hogy most fogalmam sincs, miről beszélsz? >> [Hallgató] 25.
[Malan] 25, és kiderült, hogy 24 is, mert ebben az esetben ez kívül esik a kapcsos zárójelek.
Szóval, csak egy kicsit kellemetlen, de nagyon könnyen megoldható egyszerűen nyilvánító változó
kívül a funkciót is.
Meglátjuk később ma is egy lépéssel tovább
és akkor még egy kicsit lusta.
És ez nem ajánlott az általános, de akkor még csak lusta
és tedd egy változó világban, hogy úgy mondjam, nem egy függvényen belül, nem pedig belülről egy hurok,
de a fájl maga kívül az összes funkciót, amit írt, mint én itt a 15. sor.
Ezt általában elítélik, azonban, hogy ez egy megoldás időnként más problémákra,
mivel mi végül látni.
Tehát most elmegyünk, mint ez, de lássuk, tudjuk átírni ezt
Csak kezdeni kifejező magunkat egy kicsit másképp.
Ez a program, csak hogy világos legyen, nem positive1.
Hadd menjek előre, itt és a terminál ablakban győződjön positive1, Enter.
Fordít rendben. Megyek futni positive1, nyomd meg az Entert.
Követelem, hogy adjon nekem egy pozitív egész szám. Azt mondom -1. Ez nem működik.
0, 99. Ez úgy tűnik, hogy működik.
Lehet, hogy nem a legszigorúbb vizsgálatot, de legalább ez egy jó józanság ellenőrzést
hogy mi vagyunk a helyes úton halad.
>> És most hadd menjek előre, és nyissa ki 2-es verziója e,
és mi a különbség már?
Hajtja végre ugyanazt a dolgot, de mi ugrott ki, mint egyértelműen különbözik ebben az időben?
Ez bool zöld. Ez a zöld színnel, a kulcsszó nevei bool, ami egy adattípust.
Ez nem jön beépített valamennyi változatának C.
Be kell, hogy egy speciális könyvtár.
A mi esetünkben azt tartalmazza a CS50 könyvtárban, hogy mi férhetnek hozzá bool.
De a 18 vezetéken, akkor úgy tűnik, hogy egy logikai érték van az úgynevezett hálás.
Tudtam volna nevezte ezt semmit, de én nevezte hálás
csak azért, hogy a fajta közvetíteni néhány szemantikai jelentését.
Így kezdetben on line 18 vagyok nyilvánvalóan nem hálás
mert a Logikai érték hálás inicializálódik false sorban 18.
És akkor úgy tűnik, hogy mit tettem itt sorok 21-től 23
A Már csak ilyen újraírt én logika.
Tehát nem funkcionálisan eltérő, de a 22 vezetéken most ellenőrizze, hogy a int a felhasználó által biztosított
nagyobb, mint 0, akkor egyszerűen módosítsa az értéket a hálás igaz.
És miért ne tenném? Mivel a sorban 25, látszólag megyek, hogy ellenőrizze a feltételt.
Ehhez hurok miközben hálás hamis.
Szóval javasolta ezt alternatívájaként 1-es verzió
mert ez legalább egy kicsit intuitív talán ez egy kicsit földelt angolul.
Szóval tegye a következőket, miközben te nem hálás, vagy pedig hálás hamis.
És ezúttal is úgy tűnik, nem érdekel, emlékezni, amit a felhasználó beírt
mert a nyilatkozat nincs változó n, így valójában, egy kis fehér hazugság van.
>> Funkcionálisan a program egy kicsit más, ha eljutunk a végére
mert én nem emlékszem, mi n.
De azt akartam bizonyítani, itt is, hogy bár láttuk getInt
és getString használ a jobb oldali egyenlőségjel eddig
annak érdekében, hogy emlékszünk az érték, technikailag, ez nem feltétlenül szükséges.
Ha bármilyen okból, csak nem érdekel, hogy mentse az érték,
csak azt, hogy ellenőrizze az értéket, észre, hogy egyszerűen írni ezt getInt,
nyílt paren, közeli paren.
Ez a funkció megy vissza értéket, ahogy már mondtam.
Ez lesz, hogy ismét egy int.
És így, ha úgy gondolja, szellemileg ezen történik,
amikor azt írja, 99, getInt visszaadja a szám 99,
és így fogalmilag, ez mintha a kód valójában ezt.
Tehát, ha 99 valóban nagyobb, mint 0, akkor hálás lesz igaz,
majd 25 vezetéken rájön ó, készen vagyunk, mert én vagyok most hálás,
és a 26 vezetéken, egyszerűen azt mondja: "Thanks for the pozitív egész!"
bármi is történt, hogy legyen.
Most csináljuk enyhe szintaktikai cukor van, hogy úgy mondjam.
Lássuk, ha tudjuk megtisztítani ebben a sorban a 25. A harmadik és egyben utolsó variáns positive3.
>> Figyeljük meg az egyetlen különbség az, hogy milyen kódsort? >> [Hallgató] 25. >> [Malan] Igen, 25.
És most már nem is láttam ezt a trükköt csak még, de nem látja a felkiáltójel hétfőn,
ami azt jelzi, mi? >> [Hallgató] Nem. >> Nem vagy tagadása.
Tehát hogy egy logikai érték, és fordítsa az értékét.
Igaz lesz hamis, hamis lesz igaz.
Szóval, azt javaslom, még egy kicsit intuitív módon, az írás a kód
mert még mindig inicializálni hálás hamis, még mindig végezze el az alábbi,
Én meg hálás igaz, ha eljön az ideje,
de most már tényleg csak lefordítani ezt a kódot szóban balról jobbra,
while (! hálás), mert a durranó vagy felkiáltójel jelöli fogalma nem
így amíg nem hálás.
Tehát újra, még nem vezetett be új fogalmakat per se.
Beszéltünk Logikai vissza, amikor mi játszottunk Scratch,
de észre most már csak kezdje el írni a kódot a számos különböző módon.
Így különösen a pset1 ha valami küzd, hogy kitaláljuk, az utat, hogy írjon néhány program,
esély te vagy a szerencse, mert nem lehet tetszőleges számú megoldás
hogy történhet rajta.
Például, ez mindössze 3 még a legegyszerűbb program. Rendben van.
És most felidézni hétfőn elindultunk ezzel tudomásul visszatérési értékeket.
Így a legelső alkalom, hogy írt egy programot, amely nem csak azt fő;
is megvan a saját egyedi funkció, hogy én írtam ide.
Így sor 31 keresztül 34 I megadtam egy kocka funkciót.
Ez nem bonyolult. Ez csak egy * a * a jelen ügyben.
De mi a fontos benne, hogy elviszem input formájában
és én vissza kimeneten a formájában, a * a * a.
Szóval most megvan a képessége, ugyanúgy, mint régen a prinf egyedül,
hívni ezt a funkciót hívja a kocka funkciót.
>> És a kocka függvény némi bemenet, és a kocka függvény valamilyen kimenetet.
Ezzel szemben printf csináltál valamit.
Ez nem adott vissza semmit, hogy mi törődött, bár mint egy félre ez nem ad vissza értéket;
csak általában figyelmen kívül hagyja.
Printf csináltam valamit. Ez volt a mellékhatása nyomtatás a képernyőn.
Ezzel szemben itt van a kocka funkció, amely tulajdonképpen visszatér valamit.
Így azok ismerik ezt, ez egy meglehetősen egyszerű ötlet.
De azok számára, kevésbé ismerik ezt az ötletet az elhaladó be-és kimenetek, hogy újra,
próbáljuk csak valami szuper egyszerű.
Van valaki kényelmes jön a színpadra röviden?
Van, hogy kényelmes a kamera akkor is. Igen? Oké.
Mi a neve? >> [Hallgató] Ken. >> Ken. Rendben van. Ken, gyere fel.
Ken lesz függvénye a fajta itt.
Menjünk előre, és ezt. Menjünk egy kicsit díszes.
Örülök, hogy megismerhetem. Üdvözöljük a középpontban. Rendben van.
Nézzük meg ezt a gombot nyomja meg itt. Rendben van.
Tehát itt van egy modern palatábla,
és mi vagyok, az a fő funkciója, például
és én nem egy iPad a kezemben.
>> Nem igazán emlékszem, hogyan kell - Nos, nem tudok mondani.
Nem igazán jó kézírás,
így tehát azt akarom, hogy nyomtatni valamit a képernyőn nekem.
Én volt a fő program, és megyek, hogy mondod ezt
írásban, hogy az én csirke semmiből, majd tompított neked egy bemenet.
Szóval buta bár ez a gyakorlat, a fogalom a funkciók és a hívás funkció
és a visszatérő függvény tényleg csapódik le, hogy ezt.
I am Main, az imént írt printf, idézet-unquote valamit a képernyőn,
Én fut a program, és amint lesz printf nevezik,
vesz egy argumentummal vagy egy paraméter néha dupla idézőjelek közé.
Itt van ez az érvelés. Én beengedné Ken.
Ő egy fekete doboz írásbeli néhány néhány évvel ezelőtt
hogy úgy tűnik, csak tudja, hogyan kell nyomtatni a dolgokat a képernyőn.
Szóval végre.
Ez nem rossz. Nagyon jó.
Tehát most Ken történik végrehajtó. Vajon kell, hogy adja nekem valamit vissza?
Nem láttunk eddig.
Ismét printf jelent valójában vissza a szám, de fogunk figyelmen kívül hagyni, hogy a most
mert sosem használta. Szóval ez azt Ken.
És most fő veszi át az irányítást a programot újra
mert ez a kódsor, printf, kész végrehajtó.
És megyünk mi módon végrehajtó bármely más vonalak vannak.
Tehát most próbáljunk egy kicsit más példát.
Ezúttal itt nézzük először törölje a képernyőt, és ez alkalommal mi intézzük a kocka funkció
de ez alkalommal, azt várom a kimeneti érték.
>> Akkor menjünk előre, és ezt.
Most van egy sor kódot, hogy azt mondja x jelentkeznek kocka x.
A kódsor, visszahívás, így néz ki: x = cube (x);
Hogy fog ez működni? Menjünk előre, és kapsz egy fehér képernyő újra.
Fogok írni, most az x értékét,
ami ebben a pillanatban történik, hogy, mondjuk, 2, hogy ez egyszerű.
Írtam le egy darab papírra értéke 2, ami az én értéke x.
Adom, hogy Ken. >> És én csak annyit írj a válasz? >> Igen, nézzük csak írni a választ.
Oké. És most vissza kell térnie nekem valamit. Tökéletes. Szép Segue.
Tehát most átadja vissza az értéke 8 ebben az esetben, és mit tegyek vele?
Valójában - lássuk, hogy ezt a jogot. Mit fogok csinálni vele?
Most fogom venni ezt az értéket, és valójában tárolja ugyanezen bitek a memóriában.
De észre, én vagyok a fajta küzd itt.
Én egy kicsit zavaros, mert ha tudom valójában írni az x értékét,
mert amit épp most tett fizikailag kéz Ken egy darab papírt, hogy már a 2 értéket,
amely x, és valóban, pontosan ez az, ami történt.
Így kiderül, hogy mikor hívja a funkciót és adja át egy érv
mint a hello, világ vagy át egy érv, mint a 2,
általában, te halad egy példányát ezt az érvelést.
És ahogy írtam le a 2-es szám van, és átnyújtotta Ken,
azt kell jelentenie, hogy még mindig van egy példánya a 2 értéket valahol
mert valóban, most, hogy kaptam vissza az érték 8, azt kell, hogy menjen vissza a RAM-ban
és ténylegesen írd le 8, ahol egyszer volt a 2-es szám.
Szóval vizuálisan, emlékezz erre fogalma halad, szó szerint, egy példányát az értéket.
>> Ken teszi a dolgát, a kezek vissza valamit - ebben az esetben az érték, mint a 8 -
majd tennem kell valamit, ez az érték, ha szeretném megtartani körül.
Szóval mindez vissza fog térni, hogy túlságosan is ismerős előtt hosszú.
Nagyon köszönöm, hogy erre a demo itt, Ken. [Taps]
Nagyon jól sikerült.
Lássuk, hogyan lehet, hogy végül kapcsolódik néhány függvény hív, hogy mi már itt.
Hadd menjek előre, és visz minket vissza a kocka példának.
Figyeljük meg, hogy ha azt akarjuk, hogy valóban elkezdené szedni ezt a további
megyünk kell szem előtt azt a tényt, hogy az x szám, ami a kiszabott itt
más, mint amit ez ténylegesen átadott a funkciót.
Szóval ez megint át a példányt fog válni meglehetősen valaminek megfelelő egy pillanat.
Vessünk egy pillantást a valamit, ami nem egészen helyes működése még.
Én megyek előre, és nyissa 1/3 buggy például, amely hibás, a természet,
, és ez az úgynevezett buggy3 és végrehajtja a csere funkciót.
Itt van egy fő funkciója, amely x és y önkényesen inicializálódik az 1. és 2., illetve.
Jól jönne getInt, de csak kell egy egyszerű gyakorlat,
így nehéz kódolt az 1 és 2.
Sorokban 21. és 22., mi látszólag kinyomtatja x és y, 1. soronként.
Aztán a 23, azt állítják, én csere ezeket az értékeket, pont, pont, pont.
Úgy tűnik, hívja a funkciót a 24 vezetéken úgynevezett swap-vevő 2 érveket.
Ez teljesen legális a funkciókat, hogy 2 érveket. Láttuk printf csináld már.
>> Szóval csere látszólag úgy x és y, és ahogy a neve is sugallja,
Remélem, hogy ez fog cserélni ezeket a 2 értékeket.
Így aztán azt állítják on line 25 "Megcserélvelehetőség!" és én újranyomtatása x és y
feltételezve, hogy ők már valóban cserélték.
De ha tényleg futtatni ezt a programot - hadd nyit egy terminál ablakot,
hadd buggy3 - ahogy a neve is sugallja, ez nem lesz jó vége
mert amikor Enter, észreveheti, hogy x 1, y 2,
és mégis, az a program végén, még mindig, valójában, az ugyanaz.
Tehát alapuló demonstrációs most Ken, mi folyik itt valójában?
Nézzük belevetik magukat a csere funkciót. Ez szuper rövid. Ez csak néhány sornyi kódot hosszú.
De mi az alapvető probléma alapuló egyszerű történetet mondta ki itt Ken?
Miért csere törve?
[Hallgató] Te tárolására egy másolatot, nem a változó.
Pontosan. Mi tárolni egy példányt, nem a változó magát.
Más szóval, a csere nyilván úgy 2 érvek, int,
és ez önkényesen hívják a és b,
és fel itt, amit átadott x és y, amelyek rendre 1 és 2,
de én nem szó szerint halad x, én nem szó szerint halad y,
Én halad egy példányát x és y egy példányát.
Ez majdnem olyan, mintha te illesztenie swap-
az értékeket, amelyeket szeretné, hogy valóban manipulálni.
Tehát, ha ez a helyzet, amikor a program kezdete végrehajtó 35 egyenes, majd 36,
amikor megkapom a vonal 37, ezen a ponton a történet, mi az értéke?
Ezen a ponton a történet, 37. sor, mi az értéke ezen a ponton? >> [Hallgató] 1.
[Malan] Meg kell csak 1, van, mert x-ben született az első érv,
és ez a funkció csak önkényesen hívja az első argumentum a.
Hasonlóképpen Y A második érv, és ez csak önkényesen hívja a második érvet b.
>> Ez a kettősség tulajdonképpen meglehetősen egyszerűen magyarázta. Gondolj bele.
Egyikünk sem találkozott az a személy, aki ezt írta printf,
így biztosan, ő nem tudja, mi a változók 30 évvel később lesznek hívják.
Tehát ott kell, hogy legyen a különbséget, amit úgy hívnak változókat függvények írsz
és az, amit úgy hívnak változókat függvények hívsz vagy használ.
Más szóval, írtam változókat az x és y,
de ha valaki más írt a csere funkciót, ő biztosan nem tudja
mi a változók fognak hívják,
így észre, hogy ez miért van ez a kettősség a neveket.
Technikailag tehettem ezt véletlen,
de akkor is telt el, mint példányban.
Ez csak egy tiszta véletlen esztétikailag ha ez a személy, aki írta csere
használta ugyanazt a nevet.
Tehát ezen a ponton a történet, 37. sor, a 1, b 2, és most folytassa cserélni őket.
Először is, hadd ténylegesen ezt sokkal egyszerűbben.
Én nem tudom, mi a 3 sornyi kódot csinál.
Hadd tegye a következőket: b = a, a = b; tenni.
Miért van ez törött, logikusan?
Ez a fajta az intuitív dolog, igaz?
Így egy nek az b és b válik,
de a probléma az, hogy amint a 37. sor végrehajtja, mi az értéke a és b?
Ugyanaz, 1, azért van, mert ütközés, hogy úgy mondjam, már megváltoztatta b, hogy megegyezzen a.
Tehát, ha 37. sor teljesítette, ez remek, most már 2 példányban az 1-es szám
belül ezt a funkciót, így aztán amikor azt mondod, sorban 38 a = b,
te milyen csavaros, mert csak most rendel 1-1.
Már a fajta elvesztette értéket törődött.
Tehát az eredeti változata, észre amit tettem.
Én inkább volt egy harmadik sor kódot úgy nézett ki, mint ez.
Kijelentem, ideiglenes változót.
>> Tmp egy nagyon gyakori név egy átmeneti változó, és ez egy int
mert, hogy megfeleljen, amit szeretnénk, hogy egy másolatot.
Tárolom másolata belsejében tmp, tehát egyszer sor 37 hajtott végre,
az értéke is - gyors józanság check - 1, értéke b 2,
értéke és a tmp is 1.
Szóval most végre sor 38.
Miután a 38 végrehajt egy veszi értékének b. És B 2, így a most 2.
Tehát ezen a pontján a történet, a értéke 2, b értéke 2, és a TMP jelentése 1,
így most logikusan, tudjuk csak puff tmp értéke a b és készen vagyunk.
Így már megoldotta ezt a problémát.
Sajnos, amikor fut a program ebben a formában, akkor valójában nem cserélni semmilyen értékeket.
De egyértelmű, miért?
Én rögzíteni a logikai probléma, csak egy perccel ezelőtt,
de a lényeg, ha futtatni ezt a programot, az x és y változatlan marad
végére a program végrehajtását.
[Hallhatatlan diák megjegyzése] >> Mi már nem tért vissza semmit annak érdekében, hogy ez igaz.
De kiderült, hogy van egy kis probléma itt, mert eddig,
az egyetlen dolog, amit sikerült visszatérni az egy dolog, és ez a korlátozás a C.
Egyszerre csak vissza igazán egy értéket, mely esetben én vagyok a fajta itt ragadtunk
mert tudtam vissza az új érték az x, illetve tudtam vissza az új érték az y,
de azt akarom, mindkettő vissza.
Tehát visszatérve nem az egyszerű megoldás van.
De a probléma alapvetően az oka? Mit értünk tulajdonképpen elcserélték?
[Diák] a és b. >> A és b.
De a és b másolatai x és y, ami azt jelenti, hogy csak tette mind ennek a munkának,
mi csak töltött 3 perc alatt, beszél a swap funkciót, és mind a 3 ezeket a változókat,
és ez nagyszerű, tökéletesen helyes elszigetelten,
de a és b hatáskörét egyetlen nyelven ezeket a sorokat itt.
>> Szóval, mint egy for ciklus, ha kijelentem integer i belül a hurok,
hasonlóképpen, ha nyilvánításáról és b belsejében olyan funkció, amit írt,
ők csak akkor érvényes belül ezt a funkciót, ami azt jelenti, amint csere történik végrehajtó
és mi megy a 24 vezetéken a 25 vezetéken, X és Y jelentése nem változott.
Te csak elpazarolt egy csomó időt cseréje példányban változók.
Így kiderül, hogy a megoldást, ez valójában nem nyilvánvaló.
Ez nem teljesen elegendő visszatérni értékeket, mert csak akkor tudjuk vissza 1 érték,
és én tényleg szeretnék cserélni mind x és y ugyanabban az időben,
úgyhogy kell majd még visszatérünk erre.
De most észre, hogy a kérdés alapvetően abból a tényből ered, hogy az a és b másolatok
és ezek a saját körét.
Próbáljuk meg megoldani ezt valamilyen módon.
Hadd ténylegesen lépjünk vissza, és nyissa fel, mondjuk, a negyedik változatot e, buggy4.
Mi a helyzet ezzel?
Ez egy hasonló, de egyszerűbb probléma, hogy nézd meg, mielőtt veszünk egy stab a megoldására.
Ez a program az úgynevezett növedék, és ez nyilvánvalóan inicializálja az x értéke 1-et a 18 vezetéken.
Aztán azt állítják, x 1, Aztán azt állítják: "Inkrementálás ..."
Én majd hívja növekmény, de aztán a vonalak 22 és 23, azt állítják, ez már eggyel,
Azt állítják, x ma bármi is az - 2, feltehetőleg - de ez a program hibás.
Mi a baj?
Igen. >> [Hallhatatlan tanulói válasz] >> Pontosan.
Tehát x nyilvánították, nyilvánvalóan on line 18.
Ez a belső fontosabb a kapcsos zárójeleket.
Tehát az egyszerű válasz az, hogy míg x létezik itt,
nem létezik a 32 vezetéken, így ez a program valójában nem is összeállít.
A fordító, amikor megpróbálom összeállításakor ezt a kódot fog kiabálni velem
néhány be nem jelentett azonosítója vagy valami ebben az értelemben. Tény, hogy próbáljuk meg.
Ez teszi buggy4. Ott van.
A be nem jelentett azonosító "x" sorban 32.
És valóban, legyünk kifejezettebben ma itt, hogy ez hasznos
A nyitvatartási és otthon.
>> Figyelje meg, hogy ez egy kicsit rejtélyesen írva.
De az a tény, hogy a csengés már kiabált nekünk, mondván buggy4.c: 32:5, valóban hasznos.
Ez azt jelenti, hogy a hiba a vonalon a 32 karakter 5-helyzetben.
Így 1, 2, 3, 4, 5. Ez, ugyanis, ahol a probléma.
És azt is, is tartsa szem előtt, a munkaidőn és otthoni Szerencsés vagyok itt.
Van egy hibát. Ez lesz viszonylag könnyen kijavítani.
De ha egy egész képernyő teljes elsöprő hibaüzenetek,
again észre, hogy a legalsó lehetne csak tüneti a legfelső 1.
Tehát mindig üldözőbe le a hibákat fentről lefelé
mert lehet, hogy csak egy lánc hatása
mely arra utal, van sokkal több problémát, mint amennyit ténylegesen.
Szóval, hogyan tudnánk kijavítani ezt, ha a cél az, hogy növelni x? >> [Hallgató] Make x globális.
Oké, tudjuk, hogy x globális.
Vegyük a parancsikont, hogy figyelmeztetett korábban, de a fene, akkor csak kell egy gyors fix,
így mondjuk int x itt. Ez teszi x globális.
Tehát most fő fér hozzá, és növekmény férhet hozzá,
és ezért hadd menjen előre, és fordítsd ezt most.
Győződjön buggy4, Enter. Úgy tűnik összeállításához most.
Fussunk buggy4. És úgy tűnik, hogy valóban működik.
Ez egy ilyen dolog, hogy ez tedd, amit mondok, és nem, mint én,
ahogy már most kész van, mert általában
a programokat fog kapni sokkal érdekesebb, és sokkal hosszabb, mint ez,
és ha a megoldás az élet problémák csak fel az összes változót, a tetején a fájl,
nagyon gyorsan nem kap programok horrifically nehéz kezelni.
Egyre nehezebb kitalálni új változó nevét,
egyre nehezebb megérteni, hogy mit változó mit csinál,
és így általában, ez nem egy jó megoldás.
Szóval ezt jobban.
Nem akarjuk, hogy egy globális változót itt.
>> Én szeretnék növelni x, úgyhogy tudtam nyilvánvalóan -
a végén a nap, ez a fajta egy buta történet, mert mi csak ezt -
de ha nem tudtam arról, hogy ez az üzemeltető vagy én nem engedélyezték, hogy változtassa meg a fő önmagában
hogy mást tudnék végre Ken ide, ezúttal nem a kocka, hanem növelni?
Hogyan módosítható ez a dolog itt? Igen.
[Hallgató] Pass x-ben, majd vissza [hallhatatlan] >> Oké, jó.
Akkor miért nem azt át x-ben, majd pedig vissza,
miért nem én csak vissza x + 1.
Még egy pár dolgot meg kell változtatni itt. Én vagyok a jó úton halad.
Mit kell tennem, hogy csípés? Valaki más. Igen.
[Hallhatatlan hallgatói válasz]
Meg kell változtatni a visszatérési típus increment mert nem érvényteleníti.
Void úton semmit sem vissza, de nyilvánvalóan most is az,
így ezt meg kell változtatnia, hogy - >> [hallgató] int.
int hogy konzisztens legyen az bármilyen Én tényleg visszatér.
Most valami mást még hibás itt van. Igen.
[Hallhatatlan diák válasza] >> [Malan] Szóval kell növelni x?
[Hallhatatlan diák válasza] >> [Malan] Ah, ezért kell átadni x.
Szóval kell, hogy ezt itt. >> [Hallhatatlan hallgató comment]
[Malan] Szóval a prototípus, meg kell változtatni ezt itt.
Tehát ez kell válnia int, ennek vált -
hmm, én valójában egy bug idelent. Nézzük erősít ez egy első.
Mi ez valójában? Úgy van, hogy egy int valamit.
Lehet, x, de őszintén szólva, ha elkezdesz hívja az összes változó x,
ez lesz, hogy egyre kevésbé világos, hogy melyik melyik.
>> Szóval csak önkényesen válasszon másik elnevezési az én segítő funkciók,
funkciók írok. Hívjuk, hogy egy, vagy tudnánk nevezni -
Hívjuk meg a számot még világosabbá tegye.
Így aztán vissza kell térni számától függetlenül plusz 1,
és most meg kell változtatnunk 1 másik dolog ide, és egy másik dolog itt.
Mit kell változtatni jarat: 21 az első? >> [Hallhatatlan tanulói válasz]
[Malan] El kell rendelni, hogy x. Nem tudok csak hívja növedék (x).
Meg kell emlékezni a választ módosításával az x értéke a bal oldali.
És bár x most a bal és a jobb, ez teljesen rendben
mert a jobb oldalon lesz végre először, majd lehuppant lesz a bal oldali dolog -
x ebben az esetben.
És végül, ez egy egyszerű fix most.
Ez csak a meccsek, mi lent, int szám.
Szóval egy csomó változás egy igazán hülye függvény
de reprezentatív dolog, hogy mi inkább szeretnénk csinálni.
Tehát, hogy buggy4. Már elcsesztem valahol.
Ó, Istenem. Öt hibák egy 6-soros program.
Szóval, mi a baj a 18. sor, karakter 5?
Szóval ezt bejelenteni, int.
Lássuk. Van egy csomó egyéb hibákat.
Ó, Istenem - 19, 18, 21 -, de újra, nézzük csak törölje a képernyőt, Control L itt,
és futtassa újra csenget.
Tehát 5 probléma valójában csak, hogy 1.
Tehát most fussunk buggy4, Enter. Hú, x lett eggyel helyesen.
Rendben van. Van még kérdése, hogy hogyan növekmény számok? Igen.
[Hallhatatlan hallgatói kérdésre] >> Jó kérdés.
Hogy van az, hogy én is csak megváltoztatni x számra, és a program azonnal tudni?
>> Ismét, gondolni rá, mint e absztrakció.
Szóval, ha én vagyok a fő-és Ken növedék, őszintén szólva, nem érdekel, mit Ken hívja a iPad.
Nem érdekel, amit ő semmit, hogy köze van az ő végrehajtásával ezt a funkciót.
Ez egy végrehajtási részlet, hogy én, a fő, nem kell törődni.
És így egyszerűen csak a változó következetesen belsejében a funkció - szám itt és szám itt -
már kész is van, amíg én újrafordítani.
Ez a fajta, mint ha belegondolsz sokan közülünk, azok, a vezető engedélyek
akik hajtott, vagy ha már akár hajtott egy autó,
legtöbbünknek fogalma sincs, hogyan működik egy autó a motorháztető alatt.
És szó szerint, ha megnyitja a motorháztető, a legtöbben - magamat is beleértve -
nem fognak igazán tudom, mit keresünk,
olyan, mint lehet, hogy úgy érzi, a dolgok, mint ez most.
De nem igazán érdekel, hogy hogyan kell az autó működik,
nem kell, hogy érdekel, mit az összes botok és dugattyúk és kábelek belsejében az autó
ténylegesen csinál.
Szóval, valami hasonlót, amit úgy hívnak a dugattyú nem számít, itt ebben az esetben. Same ötlet.
Igen. >> [Hallhatatlan hallgató a kérdéshez]
Ha több felhasználását a változó xa pillanat ezelőtt,
te, a programozó, kellene megváltoztatni őket mindenhol.
Vagy tudnál csinálni szó Fájl menü, majd a Keresés, cserélje ki - valami ilyesmi -
de akkor kell majd, hogy ezeket a változtatásokat magad.
Meg kell lennie. >> [Hallgató] Ha több változó [hallható]
Egy adott sorrendben, mint itt, ha ez int egy másik számot? >> [Hallgató] Correct.
[Malan] Igen. Rendelési számít, ha a funkció meghívása.
>> Tehát, ha én hívó növekmény itt valami vesszővel valamit,
van egy közvetlen leképezés.
Az első változó, bármi is hívják, készül egy példányát az első érv ide.
Bocsánat. Ez nem lehet a zárójelet.
A második érv egy vonalban áll a második. Így annak érdekében, igen, számít. Rendben van.
Bocsánat. Vettem a hosszú utat, hogy ott. Egyéb kérdés? Rendben van.
Tehát lássuk, ha nem tudjuk festeni a képet, hogy mi folyik itt valójában
a motorháztető alatt, hogy úgy mondjam.
Ez egy téglalap, amely képviseli a számítógép memóriájában.
Akkor is, ha fogalma sincs, hogyan működik a memória, vagy hogyan RAM működik,
legalábbis feltételezzük, hogy van csokor is ezekben a napokban.
Van megabájt, akkor megvan gigabyte azt,
és tudjuk, hogy egy hét 0 byte éppen mi? >> [Hallgató] 8 bit.
8 bit, ugye? Szóval 8 nullákat és 1.
Tehát ha a számítógép rendelkezik koncert a RAM, 2 giga RAM ezekben a napokban,
Van egy milliárd vagy 2 milliárd bájt memóriát vagy durván 8000000000 vagy 16 milliárd bit
belül a számítógépet.
Ellentétben a kis Wooly Willy például, ez nem mágneses részecskéket általában többé.
Egyre több - a laptopok legalábbis - ez a szilárdtest-meghajtók, SSD,
hogy csak nincs mozgó alkatrész. Ez mind elektronikus. Ez az összes villamosenergia-alapú.
Tehát úgy gondolja, ennek a téglalapnak, mint csak képviselő 1 vagy 2 gigabájt memória van.
>> Szóval ez egy darab memória.
A világ számítógép-tudomány egyfajta megosztjuk off
darabokat memória különböző dolgokat.
Például, ha ez a számítógép RAM, amint azt a téglalap van,
kiderül, hogy a konvenció, a tetején a RAM, hogy úgy mondjam,
általában az úgynevezett szöveges szegmensben.
Ezek a 0s és 1s, hogy már össze.
Tehát amikor mi már megnézték a motorháztető alatt milyen a.out van,
Mindezen 0s és 1s, amikor fut a program,
e 0s és 1s töltik a merevlemezről valami úgynevezett RAM,
és a RAM ők helyezze a tetején.
Közben, ha van más dolog: initialize adatok inicializálása adatok.
A 2 rend memória, nézze meg a globális változók, melyeket a nem gyakran használt
de néha, ha nem, akkor a végén ott is.
Aztán ott van egy másik dolog: környezeti változók, amelyet nem töltenek sok időt,
de majd a 2 fontos dolog, hogy vissza fog térni az egész félévben,
stack és a heap.
Tehát a legtöbb számítógép memóriájában van fenntartva, ha fut a program
valamit úgynevezett stack és valami úgynevezett kupac.
Nem fogunk beszélni a halom ma, de fogunk beszélni a köteget.
A verem hivatott megidézni a vizuális az étkező étkezés tálcák Mather House
vagy bárhol megtörténhet, hogy ha az ebédlőben staff tisztítsa meg őket minden nap,
ők verem őket fel emeleten fel,
és hasonlóan, a memóriában van, ez az ötlet hozatala valamit a verem,
üzembe valamit a stack, amivel valamit a verem.
És mit is jelent ez?
>> Nézzük nagyítani kell a csak az alsó fele ezt a képet, a számítógép RAM,
tegyen javaslatot a következő.
Kiderült, hogy amikor fut a program, mint a a.out vagy hello -
függetlenül a program, hogy írtál -
Ismét azok 0s és 1s töltik a merevlemezről, ami a hosszú távú tárolás,
ott marad akkor is, ha húzza ki a dugót, betöltött RAM.
RAM gyorsabb, mint a merevlemez - ez kisebb, mint a merevlemezek -
de ha programokat élnek, miközben futsz őket.
Szóval duplán kattintva a program a Mac vagy PC, ez betöltődik a merevlemezről a RAM-ba.
Amint meg van töltve a RAM-ba, a 0s és 1s tovább az út tetején,
az úgynevezett text részes, de aztán, amint a program valóban elindul,
a fő funkciója hívják, és fontosabb, mint láttuk, gyakran lokális változók,
és azt ints és vonósokra, valamint karakter és hasonlók.
Tehát, ha a program, hogy már megírt, vagy a program, hogy már dupla kattintással
használt bizonyos változók belsejében main,
a végén alján a verem a memória, hogy úgy mondjam.
Pontosabban, mit jelent ez valójában?
Ez csak azt jelenti, hogy ha megyünk száma a byte RAM a számítógép,
észre, hogy ez lehet bájt szám 0, akkor ez lehet bájt szám 1, 2, 3, 4, 5, 6,
egészen 2 milliárd lenne egészen ott a tetején.
Más szóval, amikor arról beszélünk, RAM memória szempontjából bájt,
ez csak azt jelenti, hogy valaki úgy döntött, hogy mit kell számozni minden egyes ilyen darabokat memória.
Tehát, ha szüksége van 32 bites egy int vagy meg kell 8 bit egy karakter,
hol a végén a memória?
>> Fogalmi, csak a végén alján ez a dolog az úgynevezett stack.
De mi az érdekes most, amikor fő meghív egy függvényt -
Tegyük fel a nevezett funkció ize, csak egy tetszőleges nevet -
mi történik, legfontosabb alján van ennek verem a memória;
ize most kerül a tetején a fő memóriában.
Tehát a helyi változók foo még a végén valami fogalmilag fenti e a fő.
Ha foo felhívja másik funkció nevű bárban, azokat a változókat végül itt.
Ha bar felhívja valami mást, itt, itt, itt.
Szóval, mi érdekes fut egy program, hogy ha szükséges funkciók
és mivel ezeket a funkciókat szükséges funkciókat és ezeket a funkciókat szükséges funkciókat,
építesz ezt stack funkciók a memóriában.
És csak egyszer egy függvény mit kezdeni, hogy a memória vissza.
Tehát az egyik legegyszerűbb módja, hogy elfogy a memória a számítógépi program
hogy írjon funkciók soha nem térhet vissza.
Így például, most bizonyítani annyira egy szándékosan hibás program.
Hadd menjek előre, és nem # include ,
int main (void),
és én fogom csinálni, miközben (2> 1), ami valószínűleg soha nem fog megváltozni minket,
és hadd menjen előre, és most nem printf.
Igazából, ez lesz kevésbé vizuálisan érdekes. Csináljuk ezt.
Az int i = 0; i> 0 - tegyük ezt a hibát - i + +.
És ne printf itt. Nézzük gyakorlatban mit prédikált.
Vessünk egy módszer van, üres kórus, és mi mondjuk int i,
majd fogok mondani printf - nem, tegyük ezt sokkal érdekesebb.
Nézzük valójában nem nyomtat semmit. Nézzük csak ezt: kórus (i).
Rendben van. Szóval ez hibás, mert miért?
Én találtam ki, ahogy megy, mert a program valójában nem csinál semmit érdekes.
>> De nem ez a cél.
A cél az, hogy írjon egy programot, amelynek fő funkciója mit csinál, úgy tűnik?
Hívjon magát. És valóban, nem kell a hurok.
Nézzük még egyszerűsítése csak azért, hogy ne veszítsük szem elől, hogy valóban az alapvető hiba.
Main felhívja kórus énekelni néhány kórus,
aztán csináltam valami hülyeséget, és volt kórus hívás kórus
azért, mert feltételezhető, hogy valaki fogja végrehajtása talán,
és most ez nem fog fordítani még. Azt kell, hogy mit csináljon?
Szükségem van a prototípus, emlékszem.
Szóval kell, hogy ide void kórus (int i);
Tehát most ha elmegyek ide - valójában, hadd használja a nagyobb ablakban.
Menjünk előre, és hogy a kórus.
A be nem jelentett azonosító i.
Ó, ez hülyeség volt. Nem kell az érvet. Nézzük csak ezt.
Bárcsak kezdte így. Nem lett volna sokkal könnyebb programot írni.
Tessék. Most menjünk át a terminál ablak, futtassa újra csenget, és most itt vagyunk.
Ez nagyon gyors.
Mi valójában csak történt, igaz?
Nos, most fogok hozzá a nyomtatási sort, így látjuk.
Hadd mondjam printf ("itt vagyok") - nem változó. Majd hagyja így.
Hadd futtassa újra tenni. Hadd hajtsa végre ismét a kórus.
És ... gyerünk. Folytasd.
Mint félretéve, miért nem zuhant még?
A szegmentációs hiba történt szupergyors előtt.
[Hallhatatlan diák válasza] >> Pontosan. Szóval ez időt vesz igénybe a nyomtatás, ugye?
Ez csak úgy több munkát a számítógép részét.
És itt van: Segmentation fault.
>> Szóval észre, hogy milyen gyorsan programok futtatása.
Ha nem nyomtat semmit, szuper gyors.
De még mindig van ez a szegmens hiba, mert mi történik?
Ha úgy gondolja, arról, hogy a számítógép memóriája megállapított,
ez történetesen fő, de itt hívjuk csak ezt a kórus, és hívjuk ezt a kórus.
És most, ha én azon vagyok, esztétika van, ez csak fog mondani kórus, kórus, kórus,
kórus, kórus, kórus, kórus, hirdetés nauseum, és végül, mi fog történni?
Ha a nagy kép, szó, ez, ami most történik, fogalmilag?
A stack túllépése a kupac.
Vagy, ami még rosszabb, csak túllépését mindent, beleértve a szöveget szegmens,
amely a 0-ák és 1-esek, hogy képviselje a program.
Röviden, ez csak szuper, szuper rossz.
A program nőttek ki az ellenőrzés alól.
Te így több memóriát használ, mint amennyit tervezett
azért, mert az egy buta hiba ebben az esetben,
vagy ebben az esetben egy nagyon szándékosan végzett funkció nevezte magát.
Nos, ez még nem minden rossz.
Funkciók nevezik magukat valóban nagy ereje, ha használják azt.
Én nem használtam helyesen ide.
Szóval ez nem olyan rossz, de az a tény, hogy én valójában sosem hagyja abba hív magam
alapvető gyengesége itt a program.
Szóval, hová megyünk mindezt? Mi történik valójában?
Amikor hívom a növekmény mûködnek csinálunk e példák,
Nekem van egy érték, mint 1, hogy átadom be
Én át egy példányt a 1-es szám, így a következő történik.
Menjünk be a növekmény példa, ez a srác itt van.
Itt van, mi történik valójában.
Amikor hívom növekedésnél és átadom az x, piktogramokat ábrázoló, mi folyik itt ez.
>> Ha van az értéke 1 tárolják itt, és én tényleg hívni növedék,
amely most hívott kórus - az iPad dobott le engem ide.
Nevezzük ezt a növekményt, és nem tudjuk, hogy mi ez a következő funkció lesz.
Szóval, mi is történik itt van valahol a fő van egy darab memória
amely tárolja az 1-es szám.
Amikor hívom növedék, én egy másik darabja a memóriát,
de most már a másolatot az 1.
Amikor növeljük ezt az értéket, ez lesz 2,
de akkor mi történik, amint a növekedés visszatér?
Ez a memória csak gets adta vissza az operációs rendszert,
ami azt jelenti, az összes tettél semmi hasznos.
Az 1, amelyet eredetileg szereplő fő továbbra is ténylegesen ott van.
Szóval, hová megyünk ezzel?
Kiderül, hogy a memóriában van ez a back-to-back bájtok sorozata
hogy nem tud cucc, és kiderül, hogy már láttuk valami
amely magában foglalja üzembe dolgok háttal hátra hátra.
Mi egy string alapján hét 1 hét 2, és most?
Ez csak egy gyűjtemény a karakter.
Így kiderült, hogy ahogy akkor tegye számokat a memóriában,
Hasonlóan nem teszel karaktereket a memóriában.
És amint kezdjük üzembe karakterek a memóriában háttal a háttal,
kiderül, hogy a legegyszerűbb dolgok, mint a for ciklus vagy while ciklus,
tudunk ismételget balról jobbra az egy karakterlánc karaktereinek
és meg kell kezdeni masszírozó azokat különböző karakterek összesen -
Egy válhat b, b válhat c -
annak érdekében, hogy végül mi is egy angol mondat, hogy valóban van értelme
és megtérít minden egyes ilyen leveleket egyesével
a séta a számítógép memóriájában balról jobbra, hogy ténylegesen titkosítja.
Akkor nézzük az öt perces szünet van,
és amikor visszajön, akkor kezdjük ezt a folyamatot kódolási információ.
>> Rendben van.
Mielőtt belevetik magukat néhány crypto és ezek a dolgok néven tömbök,
hadd szünetet bármilyen kérdése, mert úgy érzem, hogy tényleg ilyen zavaros
néhány ilyen téma. Szóval erősít most, ha tudunk.
Mi csak beszélgettünk visszatérési értékeit, beszélgettünk érveket,
és megbeszéltük ezt a fogalmat, amit mi jön vissza az az elkövetkezendő hetek során,
megtekintését memória egy csomó ilyen halmozott tálcák, hogy úgy mondjam,
alulról akár úgy, hogy minden egyes tálcára, hogy lesz fektetni a stack
jelentése függvény, ami jelenleg hívják.
Van még kérdése?
Hadd tegyek fel egy kérdést itt.
Hadd egyszerűsíteni ezt vissza, hogy milyen volt, mielőtt néhány korábbi Q & A.
Az a tény, hogy a növekmény már nyitott zárójelet, int szám, zárt zárójel -
mit jelent int szám képvisel?
[Hallgató] Egy érv. >> Egy érv. Oké. De mi ez az érvelés?
[Hallhatatlan diák válasza] >> Mi ez? >> [Hallgató] Valami, amit át be
Oké, tehát valami, amit át be És általában, ez csak a bemenet.
Ha írtak funkcióhoz, és ez a funkció célja az életben
az, hogy nem valami egy kicsit más minden alkalommal, amikor használja,
akkor az egyetlen módja, hogy ez megtörténjen tényleg úgy tűnik, hogy biztosítsa számára input
annak érdekében, hogy meg tudja csinálni valami mást, hogy a bemeneti minden egyes alkalommal.
>> Szóval, meg kell adnia két dolog, ha egy függvény bemenet.
Meg kell adni a kívánt nevet adni, hogy a bemeneti
pusztán csak a mi kedvünkért, így hivatkoznak rá
a funkció, hogy te magad írunk, ahogy én tettem itt sorban 32.
De azt is meg kell határozni a típus, mert a C programozási nyelv
hogy csak megköveteli, hogy ha egy változó, meg kell mondanod a számítógép milyen adattípus van,
nagy részben úgy, hogy tudja, hogy hány bitet kell kiosztani, hogy a változó
mert lehet, hogy 6 - Sajnálom, nem lesz 6.
Ez lehet 16, akkor a 8, akkor is 32, akár 64,
de a számítógép tudnia kell.
Most, a int a bal oldali képviseli azt, amit ezzel szemben?
[Hallhatatlan diák válasza] >> Mi ez? >> [Hallgató] Type of funkció.
A típus A függvény és, még pontosabban a típusát termelését. Rendben.
Így mivel a dolog zárójelben jelentése a bemenet, ha vannak ilyenek,
a dolog, hogy a bal oldali képviseli kimenet.
És ebben az esetben a növekmény látszólag ad vissza int,
és így int a visszatérési típus ezt a funkciót.
Mit jelent az, hogy vissza?
Szó szerint, akkor használja a kulcsszó hazatérését és akkor, ha amit vissza
jobbra a kulcsszó egész szám,
akkor ez valóban megfelel amit ígért.
Te nem tehetett ilyet - hello, world - mert ez egy string.
>> Nyilvánvaló, hogy nem egy egész szám.
Tehát röviden, a teher valóban minket, a programozó, hogy egyedi
hogy amit mi vissza, és aztán tényleg megy a visszaküldésével.
A kontextus itt most az, hogy a számítógép memóriájában egy gigabyte, 2 gigabájt -
bármi - talán több, talán kevesebb,
de a számítógép látja azt, hogy különböző szakaszok.
Valami megy le oda, valami más megy fel ott,
különböző cucc megy a közepén, és ma már csak kezdeni mondja a történetet,
de majd jön vissza erre az idő múlásával.
Jelenleg az egyetlen darab memória tényleg érdekel a szöveg szegmens
mert csak képviseli a 0s és 1s hogy csenget a kimeneten.
Tehát, ha egy parancs futtatható a billentyűzetet, mint a.out
vagy kattintson duplán egy ikonra Mac OS vagy a Windows,
a program betöltődik a merevlemezről a RAM-ba
és ez lehuppant a tetején a számítógép RAM, hogy úgy mondjam.
Mindeközben, ahogy a program elindul és fontosabb lesz az úgynevezett
A program, amit írt, vagy a program a Microsoft vagy az Apple írta:
bármely helyi változók a végén ott az alján a számítógép memóriájában.
De ha felhívja fő egyéb funkció maga változók, illetve érvelés végül fölé.
És ha ezt a funkciót hívja valamit, a végén fölött, fölötte, fölötte.
>> És csak ha egy funkciót történik végrehajtó jelent a köteg tálcák, hogy úgy mondjam,
kezdenek lejjebb és lejjebb.
És ez az, amit akkor, dióhéjban, megmagyarázza, hogy miért, amikor telefonál kocka
vagy hívja növekmény, akkor halad egy példányát az értéket.
És hogy ez mit jelent piktogramokat ábrázoló, hogy te szó szerint írni a 1-es szám
egy másik részén memória, a változó, amely 1-2-ben az esetben, növekmény
vagy egy 8 esetén kocka és azután, hogy a memória dob el
amint a növekedés vagy a kocka függvény. Kérdés.
[Hallgató] Hol globális változók tárolják?
A globális változók tárolják mi jelenleg úgynevezett inicializált adatok vagy inicializált adat,
A különbség az, hogy ha van egy globális változó, és rendeljen hozzá azonnal értéket
az egyenlőségjel, azt végül a tetején van,
és ha csak annyit int x; nélküli érték, végül kissé alacsonyabb a RAM-ban
egyszerűen egyezmény.
Egyéb kérdés? Rendben van.
Tehát ez a kép jön vissza, mint mi, hogy több erős
, amit tehetünk a számítógéppel,
de most, vessünk egy rövid intro a kriptográfia,
egy adott típusú titkosítás ez nem oldja meg a világ összes problémáit
de nem oldja meg néhányat.
Ebben az esetben itt van egy úgynevezett titkos kulcsú titkosítás.
Secret-kulcsú, mint a neve is sugallja, származik a biztonsági egy titkos.
>> Például, ha te vissza az iskolában, és arra halad egy kis titkos szerelmes levelet
A fiú vagy lány voltál zúzás be, ha akarta átadni, hogy vegye figyelembe a közönséget,
akkor valószínűleg nem írna ilyen megjegyzést angol vagy bármilyen az Ön anyanyelve.
Sőt, lehet, hogy titkosítani, vagy talán csak küldj nekik egy szöveges üzenetet ezekben a napokban.
De lehet, hogy tényleg át őket egy megjegyzés az egész osztályteremben.
És, hogy ezt biztonságosan oly módon, hogy a barátok és a tanár
Nem tudom, mit írsz, lehet, hogy jön egy viszonylag egyszerű algoritmus,
fiatal, bár lehet, hogy, hogy csak összekeveri a szavakat.
Tehát ahelyett, hogy írása lehet írni b,
ahelyett, b lehet írni c,
ahelyett, hogy c írhat d, és így tovább.
Vagy tudnál jönni egy kifinomultabb fordítási
levelek különböző leveleket.
De a fogás a fiú vagy lány, akire te küldése e feljegyzés
tudnia kell valamit, ami pedig nyilvánvalóan? >> [Hallgató] Amit a küldést.
Mi a titka, mint mi, hogy a leképezés közötti és a b és a c-és d's.
Vajon csak, hogy 1 az egyes betűk megy a-b, a b c?
Ez bonyolultabb, mint ez?
>> Szóval, te és a törje szükségük van e titkos információt,
de van egyfajta 22-es csapdája van.
Ha ez az első alkalom, amit küldése szerelmes levél az osztály,
hogyan van az, hogy fiú vagy lány lesz tudni, hogy mi a titok, még van?
Szóval titkos kulcs crypto nem oldja meg a világ összes problémáit,
és van valójában egy kapcsolatot, hogy itt mi jön vissza felé félév végén.
Hasonlóképpen nem a legtöbben nem tudják, hogy valaki, hogy működik, például az Amazon.com,
és még sokan valószínűleg vásárolt cuccot Amazon.com,
és mi már tanítottak, hogy azt feltételezik, hogy ezeket az e-kereskedelmi tranzakciók biztonságos.
Az URL https valószínűleg azt mondja, van talán egy hülye kis lakat ikon valahol,
van valamiféle titkosítás biztosítására a hitelkártya adatait
közted és az Amazon.com.
És mégis, ha a titkosítás magában tudni valami titkos
és még nem tudom, bárki az Amazon-on, és én már biztosan nem rendezett semmiféle titkos
valaki az Amazon, hogy van a számítógép, vagy a böngésző csinálja ezt?
Kiderült, hogy van más típusú titkosítás teljesen, hogy megoldja ezt a problémát.
De ma, akkor összpontosítani egyszerű
ahol meg lehet rendezni előre tudni, hogy valami titkos
mint a +1 vagy valami leképezés között a és b a.
És a folyamat a kriptográfia általában magában foglalja ezt.
Van néhány egyszerű szöveg, látható itt a bal oldalon,
futtatja át valamilyen algoritmus vagy eljárás titkosítás -
lehet, hogy csak egy lesz b, b válik c -
és akkor a végén a rejtjelezett.
Közben, ha a szív megkapja ezt a titkot, vegye figyelembe,
ő kell majd dekódolni azt általában tolató hogy algoritmus
annak érdekében, hogy újra a sima szöveget.
Vannak fizikai inkarnációja ezt.
>> Például, ez egy kis titok dekóder gyűrű,
és ez egy gyűrű abban az értelemben, hogy van két tárcsázza itt.
A külső kerülete ez a dolog, van betűk A-tól Z-ig,
bár ők véletlenszerű sorrendben,
, valamint a belső, van valójában néhány számot
oly módon, hogy ezzel a gyűrűvel lehet ilyen kör a külső, de a belső
annak érdekében, hogy sorban számok betűk.
Akár egy film nevű A Christmas Story, látni fogod, hogy a kis Ralphie
annyira lelkes, hogy kitaláljuk, mit Kis Árva Annie titkos üzenete az volt, hogy ő
hogy közölték, azt hiszem, abban a formában a numerikus üzenetek a gabona doboz
és meg kellett felhalmozódnak az apró kártyák jött a gabona mezőbe,
meg kellett postázni őket, meg kellett, hogy újra a titkos dekódoló gyűrű
így végre kitalálni, hogy mi a leképezés között Betűk és számok
vagy betűk és levelek.
Hogy a számítógép tudunk járni végrehajtó vagy képviselő dolgok, mint ez?
Szükségünk van egy módja expresszáló magunkat egy kicsit rugalmasabban
mint a változó eddig tették.
Már volt ints, megvolt karakter, megvolt úszók és kétágyas és néhány más,
de ezek egyedi darab memória nem igazán teszi lehetővé számunkra, hogy kifejezzék a dolgokat
mint a szavak és a mondatok és kifejezések.
Sőt, most már az úgynevezett ilyen dolgokat húrok,
de ígérjük, hogy ez tényleg csak egy egyszerűsítés CS50 könyvtárban
hogy mi kívánó héjúak vissza.
És így kezdjük erre itt.
Hadd menjek előre, és megnyitja a fájlt -
az összes ilyen fájlok, mint rendesen, online - úgynevezett array.c
megoldani a problémát független strings, de fest egy képet ide
, hogy hogyan lehet használni egy úgynevezett egy tömb.
>> Egy tömb adattípust.
Ez egy változó típusa a fajta, amely több kisebb adattípusok belsejébe
háttal hátra hátra.
Így például, ha azt akartuk, hogy írjon egy kis programot, amely megadja a kvíz átlagos
egy tanfolyam, mint a 50, hogy a 2 kvízek,
akkor nagyon könnyen levelet e program alapján még néhány múlt heti anyaga
segítségével getInt és egy pár változók: int quiz1, int quiz2.
És ez elég egyértelmű.
Ez talán 10, 20 sornyi kódot max programjának végrehajtása
arra kéri a felhasználót, 2 kvíz csoportok, majd kiszámítja az átlagos
hozzáadásával őket, elosztjuk 2-vel, majd a nyomtatás az eredményeket.
Mi valószínűleg csinálni elég könnyen jelenleg után néhány percek számát.
De a probléma az, hogy tegyük fel, hogy 50 volt 3 vagy 4 vetélkedők.
Tegyük fel, hogy akarta, hogy ugyanazt a programot egy osztály, hogy már a héten vetélkedők.
Gondolj egy osztály, amely a heti vetélkedők.
Ha van 16 vagy olyan hét a félév, most már 16 változó:
int quiz1, int quiz2, int quiz3, int quiz4.
Amint elkezdi látni ezt a redundancia, a másolás és beillesztés a kódot,
meg kell kezdeni, hogy szeretne volt egy jobb út.
És szerencsére, mert a tömbök van. Akkor csináljuk.
Először is, hadd mutassam be egy nagyon egyszerű dolog, hogy már nem használt eddig,
de látni fogod, hogy esetenként kódot.
>> Ez az, ami általában úgynevezett állandó.
Tehát ez egy állandó abban az értelemben, hogy ez az érték nem változik.
Az emberi egyezmény létrehozása során állandó
az, hogy az összes nagybetűvel csak azért, hogy valóban kiemelkedik a kódot,
és a speciális kulcsszó, hogy használja a C # define.
Tehát mondjuk # define, majd egy szóközt, majd a kívánt szó használni a konstans nevét
, majd az értékét a konstans.
Figyeljük meg ez eltér hozzárendelése valamit egy változót.
Nincs egyenlőségjel, nincs pontosvessző.
Ez az, amit az általánosan ismert, mint egy előfeldolgozó irányelv,
hanem inkább az, hogy egy másik időben.
Most, ez létrehoz egy változatlan érték nevű kvízjátékok
amelynek tényleges numerikus értéke 2 lehet.
Így bárhol látod kvízjátékok, vetélkedők, kvízjátékok során ezt a fájlt,
ez csak a 2-es szám.
Ha valaki megnézi a főbb most lássuk, hogyan is működik ez.
Először is úgy néz ki, egy kicsit rejtélyes, de ez az egész cuccot hét 1.
Kérje meg a felhasználót a fokozatok. Hogyan tudjuk ezt megtenni?
Összhangban 22 - ez tényleg a szaftos rész - Kijelentem, az úszó
de nem csak egy egyetlen úszó. Én nyilvánította, inkább egy sor lebegőpontos értékeket.
Ezt a változót fog hívni fokozatok, mint hallgatólagos itt
de az egyetlen darab új szintaxis, akkor ezek a szögletes zárójelek között.
Az a tény, hogy már mondtam float évfolyamon, majd nyitó zárójel, majd a szám -
észre, ha ez egy állandó ez éppen olyan, mint tettük ezt -
ez azt jelenti, "Hé számítógép, adj 2 úszók és nézzük együtt hívjuk őket fokozatok."
>> Ezzel szemben egy sokkal unalmas folyamat, mint ez: float grade1;
úszó grade2, és így tovább.
Tehát egy tömböt lehetővé teszi számunkra, hogy végre ezt a gondolatot, de sokkal kevésbé messily,
oly módon, hogy tudunk írni 1 sor kód helyett, mondjuk, 16 egy 16 hetes félév.
Nem akartam, hogy hard-2-es kód, mert ha úgy gondolja, erről most logikusan,
Tegyük fel a következő évben CS50 változások 3 vetélkedők helyett
és én a 2-es szám van, az volt a 2-es szám van,
Volt a 2-es szám van, a 2-es szám van.
Ez lesz nagyon unalmas és nagyon könnyen elcseszed
és hogy véletlenül módosítsa 1 érték 3 és hiányzik néhány más értéke 2.
Szóval megyek helyette elvont ezt el, és ezt a konstans, hogy
mint a neve is mutatja, soha nem változik.
És most nem számít, hogy mi a különböző vetélkedők idén vagy jövőre,
Csak meg kell változtatni, hogy egy helyen ide tetején.
Szóval ez az egész egy konstans.
Eközben az új fogalmi jellemzője az, hogy egy tömb.
Tehát a szögletes zárójelek add nekem ezt a sok úszók és lehetővé teszi számomra együttesen hívjuk őket évfolyamon itt.
És most lássuk, mit fogok csinálni.
Itt sorban 24 a kezdete a hurok.
>> Ez tényleg semmi fantázia. Ez csak a vetélkedők helyett beégetett számot.
De nincs semmi intellektuálisan más ott a múlt héten.
Ez csak printf, így a printf ("Kvíz #% d% d:")
mert én csak azt szeretném kinyomtatni adni nekem quiz száma 1, 2, majd a 2-ból 2.
Tehát ez egy tisztán esztétikai dolog.
De az érdekes rész most már összhangban van az 27.
Annak érdekében, hogy kitöltse az egyik két helykitöltõvel egy lebegőpontos érték,
újra használni szögletes zárójelben.
Ebben az esetben én vagyok a i, mert ez a for ciklus kezdődött i egyenlő milyen értéket, látszólag?
[Hallgató] 0. >> [Malan] 0.
Tehát az első iterációs e hurok, az olyan, mintha én írtam ezt a kódot,
hanem a második iteráció e hurok, az olyan, mintha én írtam ezt a kódot.
De az a tény, hogy én vagyok egy változó tökéletes, mert, mint a neve is sugallja,
ez változó értéke minden iteráció,
úgyhogy kitöltésével ezt a tömböt egy helyen egy időben.
Mit jelent ez a tömb néz ki?
Az ok, amiért felhívta a szuper egyszerű téglalap a képernyő előtt itt volt az oka.
Egy tömb csak egy darab memória, majd egy másik darabja a memória
majd egy másik darab az emlékezet és így tovább.
Szóval, ha a tömb mérete 2 ebben az esetben is, minden, amit tenne
beírja az én teszt eredmények, mint itt - kaptam 100-ez aztán kaptam a 99 e egy -
akkor ez a memória lehet, hogy nem is lehet használni, mert én már csak arra kérték, a számítógép
egy tömb mérete 2.
Ezek a terek még mindig ott vannak, ugye?
Még mindig van 2 GB RAM-mal is, ha csak azt kérdezi, 2 úszók.
Tehát az ötlet mögött tömbök, hogy a számítógép csak úgy egy darab memória
majd arányosítja kisebb darabokra háttal hátra hátra.
És ez minden egy tömb.
>> Ez egy folytonos darab memória belsejében, ahol Ön a dolgokat.
Ez történik, hogy akkor nem csak valami unalmas számtani.
Ha görgessen itt, ez az, ahol én, akkor iterációkhoz a tömbben.
Jöttem fel az összegzése minden érték a tömbben,
és akkor használhatod a round függvény itt ténylegesen összeg osztva vetélkedők.
De hadd lóbálja a kezét, hogy a fajta elég aritmetikai most.
De minden, ami csinál nekem végeredményben kiszámításánál egy átlagos.
Tehát először kvíz plus 2. kvíz osztva 2, majd a nyomtatás ki, mint egy int.
De térjünk most átmenet egy másik példát nevű sztring1,
amely hasonló képet fest, de a szálakat.
Hadd menjek előre, és egyszerűsíteni ezt csak egy pillanatra.
Bocsáss meg a behúzás most.
Közleményt a 19 E példa, kapok egy string a felhasználó elől.
De észre, mit csinálsz a következő vonalak 22-től kezdődően.
Én valójában iterációjával tól i-ig - és ez egy új trükk - strlen, string hosszát.
Ez a funkció, hogy jön a C, hogy ha át, hogy egy string,
azt mondja, hogy hány karakter van, hogy a string. Ez minden.
És az a tény, hogy ez strlen helyett string hossza csak mert tömörebb.
Harminc évvel ezelőtt, az emberek szerették írni dolgokat tömören, amennyire csak lehetséges,
ezért is tartanak, hogy az egyezmény ide.
i + + csak azt jelenti, növeljük i egyes iteráció.
És most észre, ami igazán érdekes.
A vonal 24, azt mondom, "Computer, adj egy karakter, 8 bit, és hívja meg c."
De mi ez a jobb oldali mond?
Magyarul, ez mit jelent?
[Hallgató] Az első karakter a tömbben.
Pontosan. Add ide az első karakter a tömbben.
Vagy, még általánosabban, add nekem az i-edik karaktere a tömbben.
És észre fontos most, hogy a számítógép-tudósok,
vagyunk valójában számolás 0-tól.
>> Nincs mérlegelési most kezdeni ezt.
Most meg kell viselkedni összhangban a számítógép elvárásait és számolni 0-tól
mert [0] lesz az első karakter egy string,
[1] lesz a második, [2] lesz a harmadik, és így tovább.
Szóval ezt a programot, ha fordítani, ez ismét string1, úgyhogy győződjön meg sztring1,
és most már futni string1 az én terminál ablakban.
Ez vár bemenet, így megyek írja be David, az Enter,
és most kiírja Dávid mindezt különböző vonalak, mert nyilatkozat, hogy mit csinálok.
Én nyomtat egy karaktert egy időben.
Nem fogunk belemenni részletesen ma, de azt el kell hagyni egy perccel ezelőtt ezt az ellenőrzést itt.
Kiderült, hogy ha a felhasználó nem működött megfelelően, ellenséges, vagy csak zavaros,
akkor valóban nem adnak egy sor hosszasan.
Ha bejön a rossz gombot a billentyűzeten, lehet, hogy nem adnak karakterlánc egyáltalán,
vagy ha rosszindulatú, akkor megpróbálhatja beilleszteni egy gigabájt érdemes egy esszé
pótolni ezt a string, és ha a számítógép elfogy a memória,
kiderül, hogy mi lesz, hogy újra ezt a különleges értéket nevezzük NULL.
Tehát most már, csak tudom, hogy van ez a különleges érték úgynevezett NULL
amely lehetővé teszi számunkra, hogy ellenőrizze, amikor elfogyott a memória, többek között.
De ha kinyitom most string2, észre egy különbség van.
Értesítés egy különbség itt string2.
Ezzel string2, ez a for ciklus egy kicsit más.
>> Hadd törölje a NULL annak érdekében, hogy meg tudjuk beszélni ezeket egy másik alkalommal.
Mi a különbség, ami a for ciklus ebben az időben?
Mehetek vissza az előző példában.
Szóval ez 2-es verziója, ez 1-es verzióját. 1, 2.
1, 2.
Az strlen hívás hol?
Ez az első része a hurok.
Minden gondolat, hogy miért csinálom ezt? Igen.
[Hallgató] Szóval nem hívja a funkció minden egyes alkalommal.
[Malan] Tehát nem kérdőjelezik meg a függvény minden egyes alkalommal. Pontosan.
Emlékezzünk vissza, honnan a hurok, hogy ők szuper egyszerű
ha egyszer valami megérteni, hogy ez az inicializálás, a feltétel és a frissítést.
A probléma az, hogy a feltétel történik minden iteráció a hurok.
És így ebben a példában itt, mi a rossz a tény, hogy ez az én állapotot?
[Hallgató] Te hívó strlen.
[Malan] Te hívó strlen újra és újra és újra.
De ha egyszer már beírt David, a hossza a string 5,
és ez nem fog megváltozni minden iteráció a hurok
mivel a húr még mindig D-a-v-i-d.
Szóval ez egy tipp, hogy mi fog egyre fontosabb gondolat
ismert, mint a tervezési döntés, ha csak nem, hogy a számítógép nem felesleges munkát.
>> Csakúgy, mint egy besurranó elõnézetét pset2, pset2 a standard változat
fog kihívás, hogy ténylegesen alkalmazni bizonyos számú titkosítási,
bizonyos számú titkosítási algoritmusok, így mind a titkosítani
és dekódolja titkos üzeneteket ugyanúgy, mint az egyik Ralphie ott dekódolni.
A hacker kiadásában pset2, fogunk menni egy kicsit tovább.
Fogunk átadni egy fájlt a tényleges számítógépes rendszer
amely tartalmaz egy csomó felhasználónevek és a tényleges titkosított jelszavakat,
és a kihívás a hacker verzió lesz feltörni ezeket a jelszavakat
és kitalálni, mit kriptográfia, vagy mi titkos használtak ténylegesen generálni ezeket a jelszavakat.
És mi lesz, hogy ezt az egy új funkció itt a C
hogy adok neked csak egy demo nevei parancssori argumentumok.
Kiderült, mint néhány talán már látható a szakaszban vagy tankönyveket,
fő nem mindig kell semmisnek zárójelben.
Kiderül, hogy fő is lehet írni, mint ez a két érv,
argc és argv, ahol argc a szavak száma
hogy írja után a program nevét a parancssorban
és az argv a tényleges szavakat.
És ahogy a szögletes zárójelek ott utalnak, argv nyilvánvalóan egy tömb.
Ez lesz egy string után egy string után egy string a memóriában.
>> Szóval mit fogunk tudni csinálni kezdődő Pset 2 a valami ilyesmi.
Ha teszek argv1, amely példa jövünk vissza hétfőn, és futtatni,
észre, hogy nem úgy tűnik, hogy semmit sem.
Csak kiírja a saját nevét.
De ha azt mondom, viszlát osztály, azt tapasztaljuk, hogy ez a program látszólag végigmegy
át az egyes szavak, amelyeket írt a billentyűket.
És az eszközöket, amelyek segítségével fogunk hozzáférni szó, hogy a felhasználó beírt a prompt
ez módosítja fő kiindulási e hétvégén int main (void) hova int main (argc, argv)
és így fog megszületni parancssori argumentumok.
És ha egyszer igazán kifinomult most ezt, akkor képes lesz arra, hogy írjon igazán trippy programok
mint például ez itt, amely fölé és azon túl
bizonyos funkcióit tettünk eddig, de minden nagyon erős.
>> Így fogjuk elhagyni ezt e a képernyőn, és mi találkozunk hétfőn.
>> [CS50.TV]