1
00:00:00,000 --> 00:00:02,270
[Powered by Google Translate] [Semana 2, continuação]

2
00:00:02,270 --> 00:00:04,220
[David J. Malan, Harvard University]

3
00:00:04,220 --> 00:00:06,880
[Esta é CS50. - CS50.TV]

4
00:00:06,880 --> 00:00:10,990
Tudo bem. Este é CS50, e este é o fim da semana 2.

5
00:00:10,990 --> 00:00:14,410
Se você esperar para estar com fome volta a esta hora amanhã,

6
00:00:14,410 --> 00:00:18,620
sei que nós vamos convocar como um pequeno grupo amanhã, quinta-feira, 1:15 pm.

7
00:00:18,620 --> 00:00:21,360
Há essa URL aqui se você gostaria de RSVP.

8
00:00:21,360 --> 00:00:26,740
O espaço é limitado, portanto, por favor, perdoe se o formulário foi preenchido pelo tempo que você preencher isso.

9
00:00:26,740 --> 00:00:29,300
Outra URL, no entanto, que pode ser de interesse é esse.

10
00:00:29,300 --> 00:00:32,369
Em apenas cerca de um mês, o curso vai ser disponibilizado

11
00:00:32,369 --> 00:00:36,890
tudo o mais amplamente por EDX, através do qual as pessoas na Internet será capaz de acompanhar,

12
00:00:36,890 --> 00:00:39,380
engajar no curso bastante activa, na verdade.

13
00:00:39,380 --> 00:00:42,270
Eles vão estar usando o aparelho CS50 e CS50 Discutir

14
00:00:42,270 --> 00:00:45,490
e na maioria das várias ferramentas de software que já vêm usando este semestre.

15
00:00:45,490 --> 00:00:48,710
E uma das iniciativas que gostaria de assumir como uma experiência este ano

16
00:00:48,710 --> 00:00:51,930
é para ver o quanto de conteúdo que pode traduzir

17
00:00:51,930 --> 00:00:53,960
em outras línguas faladas e escritas.

18
00:00:53,960 --> 00:00:57,500
Então, se você pode ter interesse em participar neste projecto

19
00:00:57,500 --> 00:01:02,270
qual iremos fornecer transcrições em inglês e legendas para palestras do curso

20
00:01:02,270 --> 00:01:05,450
e shorts e seminários e seções e similares,

21
00:01:05,450 --> 00:01:08,200
se você falar fluentemente ou escrever fluentemente outra língua,

22
00:01:08,200 --> 00:01:12,290
nós gostaríamos de envolver você neste projeto pelo qual você assume um ou mais dos vídeos,

23
00:01:12,290 --> 00:01:15,200
traduzi-las em uma língua que você conhece muito bem.

24
00:01:15,200 --> 00:01:18,700
>> Para dar-lhe um sentido de interface, não há essa interface de usuário baseada na web

25
00:01:18,700 --> 00:01:22,090
que nós vamos usar que irá criar, essencialmente, uma interface de usuário como este.

26
00:01:22,090 --> 00:01:24,290
Isso foi me ensinando alguns Halloween atrás,

27
00:01:24,290 --> 00:01:27,390
e no lado direito lá em preto ao lado desses carimbos de tempo,

28
00:01:27,390 --> 00:01:31,210
você vai ver as várias coisas que saíram da minha boca naquele dia,

29
00:01:31,210 --> 00:01:34,850
e abaixo, você será capaz de traduzir para outra língua

30
00:01:34,850 --> 00:01:38,690
exactamente o que é o mapeamento entre, neste caso, Inglês e, digamos, espanhol.

31
00:01:38,690 --> 00:01:40,440
Então, é realmente uma ferramenta muito amigável.

32
00:01:40,440 --> 00:01:43,370
Você pode retroceder e avançar muito rapidamente com atalhos de teclado.

33
00:01:43,370 --> 00:01:47,490
Então, se você gostaria de participar nesta experiência e ter suas palavras visto e lido

34
00:01:47,490 --> 00:01:51,850
por potencialmente milhares de pessoas lá fora, por favor, sinta-se livre para participar.

35
00:01:51,850 --> 00:01:54,350
Uma palavra sobre o gatinho de segunda-feira.

36
00:01:54,350 --> 00:02:00,350
Para que não nos enviou uma mensagem de muito assustador, fazer perceber que, como sugerem as horas de expediente

37
00:02:00,350 --> 00:02:03,300
e como secções sugere, o desenho do curso é muito

38
00:02:03,300 --> 00:02:07,360
ter alunos a colaborar e falando para trabalhar com conjuntos de problemas

39
00:02:07,360 --> 00:02:11,260
e problemas juntos, e realmente a linha só vem para baixo,

40
00:02:11,260 --> 00:02:16,010
novamente, o trabalho que, em última análise apresentar deve ser o seu próprio.

41
00:02:16,010 --> 00:02:18,860
E assim, sinceramente, em horário de expediente é totalmente normal,

42
00:02:18,860 --> 00:02:22,240
É totalmente de se esperar mesmo, para estar conversando com algum amigo ao seu lado.

43
00:02:22,240 --> 00:02:24,370
>> Se ele ou ela está lutando com algum tema e você é como,

44
00:02:24,370 --> 00:02:27,940
"Oh, bem, deixe-me dar-lhe um vislumbre de alguma linha de código que eu escrevi", que é bom,

45
00:02:27,940 --> 00:02:31,250
o que acontece, e isso é muito favorável, eu acho que, com o processo de aprendizagem.

46
00:02:31,250 --> 00:02:36,750
Onde a linha fica cruzada é quando a cabeça é uma espécie de inclinada aqui para segundo demasiadas

47
00:02:36,750 --> 00:02:41,160
ou minutos para que realmente ter sido apenas uma oportunidade de desbloqueio para o seu amigo,

48
00:02:41,160 --> 00:02:44,160
e, certamente, quando as coisas ficam trocadas via e-mail e Dropbox e afins,

49
00:02:44,160 --> 00:02:45,640
lá também é a linha.

50
00:02:45,640 --> 00:02:48,620
Então, por todos os meios se sentir confortável e se sentir estimulados a conversar com os amigos

51
00:02:48,620 --> 00:02:52,810
e colegas sobre Série de Exercícios e mais e só perceber que o que você finalmente apresentar

52
00:02:52,810 --> 00:02:57,340
realmente deve ser o produto de sua criação e não outra pessoa.

53
00:02:57,340 --> 00:03:00,490
E assim um dos problemas específicos de domínio para pset2,

54
00:03:00,490 --> 00:03:04,740
que sairá amanhã à noite tarde, é mergulhar no mundo da criptografia,

55
00:03:04,740 --> 00:03:08,970
que é a arte de criptografia ou cifragem da informação,

56
00:03:08,970 --> 00:03:12,600
e esta última instância, para o mundo da segurança.

57
00:03:12,600 --> 00:03:16,560
Agora, a segurança para a maioria de nós vem na forma de mecanismos muito mundanas.

58
00:03:16,560 --> 00:03:19,050
Todos nós temos nomes de usuários e senhas,

59
00:03:19,050 --> 00:03:23,450
e todos nós temos nomes de usuários e senhas muito ruins, mais provável.

60
00:03:23,450 --> 00:03:28,240
>> Se sua senha é a mesma em vários sites, que provavelmente não é a melhor idéia,

61
00:03:28,240 --> 00:03:30,070
como discutiremos em direção final do semestre.

62
00:03:30,070 --> 00:03:34,720
Se sua senha é escrito em uma nota - não é brincadeira - em seu monitor,

63
00:03:34,720 --> 00:03:38,350
que também não é necessariamente o melhor projeto, mas um fenômeno bastante comum.

64
00:03:38,350 --> 00:03:42,470
E se você não está usando criptografia para criptografar suas senhas,

65
00:03:42,470 --> 00:03:44,210
eles são particularmente vulneráveis.

66
00:03:44,210 --> 00:03:47,270
Então, se você acha que está sendo super inteligente por ter um documento do Word oculta

67
00:03:47,270 --> 00:03:49,910
em algum lugar no seu disco rígido que tem todas as suas senhas

68
00:03:49,910 --> 00:03:53,670
mas é em uma pasta que ninguém vai procurar, isso também não é um mecanismo muito seguro.

69
00:03:53,670 --> 00:03:56,990
E então o que pset2 irá introduzir é esta arte de criptografia

70
00:03:56,990 --> 00:04:02,010
e lutando informações para que coisas como senhas são as mais seguras.

71
00:04:02,010 --> 00:04:05,790
O contexto aqui é que, com dados inseguras

72
00:04:05,790 --> 00:04:07,930
vem uma oportunidade de criptografá-lo e para embaralhar-lo.

73
00:04:07,930 --> 00:04:11,470
E de modo que este, por exemplo, é um exemplo de uma mensagem encriptada.

74
00:04:11,470 --> 00:04:14,700
Isso realmente diz algo em Inglês, mas claramente não é totalmente óbvia.

75
00:04:14,700 --> 00:04:18,279
E vamos fechar o círculo hoje a separar o que esta mensagem segredo aqui é.

76
00:04:18,279 --> 00:04:23,490
Mas no mundo real dos computadores, as coisas nem sequer olhar como eles podem ser frases em inglês.

77
00:04:23,490 --> 00:04:28,430
Por exemplo, este é o que você pode encontrar em um padrão do Linux ou Mac ou computador UNIX

78
00:04:28,430 --> 00:04:32,070
em um arquivo que foi outrora chamado de arquivo de senha.

79
00:04:32,070 --> 00:04:34,200
>> Hoje em dia, ele foi transferido para outros lugares.

80
00:04:34,200 --> 00:04:39,210
Mas se você olhar no lugar certo em um sistema, você verá não só seu nome de usuário

81
00:04:39,210 --> 00:04:43,400
ou a de outras pessoas no sistema, mas você vai ver uma versão criptografada da sua senha.

82
00:04:43,400 --> 00:04:47,980
De fato, a cripta palavra ali sugere que o material que se segue é criptografada,

83
00:04:47,980 --> 00:04:52,680
e esta série de letras aparentemente aleatórias e personagens e números e assim por diante

84
00:04:52,680 --> 00:04:56,480
pode ser decifrada apenas por geralmente sabendo algum segredo -

85
00:04:56,480 --> 00:04:58,840
uma palavra secreta, um número secreto -

86
00:04:58,840 --> 00:05:03,160
e assim, de fato, a arte de criptografia, em última análise resume-se a confiança de algum tipo

87
00:05:03,160 --> 00:05:05,650
e saber algo que alguém não faz.

88
00:05:05,650 --> 00:05:10,090
Então, vamos explorar isso em detalhes um pouco mais hoje e no pset para vir.

89
00:05:10,090 --> 00:05:12,200
E agora uma palavra sobre passa / falha.

90
00:05:12,200 --> 00:05:15,360
Especialmente como alguns de vocês já mergulhou pset1, o aparelho,

91
00:05:15,360 --> 00:05:19,080
e um mundo muito novo para si mesmo, perceber que as frustrações e confusão

92
00:05:19,080 --> 00:05:21,700
e apenas a dificuldades técnicas são muito de se esperar,

93
00:05:21,700 --> 00:05:24,180
especialmente com a pset primeiro, onde há tanta coisa nova,

94
00:05:24,180 --> 00:05:27,730
apenas se familiarizar com ls e cd e todos estes comandos arcanos

95
00:05:27,730 --> 00:05:33,050
e um novo ambiente, e é separado do material real e própria programação.

96
00:05:33,050 --> 00:05:36,940
Então percebemos também que há certamente expediente que existem como uma estrutura de apoio.

97
00:05:36,940 --> 00:05:38,880
>> Seções começam no próximo domingo.

98
00:05:38,880 --> 00:05:42,960
Mas o mais importante, se você está se sentindo apenas que este não é o mundo para você,

99
00:05:42,960 --> 00:05:44,710
perceber que realmente levam tempo.

100
00:05:44,710 --> 00:05:48,600
E se não fosse por essa oportunidade há anos para me de tomar um passe de classe / falhar,

101
00:05:48,600 --> 00:05:50,990
honestamente, eu nunca teria sequer pôs os pés na sala de aula.

102
00:05:50,990 --> 00:05:53,690
E você pode mudar isso até, digamos, a segunda-feira quinta do curso,

103
00:05:53,690 --> 00:05:58,280
por isso, se você está na borda agora, perceber que, em vez de cabeça em algumas outras águas completamente,

104
00:05:58,280 --> 00:06:01,260
que certamente considerar apenas mudando a aprovação / reprovação.

105
00:06:01,260 --> 00:06:04,570
Novamente, não há realmente esta cultura aqui em Harvard de levar as coisas de aprovação / reprovação

106
00:06:04,570 --> 00:06:08,670
já que todo mundo realmente quer alcançar ou ultrapassar,

107
00:06:08,670 --> 00:06:11,130
mas, francamente, esta é uma ótima maneira de tentar algo fora

108
00:06:11,130 --> 00:06:16,720
que pode não ser familiar a você, e você vai acabar fazendo, na maioria dos casos, muito bem,

109
00:06:16,720 --> 00:06:18,210
talvez para sua surpresa.

110
00:06:18,210 --> 00:06:20,980
E, em termos mais concretos, o que eu acho que passa / falha geralmente faz,

111
00:06:20,980 --> 00:06:22,940
especialmente no que você pode ter experimentado com pset0,

112
00:06:22,940 --> 00:06:26,560
se você colocar em 10 horas, 15 horas, 25 horas em alguns pset

113
00:06:26,560 --> 00:06:29,920
e você está apenas bater a cabeça contra a parede e está ficando super tarde da noite

114
00:06:29,920 --> 00:06:33,950
mas você tomou os 90% pset do caminho e você simplesmente não consegue descobrir uma coisa,

115
00:06:33,950 --> 00:06:36,520
passa / falha realmente leva a borda fora de uma classe como esta,

116
00:06:36,520 --> 00:06:39,100
onde você pode classificar de dizer felizmente, "Ok, eu sei que não é perfeito,

117
00:06:39,100 --> 00:06:42,350
mas eu trabalhei pra caramba sobre isso, eu estou muito feliz com o local onde ele acabou "

118
00:06:42,350 --> 00:06:44,850
e que vão atender as expectativas de aprovação / reprovação.

119
00:06:44,850 --> 00:06:47,540
Assim que manter isso em mente. Tudo bem.

120
00:06:47,540 --> 00:06:50,520
>> Então, aqueles de vocês que têm se esforçado para usar a Universidade de Harvard Wi-Fi,

121
00:06:50,520 --> 00:06:54,780
sei que há um SSID CS50, uma conexão Wi-Fi, flutuando

122
00:06:54,780 --> 00:06:56,490
que você pode ter melhor sorte para.

123
00:06:56,490 --> 00:07:00,130
É um pouco irônico que a senha para isso, se você gostaria de tentar ligar a este

124
00:07:00,130 --> 00:07:08,350
para velocidades melhores - e deixe-nos saber se não é melhor - é 12345, todo o caminho até a 8

125
00:07:08,350 --> 00:07:10,910
8, porque é mais seguro do que 5.

126
00:07:10,910 --> 00:07:16,910
Então, se você precisa da senha de acesso Wi-Fi, conecte-se sem fio CS50 aqui, 12345678,

127
00:07:16,910 --> 00:07:20,380
e pós em CS50 Discutir se você ainda tiver problemas intermitentes de conectividade,

128
00:07:20,380 --> 00:07:25,420
e vamos deixar que os poderes que conhece para este espaço. Tudo bem.

129
00:07:25,420 --> 00:07:32,230
Então, um teaser rápido, especialmente para aqueles de vocês que são meninos ou meninas de fãs da Apple de todos as coisas.

130
00:07:32,230 --> 00:07:37,460
O que eu retirado de alguns anos atrás era este arquivo aqui, iUnlock.c,

131
00:07:37,460 --> 00:07:39,930
apenas para o tipo de tornar mais concreto e mais complexo

132
00:07:39,930 --> 00:07:42,560
alguns dos programas mais básicos C que tenho escrito.

133
00:07:42,560 --> 00:07:46,910
Então eu abri o arquivo, iUnlock.c. Ele está disponível na página de Palestras para hoje.

134
00:07:46,910 --> 00:07:49,810
No lado esquerdo você verá uma longa lista de funções.

135
00:07:49,810 --> 00:07:53,230
Assim, o sujeito que escreveu este escreveu um monte de funções, mais do que apenas principal.

136
00:07:53,230 --> 00:07:57,340
Ele usou um monte de bibliotecas aqui, e se começarmos a percorrer,

137
00:07:57,340 --> 00:08:04,890
o que isto realmente é, é o primeiro de crack, eu acredito, para o iPhone original.

138
00:08:04,890 --> 00:08:09,830
>> Quando você queria fazer o jailbreak do iPhone original, o que significa untether-os da AT & T

139
00:08:09,830 --> 00:08:13,710
e realmente instalar um software especial sobre ele e fazer as coisas que a Apple não quer que as pessoas fazem,

140
00:08:13,710 --> 00:08:18,480
alguém teve tempo para descobrir exatamente como eles poderiam explorar falhas de software,

141
00:08:18,480 --> 00:08:22,690
erros, bugs em softwares da Apple, e assim nasceu iUnlock.c -

142
00:08:22,690 --> 00:08:26,760
que se você compilou em seu computador e instalá-lo em um iPhone

143
00:08:26,760 --> 00:08:29,430
que foi conectado ao computador através de, por exemplo, um cabo USB,

144
00:08:29,430 --> 00:08:32,450
isto lhe daria privilégios administrativos ou raiz em seu iPhone

145
00:08:32,450 --> 00:08:34,620
e deixá-lo fazer praticamente o que quiser.

146
00:08:34,620 --> 00:08:36,400
E assim houve este gato fascinante e rato

147
00:08:36,400 --> 00:08:39,340
entre a Apple eo resto do mundo, em particular no que se, como muitas empresas,

148
00:08:39,340 --> 00:08:43,350
tentar bloquear as suas coisas para baixo assim que você só pode fazer com ele o que eles pretendem.

149
00:08:43,350 --> 00:08:47,360
Mas, graças a pessoas como esta e para a compreensão de detalhes de baixo nível -

150
00:08:47,360 --> 00:08:50,830
e, neste caso, de programação C - e muitas das construções conhecidas

151
00:08:50,830 --> 00:08:55,280
que já começou a jogar com, você é capaz de realmente alavancar o hardware

152
00:08:55,280 --> 00:08:59,250
de uma maneira que achar melhor e não necessariamente uma entidade corporativa.

153
00:08:59,250 --> 00:09:01,600
Assim, por exemplo, eu não tenho idéia do que tudo isso está fazendo,

154
00:09:01,600 --> 00:09:03,580
GetVersion mas soa bastante simples,

155
00:09:03,580 --> 00:09:05,710
e parece que esta é uma função que a pessoa escreveu.

156
00:09:05,710 --> 00:09:09,250
É preciso algum tipo de número inteiro como argumento, não retorna nada,

157
00:09:09,250 --> 00:09:13,710
mas parece loop com um laço e um aqui se a condição, se a interrupção condição,

158
00:09:13,710 --> 00:09:16,770
e de alguma forma se relaciona com números de versão se deslocar para baixo,

159
00:09:16,770 --> 00:09:19,650
mesmo que muitas destas palavras-chave vai ser novo.

160
00:09:19,650 --> 00:09:22,590
E há toda uma série de funções no aqui nunca vimos e talvez nunca mais ver

161
00:09:22,590 --> 00:09:24,350
ao longo do semestre.

162
00:09:24,350 --> 00:09:29,160
>> No final do dia, ele segue as mesmas regras e lógica que temos vindo a jogar até agora.

163
00:09:29,160 --> 00:09:34,340
Portanto, este é velho demais para quebrar seu iPhone ou 3s 4s 5s ou logo estes dias,

164
00:09:34,340 --> 00:09:38,830
mas sei que está tudo muito derivado deste mundo que nós mergulhou.

165
00:09:38,830 --> 00:09:42,280
Vamos dar uma olhada em um exemplo um pouco mais simples:

166
00:09:42,280 --> 00:09:46,260
este, apenas para se aquecer com uma sintaxe e também outro tipo de dados

167
00:09:46,260 --> 00:09:48,910
que temos falado, mas realmente não tenho visto em C.

168
00:09:48,910 --> 00:09:53,670
Este é um arquivo chamado positive1.c, e por os comentários na parte superior,

169
00:09:53,670 --> 00:09:56,070
este apenas exige que um utilizador forneça um número positivo.

170
00:09:56,070 --> 00:09:59,910
Então, é um exemplo de um loop do-tempo, o que é bom para os programas de usuário interativas

171
00:09:59,910 --> 00:10:02,070
onde você precisa dizer ao usuário para fazer alguma coisa,

172
00:10:02,070 --> 00:10:05,530
e se eles não cooperarem você gritar com eles ou rejeitar a sua entrada.

173
00:10:05,530 --> 00:10:10,480
Caso em questão: Eu vou fazer linhas de 19 a 24

174
00:10:10,480 --> 00:10:14,620
desde que o usuário não tenha me dado um número positivo.

175
00:10:14,620 --> 00:10:21,340
Este detalhe aqui na linha 18, por que eu declarar n acima deste looping toda construção

176
00:10:21,340 --> 00:10:26,870
em oposição à direita ao lado da linha 22, onde eu realmente importam para obter n? Sim.

177
00:10:26,870 --> 00:10:29,330
[Aluno] Escopo. >> Sim, então essa questão da abrangência.

178
00:10:29,330 --> 00:10:31,770
E, em termos leigos, o que âmbito se refere?

179
00:10:34,880 --> 00:10:41,560
Sim. >> [Resposta do aluno inaudível] >> Você pode falar um pouco mais alto?

180
00:10:41,560 --> 00:10:45,440
[Aluno] Onde você pode acessar essa variável. >> Perfeito.

181
00:10:45,440 --> 00:10:47,610
Onde você pode acessar uma determinada variável.

182
00:10:47,610 --> 00:10:50,990
E, geralmente, a regra de ouro até agora tem sido a de que o alcance de algumas variáveis

183
00:10:50,990 --> 00:10:56,140
é definido pelas chaves mais recentes encaracolados que você já viu.

184
00:10:56,140 --> 00:11:03,070
>> E por isso, neste caso, se eu cometi o erro de declarar n na linha 22, que a linha iria trabalhar.

185
00:11:03,070 --> 00:11:10,840
Gostaria de obter um int, e gostaria de colocá-lo em que n variável na linha 22,

186
00:11:10,840 --> 00:11:17,060
mas que linha de código que agora não têm idéia do que eu estou falando? >> [Aluno] 25.

187
00:11:17,060 --> 00:11:23,840
[Malan] 25, e verifica-se 24, mas também porque, neste caso, está fora das chaves.

188
00:11:23,840 --> 00:11:28,550
Então, um pouco de incômodo, mas muito fácil de resolver, basta declarar a variável

189
00:11:28,550 --> 00:11:30,700
fora da própria função.

190
00:11:30,700 --> 00:11:32,760
Vamos ver mais tarde hoje você pode ir um passo além

191
00:11:32,760 --> 00:11:34,940
e você pode até ficar um pouco preguiçoso.

192
00:11:34,940 --> 00:11:39,660
E isso não é recomendado em geral, mas você pode até ficar com preguiça

193
00:11:39,660 --> 00:11:44,150
e colocar uma variável globalmente, por assim dizer, e não dentro de uma função, e não dentro de um loop,

194
00:11:44,150 --> 00:11:49,800
mas no próprio arquivo, fora de todas as funções que você escreveu, como eu fiz aqui na linha 15.

195
00:11:49,800 --> 00:11:55,220
Este é geralmente desaprovado, mas que esta é uma solução, por vezes, a outros problemas,

196
00:11:55,220 --> 00:11:56,910
como vai finalmente ver.

197
00:11:56,910 --> 00:11:59,500
Então, por agora, vamos deixá-lo assim, mas vamos ver se podemos reescrever essa

198
00:11:59,500 --> 00:12:02,360
só para começar a expressar-nos um pouco diferente.

199
00:12:02,360 --> 00:12:05,550
Este programa, só para ficar claro, é positive1.

200
00:12:05,550 --> 00:12:11,980
Deixe-me ir à frente e aqui na minha janela de terminal fazer positive1, Enter.

201
00:12:11,980 --> 00:12:15,080
Compila bem. Eu vou correr positive1, pressione Enter.

202
00:12:15,080 --> 00:12:19,250
Eu exijo que você me dê um número inteiro positivo. Eu vou dizer -1. Isso não funcionou.

203
00:12:19,250 --> 00:12:22,340
0, 99. Que parece funcionar.

204
00:12:22,340 --> 00:12:25,310
Talvez não o teste mais rigoroso, mas pelo menos é um bom teste de sanidade

205
00:12:25,310 --> 00:12:27,100
que estamos no caminho certo.

206
00:12:27,100 --> 00:12:29,570
>> Então, agora deixe-me ir em frente e abra a versão 2 do presente,

207
00:12:29,570 --> 00:12:32,800
eo que é diferente já?

208
00:12:32,800 --> 00:12:39,030
Ele implementa a mesma coisa, mas o que está pulando fora tão claramente diferente desta vez?

209
00:12:40,790 --> 00:12:47,090
Este bool em verde. Destaca-se no verde, esta palavra-chave conhecida como bool, que é um tipo de dados.

210
00:12:47,090 --> 00:12:50,510
Ele não vem construído em a todas as versões de C.

211
00:12:50,510 --> 00:12:52,650
Você precisa incluir uma biblioteca específica.

212
00:12:52,650 --> 00:12:56,460
No nosso caso, eu incluída a biblioteca CS50 para que tenhamos acesso a bool.

213
00:12:56,460 --> 00:12:59,860
Mas, na linha 18, parece que temos um valor booleano aqui chamado agradecido.

214
00:12:59,860 --> 00:13:02,190
Eu poderia ter chamado este nada, mas eu chamei-lhe grato

215
00:13:02,190 --> 00:13:04,750
apenas para transmitir algum tipo de significado semântico.

216
00:13:04,750 --> 00:13:07,700
Portanto, inicialmente na linha 18, eu não sou aparentemente grato

217
00:13:07,700 --> 00:13:12,230
porque o valor booleano grato é inicializado como false na linha 18.

218
00:13:12,230 --> 00:13:16,500
E então parece que eu fiz aqui em linhas de 21 a 23

219
00:13:16,500 --> 00:13:19,200
é que eu tenho apenas uma espécie de reescrita minha lógica.

220
00:13:19,200 --> 00:13:26,100
Portanto, não funcionalmente diferente, mas na linha 22 agora eu verificar se o int o usuário forneceu

221
00:13:26,100 --> 00:13:31,360
é maior que 0, então eu simplesmente alterar o valor de grato a verdade.

222
00:13:31,360 --> 00:13:35,590
E por que eu faria isso? Porque, na linha 25, aparentemente, eu estou indo para verificar uma condição.

223
00:13:35,590 --> 00:13:39,760
Faça isso loop while grato é falsa.

224
00:13:39,760 --> 00:13:42,960
Então eu propus isso como uma alternativa à versão 1

225
00:13:42,960 --> 00:13:47,050
porque é pelo menos um pouco mais intuitivo, talvez, seja um pouco mais fundamentada em Inglês.

226
00:13:47,050 --> 00:13:51,980
Então faça o seguinte enquanto você não está grato ou agradecido enquanto é falso.

227
00:13:51,980 --> 00:13:56,220
E desta vez também eu, aparentemente, não se preocupam em lembrar o que o usuário digitou

228
00:13:56,220 --> 00:14:00,050
porque não há nenhum aviso n variável, portanto, na verdade, uma pequena mentira lá.

229
00:14:00,050 --> 00:14:03,290
>> Funcionalmente, o programa é um pouco diferente, uma vez que chegar ao fundo da questão

230
00:14:03,290 --> 00:14:04,960
porque eu não estou lembrando o que n é.

231
00:14:04,960 --> 00:14:09,120
Mas eu queria demonstrar aqui também que mesmo que temos visto GetInt

232
00:14:09,120 --> 00:14:13,780
e GetString a ser utilizado no lado da mão direita de um sinal de igual até agora

233
00:14:13,780 --> 00:14:17,310
para que lembrar o valor, tecnicamente, isso não é estritamente necessário.

234
00:14:17,310 --> 00:14:20,290
Se por qualquer motivo você simplesmente não se importam para salvar o valor,

235
00:14:20,290 --> 00:14:25,540
você quer apenas verificar o valor, observe que podemos simplesmente escrever isso como GetInt,

236
00:14:25,540 --> 00:14:27,320
aberto paren, paren perto.

237
00:14:27,320 --> 00:14:30,570
Essa função vai retornar um valor, como temos vindo a dizer.

238
00:14:30,570 --> 00:14:32,220
Vai lhe dar de volta um int.

239
00:14:32,220 --> 00:14:34,460
E se você acha que mentalmente de isso acontecer,

240
00:14:34,460 --> 00:14:38,190
quando eu digitar 99, GetInt retorna o número 99,

241
00:14:38,190 --> 00:14:41,840
e assim, conceitualmente, é como se o meu código eram, na verdade isso.

242
00:14:41,840 --> 00:14:45,950
Então, se 99 é de fato maior que 0, então grato se torna verdade,

243
00:14:45,950 --> 00:14:50,810
depois a linha 25 realiza ooh, estamos a fazer porque eu sou grato agora,

244
00:14:50,810 --> 00:14:53,970
e na linha 26, nós simplesmente dizer: "Obrigado pela inteiro positivo!"

245
00:14:53,970 --> 00:14:55,960
o que quer que estivesse.

246
00:14:55,960 --> 00:14:59,140
Agora vamos fazer açúcar sintático ligeiro aqui, por assim dizer.

247
00:14:59,140 --> 00:15:04,670
Vamos ver se conseguimos limpar essa linha 25 com esta variante terceiro e último positive3.

248
00:15:04,670 --> 00:15:13,600
>> Observe a única diferença agora é que linha de código? >> [Aluno] 25. >> [Malan] Sim, 25.

249
00:15:13,600 --> 00:15:17,680
E nós não temos realmente visto este truque ainda, mas fez ver o ponto de exclamação na segunda-feira,

250
00:15:17,680 --> 00:15:21,070
que denota o quê? >> [Aluno] não. Não >> ou negação.

251
00:15:21,070 --> 00:15:23,510
Então, ter um valor booleano e virar o seu valor.

252
00:15:23,510 --> 00:15:25,810
Torna-se verdadeiro, o falso se torna verdadeiro.

253
00:15:25,810 --> 00:15:30,420
Então isso, eu gostaria de propor, é até um pouco mais intuitiva maneira de escrever o código

254
00:15:30,420 --> 00:15:33,430
porque eu ainda inicializar grato a falsa, eu ainda fazer o seguinte,

255
00:15:33,430 --> 00:15:36,010
Eu defini grato a verdade quando chegar a hora,

256
00:15:36,010 --> 00:15:40,880
mas agora você pode realmente apenas traduzir este código verbalmente esquerda para a direita,

257
00:15:40,880 --> 00:15:45,630
while (grato!);, porque o ponto de exclamação ou estrondo denota a noção de não,

258
00:15:45,630 --> 00:15:47,580
Assim, embora não grato.

259
00:15:47,580 --> 00:15:49,900
Então, novamente, não introduziram novos conceitos em si.

260
00:15:49,900 --> 00:15:53,730
Nós conversamos sobre Booleanos para trás quando nós tocamos com o Scratch,

261
00:15:53,730 --> 00:15:56,720
mas percebo agora podemos apenas começar a escrever o nosso código de muitas maneiras diferentes.

262
00:15:56,720 --> 00:16:01,060
Assim, especialmente no pset1 se você é uma espécie de luta para descobrir a maneira de escrever algum programa,

263
00:16:01,060 --> 00:16:04,340
probabilidades são que você está com sorte, porque não pode haver qualquer número de soluções

264
00:16:04,340 --> 00:16:06,110
que pode acontecer em cima.

265
00:16:06,110 --> 00:16:10,500
Por exemplo, esta é apenas a 3, mesmo para o mais simples dos programas. Tudo bem.

266
00:16:10,500 --> 00:16:14,200
E agora recordar na segunda-feira que deixou esta nota com valores de retorno.

267
00:16:14,200 --> 00:16:18,450
Assim, para a primeira vez que escreveu um programa que não tem apenas principal;

268
00:16:18,450 --> 00:16:22,550
também tem sua própria função personalizada que eu escrevi aqui.

269
00:16:22,550 --> 00:16:26,810
Assim, na linha 31 a 34 eu implementei uma função cubo.

270
00:16:26,810 --> 00:16:30,240
Não é complexo. É apenas a * a * a neste caso.

271
00:16:30,240 --> 00:16:34,750
Mas o que é importante sobre o que é que eu estou tendo de entrada na forma de uma

272
00:16:34,750 --> 00:16:39,180
e estou retornando saída sob a forma de um * a * a.

273
00:16:39,180 --> 00:16:43,560
Então agora eu tenho a capacidade, tanto como eu costumava fazer com prinf sozinho,

274
00:16:43,560 --> 00:16:47,240
chamar esta função chamando a função cubo.

275
00:16:47,240 --> 00:16:51,970
>> E a função cubo tem alguma entrada, ea função cubo retorna alguma saída.

276
00:16:51,970 --> 00:16:56,960
Por outro lado, printf apenas fiz algo.

277
00:16:56,960 --> 00:17:00,840
Ele não retornou qualquer coisa que importava, mesmo que como um aparte ele não retornar um valor;

278
00:17:00,840 --> 00:17:03,110
você geralmente só ignorá-lo.

279
00:17:03,110 --> 00:17:06,510
Printf apenas fiz algo. Ele tinha um efeito colateral de impressão à tela.

280
00:17:06,510 --> 00:17:11,770
Em contraste aqui, temos a função de cubo, que na verdade retorna algo.

281
00:17:11,770 --> 00:17:15,520
Portanto, para aqueles familiarizados com este, que é uma idéia bastante simples.

282
00:17:15,520 --> 00:17:19,640
Mas, para os menos familiarizados com a idéia de passar em entradas e saídas de voltar,

283
00:17:19,640 --> 00:17:21,950
vamos tentar apenas algo simples super.

284
00:17:21,950 --> 00:17:25,490
Alguém está confortável chegando no palco brevemente?

285
00:17:25,490 --> 00:17:28,040
Você tem que estar confortável com uma câmera em você também. Sim? Okay.

286
00:17:28,040 --> 00:17:31,240
Qual é o seu nome? >> [Aluno] Ken. >> Ken. Tudo bem. Ken, vamos lá para cima.

287
00:17:31,240 --> 00:17:35,050
Ken vai ser uma função do tipo aqui.

288
00:17:35,050 --> 00:17:38,720
Vamos em frente e fazer isso. Vamos pegar um pouco de fantasia.

289
00:17:38,720 --> 00:17:42,260
Prazer em conhecê lo. Bem-vindo ao centro do palco. Tudo bem.

290
00:17:42,260 --> 00:17:46,640
Vamos bater este botão aqui. Tudo bem.

291
00:17:46,640 --> 00:17:49,820
Então aqui você tem um quadro moderno,

292
00:17:49,820 --> 00:17:53,470
eo que eu sou é a função principal, por exemplo,

293
00:17:53,470 --> 00:17:56,460
e eu não tenho um iPad na mão.

294
00:17:56,460 --> 00:17:59,710
>> Eu realmente não me lembro como - Bem, eu não posso dizer isso.

295
00:17:59,710 --> 00:18:02,480
Eu realmente não tenho boa caligrafia,

296
00:18:02,480 --> 00:18:05,520
e assim, portanto, eu quero que você imprimir algo na tela para mim.

297
00:18:05,520 --> 00:18:12,040
Eu estou sendo o programa principal, e eu vou ter que dizer isso

298
00:18:12,040 --> 00:18:16,720
escrevendo no meu zero frango e em seguida, passando-lhe uma entrada.

299
00:18:16,720 --> 00:18:20,400
Tão bobo que este exercício é, a noção de funções e chamar uma função

300
00:18:20,400 --> 00:18:22,400
e retornando uma função na verdade se resume a isso.

301
00:18:22,400 --> 00:18:26,260
Estou principal, que acabo de escrever printf, algo entre aspas na tela,

302
00:18:26,260 --> 00:18:29,110
Estou executando este programa, e logo que printf é chamado,

303
00:18:29,110 --> 00:18:32,880
é preciso um argumento ou um parâmetro, por vezes, entre aspas duplas.

304
00:18:32,880 --> 00:18:35,880
Aqui é que o argumento. Estou passando-a para Ken.

305
00:18:35,880 --> 00:18:39,020
Ele é uma caixa preta escrito um certo número de anos atrás

306
00:18:39,020 --> 00:18:41,510
que, aparentemente, só sabe como imprimir coisas na tela.

307
00:18:41,510 --> 00:18:43,150
Então executar.

308
00:18:49,280 --> 00:18:51,280
Isso não é ruim. Muito bom.

309
00:18:51,280 --> 00:18:55,510
Então, agora é feito Ken execução. Será que ele precisa me dar nada em troca?

310
00:18:55,510 --> 00:18:57,470
Não que temos visto até agora.

311
00:18:57,470 --> 00:19:00,460
Mais uma vez, printf faz realmente retornar um número, mas vamos ignorar que, por agora

312
00:19:00,460 --> 00:19:03,470
porque nunca usei. Então é isso para Ken.

313
00:19:03,470 --> 00:19:08,580
E agora principal assume o controle do programa novamente

314
00:19:08,580 --> 00:19:11,060
porque essa linha de código, printf, é feita a execução.

315
00:19:11,060 --> 00:19:14,050
E nós vamos sobre nosso caminho, executando o que as outras linhas estão lá.

316
00:19:14,050 --> 00:19:17,320
Então, agora vamos tentar um exemplo um pouco diferente.

317
00:19:17,320 --> 00:19:24,940
Desta vez, aqui vamos primeiro limpar a tela, e desta vez vamos fazer a função de cubagem,

318
00:19:24,940 --> 00:19:27,080
mas desta vez, espero um valor de saída.

319
00:19:27,080 --> 00:19:29,180
>> Então, vamos em frente e fazer isso.

320
00:19:29,180 --> 00:19:35,790
Agora eu tenho uma linha de código que diz x recebe cubo de x.

321
00:19:41,370 --> 00:19:46,370
A linha de código, recall, fica assim: x = cubo (x);

322
00:19:46,370 --> 00:19:50,930
Então, como é que isto vai funcionar? Vamos em frente e dar-lhe uma tela branca novamente.

323
00:19:50,930 --> 00:19:54,070
Eu vou escrever agora o valor de x,

324
00:19:54,070 --> 00:20:01,400
que, neste momento passa a ser, digamos, de 2 a mantê-lo simples.

325
00:20:01,400 --> 00:20:06,150
Eu escrevi em um pedaço de papel o valor de 2, que é o meu valor x.

326
00:20:06,150 --> 00:20:10,920
Eu entregá-lo a Ken. >> E eu só escrever a resposta? >> Sim, vamos apenas escrever a resposta.

327
00:20:12,760 --> 00:20:18,940
Okay. E agora ele tem de voltar-me algo. Perfeito. Segue agradável.

328
00:20:18,940 --> 00:20:23,120
Então, agora ele me dá de volta o valor de 8, neste caso, eo que eu faço com ele?

329
00:20:23,120 --> 00:20:28,250
Na verdade - vamos ver, obter este direito. O que eu vou fazer com ele?

330
00:20:28,250 --> 00:20:33,440
Agora eu vou levar esse valor e, na verdade, armazená-lo nos mesmos bits na memória.

331
00:20:33,440 --> 00:20:35,170
Mas repare que eu sou o tipo de luta aqui.

332
00:20:35,170 --> 00:20:38,210
Eu estou um pouco confuso, porque onde eu realmente escrever o valor de x,

333
00:20:38,210 --> 00:20:43,150
porque o que eu acabei de fazer é Ken fisicamente mão de um pedaço de papel que tinha o valor 2,

334
00:20:43,150 --> 00:20:46,590
que era x, e, de fato, isso é precisamente o que aconteceu.

335
00:20:46,590 --> 00:20:50,210
Assim, verifica-se que quando você chamar a função e você passar em um argumento

336
00:20:50,210 --> 00:20:53,290
como Olá, mundo ou você passa um argumento como 2,

337
00:20:53,290 --> 00:20:57,110
geralmente, você está passando em uma cópia do argumento.

338
00:20:57,110 --> 00:21:00,730
E assim como eu escrevi o número 2 aqui e entregou-a a Ken,

339
00:21:00,730 --> 00:21:04,720
isso deve significar que eu ainda tenho uma cópia do valor de dois em algum lugar

340
00:21:04,720 --> 00:21:08,890
porque na verdade, agora que eu comecei de volta o valor 8, eu preciso voltar na RAM

341
00:21:08,890 --> 00:21:12,130
e realmente escrever 8, onde uma vez eu tive o número 2.

342
00:21:12,130 --> 00:21:16,950
Assim, visualmente, lembre-se essa noção de passagem em, literalmente, uma cópia do valor.

343
00:21:16,950 --> 00:21:20,780
>> Ken faz sua coisa, me dá de volta algo - neste caso um valor como 8 -

344
00:21:20,780 --> 00:21:24,980
e então eu tenho que fazer alguma coisa com esse valor, se eu quiser mantê-lo por perto.

345
00:21:24,980 --> 00:21:29,650
Então, tudo isso vai voltar a ser tudo muito familiar antes do tempo.

346
00:21:29,650 --> 00:21:34,920
Muito obrigado por esta demo aqui, Ken. [Aplausos]

347
00:21:34,920 --> 00:21:36,920
Muito bem feito.

348
00:21:36,920 --> 00:21:42,690
Vamos ver como é que, em última análise relaciona-se com algumas das funções de chamada que estamos fazendo aqui.

349
00:21:42,690 --> 00:21:47,910
Deixe-me ir em frente e nos trazer de volta ao exemplo cubagem aqui.

350
00:21:47,910 --> 00:21:53,300
Observe que, se queremos realmente começar a tomar isso ainda mais,

351
00:21:53,300 --> 00:21:57,570
vamos ter que estar atentos ao fato de que o número x que está sendo passado aqui

352
00:21:57,570 --> 00:22:01,530
é diferente do que realmente está sendo passado para a função.

353
00:22:01,530 --> 00:22:05,880
Então, novamente, este passe por cópia vai tornar-se bastante pertinente em apenas um momento.

354
00:22:05,880 --> 00:22:09,580
Vamos dar uma olhada em algo que não funciona muito bem certo ainda.

355
00:22:09,580 --> 00:22:13,250
Eu estou indo para ir em frente e abrir um exemplo de buggy terceiro, que é falho por natureza,

356
00:22:13,250 --> 00:22:18,550
e é chamado buggy3 e implementa uma função de troca.

357
00:22:18,550 --> 00:22:25,110
Aqui temos uma função principal que x e y arbitrariamente inicializado com 1 e 2, respectivamente.

358
00:22:25,110 --> 00:22:27,700
Nós poderíamos usar GetInt, mas só precisa de um simples exercício,

359
00:22:27,700 --> 00:22:30,170
então é codificado como 1 e 2.

360
00:22:30,170 --> 00:22:35,340
Nas linhas 21 e 22, que, aparentemente, imprimir x e y, 1 por linha.

361
00:22:35,340 --> 00:22:39,720
Em seguida, na linha 23, eu afirmo que estou trocando estes valores, ponto, ponto, ponto.

362
00:22:39,720 --> 00:22:44,170
Eu aparentemente chamar uma função na linha 24 swap de chamada que leva dois argumentos.

363
00:22:44,170 --> 00:22:48,300
É totalmente legítimo para funções de tomar dois argumentos. Temos visto printf fazê-lo já.

364
00:22:48,300 --> 00:22:51,830
>> Então troca aparentemente leva x e y, e como o próprio nome sugere,

365
00:22:51,830 --> 00:22:54,670
Espero que ele vai trocar esses dois valores.

366
00:22:54,670 --> 00:23:00,090
Então eu reclamar na linha 25 "trocados!" e I reimprimir x e y

367
00:23:00,090 --> 00:23:03,070
sob a suposição de que eles realmente foram trocados.

368
00:23:03,070 --> 00:23:06,080
Mas se eu realmente executar este programa - deixe-me abrir uma janela de terminal,

369
00:23:06,080 --> 00:23:09,860
deixe-me fazer buggy3 - como o nome sugere, isso não vai acabar bem

370
00:23:09,860 --> 00:23:15,770
porque quando eu pressione Enter, observe que x é 1, y é 2,

371
00:23:15,770 --> 00:23:19,420
e ainda, no final do programa, eles ainda são, de facto, o mesmo.

372
00:23:19,420 --> 00:23:22,960
Assim, com base na demonstração apenas agora com Ken, o que está realmente acontecendo?

373
00:23:22,960 --> 00:23:28,710
Vamos mergulhar esta função swap. É super curto. É apenas algumas linhas de código longo.

374
00:23:28,710 --> 00:23:34,520
Mas qual é o problema fundamental, baseado na história simples contada aqui com Ken?

375
00:23:34,520 --> 00:23:36,670
Por que a troca de partido?

376
00:23:36,670 --> 00:23:39,660
[Aluno] Você está armazenando a uma cópia, e não variável.

377
00:23:39,660 --> 00:23:43,980
Exatamente. Nós estamos armazenando a uma cópia, e não a própria variável.

378
00:23:43,980 --> 00:23:47,170
Em outras palavras, troca aparentemente leva dois argumentos, um int,

379
00:23:47,170 --> 00:23:49,370
e é chamada arbitrariamente a e b,

380
00:23:49,370 --> 00:23:54,420
e aqui eu passei em X e Y, que são, respectivamente, 1 e 2,

381
00:23:54,420 --> 00:23:58,770
mas eu não estou literalmente passando em x, eu não estou literalmente passando em y,

382
00:23:58,770 --> 00:24:01,450
Estou passando uma cópia de x e uma cópia do y.

383
00:24:01,450 --> 00:24:04,510
É quase como se você copiado e colado em troca

384
00:24:04,510 --> 00:24:07,810
os valores que você quer que ele realmente manipular.

385
00:24:07,810 --> 00:24:14,480
Então, se esse é o caso, quando eu o início do programa em execução a linha 35, então 36,

386
00:24:14,480 --> 00:24:18,650
quando eu chegar à linha 37, neste ponto da história, o que é o valor de uma?

387
00:24:21,040 --> 00:24:25,050
Neste ponto da história, linha 37, que é o valor de um, neste ponto? >> [Aluno] 1.

388
00:24:25,050 --> 00:24:29,280
[Malan] Deve ser apenas um, certo, porque x foi passado como o primeiro argumento,

389
00:24:29,280 --> 00:24:33,080
e esta função apenas arbitrariamente está chamando seu primeiro argumento um.

390
00:24:33,080 --> 00:24:38,200
Da mesma forma é y o segundo argumento, e é apenas arbitrariamente chamar a b segundo argumento.

391
00:24:38,200 --> 00:24:40,990
>> Esta dicotomia é realmente bastante simples explicou. Pense sobre isso.

392
00:24:40,990 --> 00:24:43,320
Nenhum de nós conheceu a pessoa que escreveu printf,

393
00:24:43,320 --> 00:24:50,770
assim, certamente, ele ou ela não tem idéia do que nossas variáveis ​​30 anos mais tarde vai ser chamado.

394
00:24:50,770 --> 00:24:56,650
Então, tem que haver uma distinção entre o que você chama de variáveis ​​em funções que você está escrevendo

395
00:24:56,650 --> 00:25:02,080
e que vocês chamam de variáveis ​​em funções que você está chamando ou usando.

396
00:25:02,080 --> 00:25:05,340
Portanto, em outras palavras, eu escrevi minhas variáveis ​​como X e Y,

397
00:25:05,340 --> 00:25:08,890
mas se alguém tinha escrito a função swap, ele ou ela certamente não saberia

398
00:25:08,890 --> 00:25:10,690
o que os meus variáveis ​​vão ser chamados,

399
00:25:10,690 --> 00:25:13,830
para perceber que é por isso que você tem esta dualidade de nomes.

400
00:25:13,830 --> 00:25:16,750
Tecnicamente, eu poderia fazer isso por coincidência,

401
00:25:16,750 --> 00:25:20,080
mas eles ainda ser passado como cópias.

402
00:25:20,080 --> 00:25:23,650
Seria apenas pura coincidência esteticamente se essa pessoa que escreveu troca

403
00:25:23,650 --> 00:25:26,150
tinha usado os mesmos nomes.

404
00:25:26,150 --> 00:25:32,370
Portanto, neste ponto da história, linha 37, um é 1, b é 2, e agora devo proceder para trocá-los.

405
00:25:32,370 --> 00:25:34,900
Primeiro de tudo, deixe-me realmente fazer isso muito mais simples.

406
00:25:34,900 --> 00:25:36,690
Eu não sei o que essas três linhas de código foram fazendo.

407
00:25:36,690 --> 00:25:41,210
Deixe-me fazer isso: b = a, a = b; feito.

408
00:25:41,210 --> 00:25:44,690
Por que isso é quebrado, logicamente?

409
00:25:46,490 --> 00:25:48,900
É o tipo da coisa intuitiva, certo?

410
00:25:48,900 --> 00:25:52,560
Assim, torna-se e a b b torna-se,

411
00:25:52,560 --> 00:25:57,730
mas o problema é que, logo que linha 37 é executado, o que é o valor de a e b?

412
00:25:57,730 --> 00:26:03,410
O mesmo, 1, porque você derrotado, por assim dizer, você mudou b para igualar um.

413
00:26:03,410 --> 00:26:08,890
Portanto, uma vez linha 37 foi executado, isso é ótimo, agora você tem duas cópias do número 1

414
00:26:08,890 --> 00:26:13,350
dentro desta função, assim então quando você diz na linha 38 a = b,

415
00:26:13,350 --> 00:26:17,640
você está ferrado tipo de porque você está apenas a atribuição de 1 a 1.

416
00:26:17,640 --> 00:26:20,580
Você meio que perdi o valor que você se preocupava.

417
00:26:20,580 --> 00:26:23,220
Assim, na versão original do presente, observe o que eu fiz.

418
00:26:23,220 --> 00:26:26,850
Eu em vez teve uma terceira linha de código que era assim.

419
00:26:26,850 --> 00:26:28,580
Eu declaro uma variável temporária.

420
00:26:28,580 --> 00:26:32,170
>> Tmp é um nome muito comum para uma variável temporária, e é um int

421
00:26:32,170 --> 00:26:34,580
porque tem que coincidir com o que eu quero fazer uma cópia.

422
00:26:34,580 --> 00:26:39,770
Eu armazenar cópia de um dentro de tmp, então quando linha 37 foi executado,

423
00:26:39,770 --> 00:26:45,860
o valor de a é - verificação de sanidade rápido - 1, o valor de b é 2,

424
00:26:45,860 --> 00:26:48,970
e o valor do tmp também é 1.

425
00:26:48,970 --> 00:26:52,060
Então agora eu executar a linha 38.

426
00:26:52,060 --> 00:27:00,540
Uma vez linha 38 é executado, uma toma o valor de b. E b foi de 2, assim que uma é agora 2.

427
00:27:00,540 --> 00:27:05,210
Assim, neste ponto da história, a é 2, b é 2 e tmp é 1,

428
00:27:05,210 --> 00:27:11,060
agora, logicamente, nós podemos apenas valor tmp plop de em b e estamos a fazer.

429
00:27:11,060 --> 00:27:12,800
Então nós resolvemos esse problema.

430
00:27:12,800 --> 00:27:17,720
Infelizmente, quando eu executar este programa sob esta forma, que na verdade não trocar quaisquer valores.

431
00:27:17,720 --> 00:27:20,100
Mas, para ser claro, por quê?

432
00:27:23,660 --> 00:27:26,450
Corrigi o problema lógico de um momento atrás,

433
00:27:26,450 --> 00:27:31,020
mas, novamente, se eu executar este programa, X e Y permanecem inalterados

434
00:27:31,020 --> 00:27:33,310
até o final da execução do programa.

435
00:27:33,310 --> 00:27:37,220
[Comentário do estudante inaudível] >> Nós não retornou nada, então isso é verdade.

436
00:27:37,220 --> 00:27:39,670
Mas acontece que há um pouco de um problema aqui, porque, até agora,

437
00:27:39,670 --> 00:27:44,170
a única coisa que tenho sido capaz de voltar é uma coisa, e esta é uma restrição de C.

438
00:27:44,170 --> 00:27:49,070
Você só pode voltar realmente um valor, caso em que eu sou o tipo de preso aqui

439
00:27:49,070 --> 00:27:53,310
porque eu poderia retornar o novo valor de x ou eu poderia retornar o novo valor de y,

440
00:27:53,310 --> 00:27:55,190
mas eu quero tanto de volta.

441
00:27:55,190 --> 00:27:58,650
Então, retornando não é a solução simples aqui.

442
00:27:58,650 --> 00:28:01,710
Mas o problema fundamental é por quê? O que nós realmente trocados?

443
00:28:01,710 --> 00:28:04,190
[Estudante] a e b. >> A e b.

444
00:28:04,190 --> 00:28:08,230
Mas a e b são cópias de x e y, o que significa que apenas fez todo este trabalho,

445
00:28:08,230 --> 00:28:11,650
que acabamos passado 3 minutos falando sobre a função de troca e todos os 3 dessas variáveis,

446
00:28:11,650 --> 00:28:15,420
e isso é ótimo, perfeitamente correto em isolamento,

447
00:28:15,420 --> 00:28:20,740
mas e âmbito de b é apenas nestas linhas aqui.

448
00:28:20,740 --> 00:28:24,790
>> Então, tal como um loop, se você declarar um inteiro i dentro do loop for,

449
00:28:24,790 --> 00:28:28,760
Da mesma forma, se você está declarando dentro a e b de uma função que você escreveu,

450
00:28:28,760 --> 00:28:33,320
eles são apenas válido dentro dessa função, o que significa que, logo que swap é feito executando

451
00:28:33,320 --> 00:28:38,470
e vamos da linha 24 para a linha 25, x e y não foram alteradas de forma alguma.

452
00:28:38,470 --> 00:28:42,790
Você desperdiçou apenas um monte de tempo a troca de cópias de variáveis.

453
00:28:42,790 --> 00:28:47,010
Assim, verifica-se que a solução para isso é, na verdade, não óbvia.

454
00:28:47,010 --> 00:28:50,670
Não é bem suficiente para retornar valores, porque só podemos retornar um valor,

455
00:28:50,670 --> 00:28:53,470
e eu realmente quero trocar x e y, ao mesmo tempo,

456
00:28:53,470 --> 00:28:55,210
então nós vamos ter que voltar a este.

457
00:28:55,210 --> 00:29:01,020
Mas, por agora, perceber que a questão fundamentalmente derivada do fato de que a e b são cópias

458
00:29:01,020 --> 00:29:03,630
e eles estão em seu próprio escopo.

459
00:29:03,630 --> 00:29:05,050
Vamos tentar resolver isso de alguma forma.

460
00:29:05,050 --> 00:29:11,250
Deixe-me realmente rolar de volta aqui e abrir-se, digamos, uma quarta variante deste, buggy4.

461
00:29:11,250 --> 00:29:13,370
Que tal isso?

462
00:29:13,370 --> 00:29:17,810
Este é um problema semelhante, mas mais simples de olhar antes de tomar uma facada em resolvê-lo.

463
00:29:17,810 --> 00:29:24,190
Este programa é chamado de incremento, e, aparentemente, inicializa um número inteiro de 1 x na linha 18.

464
00:29:24,190 --> 00:29:28,150
Eu, então, afirmar que x é 1, então eu reclamar "Incrementando ..."

465
00:29:28,150 --> 00:29:33,730
Eu, então, chamar incremento, mas, em seguida, as linhas 22 e 23, eu afirmo que tem sido incrementado,

466
00:29:33,730 --> 00:29:40,220
Eu reivindico x é agora que quer que seja - 2, provavelmente -, mas este programa é buggy.

467
00:29:40,220 --> 00:29:42,610
Qual é o problema?

468
00:29:43,440 --> 00:29:50,160
Sim. >> [Resposta do aluno inaudível] >> Exatamente.

469
00:29:50,160 --> 00:29:52,490
Então x foi declarada, obviamente, na linha 18.

470
00:29:52,490 --> 00:29:54,700
Que está dentro de chaves principais de.

471
00:29:54,700 --> 00:29:58,440
Portanto, a resposta simples é que enquanto x existe aqui,

472
00:29:58,440 --> 00:30:03,930
ela não existe na linha 32, assim que este programa realmente não vai nem compilar.

473
00:30:03,930 --> 00:30:07,940
O compilador quando eu tento compilar este código vai gritar comigo

474
00:30:07,940 --> 00:30:14,100
sobre alguns identificador não declarado ou alguma coisa nesse sentido. Na verdade, vamos tentar.

475
00:30:14,100 --> 00:30:18,470
Esta é fazer buggy4. Não é.

476
00:30:18,470 --> 00:30:22,110
Uso de 'x' identificador não declarado na linha 32.

477
00:30:22,110 --> 00:30:25,580
E, na verdade, vamos ser mais explícito aqui hoje para que isso seja útil

478
00:30:25,580 --> 00:30:27,580
em horário de expediente e em casa.

479
00:30:27,580 --> 00:30:29,300
>> Observe que é um pouco enigmática escrita.

480
00:30:29,300 --> 00:30:37,270
Mas o fato de que Clang tem gritado, dizendo buggy4.c: 32:5, é realmente útil.

481
00:30:37,270 --> 00:30:42,050
Isso significa que o erro está na linha 32 na posição de caractere 5.

482
00:30:42,050 --> 00:30:46,700
Então, 1, 2, 3, 4, 5. Isso é, de fato, onde está o problema.

483
00:30:46,700 --> 00:30:49,790
E, também, também, ter em mente na hora de escritório e em casa, tenho sorte aqui.

484
00:30:49,790 --> 00:30:52,990
Eu tenho um erro. Vai ser relativamente fácil de corrigir.

485
00:30:52,990 --> 00:30:55,990
Mas se você receber uma tela cheia de mensagens de erro esmagadora,

486
00:30:55,990 --> 00:31:00,330
novamente perceber que o mais inferior pode ser apenas um sintoma da um superior.

487
00:31:00,330 --> 00:31:03,450
Então, sempre perseguir seus erros, de cima para baixo

488
00:31:03,450 --> 00:31:05,820
porque não pode ser apenas um efeito em cadeia

489
00:31:05,820 --> 00:31:09,240
que está sugerindo que você tem problemas de maneira mais do que você realmente faz.

490
00:31:09,240 --> 00:31:15,150
Então, como poderíamos corrigir isso se meu objetivo é incrementar x? >> [Aluno] Fazer x global.

491
00:31:15,150 --> 00:31:17,060
Ok, então podemos fazer x global.

492
00:31:17,060 --> 00:31:20,480
Vamos pegar o atalho que eu avisei sobre a anterior, mas que diabo, só precisamos de uma solução rápida,

493
00:31:20,480 --> 00:31:25,730
então vamos apenas dizer int x aqui. Isso faz x global.

494
00:31:25,730 --> 00:31:31,800
Então, agora principal tem acesso a ele e incremento tem acesso a ele,

495
00:31:31,800 --> 00:31:34,110
e então deixe-me ir em frente e compile isso agora.

496
00:31:34,110 --> 00:31:37,630
Faça buggy4, Enter. Parece compilar.

497
00:31:37,630 --> 00:31:41,230
Vamos correr buggy4. E parece realmente funcionar.

498
00:31:41,230 --> 00:31:45,150
Esta é uma dessas coisas que fazem o que eu digo, não o que faço,

499
00:31:45,150 --> 00:31:47,010
como eu acabei de fazer aqui, porque, em geral,

500
00:31:47,010 --> 00:31:50,440
nossos programas vão ficar muito mais interessante e muito mais do que isso,

501
00:31:50,440 --> 00:31:56,390
e se a sua solução para os problemas da vida é apenas colocar todas as variáveis ​​no topo do seu arquivo,

502
00:31:56,390 --> 00:31:59,690
muito rapidamente que os programas ficam terrivelmente difícil de gerir.

503
00:31:59,690 --> 00:32:02,190
Fica mais difícil de pensar em novos nomes de variáveis,

504
00:32:02,190 --> 00:32:05,240
fica mais difícil de entender o que está fazendo o que variável,

505
00:32:05,240 --> 00:32:08,460
e assim, em geral, isto não é uma boa solução.

506
00:32:08,460 --> 00:32:10,030
Então, vamos fazer isso melhor.

507
00:32:10,030 --> 00:32:12,160
Nós não queremos usar uma variável global aqui.

508
00:32:12,160 --> 00:32:16,240
>> Eu quero incrementar x, para que eu pudesse obviamente -

509
00:32:16,240 --> 00:32:18,670
no final do dia, este é um tipo de história boba, porque acabamos de fazer isso -

510
00:32:18,670 --> 00:32:24,450
mas se eu não sabia que o operador ou eu não tinha permissão para alterá-lo no principal em si,

511
00:32:24,450 --> 00:32:30,730
de que outra forma eu poderia implementar Ken aqui desta vez não para cubo, mas para incrementar?

512
00:32:31,380 --> 00:32:33,190
Como faço para mudar esta coisa aqui? Sim.

513
00:32:33,190 --> 00:32:38,480
[Aluno] Pass em x e em seguida, retornar [inaudível] >> Ok, bom.

514
00:32:38,480 --> 00:32:41,900
Então, por que não eu passar em x e em seguida, em vez de devolvê-lo,

515
00:32:41,900 --> 00:32:44,870
por que eu não apenas me retornar x + 1.

516
00:32:44,870 --> 00:32:47,710
Mais algumas coisas têm que mudar aqui. Eu estou no caminho certo.

517
00:32:47,710 --> 00:32:49,770
O que mais eu preciso para ajustar? Alguém. Sim.

518
00:32:49,770 --> 00:32:51,740
[Resposta do aluno inaudível]

519
00:32:51,740 --> 00:32:54,730
Eu preciso mudar o tipo de retorno de incremento porque não está vazio.

520
00:32:54,730 --> 00:32:57,780
Não significa nada vazio está sendo devolvido, mas claramente agora é,

521
00:32:57,780 --> 00:32:59,830
para isso precisa mudar para - >> [aluno] int.

522
00:32:59,830 --> 00:33:02,740
int para ser coerente com o que eu realmente estou voltando.

523
00:33:02,740 --> 00:33:05,180
Agora outra coisa ainda é de buggy aqui. Sim.

524
00:33:05,180 --> 00:33:08,400
[Resposta do aluno inaudível] >> [Malan] Então eu preciso incrementar x?

525
00:33:08,400 --> 00:33:12,080
[Resposta do aluno inaudível] >> [Malan] Ah, então eu preciso passar x.

526
00:33:12,080 --> 00:33:16,660
Então eu preciso fazer isso aqui. >> [Comentário do estudante inaudível]

527
00:33:16,660 --> 00:33:20,050
[Malan] Então o protótipo, eu tenho que mudar isso aqui.

528
00:33:20,050 --> 00:33:22,930
Portanto, este tem de se tornar um int, este tem de se tornar -

529
00:33:22,930 --> 00:33:25,620
hmm, eu realmente tenho um bug aqui. Vamos corrigir isso primeiro.

530
00:33:25,620 --> 00:33:29,590
O que isso realmente deve ser? Tem que ser uma coisa int.

531
00:33:29,590 --> 00:33:32,700
Poderia ser x, mas, francamente, se você começar a chamar toda a sua x variáveis,

532
00:33:32,700 --> 00:33:35,390
ele vai ficar cada vez menos clara qual é qual.

533
00:33:35,390 --> 00:33:39,560
>> Então vamos escolher arbitrariamente uma convenção de nomenclatura diferente para as minhas funções de auxiliares,

534
00:33:39,560 --> 00:33:41,940
as funções que eu estou escrevendo. Vamos chamar-lhe uma, ou podemos chamá-lo -

535
00:33:41,940 --> 00:33:45,010
Vamos chamá-lo de o número ser ainda mais explícito.

536
00:33:45,010 --> 00:33:47,560
Então eu tenho que devolver qualquer que seja o número é mais 1,

537
00:33:47,560 --> 00:33:50,740
e agora eu tenho que mudar uma coisa aqui e outra coisa aqui.

538
00:33:50,740 --> 00:33:54,350
O que eu tenho que mudar na linha 21 em primeiro lugar? >> [Resposta do aluno inaudível]

539
00:33:54,350 --> 00:33:57,610
[Malan] Eu tenho que atribuir a x. Eu não posso simplesmente chamar de incremento (x).

540
00:33:57,610 --> 00:34:01,960
Preciso lembrar a resposta, alterando o valor de x no lado esquerdo.

541
00:34:01,960 --> 00:34:04,680
E mesmo que x é agora à esquerda e à direita, que é totalmente bem

542
00:34:04,680 --> 00:34:08,860
porque o lado direito é executado primeiro, então, é a coisa pulou na sua mão esquerda -

543
00:34:08,860 --> 00:34:10,600
x neste caso.

544
00:34:10,600 --> 00:34:12,159
E então, finalmente, este é um reparo fácil agora.

545
00:34:12,159 --> 00:34:17,230
Este deve apenas combinar o que há lá embaixo, número int.

546
00:34:17,230 --> 00:34:20,570
Então, um monte de mudanças para uma função realmente estúpido

547
00:34:20,570 --> 00:34:24,420
mas representativa de coisas que nós vamos cada vez mais quer fazer.

548
00:34:24,420 --> 00:34:27,090
Então faça buggy4. Eu estraguei tudo em algum lugar.

549
00:34:27,090 --> 00:34:30,139
Oh, meu Deus. Cinco erros em um programa de 6 linhas.

550
00:34:30,139 --> 00:34:35,690
Então, o que há de errado na linha 18, o personagem de 5?

551
00:34:35,690 --> 00:34:39,610
Então eu tenho que declarar este int,.

552
00:34:39,610 --> 00:34:41,920
Vamos ver. Há um monte de outros erros.

553
00:34:41,920 --> 00:34:47,010
Oh, meu Deus - 19, 18, 21 - mas, novamente, vamos limpar a tela, L Controle aqui,

554
00:34:47,010 --> 00:34:49,380
e execute novamente Clang.

555
00:34:49,380 --> 00:34:51,340
Então, cinco problemas que na verdade é apenas uma.

556
00:34:51,340 --> 00:34:57,520
Então, agora vamos executar buggy4, Enter. Ufa, x foi incrementado corretamente.

557
00:34:57,520 --> 00:35:02,720
Tudo bem. Qualquer dúvida sobre como incrementar números? Sim.

558
00:35:02,720 --> 00:35:09,870
[Pergunta estudante inaudível] >> Boa pergunta.

559
00:35:09,870 --> 00:35:14,220
Como é que eu posso simplesmente mudar para o número x eo programa vai saber imediatamente?

560
00:35:14,220 --> 00:35:16,200
>> Mais uma vez, pense nisso como essa abstração.

561
00:35:16,200 --> 00:35:21,600
Então, se eu sou principal e Ken é incremento, francamente, eu não me importo com o Ken chama seu iPad.

562
00:35:21,600 --> 00:35:26,570
Eu não ligo para o que ele chama de nada que tenha a ver com a sua implementação dessa funcionalidade.

563
00:35:26,570 --> 00:35:33,340
Este é um detalhe de implementação que eu, principal, não tem que se preocupar.

564
00:35:33,340 --> 00:35:38,250
E assim simplesmente mudar consistentemente dentro da função - número aqui e número aqui -

565
00:35:38,250 --> 00:35:40,960
é tudo o que leva tanto tempo como eu recompilar.

566
00:35:40,960 --> 00:35:44,180
É uma espécie de gosto, se você pensar que muitos de nós, aqueles com carteiras de motorista

567
00:35:44,180 --> 00:35:46,770
que têm conduzido ou se você mesmo conduzido em um carro,

568
00:35:46,770 --> 00:35:50,950
a maioria de nós não tem idéia de como um carro funciona debaixo do capô.

569
00:35:50,950 --> 00:35:54,970
E, literalmente, se você abrir o capô, a maioria de nós - eu incluído -

570
00:35:54,970 --> 00:35:56,940
não estão indo para realmente saber o que estamos olhando,

571
00:35:56,940 --> 00:35:59,220
tipo de como você pode se sentir com coisas como esta agora.

572
00:35:59,220 --> 00:36:01,480
Mas nós realmente não precisa se preocupar como o carro funciona,

573
00:36:01,480 --> 00:36:05,970
não temos de cuidar o que todos os bastões e pistões e os cabos dentro do carro

574
00:36:05,970 --> 00:36:08,160
estão realmente fazendo.

575
00:36:08,160 --> 00:36:12,770
Portanto, algo como o que vocês chamam o pistão não importa aqui neste caso. Mesma idéia.

576
00:36:12,770 --> 00:36:25,300
Sim. >> [Questão estudante inaudível]

577
00:36:25,300 --> 00:36:29,180
Se há mais usos do momento xa variável atrás,

578
00:36:29,180 --> 00:36:32,150
você, programador, teria que mudar todos os lugares.

579
00:36:32,150 --> 00:36:36,600
Ou você pode literalmente fazer menu Arquivo, e em Localizar, Substituir - algo assim -

580
00:36:36,600 --> 00:36:39,170
mas você vai ter que fazer essas mudanças mesmo.

581
00:36:39,170 --> 00:36:47,450
Você tem que ser consistente. >> [Aluno] Se há múltiplas variáveis ​​[inaudível]

582
00:36:47,450 --> 00:36:53,100
A ordem particular como aqui, se isso era int outro número? >> [Aluno] Correto.

583
00:36:53,100 --> 00:36:56,590
[Malan] Yeah. Ordem importa quando você está chamando a função.

584
00:36:56,590 --> 00:37:00,050
>> Então, se eu estivesse chamando incremento aqui com algo vírgula alguma coisa,

585
00:37:00,050 --> 00:37:01,680
há um mapeamento direto.

586
00:37:01,680 --> 00:37:05,690
A primeira variável, o que é chamado, é feita uma cópia do primeiro argumento aqui.

587
00:37:05,690 --> 00:37:07,760
Desculpe. Isso não deve ser um parêntese.

588
00:37:07,760 --> 00:37:11,490
O segundo argumento linhas acima com o segundo. Assim, a ordem, sim, importa. Tudo bem.

589
00:37:11,490 --> 00:37:17,020
Desculpe. Tomei o caminho mais longo para chegar lá. Outras perguntas? Tudo bem.

590
00:37:17,020 --> 00:37:20,610
Então vamos ver se não podemos pintar uma imagem do que está realmente acontecendo aqui

591
00:37:20,610 --> 00:37:23,090
debaixo do capô, por assim dizer.

592
00:37:23,090 --> 00:37:26,640
Este é um retângulo que pode representar a memória do seu computador.

593
00:37:26,640 --> 00:37:30,970
Mesmo se você não tem idéia de como funciona a memória ou como funciona a memória RAM,

594
00:37:30,970 --> 00:37:33,940
pelo menos assumir que você tem cachos de hoje em dia.

595
00:37:33,940 --> 00:37:36,280
Você tem megabytes de que, você tem gigabytes de que,

596
00:37:36,280 --> 00:37:40,870
e sabemos que a partir da semana que um byte 0 é apenas o que? >> [Aluno] 8 bits.

597
00:37:40,870 --> 00:37:42,950
8 bits, certo? Então 8 zeros e 1.

598
00:37:42,950 --> 00:37:45,880
Então, se o seu computador tem um giga de RAM, 2 GB de RAM estes dias,

599
00:37:45,880 --> 00:37:55,030
você tem um bilhão ou 2 bilhões de bytes de memória ou cerca de 8.000 milhões ou 16 bilhões de bits

600
00:37:55,030 --> 00:37:56,890
dentro do seu computador.

601
00:37:56,890 --> 00:38:00,590
Ao contrário do exemplo pouco Willy Wooly, não é tipicamente mais partículas magnéticas.

602
00:38:00,590 --> 00:38:04,450
Cada vez mais - em laptops, pelo menos - é drives de estado sólido, SSDs

603
00:38:04,450 --> 00:38:08,580
que apenas não têm partes móveis. É tudo eletrônico. É tudo baseado em eletricidade.

604
00:38:08,580 --> 00:38:14,060
Então, acho que desse retângulo como apenas representando os 1 ou 2 gigabytes de memória que você tem.

605
00:38:14,060 --> 00:38:16,020
>> Portanto, é um pedaço da memória.

606
00:38:16,020 --> 00:38:19,830
O mundo da informática tem a sorte de dissociado

607
00:38:19,830 --> 00:38:22,950
pedaços de memória para fazer coisas diferentes.

608
00:38:22,950 --> 00:38:27,190
Por exemplo, se esta é a memória RAM do computador, tal como sugerido pelo rectângulo lá,

609
00:38:27,190 --> 00:38:31,130
verifica-se que, por convenção, no topo de sua memória RAM, por assim dizer,

610
00:38:31,130 --> 00:38:33,660
é, geralmente, o que é chamado de um segmento de texto.

611
00:38:33,660 --> 00:38:36,740
Esses são os 0s e 1s que você tenha compilado.

612
00:38:36,740 --> 00:38:39,020
Então, quando nós olhamos debaixo do capô o que a.out é,

613
00:38:39,020 --> 00:38:41,980
todos estes 0s e 1s, quando você executar um programa,

614
00:38:41,980 --> 00:38:46,290
os 0s e 1s são carregados a partir do seu disco rígido em algo chamado de memória RAM,

615
00:38:46,290 --> 00:38:49,320
e na RAM são colocadas no topo.

616
00:38:49,320 --> 00:38:52,770
Enquanto isso, você tem outras coisas: iniciar os dados, não inicializar dados.

617
00:38:52,770 --> 00:38:57,510
Esses dois trechos de memória referem-se a variáveis ​​globais, que você não costuma usar

618
00:38:57,510 --> 00:39:00,760
mas, às vezes, se você fizer isso, eles acabam se lá também.

619
00:39:00,760 --> 00:39:04,260
Depois, há algumas outras coisas: as variáveis ​​de ambiente, que não vai passar muito tempo,

620
00:39:04,260 --> 00:39:06,860
mas, em seguida, duas coisas importantes que vão voltar ao longo do semestre,

621
00:39:06,860 --> 00:39:08,550
pilha e heap.

622
00:39:08,550 --> 00:39:12,210
Assim, a maioria da memória do seu computador é reservado ao executar um programa

623
00:39:12,210 --> 00:39:15,370
para algo chamado de pilha e algo chamado de pilha.

624
00:39:15,370 --> 00:39:18,840
Nós não vamos falar sobre a pilha de hoje, mas vamos falar sobre a pilha.

625
00:39:18,840 --> 00:39:24,600
A pilha é destinado a conjurar o visual das refeições bandejas de refeição salão em Mather Casa

626
00:39:24,600 --> 00:39:28,110
ou onde quer que seja, onde a equipe refeitório limpá-los todos os dias,

627
00:39:28,110 --> 00:39:30,180
eles empilhá-los do chão em cima,

628
00:39:30,180 --> 00:39:34,550
e da mesma forma, na memória, não é essa idéia de colocar algo em uma pilha,

629
00:39:34,550 --> 00:39:36,860
colocar algo em uma pilha, colocar algo em uma pilha.

630
00:39:36,860 --> 00:39:38,240
E o que queremos dizer com isso?

631
00:39:38,240 --> 00:39:41,860
>> Vamos aumentar o zoom em apenas a metade inferior da imagem, memória RAM de seu computador,

632
00:39:41,860 --> 00:39:44,330
a propor o seguinte.

633
00:39:44,330 --> 00:39:48,170
Acontece que quando você executar um programa como a.out ou Olá -

634
00:39:48,170 --> 00:39:50,100
qualquer que seja o programa é que você escreveu -

635
00:39:50,100 --> 00:39:54,020
novamente, os 0s e 1s são carregados a partir do seu disco rígido, que é de longo prazo de armazenamento,

636
00:39:54,020 --> 00:39:57,230
permanece lá mesmo quando você puxar a ficha, carregado na memória RAM.

637
00:39:57,230 --> 00:40:00,610
RAM é mais rápida do que os discos rígidos - é menor do que os discos rígidos -

638
00:40:00,610 --> 00:40:03,300
mas é onde os programas ao vivo, enquanto você está executando-os.

639
00:40:03,300 --> 00:40:08,230
Então você clicar duas vezes um programa em um Mac ou PC, ele é carregado do disco rígido para a RAM.

640
00:40:08,230 --> 00:40:11,520
Assim como é carregado na memória RAM, o go 0s e 1s no topo forma,

641
00:40:11,520 --> 00:40:16,610
o segmento de texto chamado, mas assim que o programa realmente começa a correr,

642
00:40:16,610 --> 00:40:21,360
a principal função é chamado, e principal, como já vimos, muitas vezes tem variáveis ​​locais,

643
00:40:21,360 --> 00:40:24,870
e tem ints e cordas e caractere e semelhantes.

644
00:40:24,870 --> 00:40:29,180
Portanto, se seu programa que você escreveu ou o programa que você clicar duas vezes

645
00:40:29,180 --> 00:40:32,970
usou algumas variáveis ​​dentro de principal,

646
00:40:32,970 --> 00:40:37,240
eles acabam no fundo de sua pilha de memória, por assim dizer.

647
00:40:37,240 --> 00:40:39,410
Mais concretamente, o que isso realmente significa?

648
00:40:39,410 --> 00:40:48,450
Isto apenas significa que se nós estávamos indo para o número de bytes de memória RAM em seu computador,

649
00:40:48,450 --> 00:40:55,750
notar que este pode ser o número de bytes 0, este pode ser o número de bytes 1, 2, 3, 4, 5, 6,

650
00:40:55,750 --> 00:41:01,480
todo o caminho até 2 bilhões seria todo o caminho até lá em cima.

651
00:41:01,480 --> 00:41:05,880
Portanto, em outras palavras, quando falamos de memória RAM ou em termos de bytes,

652
00:41:05,880 --> 00:41:11,500
significa apenas que alguém decidiu que a contar cada um desses pedaços de memória.

653
00:41:11,500 --> 00:41:16,650
Assim, quando você precisar de 32 bits para um int ou você precisa de 8 bits para um char,

654
00:41:16,650 --> 00:41:18,840
onde é que eles acabam na memória?

655
00:41:18,840 --> 00:41:22,350
>> Conceitualmente, eles simplesmente acabar no fundo de uma coisa chamada a pilha.

656
00:41:22,350 --> 00:41:25,870
Mas o que é interessante agora é quando chama uma função principal -

657
00:41:25,870 --> 00:41:28,750
suponha que uma função chamada foo, apenas o nome de um arbitrário -

658
00:41:28,750 --> 00:41:32,330
o que acontece é principal está na parte inferior desta pilha de memória;

659
00:41:32,330 --> 00:41:35,680
foo agora é colocar em cima do principal na memória.

660
00:41:35,680 --> 00:41:40,990
Assim, todas as variáveis ​​locais que foo tem acabam tipo de conceitualmente acima dos de principal.

661
00:41:40,990 --> 00:41:47,070
Se foo chama outra função chamada bar, essas variáveis ​​acabam aqui.

662
00:41:47,070 --> 00:41:50,120
Se a barra de chama outra coisa, aqui, aqui, aqui.

663
00:41:50,120 --> 00:41:53,830
Então, o que é interessante sobre a execução de um programa é que, como você chamar funções

664
00:41:53,830 --> 00:41:57,750
e como essas funções chamar funções e como essas funções chamar funções,

665
00:41:57,750 --> 00:42:01,470
você construir esta pilha de funções na memória.

666
00:42:01,470 --> 00:42:06,890
E apenas uma vez a função retorna você começar a que a memória de volta.

667
00:42:06,890 --> 00:42:10,860
Portanto, uma das maneiras mais fáceis de ficar sem memória em um programa de computador

668
00:42:10,860 --> 00:42:14,360
é escrever funções que nunca retornam.

669
00:42:14,360 --> 00:42:18,900
Assim, por exemplo, vamos demonstrar tanto com um programa intencionalmente buggy.

670
00:42:18,900 --> 00:42:22,230
Deixe-me ir em frente e fazer # include,

671
00:42:22,230 --> 00:42:25,000
int main (void),

672
00:42:25,000 --> 00:42:32,940
e eu vou fazer enquanto (2> 1), o que provavelmente não vai mudar em nós,

673
00:42:32,940 --> 00:42:37,560
e deixe-me ir em frente agora e fazer printf.

674
00:42:37,560 --> 00:42:40,700
Na verdade, isso vai ser menos interessante visualmente. Vamos fazer isso.

675
00:42:40,700 --> 00:42:50,240
Para int i = 0; i> 0 - vamos cometer esse erro - i + +.

676
00:42:50,240 --> 00:42:52,720
E não vamos printf aqui. Vamos praticar o que eu estava pregando.

677
00:42:52,720 --> 00:43:00,190
Vamos ter um método aqui, refrão vazio, e vamos dizer int i,

678
00:43:00,190 --> 00:43:06,830
e então eu vou dizer printf - não, vamos tornar isso mais interessante.

679
00:43:06,830 --> 00:43:15,790
Não vamos realmente imprimir nada. Vamos fazer o seguinte: coro (i).

680
00:43:15,790 --> 00:43:20,390
Tudo bem. Portanto, este é buggy por que?

681
00:43:20,390 --> 00:43:23,380
Eu estou fazendo isso como eu ir, porque o programa não faz nada de interesse.

682
00:43:23,380 --> 00:43:25,320
>> Mas esse não é o objetivo.

683
00:43:25,320 --> 00:43:29,630
O objetivo é escrever um programa que tem como principal função faz o que, aparentemente?

684
00:43:30,720 --> 00:43:32,860
Se identificar. E, na verdade, nós não precisamos do loop.

685
00:43:32,860 --> 00:43:37,200
Vamos mesmo simplificar este só para não perder de vista o bug realmente fundamental.

686
00:43:37,200 --> 00:43:39,640
Chamadas principais coro a cantar alguma coro,

687
00:43:39,640 --> 00:43:41,440
então eu fiz algo estúpido e eu tive coro chamada coro

688
00:43:41,440 --> 00:43:43,760
porque eu assumi alguém estava indo para implementá-lo, talvez,

689
00:43:43,760 --> 00:43:47,210
e agora isso não vai compilar ainda. Eu preciso fazer o quê?

690
00:43:47,210 --> 00:43:49,970
Eu preciso do protótipo, lembre-se.

691
00:43:49,970 --> 00:43:56,110
Então, eu preciso ter-se aqui coro void (int i);

692
00:43:56,110 --> 00:43:59,210
Portanto, agora se eu descer aqui - na verdade, vamos usar a janela maior.

693
00:43:59,210 --> 00:44:01,980
Vamos em frente e fazer coro.

694
00:44:01,980 --> 00:44:06,490
Vamos em frente e fazer coro.

695
00:44:06,490 --> 00:44:08,370
Utilização de identificador não declarado i.

696
00:44:08,370 --> 00:44:12,500
Ah, isso foi estúpido. Nós não precisamos do argumento. Vamos fazer isso.

697
00:44:12,500 --> 00:44:16,370
Eu gostaria que tivesse começado dessa maneira. Teria sido um programa muito mais fácil escrever.

698
00:44:16,370 --> 00:44:25,590
Lá. Agora vamos para a minha janela de terminal, execute novamente Clang, e aqui vamos nós.

699
00:44:25,590 --> 00:44:28,460
Isso foi muito rápido.

700
00:44:28,460 --> 00:44:31,150
O que realmente aconteceu, entretanto?

701
00:44:31,150 --> 00:44:33,730
Bem, agora eu vou adicionar a linha de impressão para que possamos ver.

702
00:44:33,730 --> 00:44:43,490
Deixe-me dizer printf ("Eu estou aqui") - não variáveis. Vamos deixá-lo assim.

703
00:44:43,490 --> 00:44:47,480
Deixe-me fazer reprise. Deixe-me reprise coro.

704
00:44:47,480 --> 00:44:57,380
E ... vamos lá. Continue indo.

705
00:44:57,380 --> 00:44:59,930
Como um aparte, por que ainda não caiu ainda?

706
00:44:59,930 --> 00:45:02,080
A falha de segmentação aconteceu super rápido antes.

707
00:45:02,080 --> 00:45:06,570
[Resposta do aluno inaudível] >> Exatamente. Então, é preciso tempo para imprimir, certo?

708
00:45:06,570 --> 00:45:08,610
Ele só tem mais trabalho por parte do computador.

709
00:45:08,610 --> 00:45:10,620
E lá está: falha de segmentação.

710
00:45:10,620 --> 00:45:12,340
>> Então, observe o quão rápido os programas executados.

711
00:45:12,340 --> 00:45:14,130
Se você não está imprimindo nada, super rápido.

712
00:45:14,130 --> 00:45:18,770
Mas ainda tenho essa falha de segmentação, porque o que estava acontecendo?

713
00:45:18,770 --> 00:45:21,210
Se você pensar sobre como a memória do seu computador é colocado para fora,

714
00:45:21,210 --> 00:45:28,740
este passa a ser principal, mas aqui vamos chamar este coro, e vamos chamar esse refrão.

715
00:45:28,740 --> 00:45:34,550
E agora, se eu fizer minha estética certo, isso só vai dizer coro coro, coro,

716
00:45:34,550 --> 00:45:40,550
coro, coro, coro, coro, ad nauseum, e, eventualmente, o que vai acontecer?

717
00:45:40,550 --> 00:45:45,630
Se a imagem grande, literalmente, é isso, o que acontece apenas conceitualmente?

718
00:45:46,520 --> 00:45:48,630
As derrapagens pilha a pilha.

719
00:45:48,630 --> 00:45:51,940
Ou, pior, você só superado tudo, incluindo o segmento de texto,

720
00:45:51,940 --> 00:45:54,590
que é a 0s e 1s que representam o seu programa.

721
00:45:54,590 --> 00:45:57,080
Em suma, este é apenas super, super-ruim.

722
00:45:57,080 --> 00:45:58,830
Seu programa entrou em uma espiral fora de controle.

723
00:45:58,830 --> 00:46:01,220
Você está usando a memória muito mais do que você pretendeu

724
00:46:01,220 --> 00:46:03,960
tudo por causa de um erro estúpido, neste caso,

725
00:46:03,960 --> 00:46:08,040
ou, neste caso uma função muito deliberadamente feito ligando-se.

726
00:46:08,040 --> 00:46:09,500
Agora, isso não é de todo ruim.

727
00:46:09,500 --> 00:46:13,800
Funções que chamam-se, na verdade, tem um grande poder quando você usá-lo corretamente.

728
00:46:13,800 --> 00:46:15,800
Eu não tenho usado corretamente aqui.

729
00:46:15,800 --> 00:46:19,780
Então isso não é de todo ruim, mas o fato de que eu nunca realmente parar de chamar-me

730
00:46:19,780 --> 00:46:23,520
é uma fraqueza fundamental aqui deste programa.

731
00:46:23,520 --> 00:46:26,400
Então para onde estamos indo com tudo isso? O que está realmente acontecendo?

732
00:46:26,400 --> 00:46:30,340
Quando eu chamo a função de incremento como estávamos fazendo nesses exemplos,

733
00:46:30,340 --> 00:46:33,420
Eu tenho um valor como uma que eu passar dentro

734
00:46:33,420 --> 00:46:37,570
Eu passar em uma cópia do número 1, então acontece o seguinte.

735
00:46:37,570 --> 00:46:44,240
Vamos para o exemplo de incremento, esse cara por aqui.

736
00:46:44,240 --> 00:46:46,870
Aqui está o que realmente está acontecendo.

737
00:46:46,870 --> 00:46:53,400
Quando eu chamo incremento e eu passar em x, pictoricamente, o que está acontecendo aqui é esta.

738
00:46:53,400 --> 00:46:59,520
>> Se eu tiver o valor de um armazenados aqui e eu realmente chamar incremento,

739
00:46:59,520 --> 00:47:04,330
que agora é chamado coro - o iPad está jogando-me aqui.

740
00:47:04,330 --> 00:47:09,760
Vamos chamar esse incremento, e não sabemos o que esta função próximo vai ser.

741
00:47:09,760 --> 00:47:14,840
Então o que está realmente acontecendo é aqui em algum lugar na principal Eu tenho um pedaço de memória

742
00:47:14,840 --> 00:47:17,000
que está a armazenar o número 1.

743
00:47:17,000 --> 00:47:19,380
Quando eu chamo incremento, estou usando outro pedaço de memória,

744
00:47:19,380 --> 00:47:21,230
mas agora eu tenho a cópia do 1.

745
00:47:21,230 --> 00:47:26,660
Quando eu incrementar esse valor, isso se torna 2,

746
00:47:26,660 --> 00:47:30,560
mas então o que acontece logo que retorna de incremento?

747
00:47:30,560 --> 00:47:33,630
Esta memória só fica transferido de volta para o sistema operacional,

748
00:47:33,630 --> 00:47:37,450
o que significa que tudo que você fez não é nada útil.

749
00:47:37,450 --> 00:47:43,120
O 1 que foi originalmente contido no principal ainda é realmente lá.

750
00:47:43,120 --> 00:47:44,890
Então para onde estamos indo com isso?

751
00:47:44,890 --> 00:47:49,770
Acontece que na memória você ter esta sequência de back-to-back de bytes

752
00:47:49,770 --> 00:47:53,050
que você pode colocar coisas dentro, e verifica-se que já vimos algo

753
00:47:53,050 --> 00:47:55,390
que envolve colocar as coisas de volta para trás, para trás, para trás.

754
00:47:55,390 --> 00:47:59,860
O que é um texto baseado na 1 ª semana e agora 2 semanas?

755
00:48:00,020 --> 00:48:01,980
É apenas uma coleção de personagens.

756
00:48:01,980 --> 00:48:04,310
Assim, verifica-se apenas como você pode colocar números na memória,

757
00:48:04,310 --> 00:48:06,990
da mesma forma que você pode colocar os caracteres na memória.

758
00:48:06,990 --> 00:48:10,530
E quando começamos a colocar personagens na memória de costas para trás, para trás,

759
00:48:10,530 --> 00:48:13,620
verifica-se que usando a mais simples das coisas como um loop ou um loop while,

760
00:48:13,620 --> 00:48:17,170
podemos iterar da esquerda para a direita sobre os caracteres de uma string

761
00:48:17,170 --> 00:48:20,600
e começar massageando-os em personagens completamente diferentes -

762
00:48:20,600 --> 00:48:23,370
poderia tornar-se um b, b poderia tornar-se c -

763
00:48:23,370 --> 00:48:27,780
de modo que, em última análise, podemos tomar uma frase Inglês que realmente faz sentido

764
00:48:27,780 --> 00:48:30,310
e converter cada uma das referidas cartas de cada vez

765
00:48:30,310 --> 00:48:34,400
andando através da memória do nosso computador esquerda para a direita para realmente criptografar.

766
00:48:34,400 --> 00:48:35,810
Portanto, vamos ter a nossa pausa de cinco minutos aqui,

767
00:48:35,810 --> 00:48:40,730
e quando voltar, vamos começar esse processo de codificação de informações.

768
00:48:42,020 --> 00:48:43,520
>> Tudo bem.

769
00:48:43,520 --> 00:48:48,070
Antes de mergulhar em alguns criptografia e essas coisas chamadas de matrizes,

770
00:48:48,070 --> 00:48:51,470
deixe-me fazer uma pausa para todas as perguntas, porque eu sinto como se eu realmente tipo de confusa

771
00:48:51,470 --> 00:48:54,080
alguns desses temas. Então vamos corrigir agora, se pudermos.

772
00:48:54,080 --> 00:48:58,700
Acabamos de falar sobre valores de retorno, nós conversamos sobre argumentos,

773
00:48:58,700 --> 00:49:03,250
e conversamos sobre esta noção, que nós vamos voltar a nos próximas semanas,

774
00:49:03,250 --> 00:49:08,720
de ver a memória como um monte de estas bandejas empilhadas, por assim dizer,

775
00:49:08,720 --> 00:49:12,660
a partir de baixo, de cima, de tal modo que cada bandeja, que é colocado na pilha

776
00:49:12,660 --> 00:49:16,530
representa uma função que está sendo chamado.

777
00:49:17,900 --> 00:49:20,260
Alguma pergunta?

778
00:49:20,260 --> 00:49:22,640
Deixe-me fazer uma pergunta aqui.

779
00:49:22,640 --> 00:49:27,890
Deixe-me simplificar isso volta ao que era antes de alguns dos nossos mais cedo Q & A.

780
00:49:27,890 --> 00:49:35,570
O fato de que o incremento tem parêntese aberto, número int, fechou parênteses -

781
00:49:35,570 --> 00:49:39,110
o que é que o número int representa?

782
00:49:39,110 --> 00:49:42,790
[Aluno] Um argumento. >> Um argumento. Okay. Mas o que é um argumento?

783
00:49:42,790 --> 00:49:46,370
[Resposta do aluno inaudível] >> O que é isso? >> [Aluno] Algo que você passa dentro

784
00:49:46,370 --> 00:49:49,940
Ok, então algo que você passa dentro E de modo mais geral, é apenas a entrada.

785
00:49:49,940 --> 00:49:52,450
Se você fosse escrever uma função e finalidade dessa função na vida

786
00:49:52,450 --> 00:49:55,770
é fazer algo um pouco diferente cada vez que você usá-lo,

787
00:49:55,770 --> 00:50:00,110
então a única maneira para que isso aconteça realmente parece ser o de fornecer com entrada

788
00:50:00,110 --> 00:50:03,510
para que ele possa fazer algo diferente com que a entrada de cada vez.

789
00:50:03,510 --> 00:50:06,650
>> Então, você precisa especificar duas coisas quando leva uma função de entrada.

790
00:50:06,650 --> 00:50:09,590
Você precisa especificar o nome que você quiser dar a essa entrada

791
00:50:09,590 --> 00:50:12,700
exclusivamente para sua própria conveniência para que você possa consultá-la

792
00:50:12,700 --> 00:50:16,540
na função que você mesmo está escrevendo, como eu fiz aqui na linha 32.

793
00:50:16,540 --> 00:50:20,800
Mas você também precisa especificar o tipo porque C é uma linguagem de programação

794
00:50:20,800 --> 00:50:25,940
que exige apenas que se você quiser uma variável, você tem que dizer ao computador o tipo de dados que é,

795
00:50:25,940 --> 00:50:30,200
em boa parte, de modo que ele sabe quantos bits para alocar para essa variável

796
00:50:30,200 --> 00:50:33,020
porque poderia ser 6 - desculpe, isso não vai ser 6.

797
00:50:33,020 --> 00:50:37,080
Ele pode ser de 16, pode ser de 8, pode ser de 32, mesmo 64,

798
00:50:37,080 --> 00:50:39,130
mas o computador precisa saber.

799
00:50:39,130 --> 00:50:43,180
Agora, a int no lado esquerdo representa o que, por outro lado?

800
00:50:46,350 --> 00:50:48,850
[Resposta do aluno inaudível] >> O que é isso? >> [Aluno] Tipo de função.

801
00:50:48,850 --> 00:50:53,610
O tipo de uma função e, mais especificamente, do tipo da sua produção. Direito.

802
00:50:53,610 --> 00:50:57,380
Assim, enquanto que a única coisa entre parênteses representa sua entrada, se houver,

803
00:50:57,380 --> 00:50:59,660
a coisa para a esquerda representa sua saída.

804
00:50:59,660 --> 00:51:03,530
E, neste caso, o incremento aparentemente retorna um inteiro

805
00:51:03,530 --> 00:51:07,690
e assim int é o tipo de retorno desta função.

806
00:51:07,690 --> 00:51:09,340
O que significa retornar?

807
00:51:09,340 --> 00:51:15,090
Literalmente, você usa a palavra-chave return e então, se o que você está voltando

808
00:51:15,090 --> 00:51:18,600
à direita da palavra-chave é um número inteiro,

809
00:51:18,600 --> 00:51:21,660
em seguida, que é de fato consistente com o que prometeram.

810
00:51:21,660 --> 00:51:26,410
Você não poderia fazer algo assim - Olá mundo, - porque isso é uma string.

811
00:51:26,410 --> 00:51:28,860
>> Obviamente, isto não é um número inteiro.

812
00:51:28,860 --> 00:51:33,140
Assim, em breve, a carga é realmente em nós, o programador, para ser específico

813
00:51:33,140 --> 00:51:37,770
quanto ao que estamos retornando e então realmente ir sobre a devolver.

814
00:51:37,770 --> 00:51:43,440
O contexto aqui agora é que a memória do computador é um gigabyte, 2 gigabytes -

815
00:51:43,440 --> 00:51:45,920
qualquer que seja - talvez seja mais, talvez seja menos,

816
00:51:45,920 --> 00:51:49,050
mas o computador vê-lo como tendo diferentes seções.

817
00:51:49,050 --> 00:51:51,200
Algo vai lá, outra coisa vai lá em cima,

818
00:51:51,200 --> 00:51:54,290
coisas diferentes vai no meio, e hoje nós só começar a contar a história,

819
00:51:54,290 --> 00:51:56,340
mas vamos voltar a esse tempo acabou.

820
00:51:56,340 --> 00:51:59,980
Por enquanto, a única lembrança que realmente importa é o segmento de texto

821
00:51:59,980 --> 00:52:03,360
porque isso só representa os 0s e 1s Clang que tem emitido.

822
00:52:03,360 --> 00:52:06,050
Então, quando você executar um comando no teclado como a.out

823
00:52:06,050 --> 00:52:09,110
ou duplo clique em um ícone no Mac OS ou Windows,

824
00:52:09,110 --> 00:52:11,880
seu programa é carregado a partir do disco rígido para a RAM

825
00:52:11,880 --> 00:52:16,330
e está se estatelou no topo da RAM do seu computador, por assim dizer.

826
00:52:16,330 --> 00:52:20,450
Enquanto isso, como o seu programa começa a ser executado e principal é chamado

827
00:52:20,450 --> 00:52:23,640
no programa que você escreveu ou o programa Microsoft ou a Apple escreveu,

828
00:52:23,640 --> 00:52:27,860
qualquer uma de suas variáveis ​​locais acabam lá no fundo da memória de seu computador.

829
00:52:27,860 --> 00:52:33,230
Mas, se as chamadas principais outra função que em si tem variáveis ​​ou argumentos, eles acabam por cima.

830
00:52:33,230 --> 00:52:36,680
E se essa função chama alguma coisa, eles acabam acima dele, acima dele, acima dele.

831
00:52:36,680 --> 00:52:41,460
>> E apenas uma vez uma função de execução que é feito a pilha de tabuleiros, por assim dizer,

832
00:52:41,460 --> 00:52:43,240
começam a ficar mais e mais.

833
00:52:43,240 --> 00:52:48,250
E isto é o que então, em poucas palavras, explica porque quando você chama cubo

834
00:52:48,250 --> 00:52:51,550
ou você chamar de incremento, você está passando em uma cópia do valor.

835
00:52:51,550 --> 00:52:55,520
E o que isso significa pictoricamente é que você está, literalmente, escrevendo o número 1

836
00:52:55,520 --> 00:53:00,460
em outra parte da memória, mudando que 1 a 2, no caso de incremento

837
00:53:00,460 --> 00:53:04,820
ou de um 8, no caso de cubo e, em seguida, que a memória de distância jogando

838
00:53:04,820 --> 00:53:09,140
assim que o aumento ou a função retorna de cubo. Pergunta.

839
00:53:09,140 --> 00:53:12,900
[Estudante] Onde são variáveis ​​globais são armazenados?

840
00:53:12,900 --> 00:53:18,100
As variáveis ​​globais são armazenados em que está atualmente chamado os dados inicializados ou dados não inicializados,

841
00:53:18,100 --> 00:53:21,920
a diferença é se você tiver uma variável global e lhe atribui um valor imediato

842
00:53:21,920 --> 00:53:24,640
com o sinal de igual, ele acaba no topo lá,

843
00:53:24,640 --> 00:53:29,200
e se você acabou de dizer int x; sem valor, acaba um pouco menor na RAM

844
00:53:29,200 --> 00:53:31,710
simplesmente por convenção.

845
00:53:31,710 --> 00:53:34,940
Outras perguntas? Tudo bem.

846
00:53:34,940 --> 00:53:37,340
Portanto, esta imagem vai voltar como temos mais poderoso

847
00:53:37,340 --> 00:53:39,170
com o que podemos fazer com o computador,

848
00:53:39,170 --> 00:53:42,720
mas por agora, vamos ter uma breve introdução à criptografia,

849
00:53:42,720 --> 00:53:46,080
um tipo específico de criptografia que não resolve todos os problemas do mundo

850
00:53:46,080 --> 00:53:47,720
mas não resolve alguns deles.

851
00:53:47,720 --> 00:53:51,700
Neste caso aqui, temos uma coisa chamada criptografia de chave secreta.

852
00:53:51,700 --> 00:53:56,410
Criptografia de chave secreta, como o nome sugere, deriva a sua segurança a partir de um segredo.

853
00:53:56,410 --> 00:54:00,690
>> Por exemplo, se você estava de volta na escola e você estava passando uma carta de amor pouco secreto

854
00:54:00,690 --> 00:54:04,850
para o menino ou a menina que estava esmagando, se você queria passar essa nota por meio da audiência,

855
00:54:04,850 --> 00:54:08,380
você provavelmente não iria escrever tal nota em Inglês ou qualquer que seja sua língua nativa é.

856
00:54:08,380 --> 00:54:13,340
Em vez disso, você pode criptografar ou você pode apenas enviar-lhes uma mensagem de texto estes dias.

857
00:54:13,340 --> 00:54:15,460
Mas você pode realmente passar-lhes uma nota ao longo da sala de aula.

858
00:54:15,460 --> 00:54:18,700
E para fazer isso de forma segura, de tal forma que os seus amigos e os professores

859
00:54:18,700 --> 00:54:22,650
não sei o que você está escrevendo, você pode chegar a um algoritmo bastante simples,

860
00:54:22,650 --> 00:54:25,920
jovem que você pode ser, apenas para embaralhar as palavras.

861
00:54:25,920 --> 00:54:28,130
Então, em vez de escrever um você pode escrever b,

862
00:54:28,130 --> 00:54:30,220
em vez de b você pode escrever c,

863
00:54:30,220 --> 00:54:32,140
em vez de c você pode escrever d, e assim por diante.

864
00:54:32,140 --> 00:54:34,360
Ou você pode vir com uma tradução mais sofisticado

865
00:54:34,360 --> 00:54:36,720
de cartas para letras diferentes.

866
00:54:36,720 --> 00:54:39,740
Mas o problema é o menino ou menina a quem você está enviando esta nota

867
00:54:39,740 --> 00:54:45,020
precisa saber alguma coisa, que é o que, obviamente? >> [Aluno] O que você está enviando.

868
00:54:45,020 --> 00:54:49,720
Qual é o seu segredo, como o que é que o mapeamento entre um e b e c e d's.

869
00:54:49,720 --> 00:54:54,650
É apenas adicionando uma a cada uma das letras para ir de um para b, b para c?

870
00:54:54,650 --> 00:54:56,670
O que é mais complexa do que a?

871
00:54:56,670 --> 00:55:01,540
>> Assim, você e sua paixão precisa ter essa informação secreta,

872
00:55:01,540 --> 00:55:03,190
mas há uma espécie de catch-22 aqui.

873
00:55:03,190 --> 00:55:06,830
Se esta é a primeira vez que você está enviando esta carta de amor através da classe,

874
00:55:06,830 --> 00:55:10,720
como é que o menino ou a menina vai saber o que o segredo é mesmo?

875
00:55:10,720 --> 00:55:13,930
Então de chave secreta de criptografia não resolve todos os problemas do mundo,

876
00:55:13,930 --> 00:55:16,320
e há, na verdade, um relacionamento aqui que nós vamos voltar a em direção ao fim do semestre.

877
00:55:16,320 --> 00:55:25,110
Da mesma forma que não a maioria de nós conhece alguém que trabalha, por exemplo, a Amazon.com,

878
00:55:25,110 --> 00:55:28,190
e ainda muitos de nós provavelmente já comprou coisas no Amazon.com,

879
00:55:28,190 --> 00:55:31,990
e nós fomos ensinados a assumir que essas transações de e-commerce são seguras.

880
00:55:31,990 --> 00:55:36,470
A URL provavelmente diz https, há talvez um ícone de cadeado pouco bobo em algum lugar,

881
00:55:36,470 --> 00:55:39,930
há algum tipo de criptografia de proteger suas informações de cartão de crédito

882
00:55:39,930 --> 00:55:42,160
entre você e Amazon.com.

883
00:55:42,160 --> 00:55:45,430
E, no entanto, se a criptografia envolve saber algum segredo

884
00:55:45,430 --> 00:55:48,620
e eu ainda não conheço ninguém na Amazon e eu certamente não dispostos qualquer tipo de segredo

885
00:55:48,620 --> 00:55:52,710
com alguém na Amazônia, como é o meu computador ou o meu navegador fazendo isso?

886
00:55:52,710 --> 00:55:55,720
Acontece que há outros tipos de criptografia completamente que resolver esse problema.

887
00:55:55,720 --> 00:55:57,670
Mas por hoje, vamos nos concentrar na simples

888
00:55:57,670 --> 00:56:00,290
onde você pode organizar com antecedência para saber algum segredo

889
00:56:00,290 --> 00:56:03,760
como uma ou algumas mapeamento entre um e b do.

890
00:56:03,760 --> 00:56:05,840
E o processo de criptografia envolve geralmente a este.

891
00:56:05,840 --> 00:56:08,620
Você tem algum texto simples, representado aqui na esquerda,

892
00:56:08,620 --> 00:56:12,930
executá-lo através de algum tipo de algoritmo ou procedimento para criptografá-lo -

893
00:56:12,930 --> 00:56:15,100
talvez isso seja apenas uma se torna b, b torna-se c -

894
00:56:15,100 --> 00:56:17,490
e então você acaba com texto cifrado.

895
00:56:17,490 --> 00:56:20,380
Enquanto isso, uma vez que a sua paixão recebe esta nota secreta,

896
00:56:20,380 --> 00:56:24,200
ele ou ela tem que decifrá-lo, então por que geralmente invertendo algoritmo

897
00:56:24,200 --> 00:56:27,190
de modo a obter de volta o texto simples.

898
00:56:27,190 --> 00:56:28,960
Existem encarnações físicas deste.

899
00:56:28,960 --> 00:56:31,680
>> Por exemplo, este é um anel decodificador pouco segredo,

900
00:56:31,680 --> 00:56:35,110
e este é um anel, no sentido de que há dois mostradores aqui.

901
00:56:35,110 --> 00:56:38,490
Na periferia fora desta coisa, há letras de A a Z,

902
00:56:38,490 --> 00:56:40,340
embora eles estão em ordem aleatória,

903
00:56:40,340 --> 00:56:42,880
e no interior, há realmente alguns números

904
00:56:42,880 --> 00:56:46,620
de tal forma que com este anel, você pode transformar o tipo de fora, mas não no interior

905
00:56:46,620 --> 00:56:49,140
, a fim de alinhar números com letras.

906
00:56:49,140 --> 00:56:53,020
A partir de um filme chamado Uma História de Natal, você vai ver que Ralphie pouco

907
00:56:53,020 --> 00:56:58,000
estava tão ansioso para descobrir o que mensagem secreta Little Orphan Annie era para ele

908
00:56:58,000 --> 00:57:02,570
que havia sido comunicado, penso eu, na forma de mensagens numéricas em uma caixa de cereal

909
00:57:02,570 --> 00:57:07,220
e você teve que acumular todos os cartões pequenos que vieram na caixa de cereal,

910
00:57:07,220 --> 00:57:09,770
você tinha que enviá-los, você tinha que voltar o anel decodificador secreto

911
00:57:09,770 --> 00:57:13,910
de modo que você pode finalmente descobrir o que é o mapeamento entre letras e números

912
00:57:13,910 --> 00:57:15,550
ou cartas e cartas.

913
00:57:15,550 --> 00:57:19,520
Como em um computador podemos ir sobre a implementação ou representando coisas como esta?

914
00:57:19,520 --> 00:57:22,560
Precisamos de uma maneira de nos expressar um pouco mais flexível

915
00:57:22,560 --> 00:57:25,080
do que as nossas variáveis ​​até agora têm permitido.

916
00:57:25,080 --> 00:57:29,000
Tivemos ints, tivemos chars, tivemos carros alegóricos e de duplas e alguns outros,

917
00:57:29,000 --> 00:57:34,200
mas essas são peças individuais de memória que realmente não nos permitem expressar coisas

918
00:57:34,200 --> 00:57:36,440
como palavras e frases e frases.

919
00:57:36,440 --> 00:57:38,630
Na verdade, nós temos chamado cordas tais coisas,

920
00:57:38,630 --> 00:57:42,660
mas nós prometemos que isso é realmente apenas uma simplificação na biblioteca CS50

921
00:57:42,660 --> 00:57:45,540
que estamos com a intenção de descascar.

922
00:57:45,540 --> 00:57:47,500
E assim vamos começar a fazer isso aqui.

923
00:57:47,500 --> 00:57:49,840
Deixe-me ir em frente e abrir um arquivo -

924
00:57:49,840 --> 00:57:54,100
todos esses arquivos estão disponíveis, como de costume, online - array.c chamado

925
00:57:54,100 --> 00:57:58,960
para resolver um problema relacionado com cordas, mas que pinta um quadro aqui

926
00:57:58,960 --> 00:58:01,520
de como podemos usar uma coisa chamada matriz.

927
00:58:01,520 --> 00:58:04,050
>> Uma matriz é um tipo de dados.

928
00:58:04,050 --> 00:58:10,730
É um tipo de variável do tipo que tem vários tipos de dados menores dentro dela

929
00:58:10,730 --> 00:58:12,680
de costas para trás, para trás.

930
00:58:12,680 --> 00:58:16,980
Assim, por exemplo, se quiséssemos escrever um pequeno programa que lhe dá a sua média de teste

931
00:58:16,980 --> 00:58:19,780
para um curso como 50, que tem dois questionários,

932
00:58:19,780 --> 00:58:23,450
você poderia muito facilmente escrever este programa baseado mesmo em alguns dos materiais da semana passada

933
00:58:23,450 --> 00:58:28,830
usando GetInt e um par de variáveis: int quiz1, int quiz2.

934
00:58:28,830 --> 00:58:30,550
E é bastante simples.

935
00:58:30,550 --> 00:58:33,500
É talvez 10, 20 linhas de código máximo para implementar um programa de

936
00:58:33,500 --> 00:58:38,940
que pede ao usuário para duas pontuações do questionário e calcula a média

937
00:58:38,940 --> 00:58:42,020
somando-os, dividindo por 2, e em seguida a impressão dos resultados.

938
00:58:42,020 --> 00:58:46,400
Nós provavelmente poderia fazer isso muito rapidamente agora, depois de um determinado número de minutos.

939
00:58:46,400 --> 00:58:49,450
Mas o problema é que, suponhamos que 50 tinham 3 ou 4 testes.

940
00:58:49,450 --> 00:58:52,830
Suponha que você queria usar o mesmo programa para uma classe que teve testes semanalmente.

941
00:58:52,830 --> 00:58:55,100
Pense em uma classe que tem testes semanalmente.

942
00:58:55,100 --> 00:58:58,840
Se há 16 ou mais semanas, em um semestre, agora você tem 16 variáveis:

943
00:58:58,840 --> 00:59:03,030
int quiz1, int quiz2, int quiz3, int quiz4.

944
00:59:03,030 --> 00:59:06,870
Assim que você começar a ver essa redundância, esta cópia e colagem de código,

945
00:59:06,870 --> 00:59:09,810
ele deve começar a fazer você gostaria que houvesse uma maneira melhor.

946
00:59:09,810 --> 00:59:13,610
E, felizmente, porque de matrizes há. Então, vamos fazer isso.

947
00:59:13,610 --> 00:59:16,700
Primeiro, deixe-me apresentar uma coisa muito simples que não usei até agora,

948
00:59:16,700 --> 00:59:18,820
mas você vai ver que, ocasionalmente, em código.

949
00:59:18,820 --> 00:59:21,270
>> Isto é o que é geralmente chamado de uma constante.

950
00:59:21,270 --> 00:59:24,410
Então, é uma constante no sentido de que este valor nunca muda.

951
00:59:24,410 --> 00:59:26,450
A convenção humana ao criar uma constante

952
00:59:26,450 --> 00:59:30,420
é usar todas as letras maiúsculas apenas para que ele realmente se destaca em seu código,

953
00:59:30,420 --> 00:59:34,270
ea palavra-chave especial que você usa em C # é definir.

954
00:59:34,270 --> 00:59:39,970
Assim, dizemos # define, então, um espaço, então a palavra que você deseja usar para o nome constante do

955
00:59:39,970 --> 00:59:41,730
e, em seguida, o valor da constante.

956
00:59:41,730 --> 00:59:44,710
Note que isto é diferente de atribuir algo a uma variável.

957
00:59:44,710 --> 00:59:46,430
Não há sinal de igual, não há ponto e vírgula.

958
00:59:46,430 --> 00:59:49,140
Isso é o que é geralmente conhecido como uma diretiva de pré-processamento,

959
00:59:49,140 --> 00:59:50,840
mas mais sobre isso em outro momento.

960
00:59:50,840 --> 00:59:56,350
Por agora, isso cria um valor imutável chamado QUESTIONÁRIOS

961
00:59:56,350 --> 00:59:58,290
cujo valor numérico real é 2.

962
00:59:58,290 --> 01:00:02,180
Então, em qualquer lugar que você vê testes, questionários, testes ao longo deste arquivo,

963
01:00:02,180 --> 01:00:04,230
isso é apenas o número 2.

964
01:00:04,230 --> 01:00:06,550
Se eu olhar para principal agora, vamos ver como isso funciona.

965
01:00:06,550 --> 01:00:09,770
Primeiro, ele parece um pouco enigmático, mas é tudo coisa de 1 semana.

966
01:00:09,770 --> 01:00:12,210
Peça ao usuário para notas. Como podemos fazer isso?

967
01:00:12,210 --> 01:00:17,350
Na linha 22 - este é realmente a parte suculenta - Declaro um flutuador

968
01:00:17,350 --> 01:00:23,240
mas não apenas um único flutuador. Estou declarando, antes, um conjunto de valores de ponto flutuante.

969
01:00:23,240 --> 01:00:27,700
Essa variável vai ser chamado de notas, como implicado aqui,

970
01:00:27,700 --> 01:00:31,420
mas a única peça de nova sintaxe, então são estes colchetes.

971
01:00:31,420 --> 01:00:37,280
O fato de que eu disse notas float e, em seguida, suporte aberto e, em seguida, um número -

972
01:00:37,280 --> 01:00:40,980
perceber se esta é uma constante este é apenas como nós fizemos isso -

973
01:00:40,980 --> 01:00:46,840
isso significa, "Hey computador, dá-me dois carros alegóricos e vamos chamá-los coletivamente notas."

974
01:00:46,840 --> 01:00:51,780
>> Isto está em contraste com um processo muito mais tedioso assim: flutuador classe1;

975
01:00:51,780 --> 01:00:54,580
grade2 flutuar, e assim por diante.

976
01:00:54,580 --> 01:00:58,310
Assim, uma matriz que nos permite implementar esta idéia, mas muito menos messily,

977
01:00:58,310 --> 01:01:04,560
de modo a que podemos escrever uma linha de código, em vez de, digamos, 16 para um semestre de 16 semanas.

978
01:01:04,560 --> 01:01:09,060
Eu não queria rígido código-2 porque se você pensar sobre isso agora, logicamente,

979
01:01:09,060 --> 01:01:12,560
suponho que no próximo ano CS50 alterações 3 quizzes vez

980
01:01:12,560 --> 01:01:15,010
e eu tinha o número 2 aqui, eu tinha o número 2 aqui,

981
01:01:15,010 --> 01:01:17,210
Eu tive o número 2 aqui, o número 2 aqui.

982
01:01:17,210 --> 01:01:19,890
Torna-se muito tedioso e muito fácil de estragar

983
01:01:19,890 --> 01:01:26,550
e mudar acidentalmente um valor para 3 e perder algum outro valor de 2.

984
01:01:26,550 --> 01:01:30,660
Então, eu estou indo para lugar abstrato isso adiante e usar essa constante que,

985
01:01:30,660 --> 01:01:32,520
Como o nome sugere, nunca muda.

986
01:01:32,520 --> 01:01:35,870
E agora não importa se temos diferentes testes este ano ou no próximo,

987
01:01:35,870 --> 01:01:39,380
Eu só tenho que mudá-lo em um lugar aqui em cima.

988
01:01:39,380 --> 01:01:41,230
Então isso é tudo uma constante é.

989
01:01:41,230 --> 01:01:47,100
Enquanto isso, o novo recurso conceitual é que de uma matriz.

990
01:01:47,100 --> 01:01:55,030
Assim, os colchetes me dar esta flutua muitas e deixa-me chamá-los coletivamente notas aqui.

991
01:01:55,030 --> 01:01:56,720
Então agora vamos ver o que eu vou fazer.

992
01:01:56,720 --> 01:01:59,220
Aqui, na linha 24 é o início de um laço.

993
01:01:59,220 --> 01:02:03,380
>> Isto é realmente nada extravagante. É só usar QUESTIONÁRIOS vez de um número codificado.

994
01:02:03,380 --> 01:02:06,740
Mas não há nada intelectualmente diferente lá desde a semana passada.

995
01:02:06,740 --> 01:02:11,650
Este é apenas printf, assim printf ("Quiz d #% de% d:")

996
01:02:11,650 --> 01:02:16,670
porque eu só quero imprimir me dar questionário número 1 de 2 e, em seguida, 2 a 2.

997
01:02:16,670 --> 01:02:18,480
Então isso é uma coisa puramente estética.

998
01:02:18,480 --> 01:02:21,000
Mas a parte interessante agora é na linha 27.

999
01:02:21,000 --> 01:02:27,840
A fim de preencher um dos dois marcadores de posição com um valor de ponto flutuante,

1000
01:02:27,840 --> 01:02:29,640
novamente usar colchetes.

1001
01:02:29,640 --> 01:02:35,170
Neste caso, eu estou usando i porque este loop começou com i igualando o valor que, aparentemente?

1002
01:02:35,170 --> 01:02:36,670
[Estudante] 0. >> [Malan] 0.

1003
01:02:36,670 --> 01:02:40,990
Assim, na primeira iteração do loop, é como se eu escrevi isso no código,

1004
01:02:40,990 --> 01:02:46,310
mas na segunda iteração do loop, é como se eu escrevi isso no meu código.

1005
01:02:46,310 --> 01:02:49,970
Mas o fato de que eu estou usando uma variável é perfeito, porque, como o nome sugere,

1006
01:02:49,970 --> 01:02:52,600
está variando o seu valor a cada iteração,

1007
01:02:52,600 --> 01:02:55,900
então eu estou preenchendo essa matriz um ponto de cada vez.

1008
01:02:55,900 --> 01:02:57,380
O que essa matriz se parece?

1009
01:02:57,380 --> 01:03:01,570
A razão que eu desenhei o retângulo super simples na tela aqui antes foi por este motivo.

1010
01:03:01,570 --> 01:03:05,590
Uma matriz é apenas um pedaço de memória seguido por outro pedaço de memória

1011
01:03:05,590 --> 01:03:08,570
seguido por um outro bloco de memória e assim por diante.

1012
01:03:08,570 --> 01:03:13,120
Então, se minha matriz é de tamanho 2, neste caso, aqui, tudo o que eu estaria fazendo

1013
01:03:13,120 --> 01:03:20,200
digitando na pontuação meus questionário como aqui - Eu tenho 100 em um presente e então eu tenho um 99 em um presente -

1014
01:03:20,200 --> 01:03:24,970
então esta memória não pode ser usado até mesmo porque eu só perguntei o computador

1015
01:03:24,970 --> 01:03:26,840
para uma matriz de tamanho 2.

1016
01:03:26,840 --> 01:03:28,600
Essas praças ainda estão lá, certo?

1017
01:03:28,600 --> 01:03:32,670
Você ainda tem 2 gigabytes de RAM, mesmo se você está apenas pedindo para 2 carros alegóricos.

1018
01:03:32,670 --> 01:03:36,840
Assim, a idéia por trás de matrizes é que o computador só tem um pedaço da memória

1019
01:03:36,840 --> 01:03:41,340
e depois reparte pequenos pedaços de costas para trás, para trás.

1020
01:03:41,340 --> 01:03:43,310
E para que é tudo uma matriz é.

1021
01:03:43,310 --> 01:03:47,350
>> É um pedaço contíguo de memória dentro do qual você pode colocar as coisas.

1022
01:03:47,350 --> 01:03:50,700
Isso acontece para depois fazer apenas alguns aritmética chato.

1023
01:03:50,700 --> 01:03:54,640
Se eu rolar por aqui, este é o lugar onde eu então iterar sobre o array.

1024
01:03:54,640 --> 01:03:58,020
Eu venho com o somatório de todos os valores na matriz,

1025
01:03:58,020 --> 01:04:02,470
e então eu uso a função round aqui para realmente fazer a soma dividida por testes.

1026
01:04:02,470 --> 01:04:06,320
Mas deixe-me acenar a minha mão em que, como espécie de aritmética suficiente por enquanto.

1027
01:04:06,320 --> 01:04:08,370
Mas tudo o que está fazendo para mim, em última análise é o cálculo de uma média.

1028
01:04:08,370 --> 01:04:13,580
Então, primeiro questionário, mais segundo questionário dividido por 2 e depois mostrá-lo como um int.

1029
01:04:13,580 --> 01:04:17,280
Mas vamos transição agora a um exemplo diferente, chamado string1,

1030
01:04:17,280 --> 01:04:20,700
que pinta um quadro similar, mas usando cordas.

1031
01:04:20,700 --> 01:04:23,940
Deixe-me ir em frente e simplificar este apenas por um momento.

1032
01:04:23,940 --> 01:04:27,090
Perdoe o recuo para agora.

1033
01:04:27,090 --> 01:04:30,870
Observe na linha 19 deste exemplo, eu recebo uma string do usuário.

1034
01:04:30,870 --> 01:04:34,640
Mas note o que eu estou fazendo no próximo linhas de 22 em diante.

1035
01:04:34,640 --> 01:04:41,250
Na verdade, estou repetindo a partir de i-se - e este é um novo truque - strlen comprimento da corda,.

1036
01:04:41,250 --> 01:04:44,880
Esta é uma função que vem com o C que se você passar uma string,

1037
01:04:44,880 --> 01:04:47,730
ele diz que o número de caracteres que estão na cadeia. Isto é tudo.

1038
01:04:47,730 --> 01:04:51,550
E o fato de que é strlen em vez de comprimento da corda é apenas porque é mais sucinto.

1039
01:04:51,550 --> 01:04:55,100
Trinta anos atrás, as pessoas gostavam de escrever coisas da forma mais sucinta possível,

1040
01:04:55,100 --> 01:04:57,630
por isso temos mantido essa convenção aqui.

1041
01:04:57,630 --> 01:05:00,660
i + + significa apenas incrementar i em cada iteração.

1042
01:05:00,660 --> 01:05:02,990
E agora perceber isso, o que é realmente interessante.

1043
01:05:02,990 --> 01:05:09,180
Na linha 24, eu digo, "Computador, dê-me um personagem, 8 bits, e chamá-lo de c."

1044
01:05:09,180 --> 01:05:12,630
Mas o que é isso no lado direito dizendo?

1045
01:05:13,490 --> 01:05:16,530
Em Inglês, o que isso representa?

1046
01:05:16,530 --> 01:05:18,730
[Aluno] O primeiro caractere na matriz.

1047
01:05:18,730 --> 01:05:20,790
Exatamente. Dá-me o primeiro caractere na matriz.

1048
01:05:20,790 --> 01:05:24,090
Ou, mais geralmente, dá-me o caráter om na matriz.

1049
01:05:24,090 --> 01:05:26,100
E perceber que é importante agora que os cientistas de computador,

1050
01:05:26,100 --> 01:05:27,890
na verdade estamos a contar 0.

1051
01:05:27,890 --> 01:05:29,720
>> Você não tem a critério agora para começar a fazer isso.

1052
01:05:29,720 --> 01:05:34,160
Agora você tem que se comportar de acordo com as expectativas do computador e contar de 0

1053
01:05:34,160 --> 01:05:38,180
porque [0] vai ser o primeiro caractere em uma seqüência,

1054
01:05:38,180 --> 01:05:42,150
[1] será o segundo, [2], vai ser o terceiro, e assim por diante.

1055
01:05:42,150 --> 01:05:49,720
Portanto, este programa, se eu compilar ele, este é novamente string1, assim que string1,

1056
01:05:49,720 --> 01:05:54,670
e agora eu tenho que correr string1 na minha janela de terminal.

1057
01:05:54,670 --> 01:05:58,330
Ele está esperando por entrada, então eu vou digitar David, Enter

1058
01:05:58,330 --> 01:06:02,540
e agora ela imprime Davi tudo em linhas diferentes, pois observe o que eu estou fazendo.

1059
01:06:02,540 --> 01:06:05,820
Estou imprimindo um caráter de cada vez.

1060
01:06:05,820 --> 01:06:10,100
Nós não vamos entrar em detalhes hoje sobre isso, mas eu deletei há pouco esta verificação aqui.

1061
01:06:10,100 --> 01:06:15,480
Acontece que se o usuário está se comportando mal, contraditório, ou apenas confuso

1062
01:06:15,480 --> 01:06:20,210
você pode realmente deixar de dar uma seqüência de algum tempo.

1063
01:06:20,210 --> 01:06:22,860
Se você bater na tecla errada no teclado, você pode dar nenhuma seqüência em tudo,

1064
01:06:22,860 --> 01:06:26,950
ou se você é malicioso, você pode tentar colar no valor de um gigabyte de um ensaio

1065
01:06:26,950 --> 01:06:29,290
para preencher essa seqüência, e se o computador ficar sem memória,

1066
01:06:29,290 --> 01:06:32,710
acontece que nós vamos voltar este valor especial chamado NULL.

1067
01:06:32,710 --> 01:06:35,580
Então, por enquanto, só sei que há esse valor especial chamado NULL

1068
01:06:35,580 --> 01:06:39,580
que nos permitirá verificar quando estamos fora de memória, entre outras coisas.

1069
01:06:39,580 --> 01:06:45,630
Mas se eu abrir agora string2, notar uma diferença aqui.

1070
01:06:45,630 --> 01:06:48,210
Observe uma diferença aqui com string2.

1071
01:06:48,210 --> 01:06:51,340
Com string2, este loop é um pouco diferente.

1072
01:06:51,340 --> 01:06:55,010
>> Deixe-me apagar os nulos, para que possamos falar sobre isso outra hora.

1073
01:06:55,010 --> 01:06:57,800
O que é diferente sobre o laço for desta vez?

1074
01:06:59,620 --> 01:07:01,670
Eu posso voltar ao exemplo anterior.

1075
01:07:01,670 --> 01:07:08,580
Então essa é a versão 2, esta é a versão 1. 1, 2.

1076
01:07:08,580 --> 01:07:11,980
1, 2.

1077
01:07:13,520 --> 01:07:16,660
A chamada strlen é onde?

1078
01:07:16,660 --> 01:07:18,860
É na primeira parte do loop.

1079
01:07:18,860 --> 01:07:21,830
Todos os pensamentos a respeito de porque eu estou fazendo isso? Sim.

1080
01:07:21,830 --> 01:07:24,560
[Estudante] Então você não chamar a função de cada vez.

1081
01:07:24,560 --> 01:07:26,440
[Malan] Então, nós não chamar a função a cada momento. Exatamente.

1082
01:07:26,440 --> 01:07:28,300
Lembre-se de laços que são super simples

1083
01:07:28,300 --> 01:07:31,770
uma vez que tipo de entender que esta é a inicialização, a condição ea atualização.

1084
01:07:31,770 --> 01:07:34,750
O problema é que a condição ocorre em cada iteração do loop.

1085
01:07:34,750 --> 01:07:40,010
E assim, neste exemplo aqui, o que é ruim sobre o fato de que esta é a minha condição?

1086
01:07:40,010 --> 01:07:41,830
[Aluno] Você está chamando strlen.

1087
01:07:41,830 --> 01:07:44,340
[Malan] Você está chamando strlen novo e de novo e de novo.

1088
01:07:44,340 --> 01:07:47,410
Mas uma vez que eu digitei em Davi, o comprimento da corda que é 5,

1089
01:07:47,410 --> 01:07:49,650
e isso não vai mudar em cada iteração do loop

1090
01:07:49,650 --> 01:07:51,670
porque a cadeia ainda é D-a-v-i-d.

1091
01:07:51,670 --> 01:07:55,320
Portanto, esta é uma dica do que vai se tornar uma idéia cada vez mais importante

1092
01:07:55,320 --> 01:08:00,410
conhecido como uma decisão de projeto, onde só não fazer o computador fazer um trabalho desnecessário.

1093
01:08:00,410 --> 01:08:03,920
>> Assim como uma prévia de pset2, pset2 na edição padrão

1094
01:08:03,920 --> 01:08:07,030
vai desafiá-lo para realmente implementar um número de cifras,

1095
01:08:07,030 --> 01:08:10,410
um número de algoritmos de criptografia, de modo que você pode tanto criptografar

1096
01:08:10,410 --> 01:08:13,840
e decifrar mensagens secretas, como a muito não Ralphie um decodificado.

1097
01:08:13,840 --> 01:08:16,810
Na edição de hacker de pset2, vamos ir um pouco mais longe.

1098
01:08:16,810 --> 01:08:19,649
Nós vamos entregar-lhe um arquivo de um sistema de computador real

1099
01:08:19,649 --> 01:08:23,479
que contém um monte de nomes de usuário e senhas criptografadas reais,

1100
01:08:23,479 --> 01:08:26,939
eo desafio para a edição de hacker vai ser para quebrar as senhas

1101
01:08:26,939 --> 01:08:33,200
e descobrir o que a criptografia ou que segredo foi usado para realmente gerar essas senhas.

1102
01:08:33,200 --> 01:08:36,109
E nós vamos fazer isso usando um novo recurso aqui de C

1103
01:08:36,109 --> 01:08:40,630
que eu vou dar-lhe apenas uma demo de conhecido como linha de comando argumentos.

1104
01:08:40,630 --> 01:08:44,229
Acontece que, como alguns de vocês podem ter visto na seção ou nos livros didáticos,

1105
01:08:44,229 --> 01:08:48,260
principal nem sempre tem que ser nula entre parênteses.

1106
01:08:48,260 --> 01:08:52,430
Acontece que principal também pode ser escrito assim, com dois argumentos,

1107
01:08:52,430 --> 01:08:56,870
argc e argv, argc, onde é o número de palavras

1108
01:08:56,870 --> 01:09:00,020
que você escreva depois o nome do programa em sua linha de comando

1109
01:09:00,020 --> 01:09:03,420
e argv são as palavras reais.

1110
01:09:03,420 --> 01:09:07,540
E, como os colchetes lá sugerir, argv é, aparentemente, um array.

1111
01:09:07,540 --> 01:09:12,210
Vai ser uma seqüência, após uma série depois de uma série na memória.

1112
01:09:12,210 --> 01:09:16,010
>> Então, o que nós vamos ser capazes de fazer começando com pset 2 é algo como isto.

1113
01:09:16,010 --> 01:09:21,350
Se eu fizer argv1, que é um exemplo que vai voltar para segunda-feira, e executá-lo,

1114
01:09:21,350 --> 01:09:23,370
notar que não parece fazer nada ainda.

1115
01:09:23,370 --> 01:09:25,490
Ele só imprime seu próprio nome.

1116
01:09:25,490 --> 01:09:31,479
Mas se eu disser adeus classe, aviso que este programa aparentemente itera

1117
01:09:31,479 --> 01:09:35,479
sobre cada uma das palavras que foram digitados no prompt.

1118
01:09:35,479 --> 01:09:41,630
E os meios pelos quais nós vamos ter acesso a palavras que o usuário digitou no prompt

1119
01:09:41,630 --> 01:09:49,160
é mudando principal a partir deste fim de semana int main (void) para int main (argc, argv)

1120
01:09:49,160 --> 01:09:52,050
e, assim, vai nascer de linha de comando argumentos.

1121
01:09:52,050 --> 01:09:57,100
E uma vez que você realmente sofisticado com isso, você vai ser capaz de escrever programas realmente trippy

1122
01:09:57,100 --> 01:09:59,610
como este aqui, que vai acima e além

1123
01:09:59,610 --> 01:10:03,940
algumas das funcionalidades que temos feito até agora, mas todos muito poderoso.

1124
01:10:03,940 --> 01:10:08,950
>> Então, vamos deixar isso com isso na tela, e vamos vê-lo na segunda-feira.

1125
01:10:17,570 --> 01:10:20,000
>> [CS50.TV]