[Powered by Google Translate] Beszéljünk tömbök.
Akkor miért lenne valaha használni kívánt tömböket?
Nos, tegyük fel, hogy van egy program, hogy kell tárolni 5 hallgatói azonosítók.
Úgy tűnhet ésszerűnek, hogy 5 különböző változók.
Okokból meglátjuk egy kicsit, akkor kezdeni számítva 0.
A változók mi lesz majd int ID0, int ID1, és így tovább.
Minden logika akarunk végezni a diákigazolvány kell majd a vágólapra másolni
Minden ilyen diák azonosítók.
Ha azt akarjuk, hogy ellenőrizzék, mely a diákok történetesen CS50,
akkor először meg kell, hogy ellenőrizze, ID0 képviseli a hallgató a tanfolyamot.
Aztán ugyanezt a következő diák, akkor kell, hogy másolja be a kódot ID0
és cserélje minden előfordulását ID0 a id1 és így tovább id2, 3, és 4.
>> Amint hallja, hogy meg kell másolni és beilleszteni,
meg kell kezdeni gondolkodni, hogy van jobb megoldás.
Most mi van, ha rájössz, hogy nem kell 5 hallgatói azonosítók, hanem 7-et?
Be kell, hogy menjen vissza a forráskódot, és adjunk hozzá egy ID5, egy ID6,
és másolja a logikai ellenőrzésére, ha az azonosítók tartoznak az osztály ezeket a 2 új azonosítók.
Nincs semmi összekötő mindezen azonosítók együtt, és így nincs mód megkérdezni
A program ezt az azonosítót 0 és 6.
Hát most már észre, hogy 100 diák azonosítók.
Kezd úgy tűnik, kevesebb, mint ideális szüksége, hogy külön-külön állapítsa mindegyik azonosítók,
és másolja minden logikát az új azonosítók.
De talán mi határozza meg, és tedd meg mind a 100 versenyző.
De mi van, ha nem tudja, hogy hány diák van valójában?
Már csak néhány n a diákok és a program, hogy kérje a felhasználót, hogy mi n.
Uh oh. Ez nem fog működni jól.
A program csak akkor működik, néhány állandó számú versenyző.
>> Megoldása mindezen problémák a szépsége tömbök.
Tehát mi egy tömb?
Néhány programozási nyelv egy tömb típusú lehet, hogy csinál egy kicsit,
de itt fogunk összpontosítani az alapvető tömb adatszerkezet ahogy látni fogod, hogy a C
Egy tömb csak egy nagy blokk memória. Ennyi.
Amikor azt mondjuk, van egy sor 10-egészek, hogy csak azt jelenti, hogy néhány mondatban
memóriával rendelkezik, amely elég nagy ahhoz, hogy tartsa 10 különálló egészek.
Feltételezve, hogy egy egész szám 4 bájt, ez azt jelenti, hogy egy sor 10 egész számok
folyamatos blokk 40 bájt a memóriában.
Még ha használja többdimenziós tömbök, amelyek nem megyünk be, hogy itt,
ez még mindig csak egy nagy blokk memória.
A többdimenziós jelölés csak a kényelem.
Ha van egy 3 * 3 többdimenziós tömb egész számok,
akkor a program tényleg csak kezeli ezt, mint egy nagy blokk 36 bájt.
Teljes száma egész 3-szor 3, és mindegyik egész szám vesz fel 4 bájt.
>> Vessünk egy pillantást az alap példát.
Láthatjuk itt 2 különböző módon nyilvánítja tömbök.
Mi lesz a hozzászóláshoz 1-őket a program összeállítása
hiszen állapítsa x kétszer.
Akkor vessen egy pillantást néhány a különbség e 2 típusú nyilatkozatok egy kicsit.
Mindkét vonal állapítsa tömb mérete N,
ahol már # define N 10.
Mi is ugyanúgy kérte a felhasználó pozitív egész
és használt, hogy egész, mint egy számos elemet a tömbben.
Mint a diákigazolvány például azelőtt, ez olyan, mint nyilvánító 10 teljesen különálló
képzeletbeli változók, x0, x1, x2, és így tovább, egészen xn-1.
Figyelmen kívül hagyva a vonalakon, ahol kijelentjük a tömb, észre a szögletes zárójelek ép
belül a hurkok.
Amikor írunk valami ilyesmit x [3], amelyet én csak olvasni x konzol 3,
lehet gondolni rá, mint kérni a képzeletbeli x3.
Észrevesz mint egy sor N méret, ez azt jelenti, hogy a belsejében a számát zárójelben,
amely fogjuk hívni index, bármi lehet 0 és N-1,
amely összes N indexeket.
>> Gondolni, hogy ez tényleg működik
ne feledjük, hogy a tömb nagy blokk memória.
Feltételezve, hogy egy egész szám 4 bájt, a teljes tömb x egy 40 bájtos blokk memória.
Tehát x0 utal az első 4 byte a blokk.
X [1] utal a következő 4 byte és így tovább.
Ez azt jelenti, hogy kezdetét x minden a program mindig kell nyomon követni.
Ha szeretné használni x [400], akkor a program tudja, hogy ez egyenértékű azzal,
, hogy csak 1600 byte kezdete után az x.
Honnan jutunk 1600 bájt? Ez csak 400-szor 4 byte per egész.
>> Mielőtt mozog, nagyon fontos felismerni, hogy a C
nincs érvényesítése az index, hogy használjuk a tömbben.
A nagy blokk csak 10 egész hosszú, de semmi nem fog kiabálni minket, ha írunk x [20]
vagy akár x [-5].
Az index még csak nem is kell egy számot.
Ez lehet tetszőleges kifejezés.
A programban használjuk az i változó a for ciklus index a tömb.
Ez egy nagyon gyakori minta, a ciklusok az i = 0 és a hossza a tömb,
, majd használja i az indexet a tömb.
Ily módon hatékonyan hurok az egész tömb,
és akkor sem rendelhet minden egyes helyszínen a tömbben, vagy használja azt a bizonyos számítás.
>> Az első a hurok i 0-tól indul,
, és így fog rendelni a 0 helyszínen a tömbben, az érték 0 alkalommal 2.
Aztán i lépésekben, és hozzárendelni az első helyszínen, a tömb értéke 1-szer 2.
Majd i lépésekben újra és így tovább, egészen addig, amíg meg rendelni helyzetbe N-1-ben a tömbben
az érték N-1-szer 2.
Ezért hoztunk létre egy tömböt az első 10 páros számok.
Lehet, hogy kiegyenlíti lett volna egy kicsit jobban nevet a változó x-nél,
de adott volna a dolgokat el.
A második for ciklus akkor csak kiírja az értékeket, hogy már tárolt a tömb.
>> Próbáljuk fut a program mindkét típusú tömb nyilatkozatok
és vess egy pillantást a program kimenete.
Amennyire látjuk, a program úgy viselkedik ugyanúgy mindkét típusú nyilatkozatok.
Nézzük is, nézd meg mi történik, ha megváltoztatjuk az első ciklus, hogy nem hagyja abba az N
hanem mondjuk 10.000.
Way vége után a tömb.
Hoppá. Talán láttad ezt korábban.
A szegmentációs hiba azt jelenti, a program összeomlott.
Te újra látni ezeket, amikor megérinti területeken memória nem érnek össze.
Itt vagyunk megható 10.000 helyeken túl kezdete x,
amely nyilvánvalóan egy hely a memóriában nem kellene megható.
Így a legtöbben valószínűleg nem véletlenül hozott 10.000 helyett N,
de mi van, ha nem teszünk valamit sokkal finomabb, mint mondjuk write kisebb vagy egyenlő az N
A for ciklus feltétel, szemben a kevesebb, mint N.
Vegye figyelembe, hogy a tömb csak indexek-tól 0-N-1,
ami azt jelenti, hogy az n index túl van a végén a tömb.
A program lehet, hogy nem összeomolhat ebben az esetben, de ez még mindig a hiba.
Tény, hogy ez a hiba annyira gyakori, hogy megvan a saját nevét,
Egy 1-jéig ki hibát.
>> Ennyi az alapokat.
Szóval, mi a fő különbség a 2 típusú tömb nyilatkozatok?
Az egyik különbség az, ahol a nagy memóriablokkot megy.
Az első nyilatkozat, amelyet hívom a konzol-tömb típusú,
bár ez egyáltalán nem egy hagyományos név,
akkor megy a verem.
Míg a második, amit hívom a pointer-tömb típusú, akkor megy a kupac.
Ez azt jelenti, hogy a függvény a tömb konzol automatikusan felszabadul
mivel ahogy kell explicitily hívja ingyenes a mutató tömb
vagy pedig van egy memóriavesztés.
Továbbá, a konzol tömb valójában nem egy változó.
Ez fontos. Ez csak egy szimbólum.
Azt hiszem, hogy ez egy állandó, hogy a fordító választja ki az Ön számára.
Ez azt jelenti, hogy nem tud ilyet x + + a konzol típusát,
bár ez tökéletesen érvényes a mutató típus.
>> A mutató típus egy változó.
A mutató típusú, van 2 külön blokk memória.
A változó x maga tárolja a verem, és csak egy mutató,
de a nagy blokk memória tárolja a kupac.
A változó x a veremben csak tárolja a címet
a nagy blokk memóriát a kupac.
Egyik következménye, ez a méret az üzemeltető.
Ha megkérdezzük a méret a konzol tömb, akkor megadja a méret a nagy blokk memória,
olyasmi, mint 40 bájt,
de ha kéri a méret a mutató típusa tömb,
hogy megadja a méret a változó x is, amely a készülék valószínűleg csak 4 bájt.
A pointer-tömb típusú, lehetetlen, hogy közvetlenül kérni
a méret a nagy blokk memória.
Ez általában nem sok a korlátozás hiszen nagyon ritkán akarjuk, hogy a méret
a nagy blokk memória, és mi általában számítani, ha szükségünk van rá.
>> Végül, a konzol tömb történik adjon nekünk egy parancsikont inicializálására egy tömb.
Lássuk, hogyan lehetne írni az első 10 még egész parancsikonnal initilization.
A mutató tömb, nincs módja annak, hogy egy parancsikont, mint ez.
Ez csak egy bevezetés, hogy mit lehet csinálni tömbök.
Ezek jelennek meg szinte minden program írsz.
Remélhetőleg most már láthatod egy jobb módja az a hallgató azonosítók példa
elejétől a videó.
>> A nevem Rob Bowden, és ez CS50.