Fala galera da programação, tudo beleza? Hoje um novo exercício de calculadora para aprimorar nossa lógica de programação.
Em duas situações, o programa não deverá efetuar o cálculo:
Se o operador informado pelo usuário for inválido mostrar a mensagem “Operador inválido” e encerrar a execução do programa.
Se o segundo operando for igual a 0 (zero) e o operador escolhido for a divisão (/), mostrar na tela a mensagem “Divisão por Zero!” e encerrar a execução do programa.
[table id=3 /]
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ #include <iostream> using namespace std; int main() { float num1, num2, resultado; char operador; // Solicitar entrada do usuário cout << "Digite o primeiro operando: "; cin >> num1; cout << "Digite o operador (+, -, *, /): "; cin >> operador; cout << "Digite o segundo operando: "; cin >> num2; // Verificar se o operador é válido e efetuar o cálculo switch(operador) { case '+': resultado = num1 + num2; break; case '-': resultado = num1 - num2; break; case '*': resultado = num1 * num2; break; case '/': // Verificar se o segundo operando é zero if (num2 == 0) { cout << "Divisao por Zero!" << endl; return 1; // Encerrar o programa } resultado = num1 / num2; break; default: cout << "Operador invalido" << endl; return 1; // Encerrar o programa } // Mostrar o resultado na tela cout << num1 << " " << operador << " " << num2 << " = " << resultado << endl; return 0; }
Este programa solicita que o usuário insira o primeiro operando, o operador e o segundo operando. Em seguida, verifica se o operador é válido e se o segundo operando é zero (no caso da divisão). Dependendo das condições, exibirá uma mensagem de erro apropriada ou calculará e exibirá o resultado da operação.
A estratégia utilizada neste programa foi:
Essa abordagem permite que o programa valide as entradas do usuário e forneça mensagens de erro apropriadas quando necessário, garantindo que a calculadora funcione corretamente para as operações de adição, subtração, multiplicação e divisão.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ #include int main() { float num1, num2, resultado; char operador; // Solicitar entrada do usuário printf("Digite o primeiro operando: "); scanf("%f", &num1); printf("Digite o operador (+, -, *, /): "); scanf(" %c", &operador); // Note o espaço antes do %c para ignorar espaços em branco printf("Digite o segundo operando: "); scanf("%f", &num2); // Verificar se o operador é válido e efetuar o cálculo switch(operador) { case '+': resultado = num1 + num2; break; case '-': resultado = num1 - num2; break; case '*': resultado = num1 * num2; break; case '/': // Verificar se o segundo operando é zero if (num2 == 0) { printf("Divisao por Zero!\n"); return 1; // Encerrar o programa } resultado = num1 / num2; break; default: printf("Operador invalido\n"); return 1; // Encerrar o programa } // Mostrar o resultado na tela printf("%.2f %c %.2f = %.2f\n", num1, operador, num2, resultado); return 0; }
Este programa realiza exatamente as mesmas operações que o anterior, mas utilizando as funções de entrada e saída padrão em C (scanf e printf) e a sintaxe da linguagem C.
{ Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br } program Calculadora; var num1, num2, resultado: real; operador: char; begin // Solicitar entrada do usuário writeln('Digite o primeiro operando: '); readln(num1); writeln('Digite o operador (+, -, *, /): '); readln(operador); writeln('Digite o segundo operando: '); readln(num2); // Verificar se o operador é válido e efetuar o cálculo case operador of '+': resultado := num1 + num2; '-': resultado := num1 - num2; '*': resultado := num1 * num2; '/': begin // Verificar se o segundo operando é zero if num2 = 0 then begin writeln('Divisao por Zero!'); exit; // Encerrar o programa end; resultado := num1 / num2; end; else begin writeln('Operador invalido'); exit; // Encerrar o programa end; end; // Mostrar o resultado na tela writeln(num1, ' ', operador, ' ', num2, ' = ', resultado:0:2); end.
Este código em Pascal funciona de forma muito semelhante ao código em C/C++. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.
''' Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br ''' # Solicitar entrada do usuário num1 = float(input("Digite o primeiro operando: ")) operador = input("Digite o operador (+, -, *, /): ") num2 = float(input("Digite o segundo operando: ")) # Verificar se o operador é válido e efetuar o cálculo if operador == '+': resultado = num1 + num2 elif operador == '-': resultado = num1 - num2 elif operador == '*': resultado = num1 * num2 elif operador == '/': # Verificar se o segundo operando é zero if num2 == 0: print("Divisao por Zero!") exit() # Encerrar o programa resultado = num1 / num2 else: print("Operador invalido") exit() # Encerrar o programa # Mostrar o resultado na tela print(f"{num1} {operador} {num2} = {resultado}")
Este código em Python solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ using System; class Program { static void Main(string[] args) { float num1, num2, resultado; char operador; // Solicitar entrada do usuário Console.Write("Digite o primeiro operando: "); num1 = float.Parse(Console.ReadLine()); Console.Write("Digite o operador (+, -, *, /): "); operador = char.Parse(Console.ReadLine()); Console.Write("Digite o segundo operando: "); num2 = float.Parse(Console.ReadLine()); // Verificar se o operador é válido e efetuar o cálculo switch (operador) { case '+': resultado = num1 + num2; break; case '-': resultado = num1 - num2; break; case '*': resultado = num1 * num2; break; case '/': // Verificar se o segundo operando é zero if (num2 == 0) { Console.WriteLine("Divisao por Zero!"); return; // Encerrar o programa } resultado = num1 / num2; break; default: Console.WriteLine("Operador invalido"); return; // Encerrar o programa } // Mostrar o resultado na tela Console.WriteLine($"{num1} {operador} {num2} = {resultado}"); } }
Este programa em C# funciona de maneira semelhante aos programas em C e C++, mas utiliza as funcionalidades da linguagem C#. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); float num1, num2, resultado; char operador; // Solicitar entrada do usuário System.out.print("Digite o primeiro operando: "); num1 = scanner.nextFloat(); System.out.print("Digite o operador (+, -, *, /): "); operador = scanner.next().charAt(0); System.out.print("Digite o segundo operando: "); num2 = scanner.nextFloat(); // Verificar se o operador é válido e efetuar o cálculo switch (operador) { case '+': resultado = num1 + num2; break; case '-': resultado = num1 - num2; break; case '*': resultado = num1 * num2; break; case '/': // Verificar se o segundo operando é zero if (num2 == 0) { System.out.println("Divisao por Zero!"); return; // Encerrar o programa } resultado = num1 / num2; break; default: System.out.println("Operador invalido"); return; // Encerrar o programa } // Mostrar o resultado na tela System.out.printf("%.2f %c %.2f = %.2f%n", num1, operador, num2, resultado); } }
Este programa em Java funciona de maneira semelhante aos programas em C, C++ e C#, mas utiliza as funcionalidades da linguagem Java. Ele solicita que o usuário insira os operandos e o operador, verifica se o operador é válido, realiza o cálculo correspondente e exibe o resultado. Além disso, ele lida com a divisão por zero e exibe mensagens de erro apropriadas conforme necessário.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ use std::io; fn main() { let mut num1 = String::new(); let mut num2 = String::new(); let mut operador = String::new(); // Solicitar entrada do usuário println!("Digite o primeiro operando: "); io::stdin().read_line(&mut num1).expect("Falha ao ler a linha."); let num1: f32 = num1.trim().parse().expect("Por favor, digite um número válido."); println!("Digite o operador (+, -, *, /): "); io::stdin().read_line(&mut operador).expect("Falha ao ler a linha."); let operador: char = operador.trim().chars().next().expect("Por favor, digite um operador válido."); println!("Digite o segundo operando: "); io::stdin().read_line(&mut num2).expect("Falha ao ler a linha."); let num2: f32 = num2.trim().parse().expect("Por favor, digite um número válido."); // Verificar se o operador é válido e efetuar o cálculo let resultado = match operador { '+' => num1 + num2, '-' => num1 - num2, '*' => num1 * num2, '/' => { // Verificar se o segundo operando é zero if num2 == 0.0 { println!("Divisao por Zero!"); return; // Encerrar o programa } num1 / num2 } _ => { println!("Operador invalido"); return; // Encerrar o programa } }; // Mostrar o resultado na tela println!("{:.2} {} {:.2} = {:.2}", num1, operador, num2, resultado); }
Aqui estão algumas diferenças notáveis entre Rust e as linguagens mencionadas anteriormente:
num1
, num2
e operador
. O compilador de Rust garante a segurança de memória em tempo de compilação.std::thread
e std::sync
. Embora este programa seja simples e sequencial, Rust oferece ferramentas robustas para lidar com concorrência e paralelismo de maneira segura e eficiente.Result
ou o Option
para lidar com possíveis erros de operações de I/O ou conversões de tipo, ao contrário de lançar exceções ou retornar valores especiais de erro. No programa acima, usamos expect()
para tratar erros de leitura de entrada, o que pode falhar se houver um erro de I/O, e parse()
para converter strings em números, que pode falhar se a string não for um número válido.match
para verificar o operador inserido pelo usuário. Isso oferece uma maneira concisa e segura de lidar com várias opções de maneira elegante.
/****************************************************************************** Criado pelo Professor Giovani Da Cruz https://giovanidacruz.com.br *******************************************************************************/ package main import ( "fmt" "os" ) func main() { var num1, num2 float64 var operador string // Solicitar entrada do usuário fmt.Print("Digite o primeiro operando: ") fmt.Scanln(&num1) fmt.Print("Digite o operador (+, -, *, /): ") fmt.Scanln(&operador) fmt.Print("Digite o segundo operando: ") fmt.Scanln(&num2) // Verificar se o operador é válido e efetuar o cálculo switch operador { case "+": fmt.Printf("%.2f + %.2f = %.2f\n", num1, num2, num1+num2) case "-": fmt.Printf("%.2f - %.2f = %.2f\n", num1, num2, num1-num2) case "*": fmt.Printf("%.2f * %.2f = %.2f\n", num1, num2, num1*num2) case "/": if num2 == 0 { fmt.Println("Divisao por Zero!") os.Exit(1) // Encerrar o programa } fmt.Printf("%.2f / %.2f = %.2f\n", num1, num2, num1/num2) default: fmt.Println("Operador invalido") os.Exit(1) // Encerrar o programa } }
O algoritmo solicita ao usuário que insira dois operandos e um operador. Em seguida, verifica se o operador é válido e executa a operação correspondente (adição, subtração, multiplicação ou divisão). Se o operador for divisão e o segundo operando for zero, o programa exibe uma mensagem de erro. Por fim, o resultado é exibido na tela. O programa lida com entrada e saída usando as funcionalidades específicas da linguagem utilizada e encerra a execução caso haja um operador inválido ou uma divisão por zero.
Aqui estão algumas diferenças notáveis na sintaxe e semântica entre Go e as linguagens mencionadas anteriormente:
package main
e a função main()
.main()
ou algo semelhante.import
para importar pacotes externos.fmt
e os
para entrada e saída.fmt.Scanln()
é usada para ler entrada do usuário e fmt.Printf()
para imprimir saída formatada.os.Exit()
para encerrar o programa com um código de saída específico.fmt
, que fornece funções como Printf()
para imprimir saída formatada.Essas são algumas das diferenças mais notáveis na sintaxe e semântica entre Go e as outras linguagens mencionadas.
Este exercício proporcionou uma oportunidade valiosa para praticar conceitos fundamentais de programação, como manipulação de entradas e saídas, tratamento de erros, lógica de programação e interação com o usuário. Desenvolver uma calculadora simples em C++ não apenas reforçou esses conceitos, mas também ajudou a entender a importância de validar entradas e fornecer feedback claro ao usuário. Além disso, explorar diferentes linguagens de programação, como C++, Rust, Go e outras, permitiu compreender suas peculiaridades e aprender novas abordagens para resolver problemas. No geral, este exercício foi uma excelente oportunidade para aprimorar habilidades práticas e consolidar conhecimentos teóricos.
Beleza pessoal? Espero que tenham gostado.
Dúvidas ou sugestões de outras linguagens? Deixe o seu comentário!
Um abraço e até o próximo post. Valeu!
#Programação
#C++
#DesenvolvimentoDeSoftware
#Aprendizado
#Rust
#GO
#GiovaniDaCruz
Fala galera da programação, tudo beleza? 📅💻 Explore a manipulação de datas e descubra como calcular o dia anterior em várias linguagens de programação! Aprenda algoritmos, lógica condicional e muito mais neste desafio divertido. Considerações Para facilitar, considerar que os anos bissextos são aqueles divisíveis por 4. Assim o mês 2 (fevereiro) possui 28 […]
Fala galera da programação, tudo beleza? Vamos a um novo exercício de algoritmos com desvio condicional. Desafie suas habilidades de programação com este exercício simples de cálculo de estacionamento em diversas linguagens! 🚗💻 Aprenda e pratique condicionais, entrada/saída e sintaxe em várias linguagens. Dicas para o exercício Lembrar que pode ser informado 0 no tempo […]
Fala galera da programação, tudo beleza? 💻 Novo exercício na área para aprimorar a nossa lógica de programação. Dica do exercício: Para simplificar o problema, converta cada par de valores em um único valor em minutos. 🕒 O que podemos aprender neste exercício? Neste exercício, podemos aprender várias coisas: Manipulação de Entrada/Saída: Aprendemos como […]
Fala galera da programação, tudo beleza? Novo algoritmo na área com o tema desvio condicional. Hoje vamos explorar uma variedade de linguagens de programação! 🚀 Comparando diferentes abordagens para resolver um problema simples: determinar se um número é zero, positivo ou negativo. Da sintaxe às estruturas condicionais, mergulhamos na essência de cada linguagem. O […]
Fala galera da programação, tudo beleza? Hoje vamos descubra como este simples exercício de programação em várias linguagens pode fortalecer suas habilidades de codificação! 🚀 Aprenda a calcular médias de notas e determinar a aprovação ou reprovação de alunos em C++, C, Pascal, Python, C#, Java, Rust e Go. O que podemos aprender neste […]
Fala galera da programação, tudo beleza? O exercício pede para verificar se o número lido possui determinada característica. Ela é conhecida como “Número Kaprekar”. Um número de Kaprekar é um inteiro positivo cuja representação em quadrados de seus dígitos pode ser dividida em duas partes que somam o número original quando somadas. O exemplo […]
Fala galera da programação, tudo beleza? Lá vamos nós a mais um interessante exercício. Dados do Exercício Formulas Para Homens: ( 72.7 * altura ) – 58 Para Mulheres: ( 62.1 * altura) – 44.7 Mais dicas A altura da pessoa é um valor real. O sexo da pessoa deverá ser identificado através […]
Fala galera da programação, tudo beleza? Vamos a um novo exercício para aprimorarmos nossas habilidades. Aqui existem dados importantes para podermos realizar a tarefa. Dados do exercício Tabela de códigos: código = 1: multiplicar os três valores código = 2: somar os três valores código = 3: subtrair os três valores código = 4: […]
Fala galera da programação, tudo beleza? Quer aprimorar suas habilidades com estruturas condicionais? Explore este desafio de aprendizado de if-else. O que podemos aprender neste exercício? Neste exercício, aprendemos a: Solicitar entrada do usuário: Aprendemos a solicitar entrada do usuário para obter informações necessárias para o programa, como a idade do nadador. Isso é útil […]
Fala galera da programação, tudo beleza? Hoje vamos montar nossas calculadoras! Acredito que seja um dos exercícios mais realizados entre os iniciantes. O desafio será encapsular as operações aritméticas em funções. O que vamos aprender neste exercício? Neste exercício, vamos aprender sobre: Funções em Programação: Vamos explorar como dividir nosso código em funções. As […]