1
00:00:00,000 --> 00:00:00,440

2
00:00:00,440 --> 00:00:03,440
>> COLUNA 1: A última vez que analisou
inteiros, lembre-se que usamos alguns

3
00:00:03,440 --> 00:00:07,810
Expressões booleanas para verificar se um usuário
entrada n estava entre os números

4
00:00:07,810 --> 00:00:11,580
como 0 e 3, 4 e 7, e 8 e 10.

5
00:00:11,580 --> 00:00:14,990
Bem, nós fizemos isso utilizando se de outra pessoa e
se de, mas acontece que você pode

6
00:00:14,990 --> 00:00:17,990
implementar essa mesma lógica usando um
diferente construção de programação

7
00:00:17,990 --> 00:00:21,400
completamente enquanto ainda alcançar
precisamente o mesmo resultado.

8
00:00:21,400 --> 00:00:25,000
Na verdade, pode-se introduzir algo
chamado uma chave que nos permite

9
00:00:25,000 --> 00:00:28,660
mudar o nosso comportamento, dependendo
o valor de alguma variável.

10
00:00:28,660 --> 00:00:29,840
>> Vamos tentar dar um presente.

11
00:00:29,840 --> 00:00:35,730
Para fazer isso, eu vou primeiro a incluir
a biblioteca CS50 por meio de cs50.h.

12
00:00:35,730 --> 00:00:39,960
Eu também estou indo para incluir o padrão
biblioteca por meio de padrão I / O.h.

13
00:00:39,960 --> 00:00:44,540
E eu vou declarar principal
da maneira usual, int void main.

14
00:00:44,540 --> 00:00:45,650
Abra chaveta.

15
00:00:45,650 --> 00:00:47,100
Feche chaveta.

16
00:00:47,100 --> 00:00:49,720
E agora eu vou pedir para o
usuário para um número inteiro.

17
00:00:49,720 --> 00:00:56,990
>> Printf, dá-me um int
entre 1 e 10.

18
00:00:56,990 --> 00:00:59,310
E agora eu estou indo para obter
que int usando o CS50

19
00:00:59,310 --> 00:01:01,590
bibliotecas de funções, GetInt.

20
00:01:01,590 --> 00:01:06,140
Int, vamos chamá-lo n, é igual GetInt.

21
00:01:06,140 --> 00:01:08,500
E agora eu vou fazer um pouco
de análise em que inteiro.

22
00:01:08,500 --> 00:01:13,120
Um tanto arbitrariamente, mas com esse
nova construção conhecido como um interruptor.

23
00:01:13,120 --> 00:01:16,530
Ligue o valor de n, como se segue.

24
00:01:16,530 --> 00:01:23,240
>> No caso em que n igual a 1, ou, no
caso em que n igual a 2, ou no caso

25
00:01:23,240 --> 00:01:28,150
que n é igual a 3, vá em frente e
executar esta linha de código.

26
00:01:28,150 --> 00:01:34,480
Printf que você pegou um pequeno int, quebrar.

27
00:01:34,480 --> 00:01:37,610
Agora, eu preciso para implementar o equivalente
de um ELT simples por

28
00:01:37,610 --> 00:01:40,990
enumerando alguns casos adicionais.

29
00:01:40,990 --> 00:01:47,180
>> No caso em que n é igual a 4, ou na
caso em que n é igual a 5, ou, no caso

30
00:01:47,180 --> 00:01:53,830
que n é igual a 6, ou no caso em que n
é igual a 7, vá em frente e imprimir você

31
00:01:53,830 --> 00:01:58,000
escolheu um Int médio.

32
00:01:58,000 --> 00:01:59,490
Quebre.

33
00:01:59,490 --> 00:02:02,300
Agora, no caso o usuário escolhido
um número grande, vamos

34
00:02:02,300 --> 00:02:04,940
detectar que, como se segue.

35
00:02:04,940 --> 00:02:08,900
>> No caso em que o utilizador escolheu oito
ou no caso em que o utilizador escolher

36
00:02:08,900 --> 00:02:14,110
nove, ou no caso em que o utilizador escolher
10, vá em frente e imprimir você

37
00:02:14,110 --> 00:02:17,830
escolheu um grande Int.

38
00:02:17,830 --> 00:02:19,180
Quebre.

39
00:02:19,180 --> 00:02:23,970
ELT, se um usuário não escolher um número
que cai em qualquer um destes 10 casos,

40
00:02:23,970 --> 00:02:25,520
vamos ter algum comportamento padrão.

41
00:02:25,520 --> 00:02:27,870
Que neste caso será a seguinte.

42
00:02:27,870 --> 00:02:32,860
>> Padrão, printf, você escolheu
um Int inválido.

43
00:02:32,860 --> 00:02:36,100

44
00:02:36,100 --> 00:02:38,220
Quebre.

45
00:02:38,220 --> 00:02:42,870
Agora, se eu salvar esse arquivo de compilação
que com fazer switch.

46
00:02:42,870 --> 00:02:44,870
Executá-lo com chave de barra..

47
00:02:44,870 --> 00:02:46,770
Vamos fazer algumas checagens.

48
00:02:46,770 --> 00:02:48,440
Eu vou pegar um Int de 1.

49
00:02:48,440 --> 00:02:50,110
E ID pegou um pequeno int.

50
00:02:50,110 --> 00:02:52,240
>> Vamos agora fazer. Cortar switch.

51
00:02:52,240 --> 00:02:54,514
E digitar digamos, negativo 1.

52
00:02:54,514 --> 00:02:56,900
E ID pegou um int inválido.

53
00:02:56,900 --> 00:02:59,560
No final do dia, o interruptor
construção não permite que você faça

54
00:02:59,560 --> 00:03:03,320
qualquer coisa que você não poderia fazer já
com o mais familiar se, else if,

55
00:03:03,320 --> 00:03:04,530
mais construir.

56
00:03:04,530 --> 00:03:07,470
Mas se você tem uma lista finita de valores
que você está verificando, um

57
00:03:07,470 --> 00:03:09,820
instrução switch pode muito
bem tornar o código mais

58
00:03:09,820 --> 00:03:11,310
explícito, ou mais legível.

59
00:03:11,310 --> 00:03:12,910