1
00:00:00,000 --> 00:00:11,280

2
00:00:11,280 --> 00:00:13,650
>> COLUNA 1: Tudo bem.

3
00:00:13,650 --> 00:00:14,390
Bem-vindo de volta.

4
00:00:14,390 --> 00:00:19,260
Esta é a Semana Duas das CS50, e nós temos
até agora foi o uso de funções, mas

5
00:00:19,260 --> 00:00:20,830
em grande medida tomada para concedido.

6
00:00:20,830 --> 00:00:23,430
Nós usamos printf que tem a
efeito colateral de impressão

7
00:00:23,430 --> 00:00:24,110
as coisas na tela.

8
00:00:24,110 --> 00:00:25,790
Nós usamos get-int, se flutuar.

9
00:00:25,790 --> 00:00:29,230
>> Mas e se você realmente deseja criar
suas próprias funções, como alguns dos

10
00:00:29,230 --> 00:00:31,740
você já deve ter começado a
fazer por Problem Set One, embora

11
00:00:31,740 --> 00:00:33,140
não é estritamente necessário?

12
00:00:33,140 --> 00:00:37,150
Bem, vamos em frente e revisitar esse
problema de apenas pedindo ao usuário para

13
00:00:37,150 --> 00:00:40,660
o seu nome e a impressão algo na
tela, mas tenta fatorar alguns

14
00:00:40,660 --> 00:00:44,000
da comunhão que temos
visto no nosso código até agora.

15
00:00:44,000 --> 00:00:45,120
Então, por que eu quero dizer o seguinte.

16
00:00:45,120 --> 00:00:47,315
>> Eu estou indo para ir em frente e criar
um novo programa, basta ligar para

17
00:00:47,315 --> 00:00:49,320
ele HELLO.C como de costume.

18
00:00:49,320 --> 00:00:53,730
Eu estou indo para ir em frente e dar-me
incluir io.h padrão no topo.

19
00:00:53,730 --> 00:00:57,040
Vou também dar-me
preventivamente a biblioteca de modo a que CS50

20
00:00:57,040 --> 00:00:59,080
Eu não me gritou pelo compilador.

21
00:00:59,080 --> 00:01:02,400
E agora eu estou indo para ir em frente
e declarar int, principal, nula.

22
00:01:02,400 --> 00:01:09,020
>> E então, aqui, é aqui que eu quero
para começar a terceirizar funcionalidade para

23
00:01:09,020 --> 00:01:12,090
alguma outra função que eu mesmo sou
vai escrever, mas que não

24
00:01:12,090 --> 00:01:13,820
existem atualmente.

25
00:01:13,820 --> 00:01:19,210
Por exemplo, suponha que eu queria
escrever uma função que me permite

26
00:01:19,210 --> 00:01:23,830
imprimir Olá, vírgula, e
então o nome de algum usuário.

27
00:01:23,830 --> 00:01:29,010
Ao invés de continuar a fazer printf
Olá,% s, não seria bom se

28
00:01:29,010 --> 00:01:33,380
havia apenas uma função chamada
não printf, mas o nome de impressão?

29
00:01:33,380 --> 00:01:36,600
>> Portanto, em outras palavras, eu quero ser capaz de
escrever um programa que faz um pouco

30
00:01:36,600 --> 00:01:37,710
algo como isto.

31
00:01:37,710 --> 00:01:42,070
Primeiro, eu vou dizer o printf
nome, levando, assim, o usuário

32
00:01:42,070 --> 00:01:46,150
me dar o seu nome, e então eu sou
vai usar as cordas s familiares para

33
00:01:46,150 --> 00:01:47,290
declarar uma string.

34
00:01:47,290 --> 00:01:50,420
Dê-me uma variável do tipo string,
chamá-lo s, e loja em que o

35
00:01:50,420 --> 00:01:52,120
resultado da chamada obter string.

36
00:01:52,120 --> 00:01:56,060
Mas, agora, nas últimas semanas, eu teria
um pouco tediosamente feito Olá,% s / n.

37
00:01:56,060 --> 00:01:58,630

38
00:01:58,630 --> 00:02:02,570
>> E, em outras palavras, temos visto esta
exemplo, um monte de vezes, e é um

39
00:02:02,570 --> 00:02:05,280
trivial exemplo, porque há apenas uma
linha de código para que ele não é realmente um

40
00:02:05,280 --> 00:02:06,860
grande negócio para ficar digitando novamente.

41
00:02:06,860 --> 00:02:09,990
Mas suponhamos que esta linha de código
na verdade, estavam se tornando um fardo, e

42
00:02:09,990 --> 00:02:12,900
não é uma linha de código, mas é 10
linhas de código de um par de semanas a partir de agora,

43
00:02:12,900 --> 00:02:15,190
e você está apenas cansado
de copiar e colar ou

44
00:02:15,190 --> 00:02:17,180
redigitação esse mesmo código.

45
00:02:17,180 --> 00:02:22,100
Não seria bom ao invés de fazer
printf Olá,% s e assim por diante,

46
00:02:22,100 --> 00:02:26,500
Não seria bom se houvesse apenas
uma função chamada nome de impressão que

47
00:02:26,500 --> 00:02:27,560
recebe um argumento -

48
00:02:27,560 --> 00:02:29,120
em outras palavras, é preciso entrada -

49
00:02:29,120 --> 00:02:30,620
e, em seguida, ponto e vírgula.

50
00:02:30,620 --> 00:02:33,240
Então essa função, não seria
Seria bom se que existia?

51
00:02:33,240 --> 00:02:36,690
Então eu não teria que se preocupar com
printf que é, o que% se todos

52
00:02:36,690 --> 00:02:39,400
estas complexidades que sejam
nem tudo o que interessante.

53
00:02:39,400 --> 00:02:40,570
Eles são úteis.

54
00:02:40,570 --> 00:02:44,700
>> Assim, o nome de impressão, infelizmente, não foi
inventou cerca de 40 anos mais atrás.

55
00:02:44,700 --> 00:02:45,980
Ninguém pensou em escrevê-lo.

56
00:02:45,980 --> 00:02:48,300
Mas essa é a beleza de ter um
linguagem de programação, assim como no

57
00:02:48,300 --> 00:02:52,930
Do zero, você pode definir blocos personalizados, para
em C e mais qualquer língua, pode

58
00:02:52,930 --> 00:02:57,260
definir a sua própria funcionalidade, pode
você definir suas próprias funções.

59
00:02:57,260 --> 00:03:01,710
Portanto, apesar de chegarmos principal
automaticamente de graça, podemos declarar

60
00:03:01,710 --> 00:03:02,730
nossas próprias funções.

61
00:03:02,730 --> 00:03:05,670
>> Então, eu vou fazer algum espaço aqui
em cima, e eu vou declarar meu

62
00:03:05,670 --> 00:03:08,210
própria função que vai procurar um
pouco estranho no começo, mas nós vamos chegar

63
00:03:08,210 --> 00:03:09,400
de volta a este antes do tempo.

64
00:03:09,400 --> 00:03:12,310
Eu vou dizer nula, assim
indicando que essa função faz

65
00:03:12,310 --> 00:03:16,040
algo, tem um efeito secundário, mas
não devolver algo para mim no

66
00:03:16,040 --> 00:03:18,810
mesma forma que se int ou
obter corda em si faz.

67
00:03:18,810 --> 00:03:22,450
E eu vou dar a este uma função
nome do nome de impressão, e eu vou

68
00:03:22,450 --> 00:03:26,470
especificar que esse cara vai levar
uma string, e eu vou ligar para que

69
00:03:26,470 --> 00:03:27,600
nome string.

70
00:03:27,600 --> 00:03:32,100
Eu poderia chamá-lo de qualquer coisa que eu quiser, mas eu
quero o meu código para ser auto-documentado.

71
00:03:32,100 --> 00:03:34,770
Em outras palavras, se um de vocês fosse
abrir este arquivo e lê-lo, você poderia

72
00:03:34,770 --> 00:03:39,020
tipo de inferir a partir do nome que
entrada o papel que deveria desempenhar.

73
00:03:39,020 --> 00:03:42,270
>> E agora abaixo disso, eu vou abrir
crespos e encaracolados cinta cinta fechada,

74
00:03:42,270 --> 00:03:47,140
e assim perceber que eu tenho seguido o mesmo
padrão em linhas de quatro a sete como

75
00:03:47,140 --> 00:03:51,622
Eu tenho acompanhado de uma boa semana, além de
agora entre, digamos, nove linhas e

76
00:03:51,622 --> 00:03:53,400
14 que compõem principal.

77
00:03:53,400 --> 00:03:56,160
Em outras palavras, imprimir o nome
é uma outra função.

78
00:03:56,160 --> 00:03:58,990
Agora, o compilador não vai saber
chamar essa coisa automaticamente

79
00:03:58,990 --> 00:04:02,670
porque eu literalmente inventou,
mas vai saber ainda para chamar principal

80
00:04:02,670 --> 00:04:08,710
automaticamente, e então, naturalmente, em
linha 13, eu estou chamando minha própria função.

81
00:04:08,710 --> 00:04:12,805
E porque eu tenho declarado que a função
se na linha quatro, antes principal,

82
00:04:12,805 --> 00:04:16,579
isso vai ensinar o compilador
o orçamento, fecha aspas ", nome print"

83
00:04:16,579 --> 00:04:18,140
significa eo que ele deve fazer.

84
00:04:18,140 --> 00:04:22,700
Então, eu sou uma espécie de dar-lhe um novo costume
bloquear no contexto de, digamos, zero.

85
00:04:22,700 --> 00:04:27,240
>> Então, aqui, eu posso colocar isso muito comum
ou padrão recorrente de código guardo

86
00:04:27,240 --> 00:04:32,300
escrita em sala de aula, printf
Olá% s,% s / n "-

87
00:04:32,300 --> 00:04:36,720

88
00:04:36,720 --> 00:04:37,590
o que eu quero colocar aqui?

89
00:04:37,590 --> 00:04:39,200
S?

90
00:04:39,200 --> 00:04:41,420
Então, eu quero colocar o nome neste contexto.

91
00:04:41,420 --> 00:04:43,440
Então, observe um pouco de uma dicotomia aqui.

92
00:04:43,440 --> 00:04:47,680
Porque eu estou declarando minha própria função
e eu tenho um pouco arbitrariamente chamado

93
00:04:47,680 --> 00:04:50,880
que imprimir o nome, e porque eu tenho
especificado entre parênteses que esta

94
00:04:50,880 --> 00:04:55,035
função recebe um argumento, o tipo de
que é uma string - por isso é uma palavra

95
00:04:55,035 --> 00:05:00,010
ou frase, ou algo assim - e
Eu estou chamando esse nome argumento, que

96
00:05:00,010 --> 00:05:04,770
significa que a única variável que está em
escopo, por assim dizer, é o nome.

97
00:05:04,770 --> 00:05:07,780
>> S só existe entre o que dois
chaves, é claro?

98
00:05:07,780 --> 00:05:12,990
Bem, na verdade, assim como a linha 10 através de
14, então apenas como na segunda-feira não pode usar

99
00:05:12,990 --> 00:05:17,650
S, mas o que posso fazer é passar
S em nome de impressão.

100
00:05:17,650 --> 00:05:21,030
Imprimir o nome só acontece para dar-lhe
um alias, um sinônimo, um apelido,

101
00:05:21,030 --> 00:05:24,400
chamando-o de nome, e agora
usá-lo nesta linha.

102
00:05:24,400 --> 00:05:26,840
Então, agora deixe-me guardar este, zoom out.

103
00:05:26,840 --> 00:05:31,250
>> Deixe-me ir em frente e fazer Olá.

104
00:05:31,250 --> 00:05:32,400
Parece bom.

105
00:05:32,400 --> 00:05:36,110
Não cuspir erros.
. / Olá Enter.

106
00:05:36,110 --> 00:05:37,020
Qual é o meu nome?

107
00:05:37,020 --> 00:05:38,060
David.

108
00:05:38,060 --> 00:05:39,270
E Olá David.

109
00:05:39,270 --> 00:05:41,820
Assim, nem tudo o que emocionante,
mas só de pensar agora.

110
00:05:41,820 --> 00:05:44,310
Você agora tem o mesmo ingrediente
como fizemos em risco a

111
00:05:44,310 --> 00:05:45,420
fazer nossas próprias funções.

112
00:05:45,420 --> 00:05:46,770
>> Mas há um pouco de uma pegadinha.

113
00:05:46,770 --> 00:05:50,620
Suponha que eu realmente não tinha pensado
isso através de e eu realmente sem

114
00:05:50,620 --> 00:05:54,250
realmente pensar sobre isso escreveu
essa função aqui.

115
00:05:54,250 --> 00:05:55,420
Sente perfeitamente razoável.

116
00:05:55,420 --> 00:05:58,440
Em risco, não há noção
de localização em seus scripts.

117
00:05:58,440 --> 00:06:00,670
Você poderia colocar uma aqui em cima, aqui em cima,
um aqui, e isso pode começar a

118
00:06:00,670 --> 00:06:03,310
a parecer um pouco confuso se você não fizer isso
colocá-lo perfeitamente, mas não

119
00:06:03,310 --> 00:06:05,910
importa onde fisicamente os roteiros
estavam na tela.

120
00:06:05,910 --> 00:06:09,660
Infelizmente em C - e esta é diferente
linguagens como Java e Python

121
00:06:09,660 --> 00:06:13,600
e outros que você pode estar familiarizado
com - infelizmente, em C, a ordem não

122
00:06:13,600 --> 00:06:15,830
importa, porque o que é relógio
vai acontecer agora.

123
00:06:15,830 --> 00:06:19,010
>> A função padrão que está acontecendo
para executar, é claro, a principal.

124
00:06:19,010 --> 00:06:22,290
Principal vai chamar o nome de impressão em
A linha de oito, mas, infelizmente, a

125
00:06:22,290 --> 00:06:26,660
compilador não vai nem saber que o nome de impressão
Existe até chegar a linha 11,

126
00:06:26,660 --> 00:06:28,520
que, infelizmente, é
vai ser tarde demais.

127
00:06:28,520 --> 00:06:30,660
Então, vamos fazer fazer Olá.

128
00:06:30,660 --> 00:06:32,950
E agora, dois erros malditos gerada.

129
00:06:32,950 --> 00:06:36,050
Então, agora deixe-me ir até a própria
primeiro, como sempre devemos fazer, e

130
00:06:36,050 --> 00:06:39,560
notar que ele está gritando para mim,
"Declaração implícita da função

131
00:06:39,560 --> 00:06:40,540
imprimir o nome. "

132
00:06:40,540 --> 00:06:43,860
>> Então, temos visto essa mensagem antes,
declaração implícita de função.

133
00:06:43,860 --> 00:06:48,080
Quando vimos esse tipo de erro?

134
00:06:48,080 --> 00:06:49,180
Quando eu não incluí uma biblioteca.

135
00:06:49,180 --> 00:06:53,470
Se eu esqueci cs50.h e eu iria ficar
gritou para obter corda ou obter int.

136
00:06:53,470 --> 00:06:56,880
Mas, neste caso, esta função de impressão
nome não está na biblioteca, certo?

137
00:06:56,880 --> 00:07:00,230
É, literalmente, neste arquivo, de modo
o que é realmente o problema?

138
00:07:00,230 --> 00:07:04,660
>> Bem, infelizmente, em C, é preciso que você
tão incrivelmente literalmente que se você

139
00:07:04,660 --> 00:07:08,640
quero uma função chamada nome de impressão para
existe, você tem que implementar

140
00:07:08,640 --> 00:07:11,940
essa função no topo de sua
código para que ele seja acessível para baixar

141
00:07:11,940 --> 00:07:15,070
funções, mas, francamente, que se torna
desleixado muito rapidamente.

142
00:07:15,070 --> 00:07:18,160
Pessoalmente, eu gosto de colocar principal em primeiro lugar
porque, então, é muito claro o que isso

143
00:07:18,160 --> 00:07:19,890
programa faz à primeira vista.

144
00:07:19,890 --> 00:07:23,290
E mais, você pode entrar no canto estranho
casos em que se quer chamar x

145
00:07:23,290 --> 00:07:27,530
y mas y poderia chamar x, você só
fisicamente não pode realmente colocar um

146
00:07:27,530 --> 00:07:28,540
por cima do outro.

147
00:07:28,540 --> 00:07:31,230
>> Mas acontece que em C, pode-se
resolver isso de maneira muito simples.

148
00:07:31,230 --> 00:07:34,010
Eu vou colocar um pouco de espaço
até aqui, e eu só vou

149
00:07:34,010 --> 00:07:38,170
preventivamente, embora um pouco
redundante, vai ensinar a

150
00:07:38,170 --> 00:07:42,320
compilador que existe uma função
chamou o nome de impressão, é preciso uma string,

151
00:07:42,320 --> 00:07:46,330
e eu vou chamar
ele nomear ponto e vírgula.

152
00:07:46,330 --> 00:07:50,220
>> Portanto, este agora na linha de quatro, o que nós
não tenha visto antes, é uma declaração

153
00:07:50,220 --> 00:07:53,940
de um nome de função de impressão, mas é só
uma promessa de que esta função

154
00:07:53,940 --> 00:07:56,620
eventualmente ser definida, eventualmente
ser implementado.

155
00:07:56,620 --> 00:08:00,180
Este agora posso deixar sozinho, porque
agora esta é a definição, o

156
00:08:00,180 --> 00:08:04,090
implementação, uma espécie de última milha
da implementação deste

157
00:08:04,090 --> 00:08:05,130
função particular.

158
00:08:05,130 --> 00:08:08,450
Então, francamente, é estúpido, é chato,
mas este é o caminho é C, e é

159
00:08:08,450 --> 00:08:12,050
porque leva muito literalmente
e, como um computador, francamente deveria,

160
00:08:12,050 --> 00:08:16,020
só faz exatamente o que você diga a ele
fazer, e para que ordem é importante.

161
00:08:16,020 --> 00:08:18,940
>> Portanto, manter isso em mente e, novamente, começar a
perceber a recorrência de padrões.

162
00:08:18,940 --> 00:08:21,850
As probabilidades são que você vai, se você não tiver
já, começar a encontrar mensagens

163
00:08:21,850 --> 00:08:24,700
como este, que à primeira vista parecem
completamente enigmática, mas se você começar

164
00:08:24,700 --> 00:08:29,000
a olhar para estas palavras-chave como
"Declaração implícita", a menção de um

165
00:08:29,000 --> 00:08:32,380
função neste caso - e, francamente, você
às vezes até ficar um pouco verde

166
00:08:32,380 --> 00:08:35,010
símbolo cenoura que lhe diz onde
o problema é provavelmente -

167
00:08:35,010 --> 00:08:40,980
você pode começar a trabalhar o seu caminho através de
ainda mensagens de erro invisível.

168
00:08:40,980 --> 00:08:45,860
Qualquer dúvida sobre como escrever o seu
própria função desta forma?

169
00:08:45,860 --> 00:08:47,540
>> Vamos fazer algo que é um
pouco mais convincente.

170
00:08:47,540 --> 00:08:51,760
Ao invés de apenas fazer algo que tem
um efeito colateral de impressão, deixe-me ir

171
00:08:51,760 --> 00:08:55,340
em frente e salvar um novo arquivo, e nós vamos
chamar este positive.c, mesmo que seja

172
00:08:55,340 --> 00:08:57,600
vai ser um pouco diferente
contra a última vez.

173
00:08:57,600 --> 00:09:01,910
E desta vez, eu quero voltar a implementar
exemplo positive.C da última vez, que

174
00:09:01,910 --> 00:09:04,430
é forçar o usuário a dar
me um inteiro positivo.

175
00:09:04,430 --> 00:09:07,280
Mas eu tinha que usar get int última vez.

176
00:09:07,280 --> 00:09:10,780
Não teria sido bom se houvesse
uma função chamada obter int positivo

177
00:09:10,780 --> 00:09:13,610
que eu poderia simplesmente terceirizar essa
pedaço de funcionalidade para?

178
00:09:13,610 --> 00:09:16,480
Assim, a diferença aqui é que nós vamos
implementar obter int positivo, mas ao contrário

179
00:09:16,480 --> 00:09:20,330
Nome impressão que teve um efeito colateral - é
não devolver algo para mim como

180
00:09:20,330 --> 00:09:21,710
um número ou uma string -

181
00:09:21,710 --> 00:09:25,510
se int positivo é, naturalmente, vai
voltar, espero, um int positivo.

182
00:09:25,510 --> 00:09:26,170
>> Então, vamos fazer isso.

183
00:09:26,170 --> 00:09:30,840
Incluir cs50.h, incluem Standard io.h.

184
00:09:30,840 --> 00:09:33,520
Int void main.

185
00:09:33,520 --> 00:09:42,160
E agora aqui, eu estou indo para ir em frente
e digamos que int, chamá-lo de n, é igual a

186
00:09:42,160 --> 00:09:44,270
obter int positivo.

187
00:09:44,270 --> 00:09:49,080
E, assim como obter int já existe
porque o pessoal escreveu, eu vou

188
00:09:49,080 --> 00:09:53,950
assumir para o momento em que obtenha
int positivo existe, e agora eu vou

189
00:09:53,950 --> 00:09:57,730
para ir em frente e dizer printf,
obrigado pela% i / n ", n.

190
00:09:57,730 --> 00:10:02,940

191
00:10:02,940 --> 00:10:07,770
>> Portanto, agora se eu compilar esse programa, o que
que vai acontecer no meu terminal

192
00:10:07,770 --> 00:10:09,075
janela na parte inferior da tela?

193
00:10:09,075 --> 00:10:11,580

194
00:10:11,580 --> 00:10:13,900
Eu vou provavelmente obter esse
mesmo erro de antes.

195
00:10:13,900 --> 00:10:14,570
Então, vamos tentar isso.

196
00:10:14,570 --> 00:10:16,450
Faça positiva.

197
00:10:16,450 --> 00:10:19,900
E mais uma vez, declaração implícita
da função, obter int positivo.

198
00:10:19,900 --> 00:10:21,970
Assim, podemos resolver isso em
um par de formas.

199
00:10:21,970 --> 00:10:27,310
Eu vou mantê-lo simples e apenas
coloquei minha declaração aqui e obtenha

200
00:10:27,310 --> 00:10:28,120
int positivo.

201
00:10:28,120 --> 00:10:29,720
Eu preciso da assinatura so-called.

202
00:10:29,720 --> 00:10:32,410
A assinatura refere-se apenas
para a estética do

203
00:10:32,410 --> 00:10:34,090
primeira linha do programa.

204
00:10:34,090 --> 00:10:37,420
Então, o que deve obter positivo
int retorno?

205
00:10:37,420 --> 00:10:37,970
>> Assim, um int.

206
00:10:37,970 --> 00:10:41,540
Quero dizer, idealmente, seria voltar
algo como int positiva, mas que

207
00:10:41,540 --> 00:10:42,160
não existe.

208
00:10:42,160 --> 00:10:45,280
Nós não vimos que, entre os nossos dados
tipos, por isso temos de lidar com o

209
00:10:45,280 --> 00:10:47,170
fato de que temos muito poucos
tipos de dados para trabalhar.

210
00:10:47,170 --> 00:10:50,360
Mas podemos retornar um int e apenas
confiar que vai ser positivo.

211
00:10:50,360 --> 00:10:52,690
Vai ser chamado
obter int positivo.

212
00:10:52,690 --> 00:10:55,122
>> E agora, como sobre os seus argumentos?

213
00:10:55,122 --> 00:10:56,440
Leva qualquer entrada?

214
00:10:56,440 --> 00:10:58,280
Será que ele precisa de qualquer entrada?

215
00:10:58,280 --> 00:11:00,900
Por isso, não precisa saber
nada de antemão.

216
00:11:00,900 --> 00:11:03,220
Obter corda não, se int não.

217
00:11:03,220 --> 00:11:06,430
Printf faz - ele precisa ter algum
entrada passou para ele - eo nome de impressão

218
00:11:06,430 --> 00:11:09,020
precisava de alguma entrada, mas se
int positivo não.

219
00:11:09,020 --> 00:11:11,530
Então eu vou explicitamente
dizer o vazio compilador.

220
00:11:11,530 --> 00:11:13,470
Vácuo é a ausência de qualquer outra coisa.

221
00:11:13,470 --> 00:11:17,990
Então vazio não significa nada está acontecendo dentro
desses parênteses, ponto e vírgula.

222
00:11:17,990 --> 00:11:20,840
>> E agora, no fundo do meu arquivo - e
novamente, estou apenas sendo gentil de anal

223
00:11:20,840 --> 00:11:23,640
aqui colocando principal no topo, o que
é uma boa prática, pois desta forma,

224
00:11:23,640 --> 00:11:26,220
sempre que você ou alguém
abre o arquivo, o

225
00:11:26,220 --> 00:11:27,400
funcionalidade é logo ali.

226
00:11:27,400 --> 00:11:29,660
Você pode mergulhar a partir de uma praça.

227
00:11:29,660 --> 00:11:34,190
Então agora eu vou duplicar isto,
ficar vazio int positivo, mas eu não sou

228
00:11:34,190 --> 00:11:35,430
vai bater um ponto e vírgula agora.

229
00:11:35,430 --> 00:11:38,280
Eu vou abrir chaves,
e agora eu preciso tomar emprestado

230
00:11:38,280 --> 00:11:39,700
algumas idéias de segunda-feira.

231
00:11:39,700 --> 00:11:44,450
>> Então, como você se lembra, fizemos algo
como fazer o seguinte enquanto

232
00:11:44,450 --> 00:11:45,830
algo que era verdade.

233
00:11:45,830 --> 00:11:46,630
E o que foi que eu fiz?

234
00:11:46,630 --> 00:11:51,540
Eu fiz algo parecido com dar
me um inteiro positivo,

235
00:11:51,540 --> 00:11:52,430
pouco mais de um prompt.

236
00:11:52,430 --> 00:11:53,540
Eu poderia usar todas as palavras que eu quero.

237
00:11:53,540 --> 00:11:54,960
E então eu usei o quê?

238
00:11:54,960 --> 00:11:59,530
Int n é igual a ficar int,
sem argumentos para isso.

239
00:11:59,530 --> 00:12:00,550
>> E notar a diferença.

240
00:12:00,550 --> 00:12:04,680
Quando você chamar uma função, quando você usa
uma função, você não colocar em vazio.

241
00:12:04,680 --> 00:12:08,570
Você só faz isso quando declarar um
função, ensinando o compilador que

242
00:12:08,570 --> 00:12:09,780
ele deve esperar.

243
00:12:09,780 --> 00:12:11,650
Então você não precisa colocar
anular lá mesmo.

244
00:12:11,650 --> 00:12:12,940
>> E agora, o que era a minha condição?

245
00:12:12,940 --> 00:12:19,670
Bem, n não é igual ao positivo,
mas isso é apenas pseudo-código.

246
00:12:19,670 --> 00:12:22,530
Então, como posso expressar isso de forma mais limpa?

247
00:12:22,530 --> 00:12:24,090
Assim, a menos que ou igual a zero.

248
00:12:24,090 --> 00:12:26,250
Então, novamente, observe que você pode fazer
inferior ou igual a.

249
00:12:26,250 --> 00:12:28,100
Mesmo que seja dois separados
símbolos, você pode fazê-lo em

250
00:12:28,100 --> 00:12:29,350
o seu teclado como tal.

251
00:12:29,350 --> 00:12:33,950
>> Mas ainda há um bug que
Fiz asneira última vez também.

252
00:12:33,950 --> 00:12:36,950
Eu tenho que declarar -

253
00:12:36,950 --> 00:12:37,460
exatamente.

254
00:12:37,460 --> 00:12:39,640
Eu tenho que declarar n fora
do loop.

255
00:12:39,640 --> 00:12:44,180
Então eu preciso colocar n aqui em cima, e eu não
quero voltar a declará-lo aqui

256
00:12:44,180 --> 00:12:46,480
para que eu não obter uma nova variável.

257
00:12:46,480 --> 00:12:48,860
Eu só quero atribuir um valor aqui.

258
00:12:48,860 --> 00:12:54,320
>> E agora eu não estou bem feito aqui.

259
00:12:54,320 --> 00:12:57,290
Deixe-me chegar à frente de mim
e fingir que sou feito.

260
00:12:57,290 --> 00:13:01,220
Tornar-se positivo, e agora
há um novo erro.

261
00:13:01,220 --> 00:13:04,550
Controle atinge final
função não-vazio.

262
00:13:04,550 --> 00:13:07,760
Então nova mensagem de erro, mas se você tipo
de desmembrar cada uma das palavras,

263
00:13:07,760 --> 00:13:09,620
provavelmente aponta para o que está errado.

264
00:13:09,620 --> 00:13:11,240
>> Controlar.

265
00:13:11,240 --> 00:13:14,250
Controle significa apenas que a ordem
de operações em um programa.

266
00:13:14,250 --> 00:13:16,510
O computador está no controle e
algo deu errado.

267
00:13:16,510 --> 00:13:18,510
Portanto, chega ao fim do
uma função não-vazio.

268
00:13:18,510 --> 00:13:21,760
Que função é aparentemente
referindo?

269
00:13:21,760 --> 00:13:24,790
Que função é não-vazio?

270
00:13:24,790 --> 00:13:27,400
Portanto, obter int positivo, e um pouco
confuso em que o bem,

271
00:13:27,400 --> 00:13:29,010
é uma espécie de vazio.

272
00:13:29,010 --> 00:13:33,070
Ele tem uma especificação de vazio para a sua
argumentos, mas a sua saída vai

273
00:13:33,070 --> 00:13:34,540
ser do tipo n.

274
00:13:34,540 --> 00:13:37,260
Assim, a palavra da esquerda é o
assim chamado tipo de retorno.

275
00:13:37,260 --> 00:13:40,320
A palavra no interior aqui é
O zero ou mais argumentos

276
00:13:40,320 --> 00:13:41,970
que a função recebe.

277
00:13:41,970 --> 00:13:44,060
>> Então o que eu preciso fazer?

278
00:13:44,060 --> 00:13:47,650
Neste ponto, no meu código, linha 21, onde
prompt piscando agora é que eu

279
00:13:47,650 --> 00:13:51,430
tem um int positivo dentro
da variável chamada n.

280
00:13:51,430 --> 00:13:55,200
Como faço para devolvê-lo ao principal?

281
00:13:55,200 --> 00:13:55,960
Literalmente.

282
00:13:55,960 --> 00:13:59,320
Retornar n vírgula.

283
00:13:59,320 --> 00:14:04,090
>> Portanto, assim como Colton voltou um pedaço de
papel com uma resposta para me soltando

284
00:14:04,090 --> 00:14:07,020
aquele pedaço de papel no little black
caixa sobre a mesa, para fazer isso em

285
00:14:07,020 --> 00:14:10,100
código, você, literalmente, basta escrever, o retorno
n, e é como se fosse Colton

286
00:14:10,100 --> 00:14:12,140
entregando-me alguma coisa física.

287
00:14:12,140 --> 00:14:15,870
Neste caso, o que está acontecendo é obter
int positivo vai devolver

288
00:14:15,870 --> 00:14:19,220
o que é provavelmente positivo
inteiro para quem?

289
00:14:19,220 --> 00:14:21,380
Onde é que esse valor acabar?

290
00:14:21,380 --> 00:14:29,080
Isso acaba nesta variável, n, e
então vamos continuar com a linha de nove.

291
00:14:29,080 --> 00:14:31,920
>> Assim, em outras palavras, a fim de
operações, este programa começa

292
00:14:31,920 --> 00:14:34,430
execução, eo compilador percebe,
oh, você quer a biblioteca?

293
00:14:34,430 --> 00:14:36,310
Deixe-me ir agarrar o que está dentro disso.

294
00:14:36,310 --> 00:14:37,750
Oh, você quer a biblioteca IO padrão?

295
00:14:37,750 --> 00:14:39,660
Deixe-me ir agarrar o que está dentro disso.

296
00:14:39,660 --> 00:14:44,510
O que faz o compilador dizer para si mesmo
quando atinge quatro linhas?

297
00:14:44,510 --> 00:14:47,980
Oh, você prometeu para implementar o
função chamada ficar positivo, mas

298
00:14:47,980 --> 00:14:50,820
vamos voltar a isso mais tarde,
algo nesse sentido.

299
00:14:50,820 --> 00:14:53,450
>> Int void main significa apenas aqui
as entranhas do meu programa.

300
00:14:53,450 --> 00:14:54,990
Linha sete é apenas uma chaveta.

301
00:14:54,990 --> 00:14:59,540
Linha de oito está dizendo à esquerda, dar
me 32 bits para um inteiro, chamá-lo de n.

302
00:14:59,540 --> 00:15:02,160
No lado direito, é
dizendo se int positivo.

303
00:15:02,160 --> 00:15:07,120
Agora vamos fazer uma pausa nessa história, porque agora
Eu não manter em movimento o meu cursor para baixo.

304
00:15:07,120 --> 00:15:11,720
Meu cursor agora se põe aqui porque
agora começar int positivo executa.

305
00:15:11,720 --> 00:15:13,100
Int n é declarada.

306
00:15:13,100 --> 00:15:14,040
Faça o seguinte.

307
00:15:14,040 --> 00:15:16,090
Printf me dá um número inteiro positivo.

308
00:15:16,090 --> 00:15:19,740
>> Obter um int do usuário, armazená-lo em n,
e talvez fazer isso de novo e de novo.

309
00:15:19,740 --> 00:15:23,010
Este ciclo significa que este código pode
executar cima e para baixo como este novamente

310
00:15:23,010 --> 00:15:25,810
e de novo, mas quando o utilizador finalmente
coopera e me dá um positivo

311
00:15:25,810 --> 00:15:31,750
int, eu bati em linha de 21, altura em que o
número é entregue de volta, e que uma

312
00:15:31,750 --> 00:15:34,280
devo destacar agora?

313
00:15:34,280 --> 00:15:35,070
Nine.

314
00:15:35,070 --> 00:15:39,010
Controlo, por assim dizer, retorna
para alinhar nove.

315
00:15:39,010 --> 00:15:40,650
Essa é a linha que está agora no comando.

316
00:15:40,650 --> 00:15:43,250
>> Então, isso é o que está acontecendo
desta vez sob o capô, mas

317
00:15:43,250 --> 00:15:46,480
quando usamos funções como printf
ou até obter corda que alguém

318
00:15:46,480 --> 00:15:50,600
escreveu para você, o controle estava sendo entregue
para outra pessoa da linha de código

319
00:15:50,600 --> 00:15:51,290
por linha por linha.

320
00:15:51,290 --> 00:15:53,770
É só que não podia vê-lo e nós
realmente não poderia representá-lo neste

321
00:15:53,770 --> 00:15:57,620
programa, porque ele está em algum outro
arquivo no disco rígido

322
00:15:57,620 --> 00:16:00,000
sem o conhecimento de nós.

323
00:16:00,000 --> 00:16:02,100
Então, vamos realmente compilar
e executar isso agora.

324
00:16:02,100 --> 00:16:03,890
>> Faça positiva.

325
00:16:03,890 --> 00:16:05,260
Compilar, isso é progresso.

326
00:16:05,260 --> 00:16:06,650
. / Positivo.

327
00:16:06,650 --> 00:16:08,020
Dê-me um número inteiro positivo.

328
00:16:08,020 --> 00:16:08,800
Vamos ser difícil.

329
00:16:08,800 --> 00:16:10,430
Negativo 1.

330
00:16:10,430 --> 00:16:11,360
Zero.

331
00:16:11,360 --> 00:16:13,370
Vamos dar-lhe 50.

332
00:16:13,370 --> 00:16:18,100
Obrigado pela 50, e assim por controle
já retornou.

333
00:16:18,100 --> 00:16:21,750
Qualquer dúvida, então, sobre isso?

334
00:16:21,750 --> 00:16:23,180
Sim?

335
00:16:23,180 --> 00:16:25,630
>> [Inaudível].

336
00:16:25,630 --> 00:16:26,130
>> Diga novamente.

337
00:16:26,130 --> 00:16:27,860
Oh, boa pergunta.

338
00:16:27,860 --> 00:16:31,100
Assim, você pode notar um paralelo aqui que
Eu sou o tipo de corte de um canto.

339
00:16:31,100 --> 00:16:35,420
Na linha 12, eu estou dizendo que, se int positivo
retorna um int, mas por esse mesmo

340
00:16:35,420 --> 00:16:39,660
lógica, agora lógico que em
linha seis, eu estou dizendo que os principais retornos

341
00:16:39,660 --> 00:16:44,040
um int, mas o que temos nunca
tinha em qualquer um de nossos programas?

342
00:16:44,040 --> 00:16:46,470
Nós nunca tivemos menção de
esta palavra-chave retorno.

343
00:16:46,470 --> 00:16:49,970
>> Assim, verifica-se que em C, pelo menos
a versão que estamos usando

344
00:16:49,970 --> 00:16:55,750
feito em 1999, tecnicamente, este é
passa automaticamente para você.

345
00:16:55,750 --> 00:16:59,300
Toda vez que você implementar um programa e você
implementar uma função chamada principal,

346
00:16:59,300 --> 00:17:04,230
que a função retornará zero
padrão, se você não dizer o contrário,

347
00:17:04,230 --> 00:17:05,849
e zero é apenas uma convenção.

348
00:17:05,849 --> 00:17:09,430
O mundo retorna zero, assim,
indicando que está tudo bem,

349
00:17:09,430 --> 00:17:13,040
efetivamente nos deixando com quatro bilhões
possíveis coisas que podem dar

350
00:17:13,040 --> 00:17:17,530
errado para que se voltarmos um, que
pode significar um código que significa que este

351
00:17:17,530 --> 00:17:18,310
coisa deu errado.

352
00:17:18,310 --> 00:17:20,589
Nós poderíamos voltar dois, o que significa
essa outra coisa deu errado.

353
00:17:20,589 --> 00:17:23,440
Poderíamos voltar quatro bilhões, o que
significa essa outra coisa deu errado.

354
00:17:23,440 --> 00:17:27,170
>> E se você agora pensar sobre o seu próprio
PC ou Mac, você deve se lembrar que

355
00:17:27,170 --> 00:17:29,610
às vezes você recebe mensagens de erro enigmáticas
do software que você está

356
00:17:29,610 --> 00:17:32,650
utilizando e, às vezes, tem um humano
descrição amigável, mas há

357
00:17:32,650 --> 00:17:35,265
frequentemente um código ou um número
na tela?

358
00:17:35,265 --> 00:17:37,800
Se isso não vêm à mente,
apenas manter um olho para fora para ele.

359
00:17:37,800 --> 00:17:40,790
Isso é geralmente o que estes
códigos está se referindo.

360
00:17:40,790 --> 00:17:44,200
Eles estão incluídos no Microsoft Word e
outros programas, de modo que, se você apresentar uma

361
00:17:44,200 --> 00:17:48,850
relatório de bug com a empresa, você pode
dizer-lhes, oh, eu tenho o número do erro 45.

362
00:17:48,850 --> 00:17:51,750
E algum programador de volta na empresa
pode olhar que em sua

363
00:17:51,750 --> 00:17:54,940
código e dizer, oh, isso é porque eu fiz
esse bug e é por isso que o usuário

364
00:17:54,940 --> 00:17:56,240
tenho essa mensagem.

365
00:17:56,240 --> 00:17:59,490
>> Mas, francamente, é um pouco
distracção e um pouco entediante para

366
00:17:59,490 --> 00:18:02,130
Conclui-se que, pelo menos, no nosso
primeiros programas, por isso temos

367
00:18:02,130 --> 00:18:02,970
foi omiti-lo.

368
00:18:02,970 --> 00:18:07,450
Mas todo esse tempo, cada um de seu
funções principal secretamente tinha essa

369
00:18:07,450 --> 00:18:11,600
linha adicionada automaticamente para você pelo
compilador, apenas por convenção

370
00:18:11,600 --> 00:18:13,172
poupar algum tempo.

371
00:18:13,172 --> 00:18:14,620
>> [Inaudível].

372
00:18:14,620 --> 00:18:16,250
>> Você não precisa incluí-la no principal.

373
00:18:16,250 --> 00:18:16,700
Isso é bom.

374
00:18:16,700 --> 00:18:20,260
Você precisa incluí-lo se você fosse
implementação de uma função como essa.

375
00:18:20,260 --> 00:18:22,850
Caso contrário, a função plana
fora não iria funcionar.

376
00:18:22,850 --> 00:18:24,480
Mas, no principal, não é necessário.

377
00:18:24,480 --> 00:18:28,450
Em uma semana ou duas, vamos começar a receber
em que o hábito, uma vez que pretende iniciar

378
00:18:28,450 --> 00:18:29,690
significando erros.

379
00:18:29,690 --> 00:18:32,550
Pergunta muito boa.

380
00:18:32,550 --> 00:18:36,880
>> Pausa verbal tão rápido para mencionar que
nesta sexta-feira, que não vai ter almoço

381
00:18:36,880 --> 00:18:39,980
per se, mas vamos ter um jantar com
alguns dos alunos e funcionários.

382
00:18:39,980 --> 00:18:42,940
Se você gostaria de se juntar a nós, sinta-se
livre para ir para cs50.net/rsvp.

383
00:18:42,940 --> 00:18:45,030
06:00 desta sexta-feira.

384
00:18:45,030 --> 00:18:47,990
O espaço é, como sempre, limitado, mas vamos
continuar a fazê-los em um quase

385
00:18:47,990 --> 00:18:51,420
semanalmente se o espaço
se esgota nesta semana.

386
00:18:51,420 --> 00:18:56,160
>> Assim, o suspense que paramos em
Segunda-feira era que as cordas pode realmente

387
00:18:56,160 --> 00:19:00,520
ser indexado em, que significa apenas que você
pode começar no primeiro caractere, o

388
00:19:00,520 --> 00:19:03,770
segundo personagem, o terceiro personagem
e assim por diante, porque você pode

389
00:19:03,770 --> 00:19:07,860
efetivamente pensar em uma string, como
Olá, como neste caso, de cinco

390
00:19:07,860 --> 00:19:09,670
letras dentro de caixas.

391
00:19:09,670 --> 00:19:13,370
E você pode obter em cada um desses
caixas com o que fizemos sintaxe

392
00:19:13,370 --> 00:19:15,230
apresentar na segunda-feira?

393
00:19:15,230 --> 00:19:16,760
Esses colchetes
em seu teclado.

394
00:19:16,760 --> 00:19:18,980
Isso significava apenas ir até o local zero.

395
00:19:18,980 --> 00:19:22,840
>> Começamos a contar do zero, então o suporte
de zero significa h, suporte de um

396
00:19:22,840 --> 00:19:25,170
significa e, e assim por diante.

397
00:19:25,170 --> 00:19:28,490
E assim o tempo todo quando nós estivemos
usando cordas e digitar "Olá"

398
00:19:28,490 --> 00:19:31,250
e "mundo" e outras coisas em
tela, ele foi armazenado

399
00:19:31,250 --> 00:19:32,820
em caixas como esta.

400
00:19:32,820 --> 00:19:33,370
E dar um palpite.

401
00:19:33,370 --> 00:19:37,470
O que é que cada caixa de representar fisicamente
dentro do seu computador?

402
00:19:37,470 --> 00:19:38,250
>> [Inaudível].

403
00:19:38,250 --> 00:19:39,150
>> Desculpe?

404
00:19:39,150 --> 00:19:39,580
>> Caracteres.

405
00:19:39,580 --> 00:19:44,760
>> Assim, um personagem, certamente, no caso
de cordas, e um personagem é apenas

406
00:19:44,760 --> 00:19:46,800
oito bits ou um byte.

407
00:19:46,800 --> 00:19:49,550
Então você provavelmente tem pelo menos vagamente
familiarizado com o fato de que o seu

408
00:19:49,550 --> 00:19:50,500
computador tem memória.

409
00:19:50,500 --> 00:19:52,110
Tem dois tipos de memória, pelo menos.

410
00:19:52,110 --> 00:19:54,810
Um deles é o disco rígido onde você salvar
coisas de forma permanente, e isso é

411
00:19:54,810 --> 00:19:57,400
tipicamente grande, por isso você pode ter filmes
música e assim por diante.

412
00:19:57,400 --> 00:20:04,010
>> Então você tem um outro tipo de memória
chamada RAM, R-A-M, Random Access

413
00:20:04,010 --> 00:20:07,510
Memória, e este é o tipo de memória
que é usado quando o computador é

414
00:20:07,510 --> 00:20:11,520
funcionando, mas se você perder o poder ou a sua
bateria morre, tudo o que está armazenado

415
00:20:11,520 --> 00:20:15,300
na RAM desaparece se você perder o poder
completamente, porque não é

416
00:20:15,300 --> 00:20:16,060
persistente.

417
00:20:16,060 --> 00:20:19,120
Você normalmente tem, nos dias de hoje, um
show dele, dois shows, talvez mais.

418
00:20:19,120 --> 00:20:23,490
E a cabeça de RAM é que ela é muito
muito mais rápido do que os discos rígidos

419
00:20:23,490 --> 00:20:27,390
ou até mesmo drives de estado sólido nos dias de hoje,
mas é geralmente mais caro por isso

420
00:20:27,390 --> 00:20:28,480
você tem menos.

421
00:20:28,480 --> 00:20:32,400
>> Então, a conversa de hoje realmente se refere
para a memória RAM, que tipo de memória que

422
00:20:32,400 --> 00:20:35,270
só existe enquanto há poder
sendo alimentada em seu computador.

423
00:20:35,270 --> 00:20:40,530
Então, quando você digitar H-E-L-L-O, Enter
o teclado, o H vai numa

424
00:20:40,530 --> 00:20:44,550
byte de memória RAM, o E está indo em
outro byte de RAM, como é

425
00:20:44,550 --> 00:20:45,800
o resto da palavra.

426
00:20:45,800 --> 00:20:49,010
Então, lembro que fomos capazes
para fazer última vez foi esta.

427
00:20:49,010 --> 00:20:53,940
Deixe-me ir em frente e abrir o arquivo
que chamamos string.c, e recordar

428
00:20:53,940 --> 00:20:56,860
que ele parecia um pouco
algo como isto.

429
00:20:56,860 --> 00:20:59,860
Permitam-me, na verdade, reverter e mudar
é exatamente o que parecia,

430
00:20:59,860 --> 00:21:02,654
comprimento da corda de s.

431
00:21:02,654 --> 00:21:04,560
>> Então olhe para o programa aqui.

432
00:21:04,560 --> 00:21:08,530
Nós incluímos a biblioteca CS50 assim
que podemos usar se string.

433
00:21:08,530 --> 00:21:11,400
Nós incluímos io.h padrão
por isso podemos usar printf.

434
00:21:11,400 --> 00:21:13,580
Por que nós incluímos string.h?

435
00:21:13,580 --> 00:21:16,980
Isso era novo na segunda-feira.

436
00:21:16,980 --> 00:21:18,230
Então, nós queríamos comprimento da corda.

437
00:21:18,230 --> 00:21:19,090
Str Comp.

438
00:21:19,090 --> 00:21:21,470
As pessoas decidiram há alguns anos,
vamos ser apenas sucinto.

439
00:21:21,470 --> 00:21:24,290
Em vez de chamá-lo "comprimento da corda"
vamos chamá-lo de "str Comp" e deixar o

440
00:21:24,290 --> 00:21:28,540
figura mundial que fora, e por isso é
que temos acesso com string.h.

441
00:21:28,540 --> 00:21:29,390
>> Este é familiar.

442
00:21:29,390 --> 00:21:30,320
Este é familiar.

443
00:21:30,320 --> 00:21:31,450
Este é familiar.

444
00:21:31,450 --> 00:21:32,370
Isto é um pouco novo.

445
00:21:32,370 --> 00:21:35,420
Na linha 22 - e vamos voltar
para isso, mas agora sei -

446
00:21:35,420 --> 00:21:37,880
e você só sei que este tenha
leia a documentação ou se

447
00:21:37,880 --> 00:21:39,010
você já sabia C -

448
00:21:39,010 --> 00:21:41,510
obter corda, por vezes, pode estragar.

449
00:21:41,510 --> 00:21:45,130
Se o usuário é realmente contraditório ou
cooperante e ele ou ela só

450
00:21:45,130 --> 00:21:49,450
não digitar nada no teclado ou
tipos tanto no teclado que

451
00:21:49,450 --> 00:21:53,760
ele domina a memória do computador,
em teoria, obter corda poderia retornar

452
00:21:53,760 --> 00:21:56,270
algo diferente de um
seqüência de caracteres.

453
00:21:56,270 --> 00:22:01,930
Poderia retornar um valor especial chamado
NULL em todas as tampas, N-L-L-L, e esta é

454
00:22:01,930 --> 00:22:03,390
apenas um chamado valor sentinela.

455
00:22:03,390 --> 00:22:08,010
É um valor especial que significa
algo de ruim aconteceu neste caso.

456
00:22:08,010 --> 00:22:10,520
É a ausência de uma sequência.

457
00:22:10,520 --> 00:22:16,190
>> Então nulo Estou verificando simplesmente para que,
Resumindo, str Leng e

458
00:22:16,190 --> 00:22:20,230
outras funções que vêm com C, se
eles esperam uma corda, mas você passá-los

459
00:22:20,230 --> 00:22:23,630
a ausência de uma string, se você passar
eles NULL, o computador ou o programa

460
00:22:23,630 --> 00:22:25,000
só vai falhar completamente.

461
00:22:25,000 --> 00:22:25,610
Ele vai travar.

462
00:22:25,610 --> 00:22:27,250
Ele vai vomitar alguma mensagem de erro.

463
00:22:27,250 --> 00:22:28,690
Coisas ruins vão acontecer.

464
00:22:28,690 --> 00:22:31,130
Assim, mesmo que este ainda é
não bem definido -

465
00:22:31,130 --> 00:22:33,730
isso vai fazer mais sentido em uma semana ou
dois - na linha 22, este é apenas um

466
00:22:33,730 --> 00:22:38,790
exemplo de auto verificação de erros defensivos
apenas no caso de um tempo fora de

467
00:22:38,790 --> 00:22:42,040
um milhão de algo der errado, a
menos o meu programa não irá falhar.

468
00:22:42,040 --> 00:22:45,960
>> Então, se s não é igual a algo ruim,
Eu tenho esse loop for, e isso foi

469
00:22:45,960 --> 00:22:47,710
onde tivemos que outro
nova peça de sintaxe.

470
00:22:47,710 --> 00:22:51,580
Eu tenho um loop de iteração
zero até o comprimento do s.

471
00:22:51,580 --> 00:22:56,140
E então aqui, eu era uma impressão de fora s
suporte de i, mas por que eu uso% c todos

472
00:22:56,140 --> 00:23:00,770
repente, em vez de% s até
que s é uma string?

473
00:23:00,770 --> 00:23:02,110
É um personagem, não é?

474
00:23:02,110 --> 00:23:06,560
S é uma string, mas s suporte de alguma coisa,
s suporte i, onde i é zero

475
00:23:06,560 --> 00:23:10,380
ou um ou dois, isso é um indivíduo
caractere na cadeia, e assim por

476
00:23:10,380 --> 00:23:14,970
que, printf precisa de ser informada de que
é na verdade um personagem que esperar.

477
00:23:14,970 --> 00:23:18,096
>> E então lembro, o que fez isso
programa realmente faz?

478
00:23:18,096 --> 00:23:19,848
>> Impresso-lo em colunas.

479
00:23:19,848 --> 00:23:21,120
>> Sim, exatamente.

480
00:23:21,120 --> 00:23:24,990
Ela só imprimiu a palavra que eu digitar
uma coluna, um caractere por linha.

481
00:23:24,990 --> 00:23:26,190
Então vamos ver isso de novo.

482
00:23:26,190 --> 00:23:27,810
Então faça string.

483
00:23:27,810 --> 00:23:30,200
Compilado OK. . / String.

484
00:23:30,200 --> 00:23:35,560
Deixe-me digitar H-E-L-L-O, Enter e
na verdade eu entendo, um por linha.

485
00:23:35,560 --> 00:23:37,280
>> Então deixe-me fazer uma otimização aqui.

486
00:23:37,280 --> 00:23:40,240
Se você pensar sobre isso, especialmente se
você já programou antes, há

487
00:23:40,240 --> 00:23:43,340
sem dúvida, uma ineficiência na linha 24.

488
00:23:43,340 --> 00:23:46,160
Em outras palavras, não é necessariamente
o melhor design.

489
00:23:46,160 --> 00:23:50,200
Simples, pelo menos uma vez você
lembre-se que str Comp é, mas é

490
00:23:50,200 --> 00:23:52,640
fazendo burrice potencialmente.

491
00:23:52,640 --> 00:23:54,863
O que pode ser isso?

492
00:23:54,863 --> 00:23:56,280
>> [Inaudível].

493
00:23:56,280 --> 00:23:56,800
>> Exatamente.

494
00:23:56,800 --> 00:24:00,340
É verificando o comprimento do s
a cada momento, mesmo que

495
00:24:00,340 --> 00:24:02,980
H-E-L-L-O sempre vai
ser de cinco caracteres.

496
00:24:02,980 --> 00:24:05,490
Cada vez que através desta malha,
a cinco não está a mudar.

497
00:24:05,490 --> 00:24:08,750
Eu poderia estar incrementando i, mas o que
é o comprimento do s em cada

498
00:24:08,750 --> 00:24:09,690
iteração deste loop?

499
00:24:09,690 --> 00:24:15,810
É cinco, é cinco, que é cinco, e
ainda estou perguntando isso, no entanto

500
00:24:15,810 --> 00:24:18,320
pergunta de novo e de novo e de novo.

501
00:24:18,320 --> 00:24:20,750
Agora, francamente, o computador é tão maldita
rápido, ninguém vai notar uma

502
00:24:20,750 --> 00:24:23,780
diferença de, neste caso, mas estes tipos
de decisões de design pobre pode

503
00:24:23,780 --> 00:24:28,330
começar a somar se o próprio compilador
não tentar corrigir isso para você que

504
00:24:28,330 --> 00:24:30,630
que normalmente não faria, pelo
pelo menos no interior do aparelho.

505
00:24:30,630 --> 00:24:31,540
>> Então eu vou fazer isso.

506
00:24:31,540 --> 00:24:34,580
Eu estou indo para adicionar uma vírgula depois
minha primeira variável, i.

507
00:24:34,580 --> 00:24:37,310
Eu vou me dar outro
variável, chamando-n, apenas por

508
00:24:37,310 --> 00:24:41,330
convenção para números, e então eu estou
vai atribuir n o valor de cadeia

509
00:24:41,330 --> 00:24:42,530
comprimento do s.

510
00:24:42,530 --> 00:24:46,060
E então eu vou mudar
minha condição de ser o que?

511
00:24:46,060 --> 00:24:51,960
Eu vou mudar a minha condição
para quando eu for menor que n.

512
00:24:51,960 --> 00:24:55,700
>> Então, agora, quantas vezes sou eu
verificar o comprimento do s?

513
00:24:55,700 --> 00:25:00,110
Certa vez, mas é OK para verificar i contra
n uma e outra vez, porque agora os

514
00:25:00,110 --> 00:25:03,170
Os valores não estão realmente mudando.

515
00:25:03,170 --> 00:25:06,020
Agora, por enquanto, só sei que quando você
chamar uma função, há um pouco de

516
00:25:06,020 --> 00:25:09,930
em cima, não o suficiente para desanimá-lo
realmente sempre de utilizar as funções, mas

517
00:25:09,930 --> 00:25:12,750
certamente quando há uma linha de código
assim - e as linhas vai ficar

518
00:25:12,750 --> 00:25:15,490
mais interessante antes do tempo - onde
há uma oportunidade para pensar, se eu

519
00:25:15,490 --> 00:25:18,320
Digite este código, quantas
vezes ele vai executar?

520
00:25:18,320 --> 00:25:20,950
Você vai começar a ver ao longo do tempo a
desempenho de seus programas podem

521
00:25:20,950 --> 00:25:21,660
de fato mudar.

522
00:25:21,660 --> 00:25:24,110
>> Na verdade, um dos problemas define temos
feito no ano passado, envolve

523
00:25:24,110 --> 00:25:27,600
implementação, como você deve se lembrar de
semana zero, um corretor ortográfico, mas uma

524
00:25:27,600 --> 00:25:31,380
corretor ortográfico que é projetado para suportar
um dicionário de 150 mil mais

525
00:25:31,380 --> 00:25:32,860
palavras que dão a vocês.

526
00:25:32,860 --> 00:25:37,100
Você teria que escrever um código que carrega
essas palavras na memória RAM, assim em

527
00:25:37,100 --> 00:25:40,700
caixas como vimos na tela de um momento
atrás, e, em seguida, tão rápido quanto você

528
00:25:40,700 --> 00:25:43,740
pode, você precisa ser capaz de responder a uma
questão da forma, é esta palavra

529
00:25:43,740 --> 00:25:44,280
incorreto?

530
00:25:44,280 --> 00:25:45,420
É esta palavra incorreta?

531
00:25:45,420 --> 00:25:46,770
É esta palavra incorreta?

532
00:25:46,770 --> 00:25:49,525
>> E, em algo parecido com isso que nós temos
feito no ano passado se transformou em,

533
00:25:49,525 --> 00:25:53,500
embora em uma base opt-in opcional, um
competição do tipo, em que o

534
00:25:53,500 --> 00:25:59,470
alunos que usam o menos RAM e menos
tempo, menos ciclos de CPU, acabam

535
00:25:59,470 --> 00:26:02,640
borbulhando para o início de um pequeno
placa do líder ou a classificação que colocou em

536
00:26:02,640 --> 00:26:04,770
página inicial do curso, como já
feito nos últimos anos.

537
00:26:04,770 --> 00:26:08,100
Assim, mais uma vez, totalmente opcional, mas esta
fala às oportunidades de design

538
00:26:08,100 --> 00:26:11,250
que estão à frente quando começamos
construção no topo de algumas destas

539
00:26:11,250 --> 00:26:14,010
blocos de construção básicos.

540
00:26:14,010 --> 00:26:16,780
>> Então deixe-me voltar a este diagrama para
apenas um momento e revelar um pouco

541
00:26:16,780 --> 00:26:17,610
algo mais.

542
00:26:17,610 --> 00:26:21,400
Este fato é uma string, e temos tido
vantagem de algumas bibliotecas

543
00:26:21,400 --> 00:26:25,150
io.h padrão que tem -

544
00:26:25,150 --> 00:26:26,110
>> Printf.

545
00:26:26,110 --> 00:26:27,860
>> Printf, entre outras coisas.

546
00:26:27,860 --> 00:26:31,540
cs50.h, que se int e obter cadeia
e assim por diante, string.h, que

547
00:26:31,540 --> 00:26:32,570
teve str Comp.

548
00:26:32,570 --> 00:26:34,800
Mas acontece que há ainda um outro.

549
00:26:34,800 --> 00:26:38,540
Francamente, há muitas e muitas cabeçalho
arquivos que declarar funções

550
00:26:38,540 --> 00:26:43,320
para as bibliotecas, mas isso é ctype.h
realmente vai ser um pouco

551
00:26:43,320 --> 00:26:46,900
vantajoso, porque eu vou
para ir em frente e implementar um

552
00:26:46,900 --> 00:26:48,120
outro programa aqui.

553
00:26:48,120 --> 00:26:52,420
>> Deixe-me ir em frente e abrir mão de algo
Eu escrevi antes chamado

554
00:26:52,420 --> 00:26:55,750
capitalize.c, e vamos dar
uma olhada em como isso funciona.

555
00:26:55,750 --> 00:27:00,340
Repare que eu estou usando, nesta versão
dele, três arquivos familiares.

556
00:27:00,340 --> 00:27:04,110
Observe que, na linha 18, eu sou
obter uma linha de texto.

557
00:27:04,110 --> 00:27:07,660
Observe na linha 21, eu estou afirmando que
o seguinte código vai

558
00:27:07,660 --> 00:27:12,170
capitalizar s, o que o usuário digitou
, e como eu estou fazendo isso?

559
00:27:12,170 --> 00:27:13,300
Bem, eu estou tomando -

560
00:27:13,300 --> 00:27:14,750
lição aprendida da última vez -

561
00:27:14,750 --> 00:27:18,370
Estou declarando i e n e iteração
sobre os caracteres na string.

562
00:27:18,370 --> 00:27:22,720
E então o que é esse bloco de
código na linha 24 a 27

563
00:27:22,720 --> 00:27:24,550
fazer em termos leigos?

564
00:27:24,550 --> 00:27:27,766

565
00:27:27,766 --> 00:27:29,730
>> Minúsculas carta de volta.

566
00:27:29,730 --> 00:27:30,430
>> Exatamente.

567
00:27:30,430 --> 00:27:35,920
Se s suporte i - por isso, se o i-th
caractere de s, que é de algum

568
00:27:35,920 --> 00:27:40,220
caractere na string, é maior do que
ou igual a um e minúsculas -

569
00:27:40,220 --> 00:27:42,670
lembrar que a dupla comercial
significam e -

570
00:27:42,670 --> 00:27:46,810
e o mesmo personagem, s suporte i, é
inferior ou igual a z minúsculas,

571
00:27:46,810 --> 00:27:50,600
isso significa que é um A ou um b ou c ou
ponto, ponto, ponto ou z, o que significa

572
00:27:50,600 --> 00:27:51,340
é minúscula.

573
00:27:51,340 --> 00:27:52,900
O que eu quero fazer nesse caso?

574
00:27:52,900 --> 00:27:55,010
Bem, eu posso fazer isso um pouco
enigmaticamente, mas

575
00:27:55,010 --> 00:27:56,160
vamos provocar este apart.

576
00:27:56,160 --> 00:28:00,210
>> Eu vou ligar para o printf, imprime% c
porque eu quero reimprimir este

577
00:28:00,210 --> 00:28:01,580
personagem na tela.

578
00:28:01,580 --> 00:28:06,650
Estou passando então a ter suporte s i, o
i-th personagem s, e depois porque

579
00:28:06,650 --> 00:28:12,330
estou fazendo este pequeno truque aqui,
minúsculas Um capital de menos?

580
00:28:12,330 --> 00:28:16,352
O que é que vai dar
me, de um modo geral?

581
00:28:16,352 --> 00:28:18,600
>> [Inaudível].

582
00:28:18,600 --> 00:28:19,390
>> Exatamente.

583
00:28:19,390 --> 00:28:20,860
Eu realmente não me lembro -

584
00:28:20,860 --> 00:28:24,390
que foi de 65 para o capital A. Eu realmente não
lembre-se que é um minúsculo,

585
00:28:24,390 --> 00:28:25,540
mas não importa.

586
00:28:25,540 --> 00:28:26,580
O computador sabe.

587
00:28:26,580 --> 00:28:30,380
Assim dizendo, minúsculas a menos
maiúsculo, é estranho ser

588
00:28:30,380 --> 00:28:33,530
subtraindo um char de outro, mas
quais são chars debaixo do capô?

589
00:28:33,530 --> 00:28:34,520
Eles são apenas números.

590
00:28:34,520 --> 00:28:36,980
Então o que esses números são,
deixar que o computador lembre-se que

591
00:28:36,980 --> 00:28:38,240
em vez de o-me humana.

592
00:28:38,240 --> 00:28:41,710
>> Então minúsculas uma capital menos um é
vai me dar a diferença.

593
00:28:41,710 --> 00:28:45,370
Ele passa a ser de 32, e que seria
o caso de minúsculas b e de capital B

594
00:28:45,370 --> 00:28:45,930
e assim por diante.

595
00:28:45,930 --> 00:28:47,710
Ele permanece consistente, felizmente.

596
00:28:47,710 --> 00:28:51,930
Então, eu estou dizendo essencialmente, tomar o
letra minúscula, subtrair off que

597
00:28:51,930 --> 00:28:55,340
diferença de padrão, e que
efetivamente mudanças s suporte de i

598
00:28:55,340 --> 00:28:59,400
minúsculas, é claro, maiúscula,
sem que eu realmente ter que pensar

599
00:28:59,400 --> 00:29:03,040
sobre ou lembre-se, o que eram aqueles
números falamos sobre quando os oito

600
00:29:03,040 --> 00:29:04,800
voluntários surgiu no palco?

601
00:29:04,800 --> 00:29:08,800
Agora, enquanto isso, no mais, se não é
uma letra minúscula, conforme determinado

602
00:29:08,800 --> 00:29:10,400
pela linha 24, apenas imprimi-lo.

603
00:29:10,400 --> 00:29:12,590
Eu só quero tocar a
caracteres que eram

604
00:29:12,590 --> 00:29:14,410
na verdade originalmente minúsculas.

605
00:29:14,410 --> 00:29:15,150
>> Então, vamos ver isso.

606
00:29:15,150 --> 00:29:17,400
Faça capitalizar.

607
00:29:17,400 --> 00:29:18,470
Compilado, OK.

608
00:29:18,470 --> 00:29:19,730
. / Capitalizar.

609
00:29:19,730 --> 00:29:23,530
E deixe-me digitar H-E-L-L-O
em letras minúsculas, Enter.

610
00:29:23,530 --> 00:29:26,370
E perceber que ele é convertido
em letras maiúsculas.

611
00:29:26,370 --> 00:29:27,940
Deixe-me fazer isso de novo com
uma palavra diferente.

612
00:29:27,940 --> 00:29:32,720
Que tal D-A-V-I-D com o primeiro D
capitalizados como um nome tipicamente é?

613
00:29:32,720 --> 00:29:33,560
Enter.

614
00:29:33,560 --> 00:29:34,870
Observe ainda é correta.

615
00:29:34,870 --> 00:29:40,250
Ele só emitido o primeiro inalterada D
via que qualquer outra construção.

616
00:29:40,250 --> 00:29:42,170
>> Portanto, tenha em mente, então, um
algumas coisas aqui.

617
00:29:42,170 --> 00:29:45,060
Um, se você quiser conferir dois
condições de uma só vez, você pode e eles

618
00:29:45,060 --> 00:29:46,500
juntos, como prevíamos.

619
00:29:46,500 --> 00:29:49,900
Você pode comparar personagens dessa maneira
e tratar eficazmente personagens como

620
00:29:49,900 --> 00:29:53,050
números, mas, francamente, isso é tão maldita
críptica eu nunca vou me lembrar

621
00:29:53,050 --> 00:29:56,510
Como chegar a esta a partir do zero
sem raciocinar com ele por um bom

622
00:29:56,510 --> 00:29:57,140
um pouco de tempo.

623
00:29:57,140 --> 00:30:00,590
>> Não teria sido bom se alguém
lá fora, escreveu uma função chamada é

624
00:30:00,590 --> 00:30:05,390
inferior ao que poderia responder por mim verdadeira ou
falsa, este personagem é minúscula?

625
00:30:05,390 --> 00:30:09,350
Bem, felizmente, quem escreveu
ctype.h fez exatamente isso.

626
00:30:09,350 --> 00:30:15,540
Deixe-me ir até aqui e adicionar ctype para c
tipos, e agora deixe-me ir até aqui e

627
00:30:15,540 --> 00:30:18,820
reescrever esta linha como se segue.

628
00:30:18,820 --> 00:30:27,510
>> Então, se ele é chamado é menor, eu afirmo, s
suporte de i, então eu vou apagar

629
00:30:27,510 --> 00:30:29,400
estas duas linhas completamente.

630
00:30:29,400 --> 00:30:32,570
Então agora alguém, eu estou esperando, escreveu
uma função chamada é menor, e é

631
00:30:32,570 --> 00:30:36,250
Acontece que eles fizeram e declararam
lo dentro de ctype.h.

632
00:30:36,250 --> 00:30:39,480
E agora eu vou sair da linha 27
sozinho, eu vou deixá-linha 31

633
00:30:39,480 --> 00:30:41,890
sozinho, mas perceber o quanto eu tenho
reforçou-se o meu código.

634
00:30:41,890 --> 00:30:42,690
É agora mais limpo.

635
00:30:42,690 --> 00:30:47,250
É menos difícil olhar através
porque agora a função, além disso, é

636
00:30:47,250 --> 00:30:50,080
tão maravilhosamente nomeado apenas
faz o que diz.

637
00:30:50,080 --> 00:30:51,520
>> Então agora eu estou indo para salvar este.

638
00:30:51,520 --> 00:30:52,930
Vou diminuir o zoom.

639
00:30:52,930 --> 00:30:56,650
E assim como em risco você poderia ter
Booleanos, valores booleanos verdadeiro ou

640
00:30:56,650 --> 00:31:01,530
falsa, isso é exatamente o que é
efetivamente reduzir retornos.

641
00:31:01,530 --> 00:31:02,960
Deixe-me recompilar.

642
00:31:02,960 --> 00:31:04,500
Deixe-me re-run.

643
00:31:04,500 --> 00:31:07,350
E agora vamos tentar novamente,
H-E-L-L-S, Enter.

644
00:31:07,350 --> 00:31:07,970
Isso é muito bom.

645
00:31:07,970 --> 00:31:10,150
E tente novamente, certifique-se I
não estragar alguma coisa.

646
00:31:10,150 --> 00:31:11,670
Isso é capitalizado também.

647
00:31:11,670 --> 00:31:14,190
>> Mas isso não é bom o suficiente, porque o
outra coisa que eu nunca vou

648
00:31:14,190 --> 00:31:19,090
lembre-se se eu não trabalhar com ele realmente
cuidadosamente sobre, digamos, o papel é

649
00:31:19,090 --> 00:31:19,920
essa linha maldita.

650
00:31:19,920 --> 00:31:23,450
Não seria bom se houvesse
uma função chamada para superior?

651
00:31:23,450 --> 00:31:26,930
Bem, acontece lá fora
está em ctype.h bem.

652
00:31:26,930 --> 00:31:30,150
Eu estou indo para ir em frente e escrever -

653
00:31:30,150 --> 00:31:31,340
deixe-me trazer a linha de volta.

654
00:31:31,340 --> 00:31:36,430
Em vez disso aqui, deixe-me ir em frente
e digo, substituir o% c da

655
00:31:36,430 --> 00:31:42,110
resultado de chamar esta função para
superior do i-th caráter de s.

656
00:31:42,110 --> 00:31:45,430
E agora percebe que está ficando
um pouco equilibrado.

657
00:31:45,430 --> 00:31:48,870
Eu tenho que manter o controle de quantas
parênteses eu abria e fechava.

658
00:31:48,870 --> 00:31:50,050
>> Então, agora é ainda mais limpo.

659
00:31:50,050 --> 00:31:53,460
Agora, este programa está ficando melhor e
melhor projetado, sem dúvida, porque é

660
00:31:53,460 --> 00:31:56,450
muito, muito mais legível, mas
não é nenhuma vamos corrigir.

661
00:31:56,450 --> 00:31:57,600
Faça capitalizar.

662
00:31:57,600 --> 00:31:58,930
. / Capitalizar.

663
00:31:58,930 --> 00:32:03,220
H-E-L-L-S. Vamos executá-lo novamente,
D-V-A-I-D. OK, então ainda estamos em

664
00:32:03,220 --> 00:32:04,250
boa forma.

665
00:32:04,250 --> 00:32:06,030
>> Mas agora a superior.

666
00:32:06,030 --> 00:32:09,720
Proponho que há mais uma
refinamento nós poderíamos fazer isso seria

667
00:32:09,720 --> 00:32:12,820
muito bom, que poderia realmente apertar
se esse código e realmente nos dão cinco

668
00:32:12,820 --> 00:32:15,150
de cinco para o projeto, por exemplo.

669
00:32:15,150 --> 00:32:16,510
O que seria bom para se livrar?

670
00:32:16,510 --> 00:32:20,770
Bem, olha como maldito longo deste bloco de
código é apenas para fazer algo simples.

671
00:32:20,770 --> 00:32:23,850
>> Agora, como um aparte, como você pode ter
visto na seção de super esse passado

672
00:32:23,850 --> 00:32:27,570
fim de semana, você não precisa rigorosamente o
chaves quando você só tem uma

673
00:32:27,570 --> 00:32:32,180
linha de código, mesmo que propusemos
mantê-los de modo que ele faz muito

674
00:32:32,180 --> 00:32:36,190
mais clara, como em forma de U de zero
blocos, o que está dentro do ramo.

675
00:32:36,190 --> 00:32:40,170
Mas não seria bom se a superior,
quando dada a sua entrada, transformou-o em

676
00:32:40,170 --> 00:32:44,730
maiúsculas, se não é, e qual seria
ser maravilhoso, no caso oposto, se

677
00:32:44,730 --> 00:32:47,210
já é maiúsculo?

678
00:32:47,210 --> 00:32:49,620
Apenas passá-lo através
e deixá-lo sozinho.

679
00:32:49,620 --> 00:32:50,660
>> Então talvez seja isso.

680
00:32:50,660 --> 00:32:52,990
Eu poderia tentar e só espero
que ele, mas deixe-me

681
00:32:52,990 --> 00:32:54,450
introduzir uma outra coisa.

682
00:32:54,450 --> 00:32:57,440
Em vez de usar esta built-in do terminal
janela aqui em baixo, lembre-se que

683
00:32:57,440 --> 00:33:01,130
este ícone quadrado preto dá-lhe uma
maior janela de terminal que eu posso encher

684
00:33:01,130 --> 00:33:02,260
tela, se eu quiser?

685
00:33:02,260 --> 00:33:05,820
Então não é que eles são uma espécie de estranho
nomeado, mas não há essas coisas chamadas

686
00:33:05,820 --> 00:33:10,970
man pages, páginas de manual, o homem para breve,
e posso aceder a estes por

687
00:33:10,970 --> 00:33:14,515
digitando man -

688
00:33:14,515 --> 00:33:15,570
o que eu gostaria de escrever?

689
00:33:15,570 --> 00:33:17,830
Homem superior.

690
00:33:17,830 --> 00:33:21,090
>> E agora perceber se existe uma
funcionar no interior do computador, em

691
00:33:21,090 --> 00:33:23,970
Neste caso, o aparelho, que é apenas
o sistema operacional Linux, que vai

692
00:33:23,970 --> 00:33:27,920
para me dar um conjunto um tanto enigmática de
saída, mas você vai encontrar ao longo do tempo que

693
00:33:27,920 --> 00:33:31,720
ele sempre está formatado praticamente o
mesmo assim que você começar a se acostumar com isso.

694
00:33:31,720 --> 00:33:35,130
Observe na parte superior para cima, e
é aparentemente a mesma documentação

695
00:33:35,130 --> 00:33:35,680
para diminuir.

696
00:33:35,680 --> 00:33:38,740
Quem escreveu que estava cortando alguns
cantos e colocar tudo em uma página.

697
00:33:38,740 --> 00:33:40,720
Propósito destas "coisas em
vida é a de converter um

698
00:33:40,720 --> 00:33:42,780
carta a maiúsculas ou minúsculas.

699
00:33:42,780 --> 00:33:46,290
>> Observe que em sinopse, a página man
está me ensinando que arquivo eu tenho

700
00:33:46,290 --> 00:33:48,130
para incluir a usar esta coisa.

701
00:33:48,130 --> 00:33:51,320
Ele está me dando as assinaturas para estes
funções, ambos, até mesmo

702
00:33:51,320 --> 00:33:53,510
embora agora só
se preocupam com um.

703
00:33:53,510 --> 00:33:54,730
Aqui é agora uma descrição.

704
00:33:54,730 --> 00:33:58,800
Para superior converte a letra
c em maiúsculas, se possível.

705
00:33:58,800 --> 00:34:02,280
>> Ainda não é instrutivo, mas deixe-me
agora olhar abaixo do valor de troca, a coisa

706
00:34:02,280 --> 00:34:03,520
que é entregue de volta.

707
00:34:03,520 --> 00:34:08,600
Assim, o valor que é retornado do
carta ou c convertido se o

708
00:34:08,600 --> 00:34:09,870
conversão não foi possível.

709
00:34:09,870 --> 00:34:11,202
O que é c?

710
00:34:11,202 --> 00:34:12,560
>> O caráter original.

711
00:34:12,560 --> 00:34:15,370
>> O personagem original e sabemos
pelo que, de novo, indo até à

712
00:34:15,370 --> 00:34:19,179
sinopse, e quem escreveu isso
função apenas decidiu que a entrada

713
00:34:19,179 --> 00:34:22,909
para a parte superior e inferior é apenas
arbitrariamente vai ser chamado c.

714
00:34:22,909 --> 00:34:24,909
Eles poderiam ter chamado mais nada
eles querem, mas eles mantiveram

715
00:34:24,909 --> 00:34:26,270
simples como c.

716
00:34:26,270 --> 00:34:27,880
Então, eu consultei a página do manual.

717
00:34:27,880 --> 00:34:31,870
Esta frase me garantiu que, se
não é uma letra minúscula, é

718
00:34:31,870 --> 00:34:34,969
vai me dar de volta c, o que é
perfeita, o que significa que pode se livrar de

719
00:34:34,969 --> 00:34:36,199
minha condição de pessoa.

720
00:34:36,199 --> 00:34:39,679
>> Então deixe-me voltar para o Gedit, e
agora deixe-me fazer isso.

721
00:34:39,679 --> 00:34:41,960
Vou copiar a minha instrução printf.

722
00:34:41,960 --> 00:34:45,969
Eu estou indo para ir em frente e à direita dentro
o loop de impressão para fora, e obter

723
00:34:45,969 --> 00:34:48,760
Livrem-se agora toda essa construção se.

724
00:34:48,760 --> 00:34:51,860
Não era uma má idéia, e foi muito
muito correto e consistente com

725
00:34:51,860 --> 00:34:54,100
tudo o que tenho pregado,
Mas não é necessário.

726
00:34:54,100 --> 00:34:57,070
Assim que você perceber alguma biblioteca
função de que existe alguém

727
00:34:57,070 --> 00:35:01,340
escreveu, ou talvez você escreveu em outro lugar
o arquivo, você pode usá-lo e realmente

728
00:35:01,340 --> 00:35:02,690
começar a apertar o código.

729
00:35:02,690 --> 00:35:06,080
>> E quando eu digo coisas como bom estilo,
o fato de que essa pessoa chamada

730
00:35:06,080 --> 00:35:11,490
funcionar a superior, ou anteriormente é
inferior é incrivelmente úteis porque

731
00:35:11,490 --> 00:35:12,900
eles são muito descritivo.

732
00:35:12,900 --> 00:35:16,120
Você não gostaria de chamar as funções
x e y e z, os quais têm

733
00:35:16,120 --> 00:35:19,620
muito, muito menor significado.

734
00:35:19,620 --> 00:35:25,160
Qualquer dúvida sobre essa série
de melhorias?

735
00:35:25,160 --> 00:35:28,010
>> Então, basta dizer que um dos
delivery é mesmo como o seu próprio problema

736
00:35:28,010 --> 00:35:30,960
set - talvez um conjunto de problemas, mas
certamente P definir dois e para a frente, mesmo

737
00:35:30,960 --> 00:35:34,380
quando se está correto não necessariamente
significa que eles são perfeitos apenas

738
00:35:34,380 --> 00:35:36,155
ou ainda particularmente bem desenhado.

739
00:35:36,155 --> 00:35:38,420
Esse é o outro eixo para
começar a pensar.

740
00:35:38,420 --> 00:35:41,730
Portanto, esta foi uma seqüência dentro de sua
memória do computador, mas se você tiver um

741
00:35:41,730 --> 00:35:46,180
grupo inteiro de personagens como H-E-L-L-O
dentro de RAM, e suponha

742
00:35:46,180 --> 00:35:51,330
que em seu programa de chamar obter cadeia
várias vezes de tal forma que você

743
00:35:51,330 --> 00:35:54,200
chamar obter seqüência de uma vez, então você
chamar obter corda novamente.

744
00:35:54,200 --> 00:35:55,880
Bem, o que vai
acontecer ao longo do tempo?

745
00:35:55,880 --> 00:35:59,170
>> Em outras palavras, se você tem uma linha de
código, embora fora de contexto, como

746
00:35:59,170 --> 00:36:02,120
string s fica -

747
00:36:02,120 --> 00:36:02,960
vamos fazer isso.

748
00:36:02,960 --> 00:36:05,270
String nome é igual obter string.

749
00:36:05,270 --> 00:36:08,590
Então suponho que essa linha de código se destina
pedir ao usuário para o seu nome.

750
00:36:08,590 --> 00:36:14,580
Esta próxima linha de código é utilizado para pedir
o usuário para a sua escola, e

751
00:36:14,580 --> 00:36:15,920
esta linha seguinte, e assim por diante.

752
00:36:15,920 --> 00:36:18,150
Suponha que continuo a perguntar
o utilizador para outro e

753
00:36:18,150 --> 00:36:19,750
outra e outra string.

754
00:36:19,750 --> 00:36:22,390
Eles vão ficar na memória
ao mesmo tempo.

755
00:36:22,390 --> 00:36:24,280
Um não vai espancar o outro.

756
00:36:24,280 --> 00:36:26,420
A escola não é substituir o outro.

757
00:36:26,420 --> 00:36:28,520
Mas onde eles fazem tudo
acabar na memória?

758
00:36:28,520 --> 00:36:32,030
>> Bem, se começarmos a desenhar na tela,
que podemos usar essa coisa

759
00:36:32,030 --> 00:36:35,800
aqui como um quadro-negro, se esse preto
retângulo representa o meu computador de

760
00:36:35,800 --> 00:36:39,800
memória, eu vou começar a arbitrariamente
dividindo-o em quadrados pequenos,

761
00:36:39,800 --> 00:36:42,120
cada um dos quais representa
um byte de memória.

762
00:36:42,120 --> 00:36:46,560
Francamente, se você tem um gigabyte de RAM
nos dias de hoje, você tem um bilhão de bytes

763
00:36:46,560 --> 00:36:49,540
de memória em seu computador, de modo
um bilhão dessas praças.

764
00:36:49,540 --> 00:36:52,110
Então, basta dizer que, este
não é realmente a escala.

765
00:36:52,110 --> 00:36:58,250
>> Mas poderíamos ficar tirando todos esses
claramente não escala quadrados, e este

766
00:36:58,250 --> 00:37:01,260
representa coletivamente
memória do meu computador.

767
00:37:01,260 --> 00:37:03,136
Agora vamos fazer ponto, ponto, ponto.

768
00:37:03,136 --> 00:37:06,260
Portanto, em outras palavras, quando eu agora levar o
usuário com a corda get me dar uma

769
00:37:06,260 --> 00:37:07,350
string, o que acontece?

770
00:37:07,350 --> 00:37:14,270
Se o usuário digita em "Olá", que termina
-se em H-E-L-L-S. Mas suponha que o

771
00:37:14,270 --> 00:37:15,720
então o usuário tipos de -

772
00:37:15,720 --> 00:37:17,250
na verdade, eu não deveria ter feito
Olá, porque nós estamos pedindo

773
00:37:17,250 --> 00:37:18,330
los por seus nomes.

774
00:37:18,330 --> 00:37:20,580
Então, vamos voltar se eu posso fazer isso.

775
00:37:20,580 --> 00:37:26,130
>> Então, se eu digitar D-A-V-I-D para o meu nome,
mas lembro que a segunda linha de

776
00:37:26,130 --> 00:37:29,220
código foi obter a cadeia novamente
para obter a sua escola.

777
00:37:29,220 --> 00:37:32,090
Onde é que a palavra que o usuário
tipos em indo para ir junto?

778
00:37:32,090 --> 00:37:38,290
Bem, talvez ele vai entrar em
H-A-R-V-A-R-D. Assim, mesmo que eu tenho

779
00:37:38,290 --> 00:37:41,560
desenhado como duas linhas, este é apenas
um monte de bytes em sua

780
00:37:41,560 --> 00:37:42,710
RAM do computador.

781
00:37:42,710 --> 00:37:46,560
Há um problema agora, porque agora se eu sou
usando RAM neste muito razoável

782
00:37:46,560 --> 00:37:49,910
mas uma espécie de forma ingênua, o que pode
aparentemente não distinguir?

783
00:37:49,910 --> 00:37:52,640

784
00:37:52,640 --> 00:37:54,680
Onde começa um e onde
termina um, certo?

785
00:37:54,680 --> 00:37:55,860
Eles são o tipo de borrar juntos.

786
00:37:55,860 --> 00:37:57,920
>> Assim, verifica-se que o computador
não faz isso.

787
00:37:57,920 --> 00:38:04,720
Deixe-me realmente rolar de volta no tempo a
poucos personagens, e ao invés de Harvard

788
00:38:04,720 --> 00:38:09,570
vai imediatamente após o nome do usuário,
o usuário realmente fica, por trás

789
00:38:09,570 --> 00:38:12,000
das cenas, um personagem especial
inserido pela

790
00:38:12,000 --> 00:38:13,885
computador para ele ou ela.

791
00:38:13,885 --> 00:38:19,470
/ 0, também conhecido como o personagem nul
annoyingly chamado N-U-L, nem

792
00:38:19,470 --> 00:38:22,190
N-L-L-L, mas você escrevê-lo como / 0.

793
00:38:22,190 --> 00:38:27,130
É que todos os bits zero é um marcador de
entre a primeira palavra que o utilizador

794
00:38:27,130 --> 00:38:28,290
digitado eo segundo.

795
00:38:28,290 --> 00:38:33,020
>> Então Harvard realmente agora termina
como essa seqüência de caracteres

796
00:38:33,020 --> 00:38:36,110
e um mais / 0.

797
00:38:36,110 --> 00:38:41,690
Assim, em outras palavras, fazendo com que estes
valores sentinela, de oito a zero contígua

798
00:38:41,690 --> 00:38:45,220
pedaços, agora você pode começar a distinguir
um personagem de outro.

799
00:38:45,220 --> 00:38:49,720
Então, todo esse tempo que estava "Olá" é
na verdade, "Olá" com a / 0, e

800
00:38:49,720 --> 00:38:53,580
entretanto, pode muito bem
ser um pouco mais memória RAM

801
00:38:53,580 --> 00:38:56,400
no interior do computador.

802
00:38:56,400 --> 00:38:57,810
>> Deixe-me fazer uma outra coisa agora.

803
00:38:57,810 --> 00:39:01,800
Acontece que todas essas praças
temos vindo a desenhar, eles são, sim,

804
00:39:01,800 --> 00:39:06,140
cordas, mas mais geralmente,
essas coisas são matrizes.

805
00:39:06,140 --> 00:39:10,590
Uma matriz é apenas um pedaço de memória
que está de volta para fazer a volta para trás,

806
00:39:10,590 --> 00:39:15,130
e você normalmente usa uma matriz por meio
desta notação colchete.

807
00:39:15,130 --> 00:39:18,210
Então, vamos ver estes um pouco
ao longo do tempo, mas deixe-me ir em frente e

808
00:39:18,210 --> 00:39:21,160
abrir, vamos chamá-lo as idades.

809
00:39:21,160 --> 00:39:23,920
E observe o que podemos fazer com
estes mesmos truques, um pouco

810
00:39:23,920 --> 00:39:25,750
pouco mais de sintaxe aqui.

811
00:39:25,750 --> 00:39:29,270
>> Assim, na linha 17 deste programa -
Na verdade, deixe-me executar o programa primeiro

812
00:39:29,270 --> 00:39:30,770
para que possamos ver o que essa coisa faz.

813
00:39:30,770 --> 00:39:33,530
Deixe-me chamar para fazer as idades
compilar este programa.

814
00:39:33,530 --> 00:39:34,950
As idades. /.

815
00:39:34,950 --> 00:39:36,480
Quantas pessoas estão na sala?

816
00:39:36,480 --> 00:39:38,020
Chamá-lo de três.

817
00:39:38,020 --> 00:39:39,575
Idade da primeira pessoa?

818
00:39:39,575 --> 00:39:42,710
18, 19 e 20.

819
00:39:42,710 --> 00:39:46,770
E agora um pouco ridícula, eu só
fizeram um programa que idades os

820
00:39:46,770 --> 00:39:47,740
três pessoas.

821
00:39:47,740 --> 00:39:50,390
>> Portanto, há claramente uma oportunidade
por alguma aritmética diversão aqui.

822
00:39:50,390 --> 00:39:51,560
Felizmente, a matemática está correta.

823
00:39:51,560 --> 00:39:54,720
18 foi para 19, 19 foram
a 20 e assim por diante.

824
00:39:54,720 --> 00:39:58,510
Mas o que realmente significava ser
ilustrativo aqui é a forma como estamos armazenando

825
00:39:58,510 --> 00:40:00,190
idades dessas três pessoas.

826
00:40:00,190 --> 00:40:02,370
Deixe-me aproximar o que está
acontecendo aqui.

827
00:40:02,370 --> 00:40:06,240
>> Então, primeiro, estas primeiras linhas devem
estar recebendo bastante familiar.

828
00:40:06,240 --> 00:40:08,770
Estou apenas alertando o usuário para a
número de pessoas na sala.

829
00:40:08,770 --> 00:40:11,490
Então eu estou usando obter int e fazer enquanto a
fazer isso de novo e de novo e de novo.

830
00:40:11,490 --> 00:40:15,780
Nós vimos que o padrão anterior, mas
linha 27 é novo e bastante

831
00:40:15,780 --> 00:40:18,160
útil, e se tornará
cada vez mais útil.

832
00:40:18,160 --> 00:40:21,620
Observe que o que é diferente em linha 27
é que me parece ser declarar um

833
00:40:21,620 --> 00:40:23,960
int chamados idades, mas esperar.

834
00:40:23,960 --> 00:40:27,140
Não são apenas as idades int.

835
00:40:27,140 --> 00:40:30,130
Há esses colchetes,
dentro da qual é n.

836
00:40:30,130 --> 00:40:35,150
>> Assim, o suporte n neste contexto, não
dentro de uma instrução printf aqui, mas

837
00:40:35,150 --> 00:40:44,370
nessa única linha 27, esta linha está
dizendo, me n ints dar, cada um dos quais

838
00:40:44,370 --> 00:40:46,080
é do tipo int.

839
00:40:46,080 --> 00:40:49,870
Portanto, este é um balde, por assim dizer, de,
neste caso, três inteiros de volta ao

840
00:40:49,870 --> 00:40:52,770
volta para trás para que eu efetivamente
tem três variáveis.

841
00:40:52,770 --> 00:40:54,890
A alternativa, ser
claro, seria este.

842
00:40:54,890 --> 00:40:57,400
>> Se eu quisesse o primeiro aluno
idade, eu poderia fazer isso.

843
00:40:57,400 --> 00:40:59,520
Se eu quisesse o segundo aluno
idade que eu poderia fazer isso.

844
00:40:59,520 --> 00:41:01,860
Se eu quisesse o terceiro aluno
idade, eu poderia fazer isso.

845
00:41:01,860 --> 00:41:04,320
E Deus me livre que precisamos de todo mundo
idade nesta sala -

846
00:41:04,320 --> 00:41:07,670
Quero dizer, este é um pedaço de um monte de cópia,
colar de novo e de novo e de novo.

847
00:41:07,670 --> 00:41:10,870
E mais uma vez eu compilar este programa,
se outro aluno caminha sobre a

848
00:41:10,870 --> 00:41:14,200
daquela porta, agora meu número
de variáveis ​​está incorreto.

849
00:41:14,200 --> 00:41:17,450
>> Então, o que é agradável sobre uma matriz é como
Assim que você começar a sentir-se

850
00:41:17,450 --> 00:41:20,190
copiando e colando, as probabilidades são que é
não é a melhor abordagem.

851
00:41:20,190 --> 00:41:22,240
Uma matriz é dinâmica potencialmente.

852
00:41:22,240 --> 00:41:24,610
Eu não sei com antecedência quantas pessoas
vão estar na sala,

853
00:41:24,610 --> 00:41:28,670
mas eu sei que eu preciso n delas, e eu vou
descobrir n quando chegar a hora.

854
00:41:28,670 --> 00:41:35,500
Esta linha de código significa que agora, me dê um
pedaço de memória que se parece com isso

855
00:41:35,500 --> 00:41:40,380
onde o número de caixas na tela
é inteiramente dependente do que n

856
00:41:40,380 --> 00:41:42,010
o usuário digitou dentro

857
00:41:42,010 --> 00:41:44,850
>> Então, agora o resto do programa é
realmente muito semelhante ao que

858
00:41:44,850 --> 00:41:46,860
apenas fiz com os personagens.

859
00:41:46,860 --> 00:41:49,970
Repare que eu tenho um loop
começando na linha 30.

860
00:41:49,970 --> 00:41:54,920
Então, logo depois que eu pegar o array, I
iteração de y é igual a zero em até n.

861
00:41:54,920 --> 00:41:58,890
Eu só tenho este printf instrutivo
mensagem dizendo, dá-me a idade

862
00:41:58,890 --> 00:42:03,690
de pessoa #% i, então o número um,
número dois, número três.

863
00:42:03,690 --> 00:42:04,730
E por que eu fiz isso?

864
00:42:04,730 --> 00:42:08,870
Francamente, os seres humanos preferem contar de um
em até enquanto cientistas da computação,

865
00:42:08,870 --> 00:42:09,620
zerar em cima.

866
00:42:09,620 --> 00:42:11,700
cientistas da computação não vai
usar esse tipo de programa, por isso estamos

867
00:42:11,700 --> 00:42:13,990
vai apenas começar a contar
em um como pessoas normais.

868
00:42:13,990 --> 00:42:17,630
>> E agora, em linha 33, observe a ligeiramente
diferente pedaço de sintaxe.

869
00:42:17,630 --> 00:42:23,710
O i-th idade em que a variável do tipo
matriz é indo para obter um int.

870
00:42:23,710 --> 00:42:25,770
E agora, finalmente, este é apenas
aritmética aqui.

871
00:42:25,770 --> 00:42:29,200
Decidi em um circuito separado para reivindicar
algum tempo passa, e agora neste

872
00:42:29,200 --> 00:42:31,400
circuito separado, estas linhas de executar.

873
00:42:31,400 --> 00:42:35,810
>> Um ano a partir de agora, a pessoa i será i
anos de idade, mas observe este não é o

874
00:42:35,810 --> 00:42:36,500
variável i.

875
00:42:36,500 --> 00:42:38,390
Isto agora é% i para int.

876
00:42:38,390 --> 00:42:43,210
E notem como o primeiro espaço reservado, I
plug-in i + 1, então contamos como uma

877
00:42:43,210 --> 00:42:44,250
pessoa normal.

878
00:42:44,250 --> 00:42:49,190
E, em seguida, para o valor de sua idade, para
i anos de idade, eu tomo as idades suporte

879
00:42:49,190 --> 00:42:52,980
i - e por que eu estou fazendo mais um aqui?

880
00:42:52,980 --> 00:42:53,760
Eles só envelhecido.

881
00:42:53,760 --> 00:42:55,030
É a minha escolha estúpida de programas.

882
00:42:55,030 --> 00:42:56,810
Eles só envelheceu um ano.

883
00:42:56,810 --> 00:42:59,770
Eu poderia digitar qualquer número que
Na verdade, eu quero lá.

884
00:42:59,770 --> 00:43:02,430
>> Então, qual é, na verdade, todos
a relevância aqui?

885
00:43:02,430 --> 00:43:07,610
Bem, deixe-me realmente rolar para trás
aqui e pintar um quadro

886
00:43:07,610 --> 00:43:10,830
do que está por vir.

887
00:43:10,830 --> 00:43:15,720
O que vamos fazer com o nosso próximo
Problema Set Two é imiscuir-se no

888
00:43:15,720 --> 00:43:17,070
mundo da criptografia.

889
00:43:17,070 --> 00:43:22,500
Portanto, esta é uma cadeia de caracteres, de modo a
seqüência de vários caracteres, eo que

890
00:43:22,500 --> 00:43:23,750
que isso diz?

891
00:43:23,750 --> 00:43:28,530

892
00:43:28,530 --> 00:43:30,600
Não é na versão on-line
dos slides.

893
00:43:30,600 --> 00:43:35,880
>> Então, eu afirmo que isto equivale a isso, uma
propaganda estúpida de muitos anos

894
00:43:35,880 --> 00:43:39,950
há que possa realmente recordar
uma das suas origens.

895
00:43:39,950 --> 00:43:42,740
Portanto, este é um exemplo de criptografia
ou criptografia.

896
00:43:42,740 --> 00:43:46,150
Acontece que, se você quiser
na verdade, enviar informações ou partes

897
00:43:46,150 --> 00:43:49,310
informações com alguém de forma segura,
como uma mensagem como essa, você pode

898
00:43:49,310 --> 00:43:50,500
embaralhar as cartas.

899
00:43:50,500 --> 00:43:53,170
Mas, normalmente, as palavras são
não mexidos aleatoriamente.

900
00:43:53,170 --> 00:43:56,365
Eles estão permutados, de alguma forma ou alterados
de alguma forma para que - oops.

901
00:43:56,365 --> 00:43:59,040
Isso é um spoiler divertido para a próxima vez.

902
00:43:59,040 --> 00:44:04,390
>> Assim, você pode mapear o que é, aparentemente,
O para B. Observe que alinha

903
00:44:04,390 --> 00:44:05,420
capitalização-wise.

904
00:44:05,420 --> 00:44:07,960
Aparentemente, r torna-se e.

905
00:44:07,960 --> 00:44:14,000
Aparentemente F-H-E-R torna-se S-L-R-E. Assim
verifica-se que há um mapeamento, e em

906
00:44:14,000 --> 00:44:18,720
Neste caso, há um muito estúpido
mapeamento se alguém descobri-lo?

907
00:44:18,720 --> 00:44:21,440
Isso é algo chamado
Rot 13, Rodar 13.

908
00:44:21,440 --> 00:44:24,760
É o mais estúpido de criptografia
mecanismos, porque literalmente

909
00:44:24,760 --> 00:44:29,160
acrescenta 13 a cada uma das letras,
estúpido no sentido de que se você apenas

910
00:44:29,160 --> 00:44:31,890
ter um pouco de tempo livre em suas mãos
e um lápis, ou você simplesmente acha que

911
00:44:31,890 --> 00:44:35,260
através de sua cabeça, você pode tentar
todos os acréscimos possíveis - um, dois,

912
00:44:35,260 --> 00:44:38,470
três, ponto, ponto, ponto, de 25 para apenas
rodar o alfabeto inteiro, e

913
00:44:38,470 --> 00:44:40,860
Eventualmente, você vai descobrir
que esta é uma mensagem.

914
00:44:40,860 --> 00:44:43,700
Então, se você fez algo parecido com isso em
escola primária passando mensagens para o seu

915
00:44:43,700 --> 00:44:46,830
melhor amigo, se a sua escola primária
professor simplesmente ler através da

916
00:44:46,830 --> 00:44:50,320
mensagem e ataque de força bruta a solução,
você pode ter começado

917
00:44:50,320 --> 00:44:52,550
uma resposta por isso.

918
00:44:52,550 --> 00:44:54,970
>> Agora, é claro, no mundo real,
criptografia é mais sofisticada.

919
00:44:54,970 --> 00:45:00,120
Este é um trecho do texto de um
sistema de computador que tem nomes de usuário e

920
00:45:00,120 --> 00:45:03,630
senhas, como quase todos da nossa fazer, e
isso é o que sua senha pode

921
00:45:03,630 --> 00:45:07,260
olha como se armazenado em seu disco
dirigir, mas de forma criptografada.

922
00:45:07,260 --> 00:45:11,050
Esta não é apenas uma rotação de letras,
A é B e B é C. Esta é

923
00:45:11,050 --> 00:45:15,620
muito mais sofisticado, mas usa
o que é geralmente conhecido como chave secreta

924
00:45:15,620 --> 00:45:16,690
criptografia.

925
00:45:16,690 --> 00:45:20,210
A imagem diz o seguinte
história com alguns ícones.

926
00:45:20,210 --> 00:45:22,250
>> No lado esquerdo, o que nós temos
vamos chamar de texto simples.

927
00:45:22,250 --> 00:45:25,420
No mundo da criptografia, plain
texto é apenas a mensagem original

928
00:45:25,420 --> 00:45:29,050
escrito em Inglês ou Francês
ou qualquer outra língua qualquer.

929
00:45:29,050 --> 00:45:32,405
Se você quiser criptografar isso, vamos passar
lo através de um cadeado pictoricamente, assim

930
00:45:32,405 --> 00:45:35,580
de algum tipo de algoritmo, algumas funções
ou programa que alguém escreveu

931
00:45:35,580 --> 00:45:39,880
que embaralha as cartas espero
complicatedly mais do que apenas a adição de 13

932
00:45:39,880 --> 00:45:40,980
para cada um deles.

933
00:45:40,980 --> 00:45:43,780
>> O que você sair desse processo no
meio lá é chamado cyphertext.

934
00:45:43,780 --> 00:45:44,850
Assim uma espécie de palavra sexy.

935
00:45:44,850 --> 00:45:47,630
Significa apenas que é o criptografado
versão do texto simples.

936
00:45:47,630 --> 00:45:52,570
E somente se você tiver o mesmo segredo,
13 ou menos 13, você é capaz de

937
00:45:52,570 --> 00:45:54,970
decifrar uma mensagem como essa.

938
00:45:54,970 --> 00:45:57,770
>> Assim, no Conjunto de Problemas Dois, entre as coisas
você vai fazer se no Hacker

939
00:45:57,770 --> 00:46:01,860
Edition, você terá que escrever código para
quebrar essas senhas, descobrir

940
00:46:01,860 --> 00:46:05,170
o que eram e como eram
criptografado, embora nós dar-lhe um pouco

941
00:46:05,170 --> 00:46:06,460
de orientação ao longo do caminho.

942
00:46:06,460 --> 00:46:09,320
Na Standard Edition, introduzimos
um par de cifras, a criptografia

943
00:46:09,320 --> 00:46:12,400
mecanismos, um chamado César, um
chamado Vigenere, que ainda estão

944
00:46:12,400 --> 00:46:16,100
cifras de rotação, onde se torna um
algo, B torna-se algo, mas

945
00:46:16,100 --> 00:46:18,820
você tem que fazê-lo por meio de programação
porque há de fato vai ser um segredo

946
00:46:18,820 --> 00:46:22,840
chave envolvidos, que normalmente é um número
ou uma palavra-chave que só o

947
00:46:22,840 --> 00:46:26,420
remetente eo destinatário destes
mensagens devem entender.

948
00:46:26,420 --> 00:46:28,660
>> Agora, isso tem realmente encarnações
no mundo real.

949
00:46:28,660 --> 00:46:32,910
Este, por exemplo, é pouco órfão
Anel decodificador secreto de Annie, e você

950
00:46:32,910 --> 00:46:35,180
pode realmente implementar essas
cifras de rotação -

951
00:46:35,180 --> 00:46:37,930
Um torna-se algo, B torna-se
alguma coisa - com um par de rodas,

952
00:46:37,930 --> 00:46:40,840
uma no lado de fora, uma no lado de dentro
de tal forma que se você girar a roda ou

953
00:46:40,840 --> 00:46:44,170
o anel, você pode realmente alinhar o
cartas com letras diferentes,

954
00:46:44,170 --> 00:46:45,430
obtenção de um código secreto.

955
00:46:45,430 --> 00:46:48,110
E assim como o gancho para hoje,
o que eu pensei que eu iria fazer é um pouco de

956
00:46:48,110 --> 00:46:52,170
retrocesso que, se você ligar a TV
em 24 de dezembro, você pode assistir a

957
00:46:52,170 --> 00:46:55,390
filme ad nauseum para
24 horas em uma fila.

958
00:46:55,390 --> 00:47:06,030
Mas, por hoje, eu vou abri-lo aqui
e nos dar apenas dois minutos de

959
00:47:06,030 --> 00:47:13,493
História de Natal pedagogicamente relevantes
com um pouco de sujeito chamado Ralphie.

960
00:47:13,493 --> 00:47:14,400
>> [REPRODUÇÃO]

961
00:47:14,400 --> 00:47:17,420
>> -Que seja conhecido por toda a gente que
Ralph Parker é nomeado

962
00:47:17,420 --> 00:47:20,650
membro da Orphan Annie pequena segredo
círculo e tem o direito de todos

963
00:47:20,650 --> 00:47:23,460
as honras e benefícios
ocorrendo ao mesmo.

964
00:47:23,460 --> 00:47:25,990
>> -Assinado, Little Orphan Annie.

965
00:47:25,990 --> 00:47:30,100
Referendado, Pierre Andre em tinta.

966
00:47:30,100 --> 00:47:34,270
Honras e benefícios já
com a idade de nove anos.

967
00:47:34,270 --> 00:47:39,440
>> [GRITANDO ON RADIO]

968
00:47:39,440 --> 00:47:40,770
>> Vamos, vamos logo com isso.

969
00:47:40,770 --> 00:47:44,965
Eu não preciso de tudo o que cerca de jazz
contrabandistas e piratas.

970
00:47:44,965 --> 00:47:48,270
>> -Ouça amanhã à noite para o
concluindo aventura do preto

971
00:47:48,270 --> 00:47:49,650
navio pirata.

972
00:47:49,650 --> 00:47:53,320
Agora, é hora de segredo de Annie
Mensagem para vocês, membros

973
00:47:53,320 --> 00:47:55,720
de The Secret Circle.

974
00:47:55,720 --> 00:47:56,580
Lembre-se, crianças.

975
00:47:56,580 --> 00:48:01,720
Apenas os membros do Círculo Secreto de Annie
pode decodificar mensagem secreta de Annie.

976
00:48:01,720 --> 00:48:05,872
Lembre-se, Annie está dependendo de você.

977
00:48:05,872 --> 00:48:08,670
Defina os seus pinos para B2.

978
00:48:08,670 --> 00:48:11,000
Aqui está a mensagem.

979
00:48:11,000 --> 00:48:12,335
12, 11, 2 -

980
00:48:12,335 --> 00:48:14,670
>> -Estou no meu primeiro encontro secreto.

981
00:48:14,670 --> 00:48:19,720
>> -25, 14, 11, 18, 16 -

982
00:48:19,720 --> 00:48:21,650
>> -Pierre estava em grande voz hoje à noite.

983
00:48:21,650 --> 00:48:24,830
Eu poderia dizer que a mensagem de hoje à noite
foi muito importante.

984
00:48:24,830 --> 00:48:26,400
>> -3, 25.

985
00:48:26,400 --> 00:48:28,540
Essa é uma mensagem de Annie se.

986
00:48:28,540 --> 00:48:30,086
Lembre-se, não diga a ninguém.

987
00:48:30,086 --> 00:48:34,370

988
00:48:34,370 --> 00:48:38,710
>> -90 Segundos depois, estou na única sala
na casa onde um menino de nove anos

989
00:48:38,710 --> 00:48:42,668
poderia sentar em privacidade e decodificação.

990
00:48:42,668 --> 00:48:47,628
Aha, B. Eu fui para o outro.

991
00:48:47,628 --> 00:48:53,060
E. A primeira palavra é "ser". S.
Ele estava chegando mais fácil agora.

992
00:48:53,060 --> 00:48:54,980
U. 25.

993
00:48:54,980 --> 00:48:55,940
Isso é R.

994
00:48:55,940 --> 00:48:56,900
>> -Vamos lá, Ralphie.

995
00:48:56,900 --> 00:48:57,860
Eu tenho que ir.

996
00:48:57,860 --> 00:48:59,780
>> -Eu vou estar bem para baixo, Ma.

997
00:48:59,780 --> 00:49:01,030
Mirabolantes.

998
00:49:01,030 --> 00:49:04,300

999
00:49:04,300 --> 00:49:08,220
>> -T. O. Certifique-se.

1000
00:49:08,220 --> 00:49:09,500
Certifique-se de quê?

1001
00:49:09,500 --> 00:49:11,660
Qual foi a Little Orphan
Annie está tentando dizer?

1002
00:49:11,660 --> 00:49:12,844
Certifique-se de quê?

1003
00:49:12,844 --> 00:49:14,732
>> -Ralphie, Randy tem que ir.

1004
00:49:14,732 --> 00:49:16,148
Quer fazer o favor de sair?

1005
00:49:16,148 --> 00:49:17,092
>> -Tudo bem, mãe.

1006
00:49:17,092 --> 00:49:18,510
Eu estarei fora.

1007
00:49:18,510 --> 00:49:20,270
>> -Eu estava ficando mais perto agora.

1008
00:49:20,270 --> 00:49:21,823
A tensão era terrível.

1009
00:49:21,823 --> 00:49:23,045
O que foi?

1010
00:49:23,045 --> 00:49:26,510
O destino do planeta pode
pendurar na balança.

1011
00:49:26,510 --> 00:49:28,985
>> -Ralphie, go gotta de Randy.

1012
00:49:28,985 --> 00:49:32,680
>> -Eu vou estar bem para fora para
crying out loud.

1013
00:49:32,680 --> 00:49:33,956
>> -Quase lá.

1014
00:49:33,956 --> 00:49:35,140
Meus dedos voaram.

1015
00:49:35,140 --> 00:49:36,880
Minha mente estava em uma armadilha de aço.

1016
00:49:36,880 --> 00:49:38,010
Todos os poros vibrou.

1017
00:49:38,010 --> 00:49:39,878
Era quase clara.

1018
00:49:39,878 --> 00:49:43,210
Sim, sim, sim, sim, sim.

1019
00:49:43,210 --> 00:49:49,030
>> -Certifique-se de beber o seu Ovomaltine.

1020
00:49:49,030 --> 00:49:50,280
Ovomaltine?

1021
00:49:50,280 --> 00:49:53,980

1022
00:49:53,980 --> 00:49:55,230
Um comercial porcaria?

1023
00:49:55,230 --> 00:49:58,572

1024
00:49:58,572 --> 00:50:00,694
Filho da puta.

1025
00:50:00,694 --> 00:50:01,900
>> [FIM REPRODUÇÃO DE VÍDEO]

1026
00:50:01,900 --> 00:50:04,260
>> COLUNA 1: Este é CS50, e que
será Problem Set Two.

1027
00:50:04,260 --> 00:50:06,305
Vejo vocês na próxima semana.

1028
00:50:06,305 --> 00:50:08,800
>> COLUNA 2: Na próxima
CS50, isso acontece.

1029
00:50:08,800 --> 00:50:11,060
>> COLUNA 1: Então, um tema que não tem
olhou até agora é

1030
00:50:11,060 --> 00:50:12,220
a de ponteiros de função.

1031
00:50:12,220 --> 00:50:14,540
Agora, um ponteiro de função é apenas
o endereço de um público

1032
00:50:14,540 --> 00:50:17,000
função, mas muito parecido -

1033
00:50:17,000 --> 00:50:18,250
filho de um -

1034
00:50:18,250 --> 00:50:19,670