1
00:00:00,000 --> 00:00:00,285

2
00:00:00,285 --> 00:00:03,030
>> DAVID J. MALAN: Vamos começar a escrever
algumas condições mais complexas.

3
00:00:03,030 --> 00:00:06,530
Em particular, vamos escrever um programa
que solicita ao usuário para um número inteiro,

4
00:00:06,530 --> 00:00:09,460
dizer, entre 1 e 10, e, em seguida,
faz um pouco de análise.

5
00:00:09,460 --> 00:00:14,530
Mas, desta vez do relatório se que
número é pequeno ou médio ou grande

6
00:00:14,530 --> 00:00:17,480
tamanho, desenho essas distinções
bastante arbitrária.

7
00:00:17,480 --> 00:00:21,040
>> Para fazer isso, eu vou confiar em get
int, que a função do CS50

8
00:00:21,040 --> 00:00:22,860
biblioteca que faz exatamente isso.

9
00:00:22,860 --> 00:00:24,350
E eu também vou
alavancagem de impressão f.

10
00:00:24,350 --> 00:00:28,530
Então eu vou para começar
incluindo cs50.h como

11
00:00:28,530 --> 00:00:31,880
bem como padrão io.h.

12
00:00:31,880 --> 00:00:36,460
>> E vai, em seguida, declarar principal no
maneira usual, void main int, encaracolado aberto

13
00:00:36,460 --> 00:00:38,440
cinta, perto chaveta.

14
00:00:38,440 --> 00:00:41,240
E eu estou indo, em seguida, para solicitar
o usuário para um número inteiro.

15
00:00:41,240 --> 00:00:48,340
Imprimir f, por favor me dê um
int entre 1 e 10.

16
00:00:48,340 --> 00:00:52,640
>> Agora vamos que int declarando uma
variável chamada, digamos, n e atribuindo

17
00:00:52,640 --> 00:00:55,520
que o valor de retorno de get int.

18
00:00:55,520 --> 00:00:57,300
Vamos agora fazer um pouco de análise.

19
00:00:57,300 --> 00:01:04,500
>> Se n for maior do que ou igual a 0 e
n é inferior ou igual a, por exemplo, 3,

20
00:01:04,500 --> 00:01:12,560
então nós estamos indo para ir em frente e impressão
fora que você pegou um pequeno int.

21
00:01:12,560 --> 00:01:15,730
>> Outra coisa, se o usuário escolhe, digamos,
um valor médio porte, vamos

22
00:01:15,730 --> 00:01:16,960
verifique se que as seguintes.

23
00:01:16,960 --> 00:01:23,360
Senão, se n for maior do que ou igual a,
por exemplo, 4 e n é inferior ou igual a,

24
00:01:23,360 --> 00:01:31,850
digamos, 7, então eu vou para imprimir
fora que você pegou um meio int.

25
00:01:31,850 --> 00:01:36,490
>> Finalmente, eu vou assumir que se
o valor situa-se entre 8 e 10, eles

26
00:01:36,490 --> 00:01:37,550
escolheu um grande int.

27
00:01:37,550 --> 00:01:44,140
Assim, para expressar isso, vou digitar, else if
n é maior do que ou igual a 8 e n

28
00:01:44,140 --> 00:01:53,590
é menor ou igual a 10, vá em frente
e imprimir você escolheu um grande int.

29
00:01:53,590 --> 00:01:55,720
>> Caso contrário, há uma quarta condição aqui.

30
00:01:55,720 --> 00:01:59,520
Se o usuário não cooperou e, em vez
digitado um valor que é menos do que

31
00:01:59,520 --> 00:02:04,430
0 ou maior que 10, eu quero
simplesmente bronca.

32
00:02:04,430 --> 00:02:12,490
Else imprimir, você escolheu
um int inválido.

33
00:02:12,490 --> 00:02:13,950
>> Vamos salvar o arquivo.

34
00:02:13,950 --> 00:02:17,580
Compilá-lo com fazer não-switch.

35
00:02:17,580 --> 00:02:21,650
De volta ao meu aviso, eu vou correr
com ponto barra não-switch.

36
00:02:21,650 --> 00:02:23,320
E vamos tentar alguns valores.

37
00:02:23,320 --> 00:02:26,110
>> Primeiro, vamos não cooperar
e digite negativo 1.

38
00:02:26,110 --> 00:02:30,970
Felizmente, que foi detectado pelo nosso
ramo final em que condição.

39
00:02:30,970 --> 00:02:36,530
Vamos tentar de novo com corte de ponto
não-chave, desta vez dando-lhe 1.

40
00:02:36,530 --> 00:02:37,900
Eu, na verdade pegou um pequeno int.

41
00:02:37,900 --> 00:02:43,250
>> Vamos fazê-lo novamente com o corte de ponto
não-chave, desta vez pegando, digamos, 5.

42
00:02:43,250 --> 00:02:44,590
E isso é um meio de int.

43
00:02:44,590 --> 00:02:48,200
Vamos agora fazer novamente dot
reduzir não-switch.

44
00:02:48,200 --> 00:02:52,650
E dar-lhe um valor de 10, que
é de fato um grande int.

45
00:02:52,650 --> 00:02:55,310
>> Agora vale a pena notar que este programa
poderia ter sido implementado em

46
00:02:55,310 --> 00:02:56,840
qualquer número de maneiras.

47
00:02:56,840 --> 00:03:00,160
Em primeiro lugar, foi completamente
arbitrário que eu desenhei as linhas que eu

48
00:03:00,160 --> 00:03:03,290
fez entre pequeno, médio
e grandes ints.

49
00:03:03,290 --> 00:03:05,230
Poderíamos ter tirado aqueles
limites em qualquer lugar.

50
00:03:05,230 --> 00:03:08,930
>> Mas o mais interessante, eu não tinha
expressar-me com todos estes

51
00:03:08,930 --> 00:03:13,440
maior do que ou igual a ou menos
que ou igual a sinais.

52
00:03:13,440 --> 00:03:18,880
Eu poderia ter, por exemplo, reescrito se
n é maior do que ou igual a 4 e

53
00:03:18,880 --> 00:03:24,760
n é inferior ou igual a 7, como em vez
se n for maior do que 3 e n

54
00:03:24,760 --> 00:03:29,130
é inferior a 8, em seguida, imprimir
você escolheu um meio de int.

55
00:03:29,130 --> 00:03:33,360
>> Afinal, se a entrada do usuário, por
natureza get int, é um inteiro, que

56
00:03:33,360 --> 00:03:37,580
ou pode testar se esse valor é maior
a 3 ou maior do que ou

57
00:03:37,580 --> 00:03:38,740
igual a 4.

58
00:03:38,740 --> 00:03:43,130
E poderíamos também verificar se aquele
valor inferior a 8 ou menos

59
00:03:43,130 --> 00:03:44,590
que ou igual a 7.

60
00:03:44,590 --> 00:03:45,860