>> [Música tocando]
>> Doug LLOYD: Punteiros, aquí estamos nós.
Este é probablemente vai ser o tema máis difícil
que falamos en CS50.
E se leu nada punteiros
antes de que pode ser un pouco intimidador entrar nun vídeo.
É certo que os punteiros non permitir-lle a capacidade
quizais para romper moi mal cando está
traballar con variables, e os datos, e facendo que o seu programa trabe.
Pero son realmente moi útil e nos realmente unha boa forma permitir
para pasar datos de volta e atrás entre funcións,
que somos doutro xeito incapaz de facer.
>> E así o que realmente quero facer aquí é tren
que teña unha boa disciplina punteiro, así que pode usar agullas de forma eficaz
para facer os seus programas que moito mellor.
Como dixen punteiros dar unha diferente forma de pasar datos entre funcións.
Agora, se lembrar de un vídeo anterior, cando
que estaban falando sobre ámbito de variables, eu mencionen
que todos os datos que pasan entre funcións en C é pasado por valor.
E eu non pode usar que prazo, o que eu quería dicir alí
foi a de que estamos pasando copias de datos.
Cando pasar unha variable a unha función, non estamos realmente pasando a variable
para a función, non?
Estamos pasando unha copia do que os datos para a función.
A función fai o que vai e calcúlase algún valor,
e quizais usamos ese valor cando dalo de volta.
>> Houbo unha excepción para esta regra de pasar por valor,
e nós imos voltar para o que é un pouco máis tarde, nun vídeo.
Se usarmos punteiros vez do uso de variables,
ou en vez de utilizar as variables si ou copias das variables,
agora podemos pasar as variables en torno a entre as funcións dun xeito diferente.
Isto significa que se facemos un cambio de unha función,
que o cambio vai realmente tomar efecto nunha función diferente.
De novo, iso é algo que non podiamos facer antes,
e se xa intentou cambiar o valor de dúas variables nunha función,
entender este problema tipo de rastreando-se, non?
>> Se queremos cambiar X e Y, e nós paso-las para unha función chamada intercambio,
dentro da función cambiar o variables facer valores de cambio.
Un pasa a ser dous, dous convértese en un, pero non, en realidade,
cambiar nada no orixinal función, o chamador.
Porque non podemos, nós somos só traballar con copias deles.
Con agullas aínda, podemos realmente pasar X e Y a unha función.
Esta función pode facer algo con eles.
E eses valores variables realmente cambiar.
Entón, iso é un gran cambio en nosa capacidade de traballar con datos.
>> Antes de mergulharmos punteiros, creo que paga a pena
Tomar uns minutos para volver ao básico aquí.
E ter un ollar en como obras de memoria de ordenador
porque estes dous asuntos van para realmente ser moi interrelacionados.
Como probablemente sabe, no seu sistema informático
ten un disco duro ou quizais unha unidade de estado sólido,
algún tipo de lugar de almacenamento de ficheiros.
É xeralmente en algún lugar no barrio de 250 gigabytes
para quizais un par de terabytes agora.
E é onde todo o seu arquivos, finalmente, vivir,
mesmo cando o ordenador está apagado fóra, pode liga-lo de novo
e vai atopar os seus arquivos están alí de novo cando reiniciar o sistema.
Pero as unidades de disco, como unha unidade de disco duro, un disco duro ou unha unidade de estado sólido, un SSD,
son só o espazo de almacenamento.
>> Non podemos realmente facer algo con Os datos que está no disco duro,
ou nunha unidade de estado sólido.
Co fin de que realmente cambiar datos ou movelo,
debemos mover para RAM, memoria de acceso aleatorio.
Agora RAM, ten unha morea menos no seu ordenador.
Pode que nalgún lugar no barrio de 512 megabytes
se ten un ordenador máis antigo, para quizais dous, catro, oito, 16,
posiblemente incluso un pouco máis gigabytes de memoria RAM.
Entón, iso é moi pequena, pero iso é onde todos os datos volátiles existe.
É alí onde podemos cambiar as cousas.
Pero cando volvemos nosa ordenador apagado, todos os datos da memoria RAM é destruído.
>> Entón é por iso que necesitamos ter disco duro para a localización de máis permanente que,
de xeito que ela sería exists- ser moi malo se cada vez que
virou noso ordenador apagado, cada arquivo no noso sistema foi obliterada.
Por iso, traballamos dentro da RAM.
E cada vez que estamos a falar memoria, practicamente, en CS50,
estamos a falar de RAM, disco duro non.
>> Entón, cando cambiar as cousas na memoria, leva-se unha certa cantidade de espazo.
Todo tipo de datos que temos está a traballar con
asumir diferentes cantidades de espazo na memoria RAM.
Entón, cada vez que se crea un enteiro variables, catro bytes de memoria
son postos de lado na memoria RAM para que pode traballar con ese enteiro.
Pode declarar o número enteiro, mudalo, asocia-la
para un valor de 10 incrementado por un, así por diante e así por diante.
Todo o que ten que ocorrer en RAM, e terá catro bytes
traballando con cada enteiro que crea.
>> Cada personaxe que crear recibe un byte.
Isto é só a cantidade de espazo necesarios para almacenar un personaxe.
Cada float, unha verdadeira número, recibe catro bytes
a non ser que sexa un dobre Precisión de punto flotante
número, o que lle permite díxitos ten máis precisas ou máis
despois do punto decimal sen perder precisión,
que ocupan oito bytes de memoria.
Ansia por moito tempo, realmente grandes números enteiros, tamén ocupan oito bytes de memoria.
Cantos bytes de memoria non cordas asumir?
Ben, imos poñer un pino en cuestión que por agora, pero imos volver a el.
>> Entón, de volta a esta idea de memoria como unha gran variedade de células de tamaño byte.
Isto é realmente todo o que é, é só unha enorme variedade de células,
así como calquera outra matriz que está familiarizado con e ver,
excepto cada elemento é un byte de ancho.
E, así como unha matriz, cada elemento ten un enderezo.
Cada elemento dun array ten un índice, e nós
Pode utilizar este índice de facer chamadas de acceso aleatorio na matriz.
Non hai que comezar a o inicio da matriz,
iterado a través de cada único elemento do mesmo,
para atopar o que estamos buscando.
Podemos só dicir, quero chegar ao 15th elemento ou do elemento 100A.
E pode só pasar ese número e obter o valor que está a procurar.
>> Así mesmo cada lugar na memoria ten un enderezo.
Polo tanto, a súa memoria pode algo coma isto.
Aquí está un pequeno anaco de memoria, esta é de 20 bytes de memoria.
Os primeiros 20 bytes, porque o meu aborda alí no fondo
son 0, 1, 2, 3, e así en todo o camiño ata a 19.
E cando eu declarar variables e cando comezar a traballar con eles,
o sistema vai definir reservar un espazo para me
nesta memoria para traballar cos meus variables.
Entón, eu podería dicir, char c é igual a de capital H. E o que vai pasar?
Ben, o sistema vai reservado para me un byte.
Neste caso, el escolleu o número de bytes catro, o byte no enderezo catro,
e está indo para almacenar o letra H de capital en alí para min.
Se eu, entón, dicir velocidade int límite é igual a 65, é
vai destinar catro bytes de memoria para min.
E vai tratar aqueles catro bytes como unha única unidade
porque o que nós estamos a traballar é un número enteiro con aquí.
E vai a almacenar 65 en alí.
>> Agora xa estou medio dicíndolle un pouco de unha mentira,
dereito, porque sabemos que ordenadores traballar en binario.
Eles non entenden necesariamente o que é un capital H
ou o que é un 65, eles só comprender binarios, ceros e uns.
E así, en realidade, o que estamos almacenando alí
non é a letra H eo número 65, senón as representacións binarias
destes, que parecen un pouco algo así.
E, en particular no contexto da variable número enteiro,
non vai só cuspi-lo, non está indo para trata-lo como un de catro
byte peza necesariamente, está realmente a suceder
tratala como un catro anacos de byte, o que podería ser algo así.
E aínda que non é enteiramente verdade, quere,
por mor de algo chamado unha ordenación, que non estamos
vai entrar agora, pero Se está curioso para saber,
pode ler-se en pouco e gran endianness.
Pero por mor dese argumento, por mor deste vídeo,
imos supor que é, en feito, como o número 65 sería
ser representado en memoria en cada sistema,
aínda que non é enteiramente verdade.
>> Pero imos realmente só obter librar de todos binario enteiramente,
e só pensar en como H e 65, é moito máis fácil
pensar niso como que, como un ser humano.
Todo ben, entón tamén parece quizais un pouco aleatorio que I've- meu sistema
non me deu bytes 5, 6, 7, e 8 para almacenar o número enteiro.
Hai unha razón para iso, tamén, que Non imos entrar agora, pero só
dicir que o que o ordenador está facendo aquí
pode ser unha boa xogada da súa parte.
Para non darme a memoria que é necesariamente ao atrás.
Aínda que vai facelo agora se eu queira obter outra secuencia,
chamado apelidos, e quero para poñer Lloyd alí.
Vou ter para caber un carácter, cada letra do que é
vai esixir un carácter, un byte de memoria.
Entón, se eu podería poñer Lloyd na miña matriz así eu son moi bo para ir, non?
O que falta?
>> Lembre que cada corda traballamos con en C remata con barra invertida cero,
e non podemos omitir que aquí, tamén.
Necesitamos deixar de lado un byte de memoria para almacenar que así nós
saber cando nosa cadea rematou.
Entón, de novo este arranxo de como as cousas
aparecen en poder de memoria ser un pouco ao chou,
pero, en realidade, é como a maioría dos sistemas están deseñados.
Para aliñar a eles en múltiples de catro, por razóns de novo
que non precisa entrar agora.
Pero iso, entón basta dicir que Despois destas tres liñas de código,
este é o que a memoria pode parecer.
Se eu ter lugares de memoria 4, 8, e 12 para manter os datos,
isto é o que a miña memoria pode parecer.
>> E só ser particularmente pedante aquí, cando
estamos a falar de memoria enderezos que adoitamos
facelo utilizando notacións hexadecimais.
Entón, por que non podemos converter todos estes de decimal a notación hexadecimal
só porque iso é xeralmente como nos referimos a memoria.
Entón, en vez de ser de 0 a 19, o que temos é cero
x cero a cero, tres x1.
Estes son os 20 bytes de memoria que ter ou nós estamos mirando nesta imaxe
xusto aquí.
>> Entón, todo o que se dixo, imos afastarse da memoria para un segundo
e ao punteiros.
Aquí é o máis importante cousa a lembrar
a medida que comezar a traballar con punteiros.
Un punteiro é nada máis dun enderezo.
Eu vou dicir de novo porque é tan importante,
un punteiro non é nada máis dun enderezo.
Os punteiros son enderezos para lugares na memoria onde variables vivir.
Sabendo que xa é un esperanza pouco máis fácil traballar con eles.
Outra cousa que me gusta que facer é ter sorte
de diagramas visualmente representando o que é pasando con varias liñas de código.
E nós imos facelo un par de cando en punteiros,
e cando falamos de dinámica reserva de memoria tamén.
Porque eu creo que estes diagramas pode ser especialmente útil.
>> Entón, se eu dicir, por exemplo, int k no meu código, que está a suceder?
O que está a suceder é basicamente Estou quedando memoria reservada para min,
pero eu non me gusta nin de pense nisto como este, eu
gusto de pensar niso como unha caixa.
Eu teño unha caixa e é de cor verde porque
pode pór enteiros en caixas verdes.
Se fose un personaxe que eu pode ter unha caixa azul.
Pero sempre digo, se eu estou creando unha caixa que pode conter enteiros
que a caixa é de cor verde.
E eu tomo un marcador permanente e eu k escribir sobre o lado do mesmo.
Entón, eu teño unha caixa chamada k, para que eu poida poñer enteiros.
Polo tanto, cando digo int k, que é o que pasa na miña cabeza.
Se eu digo que k é igual a cinco, o que estou facendo?
Ben, eu estou poñendo cinco no cadro, seguro.
Isto é moi sinxelo, se Digo int k, crear unha caixa chamada k.
Se eu digo que k é igual a 5, poñer cinco na caixa.
Esperemos que isto non é moi de un salto.
Aquí é onde as cousas van un pouco interesante aínda.
Se eu digo int * pk, así, aínda que eu non fai sabe o que é, necesariamente,
é claramente ten algo que ver con un número enteiro.
Entón eu vou para colorear esta caixa verde-ISH,
Sei que ten algo que ver con un número enteiro,
pero non é un número enteiro en si, porque é unha estrela int.
Hai algo lixeiramente diferente sobre iso.
Tan implicado un número enteiro, pero se non, é
non moi diferente do o que estabamos falando.
É unha caixa, o seu ten unha etiqueta, ela está a levar posto un pk etiqueta,
e é capaz de explotación estrelas int, calquera que sexan.
Teñen algo que ver con números enteiros, de forma clara.
Aquí é a última liña aínda.
Se eu digo pk = k, whoa, o que pasou, non?
Polo tanto, este número aleatorio, aparentemente aleatoria número, vai no cadro alí.
Todo o que é, é pk obtén a dirección de k.
Entón, eu estou unirse onde k vive na memoria, seu enderezo, a dirección dos seus bytes.
Todo o que eu estou facendo é que eu estou dicindo este valor é o que eu vou
para poñer dentro da miña caixa chamada pk.
E por isto son punteiros, e porque procura
nunha cadea como nula x oito cero ° C sete catro oito
dous cero pode ser non moi significativa.
Cando xeralmente ver punteiros, realmente facelo como punteiros.
Pk dános a información necesitamos atopar k na memoria.
Entón, basicamente pk ten unha frecha nela.
E se andarmos a lonxitude de que a frecha, imaxine
é algo que pode camiñar sobre, se nós camiñar ao longo da lonxitude da frecha,
na punta de flecha que, nos vai atopar o lugar na memoria
onde k vive.
E iso é realmente importante porque unha vez que sabemos onde k vive,
podemos empezar a traballar cos datos no interior do referido local de memoria.
Aínda estamos empezando un pequenininho pouco por diante de nós mesmos para o momento.
>> Entón, o que é un punteiro?
Un punteiro é un elemento de datos cuxo valor é un enderezo de memoria.
Isto foi o que o cero x oito cousas de cero pasando, que era un enderezo de memoria.
Esa era unha posición na memoria.
E do tipo de un punteiro describe o tipo
de datos que vai atopar no este enderezo de memoria.
Polo tanto, hai a parte dereita int estrela.
Se eu seguir esta flecha, é me vai levar a un lugar.
E ese lugar, o que eu vai atopar alí no meu exemplo,
é unha caixa de cor verde.
É un enteiro, que é o que eu vai atopar se eu ir a ese enderezo.
O tipo de datos a punteiro describe o que
vai atopar ese enderezo de memoria.
Entón aquí está a cousa moi legal aínda.
Punteiros nos permiten pasar variables entre funcións.
E, de feito, pasar variables e non pasar copias deles.
Porque se sabemos exactamente onde na memoria para atopar unha variable,
non precisamos de facer unha copia de Lo, podemos só ir a ese lugar
e traballar con esa variable.
Así, en esencia punteiros especie de facer un ambiente de ordenador
moito máis parecido ao mundo real, correcta.
>> Entón aquí vai unha analoxía.
Imos dicir que eu teño un portátil, dereito, e está cheo de notas.
E gustaríame que actualiza-lo.
É unha función que actualizacións notas, certo.
No camiño nós estivemos funcionando ata agora, o que
pasa é que vai tomar o meu portátil, ir ata a tenda de copia,
vai facer unha copia de Xerox todas as páxinas do caderno.
Vai deixar o meu portátil de volta na miña mesa cando estea listo,
vai pasar e risco cousas na miña notebook que están desactualizados ou mal,
e entón vai pasar ao me a pila de páxinas Xerox
que é unha réplica do meu portátil con os cambios que fixo a ela.
E nese punto, cómpre a min como a función de chamada, como o interlocutor,
para decidir tomar as súas notas e integrala los de volta para o meu portátil.
Polo tanto, hai unha serie de pasos implicado aquí, certo.
Como non sería mellor se eu só dicir, hey, pode
actualizar o meu portátil para me, entregar-lle o meu portátil,
e levar as cousas e literalmente cruza-los fora
e actualizar as miñas notas na miña caderno.
E, a continuación, dar-me o meu portátil de volta.
Ese é o tipo que punteiros nos permiten facer,
fan este ambiente moi máis como como operamos na realidade.
>> Todo ben entón iso é o que un punteiro é, imos falar
punteiros sobre como traballar en C, e como podemos comezar a traballar con eles.
Polo tanto, hai un punteiro moi sinxelo en C chamado punteiro nulo.
O punteiro puntos nulos a nada.
Isto probablemente parece que é en realidade, non é unha cousa moi útil,
pero como nós imos ver unha pouco despois, o feito
que existe ese punteiro nulo de feito, realmente pode vir a cadra.
E sempre que crear un punteiro, e non definir o seu valor imediatamente-
un exemplo de configuración o seu valor inmediatamente
será un par de láminas de volta onde eu dixen pk k é igual e,
pk recibe o enderezo k, como imos ver o que iso significa,
imos ver como codificar que shortly- se non que o valor a algo
significativa inmediatamente, ten que sempre
definir o punteiro para apuntar para null.
Ten que configuralo para apuntar para nada.
>> Iso é moi diferente do que deixando só o valor é tan
e, a continuación, declara unha punteiro e só supoñendo
é nula porque iso raramente é verdade.
Entón ten que sempre definir o valor dun punteiro
como nulo se non definir o seu valor para algo significativo inmediatamente.
Pode comprobar se o valor dun punteiro é nulo mediante o operador de igualdade
(==), Así como comparar calquera número enteiro valores ou valores de caracteres a usar (==)
ben.
É un tipo especial de constante valor que pode usar para probar.
Entón esa foi unha forma moi simple punteiro, o punteiro nulo.
Outra forma de crear un enlace é para extraer
a dirección dunha variable xa creou,
e facelo empregando o & extracción enderezo operador.
Que xa vimos anteriormente no primeiro exemplo diagrama eu mostre.
Entón, se x é unha variable que temos xa creada do tipo enteiro,
logo & x é un punteiro para un enteiro.
& X é- recordo, e vai extraer a dirección do cousa da dereita.
E unha vez que un punteiro é só un enderezo, que & x é un punteiro para un enteiro
cuxo valor é, onde na memoria x vidas.
É a dirección de x.
Así & X é a dirección de x.
Imos dar un paso máis e conectarse a algo
Eu, en alusión a un vídeo anterior.
Se arr é unha matriz de dúos, a continuación, & Paréntese arr i é un punteiro
para unha parella.
Aceptar.
arr cadrado soporte i si arr é unha matriz de dúos,
logo arr paréntese i é o elemento i-th desa matriz,
e & arr paréntese i é onde en memoria o elemento i-th de arr existe.
>> Entón, cal é a implicación aquí?
Un nome de matrices, a implicación de todo isto,
é que o nome dunha matriz é de feito en si un punteiro.
Ten traballado con punteiros ao longo de toda
cada vez que usou unha matriz.
Teña en conta que do exemplo ámbito de variables,
preto do fin do vídeo presento un exemplo no que temos unha función
chamado int set e unha función chamada matriz set.
E o seu reto para determinar ou non, ou o que o
valores que imprimir o final da función,
ao final do programa principal.
>> Se se lembrar de que o exemplo ou se asistiu o vídeo,
vostede sabe que cando você- a chamada a conxunto int efectivamente non fai nada.
A súa chamada para definir matriz fai.
E eu medio que encuberto por que era o caso no seu momento.
Eu só dixen, ben, é un array, é especial, xa sabe, hai unha razón.
A razón é que unha matriz de nome é realmente só un punteiro,
e hai esta especial sintaxe paréntese que
facer as cousas moito máis agradable para traballar.
E eles fan a idea dun punteiro moito menos intimidante,
e é por iso que son tipo da presentada desa forma.
Pero realmente matrices son só enlaces.
E é por iso que cando fixo un cambio para a matriz,
cando pasamos dunha matriz como un parámetro para unha función ou como un argumento
a unha función, o contido da matriz realmente cambiaron tanto no receptor
e en que o interlocutor.
Que para calquera outro tipo de variable que vimos non foi o caso.
Entón, iso é só algo para manter mente cando se está a traballar con punteiros,
que é o nome dun matriz, en realidade, un punteiro
para o primeiro elemento do array.
>> OK entón agora temos todos estes feitos, imos seguir, non.
Por que nos preocupa onde algo vive.
Ben, como dixen, é moi útil saber onde algo vive
para que poida ir alí e cambialo.
Traballar con el e realmente ten a cousa que
quere facer para que entren en vigor a variable, e non produce efectos nalgúns copia do mesmo.
Iso é chamado de dereferencing.
Nós imos para a referencia e nós cambiamos o valor alí.
Entón, se temos un punteiro e chámase PC, e apunta a un personaxe,
entón podemos dicir * * PC e PC é o nome do que imos atopar, se somos
para o PC enderezo.
O que imos atopar alí é un personaxe e * PC é como nos referimos aos datos a que
localización.
Así, poderiamos dicir algo así como * PC = D ou algo parecido,
e iso significa que calquera que sexa Foi no enderezo de memoria PC,
calquera personaxe que estaba anteriormente alí, agora D, se dicimos * PC = D.
>> Entón, aquí imos nós de novo con algunhas cousas C estraño, certo.
Entón vimos anteriormente como * dalgunha forma parte do tipo de datos,
e agora está a ser usado en nun contexto lixeiramente diferente
para acceder aos datos nun lugar.
Sei que é un pouco confuso e que é, en realidade, parte dese todo
como, por punteiros teñen esa mitoloxía en torno a eles como sendo tan complexo,
é un tipo de problema de sintaxe, honesta.
Pero * se usa en ambos os contextos, tanto como parte do nome do tipo,
e veremos un pouco despois outra cousa, tamén.
E agora é o operador de eliminación de referencia.
Por iso, vai á referencia el accede os datos
na localización do punteiro, e permite que manipula-lo a gusto.
>> Agora, este é moi similar ao visitar o seu veciño, certo.
Se sabe o que o seu veciño vive, é
non saír co seu veciño.
Vostede sabe que pasar sabe onde viven,
pero iso non significa que, por virtude de ter ese coñecemento
está interactuando con eles.
Se quere interactuar con eles, ten que ir para a súa casa,
ten que ir a onde eles viven.
E unha vez que se fai iso, a continuación, pode interactuar
con eles só como vai querer.
E do mesmo xeito coas variables, ten que ir para o seu enderezo
se quere interactuar eles, non pode só saber a dirección.
E o xeito no que ir ao enderezo é de usar *, o operador de eliminación de referencia.
¿Que pensas que pasa se nós intentamos e dereference
un punteiro cuxo valor é nulo?
Lembre que o nulo punteiro apunta para nada.
Entón, se tentar eliminar referencia nada ou ir a un enderezo de nada,
o que pensas que pasa?
Segmentación Ben, se adiviñou falla, estaría ben.
Se tentar e dereference un punteiro nulo,
padece unha segmentación fallo. Pero espera,
non vos digo, que se non está indo
para definir o valor da súa punteiro para algo significativo,
ten que definir como nulo?
Eu fixen e, de feito, a segmentación culpa é unha especie de bo comportamento.
>> Algunha vez xa declarou unha variable e Non concedido o valor inmediatamente?
Entón acaba de dicir int x; non fai de feito, atribuílo-lo a nada
e despois, máis tarde, no seu código, imprimir o valor de x,
aínda non lle atribúe a calquera cousa.
Frecuentemente terá cero, pero ás veces
pode obter un número aleatorio, e non ten idea de onde veu.
Así mesmo pode cousas pasar con punteiros.
Cando declarar un punteiro int * pk por exemplo,
e non atribuílo la a un valor, recibe catro bytes para memoria.
Calquera que sexan os catro bytes de memoria do sistema pode
considerar que ten algún valor significativo.
E non podería ser algo que xa existe
non se necesita doutra función, entón só ten
todos os datos que estaba alí.
>> E se intentou facer dereference algún enderezo que non- había
xa bytes e información alí, que está agora no seu punteiro.
Se tentar cancelar a referencia dese punteiro, pode estar mexendo con algunha memoria
que non tiña a intención para xogar con todo.
E de feito, podería facer algo realmente devastador,
como romper navegador, ou romper outra función,
ou facer algo malicioso que non tiña a intención de facer nada.
E é por iso que é realmente unha boa idea
para definir os punteiros como nulo se non configure-los para algo significativo.
É probabelmente mellor no final do día, para o seu programa
a fallar, a continuación, para que faga algo que estraga
outro programa ou outra función.
Este comportamento pode ser aínda menos ideal que deixe de funcionar.
E é por iso que é realmente un bo hábito
para entrar para definir os punteiros como nulo se non configure-los
a un valor significativo inmediatamente, un valor que sabe
e que pode con seguridade a eliminar referencia.
>> Entón, imos voltar agora e bótalle un ollo na sintaxe global da situación.
Se eu digo int * p;, o que eu acabo de facer?
O que eu teño feito é este.
Sei o valor de p é un enderezo porque todos os punteiros son só
enderezos.
Podo borrar a referencia p mediante o operador *.
Neste contexto aquí, no propio top recordar a * é parte do tipo.
Int * é o tipo de datos.
Pero podo dereference p usando o operador *,
e se eu fai iso, se eu ir a este enderezo, o que vou atopar nese enderezo?
Eu vou atopar un enteiro.
Así, int * p é basicamente dicindo: p é un enderezo.
Podo borrar a referencia p e Fago, eu vou atopar un número enteiro
en que a localización de memoria.
>> OK, entón eu dixo que non había outra cousa chat con estrelas
e aquí é onde que cousa chat con estrelas é.
Algunha vez xa intentou declarar múltiples variables do mesmo tipo
na mesma liña de código?
Entón, por un segundo, finxir que a liña, o código En realidade, teño alí en verde
non está alí e el só di int x, y, z;.
Que quere facer é realmente crear tres variables enteiras para ti,
un chamado x, unha chamada y, z e un chamado.
É un xeito de facelo sen ter que dividir en tres liñas.
>> Aquí é onde as estrelas chegar irritante novo aínda,
porque o * é de feito parte tanto o nome do tipo e parte
do nome da variable.
E por iso, se digo int * px, py, pz, o que eu en realidade é un punteiro para un enteiro
chamado px e dous enteiros, e py pz.
E iso probablemente non o que é queremos, isto non é bo.
>> Entón, se eu queira crear varios punteiros na mesma liña, do mesmo tipo,
e estrelas, o que realmente precisa que facer é dicir int * pa, * pb, * PC.
Agora, tendo só dixo que e agora lle dicindo iso,
probablemente non vai facelo.
E pode ser unha cousa boa, honestamente, porque pode inadvertidamente
omitir unha estrela, algo así.
É probablemente o mellor para declarar quizais punteiros en liñas individuais,
pero é só un daqueles sintaxe irritante
cousas que fan estrelas punteiros tan difícil de traballar.
Porque é só iso sintáctica desorde que ten que traballar.
Coa práctica que fai realmente facer unha segunda natureza.
Eu cometer erros con el aínda despois da programación durante 10 anos,
polo que non sexa chat se algo acontecer para ti, é moi común honesta.
Realmente tipo de un fallo da sintaxe.
>> OK entón eu medio que prometeu que queremos volver
o concepto de quão grande é unha cadea.
Ben, se eu lle dixese que un corda, temos realmente unha especie de
mentindo para ti todo o tempo.
Non hai ningún tipo de datos chamado corda, e de feito eu
mencionen iso nun dos nosos primeiros vídeos sobre tipos de datos,
esa secuencia foi un tipo de datos que foi creado para ti en CS50.h.
Ten que # include CS50.h, a fin de usalo.
>> Ben cadea é realmente só un alias para algo
chamado char *, un Punteiro para un personaxe.
Ben punteiros, recall, son só aborda.
Entón, cal é o tamaño en bytes dunha secuencia?
Ben, é catro ou oito.
E a razón de eu dicir catro ou oito é porque realmente
depende do sistema, se está a usar CS50 ide, char * é do tamaño dun char
* É de oito, é un sistema de 64 bits.
Cada enderezo na memoria é de 64 bits de lonxitude.
Se está usando aparello CS50 ou a utilización de máquinas de 32 bits,
e xa escoitou este termo de 32 bits máquina, o que é unha máquina de 32 bits?
Ben, iso só significa que cada enderezo na memoria é de 32 bits de lonxitude.
E así 32 bits é de catro bytes.
Así, un char * é de catro ou oito bytes dependendo do seu sistema.
E, de feito calquera tipo de datos, e un punteiro para todos os datos
escriba, xa que todos os punteiros son só enderezos, catro ou oito bytes.
Entón, imos volver a esta diagramar e imos concluír
este vídeo con un pouco de exercicio aquí.
Entón aquí está o diagrama paramos con no inicio do vídeo.
Entón o que ocorre agora, se eu digo * pk = 35?
Entón, o que quero dicir cando digo, * pk = 35?
Tomé un segundo.
* Pk.
No contexto aquí, é * operador de eliminación de referencia.
Así, cando o dereference operador é usado,
imos ao enderezo sinalado por pk, e nós cambiamos o que atopamos.
Así * pk = 35 eficaz fai iso coa imaxe.
Entón é basicamente sintaticamente o mesmo que o de dicir k = 35.
>> Máis un.
Se eu digo int m, creo unha nova variable chamada m.
Unha caixa, é unha caixa verde porque que vai realizar un número enteiro,
e é rotulado m.
Se eu digo que m = 4, engada un enteiro en que a caixa.
Se digamos pk = m, como é este cambio diagrama?
Pk = m, se lembra o que o Operador & fai ou se chama?
Lembre que o nome da variable e algúns é a dirección dun nome de variable.
Entón, o que estamos dicindo é pk obtén a dirección de m.
E así efectivamente o que ocorre no diagrama é que xa non pk puntos
para k, pero apunta a m.
>> Novo punteiros son moi complicado para traballar con
e eles toman unha morea de práctica, senón porque
da súa capacidade de permitir que para transmitir datos entre funcións
e realmente ten os cambios entren en vigor,
recibindo a súa cabeza en torno é realmente importante.
É probablemente o máis complicado tema que discutir en CS50,
pero o valor que comeza de usar punteiros
supera en moito as complicacións que veñen de aprendela las.
Entón, eu desexo-lle o mellor de sorte de coñecer punteiros.
Eu son Doug Lloyd, este é CS50.