[Powered by Google Translate] [4. hét, folytatás]
[David J. Malan - Harvard University]
[Ez CS50. - CS50.TV]
>> Ez CS50, és ez a vége a 4 hét.
Szóval néhány jó hír és rossz hír.
Nincs előadás hétfőn, nem probléma állítsa a jövő héten. [Diákok éljenzés]
Ugye nem fog tetszeni, ha ez megy.
De van helyette jövő szerdán,
és van még egy a tananyag 1 Friday előadás jövő pénteken, hogy mi is marad a pályán.
De minden kerül filmre, mint rendesen, úgyhogy ne aggódj.
>> És tekintettel a kvíz 0 mit fogunk csinálni felé hét végére
A elhelyezhet a pályán honlapján cs50.net magyarázatot
Az milyen elvárásokat akkor kell, amikor az első teszt.
Általánosságban elmondható, hogy lesz feleletválasztós, igaz-hamis, a rövid válasz, rövid kódolási problémák.
Nem fogod várható végrehajtására egyenértékű
Az a probléma, hogy ha látná a Pset, amelynek van egy számítógép
és egy hibakereső és a hasonló, de nem lesz kicsi kódoló problémák.
>> És valóban, a legjobb útmutató, hogy egyfajta milyen CS50 kvízek olyanok, mint a
A megy cs50.net, menj a Feladványok linkre,
és láthatjuk az elmúlt néhány évnyi vetélkedők.
Csak észre, hogy a tananyag nem volt mindig ugyanaz az évek során.
Néha ehhez hozzátesszük, néha kivonni,
így ha látni néhány téma egyike a régi kvízek
, hogy fogalmad sincs, mit beszél, akkor sem, hogy mi volt ellepje
vagy az, hogy nem terjed ki rá.
De formájában áttekintésre, vasárnap, hétfő, kedd és
valamint a tanfolyam szintű értékelést ülésén vasárnap este -
időben és helyen, hogy bejelentette a kurzus honlapján -
mindenkinek lehetősége van arra, hogy felülvizsgálja a kurzus tanítási fickók
Az anyag ebben az évben, mind a részt, és egy teljes osztály,
és ezek fogják filmeztek a szokásos módon is.
>> Rendben van. Tehát minden további nélkül, egy megjegyzést / nem felelt meg és add / drop.
Lehet, hogy látta a jegyzeteimet tegnap este, és ez tényleg csak néhány további biztosítékot
hogy ha azok közé tartozunk, különösen a kevésbé kényelmes, vagy valahol a kettő között
és érzed, csak egy kicsit a fejed felett,
rájönnek, hogy valóban teljesen normális, és van egy bőséges támogatási rendszer a helyén,
amelyek közül az egyik munkaidőn volt szándéka javítani annál egy e-mail címemet tegnap este,
és észre azt is, hogy egy opció, mint a / nem felelt meg egy osztály, mint ez
valóban azt jelentette, mint egy olyan mechanizmus, hogy a szélén le egy tanfolyam, mint ez,
annak érdekében, hogy újra, ha töltesz e 10, 15, 20 óra
Csak próbálok valami Pset dolgozni, és tudod, hogy 90-95%-át az utat oda
de nem talál valami rohadt bug, egy megfelelt / nem felelt modell, amely a fajta rendben.
>> Az ötlet az, hogy ez a mechanizmus ezután tovább összpontosítani a többi psets
vagy aludni, vagy bármi legyen is az, amit szeretne összpontosítani.
Szóval észre, hogy van, amíg a jövő kedd - technikailag az 5., hétfő
de ez egy ünnep, így ez a jövő kedd - váltani megfelelt / nem osztályozott, vagy fordítva.
És ha tényleg a szakadék, és gondolkodás csepegtető teljesen,
kérem elkapni után Előadás vagy dobj egy üzenetet.
Szeretnénk legalább a csevegés, mielőtt ajánlatot búcsút.
Rendben van. Szóval elkezdtem szedni a képzési kerekekkel utoljára.
Különösen azt összpontosított string.
Karakterlánc van valami, ami a bejelentett CS50 könyvtárban,
kifejezetten ez a fájl neve cs50.h amelyhez kezdjük nézni ezen a héten és a jövő.
De a szöveg tényleg csak egy egyszerűsítése valami
ez egy kicsit arcanely leírt char *.
Char vagyunk tisztában. Ez csak egy karakter.
De * a hétfői jelölve mi? >> [Hallgató] A mutató.
A mutató. És mi az a mutató? >> [Hallgató] Egy cím.
>> Ez olyan, mint egy cím, egy helyet a memóriában.
Mi egy címet vagy helyet, vagy memória?
Ismét mindannyiunknak laptopok egy koncert vagy 2 GB RAM valószínűleg ezekben a napokban,
és ez azt jelenti, hogy egy milliárd vagy 2 milliárd bájt értékű memória.
És ez nem igazán számít, milyen fizikai néz ki,
de hogy a hit, hogy tudod megszámolni minden egyes bájtok saját laptop -
ez bájt 0, ez bájt 1, ez a bájt 2000000000 -
és pontosan ez az, amit egy számítógép nem.
Ha lefoglalni helyet Egyetlen karakter, például
ez nyilvánvalóan élni valahol a számítógép memóriájában,
és talán ez a byte szám 12345,
és ez valahol itt, a számítógép memóriájában.
És a címét, majd, hogy a karakter 12345.
>> Most, a 0. héten keresztül már eddig, már nem igazán érdekelte
ha a memóriában tárolt dolgok, mert mi általában használ szimbólumokat,
változók és tömbök hogy valóban kap a mi adatokat.
De hétfőn és annál ma, akkor most megy, hogy
Annál is inkább kifejező képességeket író programok
hogy valóban manipulálják a számítógép memóriáját de látod illik,
mind a jó és rossz célokra,
hibákat, hogy egy nagyon gyakori eredményt ezen a ponton a tanulási ezt a cuccot.
De mit is jelent valójában, hogy egy char *?
Menjünk előre vissza -, és mi jön vissza Muci ahogy ígértem ma.
Menjünk egy egyszerű példát itt.
Hadd menteni a fájlt compare.c, és hadd kap néhány sablon kódot itt
ide tartoznak a stdio.h, hadd adjam magam közé cs50.h. Majd Nagyításhoz odafent.
Hadd kezdjem írni fő int main (void), és most szeretnék csinálni valami ilyesmit:
printf ("Adj egy string:"), majd fogom használni s karakterlánc lesz getString
kap egy string a felhasználó, akkor fogom kérni a felhasználót egy másik.
("Adj egy másik szöveg:"), és én fogom kérni őket, át getString kap, hogy.
Majd hívlak, hogy t, mert t előzte s és s egy szép név egy húr, ha ez elég általános.
Szóval getString, és most csak azt akarom, hogy csinál egy józan ellenőrzést és fogok mondani
if (ok == t), akkor Én csak elmondom a felhasználó printf ("Te gépelt ugyanaz! \ n");
mást fogok kinyomtatni valami hasonló ("beírt valami mást! \ n")
vagy bármi a büntetés lesz. Szóval valami ilyesmi.
Aztán, mint mindig, én vissza 0, ami csak jelezte, hogy semmi rossz történt,
és én megyek előre, és fordítsd és futtasd ezt a programot.
>> De hétfőn már futott a program,
és valóban azt mondták, hogy nem HELLO Hello and Goodbye nem viszlát.
A viselkedés láttunk egy kicsit több, mint ez.
Hadd menjek az én forrás könyvtárába, nagyítás ide, és csináljuk, hogy összehasonlítani.
Összeállította rendben. Hadd futni összehasonlítani. Adj egy string: HELLO.
Adj még egy string: HELLO.
Beírt valami más!
Nos, hadd próbálj ki valami egyszerűbb, mint a 50, 50. Beírt valami más!
hi, hi. Tehát nyilvánvaló, hogy valami folyik itt.
De mi volt a magyarázata, hogy miért?
Úgy tűnik, hogy 12-es vonal teljesen működésképtelen.
Mi az alapvető probléma? Igen. >> [Hallgató] Ez összehasonlítva a címeket.
Igen, pontosan. Ez tulajdonképpen összehasonlító address
amely HELLO HELLO és tárolja.
Ez nem összehasonlítva a leveleket HELLO újra és újra,
mert mi is történt valójában, Az összes ezúttal már a getString -
Ez a tábla ismét a számítógép memóriájába,
és mondjuk hívom getString után nyilvánító változó s.
Mit jelent az emlékezetemben néz ki?
Tegyük fel azt, hogy önkényesen s úgy néz ki, mint ez. Ez egy négyzet.
És elég sok minden időt, amit húzott egy darab memóriát a képernyőn
ha ez 32 bit Már rajz terek, mint ez, mert valóban a készüléket,
a mutató, egy címet, a 32 bit. Ez ugyanaz, mint egy int.
Ez változhat alapuló számítógépes rendszer.
Azok közületek, akik halványan ismerős az a tény, hogy a Mac vagy PC 64 bit,
hogy valóban azt jelzi, hogy a számítógép használata 64-bit mutatók,
64-bites címeket, és az egyik upsides e a számítógépek
lehet sokkal több, mint a tavalyi RAM.
Hosszú történet rövid, vissza a nap, amikor a számítógépek csak akkor kell használni 32 bites
képviseletére címek, a legnagyobb bájtok száma akkor képviselt
ebben az esetben az volt, amit, ha 32 bit?
Tehát 4 milliárd van, mert a 2 a 32 pedig 4 milliárd euró.
Ez a szám már visszatérő folyamán.
>> Tehát, ha csak 32 bites, a legmagasabb számú lehet számítani, hogy a mintegy 4 milliárd euró.
De ez volt az alapvető korlátozása a számítógépek, amíg néhány évvel ezelőtt
mert ha csak akkor számíthat olyan magas, mint 4 milliárd
nem számít, ha veszel 8 GB RAM, vagy akár 5 gigabájt RAM;
nem lehet számítani, hogy a magas, így nem volt hiábavaló.
Te csak elérni az első 3 vagy 4 gigabájt a számítógép memóriájában.
Ez kevesebb a probléma, és most meg lehet vásárolni MacBook Pro és Dells
, 8 GB RAM, vagy még ezekben a napokban.
De ha osztják egészen egyszerűen ez a program a mutató, a mutató az úgynevezett s,
lehet, hogy néz ki a képernyőn, mert tényleg meg kell héjúak vissza ez a réteg.
Azt mondogatom string, hanem hétfőn, string igazán char *,
a cím néhány karakter.
Akkor nézzük, hogy a képzés kereket bár fogjuk használni a továbbiakban getString most.
Szóval bejelentett s, és ez a darab memória, 32 bit.
Mi van itt a memóriában alapértelmezés szerint? >> [Hallhatatlan tanulói válasz]
Mi ez? >> [Hallgató] Garbage. >> Garbage. Pontosan.
Ha a programozó nem tesz egy értéket egy változó, ki tudja, mi ez?
Néha szerencséd lesz, és ez 0, ami elég egy szép, tiszta alapértelmezett érték,
de mint láttuk, hétfő, néha ez teljes képtelenség,
néhány igazán nagy pozitív vagy negatív szám jött, ahol?
Igen. >> [Hallgató] A funkció előtt. >> Igen.
>> Gyakran a függvény, hogy van neve előtt, mert emlékszem,
ahogy te nevezed funkciók a memóriában, akkor vegye fel egyre több és több helyet alulról felfelé,
és amint a függvény, hogy az emlékezet lesz újra
A következő srác, hogy lesz nevezett, aki használja a ugyanazon szelet memória.
És ha már a bal szemét van, a korábbi értékeket,
talán összetévesztheti s mint amelynek néhány értéket, ha igazán már nem tesz semmit ott.
Így a RAM Ezen a ponton úgy néz ki, mint ez.
Most a jobb oldali 7-es vonal vagyunk hívás getString,
amit már csinál most a héten, de mi getString valójában csinál?
GetString írta CS50 személyzet egy kicsit intelligens
az, hogy amint a felhasználó elindítja gépelési és gombokkal találat Enter,
GetString kitalálja, hány billentyűleütéseket volt a felhasználói hit,
hogy hány karakter van szükség kiosztani RAM.
És ha ez a RAM származik, ki tudja?
Ez valahol a számítógép 2 GB vagy miegymás memória.
De tegyük fel, hogy a számítógépen talált helyet a szót HELLO itt.
A szó, amit beírt volt H-E-L-L-O.
És ha elkészíti ezt a karaktersorozatot, talán rajzolni, mint ez.
De meg kell tennem 1 extra dolog. Mi tartozik végén bármely sztring C?
A null karakter, amit írni, \ 0.
Ez technikailag a 0, de a backslash teszi a tisztább
hogy ez a szó a szám 0, értéke 0;
ez nem, például quote-unquote 0, hogy esetleg írja be a billentyűzeten.
Szóval ez HELLO.
>> És mit mondunk hétfőn, hogy egy függvény hasonló getString
ténylegesen vissza ezeket hét?
Ez nem visszatérés a húr önmagában, mert ez nem igazán van értelme
mivel a húrok nem léteznek. Ők egyfajta gyártás a CS50 könyvtárban.
Mi valóban egy string, műszakilag? >> [Hallgató] Ez az első karakter.
Pontosan. Elég csupán a címe az első karakter, hogy a felhasználó beírt be
Tehát, ha a szavam HELLO végződik fel a byte száma 123, majd a byte szám 124,
125, 126, és így tovább, ha csak az én szám bájt 0-up,
ami igazán getString visszatér szó a szám 123.
Szóval mi lesz életbe s az a szám 123, nem a H betű, nem pedig a szó HELLO,
egyszerűen a címét, amelyen találok az első betű HELLO.
De ez nem tűnik elég. Kérdeztem egy string, nem egy karaktert.
Szóval hogyan lehet, vagy a számítógép tudja, hogy ello fajta jön a H?
Mi az a fajta megállapodás van? Igen.
[Hallgató] Tartja mondja magát, hogy talál valami több karaktert. >> Pontosan.
>> Van ez ember-számítógép-egyezmény, amelynek során, ha foglalkozunk húrok,
más néven most, mint char csillagok, akkor egyszerűen kitalálni
ha a végén minden karakterlánc élet által tényleg csak iterációjával rajta egy for ciklus,
a while ciklus, mindegy, hogy amikor megtalálja a végén a húr
most már lehet következtetni arra, hogy ó, az egész szó volt HELLO.
Akik ezt a korábbi programozási tapasztalatok azt tudni Java
ha csak a tétet. hossza és más nyelveken hívhat hossz vagy hasonló.
Ez azért van, mert egy csomó nyelvek, különösen a dolgok, az úgynevezett objektum-orientált nyelvek,
hossza valami fajta kapszulázott belül az adatot is,
sokkal, mint mi kiöntött azonosítók nevét és házak belsejében egy diák hétfőn.
De C sokkal alacsonyabb szinten. Nincsenek objektumok vagy osztályok, ha már hallottam ezeket a kifejezéseket előtt.
Csak ennyit tényleg memória címeket.
Tehát ez a fajta régi vágású módon képviselő érdekes adatszerkezeteket.
Van egy kezdeti érték, mint a címe az első karakter
majd csak néhány önkényes konvenció, hogy mindenki egyetért abban, hogy kövesse.
Szóval, hogyan string hossza végrehajtása nem javasoljuk?
Strlen, strlen, amelyet néhányan most használt néhány alkalommal. Elég egyszerű, ugye?
Ez olyan, mint 2 sornyi kódot.
Elég sok a for ciklus valamiféle, talán egy további helyi változó.
De strlen csak meg, hogy egy mutatót, majd kezdeni \ 0.
>> És amint azt találja, akkor vissza az összes lépést, hogy ez hozott, hogy a húr.
Így tudjuk következtetni ebből, mi folyik a következő.
Tegyük fel, hogy akkor én kijelentem t, mint én tettem sorban 10.
Ez valami szemét érték. Ki tudja, az első?
De a jobb oldali vonal 10 Hívom getString újra.
Ki tudja, ha ez végül?
Tegyük fel önkényesen azt mondják, hogy az operációs rendszer talált helyet, hogy úton van ide.
Én történetesen véletlenül írja H-E-L-L-O újra,
és így tudjuk felhívni ugyanolyan kép.
De az a tény, hogy már ezt a képet rajzolni szándékos
mert ez egy másik HELLO, mint ez.
Tehát itt ez lehet hely 456, ez a 457, és így tovább.
Szóval, mi lesz, ha tesz a kérdőjel egykor volt?
Ebben az esetben a 456.
Mi felvette ezeket a számokat önkényesen, mert tényleg a mai nap után
nem fogunk törődni annyira, hogy mi a címe, bármi.
Minden törődünk, hogy kitaláljuk, a címét néhány adat, mint a HELLO.
>> Szóval tényleg amit a legtöbb ember csinál számítógép-tudomány, ha beszélünk memória címek
és beszél mutatók pontosabban,
ahelyett zavarta rájönni, 123 - kit érdekel, ha ez a cucc valójában,
mi csak tudjuk, hogy néhány numerikus cím -
leegyszerűsítjük a világot, és csak azt mondják, hogy s mutat, hogy a karakter
és t mutat, hogy a karakter.
És az a tény, hogy ez egy nyíl elég szándékos
mert a szó most s mutat a H és t mutat a többi H
mert az a nap végén, nem számít, hogy mi a cím,
de ez nem számít, hogy mi van a képessége, hogy ezt a címet néhány kódrészletet.
Még nem igazán manipulálni ezeket a címeket csak még
úgyhogy majd meglátjuk, hol tudunk közbevet és rendezni a dolgokat a mutatók,
de most a 12-es vonal szó milyen értékeket fogunk összehasonlítása
szerint ez a történet a 12-es vonal?
Azt mondod, hogy a 123 egyenlő egyenlő 456? És ez egyáltalán nem ez a helyzet.
És még fogalmilag, ez a mutató egyáltalán nem ugyanaz, mint a
azért, mert az úgynevezett getString kétszer, és getString nem próbálja meg, hogy szuper okos,
nem próbálja megvalósítani, oh, beírt HELLO 5 perccel ezelőtt;
hadd adjak ugyanazt a mutatót, mint én adtam neked korábban,
ez csak oszt egy új darab memória minden alkalommal, amikor hívják.
>> Szóval hogyan lehet kijavítani ezt a problémát?
Ha magasabb szintre akarom összehasonlítani a húrok és a HELLO HELLO -
Engem nem érdekel, ami a mutató - hogyan megy a választ a kérdésre,
nem a felhasználó adja meg ugyanaz a dolog? Mi szükség itt? Igen.
[Hallgató] Használja a funkciót. >> Tudom használni a funkciót ki a dobozból.
Tudom használni egy nevezett funkció strcmp, s-t-r-c-m-p,
csak a rövidített változatát, mondván karakterlánc összehasonlítani.
És ha bemegy, például összehasonlítani 2, ami napjaink emlékeztetők,
Tudom, hogy pontosan.
Megtartottam minden más ugyanaz line 1 le, hogy 26, vagy úgy,
és most már észre, ez a rész is változott egy kicsit.
Nézzük ignore 28 vezetéken egy pillanatra, és elsősorban csak ez az egy.
Mit mondunk hétfőn, hogy str összehasonlítás nem?
Ez az elem kezeli a folyamat figyelembe 2 mutatók, s és t ebben az esetben,
fajta gyakorlatilag azáltal, hogy az ujját a 2 betű,
és mit kell tennie egy olyan dolog, mint a while vagy for ciklus,
és azt mondja, ezek az ugyanaz? Ha igen, akkor mozog a kéz vagy a mutató előre.
Ezek az azonos, ezek az azonos, ezek az ugyanaz,
Ezen ugyanaz, ezek az ugyanaz? És ó, én vagyok a végén a húr mind s és t.
Én nem találtam olyan ellentmondásokat. Igen, ezek sztringek az ugyanaz.
És mit str hasonlítsa össze vissza, ha 2 karakterláncok megegyeznek, látszólag? Zero.
Szóval 0 jó ebben az esetben, mert ha visszatér -1 vagy +1,
azt jelenti, hogy s épp, hogy jöjjön elé t betűrendben vagy után t.
És miért lenne ez hasznos funkció, hogy megmondja, melyik húr előbb
vagy azt követően a szótárban?
[Hallgató] Keresés. >> Keresés és rendezés.
>> Szóval lehet csinálni a dolgokat, mint a bináris keresés, vagy buborék rendezés, illetve összeolvad rendezés
ahol van összehasonlítani a dolgokat.
Eddig voltunk ilyen vágott néhány sarkok és csak beszélt válogató
összefüggésben a számok, mert szép és könnyű beszélni,
de akkor biztosan összehasonlítani vonósok, alma és banán,
mert ha alma ismerten elé banán, hasonlóan,
tudsz mozogni húrok bárhol a memóriában, mint Rob tette merge sort a videó
és mi van a színpadon kiválasztási sort, beillesztés sort, és buborék rendezés.
Szóval, ha mást veszünk ezt? Próbáljuk ezt.
Nézzük fajta felejtsük el, hogy lecke egy pillanatra, és próbálja most, és másolja 1.c tegye a következőket.
Összhangban 21 mondok print valamit,
akkor kapok egy string a felhasználó,
akkor én bejelöli ezt.
Mi nem igazán ütött ebbe a szokás még, de most már ezt.
Menjünk ténylegesen héjúak vissza ez a réteg. Ez tényleg char *. Ez a fickó tényleg char *.
Szóval, mit is jelent, hogy ellenőrizni kell, s == NULL?
Kiderült, hogy amikor telefonál egy függvényt, mint getString
vagy még általánosabban csak kérni egy számítógépet, hogy egy kis memória,
valami elromolhat.
Lehet, hogy őrült, és kérje a számítógépet egy terabájt memória
által kért trillió byte memóriát, hogy egyszerűen nem léteznek a számítógépen,
de getString és egyéb funkciókat kell valamilyen módon kiabál rád
ha már kért túl sokat.
És ahogy getString teszi ezt, ha kért több memóriát
mint áll a számítógép, akkor is, ha ez szuper, szuper kis valószínűségű
mert egyikünk sem megy írja trillió karaktert, majd nyomja meg az Enter billentyűt,
de alacsony valószínűségű, bár lehet, én még mindig szeretné, hogy ellenőrizze, hogy csak abban az esetben,
és a speciális értéket getString, választ, és egyéb funkciók visszatér
Ha valami baj van NULL minden sapkák.
>> És mi NULL? NULL csak azért történik, hogy képviselje a mutató. Ez a memória cím 0.
A világ úgy döntött, hogy önkényesen, ha ez a számítógép memóriájában - Tudod mit? -
fogunk lopni csak 1 byte minden számítógép memóriája, és ez a 0 helyen.
Fogjuk, hogy ez a beceneve NULL, és fogunk ígér
hogy soha nem fogjuk ténylegesen valós adatokat oda
mert csak önkényesen szükségünk különleges értéke, 0, más néven NULL,
hogy így kiabálni felhasználó, ha valami balul sül el.
Ellenkező esetben előfordulhat, hogy nem tudja, nem 0 jelenti tesz valamit
vagy nem jelent valami baj?
Meg kell mindannyian egyetértünk, hogy NULL úton semmit sem tért vissza,
nem a tényleges címet vissza.
Most itt vagyok, csak az én emberi elfogadásáról egyezmény I return 1 a fő
ha valami balul sül el.
Azért, mert fő visszatérése egyezmény visszatérni 0, ha jó,
1 vagy más értéket, ha rossz.
De getString és minden olyan funkciót, hogy foglalkozik a memóriában visszatér NULL, ha valami elromlik.
>> Oké. Szóval sajnos line 27, szuper egyszerű bár, teljesen nem másolja a húr.
Miért? Láthatjuk ezt az alábbiak szerint.
Én hivatkozva line 27 lehet, hogy egy példányt s és hívja meg t.
Szóval nem azt kéri a felhasználót, 2 strings ebben az időben, csak azt mondom, az érték s
kellene helyezni t is.
Úgyhogy most csak azért, hogy mutassa be, hogyan tört ez, összhangban 29-től kezdődően, mit csinálok?
Gyártási Én ellenőrzése, hogy a hossza t jelentése 0-nál nagyobb.
Van néhány húr van. A felhasználó beírt valamit be
Mit csinál 32 vezetéken, látszólag?
[Hallhatatlan diák válasza] >> Rendben. Tudod milyen következtetni azt, amit mondtam, hogy csinál.
De technikailag, mi ez csinál? t [0] képviseli azt, amit?
[Hallgató] A 0. karakter. >> [Malan] A 0. karakter.
Vagy inkább emberi, mint az első karakter t, bármi legyen is az, H talán ebben az esetben.
És toupper azt teszi, amit mond. Ez kihasználva a nulladik jellegét t és megváltoztatja azt.
Tehát ez azt jelenti, hogy a nulladik jellegét t, legyen nagybetű,
és tedd vissza, hogy ugyanazon a helyen.
Tehát, ha azt írja hello kisbetűs, ezen változtatni kell a kisbetűs h a tőke H.
De a probléma az, hogy a vonalak 35 és 36, mit fogok csinálni a kinyomtatni számunkra s és t.
És mi a megérzés?
Mit tényleg megy, hogy ha nem adtam a hello csupa kisbetűvel?
Mi folyik itt kap nyomtatott? >> [Hallhatatlan tanulói válasz] >> Mi ez?
[Hallgató] Nagy hidrogénatom és a többi kicsi. >> A nagy H és a maradék kis, amelyre, s vagy t?
[Hallgató] Mindkettő. >> Mindkettő. Pontosan. Szóval lássuk, mi folyik itt.
>> Hadd menjek előre, és lefordításával. Ez COPY1, úgyhogy győződjön meg COPY1. Rendben van.
Nagyítás Hadd menjek előre, és fuss COPY1, Enter, Mondj valamit: hello kisbetűvel.
A tőkésített a másolás, de ez nyilvánvalóan aktiválásra az eredeti is,
mert ami most történik, ebben a történetben?
Összhangban 27 I valójában nem úgy tűnik, hogy másolás a húr,
de még akkor is lehet, hogy ösztönösen azt remélte, hogy ez a helyzet,
ha úgy gondolja, ezt a képet, ami igazán tettem?
Fele a kép az ugyanaz.
Szóval forgassa vissza az időben, hogy a t még nem létezik a történetben.
S létezhet a történetnek, de menjünk kisbetűs helló ebben az időben.
Szóval hadd rögzítse, amit valójában gépelt be
Ebben az esetben itt van h-E-l-l-o.
Majd dolgozzon, mint egy karaktersorozat, tedd a elválasztó vonalak itt a \ 0.
Szóval, ez az, ahol vagyunk, amint sorban 1-től 24-ish, ide vagy oda, már kivégezték.
Ez a kép az emlékezetemben.
Mikor kapok line 27, mi történik?
Csakúgy, mint korábban, kapok egy mutató, ami fogom hívni, mint ezen a téren.
Úgy hívják t. És mi az értéke alapértelmezés szerint? Ki tudja? Néhány szemét érték.
>> Úgyhogy elvont, hogy idegenben, mint egy kérdőjel.
És amint a jobb oldali line 27 végrehajtja, amit én üzembe belsejében t?
Ugyanaz a dolog, hogy van s.
Tehát ha egy pillanatra eltávolítani ezt absztrakció a nyíl, és azt mondjuk,
Ó, ez a memória terhelés címe 123, amikor azt mondod, t kap s, pontosvessző,
te szó szerint üzembe 123 itt.
Nos, ha már ilyen egyszerűsíteni világunk ismét képeket,
amit valójában történt, csak még egy nyíl, hogy a világ
ez mutat-től t pontosan ugyanolyan string.
Tehát, ha sorban 31 és 32 én tényleg megy a változó t [0],
mi a t [0] látszólag egyet most? s [0]
Szóval ez minden, ami történik.
És bár ez a fajta úgy érzi, egy kicsit alacsony, és misztikus
és ez a fajta érzés talán ösztönösen ennek éppen dolgozott -
Csináltam másolatot a dolgok előtt, és ez csak működött -
ha valóban úgy gondolja, hogy mi az a szöveg valóban, ez egy char *.
Nos, mi ez? Ez a címe a néhány karakter.
Akkor talán van több értelme, hogy ha megpróbál tenni valamit
super látszólag egyszerű, mint ez, minden, amit csinál, másol memória címet.
Te valójában nem csinál semmit a húr is.
Tehát akkor is, ha fogalmad sincs, hogyan megoldaná ezt a problémát kódot,
magas szintű, elméletileg, mit kell tennünk annak érdekében, hogy ta másolata s, látszólag?
Igen. >> [Hallgató] Adj neki egy új helyre? >> Pontosan.
>> Meg kell adni t egy teljesen új helyre.
Meg kell valahogy létrehozni egy olyan világban, ahol kapunk egy új darab memória,
ami csak az egyértelműség kedvéért fogom felhívni jobbra lent ez, de nem kell ott lenni.
De kell lennie az azonos méretű, úgyhogy felhívni ezeket függőleges vonalak ugyanazon a helyen.
Rendben van, ha ez az egész szemetet kezdetben. Ki tudja, mi volt ott?
De 1. lépés megy, hogy meg kell adni nekem annyi memóriát, ahogy kell
hogy illeszkedjen egy példányát hello, majd kitaláljuk, hogyan lehet másolni a h itt, e itt,
a l itt és így tovább.
De ez már kell egy kicsit nyilvánvaló, akkor is, ha egyes részleteket még elvont.
Szeretnénk másolni ezt a fonalat ebbe, ez csak egy for ciklus vagy while
vagy valami, amivel lettél annál inkább ismerős.
Akkor próbáljuk meg. Hadd menjek be copy2.c.
A copy2.c már majdnem ugyanazt a programot, kivéve a 27 vezetéken.
Úgy néz ki, egy kicsit bonyolult, de ha törjük le apránként,
a bal oldali ugyanaz.
Char * t hoz létre, ez a dolog a memóriában, jóllehet egy kérdőjel
mert fogalmunk sincs, mi van ott alapértelmezés szerint.
A jobb oldali vagyunk most, hogy új funkció, malloc,
memória osztja, adj memória,
és nyilvánvalóan úgy, hogy sok érv, hogy sok dolog zárójelek?
Hallottam zúgolódástokat 1 és 2, de ez csak 1.
Nincs vessző, ami azt jelenti, hogy csak 1 dolog zárójelben.
Annak ellenére, hogy van más zárójelben hadd jelölje
mi van benne a legkülső zárójelek, és ez a kifejezés:
(Strlen (s) + 1) * sizeof (char).
Tehát ha tényleg úgy gondolja ezt végig, ezt mondja nekem a hossza s.
Miért vagyok azonban, hogy 1-re a hossza? >> [Hallhatatlan tanulói válasz]
Pontosan. Szükségünk van hely ez a fickó a farkát, a hatodik karakter nincs angol jelentése
de nem különleges programszerű értelme.
>> Tehát szükségünk van egy + 1 az, hogy mivel strlen visszatér az emberi várható hossza,
helló vagy 5, akkor nem ad a további null karaktert.
Szóval manuálisan hozzáadni ezt a + 1.
És akkor ez, * méret (char), mi még nem láttam ilyet.
Ez technikailag nem egy függvény.
Ez egy speciális kulcsszó, hogy csak megmondja, hogy mi a mérete néhány adattípus a számítógépen
mert a valóságban, néhányan közülünk 32-bites számítógépeken.
Van egy elég régi számítógépet otthon, és mindig csak 32 bites, hogy képviselje mutatók.
És ha mégis méretű adattípus, lehet, hogy 32 bitet.
De ha én vagyok a új divatos számítógépet, talán vissza értéke 64 bit
valami, mint egy cím.
Tehát ebben az esetben, csak a szuper biztonságos, nem fogunk a kemény code valami hasonló -
Nos, mi a mérete char szerint amit mondtam eddig?
Már nagyjából azt mondta, verbálisan, hogy ez 1 byte, és ez nagyjából igaz az egész fórumon.
De ismétlem, feltételezések általában rossz.
Ők vezetnek kerekesszékes program, ha az emberek használják a szoftver oly módon, hogy nem áll szándékában.
Szóval elvont ezt el, és csak nagyobb általánosságban azt
Kell ez a sok darabokat memória
és minden egyes darab memória kell egyezniük a mérete egy karakter,
ami valójában értéke 1 ebben az esetben, de ez egy általános módon az írás azt.
Tehát, ha a szó hello, hány bájtot jelent malloc látszólag kiosztani hello?
[Hallgató] Hat. >> Hat. Pontosan annyi, mint mi kérdőjelek a képernyőn.
És akkor, hogy egy hiszem, most már az Ön megértése getString
mit malloc valószínűleg vissza? >> [Hallgató] Egy cím.
Egy cím, mi? Az első darabja a memóriát.
>> Fogalmunk sincs, mi van ott, mert néhány más funkció
lehetett volna alkalmazni ezt a memóriát korábban.
De malloc, mint getString, visszatér a cím első byte memória
arról, hogy félre az Ön számára.
Amit azonban nem csinál az, töltse ki az üres egy backslash null karakter
azért, mert kiderült, hogy tudod használni malloc kiosztani semmit: ints, vonósok, tömbök,
úszók, diák struktúrák.
Használhatja malloc teljesen általánosan.
Nem érdekel, vagy tudni, hogy mit kiosztása memória.
Szóval lenne szemtelen a malloc, hogy egy \ 0
a végén minden csonkot memória ez így
mert ez a \ 0 dolog csak egy egyezmény szálakat.
Ez nem használt ints, ez nem használt úszók, ez nem használják a diákok számára.
És így a megvagy a malloc, hogy a teher teljes egészében maga a programozó
emlékezni, hogy hány bájt te kiosztott és nem valaha is használni a for ciklus
vagy a while ciklus, és megy tovább az határa darab memória, amit kapott.
Másképpen fogalmazva, amint memóriát,
nem lehet kérni az operációs rendszer, ó, az úton, mekkora egy darab memória volt ez?
Ez teljesen rajtad múlik, hogy emlékezzen, ha kell ezt az értéket.
>> Nézzük, hogyan folytassa ezt a memóriát.
A vonal 28 és 29, miért csinálom ezt?
Csak teljes józanság csekket.
Csak abban az esetben valami baj, kérem néhány őrült mennyiségű memóriát
vagy már olyan sok dolog fut a számítógépen, hogy nem elég memória,
valami ilyesmi, én legalább akarom, hogy ellenőrizze a null.
A valóságban a legtöbb számítógép megadja az illúziót, hogy minden programot
Használhatja a teljes a RAM,
de még így is, ha a felhasználó beír néhány őrült hosszú sora talán azért, mert ők a rosszfiú
és ők tényleg megpróbálja összeomlik a program, vagy hack bele,
azt szeretnénk, hogy legalább ellenőrizze a visszaadott érték malloc valamint hogy egyenlő null.
És ha ez így van, nézzük csak kilép most, mert nem tudom, mit kell tenni ebben az ügyben.
Hogyan lehet átmásolni a húr? Van néhány módszer, hogy ezt megtehesse.
Vannak str bemásolod funkciók C, de ez szuper egyszerű számunkra, hogy ezt a régi módon.
>> Először is hadd kitalálni, hogy mi a hosszú s.
Tudtam volna, hogy ezt a hurok, hanem csak tedd ide az egyértelműség kedvéért.
Így N most tárolja a hosszát az eredeti szöveg, ami látszólag 5.
Aztán én a hurok Én iterációjával 0-tól a maximum n,
és minden iteráció leteszem s [i] belsejébe t [i].
Szóval ez az, amit az én hallgatólagos 2 ujjal mutatott a húrok előtt.
Mivel ez a for ciklus végigmegy, mint ez, én leszek másolás h be itt,
e-ba itt, l bele itt, mert ez az s, ez t.
És végül, a 35. sor, miért csinálom ezt?
Meg kell, hogy megbizonyosodjon arról, hogy én vagyok véget a húr t.
És én ezt így is szuper explicit.
De javaslom, hogy valaki, ha tehetném, egy másik módja ennek.
Nem igazán szükséged sor 35. Van egy másik módja ennek.
Igen. >> [Hallhatatlan tanulói válasz] >> Mondja hangosabban.
[Hallgató] Kisebb vagy egyenlő. >> Pontosan.
Így egyszerűen mondjuk kisebb vagy egyenlő, mint N, amely általában már rossz
mert majdnem mindig, amikor felmegyünk egyenlő a dolog, mi számlálás
megyünk 1 lépés túl messzire.
De ne felejtsd el, hogy hány bájt tudtunk kiosztani?
Mi kiosztott strlen S, így 5 + 1-es összesen 6.
Tehát ebben az esetben tudnánk tenni valamit, mint ez
hogy mi vagyunk másolást nem csak a hello, hanem a \ 0 a legvégén.
Alternatív, tudtuk használni a nevezett funkció str másolás, strcpy,
de ez nem lenne közel annyira szórakoztató.
De ez minden, ez alatt a háttérben.
Aztán végül, mi nem ugyanaz a dolog, mint korábban.
Én aktiválja t és aztán azt állítják, hogy az eredeti így néz ki, és a másolatot néz ki, hogy.
Szóval próbáld ezt most. Hadd menjek ide. Gyártó copy2. Majd nagyítás és fuss copy2.
Megyek írja hello kisbetűs, sőt kapok kisbetűs helló, mint az eredeti
de a tőke Hello for a másolatot.
De én nem csináltam csak még. Kell tennem 1 utolsó dolog itt.
46 és 47 egyértelműen felszabadítása memóriájába, de mit is jelent ez valójában?
Mit csinálok, mit gondol, a hívó vonal 46 és 47. sor?
Milyen hatással van, hogy van? Igen.
[Hallhatatlan diák válasza] >> Pontosan.
>> Te csak azt mondom az operációs rendszer, hé, köszönöm ezt a memóriát.
Most már használhatja azt valaki másnak.
És itt van egy tökéletes példa szemetet értékek.
Épp most használta ezt a memóriát, hogy írjuk le a szót hello 2 helyen,
itt, itt, itt, és itt.
Tehát ez az e-h-l-l-o-\ 0.
De aztán hívom vonal 46 és 47. sor, és tudod, hogy mi történik ott szempontjából a kép?
Igazából, várj, ez a kép a régi.
Amint tudjuk, hogy a másolatot, ez a fickó valójában mutat itt,
úgyhogy vegye le a számokat, és csak elvont idegenben, mint a mi nyilak újra.
Mi történik ezen a képen, amikor hívom szabad?
[Hallhatatlan diák válasza] >> Nem is.
Ha hívás ingyenes s és t - egyfajta beugratós kérdés - ez a kép nem változott
mert a hívó s és felhívta t, csak azt mondja az operációs rendszer,
Hé, akkor használja ezt a memóriát újra, de ez nem változtat a null
vagy néhány speciális karakter, ez nem változtat ezen,
ez nem változtatja meg a h vagy az e vagy az l vagy az l vagy az o mindkét helyen mást.
Ami a kép, amint a hívás ingyenes, semmi nem változik.
És ebben rejlik az eredete szemetet értékek mert ha később ebben a programban
kérje az operációs rendszer több memóriát getString vagy malloc vagy valami ilyesmi
és az operációs rendszer azt mondja, persze, van 12 bájt memóriával csak felszabadult,
használja ezeket, mit fog adni?
Fogsz kell adni egy darab memóriát, hogy mi lenne jellemzően döntetlen
A kérdőjelek, de mik azok a kérdőjel?
Is legyenek h-e-l-l-O, H-E-l-l-o.
Ezek az új szemeteskocsi értékeket amint felszabadítani, hogy a memóriát.
>> Van egy valós hatása itt is.
Ez történik köze RAM-mal, de a számítógépek
ténylegesen ugyanezt lemez.
Majd megbeszéljük, különösen a jövőbeli probléma halmaz összpontosít kriminalisztika.
De hogy valójában mi történik, ha van néhány érzékeny pénzügyi fájlba az asztalon
vagy néhány vázlatos JPEG és húzza be a szemetet,
mi történik, ha húzza be a szemetet, vagy a kukába?
Tudtad, amit én beszélek. [Nevetés]
Mi történik, ha már húzni a bizonyítékok be a Lomtár vagy kuka?
[Hallhatatlan hallgatói válasz]
Nos, ezért óvatos. Mi történik, ha nem ezt?
A rövid válasz: nem, nem igaz?
Sketchy vagy kényes fájlt, még mindig csak ott ült valahol a merevlemezen.
A legtöbben legalábbis kárán tanulta meg, hogy meg kell kiüríteni a szemetet
vagy a Lomtár, hogy valóban törölni fájlokat.
És valóban, ha jobb gombbal vagy a Control kattintás a kukába
vagy válassza a Fájl Kuka ürítése vagy bármi
és valóban ürítse ki a kukába vagy a Lomtár, hogy valójában mi történik azután, hogy ezt a képet?
Tovább semmit. Tehát semmi ténylegesen történik a lemezen.
>> És ha csak ideiglenesen elkalandozik és írni - I'll csak használja a hátoldalán.
Tehát most a történet változik RAM, ott, ahol programok léteznek
közben futás őket, lemez, ott, ahol azokat tárolják hosszú távú
akkor is, ha a hatalom kimegy, mert most - és mi jön vissza erre a jövőben -
mondjuk csak úgy, mintha ez jelenti a merevlemez belsejében a számítógép
mert vissza a nap régen kör alakú lemez, akárcsak floppy lemezre.
Szóval, ha van néhány érzékeny Excel fájlt, előfordulhat, hogy vegye fel ezt a darab memória
a számítógép lemez, és én csak rajz ugyanolyan önkényes 1 és 0.
Ha húzza a fájlt így a szemetesbe vagy a Lomtár,
Szó szerint semmi nem történik, mert az Apple és a Microsoft most úgy határozott,
a kukába, és kukába tényleg csak átmeneti helyőrző.
Lehet, hogy végül az operációs rendszer ürítse ki az Ön számára, de általában, nem csinál semmit,
legalábbis addig, amíg te tényleg kevés a hely.
>> Azonban, ha megy üres kukába vagy üres kukába,
hasonlóan, nem történik semmi, hogy ezt a képet.
Minden, ami történik, máshol van a számítógép, van valami táblázat.
Ez a fajta, mint egy kis puskát, hogy azt mondja, hogy, mondjuk, resume.doc,
így az önéletrajz egy Microsoft Word fájlt éltek a helyszínen 123 a merevlemezen,
nem a memóriában, és nem a RAM-ban, hanem a merevlemezen,
és a vázlatos JPEG életét 456, és az Excel file lakik 789 vagy bárhonnan.
Amikor törli a fájlokat ténylegesen a kuka kiürítése közben, vagy a Lomtár,
ezt a képet nem változtatja meg. A 0s és 1s a merevlemezen nem mennek sehova.
De ez asztal, ez a kis adatbázis fajta, nem változnak.
Ha törli önéletrajzát, az olyan, mintha a fájl törlésre kerül bizonyos értelemben,
de a számítógép nem is elfelejti, ha ez a dolog él a merevlemezen.
A 0s és 1s alkotó önéletrajzát, vagy bármely más, ezek a fájlok még mindig érintetlen.
>> Tehát, ha véletlenül tette ezt, még mindig nem nulla valószínűség
hogy akkor vissza az adatokat a Norton Utilities vagy valamilyen kereskedelmi szoftver
amelynek célja az életben, hogy megtalálják 0s és 1s, hogy a fajta nem árva,
Elfelejtettem, de itt marad itt, hogy lehet kapni az adatokat vissza.
Vagy törvényszéki nyomozók számára a rendőrség vagy az FBI valójában, hogy egy merevlemez
és valójában keresnek minták 0s és 1s, hogy néz ki, mint JPEG, néz Excel-fájlokat,
és vissza őket, így még akkor is, ha a számítógép elfelejtette őket.
Tehát az egyetlen módja valóban az adatok törlésére, mivel megbeszéljük a jövőben,
hogy dörzsölje vagy törölje a fájlt vagy a merevlemezt -
Nem igazán lehet megszabadulni a 0s és 1s
mert különben azt kezdeni egy gigabájtos merevlemez
és azt a végén egy megabájtos merevlemez, ha állandóan arra törlés,
szó 0s és 1s.
Szóval, mit tennél, ha nagyon akartam, hogy fedezze a számokat
és az alapvető probléma az, hogy még mindig van 0s és 1s a lemezen?
Látom valaki gesztikuláló, hogy akkor fizikailag megtörni a készüléket. Ez működni fog.
[Nevetés] De ha ez ilyen drága megoldás, mi lenne ésszerű?
Igen. >> [Hallgató] Felülírás őket. >> Felülírása őket mi? >> [Hallgató] Egyéb adatokat.
Egyéb adatok. Tudod csak felülírja a lemezen vagy 0s 1s vagy minden 0s, minden 1s.
>> És ez valóban, amit néhány a szoftver nem.
Lehet vásárolni szoftver is kap szabad szoftver,
és még beépített Mac OS manapság kevesebb, így Windows,
az a képesség, hogy biztonságosan törölni.
Igazából, ha azt szeretnénk, hogy az összes run haza ma, ha van egy Mac, és ezt,
ha van néhány dolog a szemetes, meg tudod csinálni Secure Empty Trash,
amely nem pontosan ezt.
Ahelyett, hogy csak törli a fájlokat ide, nem törli a 0s és 1s itt,
igen, ez csak megváltoztatja őket, például arra, hogy 0s és pont, pont, pont.
Tehát az egyik a jövő psets valóban lesz szándékosan visszaállítani az adatokat -
fényképeket, hogy már megtett az emberek, helyek és dolgok az egyetemen
amelyhez megpróbáljuk egy törvényszéki kép egy digitális fényképezőgép memóriakártyáját,
amely pontosan ugyanezt a gondolatot -, és akkor meg kell, hogy valóban kihívást találni
a mintákat, hogy képviselje JPEG a merevlemezen,
nagyon hasonló volt diák, akinek az e-mailt olvastam néhány héttel ezelőtt volt
vissza húga fényképek.
Miért nem veszünk egy 5-perces szünet van, és mi összefogja több a memória.
Tehát itt, ahol a dolgok egy kicsit pszichedelikus, de ez egy nagyon erős lépés
megértése felé ez annál inkább.
Itt van egy program neve pointers.c.
Ez az egyik a mai minta kódját.
Figyeljük meg, hogy az első pár sort, 19. és 22., Az összes csinálunk valami hasonló getString
és a visszatérő egy címet, tárolása azt s.
Ezentúl a Pset akár 3 ha akarsz, de Pset 4 és
ahol meg lehet kezdeni, hogy ezeket a képzési kerekekkel magad,
nincs ok azt állítani, hogy karakterláncokat létezik többé.
Ez természetesen rendben van, hogy csak elkezd mondani char *.
>> Mint félretéve, az online hivatkozásokat és a könyvek is gyakran látni a csillag mellett a változó.
Lehet, hogy még látni terek körül mindkét oldalát is.
Minden ezek funkcionálisan helyes.
Most azonban, mi szabványosítása e megközelítést a szuper világos
hogy a char * olyan, mintha azt mondanánk karaktert mutató.
Ez az adat típusát.
És akkor a neve a változó s ebben az esetben.
Így már ütött egy string, és mi már nevezte s.
És akkor itt lent észre, hogy csinálok valójában egy kis trükk.
Ezt hívják pointer aritmetikai, amely egyfajta szuper egyszerű.
Ez csak azt jelenti, összeadni és kivonni számokat mutató.
De ez tényleg működik.
Ez a program nyilvánvalóan kiírja az s karakterláncot 1 karakter per sor oly módon, hogy a végeredmény -
Csak így tudjuk elrontani ha ez megy, hogy a mutatók, fuss mutatókat, hadd Nagyítás
Most hadd írja valami ilyesmi HELLO és típus megadása
és kiírja 1 karakter soronként.
Egészen a második napja, már megtette volna ezt a szögletes zárójel jelöléssel.
Mi volna a for ciklus, és megtennék printf az s [i], és mi volna csinálni újra és újra és újra
egy backslash n végén minden sorban.
De ez a program más. Ezt a programot használja, szó szerint, számtani.
Szóval, mi folyik itt?
Először is, még mielőtt ez a ciklus végrehajtja, amit, csak hogy tisztázzuk, van s valójában?
S? >> [Hallgató] Egy cím. >> Egy cím.
>> És ez a címét, esetében szia, az első karakter azt szó, ami a h.
Így S, ebben a konkrét példában a címét a h.
Szóval, mit is jelent a teendő s + i?
Nos, én 0-tól indul ebben a ciklusban. Megcsináltuk, hogy sok alkalommal.
Úgy fog felmenni a hossza a string, látszólag.
Tehát az első iterációs e hurok i nyilvánvalóan 0.
Tehát ez a kifejezés azt mondja, s + i - inkább, s +0--ez nyilvánvalóan csak s.
Tehát mi * s itt?
Most már használja a csillag kissé eltérő módon.
Hadd menjek előre, és megszabadulni t, mert készen vagyunk beszélünk t és másolatait s.
Most már csak azt szeretném elmondani a történetet magában foglaló s.
És ebben a pillanatban, miután string típusú, a világ úgy néz ki, elég, mint előtte
mindössze s tároló címe h és általában mutat a húr hello.
Ha most nem egy sort * (s + i), próbáljuk ki ezt.
Így * (s + i). Hadd egyszerűsíteni, mert ez 0, tehát ez * (s +0).
Nos, várj egy percet. Egyszerűsítse tovább. Ez * (k).
Nos, zárójelben a fajta ostoba, így most nézzük csak ezt * s.
Tehát az első iteráció e hurok, hogy a vonal, ami kiemelt, 26,
nagyjából egyenértékű nyomtatás ezt.
Mi az adattípusa * s?
Ebben az összefüggésben, mivel a csillag történetesen mellett a s maga,
de konkrétan, mert már nem nyilvánító s,
nem vagyunk létre egy változót többé, nincs említés a char * sorban 26,
nincs említés a kulcsszó string, mi csak egy változót nevű s,
kiderült, hogy most a csillag kissé eltérő, és kétségkívül zavaros jelentését.
* S itt azt jelenti, menj a cím s és nyomtatási bármi van.
Tehát s itt van, * s - fajta, mint Csatornák és létrák, kövesse a nyíl - itt.
Szóval ez * s.
>> Szóval mi lesz nyomtatva az első iterációs e hurok sorban 26?
Én kinyomtatni% c, amely a helyőrző egy karaktert,
akkor a \ n az új vonal. * (S + i) ahol i értéke 0, csak ez a.
Szóval mit char tudok helyezni a% c? H.
A következő iteráció a hurok -, akkor valószínűleg látni, ahol ez megy -
a következő iteráció i nyilvánvalóan 1, tehát ez azt jelenti, s +1,
és akkor most nekem kell a zárójel, mert most a csillagot kell mondani
megy memória cím s +1.
Mi s? Menjünk forgassa vissza az időben, és azt mondják, ez a nyíl most valójában nem tesz nekünk szívességet.
Legyen ez pontosabban azt, hogy ez tárolja a száma 123
mivel a kezdetétől húr szia, ez cím 123, ez a 124, és így tovább.
Így a második iteráció amikor mondom s +1, ez, mintha azt mondanánk 123 +1,
más néven 124, akkor mi char lesz nyomtatva a második iteráció?
E at memóriacím 124.
Aztán megint +, 125, 126, 127, és ez a loop szerencsére abbahagyja, mielőtt ideérnek
mert én vagyok a strlen hogy győződjön meg arról, hogy én nem számít túl magas.
Tehát ez is azt.
Ez megint csak, mintha tette egy héttel ezelőtt.
Hadd írjam meg a vonal alatti bár nem akarunk csinálni mindkettőt.
Ez megegyezik most ezt.
>> Így annak ellenére, hogy s egy string, ahogy már nevezni hetek, s valójában egy char *.
Tehát, ha azt akarjuk, hogy szuper anális, ez tényleg helyes, hogy írjon a különleges tulajdonságokra
az i-edik helyen ezekkel a numerikus címeket és e csillag üzemeltető,
de őszintén szólva, ez annyira sokkal tisztább. Tehát ez nem rossz.
Nincs ok arra, hogy abbahagyjuk line 27 itt, de 26 funkcionálisan azonos,
és ez funkcionálisan megegyezik pontosan az okokat, hogy mi már beszélünk eddig.
És végül, 29 csak helyes gyakorlat.
Hívása ingyenes s azt jelenti, hogy most adsz vissza a memóriát getString adtam neked
mert megint, mint már említettem, hétfő getString hetekig
került bevezetése hiba be a kódot.
A kód a héten volt memóriavesztés
ahol voltál kér getString a memóriakártyák esetében, de te soha nem ad vissza.
És hogy szándékosan választott minket pedagógiailag
mert túl sokat gondolkodni korán.
De most több kell szimmetria.
Ha megkérdezzük a számítógép memóriája, mivel a helyzet a getString,
ahogy ez a helyzet a látszólag malloc,
muszáj most Pset 4-től kezdődően is szabad ilyen memóriát.
Figyeljük meg ez eltér mond int n.
Nem kell, hogy szabad, mert nem hívtál getString
és te nem hívja malloc.
>> És még ha a hívott getInt mivel mi végül látni,
GetInt nem memóriát, mert akkor valóban át körül egész
és az úszók és a karakter, ahogy mi már ezt hetekig.
Strings, mégis, vannak különleges, mert valóban ők a összefűzése több karakter.
Így ők csak más karakter, és úszók és ints és hasonlók.
De mi jön vissza, hogy mielőtt hosszú.
Van még kérdése, akkor ebben a kezdete mutatók? Igen.
[Hallhatatlan diák a kérdéshez]
Ah, nagyon jó kérdés.
Az egyik pár dolgot C valójában mire való az Ön számára, mely kényelmes,
van, hogy kitalálja, neked mi a mérete az adattípus
majd nem, hogy ilyen szorzás az Ön számára.
Ez irreleváns abban az esetben, karakter, mert szinte mindig char 1 byte,
így ez csak működik.
De a vita kedvéért, ha ténylegesen nyomtatás egészek
és meg akarták kinyomtatni valamilyen érték s hogy mutatott egy egész szám,
Ön szintén nem kell tennie, + 4 * i, csak azért, mert egy int 4 bájt.
Pointer számtani azt jelenti, hogy a C és a fordító mindent megtesz, hogy matek az Ön számára.
Mindössze annyit kell törődnünk kell a fajta elszámolást az emberi értelemben. Igen.
[Hallgató] Ha nyilvánítja egy string belsejében egy for ciklus, van, hogy szabad később?
Jó kérdés.
>> Ha a bejelentett egy string belsejében a for ciklus, akkor kell felszabadítani később?
Csak akkor kell a szabad memória, hogy osztja a getString vagy malloc.
Tehát, ha csak mondj valamit, mint - hadd fogalmazzak kapcsos zárójelek most így az összes kódot kapcsolódik.
Ha csinált valamit, bár buggily, mint ez, char * t = s,
Önnek nem kell a szabad t, mert t nem járt semmilyen említést a malloc vagy getString.
Ezzel szemben, ha ezt tetted, getString, akkor igen, akkor kell a szabad t.
És valóban, az egyetlen esélye, hogy az, most már ezen belül hurok, az azonos kérdését hatály
, hogy már tárgyalt a múltban.
Ellenkező esetben lenne elosztása memória, elosztásának memória, elosztásának memória,
és a végén a program, mert te túl a hurok,
t nem létezik, de soha nem mondta az operációs rendszer
hogy nem kell, hogy a memória már.
És mielőtt hosszú, Pset 4 vagy 5 mi felvértezzük Önt a program neve Valgrind,
amely hasonló szellemében GDB, mivel van egy kissé misztikus interfész,
de a célja az életben, hogy segítsek.
És Valgrind egy olyan program, amely a jövőben keresni a programok
keres memóriavesztés, akár a getString vagy malloc,
amely akkor kezdi el használni annál is inkább, ahogy abbahagyja a CS50 könyvtár sok.
Végre most már valami a szókincs és a fajta mentális modell elmélet
amellyel megoldani ezt a hibás programot.
>> Tehát ebben a hibás programot, swap gyártelepi belül swap,
de ez soha nem működött, mert fő fő átadott x és y, visszahívása,
illetve fogadtak el az értékek, hogy úgy mondjam.
Másolatai közülük adott cserélni.
Végére a swap, a és b valóban kicserélt,
de természetesen x és y, ahogy megbeszéltük, hétfőn nem volt.
Úgyhogy azt javaslom, zöld itt, hogy ez valójában a megoldás itt.
És valóban, hadd mozgatni a csillagok, csak hogy összhangban legyenek
még akkor is, ismét, funkcionálisan ez nem számít.
A jövőben hetekben elmagyarázzuk, hogy mikor és miért nem számít.
Így a zöld most egy megoldás.
Őszintén szólva, úgy néz ki, egy csomó messier, mert minden a csillagok.
Hadd rámutatni egy dolog.
A felső sorban van, ha azt mondja, int * a és int * b
alapvetően ugyanazt a dolgot, mint mindig.
Ez nyilvánító 2 érveket vagy paraméterek a swap,
amelyek közül az első egy int mutató úgynevezett,
amelyek közül a második egy olyan int mutató b néven.
Az egyetlen dolog, ami új, ezen a ponton az a tény, hogy van egy csillag van.
>> Mit jelent ez? A nem int, b nem int.
A jelentése a címben szereplő int és b a címe, egy eltérő int.
Itt lent, ez az, ahol bevallom C lesz zavaró.
Most már egy csillag, de ennek más jelentése ebben az összefüggésben.
Mert mi nem nyilvánításáról mutatók, mint mi itt,
itt vagyunk dereferencing dolgokat.
Szóval technikailag, a csillag ebben az összefüggésben az első, második és harmadik vonalbeli belül csere
ki a dereference operátor, ami csak annyit jelent, hogy ott.
Szóval, mint az ujjam követte a nyíl h,
* Eszköz megy, hogy a cím és találja meg az int, hogy ott van.
* B úton megy a címre, és adja át, hogy mi van ott.
Szóval dolgozza át a képet, hétfőtől már egy halom keretek,
az alsó amelyek közül az egyik legfontosabb lesz,
a felső amelyek közül az egyik lesz csere,
annak érdekében, hogy világunk úgy néz ki, mint hétfőn, mint ez.
Itt van egy darab memória fő fog használni.
>> Emlékezzünk vissza, hétfő, hogy a program csak volt 2 változó,
egy úgynevezett x és egy y hívott, és én fel a számokat 1 és 2 is.
Most, amikor hívom cserélni, mint én, hétfőn,
korábban, amikor használják a piros változata a program, ami úgy néz ki, mint ez,
Van 2 paraméter, a és b, és mit írunk itt és itt?
Csak az 1. és 2., szó szerint másolatait x és y.
Ma már változtatni.
Ma ahelyett, hogy halad ints és b fogunk átadni a 2 címeket.
Ezek a címek megtörténhet, hogy pont ints, de a címek nem ints magukat.
Ezek a címek. Olyan, mint egy postai címet helyett.
Tehát most meg kell, hogy csak így magamnak egy kicsit részletesebben a képernyőn.
Ez az én számítógép memóriájában, mint volt egész nap.
Most arra van szükség néhány önkényes számozási rendszert.
Akkor mondjuk, csak véletlen, hogy ez a memória cím 123, 124.
Mondjuk ez a 125, ez a 126, és így tovább, de ez teljesen önkényes.
Csak kell egy kis számozási rendszer az emlékezetemben.
Így most, amikor valóban át az x és y, nem megyek át az x és y;
Megyek át a postai címet, hogy úgy mondjam, az x és az y
annak érdekében, hogy mi lesz az itt tárolt és itt nem az 1. és 2.,
de ha látom a kis szöveget, mi lesz telt el itt és itt?
[Hallhatatlan diák válasza] >> Pontosan. 123 kerül fel ide, és 124 lesz fel ide.
>> Nos, azért, mert használt a csillag ebben a legelső sorban egészen itt top,
a program csak tudja, hogy a 123 és 124, annak ellenére, hogy nyilvánvalóan egészek
hogy minden ember is észre, azokat úgy kell értelmezni, címek numerikus címeket.
Ezek nem önmagukban és önmaguktól ints, ők címek,
és ez azért van, mert én kifejezetten fel a csillagok ott.
Tehát most az én első, a második és a harmadik sor tényleges kódot, hogy mi történik itt?
Nézzük felhívni a többi kép.
Tmp olyan, mint volt hétfőn. Semmi különleges tmp.
Ez csak egy helyi 32 bites változó, és belül, hogy én vagyok látszólag tárolása értékét * a.
Most, ha csak azt mondta tmp = a, mit tettem ide? >> [Hallgató] 123.
123. De ez nem az, amit csinálok.
Azt mondom tmp = * a. Csillagok úton menni.
Tehát itt van egy, 123. Hogyan menjek oda? Úgy tenni, mintha van egy nyíl.
Nos, itt van, 1. Szóval mi lesz tárolva tmp, látszólag? Csak 1.
Más szóval, a tmp * a * eszköze menj a címet jelenleg egy,
ami látszólag 123.
>> Oké, itt vagyunk a helyszínen 123, látom az 1-es szám,
így fogom fel a 1-es szám van.
Most mit tegyek sorban 2, * a * b =?
Ez egy kicsit nagyobb szerepet, mert most mi is az? Ez 123.
Szóval * a, ahol? Ott, ahol voltam. Akkor menj oda. Oké.
Nos, végül, és végül ez kezd értelme, remélhetőleg,
* B: a mi van b? 124. Szóval kell mennem oda, amely 2.
Szóval, mit tettem, ahol?
2 megy itt, mert * b * bemegy a. Így fogok tenni.
És akkor már látni, talán, hogy mi vagyunk annyira közelebb
megoldása ezt a hülye, egyszerű problémát helyesen az első alkalommal
mert most még mindig van egy emléke, mi volt az x,
van 2 példányban, igaz, az y,
de 3 sor most azt mondja, * b.
Tehát itt b. * B úton menni. Szóval hol van helye 124?
Ez látszólag van. Szóval mit tettem ide? Nyilvánvaló, tmp.
Szóval most ezt. Szóval itt van 1 és 2 itt.
És most mi van erre, a 123, a 124 és az 1?
Amint csere visszatér, ez a memória jó, mint vereség
mert amint swap-visszatér, az operációs rendszer
szabadon használhatja, hogy a memória a jövőben újra.
Egyetlen főbb memóriájába alján ezt az úgynevezett verem stick körül.
>> És így végre most már egy működő változat.
Hadd menjek be swap.c, és vegyük észre a következő.
A tetején a program, amit megváltozott a prototípus is int * a és int * b.
Tehát az egyetlen dolog, amit változott, hogy menjen a vörös, ami rossz volt, a zöld, ami jó,
az Én hozzá ezeket a csillagokat ma.
De aztán meg itt a csereügylet kellett másolás, beillesztés, mi csak a dián.
Nekem van egy csillag itt, csillag itt -, amely megfelel a prototípus -
majd az összes ezeket a dolgokat most csillagos kivéve tmp
mert a ideiglenes változó, nincs semmi új nincs.
Csak kell az átmeneti tárolás int.
Tehát nem kell a csillag ott.
Már csak be kell a csillag, hogy mi is át ezt a fajta önkényes határ
között 2 kép a számítógép memóriájában.
De egy utolsó dolog, amit meg kell változtatni, és lehet, hogy megpillantott már.
Milyen más vonal nyilvánvalóan más most? >> [Hallgató] & x.
>> Igen, 25 az utolsó sort úgy kell változtatni, hogy ez működik.
Egy héttel ezelőtt, és még hétfőn 25 vezetéken nézett ki, mint ez, csere x és y,
és ez csak törve, mert ha azt mondod, swap (x, y)
adsz másolatait x és y, hogy a csere, akkor csinálja a dolgot,
de te sosem változik x és y is.
Tehát akkor is, ha még soha nem láttam ezt a karaktert, mielőtt a jel a kódot,
Csak egy tipp. Mit csinál a jelet csinál, látszólag?
[Hallgató] úgy a címet. >> Azon a címet.
Tehát a jel mondja nekem a címét x.
Ki tudja, hol van? Előfordul, hogy 123. Nem érdekel. Csak add ide a címét x.
És y jelenti nekem a címét y.
És ezen a ponton a történet tökéletesen összhangban van a képen is rajzolt egy pillanattal ezelőtt.
>> Szóval Bevallom mutatók, természetesen számomra, amikor először kezdett tanulni ezt,
volt, határozottan az egyik legnehezebb dolog, hogy betakar a fejemben körül.
De észre, különösen tartjuk játszani ezeket a dolgokat,
ha lebontani ezeket szuper egyszerű fajta intellektuálisan érdektelen problémák
csupán mozgó számok körül, a válasz a sok zavart mutató
Tényleg lehet ezekből a nagyon alapvető mechanika.
Itt a cím. Menj oda a csillagot.
Vagy fordítva, itt egy jelet. Kitalálni, mi a cím valójában.
Rendben van.
Szóval, ha ez minden a memória jön?
Már húzott ehhez a képhez egy párszor, és azt folyamatosan ígéretes fogunk visszatérni rá,
de itt van képviselete a számítógép memóriájában
ez egy kicsit több, mint a táblán jelzett itt.
A szöveg részes csúcson képviseli, amit tekintetében a program?
[Hallhatatlan diák válasza] >> Tessék? Mondd újra.
[Hallgató] A tényleges program. >> A tényleges program.
>> Tehát a 0s és 1s hogy már összeállított kiírása után a C kódot, majd futás csenget
és a termelő 0s és 1s végül egyre gyűrve ott a memóriában
mert ha duplán kattint egy ikon a Mac vagy PC
vagy futtatni egy parancsot, mint a Mario az Ön gyors, a 0s és 1s lemezről
kap betöltődik a memóriába, így a számítógép képes manipulálni őket
és végrehajtja azokat gyorsabban.
Szóval inicializált adatok és inicializált adat, akkor nem beszélünk sokat ezekről,
de ezek csak globális változók.
Inicializált jelenti, globális változók, hogy adott értékek;
inicializált globális változók jelenti, hogy még nem ad értékeket.
Aztán ott van ezeket a környezeti változókat, amelyek leszek teljesen hullám kezem,
de ott vannak, és hogy tárolja dolgok, mint például a felhasználó nevét
és más fajta alacsonyabb szintű részletek.
De juiciest darab a memória elrendezését ez a dolog az úgynevezett stack és a heap.
A verem újra, hogy egyértelmű, az a memória, ami használni, amikor függvények,
ha vannak lokális változók
és ha vannak paraméterek továbbadása körül.
Minden, ami történik a veremben.
A kupac még nem beszéltünk róla, de hogy egy kitalálni, aki használja a kupac.
Csak egy másik darab memória.
Előfordul, hogy Megemlítendő a tetején, de ez egy tetszőleges képi egyezmény.
Ki látszólag használ memóriát a heap hetekig?
Ez technikailag úgy, de közvetett módon. >> [Hallgató] getString.
GetString és malloc. Szóval itt van az alapvető különbség.
>> Tudod, hogy az elmúlt hetekben, hogy ha szüksége van memória, csak, hogy egy változót.
Ha szüksége van sok memória, állapítsa meg egy sor jogot belsejében a funkció.
De a probléma általunk vezetett szemben az, ha kijelentem változókat helyi belső funkciók,
amint a függvény, hogy mi történik a memória és azokat a változókat?
Csak valami, hogy ez már nem a tiéd, ugye? Csak eltűnik fajta fogalmilag.
Még mindig ott fizikailag, természetesen, de ez már nem a jobb használni.
Ez nyilvánvalóan problematikus, ha azt szeretné, hogy írjon funkciók életben
hogy valóban memóriát, és nem adja vissza azonnal.
Case pont: getString célja az életben, hogy fogalmam sincs, előzetesen
mekkora egy string fogok, hogy írja meg a billentyűzetet,
de van, hogy képes legyen a memóriát, hogy tartsa David vagy helló
vagy egy egész esszé, hogy a felhasználó esetleg gépelt be
Szóval getString már használja malloc.
Malloc ezért kell használnia nem verem;
helyette ez használatával ez a dolog az úgynevezett kupac.
Nincs semmi más, ami a memóriát. Ez nem gyorsabb vagy lassabb, vagy ilyesmi.
Ez csak fizikailag egy másik helyre.
>> De a szabály az, hogy a memória, ami kiosztott a heap
soha nem fog elvenni, amíg a hívás -, hogy egy találgatás - ingyenes.
Ezzel szemben, minden memória kérsz a verem mellett csak nyilvánításáról tömb
vagy nyilvánító változó mintha csináltam a héten
hogy alapértelmezés szerint végül a verem.
És ez remekül működik 90%-át az idő, de ezek ritkábbak alkalommal
ahová a memóriát és tartsa körül,
akkor kell használni a funkciót, mint a malloc.
Vagy már használják egy függvényt, mint getString, ami használ malloc.
Lássuk, ha ez esetleg lebontják, és akkor fog egy kandikál Muci.
Majd gyere vissza, hogy a jövőben.
Itt van egy szuper egyszerű program, hogy az első 2 sor mit csinál?
In English, mit ezek első 2 sornyi kódot do belsejében fő?
[Hallhatatlan hallgatói válasz]
Óvatosan. Nem adja meg a címet az x vagy y.
[Hallgató] ad mutatókat ints. >> Jó. Adj nekem 2 mutatókat egészek.
Más szóval, add nekem 2 darabokat memória tartom rajz ma,
bár én törlik most, mint négyzetek.
Adj nekem 2 darabokat a memória, az egyik neve x, az egyik neve y -
korábban felhívtam őket s és t -, és mi az a fajta, hogy a darab a memória?
Ez lesz tárolni egy címet.
Ez a típusú int *.
>> Így a cím egy int-utóbb élni x,
a cím egy int-utóbb élni y,
de kezdetben, mi van benne az x és y? Ki tudja? Garbage értékeket.
Ennek semmi köze a mutatók.
Ha nem tesz valamit ott, ki tudja, mi van valójában ott?
Most, x. Mi történik itt? Ez legális most, mert x egy mutató. Ez egy int *.
Szóval ez azt jelenti, hogy meg tudja fogalmazni az x címét néhány darabja a memóriát.
Mit jelent a malloc vissza? Tökéletes, visszatér címek,
a címe az első byte egy egész darab memória.
Hány bájt van ez látszólag elosztására, például a készülék?
Mi a mérete int? 4.
Ha úgy gondolja, vissza hét 1, nem szuper fontos, hogy mindig emlékezni, hogy a
de ebben az esetben ez hasznos lehet tudni, 4 bájt.
Szóval ez a felosztása a heap 4 byte
és ez visszatérő a címe az első nekem önkényesen.
Nos, mi x csinál?
A * x = 42 mit csinál?
Ha ezen a ponton a történet van x, ami úgy néz ki, mint ez némi szemetet érték,
ez most y némi szemét érték, most 3-as vonal, amit kiosztott 4 byte.
Ez a kép lényegében úgy néz ki, mint ez.
Vagy még pontosabban, ha ez az önkényes címe 123, ez az, amit a mi történetünk így néz ki.
* X = 42 most mit jelent? Ez azt jelenti, megy a 123 címre, és tegye a szám 42 van.
Nem kell felhívni ezeket a sorokat, mert mi nem csinálom szálakat.
>> Kellett volna, csak írt, mint ez, és csak demonstrációs kedvéért,
42, mint egy int típusú vesz fel egy csomó hely, 4 bájt.
Szóval ez az, mi történt ott, de van egy kis gond van.
* Y = 13. Mi fog történni itt?
A probléma * y a mi egyszerűsített világban, csak azt jelenti, megy a címet y.
Mi van y? Ez valami szemetet értéket.
Tehát tegyük fel, hogy ez a szemét az érték 5551212, valami őrült ilyesmi.
* Y úton megy, hogy foglalkozzon 5551212.
Ez olyan, mint itt. Nem létezik, például.
Szóval * y jelentkeznek 13 segítségével próbálom felhívni 13 itt. Ez nem létezik.
Már meghaladta a szegmens a táblára. Mit kapok?
Ez a rejtélyes üzenetet szegmentációs hiba, mert próbálok tenni a memóriában
érték, mint 13 olyan helyen, amely nem létezik.
A többi program működhet rendben van, de addig, amíg ezen a ponton nem.
Így próbáljuk elmondani ezt a történetet.
Majd gyere vissza, hogy egyszer mi már beszéltünk hex.
Térjünk vissza erre, és arra, ezt a dolgot nevezett Muci,
amely visszahívás a Stanford professzora ül otthon játszó claymation,
hogy elmondja a történetet, hogy pontosan ugyanazt a programot.
Ez csak kb 3 perc hosszú. Itt van Muci.
[Hím hangszóró a videó] Hé Muci, kelj fel. Itt az ideje a mutató fun.
[Muci] Mi ez? Tudjon meg többet a mutatók? Oh, nagyszerű!
[Férfi hangszóró] Nos, az induláshoz, azt hiszem, szükségünk lesz egy pár mutatók.
>> [Muci] Oké. Ez a kód lefoglal 2 mutatók, amelyek rámutatnak egészek.
[Férfi hangszóró] Oké. Nos, látom a 2 mutató, de nem úgy tűnik, hogy mutat valamit.
[Muci] Ez igaz. Kezdetben mutatók nem mutatnak semmit.
A dolgokat, mutatnak nevezik pointees, és beállítása őket egy külön lépésben.
[Férfi hangszóró] Ó, igaz, igaz. Tudtam. A pointees külön.
Ööö, szóval hogyan osztják a pointee?
[Muci] Oké. Ez a kód lefoglal egy új integer pointee, és ez a rész x mutasson rá.
[Férfi hangszóró] Hé, ez jobban néz ki.
Tehát, hogy csinál valamit. >> [Muci] Oké.
Én majd dereference a mutatót x tárolni a számot 42 bele pointee.
Mert ez a trükk lesz szükségem a varázspálcával a dereferencing.
[Férfi hangszóró] A varázspálca a dereferencing? Ez nagyszerű.
[Muci] Ez az, amit a kód néz ki. Én csak állítsa be a számot, és ... [Pattogó hang]
[Férfi hangszóró] Hé nézd, ott megy.
Így csinál egy dereference az x követi a nyilat, hogy hozzáférjen az pointee,
ebben az esetben tárolni 42 ott.
Hé, próbálja meg, hogy tárolja a 13-as szám a másik mutató, y.
[Muci] Oké. Én csak megy át ide, y, és hogy a 13-as szám létrehozott
majd megteszi a pálcát a dereferencing és csak ... [Zümmögő hang] Whoa!
[Férfi hangszóró] Ó hé, ez nem működik.
>> Mondd, Muci, nem hiszem, dereferencing y ez egy jó ötlet
mivel létrehozásának pointee külön lépés
és nem hiszem, hogy valaha is tette.
[Muci] Hmm, jó érv.
[Férfi hangszóró] Igen. Mi kiosztott az egérmutatót y de soha állítsa, hogy pont egy pointee.
[Muci] Hmm, nagyon figyelmes.
[Férfi hangszóró] Hé, te jól nézel ki ott, Muci.
Meg tudja javítani úgy, hogy y pontokat ugyanazon pointee mint x? >> [Muci] Persze.
Fogom használni a varázspálcát a mutató feladat.
[Férfi hangszóró], hogy lesz a probléma, mint korábban?
[Muci] Nem, ez nem érinti a pointees.
Csak változik 1 pointer mutasson ugyanaz, mint a másik. [Pattogó hang]
[Férfi hangszóró] Oh, értem. Most y pont ugyanazon a helyen, mint x.
Szóval várj. Most y rögzített. Ez egy pointee.
Így próbálja meg a pálcát a dereferencing újra elküldeni a 13 feletti.
[Muci] Uh, oké. Itt megy. [Pattogó hang]
[Férfi hangszóró] Hé, ezt nézd meg. Most dereferencing működik y.
És mivel a mutató a megosztás, hogy az egyik pointee, mindketten lásd a 13.
[Muci] Igen, megosztását. Mindegy.
>> Így fogunk felcserélődnek most?
[Férfi hangszóró] Ó nézd, kifogytunk az időből. >> [Muci] De -
[Férfi hangszóró] Ne feledd, a 3 mutató szabályokat.
Száma 1, az alapvető struktúra, hogy van egy mutatót, és azt hangsúlyozza át a pointee.
De a mutató és pointee külön, és a közös hiba, hogy hozzon létre egy mutatót
hanem az, hogy elfelejtette, hogy ez egy pointee.
Szám 2, mutató dereferencing kezdődik a mutatót, és követi a nyíl felett
eléréséhez a pointee.
Mint azt mindannyian tudjuk, ez csak akkor működik, ha van egy pointee,
milyen kap vissza az 1-es szám uralkodni.
Szám 3, mutató feladat vesz egy mutató, és megváltoztatja
hogy pont ugyanazt a pointee egy másik mutatót.
Szóval, miután a feladat, a 2 mutatókat fog mutatni az azonos pointee.
Néha hívják megosztását.
>> És ez minden van rá igazán. Bye-bye most.
Ez Muci. Ez CS50. Találkozunk jövő héten. [Taps]
>> [CS50.TV]