>> [Zenelejátszási]
>> DOUG LLOYD: pointerek, itt vagyunk.
Ez valószínűleg fog a legnehezebb téma
hogy beszélünk a CS50.
És ha elolvastátok semmit mutatók
Mielőtt lehet egy kicsit megfélemlítő megy ez a videó.
Igaz, a mutatók nem teszi lehetővé a képesség,
hogy talán csavart ki nagyon csúnyán, ha éppen
dolgozó változók, és az adatok, és okozza a program összeomlik.
De ők valóban igazán hasznos és lehetővé teszik számunkra, egy igazán nagyszerű módja
adattovábbításhoz vissza között oda-funkciók,
hogy mi vagyunk egyébként nem tudnák megtenni.
>> És akkor mi van igazán akarok itt vonat
Önnek, hogy jó mutató fegyelem, ezért amelyek segítségével hatékonyan mutatók
hogy a programokat, hogy sokkal jobb.
Mint mondtam mutató nekünk egy másik módja közötti adattovábbításhoz funkciókat.
Most, ha visszahívja egy korábbi videó, amikor
beszéltünk változókat, megemlítettem
hogy minden adatot, hogy átadjuk között funkciókat C fogad el érték.
És én nem használtam, hogy távú, mit akartam ott
az volt, hogy haladunk példányban adatok.
Ahogy átmegyünk egy változó függvénye, akkor nem is igazából halad a változó
A funkció, ugye?
Mi halad egy példányát ezeket az adatokat a funkciót.
A funkció azt teszi, amit majd és kiszámítja néhány érték,
és talán használhatjuk ezt az értéket ha ez ad vissza.
>> Egy kivétel volt, hogy Ez a szabály az elhaladó értéket,
és mi jön vissza, hogy mi egy kicsit később ebben a videóban.
Ha az általunk használt mutatók helyett a változók használatára,
vagy használata helyett a változók saját maguk, vagy másolatát a változók,
most már át a változókat körül funkciók között eltérő módon.
Ez azt jelenti, hogy ha teszünk a változás egyik funkciója,
hogy a változás valóban megteszi hatása egy másik funkció.
Ez megint valami, nem tudtunk csinálni korábban,
és ha valaha is megpróbálta cserélni a értéke két változó függvénye,
Ön is észrevette ezt a problémát fajta kúszik fel, ugye?
>> Ha azt akarjuk, hogy a csere az X és Y, és mi át őket, hogy olyan függvény-swap,
belsejében a funkció cserélni a változók nem árfolyamokat.
Egy kettő lesz, két válik Egy, de valójában nem
változtat semmit az eredeti funkciót, a hívó fél.
Mivel nem tudjuk, mi csak dolgozó másolatát.
A mutatók azonban azt is ténylegesen át X és Y függvényében.
Hogy a funkció nem velük valamit.
És azok a változók értékei ténylegesen változtatni.
Szóval ez elég változás hogy képesek vagyunk együtt dolgozni adatokat.
>> Mielőtt még belemerülnénk mutatók, azt hiszem, megéri
vesz egy pár percet, hogy menj vissza az alapokhoz itt.
És nézd meg, hogyan számítógép memóriájában munkák
mert ez a két téma mennek hogy valóban elég egymással.
Mint bizonyára tudja, a számítógépes rendszer
van egy merevlemezt, vagy talán egy szilárdtest-meghajtó,
valamiféle fájlok tárolási helyét.
Ez általában valahol a szomszédságában 250 gigabájt
hogy talán egy-két terabájt most.
És ez az, ahol az összes Fájlok végül élni,
akkor is, ha a számítógép leállításakor kapcsolva, akkor kapcsolja vissza
és megtalálod a fájlok vannak újra, ha a rendszer újraindításához.
De meghajtók, mint egy merevlemez-meghajtót, HDD, vagy a solid state drive, SSD,
csak tárhelyet.
>> Nem tudjuk valójában mit kezdeni Az adatok, hogy a merevlemez,
vagy egy solid state drive.
Annak érdekében, hogy valóban változtatni adatok vagy mozgatni,
meg kell mozgatni, hogy RAM, véletlen hozzáférésű memória.
Most RAM, van egy csomó kevesebb a számítógép.
Lehet, hogy valahol a szomszédságában 512 megabájt
ha van egy régebbi számítógép, hogy talán két, négy, nyolc, 16,
talán még egy kicsit Több, gigabájtnyi RAM.
Szóval ez sokkal kisebb, de ez ahol minden a volatilis van adat.
Ez az, ahol meg tudjuk változtatni a dolgokat.
De amikor fordítjuk a számítógépet, minden adat a RAM-ban megsemmisült.
>> Szóval ezért van szükségünk merevlemez A több állandó helyszíne ez,
úgy, hogy exists- amilyet akkor nagyon rossz, ha minden alkalommal, amikor
fordult a számítógép kikapcsolása, minden fájlt a rendszer megsemmisült.
Így dolgozunk belül RAM.
És minden alkalommal beszélünk memória, elég sok, a CS50,
beszélünk RAM, nem merevlemez.
>> Tehát amikor azt mozgatni a dolgokat a memóriába, vesz fel egy bizonyos mennyiségű helyet.
Minden adattípusok mi már dolgozunk
vegye fel a különböző mennyiségű helyet a RAM-ban.
Tehát minden alkalommal, amikor létrehoz egy egész szám változó, négy bájt memóriát
helyez RAM, így lehet dolgozni, hogy egész.
Akkor állapítsa meg egész, megváltoztatni, hozzárendelés
a 10-es értéket eggyel nő által egy, így tovább és így tovább.
Minden, ami kell történnie RAM, és kapsz négy bájt
együttműködni minden egész hoz létre.
>> Minden karakter létrehozni kap egy bájt.
Ez csak mennyi hely áll tárolásához szükséges egy karaktert.
Minden úszó, egy igazi számú, kap négy bájt
hacsak nem egy kétágyas pontosságú lebegőpontos
száma, amely lehetővé teszi, hogy hogy pontosabb vagy több számjegy
tizedesvessző után anélkül, hogy elveszítené a pontosság,
amelyek figyelembe nyolc bájt memóriát.
Hosszú vágyik, igazán nagy egész számok, is vegye fel a nyolc bájt memóriát.
Hány bájt memóriát ne húrok vegye fel?
Hát mondjuk egy tűt a kérdésre most, de majd jön vissza hozzá.
>> Tehát vissza ez a gondolat a memóriát egy nagy tömb byte nagyságú sejtek.
Ez tényleg minden van, ez Csak egy hatalmas tömb sejtek,
mint bármely más tömb Ön ismeri és látni,
kivéve minden eleme egy byte széles.
És csupán egy tömb, minden elemnek van egy címet.
Minden elem egy tömb indexszel rendelkezik, és mi
Használhatja az indexnek köze az úgynevezett véletlenszerű hozzáférés a tömb.
Nem kell kezdeni az elején a tömb,
halad végig minden egyetlen elem cikkére,
hogy megtalálja, amit keres.
Mi csak annyit szeretnék, hogy a 15. eleme vagy a 100. elem.
És ha csak ama száma és kap az érték, amit keres.
>> Hasonlóképpen, minden helyen A memóriában van egy címet.
Tehát a memória esetleg valahogy így néz ki.
Itt egy nagyon kicsi darab memória, ez 20 bájt memóriát.
Az első 20 byte, mert a foglalkozik ott az alján
0, 1, 2, 3, és így az egészen 19-ig.
És amikor kijelentem, változók és Amikor elkezdek dolgozni velük,
a rendszer fog beállítani Szánjon helyet a számomra
ebben a memória dolgozni az én változók.
Tehát azt mondhatnám, char c egyenlő fővárosban H. És mi fog történni?
Nos, a rendszer fog félretett nekem egy bájt.
Ebben az esetben úgy döntött bájtos szám Négy, a byte címen négy,
és ez megy tárolására nagybetű H ott nekem.
Ha én akkor azt mondják int sebesség határértéket eléri a 65, ez
lesz pihentetett négy byte memóriát nekem.
És ez meg fog kezelni e négy bájt, mint egyetlen egység
mert mi dolgozunk A egész szám van.
És ez meg fog tárolni 65 odabent.
>> Most már én vagyok ilyen mondom egy kis hazugság,
jobb, mert tudjuk, hogy számítógépek dolgozik bináris.
Nem értik, feltétlenül, amit a főváros H
vagy mi a 65, csak megérteni bináris, nullák.
És így valójában mi mi tárolására ott
nem a H betű és a szám 65, hanem inkább a bináris reprezentációk
bekezdésére, amelyek úgy néznek ki a kicsit valami ilyesmi.
És különösen a összefüggésben az egész változó,
ez nem fog csak köpje be, ez nem fog kezelni, hogy egy négy
byte darab feltétlenül, mert tulajdonképpen ez lesz
kezelje azt a négy egy byte darabokat, ami valahogy így néz ki.
És még ez sem teljesen igaz vagy,
mert az úgynevezett Egy végződést, amely nem vagyunk
lesz bejutni most, de Ha kíváncsi vagy,
akkor olvass utána a kis és a nagy végződést.
De a kedvéért ezt az érvelést, kedvéért ezt a videót,
most csak feltételezik, hogy van, Tény, hogy a szám milyen lenne 65
képviselteti magát memória minden rendszeren,
bár ez nem teljesen igaz.
>> De nézzük valóban csak kap megszabadulni az összes bináris teljesen,
és gondoljuk át, mint a H és 65, ez sokkal könnyebb
gondolni rá, mint hogy mint egy emberi lény.
Rendben, így is, úgy tűnik, talán egy kis véletlen, hogy I've- a rendszerem
nem ad nekem bájt 5, 6, 7, és a 8., hogy tárolja a egész szám.
Van egy oka van is, ami nem fogunk bejutni most, de elegendő
azt mondani, hogy mi a számítógép csinál itt
Valószínűleg egy jó lépés a részéről.
Hogy nem ad nekem a memória, ami szükségszerűen háttal.
Bár ez fog csinálni most ha azt akarom, hogy egy másik szöveg,
nevű eredetű, és azt akarom, hogy Lloyd ott.
Megyek kell, hogy illeszkedjen egy karakter, minden betűt, ami
lesz szükség egy karakter, egy bájtot.
Tehát, ha tudtam tenni Lloyd az én tömb mint ez én vagyok elég jó, hogy menjen, ugye?
Mi hiányzik?
>> Ne feledje, hogy minden húr dolgozunk A C-ben végződik backslash nulla,
és nem hiányozhat, hogy itt sem.
Meg kell félre egy bájt memória állapította meg, hogy így
tudom, mikor a string véget ért.
Tehát megint ez a megállapodás A dolgok
jelennek meg a memóriában erejével egy kicsit véletlenszerű,
de valójában az, hogy hogyan A legtöbb rendszer célja.
Sorban őket a többszörösei négy okokból ismét
hogy nem kell, hogy bejutni most.
De ez, tehát elég annyit mondani, hogy Ezek után három sornyi kódot,
ez az, ami a memória nézhet.
Ha szükségem memória helyek 4, 8 és 12, hogy tartsa meg az adataimat,
ez az, amit az emlékezetemben nézhet.
>> És csak különösen pedáns itt, ha
beszélünk memória címek szoktunk
Ehhez hexadecimális jelölést.
Szóval miért nem konvertálja az összes ilyen a decimális hexadecimálisat
csak azért, mert ez általában hogyan utalunk memóriát.
Így ahelyett, hogy 0-tól 19, amink van, az nulla
x nulla és zéró x1 három.
Azok a 20 bájt memóriát, hogy mi már vagy keresünk ezen a képen
pont itt.
>> Tehát az összes, hogy azt mondta, menjünk lépésre a memória egy második
és vissza mutatók.
Itt a legfontosabb dolog, hogy emlékezzen
ahogy elkezdünk dolgozni a mutató.
Egy mutató semmi több, mint egy címet.
Én elmondom még egyszer, mert ez ilyen fontos,
egy mutató semmi több, mint egy címet.
Pointerek címeket helyek a memóriában, ahol a változók élnek.
Tudva, hogy ez lesz remélhetőleg kicsit könnyebb velük dolgozni.
A másik dolog, amit szeretek tennie, hogy van valami
ábrák vizuálisan képviselő mi történik különböző sornyi kódot.
És mi ezt egy pár alkalommal a mutatók,
és amikor beszélünk dinamikus memóriafoglalási is.
Mert azt hiszem, hogy ezek a diagramok különösen akkor lehet hasznos.
>> Tehát, ha azt mondom, például int k a kódomat, mi történik?
Nos, mi alapvetően az történik, Kezdek memória félre nekem,
de én nem is szeretek Gondolj bele, mint, hogy én
szeretnék gondolni rá, mint egy doboz.
Nekem van egy doboz, és ez zöld színű, mert
nem tud egész zöld doboz.
Ha ez volt a karakter, Lehet, hogy egy kék mezőben.
De én mindig azt mondom, ha hozok létre egy doboz, amely képes egész
hogy a dobozban zöld színű.
És veszek egy filctollal és írok k oldalán azt.
Szóval van egy doboz úgynevezett k, amelybe tudom rakni egészek.
Tehát amikor azt mondom, int k, ez mi történik a fejemben.
Ha azt mondom, k egyenlő öttel, mit csinálok?
Nos, én üzembe öt A doboz, ugye.
Ez elég egyértelmű, ha Azt mondom, int k, hozzon létre egy doboz úgynevezett k.
Ha azt mondom, k = 5, tedd öt a dobozba.
Remélhetőleg ez nem túl sok egy ugrás.
Itt, ahol a dolgok egy kicsit érdekes, bár.
Ha azt mondom, int * pk, illetve akkor is, ha nem tudom, mi ez szükségszerűen azt jelenti,
ez egyértelműen van valami köze egy egész szám.
Így fogok színezni ez a rovat zöld-szerű,
Tudom, hogy van valami, köze egy egész szám,
de ez nem egy egész szám önmagában, mert egy int csillag.
Van valami enyhén különböző róla.
Tehát egy egész szám benne van, de egyébként ez
nem túl eltér mit beszéltünk.
Ez egy doboz, annak van egy címke, ez van rajta egy címke pk,
és ez képes a gazdaság int csillagok, függetlenül azok.
Van valami köze egész számokkal, egyértelműen.
Itt az utolsó sort mégis.
Ha azt mondom, pk = & k, hé, mi történt, ugye?
Szóval ez a véletlen szám, látszólag véletlenszerű számú, kap dobott a dobozban.
Minden, ami van, pk kapja a címét k.
Szóval én vagyok maradva, ahol k él a memóriában, címét, a címet a bájt.
Minden csinálok mondok ez az érték, amit én fogok
hogy belső én box nevű pk.
És mivel ezek a dolgok mutatók, valamint azért, mert keres
egy húr, mint a nulla x Nyolc nulla c hét négy nyolc
Két nulla valószínűleg Nem nagyon értelmes.
Amikor mi általában elképzelni mutatók, valójában nem annyira, mint a mutatók.
Pk ad nekünk az információkat meg kell találnunk k emlékére.
Tehát alapvetően pk van egy nyíl benne.
És ha sétálunk hosszát Az, hogy a nyíl, képzeld
ez valami sétálhatunk, ha séta hossza mentén a nyíl,
a nagyon hegyét, hogy nyíl, mi fogja találni a helyét a memóriában
ahol k él.
És ez nagyon fontos mert ha egyszer tudjuk, hogy hol él k,
kezdhetjük a munkát az adatokkal belsejét, hogy memóriaterület.
Bár mi a sorstól egy ici kicsit előre magunkat most.
>> Tehát mi egy pointer?
A mutató olyan adat, amelynek érték egy memória címet.
Ez volt, hogy a zéró x nyolc nulla cucc folyik, ez volt a memória címet.
Ez volt a hely a memóriában.
És típusa egy mutató leírja, hogy milyen
Az adatok találsz itt hogy a memória címet.
Szóval van a int csillagos rész jobb.
Ha követem, hogy nyilat, ez fog vezetni, hogy egy helyen.
És ezen a helyen, amit én találsz ott az én például,
egy zöld színű dobozban.
Ez egy egész szám, ez az, amit én Találsz ha elmegyek arra a címre.
Az adatok típusát pointer leírja, hogy mi
meg fogja találni ebben a memória címre.
Tehát itt a nagyon klassz dolog, mégis.
Pointerek lehetővé teszi számunkra, hogy adja át változók közötti funkciók.
És valóban át változók és nem adja át másolatát.
Mert ha nem tudjuk pontosan, hol A memóriában található egy változó,
nem kell, hogy egy példányt ez, tudjuk csak megy arra a helyre
és a munka, hogy a változó.
Tehát lényegében mutató sort Az, hogy egy számítógépes környezet
sokkal több, mint a valós világban, ugye.
>> Tehát itt egy analógia.
Tegyük fel, hogy van egy notebook, Rendben, és tele van jegyzetek.
És szeretném, ha frissíteni.
Ön egy függvényt, frissítések jegyzetek, ugye.
Az utat jártunk munka eddig, milyen
történik, akkor veszem a notebook, akkor megy a másolás boltba,
akkor, hogy a Xerox másolatát minden oldalon a notebook.
Majd hagyni a notebook vissza az asztalomon, ha végeztél,
akkor menj és húzd át a dolgokat az én notebook, hogy elavultak, vagy rossz,
és akkor majd át vissza nekem a köteg Xerox oldalak
ez egy replika az én notebook A változások, hogy már meghozta hozzá.
És ezen a ponton, ez akár nekem, mint A hívó függvény, mint a hívó,
eldönteni, hogy a jegyzetek és integrálni őket vissza a notebookon.
Szóval van egy csomó lépést itt szó, ugye.
Tetszik, nem lenne jobb, ha én csak azt mondom, hé, te is
frissítem a notebook számára Számomra a kezedbe a notebookon,
és veszel dolgokat, és Szó szerint át őket
és frissíti a jegyzeteimet a notebookon.
És akkor add ide a notebook vissza.
Ez a fajta, amit mutatók lehetővé teszik számunkra, hogy nem,
teszik ezt a környezetet a sok Több, mint hogy hogyan működünk a valóságban.
>> Rendben, hogy az, amit a mutató, beszéljünk
hogyan mutatókat dolgoznak C, és hogyan tudunk kezdeni velük dolgozni.
Szóval van egy nagyon egyszerű mutatót C úgynevezett null pointer.
A null mutató semmit.
Ez talán úgy tűnik, mintha valójában nem egy nagyon hasznos dolog,
de mint látni fogjuk a kicsit később, az a tény,
hogy ez a null mutató létezik Igazából nagyon jól jöhet.
És amikor létrehoz egy mutatót, és nem az értéke immediately-
egy példa a beállítás értéke azonnal
lesz egy-két diák vissza amikor azt mondtam pk megegyezik & k,
pk kapja k címén is, majd meglátjuk, hogy ez mit jelent,
majd meglátjuk, hogyan kell a kódot, hogy shortly- ha nem az értéke legyen valami
értelmes azonnal, mindig kell
állítsa be mutatóját a null.
Be kell állítani azt, hogy pont semmit.
>> Ez nagyon más, mint csak elhagyja a értéke, ahogy van
majd nyilvánító mutatót, és csak feltételezve
ez null mert ez ritkán igaz.
Ezért mindig meg kell állítani az értéke egy mutató
null, ha nem az értéke hogy valami értelmes azonnal.
Ellenőrizheti, hogy egy mutató értékét null az operátorral
(==), Mint te hasonlítsa bármely egész értékek vagy karakter értékeket (==)
is.
Ez egy különleges fajta állandó értéket, amelyek segítségével tesztelni.
Szóval ez egy nagyon egyszerű, mutatót, a null pointer.
Egy másik módja, hogy hozzon létre A mutató kivonat
a címét egy változó már létrehozott,
és ezt megteszi a & üzemeltető címet kitermelése.
Amit már láttam korábban Az első ábrán például megmutattam.
Tehát, ha x egy változó, hogy már már létrehozott típusú egész,
Ezután & x egy mutató egy egész szám.
& x is- emlékszem, és megy kivonat A címe valami a jobb.
És mivel a mutató csak egy cím, mint & x egy mutató egy egész szám
amelynek értéke az, ahol a memóriában x életét.
Ez x címét.
Tehát & x a x címét.
Vessünk egy lépéssel tovább csatlakozni valamit
Utaltam egy korábbi videó.
Ha arr egy tömb páros, akkor & arr szögletes zárójel i Pointer
kettős.
OKÉ.
arr szögletes zárójel i, ha arr egy tömb páros,
akkor arr szögletes zárójel i az i-edik eleme az, hogy a tömb,
és & arr szögletes zárójel i, ahol a memória i-edik elemét arr létezik.
>> Szóval mi a gondolat itt?
Egy tömbök nevét, a hatása ezt az egészet,
az, hogy a tömb neve valójában maga a mutató.
Már dolgozik mutatókkal végig
minden alkalommal, hogy már használt egy tömbben.
Ne feledje, a példa A változó alkalmazási körét,
vége felé a videó bemutatom egy példát, ahol van egy funkció
úgynevezett set int és nevezett funkció beállított tömb.
És a kihívást, hogy meghatározzák e, vagy sem, vagy hogy mi a
értékeket, hogy kinyomtatják a végén a függvény,
a végén a fő program.
>> Ha felidézzük az adott példában vagy ha már figyelte a videó,
tudod, hogy ha nektek a hívást set int hatékonyan nem csinál semmit.
De a felhívást, hogy állítsa tömb nem.
És valahogy elkenték miért ez volt a helyzet abban az időben.
Csak azt mondtam, jól ez a tömb, ez Különleges, tudod, van egy oka van.
Ennek oka, hogy egy tömb Név tényleg csak egy mutató,
és itt van ez a különleges szögletes zárójel szintaxist
Hogy a dolgok sokkal szebb dolgozni.
És hogy az ötlet egy mutató sokkal kevésbé félelmetes,
és ezért ők a fajta A bemutatott így.
De tényleg tömbök csak mutatók.
És ezért, amikor változtattunk a tömb,
amikor elhaladtunk egy tömbben, mint a paraméter hogy egy funkció vagy érvként
arra a funkcióra, a tartalmát a tömb valóban megváltoztatta mind a hívott
és a hívó fél.
Amely minden más fajta változó láttuk nem volt a helyzet.
Szóval ez csak valami, hogy tartsa bánja, ha éppen dolgozik mutatók,
az, hogy a neve egy tömb valójában egy mutató
Az első elem a tömb.
>> OK, így most már mindezeket tények, hadd folytassam, ugye.
Miért érdekel ahol valami él.
Nos, mint mondtam, ez elég Hasznos tudni, hogy hol lakik valamit
így megy oda, és változtassa meg.
Vele dolgozni, és ténylegesen van a dolog, hogy
akarom, hogy a változó hatályba lépnek, és nem lépnek életbe, néhány példányt belőle.
Ez az úgynevezett dereferencing.
Mi megy a referencia és megváltoztatjuk az értéket is.
Tehát ha van egy mutatót, és úgy hívják pc, és ez arra utal, hogy egy karaktert,
akkor azt mondhatjuk * pc és * PC a nevét, mit fogunk találni, ha megyünk
A cím pc.
Mit találunk van egy karakter, és * pc hogyan utalunk az adatokat, hogy
helyen.
Tehát azt mondhatjuk, valami ilyesmit * db = D, vagy valami ilyesmi,
és ez azt jelenti, hogy bármilyen volt memória cím pc,
bármilyen jellegű korábban van, most D, ha azt mondjuk, * A PC = D.
>> Tehát itt vagyunk újra furcsa C cucc, ugye.
Így láttuk * korábban, hogy a Valahogy az adatok egy részét típusú,
és most ez is használják Egy kicsit más kontextusban
az adatokhoz való hozzáféréshez egy helyen.
Tudom, hogy ez egy kicsit zavaró és ez valójában része ennek az egész
mint, hogy miért van ez a mutató mitológia körülöttük, hogy annyira bonyolult,
egyfajta szintaktikai probléma, őszintén.
De * alkalmazunk mindkét kontextusban, mindkét részeként a típus neve,
és majd meglátjuk, egy kicsit Később még valami mást is.
És most a követéssel üzemeltető.
Így megy ez a referencia, az csatlakozik az adatokat
a helyét a mutató, és lehetővé teszi, hogy manipulálni az lesz.
>> Most ez nagyon hasonló a meglátogatta a szomszédja, jobb.
Ha tudod, mi a szomszéd él, te
Nem lóg ki a szomszédja.
Tudod, akkor megtörténhet, hogy tudom, hogy hol élnek,
de ez nem jelenti azt, hogy a ján, hogy a tudás
Ön kölcsönhatásban áll velük.
Ha azt szeretnénk, hogy kölcsönhatásba lépnek velük, el kell menni a házba,
Önnek kell menni, ahol élnek.
És ha egyszer csinálni, akkor kölcsönhatásba
velük csak tetszik, szeretnéd.
És hasonlóképpen változók, el kell menni a címére
Ha azt szeretnénk, hogy kölcsönhatásba lépnek velük, nem lehet csak úgy tudja a címet.
És ahogy megy a cím használható *, a hivatkozás feloldási üzemeltető.
Mit gondol, mi történik ha megpróbáljuk és hivatkozás feloldási
egy mutató, amelynek értéke null?
Emlékezzünk vissza, hogy a null mutató semmit.
Tehát ha megpróbálod dereference semmit, vagy menjen egy cím sem,
Mit gondol, mi történik?
Hát ha kitalálta szegmentáció Hiba, igazad van.
Ha megpróbálod, és dereference null pointer,
szenved a szegmentáció hibája. De várj,
Nem azt mondom, hogy ha nem mész
beállíthatjuk, hogy a értéke a mutatót valami értelmes,
akkor null?
Tettem, és valójában a szegmentáció hiba fajta jó viselkedés.
>> Előfordult már kijelentette, a változó és Nem rendelt érték azonnal?
Szóval csak annyit int x; te nem ténylegesen rendelje hozzá semmit
majd később a kódot, nyomtassa ki az x értékét,
mivel még mindig nem rendelt el semmit.
Gyakran kapsz nulla, de néha
lehet, hogy néhány véletlenszerű szám, Önnek fogalma sincs, hogy honnan jött.
Hasonlóképpen lehet a dolgokat megtörténjen a mutató.
Amikor egy olyan mutatót int * pk például
és nem látja, hogy egy értéket, Ön négy byte memóriát.
Bármi négy bájt memória a rendszer
találják, hogy van valamilyen értelmes értéket.
És ott lehetett volna valamit már ott, hogy
már nincs szükség újabb funkciót, így csak ki kell
bármilyen adatot is ott volt.
>> Mi van, ha próbáltam csinálni hivatkozás feloldási Néhány cím, amit don't- voltak
Már byte és információk Íme, itt most a mutató.
Ha megpróbálod, és követéssel, hogy a mutató, lehet, hogy a Messiás egy bizonyos memória
hogy nem állt szándékában bajlódni vele minden.
És valóban meg tudná csinálni valami igazán pusztító,
mint megtörni egy másik program, vagy megszakítani egy másik funkció,
vagy valami rosszindulatú, hogy hogy nem szándékozik tenni egyáltalán.
És ez az, amiért ez valójában egy jó ötlet
beállíthatjuk, hogy a mutató nincs, ha ne állítsa őket, hogy valami értelmes.
Ez talán jobb a A nap végén a programot
hogy összeomlik majd, hogy ezt valami, ami hibázott
Egy másik program vagy másik funkció.
Hogy a viselkedés valószínűleg még kevésbé ideális, mint összeomlik.
És ez az, amiért ez valójában egy jó szokás
bejutni beállíthatjuk, hogy a mutatók null, ha nem meg őket
hogy egy értelmes értéket Azonnal érték, hogy tudod,
és hogy nyugodtan a hivatkozás feloldási.
>> Tehát térjünk vissza most, és nézd A teljes szintaxis a helyzetet.
Ha azt mondom, int * p ;, mit tettem csak tenni?
Mit tettem ez.
Tudom, hogy a p értékét egy cím mert minden mutató csak
címeket.
Tudok hivatkozás feloldási p A * operátor.
Ebben az összefüggésben itt, a nagyon top felidézni a * része a típust.
Int * az adat típusát.
De nem tehetem hivatkozás feloldási o A * operátor,
és ha én ezt, ha elmegyek arra a címre, mit fogok találni arra a címre?
Meg fogom találni egész.
Tehát int * p alapvetően mondván p egy címet.
Tudok követéssel, p, és ha Én, meg fogom találni egy egész szám
abban memóriaterület.
>> OK, így azt mondtam volt egy másik idegesítő dolog a csillagok
És itt, hogy idegesítő dolog a csillagok is.
Próbáltál már nyilatkozni több változó azonos típusú
ugyanazon a vonalon a kódot?
Szóval egy pillanatra, úgy tesznek, mintha a vonal, A kód Igazából már ott zöld
nincs ott, és ez csak mondja int x, y, z ;.
Mit tenne, hogy valójában létre Három egész változók az Ön számára,
egy úgynevezett x, az egyik neve y, és egy úgynevezett részt.
Ez egy módja annak, hogy csinálni anélkül, szétszedés-ra három sor.
>> Itt van, ahol a csillagok kap idegesítő ismét ellenére,
mert a * valójában része Mindkét típus neve és részt
A változó neve.
És így ha azt mondom, int * px, py, pz, amit én tényleg csak egy mutató egy egész szám
nevű px, és két egész számot, pi és pz.
És valószínűleg nem az, amit akarjuk, hogy ez nem jó.
>> Tehát, ha azt akarom, hogy több mutató ugyanabban a sorban, az azonos típusú,
és a csillagok, amit valóban szüksége tennie, hogy azt mondják, int * pa, * pb, * db.
Most mintha éppen most mondta, hogy és most mondom ezt,
akkor valószínűleg soha nem fogja ezt tenni.
És ez talán egy jó dolog őszintén, mert lehet, hogy véletlenül
elhagysz egy csillag, valami ilyesmi.
Ez talán a legjobban talán kijelentem mutatók az egyes vonalak,
de ez csak egy újabb ilyen bosszantó szintaxis
dolgokat a csillagok, amelyek mutatók, így nehéz vele dolgozni.
Mert ez csak ezt a szintaktikai rendetlenség van, hogy a munka révén.
A gyakorlatban ez nem igazán vált természetessé.
Még mindig hibáznak vele még A programozás után a 10 éves,
így nem lehet ideges, ha valami történik neked, ez elég gyakori őszintén.
Ez tényleg ilyen egy hiba a szintaxis.
>> Ok, így egyfajta ígért hogy mi lenne újra
a koncepció, hogy milyen nagy egy szöveg.
Nos, ha azt mondanám, hogy a húr, most már tényleg ilyen
hazudtak neked az egész idő alatt.
Nincs adat típusú úgynevezett húr, és valójában én
említette ezt, az egyik a legkorábbi videók adattípusok,
hogy a húr volt egy olyan adattípust, hozták létre az Ön számára CS50.h.
Meg kell #include CS50.h annak érdekében, hogy használja azt.
>> Nos húr tényleg csak egy álnevet valamit
az úgynevezett char *, a mutató egy karaktert.
Nos mutatók, visszahívás Íme foglalkozik.
Tehát mi az a méret bájtokra egy string?
Hát ez négy vagy nyolc.
És azért mondom négy vagy A nyolcas, mert valóban
rendszertől függ, Ha használja CS50 ide, char * van akkora, mint egy char
* Nyolc, ez egy 64 bites rendszert.
Minden cím memóriában 64 bit hosszú.
Ha használja CS50 készülék vagy bármely 32 bites gép,
és akkor hallottam ezt a kifejezést a 32 bites gép, ami egy 32 bites gép?
Hát ez csak azt jelenti, hogy minden A cím memóriában 32 bit hosszú.
És így 32 bit négy bájt.
Tehát egy char * négy vagy nyolc byte rendszertől függően.
És valóban minden adattípusok, és egy hivatkozást bármilyen adat
írja, mivel minden mutató csak címek, négy vagy nyolc bájt.
Úgyhogy újra ezt rajzot és nézzük kötni
ez a videó egy kis testmozgás itt.
Tehát itt a rajz abbahagytuk a a legelején a videó.
És most mi lesz, ha azt mondom * pk = 35?
Szóval mit jelent az, amikor azt mondom, * pk = 35?
Vegyünk egy pillanatra.
* pk.
Ebben az összefüggésben itt, a * követéssel üzemeltető.
Tehát amikor a hivatkozás feloldási operátort használjuk,
megyünk a címet mutatott a pk, és mi változik, hogy mit találunk.
Tehát * pk = 35 hatékonyan Teszi ezt a képet.
Tehát alapvetően szintaktikai megegyezik az azt mondta, k = 35.
>> Még egy.
Ha azt mondom, int m, létrehozok Új nevű változó m.
Egy új doboz, ez egy zöld doboz miatt ez fog tartani egy egész szám,
és ez feliratú m.
Ha azt mondom, m = 4, tettem egy integer be azt a dobozt.
Ha mondjuk pk = & M, hogyan működik Ezen a diagramon a változás?
Pk = & m, emlékszel, amit a & Üzemeltető nem, vagy hívják?
Ne feledje, hogy néhány változó nevét és a változó címét nevet.
Tehát mi azt mondjuk van pk kapja a címét m.
És így hatékonyan, mi történik a ábrában, hogy pk már nem mutat
k, de rámutat m.
>> Ismét mutatók nagyon trükkös dolgozni
és sok a gyakorlat, hanem azért, mert
képességüket, hogy lehetővé teszik, közötti adattovábbításhoz funkciók
és tulajdonképpen azok, változások lépnek életbe,
szerzés fejed körül nagyon fontos.
Valószínűleg ez a legbonyolultabb tárgyalandó téma a CS50,
de az érték, amit kap a mutatók
messze felülmúlja a szövődmények hogy jön a tanulás őket.
Szóval azt szeretném, ha a legjobb szerencsét megismerése mutatók.
Én Doug Lloyd, ez CS50.