1
00:00:00,000 --> 00:00:00,980

2
00:00:00,980 --> 00:00:04,410
>> [MÚSICA DE JOGO]

3
00:00:04,410 --> 00:00:11,147

4
00:00:11,147 --> 00:00:12,230
DAVID J. MALAN: Tudo bem.

5
00:00:12,230 --> 00:00:16,440
Este é CS50, e esta
é o fim da Semana 2.

6
00:00:16,440 --> 00:00:18,480
Então, hoje, nós vamos
para continuar o nosso olhar

7
00:00:18,480 --> 00:00:21,150
a forma como representamos as coisas
debaixo do hood-- afastando

8
00:00:21,150 --> 00:00:23,520
de números como inteiros
e valores de ponto flutuante

9
00:00:23,520 --> 00:00:26,810
e concentrando-se em cordas e
programas, finalmente, mais interessantes.

10
00:00:26,810 --> 00:00:30,140
Mas nós também vamos dar uma olhada em um
par de problems-- específica de domínio

11
00:00:30,140 --> 00:00:33,620
a primeira das quais vai
ser envolvendo criptografia,

12
00:00:33,620 --> 00:00:36,570
o arte de codificação da informação,
em que você vê acima aqui

13
00:00:36,570 --> 00:00:41,480
é um retrato da Rádio Orphan Annie
anel decodificador secreto do passado.

14
00:00:41,480 --> 00:00:46,490
>> Este é, na verdade forma muito primitiva
e forma para crianças de cryptopgraphy

15
00:00:46,490 --> 00:00:50,590
em que este anel tem dois disks--
um dentro e outro fora.

16
00:00:50,590 --> 00:00:54,740
E girando um desses, você pode
essencialmente alinhar letras como A

17
00:00:54,740 --> 00:00:59,520
a Z com outras letras
B como através da A. Por outras palavras,

18
00:00:59,520 --> 00:01:03,730
você pode literalmente girar o alfabeto,
vindo, assim, com um mapeamento a partir de

19
00:01:03,730 --> 00:01:07,820
cartas para cartas de modo que, se você
queria enviar uma mensagem secreta

20
00:01:07,820 --> 00:01:11,820
para alguém como Annie, você poderia escrever
para baixo a sua mensagem e, em seguida, gire

21
00:01:11,820 --> 00:01:15,370
as letras, em que, se você quer dizer
dizer "A", você em vez dizer "B",

22
00:01:15,370 --> 00:01:17,280
Quer dizer "B",
você, em vez dizer "C" -

23
00:01:17,280 --> 00:01:20,240
ou algo um pouco mais inteligente
que que-- e depois, em última análise,

24
00:01:20,240 --> 00:01:24,630
enquanto Annie tem esse decodificador
anel, ela pode decodificar a mensagem.

25
00:01:24,630 --> 00:01:28,540
Agora, você deve se lembrar, aliás, que este
foi usado em um filme muito famoso que

26
00:01:28,540 --> 00:01:31,140
joga ad nauseum durante
a época de Natal.

27
00:01:31,140 --> 00:01:32,650
Vamos dar uma olhada aqui.

28
00:01:32,650 --> 00:01:35,294

29
00:01:35,294 --> 00:01:37,210
RALPHIE PARKER: "Seja
conhecido por todos, em resumo

30
00:01:37,210 --> 00:01:41,000
que Ralph Parker é nomeado
um membro da Little Orphan Annie Segredo

31
00:01:41,000 --> 00:01:44,860
Círculo e tem direito a todos os
honras e benefícios que ocorrem ao mesmo ".

32
00:01:44,860 --> 00:01:47,410
>> RALPHIE PARKER (narrando):
Assinado Little Orphan Annie.

33
00:01:47,410 --> 00:01:50,070
Referendado, Pierre Andre!

34
00:01:50,070 --> 00:01:51,490
Na tinta.

35
00:01:51,490 --> 00:01:55,494
Honras e benefícios,
já com a idade de nove anos.

36
00:01:55,494 --> 00:01:57,402
>> [MÚSICA DE JOGO]

37
00:01:57,402 --> 00:02:00,470
>> [RADIO CHATTER]

38
00:02:00,470 --> 00:02:01,470
RALPHIE PARKER: Vamos lá.

39
00:02:01,470 --> 00:02:02,344
Vamos continuar com ele.

40
00:02:02,344 --> 00:02:06,029
Eu não preciso de todo esse jazz
sobre contrabandistas e piratas.

41
00:02:06,029 --> 00:02:08,820
RADIO LOCUTOR: Ouça amanhã
noite para a aventura final

42
00:02:08,820 --> 00:02:11,060
do navio pirata Preto.

43
00:02:11,060 --> 00:02:14,740
Agora, é hora de Annie
Mensagem secreta para os membros da

44
00:02:14,740 --> 00:02:17,110
do Círculo Secreto.

45
00:02:17,110 --> 00:02:20,700
Lembre-se dos miúdos, apenas membros
de Secret Circle de Annie

46
00:02:20,700 --> 00:02:23,270
pode decodificar mensagem secreta de Annie.

47
00:02:23,270 --> 00:02:27,270
>> Lembre-se, Annie está dependendo de você.

48
00:02:27,270 --> 00:02:30,060
Defina seus pinos para B-2.

49
00:02:30,060 --> 00:02:34,004
Aqui está o message-- 12, 11, 2--

50
00:02:34,004 --> 00:02:36,503
RALPHIE PARKER (narrando): I
estou no meu primeiro encontro secreto.

51
00:02:36,503 --> 00:02:40,041
RADIO LOCUTOR: --25, 14, 11, 18, 16--

52
00:02:40,041 --> 00:02:42,790
RALPHIE PARKER (narrando): Oh,
Pierre estava em grande noite de voz.

53
00:02:42,790 --> 00:02:46,110
Eu poderia dizer que hoje à noite
mensagem era realmente importante.

54
00:02:46,110 --> 00:02:47,930
>> RADIO LOCUTOR: --3, 25.

55
00:02:47,930 --> 00:02:49,940
Essa é uma mensagem de Annie a si mesma.

56
00:02:49,940 --> 00:02:52,182
Lembre-se, não conte a ninguém.

57
00:02:52,182 --> 00:02:55,077
>> [Ofegante]

58
00:02:55,077 --> 00:02:57,285
RALPHIE PARKER (narrando):
Noventa segundos depois, eu sou

59
00:02:57,285 --> 00:03:00,090
no único quarto no
casa onde um menino de nove anos

60
00:03:00,090 --> 00:03:04,380
poderia sentar em privacidade e decodificar.

61
00:03:04,380 --> 00:03:04,990
Ah.

62
00:03:04,990 --> 00:03:05,680
"B."

63
00:03:05,680 --> 00:03:06,524
>> [Risos]

64
00:03:06,524 --> 00:03:08,684
>> RALPHIE PARKER (narrando):
Eu fui para o outro.

65
00:03:08,684 --> 00:03:09,610
"E."

66
00:03:09,610 --> 00:03:11,641
A primeira palavra é "ser".

67
00:03:11,641 --> 00:03:12,140
Sim!

68
00:03:12,140 --> 00:03:14,293
Ele estava chegando mais fácil agora.

69
00:03:14,293 --> 00:03:15,259
"U."

70
00:03:15,259 --> 00:03:16,225
>> [Risos]

71
00:03:16,225 --> 00:03:18,157
>> RANDY PARKER: Ah, vamos lá, Ralphie.

72
00:03:18,157 --> 00:03:19,606
Eu tenho que ir!

73
00:03:19,606 --> 00:03:21,538
>> RALPHIE PARKER: Eu vou descer, Ma.

74
00:03:21,538 --> 00:03:22,504
Gee Whiz.

75
00:03:22,504 --> 00:03:25,402

76
00:03:25,402 --> 00:03:31,220
"T." "O." "Certifique-se
com "." Certifique-se de "o quê?

77
00:03:31,220 --> 00:03:33,981
Qual foi Little Orphan Annie
tentando dizer? "Certifique-se de" o quê?

78
00:03:33,981 --> 00:03:35,522
MÃE: Ralphie, Randy tem que ir.

79
00:03:35,522 --> 00:03:36,735
Será que você poderia sair?

80
00:03:36,735 --> 00:03:38,190
>> RALPHIE PARKER: Tudo bem, mãe!

81
00:03:38,190 --> 00:03:39,787
Vou sair bem!

82
00:03:39,787 --> 00:03:41,995
RALPHIE PARKER (narrando):
Eu estava ficando mais perto agora.

83
00:03:41,995 --> 00:03:43,370
A tensão era terrível.

84
00:03:43,370 --> 00:03:44,794
O que foi?

85
00:03:44,794 --> 00:03:47,656
O destino do planeta
podem estar em jogo.

86
00:03:47,656 --> 00:03:50,518
>> MÃE: Ralphie, Randy tem que ir!

87
00:03:50,518 --> 00:03:53,635
>> RALPHIE PARKER: Eu estarei bem
fora, pelo amor de Deus!

88
00:03:53,635 --> 00:03:55,343
RALPHIE PARKER
(Narrando): Quase lá!

89
00:03:55,343 --> 00:03:56,520
Meus dedos voaram!

90
00:03:56,520 --> 00:03:58,500
Minha mente estava em uma armadilha de aço.

91
00:03:58,500 --> 00:03:59,850
Cada poro vibrou.

92
00:03:59,850 --> 00:04:01,806
Era quase claro!

93
00:04:01,806 --> 00:04:02,773
Sim!

94
00:04:02,773 --> 00:04:03,273
Sim!

95
00:04:03,273 --> 00:04:03,773
Sim!

96
00:04:03,773 --> 00:04:04,740
Sim!

97
00:04:04,740 --> 00:04:10,250
>> RALPHIE PARKER: "Certifique-se
para beber o seu Ovomaltine. "

98
00:04:10,250 --> 00:04:10,750
Ovomaltine?

99
00:04:10,750 --> 00:04:14,864

100
00:04:14,864 --> 00:04:17,539
Um comercial miserável?

101
00:04:17,539 --> 00:04:19,439
>> [MÚSICA DE JOGO]

102
00:04:19,439 --> 00:04:21,724
>> RALPHIE PARKER: Filho da puta.

103
00:04:21,724 --> 00:04:23,460
>> [Risos]

104
00:04:23,460 --> 00:04:27,070
>> DAVID J. MALAN: Para que, então, é
um vislumbre do que a criptografia

105
00:04:27,070 --> 00:04:29,880
pode ser para um isto--
beber do passado.

106
00:04:29,880 --> 00:04:30,900
Assim, um anúncio rápido.

107
00:04:30,900 --> 00:04:33,410
Se você está livre esta
Sexta-feira às 13:15 e faria

108
00:04:33,410 --> 00:04:36,610
gostaria de se juntar a nós para CS50
almoço, ir para este URL aqui.

109
00:04:36,610 --> 00:04:38,080
Primeiro a chegar, primeiro a servir como de costume.

110
00:04:38,080 --> 00:04:41,840
Mas com o tempo, vamos ter certeza de que
mais quem gostaria de participar

111
00:04:41,840 --> 00:04:43,640
Pode programar-wise.

112
00:04:43,640 --> 00:04:45,170
>> Assim cordas.

113
00:04:45,170 --> 00:04:47,940
Temos Zamyla-- quem
você já reuniu mais provável

114
00:04:47,940 --> 00:04:50,750
Na Série 1-- cuja
nome está escrito assim.

115
00:04:50,750 --> 00:04:53,570
E suponha que você digitou o nome dela
em um programa de computador que é

116
00:04:53,570 --> 00:04:55,710
usando algo como getString.

117
00:04:55,710 --> 00:04:57,890
A fim de recuperar
essas teclas, como

118
00:04:57,890 --> 00:05:01,620
nós vamos sobre o que representa uma
corda, uma palavra, um parágrafo,

119
00:05:01,620 --> 00:05:03,960
ou várias letras como estes aqui?

120
00:05:03,960 --> 00:05:06,790
>> Conversamos última vez sobre
inteiros e problemas

121
00:05:06,790 --> 00:05:09,960
que surgem com integer overflow
e valores de ponto flutuante

122
00:05:09,960 --> 00:05:12,190
e os problemas que
surgir dentro de precisão.

123
00:05:12,190 --> 00:05:16,080
Com cordas, nós, pelo menos,
ter um pouco mais de flexibilidade

124
00:05:16,080 --> 00:05:17,970
porque strings-- apenas
no real mundo--

125
00:05:17,970 --> 00:05:19,790
podem ter um comprimento bastante arbitrária.

126
00:05:19,790 --> 00:05:21,055
Muito curto, muito longo.

127
00:05:21,055 --> 00:05:23,680
Mas, mesmo assim, vamos
descobrir que computadores podem, por vezes,

128
00:05:23,680 --> 00:05:27,200
sem memória e nem mesmo
armazenar uma string grande o suficiente.

129
00:05:27,200 --> 00:05:30,840
>> Mas, por agora, vamos começar a visualizar
uma seqüência como algo nessas caixas

130
00:05:30,840 --> 00:05:31,340
Aqui.

131
00:05:31,340 --> 00:05:36,410
Assim, seis dessas caixas, cada um dos quais
representa um caractere ou "char".

132
00:05:36,410 --> 00:05:40,646
Então, lembrar que "char" - c-h-a-r-- é
um dos tipos de dados embutidos em C.

133
00:05:40,646 --> 00:05:43,520
E o que é bom é que você pode usar
que tipo de como um bloco de construção,

134
00:05:43,520 --> 00:05:47,880
uma peça de quebra-cabeça, se quiser, para formar um
maior tipo de dados que vamos continuar

135
00:05:47,880 --> 00:05:49,410
para chamar uma "cadeia".

136
00:05:49,410 --> 00:05:53,650
>> Agora, o que é útil pensar sobre
sobre coisas como cordas, desta forma?

137
00:05:53,650 --> 00:05:57,720
Bem, acontece que pudermos
realmente aproveitar essa estrutura

138
00:05:57,720 --> 00:06:01,420
para acessar, na verdade, caracteres individuais
de uma forma bastante simples.

139
00:06:01,420 --> 00:06:04,099
Eu estou indo para ir em frente e criar
um arquivo chamado "stringzero.c"

140
00:06:04,099 --> 00:06:05,765
mas você pode chamá-lo de tudo o que você gostaria.

141
00:06:05,765 --> 00:06:08,500
E no site do curso é
Neste exemplo já antes,

142
00:06:08,500 --> 00:06:10,430
assim você não precisa
escreva tudo.

143
00:06:10,430 --> 00:06:13,820
>> E eu estou indo para a frente
e primeiro fazer void main int.

144
00:06:13,820 --> 00:06:15,980
E dentro de poucos dias,
vamos começar a desmembrar

145
00:06:15,980 --> 00:06:19,070
o vazio é aqui, por isso que é
int ao lado principal, e assim por diante.

146
00:06:19,070 --> 00:06:21,180
Mas, por agora, vamos continuar
para copiar e colar isso.

147
00:06:21,180 --> 00:06:23,455
>> Vou declarar uma string chamada s.

148
00:06:23,455 --> 00:06:26,920
E eu vou voltar de
GetString quaisquer que sejam o usuário digita.

149
00:06:26,920 --> 00:06:29,170
Este vai ser um simples
programa, nenhuma instrução,

150
00:06:29,170 --> 00:06:31,336
Eu só vou cegamente
esperar que o usuário saiba

151
00:06:31,336 --> 00:06:32,600
o que fazer para mantê-lo simples.

152
00:06:32,600 --> 00:06:34,220
>> E agora eu vou ter um loop for.

153
00:06:34,220 --> 00:06:37,450
E dentro do meu loop Estou
vai ter int i recebe zero.

154
00:06:37,450 --> 00:06:40,660
E i é, novamente, apenas uma convenção,
um índice de variável de contagem,

155
00:06:40,660 --> 00:06:42,350
mas eu poderia chamar isso o que eu quiser.

156
00:06:42,350 --> 00:06:46,275
Eu vou fazer i é menos than-- bem
O nome de Zamyla é de seis letras.

157
00:06:46,275 --> 00:06:48,150
Então eu vou para o disco
código que não para agora.

158
00:06:48,150 --> 00:06:49,730
>> E então i ++.

159
00:06:49,730 --> 00:06:53,190
E agora dentro destes crespos
chaves eu vou fazer printf,

160
00:06:53,190 --> 00:06:55,460
e eu quero imprimir um
caractere de cada vez.

161
00:06:55,460 --> 00:06:58,227
Então eu vou usar% c para
talvez pela primeira vez.

162
00:06:58,227 --> 00:07:00,560
E então eu quero imprimir cada
personagem em sua própria linha.

163
00:07:00,560 --> 00:07:02,550
Então eu vou colocar uma
pouco barra invertida n lá.

164
00:07:02,550 --> 00:07:03,640
Fechar cotação.

165
00:07:03,640 --> 00:07:06,250
>> E agora eu quero fazer alguma coisa aqui.

166
00:07:06,250 --> 00:07:10,610
Quero imprimir o
letra específica na seqüência,

167
00:07:10,610 --> 00:07:13,670
s, como eu estou interagindo
de zero em até seis.

168
00:07:13,670 --> 00:07:17,150
Em outras palavras, eu quero
imprimir o caráter i'ésima de s.

169
00:07:17,150 --> 00:07:18,420
Agora, como posso fazer isso?

170
00:07:18,420 --> 00:07:21,550
>> Bem assim como as caixas em
esta representação aqui,

171
00:07:21,550 --> 00:07:25,560
tipo, evocar a noção de boxe
letras, você pode fazer da mesma forma que

172
00:07:25,560 --> 00:07:32,630
sintaticamente em C simplesmente especificando,
Quero imprimir s de i'ésima personagem.

173
00:07:32,630 --> 00:07:35,640
Usando os colchetes
no teclado do seu computador

174
00:07:35,640 --> 00:07:38,910
que em um teclado americano são
geralmente acima de sua tecla de retorno.

175
00:07:38,910 --> 00:07:42,630
>> Então isso não está certo
No entanto, como você deve ter notado.

176
00:07:42,630 --> 00:07:44,780
Mas eu estou indo para o tipo de
cegamente avançar aqui.

177
00:07:44,780 --> 00:07:47,020
E eu vou fazer fazer seqüência 0.

178
00:07:47,020 --> 00:07:50,860
Mas antes de eu fazer isso, vamos ver se nós
não pode antecipar alguns erros comuns.

179
00:07:50,860 --> 00:07:52,844
Será que isso vai compilar?

180
00:07:52,844 --> 00:07:54,510
Não, eu estou perdendo um monte de coisas.

181
00:07:54,510 --> 00:07:55,280
Bibliotecas ouvi.

182
00:07:55,280 --> 00:07:58,480
>> Assim que arquivos de cabeçalho
pode Quero acrescentar aqui?

183
00:07:58,480 --> 00:07:59,205
Sim.

184
00:07:59,205 --> 00:08:01,580
>> AUDIÊNCIA: Você precisa
E / S padrão [inaudível]

185
00:08:01,580 --> 00:08:02,663
>> DAVID J. MALAN: Excelente.

186
00:08:02,663 --> 00:08:06,060
Então eu preciso de I / O padrão. Para quê
propósito que eu quero padrão I / O?

187
00:08:06,060 --> 00:08:06,670
Para printf.

188
00:08:06,670 --> 00:08:09,220
Portanto, incluir stdio.h.

189
00:08:09,220 --> 00:08:13,490
E você também propor que incluem
a biblioteca CS50 por qual razão?

190
00:08:13,490 --> 00:08:14,650
Para ter strings.

191
00:08:14,650 --> 00:08:17,780
Então, vamos ver o que
Biblioteca de CS50 está fazendo

192
00:08:17,780 --> 00:08:19,260
para criar essa noção de uma string.

193
00:08:19,260 --> 00:08:21,930
Mas, por enquanto, você pode apenas pensar
nisso como um tipo de dados real.

194
00:08:21,930 --> 00:08:23,596
>> Então, que parece estar um pouco limpo.

195
00:08:23,596 --> 00:08:27,060
E agora eu estou indo para a frente
e de fato fazem seqüência 0.

196
00:08:27,060 --> 00:08:27,700
Compilado.

197
00:08:27,700 --> 00:08:28,370
Então, isso é bom.

198
00:08:28,370 --> 00:08:32,799
Então ./string0 deixe-me aproximar para que possamos
ver mais de perto o que está acontecendo.

199
00:08:32,799 --> 00:08:33,850
Enter.

200
00:08:33,850 --> 00:08:37,789
Z-A-H-Y-L-A entram.

201
00:08:37,789 --> 00:08:39,440
E nós temos impresso ao nome de Zamyla.

202
00:08:39,440 --> 00:08:40,409
>> Então, isso é muito bom.

203
00:08:40,409 --> 00:08:43,220
Então agora vamos seguir em frente e
executar este programa novamente,

204
00:08:43,220 --> 00:08:45,659
e digite o nome completo de Daven.

205
00:08:45,659 --> 00:08:46,450
Surpresa, surpresa.

206
00:08:46,450 --> 00:08:48,021
Enter.

207
00:08:48,021 --> 00:08:48,520
Hmm.

208
00:08:48,520 --> 00:08:51,750
Nós não imprimiu Daven de
primeiro nome completo corretamente.

209
00:08:51,750 --> 00:08:54,250
Agora isso deveria ser óbvio em
retrospecto por causa do que,

210
00:08:54,250 --> 00:08:57,010
tipo, design decisão estúpida?

211
00:08:57,010 --> 00:08:59,590
>> Sim, eu codificado o
seis dentro do meu loop for.

212
00:08:59,590 --> 00:09:01,610
Agora eu fiz isso só porque
Eu sabia o nome de Zamyla

213
00:09:01,610 --> 00:09:02,776
ia ser seis letras.

214
00:09:02,776 --> 00:09:04,720
Mas, certamente, isso não é
uma solução geral.

215
00:09:04,720 --> 00:09:07,720
Então não é que nós podemos de forma dinâmica
calcular o comprimento de uma corda

216
00:09:07,720 --> 00:09:10,440
chamando uma função chamada strlen.

217
00:09:10,440 --> 00:09:12,840
>> Novamente, deliberadamente
sucintamente chamado apenas

218
00:09:12,840 --> 00:09:14,450
para torná-lo mais conveniente para digitar.

219
00:09:14,450 --> 00:09:17,170
Mas isso é sinônimo de
obter o comprimento de uma corda.

220
00:09:17,170 --> 00:09:23,190
Vou voltar para o meu terminal
janela e re-executar o compilador.

221
00:09:23,190 --> 00:09:24,170
Mas está gritando comigo.

222
00:09:24,170 --> 00:09:29,130
Implicitamente declarando função de biblioteca
strlen com tipo unsigned int const--

223
00:09:29,130 --> 00:09:29,780
Estou perdido.

224
00:09:29,780 --> 00:09:30,590
Completamente.

225
00:09:30,590 --> 00:09:32,940
>> Então, especialmente como seu
olhos começam a revirarem

226
00:09:32,940 --> 00:09:36,000
com mensagens de erro como este, o foco
honestamente sobre as primeiras palavras.

227
00:09:36,000 --> 00:09:38,590
Sabemos que o problema está no
linha 8, conforme indicado aqui.

228
00:09:38,590 --> 00:09:40,500
E é em corda-0.c.

229
00:09:40,500 --> 00:09:43,580
Implicitamente declarando
função da biblioteca strlen.

230
00:09:43,580 --> 00:09:47,000
Assim que é geralmente vai
haver um padrão de mensagens de erro.

231
00:09:47,000 --> 00:09:49,190
Implicitamente declarando algo.

232
00:09:49,190 --> 00:09:53,250
>> Então, em suma, que tenho eu parecia
ter feito com relação à linha 8, aqui.

233
00:09:53,250 --> 00:09:56,880
O que poderia ser a solução ser ainda
Se você nunca usou strlen si mesmo?

234
00:09:56,880 --> 00:09:58,907
>> AUDIÊNCIA: Parte de uma biblioteca diferente?

235
00:09:58,907 --> 00:10:00,740
DAVID J. MALAN: Parte
de uma biblioteca diferente.

236
00:10:00,740 --> 00:10:02,400
Por isso, é declarado, por assim dizer.

237
00:10:02,400 --> 00:10:07,510
Ele é mencionado em algum arquivo
excepto stdio.h e CS50.h.

238
00:10:07,510 --> 00:10:09,179
Agora, onde é definida?

239
00:10:09,179 --> 00:10:12,220
Para ser honesto, você tem que apenas
sei que esta em cima da sua cabeça,

240
00:10:12,220 --> 00:10:13,640
ou você Google isso e descobrir.

241
00:10:13,640 --> 00:10:18,150
Ou sabem disso, eu abri na CS50
Aparelho usado o programa do terminal, que

242
00:10:18,150 --> 00:10:22,200
é apenas o grande, versão para a tela cheia de
o que está na parte inferior da janela do gedit.

243
00:10:22,200 --> 00:10:24,970
>> E verifica-se que há uma
comando semelhante sucinto, chamado

244
00:10:24,970 --> 00:10:29,280
homem de manual, onde se você digitar
o nome de uma função e pressione Enter,

245
00:10:29,280 --> 00:10:32,240
você vai voltar bastante
documentação arcano.

246
00:10:32,240 --> 00:10:35,299
É apenas um texto que, geralmente,
parece um pouco algo como isto.

247
00:10:35,299 --> 00:10:37,090
É um pouco esmagadora
à primeira vista.

248
00:10:37,090 --> 00:10:39,048
Mas, sinceramente, eu vou
deixei meus olhos vidrados

249
00:10:39,048 --> 00:10:41,930
e apenas se concentrar na parte
Eu me preocupo com o momento.

250
00:10:41,930 --> 00:10:42,780
>> Qual é este.

251
00:10:42,780 --> 00:10:45,470
Que parece estruturalmente como
algo que eu estou familiarizado.

252
00:10:45,470 --> 00:10:48,080
Na verdade, a página de homem, assim
para falar, vai dizer

253
00:10:48,080 --> 00:10:51,590
no cabeçalho do arquivo que a função
como strlen é definido.

254
00:10:51,590 --> 00:10:54,170
Então, eu vou voltar agora para gedit.

255
00:10:54,170 --> 00:10:59,070
E eu estou indo para ir em frente e
adicionar aqui # include

256
00:10:59,070 --> 00:11:00,480
e salve o arquivo.

257
00:11:00,480 --> 00:11:04,300
>> Eu estou indo para limpar a tela com
Control L Se você estiver se perguntando.

258
00:11:04,300 --> 00:11:08,210
E eu vou fazer re-execute
string.0, compila neste momento.

259
00:11:08,210 --> 00:11:11,790
./string.0 Zamyla.

260
00:11:11,790 --> 00:11:15,020
Isso parecia funcionar Deixe-me ir
em frente e execute-a novamente com Davenport.

261
00:11:15,020 --> 00:11:15,860
Enter.

262
00:11:15,860 --> 00:11:17,730
E que, também, parecia funcionar.

263
00:11:17,730 --> 00:11:21,220
>> Assim, podemos fazer um pouco melhor do que isso,
no entanto, podemos começar a arrumar as coisas

264
00:11:21,220 --> 00:11:23,257
-se um pouco.

265
00:11:23,257 --> 00:11:25,590
E eu vou, na verdade,
introduzir uma outra coisa agora.

266
00:11:25,590 --> 00:11:28,930
Eu estou indo para ir em frente e
salvar esta em um arquivo diferente.

267
00:11:28,930 --> 00:11:31,770
E eu vou chamar
este string1.c arquivo apenas

268
00:11:31,770 --> 00:11:34,620
para ser consistente com o código
você vai ser capaz de encontrar online.

269
00:11:34,620 --> 00:11:37,050
>> E vamos focar em
exatamente o mesmo código.

270
00:11:37,050 --> 00:11:39,000
Acontece que eu tenho
sido uma espécie de tomada

271
00:11:39,000 --> 00:11:42,600
como certo o fato de que meu laptop,
e, por sua vez, o aparelho CS50

272
00:11:42,600 --> 00:11:47,450
tem um monte de memória, um monte de
RAM, uma grande quantidade de bytes de espaço

273
00:11:47,450 --> 00:11:48,920
em que eu possa armazenar strings.

274
00:11:48,920 --> 00:11:53,560
>> Mas a realidade se eu digitei longo
suficientes, e suficiente as teclas digitadas,

275
00:11:53,560 --> 00:11:56,170
Eu poderia, em teoria tipo
em mais caracteres

276
00:11:56,170 --> 00:11:58,830
do que o meu computador
fisicamente tem memória para.

277
00:11:58,830 --> 00:11:59,830
E isso é problemático.

278
00:11:59,830 --> 00:12:03,050
Muito parecido com um int só pode
Quantidade de tão elevada, em teoria,

279
00:12:03,050 --> 00:12:06,600
você só pode empinar tantos personagens
na memória RAM do seu computador ou aleatória

280
00:12:06,600 --> 00:12:07,920
Access Memory.

281
00:12:07,920 --> 00:12:11,140
>> Então, eu tinha melhor antecipar
este problema, mesmo

282
00:12:11,140 --> 00:12:13,660
embora possa ser um raro
caso esquina, por assim dizer.

283
00:12:13,660 --> 00:12:15,670
Não acontece que, muitas vezes, pode acontecer.

284
00:12:15,670 --> 00:12:18,815
E se isso acontecer e eu não
antecipar e programa para que,

285
00:12:18,815 --> 00:12:20,300
meu programa poderia fazer quem sabe o que.

286
00:12:20,300 --> 00:12:22,220
Congelar, travar, reiniciar, o que for.

287
00:12:22,220 --> 00:12:24,490
Algo esperado poderia acontecer.

288
00:12:24,490 --> 00:12:27,120
>> Então o que eu vou fazer
agora, a partir de agora, na verdade,

289
00:12:27,120 --> 00:12:31,630
é antes de eu nunca cegamente
usar uma variável como s que

290
00:12:31,630 --> 00:12:36,790
foi atribuído o valor de retorno de
alguma outra função como getString,

291
00:12:36,790 --> 00:12:40,200
Eu vou ter a certeza
que o seu valor é válido.

292
00:12:40,200 --> 00:12:44,280
Então eu sei que só por ter lido
Documentação do CS50 para getString,

293
00:12:44,280 --> 00:12:49,020
que em última análise, vamos apontá-lo em,
que getString retorna um símbolo especial

294
00:12:49,020 --> 00:12:53,610
chamado NULL, N-L-L-L em todos
CAPS, se algo der errado.

295
00:12:53,610 --> 00:12:55,650
>> Então, normalmente, ele retorna um string.

296
00:12:55,650 --> 00:12:59,700
Mas caso contrário, se ele retorna N-U-L-eu--
vamos finalmente ver o que realmente

297
00:12:59,700 --> 00:13:01,790
means-- isso apenas significa
algo ruim aconteceu.

298
00:13:01,790 --> 00:13:05,560
Agora, isso significa, bem como em risco,
Eu posso verificar uma condição aqui em C,

299
00:13:05,560 --> 00:13:08,830
Se s não é igual a NULL.

300
00:13:08,830 --> 00:13:11,930
Então, se você não vi isso antes,
isto significa apenas não é igual.

301
00:13:11,930 --> 00:13:15,290
>> Então, é o oposto do
iguais iguais, que, recordam,

302
00:13:15,290 --> 00:13:18,940
é diferente da única
é igual, o que é atribuição.

303
00:13:18,940 --> 00:13:23,030
Então, se s não é igual
NULL, só então

304
00:13:23,030 --> 00:13:25,980
Eu quero executar estas linhas de código.

305
00:13:25,980 --> 00:13:28,080
Assim, em outras palavras,
Antes de me aprofundar em cegamente

306
00:13:28,080 --> 00:13:30,919
e iniciar a iteração
sobre s, e tratando-o

307
00:13:30,919 --> 00:13:33,710
como se fosse uma seqüência de
personagens, eu vou para a primeira verificação,

308
00:13:33,710 --> 00:13:37,900
espere um minuto, é definitivamente não
igual a este valor especial, NULL?

309
00:13:37,900 --> 00:13:40,030
>> Porque se for, coisas ruins podem acontecer.

310
00:13:40,030 --> 00:13:43,080
E por agora, assumir as coisas que os maus
acontecendo significa que seu programa trava,

311
00:13:43,080 --> 00:13:45,070
e você não pode necessariamente recuperar.

312
00:13:45,070 --> 00:13:46,800
Então, francamente, parece mais feio.

313
00:13:46,800 --> 00:13:48,660
é meio confuso agora para olhar.

314
00:13:48,660 --> 00:13:50,780
Mas esta se torne mais
familiarizado antes do tempo.

315
00:13:50,780 --> 00:13:52,920
>> Mas eu vou propor
agora uma outra melhoria.

316
00:13:52,920 --> 00:13:54,660
Essa é uma melhoria para correção.

317
00:13:54,660 --> 00:13:58,800
Meu programa agora é mais correta, pois
No caso raro que a memória não é suficiente

318
00:13:58,800 --> 00:14:01,180
existe, eu vou lidar com isso,
e eu simplesmente não fazer nada.

319
00:14:01,180 --> 00:14:02,680
Eu, pelo menos, não vai falhar.

320
00:14:02,680 --> 00:14:05,000
>> Mas vamos fazer uma versão final aqui.

321
00:14:05,000 --> 00:14:07,690
E um arquivo chamado string2.c.

322
00:14:07,690 --> 00:14:10,190
Vou colar esse
mesmo código só por um momento,

323
00:14:10,190 --> 00:14:14,210
e eu estou indo para destacar esta
line, 11, aqui, apenas por um momento.

324
00:14:14,210 --> 00:14:18,179
Agora, a realidade é que os compiladores inteligentes
como Clang poderia consertar isso para nós

325
00:14:18,179 --> 00:14:19,970
nos bastidores
sem o nosso nunca saber.

326
00:14:19,970 --> 00:14:24,670
Mas vamos pensar sobre isso
fundamentalmente como um projeto problemático.

327
00:14:24,670 --> 00:14:29,010
>> Esta linha de código, é claro,
dizendo: inicializar alguns variável i para 0.

328
00:14:29,010 --> 00:14:30,260
Isso é bastante simples.

329
00:14:30,260 --> 00:14:34,691
E o que mais uma vez é esta
declaração, aqui, i ++, fazendo?

330
00:14:34,691 --> 00:14:37,066
Já vimos isso antes, mas nós
realmente não falar sobre isso.

331
00:14:37,066 --> 00:14:37,900
>> AUDIÊNCIA: Incrementando i.

332
00:14:37,900 --> 00:14:39,191
>> DAVID J. MALAN: Incrementando i.

333
00:14:39,191 --> 00:14:41,890
Assim, a cada iteração através
este circuito, cada ciclo,

334
00:14:41,890 --> 00:14:43,570
você está incrementando i por um.

335
00:14:43,570 --> 00:14:45,740
Por isso, se torna maior e maior, e
maior até que o loop termina.

336
00:14:45,740 --> 00:14:46,810
Como isso termina?

337
00:14:46,810 --> 00:14:49,430
Bem, há este meio
condição que usamos antes.

338
00:14:49,430 --> 00:14:52,500
Você já viu e em
instruções passo a passo no conjunto de P.

339
00:14:52,500 --> 00:14:53,880
>> Mas o que é esta palavra?

340
00:14:53,880 --> 00:14:58,352
Faça o seguinte loop para
enquanto i é menor do que o quê?

341
00:14:58,352 --> 00:14:59,810
AUDIÊNCIA: O comprimento da corda.

342
00:14:59,810 --> 00:15:01,518
David J. MALAN: O
comprimento da corda.

343
00:15:01,518 --> 00:15:04,300
Por isso traduz muito limpa
para Inglês nesse sentido.

344
00:15:04,300 --> 00:15:08,810
Agora o problema é que toda vez que eu
iteração através deste ciclo, em teoria,

345
00:15:08,810 --> 00:15:10,000
Eu estou fazendo esta pergunta.

346
00:15:10,000 --> 00:15:12,250
É i menor que o comprimento da cadeia de s?

347
00:15:12,250 --> 00:15:14,500
É i menor que o comprimento da cadeia de s?

348
00:15:14,500 --> 00:15:18,380
>> Agora é i mudando a cada iteração?

349
00:15:18,380 --> 00:15:18,880
É.

350
00:15:18,880 --> 00:15:19,629
Devido à ++.

351
00:15:19,629 --> 00:15:21,700
Assim, a cada iteração i está ficando maior.

352
00:15:21,700 --> 00:15:25,411
Mas é s ficando maior, ou
menor, ou mudar em tudo?

353
00:15:25,411 --> 00:15:25,910
No.

354
00:15:25,910 --> 00:15:30,240
Assim, em termos de design, um dos eixos
ao longo do qual tentamos avaliar o código

355
00:15:30,240 --> 00:15:32,610
na classe, isso parece meio idiota.

356
00:15:32,610 --> 00:15:34,690
>> Como você está literalmente,
em cada iteração

357
00:15:34,690 --> 00:15:37,110
deste laço pedindo a
mesma maldita pergunta novamente,

358
00:15:37,110 --> 00:15:40,770
e de novo, e de novo, e, literalmente,
isso nunca vai mudar.

359
00:15:40,770 --> 00:15:44,220
Pelo menos, se eu não estou tocando s e
tentar mudar o conteúdo de s.

360
00:15:44,220 --> 00:15:46,610
Para que eu possa fazer um pouco melhor do que isso.

361
00:15:46,610 --> 00:15:49,530
>> E o que eu vou fazer não é
declarar apenas uma variável i,

362
00:15:49,530 --> 00:15:53,330
mas uma segunda variável Vou arbitrariamente,
mas convencionalmente, chamá-lo de n.

363
00:15:53,330 --> 00:15:55,940
Atribuir n igual ao
comprimento da corda de s.

364
00:15:55,940 --> 00:15:59,090
E então para cá, eu vou
fazer um pouco de otimização inteligente, de modo

365
00:15:59,090 --> 00:16:03,460
falar, que, no final do dia
não mais correta ou não menos correcta é

366
00:16:03,460 --> 00:16:04,260
do que antes.

367
00:16:04,260 --> 00:16:05,500
Mas é um projeto melhor.

368
00:16:05,500 --> 00:16:09,480
No fato de que eu estou usando
menos tempo, menos ciclos de CPU, de modo

369
00:16:09,480 --> 00:16:14,040
para falar, para responder a mesma
pergunta, mas apenas uma vez.

370
00:16:14,040 --> 00:16:17,870
>> Qualquer dúvida sobre que geral
princípio da melhoria,

371
00:16:17,870 --> 00:16:21,294
dizer, a eficiência de um programa?

372
00:16:21,294 --> 00:16:21,991
Sim?

373
00:16:21,991 --> 00:16:23,699
AUDIÊNCIA: Por que você
usar o [inaudível]?

374
00:16:23,699 --> 00:16:25,760

375
00:16:25,760 --> 00:16:27,010
DAVID J. MALAN: Boa pergunta.

376
00:16:27,010 --> 00:16:30,690
Então, por que colocar o ++ no final de
i em vez de no início do i?

377
00:16:30,690 --> 00:16:33,070
Neste caso, tem
nenhum impacto funcional.

378
00:16:33,070 --> 00:16:36,670
E, em geral, tendem a
usar o operador postfix

379
00:16:36,670 --> 00:16:41,750
de modo que é um pouco mais claro como
para quando a operação está acontecendo.

380
00:16:41,750 --> 00:16:46,670
>> Para quem não conhece, existe uma outra
declarações em que você poderia fazer ++ i.

381
00:16:46,670 --> 00:16:48,747
Estes são funcionalmente
equivalente neste caso

382
00:16:48,747 --> 00:16:51,080
porque não há mais nada
em torno desse incremento.

383
00:16:51,080 --> 00:16:54,435
Mas você pode vir até com
casos e linhas de código

384
00:16:54,435 --> 00:16:55,810
em que isso faz a diferença.

385
00:16:55,810 --> 00:16:57,810
Então, geralmente, não temos
até mesmo falar sobre isso.

386
00:16:57,810 --> 00:17:00,690
Porque, francamente, ele faz o seu
código mais sexy, e uma espécie de vigarista,

387
00:17:00,690 --> 00:17:01,776
e menos caracteres.

388
00:17:01,776 --> 00:17:04,859
Mas a realidade é que é muito mais difícil,
Eu acho que, mesmo para me envolver minha mente

389
00:17:04,859 --> 00:17:07,319
em torno de, por vezes,
a ordem das operações.

390
00:17:07,319 --> 00:17:09,750
Assim como um aparte, se você
realmente não gosto disso,

391
00:17:09,750 --> 00:17:14,650
mesmo que este é o tipo de sexy
procurando, você também pode fazer i + = 1,

392
00:17:14,650 --> 00:17:18,880
que é a versão mais feio do
mesma idéia para postfix incrementação.

393
00:17:18,880 --> 00:17:22,250
>> Digo isso e você
deve fazer o divertimento dele,

394
00:17:22,250 --> 00:17:25,140
mas você vai ver como código
algo bonito em pouco tempo.

395
00:17:25,140 --> 00:17:27,160
>> [Risos]

396
00:17:27,160 --> 00:17:28,410
>> DAVID J. MALAN: Direito?

397
00:17:28,410 --> 00:17:29,360
Sim.

398
00:17:29,360 --> 00:17:30,480
Pergunta no meio.

399
00:17:30,480 --> 00:17:32,146
>> AUDIÊNCIA: Você precisa dizer int n?

400
00:17:32,146 --> 00:17:34,020
DAVID J. MALAN: Você faz
Não precisa dizer int n.

401
00:17:34,020 --> 00:17:37,670
Então, porque já dissemos int,
você não precisa dizer isso de novo.

402
00:17:37,670 --> 00:17:41,820
O problema é que n tem que
ser o mesmo tipo de dados, como eu.

403
00:17:41,820 --> 00:17:43,310
Então, isso é apenas uma conveniência aqui.

404
00:17:43,310 --> 00:17:44,058
Sim.

405
00:17:44,058 --> 00:17:47,806
>> AUDIÊNCIA: Você pode passar por cima da
suporte de impressão de caracteres s i de novo?

406
00:17:47,806 --> 00:17:48,930
DAVID J. MALAN: Absolutamente.

407
00:17:48,930 --> 00:17:52,110
Então,% c, lembrar da última
tempo, é apenas um espaço reservado.

408
00:17:52,110 --> 00:17:53,930
Significa colocar um char aqui.

409
00:17:53,930 --> 00:17:56,780
n invertida, é claro, apenas
meio colocar uma quebra de linha aqui.

410
00:17:56,780 --> 00:17:59,540
Então, isso só deixa, agora,
este pedaço de nova sintaxe.

411
00:17:59,540 --> 00:18:03,730
E este é, literalmente dizendo, grab
a seqüência de chamada s e ir buscar sua

412
00:18:03,730 --> 00:18:06,050
caráter i'ésima, por assim dizer.

413
00:18:06,050 --> 00:18:10,590
>> E eu continuo dizendo caráter i'ésima
porque em cada iteração deste circuito

414
00:18:10,590 --> 00:18:14,540
é como se estamos imprimindo
, em primeiro lugar s suporte 0,

415
00:18:14,540 --> 00:18:15,780
como programador poderia dizer.

416
00:18:15,780 --> 00:18:18,680
Então é faixa 1, em seguida, s
suporte 2, em seguida, 3, 4, em seguida.

417
00:18:18,680 --> 00:18:21,610
Mas é claro que é uma variável,
então eu apenas expressá-la com i.

418
00:18:21,610 --> 00:18:23,900
>> Chave, porém, é perceber,
especialmente se você não ter

419
00:18:23,900 --> 00:18:26,358
se aclimatando a este mundo
de programação, onde todos nós

420
00:18:26,358 --> 00:18:28,950
parecem contar a partir de zero, tem que
começa a contar do zero agora.

421
00:18:28,950 --> 00:18:35,130
Porque cordas, primeiro caractere, o
z em Zamyla é para melhor ou para pior

422
00:18:35,130 --> 00:18:40,490
vai viver no número de localização zero.

423
00:18:40,490 --> 00:18:48,210
>> Tudo bem, então deixe-me trazer
nos de volta aqui para Zamyla

424
00:18:48,210 --> 00:18:50,746
e ver o que realmente está acontecendo
por baixo do capô.

425
00:18:50,746 --> 00:18:52,370
Portanto, não há essa noção de type casting.

426
00:18:52,370 --> 00:18:53,800
Você pode ter, na verdade,
jogado com isso já,

427
00:18:53,800 --> 00:18:55,970
talvez para o hacker
edição do P definido.

428
00:18:55,970 --> 00:19:00,320
Mas type casting apenas se refere ao
habilidade em C e outras linguagens

429
00:19:00,320 --> 00:19:03,170
para converter um tipo de dados para outro.

430
00:19:03,170 --> 00:19:05,450
>> Agora como podemos ver isso
muito direta?

431
00:19:05,450 --> 00:19:08,530
Então isso, lembre-se, é o começo
do alfabeto Inglês.

432
00:19:08,530 --> 00:19:11,265
E o contexto, recordar, a partir de
como há uma semana é ASCII.

433
00:19:11,265 --> 00:19:13,790
A American Standard Code
for Information Interchange.

434
00:19:13,790 --> 00:19:17,080
Que é apenas um longo caminho
de dizer um mapeamento a partir de cartas

435
00:19:17,080 --> 00:19:19,370
de números, e de números para letras.

436
00:19:19,370 --> 00:19:22,940
>> Então, de A a M aqui, dot dot
ponto, alinhado com, recall,

437
00:19:22,940 --> 00:19:25,582
o número decimal 65 em cima.

438
00:19:25,582 --> 00:19:27,290
E nós não falamos
sobre isso explicitamente,

439
00:19:27,290 --> 00:19:29,850
mas certamente há semelhante
números às letras minúsculas.

440
00:19:29,850 --> 00:19:30,820
E, de fato, existem.

441
00:19:30,820 --> 00:19:33,730
O mundo decidiu há alguns anos
atrás que um pouco, minúsculas a,

442
00:19:33,730 --> 00:19:35,020
vai ser 97.

443
00:19:35,020 --> 00:19:38,010
E pouco b vai
igual a 98, e assim por diante.

444
00:19:38,010 --> 00:19:40,200
>> E para qualquer outra tecla na
seu teclado, há

445
00:19:40,200 --> 00:19:42,190
Vai ser um padrão semelhante de bits.

446
00:19:42,190 --> 00:19:44,540
Ou equivalentemente, um número decimal.

447
00:19:44,540 --> 00:19:47,110
Então, a questão em apreço,
então, é como podemos

448
00:19:47,110 --> 00:19:49,400
realmente ver esta debaixo do capô?

449
00:19:49,400 --> 00:19:51,539
Então, eu estou indo para ir para gedit novamente.

450
00:19:51,539 --> 00:19:53,330
E em vez de Tipo
este a partir do zero,

451
00:19:53,330 --> 00:19:55,330
Eu estou indo para ir em frente e
basta abrir mão de algo

452
00:19:55,330 --> 00:19:58,350
a partir do código de hoje chamado ASCII zero.

453
00:19:58,350 --> 00:20:01,210
>> E zero ASCII se parece com isso.

454
00:20:01,210 --> 00:20:02,710
Então, vamos envolver nossas mentes em torno deste.

455
00:20:02,710 --> 00:20:04,969
Então, primeiro, eu comentei
o código, que é bom.

456
00:20:04,969 --> 00:20:07,010
Porque é literalmente
me dizendo o que esperar,

457
00:20:07,010 --> 00:20:08,950
apresentar um mapeamento para letras maiúsculas.

458
00:20:08,950 --> 00:20:13,690
Agora eu não sei bem o que eu
quer dizer com isso, então vamos inferir.

459
00:20:13,690 --> 00:20:16,870
>> Em Inglês, talvez
Inglês um pouco techie,

460
00:20:16,870 --> 00:20:20,660
o que faz a linha 18 aparecem
estar fazendo por nós?

461
00:20:20,660 --> 00:20:21,500
Apenas a linha 18.

462
00:20:21,500 --> 00:20:22,430
O que é que a indução?

463
00:20:22,430 --> 00:20:25,192
O que é que vai começar aqui?

464
00:20:25,192 --> 00:20:26,100
>> AUDIÊNCIA: Um loop.

465
00:20:26,100 --> 00:20:26,630
>> DAVID J. MALAN: Um loop.

466
00:20:26,630 --> 00:20:28,463
E quantas vezes é
que vai fazer uma iteração?

467
00:20:28,463 --> 00:20:31,562

468
00:20:31,562 --> 00:20:33,270
AUDIÊNCIA: [interpondo VOZES]
seis vezes.

469
00:20:33,270 --> 00:20:34,830
DAVID J. MALAN: não seis vezes.

470
00:20:34,830 --> 00:20:35,840
AUDIÊNCIA: 26 vezes.

471
00:20:35,840 --> 00:20:36,560
David J. MALAN: 26 vezes.

472
00:20:36,560 --> 00:20:37,060
Sim, desculpe.

473
00:20:37,060 --> 00:20:37,960
26 vezes.

474
00:20:37,960 --> 00:20:38,460
Por quê?

475
00:20:38,460 --> 00:20:41,590
Bem, é um pouco estranho, mas
Eu comecei a contar a partir de 65 anos.

476
00:20:41,590 --> 00:20:43,300
O que é estranho, mas não é errado.

477
00:20:43,300 --> 00:20:44,610
Não é ruim por dizer.

478
00:20:44,610 --> 00:20:46,980
E eu estou fazendo isso só
porque, para este exemplo,

479
00:20:46,980 --> 00:20:50,455
Eu sou o tipo de antecipação
que o capital A foi de 65.

480
00:20:50,455 --> 00:20:53,330
Agora, isso não é o mais elegante
maneira de fazer isso, a espécie de código rígido

481
00:20:53,330 --> 00:20:56,130
valores esotéricos que ninguém
é sempre esperado para recordar.

482
00:20:56,130 --> 00:21:00,155
>> Mas, por agora, perceber que eu sou
fazendo isso através de 65 mais 26.

483
00:21:00,155 --> 00:21:03,030
Porque, aparentemente, eu não quero nem
para fazer a aritmética na minha cabeça.

484
00:21:03,030 --> 00:21:04,440
Então eu vou deixar o compilador fazê-lo.

485
00:21:04,440 --> 00:21:08,600
Mas, então, em cada ciclo, cada iteração
do circuito, estou incrementando i.

486
00:21:08,600 --> 00:21:10,196
>> Então, agora isso parece um pouco enigmática.

487
00:21:10,196 --> 00:21:13,320
Mas devemos ter o básico de construção
blocos com que entender isso.

488
00:21:13,320 --> 00:21:15,510
% C é apenas um espaço reservado para um char.

489
00:21:15,510 --> 00:21:19,010
% I é um espaço reservado para um int.

490
00:21:19,010 --> 00:21:23,310
E verifica-se que, ao utilizar este
nova sintaxe, este parêntesis, então

491
00:21:23,310 --> 00:21:26,100
falar, portanto, um tipo de dados
dentro de um parêntesis

492
00:21:26,100 --> 00:21:32,270
Eu posso forçar o compilador a tratar
i não é um número inteiro, mas como um char.

493
00:21:32,270 --> 00:21:35,520
>> Assim, me mostrando o caráter
equivalente a esse número.

494
00:21:35,520 --> 00:21:37,986
Agora aqui em baixo, este código
é praticamente idêntico.

495
00:21:37,986 --> 00:21:39,860
Eu só queria fazer
Super explícito o fato de

496
00:21:39,860 --> 00:21:42,095
que eu estou começando a 97,
o que é minúsculo a.

497
00:21:42,095 --> 00:21:44,080
Na acima por mais 26 letras.

498
00:21:44,080 --> 00:21:46,970
E eu estou doing-- novamente,
lançando i, por assim dizer.

499
00:21:46,970 --> 00:21:49,160
Ou type casting i, por assim dizer.

500
00:21:49,160 --> 00:21:51,420
>> A partir de um int para um char.

501
00:21:51,420 --> 00:21:55,760
Assim, o resultado final vai ser,
francamente, informações que já sabemos.

502
00:21:55,760 --> 00:21:59,411
Eu vou fazer
ascii-0 não dot-- ponto c.

503
00:21:59,411 --> 00:22:02,160
Observe, você provavelmente fez isso
erro que eu só fiz acidentalmente.

504
00:22:02,160 --> 00:22:03,820
Faça ascii-0.

505
00:22:03,820 --> 00:22:06,090
Agora eu vou fazer ./ascii-0.

506
00:22:06,090 --> 00:22:09,050
Vou aumentar o zoom, e, infelizmente,
vai rolar para fora da tela.

507
00:22:09,050 --> 00:22:15,060
Mas vemos um gráfico inteiro onde
a mapas a 97, b mapas para 98,

508
00:22:15,060 --> 00:22:18,931
e se deslocar para cima ainda mais
Um, é claro, mapeia a 65.

509
00:22:18,931 --> 00:22:21,180
Então, isso é só para dizer que
o que tenho pregado,

510
00:22:21,180 --> 00:22:25,310
há essa equivalência, é
de facto, o caso na realidade.

511
00:22:25,310 --> 00:22:28,000
Assim, uma modificação rápida da presente.

512
00:22:28,000 --> 00:22:31,220
Deixe-me abrir ascii-1.c.

513
00:22:31,220 --> 00:22:38,070
E perceber isso inteligente, tipo
de, a clarificação deste.

514
00:22:38,070 --> 00:22:41,770
Esta é ascii-1.c, e
perceber essa coisa louca.

515
00:22:41,770 --> 00:22:45,120
>> E isso realmente chega ao coração
de que os computadores estão fazendo.

516
00:22:45,120 --> 00:22:48,150
Mesmo que nós seres humanos pudéssemos
não contam em termos de letters--

517
00:22:48,150 --> 00:22:50,380
Eu não começar a pensar,
Tudo bem, então um b,

518
00:22:50,380 --> 00:22:52,590
e usá-las para contar objetos físicos.

519
00:22:52,590 --> 00:22:58,680
Você pode certamente dizer que eu quero
inicializar alguns variável chamada C--

520
00:22:58,680 --> 00:23:03,220
mas eu poderia ter chamado este qualquer coisa--
então c é inicializado ao capital A.

521
00:23:03,220 --> 00:23:07,560
>> Porque no final do dia, o computador
não importa o que você está armazenando,

522
00:23:07,560 --> 00:23:10,170
ele só se importa como você quer
apresentar essa informação.

523
00:23:10,170 --> 00:23:13,560
Como você quer que o computador
interpretar esse padrão de bits?

524
00:23:13,560 --> 00:23:16,320
Então isso não é algo que eu
, em geral, recomendo fazer.

525
00:23:16,320 --> 00:23:19,500
É realmente apenas um exemplo para
saber que você pode absolutamente

526
00:23:19,500 --> 00:23:22,049
inicializar um inteiro para um char.

527
00:23:22,049 --> 00:23:24,090
Devido ao baixo
capô de um char, é claro,

528
00:23:24,090 --> 00:23:26,170
é apenas um número de 0 a 255.

529
00:23:26,170 --> 00:23:28,540
>> Assim, você pode certamente
colocá-lo dentro de um int.

530
00:23:28,540 --> 00:23:30,890
E o que isso também
demonstra é que nós

531
00:23:30,890 --> 00:23:34,040
pode converter de um
tipo para outro, aqui,

532
00:23:34,040 --> 00:23:36,780
em última análise, a impressão do mesmo.

533
00:23:36,780 --> 00:23:44,760
E, de fato, isso eu vou corrigir online--
era para dizer isso, mais uma vez, aqui.

534
00:23:44,760 --> 00:23:48,610
Deixe-me limpar isso on-line, e nós vamos
ver em um passo a passo on-line, se necessário,

535
00:23:48,610 --> 00:23:50,280
o que se pretende não.

536
00:23:50,280 --> 00:23:50,960
>> Está bem.

537
00:23:50,960 --> 00:23:53,892
Assim último exemplo, agora envolvendo
A e B e, em seguida, nós vamos

538
00:23:53,892 --> 00:23:54,850
levar as coisas acima de um entalhe.

539
00:23:54,850 --> 00:23:58,330
Assim, com um e B e
c está na capitalização

540
00:23:58,330 --> 00:24:01,560
e a equivalência destes, vamos
dê uma olhada neste exemplo, aqui.

541
00:24:01,560 --> 00:24:02,752
Outro exemplo de código.

542
00:24:02,752 --> 00:24:04,460
Vamos abrir um que é
já realizados, para que

543
00:24:04,460 --> 00:24:06,440
não precisa digitá-lo
tudo a partir do zero.

544
00:24:06,440 --> 00:24:09,420
>> E observe, em antecipação
estamos usando cabeçalho múltipla

545
00:24:09,420 --> 00:24:13,240
arquivos, entre os quais se
nosso novo amigo, string.h.

546
00:24:13,240 --> 00:24:15,597
Agora isso parece, à primeira
vista, um pouco enigmática.

547
00:24:15,597 --> 00:24:18,180
Mas vamos ver se não podemos raciocinar
através do que está acontecendo aqui.

548
00:24:18,180 --> 00:24:21,150
Primeiro eu tenho uma string do usuário,
e eu coloquei essa string em uma variável

549
00:24:21,150 --> 00:24:22,286
chamados s.

550
00:24:22,286 --> 00:24:24,090
Copiar de antes.

551
00:24:24,090 --> 00:24:27,250
Na linha 22, sou aparentemente
fazendo exatamente o que

552
00:24:27,250 --> 00:24:30,760
Eu fiz há pouco, estou interagindo
sobre os personagens de s.

553
00:24:30,760 --> 00:24:34,780
>> E os novos truques aqui estão usando
comprimento da corda, a otimização menor

554
00:24:34,780 --> 00:24:37,930
de armazenar o comprimento da corda em n,
Em vez de chamar strlen novamente,

555
00:24:37,930 --> 00:24:38,850
e de novo, e de novo.

556
00:24:38,850 --> 00:24:41,120
E apenas verificando que i é menor que n.

557
00:24:41,120 --> 00:24:43,330
Agora, aqui, as coisas ficam
um pouco interessante.

558
00:24:43,330 --> 00:24:45,980
Mas é apenas uma aplicação
desta mesma idéia nova.

559
00:24:45,980 --> 00:24:48,470
O que faz em Inglês
s suporte i representa?

560
00:24:48,470 --> 00:24:51,772

561
00:24:51,772 --> 00:24:54,260
>> AUDIÊNCIA: Contando cada
caráter [inaudível].

562
00:24:54,260 --> 00:24:55,926
>> DAVID J. MALAN: Contando cada personagem.

563
00:24:55,926 --> 00:24:58,680
E ainda mais sucinta,
s suporte i representam o que?

564
00:24:58,680 --> 00:25:00,950
Você diria.

565
00:25:00,950 --> 00:25:04,084
Não colocá-lo no local aqui.

566
00:25:04,084 --> 00:25:06,375
>> AUDIÊNCIA: Bem--

567
00:25:06,375 --> 00:25:09,500
DAVID J. MALAN: Então, se a palavra é-- se
a corda é Zamyla, que starts--

568
00:25:09,500 --> 00:25:12,380
AUDIÊNCIA: --você lidar com
os caracteres separately--

569
00:25:12,380 --> 00:25:13,690
DAVID J. MALAN: Good.

570
00:25:13,690 --> 00:25:14,190
Exatamente.

571
00:25:14,190 --> 00:25:17,940
A notação colchete permite
para acessar cada personagem individualmente,

572
00:25:17,940 --> 00:25:21,120
então s suporte 0 vai ser o
primeiro caractere na string.

573
00:25:21,120 --> 00:25:24,110
s suporte 1 vai ser
o segundo, e assim por diante.

574
00:25:24,110 --> 00:25:28,050
Então, a pergunta que eu estou pedindo,
aqui, nesta condição é o quê?

575
00:25:28,050 --> 00:25:33,984
O personagem i'ésima de s maior
ou igual a um minúsculas?

576
00:25:33,984 --> 00:25:36,400
E o que isso significa, aqui,
com as duplas e comercial?

577
00:25:36,400 --> 00:25:36,800
AUDIÊNCIA (em conjunto): E.

578
00:25:36,800 --> 00:25:37,210
DAVID J. MALAN: E.

579
00:25:37,210 --> 00:25:38,418
É apenas o equivalente a isso.

580
00:25:38,418 --> 00:25:42,310
E não é uma palavra-chave em C, você tem que
uso, irritantemente, comercial e comercial.

581
00:25:42,310 --> 00:25:47,520
E isso, por outro lado, está a pedir é
s de i'ésima caráter inferiores ou iguais

582
00:25:47,520 --> 00:25:49,030
para minúsculas z?

583
00:25:49,030 --> 00:25:52,440
E mais uma vez, aqui é onde
compreender o subjacente

584
00:25:52,440 --> 00:25:54,550
implementação de um
computador faz sentido.

585
00:25:54,550 --> 00:25:57,330
Observe que, apesar de eu ter
o dot dot dot lá,

586
00:25:57,330 --> 00:26:04,410
Parece que de A a Z em minúsculas são
todos os valores de 97 contíguas superior em cima.

587
00:26:04,410 --> 00:26:07,820
>> E mesmo para maiúsculas a partir de 65.

588
00:26:07,820 --> 00:26:10,410
Assim, o takeaway, então,
é que, em Inglês,

589
00:26:10,410 --> 00:26:12,760
como você descreveria
que linha 24 está fazendo?

590
00:26:12,760 --> 00:26:15,736

591
00:26:15,736 --> 00:26:16,728
Sim?

592
00:26:16,728 --> 00:26:21,575
>> AUDIÊNCIA: No dia 24 é a verificação para ver
se cada personagem é uma minúscula.

593
00:26:21,575 --> 00:26:24,700
DAVID J. MALAN: É verificar se
cada personagem é uma letra minúscula.

594
00:26:24,700 --> 00:26:28,590
Assim, mesmo de forma mais sucinta, é o
caráter i'ésima de s minúsculas?

595
00:26:28,590 --> 00:26:30,690
Isso é tudo o que somos
expressar aqui, logicamente,

596
00:26:30,690 --> 00:26:33,750
um pouco enigmático, mas
em última análise, muito direta.

597
00:26:33,750 --> 00:26:36,480
É S de i'ésima letra minúscula?

598
00:26:36,480 --> 00:26:40,130
>> Se assim for, e aqui é onde as coisas
ficar um pouco mente dobra

599
00:26:40,130 --> 00:26:44,760
só por um momento, se assim for, vá
em frente e imprimir um caráter.

600
00:26:44,760 --> 00:26:47,360
Portanto, este é apenas um espaço reservado,
mas o personagem?

601
00:26:47,360 --> 00:26:53,710
Por que estou fazendo s suporte de i
menos essa expressão aqui?

602
00:26:53,710 --> 00:26:55,110
>> Bem perceber o padrão aqui.

603
00:26:55,110 --> 00:26:57,380
Os números reais não importam tanto.

604
00:26:57,380 --> 00:27:02,700
Mas note que 97 é
quão longe de 65?

605
00:27:02,700 --> 00:27:03,560
>> AUDIÊNCIA: 32.

606
00:27:03,560 --> 00:27:04,480
>> DAVID J. MALAN: 32.

607
00:27:04,480 --> 00:27:06,890
A que distância é de 98 a partir de 66?

608
00:27:06,890 --> 00:27:07,740
>> AUDIÊNCIA: 32.

609
00:27:07,740 --> 00:27:09,890
>> DAVID J. MALAN: Pouco c de grande C?

610
00:27:09,890 --> 00:27:10,420
32.

611
00:27:10,420 --> 00:27:14,550
Portanto, há 32 saltos de
uma carta para o outro.

612
00:27:14,550 --> 00:27:17,790
Então, sinceramente, eu, poderia
simplificar este àquele.

613
00:27:17,790 --> 00:27:20,400
Mas então eu estou codificação um pouco difícil
esta compreensão baixo nível

614
00:27:20,400 --> 00:27:21,740
que não é sempre leitor
vai entender.

615
00:27:21,740 --> 00:27:25,080
Então eu vou generalizar-lo como eu
conhecer as letras minúsculas são maiores.

616
00:27:25,080 --> 00:27:28,400
Eu sei que as letras maiúsculas são
valores menores, ironicamente.

617
00:27:28,400 --> 00:27:33,216
>> Mas esta é efectivamente equivalentes aos
dizendo subtrair 32 de s suporte de i.

618
00:27:33,216 --> 00:27:35,430
Assim, no âmbito destes
letras, se a carta

619
00:27:35,430 --> 00:27:38,950
passa a ser, uma minúscula
um, e eu subtrair 32,

620
00:27:38,950 --> 00:27:43,442
qual o efeito que isso tem,
matematicamente, em letras minúsculas de a?

621
00:27:43,442 --> 00:27:44,400
AUDIÊNCIA: Capitalizes--

622
00:27:44,400 --> 00:27:45,691
David J. MALAN: Capitalizes ele.

623
00:27:45,691 --> 00:27:48,440
E, de fato, é por isso que o nosso
programa é chamado de capitalizar zero.

624
00:27:48,440 --> 00:27:51,590
Este programa quer
capitaliza uma carta,

625
00:27:51,590 --> 00:27:54,580
depois de verificar se é
na verdade, uma letra minúscula.

626
00:27:54,580 --> 00:27:59,810
Caso contrário, na linha 30, o que devo fazer se
não é uma letra minúscula que eu sou

627
00:27:59,810 --> 00:28:02,852
olhando numa determinada
iteração do loop.

628
00:28:02,852 --> 00:28:03,890
Basta imprimi-lo.

629
00:28:03,890 --> 00:28:07,010
>> Portanto, não mudar coisas
isso não é mesmo minúsculas.

630
00:28:07,010 --> 00:28:10,790
Restringir-se a
um pouco através pouco z.

631
00:28:10,790 --> 00:28:12,730
Agora isso é bastante misterioso.

632
00:28:12,730 --> 00:28:15,230
Contudo, no final do dia, esta
É assim que, certa vez,

633
00:28:15,230 --> 00:28:16,460
teve que implementar coisas.

634
00:28:16,460 --> 00:28:19,780
Se eu, em vez aberto capitalizar
um, oh graças a Deus.

635
00:28:19,780 --> 00:28:22,320
Há uma função
chamados a superior que pode

636
00:28:22,320 --> 00:28:25,410
fazer tudo o que acabamos de fazer
a um nível relativamente baixo.

637
00:28:25,410 --> 00:28:28,752
>> Agora, para superior é interessante
porque ele é declarado em um arquivo,

638
00:28:28,752 --> 00:28:31,210
e você só saberia disso
verificando a documentação,

639
00:28:31,210 --> 00:28:35,730
ou sendo dito, por exemplo, em sala de aula, onde
ele existe, num ctype.h arquivo chamado.

640
00:28:35,730 --> 00:28:37,630
Portanto, este é um novo amigo nosso.

641
00:28:37,630 --> 00:28:40,750
E superior faz exatamente
o que seu nome sugere.

642
00:28:40,750 --> 00:28:44,860
>> Você pode passar, como argumento, entre
estes parênteses, algum personagem.

643
00:28:44,860 --> 00:28:48,390
Vou passar no caráter i'ésima
de s usando nossa nova notação fantasia

644
00:28:48,390 --> 00:28:49,870
envolvendo colchetes.

645
00:28:49,870 --> 00:28:53,391
E dar um palpite, que é o retorno
valor superior a, aparentemente, vai

646
00:28:53,391 --> 00:28:53,890
ser?

647
00:28:53,890 --> 00:28:56,460

648
00:28:56,460 --> 00:28:57,770
A letra maiúscula.

649
00:28:57,770 --> 00:28:58,620
A letra maiúscula.

650
00:28:58,620 --> 00:29:02,330
>> Então, se eu passar em letras minúsculas a,
espero que, por definição de para superior,

651
00:29:02,330 --> 00:29:05,600
ele vai retornar um
maiúscula A. Caso contrário,

652
00:29:05,600 --> 00:29:08,590
se não é uma letra minúscula em
primeiro lugar, eu só imprimi-lo.

653
00:29:08,590 --> 00:29:10,800
E, de fato, observe a
segundo amigo aqui.

654
00:29:10,800 --> 00:29:13,840
Não apenas a parte superior existe,
mas é mais baixa, o qual

655
00:29:13,840 --> 00:29:16,200
na verdade, responde a essa pergunta para mim.

656
00:29:16,200 --> 00:29:19,730
>> Agora quem escreveu essas coisas,
10s de anos atrás, você sabe o quê?

657
00:29:19,730 --> 00:29:23,840
Implementado para superior e é
baixar usando um código como este.

658
00:29:23,840 --> 00:29:27,270
Mas, novamente, consistente com
essa idéia de abstrair,

659
00:29:27,270 --> 00:29:29,190
tipo, nível mais baixo
detalhes de implementação.

660
00:29:29,190 --> 00:29:32,600
E de pé sobre os ombros de pessoas
que vieram antes de nós, através de funções

661
00:29:32,600 --> 00:29:36,300
como a parte superior e inferior é, que
maravilhosamente suficiente são bem

662
00:29:36,300 --> 00:29:40,190
chamado para dizer o que eles fazem, é
um paradigma maravilhoso para adotar.

663
00:29:40,190 --> 00:29:44,040
>> Agora, acontece que se eu ler
a página man para, digamos, a parte superior,

664
00:29:44,040 --> 00:29:45,010
Eu aprendo algo mais.

665
00:29:45,010 --> 00:29:46,890
Assim, o homem toupper.

666
00:29:46,890 --> 00:29:48,050
É um pouco esmagadora.

667
00:29:48,050 --> 00:29:51,110
Mas aviso, aqui está que a menção de
o arquivo de cabeçalho que eu deveria usar.

668
00:29:51,110 --> 00:29:54,460
Como um aparte, porque esta
é enganosa, a função

669
00:29:54,460 --> 00:29:59,070
usa inteiros em vez de caracteres
por razões de verificação de erros.

670
00:29:59,070 --> 00:30:01,260
Mas vamos talvez venha
de volta para que, no futuro.

671
00:30:01,260 --> 00:30:05,910
>> Mas note, aqui, aos convertidos superiores
a letra c em maiúsculas, se possível.

672
00:30:05,910 --> 00:30:07,674
Então, isso é bastante simples.

673
00:30:07,674 --> 00:30:09,340
E agora vamos ser um pouco mais específico.

674
00:30:09,340 --> 00:30:12,750
Vamos olhar para a parte do
página do manual sobre valor de retorno.

675
00:30:12,750 --> 00:30:15,420
O valor retornado é que
da carta convertido.

676
00:30:15,420 --> 00:30:18,690
Ou c, se a conversão
não foi possível,

677
00:30:18,690 --> 00:30:20,250
em que c é a entrada original.

678
00:30:20,250 --> 00:30:24,140
Que eu sei que a partir daqui, a partir de
o argumento para a superior.

679
00:30:24,140 --> 00:30:25,780
>> Então, qual é o takeaway isso?

680
00:30:25,780 --> 00:30:28,060
O valor retornado é que
da carta convertido,

681
00:30:28,060 --> 00:30:32,110
ou c, a letra original, se
a conversão não foi possível.

682
00:30:32,110 --> 00:30:36,460
O que melhora posso, portanto,
fazer o projeto do meu código?

683
00:30:36,460 --> 00:30:37,146
Sim?

684
00:30:37,146 --> 00:30:38,810
>> AUDIÊNCIA: Você pode remover o resto.

685
00:30:38,810 --> 00:30:40,810
DAVID J. MALAN: eu puder
remova a instrução else,

686
00:30:40,810 --> 00:30:42,510
e não apenas a instrução else.

687
00:30:42,510 --> 00:30:44,150
>> AUDIÊNCIA: Você pode remover [inaudível].

688
00:30:44,150 --> 00:30:46,310
>> DAVID J. MALAN: eu puder
remover todo o garfo

689
00:30:46,310 --> 00:30:48,209
na estrada, o caso mais completo.

690
00:30:48,209 --> 00:30:50,250
Então, na verdade, deixe-me abrir
a versão final deste,

691
00:30:50,250 --> 00:30:55,540
capitalizar-2 e perceber o quão, se
você vai, sexy, o código está começando agora,

692
00:30:55,540 --> 00:31:00,040
em que eu reduzido de alguns
sete ou mais linhas para apenas quatro,

693
00:31:00,040 --> 00:31:03,850
a funcionalidade que eu pretendia
simplesmente chamando a superior,

694
00:31:03,850 --> 00:31:09,410
passando s suporte de i, e impressão
para fora, com o espaço reservado% c,

695
00:31:09,410 --> 00:31:11,090
que o caráter particular.

696
00:31:11,090 --> 00:31:14,560
>> Agora, sem dúvida, não é um erro,
ou, pelo menos, o risco de um erro,

697
00:31:14,560 --> 00:31:15,350
neste programa.

698
00:31:15,350 --> 00:31:18,200
Então, só para voltar
para uma viagem mais cedo,

699
00:31:18,200 --> 00:31:21,820
o que devo fazer, provavelmente, também em
este programa para torná-lo mais robusto,

700
00:31:21,820 --> 00:31:24,974
de modo que não há nenhuma maneira ele pode
falhar, mesmo em casos raros?

701
00:31:24,974 --> 00:31:26,390
AUDIÊNCIA: Certifique-se de que não é NULL.

702
00:31:26,390 --> 00:31:28,056
DAVID J. MALAN: Certifique-se de que não é NULL.

703
00:31:28,056 --> 00:31:31,030
Então, realmente, para fazer este super
bom, eu deveria fazer algo como:

704
00:31:31,030 --> 00:31:35,300
Se s não for nulo, então
vá em frente e executar

705
00:31:35,300 --> 00:31:38,470
estas linhas de código, que
Eu posso então travessão assim,

706
00:31:38,470 --> 00:31:39,870
e, em seguida, colocar na minha chave de fechamento.

707
00:31:39,870 --> 00:31:41,550
Tão bom subordinação junto das duas idéias.

708
00:31:41,550 --> 00:31:42,429
Sim?

709
00:31:42,429 --> 00:31:44,470
AUDIÊNCIA: Você poderia usar
um loop Do While, em vez disso?

710
00:31:44,470 --> 00:31:47,270
DAVID J. MALAN: Could
Eu faço um loop Do While?

711
00:31:47,270 --> 00:31:50,020
AUDIÊNCIA: --você quer certificar-se
que você realmente [inaudível].

712
00:31:50,020 --> 00:31:51,728
DAVID J. MALAN: Could
você usa um do tempo?

713
00:31:51,728 --> 00:31:52,450
Resposta curta, não.

714
00:31:52,450 --> 00:31:54,700
Porque você está prestes a
introduzir um outro caso canto.

715
00:31:54,700 --> 00:31:56,660
Se a string é de comprimento zero.

716
00:31:56,660 --> 00:31:59,600
Se, por exemplo, eu só bater
Enter, sem nunca digitando Zamyla.

717
00:31:59,600 --> 00:32:02,490
Vou entregá-lo de volta um real
corda, como vamos finalmente ver,

718
00:32:02,490 --> 00:32:03,780
que tem zero caracteres.

719
00:32:03,780 --> 00:32:05,630
Ainda é uma string,
é apenas super curto.

720
00:32:05,630 --> 00:32:07,960
Mas se você usar um do tempo,
você vai cegamente

721
00:32:07,960 --> 00:32:10,050
tentar fazer algo com
relação a essa seqüência,

722
00:32:10,050 --> 00:32:12,537
e nada vai estar lá.

723
00:32:12,537 --> 00:32:18,607
>> AUDIÊNCIA: Bem, se você fez
fazer [inaudível] enquanto s--

724
00:32:18,607 --> 00:32:21,190
DAVID J. MALAN: Oh, eu vejo, manter
recebendo uma string do usuário.

725
00:32:21,190 --> 00:32:23,525
Resposta tão curta, você
poderia, e manter importunando

726
00:32:23,525 --> 00:32:26,150
lhes dar-lhe uma cadeia que é
curta o suficiente para caber na memória.

727
00:32:26,150 --> 00:32:26,700
Absolutamente.

728
00:32:26,700 --> 00:32:27,630
Eu só não quis.

729
00:32:27,630 --> 00:32:30,505
Se eles não me dão a seqüência I
quiser, eu vou desistir, eu vou desistir.

730
00:32:30,505 --> 00:32:33,260
Mas, absolutamente, para esse efeito,
você pode absolutamente fazer isso.

731
00:32:33,260 --> 00:32:37,500
>> Assim, arquivos de cabeçalho da biblioteca que
agora estamos familiarizados com são estes, aqui.

732
00:32:37,500 --> 00:32:41,550
Padrão I / O, CS50.h, string.h,
ctype.h, e há, de fato, outros.

733
00:32:41,550 --> 00:32:44,460
Alguns de vocês já descobriram
a biblioteca de matemática em math.h.

734
00:32:44,460 --> 00:32:48,200
Mas deixe-me apresentar-lhe, agora, a
este recurso que o pessoal CS50, Davin,

735
00:32:48,200 --> 00:32:50,630
e Rob, e Gabe especial
têm juntos.

736
00:32:50,630 --> 00:32:52,630
Que em breve ligação em
site do curso.

737
00:32:52,630 --> 00:32:54,870
É chamado CS50 referência.

738
00:32:54,870 --> 00:32:58,230
>> Que só para lhe dar um rápido
gosto disso, funciona como se segue.

739
00:32:58,230 --> 00:33:00,740
Deixe-me ir para reference.cs50.net.

740
00:33:00,740 --> 00:33:02,990
Você vai ver na mão esquerda
o outro uma lista esmagadora

741
00:33:02,990 --> 00:33:04,595
de funções que vêm com c.

742
00:33:04,595 --> 00:33:07,790
Mas se eu me importo, para o momento,
sobre algo como strlen,

743
00:33:07,790 --> 00:33:08,746
I pode digitá-lo lá.

744
00:33:08,746 --> 00:33:10,870
Ele filtra a lista
apenas o que me interessa.

745
00:33:10,870 --> 00:33:11,940
Vou clique nele.

746
00:33:11,940 --> 00:33:14,740
E agora sobre a esquerda,
você vai ver o que nós esperamos

747
00:33:14,740 --> 00:33:18,290
é um mais simples, humano
explicação amigável de como

748
00:33:18,290 --> 00:33:19,170
Esta função funciona.

749
00:33:19,170 --> 00:33:20,600
>> Retorna o comprimento de uma corda.

750
00:33:20,600 --> 00:33:24,060
Aqui está um resumo, aqui está como você
usá-lo em termos de arquivo de cabeçalho,

751
00:33:24,060 --> 00:33:27,430
e em termos do que a função
Parece que em termos de seus argumentos.

752
00:33:27,430 --> 00:33:30,250
E então, aqui, os retornos
o comprimento de uma string.

753
00:33:30,250 --> 00:33:34,280
Mas para aqueles de vocês mais confortável,
você realmente pode clicar mais confortável,

754
00:33:34,280 --> 00:33:37,070
e os conteúdos desta
página, agora, vai mudar

755
00:33:37,070 --> 00:33:41,660
ser os valores padrão do que
você começa usando a página homem.

756
00:33:41,660 --> 00:33:44,100
>> Em outras palavras, CS50
referência é uma simplificação

757
00:33:44,100 --> 00:33:46,220
de páginas de manual pela equipe, para os alunos.

758
00:33:46,220 --> 00:33:49,320
Particularmente, os menos confortável
e no meio, de modo que você

759
00:33:49,320 --> 00:33:51,660
não tem que tentar envolvê
sua mente em torno, francamente,

760
00:33:51,660 --> 00:33:55,030
alguma sintaxe críptica
e documentação em algum momento.

761
00:33:55,030 --> 00:33:57,650
>> Portanto, manter isso em mente
nos dias que virão.

762
00:33:57,650 --> 00:33:59,560
Então, aqui, mais uma vez, é um Zamyla.

763
00:33:59,560 --> 00:34:03,255
Vamos agora fazer uma pergunta que é
um pouco mais acessível humano.

764
00:34:03,255 --> 00:34:05,380
Graças a Chang, que tem sido
imprimir mais elefantes

765
00:34:05,380 --> 00:34:07,090
sem parar durante os últimos dias.

766
00:34:07,090 --> 00:34:09,730
Temos uma oportunidade de dar
pelo menos um deles de distância.

767
00:34:09,730 --> 00:34:13,239
Se pudéssemos obter apenas um voluntário
que se aproximasse para desenhar na tela.

768
00:34:13,239 --> 00:34:14,530
E aqui?

769
00:34:14,530 --> 00:34:15,340
>> Vamos lá para cima.

770
00:34:15,340 --> 00:34:16,720
Qual é o seu nome?

771
00:34:16,720 --> 00:34:17,219
ALEX: Alex.

772
00:34:17,219 --> 00:34:17,760
DAVID J. MALAN: Alex.

773
00:34:17,760 --> 00:34:18,259
Tudo certo.

774
00:34:18,259 --> 00:34:19,388
Alex, vamos lá para cima.

775
00:34:19,388 --> 00:34:21,679
Estamos prestes a ver o seu
escrita na tela aqui.

776
00:34:21,679 --> 00:34:24,325

777
00:34:24,325 --> 00:34:25,570
Tudo bem, prazer em conhecê-lo.

778
00:34:25,570 --> 00:34:26,429
>> ALEX: Nice você conhecê-lo.

779
00:34:26,429 --> 00:34:27,512
>> DAVID J. MALAN: Tudo bem.

780
00:34:27,512 --> 00:34:28,969
Assim, o exercício super simples.

781
00:34:28,969 --> 00:34:31,440
Bar não é alta para
obter um elefante hoje.

782
00:34:31,440 --> 00:34:33,439
Você está fazendo o papel de getString.

783
00:34:33,439 --> 00:34:35,980
E eu vou apenas dizer-lhe
a seqüência de caracteres que você chegou.

784
00:34:35,980 --> 00:34:38,080
E suponha que você,
getString, foram chamados.

785
00:34:38,080 --> 00:34:42,480
E o ser humano, como eu, tem
digitei Zamyla, Z-A-H-Y-L-A.

786
00:34:42,480 --> 00:34:45,650
Basta ir em frente e escrever Zamyla no
tela como se você tivesse conseguido

787
00:34:45,650 --> 00:34:47,250
e armazenados em algum lugar na memória.

788
00:34:47,250 --> 00:34:52,370

789
00:34:52,370 --> 00:34:55,570
>> Deixando espaço para o que vai ser várias
outro palavras-- tudo bem, continue.

790
00:34:55,570 --> 00:34:59,620
>> [Risos]

791
00:34:59,620 --> 00:35:00,800
>> Então Zamyla, excelente.

792
00:35:00,800 --> 00:35:04,880
Então, suponha que você,
getString, são chamados novamente.

793
00:35:04,880 --> 00:35:09,350
E, portanto, eu lhe fornecer, no
teclado, com outro nome, Belinda.

794
00:35:09,350 --> 00:35:17,560

795
00:35:17,560 --> 00:35:18,060
Tudo certo.

796
00:35:18,060 --> 00:35:22,380
E agora o getString próxima vez é
chamado, eu digitar algo como Gabe,

797
00:35:22,380 --> 00:35:27,560
L-A-B-E. Você realmente está tomando
ao coração de memória de acesso aleatório.

798
00:35:27,560 --> 00:35:29,631
Que está atraindo tudo
de forma completamente aleatória.

799
00:35:29,631 --> 00:35:30,130
Está bem.

800
00:35:30,130 --> 00:35:31,104
>> [Risos]

801
00:35:31,104 --> 00:35:32,520
ALEX: Desculpe minha letra é ruim.

802
00:35:32,520 --> 00:35:33,770
DAVID J. MALAN: Não, isso é OK.

803
00:35:33,770 --> 00:35:40,480
E como sobre Rob, R-O-B. Está bem.

804
00:35:40,480 --> 00:35:41,020
Boa.

805
00:35:41,020 --> 00:35:43,853
Então, eu não esperava que seria
tipo de colocar as coisas desta maneira.

806
00:35:43,853 --> 00:35:45,020
Mas podemos fazer este trabalho.

807
00:35:45,020 --> 00:35:48,810
Então como é que você vai fazer sobre postura
esses caracteres em memória?

808
00:35:48,810 --> 00:35:51,310
Em outras palavras, se pensarmos
esta tela preta retangular

809
00:35:51,310 --> 00:35:53,550
como representando um
RAM, ou memória do computador.

810
00:35:53,550 --> 00:35:55,850
>> E lembrar que a RAM é apenas
um monte de bytes,

811
00:35:55,850 --> 00:35:57,480
e bytes são um monte de bits.

812
00:35:57,480 --> 00:35:59,350
E bits são de alguma forma
implementado, geralmente

813
00:35:59,350 --> 00:36:01,119
com alguma forma de
eletricidade em hardware.

814
00:36:01,119 --> 00:36:03,160
Então, isso é uma espécie de
estratificação nós já conversamos sobre

815
00:36:03,160 --> 00:36:04,510
e agora pode tomar para concedido.

816
00:36:04,510 --> 00:36:07,020
Como é que você vai fazer sobre
decidir onde escrever

817
00:36:07,020 --> 00:36:11,634
Rob contra Gabe contra
Belinda contra Zamyla?

818
00:36:11,634 --> 00:36:14,020
>> ALEX: Eu só fiz isso no
ordenar que você me disse.

819
00:36:14,020 --> 00:36:15,650
>> DAVID J. MALAN: E isso é verdade.

820
00:36:15,650 --> 00:36:20,100
Mas o que rege onde você coloca
O nome de Belinda eo nome de Gabe?

821
00:36:20,100 --> 00:36:20,764
>> ALEX: Nada?

822
00:36:20,764 --> 00:36:22,930
DAVID J. MALAN: [Risos]
Assim que funciona, isso é bom.

823
00:36:22,930 --> 00:36:25,290
Assim, os computadores são pouco
mais ordenada do que isso.

824
00:36:25,290 --> 00:36:29,000
E assim quando nós implement-- ficar lá
por apenas um moment-- quando nós realmente

825
00:36:29,000 --> 00:36:31,470
implementar algo como
getString em um computador,

826
00:36:31,470 --> 00:36:34,480
Zamyla pode ser colocado para fora praticamente
como você fez na tela, não.

827
00:36:34,480 --> 00:36:36,660
>> E o que é fundamental para perceber
aqui, o Alex fez,

828
00:36:36,660 --> 00:36:40,260
é que há uma espécie de demarcação
entre cada uma dessas palavras, certo?

829
00:36:40,260 --> 00:36:46,580
Você não escreveu
Z-A-H-Y-L-A-B-E-L-I-N-D-A-L-A-B--

830
00:36:46,580 --> 00:36:49,740
em outras palavras, há algum tipo
de demarcação que parece ser,

831
00:36:49,740 --> 00:36:52,370
de alguma forma, espaçamento aleatório
entre estas várias palavras.

832
00:36:52,370 --> 00:36:54,120
Mas isso é bom, porque
nós, humanos, podemos agora

833
00:36:54,120 --> 00:36:56,470
visualizar que estes são
quatro cordas diferentes.

834
00:36:56,470 --> 00:36:59,540
Não é apenas uma seqüência
de muitos personagens.

835
00:36:59,540 --> 00:37:04,190
Assim, um computador, então, enquanto isso,
pode ter uma string como Zamyla,

836
00:37:04,190 --> 00:37:07,220
colocar cada uma dessas cartas
dentro de um byte de memória.

837
00:37:07,220 --> 00:37:10,400
Mas esse número é muito maior,
é claro, do que seis caracteres.

838
00:37:10,400 --> 00:37:11,690
>> Há um monte de RAM.

839
00:37:11,690 --> 00:37:15,330
E assim, a partir de agora, este
grade de caixas vai

840
00:37:15,330 --> 00:37:17,560
para representar o que Alex apenas
fiz aqui na tela.

841
00:37:17,560 --> 00:37:20,937
E agora, Alex, podemos oferecer-lhe um
azul ou um elefante laranja de Chang.

842
00:37:20,937 --> 00:37:22,270
ALEX: Vou levar um elefante azul.

843
00:37:22,270 --> 00:37:23,120
DAVID J. MALAN: Um elefante azul.

844
00:37:23,120 --> 00:37:25,580
Assim, uma grande salva de palmas,
se pudéssemos, por Alex aqui.

845
00:37:25,580 --> 00:37:26,100
>> [Aplausos]

846
00:37:26,100 --> 00:37:26,766
>> ALEX: Obrigado.

847
00:37:26,766 --> 00:37:28,820
DAVID J. MALAN: Obrigado.

848
00:37:28,820 --> 00:37:36,230
Então, o que é estaladiça, muito embora o
padrão meio que mudou ao longo do tempo, aqui

849
00:37:36,230 --> 00:37:40,430
na placa, havia um
demarcação entre as diversas cadeias

850
00:37:40,430 --> 00:37:42,610
que Alex tem para nós.

851
00:37:42,610 --> 00:37:45,230
Agora, os computadores, francamente,
poderia fazer a mesma coisa.

852
00:37:45,230 --> 00:37:48,210
Eles poderiam tipo de chape
cordas em qualquer lugar na RAM.

853
00:37:48,210 --> 00:37:50,710
Até aqui, aqui,
aqui em baixo, aqui em baixo.

854
00:37:50,710 --> 00:37:52,020
>> Eles poderiam fazer exatamente isso.

855
00:37:52,020 --> 00:37:54,280
Mas, claro, isso é
provavelmente não o melhor planejamento.

856
00:37:54,280 --> 00:37:54,780
Certo?

857
00:37:54,780 --> 00:37:57,340
Se eu ficava perguntando para Alex
obter nomes, provavelmente ele tinha

858
00:37:57,340 --> 00:38:01,370
colocar um pouco mais aqui, talvez até
aqui, aqui, aqui, eventualmente,

859
00:38:01,370 --> 00:38:02,211
aqui.

860
00:38:02,211 --> 00:38:05,460
Mas, com um pouco mais de planejamento, certamente,
poderíamos colocar as coisas de forma mais limpa.

861
00:38:05,460 --> 00:38:07,350
E, de fato, é o que um computador faz.

862
00:38:07,350 --> 00:38:10,720
>> Mas o problema é que
se a próxima seqüência de eu chegar

863
00:38:10,720 --> 00:38:14,050
depois Zamyla é algo
como a Belinda,

864
00:38:14,050 --> 00:38:17,929
propor onde podemos escrever o
letra b com relação a esta rede?

865
00:38:17,929 --> 00:38:18,720
Para onde você iria?

866
00:38:18,720 --> 00:38:21,480
Para a direita da um,
abaixo a z, a seguir a um?

867
00:38:21,480 --> 00:38:23,204
Quais seriam seus primeiros instintos ser?

868
00:38:23,204 --> 00:38:24,120
AUDIÊNCIA: Abaixo a z.

869
00:38:24,120 --> 00:38:25,100
DAVID J. MALAN: Então, abaixo da z.

870
00:38:25,100 --> 00:38:26,530
E isso é muito
simples, certo?

871
00:38:26,530 --> 00:38:29,321
É uma espécie de puro, que é o que fazemos
em um teclado quando teclar Enter,

872
00:38:29,321 --> 00:38:31,770
ou um e-mail ao fazer uma
lista com marcadores das coisas.

873
00:38:31,770 --> 00:38:34,310
Mas a realidade é que os computadores
tente ser mais eficiente,

874
00:38:34,310 --> 00:38:37,170
e empinar certamente tanto
dados na memória RAM quanto possível,

875
00:38:37,170 --> 00:38:38,890
para que você não perca nenhum bytes.

876
00:38:38,890 --> 00:38:41,545
Para que você não perca
qualquer imóvel tela.

877
00:38:41,545 --> 00:38:44,170
E o problema, porém, é que
se, literalmente, colocar a letra

878
00:38:44,170 --> 00:38:49,940
b depois de um, como é que vamos
sabe onde o nome de Zamyla termina

879
00:38:49,940 --> 00:38:51,840
eo nome da Belinda começa?

880
00:38:51,840 --> 00:38:55,270
Então, vocês humanos apenas proposto, bem,
pressione a tecla Enter, essencialmente.

881
00:38:55,270 --> 00:38:56,410
Coloque-o abaixo.

882
00:38:56,410 --> 00:38:59,750
Ou até mesmo como Alex fez, basta começar a escrever
o seguinte nome abaixo do anterior,

883
00:38:59,750 --> 00:39:01,583
e abaixo que um, e
em seguida, abaixo dessa.

884
00:39:01,583 --> 00:39:02,510
Isso é um sinal visual.

885
00:39:02,510 --> 00:39:05,960
>> Os computadores têm outra sugestão visual,
mas é um pouco mais sucinto.

886
00:39:05,960 --> 00:39:07,840
É esse personagem mal-cheiroso.

887
00:39:07,840 --> 00:39:11,890
0 barra invertida, o que é talvez
reminiscência de barra invertida n,

888
00:39:11,890 --> 00:39:12,640
e assim por diante, agora.

889
00:39:12,640 --> 00:39:14,120
As seqüências de escape especiais.

890
00:39:14,120 --> 00:39:19,120
Barra invertida 0 é o caminho da
representando oito bits zero em uma fileira.

891
00:39:19,120 --> 00:39:22,000
0000 0000.

892
00:39:22,000 --> 00:39:26,130
>> A maneira como você expressar que não é
atingiu o número zero no teclado,

893
00:39:26,130 --> 00:39:28,140
, porque, de facto, que é um carvão ASCII.

894
00:39:28,140 --> 00:39:30,990
Parece um número, mas
é, na verdade, um número decimal

895
00:39:30,990 --> 00:39:35,910
que representa a circular
glifo, a fonte circular.

896
00:39:35,910 --> 00:39:38,410
Enquanto isso, a barra invertida
zero significa, literalmente

897
00:39:38,410 --> 00:39:40,700
colocar oito bytes zero aqui para mim.

898
00:39:40,700 --> 00:39:42,136
>> Portanto, este é um tanto arbitrária.

899
00:39:42,136 --> 00:39:44,260
Nós poderíamos ter usado qualquer padrão
de bits, mas o mundo

900
00:39:44,260 --> 00:39:46,610
decidiu alguns anos
atrás, que, para representar

901
00:39:46,610 --> 00:39:49,710
a extremidade de uma corda na memória,
basta colocar um monte de zeros.

902
00:39:49,710 --> 00:39:51,000
Como podemos detectar isso.

903
00:39:51,000 --> 00:39:54,790
Agora, o que significa que nenhuma carta do
alfabeto podem ser representados por zeros.

904
00:39:54,790 --> 00:39:58,480
>> Mas tudo bem, já vimos
que estamos usando 65 em em 97 em cima.

905
00:39:58,480 --> 00:40:00,290
Nós não chegar a lugar nenhum
Perto de todos os zeros.

906
00:40:00,290 --> 00:40:03,040

907
00:40:03,040 --> 00:40:06,540
Então Belinda na memória de um computador
está realmente indo para ir para lá.

908
00:40:06,540 --> 00:40:09,764
Eu desenhei ele em amarelo apenas
para chamar a nossa atenção para ele.

909
00:40:09,764 --> 00:40:11,680
E notem, também, este
é completamente arbitrária.

910
00:40:11,680 --> 00:40:12,680
Eu desenhei-a como uma grade.

911
00:40:12,680 --> 00:40:14,460
Como, RAM é apenas um objeto físico.

912
00:40:14,460 --> 00:40:17,300
Ele não tem necessariamente
linhas e colunas, de per si.

913
00:40:17,300 --> 00:40:20,490
Ele só tem um monte de bytes
implementado em hardware de alguma forma.

914
00:40:20,490 --> 00:40:22,817
Mas se depois Belinda I
digitado em nome de Gabe,

915
00:40:22,817 --> 00:40:25,650
ele vai acabar aqui na memória,
e se eu digitei o nome de Daven,

916
00:40:25,650 --> 00:40:27,316
por exemplo, ele vai acabar por aqui.

917
00:40:27,316 --> 00:40:29,310
E eu posso continuar a
escrever ainda mais nomes.

918
00:40:29,310 --> 00:40:32,100
>> Infelizmente, se eu tentar
escrever uma super longo nome,

919
00:40:32,100 --> 00:40:33,730
Eu poderia, eventualmente, ficar sem memória.

920
00:40:33,730 --> 00:40:37,810
Nesse caso, é getString
vai retornar NULL, como dissemos.

921
00:40:37,810 --> 00:40:41,720
Mas, felizmente, pelo menos neste visuais
aqui, nós não conseguimos tão longe.

922
00:40:41,720 --> 00:40:45,860
>> Agora, o que é bom é que esta
idéia geral de tratar as coisas

923
00:40:45,860 --> 00:40:49,720
como em caixas é
representativo de uma característica de C

924
00:40:49,720 --> 00:40:52,690
e um monte de línguas,
conhecida como uma matriz.

925
00:40:52,690 --> 00:40:55,490
Um array é um outro tipo de dados.

926
00:40:55,490 --> 00:40:57,380
É uma estrutura de dados, se você quiser.

927
00:40:57,380 --> 00:41:01,160
Estrutura, no sentido de que, realmente,
tipo de, parecendo uma caixa, pelo menos

928
00:41:01,160 --> 00:41:02,320
no olho da sua mente.

929
00:41:02,320 --> 00:41:09,680
Uma matriz é um contíguo
seqüência de tipos de dados idênticos,

930
00:41:09,680 --> 00:41:11,330
volta para trás a volta para trás.

931
00:41:11,330 --> 00:41:14,720
>> Assim, uma corda, em outro
palavras, é uma matriz de caracteres.

932
00:41:14,720 --> 00:41:16,120
Uma matriz de caracteres.

933
00:41:16,120 --> 00:41:19,070
Mas acontece que você pode ter
matrizes de cachos de coisas.

934
00:41:19,070 --> 00:41:21,870
Na verdade, podemos colocar ainda
os números em uma matriz.

935
00:41:21,870 --> 00:41:23,920
Assim, a forma na qual
vamos começar

936
00:41:23,920 --> 00:41:26,590
declarar esses dados
estrutura conhecida como uma matriz

937
00:41:26,590 --> 00:41:28,250
também vai usar colchetes.

938
00:41:28,250 --> 00:41:31,500
Mas esses colchetes vão
têm um significado diferente neste contexto.

939
00:41:31,500 --> 00:41:33,450
>> E vamos ver como se segue.

940
00:41:33,450 --> 00:41:36,780
Suponha que eu abri
-se aqui um novo ficheiro.

941
00:41:36,780 --> 00:41:38,535
E eu salve como ages.c.

942
00:41:38,535 --> 00:41:41,280

943
00:41:41,280 --> 00:41:43,470
E eu vou guardar isso na minha pasta aqui.

944
00:41:43,470 --> 00:41:46,130
E agora eu estou indo para a frente
e começar a digitar algo

945
00:41:46,130 --> 00:41:53,940
como incluir CS50.h incluem
stdio.h, int void main.

946
00:41:53,940 --> 00:41:57,370
E então, aqui dentro, eu quero
a primeira tem um int chamado idade.

947
00:41:57,370 --> 00:42:01,371
>> E eu vou usar isso para obter um
int do usuário para a sua idade.

948
00:42:01,371 --> 00:42:04,620
Mas este programa destina-se a ser utilizado por
várias pessoas, por qualquer contexto.

949
00:42:04,620 --> 00:42:05,490
Eu tenho uma fila de pessoas.

950
00:42:05,490 --> 00:42:08,281
Todos eles tem que digitar sua
idade para talvez alguns, eu não sei,

951
00:42:08,281 --> 00:42:10,530
competição ou evento
que eles chegaram para.

952
00:42:10,530 --> 00:42:13,030
Portanto, a próxima pessoa, eu
preciso de outra variável.

953
00:42:13,030 --> 00:42:15,790
>> Porque se eu só faço
idade fica getInt, isso é

954
00:42:15,790 --> 00:42:18,500
vai espancar, ou substituir
a idade da pessoa anterior.

955
00:42:18,500 --> 00:42:19,760
Então, isso não é bom.

956
00:42:19,760 --> 00:42:21,790
Então, meu primeiro instinto
pode ser, oh, tudo bem,

957
00:42:21,790 --> 00:42:26,260
se eu quiser obter várias pessoas da
ages-- vamos chamar este idade1,

958
00:42:26,260 --> 00:42:31,280
int age2 recebe int, int idade3 recebe getInt.

959
00:42:31,280 --> 00:42:35,340
E agora eu vou usar
algum código pseudocódigo aqui.

960
00:42:35,340 --> 00:42:37,679
>> Faça alguma coisa com esses números.

961
00:42:37,679 --> 00:42:40,470
Vamos deixar para outro dia o que
estamos fazendo lá, porque nós só

962
00:42:40,470 --> 00:42:44,200
cuidado com o momento
cerca de idade1, idade2, idade3.

963
00:42:44,200 --> 00:42:46,450
Infelizmente, uma vez que eu
compilar este programa

964
00:42:46,450 --> 00:42:51,140
e colocá-lo na frente de usuários reais,
qual é a má concepção fundamentalmente

965
00:42:51,140 --> 00:42:53,890
decisão que parece ter feito?

966
00:42:53,890 --> 00:42:54,624
Sim?

967
00:42:54,624 --> 00:42:55,499
AUDIÊNCIA: [inaudível]

968
00:42:55,499 --> 00:42:58,071

969
00:42:58,071 --> 00:42:59,820
DAVID J. MALAN: Sim,
Eu nem sequer tentei

970
00:42:59,820 --> 00:43:02,028
para descobrir como muitas idades
eu realmente se preocupam?

971
00:43:02,028 --> 00:43:05,380
Se eu tiver menos de três pessoas aqui,
e, portanto, menos de três séculos,

972
00:43:05,380 --> 00:43:07,260
Eu ainda estou esperando cegamente três.

973
00:43:07,260 --> 00:43:08,720
Deus me livre quatro pessoas aparecem.

974
00:43:08,720 --> 00:43:10,990
Meu programa só não vai mesmo apoiá-los.

975
00:43:10,990 --> 00:43:13,280
>> E assim, este, longa história
Resumindo, não é um bom hábito.

976
00:43:13,280 --> 00:43:13,780
Certo?

977
00:43:13,780 --> 00:43:16,530
Eu estava essencialmente copiando e
colando o código e apenas ajustes

978
00:43:16,530 --> 00:43:17,430
os nomes das variáveis.

979
00:43:17,430 --> 00:43:22,410
E, meu Deus, se você tivesse, não três
as idades, mas 10, ou 100, ou até 6500

980
00:43:22,410 --> 00:43:23,820
alunos de graduação, por exemplo.

981
00:43:23,820 --> 00:43:26,950
Isso não vai ser particularmente
código elegante, ou sustentável.

982
00:43:26,950 --> 00:43:29,200
Você vai ter que
reescrever o programa de cada vez

983
00:43:29,200 --> 00:43:30,760
o número de pessoas muda.

984
00:43:30,760 --> 00:43:35,090
>> Então, felizmente, em nosso atual
arquivo ages.c para hoje,

985
00:43:35,090 --> 00:43:36,970
temos uma solução mais inteligente.

986
00:43:36,970 --> 00:43:39,800
Em primeiro lugar, eu vou pedir o
construir usamos algumas vezes,

987
00:43:39,800 --> 00:43:43,744
fazei isto enquanto loop, a fim de obter
o número de pessoas na sala.

988
00:43:43,744 --> 00:43:46,910
Eu estou indo só para incomodar o usuário, mais uma vez
e outra vez, até que ele ou ela me dá

989
00:43:46,910 --> 00:43:49,260
um valor de n é um inteiro positivo.

990
00:43:49,260 --> 00:43:51,590
>> Eu poderia ter usado, último
tempo de obter int positivo.

991
00:43:51,590 --> 00:43:53,720
Mas não temos que
for real, então eu fui em frente

992
00:43:53,720 --> 00:43:55,660
e está implementada essa idéia.

993
00:43:55,660 --> 00:43:58,410
Agora aqui, este é o novo truque.

994
00:43:58,410 --> 00:44:02,260
Na linha 27, como os comentários
na linha 26 sugere,

995
00:44:02,260 --> 00:44:05,180
declarar uma matriz em que
para armazenar a idade de todos.

996
00:44:05,180 --> 00:44:09,320
>> Então, se você deseja obter, e não um int, não
duas interrupções, mas todo um conjunto de inteiros.

997
00:44:09,320 --> 00:44:13,800
Especificamente n inteiros, eram n pode
ser três, pode ser 100, pode ser 1000.

998
00:44:13,800 --> 00:44:17,570
A sintaxe, muito simplesmente, é a
por exemplo, que tipo de dados que você quer?

999
00:44:17,570 --> 00:44:19,620
O que você deseja chamar
que pedaço de memória?

1000
00:44:19,620 --> 00:44:23,530
O que você deseja chamar a grade
que se parece com isso pictoricamente?

1001
00:44:23,530 --> 00:44:27,700
>> E entre parênteses aqui, você diz
como grande você quer a matriz para ser.

1002
00:44:27,700 --> 00:44:30,450
E assim, mais cedo, quando eu disse que o
sintaxe é um pouco diferente aqui,

1003
00:44:30,450 --> 00:44:33,614
ainda estamos usando colchetes,
mas quando eu estou declarando uma matriz,

1004
00:44:33,614 --> 00:44:35,530
o número dentro do
colchetes meios

1005
00:44:35,530 --> 00:44:37,610
Qual o tamanho que você deseja que o conjunto estar.

1006
00:44:37,610 --> 00:44:42,490
>> Por outro lado, quando estávamos usando s
suporte de i há pouco, s, uma string,

1007
00:44:42,490 --> 00:44:46,820
é de fato uma matriz de caracteres, mas
quando você não está declarando uma variável,

1008
00:44:46,820 --> 00:44:49,760
como aqui com esta palavra-chave,
você está simplesmente recebendo

1009
00:44:49,760 --> 00:44:54,280
um índice específico, um específico
elemento dessa matriz.

1010
00:44:54,280 --> 00:44:57,090
Uma vez que sabemos que, o resto
isso é simples.

1011
00:44:57,090 --> 00:45:00,765
Se o novo Vou primeiro para imprimir
qual é a idade da pessoa número i.

1012
00:45:00,765 --> 00:45:03,890
Onde eu acabei de dizer número um pessoa,
pessoa número dois, número três pessoa.

1013
00:45:03,890 --> 00:45:06,306
>> E eu só estou fazendo aritmética,
de modo que, como pessoas normais,

1014
00:45:06,306 --> 00:45:09,030
contamos a partir de um para este
programa, e não a partir de zero.

1015
00:45:09,030 --> 00:45:13,620
Então eu chamo getInt, mas eu armazenar
a resposta em idades adaptador.

1016
00:45:13,620 --> 00:45:16,610
Qual é o i-ésimo idade na matriz.

1017
00:45:16,610 --> 00:45:21,640
Assim, enquanto última vez que estavam tratando
essas caixas como caracteres para o nome de Zamyla,

1018
00:45:21,640 --> 00:45:22,490
e outros.

1019
00:45:22,490 --> 00:45:26,530
Agora, essas caixas representam
32 bits, ou quatro bytes

1020
00:45:26,530 --> 00:45:29,510
em que podemos armazenar
um int, int, int.

1021
00:45:29,510 --> 00:45:31,890
Todos os quais, de novo,
são o mesmo tipo de dados.

1022
00:45:31,890 --> 00:45:33,890
>> Agora eu faço algo bobo,
como o tempo passa, apenas

1023
00:45:33,890 --> 00:45:35,510
para justificar a escrever este programa.

1024
00:45:35,510 --> 00:45:40,050
E então aqui em baixo, volto a iteração
sobre a matriz dizendo daqui a um ano,

1025
00:45:40,050 --> 00:45:43,090
pessoa número um testamento
ser algo anos de idade.

1026
00:45:43,090 --> 00:45:45,010
E para descobrir o que
math-- Quer dizer, isso

1027
00:45:45,010 --> 00:45:49,260
não é muito complicado arithmetic--
Acabei de adicionar um para sua idade.

1028
00:45:49,260 --> 00:45:51,240
Só para demonstrar, mais uma vez, este.

1029
00:45:51,240 --> 00:45:57,910
>> Assim como eu posso índice em uma seqüência, s,
para que eu possa índice em uma matriz de idades,

1030
00:45:57,910 --> 00:45:59,950
assim há.

1031
00:45:59,950 --> 00:46:03,340
Então, onde é que isto vai ser nos levando?

1032
00:46:03,340 --> 00:46:07,070
Então, vamos ver, em última análise, uma
Algumas coisas nos dias que virão.

1033
00:46:07,070 --> 00:46:09,510
Um deles, de todo esse tempo, quando
escrever seus próprios programas,

1034
00:46:09,510 --> 00:46:11,239
como Mario, ganancioso, de crédito.

1035
00:46:11,239 --> 00:46:13,780
Você foi a digitar o nome
o programa e pressionar Enter.

1036
00:46:13,780 --> 00:46:15,610
E em seguida, obter a entrada do usuário.

1037
00:46:15,610 --> 00:46:18,137
>> Com getString, getInt,
getLongLong, ou semelhantes.

1038
00:46:18,137 --> 00:46:20,720
Mas acontece que os suportes C
algo chamado de linha de comando

1039
00:46:20,720 --> 00:46:25,740
argumentos, que vai nos deixar
realmente chegar ao ouvir as palavras que você digita,

1040
00:46:25,740 --> 00:46:28,570
no prompt piscando,
após o nome do seu programa.

1041
00:46:28,570 --> 00:46:31,430
>> Assim, nos dias que virão, você
pode digitar algo como César,

1042
00:46:31,430 --> 00:46:34,950
ou ./caesar número 13, a partir daí.

1043
00:46:34,950 --> 00:46:36,070
Vamos ver como isso funciona.

1044
00:46:36,070 --> 00:46:37,550
Porque, de fato, em
conjunto de problemas dois, estamos

1045
00:46:37,550 --> 00:46:39,383
vai apresentá-lo
para uma coisinha

1046
00:46:39,383 --> 00:46:42,360
reminiscência de Ralphie de
desafiar antes da cartografia.

1047
00:46:42,360 --> 00:46:43,970
A arte de codificação de informações.

1048
00:46:43,970 --> 00:46:46,660
Isto, de facto, é muito
lembra o que Ralphie fez.

1049
00:46:46,660 --> 00:46:51,380
>> Este é um exemplo de uma codificação
chamado algoritmo rot13, R-S-T 13.

1050
00:46:51,380 --> 00:46:54,910
O que significa simplesmente girar o
letras do alfabeto 13 lugares.

1051
00:46:54,910 --> 00:46:58,309
E se você fizer isso, você vai ver agora
o que é, talvez, uma frase familiar.

1052
00:46:58,309 --> 00:47:01,100
Mas a forma como vamos usar
isto, em última instância, é uma forma mais geral.

1053
00:47:01,100 --> 00:47:04,390
>> Em P definir dois, na edição padrão,
você vai implementar um par de cifras,

1054
00:47:04,390 --> 00:47:06,720
um chamado César, um chamado Vigenere.

1055
00:47:06,720 --> 00:47:10,090
Ambos são rotacional
cifras, em que de alguma forma você

1056
00:47:10,090 --> 00:47:11,826
transformar uma letra em uma letra diferente.

1057
00:47:11,826 --> 00:47:12,950
E César é super simples.

1058
00:47:12,950 --> 00:47:16,220
Você pode adicionar um, você adiciona 13,
ou algum número até 26.

1059
00:47:16,220 --> 00:47:19,570
Vigenere faz isso em
uma base por carta.

1060
00:47:19,570 --> 00:47:22,140
Então Vigenere, como você verá
na especificação, é mais seguro.

1061
00:47:22,140 --> 00:47:24,973
>> Contudo, no final do dia, o que
você estará implementando e P definir dois,

1062
00:47:24,973 --> 00:47:29,050
é a chave que você use tanto
para criptografia e descriptografia.

1063
00:47:29,050 --> 00:47:32,160
Referindo-se ao processo de transformar
texto simples, alguma mensagem original,

1064
00:47:32,160 --> 00:47:34,490
em texto cifra, que
é algo encriptado.

1065
00:47:34,490 --> 00:47:36,220
E depois decodificá-los novamente.

1066
00:47:36,220 --> 00:47:38,119
>> Na edição de hacker
Enquanto isso, você estará

1067
00:47:38,119 --> 00:47:40,660
encarregado de algo semelhante
em espírito, onde nós vamos dar-lhe

1068
00:47:40,660 --> 00:47:44,610
um arquivo, a partir de um Linux típico, ou
Mac, Unix ou computador chamado Etsy

1069
00:47:44,610 --> 00:47:47,800
palavra-passe, o qual contém um conjunto
bando de nomes de usuários e senhas.

1070
00:47:47,800 --> 00:47:50,932
E as senhas têm tudo
foram criptografados, ou hash,

1071
00:47:50,932 --> 00:47:53,140
por assim dizer, mais propriamente
como você verá na spec.

1072
00:47:53,140 --> 00:47:57,090
>> E a edição hacker vai desafiar
vós, sendo uma entrada como esta,

1073
00:47:57,090 --> 00:47:58,800
e quebrar a senha.

1074
00:47:58,800 --> 00:48:02,590
Ou seja, descobrir o que o
senha do ser humano, na verdade, era.

1075
00:48:02,590 --> 00:48:05,570
Porque, de fato, as senhas são
geralmente não são armazenados em claro,

1076
00:48:05,570 --> 00:48:08,260
e, geralmente, as senhas
deve ser difícil de adivinhar.

1077
00:48:08,260 --> 00:48:09,610
Isso não é frequentemente o caso.

1078
00:48:09,610 --> 00:48:12,110
>> E o que eu pensei que ia fazer é
Concluo com um par de minutos

1079
00:48:12,110 --> 00:48:15,160
olhar para um particular
má escolha de palavras-passe

1080
00:48:15,160 --> 00:48:17,260
a partir de um filme que você deve se lembrar com carinho.

1081
00:48:17,260 --> 00:48:18,915
E se não, você deve alugar.

1082
00:48:18,915 --> 00:48:20,070
>> [REPRODUÇÃO]

1083
00:48:20,070 --> 00:48:22,320
>> -Helmet, Você diabo, o que está acontecendo?

1084
00:48:22,320 --> 00:48:24,240
O que você está fazendo com a minha filha?

1085
00:48:24,240 --> 00:48:28,010
>> -permitir-Me apresentar o
brilhante cirurgião plástico jovem,

1086
00:48:28,010 --> 00:48:30,010
Doutor Phillip Schlotkin.

1087
00:48:30,010 --> 00:48:35,020
O maior nariz do homem no trabalho
universo inteiro e Beverly Hills.

1088
00:48:35,020 --> 00:48:36,140
>> -Seu Alteza.

1089
00:48:36,140 --> 00:48:36,820
>> Trabalho -Nose?

1090
00:48:36,820 --> 00:48:37,700
Eu não entendi.

1091
00:48:37,700 --> 00:48:39,070
Ela já tinha uma plástica no nariz.

1092
00:48:39,070 --> 00:48:40,800
Era o seu doce 16 presentes.

1093
00:48:40,800 --> 00:48:42,590
>> Não, não é o que você pensa.

1094
00:48:42,590 --> 00:48:44,490
É muito, muito pior.

1095
00:48:44,490 --> 00:48:48,160
Se você não me der o
combinação com o escudo de ar,

1096
00:48:48,160 --> 00:48:52,748
médico Schlotkin vai dar o seu
filha de volta seu antigo nariz.

1097
00:48:52,748 --> 00:48:53,748
- [Suspiros] Nooooooooooooo.

1098
00:48:53,748 --> 00:48:57,684

1099
00:48:57,684 --> 00:48:59,652
Onde você conseguiu isso?

1100
00:48:59,652 --> 00:49:00,640
>> -Certo.

1101
00:49:00,640 --> 00:49:02,506
Eu vou te dizer, eu vou dizer.

1102
00:49:02,506 --> 00:49:03,498
>> Não, papai, não.

1103
00:49:03,498 --> 00:49:04,490
Você não deve.

1104
00:49:04,490 --> 00:49:06,090
>> -Você Direito meu caro.

1105
00:49:06,090 --> 00:49:07,390
Vou sentir falta de seu novo nariz.

1106
00:49:07,390 --> 00:49:10,990
Mas eu não vou dizer-lhes o
combinação não importa o quê.

1107
00:49:10,990 --> 00:49:12,450
>> -Muito Bem.

1108
00:49:12,450 --> 00:49:14,830
Doutor Schlotkin, faça o seu pior.

1109
00:49:14,830 --> 00:49:15,744
>> O prazer é meu.

1110
00:49:15,744 --> 00:49:19,860

1111
00:49:19,860 --> 00:49:20,800
>> Não!

1112
00:49:20,800 --> 00:49:22,780
Espere, espere.

1113
00:49:22,780 --> 00:49:24,000
Eu vou te dizer.

1114
00:49:24,000 --> 00:49:25,830
Eu vou te dizer.

1115
00:49:25,830 --> 00:49:28,270
>> Eu sabia que ele iria trabalhar.

1116
00:49:28,270 --> 00:49:31,390
Tudo bem, dê para mim.

1117
00:49:31,390 --> 00:49:36,220
>> -The Combinação é um deles.

1118
00:49:36,220 --> 00:49:36,740
>> -One.

1119
00:49:36,740 --> 00:49:37,473
>> -One.

1120
00:49:37,473 --> 00:49:37,972
-Dois.

1121
00:49:37,972 --> 00:49:38,471
-Dois.

1122
00:49:38,471 --> 00:49:39,800
-Dois.

1123
00:49:39,800 --> 00:49:40,300
-Três.

1124
00:49:40,300 --> 00:49:40,800
-Três.

1125
00:49:40,800 --> 00:49:41,800
-Três.

1126
00:49:41,800 --> 00:49:42,300
-Quatro.

1127
00:49:42,300 --> 00:49:42,800
-Quatro.

1128
00:49:42,800 --> 00:49:44,707
-Quatro.

1129
00:49:44,707 --> 00:49:45,521
-Cinco.

1130
00:49:45,521 --> 00:49:46,430
-Cinco.

1131
00:49:46,430 --> 00:49:47,930
-Cinco.

1132
00:49:47,930 --> 00:49:53,480
-Então A combinação é um,
dois, três, quatro, cinco.

1133
00:49:53,480 --> 00:49:56,140
Essa é a combinação mais estúpida
Eu já ouvi na minha vida.

1134
00:49:56,140 --> 00:49:58,640
Esse é o tipo de coisa que um
idiota teria em sua bagagem.

1135
00:49:58,640 --> 00:50:00,000
>> Obrigado, sua Alteza.

1136
00:50:00,000 --> 00:50:01,340
>> [CLIQUES REMOTE]

1137
00:50:01,340 --> 00:50:02,450
>> -Qual Que você fez?

1138
00:50:02,450 --> 00:50:03,800
>> -I Desligado da parede.

1139
00:50:03,800 --> 00:50:05,010
>> Não, você não fez, você
desligada todo o filme.

1140
00:50:05,010 --> 00:50:06,220
>> Deve ter -I apertou o botão errado.

1141
00:50:06,220 --> 00:50:07,064
>> Bem, colocá-lo novamente!

1142
00:50:07,064 --> 00:50:07,910
Coloque o filme de volta!

1143
00:50:07,910 --> 00:50:08,300
>> Sim, senhor!

1144
00:50:08,300 --> 00:50:08,799
Sim, senhor.

1145
00:50:08,799 --> 00:50:09,660
-Vamos, Arnold.

1146
00:50:09,660 --> 00:50:10,450
Venha, Gretchen.

1147
00:50:10,450 --> 00:50:12,533
É claro que você sabe que eu vou
tem que cobrá-lo por isso.

1148
00:50:12,533 --> 00:50:16,720

1149
00:50:16,720 --> 00:50:17,220
Bem?

1150
00:50:17,220 --> 00:50:17,802
Será que isso funciona?

1151
00:50:17,802 --> 00:50:18,510
Onde está o rei?

1152
00:50:18,510 --> 00:50:20,218
>> -It Trabalhou, senhor,
têm a combinação.

1153
00:50:20,218 --> 00:50:20,740
-Grande.

1154
00:50:20,740 --> 00:50:24,810
Agora podemos tomar cada último suspiro
de ar fresco do planeta Druidia.

1155
00:50:24,810 --> 00:50:25,890
Qual é a combinação?

1156
00:50:25,890 --> 00:50:28,155
>> Um, dois, três, quatro, cinco.

1157
00:50:28,155 --> 00:50:29,890
>> Um, dois, três, quatro, cinco?

1158
00:50:29,890 --> 00:50:30,390
Sim.

1159
00:50:30,390 --> 00:50:31,110
-É Incrível.

1160
00:50:31,110 --> 00:50:34,550
Eu tenho o mesmo
combinação em minha bagagem.

1161
00:50:34,550 --> 00:50:37,160
Prepare Spaceball 1 para
partida imediata.

1162
00:50:37,160 --> 00:50:38,160
>> Sim, senhor.

1163
00:50:38,160 --> 00:50:40,745
>> -E Alterar o
combinação em minha bagagem.

1164
00:50:40,745 --> 00:50:41,578
[Fechamento da porta SOUND]

1165
00:50:41,578 --> 00:50:42,064
[CLINK de portas CAPACETE QUE BATE]

1166
00:50:42,064 --> 00:50:42,550
-Ahh.

1167
00:50:42,550 --> 00:50:43,383
[FIM REPRODUÇÃO DE VÍDEO]

1168
00:50:43,383 --> 00:50:46,700
DAVID J. MALAN: Isso é tudo para
CS50, vamos vê-lo na próxima semana.

1169
00:50:46,700 --> 00:50:49,883
NARRADOR: E agora, Profundo
Pensamentos, por Daven Farnham.

1170
00:50:49,883 --> 00:50:53,160

1171
00:50:53,160 --> 00:50:55,860
>> Daven FARNHAM: Codificação em C é
muito mais difícil do que zero.

1172
00:50:55,860 --> 00:50:57,320
printf, risco era uma mentira.

1173
00:50:57,320 --> 00:50:59,930

1174
00:50:59,930 --> 00:51:01,430
>> [Risos SoundBite]

1175
00:51:01,430 --> 00:51:02,486