[MÚSICA, TOCANDO] DAVID MALAN: Tudo bem, esse é o CS50 e esta é a quarta semana. E nas últimas semanas, tivemos uma espécie de treino de iniciação, ao usar esta linguagem conhecida como C. E essas treino de iniciação na forma da biblioteca CS50. E você usa esta biblioteca, é claro, selecionando e incluindo cs50.h sobre o seu código. E então, se você pensar em como o clang funciona, você vinculou seu código via / L CS50. Mas tudo isso foi automatizado para você até agora, usando make. Hoje, faremos a transição do foco da semana passada em algoritmos para
focar um pouco mais nas máquinas e nas máquinas que agora usamos para implementar esses algoritmos ainda mais poderosamente, quando começamos a tirar essas treino de iniciação e vemos o que está acontecendo por baixo do capô do seu computador. E por mais complicado que alguns aspectos do C tenham sido, já que a programação, pode ser algo novo para você, perceba que não há tanta coisa acontecendo debaixo do capô que precisamos entender para seguir em frente e começar a resolver muito mais interessantes, mais sofisticados e mais problemas divertidos. Precisamos apenas de alguns blocos de construção adicionais. E
hoje, vamos fazer isso, primeiro, reaprendendo a contar. Aqui, por exemplo, está o que chamaremos de memória do computador. E já vimos essa grade antes. E podemos numerar as chamadas de todos bytes na memória do seu computador. Podemos chamar esse byte de número 0, 1, 2, 3, 4, até o byte 15, e assim por diante. Mas acontece que, ao falar sobre as memórias dos computadores, computadores e cientistas da computação e programadores na verdade, não tendem a usar decimais. Eles definitivamente não tendem a usar binários nesse baixo nível. Em vez disso, eles tendem a usar, por convenção,
algo chamado hexadecimal. Hexadecimal é um sistema de base diferente que, em vez de usar 10 ou 2 dígitos, usa 16. E então um cientista da computação, quando numerar coisas como bytes em uma memória de computador, ainda faria 0, 1, 2, 3, 4, 5, 6, 7, 8, 9. Mas depois disso, em vez de prosseguir com o decimal para, digamos, 10, 11, 12, 13, 14, 15, em vez disso, convencionalmente, começaria a usar algumas letras do alfabeto. E assim, em hexadecimal, este sistema de base diferente de base 16, você começa a contar em 0 ainda. Você conta até
e até 9. Mas quando você quiser continuar contando mais alto, você então vai para A, B, C, D, E e F. E a vantagem disso é que, dentro de hexadecimal - e esse hex implica 16 - você tem 16 dígitos individuais totais, 0 a 9, e também agora, A a F. Portanto, não precisamos introduzir segundos dígitos apenas para contar até 16. Podemos usar dígitos individuais de 0 a F. E podemos continuar contando usando vários dígitos hexadecimais. Mas para chegar lá, vamos introduzir esse vocabulário. Então, em binário, é claro, usamos 0's e 1's. Em decimal, é
claro, usamos 0 a 9's. E em hexadecimal, para ser claro, vamos usar de 0 a F's, conhecido como base-16. E é uma convenção que usamos de A a F. Nós poderíamos ter usado quaisquer outros seis símbolos. Mas isso é o que os humanos escolheram. Portanto, o hexadecimal funciona de maneira bastante semelhante ao nosso sistema decimal. E é até familiar, agora, com o que você conhece como sistema binário, como segue. Vamos considerar um valor de dois dígitos usando hexadecimal em vez de decimal e em vez de binário. Bem, assim como no mundo decimal, usamos a base
10, ou no mundo do binário, usamos a base 2. Vamos usar, agora, base-16, logo, hexadecimal. Portanto, este é 16 na 1. Isso é 16 para o - desculpe 16 elevado a 0. Este é 16 na 1. E, claro, se multiplicarmos isso, é a coluna de uns e agora a 16ª coluna. E então, se você quiser contar em hexadecimal, você ainda começa com 0, como de costume, então 01, 02, 03, 04, 05, 06, 07, 08, 09. E então as coisas ficam interessantes. Agora, você não vai eleva a 01, porque isso seria incorreto. 01, neste sistema básico,
seria 16 vezes 1 mais 1 vez 0. Não é isso que queremos. Depois que o número que sabemos ser 9, agora contamos até A, B, C, D, E, F. E agora, as coisas ficam interessantes de novo. Mas, assim como no sistema decimal, quando você conta até 99, você tem que começar a carregar o 1, a mesma coisa aqui. Se você quiser contar além de F, carregue o 1. E agora, para representar um valor maior que F, usamos 01, que parece 10, mas não é 10. Em hexadecimal, é 01. 16 vezes 1 nos dá 16. 1
vez 0 nos dá 0. E, claro, isso nos dá o número decimal que agora sabemos que é 16. Portanto, não vamos mais introduzir mais e mais sistemas básicos. Mas deixe-me estipular que apenas usando essas colunas que você aprendeu na escola primária, provavelmente, você pode implementar qualquer sistema básico agora. Acontece que, no mundo dos computadores, E hoje no mundo da memória, e em breve, também arquivos, vai ser muito convencional ser capaz de reconhecer e usar hexadecimal. E, há uma razão pela qual os humanos gostam de hexadecimais, ou pelo menos alguns humanos. Os cientistas da computação lembram
que se contarmos até FF, neste caso, ainda faríamos a mesma matemática. Então, 16 vezes 15 mais 1 vez 15 vai nos dar, isso, ou, claro, 240 mais 15 ou 255. E eu fiz isso muito rapidamente. Mas esse é o tipo de matemática do ensino fundamental de multiplicação a coluna pelo valor que está nela, onde novamente, Cada um desses Fs é como agora expressamos 15 usando um único dígito. Mas lembre-se de que vimos 255 antes. Quando falamos sobre binário há algumas semanas, 255 também passou a ser o padrão que vemos aqui, oito bits 1 usando binário.
E então, a razão pela qual os cientistas da computação tendem ao hexadecimal, é que, em oito bits, há dois pares aqui, como quatro à esquerda, quatro à direita. Se dermos um jeito nessas coisas, acontece que, porque hexadecimal permite a você representar 16 valores possíveis, é um sistema perfeito para representar quatro bits por vez. Afinal, se você tem quatro bits aqui, cada um dos quais pode ser 0 ou 1, Ou seja, 2 vezes 2 vezes 2 vezes 2 valores possíveis para cada um deles, ou 16 valores totais, ou seja, no mundo dos computadores, se você quiser
falar em unidades de quatro bits, é conveniente usar hexadecimal em vez disso, apenas porque, convenientemente, um dígito hexadecimal passa a ser equivalente a quatro dígitos binários, 0's e 1's. Portanto, 0, 0, 0, 0, todo o caminho até 1, 1, 1, 1. Então, por que os humanos fazem isso? Só agora é a convenção humana por causa dessa conveniência. Agora, alguns de vocês podem muito bem ter visto hexadecimal antes. Na verdade, lembre-se de nossa discussão na semana 0 de RGB, onde discutimos a representação de cores usando Alguma quantidade de vermelho, verde e azul. E na época, usamos
este exemplo. Pegamos nosso exemplo fora do contexto. E em vez de usar oi como uma string de texto, reinterpretamos 72, 73 e 33 como uma sequência de cores. Quanto vermelho você quer? Quanto verde você quer? Quanto azul você quer? E isso é bom. É perfeitamente normal pensar e se expressar em termos decimais. Mas os cientistas da computação tendem a não fazer dessa forma no contexto das cores e no contexto da memória. Em vez disso, eles tendem a usar algo chamado hexadecimal. E hexadecimal, aqui, seria apenas mudar esses valores de 72, 73, 33, para o hexadecimal
equivalente em representação. E não vamos nos incomodar em fazer as contas aqui. Mas deixe-me estipular que 72, 73, 33 em decimal é a mesma coisa que 48, 49, 21 em hexadecimal. Agora, obviamente, se você olhar para esses três números, não é nada óbvio se você está olhando para dígitos hexadecimais ou dígitos decimais, porque eles usam o mesmo subconjunto, de 0 a 9. E então uma convenção também, no mundo do Computação, é que sempre que você representa dígitos hexadecimais, Você tende a prefixá-los, porque sim, com 0x. E não há significado matemático para 0 ou x. É
apenas um prefixo que você coloca lá para deixar claro para o visualizador que esses são dígitos hexadecimais, mesmo se pudessem de outra forma parecer dígitos decimais. Então, aonde vamos com isso? Bem, aqueles de vocês que podem ter experimentado no passado, criando suas próprias páginas da web e tornando-as coloridas, ou aqueles de vocês que são artistas e usaram programas como o Photoshop, você já viu esses códigos antes. Na verdade, aqui estão algumas capturas de tela do próprio Photoshop. Se você clicar em uma cor no Photoshop e abrir esta janela, Você pode mudar a cor que está
desenhando na tela qualquer uma das cores do arco-íris. Mas de forma mais precisa, se você olhar aqui embaixo, você pode ver esses códigos hexadecimais, porque se tornou uma convenção humana ao longo dos anos usar hexadecimal para representar diferentes quantidades de vermelho, verde, e azul. Então, se você não tem vermelho, verde, azul, representado como 000000, bem, isso vai lhe dar a cor que conhecemos aqui como preto. É uma espécie de ausência de qualquer comprimento de onda de luz ali. Se, por outro lado, você alterar todos esses seis dígitos para o maior valor possível, que, novamente, é
F. O intervalo em hexadecimal 0 A F, em decimal, sendo 0 a 15, bem, com FFFFFF, é muito vermelho, muito verde, muito azul. E quando você combina esses comprimentos de onda de luz, você obtém a cor que vemos aqui como branco. E você pode imaginar, agora, combinando diferentes quantidades de vermelho, verde ou azul. Então, por exemplo, em hexadecimal, FF0000, é a cor que conhecemos como vermelho. 00FF00 é a cor que conhecemos como verde. E, finalmente, 0000FF é a cor que conhecemos como azul, porque, novamente, o sistema que os programadores e artistas frequentemente, mas nem sempre
usam, é de fato, este sistema de RGB para vermelho, verde e azul. Então, nós introduzimos isso aqui não porque você Tem que começar a pensar de forma diferente, porque, novamente, o mecanismo matemático é o mesmo da semana 0. Mas você vai começar a ver números em exemplos, em programas, como apenas aparecendo em hexadecimal por convenção, em oposição a sendo interpretado como decimal. Então, se considerarmos, agora, a memória do nosso computador, vamos agora começar a pensar em toda essa tela de memória, todos esses bytes dentro da memória do nosso computador, como sendo inumeráveis como 0, 1,
2, até F. E então, se continuarmos contando, podemos ir para 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 1A, 1B, 1C, 1D e assim por diante. E tudo bem se não for tão óbvio, Quando você olha para essas coisas, quais são os equivalentes decimais. Isso não é um problema. É apenas uma maneira diferente de pensar sobre os locais, neste caso, da memória de um computador, ou a representação de uma cor ou outra. Tudo bem, vamos agora usar isso como um exemplo de oportunidade, em vez disso, considerar o que está sendo armazenado na memória
do nosso computador. E para ser claro, vou começar a prefixar todos esses endereços de memória, por assim dizer, com 0x, apenas para deixar claro que agora estamos falando, em termos de 0's e 1's. Portanto, aqui está uma linha de código simples. Fora do contexto, precisaríamos, na verdade, colocar isso no main ou algum outro programa para fazer qualquer coisa com ele. Mas já vimos isso muitas vezes, agora, onde você declara uma variável, por exemplo, n para número. Declare-o como um int para seu tipo. E então, talvez, até mesmo atribua um valor a ele. Bem, o que
está acontecendo quando usamos esse tipo de código em nosso computador? Bem, vamos prosseguir e transformar isso em um programa real. Vamos criar um arquivo chamado address.c porque eu deseja começar a experimentar alguns endereços na memória do computador. Vou prosseguir e incluir o padrão io ponto h. Vou criar int main void. E aqui embaixo, vou prosseguir e declarar exatamente essa variável, int n é igual a 50. E então vou prosseguir e imprimir, com percentual i e uma \ 0, o valor de n. Então nada de interessante aí, nada muito complicado. Vou seguir em frente e make
address. E então vou prosseguir e fazer ./ address. E, claro, como na primeira semana, devemos esperar apenas o número 50. Mas hoje, vamos lhe dar mais algumas ferramentas com as quais você pode vasculhar a memória do seu computador. Mas vamos primeiro considerar esta linha de código no contexto do hardware do seu computador. Então, se você estiver escrevendo um programa com uma linha de código como esta, Que n precisa estar em algum lugar na memória do seu computador. Esse 50 precisa ser colocado em algum lugar na memória do seu computador. Então, se nós, novamente, considerarmos que
isso seja apenas parte da memória, algumas dezenas de bytes, bem, suponha que essa variável, n, acaba aqui embaixo. Eu desenhei deliberadamente n ocupando quatro bytes, quatro quadrados, porque nós chamamos a isso de um número inteiro, normalmente, pelo menos em CS50 IDE e sistemas modernos, tende a ter quatro bytes. Então, fiz questão de preencher quatro caixas completas. E então o valor pode ser 50 que está armazenado lá. Bem, acontece que na memória do seu computador, novamente, existem esses endereços que estão implicitamente lá. Portanto, embora, sim, podemos nos referir a esta variável, n, com base no nome
da variável que dei em meu código, certamente essa variável existe em um local específico na memória. Não sei de imediato onde está. Mas deixe-me apenas propor que talvez esteja na localização 0x12345678, apenas um endereço arbitrário. Não tenho ideia, na verdade, de onde está. Mas certamente tem um endereço, porque cada um desses quadrados dentro da memória do seu computador tem um endereço, um identificador único como 0, 1, 2, e assim por diante. Talvez o 50 tenha terminado no endereço de memória 0x12345678. Bem, isso é o legal sobre C, é que podemos começar a ver isso, Sem
trocadilhos. Então, deixe-me ir em frente e modificar este programa e introduzir um pouco de nova sintaxe que nos permitirá começar a vasculhar o interior da memória do seu computador para que possamos ver o que está acontecendo por baixo. Portanto, vou prosseguir e alterar este programa para fazer isso. Vou prosseguir e dizer, quer saber? Não imprima apenas o valor, n, que, claro, é 50. Vamos ver, apenas por curiosidade, qual é o endereço real de n. E para fazer isso hoje, vamos apresentar uma nova parte da sintaxe, que por acaso é esta aqui. Existem dois novos operadores,
hoje, em C. O primeiro é um & - &, que Não representa um e lógico. Lembre-se de algumas semanas atrás, vimos que se você deseja combinar expressões booleanas, isso e aquilo, você usa dois & - &&. É uma coincidência infeliz que um & comercial, sozinho, significará algo diferente hoje. Especificamente, esse & será nosso endereço do operador. Simplesmente prefixando qualquer nome de variável com um &, podemos dizer ao C, diga-me em que endereço esta variável está armazenada. E esta asterisco, não deve ser confundida com multiplicação, também tem outro significado no contexto atual. Quando você usa este
asterisco, você pode dizer ao seu programa para olhar dentro de um endereço de memória específico. Portanto, o & informa em que endereço está uma variável. O operador asterisco, também conhecido como operador de desreferência, significa, vá para o seguinte endereço. Então, meio que são operações reversas. Descobre-se o endereço. Um vai para o endereço. E então vamos ver isso de verdade aqui. Vamos prosseguir e alterar meu n em meu programa aqui para & n. Então, eu quero imprimir, não o número em n, mas o endereço de n. E agora, como imprimo um endereço? Bem, é um número.
Mas, na verdade, printf suporta um código de formato diferente para endereços. Você pode fazer % p, por razões que veremos em breve, que diz para imprimir o endereço desta variável e interpretá-lo como hexadecimal, novamente, por convenção. Vou prosseguir e make address now depois de fazer apenas duas alterações neste arquivo. Tudo parece compilar bem. Agora, vou prosseguir e executar o endereço. E veremos que, neste programa específico, address.c, por qualquer motivo, essa variável, n, acabou na localização maluca 0x7ffd80792f7c. Agora, isso é útil? Não na prática. Faremos com que isso se torne útil aproveitando esses endereços. Mas o
endereço específico não é interessante. Estou olhando para este número. Não tenho ideia do que é esse número em decimal. Eu teria que fazer as contas ou apenas pesquisar um conversor no Google fazendo isso por mim. Então, novamente, essa não é a parte interessante. O fato de estar em hexadecimal é apenas um detalhe de implementação. Acontece que representa a localização desta variável. E, novamente, não queremos fazer isso. Mas só para deixar claro que um desses operadores, o & obtém o endereço. E o operador asterisco vai para um endereço. Podemos desfazer os efeitos dessas coisas. Por exemplo,
se eu imprimir agora, não e comercial n, mas apenas por curiosidade, asterisco & n, posso desfazer os efeitos desse operador. & n dirá, qual é o endereço de n? & asterisco n vai dizer, vá para esse endereço. Portanto, este é um exercício meio inútil, porque se eu só quero o que está em n, Eu posso, obviamente, imprimir n como começamos. Mas, novamente, apenas como um exercício intelectual, se eu prefixo n com o endereço do operador e, em seguida, uso o asterisco e digo, vá para aquele endereço, é exatamente a mesma coisa como apenas imprimir n
em si. Então, deixe-me mudar de volta para um inteiro. Em vez de % p, deixe-me ir em frente e make address now, parece compilar OK e executar o endereço. E pronto, estamos de volta aos 50. Por mais estranha que a sintaxe de hoje possa começar a parecer, perceber que esses operadores, afinal, são relativamente simples no que fazem. E se você entender que um meio que desfaz os efeitos do outro, podemos começar a construir alguns programas bastante interessantes com eles. E faremos isso aproveitando um tipo especial de variável, uma variável chamada ponteiro. E existe aquele p
em % p. Um ponteiro é uma variável que contém o endereço de algum outro valor. Então, já vimos números inteiros antes. Vimos floats, chars, strings e outros tipos também. Ponteiros, agora, são apenas um tipo diferente de variável que armazenam o endereço de algum valor. E você pode ter ponteiros para inteiros, ponteiros para chars, ponteiros para booleanos, ou qualquer outro tipo de dados. Um ponteiro faz referência ao tipo específico do valor a que se refere. Então, vamos ver isso mais concretamente. voltando, agora, ao meu programa aqui. E deixe-me apresentar outra variável aqui. Em vez de imprimir
imediatamente algo como n, deixe-me prosseguir e introduzir uma segunda variável do tipo int asterisco. E isso, devo admitir, é provavelmente a parte mais confusa da sintaxe C que iremos, em geral, ver, só porque, meu Deus, asterisco é agora usado para multiplicação, para ir para um endereço, e também, agora, declarar uma variável. Esta não é, sem dúvida, a melhor decisão de design. Mas foi feito há décadas. Então é isso que temos. Mas se eu fizer int asterisco p é igual a e comercial n, agora, o que posso fazer aqui, é imprimir o endereço de n armazenando-o
temporariamente em uma variável. Portanto, não estou fazendo nada novo ainda. Ainda estou declarando na linha 5, um inteiro chamado n, atribuindo no valor 50. O que há de novo agora na linha 6 é que estou introduzindo um novo tipo de variável. Esse tipo de variável é conhecida como ponteiro. Um ponteiro, novamente, é uma variável que armazena o endereço de algum valor. E a sintaxe, reconhecidamente estranha, para declarar um ponteiro para um inteiro, é literalmente dizer int, porque esse é o tipo para o qual você está apontando, asterisco e, em seguida, o nome da variável que
deseja criar. E eu poderia chamar isso de qualquer coisa, mas vou chamar de p para mantê-lo sucinto. E, novamente, do lado direito do sinal de igual é o mesmo operador de antes. Se você quiser descobrir qual é o endereço de n, é & n. E para que possamos armazenar esse endereço, agora, em algum lugar de longo prazo. Antes, acabei de passar o & n e printf fez o que costuma fazer. Agora, estou temporariamente, na linha 6, armazenando esse endereço em uma nova variável chamada p. E seu tipo é tecnicamente int asterisco, é o que um
programador diria. Portanto, seria incorreto dizer que int p é igual a & n. E, nosso compilador, Clang, não vai gostar disso. Provavelmente, não permitirá que você compile o código. E então, em vez disso, pretendo deixar claro que sei o que estou fazendo. Estou armazenando o endereço de um int, não de um inteiro, por assim dizer. Então, se eu for em frente agora e salvar isso, recompilar com make address. E observe, eu mudei uma linha do código 2 antes. Voltei para a % p para imprimir um ponteiro que é um endereço. E estou apontando o valor
de p, não mais o valor de n. Se eu agora executar o endereço de barra pontilhada, voila, há aquele endereço enigmático. E esses endereços podem muito bem mudar com o tempo. Dependendo do que está acontecendo dentro do seu programa ou outras coisas no sistema, esses endereços podem ser diferentes a cada vez. E isso é esperado e não algo em que se possa confiar. Mas é claramente algum endereço criptográfico aleatório, semelhante ao meu arbitrário 0x12345678 antes. Mas agora, vamos apenas desfazer esta operação. Só para que possamos fechar o círculo aqui, deixe-me propor como posso imprimir o
valor de n. E deixe-me chamar alguém para isso, se puder. Se meu objetivo, agora, na linha 7, não é mais imprimir o endereço de n, mas imprimir o próprio n usando p. Vou seguir em frente e mudar, preventivamente, o código de formato em % i. E uma notação abreviada seria, obviamente, basta imprimir n. Mas suponha que eu não queira imprimir n para este exercício, como posso agora imprimir o valor em n referindo-me a ele por meio de p? O que devo digitar literalmente como o segundo argumento de printf para imprimir o valor de n usando
esta nova variável, p, de alguma forma. Sim, vamos chamar Joshua. PÚBLICO: Eu acredito, se você usar o & antes do p, Provavelmente fará isso. DAVID MALAN: OK, & p, agora eu vou tentar isso. Vamos tentar & p para imprimir esse valor. Portanto, & p, salvarei o arquivo. Vou make address e entrar. E não parece ser o caso. Observe que estou recebendo um erro. É um pouco enigmático. O formato especifica o tipo int, mas o argumento tem o tipo int asterisco asterisco, Mais disso em outro momento. Acontece que isso estava incorreto. Vamos dar uma outra sugestão,
porque o &, lembre-se, Obtém o endereço de algo. Mas p já é um endereço. Joshua, o que você propôs tecnicamente, foi me dar o endereço do endereço. E essa não é a direção que queremos ir. Queremos ir para o que está naquele endereço. Sofia, o que você acha? PÚBLICO: Queremos adicionar um % - ou um asterisco p quando o imprimimos. DAVID MALAN: Sim. Então eu tive um pouco de dificuldade em ouvir você. Mas acho que, se não usarmos o operador &, Mas o operador asterisco, isso vai ser, na verdade, o operador de desreferência, o que
significa , vá para o valor em p. E se o valor em p for um endereço, eu acho, vamos tentar fazer isso, make address. Sim, isso compilou OK desta vez. Agora, se eu fizer um ponto e barra de endereço, espero que eu veja agora o número 50. Portanto, novamente, não parecemos ter feito nenhum progresso fundamental. no fim das contas, ainda estou imprimindo o valor de n. Mas apresentamos este novo primitivo, esta nova peça do quebra-cabeça, se assim preferir, isso permite que você, programaticamente, descubra o endereço de algo na memória do computador E vá para esse
endereço. E logo vamos exercitar um controle mais sofisticado. Mas vamos voltar a uma representação disto e considere o que acabamos de fazer no contexto, agora, deste código. Então, dentro do meu main, as duas linhas interessantes de código, essas duas linhas eram as primeiras, antes de adicionarmos a sugestão da Sofia, desreferenciando p e imprimindo com printf. Mas vamos considerar, por um momento, quais são esses valores agora que parecem na memória de um computador. E, novamente, a sintaxe é um pouco enigmática porque agora temos uma asterisco e um &. Mas, novamente, isso significa apenas, agora, vamos começar
a pensar Em termos de memória do computador. Por exemplo, aqui está uma grade de memória dentro do meu computador. E talvez, por exemplo, o 50 e o n acabam lá embaixo. Eles podem acabar em qualquer lugar, nem mesmo retratados na tela aqui. Eles acabam em algum lugar na memória do computador, para nossos propósitos até agora. Mas tecnicamente estão em um endereço. E deixe-me simplificar o endereço para que seja mais rápido de dizer. Este 50, agora, armazenado na variável n, talvez ele esteja no endereço 0x123. Não tenho ideia de onde está, mas claramente visto que ele
pode estar em um endereço aparentemente aleatório como aquele. Agora, que tal p? P é tecnicamente uma variável em si. É uma variável que armazena o endereço de outra coisa. Mas ainda é uma variável, o que significa que, quando você declara p com o código anterior, ele ocupa alguns bytes de memória na tela. E então agora eu vou propor que p acabe na memória aqui. Agora, p é deliberadamente desenhado para ser mais longo aqui. Estou consumindo oito bytes no total desta vez, porque, ao que parece, em sistemas de computador modernos, incluindo CS50 IDE, os ponteiros tendem
a ocupar oito bytes. Portanto, não um, não quatro, mas oito bytes, então eu simplesmente desenhei para ser maior. Então, o que é armazenado na variável p? Bem, acontece que, novamente, está apenas armazenando o endereço de algum valor. Portanto, se o inteiro n, que por si só está armazenando 50, estiver na localização 0x123, e o ponteiro p está sendo atribuído a esse endereço, é como dizer, bem, armazenado nesta variável p, é literalmente apenas um número representado aqui em notação hexadecimal, 0x123. Então isso é tudo o que está acontecendo dentro da memória do computador com essas duas
linhas de código. Não há nada fundamentalmente novo, exceto o fato que temos uma nova sintaxe para nos referirmos a esses endereços explicitamente. Este é o n aqui embaixo. Este é o p aqui em cima. E o valor de p simplesmente é um endereço. Agora, eu continuo dizendo que esses endereços são um pouco enigmáticos. Eles são um pouco arbitrários. E são. E honestamente, raramente, ou nunca, vai ser esclarecedor saber, como um humano, em que endereço este inteiro n está. Quem se importa se está em 0x123 ou 0x456? Geralmente, não. E então os cientistas da computação, ao
falar sobre a memória dos computadores, tendem a não falar nesses detalhes de baixo nível, em termos de números reais. Em vez disso, eles tendem a simplificar a imagem, tipo de abstração de todas as outras memórias, o que francamente, não é relevante para a discussão até agora, e apenas Quer saber, eu sei que p está armazenando um endereço. E esse endereço é o de 50 aqui embaixo. Mas eu não me importo, na minha vida diária de programação, quais são esses endereços específicos. E sabe do que mais? Vamos abstrair isso rapidamente. E, novamente, abstração é simplificar os
detalhes de nível inferior que você pode muito bem precisar entender, mas não necessariamente precisa continuar pensando. Você não precisa ficar pensando neste nível. Basta pensar neste nível. Então, podemos também desenhar um ponteiro, Como apontando para algum valor e independentemente de qual o endereço real é. E esse é o caso em nosso mundo humano. Temos convenções muito semelhantes, seja ou não óbvio à primeira vista, tal que podemos muito bem estar usando esses mesmos mecanismos em nossa vida cotidiana. Por exemplo, se acontecer de você ter uma caixa de correio na rua de sua casa ou no porão
de Harvard, no Centro de Ciências, pode muito bem se parecer com algo assim, pelo menos mais residencial. E suponha que esta caixa de correio aqui esteja representando, neste caso, p, nessa história. É armazenar um ponteiro, ou seja, o endereço de outra coisa. Bem, se houver um monte de outras caixas de correio na rua, bem, podemos colocar o que quisermos nessas caixas de correio. Podemos colocar cartões postais, cartas, até pacotes. E assim como no mundo real, podemos fazer o mesmo no virtual. Posso armazenar caracteres ou inteiros ou outras coisas, incluindo endereços. Brian, por exemplo, acho que
você tem sua própria caixa de correio em outro lugar. E Brian, é claro, tem uma caixa de correio que tem um endereço exclusivo. Brian, por exemplo, o que é o endereço único da caixa de correio da sua rua aí? BRIAN: Sim, então aqui está minha caixa de correio. É rotulada como n. E seu endereço está aqui. O endereço da minha caixa de correio parece ser 0x123. DAVID MALAN: Sim, minha caixa de correio também tem um endereço. Francamente, novamente, eu não me importo com isso. Então eu nem mesmo coloquei na caixa de correio aqui. Mas se
minha caixa de correio representa p, um ponteiro e a caixa de correio de Brian representa n, um inteiro, bem, deveria significa que se eu olhar dentro do conteúdo do meu ponteiro e vejo o valor 0x123, essa agora é minha pista, uma espécie de migalha de pão, que agora me permite dar uma olhada na caixa de correio de Brian. E Brian, se você não se importasse de fazer isso por nós, o que você tem nesse endereço? BRIAN: E se eu olhar em minha caixa de correio no endereço 0x123, Tenho o número 50 dentro desta caixa de
correio. DAVID MALAN: Sim. Portanto, neste caso, ele está armazenando um int. Mas pode ser qualquer outra coisa. E, novamente, normalmente não nos importamos com esses endereços específicos. Depois de entender a metáfora, podemos fazer algo bobo e pensar nessa caixa de correio como armazenando um valor que está apontando para a caixa de correio de Brian. É algum tipo de direção desenhada lá, como uma seta, aqui como um dedo de espuma bobo. Ou, se preferir, um dedo da Yale, feito de espuma, apontando para a caixa de correio de Brian, apenas como uma espécie de trilha de navegação
que nos leva a algum outro valor na tela. Então, quando falamos hoje e além sobre endereços, é nisso que falamos. Nós, humanos, no mundo real, temos usado endereços por eras, agora, para identificar com exclusividade nossas casas ou empresas ou semelhantes. Os computadores fazem exatamente a mesma coisa em um nível inferior usando a memória do computador. Vou fazer uma pausa aqui para ver se há alguma dúvida sobre ponteiros, variáveis que armazenam endereços, ou nessas novos operadores, como o & ou o asterisco, que agora tem um novo significado. Nada ainda. Tudo bem, vamos considerar agora, A mesma
história no contexto de um tipo de dados completamente diferente. Até agora, jogamos apenas com ints. Mas considere strings. Gastamos muito tempo com strings, usando criptografia com elas e resolvendo a implementação de algoritmos eleitorais usando a entrada do usuário. Então, vamos considerar um dado fundamentalmente diferente que armazena, não inteiros individuais, mas strings de texto. Então, por exemplo, em qualquer programa envolvendo uma string, você pode ter uma linha de código semelhante a esta. string s é igual a, aspas "HI!" em maiúsculas com um ponto de exclamação. Portanto, essa pode muito bem ser uma linha de código que
vimos até agora. O que está acontecendo dentro da memória do computador? Bem, deixe-me sugerir que, quando você digitar "HI!" em um computador, ele acaba em algum lugar na memória do seu computador. Então, HI!, mais, como vimos semana passada, uma \ 0-- ou duas semanas atrás, uma \ 0, que é como um computador representa o final dessa string. Mas vamos olhar um pouco mais cuidadosamente o que está acontecendo debaixo deste capô aqui. Tecnicamente falando, eu poderia abordar esses caracteres individuais como vimos a partir da segunda semana, usando a notação de colchetes como o colchete 0, s
colchete 1, s colchete 2 e s colchete 3 Usamos a notação de colchetes para tratar uma string como se fosse um array de caracteres. E é, foi e ainda é. Mas acontece que as strings também podem ser manipuladas por meio de seus endereços também. E então, por exemplo, talvez esta mesma string exata, HI, armazenada no endereço de memória 0x123 e então 0x124, 0x125 e 0x126. Observe que são deliberadamente contíguos os endereços, de ponta a ponta. E estão separados por apenas um byte, porque cada um desses chars, é claro, são apenas um byte em C. Portanto,
esses números não são importantes, especificamente. Mas o fato de eles estarem separados um do outro é importante, porque essa é a definição de uma string, E, um array, ter memória consecutiva. Agora, o que exatamente é S? S era o nome da variável que dei um momento atrás para ir para essa linha de código, string S igual "HI." bem, o que é S? S é uma variável que precisa ir para algum lugar na memória do computador. E suponha que S seja, HI com um ponto de exclamação. E acontece que o HI fica neste local aqui. Você
sabe o que você pode pensar de S como sendo agora, não é, em um nível alto, uma string, mas em um nível inferior, é o endereço de uma string. Mais especificamente, vamos começar a pensar em uma string Como sendo tecnicamente apenas o endereço do primeiro caractere na string. Agora, isso pode fazer você parar por um momento, por que o primeiro caractere? Como você vai se lembrar disso, espere um minuto, esta string não está apenas em 0x123. Também continua em 0x124, 0x125 e assim por diante. Mas deixe-me fazer uma pausa e perguntar ao grupo aqui, por
que pode muito bem ser suficiente para um computador e nós, programadores, pensemos apenas em strings em termos de ser o endereço do primeiro byte. Tipo, por que é suficiente, não importa quanto tempo a string é, mesmo que seja um parágrafo inteiro de texto, Por que é muito habilmente suficiente pensar em uma string como S como sendo idêntica ao endereço do primeiro byte? Ginni, não é? PÚBLICO: Possivelmente porque acontece que as strings, sempre que estamos definindo uma nova string, isso é tudo. Suponha que, se estou escrevendo meu nome, Ginni, então será G-I-N-N-I. Portanto, será suficiente se
algo for apontado para apenas o primeiro caractere do meu nome, para que eu possa apenas seguir para o primeiro caractere e, em seguida, obter todos os caracteres. DAVID MALAN: Perfeito. Todas essas definições básicas que tivemos nas últimas semanas agora se juntaram. Se uma string é um array de caracteres - e por definição de array, esses caracteres estão de ponta a ponta e, duas semanas atrás, cada string termina com este caractere de barra invertida convencional zero ou nulo. Tudo o que você precisa fazer ao pensar em uma string é saber onde a string começa, porque você
pode usar um loop for ou um loop while ou alguma outra heurística com uma condição e uma expressão booleana para descobrir onde a string termina, mesmo sem saber, antecipadamente, seu comprimento. Quer dizer, vamos começar, por enquanto, pensando em strings como sendo simplesmente Apenas o endereço do primeiro caractere na string. E se tomarmos isso como um fato, vamos em frente, agora, e começar a brincar com um programa que não usa números inteiros, mas em vez disso, strings usadas, usando este primitivo básico. Então, agora eu vou deletar o código que escrevi antes, um adddress.c. Vou mudar para
uma string igual a ponto-e-vírgula "HI". E observe, eu não estou digitando manualmente nenhum 0 de \. C faz isso para nós automaticamente. Quando você fecha a aspas, o compilador cuida de adicionar a \ 0 para você. Agora, vou em frente na próxima linha e imprima % s \ vírgula s, Se eu quiser imprimir essa string. Agora, este programa não é mais interessante. Na primeira semana, escrevemos algo como - OK, sim, é interessante porque eu estraguei tudo. Então, cinco erros. Escrevi sete linhas de código e cinco erros. E vamos ver o que está acontecendo. Como sempre,
vá sempre para o topo, porque as probabilidades são, de haver um efeito em cascata confuso. O primeiro erro que vejo é o uso de string de identificador não declarado. Eu quis dizer padrão n? Eu não quis dizer padrão n, string, string, string. Então, eu poderia rodar help50 como minha fronteira, mas, honestamente, eu cometo esse erro com frequência suficiente para que eu saiba agora que esqueci de incluir cs50.h. E, se eu fizer isso e recompilar make address - OK, todos os cinco erros são eliminados apenas por aquela mudança simples. E se eu executar o endereço agora,
ele simplesmente vai dizer HI. Mas agora vamos começar a considerar o que está acontecendo por baixo do capô deste programa. Suponha que eu esteja curioso e queira imprimir o que é o endereço em que esta string reside. Bem, acontece - deixe-me ser inteligente aqui. Vamos imprimir, não um código de % s, mas % p. Mostre-me esta mesma string como um endereço. Eu vou recompilar, make address, parece compilar OK. Vamos executar ./ address. E novamente, ainda estou imprimindo s, mas estou pedindo printf para apresentá-lo como se fosse um ponteiro. E interessante, não é o mesmo de
antes. Mas, novamente, isso é razoável porque os endereços de memória não serão sempre os mesmos. Mas não importa o que seja. Mas isso é interessante. Todo esse tempo, sempre que você estiver usando strings, Você tinha acabado de mudar seu %s para % p, você poderia ter visto onde, na memória, essa string começa. Ainda não é funcionalmente útil para nós. Mas está lá o tempo todo. Agora eu vou fazer o seguinte. Suponha que eu fique um pouco mais curioso e faça printf. Eu vou imprimir outro endereço seguido por uma nova linha. Agora eu vou imprimir o
endereço do primeiro caractere. Então, novamente, isso é um pouco estranho de se fazer. E normalmente não faríamos isso com tanta frequência. Mas, novamente, apenas para deixar claro que esses operadores nos fornecem muito simples respostas a perguntas como, qual é o endereço dessa coisa? Se s colchete i, a partir da segunda semana em CS50, representou o segundo caractere em s, porque o índice 0 significa s colchete 0 é o primeiro, s colchete 1 é o segundo. Se eu brincar com o novo operador de hoje, este &, aposto que posso ver o endereço desse segundo caractere. E,
deixe-me ir em frente e ser mais explícito. Vou mudar este primeiro s para o colchete 0 e colocar um & aqui. E deixe-me ir em frente, agora, e fazer este programa, make address. OK, um pouco esquisito - Acabei de perder um ponto e vírgula. Tão fácil consertar. Vamos prosseguir e recompilar com make address. Vamos prosseguir e executar ./ endereço. E interessante, bem, talvez - interessante para mim. Então você vê, agora, dois endereços, o primeiro dos quais é 0x4006a4, que aparentemente é o endereço do primeiro caractere em s. Mas observe o que há de curioso no
próximo. É quase o mesmo, exceto que o byte está um mais distante. E eu aposto que se eu fizer isso, não apenas para "h" e "i", mas também o ponto de exclamação - deixe-me fazer mais uma linha de código quase idêntica, apenas para deixar claro que todo esse tempo é, é o caso em que todos os caracteres em uma string estão consecutivos. E agora você pode vê-lo em código. B4, b5, b6 estão separados por apenas um byte. Então, vemos alguma confirmação visual, agora, essas strings são de fato colocadas na memória assim. Agora, novamente, este não
é um exercício programático muito útil ver o endereço de caracteres individuais. Mas, novamente, isso é para enfatizar que, por baixo do capô, algumas operações relativamente simples estão sendo habilitadas por meio deste novo &, e por sua vez, operador asterisco. Então, vamos considerar por um momento o que isso parece dentro da memória do computador. Em um baixo nível, sim, s é tecnicamente um endereço. E sim, é tecnicamente o endereço do primeiro byte, Que no computador real, parecia diferente. Mas no meu slide aqui, eu apenas propus arbitrariamente que está em 0x123, 0x124, 0x125. Mas, novamente, não vamos
nos importar com esse nível de detalhe. Vamos abstrair esses endereços e agora comece a pensar em s, que é uma string, como tecnicamente apenas sendo um ponteiro. Um ponteiro. Acontece que, embora seja muito útil e muito comum pensar em strings como, obviamente, sendo apenas sequências de caracteres. E isso é verdade desde a primeira semana. E você também pode pensar nelas como arrays, Sequências consecutivas de caracteres. Você também pode, ao que parece, a partir de hoje, pensar nelas como apenas ponteiros, ou seja, o endereço de um caractere em algum lugar na memória do computador. E como
Ginni observa, porque todos os caracteres em uma string são, por definição, de ponta a ponta, porque, por definição, todas as strings terminam com uma \ 0, que é literalmente a menor e única quantidade de informação que você precisa manter um computador para saber onde estão todas as suas strings. Basta lembrar o endereço do primeiro caractere porque você pode encontrar seu caminho até o fim lembrando que esta \ 0 é, na verdade, apenas oito 0 Bits, representada como \ 0. E então certamente poderíamos ter uma condição if, muito parecida com o que fizemos há duas semanas,
quando brincávamos com o comprimento das strings, que nos permite verificar precisamente isso. E então, quando digo que vamos remover as muletas, aqui está. Até agora, estamos usando, novamente, a biblioteca CS50, o que nos dá, convenientemente, funções como get string e get int e get float e assim por diante. Mas todo esse tempo, a biblioteca CS50, especificamente o arquivo, cs50.h, teve um pouco de simplificação pedagógica. Lembre-se da semana passada, que você pode definir seus próprios tipos de dados personalizados. Bem, acontece que todo esse tempo, temos afirmado que existem strings E são algo que você pode usar
em seus programas. E strings existem em C. Elas existem em Python, em Java Script, em Java, e C, em muitas, muitas, muitas outras linguagens. Este não é um termo CS50. Mas string, tecnicamente, não existe como um tipo de dados em C. Em vez disso, é mais cripticamente e de nível mais baixo conhecido como char*. Asterisco char, agora o que isso significa? Bem, char*, muito parecida com nosso asterisco int de alguns minutos atrás, apenas representa o endereço de um caractere, bem como int asterisco representa o endereço de um int. E se, novamente, você meio que concorda
comigo agora, que você pode pensar em strings como sequências de caracteres, Ou mais especificamente, arrays de caracteres ou, mais especificamente, a partir de hoje, o endereço apenas do primeiro caractere, então é, o caso de que agora podemos aplicar esta nova terminologia, hoje, de ponteiro, para nossas velhas amigas, as strings. String é a mesma coisa que um sinônimo, se assim preferir, de char*. E é na biblioteca CS50 que temos uma linha de código que simplifica ou abstrai asterisco char, que honestamente, ninguém quer pensar ou ter essa dificuldade na primeira semana de aula, muito menos as primeiras
duas ou três semanas de aula. É uma simplificação, um tipo de dado customizado, que chamamos de string, só para você não ter que pensar, o que é esse asterisco? O que isso significa para o caractere? Sobre qual é o endereço? Mas hoje podemos remover essas rodas de treinamento e revelar isso, todo esse tempo, você manipulou caracteres em endereços específicos. E usamos esse tipo de técnica antes, abstraindo esses detalhes de nível inferior. Por exemplo, lembre-se na semana passada, que introduzimos essa noção de uma estrutura, um tipo de dados que você pode personalizar. Nós implementamos uma melhor
lista telefônica, envolvendo um nome e um número dentro de um tipo de dados personalizado, encapsulando-os se assim preferir, dentro de algo que chamamos de pessoa. E toda pessoa que afirmamos ter uma estrutura Que contém um nome e um número. E pelo caminho dessa característica do C, typedef, podemos definir um novo tipo. E o nome desse na semana passada, era apenas uma pessoa. Então, já estamos usando e temos estado secretamente usando desde a primeira semana do C, uma linha de código que se parece com isso. E esta é, uma das linhas de código dentro de cs50.h.
Diz typedef, o que significa me dê um tipo personalizado. E cria um sinônimo para char* chamado string. E é uma maneira de esconder a char*. Podemos ocultar o asterisco, em particular, o que não seria divertido de brincar nos primeiros dias, Sem alterar a definição do que é uma string. Portanto, strings existem em C. Mas não há nenhum tipo de dado chamado string em C até usar uma biblioteca como CS50's, que o faz existir por meio desse tipo de definição. Tudo bem, deixe-me fazer uma pausa aqui para ver se há qualquer dúvida, então, sobre o que
são strings ou essas novas formas de pensar sobre elas. Alguma dúvida sobre strings ou char*s? Tudo bem, bem, se não houver perguntas aqui, por que não vamos em frente e fazemos uma pausa de 5 minutos aqui primeiro. E estaremos de volta em 5 e daremos outra olhada no que podemos fazer agora com esses novos primitivos. Tudo bem, estamos de volta. E temos, agora, essa capacidade no código de obter o endereço de alguma variável e também para ir a um endereço usando & e o asterisco, respectivamente. Nós pensamos em strings como sendo não apenas sequências contíguas
de caracteres, mas também arrays. E então, é claro, a partir de hoje, endereços reais, o endereço do primeiro caractere e, a partir daí, podemos encontrar nosso caminho, programaticamente, até o fim, graças a esse caractere nul. Mas acontece que há outra coisa que podemos fazer com esses endereços ou com ponteiros de forma mais geral. E isso é conhecido como operação matemática de ponteiro. Então, qualquer coisa que seja um número, claro, podemos fazer matemática. E a matemática não vai ser complicada, mas vai ser poderoso para nós aqui. Portanto, vou voltar ao meu mais recente estado de address.c.
E deixe-me ir em frente, agora, e reiterar que podemos imprimir os caracteres individuais em uma string, assim como fizemos na segunda semana, usando nossa notação de colchetes. Portanto, estou me livrando de todas as evidências desses endereços por enquanto. Estou recompilando este programa como make address. E então vou executar o ./address agora. E vejo HI!, um caractere por linha. Mas agora, considere que não precisa haver um tipo de dados de string. Na verdade, podemos tirar essa roda de treinamento. E embora possa parecer um pouco desconfortável no início, se eu excluir esta primeira linha completamente, como eu
acidentalmente omiti de qualquer maneira às vezes, não preciso ficar chamando as coisas de strings. Posso descrever como strings verbalmente. Posso pensar nelas como strings, porque strings são uma coisa em muitas linguagens de programação diferentes. Mas, por padrão, em C, simplesmente não existe como um tipo. Em vez disso, o tipo tem um nome um tanto enigmático, char*. Mas, novamente, tudo o que isso significa é que o asterisco está marcando o endereço de algo. Char significa que é o endereço de um char. Então char* dá a você uma variável de ponteiro isso vai apontar para um caractere.
Então agora, se s é isso, posso tratar da mesma forma. Não há motivo para eu não poder continuar usando s como uma string estava na segunda semana, usando nossa notação de colchetes. E posso continuar imprimindo o HI! usando a mesma sintaxe de colchetes. Mas há uma outra maneira de fazer isso. Se agora eu sei que s é um endereço, Posso me livrar dessa notação de colchetes. E eu posso apenas fazer s*, porque lembre-se daquele asterisco, além disso Para ser o novo símbolo que usamos ao declarar um ponteiro aqui, também é o mesmo símbolo, confuso, admito,
que costumávamos usar para ir a um endereço. Então, se s está armazenando um endereço, que é por definição um ponteiro, s* significa ir para aquele endereço. E de acordo com minha foto anterior, parece para ser o caso em que s provavelmente está em um endereço que começa em 0x123. Não será o mesmo em meu IDE real aqui. Será tudo o que o computador ordenar. Mas vai ser exatamente a mesma ideia. Então, agora eu vou ir para as s*. E só por diversão, vou deixar apenas uma linha. Então, vou executar novamente como make address. Tudo bem,
e agora ./address. Devo ver, com sorte, H e apenas um H. Mas observe isso. Se eu sei que s, uma string, é tecnicamente apenas um endereço, na verdade, agora posso fazer cálculos. E posso imprimir outro caractere, seguido por uma nova linha. E eu posso ir para, não s, mas que tal s mais 1. Posso fazer uma operação matemática muito simples, se assim preferir, nesse ponteiro. Agora eu vou recompilar isso. Então make address, compila OK, ./address. E eu deveria ver o HI. E se eu fizer mais uma linha de código como esta, printf, % c, \
n, S* + 2, agora posso ir para o caractere que está a dois bytes de distância de qualquer s, que, novamente, é o início da string. Então, agora, reimprimi HI com o ponto de exclamação, caractere por caractere, mas não usando este colchete sofisticado apenas no sentido de que era uma espécie de abstração para nós, se preferir assim. Em vez disso, estou manipulando s pelo que é, que é um endereço. E aqui também, e já usei essa frase antes, aquela notação de colchetes que introduzimos na semana dois, é tecnicamente apenas syntatic sugar. Não está fazendo nada
fundamentalmente diferente A partir desses asteriscos e desses endereços. está apenas fazendo isso, honestamente, de uma forma muito mais amigável. Eu ainda prefiro, pessoalmente, a notação de colchetes da segunda semana. Mas é a mesma coisa que usar * e fazer as contas você mesmo. Então, C está apenas nos fornecendo esse recurso útil de usar colchetes que fazem todo esse ponteiro aritmético para você. Mas, novamente, vamos para esse baixo nível apenas para enfatizar o que está acontecendo por baixo do capô aqui. Tudo bem, deixe-me pausar aqui para qualquer dúvida. E Brian, por favor, sinta-se livre para verbalizar
qualquer coisa de sua parte. Brian: Eu vejo uma pergunta que surgiu sobre o que aconteceria Se você tentasse imprimir s* + 3. David Malan: Então, tenho certeza que isso vai imprimir o caractere nul. Mas vamos em frente e confirmar aqui, %c \n s* + 3. Tudo bem, estou me aventurando um pouco ao olhar para as coisas que talvez não deveria estar olhando, porque isso é um detalhe de implementação de baixo nível. Mas vamos ver o que acontece. Ele compila ok, ./address. E parece estar em branco. Agora, talvez esse seja o caractere Nul. Honestamente, não é
para ser um caractere imprimível. É este valor sentinela especial que indica o fim da string. Mas eu poderia fazer isso. Eu sei desde a segunda semana que os chars são inteiros, e inteiros são chars se eu quiser pensar neles dessa forma. Então, deixe-me mudar apenas o último caractere para usar o formato de código %i. Vamos recompilar meu código. Eu vou executar o endereço. E pronto, HI exclamação 0. E há todos os bits 0 representados aqui como um único dígito decimal, graças a % i. Agora, posso ficar louco aqui. E por que não vamos em frente
e imprimimos não apenas quais caracteres estão logo após esta sequência, HI!, caractere nul, por que não vamos - que tal endereçarmos a 1.000 bytes de distância, e com estilo vamos para dentro do meu computador? Vamos recompilar esse ./address. OK, nada acontecendo aqui. Que tal cerca de 10.000 bytes de distância? Eu vou make address. Vamos prosseguir e executar essa falha de segmentação. Tudo bem isso não está bom. E você pode estar entre os poucos afortunados que viram esse erro antes ao tocar a memória que não deveria. E vamos considerar isso deliberadamente hoje. Mas uma falha de
segmentação, significa que você fez algo errado em algum lugar do seu código. E isso tende a significar que você tocou um segmento de memória que você não deveria ter tocado. Eu não me interesso, honestamente, em olhar 10.000 bytes de distância da memória que sei que pertence à string. Isso é como olhar arbitrariamente em qualquer lugar na memória do seu computador, que provavelmente, ao que parece, não é uma boa ideia. Mais sobre esse assunto daqui a pouco. Então, vamos considerar, agora, algumas das implicações desses detalhes de implementação subjacentes E considere, agora, a partir da semana passada,
porque fizemos algumas coisas do jeito que fizemos nas últimas semanas, na verdade. Então string é um char*. E vamos, agora, considerar um exemplo. Vamos diminuir o zoom na minha memória, apenas para que eu possa incluir mais de uma vez. Vamos considerar um exemplo onde eu poderia querer escrever um programa que compara duas strings. Vamos prosseguir e escrever um novo código aqui em um novo arquivo desta vez, chamado, por exemplo, compare.c. Meu objetivo com este programa, simplesmente, é ser imprimir o conteúdo de - ou melhor, comparar duas strings que o usuário pode inserir. Vou prosseguir e
incluir cs59.h, não porque eu continue querendo a string, digamos, mas porque eu quero usar get string apenas por conveniência. Mas também tiraremos essa roda de treinamento daqui a pouco. E neste programa, vou em frente e primeiro vou usar isso, e não get string ainda. Vamos prosseguir e manter as coisas simples e começar com get int. E vou pedir ao usuário uma variável i. E deixe-me fazer outro desses get int e perguntar ao usuário por um valor para j. E então agora eu vou simplesmente dizer, se i é igual a j, então vá em frente e
imprima o mesmo. Eu vou imprimir de forma diferente. Então, esta é a primeira semana, onde estou usando algumas variáveis. Estou usando uma condição com duas ramificações e estou usando printf para imprimir se essas duas variáveis, i e j, são as mesmas. Então, vamos compilar isso. Tudo está bem. Execute compare e deixe-me dar os dígitos 1 e 2. E, são diferentes. Agora eu vou dar 1 e 1, e são iguais. Então eu acho, logicamente, prova por exemplo, se preferir, este programa parece correto. Mas deixe-me torná-lo aparentemente incorreto, não usando números inteiros. Mas que tal usar strings
em vez disso. vou continuar e criar uma string. Embora, não, eu não precise mais daquela roda de treinamento. Vamos fazer char* s igual a get string de s. Mas, novamente, embora eu esteja chamando de char*, ainda é uma string como se fosse semanas atrás. Vou criar outra string chamada t, apenas para manter o nome curto. E vai obter - t obterá esse valor. E deixe-me apenas, muito ingenuamente, mas razoavelmente, dizer que se s é igual a t, vamos prosseguir e imprimir o mesmo. E caso contrário, vamos prosseguir e imprimir diferente. Portanto, o mesmo código exato,
apenas diferentes tipos de dados, e usando get string em vez de get int. Eu vou fazer make compare, parece compilar OK, ./compare. Vamos prosseguir e digitar HI! - woops, HI !. Vamos prosseguir e digitar HI! novamente. E voila, diferente. E esqueci minha \, mas esse parece ser o menor dos meus problemas. Vamos recompilar isso, make compare, e agora, deixe-me executá-lo novamente. Que tal fazer um teste rápido. David, Brian, esses são definitivamente diferentes. Tudo bem. Portanto, o programa parece funcionar. Que tal David, David? Também diferente. Huh, deixe-me tentar novamente. Brian, Brian, também diferentes. Mas tenho certeza
de que essas strings são as mesmas. Por que este programa pode ter falhas? O que há de errado com este programa agora? BRIAN: Algumas pessoas no chat estão dizendo que não estamos comparando os caracteres, estamos comparando os endereços. DAVID MALAN: Sim, essa é a conclusão lógica de hoje Na definição do que uma string é. Se uma string é o endereço de seu primeiro caractere, então, se você estiver literalmente fazendo s igual a t, você está comparando esses dois endereços. E provavelmente serão diferentes, mesmo se eu digitar a mesma coisa, porque toda vez que chamei get
int ou get string, meio que inseriu na entrada do usuário em algum lugar da memória do meu computador. Mas agora temos as ferramentas, honestamente, para responder ou examinar esta resposta nós mesmos. Vamos simplificar este programa. E vamos, apenas para uma rápida verificação, imprimir s. E vamos prosseguir e imprimir usando uma nova linha após cada, só para vermos quais são as strings. Então, agora eu vou fazer isso de novo, make compare, compila OK, ./ compare. Vamos digitar HI, HI. E eles parecem ser visualmente iguais. Mas lembre-se que, agora, eu tenho esse outro código de formato, de
modo que agora posso começar a tratar strings como os endereços que são tecnicamente. Então, deixe-me mudar a % s para a % p em ambos os lugares. Vamos então recompilar o programa, e agora, execute-o novamente e compare com HI e HI digitados de forma idêntica. Mas observe, eles acabaram em locais de memória ligeiramente diferentes. Mesmo que eu tenha coincidentemente digitado a mesma coisa, C e meu computador não serão tão presunçosos a ponto de usar os mesmos bytes para ambas as strings. Isso não vai me dar muita flexibilidade se eu quiser mudar um ou outro. Isso
vai colocar, de forma muito simplista, incluir um pedaço neste pedaço de memória e o outro neste pedaço de memória. E, esses endereços são respectivamente, mas arbitrariamente, 0x22fe670 e 0x22fe6b0. Portanto, estão separados a alguma distância. Mas, novamente, cabe ao computador decidir onde colocá-los. Então, o que está acontecendo dentro da memória do computador? Bem, vamos considerar se, por exemplo, este é s, meu ponteiro, ou , minha string. Mas agora é um ponteiro. É o endereço de algo. Observe que eu o desenhei como ocupando oito quadrados, porque, novamente, um ponteiro em sistemas modernos tem oito bytes. É por
isso que essa coisa é tão grande. Enquanto isso, quando eu digito algo como HI!, então acaba em algum lugar na memória. Nós não sabemos ou não nos importamos onde está. Então, vamos simplesmente dizer que acaba ficando ali Na memória do meu computador. Agora, cada um desses bytes, claro, tem um endereço. Eu não necessariamente sei ou me importo com o que são. Mas para fins de explicação, vamos numerá-los novamente como antes, 0x123, 0x124, 0x125, 0x126. Quando eu atribuo s à esquerda o valor de get string à direita, get string, o que vai fazer? Bem, todo esse
tempo desde a primeira semana, desde que você o tem usado, obtém uma string e devolve a você como um valor de retorno. Mas o que isso significa? Bem, se uma string é um endereço, o valor de retorno de uma função como get string é para retornar, não a string em si, porque isso é Um tipo de conceito de alto nível. O que get string sempre fez por nós é retornar o endereço da string, ou mais especificamente, o endereço do primeiro caractere na string. E então o que é tecnicamente armazenado em s, para ser claro, é
esse endereço, 0x123. Não está retornando a string inteira, o H, o I, o ponto de exclamação. Em vez disso, está retornando apenas um valor para você. está retornando apenas para você o endereço do primeiro caractere daquela string. Mas, novamente, tudo isso é muito bom para apenas s. O que está acontecendo com t? t é mais ou menos a mesma história, porque estou chamando get string novamente. t vai ser atribuído ao endereço do primeiro caractere Desta versão do HI. E vamos apenas dizer que está em 0x456, 0x457, 0x458 e 0x459. E neste ponto, t vai assumir
o valor de 0x456. E agora, neste ponto, honestamente, estamos entrando nas minúcias. Vamos começar a abstrair tudo isso e usar setas para apontar para os valores. E, essas setas representam apenas ponteiros quando paramos de nos preocupar com os endereços específicos. Então s é um ponteiro, uma variável que aponta no primeiro caractere de HI aqui. t é uma variável apontando para o primeiro caractere de HI ali. E então, quando você está comparando duas strings Como eu estava antes na versão anterior do meu programa, onde eu estava verificando se s é igual a t, eu estava, comparando
s e t. O que são s e t? s e t, respectivamente, são 0x123 e 0x456, ou quaisquer que sejam os valores reais, que não vão ser os mesmos porque acabam por apontar para diferentes blocos de memória. Tudo bem, quem se importa? Isso tudo é um bom exercício intelectual. Mas quem se importa? Bem, como podemos resolver este problema? Vamos considerar o que eu fiz em uma demonstração anterior. Eu meio que mencionei preventivamente que existe esta função, comparação de strings, que permite que você compare duas strings. E eu prometi que explicaríamos porque usamos str compare ao
invés de apenas usar o sinal de igual igual. Bem, para usar esta função, vou precisar adicionar string.h até aqui pela última vez. Mas se string compare s t, vou recompilar isso, compare ./compare Agora, deixe-me digitar HI! e HI! identicamente. Agora, eles ainda parecem ser diferentes. E caramba, cometi o mesmo erro estúpido da última vez. Alguém sabe que erro cometi ao comparar duas strings? De alguma forma, pareço ser muito bom em cometer esse erro. BRIAN: Ibrahim está sugerindo que você adicione um igual igual a zero. DAVID MALAN: Obrigado. Ibrahim está certo. O valor de retorno, lembrem,
de str compare, é retornar 0 se forem iguais, um número negativo se um vier antes do outro, e um número positivo se um vier depois do outro, como na ordem ASCIIbética. Então o que eu deveria ter feito, da última vez e desta vez, a verificação de igualdade com 0. Eu vou recompilar este programa. Tudo bem. Agora, deixe-me executar novamente este programa com o HI! duas vezes. Voila, são iguais. E só para ter certeza, deixe-me fazer outra verificação. Vou fazer David e Brian, o que deve ser, diferente. Então agora, novamente, eu não fiz nada diferente da
última vez. Mas agora estou pensando nessas strings como sendo fundamentalmente apenas seus endereços. E então, agora, vamos tornar isso pertinente. Vamos prosseguir e criar um novo arquivo. E vamos, razoavelmente, tentar copiar uma string e fazer alterações nela. Então, vou prosseguir aqui. E apenas por conveniência, ainda vou usar a biblioteca CS50, não para o tipo de dados string, mas apenas para o get string function, que veremos é mais útil do que outras coisas - do que outras maneiras de fazer as coisas. E vou prosseguir e incluir include standard io ponto h. E vou prosseguir e incluir,
que tal, string.h. Eu vou fazer int main void. E deixe-me ir em frente, neste programa, e criar uma string. Mas observe, não vamos chamar mais de string. Vamos chamar de char*. Então, novamente, comece a tirar a roda de treinamento. E vou prosseguir e obter uma string chamada s. E então vou pegar outra string. Mas não vou chamar assim. Vou chamar de char* t. E eu quero copiar s. E então você pode pensar, com base na semana um, semana dois, e desde então, que OK, se você quiser copiar uma variável, basta fazê-lo. Quer dizer, usamos o
operador de atribuição para copiar uma variável da direita para a esquerda para inteiros, para chars, e para outros tipos de dados, talvez também. Vou prosseguir, agora, e fazer uma alteração na string original. Então, agora eu vou fazer isso. Vamos continuar e dizer, vamos mudar o primeiro caractere de t Em maiúsculas. Lembre-se de que existe esta função, to upper, que leva, como entrada, um caractere, como o primeiro caractere em t, e retorna a versão em maiúsculas. Agora, para usar o to upper, preciso de outro arquivo de cabeçalho, que pelo que me lembro, de algumas semanas atrás,
é o ctype.h. Então, volto e coloco isso lá. E agora, deixe-me ir em frente e imprimir essas duas strings. Eu vou imprimir s como sendo % s. Agora eu vou imprimir o valor de t com % s como segue. Então, novamente, o que estou fazendo é recebendo uma string do usuário. E a única coisa nova aqui é char asterisco hoje, que é sinônimo de string. Na linha 10 aqui, estou copiando a string da direita para a esquerda. E então estou colocando em maiúscula apenas a primeira letra na cópia, também conhecida como t. E então estou
imprimindo ambas. Então agora eu vou fazer uma cópia, compila OK. Faça copy-- cópia ponto-barra. Vamos prosseguir e digitar hi! em minúsculas, todas em minúsculas, e, em seguida, entre. E voila. Parece que de alguma forma eu coloquei S e T em maiúscula, embora eu apenas chamado to upper em T. Brian, alguma ideia do grupo sobre por que eu acidentalmente e erroneamente converti em maiúscula Ambas, de alguma forma? BRIAN: Algumas pessoas estão dizendo que t é um pseudônimo de s. DAVID MALAN: Apenas um pseudônimo de s, essa é uma maneira razoável de pensar nisso, certo. E, mais
precisamente, algum outro pensamento sobre por que isso está incorreto de alguma forma? BRIAN: Peter agora está sugerindo que tenham o mesmo endereço. DAVID MALAN: Sim, mais especificamente, tudo o que fiz foi copiar s para t. Mas, de novo, o que é "s" hoje? É apenas um endereço. Então, sim, copiei o s. Mas eu copiei o que significa copiar seu endereço, 0x123, ou seja o que for. E então na linha 12, observe que estou mudando t colocando-o em letras maiúsculas. Mas t está no mesmo endereço de s. Então, estou mudando um na mesma string. Então, se
pensarmos nisso em termos de memória do computador, vamos considerar o que acabei de fazer. Vamos limpar a memória do computador. Vamos tratar o "s", como fizemos antes. Deixa eu colocar hi! para baixo como antes, mas todas em minúsculas desta vez. E lembre-se de que podem ser os endereços 0x123, 124, 125 e 126. E agora, se considerarmos que tecnicamente contém o endereço do primeiro caractere, 0x123, e eu continuo criando uma nova variável, t, e atribuo t o valor de s, Eu tenho que interpretar essa afirmação literalmente. Estou literalmente colocando 0x123 aqui. E se agora abstrairmos esses
detalhes apenas para deixar mais claro visualmente o que está acontecendo, isso é quase como dizer que ambos os pontos s e t estão no mesmo local na memória. Então, sim, nesse sentido, t é um apelido para s, que é uma maneira razoável de pensar nisso. Mas, na verdade, t é idêntico a s. Então, quando você usa a notação de colchetes para ir para o primeiro caractere de t, você está, equivalentemente, indo para o primeiro caractere em s. São o mesmo. Então, quando eu chamo to upper, estou chamando esse caractere, que é claro, é o único
h na história. E quando eu print s e print t, printf é seguindo essas mesmas migalhas de pão, se preferir, e, finalmente, exibindo o mesmo valor como tendo sido alterado. Portanto, parece que precisamos repensar fundamentalmente como estamos copiando strings. E deixe-me perguntar, se esta é a maneira errada de copiar uma string na outra, qual é o caminho certo? Mesmo que você não tenha as funções em mente ou o vocabulário certo, apenas intuitivamente, se quisermos copiar uma string da maneira que um humano faria Pense em copiar uma no outra, como uma fotografia ou fotocópia, como podemos
fazer isso? Alguma ideia, Brian? BRIAN: Sim, Sofia sugeriu fazer um loop de alguma forma com elementos em s e colocá-los em t. DAVID MALAN: Sim, gosto disso. Então, faça um loop sobre os elementos de s e coloque-os em t. Portanto, parece mais trabalho. Mas isso é, novamente, o que vamos ter que fazer se quisermos pensar nisso - se quisermos aceitar o fato de que essas coisas, s e t, são apenas endereços, agora vamos ter que seguir essas migalhas de pão. Portanto, vamos prosseguir e considerar uma variante deste programa. Vou continuar aqui e mudar isso para
que eu ainda esteja recebendo uma string s. Mas agora, deixe-me ir em frente e propor exatamente isso, que copiemos os caracteres individuais. Mas preciso copiá-los em algum lugar. Então, eu sinto como se mais uma etapa neste processo de copiar uma string precisa me retornar alguma memória adicional. Se eu tiver Hi! em caráter nulo, eu preciso, agora, de alguma forma, assumir o controle desta situação e dizer ao computador, de alguma forma, em código, me dê mais quatro bytes de memória para que eu tenha um local para t no qual copiar esses caracteres. Então, aqui está uma
nova função hoje. Se eu quiser criar uma string t, também conhecido hoje como char*, há uma nova função que podemos usar chamada malloc, que representa a alocação de memória. Esta é uma função muito sofisticada que, felizmente, é muito simples de usar. Leva, como entrada, apenas um número. Quantos bytes de memória você deseja solicitar ao computador? Então, como faço isso? Bem, HI! .\0, eu poderia literalmente dizer apenas quatro. Mas isso não parece muito dinâmico. Acho que posso implementar isso programaticamente com um pouco mais de elegância. Eu vou dizer, me dê tantos bytes quanto houver de caracteres
em s mais 1. Mais 1, por que estou fazendo isso? Bem, HI! nul é, tecnicamente o que está armazenado embaixo do capô. Mas, qual é a duração do Hi! ? Bem, as probabilidades são, no mundo humano, é HI!. E quem se importa com esse detalhe de baixo nível, esse terminador nul. Você não inclui isso no comprimento de uma palavra em inglês ou de qualquer palavra. Você só pensa nos caracteres reais que pode ver. Portanto, o comprimento de H, i, ponto de exclamação, é 3. Mas eu preciso habilmente adicionar mais um bite, um quarto, para o
caractere nulo, porque terei que copiá-lo também. Caso contrário, se eu não tiver um caractere nul idêntico, Não vai ter um final óbvio. Então, como faço para copiar, agora, uma string na outra? Bem, agora eu vou recorrer ao nosso velho amigo, o loop for, da primeira semana. E digamos, for i = 0 - que tal, na verdade, n é igual ao comprimento da string de s. Já fizemos esse truque antes. i é menor que n, i ++. Eu vou, simplesmente, dizer t [i] gets s[i]. Então, isso irá copiar de s, cada um dos caracteres, um de
cada vez em t. Mas preciso ser um pouco mais esperto agora. Embora quase sempre façamos i<n, na verdade, vou dizer de forma muito agressiva i <= n. Por quê? Por que vou um passo além do que normalmente considero fazer ao iterar sobre strings, e um passo além do que você provavelmente faria ao iterar sobre uma cifra de césar ou uma string nesse contexto? Brian, alguma ideia aqui? Por que vou de i menor ou igual a n, mais ou menos pela primeira vez aqui? BRIAN: Celina está sugerindo que precisamos incluir o caractere nul. DAVID MALAN: Sim,
então se eu-- e agora eu entendo como as strings funcionam. Portanto, não é suficiente apenas copiar H,I,! Preciso dar um passo adiante, mais um do que o comprimento da string. E a maneira mais fácil de fazer isso seria menor ou igual a n. Ou eu poderia simplesmente fazer um +1 ali. Ou posso fazer isso de várias maneiras. Não importa como você faz isso. Mas acho que menor ou igual a é uma maneira razoável de fazer isso. E agora, vamos descer ao fundo aqui e agora faço esta conversão em maiúscula. Vamos agora mudar o primeiro caractere
em t para ser o resultado de to upper do primeiro caractere de t. E então, como antes, vamos imprimir o que quer que seja. E como antes, vamos prosseguir e imprimir Seja o que t for e espero que agora t tenha sido convertido em maiúscula. Mas preciso fazer uma mudança agora. Acontece que esta função, malloc, vem em um arquivo denominado lib ponto h, padrão. E, novamente, esse é o tipo de coisa que você pode anotar. Você sempre pode pesquisar esse tipo de coisa no Google. Até eu esqueço em quais arquivos de cabeçalho essas funções às
vezes são declaradas. Mas acontece de ser um novo chamado lib padrão para biblioteca que dá acesso ao malloc. Então deixe-me ir em frente, agora, fazer make compare. Tudo bem, até agora tudo bem. ./compare - desculpe, isso não é compare. O programa antigo funciona bem. Make copy - oh meu Deus, sete erros. O que eu fiz de errado aqui? Oh, parece que esqueci o tipo de i e n. Então, deixe-me entrar em meu loop for e adicionar o int. Isso foi minha culpa. Vamos fazer uma cópia novamente. OK, todos os sete erros, felizmente, sumiram. Make copy,
vamos digitar hi! em minúsculas e pressionar Enter. E pronto, agora coloquei em maiúscula apenas a cópia de s, também conhecida como t. E só para ficar claro, eu meio que regredi de volta à minha notação de colchetes, honestamente, porque é perfeitamente aceitável. É muito legível. Mas observe, se eu quero me exibir, eu poderia dizer algo como, bem, vá para o local de t + i. E então faça isso, o que, novamente, não necessariamente recomendo, para facilitar a leitura. Mas, novamente, existe essa equivalência. A notação de colchetes é a mesma coisa que a operação matemática de
ponteiro. Então, se você quiser ir para o endereço em t mais o que for i para se compensar um ou mais bytes, você pode fazer isso sem problemas. E se eu quiser ser sofisticado, eu posso descer aqui e dizer, vá para o primeiro caractere em t e coloque-o em maiúscula. Mas, novamente, eu diria que, embora, sim, você seja muito inteligente e que você entende as dicas e endereços neste momento Se você estiver escrevendo um código assim. Honestamente, não é necessariamente legível. Então, continuando com a sintaxe da semana dois da notação de colchetes, totalmente razoável, totalmente
correto, totalmente bem projetado e talvez preferível, embora eu deva ter cuidado aqui. Esta linha de código é um pouco arriscada para mim porque e se o usuário apenas clicar em Enter e não digitar hi ou David ou Brian. E se não digitarem nada, exceto Enter? Nesse caso, o comprimento da string pode ser 0. E então eu provavelmente não deveria colocar o primeiro caractere em maiúscula em uma string que nem existe. Então, provavelmente devo ter alguma verificação de erros, como se, por exemplo, o comprimento da string de t for pelo menos maior que 0, então vá
em frente e faça isso com segurança. Mas, novamente, este é um exemplo de algum erro adicional verificando se posso adicionar ao programa. Na verdade, há mais uma verificação de erro que eu deveria fazer em um programa totalmente correto, como você deve fazer em conjuntos de problemas. Às vezes, as coisas podem dar errado. E se o seu programa for tão grande, tão extravagante, e tão faminto por memória que você está usando o comando malloc e usando muita e muita memória, que você não fará no programa tão pequeno, Mas com o tempo você pode precisar de mais
e mais memória, também devemos ter certeza de que t tem um endereço válido. Acontece que malloc, na maioria das vezes, vai devolver para você o endereço de um pedaço de memória alocado para você. Assim como get string, vai voltar para você o endereço do primeiro byte do pedaço de memória para o qual encontrou espaço. No entanto, às vezes as coisas podem dar errado. Às vezes, seu computador pode estar sem memória. Você provavelmente já viu seu Mac ou O PC congelar, travar ou reiniciar sozinho. Isso geralmente é o resultado de erros de memória. Portanto, devemos verificar
algo assim. Se t for igual a este valor especial nul, então vou apenas pular e devolver um, e sair, vamos sair do programa. Não vai funcionar. Isso pode acontecer apenas uma em um milhão de vezes. Mas é mais correto verificar se há nul. Agora, infelizmente, os designers de C meio que usaram - ou programadores mais geralmente, esta palavra, que é quase o mesmo que N-U-L, também conhecida como \0. Infelizmente, esse é um valor diferente. N-U-L-L representa um ponteiro nul. É um endereço falso. É a ausência de endereço. Tecnicamente, seu endereço é 0. É diferente de
\ 0. Você usa N-U-L-L no contexto de ponteiros, como estamos fazendo hoje. Você usa \ 0, de outra forma conhecido verbalmente, como um N-U-L, ou nul, no contexto de caracteres. Portanto, a \ 0 é para caracteres. N-U-L-L em maiúsculas é para ponteiros. E é um novo símbolo que estamos apresentando hoje que vem com este arquivo lib ponto h padrão. Tudo bem, então parece, honestamente, que eu não preciso fazer parte desse trabalho. Acontece que se eu quiser copiar uma string para outra, existe uma função para isso. E cada vez mais, você não terá que escrever tantas
linhas de código como você fez anteriormente, porque se você olhar nas páginas de manual ou você ouviu falar ou descobriu online que há outra função, como uma chamada strcpy, você pode, na verdade, mais simplesmente, fazer algo assim. Embora eu tenha gostado da ideia, e foi correto usar um loop for para copiar todos os caracteres de s para t, há uma função para isso. É chamada de strcpy. Leva dois argumentos, o destino seguido pela fonte. E vai lidar com todo o looping para nós, todas as cópias para nós, incluindo \ 0, Para que eu possa me
concentrar no que quero fazer, que, neste caso, é, na verdade, converter em maiúscula as coisas. Então, se considerarmos, agora, este exemplo, no contexto da memória do meu computador, veremos que é um pouco diferente. Mas há mais um bug que eu quero consertar primeiro. E isso é algo que ainda não tivemos que fazer. Acontece que sempre que você aloca memória com malloc, você pede memória ao computador, a responsabilidade recai sobre você, o programador, para, eventualmente, devolvê-la. E com isso, quero dizer que se você alocar quatro bytes, ou quem sabe, quatro milhões de bytes de memória para
um programa ainda maior, é melhor devolver o espaço ao computador, mais especificamente, Ao sistema operacional, seja Linux ou Mac OS ou Windows, para que seu computador não fique sem memória. Se tudo o que você faz é pedir mais memória e mais memória, é lógico que, eventualmente, seu computador ficará sem, porque ele apenas tem uma quantidade finita de memória. Ele tem uma quantidade finita de hardware. Então, quando você terminar de usar a memória, deve ser sua melhor prática liberá-la depois também. E o oposto de malloc é uma função chamada free, que leva, como sua entrada, qualquer
que seja a saída de malloc. E lembre-se de que a saída de malloc, o valor de retorno de malloc, é o endereço do primeiro byte de memória que ele alocou para você. Então, se você pedir quatro bytes, como eu fiz algumas linhas atrás com malloc, você receberá de volta o endereço do primeiro desses bytes. E cabe a você lembrar quantos bytes você pediu. No caso de free, tudo o que tem a fazer é dizer free, por meio de sua entrada, o endereço que o malloc lhe forneceu. Então, se você armazenou esse endereço como eu fiz,
nesta variável chamada t, é suficiente quando você termine aquela memória com a chamada t free. E o computador irá liberar essa memória para você. E você pode muito bem recuperá-la mais tarde. Mas pelo menos o seu computador não ficará sem memória tão rapidamente, porque agora ele pode reutilizar esse espaço para outra coisa. Tudo bem, deixe-me ir em frente, então, e propor Que desenhemos uma imagem disso - agora a memória do novo programa, onde copiamos as coisas. Então, lembre-se, foi aqui que paramos antes ao comparar duas strings. Se este fosse s, apontando para h, i, !,
em minúsculas, esta nova versão do meu código em copy.c, veja só, ainda me dá outro ponteiro chamado t. Portanto, essa parte da história não mudou. Mas eu chamo malloc agora. E malloc vai me devolver um novo pedaço de memória. Não sei de antemão onde está. Mas o valor de retorno de malloc será o endereço do primeiro bite dessa memória. Então, por exemplo, 0x456 ou seja o que for. E os bytes subsequentes vão aumentar em um byte de cada vez, 0x457, 0x458, 0x459. Então, o que é, em última análise, armazenado em t quando eu atribuo a
ele o valor de retorno de malloc? É o que quer que seja esse endereço. Novamente, eu poderia escrever tecnicamente 0x456 aqui. Mas, novamente, já superamos isso. Isso foi há 30 minutos. Agora vamos nos concentrar apenas na abstração que é um ponteiro. Um ponteiro é uma seta apontando a partir da variável para o local real na memória. Então agora, se eu for copiar s para t usando strcpy, ou mais manualmente, Usando meu loop for, o que acontece? Bem, estou copiando h de s para t. Estou copiando o i de s para t, o ponto de exclamação
de s para t. E, por último, o caractere nul de terminação de s para t. Portanto, a imagem agora é fundamentalmente diferente. t não está apontando para a mesma coisa. Está apontando para seu próprio pedaço de memória que agora, um passo de cada vez, duplicando tudo o que estava no endereço s. E isso é o que você e eu, como humanos, consideraríamos, presumivelmente, ser uma cópia adequada do programa. Alguma dúvida, então, sobre o que acabamos de fazer com a introdução do malloc e do free? O primeiro deles aloca memória e dá a você O endereço
do primeiro byte de memória que você pode usar agora, o último o devolve ao seu sistema operacional e diz: terminei com isso. Agora pode ser reutilizado para outra coisa, alguma outra variável, talvez, no futuro, se nosso programa fosse mais longo. Brian, alguma dúvida ou confusão em que posso ajudar? BRIAN: Alguém perguntou, mesmo se você estiver usando strcpy para copiar a string em vez de copiar os caracteres um de cada vez, você ainda precisa liberar a memória? DAVID MALAN: Boa pergunta. Mesmo se você estiver usando strcpy, você ainda precisa usar free. Sim, a partir de agora,
sempre que você usar o malloc, deverá usar free. Sempre que usar malloc, você deve usar free para liberar essa memória. strcpy está copiando o conteúdo de um pedaço de memória para o outro. Ele não está alocando ou gerenciando essa memória para você. Está apenas implementando, isso para loop. E talvez seja a hora de tirar outra roda de treinamento verbalmente. Acontece que get string, todo esse tempo, é meio mágico. Uma das coisas que get string faz a partir da biblioteca CS50 é que ele próprio usa malloc. Considere, afinal, quando nós, o staff, escrevemos get string anos
atrás, não tínhamos ideia de quanto tempo seus nomes vão durar este ano. Não temos ideia de quais frases você está falando Para digitar, quais parágrafos você vai digitar, que texto você vai analisar para um programa como readability. Então, tivemos que implementar get string de tal forma que você pode digitar poucos ou tantos caracteres em seu teclado como você quiser. E vamos garantir que haja memória suficiente para essa string. Então, get string, por baixo do capô, se você olhar para o código, nós, o staff, escrevemos algum dia, você verá que usamos malloc. E chamamos malloc para
obter memória suficiente para caber nessa string. E então, o que a biblioteca CS50 também está secretamente fazendo, é que também está chamando free para você. Há um jeito sofisticado onde você Pode escrever um programa que, assim que o main estiver prestes a sair ou retornar para o seu prompt piscando, algum código especial nós escrevemos swoops naquele momento final, liberando qualquer parte da memória que nós, a biblioteca, alocamos para que você não fique sem memória por nossa causa. Mas todos vocês, ao usar malloc, terão que chamar free, porque a biblioteca não vai fazer isso por você.
E, a meta de hoje e da próxima semana e além é parar de usar a biblioteca CS50, em última análise, por completo. Tudo bem, vamos-- seria injusto, eu acho, se introduzirmos todas essas novas técnicas sofisticadas, mas não necessariamente fornecemos a você qualquer tipo de ferramenta para determinar a perseguição de bugs Em seu novo código sofisticado ou resolução de problemas, agora, que estão relacionados à memória. E, felizmente, existem programas por meio dos quais você pode perseguir bugs relacionados à memória. Isso é além de printf, e help50 e check50 e debug50 e depuradores de forma mais geral.
Este programa - e é a última das novas ferramentas que apresentaremos a você em C-- é chamado valgrind. E este é um programa que existe no CS50 IDE. Mas existe em Macs e PCs e Linux em qualquer lugar, onde você pode executá-lo em seu código para detectar se você está fazendo algo errado com a memória. O que você pode fazer de errado com a memória? Bem, antes, lembre-se, eu acionei essa falha de segmentação. Toquei a memória que não deveria. Valgrind é uma ferramenta que pode ajudá-lo a descobrir, onde você tocou na memória que não deveria,
de modo a focar sua própria atenção humana em quaisquer linhas de código que pode estar cheio de erros. Valgrind grant também pode detectar se você esquecer de chamar free. Se você chamar malloc uma ou mais vezes, mas não chamar free um número correspondente de vezes, valgrind é um programa que pode perceber isso e dizer que você tem o que é chamado de vazamento de memória. E, isso é pertinente aos nossos próprios Macs e PCs. Novamente, se você tem usado o seu Mac ou PC ou às vezes até mesmo seu telefone por muito, muito tempo, e
talvez executando muitos programas diferentes ao mesmo tempo, muitas guias do navegador abertas, muitos programas diferentes abertos ao mesmo tempo, seu Mac ou PC pode muito bem ter começado a ficar lento. Pode ser irritante, se não impossível de usar, porque tudo é muito lento. Isso pode muito bem ser porque um ou mais dos programas que você está usando tem algum bug em que um programador ficava alocando memória e nunca chamou free. Talvez seja um bug, talvez tenha sido deliberado, Não esperavam que você tivesse tantas janelas abertas. Mas o valgrind pode detectar erros como esse. E honestamente,
alguns de vocês, se forem como eu, você pode muito bem ter 10, 20, 50 guias diferentes do navegador abertas ao mesmo tempo, pensando "eu vou voltar a isso algum dia", embora nunca o façamos. Cada uma dessas guias ocupa memória. Literalmente, sempre que você abrir uma guia do navegador, pense nisso, como Chrome ou Edge ou Firefox ou qualquer outro que você está usando, por baixo do capô, estão provavelmente chamando uma função no Mac OS ou Windows como malloc para lhe dar mais memória para conter o conteúdo dessa página da web temporariamente. E se você continuar abrindo
mais e mais guias do navegador, é como chamar malloc, malloc, malloc. Eventualmente, você vai ficar sem recursos. E os computadores podem ser inteligentes hoje em dia. Eles podem remover coisas temporariamente da memória para liberar espaço. Isso é chamado de memória virtual. Mas, eventualmente, algo vai sair mal. E pode muito bem ser sua experiência de usuário quando as coisas ficam tão lentas que você literalmente tem que sair do programa ou talvez até reiniciar o seu computador. Então, como usamos valgrind? Bem, vou escrever um pequeno programa Que não faz nada de útil, mas demonstra vários erros relacionados
à memória. Vou chamar esse arquivo de memory.c. Vou prosseguir e abrir o arquivo memory.c e incluir no topo o padrão io ponto h. E então eu irei também, preventivamente, incluir lib ponto h padrão, que lembra de malloc, int main void. E vou manter tudo bem simples. Eu vou seguir em frente e criar um monte de números inteiros. Então isso é legal. Acontece que-- bem, vamos em frente. Sim, posso fazer isso. Vamos fazer isso. Char s* gets malloc. Agora eu vou criar, que tal três desses. Vou alocar espaço para três caracteres. Ou, na verdade, vamos criar
quatro, como antes. Agora, vou prosseguir e dizer que s colchete 0 é igual a 72. s colchete 1-- na verdade, vou apenas fazer isso manualmente. Vamos fazer h. Vamos fazer i. Vamos fazer nosso ponto de exclamação usual. E então, apenas para garantir, s colchete 3 gets "\ 0". Esta é a maneira muito manual de - esta é a maneira muito manual de construir uma string. Mas deixe-me apresentar um erro. Vamos alocar acidentalmente apenas três bytes, embora eu claramente precise de um quarto para aquele caractere nul final. E observe também a ausência de free. Eu vou,
muito descuidadamente, não me preocupar em chamar free. Agora, vou compilar este programa, make memory. OK, ele compila OK, então isso é bom, ./memory OK, nada acontece, mas isso faz sentido porque eu não disse a ele para fazer nada. Só por diversão, vamos imprimir essa string como sempre fazemos. Vamos recompilar a memória, ainda compila. Vamos executar ./memory. OK, parece funcionar. Portanto, à primeira vista, você pode estar muito orgulhoso de si mesmo. Você escreveu outro programa correto, parece passar no check50. Você submete. Você continua seu dia. E você fica muito desapontado alguns dias depois quando você percebe,
caramba, eu não recebi todo o crédito nisso porque há na verdade, um bug evidente. Então, às vezes, existem bugs no seu código Que você não necessariamente vê, visualmente, você não necessariamente experiencia ao executá-lo sozinho, mas, eventualmente, pode aparecer um erro ao executá-lo várias vezes. Eventualmente, um computador pode perceber que você está fazendo algo errado. E, felizmente, existem ferramentas como valgrind, que pode permitir que você detecte isso. Eu vou aumentar o tamanho da janela do meu terminal aqui. Agora eu vou executar o valgrind em ./memory. Portanto, é como debug50. Em vez de executar debug50 e, em
seguida, ./ seja qual for o programa, você executa valgrind ./ memory. Esta, infelizmente, é uma interface de linha de comando. Não há interface gráfica do usuário como debug50. E, honestamente, é uma sequência horrível de saída. Isso deve surpreendê-lo à primeira vista. Há um visual codificado muito ruim. Não é o programa mais bem projetado. Foi feito para as pessoas mais adaptadas à programação. Mas existem algumas dicas úteis que podemos tirar disso. Como sempre, deixe-me mostrar todo o caminho até o topo para a primeira linha de saída. E vou chamar sua atenção para algumas coisas que vão
começar a saltar aos olhos para você. E help50 pode ajudá-lo com isso. Se você está confuso com a saída de valgrind, execute-o novamente. Mas coloque help50 no início. E assim como farei agora verbalmente, help50 vai ajudá-lo a perceber as coisas importantes nesta bagunça maluca de saída. Isso é preocupante. Valgrind está observando nesta linha aqui, direito inválido de tamanho 1. E isso está na linha 10 de memory.c. Então, veremos isso em um momento. Se eu rolar mais para baixo, leitura inválida de tamanho 1. E isso também parece estar aqui, parece, na linha 11 de memory.c. E
então, se eu continuar rolando, continue rolando, continue rolando, Eu não estou gostando disso. 3 bytes em 1 bloco são definitivamente perdidos no registro de perda, seja ele qual for. Mas três bytes em 1 bloco estão definitivamente perdidos. E então aqui embaixo, resumo do vazamento, definitivamente perdido, 3 bytes em 1 blocos. Aliás, 1 blocos, obviamente não é a gramática certa. Isso é o que acontece quando seu programa não tem uma condição if que verifica se o número é 1 ou positivo ou 0. Você poderia corrigir isso, gramaticalmente, honestamente, com uma condição if simples. Eles não o
fizeram quando escreveram este programa anos atrás. Portanto, há dois ou três erros aqui. Um é algum tipo de leitura ou gravação inválida. E outro é esse vazamento. Bem, o que é uma escrita? Uma gravação refere-se apenas à alteração de um valor. Uma leitura refere-se apenas à leitura, uso ou impressão de um valor. Então, vamos nos concentrar na linha 10. Se eu rolar de volta para o meu código e olhar a linha 10, esta foi uma gravação inválida, gravação inválida. Bem, por que é inválido? Bem, pela definição de hoje, se você estiver alocando 3 bytes, você
pode tocar no primeiro byte, o segundo byte e o terceiro byte. Mas você não tem que tocar no quarto byte se você pediu apenas três. Isso é como uma versão em pequena escala do muito aventureiro e inapropriado modo em que entrei, bisbilhotando, quando olhei para 10.000 bytes adiante. Mesmo olhar a um byte de distância é um bug em potencial e pode causar o travamento de um programa. Enquanto isso, a linha 11 também é problemática, o que é uma leitura inválida, porque agora, você está dizendo para imprimir esta string. Mas essa string contém um endereço de
memória que você não deveria ter tocado em primeiro lugar. E o vazamento de memória, o terceiro problema, decorre do fato que não liberei essa memória. Então, novamente, vai precisar de alguma prática e experiência, alguns erros seus, para perceber e entender esses bugs. Mas deixe-me corrigir os dois primeiros assim. Vou criar quatro bytes. E deixe-me consertar o segundo ou o terceiro, ao liberar s bem no final, porque, novamente, sempre que você usa malloc você deve usar free. Eu vou recompilar a memória, parece compilar. Vamos executá-lo novamente, ainda funciona da mesma forma, visualmente. Mas agora, vamos executar
novamente o valgrind nele e ver se há algum erro agora, então valgrind ./ memory, Enter. A saída ainda parecerá muito enigmática. Mas observe que todos os blocos de heap foram liberados, seja lá o que isso signifique. Nenhum vazamento é possível. Na verdade, não fica mais explícito do que isso. Isso é uma coisa boa. E se eu rolar para cima, não vejo nenhuma menção a essas leituras ou gravações inválidas. Então, começando com os problemas desta semana e os da próxima semana em C, você não só vai querer usar ferramentas como help50 e printf e debug50 e
check50, mas mesmo se você achar que seu código está certo, a saída parece certa, você pode ter um bug latente. E mesmo quando seus programas são pequenos, não travando o computador, Sem causar essa falha de segmentação, eventualmente, eles vão. E é melhor usar ferramentas como esta para perseguir esses erros. Caso contrário, coisas ruins podem acontecer. E o que pode acontecer? Bem, deixe-me ir em frente e revelar um exemplo aqui Que apresenta algum código que é um pouco perigoso. Então aqui, por exemplo, é um exemplo onde estou declarando no topo da função, int asterisco x e
int asterisco y. Então, o que isso significa? Bem, pela linguagem de hoje, isso significa apenas me dê um ponteiro para um inteiro chamado x. Dê-me um ponteiro para um inteiro chamado y. Dito de outra forma, dê-me uma variável chamada x que eu possa armazenar o endereço de um int. Dê-me uma variável chamada y na qual posso armazenar o endereço de outro int. Mas observe o que não estou fazendo nessas duas primeiras linhas. Na verdade, não estou atribuindo a elas um valor até a linha 3. Na linha 3, embora isso seja estranho - não é assim
que alocamos espaço para inteiros antes - não há razão para que você não possa usar malloc e diga, dê-me espaço suficiente para o tamanho de um inteiro. sizeof é novo. É apenas um operador em C que informa o tamanho de um tipo de dados, como o tamanho de um int. Então, talvez você tenha esquecido que um int é 4. E, um int é geralmente 4, mas nem sempre 4 em todos os sistemas. Portanto, o tamanho de int só garante que sempre fornecerá a resposta certa, se você está usando um computador moderno ou antigo. Então, isso
significa, alocar 4 bytes para mim em um sistema moderno. E armazena o endereço do primeiro byte em x. Alguém se importaria de traduzir para termos leigos, o que asterisco x igual a 42 está fazendo? Asterisco, novamente, é o operador de desreferência. Significa ir para o endereço. E fazer o que? Como você descreveria, com um comentário verbal, o que asterisco x igual a 42 está fazendo? Brian, você se importaria de verbalizar algum pensamento? BRIAN: Sim, então Sofia sugeriu que nesse endereço, colocaremos o 42. DAVID MALAN: Perfeito. Nesse endereço, coloque 42. Equivalentemente, vá para aquele endereço em
x e coloque o número 42 lá. É como ir à caixa de correio de Brian e colocar o 42 em sua caixa de correio, em vez do que tínhamos anteriormente, que era o número 50. Que tal esta próxima quinta linha, asterisco y é igual a 13? Brian, você poderia verbalizar outra pessoa? O que asterisco y igual a 13 faz por nós? E não é por acaso que 13 tende a ser azarado. BRIAN: Peter diz, coloque 13 no endereço y. DAVID MALAN: Bom, coloque 13 no endereço em y. Ou dito de outra forma, vá para o
endereço em y e coloque 13 lá. Mas há um problema lógico aqui. O que está em y? Se eu retroceder, nunca atribuo um valor a y. Eu não faço inicialmente, e eu não faço eventualmente. Pelo menos com x, embora eu não tenha dado um valor ao declará-lo aqui como uma variável, acabei armazenando nela o endereço real. Agora, apenas para ser minucioso, eu provavelmente deveria, neste programa, verificar em nul caso algo dê errado. Mas esse é um problema totalmente diferente. É um problema mais terrível que eu sequer dei um valor a y. E é aqui que
podemos revelar outro detalhe sobre um computador. Até agora, consideramos que você e eu quase sempre inicializamos nossa memória. Se quisermos nos dar um char, um int, uma string, Nós literalmente digitamos no programa para que esteja lá quando quisermos. Mas se considerarmos esta imagem aqui, que agora é uma encarnação física de alguns dos conteúdos da memória do seu computador, divertidamente rotulada com muito Oscars, isso é porque você nunca deve confiar no conteúdo da memória do seu computador se você mesmo não colocou algo lá. Existe um termo técnico em programação chamado valores de lixo. Se você mesmo
não colocou um valor em algum lugar da memória, você deve assumir, para estar seguro, que é "valor de lixo". Não é um valor estranho. É apenas 1, 2, um A, a B, o C, você apenas Não sabe o que é, porque se o seu programa está rodando e você está chamando funções e funções estão retornando. Você está chamando outras funções e as funções estão retornando. Esses valores na memória do seu computador estão mudando constantemente, e sua memória é reutilizada. Quando você libera memória, isso não a apaga ou define tudo de volta para zero ou define
tudo de volta para 1's. Ele apenas deixa estar para que você possa reutilizar isso, o que significa com o tempo, seu computador contém resquícios de todas as variáveis que você já usou em seu programa aqui, aqui, e lá. E dessa forma, em um programa assim, onde você não inicializou explicitamente y A qualquer coisa, você deve presumir que Oscar, por assim dizer, está nesse local. É um valor lixo que se parece com um endereço, mas não é um endereço válido. E então, quando você diz asterisco y é igual a 13, isso significa ir para esse endereço.
Mas, vá para aquele endereço falso e coloque algo lá. E as chances são de que seu programa irá falhar. Você vai ter uma falha de segmentação, porque indo para algum endereço de valor de lixo arbitrário, seria como pegar um pedaço de papel aleatório com um número e então indo para essa caixa de correio. Por quê? Isso pertence a você. Se você tentar cancelar a referência de uma variável não inicializada, seu programa pode muito bem travar. E isso é, talvez, não melhor apresentado do que por alguns de nossos amigos, Nick Parlante, um professor em Stanford Universidade
que dá vida a um caractere em claymation conhecido como Binky. Temos um clipe de 2 minutos disso que mostra o quadro das coisas ruins acontecendo quando você toca a memória que você não deveria. Felizmente, um lembrete útil sobre o que fazer e o que não fazer com os ponteiros. Aqui vamos nós. [REPRODUÇÃO DE VÍDEO] - Ei, Binky. Acorde, é hora de se divertir com o ponteiro. - O que é aquilo? Aprender sobre ponteiros? Oh, que bom! - Bem, para começar, acho que vamos precisar de algumas dicas. - OK, este código aloca dois ponteiros que podem
apontar para inteiros. - OK, bem, vejo as duas dicas. Mas eles não parecem estar apontando para nada. - Isso está certo. Inicialmente, os ponteiros não apontam para nada. As coisas para as quais eles apontam são chamadas de pontas. E configurá-las é uma etapa separada. - Oh, certo, certo. Eu sabia. As pontas são separadas. Então, como você aloca uma ponta? - OK, bem, este código aloca uma nova ponta inteira. E esta parte define x para apontar para ele. - Ei, isso parece melhor. Então faça algo. - OK, vou desreferenciar o ponteiro x para armazenar o número
42 em sua ponta. Para este truque, vou precisar da minha varinha mágica de desreferenciação. - Sua varinha mágica de desreferenciação? Isso é ótimo. - É assim que o código se parece. Vou apenas configurar o número e - - Ei, olha, aí vai. Portanto, fazer uma desreferenciação em x segue a seta para acessar sua ponta. Nesse caso, para armazenar 42 ali. Ei, tente usá-lo para armazenar o número 13 por meio do outro ponteiro, y. - OK. Vou apenas ir aqui para y e obter o número 13 configurado e, em seguida, pegar a varinha de desreferenciação e
apenas - uau! - Oh, ei, isso não funcionou. Diga, Binky, não acho que desreferenciar y seja uma boa ideia, porque configurar A ponta é uma etapa separada. E acho que nunca fizemos isso. - Hmm, bom ponto. - Sim, alocamos o ponteiro y. Mas nunca o definimos para apontar para uma ponta. - Hmm, muito observador. - Ei, você está bem aí, Binky. Você pode corrigi-lo de forma que y aponte para a mesma ponta de x? - Claro, vou usar minha varinha mágica de atribuição de ponteiro. - Isso vai ser um problema como antes? - Não, isso
não toca nas pontas. Ele apenas muda um ponteiro para apontar para a mesma coisa que outro. - Oh, entendi. Agora, y aponta para o mesmo lugar que x. Então espere, agora y está consertado. Tem uma ponta. Portanto, você pode tentar a varinha de desreferenciação novamente para enviar o 13. - Ah ok. Aqui vai. - Ei, olha isso. Agora, o desreferenciação funciona em y. porque os ponteiros estão compartilhando aquele ponto, ambos veem o 13. - Sim, compartilhando, tanto faz. Então, vamos trocar de lugar agora? - Oh, olhe, estamos sem tempo. - Mas-- [FIM DA REPRODUÇÃO] DAVID
MALAN: Tudo bem, então não estamos muito sem tempo. Mas vamos prosseguir e fazer nosso segundo intervalo de 5 minutos aqui. E quando voltarmos, daremos uma olhada mais de perto do Oscar e muito mais. De volta em 5. Tudo bem, então eu afirmo que há todo esse lixo de valores na memória do seu computador. Mas como você pode vê-los? O que Binky fez foi, claro, tentar cancelar a deferência de um valor de lixo Quando coisas ruins acontecem. Mas podemos ver isso com nosso próprio código. Então, agora eu vou preparar um pequeno programa aqui, como algo que
fizemos na primeira ou segunda semana, mas sem fazer muito bem. Eu vou incluir o padrão io ponto h, como de costume, int main void. E então agora eu vou dar a mim mesmo uma série de scores. Que tal uma série de três scores? E já fizemos isso antes, quando coletamos as scores de um usuário. Mas desta vez, vou fazer deliberadamente o erro de não inicializar essas scores ou mesmo pedindo ao humano por essas scores. Vou continuar repetindo cegamente de i igual a 0 até 3. E em cada iteração, vou imprimir presunçosamente o que quer que
seja naquele local na faixa de score i. Então, logicamente, meu código está correto no que está tentando fazer, imprimir os valores em scores. Mas note que eu deliberadamente não inicializei nenhuma das scores 1, 2, 3 nesse array. Então, quem sabe o que vai estar lá? Na verdade, devem ser valores de lixo de algum tipo que não poderíamos necessariamente prever antes. Então, agora eu vou fazer lixo, uma vez que este programa está em um arquivo chamado garbage.c. Compila OK, mas quando eu agora rodo garbage, nós devemos ver três scores, que são cripticamente negativas, 833060864. Outro é
32765. E o terceiro simplesmente é 0. Então, existem esses valores de lixo, porque novamente, o computador não inicializará nenhum desses valores para você. Agora, existem exceções. Temos, na ocasião, usou uma variável global, uma constante que está fora do contexto de principal e de todas as minhas outras funções. Variáveis globais, se você não defini-las, são inicializados convencionalmente como 0 ou nul para você. Mas você geralmente não deve confiar nesse tipo de comportamento. Seu instinto deve ser sempre inicializar valores antes de pensar em tocá-los ou lê-los como via printf ou algum outro mecanismo. Tudo bem, vamos ver
como esse entendimento, agora, de memória, pode nos levar a resolver problemas, mas também encontrar novos tipos de problemas, mas problemas que agora podemos entender. Vou prosseguir e criar um novo programa aqui. E lembre-se da semana passada que era muito comum querermos trocar valores. Quando Brian estava fazendo nossa classificação por nós, fosse seleção ou bubble sort havia muitas trocas acontecendo. Mesmo assim, não escrevemos nenhum código para esses algoritmos. E isso é bom. Mas vamos considerar aquele primitivo muito simples de apenas trocar dois valores, por exemplo, trocando dois inteiros. Vamos prosseguir e iniciar um programa e swap.c
aqui. Vou incluir o padrão io ponto h, int main void. E dentro do principal, vou me dar dois inteiros. Vou criar um int chamado x e atribuir a ele 1, um int chamado y e atribuir 2. E então agora eu vou imprimir quais são esses valores. Direi apenas, x é percentual i vírgula y é percentual i \ n. E então prosseguirei e imprimirei x vírgula y, respectivamente. E então, eventualmente, irei escrever uma função chamada Swap que troca x e y. Mas vamos supor, por enquanto, que exista. Não existe, porque o que então eu quero fazer
o certo depois disso, é reimprimir a mesma coisa, x agora é % i, y é % i, minha suposição é que os valores de x e y serão trocados. Então, como posso trocar esses dois valores? Bem, deixe-me seguir em frente e implementar minha própria função. Não acho que precise retornar nada, então direi void é o tipo de retorno. Vou chamar de swap. Terá dois argumentos como entrada. Vamos chamar de a e b, ambos inteiros. Mas eu poderia chamar do que eu quiser. Mas a e b parecem razoáveis. E agora, quero ir em frente e trocar
dois valores. Agora, Brian estava fazendo isso com as duas mãos na semana passada. E isso é bom, mas provavelmente devemos considerar isso um pouco mais de perto. Na verdade, Brian, em vez de números, vamos faça algo um pouco mais do mundo real. Acho que você tem algumas bebidas na sua frente. BRIAN: Sim. Então, bem aqui, eu tenho um vidro vermelho e um vidro azul, que acho que podemos usar para representar duas variáveis, por exemplo. DAVID MALAN: Sim. Agora, deixe-me supor - Eu gostaria de ter contado a você antes. Na verdade, prefiro que o líquido vermelho
seja no vidro azul e o líquido azul no vidro vermelho. Então você se importa em trocar esses dois valores, assim como você trocou de números na semana passada? BRIAN: Sim, claro. Então, posso apenas pegar os dois copos, e posso trocar de lugar. DAVID MALAN: OK, espere, OK, isso não é exatamente - você me interpretou muito literalmente. Acho que aqui, se pensarmos no copos, agora, como locais específicos Na memória, você não pode apenas mover fisicamente os chips de memória dentro do seu computador para trocar coisas. Acho que literalmente preciso que você mova o líquido azul no
vidro vermelho e o líquido vermelho no vidro azul para que seja mais como a memória de um computador. BRIAN: OK, posso tentar fazer isso. Estou um pouco nervoso, no entanto, porque eu sinto que não posso simplesmente despejar o líquido azul no vidro vermelho, porque o líquido vermelho já está lá. DAVID MALAN: Sim, então isso provavelmente não termina bem, se ele tem que fazer algum tipo de troca entre os dois copos. Então, alguma ideia aqui? Como qual é a solução do mundo real para este problema estranho, mas real, onde queremos trocar o conteúdo desses dois locais,
assim como Brian estava trocando o conteúdo de dois locais de memória na semana anterior? Brian, se você estiver de olho no chat em paralelo, alguém poderia ter ideias sobre como poderíamos trocar esses dois líquidos? BRIAN: Sim, algumas pessoas estão dizendo que preciso de um terceiro copo. DAVID MALAN: Tudo bem, bem Brian, você por acaso tem um terceiro copo com você atrás do palco? BRIAN: Na verdade, acho que sim. Então, eu tenho um terceiro copo aqui que por acaso está vazio. DAVID MALAN: OK. E como você faria para trocar essas duas coisas? BRIAN: Tudo bem, então
eu quero colocar o líquido azul dentro do copo vermelho. Então, a primeira coisa que preciso fazer, eu acho, é esvaziar o copo vermelho para dar espaço ao líquido azul. Vou pegar o líquido vermelho e só vou despejá-lo neste copo extra. DAVID MALAN: Mas temporariamente, certo? BRIAN: Temporariamente, sim. DAVID MALAN: OK. BRIAN: Só para guardar aí. E agora, acho que posso apenas derramar o líquido azul no vidro vermelho original, porque agora estou livre para fazer isso. Então, vou derramar o líquido azul ali. E acho que a última coisa que preciso fazer agora é, agora este azul
- este copo que originalmente continha o líquido azul agora está vazio. Então, o líquido vermelho, que estava dentro deste vidro temporário aqui, Posso pegar o líquido vermelho e apenas despejá-lo neste copo aqui. E agora, não troquei as posições dos copos. Mas os líquidos trocaram de lugar. Agora, o líquido azul está à esquerda e o líquido vermelho está à direita. DAVID MALAN: Incrível. Sim, acho que é uma implementação mais literal do que você estava fazendo e dando como certo na semana passada, Trocando os dois valores em dois locais separados. Portanto, parece muito simples. Só preciso de
um pouco mais de espaço. Preciso de uma variável temporária no código. E parece que preciso de três etapas. Eu preciso derramar um, despejar o outro fora, despejar o outro de volta. Então, acho que posso traduzir isso em código aqui. Eu vou me dar uma variável temporária, como um copo, como Brian fez. E vou chamar de tmp, T-M-P, o que é bem convencional quando é melhor trocar duas coisas no código. E eu vou assinar, temporariamente, o valor de a. Vou então alterar o conteúdo de a para igual a qualquer que seja o conteúdo de B E
então vou mudar b para ser qualquer que fosse o conteúdo de tmp. Isso parece bastante razoável e correto, porque é uma tradução literal em código, agora, do que Brian fez no mundo real. E acho que isso vai compilar. Então, vamos começar por aí, fazer a troca. Ele -- não compila. OK, declaração implícita anterior, tantos erros, meu Deus. Declaração implícita de troca de função - espere um minuto. Eu já vi isso antes. Já cometi esse erro antes. Você também pode ter cometido. Sempre que vir isso, lembre-se de que está faltando seu protótipo. Lembre-se de que o
compilador irá interpretá-lo literalmente. E se ele não souber que a palavra troca existe quando a vir, não vai ser compilado com sucesso. Portanto, precisamos incluir meu protótipo no topo do meu arquivo. Agora, deixe-me tentar novamente, make swap. OK, isso compila. Vou continuar agora e executar o swap e relembrar que, em geral, o que eu fiz foi inicializado x para 1, y para 2. Em seguida, imprimo o que é x e o que é y. Eu chamo swap e imprimo o que é x e y novamente. Devo ver 1, 2 e 2, 1. Então, vamos apertar
Enter. Huh, não parece estar funcionando. Bem, vamos tentar novamente, apenas no caso - não, não está funcionando. Bem, deixe-me tentar isso. Vamos adicionar alguns-- printf é meu amigo. Vamos prosseguir e dizer que a é % i. b é a % i \ n, a, b. Então, vamos imprimir isso. E vamos imprimir isso duas vezes. Portanto, esta seria uma técnica de depuração razoável. Se você quiser saber o que está acontecendo por baixo do capô, adicione alguns printf's. Eu vou fazer make swap. Isso compila, ./swap. E vamos ver, a é 1, b é 2, a é 2,
b é 1. Mas então x e y permanecem inalterados. Então eu sinto que minha lógica está certa. Está trocando a e b. Mas, na verdade, não está trocando x e y. E eu poderia confirmar isso, certo? A maneira mais poderosa de depurar isso seria Executar debug50, definir um ponto de interrupção, por exemplo, na linha 17, percorrer meu código, passo a passo, entrando na função swap. Mas, por enquanto, parece claro que a troca funciona. Mas o main não está vendo esses resultados. Então, o que está acontecendo? Bem, vamos considerar esta encarnação do mundo real do que
minha memória é para que eu possa mover as coisas. E tudo isso graças aos nossos amigos na loja de acessórios do teatro nos fundos. Se pensarmos nisso como a memória do meu computador, inicialmente, são todos valores de lixo. Mas posso usar isso como uma tela para começar a projetar as coisas na memória. Mas chamar funções é algo que achamos ser algo fácil e tranquilo, até aqui. E acontece que, quando você chama funções, o computador, por padrão, usa essa memória de uma forma padrão. Na verdade, agora eu vou fazer um desenho mais gráfico. Vamos desenhar uma
imagem mais literal aqui, se assim preferir, da memória do computador novamente. Então, se esta for a memória do computador e fizermos zoom em um dos chips, e pensamos no chip como tendo um monte de bytes assim. Vamos abstrair o hardware real e pensar nele como sempre foi. É apenas esta grande região retangular da memória, não muito diferente de todos aqueles Oscars de um momento atrás. Mas, por convenção, seu computador não fica apenas inserindo coisas em locais aleatórios na memória. Ele segue certas regras básicas. Em particular, ele trata diferentes partes da memória do seu computador de
maneiras diferentes. Ele o usa de uma maneira padrão para que não seja completamente aleatório. Por exemplo, quando você executa um programa fazendo alguma ./ no IDE CS50 ou no Linux de forma mais geral, ou você clica duas vezes em um ícone no Mac OS ou Windows, que aciona o computador - os 0's e 1's do programa armazenados no seu disco rígido para serem carregados aqui, ao que chamaremos de código de máquina, que, novamente, são os 0's e 1's. Então, se você pensar novamente, metaforicamente, como sua memória é esta região retangular, então o código de máquina,
os 0's e 1's que compõem seu programa são carregados na parte superior da memória. E, novamente, superior, inferior, esquerda, direita, não tem nenhum significado técnico fundamental. É apenas uma representação técnica. Mas ele vai para um local padrão. Abaixo disso estão todas as suas variáveis globais. O mesmo ocorre com as constantes que você coloca fora de suas funções. Isso vai acabar logo abaixo do código de máquina, novamente, no topo da memória do seu computador. Abaixo disso está o que é chamado de heap. E este é um termo técnico. E se refere a um grande pedaço de
memória que malloc usa para obter alguma memória sobressalente. Sempre que você chamar malloc, você recebe o endereço de algum pedaço de memória Sobre nesta região, abaixo do código de máquina, abaixo de suas variáveis globais. E é uma zona grande. Mas o problema é que outras partes da sua memória são usadas de maneira diferente. Na verdade, embora a pilha seja considerada aqui embaixo, um pouco preocupantemente, a pilha é considerada aqui para cima. Ou seja, quando você chama malloc e pede memória, que é alocado aqui. Quando você chama uma função, embora, essas funções usem o que é
chamado de espaço de pilha em vez de espaço de pilha. Então, sempre que você chamar uma função, main ou swap ou strlang ou string compare ou qualquer uma das funções que você usou até agora, seu computador irá armazenar automaticamente qualquer Das variáveis locais ou parâmetros dessas funções aqui. Agora, este não é necessariamente o melhor design, porque você pode ver as duas setas apontando para uma outra - é como dois trens correndo pelos trilhos um contra o outro. Coisas ruins podem acontecer. Felizmente, normalmente temos memória suficiente para que essas duas coisas não colidam, mas mais nisso
daqui a pouco. Então, novamente, quando você chama funções, a memória aqui embaixo é usada. Quando você usa malloc, a memória aqui é usada. Agora, para minha função swap, eu não estou usando malloc. Então eu não acho que tenho que me preocupar com a pilha. E eu não tenho nenhuma variável global. E eu não me importo com meu código de máquina. Eu só preciso saber se está armazenado em algum lugar. Mas vamos considerar, então, do que se trata a pilha. A pilha, é esse tipo de lugar dinâmico onde a memória continua sendo usada e reutilizada. Então,
por exemplo, quando você chama main, como você faria quando swap roda, main usa uma porção de memória na parte inferior da imagem, se preferir. Portanto, as variáveis locais principais, como x e y, acabam nesta parte inferior da memória. Quando você chama o swap, o swap usa um pedaço de memória logo acima do principal, neste diagrama, como as variáveis a e b e temp, para essa ação. E então, uma vez que o swap retorna e termina a execução, aquele pedaço de memória vai embora. Agora, ele não desaparece. Obviamente, ainda há memória física lá. Mas é aí
que entramos na discussão dos valores lixo novamente. Eles ainda são como Oscar por toda parte. Você simplesmente não sabe, ou neste ponto nem se importa, quais são os valores. Mas existem valores aí. E é por isso que, um momento atrás, quando imprimi aquele array scores não inicializado, eu vi alguns valores falsos, porque ainda vai haver 0's e 1's que sobraram de antes. O problema, porém, é este. Vamos passar para esta encarnação física de nossa memória e considero isso como sendo nossa pilha, por isso está crescendo. E, se eu quiser ter duas variáveis locais como eu
faço, x e y, vamos prosseguir e pensar nesta linha de memória aqui como sendo main, por exemplo, aqui. E vou prosseguir e substituir todos esses valores de lixo com um valor real pelo qual me preocupo. E os valores reais que me interessam, vamos chamar x e y, assim como antes. Portanto, cada um desses Oscars tem um byte. Mas um int tem 4 bytes. Felizmente, de nossos amigos da loja de presentes, Temos esses blocos maiores de tamanho inteiro. E vou prosseguir e inserir isso aqui. E vamos pensar nisso, em um momento, como x. E, vou prosseguir
e chamar esse x com um marcador. E então vou criar outro número inteiro, um tamanho 4, e colocar aqui. E vamos pensar nisso como y. E lembre-se, como eu inicializo esses valores? Bem, o valor 1, inicialmente, e o valor 2. Mas então chamei a função swap. E a função swap tem dois argumentos, a e b. E esses, por design, tornam-se cópias de x e y, porque passei x vírgula y. E eu defini troca como uma vírgula b. Acho que o que preciso fazer, fisicamente aqui, e agora pense nesta segunda linha de memória como agora pertencente
à função swap, não para main. E dentro desta segunda linha de memória, eu irei pensar nisso como pertencendo a uma troca. E dentro da linha de troca, terei outro inteiro de tamanho 4. E vamos chamar este aqui de a. E então terei outro pedaço de tamanho 4. E vamos chamar isso de b. E, novamente, porque esses são apenas os argumentos, x vírgula y, caso contrário agora conhecido como vírgula b, copio 1 e 2 nesses valores. Mas swap tem uma terceira variável. Brian propôs uma variável temporária. Vou criar mais quatro bytes, assim, livrando-se de qualquer valor
de lixo que esteja lá e configurá-la para uma chamada de número inteiro tmp. Portanto, vou prosseguir e chamar isso de tmp, T-M-P. E o que eu fiz primeiro? Defino tmp igual a a. Portanto, tmp é igual a a. Portanto, se a for 1, tmp será 1. Então o que eu fiz? Então fiz a é igual a b. Portanto, b é 2. a também é 2. E então, por último, o que eu fiz? Eu fiz b get tmp. Então eu tenho que ir em frente e mudar isso para qualquer valor de tmp, que agora é o
número 1. Então você pode ver que a troca está correta na medida em que está trocando os valores de a e b. Mas no momento em que o swap retorna, estes retornam a ser pensados como valores de lixo. Main ainda está no meio da execução. A troca não está mais em execução. Mas esses valores permanecem lá. Portanto, esses são valores de lixo. Acontece que sabemos o que são, mas eles não são mais válidos, porque quando vou imprimir x e y pela segunda vez, o que são x e y? Eles ainda são os mesmos. E isso
quer dizer, quando você escreve um código que leva argumentos e você passa argumentos de uma função para outra, esses argumentos são copiados de uma função para outra. E, x e y são copiados em a e b. Portanto, seu código pode muito bem parecer correto por estar alternando corretamente. Mas só está trocando corretamente no contexto de troca, não tocar nos valores originais. Então, o que acho que precisamos fazer, fundamentalmente, é reimplementar a troca de forma que altere os valores de x e y. Mas como podemos fazer isso? Brian, se pudéssemos chamar alguém aqui. Como eu poderia
mudar conceitualmente minha implementação de swap para que de alguma forma me capacite a alterar x e y, não alterar cópias de x e y? O que eu poderia passar para swap, Brian? BRIAN: Igor está sugerindo que usemos ponteiros em seu lugar. DAVID MALAN: Sim, talvez a questão principal aqui hoje. Mas as dicas parecem nos dar uma solução. Se os ponteiros são como um mapa do tesouro Apontando para um endereço específico na memória do seu computador, o que eu deveria fazer a partir do main para swap é passar não x e y literalmente, mas por que
não passo o endereço de x e o endereço de y, para que a troca agora possa ir para esses endereços e fazer o tipo de troca que Brian fez pessoalmente. Então, dê à função uma espécie de mapa para esses valores, ponteiros para esses valores, e depois vá para esses valores. Então, como posso fazer isso? Bem, o código tem que ser um pouco diferente agora. Quando eu chamo swap desta vez, o que eu preciso fazer é passar os endereços dessas duas variáveis. Portanto, não sei necessariamente quais são esses endereços. Mas pelo bem da história, podemos apenas
supor que este endereço, por exemplo, é como 0x123. E então quatro bytes de distância disso podem ser 0x127, por exemplo. Mas, novamente, não importa o que seja. Mas têm endereços, x e y. Portanto, uma chamada de ponteiro tende a ser muito grande. Então, precisávamos pegar um pedaço maior de madeira, oito bytes que representam um ponteiro. E, na verdade, preciso usar um pouco mais de memória no swap agora. Se eu declarar que a é, não um número inteiro, mas um ponteiro para um int, essa é uma variável int*, Eu poderia chamar isso de agora. E eu
poderia armazenar, nela, o endereço de x, como 0x123. Se eu mudar a definição de b para ser não um inteiro, mas um ponteiro para um inteiro, essa é outra int*, que por acaso tem oito bytes. Vou usar um pouco mais de memória para isso, mas tudo bem. E seu nome vai ser b agora. E vai conter 0x127. Ainda preciso de uma variável temporária. Ainda preciso de uma variável temporária, mas tudo bem. Eu só preciso de quatro bytes para isso, porque a variável em si só precisa armazenar um int, como Brian o guardou temporariamente em um
copo. Então, eu só preciso de quatro bytes adicionais, como antes, para isso. E agora, vamos apenas considerar a lógica. Aqui está o main. E o swap agora está usando essas 3 - 2 e 1/2 linhas de memória. E isso é bom. Está crescendo conforme eu propus. X está no endereço 0x123. y está no endereço 0x127. Portanto, a e b, proponho conceitualmente, como Igor propôs, armazene os endereços de a, x e y, respectivamente. E agora meu código, eu acho, precisa dizer isso. Vá e armazene, na variável tmp, o que quer que esteja no endereço a. Então
você pode pensar nisso como uma flecha aqui embaixo. Siga a seta, OK. O que está no endereço 0x123? O número 1. Então colocamos um no tmp, assim como antes. Então o que vamos fazer? Bem, agora, vou prosseguir e mudar, não o valor de um, mas vou mudar o que está no local para ser o que quer que esteja no local em b, que é uma seta apontando para baixo aqui, 0x127. Vou mudar este 1, agora, para um 2. E a terceira e última etapa, lembre-se, é para mim, agora, ir, não para b, mas para ir
para onde b aponta, que por acaso é y, E mudar para o valor de tmp, que é claro, está aqui em cima. E neste ponto da história, ainda são apenas três linhas de código. São diferentes tipos de linhas de código. São três linhas de código. Mas quando swap termina a execução, observe o que fizemos. Trocamos x e y com sucesso, permitindo que swap vá para esses endereços em vez de apenas obter ingenuamente cópias dos valores nele contidos. Agora, embora este código pareça um pouco enigmático, é uma aplicação da lógica que vimos até agora. Vou prosseguir
e voltar para a minha versão antiga com erros. E vou mudar a definição de swap Para dizer que não são necessários dois inteiros, a e b, mas dois ponteiros para inteiros a e b. E a forma como você declara um ponteiro, lembre, é o tipo de variável que você aponta para, seguida por um asterisco e então o nome dela. E nós não vimos isso, reconhecidamente, no contexto de uma função que leva parâmetros ainda. Mas é simplesmente isso. Eu adicionei os asteriscos. Aqui embaixo, preciso dizer, armazenar em tmp, o que quer que esteja em a. Como
faço para expressar "vá para a"? Basta adicionar uma asterisco aqui. Como expresso "vá para a" e coloco o que quer que esteja em b? Eu adiciono asteriscos lá. Como posso dizer para ir para b e armazenar o que quer que esteja em tmp? Eu adiciono uma asterisco aqui. Portanto, tmp é um número inteiro simples. É apenas um copo vazio como o de Brian. Não há nada sofisticado aí. Portanto, não precisamos de asteriscos em torno de tmp. Mas agora preciso mudar a forma como estou usando a e b, porque agora são endereços aonde eu quero ir.
Não há necessidade de endereço do operador neste contexto. Mas aqui em cima, vou precisar fazer uma mudança. Eu preciso mudar o protótipo para corresponder. Então isso é copiar e colar. Mas aposto que você pode imaginar o que, por último, precisa mudar. Ao chamar swap, não quero passar ingenuamente x e y, porque, novamente, serão copiadas. Eu quero passar o endereço de x e o endereço de y, então essa troca agora tem uma espécie de acesso especial para o conteúdo desses locais na memória para que possa fazer algumas alterações. E que, se eu recompilar este programa agora,
make swap, e eu .swap, e cruzo meus dedos. Voila. Agora, eu troquei com sucesso as linhas de código. Então, na semana passada, se você estivesse se perguntando, talvez, Por que não mostramos como fazer a troca, poderíamos ter feito. E não precisamos de uma função especial. Você não precisa necessariamente de ponteiros se fizermos tudo isso no main. Mas estou tentando introduzir uma abstração, esta função que troca exatamente como o Brian trocou os copos por nós. E para passar valores de uma função para outra, você precisa entender o que está acontecendo na memória do seu computador para
que você possa passar pequenas migalhas de pão novamente, mapas do tesouro para esses locais e memórias, mais uma vez, graças a essas coisas chamadas ponteiros. Tudo bem, deixe-me propor e enfatizar, então, que este desenho da pilha estando no topo, Onde malloc usa memória e a pilha sendo na parte inferior, onde suas próprias funções usam memória, este é um problema claramente esperando para acontecer. E esses problemas têm nomes. E alguns de vocês que já programaram antes pode conhecer alguns desses termos, heap overflow, estouro de pilha ou stack overflow. E, muitos de vocês devem conhecer stackoverflow.com apenas
como um site. Bem, há uma história de origem em seu nome. Um estouro de pilha se refere ao processo de chamar uma função tantas vezes que transborda a pilha. Ou seja, toda vez que você chama a função, como eu fiz aqui, você usa cada vez mais linhas, por assim dizer, de memória. E se você chamar tantas funções de novo e de novo, eventualmente, você pode muito bem correr sobre a área da memória chamada heap. E nesse ponto, seu programa irá travar. Não há solução fundamental para esse problema além de não fazer isso. Não use muita
memória. Mas isso pode ser difícil de fazer. E, esse é um dos perigos da programação hoje. E podemos induzir isso um pouco deliberadamente. E, na verdade, pensei que poderíamos revisitar, por exemplo, onde paramos com o Mario da última vez, que foi essa foto aqui. Lembre-se de que esta era uma pirâmide, é claro, mais simples do que aquela com a qual você pode ter brincado nos problemas da semana 0. Mas é uma pirâmide recursiva em que você pode definir uma pirâmide de altura 4, em termos de uma pirâmide de altura 3, em termos de uma pirâmide
de altura 2 e uma altura 1. E, eu construí isso na semana passada usando esses mesmos blocos. Bem, você pode implementar a pirâmide do Mário assim de algumas maneiras diferentes. Uma deles é usar apenas a iteração de estilo da semana um, usando um loop. E, na verdade, deixe-me ir em frente e criar uma solução rápida que faz exatamente isso. Eu vou chamar isso de mario.c. E vou prosseguir e incluir cs50.h. Portanto, podemos usar uma de nossas funções get. Vou usar o padrão io ponto h. E vou fazer o main void. E tudo que eu quero
fazer é imprimir esta pirâmide. Mas quero perguntar ao usuário a altura. Portanto, vou dizer que int height é igual a get int. E pediremos ao usuário a altura, assim como você fez para o conjunto de problemas 1. E então vou seguir em frente e desenhar uma pirâmide dessa altura. Agora, o desenho não existe. Mas tudo bem. Vou seguir em frente e desenhar isso agora, implementar o desenho sozinho. Não precisa retornar um valor, porque estou apenas imprimindo coisas na tela. A função é chamada de draw, e vai pegar uma entrada chamada h, por exemplo. h para
altura, mas eu poderia chamar seu argumento do que eu quiser. E então eu vou apenas fazer isso, para int eu recebo 1, i menor ou igual a h, i++. E, dentro disso, é aqui que você deve se lembrar, do conjunto de problemas um, descobriu que um loop aninhado é útil. Vou fazer int j gets 1, j menor ou igual a i, j++. Isso será semelhante, mas não idêntico a mais confortável versão de Mario do passado, porque esta pirâmide é moldada em uma direção diferente. Agora, você imprime um hash. E então agora eu vou imprimir uma
nova linha aqui. Então eu fiz isso super rápido. Mas logicamente, o que estou fazendo está iterando em todas as linhas, de 1 a h, portanto, linhas 1, 2, 3, 4, por exemplo. E então, em cada linha, estou deliberadamente iterando de 1 a i. Então, imprimo 1, 2, 3 e 4. E, novamente, posso zerar o índice. Acho que, neste contexto, é mais amigável, mais inteligível para mim indexar de 1, totalmente razoável se você pensar que há um argumento de design atraente. Então agora eu vou fazer make Mario. Ah, droga. Oh, eu perdi meu protótipo. Então observe,
não está entendendo draw. Então, a solução para isso é mover toda a função ou, como já pregamos, apenas colocar seu protótipo no topo. Vamos recompilar Mario. OK, agora com sucesso. Mario, vamos fazer uma altura de 4 e voila. Agora, eu consegui, relativamente simples - embora eu certamente fiz isso mais rápido do que você faria sem alguma prática - na implementação da pirâmide do Mário. Mas é aqui que as coisas ficam mais legais. Vamos estipular que essa é uma solução iterativa correta, mesmo Se isso pode exigir um certo número de etapas ou tentativa e erro para
obter esse código baseado em loop iterativo correto. Vou mudar isso, agora, para ser recursivo. E lembre-se, uma função recursiva é aquela que chama a si mesma. Como você imprime uma pirâmide de altura h? Bem, lembre-se de que você imprime uma pirâmide de altura h menos 1, e, em seguida, você imprime mais uma linha de blocos. Então, deixe-me interpretar literalmente. para int, eu chego a zero. i é menor que h, i++. Eu vou imprimir essa linha extra de tijolos assim, seguido por uma nova linha. Então agora, eu fiz isso meio rápido. Mas o que estou fazendo
aqui? Bem, se a altura for igual a 1, quero que este loop itere uma vez. Se a altura fosse igual a 2, eu queria iterar duas vezes, 3 e assim por diante. Então eu acho que, usando minha técnica de indexação zero aqui, isso vai funcionar também. Mas se você preferir, eu certamente poderia mudar isso para 1 e alterar este 2. Mas vou ... não. Neste caso, quero deixar assim, índice zero, exatamente como fazemos normalmente. Tudo bem, deixe-me compilar isso, make Mario. OK, oops, interessante. Todos os caminhos por meio dessa função serão chamados a si próprios.
Então o clang é ser inteligente aqui, por meio do qual, vejo que em minha função draw, estou chamando minha função draw. E esse é um processo que nunca muda. Na verdade, deixe-me ver se eu posso substituir isso. Vamos usar o clang manualmente e compilar um programa chamado mario usando mario.c. Agora eu vou criar um link no cs50. Portanto, estou usando nossa sintaxe old school da segunda semana. OK, compilado. E por que isso compilou? Bem, make é, novamente, um programa que usa o clang do compilador. E configuramos o make para ser um pouco mais amigável e
um pouco mais Protetor, ativando recursos especiais onde detectamos problemas como esse. Ao usar o clang diretamente agora, estou desativando essas verificações especiais. E veja o que acontece quando eu rodo o Mario agora para a altura de 4, por exemplo. E é isso, travou. Nem mesmo imprimiu nada. Ele travou muito rapidamente. E, novamente, uma falha de segmentação significa que você tocou na memória que não deveria. Então, o que está acontecendo? Bem, se você pensar nesta memória como uma representação de parada principal, mas então desenhar, desenhar, desenhar, desenhar, desenhar, desenhar. Se todas as suas chamadas para draw
chamam draw de novo, Por que isso iria parar? Não pareceria parar aqui. Portanto, parece que está faltando um detalhe importante em minha versão recursiva. Você sabe o que é? Se não houver nada para desenhar, se a altura for igual a 0, deixe-me continuar, então, e voltar imediatamente. Caso contrário, vou seguir em frente e desenhar parte da pirâmide e, em seguida, adicionar a nova linha. Então, você precisa desse chamado caso básico, que você literalmente escolhe igualar a algum valor simples, como altura de 0, altura de 1, qualquer valor codificado permanentemente, de modo que, eventualmente, draw não
chame a si mesmo. Então, deixe-me recompilar isso com clang ou make. Vamos executá-lo novamente, altura de 4 e voila. Ainda está funcionando como a versão interna, mas agora está usando recursão. Então aqui está um tipo de questão de design. A iteração é melhor do que a recursão? Depende. A iteração sempre funcionará. Ao usar a versão iterativa, eu nunca vou estourar a pilha e acertar heap. Por quê? Porque não estou chamando funções de novo e de novo. Há apenas main e uma invocação de draw. Mas com a versão recursiva, é uma forma legal e poderosa para
fazer coisas. Tipo, eu posso desenhar para você uma pirâmide de altura h. Vamos desenhar uma pirâmide de altura h menos 1, e então adicionarei uma linha. É um tipo de argumento inteligente e cíclico que funciona de maneira muito elegante. Mas existe um perigo. E, embora este caso básico garanta que não durará eternamente, poderia demorar muito - talvez vamos tentar 10.000 invocações. Então funcionou bem. É um pouco lento. Estou perdendo o controle do meu teclado. Portanto, o Ctrl C é seu amigo. Vamos tentar mais uma vez. Eu vou fazer algo como 2 bilhões para ver se
funciona. Explodiu. Portanto, mesmo isso não funciona. Portanto, há esse perigo inerente com a recursão, por meio da qual, embora tenha nos capacitado na semana passada para resolver um problema de forma ainda mais eficiente com o merge sort, meio que tivemos sorte, em que não estávamos tentando coisas insanamente grandes na prateleira de Brian, porque parece que se você usar recursão e chamar a si mesmo de novo e de novo e de novo e de novo, mesmo que finitamente, mas muitas vezes, você pode tocar na memória que não deveria. E qual é a solução aqui? Infelizmente, é
"Não faça isso". Projete seus algoritmos, escolha suas entradas de tal forma que simplesmente não exista esse risco. E usaremos a recursão novamente em algumas semanas no momento em que olhamos para estruturas de dados mais sofisticadas. Mas, novamente, sempre há essa troca. Só porque você pode criar algo um pouco mais elegantemente não significa necessariamente que sempre funcionará para você. Mas, mais comumente, você provavelmente terá outros problemas também? Existe algo chamado estouro de buffer. E você certamente tropeçará nisso nas próximas semanas. Um estouro de buffer é quando você aloca um array E vai muito além do fim.
Ou você usa malloc e, no entanto, vai mais longe do que o final do pedaço de memória que você alocou. Um buffer é um pedaço de memória, por assim dizer, que você pode usar enquanto couber. O estouro do buffer significa ir além dos limites desse array. Você pode usar-- você está usando, agora, vídeo. Você deve conhecer a frase buffering de vídeos, como o buffer irritante da Netflix, porque há um ícone giratório ou algo assim. Bem, isso significa exatamente isso. Um buffer, no contexto de YouTube ou Zoom ou Netflix, Significa algum pedaço de memória que foi
recuperado via malloc ou alguma ferramenta semelhante que é preenchida com bytes compreendendo seu vídeo. E é finito, por isso você só pode armazenar alguns segundos ou minutos de vídeo antes, eventualmente, se você estiver offline, você fica sem conteúdo de vídeo para assistir. E o ícone idiota aparece, e você pode não ver mais nada, porque um buffer é um pedaço de memória, um array de memória. E se a Netflix, o Google ou outros implementassem seus códigos de maneira insegura, eles poderiam muito bem ir muito além dessa fronteira. Com tudo isso dito, vamos considerar, em alguns de
nossos minutos finais aqui hoje, apenas o que mais recebemos dessas treino de iniciação, Porque queremos retirá-las na maioria para você andar sozinho. Portanto, a biblioteca CS50 não fornece apenas esta abstração de um tipo de string, que novamente, não oferece nenhuma nova funcionalidade. Strings em C existem, apenas não por esse nome. Eles são conhecidas mais apropriadamente como char*. Mas todas essas funções na biblioteca CS50 podem ser implementadas com outras funções C que não eram do CS50, ou seja, usando um chamado scanf. Mas você vai ver, imediatamente, alguns dos perigos de usar algo como scanf, que é
uma função old school. Não foi projetada para ser autodefensivo como a biblioteca do CS50. E assim é muito fácil cometer erros. vou continuar, por exemplo, e criar um arquivo chamado scanf.c, apenas para demonstrar esta função. Não vou usar a biblioteca CS50, apenas o padrão io ponto h. E vou criar int main void. Vou criar uma variável x. E vou prosseguir e imprimir "x:" assim como a função get int do CS50. E então vou chamar o scanf. E vou prosseguir e dizer, digitalize, no teclado do usuário, um número inteiro, e armazene-o no local de x. Então,
vou prosseguir e imprimir, novamente, X, e dois pontos e uma \ %i \n. E vou imprimir x. Então, o que está acontecendo aqui? Na linha 5, estou declarando uma variável chamada x, assim como na primeira semana. Linha 6, apenas usando printf, como na primeira semana. O interessante parece estar na linha 7. Scanf é uma função que recebe a entrada do usuário, assim como get int, get string, get float e assim por diante. Mas isso só acontece quando você precisa entender os ponteiros, porque lembre-se de nosso exemplo de swap, se você quiser ter uma função, alterar
o conteúdo de uma variável, como fizemos com a e b e x e y, você tem que passar o endereço da variável, cujo Valor deseja alterar. Você não pode simplesmente passar o próprio x. Então, se não usássemos a Biblioteca CS50 na primeira semana, você teria escrito código assim apenas para obter um int do usuário. E você teria que entender os ponteiros. E você teria que entender & e * e assim por diante. É demais, quando tudo o que nos preocupamos nas primeiras semanas foram loops e variáveis e condições e tipos dos fundamentos. Mas aqui, agora
temos a capacidade de chamar a SCANF, contar para digitalizar do teclado do usuário, por assim dizer, um inteiro ou % F nos daria um float ou outros códigos, e passar no endereço de x para que a SCANF possa ir a esse endereço E colocar o inteiro do teclado do usuário. A linha 8 parece coisa da semana 1 . Eu estou apenas imprimindo o valor. E isso é bem seguro. vou continuar e fazer a SCANF. Compila ok. Vou prosseguir e executá-lo. Vou digitar 50. E pronto, ele imprime um 50. Mas há algumas estranhezas, porque se você
executar este programa também e digitar cat, então x é 0. E não há verificação de erros. Então, imediatamente, você deve lembrar das características da Biblioteca CS50, lembre-se, que continuamos avisando o usuário repetidamente, se ele não estiver cooperando e dando a você um int. Esse é um recurso que você obtém da biblioteca. Mas acontece que get string é ainda mais poderoso, porque se eu for e mudar este programa agora, não para obter um int, mas algo mais sofisticado como uma string - ou espere, estamos chamando de char* agora. Vou prosseguir e fazer algo muito semelhante. Vou
solicitar ao usuário a string s. E vou usar o scanf. E vou usar % s, assim como printf usa % s. E vou passar um s. Agora, para ficar claro, não preciso fazer o & aqui, porque agora, todos nós sabemos que s é fundamentalmente um endereço. Portanto, basta passar o endereço que você já possui. Agora, vou prosseguir e imprimir os dois pontos, a \ de % s, e imprimir s. Mas quando eu compilo isso, make scanf, ele não gosta quando eu compilo a variável s não inicializada quando usada aqui. Tudo bem, se eu quero ser
uma espécie de aventureiro, posso anular as proteções do make. E posso apenas compilar manualmente usando scanf - Usando clang diretamente. Isso funcionou, ./ scanf. Vamos prosseguir e digitar, por exemplo, "HI!" e você vê estranheza, nul. Bem, felizmente, make, e por sua vez clang, estavam nos ajudando a ajudar a nós mesmos. Ele estava apontando que você declarou s. Você declarou 8 bytes para um ponteiro. Mas não há nada lá. É um valor de lixo. E então não há onde colocar isso. E, felizmente, printf e scanf estão sendo inteligentes o suficiente Por não apenas ir cegamente lá
e colocar H, I, ponto de exclamação em um caractere nulo. Eles estão apenas deixando para lá. E esse nul entre parênteses é um recurso do printf que diz, você estragou tudo. Se você vir nul, significa que fez algo errado. Está sendo generoso para evitar travar. Se eu quiser obter a entrada do usuário, preciso ser mais esperto do que isso. E eu preciso me alocar 4 bytes, como fizemos mais cedo hoje. Ou eu poderia voltar às coisas da segunda semana e dizer algo como, dê-me 4 bytes. Isso, porém, me dá 4 bytes na pilha em algum
lugar aqui embaixo no quadro principal, por assim dizer. Essas linhas são chamadas de quadros. Se eu usar malloc, em vez disso, vem da chamada pilha, que não é retratada, está mais ou menos aqui. E a única diferença é que se estou usando o malloc, tenho que usar free. Se estou usando a pilha, como fiz na semana dois, não preciso usar free. Gerencia-se automaticamente para mim. Francamente, há muitas coisas novas hoje. Eu gosto da ideia de ficar com as arrays old school. Agora, porém, se eu for em frente e fizer make scanf, agora compilará com make.
Se eu executar o scanf e digitar, HI!, voila, parece funcionar. Mas isso é porque eu era inteligente e previ que H-I, OK, quatro caracteres. Eu me dei 4 bytes. Mas e se o usuário digitar, AQUI, DAVID, COMO ESTÁ? Claramente, mais de quatro bytes. E eu apertei Enter agora, algo estranho aconteceu. O resto está perdido. E isso seria irritante e muito frustrante se você - tentando obter a opinião do usuário na primeira semana de aula. Get string evita isso para você. Get string chama malloc para você. E exige um pedaço de memória tão grande quanto a
string que os humanos digitam. Resumindo, nós meio que observamos o que estão digitando caractere por caractere. E nos certificamos de alocar ou realocar apenas memória suficiente para caber o que quer que o humano tenha digitado. Então scanf é, uma função como a biblioteca CS50 e funciona sob o capô. Mas está fazendo tudo isso por você. E assim que você tira rodinhas como essa, ou francamente, bibliotecas assim. Não é uma ferramenta de ensino. É uma biblioteca útil. Você mesmo precisa começar a implementar mais dessas coisas de baixo nível. Então, novamente, há uma troca. Se você não
quiser usar algo como a biblioteca CS50, tudo bem. Agora, a responsabilidade recai sobre você para evitar todas essas possíveis condições de erro. Tudo bem, com isso dito, nós temos um recurso final para lhe dar a fim de motivar os problemas desta semana, em que você explorará, manipulará e escreverá código para alterar arquivos. E para isso, precisamos de um tópico final de I / O de arquivo. File I/O é o termo técnico que descreve a obtenção de entrada e saída de arquivos. Quase todos os programas que escrevemos até agora usam apenas memória, assim aqui, por meio
do qual, você pode colocar coisas na memória. Mas assim que seu programa terminar, bum! Já se foi. O conteúdo da memória se foi. Os arquivos, é claro, estão onde você e eu no mundo do Computação Salvamos nossos artigos, documentos e currículos e tudo isso permanentemente no seu computador. Em C, você tem a habilidade, certamente, para escrever você mesmo um código que salva arquivos a longo prazo. Por exemplo, vou escrever meu próprio programa aqui, um programa de lista telefônica que armazena nomes e números em um arquivo. Vou prosseguir e incluir, apenas por conveniência, a biblioteca CS50
de novo, porque não quero lidar com scanf. Vou prosseguir e salvar isso, aliás, como phonebook.c. Vou prosseguir e incluir não apenas a biblioteca CS50, mas o io padrão. E preventivamente, irei prosseguir e incluir string.h também. E vou prosseguir na minha função main. E vou usar algumas novas funções que veremos brevemente aqui. Mas no próximo conjunto de problemas, você os explorará com mais detalhes. Vou criar uma indicação para um arquivo. Acontece que, estranhamente, que em maiúsculas, FILE, este é um novo tipo de dados que vem com C que representa um arquivo. Vou seguir em frente e
criar uma indicação para um arquivo, o endereço de um arquivo. E vou chamar o arquivo variável. Eu poderia chamar f, poderia chamar de x. Vou chamar de arquivo em letras minúsculas, só para ficar claro. E vou usar uma nova função chamada f open, que significa abrir arquivo. E a abertura do arquivo leva dois argumentos. Recebe o primeiro argumento, que é o nome de um arquivo que deseja abrir. Vou abrir um arquivo chamado phonebook.csv. E então vou prosseguir e abri-lo, especificamente, no modo anexar. Resumindo, você pode abrir arquivos de diferentes maneiras, lê-los, isto é, basta olhar
para o seu conteúdo, escrevê-los, que é mudar seu conteúdo completamente, ou para anexar a eles, a, que significa adicionar linha por linha a eles, para continuar a fornecer mais informações. Vou continuar e, só para ficar seguro, vou dizer que se o arquivo é igual a nul, porque lembre-se de que nul significa que algo deu errado, vamos retornar agora. Talvez eu tenha digitado incorretamente o nome do arquivo. Talvez não exista. Algo deu errado, provavelmente. Vou verificar isso dizendo: se o arquivo for igual a nul, apenas saia do programa agora. Mas depois disso, vou prosseguir e obter
uma string. Mas podemos chamar de char* agora, chamada de name. E vou pedir um nome ao usuário. E já fizemos isso antes. Vou pedir a eles um número, um número de telefone. E já fizemos isso antes. A única diferença, agora, é estou chamando string char*. E agora, aqui está a parte legal. Acontece que, se eu quiser salvar este nome e número a esse arquivo permanentemente em um CSV - se desconhecido, popular no mundo da consultoria, o mundo analítico. É apenas uma planilha, um valor separado por vírgula arquivo que você pode abrir no Excel ou planilha
do Google. Vou prosseguir e, não printf, mas fprintf para esse arquivo, uma string seguida por uma vírgula, seguida por uma string, seguida por uma nova linha, conectando o nome e o número. E então, aqui embaixo, fecharei o arquivo. Então, isso é novo. fprintf não é printf, que imprime na tela. fprintf imprime em um arquivo. Então você tem que passar mais um argumento, o primeiro, que é o ponteiro para o arquivo para o qual é deseja enviar essas novas strings. Então você ainda fornece uma string de formato, que diz, hey fprintf, este é o tipo de
dados que desejo imprimir no arquivo. E então você conecta as variáveis, assim como sempre fizemos com printf. E, por último, fechamos o arquivo. Resumindo, este programa parece solicitar a um humano um nome e um número. E então vai seguir em frente e escrever esses nomes e números para o arquivo. Então agora eu vou fazer a lista telefônica. OK, nenhum erro até agora, lista telefônica ./, David, 949-468-2750. OK, deixe-me executá-lo mais uma vez, embora nada pareça ter acontecido. Brian, que tal 617-495-1000, Enter. Vamos verificar meu explorador de arquivos aqui. Observe, todos os arquivos que criamos hoje,
incluindo, se eu aumentar o zoom, não apenas phonebook.c, mas phonebook.csv. E se eu clicar duas vezes nisso, observe o que está dentro disso. Voila, o nome de David, o nome de Brian e cada um dos nossos números. E ainda mais legal do que isso, agora eu vou encerrar isso. Vamos prosseguir e baixar este arquivo usando o IDE. E isso vai colocá-lo na minha pasta Downloads. Eu vou clicar nele. E vai abrir Excel ou Numbers ou qualquer outra coisa que você tem no seu Mac ou PC. Vou prosseguir. E voila, parece um pouco estúpido nesta formatação
aqui. Mas eu abri uma planilha que eu mesmo gerei usando fopen, fprintf e fclose. Então, agora que temos ponteiros à nossa disposição, podemos manipular coisas como arquivos, o que é muito legal. Mas vamos fazer isso esta semana, não com texto, mas com tipos específicos reais de arquivos. E, lembre-se desse tipo de pensamento aqui. Se você olhar para isso, provavelmente é muito enigmático. Parece um código de máquina, mas não é. Esta é, talvez, a representação mais simples De um rosto sorridente dentro de um arquivo. Se você tiver um arquivo de bitmap, um mapa de bits, uma
grade de bits, esses bits, muito simplesmente, podem ser literalmente 0's e 1's. E se você atribuir a cor preta a 0 e a cor branca a 1, você poderia pensar nesta mesma grade de 0 e 1 representando, na verdade, um rosto sorridente. Em outras palavras, aqui estão alguns pixels. Falamos sobre pixels na semana zero. Pixels são apenas os pontos que compõem um arquivo gráfico em seu computador. E os pixels estão por toda parte. Todos nós, agora, sintonizando ao vivo via Zoom ou YouTube ou similares, estamos assistindo a fluxos de pixels, que compõem várias imagens e
várias Imagens compondo vídeos que parecem estar se movendo em 20 ou 30 quadros por segundo. Agora, é claro, há um limite de fidelidade nesse tipo de imagem. E é bastante comum no caso da TV e do cinema, se houver algum bandido que foi pego em alguma gravação de vigilância, ou similares, invariavelmente, o staff do Direito pode melhorar o vídeo e aumentar, para ver exatamente a pessoa que cometeu tal crime. Bem, isso tudo é um absurdo. E deriva de alguns dos primitivos que introduzimos na semana zero. Na verdade, só para brincar com isso, deixe-me ir em
frente e passar alguns segundos desse programa de TV aqui nos EUA Chamado CSI, apenas para lhe dar uma noção de quão comum esse tipo de lógica é. [REPRODUÇÃO DE VÍDEO] - Nós sabemos. - Isso às 9:15, Ray Santoya estava no caixa eletrônico. - Então a questão é, o que ele estava fazendo às 9:16? - Atirando com sua 9 milímetros em alguma coisa. Talvez ele tenha visto o atirador. - Ou estava trabalhando com ele. - Espere, volte um. - O que você vê? [CLICANDO] - Traga o rosto para cima, tela inteira. - Os óculos dele. -
Há um reflexo. [DIGITANDO] - Esse é o time de beisebol, Neuvitas. Esse é o logotipo deles. - E está falando com quem está vestindo essa jaqueta. - Podemos ter uma testemunha. - Para ambos os tiroteios. [FIM DA REPRODUÇÃO] DAVID MALAN: Então, infelizmente, hoje vamos estragar muitos filmes e séries para você, porque você não pode simplesmente aumentar o zoom infinitamente e ver mais informações se essas informações não estiverem lá. no fim das contas, há apenas um número finito de bits. E, caso em questão, aqui está uma fotografia de Brian. E você pode ver que, há um
brilho em seus olhos. Vamos ver o que estava refletido no olho dele ali. E se dermos um zoom nesta imagem de Brian, e talvez possamos ampliar um pouco mais, isso é tudo o que existe. Você não pode simplesmente clicar no botão aprimorar e ver mais, porque no fim das contas, são apenas pixels. E pixels, como visto na semana zero, são apenas 0's e 1's, finitamente. Então, o que você vê é o que você obtém. Agora, com isso dito - e na verdade, podemos zombar disso também, aqui. Vamos reproduzir um outro clipe curto de Futurama, que
mostra esse ponto também, mas de forma mais divertida. [REPRODUÇÃO DE VÍDEO] - Aumente a velocidade da morte. Por que ainda está borrado? - Essa é toda a resolução que temos. Aumentar o zoom não o torna mais claro. - Fazem isso no CSI: Miami. - [SUSPIRAR] [FIM DA REPRODUÇÃO] DAVID MALAN: Então, temos dois clipes conversando, na verdade, um com o outro. Mas tenho que atualizar as coisas para 2020. Você não pode pegar a internet hoje em dia ou a revista hoje em dia, que de alguma forma não mencione aprendizado de máquina e inteligência artificial e algoritmos
sofisticados por meio dos quais você pode fazer coisas que anteriormente não era possível. E isso é meio que o caso. Você deve se lembrar da semana zero, que encontramos esta bela aquarela de pintura nos arquivos de Harvard que tem apenas cerca de 11 polegadas de altura total. E ainda assim, de alguma forma, tem 13 pés de altura aqui atrás de mim. Agora, normalmente, se você fosse apenas realçar esta pintura em aquarela, Começaria a parecer muito estúpido muito rapidamente com muita e muita pixelização, mesmo se você usar uma câmera muito sofisticada, como costumam fazer, para capturar
a imagem original. Mas queríamos aumentar para 4 metros de altura para que ficasse em alta qualidade o tempo todo. E aí, usamos o aprimoramento, de certa forma. Então, usando, para encurtar a longa história, algoritmos mais sofisticados do que os da semana passada, você pode usar inteligência artificial, aprendizado de máquina, para analisar os dados e encontrar padrões onde não havia - que não são necessariamente visíveis ao olho humano. Por exemplo, se pegarmos o original aqui e começarmos a aumentar o zoom, Parece muito bom nesta resolução. Mas é muito bom. Você não vê o fato de que
isso era tinta em uma tela real. Então, isso foi apenas um zoom no Photoshop. Mas quando você executa uma imagem como esta por meio de software sofisticado baseado em aprendizado de máquina, inteligência artificial, você pode começar a melhorá-la e ver, não apenas esta janela do topo de um dos edifícios, que é bem borrado aqui no Photoshop, mas você pode começar a ver mais detalhes. Então, isso é literalmente o antes, apenas ampliando no Photoshop. Isso é depois de aplicar algoritmos sofisticados de inteligência artificial Que vemos, espere um minuto, há uma pequena descoloração ali. Espere, há um
pouco de descoloração aí. E hoje em dia, o aprimoramento está cada vez mais se tornando uma realidade. Ainda está melhorando. Não é ressuscitar informações que necessariamente existiam. Mas sim acertar mais, algoritmicamente, para reconstruir o que a imagem era. E se ampliarmos ainda mais, você pode, talvez, ver que isso está começando a ficar borrado se você usar apenas o Photoshop e continuar ampliando. Mas se você executar por meio de algoritmos sofisticados o suficiente e começar a notar pequenas descolorações que Não são super visíveis para o olho humano, podemos melhorar ainda mais. E você não pode fazer
isso infinitamente. E, de certa forma, estamos criando informações onde não há necessariamente essa informação lá. Então, se esses tipos de coisas se mantêm no tribunal é outra questão. Mas pode melhorar a fidelidade de imagens como esta. E, isso nos permitiu ampliar de 11 polegadas a 13 pés. Então, quando se trata de manipular imagens, em última análise, nós temos algumas capacidades programáticas, incluindo este ponteiro de arquivo, como acabamos de ver, e também, algumas outras funções. E nossos exemplos finais, aqui, vão colocar a fundação pelo que você fará esta semana, que É manipular seus próprios arquivos gráficos
com um novo entendimento de ponteiros e endereços e agora arquivos e entrada e saída. Por exemplo, vou prosseguir e abrir um programa aqui chamado - me dê apenas um segundo. Vou abrir um programa aqui chamado jpeg.c. E este programa, jpeg.c, que escrevi antes, que está no site do curso, faz o seguinte. Primeiro, ele declara um tipo chamado byte. Acontece que, em C, não há uma definição comum do que é um byte. Um bite, como conhecemos, é um pedaço. E acontece que a maneira mais simples de criar um byte é definir o nosso pedaço, assim como
definimos uma string, Assim como definimos outros tipos também, como um estudante, a fim - de que uma pessoa possa nos fornecer um byte. Portanto, esta primeira linha de código apenas declara um tipo de dados chamado byte, usando outro tipo de dados mais misterioso chamado u int a sublinhado t. Mas mais disso no conjunto de problemas. Acabamos de inventar algo chamado byte. Observe, neste programa, estou ressuscitando a ideia da segunda semana de argumentos de linha de comando, onde podemos obter a entrada do usuário. Observe que estou verificando se o usuário digitou dois argumentos. E s não,
estou devolvendo um imediatamente para significar erro. Na linha 17, estou usando minha nova técnica. Estou abrindo um arquivo usando o nome do arquivo Que o humano digitou na linha de comando. E, desta vez, estou abrindo para ler "r" em vez de a. Mas se não houver um arquivo - então, se o arquivo bang, isto é, se arquivo de ponto de exclamação, ou se o arquivo for igual a NULL, significam a mesma coisa. Posso prosseguir e devolver um, significando um erro. Aqui embaixo, estou fazendo algo um pouco inteligente. Acontece que com uma probabilidade muito alta, você
pode determinar se algum arquivo é um jpeg olhando apenas para os três primeiros bytes. Muitos formatos de arquivo têm o que chamamos de números mágicos no início de seus arquivos. E esses são números padrão da indústria, 1 ou 2 ou 3 ou mais deles, que normalmente se espera que esteja no início de um arquivo, para que um programa possa verificar rapidamente, isso é um jpeg? Isso é um GIF? Este é um documento do Word? Este é um arquivo Excel? Eles tendem a ter esses números no início deles. E os JPEGs têm uma sequência de bytes
que estamos prestes a ver. Esta linha de código 24 aqui, como você verá no próximo conjunto de problemas, é como você pode dar a si mesmo um buffer de bytes, especificamente um array de três bytes. A próxima linha de código, como você verá na próxima semana, é chamada de fread. Fread, como o nome sugere, lê um arquivo. Ou seja, ele pega bytes de um arquivo. E é um pouco sofisticado de usar, mas você ficará mais confortável com isso ao longo do tempo. Ele lê neste buffer, seu primeiro argumento, o tamanho deste tipo de dados, o
tamanho de um byte. E ele lê muitos desses tipos de dados deste arquivo. Então, novamente, é para argumentos, o que é muito pelo que vimos. Mas ele lê a partir deste arquivo, três bytes nesse array, buffer também conhecido como, denominado bytes. Então é assim que você escreve código que não coloca dados em um arquivo, mas lê a partir dele. E então aqui, observe nosso hexadecimal. Então, fechamos o círculo. Se bytes, colchete 0 é igual a 0xff e bytes colchete 1 é igual a 0xd8 e bytes colchete 2 é igual a 0xff, isso definitivamente parece enigmático
para você. Mas isso é só porque eu procurei no manual de jpegs, e acontece que quase qualquer JPEG, ao contrário, deve começar com 0xff, 0xd8, 0xff. Esses são os primeiros três bytes de qualquer jpeg em seu Mac, seu PC, na internet. Sempre existem esses três bytes. Acontece que o quarto byte ainda decide se Um arquivo é, na verdade, um jpeg. Mas o algoritmo para isso é um pouco mais elaborado, então mantive-o simples. Se os primeiros três bytes de um arquivo forem esses, talvez você tem um jpeg. Mas se você não tiver exatamente esses três bytes,
você definitivamente não tem um JPEG. E então o que posso fazer, aqui, é o seguinte. No código de hoje - deixe-me prosseguir e pegar dois outros arquivos que eu trouxe comigo. E acontece que é uma fotografia novamente. Dê-me um segundo. Eu trouxe comigo alguns arquivos, um dos quais é chamado brian.jpeg, que é a mesma foto de Brian. E então eu tenho um gif, o que é claro, não é um jpeg, que é esse gato digitando aqui. E o que eu, efetivamente, tem na minha frente agora é um programa que, se eu fizer make jpeg, porque
este arquivo é jpeg.c, e executo o ./ jpeg, posso digitar algo como cat.gif na linha de comando como um argumento, Enter, e eu não verei nenhum. Por outro lado, se eu passar o JPEG de Brian na linha de comando como um argumento, Eu vejo talvez. E novamente, talvez apenas porque o algoritmo para julgar se algo é um JPEG é um pouco mais complicado do que isso. Mas, agora posso acessar os bytes individuais e, portanto, os pixels, Ao que parece, de um arquivo de imagem. E, podemos até fazer isso. Eu vou mostrar um último programa que
escrevemos deliberadamente antes, apenas para lhe dar um gostinho do que está vindo com o próximo conjunto de problemas. Este programa é uma reimplementação do programa que você provavelmente deve ter usado uma ou mais vezes chamado de CP. Lembre-se de que o CP é um programa no IDE e no Linux, de forma mais geral, isso permite que você copie um arquivo. Você faz CP, espaço, nome do arquivo, espaço, o novo nome de arquivo. Como é que isso funciona? Agora tenho todos os blocos de construção com os quais posso copiar arquivos sozinho. Então, novamente, estou definindo um
byte aqui. Estou definindo main como aceitando argumentos de linha de comando aqui. E observe uma mudança. Não estou usando a biblioteca CS50. Então, mesmo o que antes era string na semana dois agora é char*. Mesmo aqui para argv, estou garantindo que os tipos humanos em três palavras, o nome do programa e o arquivo de origem e o arquivo de destino. Estou usando o fopen novamente. Estou abrindo o arquivo de origem aqui do argv1. Estou garantindo que não seja nulo. E então estou desistindo, se for. Eu estou então - aqui está algo novo, abrindo o arquivo
de destino aqui, também com fopen. Mas estou usando "w." Estou abrindo um arquivo com r, um arquivo para w, porque quero ler de um e escrever para o outro. E aqui embaixo, este loop é uma maneira inteligente de copiar um arquivo para outro. Estou me dando um buffer de um byte, então apenas uma variável temporária, apenas como a temperatura de Brian ou o copo vazio. E estou usando essa função, fread. Estou lendo naquele buffer por meio de seu endereço, do tamanho de um byte, especificamente um byte do arquivo de origem. E então, nesse mesmo loop,
estou escrevendo desse buffer, do tamanho de um byte, especificamente um byte, para o destino. Então, o programa CP que você deve ter me visto usar ou você mesmo usou para copiar arquivos, está literalmente fazendo isso. está abrindo um arquivo, iterando sobre todos os seus bytes, e copiando da origem ao destino. E por último, está fechando o arquivo. E esses dois últimos exemplos deliberadamente rápidos, porque toda esta semana será gasta mergulhando em I/O de arquivos e imagens como esses. Mas tudo o que fizemos foi usar esses fread, fopen e fwrite e f close, para manipular esses
mesmos arquivos. Então, por exemplo, se eu fizer isso agora, deixe-me fazer make cp. OK, parece compilar, ./ cp, brian.jpeg. Que tal brian2.jpeg? E Enter. Parece que nada aconteceu. Mas se eu entrar aqui e clicar duas vezes em brian2, vemos que temos uma segunda cópia do arquivo real de Brian. Portanto, na próxima semana, você experimentará vários formatos de arquivo para imagens. O primeiro é jpeg. E nós daremos a você a chamada imagem forense de um monte de fotos de um cartão de memória digital. Na verdade, é muito comum hoje em dia, certamente na aplicação do Direito,
Fazer cópias forenses de discos rígidos, de dispositivos de mídia, de telefones e outros dispositivos, e então analisá-los em busca de dados perdidos, corrompidos ou excluídos. Faremos exatamente isso, onde, você vai escrever um programa que recupera JPEGs que foram excluídos acidentalmente de um cartão de memória digital. E nós daremos a você todas as cópias desse cartão de memória fazendo uma imagem forense disso, que está copiando todos os 0's e 1's de uma câmera e entregando a você em um arquivo que você pode abrir e escrever. Também apresentaremos os arquivos de bitmap, BMP's, popularizado pelo funcionamento do
Windows com uso principal em papéis de parede e similares. Mas vamos usá-los para implementar usando ponteiros e I/O de arquivo, seu próprio filtro semelhante ao do Instagram. Então, vamos tirar esta foto, aqui, da passarela do Weeks aqui em Cambridge, Massachusetts - Harvard. E vamos implementar uma série de filtros, tomando esta imagem original, por exemplo, e dessaturando-a, tornando-a preto e branco, iterando sobre todos os pixels de cima para baixo, da esquerda para a direita, e reconhecendo todas as cores, como vermelho, verde, azul ou qualquer coisa intermediária, e mudá-las para algum tom de cinza, fazendo um filtro
sépia, fazendo as coisas parecerem antigas, como esta foto tirada muitos anos atrás, aplicando da mesma forma uma heurística que altera as cores de todos Os pixels nesta imagem. Vamos fazer com que você vire para colocar esse pixel aqui e este pixel ali. E você apreciará exatamente como os arquivos são implementados dentro de seu próprio disco rígido e telefone. E você vai até implementar, por exemplo, um filtro de desfoque, que não por acaso, torna mais difícil ver o que está acontecendo aqui, porque você está começando a, agora, calcular a média dos pixels que estão próximos uns
aos outros para encobrir as coisas e deliberadamente tornar mais difícil ver aqui. E então nós ainda, se você quiser, teremos você implementando detecção de borda, se ficar melhor para você, Onde você encontrará bordas de todos os objetos físicos nessas imagens, a fim de detectá-las no código e criar uma arte visual como esta. Agora, isso é muita coisa. E eu sei que os ponteiros são geralmente considerados estar entre os recursos mais desafiadores do C, e certamente, programação em geral. Então, se você está sentindo que já viu muita coisa, foi isso mesmo. Mas agora você tem a
habilidade, tanto hoje ou em um prazo muito próximo, para entender até mesmo quadrinhos XKCD como a maioria dos cientistas da computação. Então, nosso look final para você, hoje, está essa brincadeira aqui. E mesmo que eu não possa necessariamente ouvir você de longe, Vou apenas assumir, em nossos momentos finais de hoje, que todo mundo está explodindo em uma gargalhada muito nerd. E vejo alguns sorrisos, pelo menos, o que é reconfortante. Este foi, então, o CS50. Nos vemos na próxima. [MÚSICA, TOCANDO]