1
00:00:00,000 --> 00:00:12,410
>> [Música tocando]

2
00:00:12,410 --> 00:00:12,830
>> DAVID MALAN: Tudo bem.

3
00:00:12,830 --> 00:00:13,370
Bem-vindo de volta.

4
00:00:13,370 --> 00:00:16,510
Isto é CS50, e este é
Uma semana, continuação.

5
00:00:16,510 --> 00:00:20,050
Então, uma das razões que estamos passando
em torno de tecnologias como

6
00:00:20,050 --> 00:00:24,120
Google Glass é que eles vêm com
algo conhecido como uma API, um

7
00:00:24,120 --> 00:00:25,980
Interface de Programação de Aplicativos.

8
00:00:25,980 --> 00:00:28,830
E o que isto significa é que, com o
arquivos certo e com o direito

9
00:00:28,830 --> 00:00:32,850
documentação, você pode realmente escrever
software para dispositivos até mesmo como estes.

10
00:00:32,850 --> 00:00:36,200
>> E assim, o que temos em mente para
semestres final é, se um projeto

11
00:00:36,200 --> 00:00:39,310
envolvendo, por exemplo, vidro Google pode
recurso, vamos ver o que podemos fazer em

12
00:00:39,310 --> 00:00:42,220
termos de ligar-te com alguns
emprestado hardware, bem como o

13
00:00:42,220 --> 00:00:46,500
API publicamente acessível para que você possa
realmente começar a criar software

14
00:00:46,500 --> 00:00:48,630
que corre no mesmo vidro Google.

15
00:00:48,630 --> 00:00:51,710
>> Outro dispositivo que temos vindo a jogar
com de tarde que nós pensamos que poderia ser

16
00:00:51,710 --> 00:00:53,910
diversão no final do semestre é
esta coisinha aqui.

17
00:00:53,910 --> 00:00:56,860
É chamado Leap Movimento, e que você está
prestes a ver é tecnicamente um

18
00:00:56,860 --> 00:01:00,280
anúncio para o dispositivo, mas ele
fala o que neste particular

19
00:01:00,280 --> 00:01:01,240
dispositivo é capaz de fazer.

20
00:01:01,240 --> 00:01:05,550
E, também, vem com uma API via
que você pode escrever software para

21
00:01:05,550 --> 00:01:10,545
controlar seu próprio computador de forma
gosto muito deste filme de um minuto aqui.

22
00:01:10,545 --> 00:01:12,070
>> [REPRODUÇÃO]

23
00:01:12,070 --> 00:02:08,002

24
00:02:08,002 --> 00:02:08,590
>> [FIM REPRODUÇÃO DE VÍDEO]

25
00:02:08,590 --> 00:02:11,190
>> Então, agora, este dispositivo passa a
ser implementada como um pequeno USB

26
00:02:11,190 --> 00:02:14,290
conector que você pode ligar para o seu
computador, mas eu não ficaria surpreso

27
00:02:14,290 --> 00:02:17,930
se antes de tempo que tem esses tipos de
tecnologias no próximo lote de PCs

28
00:02:17,930 --> 00:02:20,510
e Macs para que você possa, de fato,
interagir com ela

29
00:02:20,510 --> 00:02:21,650
de forma semelhante.

30
00:02:21,650 --> 00:02:24,250
Na verdade, o que eu pensei que eu ia fazer, também, é
Puxei uma pequena demonstração

31
00:02:24,250 --> 00:02:25,860
programa que vem com este software.

32
00:02:25,860 --> 00:02:28,700
Então eu coloquei o pequeno sensor de
na frente do meu laptop.

33
00:02:28,700 --> 00:02:32,420
>> E como você pode ver, ele já percebe
que minha mão está lá

34
00:02:32,420 --> 00:02:33,400
controlá-la.

35
00:02:33,400 --> 00:02:37,900
E toda esta aplicação faz é
maravilhas pequenas coisas como esta.

36
00:02:37,900 --> 00:02:41,080
Mas você pode ver que, de fato,
Eu tenho cinco dedos lá.

37
00:02:41,080 --> 00:02:44,270
Se conseguirmos que ele faça todos os 10,
você pode imaginar um piano limpo

38
00:02:44,270 --> 00:02:45,390
aplicação ou semelhante.

39
00:02:45,390 --> 00:02:47,820
Então, se você gostaria de vir até depois da aula
hoje e brincar com isso como

40
00:02:47,820 --> 00:02:49,720
bem, você é bem-vindo.

41
00:02:49,720 --> 00:02:52,930
Então, mais sobre isso mais para o final do semestre.

42
00:02:52,930 --> 00:02:54,420
>> Assim, um par de administrativa
anúncios.

43
00:02:54,420 --> 00:02:58,690
Um deles, por fazer parte desta sexta-feira
ao meio-dia cs60.net/section.

44
00:02:58,690 --> 00:03:01,260
Essa URL é sobre o curso de
página inicial também.

45
00:03:01,260 --> 00:03:04,010
Nesse meio tempo, porém, supersections
vai estrear neste domingo.

46
00:03:04,010 --> 00:03:07,800
Supersections são uma coisa de uma só vez,
porque nos leva algum tempo para trabalhar

47
00:03:07,800 --> 00:03:09,470
quem está em qual seção e onde.

48
00:03:09,470 --> 00:03:12,280
>> Portanto, este próximo domingo, haverá uma
seção para aqueles menos confortável,

49
00:03:12,280 --> 00:03:14,040
uma seção para aqueles
mais confortável.

50
00:03:14,040 --> 00:03:16,110
E aqueles de vocês em algum lugar
entre são bem-vindos para ir para

51
00:03:16,110 --> 00:03:17,850
um ou ambos ou nenhum.

52
00:03:17,850 --> 00:03:19,150
Ambos serão filmadas.

53
00:03:19,150 --> 00:03:22,740
Eles vão estar em um auditório maior do que
uma secção normalmente estaria dentro

54
00:03:22,740 --> 00:03:26,110
Mas o objetivo aqui é equipá-lo com
algum conforto com um conjunto de problemas,

55
00:03:26,110 --> 00:03:29,910
com C, com o aparelho CS50, esta
fim de semana, antes mesmo de você descobrir o seu

56
00:03:29,910 --> 00:03:31,050
atribuição formal de seção.

57
00:03:31,050 --> 00:03:34,700
Então, você vai conhecer o seu TF e sua menor
grupo de sectionmates em cerca de

58
00:03:34,700 --> 00:03:36,350
tempo de uma semana.

59
00:03:36,350 --> 00:03:38,200
>> Horário de expediente, por sua vez,
foram acontecendo.

60
00:03:38,200 --> 00:03:41,020
Fazer aproveitá-las hoje à noite ou
amanhã à noite, se você gostaria.

61
00:03:41,020 --> 00:03:43,460
Problema set 0 é devido na sexta-feira.

62
00:03:43,460 --> 00:03:46,680
Este é um dia mais tarde do que o
regular-programado quinta-feira.

63
00:03:46,680 --> 00:03:50,410
Mas, com um conjunto de problemas, você verá
que inclui alguns warm-up

64
00:03:50,410 --> 00:03:52,770
exercícios com o qual você se
pode estender sua

65
00:03:52,770 --> 00:03:54,660
Quinta-feira prazo para sexta-feira.

66
00:03:54,660 --> 00:03:58,410
Um conjunto de problemas, entretanto, vai estrear
no site da Claro no próximo

67
00:03:58,410 --> 00:04:02,000
Sexta-feira, se você gostaria de se enroscar com
como eu fiz era uma vez atrasado

68
00:04:02,000 --> 00:04:04,370
Sexta à noite no seu quarto.

69
00:04:04,370 --> 00:04:07,660
>> Então cs50.net/appliance é o lugar onde
você pode obter o aparelho CS50

70
00:04:07,660 --> 00:04:09,040
que começamos a usar na segunda-feira.

71
00:04:09,040 --> 00:04:10,140
Vamos usá-lo um pouco mais hoje.

72
00:04:10,140 --> 00:04:14,040
Mas a certeza de que o problema definido um
especificação irá orientá-lo através

73
00:04:14,040 --> 00:04:16,490
precisamente os passos que você precisa
para obter esse instalado e funcionando.

74
00:04:16,490 --> 00:04:22,120
Então não se preocupe em fazer isso antes
Pset 1, se você não preferir.

75
00:04:22,120 --> 00:04:22,660
>> Tudo bem.

76
00:04:22,660 --> 00:04:27,180
Então, nós olhamos na segunda-feira no código-fonte,
mas, no contexto de uma nova

77
00:04:27,180 --> 00:04:30,895
linguagem de programação, isto é, C. e C,
ao contrário de risco, não é gráfica.

78
00:04:30,895 --> 00:04:32,270
Não é Puzzle Pieces.

79
00:04:32,270 --> 00:04:34,450
É mais Inglês-como sintaxe.

80
00:04:34,450 --> 00:04:37,140
E há um par de passos envolvidos
realmente em escrever e executar um

81
00:04:37,140 --> 00:04:41,650
programa em C, pois além de fonte
código como este, você precisa de algo

82
00:04:41,650 --> 00:04:42,890
chamado compilador.

83
00:04:42,890 --> 00:04:46,682
E, em termos leigos, o que
não um compilador fazer por nós?

84
00:04:46,682 --> 00:04:47,650
Sim.

85
00:04:47,650 --> 00:04:51,040
>> ALUNO: Ele converte o código
que você escreve para 0s e 1s.

86
00:04:51,040 --> 00:04:51,151
>> DAVID MALAN: Ótimo.

87
00:04:51,151 --> 00:04:53,580
Por isso, o código que converte
nós escrevemos para 0s e 1s.

88
00:04:53,580 --> 00:04:57,730
Ele converte o chamado código fonte para
código objeto, o último dos quais parece

89
00:04:57,730 --> 00:04:59,140
um pouco algo como isto.

90
00:04:59,140 --> 00:05:02,860
E é a sua CPU, os cérebros dentro de
o computador, que, por causa da

91
00:05:02,860 --> 00:05:06,280
pessoas que criaram esses computadores,
sabe o que essas sequências

92
00:05:06,280 --> 00:05:07,460
média de 0s e 1s.

93
00:05:07,460 --> 00:05:08,640
>> Talvez isso signifique impressão.

94
00:05:08,640 --> 00:05:10,265
Talvez isso signifique disso.

95
00:05:10,265 --> 00:05:11,610
Talvez isso significa subtração.

96
00:05:11,610 --> 00:05:13,350
Talvez isso signifique exibir um gráfico.

97
00:05:13,350 --> 00:05:16,870
Existem padrões predefinidos de bits
que o mundo decidiu dizer

98
00:05:16,870 --> 00:05:17,700
certas coisas.

99
00:05:17,700 --> 00:05:20,760
Mas para a maior parte deste curso,
nós vamos trabalhar em um nível superior, e

100
00:05:20,760 --> 00:05:24,180
vamos tomar como certo que existem
coisas como compiladores que podem

101
00:05:24,180 --> 00:05:27,670
fazer a nossa função de código fonte
na forma como pretendemos.

102
00:05:27,670 --> 00:05:31,660
>> Assim, o programa que escreveu pela primeira vez na semana passada
e, em seguida, começaram a porta, de modo a

103
00:05:31,660 --> 00:05:33,920
falar, C esse passado
Segunda-feira, foi isso.

104
00:05:33,920 --> 00:05:35,700
Quando a bandeira verde clicado, dizer Olá.

105
00:05:35,700 --> 00:05:37,430
Este foi, claro,
escrito em risco.

106
00:05:37,430 --> 00:05:40,710
E afirmou que o equivalente
programa em C parecia um pouco

107
00:05:40,710 --> 00:05:41,520
algo como isto.

108
00:05:41,520 --> 00:05:45,050
>> Então o que eu pensei que iria fazer em primeiro lugar é,
vamos desmembrar o que parece, à primeira

109
00:05:45,050 --> 00:05:48,790
vista, na verdade, como bastante misterioso
sintaxe, mas você vai começar a notar

110
00:05:48,790 --> 00:05:50,160
padrões muito rapidamente.

111
00:05:50,160 --> 00:05:53,770
O que nós também vamos fazer hoje é fornecer
lo com um modelo mental para alguns

112
00:05:53,770 --> 00:05:57,280
canônico, algumas construções padrão
na programação.

113
00:05:57,280 --> 00:06:00,420
E então nós vamos realmente chegar em nossas mãos
sujo com alguns exemplos bem.

114
00:06:00,420 --> 00:06:04,140
>> Portanto, para aqueles de vocês mais confortável,
perceber que esta semana e, em seguida, ao lado

115
00:06:04,140 --> 00:06:05,940
semana pode muito bem ser um pouco de crítica.

116
00:06:05,940 --> 00:06:08,810
Mas, sobretudo quando a edição hackers
de um problema conjunto sai no

117
00:06:08,810 --> 00:06:12,330
site do curso na sexta-feira, eu acho que
você vai descobrir que, mesmo que você preencher

118
00:06:12,330 --> 00:06:15,390
algumas lacunas ao longo da próxima semana ou duas,
você vai começar a ficar cada vez mais

119
00:06:15,390 --> 00:06:18,410
desafiado e encontrar
coisas novas e mais recentes.

120
00:06:18,410 --> 00:06:21,310
>> Então, vamos provocar este programa para além
algumas linhas de cada vez.

121
00:06:21,310 --> 00:06:24,140
No topo, temos o que há de
tecnicamente chamado de

122
00:06:24,140 --> 00:06:25,950
diretiva de pré-processamento.

123
00:06:25,950 --> 00:06:30,510
Esta é apenas uma linha de código que diz
para incluir o conteúdo de um ficheiro,

124
00:06:30,510 --> 00:06:35,080
chamado padrão I / N, entrada padrão -
ou, desculpe, padrão I / O, padrão

125
00:06:35,080 --> 00:06:38,670
de entrada / saída. h, para dentro
do meu próprio programa.

126
00:06:38,670 --> 00:06:41,670
>> Portanto, em outras palavras, se eu escrevi isso
programa com um editor de texto simples como

127
00:06:41,670 --> 00:06:45,260
gedit, o equivalente a mais simples de
algo como o Microsoft Word, que

128
00:06:45,260 --> 00:06:50,970
instrução # include stdio.h, é apenas
vai dizer ao compilador, pegue o

129
00:06:50,970 --> 00:06:56,080
conteúdo do que outro arquivo, stdio.h,
e colá-los aqui.

130
00:06:56,080 --> 00:06:57,090
>> Agora, por que eu me importo?

131
00:06:57,090 --> 00:07:01,850
O que nós reivindicamos é dentro deste arquivo
stdio.h chamado, que é armazenado

132
00:07:01,850 --> 00:07:05,490
em algum lugar no meu disco rígido, ou neste
caso, em algum lugar do aparelho CS50?

133
00:07:05,490 --> 00:07:06,635
Alguém colocou lá para mim.

134
00:07:06,635 --> 00:07:09,910
Mas o que está nele?

135
00:07:09,910 --> 00:07:13,020
>> Sim, por isso é uma declaração de
uma função chamada printf.

136
00:07:13,020 --> 00:07:17,400
Então printf recorda a função que
exibe palavras e caracteres e

137
00:07:17,400 --> 00:07:20,160
números na tela de meu lance.

138
00:07:20,160 --> 00:07:21,220
Mas eu não queria escrever.

139
00:07:21,220 --> 00:07:22,230
CS50 não escrevê-lo.

140
00:07:22,230 --> 00:07:26,990
Anos atrás alguém escreveu, e eles
essencialmente nos deu a receita para isso

141
00:07:26,990 --> 00:07:29,110
em um arquivo chamado stdio.h.

142
00:07:29,110 --> 00:07:33,240
Assim que a primeira linha apenas me dá acesso
às funções que alguém

143
00:07:33,240 --> 00:07:36,500
escreveu anos atrás, entre
que são printf.

144
00:07:36,500 --> 00:07:39,450
>> Agora, a próxima linha que eu vou acenar minha
mão em, pelo menos até a próxima semana.

145
00:07:39,450 --> 00:07:43,620
Mas, por agora, saiba que int main (void) é
essencialmente o equivalente desta

146
00:07:43,620 --> 00:07:46,310
peça do puzzle amarelo quando
bandeira verde clicado.

147
00:07:46,310 --> 00:07:49,510
O mundo, há anos, decidiu que, se
você está escrevendo um programa no

148
00:07:49,510 --> 00:07:53,150
linguagem chamada C, você começa
o seu programa com uma linha

149
00:07:53,150 --> 00:07:54,410
que se parece com isso.

150
00:07:54,410 --> 00:07:57,650
Em apenas cerca de uma semana, ele vai fazer
sentido que int é, o que é vazio.

151
00:07:57,650 --> 00:08:00,840
Mas, por agora, apenas pense nisso
como esta peça do puzzle amarelo.

152
00:08:00,840 --> 00:08:04,550
>> Agora seguinte, temos uma chaveta seguido
por outro perto encaracolados cinta,

153
00:08:04,550 --> 00:08:05,240
por assim dizer.

154
00:08:05,240 --> 00:08:07,430
E vamos ver ao longo destes
programas em C, bem como a

155
00:08:07,430 --> 00:08:08,930
JavaScript e PHP.

156
00:08:08,930 --> 00:08:11,345
E estes apenas encapsular
linhas afins de código.

157
00:08:11,345 --> 00:08:14,600
O aberto chaveta essencialmente
diz, aí vem um código.

158
00:08:14,600 --> 00:08:17,590
E a chaveta fechada, o que é
inclinado na direção contrária, apenas

159
00:08:17,590 --> 00:08:19,920
significa, isso é tudo para
o código correspondente.

160
00:08:19,920 --> 00:08:22,970
>> Assim, a linha suculento neste primeiro
programa é a última, printf,

161
00:08:22,970 --> 00:08:25,080
entre aspas, Olá mundo.

162
00:08:25,080 --> 00:08:30,670
E eu chamei a coisa entre
citações que da última vez?

163
00:08:30,670 --> 00:08:31,285
Então é uma string.

164
00:08:31,285 --> 00:08:35,309
E uma corda é apenas o tecnólogo
prazo para uma seqüência de

165
00:08:35,309 --> 00:08:37,169
personagens, uma palavra, uma frase.

166
00:08:37,169 --> 00:08:39,380
Mesmo uma única letra pode
ser o dobro citado.

167
00:08:39,380 --> 00:08:41,840
Mas é uma seqüência de zero
ou mais caracteres.

168
00:08:41,840 --> 00:08:43,650
>> Barra-n, no entanto, parece
um pouco estranho.

169
00:08:43,650 --> 00:08:46,290
Mas simplesmente dizer algo
simples para o computador.

170
00:08:46,290 --> 00:08:48,060
O que é barra-n?

171
00:08:48,060 --> 00:08:48,570
Nova linha.

172
00:08:48,570 --> 00:08:52,490
Então, isso é apenas a sequência especial de
personagens que o mundo decidiu

173
00:08:52,490 --> 00:08:56,880
significa colocar uma quebra de linha ali,
porque o compilador vai realmente começar

174
00:08:56,880 --> 00:09:02,280
confusa, geralmente, se você, muito
compreensivelmente, mas incorretamente, apenas

175
00:09:02,280 --> 00:09:04,570
começar a bater Enter para colocar
novas linhas em seu código.

176
00:09:04,570 --> 00:09:07,150
Você precisa ser um pouco mais
explícita com barra-n.

177
00:09:07,150 --> 00:09:10,540
>> E nós vamos ver que há alguns outros, tais
padrões para caracteres especiais.

178
00:09:10,540 --> 00:09:14,340
Por exemplo, se você quiser deixar o seu
mente vagar a um caso de canto,

179
00:09:14,340 --> 00:09:18,080
supor que eu queria imprimir uma
aspas na tela para

180
00:09:18,080 --> 00:09:21,840
qualquer razão, pareceria que
ser um pouco problemático, certo?

181
00:09:21,840 --> 00:09:24,990
Porque se eu colocar aspas no
meio do "Olá, mundo", para o que

182
00:09:24,990 --> 00:09:30,120
razão, por que é que isso parece
potencialmente problemáticos?

183
00:09:30,120 --> 00:09:32,180
Ele quebra a string.

184
00:09:32,180 --> 00:09:34,700
>> O compilador é apenas um programa.

185
00:09:34,700 --> 00:09:37,210
Um programa como um compilador é só ir
de ler o seu top código para baixo,

186
00:09:37,210 --> 00:09:37,990
esquerda para a direita.

187
00:09:37,990 --> 00:09:41,850
E se vê três aspas duplas em vez
de dois filhos, ele não vai saber

188
00:09:41,850 --> 00:09:45,210
Se você quer dizer que a coisa à esquerda
deve ser a string, ou a coisa a

189
00:09:45,210 --> 00:09:46,570
à direita, ou a coisa toda.

190
00:09:46,570 --> 00:09:50,560
É ambíguo, e assim o que um típico
compilador fazer é surtar,

191
00:09:50,560 --> 00:09:53,710
e dar-lhe alguma mensagem de erro, e
fazer você lidar com o problema.

192
00:09:53,710 --> 00:09:58,120
>> Assim, dado que a barra-n significa uma nova
linha, o que faria seus instintos agora

193
00:09:58,120 --> 00:10:02,610
começar a ser se você quiser incluir
algo anômalo como um duplo

194
00:10:02,610 --> 00:10:06,210
citar dentro deste caso contrário citado
corda?

195
00:10:06,210 --> 00:10:07,640
Citação barra-dupla.

196
00:10:07,640 --> 00:10:09,630
E então vamos ver isso
tipo de padrão também.

197
00:10:09,630 --> 00:10:12,490
>> Se você quiser fazer algo um pouco
estranho, você vai descobrir que o

198
00:10:12,490 --> 00:10:15,060
soluções muitas vezes seguem um padrão,
ea barra invertida

199
00:10:15,060 --> 00:10:17,150
denota uma seqüência de escape.

200
00:10:17,150 --> 00:10:20,320
E isso significa apenas algo especial
que precisamos para representar em uma

201
00:10:20,320 --> 00:10:21,060
maneira diferente.

202
00:10:21,060 --> 00:10:23,830
Quanto à forma como você representa
uma barra invertida, bem, vamos

203
00:10:23,830 --> 00:10:24,550
voltar a isso.

204
00:10:24,550 --> 00:10:26,930
Mas a resposta também é verdade
um pouco óbvio.

205
00:10:26,930 --> 00:10:31,080
>> Então, vamos agora introduzir algum outro
construções de programação

206
00:10:31,080 --> 00:10:31,915
que você viu em risco.

207
00:10:31,915 --> 00:10:34,790
Você provavelmente já tida como certa
já se você já mergulhou

208
00:10:34,790 --> 00:10:36,060
conjunto de problemas 0.

209
00:10:36,060 --> 00:10:40,950
Mas vamos agora introduzir a sintaxe em C
para estes caso contrário bastante intuitiva

210
00:10:40,950 --> 00:10:42,300
ideias, pelo menos alguns deles.

211
00:10:42,300 --> 00:10:45,570
>> Portanto, esta noção de uma condição ou
um ramo, ao passo que anteriormente nós

212
00:10:45,570 --> 00:10:49,330
representado com um código que olhou
como esta à esquerda em Risco -

213
00:10:49,330 --> 00:10:52,200
Se x é menor que y, então diga -

214
00:10:52,200 --> 00:10:56,760
em vez agora em C - deixe-me aperfeiçoar
em no caso mais simples -

215
00:10:56,760 --> 00:11:01,235
estamos indo simplesmente para dizer que, se, abra
parênteses, algo é verdadeiro - um

216
00:11:01,235 --> 00:11:04,190
Expressão booleana está a ir
onde eu disse condição -

217
00:11:04,190 --> 00:11:08,170
Fechar parênteses, em seguida, fazer o que é
dentro dessas chaves.

218
00:11:08,170 --> 00:11:11,020
>> Então, aqui, também, as chaves
é tipo como de risco da

219
00:11:11,020 --> 00:11:12,460
Peças de quebra-cabeça em forma de U.

220
00:11:12,460 --> 00:11:14,890
Faça o que tem dentro dessas chaves.

221
00:11:14,890 --> 00:11:16,790
Neste caso, slash slash.

222
00:11:16,790 --> 00:11:19,720
E perceber isso é um atacante
slash, não uma barra invertida.

223
00:11:19,720 --> 00:11:21,440
Barra, barra,
para aqueles que já programou

224
00:11:21,440 --> 00:11:23,370
antes, apenas significa -

225
00:11:23,370 --> 00:11:24,190
é apenas um comentário.

226
00:11:24,190 --> 00:11:26,630
Um comentário não é uma linha
de código, de per si.

227
00:11:26,630 --> 00:11:30,200
É uma linha de Inglês que você,
humano, ter escrito a si mesmo para

228
00:11:30,200 --> 00:11:33,540
talvez lembrá-lo de fazer algo,
explicar para si mesmo, para explicar a

229
00:11:33,540 --> 00:11:35,260
outra pessoa, o que o código está fazendo.

230
00:11:35,260 --> 00:11:37,050
É apenas um comentário descritivo.

231
00:11:37,050 --> 00:11:40,880
>> Agora, é claro, podemos ter uma de duas vias
bifurcação na estrada, apenas por isso, um

232
00:11:40,880 --> 00:11:43,930
três vias bifurcação na estrada, fazendo
isso, e se você continuar esta

233
00:11:43,930 --> 00:11:47,570
padrão, você pode ter de quatro vias,
cinco vias, seis vias garfos na estrada se

234
00:11:47,570 --> 00:11:50,150
você precisa lidar, de fato,
que muitas condições.

235
00:11:50,150 --> 00:11:52,010
E, em seguida, observe o paralelismo aqui -

236
00:11:52,010 --> 00:11:55,070
if (condição), else if (condição),
eo único que é um pouco

237
00:11:55,070 --> 00:11:58,010
estranho é a última, que
É justo que os outros.

238
00:11:58,010 --> 00:12:01,170
Mas, novamente, esta é idêntica,
conceitualmente, para o que fizemos

239
00:12:01,170 --> 00:12:04,690
já, embora a sintaxe vontade
demorar um pouco para se acostumar.

240
00:12:04,690 --> 00:12:07,730
>> Agora, no presente exemplo, existem
alguma outra sintaxe estranha.

241
00:12:07,730 --> 00:12:11,220
Vemos printf novamente, parêntese aberto,
e parêntesis.

242
00:12:11,220 --> 00:12:13,190
E lá dentro é
uma string.

243
00:12:13,190 --> 00:12:17,060
Os parênteses, no contexto
de printf, vá à esquerda

244
00:12:17,060 --> 00:12:18,160
e direito de quê?

245
00:12:18,160 --> 00:12:22,190
O que nós descrevemos que citada
string como mais geral?

246
00:12:22,190 --> 00:12:23,320
>> Então é um argumento.

247
00:12:23,320 --> 00:12:26,620
Toda vez que você tem uma função, como
printf, e, em seguida, um parêntese aberto e um

248
00:12:26,620 --> 00:12:30,330
perto parêntese e algo dentro de
que, se é uma string, ou um

249
00:12:30,330 --> 00:12:34,420
inteiro, ou qualquer outra coisa, a coisa em
entre os parênteses é chamado

250
00:12:34,420 --> 00:12:35,110
um argumento.

251
00:12:35,110 --> 00:12:37,910
>> E um argumento só influencia
comportamento da função.

252
00:12:37,910 --> 00:12:39,990
Neste caso, é bastante claro como.

253
00:12:39,990 --> 00:12:44,480
x <y é o que está sendo transmitido,
por assim dizer, como um argumento.

254
00:12:44,480 --> 00:12:47,720
E printf vai
imprimir exatamente isso.

255
00:12:47,720 --> 00:12:51,590
Porque, certamente, a pessoa de anos atrás
que implementou printf não tinha idéia

256
00:12:51,590 --> 00:12:55,000
o que sucessores humanos foram
vai usar printf para.

257
00:12:55,000 --> 00:12:58,610
É por isso que existem argumentos, a
influenciar o comportamento depois de uma função de

258
00:12:58,610 --> 00:12:59,450
foi escrito.

259
00:12:59,450 --> 00:13:00,780
>> Agora, a expressão booleana.

260
00:13:00,780 --> 00:13:02,470
Nós já vimos isso antes em risco.

261
00:13:02,470 --> 00:13:06,680
Acontece em C, você também pode "ou"
los juntos, por assim dizer.

262
00:13:06,680 --> 00:13:10,930
Duas barras verticais significa que este bloco
de código, este fizer isso, vai

263
00:13:10,930 --> 00:13:15,350
executar, se a primeira condição é verdadeira
ou a segunda condição é verdadeira.

264
00:13:15,350 --> 00:13:17,710
E mesmo que você não poderia ter feito
esta em risco, você poderia de fato

265
00:13:17,710 --> 00:13:20,580
fazer isso em risco, e você também pode
expressar-se de forma diferente -

266
00:13:20,580 --> 00:13:25,300
Se o primeiro estado e o segundo
condição é verdadeira, então o que é

267
00:13:25,300 --> 00:13:27,160
dentro das chaves.

268
00:13:27,160 --> 00:13:31,210
>> E assim como um aparte, a razão é
um duplo e comercial e um duplo

269
00:13:31,210 --> 00:13:34,610
barra vertical, vamos ver, eventualmente,
que uma única barra vertical e uma

270
00:13:34,610 --> 00:13:38,710
único e comercial, na verdade, têm diferentes
significado em C. Então, por agora,

271
00:13:38,710 --> 00:13:41,840
que a duplicação de símbolos
é intencional.

272
00:13:41,840 --> 00:13:45,070
>> Então, vamos apresentar, resumidamente,
este outro pouco de sintaxe.

273
00:13:45,070 --> 00:13:48,940
Isso não chega a transitar para
Zero, mas eu afirmo que eu puder

274
00:13:48,940 --> 00:13:55,190
implementar a noção de uma pessoa se, se
então, se mais, se else usando

275
00:13:55,190 --> 00:13:56,760
algo chamado uma instrução switch.

276
00:13:56,760 --> 00:14:00,820
E a única razão pela qual isso realmente existe
é apenas para dar a você, programador, um

277
00:14:00,820 --> 00:14:05,470
maneira um pouco diferente de resolver alguns
problema, embora logicamente

278
00:14:05,470 --> 00:14:07,340
não lhe dá quaisquer novas capacidades.

279
00:14:07,340 --> 00:14:08,530
>> Por isso quero dizer isso.

280
00:14:08,530 --> 00:14:13,330
Quando você diz interruptor, e, em seguida, um espaço,
e, em seguida, um par de parênteses, para dentro

281
00:14:13,330 --> 00:14:14,570
dos quais passa uma expressão -

282
00:14:14,570 --> 00:14:18,010
e isso pode ser um pouco não-óbvio
num primeiro momento, mas isso não é um argumento,

283
00:14:18,010 --> 00:14:20,680
tecnicamente, porque interruptor
não é uma função.

284
00:14:20,680 --> 00:14:24,230
Então, por agora, apenas supor que estamos usando
parênteses em locais diferentes

285
00:14:24,230 --> 00:14:25,250
por razões diferentes.

286
00:14:25,250 --> 00:14:29,310
>> Então ligue expressão significa que eu posso
colocar uma variável dentro dos

287
00:14:29,310 --> 00:14:31,350
parênteses, onde se lê a expressão.

288
00:14:31,350 --> 00:14:33,090
E então, se essa variável -

289
00:14:33,090 --> 00:14:35,400
Suponho que é chamado x, e
é apenas um inteiro -

290
00:14:35,400 --> 00:14:38,900
Posso, então, enumerar em meu slide
aqui algo parecido com isso.

291
00:14:38,900 --> 00:14:41,690
Se x é a minha variável, e eu
quer fazer alguma coisa, se x

292
00:14:41,690 --> 00:14:43,480
é igual a 1, não posso fazer isso.

293
00:14:43,480 --> 00:14:46,660
>> Se eu quiser, em vez de fazer alguma coisa
Se x é 2, eu posso fazer isso.

294
00:14:46,660 --> 00:14:50,390
Outra coisa, se eu quiser fazer outra coisa
totalmente, eu posso ter um caso default em

295
00:14:50,390 --> 00:14:52,750
caso em que eu faço isso outra coisa.

296
00:14:52,750 --> 00:14:58,730
Então, nesse sentido, é equivalente a um
Se x é igual a igual a 1, então se mais,

297
00:14:58,730 --> 00:15:01,150
mas eu falar isso agora só porque
vamos vê-lo novamente.

298
00:15:01,150 --> 00:15:03,720
Mas, por enquanto, só sei que ele existe.

299
00:15:03,720 --> 00:15:04,220
>> Tudo bem.

300
00:15:04,220 --> 00:15:07,660
Então, esses dois últimos são um pouco mais
complexo à primeira vista, mas eles

301
00:15:07,660 --> 00:15:09,385
algo bastante simples.

302
00:15:09,385 --> 00:15:14,410
Um laço for em C é um pedaço de código que
apenas faz algo de novo e

303
00:15:14,410 --> 00:15:15,330
uma e outra vez.

304
00:15:15,330 --> 00:15:17,590
E a única coisa irritante sobre ele é
isso é que é um pouco enigmática

305
00:15:17,590 --> 00:15:21,380
para se expressar neste cíclico
padrão, mas o mundo padronizado em

306
00:15:21,380 --> 00:15:22,450
da seguinte forma.

307
00:15:22,450 --> 00:15:25,760
>> Quando você usa um loop for, você tem
um par de parênteses novamente.

308
00:15:25,760 --> 00:15:27,570
E observe as duas vírgulas
lá dentro.

309
00:15:27,570 --> 00:15:34,380
Esses dois vírgula três separados
expressões diferentes dentro do

310
00:15:34,380 --> 00:15:35,020
parênteses.

311
00:15:35,020 --> 00:15:37,170
Um deles é o chamado inicializações.

312
00:15:37,170 --> 00:15:38,830
Uma delas é a condição chamada.

313
00:15:38,830 --> 00:15:40,210
E é um dos chamados actualizações.

314
00:15:40,210 --> 00:15:43,240
>> Olhou em abstrato, isto é
completamente não-óbvio, então vamos olhar

315
00:15:43,240 --> 00:15:44,630
um exemplo concreto.

316
00:15:44,630 --> 00:15:46,720
Em risco tivemos um bloco de repetição.

317
00:15:46,720 --> 00:15:50,670
E este bloco disse repita 10 vezes, digamos
"Olá, mundo". Deixe-me reivindicar para

318
00:15:50,670 --> 00:15:53,810
agora, e nós vamos voltar a este, e
isso, também, vai ficar mais familiar para

319
00:15:53,810 --> 00:15:57,345
você em pouco tempo, o equivalente C
código pode ser dito ser este -

320
00:15:57,345 --> 00:16:02,320
uma instrução e um espaço, um par de
parênteses, observe as vírgulas em

321
00:16:02,320 --> 00:16:05,730
ali, que separam três distintas
coisas, a inicialização, o

322
00:16:05,730 --> 00:16:07,320
condição ea atualização.

323
00:16:07,320 --> 00:16:08,840
>> E dar um palpite que
a primeira está fazendo.

324
00:16:08,840 --> 00:16:10,690
Int i = 0.

325
00:16:10,690 --> 00:16:15,120
Em termos leigos áspero, o que é
que está fazendo por nós, provavelmente?

326
00:16:15,120 --> 00:16:15,590
Então, sim.

327
00:16:15,590 --> 00:16:19,630
Ele está declarando uma variável chamada i,
e está dando o valor?

328
00:16:19,630 --> 00:16:20,220
0.

329
00:16:20,220 --> 00:16:24,280
Por isso, está criando uma variável chamada
i, armazenando o valor em que 0.

330
00:16:24,280 --> 00:16:26,420
É o chamado inicialização.

331
00:16:26,420 --> 00:16:29,360
>> Tudo bem, agora eu reivindiquei antes
que a coisa meio, i

332
00:16:29,360 --> 00:16:31,760
<10, é a condição.

333
00:16:31,760 --> 00:16:32,730
Então o que está fazendo?

334
00:16:32,730 --> 00:16:36,560
Bem, o que o loop for faz quando um
programa com um loop é executado, é

335
00:16:36,560 --> 00:16:41,050
cada vez que o computador é executado através de
este loop, de cima para baixo, de cima para

336
00:16:41,050 --> 00:16:43,740
inferior, assim como vocês fizeram quando
contando-se e sentar-se,

337
00:16:43,740 --> 00:16:47,090
novo e de novo e de novo,
o computador vai

338
00:16:47,090 --> 00:16:48,560
para verificar essa condição.

339
00:16:48,560 --> 00:16:51,140
E se for inferior a 10,
ele vai fazê-lo novamente.

340
00:16:51,140 --> 00:16:53,100
Se i for inferior a 10,
ele vai fazê-lo novamente.

341
00:16:53,100 --> 00:16:55,030
Se i for inferior a dez,
ele vai fazê-lo novamente.

342
00:16:55,030 --> 00:16:57,330
Assim que parece sugerir que
Espero está mudando.

343
00:16:57,330 --> 00:16:59,010
Caso contrário, teríamos um loop infinito.

344
00:16:59,010 --> 00:17:02,590
E, de fato, eu está mudando, porque a
última coisa após o ponto e vírgula não

345
00:17:02,590 --> 00:17:05,569
é a sintaxe um tanto enigmática de i + +.

346
00:17:05,569 --> 00:17:07,630
Mas aqueles de vocês que já fez isso
antes, isso apenas significa

347
00:17:07,630 --> 00:17:08,609
simplesmente o quê?

348
00:17:08,609 --> 00:17:09,730
>> ESTUDANTES: [interpondo VOZES].

349
00:17:09,730 --> 00:17:10,740
>> DAVID MALAN: Adicione 1 para i.

350
00:17:10,740 --> 00:17:11,819
Incrementar i.

351
00:17:11,819 --> 00:17:13,910
Então vimos um quebra zero
peça para que, na verdade.

352
00:17:13,910 --> 00:17:18,230
Ele não se parecia com i + +, mas isso só
significa, muito simplesmente, aumentar o

353
00:17:18,230 --> 00:17:24,040
Valorizamos i por 1 a cada vez que você faz isso.

354
00:17:24,040 --> 00:17:26,910
Então, literalmente, você começa
i inicializar a 0.

355
00:17:26,910 --> 00:17:29,520
Você, então, verificar o seu estado.

356
00:17:29,520 --> 00:17:31,070
É 0 a menos de 10?

357
00:17:31,070 --> 00:17:31,730
Sim.

358
00:17:31,730 --> 00:17:32,910
Vamos através do loop.

359
00:17:32,910 --> 00:17:35,150
>> A próxima coisa que eu afirmo que o computador de
vai fazer é que vai

360
00:17:35,150 --> 00:17:35,910
incrementar i.

361
00:17:35,910 --> 00:17:37,080
Então eu é agora 1.

362
00:17:37,080 --> 00:17:37,940
Ele verifica a condição.

363
00:17:37,940 --> 00:17:39,290
É um inferior a 10?

364
00:17:39,290 --> 00:17:39,930
Claro.

365
00:17:39,930 --> 00:17:41,030
Então faz isso de novo.

366
00:17:41,030 --> 00:17:43,580
Em seguida, ele incrementa i + + para 2.

367
00:17:43,580 --> 00:17:44,610
2 é inferior a 10?

368
00:17:44,610 --> 00:17:45,230
Sim.

369
00:17:45,230 --> 00:17:46,670
E de novo e de novo e de novo.

370
00:17:46,670 --> 00:17:50,070
E, finalmente, em virtude da
plus-plussing, temos de i é igual a 10.

371
00:17:50,070 --> 00:17:51,675
É 10 a menos do que 10?

372
00:17:51,675 --> 00:17:52,990
Bem, obviamente que não.

373
00:17:52,990 --> 00:17:55,320
E esse é o ponto em que
o loop for simplesmente pára.

374
00:17:55,320 --> 00:17:58,320
E se você tiver mais de código no
tela abaixo, o computador

375
00:17:58,320 --> 00:18:01,620
recursos para executar esse código em vez.

376
00:18:01,620 --> 00:18:05,380
>> Então, novamente, mesmo que isso vai
olhar e sentir um pouco estranho no

377
00:18:05,380 --> 00:18:07,830
em primeiro lugar, certamente, para aqueles de vocês que
nunca programou antes,

378
00:18:07,830 --> 00:18:11,640
literalmente reduz conceitualmente
o que é uma outra forma muito

379
00:18:11,640 --> 00:18:14,330
quebra-cabeça simples
peça em risco.

380
00:18:14,330 --> 00:18:19,130
>> Tudo bem, eu prometi que não tinha
ser outros análogos em risco.

381
00:18:19,130 --> 00:18:20,060
Há um presente também.

382
00:18:20,060 --> 00:18:21,700
E vimos isso brevemente última vez.

383
00:18:21,700 --> 00:18:23,530
Mas lembre-se sempre o
bloquear em zero?

384
00:18:23,530 --> 00:18:25,490
Ele só faz algo para sempre?

385
00:18:25,490 --> 00:18:27,470
Eu afirmava que você poderia implementar
isto desta maneira.

386
00:18:27,470 --> 00:18:29,740
E você pode realmente implementar esta
em um grupo de diferentes maneiras.

387
00:18:29,740 --> 00:18:34,260
>> Mas o loop while é apenas uma diferente
forma em C de se expressar.

388
00:18:34,260 --> 00:18:37,080
No final do dia, você não pode fazer
qualquer coisa com um loop while que você

389
00:18:37,080 --> 00:18:38,360
não pode com um loop for.

390
00:18:38,360 --> 00:18:41,430
Então, eles estão no final da
funcionalmente o mesmo dia.

391
00:18:41,430 --> 00:18:43,840
Mas ele permite que você se expresse
um pouco diferente em

392
00:18:43,840 --> 00:18:44,850
da seguinte forma.

393
00:18:44,850 --> 00:18:49,720
>> Com o loop while, é o que está em
parênteses que está verificados novamente e

394
00:18:49,720 --> 00:18:51,050
uma e outra vez.

395
00:18:51,050 --> 00:18:55,100
E tão logo que a expressão é falsa,
em seguida, interrompe o ciclo de execução,

396
00:18:55,100 --> 00:18:57,890
e o computador prossegue
executar qualquer outro código

397
00:18:57,890 --> 00:18:59,230
tem em seu arquivo.

398
00:18:59,230 --> 00:19:02,180
>> Mas o que é interessante aqui é
que eu literalmente digitado verdade.

399
00:19:02,180 --> 00:19:06,680
E verdade é um tipo de valor booleano,
um valor verdadeiro ou falso.

400
00:19:06,680 --> 00:19:09,750
Assim, poderia se tornar verdade nunca
false se eu tenho literalmente

401
00:19:09,750 --> 00:19:11,970
codificado-lo em meu programa?

402
00:19:11,970 --> 00:19:12,470
Então, não.

403
00:19:12,470 --> 00:19:13,730
É um pouco estranho que eu fiz isso.

404
00:19:13,730 --> 00:19:15,190
Mas verdade é verdade.

405
00:19:15,190 --> 00:19:16,320
Não há nenhuma mais-plussing.

406
00:19:16,320 --> 00:19:17,820
Não há uso de variáveis ​​aqui.

407
00:19:17,820 --> 00:19:22,740
Então porque eu codificado enquanto verdadeiro, este
loop é sempre indo para avaliar

408
00:19:22,740 --> 00:19:24,090
novo e de novo e de novo.

409
00:19:24,090 --> 00:19:27,660
>> Então, quantas vezes é Olá mundo
vai imprimir na tela?

410
00:19:27,660 --> 00:19:28,170
Forever.

411
00:19:28,170 --> 00:19:31,980
Um número infinito de vezes, até que o
bateria morre ou algum outro externas

412
00:19:31,980 --> 00:19:32,730
evento acontece.

413
00:19:32,730 --> 00:19:35,880
Portanto, este não é provavelmente o melhor programa
para escrever, porque se o usuário

414
00:19:35,880 --> 00:19:38,660
nunca pode sair do seu programa, é
provavelmente não é o que você pretende.

415
00:19:38,660 --> 00:19:41,070
>> Mas, às vezes, os programas devem
ter um loop infinito.

416
00:19:41,070 --> 00:19:44,050
Por exemplo, se o seu computador tem um
relógio nele, ele certamente seria

417
00:19:44,050 --> 00:19:48,130
bom se o seu relógio ele manter a atualização
si para sempre, mesmo que uma vez por

418
00:19:48,130 --> 00:19:50,500
segundo ou uma vez por minuto ou
algo parecido.

419
00:19:50,500 --> 00:19:53,690
Assim, mesmo laços infinitos
têm o seu lugar.

420
00:19:53,690 --> 00:19:54,360
>> Tudo bem.

421
00:19:54,360 --> 00:19:55,190
Por último, um presente.

422
00:19:55,190 --> 00:19:57,770
E este é um pouco diferente
funcionalmente, e nós vamos voltar para

423
00:19:57,770 --> 00:19:59,460
isso provavelmente em Pset 1.

424
00:19:59,460 --> 00:20:02,370
Mas há outro tipo de loop
chamado de fazer enquanto loop.

425
00:20:02,370 --> 00:20:07,100
E a única diferença aqui entre um
fazer loop while e, digamos, um loop while,

426
00:20:07,100 --> 00:20:11,120
é que a condição é verificada não
antes de executar o código, mas depois

427
00:20:11,120 --> 00:20:12,080
você executar o código.

428
00:20:12,080 --> 00:20:15,380
Então, na parte superior para o tempo
loop, enquanto o fazer enquanto

429
00:20:15,380 --> 00:20:16,560
verifica-lo na parte inferior.

430
00:20:16,560 --> 00:20:21,370
>> E isso significa apenas que o loop while
tipicamente executar mais vezes

431
00:20:21,370 --> 00:20:24,630
ou menor número de vezes que um loop while?

432
00:20:24,630 --> 00:20:30,810
Potencialmente mais vezes, porque a fazer
while está dizendo claramente isso,

433
00:20:30,810 --> 00:20:34,600
só depois que ponto você verifique
se o estado no interior do

434
00:20:34,600 --> 00:20:35,980
parênteses é verdadeiro.

435
00:20:35,980 --> 00:20:37,940
>> Então, vamos ver isso de novo
provavelmente em Pset 1.

436
00:20:37,940 --> 00:20:41,150
Se você quiser fazer alguma coisa em
menos uma vez e, em seguida, talvez um pouco mais

437
00:20:41,150 --> 00:20:43,350
vezes, este é um bom
construir a utilizar.

438
00:20:43,350 --> 00:20:46,970
Mas um loop while, pelo contrário, vai
verificar a sua condição de primeira.

439
00:20:46,970 --> 00:20:50,660
E isso é tudo para loops em C, não
enquanto, ao mesmo tempo, e para loops.

440
00:20:50,660 --> 00:20:54,700
E, novamente, eles mapeiam muito bem de volta
a zero, exceto este não

441
00:20:54,700 --> 00:20:57,350
consegue ter o mesmo analógico em risco.

442
00:20:57,350 --> 00:20:58,880
>> Bem, que tal, agora, as variáveis?

443
00:20:58,880 --> 00:21:02,600
Então é assim que eu declarei uma variável
sintaticamente no outro dia.

444
00:21:02,600 --> 00:21:06,440
Eu tive um int, que alegou
é um número inteiro.

445
00:21:06,440 --> 00:21:09,690
Então eu tive uma variável chamada contador,
e, em seguida, um ponto e vírgula.

446
00:21:09,690 --> 00:21:11,070
Então o que é esta linha de código está fazendo?

447
00:21:11,070 --> 00:21:14,540
Este é, simplesmente, declarando
uma variável -

448
00:21:14,540 --> 00:21:17,940
isto é, pedindo o computador, dá-me
um pouco de memória, dá-me alguns bits - em

449
00:21:17,940 --> 00:21:19,450
que posso armazenar o quê?

450
00:21:19,450 --> 00:21:20,300
Um int.

451
00:21:20,300 --> 00:21:23,570
E o ponto e vírgula significa apenas
final da linha de código.

452
00:21:23,570 --> 00:21:25,500
>> Agora, a segunda linha é provavelmente
muito adivinhação.

453
00:21:25,500 --> 00:21:29,710
O que é contador = 0; fazendo?

454
00:21:29,710 --> 00:21:31,690
É a atribuição de 0 a combater.

455
00:21:31,690 --> 00:21:33,470
E por isso esta é a outra coisa
isso é um pouco chato

456
00:21:33,470 --> 00:21:34,540
contra, digamos, álgebra.

457
00:21:34,540 --> 00:21:39,110
Considerando que, em álgebra, o sinal de igual significa
iguais, aqui em C, a igual

458
00:21:39,110 --> 00:21:40,470
sinal significa atribuição.

459
00:21:40,470 --> 00:21:45,380
Então isso significa colocar o que está à direita
em que está na esquerda.

460
00:21:45,380 --> 00:21:49,030
E nós vamos ver um outro símbolo, é igual a
iguais, quando queremos realmente testar

461
00:21:49,030 --> 00:21:50,570
de qualidade, um pouco irritante.

462
00:21:50,570 --> 00:21:52,590
>> Mas isso é um pouco ineficiente.

463
00:21:52,590 --> 00:21:55,090
É o tipo de chato que eu tenho
para declarar uma variável e

464
00:21:55,090 --> 00:21:56,110
em seguida, dar-lhe um valor.

465
00:21:56,110 --> 00:21:59,380
Então C realmente nos permite simplificar este
e apenas fazê-lo de uma vez.

466
00:21:59,380 --> 00:22:01,330
Você pode declarar a variável
no lado esquerdo.

467
00:22:01,330 --> 00:22:04,590
Você ainda pode fazer a atribuição a
direito, colocando o sinal igual em

468
00:22:04,590 --> 00:22:05,030
meio.

469
00:22:05,030 --> 00:22:08,740
Assim, no final do dia, estes são dois
equivalente, mas este, francamente,

470
00:22:08,740 --> 00:22:11,840
é provavelmente o melhor hábito de entrar
só porque ele é um pouco menos

471
00:22:11,840 --> 00:22:15,040
código, que é um pouco mais fácil de ler,
e ele só aperta

472
00:22:15,040 --> 00:22:17,470
seu código, por assim dizer.

473
00:22:17,470 --> 00:22:22,120
>> Qualquer dúvida, até agora, sobre os loops,
sobre variáveis, em condições de, em

474
00:22:22,120 --> 00:22:27,001
Booleanos, seja tecnicamente
ou conceitual?

475
00:22:27,001 --> 00:22:28,010
Tudo bem.

476
00:22:28,010 --> 00:22:30,690
Então, agora o próximo obtém-se uma
pouco mais interessante.

477
00:22:30,690 --> 00:22:34,790
E este é o exemplo que eu colocar última
vez que apenas mapeia um exemplo do risco

478
00:22:34,790 --> 00:22:35,820
sobre a C.

479
00:22:35,820 --> 00:22:36,580
>> Assim, uma função.

480
00:22:36,580 --> 00:22:38,110
Em termos leigos, o que é uma função?

481
00:22:38,110 --> 00:22:42,900

482
00:22:42,900 --> 00:22:44,350
Tem que ser mais ousado com a sua resposta.

483
00:22:44,350 --> 00:22:45,020
O que é uma função?

484
00:22:45,020 --> 00:22:46,320
>> ALUNO: Será que alguma coisa.

485
00:22:46,320 --> 00:22:46,780
>> DAVID MALAN: O que é isso?

486
00:22:46,780 --> 00:22:48,000
>> ALUNO: Será que alguma coisa.

487
00:22:48,000 --> 00:22:48,710
>> DAVID MALAN: Faz alguma coisa.

488
00:22:48,710 --> 00:22:49,000
OK.

489
00:22:49,000 --> 00:22:49,590
Vamos começar por aí.

490
00:22:49,590 --> 00:22:51,270
Assim, uma função faz alguma coisa.

491
00:22:51,270 --> 00:22:55,160
Portanto, é um pedaço de código que é
essencialmente implementado em outro lugar que

492
00:22:55,160 --> 00:22:56,620
realmente faz alguma coisa.

493
00:22:56,620 --> 00:23:00,180
Agora, o que é interessante sobre a função
é que ele pode receber a entrada de,

494
00:23:00,180 --> 00:23:02,710
e pode produzir uma saída.

495
00:23:02,710 --> 00:23:05,090
E vamos realmente tomar
uma olhada nisso.

496
00:23:05,090 --> 00:23:09,030
>> Então, o homem por trás da cortina
foi deliberado um momento atrás.

497
00:23:09,030 --> 00:23:10,320
Aqui temos uma tabela.

498
00:23:10,320 --> 00:23:13,010
Mas suponha que isso realmente
representa uma grande caixa.

499
00:23:13,010 --> 00:23:14,940
Portanto, esta é uma chamada caixa preta.

500
00:23:14,940 --> 00:23:19,800
E, em geral, no design, no computador
ciência, caixas-pretas apenas se referir a

501
00:23:19,800 --> 00:23:22,510
partes de uma funcionalidade que alguém
implementou, e você não

502
00:23:22,510 --> 00:23:26,140
necessariamente saber ou se importar como é
implementado sob o capô.

503
00:23:26,140 --> 00:23:28,960
Você só se importa que essa caixa preta,
que agora vai começar a chamar a

504
00:23:28,960 --> 00:23:30,730
função, faz alguma coisa.

505
00:23:30,730 --> 00:23:34,710
>> Assim, por exemplo, se esta caixa negra
o estágio aqui representa printf, uma

506
00:23:34,710 --> 00:23:38,040
função, eu sei que a partir de exemplos anteriores
que leva uma ou mais printf

507
00:23:38,040 --> 00:23:40,910
argumentos, eo primeiro daqueles
argumentos deve ser uma string, como

508
00:23:40,910 --> 00:23:44,780
"Olá, mundo". Bem, se eu sou a pessoa
escrever o programa, e eu quero

509
00:23:44,780 --> 00:23:50,460
usar printf, eu, por exemplo, pode
pegue um pedaço de papel em branco aqui e um

510
00:23:50,460 --> 00:23:55,060
marcador preto e escrever sobre ela -

511
00:23:55,060 --> 00:23:56,580
Eu grafada "mundo" -

512
00:23:56,580 --> 00:23:59,560
H-E-L-L-S.

513
00:23:59,560 --> 00:24:04,220
>> Então, eu vou levar o meu marcador preto e eu vou
escrever, tão grande e legível quanto possível em

514
00:24:04,220 --> 00:24:07,260
este pedaço de papel: "Olá, mundo", e
agora eu reivindico este é o meu argumento.

515
00:24:07,260 --> 00:24:09,740
Isto é uma string representado com
um pedaço de papel branco.

516
00:24:09,740 --> 00:24:13,030
E agora a minha entrada para a função
printf vai ser isso.

517
00:24:13,030 --> 00:24:18,250
Então, eu estou chamando printf, passando
esse argumento como entrada para ele.

518
00:24:18,250 --> 00:24:22,110

519
00:24:22,110 --> 00:24:26,740
>> E agora, eu não sei como a pessoa que
escreveu printf fez isso anos atrás, mas

520
00:24:26,740 --> 00:24:31,110
Eu sei de sua documentação
seu propósito na vida é para imprimir o que eu

521
00:24:31,110 --> 00:24:34,410
fornecer a ele como entrada.

522
00:24:34,410 --> 00:24:40,630
E assim, mesmo que esta implementação
é desconhecido para mim

523
00:24:40,630 --> 00:24:44,170
debaixo do capô, agora
Eu vejo, oh, ele é feito.

524
00:24:44,170 --> 00:24:45,740
Tem algo impresso
no ecrã.

525
00:24:45,740 --> 00:24:49,070
E agora, o controle do programa, se houver
foram mais linhas de código, iria

526
00:24:49,070 --> 00:24:51,070
já voltaram para mim.

527
00:24:51,070 --> 00:24:52,290
E assim o fato de que Colton -

528
00:24:52,290 --> 00:24:55,370
abençoe seu coração, está se escondendo aqui em
uma mesa na frente de todos vocês -

529
00:24:55,370 --> 00:24:59,530
é deliberada em que eu não sei
e eu não me importo como printf é

530
00:24:59,530 --> 00:25:00,100
implementadas.

531
00:25:00,100 --> 00:25:03,390
Eu só sei que, mais uma vez, desde a sua
documentação, o que ele faz e como eu

532
00:25:03,390 --> 00:25:05,040
devo usá-lo.

533
00:25:05,040 --> 00:25:09,140
>> Agora, lembre-se que printf poderia começar
um pouco mais sofisticadas.

534
00:25:09,140 --> 00:25:12,220
Mais uma vez, estamos apenas falando sobre o
equivalente do bloco Say do zero.

535
00:25:12,220 --> 00:25:14,230
Mas eu também fiz isso da última vez.

536
00:25:14,230 --> 00:25:17,270
Eu queria fazer o meu programa Olá a
pouco mais dinâmica e não apenas difícil

537
00:25:17,270 --> 00:25:19,740
código algo como "mundo", e
definitivamente não é algo rígido código

538
00:25:19,740 --> 00:25:22,520
arbitrária como o D-A-V-I-D
no programa.

539
00:25:22,520 --> 00:25:27,510
Eu queria pedir ao usuário para o seu
nome, e, em seguida, fazer algo com

540
00:25:27,510 --> 00:25:29,720
essa seqüência que eles fornecem.

541
00:25:29,720 --> 00:25:32,690
>> Portanto, há algo um pouco diferente
aqui. printf, há pouco,

542
00:25:32,690 --> 00:25:35,860
se, de fato, fazer alguma coisa, mas
não retornou nada para mim.

543
00:25:35,860 --> 00:25:36,020
Certo?

544
00:25:36,020 --> 00:25:38,910
Colton não me entregar nada
para trás, nenhum pedaço de papel.

545
00:25:38,910 --> 00:25:40,320
Havia apenas um efeito colateral.

546
00:25:40,320 --> 00:25:44,510
Meu fornecendo "Olá, mundo" como um
argumento a Colton resultou na

547
00:25:44,510 --> 00:25:48,420
efeito colateral de uma palavra, algumas palavras,
que aparece na tela.

548
00:25:48,420 --> 00:25:51,350
>> getstring, porém, é um pouco
diferente. getstring também um

549
00:25:51,350 --> 00:25:54,590
funcionar, mas retorna algum valor.

550
00:25:54,590 --> 00:25:56,370
Ele não tem apenas um
efeito colateral estética.

551
00:25:56,370 --> 00:26:00,230
Na verdade, me dá, a pessoa
chamada ou utilizar a função,

552
00:26:00,230 --> 00:26:01,320
algo de volta.

553
00:26:01,320 --> 00:26:05,740
Portanto, neste caso, é getstring
chamado com getstring aberto

554
00:26:05,740 --> 00:26:07,510
parêntese, perto parêntese.

555
00:26:07,510 --> 00:26:11,370
Será getstring, portanto, tomar
quaisquer argumentos ou entrada?

556
00:26:11,370 --> 00:26:12,340
Não, não parece.

557
00:26:12,340 --> 00:26:14,460
Seu objetivo na vida é
só para ter uma string.

558
00:26:14,460 --> 00:26:16,910
Ela não precisa de mais detalhes do que isso.

559
00:26:16,910 --> 00:26:20,430
Então deixe-me ir em frente e fingir que,
novamente, desta caixa preta não é printf,

560
00:26:20,430 --> 00:26:25,160
mas getstring, e deixe-me, a pessoa
escrever este programa, chamar ou utilizar

561
00:26:25,160 --> 00:26:29,720
getString por apenas escrever
G-E-T-S-T-R-I-N-G, aberto parêntese, perto

562
00:26:29,720 --> 00:26:32,170
parêntese, getstring.

563
00:26:32,170 --> 00:26:36,920
>> Agora, eu não tenho nenhuma idéia de como a equipe CS50
implementado getstring, mas eu sei que

564
00:26:36,920 --> 00:26:41,240
se eu esperar o tempo suficiente, ele vai fazer o seu
coisa debaixo do capô, talvez usando

565
00:26:41,240 --> 00:26:44,940
algumas variáveis, talvez usando algum
condições, talvez o uso de alguns loops,

566
00:26:44,940 --> 00:26:48,170
talvez usando algumas funções,
talvez usando -

567
00:26:48,170 --> 00:26:52,290
apenas tentando tenda - talvez usando
alguns outros recursos de programação.

568
00:26:52,290 --> 00:26:55,350
Mas se eu esperar o tempo suficiente - na realidade,
em que o computador, isto acontece

569
00:26:55,350 --> 00:26:56,270
super rápido -

570
00:26:56,270 --> 00:26:59,910
se eu esperar o tempo suficiente, esta função
getstring vai receber uma string

571
00:26:59,910 --> 00:27:04,060
do utilizador, que é presumivelmente digitando
lo em seu teclado, e

572
00:27:04,060 --> 00:27:08,090
então, se quando você getstring é feito
os personagens do usuário

573
00:27:08,090 --> 00:27:14,080
e armazená-los em uma string, que
função, getstring, vai ter

574
00:27:14,080 --> 00:27:17,990
pronto para me alguma saída que eu sou
indo para recuperar por meio do

575
00:27:17,990 --> 00:27:19,470
operador de atribuição.

576
00:27:19,470 --> 00:27:25,390
>> E se eu for, de fato, para a saída
aqui, Obosi tem generosamente

577
00:27:25,390 --> 00:27:29,900
participaram, sem saber isso em
avançar, escrevendo seu nome para esta

578
00:27:29,900 --> 00:27:33,100
variável, que está representando
uma corda.

579
00:27:33,100 --> 00:27:35,640
Agora, o operador de atribuição significa que, mesmo
embora isso possa se sentir um pouco

580
00:27:35,640 --> 00:27:38,790
redundante, eu realmente preciso
para fazer a minha própria cópia deste.

581
00:27:38,790 --> 00:27:40,700
Porque na mão esquerda
lado - gritos! -

582
00:27:40,700 --> 00:27:45,760
notar que essencialmente tem cadeia
nome no lado esquerdo.

583
00:27:45,760 --> 00:27:48,280
Então, eu também vou fazer
minha própria cópia deste.

584
00:27:48,280 --> 00:27:50,990
E isso é um pouco de uma mentira branca,
porque nós vamos ver em uma semana ou duas de

585
00:27:50,990 --> 00:27:54,100
tempo que as cordas não são realmente
o que parecem ser.

586
00:27:54,100 --> 00:27:56,700
>> Mas, por agora, aqui está o valor de retorno.

587
00:27:56,700 --> 00:28:00,160
Aqui é a minha própria cópia do mesmo após
usando o operador de atribuição.

588
00:28:00,160 --> 00:28:01,790
E agora, o que eu quero fazer a seguir?

589
00:28:01,790 --> 00:28:04,080
Temos agora a segunda
de duas linhas de código.

590
00:28:04,080 --> 00:28:05,640
Então, agora eu quero chamar printf.

591
00:28:05,640 --> 00:28:08,500
Vamos fingir que agora que o preto
caixa está de volta novamente a ser

592
00:28:08,500 --> 00:28:10,210
printf e não getstring.

593
00:28:10,210 --> 00:28:12,200
>> Printf este tempo vai
tomar quantos argumentos?

594
00:28:12,200 --> 00:28:14,890

595
00:28:14,890 --> 00:28:16,770
Então olhe, é como dois.

596
00:28:16,770 --> 00:28:18,860
Há duas vírgulas ali, mas
uma daquelas vírgulas, é

597
00:28:18,860 --> 00:28:20,220
dentro das aspas.

598
00:28:20,220 --> 00:28:23,190
Assim, o primeiro argumento é literalmente
vai ser isso.

599
00:28:23,190 --> 00:28:31,850
H-E-L-L-S, vírgula por cento
s, barra-n.

600
00:28:31,850 --> 00:28:36,560
E agora eu estou oferecendo não um argumento,
mas dois argumentos para printf.

601
00:28:36,560 --> 00:28:39,530
>> E o que printf deve fazer com
estas duas entradas depois passá-las em

602
00:28:39,530 --> 00:28:42,050
como argumentos?

603
00:28:42,050 --> 00:28:45,360
É suposto tomar a segunda de
eles, que eu chamei de nome, de modo que o

604
00:28:45,360 --> 00:28:48,660
segundo pedaço de papel que eu escrevi
um momento atrás é chamado nome.

605
00:28:48,660 --> 00:28:53,550
Vai ficha do valor dentro
dessa variável no espaço reservado,

606
00:28:53,550 --> 00:28:58,310
% S, de modo que, mais uma vez, em apenas um momento de
tempo, veremos um efeito colateral de

607
00:28:58,310 --> 00:29:04,180
ter chamado printf, pelo qual agora temos
não vêem "Olá, mundo", mas "Olá,

608
00:29:04,180 --> 00:29:04,710
Obosi. "

609
00:29:04,710 --> 00:29:08,730
>> Assim, uma grande salva de palmas para os dois
nossos voluntários, dos quais apenas um sabia

610
00:29:08,730 --> 00:29:12,010
disso estaria acontecendo.

611
00:29:12,010 --> 00:29:12,990
Tudo bem.

612
00:29:12,990 --> 00:29:16,480
Então, talvez, simples como isso era,
Certamente, se você já está familiarizado

613
00:29:16,480 --> 00:29:20,190
com tal, espero que você nunca vai
esquecer que o visual particular de como

614
00:29:20,190 --> 00:29:21,220
funções de trabalho.

615
00:29:21,220 --> 00:29:23,000
>> Portanto, não há mais do que apenas getstring.

616
00:29:23,000 --> 00:29:26,020
Dentro da biblioteca CS50, há uma
bando inteiro de funções, todos os quais

617
00:29:26,020 --> 00:29:29,510
são capitalizados apenas para deixar claro
que escrevemos estas funções.

618
00:29:29,510 --> 00:29:33,610
Tipicamente, em C, quase todos os outros
função que você vai usar é minúsculas.

619
00:29:33,610 --> 00:29:36,190
Mas nós deliberadamente usar letras maiúsculas
só para deixar claro que estes

620
00:29:36,190 --> 00:29:39,880
são rodinhas de tipos que nós vamos
utilizar por apenas algumas semanas que

621
00:29:39,880 --> 00:29:42,890
simplificar o processo de obtenção de
entrada do usuário.

622
00:29:42,890 --> 00:29:46,740
>> A biblioteca CS50 não faz nada
que vós mesmos não podiam fazer por

623
00:29:46,740 --> 00:29:50,230
apenas usando o código C a partir de uma
livro oldschool.

624
00:29:50,230 --> 00:29:53,310
Mas, novamente, usá-los como treinamento
rodas de tipos para apenas um par de

625
00:29:53,310 --> 00:29:57,250
semanas para que possamos livrar-se do
complexidade que em breve você vai entender

626
00:29:57,250 --> 00:30:00,460
-se de fazer algo como
relativamente simples como a obtenção de

627
00:30:00,460 --> 00:30:02,080
de entrada a partir de um utilizador.

628
00:30:02,080 --> 00:30:05,540
>> Então saiba que você terá acesso
a getchar, GetDouble -

629
00:30:05,540 --> 00:30:06,050
dobrar.

630
00:30:06,050 --> 00:30:07,050
What's - e, em seguida GetFloat.

631
00:30:07,050 --> 00:30:07,600
O que é um float?

632
00:30:07,600 --> 00:30:09,382
Vamos começar por aí.

633
00:30:09,382 --> 00:30:10,600
>> Estudante: [inaudível].

634
00:30:10,600 --> 00:30:10,790
>> DAVID MALAN: Yeah.

635
00:30:10,790 --> 00:30:12,120
É um número com um ponto decimal.

636
00:30:12,120 --> 00:30:15,930
Assim, enquanto um inteiro é um inteiro, o qual
é apenas um número de 0 a 9,

637
00:30:15,930 --> 00:30:18,940
um certo número de repetições do mesmo,
um flutuador é algo

638
00:30:18,940 --> 00:30:20,100
com um ponto decimal.

639
00:30:20,100 --> 00:30:26,090
E um duplo, por sua vez, também é um
número com um ponto decimal, mas mais

640
00:30:26,090 --> 00:30:28,160
números após o decimal
ponto, potencialmente.

641
00:30:28,160 --> 00:30:30,040
>> Então, nós vamos voltar a este antes do tempo.

642
00:30:30,040 --> 00:30:34,560
Porém, em geral, cada um desses tipos de
de dados, cada um destes tipos de variáveis

643
00:30:34,560 --> 00:30:39,380
que uma biblioteca como a nossa, pode retornar ao
você, use números diferentes de bits para

644
00:30:39,380 --> 00:30:40,290
armazenar informações.

645
00:30:40,290 --> 00:30:43,910
Normalmente, um Char, que significa apenas
um personagem, usa 8 bits.

646
00:30:43,910 --> 00:30:47,490
E isso é realmente consistente com nossa
byte de voluntários na semana passada que

647
00:30:47,490 --> 00:30:50,410
veio e representou um
Caracteres ASCII de cada vez.

648
00:30:50,410 --> 00:30:51,850
Assim, um Char é de 8 bits.

649
00:30:51,850 --> 00:30:54,430
>> Um flutuador passa a ser
32 bits, tipicamente.

650
00:30:54,430 --> 00:30:59,230
E um duplo, como você pode imaginar, é
na verdade 64 bits, o que é apenas mais,

651
00:30:59,230 --> 00:31:01,360
o que significa que você pode ter maior
números ou mais precisão.

652
00:31:01,360 --> 00:31:03,000
Mas, novamente, mais sobre isso outra hora.

653
00:31:03,000 --> 00:31:06,550
GetLongLong, entretanto, embora estupidamente
nome, é realmente apenas uma

654
00:31:06,550 --> 00:31:10,770
inteiro que é duas vezes maior, o dobro
tempo, potencialmente, como uma forma regular

655
00:31:10,770 --> 00:31:12,940
número inteiro, 64 bits em vez de 32.

656
00:31:12,940 --> 00:31:14,560
E GetString estamos usando.

657
00:31:14,560 --> 00:31:18,870
>> Mas acontece que, na biblioteca CS50,
que é implementado, como veremos, em

658
00:31:18,870 --> 00:31:23,560
sob a forma dos dois ficheiros, um dos quais
é chamado cs50.h, tem outros dois

659
00:31:23,560 --> 00:31:24,770
tipos de dados nele.

660
00:31:24,770 --> 00:31:29,700
Booleanos não existem em C. Você pode
simulá-los usando apenas 0s e 1s

661
00:31:29,700 --> 00:31:30,850
ao longo de seus programas.

662
00:31:30,850 --> 00:31:35,500
Mas na biblioteca CS50 criaram
os símbolos de "verdadeiro" e "falso"

663
00:31:35,500 --> 00:31:38,580
para representar 1 e 0 para que você não
tem que codificar algo

664
00:31:38,580 --> 00:31:39,810
literalmente como 1 e 0.

665
00:31:39,810 --> 00:31:40,980
Mas vamos ver os novamente.

666
00:31:40,980 --> 00:31:42,330
>> String, também, não existe.

667
00:31:42,330 --> 00:31:44,520
E é por isso que eu mencionei é
um pouco de mentira para agora.

668
00:31:44,520 --> 00:31:46,660
Mas vamos descascar que
camada antes do tempo.

669
00:31:46,660 --> 00:31:49,540
Mas, por agora, uma string é um
seqüência de caracteres.

670
00:31:49,540 --> 00:31:51,790
>> Enquanto isso, em C, é de fato
têm diferentes tipos de dados.

671
00:31:51,790 --> 00:31:53,200
Observe estes são minúsculas.

672
00:31:53,200 --> 00:31:56,960
Assim, as funções que você viu há pouco
são funções escritas por CS50 que

673
00:31:56,960 --> 00:32:02,310
tornarei para vós um valor que cai
em uma dessas categorias.

674
00:32:02,310 --> 00:32:06,730
>> A cheat sheets casal apenas para plantar
a semente aqui. printf não apenas

675
00:32:06,730 --> 00:32:08,600
levar% s como espaços reservados.

676
00:32:08,600 --> 00:32:13,490
Leva% d para inteiros decimais,
ou% i iria funcionar tão bem.

677
00:32:13,490 --> 00:32:19,450
% F está valores de ponto flutuante. % C é para
um char, se você quer apenas ligar um

678
00:32:19,450 --> 00:32:23,510
caracteres em uma seqüência pré-formatado
como temos vindo a fazer, você pode usar% c.

679
00:32:23,510 --> 00:32:28,490
>> E então, um pouco irritante,% LLD é
por um longo, longo inteiro decimal,

680
00:32:28,490 --> 00:32:31,050
o que só significa que se você realmente precisa de um
grande número e que você está usando algo

681
00:32:31,050 --> 00:32:35,450
chamado de um longo, que virá
de volta para em um pset, você pode usar% para LLD

682
00:32:35,450 --> 00:32:40,700
dizer printf, conecte realmente uma grande
inteiro aqui sob a forma do seu segundo ou

683
00:32:40,700 --> 00:32:41,830
algum outro argumento.

684
00:32:41,830 --> 00:32:45,700
>> E, finalmente, eu prometi que
Há algumas outras fuga

685
00:32:45,700 --> 00:32:47,670
seqüências que printf suporta.

686
00:32:47,670 --> 00:32:49,160
Nós vimos barra-n.

687
00:32:49,160 --> 00:32:50,510
Barra-r você pode ver.

688
00:32:50,510 --> 00:32:51,780
É uma espécie de uma coisa old-school.

689
00:32:51,780 --> 00:32:55,920
Se você já usou uma verdadeira máquina de escrever anos
atrás e você puxou a manivela

690
00:32:55,920 --> 00:32:59,810
que não só a rotação do volante
mover a linha, ele também mudou a

691
00:32:59,810 --> 00:33:03,730
tudo isso por todo o caminho de volta para
à esquerda, bem, barra-r apenas

692
00:33:03,730 --> 00:33:06,480
essencialmente move o cursor de volta
para o início da linha

693
00:33:06,480 --> 00:33:07,830
sem movê-lo para baixo.

694
00:33:07,830 --> 00:33:09,780
Mas, novamente, mais sobre isso,
talvez, no futuro.

695
00:33:09,780 --> 00:33:13,670
>> Barra-citações, barra-double,
barra-barra invertida é o

696
00:33:13,670 --> 00:33:16,600
solução para o pequenino mistério
Aludi anteriormente.

697
00:33:16,600 --> 00:33:18,920
E barra-0 é realmente
bastante interessante.

698
00:33:18,920 --> 00:33:21,470
Mas vamos voltar ao
que em pouco tempo.

699
00:33:21,470 --> 00:33:25,640
>> Então deixe-me entrar, agora, o CS50
aparelho, e vamos realmente fazer uma

700
00:33:25,640 --> 00:33:28,930
rápida aquecer com um dos exemplos
já e depois se moveu para

701
00:33:28,930 --> 00:33:31,160
algo um pouco mais complexo.

702
00:33:31,160 --> 00:33:34,980
Então, se eu abrir o meu programa
chamado gedit -

703
00:33:34,980 --> 00:33:36,840
este é o meu editor gráfico.

704
00:33:36,840 --> 00:33:38,460
E eu posso fazer isso -

705
00:33:38,460 --> 00:33:39,820
deixe-me fechar a janela lá -

706
00:33:39,820 --> 00:33:42,720
por meio deste ícone aqui em baixo,
gedit, no canto inferior esquerdo

707
00:33:42,720 --> 00:33:44,170
canto ao lado do menu.

708
00:33:44,170 --> 00:33:48,670
>> Eu estou indo para ir em frente e avançar, e
salvar este exemplo em, digamos, John

709
00:33:48,670 --> 00:33:49,660
Pasta de Harvard.

710
00:33:49,660 --> 00:33:52,690
Pasta de John Harvard é apenas a sua casa
diretório onde todos os seus arquivos de viver

711
00:33:52,690 --> 00:33:53,340
por padrão.

712
00:33:53,340 --> 00:33:58,410
E eu vou guardá-lo como
um arquivo chamado Olá-0.C.

713
00:33:58,410 --> 00:34:01,260
E eu escolhi esse nome só por isso
alinha com o código de exemplo na

714
00:34:01,260 --> 00:34:04,210
site do curso e na
YouTube vídeos online.

715
00:34:04,210 --> 00:34:06,320
>> Então agora eu vou começar a
escrever o meu primeiro programa.

716
00:34:06,320 --> 00:34:08,469
Deixe-me aproximar para legibilidade.

717
00:34:08,469 --> 00:34:12,760
E eu estou indo para ir em frente e dizer int
void main, que é assim mesmo

718
00:34:12,760 --> 00:34:14,900
amarelo peça do puzzle que
inicia um programa.

719
00:34:14,900 --> 00:34:18,290
Eu comecei o hábito ao longo do
anos de abertura meu chaveta, em seguida,

720
00:34:18,290 --> 00:34:22,000
também fechá-lo e, em seguida, voltar para
onde eu quero colocar o meu código, basta

721
00:34:22,000 --> 00:34:24,630
porque isso me ajuda a manter tudo
equilibrada, especialmente meu

722
00:34:24,630 --> 00:34:25,880
programa fica muito tempo.

723
00:34:25,880 --> 00:34:29,239
>> E agora, aqui, eu estou indo para ir em frente
e dizer, printf, citar unquote,

724
00:34:29,239 --> 00:34:34,330
Olá mundo, barra-n, perto citação,
Fechar parênteses, ponto e vírgula.

725
00:34:34,330 --> 00:34:38,100
Então, eu estou apenas repetindo tudo o que temos
tomado como certo até agora.

726
00:34:38,100 --> 00:34:39,270
Agora vou para diminuir o zoom.

727
00:34:39,270 --> 00:34:43,030
>> E essa janela de terminal aqui em baixo, o que
estou autorizado a fazer nesta preto

728
00:34:43,030 --> 00:34:44,389
ea janela de branco?

729
00:34:44,389 --> 00:34:46,977
O que eu posso usá-lo?

730
00:34:46,977 --> 00:34:49,770
Portanto, este é o lugar onde eu executar comandos e
onde eu possa compilar as coisas.

731
00:34:49,770 --> 00:34:50,620
E eu vou mantê-lo simples.

732
00:34:50,620 --> 00:34:52,780
Eu vou usar um programa
chamado Make, o que não é

733
00:34:52,780 --> 00:34:54,020
tecnicamente um compilador.

734
00:34:54,020 --> 00:34:56,360
Chamado Clang do compilador, mas
vamos voltar a isso em um

735
00:34:56,360 --> 00:34:57,190
semana ou tempo de dois.

736
00:34:57,190 --> 00:35:03,410
>> Por agora, eu só vou digitar fazer
Olá-0, mas aqueles que foram

737
00:35:03,410 --> 00:35:07,050
comparando em suas mentes o que eu
digitado com o que eu deveria ter digitado pode

738
00:35:07,050 --> 00:35:10,180
já sei que eu fiz
algo errado aqui.

739
00:35:10,180 --> 00:35:12,160
Agora, há claramente alguns erros.

740
00:35:12,160 --> 00:35:16,742
Antes mesmo de olhar para o que eles são, de qualquer
pensamentos sobre o que eu fiz de errado?

741
00:35:16,742 --> 00:35:18,590
>> ESTUDANTES: [interpondo VOZES].

742
00:35:18,590 --> 00:35:18,840
>> DAVID MALAN: Yeah.

743
00:35:18,840 --> 00:35:20,640
Eu estou sentindo falta de arquivo de cabeçalho da biblioteca.

744
00:35:20,640 --> 00:35:24,240
Qualquer um desses arquivos h. São chamados de cabeçalho
arquivos, e eles coletivamente

745
00:35:24,240 --> 00:35:25,680
pertencem a coisas chamadas bibliotecas.

746
00:35:25,680 --> 00:35:28,030
Bibliotecas são apenas pedaços de código
que outras pessoas escreveram.

747
00:35:28,030 --> 00:35:32,140
Assim, o padrão de [? i?] é uma biblioteca
coleção de arquivos que contenham código

748
00:35:32,140 --> 00:35:33,330
que outras pessoas escreveram.

749
00:35:33,330 --> 00:35:34,820
>> Então, eu estou sentindo falta disso.

750
00:35:34,820 --> 00:35:36,520
Então por que estou recebendo um erro?

751
00:35:36,520 --> 00:35:40,840
Bem, deixe-me voltar para cima em
minha janela do terminal aqui.

752
00:35:40,840 --> 00:35:44,310
E, infelizmente, no C, como em um monte de
linguagens de programação, especialmente

753
00:35:44,310 --> 00:35:47,830
se é tudo novo para você, o erro
mensagens são precisos, mas eles também são

754
00:35:47,830 --> 00:35:48,620
bastante enigmática.

755
00:35:48,620 --> 00:35:51,720
E o erro aqui, em vermelho, é
"Função de biblioteca implicitamente declarando

756
00:35:51,720 --> 00:35:57,660
printf com o tipo ", e então rola
para a próxima linha, "int const char *,

757
00:35:57,660 --> 00:36:00,220
... "Ele só fica realmente
esmagadora rapidamente.

758
00:36:00,220 --> 00:36:04,420
>> Mas o que você deve começar a fazer, se,
novo, novo para tudo isso, é apenas para

759
00:36:04,420 --> 00:36:06,010
começar a procurar palavras-chave.

760
00:36:06,010 --> 00:36:08,770
Obviamente, eu não poderia entender a metade
as palavras que eu estou vendo ainda.

761
00:36:08,770 --> 00:36:10,140
Você vai, no entanto, dentro de uma semana.

762
00:36:10,140 --> 00:36:11,230
Mas vejo printf.

763
00:36:11,230 --> 00:36:14,310
E isso deve começar, em pouco tempo, a
refrescar sua memória, tudo bem, printf.

764
00:36:14,310 --> 00:36:15,210
Algo está errado com printf.

765
00:36:15,210 --> 00:36:16,580
Será que eu soletrar errado?

766
00:36:16,580 --> 00:36:18,130
Não, ele não se parece com - oh.

767
00:36:18,130 --> 00:36:21,350
Eu não posso usá-lo, a menos que eu ensino
o compilador que ele existe.

768
00:36:21,350 --> 00:36:25,220
E assim, mais uma vez, vá com seus instintos,
mesmo se você realmente não entendo

769
00:36:25,220 --> 00:36:26,510
as mensagens de erro reais.

770
00:36:26,510 --> 00:36:30,240
>> E, de fato, a solução aqui é apenas
incluí-lo na parte superior do arquivo

771
00:36:30,240 --> 00:36:34,340
assim, resaving meu arquivo com
Control-S ou no menu Arquivo.

772
00:36:34,340 --> 00:36:36,730
E se eu agora voltar aqui,
Vou esclarecer isso.

773
00:36:36,730 --> 00:36:39,150
Control-L é apenas uma maneira agradável
para limpar a tela.

774
00:36:39,150 --> 00:36:44,870
E então eu vou escrever "Olá fazer
0 "Enter, e agora eu ainda vejo um

775
00:36:44,870 --> 00:36:47,710
seqüência enigmática de símbolos, mas
vamos voltar a isso.

776
00:36:47,710 --> 00:36:49,230
Isso é o que fazem está fazendo por você.

777
00:36:49,230 --> 00:36:52,590
É a automatização o processo de tomada
um comando bastante chato envolvendo

778
00:36:52,590 --> 00:36:54,050
Clang, o compilador real.

779
00:36:54,050 --> 00:36:57,460
Mas o fato de que eu não tenho erros significa
que essa coisa deve funcionar.

780
00:36:57,460 --> 00:37:00,630
>> Então, eu estou indo agora para fazer -
deixe-me aproximar novamente -

781
00:37:00,630 --> 00:37:07,070
./hello-0 Enter, e, na verdade, eu vejo
"Olá, mundo". Então, vamos agora melhorar

782
00:37:07,070 --> 00:37:12,105
este nunca tão pouco apenas para replicar
os passos que pretendia.

783
00:37:12,105 --> 00:37:15,370
Vou mudar o nome deste com
Salvar como para hello1.c.

784
00:37:15,370 --> 00:37:20,300
E agora eu vou declarar uma variável
chamou o nome, por isso o nome string,

785
00:37:20,300 --> 00:37:23,420
e eu vou colocar nele o
valor entre aspas

786
00:37:23,420 --> 00:37:27,030
D-A-V-I-D close-quote ponto e vírgula.

787
00:37:27,030 --> 00:37:31,150
E agora eu estou indo para substituir o "mundo"
com o espaço reservado para uma string?

788
00:37:31,150 --> 00:37:32,200
% S.

789
00:37:32,200 --> 00:37:35,040
>> E agora, quantos argumentos devem
printf aproveitar este momento?

790
00:37:35,040 --> 00:37:35,700
Assim, dois.

791
00:37:35,700 --> 00:37:37,090
Então eu ir para fora das aspas.

792
00:37:37,090 --> 00:37:39,330
Eu digito "nome" depois de uma vírgula.

793
00:37:39,330 --> 00:37:41,550
Mas eu fiz algo
mais errado neste momento.

794
00:37:41,550 --> 00:37:43,940
Mas vamos supor que eu não fiz
perceber isso ainda.

795
00:37:43,940 --> 00:37:44,910
Deixe-me ir até aqui.

796
00:37:44,910 --> 00:37:48,850
>> E notem, também, eu estou ficando um pouco
cansar de digitar "fazer Olá 0" todo o

797
00:37:48,850 --> 00:37:50,180
tempo, "fazer" e tudo isso.

798
00:37:50,180 --> 00:37:53,270
Assim, verifica-se, na Linus você pode
muitas vezes bater a seta para cima no seu

799
00:37:53,270 --> 00:37:56,850
teclado, e você pode realmente rolar
através de todos os comandos que eu

800
00:37:56,850 --> 00:37:58,830
executado anterior para agora.

801
00:37:58,830 --> 00:38:02,040
Então, se eu fizer isso, Cima, Cima,
há fazer Olá 0.

802
00:38:02,040 --> 00:38:02,610
Eu não quero isso.

803
00:38:02,610 --> 00:38:05,450
Eu só quero mudar isso para
Olá 1 neste momento, Enter.

804
00:38:05,450 --> 00:38:07,620
Eventualmente, isso vai
poupar algum tempo.

805
00:38:07,620 --> 00:38:08,150
>> Tudo bem.

806
00:38:08,150 --> 00:38:09,520
Infelizmente, não é um erro.

807
00:38:09,520 --> 00:38:10,980
Então deixe-me ir para cima.

808
00:38:10,980 --> 00:38:13,120
Este parece que eu realmente
massacrado este programa.

809
00:38:13,120 --> 00:38:16,530
Quero dizer, meu Deus, é duas linhas de código,
e suas 10 linhas de erros.

810
00:38:16,530 --> 00:38:18,800
Mas olhe para o alto primeiro.

811
00:38:18,800 --> 00:38:21,640
Uso de cadeia do identificador não declarado.

812
00:38:21,640 --> 00:38:23,270
Será que eu quero dizer padrão i n?

813
00:38:23,270 --> 00:38:23,930
Não, eu não fiz.

814
00:38:23,930 --> 00:38:24,940
Eu quis dizer string.

815
00:38:24,940 --> 00:38:29,390
>> Mas onde está a variável de cadeia
tipo declarado, DD podemos dizer?

816
00:38:29,390 --> 00:38:30,730
Portanto, é no CS50 da biblioteca.

817
00:38:30,730 --> 00:38:33,740
Por isso, não é suficiente, nesses primeiros
par de semanas, apenas para usar

818
00:38:33,740 --> 00:38:34,860
C o que nos dá.

819
00:38:34,860 --> 00:38:38,120
Eu também estou indo para ir até aqui, e eu
poderia colocá-lo acima ou abaixo, mas vou

820
00:38:38,120 --> 00:38:40,340
apenas mantê-lo alfabética
para manter as coisas em ordem.

821
00:38:40,340 --> 00:38:43,470
Eu estou indo para incluir cs50.h,
que é pré-instalado para

822
00:38:43,470 --> 00:38:44,900
você no aparelho CS50.

823
00:38:44,900 --> 00:38:47,640
E é open source, por isso mesmo as pessoas
na internet pode usá-lo na sua

824
00:38:47,640 --> 00:38:48,450
computadores próprios.

825
00:38:48,450 --> 00:38:50,700
Mas ele vem com o aparelho CS50.

826
00:38:50,700 --> 00:38:55,320
>> Então, agora deixe-me voltar e recompilar
Olá fazer isso com um.

827
00:38:55,320 --> 00:38:55,710
Droga.

828
00:38:55,710 --> 00:38:57,240
Ainda outro erro.

829
00:38:57,240 --> 00:38:59,370
Deixe-me ir até o primeiro, no entanto.

830
00:38:59,370 --> 00:39:00,630
Essa é um pouco complexo.

831
00:39:00,630 --> 00:39:03,830
Constante carácter multi-caráter.

832
00:39:03,830 --> 00:39:04,890
Isso não está me ajudando.

833
00:39:04,890 --> 00:39:08,220
Mas aviso, Clang é pelo menos um pouco
pouco decente, em que com um pouco de

834
00:39:08,220 --> 00:39:11,890
verde símbolo de acento circunflexo, ele está dizendo
aqui é onde eu estraguei tudo.

835
00:39:11,890 --> 00:39:16,160
Por que é apontar, com esse pequeno
Arqueiro Verde, para o apóstrofo próximo

836
00:39:16,160 --> 00:39:18,290
para o meu nome?

837
00:39:18,290 --> 00:39:20,880
>> Portanto, esta é uma das coisas que você apenas
se acostumar, especialmente se você tiver sido

838
00:39:20,880 --> 00:39:23,980
programação em Python, ou JavaScript,
ou outras línguas onde este detalhe

839
00:39:23,980 --> 00:39:24,560
não importa.

840
00:39:24,560 --> 00:39:25,740
Em C, ele não importa.

841
00:39:25,740 --> 00:39:29,520
Se você declarar uma string, que é
uma seqüência de 0 ou mais caracteres,

842
00:39:29,520 --> 00:39:32,280
você realmente deve usar aspas duplas.

843
00:39:32,280 --> 00:39:36,670
Então, eu realmente preciso mudar isso de volta
para abrir citação, feche citação, com

844
00:39:36,670 --> 00:39:37,800
aspas duplas.

845
00:39:37,800 --> 00:39:41,610
As aspas simples têm o seu lugar, mas
somente quando você estiver usando indivíduo

846
00:39:41,610 --> 00:39:44,100
caracteres, mas mais sobre isso outra hora.

847
00:39:44,100 --> 00:39:46,550
Por enquanto, as aspas duplas
são necessárias.

848
00:39:46,550 --> 00:39:50,460
>> Então, agora, deixe-me voltar ao meu terminal
janela, faça Olá 1.

849
00:39:50,460 --> 00:39:51,450
E quem é confiante?

850
00:39:51,450 --> 00:39:53,800
É este programa agora vai
para compilar corretamente?

851
00:39:53,800 --> 00:39:58,250

852
00:39:58,250 --> 00:39:58,540
OK.

853
00:39:58,540 --> 00:39:59,780
Assim, três de nós pensamos isso.

854
00:39:59,780 --> 00:40:00,280
Tudo bem.

855
00:40:00,280 --> 00:40:01,190
Enter.

856
00:40:01,190 --> 00:40:02,440
E ele realmente fez.

857
00:40:02,440 --> 00:40:05,130
Portanto, não há nenhum erro desta vez, mesmo
que este programa está ficando um pouco

858
00:40:05,130 --> 00:40:05,840
mais complexa.

859
00:40:05,840 --> 00:40:10,110
Se eu agora fazer ponto barra 1 Olá, Enter
ele vai dizer "Olá, David."

860
00:40:10,110 --> 00:40:11,750
>> Mas vamos fazer a terceira iteração
Daí que, quando a

861
00:40:11,750 --> 00:40:13,380
programa é realmente dinâmica.

862
00:40:13,380 --> 00:40:16,770
Deixe-me ir em frente e mudar o arquivo
nome, apenas por coerência com a

863
00:40:16,770 --> 00:40:20,410
arquivos que você terá disponível
para você depois online.

864
00:40:20,410 --> 00:40:21,620
Enter.

865
00:40:21,620 --> 00:40:25,510
E agora eu estou indo para ir e não
armazenar "David" codificado aqui.

866
00:40:25,510 --> 00:40:28,826
O que eu poderia fazer para muito simplesmente
melhorar este programa?

867
00:40:28,826 --> 00:40:30,520
>> Eu poderia chamar getstring.

868
00:40:30,520 --> 00:40:33,240
Ele pode ser um pouco o que não é óbvio
prestes a acontecer, então eu vou

869
00:40:33,240 --> 00:40:38,470
para realmente adicionar outra linha, printf,
e dizer o nome, cólon, próximo citação, apenas

870
00:40:38,470 --> 00:40:40,790
para dar ao usuário um prompt
no ecrã.

871
00:40:40,790 --> 00:40:42,980
E agora eu estou indo para ir aqui, e eu estou
vai usar o meu atalho de teclado.

872
00:40:42,980 --> 00:40:47,680
Eu estou indo para ir para cima, para cima, e mudar
Olá Olá 1 a 2, Enter.

873
00:40:47,680 --> 00:40:49,260
E, felizmente, estou fazendo progresso.

874
00:40:49,260 --> 00:40:52,720
>> E agora eu vou subir
a ponto barra Olá e

875
00:40:52,720 --> 00:40:54,690
mudar isso a 2, Enter.

876
00:40:54,690 --> 00:40:55,650
E agora o meu programa -

877
00:40:55,650 --> 00:40:57,700
Eu vou fazer zoom in - está ficando
um pouco mais bonita.

878
00:40:57,700 --> 00:41:02,190
Nome vai ser, digamos Rob
Neste momento, entra, Olá, Rob.

879
00:41:02,190 --> 00:41:03,260
Nós podemos fazê-lo novamente.

880
00:41:03,260 --> 00:41:05,360
Nome, Lauren, Enter.

881
00:41:05,360 --> 00:41:07,820
Nome: José, Enter.

882
00:41:07,820 --> 00:41:11,596
Nome, vamos tentar ser
difícil, Enter.

883
00:41:11,596 --> 00:41:12,410
Eh.

884
00:41:12,410 --> 00:41:14,680
Não é realmente um bug.

885
00:41:14,680 --> 00:41:16,090
Então é um pouco feio.

886
00:41:16,090 --> 00:41:18,640
Então talvez possamos resolver este
no futuro, não agora.

887
00:41:18,640 --> 00:41:20,840
>> Mas como é que você instintivamente
percorrer cerca de endereçamento

888
00:41:20,840 --> 00:41:21,990
esse desafio particular?

889
00:41:21,990 --> 00:41:23,710
Ele apenas parece estúpido.

890
00:41:23,710 --> 00:41:27,320
Como você evita coisas
olhar estúpido?

891
00:41:27,320 --> 00:41:29,890
Assim nós poderíamos fazer, OK, eu ouvi um casal
coisas, uma condição e um loop.

892
00:41:29,890 --> 00:41:33,340
Nós poderíamos usar, uma, uma condição, para verificar
o que é o comprimento da cadeia

893
00:41:33,340 --> 00:41:34,190
o usuário nos deu?

894
00:41:34,190 --> 00:41:37,100
E se for 0, ele é apenas citar unquote,
eles apenas pressione Enter, em seguida,

895
00:41:37,100 --> 00:41:38,930
talvez eu deveria gritar com eles
e levá-los novamente.

896
00:41:38,930 --> 00:41:39,970
Mas como a levá-los de novo?

897
00:41:39,970 --> 00:41:44,230
Bem, eu também ouvi loop, e eu podia
fazer isso de novo e de novo e de novo

898
00:41:44,230 --> 00:41:47,010
avisar o usuário para a mesma coisa.

899
00:41:47,010 --> 00:41:48,880
>> Bem, vamos fazer um outro exemplo
usando uma diferente

900
00:41:48,880 --> 00:41:50,620
função na biblioteca CS50.

901
00:41:50,620 --> 00:41:52,330
Deixe-me encerrar este processo.

902
00:41:52,330 --> 00:41:53,510
Deixe-me criar um novo.

903
00:41:53,510 --> 00:41:58,510
E eu vou chamá-lo de adder.c, só porque
é fácil de fazer aritmética simples,

904
00:41:58,510 --> 00:42:00,890
mesmo que isso será completamente
abaixo do esperado com o que você poderia fazer

905
00:42:00,890 --> 00:42:02,250
com qualquer computador moderno.

906
00:42:02,250 --> 00:42:03,750
>> Mas deixe-me ir em frente agora e -

907
00:42:03,750 --> 00:42:10,680
Eu aprendi minha lição última vez - incluem
cs50.h, include stdio.h, int

908
00:42:10,680 --> 00:42:14,170
void main, que, por enquanto, eu vou
assumir uma fé cega, mas vamos assumir

909
00:42:14,170 --> 00:42:16,380
que vai entender o que
isso significa que antes do tempo.

910
00:42:16,380 --> 00:42:21,030
E eu vou dizer uma coisa
como "dá-me um int."

911
00:42:21,030 --> 00:42:22,140
>> E agora, como faço para obter um int?

912
00:42:22,140 --> 00:42:26,820
Quero, finalmente, declarar uma variável
chamada x de tipo int e

913
00:42:26,820 --> 00:42:29,240
nela armazenar um número inteiro a partir do utilizador.

914
00:42:29,240 --> 00:42:29,970
Então isso foi um bocado.

915
00:42:29,970 --> 00:42:35,680
Mas se alguém quer propor, como
faço para declarar um inteiro chamado x?

916
00:42:35,680 --> 00:42:36,310
X INT.

917
00:42:36,310 --> 00:42:37,430
>> Então, ele realmente é tão simples.

918
00:42:37,430 --> 00:42:38,240
Dê-me um int.

919
00:42:38,240 --> 00:42:39,070
Chame-x.

920
00:42:39,070 --> 00:42:40,580
Agora eu uso o operador de atribuição.

921
00:42:40,580 --> 00:42:43,400
E como faço para armazenar a partir do
deixado um valor do utilizador?

922
00:42:43,400 --> 00:42:47,310
Eu não quero chamar getstring,
obviamente, mas sim getInt.

923
00:42:47,310 --> 00:42:49,060
Quaisquer argumentos?

924
00:42:49,060 --> 00:42:49,350
Não.

925
00:42:49,350 --> 00:42:51,870
Por isso, é aberto parêntese, perto paren
de imediato, e em seguida, uma

926
00:42:51,870 --> 00:42:53,440
vírgula termina a linha.

927
00:42:53,440 --> 00:42:54,930
>> Agora, deixe-me fazer isso de novo.

928
00:42:54,930 --> 00:42:57,070
Dê-me outra int.

929
00:42:57,070 --> 00:43:01,850
Desta vez eu vou fazer int, vamos
chamá-lo de y, é igual a getInt.

930
00:43:01,850 --> 00:43:05,060
E agora deixe-me fazer uma coisa super-simples
como um pouco de matemática.

931
00:43:05,060 --> 00:43:14,340
Assim printf, a soma das% d é o
espaço reservado para um int.

932
00:43:14,340 --> 00:43:20,030
E% d, período, barra-n.

933
00:43:20,030 --> 00:43:20,360
>> Tudo bem.

934
00:43:20,360 --> 00:43:21,670
Então, isso não é verdade matemática.

935
00:43:21,670 --> 00:43:25,500
Mas se eu quero dizer que a soma deste
valor mais este valor é igual a este

936
00:43:25,500 --> 00:43:29,320
outro valor, quantos argumentos em
total de que eu deveria estar dando printf,

937
00:43:29,320 --> 00:43:30,520
em última instância?

938
00:43:30,520 --> 00:43:31,420
Assim, quatro, certo?

939
00:43:31,420 --> 00:43:33,790
Esta cadeia e, em seguida, os três valores.

940
00:43:33,790 --> 00:43:37,560
Então x é o primeiro que eu quero ser
conectados pela primeira vez ao% d.

941
00:43:37,560 --> 00:43:39,270
y vai ser o próximo.

942
00:43:39,270 --> 00:43:42,030
>> E agora eu meio que quero dizer
z, z, mas não existe.

943
00:43:42,030 --> 00:43:43,190
Mas isso não é um grande negócio.

944
00:43:43,190 --> 00:43:45,440
Porque o que você faz instintivamente,
especialmente se você tivesse um

945
00:43:45,440 --> 00:43:47,820
calculadora gráfica, o que você digita?

946
00:43:47,820 --> 00:43:48,760
Como cerca de x + y?

947
00:43:48,760 --> 00:43:50,200
Portanto, não é uma variável real.

948
00:43:50,200 --> 00:43:51,820
É apenas a soma de dois
outras variáveis.

949
00:43:51,820 --> 00:43:53,170
E isso é perfeitamente legítimo.

950
00:43:53,170 --> 00:43:56,630
C certamente entende simples
aritmética assim.

951
00:43:56,630 --> 00:43:58,450
>> Ponto e vírgula, salve.

952
00:43:58,450 --> 00:44:02,080
Agora, deixe-me ir para baixo aqui e
digite make víbora, Enter.

953
00:44:02,080 --> 00:44:04,100
Nenhum erro, de modo que é um progresso também.

954
00:44:04,100 --> 00:44:04,890
Digite víbora.

955
00:44:04,890 --> 00:44:07,100
E um outro atalho de teclado,
se você começar a se cansar

956
00:44:07,100 --> 00:44:08,760
com todos os comandos -

957
00:44:08,760 --> 00:44:12,650
Se você começa a digitar um comando, como ponto
reduzir anúncio, e é aí que o seu

958
00:44:12,650 --> 00:44:16,020
tédio entra em ação, você geralmente pode bater
Tab para que o computador terminar a

959
00:44:16,020 --> 00:44:20,510
descansar da frase para você, se não é
ambíguo que deve vir depois do anúncio.

960
00:44:20,510 --> 00:44:23,950
>> Então deixe-me ir em frente agora
e clicar em Enter.

961
00:44:23,950 --> 00:44:27,490
Dê-me um int, 1, 2, e
Felizmente, é 3.

962
00:44:27,490 --> 00:44:29,900
Mas, como sempre, os programas de testes
não deve reduzir a

963
00:44:29,900 --> 00:44:30,820
apenas experimentá-lo uma vez.

964
00:44:30,820 --> 00:44:35,560
Deixe-me tentar um caso extremo, como negativo
1, dá-me um, e que um

965
00:44:35,560 --> 00:44:36,210
verifica também.

966
00:44:36,210 --> 00:44:38,870
E eu provavelmente vai querer fazer um pouco mais
testes rigorosos, mas estou bastante

967
00:44:38,870 --> 00:44:40,630
confortável com o local onde isso está.

968
00:44:40,630 --> 00:44:43,110
>> Bem, agora vamos tentar outro programa
que desta vez utiliza um

969
00:44:43,110 --> 00:44:44,620
bit de outra sintaxe.

970
00:44:44,620 --> 00:44:46,100
Deixe-me criar um novo arquivo.

971
00:44:46,100 --> 00:44:51,050
Vou chamar esta conditions0.c para alinhar
com um código de exemplo online.

972
00:44:51,050 --> 00:44:55,550
E deixe-me ir em frente e fazer
incluem cs50.h incluem

973
00:44:55,550 --> 00:45:00,320
stdio.h, em void main -

974
00:45:00,320 --> 00:45:01,030
OK.

975
00:45:01,030 --> 00:45:01,850
Lá vamos nós.

976
00:45:01,850 --> 00:45:03,010
Temos o nosso clichê padrão.

977
00:45:03,010 --> 00:45:08,170
>> E dessa vez eu vou dizer printf,
"Eu gostaria de um int, por favor", apenas para

978
00:45:08,170 --> 00:45:10,030
fazer o prompt de um pouco
mais amigável.

979
00:45:10,030 --> 00:45:11,620
E agora eu quero ter uma
int do usuário.

980
00:45:11,620 --> 00:45:15,010
Vou chamá-lo de n este tempo, apenas
porque n soa como número.

981
00:45:15,010 --> 00:45:18,140
getInt, e agora, o que fazer
Eu quero fazer com ele?

982
00:45:18,140 --> 00:45:21,640
Bem, se n é - e eu vou fazer zoom in -

983
00:45:21,640 --> 00:45:25,930
se n for maior do que 0, quero
fazer o seguinte -

984
00:45:25,930 --> 00:45:36,060
printf "Você escolheu um número positivo."
Senão, eu vou digitar printf "Você

985
00:45:36,060 --> 00:45:37,870
escolheu um negativo

986
00:45:37,870 --> 00:45:39,650
número. "Tudo bem.

987
00:45:39,650 --> 00:45:44,410
Portanto, este programa, embora eu fiz isso
rápido, parece certo sintaticamente.

988
00:45:44,410 --> 00:45:45,010
Deixe-me tentar isso.

989
00:45:45,010 --> 00:45:46,890
Faça condição 0.

990
00:45:46,890 --> 00:45:47,710
Parece estar a correr.

991
00:45:47,710 --> 00:45:49,230
Condição 0, entrar.

992
00:45:49,230 --> 00:45:51,910
Vamos dar-lhe um int de 50.

993
00:45:51,910 --> 00:45:53,160
Eu escolhi um número positivo.

994
00:45:53,160 --> 00:45:54,230
Vamos tentar novamente.

995
00:45:54,230 --> 00:45:54,930
Estado 0.

996
00:45:54,930 --> 00:45:56,260
Negativo 50.

997
00:45:56,260 --> 00:45:57,290
Eu escolhi um número negativo.

998
00:45:57,290 --> 00:46:00,350
>> Mas agora, deixe-me escolher o que vamos continuar
chamando um caso de canto, que é mais

999
00:46:00,350 --> 00:46:04,702
um caso interessante que você pensa
pode dar-lhe alguns problemas, 0.

1000
00:46:04,702 --> 00:46:07,940
Agora, eu tenho certeza que este é um dos
Nesses casos canto onde zero é

1001
00:46:07,940 --> 00:46:12,330
nem positivo nem negativo, então minha
programa, embora em sintaticamente

1002
00:46:12,330 --> 00:46:15,440
corrigir - ele compila, ele roda -
não é logicamente correta.

1003
00:46:15,440 --> 00:46:21,050
Então qual é a solução simples aqui se eu quiser
para detectar, se eu quiser manipular n

1004
00:46:21,050 --> 00:46:23,840
é igual a 0 separadamente?

1005
00:46:23,840 --> 00:46:32,980
>> Assim, se n é igual a 0, então eu quero dizer
algo como printf "Você escolheu a 0."

1006
00:46:32,980 --> 00:46:33,990
Deixe-me tentar isso agora.

1007
00:46:33,990 --> 00:46:38,320
Deixe-me voltar aqui, desmarque
minha janela, e recompilar.

1008
00:46:38,320 --> 00:46:38,690
Hm.

1009
00:46:38,690 --> 00:46:39,770
Um erro gerar.

1010
00:46:39,770 --> 00:46:41,630
Mas eu quiser verificar
se n for igual a 0.

1011
00:46:41,630 --> 00:46:44,230

1012
00:46:44,230 --> 00:46:47,720
>> Então, novamente, outra coisa estúpida
para se acostumar, é sinal de igual

1013
00:46:47,720 --> 00:46:48,910
o operador de atribuição.

1014
00:46:48,910 --> 00:46:52,240
Portanto, este é realmente erro em que,
tecnicamente, embora o compilador

1015
00:46:52,240 --> 00:46:56,450
protegeu-me de mim mesmo, nós
ser tecnicamente copiar 0 em n, que

1016
00:46:56,450 --> 00:46:57,590
não é o que eu quero.

1017
00:46:57,590 --> 00:47:00,950
Eu quero testar a igualdade
com iguais iguais.

1018
00:47:00,950 --> 00:47:03,390
E para que agora pode ser
o meu melhor solução.

1019
00:47:03,390 --> 00:47:07,810
>> Deixe-me realmente salve isso como, por exemplo,
conditions1, para ser novo e melhorado.

1020
00:47:07,810 --> 00:47:10,480
Portanto, agora se eu recompilar isso,
faria condições -

1021
00:47:10,480 --> 00:47:16,960
gritos - fazer conditions1 dot barra
conditions1, Enter, "Eu gostaria de um int,

1022
00:47:16,960 --> 00:47:18,760
por favor. "Eu estou indo para ir
frente e digite 50.

1023
00:47:18,760 --> 00:47:19,660
Ele ainda é bom.

1024
00:47:19,660 --> 00:47:21,200
Negativo 50, ainda bem.

1025
00:47:21,200 --> 00:47:24,920
0, e, de facto, detectaram
que eu peguei 0.

1026
00:47:24,920 --> 00:47:28,200
>> Então, o que mais pode agora eu faço com isso?

1027
00:47:28,200 --> 00:47:32,280
Bem, nós certamente podemos fazer cada vez mais
coisas complexas.

1028
00:47:32,280 --> 00:47:37,240
Mas o que eu gostaria de propor é
que vamos acabar com esta nota aqui.

1029
00:47:37,240 --> 00:47:41,680
Se puxar isso, você vai ver, talvez,
uma caricatura sua favorita

1030
00:47:41,680 --> 00:47:43,326
até hoje você pode
nunca entendi.

1031
00:47:43,326 --> 00:47:46,550

1032
00:47:46,550 --> 00:47:49,520
E isso é sobre a qualidade do riso
você deve começar com piadas CS.

1033
00:47:49,520 --> 00:47:51,060
Então, isso é certo.

1034
00:47:51,060 --> 00:47:54,900
>> Mas o mais convincente, eu pensei que tinha
nos dar um pouco de provocação para segunda-feira.

1035
00:47:54,900 --> 00:47:56,430
Então nós começamos com números inteiros.

1036
00:47:56,430 --> 00:47:57,510
Nós já referido carros alegóricos.

1037
00:47:57,510 --> 00:48:00,120
Temos ainda referido duplas,
que, mais uma vez, dar-lhe números

1038
00:48:00,120 --> 00:48:01,390
após os pontos decimais.

1039
00:48:01,390 --> 00:48:04,230
>> Mas acontece que os carros alegóricos e
duplas, e, realmente, computadores,

1040
00:48:04,230 --> 00:48:08,470
fundamentalmente, não pode expressar
alguns valores precisamente.

1041
00:48:08,470 --> 00:48:12,840
Sabemos de aulas de matemática que você pode
ter qualquer número de números após o

1042
00:48:12,840 --> 00:48:13,510
ponto decimal.

1043
00:48:13,510 --> 00:48:16,460
E você ainda pode colocar uma barra vertical
para dizer que estes vão para sempre.

1044
00:48:16,460 --> 00:48:18,810
>> Infelizmente, você não pode realmente
fazer isso em um computador.

1045
00:48:18,810 --> 00:48:20,400
E assim surgem casos de canto.

1046
00:48:20,400 --> 00:48:23,120
Por exemplo, suponha que você está
fazendo algo financeira.

1047
00:48:23,120 --> 00:48:25,700
Você está fazendo matemática
com porcentagens e

1048
00:48:25,700 --> 00:48:27,030
com dólares e centavos.

1049
00:48:27,030 --> 00:48:29,230
E os centavos não
linha necessariamente up.

1050
00:48:29,230 --> 00:48:34,120
Pois bem, verifica-se que as frações de
tostões pode começar a somar quando

1051
00:48:34,120 --> 00:48:37,250
modelado com um sistema de computador
de tal forma que inteligente

1052
00:48:37,250 --> 00:48:39,100
os seres humanos podem tirar proveito.

1053
00:48:39,100 --> 00:48:42,650
>> E aqueles de vocês que ainda não viram, eu
gostaria de lhe dar um teaser de 30 segundos de

1054
00:48:42,650 --> 00:48:48,290
um filme maravilhoso, conhecido como Office Space,
que vai pintar um retrato de um

1055
00:48:48,290 --> 00:48:51,205
problema que deve enfrentar
primeira coisa que na segunda-feira.

1056
00:48:51,205 --> 00:48:53,960
Se pudéssemos aumentar o volume
um pouco, dou-lhe 30

1057
00:48:53,960 --> 00:48:55,495
segundos de espaço de escritório.

1058
00:48:55,495 --> 00:48:55,770
>> [REPRODUÇÃO]

1059
00:48:55,770 --> 00:48:59,000
>> -Quero dizer, você, você não se mostrando
e você consegue manter o seu emprego.

1060
00:48:59,000 --> 00:49:00,620
>> -Na verdade, estou sendo promovido.

1061
00:49:00,620 --> 00:49:03,240
>> -Eu poderia programar um vírus que tinha
rasgar aquele lugar fora um grande momento.

1062
00:49:03,240 --> 00:49:04,430
>> -Bem, como é que funciona?

1063
00:49:04,430 --> 00:49:06,782
>> -Toda vez que há uma transação bancária
onde o interesse é calculado, e não

1064
00:49:06,782 --> 00:49:10,160
são milhares por dia, o computador termina
com essas frações de um centavo.

1065
00:49:10,160 --> 00:49:12,030
>> -Mas eu não vou
fazer qualquer coisa ilegal.

1066
00:49:12,030 --> 00:49:12,660
>> -Ilegal?

1067
00:49:12,660 --> 00:49:15,075
Samir, este é a América.

1068
00:49:15,075 --> 00:49:16,570
>> -Temos de juro por Deus.

1069
00:49:16,570 --> 00:49:19,070
>> -Se ninguém sabe sobre isso
mas nós, certo?

1070
00:49:19,070 --> 00:49:21,920
Nenhum membro da família, sem
namoradas, ninguém.

1071
00:49:21,920 --> 00:49:22,700
>> -Claro.

1072
00:49:22,700 --> 00:49:23,320
>> -Concordo.

1073
00:49:23,320 --> 00:49:24,280
>> -Não se preocupe, cara.

1074
00:49:24,280 --> 00:49:25,640
Eu não vou contar a ninguém quer.

1075
00:49:25,640 --> 00:49:26,504
>> [FIM REPRODUÇÃO DE VÍDEO]

1076
00:49:26,504 --> 00:49:30,030
>> DAVID MALAN: Então este é, então, CS50,
que era Office Space, e tudo vai

1077
00:49:30,030 --> 00:49:31,465
fazer sentido na segunda-feira.

1078
00:49:31,465 --> 00:49:33,940
Vejo vocês depois.

1079
00:49:33,940 --> 00:49:37,880
>> Narrador: Na próxima CS50, Rob
ajusta-se estar fora do

1080
00:49:37,880 --> 00:49:39,130
Harvard plano de refeição.

1081
00:49:39,130 --> 00:49:56,160