[Powered by Google Translate] [Adran 5 - Mwy cyfforddus]
[Rob Bowden - Harvard University]
[Mae hyn yn CS50. - CS50.TV]
>> Fel y dywedais yn fy e-bost, mae llawer o bethau y gallwch eu defnyddio
heblaw am yr offer i mewn gwirionedd wneud y setiau broblem.
Rydym yn argymell eich bod yn ei wneud yn y peiriant dim ond oherwydd wedyn gallwn yn haws yn eich helpu i
ac rydym yn gwybod sut mae popeth yn mynd i weithio.
Ond fel un enghraifft o ble y gallwch wneud pethau os, er enghraifft, nad oes gennych fynediad
i ddyfais neu os ydych eisiau gweithio yn y Ganolfan Gwyddoniaeth islawr -
sydd mewn gwirionedd mae ganddynt yr offer hefyd -
os ydych chi am weithio yn unrhyw le.
Un enghraifft yw a ydych wedi gweld / clywed am SSH?
SSH yn y bôn yn union fel cysylltu â rhywbeth.
Mewn gwirionedd, ar hyn o bryd rwy'n SSHed i mewn i'r ddyfais.
Dwi byth yn gweithio'n uniongyrchol yn y peiriant.
Yma yn y peiriant, ac os ydych yn edrych i lawr yma byddwch yn gweld yr gyfeiriad IP.
Dwi byth yn gweithio yn y peiriant ei hun;
Rwyf bob amser yn dod drosodd i iTerm2 ffenestr / terminal ffenestr.
Gallwch SSH i'r cyfeiriad hwnnw IP, ssh jharvard@192.168.129.128.
Rwy'n cofio bod nifer yn hawdd iawn oherwydd ei fod yn gymaint o batrwm 'n glws.
Ond a fydd yn gofyn i mi am fy nghyfrinair, ac erbyn hyn rwy'n yn y peiriant.
Yn y bôn, ar y pwynt hwn, os byddwch yn agor terfynell tu mewn i'r peiriant ei hun,
rhyngwyneb hwn, fodd bynnag, y byddech yn ei ddefnyddio, yn union yr un fath
fel y rhyngwyneb rwy'n ei ddefnyddio dros yma, ond nawr dych chi'n SSHed.
Nid oes rhaid i chi SSH i'r ddyfais.
Un enghraifft o ryw le arall y gallech SSH i yw fy mod i'n eithaf siŵr fod gennych yn ddiofyn -
Oh. Mwy.
Dylai pob un ohonoch gael gan gyfrifon FAS ddiofyn ar y gweinyddion FAS.
I mi, byddwn SSH i rbowden@nice.fas.harvard.edu.
Mae'n mynd i ofyn i chi fod y tro cyntaf, ac rydych yn dweud ie.
Mae fy nghyfrinair yn unig yn mynd i fod yn fy nghyfrinair FAS.
Ac felly yn awr, rwy'n SSHed i'r gweinyddwyr 'n glws, a gallaf wneud unrhyw beth yr wyf eisiau ar yma.
Mae llawer o ddosbarthiadau gallech eu cymryd, fel 124, yn mynd i gael i chi lwytho pethau i yma
mewn gwirionedd gyflwyno eich setiau problem.
Ond yn dweud nad oes gennych fynediad at eich offer.
Yna, gallwch wneud pethau, fel ar fan hyn, bydd yn dweud -
Mae hyn yn unig yw ein hadran o gwestiynau.
Bydd yn gofyn i chi wneud hyn yn y peiriant.
Yn hytrach, 'n annhymerus' jyst yn gwneud hynny ar y gweinydd.
Rydw i'n mynd i unzip hynny.
Mae'r broblem yn mynd i fod yn eich bod yn gyfarwydd â defnyddio rhywbeth fel gedit
neu beth bynnag tu mewn i'r offer.
Nid ydych yn mynd i gael hynny ar y gweinydd FAS.
Mae i gyd yn unig yn mynd i fod y rhyngwyneb testunol.
Felly, gallech naill ai un, ceisiwch ddysgu golygydd testun y maent yn cael.
Mae ganddynt Nano.
Nano fel arfer yn eithaf hawdd i'w defnyddio.
Gallwch ddefnyddio eich saethau a deipio fel arfer.
Felly nid yw hynny'n anodd.
Os ydych am ca 'n sylweddol ffansi y gallwch eu defnyddio Emacs,
yr wyf yn debyg na ddylai wedi agor oherwydd nid wyf yn hyd yn oed yn gwybod sut i gau Emacs.
Rheoli X, Rheoli C? Yeah.
Neu gallwch ddefnyddio Vim, sef yr hyn yr wyf yn ei ddefnyddio.
Ac felly dyna yw eich opsiynau.
Os nad ydych am wneud hynny, gallwch hefyd, os edrychwch ar manual.cs50.net--
Oh.
Ar PC, gallwch ddefnyddio SSH pwti,
yr ydych yn mynd i gael i lawrlwytho ar wahân.
Ar Mac, gallwch dim ond drwy ddefnyddio Terminal ddiofyn neu gallwch lawrlwytho iTerm2,
sydd fel a 'n glws, Terminal ffansi.
Os byddwch yn mynd i manual.cs50.net byddwch yn gweld dolen i Notepad + +,
sef yr hyn y gallwch ei ddefnyddio ar gyfrifiadur personol.
Mae'n gadael i chi SFTP o Notepad + +, sydd yn y bôn SSH.
Beth fydd hyn yn gadael i chi ei wneud yw olygu eich ffeiliau yn lleol,
ac yna pryd bynnag yr ydych am arbed iddynt, bydd yn arbed i nice.fas,
lle gallwch wedyn eu rhedeg.
Ac yr hyn sy'n cyfateb ar Mac yn mynd i fod TextWrangler.
Felly mae'n gadael i chi wneud yr un peth.
Mae'n gadael i chi golygu ffeiliau yn lleol ac yn eu cadw i nice.fas,
lle gallwch wedyn eu rhedeg.
Felly, os ydych yn sownd erioed heb offer, mae gennych yr opsiynau hyn
dal i wneud eich setiau problem.
Mae'r un broblem yn mynd i fod nad ydych chi'n mynd i gael y llyfrgell CS50
oherwydd nad oes nice.fas yn ddiofyn wedi hynny.
Gallwch naill ai lawrlwytho'r llyfrgell CS50 -
Nid wyf yn credu fy mod angen bod ar y pwynt hwn.
Gallwch naill ai lawrlwytho'r llyfrgell CS50 ac anfon copi ohono drosodd i nice.fas,
neu wyf yn meddwl ar hyn o bryd nid ydym yn ei ddefnyddio anymore beth bynnag.
Neu, os ydym yn ei wneud, gallwch chi am y tro yn ei le
y gweithrediadau o'r swyddogaethau yn y llyfrgell CS50 beth bynnag.
Felly, ni ddylai hynny fod gymaint o gyfyngiad.
A dyna hynny.
>> 'N annhymerus' mynd yn ôl i'r peiriant hyn o bryd; byddwn yn gwneud popeth yn y peiriant.
Edrych ar ein hadran o gwestiynau, ar y dechrau, fel y dywedais yn fy e-bost,
mae'n rhaid i ni siarad am yr un byr oeddech yn fod i wylio.
Mae gennym y ailgyfeirio & Pipes ac mae'r rhain tri chwestiwn.
>> I ba ffrwd yn swyddogaethau fel printf ysgrifennu yn ddiofyn?
Felly ffrwd. Beth yw ffrwd?
Mae nant yn y bôn fel ei fod dim ond rhai -
Nid yw'n hyd yn oed yn ffynhonnell o 1s a 0au.
Mae'r nant mae'n gofyn amdano yma yw allan safonol.
Ac felly safonol yn ffrwd pan fyddwch yn ysgrifennu ato,
mae'n ymddangos ar y sgrin.
Allan Safonol, gan nant, mae'n golygu eich bod dim ond ysgrifennu 1s 0s ac iddo,
a'r pen arall y tu allan safonol yn unig yn darllen o'r nant.
Mae'n dim ond cyfres o 1s a 0au.
Gallwch ysgrifennu at nentydd neu gallwch ddarllen o ffrydiau
yn dibynnu ar yr hyn y nant mewn gwirionedd.
Mae'r ffrydiau diofyn ddau arall yn safonol mewn ac gwall safonol.
Safonol mewn pryd bynnag y byddwch yn yn GetString, mae'n aros i chi i bethau mewnbwn.
Felly, mae'n aros i chi, mae'n mewn gwirionedd yn aros ar safon mewn,
sydd mewn gwirionedd yr hyn a gewch pan fyddwch yn teipio ar y bysellfwrdd.
Rydych yn teipio i mewn i safon mewn
Gwall safonol yn y bôn cyfateb i allan safonol,
ond mae'n arbenigo mewn bod pan fyddwch yn argraffu i gwall safonol,
rydych yn fod i pheidiwch ag argraffu negeseuon gwall i'r
fel y gallwch wahaniaethu rhwng negeseuon rheolaidd printiedig i'r sgrin
yn erbyn negeseuon gwall yn dibynnu ar p'un a ydynt yn mynd i allan safonol neu wall safonol.
Ffeiliau hefyd.
Allan Safonol, safon mewn, a gwall safonol yn unig ffrydiau arbennig,
ond mewn gwirionedd unrhyw ffeil, pan fyddwch yn agor ffeil, mae'n dod yn ffrwd o bytes
lle gallwch newydd ei ddarllen o'r nant.
Rydych chi, ar gyfer y rhan fwyaf yn gallu, dim ond meddwl am ffeil fel ffrwd o bytes.
Felly, pa ffrydiau maent yn ysgrifennu at ddiofyn? Allan Safonol.
>> Beth yw'r gwahaniaeth rhwng> ac >>?
A oedd unrhyw un wylio'r fideo ymlaen llaw? Iawn.
> Yn mynd i fod sut yr ydych yn ailgyfeirio i mewn i ffeil,
a >> hefyd yn mynd i ailgyfeirio allbwn i mewn i ffeil,
ond mae yn hytrach yn mynd i atodi i'r ffeil.
Er enghraifft, gadewch i ni ddweud fy mod yn digwydd i gael ngeiriadur i'r dde yma,
a'r pethau yn unig y tu mewn o ngeiriadur yn gath, cath, ci, pysgod, ci.
Un gorchymyn bod gennych ar y llinell orchymyn yn gath,
sydd yn unig yn mynd i argraffu beth sydd mewn ffeil.
Felly, pan fyddaf yn dweud ngeiriadur cath, mae'n mynd i argraffu cath, cath, ci, pysgod, ci. Dyna'r cyfan gath ei wneud.
Mae hynny'n golygu ei bod yn argraffu i safon allan gath cath,, ci, pysgod, ci.
Os ydw i yn lle hynny am ailgyfeirio hynny i ffeil, gallaf ddefnyddio> a'i ailgyfeirio i beth bynnag y ffeil yn.
'N annhymerus' galw y ffeil ffeil.
Felly, yn awr, os wyf ls, 'n annhymerus' gweld gen i ffeil newydd o'r enw ffeil.
Ac os byddaf yn agor i fyny, mae'n mynd i gael union beth gath ei roi ar y llinell orchymyn.
Felly, yn awr os wyf yn gwneud hynny eto, yna mae'n mynd i ailgyfeirio'r allbwn i mewn i ffeil,
ac rwy'n mynd i gael yr union beth yr un.
Felly, yn dechnegol, yn gyfan gwbl overrode yr hyn a oedd gennym.
A byddwn yn gweld os byddaf yn newid ngeiriadur, yr wyf yn cymryd allan ci.
Nawr, os ydym yn gath ngeiriadur i mewn i ffeil eto, rydym yn mynd i gael y fersiwn newydd gyda ci symud.
Felly, mae'n gwbl drech arno.
Yn lle hynny, os ydym yn defnyddio >>, mae'n mynd i atodi ffeil.
Yn awr, yn agor ffeil, gwelwn ydym newydd yr un peth ddwywaith argraffu
oherwydd ei fod yno unwaith, yna rydym yn atodiad i'r gwreiddiol.
Felly, dyna beth> a >> yn ei wneud.
A yw'r un nesaf gofyn - Nid yw'n gofyn am y peth.
>> Mae un arall sydd gennym yw <, ac os> ailgyfeiriadau allan safonol,
<Yn mynd i gael ei ailgyfeirio safon mewn
Gadewch i ni weld os oes gennym enghraifft.
Gallaf ysgrifennu un cyflym go iawn.
Gadewch i ni gymryd unrhyw ffeil, hello.c.
Ffeil gymharol syml.
Im 'jyst yn cael llinyn ac yna argraffu "Helo" beth bynnag y llinyn Fi jyst mynd yn.
Felly gwnewch yn helo, ac yna. / Helo.
Nawr mae'n annog i mi i fynd i mewn rhywbeth,
sy'n golygu ei fod yn aros ar bethau i gael ei wneud mewn safon
Felly, rhoi beth bynnag rwyf am i safon ynddo Rydym yn jyst yn mynd i ddweud Helo, Rob!
Yna, mae'n argraffu i safon allan Helo, Rob!
Os byddaf yn ei wneud. / Helo, ac yna ailgyfeirio,
ar hyn o bryd gallwch ailgyfeirio o ffeil.
Felly, os ydw i'n rhoi mewn rhai ffeil, txt, ac yr wyf yn rhoi Rob,
os byddaf yn rhedeg helo, ac yna ailgyfeirio'r txt ffeil i mewn. / helo, mae'n mynd i ddweud Helo, Rob! ar unwaith.
Pan yn gyntaf yn cyrraedd GetString ac mae'n aros ar safon mewn,
safonol yw mwyach yn aros ar y bysellfwrdd ar gyfer data i gael ei gofnodi.
Yn lle hynny, rydym wedi ailgyfeirio safonol i ddarllen o'r txt ffeil.
Ac felly mae'n mynd i ddarllen o'r txt ffeil, sydd ychydig y Rob llinell,
ac yna mae'n mynd i argraffu Helo, Rob!
Ac os oeddwn i eisiau, gallwn hefyd wneud. / Helo <txt
ac yna y safon y ffaith ei argraffu, sef Hello, Rob!,
Gallaf ailgyfeirio bod yn ei ffeil ei hun.
'N annhymerus' jyst ffoniwch y ffeil hello - na, ni wnaf, oherwydd dyna y gweithredadwy - txt2.
Yn awr, txt2 yn mynd i gael yr allbwn. / Helo <txt, sydd yn mynd i fod yn Helo, Rob!
>> Cwestiynau?
>> Iawn. Felly, yna yma mae gennym biblinell.
Pipes yn yr uned olaf ailgyfeiriad.
>> Oh. Amcana un uned mwy o ailgyfeirio yw os yn hytrach na> ydych yn ei wneud 2>,
sydd wedi ailgyfeirio gwall safonol.
Felly os oes rhywbeth yn mynd i wall safonol, ni fyddai'n cael ei roi i mewn i txt2.
Ond rhybudd os wyf yn gwneud 2>, yna mae'n dal i argraffu Helo, Rob! i 'r archa bannod
gan fy mod yn unig ailgyfeirio gwall safonol, dydw i ddim yn ailgyfeirio safon allan.
Gwall safonol ac allan safonol yn wahanol.
Os ydych eisiau mewn gwirionedd yn ysgrifennu at gwall safonol,
yna gallwn newid hyn i fod yn fprintf i stderr.
Felly printf, yn ddiofyn, printiau i allan safonol.
Os ydw i eisiau argraffu i gwall safonol â llaw, yna rhaid i mi ddefnyddio fprintf
ac yn pennu'r hyn yr wyf am i argraffu iddo.
Os yn lle hynny wnes i stdout fprintf, yna mae hynny'n bôn cyfateb i printf.
Ond fprintf i wall safonol.
Felly yn awr, os wyf yn ailgyfeirio hyn i txt2, Helo, Rob! yn dal i gael ei argraffu ar y llinell orchymyn
gan ei fod yn cael ei argraffu i'r gwall safonol ac rwy'n dim ond ailgyfeirio safon allan.
Os wyf yn awr yn ailgyfeirio gwall safonol, yn awr nid oedd yn cael eu hargraffu, a txt2 yn mynd i fod Helo, Rob!
Felly nawr, gallwch argraffu eich camgymeriadau gwirioneddol gwall safonol
ac argraffu eich negeseuon rheolaidd i allan safonol.
Ac felly pan fyddwch yn rhedeg eich rhaglen, gallwch redeg fel. / Hello math hwn gyda'r 2>
fel bod eich rhaglen yn mynd i redeg fel arfer,
ond gall unrhyw negeseuon gwall eich bod yn cael eich bod yn gwirio yn ddiweddarach yn eich cofnod camgymeriadau,
cynifer o gamgymeriadau, ac yna edrych yn ddiweddarach a bydd eich camgymeriadau ffeil yn unrhyw wallau sydd wedi digwydd.
>> Cwestiynau?
>> Mae'r un olaf yn bibell, y gallwch feddwl â chymryd y safon allan o un gorchymyn
a'i gwneud yn y safon yn y gorchymyn nesaf.
Mae enghraifft yma yn cael ei adleisio yn gorchymyn beth llinell
bod yn unig yn mynd i adleisio beth bynnag yr wyf yn rhoi yn ei ddadl. Ni fyddaf yn rhoi dyfyniadau.
Echo blah, blah, blah yn unig yn mynd i argraffu blah, blah, blah.
Cyn, pan ddywedais fy mod wedi i roi Rob i ffeil txt
oherwydd ni allaf ond ailgyfeirio ffeiliau txt, yn hytrach, / os ategaf Rob
ac yna i mewn i bibell. / helo, a fydd hefyd yn gwneud yr un math o beth.
Mae hyn yn cymryd y cynnyrch hwn yn gorchymyn, adlais Rob,
a'i defnyddio fel mewnbwn ar gyfer. / helo.
Gallwch feddwl am y peth fel gyntaf ailgyfeirio adlais Rob i mewn i ffeil
ac yna mewnbwn i. / helo y ffeil a outputted yn unig.
Ond mae'n cymryd y ffeil dros dro allan o'r llun.
>> Cwestiynau ar hynny?
>> Mae'r cwestiwn nesaf yn mynd i gynnwys hyn.
Beth allech biblinell ei ddefnyddio i ddod o hyd i'r nifer o enwau unigryw mewn ffeil o'r enw names.txt?
Mae'r gorchmynion rydym yn mynd i eisiau i ddefnyddio yma yn unigryw, felly uniq, ac yna toiled.
Gallwch wneud uniq dyn i mewn gwirionedd yn edrych ar beth yw hynny,
ac mai dim ond yn mynd i hidlo llinellau cyfateb cyfagos o fewnbwn.
Ac mae dyn toiled yn mynd i argraffu'r Newline, gair, ac yn cyfrif beit ar gyfer pob ffeil.
Ac yr un olaf rydym yn mynd i eisiau ei ddefnyddio yn fath,
sydd yn mynd i ychydig didoli llinellau txt ffeil.
Os byddaf yn gwneud rhai, ffeil txt names.txt, ac mae'n Rob, Tommy, Joseph, Tommy, Joseph, RJ, Rob,
hyn yr wyf eisiau ei wneud yma yw dod o hyd i nifer o enwau unigryw yn y ffeil hon.
Felly, beth ddylai'r ateb fod? >> [Myfyrwyr] 4. >> Yeah.
Dylai fod yn 4 ers Rob, Tommy, Joseph, RJ yw'r unig enwau unigryw yn y ffeil hon.
Y cam cyntaf, os Fi jyst yn gwneud nifer y geiriau ar names.txt,
hyn mewn gwirionedd yn dweud wrthyf bopeth.
Mae hyn mewn gwirionedd argraffu - gadewch i ni weld, dyn toiled - newlines, geiriau, ac yn cyfrif beit.
Os mai dim ond gofalu am linellau, yna gallaf ei wneud toiled-l names.txt.
Felly dyna cam 1.
Ond nid wyf am toiled-l names.txt oherwydd names.txt yn unig yn cynnwys yr holl enwau,
ac rydw i eisiau i hidlo allan unrhyw rai nad ydynt yn unigryw.
Felly, os wyf yn gwneud uniq names.txt, nid yw hynny'n hollol yn rhoi i mi yr hyn yr wyf eisiau
oherwydd bod yr enwau dyblygu yn dal i fod yno.
Pam hynny? Pam nad yw uniq gwneud yr hyn rwyf eisiau?
[Myfyrwyr] Nid yw'r dyblygu yn [Anghlywadwy] >> Yeah.
Cofiwch y dudalen dyn am uniq yn dweud llinellau cyfateb cyfagos hidlo.
Nid ydynt yn gyfagos, felly ni fydd yn hidlo iddynt.
Os byddaf yn trefnu iddynt yn gyntaf, names.txt fath yn mynd i roi'r holl linellau wedi'u dyblygu ei gilydd.
Felly nawr names.txt fath yw hynny.
Rydw i'n mynd i eisiau defnyddio hynny fel y mewnbwn i uniq, sef | uniq.
Mae hynny'n rhoi i mi Joseph, RJ, Rob, Tommy,
ac rydw i eisiau defnyddio hynny fel mewnbwn i wc-l,
sydd yn mynd i roi i mi 4.
Fel mae'n dweud yma, pa bibell rydych yn ei ddefnyddio?
Gallwch wneud llawer o bethau fel defnyddio cyfres o orchmynion
lle rydych yn defnyddio'r allbwn o un gorchymyn fel y mewnbwn i'r gorchymyn nesaf.
Gallwch wneud llawer o bethau, mae llawer o bethau clyfar.
>> Cwestiynau?
Iawn.
Dyna ni am pibellau a ailgyfeiriad.
>> Nawr rydym yn mynd ar y pethau gwirioneddol, y stwff codio.
Y tu mewn o hyn PDF, byddwch yn gweld y gorchymyn,
a youll 'angen at hidla hon archa yn eich offer.
wget yw'r gorchymyn ar gyfer dim ond cael rhywbeth oddi ar y Rhyngrwyd, yn y bôn,
felly wget ac mae hyn yn URL.
Os byddwch yn mynd i'r URL yn eich porwr, byddai'n llwytho i lawr y ffeil.
Fi jyst clicio arno, felly ei lwytho i lawr y ffeil i mi.
Ond ysgrifennu wget y peth y tu mewn i'r derfynell
yn unig yn mynd i lwytho i lawr i mewn i'ch terfynol.
Mae gen i section5.zip, a youll 'angen at unzip section5.zip,
sydd yn mynd i roi ffolder o'r enw section5,
sydd yn mynd i gael yr holl ffeiliau rydym yn mynd i gael ei ddefnyddio heddiw tu mewn iddo.
Gan fod enwau ffeiliau rhaglenni hyn 'yn awgrymu, maen nhw'n bygi ychydig,
fel bod eich cenhadaeth yw i chyfrif i maes pam mae defnyddio gdb.
Ydy pawb wedi eu llwytho i lawr / yn gwybod sut i gael eu llwytho i lawr
yn eu teclyn? Iawn.
>> Rhedeg ./buggy1, bydd yn dweud fai Segmentiad (craidd gadael),
y mae unrhyw tro y byddwch yn cael segfault, mae'n beth drwg.
O dan ba amgylchiadau rydych chi'n cael segfault?
[Myfyrwyr] Dereferencing pwyntydd nwl. >> Yeah. Felly dyna un enghraifft.
Dereferencing pwyntydd null ydych yn mynd i gael segfault.
Beth yw segfault yn ei olygu yw eich bod yn cyffwrdd cof na ddylech fod yn cyffwrdd.
Felly dereferencing pwyntydd nwl yn cyffwrdd gyfeiriad 0,
ac yn y bôn, yr holl gyfrifiaduron y dyddiau hyn yn dweud bod 0 cyfeiriad cof na ddylech fod yn cyffwrdd.
Felly dyna pam dereferencing o ganlyniadau pwyntydd nwl mewn segfault.
Pan fyddwch yn digwydd i ni gychwyn y pwyntydd, yna mae ganddo werth garbage,
ac felly pan fyddwch yn ceisio dereference hynny, yn ôl pob tebyg rydych chi'n cyffwrdd cof
sydd yn y nghanol unlle.
Os ydych yn digwydd i gael lwcus a gwerth garbage
ddigwyddodd i bwyntio at rywle ar y simnai neu rywbeth,
Yna, pan fyddwch yn dereference y pwyntydd nad ydych wedi ymgychwyn,
Bydd unrhyw beth yn mynd o'i le.
Ond os caiff ei bwyntio i, dyweder, rhywle rhwng y pentwr a'r domen,
neu mae'n pwyntio yn unig i rywle nad yw wedi cael ei ddefnyddio gan eich rhaglen eto,
yna rydych chi'n cyffwrdd cof na ddylech fod yn cyffwrdd a chi segfault.
Pan fyddwch yn ysgrifennu swyddogaeth recursive ac mae'n recurses gormod o weithiau
a bod eich simnai yn tyfu yn rhy fawr ac mae'r gwrthdaro pentwr i mewn i bethau
na ddylid ei wrthdaro gyda, rydych chi'n cyffwrdd cof na ddylech fod yn cyffwrdd,
er mwyn i chi segfault.
Dyna beth yw segfault yw.
>> Mae hefyd yr un rheswm, os oes gennych llinyn fel -
gadewch i ni fynd yn ôl at y rhaglen flaenorol.
Yn hello.c--I'm jyst yn mynd i wneud rhywbeth arall.
torgoch * s = "helo byd!";
Os byddaf yn defnyddio * s = rhywbeth neu s [0] = 'X';
felly gwnewch yn helo,. / helo, pam oedd hynny'n segfault?
Pam oedd hyn yn segfault?
Beth fyddech chi'n disgwyl i ddigwydd?
Os byddaf yn gwneud printf ("% s \ n", s); beth fyddech chi'n disgwyl eu hargraffu?
[Myfyrwyr] X helo. >> Yeah.
Y broblem yw bod pan fyddwch yn datgan llinyn fel hyn,
s yn pwyntydd sy'n mynd i fynd ar y simnai,
a'r hyn y s yn pwyntio i yw hyn llinyn sydd wedi'i chynnwys yn darllen yn unig cof.
Felly, yn unig gan yr enw, darllen yn unig cof, dylech gael y syniad
os ydych yn ceisio newid yr hyn sydd yn darllen yn unig cof,
rydych chi'n ei wneud rhywbeth na ddylech fod yn ei wneud gyda'r cof a chi segfault.
Hyn mewn gwirionedd yn wahaniaeth mawr rhwng torgoch * s torgoch a'r s [].
Felly torgoch s [], yn awr, y llinyn yn mynd i gael ei roi ar y corn,
ac nad yw'r pentwr yn darllen yn unig, sy'n golygu y dylai hyn weithio berffaith iawn.
Ac mae'n ei wneud.
Cofiwch fod pan fyddaf yn gwneud golosg * s = "helo byd!", S ei hun ar y simnai
ond mae'n tynnu sylw s i rywle arall, a bod yn rhywle arall yn digwydd bod yn darllen-yn-unig.
Ond cols s [] yn unig rhywbeth ar y pentwr.
Felly dyna enghraifft arall o segfault digwydd.
>> Gwelsom fod ./buggy1 arwain at segfault.
Mewn theori, ni ddylech edrych ar buggy1.c ar unwaith.
Yn hytrach, byddwn yn edrych arno drwy gdb.
Hysbysiad bod pan fyddwch yn cael nam Segmentiad (craidd gadael),
byddwch yn cael y ffeil dros craidd a elwir yma.
Os byddwn yn ls-l, byddwn yn gweld y craidd hwnnw fel arfer ffeil eithaf mawr.
Mae hyn yn y nifer o bytes y ffeil, felly mae'n edrych fel ei fod yn 250-rhywbeth kilobytes.
Y rheswm am hyn yw bod yr hyn y domen craidd mewn gwirionedd yn
yw pan fydd eich damweiniau rhaglen, cyflwr cof eich rhaglen
yn unig yn cael copïo a gludo i mewn i'r ffeil.
Mae'n cael ei adael i mewn i'r ffeil.
Mae'r rhaglen hon, er ei fod yn rhedeg, ddigwyddodd i gael defnydd cof am tua 250 cilobeit,
ac felly dyna beth gafodd eu gadael i mewn i'r ffeil.
Nawr gallwch edrych ar y ffeil os ydym yn ei wneud gdb buggy1 craidd.
Gall Rydym yn unig yn gwneud gdb buggy1, a fydd ond yn dechrau i fyny gdb yn rheolaidd,
defnyddio buggy1 fel ei ffeil mewnbwn.
Ond os ydych chi'n gdb buggy1 craidd, yna mae'n benodol yn mynd i ddechrau gdb
drwy edrych ar y ffeil craidd.
A ydych yn dweud buggy1 gdb golygu gwybod bod y ffeil craidd yn dod o'r rhaglen buggy1.
Felly gdb buggy1 craidd yn mynd i ddod â ni ar unwaith
i ble digwyddodd y rhaglen i derfynu.
Rydym yn gweld yma Rhaglen terfynu gyda signal 11, nam Segmentiad.
Rydym yn digwydd i weld llinell cynulliad, sydd yn debyg nad yn ddefnyddiol iawn.
Ond os ydych yn teipio bt neu olrheiniad, mae hynny'n mynd i fod yn swyddogaeth
sy'n rhoi i ni y rhestr o ein fframiau stac ar hyn o bryd.
Felly olrheiniad. Mae'n edrych fel mai dim ond dwy ffrâm pentwr.
Y cyntaf yw ein prif ffrâm pentwr,
ac mae'r ail yn y ffrâm pentwr gyfer y swyddogaeth hon yr ydym yn digwydd bod yn,
sy'n edrych fel mai dim ond y cod cynulliad ar gyfer.
Felly, gadewch i ni fynd yn ôl i mewn i'n prif swyddogaeth,
ac i wneud hynny y gallwn ei wneud ffrâm 1, ac rwy'n credu y gallwn ni hefyd wneud i lawr,
ond dydw i erioed bron yn ei wneud i lawr - neu hyd. Yeah.
Ar hyd a lled. Up yn dod â chi i fyny un ffrâm stac, i lawr yn dod â chi i lawr ffrâm pentwr.
Dwi'n tueddu i byth yn defnyddio hynny.
Fi jyst yn dweud yn benodol ffrâm 1, sy'n cael ei mynd i'r ffrâm labelu 1.
Ffrâm 1 yn mynd i ddod â ni i mewn i ffrâm pentwr prif
ac mae'n dweud dde yma y llinell o god ydym yn digwydd bod yn.
Os ydym eisiau llinellau ychydig mwy o god, gallwn ddweud rhestr,
ac mae hynny'n mynd i roi i ni yr holl linellau o god o'i amgylch.
Mae'r llinell rydym yn segfaulted arno oedd 6:
os (strcmp ("CS50 creigiau", argv [1]) == 0).
Os nad yw'n amlwg eto, gallwch ei gael yn syth o'r fan yma yn unig gan feddwl pam ei segfaulted.
Ond gallwn fynd ag ef un cam ymhellach a dweud, "Pam y byddai argv [1] segfault?"
Gadewch i ni print argv [1], ac mae'n edrych fel ei fod yn 0x0, sef y pwyntydd nwl.
Rydym yn strcmping CS50 greigiau a null, ac felly mae hynny'n mynd i segfault.
A pham mae argv [1] null?
[Myfyrwyr] Gan nad ydym yn rhoi unrhyw ddadleuon gorchymyn-lein.
Yeah. Doedden ni ddim yn rhoi unrhyw ddadleuon gorchymyn-lein.
Felly ./buggy1 yn unig yn mynd i gael argv [0] fod ./buggy1.
Dyw hi ddim yn mynd i gael argv [1], felly mae hynny'n mynd i segfault.
Ond os, yn lle hynny, yr wyf yn jyst CS50, mae'n mynd i ddweud Byddwch yn cael D
oherwydd dyna beth y mae'n ei fod i'w wneud.
O edrych ar buggy1.c, mae'n fod i argraffu "Byddwch yn cael D" -
Os argv [1] Nid yw "CS50 creigiau", "Byddwch yn cael D", arall "Rydych yn cael A!"
Felly, os ydym am A, mae angen hyn i gymharu yn wir,
sy'n golygu ei fod yn cymharu â 0.
Felly argv [1] Mae angen i fod yn "CS50 creigiau".
Os ydych am wneud hynny ar y llinell orchymyn, bydd angen i chi ddefnyddio \ i ddianc rhag y gofod.
Felly, CS50 \ creigiau a Byddwch yn cael A!
Os nad ydych yn gwneud y slaes, pam nad yw hyn yn gweithio?
[Myfyrwyr] Mae'n dwy ddadl wahanol. >> Yeah.
Argv [1] yn mynd i fod CS50, a argv [2] yn mynd i fod creigiau. Iawn.
>> Nawr ./buggy2 yn mynd i segfault eto.
Yn hytrach na agor 'i ag ei ​​ffeil craidd, byddwn yn jyst agor i fyny buggy2 yn uniongyrchol,
felly gdb buggy2.
Nawr, os ydym yn unig yn rhedeg ein rhaglen, yna mae'n mynd i ddweud Rhaglen derbyn signal SIGSEGV,
sef y segfault signal, a dyma lle y digwyddodd i ddigwydd.
Edrych ar ein olrheiniad, gwelwn ein bod yn y oh_no swyddogaeth,
a alwyd gan y Dinky swyddogaeth a elwir gan y binky swyddogaeth,
a gafodd ei alw gan brif.
Gallwn hefyd weld y dadleuon i'r swyddogaethau hyn.
Mae'r ddadl i Dinky a binky oedd 1.
Os byddwn yn rhestru'r oh_no swyddogaeth, rydym yn gweld bod oh_no yn unig yw gwneud torgoch ** s = NULL;
* S = "Boom";
Pam y byddai hynny yn methu?
[Myfyrwyr] Ni allwch dereference y pwyntydd null? >> Yeah.
Mae hyn yn dim ond dweud s NULL, waeth os bydd hynny'n digwydd i fod yn ** torgoch,
sydd, yn dibynnu ar sut yr ydych yn ei ddehongli, gallai fod yn pwyntydd i'r pwyntydd i'r llinyn
neu amrywiaeth o linynnau.
Mae'n s NULL, felly * s yn dereferencing pwyntydd null,
ac felly mae hyn yn mynd i ddamwain.
Mae hwn yn un o'r ffyrdd cyflymaf y gallwch o bosibl segfault.
Mae'n dim ond datgan pwyntydd nwl ac yn union segfaulting.
Dyna beth oh_no yn ei wneud.
Os ydym yn mynd i fyny un ffrâm, yna rydym yn mynd i fynd i mewn i'r swyddogaeth a oedd yn galw oh_no.
Angen i mi wneud hynny i lawr.
Os nad ydych yn mynd i mewn gorchymyn a 'ch jyst daro Enter eto,
bydd ddim ond yn ailadrodd y gorchymyn blaenorol eich bod yn rhedeg.
Rydym yn ffrâm 1.
Rhestru y ffrâm, rydym yn gweld yma yw ein swyddogaeth.
Gallwch daro rhestr eto, neu gallwch wneud rhestr 20 a bydd yn rhestru mwy.
Mae'r Dinky swyddogaeth yn dweud os fi yw 1, yna ewch at y swyddogaeth oh_no,
arall yn mynd i'r swyddogaeth slinky.
Ac rydym yn gwybod i yw 1 oherwydd ein bod yn digwydd i weld hyd yma
bod Dinky galwyd gyda'r ddadl 1.
Neu gallwch yn unig yn argraffu i a bydd yn dweud i yw 1.
Rydym ar hyn o bryd yn Dinky, ac os ydym yn mynd i fyny arall ffrâm, rydym yn gwybod y byddwn yn y pen draw yn binky.
Up. Awr yr ydym mewn binky.
Rhestru swyddogaeth hon - y rhestr o cyn hanner yn fy atal -
iddi ddechrau fel os fi yw 0, yna rydym yn mynd i alw oh_no, arall ffoniwch Dinky.
Rydym yn gwybod fi oedd 1, felly yn galw Dinky.
Ac yn awr rydym yn ôl yn y brif, a phrif yn unig yn mynd i fod yn int i = Rand ()% 3;
Mae hynny yn unig yn mynd i roi rhif ar hap sydd naill ai'n 0, 1, neu 2.
Mae'n mynd i alw binky â'r rhif hwnnw, a bydd yn dychwelyd 0.
Edrych ar hyn,
gerdded drwy'r rhaglen llaw heb redeg ar unwaith,
byddech yn gosod pwynt torri yn y prif, sy'n golygu bod pan fyddwn yn rhedeg y rhaglen
eich rhaglen yn rhedeg hyd nes ei fod yn taro pwynt egwyl.
Felly rhedeg y rhaglen, bydd yn rhedeg ac yna bydd yn cyrraedd y brif swyddogaeth a rhoi'r gorau i redeg.
Nawr rydym ni'n tu mewn prif, a llys neu nesaf yn mynd i ddod â ni at y llinell nesaf o god.
Gallwch wneud cam neu nesaf.
Taro nesaf, yn awr fi wedi ei osod i rand ()% 3, er mwyn i ni argraffu'r gwerth i,
a bydd yn dweud i yw 1.
Nawr mae'n fater a ydym yn defnyddio nesaf neu gam.
Mae'n debyg ei fod yn bwysig yn yr un blaenorol, ond byddem yn dymuno ei ddefnyddio nesaf.
Os ydym yn defnyddio cam, rydym yn camu i mewn i'r swyddogaeth, sy'n golygu edrych ar y peth go iawn
sy'n digwydd y tu mewn o binky.
Os ydym yn defnyddio nesaf, yna mae'n golygu mynd dros y swyddogaeth
a dim ond mynd at y rheng nesaf o god yn ein prif swyddogaeth.
Hawl yma ar y llinell hon, yr oeddwn ar ble mae'n dweud Rand ()% 3;
os wyf yn gwneud cam, byddai'n mynd i mewn i'r weithredu rand
ac yn edrych ar yr hyn sy'n digwydd yno, a gallwn gamu trwy'r swyddogaeth rand.
Ond nid wyf yn poeni am y swyddogaeth rand.
Fi jyst eisiau mynd at y llinell nesaf o god yn y brif, felly rwy'n defnyddio nesaf.
Ond yn awr yr wyf yn poeni am y swyddogaeth binky, felly rwy'n awyddus i gamu i mewn i hynny.
Nawr rwy'n yn binky.
Mae'r llinell gyntaf y cod yn mynd i ddweud os (i == 0), yr wyf yn cymryd cam,
gwelwn ni yn y pen draw yn Dinky.
Os bydd pethau'n rhestr ydym ni, rydym yn gweld bod ei wirio yn i = 0.
nid fi yn hafal i 0, felly aeth i gyflwr arall,
sydd yn mynd i alw Dinky (i).
Efallai y byddwch yn cael drysu.
Os ydych yn edrych ar y llinellau hyn yn uniongyrchol, efallai y byddwch yn meddwl os (i == 0),
iawn, yna yr wyf yn cymryd cam ac erbyn hyn rwy'n yn Dinky (i),
efallai y byddwch yn meddwl bod yn rhaid i olygu i = 0 neu rywbeth.
Na jyst yn golygu ei fod yn gwybod y gall glynu uniongyrchol i'r (i) Dinky llinell.
Gan nad yw 0 i, nid yw'r cam nesaf yn mynd i ben ar y arall.
Nid Else yn llinell mae'n mynd i aros yn.
Mae'n dim ond yn mynd i fynd i'r llinell nesaf gall fod mewn gwirionedd yn gweithredu, sy'n Dinky (i).
Camu i mewn i Dinky (i), rydym yn gweld os (i == 1).
Ydym yn gwybod i = 1, felly pan fyddwn yn camu, rydym yn gwybod ein bod yn mynd i roi diwedd ar i fyny yn oh_no
oherwydd i = 1 galw y, oh_no swyddogaeth y gallwch gamu i mewn i,
sydd yn mynd i osod cols ** s = i nwl ac yn syth "Boom".
Ac yna mewn gwirionedd yn edrych ar y gweithredu buggy2,
hyn, i yn unig yw cael rhif ar hap - 0, 1, neu 2 - galw binky,
ac os i yw 0 mae'n galw oh_no, arall y mae'n galw Dinky, sy'n dod i fyny yma.
Os i yw 1, ffoniwch oh_no, arall ffoniwch slinky, sy'n dod i fyny yma,
os fi yw 2, ffoniwch oh_no.
Dydw i ddim hyd yn oed yn meddwl bod ffordd -
A oes unrhyw un yn gweld ffordd o wneud hyn yn rhaglen na fydd yn segfault?
Oherwydd oni bai fy mod i'n methu rhywbeth, os fi yw 0, byddwch yn syth segfault,
arall byddwch yn mynd i swyddogaeth sy'n os fi yw 1 chi segfault,
arall byddwch yn mynd i swyddogaeth lle os fi yw 2 eich bod yn segfault.
Felly, dim ots beth ydych yn ei wneud, rydych segfault.
>> Amcana un ffordd o osod y byddai'n hytrach na gwneud torgoch ** s = NULL,
gallech malloc le ar gyfer y llinyn.
Gallem wneud malloc (sizeof) - sizeof beth?
[Myfyrwyr] (torgoch) * 5? >> A yw hyn yn ymddangos yn iawn?
Rwy'n tybio y bydd hyn yn gweithio os wyf mewn gwirionedd yn rhedeg, ond nid yw'n hyn yr wyf i'n chwilio amdano.
Edrychwch ar y math o s. Gadewch i ni ychwanegu * int, felly int * x.
Byddwn yn gwneud malloc (sizeof (canolradd)).
Neu os oeddwn i eisiau amrywiaeth o 5, byddwn yn ei wneud (sizeof (canolradd) * 5);
Beth os oes gennyf ** int?
Beth fyddwn i'n malloc?
[Myfyrwyr] Maint y pwyntydd. >> Yeah. (Sizeof (canolradd *));
Un peth i lawr yma.
Rwyf am (sizeof (torgoch *));
Mae hyn yn mynd i neilltuo lle ar gyfer y pwyntydd sy'n cyfeirio at "Boom".
Nid oes angen i mi neilltuo lle ar gyfer "Boom" ei hun
oherwydd mae hyn yn y bôn cyfateb i'r hyn a ddywedais o'r blaen
o torgoch * x = "Boom".
"Boom" yn bodoli eisoes. Mae'n digwydd i fodoli yn y rhanbarth darllen yn unig cof.
Ond mae'n bodoli eisoes, sy'n golygu y llinell hon o god, os yw yn ** torgoch,
yna * s yn * torgoch ac rydych yn gosod y * torgoch i bwyntio at "Boom".
Os byddaf yn awyddus i gopïo "Boom" yn s, yna byddai angen i mi neilltuo lle ar s.
Fe ddylwn i ei wneud * s = malloc (sizeof (torgoch) * 5);
Pam 5?
Pam na 4? Mae'n edrych fel "Boom" yw 4 cymeriadau. >> [Myfyrwyr] Y cymeriad nwl.
Yeah. Mae eich holl llinynnau yn mynd i angen y cymeriad null.
Nawr gallaf wneud rhywbeth fel strcat - Beth yw swyddogaeth ar gyfer copïo llinyn?
[Myfyrwyr] cpy? >> Strcpy.
strcpy dyn.
Felly strcpy neu strncpy.
strncpy yn ychydig yn fwy diogel gan y gall eich bod yn nodi yn union faint o gymeriadau,
ond yma nid oes ots oherwydd ein bod yn gwybod.
Felly strcpy ac yn edrych yn y dadleuon.
Y ddadl cyntaf yw ein cyrchfan.
Yr ail ddadl yw ein ffynhonnell.
Rydym yn mynd i gopïo i mewn i'n * cyrchfan s y pwyntydd "Boom".
Pam y gallai byddwch am wneud hyn gyda strcpy hytrach na dim ond yr hyn a oedd gennym o'r blaen
o * s = "Boom"?
Mae yna reswm efallai y byddwch am wneud hyn, ond beth yw y rheswm?
[Myfyrwyr] Os ydych chi am newid rhywbeth yn "Boom". >> Yeah.
Nawr gallaf wneud rhywbeth fel s [0] = 'X';
oherwydd mae pwyntiau s at y domen a bod lle ar y domen fod ef yn pwyntio at
rhoi syniad inni am mwy o le ar y domen, sy'n cael ei storio "Boom".
Felly, mae hyn copi o "Boom" yn cael ei storio yn y domen.
Mae dechnegol dau gopi o "Boom" yn ein rhaglen.
Mae yr un cyntaf sydd wedi rhoi dim ond gan y cyson llinyn "Boom",
a'r ail gopi o "Boom", strcpy greodd y copi o "Boom".
Ond mae'r copi o "Boom" yn cael ei storio ar y domen, a'r domen rydych chi'n rhydd i newid.
Nid yw'r domen yn darllen yn unig, felly mae hynny'n golygu bod s [0]
yn mynd i adael i chi newid y gwerth o "Boom".
Mae'n mynd i adael i chi newid y cymeriadau.
>> Cwestiynau?
Iawn.
>> Symud ymlaen at buggy3, gadewch i gdb buggy3.
Rydym yn unig yn rhedeg a gwelwn ni gael segfault.
Os ydym yn olrheiniad, dim ond dwy swyddogaeth.
Os ydym yn mynd i fyny i mewn i'n prif swyddogaeth, rydym yn gweld ein bod yn segfaulted yn y llinell hon.
Felly, dim ond edrych ar y llinell hon, am (int llinell = 0; fgets y pethau hyn yn NULL nid cyfartal;
llinell + +).
Mae ein ffrâm flaenorol a elwir yn _IO_fgets.
Byddwch yn gweld bod llawer gyda adeiledig mewn swyddogaethau C,
pan fyddwch yn cael y segfault, bydd enwau swyddogaeth wirioneddol cryptig
fel hyn _IO_fgets.
Ond mae hynny'n mynd i ymwneud â'r alwad hon fgets.
Rhywle y tu mewn yma, rydym yn segfaulting.
Os ydym yn edrych ar y dadleuon i fgets, gallwn argraffu byffer.
Gadewch i ni argraffu fel a - O, na.
Nid Print yn mynd i weithio yn union fel yr wyf am iddo.
Gadewch i ni edrych ar y rhaglen ei hun.
Byffer yn amrywiaeth cymeriad. Mae'n gymeriad amrywiaeth o 128 nod.
Felly, pan fyddaf yn dweud byffer print, mae'n mynd i argraffu rhai 128 nod,
yr wyf yn dyfalu yn yr hyn a ddisgwylir.
Hyn yr oeddwn yn chwilio amdano yw argraffu'r cyfeiriad byffer,
ond nid yw hynny'n wir dweud wrthyf lawer.
Felly, pan fyddaf yn digwydd i ddweud hyd yma x byffer, mae'n dangos i mi 0xbffff090,
sydd, os ydych yn cofio o gyfnod cynharach neu ryw bwynt, Oxbffff yn tueddu i fod yn rhanbarth bentwr-ish.
Mae'r stac yn tueddu i ddechrau yn rhywle ychydig o dan 0xc000.
Dim ond trwy weld y cyfeiriad hwn, yr wyf yn gwybod bod byffer sy'n digwydd ar y pentwr.
Ailddechrau fy rhaglen, a gynhelir, i fyny, clustogi a welsom yn y dilyniant o gymeriadau
sy'n 'n bert lawer ddiystyr.
Yna argraffu ffeil, beth yw ffeil yn edrych fel?
[Myfyrwyr] Null. >> Yeah.
Ffeil yn o * FILE fath, felly mae'n pwyntydd,
a gwerth y pwyntydd yn null.
Felly fgets yn mynd i geisio i ddarllen o'r pwyntydd mewn ffordd anuniongyrchol,
ond er mwyn cael mynediad y pwyntydd, mae'n rhaid iddo dereference iddo.
Neu, er mwyn cael mynediad yr hyn y dylid ei fod yn pwyntio ato, dereferences hynny.
Felly, mae'n dereferencing pwyntydd nwl ac mae'n segfaults.
Gallwn fod wedi ailgychwyn yn y fan honno.
Os ydym yn ei dorri yn ein prif bwynt a rhedeg,
y llinell gyntaf cod yn torgoch * enw ffeil = "nonexistent.txt";
Dylai hynny roi awgrym eithaf mawr o ran pam y rhaglen hon yn methu.
Teipio nesaf dod â mi at y llinell nesaf, lle yr wyf yn agor y ffeil,
ac yna yn syth mynd i mewn ein llinell, lle ar ôl i mi daro nesaf, mae'n mynd i segfault.
A oes unrhyw un eisiau i daflu allan rheswm pam y byddwn yn segfaulting?
Nid yw [myfyrwyr] Ffeil yn bodoli. >> Yeah.
Mae hyn yn dybiedig i fod yn awgrym
bod unrhyw un rydych chi'n agor ffeil angen i chi wirio bod y ffeil yn bodoli mewn gwirionedd.
Felly yma, "nonexistent.txt";
Pan fyddwn yn enw'r ffeil fopen ar gyfer darllen, bydd wedyn angen i ddweud
os (ffeil == NULL) a dweud printf ("Nid yw'r ffeil yn bodoli!"
neu - yn well eto - enw ffeil); dychwelyd 1;
Felly, nawr rydym yn gwirio i weld os yw'n NULL
cyn mewn gwirionedd yn parhau ac yn ceisio darllen o'r ffeil.
Gallwn ei ail-lunio dim ond i weld fod hynny'n gweithio.
Oeddwn yn bwriadu i gynnwys llinell newydd.
Felly erbyn hyn nid nonexistent.txt yn bodoli.
Dylech bob tro edrych am y math hwn o beth.
Dylech bob amser wirio i weld os fopen dychwelyd null.
Dylech bob amser wirio i wneud yn siŵr nad yw malloc yn dychwelyd NULL,
neu arall rydych segfault.
>> Nawr buggy4.c.
Rhedeg. Rwy'n dyfalu hyn yn aros am fewnbwn neu dolennu o bosibl ddiddiwedd.
Ydy, mae'n dolennu ddiddiwedd.
Felly buggy4. Mae'n edrych fel ein bod dolennu ddiddiwedd.
Gallwn dorri ar y prif, yn rhedeg ein rhaglen.
Yn gdb, cyn belled â bod y talfyriad rydych yn ei ddefnyddio yn ddiamwys
neu dalfyriadau arbennig y maent yn ei ddarparu i chi,
yna gallwch ddefnyddio n defnyddio nesaf yn hytrach na gorfod teipio allan wrth yr holl ffordd.
Ac yn awr fy mod i wedi taro n unwaith, gall Fi jyst daro Enter i gadw i fynd nesaf
yn hytrach na gorfod daro n Mewnbynnu, n Mewnbynnu, n Enter.
Mae'n edrych fel fy mod yn rhyw fath o ddolen i sydd wedi gosod amrywiaeth [i] i 0.
Mae'n edrych fel erioed fy mod yn torri allan o hyn ar gyfer dolen.
Os byddaf yn argraffu i, felly fi yw 2, yna byddaf yn mynd nesaf.
'N annhymerus' argraffu i, fi yn 3, yna byddaf yn mynd nesaf.
'N annhymerus' argraffu i a fi yw 3. Nesaf, argraffu i, i yw 4.
Mewn gwirionedd, print sizeof (array), felly faint o amrywiaeth yw 20.
Ond mae'n edrych fel mae rhywfaint o gorchymyn gdb arbennig ar gyfer mynd nes bod rhywbeth yn digwydd.
Mae fel gosod amod ar y gwerth y newidyn. Ond nid wyf yn cofio yr hyn ydyw.
Felly, os ydym yn dal i fynd -
Beth oeddech chi'n ei ddweud? Beth wnaethoch chi ddod i fyny?
[Myfyrwyr] yw dangos i ychwanegu - >> Yeah. Felly arddangos gallu i helpu.
Os ydym yn unig arddangos i, bydd yn rhoi i fyny dyma beth yw gwerth i yw
felly nid oes rhaid i mi ei hargraffu bob tro.
Os ydym yn unig yn cadw mynd nesaf, rydym yn gweld 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5.
Mae rhywbeth yn mynd o'i le ofnadwy, a fi yn cael ei ailosod i 0.
O edrych ar buggy4.c, gwelwn cyfan sy'n digwydd yw amrywiaeth int [5];
ar gyfer (i = 0; i <= sizeof (arae): i + +)
array [i] = 0;
Beth rydyn ni'n gweld bod yn anghywir yma?
Fel awgrym, pan oeddwn yn gwneud y gdb buggy4 - gadewch i ni dorri prif, rhedeg -
Wnes i ddim print sizeof (arae) dim ond i weld beth yw'r cyflwr yn lle y dylai yn olaf torri allan.
Ble ydw i? Wnes i redeg?
Doeddwn i ddim yn datgan eto.
Felly argraffu sizeof (amrywiaeth) a dyna 20,
a ddisgwylir ers fy amrywiaeth o faint 5 a mae'n o 5 cyfanrifau,
felly dylai y peth cyfan yn 5 * sizeof (canolradd) bytes, lle sizeof (canolradd) yn tueddu i fod yn 4.
Felly sizeof (arae) yw 20.
Beth ddylai hyn fod?
[Myfyrwyr] wedi ei rannu â sizeof (canolradd). >> Yeah, / sizeof (canolradd).
Mae'n edrych fel mae dal i fod yn broblem yma. Rwy'n credu y dylai hon fod <
gan ei fod yn 'n bert lawer bob amser byth <a <=.
Nawr, gadewch i ni feddwl am pam fod hyn wedi torri mewn gwirionedd.
A oes unrhyw un wedi dyfalu pam yr oedd i ailosod i 0 drwy bob fersiwn o'r ddolen?
Yr unig beth y tu mewn yma sy'n digwydd yw bod amrywiaeth [i] yn cael ei osod i 0.
Felly, rhywsut, y llinell hon o god yn achosi ein int i gael ei osod i 0.
A allai [myfyrwyr] yn cael ei oherwydd ei fod yn bwysicach y cof am y rhan hon o i
pan fydd yn meddwl ei fod yn elfen nesaf o amrywiaeth? >> [Bowden] Ydw.
Pan fyddwn ni'n mynd y tu hwnt i ddiwedd ein amrywiaeth,
rywsut lle hwnnw ein bod yn bwysicach yn gwrthwneud y gwerth i.
Ac felly os ydym yn edrych i mewn buggy4, torri prif, rhedeg,
gadewch i ni argraffu'r cyfeiriad i.
Mae'n edrych fel ei fod bffff124.
Nawr gadewch i ni argraffu'r cyfeiriad amrywiaeth [0]. 110.
Beth am [1]? 114.
[2], 118.
11c, 120. array [5] yn bfff124.
Felly amrywiaeth [5] yn yr un cyfeiriad fel fi, sy'n golygu bod amrywiaeth [5] yn i.
Os oes ganddynt yr un cyfeiriad, maent yn yr un peth.
Felly, pan fyddwn yn gosod amrywiaeth [5] i 0, rydym yn gosod i i 0.
Ac os ydych yn meddwl am hyn o ran y simnai,
int i gael ei ddatgan yn gyntaf, sy'n golygu i cael rhywfaint o le ar y pentwr.
Yna array [5] yn cael ei ddyrannu, felly nag 20 bytes yn cael eu dyrannu ar y pentwr.
Felly, fi yn cael ei ddyrannu yn gyntaf, yna yr 20 bytes cael ddyrannu.
Felly, fi fydd yn digwydd i'r dde cyn y array,
ac oherwydd y ffordd, fel y dywedais yr wythnos diwethaf, pan fo hynny'n dechnegol y pentwr tyfu am i lawr,
pan fyddwch yn fynegai i mewn i amrywiaeth, rydym yn gwarantu fod y sefyllfa 0 yn yr amrywiaeth
bob amser yn digwydd cyn y safle cyntaf yn y rhesi.
Mae hyn yn fath o sut yr wyf yn tynnodd yr wythnos diwethaf.
Sylwch fod ar y gwaelod mae gennym gyfeiriad 0 a ar y brig mae gennym Max gyfeiriad.
Mae'r stac bob amser yn tyfu i lawr.
Lets 'ddeud yr ydym yn dyrannu i.
Rydym yn neilltuo cyfanrif i, sy'n golygu gadewch i 'jyst dweud yma cyfanrif i yn cael ei ddyrannu.
Yna yr ydym yn dyrannu ein amrywiaeth o 5 cyfanrifau, sy'n golygu bod o dan hynny,
gan fod y pentwr yn tyfu i lawr, rhai 5 cyfanrif yn cael eu dyrannu.
Ond oherwydd y ffordd y araeau yn gweithio, rydym yn gwarantu bod y safle cyntaf yn y casgliad
bob amser hwnnw gyfeiriad llai na'r ail beth yn y rhesi.
Felly 0 sefyllfa amrywiaeth bob amser i ddigwydd yn gyntaf er cof,
tra bod 1 Sefyllfa amrywiaeth rhaid i ddigwydd ar ôl hynny
a 2 safle array rhaid i ddigwydd ar ôl hynny,
sy'n golygu y byddai amrywiaeth 0 sefyllfa yn digwydd yn rhywle i lawr yma,
byddai 1 swydd amrywiaeth yn digwydd uwch na'r hyn a
oherwydd gall symud i fyny yn golygu cyfeiriadau yn uwch ers i'r cyfeiriad mwyaf yw i fyny yma.
Felly amrywiaeth [0] i lawr yma, array [1] i fyny yma, array [2] i fyny yma, array [3] i fyny yma.
Hysbysiad sut cyn i ni ddyrannu cyfanrif i holl ffordd i fyny yma,
wrth i ni symud ymhellach ac ymhellach i mewn i'n amrywiaeth, rydym yn dod yn nes ac yn nes at ein cyfanrif i.
Fel mae'n digwydd bod amrywiaeth [5], sy'n un sefyllfa y tu hwnt i'n array,
yn union ble i gyfanrif digwydd i'w ddyrannu.
Felly, dyna'r pwynt lle rydym yn digwydd bod yn taro y gofod ar y pentwr
a ddyrannwyd ar gyfer cyfanrif i, ac rydym yn gosod y i 0.
>> Dyna sut mae hynny'n gweithio. Cwestiynau? Yeah.
[Myfyrwyr] Peidiwch byth â meddwl. Iawn.
[Myfyrwyr] Sut ydych chi'n osgoi y math yma o wallau?
Mae'r rhain yn fath o wallau? Peidiwch â defnyddio C fel eich iaith raglennu.
Defnyddiwch iaith sydd â ffiniau amrywiaeth gwirio.
Cyn belled ag y byddwch chi'n ofalus, 'ch jyst angen i osgoi mynd heibio ffiniau eich casgliad.
[Myfyrwyr] Felly dyma pan fyddwn yn mynd heibio i ffiniau eich amrywiaeth -
[Bowden] Dyna ble mae pethau yn dechrau mynd o'i le. >> [Myfyrwyr] O, iawn.
Cyn belled ag y byddwch yn aros o fewn y cof dyrannu ar gyfer eich array, eich bod yn iawn.
Ond C ni wna unrhyw wirio gwall. Os byddaf yn gwneud amrywiaeth [1000], bydd yn llawen dim ond addasu beth bynnag sy'n digwydd -
Mae'n mynd i ddechrau'r array, yna mae'n mynd ar ôl 1000 swyddi ac yn gosod i 0.
Nid yw'n gwneud unrhyw gwirio nad oh, nid yw hyn yn mewn gwirionedd yn wedi 1000 bethau ynddo.
1000 ymhell y tu hwnt yr hyn y dylwn ei newid,
tra Java neu rywbeth fe gewch amrywiaeth yn waharddedig mynegai
neu fynegai y tu allan i ffiniau eithriad.
Dyna pam mae llawer o ieithoedd ar lefel uwch yn cael y pethau hyn
lle os byddwch yn mynd y tu hwnt i ffiniau'r array, byddwch yn methu
fel nad oes modd i chi newid pethau o dan eich
ac yna pethau'n mynd yn waeth o lawer na dim ond cael eithriad
dweud eich bod yn mynd y tu hwnt i ddiwedd y rhesi.
[Myfyrwyr] A ddylai felly rydym wedi newid dim ond y <= i ychydig <? >> [Bowden] Yeah.
Dylai fod yn <sizeof (arae) / sizeof (int);
ers sizeof (arae) yw 20, ond dim ond am 5. >> [Myfyrwyr] Hawl.
Mwy o gwestiynau? Iawn.
>> [Myfyrwyr] Mae gen i gwestiwn. >> Yeah.
[Myfyrwyr] Beth yw'r newidyn amrywiaeth gwirioneddol?
[Bowden] Fel beth yw amrywiaeth?
Array ei hun yn symbol.
Mae'n dim ond y cyfeiriad y dechrau yr 20 bytes yr ydym yn eu cyfeirio.
Gallwch feddwl amdano fel pwyntydd, ond mae'n rhoi syniad cyson.
Cyn gynted ag pethau'n cael eu llunio, nid yw'r casgliad amrywiol yn bodoli anymore.
[Myfyrwyr] Felly, sut mae'n dod o hyd i'r faint o amrywiaeth?
Maint o amrywiaeth yn cyfeirio at faint y bloc bod y symbol yn cyfeirio at.
Pan fyddaf yn gwneud rhywbeth fel printf ("% p \ n", array);
gadewch i ni redeg.
Beth wnes i jyst yn ei wneud o'i le?
'Array' Array datgan yma.
O, i fyny yma.
Clang yn glyfar, ac mae'n digwydd i sylwi fy mod yn datgan y casgliad fel 5 elfen
ond rwy'n mynegeio i mewn i sefyllfa 1000.
Gall wneud hynny oherwydd bod yn unig yw'r rhain gysonion.
Gall dim ond fynd mor bell yn sylwi fy mod yn mynd y tu hwnt i ffiniau'r y rhesi.
Ond cyn i sylwi pan oedd gennym i fod yn anghywir,
Ni all fod o bosibl yn penderfynu faint o werthoedd gallai i gymryd ar,
felly ni all benderfynu bod fi yn mynd tu hwnt i ddiwedd y rhesi.
Dyna Clang fod yn glyfar.
>> Ond yn awr yn gwneud buggy4. Felly beth arall ydw i'n ei wneud o'i le?
Ymhlyg yn datgan swyddogaeth llyfrgell 'printf'.
Rydw i'n mynd i eisiau i # cynnwys .
Iawn. Nawr yn rhedeg buggy4.
Argraffu gwerth yr amrywiaeth fel y gwnes i yma, ei brintio fel pwyntydd
printiau rhywbeth sy'n edrych fel hyn - bfb8805c - sydd tua gyfeiriad
sydd yn y rhanbarth pentwr-ish.
Array ei hun fel pwyntydd, ond nid yw'n pwyntydd go iawn,
gan fod pwyntydd rheolaidd gallwn newid.
Array yn unig yw rhai cyson. Mae'r 20 blociau o gof yn dechrau am 0xbfb8805c cyfeiriad.
Felly bfb8805c drwy'r cyfeiriad +20--neu yr wyf yn dyfalu -20 -
yw pob un o'r cof dyrannu ar gyfer y casgliad.
Array, nid yw'r newidyn ei hun yn cael ei storio yn unrhyw le.
Pan fyddwch chi'n casglu, y casglwr - don llaw arno -
ond bydd y casglwr yn ei ddefnyddio lle mae'n gwybod amrywiaeth i fod.
Mae'n gwybod i ble mae'r amrywiaeth yn dechrau,
ac felly mae'n gallu bob amser yn unig yn gwneud pethau yn nhermau gwrthbwyso o'r dechrau.
Nid oes angen newidyn ei hun i gynrychioli amrywiaeth.
Ond pan fyddaf yn gwneud rhywbeth fel int * p = array; yn awr p yn pwyntydd sy'n cyfeirio at y array,
ac yn awr p mewn gwirionedd yn bodoli ar y pentwr.
Rwy'n rhad ac am ddim i newid t. Gallaf ei wneud p = malloc.
Felly, yn wreiddiol yn tynnu sylw at amrywiaeth, yn awr mae'n cyfeirio at ychydig o le ar y domen.
Ni allaf wneud amrywiaeth = malloc.
Os Clang yn glyfar, bydd yn gweiddi arnaf dde oddi ar y ystlumod.
A dweud y gwir, rwy'n eithaf siwr y byddai gcc wneud hyn hefyd.
Felly fath array 'int [5]' Nid yn aseiniadwy.
Ni allwch neilltuo rhywbeth i fath amrywiaeth
oherwydd amrywiaeth yn unig yw gyson.
Mae'n symbol sy'n cyfeiriadau yr 20 bytes. Nid wyf yn gallu ei newid.
>> [Myfyrwyr] A ble mae'r maint y rhesi storio?
[Bowden] Dyw hi ddim yn cael ei storio yn unrhyw le. Mae'n pan fydd yn llunio.
Felly, ble mae'r maint o amrywiaeth storio?
Gallwch ddefnyddio sizeof (arae) tu mewn i'r swyddogaeth y mae'r casgliad yn cael ei ddatgan ei hun.
Felly, os wyf yn gwneud rhywfaint o swyddogaeth, foo, ac yr wyf yn ei wneud (int array [])
printf ("% d \ n", sizeof (arae));
ac yna i lawr yma galwaf foo (arae);
tu mewn swyddogaeth hon - gadewch i ni redeg.
Mae hyn yn Clang fod yn glyfar eto.
Mae'n dweud wrthyf fod sizeof ar paramedr swyddogaeth amrywiaeth
bydd yn dychwelyd maint o '* int'.
Byddai hyn yn gwall os nad yw'n hyn yr wyf eisiau iddo ddigwydd.
Gadewch i ni mewn gwirionedd yn diffodd Werror.
Rhybudd. Rhybuddion yn iawn.
Bydd yn dal i lunio cyn belled â'i fod yn cael rhybudd.
. / A.out yn mynd i argraffu 4.
Mae'r rhybudd a gynhyrchwyd yn ddangosydd clir o'r hyn a aeth o'i le.
Mae'r amrywiaeth int yn unig yn mynd i argraffu sizeof (int *).
Hyd yn oed os wyf yn rhoi amrywiaeth [5] i mewn yma, mae'n dal i jyst yn mynd i argraffu sizeof (int *).
Felly, cyn gynted ag y byddwch yn ei drosglwyddo i mewn i swyddogaeth, mae'r gwahaniaeth rhwng araeau ac awgrymiadau
yn ddim yn bodoli.
Mae hyn yn digwydd i fod yn amrywiaeth a datgan ar y simnai,
ond cyn gynted ag y byddwn yn rhoi y gwerth, y 0xbf blah, blah, blah yn y swyddogaeth hon,
yna mae hyn pwyntydd cyfeirio at y casgliad ar y pentwr.
Felly golyga hyn bod sizeof ond yn berthnasol yn y swyddogaeth y mae'r amrywiaeth gael ei ddatgan,
sy'n golygu, pan fyddwch yn casglu swyddogaeth hon,
pan Clang mynd drwy'r swyddogaeth hon, mae'n gweld amrywiaeth yn int amrywiaeth o ran maint 5.
Felly, yna mae'n gweld sizeof (arae). Wel, dyna 20.
Dyna mewn gwirionedd sut y sizeof yn y bôn yn gweithio ar gyfer bron pob achos.
Nid yw Sizeof yn swyddogaeth; ei fod yn weithredwr.
Nid ydych yn galw swyddogaeth sizeof.
Sizeof (canolradd), bydd y casglwr yn unig drosi hynny i 4.
Got hyn? Iawn.
>> [Myfyrwyr] Felly beth yw'r gwahaniaeth rhwng sizeof (arae) yn y brif ac yn foo?
Mae hyn oherwydd ein bod yn dweud sizeof (array), sydd o * int fath,
tra bod y casgliad i lawr yma yw nid * int fath, mae'n arae int.
>> [Myfyrwyr] Felly, os ydych wedi cael y paramedr mewn amrywiaeth [] yn hytrach na amrywiaeth * int,
Byddai hynny'n golygu y gallech ddal i newid amrywiaeth oherwydd erbyn hyn mae'n pwyntydd?
[Bowden] Fel hyn? >> [Myfyrwyr] Yeah. Allwch chi newid amrywiaeth o fewn y swyddogaeth nawr?
[Bowden] Gallech newid amrywiaeth yn y ddau achos.
Yn y ddau achos hyn rydych yn rhydd i ddweud amrywiaeth [4] = 0.
[Myfyrwyr] Ond gallwch wneud pwynt amrywiaeth i rywbeth arall?
[Bowden] Oh. Yeah. Yn y naill achos neu'r llall - >> [myfyrwyr] Yeah.
[Bowden] Mae'r gwahaniaeth rhwng amrywiaeth [] ac amrywiaeth * int, nid oes dim.
Gallwch hefyd gael rhywfaint o amrywiaeth amlddimensiwn yma
ar gyfer rhai cystrawen cyfleus, ond mae'n dal i fod dim ond pwyntydd.
Mae hyn yn golygu fy mod yn rhydd i wneud array = malloc (sizeof (canolradd)); ac yn awr pwyntio rhywle arall.
Ond yn union fel sut mae hyn yn gweithio am byth a bob amser,
newid y casgliad trwy ei gwneud yn cyfeirio at rywbeth arall
nid yw'n newid y casgliad i lawr yma am ei fod yn gopi o'r ddadl,
nid yw'n rhoi syniad inni am y ddadl honno.
Ac mewn gwirionedd, yn union fel arwydd mwy ei fod yn union yr un fath -
rydym eisoes yn gweld yr hyn a phrintiau argraffu amrywiaeth -
beth os ydym yn argraffu'r cyfeiriad y rhesi neu gyfeiriad y cyfeiriad y rhesi
naill ai o'r rheiny?
Gadewch i ni anwybyddu'r hwn.
Iawn. Mae hyn yn iawn. Mae'n awr yn rhedeg. / A.out.
Array argraffu, ac yna argraffu'r cyfeiriad y rhesi, yn yr un peth.
Array nid yn unig yn bodoli.
Mae'n gwybod pan fyddwch chi'n argraffu array, rydych yn argraffu'r symbol sy'n cyfeirio at yr 20 bytes.
Argraffu y cyfeiriad y rhesi, wel, nid amrywiaeth yn bodoli.
Nid oes ganddo gyfeiriad, felly mae'n dim ond argraffu'r cyfeiriad o blith yr 20 bytes.
Cyn gynted ag y byddwch yn llunio i lawr, fel yn eich buggy4 luniwyd. / A.out,
amrywiaeth yn ddim yn bodoli.
Pointers bodoli. Nid yw araeau wneud.
Mae blociau o gof sy'n cynrychioli amrywiaeth yn dal i fodoli,
ond nid yr amrywiaeth amrywiol a newidynnau o'r fath yn bodoli.
Dyna fel y prif wahaniaethau rhwng araeau ac awgrymiadau
yn cael eu cyn gynted ag y byddwch yn gwneud galwadau swyddogaeth, nid oes gwahaniaeth.
Ond tu mewn i'r swyddogaeth y mae'r casgliad ei hun yn ei ddatgan, sizeof yn gweithio yn wahanol
ers i chi yn argraffu maint y blociau yn hytrach na maint y math,
ac ni allwch ei newid am ei fod yn symbol.
Argraffu y peth a chyfeiriad y peth printiau yr un peth.
A dyna 'n bert lawer iddo.
[Myfyrwyr] Allech chi ddweud bod un mwy o amser?
Efallai fy mod wedi colli rhywbeth.
Amrywiaeth Argraffu a chyfeiriad amrywiaeth yn argraffu'r un peth,
ond os ydych yn argraffu pwyntydd yn erbyn cyfeiriad y pwyntydd,
yr un peth yn argraffu'r cyfeiriad hyn yr ydych yn cyfeirio at,
y llall yn argraffu'r cyfeiriad y pwyntydd ar y pentwr.
Gallwch newid pwyntydd, nad ydych yn gallu newid yn symbol arae.
Ac sizeof pwyntydd yn mynd i argraffu faint y math pwyntydd.
Felly int * p sizeof (p) yn mynd i argraffu 4,
ond int array [5] print sizeof (arae) yn mynd i argraffu 20.
[Myfyrwyr] Felly, int array [5] yn argraffu 20? >> Ydy.
Dyna pam y tu mewn o buggy4 pryd yr arferai fod sizeof (arae)
hyn yn ei wneud i <20, nad yw hyn yr ydym ei eisiau.
Rydym am i <5. >> [Myfyrwyr] Iawn.
[Bowden] Ac yna cyn gynted ag y byddwch yn dechrau pasio yn y swyddogaethau,
os ydym yn gwneud int * p = array;
y tu mewn swyddogaeth hon, gallwn ddefnyddio bôn p ac amrywiaeth yn union yr un ffordd,
heblaw am y broblem sizeof a'r broblem sy'n newid.
Ond p [0] = 1; yr un fath â dweud array [0] = 1;
A chyn gynted ag yr ydym yn dweud foo (arae), neu foo (p);
tu mewn i'r swyddogaeth foo, dyma'r alwad un ddwywaith.
Nid oes unrhyw wahaniaeth rhwng y ddwy alwad.
>> Mae pawb yn dda ar hynny? Iawn.
Mae gennym 10 munud.
>> Byddwn yn ceisio cael drwy'r Typer Hacker rhaglen,
y wefan hon, a ddaeth allan y flwyddyn ddiwethaf neu rywbeth.
Mae 'n dybiedig yn unig i fod yn debyg i chi ei deipio ar hap ac y bydd yn argraffu allan -
Beth bynnag ffeil mae'n digwydd i fod wedi eu llwytho yn yr hyn y mae'n edrych fel eich bod yn teipio.
Mae'n edrych fel rhyw fath o god system weithredu.
Dyna beth yr ydym am ei weithredu.
Dylai fod gennych gweithredadwy deuaidd a enwir hacker_typer
sy'n cymryd mewn dadl sengl, y ffeil i "fath haciwr."
Dylai Rhedeg y cyflawnadwy clirio'r sgrin
ac yna ei argraffu ar un cymeriad o'r ffeil basio i mewn bob tro y mae'r defnyddiwr yn pwyso allweddol.
Felly, beth bynnag allweddol fyddwch yn y wasg, dylai ei daflu i ffwrdd ac yn lle argraffu cymeriad o'r ffeil
hynny yw y ddadl.
'N annhymerus' 'n bert lawer yn dweud wrthych beth y pethau yr ydym yn mynd i angen i chi wybod yn.
Ond rydym am edrych ar y llyfrgell termios.
Nid wyf erioed wedi defnyddio'r llyfrgell yn fy mywyd cyfan, felly mae wedi ddibenion fach iawn.
Ond mae hyn yn mynd i fod y llyfrgell gallwn ei ddefnyddio i daflu i ffwrdd y cymeriad chi daro
pan fyddwch yn teipio i mewn i safon mewn
Felly hacker_typer.c, ac rydym yn mynd i eisiau i # gynnwys .
O edrych ar y dudalen dyn am termios - I'm dyfalu ei derfynell OS neu rywbeth -
Nid wyf yn gwybod sut i ddarllen.
Edrych ar hyn, mae'n dweud i gynnwys y 2 ffeil, felly byddwn yn gwneud hynny.
>> Y peth cyntaf yn gyntaf, rydym am eu cymryd wrth dadl sengl, sef y ffeil dylem agor.
Felly, beth ydw i eisiau ei wneud? Sut ydw i'n gwirio i weld gen i ddadl sengl?
[Myfyrwyr] Os argc yn dychwelyd iddo. >> [Bowden] Yeah.
Felly, os (argc = 2!) Printf ("defnydd:% s [Ffeil i agor]").
Felly, nawr os byddaf yn rhedeg hyn heb ddarparu ail ddadl - oh, yr wyf angen y llinell newydd -
byddwch yn gweld ei fod yn dweud defnydd:. / hacker_typer,
ac yna dylai'r ail ddadl yn y ffeil gallaf eisiau agor.
Nawr beth ddylwn i ei wneud?
Rwyf am i ddarllen o'r ffeil hon. Sut ydw i'n darllen o ffeil?
[Myfyrwyr] Byddwch yn agor ei gyntaf. >> Yeah.
Felly fopen. Beth mae fopen yn edrych fel?
[Myfyrwyr] Filename. >> [Bowden] Filename yn mynd i fod argv [1].
[Myfyrwyr] Ac yna beth rydych am ei wneud ag ef, felly y - >> [Bowden] Yeah.
Felly os nad ydych yn cofio, dim ond gallech wneud fopen dyn,
lle mae'n mynd i fod yn llwybr * torgoch Etholaeth lle mae'r llwybr yn enw'r ffeil,
modd * torgoch Etholaeth.
Os ydych yn digwydd i ddim yn cofio pa fodd, yna gallwch chi chwilio am fodd.
Y tu mewn o dudalennau dyn, y cymeriad slaes yn yr hyn y gallwch ei ddefnyddio i chwilio am bethau.
Felly, yr wyf deipio / fodd i chwilio am modd.
n ac E yn yr hyn y gallwch ei ddefnyddio i feicio drwy gemau chwilio.
Yma, mae'n dweud y pwyntiau ddadl modd i linyn
ddechrau gydag un o'r dilyniannau canlynol.
Felly r, ffeil testun Agored ar gyfer darllen. Dyna beth yr ydym am ei wneud.
Am ddarllen, ac rwyf am i storio hynny.
Y peth yw mynd i fod yn * FILE. Nawr beth ydw i eisiau ei wneud?
Rhowch i mi ail.
Iawn. Nawr beth ydw i eisiau ei wneud?
[Myfyrwyr] Edrychwch i weld a yw'n null. >> [Bowden] Yeah.
Unrhyw bryd y byddwch yn agor ffeil, gwnewch yn siŵr eich bod yn llwyddiannus yn gallu ei agor.
>> Nawr rwyf am wneud hynny pethau termios i ble yr hoffwn yn gyntaf ddarllen fy gosodiadau cyfredol
ac arbed rhai i mewn i rywbeth, yna rwyf am newid fy lleoliadau
i daflu i ffwrdd unrhyw gymeriad fy mod yn teipio,
ac yna rwyf am i ddiweddaru y lleoliadau hynny.
Ac yna ar ddiwedd y rhaglen, yr wyf am newid yn ôl i fy lleoliadau gwreiddiol.
Felly, mae'r strwythur yn mynd i fod o termios fath, ac yr wyf i'n mynd i eisiau dau o'r rheiny.
Mae'r un cyntaf yn mynd i fod fy current_settings,
ac yna maent yn mynd i fod fy hacker_settings.
Yn gyntaf, yr wyf i'n mynd i am arbed fy gosodiadau cyfredol,
yna rwy'n mynd i eisiau i ddiweddaru hacker_settings,
ac yna ffordd ar ddiwedd fy rhaglen, yr wyf eisiau dychwelyd i'r gosodiadau cyfredol.
Felly arbed gosodiadau cyfredol, y ffordd sy'n gweithio, termios dyn ni.
Rydym yn gweld bod gennym y tcsetattr int, int tcgetattr.
Rwy'n pasio mewn strwythur termios gan ei pwyntydd.
Mae'r ffordd y bydd hyn yn edrych yn - I've anghofio eisoes beth yw swyddogaeth ei alw.
Copïwch a gludwch ef.
Felly tcgetattr, yna rwyf am i basio yn y strwythur fy mod yn arbed y wybodaeth i mewn,
sydd yn mynd i fod yn current_settings,
ac mae'r ddadl gyntaf yw'r disgrifydd ffeil ar gyfer y peth yr wyf am gadw'r nodweddion.
Beth mae'r disgrifydd ffeil yn debyg i unrhyw tro y byddwch yn agor ffeil, ei fod yn cael disgrifydd ffeil.
Pan fyddaf yn fopen argv [1], ei fod yn cael disgrifydd ffeil yr ydych yn cyfeirio
pryd bynnag y dymunwch i ddarllen neu ysgrifennu ato.
Nid dyna'r disgrifydd ffeil Rwyf eisiau defnyddio yma.
Mae tri disgrifiadau ffeil sydd gennych yn ddiofyn,
sy'n safonol mewn, allan safonol, a gwallau safonol.
Yn ddiofyn, yr wyf yn meddwl ei fod yn safonol yw 0, safon allan yw 1, ac gwall safonol yw 2.
Felly, beth ddylwn i ei eisiau newid y gosodiadau o?
Rwyf am i newid y gosodiadau o bryd bynnag yr wyf yn taro cymeriad,
Yr wyf am iddo daflu i ffwrdd y cymeriad yn hytrach na argraffu i'r sgrin.
Pa ffrwd - safonol mewn, allan safonol, neu wall safonol -
yn ymateb i bethau pan fyddaf yn teipio ar y bysellfwrdd? >> [Myfyrwyr] Safon i mewn >> Yeah.
Felly gallaf naill ai wneud 0 neu y gallaf ei wneud stdin.
Rwy'n cael y current_settings o safon mewn
>> Nawr rwyf am i ddiweddaru lleoliadau hynny,
felly yn gyntaf byddaf yn copïo i mewn i hacker_settings beth yw fy current_settings yn cael eu.
A sut structs gwaith y bydd yn ei ddynwared.
Mae hyn copïau holl feysydd, fel y byddech yn ei ddisgwyl.
>> Nawr rwyf am i ddiweddaru rhai o'r caeau.
Edrych ar termios, byddai'n rhaid i chi ddarllen trwy lawer o hyn
dim ond i weld beth fyddech chi eisiau i chwilio am,
ond mae'r baneri ydych yn mynd i eisiau i chwilio am eu adlais,
felly ECHO cymeriadau mewnbwn Echo.
Yn gyntaf hoffwn nodi - I've anghofio eisoes beth yw'r caeau yn cael eu.
Dyma beth mae'r strwythur yn edrych fel.
Felly dulliau mewnbwn Rwy'n credu ein bod eisiau newid.
Byddwn yn edrych ar yr ateb i wneud yn siŵr bod beth yr ydym am ei newid.
Rydym yn awyddus i newid lflag er mwyn atal yr angen i edrych trwy hyn i gyd.
Rydym yn awyddus i newid dulliau lleol.
Byddai'n rhaid i chi ddarllen drwy'r peth cyfan i ddeall lle mae popeth yn perthyn
yr ydym am ei newid.
Ond mae'n tu mewn dulliau lleol lle rydym yn mynd i am newid hynny.
Felly hacker_settings.cc_lmode hyn fe'i gelwir.
c_lflag.
Dyma lle rydym yn mynd i mewn i weithredwyr bitwise.
Rydym yn fath o allan o amser, ond byddwn yn mynd drwyddo gyflym go iawn.
Dyma lle rydym yn mynd i mewn i weithredwyr bitwise,
lle rwy'n meddwl fy mod dywedodd un amser maith yn ôl pryd bynnag y byddwch yn dechrau delio gyda baneri,
rydych yn mynd i gael ei ddefnyddio bitwise gweithredwr llawer.
Mae pob rhan yn y faner yn cyfateb i ryw fath o ymddygiad.
Felly yma, y ​​faner hon wedi i griw o bethau gwahanol, lle mae pob un ohonynt yn golygu rhywbeth gwahanol.
Ond yr hyn rwyf am ei wneud yn unig yw troi oddi ar y darn sy'n cyfateb i ECHO.
Felly, i droi bod i ffwrdd ddylwn i ei wneud & = ¬ ECHO.
A dweud y gwir, yr wyf yn meddwl ei fod yn debyg tECHO neu rywbeth. Im 'jyst yn mynd i wirio eto.
Gallaf termios hynny. Mae'n dim ond ECHO.
ECHO yn mynd i fod ychydig yn sengl.
¬ ECHO yn mynd i olygu pob ddarnau yn cael eu gosod i 1, sy'n golygu bod yr holl baneri yn cael eu gosod i gwir
ac eithrio ar gyfer y rhan ECHO.
Drwy dod i ben fy baneri lleol â hyn, mae'n golygu'r holl faneri sy'n cael eu gosod ar hyn o bryd yn wir
yn dal i gael eu gosod i gwir.
Os bydd fy baner ECHO yn cael ei gosod i gwir, yna mae hyn yn cael ei osod o reidrwydd i ffug ar y faner ECHO.
Felly y llinell hon o god dim ond troi oddi ar y faner ECHO.
Mae'r llinellau eraill o god, 'n annhymerus' jyst adysgrifia yn y diddordeb o amser ac yna egluro iddynt.
Yn ateb, dywedodd 0.
Mae'n debyg well i ddweud yn benodol stdin.
>> Hysbysiad fy mod hefyd yn gwneud ECHO | ICANON yma.
ICANON yn cyfeirio at rywbeth ar wahân, sy'n golygu dull canonaidd.
Pa fodd dull canonaidd fel arfer pan fyddwch chi'n teipio allan y llinell orchymyn,
Nid safonol mewn yn prosesu unrhyw beth nes i chi daro Newline.
Felly, pan fyddwch yn gwneud GetString, byddwch yn teipio criw o bethau, yna byddwch yn taro Newline.
Dyna pan gaiff ei anfon i safon mewn
Dyna 'r ball.
Pan wyf yn troi oddi modd canonaidd, yn awr bob cymeriad unigol fyddwch yn y wasg
yn hyn sy'n cael ei brosesu, sydd fel arfer yn fath o ddrwg oherwydd ei fod yn araf i brosesu y pethau hyn,
a dyna pam mae'n beth da i glustogi i mewn i linellau cyfan.
Ond yr wyf am i bob cymeriad i gael eu prosesu
gan nad wyf am iddo aros i mi daro Newline
cyn iddo prosesu'r holl gymeriadau rwyf wedi bod yn teipio.
Mae hyn yn troi'r dull canonaidd.
Mae hyn yn stwff yn unig yn golygu pan fydd mewn gwirionedd yn prosesu cymeriadau.
Mae hyn yn golygu eu prosesu ar unwaith; cyn gynted ag yr wyf yn eu teipio, prosesu.
Ac mae hyn yn swyddogaeth sy'n cael ei diweddaru fy lleoliadau ar gyfer safon mewn,
a dulliau TCSA yn ei wneud ar hyn o bryd.
Mae'r opsiynau eraill yn aros nes bod popeth sydd ar hyn o bryd ar y nant yn cael ei brosesu.
Nid yw hynny'n wirioneddol bwysig.
Dim ond ar hyn o bryd yn newid fy lleoliadau i fod beth bynnag ar hyn o bryd yn hacker_typer_settings.
Amcana ei alw'n hacker_settings, felly gadewch i ni newid hynny.
Newid popeth i hacker_settings.
>> Nawr yn y diwedd ein rhaglen rydym yn mynd i eisiau mynd yn ôl
i'r hyn sydd ar hyn o bryd y tu mewn o normal_settings,
sy'n mynd i dim ond yn edrych fel & ar normal_settings.
Hysbysiad Nid wyf wedi newid unrhyw un o fy normal_settings ers wreiddiol gael.
Yna i ddim ond eu newid yn ôl, yr wyf pasio yn ôl ar y diwedd.
Hwn oedd y diweddariad. Iawn.
>> Nawr tu mewn yma byddaf dim ond esbonio y cod yn y diddordeb o amser.
Nid yw'n bod llawer cod.
Rydym yn gweld rydym yn darllen cymeriad o'r ffeil. Byddem ni'n ei alw f.
Awron alli fgetc ddyn, ond sut fgetc yn mynd i weithio
yn unig mae'n mynd i ddychwelyd y cymeriad yr ydych newydd ei ddarllen neu EOF,
sy'n cyfateb i ddiwedd y ffeil neu ryw yn digwydd wall.
Rydym yn dolennu, gan barhau i ddarllen cymeriad unigol o'r ffeil,
nes ein bod wedi rhedeg allan o gymeriadau i'w ddarllen.
Ac er ein bod ni'n gwneud hynny, rydym yn aros ar gymeriad unigol o safon mewn
Bob tro sengl i chi deipio rhywbeth ar y llinell orchymyn,
sef darllen mewn cymeriad o safon mewn
Yna putchar yn unig yn mynd i roi'r torgoch rydym yn darllen i fyny yma o'r ffeil i allan safonol.
Gallwch putchar dyn, ond mae'n dim ond rhoi i safon allan, mae'n argraffu y cymeriad hwnnw.
Gallech hefyd dim ond gwneud printf ("% c", c); syniad Same.
Mae hynny'n mynd i wneud y rhan fwyaf o'n gwaith.
>> Y peth olaf rydym yn mynd i eisiau ei wneud yw unig mmap ein ffeil.
Os nad ydych yn mmap, mae hynny'n gollwng cof.
Rydym yn awyddus i mmap y ffeil yn wreiddiol agor, ac yr wyf yn meddwl dyna ni.
Os byddwn yn gwneud hynny, yr wyf eisoes yn cael problemau.
Gadewch i ni weld.
Beth oedd ei gwyno amdano?
Disgwyl 'int' ond dadl yw o fath 'strwythur _IO_FILE *'.
Byddwn yn gweld os sy'n gweithio.
Dim ond yn y C99. Augh. Iawn, yn gwneud hacker_typer.
Nawr rydym yn cael disgrifiadau mwy defnyddiol.
Felly, y defnydd o dynodwr heb eu datgan 'normal_settings'.
Doeddwn i ddim yn ei alw normal_settings. Gelwais ei current_settings.
Felly, gadewch i ni newid hynny i gyd.
Nawr pasio ddadl.
Byddaf yn gwneud hyn yn 0 ar gyfer yn awr.
Iawn. . / Hacker_typer cp.c.
Rwyf hefyd nad oedd yn glir y sgrin ar y dechrau.
Ond gallwch edrych yn ôl at y broblem a osodwyd olaf i weld sut rydych yn glir y sgrin.
Mae'n dim ond argraffu rhai cymeriadau
tra bod hyn yn gwneud yr hyn rwyf eisiau ei wneud.
Iawn.
Ac yn meddwl am pam fod hyn sydd ei angen i fod yn 0 yn hytrach na stdin,
y dylid eu diffinio # 0,
mae hyn yn cwyno bod -
Cyn pan ddywedais fod yna disgrifwyr ffeil ond yna byddwch hefyd yn cael eich * FILE,
disgrifydd ffeil yn unig yw cyfanrif sengl,
tra bod * FILE Mae criw cyfan o bethau sy'n gysylltiedig ag ef.
Y rheswm mae angen inni ddweud 0 yn hytrach na stdin
yw bod stdin yn * FILE sy'n cyfeirio at y peth sy'n cael ei gyfeirio 0 disgrifydd ffeil.
Felly hyd yn oed i fyny yma pan ddylwn i ei wneud fopen (argv [1], rwy'n cael * FILE yn ôl.
Ond rhywle yn y * FILE yn beth sy'n cyfateb i'r disgrifydd ffeil ar gyfer y ffeil.
Os edrychwch chi ar y dudalen dyn am agored, felly rwy'n credu y bydd yn rhaid i chi wneud dyn 3 ar agor - Na -
dyn 2 ar agor - yeah.
Os edrychwch ar y dudalen i agor, agored yn debyg i fopen lefel is,
ac mae'n dychwelyd y disgrifydd ffeil ei hun.
fopen mae criw o bethau ar ben agored,
sydd yn lle dychwelyd hynny ddisgrifydd ffeil yn dychwelyd FFEIL cyfan * pwyntydd
tu mewn sydd yn ein disgrifydd ffeil bach.
Felly safonol yn cyfeirio at y FFEIL peth *,
tra 0 yn cyfeirio at jyst safon ffeil disgrifydd ynddo'i hun.
>> Cwestiynau?
[Chwerthin] Blew drwy hynny.
Mae pob hawl. Rydym yn gwneud. [Chwerthin]
>> [CS50.TV]