1
00:00:00,000 --> 00:00:01,110
>> [MÚSICA DE JOGO]

2
00:00:01,110 --> 00:00:10,567

3
00:00:10,567 --> 00:00:11,650
DAVID J. MALAN: Tudo bem.

4
00:00:11,650 --> 00:00:15,610
Este é CS50, e esta
é o final da quarta semana.

5
00:00:15,610 --> 00:00:19,420
E um dos temas hoje
é a de forense digital,

6
00:00:19,420 --> 00:00:20,989
técnica de recuperar a informação.

7
00:00:20,989 --> 00:00:22,780
E, de fato, muito embora
você está no meio

8
00:00:22,780 --> 00:00:25,070
agora da Paz em Três
e Breakout, na próxima semana,

9
00:00:25,070 --> 00:00:27,880
o foco será em
precisamente neste domínio.

10
00:00:27,880 --> 00:00:30,686
>> Então, um dos trabalhos mais legais que eu já
teve foi em pós-graduação,

11
00:00:30,686 --> 00:00:33,560
quando eu estava trabalhando para o local,
Middlesex County District Attorney

12
00:00:33,560 --> 00:00:34,950
escritório, fazendo forense trabalhar.

13
00:00:34,950 --> 00:00:37,450
Então, basicamente, o Massachusetts
Polícia do Estado, na ocasião,

14
00:00:37,450 --> 00:00:40,100
quando se trabalha em casos seria
trazer coisas como discos rígidos

15
00:00:40,100 --> 00:00:42,185
e disquetes e
cartões de memória e similares.

16
00:00:42,185 --> 00:00:44,060
E eles iriam entregá-los
para mim e meu mentor,

17
00:00:44,060 --> 00:00:48,070
e nosso objetivo era encontrar provas,
se havia algum, nestes meios.

18
00:00:48,070 --> 00:00:50,700
Vislumbres Agora, você pode ter visto
deste mundo da ciência forense

19
00:00:50,700 --> 00:00:53,000
na mídia, TV e cinema.

20
00:00:53,000 --> 00:00:55,730
Mas o trabalho que eu tinha, e
ouso dizer que o mundo,

21
00:00:55,730 --> 00:00:57,550
não é bem assim que você vê-lo.

22
00:00:57,550 --> 00:01:00,794
Vamos dar uma olhada no que
você provavelmente já viu.

23
00:01:00,794 --> 00:01:01,460
[REPRODUÇÃO]

24
00:01:01,460 --> 00:01:02,930
-OK.

25
00:01:02,930 --> 00:01:05,380
Agora, vamos dar uma boa olhada em você.

26
00:01:05,380 --> 00:01:06,850
>> [MÚSICA DE JOGO]

27
00:01:06,850 --> 00:01:12,260

28
00:01:12,260 --> 00:01:12,932
>> -Segure Ele.

29
00:01:12,932 --> 00:01:13,657
Correr de volta.

30
00:01:13,657 --> 00:01:14,733
>> Espere um minuto.

31
00:01:14,733 --> 00:01:15,233
Vá para a direita.

32
00:01:15,233 --> 00:01:16,371

33
00:01:16,371 --> 00:01:16,870
-Há.

34
00:01:16,870 --> 00:01:17,369
Congelar isso.

35
00:01:17,369 --> 00:01:17,930
Tela -Full.

36
00:01:17,930 --> 00:01:18,376
>> -OK.

37
00:01:18,376 --> 00:01:18,875
Congelar isso.

38
00:01:18,875 --> 00:01:20,160
-Tighten-Se sobre isso, você vai?

39
00:01:20,160 --> 00:01:22,126
>> -vector Em em que
cara pela roda traseira.

40
00:01:22,126 --> 00:01:24,435
>> -zoom Em direito aqui neste local.

41
00:01:24,435 --> 00:01:28,580
>> -Com O equipamento certo, o
imagem pode ser ampliada e afiada.

42
00:01:28,580 --> 00:01:29,330
>> -Qual Que é isso?

43
00:01:29,330 --> 00:01:30,780
>> -É Um programa de melhoramento.

44
00:01:30,780 --> 00:01:32,170
>> -Consegue Claro que se for o caso?

45
00:01:32,170 --> 00:01:33,070
>> Năo sei.

46
00:01:33,070 --> 00:01:34,150
Vamos melhorá-lo.

47
00:01:34,150 --> 00:01:35,440
>> -Aprimore Seção A6.

48
00:01:35,440 --> 00:01:36,570

49
00:01:36,570 --> 00:01:38,562
Eu aumentei o detalhe, e--

50
00:01:38,562 --> 00:01:40,020
-Acho Há o suficiente para melhorar.

51
00:01:40,020 --> 00:01:40,976
Liberá-lo para a tela do computador.

52
00:01:40,976 --> 00:01:42,559
>> -I Reforçada a reflexão em seus olhos.

53
00:01:42,559 --> 00:01:44,322
-Vamos Executar este meio
aprimoramento de vídeo.

54
00:01:44,322 --> 00:01:45,210
>> -Edgar, Você pode melhorar isso?

55
00:01:45,210 --> 00:01:45,710
>> -hang Em.

56
00:01:45,710 --> 00:01:47,570

57
00:01:47,570 --> 00:01:49,458
>> -Eu Vindo a trabalhar sobre esta reflexão.

58
00:01:49,458 --> 00:01:50,402
>> Reflexo de alguém -Há.

59
00:01:50,402 --> 00:01:50,902
>> -Reflection.

60
00:01:50,902 --> 00:01:52,870
-Há Um reflexo do rosto do homem.

61
00:01:52,870 --> 00:01:53,694
>> Reflexão -The!

62
00:01:53,694 --> 00:01:54,610
-Há Uma reflexão.

63
00:01:54,610 --> 00:01:55,880
-zoom Em no espelho.

64
00:01:55,880 --> 00:01:57,860
Você pode ver um reflexo.

65
00:01:57,860 --> 00:01:59,630
>> Você-pode melhorar a imagem a partir daqui?

66
00:01:59,630 --> 00:02:00,377

67
00:02:00,377 --> 00:02:01,210
Você-pode melhorá-lo?

68
00:02:01,210 --> 00:02:02,190
Você-pode melhorá-lo?

69
00:02:02,190 --> 00:02:03,066
-Podemos Melhorar isso?

70
00:02:03,066 --> 00:02:03,898
Você-pode melhorá-lo?

71
00:02:03,898 --> 00:02:04,740
-Segure Um segundo.

72
00:02:04,740 --> 00:02:05,281
Eu vou melhorar.

73
00:02:05,281 --> 00:02:06,470
-zoom Em na porta.

74
00:02:06,470 --> 00:02:06,970
-Times 10.

75
00:02:06,970 --> 00:02:08,009
-Zoom.

76
00:02:08,009 --> 00:02:08,509
-Mover Em.

77
00:02:08,509 --> 00:02:09,340
-Mais.

78
00:02:09,340 --> 00:02:10,094
Espere, pare.

79
00:02:10,094 --> 00:02:10,750
Pare.

80
00:02:10,750 --> 00:02:11,250
-PAUSE Ele.

81
00:02:11,250 --> 00:02:13,542
-Rotate Nos 75 graus
em torno da vertical, por favor.

82
00:02:13,542 --> 00:02:14,750

83
00:02:14,750 --> 00:02:16,127
>> Pare.

84
00:02:16,127 --> 00:02:19,330
Volte para a parte
sobre a porta novamente.

85
00:02:19,330 --> 00:02:21,420
>> -Tem Um intensificador de imagem que pode bitmap?

86
00:02:21,420 --> 00:02:24,420
>> -Talvez Podemos usar o Pradeep Singh
método para ver nas janelas.

87
00:02:24,420 --> 00:02:25,902
>> -The Software é o estado da arte.

88
00:02:25,902 --> 00:02:26,866
>> -The Autovalor está desligado.

89
00:02:26,866 --> 00:02:29,758
>> -Com Direita
combinação de algorithms--

90
00:02:29,758 --> 00:02:32,168
>> Iluminação tomadas -Ele
algoritmos para o próximo nível,

91
00:02:32,168 --> 00:02:34,110
e eu posso usá-los para
melhorar esta fotografia.

92
00:02:34,110 --> 00:02:36,840
>> -lock On e ampliar o eixo z.

93
00:02:36,840 --> 00:02:37,351
>> -Aprimore.

94
00:02:37,351 --> 00:02:37,850
Aprimorar.

95
00:02:37,850 --> 00:02:38,720
-Aprimore.

96
00:02:38,720 --> 00:02:40,070
-Freeze E melhorar.

97
00:02:40,070 --> 00:02:43,420
[FIM REPRODUÇÃO DE VÍDEO]

98
00:02:43,420 --> 00:02:45,830
DAVID J. MALAN: Então, essas são
todas as palavras, mas não eram

99
00:02:45,830 --> 00:02:47,870
usado em frases corretamente.

100
00:02:47,870 --> 00:02:52,370
E, de fato, no futuro, a qualquer hora,
por favor, você ouve alguém dizer a palavra,

101
00:02:52,370 --> 00:02:54,250
"Melhorar", rir um pouco.

102
00:02:54,250 --> 00:02:57,190
Porque quando você tenta melhorar,
por exemplo, isso é o que acontece.

103
00:02:57,190 --> 00:02:58,580
>> Então aqui vai uma foto linda.

104
00:02:58,580 --> 00:02:59,720
Isto é próprio Daven de CS50.

105
00:02:59,720 --> 00:03:03,740
E suponha que queríamos
focar na brilho nos olhos,

106
00:03:03,740 --> 00:03:05,870
ou a reflexão do
bandido que estava claramente

107
00:03:05,870 --> 00:03:07,820
capturada pela câmera de segurança.

108
00:03:07,820 --> 00:03:10,330
Isto é o que acontece quando
você aumentar o zoom em uma imagem que

109
00:03:10,330 --> 00:03:14,060
tem apenas um número finito
de bits associados.

110
00:03:14,060 --> 00:03:15,420
>> Isso é o que você iria ficar.

111
00:03:15,420 --> 00:03:19,190
E, de fato, está no olho do Daven
é, mas quatro, talvez seis pixels

112
00:03:19,190 --> 00:03:22,110
que compõem exatamente o que
foi brilhando lá.

113
00:03:22,110 --> 00:03:25,890
Então Problem Set Quatro acabará por ter
você explorar este mundo, especialmente

114
00:03:25,890 --> 00:03:28,090
pela natureza de algo
que chamamos de arquivo I / O, onde

115
00:03:28,090 --> 00:03:31,000
i / o é apenas uma maneira elegante de
dizendo entrada e saída.

116
00:03:31,000 --> 00:03:34,280
>> Então, até agora, todas as interações
que tivemos com um computador

117
00:03:34,280 --> 00:03:36,770
ter sido em grande parte com o seu
teclado e ecrã,

118
00:03:36,770 --> 00:03:40,770
mas não tanto com o disco rígido,
ou gravar os ficheiros para além dos que você

119
00:03:40,770 --> 00:03:41,620
você mesmo escrever.

120
00:03:41,620 --> 00:03:44,570
Seus programas, até agora, tem
não vindo a criar e salvar,

121
00:03:44,570 --> 00:03:46,270
e atualização de seus próprios arquivos.

122
00:03:46,270 --> 00:03:47,150
>> Bem, o que é um arquivo?

123
00:03:47,150 --> 00:03:48,105
Bem, algo como um JPEG.

124
00:03:48,105 --> 00:03:50,520
Esta é uma imagem que você pode
ter ou fazer upload para o Facebook,

125
00:03:50,520 --> 00:03:51,690
ou ver em qualquer lugar na web.

126
00:03:51,690 --> 00:03:54,460
Na verdade, essa foto que acabamos de
serra de Daven foi um JPEG.

127
00:03:54,460 --> 00:03:57,570
E o que é interessante
sobre arquivos como JPEGs

128
00:03:57,570 --> 00:04:02,170
é que eles podem ser identificados,
tipicamente, por certos padrões de bits.

129
00:04:02,170 --> 00:04:05,200
>> Em outras palavras, o que é que
distingue um JPEG a partir de um GIF

130
00:04:05,200 --> 00:04:08,109
a partir de um PING a partir de uma palavra
documento a partir de um arquivo do Excel?

131
00:04:08,109 --> 00:04:09,900
Bem, é apenas diferente
padrões de bits.

132
00:04:09,900 --> 00:04:12,820
E esses padrões diferentes são
geralmente no início desses ficheiros.

133
00:04:12,820 --> 00:04:18,200
>> De modo que quando o computador abre uma Palavra
doc, ou quando um computador abre um JPEG,

134
00:04:18,200 --> 00:04:20,940
parece tipicamente na
primeiro de vários bits no arquivo.

135
00:04:20,940 --> 00:04:24,059
E se reconhece um padrão,
ele diz, oh, esta é uma imagem.

136
00:04:24,059 --> 00:04:25,850
Deixe-me apresentá-lo ao
o usuário como um gráfico.

137
00:04:25,850 --> 00:04:27,870
Ou, oh, isso se parece com um documento do Word.

138
00:04:27,870 --> 00:04:30,480
Deixe-me mostrar para o usuário como um ensaio.

139
00:04:30,480 --> 00:04:33,020
>> Assim, por exemplo, JPEGs,
ao que parece, são

140
00:04:33,020 --> 00:04:35,460
bastante sofisticado
debaixo do capô.

141
00:04:35,460 --> 00:04:40,140
Mas os três primeiros bytes em quase todas as
JPEG começar com estes três números.

142
00:04:40,140 --> 00:04:44,680
Assim byte zero, um, dois e são, em
mais cada JPEG, 255, então o número

143
00:04:44,680 --> 00:04:46,675
216, em seguida, o número 255.

144
00:04:46,675 --> 00:04:48,990
>> E o que você vai ser capaz
para começar a fazer na próxima semana

145
00:04:48,990 --> 00:04:52,920
é, na verdade, cutucando por baixo
a capa de arquivos como JPEGs

146
00:04:52,920 --> 00:04:57,210
e como arquivos de bitmap, e vendo
o que sempre esteve lá por tanto tempo

147
00:04:57,210 --> 00:04:58,650
como você está usando um computador.

148
00:04:58,650 --> 00:05:01,860
>> Mas o que está lá não é tipicamente
escrito como números decimais como este.

149
00:05:01,860 --> 00:05:04,620
Os cientistas da computação não
tendem a falar em decimal.

150
00:05:04,620 --> 00:05:06,139
Eles realmente não falam em binário.

151
00:05:06,139 --> 00:05:07,930
Normalmente, quando queremos
para expressar números,

152
00:05:07,930 --> 00:05:10,710
nós realmente usar hexadecimal,
que você pode recordar

153
00:05:10,710 --> 00:05:13,027
de, digamos, Conjunto de Problemas
Um deles, que desafiou

154
00:05:13,027 --> 00:05:14,610
você pensar em um sistema diferente.

155
00:05:14,610 --> 00:05:17,170
>> Nós, é claro, estão familiarizados
com decimal, de zero a nove.

156
00:05:17,170 --> 00:05:18,215
Nós conversamos sobre binário.

157
00:05:18,215 --> 00:05:20,710
E nós realmente não têm
usar muito aqui

158
00:05:20,710 --> 00:05:22,470
em diante, porque os computadores irão usar isso.

159
00:05:22,470 --> 00:05:24,900
Mas os programadores vão muito
muitas vezes, mas não sempre,

160
00:05:24,900 --> 00:05:29,360
usar hexadecimal, o que significa apenas
você tem 16 letras no alfabeto,

161
00:05:29,360 --> 00:05:31,330
em oposição a duas ou 10.

162
00:05:31,330 --> 00:05:34,530
>> Então, como você contar até maior
de nove em hexadecimal?

163
00:05:34,530 --> 00:05:41,120
Você vai 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
a, b, c, d, e, f, apenas por convenção.

164
00:05:41,120 --> 00:05:43,540
Mas o que é fundamental é que cada
destes é um único símbolo.

165
00:05:43,540 --> 00:05:44,340
Não há 10.

166
00:05:44,340 --> 00:05:48,400
Não existe 11, por si só, porque cada
de seus dígitos, assim como em decimal

167
00:05:48,400 --> 00:05:51,940
e, assim como no sistema binário, deve apenas
ser um personagem único, por convenção.

168
00:05:51,940 --> 00:05:55,280
>> Para que, então, é o alfabeto que temos
à nossa disposição para hexadecimal.

169
00:05:55,280 --> 00:05:58,600
Então, o que um JPEG olhar como se você
eram para escrever os três primeiros

170
00:05:58,600 --> 00:06:01,980
não bytes como decimal, mas,
por exemplo, como hexadecimal?

171
00:06:01,980 --> 00:06:03,640
E por que é hex mesmo tão útil?

172
00:06:03,640 --> 00:06:05,290
>> Bem, uma rápida olhada em um exemplo.

173
00:06:05,290 --> 00:06:09,030
Então, se eu escrever os bits que
representam estes Números de decimal

174
00:06:09,030 --> 00:06:12,450
isso pode ser um pouco enferrujado
agora de algumas semanas atrás,

175
00:06:12,450 --> 00:06:14,820
mas o esquerdo e o
um direito é muito fácil.

176
00:06:14,820 --> 00:06:17,990
255 foi o maior que o número
poderia representar com oito bits.

177
00:06:17,990 --> 00:06:18,820
Era todos os queridos.

178
00:06:18,820 --> 00:06:21,320
Então, a única que é ligeiramente
interessante é o do meio.

179
00:06:21,320 --> 00:06:24,700
E se você tipo de fazer a
matemática, você vai deduzir que, de fato,

180
00:06:24,700 --> 00:06:27,949
esse padrão de um e
zeros representa 216.

181
00:06:27,949 --> 00:06:30,240
Então vamos estipular para
agora que estes estão corretos.

182
00:06:30,240 --> 00:06:31,730
Mas por que isso é interessante?

183
00:06:31,730 --> 00:06:33,970
>> Bem, um byte, é claro, é de oito bits.

184
00:06:33,970 --> 00:06:38,980
E verifica-se que se você pensar
de um byte de dois blocos de quatro bits,

185
00:06:38,980 --> 00:06:39,500
assim.

186
00:06:39,500 --> 00:06:41,000
Deixe-me apenas acrescentar um pouco de espaço.

187
00:06:41,000 --> 00:06:42,550
Então, antes, depois.

188
00:06:42,550 --> 00:06:46,520
Eu acabei de adicionar algum espaço em branco
pelo amor de visualização aqui.

189
00:06:46,520 --> 00:06:51,840
Como podemos agora representar em,
digamos, hexadecimal cada quad de bits,

190
00:06:51,840 --> 00:06:52,880
cada conjunto de quatro bits?

191
00:06:52,880 --> 00:06:56,420
>> Assim, por exemplo, no lado esquerdo
agora, temos 1111 em binário.

192
00:06:56,420 --> 00:07:00,420
Qual é esse número em decimal,
se você fizer a matemática?

193
00:07:00,420 --> 00:07:03,780
Você tem a casa das unidades, o local dois,
o lugar de quatro, eo lugar oitos.

194
00:07:03,780 --> 00:07:04,341
>> AUDIÊNCIA: 15.

195
00:07:04,341 --> 00:07:05,340
DAVID J. MALAN: É 15.

196
00:07:05,340 --> 00:07:08,340
Então, se fizermos oito mais quatro
mais dois mais um, temos 15.

197
00:07:08,340 --> 00:07:11,790
Então, eu poderia escrever 15 abaixo
1111, mas o ponto aqui

198
00:07:11,790 --> 00:07:13,190
é hexadecimal, não decimal.

199
00:07:13,190 --> 00:07:17,310
Então, ao invés de escrever 15, 1-5,
Eu vou escrever isso em hexadecimal,

200
00:07:17,310 --> 00:07:22,311
que se você olhar para trás, se você tiver
zero a f, o que é 15 vai ser?

201
00:07:22,311 --> 00:07:22,810
AUDIÊNCIA: f.

202
00:07:22,810 --> 00:07:24,434
DAVID J. MALAN: Então não é que a sua f.

203
00:07:24,434 --> 00:07:29,140
E você pode resolver isso, dizendo:
assim, se um é 10, então OK, f é 15.

204
00:07:29,140 --> 00:07:33,250
Então, na verdade, poderíamos reescrever
este mesmo conjunto de números como f f.

205
00:07:33,250 --> 00:07:35,750
E então, se fizermos um pouco de matemática,
vamos deduzir que isso é d.

206
00:07:35,750 --> 00:07:38,650
Oito é muito fácil, porque nós
ter um no lugar oitos.

207
00:07:38,650 --> 00:07:40,620
E então, temos um casal mais f f do.

208
00:07:40,620 --> 00:07:44,669
>> Então, o que os seres humanos tendem a fazer por convenção
quando usam hexadecimal é que eles simplesmente

209
00:07:44,669 --> 00:07:47,710
escrever este um pouco mais sucinta,
se livrar da maior parte desse espaço em branco.

210
00:07:47,710 --> 00:07:50,890
E só para ser super claro para
leitores que este é hexadecimal,

211
00:07:50,890 --> 00:07:54,670
a simples convenção entre
seres humanos é você escrever de zero

212
00:07:54,670 --> 00:07:58,000
x, que não tem outro significado
do que um identificador visual,

213
00:07:58,000 --> 00:07:59,590
aqui vem um número hexadecimal.

214
00:07:59,590 --> 00:08:04,210
>> E então, você coloca os dois dígitos, f
f neste caso, em seguida, d a, então f f.

215
00:08:04,210 --> 00:08:06,700
Então, longa história curta,
hexadecimal só tende

216
00:08:06,700 --> 00:08:11,990
para ser útil porque cada um dos seus
dígitos, de zero a f, perfeitamente linhas

217
00:08:11,990 --> 00:08:13,880
acima com um padrão de quatro bits.

218
00:08:13,880 --> 00:08:18,080
>> Então, se você tem dois dígitos hexadecimais,
zero a F, uma e outra vez,

219
00:08:18,080 --> 00:08:20,256
que lhe dá perfeitamente
oito bits ou um byte.

220
00:08:20,256 --> 00:08:22,380
Então é por isso que tende a
convencionalmente ser útil.

221
00:08:22,380 --> 00:08:24,990
Não há intelectual
conteúdo muito além disso,

222
00:08:24,990 --> 00:08:27,010
diferente da sua real utilidade.

223
00:08:27,010 --> 00:08:29,310
>> Agora JPEGs não são a única
formatos de arquivo para gráficos.

224
00:08:29,310 --> 00:08:33,230
Você deve se lembrar que existem
arquivos como este no mundo,

225
00:08:33,230 --> 00:08:34,830
pelo menos a partir de alguns anos atrás.

226
00:08:34,830 --> 00:08:37,580
>> Portanto, este foi realmente
instalado no Windows XP

227
00:08:37,580 --> 00:08:39,960
em milhões de PCs em todo o mundo.

228
00:08:39,960 --> 00:08:43,000
E este era um arquivo bitmap, BMP.

229
00:08:43,000 --> 00:08:47,690
E um arquivo de bitmap, como você verá no próximo
semana, apenas significa um padrão de pontos,

230
00:08:47,690 --> 00:08:51,710
pixels, como são chamados,
Um mapa em pedaços, na verdade.

231
00:08:51,710 --> 00:08:55,160
>> Então, o que é interessante, porém,
sobre o formato de arquivo, BMP, é

232
00:08:55,160 --> 00:08:58,590
que debaixo do capô, ele
tem mais do que apenas três bytes

233
00:08:58,590 --> 00:09:01,020
que compor seu cabeçalho, assim
dizer, as primeiras mordidas.

234
00:09:01,020 --> 00:09:03,330
Ele realmente parece um pouco
complicado à primeira vista.

235
00:09:03,330 --> 00:09:04,704
E você vai ver isso no conjunto P.

236
00:09:04,704 --> 00:09:06,810
E recebendo algo
especial deste agora

237
00:09:06,810 --> 00:09:10,720
não é tão importante, como apenas o facto
que, no início de cada bitmap

238
00:09:10,720 --> 00:09:13,823
arquivo, um formato gráfico,
há um monte de números.

239
00:09:13,823 --> 00:09:14,980

240
00:09:14,980 --> 00:09:16,720
>> Agora, a Microsoft, a
autor deste formato,

241
00:09:16,720 --> 00:09:18,820
tende a chamar aqueles
As coisas não inteiros e caracteres

242
00:09:18,820 --> 00:09:22,259
e carros alegóricos, mas palavras e d
palavras e anseia e bytes.

243
00:09:22,259 --> 00:09:23,800
Então, eles são apenas diferentes tipos de dados.

244
00:09:23,800 --> 00:09:25,170
Eles são nomes diferentes
para a mesma coisa.

245
00:09:25,170 --> 00:09:26,740
Mas você vai ver que em P Set Four.

246
00:09:26,740 --> 00:09:31,450
>> Mas isso é só para dizer que se um ser humano
clica duas vezes em algum arquivo bmp em seu

247
00:09:31,450 --> 00:09:35,015
ou seu disco rígido, e uma janela se abre
up mostrando-lhe que a imagem,

248
00:09:35,015 --> 00:09:38,500
isso aconteceu porque a operação
sistema presumivelmente notado não só

249
00:09:38,500 --> 00:09:41,460
a extensão do arquivo bmp
no nome do arquivo,

250
00:09:41,460 --> 00:09:45,010
mas também o fato de que há alguns
convenção para o padrão de bits

251
00:09:45,010 --> 00:09:47,490
no início
desse arquivo bitmap.

252
00:09:47,490 --> 00:09:50,270
>> Mas vamos agora concentrar-se em
um arquivo complicado tal,

253
00:09:50,270 --> 00:09:52,120
mas em algo como isso.

254
00:09:52,120 --> 00:09:55,190
Suponha que aqui em GEdit, I
só tem o começo

255
00:09:55,190 --> 00:09:57,070
de um programa que é muito simples.

256
00:09:57,070 --> 00:09:58,860
Eu tenho algumas inclui em cima.

257
00:09:58,860 --> 00:10:02,120
Agora eu tenho "structs.h" # include mas
Eu vou voltar a isso em um momento.

258
00:10:02,120 --> 00:10:03,974
Mas isto é útil para agora.

259
00:10:03,974 --> 00:10:05,890
Portanto, este é um programa
que vai implementar

260
00:10:05,890 --> 00:10:07,335
como banco de dados do registrador.

261
00:10:07,335 --> 00:10:09,710
Assim, um banco de dados de alunos,
e cada aluno no mundo

262
00:10:09,710 --> 00:10:13,190
tem um nome e uma casa e, provavelmente, alguns
outras coisas, mas vamos mantê-lo simples.

263
00:10:13,190 --> 00:10:15,140
Cada estudante tem um nome e uma casa.

264
00:10:15,140 --> 00:10:17,700
>> Então, se eu queria escrever um
programa cujo objetivo na vida

265
00:10:17,700 --> 00:10:19,860
foi apenas para fazer uma iteração do
zerar em até três,

266
00:10:19,860 --> 00:10:22,070
se há três estudantes
na Universidade de Harvard.

267
00:10:22,070 --> 00:10:25,350
E eu só quero pegar, usando GetString,
O nome de cada aluno e da casa,

268
00:10:25,350 --> 00:10:26,600
e depois é só imprimir os para fora.

269
00:10:26,600 --> 00:10:28,630
>> Esta é uma espécie de Semana
One, Two Week coisas agora,

270
00:10:28,630 --> 00:10:30,810
onde eu só quero uma para
loop ou algo parecido.

271
00:10:30,810 --> 00:10:34,500
E eu quero chamar GetString alguns
vezes, e em seguida, imprimir f algumas vezes.

272
00:10:34,500 --> 00:10:37,340
Então, como eu poderia fazer isso, porém,
quando um nome e uma casa

273
00:10:37,340 --> 00:10:39,070
estão envolvidos para cada aluno?

274
00:10:39,070 --> 00:10:42,830
>> Então, meu primeiro instinto pode
ser para fazer algo assim.

275
00:10:42,830 --> 00:10:49,620
Eu poderia dizer em primeiro lugar, bem, dê-me,
dizer, uma matriz de strings chamados nomes.

276
00:10:49,620 --> 00:10:51,530
E eu não quero um hardcode três aqui.

277
00:10:51,530 --> 00:10:53,064
O que eu quero colocar lá?

278
00:10:53,064 --> 00:10:55,730
Para que os alunos, porque isso é apenas
uma constante declarado na parte superior,

279
00:10:55,730 --> 00:10:57,860
apenas para que eu não tenho que codificar
três em vários lugares.

280
00:10:57,860 --> 00:11:00,859
Desta forma, eu posso mudá-lo um lugar,
e isso afeta uma mudança em todos os lugares.

281
00:11:00,859 --> 00:11:04,470
E então, eu poderia fazer
cadeia abriga alunos.

282
00:11:04,470 --> 00:11:10,250
>> E agora, eu poderia fazer algo assim
for (int i = 0; i <ESTUDANTES; i ++.

283
00:11:10,250 --> 00:11:14,390
Então, eu estou escrevendo rápido, mas isso é
provavelmente familiar sintaxe agora.

284
00:11:14,390 --> 00:11:17,030
>> E agora, este foi mais recente.

285
00:11:17,030 --> 00:11:22,890
Se eu quiser colocar no i-th
nome do aluno, eu acho que eu faço isso.

286
00:11:22,890 --> 00:11:26,480
E então, não os nomes
mas casas adaptador.

287
00:11:26,480 --> 00:11:29,930
Eu faço isso, GetString, e deixar
me voltar atrás e corrigir esta linha.

288
00:11:29,930 --> 00:11:30,430
Concordar?

289
00:11:30,430 --> 00:11:31,200
Discorda?

290
00:11:31,200 --> 00:11:32,366
Não é muito fácil de usar.

291
00:11:32,366 --> 00:11:33,890
Eu não disse que o usuário o que fazer.

292
00:11:33,890 --> 00:11:36,520
>> Mas agora, se eu também
queria mais tarde, vamos

293
00:11:36,520 --> 00:11:40,060
digamos, imprimir essas coisas
out-- assim TODO posterior.

294
00:11:40,060 --> 00:11:42,330
Vou fazer mais com
isso-- este sem dúvida é

295
00:11:42,330 --> 00:11:45,970
uma correcta execução
recebendo nomes e casas, três

296
00:11:45,970 --> 00:11:48,870
do total de cada um deles, a partir de um utilizador.

297
00:11:48,870 --> 00:11:51,280
>> Mas isso não é muito bom design, certo?

298
00:11:51,280 --> 00:11:55,220
E se um aluno não tem apenas um nome
e uma casa, mas também um número de identificação,

299
00:11:55,220 --> 00:11:57,770
e um número de telefone,
e um endereço de e-mail,

300
00:11:57,770 --> 00:12:00,280
e talvez um home page, e
talvez uma alça Twitter,

301
00:12:00,280 --> 00:12:03,730
e qualquer número de outros detalhes
associado com um aluno ou uma pessoa,

302
00:12:03,730 --> 00:12:04,610
de modo mais geral.

303
00:12:04,610 --> 00:12:07,720
Como é que nós começamos a adicionar
funcionalidade para este programa?

304
00:12:07,720 --> 00:12:14,080
>> Bem, eu sinto que a maneira mais simples pode
ser para fazer algo assim, digamos,

305
00:12:14,080 --> 00:12:16,490
int id alunos.

306
00:12:16,490 --> 00:12:18,380
Portanto, posso colocar todos os seus IDs lá.

307
00:12:18,380 --> 00:12:22,240
E, em seguida, para algo
como números de telefone,

308
00:12:22,240 --> 00:12:24,400
Eu não sei como
representa que apenas ainda.

309
00:12:24,400 --> 00:12:30,280
Então, vamos em frente e apenas chamada
este twitters alunos, o que

310
00:12:30,280 --> 00:12:33,550
É um pouco estranho, mas--
e mais um monte campos.

311
00:12:33,550 --> 00:12:36,360
>> Eu comecei a efetivamente
copiar e colar aqui.

312
00:12:36,360 --> 00:12:39,416
E isso vai crescer muito
pesado muito rapidamente, certo?

313
00:12:39,416 --> 00:12:42,290
Não seria bom se houvesse
em todo o mundo uma estrutura de dados conhecida

314
00:12:42,290 --> 00:12:45,600
não como um int ou uma corda, mas algo
nível superior, uma abstração, de modo

315
00:12:45,600 --> 00:12:47,570
dizer, conhecido como um aluno?

316
00:12:47,570 --> 00:12:50,220
C não veio com built-in
funcionalidade para os estudantes,

317
00:12:50,220 --> 00:12:52,260
mas e se eu queria dar-lhe tal?

318
00:12:52,260 --> 00:12:55,640
>> Bem, ao que parece, eu vou
abrir um arquivo chamado structs.h aqui,

319
00:12:55,640 --> 00:12:57,090
e você pode fazer exatamente isso.

320
00:12:57,090 --> 00:12:58,290
E vamos começar a fazer isso agora.

321
00:12:58,290 --> 00:13:01,490
E debaixo do capô de P Conjunto Três,
você já venho fazendo isso agora.

322
00:13:01,490 --> 00:13:05,920
Não existe tal coisa como um g ret ou
um g oval na linguagem de programação C.

323
00:13:05,920 --> 00:13:10,570
>> Pessoal da Stanford implementado aqueles
tipos de dados usando esta abordagem aqui,

324
00:13:10,570 --> 00:13:13,900
declarando sua própria novos dados
tipos usando uma nova palavra-chave

325
00:13:13,900 --> 00:13:16,744
chamada estrutura e outra
um chamado typedef.

326
00:13:16,744 --> 00:13:19,660
E, de facto, embora a sintaxe
parece um pouco diferente a partir de material

327
00:13:19,660 --> 00:13:23,550
que já vimos antes, em
princípio, é super simples.

328
00:13:23,550 --> 00:13:25,297
>> Isto significa apenas "definir um tipo."

329
00:13:25,297 --> 00:13:27,255
Isso vai ser um
estrutura, e uma estrutura

330
00:13:27,255 --> 00:13:29,400
é como um recipiente
para várias coisas.

331
00:13:29,400 --> 00:13:31,780
E essa estrutura vai
para ter uma seqüência chamada nome,

332
00:13:31,780 --> 00:13:33,210
e uma série chamada casa.

333
00:13:33,210 --> 00:13:37,520
E vamos chamar, apenas por conveniência,
esta estrutura de dados inteira estudante.

334
00:13:37,520 --> 00:13:40,320
>> Assim, no momento que você começa a
o ponto e vírgula, você tem agora

335
00:13:40,320 --> 00:13:43,280
criou seu próprio dados
tipo chamado estudante

336
00:13:43,280 --> 00:13:46,420
que agora está ao lado de int,
e float e char, e corda,

337
00:13:46,420 --> 00:13:50,270
e g rect, e g oval, e qualquer número
de outras coisas que as pessoas inventaram.

338
00:13:50,270 --> 00:13:53,340
>> Então, o que é útil sobre esta
agora é que se eu voltar

339
00:13:53,340 --> 00:13:57,430
para a estrutura 0 e terminar esta
implementação, o que eu escrevi

340
00:13:57,430 --> 00:14:02,080
com antecedência aqui, notar que todos
da desordem inevitável que

341
00:14:02,080 --> 00:14:05,490
estava prestes a começar a acontecer como eu adicionei
números de telefone e twitters e tudo

342
00:14:05,490 --> 00:14:07,370
essas outras coisas para
definição de um aluno,

343
00:14:07,370 --> 00:14:11,810
agora está envolto sucintamente up
apenas como um conjunto de alunos.

344
00:14:11,810 --> 00:14:15,500
>> E cada um desses estudantes agora
tem várias coisas dentro dela.

345
00:14:15,500 --> 00:14:16,930
Assim que deixa apenas uma pergunta.

346
00:14:16,930 --> 00:14:19,700
Como você começa no nome,
ea casa, eo ID,

347
00:14:19,700 --> 00:14:21,640
e tudo aquilo que é
dentro do aluno?

348
00:14:21,640 --> 00:14:22,930
Super simples, também.

349
00:14:22,930 --> 00:14:25,730
Nova sintaxe, mas uma idéia simples.

350
00:14:25,730 --> 00:14:29,239
>> Você simplesmente índice para a matriz,
como fizemos na semana passada e esta.

351
00:14:29,239 --> 00:14:31,030
E o que é claramente o
nova peça de sintaxe?

352
00:14:31,030 --> 00:14:32,590

353
00:14:32,590 --> 00:14:35,880
Just., Que significa "ir para dentro do
estrutura e se o campo chamado

354
00:14:35,880 --> 00:14:39,030
nome, obter o campo chamado casa,
obter o campo chamado de estudante. "

355
00:14:39,030 --> 00:14:41,940
>> Então, em P Conjunto Três, se você estiver
ainda trabalhando nisso,

356
00:14:41,940 --> 00:14:44,020
ea maioria das pessoas ainda
são, percebo que, como você

357
00:14:44,020 --> 00:14:46,130
começar a usar coisas como
rects G e G ovais

358
00:14:46,130 --> 00:14:50,201
e outras coisas que não parecem
vêm de Semana Zero, um, ou dois,

359
00:14:50,201 --> 00:14:52,950
perceber que isso é porque Stanford
declarou alguns novos tipos de dados.

360
00:14:52,950 --> 00:14:56,160
>> E, de fato, isso é exatamente o que vamos
fazer, assim, em P Set Four, quando

361
00:14:56,160 --> 00:14:59,880
começamos a lidar com as coisas
como imagens, bitmaps, e muito mais.

362
00:14:59,880 --> 00:15:02,882
Então, isso é apenas um teaser e um
modelo mental para o que está por vir.

363
00:15:02,882 --> 00:15:04,590
Agora, eu procrastinado
um pouco esta manhã.

364
00:15:04,590 --> 00:15:09,560
Eu era uma espécie de curiosidade para ver o que
o papel de parede Microsoft realmente

365
00:15:09,560 --> 00:15:10,310
parece hoje.

366
00:15:10,310 --> 00:15:15,200
E acontece que alguém em 2006
realmente foi para quase precisamente

367
00:15:15,200 --> 00:15:19,210
o mesmo local para fotografar na realidade
o que parece que nos dias de hoje.

368
00:15:19,210 --> 00:15:21,380
O campo está agora coberto um pouco.

369
00:15:21,380 --> 00:15:24,850
>> Então, falando agora de imagens,
Vamos trazer de volta Daven aqui

370
00:15:24,850 --> 00:15:26,890
na tela e Nicholas,
e apenas lembrá-lo

371
00:15:26,890 --> 00:15:30,540
que se você quiser se juntar a nós para o almoço
nesta sexta-feira, de cabeça para o nosso URL habitual

372
00:15:30,540 --> 00:15:31,440
Aqui.

373
00:15:31,440 --> 00:15:33,530
>> Então, de onde paramos na segunda-feira?

374
00:15:33,530 --> 00:15:35,140
Nós introduzimos este problema, certo?

375
00:15:35,140 --> 00:15:37,610
Esta foi aparentemente a correta
implementação de swap,

376
00:15:37,610 --> 00:15:40,460
em que você tomar dois inteiros,
um chamado, um chamado b,

377
00:15:40,460 --> 00:15:44,130
trocá-los, assim como Laura fez aqui
no palco com o leite ea água,

378
00:15:44,130 --> 00:15:46,820
usando um temporária
variável, ou um copo vazio,

379
00:15:46,820 --> 00:15:50,540
para que pudéssemos colocar em um b e um em
b sem fazer uma bagunça de coisas.

380
00:15:50,540 --> 00:15:51,560
Nós usamos uma variável.

381
00:15:51,560 --> 00:15:52,870
É chamado de temperatura.

382
00:15:52,870 --> 00:15:55,520
>> Mas o que era fundamental
problema com este código na segunda-feira?

383
00:15:55,520 --> 00:15:57,700

384
00:15:57,700 --> 00:15:58,870
Qual foi o problema aqui?

385
00:15:58,870 --> 00:16:00,106

386
00:16:00,106 --> 00:16:00,605
Sim.

387
00:16:00,605 --> 00:16:01,970
>> AUDIÊNCIA: É preciso mais espaço.

388
00:16:01,970 --> 00:16:04,719
>> DAVID J. MALAN: Leva-se mais
espaço, porque eu estou usando uma variável,

389
00:16:04,719 --> 00:16:05,400
e isso é OK.

390
00:16:05,400 --> 00:16:07,300
Isso é verdade, mas eu sou
vai dizer que está tudo bem.

391
00:16:07,300 --> 00:16:10,030
É apenas 32 bits na grande
esquema das coisas, então não é um grande negócio.

392
00:16:10,030 --> 00:16:10,655
Outros pensamentos?

393
00:16:10,655 --> 00:16:12,572
AUDIÊNCIA: só troca
as variáveis ​​localmente.

394
00:16:12,572 --> 00:16:13,571
DAVID J. MALAN: Exatamente.

395
00:16:13,571 --> 00:16:15,090
É apenas troca os variáveis ​​localmente.

396
00:16:15,090 --> 00:16:18,173
Porque sempre que você chamar um function--
quando eu tinha as bandejas a partir Annenberg

397
00:16:18,173 --> 00:16:19,840
última vez, você tem principal na parte inferior.

398
00:16:19,840 --> 00:16:23,560
Assim que você chamar uma função chamada
swap, swap de não obter x e y,

399
00:16:23,560 --> 00:16:24,400
os valores originais.

400
00:16:24,400 --> 00:16:26,392
O que faz troca get, que nós reivindicamos?

401
00:16:26,392 --> 00:16:27,100
Audiência: Cópias.

402
00:16:27,100 --> 00:16:28,090
DAVID J. MALAN: Então cópias deles.

403
00:16:28,090 --> 00:16:31,120
Assim, torna-se um e dois, se você
recordar o exemplo da última vez,

404
00:16:31,120 --> 00:16:34,730
mas uma cópia de um e dois
que são trocados com sucesso.

405
00:16:34,730 --> 00:16:38,550
Mas, infelizmente, no final,
esses valores ainda são os mesmos.

406
00:16:38,550 --> 00:16:41,880
Assim, podemos ver isso com a nossa
novo amigo, espero que GDB,

407
00:16:41,880 --> 00:16:45,180
que você ou os TFs e Ca de ter
foi guiando-o para a seguinte.

408
00:16:45,180 --> 00:16:51,210
>> Portanto, não há recordação de swap parece como-- vamos
abrir isso-- esta aparência.

409
00:16:51,210 --> 00:16:54,160
Nós inicializado x para um y a dois.

410
00:16:54,160 --> 00:16:55,620
Tinha um monte de impressão de f.

411
00:16:55,620 --> 00:16:58,080
Mas, em seguida, a tecla de chamada
aqui era para trocar, o que

412
00:16:58,080 --> 00:17:00,260
é exatamente o que o código
só vi um momento atrás.

413
00:17:00,260 --> 00:17:03,180
O que é correto em primeiro
vista, mas funcionalmente,

414
00:17:03,180 --> 00:17:06,800
este programa não funciona, porque
não trocar permanentemente x e y.

415
00:17:06,800 --> 00:17:10,190
>> Então vamos ver isso, um ambiente aconchegante rápida
aqui com GDB, um ./noswap.

416
00:17:10,190 --> 00:17:11,867

417
00:17:11,867 --> 00:17:15,200
Um monte de informações contundentes de que
Vou me livrar de L com controle por enquanto.

418
00:17:15,200 --> 00:17:17,516
E agora, eu vou
vá em frente e execute-o.

419
00:17:17,516 --> 00:17:19,349
E, infelizmente, que
não era tão útil.

420
00:17:19,349 --> 00:17:22,355
Ele executou o programa dentro deste
programa chamado GDB, um depurador,

421
00:17:22,355 --> 00:17:23,730
mas não deixe-me bisbilhotar.

422
00:17:23,730 --> 00:17:26,229
>> Então, como eu posso realmente fazer uma pausa
execução dentro deste programa?

423
00:17:26,229 --> 00:17:27,410

424
00:17:27,410 --> 00:17:28,329
Então quebrar.

425
00:17:28,329 --> 00:17:32,340
E eu poderia quebrar em qualquer
linha número, um, 10, 15.

426
00:17:32,340 --> 00:17:35,530
Mas também posso quebrar simbolicamente
dizendo quebra principal.

427
00:17:35,530 --> 00:17:38,980
E que vai definir um intervalo
ponto, aparentemente na linha 16 na principal.

428
00:17:38,980 --> 00:17:40,050
E onde está a linha 16?

429
00:17:40,050 --> 00:17:42,960
Vamos subir para o código
e vão até noswap.

430
00:17:42,960 --> 00:17:46,930
E, de fato, a linha 16 é o
primeiro no programa.

431
00:17:46,930 --> 00:17:52,130
>> Então, agora, se eu ir em frente e tipo
executar este tempo, Enter, ele fez uma pausa.

432
00:17:52,130 --> 00:17:53,080
Então, vamos bisbilhotar.

433
00:17:53,080 --> 00:17:55,716
Imprimir x-- por que é x Zero?

434
00:17:55,716 --> 00:17:56,705

435
00:17:56,705 --> 00:17:57,830
E ignorar o sinal de dólar.

436
00:17:57,830 --> 00:17:59,725
Isso é apenas para columbófilo
utilização do programa.

437
00:17:59,725 --> 00:18:00,780

438
00:18:00,780 --> 00:18:03,140
Por que é x zero no momento?

439
00:18:03,140 --> 00:18:03,640
Sim.

440
00:18:03,640 --> 00:18:07,061
>> AUDIÊNCIA: Ele fez uma pausa antes de direita
linha 16, não, na verdade, na linha 16.

441
00:18:07,061 --> 00:18:08,060
DAVID J. MALAN: Exatamente.

442
00:18:08,060 --> 00:18:11,630
GDB, por padrão, tem uma pausa
execução um pouco antes da linha 16.

443
00:18:11,630 --> 00:18:14,820
Por isso, não foi executado, o que
significa que x é de algum valor desconhecido.

444
00:18:14,820 --> 00:18:17,150
E nós temos sorte de que é
algo limpo como zero.

445
00:18:17,150 --> 00:18:20,310
Portanto, agora se eu digito seguinte,
agora é executado 16.

446
00:18:20,310 --> 00:18:22,000
Ele está esperando por mim para executar 17.

447
00:18:22,000 --> 00:18:23,400
Deixe-me ir em frente e impressão x.

448
00:18:23,400 --> 00:18:24,094
É uma.

449
00:18:24,094 --> 00:18:25,260
Deixe-me ir em frente e impressão y.

450
00:18:25,260 --> 00:18:26,176
O que eu deveria ver agora?

451
00:18:26,176 --> 00:18:27,660

452
00:18:27,660 --> 00:18:28,560
>> AUDIÊNCIA: [inaudível]

453
00:18:28,560 --> 00:18:29,165
>> DAVID J. MALAN: Um pouco mais alto.

454
00:18:29,165 --> 00:18:30,040
>> AUDIÊNCIA: [inaudível]

455
00:18:30,040 --> 00:18:30,537

456
00:18:30,537 --> 00:18:32,120
DAVID J. MALAN: Não é bem um consenso.

457
00:18:32,120 --> 00:18:34,760
Então, sim, nós vemos algum valor de lixo.

458
00:18:34,760 --> 00:18:37,862
Agora, y é 134514064 lá.

459
00:18:37,862 --> 00:18:39,320
Bem, isso é só um valor de lixo.

460
00:18:39,320 --> 00:18:41,350
Meu programa usa RAM
para fins diferentes.

461
00:18:41,350 --> 00:18:42,350
Há outras funções.

462
00:18:42,350 --> 00:18:44,040
Outras pessoas escreveram no meu computador.

463
00:18:44,040 --> 00:18:46,789
Então, os bits tenham sido utilizados para
outros valores, eo que eu estou vendo

464
00:18:46,789 --> 00:18:49,470
representa os restos de alguns
uso prévio de que a memória.

465
00:18:49,470 --> 00:18:53,350
>> Portanto, não é grande coisa, porque assim
enquanto eu digito seguinte e, em seguida, imprimir y,

466
00:18:53,350 --> 00:18:55,640
é inicializado para
o valor que eu quero.

467
00:18:55,640 --> 00:18:57,400
Então, agora, vamos em frente um pouco mais rápido.

468
00:18:57,400 --> 00:18:58,540
N para o próximo.

469
00:18:58,540 --> 00:18:59,570
Vamos fazer isso de novo.

470
00:18:59,570 --> 00:19:00,530
Vamos fazer isso de novo.

471
00:19:00,530 --> 00:19:02,404
Mas eu não quero bater
lo aqui, porque se eu

472
00:19:02,404 --> 00:19:05,110
quero ver o que está acontecendo dentro
de swap, que é o comando?

473
00:19:05,110 --> 00:19:05,520
>> AUDIÊNCIA: passos.

474
00:19:05,520 --> 00:19:06,436
>> DAVID J. MALAN: passos.

475
00:19:06,436 --> 00:19:09,800
Então isso me pisa em um
função, em vez de por cima.

476
00:19:09,800 --> 00:19:12,270
E agora, é um pouco enigmática
honestamente, mas este é apenas

477
00:19:12,270 --> 00:19:14,581
me dizendo que eu estou na linha 33 agora.

478
00:19:14,581 --> 00:19:15,580
E vamos fazer isso de novo.

479
00:19:15,580 --> 00:19:16,080
Temperatura de impressão.

480
00:19:16,080 --> 00:19:17,129

481
00:19:17,129 --> 00:19:20,170
Valor de lixo, negativo, desta vez,
mas isso é só ainda um valor de lixo.

482
00:19:20,170 --> 00:19:22,810
Então, vamos fazer a seguir, temp impressão.

483
00:19:22,810 --> 00:19:27,130
Ele é inicializado a 1, o que
foi o valor de x, aka a.

484
00:19:27,130 --> 00:19:29,110
>> Agora, onde está o nosso A e X está vindo?

485
00:19:29,110 --> 00:19:32,510
Bem, aviso no principal, que
chamou esses valores x e y.

486
00:19:32,510 --> 00:19:34,740
Em seguida, passou-os para trocar como se segue.

487
00:19:34,740 --> 00:19:37,010
X veio primeiro, vírgula y.

488
00:19:37,010 --> 00:19:40,020
E, em seguida, troca poderia chamá-los de x e y.

489
00:19:40,020 --> 00:19:42,630
Mas, para clarificar, é
chamando-a e b.

490
00:19:42,630 --> 00:19:45,970
Mas a e b estão agora vai ser
cópias de x e y, respectivamente.

491
00:19:45,970 --> 00:19:50,660
>> Então, se eu voltar para o GDB, temp
é agora um e é agora um.

492
00:19:50,660 --> 00:19:56,130
Mas, se eu faço agora e agora fazer print
um, um já foi movido mais.

493
00:19:56,130 --> 00:20:00,030
O leite foi derramado em ex-
copo de suco de laranja, ou vice-versa.

494
00:20:00,030 --> 00:20:04,750
>> E se eu faço agora novamente, e agora
se eu imprimir como uma verificação de sanidade,

495
00:20:04,750 --> 00:20:07,687
é ainda um dois, mas é agora uma b.

496
00:20:07,687 --> 00:20:08,770
Francamente, ele ainda está lá.

497
00:20:08,770 --> 00:20:10,670
Eu não me importo o que é temporário.

498
00:20:10,670 --> 00:20:16,850
Mas assim que eu agora escrever, digamos,
continuar a voltar, agora estou no final

499
00:20:16,850 --> 00:20:17,480
o programa.

500
00:20:17,480 --> 00:20:20,730
E, infelizmente, x é
ainda um e y é ainda dois.

501
00:20:20,730 --> 00:20:22,272
>> Então, qual foi a utilidade do GDB lá?

502
00:20:22,272 --> 00:20:23,980
Ele não me ajudar a corrigir
o problema por si só,

503
00:20:23,980 --> 00:20:26,265
mas espero que me ajude
compreendê-lo através da realização

504
00:20:26,265 --> 00:20:30,000
que sim, a minha lógica é certo, mas
meu código não é, em última análise ter

505
00:20:30,000 --> 00:20:31,450
um impacto permanente.

506
00:20:31,450 --> 00:20:34,570
Então, isso é um problema que estamos
vai agora resolver hoje.

507
00:20:34,570 --> 00:20:37,870
>> Mas vamos chegar lá por meio deste.

508
00:20:37,870 --> 00:20:39,230
String é uma mentira.

509
00:20:39,230 --> 00:20:41,860
É, também, não é um tipo de dados
que existe em C. É

510
00:20:41,860 --> 00:20:44,750
sido um sinônimo para alguns
tempo para outra coisa,

511
00:20:44,750 --> 00:20:47,300
e que pode revelar que, como se segue.

512
00:20:47,300 --> 00:20:53,282
>> Deixe-me ir em frente e abrir
Um programa chamado comparar-0.

513
00:20:53,282 --> 00:20:56,240
E ao invés de digitar essa modalidade,
vamos começar a percorrer o código

514
00:20:56,240 --> 00:20:58,040
Eu já escrevi, mas
é apenas algumas linhas.

515
00:20:58,040 --> 00:20:59,570
Portanto, este é comparar-0.

516
00:20:59,570 --> 00:21:02,380
E a primeira coisa que eu estou fazendo
está recebendo uma linha de texto.

517
00:21:02,380 --> 00:21:05,610
>> Mas note o que eu sou
fazendo para a primeira vez.

518
00:21:05,610 --> 00:21:07,910
O que é diferente claramente sobre a linha 21?

519
00:21:07,910 --> 00:21:10,020

520
00:21:10,020 --> 00:21:11,402
Na verdade, espere um minuto.

521
00:21:11,402 --> 00:21:12,110
Esta é cópia dois.

522
00:21:12,110 --> 00:21:13,568
Isso não é nem mesmo o programa certo.

523
00:21:13,568 --> 00:21:14,780
Tudo alerta direita, saqueador.

524
00:21:14,780 --> 00:21:16,890
Tudo bem, então não importa.

525
00:21:16,890 --> 00:21:18,520
Essa é a resposta a uma pergunta futuro.

526
00:21:18,520 --> 00:21:21,450
>> Aqui é comparar-0, e eu sou
prestes a receber uma linha de texto.

527
00:21:21,450 --> 00:21:22,435
Programa de muito mais simples.

528
00:21:22,435 --> 00:21:23,560
Então, isso é simples.

529
00:21:23,560 --> 00:21:28,070
Isto é como Week One, Two Week coisas
no momento. string s = GetString.

530
00:21:28,070 --> 00:21:29,700
Agora, eu digo novamente aqui.

531
00:21:29,700 --> 00:21:31,830
corda t = GetString.

532
00:21:31,830 --> 00:21:35,300
E, em seguida, a última coisa neste
programa, como o próprio nome sugere,

533
00:21:35,300 --> 00:21:37,090
é que eu vou tentar compará-los.

534
00:21:37,090 --> 00:21:40,709
>> Então, se s, a primeira corda,
é igual a = t, então eu sou

535
00:21:40,709 --> 00:21:42,250
vai dizer que você digite a mesma coisa.

536
00:21:42,250 --> 00:21:44,291
Senão, eu vou dizer
você digita coisas diferentes.

537
00:21:44,291 --> 00:21:45,880
Então, vamos compilar e executar este programa.

538
00:21:45,880 --> 00:21:48,481
Então faça comparar zero.

539
00:21:48,481 --> 00:21:48,980
Parece bom.

540
00:21:48,980 --> 00:21:50,490
Não há erros de compilação.

541
00:21:50,490 --> 00:21:52,386
>> Deixe-me ir em frente agora
e digite ./compare-0.

542
00:21:52,386 --> 00:21:55,230

543
00:21:55,230 --> 00:21:59,220
Deixe-me ir em frente e dizer alguma coisa
: Daven e algo: Rob.

544
00:21:59,220 --> 00:22:00,450
E eu escreva coisas diferentes.

545
00:22:00,450 --> 00:22:01,250
Por enquanto, tudo bem.

546
00:22:01,250 --> 00:22:02,680
Programa parece ser correto.

547
00:22:02,680 --> 00:22:03,880
>> Mas vamos executá-lo novamente.

548
00:22:03,880 --> 00:22:05,800
Diga alguma coisa: Gabe.

549
00:22:05,800 --> 00:22:07,140
Diga alguma coisa: Gabe.

550
00:22:07,140 --> 00:22:08,520

551
00:22:08,520 --> 00:22:09,020
Tudo certo.

552
00:22:09,020 --> 00:22:10,851
Talvez eu bater a barra de espaço
ou algo funky.

553
00:22:10,851 --> 00:22:11,600
Vamos fazer isso de novo.

554
00:22:11,600 --> 00:22:13,020
Então Zamyla.

555
00:22:13,020 --> 00:22:13,970

556
00:22:13,970 --> 00:22:14,470
Zamyla.

557
00:22:14,470 --> 00:22:15,740

558
00:22:15,740 --> 00:22:17,330
Coisas diferentes.

559
00:22:17,330 --> 00:22:19,430
Então, o que está acontecendo?

560
00:22:19,430 --> 00:22:23,200
>> Portanto, temos estas duas linhas de
código, GetString ser chamado duas vezes.

561
00:22:23,200 --> 00:22:25,760
E então, eu sou simplesmente
tentar comparar s e t.

562
00:22:25,760 --> 00:22:28,370
Mas o que realmente está acontecendo, então?

563
00:22:28,370 --> 00:22:31,180
Bem, sobre o meu manuscrito para
açougueiro este exemplo um pouco.

564
00:22:31,180 --> 00:22:34,630
E vamos realmente jogar
isso aqui, também.

565
00:22:34,630 --> 00:22:37,390

566
00:22:37,390 --> 00:22:45,712
>> Portanto, temos uma linha como
string s = GetString.

567
00:22:45,712 --> 00:22:48,295
Então, isso é simplesmente o primeiro
linha interessante desse programa.

568
00:22:48,295 --> 00:22:49,920

569
00:22:49,920 --> 00:22:52,974
Mas o que todo esse tempo tem sido
acontecendo debaixo do capô?

570
00:22:52,974 --> 00:22:55,890
Bem, sobre a mão esquerda lado é cadeia,
que é algum tipo de variável,

571
00:22:55,890 --> 00:22:56,785
e chama-se s.

572
00:22:56,785 --> 00:23:00,019
Então, eu sei que isso é usando a memória,
ou RAM, no meu computador de alguma forma.

573
00:23:00,019 --> 00:23:02,060
Então eu vou abstratamente
chamar isso como um quadrado.

574
00:23:02,060 --> 00:23:04,820
32 bits, verifica-se, mas
mais sobre isso no futuro.

575
00:23:04,820 --> 00:23:06,410
E então, o que está acontecendo aqui?

576
00:23:06,410 --> 00:23:08,700
>> Bem, obviamente GetString
recebe uma string do usuário.

577
00:23:08,700 --> 00:23:11,360
E tem GetString
Zamyla ou Gabe ou Daven.

578
00:23:11,360 --> 00:23:14,640
Então, vamos escolher a primeira
daqueles, que foi Daven.

579
00:23:14,640 --> 00:23:19,174
Então, efetivamente, o que GetString tem
me nesse primeiro caso foi D-a-v-e-n.

580
00:23:19,174 --> 00:23:22,690

581
00:23:22,690 --> 00:23:25,045
E então, o que mais fez
ele me dar secretamente?

582
00:23:25,045 --> 00:23:25,920
AUDIÊNCIA: [inaudível]

583
00:23:25,920 --> 00:23:28,720
DAVID J. MALAN: Sim,
o / 0 ou nulo personagem.

584
00:23:28,720 --> 00:23:30,550
Por isso, efetivamente me deu uma string.

585
00:23:30,550 --> 00:23:34,550
Mas nós já sabemos a partir de anterior
Parece que uma string é apenas uma matriz

586
00:23:34,550 --> 00:23:37,895
de personagens, e é denunciado por
este caráter especial sentinela, / 0.

587
00:23:37,895 --> 00:23:39,220

588
00:23:39,220 --> 00:23:42,310
>> Mas se isso é verdade
e isto é um quadrado,

589
00:23:42,310 --> 00:23:44,160
este é claramente um retângulo muito maior.

590
00:23:44,160 --> 00:23:46,830
E, de fato, este é,
Eu afirmo, apenas 32 bits.

591
00:23:46,830 --> 00:23:49,500
E isto é claramente mais do que 32
bits, porque este é, provavelmente,

592
00:23:49,500 --> 00:23:51,583
oito mais oito mais oito
mais oito mais oito,

593
00:23:51,583 --> 00:23:53,320
só por causa de bytes em ASCII.

594
00:23:53,320 --> 00:23:57,030
Como o diabo é que vamos caber
Daven nessa caixinha aqui?

595
00:23:57,030 --> 00:23:59,880
>> Bem, o que está realmente fazendo GetString?

596
00:23:59,880 --> 00:24:03,680
Bem, essa grade representa aqui
memória do meu computador ou RAM.

597
00:24:03,680 --> 00:24:07,564
Então vamos arbitrariamente dizer que se
cada um deles representa um byte,

598
00:24:07,564 --> 00:24:09,730
então podemos pensar em cada
byte como tendo um endereço,

599
00:24:09,730 --> 00:24:13,830
como 33 Oxford Street, ou 34
Oxford Street, ou 35 Oxford Street.

600
00:24:13,830 --> 00:24:16,700
>> Assim como as casas têm endereços
e os edifícios têm endereços,

601
00:24:16,700 --> 00:24:19,810
assim como de bytes individuais
memória têm endereços ou números

602
00:24:19,810 --> 00:24:21,042
que identificá-las unicamente.

603
00:24:21,042 --> 00:24:22,000
Agora, este é arbitrária.

604
00:24:22,000 --> 00:24:25,370
Mas mantê-lo simples, eu vou
usar hexadecimal apenas por convenção,

605
00:24:25,370 --> 00:24:28,200
mas o 0x não significa outra coisa
que "este é hexadecimal."

606
00:24:28,200 --> 00:24:31,030
e eu vou afirmar que a
"D" acaba em Byte One na memória.

607
00:24:31,030 --> 00:24:34,210
>> Eu não tenho nada mais acontecendo no
memória, assim Daven conseguiu o primeiro lugar

608
00:24:34,210 --> 00:24:35,509
Um byte no.

609
00:24:35,509 --> 00:24:36,800
Este, então, vai ser 0x2.

610
00:24:36,800 --> 00:24:37,831

611
00:24:37,831 --> 00:24:38,705
Isso vai 0x3.

612
00:24:38,705 --> 00:24:39,840

613
00:24:39,840 --> 00:24:41,800
Este vai ser 0x4.

614
00:24:41,800 --> 00:24:43,025
Isso vai 0x5.

615
00:24:43,025 --> 00:24:44,025
Este vai ser 0x6.

616
00:24:44,025 --> 00:24:45,560

617
00:24:45,560 --> 00:24:48,290
>> Mas uma vez que você começar a pensar
sobre o que procede do computador

618
00:24:48,290 --> 00:24:50,710
debaixo do capô,
você pode começar a inferir

619
00:24:50,710 --> 00:24:54,960
como você, há alguns anos, seria
Implementamos C em si.

620
00:24:54,960 --> 00:24:58,360
O que é provavelmente GetString
returning-- porque

621
00:24:58,360 --> 00:25:00,946
Parece que não é
retornando Daven, por si só,

622
00:25:00,946 --> 00:25:03,320
porque ele certamente não vai
para caber neste pequeno box--

623
00:25:03,320 --> 00:25:05,090
então o que é GetString provavelmente retornando?

624
00:25:05,090 --> 00:25:07,958

625
00:25:07,958 --> 00:25:08,920
>> AUDIÊNCIA: [inaudível]

626
00:25:08,920 --> 00:25:10,540
>> DAVID J. MALAN: O local de Daven.

627
00:25:10,540 --> 00:25:12,770
E ele vem fazendo isso
desde Primeira Semana.

628
00:25:12,770 --> 00:25:16,150
O que é realmente GetString
retornando não é uma string, per se.

629
00:25:16,150 --> 00:25:17,780
Essa é uma das mentirinhas.

630
00:25:17,780 --> 00:25:22,520
É retornar o endereço do
cadeia na memória, o endereço único.

631
00:25:22,520 --> 00:25:24,820
Daven vive a 33 Oxford Street.

632
00:25:24,820 --> 00:25:29,310
Mas de forma mais sucinta, Gavin vive
em 0x1, Address Number One.

633
00:25:29,310 --> 00:25:32,280
>> Então, o que é colocado neste
pequena caixa, em seguida, para ser claro,

634
00:25:32,280 --> 00:25:35,930
é apenas o endereço dessa string.

635
00:25:35,930 --> 00:25:38,110
Então todo esse tempo, este
vem acontecendo.

636
00:25:38,110 --> 00:25:41,650
Mas o que isso sugere
agora é que se todo s tem

637
00:25:41,650 --> 00:25:44,710
é um número dentro do mesmo, que é
para impedi-lo, o programador,

638
00:25:44,710 --> 00:25:47,970
de colocar qualquer número em
qualquer variável e apenas pulando

639
00:25:47,970 --> 00:25:49,080
para que pedaço de memória?

640
00:25:49,080 --> 00:25:51,320
E, de fato, vamos ver
isso é uma ameaça próxima vez.

641
00:25:51,320 --> 00:25:53,500
>> Mas, por enquanto, isso parece insuficiente.

642
00:25:53,500 --> 00:25:55,630
Se eu disser, arranja-me um
string, você me dar Daven.

643
00:25:55,630 --> 00:25:57,230
Mas você realmente não me dar Daven.

644
00:25:57,230 --> 00:25:59,310
Tudo o que você me dá é o endereço de Daven.

645
00:25:59,310 --> 00:26:04,310
Como posso então saber ao certo
Daven onde começa e ends--

646
00:26:04,310 --> 00:26:07,140
a história está ficando weird--
Daven onde começa e termina,

647
00:26:07,140 --> 00:26:10,435
e, em seguida, o próximo
seqüência na memória começa?

648
00:26:10,435 --> 00:26:11,520

649
00:26:11,520 --> 00:26:13,620
>> Bem, se você está entregando
me o início de Daven,

650
00:26:13,620 --> 00:26:17,230
essencialmente, como eu sei
onde o fim do seu nome é?

651
00:26:17,230 --> 00:26:20,550
Esse personagem nulo especial, que
é ainda mais importante agora

652
00:26:20,550 --> 00:26:23,040
se cordas debaixo do
capô são simplesmente identificados

653
00:26:23,040 --> 00:26:25,820
exclusivamente pela sua localização na memória.

654
00:26:25,820 --> 00:26:28,130
Então todo esse tempo, que é
o que está acontecendo.

655
00:26:28,130 --> 00:26:32,470
>> Assim, quando olhamos agora em
o código aqui, explicar

656
00:26:32,470 --> 00:26:35,790
se você faria o bug na linha 26.

657
00:26:35,790 --> 00:26:39,560
Por que é Zamyla e Zamyla diferente?

658
00:26:39,560 --> 00:26:41,330
Porque é que Gabe e Gabe diferente?

659
00:26:41,330 --> 00:26:42,154
Sim, na parte de trás.

660
00:26:42,154 --> 00:26:43,390
>> AUDIÊNCIA: Eles têm endereços diferentes.

661
00:26:43,390 --> 00:26:45,931
>> DAVID J. MALAN: Simplesmente porque
eles têm endereços diferentes.

662
00:26:45,931 --> 00:26:48,820
Porque quando você chamar GetString
novamente, o que eu vou fazer rapidamente aqui,

663
00:26:48,820 --> 00:26:52,870
se esta é a segunda linha, cadeia
t, como eu fiz nesse programa,

664
00:26:52,870 --> 00:26:55,030
é igual a outra chamada para GetString.

665
00:26:55,030 --> 00:26:56,370

666
00:26:56,370 --> 00:26:58,670
A próxima vez que eu chamo
GetString, eu vou

667
00:26:58,670 --> 00:27:00,190
para obter um pedaço diferente de memória.

668
00:27:00,190 --> 00:27:02,220
>> GetString é permitido
pedir ao funcionamento

669
00:27:02,220 --> 00:27:03,800
sistema para obter mais e mais memória.

670
00:27:03,800 --> 00:27:07,894
Não vai reutilizar a mesma
seis bytes cada vez.

671
00:27:07,894 --> 00:27:09,810
Vai começar um novo
pedaço de memória, o que

672
00:27:09,810 --> 00:27:12,780
significa t vai ficar
algum outro valor aqui.

673
00:27:12,780 --> 00:27:15,380
>> Então, quando eu faço s é igual a =
t, você não está comparando

674
00:27:15,380 --> 00:27:17,880
D contra este e contra A
este e V contra este.

675
00:27:17,880 --> 00:27:19,588
Você está comparando este
contra este, o qual

676
00:27:19,588 --> 00:27:24,020
francamente é muito useless-- useful--
é inútil, porque quem realmente

677
00:27:24,020 --> 00:27:25,830
importa onde as cordas estão na memória?

678
00:27:25,830 --> 00:27:26,850
>> E, de fato, nós não temos.

679
00:27:26,850 --> 00:27:28,980
E nós não vamos
iniciar particularmente carinhoso.

680
00:27:28,980 --> 00:27:34,180
Só na medida em que os erros podem surgir
e as ameaças à segurança podem surgir vontade

681
00:27:34,180 --> 00:27:36,100
nós realmente começar a se preocupar com isso.

682
00:27:36,100 --> 00:27:37,230
Então vamos corrigir esse problema.

683
00:27:37,230 --> 00:27:39,650
Acontece que, de corrigir-lo super simples.

684
00:27:39,650 --> 00:27:42,600
>> E vamos de fato, antes de eu
revelam que mais uma vez, o que seria

685
00:27:42,600 --> 00:27:47,170
você faria se em uma classe CS50,
e você teve que implementar

686
00:27:47,170 --> 00:27:48,600
uma comparação com duas cordas.

687
00:27:48,600 --> 00:27:51,440
Você claramente não pode apenas usar s é igual a = t.

688
00:27:51,440 --> 00:27:54,090
Mas, logicamente, como
Como você comparar esta cadeia

689
00:27:54,090 --> 00:27:56,370
contra essa string usando o código C?

690
00:27:56,370 --> 00:27:56,880
Sim.

691
00:27:56,880 --> 00:27:58,780
>> AUDIÊNCIA: Basta fazer o
loop [inaudível]

692
00:27:58,780 --> 00:28:00,670

693
00:28:00,670 --> 00:28:01,670
DAVID J. MALAN: Perfeito.

694
00:28:01,670 --> 00:28:02,900
AUDIÊNCIA: [inaudível]

695
00:28:02,900 --> 00:28:03,310
DAVID J. MALAN: Yeah.

696
00:28:03,310 --> 00:28:05,390
Basta usar um loop ou um
while ou o que quer.

697
00:28:05,390 --> 00:28:08,710
Mas basta aplicar a idéia básica de que, se
este é um pedaço de memória ou um array

698
00:28:08,710 --> 00:28:11,590
e este é, iterar
os dois ao mesmo tempo.

699
00:28:11,590 --> 00:28:12,960
E basta comparar as letras.

700
00:28:12,960 --> 00:28:14,260
>> E você tem de ser um
pouco cuidado, porque você

701
00:28:14,260 --> 00:28:16,247
Não quero um dedo
para passar a outra

702
00:28:16,247 --> 00:28:18,080
porque uma string é
mais do que o outro.

703
00:28:18,080 --> 00:28:21,380
Então você vai querer verificar para
este valor especial no final, nulo.

704
00:28:21,380 --> 00:28:24,017
Mas ele realmente é, na
final, tão simples como isso.

705
00:28:24,017 --> 00:28:26,100
E, francamente, nós não precisamos
reinventar a roda.

706
00:28:26,100 --> 00:28:27,960
Aqui é versão dois.

707
00:28:27,960 --> 00:28:32,910
E o que eu vou dizer aqui é que
em vez de comparar s é igual a = t,

708
00:28:32,910 --> 00:28:38,964
Estou vez vai dizer, se a cadeia
comparação de s vírgula t é igual a = 0.

709
00:28:38,964 --> 00:28:40,130
Agora, o que é String de comparação?

710
00:28:40,130 --> 00:28:43,046
>> Acontece, é uma função que
vem com C, cujo propósito na vida

711
00:28:43,046 --> 00:28:44,650
é comparar duas strings.

712
00:28:44,650 --> 00:28:48,300
E mexa comparar, se lermos a sua
página ou documentação ou CS50 homem

713
00:28:48,300 --> 00:28:50,630
referência, será
simplesmente dizer-lhe que mexa

714
00:28:50,630 --> 00:28:55,730
comparar retorna um negativas
número ou um número positivo ou zero,

715
00:28:55,730 --> 00:28:57,660
em que zero significa que eles são iguais.

716
00:28:57,660 --> 00:28:58,570
>> Portanto, apenas conjecturas.

717
00:28:58,570 --> 00:29:00,390
O que isso pode significar se
agitar retornos comparar

718
00:29:00,390 --> 00:29:02,110
valor negativo ou um valor positivo?

719
00:29:02,110 --> 00:29:02,785

720
00:29:02,785 --> 00:29:04,285
AUDIÊNCIA: Maior ou menor que.

721
00:29:04,285 --> 00:29:05,570
DAVID J. MALAN: Sim,
superior ou inferior.

722
00:29:05,570 --> 00:29:08,640
Então, se você quisesse classificar um todo
grupo de cordas em um dictionary--

723
00:29:08,640 --> 00:29:12,975
como nós acabará por baixo do road--
função perfeita para usar potencialmente,

724
00:29:12,975 --> 00:29:15,850
porque ele vai fazer isso
comparação de strings para você, e dizer

725
00:29:15,850 --> 00:29:20,060
você faz um vem antes de b, ou não
b vir antes de uma ordem alfabética.

726
00:29:20,060 --> 00:29:21,490
Nós podemos fazer exatamente isso.

727
00:29:21,490 --> 00:29:23,620
>> E notem que eu fiz um outro
coisa neste exemplo.

728
00:29:23,620 --> 00:29:26,870
O que mais mudou maior
se nesta função principal?

729
00:29:26,870 --> 00:29:28,500

730
00:29:28,500 --> 00:29:29,350
Char *.

731
00:29:29,350 --> 00:29:31,150
E esta é a outra mentira.

732
00:29:31,150 --> 00:29:33,750
Todo esse tempo, quando você tem
escrito corda,

733
00:29:33,750 --> 00:29:38,350
temos sido secretamente reescrever
string como char * para que, na verdade, clang

734
00:29:38,350 --> 00:29:39,270
compreende.

735
00:29:39,270 --> 00:29:42,450
>> Em outras palavras, em CS50.h
e como vamos finalmente ver,

736
00:29:42,450 --> 00:29:45,950
fizemos uma corda sinônimo chamado
isso é a mesma coisa que char *.

737
00:29:45,950 --> 00:29:49,910
E, por enquanto, só sei que o
*, Neste contexto, pelo menos,

738
00:29:49,910 --> 00:29:51,286
significa o endereço.

739
00:29:51,286 --> 00:29:52,210
>> O endereço de quê?

740
00:29:52,210 --> 00:29:56,390
Bem, o fato de que eu disse
char *, e não int * ou float *,

741
00:29:56,390 --> 00:30:00,820
significa que char * é
o endereço de um char.

742
00:30:00,820 --> 00:30:06,770
Então essa caixinha aqui, aka
corda, é realmente do tipo char *,

743
00:30:06,770 --> 00:30:10,490
que é simplesmente uma maneira elegante de dizer,
nessa caixa vai um endereço.

744
00:30:10,490 --> 00:30:12,430
E o que é que o endereço se refere?

745
00:30:12,430 --> 00:30:13,780
Aparentemente, um char.

746
00:30:13,780 --> 00:30:16,410
>> Mas poderíamos absolutamente
tem int * e outras coisas.

747
00:30:16,410 --> 00:30:20,790
Mas, por enquanto, char * é realmente o mais
simples e uma de interesse.

748
00:30:20,790 --> 00:30:23,310
Portanto, este problema vai
a subir, apesar de, outra vez.

749
00:30:23,310 --> 00:30:24,830
>> Suponha que eu abrir este programa.

750
00:30:24,830 --> 00:30:27,670
Vamos ver se agora podemos prever
o que há de errado com este código.

751
00:30:27,670 --> 00:30:31,140
Então, neste programa, copie-0, estou
indo para a frente e novamente chamar

752
00:30:31,140 --> 00:30:34,190
GetString e armazenar o valor em s.

753
00:30:34,190 --> 00:30:38,800
>> E então, por que eu estou fazendo isso,
apenas como um lembrete de semana passado?

754
00:30:38,800 --> 00:30:40,960
Fizemos dizer que GetString
às vezes retorna nulo.

755
00:30:40,960 --> 00:30:42,793
O que significa se
GetString retorna null?

756
00:30:42,793 --> 00:30:45,040

757
00:30:45,040 --> 00:30:46,034
Algo deu errado.

758
00:30:46,034 --> 00:30:48,950
Isso provavelmente significa a seqüência é muito
grande, para fora do computador de memória.

759
00:30:48,950 --> 00:30:51,724
Acontece super, super, super
raramente, mas pode acontecer.

760
00:30:51,724 --> 00:30:53,890
Queremos verificar para ele,
e isso é tudo o que estamos fazendo.

761
00:30:53,890 --> 00:30:57,910
>> Porque nós vamos ver agora, se não o fizer
começar a verificar habitualmente para as coisas

762
00:30:57,910 --> 00:31:00,870
como nulo, que você pode
realmente começar a ir

763
00:31:00,870 --> 00:31:03,106
para endereços na memória que são inválidas.

764
00:31:03,106 --> 00:31:05,980
E você vai começar a induzir
mais e mais falhas de segmentação.

765
00:31:05,980 --> 00:31:08,360
Ou em um Mac ou um PC, apenas
fazendo com que um computador para pendurar

766
00:31:08,360 --> 00:31:10,340
ou um programa de congelamento, potencialmente.

767
00:31:10,340 --> 00:31:14,930
>> Então, agora, eu afirmo na cópia-0.c, que eu
vou copiar essas seqüências por meio

768
00:31:14,930 --> 00:31:15,685
da linha 28.

769
00:31:15,685 --> 00:31:16,850

770
00:31:16,850 --> 00:31:18,750
E então, eu vou
a reivindicação, na parte inferior

771
00:31:18,750 --> 00:31:21,430
aqui que eu vou
para alterar um deles.

772
00:31:21,430 --> 00:31:22,330
>> Então, observe isso.

773
00:31:22,330 --> 00:31:24,370
Vou chamar o nosso velho amigo strlen.

774
00:31:24,370 --> 00:31:28,960
E só explicar em Inglês
o que esta linha 34 está fazendo?

775
00:31:28,960 --> 00:31:32,480
O que faz t suporte 0
representam à esquerda.

776
00:31:32,480 --> 00:31:32,980
Sim.

777
00:31:32,980 --> 00:31:34,339
>> AUDIÊNCIA: primeiro caractere de t?

778
00:31:34,339 --> 00:31:35,880
DAVID J. MALAN: primeiro caractere de t.

779
00:31:35,880 --> 00:31:36,379
É isso aí.

780
00:31:36,379 --> 00:31:40,024
Primeiro caractere de t, eu quero
para atribuir a versão em maiúsculas

781
00:31:40,024 --> 00:31:41,190
do primeiro caractere t.

782
00:31:41,190 --> 00:31:43,200
Portanto, esta é a capitalização
a primeira letra.

783
00:31:43,200 --> 00:31:46,340
E, em seguida, a última coisa que eu faço
neste programa é eu reclamo aqui

784
00:31:46,340 --> 00:31:50,340
o original, é, e aqui está a cópia, t.

785
00:31:50,340 --> 00:31:54,610
>> Mas baseado na história que acabamos de
contou sobre o que realmente são cordas,

786
00:31:54,610 --> 00:31:57,520
o que é realmente 28 linha
fazendo, eo que é

787
00:31:57,520 --> 00:31:59,405
o erro resultante vai
para ser exibida na tela?

788
00:31:59,405 --> 00:32:01,300

789
00:32:01,300 --> 00:32:03,500
>> Então, primeiro, a primeira pergunta, 28.

790
00:32:03,500 --> 00:32:09,040
O que é String t = s realmente fazendo?

791
00:32:09,040 --> 00:32:16,430
Se tivermos na mão esquerda
lado aqui corda t = s;

792
00:32:16,430 --> 00:32:19,400
que me dá uma caixa de
aqui e uma caixa aqui.

793
00:32:19,400 --> 00:32:25,530
E suponha que este endereço é 0x,
vamos dizer, 50, desta vez, de forma arbitrária.

794
00:32:25,530 --> 00:32:28,847
O que significa corda t = s
fazer debaixo do capô?

795
00:32:28,847 --> 00:32:30,340
>> AUDIÊNCIA: [inaudível]

796
00:32:30,340 --> 00:32:34,100
>> David J. MALAN: Armazena a memória
tratar lá, então 0x50 vai lá.

797
00:32:34,100 --> 00:32:37,980
Então, se agora, eu vou para o primeiro
personagem em t e maiúsculas que,

798
00:32:37,980 --> 00:32:39,535
O que estou fazendo de forma eficaz para s?

799
00:32:39,535 --> 00:32:41,300

800
00:32:41,300 --> 00:32:43,450
Eu realmente estou fazendo a mesma coisa, certo?

801
00:32:43,450 --> 00:32:47,680
Porque se Endereço 0x50-- e só, eu
não tem muito espaço na placa aqui,

802
00:32:47,680 --> 00:32:51,750
mas supor que esta é 0x50 até aqui,
em algum lugar na memória do meu computador.

803
00:32:51,750 --> 00:32:55,825
>> E eu, por exemplo, gabe
em minúscula aqui, assim.

804
00:32:55,825 --> 00:32:57,120

805
00:32:57,120 --> 00:33:01,980
E tenho dito suporte t
0 fica maiúscula.

806
00:33:01,980 --> 00:33:04,860
Bem, t suporte 0 é
a primeira letra t.

807
00:33:04,860 --> 00:33:07,840
Tão pouco g vai
tornar-se grande G. Mas o problema

808
00:33:07,840 --> 00:33:09,410
é, o que s também apontam para?

809
00:33:09,410 --> 00:33:10,300
>> AUDIÊNCIA: O mesmo.

810
00:33:10,300 --> 00:33:11,841
>> DAVID J. MALAN: Exatamente a mesma coisa.

811
00:33:11,841 --> 00:33:16,342
Assim, uma explicação simples, talvez,
mesmo que a sintaxe é um pouco estranho.

812
00:33:16,342 --> 00:33:17,050
Então, vamos fazer isso.

813
00:33:17,050 --> 00:33:20,210
Fazer cópia-0 e, em seguida, ./copy-0.

814
00:33:20,210 --> 00:33:21,820

815
00:33:21,820 --> 00:33:24,110
Diga alguma coisa: Gabe.

816
00:33:24,110 --> 00:33:26,760
E, infelizmente, ambos
eles já foram capitalizados,

817
00:33:26,760 --> 00:33:29,500
mas para que, subjacente
razão que estamos simplesmente

818
00:33:29,500 --> 00:33:32,350
agora a lidar com endereços.

819
00:33:32,350 --> 00:33:36,470
>> Então, como vamos começar a
address-- sem trocadilho intended--

820
00:33:36,470 --> 00:33:39,270
como é que vamos começar a resolver
este problema em particular?

821
00:33:39,270 --> 00:33:44,400
Bem, em copy1.c, as coisas vão
a ficar um pouco mais complicado.

822
00:33:44,400 --> 00:33:49,310
Mas eu gostaria de reivindicar uma
solução conceitualmente simples.

823
00:33:49,310 --> 00:33:50,852
>> Tão difícil de chegar à primeira vista.

824
00:33:50,852 --> 00:33:53,560
Não vai ser fácil para o primeiro
vez que você digitá-lo, talvez,

825
00:33:53,560 --> 00:33:57,440
mas se o problema é que
simplesmente fazendo t = s apenas

826
00:33:57,440 --> 00:33:59,694
copia o endereço, o que,
novamente se eu posso pegar em você,

827
00:33:59,694 --> 00:34:02,110
vai ser a solução
para realmente copiar uma string?

828
00:34:02,110 --> 00:34:04,906

829
00:34:04,906 --> 00:34:06,770
>> AUDIÊNCIA: Nós provavelmente
utilizar um ciclo novo.

830
00:34:06,770 --> 00:34:06,890
>> DAVID J. MALAN: Yeah.

831
00:34:06,890 --> 00:34:08,390
Então, nós vamos precisar de um loop novamente.

832
00:34:08,390 --> 00:34:11,800
E porque se deseja copiar
uma string s em outra seqüência,

833
00:34:11,800 --> 00:34:14,120
que provavelmente vai querer fazê-lo
caractere por caractere.

834
00:34:14,120 --> 00:34:17,199
Mas o problema é que, se
este é inicialmente s,

835
00:34:17,199 --> 00:34:22,159
agora precisamos começar explicitamente
alocação de memória para t.

836
00:34:22,159 --> 00:34:24,320
>> Em outras palavras, vamos
redesenhar uma última vez.

837
00:34:24,320 --> 00:34:28,659
Se esta é a string s = GetString.

838
00:34:28,659 --> 00:34:30,956

839
00:34:30,956 --> 00:34:32,455
E vamos colocar isso aqui, também.

840
00:34:32,455 --> 00:34:36,639

841
00:34:36,639 --> 00:34:37,420
Este é GetString.

842
00:34:37,420 --> 00:34:39,070

843
00:34:39,070 --> 00:34:43,860
E, em seguida, a imagem de algo
como que vai ser como antes,

844
00:34:43,860 --> 00:34:44,360
g-a--b eletrônico / 0.

845
00:34:44,360 --> 00:34:47,294

846
00:34:47,294 --> 00:34:48,960
Isso parece um pouco algo como isto.

847
00:34:48,960 --> 00:34:53,650
E s por isso, nós chamamos isso de 0x50,
e que vai ser 51, 52.

848
00:34:53,650 --> 00:34:54,409
>> Portanto, esta é 0x50.

849
00:34:54,409 --> 00:34:55,679

850
00:34:55,679 --> 00:34:59,690
E então, eu faço corda t.

851
00:34:59,690 --> 00:35:02,450
Na memória, que só vai
dê-me um pouco quadrado assim.

852
00:35:02,450 --> 00:35:04,080
Então, qual é o passo fundamental agora?

853
00:35:04,080 --> 00:35:09,870
Se eu quiser copiar s em t, o que
em branco que precisamos preencher aqui?

854
00:35:09,870 --> 00:35:12,050
Ou o que precisamos
fazer a um nível elevado?

855
00:35:12,050 --> 00:35:14,101

856
00:35:14,101 --> 00:35:14,600
Sim?

857
00:35:14,600 --> 00:35:16,200

858
00:35:16,200 --> 00:35:17,020
Alguém?

859
00:35:17,020 --> 00:35:17,690
Sim.

860
00:35:17,690 --> 00:35:19,214
>> AUDIÊNCIA: Precisamos [inaudível].

861
00:35:19,214 --> 00:35:21,380
DAVID J. MALAN: Sim, nós
precisa preencher este campo em branco.

862
00:35:21,380 --> 00:35:24,340
Eu não posso copiar e, em seguida,
capitalizar o nome de Gabe

863
00:35:24,340 --> 00:35:28,120
até eu pedir para o sistema operacional
para um outro pedaço de memória

864
00:35:28,120 --> 00:35:30,640
que é pelo menos tão grande quanto o original.

865
00:35:30,640 --> 00:35:32,130
Então isso nos deixa com uma pergunta.

866
00:35:32,130 --> 00:35:36,080
>> Como posso pedir o sistema operacional não
apenas para um pouco de Pointer simples

867
00:35:36,080 --> 00:35:38,530
como esta é chamada, um
endereço, a não Pointer

868
00:35:38,530 --> 00:35:40,980
para uma caixa pequena e simples
assim chamado uma string?

869
00:35:40,980 --> 00:35:44,200
Como posso pedir o operacional
sistema para uma grande parte da memória?

870
00:35:44,200 --> 00:35:48,430
Até agora, eu só comecei isso de volta
indiretamente chamando GetString.

871
00:35:48,430 --> 00:35:50,740
Então, como é GetString
mesmo recebendo sua memória?

872
00:35:50,740 --> 00:35:53,430
>> Bem, acontece que há
esta outra função aqui

873
00:35:53,430 --> 00:35:55,160
que agora nós vamos começar a usar.

874
00:35:55,160 --> 00:35:59,780
Agora, isso parece than-- forma mais críptica
e eu sou o único que pode ver ele--

875
00:35:59,780 --> 00:36:03,150
esta linha parece muito mais enigmática
então deve à primeira vista.

876
00:36:03,150 --> 00:36:04,650
Mas vamos provocá-lo à parte.

877
00:36:04,650 --> 00:36:07,950
>> No lado esquerdo, eu tenho char * t.

878
00:36:07,950 --> 00:36:13,280
Assim, em Inglês, vamos começar a formular
apropriadas em jargão técnico.

879
00:36:13,280 --> 00:36:19,757
Portanto, esta é a atribuição de uma
variável do tipo char * chamado t.

880
00:36:19,757 --> 00:36:21,090
Agora, o que isso realmente significa?

881
00:36:21,090 --> 00:36:23,881
>> Bem, isso significa que, o que eu vou
colocar nesta variável chamada t?

882
00:36:23,881 --> 00:36:24,780

883
00:36:24,780 --> 00:36:26,402
Um endereço de um char.

884
00:36:26,402 --> 00:36:28,360
Então, isso é apenas o mais simples,
maneira mais razoável

885
00:36:28,360 --> 00:36:29,930
de descrever o lado esquerdo.

886
00:36:29,930 --> 00:36:32,890
Assim que cria esta caixa aqui só.

887
00:36:32,890 --> 00:36:34,760
Então, o lado direito,
presumivelmente, vai

888
00:36:34,760 --> 00:36:37,170
alocar que maior
pedaço de memória como?

889
00:36:37,170 --> 00:36:38,340
Então, vamos brincar com este apart.

890
00:36:38,340 --> 00:36:41,131
>> É impressionante à primeira vista,
mas o que está acontecendo aqui dentro?

891
00:36:41,131 --> 00:36:43,740
Primeiro, há malloc, que
é, aparentemente, o nosso novo amigo,

892
00:36:43,740 --> 00:36:45,450
"Memória alocar."

893
00:36:45,450 --> 00:36:49,560
Portanto, este é o argumento que está sendo passado
para ele, por isso é um argumento muito grande.

894
00:36:49,560 --> 00:36:50,970
Então, vamos brincar com este apart.

895
00:36:50,970 --> 00:36:53,410
>> strlen de s, é claro, representa o--

896
00:36:53,410 --> 00:36:54,142

897
00:36:54,142 --> 00:36:55,600
AUDIÊNCIA: O número de caracteres.

898
00:36:55,600 --> 00:36:56,710
DAVID J. MALAN: Apenas o
número de caracteres em s.

899
00:36:56,710 --> 00:36:59,040
Assim, o comprimento de s, a string original.

900
00:36:59,040 --> 00:37:00,350
Assim G-a-b-e.

901
00:37:00,350 --> 00:37:02,320
Então é provavelmente quatro neste caso.

902
00:37:02,320 --> 00:37:05,485
Por que estou fazendo um depois
chamando strlen de s?

903
00:37:05,485 --> 00:37:06,360
AUDIÊNCIA: [inaudível]

904
00:37:06,360 --> 00:37:07,590
David J. MALAN: Para isso
caractere especial nulo.

905
00:37:07,590 --> 00:37:11,260
Se você me perguntar qual é o comprimento de
O nome de Gabe, eu vou dizer quatro.

906
00:37:11,260 --> 00:37:14,480
Debaixo do capô, porém, eu preciso
que o quinto byte para o caracter nulo.

907
00:37:14,480 --> 00:37:16,100
Então é por isso que eu estou fazendo o 1.

908
00:37:16,100 --> 00:37:21,730
>> Agora é só no caso de você estiver executando este
programa em um computador diferente, digamos,

909
00:37:21,730 --> 00:37:24,610
o aparelho CS50,
em que o tamanho de um char

910
00:37:24,610 --> 00:37:26,350
pode ser diferente
de minha própria Computador--

911
00:37:26,350 --> 00:37:30,590
Acontece que eu posso chamar isso de
sizeof operador, é só pedir o computador,

912
00:37:30,590 --> 00:37:32,870
o que é o tamanho de um
carbonizar neste computador?

913
00:37:32,870 --> 00:37:37,400
>> E multiplicando cinco neste
por exemplo o tamanho de um carvão animal, que

914
00:37:37,400 --> 00:37:40,440
na maioria dos computadores vai
ser apenas um, malloc

915
00:37:40,440 --> 00:37:44,830
vai destinar para mim este grande
pedaço de memória aqui à direita.

916
00:37:44,830 --> 00:37:47,140
E isso vai return--
é uma function-- por isso é

917
00:37:47,140 --> 00:37:48,265
vai voltar para mim o que?

918
00:37:48,265 --> 00:37:50,914

919
00:37:50,914 --> 00:37:51,830
AUDIÊNCIA: O endereço?

920
00:37:51,830 --> 00:37:53,709
DAVID J. MALAN: O endereço de quê?

921
00:37:53,709 --> 00:37:55,250
AUDIÊNCIA: É a memória que alocados?

922
00:37:55,250 --> 00:37:56,450
DAVID J. MALAN: Do
memória que ele alocado.

923
00:37:56,450 --> 00:37:59,189
Então, eu não tenho nenhuma idéia, francamente,
onde é que isto vai acabar.

924
00:37:59,189 --> 00:38:01,480
Vou propor que
isso vai acabar em 0x88.

925
00:38:01,480 --> 00:38:02,770

926
00:38:02,770 --> 00:38:06,009
Completamente arbitrário, mas
em algum lugar diferente 0x50,

927
00:38:06,009 --> 00:38:08,800
porque o sistema operativo, o
Windows e Mac OS fazer para mim, é

928
00:38:08,800 --> 00:38:11,230
certificar-se de que ele está dando
me diferentes pedaços de RAM.

929
00:38:11,230 --> 00:38:14,210
>> Portanto, este é o valor que esta
pedaço de memória pode acabar.

930
00:38:14,210 --> 00:38:16,060
Então é isso que acaba por aqui, 0x88.

931
00:38:16,060 --> 00:38:17,480

932
00:38:17,480 --> 00:38:21,570
Então, agora claramente, eu posso entender
que este não é o mesmo como esta,

933
00:38:21,570 --> 00:38:23,960
porque eles estão apontando para
diferentes pedaços de memória.

934
00:38:23,960 --> 00:38:29,980
Então, se eu agora realmente deseja copiar esta
em, vamos fazer a solução proposta.

935
00:38:29,980 --> 00:38:36,870
>> Vamos embora, crie um loop for,
e fazer suporte t i recebe suporte s i.

936
00:38:36,870 --> 00:38:39,760
Porque agora eu posso usar
esta notação de matriz-like,

937
00:38:39,760 --> 00:38:43,390
porque mesmo que malloc muito
genericamente me atribui memória,

938
00:38:43,390 --> 00:38:45,290
bytes de memória é apenas contíguos.

939
00:38:45,290 --> 00:38:47,240
Byte, byte, byte, back to back to back.

940
00:38:47,240 --> 00:38:50,030
>> Eu posso certamente como um programador
tratá-la como uma matriz, que

941
00:38:50,030 --> 00:38:55,090
significa que eu posso usar este finalmente familiarizado
notação de apenas alguns colchetes.

942
00:38:55,090 --> 00:38:56,462

943
00:38:56,462 --> 00:39:00,020
>> Então deixe-me fazer uma pausa lá, porque
este é um lote de uma só vez, até

944
00:39:00,020 --> 00:39:03,530
embora a idéia básica para recapitular
é essa cadeia, todo esse tempo,

945
00:39:03,530 --> 00:39:05,550
não é um novo tipo de dados per se.

946
00:39:05,550 --> 00:39:10,150
É apenas um ponteiro chamado,
um endereço de um personagem,

947
00:39:10,150 --> 00:39:12,650
que apenas significa que é um número
que, por convenção, humano

948
00:39:12,650 --> 00:39:15,350
que tendem a escrever como 0x algo.

949
00:39:15,350 --> 00:39:18,590
>> Mas é apenas um número,
como 33 Oxford Street,

950
00:39:18,590 --> 00:39:20,530
que passa a ser o
Endereço do CS edifício.

951
00:39:20,530 --> 00:39:22,000

952
00:39:22,000 --> 00:39:23,545
Qualquer dúvida sobre esses detalhes?

953
00:39:23,545 --> 00:39:24,790

954
00:39:24,790 --> 00:39:25,289
Sim?

955
00:39:25,289 --> 00:39:28,530
>> AUDIÊNCIA: Por que nós verificamos fazer
para t igual a nulo?

956
00:39:28,530 --> 00:39:30,740
>> DAVID J. MALAN: Por que
verificar a existência de t igual a nulo?

957
00:39:30,740 --> 00:39:33,250
Se lermos o documentation--
grande pergunta-- para malloc,

958
00:39:33,250 --> 00:39:37,020
ele vai dizer em letras miúdas,
às vezes malloc pode retornar nulo,

959
00:39:37,020 --> 00:39:38,080
assim como GetString.

960
00:39:38,080 --> 00:39:41,820
E, de fato, GetString retorna null
se, por sua vez, malloc retorna nulo,

961
00:39:41,820 --> 00:39:43,130
porque GetString usa malloc.

962
00:39:43,130 --> 00:39:46,400
>> E isso pode acontecer se o sistema operacional,
Mac OS, Windows, qualquer que seja, é simplesmente

963
00:39:46,400 --> 00:39:48,130
falta de memória para você.

964
00:39:48,130 --> 00:39:49,820
Então, isso é o que aconteceu lá.

965
00:39:49,820 --> 00:39:52,910
>> E deixe-me revelar uma outra coisa
que só poderia explodir sua mente

966
00:39:52,910 --> 00:39:55,100
ou completamente estar muito em cima da linha.

967
00:39:55,100 --> 00:39:59,770
Mas deixe-me puxar para cima o
mesmo laço for para copiar,

968
00:39:59,770 --> 00:40:05,480
que há um momento, a retirada foi
este. suporte t i recebe suporte s i.

969
00:40:05,480 --> 00:40:06,740
>> Nice and user-friendly.

970
00:40:06,740 --> 00:40:09,330
Parece Week Two novamente.

971
00:40:09,330 --> 00:40:14,920
Mas esta versão, na verdade, pode ser
reescrita como este, que parece enigmática.

972
00:40:14,920 --> 00:40:18,280
É um ponteiro técnica chamada
aritmética, aritmética endereço.

973
00:40:18,280 --> 00:40:19,600
Mas por que isso funciona?

974
00:40:19,600 --> 00:40:22,220
>> Agora irritantemente, o
C autores decidiram utilizar

975
00:40:22,220 --> 00:40:25,070
o símbolo * para fins diferentes.

976
00:40:25,070 --> 00:40:29,020
Já vimos isso usado uma vez já,
char *, que significa "me dê uma variável

977
00:40:29,020 --> 00:40:31,210
que vai conter
o endereço de um char. "

978
00:40:31,210 --> 00:40:33,990
* Então caractere em que contexto
significa "me dê uma variável."

979
00:40:33,990 --> 00:40:40,050
>> Infelizmente, se você usar o * sem
uma palavra em frente do mesmo, como carvão,

980
00:40:40,050 --> 00:40:41,905
agora é chamado de
operador de dereferência.

981
00:40:41,905 --> 00:40:43,530
E vamos ver mais deste antes do tempo.

982
00:40:43,530 --> 00:40:44,930
Mas isso apenas significa "ir para lá."

983
00:40:44,930 --> 00:40:49,070
É como dizer que, se alguém me entregou
em um pedaço de papel "33 Oxford Street,"

984
00:40:49,070 --> 00:40:53,830
se eu fizer "* 33 Oxford Street", que significa
"Descer a estrada para a construção CS."

985
00:40:53,830 --> 00:40:57,220
>> Então * significa apenas ir para lá se
não há nenhuma palavra na frente dele.

986
00:40:57,220 --> 00:40:59,100
Então, o que é t, para ser claro?

987
00:40:59,100 --> 00:41:03,250
t é o endereço do bloco de
memória que foi dado de volta para mim.

988
00:41:03,250 --> 00:41:06,650
s é o endereço de que, para ser claro,
no exemplo que estamos discutindo,

989
00:41:06,650 --> 00:41:07,500
gabe de minúsculas?

990
00:41:07,500 --> 00:41:08,990

991
00:41:08,990 --> 00:41:10,005
s é o endereço de--

992
00:41:10,005 --> 00:41:11,585

993
00:41:11,585 --> 00:41:12,460
AUDIÊNCIA: A string.

994
00:41:12,460 --> 00:41:14,126
DAVID J. MALAN: É o nome original de Gabe.

995
00:41:14,126 --> 00:41:16,660
Então, é o endereço de
este pedaço de memória.

996
00:41:16,660 --> 00:41:22,220
Então, se eu digo t + i-- i, o aviso prévio,
é apenas o nosso velho amigo.

997
00:41:22,220 --> 00:41:24,770
É apenas uma variável de índice
que é a iteração de zero em cima

998
00:41:24,770 --> 00:41:26,960
para o comprimento da string s.

999
00:41:26,960 --> 00:41:30,367
Por isso, vai ser zero, em seguida, um,
depois dois, depois três, depois quatro.

1000
00:41:30,367 --> 00:41:33,200
Então, vamos montar esses novos
O enigma de raspadinhas-like, se quiser,

1001
00:41:33,200 --> 00:41:36,140
apesar de, novamente, a sintaxe
é muito mais misterioso do que zero.

1002
00:41:36,140 --> 00:41:39,522
Então t é um endereço +
i vai me dar

1003
00:41:39,522 --> 00:41:42,480
um número, porque estes são todos
números que temos vindo a desenhar como hex.

1004
00:41:42,480 --> 00:41:43,560
Mas eles são apenas números.

1005
00:41:43,560 --> 00:41:49,960
>> Então, se o endereço de t dissemos
era 0x88, o que é 0x88 mais zero.

1006
00:41:49,960 --> 00:41:51,564

1007
00:41:51,564 --> 00:41:53,980
Mesmo se você não está confortável
com hex ainda, dar um palpite.

1008
00:41:53,980 --> 00:41:54,410
>> AUDIÊNCIA: The original.

1009
00:41:54,410 --> 00:41:55,850
>> DAVID J. MALAN: Ainda 0x88.

1010
00:41:55,850 --> 00:41:58,910
Então, o que * 0x88 significa?

1011
00:41:58,910 --> 00:42:02,670
Quer dizer, "ir lá", que significa
efetivamente, "colocar o dedo aqui."

1012
00:42:02,670 --> 00:42:06,930
E agora no lado da mão direita de
esta expressão, * e, em seguida, em parênteses,

1013
00:42:06,930 --> 00:42:11,586
s + i significa s, que é o
tratar-se aqui da pequena g.

1014
00:42:11,586 --> 00:42:16,220
s + 0 é, naturalmente, é, tudo o que é s.

1015
00:42:16,220 --> 00:42:21,230
>> Então, agora, é * s, que assim como * 33
Oxford Street significa ir para o endereço

1016
00:42:21,230 --> 00:42:22,010
s.

1017
00:42:22,010 --> 00:42:24,170
Então aqui está esse dedo, a mão direita.

1018
00:42:24,170 --> 00:42:26,050
Então o que é que eu vou copiar para o quê?

1019
00:42:26,050 --> 00:42:30,260
A coisa sobre o direito, que é
gabe, pouco g aqui, para aqui.

1020
00:42:30,260 --> 00:42:32,750
>> E assim o efeito de que
primeira iteração do loop,

1021
00:42:32,750 --> 00:42:36,200
como proposto, mesmo que pareça
louco mais complicado do que qualquer coisa

1022
00:42:36,200 --> 00:42:42,110
que já vimos antes, está simplesmente dizendo
clique aqui e copie esse personagem aqui.

1023
00:42:42,110 --> 00:42:44,700
É o que lhe dá um mapa para ambos os locais.

1024
00:42:44,700 --> 00:42:46,130
>> E vamos ver muito mais disso.

1025
00:42:46,130 --> 00:42:50,600
Mas, por agora, a esperança é apenas para
introduzir algumas dessas idéias básicas.

1026
00:42:50,600 --> 00:42:53,550
E, de fato, vejamos
um programa de final aqui,

1027
00:42:53,550 --> 00:42:57,480
e então o claymation prometido,
que irá fazer tudo certo.

1028
00:42:57,480 --> 00:42:57,980
Tudo certo.

1029
00:42:57,980 --> 00:43:01,680
Então deixe-me abrir up-- lá vamos nós.

1030
00:43:01,680 --> 00:43:02,850

1031
00:43:02,850 --> 00:43:05,440
Então vamos me-- vamos voltar
a esse quadro antes do tempo.

1032
00:43:05,440 --> 00:43:08,360
Deixe-me abrir este último exemplo aqui.

1033
00:43:08,360 --> 00:43:09,440

1034
00:43:09,440 --> 00:43:12,710
>> Então aqui vai uma super, super
programa que realiza

1035
00:43:12,710 --> 00:43:15,050
nada na vida que faz o seguinte.

1036
00:43:15,050 --> 00:43:18,740
Primeiro, ele declara duas variáveis, x
e y, que não são números este tempo,

1037
00:43:18,740 --> 00:43:19,240
per si.

1038
00:43:19,240 --> 00:43:20,448
Eles não estão inteiros, per se.

1039
00:43:20,448 --> 00:43:22,899
Eles são aparentemente int *.

1040
00:43:22,899 --> 00:43:25,690
Então, qualquer um, o que significa
Se o seu tipo de dados, a sua variável,

1041
00:43:25,690 --> 00:43:26,860
é do tipo int * star?

1042
00:43:26,860 --> 00:43:30,240
Esse é o endereço de um int.

1043
00:43:30,240 --> 00:43:31,990
>> Então, eu não tenho nenhuma idéia de onde é ainda.

1044
00:43:31,990 --> 00:43:35,150
Significa apenas "colocar, eventualmente,
o endereço de um int aqui. "

1045
00:43:35,150 --> 00:43:38,340
0x50, 0x88, onde quer que seja em
memória, um endereço está acontecendo lá.

1046
00:43:38,340 --> 00:43:40,200
E é isso que y é
vai ser, também.

1047
00:43:40,200 --> 00:43:44,920
>> Se eu agora dizer x = malloc (sizeof (int)),
esta é uma maneira elegante de dizer,

1048
00:43:44,920 --> 00:43:49,000
hey sistema operacional, via malloc,
dá-me a memória suficiente para o tamanho

1049
00:43:49,000 --> 00:43:52,370
de um int, que é provavelmente
vai ser de 32 bits ou quatro bytes.

1050
00:43:52,370 --> 00:43:53,680
>> Então, o que malloc retornar?

1051
00:43:53,680 --> 00:43:55,250
Malloc retorna um endereço.

1052
00:43:55,250 --> 00:43:57,020
Então, o que vai ser armazenado em x?

1053
00:43:57,020 --> 00:44:00,600
O endereço do bloco de
memória, os quatro bytes, que malloc

1054
00:44:00,600 --> 00:44:03,360
só encontrei para me perguntando
o sistema operativo.

1055
00:44:03,360 --> 00:44:08,240
>> Agora, entretanto, a linha
quatro aqui, a * x = 42.

1056
00:44:08,240 --> 00:44:09,990
Só para ficar claro,
o que está acontecendo lá embaixo?

1057
00:44:09,990 --> 00:44:11,530
No lado esquerdo, * x.

1058
00:44:11,530 --> 00:44:13,610
que é como * 33 Oxford Street.

1059
00:44:13,610 --> 00:44:15,523
Então * x significa o quê?

1060
00:44:15,523 --> 00:44:16,450
>> AUDIÊNCIA: Vá para.

1061
00:44:16,450 --> 00:44:17,908
>> DAVID J. MALAN: Vá para esse endereço.

1062
00:44:17,908 --> 00:44:20,466
Onde quer que esse pedaço de
memória é, ir para ele.

1063
00:44:20,466 --> 00:44:21,979
E colocar o que há, obviamente?

1064
00:44:21,979 --> 00:44:22,520
AUDIÊNCIA: 42.

1065
00:44:22,520 --> 00:44:23,580
DAVID J. MALAN: 42.

1066
00:44:23,580 --> 00:44:25,650
Tudo bem, * y, mesma idéia.

1067
00:44:25,650 --> 00:44:26,860
Ir para o endereço em y.

1068
00:44:26,860 --> 00:44:31,740
Coloque o número 13 lá,
mas o que é y no momento?

1069
00:44:31,740 --> 00:44:33,172

1070
00:44:33,172 --> 00:44:34,630
AUDIÊNCIA: Não há memória para y.

1071
00:44:34,630 --> 00:44:35,710
DAVID J. MALAN: Não
há memória para y.

1072
00:44:35,710 --> 00:44:38,215
Então, o que faz y provavelmente
conter, como temos vindo a dizer?

1073
00:44:38,215 --> 00:44:38,520
>> AUDIÊNCIA: Garbage.

1074
00:44:38,520 --> 00:44:39,480
>> DAVID J. MALAN: Algum valor de lixo.

1075
00:44:39,480 --> 00:44:41,320
Agora, o valor de lixo ainda é um número.

1076
00:44:41,320 --> 00:44:43,160
Ele ainda pode ser confundido com um endereço.

1077
00:44:43,160 --> 00:44:45,160
É como se alguém
rabiscou algo,

1078
00:44:45,160 --> 00:44:48,002
e eu mal interpretado como significando
um prédio no final da rua.

1079
00:44:48,002 --> 00:44:50,460
E se você apenas tentar entrar em
um prédio que não possui,

1080
00:44:50,460 --> 00:44:53,710
ou algum pedaço de memória que você não tem
sido dado, as coisas ruins podem acontecer.

1081
00:44:53,710 --> 00:44:57,740
Computador pode falhar, ou algum outro
comportamento indeterminado pode acontecer.

1082
00:44:57,740 --> 00:45:01,310
>> Assim, a introdução, em seguida, para Binky é isso.

1083
00:45:01,310 --> 00:45:04,290
Eu ainda me lembro, 20
tantos anos depois,

1084
00:45:04,290 --> 00:45:07,200
onde eu estava quando eu finalmente
compreendida ponteiros.

1085
00:45:07,200 --> 00:45:09,520
>> O que quer dizer, se você
deixe aqui em três minutos

1086
00:45:09,520 --> 00:45:12,170
e acho que não
entender ponteiros, perceber

1087
00:45:12,170 --> 00:45:14,410
Tenho lembrado por 20
anos, por alguma razão maluca

1088
00:45:14,410 --> 00:45:17,140
quando e por que finalmente afundado
em, sentado com o meu ensino

1089
00:45:17,140 --> 00:45:19,501
companheiro, Nishat Mehta no
volta de Eliot Refeitório.

1090
00:45:19,501 --> 00:45:21,250
Agora, eu me lembrei
isso porque foi

1091
00:45:21,250 --> 00:45:23,920
um dos temas I, em
particular, lutou com.

1092
00:45:23,920 --> 00:45:26,470
E então, finalmente clicado,
como eu ouso dizer um monte de tópicos

1093
00:45:26,470 --> 00:45:27,460
acabará.

1094
00:45:27,460 --> 00:45:32,590
E agora, para fazer que sentir toda a
mais feliz e tudo o mais convincente,

1095
00:45:32,590 --> 00:45:35,360
vamos dar uma olhada final na nossa
últimos três minutos aqui no Binky,

1096
00:45:35,360 --> 00:45:37,675
do nosso amigo, Nick
Parlante de Stanford.

1097
00:45:37,675 --> 00:45:38,910

1098
00:45:38,910 --> 00:45:41,580
>> [REPRODUÇÃO]

1099
00:45:41,580 --> 00:45:42,750
>> Ei, Binky.

1100
00:45:42,750 --> 00:45:43,500
Acorde!

1101
00:45:43,500 --> 00:45:45,960
É hora de diversão ponteiro.

1102
00:45:45,960 --> 00:45:47,012
>> -Qual Que é isso?

1103
00:45:47,012 --> 00:45:48,723
Saiba mais sobre ponteiros?

1104
00:45:48,723 --> 00:45:50,580
Ah, que bom!

1105
00:45:50,580 --> 00:45:53,563
>> Bem, para começar, eu acho que estamos
vai precisar de um par de ponteiros.

1106
00:45:53,563 --> 00:45:54,390
>> -OK.

1107
00:45:54,390 --> 00:45:57,930
Este código aloca dois ponteiros,
que pode apontar para números inteiros.

1108
00:45:57,930 --> 00:45:58,430
-OK.

1109
00:45:58,430 --> 00:46:02,140
Bem, eu vejo os dois ponteiros, mas eles
não parecem estar apontando para qualquer coisa.

1110
00:46:02,140 --> 00:46:02,980
>> -É Direita.

1111
00:46:02,980 --> 00:46:05,100
Inicialmente, os ponteiros
não apontam para nada.

1112
00:46:05,100 --> 00:46:08,030
As coisas que eles apontam para são chamados
pointees, e configurá-los de

1113
00:46:08,030 --> 00:46:09,370
um passo separado.

1114
00:46:09,370 --> 00:46:10,220
>> Ah, certo, certo.

1115
00:46:10,220 --> 00:46:10,950
Eu sabia disso.

1116
00:46:10,950 --> 00:46:12,385
Os pointees são separados.

1117
00:46:12,385 --> 00:46:14,315
Er, assim como você alocar uma pointee?

1118
00:46:14,315 --> 00:46:15,340

1119
00:46:15,340 --> 00:46:15,960
>> -OK.

1120
00:46:15,960 --> 00:46:18,970
Bem, este código aloca
um novo pointee inteiro,

1121
00:46:18,970 --> 00:46:20,950
e isso define Parte X para apontar para ele.

1122
00:46:20,950 --> 00:46:22,050

1123
00:46:22,050 --> 00:46:23,230
>> Ei, que parece melhor.

1124
00:46:23,230 --> 00:46:25,060
Então ele fazer alguma coisa.

1125
00:46:25,060 --> 00:46:25,990
>> -OK.

1126
00:46:25,990 --> 00:46:30,455
Vou cancelar o ponteiro x para
armazenar o número 42 na sua pointee.

1127
00:46:30,455 --> 00:46:32,830
Para este truque, eu vou precisar da minha
Varinha Mágica de desreferenciação.

1128
00:46:32,830 --> 00:46:34,130

1129
00:46:34,130 --> 00:46:36,080
>> -Seu Magic Wand de Dereferencing?

1130
00:46:36,080 --> 00:46:37,357

1131
00:46:37,357 --> 00:46:38,190
Que-- isso é ótimo.

1132
00:46:38,190 --> 00:46:39,340

1133
00:46:39,340 --> 00:46:41,080
>> -Este É o que o código se parece.

1134
00:46:41,080 --> 00:46:44,110
Eu só vou definir o número, e [POP]

1135
00:46:44,110 --> 00:46:44,700
>> Ei, olha.

1136
00:46:44,700 --> 00:46:46,140
Não vai.

1137
00:46:46,140 --> 00:46:50,980
>> -Então Fazendo um desreferenciava em x segue
a seta para acessar sua pointee.

1138
00:46:50,980 --> 00:46:53,160
Neste caso, uma loja de 42 em lá.

1139
00:46:53,160 --> 00:46:57,710
Hey tentar usá-lo para armazenar o número
13 através do outro ponteiro, y.

1140
00:46:57,710 --> 00:46:58,760
>> -OK.

1141
00:46:58,760 --> 00:47:03,270
Eu vou passar por cima aqui para y,
e obter o número 13 set up.

1142
00:47:03,270 --> 00:47:07,930
E, em seguida, pegue a varinha de
Dereferencing e apenas [BUZZ]

1143
00:47:07,930 --> 00:47:08,960
>> Ah!

1144
00:47:08,960 --> 00:47:09,500
>> Oh, hey!

1145
00:47:09,500 --> 00:47:11,090
Isso não funcionou.

1146
00:47:11,090 --> 00:47:15,630
Diga, Binky, eu não acho que dereferencing
y é uma boa idéia, porque você sabe,

1147
00:47:15,630 --> 00:47:17,850
criação do pointee
é um passo separado.

1148
00:47:17,850 --> 00:47:20,450
E eu não acho que nunca fiz isso.

1149
00:47:20,450 --> 00:47:21,480
>> Ponto -Boa.

1150
00:47:21,480 --> 00:47:21,980
Sim.

1151
00:47:21,980 --> 00:47:25,680
Alocamos o ponteiro y, mas nós
nunca defini-lo para apontar para um pointee.

1152
00:47:25,680 --> 00:47:27,190

1153
00:47:27,190 --> 00:47:28,616
>> -Muito Observador.

1154
00:47:28,616 --> 00:47:30,240
Ei, você está olhando bom lá, Binky.

1155
00:47:30,240 --> 00:47:33,400
Você pode corrigi-lo assim que os pontos y
ao mesmo pointee como x?

1156
00:47:33,400 --> 00:47:34,000
>> -sure.

1157
00:47:34,000 --> 00:47:36,780
Vou usar a minha varinha mágica
Ponteiro de Cessão.

1158
00:47:36,780 --> 00:47:38,740
>> -É Que vai ser
um problema como antes?

1159
00:47:38,740 --> 00:47:39,240
-No.

1160
00:47:39,240 --> 00:47:40,660
Este não toca nos pointees.

1161
00:47:40,660 --> 00:47:44,450
Ele só muda um ponteiro para
apontam para a mesma coisa que o outro.

1162
00:47:44,450 --> 00:47:45,450
>> Oh, eu vejo.

1163
00:47:45,450 --> 00:47:48,200
Agora y aponta para o mesmo lugar que x.

1164
00:47:48,200 --> 00:47:48,910
Então, espere.

1165
00:47:48,910 --> 00:47:49,950
Agora, y é fixo.

1166
00:47:49,950 --> 00:47:51,120
Tem um pointee.

1167
00:47:51,120 --> 00:47:54,510
Então você pode tentar o Wand of
Dereferencing novamente para enviar a 13 terminado.

1168
00:47:54,510 --> 00:47:56,510
>> Uh, OK.

1169
00:47:56,510 --> 00:47:58,160
Aqui vai. [POP]

1170
00:47:58,160 --> 00:47:59,340
>> Ei, olha isso.

1171
00:47:59,340 --> 00:48:00,750
Agora dereferencing obras sobre y.

1172
00:48:00,750 --> 00:48:04,991
E porque os ponteiros estão compartilhando
que um pointee, ambos ver o 13.

1173
00:48:04,991 --> 00:48:05,490
Sim.

1174
00:48:05,490 --> 00:48:06,870
Compartilhando, qualquer que seja.

1175
00:48:06,870 --> 00:48:08,820
Então, vamos trocar de lugar agora?

1176
00:48:08,820 --> 00:48:09,440
>> Oh, olhe.

1177
00:48:09,440 --> 00:48:10,830
Estamos sem tempo.

1178
00:48:10,830 --> 00:48:11,570
>> -Mas

1179
00:48:11,570 --> 00:48:13,530
>> -Basta Lembrar as três regras de ponteiro.

1180
00:48:13,530 --> 00:48:16,560
Number One, a estrutura básica
é que você tem um ponteiro,

1181
00:48:16,560 --> 00:48:18,680
e aponta mais para um pointee.

1182
00:48:18,680 --> 00:48:20,640
Mas o ponteiro e
pointee são separados,

1183
00:48:20,640 --> 00:48:22,610
e o erro comum
é a criação de um ponteiro,

1184
00:48:22,610 --> 00:48:25,000
mas esquecer-se de dar-lhe um pointee.

1185
00:48:25,000 --> 00:48:28,170
>> Número Dois, dereferencing ponteiro
começa no ponteiro

1186
00:48:28,170 --> 00:48:31,050
e segue a sua seta sobre
para acessar sua pointee.

1187
00:48:31,050 --> 00:48:33,400
Como todos sabemos, este
só funciona se houver

1188
00:48:33,400 --> 00:48:36,270
um pointee, que tipo de
recebe de volta a regra número um.

1189
00:48:36,270 --> 00:48:39,000
>> Número Três, ponteiro
atribuição é um ponteiro

1190
00:48:39,000 --> 00:48:42,320
e muda-lo para apontar para o
mesmo pointee como outro ponteiro.

1191
00:48:42,320 --> 00:48:44,160
Assim, após a atribuição,
os dois ponteiros

1192
00:48:44,160 --> 00:48:45,910
irá apontar para o mesmo pointee.

1193
00:48:45,910 --> 00:48:47,990
Às vezes, isso é chamado de partilha.

1194
00:48:47,990 --> 00:48:49,740
E isso é tudo que existe para ela, realmente.

1195
00:48:49,740 --> 00:48:50,277
Bye-bye agora.

1196
00:48:50,277 --> 00:48:51,110
[FIM REPRODUÇÃO DE VÍDEO]

1197
00:48:51,110 --> 00:48:52,568
DAVID J. MALAN: Isso é tudo para CS50.

1198
00:48:52,568 --> 00:48:55,110
Vamos vê-lo na próxima semana.

1199
00:48:55,110 --> 00:48:56,064