>> [MUSIC nagpe-play]
>> DOUG LLOYD: Payo, dito tayo.
Ito ay marahil pagpunta sa ang pinaka-mahirap na paksa
na makipag-usap namin tungkol sa CS50.
At kung nabasa mo na kahit ano tungkol sa mga payo
bago mo maaaring maging isang maliit na piraso pananakot ng pagpunta sa video na ito.
Ito ay totoo ang mga payo pinapayagan ka ng kakayahan
upang marahil magtaas medyo maayos na kapag ikaw ay
nagtatrabaho sa mga variable, at data, at nagiging sanhi ng iyong mga programa ng pag-crash.
Ngunit ang mga ito ang tunay na talagang kapaki-pakinabang at payagan ang mga ito sa amin ng isang talagang mahusay na paraan
upang pumasa data sa likod at balik sa pagitan ng mga pag-andar,
na kami sa kabilang banda ay hindi na gawin.
>> At kaya kung ano ang aming talagang gusto mong gawin dito ay tren
mong magkaroon ng mahusay na disiplina pointer, kaya na maaari mong gamitin ang mga payo epektibong
upang gawin ang iyong mga programa na mas mahusay.
Tulad ng sinabi ko payo bigyan kami ng isang iba't ibang mga paraan upang pumasa data sa pagitan ng mga pag-andar.
Ngayon kung ang pagpapabalik sa iyo mula sa isang mas naunang video, kapag
kami ay pakikipag-usap tungkol sa variable na saklaw, nabanggit ko
na ang lahat ng data na ipasa namin sa pagitan ng function sa C ay dumaan sa pamamagitan ng halaga.
At hindi ko maaaring magkaroon ng ginagamit na term, ano ang ibig sabihin ko doon
ay na ang pagpasa namin ay mga kopya ng data.
Kapag pumasa namin ang isang variable sa isang function, hindi kami talagang makapasa sa variable
sa pag-andar, tama?
Kami ay pagpasa ng isang kopya ng ang data na iyon sa pag-andar.
Ang function na ay kung ano ay ito at ito kinakalkula ilang mga halaga,
at baka ginagamit namin ang halaga na kapag ito ay nagbibigay sa likod.
>> Nagkaroon ng isang pagbubukod sa sa alituntuning ito ng pagpasa sa pamamagitan ng halaga,
at kami ay bumalik sa kung ano na ang ay isang maliit na sa susunod sa video na ito.
Sa halip Kung gagamitin namin ang mga payo ng paggamit ng mga variable,
o sa halip ng paggamit ng mga variable kanilang mga sarili o ng mga kopya ng mga variable,
maaari naming ngayon ipasa ang mga variable sa paligid pagitan ng mga function sa isang iba't ibang mga paraan.
Nangangahulugan ito na kung gawin namin isang pagbabago sa isang function,
pagbabago na talagang magdadala epekto sa ibang function.
Muli, ito ay isang bagay na hindi namin maaaring gawin dati,
at kung sakaling mo na sinubukan upang magpalit ng halaga ng dalawang variable sa isang function,
napansin mo ang problemang ito uri ng gumagapang up, di ba?
>> Kung gusto namin upang magpalitan ng X at Y, at kami ipasa ang mga ito sa isang function na tinatawag na swap,
sa loob ng function na magpalit ng mga variable gawin exchange halaga.
One nagiging dalawa, dalawang nagiging isa, ngunit hindi namin talagang
baguhin ang anumang bagay sa orihinal na function, sa mga tumatawag.
Dahil hindi namin, hindi namin lamang nagtatrabaho sa mga kopya ng mga ito.
Sa mga payo bagaman, maaari naming talagang pumasa X at Y sa isang function.
Maaaring gawin function na isang bagay sa kanila.
At ang mga variable na halaga aktwal na maaaring baguhin.
Kaya na ay lubos ng isang pagbabago sa ang aming kakayahan upang gumana sa data.
>> Bago namin sumisid sa mga payo, sa tingin ko ito ay nagkakahalaga ng
pagkuha ng ilang minuto upang bumalik sa pangunahing kaalaman dito.
At magkaroon ng isang pagtingin sa kung paano gawa ng computer memory
sapagka't ang dalawang paksa ay pagpunta sa tunay na maging pretty magkakaugnay.
Bilang mo marahil alam, sa iyong computer system
ikaw ay may isang hard drive o marahil ng isang solid drive ng estado,
ilang uri ng mga lokasyon ng imbakan ng file.
Ito ay karaniwang isang lugar sa kabayanan ng 250 gigabytes
upang marahil isang pares ng terabytes ngayon.
At ito ay kung saan ang lahat ng iyong file sa huli ay nakatira,
kahit na kapag ang iyong computer ay shut off, maaari mo itong i-pabalik sa
at makikita mo ang iyong mga file ay may muli kapag reboot mo ang iyong system.
Ngunit disk drive, tulad ng isang hard disk drive, isang HDD, o isang solid drive ng estado, isang SSD,
mga puwang lamang storage.
>> Hindi namin maaaring aktwal na gawin sa ang data na nasa hard disk,
o sa isang solid estado drive.
Upang tunay na baguhin data o ilipat ito sa paligid,
kami ay may upang ilipat ito sa RAM, random access memory.
Ngayon RAM, mayroon kang maraming mas mababa ng sa iyong computer.
Ikaw ay maaaring magkaroon saanman sa kabayanan ng 512 megabytes
kung ikaw ay may isang mas lumang mga computer, na siguro dalawa, apat, walo, 16,
marahil kahit na isang maliit higit pa, gigabytes ng RAM.
Kaya na ang mas maliit, ngunit iyan ay kung saan ang lahat ng mga salawahan data ay umiiral na.
Iyon ay kung saan maaari naming baguhin ang mga bagay.
Ngunit kapag binuksan namin ang aming mga computer off, ang lahat ng data sa RAM ay pupuksain.
>> Kaya na ang dahilan kung bakit kailangan naming magkaroon ng hard disk para sa mas permanenteng lokasyon ng mga ito,
upang ang exists- ito gagawin ito maging ganap na hindi maayos kung sa bawat oras na namin
naka aming computer off, ang bawat file sa aming sistema ay obliterated.
Kaya ang trabaho namin sa loob ng RAM.
At sa tuwing pinag-uusapan natin ang tungkol sa memory, medyo marami, sa CS50,
pinag-uusapan natin ang tungkol sa RAM, hindi hard disk.
>> Kaya kapag lumipat kami ng mga bagay sa memory, ito ay tumatagal ng hanggang sa isang tiyak na halaga ng puwang.
Ang lahat ng mga uri ng data na kami ay nagtatrabaho sa
tumagal ng hanggang iba't ibang halaga ng puwang sa RAM.
Kaya sa bawat oras na lumikha ng isang integer variable, apat na bytes ng memory
ay magtabi sa RAM kaya mo maaaring gumana sa na integer.
Maaari mong ipahayag ang mga integer, baguhin ito, italaga ito
sa halagang 10 incremented sa pamamagitan ng isa, kaya sa at iba pa.
Lahat na mga pangangailangan sa mangyayari sa RAM, at makakakuha ka ng apat bytes
upang gumana sa para sa bawat integer na kang lumikha.
>> Ang bawat karakter mo lumikha ng isa nakukuha byte.
Iyon ang dahilan lamang kung magkano ang space ay kinakailangan upang mag-imbak ng isang character.
Bawat float, isang tunay na number, makakakuha ng apat na bytes
maliban kung ito ay isang double precision lumulutang point
numero, na kung saan ay nagbibigay-daan sa iyo upang magkaroon ng mas tumpak o higit pang mga digit
pagkatapos ng decimal point nang hindi nawawala ang katumpakan,
na tumagal ng hanggang sa walong bytes ng memorya.
Long longs, talagang malaking integer, ring kumuha ng up ng walong bytes ng memorya.
Gaano karaming bytes ng memory huwag string tumagal ng hanggang?
Maglagay ng isang pin sa tanong na rin ipaalam para sa ngayon, ngunit kami ay bumalik na ito.
>> Kaya bumalik sa ideya na ito ng memorya bilang isang malaking hanay ng mga cell byte-sized.
Iyan ay talagang ang lahat ng ito ay, ito ay lamang ng isang malaking hanay ng mga cell,
tulad ng anumang iba pang mga array na pamilyar ka sa at makita,
maliban bawat elemento ay isa byte wide.
At tulad ng isang array, bawat elemento ay may isang address.
Ang bawat elemento ng isang array ay may isang index, at kami
maaaring gumamit ng index na gawin sa tinatawag na random access sa array.
Wala kaming upang magsimula sa sa simula ng array,
umulit sa pamamagitan ng bawat solong elemento nito,
upang makita kung ano ang aming hinahanap.
Maaari lang namin sabihin, gusto ko upang makakuha ng sa Ika-15 na sangkap o ang ika-100 na element.
At maaari ka lamang pumasa sa numero na at makuha ang halaga na iyong hinahanap.
>> Sa katulad na paraan sa bawat lokasyon sa memory ay isang address.
Kaya ang iyong memory baka magmumukhang ganito.
Narito ang isang tunay maliit na tipak ng memory, ito ay 20 bytes ng memorya.
Ang unang 20 bytes dahil ang aking address doon sa ibaba
ay 0, 1, 2, 3, at iba sa lahat ng mga paraan ng hanggang sa 19.
At kapag Ipinahahayag ko variable at kapag binuksan ko na magtrabaho sa mga ito,
ang sistema ay pagpunta sa set Magbibigay ng ilang espasyo para sa akin
sa memory sa trabaho sa aking mga variable.
Kaya maaaring sabihin ko, char c ay katumbas ng capital H. At kung ano ang nangyayari sa mangyayari?
Well ang sistema ay pagpunta sa magtabi para sa akin ang isa byte.
Sa kasong ito pinili ito number byte apat, ang byte sa address apat,
at ito ay pagpunta sa tindahan ng sulat capital H sa doon para sa akin.
Kung pagkatapos kong sabihin speed int limit ay katumbas ng 65, ito ay
pagpunta sa magtabi ng apat bytes ng memory para sa akin.
At ito ang nangyayari sa paggamot sa mga apat na bytes bilang isang yunit
dahil kung ano kami ay nagtatrabaho may ay isang integer dito.
At ito ang nangyayari sa tindahan ng 65 sa doon.
>> Ngayon na ako ang uri ng na nagsasabi sa iyo ng isang piraso ng isang kasinungalingan,
karapatan, dahil alam namin na computer na trabaho sa binary.
Hindi nila maunawaan kinakailangan kung ano ang isang capital H ay
o kung ano ang isang 65 ay, sila lamang maunawaan binary, zero at mga.
At kaya kung ano ang tunay kami ay nag-iimbak sa doon
ay hindi ang titik H at ang bilang 65, ngunit sa halip ang binary na representasyon
niyaon, na tumingin ng isang maliit na bagay tulad nito.
At sa partikular na sa konteksto ng mga integer variable,
hindi ito ay pagpunta sa dumura lamang ito sa, hindi ito ay pagpunta upang matrato ito bilang isa sa apat na
byte tipak kinakailangan, talagang ito ay pagpunta
na ituring ito bilang apat isa chunks byte, kung saan ay maaaring tumingin ng isang bagay tulad nito.
At kahit na ito ay hindi lubos na totoo ang alinman sa,
dahil sa isang bagay na tinatawag na isang endianness, na kung saan kami ay hindi
pagpunta sa kumuha sa ngayon, ngunit kung gusto mong malaman ang tungkol sa,
maaari mong basahin hanggang sa maliit na at malaking endianness.
Ngunit para sa kapakanan ng mga argument na ito, para sa kapakanan ng video na ito,
akala lang iyon ay, sa ipaalam katunayan, kung paano ang bilang na 65 gagawin
kinakatawan sa memory sa bawat sistema,
kahit na ito ay hindi ganap na totoo.
>> Ngunit sabihin aktwal lamang makuha alisan ng lahat ng binary ganap,
at sa tingin lamang tungkol sa bilang H at 65, ito ay isang mas madaling
mag-isip tungkol sa mga ito tulad ng na bilang isang tao.
Lahat ng mga karapatan, sa gayon ito rin ay tila marahil isang maliit na random na I've- aking sistema
ay hindi ninyo ako bytes 5, 6, 7, at 8 sa tindahan ng mga integer.
May isang dahilan para sa na, masyadong, na Hindi namin makuha sa ngayon, ngunit makasapat
ito sa sabihin na kung ano ang ay ginagawa dito ng computer
ay marahil isang magandang ilipat sa bahagi nito.
Upang hindi ninyo ako memory na kinakailangang i-back sa likod.
Kahit na ito ay pagpunta sa gawin ito ngayon kung gusto ko upang makakuha ng isa pang string,
tinatawag na apelyido, at gusto ko upang ilagay Lloyd doon.
Pupunta ako sa kailangan upang umangkop sa isa character, ang bawat titik ng iyan ay
pagpunta sa nangangailangan ng isa character, isang byte ng memorya.
Kaya kung maaari ko bang ilagay Lloyd sa aking array tulad nito Ako ay medyo magandang pumunta, di ba?
Ano ang nawawala?
>> Tandaan na ang bawat string ng trabaho namin may in C nagtatapos sa backslash zero,
at hindi namin maaaring ligtaan na dito, alinman.
Kailangan namin na maglaan ng isang byte ng memory upang i-hold na kaya namin
Alam kapag ang aming mga string ay natapos.
Kaya muli-aayos na ito ng paraan ng mga bagay
lumitaw sa memory kapangyarihan maging isang maliit na random,
ngunit ito talaga ay kung paano karamihan sa mga system ay dinisenyo.
Sa line up ang mga ito sa multiple ng apat na, para sa mga kadahilanan na muli
na hindi natin kailangang kumuha sa ngayon.
Ngunit ito, kaya magkasiya ito upang sabihin na pagkatapos ng mga tatlong linya ng code,
ito ay kung ano ang maaaring maging hitsura memory gusto.
Kung kailangan ko lokasyon ng memorya 4, 8, at 12 na hawakan ang aking data,
ito ay kung ano ang maaaring maging hitsura ng aking memory gusto.
>> At maging partikular lamang pedantic dito, kapag
pinag-uusapan natin ang tungkol sa memory addresses namin karaniwang
gawin ito gamit hexadecimal notasyon.
Kaya bakit hindi convert namin ang lahat ng mga mula sa decimal sa hexadecimal notasyon
dahil lang na sa pangkalahatan kung paano namin sumangguni sa memory.
Kaya sa halip ng pagiging 0 hanggang 19, kung ano ang mayroon kami ay zero
x zero sa pamamagitan ng zero x1 tatlo.
Iyon ang mga 20 bytes ng memorya na namin may o kaming naghahanap sa sa imahe na ito
dito.
>> Kaya lahat ng na ang pagiging sinabi, sabihin hakbang ang layo mula sa memory para sa isang segundo
at bumalik sa mga payo.
Narito ang pinaka-mahalaga bagay na dapat tandaan
bilang namin simulan ang nagtatrabaho sa mga payo.
Ang isang pointer ay wala higit sa isang address.
Sasabihin kong ito muli dahil ito ay na mahalaga,
isang pointer ay wala higit sa isang address.
Payo ay addresses sa mga lokasyon sa memorya kung saan variable nakatira.
Alam na ito ay nagiging sana ay isang kaunti mas madali upang gumana sa mga ito.
Isa pang bagay na gusto ko na gawin ay ang magkaroon ng isang uri
ng diagram biswal na kumakatawan sa kung ano ang nangyayari sa iba't-ibang linya ng code.
At kami na gawin ito ng ilang ng mga beses sa mga payo,
at kapag kami makipag-usap tungkol sa mga dynamic memory laang-gugulin rin.
Dahil sa tingin ko na ang mga diagram maaaring maging partikular na kapaki-pakinabang.
>> Kaya kung sinasabi ko halimbawa, int k sa aking code, ano ang nangyayari?
Well kung ano ang karaniwang nangyayari ay Nakakakuha ako ng memory na magtabi para sa akin,
ngunit hindi ko kahit na nais na isipin ang tungkol sa mga ito tulad na, ako
nais na isipin ang tungkol sa mga ito tulad ng isang kahon.
Mayroon akong isang box at ito ay berdeng kulay dahil ako
maaaring maglagay ng integer sa berdeng kahon.
Kung ito ay isang character ko maaaring magkaroon ng isang asul na kahon.
Ngunit laging kong sabihin, kung Lumilikha ako isang kahon na maaaring humawak ng integer
na kahon ay kulay berde.
At kumuha ako ng isang permanenteng marker at isulat ko k sa gilid ng mga ito.
Kaya ako ay may isang kahon na tinatawag k, sa kung saan ang maaari kong ilagay integer.
Kaya kapag sinabi ko int k, na ang kung ano ang mangyayari sa aking ulo.
Kung aking sabihin k ay katumbas ng limang, kung ano ang aking ginagawa?
Well, ako ng paglagay ng limang sa kahon, i-right.
Ito ay medyo tapat, kung Sinasabi ko int k, lumikha ng isang kahon na tinatawag na k.
Kung aking sabihin k katumbas ng 5, maglagay ng limang sa kahon.
Sana na hindi masyadong maraming ng isang hakbang.
Narito ang kung saan ang mga bagay pumunta sa isang maliit na kagiliw-giliw na kahit na.
Kung aking sabihin int * pk, well kahit hindi ko malaman kung ano ang kinakailangan na ang ibig sabihin,
malinaw na ito ay nakuha ng isang bagay ang gagawin sa isang integer.
Kaya ako ng pagpunta sa kulay ang kahong green-ish,
Alam ko na ito ay nakuha ng isang bagay ang gagawin sa isang integer,
ngunit ito ay hindi isang integer mismo, dahil sa ito ay isang int star.
Mayroong isang bagay na bahagyang iba't ibang tungkol dito.
Kaya kasangkot isang integer, ang ngunit kung hindi man ito ay
hindi masyadong naiiba mula sa kung ano ang pinag-uusapan natin ay tungkol sa.
Ito ay isang box, nito got ang isang label, ito ay may suot ng isang label pk,
at ito ay kaya ng mga humahawak int stars, ano man ang mga iyon ay.
Sila ay may isang bagay na gawin may integer, malinaw.
Narito ang huling linya bagaman.
Kung aking sabihin pk = & k, aba, kung ano lamang ang nangyari, di ba?
Kaya ito random na numero, tila random number, makakakuha ng itinapon doon sa kahon.
Ang lahat ng iyon ay, ay pk nakukuha ang mga address ng mga k.
Kaya ako ng malagkit kung saan k nakatira sa memorya, kanyang address, ang address ng bytes nito.
Lahat ako paggawa ay ko sinasabi halaga na ito ay kung ano ako pagpunta
upang ilagay sa loob ng aking kahon na tinatawag pk.
At dahil ang mga bagay ay mga payo, at dahil naghahanap
sa isang string tulad ng zero x walong zero c pitong apat na walong
dalawang zero ay marahil hindi masyadong makabuluhan.
Kapag kami ay karaniwang maisalarawan mga payo, talaga naming gawin ito bilang payo.
Pk nagbibigay sa amin ng impormasyon kailangan namin upang makahanap k sa memorya.
Kaya talaga pk ay may isang arrow sa loob nito.
At kung ang aming lakad ang haba ng arrow na, akala
ito ay isang bagay na maaari mong maglakad sa, kung tayo maglakad sa kahabaan ng haba ng arrow,
sa tunay na dulo ng arrow na, kami ay hanapin ang lokasyon sa memorya
kung saan nakatira k.
At iyan ay talagang mahalaga dahil sa sandaling malaman namin kung saan nakatira k,
maaari naming simulan upang magtrabaho kasama ang data sa loob ng na lokasyon sa memorya.
Kahit na kami ay nakakakuha ng isang maliit bit maagang ng ating sarili para sa ngayon.
>> Kaya kung ano ang isang pointer?
Ang isang pointer ay isang item ng data na halaga ay isang memory address.
Iyon ay na zero x walong zero stuff pagpunta sa, na noon ay isang memory address.
Iyon ay isang lokasyon sa memorya.
At ang uri ng isang pointer naglalarawan ng mga uri
ng data na makikita ninyo sa address na memory.
Kaya may mga int star bahagi ng karapatan.
Kung susundin ko arrow iyan, pagpunta sa humantong ako sa isang lokasyon.
At lokasyon na iyon, kung ano ang aking ay mahanap doon sa aking halimbawa,
ay isang green na kulay na kahon.
Ito ay isang integer, na kung ano ako mahahanap kung pumunta ako sa address na iyon.
Ang uri ng data ng isang pointer ay naglalarawan kung ano ang
makikita mo sa na memory address.
Kaya dito ang talagang cool na bagay kahit na.
Payagan payo sa amin na ipasa variable sa pagitan ng mga pag-andar.
At talagang pumasa variable at hindi pumasa ang mga kopya ng mga ito.
Dahil kung alam natin ang eksaktong sa memory upang mahanap ang isang variable,
hindi namin kailangan upang gumawa ng isang kopya ng ito, maaari naming pumunta lamang sa na lokasyon
at gumagana sa mga variable na iyon.
Kaya sa kakanyahan payo uri ng gumawa ng isang computer na kapaligiran
isang pulutong mas tulad ng sa totoong mundo, kanan.
>> Kaya narito ang isang pagkakatulad.
Sabihin natin na mayroon akong isang notebook, karapatan, at ito ay puno ng mga tala.
At gusto ko sa iyo upang i-update ito.
Ikaw ay isang function na update ng mga tala, right.
Sa daan na nakaya naming nagtatrabaho sa ngayon, kung ano
mangyayari ay ikaw ay kumuha ng aking notebook, kailangan mong pumunta sa mga kopya ng tindahan,
ikaw ay gumawa ng isang Xerox copy ng ang bawat pahina ng notebook.
Makikita iwan ang aking notebook sa likod sa aking desk kapag tapos ka na,
kailangan mong pumunta at i-cross ang mga bagay sa aking notebook na sa labas ng petsa o mali,
at pagkatapos ay makikita mo ipasa pabalik sa akin ang stack ng Xerox pahina
na ay isang kopya ng aking mga notebook sa ang mga pagbabago na iyong ginawa sa mga ito.
At sa puntong iyon, ikaw ang bahala sa akin bilang pagtawag sa function, pati na ang tumatawag,
upang magpasya na kunin ang iyong mga tala at isama ang mga ito pabalik sa aking notebook.
Kaya mayroong isang pulutong ng mga hakbang kasangkot dito, right.
Tulad ng hindi ito ay magiging mas mahusay na kung ako lamang sabihin, hey, maaari mong
i-update ang aking notebook para sa sa akin, kamay mo ang aking mga notebook,
at kumuha ka ng mga bagay at literal cross ang mga ito sa labas
at i-update ang aking mga tala sa aking notebook.
At pagkatapos ay bigyan ako ng aking notebook back.
Na ang uri ng kung ano ang payagan payo sa amin upang gawin,
gumawa sila ng environment na ito ng maraming higit na katulad ng kung paano namin gumana sa katotohanan.
>> Lahat ng mga karapatan sa gayon ay ang kung ano ang makipag-usap sa isang pointer ay, ipaalam
tungkol sa kung paano gumagana ang mga payo sa C, at kung paano namin simulan upang gumana sa mga ito.
Kaya mayroong isang napaka-simpleng pointer sa C na tinatawag na ang null pointer.
Ang null pointer mga puntos sa wala.
Ito marahil ay tila tulad ng ito ay talagang hindi isang lubhang kapaki-pakinabang na bagay,
ngunit bilang namin makita ang isang maliit na sa paglaon, ang katunayan
na ito ay umiiral na null pointer tunay na tunay ay maaaring dumating sa madaling-gamiting.
At kapag lumikha ka ng isang pointer, at hindi ka nagtakda ng halaga immediately- nito
isang halimbawa ng pagtatakda ang halaga nito ay agad-agad
ay bumalik sa isang pares ng mga slide kung saan sinabi ko pk katumbas & k,
pk makakakuha address k, tulad ng ipapakita namin makita kung ano ang ibig sabihin nito,
ipapakita namin makita kung paano code na shortly- kung hindi namin itakda ang halaga nito sa isang bagay
makabuluhan agad, ikaw ay dapat na laging
itakda ang iyong pointer upang tumuro sa null.
Dapat mong itakda ito upang tumuro sa wala.
>> Iyan ay ibang-iba kaysa Aalis lang ang halaga na ito ay
at pagkatapos ng deklarasyon ng isang pointer at lamang sa pag-aakala
ito ay null dahil na bihira totoo.
Kaya dapat palagi kang naka-set sa halaga ng isang pointer
sa null kung hindi mo itakda ang halaga nito sa isang bagay na mahalaga kaagad.
Maaari mong suriin kung ang halaga ng isang pointer ni ay null gamit ang pagkakapantay-pantay operator
(==), Tulad lamang ng sa iyo na ihambing ang anumang integer mga halaga o mga halaga ng character na gamit (==)
din.
Ito ay isang espesyal na uri ng pare-pareho halaga na maaari mong gamitin upang subukan.
Kaya na ay isang napaka-simple pointer, ang null pointer.
Ang isa pang paraan upang lumikha ng isang pointer ay upang kunin
ang address ng isang variable nakalikha ka na ng,
at gawin mo ito gamit ang & operator bunutan address.
Alin na namin nakita dati sa unang halimbawa diagram ako ay nagpakita.
Kaya kung x ay isang variable na kami nakalikha ng ganitong uri ng integer,
pagkatapos & x ay isang pointer sa isang integer.
& x ay- tandaan, at ay pagpunta upang kunin ang address ng bagay sa kanan.
At dahil ang isang pointer ay lamang ng isang address, sa & x ay isang pointer sa isang integer
halaga na ay kung saan sa memory x buhay.
Ito ay address x ni.
Kaya & x ay ang address ng x.
Tingnan natin ang mga ito sa isang hakbang karagdagang at kumonekta sa isang bagay
Tinukoy ko na sa isang naunang video.
Kung arr ay isang array ng doubles, pagkatapos ay & arr square bracket i ay isang pointer
sa isang double.
SIGE.
arr square bracket i, kung arr ay isang array ng doubles,
pagkatapos arr square bracket i ay ang i-ika element ng array,
at & arr square bracket i ay kung saan in memory ang i-ika elemento ng isinaayos na umiiral na.
>> Kaya kung ano ang pagkakasangkot dito?
Isang array name, ang pagkakasangkot ng buong bagay,
ay na pangalan ng isang array ay talagang mismong isang pointer.
Ikaw ay nagtatrabaho may mga payo sa lahat ng kasama
sa bawat oras na nagamit mo na ang isang array.
Tandaan mula sa halimbawa sa variable na saklaw,
na malapit sa dulo ng video kasalukuyan ko isang halimbawa kung saan kami ay may isang function
tinatawag set int at isang function na tinatawag na set array.
At ang iyong mga hamon upang matukoy man o hindi, o kung ano ang
mga halaga na naka-print out namin sa dulo ng function,
sa dulo ng mga pangunahing programa.
>> Kung isipin ang mo mula sa halimbawa na o kung pinanood mo na ang video,
alam mo na kapag ka-ang tawag sa set int epektibo ay wala.
Ngunit ang tawag upang i-set ang dami ginagawa.
At ako uri ng glossed higit bakit na ang kaso sa panahon.
Lang ang sinabi ko, na rin ito ay isang array, ito ay espesyal na, alam mo na, mayroong isang dahilan.
Ang dahilan ay ang isang array ni name ay talagang lamang ang pointer,
at may mga ito ng espesyal square bracket syntax na
gumawa ng mga bagay ng maraming nicer upang gumana sa.
At sila ay gumawa ng ideya ng isang pointer mas pananakot ng isang pulutong,
at iyon ang dahilan kung bakit ang mga ito ay mga uri ng ipinakita sa paraang iyon.
Ngunit talagang array ay lamang payo.
At iyon ang dahilan kung bakit kapag tayo ginawa ng isang pagbabago sa array,
kapag ipinasa namin ang isang array bilang isang parameter sa isang function o bilang isang argument
sa isang function, ang mga nilalaman ng array talagang nagbago sa parehong callee
at sa mga tumatawag.
Aling para sa bawat iba pang mga uri ng variable nakita natin ay hindi ito ang kaso.
Kaya na ang isang bagay lamang na panatilihin sa isip kapag ikaw ay nagtatrabaho sa mga payo,
ay na ang pangalan ng isang array talagang isang pointer
sa unang elemento ng array.
>> OK kaya ngayon kami ay lahat ng mga ito katotohanan, sabihin panatilihin ang pagpunta, right ipaalam.
Bakit namin pag-aalaga tungkol kung saan ang isang bagay na nabubuhay.
Well tulad ng sinabi ko, ito ay medyo kapaki-pakinabang na malaman kung saan ang isang bagay ay nabubuhay
kaya maaari kang pumunta doon at baguhin ito.
Makipagtulungan sa mga ito at ang tunay na may mga bagay na kayo
gusto mong gawin sa na variable take effect, at hindi magkakaroon ng epekto sa ilang kopya nito.
Ito ay tinatawag na dereferencing.
Pumunta kami sa reference at palitan namin ang mga halaga doon.
Kaya kung kami ay may isang pointer at ito ay tinatawag PC, at mga puntos sa isang character,
pagkatapos ay maaari naming sabihin * pc at * PC ay ang mga pangalan ng kung ano ang makikita namin mahanap kung pumunta kami
sa address na pc.
Ano ang makikita namin mahanap doon ay isang karakter at * pc ay kung paano namin sumangguni sa data sa na
lokasyon.
Kaya maaari naming sabihin isang bagay tulad ng * pc = D o isang bagay tulad na,
at na nangangahulugan na ang anumang ay sa memory address pc,
kahit anong character na dati ay doon, ay D ngayon, kung sabihin namin * pc = D.
>> Kaya dito namin pumunta muli gamit ilang mga kakatwang mga bagay-bagay C, right.
Kaya nakita namin na ang * dati na rin ang pagiging kahit papaano bahagi ng uri ng data,
at ngayon ito ay ginagamit sa isang bahagyang naiiba context
upang ma-access ang data sa isang lokasyon.
Alam ko ito ay isang maliit na nakalilito at na ang tunay na bahagi ng buong
tulad ng, kung bakit mga payo na ito ay may mga alamat sa paligid ng mga ito bilang sa pagiging kaya complex,
ay uri ng isang problema syntax, totoo lang.
Ngunit * ay ginagamit sa parehong konteksto, parehong bilang bahagi ng pangalan ng uri,
at kami na makita ang isang maliit na mamaya may ibang tao, masyadong.
At ngayon ay ang dereference operator.
Kaya ito ang papunta sa reference, ito-access ang data
sa lokasyon ng pointer, at ay nagbibigay-daan sa iyo upang manipulahin ang mga ito sa kalooban.
>> Ngayon na ito ay halos kapareho sa sa pagbisita sa iyong mga kapit-bahay, right.
Kung alam mo kung ano ang iyong kapwa nakatira, ikaw ay
hindi nakikipag-hang-out kasama ang iyong kapwa.
Alam mo mong mangyari sa alam kung saan sila nakatira,
ngunit iyon ay hindi nangangahulugan na sa pamamagitan ng dahil sa pagkakaroon ng kaalaman na
ikaw ay nakikipag-ugnayan sa kanila.
Kung nais mong makipag-ugnayan sa kanila, kailangan mong pumunta sa kanilang mga bahay,
ikaw ay may upang pumunta sa kung saan sila nakatira.
At sa sandaling gawin mo iyon, pagkatapos ay maaari kang makipag-ugnayan
sa kanila gusto lang gusto mo nais na.
At katulad sa mga variable, kailangan mong pumunta sa kanilang address
kung gusto mong makipag-ugnayan sa kanila, hindi mo pwedeng malaman ang address.
At ang paraan na pumunta ka sa address na ito ay gamitin *, ang dereference operator.
Ano sa tingin ninyo ang mangyayari kung susubukan namin at dereference
isang pointer na ang halaga ay null?
Alalahanin na ang mga null pointer mga puntos sa wala.
Kaya kung susubukan mo at dereference wala o pumunta sa isang address sa wala,
ano sa palagay mo ang mangyayari?
Well kung nahulaan mo segmentation kasalanan, gusto mo ay tama.
Kung subukan mo at dereference isang null pointer,
magdusa ka ng isang segmentation kasalanan. Ngunit sandali,
Hindi ko sabihin sa iyo, na kung hindi ka pupunta
upang itakda ang iyong halaga ng iyong pointer sa isang bagay na mahalaga,
dapat mong i-set sa null?
Ginawa ko at talagang ang segmentation kasalanan ay uri ng isang magandang pag-uugali.
>> Nakarating na ba ipinahayag sa iyo ng isang variable at hindi nakatakda ang halaga nito ay agad-agad?
Kaya sabihin mo lang int x; hindi mo talagang italaga ito sa kahit ano
at pagkatapos ay sa susunod sa iyong code, mong i-print out ang halaga ng x,
pagkakaroon ng hindi pa rin itinalaga ito sa kahit ano.
Madalas na makakakuha ka ng zero, ngunit kung minsan mo
maaaring makakuha ng ilang mga random na numero, at wala kang ideya kung saan ito nanggaling.
Sa katulad na paraan Maaari bagay mangyayari sa mga payo.
Kapag ipinapahayag mo ang isang pointer int * pk halimbawa,
at hindi mo na italaga ito sa isang halaga, makakakuha ka ng apat bytes para sa memory.
Anuman ang apat na bytes ng memory ng system ang maaaring
makahanap na ang ilang mga makabuluhang halaga.
At doon ay maaaring naging isang bagay na doon na
ay hindi na kailangan ng isa pang function, kaya mo na lang
kahit anong data ay naroon.
>> Paano kung sinubukan mong gawin dereference ilang address na do not mong mayroong
naka bytes at impormasyon sa doon, na sa iyong pointer ngayon.
Kung subukan mo at dereference na pointer, maaari kang maging panggugulo sa ilang mga memory
na hindi ninyo kagustuhan sa gulo sa lahat ng ito.
At sa katunayan na maaari mong gawin isang bagay na talagang nagwawasak,
tulad ng break ng isa pang programa, o basagin ang isa pang pag-andar,
o gawin ang isang bagay masamang hangarin na hindi ninyo kagustuhan na gawin sa lahat.
At kaya na kung bakit ito ay talagang isang magandang ideya
upang itakda ang iyong mga payo sa null kung ikaw hindi itakda ang mga ito sa isang bagay na mahalaga.
Ito ay malamang na mas mahusay sa pagtatapos ng araw para sa iyong mga programa
pag-crash at pagkatapos ay para sa mga ito upang gawin isang bagay na screws up
ibang programa o iba pang function.
Pag-uugali na ito ay marahil kahit na mas mainam pa sa pag-crash.
At kaya na kung bakit ito ay talagang isang magandang ugali
upang makakuha ng sa upang i-set ang iyong mga payo sa null kung hindi mo itakda ang mga ito
sa isang makabuluhang halaga agad-agad, ang halaga ng isang na alam mo
at na maaari mong ligtas ang dereference.
>> Kaya sabihin bumalik ngayon at kumuha ng isang hitsura sa pangkalahatang syntax ng ang sitwasyon.
Kung aking sabihin int * p ;, kung ano ang nagawa ko na lang?
Ano ang aking nagawa ay na ito.
Alam ko ang halaga ng p ay isang address dahil ang lahat ng mga payo ay lamang
address.
Maaari ko dereference p gamit ang * operator.
Sa kontekstong ito dito, sa pinakadulo top pagpapabalik ng * ay bahagi ng uri.
Int * ay ang uri ng data.
Ngunit maaari ko dereference p gamit ang * operator,
at kung gagawin ko ito, kung pumunta ako sa address na iyon, kung ano ang mahahanap ko sa address na iyon?
Maghahanap ako ng isang integer.
Kaya int * p talaga na nagsasabi, p ay isang address.
Maaari ko dereference p at kung Gagawin ko, maghahanap ako ng isang integer
sa na lokasyon sa memorya.
>> OK kaya sinabi ko nagkaroon ng isa pang nakakainis na bagay na may mga bituin
at narito ang kung saan na nakakainis na bagay na may mga bituin ay.
Nakarating na ba sinubukan na idedeklara maramihang mga variable ng parehong uri
sa parehong linya ng code?
Kaya para sa isang segundo, magpanggap na ang linya, ang code ako tunay na may doon sa green
ay hindi doon at ito lamang ang nagsasabing int x, y, z ;.
Ano na gawin ay ang tunay na lumikha tatlong integer variable para sa iyo,
isa na tinatawag na x, isa na tinatawag na y, at isa na tinatawag z.
Ito ay isang paraan upang gawin ito nang walang kinakailangang mag-split papunta tatlong linya.
>> Narito kung saan stars makakuha ng nakakainis muli bagaman,
dahil ang * ay aktwal na bahagi ng parehong mga uri ng pangalan at mga bahagi
ng pangalan ng variable.
At kaya kung sinasabi ko int * px, py, pz, ano ang aking talagang makakuha ay isang pointer sa isang integer
tinatawag px at dalawang integer, py at pz.
At iyan ay marahil hindi kung ano gusto namin, na hindi mabuti.
>> Kaya kung nais kong lumikha ng maramihang mga payo sa parehong linya, ng ang parehong uri,
at mga bituin, kung ano talaga ang kailangan ko gawin ay sabihin int * pa, * pb, * pc.
Ngayon ang pagkakaroon ng sinabi lamang na at ngayon na nagsasabi sa iyo na ito,
ikaw ay malamang na hindi kailanman gawin ito.
At ito ay marahil isang magandang bagay sa totoo lang, dahil maaaring hindi sinasadyang mo
ligtaan isang bituin, isang bagay na tulad ng.
Ito ay marahil pinakamahusay na siguro idedeklara mga payo sa mga indibidwal na mga linya,
ngunit ito ay lamang ng isa pa ng mga nakakainis na syntax
mga bagay-bagay na may mga bituin na bumubuo payo kaya mahirap upang gumana sa.
Dahil ito lang ang syntactic ito Nagkamali mayroon kang magtrabaho sa pamamagitan ng.
Sa pamamagitan ng pagsasanay ng ginagawa nito talagang naging pangalawang kalikasan.
Gumawa pa rin ako ng mga pagkakamali sa mga ito pa rin matapos programming para sa 10 taon,
kaya huwag maging sira kung may mangyari sa iyo, ito ay medyo pangkaraniwan sa totoo lang.
Ito ay talagang uri ng isang kapintasan ng syntax.
>> OK kaya ako uri ng ipinangako na kami ay muling bisitahin ang
ang konsepto ng kung paano malaki ay isang string.
Well kung sinabi ko sa iyo na ang isang string, na namin talagang uri ng
tinanggal namamalagi sa iyo ang buong oras.
Walang uri ng data na tinatawag na string, at sa katunayan ko
nabanggit na ito sa isa sa aming mga pinakamaagang mga video sa mga uri ng data,
na string ay isang uri ng data na ay nilikha para sa iyo sa CS50.h.
Ikaw ay may na # include CS50.h upang gamitin ito.
>> Well string ay talagang lamang isang alias para sa isang bagay
tinatawag na ang char *, isang pointer sa isang character.
Well payo, pagpapabalik, ay lamang address.
Kaya kung ano ang laki sa bytes ng isang string?
Well ito ay apat o walong.
At ang dahilan kung bakit sinasabi ko ang apat o walong ay dahil ito ang tunay na
depende sa sistema, Kung gumagamit ka ng CS50 ide, char * ay ang laki ng isang pansamantalang trabaho
* Ay walong, ito ay isang 64-bit system.
Bawat address sa memorya ay 64 bits mahaba.
Kung gumagamit ka ng CS50 appliance o paggamit ng anumang 32-bit machine,
at iyong narinig na kataga 32-bit machine, ano ay isang 32-bit machine?
Well ito ay nangangahulugan lamang na ang bawat address sa memorya ay 32 bits mahaba.
At kaya 32 bits ay apat na bytes.
Kaya ang isang pansamantalang trabaho * ay apat o walong bytes depende sa iyong system.
At sa katunayan ng anumang uri ng data, at isang pointer sa anumang data
type, dahil ang lahat ng mga payo ay lamang address, apat o walong bytes.
Kaya sabihin muling bisitahin ito diagram at ni tapusin ipaalam
ang video na ito gamit ang isang maliit na ehersisyo dito.
Kaya dito ang diagram tumigil kami sa sa pinakadulo simula ng video.
Kaya kung ano ang mangyayari ngayon kung sinasabi ko * pk = 35?
Kaya kung ano ang ibig sabihin kapag sinasabi ko, * pk = 35?
Kumuha ng isang segundo.
* pk.
Sa konteksto dito, * ay dereference operator.
Kaya kapag ang dereference operator ay ginagamit,
pumunta kami sa address itinuturo sa sa pamamagitan ng pk, at baguhin natin kung ano ang nakita namin.
Kaya * pk = 35 epektibong Ginagawa ito sa larawan.
Kaya ito ay isa lamang syntactically magkapareho sa mga pag-sinabi k = 35.
>> Isa pa.
Kung aking sabihin int m, ako lilikha ng isang bagong variable na tinatawag na m.
Ang isang bagong box, ito ay isang green box dahil ito ay pagpunta upang i-hold ang isang integer,
at ito ay may label na m.
Kung aking sabihin m = 4, Naglagay ako ng isang integer sa na box.
Kung sabihin nating pk = & m, kung paano gumagana ang pagbabagong ito diagram?
Pk = & m, gawin mo matandaan kung ano ang mga & Operator ay o ay tinatawag na?
Tandaan & ilang pangalan na variable ay ang address ng isang pangalan ng variable.
Kaya kung ano ang iyong sinasabi namin ay pk nakukuha ang address ng m.
At kaya epektibo kung ano ang mangyayari sa mga diagram ay na pk hindi na puntos
sa k, ngunit puntos upang m.
>> Muli payo ay napaka nakakalito na magtrabaho sa
at sila ay kumuha ng isang pulutong ng pagsasanay, ngunit dahil
sa kanilang kakayahan na magpapahintulot sa inyo upang pumasa data sa pagitan ng mga pag-andar
at tunay na may mga pagbabago magkakabisa,
pagkuha ng inyong ulo sa paligid ay talagang mahalaga.
Ito marahil ay ang pinaka-kumplikado topic tatalakayin natin sa CS50,
ngunit ang halaga na kayo makuha mula sa paggamit ng mga payo
malayo outweighs ang komplikasyon na nanggaling mula sa pag-aaral ng mga ito.
Kaya gusto ko sa iyo ang pinakamahusay na ng swerte sa pag-aaral tungkol sa mga payo.
Ako Doug Lloyd, ito ay CS50.