>> DAVID MALAN: Olá, e boas-vindas de volta ao CS50.
Portanto, este é o fim de semana quatro.
Apenas um anúncio em primeiro lugar.
Assim, o chamado quinto segunda for chegando esta próxima segunda-feira.
Esta é a oportunidade para alterar de SAT / unsat a uma carta grau, ou de
carta grau SAT / unsat.
Importunamente, este processo exige uma assinatura, porque você tem que preencher
fora um desses add / drop formas-de-rosa.
>> Porque tecnicamente, o SAT / unsat ea versão classe da letra
têm números de catálogo distintas.
Mas não é grande coisa.
Basta vir até mim ou para o Rob ou Lauren a qualquer momento.
Ou e-mail, se você não tem o tipo de papelada que você precisa hoje, e nós
não se esqueça de ajudá-lo a tomar cuidado de que antes de segunda-feira.
>> Tudo bem, então hoje em dia -
Na verdade, há um pouco de eco.
Podemos tom me um pouco para baixo?
OK.
Então, hoje, nós introduzimos um tópico conhecido como ponteiros.
E eu admito que este é um dos temas mais complexos que tendem a
cobrir nesta classe, ou realmente qualquer curso introdutório que utiliza C.
>> Mas tome minha palavra para ela, especialmente Se sua mente se sente um pouco mais curvada
hoje e nas próximas semanas.
Não é representativo de você ficar pior neste isso significa apenas que
é um tema particularmente sofisticado que eu prometo, algumas semanas
Por isso, vai parecer muito impressionante simples em retrospecto.
>> Ainda me lembro até hoje.
Eu estava sentado no Elliott Dining Hall, sentado ao lado do meu TF Nishat Mehta,
que era um residente de Elliott casa.
E por alguma razão, este tema apenas cliques.
O que quer dizer que eu também lutava com ele por algum tempo, mas eu
farei o meu melhor para ajudar a evitar qualquer luta com um tema que, finalmente,
é bastante poderoso.
>> De fato, um dos temas que discutiremos nas próximas semanas é que
de segurança, e como você pode realmente explorar máquinas de maneiras
que não se destinam.
E essas explorações são tipicamente o resultado de erros, erros que
as pessoas fazem por não compreender algumas da implementação subjacente
detalhes através do qual os programas são feitos.
>> Agora, para fazer isso parecer mais user amigável, eu pensei em jogar a 10
segunda prévia de uma pequena claymation figura chamado Binky que foi trazido para
vida por um amigo nosso em Stanford, Professor Nick Parlante.
Então, permita-me dar-lhe este teaser do Binky aqui.
>> [REPRODUÇÃO]
>> -Ei, Binky.
Acordar.
É tempo para se divertir ponteiro.
>> -O que é isso?
Saiba mais sobre ponteiros?
Oh, goodie.
>> [FIM REPRODUÇÃO DE VÍDEO]
>> DAVID MALAN: Isso é Stanford ciência da computação.
Então, mais sobre isso mais para vir.
>> [Aplausos]
>> DAVID MALAN: Desculpe, Nick.
>> Então, lembro a última vez que terminou em este suspense realmente emocionante
pelo qual esta função simplesmente não funciona.
Pelo menos intuitivamente, senti como ele deve funcionar.
Basta trocar os valores de dois inteiros.
Mas lembre-se que quando impresso a valores originais em principal, um e
dois, eles ainda eram uma ea dois e dois e não uma.
>> Então deixe-me realmente mudar para o aparelho.
E eu escrevi um pouco de código esquelético em avançar aqui, onde eu afirmo que x
será de 1, y vai ser 2.
Eu, então, imprimir tanto de sua valores com f impressão.
>> Eu, então, afirmar aqui que vamos trocá-los.
Deixei um espaço vazio aqui para nós preencher hoje em apenas um momento.
Então, eu vou afirmar que a duas variáveis ​​foram trocados.
Então eu vou para imprimir los novamente.
E assim espero, deverá ver 1, 2.
2, 1.
Esse é o super simples objetivo agora.
>> Então, como é que vamos trocar duas variáveis?
Bem, se eu proponho aqui que estes copos pode representar em memória de um computador.
Esta é algumas mordidas, este é mais algumas mordidas.
Poderíamos ter um voluntário venha para cima e misturar-nos algumas bebidas, se familiar?
Vamos para cima.
Qual é o seu nome?
>> JESS: Jess.
>> DAVID MALAN: Jess?
Venha, Jess.
Se você não se importa, temos que colocar o Google Vidro em você para que possamos
imortalizar este.
OK, vidro.
Gravar um vídeo.
E OK, nós somos bons para ir com Jess aqui.
Tudo bem.
Prazer em conhecê lo.
>> Então o que eu gostaria de fazer aqui - se você pudesse, muito rapidamente -
só nós derrama metade de um copo de laranja suco e meio copo de leite,
representar efetivamente os números 1 em um copo e dois no outro copo.
>> Isso vai ser bom filmagens.
>> JESS: Desculpe.
>> DAVID MALAN: Não, não.
É OK.
Nice.
Tudo bem, então temos quatro bytes pena de suco de laranja.
Vamos chamou o valor 1.
Agora, mais quatro bytes no valor de leite.
Vai chamá-lo de valor 2.
Assim, X e Y, respectivamente.
>> Tudo bem, agora se a tarefa à mão - para você, Jess, na frente de todos
de seus colegas -
é trocar os valores de x e y tais que queremos que o suco de laranja no
outro copo e do leite neste copo, como talvez você - antes de você realmente faz
ele - vai fazer sobre isso?
>> OK, sábia decisão.
Então você precisa de um pouco mais de memória.
Então, vamos alocar um temporário copo, se você quiser.
E agora proceder para trocar x e y.
>> Excelente.
Então, muito bem feito.
Muito obrigado, Jess.
Aqui está.
Uma pequena lembrança.
>> OK, então, obviamente, super simples idéia.
Completamente intuitivo que precisamos de um pouco mais espaço de armazenamento - desta forma,
um copo - se realmente querem trocar essas duas variáveis.
Então, vamos fazer exatamente isso.
Até aqui no meio onde eu afirmo que eu sou vai fazer alguma troca, eu vou
vá em frente e declarar temporária.
E eu vou defini-lo igual a, digamos, x.
>> Então eu vou para alterar o valor de x apenas como Jess fez aqui com o
leite e suco de laranja ser igual a y.
E eu vou mudar y ser igual não x, porque agora nós estaríamos
preso em um círculo, mas sim temporários.
Onde temporariamente - ou onde Jess temporariamente colocar o suco de laranja
antes de sobrepor que xícara com o leite.
>> Então deixe-me ir em frente agora e fazer isso.
É chamado noswap.c.
E agora deixe-me correr sem swap.
E, na verdade eu vejo, se eu expandir a janela um pouco, que
x é 1, y é 2.
E então x é 2, y é 1.
>> Mas lembre-se que na segunda-feira nós fizemos coisas um pouco diferente em que eu
em vez implementada uma função auxiliar, se você, que era, na verdade vazio.
Liguei para ele trocar.
Eu dei-lhe dois parâmetros, e eu chamei -lhes um e liguei para eles b.
>> Francamente, eu poderia chamá-los de x e y.
Não há nada que impeça me de fazer isso.
Mas eu diria que é, em seguida, um pouco ambígua.
Porque recordação para segunda-feira que nós alegou que estes parâmetros foram
cópias dos valores passados ​​dentro
Por isso só mexe com o seu mente, eu acho que, se você usar
exactamente as mesmas variáveis.
>> Então, eu vou chamá-los de uma vez e b, apenas por razões de clareza.
Mas poderíamos chamá-los mais qualquer coisa que quisermos.
E eu vou copiar e colar eficazmente este código lá de cima
baixo em aqui.
Porque eu só vi que ele funciona.
Então, isso é em muito boa forma.
E eu vou mudar o meu x para um, meu x a um, o meu y a b e meu y a b.
>> Portanto, em outras palavras, exatamente a mesma lógica.
A mesma coisa que Jess fez.
E então a única coisa que tenho a fazer-se aqui, é claro, está agora invocar esta
função, ou ligue para essa função.
Então eu vou chamar essa função com dois insumos, x e y, e bateu em Salvar.
>> Tudo bem, então fundamentalmente a mesma coisa.
Na verdade, eu provavelmente já fez o programa desnecessariamente complexa por
escrever uma função que está apenas tomando cerca de seis linhas de código, enquanto eu
anteriormente havia implementado isso em apenas três.
>> Então deixe-me ir em frente agora e refazer isso, não fazem swap.
Tudo bem, eu estraguei tudo aqui.
Este deve ser um erro que você pode ver cada vez mais comumente como o seu
programas se tornam mais complexas.
Mas há um reparo fácil.
Deixe-me rolar para trás até aqui.
>> E o que é o primeiro erro que eu estou vendo?
Declaração implícita.
O que significa que normalmente indicam?
Ah, eu esqueci o protótipo.
Eu esqueci de ensinar o compilador que troca vai existir, embora ele
não existe no início do programa.
Então, eu só vou dizer nula, swap, int, um int b, ponto e vírgula.
>> Então, eu não estou indo para reimplementar-lo.
Mas agora coincide com o que está aqui embaixo.
E notem, a ausência de um ponto e vírgula aqui, o que não é necessário quando
de execução.
>> Então deixe-me refazer este, não fazem swap.
Muito melhor forma.
Executar sem swap.
E dane-se.
Agora estamos de volta onde estávamos na segunda-feira, onde a coisa não trocar.
>> E qual é a explicação intuitiva por que esse é o caso?
Sim?
>> Estudante: [inaudível].
>> DAVID MALAN: Exatamente.
Assim, a e b são cópias de x e y.
E, de fato, a qualquer momento que você esteve chamar uma função, até agora, que
passa variáveis ​​como ints -
apenas como swap está esperando aqui -
Vocês foram passando cópias.
>> Agora, isso significa que ele tem um pouco de tempo, uma fração de segundo, para o
computador para copiar os bits de um variável para os bits de outro.
Mas isso não é um negócio tão grande.
Mas eles são, no entanto uma cópia.
>> E agora, no contexto de swap, Eu sou de fato com sucesso
alterando a e b.
Na verdade, vamos fazer um rápido teste de sanidade.
Imprimir um f é% i, a nova linha.
E ficha vamos em um.
Agora vamos fazer a mesma coisa com b.
E vamos fazer a mesma coisa aqui.
>> E agora, deixe-me copiar as mesmas linhas novamente na parte inferior da função
depois dos meus três linhas de interessante poderia ter executado, e
imprimir a e b novamente.
Então agora vamos fazer isso, não fazem swap.
Deixe-me fazer a janela do terminal um pouco mais alto, para que possamos ver
mais do que uma vez.
>> E executar nenhum swap.
x é 1, y é 2. a é 1, b é 2.
E, em seguida, a é 2, b é 1.
Então, ele está trabalhando, assim como Jess fiz aqui dentro de swap.
Mas, claro, ele está tendo nenhum efeito sobre as variáveis ​​principal.
>> Então vimos um truque pelo qual poderia corrigir isso, certo?
Quando você se depara com este escopo problema, você poderia apenas punt e fazer x
e y que tipo de variáveis ​​em vez disso?
>> Você poderia torná-los global.
Coloque-os no topo do arquivo como fizemos, mesmo no jogo da 15.
Nós usamos uma variável global.
Mas, no contexto de um jogo 15, é razoável ter um mundial
variável que representa o conselho, porque a totalidade de todos é 15.c
sobre a implementação desse jogo.
Isso é o que existe no arquivo para fazer.
>> Mas, neste caso aqui, eu sou chamando uma troca de função.
Quero trocar duas variáveis.
E isso deve começar a se sentir apenas desleixado se a solução para todas as nossas
problemas quando são executados no escopo questões é torná-lo global.
Devido muito rapidamente nosso programa é vai se tornar uma grande bagunça.
E nós fizemos isso com muita moderação como resultado, em 15.c.
>> Mas acontece que há uma melhor maneira completamente.
Permitam-me, na verdade, voltar atrás e apagar a imprimir de f, apenas para simplificar o código.
E deixe-me propor que este, de fato, é ruim.
Mas se eu, em vez de adicionar alguns asteriscos e as estrelas, posso transformar isso em vez
função em que é realmente operacional.
>> Então deixe-me voltar aqui e admitir dizendo asteriscos é sempre difícil,
então eu vou dizer estrelas.
Vou confessar para isso.
Tudo bem.
E agora, o que eu vou fazer em vez disso?
>> Então, primeiro de tudo, eu vou especificar que em vez de passar um int em
a função swap, estou vez de vai dizer int estrela.
Agora, o que a estrela indica?
Esta é a ideia de que um ponteiro que Binky, o personagem claymation, foi
referindo-se a um momento atrás.
>> Então, se nós dizemos int estrela, o significado de isto agora é que uma não vai ser
passado pelo seu valor.
Ele não vai ser copiado dentro
Em vez disso, o endereço é um vai ser passado dentro
>> Então, lembro que dentro do seu computador é um monte de memória, caso contrário,
conhecido como RAM.
E que a RAM é apenas uma grupo inteiro de bytes.
Portanto, se o seu Mac ou PC tem dois gigabytes, você tem 2
bilhão de bytes de memória.
>> Agora vamos supor que apenas a manter as coisas agradáveis ​​e ordenada, que
atribuir um endereço -
um número -
para cada byte de memória RAM em seu computador.
O primeiro byte dos dois bilhões é pelo número zero.
O seguinte é um número de um byte, o número dois, todo o caminho para cima, dot dot
ponto, para cerca de 2 bilhões de dólares.
>> Assim, você pode número de bytes de memória em seu computador.
Então vamos supor que isso é o que queremos dizer com um endereço.
Então, quando eu vejo uma estrela int, o que está acontecendo para ser passado em troca agora é o
endereço de um.
Não o seu valor, mas seja qual for o seu postal endereço é, por assim dizer -
a sua localização na RAM.
>> E da mesma forma para b, eu vou para dizer a mesma coisa.
Int, estrela, b.
Como um aparte, tecnicamente a estrela poderia ir em outros locais.
Mas vamos padronizar a estrela estar ao lado do tipo de dados.
>> Então trocar assinatura significa que agora, dá-me o endereço de um int, e chamada
que um endereço.
E me dar outro endereço de um int e chamar esse endereço b.
>> Mas agora o meu código aqui tem que mudar.
Porque se eu declarar int temperatura -
que ainda é do tipo int -
mas armazenar nele um, que tipo de valor?
Para ser claro, eu estou pondo um com o código como está escrito agora?
>> Eu estou colocando o local em um.
Mas eu não me importo com o localização agora, certo?
Temp existe apenas terceira xícara de Jess existido, para que finalidade?
Para armazenar um valor.
Leite ou suco de laranja.
Não, na verdade, armazenar o endereço de nenhuma dessas coisas, que se sente um
pouco sem sentido neste verdadeiro contexto do mundo de qualquer maneira.
>> Então, realmente, o que eu quero colocar em temperatura não é o endereço de um, mas a
conteúdo de um.
Então, se a é um número como 123, este é o byte 123 de memória que um só
passa a ser ocupante, que o valor de em que ocorra ser ocupante.
>> Se eu quero ir para esse endereço, Eu preciso dizer uma estrela.
Da mesma forma, se eu fosse para mudar o que é no endereço um, eu mudo
isto para iniciar uma.
Se eu quiser armazenar em que está no localização de um com o que está no local
em b, estrela b estrela.
>> Assim, em breve, mesmo que isso não é muito afundando ainda - e eu não esperaria
que seria tão rápido -
perceber que tudo o que eu estou fazendo é prefixar estas estrelas para os meus variáveis,
dizendo que não pegar os valores.
Não altere os valores.
Mas, sim, ir a esses endereços e obter o valor.
Vá para esse endereço e mudança o valor aí.
>> Então, agora deixe-me rolar para trás até o topo, apenas para corrigir essa linha aqui, a
mudar o protótipo para corresponder.
Mas agora eu preciso fazer uma coisa.
Intuitivamente, se eu mudei os tipos troca de argumentos que está esperando,
o que mais eu preciso alterar no meu código?
>> Quando eu chamo de swap.
Porque agora, o que eu Eu passando a trocar ainda?
O valor de x e o valor de y, ou o leite eo suco de laranja.
Mas eu não quero fazer isso.
Eu em vez quer passar em quê?
A localização de xe o local de y.
Quais são os seus endereços postais, por assim dizer.
>> Então, para fazer isso, há um e comercial.
Ampersand tipo de sons como o endereço.
assim n, comercial, o endereço de x, e o endereço de Y.
Por isso é deliberado que usamos ampersands ao chamar a função,
e as estrelas quando declarar e quando execução da função.
>> E só de pensar e comercial como o endereço do operador, e uma estrela como o
ir lá operador -
ou, mais corretamente, o Operador de referência.
Então, isso é um monte de palavras apenas para dizer que agora, felizmente, troca vai
a ser corretas.
>> Deixe-me ir em frente e fazer -
vamos realmente mudar o nome do arquivo, para que não este programa ainda ser chamado sem swap.
Eu afirmo que vamos chamá-lo swap.c agora.
Então faça, troque.
Dot, Slash, troque.
>> E agora verdade, x é 1, y é 2.
E então, x é 2, y é um.
Bem, vamos ver se não podemos fazer isso um pouco diferente, como o que é
acontecendo aqui.
Primeiro, deixe-me aproximar em nosso tela de desenho aqui.
E deixe-me propor por um momento - e sempre que eu chamar aqui será espelhado
lá em cima agora - deixe-me propor que aqui está um monte de memória, ou
RAM, dentro do meu computador.
>> E este vai ser o número mordida, digamos, um.
Este será o número 2 bytes.
E eu vou fazer um monte de outras, e em seguida, um grupo de Dot Dot pontos para
indicam que há 2 bilhões destas coisas.
4, 5 e assim por diante.
>> Portanto, há os cinco primeiros bytes de memória do meu computador.
Tudo bem?
Muito poucos de 2 bilhões de dólares.
Mas agora eu vou propor a seguir.
Vou propor que x vai armazenar o número 1, e y vai
para armazenar o número 2.
E deixe-me ir em frente agora e representa estes valores como segue.
>> Vamos fazer isso da seguinte forma.
Dê-me apenas um segundo.
Um segundo.
OK.
Eu quero fazer isso um pouco -
vamos fazer isso de novo.
Caso contrário, eu vou e usando o mesmos números, sem querer,
várias vezes.
>> Então, só por isso temos números diferentes para falar, vamos chamar isso de byte
número 123, 124, 125, 126, e dot dot dot.
E deixe-me afirmar agora que eu vou colocar o valor 1 aqui, e o valor de 2
aqui, também conhecido como x e y.
Então, acontece que este é x, isto é y.
>> E só por algum acaso, o computador, o sistema operativo,
passou a colocar x no local número 123.
E y acabou no local 124 -
caramba.
Eu deveria ter corrigido isso.
Oh homem, que eu realmente quero fazer isso?
Sim, eu quero corrigir isso e b adequada sobre isso hoje.
Desculpe, novo nisso.
>> 127, 131, e eu não quero ser essa complexo, mas por que eu mudar o
números lá?
Porque eu quero que os ints para na verdade, ser de quatro bytes.
Então, vamos ser super anal sobre isso.
Assim, se um passa a ser endereçado 123, o 2 vai ser no endereço
127, porque isso é apenas 4 despedidas distância.
Isto é tudo.
E vamos esquecer tudo o outros endereços do mundo.
>> Assim x está na posição 123, Y está na posição 127.
E agora, o que eu realmente quer fazer?
Quando eu chamo de swap agora, o que é realmente está acontecendo?
Bem, quando eu chamo de swap, eu estou passando em o endereço de X e o endereço de Y.
Assim, por exemplo, se estas duas peças de papel representam agora os dois
argumentos a e b para trocar, o que eu sou indo para escrever na primeira delas,
que eu vou ligar para o referem como um?
>> Exatamente, 123.
Então, isso eu afirmo é um.
Este é um parâmetro.
Estou colocando o endereço de x ali.
>> O que é isso?
>> Não, não.
Isso é OK.
Ainda bem, ainda bem.
Portanto, este é um.
E agora no segundo pedaço de papel, este vai ser b, e que sou eu
vai ser escrita em este pedaço de papel?
127.
>> Então a única coisa que mudou desde nosso entendimento anterior desta história é,
ao invés de, literalmente, um e dois, eu sou vai passar em 123 e 127.
E eu estou indo agora para colocá-los dentro desta caixa, certo?
Assim que a caixa preta representa agora a função swap.
>> Enquanto isso, vamos agora ter alguém implementar a função swap.
Será que alguém aqui gostaria de ser voluntário?
Vamos para cima.
Qual é o seu nome?
Charlie.
Tudo bem, Charlie.
Vamos para cima.
>> Então, Charlie vai jogar o papel do nosso caixa preta.
E Charlie, o que eu gostaria que você faça agora é implementar permuta de tal maneira
que, dado os dois endereços, você estava indo realmente
para alterar os valores.
E eu vou sussurrar em seu ouvido como executar a TV aqui.
>> Então vá em frente, e você é a caixa preta.
Chegar lá.
Que valores você vê um, e os valores que você vê para b?
>> Nash: a é 123 e b é 127.
>> DAVID MALAN: OK, exatamente.
Agora, há uma pausa por um momento.
A primeira coisa que você vai fazer agora, de acordo com o código - que
Agora eu vou puxar para cima na tela -
vai ser para alocar um pouco bit de memória chamado Temp.
Então, eu estou indo para ir em frente e dar-lhe a memória.
>> Então, isso vai ser uma terceira variável que você tem acesso a
você chamado Temp.
E o que você vai escrever no pedaço de papel temporária?
>> CHARLIE: Ponteiros, certo?
>> DAVID MALAN: OK, bem, não necessariamente ponteiros.
Assim, a linha de código que eu tenho destaque no lado direito,
vamos começar por aí.
Ele diz que uma estrela.
Assim, uma está armazenando o número 123.
E, assim, intuitivamente, o que que estrela 123 significa?
>> Mas especificamente, se é um 123, uma estrela significa o quê?
O valor de um.
Ou, mais casual, vá lá.
Então deixe-me propor que, segurando a uma em sua mão, vá em frente e tratar esse
como se fosse um mapa.
E caminhar-se para o computador do memória, e encontrar-nos o que é
na posição 123.
Exatamente.
>> Assim, vemos na posição 123 é o que, obviamente,?
OK, então o valor agora é você vai colocar em temperatura?
Exatamente.
Então vá em frente e fazer isso.
E escreva o número 1 no pedaço de papel que está atualmente intitulado temporária.
>> E agora o próximo passo que você está indo para implementar
vai ser o quê.
Bem, no lado direito da próxima linha de código é a estrela b. b, de
Claro, armazena um endereço.
Que aborda 127.
Estrela b significa que, casualmente falando?
>> Vá para esse local.
Então vá em frente e encontrar-nos o que é na posição 127.
OK.
Claro que, na posição 127, ainda é o valor 2.
Então, o que você está indo agora em loja o que está no local em um?
Então, estrela um meio ir para o local a.
Qual é a localização de um?
>> Exatamente.
Então, agora, se você quiser mudar o que está naquele local -
Eu vou em frente e correr a borracha está aqui.
E agora colocá-lo novamente na escova.
Qual é o número que você vai escrever na caixa em branco agora?
>> Exatamente.
Portanto, esta linha de código, para ser claro - vamos me pausar o que Charlie está fazendo e
salientar aqui, que ele acabou de fazer é escrever para a caixa no local 123
O valor que foi anteriormente em b.
E assim temos agora implementada de fato Nesta segunda linha de código.
>> Agora, infelizmente, não há ainda uma linha restante.
Agora o que está em temp, literalmente?
É óbvio que é o número um.
Isso não é um endereço.
É apenas um número, uma espécie de uma variável a partir de uma semana.
>> E agora, quando você diz estrela b, o que significa ir para o endereço de b, que é de
curso aqui.
Então, quando você chegar lá -
Eu vou em frente e apagar o que é realmente lá - e que é você
vai escrever agora em 127 localização?
>> CHARLIE: Temp, que é um.
>> DAVID MALAN: Temp, que é um.
E o que acontece a temperatura no final?
Bem, nós realmente não sabemos.
Nós realmente não me importo.
Toda vez que nós implementamos uma função até o momento, todas as variáveis ​​locais você tem
são, de fato local.
E eles simplesmente desaparecem.
Eles estão recuperados pela operação sistema eventualmente.
>> Assim, o facto de que ainda tem a temperatura valor 1 é uma espécie de fundamentalmente
desinteressante para nós.
Tudo bem, então uma salva de palmas se pudéssemos para Charlie.
Muito bem feito.
>> Tudo bem, então o que mais faz Isso significa que nós podemos fazer?
Assim, verifica-se que temos sido contando algumas mentirinhas
por algum tempo.
De fato, verifica-se que a corda, todo este tempo, não é realmente um
seqüência de caracteres por si só.
É o tipo de é que intuitivamente.
>> Mas, tecnicamente falando, a string é uma tipo de dados que declarada dentro de
a biblioteca CS50 para simplificar o mundo para as primeiras semanas de aula.
O que uma string é realmente é o endereço de um personagem em algum lugar na RAM.
A corda é realmente um número, como 123 ou 127, que passa a demarcar
onde uma string começa em a memória do seu computador.
>> Mas isso não representa a cadeia, por si só, em si.
E podemos ver isso da seguinte forma.
Deixe-me ir em frente e abrir algum código que está entre
exemplos de código fonte de hoje.
E eu estou indo para ir em frente e abrir até, digamos, compare-0.C.
Este é um programa buggy que vai para ser implementada como se segue.
>> First.
Eu vou dizer uma coisa.
Então, eu estou indo para ir em frente e obter uma string do usuário
nessa linha seguinte.
Então eu vou dizê-lo novamente.
Então eu vou ter outra corda do usuário.
>> E notem, eu estou mostrando um dos cordas em uma variável chamada s, e
outra dessas cordas em uma variável chamada t.
E agora eu vou reclamar, muito razoavelmente, que se s é igual é igual a t,
as cordas são as mesmas.
Você digita a mesma coisa.
Caso contrário, as cordas são não é a mesma coisa.
>> Afinal de contas, se a entrada de dois inteiros, dois caracteres, dois carros alegóricos, dois duplos, todos de
os tipos de dados que nós falamos até agora para compará-los -
lembro que fizemos muito claro há um tempo atrás que você não fazer isso, porque a
único sinal de igualdade é, naturalmente, o operador de atribuição.
Então, isso seria um erro.
>> Nós usamos o sinal de igual igual, que de fato se compara
coisas para uma verdadeira igualdade.
Mas eu afirmo isso é buggy.
Se eu ir em frente e fazer comparar zero, e então não dot barra comparar zero.
E eu digitar, vamos dizer, Olá.
E então, vamos dizer Olá novamente.
Literalmente a mesma coisa, o computador reclamações que eu digitei coisas diferentes.
>> Agora, talvez eu apenas digitado errado alguma coisa.
Eu vou escrever meu nome neste momento.
Quero dizer, Olá.
Olá.
É diferente a cada momento.
>> Bem, por que isso?
O que realmente está acontecendo debaixo do capô?
Bem, o que realmente está acontecendo por baixo a capa é a cadeia, em seguida,
Eu digitei em que pela primeira vez, por exemplo, é a palavra Olá, é claro.
Mas se representar esta embaixo o capô, lembre-se que uma
string é em uma matriz.
E nós dissemos, tanto no passado.
>> Então, se eu tirar essa matriz como este, eu sou vai representar algo muito
semelhante ao que fizemos há pouco.
E há realmente algo especial também.
O que nós fizemos foi determinar a Ao final de cada corda?
Sim, esta barra invertida zero, o que é apenas a forma de representação,
literalmente, 00000000.
Oito bits 0 em uma fileira.
>> Eu não sei, francamente, o que é depois disso.
Isso é apenas um bando de mais memória RAM dentro do meu computador.
Mas esta é uma matriz.
Nós conversamos sobre matrizes antes.
E nós tipicamente falar sobre matrizes como sendo localização zero,
em seguida, um, depois dois.
Mas isso é apenas por conveniência.
E isso é totalmente relativo.
>> Quando você está realmente ficando memória o computador, é, claro, qualquer
2 bilhões de alguns bytes ímpares, potencialmente.
Então, realmente debaixo do capô, todo esse tempo, sim.
Isso pode muito bem ser o suporte zero.
Mas se você cavar ainda mais fundo por baixo o capô, que é realmente
abordar número 123.
Este é o endereço 124.
Este é o endereço 125.
>> E eu não queria estragar esse momento.
Estes são agora uma bytes separados por qual razão?
Quão grande é um char?
Um char é apenas um byte.
Um int é tipicamente quatro bytes.
É por isso que eu fiz 123, 127, 131 e assim por diante.
Agora eu posso manter a matemática simples e apenas fazer mais 1.
E isso agora é o que está realmente acontecendo por baixo do capô.
>> Então, quando você declarar algo como isso, string s, este é, na verdade -
acontece -
estrela Char.
Star, é claro, significa endereço, ponteiro aka.
Portanto, é o endereço de alguma coisa.
O que é o endereço do?
>> Bem -
Eu sou o único que pode ver o muito ponto importante que eu estou fazendo, ou pensam
Eu estou fazendo.
Então string -
o triste é que eu tenho um monitor lá onde eu
poderia ter visto isso.
>> Tudo bem, então string s é o que Eu declarei anteriormente.
Mas acontece que, graças a um pouco magia na biblioteca CS50, tudo isso
string de hora tem literalmente foi estrela de char.
A estrela significa novamente ponteiro ou endereço.
O fato de que ele é o acompanhamento caracter de palavra significa que é a
endereço de um personagem.
>> Então, se conseguir string é chamado, e eu digito em H-E-L-L-O, propor agora o que se
corda sido literalmente voltando todos Neste momento, mesmo que nós, em vez
simplista do mundo?
O que significa obter corda realmente retornar como seu valor de retorno?
>> 123, neste caso, por exemplo.
Nós já disse anteriormente que se cadeia simplesmente retorna uma string, uma seqüência de
caracteres.
Mas isso é um pouco de uma mentira branca.
A forma como se cordas realmente funciona debaixo do capô é que fica a
corda do usuário.
Ele se estatela os personagens que ele ou ela tipos de memória.
Ela coloca um zero barra invertida no final daqueles sequência de caracteres.
>> Mas então o que se cadeia literalmente voltar?
É, literalmente, retorna o endereço do primeiros bytes na RAM que
é usado para essa força.
E verifica-se que apenas devolvendo um único endereço da
primeiro caractere na string, que é suficiente para encontrar a totalidade
a string.
>> Em outras palavras, obter a cadeia não tem para retornar 123 e 124 e 125.
Ele não tem que me dar um longo lista de todos os bytes
minha corda está usando.
Porque um, todos eles estão de volta para trás.
E segundo, com base no primeiro endereço, I pode descobrir onde a string termina.
Como?
>> O caractere nulo especial, a barra invertida zero no final.
Assim, em outras palavras, se você passa ao redor -
dentro das variáveis ​​-
o endereço de um char, e assume que, no final de qualquer cadeia, qualquer
seqüência de caracteres como nós, seres humanos pensar em cordas, se você assumir que
no final de tal cadeia há um zero barra invertida, você é ouro.
Porque você sempre pode encontrar no final de uma string.
>> Agora o que realmente está acontecendo, em seguida, em neste programa?
Porque é que este programa, comparar-0.C, com bugs?
O que realmente está sendo comparado?
Sim?
>> Estudante: [inaudível].
>> DAVID MALAN: Exatamente.
É comparando as posições das cordas.
Portanto, se o usuário digitou em Olá uma vez, como eu fiz, a memória pode acabar
desse jeito.
Se, em seguida, o usuário digita em Olá novamente, mas chamando obter corda de novo, c é
não é particularmente inteligente, a menos que você ensina que ele seja inteligente, escrevendo código.
>> C -
e computadores em geral -
se você digitar a palavra Olá novamente, você sabe o que você vai conseguir.
Você está indo só para ter uma segunda matriz de memória que, sim, acontece ser
armazenar H-E-L-L-S e assim por diante.
>> Vai ter a mesma aparência de nós seres humanos, mas este endereço
pode não ser 123.
Ele só poderia acontecer que o sistema operativo tem alguns disponíveis
espaço, por exemplo, a localização -
digamos que algo arbitrário, como este é local 200.
E este é o local 201.
E este é o local 202.
Nós não temos nenhuma idéia de onde isso é vai ser na memória.
>> Mas o que isso significa é que o que é vai ser armazenado, finalmente, em s?
O número 123.
O que vai ser armazenada em t, neste exemplo arbitrária?
O número 200.
E tudo isso significa, então, é claro, 123 não é igual a 200.
E assim esta condição nunca se avaliada como verdadeira.
Porque corda get está usando diferentes pedaços de memória de cada vez.
>> Agora podemos ver isso de novo noutro exemplo.
Deixe-me ir em frente e abrir cópia 0.C.
Eu afirmo que este exemplo vai tentar - mas não - copiar duas cordas
como se segue.
>> Eu vou dizer uma coisa para o utilizador.
Estou passando então a ter uma corda e chamá-lo s.
E agora, eu estou fazendo essa verificação aqui.
Mencionamos isso um tempo atrás.
Mas quando pode ter seqüência de retorno null, outro caractere especial ou especial
símbolo digamos.
Se é falta de memória.
>> Por exemplo, se o usuário é realmente ser difícil e os tipos de atroz
número de caracteres no teclado e batidas Enter.
Se esse número de caracteres simplesmente não pode caber na memória RAM para qualquer louco
razão, bem se poderia corda muito bem retornar nulo.
>> Ou se o seu próprio programa está fazendo muito de outras coisas e não apenas
não há memória suficiente para a corda get para ter sucesso, ele pode acabar
voltando nulo.
Mas vamos ser mais preciso como o que é isso.
Qual é o tipo de dados de s realmente?
Estrela Char.
>> Então não é que agora podemos casca apoiar a camada de nulo.
Acontece que, nula é - sim, obviamente um símbolo especial.
Mas o que é realmente?
Realmente, nulo é apenas um símbolo que os seres humanos usam para representar zero também.
>> Assim, os autores C e computadores mais geralmente, decidiu anos atrás
que, você sabe o quê.
Por que não podemos garantir que nenhum usuário dados é que nunca, nunca, nunca
armazenado a bye Zero?
De fato, mesmo no meu exemplo arbitrário antes, eu não iniciar a numeração da
bytes em zero.
Eu comecei em um.
Porque eu sabia que as pessoas no mundo decidiram reservar o zero
byte em ninguém RAM como algo especial.
>> A razão de ser, a qualquer hora que você quiser sinal de que algo está errado
no que diz respeito aos endereços, é devolvido null - também conhecido como zero -
e porque você sabe que não há nenhuma legítimo de dados no endereço zero, claramente
que significa um erro.
E é por isso que, por convenção, verifique para nula e retorno algo
como um desses casos.
>> Então, se rolar agora, este é apenas em seguida, verificação de erros, apenas no caso
algo deu errado com [? fiança?]
completamente e sair do programa voltando mais cedo.
Esta linha agora poderia ser reescrito como este, o que significa o quê?
No lado esquerdo, dá-me outra ponteiro para um personagem, e chamá-lo de t.
O que eu estou armazenando dentro de t, com base sobre esta linha de código?
>> Estou armazenando um local.
Especificamente, a localização que foi em s.
Portanto, se o usuário digitou em Olá, e que primeiro acontece Olá acabar
aqui, em seguida, o número 123 é vai voltar de obter
corda e ser armazenado -
como dissemos anteriormente -
em s.
>> Quando eu declaro agora outro ponteiro para um char e chamá-lo de t, o número é
literalmente vai acabar em t de acordo com a história?
Então, 123.
>> Então, tecnicamente agora ambos s e t estão apontando para o exato
mesmos pedaços de memória.
Então, observe o que eu vou fazer agora para provar que este programa é buggy.
>> Primeiro eu vou afirmar, com um f impressão, capitalizando
a cópia da string.
Então eu vou fazer um pouco verificação de erros.
Eu vou ter certeza.
Vamos certificar-se de que a cadeia t está em menos maior que zero no comprimento,
por isso há algum personagem lá para realmente capitalizar.
>> E então você pode recordar esta dos exemplos anteriores.
2 superior - o que é na o arquivo ctype.h.
T faixa de zero me dá o zero caracter da string t.
E 2 superior do mesmo valor, de Claro, converte para maiúsculas.
>> Assim, intuitivamente, esta linha destacada do código está capitalizando o primeiro
letra t.
Mas não é capitalizar, de forma intuitiva, a primeira letra s.
Mas se você está pensando no futuro, o que eu sou prestes a ver, quando eu executar este programa
e imprimir o original, s, ea cópia chamada, t?
>> Eles estão, na verdade, vai ser o mesmo.
E por que é que eles vão ser os mesmos?
Ambos estão apontando para exatamente a mesma coisa.
Então, vamos fazer isso.
>> Fazer cópia zero.
Ele compila OK.
Deixe-me correr cópia zero.
Deixe-me escrever algo como Olá em todas as letras minúsculas, em seguida, pressione Enter.
E ela afirma que tanto o s originais ea cópia são realmente idênticas.
>> Então, o que realmente aconteceu aqui?
Deixe-me redesenhar esta imagem só para contar a história de uma
maneira um pouco diferente.
O que realmente está acontecendo debaixo do capuz quando eu declarar algo como
s de char começo, ou string s, Estou recebendo um ponteiro -
que passa a ser de quatro bytes no aparelho CS50
e em um monte de computadores.
E eu vou chamar isso de s.
E isso tem atualmente algum valor desconhecido.
>> Quando você declara uma variável, a menos que você se colocar um valor lá, que
sabe o que está lá.
Pode ser uma sequência aleatória de bits da execução anterior.
Então, quando eu, na minha linha de código fizer string, e depois armazenar o retorno
valor em s obter seqüência de alguma forma -
e vamos eventualmente descascar como obter obras de cordas, de alguma forma atribui uma
matriz que provavelmente parece um pouco como isso.
H-E-L-L-S, invertida zero.
>> Vamos supor que este é o endereço 123 apenas primeiro consistência.
Portanto, obter corda retorna, no linha destacada lá, ele retorna o
número dissemos, 123.
Então, o que realmente se passa dentro de s aqui?
>> Bem, o que realmente se passa dentro de s é 123.
Mas, francamente, eu estou ficando um pouco confuso por todos estes endereços,
todos estes números arbitrários.
123, 124, 127.
Então, vamos realmente simplificar o mundo um pouco.
>> Quando falamos de ponteiros, francamente, para nós seres humanos, quem diabos se importa onde
as coisas estão na memória?
Isso é completamente arbitrária.
Vai depender de como quantidade de RAM que o usuário tem.
Vai depender de quando, no dia você executar o programa, talvez, e
que a entrada do usuário lhe dá.
Estamos habitação em detalhes sem importância.
>> Então vamos abstrair e dizer que, quando você executa uma linha de código como este,
carbonizar estrela s recebe o retorno valor da cadeia get.
Por que não ao invés de apenas desenhar o que continuar chamando um ponteiro como se fosse
apontando para alguma coisa?
Então eu afirmo agora que s up existe um ponteiro -
debaixo do capô é um endereço.
Mas é apenas apontando para o primeiro byte na
string que foi retornado.
>> Se eu voltar agora para o código aqui, o que está acontecendo nessa linha?
Bem, nessa linha destaque agora, Estou declarando aparentemente outro
variável chamada t.
Mas também é um ponteiro, então eu vou desenhá-lo como, em teoria, a exacta
mesma caixa de tamanho.
E eu vou chamá-lo de t.
>> E agora se voltar para o código novamente, quando eu armazenar está dentro de t,
o que eu sou tecnicamente colocando dentro de t?
Bem, tecnicamente, este foi o número 123.
Então, realmente eu deveria estar escrevendo o número 123 existe.
Mas vamos levá-lo de nível superior.
t, se é apenas um ponteiro, intuitivamente, é só isso.
Isso é tudo o que está sendo aí armazenados.
>> Então, agora nas últimas linhas interessantes de código, quando eu realmente ir sobre
capitalizando o zero em t, o que está acontecendo?
Bem, t faixa de zero agora está apontando para o personagem, presumivelmente?
>> Ele está apontando para h.
Porque t faixa de zero -
lembro, esta é velha sintaxe. t suporte de zero significa apenas que se t é uma string, t
faixa de zero significa obter o zero personagem em que a força.
Então, o que realmente significa é ir a essa matriz -
e sim, isso pode ser 123, isto pode ser 124.
Mas é tudo relativo, lembre-se.
Sempre falando de uma matriz, temos a vantagem de falar
índices relativos.
>> E agora, podemos apenas supor que t suporte zero é h.
Então, se eu chamar 2 superior sobre ele, o que é fazendo realmente está capitalizando
o h minúsculas para maiúsculas H. Mas, claro, o que é s?
Ele está apontando para a mesma seqüência danado.
>> Então, isso é tudo o que está acontecendo neste código até o momento.
Então, qual é então a implicação?
Como é que vamos corrigir esses dois problemas?
Como podemos comparar com cordas reais?
>> Bem, intuitivamente, como é que você vai sobre a comparação de dois
cordas para a verdadeira igualdade?
>> O que significa se dois strings são iguais?
É claro que não são os seus endereços igual na memória, porque isso é um baixo
detalhe de implementação nível.
Todos os caracteres são idênticos.
Então deixe-me propor, e deixe-me apresentar na versão de um compare.c
aqui, então comparar-1.c.
>> Deixe-me propor que nós ainda obter um ponteiro chamado s, e uma loja em que o
retornar o valor de seqüência de get.
Vamos fazer a mesma coisa com t.
Assim, a parte do código é diferente.
Eu estou indo para adicionar um pouco mais a verificação de erros agora.
Então, agora que estamos espécie de descamação de volta este camadas CS50 do que uma string
realmente é, precisamos ser mais anal sobre certificando-se de não abusar
valores inválidos como nulos.
>> Então, eu só vou verificar.
Se s não é igual a nulo e t não igual nulo, isso significa que estamos OK.
Seja corda não estragar ficando qualquer uma dessas cordas.
E você pode, talvez, acho que agora, o que não STR CMP presumivelmente fazer?
String de comparação.
>> Portanto, se você programa em java antes, isto é como o método equals no
classe string.
Mas para aqueles de vocês que não têm programado antes,
esta é apenas uma função c.
Acontece a entrar em uma arquivo chamado string.h.
É aí que ele é declarado.
>> E corda comparar -
Eu realmente esquecer seu uso, mas não importa.
Lembre-se que nós podemos fazer homem, mexa comparar.
E isso vai trazer o Manual de programadores Linux.
E é, francamente, um pouco enigmática.
Mas eu posso ver que aqui, sim.
Eu tenho que incluir string.h.
>> E diz aqui em descrição, "o função de comparação compara cadeia
as duas seqüências S1 e S2. "E S1 e S2 são, aparentemente, os dois
argumentos passados ​​dentro
Eu realmente não lembro o que const é, mas agora percebe -
e você pode ter visto isso já quando você usar as páginas do manual, se você
ter tudo -
aquela estrela char é apenas sinónimo com string.
>> Então, ele compara as duas cordas, S1 e S2, e retorna um inteiro menor
que ou igual a ou maior do que zero S1 se encontra, respectivamente, para ser
inferiores ou iguais, ou ser maior que S2.
Isso é apenas uma maneira muito complexa de dizer essa seqüência comparar retornos
zero se duas strings são intuitivamente idênticas, personagem de
personagem para personagem.
>> Ele retorna um número negativo se s, por ordem alfabética, é suposto
para vir antes de t.
Ou retorna um número positivo se s deve vir depois de t
em ordem alfabética.
Assim, com esta função simples, poderia você, por exemplo, classificar uma
todo monte de palavras?
>> Assim, nesta nova versão, eu vou para ir em frente e fazer compare1.
Dot barra comparar um.
Eu vou digitar Olá em todas as letras minúsculas.
Vou digitar Olá em todas as letras minúsculas novamente.
E felizmente agora percebe Eu digitei a mesma coisa.
>> Enquanto isso, se eu digitar Olá em baixa OLÁ caso e em letras maiúsculas e
compará-los, eu digitei coisas diferentes.
Porque não são apenas os endereços diferente, mas estamos comparando
diferentes personagens novamente e novamente.
>> Bem, vamos lá e corrigir um outro problema agora.
Deixe-me abrir uma versão de cópia, que agora dirige
esta questão da seguinte forma.
E este vai ficar um pouco mais complexa.
Mas se você pensar sobre o problema que precisa resolver, espero que este será
claro em apenas um momento agora.
>> Portanto, esta primeira linha, char início t, em termos leigos alguém poderia propor
o que esta linha aqui significa?
Char estrela t, o que é que está fazendo?
>> Bom.
Criar um ponteiro para alguns local de memória.
E deixe-me refiná-lo um pouco.
Declare uma variável que irá armazenar o endereço de algum caractere na memória, apenas
a ser um pouco mais adequada.
>> OK, agora no lado direito, eu tenho nunca vi uma dessas funções
antes, malloc.
Mas o que poderia dizer?
Alocação de memória.
>> Assim, ao que parece, até agora, nós realmente não tinha uma maneira poderosa de
pedindo o sistema operacional, dê-me um pouco de memória.
Em vez disso, agora temos uma função chamada malloc que faz exatamente isso.
Mesmo que isso é um pouco de distração, agora, perceber que em
entre os dois parêntesis está só vai ser um número.
Onde eu digitei em questão as marcas podem ser um número.
>> E esse número significa, dar-me 10 bytes.
Dê-me 20 bytes.
Dê-me 100 bytes.
Malloc e fará o seu melhor para pedir ao sistema operacional -
Linux, neste caso -
hey, são seus 100 bytes de memória RAM disponível?
Se assim for, devolver esses bytes para mim por retornando o endereço de qual
os bytes, talvez?
O próprio primeiro.
>> Portanto, aqui também - e isto é predominante em C, a qualquer hora que você está
lidar com endereços?
Você está quase sempre lidando com o primeiro endereço tal, não importa quão grande
um pedaço de memória que está a ser devolveu, por assim dizer.
>> Então vamos mergulhar aqui.
Estou tentando alocar como muitos bytes, exatamente?
Well.
Comprimento da corda de s - vamos fazer um exemplo concreto.
Se s é Olá, H-E-L-L-O, que é o comprimento da corda de s, obviamente?
Por isso, é de cinco anos.
Mas eu estou fazendo um mais um em que, por quê?
Por que eu quero seis bytes em vez de cinco?
O caráter nulo.
>> Eu não quero deixar de fora esta caractere nulo especial.
Porque se eu fizer uma cópia do Olá e apenas fazer H-E-L-L-O, mas eu não ponho
esse caráter especial, o computador não pode ter, por acaso, uma barra invertida
zerar lá para mim.
E assim, se eu estou tentando descobrir o comprimento da cópia, eu poderia pensar que
é 20 caracteres, ou um milhão caracteres se eu nunca acontecer
para bater um zero barra invertida.
>> Por isso, precisamos de seis bytes para armazenar H-E-L-L-S, invertida zero.
E então este é apenas ser super anal.
Suponha que eu esqueça o que o tamanho de uma char é.
Nós mantemo-nos dizendo que é um byte.
E geralmente é.
Em teoria, poderia ser algo diferentes, em um Mac diferente ou uma
PC diferente.
>> Então não é que há esse operador chamado sizeof que se você passá-lo a
nome de um tipo de dados - como char, ou int ou float -
ele vai lhe dizer, de forma dinâmica, quantos bytes um char ocupa neste
determinado computador.
>> Portanto, esta é efetivamente apenas como vezes um ou dizendo
vezes nada.
Mas eu estou fazendo isso apenas para ser super anal, que apenas no caso de um char diferente
em seu computador contra a minha, desta forma a matemática está sempre indo para check-out.
>> Por fim, aqui eu verifico para nulo, que é sempre uma boa prática - de novo,
qualquer momento que estamos lidando com ponteiros.
Se malloc não foi capaz de dar me seis despedidas - o que é
pouco provável, mas apenas no caso -
retornar um imediatamente.
E agora, vá em frente e copiar a corda como se segue.
E esta é a sintaxe familiar, embora em um papel diferente.
>> Eu estou indo para ir em frente e começar a string comprimento de s e armazená-lo em n.
Estou passando então a iteração de i é igual a zero até e incluindo n,
maior ou igual a.
De modo que em cada iteração, eu coloquei o caráter om de s no om
caráter de t.
>> Então, o que realmente está acontecendo por baixo a capa aqui?
Bem, se este, por exemplo, é s -
e eu digitei a palavra H-E-L-L-O e há um zero barra invertida.
E mais uma vez, esta é s apontando aqui.
E aqui agora é t.
>> E isso está apontando agora para uma cópia de memória, certo?
Malloc me deu um todo pedaço de memória.
Eu não sei o que é, inicialmente, em qualquer um destes locais.
Então, eu vou pensar nisso como um monte de pontos de interrogação.
>> Mas assim que eu começar looping de zero em cima ao longo do comprimento s, t
suporte zero e suporte t 1 -
e eu vou colocar isso agora na sobrecarga -
t suporte zero e s suporte média zero que eu vou estar copiando
iterativamente h aqui, o E-L-L-S. Além disso, porque eu fiz o mais
1, barra invertida zero.
>> Então, agora, no caso de compará-1.c, no final, se eu imprimir o
capitalização de t, devemos ver que s mantém-se inalterado.
Deixe-me ir em frente agora e fazer isso.
Então faça copy1.
Dot barra copy1.
Vou digitar Olá, Enter.
E agora observar, apenas a cópia tem sido capitalizados.
Porque eu realmente tenho dois pedaços de memória.
>> Infelizmente, você pode fazer algum bem coisas ruins e muito perigoso aqui.
Deixe-me puxar para cima um exemplo aqui agora, , que nos dá um exemplo de alguns
linhas diferentes.
Então, só intuitivamente aqui, a primeira linha de código, int x estrela, está declarando
uma variável chamada x.
E qual é o tipo de dados dessa variável?
Qual é o tipo de dados que a variável?
Aquele não era o momento de angústia.
>> O tipo de dados int é estrela.
Então, o que isso significa? x vontade armazenar o endereço de um int.
Simples como isso.
Y vai armazenar o endereço de um int.
O que é a terceira linha do código está fazendo lá?
É atribuição quantos bytes, provavelmente?
Four.
Devido ao tamanho de um int é geralmente quatro, malloc de quatro dá
me fazer o endereço de um pedaço de memória, o primeiro de cujos bytes é
armazenado agora em x.
>> Agora estamos nos movendo um pouco rapidamente.
Estrela x significa o quê?
Isso significa ir para esse endereço e colocar o número de lá?
Coloque o número 42 lá.
Estrela y significa ir para o que está em y e colocar o número 13 lá.
>> Mas espere um minuto.
O que está em y no momento?
O endereço é y armazenamento?
Nós não sabemos, certo?
Nós nunca uma vez usar a atribuição operador envolvendo y.
Então, y, conforme declarado na segunda linha de código é apenas um valor de lixo, um grande
ponto de interrogação, por assim dizer.
Pode-se apontar aleatoriamente a qualquer coisa na memória, que
geralmente é ruim.
>> Assim, logo que batemos essa linha lá, estrela y é igual a 13, algo ruim,
algo muito ruim está acontecer com Binky.
Então vamos ver o que vai acabar acontecendo com Binky aqui neste minuto
ou então procure.
>> [REPRODUÇÃO]
>> -Ei, Binky.
Acordar.
É tempo para se divertir ponteiro.
>> -O que é isso?
Saiba mais sobre ponteiros?
Oh, goodie.
>> -Bem, para começar, eu acho que estamos vai precisar de um par de ponteiros.
>> -OK.
Este código aloca dois ponteiros que pode apontar para números inteiros.
>> -OK, bem, eu vejo os dois ponteiros.
Mas eles não parecem ser apontando para nada.
>> -Isso mesmo.
Inicialmente, os ponteiros não apontar para qualquer coisa.
As coisas que eles apontam são chamados pointees, e configurá-los é uma
etapa separada.
>> -Oh, certo, certo.
Eu sabia disso.
Os pointees são separados.
Assim como você alocar um pointee?
>> -OK.
Bem, este código aloca um novo inteiros pointee, e esta parte define x
para apontar para ele.
>> -Ei, isso parece melhor.
Então ele fazer alguma coisa.
>> -OK.
Vou cancelar o ponteiro x para armazenar o número 42 na sua pointee.
Para este truque, eu vou precisar da minha magia varinha de dereferencing.
>> -Sua varinha mágica de dereferencing?
Uh, isso é ótimo.
>> -Isto é o que o código parece.
Eu só vou definir o número, e -
>> -Ei, olha.
Lá vai ele.
Então, fazendo um desreferenciava em x segue a seta para acessar sua pointee.
Neste caso, 42 para armazenar ali.
Hey, tente usá-lo para armazenar o número 13 através do outro ponteiro, y.
>> -OK.
Eu vou passar por cima aqui para y e se o número 13 configurar.
E, em seguida, tomar a varinha de dereferencing e apenas -
Uau!
>> -Oh, hey.
Isso não funcionou.
Digamos, Binky, eu não acho que o dereferencing y é uma boa idéia,
porque a configuração do pointee é um passo separado.
E eu não acho que nós já fizemos.
>> -Hmm.
Bom ponto.
>> -Sim, alocamos o ponteiro y.
Mas nós nunca configurá-lo para apontar para um pointee.
>> -Hmm.
Muito observador.
>> -Ei, você está olhando bom lá, Binky.
Você pode corrigi-lo, para que y pontos ao mesmo pointee como x?
>> -Claro.
Eu vou usar a minha varinha mágica de atribuição de ponteiro.
>> -Será que vai ser um problema como antes?
>> -No.
Isso não tocar nos pointees.
Ele só muda um ponteiro para apontar a mesma coisa que o outro.
>> -Oh, eu vejo.
Agora y aponta para o mesmo lugar que x.
Então, espere.
Agora y é fixo.
Tem um pointee.
Então, você pode tentar a varinha de dereferencing novamente
para enviar a 13 terminado.
>> -OK.
Aqui vai.
>> -Ei, olha isso.
Agora dereferencing obras sobre y.
E porque os ponteiros estão compartilhando que um pointee, eles
tanto ver o 13.
>> -Sim.
Compartilhando.
Qualquer que seja.
Então vamos trocar de lugar agora?
>> -Oh, olhe.
Estamos sem tempo.
>> -Mas -
>> -Lembre-se de três regras ponteiro.
O número um, a estrutura básica é que você tem um ponteiro.
E aponta mais para um pointee.
Mas o ponteiro e pointee são separados.
E o erro comum é criar um ponteiro, mas a
esquecer de um dado pointee.
>> Número dois, apontador dereferencing começa no ponteiro e segue o seu
seta sobre para acessar sua pointee.
Como todos sabemos, isso só funciona se houver é um pointee, que volta ao
regra número um.
>> Número três, a atribuição de ponteiro leva um ponteiro e muda-lo para apontar para
Nas mesmas pointee como outro ponteiro.
Assim, após a atribuição, os dois ponteiros
apontar para o mesmo pointee.
Às vezes isso é chamado de partilha.
E isso é tudo que existe para ela, realmente.
Bye bye agora.
>> [FIM REPRODUÇÃO DE VÍDEO]
>> DAVID MALAN: So mais sobre ponteiros, mais sobre Binky na próxima semana.
Vemo-nos na segunda-feira.