1
00:00:00,000 --> 00:00:02,200
[Powered by Google Translate] [Semana 3]

2
00:00:02,200 --> 00:00:03,950
[David J. Malan - Harvard University]

3
00:00:03,950 --> 00:00:07,140
[Esta é CS50. - CS50.TV]

4
00:00:07,140 --> 00:00:10,720
Deixe-me guiar-nos na direção de onde paramos da última vez,

5
00:00:10,720 --> 00:00:13,890
que estava começando a pensar um pouco mais do que sobre a sintaxe

6
00:00:13,890 --> 00:00:17,150
e tentando pensar um pouco menos sobre todas as minúcias

7
00:00:17,150 --> 00:00:20,630
que leva um pouco de tempo para se aclimatar ao até agora em termos de ponto e vírgula

8
00:00:20,630 --> 00:00:22,360
e parênteses e chaves,

9
00:00:22,360 --> 00:00:25,630
para começar a tomar as coisas um pouco para um nível superior conceitual

10
00:00:25,630 --> 00:00:28,800
para que os problemas que agora começam a resolução sobre as próximas semanas

11
00:00:28,800 --> 00:00:32,340
vai envolver muito mais problemas conceituais de nível superior

12
00:00:32,340 --> 00:00:36,310
e um pouco menos no sintática como você obter seus pés molhados

13
00:00:36,310 --> 00:00:40,090
e as mãos sujas com alguma da sintaxe de nas últimas semanas.

14
00:00:40,090 --> 00:00:43,690
>> Então lembrar que na semana passada, introduziu esta noção de uma matriz.

15
00:00:43,690 --> 00:00:49,320
E uma matriz em Inglês pode ser descrito como o que? >> [Resposta do aluno inaudível]

16
00:00:49,320 --> 00:00:51,710
Desculpe?

17
00:00:51,710 --> 00:00:54,810
Uma coleção de? >> [Resposta do aluno inaudível] >> Ok, bom.

18
00:00:54,810 --> 00:00:57,820
Uma coleção de itens. Então vimos matrizes em Scratch.

19
00:00:57,820 --> 00:01:01,880
Se você passou a usar para pset 0 uma das listas de raspadinhas, que você pode arrastar as coisas

20
00:01:01,880 --> 00:01:05,410
como laranjas e bananas, um inventário de tipos,

21
00:01:05,410 --> 00:01:07,100
esse é o tipo de como o que é uma matriz.

22
00:01:07,100 --> 00:01:10,980
E, em seguida, mais tecnicamente, no contexto de um computador real,

23
00:01:10,980 --> 00:01:14,730
uma matriz é simplesmente um pedaço contíguo de memória.

24
00:01:14,730 --> 00:01:18,590
Em outras palavras, você tem um byte, então byte outro, depois outro byte, depois outro byte,

25
00:01:18,590 --> 00:01:21,330
e se você fosse desenhar os bytes em uma imagem,

26
00:01:21,330 --> 00:01:24,510
eles estariam de volta para trás, para trás, para trás. Isso é o que queremos dizer com contíguo.

27
00:01:24,510 --> 00:01:26,690
>> Por isso é o número de bytes 1, depois 2, depois 3.

28
00:01:26,690 --> 00:01:29,680
Isso não significa que aqui, aqui, aqui, aqui.

29
00:01:29,680 --> 00:01:33,800
Uma matriz é um pedaço contíguo de 0 ou mais bytes.

30
00:01:33,800 --> 00:01:36,160
Então, o que eles são úteis para?

31
00:01:36,160 --> 00:01:40,090
Lembro que tínhamos esse tipo de exemplo fictício de graus pessoas armazenamento da Quiz em um programa

32
00:01:40,090 --> 00:01:42,580
para calcular a média quiz para algum curso,

33
00:01:42,580 --> 00:01:46,780
e lembrar que nós poderíamos começar a escrever o programa, declarando um quiz1 variável.

34
00:01:46,780 --> 00:01:49,550
Então poderíamos ter outra variável chamada quiz2.

35
00:01:49,550 --> 00:01:52,030
Mas então se foram 3 questionários nesta classe, quiz4.

36
00:01:52,030 --> 00:01:55,710
Ou se houve um quiz semanal, seria quiz5, quiz6, quiz7.

37
00:01:55,710 --> 00:01:58,520
Assim, você teria todas estas variáveis ​​declaradas dentro de main

38
00:01:58,520 --> 00:02:00,470
ou em outro lugar no seu programa,

39
00:02:00,470 --> 00:02:03,870
eo problema com essa abordagem, embora seja fácil de copiar e colar,

40
00:02:03,870 --> 00:02:06,120
É apenas muito rapidamente torna-se difícil.

41
00:02:06,120 --> 00:02:09,360
Deus me livre que você realmente tem 30 testes ou 50 testes.

42
00:02:09,360 --> 00:02:12,080
Se é como uma escola de teste alto estilo pop diariamente,

43
00:02:12,080 --> 00:02:15,910
então você apenas tem uma lista ridiculamente longo de variáveis ​​sendo declarado,

44
00:02:15,910 --> 00:02:17,780
e isso só muito rapidamente fica fora de controle.

45
00:02:17,780 --> 00:02:20,820
É feio, é difícil manter, é muito mais fácil fazer um erro de digitação

46
00:02:20,820 --> 00:02:23,910
se você receber um número digitado errado em algum lugar no seu programa.

47
00:02:23,910 --> 00:02:26,800
>> Assim, introduziu a noção de uma matriz em vez.

48
00:02:26,800 --> 00:02:30,760
E lembre que implementou este programa, fazendo um pouco algo como isto.

49
00:02:30,760 --> 00:02:33,950
Deixe-me ir para hoje Fonte diretório segunda-feira 3

50
00:02:33,950 --> 00:02:37,160
e abrir matriz, que vimos pela última vez.

51
00:02:37,160 --> 00:02:39,940
E mesmo que houvesse um par de novos truques C aqui,

52
00:02:39,940 --> 00:02:41,920
entre eles, a noção de uma constante,

53
00:02:41,920 --> 00:02:47,140
lembre que declarou várias bóias essencialmente usando a seguinte sintaxe:

54
00:02:47,140 --> 00:02:51,750
float, em seguida, o nome da variável, em seguida, utilizou-colchetes realmente pela primeira vez,

55
00:02:51,750 --> 00:02:55,450
eo que fizemos dentro dos colchetes foi efetivamente colocar um número.

56
00:02:55,450 --> 00:02:59,780
Mas em vez de colocar um número, eu coloquei esta palavra maiúscula, quizzes.

57
00:02:59,780 --> 00:03:03,220
E qual foi a motivação para colocar uma palavra em maiúsculas como quizzes

58
00:03:03,220 --> 00:03:08,170
e em seguida, usando truque linha 17 aqui para realmente dar um que número?

59
00:03:08,170 --> 00:03:11,240
Qual foi a motivação lá? Sim.

60
00:03:11,240 --> 00:03:13,360
>> [Resposta do aluno inaudível] >> Exatamente.

61
00:03:13,360 --> 00:03:16,630
Se queremos mudar esse valor 2, só temos que mudá-lo em um lugar

62
00:03:16,630 --> 00:03:19,680
, por considerar - Eu nem me lembro o que este programa fez exatamente,

63
00:03:19,680 --> 00:03:22,040
mas se você apenas roçar que você vê testes, questionários.

64
00:03:22,040 --> 00:03:24,720
Você vê questionários, aqui mais testes.

65
00:03:24,720 --> 00:03:28,180
Então, se não tivéssemos essa constante, esse uso de acentuada definir,

66
00:03:28,180 --> 00:03:33,320
teríamos digitado 2, depois 2, depois 2, depois 2, o que é bom. Seria também correto.

67
00:03:33,320 --> 00:03:36,220
Mas suponha que no próximo ano temos três questionários na CS50.

68
00:03:36,220 --> 00:03:39,190
Então, eu tenho que ir e atualizar o código, eu tenho que recompilar,

69
00:03:39,190 --> 00:03:43,820
mas o problema é se eu fizer algo estúpido, como se eu esquecer uma menção de 2

70
00:03:43,820 --> 00:03:46,750
e se esqueça de ligar 3, todo o programa poderia muito bem quebrar.

71
00:03:46,750 --> 00:03:48,720
Então, estamos apenas pedindo para ter problemas.

72
00:03:48,720 --> 00:03:53,170
>> Assim, a noção de uma constante é tudo sobre fatoração de algum pedaço de dados,

73
00:03:53,170 --> 00:03:56,070
se é uma string ou um char ou uma bóia ou qualquer que seja,

74
00:03:56,070 --> 00:04:00,070
e declará-lo um lugar para que você possa mais facilmente mudá-lo no futuro.

75
00:04:00,070 --> 00:04:03,660
E também é, francamente, um pouco mais fácil de ler, porque se você só pensar nisso agora,

76
00:04:03,660 --> 00:04:07,840
é quizzes, ou poderíamos até mudar o nome de algo como NUMBER_OF_QUIZZES

77
00:04:07,840 --> 00:04:09,430
ou algo mais explícito.

78
00:04:09,430 --> 00:04:11,830
O código só se torna um pouco mais óbvio sobre o que ele está fazendo,

79
00:04:11,830 --> 00:04:15,780
e você quer saber um pouco menos que o número 2 pode acontecer a dizer.

80
00:04:15,780 --> 00:04:18,920
Assim, a constante não tinha nada a ver fundamentalmente com matrizes.

81
00:04:18,920 --> 00:04:22,990
A matriz foi introduzida por meio desses parêntesis rectos.

82
00:04:22,990 --> 00:04:26,610
>> Então, observe que na linha 23 pedimos ao usuário, "Quais foram suas contagens de questionários?"

83
00:04:26,610 --> 00:04:31,120
Então só temos esse laço que aparentemente pede ao usuário para suas notas. Como?

84
00:04:31,120 --> 00:04:37,460
Ele itera 0-2. E eu digo 2 porque questionários em todas as tampas é atualmente 2.

85
00:04:37,460 --> 00:04:42,310
Por isso, itera de 0 a 2 e então ela mostra Quiz # algo de alguma coisa,

86
00:04:42,310 --> 00:04:45,830
e, em seguida, ele usa GetFloat para obter um valor do usuário.

87
00:04:45,830 --> 00:04:49,050
Então, observe esta é a única outra peça nova sintaxe da última quarta-feira.

88
00:04:49,050 --> 00:04:53,120
Se você deseja armazenar algo em um determinado local, em que a matriz,

89
00:04:53,120 --> 00:04:55,460
você usar novamente os colchetes.

90
00:04:55,460 --> 00:04:57,030
>> Portanto, há um pouco de dicotomia aqui.

91
00:04:57,030 --> 00:04:59,040
A primeira vez que utilizar os colchetes

92
00:04:59,040 --> 00:05:02,250
você usá-lo para especificar como grande você quer a matriz para ser.

93
00:05:02,250 --> 00:05:06,580
Mas esse contexto próxima aqui onde nós novamente empregar esses colchetes

94
00:05:06,580 --> 00:05:10,540
significa que a matriz onde, em que você quer colocar algum valor?

95
00:05:10,540 --> 00:05:13,650
E a distinção aqui pode ser inferida a partir do contexto.

96
00:05:13,650 --> 00:05:17,130
Note-se aqui que temos um tipo de dados, em seguida, temos o nome de uma variável,

97
00:05:17,130 --> 00:05:20,770
em seguida, temos as nossas chaves quadrados com um número dentro, ponto e vírgula. É isso aí.

98
00:05:20,770 --> 00:05:22,290
Então, isso é uma declaração.

99
00:05:22,290 --> 00:05:28,390
É como se tivéssemos feito algo como bóia classe1; flutuador grade2;

100
00:05:28,390 --> 00:05:31,730
mas, novamente, isso muito rapidamente se transforma em cópia demais, colar,

101
00:05:31,730 --> 00:05:34,260
assim, em vez que apenas simplificada como tal,

102
00:05:34,260 --> 00:05:38,800
o que significa que daqui em diante, temos um grau que pode ser armazenado no suporte de 0,

103
00:05:38,800 --> 00:05:41,760
temos uma outra qualidade, que pode ser armazenado a braçadeira 1,

104
00:05:41,760 --> 00:05:46,890
mas e se eu goof e, por exemplo, o meu ciclo vai tão longe -

105
00:05:46,890 --> 00:05:48,740
por exemplo, I tornam este menos do que ou igual a,

106
00:05:48,740 --> 00:05:50,620
que recall foi a origem de um erro anterior -

107
00:05:50,620 --> 00:05:55,590
que na prática significa que, em algum acidental terceira iteração deste laço

108
00:05:55,590 --> 00:06:00,380
Eu uso o suporte de 2. Efetivamente, o que pode acontecer aqui? Desculpe?

109
00:06:00,380 --> 00:06:02,860
[Aluno] Vai ser substituído. >> Será que vai ser substituído?

110
00:06:02,860 --> 00:06:04,520
O que seria substituído?

111
00:06:04,520 --> 00:06:10,890
Este é literalmente dizendo substituir o que está em localização 2 com o valor de retorno de GetFloat.

112
00:06:10,890 --> 00:06:13,690
Mas o problema é o quão grande é a matriz, neste ponto da história?

113
00:06:13,690 --> 00:06:17,730
[Resposta do aluno inaudível] >> A matriz ainda é apenas de tamanho 2

114
00:06:17,730 --> 00:06:22,730
porque a matriz, como qualquer outra variável, foi declarada em primeiro lugar, antes que usou,

115
00:06:22,730 --> 00:06:27,220
e nós aqui especificado por causa dessa constante que eu tenho duas notas que eu vou colocar.

116
00:06:27,220 --> 00:06:29,930
>> Mas lembre-se, os cientistas da computação começa a contar a partir de 0.

117
00:06:29,930 --> 00:06:33,620
Assim, o primeiro local em que a matriz é suporte 0.

118
00:06:33,620 --> 00:06:40,210
A localização próxima é 1. Essa coisa é sempre tão pouco longe demais para o lado.

119
00:06:40,210 --> 00:06:42,870
Portanto, em outras palavras, se eu realmente tinha essa matriz -

120
00:06:42,870 --> 00:06:46,790
e deixe-me ver o quão bem este coopera aqui para nós -

121
00:06:46,790 --> 00:06:52,360
se eu tenho uma matriz que eu simplesmente com as seguintes

122
00:06:52,360 --> 00:06:56,750
e eu alocado espaço para dois elementos, eu poderia tirar esta como esta na memória

123
00:06:56,750 --> 00:06:58,020
onde esta grande tela branca é.

124
00:06:58,020 --> 00:07:00,920
É apenas a RAM que eu tenho em meu computador, um giga de RAM, 2 GB de RAM, o que,

125
00:07:00,920 --> 00:07:05,400
mas estas duas caixas de agora individualmente, representam uma bóia, 32 bits.

126
00:07:05,400 --> 00:07:10,860
Então, se eu colocar um número aqui como 1.0, então eu coloquei outro número aqui como 3,2

127
00:07:10,860 --> 00:07:15,280
mas depois eu suporte 2, que é como colocar algo aqui.

128
00:07:15,280 --> 00:07:17,820
E como a imagem sugere, não há nada lá.

129
00:07:17,820 --> 00:07:20,450
É uma espécie de como terra de ninguém, porque eu não perguntei o sistema operacional

130
00:07:20,450 --> 00:07:23,550
para me dar este quiz terceiro.

131
00:07:23,550 --> 00:07:26,940
Se eu queria que teste terceira, eu deveria ter tido a premeditação

132
00:07:26,940 --> 00:07:31,700
de pedir ao sistema operacional para ele, declarando QUIZ para não ser 2

133
00:07:31,700 --> 00:07:34,210
mas em vez disso a igualar 3.

134
00:07:34,210 --> 00:07:39,000
>> Portanto, em outras palavras, a imagem que nós efetivamente ter em mãos se parece com isso aqui.

135
00:07:39,000 --> 00:07:42,260
Este novo é terra de ninguém. É melhor não tentar escrever valores aqui.

136
00:07:42,260 --> 00:07:45,300
Mas, novamente, os cientistas porque o computador contar de 0,

137
00:07:45,300 --> 00:07:49,520
quando falamos sobre este local na matriz, que é suposto ser a localização 0,

138
00:07:49,520 --> 00:07:53,890
isto é suposto ser um local, e isso não existe mesmo

139
00:07:53,890 --> 00:07:57,380
porque nós só perguntou o sistema operacional para dois lugares.

140
00:07:57,380 --> 00:08:00,130
Então, aqueles de vocês com experiência anterior em programação de outras línguas

141
00:08:00,130 --> 00:08:04,150
poderia saber que este não é sempre o caso com matrizes ou coisas chamados de vetores.

142
00:08:04,150 --> 00:08:06,930
Em vez disso, você pode apenas manter acrescentando e acrescentando e acrescentando coisas para matrizes,

143
00:08:06,930 --> 00:08:10,720
que, francamente, tivemos essa capacidade em Scratch e ainda assim parecem ter dado aqui

144
00:08:10,720 --> 00:08:15,160
porque com C você está programando muito mais explicitamente.

145
00:08:15,160 --> 00:08:17,980
É só você eo computador agora, e que o computador só vai fazer

146
00:08:17,980 --> 00:08:19,530
o que você diga a ele o que fazer.

147
00:08:19,530 --> 00:08:24,270
Então, se você apenas dizer-lhe para lhe dar dois flutuadores por meio de linha 22 aqui,

148
00:08:24,270 --> 00:08:27,640
isso é tudo que você vai receber de volta a partir do sistema operacional: espaço para 2.

149
00:08:27,640 --> 00:08:34,049
>> Assim, estão cada vez mais seus programas vai ser ocasionalmente buggy com relação a matrizes.

150
00:08:34,049 --> 00:08:37,520
Este é exatamente o tipo da natureza da besta em que todos nós somos falíveis,

151
00:08:37,520 --> 00:08:42,490
e em algum momento você irá indexar muito provavelmente além do limite da sua matriz.

152
00:08:42,490 --> 00:08:45,980
E isso é apenas uma maneira elegante de dizer que você foi em algo suporte

153
00:08:45,980 --> 00:08:49,970
e algo era muito grande de um número. Você foi além dos limites de sua matriz.

154
00:08:49,970 --> 00:08:51,530
Mas a cabeça agora é este.

155
00:08:51,530 --> 00:08:54,990
O restante deste programa realmente tem nada de fundamentalmente a ver com matrizes.

156
00:08:54,990 --> 00:08:58,180
É tudo apenas sobre alguns aritmética simples para médias de computação.

157
00:08:58,180 --> 00:09:03,200
Portanto, temos aqui neste loop for aqui primeiro uma quantia variável chamada que inicializar a 0.

158
00:09:03,200 --> 00:09:09,020
Então nós iterar de 0 até 2 de novo e acrescentar a essa variável soma

159
00:09:09,020 --> 00:09:12,620
o grau i, para suporte 0, suporte 1.

160
00:09:12,620 --> 00:09:15,130
E então, como você faria na escola para calcular a média,

161
00:09:15,130 --> 00:09:19,420
nós simplesmente tomar essa soma, dividi-lo pelo número total de questionários,

162
00:09:19,420 --> 00:09:22,520
e, em seguida, para uma boa medida que nós chamamos uma função aqui chamado rodada.

163
00:09:22,520 --> 00:09:28,580
>> Agora, como um aparte, o que é o negócio com este int entre parênteses na linha 34?

164
00:09:28,580 --> 00:09:31,730
Ele poderia ter vindo se já em seção, realmente não conversamos sobre isso formalmente aqui,

165
00:09:31,730 --> 00:09:35,210
mas o que é isso int em parens provavelmente fazendo? >> [Resposta do aluno inaudível]

166
00:09:35,210 --> 00:09:38,500
Sim, isso se refere ao vazamento ou estereótipo,

167
00:09:38,500 --> 00:09:41,690
o que significa assumir um tipo de dados e convertê-lo para outro.

168
00:09:41,690 --> 00:09:45,400
Você não pode fazer isso com todos os tipos de dados, porque às vezes seria um pouco estranho.

169
00:09:45,400 --> 00:09:49,640
Mas, neste caso, se o valor de retorno e volta é um flutuador

170
00:09:49,640 --> 00:09:53,880
porque, afinal, eu estou tendo uma bóia e dividindo-o por um número como 2,

171
00:09:53,880 --> 00:09:55,840
Eu vou voltar um float.

172
00:09:55,840 --> 00:10:00,760
Mas as pessoas da escola da classe realmente não gosta de saber que sua média foi de 93,4

173
00:10:00,760 --> 00:10:04,420
porque eles vão perceber que eles nunca foram tão perto desse ponto arredondamento 95.

174
00:10:04,420 --> 00:10:09,540
>> Então, nós queremos usar int em vez de arredondar todos para o próximo int,

175
00:10:09,540 --> 00:10:12,730
que neste caso vai ser 94 com nenhum ponto depois dela.

176
00:10:12,730 --> 00:10:14,530
Então, isso é apenas um pequeno truque matemático.

177
00:10:14,530 --> 00:10:17,570
E nós vamos voltar a esta noção de elenco, porque vai ter implicações,

178
00:10:17,570 --> 00:10:21,640
se você ainda não descobriram já, por conjunto de problemas 2.

179
00:10:21,640 --> 00:10:25,210
Assim, uma matriz, então, você pode pensar - que vai me fazer sorrir todos os dias.

180
00:10:25,210 --> 00:10:27,830
Parece que este se você tirar uma foto dele,

181
00:10:27,830 --> 00:10:31,460
mas o fundamental é que o tamanho também é selecionado por você

182
00:10:31,460 --> 00:10:34,050
quando você solicitar a partir do sistema operacional.

183
00:10:34,050 --> 00:10:39,460
Quaisquer perguntas, então em matrizes? Sim.

184
00:10:39,460 --> 00:10:47,080
[Pergunta estudante inaudível]

185
00:10:47,080 --> 00:10:49,310
Ah, boa pergunta.

186
00:10:49,310 --> 00:10:53,150
A questão é o que acontece com o 0 nulo na matriz? Não existe neste contexto.

187
00:10:53,150 --> 00:10:57,430
Que só existe no contexto de strings, que estamos prestes a chegar a apenas em um momento.

188
00:10:57,430 --> 00:11:02,300
Mas, para uma matriz, como neste caso, tudo o que você recebe é o que você perguntar ao sistema operacional para.

189
00:11:02,300 --> 00:11:04,050
>> E como um aparte, para que esta não ser claro,

190
00:11:04,050 --> 00:11:07,030
Eu continuo dizendo que você pedir ao sistema operacional, pedir ao sistema operacional.

191
00:11:07,030 --> 00:11:10,090
Um sistema operacional, como você provavelmente sabe, é o Mac OS, Windows, Linux.

192
00:11:10,090 --> 00:11:13,560
Quando você está chamando funções como GetFloat

193
00:11:13,560 --> 00:11:19,280
ou você está declarando variáveis ​​como notas,

194
00:11:19,280 --> 00:11:23,200
no fim do dia você está efetivamente pedindo alguém para dar-lhe de que a memória

195
00:11:23,200 --> 00:11:25,940
porque como aspirantes a programadores

196
00:11:25,940 --> 00:11:28,800
não tem idéia de como realmente ter acesso físico à memória.

197
00:11:28,800 --> 00:11:31,100
Mas alguém faz: o sistema operacional.

198
00:11:31,100 --> 00:11:36,630
Assim, além de apresentar-nos com ícones e menus bonitos e pastas e similares

199
00:11:36,630 --> 00:11:39,050
que você vê em seu desktop, se um Mac ou PC,

200
00:11:39,050 --> 00:11:42,240
sistemas operacionais também fazer as coisas de baixo nível mundano,

201
00:11:42,240 --> 00:11:44,680
o material altamente técnico de gestão da gigabyte

202
00:11:44,680 --> 00:11:48,780
ou 2 gigabytes de memória que você tem, a gestão do CPU que você tem, e assim por diante.

203
00:11:48,780 --> 00:11:50,170
Então, quando você está escrevendo código,

204
00:11:50,170 --> 00:11:53,900
você está realmente ligando para o seu sistema operacional nesse sentido.

205
00:11:53,900 --> 00:11:55,720
Eu vou ter que minimizar isso. Tudo bem.

206
00:11:55,720 --> 00:11:59,980
>> Outras questões sobre matrizes?

207
00:12:00,330 --> 00:12:02,520
Não? Okay.

208
00:12:02,520 --> 00:12:06,680
Assim, a transição naturalmente a partir de matrizes é na verdade a um tema que é um pouco familiar.

209
00:12:06,680 --> 00:12:09,570
E nós olhamos sempre tão brevemente esta última vez também.

210
00:12:09,570 --> 00:12:12,500
Este foi um exemplo de cadeia de quarta-feira.

211
00:12:12,500 --> 00:12:15,060
Este exemplo de cadeia era um programa muito simples,

212
00:12:15,060 --> 00:12:18,120
e eu realmente simplificou-lo por um par de linhas para fins de hoje.

213
00:12:18,120 --> 00:12:22,680
Tudo que faz na linha 19 é obter uma string do usuário, armazena em uma variável chamada s.

214
00:12:22,680 --> 00:12:28,670
Então, em frente a linha 22 é aparentemente imprimir essa string um caractere por linha.

215
00:12:28,670 --> 00:12:30,730
Mas como ele está fazendo isso?

216
00:12:30,730 --> 00:12:33,350
Estamos declarando uma variável i, definindo-o igual a 0,

217
00:12:33,350 --> 00:12:35,770
e isso está se tornando hábito velho agora.

218
00:12:35,770 --> 00:12:39,270
Não tinha visto isso até quarta-feira, mas você pode tipo de inferir de seu nome

219
00:12:39,270 --> 00:12:44,610
strlen retorna apenas que quando dado s? O comprimento da corda.

220
00:12:44,610 --> 00:12:47,940
Então, se eu passar uma corda, citação-unquote DAVID,

221
00:12:47,940 --> 00:12:51,810
é esperançosamente vai voltar para mim o número 5 porque de Davi.

222
00:12:51,810 --> 00:12:55,600
Então esse é o seu propósito na vida é ter uma string, se codificado por você

223
00:12:55,600 --> 00:12:58,840
ou neste caso, conectado como uma variável, como um argumento,

224
00:12:58,840 --> 00:13:01,980
e ele descobre que o comprimento de corda que é.

225
00:13:01,980 --> 00:13:06,470
>> Então aqui agora estamos emprestando alguma notação do exemplo questionário anterior.

226
00:13:06,470 --> 00:13:09,390
Isto não tem nada a ver com carros alegóricos, não tem nada a ver com quizzes,

227
00:13:09,390 --> 00:13:13,100
mas acontece que a pequena mentira que estamos dizendo desde a semana 1

228
00:13:13,100 --> 00:13:16,330
é que uma seqüência realmente não existe em C.

229
00:13:16,330 --> 00:13:20,230
Uma seqüência no final do dia é realmente apenas uma matriz.

230
00:13:20,230 --> 00:13:25,140
É uma matriz de bytes, assim byte, byte, byte, byte, que recall é apenas 8 bits,

231
00:13:25,140 --> 00:13:28,130
assim pedaço de memória, pedaço da memória, pedaço da memória, pedaço da memória.

232
00:13:28,130 --> 00:13:31,210
E o meio pelo qual uma string é implementado

233
00:13:31,210 --> 00:13:33,070
é colocando o primeiro caractere aqui,

234
00:13:33,070 --> 00:13:37,470
então aqui, então aqui, então aqui, volta para trás para trás na memória do computador.

235
00:13:37,470 --> 00:13:42,160
Então, se você queria para soletrar uma palavra como OLÁ, você iria colocar um personagem H,

236
00:13:42,160 --> 00:13:48,240
E depois, então L então L, em seguida, O - 5 caracteres no total - em algum lugar na memória RAM do seu computador.

237
00:13:48,240 --> 00:13:52,080
Mas o detalhe chave aqui é que eles vão voltar para trás, para trás, para trás,

238
00:13:52,080 --> 00:13:54,200
ao lado um do outro.

239
00:13:54,200 --> 00:13:58,820
Quando quando digo s [i], o que em Inglês é esta a dar-me?

240
00:14:01,240 --> 00:14:04,550
O que s [i] constituem, neste caso? Sim.

241
00:14:04,550 --> 00:14:07,800
>> [Aluno] O personagem om na cadeia. >> Exatamente. O personagem om na cadeia.

242
00:14:07,800 --> 00:14:12,260
Agora, eu vai começar em 0 como por minha loop for aqui,

243
00:14:12,260 --> 00:14:14,850
mas isso é bom porque tudo começa a contar a partir de 0.

244
00:14:14,850 --> 00:14:19,160
Então s [0] vai representar a letra H em uma palavra como OLÁ,

245
00:14:19,160 --> 00:14:24,530
s [1] vai representar uma carta como E em uma palavra como OLÁ, e assim por diante.

246
00:14:24,530 --> 00:14:27,130
E o que parecem estar fazendo em cada iteração deste laço

247
00:14:27,130 --> 00:14:32,780
é armazenar temporariamente o personagem om em uma variável chamada c, que é apenas um char,

248
00:14:32,780 --> 00:14:35,010
e depois vamos imprimir c

249
00:14:35,010 --> 00:14:37,620
de modo que, no final do dia, o que este programa faz é o seguinte.

250
00:14:37,620 --> 00:14:42,900
Se eu ir para o diretório de origem e eu faço string1 e eu ir em frente e correr string1,

251
00:14:42,900 --> 00:14:51,920
e então eu digitar uma palavra como OLÁ, Enter, tudo que faz é imprimir esse personagem um de cada vez.

252
00:14:51,920 --> 00:14:54,010
>> Portanto, há uma oportunidade para o refinamento aqui.

253
00:14:54,010 --> 00:14:58,150
Eu sou do tipo de fazer mais trabalho, mesmo que seja mais claro talvez desta forma, que o necessário.

254
00:14:58,150 --> 00:15:03,270
Que linha de código aqui posso jogar fora provavelmente por completo? Sim.

255
00:15:03,270 --> 00:15:08,290
Linha 24. Na linha 24 eu estou declarando uma variável c.

256
00:15:08,290 --> 00:15:14,320
Eu estou armazenando o caráter i de s na mesma, mas então eu estou usando c aqui.

257
00:15:14,320 --> 00:15:20,160
Então, eu estou usando c, então eu sinto que não pode apenas jogar linha 24 de distância.

258
00:15:20,160 --> 00:15:23,850
[Comentário do estudante inaudível] >> Exatamente.

259
00:15:23,850 --> 00:15:26,240
Assim, quando se trata de falar sobre a concepção de programas,

260
00:15:26,240 --> 00:15:30,740
perceber isso ligeira simplificação do código, que é tão legível,

261
00:15:30,740 --> 00:15:34,680
mas percebe que está é apenas uma variável, seu tipo de dados é um array,

262
00:15:34,680 --> 00:15:38,610
então s [i] está indo só para imediatamente voltar para você o personagem om em que seqüência.

263
00:15:38,610 --> 00:15:40,620
E se você quiser imprimi-lo, tudo bem.

264
00:15:40,620 --> 00:15:43,680
Você apenas tem que usar% c porque você não estiver imprimindo uma string,

265
00:15:43,680 --> 00:15:48,520
você estiver imprimindo um caractere em uma seqüência, e isso também tem o efeito de imprimir o caráter i.

266
00:15:48,520 --> 00:15:51,390
E lembro que a única diferença realmente da semana passada com o uso de printf

267
00:15:51,390 --> 00:15:54,220
é que, enquanto nas últimas semanas que iria fazer algo super simples

268
00:15:54,220 --> 00:15:58,510
como espaço reservado% s então o nome de uma seqüência aqui,

269
00:15:58,510 --> 00:16:01,190
agora estamos mergulhando em um pouco mais debaixo do capô e dizendo:

270
00:16:01,190 --> 00:16:06,090
não imprimir a string; imprimir o único personagem nele.

271
00:16:06,090 --> 00:16:10,570
>> Então nós podemos fazer algo um pouco diferente aqui porque há uma outra - não bug

272
00:16:10,570 --> 00:16:14,090
porque este programa é certo, mas eu estou fazendo algo estúpido

273
00:16:14,090 --> 00:16:16,810
que eu mencionei brevemente na quarta-feira.

274
00:16:16,810 --> 00:16:22,680
Mas pensando, como poderia projeto este programa pode ser melhorado ainda mais? Sim.

275
00:16:22,680 --> 00:16:28,280
[Resposta do aluno inaudível] >> Ah, bom.

276
00:16:28,280 --> 00:16:32,120
Então, lembro que foi introduzida uma segunda variável chamada n última vez,

277
00:16:32,120 --> 00:16:34,850
que parece estar nos contradizendo porque meu objetivo um segundo atrás

278
00:16:34,850 --> 00:16:37,380
era só para jogar fora uma variável como desnecessário,

279
00:16:37,380 --> 00:16:40,700
mas lembro que na quarta-feira que realmente fez isso.

280
00:16:40,700 --> 00:16:46,170
Eu mudei o loop for para realmente ter uma vírgula aqui, então n = strlen,

281
00:16:46,170 --> 00:16:52,120
e então aqui eu fiz i <n, então eu fiz meus incrementos.

282
00:16:52,120 --> 00:16:57,660
Qual é o ganho fundamental que eu estou mudando minha alcançar inicialização para este

283
00:16:57,660 --> 00:17:01,590
e minha condição para isso agora? >> [Resposta do aluno inaudível] >> Exatamente.

284
00:17:01,590 --> 00:17:06,170
Eu não estou lembrando strlen de novo e de novo e de novo, porque lembram como a de obras de laço.

285
00:17:06,170 --> 00:17:08,790
Mesmo se eles começam a ficar mais complicadas para o futuro,

286
00:17:08,790 --> 00:17:12,480
Recordamos que a coisa antes do ponto e vírgula primeira é a inicialização, o que acontece uma vez.

287
00:17:12,480 --> 00:17:14,359
A condição, no entanto, está no meio,

288
00:17:14,359 --> 00:17:17,710
e isso é verificado cada vez que você passar pelo loop.

289
00:17:17,710 --> 00:17:22,420
>> Então é meio idiota estar se perguntando o computador a mesma pergunta de novo e de novo -

290
00:17:22,420 --> 00:17:25,920
Qual é o comprimento da OLÁ? Qual é o comprimento da OLÁ? Qual é o comprimento da OLÁ? -

291
00:17:25,920 --> 00:17:29,740
porque como vamos ver hoje e na quarta-feira, este é definitivamente vai levar tempo,

292
00:17:29,740 --> 00:17:34,320
e não é um bom uso do tempo, porque para descobrir o comprimento de uma string

293
00:17:34,320 --> 00:17:37,030
na verdade, leva um pouco de esforço.

294
00:17:37,030 --> 00:17:39,760
Não é instantânea, como é em certas línguas.

295
00:17:39,760 --> 00:17:43,920
Então, mudando isto a n, o preço que eu estou pagando é o quê?

296
00:17:43,920 --> 00:17:45,640
Estamos vendo um trade-off aqui.

297
00:17:45,640 --> 00:17:49,460
Eu posso ganhar tempo não fazendo a mesma pergunta maldita de novo e de novo,

298
00:17:49,460 --> 00:17:51,740
mas vai custar-me uma coisa, que é o que?

299
00:17:51,740 --> 00:17:55,050
>> [Aluno] Você perde uma certa quantidade de memória. >> Exatamente. Vai custar-me um pouco de memória.

300
00:17:55,050 --> 00:17:56,670
Portanto, neste caso custa-me o quê?

301
00:17:56,670 --> 00:18:01,530
Outros 32 bits porque n é apenas um int, como implicado pelo int palavra aqui.

302
00:18:01,530 --> 00:18:03,300
Mas tudo bem?

303
00:18:03,300 --> 00:18:05,800
Francamente, isso é provavelmente tudo bem, porque se você pensar sobre isso,

304
00:18:05,800 --> 00:18:09,030
o mais longo da cadeia é, quanto mais tempo eu vou estar perdendo

305
00:18:09,030 --> 00:18:11,920
strlen porque vai ficar chamado novamente e de novo e de novo

306
00:18:11,920 --> 00:18:13,520
para cada iteração do loop.

307
00:18:13,520 --> 00:18:18,070
E estes dias, o meu Mac tem 2 GB de memória RAM, estes dias 4 GB de RAM, às vezes.

308
00:18:18,070 --> 00:18:22,420
Eu acho que eu posso pagar quatro desses bytes para realmente acelerar as coisas.

309
00:18:22,420 --> 00:18:26,590
Mas este vai ser um trade-off e um tema muito na programação e na ciência da computação

310
00:18:26,590 --> 00:18:28,320
de nunca conseguir nada de graça.

311
00:18:28,320 --> 00:18:32,880
Se você quer melhorar algo aqui, você tem que pagar por isso no outro lado de algum modo.

312
00:18:32,880 --> 00:18:35,880
Espaço em função do tempo neste caso.

313
00:18:35,880 --> 00:18:40,700
>> Então, tudo isso foi levando-se em direção a algo enigmático como este,

314
00:18:40,700 --> 00:18:44,070
que, como você deve ter percebido até agora, realmente diz?

315
00:18:44,070 --> 00:18:47,420
[Resposta do aluno inaudível] >> Sim, por isso esta é, Certifique-se de beber o seu Ovomaltine,

316
00:18:47,420 --> 00:18:52,490
na verdade, usando um algoritmo chamado ROT13, ROT 1-3,

317
00:18:52,490 --> 00:18:55,500
significa apenas que rodar todas as letras 13 lugares,

318
00:18:55,500 --> 00:18:58,720
o que significa tomar uma e depois adicionar de 13 a ela e ir do ponto, ponto, ponto

319
00:18:58,720 --> 00:19:04,640
todo o caminho para a carta 13 para longe, fazer a mesma coisa para B e de C para D e assim por diante.

320
00:19:04,640 --> 00:19:10,850
E assim se realmente converter este aqui, usando um deslocamento de 13 lugares,

321
00:19:10,850 --> 00:19:14,580
vamos voltar ao que Ralphie pouco teve, que foi, Certifique-se de beber o seu Ovomaltine.

322
00:19:14,580 --> 00:19:18,160
Mas agora para o problema conjunto 2, na edição padrão, pelo menos,

323
00:19:18,160 --> 00:19:21,680
você tem que fazer isso tipo de cifragem mesmo,

324
00:19:21,680 --> 00:19:25,990
e nós temos que de alguma forma levar em entrada como esta e criptografá-la ou decifrá-lo.

325
00:19:25,990 --> 00:19:29,850
>> Então, qual destes tipo fundamentos de leva-nos a essa oportunidade?

326
00:19:29,850 --> 00:19:32,650
Vamos dar uma olhada neste terceiro exemplo aqui.

327
00:19:32,650 --> 00:19:38,430
Primeiro de tudo, ele é chamado ASCII. O que ASCII remeter para?

328
00:19:38,430 --> 00:19:40,460
American Standard Code Information Interchange,

329
00:19:40,460 --> 00:19:43,850
que é uma maneira muito longa de dizer o que? O que é ASCII?

330
00:19:43,850 --> 00:19:47,890
[Resposta do aluno inaudível] >> O que é isso? >> [Aluno] Um mapa de caracteres. Mapa >> Um personagem.

331
00:19:47,890 --> 00:19:51,390
Ele só mapeia números de letras, porque o mundo tem padronizado

332
00:19:51,390 --> 00:19:55,380
o que os números representam o que vai cartas para que todos nós podemos usar computadores

333
00:19:55,380 --> 00:19:59,340
e nossos programas são todos compatíveis apenas quando se trata de imprimir coisas na tela.

334
00:19:59,340 --> 00:20:04,680
Então, lembro que 65 acontece a representar A, 97 acontece a representar uma minúscula.

335
00:20:04,680 --> 00:20:08,510
E assim, este programa simples ASCII aqui está se aproveitando desse fato -

336
00:20:08,510 --> 00:20:12,770
que o mundo sabe que o capital Um é de 65 - e é só imprimir o mapeamento.

337
00:20:12,770 --> 00:20:16,320
>> Então, antes de mergulhar neste código, deixe-me em vez abrir uma janela de terminal.

338
00:20:16,320 --> 00:20:21,550
Deixe-me ir em frente e fazer ASCII, e depois vamos executar esta coisa apenas para estragar a saída.

339
00:20:21,550 --> 00:20:25,960
E ele só faz isso: um gráfico muito grande que só me diz que todos os códigos de vários

340
00:20:25,960 --> 00:20:27,950
para todas as várias letras.

341
00:20:27,950 --> 00:20:32,100
Assim, um programa super simples, mas eu não precisava código rígido essas 52 linhas de saída:

342
00:20:32,100 --> 00:20:34,860
26 letras maiúsculas, 26 minúsculas.

343
00:20:34,860 --> 00:20:37,790
Em vez disso, eu fiz isso programaticamente com um par de loops.

344
00:20:37,790 --> 00:20:39,720
Observe o que eu fiz aqui.

345
00:20:39,720 --> 00:20:44,790
Eu iterado de i é de 65 em até 65 + 26, porque eu queria imprimir 26 letras

346
00:20:44,790 --> 00:20:49,860
no alfabeto Inglês, i + + em cada iteração, e agora perceber isso novamente.

347
00:20:49,860 --> 00:20:52,540
É o retorno de nosso amigo typecasting

348
00:20:52,540 --> 00:20:54,620
pelo qual você converter um tipo de dados para outro

349
00:20:54,620 --> 00:20:57,480
porque o que eu quero fazer neste programa especial?

350
00:20:57,480 --> 00:21:02,650
Eu quero contar numericamente porque é assim que eu cresci contagem - 65, 66, 67, e assim por diante -

351
00:21:02,650 --> 00:21:04,420
mas eu não quero imprimir apenas os números.

352
00:21:04,420 --> 00:21:08,030
Quero imprimir a letra, seguido do número.

353
00:21:08,030 --> 00:21:18,640
Quero imprimir A: número, B: número, mas eu posso fazer isso com a mesma variável exata.

354
00:21:18,640 --> 00:21:21,630
Então eu imprimir c% como um espaço reservado para um personagem,

355
00:21:21,630 --> 00:21:25,080
D% como um espaço reservado para um dígito ou número.

356
00:21:25,080 --> 00:21:27,750
Então, o que eu ligar para esses dois espaços reservados?

357
00:21:27,750 --> 00:21:33,960
Eu ligar primeiro no equivalente caráter de i, e então eu imprimir i si.

358
00:21:33,960 --> 00:21:36,400
>> Então, observe isso também funciona.

359
00:21:36,400 --> 00:21:39,320
Assim como eu pode converter de um flutuador para um int

360
00:21:39,320 --> 00:21:41,750
, a fim de ir de um número real para um inteiro,

361
00:21:41,750 --> 00:21:46,100
aqui eu posso ir de um int para um char, que é um pouco estranho -

362
00:21:46,100 --> 00:21:48,680
não muito mapear para o mundo real - mas em computadores

363
00:21:48,680 --> 00:21:51,140
um char é apenas um número por baixo do capô,

364
00:21:51,140 --> 00:21:53,590
por isso estamos sendo sempre tão explícita aqui para o computador, dizendo:

365
00:21:53,590 --> 00:21:58,920
printf, imprimir não fora eu como 65, imprimi-lo como seu equivalente numérico.

366
00:21:58,920 --> 00:22:02,110
E não é que eu tecnicamente não precisa disso.

367
00:22:02,110 --> 00:22:05,020
O que eu estava fazendo há pouco é explicitamente lançando

368
00:22:05,020 --> 00:22:08,760
especificando que tipo de dados eu quero ir de e para.

369
00:22:08,760 --> 00:22:11,840
Mas repare que eu já tenho esse espaço reservado c%

370
00:22:11,840 --> 00:22:14,930
e esse outro espaço reservado% c aqui.

371
00:22:14,930 --> 00:22:18,880
Mesmo que este não é int, o computador percebe que um char,

372
00:22:18,880 --> 00:22:21,080
é apenas um int debaixo do capô.

373
00:22:21,080 --> 00:22:25,100
>> Então, se eu realmente recompilar esses e execute novamente o programa de ASCII,

374
00:22:25,100 --> 00:22:31,210
perceber que ainda só funciona porque o computador percebe que há essa correspondência.

375
00:22:31,210 --> 00:22:34,870
Agora, é mais importante fazer a conversão explícita no mundo dos carros alegóricos para ints

376
00:22:34,870 --> 00:22:37,460
porque na verdade você está fazendo uma decisão calculada:

377
00:22:37,460 --> 00:22:40,140
jogue fora tudo que vem depois do ponto decimal.

378
00:22:40,140 --> 00:22:44,990
Aqui não há nada para jogar fora porque um personagem é apenas um número,

379
00:22:44,990 --> 00:22:48,220
e uma corda é apenas uma matriz de caracteres.

380
00:22:48,220 --> 00:22:52,530
Então, quando chega a hora de implementar algumas criptografia ou descriptografia,

381
00:22:52,530 --> 00:22:56,770
como é que nós podemos realmente traduzir algo assim absurdo,

382
00:22:56,770 --> 00:22:58,670
Certifique-se de beber o seu Ovomaltine?

383
00:22:58,670 --> 00:23:02,700
O que se sabe agora - vamos tomar como premissa - que a chave,

384
00:23:02,700 --> 00:23:08,010
o número que está rodando todas estas letras por, é o número 13?

385
00:23:08,010 --> 00:23:11,800
Então, fomos de a letra B todo o caminho para o No início da frase,

386
00:23:11,800 --> 00:23:14,710
Certifique-se de beber o seu Ovomaltine, porque se eu fizer B

387
00:23:14,710 --> 00:23:19,600
e então eu vou C, D, E, F, G, H, I, J, K, L, M, N, O,

388
00:23:19,600 --> 00:23:23,760
é por isso que a criptografia da letra B torna-se O

389
00:23:23,760 --> 00:23:26,570
porque eu adicionei 13 a ele.

390
00:23:26,570 --> 00:23:33,460
>> Então, se eu quiser decifrar isso, eu essencialmente tem que tomar O e depois subtrair 13 a partir dele.

391
00:23:33,460 --> 00:23:36,880
Ou, francamente, porque há 26 letras no alfabeto, este é maravilhosamente simétrica,

392
00:23:36,880 --> 00:23:41,260
podemos também adicionar 13 e vamos voltar para a letra B.

393
00:23:41,260 --> 00:23:44,290
Mas como você vai fazer sobre a implementação de algo como isto em César

394
00:23:44,290 --> 00:23:46,600
ou realmente manipulando cordas em geral?

395
00:23:46,600 --> 00:23:51,380
Se a letra B é o número?

396
00:23:51,380 --> 00:23:55,290
Qual é a letra B? Então é 66, certo?

397
00:23:55,290 --> 00:23:59,220
Então, se a letra A é de 65 ea letra B é de 66,

398
00:23:59,220 --> 00:24:03,940
para 66, tudo o que tenho a fazer é adicionar 13 para ele, e isso me dá 79.

399
00:24:03,940 --> 00:24:09,150
E se formos para a nossa folha de fraude pouco, na verdade 79 mapas no O.

400
00:24:09,150 --> 00:24:11,290
>> Mas há um pouco de um caso de canto aqui.

401
00:24:11,290 --> 00:24:15,170
O que é, digamos, a letra Z?

402
00:24:15,170 --> 00:24:20,180
Se fizermos 66 + 25 para obter todo o caminho até o fim do alfabeto, estamos em 91.

403
00:24:20,180 --> 00:24:24,520
91 + 13 me dá 104, e adivinhem?

404
00:24:24,520 --> 00:24:29,200
104 não é igual uma letra maiúscula.

405
00:24:29,200 --> 00:24:31,610
Vamos voltar a uma cábula pouco aqui.

406
00:24:31,610 --> 00:24:38,070
Se eu executar novamente este programa no aparelho, observe que 104, se eu voltar para a janela do terminal,

407
00:24:38,070 --> 00:24:41,800
104 é, aparentemente, o h minúsculo.

408
00:24:41,800 --> 00:24:46,400
Então precisamos de algum truque chave aqui, a fim de se certificar de que quando começamos a Z

409
00:24:46,400 --> 00:24:50,260
e adicionar 13 a ele que não quer apenas seguir em frente aos números cada vez maiores.

410
00:24:50,260 --> 00:24:52,600
O que nós realmente queremos fazer?

411
00:24:52,600 --> 00:24:54,570
Você quer envolver.

412
00:24:54,570 --> 00:25:00,250
>> Então não é que, como você viu, provavelmente, na secção de agora ou no conjunto de especificações problema em si

413
00:25:00,250 --> 00:25:05,730
percebi que há este outro operador em C, que também é um sinal de porcentagem,

414
00:25:05,730 --> 00:25:11,020
mas que nós usamos% aqui para especificar um espaço reservado,

415
00:25:11,020 --> 00:25:15,420
sabe que, especialmente para conjunto de problemas 2, há também algo como isto:

416
00:25:15,420 --> 00:25:18,990
int x =% y z.

417
00:25:18,990 --> 00:25:22,770
Deixe-me apresentar isso como uma forma muito genérica deste.

418
00:25:22,770 --> 00:25:25,580
Por cento significa que em uma linguagem de programação? >> [Aluno] Modulo.

419
00:25:25,580 --> 00:25:28,790
Modulo, que é uma maneira elegante de dizer o resto.

420
00:25:28,790 --> 00:25:31,620
Mesmo que não haja uma ligeira distinção com a definição lá,

421
00:25:31,620 --> 00:25:37,210
isso significa dividir y por z, mas não retornam o resultado dessa divisão;

422
00:25:37,210 --> 00:25:39,650
em vez disso, devolver o restante.

423
00:25:39,650 --> 00:25:47,390
>> Portanto, se y é 3, e, na verdade, z é realmente 2, 3 dividido por 2 é 1, com um resto de 1,

424
00:25:47,390 --> 00:25:51,550
então o que x realmente igual neste cenário? 1.

425
00:25:51,550 --> 00:25:54,540
Esse é um simples, a idéia de baixo nível.

426
00:25:54,540 --> 00:25:56,480
É preciso um pouco de tempo para obter a sua mente em torno dele

427
00:25:56,480 --> 00:25:58,740
porque é provavelmente um tempo desde que você ainda tinha de se preocupar com sobras

428
00:25:58,740 --> 00:26:01,160
e realmente usá-los para algo proposital,

429
00:26:01,160 --> 00:26:05,290
mas neste caso, o simples fato de que você pode ir de um número grande como 3

430
00:26:05,290 --> 00:26:08,920
a um número relativamente pequeno, como 2, e, em seguida, enrolar em torno eficazmente

431
00:26:08,920 --> 00:26:14,160
usando o restante para um valor menor como um vai ser um truque de valor inestimável

432
00:26:14,160 --> 00:26:17,690
que podemos usar ambos para algo como César e Vigenère esta outra coisa

433
00:26:17,690 --> 00:26:22,240
no conjunto de problemas 2, mas isso vai ser um truque recorrente ao longo do semestre.

434
00:26:22,240 --> 00:26:24,880
Esta idéia simples, simples de apenas tomar o restante em geral

435
00:26:24,880 --> 00:26:26,530
vai permitir-nos a envolver em torno.

436
00:26:26,530 --> 00:26:31,140
E quando começamos a jogar mais com matrizes, como começar a jogar mais com a memória em si,

437
00:26:31,140 --> 00:26:35,800
este vai se tornar mais e mais de um truque poderoso.

438
00:26:35,800 --> 00:26:43,420
>> Assim, quaisquer perguntas, então em ASCII ou a representação de strings como arrays?

439
00:26:43,420 --> 00:26:47,430
E nós vamos levá-la até um entalhe mais. Sim.

440
00:26:47,430 --> 00:26:52,350
[Pergunta estudante inaudível] >> Boa pergunta.

441
00:26:52,350 --> 00:26:55,370
O que significa quando uma variável tem um asterisco na frente dele?

442
00:26:55,370 --> 00:26:57,720
Deixe-me adiar a resposta de que em qualquer detalhe,

443
00:26:57,720 --> 00:27:00,100
mas que se refere a um tópico conhecido como um ponteiro.

444
00:27:00,100 --> 00:27:03,440
Ponteiros têm a ver com memória, e na verdade estamos hoje

445
00:27:03,440 --> 00:27:06,330
dar o primeiro passo em direção a essa discussão,

446
00:27:06,330 --> 00:27:08,600
mas por agora, deixe-me fazer de conta que a estrela não existe

447
00:27:08,600 --> 00:27:15,380
e vamos continuar chamando cordas cordas em vez de usar char *,

448
00:27:15,380 --> 00:27:19,530
que você provavelmente já viu antes e vou colocar na tela em um momento como um teaser.

449
00:27:19,530 --> 00:27:23,010
Então, nós vamos voltar a isso em detalhes muito mais do que muitos de vocês provavelmente vai gostar.

450
00:27:23,010 --> 00:27:25,760
Eventualmente, não hoje. Sim.

451
00:27:25,760 --> 00:27:42,810
>> [Pergunta estudante inaudível]

452
00:27:42,810 --> 00:27:47,080
Em que contexto você tem que fornecer o sinal para um personagem? >> [Estudante] Yeah.

453
00:27:47,080 --> 00:27:52,130
Então, por padrão, quando você não colocar a +, apenas números positivos são assumidos.

454
00:27:52,130 --> 00:27:55,390
Então, se basta escrever o número 1, é a 1 positivo.

455
00:27:55,390 --> 00:27:57,710
Se você realmente quiser especificar a negação de um valor,

456
00:27:57,710 --> 00:28:01,060
você literalmente tem que fazer -1 em seu teclado.

457
00:28:01,060 --> 00:28:20,440
Mas isso provavelmente não é a sua pergunta. >> [Resposta do aluno inaudível]

458
00:28:20,440 --> 00:28:22,200
>> Boa pergunta. Okay.

459
00:28:22,200 --> 00:28:24,970
Então, isso tem a ver, eu suponho, com algum tipo de bug você correu para

460
00:28:24,970 --> 00:28:27,640
porque você estava convertendo um inteiro para um personagem,

461
00:28:27,640 --> 00:28:29,780
mas de alguma forma a negatividade se envolveu,

462
00:28:29,780 --> 00:28:32,380
e assim o personagem só saiu munged de alguma forma.

463
00:28:32,380 --> 00:28:36,710
Então, por agora, deixe-me simplificar um pouco, até que volte a este tipo de assunto.

464
00:28:36,710 --> 00:28:39,570
Por agora, pense em coisas desta forma - e esta é uma simplificação exagerada.

465
00:28:39,570 --> 00:28:43,500
Mas no mundo de um inteiro, você tem quantos bits à sua disposição?

466
00:28:43,500 --> 00:28:45,190
Você tem 32 bits.

467
00:28:45,190 --> 00:28:49,030
E, até agora, nós já conversamos sobre o número total de inteiros que você pode, portanto, representam

468
00:28:49,030 --> 00:28:52,430
a cerca de 4 bilhões no total, porque você tem 32 bits,

469
00:28:52,430 --> 00:28:55,100
de modo que é 2 ao 32, de modo que é cerca de 4 bilhões de dólares.

470
00:28:55,100 --> 00:28:58,810
Mas vimos uma semana ou dois atrás, que você realmente não tem um intervalo de números

471
00:28:58,810 --> 00:29:01,240
em 0 até 4 bilhões.

472
00:29:01,240 --> 00:29:06,340
A faixa vai de vez cerca de 2 bilhões para negativo positivo 2 bilhões.

473
00:29:06,340 --> 00:29:10,990
Mas este, em seguida levanta a questão, como você representar a noção de negativo 2000000000

474
00:29:10,990 --> 00:29:13,260
muito menos negativo 1?

475
00:29:13,260 --> 00:29:17,960
Por agora, podemos simplificar e dizer que estamos indo para usar o bit mais à esquerda

476
00:29:17,960 --> 00:29:22,380
desses 32 bits, e se é um 1 é um número negativo,

477
00:29:22,380 --> 00:29:25,090
e se for um 0 é um número positivo.

478
00:29:25,090 --> 00:29:28,570
O problema com esta representação simplificada de números negativos

479
00:29:28,570 --> 00:29:33,700
é que se você estivesse deliberadamente ser inteligente e tentar converter a partir de um personagem para um número

480
00:29:33,700 --> 00:29:37,190
ou vice-versa, não há tal coisa como um caráter negativo.

481
00:29:37,190 --> 00:29:42,550
No mundo do ASCII, que utiliza apenas 8 bits, todas as 8 daqueles questão bits,

482
00:29:42,550 --> 00:29:46,810
eo bit mais à esquerda não tem nada a ver com a negatividade.

483
00:29:46,810 --> 00:29:49,670
E só para ficar claro, quando eu digo bits à esquerda,

484
00:29:49,670 --> 00:29:54,610
lembro que quando fizemos a nossa parte relacionados com exemplos na primeira semana

485
00:29:54,610 --> 00:30:02,570
Recordamos que traçamos coisas como 1001101, algo como isto.

486
00:30:02,570 --> 00:30:07,210
Quando eu digo a pouco mais à esquerda, eu literalmente significar a 1 que você escrever todo o caminho para a esquerda.

487
00:30:07,210 --> 00:30:11,910
Assim, no mundo de personagens, não há noção de negatividade,

488
00:30:11,910 --> 00:30:16,360
de modo que pouco mais à esquerda, na verdade, tem algo a ver com ASCII, nada a ver com a negatividade.

489
00:30:16,360 --> 00:30:19,390
>> Assim que parece - e fora de contexto, é difícil responder exatamente -

490
00:30:19,390 --> 00:30:25,840
mas de alguma forma, seu código foi confuso que pouco mais à esquerda como representando um valor negativo

491
00:30:25,840 --> 00:30:29,160
quando ele realmente fazia parte do personagem em questão.

492
00:30:29,160 --> 00:30:32,250
E novamente, eu estou simplificando demais, porque os computadores realmente fazer algo um pouco mais sofisticado

493
00:30:32,250 --> 00:30:37,080
do que apenas mudar esse bocado mais à esquerda para um 1 para o sinal negativo em relação a 0.

494
00:30:37,080 --> 00:30:41,270
Eles em vez disso, se você está curioso para o Google, usar algo tipicamente chamada de complemento de 2,

495
00:30:41,270 --> 00:30:43,830
que é um pouco mais sofisticada de uma abordagem

496
00:30:43,830 --> 00:30:45,490
mas a idéia é basicamente a mesma.

497
00:30:45,490 --> 00:30:50,530
>> Então, em suma, que tinha a ver com o fato de que você estava massageando um número para um personagem

498
00:30:50,530 --> 00:30:53,750
ou vice-versa, mas seu código não estava ciente do fato

499
00:30:53,750 --> 00:30:56,510
que um desses bits tinha um significado no mundo numérico.

500
00:30:56,510 --> 00:30:59,940
Esse não é o caso no mundo personagem.

501
00:30:59,940 --> 00:31:04,270
Mas parece que você fixa, caso em que discutível agora. Outras questões.

502
00:31:06,030 --> 00:31:07,110
Okay.

503
00:31:07,110 --> 00:31:11,560
Então, até agora, todos os programas que nós escrevemos ter tomado talvez entrada do usuário

504
00:31:11,560 --> 00:31:14,330
sob a forma de funções como GetInt, GetString,

505
00:31:14,330 --> 00:31:16,990
ou se você estiver lendo à frente em vários livros ou referências on-line,

506
00:31:16,990 --> 00:31:21,390
vós mesmos poderiam ter usado funções como scanf que, francamente, que nós usamos na biblioteca CS50.

507
00:31:21,390 --> 00:31:25,370
Mas em uma semana ou duas, vamos realmente mostrar-lhe como a biblioteca CS50 é implementado

508
00:31:25,370 --> 00:31:27,890
para que possamos tomar as rodinhas completamente.

509
00:31:27,890 --> 00:31:31,340
>> Mas acontece que não há outra forma de obter a entrada de um usuário.

510
00:31:31,340 --> 00:31:34,670
Na verdade, nós mesmos temos vindo a utilizar argumentos de linha de comando

511
00:31:34,670 --> 00:31:36,500
por um par de semanas.

512
00:31:36,500 --> 00:31:41,150
Cada vez que executar Clang ou temos executar o make,

513
00:31:41,150 --> 00:31:45,050
nós não apenas digitado bumbum, Enter, que não digitou fazer, Enter.

514
00:31:45,050 --> 00:31:49,340
O que nós normalmente escrito após o barulho palavra de nosso terminal prompt do Windows?

515
00:31:51,110 --> 00:31:52,900
[Estudante] O nome de arquivo. >> O nome do arquivo, certo?

516
00:31:52,900 --> 00:31:57,560
Hello.c ou mario.c ou qualquer que seja o nome do arquivo é relevante.

517
00:31:57,560 --> 00:32:01,910
E, nesse sentido, o que você realmente faz é você influenciado o comportamento de Clang

518
00:32:01,910 --> 00:32:05,750
porque certamente as pessoas que escreveram Clang não tinha idéia de que pouco velho você

519
00:32:05,750 --> 00:32:08,890
ia escrever um programa chamado mario.c anos mais tarde.

520
00:32:08,890 --> 00:32:13,150
Então você tinha de alguma forma influenciar o comportamento desse programa,

521
00:32:13,150 --> 00:32:18,140
e que Clang programa tinha de ser escrita de tal modo que ele pode aceitar entrada de você

522
00:32:18,140 --> 00:32:23,480
pela adição de palavras sobre o aviso antes de os golpes de usuário Enter.

523
00:32:23,480 --> 00:32:27,860
>> Assim, verifica-se que há algum tempo que temos vindo declarando quase todos os nossos programas

524
00:32:27,860 --> 00:32:32,840
começar assim - int main (void) - e então temos ido

525
00:32:32,840 --> 00:32:35,110
e comecei a escrever o nosso código.

526
00:32:35,110 --> 00:32:37,910
E que pode ter alguma afiado inclui, na parte superior do arquivo,

527
00:32:37,910 --> 00:32:40,660
mas quase todos os nossos programas, até agora, ter começado com esta

528
00:32:40,660 --> 00:32:44,200
mesmo que você pode ter visto em seção, em livros, referências on-line

529
00:32:44,200 --> 00:32:46,570
que isso não, na verdade tem que ser nula.

530
00:32:46,570 --> 00:32:55,820
Outra forma legítima para se fazer isso é int argc e argv corda [].

531
00:32:55,820 --> 00:32:57,500
Então agora o que é que isso implique?

532
00:32:57,500 --> 00:33:01,320
Acontece que argc, que é uma convenção humana - você poderia chamar isso de foo,

533
00:33:01,320 --> 00:33:03,710
mas que seria apenas muito menos claro para os leitores -

534
00:33:03,710 --> 00:33:09,330
argc é apenas um argumento para a função chamada principal que representa o que?

535
00:33:09,330 --> 00:33:12,450
O que argc representam para aqueles familiar?

536
00:33:12,450 --> 00:33:14,980
>> [Resposta do aluno inaudível] >> Sim, o número de argumentos ou de contagem de argumento.

537
00:33:14,980 --> 00:33:16,510
É tão simples como isso.

538
00:33:16,510 --> 00:33:19,160
Quantos argumentos foram passados ​​para este programa?

539
00:33:19,160 --> 00:33:20,630
O que significa isso?

540
00:33:20,630 --> 00:33:27,090
Se na linha de comando eu tenho que correr algo como isto - clang mario.c -

541
00:33:27,090 --> 00:33:35,440
argc quando eu pressione Enter vai assumir um valor, um pouco confusa, 2.

542
00:33:35,440 --> 00:33:40,150
Assim, verifica-se que argc é contagem de argumentos,

543
00:33:40,150 --> 00:33:46,280
mas, por razões históricas, o nome do próprio programa que está incluído na contagem.

544
00:33:46,280 --> 00:33:51,950
Então argc é 2 quando escrevi clang mario.c.

545
00:33:51,950 --> 00:33:54,290
O que argv contém?

546
00:33:54,290 --> 00:33:57,020
Em primeiro lugar, parece que argv uma cadeia mas não completamente

547
00:33:57,020 --> 00:33:59,310
porque a partir de quarta-feira passada e tudo o mais, hoje,

548
00:33:59,310 --> 00:34:02,890
estes colchetes denotam o que? Isso é um array.

549
00:34:02,890 --> 00:34:07,110
Não há nenhum número na matriz, e que deve fazer sentido intuitivamente

550
00:34:07,110 --> 00:34:10,790
porque as pessoas que escreveram anos atrás Clang certamente não tinha idéia

551
00:34:10,790 --> 00:34:16,300
pessoas quantas palavras como nós deve digitar no prompt antes de bater Enter.

552
00:34:16,300 --> 00:34:22,280
>> Portanto, neste caso aqui eles declararam que a principal função como tendo uma matriz de argumentos,

553
00:34:22,280 --> 00:34:24,590
0 ou mais argumentos.

554
00:34:24,590 --> 00:34:26,460
Eles não sabem de antemão quantos são,

555
00:34:26,460 --> 00:34:29,690
por isso não é deliberadamente não dentro número desses colchetes.

556
00:34:29,690 --> 00:34:32,750
Mas o fato de que os colchetes estão lá estão dizendo ao computador,

557
00:34:32,750 --> 00:34:34,639
esperar uma matriz.

558
00:34:34,639 --> 00:34:37,489
Argv é apenas notação abreviada para vetor argumento.

559
00:34:37,489 --> 00:34:39,889
Um vetor é uma maneira elegante de dizer matriz,

560
00:34:39,889 --> 00:34:42,980
e matriz é uma maneira elegante de dizer uma lista ou coleção.

561
00:34:42,980 --> 00:34:47,360
Então isto significa apenas que se você escrever principal como esta

562
00:34:47,360 --> 00:34:51,100
em vez de como como temos vindo a fazê-lo para o último par de semanas,

563
00:34:51,100 --> 00:34:54,699
seu programa agora tem o poder de aceitar os argumentos da linha de comando

564
00:34:54,699 --> 00:34:58,520
de modo que não mais se você tem que escrever mario e pressione a tecla Enter,

565
00:34:58,520 --> 00:35:01,610
em seguida, digite um número para quantos blocos de alta da pirâmide você quer ser,

566
00:35:01,610 --> 00:35:03,100
em seguida, pressione Enter novamente.

567
00:35:03,100 --> 00:35:07,720
Não precisa nem usar GetString mais ou GetInt ou GetFloat para esse assunto.

568
00:35:07,720 --> 00:35:12,370
Nós podemos apenas esperar que o usuário digite as palavras no prompt próprio

569
00:35:12,370 --> 00:35:16,850
assim como os autores do Clang decidiu que seria um programa muito chato

570
00:35:16,850 --> 00:35:20,550
se compilar o código que você clang primeiro digitado, pressione Enter,

571
00:35:20,550 --> 00:35:24,090
então nós dissemos para o usuário, por favor digite o nome do arquivo que você deseja compilar,

572
00:35:24,090 --> 00:35:26,920
então digitar mario.c e pressione Enter.

573
00:35:26,920 --> 00:35:29,850
Mas isso é exatamente o que estamos fazendo para os nossos usuários do casal últimas semanas.

574
00:35:29,850 --> 00:35:33,550
Usamos GetString e vamos esperar até que o programa está sendo executado para levá-los para a entrada.

575
00:35:33,550 --> 00:35:36,710
Que já não precisa ser o caso.

576
00:35:36,710 --> 00:35:41,160
>> Portanto, neste exemplo aqui, agora temos corda argv,

577
00:35:41,160 --> 00:35:43,390
e isso também é uma simplificação,

578
00:35:43,390 --> 00:35:45,610
rodinhas que muito em breve sair.

579
00:35:45,610 --> 00:35:50,860
Esta é a forma mais adequada de escrever esta declaração alternativa de principal

580
00:35:50,860 --> 00:35:54,740
pois verifica-se que o que nós continuar chamando corda tem realmente uma estrela,

581
00:35:54,740 --> 00:35:58,440
um asterisco, em sua própria definição, mas isso só parece complicado,

582
00:35:58,440 --> 00:36:02,600
é confuso no início, para que simplificar por apenas criar um sinônimo de sorte

583
00:36:02,600 --> 00:36:09,340
na biblioteca CS50 que mapeia char * para esta seqüência de palavras mais user-friendly.

584
00:36:09,340 --> 00:36:13,180
>> Então, vamos realmente tentar isso então. Deixe-me ir em frente e abrir gedit aqui.

585
00:36:13,180 --> 00:36:17,010
Deixe-me ir em frente e abrir argv de 1.

586
00:36:17,010 --> 00:36:21,620
Este programa imprime os argumentos aparentemente, mas em termos de inglês,

587
00:36:21,620 --> 00:36:26,290
ao olhar para este código, o que isso faz mais especificamente?

588
00:36:26,290 --> 00:36:35,910
Se eu digitar o comando a.out foo bar, o que é impresso em minha janela a preto e branco?

589
00:36:35,910 --> 00:36:41,260
A.out foo bar, Enter.

590
00:36:43,120 --> 00:36:48,300
Vá em frente. Sim. >> [Resposta do aluno inaudível]

591
00:36:48,300 --> 00:36:52,730
Bom. Então a.out, nova linha, foo, nova linha, bar, nova linha.

592
00:36:52,730 --> 00:36:54,980
Por que isso? Podemos certamente confirmar em apenas um momento.

593
00:36:54,980 --> 00:36:56,940
Este é o tipo de uma linha fofa de código.

594
00:36:56,940 --> 00:36:59,560
 Ele só imprime uma nova linha apenas para tornar as coisas mais bonitas na tela.

595
00:36:59,560 --> 00:37:03,730
Este é um ciclo que está interagindo em 0 até argc,

596
00:37:03,730 --> 00:37:07,210
e isto é incrementado em cada iteração + +.

597
00:37:07,210 --> 00:37:12,270
Portanto, este está dizendo agora imprimir uma seqüência, como implícito por este% s.

598
00:37:12,270 --> 00:37:16,460
Argv [i] é praticamente a mesma idéia do exemplo anterior.

599
00:37:16,460 --> 00:37:19,580
Nós costumávamos chamar a variável s, agora ele é chamado, de forma arbitrária, argv.

600
00:37:19,580 --> 00:37:24,270
Isto significa imprimir o argumento om que foi digitado na linha de comando,

601
00:37:24,270 --> 00:37:28,690
e depois de tudo isso é feito, apenas para uma boa medida imprimir outra nova linha.

602
00:37:28,690 --> 00:37:31,600
>> Então, vamos ver isso. Deixe-me abrir a janela de terminal.

603
00:37:31,600 --> 00:37:37,470
Deixe-me compilar argv de 1, e agora deixe-me correr argv de 1, Enter. Hmm. Okay.

604
00:37:37,470 --> 00:37:40,850
Vamos executar foo bar. Interessante. Baz.

605
00:37:40,850 --> 00:37:42,640
E se você já se perguntou por que eu escreva isso,

606
00:37:42,640 --> 00:37:45,010
isso é apenas uma convenção também ciência estúpido computador.

607
00:37:45,010 --> 00:37:48,050
O mundo muitas vezes precisa apenas marcadores verbais para palavras.

608
00:37:48,050 --> 00:37:50,090
Então, se você quiser falar sobre alguma corda genérica,

609
00:37:50,090 --> 00:37:53,250
cientistas da computação só tendem a dizer foo quando eles precisam de uma palavra aleatória,

610
00:37:53,250 --> 00:37:55,530
depois dizem bar se eles precisam de uma segunda palavra aleatória,

611
00:37:55,530 --> 00:37:59,100
depois dizem baz se eles precisam de uma terceira palavra, então eles dizem qux se eles precisam de uma palavra quarta,

612
00:37:59,100 --> 00:38:01,520
e depois há uma linha de grande debate religioso, como o que vem depois qux,

613
00:38:01,520 --> 00:38:04,940
assim você pode Google que, para descobrir o que a outra palavra arbitrária deve ser.

614
00:38:04,940 --> 00:38:07,480
Mas estes têm qualquer significado,

615
00:38:07,480 --> 00:38:10,100
embora foo bar, se você Google que, que não tem sentido,

616
00:38:10,100 --> 00:38:12,780
que faz parte da etimologia aqui.

617
00:38:12,780 --> 00:38:17,550
>> Então, tudo isso está a fazer, então, é a impressão de uma dessas cordas por linha.

618
00:38:17,550 --> 00:38:19,900
Então, se eu em vez disso, porém, queria ficar um pouco mais sofisticado,

619
00:38:19,900 --> 00:38:22,550
suponha que eu não queria imprimir cada string por linha;

620
00:38:22,550 --> 00:38:26,220
Eu queria imprimir cada personagem de cada string por linha.

621
00:38:26,220 --> 00:38:28,550
Como eu poderia fazer isso em vez?

622
00:38:28,550 --> 00:38:33,720
O que eu preciso para mudar sobre este programa se eu quiser imprimir não cada palavra

623
00:38:33,720 --> 00:38:37,290
mas eu quero imprimir cada palavra letra por letra por letra,

624
00:38:37,290 --> 00:38:40,590
em seguida, a carta palavra seguinte por letra por letra?

625
00:38:40,590 --> 00:38:43,650
Como podemos combinar essas idéias até agora? Sim.

626
00:38:43,650 --> 00:38:47,390
[Aluno]% c. >> Tudo bem. Então, em algum lugar precisa de um c%.

627
00:38:47,390 --> 00:38:50,680
Bom, porque eu não quero imprimir cadeias inteiras, eu quero imprimir caracteres. O que mais?

628
00:38:50,680 --> 00:38:54,290
>> [Resposta do aluno inaudível] >> interessante.

629
00:38:54,290 --> 00:38:56,860
Então precisamos de uma espécie de segunda dimensão aqui agora

630
00:38:56,860 --> 00:39:02,300
porque pensar em argv como uma matriz, mas é uma matriz de strings.

631
00:39:02,300 --> 00:39:07,170
Mas, como de, tipo, 15 minutos atrás, o que é uma string? É uma matriz de caracteres.

632
00:39:07,170 --> 00:39:12,320
Então, realmente, argv é uma matriz de uma matriz de caracteres,

633
00:39:12,320 --> 00:39:14,870
uma matriz de matrizes de caracteres.

634
00:39:14,870 --> 00:39:19,170
Assim, verifica-se que podemos usar anotações suporte apenas mais quadrados. Então, vamos fazer isso.

635
00:39:19,170 --> 00:39:23,650
No topo deste laço na linha 19, eu vou repetir a partir de i até argc,

636
00:39:23,650 --> 00:39:25,760
mas então eu vou fazer isso:

637
00:39:25,760 --> 00:39:27,580
para - Eu não posso usar i agora.

638
00:39:27,580 --> 00:39:30,300
Preciso de outra variável, porque eu quero iterar sobre as palavras

639
00:39:30,300 --> 00:39:32,640
mas depois também sobre as letras nas palavras

640
00:39:32,640 --> 00:39:37,280
Então eu meio que tem um eixo vertical e um eixo horizontal, tipo de conceitualmente.

641
00:39:37,280 --> 00:39:43,930
Então j int recebe 0, então eu quero fazer j enquanto j for menor que - e eu vou limpar isso um pouco.

642
00:39:43,930 --> 00:39:48,410
Como eu iterar sobre as letras em uma string? Fizemos isso há um momento.

643
00:39:48,410 --> 00:39:54,670
Strlen de argv [i]. Bom.

644
00:39:54,670 --> 00:39:57,860
E novamente, eu estou fazendo uma ineficiência pouco aqui, não criando n ou o que seja,

645
00:39:57,860 --> 00:39:59,610
mas vamos voltar a isso.

646
00:39:59,610 --> 00:40:03,270
>> Então, agora j + +. Agora eu tenho que recuar mais aqui.

647
00:40:03,270 --> 00:40:06,950
O que eu agora quero imprimir em cada iteração?

648
00:40:06,950 --> 00:40:09,720
[Resposta do aluno inaudível] >> Então [i] vai me dar a palavra.

649
00:40:09,720 --> 00:40:12,910
[I] [j], como uma espécie de matriz.

650
00:40:12,910 --> 00:40:14,810
Aqueles de vocês com a matemática y-fundos,

651
00:40:14,810 --> 00:40:19,340
somos um tipo de indexação ainda mais fundo nessa matriz ou esta matriz de matrizes,

652
00:40:19,340 --> 00:40:21,380
esta estrutura 2-dimensional.

653
00:40:21,380 --> 00:40:25,070
Então agora vamos ver o que acontece aqui. Deixe-me abrir a minha janela maior terminal.

654
00:40:25,070 --> 00:40:28,170
Deixe-me fazer reprise de argv de 1.

655
00:40:28,170 --> 00:40:33,090
E eu estraguei tudo aqui, o que é uma boa lição, porque eu também esqueci de fazer isso.

656
00:40:33,090 --> 00:40:37,150
Implicitamente declarando 'strlen' C função de biblioteca com unsigned tipo '-

657
00:40:37,150 --> 00:40:40,360
Eu não sei mesmo o que o resto do que isso significa, mas eu já vi isso antes,

658
00:40:40,360 --> 00:40:42,000
implicitamente declarando.

659
00:40:42,000 --> 00:40:45,540
Sempre que vemos esse erro, o que é que isso geralmente significa?

660
00:40:45,540 --> 00:40:48,520
>> [Resposta do aluno inaudível] >> eu esqueci uma biblioteca em cima. Mas espere um minuto.

661
00:40:48,520 --> 00:40:51,690
Normalmente eu estraguei tudo porque eu esqueci a biblioteca CS50, mas que está lá.

662
00:40:51,690 --> 00:40:54,480
Normalmente eu estraguei tudo porque esqueci padrão de I / O.

663
00:40:54,480 --> 00:40:57,960
E, francamente, eu nem preciso disso. Nós não estamos usando GetString hoje.

664
00:40:57,960 --> 00:40:59,900
Então, o que eu estou ausente?

665
00:40:59,900 --> 00:41:04,860
Há uma outra biblioteca que agora precisamos usar string.h chamado ocasionalmente,

666
00:41:04,860 --> 00:41:08,980
e esta é apenas mais uma biblioteca que tem mais funções que não estão no padrão de I / O.

667
00:41:08,980 --> 00:41:11,640
>> Então, vamos voltar para a minha janela de terminal grande.

668
00:41:11,640 --> 00:41:16,670
Okay. Agora, droga, eu acho que eu estava errado. Eu estava usando a biblioteca CS50.

669
00:41:16,670 --> 00:41:18,460
Assim, podemos corrigir isso em qualquer uma das duas maneiras.

670
00:41:18,460 --> 00:41:21,510
Podemos tomar as rodinhas agora e só fazer isso,

671
00:41:21,510 --> 00:41:26,600
ou tipo vamos de manter essa simplificação só para agora, cole este de volta,

672
00:41:26,600 --> 00:41:30,180
resolver esse problema, e agora voltar para a janela de terminal.

673
00:41:30,180 --> 00:41:33,080
Então, para ser claro, na biblioteca CS50 não é apenas funções,

674
00:41:33,080 --> 00:41:36,920
é também a seqüência de palavras-chave, que é por isso que o erro aconteceu.

675
00:41:36,920 --> 00:41:43,010
>> Então, vamos lá. I fixado de ambos os problemas de bibliotecas. Enter. Bom.

676
00:41:43,010 --> 00:41:49,250
Argv de 1, foo bar, Enter. Excelente.

677
00:41:49,250 --> 00:41:52,830
Portanto, agora temos cada letra de cada palavra impressa uma por linha,

678
00:41:52,830 --> 00:41:55,290
o que não faz um programa muito interessante,

679
00:41:55,290 --> 00:41:59,350
mas observe agora temos a capacidade de não só iterando palavras

680
00:41:59,350 --> 00:42:04,090
mas também sobre as letras individuais em palavras, o que soa muito familiar

681
00:42:04,090 --> 00:42:10,330
até mesmo a mais simples das aplicações, como cartas lutando em uma string como esta.

682
00:42:10,330 --> 00:42:12,410
Vamos em frente e tomar o nosso intervalo de 5 minutos aqui.

683
00:42:12,410 --> 00:42:14,410
E quando voltar, vamos começar a falar sobre a eficiência

684
00:42:14,410 --> 00:42:17,670
com a qual podemos fazer essas coisas melhor.

685
00:42:19,370 --> 00:42:21,900
>> Tudo bem. Estamos de volta.

686
00:42:21,900 --> 00:42:26,970
Graças a um de nossos TFs que joga um monte de bananagrams,

687
00:42:26,970 --> 00:42:30,000
nós realmente temos um monte de caracteres com a gente aqui hoje

688
00:42:30,000 --> 00:42:32,520
fisicamente encarnado com estes pequenos pedaços de plástico,

689
00:42:32,520 --> 00:42:36,910
e deixe-me propor que esta lousa em branco aqui representa a memória RAM no meu computador -

690
00:42:36,910 --> 00:42:39,790
desktop, laptop, o que quer - e não se parece com um monte de que

691
00:42:39,790 --> 00:42:44,090
porque se começarmos a cortar-se esta RAM em pequenos pedaços de bytes de tamanho,

692
00:42:44,090 --> 00:42:48,970
vamos arbitrariamente dizer que algo desse tamanho e que embaçada representa -

693
00:42:48,970 --> 00:42:52,430
lá vamos nós, e vamos afastar um pouco aqui -

694
00:42:52,430 --> 00:42:56,120
vamos dizer algo que tamanho representa um único byte.

695
00:42:56,120 --> 00:43:00,400
Assim, podemos de fato encaixar um monte de bytes ou caracteres dentro desta memória,

696
00:43:00,400 --> 00:43:02,860
tal como sugerido pelo tamanho relativo aqui.

697
00:43:02,860 --> 00:43:06,780
>> Então suponho que agora que o objetivo é alocar memória para uma string.

698
00:43:06,780 --> 00:43:08,680
Como é que isso realmente funciona?

699
00:43:08,680 --> 00:43:11,380
Nos programas que tenho escrito, nós geralmente usado GetString,

700
00:43:11,380 --> 00:43:16,300
mas agora, claramente, há este outro canal através do qual podemos obter a entrada do usuário em argv

701
00:43:16,300 --> 00:43:18,190
por meio de argumentos de linha de comando.

702
00:43:18,190 --> 00:43:20,580
Mas o que realmente está acontecendo debaixo do capô?

703
00:43:20,580 --> 00:43:24,920
Acontece que, se nós chamamos - vamos rolar de volta para GetString - a função GetString

704
00:43:24,920 --> 00:43:28,190
na biblioteca CS50, o usuário é solicitado para uma string,

705
00:43:28,190 --> 00:43:30,780
o usuário digita uma palavra - vamos chamá-lo OLÁ.

706
00:43:30,780 --> 00:43:35,410
E nós temos dito para o último par de semanas que o valor de retorno de GetString

707
00:43:35,410 --> 00:43:37,750
é de fato uma corda, como a palavra OLÁ.

708
00:43:37,750 --> 00:43:39,660
>> Mas o que está realmente fazendo GetString?

709
00:43:39,660 --> 00:43:45,230
Como o usuário digita em OLÁ, Enter, GetString é descobrir,

710
00:43:45,230 --> 00:43:47,930
bem, quantos caracteres é isso? Trata-se de H-E-L-L-S.

711
00:43:47,930 --> 00:43:52,500
Então ele precisa alocar, ele precisa pedir ao sistema operacional - Linux neste caso -

712
00:43:52,500 --> 00:43:55,410
durante pelo menos 5 bytes para armazenar OLÁ.

713
00:43:55,410 --> 00:43:59,570
E o que ele então começa a fazer uma vez que ele recebe de volta os 5 bytes do sistema operacional

714
00:43:59,570 --> 00:44:04,120
é estabelecer OLÁ volta para trás para voltar para trás.

715
00:44:04,120 --> 00:44:11,070
E então o que está realmente voltou de GetString é um pedaço de dados que se parece com isso.

716
00:44:11,070 --> 00:44:16,850
Mas isso é um pouco imprecisa porque verifica-se que não é tão simples

717
00:44:16,850 --> 00:44:20,310
como apenas armazenar OLÁ na memória do computador

718
00:44:20,310 --> 00:44:24,140
porque acho que o meu programa que eu estou escrevendo em C, então, chama GetString novamente,

719
00:44:24,140 --> 00:44:28,210
ea palavra seguinte, o usuário digita é tchau, tchau.

720
00:44:28,210 --> 00:44:31,300
Bem, eu preciso de encaixar que BYE palavra em algum lugar na memória.

721
00:44:31,300 --> 00:44:33,790
Eu não posso espancar OLÁ.

722
00:44:33,790 --> 00:44:37,320
Por exemplo, eu não quero que o computador apenas para começar a substituir como esta

723
00:44:37,320 --> 00:44:41,400
a palavra original, porque eu ainda poderia estar usando a palavra OLÁ em uma variável

724
00:44:41,400 --> 00:44:43,070
em outro lugar no meu programa.

725
00:44:43,070 --> 00:44:45,900
>> Então B-Y-E tem que acabar em algum outro lugar na memória.

726
00:44:45,900 --> 00:44:50,460
Mas a convenção é que normalmente a próxima seqüência de alocar

727
00:44:50,460 --> 00:44:54,940
Provavelmente, mas não sempre, vai acabar na próxima posição de memória disponível.

728
00:44:54,940 --> 00:44:57,370
E se eu não perguntei o sistema operacional para a memória

729
00:44:57,370 --> 00:45:01,380
desde a última vez eu chamei GetString, as probabilidades são a palavra BYE

730
00:45:01,380 --> 00:45:05,790
vai acabar logo após a palavra OLÁ na memória.

731
00:45:05,790 --> 00:45:10,550
Mas, neste ponto, você pode ver onde talvez um potencial problema surge.

732
00:45:10,550 --> 00:45:13,310
Porque os pedaços próximos de memória, os próximos bytes que eram apenas livre -

733
00:45:13,310 --> 00:45:18,230
limpar lousa branca - na memória do computador estavam ao lado OLÁ,

734
00:45:18,230 --> 00:45:23,670
parece que a primeira corda Pedi pode de repente mudar agora

735
00:45:23,670 --> 00:45:26,410
porque eu essencialmente mudou para HELLOBYE

736
00:45:26,410 --> 00:45:31,310
em vez de alguma forma, do início do demarcing BYE eo fim da OLÁ.

737
00:45:31,310 --> 00:45:33,920
>> Assim, verifica-se que o que realmente está acontecendo sob o capô,

738
00:45:33,920 --> 00:45:37,570
que você pode ter vislumbrado em referências on-line ou seção ou livros

739
00:45:37,570 --> 00:45:41,780
ou não em todos apenas ainda é a de que há realmente uma demarcação deliberada

740
00:45:41,780 --> 00:45:45,890
entre as palavras na memória de um computador.

741
00:45:45,890 --> 00:45:52,480
E, de fato, neste caso aqui, em vez de apenas colocar BYE ao lado OLÁ,

742
00:45:52,480 --> 00:45:58,610
em vez disso, o computador coloca um caractere especial, o caráter especial nulo, por assim dizer,

743
00:45:58,610 --> 00:46:03,050
o qual é representado com um marcador com barra invertida 0.

744
00:46:03,050 --> 00:46:06,700
Então, longa história curta, lembro que os personagens são representados em ASCII.

745
00:46:06,700 --> 00:46:09,680
ASCII é apenas um mapeamento entre números e letras,

746
00:46:09,680 --> 00:46:13,870
ea maioria dessas cartas começam cerca de 65 para capital de A,

747
00:46:13,870 --> 00:46:19,780
mas acontece que você pode certamente representar o número 0 como um inteiro ou em binário,

748
00:46:19,780 --> 00:46:22,690
e não é que o mundo resolveu muito, muito tempo atrás: "Você sabe o quê?"

749
00:46:22,690 --> 00:46:27,550
"Vamos 0 Número reserva como não representando quaisquer caracteres no teclado -

750
00:46:27,550 --> 00:46:30,810
"Sem letras, sem números, sem pontuação. 0 é especial."

751
00:46:30,810 --> 00:46:35,830
"Vai ser o caráter especial nulo, e nós estamos indo para escrevê-lo como \ 0".

752
00:46:35,830 --> 00:46:41,170
A diferença é se nós apenas escreveu 0, 0 é um personagem.

753
00:46:41,170 --> 00:46:45,700
Lembre-se que existem códigos ASCII para 0, para 1, para 2, para 3

754
00:46:45,700 --> 00:46:50,570
porque o 0 carácter é diferente do número 0.

755
00:46:50,570 --> 00:46:54,270
E você pode ver que se você olhar para trás de uma semana, quando falou pela primeira vez sobre o ASCII,

756
00:46:54,270 --> 00:46:59,130
0 e 1 e 2 e 3 de todo o caminho até aos 9 tinham os seus próprios códigos ASCII.

757
00:46:59,130 --> 00:47:02,300
Eles não são, coincidentemente, de 0 a 9. Eles são muito diferentes.

758
00:47:02,300 --> 00:47:08,770
Assim, 0 significa apenas "Eu sou especial", e os \ 0 significa, literalmente, "Eu não sou o personagem 0."

759
00:47:08,770 --> 00:47:11,360
"Eu sou este valor especial, o personagem nulo."

760
00:47:11,360 --> 00:47:16,930
Então, eu realmente preciso de outro destes já que não posso cometer o mesmo erro duas vezes.

761
00:47:16,930 --> 00:47:21,550
>> Assim, após a palavra BYE também vamos precisar de mais um desses caracteres nulos.

762
00:47:21,550 --> 00:47:27,090
Deixe-me pegar minha caneta aqui e deixe-me desenhar outro \ 0

763
00:47:27,090 --> 00:47:30,480
para que depois eu pedi o sistema operacional para duas cordas

764
00:47:30,480 --> 00:47:33,270
getString via seguida por outra chamada para GetString,

765
00:47:33,270 --> 00:47:35,640
isso é o que é realmente na memória.

766
00:47:35,640 --> 00:47:39,900
Então, quando eu voltar uma corda, eu estou realmente ficando para trás que,

767
00:47:39,900 --> 00:47:43,450
e quando eu começar a seqüência seguinte, eu estou realmente ficando para trás disso.

768
00:47:43,450 --> 00:47:47,910
Então, isso levanta a questão, strlen, antes de tudo, o que deveria voltar?

769
00:47:47,910 --> 00:47:54,650
Quando eu chamo strlen na cadeia s e s foi a palavra OLÁ que o usuário digitou,

770
00:47:54,650 --> 00:47:57,800
o que é que nós, obviamente, dizer que o comprimento da OLÁ foi há poucos minutos?

771
00:47:57,800 --> 00:48:01,290
Foi 5, certo? H-E-L-L-S. E isso é fato, como strlen obras.

772
00:48:01,290 --> 00:48:05,670
Ele retorna o que um ser humano normal seria esperar que o comprimento de uma string para ser.

773
00:48:05,670 --> 00:48:11,030
Mas, na realidade, quão grande é a matriz de caracteres que está armazenando Olá?

774
00:48:11,030 --> 00:48:12,770
É realmente 6.

775
00:48:12,770 --> 00:48:15,740
Então strlen não menciona esse fato para você.

776
00:48:15,740 --> 00:48:20,300
Mas debaixo do capô o computador está realmente usando 6 bytes para armazenar uma palavra de 5 letras,

777
00:48:20,300 --> 00:48:22,380
e isso é verdade, não importa quanto tempo é a palavra.

778
00:48:22,380 --> 00:48:26,470
Há sempre vai ser um personagem nulo especial encerra no final da string

779
00:48:26,470 --> 00:48:28,800
demarc para o seu comprimento total.

780
00:48:28,800 --> 00:48:33,430
>> Então, se você está agora a pessoa implementação strlen 20, 30 anos atrás,

781
00:48:33,430 --> 00:48:35,520
como você vai fazer sobre a implementação de strlen si?

782
00:48:35,520 --> 00:48:39,980
Tomamos por certo que ele existe, assim como nós tomamos por certo que printf existe,

783
00:48:39,980 --> 00:48:42,850
mas se OLÁ é a palavra em questão

784
00:48:42,850 --> 00:48:45,220
eo que eu tenho na memória é algo que se parece com isso,

785
00:48:45,220 --> 00:48:48,130
se você tivesse que reimplementar strlen porque lhe foi pedido para

786
00:48:48,130 --> 00:48:50,260
ou porque, francamente, você não sabia que existia strlen -

787
00:48:50,260 --> 00:48:54,280
você tinha que rolar um presente por conta própria - como você pode implementar strlen

788
00:48:54,280 --> 00:48:57,760
quando recebe algo que se parece com isso?

789
00:48:57,760 --> 00:49:02,750
Agora que sabemos que uma string é uma matriz, podemos iterar sobre cada um dos personagens individuais

790
00:49:02,750 --> 00:49:06,320
usando algo como - Vamos tentar fazer isso em tempo real.

791
00:49:06,320 --> 00:49:12,060
>> Deixe-me ir para dentro do aparelho. Deixe-me criar um novo arquivo, strlen.c.

792
00:49:12,060 --> 00:49:19,260
Deixe-me ir em frente agora e não incluem stdio.h para que tenhamos acesso a printf.

793
00:49:19,260 --> 00:49:25,820
Deixe-me fazer int (void) principal. Oh. Eu só vou fazer isso no meu próprio para agora então. [Risos]

794
00:49:25,820 --> 00:49:28,300
Obrigado.

795
00:49:28,300 --> 00:49:31,000
Isto é o que eu estou fazendo. Tudo bem.

796
00:49:31,000 --> 00:49:34,820
Então, antes de me virar na tela, eu digitei tudo isso.

797
00:49:34,820 --> 00:49:37,550
E agora o que eu vou fazer é o seguinte:

798
00:49:37,550 --> 00:49:40,360
printf ("Dê-me uma string:")

799
00:49:40,360 --> 00:49:42,700
Isso é só instruções macias.

800
00:49:42,700 --> 00:49:45,700
Agora deixe-me fazer GetString string s =.

801
00:49:45,700 --> 00:49:47,260
Eu já preciso fazer uma mudança agora.

802
00:49:47,260 --> 00:49:52,740
Eu estou usando a biblioteca CS50, de repente, então deixe-me ir em frente e digitar cs50.h.

803
00:49:52,740 --> 00:50:00,720
E agora vamos fazer isso: printf ("O comprimento é:% d, strlen [s] -

804
00:50:00,720 --> 00:50:03,540
e eu não estou pronto ainda. O que mais tenho a acrescentar a este programa?

805
00:50:03,540 --> 00:50:05,740
>> [Aluno] string.h. >> String.h.

806
00:50:05,740 --> 00:50:10,800
Então, por enquanto, estamos usando strlen, então vamos garantir que o compilador sabe onde fica,

807
00:50:10,800 --> 00:50:12,390
assim um pouco de sanidade verificar.

808
00:50:12,390 --> 00:50:16,400
Estou recebendo uma string na linha 8, e na linha 9 estou imprimindo sua extensão, com d%.

809
00:50:16,400 --> 00:50:19,400
Então, vamos em frente e abrir isso.

810
00:50:19,400 --> 00:50:23,380
Temos fazer strlen - compila bem -

811
00:50:23,380 --> 00:50:30,120
strlen - deixe-me aproximar - Digite, H-E-L-L-O, Enter. O comprimento é de 5.

812
00:50:30,120 --> 00:50:32,730
>> Ok, então strlen parece funcionar, mas o mundo sabia disso.

813
00:50:32,730 --> 00:50:37,310
Então, vamos agora implementar strlen-se como segue.

814
00:50:37,310 --> 00:50:39,490
Deixe-me tomar esta biblioteca de distância.

815
00:50:39,490 --> 00:50:42,590
Nós já não temos acesso a string.h porque eu nem sabia que existia.

816
00:50:42,590 --> 00:50:45,970
Mas tudo bem, porque eu posso implementar strlen me

817
00:50:45,970 --> 00:50:50,200
e tê-lo tomar uma string chamada de entrada,

818
00:50:50,200 --> 00:50:53,830
e agora eu preciso descobrir o comprimento da corda.

819
00:50:53,830 --> 00:50:55,880
Então, como posso fazer isso?

820
00:50:55,880 --> 00:51:00,190
E se eu fizer - vamos ver como fazer isso - O que você quer fazer?

821
00:51:00,190 --> 00:51:04,130
>> [Resposta do aluno inaudível] >> Okay.

822
00:51:04,130 --> 00:51:05,970
Assim, podemos fazer isso em um monte de maneiras. Deixe-me tentar tomar essa atitude.

823
00:51:05,970 --> 00:51:10,220
Deixe-me dar-me uma variável int i, para i começa em 0.

824
00:51:10,220 --> 00:51:19,380
E deixe-me dizer isto: enquanto a entrada [i] não é igual a que? \ 0.

825
00:51:19,380 --> 00:51:23,480
Então não é que, como é o caso com todos os caracteres quando escrever-lhes, literalmente, em um programa,

826
00:51:23,480 --> 00:51:25,940
você tem que usar aspas simples, não aspas duplas.

827
00:51:25,940 --> 00:51:29,250
Então, se eu estivesse escrevendo a letra, eu faria isso, a letra b, eu faria isso.

828
00:51:29,250 --> 00:51:33,440
Este, ao contrário, seria uma string, não caráter de um indivíduo.

829
00:51:33,440 --> 00:51:38,470
>> Então, eu quero \ 0 literalmente. O que eu quero fazer neste loop?

830
00:51:38,470 --> 00:51:42,650
Na verdade, eu preciso de outra variável, de modo comprimento int recebe 0.

831
00:51:42,650 --> 00:51:46,190
Mesmo se você não estava certo porque nós começamos a maneira como o fez,

832
00:51:46,190 --> 00:51:50,110
agora que estamos indo por este caminho, o que eu quero fazer na linha 9?

833
00:51:50,110 --> 00:51:55,820
comprimento + + e depois aqui na linha 10, comprimento retorno.

834
00:51:55,820 --> 00:51:58,370
Então, como é strlen implementado?

835
00:51:58,370 --> 00:52:00,550
É realmente implementado provavelmente como este.

836
00:52:00,550 --> 00:52:03,470
Talvez a pessoa usou um laço for, talvez um fazer enquanto loop - quem sabe?

837
00:52:03,470 --> 00:52:05,940
Nós realmente temos que olhar debaixo do capô o código fonte real

838
00:52:05,940 --> 00:52:08,520
em algum arquivo chamado string.c provavelmente.

839
00:52:08,520 --> 00:52:10,480
>> Mas aqui vamos pensar sobre o que eu estou fazendo.

840
00:52:10,480 --> 00:52:13,640
Estou declarando uma variável chamada i, definindo-o igual a 0.

841
00:52:13,640 --> 00:52:17,520
Estou em seguida, declarando outro comprimento variável chamada, colocando-a igual a 0.

842
00:52:17,520 --> 00:52:25,440
Então eu estou dizendo quando o personagem om na entrada não é igual ao caractere nulo especial, \ 0,

843
00:52:25,440 --> 00:52:27,070
incrementar o comprimento.

844
00:52:27,070 --> 00:52:32,550
Mas assim como o personagem om é este caráter especial, o que acontece com o loop?

845
00:52:32,550 --> 00:52:36,540
É curto-circuitos. Ela pára, o que significa que, em seguida, retornar instantaneamente comprimento.

846
00:52:36,540 --> 00:52:40,740
>> Então, se eu não errar, vamos em frente e voltar para a minha janela de terminal.

847
00:52:40,740 --> 00:52:43,550
Deixe-me recompilar. E eu errei.

848
00:52:43,550 --> 00:52:46,320
Redeclaração incompatível de biblioteca de função strlen.

849
00:52:46,320 --> 00:52:48,650
Então, eu estava tentando fazer demasiado inteligente para o meu próprio bem aqui.

850
00:52:48,650 --> 00:52:51,610
O compilador realmente sabe que existe uma função chamada strlen

851
00:52:51,610 --> 00:52:55,290
mesmo que não tenha incluído a biblioteca. Isso é bom. Qualquer que seja.

852
00:52:55,290 --> 00:52:58,230
Estamos apenas vai cooperar então. Vamos renomear este comprimento.

853
00:52:58,230 --> 00:53:04,110
Deixe-me mudar o uso do mesmo com o comprimento aqui, e isso vai fazer Clang mais feliz.

854
00:53:04,110 --> 00:53:08,900
Como um aparte, porque algumas dessas funções são tão danado comum -

855
00:53:08,900 --> 00:53:12,390
strlen, prinf - eles realmente têm uma espécie de estatuto especial.

856
00:53:12,390 --> 00:53:15,310
E assim Clang só sabe um pouco algo especial sobre eles.

857
00:53:15,310 --> 00:53:18,760
Isso nem sempre é o caso com a maioria das funções, de modo que é por isso que temos gritado.

858
00:53:18,760 --> 00:53:21,350
>> Deixe-me tentar novamente. Felizmente, deu certo naquele momento.

859
00:53:21,350 --> 00:53:23,560
Então, agora deixe-me executar o meu programa strlen própria.

860
00:53:23,560 --> 00:53:29,740
Dê-me uma string: H-E-L-L-O, Enter. E eu estraguei tudo.

861
00:53:29,740 --> 00:53:34,750
Por quê? >> [Resposta do aluno inaudível] >> Exatamente.

862
00:53:34,750 --> 00:53:39,180
Então, eu tenho-me aqui um laço muito bonito infinito

863
00:53:39,180 --> 00:53:42,270
porque mesmo que eu estou incrementando comprimento em cada iteração,

864
00:53:42,270 --> 00:53:47,860
o que eu claramente não está fazendo? Eu não estou incrementando i. Okay. Reparo fácil. Sim?

865
00:53:47,860 --> 00:53:52,430
Okay. Não. Agora nós entrar em conflito com algum outro erro comum onde eu preciso colchetes.

866
00:53:52,430 --> 00:53:54,430
E, francamente, este código está começando a olhar feio,

867
00:53:54,430 --> 00:53:56,460
então vamos tomar uma facada em limpar isso em um momento.

868
00:53:56,460 --> 00:53:58,810
Mas agora eu estou incrementando comprimento e i.

869
00:53:58,810 --> 00:54:02,630
Francamente, eu já vejo uma oportunidade de melhoria aqui, mas vamos voltar a isso.

870
00:54:02,630 --> 00:54:05,270
>> Então, agora vamos ter certeza que estamos pelo menos a fazer progressos.

871
00:54:05,270 --> 00:54:08,320
Isso aconteceu um pouco de você, e eu esqueci de mencionar isso com antecedência.

872
00:54:08,320 --> 00:54:12,420
Quando você tem a infelicidade de um cenário como este, como você corrigir isso

873
00:54:12,420 --> 00:54:15,130
curto de reiniciar o aparelho ou o computador ou fechar a janela?

874
00:54:15,130 --> 00:54:16,860
É realmente fácil.

875
00:54:16,860 --> 00:54:21,680
Controle C vai enviar esta pequena cenoura símbolo C, e que só termina a maioria dos programas.

876
00:54:21,680 --> 00:54:25,990
Se você tem um loop infinito muito ruim que está imprimindo vezes coisas infinitas,

877
00:54:25,990 --> 00:54:29,960
às vezes você pode ter que acertar C Controle mil vezes para torná-lo realmente ouvi-lo.

878
00:54:29,960 --> 00:54:33,910
Então, só agora percebo porque eu não estou imprimindo nada, que foi bastante fácil.

879
00:54:33,910 --> 00:54:37,970
E, tecnicamente, uma vez que é suficiente, mas eu fico impaciente e eu costumo bater tantas vezes.

880
00:54:37,970 --> 00:54:43,400
>> Então strlen. Dê-me uma string: OLÁ. Será que vai funcionar desta vez?

881
00:54:44,580 --> 00:54:47,490
Okay. Outro erro comum. Tem que recompilar.

882
00:54:47,490 --> 00:54:50,430
Isso foi proposital, que um. Tudo bem.

883
00:54:50,430 --> 00:54:54,260
Então strlen, H-E-L-L-O, Enter. Excelente.

884
00:54:54,260 --> 00:54:55,910
Assim, temos agora um strlen a 5.

885
00:54:55,910 --> 00:54:58,100
Portanto, temos que literalmente reimplemented roda.

886
00:54:58,100 --> 00:55:02,080
Então agora vamos limpar isto porque este não me faz impressionado

887
00:55:02,080 --> 00:55:04,080
com o desenho do meu código.

888
00:55:04,080 --> 00:55:07,200
O que podemos eliminar claramente neste programa para limpar isso?

889
00:55:07,200 --> 00:55:11,840
[Resposta do aluno inaudível] >> Yeah. Literalmente, estamos tratando i e comprimento de forma idêntica.

890
00:55:11,840 --> 00:55:16,440
Então, por que nós não apenas ficar esperto e dizer enquanto o comprimento?

891
00:55:16,440 --> 00:55:20,450
Em vez disso, vamos chamá-lo de comprimento, para começar, inicialize-a 0

892
00:55:20,450 --> 00:55:23,340
porque, por padrão a string não tem um comprimento até descobrir o que é.

893
00:55:23,340 --> 00:55:26,160
>> Agora vamos fazer isso, e agora este é um programa muito elegante.

894
00:55:26,160 --> 00:55:28,660
Uma variável. Limpei-a, apertou-se.

895
00:55:28,660 --> 00:55:31,980
Então agora vamos voltar para a minha janela de terminal. Vamos em frente e executar este.

896
00:55:31,980 --> 00:55:35,670
Faça strlen. Parece bom. Executar strlen novamente, Enter.

897
00:55:35,670 --> 00:55:40,680
Dê-me uma string: OLÁ, Enter. E isso parece estar funcionando como 5.

898
00:55:40,680 --> 00:55:45,580
Agora, para ser claro, se eu não tivesse escrito, por exemplo, em uma corda OLÁ

899
00:55:45,580 --> 00:55:48,840
e depois BYE em outro, certamente podemos ter várias palavras.

900
00:55:48,840 --> 00:55:53,150
Se a expressão que eu realmente queria escrever não era OLÁ, mas, por exemplo,

901
00:55:53,150 --> 00:55:58,920
OLÁ MUNDO, aviso de que o que nós não temos é essa situação aqui, certo?

902
00:55:58,920 --> 00:56:00,580
Isso sugeriria que isso é duas cordas.

903
00:56:00,580 --> 00:56:06,060
Você certamente pode ter caracteres barra de espaço, por isso, se nós realmente digitou uma frase mais longa

904
00:56:06,060 --> 00:56:08,390
como o mundo OLÁ, o que nós realmente temos na memória

905
00:56:08,390 --> 00:56:12,730
parece um pouco algo como aquilo lá.

906
00:56:12,730 --> 00:56:18,910
>> Tudo bem. Quaisquer perguntas, então sobre a representação aqui de cordas?

907
00:56:18,910 --> 00:56:20,450
Não? Tudo bem.

908
00:56:20,450 --> 00:56:25,130
Então, eu disse mais cedo que a chamada strlen novo e de novo como que deliberadamente

909
00:56:25,130 --> 00:56:28,070
provavelmente não é a melhor idéia, porque você vai estar fazendo um monte de trabalho

910
00:56:28,070 --> 00:56:30,280
de novo e de novo e de novo.

911
00:56:30,280 --> 00:56:36,150
Na verdade, o tipo de trabalho é necessário para descobrir o comprimento de uma corda, aparentemente?

912
00:56:36,150 --> 00:56:40,720
Você tem que começar no início e, em seguida, olha, olha, olha, olha, olha

913
00:56:40,720 --> 00:56:44,930
até que você finalmente ver que o caráter especial, altura em que, ah, agora eu sei o comprimento.

914
00:56:44,930 --> 00:56:48,040
Então, no início, quando tínhamos strlen sendo chamado de novo e de novo e de novo,

915
00:56:48,040 --> 00:56:52,080
a razão propus que era uma espécie de estúpida é porque mais uma vez, a corda parece assim.

916
00:56:52,080 --> 00:56:54,880
Não vai mudar cada vez que você percorrer alguns loop,

917
00:56:54,880 --> 00:56:56,890
então você está fazendo um trabalho desnecessário.

918
00:56:56,890 --> 00:57:00,620
Ao mesmo tempo, você deve saber, como um aparte, que os compiladores como Clang estes dias

919
00:57:00,620 --> 00:57:02,530
foram desenvolvidos ao longo de muitos anos,

920
00:57:02,530 --> 00:57:05,690
e escritores de compilador, programadores, são muito inteligentes.

921
00:57:05,690 --> 00:57:10,170
E assim acontece que compiladores Clang e outro pode realmente descobrir o que,

922
00:57:10,170 --> 00:57:13,650
Ok, sim, você escreveu strlen em sua condição,

923
00:57:13,650 --> 00:57:17,520
que tecnicamente significa que chamaríamos isso de novo e de novo e de novo.

924
00:57:17,520 --> 00:57:21,880
Mas compiladores inteligentes pode realmente otimizar esses tipos de decisões de usuários pobres

925
00:57:21,880 --> 00:57:23,870
de seu código para corrigir as coisas.

926
00:57:23,870 --> 00:57:27,360
>> Então, basta perceber que, por vezes, o compilador é mais inteligente do que nós

927
00:57:27,360 --> 00:57:29,210
e tipo de esconder nossos próprios erros.

928
00:57:29,210 --> 00:57:31,620
Mas certamente quando se trata de conjuntos de problemas e semelhantes,

929
00:57:31,620 --> 00:57:35,340
não estar pensando sobre essas decisões de design fundamentalmente errôneas

930
00:57:35,340 --> 00:57:38,110
potencialmente pela simples razão de que nós estaríamos fazendo o trabalho de forma mais

931
00:57:38,110 --> 00:57:41,330
do que realmente tem que fazer. Mas quanto mais trabalho?

932
00:57:41,330 --> 00:57:44,960
No caso do MUNDO OLÁ, vamos começar a generalizar o tamanho do problema.

933
00:57:44,960 --> 00:57:48,100
O que é o comprimento do problema ou a dimensão do problema

934
00:57:48,100 --> 00:57:50,770
quando a palavra que o usuário digitou é OLÁ?

935
00:57:50,770 --> 00:57:53,790
É, aparentemente, cinco, talvez seis. Mais ou menos 1. Qualquer que seja.

936
00:57:53,790 --> 00:57:55,680
É tão perto, vamos chamá-lo apenas 5.

937
00:57:55,680 --> 00:58:00,480
>> Então, qual é o tamanho do problema aqui ao tentar descobrir o comprimento da OLÁ?

938
00:58:00,480 --> 00:58:06,790
É 1, 2, 3, 4, 5, 6 e talvez para o último caractere, mas vamos generalizar que como n.

939
00:58:06,790 --> 00:58:10,300
Assim, n, n apenas a variável, é o que os cientistas da computação usaria normalmente

940
00:58:10,300 --> 00:58:13,890
para descrever o tamanho de um problema, e que o problema em questão é quanto tempo é OLÁ?

941
00:58:13,890 --> 00:58:17,050
Quanto tempo strlen tomar?

942
00:58:17,050 --> 00:58:21,010
Ela recebe a ordem dos passos de n, em que cada passo significa olhar para um caracter,

943
00:58:21,010 --> 00:58:23,350
olhar para um personagem, olhar para um personagem.

944
00:58:23,350 --> 00:58:26,850
E nós tivemos essa discussão um tempo atrás, o número de operações algo preciso.

945
00:58:26,850 --> 00:58:29,910
O primeiro dia de aula, tinha todos desajeitadamente em pé,

946
00:58:29,910 --> 00:58:32,060
e então todos começaram a emparelhar-se com o outro

947
00:58:32,060 --> 00:58:35,990
, a fim de realmente contar idealmente quantas pessoas estavam na sala.

948
00:58:35,990 --> 00:58:39,860
E também fez outra coisa em que se eu, em vez fez isso da maneira antiga escola

949
00:58:39,860 --> 00:58:44,800
de apenas a partir de 1, 2, 3, 4, 5, 6 e assim por diante,

950
00:58:44,800 --> 00:58:49,360
isso também, o tamanho desse problema era de tamanho n. Havia pessoas na sala n.

951
00:58:49,360 --> 00:58:52,010
Mas eu poderia acelerar isso, certo? Estilo de escola primária que eu poderia começar a contar em 2s.

952
00:58:52,010 --> 00:58:55,560
2, 4, 6, 8, 10, 12. E que se sente muito mais rápido, e de fato é.

953
00:58:55,560 --> 00:59:01,720
É literalmente duas vezes mais rápido, mas, novamente, se mais 400 pessoas entraram nesta sala

954
00:59:01,720 --> 00:59:08,250
tudo de uma vez, esses algoritmos levaria mais 400 ou talvez 200 passos.

955
00:59:08,250 --> 00:59:13,310
>> Mas por outro lado, se realmente ficar esperto e sim ter todos vocês considerem-se,

956
00:59:13,310 --> 00:59:15,280
lembrar como esse algoritmo funcionou.

957
00:59:15,280 --> 00:59:17,110
Você todos se levantaram. Deixe-me avançar para isso.

958
00:59:17,110 --> 00:59:20,430
Você todos se levantaram, você emparelhados, então metade do que você se sentou,

959
00:59:20,430 --> 00:59:22,510
metade de você se sentou, metade de você se sentou,

960
00:59:22,510 --> 00:59:27,350
e em cada iteração deste laço de semana 0, metade do problema na mão

961
00:59:27,350 --> 00:59:30,040
e foi a n / 2, então n / 4, então n / 8.

962
00:59:30,040 --> 00:59:35,350
E a implicação disso é que, se mais 400 pessoas a pé na sala, não é grande coisa,

963
00:59:35,350 --> 00:59:40,120
nos levará round 1 mais, não 400 mais rodadas, e não 200 mais rodadas.

964
00:59:40,120 --> 00:59:43,640
E assim a história que disse a um tempo atrás tinha que fazer alguma coisa com isso.

965
00:59:43,640 --> 00:59:47,750
Esta linha vermelha aqui é linear, é reta, e é classificado como n

966
00:59:47,750 --> 00:59:50,250
porque, como o tamanho de um problema cresce,

967
00:59:50,250 --> 00:59:54,690
se o seu algoritmo ou programa com o qual você está resolvendo é preciso n passos,

968
00:59:54,690 --> 00:59:58,620
podemos traçar-lo como uma linha recta onde ele leva mais tempo a maior dimensão do problema.

969
00:59:58,620 --> 01:00:03,280
E a abordagem twosies, contando 2, 4, 6, 8, ainda uma linha reta, apenas um pouco melhor.

970
01:00:03,280 --> 01:00:08,440
Leva um pouco de tempo menor, para que a linha amarela é abaixo do ponto de linha vermelha para o ponto.

971
01:00:08,440 --> 01:00:12,580
>> Mas o melhor mesmo era esse santo graal do que chamamos tempo logarítmico

972
01:00:12,580 --> 01:00:14,830
onde até mesmo se, novamente, o dobro do número de pessoas na sala,

973
01:00:14,830 --> 01:00:18,240
dobramos o tamanho da lista telefónica do primeiro dia de aula,

974
01:00:18,240 --> 01:00:22,310
não é grande coisa, é preciso uma lágrima mais página, leva uma sessão mais baixo

975
01:00:22,310 --> 01:00:25,550
a fim de resolver um problema que é duas vezes maior.

976
01:00:25,550 --> 01:00:27,460
E assim a conversa que começa agora a começar a ter é

977
01:00:27,460 --> 01:00:30,380
como é que vamos realmente resolver os problemas de forma eficiente

978
01:00:30,380 --> 01:00:32,510
se considerarmos o mais simples de problemas como este?

979
01:00:32,510 --> 01:00:36,210
Suponha que temos 8 portas por trás da qual estão alguns números,

980
01:00:36,210 --> 01:00:39,720
e cada um desses números não é classificada em qualquer forma,

981
01:00:39,720 --> 01:00:42,830
eles são apenas inteiros aleatórios por trás dessas portas,

982
01:00:42,830 --> 01:00:47,290
e fazemos a pergunta como você vai encontrar o número - quem sabe -

983
01:00:47,290 --> 01:00:50,250
7 por trás dessas portas?

984
01:00:50,250 --> 01:00:53,400
O que você, um ser humano, fazer a fim de encontrar-me o número 7

985
01:00:53,400 --> 01:00:56,810
Se novamente cada um deles são as portas e ver um valor que você tem que abrir uma porta?

986
01:00:56,810 --> 01:00:59,650
Qual seria o seu algoritmo de ser, talvez?

987
01:00:59,650 --> 01:01:05,310
>> [Resposta do aluno inaudível] >> Então comece com a esquerda e abrir uma porta, abre uma porta, abrir uma porta.

988
01:01:05,310 --> 01:01:08,570
E no pior dos casos, quanto tempo é que vai nos levar a encontrar o número 7?

989
01:01:08,570 --> 01:01:12,800
E, novamente, eles não são classificados, por isso não é tão fácil quanto, bem, eu vou abrir a porta 7.

990
01:01:12,800 --> 01:01:15,240
Ele poderia nos levar, no máximo, 8 etapas.

991
01:01:15,240 --> 01:01:19,940
No pior dos casos, 7 é aleatoriamente no final da linha de portas,

992
01:01:19,940 --> 01:01:22,090
assim que nós pode ter que tentar todas as portas n.

993
01:01:22,090 --> 01:01:24,440
Então, novamente aqui, parece que temos um algoritmo linear.

994
01:01:24,440 --> 01:01:27,030
Na verdade, fizemos isso apenas um par de anos atrás.

995
01:01:27,030 --> 01:01:29,910
Um de seus antecessores foi desafiado precisamente com este

996
01:01:29,910 --> 01:01:32,050
onde nós não temos uma versão digital, em vez teve um quadro negro

997
01:01:32,050 --> 01:01:33,780
com alguns pedaços de papel sobre ela.

998
01:01:33,780 --> 01:01:36,940
E o que eu pensei que eu gostaria de fazer é dar uma rápida olhada para trás em como este foi,

999
01:01:36,940 --> 01:01:40,760
uma das melhores oportunidades e, talvez mais difíceis no palco

1000
01:01:40,760 --> 01:01:42,530
de ter uma demonstração aqui na Sanders.

1001
01:01:42,530 --> 01:01:44,000
Tivemos duas linhas de números.

1002
01:01:44,000 --> 01:01:47,280
Só vamos olhar para o que acontece aqui com Sean para o topo dessas linhas.

1003
01:01:47,280 --> 01:01:49,660
A não ser que ninguém nunca mais voluntários em CS50,

1004
01:01:49,660 --> 01:01:52,010
tivemos a bênção de Sean para manter esta na câmera,

1005
01:01:52,010 --> 01:01:54,670
então ele sabe que centenas de pessoas foram assistir a este momento por anos.

1006
01:01:54,670 --> 01:01:59,500
Mas Sean fez um trabalho incrível - ou ele -? De realmente encontrar-nos um determinado número.

1007
01:01:59,500 --> 01:02:04,570
>> Então, vamos ver como ele resolveu esse algoritmo de modo que nós vamos retomar essa conversa antes de tempo

1008
01:02:04,570 --> 01:02:08,300
de como encontrar as coisas de forma eficiente.

1009
01:02:08,300 --> 01:02:12,300
[Malan em vídeo] eu ter escondido por trás dessas portas o número 7,

1010
01:02:12,300 --> 01:02:16,710
mas escondido em algumas dessas portas também são outros números não negativos,

1011
01:02:16,710 --> 01:02:19,980
e seu objetivo é pensar desta linha superior de números como apenas uma matriz

1012
01:02:19,980 --> 01:02:22,920
ou apenas uma seqüência de pedaços de papel com números por trás deles,

1013
01:02:22,920 --> 01:02:26,960
e seu objetivo é, apenas usando a matriz superior aqui, encontrar-me o número 7.

1014
01:02:26,960 --> 01:02:30,800
E estamos indo então para a crítica como você vai fazer sobre isso. >> Tudo bem.

1015
01:02:30,800 --> 01:02:33,880
[Malan] Encontre-nos o número 7, por favor.

1016
01:02:36,210 --> 01:02:38,350
[Risos]

1017
01:02:41,610 --> 01:02:44,460
[Malan] Não. [risos]

1018
01:02:45,760 --> 01:02:58,080
5, 19, 13, [risos]. Não é uma pergunta capciosa.

1019
01:03:00,560 --> 01:03:02,390
1.

1020
01:03:04,560 --> 01:03:06,910
[Risos]

1021
01:03:06,910 --> 01:03:10,760
Neste ponto, sua pontuação não é muito boa, então você pode muito bem continuar. [Risos]

1022
01:03:12,490 --> 01:03:14,070
3.

1023
01:03:17,340 --> 01:03:23,480
Vá em frente. Francamente, eu não posso ajudar, mas pergunto o que você está pensando mesmo. [Risos]

1024
01:03:25,010 --> 01:03:28,870
Apenas uma linha no topo, então você tem três esquerda. Então, encontrar-me 7.

1025
01:03:28,870 --> 01:03:45,360
[Estudantes murmurando]

1026
01:03:46,270 --> 01:03:49,870
[Malan] 17.

1027
01:03:49,870 --> 01:03:55,460
[Estudantes murmurando]

1028
01:03:56,920 --> 01:04:01,550
[Malan] 7! [Aplausos]

1029
01:04:01,550 --> 01:04:06,080
>> Então, na quarta-feira vamos mergulhar neste e algoritmos mais sofisticados para encontrar coisas.

1030
01:04:06,080 --> 01:04:10,200
Por agora, vou deixar você com Sean e ver você na quarta-feira.

1031
01:04:11,280 --> 01:04:13,000
[CS50.TV]