1
00:00:00,000 --> 00:00:00,487

2
00:00:00,487 --> 00:00:11,210
>> [Música tocando]

3
00:00:11,210 --> 00:00:12,100
>> ROB BODEN: Tudo bem.

4
00:00:12,100 --> 00:00:15,620
Então, a primeira coisa em primeiro lugar, de vídeo
a partir de um rosto familiar.

5
00:00:15,620 --> 00:00:22,080

6
00:00:22,080 --> 00:00:22,560
>> [REPRODUÇÃO]

7
00:00:22,560 --> 00:00:23,370
>> -Tudo bem.

8
00:00:23,370 --> 00:00:27,150
Este é CS50, e este é
o início da semana três.

9
00:00:27,150 --> 00:00:29,980
Me desculpe, eu não poderia estar lá com você
hoje, mas permita-me apresentar

10
00:00:29,980 --> 00:00:32,880
Próprio Rob Boden do CS50.

11
00:00:32,880 --> 00:00:33,872
>> [FIM REPRODUÇÃO DE VÍDEO]

12
00:00:33,872 --> 00:00:39,340
>> [Aplausos e exclamações]

13
00:00:39,340 --> 00:00:41,277
>> ROB BODEN: A filmografia em
esse vídeo é fantástico.

14
00:00:41,277 --> 00:00:47,280

15
00:00:47,280 --> 00:00:47,770
Tudo bem.

16
00:00:47,770 --> 00:00:50,960
Então, primeiro, há um outro almoço.

17
00:00:50,960 --> 00:00:52,330
É amanhã às 1:15.

18
00:00:52,330 --> 00:00:54,480
Não há almoço nesta sexta-feira.

19
00:00:54,480 --> 00:00:55,810
É com Quora.

20
00:00:55,810 --> 00:01:00,190
E Tommy não está aqui ainda, mas um dos
as pessoas de lá é o ex-CF cabeça,

21
00:01:00,190 --> 00:01:01,530
Tommy McWilliam.

22
00:01:01,530 --> 00:01:02,730
Então, ele é um cara divertido.

23
00:01:02,730 --> 00:01:04,819
Você deve vir.

24
00:01:04,819 --> 00:01:05,900
>> Tudo bem.

25
00:01:05,900 --> 00:01:11,360
Então, na semana passada, começamos quebrando
sobre o que uma seqüência realmente é.

26
00:01:11,360 --> 00:01:14,830
Nós nos conhecemos desde o início que
é uma seqüência de caracteres.

27
00:01:14,830 --> 00:01:18,130
Mas na semana passada, que investigou o fato
que o que é realmente uma seqüência de

28
00:01:18,130 --> 00:01:22,110
caracteres, bem, agora temos
arrays de caracteres.

29
00:01:22,110 --> 00:01:26,450
E nós sabemos que uma seqüência, é uma matriz
de caracteres, no final,

30
00:01:26,450 --> 00:01:30,920
temos este byte especial nulo, este
invertida 0, que indica o final de

31
00:01:30,920 --> 00:01:32,230
a corda.

32
00:01:32,230 --> 00:01:36,970
>> E assim uma string é um array de
caracteres, mas podemos ter mais do que

33
00:01:36,970 --> 00:01:39,530
apenas uma matriz de caracteres,
que pode ter uma matriz de qualquer

34
00:01:39,530 --> 00:01:40,890
tipo de coisa que nós queremos.

35
00:01:40,890 --> 00:01:51,570
Então, se você se lembra da semana passada, o
Programa Idade que David introduziu

36
00:01:51,570 --> 00:01:53,560
muito rapidamente.

37
00:01:53,560 --> 00:01:57,010
Então a primeira coisa que vamos fazer é
pedir ao usuário para um número inteiro, o

38
00:01:57,010 --> 00:01:58,800
número de pessoas na sala.

39
00:01:58,800 --> 00:02:01,260
Uma vez que temos esse inteiro,
estamos declarando um array.

40
00:02:01,260 --> 00:02:02,890
Observe esta sintaxe suporte.

41
00:02:02,890 --> 00:02:04,540
Você vai se acostumar com isso.

42
00:02:04,540 --> 00:02:09,430
>> Então, nós estamos declarando um array de inteiros
chamado idades, e existem n

43
00:02:09,430 --> 00:02:12,080
inteiros nessa matriz.

44
00:02:12,080 --> 00:02:16,480
Portanto, este padrão aqui, este 4 int
i é igual a 0, i é menos do que n, i além

45
00:02:16,480 --> 00:02:20,580
plus, que também vai ser um padrão
que você começa muito acostumado.

46
00:02:20,580 --> 00:02:24,000
Porque isso é muito bonito como você está
sempre vai iterar sobre matrizes.

47
00:02:24,000 --> 00:02:26,330
Assim lembrar que n é o
comprimento da nossa matriz.

48
00:02:26,330 --> 00:02:32,120
E aqui, estamos pedindo repetidamente
para a idade da pessoa i na sala.

49
00:02:32,120 --> 00:02:36,640
>> Depois disso, nós vamos para baixo, e por qualquer
razão arbitrária, que, em seguida,

50
00:02:36,640 --> 00:02:40,220
imprimir quantos anos eles vão
ser um ano a partir de agora.

51
00:02:40,220 --> 00:02:49,980
E correr esse programa, vamos
fazer as idades, dot idades Slash.

52
00:02:49,980 --> 00:02:53,010
Assim, o número de pessoas na sala,
digamos que há três.

53
00:02:53,010 --> 00:02:59,880
E dizem, a primeira pessoa é de 13,
em seguida é 26, e o último é 30.

54
00:02:59,880 --> 00:03:05,080
Então ele vai interagir sobre os três
pessoas, imprima 14, 27 e 31.

55
00:03:05,080 --> 00:03:16,060
>> Então lembre-se que, quando se declarar um
matriz de tamanho n, em que os índices

56
00:03:16,060 --> 00:03:19,950
matriz, a matriz tem valores e
índices de 0, 1, 2, todo o caminho

57
00:03:19,950 --> 00:03:21,680
até n menos 1.

58
00:03:21,680 --> 00:03:26,255
Assim, quando nos disse que havia três pessoas
na sala, e nós colocamos aqui

59
00:03:26,255 --> 00:03:29,850
a primeira iteração através desta
loop, i vai ser 0.

60
00:03:29,850 --> 00:03:31,650
Assim, no índice 0.

61
00:03:31,650 --> 00:03:34,540
Estamos atribuindo o primeiro
idade que o usuário digita.

62
00:03:34,540 --> 00:03:38,870
Então, na próxima, estamos entrando na
segundo n o usuário digita, e em

63
00:03:38,870 --> 00:03:40,580
ao lado de dois, os últimos n.

64
00:03:40,580 --> 00:03:44,200
>> Então percebe que uma matriz de tamanho
três não tem nada

65
00:03:44,200 --> 00:03:46,040
no índice de três.

66
00:03:46,040 --> 00:03:49,036
Este não é válido.

67
00:03:49,036 --> 00:03:50,250
Tudo bem.

68
00:03:50,250 --> 00:03:55,136
Então, vamos voltar aqui.

69
00:03:55,136 --> 00:03:57,650

70
00:03:57,650 --> 00:04:01,590
Portanto, agora que você lidou com matrizes,
temos alguma familiaridade.

71
00:04:01,590 --> 00:04:03,780
Agora vamos passar para o comando
argumentos de linha, que vão ser

72
00:04:03,780 --> 00:04:05,890
muito relevante para este conjunto de problemas.

73
00:04:05,890 --> 00:04:09,670
>> Então, até agora, sempre que você tem
declarou a sua principal função, temos

74
00:04:09,670 --> 00:04:11,230
disse void main int.

75
00:04:11,230 --> 00:04:14,070
Então vazio significa apenas que
não estamos passando qualquer

76
00:04:14,070 --> 00:04:16,440
argumentos para esta função.

77
00:04:16,440 --> 00:04:19,190
Agora vamos ver que o principal
pode levar alguns argumentos.

78
00:04:19,190 --> 00:04:22,470
Aqui vamos chamá-los int argc
e cordas suportes argv.

79
00:04:22,470 --> 00:04:26,930
Os suportes, mais uma vez, indicando
que estamos lidando com matrizes.

80
00:04:26,930 --> 00:04:31,850
Então, aqui, suportes de corda argv, estamos
lidar com um conjunto de cordas.

81
00:04:31,850 --> 00:04:35,360
Então argc, que vai indicar
quantos argumentos temos

82
00:04:35,360 --> 00:04:37,580
passado para este programa.

83
00:04:37,580 --> 00:04:46,050
E para ver o que isso significa,
vamos fechar isso.

84
00:04:46,050 --> 00:04:46,490
>> OK.

85
00:04:46,490 --> 00:04:50,790
Então, até agora, nós funcionamos todos
programa como idades de barra de pontos.

86
00:04:50,790 --> 00:04:55,250
Podemos também, na linha de comando, o passado
passar argumentos, assim, a prazo, de comando

87
00:04:55,250 --> 00:04:56,550
argumentos de linha.

88
00:04:56,550 --> 00:04:59,760
Assim, o primeiro argumento, Olá mundo.

89
00:04:59,760 --> 00:05:03,350
Então, aqui, argc seria três.

90
00:05:03,350 --> 00:05:07,720
É a contagem dos argumentos
na linha de comando.

91
00:05:07,720 --> 00:05:12,840
Argc é sempre pelo menos um, uma vez que do ponto
reduzir as idades, em si, é considerada como um dos

92
00:05:12,840 --> 00:05:14,490
os argumentos de linha de comando.

93
00:05:14,490 --> 00:05:17,010
>> Então Olá é a primeira.

94
00:05:17,010 --> 00:05:20,460
Se as idades barra de pontos é o zeroth, então
Olá é a primeira, e é o mundo

95
00:05:20,460 --> 00:05:22,830
segundo argumento de linha de comando.

96
00:05:22,830 --> 00:05:29,490
Assim, o argv corda, vamos ver,
contém a cordas, barra dot

97
00:05:29,490 --> 00:05:33,830
idades, Olá, e do mundo.

98
00:05:33,830 --> 00:05:38,945
E, ao pedido de Davi, vamos
para reproduzir um vídeo introduzindo isso.

99
00:05:38,945 --> 00:05:42,486

100
00:05:42,486 --> 00:05:43,890
>> [REPRODUÇÃO]

101
00:05:43,890 --> 00:05:46,240
>> -Até agora, em programas que já
escrito, nós declaramos

102
00:05:46,240 --> 00:05:48,500
principal void main como int.

103
00:05:48,500 --> 00:05:51,170
E todo esse tempo, esse vazio tem
simplesmente foi especificando que a

104
00:05:51,170 --> 00:05:54,430
programa não tomar qualquer
Argumentos da linha de comando.

105
00:05:54,430 --> 00:05:57,750
Em outras palavras, quando um usuário executa um
programa, ele ou ela pode fornecer comando

106
00:05:57,750 --> 00:06:01,710
argumentos de linha escrevendo adicional
palavras ou frases depois do programa

107
00:06:01,710 --> 00:06:03,000
nome no prompt.

108
00:06:03,000 --> 00:06:06,550
>> Bem, se você quer que seu programa para
ter argumentos de linha de comando, um ou

109
00:06:06,550 --> 00:06:10,540
mais dessas palavras, precisamos substituir
anular com um par de argumentos.

110
00:06:10,540 --> 00:06:12,200
Então, vamos fazer isso.

111
00:06:12,200 --> 00:06:15,750
Incluir CS50.h.

112
00:06:15,750 --> 00:06:19,360
Incluir io.h. padrão

113
00:06:19,360 --> 00:06:20,760
Int principal.

114
00:06:20,760 --> 00:06:26,330
E agora, em vez de vazio, eu vou
especificar um int argc chamado, e um

115
00:06:26,330 --> 00:06:28,780
matriz de strings chamado argv.

116
00:06:28,780 --> 00:06:31,820
Agora, argc e argv são
simplesmente convenções.

117
00:06:31,820 --> 00:06:34,000
>> Poderíamos ter chamado esses argumentos
mais qualquer coisa que quisermos.

118
00:06:34,000 --> 00:06:37,630
Mas o que é importante é que argc é
um int porque, por definição, é

119
00:06:37,630 --> 00:06:41,360
indo para conter o número de argumentos, a
número de palavras no total, que o

120
00:06:41,360 --> 00:06:43,380
usuário digitou em seu alerta.

121
00:06:43,380 --> 00:06:47,910
argv, entretanto, o argumento do vetor, é
vai realmente ser uma matriz armazenar

122
00:06:47,910 --> 00:06:52,020
todas as palavras que o usuário tem
digitado no seu alerta.

123
00:06:52,020 --> 00:06:54,500
>> Vamos continuar a fazer algo agora
com uma ou mais destas

124
00:06:54,500 --> 00:06:55,660
Argumentos da linha de comando.

125
00:06:55,660 --> 00:07:00,070
Em particular, vamos em frente e imprimir
qualquer palavra que o usuário digita

126
00:07:00,070 --> 00:07:03,960
após o nome do programa
no prompt.

127
00:07:03,960 --> 00:07:04,730
Abrir suporte.

128
00:07:04,730 --> 00:07:06,240
Fechar suporte.

129
00:07:06,240 --> 00:07:10,510
Por cento Printf s barra invertida e vírgula.

130
00:07:10,510 --> 00:07:14,550
E agora eu preciso dizer que valor printf
para ligar a esse espaço reservado.

131
00:07:14,550 --> 00:07:18,600
Eu quero que a primeira palavra que o usuário tem
digitado após o nome do programa,

132
00:07:18,600 --> 00:07:23,130
e então eu vou para especificar
argv suporte 1, perto

133
00:07:23,130 --> 00:07:24,830
parênteses, ponto e vírgula.

134
00:07:24,830 --> 00:07:27,290
>> Agora, por um suporte e não o suporte 0?

135
00:07:27,290 --> 00:07:30,990
Bem, ao que parece, armazenados automaticamente
em argv 0 vai ser o

136
00:07:30,990 --> 00:07:32,620
nome real do programa.

137
00:07:32,620 --> 00:07:36,180
Assim, a primeira palavra que o usuário digita
após o nome do programa é, por

138
00:07:36,180 --> 00:07:38,990
convenção, vai ser
armazenado em argv 1.

139
00:07:38,990 --> 00:07:42,380
Vamos agora compilar e
executar este programa.

140
00:07:42,380 --> 00:07:47,780
>> Faça argv 0, ponto barra argv 0.

141
00:07:47,780 --> 00:07:50,520
E agora uma palavra como Olá.

142
00:07:50,520 --> 00:07:51,670
Enter.

143
00:07:51,670 --> 00:07:53,520
E aí temos que, Olá.

144
00:07:53,520 --> 00:07:55,750
>> [FIM REPRODUÇÃO DE VÍDEO]

145
00:07:55,750 --> 00:07:57,000
>> ROB BODEN: Tudo bem.

146
00:07:57,000 --> 00:07:59,380

147
00:07:59,380 --> 00:08:01,230
Feche essa.

148
00:08:01,230 --> 00:08:16,730
Então, dando uma olhada no que o programa que
nós apenas apresentado a nós, bem, apenas

149
00:08:16,730 --> 00:08:24,710
para mostrar, se imprimir argv 0, fazer, agora
o que é isso, argv 0, ponto barra argv 0.

150
00:08:24,710 --> 00:08:30,440
Então, como seria de esperar, está imprimindo a
nome do programa, uma vez que argv 0 é

151
00:08:30,440 --> 00:08:32,970
sempre vai ser o
nome do programa.

152
00:08:32,970 --> 00:08:35,640
Mas vamos fazer algo um
pouco mais interessante.

153
00:08:35,640 --> 00:08:42,080
>> Assim, no conjunto de problemas, você será
introduzida para esta função, atoi.

154
00:08:42,080 --> 00:08:44,440
Então o que vamos usar atoi para?

155
00:08:44,440 --> 00:08:48,550
Isso vai converter um
string para um inteiro.

156
00:08:48,550 --> 00:08:53,280
Então, se eu passar a corda, um, dois, três,
para atoi, que vai converter esse

157
00:08:53,280 --> 00:08:56,910
para o número inteiro, um, dois, três.

158
00:08:56,910 --> 00:09:01,480
Então, nós estamos indo para converter o primeiro
argumento de linha de comando para um inteiro,

159
00:09:01,480 --> 00:09:05,690
e depois é só imprimir esse inteiro.

160
00:09:05,690 --> 00:09:09,680
>> Então, basicamente, nós somos tipo de
reimplementar getInt, apenas o

161
00:09:09,680 --> 00:09:12,350
inteiro é inserido no comando
linha, em vez de no programa

162
00:09:12,350 --> 00:09:14,560
interativamente.

163
00:09:14,560 --> 00:09:23,170
Então, fazendo argv 0, vamos fazer
ele aqui, e fechar isso.

164
00:09:23,170 --> 00:09:27,670
Então, correndo argv 0, e vamos entrar no
inteiro, um, dois, três, quatro, um, dois.

165
00:09:27,670 --> 00:09:30,840
Então, ele vai imprimir o número inteiro, um
dois, três, quatro, um, dois.

166
00:09:30,840 --> 00:09:35,500
Há algumas sutilezas para que atoi
ele vai parar de se preocupar com nada

167
00:09:35,500 --> 00:09:39,040
além de um caractere numérico válido,
mas isso não importa.

168
00:09:39,040 --> 00:09:42,870
>> Então, o que você acha que acontece
se eu fizer isso?

169
00:09:42,870 --> 00:09:45,520

170
00:09:45,520 --> 00:09:47,050
Falha de segmentação.

171
00:09:47,050 --> 00:09:50,410
Então, por que isso?

172
00:09:50,410 --> 00:09:56,060
Se você olhar para trás, o nosso programa, estamos
convertendo argv 1, o primeiro argumento

173
00:09:56,060 --> 00:09:59,610
após o nome do programa, para um inteiro.

174
00:09:59,610 --> 00:10:03,350
Mas não há nenhum argumento passado
após o nome do programa.

175
00:10:03,350 --> 00:10:08,060
Então, aqui, vemos que este é um buggy
programa, uma vez que, se tentar executá-lo

176
00:10:08,060 --> 00:10:10,530
sem nenhum argumento,
ela só vai falhar.

177
00:10:10,530 --> 00:10:16,950
>> Então, um outro padrão comum você verá
é algo como, se argc é menos

178
00:10:16,950 --> 00:10:21,100
do que dois, o que indica que não houve
, pelo menos, o nome do programa e uma

179
00:10:21,100 --> 00:10:29,100
primeiro argumento, então vamos fazer alguma coisa
como printf, não o suficiente

180
00:10:29,100 --> 00:10:31,190
Argumentos da linha de comando.

181
00:10:31,190 --> 00:10:33,170
Isso provavelmente não é uma boa para imprimir,
provavelmente é alguma coisa, como

182
00:10:33,170 --> 00:10:35,440
você deve digitar um número inteiro
na linha de comando.

183
00:10:35,440 --> 00:10:37,450
Eu vou acabar com ela lá.

184
00:10:37,450 --> 00:10:39,600
E, em seguida, retornar 1.

185
00:10:39,600 --> 00:10:44,740
Então lembre-se que no final da nossa
programa, se retornar 0, esse tipo de

186
00:10:44,740 --> 00:10:47,060
indica sucesso.

187
00:10:47,060 --> 00:10:50,940
E principal também automaticamente
retorna 0 se não o fizer.

188
00:10:50,940 --> 00:10:55,800
>> Então, aqui, estamos afinando novamente 1 para indicar
que isso não é sucesso.

189
00:10:55,800 --> 00:11:01,000
E você pode devolver o que quiser,
apenas, 0 indica sucesso, e

190
00:11:01,000 --> 00:11:03,390
qualquer outra coisa que indica falha.

191
00:11:03,390 --> 00:11:04,855
Então, vamos executar esta versão das coisas.

192
00:11:04,855 --> 00:11:12,880

193
00:11:12,880 --> 00:11:16,600
Então, agora, se não entrar em uma linha de comando
argumento, ele vai dizer corretamente

194
00:11:16,600 --> 00:11:18,290
nós, não é suficiente linha de comando.

195
00:11:18,290 --> 00:11:20,610
Não terminou a frase.

196
00:11:20,610 --> 00:11:24,950
Outra coisa, se realmente passar um,
ele pode completar o programa.

197
00:11:24,950 --> 00:11:27,920
Então é assim que você usaria em argc
Para validar o número de

198
00:11:27,920 --> 00:11:30,630
argumentos de linha de comando que
são realmente passou.

199
00:11:30,630 --> 00:11:39,360
>> Então, vamos tornar este programa um pouco mais
complicado, e olhar para a segunda

200
00:11:39,360 --> 00:11:42,180
iteração das coisas.

201
00:11:42,180 --> 00:11:46,310
Então, agora, nós não estamos apenas a impressão do
primeiro argumento de linha de comando.

202
00:11:46,310 --> 00:11:51,210
Aqui, nós estamos interagindo de iguais i int
0, i é menos de argc, i além

203
00:11:51,210 --> 00:11:55,280
plus, e impressão argv, o índice i.

204
00:11:55,280 --> 00:11:59,300
Portanto, este padrão, mais uma vez, este é o mesmo
padrão como antes, exceto em vez

205
00:11:59,300 --> 00:12:02,600
de chamar a variável
n, estamos usando argc.

206
00:12:02,600 --> 00:12:09,520
>> Portanto, esta é a iteração sobre cada índice
na matriz, e imprimindo cada

207
00:12:09,520 --> 00:12:11,910
elemento dessa matriz.

208
00:12:11,910 --> 00:12:20,300
E assim, quando executar este programa, bem como,
Eu não entrar em qualquer linha de comando

209
00:12:20,300 --> 00:12:22,540
argumentos, por isso apenas impressões
o nome do programa.

210
00:12:22,540 --> 00:12:26,053
Se eu entrar em um monte de coisas, ele vai
imprimir um, cada um em sua própria linha.

211
00:12:26,053 --> 00:12:31,213

212
00:12:31,213 --> 00:12:32,210
>> OK.

213
00:12:32,210 --> 00:12:34,770
Então, vamos dar um passo adiante.

214
00:12:34,770 --> 00:12:38,890
E em vez de imprimir cada argumento
em sua própria linha, vamos imprimir cada

215
00:12:38,890 --> 00:12:42,590
caráter de cada argumento
em sua própria linha.

216
00:12:42,590 --> 00:12:46,700
Então lembre-se que é argv
uma matriz de strings.

217
00:12:46,700 --> 00:12:50,960
Então, o que é uma string, mas
um conjunto de caracteres?

218
00:12:50,960 --> 00:12:57,140
Então isso significa que argv é realmente uma
de uma matriz de caracteres.

219
00:12:57,140 --> 00:13:04,920
Então, aproveitando que,
vamos ignorar isso por enquanto.

220
00:13:04,920 --> 00:13:08,190
Vamos considerar apenas a string argv 0.

221
00:13:08,190 --> 00:13:14,170
>> Portanto, se queremos trazer cada personagem de
argv 0 em sua própria linha, então eu quero

222
00:13:14,170 --> 00:13:19,500
de fazer o padrão que estamos acostumados a, i é
menos do que o comprimento da matriz,

223
00:13:19,500 --> 00:13:23,990
que aqui, é de strlen, isso é
não o que eu quero fazer, corda

224
00:13:23,990 --> 00:13:26,450
s é igual a 0 argv.

225
00:13:26,450 --> 00:13:30,390
Assim, i é inferior ao comprimento do nosso
matriz, que neste caso é uma matriz

226
00:13:30,390 --> 00:13:34,410
de caracteres, i plus plus.

227
00:13:34,410 --> 00:13:41,040
E assim, como vimos na semana passada, é ideal
se mover que strlen fora

228
00:13:41,040 --> 00:13:45,210
da condição, uma vez que n vai adicionar
o strlen de s cada vez que vamos

229
00:13:45,210 --> 00:13:47,720
através do laço, e é
não vai estar mudando.

230
00:13:47,720 --> 00:13:50,230
Então, vamos defini-lo igual a n aqui.

231
00:13:50,230 --> 00:13:54,260

232
00:13:54,260 --> 00:13:55,170
>> OK.

233
00:13:55,170 --> 00:14:01,320
Então, agora, nós estamos interagindo sobre
cada índice do array.

234
00:14:01,320 --> 00:14:05,630
E assim, se queremos imprimir cada
caráter nesse array, cento c é

235
00:14:05,630 --> 00:14:06,880
a bandeira que queremos usar
para os personagens.

236
00:14:06,880 --> 00:14:10,750

237
00:14:10,750 --> 00:14:19,770
E agora eu suporte vai ser o
corda, personagem índice i, por isso, se o

238
00:14:19,770 --> 00:14:20,970
corda foram Olá.

239
00:14:20,970 --> 00:14:27,530
então s 0 vai ser h, s suporte
1 e será, e assim por diante.

240
00:14:27,530 --> 00:14:30,800
>> Então, agora queremos combinar
essas duas coisas.

241
00:14:30,800 --> 00:14:35,440
Queremos imprimir cada personagem
de cada argumento de linha de comando.

242
00:14:35,440 --> 00:14:38,950
Então, nós vamos ter
um aninhados para loop.

243
00:14:38,950 --> 00:14:47,480
E convencionalmente, o primeiro contador
é i, o próximo vai ser j, n

244
00:14:47,480 --> 00:14:54,450
será o strlen de argv i, i
é menor do que n, i, mais além.

245
00:14:54,450 --> 00:14:59,150

246
00:14:59,150 --> 00:15:06,870
E agora em vez de imprimir argv i, então
argv suporte i vai para o índice -

247
00:15:06,870 --> 00:15:14,280
que vai ser a linha de comando i-th
argumento, argv i, j vai

248
00:15:14,280 --> 00:15:16,925
ser o personagem de jth
o argumento de i-th.

249
00:15:16,925 --> 00:15:20,580

250
00:15:20,580 --> 00:15:24,810
Vou me livrar desse aqui agora
uma vez que colocá-lo em que loop.

251
00:15:24,810 --> 00:15:33,900
Então, é equivalente a iguais string s
argv i, e, em seguida, s suporte j.

252
00:15:33,900 --> 00:15:36,980
>> Bem, não precisa declarar
este s variável.

253
00:15:36,980 --> 00:15:44,530
Em vez disso, vamos combinar estes
dois em o que tínhamos, argv i, j.

254
00:15:44,530 --> 00:15:45,780
>> Speaker 1: [inaudível].

255
00:15:45,780 --> 00:15:48,850

256
00:15:48,850 --> 00:15:49,680
>> ROB BODEN: Boa chamada.

257
00:15:49,680 --> 00:15:52,936
Portanto, este é quebrado.

258
00:15:52,936 --> 00:15:55,510
Se eu realmente correu, teríamos
já perceberam isso.

259
00:15:55,510 --> 00:16:01,210
Assim, o contador que me interessa
neste particular, para

260
00:16:01,210 --> 00:16:05,410
loop é j, o iterador.

261
00:16:05,410 --> 00:16:08,560
Então você teria corrido em questões,
provavelmente um loop infinito, se nós

262
00:16:08,560 --> 00:16:09,540
Não tinha fixado que.

263
00:16:09,540 --> 00:16:12,220
É por isso que também estamos falando
sobre depuração de hoje.

264
00:16:12,220 --> 00:16:13,120
>> OK.

265
00:16:13,120 --> 00:16:15,240
Então, vamos executar este programa.

266
00:16:15,240 --> 00:16:21,200
E vamos realmente adicionar um printf separado
aqui que só vai imprimir

267
00:16:21,200 --> 00:16:27,480
uma outra linha, uma vez que isso significa que quando
executar o programa, haverá um espaço em branco

268
00:16:27,480 --> 00:16:31,830
linha entre cada personagem do
cada argumento de linha de comando.

269
00:16:31,830 --> 00:16:33,448
Bem, vamos ver o que isso significa.

270
00:16:33,448 --> 00:16:37,310

271
00:16:37,310 --> 00:16:37,790
Oop.

272
00:16:37,790 --> 00:16:39,870
Tem algum bug.

273
00:16:39,870 --> 00:16:42,860
Erro implicitamente declarando
função de biblioteca strlen.

274
00:16:42,860 --> 00:16:51,630
>> Então, voltando para o nosso programa, eu
esqueci de botar incluem string.h.

275
00:16:51,630 --> 00:16:54,240

276
00:16:54,240 --> 00:16:57,730
Então string.h vai ser o
arquivo de cabeçalho que declara

277
00:16:57,730 --> 00:16:58,980
a função strlen.

278
00:16:58,980 --> 00:17:04,650

279
00:17:04,650 --> 00:17:06,060
OK, ele compila.

280
00:17:06,060 --> 00:17:09,109
Agora, vamos executá-lo.

281
00:17:09,109 --> 00:17:10,930
Então, só isso.

282
00:17:10,930 --> 00:17:17,790
Vai imprimir a nossa
nome do programa, Olá mundo.

283
00:17:17,790 --> 00:17:23,510
Vai imprimir cada coisa, cada um
personagem, em sua própria linha.

284
00:17:23,510 --> 00:17:24,540
OK.

285
00:17:24,540 --> 00:17:30,625
>> Então, vamos realmente tomar esta
um passo adiante.

286
00:17:30,625 --> 00:17:34,050

287
00:17:34,050 --> 00:17:39,700
E em vez de usar string.h, vamos
pensar sobre como iríamos implementar nossa própria

288
00:17:39,700 --> 00:17:41,420
função strlen.

289
00:17:41,420 --> 00:17:45,600
Então, eu vou dar imediatamente
a assinatura da função.

290
00:17:45,600 --> 00:17:52,900
Então, vamos chamar my_strlen, e é
vai levar uma string como argumento,

291
00:17:52,900 --> 00:17:57,220
e esperamos para voltar a
comprimento dessa corda.

292
00:17:57,220 --> 00:18:03,430
Então, onde é esse cara?

293
00:18:03,430 --> 00:18:04,990
Sim.

294
00:18:04,990 --> 00:18:06,740
OK.

295
00:18:06,740 --> 00:18:12,900
Então lembre-se a partir do slide anterior que
Foi também a partir da semana passada, que um

296
00:18:12,900 --> 00:18:18,890
array de caracteres, bem, uma string,
então vamos dizer que esta é a nossa cadeia s.

297
00:18:18,890 --> 00:18:29,870
Portanto, se s é a string, Olá, então,
H-E-L-L-O, na memória, que vai

298
00:18:29,870 --> 00:18:35,610
ser, em seguida, esta barra invertida
0 caráter.

299
00:18:35,610 --> 00:18:39,170
>> Então, como podemos obter o comprimento de s?

300
00:18:39,170 --> 00:18:43,190
Bem, o truque é olhar para este
repercutiria 0 personagem, este nulo

301
00:18:43,190 --> 00:18:44,380
terminator.

302
00:18:44,380 --> 00:18:50,270
Assim, o algoritmo Vai
para ser algo como poucos

303
00:18:50,270 --> 00:18:51,510
caracteres suficientes que -

304
00:18:51,510 --> 00:18:56,180
vamos ter esta mão representam alguns
contador, vamos chamar isso de comprimento int.

305
00:18:56,180 --> 00:19:00,060
Assim, a partir de aqui, nós somos
vai interagir sobre nossa string.

306
00:19:00,060 --> 00:19:04,100
>> Assim, o primeiro personagem, é H,
e ele não está de volta reduzir 0, portanto,

307
00:19:04,100 --> 00:19:05,170
o comprimento é 1.

308
00:19:05,170 --> 00:19:08,050
Iterate para o próximo caractere,
E, e não é barra invertida 0.

309
00:19:08,050 --> 00:19:09,630
O comprimento é 2.

310
00:19:09,630 --> 00:19:10,960
G, 3.

311
00:19:10,960 --> 00:19:11,850
L, 4.

312
00:19:11,850 --> 00:19:13,050
Ó, 5.

313
00:19:13,050 --> 00:19:16,690
E, finalmente, chegamos a barra invertida
0, e assim que isso significa, também,

314
00:19:16,690 --> 00:19:17,780
esta string é longo.

315
00:19:17,780 --> 00:19:20,130
Então, vamos voltar 5.

316
00:19:20,130 --> 00:19:33,630
>> Então, na verdade, a implementação que, em primeiro lugar,
meu comprimento n é igual a 0, a minha mão direita.

317
00:19:33,630 --> 00:19:36,088
E vamos fazer uma iteração -

318
00:19:36,088 --> 00:19:38,000
>> COLUNA 1: [inaudível]

319
00:19:38,000 --> 00:19:38,640
>> ROB BODEN: Oh, atirar.

320
00:19:38,640 --> 00:19:39,870
Boa chamada.

321
00:19:39,870 --> 00:19:42,680
Lança.

322
00:19:42,680 --> 00:19:44,140
Assim, o comprimento n igual a 0.

323
00:19:44,140 --> 00:19:46,910

324
00:19:46,910 --> 00:19:58,310
Então, agora, comprimento, enquanto S não
igual e, em seguida, barra invertida 0.

325
00:19:58,310 --> 00:20:04,660
Então lembre-se, esta barra invertida 0, é uma
personagem real, e indica

326
00:20:04,660 --> 00:20:05,820
o fim da string.

327
00:20:05,820 --> 00:20:09,850
Assim como, também, de barra invertida
n é um personagem real.

328
00:20:09,850 --> 00:20:14,040
Barra invertida 0 vai para indicar
o fim da nossa string.

329
00:20:14,040 --> 00:20:15,414
Eu não quero colocar isso lá.

330
00:20:15,414 --> 00:20:19,190

331
00:20:19,190 --> 00:20:25,620
E enquanto s indexados pelo comprimento não é
igual ao terminador nulo, então

332
00:20:25,620 --> 00:20:27,130
nós apenas estamos indo para incrementar comprimento.

333
00:20:27,130 --> 00:20:29,860

334
00:20:29,860 --> 00:20:34,880
Então, no final do nosso programa,
comprimento é, eventualmente, vai

335
00:20:34,880 --> 00:20:37,610
5 ser neste caso.

336
00:20:37,610 --> 00:20:39,210
E nós vamos comprimento basta retornar.

337
00:20:39,210 --> 00:20:42,570

338
00:20:42,570 --> 00:20:43,530
>> OK.

339
00:20:43,530 --> 00:20:48,290
Então, agora aqui, eu não
fazer my_strlen.

340
00:20:48,290 --> 00:20:50,700
Vamos compilá-lo para certificar-se
tudo corra bem.

341
00:20:50,700 --> 00:20:55,820

342
00:20:55,820 --> 00:20:58,210
Eu estava fazendo em 2?

343
00:20:58,210 --> 00:21:00,565
Ou foi um?

344
00:21:00,565 --> 00:21:01,940
Isso deve fazer.

345
00:21:01,940 --> 00:21:02,690
Tudo bem.

346
00:21:02,690 --> 00:21:08,490
Portanto, esta é argv 2.

347
00:21:08,490 --> 00:21:11,585
Funciona como previsto, embora
foi a de que o que eu fiz isso em?

348
00:21:11,585 --> 00:21:15,060

349
00:21:15,060 --> 00:21:15,550
Sim.

350
00:21:15,550 --> 00:21:16,760
OK.

351
00:21:16,760 --> 00:21:21,820
Esta versão das coisas que não tinha
a nova linha printf depois, mas

352
00:21:21,820 --> 00:21:22,910
não faz qualquer diferença.

353
00:21:22,910 --> 00:21:23,300
OK.

354
00:21:23,300 --> 00:21:25,780
Assim funcionou como esperado.

355
00:21:25,780 --> 00:21:34,750
>> Agora podemos até combinar um passo
mais longe, onde aviso aqui, bem,

356
00:21:34,750 --> 00:21:38,920
primeiro, nós estamos pegando o strlen de argv
i, e então nós estamos iterando

357
00:21:38,920 --> 00:21:41,450
cada personagem nessa string.

358
00:21:41,450 --> 00:21:47,480
Então, ao invés de fazer isso, o que se
apenas combinar essa lógica de esperar

359
00:21:47,480 --> 00:21:50,740
até chegarmos barra invertida 0 direito
neste loop for?

360
00:21:50,740 --> 00:21:53,740

361
00:21:53,740 --> 00:22:07,490
Então iteração enquanto argv i, j faz
não é igual barra invertida 0.

362
00:22:07,490 --> 00:22:10,680
Então, vamos executá-lo pela primeira vez.

363
00:22:10,680 --> 00:22:19,838

364
00:22:19,838 --> 00:22:21,180
>> Tudo bem.

365
00:22:21,180 --> 00:22:27,655
Então, aqui, esta condição está dizendo -

366
00:22:27,655 --> 00:22:38,090

367
00:22:38,090 --> 00:22:40,060
vamos esclarecer isso.

368
00:22:40,060 --> 00:22:49,140
Então, agora, que este seja o nosso argv.

369
00:22:49,140 --> 00:22:55,290
Então, quando eu apenas corri esse programa antes,
argv é uma matriz de strings.

370
00:22:55,290 --> 00:23:03,100
E assim, se eu executá-lo com um ponto argv barra
2, Olá mundo, então o argv

371
00:23:03,100 --> 00:23:07,650
si é comprimento 3, para argv
zero, Olá, e mundo.

372
00:23:07,650 --> 00:23:11,700

373
00:23:11,700 --> 00:23:19,660
>> E no interior de cada um destes índices é,
também uma matriz, onde esta vai ser

374
00:23:19,660 --> 00:23:23,780
ponto, isso vai ser barra, eu não sei
se essa era a direção certa, eu

375
00:23:23,780 --> 00:23:25,680
Não acho que era.

376
00:23:25,680 --> 00:23:30,110
A-R-V traço, precisa de mais espaço.

377
00:23:30,110 --> 00:23:32,570
Vamos cortar a esta matriz.

378
00:23:32,570 --> 00:23:38,230
Traço 0 e barra invertida 0 A-R-V.

379
00:23:38,230 --> 00:23:43,160
E então em desordem será Olá.

380
00:23:43,160 --> 00:23:45,910
Digamos, H-E barra invertida 0.

381
00:23:45,910 --> 00:23:51,130
E, finalmente, o W-O invertida 0.

382
00:23:51,130 --> 00:23:59,730
>> Assim, o algoritmo que acabou de escrever,
o aninhados para loops, o que eles estão

383
00:23:59,730 --> 00:24:07,321
fazendo é, primeiro temos o
contador i e, em seguida, j.

384
00:24:07,321 --> 00:24:15,206
Isto seria mais fácil com o código do
tela, Vamos voltar a isso.

385
00:24:15,206 --> 00:24:17,476
OK.

386
00:24:17,476 --> 00:24:24,600
Então percebe que i é o iterador que é
iteração sobre cada comando

387
00:24:24,600 --> 00:24:25,610
argumento de linha.

388
00:24:25,610 --> 00:24:28,870
E j é a iteração iterador
sobre cada personagem em que

389
00:24:28,870 --> 00:24:30,410
argumento de linha de comando.

390
00:24:30,410 --> 00:24:46,755
Então, o que este printf íntimo está fazendo
é, temos printf argv 0 0, printf

391
00:24:46,755 --> 00:24:58,680
argv 0 1, printf argv 0 2 0 3 0 4, 0
5, 0 6, mas agora, argv 0 7 vai

392
00:24:58,680 --> 00:25:00,670
igual barra invertida 0.

393
00:25:00,670 --> 00:25:05,730
>> Então saímos para que loop,
e agora eu repete a 1.

394
00:25:05,730 --> 00:25:10,910
E agora nós estamos indo para impressão
argv 1 0, argv 1 1 -

395
00:25:10,910 --> 00:25:17,040
bem, agora, uma vez que eu cortei Olá suma,
argv 1 2 é novamente será

396
00:25:17,040 --> 00:25:18,170
barra invertida 0.

397
00:25:18,170 --> 00:25:25,050
E assim, incrementar i e continuar, e
assim por diante, até que imprimir todos

398
00:25:25,050 --> 00:25:28,580
mundo, e essas são três de linha de comando
argumentos, e nós vamos sair do

399
00:25:28,580 --> 00:25:31,670
o circuito externo, e
terminar nosso programa.

400
00:25:31,670 --> 00:25:38,390

401
00:25:38,390 --> 00:25:39,640
OK.

402
00:25:39,640 --> 00:25:43,903

403
00:25:43,903 --> 00:25:46,795
>> Então, vamos voltar aqui.

404
00:25:46,795 --> 00:25:49,670

405
00:25:49,670 --> 00:25:52,370
Então, você vai ganhar alguma familiaridade com
argumentos de linha de comando nesta

406
00:25:52,370 --> 00:25:54,460
determinado conjunto de problemas.

407
00:25:54,460 --> 00:25:56,630
>> Agora, a depuração.

408
00:25:56,630 --> 00:26:01,680
Então, provavelmente você já teve que fazer
alguma depuração com o seu anterior

409
00:26:01,680 --> 00:26:03,120
conjunto de problemas.

410
00:26:03,120 --> 00:26:08,420
E uma maneira muito fácil de depuração,
em primeiro lugar, vamos olhar para um programa de buggy.

411
00:26:08,420 --> 00:26:20,710

412
00:26:20,710 --> 00:26:23,830
Bem, andando por este programa,
vamos pedir ao usuário para um

413
00:26:23,830 --> 00:26:29,350
inteiro, pegue esse inteiro, e em seguida,
arbitrariamente, temos um loop while que

414
00:26:29,350 --> 00:26:32,280
é só ir a diminuir
i até que seja igual a 10.

415
00:26:32,280 --> 00:26:35,820
Vamos supor que eu estou entrando
um número inteiro maior do que 10.

416
00:26:35,820 --> 00:26:38,700
Então diminuir i até que seja igual a 10.

417
00:26:38,700 --> 00:26:42,630
>> E então nós temos um outro loop while
que, apesar de i não é igual a 0, estamos

418
00:26:42,630 --> 00:26:44,540
vai diminuir i por 3.

419
00:26:44,540 --> 00:26:49,790
Então, se você ver a intenção do bug
aqui, é que isso vai diminuir i para

420
00:26:49,790 --> 00:26:57,010
ser 10, e depois esta vontade loop while
decremento i de 10, a 7, a 4, a 1,

421
00:26:57,010 --> 00:27:02,880
a 2 negativo, para negativo 5, e assim por diante,
ao infinito negativo, uma vez que eu vou

422
00:27:02,880 --> 00:27:05,920
na verdade, nunca igual a 0.

423
00:27:05,920 --> 00:27:08,610
E depois, no final do presente programa,
que têm a função foo que é

424
00:27:08,610 --> 00:27:12,130
acontecendo impressão que eu.

425
00:27:12,130 --> 00:27:16,520
>> Portanto, este é um programa curto e trivial,
eo erro for óbvio,

426
00:27:16,520 --> 00:27:18,790
especialmente depois de eu
disse que o erro era.

427
00:27:18,790 --> 00:27:24,840
Mas a intenção aqui é, bem, este pode
realmente parecido com algumas de suas

428
00:27:24,840 --> 00:27:30,040
soluções de ávida da última
conjunto de problemas e, talvez, você tem

429
00:27:30,040 --> 00:27:32,800
algum loop infinito em seu programa,
e você não tem idéia

430
00:27:32,800 --> 00:27:34,100
o que está causando isso.

431
00:27:34,100 --> 00:27:38,690
Assim, uma técnica de depuração muito útil
é só adicionar printfs

432
00:27:38,690 --> 00:27:40,180
todo o seu código.

433
00:27:40,180 --> 00:27:49,200
>> Então, aqui eu quero um printf fora
primeiro loop while.

434
00:27:49,200 --> 00:27:53,155
E aqui eu quero um printf,
e eu vou imprimir i.

435
00:27:53,155 --> 00:27:55,670

436
00:27:55,670 --> 00:27:58,330
Eu mesmo vou fazer em primeiro lugar, enquanto loop, i.

437
00:27:58,330 --> 00:28:05,130

438
00:28:05,130 --> 00:28:09,040
Lá fora, segundo loop while.

439
00:28:09,040 --> 00:28:12,170
Mais uma vez, imprimir dentro
daqui, o valor i.

440
00:28:12,170 --> 00:28:16,270

441
00:28:16,270 --> 00:28:17,520
E vamos executar este.

442
00:28:17,520 --> 00:28:22,620

443
00:28:22,620 --> 00:28:24,800
>> Debug barra Assim ponto.

444
00:28:24,800 --> 00:28:25,610
Digite um número inteiro.

445
00:28:25,610 --> 00:28:28,150
Vamos fazer 13.

446
00:28:28,150 --> 00:28:28,760
E boom.

447
00:28:28,760 --> 00:28:33,300
Vemos que estamos loop infinito
dentro do segundo circuito, enquanto.

448
00:28:33,300 --> 00:28:36,305
Portanto, agora sabemos qual é o erro.

449
00:28:36,305 --> 00:28:39,610

450
00:28:39,610 --> 00:28:45,610
Mas printf depuração é perfeitamente grande,
mas uma vez que os seus programas de obter

451
00:28:45,610 --> 00:28:50,560
mais longo e complicado, existem
soluções mais sofisticadas para

452
00:28:50,560 --> 00:28:51,705
fazer as coisas funcionando.

453
00:28:51,705 --> 00:28:52,955
Portanto, vamos remover todas essas printfs.

454
00:28:52,955 --> 00:29:06,242

455
00:29:06,242 --> 00:29:08,896
E vamos ter certeza que eu não fiz
quebrar nada.

456
00:29:08,896 --> 00:29:09,850
OK.

457
00:29:09,850 --> 00:29:14,180
>> Assim, o programa que vamos
introduzir é chamado

458
00:29:14,180 --> 00:29:16,715
GDB, para o GNU Debugger.

459
00:29:16,715 --> 00:29:21,892

460
00:29:21,892 --> 00:29:27,510
Bem, na verdade, vamos remover depuração para
um segundo, e fazer debug de novo.

461
00:29:27,510 --> 00:29:31,420

462
00:29:31,420 --> 00:29:34,440
Bem, na verdade em primeiro lugar, uma boa lição
em argumentos de linha de comando.

463
00:29:34,440 --> 00:29:37,780
Observe que este comando Clang que é
compilando tudo está sendo passado

464
00:29:37,780 --> 00:29:41,300
na linha de comando, estes
Argumentos da linha de comando.

465
00:29:41,300 --> 00:29:46,250
Então, exatamente como você está indo estar usando
argumentos de linha de comando, como nós

466
00:29:46,250 --> 00:29:51,500
fez antes, e como você vai em PSET
2, que é como Clang é usá-los.

467
00:29:51,500 --> 00:30:00,070
>> Então, observe que esta primeira bandeira, traço
ggdb3, o que está dizendo é que, Clang,

468
00:30:00,070 --> 00:30:03,790
você deve compilar este arquivo com o
intenção que acabará

469
00:30:03,790 --> 00:30:05,380
precisa depurá-lo.

470
00:30:05,380 --> 00:30:13,840
Então, enquanto você tem essa bandeira,
então podemos GDB depuração.

471
00:30:13,840 --> 00:30:17,380
E vai abrir o depurador GNU.

472
00:30:17,380 --> 00:30:22,920
>> Portanto, há um monte de comandos
que você precisa para se acostumar.

473
00:30:22,920 --> 00:30:27,100
Primeiro que você provavelmente vai
imediatamente precisamos é Executar.

474
00:30:27,100 --> 00:30:28,200
Então o que está Executar vai fazer?

475
00:30:28,200 --> 00:30:30,910
Vai começar o nosso programa.

476
00:30:30,910 --> 00:30:36,180
Então corra, o programa de partida, o programa de
pede-nos para um inteiro de 13.

477
00:30:36,180 --> 00:30:39,170
E então é infinito looping como
esperado, exceto eu removi o

478
00:30:39,170 --> 00:30:40,500
printfs, por isso nem sequer ver isso.

479
00:30:40,500 --> 00:30:43,320

480
00:30:43,320 --> 00:30:44,600
Saiu normalmente.

481
00:30:44,600 --> 00:30:45,850
Oh.

482
00:30:45,850 --> 00:30:48,570

483
00:30:48,570 --> 00:30:53,640
É possível que ele envolveu toda a
volta, volta para - ignorando isso.

484
00:30:53,640 --> 00:30:55,170
Suponha que não sair normalmente.

485
00:30:55,170 --> 00:30:59,500

486
00:30:59,500 --> 00:31:03,370
Há uma resposta complicada para isso.

487
00:31:03,370 --> 00:31:07,890
>> Então, agora, que não é muito útil.

488
00:31:07,890 --> 00:31:11,480
Então, basta executar o nosso programa no interior de
este depurador não nos ajuda em qualquer

489
00:31:11,480 --> 00:31:15,610
forma, uma vez que poderia ter feito
dot cortar depuração de fora GDB.

490
00:31:15,610 --> 00:31:21,250
Assim, o comando que
você provavelmente vai -

491
00:31:21,250 --> 00:31:22,970
e eu vou sair desta.

492
00:31:22,970 --> 00:31:25,850
Control-d ou sair, tanto trabalho.

493
00:31:25,850 --> 00:31:29,550
Então, vamos abri-lo novamente.

494
00:31:29,550 --> 00:31:31,130
>> Outro comando que você, provavelmente,
quer imediatamente para

495
00:31:31,130 --> 00:31:33,600
habituar-se é Break.

496
00:31:33,600 --> 00:31:37,120
Então, vamos quebrar a principal, por agora,
e então eu vou explicar isso.

497
00:31:37,120 --> 00:31:41,010

498
00:31:41,010 --> 00:31:46,370
Bem, aqui nós vemos que definir um ponto de interrupção
nesta linha em debug.c.

499
00:31:46,370 --> 00:31:50,160
Então, o que significa quebra é que quando eu
tipo de execução, o programa vai

500
00:31:50,160 --> 00:31:53,560
continuar a funcionar até
Eu bati um ponto de interrupção.

501
00:31:53,560 --> 00:31:59,390
Então, quando eu bati prazo, o programa é iniciado,
e depois se rompe, logo que ele

502
00:31:59,390 --> 00:32:01,940
entra a função principal.

503
00:32:01,940 --> 00:32:06,930
Quebre principal vai ser algo
você muito comumente fazem.

504
00:32:06,930 --> 00:32:11,340
>> E agora, para apresentá-lo
para mais alguns comandos.

505
00:32:11,340 --> 00:32:14,330
Observe aqui, que ele está dizendo que
quebraram na linha 11, que é

506
00:32:14,330 --> 00:32:16,230
printf, insira um número inteiro.

507
00:32:16,230 --> 00:32:21,260
Assim, o comando seguinte vai ser como
vamos para a próxima linha de código.

508
00:32:21,260 --> 00:32:24,810
Isso vai permitir-nos para a etapa
através da nossa linha de programa por linha.

509
00:32:24,810 --> 00:32:26,260
Assim, na próxima.

510
00:32:26,260 --> 00:32:29,820
>> Agora a linha 12, nós vamos
para obter o número inteiro.

511
00:32:29,820 --> 00:32:30,450
Avançar.

512
00:32:30,450 --> 00:32:34,290
E se você apenas pressione Enter novamente, ele vai
refazer a última coisa que você fez.

513
00:32:34,290 --> 00:32:36,480
Então eu não preciso digitar
ao lado de cada vez.

514
00:32:36,480 --> 00:32:40,100
Então, insira um número inteiro de 13.

515
00:32:40,100 --> 00:32:46,940
Então, agora, linha 14, enquanto i é maior
de 10, e eu vou fazer a seguir.

516
00:32:46,940 --> 00:32:48,685
E vemos que vamos diminuir i.

517
00:32:48,685 --> 00:32:50,210
Então, nós estamos indo para diminuir i novamente.

518
00:32:50,210 --> 00:32:53,620
>> Então, agora, outro útil
comando é Imprimir.

519
00:32:53,620 --> 00:32:55,750
Assim Imprimir está indo para imprimir
o valor da variável.

520
00:32:55,750 --> 00:32:57,825
Vamos trazer o valor
de i variável.

521
00:32:57,825 --> 00:32:58,705
Vamos imprimir i.

522
00:32:58,705 --> 00:33:00,910
Vai dizer que eu é 11.

523
00:33:00,910 --> 00:33:03,330
Agora nós Avançar novamente enquanto
i é maior do que 10.

524
00:33:03,330 --> 00:33:05,590
Então, eu ainda é maior do que
10, uma vez que tem 11 anos.

525
00:33:05,590 --> 00:33:06,920
i menos de menos.

526
00:33:06,920 --> 00:33:08,250
Vamos imprimir i novamente.

527
00:33:08,250 --> 00:33:10,950
Como esperado, ele tem 10 anos.

528
00:33:10,950 --> 00:33:12,510
>> Então, agora, ao lado.

529
00:33:12,510 --> 00:33:16,250
Ele vai voltar para a condição, i é
superior a 10, mas agora é i 10, de modo

530
00:33:16,250 --> 00:33:20,040
não é maior que 10, por isso, esperamos
que caia fora do loop while.

531
00:33:20,040 --> 00:33:22,220
E agora estamos abaixo dessa linha de código.

532
00:33:22,220 --> 00:33:28,750
E um outro comando, List, é só ir
para exibir o anterior eo próximo

533
00:33:28,750 --> 00:33:31,240
par de linhas de código, em
Caso você se perdeu.

534
00:33:31,240 --> 00:33:35,420
Então nós só saiu este loop while,
e agora nós entramos neste

535
00:33:35,420 --> 00:33:37,080
enquanto loop, linha 18.

536
00:33:37,080 --> 00:33:39,860
Assim, enquanto i não é igual a 0.

537
00:33:39,860 --> 00:33:46,570
E, em seguida, i é igual a i menos 3, e nós vamos
notar, este só vai continuar.

538
00:33:46,570 --> 00:33:48,270
E podemos imprimir i.

539
00:33:48,270 --> 00:33:49,990
>> Cada comando tem uma espécie de atalhos.

540
00:33:49,990 --> 00:33:51,720
Então p é curto para Imprimir.

541
00:33:51,720 --> 00:33:53,400
Então podemos p i.

542
00:33:53,400 --> 00:33:57,550
Basta manter segurando n,
ou continuar fazendo Avançar.

543
00:33:57,550 --> 00:33:58,340
Imprimir i novamente.

544
00:33:58,340 --> 00:34:00,380
Você vê agora é negativo 167.

545
00:34:00,380 --> 00:34:06,030
Então, isso vai durar para sempre, mas não
realmente para sempre, uma vez que você acabou de ver, é

546
00:34:06,030 --> 00:34:09,330
vai realmente acabar em algum momento.

547
00:34:09,330 --> 00:34:15,699
>> Assim que começa GDB.

548
00:34:15,699 --> 00:34:19,504
Mas vamos fazer mais uma coisa em GDB.

549
00:34:19,504 --> 00:34:20,754
Uh, depuração.

550
00:34:20,754 --> 00:34:23,540

551
00:34:23,540 --> 00:34:28,534
Assim, neste caso particular, o
loop infinito passou a ser dentro de

552
00:34:28,534 --> 00:34:30,050
a função principal.

553
00:34:30,050 --> 00:34:35,779
E, por enquanto, apenas aceitar que que eu sou
vai mover o ciclo infinito em

554
00:34:35,779 --> 00:34:37,029
a função foo.

555
00:34:37,029 --> 00:34:40,679

556
00:34:40,679 --> 00:34:43,730
Basta lembrar que, no final do presente
programa, bem, este era originalmente

557
00:34:43,730 --> 00:34:46,210
chamar foo, que era apenas
indo para imprimir i.

558
00:34:46,210 --> 00:34:51,880
Mas agora nós estamos chamando foo, que é
vai diminuir i até que seja 0, e

559
00:34:51,880 --> 00:34:54,548
em seguida, imprimir essa variável.

560
00:34:54,548 --> 00:34:55,469
OK.

561
00:34:55,469 --> 00:34:57,970
Guarde isso.

562
00:34:57,970 --> 00:35:00,175
Faça debug.

563
00:35:00,175 --> 00:35:03,310
E agora, gdb depuração.

564
00:35:03,310 --> 00:35:04,090
OK.

565
00:35:04,090 --> 00:35:10,580
>> Então, se eu apenas correr, então eu não vou
ser capaz de realmente passar por minha

566
00:35:10,580 --> 00:35:11,730
linha por linha do programa.

567
00:35:11,730 --> 00:35:19,820
Então, vamos quebrar a principal,
e digite prazo.

568
00:35:19,820 --> 00:35:28,160
Então, passar por isso, printf, insira
um inteiro, obter o número inteiro de 13.

569
00:35:28,160 --> 00:35:34,180

570
00:35:34,180 --> 00:35:37,490
Então, nós estamos indo para mantê-decremento
até i é maior do que 10.

571
00:35:37,490 --> 00:35:42,840
Então vamos a cair até o
while, e chegar à linha -

572
00:35:42,840 --> 00:35:44,364
Vamos abri-lo em uma janela separada.

573
00:35:44,364 --> 00:35:48,720

574
00:35:48,720 --> 00:35:53,300
Então, nós diminuída até que eu já não era
superior a 10, e então nós

575
00:35:53,300 --> 00:35:55,700
chamou a função, foo.

576
00:35:55,700 --> 00:36:01,340
>> Então o que aconteceu assim que eu bati
função foo, bem, eu liguei para foo, e

577
00:36:01,340 --> 00:36:04,030
então eu não tinha mais controle sobre o GDB.

578
00:36:04,030 --> 00:36:10,230
Assim, logo que eu bati seguida nesta linha,
coisas continuou até que isso aconteceu,

579
00:36:10,230 --> 00:36:12,400
onde o programa saiu quando -

580
00:36:12,400 --> 00:36:14,450
assumir que não existia eventualmente.

581
00:36:14,450 --> 00:36:16,390
Você viu uma pausa para um pouco embora.

582
00:36:16,390 --> 00:36:22,040
Então, por que eu perdi o controle sobre
o programa em que ponto?

583
00:36:22,040 --> 00:36:27,540
Bem, quando eu digito seguinte, que vai para
a próxima linha de código que literal

584
00:36:27,540 --> 00:36:28,850
será executado.

585
00:36:28,850 --> 00:36:35,950
Assim, após a linha 21, a próxima linha de código
que será executada é a linha 22,

586
00:36:35,950 --> 00:36:38,520
que é, saindo da principal.

587
00:36:38,520 --> 00:36:43,810
Então, eu não quero apenas ir
para a próxima linha de código.

588
00:36:43,810 --> 00:36:48,170
Eu quero ir para a função, foo,
e depois também percorrer

589
00:36:48,170 --> 00:36:49,830
essas linhas de código.

590
00:36:49,830 --> 00:36:53,726
>> Então, para isso, temos uma alternativa.

591
00:36:53,726 --> 00:36:56,770
Vamos parar com isso de novo.

592
00:36:56,770 --> 00:36:58,020
Quebre principal.

593
00:36:58,020 --> 00:37:00,520

594
00:37:00,520 --> 00:37:06,370
Uh, 1, next, next, 13, ao lado,
next, next, com cuidado,

595
00:37:06,370 --> 00:37:09,820
antes de bater linha foo.

596
00:37:09,820 --> 00:37:10,520
OK.

597
00:37:10,520 --> 00:37:13,700
>> Então, agora, estamos na linha 21,
onde chamamos foo.

598
00:37:13,700 --> 00:37:17,100
Nós não queremos que digitar próximo, uma vez que
só vai chamar a função foo, e

599
00:37:17,100 --> 00:37:18,710
ir para a próxima linha de código.

600
00:37:18,710 --> 00:37:20,840
O que queremos usar é Step.

601
00:37:20,840 --> 00:37:25,690
Portanto, há uma diferença entre a Passo
e no próximo, onde passo as etapas para o

602
00:37:25,690 --> 00:37:28,190
funcionar, e na próxima vai
sobre a função.

603
00:37:28,190 --> 00:37:32,830
Ele apenas executa a totalidade de
a função e continua indo.

604
00:37:32,830 --> 00:37:37,210
>> Então Passo vai trazer-nos
na função, foo.

605
00:37:37,210 --> 00:37:41,160
E vemos aqui, agora, estamos de volta ao
esse loop while que é, em teoria,

606
00:37:41,160 --> 00:37:44,190
vai continuar para sempre.

607
00:37:44,190 --> 00:37:50,420
E se você bater Step, quando não é mesmo
uma função para chamar, então é

608
00:37:50,420 --> 00:37:51,720
idêntica à seguida.

609
00:37:51,720 --> 00:37:55,320
Então, é só quando você está em uma linha que
está chamando uma função que o passo

610
00:37:55,320 --> 00:37:56,970
vai diferir em Avançar.

611
00:37:56,970 --> 00:37:57,930
Então Passo vai nos trazer aqui.

612
00:37:57,930 --> 00:38:02,100
Passo, passo, passo, passo, passo, passo, e
vamos Infinite Loop para sempre.

613
00:38:02,100 --> 00:38:06,810
>> Então, você pode se acostumar com isso como sua
maneira de identificar loops infinitos, é

614
00:38:06,810 --> 00:38:08,960
apenas segurando esta tecla Enter para
ver onde você ficar preso.

615
00:38:08,960 --> 00:38:11,610

616
00:38:11,610 --> 00:38:14,780
Há maneiras melhores de fazer isso, mas
por enquanto, isso é perfeitamente suficiente.

617
00:38:14,780 --> 00:38:17,967
E estilisticamente, em conformidade com Estilo
50, eu deveria ter feito isso.

618
00:38:17,967 --> 00:38:21,550

619
00:38:21,550 --> 00:38:24,030
OK.

620
00:38:24,030 --> 00:38:28,400
>> Então, um último comando a introduzir.

621
00:38:28,400 --> 00:38:30,810
Bem, vamos gdb debug dentro

622
00:38:30,810 --> 00:38:35,580
Então, ao invés de quebrar a principal, se eu
conhecer a função foo é também o

623
00:38:35,580 --> 00:38:39,230
problema, então eu poderia ter apenas
disse, quebrar a foo, em seu lugar.

624
00:38:39,230 --> 00:38:42,310
Vamos dizer que eu quebrar a
ambos principal e foo.

625
00:38:42,310 --> 00:38:45,390
Assim, você pode definir como muitos pontos de interrupção
como você quer.

626
00:38:45,390 --> 00:38:49,230
Quando eu digito prazo, que vai
parar na -

627
00:38:49,230 --> 00:38:52,180
ooh, vamos recompilar, desde
Eu mudei as coisas.

628
00:38:52,180 --> 00:38:55,950
Você verá esta linha, Aviso fonte
arquivo é mais recente do que executável.

629
00:38:55,950 --> 00:38:59,680
Então isso significa que eu só fui aqui
e mudou-los para estar de acordo com Estilo

630
00:38:59,680 --> 00:39:03,100
50, mas eu não recompilar
o programa.

631
00:39:03,100 --> 00:39:04,870
Então GDB me faz consciente disso.

632
00:39:04,870 --> 00:39:10,130
Eu vou parar de fumar, fazer debug de novo,
bater gdb depuração.

633
00:39:10,130 --> 00:39:10,700
OK.

634
00:39:10,700 --> 00:39:12,800
>> Então, agora, voltar ao que eu estava fazendo.

635
00:39:12,800 --> 00:39:15,720
Quebre principal, foo pausa.

636
00:39:15,720 --> 00:39:20,680
Agora, se eu executar o programa, por isso é
vai continuar até que atinge uma

637
00:39:20,680 --> 00:39:21,320
breakpoint.

638
00:39:21,320 --> 00:39:24,680
Essa interrupção acontece a
ser o primeiro a principal.

639
00:39:24,680 --> 00:39:28,630
Agora, em vez de fazer next, next, next,
next, next, até que eu bati foo, eu

640
00:39:28,630 --> 00:39:35,230
pode escrever continuar, que continuará
até chegar ao próximo ponto de interrupção.

641
00:39:35,230 --> 00:39:37,200
Eu tenho que entrar no primeiro número inteiro.

642
00:39:37,200 --> 00:39:40,570
Continuar continuará até que eu bati o
próximo ponto de interrupção, o que é que

643
00:39:40,570 --> 00:39:43,320
função de foo.

644
00:39:43,320 --> 00:39:50,130
>> Então Run será executado até que você bata um
breakpoint, mas você só digitar run quando

645
00:39:50,130 --> 00:39:54,060
você está começando o programa, e em seguida,
a partir de então, é continuar.

646
00:39:54,060 --> 00:40:01,950
Se eu só fiz quebrar principal e
em seguida, correu, ele vai quebrar a

647
00:40:01,950 --> 00:40:03,670
principal, e em seguida continuar.

648
00:40:03,670 --> 00:40:10,050
Desde que eu não tenho um ponto de ruptura em foo,
inserir o número inteiro, então agora eu estou

649
00:40:10,050 --> 00:40:11,380
não vai quebrar a foo.

650
00:40:11,380 --> 00:40:16,318
É só ir ao infinito
loop até que.

651
00:40:16,318 --> 00:40:17,568
OK.

652
00:40:17,568 --> 00:40:19,500

653
00:40:19,500 --> 00:40:24,420
>> Então, isso é Introdução à GDB.

654
00:40:24,420 --> 00:40:27,790
Você deve começar a usá-lo
em seus conjuntos de problemas.

655
00:40:27,790 --> 00:40:30,550
Pode ser muito útil
para identificar bugs.

656
00:40:30,550 --> 00:40:35,280
Se você realmente apenas, linha por linha, vá
através de seu código, e comparar o que é

657
00:40:35,280 --> 00:40:39,740
realmente acontecendo com o que você espera
acontecer, então é muito

658
00:40:39,740 --> 00:40:41,060
difícil perder seus bugs.

659
00:40:41,060 --> 00:40:45,280

660
00:40:45,280 --> 00:40:46,530
OK.

661
00:40:46,530 --> 00:40:48,310

662
00:40:48,310 --> 00:40:54,040
>> Então, na semana passada, David trouxe presente
coisas criptografia de chave secreta para o

663
00:40:54,040 --> 00:40:59,350
primeira vez, onde nós não queremos
senhas apenas ser armazenado em nosso

664
00:40:59,350 --> 00:41:03,210
computador em algum arquivo de texto simples, onde
alguém pode vir e apenas

665
00:41:03,210 --> 00:41:04,660
abri-lo e lê-los.

666
00:41:04,660 --> 00:41:07,530
Idealmente, eles seriam criptografados
de algum modo.

667
00:41:07,530 --> 00:41:13,340
E no Conjunto de Problemas 2, você estará lidando
com um método de criptografia,

668
00:41:13,340 --> 00:41:16,520
ou, bem, dois métodos, mas
eles não são tão grandes.

669
00:41:16,520 --> 00:41:20,050
Se você fizer a edição hacker, você está
também vai estar lidando com

670
00:41:20,050 --> 00:41:22,150
descriptografar algumas coisas.

671
00:41:22,150 --> 00:41:29,770
>> Assim, a questão agora é, bem, mesmo se
temos a criptografia mais forte

672
00:41:29,770 --> 00:41:34,830
algoritmo do mundo, se você escolher um
particularmente pobre senha, então ele

673
00:41:34,830 --> 00:41:37,720
não vai ajudar muito, pois as pessoas
ainda será capaz de descobrir isso.

674
00:41:37,720 --> 00:41:41,530
Mesmo vendo a string encriptada e
ele se parece com uma confusão de lixo

675
00:41:41,530 --> 00:41:44,760
que não significa nada para eles, se eles
ainda só precisa tentar algumas senhas

676
00:41:44,760 --> 00:41:50,560
para descobrir isso, então você
não são muito seguros.

677
00:41:50,560 --> 00:41:55,890
Então, assistindo a um vídeo que
faz esse ponto.

678
00:41:55,890 --> 00:41:59,587

679
00:41:59,587 --> 00:42:00,970
>> [REPRODUÇÃO]

680
00:42:00,970 --> 00:42:02,100
>> -Helmet, você demônio.

681
00:42:02,100 --> 00:42:03,370
O que está acontecendo?

682
00:42:03,370 --> 00:42:05,170
O que você está fazendo com a minha filha?

683
00:42:05,170 --> 00:42:09,910
>> -Permita-me apresentar o brilhante
jovem cirurgião plástico, Dr. Phillip

684
00:42:09,910 --> 00:42:13,730
Schlotkin, o maior nariz
homem do trabalho em todo o

685
00:42:13,730 --> 00:42:16,080
universo, e Beverly Hills.

686
00:42:16,080 --> 00:42:17,210
>> -Sua Alteza.

687
00:42:17,210 --> 00:42:18,070
>> -Nariz trabalho?

688
00:42:18,070 --> 00:42:18,670
Não estou entendendo.

689
00:42:18,670 --> 00:42:20,090
Ela já tinha uma plástica no nariz.

690
00:42:20,090 --> 00:42:21,910
Era um doce dezesseis presente.

691
00:42:21,910 --> 00:42:22,140
>> -No.

692
00:42:22,140 --> 00:42:23,690
Não é o que você pensa.

693
00:42:23,690 --> 00:42:25,420
É muito, muito pior.

694
00:42:25,420 --> 00:42:30,300
Se você não me der a combinação de
o escudo do ar, Dr. Schlotkin vontade

695
00:42:30,300 --> 00:42:34,226
dar a sua filha de volta seu antigo nariz.

696
00:42:34,226 --> 00:42:35,476
>> -No.

697
00:42:35,476 --> 00:42:38,712

698
00:42:38,712 --> 00:42:40,516
De onde você tirou isso?

699
00:42:40,516 --> 00:42:41,440
>> -Tudo bem.

700
00:42:41,440 --> 00:42:42,180
Eu vou te dizer.

701
00:42:42,180 --> 00:42:43,381
Eu vou te dizer.

702
00:42:43,381 --> 00:42:44,263
Não, papai.

703
00:42:44,263 --> 00:42:45,590
Não, você não deve.

704
00:42:45,590 --> 00:42:46,860
>> -Você está bem, minha querida.

705
00:42:46,860 --> 00:42:48,450
Vou sentir falta de seu novo nariz.

706
00:42:48,450 --> 00:42:52,090
Mas eu não vou dizer-lhe a combinação,
não importa o que.

707
00:42:52,090 --> 00:42:53,680
>> -Muito bem.

708
00:42:53,680 --> 00:42:55,685
Dr. Schlotkin, faça o seu pior.

709
00:42:55,685 --> 00:42:56,914
>> -O prazer é meu.

710
00:42:56,914 --> 00:43:00,690
>> [TOOLS sendo afiadas]

711
00:43:00,690 --> 00:43:01,910
>> -No.

712
00:43:01,910 --> 00:43:02,520
Espere.

713
00:43:02,520 --> 00:43:03,836
Espere.

714
00:43:03,836 --> 00:43:05,300
Eu vou te dizer.

715
00:43:05,300 --> 00:43:06,880
Eu vou te dizer.

716
00:43:06,880 --> 00:43:09,130
>> -Eu sabia que ele iria trabalhar.

717
00:43:09,130 --> 00:43:09,900
Tudo bem.

718
00:43:09,900 --> 00:43:12,850
Dê-me isso.

719
00:43:12,850 --> 00:43:16,918
>> -A combinação é um.

720
00:43:16,918 --> 00:43:17,406
>> -One.

721
00:43:17,406 --> 00:43:18,382
>> -One.

722
00:43:18,382 --> 00:43:19,358
>> -Two.

723
00:43:19,358 --> 00:43:19,846
>> -Two.

724
00:43:19,846 --> 00:43:20,822
>> -Two.

725
00:43:20,822 --> 00:43:21,310
>> -Três.

726
00:43:21,310 --> 00:43:21,798
>> -Três.

727
00:43:21,798 --> 00:43:22,774
>> -Três.

728
00:43:22,774 --> 00:43:23,262
>> -Quatro.

729
00:43:23,262 --> 00:43:23,750
>> -Quatro.

730
00:43:23,750 --> 00:43:26,150
>> -Quatro.

731
00:43:26,150 --> 00:43:27,010
>> -Five.

732
00:43:27,010 --> 00:43:27,670
>> -Five.

733
00:43:27,670 --> 00:43:29,010
>> -Five.

734
00:43:29,010 --> 00:43:34,770
>> -Assim, a combinação é um,
dois, três, quatro, cinco.

735
00:43:34,770 --> 00:43:37,460
Essa é a combinação mais estúpida
Que eu já ouvi na minha vida.

736
00:43:37,460 --> 00:43:39,710
Esse é o tipo de coisa que um idiota
teria em sua bagagem.

737
00:43:39,710 --> 00:43:42,000
>> -Obrigado, sua Alteza.

738
00:43:42,000 --> 00:43:43,530
>> -O que você fez?

739
00:43:43,530 --> 00:43:44,490
>> -Eu desliguei a parede.

740
00:43:44,490 --> 00:43:45,420
>> -Não, você não fez.

741
00:43:45,420 --> 00:43:45,840
Você desligou o filme inteiro.

742
00:43:45,840 --> 00:43:46,930
>> -Devo ter apertado o botão errado.

743
00:43:46,930 --> 00:43:48,265
>> -Bem, colocá-lo novamente.

744
00:43:48,265 --> 00:43:49,110
Coloque o filme novamente.

745
00:43:49,110 --> 00:43:49,510
>> -Sim, senhor.

746
00:43:49,510 --> 00:43:49,917
Sim, senhor.

747
00:43:49,917 --> 00:43:50,324
>> -Vamos, Arnold.

748
00:43:50,324 --> 00:43:51,140
Venha, Gretchen.

749
00:43:51,140 --> 00:43:53,060
Claro, você sabe que eu ainda vou
tem que cobrá-lo por isso.

750
00:43:53,060 --> 00:43:53,440
>> [FIM REPRODUÇÃO DE VÍDEO]

751
00:43:53,440 --> 00:43:54,690
>> ROB BODEN: Tudo bem.

752
00:43:54,690 --> 00:43:59,690

753
00:43:59,690 --> 00:44:08,430
Portanto, agora que já estamos a falar de
segurança, de certa forma, agradável

754
00:44:08,430 --> 00:44:16,050
pouco poster do filme, portanto, em recente
dia, estas questões com o NSA

755
00:44:16,050 --> 00:44:17,300
monitorando tudo.

756
00:44:17,300 --> 00:44:21,840

757
00:44:21,840 --> 00:44:26,930
Pode ser difícil de se sentir como você
ter algum tipo de privacidade no

758
00:44:26,930 --> 00:44:34,540
mundo on-line, embora eu não poderia dizer
te a maioria dos detalhes de Prism.

759
00:44:34,540 --> 00:44:42,130
Então, indo além PRISM, nós não vamos
estar falando sobre isso, agora

760
00:44:42,130 --> 00:44:44,030
pensar sobre o seu laptop.

761
00:44:44,030 --> 00:44:48,360
Então, aqui, eu quero mudar
para a minha conta real,

762
00:44:48,360 --> 00:44:50,370
com o meu pequeno pinguim.

763
00:44:50,370 --> 00:44:57,310
Então, eu tenho um conjunto de senha, e que
senha é o que eu quiser que ele seja.

764
00:44:57,310 --> 00:45:02,430
>> Mas lembre-se de que o que eu estou entrando
com, assim que este login

765
00:45:02,430 --> 00:45:04,850
alerta, é algum programa.

766
00:45:04,850 --> 00:45:07,910
É algum programa que foi
escrito por uma pessoa.

767
00:45:07,910 --> 00:45:13,250
E por isso, que a pessoa, se forem
particularmente mal-intencionado, que puderam

768
00:45:13,250 --> 00:45:17,780
já disse, tudo bem, por isso, se a senha
que eu entro é igual ao meu

769
00:45:17,780 --> 00:45:22,800
senha real, ou é igual
para alguma senha especial -

770
00:45:22,800 --> 00:45:25,550
David é incrível, ou algo assim -

771
00:45:25,550 --> 00:45:27,190
em seguida, deixá-los dentro

772
00:45:27,190 --> 00:45:33,760
Assim, um programador mal-intencionado poderia ter
acesso a todos os seus Macs, ou

773
00:45:33,760 --> 00:45:36,150
Do Windows, ou qualquer coisa.

774
00:45:36,150 --> 00:45:41,980
>> De modo que não é muito de uma preocupação, uma vez que,
Quero dizer, isso é programa de login

775
00:45:41,980 --> 00:45:48,720
que é fornecido com o OS X, centenas
ou milhares de pessoas têm

776
00:45:48,720 --> 00:45:50,020
Revisei este código.

777
00:45:50,020 --> 00:45:55,330
E assim, se, no seu código em algum lugar, você
dizer se esta string é igual a iguais

778
00:45:55,330 --> 00:45:58,860
David é incrível, login, então alguém está
vai ser, tipo, esperar.

779
00:45:58,860 --> 00:45:59,800
Isso não está certo.

780
00:45:59,800 --> 00:46:01,790
Isso não deveria estar aqui.

781
00:46:01,790 --> 00:46:06,650
Então, isso é uma maneira de fazer as coisas
para ser uma espécie de seguro.

782
00:46:06,650 --> 00:46:10,300
>> Mas pense até mesmo programas
que você escreve.

783
00:46:10,300 --> 00:46:13,000
Vamos dizer que você escreveu o programa de login.

784
00:46:13,000 --> 00:46:20,440
Portanto, este programa de login que você escreveu,
então, obviamente, você é um bom

785
00:46:20,440 --> 00:46:21,210
programador.

786
00:46:21,210 --> 00:46:25,610
Você não vai colocar qualquer mal-intencionado
se x é igual a igual David é incrível

787
00:46:25,610 --> 00:46:27,860
em seu código.

788
00:46:27,860 --> 00:46:31,930
Mas este programa, o que você faz
usar para compilar este programa?

789
00:46:31,930 --> 00:46:34,180
Algo como Clang.

790
00:46:34,180 --> 00:46:38,460
Assim que se a pessoa que passou a
escrever Clang especial encaixotado em Clang

791
00:46:38,460 --> 00:46:44,310
algo como, se estou compilando o
sessão do programa, em seguida, digite o código

792
00:46:44,310 --> 00:46:49,720
para o programa de login que diz que, se
x é igual a igual David é incrível?

793
00:46:49,720 --> 00:46:59,890
Portanto, não muito ainda, mas temos o mesmo
emitir aqui, onde Clang, bem,

794
00:46:59,890 --> 00:47:03,790
milhares, se não dezenas de milhares de
pessoas, ter olhado para Clang, têm

795
00:47:03,790 --> 00:47:07,160
olhou para as suas linhas de código, e disse:
tudo bem, não há nada de ruim aqui.

796
00:47:07,160 --> 00:47:10,680
Obviamente, ninguém está fazendo
qualquer coisa esta mal-intencionado.

797
00:47:10,680 --> 00:47:15,780
>> Mas o que é próprio bumbum, como,
e se eu compilar Clang?

798
00:47:15,780 --> 00:47:20,900
E se eu tiver algum compilador que
compila Clang que insere Clang

799
00:47:20,900 --> 00:47:25,610
esse truque especial que diz, tudo bem,
quando eu compilar Clang, então o

800
00:47:25,610 --> 00:47:31,290
executável Recebo deve especialmente olhar
dentro do programa de login e inserção

801
00:47:31,290 --> 00:47:34,230
essa senha, é igual a iguais
Dave é impressionante?

802
00:47:34,230 --> 00:47:37,990
Então lembre-se de que o seu próprio compilador
precisa ser compilado em algum ponto.

803
00:47:37,990 --> 00:47:42,810
Portanto, se o que você escolher para compilar Clang
com, em si é mal-intencionado, então você

804
00:47:42,810 --> 00:47:45,580
pode ser aparafusada a todo
caminho para baixo da linha.

805
00:47:45,580 --> 00:47:49,630
>> Então, aqui, temos Ken Thompson
e Dennis Ritchie.

806
00:47:49,630 --> 00:47:53,780
Portanto, esta é uma foto icônica.

807
00:47:53,780 --> 00:47:55,470
Dennis Ritchie está à direita.

808
00:47:55,470 --> 00:47:58,740
Ele é um grande -

809
00:47:58,740 --> 00:48:03,640
praticamente escreveu C. Assim, você pode
agradecê-lo por esta classe.

810
00:48:03,640 --> 00:48:04,840
Ken Thomson é do lado esquerdo.

811
00:48:04,840 --> 00:48:07,780
Os dois basicamente escreveu UNIX.

812
00:48:07,780 --> 00:48:10,140
Bem, eles foram grandes contribuintes
em UNIX.

813
00:48:10,140 --> 00:48:11,310
Havia alguns outros.

814
00:48:11,310 --> 00:48:16,240
Então, Ken Thompson, em algum momento,
ele ganha o Prêmio Turing.

815
00:48:16,240 --> 00:48:20,860
E o prêmio Turing, eu sempre ouvi
ele referenciada desta forma, é o

816
00:48:20,860 --> 00:48:23,100
Prêmio Nobel de ciência da computação.

817
00:48:23,100 --> 00:48:27,500
>> Então, o Prêmio Turing, ele tem que
dar seu discurso de aceitação.

818
00:48:27,500 --> 00:48:31,790
E ele dá esta muito famoso discurso
agora, chamado Reflexões sobre Confiança

819
00:48:31,790 --> 00:48:35,620
Trust, que temos ligados
no site do curso.

820
00:48:35,620 --> 00:48:41,670
E, neste discurso, ele diz, tudo bem,
então eu escrevi UNIX, e agora todos

821
00:48:41,670 --> 00:48:43,320
você as pessoas estão usando UNIX.

822
00:48:43,320 --> 00:48:46,960
Agora, lembre-se, hoje, que o Linux é
um descendente direto do UNIX.

823
00:48:46,960 --> 00:48:50,140
OS X usa diretamente UNIX.

824
00:48:50,140 --> 00:48:53,810
Windows não faz muito, mas muito
de idéias foram tiradas de UNIX.

825
00:48:53,810 --> 00:48:59,220
>> Assim, ele vai até o palco e diz:
tudo bem, eu escrevi UNIX.

826
00:48:59,220 --> 00:49:03,940
E só assim vocês sabem, eu sou
capaz de fazer logon em cada

827
00:49:03,940 --> 00:49:05,590
um único de seus computadores.

828
00:49:05,590 --> 00:49:14,280
Desde que eu colocar um desses especial se x
é igual a igual Ken Thomson é incrível,

829
00:49:14,280 --> 00:49:16,350
então eu tenho permissão para entrar.

830
00:49:16,350 --> 00:49:18,370
Então, as pessoas são como, bem,
Como você faz isso?

831
00:49:18,370 --> 00:49:21,090
Olhamos para o programa de login
e nada está lá.

832
00:49:21,090 --> 00:49:24,700
Ele é como, bem, eu modifiquei o compilador
para entrar no programa de login

833
00:49:24,700 --> 00:49:30,490
para que o programa de login terá agora
que x é igual a igual Ken Thompson

834
00:49:30,490 --> 00:49:31,700
é incrível.

835
00:49:31,700 --> 00:49:33,120
>> E eles dizem, bem, isso não é verdade.

836
00:49:33,120 --> 00:49:35,740
Nós estamos olhando para o compilador, eo
compilador não possui linhas de

837
00:49:35,740 --> 00:49:36,400
código como esse.

838
00:49:36,400 --> 00:49:40,540
Ele é como, OK, mas o que você está
compilar o compilador com?

839
00:49:40,540 --> 00:49:44,810
E eles pensam, e ele é, como, bem,
Eu sou o único que lhe deu o compilador

840
00:49:44,810 --> 00:49:50,580
você está usando para compilar o compilador, por isso
você está compilando um compilador, que

841
00:49:50,580 --> 00:49:56,390
em si é mal-intencionado, e vontade
quebrar o programa de login.

842
00:49:56,390 --> 00:49:59,360
Então, basicamente, nesse ponto, não há
nenhuma maneira que você pode olhar para a fonte

843
00:49:59,360 --> 00:50:02,450
código do programa de login
para ver o que está errado.

844
00:50:02,450 --> 00:50:04,220
Você não podia nem olhar na
código-fonte do compilador

845
00:50:04,220 --> 00:50:06,790
para ver o que está errado.

846
00:50:06,790 --> 00:50:11,940
>> Você precisa olhar para a máquina
de código, o binário efectivo da

847
00:50:11,940 --> 00:50:16,760
compilado compilador para ver, esperar, estes
linhas de código não deveria estar aqui.

848
00:50:16,760 --> 00:50:22,130
Mas Ken Thompson deu um passo
mais longe e disse, bem, há

849
00:50:22,130 --> 00:50:25,980
estes programas especiais que efectivamente
ajudá-lo a ler o binário de programas,

850
00:50:25,980 --> 00:50:29,340
e por isso, se alguém usou esse programa para
ler o binário, veriam estes

851
00:50:29,340 --> 00:50:30,490
linhas de código.

852
00:50:30,490 --> 00:50:34,020
Ele modificou esses programas para dizer, tudo
bem, se você está olhando para o

853
00:50:34,020 --> 00:50:38,460
compilador, não mostram este particular
conjunto de binário.

854
00:50:38,460 --> 00:50:42,830
>> Então, então você precisa dar um passo
ainda mais e, basicamente, que poderia ter

855
00:50:42,830 --> 00:50:46,210
tomadas vários níveis de engano,
e em algum momento, ninguém é realmente

856
00:50:46,210 --> 00:50:47,990
vai estar verificando.

857
00:50:47,990 --> 00:50:52,590
Assim, a moral da história é, você é
não vai ser escrito

858
00:50:52,590 --> 00:50:54,340
Clang nesta classe.

859
00:50:54,340 --> 00:50:57,020
Você vai estar usando escalada
Tinido muito nesta classe.

860
00:50:57,020 --> 00:51:00,490
Para todos sabem, Clang é um malicioso
programa que está sabotando cada

861
00:51:00,490 --> 00:51:03,520
único programa que você já compilado.

862
00:51:03,520 --> 00:51:08,206
E para deixá-lo naquele mesmo sinistro
notar, vê-lo na quarta-feira.

863
00:51:08,206 --> 00:51:10,030
>> [Aplausos]

864
00:51:10,030 --> 00:51:12,935
>> COLUNA 2: Na próxima CS50.

865
00:51:12,935 --> 00:51:14,580
>> COLUNA 3: Não se atreva a dizer isso.

866
00:51:14,580 --> 00:51:15,930
Você pode fazer isso.

867
00:51:15,930 --> 00:51:19,440
Você já fez isso antes, você pode fazer isso
hoje em dia, você pode fazer isso amanhã.

868
00:51:19,440 --> 00:51:20,930
Você tem feito isso há anos.

869
00:51:20,930 --> 00:51:22,790
Basta ir até lá e fazer isso.

870
00:51:22,790 --> 00:51:24,310
Você pode fazer isso.

871
00:51:24,310 --> 00:51:26,102
>> [Música tocando]