1
00:00:00,000 --> 00:00:02,000
[Powered by Google Translate] [Seção 4] [menos confortável]

2
00:00:02,000 --> 00:00:04,000
[Nate Hardison] [Harvard University]

3
00:00:04,000 --> 00:00:07,000
[Esta é CS50.] [CS50.TV]

4
00:00:07,000 --> 00:00:10,000
>> Tudo bem, bem-vindo de volta à seção.

5
00:00:10,000 --> 00:00:13,000
Na seção desta semana vamos fazer um par de coisas.

6
00:00:13,000 --> 00:00:17,000
Nós vamos primeiro Ajuste repescagem Problema 2,

7
00:00:17,000 --> 00:00:20,000
que é o conjunto de problemas César e Vigenère.

8
00:00:20,000 --> 00:00:23,000
E então vamos mergulhar Quiz de 0 avaliação

9
00:00:23,000 --> 00:00:26,000
e passar um pouco de tempo recapitulando o que nós já conversamos sobre

10
00:00:26,000 --> 00:00:30,000
em cada uma das palestras até agora, e vamos também fazer alguns problemas

11
00:00:30,000 --> 00:00:32,000
a partir de questionários ano anterior.

12
00:00:32,000 --> 00:00:36,000
Dessa forma, vocês têm uma boa maneira de se preparar para isso.

13
00:00:36,000 --> 00:00:40,000
>> Para começar, eu tenha iniciado um par de boas soluções

14
00:00:40,000 --> 00:00:45,000
para o conjunto de problemas anterior, Conjunto de Problemas 2, neste espaço.

15
00:00:45,000 --> 00:00:48,000
Se vocês todos bater este link,

16
00:00:48,000 --> 00:00:53,000
e se você clicar meu nome e clique na minha primeira revisão

17
00:00:53,000 --> 00:00:56,000
você verá caesar.c, que é exatamente o que eu estou olhando.

18
00:00:56,000 --> 00:01:00,000
Vamos falar sobre isso muito rapidamente.

19
00:01:00,000 --> 00:01:02,000
Esta é apenas uma solução de amostra.

20
00:01:02,000 --> 00:01:05,000
Esta não é necessariamente a solução perfeita.

21
00:01:05,000 --> 00:01:08,000
Há muitas maneiras diferentes de escrever isso,

22
00:01:08,000 --> 00:01:10,000
mas há algumas coisas que eu gostaria de destacar

23
00:01:10,000 --> 00:01:13,000
que eu vi como eu estava de classificação, os erros mais comuns que eu acho que

24
00:01:13,000 --> 00:01:18,000
esta solução faz um trabalho muito bom de manuseio.

25
00:01:18,000 --> 00:01:22,000
>> O primeiro é ter algum tipo de comentário de cabeçalho no topo.

26
00:01:22,000 --> 00:01:25,000
Em linhas 1 a 7 você ver os detalhes,

27
00:01:25,000 --> 00:01:28,000
exatamente o que este programa está fazendo.

28
00:01:28,000 --> 00:01:32,000
Uma boa prática padrão quando você está escrevendo código C

29
00:01:32,000 --> 00:01:35,000
independentemente se o seu programa está contido em um único arquivo ou

30
00:01:35,000 --> 00:01:38,000
se ele está dividido em vários arquivos é ter algum tipo de

31
00:01:38,000 --> 00:01:40,000
orientar comentário no topo.

32
00:01:40,000 --> 00:01:43,000
Este também é para as pessoas que vão para fora e escrever código no mundo real.

33
00:01:43,000 --> 00:01:47,000
Este é o lugar onde eles vão colocar informações de copyright.

34
00:01:47,000 --> 00:01:50,000
A seguir estão listadas as inclui #.

35
00:01:50,000 --> 00:01:55,000
Na linha 16 há essa # define, que nós vamos voltar a nos um pouco.

36
00:01:55,000 --> 00:01:59,000
E então, uma vez que a função começa, começa uma vez principais,

37
00:01:59,000 --> 00:02:03,000
porque este programa foi tudo contido em uma única função

38
00:02:03,000 --> 00:02:09,000
a primeira coisa que acontece, e isso é muito idiomática e típica de um programa C

39
00:02:09,000 --> 00:02:14,000
que leva em linha de comando argumentos é que ele verifica imediatamente

40
00:02:14,000 --> 00:02:18,000
>> para a contagem de argumento, argc.

41
00:02:18,000 --> 00:02:24,000
Aqui podemos ver que este programa está esperando dois argumentos exatamente.

42
00:02:24,000 --> 00:02:27,000
Lembre-se que não há primeiro argumento que é o especial

43
00:02:27,000 --> 00:02:29,000
que é sempre o nome do programa que está sendo executado,

44
00:02:29,000 --> 00:02:31,000
o nome do arquivo executável.

45
00:02:31,000 --> 00:02:36,000
E então o que isto significa é que impede o usuário de execução do programa

46
00:02:36,000 --> 00:02:42,000
com argumentos mais ou menos.

47
00:02:42,000 --> 00:02:44,000
A razão que nós queremos para verificar isso de imediato é porque

48
00:02:44,000 --> 00:02:52,000
não podemos realmente acessar essa matriz argv aqui confiável

49
00:02:52,000 --> 00:02:55,000
até que tenhamos verificado para ver o quão grande ela é.

50
00:02:55,000 --> 00:02:58,000
>> Um dos erros mais comuns que eu vi foi pessoas imediatamente ir

51
00:02:58,000 --> 00:03:01,000
e agarrar argv [1].

52
00:03:01,000 --> 00:03:06,000
Eles pegar o argumento chave da matriz e não a um para eu verificar sobre ele,

53
00:03:06,000 --> 00:03:11,000
e então faria o teste para argc, bem como o próximo teste,

54
00:03:11,000 --> 00:03:16,000
com ou sem o primeiro argumento era realmente um número inteiro, ao mesmo tempo,

55
00:03:16,000 --> 00:03:20,000
e que não funciona, porque no caso de que não existem argumentos fornecidos

56
00:03:20,000 --> 00:03:26,000
você vai ser pegar um argumento que não existe, ou tentar pegar uma que não está lá.

57
00:03:26,000 --> 00:03:29,000
>> A outra grande coisa que você deve observar é que

58
00:03:29,000 --> 00:03:32,000
você sempre quer imprimir algum tipo de mensagem de erro útil

59
00:03:32,000 --> 00:03:34,000
para o utilizador a orientar-los.

60
00:03:34,000 --> 00:03:37,000
Tenho certeza de que você tem todos os programas de execução, onde, de repente, ele trava,

61
00:03:37,000 --> 00:03:41,000
e você receber esse diálogo pouco ridículo que aparece e diz

62
00:03:41,000 --> 00:03:44,000
algo terrivelmente enigmático e talvez lhe dá um código de erro ou algo parecido

63
00:03:44,000 --> 00:03:47,000
que não faz sentido.

64
00:03:47,000 --> 00:03:50,000
Isto é onde você realmente quer oferecer algo útil

65
00:03:50,000 --> 00:03:54,000
e orientada para o usuário, de modo que quando executá-lo eles vão "Oh," palma rosto.

66
00:03:54,000 --> 00:03:58,000
"Eu sei exatamente o que fazer. Sei como corrigir isso."

67
00:03:58,000 --> 00:04:01,000
>> Se você não imprimir uma mensagem, então você acaba realmente

68
00:04:01,000 --> 00:04:04,000
deixando o usuário a ir examinar o código-fonte

69
00:04:04,000 --> 00:04:07,000
para descobrir o que deu errado.

70
00:04:07,000 --> 00:04:11,000
Há também algumas vezes que você vai usar os códigos de erro diferentes.

71
00:04:11,000 --> 00:04:14,000
Aqui nós apenas usou um para dizer que houve um erro,

72
00:04:14,000 --> 00:04:16,000
houve um erro, houve um erro.

73
00:04:16,000 --> 00:04:20,000
Programas maiores, muitas vezes, os programas que são chamados por outros programas,

74
00:04:20,000 --> 00:04:25,000
irá retornar algum tipo de códigos de erro especiais em diferentes cenários

75
00:04:25,000 --> 00:04:28,000
programaticamente comunicar o que você faria de outra forma

76
00:04:28,000 --> 00:04:32,000
usar apenas uma bela mensagem Inglês para.

77
00:04:32,000 --> 00:04:35,000
Cool.

78
00:04:35,000 --> 00:04:37,000
Como nós trabalhamos para baixo, você pode ver que puxar a chave.

79
00:04:37,000 --> 00:04:40,000
Testamos para ver se a chave se encaixa.

80
00:04:40,000 --> 00:04:42,000
Recebemos uma mensagem do usuário.

81
00:04:42,000 --> 00:04:46,000
A razão por que fazê-lo nesta fazer enquanto ciclo e isso é algo que vamos cobrir

82
00:04:46,000 --> 00:04:50,000
em um pouquinho, mas acontece que se você digitar o controle D

83
00:04:50,000 --> 00:04:54,000
quando você começa a GetString prompt no terminal

84
00:04:54,000 --> 00:04:59,000
o que isso realmente significa é que envia um caractere especial

85
00:04:59,000 --> 00:05:01,000
para o programa.

86
00:05:01,000 --> 00:05:05,000
É o chamado ELF ou o fim do arquivo de caracteres.

87
00:05:05,000 --> 00:05:08,000
E, nesse caso, a nossa cadeia de mensagem será nulo,

88
00:05:08,000 --> 00:05:14,000
, que não foi algo que verificado para o conjunto de problemas em si.

89
00:05:14,000 --> 00:05:17,000
>> Mas como nós vamos, agora que começamos a falar sobre ponteiros

90
00:05:17,000 --> 00:05:21,000
e alocação dinâmica de memória na pilha,

91
00:05:21,000 --> 00:05:25,000
verificação de nulo sempre que você tem uma função que poderia

92
00:05:25,000 --> 00:05:30,000
retornar nulo como um valor é algo que você vai querer adquirir o hábito de fazer.

93
00:05:30,000 --> 00:05:33,000
Isto é aqui principalmente para fins de ilustração.

94
00:05:33,000 --> 00:05:36,000
Mas quando você vê GetString no futuro,

95
00:05:36,000 --> 00:05:41,000
assim do Conjunto de Problemas 4, você vai querer manter isso em mente.

96
00:05:41,000 --> 00:05:44,000
Novamente, isto não é um problema para Conjunto de Problemas 3 ou uma vez que não tinha coberto isso ainda.

97
00:05:44,000 --> 00:05:53,000
Finalmente, chegamos a esta parte, onde temos para o circuito de criptografia principal,

98
00:05:53,000 --> 00:05:57,000
e há um par de coisas acontecendo aqui.

99
00:05:57,000 --> 00:06:02,000
Primeiro, iterar sobre a cadeia de mensagem inteira em si.

100
00:06:02,000 --> 00:06:07,000
Aqui mantivemos a chamada strlen na condição,

101
00:06:07,000 --> 00:06:12,000
que alguns de vocês têm apontado não é um grande caminho a percorrer.

102
00:06:12,000 --> 00:06:15,000
Acontece que, neste caso, também não é grande,

103
00:06:15,000 --> 00:06:20,000
em parte porque estamos modificando o conteúdo da mensagem em si

104
00:06:20,000 --> 00:06:27,000
dentro do loop for, então se temos uma mensagem que é 10 caracteres,

105
00:06:27,000 --> 00:06:32,000
a primeira vez que iniciar esse ciclo for strlen vai devolver o que?

106
00:06:32,000 --> 00:06:35,000
10.

107
00:06:35,000 --> 00:06:40,000
>> Mas se então modificar mensagem, dizer que modificar seu caráter 5,

108
00:06:40,000 --> 00:06:46,000
e nós jogar em um caracter \ 0 na posição 5,

109
00:06:46,000 --> 00:06:49,000
em uma iteração subseqüente strlen (mensagem) não irá retornar o que ele fez

110
00:06:49,000 --> 00:06:52,000
a primeira vez que iterada,

111
00:06:52,000 --> 00:06:56,000
mas, ao contrário, retornar 5, porque nós jogamos em que terminador nulo,

112
00:06:56,000 --> 00:06:59,000
e comprimento da corda é definido

113
00:06:59,000 --> 00:07:03,000
pelo que a posição de \ 0.

114
00:07:03,000 --> 00:07:09,000
Neste caso, esta é uma ótima maneira de ir porque estamos modificando-o no lugar.

115
00:07:09,000 --> 00:07:13,000
Mas você percebe que este é realmente surpreendentemente simples para criptografar

116
00:07:13,000 --> 00:07:16,000
se você pode obter a matemática correta.

117
00:07:16,000 --> 00:07:19,000
Tudo o que é necessário é verificar se há ou não a letra que você está olhando

118
00:07:19,000 --> 00:07:21,000
é maiúscula ou minúscula.

119
00:07:21,000 --> 00:07:24,000
>> A razão, só temos que verificar isso e não temos para verificar

120
00:07:24,000 --> 00:07:27,000
o caso do alfa é porque

121
00:07:27,000 --> 00:07:30,000
se um personagem é maiúscula ou se é minúscula

122
00:07:30,000 --> 00:07:33,000
então é definitivamente um caractere alfabético,

123
00:07:33,000 --> 00:07:38,000
porque não tem dígitos maiúsculas e minúsculas.

124
00:07:38,000 --> 00:07:41,000
A outra coisa que fazer, e isso é um pouco complicado,

125
00:07:41,000 --> 00:07:45,000
é que já modificou o padrão César cifra fórmula

126
00:07:45,000 --> 00:07:49,000
que demos na especificação do conjunto de problemas.

127
00:07:49,000 --> 00:07:52,000
O que é diferente aqui é que nós subtraído

128
00:07:52,000 --> 00:07:58,000
na capital caso maiúsculas A, e então nós adicionamos maiúsculo

129
00:07:58,000 --> 00:08:02,000
voltar no final.

130
00:08:02,000 --> 00:08:05,000
>> Eu sei que alguns de vocês têm feito isso em seu código.

131
00:08:05,000 --> 00:08:09,000
Será que algum de vocês fazem isso em suas apresentações?

132
00:08:09,000 --> 00:08:13,000
Você fez isso. Pode explicar o que isto significa, SAHB?

133
00:08:13,000 --> 00:08:18,000
Subtraindo-lo, porque você fez um mod logo depois,

134
00:08:18,000 --> 00:08:21,000
você tem que levá-la para fora, assim que você começa maneira [tosse] posição.

135
00:08:21,000 --> 00:08:25,000
E, em seguida, adicionando-lo de volta mais tarde você mudou mais o que você queria.

136
00:08:25,000 --> 00:08:27,000
Sim, exatamente.

137
00:08:27,000 --> 00:08:32,000
O que SAHB disse foi que quando se deseja adicionar

138
00:08:32,000 --> 00:08:36,000
nossa mensagem e nossa chave juntos

139
00:08:36,000 --> 00:08:42,000
e mod mod que, que por NUM_LETTERS,

140
00:08:42,000 --> 00:08:50,000
se não escalar a nossa mensagem para o intervalo 0 a 25 apropriado primeira,

141
00:08:50,000 --> 00:08:54,000
então pode acabar recebendo um número muito estranho

142
00:08:54,000 --> 00:08:59,000
porque os valores que nós estamos olhando quando olhamos mensagem [i],

143
00:08:59,000 --> 00:09:03,000
quando olhamos para o caráter i de nossa mensagem de texto simples,

144
00:09:03,000 --> 00:09:08,000
é um valor algures nesta gama de 65-122

145
00:09:08,000 --> 00:09:13,000
com base nos valores ASCII para letras maiúsculas de A a Z em minúsculas.

146
00:09:13,000 --> 00:09:18,000
E assim, quando nós mod-lo por 26 ou por NUM_LETTERS,

147
00:09:18,000 --> 00:09:23,000
uma vez que era o nosso # define no canto superior direito até aqui,

148
00:09:23,000 --> 00:09:28,000
que vai nos dar um valor que está na faixa de 0 a 25,

149
00:09:28,000 --> 00:09:30,000
e precisamos de uma maneira de escalar então que back-up

150
00:09:30,000 --> 00:09:32,000
e obtê-lo no intervalo apropriado ASCII.

151
00:09:32,000 --> 00:09:36,000
A maneira mais fácil de fazer isso é apenas para escalar tudo para baixo

152
00:09:36,000 --> 00:09:39,000
no intervalo entre 0 e 25 para começar,

153
00:09:39,000 --> 00:09:43,000
e depois mudar tudo de volta no final.

154
00:09:43,000 --> 00:09:46,000
>> Outro erro comum que eu vi as pessoas se é que

155
00:09:46,000 --> 00:09:50,000
se você não realmente fazer isso escalonamento imediato

156
00:09:50,000 --> 00:09:53,000
e você adicionar a mensagem ea chave juntos e você adicioná-los, por exemplo,

157
00:09:53,000 --> 00:09:58,000
em uma variável char, o problema com que

158
00:09:58,000 --> 00:10:01,000
é, desde mensagem [i] é um número relativamente grande para começar-

159
00:10:01,000 --> 00:10:05,000
lembre-se que é pelo menos 65 se for uma maiúscula caracteres

160
00:10:05,000 --> 00:10:09,000
se você tiver uma chave grande, digamos, algo como 100,

161
00:10:09,000 --> 00:10:13,000
e você adicionar os dois juntos em um char assinado você está indo para obter um estouro.

162
00:10:13,000 --> 00:10:17,000
Você está indo para obter um valor que é maior do que 127,

163
00:10:17,000 --> 00:10:22,000
que é o maior valor que uma variável char.

164
00:10:22,000 --> 00:10:26,000
Mais uma vez, é por isso que você gostaria de fazer esse tipo de coisa para começar.

165
00:10:26,000 --> 00:10:29,000
Algumas pessoas tem em torno desse caso, fazendo uma coisa e se testar

166
00:10:29,000 --> 00:10:33,000
para ver se ele seria estouro antes de fazer isso,

167
00:10:33,000 --> 00:10:36,000
mas desta forma fica em torno disso.

168
00:10:36,000 --> 00:10:40,000
E então nesta solução é impresso a corda toda no final.

169
00:10:40,000 --> 00:10:45,000
Outras pessoas impresso um personagem de cada vez. Ambos são impressionantes.

170
00:10:45,000 --> 00:10:51,000
Neste ponto, vocês tem alguma dúvida, algum comentário sobre isso?

171
00:10:51,000 --> 00:10:56,000
Coisas que você gosta, coisas que você não gosta?

172
00:10:56,000 --> 00:10:58,000
>> Eu tinha uma pergunta.

173
00:10:58,000 --> 00:11:01,000
Talvez eu tenha perdido durante a sua explicação, mas como é que este programa

174
00:11:01,000 --> 00:11:07,000
pular os espaços para ligar a chave para o comprimento do texto?

175
00:11:07,000 --> 00:11:10,000
Este é apenas César cifra. >> Ah, desculpe, sim.

176
00:11:10,000 --> 00:11:13,000
Sim, vamos ver isso.

177
00:11:13,000 --> 00:11:16,000
Na cifra de César temos em torno de que, por causa

178
00:11:16,000 --> 00:11:18,000
só capotou caracteres.

179
00:11:18,000 --> 00:11:27,000
Nós só rodada se eles eram maiúsculas ou minúsculas.

180
00:11:27,000 --> 00:11:32,000
Vocês me sentindo muito bem sobre isso?

181
00:11:32,000 --> 00:11:34,000
Sinta-se livre para copiar esta casa, levá-la,

182
00:11:34,000 --> 00:11:37,000
compará-lo com o que vocês escreveram.

183
00:11:37,000 --> 00:11:42,000
Definitivamente, não hesite em enviar perguntas sobre ele também.

184
00:11:42,000 --> 00:11:46,000
E mais uma vez, perceber que o objetivo aqui com o seu problema define

185
00:11:46,000 --> 00:11:50,000
não é obter vocês para escrever código perfeito para seus conjuntos de problemas.

186
00:11:50,000 --> 00:11:57,000
É uma experiência de aprendizagem. Sim.

187
00:11:57,000 --> 00:12:01,000
>> Voltar para o fazer enquanto loop, se for igual nulo,

188
00:12:01,000 --> 00:12:06,000
assim nula apenas significa nada, eles simplesmente pressionar enter?

189
00:12:06,000 --> 00:12:12,000
Nulo é um valor ponteiro especial,

190
00:12:12,000 --> 00:12:17,000
e usamos nulo quando queremos dizer

191
00:12:17,000 --> 00:12:23,000
temos uma variável ponteiro que está apontando para nada.

192
00:12:23,000 --> 00:12:28,000
E assim normalmente isso significa que esta variável, esta variável mensagem

193
00:12:28,000 --> 00:12:35,000
está vazio, e aqui, porque nós estamos usando o CS50 tipo string especial,

194
00:12:35,000 --> 00:12:37,000
qual é o tipo de cadeia CS50?

195
00:12:37,000 --> 00:12:42,000
Você já viu o que é quando David tirou o capuz na aula?

196
00:12:42,000 --> 00:12:44,000
É um funky-que é um ponteiro, certo?

197
00:12:44,000 --> 00:12:48,000
Ok, sim. >> É um char *.

198
00:12:48,000 --> 00:12:52,000
E assim realmente poderíamos substituir este

199
00:12:52,000 --> 00:12:56,000
aqui com a mensagem de char *,

200
00:12:56,000 --> 00:13:04,000
e assim a função GetString, se não conseguir obter uma string do usuário,

201
00:13:04,000 --> 00:13:08,000
não se pode analisar uma seqüência, e um caso em que não se pode analisar uma seqüência

202
00:13:08,000 --> 00:13:11,000
é se o usuário digita o caractere de fim de arquivo, o controle D,

203
00:13:11,000 --> 00:13:17,000
o que não é algo que você costuma fazer, mas se isso acontecer

204
00:13:17,000 --> 00:13:20,000
em seguida, a função irá retornar esse valor nulo como uma maneira de dizer

205
00:13:20,000 --> 00:13:23,000
"Ei, eu não tive uma seqüência."

206
00:13:23,000 --> 00:13:27,000
O que aconteceria se nós não colocamos mensagem = null,

207
00:13:27,000 --> 00:13:30,000
que é algo que não tem feito ainda?

208
00:13:30,000 --> 00:13:32,000
Por que isso seria um problema aqui?

209
00:13:32,000 --> 00:13:38,000
Porque eu sei que nós conversamos um pouco na palestra sobre vazamentos de memória.

210
00:13:38,000 --> 00:13:42,000
Sim, vamos fazer isso, e vamos ver o que acontece.

211
00:13:42,000 --> 00:13:44,000
>> Questão Basílio foi o que acontece se nós realmente não têm

212
00:13:44,000 --> 00:13:48,000
esta mensagem de teste = null?

213
00:13:48,000 --> 00:13:51,000
Vamos deslocar-se para o topo.

214
00:13:51,000 --> 00:13:53,000
Vocês podem comentar isto.

215
00:13:53,000 --> 00:13:55,000
Na verdade, eu vou salvá-lo em uma revisão.

216
00:13:55,000 --> 00:13:58,000
Este será revisão 3.

217
00:13:58,000 --> 00:14:02,000
O que você tem que fazer para executar este programa é que você terá que clicar nesse ícone de engrenagem até aqui,

218
00:14:02,000 --> 00:14:04,000
e você vai ter que adicionar um argumento para ele.

219
00:14:04,000 --> 00:14:10,000
Você tem que dar o argumento-chave, já que queremos passar em um argumento de linha de comando.

220
00:14:10,000 --> 00:14:13,000
Aqui eu vou dar-lhe o número 3. Eu gosto 3.

221
00:14:13,000 --> 00:14:19,000
Agora o zoom para fora, a execução do programa.

222
00:14:19,000 --> 00:14:24,000
Está funcionando, compilação, construindo.

223
00:14:24,000 --> 00:14:27,000
Aqui vamos nós. Ele está à espera de ser solicitado.

224
00:14:27,000 --> 00:14:33,000
Se eu digitar algo como Olá, onde é que isso vai?

225
00:14:33,000 --> 00:14:38,000
Oh, meu programa levou muito tempo para ser executado. Eu estava jawing por muito tempo.

226
00:14:38,000 --> 00:14:40,000
Aqui vai.

227
00:14:40,000 --> 00:14:43,000
Agora eu digitar Olá.

228
00:14:43,000 --> 00:14:46,000
Vemos que ele criptografa de forma adequada.

229
00:14:46,000 --> 00:14:52,000
Agora o que acontece se não fizermos GetString pronta para retornar nulo?

230
00:14:52,000 --> 00:14:57,000
Lembre-se, eu disse que nós fizemos isso pressionando o controle D ao mesmo tempo.

231
00:14:57,000 --> 00:14:59,000
Eu vou rolar por aqui. Vamos executá-lo novamente.

232
00:14:59,000 --> 00:15:01,000
Edifício. Não vai.

233
00:15:01,000 --> 00:15:04,000
Agora, quando eu bati o controle D

234
00:15:04,000 --> 00:15:12,000
Eu tenho essa linha que diz opt/sandbox50/bin/run.sh, falha de segmentação.

235
00:15:12,000 --> 00:15:15,000
Vocês já viram isso antes?

236
00:15:15,000 --> 00:15:17,000
>> [Estudante] Por que não há >>-Desculpe?

237
00:15:17,000 --> 00:15:20,000
[Estudante] Por que não há despejo de núcleo neste caso?

238
00:15:20,000 --> 00:15:26,000
O despejo de núcleo é, a questão é por que não há despejo de núcleo aqui?

239
00:15:26,000 --> 00:15:29,000
A questão é que não pode ser, mas o despejo de núcleo é um arquivo

240
00:15:29,000 --> 00:15:31,000
que fica armazenado no disco rígido.

241
00:15:31,000 --> 00:15:34,000
Neste caso temos desativado core dumps

242
00:15:34,000 --> 00:15:37,000
no servidor de execução para que nós não temos pessoas seg falha

243
00:15:37,000 --> 00:15:40,000
e construção de toneladas de core dumps.

244
00:15:40,000 --> 00:15:46,000
Mas você pode obter um.

245
00:15:46,000 --> 00:15:48,000
Despejos principais são o tipo de coisa que muitas vezes você pode desativar,

246
00:15:48,000 --> 00:15:52,000
e às vezes você faz.

247
00:15:52,000 --> 00:15:55,000
A falha de segmentação, para responder sua pergunta, Basílio,

248
00:15:55,000 --> 00:16:00,000
está dizendo que nós tentamos acessar um ponteiro

249
00:16:00,000 --> 00:16:05,000
que não foi definido para apontar para qualquer coisa.

250
00:16:05,000 --> 00:16:09,000
Lembre-se de Binky no vídeo quando tenta Binky

251
00:16:09,000 --> 00:16:12,000
vá acessar um ponteiro que não está apontando para alguma coisa?

252
00:16:12,000 --> 00:16:16,000
Neste caso, eu acho que, tecnicamente, o ponteiro está apontando para alguma coisa.

253
00:16:16,000 --> 00:16:20,000
Ele está apontando para nulo, o que é tecnicamente 0,

254
00:16:20,000 --> 00:16:25,000
mas que é definido como sendo um segmento em que não está acessível

255
00:16:25,000 --> 00:16:28,000
por seu programa, de modo a obter uma falha de segmentação

256
00:16:28,000 --> 00:16:31,000
porque você não está acessando a memória que está em um segmento válido

257
00:16:31,000 --> 00:16:38,000
como o segmento de pilha ou o segmento de pilha ou o segmento de dados.

258
00:16:38,000 --> 00:16:40,000
Cool.

259
00:16:40,000 --> 00:16:48,000
Mais alguma pergunta sobre César?

260
00:16:48,000 --> 00:16:51,000
>> Vamos seguir em frente. Vamos olhar para Revisão 2 muito rapidamente.

261
00:16:51,000 --> 00:17:00,000
Isso é Vigenère.

262
00:17:00,000 --> 00:17:04,000
Aqui em Vigenère

263
00:17:04,000 --> 00:17:06,000
vamos caminhar por este um muito rapidamente, porque, de novo,

264
00:17:06,000 --> 00:17:10,000
Vigenère e César são bastante semelhantes.

265
00:17:10,000 --> 00:17:12,000
Comentário de cabeçalho é antes,

266
00:17:12,000 --> 00:17:17,000
# Define é antes para evitar o uso desses números mágicos.

267
00:17:17,000 --> 00:17:21,000
O bom é dizer que queria se mudar para

268
00:17:21,000 --> 00:17:23,000
um alfabeto diferente, ou algo assim.

269
00:17:23,000 --> 00:17:26,000
Ao invés de ter que ir alterar manualmente todos os 26 no código

270
00:17:26,000 --> 00:17:30,000
podemos mudar isso para 27 ou deixa-lo cair

271
00:17:30,000 --> 00:17:34,000
se estivéssemos usando alfabetos diferentes, línguas diferentes.

272
00:17:34,000 --> 00:17:38,000
Mais uma vez, temos essa verificação da contagem de argumento,

273
00:17:38,000 --> 00:17:42,000
e realmente você quase pode tomar isso como um modelo.

274
00:17:42,000 --> 00:17:46,000
Praticamente todos os programas que você escreve deve ter-

275
00:17:46,000 --> 00:17:50,000
se leva de linha de comando argumentos, alguns seqüência de linhas

276
00:17:50,000 --> 00:17:55,000
que lê como este no início.

277
00:17:55,000 --> 00:17:59,000
Esse é um dos testes de sanidade primeira que você quer fazer.

278
00:17:59,000 --> 00:18:03,000
>> Aqui o que nós fizemos foi a certeza de que

279
00:18:03,000 --> 00:18:06,000
a palavra-chave era válida, e que foi a segunda verificação que nós fizemos.

280
00:18:06,000 --> 00:18:11,000
Observe mais uma vez que estamos separados isso argc e 2.

281
00:18:11,000 --> 00:18:14,000
Note-se que, neste caso, uma coisa que tinha a fazer era, em vez

282
00:18:14,000 --> 00:18:18,000
de usar um ao i que queríamos para validar toda a cadeia,

283
00:18:18,000 --> 00:18:21,000
e, a fim de fazer o que você realmente tem que ir caractere por caractere

284
00:18:21,000 --> 00:18:23,000
sobre a corda.

285
00:18:23,000 --> 00:18:29,000
Não há nenhuma boa maneira de chamar algo sobre ele

286
00:18:29,000 --> 00:18:31,000
porque, mesmo, por exemplo, um para i retornará 0

287
00:18:31,000 --> 00:18:37,000
se não pode analisar um número inteiro, de modo que nem sequer funciona.

288
00:18:37,000 --> 00:18:42,000
Mais uma vez, bela mensagem dizendo ao usuário exatamente o que aconteceu.

289
00:18:42,000 --> 00:18:45,000
Então, aqui, de novo, nós também lidar com o caso em que

290
00:18:45,000 --> 00:18:50,000
o usuário digita em um personagem D controle aleatória.

291
00:18:50,000 --> 00:18:54,000
>> E então, Charlotte tinha uma pergunta anterior sobre como conseguimos pular espaços

292
00:18:54,000 --> 00:18:57,000
em nossa string aqui.

293
00:18:57,000 --> 00:19:00,000
Esta era uma espécie de semelhante ao que fizemos com o programa do Myspace

294
00:19:00,000 --> 00:19:04,000
que fizemos na seção, ea forma como isto funcionou

295
00:19:04,000 --> 00:19:08,000
é que rastreou o número de cartas que tinha visto.

296
00:19:08,000 --> 00:19:13,000
Enquanto caminhávamos sobre a seqüência de mensagem, como andou caractere por caractere,

297
00:19:13,000 --> 00:19:16,000
que acompanhou o índice como parte do nosso loop for, e então nós também acompanhou

298
00:19:16,000 --> 00:19:21,000
o número de letras, por isso não caracteres especiais, não-dígitos, não-branco espaço

299
00:19:21,000 --> 00:19:27,000
que tinha visto na variável separada.

300
00:19:27,000 --> 00:19:33,000
E, em seguida, esta solução modifica a chave

301
00:19:33,000 --> 00:19:41,000
para obter um inteiro real da chave, e ele faz isso em tempo real,

302
00:19:41,000 --> 00:19:47,000
direita antes que depois vai para criptografar a mensagem real caráter.

303
00:19:47,000 --> 00:19:50,000
Existem algumas soluções que eram perfeitamente muito grande

304
00:19:50,000 --> 00:19:58,000
que modificar a chave até ao testar a validade da chave.

305
00:19:58,000 --> 00:20:01,000
Além de garantir que o caráter ea palavra-chave

306
00:20:01,000 --> 00:20:05,000
foi um caractere alfabético também que virou em um número inteiro

307
00:20:05,000 --> 00:20:13,000
na faixa de 0 a 25 para, em seguida, pular ter que fazer isso mais tarde neste loop.

308
00:20:13,000 --> 00:20:18,000
Mais uma vez, você vê aqui é realmente exatamente o mesmo código

309
00:20:18,000 --> 00:20:22,000
que usamos no Caesar neste momento.

310
00:20:22,000 --> 00:20:25,000
Você está fazendo exatamente a mesma coisa, então o verdadeiro truque é descobrir

311
00:20:25,000 --> 00:20:30,000
como transformar a palavra-chave em um número inteiro.

312
00:20:30,000 --> 00:20:35,000
>> Uma coisa que nós fizemos aqui, que é um pouco densa

313
00:20:35,000 --> 00:20:39,000
é que repetiu essa frase, eu acho que você poderia chamá-lo,

314
00:20:39,000 --> 00:20:45,000
3 vezes separadas nas linhas 58, 59 e 61.

315
00:20:45,000 --> 00:20:52,000
Alguém pode explicar o que exatamente esta frase faz?

316
00:20:52,000 --> 00:20:55,000
Ele está acessando um personagem, como você disse.

317
00:20:55,000 --> 00:20:59,000
Sim, é [inaudível] um personagem na palavra-chave,

318
00:20:59,000 --> 00:21:04,000
e por isso é visto número de letras, porque você só está se movendo ao longo

319
00:21:04,000 --> 00:21:06,000
a palavra-chave, uma vez que você tenha visto a carta,

320
00:21:06,000 --> 00:21:10,000
de modo que vai efetivamente pular espaços e coisas assim.

321
00:21:10,000 --> 00:21:12,000
Sim, exatamente.

322
00:21:12,000 --> 00:21:16,000
E então, uma vez que você viu o branco mod palavra-chave que só assim você se mover de volta.

323
00:21:16,000 --> 00:21:18,000
Exatamente. Essa é uma explicação perfeita.

324
00:21:18,000 --> 00:21:23,000
O que Kevin disse é que queremos índice para a palavra-chave.

325
00:21:23,000 --> 00:21:28,000
Queremos chegar o caráter num_letters_seen, se quiser,

326
00:21:28,000 --> 00:21:32,000
mas se num_letters_seen excede o comprimento da palavra-chave,

327
00:21:32,000 --> 00:21:37,000
a nossa forma de voltar para a faixa apropriada é que usar o operador mod

328
00:21:37,000 --> 00:21:40,000
efetivamente envolvente.

329
00:21:40,000 --> 00:21:43,000
Por exemplo, como a curto, a nossa palavra-chave é bacon,

330
00:21:43,000 --> 00:21:46,000
e é 5 letras.

331
00:21:46,000 --> 00:21:50,000
Mas temos visto seis letras do nosso texto simples neste momento

332
00:21:50,000 --> 00:21:52,000
e criptografada 6.

333
00:21:52,000 --> 00:21:57,000
Vamos acabar acessando o num_letters_seen,

334
00:21:57,000 --> 00:22:00,000
que é de 6, mod o comprimento da palavra-chave, 5,

335
00:22:00,000 --> 00:22:04,000
e assim vamos conseguir um, e assim que nós vamos fazer é que vamos

336
00:22:04,000 --> 00:22:14,000
acesso ao interior do nosso primeiro personagem palavra-chave nesse ponto.

337
00:22:14,000 --> 00:22:21,000
>> Tudo bem, todas as perguntas sobre Vigenère

338
00:22:21,000 --> 00:22:26,000
antes de seguir em frente?

339
00:22:26,000 --> 00:22:31,000
Vocês me sentindo muito bem sobre isso?

340
00:22:31,000 --> 00:22:35,000
Legal, ótimo.

341
00:22:35,000 --> 00:22:38,000
Eu quero ter certeza de que vocês estão tendo a chance de ver o código

342
00:22:38,000 --> 00:22:48,000
que acha que está bom e tem a chance de aprender com ele.

343
00:22:48,000 --> 00:22:53,000
Esta vai ser a última vez que vou estar usando os espaços para o momento,

344
00:22:53,000 --> 00:22:59,000
e nós vamos fazer a transição agora, e eu estou indo para ir para cs50.net/lectures

345
00:22:59,000 --> 00:23:06,000
para que possamos fazer um pouco de análise quiz.

346
00:23:06,000 --> 00:23:10,000
A melhor maneira que eu acho que para começar a fazer teste revisão

347
00:23:10,000 --> 00:23:15,000
é vir para esta página Palestras, cs50.net/lectures,

348
00:23:15,000 --> 00:23:20,000
e debaixo de cada uma das rubricas semanas, então se eu olhar aqui na Semana 0,

349
00:23:20,000 --> 00:23:27,000
Vejo que temos uma lista de tópicos que cobrimos na Semana 0.

350
00:23:27,000 --> 00:23:31,000
>> Se qualquer um desses tópicos parece estranho para você

351
00:23:31,000 --> 00:23:34,000
você definitivamente vai querer voltar e vasculhar as anotações de aula e, possivelmente,

352
00:23:34,000 --> 00:23:39,000
mesmo folhear as palestras, vê-los novamente se quiser

353
00:23:39,000 --> 00:23:44,000
para ter uma idéia de o que está acontecendo com cada um desses temas.

354
00:23:44,000 --> 00:23:49,000
Direi ainda este ano, um dos recursos legais que temos

355
00:23:49,000 --> 00:23:55,000
é destes shorts que criamos, e se você olhar na Semana 0,

356
00:23:55,000 --> 00:24:00,000
não temos todos os temas, mas temos um bom número deles,

357
00:24:00,000 --> 00:24:03,000
algumas das mais complicadas, então assistindo esses shorts de novo

358
00:24:03,000 --> 00:24:08,000
é uma boa maneira para chegar até a velocidade.

359
00:24:08,000 --> 00:24:15,000
Em particular, eu vou colocar em uma ficha para o 3 na parte inferior, uma vez que eu fiz aqueles.

360
00:24:15,000 --> 00:24:20,000
Mas se você está lutando com o binário, bits, hex, esse tipo de coisa,

361
00:24:20,000 --> 00:24:22,000
binário é um ótimo lugar para começar.

362
00:24:22,000 --> 00:24:25,000
ASCII é outro que é bom para ver também.

363
00:24:25,000 --> 00:24:31,000
Você pode até mesmo ver-me na velocidade 1.5x se eu estou indo muito devagar para você.

364
00:24:31,000 --> 00:24:35,000
Desde a sua revisão, sinta-se livre para fazer isso.

365
00:24:35,000 --> 00:24:40,000
>> Só para começar muito rapidamente, nós vamos passar por um casal destes problemas do quiz

366
00:24:40,000 --> 00:24:44,000
apenas para rapidamente churn através destes.

367
00:24:44,000 --> 00:24:50,000
Por exemplo, vamos olhar para 16 problema que eu tenho aqui em cima da placa.

368
00:24:50,000 --> 00:24:54,000
Temos a seguinte cálculo em binário,

369
00:24:54,000 --> 00:24:56,000
e queremos mostrar qualquer trabalho.

370
00:24:56,000 --> 00:24:59,000
Ok, eu vou dar a este um tiro.

371
00:24:59,000 --> 00:25:01,000
Vocês devem seguir junto com o papel,

372
00:25:01,000 --> 00:25:04,000
e nós vamos fazer isso muito rapidamente.

373
00:25:04,000 --> 00:25:06,000
Queremos executar o seguinte cálculo em binário.

374
00:25:06,000 --> 00:25:16,000
Eu tenho 00110010.

375
00:25:16,000 --> 00:25:27,000
E eu estou indo para adicionar a ele 00110010.

376
00:25:27,000 --> 00:25:30,000
Para a matemática gênios acompanhando em casa,

377
00:25:30,000 --> 00:25:35,000
esta é efectivamente multiplicar por 2.

378
00:25:35,000 --> 00:25:37,000
Vamos começar.

379
00:25:37,000 --> 00:25:39,000
Nós vamos seguir o algoritmo disso mesmo que nós fazemos

380
00:25:39,000 --> 00:25:43,000
quando adicionamos números decimais juntos.

381
00:25:43,000 --> 00:25:46,000
Realmente a única diferença aqui é que nós loop de volta em torno de

382
00:25:46,000 --> 00:25:51,000
uma vez que temos 1 + 1 em vez de uma vez ficamos com a 10.

383
00:25:51,000 --> 00:25:53,000
>> Se começarmos a partir da direita, muito rapidamente, o que é o primeiro dígito?

384
00:25:53,000 --> 00:25:55,000
[Estudante] 0. >> [Nate H.] 0.

385
00:25:55,000 --> 00:25:58,000
Grande, o segundo dígito?

386
00:25:58,000 --> 00:26:00,000
[Estudante] 1.

387
00:26:00,000 --> 00:26:02,000
[Nate H.] É um 1? 1 + 1 é?

388
00:26:02,000 --> 00:26:04,000
[Estudante] 10.

389
00:26:04,000 --> 00:26:08,000
[Nate H.] Exatamente, então o que é o dígito que eu escrevo logo abaixo as 2 adicionados juntos?

390
00:26:08,000 --> 00:26:11,000
[Estudante] 1, 0 ou 0 e, em seguida, levar o 1.

391
00:26:11,000 --> 00:26:15,000
[Nate H.] 0 e levar a 1, exatamente.

392
00:26:15,000 --> 00:26:18,000
Em seguida um up, Basil, você está acima.

393
00:26:18,000 --> 00:26:20,000
Qual é o terceiro? >> [Basil] 1.

394
00:26:20,000 --> 00:26:23,000
[Nate H.] 1, perfeito. Kevin?

395
00:26:23,000 --> 00:26:27,000
[Kevin] 0. >> [Nate H.] 0, Charlotte?

396
00:26:27,000 --> 00:26:30,000
[Charlotte] 0. >> [Nate H.] Sim, eo que eu faço?

397
00:26:30,000 --> 00:26:32,000
[Aluno] O 1.

398
00:26:32,000 --> 00:26:34,000
[Nate H.] E o que eu faço? E então eu carrego a 1.

399
00:26:34,000 --> 00:26:36,000
Perfeito, SAHB? >> [SAHB] Agora você tem um.

400
00:26:36,000 --> 00:26:40,000
[Nate H.] E eu faço alguma coisa aqui?

401
00:26:40,000 --> 00:26:43,000
[SAHB] Então, para a próxima que você tem um porque você transitadas 1.

402
00:26:43,000 --> 00:26:49,000
[Nate H.] Ótimo, então aqui nós podemos terminá-lo.

403
00:26:49,000 --> 00:26:51,000
Cool.

404
00:26:51,000 --> 00:26:54,000
[Estudante] O 0 + 0 = 0?

405
00:26:54,000 --> 00:26:56,000
0 + 0 = 0.

406
00:26:56,000 --> 00:27:01,000
1 + 1, como você disse, é de 10, ou 1, 0, sim.

407
00:27:01,000 --> 00:27:07,000
10 é um equívoco, porque para mim 10 significa o número 10,

408
00:27:07,000 --> 00:27:12,000
e é a peculiaridade de como estamos representando-o quando estamos escrevendo.

409
00:27:12,000 --> 00:27:20,000
Nós representar o número 2, por 1, 0, e o número 10 é um pouco diferente.

410
00:27:20,000 --> 00:27:23,000
>> O que é uma espécie de bom sobre o binário é que não há realmente que muitos

411
00:27:23,000 --> 00:27:25,000
casos, você precisa aprender.

412
00:27:25,000 --> 00:27:30,000
Há 0 + 0 = 0, 0 + 1 = 1,

413
00:27:30,000 --> 00:27:34,000
1 + 1 é 0, e, em seguida, carregar um 1,

414
00:27:34,000 --> 00:27:37,000
e então você pode ver aqui na terceira coluna da direita

415
00:27:37,000 --> 00:27:40,000
tivemos este 1, 1 e 1.

416
00:27:40,000 --> 00:27:43,000
E 1 + 1 + 1 é um 1,

417
00:27:43,000 --> 00:27:45,000
e você carrega outro 1.

418
00:27:45,000 --> 00:27:48,000
Quando você está fazendo a adição binária, muito simples.

419
00:27:48,000 --> 00:27:51,000
Eu faria um casal mais desses para verificar a sanidade vós

420
00:27:51,000 --> 00:27:54,000
antes de ir porque este é

421
00:27:54,000 --> 00:28:00,000
provavelmente algo que veremos no questionário.

422
00:28:00,000 --> 00:28:03,000
Agora vamos fazer este próximo também.

423
00:28:03,000 --> 00:28:06,000
Vamos fazer 17 problema.

424
00:28:06,000 --> 00:28:12,000
Nós estamos indo para converter o seguinte número binário para decimal.

425
00:28:12,000 --> 00:28:28,000
Eu tenho 10100111001.

426
00:28:28,000 --> 00:28:33,000
Lembre-se no vídeo binário que eu fiz

427
00:28:33,000 --> 00:28:36,000
Eu andei por um par de exemplos, e mostrei como

428
00:28:36,000 --> 00:28:41,000
tudo funciona quando você está fazendo isso em decimal.

429
00:28:41,000 --> 00:28:45,000
Quando você está trabalhando em representação decimal Acho que estamos

430
00:28:45,000 --> 00:28:48,000
neste momento em nossas vidas tão fluente em que ela

431
00:28:48,000 --> 00:28:53,000
é muito fácil para encobrir a mecânica de como ele realmente funciona.

432
00:28:53,000 --> 00:28:59,000
>> Mas para fazer uma rápida recapitulação, se eu tiver o número 137

433
00:28:59,000 --> 00:29:06,000
isso realmente significa e de novo, isto é, em representação decimal-

434
00:29:06,000 --> 00:29:19,000
o número 137 em decimal significa que tenho 1 x 100 + 3 x 10 + 7 x 1.

435
00:29:19,000 --> 00:29:22,000
Isso tudo é permanecer na tela.

436
00:29:22,000 --> 00:29:29,000
E então, se você olhar para esses números aqui,

437
00:29:29,000 --> 00:29:34,000
100, 10 e 1, você vê que eles são realmente todas as potências de 10.

438
00:29:34,000 --> 00:29:43,000
Eu tenho 10 ², 10 ¹, e 10 para o zero.

439
00:29:43,000 --> 00:29:48,000
Nós temos um tipo semelhante de coisa em binário,

440
00:29:48,000 --> 00:29:55,000
exceto que a nossa base, como o chamamos, é 2 em vez de 10.

441
00:29:55,000 --> 00:29:58,000
Esses 10s que eu escrevi aqui no fundo,

442
00:29:58,000 --> 00:30:02,000
este ² 10, 10 ¹, 10 ao zero, 10 é a nossa base,

443
00:30:02,000 --> 00:30:08,000
e o expoente, 0, 1, ou 2,

444
00:30:08,000 --> 00:30:14,000
está implícita a posição do dígito do número que escrever.

445
00:30:14,000 --> 00:30:21,000
1, se olharmos para ele, este 1 está na posição 2.

446
00:30:21,000 --> 00:30:27,000
A 3 está na posição 1, e o 7 está na posição 0.

447
00:30:27,000 --> 00:30:35,000
É assim que tivermos os vários expoentes abaixo de nossas bases.

448
00:30:35,000 --> 00:30:40,000
>> Após tudo isso we'll-na verdade, você sabe o que?

449
00:30:40,000 --> 00:30:43,000
Nós vamos fazer, onde fiz o meu botão desfazer ir?

450
00:30:43,000 --> 00:30:45,000
Não vai.

451
00:30:45,000 --> 00:30:47,000
Eu amo este desfazer coisa.

452
00:30:47,000 --> 00:30:51,000
Após isso, eu acho que para mim pelo menos,

453
00:30:51,000 --> 00:30:54,000
a maneira mais fácil para começar a converter um número binário

454
00:30:54,000 --> 00:30:57,000
ou um número hexadecimal onde a base é 16

455
00:30:57,000 --> 00:31:02,000
e não 10 ou 2 é ir em frente e escrever

456
00:31:02,000 --> 00:31:09,000
as bases e expoentes para o conjunto de números em meu número binário, na parte superior.

457
00:31:09,000 --> 00:31:14,000
Se começarmos a partir da esquerda para a direita de novo,

458
00:31:14,000 --> 00:31:17,000
que é uma espécie de contra-intuitivo,

459
00:31:17,000 --> 00:31:23,000
Eu vou mudar de volta para o preto aqui, temos a 2 para a posição 0,

460
00:31:23,000 --> 00:31:27,000
e então temos 2 ¹, 2 ²,

461
00:31:27,000 --> 00:31:33,000
e, em seguida, 2 para a 3, 2 a 4, 2 a 5, 6,

462
00:31:33,000 --> 00:31:39,000
7, 8, 9, e 10.

463
00:31:39,000 --> 00:31:41,000
Estes números que eu escrevi para fora são todos os expoentes.

464
00:31:41,000 --> 00:31:48,000
Eu só escrevi as bases aqui no 3 primeiro apenas para o espaço.

465
00:31:48,000 --> 00:31:50,000
>> Neste momento eu estou indo para ir em frente e eu estou indo realmente para apagar

466
00:31:50,000 --> 00:31:53,000
as coisas que fizemos em decimal, se está tudo bem.

467
00:31:53,000 --> 00:31:57,000
Vocês todos tem isso.

468
00:31:57,000 --> 00:32:05,000
Aqueles de vocês assistir online eu tenho certeza que será capaz de voltar-me se você quiser.

469
00:32:05,000 --> 00:32:07,000
De voltar para a caneta.

470
00:32:07,000 --> 00:32:12,000
Agora, o que podemos fazer, se vocês não são totalmente até a velocidade em seus poderes de 2,

471
00:32:12,000 --> 00:32:15,000
que é totalmente legal.

472
00:32:15,000 --> 00:32:18,000
Acontece. Eu entendo.

473
00:32:18,000 --> 00:32:23,000
Uma vez eu tive uma entrevista de emprego onde me foi dito que eu deveria saber todas as potências de 2

474
00:32:23,000 --> 00:32:26,000
-se através de 2 a 30.

475
00:32:26,000 --> 00:32:29,000
Não era um trabalho que eu tenho.

476
00:32:29,000 --> 00:32:32,000
De qualquer forma, vocês podem ir em frente e fazer as contas aqui,

477
00:32:32,000 --> 00:32:35,000
mas com o binário que não faz muito sentido,

478
00:32:35,000 --> 00:32:38,000
e nem faz sentido com decimal ou hexadecimal ou,

479
00:32:38,000 --> 00:32:43,000
a fazer as contas para onde você tem zeros.

480
00:32:43,000 --> 00:32:49,000
Você pode ver que eu tenho 0 aqui, um 0 aqui, 0 aqui, 0 aqui, 0 aqui, 0 aqui.

481
00:32:49,000 --> 00:32:52,000
Por que não faz sentido fazer a matemática real

482
00:32:52,000 --> 00:32:56,000
para calcular a potência adequada, de 2 para essa posição?

483
00:32:56,000 --> 00:32:59,000
Precisamente, como Charlotte disse, será 0.

484
00:32:59,000 --> 00:33:05,000
Poderia muito bem salvar a época se calcular potências de 2 não é o seu forte.

485
00:33:05,000 --> 00:33:10,000
Neste caso, só precisamos calculá-lo para 2 a 0, o que é-?

486
00:33:10,000 --> 00:33:12,000
[Estudante] 1.

487
00:33:12,000 --> 00:33:14,000
[Nate H.] 1, 2 e 3, que é a-?

488
00:33:14,000 --> 00:33:16,000
[Estudante] 8. >> [Nate H.] 8.

489
00:33:16,000 --> 00:33:18,000
2 à 4?

490
00:33:18,000 --> 00:33:21,000
[Estudante] 2. Sinto muito, 1.

491
00:33:21,000 --> 00:33:26,000
[Nate H.] 2 a 4 é 16, exatamente.

492
00:33:26,000 --> 00:33:28,000
2 à 5, Kevin? >> 32.

493
00:33:28,000 --> 00:33:32,000
[Nate H.] 32, 2 a 8?

494
00:33:32,000 --> 00:33:38,000
[Estudante] 32 x 8, 256.

495
00:33:38,000 --> 00:33:41,000
[Nate H.] Perfeito.

496
00:33:41,000 --> 00:33:43,000
E 2 para o 10?

497
00:33:43,000 --> 00:33:45,000
[Estudante] 1024.

498
00:33:45,000 --> 00:33:49,000
[Nate H.] Sim, 1024.

499
00:33:49,000 --> 00:33:57,000
>> Uma vez que temos esses números podemos somar todos eles.

500
00:33:57,000 --> 00:34:01,000
E é aqui que é realmente importante para fazer um par de coisas.

501
00:34:01,000 --> 00:34:07,000
Uma delas é ir devagar e verificar o seu trabalho.

502
00:34:07,000 --> 00:34:10,000
Você pode dizer que há um 1 no final deste número,

503
00:34:10,000 --> 00:34:15,000
então eu deveria ficar definitivamente um número ímpar como o meu resultado,

504
00:34:15,000 --> 00:34:18,000
porque todos os outros vão ser ainda números

505
00:34:18,000 --> 00:34:21,000
dado que é um número binário.

506
00:34:21,000 --> 00:34:24,000
A outra coisa a fazer é se você chegar a este ponto no teste

507
00:34:24,000 --> 00:34:27,000
e você escreveu chegar até este ponto

508
00:34:27,000 --> 00:34:30,000
e você está correndo contra o tempo

509
00:34:30,000 --> 00:34:33,000
olhar para o número de pontos que o problema vale a pena.

510
00:34:33,000 --> 00:34:40,000
Este problema, como você pode ver, se eu virar de volta para o meu laptop muito rapidamente-

511
00:34:40,000 --> 00:34:44,000
este problema vale 2 pontos, de modo que este não é o tipo de adição

512
00:34:44,000 --> 00:34:47,000
você deve estar passando, se você realmente está pressionado pelo tempo.

513
00:34:47,000 --> 00:34:52,000
Mas vamos voltar para o iPad, e nós vamos passar por isso muito rapidamente.

514
00:34:52,000 --> 00:34:54,000
>> Eu gosto de fazer os pequenos números primeira

515
00:34:54,000 --> 00:34:56,000
porque eu acho que mais fácil.

516
00:34:56,000 --> 00:35:00,000
Eu gosto de 32 e 8, porque eles vão juntos muito facilmente, e nós temos 50.

517
00:35:00,000 --> 00:35:03,000
16 e 1 recebe 17.

518
00:35:03,000 --> 00:35:05,000
Não temos 57,

519
00:35:05,000 --> 00:35:14,000
e depois podemos fazer o resto deste, para que possamos fazer 57, 156.

520
00:35:14,000 --> 00:35:16,000
Vamos.

521
00:35:16,000 --> 00:35:19,000
Homem, bem, vamos ver.

522
00:35:19,000 --> 00:35:27,000
Tivemos 57, 256 e 1024.

523
00:35:27,000 --> 00:35:31,000
Neste ponto, eu prefiro passar.

524
00:35:31,000 --> 00:35:35,000
Eu não tenho idéia. Eu claramente precisa de ler sobre isso.

525
00:35:35,000 --> 00:35:40,000
7, 6, e 4, obtém 17.

526
00:35:40,000 --> 00:35:42,000
1, 5, 5, 2, 13.

527
00:35:42,000 --> 00:35:45,000
Então, temos três, e então nós começamos 1.

528
00:35:45,000 --> 00:35:52,000
1337.

529
00:35:52,000 --> 00:35:55,000
Ovo de Páscoa, alguém?

530
00:35:55,000 --> 00:35:59,000
Qualquer pessoa reconhecer esse número?

531
00:35:59,000 --> 00:36:02,000
Chris reconhece o número. O que significa, Chris?

532
00:36:02,000 --> 00:36:04,000
[Chris] Leet.

533
00:36:04,000 --> 00:36:11,000
Leet, por isso, se você olhar para isso, parece que leet.

534
00:36:11,000 --> 00:36:15,000
Material hacker. Cuidado com esse tipo de coisa no meio termo, ou o teste, melhor dizendo.

535
00:36:15,000 --> 00:36:19,000
Se você ver esse tipo de coisa e você está se perguntando "Huh",

536
00:36:19,000 --> 00:36:22,000
que pode realmente significar alguma coisa.

537
00:36:22,000 --> 00:36:24,000
Eu não sei. David gosta de colocá-lo dentro

538
00:36:24,000 --> 00:36:26,000
É uma boa maneira de sanidade verificar.

539
00:36:26,000 --> 00:36:30,000
Como bem, eu posso ver o que está acontecendo.

540
00:36:30,000 --> 00:36:34,000
>> Isso é uma coisa Semana 0/Week.

541
00:36:34,000 --> 00:36:39,000
Se voltar para o nosso laptop agora,

542
00:36:39,000 --> 00:36:46,000
diminuir o zoom, e um par de outras coisas.

543
00:36:46,000 --> 00:36:50,000
Há ASCII, que temos vindo a fazer um monte de com os conjuntos de problemas.

544
00:36:50,000 --> 00:36:55,000
Esta noção de capital A. O que é isso mesmo?

545
00:36:55,000 --> 00:36:57,000
Sabendo que é o inteiro decimal.

546
00:36:57,000 --> 00:37:00,000
65 é o que está mapeado para na tabela ASCII,

547
00:37:00,000 --> 00:37:03,000
e que é, portanto, como o computador, escreve ele,

548
00:37:03,000 --> 00:37:06,000
e é assim que temos vindo a fugir com escrevendo

549
00:37:06,000 --> 00:37:09,000
A personagem da capital e do caráter letras minúsculas de a

550
00:37:09,000 --> 00:37:14,000
em algumas dessas soluções e conjuntos de problemas que você tem feito.

551
00:37:14,000 --> 00:37:16,000
A par de outras coisas.

552
00:37:16,000 --> 00:37:25,000
Temos declarações, expressões booleanas, condições, loops, variáveis ​​e segmentos.

553
00:37:25,000 --> 00:37:29,000
>> Aqueles tudo parece fazer sentido para a maior parte?

554
00:37:29,000 --> 00:37:35,000
Parte dessa terminologia é um pouco descolada, às vezes.

555
00:37:35,000 --> 00:37:46,000
Eu gosto de pensar de uma declaração como para a maior parte algo que termina com um ponto e vírgula.

556
00:37:46,000 --> 00:37:51,000
Declarações como x = 7, que define uma variável,

557
00:37:51,000 --> 00:37:54,000
presumivelmente chamado x = 7.

558
00:37:54,000 --> 00:38:01,000
Presumivelmente x também é um tipo que pode armazenar o número 7,

559
00:38:01,000 --> 00:38:05,000
por isso é um int ou possivelmente uma bóia ou um curto ou um char,

560
00:38:05,000 --> 00:38:07,000
algo assim.

561
00:38:07,000 --> 00:38:12,000
Uma expressão booleana está usando estes dois iguais

562
00:38:12,000 --> 00:38:17,000
eo estrondo igual ou não é igual, menor que, maior que,

563
00:38:17,000 --> 00:38:22,000
inferior ou igual a, todo o tipo de coisas.

564
00:38:22,000 --> 00:38:28,000
Condições então são declarações, se outro lugar.

565
00:38:28,000 --> 00:38:32,000
Gostaria de lembrar que você não pode ter uma pessoa sem um correspondente se.

566
00:38:32,000 --> 00:38:37,000
Da mesma forma, você não pode ter uma pessoa se sem um correspondente se.

567
00:38:37,000 --> 00:38:40,000
Loops, recordar os três tipos de loops estamos martelando em você

568
00:38:40,000 --> 00:38:43,000
para o último par de seções e conjuntos de problemas.

569
00:38:43,000 --> 00:38:46,000
Usando que quando, quando você está recebendo entrada do usuário,

570
00:38:46,000 --> 00:38:51,000
usando while até que uma determinada condição é verdadeira,

571
00:38:51,000 --> 00:38:56,000
e em seguida, usando os loops se você precisa

572
00:38:56,000 --> 00:39:01,000
saber qual iteração do loop que você está no momento é como eu penso sobre isso.

573
00:39:01,000 --> 00:39:07,000
Ou, se você está fazendo um para cada personagem de uma série que eu quero fazer alguma coisa,

574
00:39:07,000 --> 00:39:15,000
para cada elemento em uma matriz que eu quero fazer algo para esse elemento.

575
00:39:15,000 --> 00:39:18,000
>> Tópicos e eventos.

576
00:39:18,000 --> 00:39:21,000
Estes não cobrimos de forma tão explícita em C,

577
00:39:21,000 --> 00:39:23,000
mas lembre-se este a partir do zero.

578
00:39:23,000 --> 00:39:26,000
Esta é a noção de ter roteiros diferentes.

579
00:39:26,000 --> 00:39:32,000
Esta é também a noção de transmitir um evento.

580
00:39:32,000 --> 00:39:37,000
Algumas pessoas não utiliza a transmissão de seus projetos, inicialmente,

581
00:39:37,000 --> 00:39:40,000
que é totalmente legal,

582
00:39:40,000 --> 00:39:46,000
mas estas são duas formas diferentes de lidar com esta questão maior chamados de concorrência,

583
00:39:46,000 --> 00:39:49,000
que é como você começa a executar programas

584
00:39:49,000 --> 00:39:54,000
ou aparentemente executar ao mesmo tempo?

585
00:39:54,000 --> 00:39:59,000
Diferentes tarefas em execução, enquanto outras tarefas também estão em execução.

586
00:39:59,000 --> 00:40:01,000
Esta é a forma como seu sistema operacional parece funcionar.

587
00:40:01,000 --> 00:40:04,000
É por isso que, ainda que, por exemplo,

588
00:40:04,000 --> 00:40:10,000
Eu tenho o meu navegador rodando, eu também posso ligar Spotify e tocar uma música.

589
00:40:10,000 --> 00:40:14,000
Isso é mais uma coisa conceitual para entender.

590
00:40:14,000 --> 00:40:17,000
Gostaria de ter um olhar para os fios curtos

591
00:40:17,000 --> 00:40:21,000
se você quiser saber mais sobre isso.

592
00:40:21,000 --> 00:40:26,000
>> Vamos ver, acredito que poderia ter sido

593
00:40:26,000 --> 00:40:31,000
um problema sobre isso em um desses.

594
00:40:31,000 --> 00:40:35,000
Mais uma vez, acho que tópicos e eventos não são algo que iremos cobrir em C

595
00:40:35,000 --> 00:40:41,000
só porque é muito mais difícil do que em Scratch.

596
00:40:41,000 --> 00:40:44,000
Você não deve se preocupar com isso lá, mas definitivamente entender os conceitos,

597
00:40:44,000 --> 00:40:47,000
entender o que está acontecendo.

598
00:40:47,000 --> 00:40:52,000
Antes de seguir em frente, qualquer dúvida sobre Semana 0 materiais?

599
00:40:52,000 --> 00:40:55,000
Todo mundo se sentindo muito bem?

600
00:40:55,000 --> 00:41:03,000
Variáveis ​​compreensão e que é uma variável?

601
00:41:03,000 --> 00:41:08,000
>> Seguindo em frente. 1 semana.

602
00:41:08,000 --> 00:41:12,000
Um par de coisas aqui que não foram especialmente visados

603
00:41:12,000 --> 00:41:21,000
na revisão questionário necessariamente e também coisas mais conceituais para pensar.

604
00:41:21,000 --> 00:41:30,000
A primeira é a noção de que de código fonte, compiladores e código objeto são.

605
00:41:30,000 --> 00:41:32,000
Alguém? Basil.

606
00:41:32,000 --> 00:41:37,000
É objeto de código, quero dizer código-fonte é o que você colocar bumbum,

607
00:41:37,000 --> 00:41:42,000
e código objeto é o bumbum põe para fora para que o computador possa ler o programa.

608
00:41:42,000 --> 00:41:44,000
Exatamente.

609
00:41:44,000 --> 00:41:47,000
O código-fonte é o código C que você realmente digitar.

610
00:41:47,000 --> 00:41:50,000
Código objeto é o que você sai de bumbum.

611
00:41:50,000 --> 00:41:54,000
É a 0s e 1s em que formato binário.

612
00:41:54,000 --> 00:41:59,000
Então, o que acontece é que quando você tem um monte de arquivos de objeto,

613
00:41:59,000 --> 00:42:04,000
dizer que você está compilando um projeto ou um programa que usa vários arquivos de código fonte,

614
00:42:04,000 --> 00:42:09,000
que, por convenção têm a extensão de arquivo. c.

615
00:42:09,000 --> 00:42:13,000
É por isso que temos caesar.c, vigenère.c.

616
00:42:13,000 --> 00:42:18,000
Se você estiver escrevendo programas em Java você dar-lhes a extensão. Java.

617
00:42:18,000 --> 00:42:24,000
Programas em Python têm a extensão. Aa freqüência.

618
00:42:24,000 --> 00:42:26,000
>> Uma vez que você tem vários arquivos. C, compilá-los.

619
00:42:26,000 --> 00:42:29,000
Clang cospe todo esse lixo binário.

620
00:42:29,000 --> 00:42:33,000
Então, porque você só quer um programa

621
00:42:33,000 --> 00:42:37,000
você tem o link de ligação de todos estes arquivos objeto juntos

622
00:42:37,000 --> 00:42:40,000
em um arquivo executável.

623
00:42:40,000 --> 00:42:45,000
Este é também o que acontece quando você usa a biblioteca CS50, por exemplo.

624
00:42:45,000 --> 00:42:50,000
A biblioteca CS50 é tanto isso. H arquivo de cabeçalho

625
00:42:50,000 --> 00:42:53,000
que você leu, que # includecs50.h.

626
00:42:53,000 --> 00:42:58,000
E então é também um arquivo de biblioteca especial binário

627
00:42:58,000 --> 00:43:02,000
que foi compilado que é 0s e 1s,

628
00:43:02,000 --> 00:43:08,000
e que a L-bandeira, por isso, se voltarmos aos nossos espaços e estamos muito rapidamente

629
00:43:08,000 --> 00:43:11,000
o que está acontecendo aqui, quando olhamos para o nosso comando bumbum,

630
00:43:11,000 --> 00:43:15,000
o que temos é este é o nosso arquivo de código fonte aqui.

631
00:43:15,000 --> 00:43:18,000
Estes são um bando de sinalizadores de compilador.

632
00:43:18,000 --> 00:43:22,000
E então, no final, estes elo l-bandeiras em

633
00:43:22,000 --> 00:43:30,000
os arquivos binários reais para essas duas bibliotecas, a biblioteca CS50 e, em seguida, a biblioteca de matemática.

634
00:43:30,000 --> 00:43:35,000
>> Entender cada tipo de finalidade arquivos '

635
00:43:35,000 --> 00:43:38,000
no processo de compilação é algo que você vai querer ser capaz de

636
00:43:38,000 --> 00:43:43,000
dar, pelo menos, um elevado nível de visão.

637
00:43:43,000 --> 00:43:46,000
Código fonte vem dentro do código objeto sai.

638
00:43:46,000 --> 00:43:53,000
Arquivos de código objeto vincular juntos, e você recebe um arquivo, bonito executável.

639
00:43:53,000 --> 00:43:55,000
Cool.

640
00:43:55,000 --> 00:43:58,000
Esta é também onde você pode obter erros em vários pontos

641
00:43:58,000 --> 00:44:00,000
no processo de compilação.

642
00:44:00,000 --> 00:44:04,000
Este é o lugar onde, por exemplo, se você tirar essa bandeira ligação,

643
00:44:04,000 --> 00:44:10,000
a bandeira CS50, e omitir-lo em espaços ou quando você está executando o seu código,

644
00:44:10,000 --> 00:44:13,000
este é o lugar onde você vai ter um erro na fase de vinculação,

645
00:44:13,000 --> 00:44:18,000
eo vinculador vai dizer: "Ei, você chamou um GetString função

646
00:44:18,000 --> 00:44:20,000
que está na biblioteca CS50 ".

647
00:44:20,000 --> 00:44:25,000
"Você me disse que estava na biblioteca CS50, e eu não consigo encontrar o código para ele."

648
00:44:25,000 --> 00:44:28,000
É aí que você tem que ligar-lo, e que é separado

649
00:44:28,000 --> 00:44:33,000
a partir de um erro do compilador porque o compilador está olhando sintaxe e esse tipo de coisa.

650
00:44:33,000 --> 00:44:38,000
É bom saber o que está acontecendo quando.

651
00:44:38,000 --> 00:44:42,000
>> Outras coisas a conhecer.

652
00:44:42,000 --> 00:44:49,000
Eu diria que você definitivamente quero ter um olhar para o curto no typecasting feito por Jordan

653
00:44:49,000 --> 00:44:55,000
para entender o que ints estão sob o capô,

654
00:44:55,000 --> 00:44:58,000
o que chars estão sob o capô.

655
00:44:58,000 --> 00:45:02,000
Quando falamos em ASCII e nós realmente olhar para a tabela ASCII,

656
00:45:02,000 --> 00:45:07,000
o que está fazendo é dando-nos um olhar sob o capô

657
00:45:07,000 --> 00:45:13,000
a forma como o computador realmente representa o capital A e 7 dígitos

658
00:45:13,000 --> 00:45:17,000
e uma vírgula e um ponto de interrogação.

659
00:45:17,000 --> 00:45:20,000
O computador também tem formas especiais para representar

660
00:45:20,000 --> 00:45:23,000
o número 7 como um inteiro.

661
00:45:23,000 --> 00:45:27,000
Ele tem um jeito especial para representar o número 7 como um número de ponto flutuante,

662
00:45:27,000 --> 00:45:29,000
e aqueles que são muito diferentes.

663
00:45:29,000 --> 00:45:32,000
Typecasting é como você dizer ao computador "Ei, eu quero que você converter

664
00:45:32,000 --> 00:45:37,000
a partir de uma representação a outra representação ".

665
00:45:37,000 --> 00:45:40,000
Por que não vamos dar uma olhada nisso.

666
00:45:40,000 --> 00:45:44,000
>> Também gostaria de dar uma olhada no curto em bibliotecas e em curto compiladores.

667
00:45:44,000 --> 00:45:47,000
Aqueles falar sobre o processo de compilação,

668
00:45:47,000 --> 00:45:53,000
que é uma biblioteca, e passar por cima de algumas dessas perguntas que você pode se perguntou.

669
00:45:53,000 --> 00:45:55,000
Perguntas sobre o material Semana 1?

670
00:45:55,000 --> 00:46:03,000
Há algum tópicos aqui que parecem assustador que você gostaria de cobrir?

671
00:46:03,000 --> 00:46:07,000
Estou tentando explodir na maioria destes tópicos anteriores, para que possamos chegar a

672
00:46:07,000 --> 00:46:13,000
ponteiros e fazer um pouco de recursão.

673
00:46:13,000 --> 00:46:15,000
Pensamentos?

674
00:46:15,000 --> 00:46:19,000
Qualquer coisa para cobrir?

675
00:46:19,000 --> 00:46:21,000
Tempo para um pouco de chocolate, talvez?

676
00:46:21,000 --> 00:46:23,000
Vocês estão trabalhando com ele.

677
00:46:23,000 --> 00:46:26,000
Eu vou continuar a beber o meu café.

678
00:46:26,000 --> 00:46:31,000
Semana 2.

679
00:46:31,000 --> 00:46:34,000
Boa chamada, boa chamada.

680
00:46:34,000 --> 00:46:38,000
Na 2 ª semana falamos um pouco mais sobre funções.

681
00:46:38,000 --> 00:46:43,000
>> Nos primeiros conjuntos de problemas poucas que realmente não escrever quaisquer funções em tudo

682
00:46:43,000 --> 00:46:45,000
diferente do que função?

683
00:46:45,000 --> 00:46:47,000
[Estudante] principal. >> Principal, exatamente.

684
00:46:47,000 --> 00:46:51,000
E assim temos visto os trajes diferentes que veste principal.

685
00:46:51,000 --> 00:46:54,000
Há aquele em que não tem argumentos,

686
00:46:54,000 --> 00:46:58,000
e nós apenas dizer vazio entre os parênteses,

687
00:46:58,000 --> 00:47:01,000
e depois há o outro, onde queremos ter argumentos de linha de comando,

688
00:47:01,000 --> 00:47:08,000
e, como vimos, que é onde você tem argc int e string matriz argv

689
00:47:08,000 --> 00:47:13,000
ou agora que nós realmente expostos string para ser o char que é

690
00:47:13,000 --> 00:47:20,000
Nós vamos começar a escrevê-lo como char * argv e colchetes.

691
00:47:20,000 --> 00:47:22,000
No Conjunto de Problemas 3, vocês viram um monte de funções,

692
00:47:22,000 --> 00:47:27,000
e você implementou um monte de funções, desenhar, olhar para cima, scramble.

693
00:47:27,000 --> 00:47:31,000
Os protótipos foram todos escritos lá para você.

694
00:47:31,000 --> 00:47:33,000
>> O que eu queria falar aqui com funções muito rapidamente

695
00:47:33,000 --> 00:47:38,000
é que existem 3 partes a eles sempre que você escrever uma função.

696
00:47:38,000 --> 00:47:43,000
Você tem que especificar o tipo de retorno da função.

697
00:47:43,000 --> 00:47:46,000
Você tem que especificar um nome para a função, e então você tem que especificar

698
00:47:46,000 --> 00:47:51,000
a lista de argumentos ou a lista de parâmetros.

699
00:47:51,000 --> 00:47:57,000
Por exemplo, se eu fosse escrever uma função para resumir um monte de números inteiros

700
00:47:57,000 --> 00:48:03,000
e depois voltar para mim a soma do que seria o meu tipo de retorno

701
00:48:03,000 --> 00:48:06,000
se eu queria somar inteiros e depois retornar a soma?

702
00:48:06,000 --> 00:48:12,000
Em seguida, o nome da função.

703
00:48:12,000 --> 00:48:27,000
Se eu ir em frente e escrever em verde, essa parte é o tipo de retorno.

704
00:48:27,000 --> 00:48:34,000
Esta parte é o nome.

705
00:48:34,000 --> 00:48:40,000
E então, entre parênteses

706
00:48:40,000 --> 00:48:46,000
é onde eu dou os argumentos,

707
00:48:46,000 --> 00:48:56,000
muitas vezes abreviado como args, às vezes chamado params para os parâmetros.

708
00:48:56,000 --> 00:49:00,000
E se você tem um, você só especificar a um.

709
00:49:00,000 --> 00:49:06,000
Se você tiver vários de separar cada um com uma vírgula.

710
00:49:06,000 --> 00:49:13,000
E para cada argumento que você dê duas coisas que são-Kevin?

711
00:49:13,000 --> 00:49:18,000
[Kevin] Você tem que dar o tipo e em seguida o nome.

712
00:49:18,000 --> 00:49:21,000
E então o nome, eo nome é o nome que você vai usar

713
00:49:21,000 --> 00:49:25,000
para se referir a esse argumento dentro da função soma,

714
00:49:25,000 --> 00:49:27,000
dentro da função que você está escrevendo atualmente.

715
00:49:27,000 --> 00:49:32,000
>> Você não tem que, por exemplo, se eu estou indo para resumir,

716
00:49:32,000 --> 00:49:41,000
dizer, uma matriz de números inteiros: nós fazer matriz int,

717
00:49:41,000 --> 00:49:46,000
e eu vou me dar algumas chaves lá-

718
00:49:46,000 --> 00:49:51,000
então, quando eu passar um array para a função soma

719
00:49:51,000 --> 00:49:55,000
I passá-lo na primeira posição da lista de argumento.

720
00:49:55,000 --> 00:49:59,000
Mas a matriz que passar não tem que ter o nome arr.

721
00:49:59,000 --> 00:50:07,000
Arr. vai ser como eu me refiro a esse argumento dentro do corpo da função.

722
00:50:07,000 --> 00:50:10,000
A outra coisa que temos de ter em conta,

723
00:50:10,000 --> 00:50:14,000
e isso é um pouco diferente de funções, mas eu acho que é um ponto importante,

724
00:50:14,000 --> 00:50:20,000
é que, no C, quando estou escrevendo uma função como esta

725
00:50:20,000 --> 00:50:29,000
como eu sei quantos elementos estão nesta matriz?

726
00:50:29,000 --> 00:50:31,000
Isso é um pouco de uma pergunta capciosa.

727
00:50:31,000 --> 00:50:35,000
Nós conversamos sobre isso um pouco na seção da última semana.

728
00:50:35,000 --> 00:50:40,000
Como eu sei que o número de elementos dentro de uma matriz em C?

729
00:50:40,000 --> 00:50:44,000
Existe uma maneira?

730
00:50:44,000 --> 00:50:49,000
>> Acontece que não há nenhuma maneira de saber.

731
00:50:49,000 --> 00:50:52,000
Você tem que passá-lo em separado.

732
00:50:52,000 --> 00:50:55,000
Existe um truque que você pode fazer

733
00:50:55,000 --> 00:51:00,000
se você estiver na mesma função em que a matriz tenha sido declarado,

734
00:51:00,000 --> 00:51:04,000
e você está trabalhando com uma grande pilha.

735
00:51:04,000 --> 00:51:06,000
Mas isso só funciona se você estiver na mesma função.

736
00:51:06,000 --> 00:51:09,000
Depois de passar uma matriz para outra função ou se você tiver declarado uma matriz

737
00:51:09,000 --> 00:51:12,000
e você colocar essa matriz na pilha, você já usou malloc

738
00:51:12,000 --> 00:51:15,000
 e esse tipo de coisa, então todas as apostas estão fora.

739
00:51:15,000 --> 00:51:18,000
Então, você realmente tem que passar em torno de

740
00:51:18,000 --> 00:51:21,000
um argumento especial ou outro parâmetro

741
00:51:21,000 --> 00:51:23,000
dizendo o quão grande é a matriz.

742
00:51:23,000 --> 00:51:28,000
Neste caso, eu gostaria de usar uma vírgula-Sinto muito, vai para fora da tela aqui-

743
00:51:28,000 --> 00:51:32,000
e eu passar em outro argumento

744
00:51:32,000 --> 00:51:40,000
 e chamá-lo len int para o comprimento.

745
00:51:40,000 --> 00:51:44,000
>> Uma coisa que possa surgir no questionário

746
00:51:44,000 --> 00:51:49,000
está pedindo para você escrever ou implementar uma função especial chamada algo.

747
00:51:49,000 --> 00:51:54,000
Se não lhe dar o protótipo, então essa coisa toda aqui,

748
00:51:54,000 --> 00:51:58,000
toda essa confusão é chamado de declaração de função ou o protótipo da função,

749
00:51:58,000 --> 00:52:01,000
esta é uma das primeiras coisas que você vai querer pregar para baixo, se não for dado

750
00:52:01,000 --> 00:52:03,000
para você imediatamente no questionário.

751
00:52:03,000 --> 00:52:06,000
O outro truque que eu aprendi é que

752
00:52:06,000 --> 00:52:11,000
dizer que lhe dão um protótipo para uma função, e dizemos: "Ei, você tem que escrever."

753
00:52:11,000 --> 00:52:16,000
Dentro das chaves que você tem no questionário

754
00:52:16,000 --> 00:52:20,000
Se você notar que existe um tipo de retorno e você percebe que o tipo de retorno

755
00:52:20,000 --> 00:52:25,000
é algo diferente de vazio, o que significa que a função não retorna nada,

756
00:52:25,000 --> 00:52:28,000
em seguida, uma coisa que você definitivamente quer fazer é escrever

757
00:52:28,000 --> 00:52:33,000
algum tipo de instrução de retorno no final da função.

758
00:52:33,000 --> 00:52:40,000
Retorno, e neste caso, vamos colocar um em branco, porque queremos preencher o espaço em branco.

759
00:52:40,000 --> 00:52:44,000
Mas isto faz você pensar da maneira correta sobre como é que eu vou abordar esse problema?

760
00:52:44,000 --> 00:52:49,000
E lembra que você vai ter que retornar um valor

761
00:52:49,000 --> 00:52:51,000
à chamador da função.

762
00:52:51,000 --> 00:52:54,000
>> Sim. >> [Estudante] O estilo aplica quando estamos escrevendo código no teste?

763
00:52:54,000 --> 00:52:58,000
Como recuo e esse tipo de coisa? >> [Estudante] Yeah.

764
00:52:58,000 --> 00:53:00,000
Não, não é tão grande.

765
00:53:00,000 --> 00:53:09,000
Eu acho que um monte de-isto é algo que vai esclarecer sobre o teste no dia da,

766
00:53:09,000 --> 00:53:15,000
mas normalmente se preocupar com # inclui e esse tipo de coisa, é uma espécie de fora.

767
00:53:15,000 --> 00:53:17,000
[Estudante] Você precisa comentar seu código escrito à mão?

768
00:53:17,000 --> 00:53:19,000
Você precisa comentar o seu código escrito à mão?

769
00:53:19,000 --> 00:53:24,000
Comentando é sempre bom se você está preocupado com crédito parcial

770
00:53:24,000 --> 00:53:29,000
ou você quer comunicar a sua intenção para o aluno.

771
00:53:29,000 --> 00:53:33,000
Mas eu, mais uma vez, vai esclarecer sobre o questionário em si e no dia quiz,

772
00:53:33,000 --> 00:53:39,000
mas eu não acredito que você vai ser obrigado a escrever comentários, não.

773
00:53:39,000 --> 00:53:42,000
Normalmente não, mas é definitivamente o tipo de coisa que

774
00:53:42,000 --> 00:53:45,000
você pode comunicar a sua intenção, como "Ei, aqui é onde eu estou indo com isso."

775
00:53:45,000 --> 00:53:49,000
E às vezes isso pode ajudar com crédito parcial.

776
00:53:49,000 --> 00:53:51,000
Cool.

777
00:53:51,000 --> 00:53:53,000
>> Basil.

778
00:53:53,000 --> 00:53:56,000
[Basil] Qual é a diferença entre declarar, por exemplo, int lang

779
00:53:56,000 --> 00:54:03,000
nos argumentos ou parâmetros contra declarar uma variável dentro da função?

780
00:54:03,000 --> 00:54:05,000
Uau, o café caiu na traquéia.

781
00:54:05,000 --> 00:54:07,000
[Basil] Como que as coisas que queremos colocar em argumentos.

782
00:54:07,000 --> 00:54:09,000
Sim, essa é uma grande questão.

783
00:54:09,000 --> 00:54:11,000
Como você escolhe as coisas que você quer colocar nos argumentos

784
00:54:11,000 --> 00:54:17,000
versus o que você deve fazer as coisas dentro da função?

785
00:54:17,000 --> 00:54:24,000
Neste caso, incluiu ambos como argumentos

786
00:54:24,000 --> 00:54:29,000
porque é algo que quem vai usar a função soma

787
00:54:29,000 --> 00:54:32,000
precisa especificar essas coisas.

788
00:54:32,000 --> 00:54:35,000
>> A função soma, como falamos, não tem como saber

789
00:54:35,000 --> 00:54:40,000
como é grande a matriz é que fica de seu interlocutor ou quem estiver usando a função soma.

790
00:54:40,000 --> 00:54:44,000
Ele não tem forma de saber o tamanho dessa matriz é.

791
00:54:44,000 --> 00:54:48,000
A razão devemos passar nesse comprimento aqui como um argumento

792
00:54:48,000 --> 00:54:51,000
é porque isso é algo que nós estamos basicamente dizendo o chamador da função,

793
00:54:51,000 --> 00:54:55,000
quem vai usar a função soma: "Ei, você não só tem que nos dar uma matriz

794
00:54:55,000 --> 00:54:59,000
de inteiros, você também tem que nos dizer o quão grande a matriz que você nos deu. "

795
00:54:59,000 --> 00:55:03,000
[Basil] Aqueles serão ambos argumentos de linha de comando?

796
00:55:03,000 --> 00:55:06,000
Não, estes são argumentos reais que você deve passar para a função.

797
00:55:06,000 --> 00:55:10,000
>> Deixe-me fazer uma nova página aqui.

798
00:55:10,000 --> 00:55:13,000
[Basil] Como nome iria passar-

799
00:55:13,000 --> 00:55:24,000
[Nate H.] Se eu tiver int main (void),

800
00:55:24,000 --> 00:55:27,000
e eu vou colocar no meu retorno 0 aqui na parte inferior,

801
00:55:27,000 --> 00:55:31,000
e dizer que eu quero chamar a função soma.

802
00:55:31,000 --> 00:55:42,000
Eu quero dizer int x = soma ();

803
00:55:42,000 --> 00:55:46,000
Para usar a função soma eu tenho que passar em tanto a matriz que eu quero resumir

804
00:55:46,000 --> 00:55:51,000
e o comprimento da matriz, de modo que este é o local onde

805
00:55:51,000 --> 00:55:54,000
supondo que eu tivesse um array de inteiros,

806
00:55:54,000 --> 00:56:12,000
dizem tive Numbaz int [] = 1, 2, 3,

807
00:56:12,000 --> 00:56:16,000
tipo de uso que hackeou sintaxe ali,

808
00:56:16,000 --> 00:56:21,000
então o que eu gostaria de fazer é em suma eu gostaria de passar em

809
00:56:21,000 --> 00:56:27,000
tanto Numbaz e o número 3

810
00:56:27,000 --> 00:56:30,000
para dizer a função de soma "Ok, aqui está a matriz que eu quero que você somar."

811
00:56:30,000 --> 00:56:34,000
"Aqui é o seu tamanho."

812
00:56:34,000 --> 00:56:39,000
Isso faz sentido? Isso responde a sua pergunta?

813
00:56:39,000 --> 00:56:42,000
>> Em muitos aspectos, ele faz paralelo o que estamos fazendo com o principal

814
00:56:42,000 --> 00:56:44,000
quando temos os argumentos de linha de comando.

815
00:56:44,000 --> 00:56:47,000
Um programa como o César cifra, por exemplo, que precisava

816
00:56:47,000 --> 00:56:53,000
argumentos de linha de comando não seria capaz de fazer qualquer coisa.

817
00:56:53,000 --> 00:56:57,000
Ele não saberia como criptografar se você não informar o que a chave para usar

818
00:56:57,000 --> 00:57:03,000
ou se você não disse a ele o que você queria corda para criptografar.

819
00:57:03,000 --> 00:57:08,000
Solicitação de uma entrada, este é o lugar onde temos dois mecanismos diferentes

820
00:57:08,000 --> 00:57:14,000
para a tomada de entrada a partir do utilizador, para a tomada de informação a partir do utilizador.

821
00:57:14,000 --> 00:57:19,000
Para Conjunto de Problemas 1 vimos este GetInt, GetString forma, GetFloat

822
00:57:19,000 --> 00:57:26,000
de solicitação de entrada, e que é chamado usando o fluxo de entrada padrão.

823
00:57:26,000 --> 00:57:28,000
É um pouco diferente.

824
00:57:28,000 --> 00:57:31,000
Isso é algo que você pode fazer em um tempo ao contrário

825
00:57:31,000 --> 00:57:35,000
quando você chamar o programa, quando você iniciar o programa em execução.

826
00:57:35,000 --> 00:57:41,000
Os argumentos de linha de comando são especificados todos quando você iniciar o funcionamento do programa.

827
00:57:41,000 --> 00:57:47,000
Nós temos a mistura dos dois desses.

828
00:57:47,000 --> 00:57:52,000
Quando usamos argumentos para uma função, é muito parecido com os argumentos de linha de comando para a principal.

829
00:57:52,000 --> 00:57:56,000
É quando você chamar a função que você precisa dizer a ele

830
00:57:56,000 --> 00:58:05,000
exatamente o que ele precisa para executar suas tarefas.

831
00:58:05,000 --> 00:58:08,000
Outra coisa boa para olhar, e eu vou deixar você olhar em seu tempo livre,

832
00:58:08,000 --> 00:58:11,000
e foi coberto no questionário, era essa noção de escopo

833
00:58:11,000 --> 00:58:15,000
e as variáveis ​​locais versus variáveis ​​globais.

834
00:58:15,000 --> 00:58:18,000
Preste atenção a isso.

835
00:58:18,000 --> 00:58:23,000
>> Agora que estamos chegando para essas outras coisas,

836
00:58:23,000 --> 00:58:27,000
na Semana 3 começamos a falar sobre pesquisa e classificação.

837
00:58:27,000 --> 00:58:32,000
Pesquisa e classificação, pelo menos no CS50,

838
00:58:32,000 --> 00:58:39,000
é muito mais uma introdução a algumas das partes mais teóricas da ciência da computação.

839
00:58:39,000 --> 00:58:42,000
O problema da pesquisa, o problema da ordenação

840
00:58:42,000 --> 00:58:46,000
são grandes problemas canônicos.

841
00:58:46,000 --> 00:58:52,000
Como você encontrar um número específico em uma matriz de milhares de milhões de inteiros?

842
00:58:52,000 --> 00:58:55,000
Como você encontrar um nome específico dentro de um livro de telefone

843
00:58:55,000 --> 00:58:59,000
que está armazenado em seu laptop?

844
00:58:59,000 --> 00:59:04,000
E, assim, introduzir esta noção de tempos de execução assintóticos

845
00:59:04,000 --> 00:59:11,000
realmente quantificar quanto tempo, o quão duro esses problemas são,

846
00:59:11,000 --> 00:59:14,000
quanto tempo demora para resolver.

847
00:59:14,000 --> 00:59:20,000
Em, acredito, 2011 do questionário há um problema que eu acho que merece

848
00:59:20,000 --> 00:59:27,000
cobrindo muito rapidamente, o que é um presente, problema 12.

849
00:59:27,000 --> 00:59:32,000
O não, é Omega.

850
00:59:32,000 --> 00:59:41,000
>> Aqui nós estamos falando sobre o tempo de execução mais rápido possível

851
00:59:41,000 --> 00:59:46,000
para um determinado algoritmo e, em seguida, o tempo de execução mais lenta possível.

852
00:59:46,000 --> 00:59:52,000
Este Omega e O são realmente apenas atalhos.

853
00:59:52,000 --> 00:59:55,000
Eles são atalhos de notação por dizer

854
00:59:55,000 --> 00:59:59,000
rapidez no caso melhor possível vontade nossa corrida algoritmo,

855
00:59:59,000 --> 01:00:06,000
e como lento no pior caso possível nosso algoritmo irá executar?

856
01:00:06,000 --> 01:00:10,000
Vamos fazer um par destes, e estes foram também abrangidos

857
01:00:10,000 --> 01:00:13,000
no curto sobre notação assintótica, o que eu recomendo.

858
01:00:13,000 --> 01:00:17,000
Jackson fez um trabalho realmente bom.

859
01:00:17,000 --> 01:00:23,000
Com busca binária, falamos de busca binária como sendo um algoritmo,

860
01:00:23,000 --> 01:00:28,000
e costumamos falar sobre isso em termos de sua grande O.

861
01:00:28,000 --> 01:00:30,000
O que é o grande?

862
01:00:30,000 --> 01:00:34,000
Qual é o tempo de execução mais lenta possível de busca binária?

863
01:00:34,000 --> 01:00:36,000
[Estudante] N ²?

864
01:00:36,000 --> 01:00:41,000
Fechar, eu acho semelhante a isso.

865
01:00:41,000 --> 01:00:43,000
É muito mais rápido do que isso.

866
01:00:43,000 --> 01:00:45,000
[Estudante] binário? >> Sim, busca binária.

867
01:00:45,000 --> 01:00:47,000
[Estudante] É log n.

868
01:00:47,000 --> 01:00:49,000
Log n, então o que log n significa?

869
01:00:49,000 --> 01:00:51,000
É metades que cada iteração.

870
01:00:51,000 --> 01:00:56,000
Exatamente, por isso, no caso o mais lento possível,

871
01:00:56,000 --> 01:01:00,000
dizer se você tem um array ordenado

872
01:01:00,000 --> 01:01:08,000
de um milhão de números inteiros eo número que você está procurando

873
01:01:08,000 --> 01:01:14,000
ou é o primeiro elemento da matriz ou o último elemento na matriz.

874
01:01:14,000 --> 01:01:18,000
Lembre-se, o algoritmo de busca binária funciona olhando para o elemento do meio,

875
01:01:18,000 --> 01:01:21,000
ver se esse é o jogo que você está procurando.

876
01:01:21,000 --> 01:01:23,000
Se for, então ótimo, você o encontrou.

877
01:01:23,000 --> 01:01:27,000
>> No melhor caso possível, o quão rápido é executado de busca binária?

878
01:01:27,000 --> 01:01:29,000
[Os alunos] 1.

879
01:01:29,000 --> 01:01:32,000
1, é de tempo constante, grande O do 1. Sim.

880
01:01:32,000 --> 01:01:36,000
[Estudante] Eu tenho uma pergunta. Quando você diz fazer de n, você quer dizer com respeito a base 2, certo?

881
01:01:36,000 --> 01:01:40,000
Sim, de modo que é a outra coisa.

882
01:01:40,000 --> 01:01:44,000
Dizemos n log, e eu acho que quando eu estava na escola

883
01:01:44,000 --> 01:01:48,000
Eu sempre achei que era log base 10.

884
01:01:48,000 --> 01:01:57,000
Sim, isso, sim, fazer 2 base normalmente é o que usamos.

885
01:01:57,000 --> 01:02:02,000
Mais uma vez, voltando a busca binária, se você estiver procurando por um ou outro

886
01:02:02,000 --> 01:02:05,000
o elemento no final ou o elemento no início,

887
01:02:05,000 --> 01:02:08,000
porque você começa no meio e depois de descartar

888
01:02:08,000 --> 01:02:13,000
o que meia não cumprir os critérios que você está procurando,

889
01:02:13,000 --> 01:02:15,000
e você vai para o próximo semestre e do próximo semestre e do próximo semestre.

890
01:02:15,000 --> 01:02:19,000
Se eu estou procurando o maior elemento da matriz de inteiros milhões

891
01:02:19,000 --> 01:02:25,000
Vou reduzir para metade é a mais registro de 1 milhão de vezes

892
01:02:25,000 --> 01:02:28,000
antes de eu finalmente testar e ver que o elemento que eu estou procurando

893
01:02:28,000 --> 01:02:33,000
está na maior ou na maior índice da matriz,

894
01:02:33,000 --> 01:02:38,000
e que terá registro de n, faça o login de 1 milhão de vezes.

895
01:02:38,000 --> 01:02:40,000
>> Espécie de bolha.

896
01:02:40,000 --> 01:02:43,000
Vocês lembrar o algoritmo de ordenação bolha?

897
01:02:43,000 --> 01:02:47,000
Kevin, você pode me dar uma rápida recapitulação do que aconteceu no algoritmo de ordenação bolha?

898
01:02:47,000 --> 01:02:50,000
[Kevin] Basicamente ele passa por tudo na lista.

899
01:02:50,000 --> 01:02:52,000
Ele olha para os dois primeiros.

900
01:02:52,000 --> 01:02:55,000
Se o primeiro é maior do que a segunda ela passa-los.

901
01:02:55,000 --> 01:02:58,000
Em seguida, ele compara, segundo e terceiro, a mesma coisa, swaps,

902
01:02:58,000 --> 01:03:00,000
terceiro e quarto, todo o caminho.

903
01:03:00,000 --> 01:03:03,000
Números maiores seguirá até o fim.

904
01:03:03,000 --> 01:03:07,000
E depois de muitas voltas no entanto você está feito.

905
01:03:07,000 --> 01:03:11,000
Exatamente, por isso que Kevin disse é que nós vamos assistir números maiores

906
01:03:11,000 --> 01:03:15,000
bolha até ao final da matriz.

907
01:03:15,000 --> 01:03:19,000
Por exemplo, você se importa de caminhar conosco através deste exemplo, se esta é a nossa matriz?

908
01:03:19,000 --> 01:03:21,000
[Kevin] Você vai tomar 2 e 3.

909
01:03:21,000 --> 01:03:23,000
3 é maior que 2, então você trocá-los.

910
01:03:23,000 --> 01:03:29,000
[Nate H.] Certo, então nós trocamos estes, e assim temos 2, 3, 6, 4 e 9.

911
01:03:29,000 --> 01:03:31,000
[Kevin] Então você comparar a 3 e 6.

912
01:03:31,000 --> 01:03:33,000
3 é menor que 6, de modo que você deixá-los,

913
01:03:33,000 --> 01:03:37,000
e 6 e 4, você trocá-los por 4 é menor que 6.

914
01:03:37,000 --> 01:03:42,000
[Nate H.] Direito, por isso fico 2, 3, 4, 6, 9.

915
01:03:42,000 --> 01:03:46,000
[Kevin] e 9 é maior do que 6, então você deixá-lo.

916
01:03:46,000 --> 01:03:48,000
E você voltar com ele novamente.

917
01:03:48,000 --> 01:03:50,000
>> [Nate H.] Estou feito neste momento? >> [Kevin] Não.

918
01:03:50,000 --> 01:03:52,000
E por que não estou feito neste momento?

919
01:03:52,000 --> 01:03:54,000
Porque parece que minha matriz é classificada. Estou olhando para ele.

920
01:03:54,000 --> 01:03:57,000
[Kevin] passar por isso novamente e certifique-se de que existem swaps não mais

921
01:03:57,000 --> 01:04:00,000
antes de parar totalmente.

922
01:04:00,000 --> 01:04:04,000
Exatamente, por isso é necessário manter a atravessar e certifique-se de que não existem swaps

923
01:04:04,000 --> 01:04:06,000
que você pode fazer neste momento.

924
01:04:06,000 --> 01:04:08,000
Era realmente apenas sorte, como você disse, que terminou

925
01:04:08,000 --> 01:04:12,000
só ter que fazer uma passagem e estamos classificados.

926
01:04:12,000 --> 01:04:16,000
Mas, para isso, no caso geral, vamos realmente tem que fazer isso uma e outra vez.

927
01:04:16,000 --> 01:04:20,000
E, de fato, este foi um exemplo do melhor caso possível,

928
01:04:20,000 --> 01:04:24,000
como vimos no problema.

929
01:04:24,000 --> 01:04:28,000
Nós vimos que o melhor caso possível foi n.

930
01:04:28,000 --> 01:04:32,000
Passamos por um momento matriz.

931
01:04:32,000 --> 01:04:35,000
Qual é o pior caso possível para este algoritmo?

932
01:04:35,000 --> 01:04:37,000
[Kevin] N ².

933
01:04:37,000 --> 01:04:41,000
E o que isso parece? O que seria um olhar matriz como que levaria tempo n ²?

934
01:04:41,000 --> 01:04:43,000
[Kevin] [inaudível] classificados.

935
01:04:43,000 --> 01:04:51,000
Exatamente, por isso, se eu tivesse a matriz de 9, 7, 6, 5, 2,

936
01:04:51,000 --> 01:04:54,000
primeiro o 9 seria bolha todo o caminho até.

937
01:04:54,000 --> 01:04:59,000
Depois de uma iteração teríamos 7, 6, 5, 2, 9.

938
01:04:59,000 --> 01:05:07,000
Em seguida, a 7 seria borbulhar, 6, 5, 2, 7, 9, e assim por diante e assim por diante.

939
01:05:07,000 --> 01:05:13,000
>> Nós teríamos que passar por toda a matriz n vezes,

940
01:05:13,000 --> 01:05:16,000
e você pode realmente ficar um pouco mais preciso do que isso

941
01:05:16,000 --> 01:05:23,000
porque uma vez que mudamos o 9 todo o caminho até em sua última posição possível

942
01:05:23,000 --> 01:05:26,000
sabemos que nunca temos que comparar com o elemento novo.

943
01:05:26,000 --> 01:05:29,000
Assim que começar a borbulhar o 7-se

944
01:05:29,000 --> 01:05:35,000
sabemos que podemos parar uma vez que o 7 é logo antes da 9

945
01:05:35,000 --> 01:05:37,000
uma vez que já comparou a 9 para ele.

946
01:05:37,000 --> 01:05:46,000
Se você fizer isso de forma inteligente, não é verdade, eu acho, que muito tempo.

947
01:05:46,000 --> 01:05:49,000
Você não vai comparar todas as possíveis combinações de [inaudível]

948
01:05:49,000 --> 01:05:55,000
cada vez que você passar por cada iteração.

949
01:05:55,000 --> 01:05:59,000
Mas, ainda assim, quando falamos sobre este limite superior dizemos que

950
01:05:59,000 --> 01:06:04,000
você está olhando para n ² comparações durante todo o tempo.

951
01:06:04,000 --> 01:06:12,000
>> Vamos voltar, e já estamos começando a ficar um pouco em curto tempo

952
01:06:12,000 --> 01:06:15,000
Eu diria que você deve definitivamente passar o resto desta tabela,

953
01:06:15,000 --> 01:06:17,000
preencher tudo.

954
01:06:17,000 --> 01:06:20,000
Pense em exemplos. Pense em exemplos concretos.

955
01:06:20,000 --> 01:06:22,000
Isso é muito prático e útil para fazer.

956
01:06:22,000 --> 01:06:25,000
Retirá-la.

957
01:06:25,000 --> 01:06:28,000
Este é o tipo de tabela que como você passar em ciência da computação

958
01:06:28,000 --> 01:06:32,000
você deve realmente começar a conhecer estes coração por.

959
01:06:32,000 --> 01:06:34,000
Estes são os tipos de perguntas que você entrar em entrevistas.

960
01:06:34,000 --> 01:06:36,000
Estes são os tipos de coisas que são boas para saber,

961
01:06:36,000 --> 01:06:41,000
e pensar sobre os casos de ponta, realmente descobrir como pensar

962
01:06:41,000 --> 01:06:45,000
sabendo que para bolha classificar a matriz pior possível

963
01:06:45,000 --> 01:06:52,000
de classificar com que é aquele que está em ordem inversa.

964
01:06:52,000 --> 01:06:58,000
>> Ponteiros. Vamos falar um pouco sobre ponteiros.

965
01:06:58,000 --> 01:07:03,000
Nos últimos minutos que temos aqui

966
01:07:03,000 --> 01:07:11,000
Eu sei que isso é algo junto com o arquivo de I / O que é novo.

967
01:07:11,000 --> 01:07:19,000
Quando falamos de ponteiros a razão pela qual quero falar sobre ponteiros

968
01:07:19,000 --> 01:07:24,000
é, pois, um, quando estamos trabalhando em C

969
01:07:24,000 --> 01:07:33,000
estamos realmente em um nível bastante baixo em comparação com linguagens de programação mais modernas.

970
01:07:33,000 --> 01:07:38,000
Nós somos realmente capazes de manipular as variáveis ​​na memória,

971
01:07:38,000 --> 01:07:43,000
descobrir onde eles estão, na verdade, localizado dentro da nossa memória RAM.

972
01:07:43,000 --> 01:07:46,000
Uma vez que você passou a ter aulas de sistema operacional que você verá

973
01:07:46,000 --> 01:07:48,000
que isso é, novamente, uma espécie de abstração.

974
01:07:48,000 --> 01:07:50,000
Isso não é realmente o caso.

975
01:07:50,000 --> 01:07:52,000
Temos memória virtual que está escondendo os detalhes de nós.

976
01:07:52,000 --> 01:07:58,000
>> Mas, por agora você pode assumir que quando você tem um programa,

977
01:07:58,000 --> 01:08:02,000
por exemplo, quando você começar a executar o seu programa de cifra de César

978
01:08:02,000 --> 01:08:06,000
Eu vou voltar para o meu iPad muito rapidamente-

979
01:08:06,000 --> 01:08:12,000
que, no início, o seu programa, se você tem, digamos,

980
01:08:12,000 --> 01:08:15,000
4 gigabytes de memória RAM do seu computador portátil,

981
01:08:15,000 --> 01:08:21,000
você se esquecer esse pedaço, e nós vamos chamar isso de RAM.

982
01:08:21,000 --> 01:08:25,000
E começa em um lugar que nós vamos chamar 0,

983
01:08:25,000 --> 01:08:30,000
e termina em um lugar que nós vamos chamar de 4 gigabytes.

984
01:08:30,000 --> 01:08:37,000
Eu realmente não posso escrever. O homem, que é cortado.

985
01:08:37,000 --> 01:08:40,000
Quando o programa é executado

986
01:08:40,000 --> 01:08:44,000
o sistema operacional esculpe a memória RAM,

987
01:08:44,000 --> 01:08:51,000
e especifica segmentos diferentes para diferentes partes do seu programa para se viver

988
01:08:51,000 --> 01:08:58,000
Aqui em baixo esta área é uma espécie de terra de ninguém.

989
01:08:58,000 --> 01:09:02,000
Quando você vai até um pouco mais aqui

990
01:09:02,000 --> 01:09:05,000
você tem realmente o lugar onde

991
01:09:05,000 --> 01:09:09,000
o código para a vida de seus programas.

992
01:09:09,000 --> 01:09:13,000
Esse código binário real, que na verdade arquivo executável é carregado na memória

993
01:09:13,000 --> 01:09:17,000
quando você executar um programa, e que vive no segmento de código.

994
01:09:17,000 --> 01:09:22,000
E como o programa é executado o processador olha para este segmento de código

995
01:09:22,000 --> 01:09:24,000
para descobrir o que é a instrução seguinte?

996
01:09:24,000 --> 01:09:27,000
Qual é a próxima linha de código que eu preciso para executar?

997
01:09:27,000 --> 01:09:31,000
>> Há também um segmento de dados, e é aí que aqueles constantes da cadeia

998
01:09:31,000 --> 01:09:34,000
ficam armazenados que você está usando.

999
01:09:34,000 --> 01:09:42,000
E depois mais acima há um lugar chamado a pilha.

1000
01:09:42,000 --> 01:09:46,000
Nós acessar a memória lá usando malloc,

1001
01:09:46,000 --> 01:09:49,000
e depois para o topo do seu programa

1002
01:09:49,000 --> 01:09:52,000
há a pilha,

1003
01:09:52,000 --> 01:09:57,000
e é aí que temos vindo a jogar a maior parte do início.

1004
01:09:57,000 --> 01:09:59,000
Esta não é a escala ou nada.

1005
01:09:59,000 --> 01:10:03,000
Muito disso é muito dependente da máquina,

1006
01:10:03,000 --> 01:10:10,000
dependentes do sistema operacional, mas isso é como as coisas são relativamente fragmentada cima.

1007
01:10:10,000 --> 01:10:17,000
Quando você executar um programa e você declarar uma variável chamada x-

1008
01:10:17,000 --> 01:10:27,000
Eu vou chamar a outra caixa em baixo, e isso vai ser RAM também.

1009
01:10:27,000 --> 01:10:29,000
E eu vou olhar.

1010
01:10:29,000 --> 01:10:34,000
Vamos desenhar linhas irregulares para indicar esta é apenas uma pequena parte da RAM

1011
01:10:34,000 --> 01:10:38,000
e não a sua totalidade como se desenhar na parte superior.

1012
01:10:38,000 --> 01:10:43,000
>> Se eu declarar uma variável inteira chamada x,

1013
01:10:43,000 --> 01:10:49,000
então o que eu na verdade é um mapeamento

1014
01:10:49,000 --> 01:10:54,000
que é armazenado na tabela de símbolos do meu programa

1015
01:10:54,000 --> 01:11:00,000
que liga o x nome a esta região de memória que eu desenhei

1016
01:11:00,000 --> 01:11:03,000
aqui entre as barras verticais.

1017
01:11:03,000 --> 01:11:08,000
Se eu tiver uma linha de código no meu programa que diz que x = 7

1018
01:11:08,000 --> 01:11:15,000
o processador sabe "Oh, ok, eu sei que vive x neste local na memória."

1019
01:11:15,000 --> 01:11:25,000
"Eu estou indo para ir em frente e escrever um 7 lá."

1020
01:11:25,000 --> 01:11:28,000
Como ele sabe o que esta localização é na memória?

1021
01:11:28,000 --> 01:11:30,000
Bem, tudo isso é feito em tempo de compilação.

1022
01:11:30,000 --> 01:11:34,000
O compilador cuida de alocar onde cada uma das variáveis ​​estão a ir para

1023
01:11:34,000 --> 01:11:40,000
e criando um mapeamento especial ou melhor ligar os pontos

1024
01:11:40,000 --> 01:11:43,000
entre um símbolo e para onde está indo, o nome de uma variável

1025
01:11:43,000 --> 01:11:46,000
e onde ele vai viver na memória.

1026
01:11:46,000 --> 01:11:50,000
Mas acontece que nós realmente podemos acessá-lo em nossos programas também.

1027
01:11:50,000 --> 01:11:55,000
Isso fica importante quando começamos a falar sobre algumas das estruturas de dados,

1028
01:11:55,000 --> 01:11:58,000
que é um conceito que vamos introduzir mais tarde.

1029
01:11:58,000 --> 01:12:09,000
>> Mas, por agora, o que você pode saber é que eu posso criar um ponteiro para esse local, x.

1030
01:12:09,000 --> 01:12:12,000
Por exemplo, posso criar uma variável ponteiro.

1031
01:12:12,000 --> 01:12:16,000
Quando criamos uma variável ponteiro usamos a notação estrela.

1032
01:12:16,000 --> 01:12:21,000
Neste caso, este diz que eu estou indo para criar um ponteiro para um int.

1033
01:12:21,000 --> 01:12:24,000
É um tipo como qualquer outro.

1034
01:12:24,000 --> 01:12:27,000
Nós dar-lhe uma variável como y,

1035
01:12:27,000 --> 01:12:32,000
e então configurá-lo igual ao endereço, para um endereço.

1036
01:12:32,000 --> 01:12:38,000
Neste caso, podemos definir y para apontar para x

1037
01:12:38,000 --> 01:12:43,000
tomando o endereço de x, o que fazemos com este comercial,

1038
01:12:43,000 --> 01:12:55,000
e, então, definir y para apontar para ele.

1039
01:12:55,000 --> 01:12:59,000
O que isso faz é essencialmente se olharmos para a nossa memória RAM

1040
01:12:59,000 --> 01:13:02,000
isto cria uma variável separada.

1041
01:13:02,000 --> 01:13:04,000
Ele vai chamá-lo de y,

1042
01:13:04,000 --> 01:13:06,000
e quando esta linha de código é executado

1043
01:13:06,000 --> 01:13:13,000
ele está realmente indo para criar um ponteiro pouco que nós normalmente desenhar como uma flecha,

1044
01:13:13,000 --> 01:13:15,000
e define y para apontar para x.

1045
01:13:15,000 --> 01:13:17,000
Sim.

1046
01:13:17,000 --> 01:13:19,000
[Estudante] Se x é já um ponteiro, que você acabou de fazer

1047
01:13:19,000 --> 01:13:22,000
int * y = x em vez de ter o comercial?

1048
01:13:22,000 --> 01:13:24,000
Sim.

1049
01:13:24,000 --> 01:13:27,000
Se x é já um ponteiro, então você pode definir dois ponteiros iguais uns aos outros,

1050
01:13:27,000 --> 01:13:30,000
caso em que y não iria apontar para x,

1051
01:13:30,000 --> 01:13:34,000
mas chama a atenção para o que quer que x está apontando.

1052
01:13:34,000 --> 01:13:37,000
Infelizmente, estamos fora do tempo.

1053
01:13:37,000 --> 01:13:44,000
>> O que gostaria de dizer neste momento, podemos falar sobre isso desligada,

1054
01:13:44,000 --> 01:13:49,000
mas eu diria que começar a trabalhar com este problema, # 14.

1055
01:13:49,000 --> 01:13:53,000
Você pode ver que há já um pouco preenchido para você aqui.

1056
01:13:53,000 --> 01:13:57,000
Você pode ver que quando nós declaramos dois ponteiros, int * x e y *,

1057
01:13:57,000 --> 01:14:01,000
e note que apontar o * próximo à variável foi algo que foi feito no ano passado.

1058
01:14:01,000 --> 01:14:05,000
Acontece que este é semelhante ao que nós estamos fazendo este ano.

1059
01:14:05,000 --> 01:14:11,000
Não importa onde você escreve o * quando você está declarando o ponteiro.

1060
01:14:11,000 --> 01:14:17,000
Mas temos escrito o * ao lado do tipo

1061
01:14:17,000 --> 01:14:24,000
porque que o torna muito claro que você está declarando uma variável ponteiro.

1062
01:14:24,000 --> 01:14:27,000
Você pode ver que declarar os dois ponteiros nos dá duas caixas.

1063
01:14:27,000 --> 01:14:31,000
Aqui quando vamos definir x igual a malloc

1064
01:14:31,000 --> 01:14:34,000
o que isso está dizendo é deixar de lado a memória no heap.

1065
01:14:34,000 --> 01:14:41,000
Essa pequena caixa aqui, este círculo, está localizado na pilha.

1066
01:14:41,000 --> 01:14:43,000
X está a apontar para ele.

1067
01:14:43,000 --> 01:14:46,000
Note que y ainda não está apontando para qualquer coisa.

1068
01:14:46,000 --> 01:14:50,000
Para obter memória para armazenar o número 42 em x

1069
01:14:50,000 --> 01:14:55,000
poderíamos usar o que a notação?

1070
01:14:55,000 --> 01:14:59,000
[Estudante] * x = 42.

1071
01:14:59,000 --> 01:15:01,000
Exatamente, * x = 42.

1072
01:15:01,000 --> 01:15:06,000
Isso significa que siga a seta e jogar 42 em lá.

1073
01:15:06,000 --> 01:15:09,000
Aqui onde vamos definir y e x temos y apontando para x.

1074
01:15:09,000 --> 01:15:13,000
Novamente, isso é como o que Kevin disse onde vamos definir y igual a x.

1075
01:15:13,000 --> 01:15:15,000
Y não está apontando para x.

1076
01:15:15,000 --> 01:15:19,000
Em vez disso, ele está apontando para o que x está apontando para bem.

1077
01:15:19,000 --> 01:15:24,000
>> E então, finalmente nesta última caixa há duas coisas possíveis que poderíamos fazer.

1078
01:15:24,000 --> 01:15:28,000
Um deles é, poderíamos dizer * x = 13.

1079
01:15:28,000 --> 01:15:33,000
A outra coisa é que poderia dizer-Alex, você sabe o que podemos fazer aqui?

1080
01:15:33,000 --> 01:15:37,000
Você poderia dizer * x = 13 ou-

1081
01:15:37,000 --> 01:15:41,000
[Estudante] Você poderia dizer o que int.

1082
01:15:41,000 --> 01:15:45,000
[Nate H.] Se isso foi referido como uma variável int que poderia fazer isso.

1083
01:15:45,000 --> 01:15:49,000
Poderíamos também dizer * y = 13, pois ambos estão apontando para o mesmo lugar,

1084
01:15:49,000 --> 01:15:51,000
para que pudéssemos usar uma variável para chegar lá.

1085
01:15:51,000 --> 01:15:56,000
Sim. >> [Estudante] Qual seria a sua aparência se apenas dizer que x int é 13?

1086
01:15:56,000 --> 01:16:00,000
Isso seria declarar uma nova variável chamada x, que não iria funcionar.

1087
01:16:00,000 --> 01:16:04,000
Nós teríamos uma colisão porque declarou x para ser um ponteiro aqui.

1088
01:16:04,000 --> 01:16:10,000
[Estudante] Se nós apenas tivemos essa afirmação por si só o que seria a sua aparência em termos do círculo?

1089
01:16:10,000 --> 01:16:14,000
Se tivéssemos x = 13, então teríamos uma caixa e, em vez de ter uma seta

1090
01:16:14,000 --> 01:16:16,000
saindo da caixa de nós desenhá-lo como apenas um 13.

1091
01:16:16,000 --> 01:16:19,000
[Estudante] Na caixa. Okay.

1092
01:16:19,000 --> 01:16:24,000
>> Obrigado por assistir, e boa sorte em 0 Quiz.

1093
01:16:24,000 --> 01:16:28,000
[CS50.TV]