00:00:00
Bom,
00:00:01
pessoal, vou ensinar para vocês o
00:00:03
comando sutch.
00:00:14
Bom, esse cômodo aqui ele é uma
00:00:19
simplificação, vamos dizer assim,
00:00:21
do if com if encadeado, if um if dentro
00:00:26
do outro, só que ele ele trata dados
00:00:30
equalitários, ou seja, isso igual a
00:00:32
isso, igual a isso, igual a aquilo, não
00:00:33
tem maior, menor, igual ou diferente.
00:00:37
Então, por exemplo, vejam esse programa
00:00:43
aqui. Vou criar uma variável tiar e vou
00:00:46
dar o nome para ela de
00:00:48
cara. Print
00:00:51
f de um
00:00:55
caracter. Se eu usar o scan
00:00:59
f, eu vou usar o recurso de porcento
00:01:03
C e comercial.
00:01:07
A variável. Só vamos testar
00:01:11
aqui. Compilou. Vou mandar
00:01:14
rodar. Tá pedindo um caracter e já era.
00:01:18
Muito
00:01:20
bem. Prosseguindo. Como que funciona o
00:01:23
sutch? Lembrando que a linguagem C é é
00:01:26
linguagem derivada para muitas
00:01:28
linguagens, por exemplo,
00:01:30
C#ARP, Java, JavaScript. Então esse
00:01:33
comando aqui também funciona nessas
00:01:35
linguagens com algumas pequenas
00:01:37
diferenças, tá bom? Então faço o
00:01:39
seguinte, sutch, qual o caracter que eu
00:01:42
quero, qual é a variável que eu quero
00:01:45
comparar? Por
00:01:47
exemplo, eu quero comparar essa
00:01:49
variável.
00:01:51
Então eu faço um
00:01:54
bloco e pergunto
00:01:58
case, por exemplo,
00:02:02
a vai acontecer o quê? Vou mandar uma
00:02:04
mensagem na tela.
00:02:08
Pf
00:02:10
vogal
00:02:15
case B. Eu vou colocar, por
00:02:20
exemplo,
00:02:24
consoante
00:02:26
case
00:02:28
C, a mesma
00:02:33
coisa.
00:02:35
Case
00:02:43
de Só vou colocar cinco caracteres,
00:02:46
cinco letras. Só para vocês verem
00:02:49
o
00:02:56
contexto. Então
00:02:58
aqui eu vou mudar a
00:03:01
frase.
00:03:05
Digite uma letra
00:03:09
entre a E.
00:03:13
E dependendo da letra que for
00:03:16
apresentar, da letra digitada, ele vai
00:03:18
apresentar uma mensagem. Por
00:03:20
exemplo, se for E a são vogais, se for
00:03:23
B, C, D, são
00:03:26
consoantes.
00:03:29
Legal. Vamos
00:03:31
compilar. Acostumado com Python que
00:03:34
aceita qualquer aspas simples ou duplas.
00:03:38
Vamos lá.
00:03:41
Ele tá pedindo paraar um caracter. Se eu
00:03:42
digitar o
00:03:44
a, olha que ele apresentou. Vogal,
00:03:46
consoante, consoante, consoante, vogal,
00:03:48
vogal,
00:03:50
vogal. Eu vou colocar um barra n para
00:03:53
ficar mais
00:03:54
claro a
00:03:56
explicação. Barra N barra
00:04:01
n barra
00:04:03
n barra
00:04:05
n e barra n.
00:04:09
De
00:04:11
novo, eu vou digitar o A. Olha o que
00:04:15
apresentou. Vogal consoante. Consoante.
00:04:17
Vou explicar o
00:04:20
porquê. Antes só mais um teste. Se eu
00:04:23
digitar
00:04:25
C, ele só exibiu o consoante consoante
00:04:27
vogal. O que que ele tá entendendo? A
00:04:30
partir do momento que ele encontra, ele
00:04:33
exibe todos. Por exemplo, se onde está a
00:04:36
compare o caracter. É a, se for verdade,
00:04:39
ele executa todos os comandos,
00:04:41
independentemente de qual letra seja.
00:04:44
Então, como nós fazemos para resolver
00:04:46
isso? Usamos o break. Que que o brake
00:04:49
faz? Ele força a
00:04:52
saída da estrutura, neste caso, a
00:04:55
estrutura suitch.
00:04:58
Então, cada
00:05:01
caracter que eu digitar, ele compara,
00:05:05
vai entrar em um
00:05:07
deles e agora vai dar o break. Por
00:05:13
exemplo, se eu digitar o A, apareceu
00:05:16
vogal. Agora tá certo. É o A, verdade.
00:05:20
Exiba a vogal e saia. Saiu, pulou tudo.
00:05:24
Tranquilo. Muito bem.
00:05:28
Eh, então para este exemplo, eu quero
00:05:31
que vocês façam um
00:05:34
exercício antes. Só deixa eu explicar
00:05:36
uma coisinha.
00:05:37
Esqueci. Vamos ver. E se por acaso eu
00:05:41
dititar um um letra que seja fora desse
00:05:43
range aí? Se eu colocar R, por exemplo,
00:05:46
vejam que não aconteceu nada porque eu
00:05:47
não previ isso. Mas o que que eu posso
00:05:51
fazer? Eu posso aqui
00:05:55
usar o
00:05:58
default, OK? Que que é o default? Seria
00:06:00
um else. Se não cair nenhum dos
00:06:02
anteriores, cai aqui. Então dou uma
00:06:04
mensagem. Print
00:06:07
F. O quê?
00:06:10
Letra fora
00:06:12
do
00:06:16
intervalo.
00:06:17
Tranquilo? Então vamos ver.
00:06:20
Se eu mandar executar
00:06:22
novamente, faltou o
00:06:24
ponto se eu mandar executar novamente,
00:06:27
se eu está R agora, ele aparece letra
00:06:30
fora do intervalo. Então ele só trata
00:06:32
estas letras. Então, para este programa,
00:06:36
eu quero que vocês façam o
00:06:40
exercício. Dada uma
00:06:45
letra, exibir uma das
00:06:50
seguintes
00:06:54
mensagens. Quais são as
00:06:56
mensagens?
00:06:59
Vogal maiúscula.
00:07:02
A outra
00:07:03
mensagem
00:07:06
vogal
00:07:08
minúscula, consoante
00:07:12
maiúscula e
00:07:15
consoante
00:07:18
minúscula. Então, eu quero que vocês
00:07:20
tentem fazer esse exercício aqui. Será
00:07:22
que eu tenho que fazer um case para cada
00:07:24
letra? Será que teria um jeito mais
00:07:25
fácil? Hum, não sei. Você que vai ter
00:07:28
que
00:07:29
descobrir. OK. Então, quero que vocês
00:07:31
façam este
00:07:36
exercício. Eu vou criar aqui um novo
00:07:39
arquivo para poder dar um segundo
00:07:41
exemplo para
00:07:43
vocês. Bom, nós vimos o sutch tratando
00:07:46
caracteres. E como o sutch trataria, por
00:07:49
exemplo, números. Vamos ver.
00:07:58
dia. Então, o que que eu quero fazer
00:08:00
nesse programa aqui? Eu quero que o
00:08:01
usuário digite um dia e eu mostre a
00:08:04
semana. Se car tá dois, segunda-feira,
00:08:07
se caso tá um, domingo, se car tá c
00:08:09
quinta-feira. OK? Então vamos
00:08:13
lá.
00:08:14
Eu vou mandar o cara
00:08:17
exibir, perdão, mandar o programa
00:08:23
exibir. Deixa eu
00:08:27
número scan
00:08:31
f por d porque eu estou lendo um valor
00:08:36
decimal e comercial dia, que foi a
00:08:39
variável que eu criei ali em cima.
00:08:41
Então, como vai funcionar o sutch agora?
00:08:46
Suitch
00:08:49
dia. Bom, quem eu tô compando? Eu tô
00:08:53
compando o dia. Tranquilo? Então, se eu
00:08:57
colocar
00:08:59
case um, vejam que agora não está entre
00:09:03
apóstfo, porque não é um caracter, isso
00:09:05
é um número. Case
00:09:09
1, print F.
00:09:12
domingo.
00:09:14
OK. Ponto e vírgula. Aí eu
00:09:17
coloco o break. Eu poderia ter mais
00:09:20
comandos dentro do case um, mas nesse
00:09:22
exercício não é necessário. Então vou
00:09:25
copiar isso daqui e
00:09:29
fazê-lo seis vezes. Se for o dois, eu
00:09:33
sei que
00:09:34
é segunda feira.
00:09:38
Se for o três, eu sei que é
00:09:41
terça-feira. Se for o
00:09:43
quatro, eu sei que
00:09:46
é quarta feira. Se for o cinco,
00:09:53
quinta-feira. Se for o seis, eu sei que
00:09:56
é
00:09:58
sexta feira.
00:10:02
Se for o sete, eu sei que é
00:10:07
sábado.
00:10:09
Tranquilo? Então vamos executar isso
00:10:11
daqui.
00:10:12
Executei. Ele pede para salvar. Vou dar
00:10:15
o nome de sutch
00:10:17
2.
00:10:21
Legal. Faltou o ponto e vírgula em
00:10:23
todos. Ponto e vírgula. Ponto e
00:10:27
vírgula para todos.
00:10:30
Mandei
00:10:32
executar. Então, qualquer número que eu
00:10:34
vier a digitar, por exemplo, quatro,
00:10:37
apareceu
00:10:41
quarta-feira. Se eu
00:10:44
digitar um, apareceu
00:10:47
domingo. E se eu digitar um número não
00:10:49
previsto, por exemplo, o número 10, não
00:10:52
acontece nada. Por quê? Porque eu não
00:10:54
coloquei o
00:10:57
default. Default.
00:10:59
Ou seja, se não cair em nenhum desses
00:11:01
números,
00:11:03
print print F, dia
00:11:08
inválido,
00:11:10
OK? Ponto e vírgula. Não precisa colocar
00:11:12
break aqui porque eu já tô no final
00:11:14
mesmo, tá? Então só não esqueçam de
00:11:16
fechar adequadamente a estrutura, tá
00:11:19
bom?
00:11:20
de
00:11:21
novo, se eu está agora o número
00:11:25
23, aí aparece de
00:11:28
inválido. Então, para este exemplo, eu
00:11:31
quero que vocês façam o seguinte
00:11:33
exercício. O exercício
00:11:36
dois, dado o dia da
00:11:41
semana ou
00:11:43
desculpa, dado um número,
00:11:47
vírgula, exibir o
00:11:51
mês
00:11:54
correspondente.
00:11:56
Correspondente. Por exemplo, se o cara
00:12:01
digitar, pedir o mês pr ele, se o cara
00:12:03
digitar quatro, vai
00:12:06
aparecer abriu e assim para todos os
00:12:09
meses, do 1 ao 12. Bem facinho esse
00:12:12
aqui. E lembre-se colocar o def caso a
00:12:14
pessoa digite um número diferente de 1 a
00:12:17
12. Tranquilo?
00:12:21
Ótimo. Então vamos para a terceira
00:12:27
situação. Criar um novo
00:12:30
arquivo. Muito
00:12:33
bem. Qual a outra variação que eu posso
00:12:36
usar com o comando
00:12:38
sutch?
00:12:41
Vejam, eu poderia fazer assim.
00:12:44
dia é
00:12:46
igual,
00:12:48
desculpa,
00:12:49
in. Vou colocar número, vai para não
00:12:52
ficar genérico. Eu pego um
00:12:56
número
00:13:00
sut não tem que ler o número, né?
00:13:04
print
00:13:07
f git um
00:13:11
número. Aí eu falo pro
00:13:14
usuário digitar esse número scan
00:13:20
f por
00:13:24
d e
00:13:25
comercial
00:13:27
número.
00:13:29
Tranquilo? Muito bem. Eu poderia fazer
00:13:34
assim, eu vou usar eh algo hipotético
00:13:37
agora, sem nenhum sentido, OK? Só para o
00:13:41
exercício vocês fazerem de forma
00:13:43
mais
00:13:47
tranquila. Case 10, por
00:13:50
exemplo, que que eu vou fazer?
00:13:53
Print
00:13:55
F
00:13:56
digitou 10,
00:13:59
case 20 print F digitou
00:14:05
20.
00:14:07
OK. Só mais dois aqui para vocês
00:14:09
entenderem onde eu quero chegar. Não
00:14:12
posso esquecer do ponto de
00:14:16
vírgula e o do break ponto de vírgula.
00:14:19
OK.
00:14:21
Posso colocar aqui
00:14:25
30
00:14:27
40 digitou 30 digitou 40. Até até aqui
00:14:32
nenhuma novidade para vocês. É igual o
00:14:34
exemplo
00:14:35
anterior.
00:14:37
Default
00:14:39
printf dia não
00:14:42
previsto ou dia
00:14:44
não, número não
00:14:48
previsto. Vocês podem ver que a execução
00:14:50
aqui não vai ter nada de
00:14:52
novidade. Ele pede para salvar. Vou
00:14:55
salvar como sutch
00:15:02
3. Então ele executa. Se eu colocar 20,
00:15:06
ou seja, estou 20, nenhuma novidade por
00:15:08
enquanto. Mas olha o que eu consigo
00:15:09
fazer
00:15:12
aqui. Aqui, ao invés de uma variável, eu
00:15:15
posso colocar uma sentença que exulte um
00:15:17
valor inteiro. Então, se eu colocar
00:15:19
número mais 10, o número que eu digitar,
00:15:21
ele vai somar 10 e vai permitir que seja
00:15:25
exibido estes, OK? Por exemplo, suitch
00:15:29
número + 10. Se eu 10 agora, ele vai
00:15:33
comparar o quê? 10 + 10 e vai dar
00:15:36
20. OK? Se eu
00:15:39
digitar
00:15:41
20, que que vai acontecer? Exibiu 30.
00:15:44
Então é possível fazer alguma conta aqui
00:15:46
o resultado dessa conta que é comparado
00:15:49
aqui, tá bom?
00:15:52
Então isso aí é para abrir um pouquinho
00:15:53
a mente de vocês. Então para tal, vamos
00:15:56
fazer o seguinte
00:15:58
exercício.
00:16:00
Dados
00:16:02
exercício, dados
00:16:05
os quatro dígitos de
00:16:10
uma
00:16:12
placa antiga de carro.
00:16:18
exibir o dia do
00:16:22
rodízio. Por
00:16:25
exemplo, se eu fizer isso daqui, ó,
00:16:28
vamos supor que que seja o programa
00:16:30
funcionando, tá bom? Pede pro cara
00:16:34
digitar os dígitos, por exemplo. Aí o
00:16:37
cara
00:16:38
digita 5 4 3 2. Só os dígitos. É em uma
00:16:43
variável só, tá? Aí vai exibir o que na
00:16:45
tela? Eu quero que exiba 1
00:16:49
2
00:16:53
rodízio de
00:16:56
segunda-feira, ou seja, o seu programa
00:16:58
vai descobrir qual o dia do
00:17:00
rodízio, tá? Então, a partir de uma
00:17:02
variável inteira que foi digitada com
00:17:05
quatro dígitos, eu quero descobrir o dia
00:17:08
do rodíziel apenas para
00:17:11
conhecimento finais.
00:17:14
Um e
00:17:16
do é segunda, o
00:17:19
rodízio. 3 e
00:17:22
4 é o
00:17:25
quê? Terça, o
00:17:28
rodízio.
00:17:30
5 e
00:17:32
6 é
00:17:36
quarta.
00:17:37
7 e 8 é o
00:17:41
quê? Quinta.
00:17:44
9 e
00:17:48
é
00:17:50
sexta. Esses são os finais, tá? Então o
00:17:53
que que você vai ter que
00:17:55
fazer? Ah, professor, tem que fazer um
00:17:57
case do 00 até o 9999. Se fizer isso aí,
00:18:01
tudo bem. Mas pense, eu vou colocar aqui
00:18:05
uma
00:18:06
observação. Com um
00:18:12
cálculo, eu
00:18:14
consigo
00:18:17
descobrir o último
00:18:20
dígito de um
00:18:24
número. Então, não importa o número que
00:18:26
a pessoa digite. Se eu fizer um cálculo,
00:18:28
pode ser parecido com esse. Vou fazer um
00:18:29
cálculo aqui, ó. Não sei qual. que eu
00:18:32
vou conseguir descobrir qual que é o dia
00:18:34
do
00:18:36
rodízio. Entenderam?
00:18:39
Salvar. Agora vamos pro próximo, pra
00:18:41
próxima
00:18:43
brincadeira. Copiar aqui. Vou criar um
00:18:47
novo
00:18:48
arquivo. E se eu quiser fazer uma
00:18:49
calculadora, por
00:18:51
exemplo,
00:18:53
flu número
00:18:55
um, número dois, ponto e vírgula.
00:19:00
Charar
00:19:01
sinal ponto e
00:19:03
vírgula. Então eu falo o seguinte, meu
00:19:06
cara, print
00:19:09
fite dois
00:19:12
valores. Então o vídeo pro cara está o
00:19:14
quê?
00:19:16
Eh, scan
00:19:20
f. Eu posso digitar dessa forma aqui,
00:19:24
ó. Cadê? Por F. Por F.
00:19:30
vírgula e
00:19:33
comercial número um,
00:19:37
vírgula e
00:19:39
comercial número
00:19:42
do. Ele entende isso, tá? Então, veja,
00:19:46
se eu mandar executar isso daqui, ó,
00:19:48
deixa eu só fechar
00:19:50
aqui. Se eu mandar
00:19:52
executar, vai pedir para salvar. Vou
00:19:55
salvar como
00:19:56
sut. Muito bem.
00:19:59
Só veio com switch 4. Ele entende, ó. Se
00:20:02
eu estar dois valores, ele leu
00:20:05
tranquilo. Fechou? Então eu consigo ler
00:20:07
dois valores assim. Agora eu vou pedir
00:20:10
pro cara digitar um sinal. Vou pedir pro
00:20:12
usuário digitar o quê? Um sinal. Sinal.
00:20:15
Eu vou até colocar aqui entre parênteses
00:20:17
o sinal que eu quero que eu digite, ou é
00:20:19
o sinal de mais ou o sinal de menos ou
00:20:24
multiplicação
00:20:25
ou
00:20:27
divisão. Tranquilo? E aqui eu coloco o
00:20:30
quê? Por
00:20:32
C. Aí eu coloco aqui a variável sinal.
00:20:36
Eu só vou fazer um teste
00:20:39
porque quase todas as versões não
00:20:42
aceitam isso. Então, fazer um teste aqui
00:20:45
só para ver se vai funcionar para não
00:20:47
ter um um problema no final. Eh, print
00:20:51
f. Eu vou mandar exibir todas essas
00:20:53
variáveis aí que eu acabei de digitar,
00:20:58
OK?
00:20:59
Por F, por C,
00:21:04
por F.
00:21:07
Só quero exibir as variáveis. Vou
00:21:09
exibir num
00:21:11
um, no
00:21:15
ô, no dois não, tá na ordem
00:21:17
sinal
00:21:19
e num
00:21:21
2. Eu só quero resolver o problema não
00:21:23
funcione aqui. Vamos lá. Salvei, mandei
00:21:27
rodar.
00:21:30
tá pedindo dois valores, por exemplo,
00:21:32
4 5.
00:21:35
Ó, vocês podem ver que ele não permite
00:21:36
que você digite o sinal. Eu vou explicar
00:21:39
o porquê. Não vou explicar, na verdade,
00:21:41
só vou dar uma dica, tá? Porque como é
00:21:43
um caracter, se eu digitasse, por
00:21:45
exemplo, o sinal de mais e apertasse o
00:21:50
enter, o que aconteceu? Ele entendeu que
00:21:54
o enter que eu digitei na variável de
00:21:57
cima foi jogado dentro do sinal e ele
00:22:00
nem leu. Então o scan f ele é falho para
00:22:03
ler caracter. Então vamos resolver esse
00:22:05
problema
00:22:07
aqui.
00:22:10
Eh,
00:22:12
sinal é
00:22:14
igual
00:22:16
getar. Isso aqui é uma funçãozinha que
00:22:19
lê um
00:22:20
caracter apertar o enter, tá bom? Vamos
00:22:23
ver se vai funcionar. Eu creio que não
00:22:24
vai funcionar ainda. Vamos ver se
00:22:26
funcionou. 4 5 e um caracter
00:22:31
sinal de novo. Desculpa que eu não vi o
00:22:34
que aconteceu. 4
00:22:37
5 Ele ainda não leu. E se eu colocar get
00:22:40
ch? Vamos ver.
00:22:43
Rodei. Ele tá dizendo aqui que ele não
00:22:46
conhece esse
00:22:48
comando.
00:22:50
Certo. Vou fazer um uma pesquisa aqui
00:22:52
para vocês verem.
00:22:56
Biblioteca. Get char.
00:22:59
Biblioteca para
00:23:02
ler. Ficar
00:23:03
aqui. Get
00:23:06
char.
00:23:08
Linguagem C. Então vamos ver.
00:23:12
Eh, vou colocar o Google aqui.
00:23:17
Biblioteca
00:23:19
para o
00:23:23
getar em
00:23:26
C. Tá vendo essa biblioteca aqui, ó?
00:23:30
SD io. Já tá aqui. Beleza. Então, vou
00:23:35
fazer outra pesquisa.
00:23:40
Biblioteca para GE get
00:23:43
ch em
00:23:46
C. Acho que é o
00:23:48
conio. Então vamos incluir ela
00:23:51
aqui.
00:23:52
Cono. Então agora eu creio que vai
00:23:54
funcionar essa função. Vamos ver. Mandei
00:23:58
executar. Pediu dois
00:24:01
valores. Agora tá esperando o caracter.
00:24:03
Tá vendo, ó? Eu vou editar agora o sinal
00:24:05
de mais.
00:24:07
Aí ele entendeu, ó, 4 + 4. Então,
00:24:09
beleza, agora tá funcionando. Então,
00:24:12
agora vamos fazer um uma
00:24:15
calculadora sutch sinal, porque depende
00:24:18
do sinal, é uma
00:24:20
conta,
00:24:22
beleza?
00:24:24
Case mais quer dizer o quê? Que a pessoa
00:24:28
quer fazer uma
00:24:30
conta, que é uma variável que eu vou
00:24:32
criar aqui em cima, ó.
00:24:36
é
00:24:37
igual num 1 + num 2 ponto e vírgula.
00:24:43
Muito
00:24:45
bem, já vou colocar break
00:24:47
aqui.
00:24:51
Acabou. Case. E se for
00:24:55
menos, pessoal, no caso de caracter, tem
00:24:57
que colocar entre apóstrofo, tá? Não
00:24:58
pode colocar entre aspas.
00:25:02
Cuidado. Aspas em C para
00:25:05
string. Caracter tipo apósfo é para
00:25:09
caracter. Então no 1
00:25:13
men do Então se a pessoa digitou o sinal
00:25:16
de menos, vai cair nessa
00:25:19
conta brick. para agilizar o processo.
00:25:23
Deixa eu copiar e colar isso
00:25:26
aqui. E se a pessoa digitou
00:25:30
asterisco, ela vai fazer qual
00:25:34
conta?
00:25:37
Multiplicação. E se a pessoa digitou
00:25:41
barra, qual conta que ela vai
00:25:43
fazer? A divisão. Eu posso colocar aqui
00:25:48
default, uma mensagem.
00:25:52
Print
00:25:55
F.
00:25:57
Operação
00:25:59
não
00:26:02
prevista. Ponto e vírgula. Eu tô
00:26:04
colocando sem acento, pessoal, que tem
00:26:05
que colocar uma outra biblioteca para
00:26:06
aceitar assento e não é aula para hoje,
00:26:09
tá bom? Aí o que que vai acontecer?
00:26:12
Quando sair dessa estrutura, eu mando
00:26:14
exibir print F. Eu vou colocar bonitinho
00:26:18
aqui, ó.
00:26:20
por
00:26:21
F por C por F é igual a por
00:26:29
F. Primeiro porcento F é referente ao N
00:26:34
1, segundo ao N 2. Não, não. O segundo é
00:26:39
é o sinal sinal. O terceiro é o Num 2 e
00:26:44
o quarto é a variável. Então ele vai
00:26:48
mostrar bonitinho a tá aqui. Quer ver?
00:26:49
Ó, mandando executar dois valores
00:26:54
34 e
00:26:56
21. Qual o sinal que eu
00:26:59
quero?
00:27:00
Mais. Então, vejam, ele exibiu aqui 34 +
00:27:04
21 = 55. Eu só vou melhorar a
00:27:07
apresentação aqui, tá? Eu vou colocar
00:27:09
2/n para pular a linha aqui para ficar
00:27:11
bem evidente a conta. Então vamos de
00:27:14
novo. Dois valores 33
00:27:20
56. Qual o sinal?
00:27:23
Menos 33 - 56 =
00:27:27
-23. OK? Então não importa qual a conta
00:27:31
ele vai fazer.
00:27:35
Tranquilo? Então vejam
00:27:38
só o que eu quero que vocês façam. como
00:27:43
exercício para este
00:27:45
exemplo.
00:27:47
Exercício
00:27:49
fazer a
00:27:53
versão 2.0
00:27:55
desta
00:27:59
calculadora. Beleza? O que seria essa
00:28:02
versão 2.0?
00:28:08
Caiu aqui
00:28:10
meu minha o
00:28:13
webcam. Bom, desculpa aí, pessoal. Vamos
00:28:16
lá. O que que faz a versão 2.0? Vejam um
00:28:20
problema que eu quero que vocês
00:28:21
resolvam.
00:28:24
O
00:28:25
usuário ele não tem obrigação de saber
00:28:28
que o
00:28:29
asterisco ele é multiplicação. E se o
00:28:31
cara quiser digitar, por exemplo,
00:28:34
xizinho de multiplicação, apareceu o
00:28:36
quê? Operação não prevista. Então o que
00:28:40
que você vai melhorar?
00:28:43
Aceitar
00:28:45
asterisco
00:28:47
xizinho xizão ou pontinho
00:28:51
para para
00:28:53
multiplicação. OK? Muito bem. Qual é o
00:28:56
outro problema?
00:28:59
Só executar essa calculadora aqui dois
00:29:02
valores 4 2 e
00:29:07
divisão. Desculpa, foi muito
00:29:12
rápido. 4 2 e a divisão. Ele fez a
00:29:17
conta, dividiu. Até aí tudo bem.
00:29:20
Porém, e se eu dividir por zero,
00:29:25
ó, 4 0
00:29:29
dividido. Pode ver que isso aqui é um
00:29:31
erro. Ele não entendeu a divisão por
00:29:33
zero, então deu um pau no meu programa.
00:29:36
Então eu quero que vocês verifiquem o
00:29:39
quê? Não permitir divisão por zero.
00:29:45
Ok? Então aqui dentro desse case você
00:29:47
vai ter que fazer alguma coisa. Eu só
00:29:49
vou dividir se o segundo número não for
00:29:51
zero. Agora, se for zero, eu vou dar uma
00:29:52
mensagem, ó, não existe divisão por
00:29:56
zero. Então é isso aí que eu quero que
00:29:58
vocês façam, tudo bem? Então esses
00:30:01
exercícios valerão
00:30:05
nota, beleza? Então, por gentileza,
00:30:10
façam os exercícios. M.
