1
00:00:00,000 --> 00:00:03,395
>> [Música tocando]

2
00:00:03,395 --> 00:00:11,031

3
00:00:11,031 --> 00:00:13,280
DAVID J. MALAN: Isto é como
um seminário hoje calouro.

4
00:00:13,280 --> 00:00:14,060
ESTÁ BEM.

5
00:00:14,060 --> 00:00:15,024
Então, muito chuvoso para fora.

6
00:00:15,024 --> 00:00:17,690
Isto tende a acontecer às quartas-feiras,
mas todos os mais oportunidade

7
00:00:17,690 --> 00:00:18,700
para perguntas hoje.

8
00:00:18,700 --> 00:00:22,210
Então, vamos começar realmente
com o filme em apenas um momento.

9
00:00:22,210 --> 00:00:24,560
Mas vamos começar grandiosamente como sempre.

10
00:00:24,560 --> 00:00:28,000
>> Este é CS50, e este
é o fim de semana 4.

11
00:00:28,000 --> 00:00:30,820
Então, se você já assistiu
TV ou um filme em que

12
00:00:30,820 --> 00:00:34,690
há alguns especialistas em informática e
a polícia, ou FBI, ou alguma agência

13
00:00:34,690 --> 00:00:36,930
está tentando pegar alguns
adversário, bem, você tem

14
00:00:36,930 --> 00:00:40,850
provavelmente já ouviu a expressão "melhorar"
em que de alguma forma que técnico

15
00:00:40,850 --> 00:00:44,750
magicamente amplia infinitamente
zoom para ver os criminosos

16
00:00:44,750 --> 00:00:48,640
identidade ou o número da placa
no mesmo o brilho de um espelho

17
00:00:48,640 --> 00:00:50,390
ou o brilho de olhos de alguém.

18
00:00:50,390 --> 00:00:55,196
Então, na verdade, vamos dar uma olhada
algumas dessas cenas de Hollywood.

19
00:00:55,196 --> 00:00:55,862
[REPRODUÇÃO DE VÍDEO]

20
00:00:55,862 --> 00:00:59,243
-OK, Agora vamos dar uma boa olhada em você.

21
00:00:59,243 --> 00:01:06,488

22
00:01:06,488 --> 00:01:07,415
>> -Segure-Lo.

23
00:01:07,415 --> 00:01:08,267
Execute isso de volta.

24
00:01:08,267 --> 00:01:09,121
>> -Espere um minuto.

25
00:01:09,121 --> 00:01:11,300
Vire a direita.

26
00:01:11,300 --> 00:01:12,209
>> -Não, Que congelar.

27
00:01:12,209 --> 00:01:12,750
-Tela cheia.

28
00:01:12,750 --> 00:01:13,558
-OK, Que congelar.

29
00:01:13,558 --> 00:01:14,820
-Tighten-Se em que, você vai?

30
00:01:14,820 --> 00:01:16,530
-vector Em em que
cara pela roda traseira.

31
00:01:16,530 --> 00:01:19,400
-zoom Em direito aqui neste local.

32
00:01:19,400 --> 00:01:22,846
-Com O equipamento certo, a imagem
poderia ser ampliada e afiada.

33
00:01:22,846 --> 00:01:24,065
-O que é isso?

34
00:01:24,065 --> 00:01:25,600
-É Um programa de melhoramento.

35
00:01:25,600 --> 00:01:26,860
-Pode-Se claro que qualquer?

36
00:01:26,860 --> 00:01:27,890
-Eu não sei.

37
00:01:27,890 --> 00:01:29,050
Vamos melhorá-lo.

38
00:01:29,050 --> 00:01:31,575
>> A6 seção -Aprimore.

39
00:01:31,575 --> 00:01:33,642
>> -I Aumentada o detalhe,
e- Eu acho que há

40
00:01:33,642 --> 00:01:35,433
o suficiente para melhorar,
liberá-lo para minha tela.

41
00:01:35,433 --> 00:01:37,080
-Eu Reforçada a reflexão em seus olhos.

42
00:01:37,080 --> 00:01:38,830
>> -Vamos Executar este através
melhoramento de vídeo.

43
00:01:38,830 --> 00:01:40,100
-Edgar, Você pode melhorar isso?

44
00:01:40,100 --> 00:01:41,875
>> -Esperar.

45
00:01:41,875 --> 00:01:44,010
>> -Eu Vindo a trabalhar sobre esta reflexão.

46
00:01:44,010 --> 00:01:44,995
>> A reflexão de -Alguém.

47
00:01:44,995 --> 00:01:45,495
-Reflection.

48
00:01:45,495 --> 00:01:47,399
-Há Um reflexo do rosto do homem.

49
00:01:47,399 --> 00:01:48,065
-O Reflexão.

50
00:01:48,065 --> 00:01:48,981
-Há Uma reflexão.

51
00:01:48,981 --> 00:01:50,600
-zoom Em no espelho.

52
00:01:50,600 --> 00:01:52,712
-Você Pode ver um reflexo.

53
00:01:52,712 --> 00:01:54,350
-Pode Você melhorar a imagem a partir daqui?

54
00:01:54,350 --> 00:01:55,370
-Pode Você melhorar o bem aqui?

55
00:01:55,370 --> 00:01:56,210
-Pode Você melhorá-lo?

56
00:01:56,210 --> 00:01:56,900
Você pode melhorá-lo?

57
00:01:56,900 --> 00:01:57,870
>> -Podemos Melhorar isso?

58
00:01:57,870 --> 00:01:58,717
>> -Pode Você melhorá-lo?

59
00:01:58,717 --> 00:02:00,050
-Mantenha Um segundo, eu vou melhorar.

60
00:02:00,050 --> 00:02:00,924
Em -zoom na porta.

61
00:02:00,924 --> 00:02:01,700
-Times 10.

62
00:02:01,700 --> 00:02:02,586
-zoom.

63
00:02:02,586 --> 00:02:03,490
-move In.

64
00:02:03,490 --> 00:02:03,990
-Mais.

65
00:02:03,990 --> 00:02:04,690
Espere, pare.

66
00:02:04,690 --> 00:02:05,190
-Pare.

67
00:02:05,190 --> 00:02:05,970
-pause-Lo.

68
00:02:05,970 --> 00:02:09,460
-Rotate Nos 75 graus
em torno da vertical, por favor.

69
00:02:09,460 --> 00:02:10,962
-Pare.

70
00:02:10,962 --> 00:02:14,040
Volte para a parte
Sobre a porta, mais uma vez.

71
00:02:14,040 --> 00:02:15,860
>> -Got Um intensificador de imagem que pode bitmap?

72
00:02:15,860 --> 00:02:18,776
>> Ei, talvez possamos usar o Pradeep
Sen método para ver nas janelas.

73
00:02:18,776 --> 00:02:20,372
Software -Este é o estado da arte.

74
00:02:20,372 --> 00:02:21,845
>> -O Valor próprio é desligado.

75
00:02:21,845 --> 00:02:24,300
>> -Com O direito
combinação de algorithm--

76
00:02:24,300 --> 00:02:26,755
>> Eliminação tomada de -Ele
algoritmos para o próximo nível,

77
00:02:26,755 --> 00:02:28,730
e eu posso usá-los para
melhorar esta fotografia.

78
00:02:28,730 --> 00:02:31,286
>> -Lock Em e ampliar o eixo z.

79
00:02:31,286 --> 00:02:32,560
>> -Aprimore.

80
00:02:32,560 --> 00:02:33,100
>> -Aprimore.

81
00:02:33,100 --> 00:02:33,600
>> -Aprimore.

82
00:02:33,600 --> 00:02:34,960
-Freeze E melhorar.

83
00:02:34,960 --> 00:02:37,180
>> [FIM DE REPRODUÇÃO]

84
00:02:37,180 --> 00:02:41,160
>> DAVID J. MALAN: Tudo bem, então
todos esses são realmente palavras.

85
00:02:41,160 --> 00:02:44,450
Eles só estão amarrados juntos em um
forma que não é realmente sensata.

86
00:02:44,450 --> 00:02:48,400
E, de fato, CS50 e cursos como ele
tende a arruinar um monte de TV e filmes

87
00:02:48,400 --> 00:02:48,900
para voce.

88
00:02:48,900 --> 00:02:52,330
Porque quando esses especialistas em informática
estão despejando termos e dizendo

89
00:02:52,330 --> 00:02:56,860
coisas extravagantes como
vectores próprios, e o eixo-z,

90
00:02:56,860 --> 00:02:59,572
e qualquer número de outros
realmente termos mais técnicos,

91
00:02:59,572 --> 00:03:02,030
eles realmente estão apenas amarrando
palavras juntas com demasiada frequência.

92
00:03:02,030 --> 00:03:05,020
É que uma das nossas esperanças é que,
como um efeito colateral de cursos tomada

93
00:03:05,020 --> 00:03:08,245
como este, será mais pessoas no
mundo realmente ser capaz de pesar

94
00:03:08,245 --> 00:03:12,040
e apenas muito ligeiramente influenciar o
qualidade e precisão desses filmes?

95
00:03:12,040 --> 00:03:14,350
>> Na verdade, vamos dar uma olhada em realidade.

96
00:03:14,350 --> 00:03:18,070
Então aqui está a foto da equipe
Mary, um dos nossos companheiros de ensino.

97
00:03:18,070 --> 00:03:20,050
E suponho que ela é
suspeito de alguma coisa.

98
00:03:20,050 --> 00:03:23,730
E, no entanto, há um vislumbre de
algum pedaço de evidência em seu olho,

99
00:03:23,730 --> 00:03:25,480
ou na reflexão de seus óculos.

100
00:03:25,480 --> 00:03:30,760
Bem, se fizermos exatamente como os filmes
propor, na qual estamos zoom e "melhorar",

101
00:03:30,760 --> 00:03:34,080
esta é a quantidade de informação
é no rosto de Mary

102
00:03:34,080 --> 00:03:36,795
quando você captura uma imagem
com essa resolução original.

103
00:03:36,795 --> 00:03:39,120
>> E, de fato, você pode ver esses pontos.

104
00:03:39,120 --> 00:03:41,900
E estes são o que são
chamados de pixels, P-X-I-E-L-S,

105
00:03:41,900 --> 00:03:45,740
que é apenas uma praça tipicamente
que é um ponto que compõe uma imagem.

106
00:03:45,740 --> 00:03:49,200
E de volta no dia, e, na verdade, até mesmo
hoje com algumas das TVs LED de hoje

107
00:03:49,200 --> 00:03:51,950
ou TVs LCD, se você tem
um no seu quarto ou em casa,

108
00:03:51,950 --> 00:03:55,100
se você ir para cima super próximo a ele, e
especialmente se for uma TV um pouco mais velho,

109
00:03:55,100 --> 00:03:58,760
você provavelmente pode até mesmo ver esses pontos
e é isso que compor uma imagem.

110
00:03:58,760 --> 00:04:00,980
>> E não há mais
informações do que este.

111
00:04:00,980 --> 00:04:05,400
Poderíamos "aprimorar", no sentido de
suavização sobre as coisas e tipo de

112
00:04:05,400 --> 00:04:09,040
inferindo tipo de, tipo do que
cor deve ser próximo aos olhos de Mary

113
00:04:09,040 --> 00:04:10,910
para que ele não é realmente tão pixelizada.

114
00:04:10,910 --> 00:04:14,510
Mas se eu continuar ampliando, não
é o cara mau em seu olho.

115
00:04:14,510 --> 00:04:16,600
Como isso é tudo o
informação que temos.

116
00:04:16,600 --> 00:04:18,920
Você não pode criar
informações a partir do nada.

117
00:04:18,920 --> 00:04:20,790
Havia apenas um finito
número de bits de lá.

118
00:04:20,790 --> 00:04:22,873
>> Assim, no Conjunto de Problemas 4, onde
você tem uma oportunidade

119
00:04:22,873 --> 00:04:24,580
jogar com este tipo de mundo.

120
00:04:24,580 --> 00:04:27,610
Em Conjunto de Problemas 4, você vai explorar o
mundo de gráficos e forense,

121
00:04:27,610 --> 00:04:30,870
e realmente escrever código
que recupera imagens perdidas.

122
00:04:30,870 --> 00:04:33,510
Você vai escrever um código que
manipula imagens existentes

123
00:04:33,510 --> 00:04:36,120
e, finalmente, entender o que é
acontecendo debaixo do capô.

124
00:04:36,120 --> 00:04:38,540
>> E, ao que parece, é realmente
não tão complicado.

125
00:04:38,540 --> 00:04:41,320
Por exemplo, se quiséssemos
representam um rosto sorridente onde

126
00:04:41,320 --> 00:04:44,160
com esses pixels pretos,
ou esses pontos pretos,

127
00:04:44,160 --> 00:04:47,230
Bem, nós poderíamos simplesmente representar
-los como realmente um bitmap.

128
00:04:47,230 --> 00:04:50,040
E se você nunca tinha ouvido falar que
expressão bitmap, talvez

129
00:04:50,040 --> 00:04:52,330
agora começa a fazer uma
pouco mais de sentido hoje.

130
00:04:52,330 --> 00:04:53,580
>> Nós já sabemos o que é um pouco.

131
00:04:53,580 --> 00:04:54,160
É 0 ou 1.

132
00:04:54,160 --> 00:04:56,201
E um mapa é apenas algo
como um pedaço de papel

133
00:04:56,201 --> 00:04:59,180
que lhe dá direções e tem
talvez uma grade de coordenadas x e y.

134
00:04:59,180 --> 00:05:00,540
Então aqui está um mapa de bits.

135
00:05:00,540 --> 00:05:03,680
É um mapa de bits
em que 1 é um aparentemente

136
00:05:03,680 --> 00:05:07,857
vai representar um pixel branco, e um
0 vai representar um pixel preto.

137
00:05:07,857 --> 00:05:09,440
Mas nós certamente poderia lançá-lo ao redor.

138
00:05:09,440 --> 00:05:11,648
Realmente não importa,
Desde que estejamos consistente.

139
00:05:11,648 --> 00:05:15,570
E aqui está como, em binary-- dentro
de memória de um computador, ou mesmo dentro

140
00:05:15,570 --> 00:05:18,160
de um arquivo no seu disco
drive-- você pode armazenar

141
00:05:18,160 --> 00:05:20,240
a mais simples das imagens da cara do smiley.

142
00:05:20,240 --> 00:05:23,990
Mas o que devemos, naturalmente,
falta nesta imagem?

143
00:05:23,990 --> 00:05:24,610
Cor, certo?

144
00:05:24,610 --> 00:05:28,220
É um próximo passo óbvio ou
realce para melhorar este com a cor.

145
00:05:28,220 --> 00:05:32,230
Então, infelizmente, com apenas um único
bit, 0 ou 1, poderíamos representar cores.

146
00:05:32,230 --> 00:05:36,100
Isso poderia ser vermelho ou azul, ou
preto, ou branco, ou verde, ou cor de rosa,

147
00:05:36,100 --> 00:05:37,420
ou qualquer par de cores.

148
00:05:37,420 --> 00:05:40,860
Mas, para simplificar, vamos
simplesmente assumir preto e branco.

149
00:05:40,860 --> 00:05:45,930
>> Então, o que logicamente que precisamos se nós
deseja implementar cor em uma imagem?

150
00:05:45,930 --> 00:05:49,080
O que nós temos que fazer?

151
00:05:49,080 --> 00:05:51,900
Como se o fator limitante aqui
é que, com um pouco você só pode

152
00:05:51,900 --> 00:05:55,977
representam dois estados, 0 ou 1, branco
ou preto, o que você quer fazer?

153
00:05:55,977 --> 00:05:56,810
Audiência: mais dados.

154
00:05:56,810 --> 00:05:58,813
DAVID J. MALAN: mais bits,
, yeah mais dados, mais bits.

155
00:05:58,813 --> 00:06:01,440
E, de fato, isso é exatamente como
imagens a cores são representadas.

156
00:06:01,440 --> 00:06:05,120
Em vez de usar um único bit, uma
0 ou 1 para cada pixel, cada ponto,

157
00:06:05,120 --> 00:06:06,170
você acabou de usar múltipla.

158
00:06:06,170 --> 00:06:09,660
Talvez use 8, talvez, mais comumente
utilizar 24 e, na verdade, no Conjunto de Problemas

159
00:06:09,660 --> 00:06:13,300
4, você vai jogar com um arquivo
formato que usa 24 bits normalmente.

160
00:06:13,300 --> 00:06:15,430
>> Mas a maioria de vocês provavelmente estão
familiarizado com JPEGs.

161
00:06:15,430 --> 00:06:17,460
Se você já tomadas
uma foto em seu telefone,

162
00:06:17,460 --> 00:06:20,360
ou enviados ou visto algo sobre
Facebook ou Flickr, qualquer número

163
00:06:20,360 --> 00:06:24,882
de sites baseados em fotos, você tem
provavelmente já viu uma imagem JPEG antes.

164
00:06:24,882 --> 00:06:27,840
E ao que parece, este é o arquivo
formato que vamos usar em PSet 4,

165
00:06:27,840 --> 00:06:30,340
em que você vai
ter de recuperar imagens

166
00:06:30,340 --> 00:06:35,160
que eu acidentalmente excluídos de um
cartão de memória corrompida na câmera,

167
00:06:35,160 --> 00:06:35,800
Se você for.

168
00:06:35,800 --> 00:06:38,490
>> E verifica-se que, apesar de
JPEG é bastante sophisticated--

169
00:06:38,490 --> 00:06:40,906
é muito mais sofisticado
do que os pontos preto e branco

170
00:06:40,906 --> 00:06:44,480
vimos há pouco, porque há
algoritmos sofisticados que realmente

171
00:06:44,480 --> 00:06:47,410
são usados ​​para compactar um arquivo JPEG, de modo
que você pode ter um muito bom,

172
00:06:47,410 --> 00:06:49,832
qualidade de imagem, mas usando
relativamente poucos bits.

173
00:06:49,832 --> 00:06:51,790
E nós vamos voltar a
compressão antes do tempo.

174
00:06:51,790 --> 00:06:56,280
Acontece que o primeiro
três bytes de um image-- JPEG

175
00:06:56,280 --> 00:07:02,750
não importa o que você tenha tomado uma fotografia
de-- são os valores 255, 216, 255.

176
00:07:02,750 --> 00:07:05,990
>> Em outras palavras, se você apenas
ver que o padrão de bits,

177
00:07:05,990 --> 00:07:09,180
aqui representada como três
bytes, ou 24 bits no total,

178
00:07:09,180 --> 00:07:13,810
com elevada probabilidade, você pode inferir que
você está olhando para ele este três primeiros

179
00:07:13,810 --> 00:07:15,230
bytes de um JPEG.

180
00:07:15,230 --> 00:07:18,040
E isso é o que é conhecido
como a assinatura de um JPEG.

181
00:07:18,040 --> 00:07:20,540
Um monte de formatos de arquivo
lá fora, tendem a começar

182
00:07:20,540 --> 00:07:23,735
com certos padrões de 0s e 1s,
para que o Windows e Mac OS, e iOS,

183
00:07:23,735 --> 00:07:28,272
Android e saber que tipo de arquivo que eles
são, em adição ao ficheiro de chamada

184
00:07:28,272 --> 00:07:29,730
extensão que um monte de arquivos têm.

185
00:07:29,730 --> 00:07:32,590
Se você tiver .jpg, isso é
outra pista para o computador.

186
00:07:32,590 --> 00:07:35,310
>> Então, vamos agora olhar para este
um pouco mais tecnicamente.

187
00:07:35,310 --> 00:07:37,390
Sabemos que o decimal
sistema é de 0 a 9.

188
00:07:37,390 --> 00:07:38,740
Sabemos binário é 0 e 1.

189
00:07:38,740 --> 00:07:41,842
E se você acha que volta para PSet
0, tivemos você lutar com,

190
00:07:41,842 --> 00:07:43,800
para um pouco, algo
chamado hexadecimal,

191
00:07:43,800 --> 00:07:47,320
onde você tem 16 dígitos,
10, em vez de ou em vez de 2.

192
00:07:47,320 --> 00:07:50,405
E esses dígitos, por convenção,
são de 0 a 9 e, em seguida, uma

193
00:07:50,405 --> 00:07:55,040
através de f, onde f representa o que
número decimal, assim como a sanidade rápida

194
00:07:55,040 --> 00:07:56,640
Verifica?

195
00:07:56,640 --> 00:07:57,610
Então, 15.

196
00:07:57,610 --> 00:08:01,390
E um deve representar 10, apenas por
natureza da ordem que eu dei.

197
00:08:01,390 --> 00:08:04,350
É apenas uma convenção arbitrária,
mas é bastante padrão.

198
00:08:04,350 --> 00:08:06,870
>> Portanto, se olharmos para este padrão
de três bytes-- vamos

199
00:08:06,870 --> 00:08:09,620
basta começar a olhar para ele de
uma forma consistente com a forma como

200
00:08:09,620 --> 00:08:12,450
cientistas da computação em geral
olhar e pensar sobre arquivos.

201
00:08:12,450 --> 00:08:15,580
Você certamente pode pensar em
arquivos em 0s e 1s, e decimal,

202
00:08:15,580 --> 00:08:19,340
mas, na realidade, nós tendemos a usar binário
ou, mais tipicamente hexadecimal--

203
00:08:19,340 --> 00:08:20,760
de volta de PSet 0.

204
00:08:20,760 --> 00:08:25,857
Então deixe-me propor que 255, 216, e 255
são apenas esses padrões de 0s e 1s.

205
00:08:25,857 --> 00:08:28,440
E você pode verificar isso, se você
quer fazer a matemática de Semana 0.

206
00:08:28,440 --> 00:08:30,810
Mas, por agora, apenas supor
que este é realmente correta.

207
00:08:30,810 --> 00:08:33,850
Acabei reescrito três decimal
números como três valores binários.

208
00:08:33,850 --> 00:08:36,100
Agora o que eu vou fazer é
basta adicionar algum espaço em branco,

209
00:08:36,100 --> 00:08:37,266
apenas pelo amor de legibilidade.

210
00:08:37,266 --> 00:08:39,940
E observem, eu só vou
para mover as coisas separadas.

211
00:08:39,940 --> 00:08:43,090
Portanto, antes de, após, antes, depois.

212
00:08:43,090 --> 00:08:46,180
Eu estou fazendo nada mais interessante
que apenas se espalhando para fora coisas assim

213
00:08:46,180 --> 00:08:50,380
que a notificação de cada conjunto de oito
bocados é agora dois conjuntos de quatro bits.

214
00:08:50,380 --> 00:08:54,920
Isto é útil porque hexadecimal
é particularmente elegante

215
00:08:54,920 --> 00:09:00,930
porque cada dígito hexadecimal entre 0 e
F, ou, mais especificamente, 0 a 15,

216
00:09:00,930 --> 00:09:03,430
pode ser representada
com exatamente quatro pedaços.

217
00:09:03,430 --> 00:09:07,960
Em outras palavras, se você em hexadecimal
quer representar um 0, é apenas 0000,

218
00:09:07,960 --> 00:09:08,780
quatro zeros.

219
00:09:08,780 --> 00:09:13,997
E se você quer representar 15,
é 1111, que é quatro bits.

220
00:09:13,997 --> 00:09:16,080
E se você fizer as contas,
se este é o lugar queridos,

221
00:09:16,080 --> 00:09:18,210
este é o lugar 16s,
que vai dar vocę--

222
00:09:18,210 --> 00:09:19,960
sim que está acontecendo
a-- muito, em binário,

223
00:09:19,960 --> 00:09:23,660
que vai lhe dar 15, queridos lugar,
twos lugar, quatro e oitos lugar.

224
00:09:23,660 --> 00:09:26,821
Então deixe-me propor que que
conjunto de quatro bits na esquerda

225
00:09:26,821 --> 00:09:28,070
é o que nós vamos chamar f.

226
00:09:28,070 --> 00:09:30,110
É o maior número que
pode representar com quatro bits.

227
00:09:30,110 --> 00:09:33,300
E já sabemos de hexadecimal,
f é o maior dígitos em hexadecimal.

228
00:09:33,300 --> 00:09:36,020
Temos outro f lá,
mais por lá dois.

229
00:09:36,020 --> 00:09:38,980
E por agora, basta ter em fé
que eu fiz o direito de matemática

230
00:09:38,980 --> 00:09:41,890
e que a metade esquerda
desses bits, 1101,

231
00:09:41,890 --> 00:09:43,980
é a mesma coisa que d em hexadecimal.

232
00:09:43,980 --> 00:09:46,490
E a mão direita, 1000, está apenas a 8.

233
00:09:46,490 --> 00:09:48,140
>> E isso é fácil de ver, certo?

234
00:09:48,140 --> 00:09:51,670
A 8 represents-- é certo
debaixo daquele lugar oitos.

235
00:09:51,670 --> 00:09:56,040
Portanto, temos uma na coluna oitos
e nada nos fours, twos queridos ou.

236
00:09:56,040 --> 00:09:59,830
Então, agora mais convencional, os seres humanos tendem
para escrever dígitos hexadecimais como este,

237
00:09:59,830 --> 00:10:03,000
você apenas esmagá-los juntos,
e então você prefixar-los com 0x.

238
00:10:03,000 --> 00:10:05,920
Isso significa nada mais do que
uma pista visual para um human--

239
00:10:05,920 --> 00:10:10,350
aqui vem um value-- hexadecimal porque
que não poderiam ser óbvio.

240
00:10:10,350 --> 00:10:13,629
>> O que significa dizer, em última análise, que
o padrão de zeros e uns,

241
00:10:13,629 --> 00:10:16,170
ou o padrão de hexadecimal
dígitos equivalentemente que você é

242
00:10:16,170 --> 00:10:18,990
vai começar a procurar
no Conjunto de Problemas 4 é isto--

243
00:10:18,990 --> 00:10:22,120
e do Conjunto de Problemas 4 especificação andará
-lo através deste em mais detail--

244
00:10:22,120 --> 00:10:25,344
mas percebem como uma espécie de misterioso como
este pode parecer à primeira vista,

245
00:10:25,344 --> 00:10:27,010
você vai começar a ver muito isso.

246
00:10:27,010 --> 00:10:30,320
E, de fato, mesmo em GDB, a
depurador nós introduzimos na segunda-feira

247
00:10:30,320 --> 00:10:35,440
e Dan introduz no PSet 3, vai
muitas vezes para mostrar-lhe valores hexadecimais

248
00:10:35,440 --> 00:10:39,910
só porque eles tendem a ser mais
convencional do que decimal ou binário

249
00:10:39,910 --> 00:10:41,157
no mundo dos computadores.

250
00:10:41,157 --> 00:10:42,490
Agora vamos colocar isso em contexto.

251
00:10:42,490 --> 00:10:48,040
Muitos de vocês podem recordar este
imagem aqui, que veio de uma coisa?

252
00:10:48,040 --> 00:10:51,240
Vista, por isso mesmo mais cedo do que
que, o Windows XP fez esta estréia.

253
00:10:51,240 --> 00:10:52,620
Portanto, esta é uma bela paisagem.

254
00:10:52,620 --> 00:10:55,940
E, de fato, se você fuçar online--
Eu acho que é um artigo da Wikipédia,

255
00:10:55,940 --> 00:11:00,110
em que alguém muito surpreendentemente saiu
encontramos a localização no mundo criado

256
00:11:00,110 --> 00:11:02,240
sua câmera em
precisamente o direito Place--

257
00:11:02,240 --> 00:11:06,510
e isso hoje parece como-- mas
é exatamente a mesma configuração.

258
00:11:06,510 --> 00:11:10,060
Esta imagem, porém, é em um arquivo
chamado formato de mapa de bits, b-m-p.

259
00:11:10,060 --> 00:11:12,910
E nós estamos indo tomar um super-
rápido olhar sobre o que isso significa.

260
00:11:12,910 --> 00:11:17,770
>> Mas bitmap é apenas uma maneira diferente de
imagens que representam ainda usando pixels

261
00:11:17,770 --> 00:11:19,580
em 0s e 1s, em última instância.

262
00:11:19,580 --> 00:11:23,282
Mas pelo olhar rápido, ele tem
uma assinatura mais interessante

263
00:11:23,282 --> 00:11:24,490
no inicio do ficheiro.

264
00:11:24,490 --> 00:11:26,670
Não é apenas três
bytes, em vez há

265
00:11:26,670 --> 00:11:30,770
um monte de padrões de bytes
que têm significado predeterminado.

266
00:11:30,770 --> 00:11:34,490
Por exemplo, em algum lugar na
primeiros bytes de uma imagem bitmap

267
00:11:34,490 --> 00:11:37,440
vai ser o tamanho do
imagem, a largura da imagem,

268
00:11:37,440 --> 00:11:40,390
a altura da imagem, de modo
metadados úteis, se você quiser.

269
00:11:40,390 --> 00:11:43,940
Informações úteis que o Photoshop
ou programar todos os gráficos que você está usando

270
00:11:43,940 --> 00:11:45,180
pode realmente se preocupam.

271
00:11:45,180 --> 00:11:47,170
>> Então, mais sobre isso em
Problema jogo 4, mas esta

272
00:11:47,170 --> 00:11:49,220
é só para dizer que
no fim do dia

273
00:11:49,220 --> 00:11:52,390
todos os formatos de arquivo que você está usando
para arquivos do Microsoft Word anos--,

274
00:11:52,390 --> 00:11:55,820
Números arquivos, arquivos do Excel
qualquer número de formatos de arquivo

275
00:11:55,820 --> 00:11:57,770
que pode ter algum
extensão de arquivo conhecidos

276
00:11:57,770 --> 00:12:00,130
são apenas 0s e 1s debaixo do capô.

277
00:12:00,130 --> 00:12:02,970
E os seres humanos decidiram
o que as convenções são,

278
00:12:02,970 --> 00:12:08,340
o que padrões de 0s e 1s representam
arquivar uma palavra contra um arquivo do Excel,

279
00:12:08,340 --> 00:12:10,322
contra qualquer número de outros formatos de arquivo.

280
00:12:10,322 --> 00:12:12,780
Assim, em PSet 4, você vai ter um
oportunidade de jogar com isso.

281
00:12:12,780 --> 00:12:14,405
>> Mas o que significa ter um struct.

282
00:12:14,405 --> 00:12:18,012
Este é realmente um agradável segue agora
em C, que tem apenas um par

283
00:12:18,012 --> 00:12:20,220
características adicionais de que
nós não olhei ainda.

284
00:12:20,220 --> 00:12:24,230
É uma linguagem muito pequeno e um dos
as características agradáveis ​​sobre C é um struct.

285
00:12:24,230 --> 00:12:27,300
Por exemplo, se você
queria represent-- vamos

286
00:12:27,300 --> 00:12:33,690
diz que queria ter uma variável que
representa um aluno em algum programa.

287
00:12:33,690 --> 00:12:37,330
Talvez você estivesse escrevendo um curso
programa de registro, ou núcleo de compras

288
00:12:37,330 --> 00:12:38,870
ferramenta, ou algo parecido.

289
00:12:38,870 --> 00:12:42,922
Quais são pedaços de dados relacionados
a um estudante que vem à mente?

290
00:12:42,922 --> 00:12:44,880
Como um estudante é
representado com que valores?

291
00:12:44,880 --> 00:12:45,732
Sim?

292
00:12:45,732 --> 00:12:46,940
Você tem um nome como um estudante.

293
00:12:46,940 --> 00:12:48,900
O que mais faz um típico estudante tem?

294
00:12:48,900 --> 00:12:49,320
>> AUDIÊNCIA: [inaudível]

295
00:12:49,320 --> 00:12:50,200
>> DAVID J. MALAN: Então, desculpe.

296
00:12:50,200 --> 00:12:50,660
>> AUDIÊNCIA: Idade.

297
00:12:50,660 --> 00:12:52,980
>> DAVID J. MALAN: Uma idade ou
aniversário equivalentemente, sim.

298
00:12:52,980 --> 00:12:53,557
O que mais?

299
00:12:53,557 --> 00:12:54,390
AUDIÊNCIA: número de identificação?

300
00:12:54,390 --> 00:12:57,460
DAVID J. MALAN: Então um número de identificação, talvez
um número de telefone, talvez um dormitório ou casa,

301
00:12:57,460 --> 00:12:58,670
ou faculdade, ou algo parecido.

302
00:12:58,670 --> 00:13:01,820
Qualquer número de pedaços de dados que
você pode ter em sua lista de contatos

303
00:13:01,820 --> 00:13:03,890
é o que poderia definir um estudante.

304
00:13:03,890 --> 00:13:08,490
Então, se nós queríamos fazer isso, no código,
poderíamos fazer algo simples como este.

305
00:13:08,490 --> 00:13:15,670
Podemos ter um programa para que
tem, digamos, int main (void).

306
00:13:15,670 --> 00:13:18,920
E se eu quiser representar um
estudante eu poderia ter, por exemplo,

307
00:13:18,920 --> 00:13:24,330
uma string chamada nome para esse estudante,
uma string chamada dormitório para esse estudante,

308
00:13:24,330 --> 00:13:26,900
talvez um int chamado ID para esse estudante.

309
00:13:26,900 --> 00:13:30,840
E porque eu estou usando corda, I
precisa voltar e colocar-se CS50.h.

310
00:13:30,840 --> 00:13:33,300
Talvez eu vou precisar stdio.h.

311
00:13:33,300 --> 00:13:38,190
Então deixe-me fazer aqueles preventivamente e eu sou
vai chamar este student.c por enquanto

312
00:13:38,190 --> 00:13:40,080
e salve este.

313
00:13:40,080 --> 00:13:44,206
>> E agora eu posso fazer alguma coisa
com estas variáveis.

314
00:13:44,206 --> 00:13:46,830
E nós apenas estamos indo para escrever
que, como um comentário no código pseudo,

315
00:13:46,830 --> 00:13:48,829
porque não é interessante
o que fazemos agora.

316
00:13:48,829 --> 00:13:51,242
OK, portanto, este é um programa que
de alguma forma armazena um estudante.

317
00:13:51,242 --> 00:13:53,450
O que eu quero fazer, se eu
deseja armazenar dois estudantes?

318
00:13:53,450 --> 00:13:55,991
Então, meu primeiro instinto vai
dar tudo certo, espere um minuto,

319
00:13:55,991 --> 00:14:01,920
se eu tiver outro aluno por que não eu
apenas fazer nome da seqüência 2, seqüência de dormitório 2,

320
00:14:01,920 --> 00:14:04,190
int id2.

321
00:14:04,190 --> 00:14:06,540
E fizemos gone
por isso antes

322
00:14:06,540 --> 00:14:10,890
e qual foi a nossa solução para o que parece
para ser uma espécie de cópia de pasta hackish

323
00:14:10,890 --> 00:14:11,555
trabalho aqui?

324
00:14:11,555 --> 00:14:12,346
AUDIÊNCIA: Uma matriz.

325
00:14:12,346 --> 00:14:13,830
DAVID J. MALAN: Sim,
nós poderíamos usar uma matriz.

326
00:14:13,830 --> 00:14:15,620
Por aqui muito rapidamente
torna-se difícil.

327
00:14:15,620 --> 00:14:18,453
Você tem que classificar de forma arbitrária
começar a nomear todas essas variáveis.

328
00:14:18,453 --> 00:14:22,190
E você, o humano, tem que manter
acompanhar o que corresponde OK NAME2

329
00:14:22,190 --> 00:14:25,060
com dorm2 corresponde com ID2.

330
00:14:25,060 --> 00:14:26,200
Ele só se torna uma bagunça.

331
00:14:26,200 --> 00:14:29,350
Por isso, é muito mais fácil,
lembrar de algumas semanas atrás,

332
00:14:29,350 --> 00:14:34,300
apenas para ter de chamados nomes de cadeia
e talvez dar-nos três delas.

333
00:14:34,300 --> 00:14:36,940
E então talvez nós temos
dormitórios cordas e têm

334
00:14:36,940 --> 00:14:41,900
três destes, ou com uma constante,
int ids e têm três delas.

335
00:14:41,900 --> 00:14:45,250
Mas mesmo agora isso se sente
um pouco desleixado, certo.

336
00:14:45,250 --> 00:14:49,440
Estamos falando de estudantes e ainda
Eu realmente estou me deter sobre o nível baixo

337
00:14:49,440 --> 00:14:50,470
detalhes de implementação.

338
00:14:50,470 --> 00:14:52,790
O estudante é um nome e um dormitório e ID.

339
00:14:52,790 --> 00:14:59,814
>> Por que eu não posso simplesmente declarar uma variável
chamado de estudante e chamá-lo s.

340
00:14:59,814 --> 00:15:02,230
E se eu quiser um outro estudante,
por que não eu apenas chamá-lo t.

341
00:15:02,230 --> 00:15:05,260
Ou, se eu quiser um grupo inteiro
de estudantes, por que não eu apenas

342
00:15:05,260 --> 00:15:09,740
dizer que tenho toda uma classe de
estudantes, e é três deles.

343
00:15:09,740 --> 00:15:12,470
Em outras palavras, por que não posso vir
com meu próprio tipo de dados, chamado

344
00:15:12,470 --> 00:15:15,641
Estudantes, dentro dos quais é
um nome, é um ID, é um dormitório,

345
00:15:15,641 --> 00:15:16,890
é qualquer número de outros campos.

346
00:15:16,890 --> 00:15:19,030
E acontece que você
pode fazer exatamente isso.

347
00:15:19,030 --> 00:15:21,850
>> Então C tem esse recurso chamado struct.

348
00:15:21,850 --> 00:15:24,700
Isso é um recurso de linguagem que
nos permite fazer exatamente isso.

349
00:15:24,700 --> 00:15:28,370
Eu estou indo para ir em frente
e abrir structs.h

350
00:15:28,370 --> 00:15:32,299
onde estamos indo para ver o
seguinte definição de um estudante.

351
00:15:32,299 --> 00:15:35,215
Acontece que - e este é mesmo
mais simples do que o que envolveu um ID

352
00:15:35,215 --> 00:15:36,080
há um momento atrás.

353
00:15:36,080 --> 00:15:39,120
Se você quiser vir para cima com
seu tipo de dados caseiro,

354
00:15:39,120 --> 00:15:42,750
e para além de Int, e carvão animal e
flutuar e todos esses outros que existem,

355
00:15:42,750 --> 00:15:45,810
você pode fazê-lo literalmente
escrevendo typedef struct,

356
00:15:45,810 --> 00:15:47,880
em seguida, algumas chaves,
dentro do qual você

357
00:15:47,880 --> 00:15:51,460
listar as variáveis ​​que você deseja
associar a esta nova dados personalizado

358
00:15:51,460 --> 00:15:55,670
digite como um nome e um dormitório,
e em seguida, após as chaves

359
00:15:55,670 --> 00:15:57,860
você dar um nome para o novo tipo de dados.

360
00:15:57,860 --> 00:15:59,220
Assim, por exemplo, estudante.

361
00:15:59,220 --> 00:16:03,247
>> E o que é bom sobre isso agora é que
se olharmos para o código correspondente,

362
00:16:03,247 --> 00:16:05,080
a convenção, em primeiro lugar
de tudo, é colocar este

363
00:16:05,080 --> 00:16:08,230
em um arquivo chamado algo dot h,
um arquivo de cabeçalho, que não tem

364
00:16:08,230 --> 00:16:09,780
começou a utilizar-nos muito.

365
00:16:09,780 --> 00:16:12,120
Mas vamos começar
usando um pouco agora.

366
00:16:12,120 --> 00:16:18,650
E o que podemos fazer com isso,
em última análise, nestas poucas linhas de código

367
00:16:18,650 --> 00:16:22,130
é declarar exatamente o que
tipo de dados, um estudante.

368
00:16:22,130 --> 00:16:23,230
E agora vamos usá-lo.

369
00:16:23,230 --> 00:16:27,274
>> Eu vou agora entrar em
um arquivo chamado structs1.c.

370
00:16:27,274 --> 00:16:29,440
E vamos dar uma olhada em um
algumas características aqui.

371
00:16:29,440 --> 00:16:32,250
Então, as coisas aqui em cima é
principalmente familiar, e nós vamos

372
00:16:32,250 --> 00:16:35,040
voltar para o que não é
familiarizado em apenas um momento.

373
00:16:35,040 --> 00:16:39,880
Isto, obviamente está incluindo a minha própria
arquivo de cabeçalho, que é novo, bem como,

374
00:16:39,880 --> 00:16:42,580
excepto para PSet 3 onde,
recall, temos helpers.h.

375
00:16:42,580 --> 00:16:45,150
Então você pode se lembrar helpers.h #include.

376
00:16:45,150 --> 00:16:49,381
>> Por que eu estou usando aspas
em vez de colchetes angulares?

377
00:16:49,381 --> 00:16:50,630
Quando eu escolho entre eles?

378
00:16:50,630 --> 00:16:52,310
Quase sempre eu pareço
para usar suportes angulares.

379
00:16:52,310 --> 00:16:55,040
E então, de repente, em
linha de seis Eu estou usando aspas duplas.

380
00:16:55,040 --> 00:16:55,860
Por que poderia ser?

381
00:16:55,860 --> 00:16:56,700
Sim?

382
00:16:56,700 --> 00:16:57,725
>> AUDIÊNCIA: [inaudível]

383
00:16:57,725 --> 00:16:59,350
DAVID J. MALAN: Isso é um real, o quê?

384
00:16:59,350 --> 00:17:00,559
AUDIÊNCIA: É na sua IDE.

385
00:17:00,559 --> 00:17:02,475
DAVID J. MALAN: Sim,
que está no meu IDE real.

386
00:17:02,475 --> 00:17:05,690
E não vamos debruçar sobre o IDE, porque
isso é apenas uma ferramenta que eu estou usando.

387
00:17:05,690 --> 00:17:08,119
Isso está no meu atual
diretório, especificamente.

388
00:17:08,119 --> 00:17:11,647
Então structs.h é o meu próprio arquivo
não instalado no IDE,

389
00:17:11,647 --> 00:17:14,480
no próprio sistema operativo,
ao contrário, está no meu diretório atual.

390
00:17:14,480 --> 00:17:16,910
Assim, a convenção é se você quiser
para incluir seu próprio arquivo de cabeçalho,

391
00:17:16,910 --> 00:17:18,200
você acabou de usar aspas duplas.

392
00:17:18,200 --> 00:17:23,290
>> O que nós chamamos essa coisa em
linha 8, de um modo geral?

393
00:17:23,290 --> 00:17:25,200
Isso é o que?

394
00:17:25,200 --> 00:17:28,220
algo # define.

395
00:17:28,220 --> 00:17:31,040
Isso representa constantes, certo?

396
00:17:31,040 --> 00:17:33,140
Se você quiser ter um
valor em seu programa

397
00:17:33,140 --> 00:17:35,110
que você use um todo
monte de vezes, é

398
00:17:35,110 --> 00:17:39,330
boa convenção para incluí-lo para fora,
declará-la, com o símbolo de hash

399
00:17:39,330 --> 00:17:43,340
definir, em seguida, por convenção, em todos
maiúsculas word-- embora não seja

400
00:17:43,340 --> 00:17:45,320
estritamente necessário, mas
é convenção humana

401
00:17:45,320 --> 00:17:47,210
para capitalizar constantes
de modo que eles pulam para fora

402
00:17:47,210 --> 00:17:50,380
em você visually-- espaço e
então o valor que você quer ser

403
00:17:50,380 --> 00:17:52,250
equivalente ao que o nome da constante.

404
00:17:52,250 --> 00:17:56,110
Sem ponto e vírgula, mas você simplesmente
siga esse padrão existe.

405
00:17:56,110 --> 00:17:57,770
>> Então, o que estou fazendo neste código real.

406
00:17:57,770 --> 00:18:00,660
Então, vamos dar uma olhada
o principal programa aqui.

407
00:18:00,660 --> 00:18:04,080
Na linha 12, porque eu
incluíram structs.h,

408
00:18:04,080 --> 00:18:06,492
Agora tenho magicamente no meu
eliminação de um novo tipo de dados.

409
00:18:06,492 --> 00:18:09,200
Eu apenas não têm acesso à int,
e char, e float, e corda,

410
00:18:09,200 --> 00:18:10,060
e azul e outros.

411
00:18:10,060 --> 00:18:12,470
Agora tenho acesso a
um tipo de dados do aluno.

412
00:18:12,470 --> 00:18:17,740
Assim, em linha 12, eu estou combinando dois
ideas-- um um tipo de dados personalizado e dois,

413
00:18:17,740 --> 00:18:18,940
utilizando uma matriz.

414
00:18:18,940 --> 00:18:21,700
E assim, este programa se
Eu quero realmente apoiar

415
00:18:21,700 --> 00:18:24,320
três estudantes diferentes
no meu programa, eu

416
00:18:24,320 --> 00:18:30,480
pode simplesmente dizer me dê uma variável
chamados alunos, cada um dos quais

417
00:18:30,480 --> 00:18:32,970
é de estudantes tipo, que
é o meu tipo de dados personalizado.

418
00:18:32,970 --> 00:18:35,890
E, especificamente, dá-me
três daqueles na minha matriz.

419
00:18:35,890 --> 00:18:37,750
>> Então, agora, o que fazemos neste programa?

420
00:18:37,750 --> 00:18:40,670
Aqui é apenas um para a iteração de loop
de 0 a 3, que é porque

421
00:18:40,670 --> 00:18:42,110
qual é o valor de estudantes é.

422
00:18:42,110 --> 00:18:44,420
Eu só estou pedindo ao utilizador
dá-me o nome do aluno.

423
00:18:44,420 --> 00:18:48,090
E, em seguida, na linha 17, nós
ter uma linha na maior parte familiar.

424
00:18:48,090 --> 00:18:50,370
Temos o nosso velho amigo
GetString à direita.

425
00:18:50,370 --> 00:18:52,345
E o pedaço de sintaxe
é aparentemente nova,

426
00:18:52,345 --> 00:18:55,130
se você nunca programado em C antes,
e nunca usou as estruturas?

427
00:18:55,130 --> 00:18:55,510
Sim?

428
00:18:55,510 --> 00:18:56,417
>> AUDIÊNCIA: O .name.

429
00:18:56,417 --> 00:18:57,500
DAVID J. MALAN: O .name.

430
00:18:57,500 --> 00:19:01,220
Mas isso não é muito de um salto,
porque agora os alunos adaptador

431
00:19:01,220 --> 00:19:02,590
dá-lhe o estudante i-th.

432
00:19:02,590 --> 00:19:04,730
E se você quiser mergulhar
dentro da referida estrutura,

433
00:19:04,730 --> 00:19:09,490
basta usar um único período e
em seguida, o nome da variável dentro,

434
00:19:09,490 --> 00:19:11,900
ou a propriedade dentro desse
Você quer ter acesso.

435
00:19:11,900 --> 00:19:14,816
Da mesma forma, em seguida, se eu, em seguida, solicitar que o
usuário, dá-me dormitório do aluno,

436
00:19:14,816 --> 00:19:18,390
você pode armazenar de forma semelhante que
cadeia na variável dormitório dentro

437
00:19:18,390 --> 00:19:19,940
de que a estrutura estudante.

438
00:19:19,940 --> 00:19:21,410
>> E agora as coisas ficam um pouco extravagante.

439
00:19:21,410 --> 00:19:24,420
E isso está indo olhar
talvez em um lote muito em breve.

440
00:19:24,420 --> 00:19:27,970
Mas você vai ver isso muito mais em PSet
4, então, basta olhar para ele agora vamos.

441
00:19:27,970 --> 00:19:33,364
Acontece que na linha 23 através
38, o que você acha que eu estou fazendo, talvez?

442
00:19:33,364 --> 00:19:35,530
Eu removi os comentários
para hoje, mas a versão

443
00:19:35,530 --> 00:19:38,660
do código online
referência tem todos os comentários.

444
00:19:38,660 --> 00:19:40,171
O que parece que estou fazendo?

445
00:19:40,171 --> 00:19:42,530
>> AUDIÊNCIA: Salvar o arquivo com todas
as informações que o usuário inseriu.

446
00:19:42,530 --> 00:19:44,530
>> DAVID J. MALAN: Sim,
exatamente, esta é uma nova forma

447
00:19:44,530 --> 00:19:46,370
que estamos vendo dois,
Outra característica de C,

448
00:19:46,370 --> 00:19:48,700
em que posso criar meus próprios arquivos.

449
00:19:48,700 --> 00:19:51,580
Até agora, quase todos os programas
você escreveu é apátrida.

450
00:19:51,580 --> 00:19:53,334
Assim que ele é feito em execução, é isso.

451
00:19:53,334 --> 00:19:55,000
Não há memória ou recordação dele.

452
00:19:55,000 --> 00:19:56,110
Não há nenhum arquivo salvo.

453
00:19:56,110 --> 00:19:58,120
Mas se você quiser
salvar entrada que tem

454
00:19:58,120 --> 00:20:02,100
aconteceu, como em um jogo ou um programa
como este, ao que parece nós podemos fazê-lo.

455
00:20:02,100 --> 00:20:04,360
E você vai ver isso mais
em PSet 4 e na Seção.

456
00:20:04,360 --> 00:20:08,661
Mas esta linha 23 essencialmente
cria um arquivo chamado students.csv.

457
00:20:08,661 --> 00:20:10,160
E você pode ter visto isso antes.

458
00:20:10,160 --> 00:20:14,250
Mesmo que você nunca tenha estudado CS antes,
CSV é variáveis ​​separados por vírgulas.

459
00:20:14,250 --> 00:20:19,000
É como um homem muito pobre de
versão de um arquivo do Excel,

460
00:20:19,000 --> 00:20:22,270
o que significa que ele pode ser aberto
em Excel e em Números da Apple,

461
00:20:22,270 --> 00:20:23,830
e tem linhas e colunas.

462
00:20:23,830 --> 00:20:26,485
Mas não é uma propriedade
formato como a Microsoft ou a Apple.

463
00:20:26,485 --> 00:20:29,840
É apenas vírgulas que separam o
valores que veremos em um momento.

464
00:20:29,840 --> 00:20:31,010
>> E apenas dar um palpite.

465
00:20:31,010 --> 00:20:33,480
Na linha 23, no
final, o meu segundo argumento

466
00:20:33,480 --> 00:20:37,700
a esta nova função chamada
f aberto para arquivo aberto é w.

467
00:20:37,700 --> 00:20:39,430
O que pode denotar w?

468
00:20:39,430 --> 00:20:40,022
Sim?

469
00:20:40,022 --> 00:20:41,260
>> AUDIÊNCIA: Ele permite que você gravar o arquivo?

470
00:20:41,260 --> 00:20:42,630
>> DAVID J. MALAN: Deixa
você gravar o arquivo.

471
00:20:42,630 --> 00:20:44,810
Portanto, há um par de variantes
que podemos ligar aqui.

472
00:20:44,810 --> 00:20:47,184
Mas se você só quer ler
o arquivo, que é olhar para ele

473
00:20:47,184 --> 00:20:50,010
e lê-lo para a memória, você
basta usar entre aspas "r".

474
00:20:50,010 --> 00:20:53,110
Se você quiser escrever para o
arquivo, use entre aspas "w".

475
00:20:53,110 --> 00:20:55,190
Há também é acrescentar e
um par de outras coisas

476
00:20:55,190 --> 00:20:57,356
se você quiser modificar os arquivos existentes.

477
00:20:57,356 --> 00:21:00,480
Agora vamos continuar vendo este
coisa, então vamos voltar para a linha 24.

478
00:21:00,480 --> 00:21:02,640
NULL, ao que parece, é
um valor especial que

479
00:21:02,640 --> 00:21:06,070
podem ser devolvidos por certas funções
se algo foi wrong--

480
00:21:06,070 --> 00:21:08,490
se o arquivo não existir,
se você ficar sem memória,

481
00:21:08,490 --> 00:21:09,620
ou um monte de outros erros.

482
00:21:09,620 --> 00:21:13,470
Mas, por enquanto, vamos apenas supor que essa
verificação de erros é apenas convencional.

483
00:21:13,470 --> 00:21:17,090
Aqui na linha 26, eu estou iteração
0-3 sobre todos os meus alunos.

484
00:21:17,090 --> 00:21:20,470
E este é o tipo de espécie
de uma nova função, fprintf,

485
00:21:20,470 --> 00:21:21,460
mas apenas dar um palpite.

486
00:21:21,460 --> 00:21:24,370
Se printf é apenas impressão
uma string formatada,

487
00:21:24,370 --> 00:21:26,507
o que fprintf provavelmente significa?

488
00:21:26,507 --> 00:21:27,590
AUDIÊNCIA: Imprimir em um arquivo.

489
00:21:27,590 --> 00:21:29,290
DAVID J. MALAN: Imprimir um
string formatada para um arquivo.

490
00:21:29,290 --> 00:21:31,180
Isso é o que a adicional
f meios é arquivo.

491
00:21:31,180 --> 00:21:36,420
E o novo primeiro argumento tem de ser
a variável que representa o arquivo.

492
00:21:36,420 --> 00:21:38,866
Então só temos um formato
corda assim como printf.

493
00:21:38,866 --> 00:21:40,740
E mesmo que esta
sintaxe é novo, isso só

494
00:21:40,740 --> 00:21:44,610
significa ligar o nome do aluno,
plug-in do dormitório estudantil e, em seguida,

495
00:21:44,610 --> 00:21:47,160
com fclose, feche o arquivo.

496
00:21:47,160 --> 00:21:49,730
E então lastly-- isto é novo
e nós vamos voltar a este

497
00:21:49,730 --> 00:21:53,240
antes long-- Estou liberando
o estudante por razões

498
00:21:53,240 --> 00:21:54,860
que aconteceu lá em cima.

499
00:21:54,860 --> 00:21:56,820
Mas vamos voltar
para que, antes de long--

500
00:21:56,820 --> 00:21:59,820
isso é por causa de como é GetString
realmente trabalhando debaixo do capô.

501
00:21:59,820 --> 00:22:01,280
>> Então, vamos dar uma olhada rápida aqui.

502
00:22:01,280 --> 00:22:04,380
Se eu digitar ls no meu diretório,
notar que eu não faço

503
00:22:04,380 --> 00:22:09,360
tem um arquivo chamado students.csv,
simplesmente não existe, não existe.

504
00:22:09,360 --> 00:22:14,965
Então, se eu agora compilar este programa,
fazer structs-1,. / structs-1,

505
00:22:14,965 --> 00:22:20,570
e eu estou indo para ir em frente e digitar
Andi, que vive em Berkeley na Universidade de Yale.

506
00:22:20,570 --> 00:22:26,350
Nós vamos ter que Rob
vive em Thayer estes dias.

507
00:22:26,350 --> 00:22:33,760
E vamos chegar a onde
é, penso eu, Maria está em Mather,

508
00:22:33,760 --> 00:22:35,100
se eu ter lembrado corretamente.

509
00:22:35,100 --> 00:22:36,460
>> Portanto, nada parece acontecer.

510
00:22:36,460 --> 00:22:40,680
Mas se eu digitar ls agora,
há students.csv.

511
00:22:40,680 --> 00:22:43,080
Vamos em frente e students.csv aberto.

512
00:22:43,080 --> 00:22:46,050
Esta é mais uma vez um muito
formato de arquivo leve.

513
00:22:46,050 --> 00:22:49,570
Mas eu simplesmente adotou uma convenção
que eu tenho duas linhas e colunas aqui.

514
00:22:49,570 --> 00:22:52,020
A coluna é primeiro
primeiros nomes das pessoas.

515
00:22:52,020 --> 00:22:55,740
A segunda coluna é o estudante de
dormitório, ou faculdade, ou casa, ou outros enfeites.

516
00:22:55,740 --> 00:22:57,900
E agora eu tenho guardado esse
permanentemente em um arquivo.

517
00:22:57,900 --> 00:22:59,280
>> Portanto, não é tão interessante.

518
00:22:59,280 --> 00:23:02,980
Mas este é apenas um trampolim agora
para ser capaz de manter as informações

519
00:23:02,980 --> 00:23:04,040
permanentemente.

520
00:23:04,040 --> 00:23:08,340
Então vamos ver agora o que mais nós podemos
fazer com essas e outras características.

521
00:23:08,340 --> 00:23:10,729
Mas, primeiro, alguma pergunta?

522
00:23:10,729 --> 00:23:12,145
Isso foi muito, e isso foi rápido.

523
00:23:12,145 --> 00:23:16,131
Mas você vai ver um monte
mais em PSet 4, bem.

524
00:23:16,131 --> 00:23:16,630
Sim?

525
00:23:16,630 --> 00:23:19,360
>> AUDIÊNCIA: Existe uma maneira de
continuar a adicionar nomes para esse arquivo?

526
00:23:19,360 --> 00:23:19,880
>> DAVID J. MALAN: Boa pergunta.

527
00:23:19,880 --> 00:23:21,800
Existe uma maneira de continuar
adicionando nomes para esse arquivo?

528
00:23:21,800 --> 00:23:22,340
Sim.

529
00:23:22,340 --> 00:23:24,630
E, de fato, se você acabar
se re-abrir o arquivo,

530
00:23:24,630 --> 00:23:26,780
você usaria Citação
unquote "a" por acréscimo,

531
00:23:26,780 --> 00:23:31,090
que gostaria apenas de acrescentar uma nova linha, a
nova linha de novo e de novo, exatamente.

532
00:23:31,090 --> 00:23:32,010
Boa pergunta.

533
00:23:32,010 --> 00:23:32,950
Outras perguntas?

534
00:23:32,950 --> 00:23:33,450
Sim?

535
00:23:33,450 --> 00:23:35,580
Audiência: Se você executou o
programa novamente agora,

536
00:23:35,580 --> 00:23:38,000
seria continuar a adicionar nomes para o
arquivar ou seria abrir um novo arquivo?

537
00:23:38,000 --> 00:23:38,740
>> DAVID J. MALAN: Ah, boa pergunta.

538
00:23:38,740 --> 00:23:41,448
Se você executou o programa novamente à direita
agora, talvez digitado em novos nomes,

539
00:23:41,448 --> 00:23:44,820
seria adicionar ao arquivo
ou substituir o arquivo?

540
00:23:44,820 --> 00:23:47,420
Este último, porque eu sou
não usar o modo de acréscimo.

541
00:23:47,420 --> 00:23:49,930
E porque eu sou apenas cegamente
abrir o arquivo para escrita,

542
00:23:49,930 --> 00:23:51,310
é só ir para substituir o arquivo.

543
00:23:51,310 --> 00:23:54,570
Então, eu seria realmente precisa fazer é acrescentar,
se eu quiser realmente ter um longo prazo

544
00:23:54,570 --> 00:23:55,350
banco de dados.

545
00:23:55,350 --> 00:23:58,220
>> Agora CSV é útil, francamente, mesmo
para como se você é writing--

546
00:23:58,220 --> 00:24:00,100
e vamos finalmente ver este
no final do semestre, quando

547
00:24:00,100 --> 00:24:01,455
usamos CSVs para outros fins.

548
00:24:01,455 --> 00:24:04,920
Se você deseja armazenar todas as pessoas
que se inscreveram para algum evento,

549
00:24:04,920 --> 00:24:07,420
ou se inscreveu para o aluno
grupo, ou algo parecido,

550
00:24:07,420 --> 00:24:10,330
armazenar os dados neste tipo
de formato é super conveniente.

551
00:24:10,330 --> 00:24:12,580
Porque, literalmente, se eu
foram para o download deste arquivo.

552
00:24:12,580 --> 00:24:14,540
Eu poderia double-- e
vamos realmente tentar isso

553
00:24:14,540 --> 00:24:16,720
se eu tiver Excel ou Numbers aqui.

554
00:24:16,720 --> 00:24:19,130
>> Vou botão direito do mouse
ou control-clique meu arquivo.

555
00:24:19,130 --> 00:24:20,020
Whoops.

556
00:24:20,020 --> 00:24:21,830
Botão direito do mouse ou controle clique com o meu arquivo.

557
00:24:21,830 --> 00:24:24,960
Vamos lá, meu mouse não está cooperando.

558
00:24:24,960 --> 00:24:32,694
Download-- eu vou
baixar todos os arquivos aqui para

559
00:24:32,694 --> 00:24:33,860
só assim eu posso pegar este.

560
00:24:33,860 --> 00:24:37,850
E vamos ver se isso funciona
primeira vez students.csv--

561
00:24:37,850 --> 00:24:39,310
Eu ativada.

562
00:24:39,310 --> 00:24:41,360
Agora eles querem ver meus contatos.

563
00:24:41,360 --> 00:24:44,310
Agora, eu preciso me registrar.

564
00:24:44,310 --> 00:24:47,620
Veja como é fácil usar CSVs?

565
00:24:47,620 --> 00:24:50,840
Sim, mantenha-o atualizado.

566
00:24:50,840 --> 00:24:52,375
OK, agora estamos prontos para a aula.

567
00:24:52,375 --> 00:24:58,750

568
00:24:58,750 --> 00:25:00,370
OK, oh, o que há de novo?

569
00:25:00,370 --> 00:25:02,920
OK, fechar.

570
00:25:02,920 --> 00:25:04,750
Isso foi mágica.

571
00:25:04,750 --> 00:25:07,280
OK, agora temos que atualizar.

572
00:25:07,280 --> 00:25:10,890
E agora, ele esqueceu o que
arquivar I originalmente inaugurado,

573
00:25:10,890 --> 00:25:13,090
mas o que A-- lá vamos nós.

574
00:25:13,090 --> 00:25:16,341
OK, então agora temos um arquivo do Excel.

575
00:25:16,341 --> 00:25:18,290
Obrigado.

576
00:25:18,290 --> 00:25:20,764
>> OK, então o que eu fiz foi a parte fácil.

577
00:25:20,764 --> 00:25:23,930
Claro que eu poderia ter pré-instalado
Excel ou Numbers, ou qualquer programa.

578
00:25:23,930 --> 00:25:25,846
Mas isso é bom, porque
agora eu posso manipular

579
00:25:25,846 --> 00:25:28,090
os dados em um formato padrão.

580
00:25:28,090 --> 00:25:30,294
>> Então agora vamos contexto
mudar para onde paramos

581
00:25:30,294 --> 00:25:32,710
última vez, o que era para começar
para tirar rodinhas.

582
00:25:32,710 --> 00:25:34,543
Mas, primeiro, você não fez
veja este almoço mais cedo

583
00:25:34,543 --> 00:25:38,150
está novamente acontecendo aqui no fogo e
Gelo em Cambridge, Sitar em New Haven.

584
00:25:38,150 --> 00:25:43,150
Registe-se no site o mais rápido possível CS50s
para se juntar a estudantes CS50 e funcionários.

585
00:25:43,150 --> 00:25:46,090
>> Por isso, tomou rodinhas
na segunda-feira como follows--

586
00:25:46,090 --> 00:25:49,120
corda tenha sido declarada em
Biblioteca CS50s durante algum tempo.

587
00:25:49,120 --> 00:25:52,650
E é bom, porque permite
nós para falar sobre variáveis ​​como sendo

588
00:25:52,650 --> 00:25:54,660
palavras e frases completas e mais.

589
00:25:54,660 --> 00:25:56,710
Mas acontece cadeia não existe.

590
00:25:56,710 --> 00:26:00,200
Isso é apenas um sinônimo, ou um alias,
que criamos para algo que

591
00:26:00,200 --> 00:26:03,780
na verdade, é um pouco mais
técnico chamado um char *.

592
00:26:03,780 --> 00:26:07,900
>> E, de fato, vimos um exemplo
de um programa na segunda-feira

593
00:26:07,900 --> 00:26:11,200
que não se comportou bem como esperávamos.

594
00:26:11,200 --> 00:26:13,630
Este foi o arquivo, comparar-0.

595
00:26:13,630 --> 00:26:17,910
E lembrar que comparar-0, se
Eu recompilar programa de segunda-feira

596
00:26:17,910 --> 00:26:22,670
e executar comparar-0 e digite mãe em
minúsculas, e mãe em minúsculas novamente.

597
00:26:22,670 --> 00:26:25,320
O programa insistiu I
escreva coisas diferentes,

598
00:26:25,320 --> 00:26:29,210
mesmo que a mãe, tudo em
minúsculas, é idêntica visualmente.

599
00:26:29,210 --> 00:26:31,990
Então, qual foi a resposta curta
por que o computador pensa

600
00:26:31,990 --> 00:26:34,500
essas duas seqüências são diferentes?

601
00:26:34,500 --> 00:26:35,250
Sim?

602
00:26:35,250 --> 00:26:36,534
>> AUDIÊNCIA: [inaudível]

603
00:26:36,534 --> 00:26:37,450
DAVID J. MALAN: Certo.

604
00:26:37,450 --> 00:26:39,600
Então, a mãe, a primeira vez
Eu escrevê-la no, está sendo

605
00:26:39,600 --> 00:26:42,710
armazenado em algum lugar no meu computador de
memória, mas num local diferente

606
00:26:42,710 --> 00:26:44,690
que a segunda vez que eu digitar mãe.

607
00:26:44,690 --> 00:26:46,580
Agora ele certamente poderia ser otimizado.

608
00:26:46,580 --> 00:26:49,205
O computador pode ser inteligente e
realizar estas duas cordas, hey,

609
00:26:49,205 --> 00:26:49,954
eles são idênticos.

610
00:26:49,954 --> 00:26:51,520
Deixe-me não redundantemente armazená-lo.

611
00:26:51,520 --> 00:26:54,229
Mas os computadores não fazem isso
otimização a menos que você diga a eles para.

612
00:26:54,229 --> 00:26:56,061
Então, por padrão, eles são
só vai acabar

613
00:26:56,061 --> 00:26:57,670
em dois lugares diferentes na memória.

614
00:26:57,670 --> 00:27:01,570
E assim, para ser mais claro, quando
nós comparamos as duas cordas,

615
00:27:01,570 --> 00:27:03,950
O primeiro foi chamado de s,
o segundo foi chamado

616
00:27:03,950 --> 00:27:08,530
t, o que foi que eu especificamente
comparando aqui na linha 13?

617
00:27:08,530 --> 00:27:09,494
Sim.

618
00:27:09,494 --> 00:27:12,390
>> AUDIÊNCIA: É o lugar na memória
que a variável irá apontar para.

619
00:27:12,390 --> 00:27:14,900
>> DAVID J. MALAN: Exatamente, eu estava
comparando o local na memória

620
00:27:14,900 --> 00:27:16,300
que essas variáveis ​​apontado.

621
00:27:16,300 --> 00:27:20,560
Então, especificamente, se a mãe estava em
número de bytes 1 e 2, e 3,

622
00:27:20,560 --> 00:27:24,020
4-- e lembre-se porque a barra invertida
0 precisa ser todo o caminho no final.

623
00:27:24,020 --> 00:27:29,420
E a outra instância da mãe, m-o-m,
Foi no endereço 10, 11, 12 e 13.

624
00:27:29,420 --> 00:27:33,100
Eu estava comparando 1, esse endereço,
essa localização na memória,

625
00:27:33,100 --> 00:27:35,160
contra 10, que é
obviamente, não é o mesmo.

626
00:27:35,160 --> 00:27:36,260
1 não é 10.

627
00:27:36,260 --> 00:27:39,620
>> Portanto, este é agradável em que
é bastante simples.

628
00:27:39,620 --> 00:27:42,870
Mas é problemático na medida em que
parece que não conseguimos para comparar strings.

629
00:27:42,870 --> 00:27:44,930
Então fundamentally--
e neste nível baixo,

630
00:27:44,930 --> 00:27:47,300
se você queria implementar
um programa para comparar

631
00:27:47,300 --> 00:27:50,270
duas palavras separadas que o
usuário digitou em para a qualidade,

632
00:27:50,270 --> 00:27:53,944
fazer eles se alinham para carbonizar
char, apenas em termos gerais,

633
00:27:53,944 --> 00:27:55,360
o que precisamos fazer, aparentemente?

634
00:27:55,360 --> 00:27:57,940
Não é suficiente apenas para
olhar para os dois endereços.

635
00:27:57,940 --> 00:27:58,860
O que precisamos fazer?

636
00:27:58,860 --> 00:27:59,360
Sim?

637
00:27:59,360 --> 00:28:01,120
>> AUDIÊNCIA: Iterar
a string [inaudível].

638
00:28:01,120 --> 00:28:02,600
>> DAVID J. MALAN: Sim, vamos
percorrer a string.

639
00:28:02,600 --> 00:28:05,808
Vamos usar um loop, um loop while, ou
o que você sente mais confortável.

640
00:28:05,808 --> 00:28:08,840
E se nós temos duas cordas em algum lugar
na memória, vamos olhar para cada um de

641
00:28:08,840 --> 00:28:11,770
primeiro caractere, em seguida, cada segundo é
personagem, então terceiro e quarto,

642
00:28:11,770 --> 00:28:15,206
e quinto, até chegarmos
o valor especial sentinela?

643
00:28:15,206 --> 00:28:16,080
AUDIÊNCIA: [inaudível]

644
00:28:16,080 --> 00:28:18,800
DAVID J. MALAN: Sim, a barra invertida
zero, altura em que em qualquer cadeia

645
00:28:18,800 --> 00:28:20,100
Podemos decidir que é isso.

646
00:28:20,100 --> 00:28:21,970
Temos correspondido cada personagem?

647
00:28:21,970 --> 00:28:22,990
Caso contrário, retornará false.

648
00:28:22,990 --> 00:28:24,770
Se assim for, return true.

649
00:28:24,770 --> 00:28:28,800
E então isso é exatamente o que esta versão
do programa comparar-1.c faz.

650
00:28:28,800 --> 00:28:31,677
Ele é idêntico ao que nós
olhou para segunda-feira, exceto que eu tenho

651
00:28:31,677 --> 00:28:34,760
se livrado da palavra string-- embora
que não tem impact-- funcional tudo

652
00:28:34,760 --> 00:28:37,450
Eu estou fazendo agora está removendo
algumas rodinhas visuais,

653
00:28:37,450 --> 00:28:40,880
mas para ver claramente que
s e t são endereços.

654
00:28:40,880 --> 00:28:43,020
E é isso que a estrela,
o asterisco, representa

655
00:28:43,020 --> 00:28:46,690
é um endereço, também conhecido
tecnicamente mais como um ponteiro.

656
00:28:46,690 --> 00:28:49,880
>> Então, quando eu declarar s em
linha 9 e dizer char * s,

657
00:28:49,880 --> 00:28:52,160
isso não significa dar-me uma corda.

658
00:28:52,160 --> 00:28:56,360
Isso significa dar-me uma variável cujo
propósito na vida é para armazenar um endereço.

659
00:28:56,360 --> 00:29:00,400
Porque eu estou a ponto de colocar o
endereço de uma cadeia para ele.

660
00:29:00,400 --> 00:29:03,500
E, de fato, GetString, para ser
claro, não retorna um string.

661
00:29:03,500 --> 00:29:06,110
Ela não retorna mãe
barra invertida zero, per se.

662
00:29:06,110 --> 00:29:10,005
O que especificamente GetString
e precisamente voltar?

663
00:29:10,005 --> 00:29:10,880
AUDIÊNCIA: [inaudível]

664
00:29:10,880 --> 00:29:14,080
DAVID J. MALAN: um endereço, o
endereço do primeiro caractere

665
00:29:14,080 --> 00:29:16,070
em alguma corda que tenha chegado.

666
00:29:16,070 --> 00:29:19,250
E agora nós estamos vendo
uma palavra-chave especial novamente.

667
00:29:19,250 --> 00:29:20,640
E, eu aludiu a isso mais cedo.

668
00:29:20,640 --> 00:29:23,620
Isso vai ser bom convenção
que vamos ver novamente e novamente agora.

669
00:29:23,620 --> 00:29:27,540
Estou verificando para certificar-se de que
s não é nulo e t não é nulo.

670
00:29:27,540 --> 00:29:30,100
Porque com base na minha realmente
rápida menção anteriormente,

671
00:29:30,100 --> 00:29:35,510
o que pode significar, se não retorna GetString
um endereço, mas de N-L-L-L, que é novo,

672
00:29:35,510 --> 00:29:36,990
algum valor especial?

673
00:29:36,990 --> 00:29:37,890
>> AUDIÊNCIA: Erro.

674
00:29:37,890 --> 00:29:38,600
>> DAVID J. MALAN: É um erro.

675
00:29:38,600 --> 00:29:39,550
Algo deu errado.

676
00:29:39,550 --> 00:29:41,341
E o que tipicamente
pode acontecer, especialmente

677
00:29:41,341 --> 00:29:45,162
com o que pode ser strings--
de comprimento desconhecido em advance--

678
00:29:45,162 --> 00:29:46,870
talvez os computadores dos
sem memória, talvez

679
00:29:46,870 --> 00:29:49,280
você digitou, de tal
longa palavra ou sentença

680
00:29:49,280 --> 00:29:51,880
ou colado um grande ensaio tal
há não apenas a memória suficiente.

681
00:29:51,880 --> 00:29:55,340
E assim GetString não pode retornar
o endereço da coisa toda,

682
00:29:55,340 --> 00:29:56,620
por isso só retorna nada.

683
00:29:56,620 --> 00:30:00,580
E ele diz que um erro aconteceu
retornando o valor especial NULL.

684
00:30:00,580 --> 00:30:02,890
É o endereço zero, por assim dizer.

685
00:30:02,890 --> 00:30:06,157
>> Agora, descobre-C vem com um
função que faz a iteração.

686
00:30:06,157 --> 00:30:09,240
Não temos de implementar isso com
um loop ou um loop while nós mesmos.

687
00:30:09,240 --> 00:30:11,150
Podemos usar uma função,
chamado de forma sucinta,

688
00:30:11,150 --> 00:30:15,400
agitar comp, ou String de comparação, cuja
propósito na vida é fazer exatamente isso.

689
00:30:15,400 --> 00:30:19,990
Você dar-lhe dois ponteiros, dois endereços,
e ele vai para esses endereços

690
00:30:19,990 --> 00:30:23,130
e então comparar carta para
letra por letra para a qualidade,

691
00:30:23,130 --> 00:30:26,610
parando apenas quando o que é verdade?

692
00:30:26,610 --> 00:30:31,540
Quando intuitivamente deve agitar comp
parar a iteração, só para ficar claro?

693
00:30:31,540 --> 00:30:35,400
Quando ela atinge uma barra invertida 0 em qualquer
corda, em que ponto ele pode decidir

694
00:30:35,400 --> 00:30:38,910
tem tudo combinado, ou
houve uma discrepância?

695
00:30:38,910 --> 00:30:42,740
>> Então, se nós funcionamos este agora e tentar
o nosso jogo pouco capitalização,

696
00:30:42,740 --> 00:30:49,260
assim que comparar-1, ./compare-1, e
escreva mãe em minúsculas ambas as vezes.

697
00:30:49,260 --> 00:30:50,560
Agora é a mesma coisa.

698
00:30:50,560 --> 00:30:54,080
E se eu fazê-lo novamente com
minúsculas e então talvez maiúsculas.

699
00:30:54,080 --> 00:30:56,720
Agora é realmente distingue
entre maiúsculas e minúsculas.

700
00:30:56,720 --> 00:31:00,440
Então, não tão difícil ou
mágico, mas ele agora explicar

701
00:31:00,440 --> 00:31:03,140
o que está acontecendo debaixo do capô.

702
00:31:03,140 --> 00:31:07,640
>> Então, o que mais podemos extrair
a partir deste tipo de lição?

703
00:31:07,640 --> 00:31:08,980
Então, vamos dar uma olhada nisso.

704
00:31:08,980 --> 00:31:15,380
Eu estou indo para ir em frente e escrever uma
programa rápido aqui chamado copy-0.

705
00:31:15,380 --> 00:31:21,594
E agora vamos ir em frente e, na verdade,
vamos fazer isto-- com cópia-0,

706
00:31:21,594 --> 00:31:23,010
Dê uma olhada no que eu tenho aqui.

707
00:31:23,010 --> 00:31:24,712
I primeiro informar ao usuário, diga alguma coisa.

708
00:31:24,712 --> 00:31:26,420
Então eu recebo uma string
e eu armazenado em s.

709
00:31:26,420 --> 00:31:29,810
Então eu verificar se s é igual a
é igual a NULL, basta retornar 1.

710
00:31:29,810 --> 00:31:31,590
Portanto, esta é apenas a verificação de erros padrão.

711
00:31:31,590 --> 00:31:33,112
Nada de interessante aconteceu.

712
00:31:33,112 --> 00:31:36,320
E, de fato, se nos livrarmos do erro
a verificação, esta parece ser uma semana de código

713
00:31:36,320 --> 00:31:36,985
no momento.

714
00:31:36,985 --> 00:31:39,110
Mas eu comecei a ficar um
pouco melhor sobre isso.

715
00:31:39,110 --> 00:31:43,340
>> Agora, na linha 16, uma semana atrás, talvez
dia até mesmo um casal ou minutos atrás,

716
00:31:43,340 --> 00:31:46,720
pode-se dizer linha 16 é
a criação de uma variável chamada t

717
00:31:46,720 --> 00:31:48,219
e cópia é para ele.

718
00:31:48,219 --> 00:31:50,010
E isso é um perfeitamente
takeaway razoável.

719
00:31:50,010 --> 00:31:51,560
Mas ser mais preciso agora.

720
00:31:51,560 --> 00:31:54,190
O que está acontecendo na linha 16?

721
00:31:54,190 --> 00:31:56,170
O que está sendo copiado
da direita para a esquerda?

722
00:31:56,170 --> 00:31:56,669
Sim?

723
00:31:56,669 --> 00:31:58,490
AUDIÊNCIA: É t obter um endereço de s?

724
00:31:58,490 --> 00:32:01,220
>> DAVID J. MALAN: Exatamente, t
está recebendo o endereço de s.

725
00:32:01,220 --> 00:32:05,170
Assim, para ser claro agora, se eu for
de volta a esse exemplo anterior

726
00:32:05,170 --> 00:32:08,520
e eu tirar a coisa que eu digitei.

727
00:32:08,520 --> 00:32:11,640
E o que eu digitei
em-- aqui está s, e aqui

728
00:32:11,640 --> 00:32:15,830
é o que eu digitei em algum lugar
memória, mãe e, em seguida, uma barra invertida

729
00:32:15,830 --> 00:32:17,840
0 que é adicionado para mim.

730
00:32:17,840 --> 00:32:23,060
O que eu armazenados aqui, recordo,
este está na posição 1, 2, 3, 4,

731
00:32:23,060 --> 00:32:24,655
isso é o que está atualmente em s.

732
00:32:24,655 --> 00:32:29,220
Portanto, se na linha 16, eu digo me dê
outra variável chamada t e loja

733
00:32:29,220 --> 00:32:33,590
em pelo o valor de s, que
fica armazenado aqui não vai mom

734
00:32:33,590 --> 00:32:35,480
mas sim apenas o número 1.

735
00:32:35,480 --> 00:32:38,520
>> Portanto, se olharmos para o futuro neste programa
agora, o que vai acontecer?

736
00:32:38,520 --> 00:32:40,690
Então, observe que não há
esta função você pode

737
00:32:40,690 --> 00:32:44,410
têm utilizado este um tempo atrás para César,
ou Vigenere, ou talvez não em todos.

738
00:32:44,410 --> 00:32:48,170
Eu reclamo com o meu printf, eu sou
vai capitalizar a cópia t.

739
00:32:48,170 --> 00:32:51,616
Primeiro na linha 19, sanidade rápida
verificação, verificações STRLEN o comprimento de t.

740
00:32:51,616 --> 00:32:53,740
Porque eu não quero
tentar capitalizar algo

741
00:32:53,740 --> 00:32:55,104
se não há nenhuma seqüência de lá.

742
00:32:55,104 --> 00:32:57,520
Se o usuário simplesmente pressionar Enter,
não há nada para capitalizar.

743
00:32:57,520 --> 00:33:01,100
Então eu não quero fazer linha 21.

744
00:33:01,100 --> 00:33:05,758
Então linha 21 está capitalizando
que carta, aparentemente, em t?

745
00:33:05,758 --> 00:33:06,514
>> AUDIÊNCIA: m?

746
00:33:06,514 --> 00:33:08,722
DAVID J. MALAN: Olha
como se fosse copiar qual?

747
00:33:08,722 --> 00:33:09,486
AUDIÊNCIA: m.

748
00:33:09,486 --> 00:33:10,450
DAVID J. MALAN: Uh, m.

749
00:33:10,450 --> 00:33:12,685
OK, então a primeira m,
porque aviso que estou

750
00:33:12,685 --> 00:33:14,935
passando para toupper, que
se você nunca viu é

751
00:33:14,935 --> 00:33:16,980
apenas uma função para
capitalizar como sua entrada.

752
00:33:16,980 --> 00:33:20,240
t significa dar suporte de zero
me o zero de t.

753
00:33:20,240 --> 00:33:22,550
E assim como faz este
mudança de imagem, para ser claro?

754
00:33:22,550 --> 00:33:25,490

755
00:33:25,490 --> 00:33:29,160
O que precisa ser reescrito ou alterado
em relação a s e t e mãe

756
00:33:29,160 --> 00:33:30,097
de zero barra invertida.

757
00:33:30,097 --> 00:33:31,470
>> AUDIÊNCIA: [inaudível]

758
00:33:31,470 --> 00:33:34,030
>> DAVID J. MALAN: Sim,
por isso este um aqui simplesmente

759
00:33:34,030 --> 00:33:40,860
precisa de ter mudado a-- corrigir isto--
precisa ser alterado para um capital m.

760
00:33:40,860 --> 00:33:44,330
Mas agora, olhe no final do
programa, se eu imprimir

761
00:33:44,330 --> 00:33:49,800
s e t como eu limpar aqui, ver o que é
vai acontecer imprimir e s t.

762
00:33:49,800 --> 00:33:54,310
Então, faça copy-0, ./copy-0.

763
00:33:54,310 --> 00:33:57,140
Deixe-me ir em frente e digite
na mãe em todas as minúsculas.

764
00:33:57,140 --> 00:34:00,140
Observe o original e
a cópia ter sido capitalizados.

765
00:34:00,140 --> 00:34:00,850
Por quê?

766
00:34:00,850 --> 00:34:04,431
Bem, s e t são ambos apontando para,
se você, o mesmo pedaço de memória.

767
00:34:04,431 --> 00:34:06,930
E, francamente, isso está ficando
uninteresting-- realmente o facto

768
00:34:06,930 --> 00:34:09,150
que estamos usando o endereço de zero aqui.

769
00:34:09,150 --> 00:34:11,719
Quer dizer, eu realmente não me importo
onde o material está na memória.

770
00:34:11,719 --> 00:34:13,550
Desculpe eu estou apagando um pouco demais.

771
00:34:13,550 --> 00:34:15,674
Mas eu realmente não me importo
onde as coisas estão na memória.

772
00:34:15,674 --> 00:34:18,510
E assim, de fato o que
programadores tendem a pensar sobre

773
00:34:18,510 --> 00:34:21,080
é que quando você fala sobre
um endereço ou um ponteiro,

774
00:34:21,080 --> 00:34:22,679
quem se importa onde ele está na memória.

775
00:34:22,679 --> 00:34:24,989
Eu não me importo se é em
byte um ou um bilhão.

776
00:34:24,989 --> 00:34:27,920
Eu só me importo que esta
variável é eficazmente

777
00:34:27,920 --> 00:34:29,620
apontando para que pedaço de memória.

778
00:34:29,620 --> 00:34:33,350
E assim, a partir de agora, ao invés de tergiversar
sobre endereços de memória arbitrárias, vamos

779
00:34:33,350 --> 00:34:36,710
basta começar a desenhar ponteiros
como ponteiros, como flechas.

780
00:34:36,710 --> 00:34:39,340
Então, o que s e t realmente são,
de acordo com este programa,

781
00:34:39,340 --> 00:34:42,130
por causa de como eu criei t,
é apenas duas variáveis ​​separadas

782
00:34:42,130 --> 00:34:43,840
apontando para o mesmo pedaço de memória.

783
00:34:43,840 --> 00:34:45,215
E nós não nos importamos onde eles estão.

784
00:34:45,215 --> 00:34:47,130
Assim, podemos abstrair esse detalhe.

785
00:34:47,130 --> 00:34:48,780
>> Então, como faço para corrigir isso?

786
00:34:48,780 --> 00:34:54,120
Se eu quiser escrever uma versão da cópia
programa que realmente copia a seqüência de caracteres

787
00:34:54,120 --> 00:34:56,840
e capitaliza apenas o
cópia, apenas de forma intuitiva,

788
00:34:56,840 --> 00:34:59,766
o que tem que ser um
Ingrediente para a nossa solução?

789
00:34:59,766 --> 00:35:00,640
AUDIÊNCIA: [inaudível]

790
00:35:00,640 --> 00:35:01,420
DAVID J. MALAN: Precisamos de uma coisa?

791
00:35:01,420 --> 00:35:01,820
AUDIÊNCIA: Pedaço de memória.

792
00:35:01,820 --> 00:35:03,280
DAVID J. MALAN: Precisamos
outro pedaço de memória, certo?

793
00:35:03,280 --> 00:35:05,360
Nós não sabemos como
fazê-lo ainda, necessariamente.

794
00:35:05,360 --> 00:35:11,330
Mas eu meio que precisa que isso aconteça de modo
que a mãe original no caso de menor

795
00:35:11,330 --> 00:35:14,170
acaba nesse pedaço extra de memória.

796
00:35:14,170 --> 00:35:19,770
E então quando eu alterar a cópia, eu
Não quero mudar essa cópia aqui.

797
00:35:19,770 --> 00:35:26,020
I em vez quiser alterar apenas este
cópia do original, de modo que permanece inalterada.

798
00:35:26,020 --> 00:35:27,980
>> Então, vamos ver como podemos fazer isso.

799
00:35:27,980 --> 00:35:31,800
Em copy-1, que já tem
sido despojado de comentário,

800
00:35:31,800 --> 00:35:33,250
mas é comentado online.

801
00:35:33,250 --> 00:35:36,710
Nós em vez fazer a estes following--
linhas são idênticos, me uma corda

802
00:35:36,710 --> 00:35:38,340
e chamá-lo s.

803
00:35:38,340 --> 00:35:43,500
Mas agora vamos olhar para um dos nossos mais
complexo mas o último de complexidade

804
00:35:43,500 --> 00:35:47,340
por algum tempo, linha 16 faz exatamente isso.

805
00:35:47,340 --> 00:35:49,400
Portanto, se seu confortável com o
imagem que apenas drew--

806
00:35:49,400 --> 00:35:51,790
dê-me um novo pedaço de memória,
copiar tudo para ele,

807
00:35:51,790 --> 00:35:53,730
vamos ver como podemos traduzir isso para código.

808
00:35:53,730 --> 00:35:59,400
>> Assim a linha 16, no lado esquerdo,
char * t dá-me essa caixa por aqui.

809
00:35:59,400 --> 00:36:00,230
Isso é tudo que ele faz.

810
00:36:00,230 --> 00:36:03,240
No lado direito,
m alloc, ou malloc,

811
00:36:03,240 --> 00:36:06,480
é a alocação de memória, super extravagante,
uma maneira enigmática de apenas dizer

812
00:36:06,480 --> 00:36:07,640
dê-me um pedaço de memória.

813
00:36:07,640 --> 00:36:09,290
Quanta memória precisamos?

814
00:36:09,290 --> 00:36:10,910
Bem, é uma espécie de grande expressão.

815
00:36:10,910 --> 00:36:12,570
Mas vamos ver o que diz aqui.

816
00:36:12,570 --> 00:36:15,940
Então, isso, é claro, é dar-
me o comprimento da corda de s.

817
00:36:15,940 --> 00:36:19,094
Então, a mãe deve ser o que?

818
00:36:19,094 --> 00:36:21,010
Então, só três, certo?
mãe é de três caracteres.

819
00:36:21,010 --> 00:36:22,830
Você não contar com o
barra invertida zero quando você

820
00:36:22,830 --> 00:36:25,960
falar sobre o comprimento de uma string é
na verdade, as letras visíveis humanos.

821
00:36:25,960 --> 00:36:28,020
Então mãe, então isso me dá 3.

822
00:36:28,020 --> 00:36:31,170
Mas espere um minuto, eu agora estou adicionando 1.

823
00:36:31,170 --> 00:36:34,861
Por que eu realmente quero
alocar 4 bytes e não apenas 3?

824
00:36:34,861 --> 00:36:35,360
Sim?

825
00:36:35,360 --> 00:36:36,910
>> AUDIÊNCIA: Para o valor de sentinela?

826
00:36:36,910 --> 00:36:38,951
>> DAVID J. MALAN: Exatamente,
para esse valor de sentinela.

827
00:36:38,951 --> 00:36:40,840
Para a barra invertida zero,
Preciso total de 4 bytes.

828
00:36:40,840 --> 00:36:42,870
Então, eu preciso do comprimento
da corda mais uma.

829
00:36:42,870 --> 00:36:45,400
E, em seguida, apenas para uma boa measure--
apesar de neste sistema,

830
00:36:45,400 --> 00:36:49,390
ele está sempre vai ser 1-- estou dizendo
multiplicar este por o tamanho de um carvão animal.

831
00:36:49,390 --> 00:36:51,552
Acontece que é sizeof
um operador em C que

832
00:36:51,552 --> 00:36:53,260
apenas diz-lhe o
número de bytes que é

833
00:36:53,260 --> 00:36:54,700
requerido para um determinado tipo de dados.

834
00:36:54,700 --> 00:36:57,740
Ele não funciona para matrizes,
normalmente, às vezes ele faz.

835
00:36:57,740 --> 00:36:59,210
Mas, no caso geral, sem.

836
00:36:59,210 --> 00:37:02,330
Mas ele vai me dizer quantos bytes um
char é, o que acaba é sempre 1.

837
00:37:02,330 --> 00:37:04,080
Então, isso é como multiplicar por 1.

838
00:37:04,080 --> 00:37:05,900
>> Linha de olhar tão super enigmático de código.

839
00:37:05,900 --> 00:37:09,320
Mas tudo o que ele faz é dá
me um pedaço de memória.

840
00:37:09,320 --> 00:37:13,590
Mas isso parece estar copiando
qualquer coisa em que a memória?

841
00:37:13,590 --> 00:37:14,560
Ainda não.

842
00:37:14,560 --> 00:37:22,040
E então o que faço na linha 22, e
23, 24, 25, bem, eu simplesmente fazer isso.

843
00:37:22,040 --> 00:37:23,760
E este é o tipo de
material escolar velho agora.

844
00:37:23,760 --> 00:37:26,010
Isto é como PSet 2, onde
você está apenas movendo as coisas

845
00:37:26,010 --> 00:37:28,620
em torno da memória, ou melhor, em strings.

846
00:37:28,620 --> 00:37:31,920
>> Então, eu estou repetindo de 0 a
o comprimento da cadeia s.

847
00:37:31,920 --> 00:37:37,820
E eu estou copiando o personagem i-th
no s para o personagem i-th em t.

848
00:37:37,820 --> 00:37:41,820
E porque eu, o programador, feita
Certifique-se de alocar exatamente como muitos bytes

849
00:37:41,820 --> 00:37:44,600
como eu preciso, é perfeito
um-para-um.

850
00:37:44,600 --> 00:37:47,060
E eu copiar mãe em
minúsculas para o novo.

851
00:37:47,060 --> 00:37:50,170
E então, finalmente, eu faço essa linha.

852
00:37:50,170 --> 00:37:54,637
E assim o efeito só é
para capitalizar esta t aqui.

853
00:37:54,637 --> 00:37:56,470
Então, um monte de absorver, mas
se você considerar apenas

854
00:37:56,470 --> 00:37:58,220
o que realmente está acontecendo
por baixo do capuz

855
00:37:58,220 --> 00:38:00,880
é apenas movendo estes
bytes em volta, tudo o que

856
00:38:00,880 --> 00:38:06,617
é necessária para resolver este problema é
apenas para nos dar este pedaço de memória.

857
00:38:06,617 --> 00:38:08,450
Agora, com o risco de
esmagadora, deixe-me mostrar

858
00:38:08,450 --> 00:38:13,200
um outro exemplo que é quase
idênticas, exceto para esta

859
00:38:13,200 --> 00:38:14,350
linha de código.

860
00:38:14,350 --> 00:38:18,870
Portanto, esta é a versão de hackers
deste programa, se você quiser.

861
00:38:18,870 --> 00:38:21,050
Mas vamos apenas destilar
-lo em o que está acontecendo.

862
00:38:21,050 --> 00:38:28,920
A linha 24 é utilizado para ser este t
suporte de i recebe suporte s i.

863
00:38:28,920 --> 00:38:33,370
Agora, eu estou mudando isso para
a estrela muito mais enigmática t

864
00:38:33,370 --> 00:38:36,280
mais 1 é igual a estrela mais 1 s.

865
00:38:36,280 --> 00:38:38,702
>> Então o que está acontecendo e por quê
temos um personagem estrela?

866
00:38:38,702 --> 00:38:41,410
Nós vimos a estrela antes, e
ele está sendo usado de forma diferente aqui.

867
00:38:41,410 --> 00:38:45,490
Nós já vimos char *, agora eu estou vendo
Uma estrela no início, e isso é OK.

868
00:38:45,490 --> 00:38:48,190
Pois verifica-se que
pode tipo de inferir apenas

869
00:38:48,190 --> 00:38:50,280
daqueles primeiro
princípios que está acontecendo.

870
00:38:50,280 --> 00:38:53,860
Então, só para ficar claro, o que é s?

871
00:38:53,860 --> 00:38:55,052
Na semana passada, foi uma string.

872
00:38:55,052 --> 00:38:56,260
Isso não é suficiente anymore.

873
00:38:56,260 --> 00:38:57,690
O que é s, especificamente?

874
00:38:57,690 --> 00:38:58,590
>> AUDIÊNCIA: [inaudível]

875
00:38:58,590 --> 00:38:59,881
>> DAVID J. MALAN: É um ponteiro.

876
00:38:59,881 --> 00:39:02,610
É o endereço do
primeiro caractere digitado em nós.

877
00:39:02,610 --> 00:39:04,780
OK, o que é t?

878
00:39:04,780 --> 00:39:05,660
>> AUDIÊNCIA: [inaudível]

879
00:39:05,660 --> 00:39:07,950
>> David J. MALAN: A
endereço do primeiro byte

880
00:39:07,950 --> 00:39:10,490
em t, que pedaço de memória realocada.

881
00:39:10,490 --> 00:39:14,720
Assim, verifica-se que, quando
iteração de 0 diante até a string

882
00:39:14,720 --> 00:39:17,424
length-- antes de tudo, i
Começa a 0, porque

883
00:39:17,424 --> 00:39:18,840
desta antiga escola para coisa loop.

884
00:39:18,840 --> 00:39:22,400
Então, só para simplificar, vamos
supor que a primeira linha de código

885
00:39:22,400 --> 00:39:23,760
é realmente apenas isso, certo.

886
00:39:23,760 --> 00:39:26,080
Se I é zero, zero, adicionando
a algo presumivelmente

887
00:39:26,080 --> 00:39:27,540
não vai ter um efeito.

888
00:39:27,540 --> 00:39:28,560
>> Então, qual é essa palavra?

889
00:39:28,560 --> 00:39:31,600
Acontece que a estrela
operador neste contexto

890
00:39:31,600 --> 00:39:33,700
é o dereference
operador, que é apenas

891
00:39:33,700 --> 00:39:37,530
uma maneira elegante de dizer ir
para o seguinte endereço.

892
00:39:37,530 --> 00:39:42,080
Portanto, se s é o endereço do primeiro
personagem neste pedaço de memória,

893
00:39:42,080 --> 00:39:43,630
* s meios ir para lá.

894
00:39:43,630 --> 00:39:45,630
E porque temos desenhada
a imagem desta forma,

895
00:39:45,630 --> 00:39:47,430
você pode adotar o
seguindo o modelo mental.

896
00:39:47,430 --> 00:39:51,030
Se esta é s, e você diz * s * s,
tipo de como rampas e escadas,

897
00:39:51,030 --> 00:39:54,540
se você se lembra do jogo desde a infância,
é como seguir esse seta e vá

898
00:39:54,540 --> 00:39:55,570
para o endereço.

899
00:39:55,570 --> 00:39:57,080
>> * t é a mesma coisa.

900
00:39:57,080 --> 00:39:59,855
Então comece aqui, vá para o seu pedaço.

901
00:39:59,855 --> 00:40:03,350
Eu não posso simplesmente desenhar sobre
Nesta tela dessa forma.

902
00:40:03,350 --> 00:40:05,560
* t significa que ir aqui.

903
00:40:05,560 --> 00:40:08,830
E, em seguida, o loop for é apenas
dizendo mover esse personagem aqui,

904
00:40:08,830 --> 00:40:11,330
mover esse personagem aqui,
mover esse personagem aqui.

905
00:40:11,330 --> 00:40:12,890
Mas como posso fazer isso incrementação?

906
00:40:12,890 --> 00:40:15,430
Eu preciso desfazer o que eu acabei de excluir.

907
00:40:15,430 --> 00:40:18,140
Isto é o que geralmente é chamado
aritmética de ponteiro, que

908
00:40:18,140 --> 00:40:20,040
significa matemática com endereços.

909
00:40:20,040 --> 00:40:22,460
>> Se, neste loop for,
Eu continuo incremento i,

910
00:40:22,460 --> 00:40:26,880
e s é um endereço de e t é um
endereço, se eu simplesmente continuar adicionando 1,

911
00:40:26,880 --> 00:40:31,406
isso significa apenas seguir em frente,
e para a frente, e para a frente na memória.

912
00:40:31,406 --> 00:40:34,030
É como Oxford Street, o
rua que o edifício está no CS.

913
00:40:34,030 --> 00:40:36,490
Os edifícios do CS é de 33 Oxford Street.

914
00:40:36,490 --> 00:40:39,870
Então, se você fosse fazer 33
Oxford Street mais 1,

915
00:40:39,870 --> 00:40:42,870
que o leva até 34 Oxford
Street, em seguida, 35 Oxford Street,

916
00:40:42,870 --> 00:40:46,380
em seguida, 36 Oxford Street, quaisquer que
prédios realmente são - se existirem.

917
00:40:46,380 --> 00:40:50,540
E assim, isso é tudo que estamos fazendo
aqui com a aritmética de ponteiro.

918
00:40:50,540 --> 00:40:53,820
>> Portanto, é uma maneira super arcano
de nos expressar.

919
00:40:53,820 --> 00:40:56,160
Mas tudo o que está acontecendo
debaixo da capa

920
00:40:56,160 --> 00:40:59,330
está apenas seguindo esses endereços,
como seguir um mapa, se quiserem,

921
00:40:59,330 --> 00:41:02,692
ou na sequência de flechas como
temos desenhado na tela.

922
00:41:02,692 --> 00:41:04,910
OK, um monte de digerir.

923
00:41:04,910 --> 00:41:10,410
Qualquer pergunta sobre a sintaxe, conceitos,
ponteiros, malloc, ou semelhantes.

924
00:41:10,410 --> 00:41:11,480
Sim, aqui em primeiro lugar.

925
00:41:11,480 --> 00:41:13,755
>> AUDIÊNCIA: Então onde isso
diz * t é igual a toupper * t,

926
00:41:13,755 --> 00:41:15,575
é que vai capitalizar
todas as letras ou apenas--

927
00:41:15,575 --> 00:41:17,283
>> DAVID J. MALAN: Ah,
pergunta muito boa.

928
00:41:17,283 --> 00:41:19,805
Então nessa linha aqui, 31,
é que isto vai capitalizar

929
00:41:19,805 --> 00:41:21,430
a primeira letra ou de todas as cartas.

930
00:41:21,430 --> 00:41:23,460
Então, vamos responder a isso, indo
de volta aos primeiros princípios.

931
00:41:23,460 --> 00:41:26,168
E primeiros princípios aqui eu quero dizer
basta ir para as definições básicas

932
00:41:26,168 --> 00:41:27,000
do que está envolvido.

933
00:41:27,000 --> 00:41:29,770
Então toupper é uma função
que capitaliza um char.

934
00:41:29,770 --> 00:41:30,530
Isso é tudo.

935
00:41:30,530 --> 00:41:36,740
* t significa ir para o first--
ir para o endereço em t.

936
00:41:36,740 --> 00:41:40,350
Assim, na foto, se este é o pedaço
de memória que alocados com malloc,

937
00:41:40,350 --> 00:41:43,310
e este é t, * t significa ir aqui.

938
00:41:43,310 --> 00:41:46,710
>> Enquanto isso, você está passando
esse valor, minúsculas m

939
00:41:46,710 --> 00:41:50,040
para toupper, você está recebendo de volta
M maiúsculo, onde você colocá-lo?

940
00:41:50,040 --> 00:41:52,410
Você está colocando-o no mesmo local.

941
00:41:52,410 --> 00:41:55,540
E assim por que a lógica daqueles
definições básicas é só

942
00:41:55,540 --> 00:41:58,792
capitalizando a primeira letra
a menos que você interagir com i ou um

943
00:41:58,792 --> 00:42:02,000
loop ou um loop while, ele não vai
para fazer algo mais do que você perguntar isso.

944
00:42:02,000 --> 00:42:02,583
Boa pergunta.

945
00:42:02,583 --> 00:42:03,237
Sim?

946
00:42:03,237 --> 00:42:05,369
>> AUDIÊNCIA: Por que você use o
dereference método, em vez de

947
00:42:05,369 --> 00:42:05,979
matriz?

948
00:42:05,979 --> 00:42:07,395
>> DAVID J. MALAN: Ah, boa pergunta.

949
00:42:07,395 --> 00:42:10,672
Por que você usaria o dereference
método, em vez do método de array?

950
00:42:10,672 --> 00:42:12,130
Nenhuma razão em particular, para ser honesto.

951
00:42:12,130 --> 00:42:15,290
E, de fato, para este
tipo de exemplo, direito,

952
00:42:15,290 --> 00:42:17,556
Estou apenas discutindo tornando o
programa mais complicado,

953
00:42:17,556 --> 00:42:19,680
Mais olhos estão vidrados,
as pessoas a visitar a

954
00:42:19,680 --> 00:42:22,830
porque este parece super arcano, mas
mesmo que ele está fazendo a mesma coisa.

955
00:42:22,830 --> 00:42:26,695
E assim, francamente, esta é uma
solução desnecessariamente complexo visualmente

956
00:42:26,695 --> 00:42:27,320
para o problema.

957
00:42:27,320 --> 00:42:29,580
>> É ainda bom design,
cinco de cinco para o projeto,

958
00:42:29,580 --> 00:42:33,140
se é na faixa
notação ou a notação de ponteiro.

959
00:42:33,140 --> 00:42:36,299
Mas-- especialmente quando chegarmos
mais tarde no curso em PSet 5

960
00:42:36,299 --> 00:42:39,340
quando implementamos esse dicionário que
Eu mencionei um par de vezes--

961
00:42:39,340 --> 00:42:42,300
vamos realmente se preocupam com o
endereços de memória de baixo nível

962
00:42:42,300 --> 00:42:44,140
que nós realmente entendemos
o que está acontecendo.

963
00:42:44,140 --> 00:42:48,300
>> Mas, por agora, verifica-se que este
linha de código colchetes aqui quadrados

964
00:42:48,300 --> 00:42:49,900
não existem realmente.

965
00:42:49,900 --> 00:42:52,230
Eles são o que é chamado
açúcar sintático, que

966
00:42:52,230 --> 00:42:58,390
é apenas uma maneira estranhamente legal de dizer a
compilador converte colchetes ser

967
00:42:58,390 --> 00:43:00,420
que a expressão matemática.

968
00:43:00,420 --> 00:43:02,660
Portanto, é uma convenção humana
para ser capaz de escrever apenas

969
00:43:02,660 --> 00:43:04,220
estes suportes muito fácil de usar.

970
00:43:04,220 --> 00:43:06,850
Mas o que o compilador, clang,
está realmente fazendo qualquer momento

971
00:43:06,850 --> 00:43:10,970
você escreve o que está em destaque na linha
24, debaixo da capa é realmente

972
00:43:10,970 --> 00:43:12,330
convertê-lo a este.

973
00:43:12,330 --> 00:43:16,200
É apenas mais prazeroso como um ser humano
a ler e escrever código como linha 24.

974
00:43:16,200 --> 00:43:18,530
Mas, eventualmente, aqueles
rodinhas também vêm off

975
00:43:18,530 --> 00:43:21,780
quando o próprio conforto fica mais forte.

976
00:43:21,780 --> 00:43:27,240
>> Tudo bem, então recordar, em seguida, que este
Era o tipo de maior problema

977
00:43:27,240 --> 00:43:27,807
Deparamo-nos.

978
00:43:27,807 --> 00:43:30,640
E é isso que desencadeou todo este
conversa maldita sobre ponteiros,

979
00:43:30,640 --> 00:43:32,340
e endereços, e copiando coisas.

980
00:43:32,340 --> 00:43:35,410
Foi porque nós tropeçou
este problema estúpido, estúpido, pelo qual

981
00:43:35,410 --> 00:43:38,830
Eu implementei logically-- com Lauren
aqui na demo eo suco de laranja

982
00:43:38,830 --> 00:43:43,770
no milk-- um perfeitamente
algorithmically função correta

983
00:43:43,770 --> 00:43:47,010
para trocar duas variáveis ​​'
valores, mas a maldita coisa

984
00:43:47,010 --> 00:43:50,550
não têm qualquer persistente, ou
permanente, efeito sobre o meu código.

985
00:43:50,550 --> 00:43:51,820
>> E por que isso?

986
00:43:51,820 --> 00:43:54,650
Em poucas palavras, por que é isso
implementação de troca

987
00:43:54,650 --> 00:43:58,740
logicamente correta, mas não tem impacto
sobre as variáveis ​​que são passados ​​para ele,

988
00:43:58,740 --> 00:44:01,119
como x e y para o principal?

989
00:44:01,119 --> 00:44:02,410
Qual era a essência da questão?

990
00:44:02,410 --> 00:44:02,909
Sim?

991
00:44:02,909 --> 00:44:05,532
AUDIÊNCIA: Porque variável feito
cópias da variável no passe

992
00:44:05,532 --> 00:44:06,240
através da função.

993
00:44:06,240 --> 00:44:09,060
>> DAVID J. MALAN: Exatamente, quando você passa
variáveis ​​em uma função, ou argumentos

994
00:44:09,060 --> 00:44:11,030
em uma função, elas são
passou por cópia, que

995
00:44:11,030 --> 00:44:14,770
significa que você começa um idêntico à procura
padrão de bits para ambos os X e Y,

996
00:44:14,770 --> 00:44:15,955
chamado aqui a e b.

997
00:44:15,955 --> 00:44:18,080
E você pode fazer qualquer coisa
você quer com essas cópias,

998
00:44:18,080 --> 00:44:20,657
mas eles vão ter nenhum
efeito sobre a função de chamada.

999
00:44:20,657 --> 00:44:22,990
E, de fato, que nós extraímos
imagem na tela, lembre-

1000
00:44:22,990 --> 00:44:25,520
última vez, em que se
realmente pensar sobre o que é

1001
00:44:25,520 --> 00:44:28,570
acontecendo debaixo do hood-- se
esta é a memória do seu computador,

1002
00:44:28,570 --> 00:44:31,650
e aqui é o pedaço de
memória que está sendo usada para o principal,

1003
00:44:31,650 --> 00:44:34,020
este é o pedaço de
memória que está sendo utilizada para swap,

1004
00:44:34,020 --> 00:44:37,090
e assim mesmo se principal tem
duas variáveis, X e Y,

1005
00:44:37,090 --> 00:44:41,840
de swap pode ter idêntica à procura
valores, ambos os quais são 1 e 2,

1006
00:44:41,840 --> 00:44:44,520
mas eles são completamente
diferentes pedaços de memória.

1007
00:44:44,520 --> 00:44:46,130
>> Então, precisamos de uma solução para isso.

1008
00:44:46,130 --> 00:44:51,580
E, francamente, parece que temos agora
tem uma solução para este problema, certo.

1009
00:44:51,580 --> 00:44:55,760
Se agora temos a capacidade de
manipular as coisas por meio de endereços

1010
00:44:55,760 --> 00:44:59,310
e, uma espécie de rampas e escadas
estilo, siga estas setas

1011
00:44:59,310 --> 00:45:02,820
e ir a qualquer lugar que queremos
na memória, não poderíamos nós

1012
00:45:02,820 --> 00:45:06,220
resolver este problema
passando de principal de trocar

1013
00:45:06,220 --> 00:45:09,650
não os valores que queremos
swap, mas apenas de forma intuitiva

1014
00:45:09,650 --> 00:45:11,630
o que poderíamos passar para trocar em vez disso?

1015
00:45:11,630 --> 00:45:12,620
>> [Interpondo VOZES]

1016
00:45:12,620 --> 00:45:15,244
>> DAVID J. MALAN: Por que nós não apenas
passá-lo os endereços, certo?

1017
00:45:15,244 --> 00:45:17,470
Por que não vamos dar uma troca
mapa do tesouro, se quiserem,

1018
00:45:17,470 --> 00:45:20,950
que leva-o para o
reais valores x e y.

1019
00:45:20,950 --> 00:45:24,340
Vamos swap, realmente mudar
esses bits originais, em vez de

1020
00:45:24,340 --> 00:45:26,797
só de passagem cópias dos bits.

1021
00:45:26,797 --> 00:45:29,130
E assim, de fato, que é o que é
vai ser a solução.

1022
00:45:29,130 --> 00:45:31,899
Esta versão é aqui
claramente ruim e falho.

1023
00:45:31,899 --> 00:45:35,190
E agora, à primeira vista, ele só olha
como nós adicionamos um monte de estrelas aleatoriamente

1024
00:45:35,190 --> 00:45:37,106
e cruzou os dedos
que iria compilar.

1025
00:45:37,106 --> 00:45:38,460
Mas, seria agora compilar.

1026
00:45:38,460 --> 00:45:40,090
>> Mas vamos ver o que significam estas coisas.

1027
00:45:40,090 --> 00:45:43,990
E, infelizmente, os autores de
C poderia ter escolhido outro símbolo

1028
00:45:43,990 --> 00:45:46,380
para fazer deste um pouco
mais clara, mas o operador estrela

1029
00:45:46,380 --> 00:45:48,610
tem um significado diferente em
dois contextos diferentes.

1030
00:45:48,610 --> 00:45:50,890
E temos visto tanto,
mas vamos distinguir.

1031
00:45:50,890 --> 00:45:55,310
>> Assim, no topo lá,
quando eu mudei a e b

1032
00:45:55,310 --> 00:46:00,470
de ser int de na ruim
versão para int estrelas, a e b,

1033
00:46:00,470 --> 00:46:01,740
Anteriormente, foram inteiros.

1034
00:46:01,740 --> 00:46:05,752
O que são a e b agora em
o bom, versão verde?

1035
00:46:05,752 --> 00:46:06,900
Eles são endereços.

1036
00:46:06,900 --> 00:46:09,610
Endereços de que, para ser claro?

1037
00:46:09,610 --> 00:46:10,770
Endereços de inteiros.

1038
00:46:10,770 --> 00:46:12,520
Assim, o fato de que eu sou
dizendo meios int estrela

1039
00:46:12,520 --> 00:46:15,440
este é o endereço de
um inteiro, especificamente.

1040
00:46:15,440 --> 00:46:19,120
>> Então agora notar nas linhas de código,
outra coisa também mudou.

1041
00:46:19,120 --> 00:46:22,770
tmp permanece o mesmo, porque
é apenas o número inteiro temporária,

1042
00:46:22,770 --> 00:46:24,110
nenhuma mágica memória lá.

1043
00:46:24,110 --> 00:46:26,370
Mas uma empresa precisa de uma estrela.

1044
00:46:26,370 --> 00:46:28,560
E, de fato, todos os
outra menção de a e b,

1045
00:46:28,560 --> 00:46:31,780
perceber que tudo o que é
mudar de vermelho para verde

1046
00:46:31,780 --> 00:46:34,209
é que eu estou prefixing
as variáveis ​​com estrelas.

1047
00:46:34,209 --> 00:46:35,750
Porque eu não quero copiar a e b.

1048
00:46:35,750 --> 00:46:40,350
Porque se eu apenas copiar a e b e swap
a e b, o que eu realmente trocar?

1049
00:46:40,350 --> 00:46:43,760
Apenas endereços, eu quero trocar
o que está em esses endereços.

1050
00:46:43,760 --> 00:46:44,860
Eu quero ir lá.

1051
00:46:44,860 --> 00:46:48,000
E assim o operador estrela
dentro da minha função,

1052
00:46:48,000 --> 00:46:51,700
não dentro da lista de parâmetros,
significa que você ir para esses endereços

1053
00:46:51,700 --> 00:46:54,490
e realmente mudar esses valores.

1054
00:46:54,490 --> 00:46:56,500
>> Então, o que faz a imagem
agora olhar como em seu lugar.

1055
00:46:56,500 --> 00:47:03,250
Bem, se em vez disso eu estou passando
por A e B não 1 e 2--

1056
00:47:03,250 --> 00:47:05,790
Na verdade, eu preciso adicionar
uma outra definição aqui.

1057
00:47:05,790 --> 00:47:09,030
Então suponho que este pedaço
de memória está na posição 10.

1058
00:47:09,030 --> 00:47:12,960
>> Esta é a localização 11, mas este
é um pouco de uma simplificação,

1059
00:47:12,960 --> 00:47:18,900
Agora tenho duas escolhas eu passar x
e y ou eu passar seus endereços?

1060
00:47:18,900 --> 00:47:22,500
Se eu passar seus endereços
como este, eu apenas

1061
00:47:22,500 --> 00:47:25,390
Agora precisamos implementar
de troca por o código verde

1062
00:47:25,390 --> 00:47:29,080
de modo que, quando se vê um e quando
b vê, não apenas copiar a e b

1063
00:47:29,080 --> 00:47:30,540
e mover o leite e suco de laranja.

1064
00:47:30,540 --> 00:47:32,664
O suco de laranja e leite
metáfora agora quebra,

1065
00:47:32,664 --> 00:47:35,060
porque esses são copos
de mapas de líquido e não.

1066
00:47:35,060 --> 00:47:37,750
Nós em vez precisa ir
para tratar 10 e nós

1067
00:47:37,750 --> 00:47:42,420
precisa ir para lidar com 11, e
em seguida, executar essa lógica troca.

1068
00:47:42,420 --> 00:47:45,580
>> Assim, a lógica é a mesma, mas
precisamos de uma maneira ligeiramente diferente

1069
00:47:45,580 --> 00:47:47,160
de aceder a essas variáveis.

1070
00:47:47,160 --> 00:47:52,400
E assim, no final, o que o
programa tem que olhar como é isso.

1071
00:47:52,400 --> 00:47:56,610
Em swap.c literalmente copiados
e colado a versão verde.

1072
00:47:56,610 --> 00:47:58,450
Mas eu preciso fazer uma mudança.

1073
00:47:58,450 --> 00:48:00,180
Não é suficiente apenas para mudar swap.

1074
00:48:00,180 --> 00:48:03,830
Que outra linha de código
eu preciso mudar?

1075
00:48:03,830 --> 00:48:04,330
Sim?

1076
00:48:04,330 --> 00:48:05,770
>> AUDIÊNCIA: Onde leva os argumentos.

1077
00:48:05,770 --> 00:48:07,603
>> DAVID J. MALAN: Onde
que leva seu argumento.

1078
00:48:07,603 --> 00:48:09,985
Então, se eu rolar até a Main, I
não pode simplesmente passar em x e y,

1079
00:48:09,985 --> 00:48:12,820
e, eu prometo, o último
pedaço de nova sintaxe hoje.

1080
00:48:12,820 --> 00:48:17,200
Eu preciso passar em não xe
y, mas o endereço de X e Y.

1081
00:48:17,200 --> 00:48:20,400
E ao que parece, o símbolo
que os autores do C escolheu

1082
00:48:20,400 --> 00:48:23,860
é se você usar um e comercial aqui, não para
ser confundido com o bit a bit e comercial,

1083
00:48:23,860 --> 00:48:27,130
se você usar um e comercial
aqui e um e comercial aqui,

1084
00:48:27,130 --> 00:48:29,570
esta figura para fora para você,
qual é o endereço de x,

1085
00:48:29,570 --> 00:48:31,740
talvez é 10, qual é o
endereço de y, talvez seja

1086
00:48:31,740 --> 00:48:35,400
11, e passa aqueles em vez disso.

1087
00:48:35,400 --> 00:48:37,210
>> Assim, uma grande quantidade de absorver toda de uma vez.

1088
00:48:37,210 --> 00:48:40,190
Mas vamos ver agora rapidamente em
nossas restantes quatro minutos

1089
00:48:40,190 --> 00:48:42,150
onde as coisas podem dar errado.

1090
00:48:42,150 --> 00:48:45,120
E como um aparte, na verdade,
Eu tomei esta imagem,

1091
00:48:45,120 --> 00:48:46,920
TF tomei esta imagem de um ou dois anos atrás.

1092
00:48:46,920 --> 00:48:49,190
Então este é o canto de trás
de Eliot Refeitório.

1093
00:48:49,190 --> 00:48:52,310
Os ponteiros são talvez o mais difícil
tópico que nós cobrimos em CS50.

1094
00:48:52,310 --> 00:48:54,810
Então, se você se preocupa o tipo
de inclinação é como talvez seja

1095
00:48:54,810 --> 00:48:56,770
mais de um stick de hóquei
assim, perceber

1096
00:48:56,770 --> 00:49:00,160
nós estamos nos aproximando de um pico em
termos de complexidade conceitual.

1097
00:49:00,160 --> 00:49:02,300
>> E eu trago este
foto, porque eu juro

1098
00:49:02,300 --> 00:49:05,920
a deus, no outono de 1996, quando eu assumi
CS50 com meu companheiro de ensino,

1099
00:49:05,920 --> 00:49:09,620
Nishat Mehta, ele me sentou-se na
canto do Eliot D. Hall durante o almoço,

1100
00:49:09,620 --> 00:49:12,330
ou jantar, ou algo para tentar
para me ajudar a entender ponteiros.

1101
00:49:12,330 --> 00:49:16,520
E este é o lugar onde eu estava semanas após
que foi introduzida em palestra quando

1102
00:49:16,520 --> 00:49:18,170
Eu finalmente entendi ponteiros.

1103
00:49:18,170 --> 00:49:20,590
E eu estou esperançoso de que esta
vai clicar muito mais cedo para você.

1104
00:49:20,590 --> 00:49:23,540
Mas perceber isso absolutamente entre
os temas mais sofisticados

1105
00:49:23,540 --> 00:49:24,420
nós olhamos.

1106
00:49:24,420 --> 00:49:25,819
Mas é entre os mais poderosos.

1107
00:49:25,819 --> 00:49:28,860
E quando você obtê-lo, é realmente tudo
só vai finalmente chegar juntos.

1108
00:49:28,860 --> 00:49:31,460
Assim, a certeza de que não faz
precisamos todos pia hoje.

1109
00:49:31,460 --> 00:49:32,980
>> Então aqui está o último programa
vamos olhar.

1110
00:49:32,980 --> 00:49:35,605
E vamos acabar com uma
rápidas três minutos de claymation

1111
00:49:35,605 --> 00:49:37,030
feita pelo nosso amigo, Nick Parlante.

1112
00:49:37,030 --> 00:49:41,440
Aqui está um programa, que em os dois primeiros
linhas declara uma variável x e y.

1113
00:49:41,440 --> 00:49:44,780
Ambos os quais são endereços
de inteiros, ponteiros aka.

1114
00:49:44,780 --> 00:49:48,125
Nós, então, alocar o suficiente
memória para armazenar um int

1115
00:49:48,125 --> 00:49:51,344
e armazenar o endereço
em que a memória de x.

1116
00:49:51,344 --> 00:49:53,260
Então, é ainda mais simples
do que o exemplo anterior.

1117
00:49:53,260 --> 00:49:56,100
Dê-me quatro bytes de memória,
que é o tamanho de um int,

1118
00:49:56,100 --> 00:49:58,000
e colocar esse endereço em x.

1119
00:49:58,000 --> 00:50:01,070
Esta linha aqui significa
ir para o endereço em x

1120
00:50:01,070 --> 00:50:05,270
e colocar o significado de
vida, o número 42 lá.

1121
00:50:05,270 --> 00:50:07,710
Mas esta linha me preocupa.

1122
00:50:07,710 --> 00:50:12,620
Estrelar y significa ir para o endereço em y,
e colocar o número 13 azarados lá.

1123
00:50:12,620 --> 00:50:15,780
Por que é perigoso, neste ponto
nas story-- ainda que rapidamente dito

1124
00:50:15,780 --> 00:50:17,980
em nossas minutos minguantes
aqui-- por que é ruim

1125
00:50:17,980 --> 00:50:19,660
para mim dizer, ir para o endereço em y?

1126
00:50:19,660 --> 00:50:21,077
>> AUDIÊNCIA: não Você tem [inaudível].

1127
00:50:21,077 --> 00:50:22,910
DAVID J. MALAN: Eu não tenho
colocar qualquer coisa em y.

1128
00:50:22,910 --> 00:50:25,520
Então, qual é o valor de y,
neste ponto da história?

1129
00:50:25,520 --> 00:50:26,570
Nós não temos idéia.

1130
00:50:26,570 --> 00:50:29,190
É algum valor de lixo
e nem sei Binky.

1131
00:50:29,190 --> 00:50:32,532
Se nós poderíamos terminar com esta nota.

1132
00:50:32,532 --> 00:50:34,832
>> [REPRODUÇÃO DE VÍDEO]

1133
00:50:34,832 --> 00:50:36,500
>> Ei, Binky, acorde.

1134
00:50:36,500 --> 00:50:39,140
É hora para o divertimento ponteiro.

1135
00:50:39,140 --> 00:50:40,210
>> -O que é isso?

1136
00:50:40,210 --> 00:50:41,690
Saiba mais sobre ponteiros?

1137
00:50:41,690 --> 00:50:43,570
Oh, goody.

1138
00:50:43,570 --> 00:50:46,600
>> Bem, para começar, eu acho que estamos
vai precisar de um par de ponteiros.

1139
00:50:46,600 --> 00:50:47,380
>> -ESTÁ BEM.

1140
00:50:47,380 --> 00:50:51,120
Este código aloca dois ponteiros
que pode apontar para números inteiros.

1141
00:50:51,120 --> 00:50:53,557
>> -OK, Bem vejo o
dois ponteiros, mas eles

1142
00:50:53,557 --> 00:50:55,140
não parecem estar apontando para qualquer coisa.

1143
00:50:55,140 --> 00:50:55,970
>> -Está certo.

1144
00:50:55,970 --> 00:50:58,100
Inicialmente ponteiros
não apontam para nada.

1145
00:50:58,100 --> 00:51:00,950
As coisas que eles apontam para são
chamado pointees e configurá-los

1146
00:51:00,950 --> 00:51:02,330
é um passo separado.

1147
00:51:02,330 --> 00:51:03,210
>> Ah, certo, certo.

1148
00:51:03,210 --> 00:51:03,940
Eu sabia.

1149
00:51:03,940 --> 00:51:05,730
Os pointees são separados.

1150
00:51:05,730 --> 00:51:08,310
Então, como você alocar um pointee?

1151
00:51:08,310 --> 00:51:11,960
>> -Ok, Bem este aloca código
uma nova pointee inteiro,

1152
00:51:11,960 --> 00:51:15,050
e isso define Parte X para apontar para ele.

1153
00:51:15,050 --> 00:51:16,240
>> Ei, que parece melhor.

1154
00:51:16,240 --> 00:51:17,743
Assim torná-lo fazer alguma coisa.

1155
00:51:17,743 --> 00:51:23,580
>> -OK, Eu vou cancelar o ponteiro x para
armazenar o número 42 na sua pointee.

1156
00:51:23,580 --> 00:51:27,130
Para este truque, vou precisar da minha
varinha mágica de dereferencing.

1157
00:51:27,130 --> 00:51:30,200
>> -Seu Varinha mágica de dereferencing?

1158
00:51:30,200 --> 00:51:32,310
Uh, isso, isso é ótimo.

1159
00:51:32,310 --> 00:51:34,270
>> -Este É o que o código parece.

1160
00:51:34,270 --> 00:51:35,970
Eu só vou definir o número e-

1161
00:51:35,970 --> 00:51:37,070
>> [POP SOUND]

1162
00:51:37,070 --> 00:51:39,140
>> Ei, olha lá vai.

1163
00:51:39,140 --> 00:51:43,980
Então, fazendo um dereference em x segue
a seta para acessar seu pointee.

1164
00:51:43,980 --> 00:51:46,150
Neste caso, para armazenar 42 em lá.

1165
00:51:46,150 --> 00:51:50,700
Hey, tente usá-lo para armazenar o número
13 através do outro ponteiro, y.

1166
00:51:50,700 --> 00:51:51,840
>> -ESTÁ BEM.

1167
00:51:51,840 --> 00:51:56,270
Eu só vou passar por cima aqui para y,
e obter o número 13 set up.

1168
00:51:56,270 --> 00:52:00,380
E, em seguida, tomar a varinha de
dereferencing e apenas--

1169
00:52:00,380 --> 00:52:01,646
>> [BUZZER SOUND]

1170
00:52:01,646 --> 00:52:04,080
>> Oh, hey que não funcionou.

1171
00:52:04,080 --> 00:52:06,470
Diga, uh, Binky, eu não
acho dereferencing

1172
00:52:06,470 --> 00:52:10,850
y é uma boa idéia, porque a configuração
o pointee é um passo separado.

1173
00:52:10,850 --> 00:52:12,480
E eu não acho que nunca fiz isso.

1174
00:52:12,480 --> 00:52:14,620
>> Hmm, bom ponto.

1175
00:52:14,620 --> 00:52:19,810
>> -Sim, Alocamos o ponteiro, y, mas
nós nunca defini-lo para apontar para um pointee.

1176
00:52:19,810 --> 00:52:21,590
>> Hmm, muito observador.

1177
00:52:21,590 --> 00:52:23,215
Ei, você está procurando boa lá, Binky.

1178
00:52:23,215 --> 00:52:26,390
Você pode corrigi-lo assim que os pontos y
ao mesmo pointee como x.

1179
00:52:26,390 --> 00:52:29,290
>> -Claro, Eu uso minha varinha mágica
de atribuição de ponteiro.

1180
00:52:29,290 --> 00:52:31,970
>> -É Que vai ser um
problema, como antes?

1181
00:52:31,970 --> 00:52:33,790
>> Não, este não toca nas pointees.

1182
00:52:33,790 --> 00:52:35,840
Apenas muda um ponteiro
para apontar para o mesmo coisa--

1183
00:52:35,840 --> 00:52:36,465
>> [Estalo]

1184
00:52:36,465 --> 00:52:37,450
--como outro.

1185
00:52:37,450 --> 00:52:38,440
>> -Oh, eu vejo.

1186
00:52:38,440 --> 00:52:41,200
Agora y aponta para o mesmo local que x.

1187
00:52:41,200 --> 00:52:42,950
Então, espere, agora y é fixo.

1188
00:52:42,950 --> 00:52:44,110
Tem um pointee.

1189
00:52:44,110 --> 00:52:47,779
Então você pode tentar a varinha de
dereferencing novamente para enviar a 13 over.

1190
00:52:47,779 --> 00:52:51,110
>> Ah, OK, aqui vai.

1191
00:52:51,110 --> 00:52:52,330
>> Ei, olha isso.

1192
00:52:52,330 --> 00:52:53,570
Agora dereferencing obras sobre y.

1193
00:52:53,570 --> 00:52:57,900
E porque os ponteiros estão compartilhando
que um pointee, os dois vêem a 13.

1194
00:52:57,900 --> 00:52:59,952
>> -Sim, Partilha, uh, qualquer que seja.

1195
00:52:59,952 --> 00:53:01,535
Então, vamos trocar de lugar agora?

1196
00:53:01,535 --> 00:53:03,730
>> -Ah, Olha que estamos fora do tempo.

1197
00:53:03,730 --> 00:53:04,660
>> -But--

1198
00:53:04,660 --> 00:53:06,520
>> -Apenas Lembrar as três regras de ponteiro.

1199
00:53:06,520 --> 00:53:09,550
Número 1, a estrutura básica
é que você tem um ponteiro,

1200
00:53:09,550 --> 00:53:11,630
e aponta até um pointee.

1201
00:53:11,630 --> 00:53:13,740
Mas o ponteiro e
pointee são separados.

1202
00:53:13,740 --> 00:53:15,620
E o erro comum
é a criação de um ponteiro

1203
00:53:15,620 --> 00:53:18,000
mas para se esqueça de dar-lhe um pointee.

1204
00:53:18,000 --> 00:53:21,170
>> Número 2, dereferencing ponteiro
começa no ponteiro

1205
00:53:21,170 --> 00:53:24,020
e segue a sua seta sobre
para acessar sua pointee.

1206
00:53:24,020 --> 00:53:27,815
Como todos sabemos, isso só funciona se houver
é um pointee, que tipo de recebe de volta

1207
00:53:27,815 --> 00:53:29,260
a regra número 1.

1208
00:53:29,260 --> 00:53:31,990
>> Número 3, ponteiro
atribuição leva um ponteiro

1209
00:53:31,990 --> 00:53:35,330
e muda-lo para apontar para o
pointee mesmo como um outro ponteiro.

1210
00:53:35,330 --> 00:53:37,150
Assim, após a atribuição,
os dois ponteiros

1211
00:53:37,150 --> 00:53:40,927
irá apontar para o mesmo pointee,
Às vezes isso é chamado de partilha.

1212
00:53:40,927 --> 00:53:42,510
E isso é tudo que existe para ela, realmente.

1213
00:53:42,510 --> 00:53:43,130
Bye-bye agora.

1214
00:53:43,130 --> 00:53:43,475
>> [FIM DE REPRODUÇÃO]

1215
00:53:43,475 --> 00:53:44,830
>> DAVID J. MALAN: Isso é tudo para CS50.

1216
00:53:44,830 --> 00:53:46,246
Graças ao Professor Nick Parlante.

1217
00:53:46,246 --> 00:53:47,730
Vamos vê-lo na próxima semana.

1218
00:53:47,730 --> 00:53:51,706

1219
00:53:51,706 --> 00:53:56,435
>> [MÚSICA ELETRÔNICA DE JOGO]

1220
00:53:56,435 --> 00:57:22,775