>> [REPRODUCCIÓ DE MÚSICA]
>> DOUG LLOYD: Punters, aquí estem.
Aquesta és, probablement, va serà el tema més difícil
que es parla al CS50.
I si has llegit res d'apuntadors
abans que vostè pot ser que sigui una mica intimidatori entrar en aquest vídeo.
És cert els punters Permet la capacitat
cargolar potser fins bastant malament quan estàs
treballar amb variables, i les dades, i fent que el seu programa es bloquegi.
Però en realitat són realment útils i ens realment una gran manera permeten
per passar les dades cap enrere i tornada entre funcions,
que som d'una altra manera no pot fer.
>> I així el que realment vull fer aquí és el tren
li permet tenir una bona disciplina punter, per la qual que pot utilitzar punters amb eficàcia
per fer els seus programes que molt millor.
Com vaig dir punters ens donen una diferent manera de passar les dades entre funcions.
Ara bé, si vostè recorda de un vídeo anterior, quan
parlàvem àmbit de variable, vaig esmentar
que totes les dades que es passa entre funcions en C es passen per valor.
I pot ser que no he fet servir aquesta termini, la qual cosa significava que
va ser que estem passant còpies de les dades.
Quan es passa una variable a una funció, no estem en realitat passa la variable
a la funció, no?
Estem passant una còpia de que les dades a la funció.
La funció fa el que farà i es calcula un valor,
i potser fem servir aquest valor quan se li dóna l'esquena.
>> Hi va haver una excepció a aquesta regla de passar per valor,
i anem a tornar al que és una mica més endavant en aquest vídeo.
Si fem servir punters lloc d'utilitzar variables,
o en lloc d'utilitzar les variables ells mateixos o còpies de les variables,
ara podem passar a les variables al voltant entre les funcions d'una manera diferent.
Això vol dir que si fem un canvi en una funció,
que el canvi realment prendre efectuar en una funció diferent.
Un cop més, això és una cosa que no podíem fer abans,
i si alguna vegada has tractat de canviar la valor de dues variables en una funció,
vostè ha notat aquest problema espècie de rèptil, oi?
>> Si volem canviar X i Y, i passar-los a una funció anomenada swap,
dins de la funció de canviar el variables que fan els valors de canvi.
Un es converteix en dues, dues esdevé un, però no ho fem realitat
canviar res en l'original funció, en la persona que truca.
Perquè no podem, estem només treballar amb còpies dels mateixos.
Amb punters això, podem en realitat passar X i Y a una funció.
Aquesta funció pot fer alguna cosa amb ells.
I els valors de les variables en realitat pot canviar.
Així que això és un gran canvi en la nostra capacitat per treballar amb dades.
>> Abans de submergir-se en punters, crec que val la pena
prendre un parell de minuts a tornar al bàsic aquí.
I fer una ullada a com obres de memòria per a ordinadors
perquè aquests dos temes van per ser realment molt relacionats entre si.
Com vostè probablement sap, en el seu sistema informàtic
Té un disc dur o potser una unitat d'estat sòlid,
una mena de lloc d'emmagatzematge d'arxius.
En general és un lloc en el veïnatge de 250 gigabytes
que potser un parell de terabytes ara.
I és on tots els de la seva arxius viuen en última instància,
fins i tot quan l'ordinador està apagat apagat, pot tornar a engegar
i trobareu els arxius hi són de nou al reiniciar el sistema.
Però les unitats de disc, com una unitat de disc dur, un disc dur o una unitat d'estat sòlid, un SSD,
són l'espai d'emmagatzematge just.
>> En realitat no podem fer res amb les dades que es troba en el disc dur,
o en una unitat d'estat sòlid.
Per tal de canviar realment de dades o moure'l,
hem de moure-ho a RAM, memòria d'accés aleatori.
Ara RAM, vostè té un munt menys en el seu ordinador.
És possible que en algun lloc del barri de 512 megabytes
si vostè té un ordinador antic, que potser dos, quatre, vuit, 16,
possiblement fins i tot una mica més, gigabytes de RAM.
Així que això és molt més petit, però això és on totes les dades volàtils existeix.
Aquí és on podem canviar les coses.
Però quan ens tornem nostre ordinador apagat, totes les dades a la RAM es destrueix.
>> Així que per això hem de tenir el disc dur per a la ubicació més permanent de la mateixa,
de manera que existeix- que ho faria ser realment dolent si cada vegada que
convertit al nostre ordinador apagat, cada arxiu en el nostre sistema va ser esborrada.
Així que treballem dins de RAM.
I cada vegada que estem parlant de memòria, més o menys, al CS50,
estem parlant de RAM, no disc dur.
>> Així que quan ens movem coses a la memòria, que ocupa una certa quantitat d'espai.
Tots els tipus de dades que hem estat treballant amb
assumir diferents quantitats d'espai a la RAM.
Així que cada vegada que creï un sencer variables, quatre bytes de memòria
es deixen de costat a la memòria RAM perquè pot treballar amb aquest sencer.
Pot declarar el nombre sencer, canviar-ho, assignar-
a un valor de 10 incrementat per un, així successivament i així successivament.
Tot el que ha de passar a RAM, i s'obté 4 bytes
per treballar amb per a cada sencer que vostè creu.
>> Cada caràcter que crear aconsegueix un byte.
Això és només la quantitat d'espai necessària per emmagatzemar un caràcter.
Cada flotador, un veritable nombre, obté quatre bytes
llevat que sigui un doble punt flotant de precisió
nombre, que li permet tenir dígits més precises o més
després del punt decimal sense perdre precisió,
de prendre fins a vuit bytes de memòria.
Anhela llargs, realment grans nombres enters, També prendre fins a vuit bytes de memòria.
Quants bytes de memòria Què cadenes ocupen?
Bé anem a posar una agulla en aquesta pregunta per ara, però anem a tornar-hi.
>> Així que de tornada a aquesta idea de la memòria com una gran varietat de cèl·lules bytes de mida.
Això és realment tot el que és, és només una enorme varietat de cèl·lules,
de la mateixa manera que qualsevol altra matriu que vostè està familiaritzat amb i veure,
excepte cada element és un byte d'amplada.
I igual que una matriu, cada element té una adreça.
Cada element d'una matriu té un índex, i nosaltres
pot utilitzar aquest índex per fer la trucada accés aleatori a la matriu.
No hem de començar per el principi de la matriu,
iterar a través de tots els sol element de la mateixa,
per trobar el que estem buscant.
Només podem dir que vull arribar al Element 15a o l'element número 100.
I que només pot passar en aquest nombre i obtenir el valor que vostè està buscant.
>> De la mateixa manera cada localització en la memòria té una adreça.
Així que la seva memòria podria alguna cosa com això.
Aquí hi ha una molt petita part de memòria, aquesta és de 20 bytes de memòria.
Els primers 20 bytes perquè el meu aborda hi ha a la part inferior
són 0, 1, 2, 3, i així en tot el camí fins al 19.
I quan em declaro variables, i quan començo a treballar amb ells,
el sistema es va a establir de costat una mica d'espai per a mi
en aquesta memòria per treballar amb els meus variables.
Així que podria dir, char c és igual a la capital H. I què passarà?
Bé, el sistema va reservat per a mi un byte.
En aquest cas es va triar el nombre de bytes quatre, el octet en la direcció de quatre,
i que va a emmagatzemar el lletra majúscula H en allà per a mi.
Doncs si jo dic velocitat int límit és igual a 65, que és
va a deixar de banda les quatre bytes de memòria per a mi.
I que va a tractar a les persones 4 bytes com una sola unitat
perquè el que estem treballant amb un sencer aquí.
I que va a emmagatzemar 65 en aquest país.
>> Ara ja estic una mica que li diu una mica d'una mentida,
dreta, perquè sabem que ordinadors funcionen en binari.
Ells no entenen necessàriament el majúscula és
o el que és un 65, és a dir, que només entenen el binari, zeros i uns.
I el que en realitat el que estem emmagatzemant allà
no és la lletra H i el número 65, sinó més aviat les representacions binàries
del mateix, que busqui un mica alguna cosa com això.
I, en particular en el context de la variable de nombre sencer,
no va a simplement escopir a, no va a tractar-lo com un de quatre
tros byte necessàriament, en realitat està passant
tractar-lo com quatre trossos d'un byte, que podria ser alguna cosa com això.
I fins i tot això no és tot cert tampoc,
causa d'alguna cosa anomenat 1 endianness, que no estem
va entrar en aquest moment, però si ets curiós sobre,
es pot llegir en poc i grans endianness.
Però pel bé d'aquest argument, pel bé d'aquest vídeo,
anem a suposar que és, en De fet, com el nombre 65 ho faria
estar representats en memòria en tots els sistemes,
encara que no és del tot cert.
>> Però siguem en realitat només aconsegueixen desfer-se de tots binari complet,
i només pensar en com H i el 65, que és molt més fàcil
pensar-hi com que com a ésser humà.
Molt bé, pel que també sembla potser un poc aleatori que I've- meu sistema
no em va donar bytes 5, 6, 7, i 8 per emmagatzemar el nombre enter.
Hi ha una raó per això, també, que no entrarem en aquest moment, però suficient
amb dir que el que el equip està fent aquí
és probablement una bona jugada de la seva part.
Per no donar-me memòria que és còpia necessàriament amb esquena.
Tot i que va a fer-ho ara si vull tenir una altra cadena,
Vaig trucar cognom, i vull posar Lloyd allà.
Vaig a haver d'adaptar a un sol caràcter, cada lletra que és
requerirà d'un caràcter, un byte de memòria.
Així que si podia posar Lloyd en el meu arsenal com això sóc bastant bo per anar, oi?
Què falta?
>> Recordeu que cada cadena treballem amb en C acaba amb barra invertida zero,
i no podem ometre que aquí, tampoc.
Hem de deixar de banda un byte de memòria per sostenir que el que
saber quan la nostra cadena ha acabat.
Així que de nou aquest acord de les coses
apareixerà en la força de la memòria ser una mica a l'atzar,
però en realitat és com la majoria dels sistemes estan dissenyats.
Per alinear en múltiples de quatre, per raons de nou
que no necessitem entrar en aquest moment.
Però això, per la qual cosa n'hi ha prou amb dir que després d'aquestes tres línies de codi,
això és el que la memòria podria ser similar.
Si necessito posicions de memòria 4, 8 i 12 per subjectar les meves dades,
això és el que la meva memòria podria ser similar.
>> I només ser particularment pedant aquí, quan
estem parlant de la memòria adreces Solem
fer-ho usant notacions hexadecimals.
Llavors, ¿per què no ens convertim tots aquests de decimal a notació hexadecimal
simplement perquè això és en general com ens referim a la memòria.
Així que en lloc de ser de 0 a 19, el que tenim és zero
x zero per zero x1 3.
Aquests són els 20 bytes de memòria que hem o estem veient en aquesta imatge
aquí mateix.
>> Així que tot el que es diu, anem a allunyar-se de la memòria per un segon
i de nou als punters.
Aquí és el més important cosa per recordar
a mesura que vam començar a treballar amb punters.
Un punter és gens més d'una adreça.
Ho diré una altra vegada perquè que és tan important,
un punter no és gens més d'una adreça.
Els punters són adreces a llocs en la memòria on viuen variables.
Sabent que es fa d'esperar un poc més fàcil treballar amb ells.
Una altra cosa que m'agrada de fer és tenir sort
dels diagrames de representar visualment el que és passant amb diverses línies de codi.
I farem això un parell de vegades en els punters,
i quan parlem de dinàmica assignació de memòria també.
Perquè crec que aquests diagrames pot ser particularment útil.
>> Així que si jo dic per exemple, int k en el meu codi, què està passant?
Bé el que està succeint és, bàsicament, M'estic posant de memòria reservat per a mi,
però ni tan sols m'agrada penso així, jo
agradaria pensar-hi com una caixa.
Tinc una caixa i és de color verd perquè
pot posar nombres enters en caixes verdes.
Si es tractava d'un personatge que podria tenir un quadre blau.
Però jo sempre dic, si jo estic creant una caixa que pot contenir nombres enters
aquesta caixa és de color verd.
I prenc un marcador permanent i escric k al costat de la mateixa.
Així que tinc una caixa anomenada k, en la qual puc posar sencers.
Així que quan dic int k, això és el que passa al meu cap.
Si dic k és igual a cinc, què estic fent?
Bé, em posaré de cinc en el quadre, la dreta.
Això és bastant senzill, si Dic int k, crear un quadre anomenat k.
Si dic k és igual a 5, posar cinc a la caixa.
Esperem que això no és massa d'un salt.
Aquí és on les coses van una poc interessant.
Si dic int * pk, bé encara que no ho faig sap el que això significa necessàriament,
És clarament té alguna cosa a veure amb un sencer.
Així que vaig a pintar aquesta caixa verda-ish,
Sé que té alguna cosa a veure amb un sencer,
però no és un nombre enter en si, perquè és un int estrelles.
Hi ha alguna cosa una mica diferent al respecte.
Així involucrats d'un sencer, però per la resta és
no molt diferent de el que estàvem parlant.
És una caixa, la seva té una etiqueta, que porta un pk etiqueta,
i és capaç de tinença estrelles int, el que són.
Tenen alguna cosa a veure amb nombres enters, amb claredat.
Aquí està l'última línia però.
Si dic pk = & k, espera, el que acaba de succeir, oi?
Així que aquest nombre a l'atzar, aparentment a l'atzar nombre, es tira en el quadre d'allà.
Tot el que és, és pk obté la direcció de k.
Així que em quedo on k viu en la memòria, seva direcció, la direcció dels seus bytes.
Tot el que estic fent és el que dic que el valor és el que vaig
per posar dins del meu caixa anomenada pk.
I perquè aquestes coses són punters, i perquè busca
en una cadena com zero x 08:00 zero c 07:00 04:08
02:00 zero és, probablement, no és molt significativa.
Quan visualitzem general punters, que en realitat fem com punters.
Pk ens dóna la informació hem de trobar k en la memòria.
Així que, bàsicament pk té una fletxa en ell.
I si caminem la longitud d'aquesta fletxa, imagini
és una cosa que es pot caminar, si caminar al llarg de la longitud de la fletxa,
a la punta de la fletxa, que serà trobar la ubicació en la memòria
on k viu.
I això és realment important perquè una vegada que sabem que k viu,
podem començar a treballar amb les dades dins d'aquesta posició de memòria.
Tot i que estem rebent un petit mica per davant de nosaltres per ara.
>> Llavors, què és un punter?
Un punter és un element de dades el valor és una adreça de memòria.
Aquesta va ser que el zero x 8 zero coses passant, que era una direcció de memòria.
Aquesta va ser una ubicació en la memòria.
I el tipus d'un punter descriu el tipus
de les dades que trobareu a aquesta direcció de memòria.
Així que la part dreta int estrelles.
Si segueixo aquesta fletxa, és em va portar a una ubicació.
I aquest lloc, el que trobaran allà en el meu exemple,
és un quadre de color verd.
És un sencer, això és el que trobaran si vaig a aquesta direcció.
El tipus de dades d'un punter descriu el
es troba en aquesta adreça de memòria.
Així que aquí està la cosa molt fresc però.
Punters ens permeten passar variables entre funcions.
I en realitat passar variables i no passar còpies d'ells.
Perquè si sabem exactament on en memòria per trobar una variable,
no necessitem fer una còpia de ella, que només pot anar a aquest lloc
i treballar amb aquesta variable.
Així que en essència punters espècie de fer un entorn informàtic
molt més com el món real, a la dreta.
>> Així que aquí hi ha una analogia.
Diguem que tinc un quadern, dreta, i està ple de notes.
I m'agradaria que actualitzar-lo.
Vostè és una funció que Actualitzacions de notes, dreta.
En la forma en què hem estat treballant fins ara, el que
que passa és que vostè prengui el meu quadern, te'n vas a la botiga de còpia,
que va a fer una còpia de Xerox cada pàgina del quadern.
Vas a deixar la meva llibreta de tornada en el meu escriptori quan hagi acabat,
aniràs i ratllar coses en el meu quadern que estan fora de data o erroni,
i després passarà de nou a me la pila de pàgines Xerox
que és una rèplica del meu portàtil amb els canvis que vostè ha fet a ella.
I en aquest punt, li toca a mi com la funció de trucada, ja que la persona que truca,
en decidir prendre les seves notes i integrar-los de nou en el meu quadern.
Així que hi ha un munt de passos involucrat aquí, a la dreta.
Igual que no seria millor si acabo de dir, bé, oi
actualitzar el meu quadern per jo, que lliuro el meu quadern,
i es pren les coses i creuar literalment fora
i actualitzar els meus notes en la llibreta.
I després em donen el meu quadern esquena.
Això és una cosa del que punters ens permeten fer,
que fan d'aquest entorn molt més com la forma en què operem a la realitat.
>> Està bé així que això és el que un punter està, anem a parlar
sobre com funcionen els punters en C, i com podem començar a treballar amb ells.
Així que hi ha una molt simple punter en C anomenat el punter nul.
Els punts de punter nul a res.
Això probablement sembla que és En realitat no és una cosa molt útil,
però com veurem un poc més endavant, el fet
l'existència d'aquest punter nul realment realment pot ser útil.
I cada vegada que es crea un punter i no estableix el seu valor seguit-
un exemple de configuració el seu valor immediatament
serà un parell de diapositives de retorn on vaig dir pk és igual a & k,
pk obté la direcció de k, com anem a veure el que això significa,
anem a veure com el codi que shortly- si no establim seu valor a alguna cosa
immediatament significatiu, sempre ha de
establir el punter per apuntar a null.
Vostè ha configurar-lo perquè apunti a res.
>> Això és molt diferent a simplement deixant el valor ja que és
i després declarar una punter i acaba assumint
és nul·la perquè és poques vegades és cert.
Així que sempre s'ha d'establir el valor d'un punter
null si no s'estableix el seu valor a alguna cosa significatiu immediatament.
Podeu comprovar si el valor d'un punter és nul utilitzant l'operador d'igualtat
(==), Igual que es compara qualsevol sencer valors o valors de caràcters utilitzant (==)
tant be.
És un tipus especial de constant valor que es pot utilitzar per provar.
Així que va ser una molt simple punter, el punter nul.
Una altra manera de crear un punter és extreure
la direcció d'una variable ja ha creat,
i ho fa utilitzant la I extracció direcció de l'operador.
Que ja hem vist amb anterioritat en el primer exemple diagrama vaig mostrar.
Així que si x és una variable que hem ja creat de tipus sencer,
a continuació, i x és un punter a un enter.
i x es- recorden, i es va a extreure la direcció de la cosa a la dreta.
I ja que un punter és només una direcció, que i x és un punter a un enter
el valor és on en la memòria x vides.
És l'adreça de x.
Així i x és la direcció de x.
Fem un pas més enllà i connectar a alguna cosa
He al·ludit en un vídeo anterior.
Si arr és una matriu de dobles, a continuació, i claudàtor arr i és un punter
a una doble.
D'ACORD.
arr claudàtor i, si arr és una matriu de dobles,
després arr claudàtor i és l'element i d'aquesta matriu,
i I arr claudàtor i és on en existeix l'element i de arr memòria.
>> Quina és la implicació aquí?
Un nom de matrius, la implicació de tot aquest assumpte,
és que el nom d'una matriu és en realitat si mateix un punter.
Vostè ha estat treballant amb punters al llarg
cada vegada que vostè ha utilitzat una matriu.
Recordeu l'exemple l'àmbit de les variables,
prop del final del vídeo que presento un exemple en el qual tenim una funció
anomenada int setembre i un funció anomenada matriu de conjunts.
I el seu repte per determinar si o no, o el que el
valors que imprimeix al final de la funció,
al final del programa principal.
>> Si vostè recorda d'aquest exemple o si has vist el vídeo,
vostè sap que quan tu- la crida a conjunt int fa efectivament res.
Però la crida per establir matriu fa.
I en certa manera em va passar per alt per què aquest va ser el cas en el moment.
Que acabo de dir, així que és una matriu, que és especial, ja saps, hi ha una raó.
La raó és que una matriu de nom és en realitat només un punter,
i hi ha aquest especial sintaxi de claudàtor que
fer les coses molt més agradable per treballar.
I fan la idea d'un punter molt menys intimidant,
i és per això que són una espècie de presentat d'aquesta manera.
Però en realitat les matrius són punters.
I per això quan ens fet un canvi en la matriu,
quan vam passar una matriu com un paràmetre a una funció o com un argument
a una funció, el contingut de la matriu en realitat canviat tant en el destinatari de la trucada
i en la persona que truca.
El que per a qualsevol altre tipus de variables que vam veure no va ser el cas.
Així que això és una cosa a tenir en ment quan es treballa amb punters,
és que el nom d'un array en realitat un punter
al primer element de la matriu.
>> Acceptar el que ara tenim tots aquests fets, seguirem endavant, a la dreta.
Per què ens preocupem on alguna cosa viu.
Bé, com he dit, és bastant útil saber on alguna cosa viu
pel que pot anar-hi i canviar-lo.
Treballar amb ell i, de fet tenir la cosa que vostè
vol fer en aquest sentit pren variables, i no prendre efecte en alguna còpia.
Això es diu eliminació de referències.
Ens anem a la referència i canviem el valor allà.
Així que si tenim un punter i es diu pc, i apunta a un personatge,
llavors podem dir * * PC i PC és el nom del que trobarem si anem
a la direcció de PC.
Què trobarem que hi ha un personatge i * PC és com ens referim a les dades en aquest
ubicació.
Així que podríem dir alguna cosa com * Pc = D o alguna cosa per l'estil,
i això vol dir que tot el que va ser en memòria d'adreces de PC,
qualsevol caràcter era prèviament allà, ara és D, si diem * pc = D.
>> Així que aquí anem de nou amb algunes coses rares C, dreta.
Així que hem vist anteriorment com * d'alguna manera part del tipus de dades,
i ara s'està utilitzant en un context lleugerament diferent
per accedir a les dades en una ubicació.
Sé que és una mica confús i això és en realitat part d'aquest tot
de la mateixa manera que, per què punters tenen aquesta mitologia al voltant d'ells per ser tan complex,
és una espècie de problema de sintaxi, la veritat.
Però * s'utilitza en ambdós contextos, tant com a part del nom de tipus,
i anem a veure una mica una mica més tard la resta, també.
I ara mateix és el operador d'eliminar la referència.
Així que va a la referència, s'accedeix a les dades
en la ubicació del punter, i li permet manipular a voluntat.
>> Ara bé, això és molt similar a visitar al seu veí, a la dreta.
Si vostè sap el que el seu veí viu, vostè és
no sortir amb el seu veí.
Vostè sap vostè passa saber on viuen,
però això no vol dir que per virtut de tenir aquest coneixement
està interactuant amb ells.
Si voleu interactuar amb ells, vostè ha d'anar a casa seva,
has d'anar a on viuen.
I una vegada que ho fas, llavors vostè pot interactuar
amb ells igual que voldries.
I de manera similar amb les variables, has d'anar al seu domicili
si vols interactuar ells, un no pot saber la direcció.
I la manera d'anar a l'adreça és d'usar *, l'operador eliminar la referència.
Què creus que passa si tractem d'eliminar la referència
un punter el valor és nul?
Recordem que la hipòtesi nul·la punter apunta a res.
Així que si vostè tracta d'eliminar la referència res o anar a una adreça de res,
¿Què creus que passa?
Segmentació Bé, si vostè ho va endevinar culpa, estaríem en la veritat.
Si tractes d'eliminar la referència un punter nul,
vostè pateix una segmentació criticar. Però espera,
No et dic, que si no vas
per establir el seu valor del seu Punter a alguna cosa significatiu,
d'establir en nul?
Ho vaig fer i realment la segmentació culpa és una espècie de bon comportament.
>> Alguna vegada ha declarat una variable i No assignat el seu valor immediatament?
Així que vostè acaba de dir int x; no ho fa realitat assignar-la a res
i més tard en el seu codi, imprimeixi el valor de x,
Encara no tenir és assignat a res.
Freqüents que obtindrà zero, però de vegades
podria aconseguir alguna cosa de nombres aleatoris, i vostè no té idea d'on vi.
De la mateixa manera pot coses passar amb punters.
Quan es declara un punter int * pk per exemple,
i no s'assigna a un valor, vostè aconsegueix quatre octets per a la memòria.
Qualssevol que siguin quatre octets de la memòria del sistema pot
trobar que tenen algun valor significatiu.
I podria haver hagut cosa que ja existeix que
ja no és necessària per un altre funció, de manera que només té
totes les dades que hi era.
>> El que si es va tractar de fer dereference alguna adreça que no- havia
ja bytes i informació en allà, això és ara al punter.
Si tractes d'eliminar la referència d'aquest punter, vostè podria estar ficant amb una mica de memòria
que no tenia intenció ficar-se amb tot.
I, de fet, vostè podria fer alguna cosa realment devastador,
com trencar un altre programa, o trencar una altra funció,
o fer alguna cosa maliciós que que no té la intenció de fer-ho en absolut.
I per això és realment una bona idea
per establir els seus punters a null si no els estableix en alguna cosa significatiu.
És probablement millor en el final del dia per al seu programa
a estavellar a continuació perquè ho faci cosa que fica la pota
altre programa o una altra funció.
Aquest comportament és probablement encara menys ideal que només estavellar-se.
I per això és en realitat un bon hàbit
per entrar en establir les seves punters null si no s'estableix que
a un valor significatiu immediatament, un valor que vostè sap
i que vostè pot de manera segura en eliminar la referència.
>> Així que tornem ara i fer una ullada en la sintaxi general de la situació.
Si dic int * p;, el que he acabo de fer?
El que he fet és això.
Sé que el valor de p és una adreça perquè tots els indicadors són només
direccions.
Puc eliminar la referència p usant l'operador *.
En aquest context aquí, al molt superior recordar la * forma part del tipus.
Int * és el tipus de dades.
Però no puc eliminar la referència p usant l'operador *,
i si ho faig, si em vaig a aquesta direcció, el que vaig a trobar en aquesta direcció?
Vaig a trobar un enter.
Així int * p és bàsicament dient: p és una direcció.
Puc eliminar la referència p i si Ho faig, vaig a trobar un enter
en aquesta ubicació de memòria.
>> OK, així que va dir que hi havia un altre cosa molesta amb les estrelles
i aquí és on que cosa molesta amb les estrelles és.
Alguna vegada ha tractat de declarar múltiples variables del mateix tipus
en la mateixa línia de codi?
Així que per un segon, pretendre que la línia, el codi realitat hi tinc en verd
No hi és i només diu int x, i, z;.
El que faria és en realitat crear 3 variables senceres per a vostè,
un anomenat x, un anomenat i, i un anomenat z.
És una manera de fer-ho sense haver de dividir en tres línies.
>> Aquí és on les estrelles obtenen molest altra vegada però,
perquè el * és en realitat part tant el nom del tipus i part
del nom de la variable.
I pel que si et dic int * px, py, pz, el que aconseguir realment és un punter a un enter
anomenat px i dos nombres enters, p i i pl.
I això probablement no ho és que volem, això no és bo.
>> Així que si vull crear múltiples punters en la mateixa línia, del mateix tipus,
i les estrelles, el que realment necessita de fer és dir int * pa, * pb, * pc.
Ara que acaba de dir que i ara vostè està dient,
vostè probablement mai va a fer això.
I és probablement una bona cosa, sincerament, perquè és possible que inadvertidament
ometre una estrella, una cosa així.
És probablement el millor per declarar potser indicacions sobre les línies individuals,
però és només un altre dels sintaxi molest
coses amb les estrelles que fan punters tan difícil de treballar.
Perquè és precisament aquesta sintàctica embolic que ha de treballar a través.
Amb la pràctica ho fa realment convertit en una segona naturalesa.
Encara cometo errors amb ell encara després de la programació durant 10 anys,
així que no us preocupeu si passa alguna cosa a vostè, que és bastant comú amb honestedat.
És molt amable de un defecte de la sintaxi.
>> Acceptar així que tipus de prometre que anàvem a tornar
el concepte de què tan gran és una cadena.
Bé si et digués que un cadena, tenim molt amable de
estat mentint tot el temps.
No hi ha cap tipus de dades anomenat cadena, i de fet
esmentat això en una de les nostres primers vídeos sobre tipus de dades,
aquesta cadena era un tipus de dades que va ser creat per vostè en CS50.h.
Has de #include CS50.h per tal d'usar-lo.
>> Bé cadena és realment només un àlies per a alguna cosa
anomenat el char *, 1 Punter a un personatge.
Bé punters, el record, són només aborda.
Llavors, quin és la mida en bytes d'una cadena?
Bé, és de quatre o vuit.
I la raó per la qual dir quatre o vuit és perquè en realitat
depèn del sistema, Si utilitzeu Ide CS50, char * és la mida d'un char
* És de vuit, que és un sistema de 64 bits.
Cada direcció a la memòria és de 64 bits de longitud.
Si utilitzes aparell CS50 o l'ús de qualsevol màquina de 32 bits,
i vostè ha sentit aquest terme de 32 bits màquina, el que és una màquina de 32 bits?
Bé, només dir que cada direcció a la memòria és de 32 bits de longitud.
I així 32 bits és de quatre bytes.
Així que un char * és de quatre o vuit bytes en funció del sistema.
I de fet qualsevol tipus de dades, i un punter a les dades
escrigui, ja que tots els punters són només direccions, quatre o vuit bytes.
Així que anem a revisar aquest Diagrama i arribarem a la conclusió
aquest vídeo amb una mica d'exercici aquí.
Així que aquí està el diagrama ho deixem amb en el començament del vídeo.
Llavors, què passa ara si dic * pk = 35?
Així que, què vol dir quan dic, * pk = 35?
Tome un segon.
* Pk.
En el context aquí, * és operador d'eliminar la referència.
Així que quan el dereference s'utilitza operador,
anem a l'adreça apuntada per pk i canviem el que trobem.
Així * pk = 35 amb eficàcia Fa això a la imatge.
Així que és bàsicament sintàcticament idèntic al d'haver dit k = 35.
>> Un més.
Si dic int m, crec una nova variable anomenada m.
Una nova caixa, que és una caixa verda perquè que contindrà un nombre sencer,
i està etiquetada m.
Si dic m = 4, vaig posar un sencer en aquesta caixa.
Si per exemple pk = & m, com ho fa aquest canvi diagrama?
Pk = & m, recorda el que el I l'operador fa o es diu?
Recordeu que i algun nom de variable és l'adreça d'un nom de variable.
Així que el que estem dient és pk obté la direcció del m.
I així efectivament el que passa el diagrama és que ja no pk punts
k, però apunta m.
>> Un cop més punters són molt difícil de treballar amb
i prenen una gran quantitat de pràctica, sinó perquè
de la seva capacitat de permetre que per passar les dades entre les funcions
i en realitat tenen els els canvis tinguin efecte,
aconseguir el seu cap al voltant que és realment important.
És probablement el més complicat tema es discuteix en el CS50,
però el valor que arribar des de l'ús de punters
és molt més gran que les complicacions que provenen de aprendre-les.
Així que li desitjo la millor de sort aprenent sobre punters.
Sóc Doug Lloyd, això és CS50.