Exercício: calculadora de quatro operações
Fala galera da programação, tudo beleza? Hoje um novo exercício de calculadora para aprimorar nossa lógica de programação.
Dicas do exercício
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 /]
Exemplo em C++
/******************************************************************************
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:
- Solicitar ao usuário que forneça o primeiro operando, o operador e o segundo operando.
- Utilizar um switch-case para verificar o operador inserido pelo usuário e executar a operação correspondente.
- Se o operador for inválido (ou seja, diferente de ‘+’, ‘-‘, ‘*’, ‘/’), exibir a mensagem “Operador inválido” e encerrar a execução do programa.
- Se o operador for ‘/’, verificar se o segundo operando é zero. Se for zero, exibir a mensagem “Divisão por Zero!” e encerrar a execução do programa.
- Calcular o resultado da operação e exibi-lo na tela.
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.
Exemplo em C
/******************************************************************************
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.
Exemplo em Pascal / Delphi / Lazarus
{
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.
Exemplo Python
'''
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.
Exemplo C# / C Sharp
/******************************************************************************
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.
Exemplo em Java
/******************************************************************************
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.
Exemplo em Rust
/******************************************************************************
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:
- Segurança e gerenciamento de memória: Rust é conhecido por seu sistema de tipos seguro e por evitar erros de memória, como referências nulas e vazamentos de memória, por meio de seu sistema de propriedade e regras de empréstimo. Neste programa, não há necessidade de gerenciar explicitamente a alocação e liberação de memória para variáveis de string, como
num1,num2eoperador. O compilador de Rust garante a segurança de memória em tempo de compilação. - Padrões de concorrência: Rust tem suporte para concorrência seguro em seu sistema de tipos, através de construções como
std::threadestd::sync. Embora este programa seja simples e sequencial, Rust oferece ferramentas robustas para lidar com concorrência e paralelismo de maneira segura e eficiente. - Gerenciamento de erros: Em Rust, é comum usar o
Resultou oOptionpara 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, usamosexpect()para tratar erros de leitura de entrada, o que pode falhar se houver um erro de I/O, eparse()para converter strings em números, que pode falhar se a string não for um número válido. - Coincidência de padrões (pattern matching): Rust oferece uma poderosa construção de correspondência de padrões, que é usada no bloco
matchpara verificar o operador inserido pelo usuário. Isso oferece uma maneira concisa e segura de lidar com várias opções de maneira elegante.
Exemplo em Go
/******************************************************************************
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:
- Declaração de Pacote e Função Main:
- Em Go, o código é organizado em pacotes, e um programa começa com a declaração do pacote principal
package maine a funçãomain(). - Nas outras linguagens, a estrutura do programa pode variar, mas normalmente começa com uma função
main()ou algo semelhante.
- Em Go, o código é organizado em pacotes, e um programa começa com a declaração do pacote principal
- Importação de Pacotes:
- Go usa a palavra-chave
importpara importar pacotes externos. - Em outras linguagens, como C/C++, Java, C#, a importação de bibliotecas é feita de maneira semelhante, mas a sintaxe pode variar ligeiramente.
- Go usa a palavra-chave
- Entrada e Saída:
- Go usa os pacotes
fmteospara entrada e saída. - A função
fmt.Scanln()é usada para ler entrada do usuário efmt.Printf()para imprimir saída formatada. - Em outras linguagens, como C/C++, Java, C#, as entradas e saídas são tratadas com funções específicas da linguagem ou bibliotecas padrão.
- Go usa os pacotes
- Tratamento de Erros e Encerramento do Programa:
- Em Go, os erros são tratados usando funções como
os.Exit()para encerrar o programa com um código de saída específico. - Nas outras linguagens, o tratamento de erros pode ser feito de maneira semelhante, mas pode variar na sintaxe e nas convenções de uso.
- Em Go, os erros são tratados usando funções como
- Tipo de Dados e Formatação de Saída:
- Go é uma linguagem fortemente tipada que requer declarações explícitas de tipos de variáveis.
- A formatação de saída em Go é feita usando o pacote
fmt, que fornece funções comoPrintf()para imprimir saída formatada. - Em outras linguagens, como Java e C#, a formatação de saída pode ser semelhante, mas a sintaxe específica e os recursos disponíveis podem variar.
Essas são algumas das diferenças mais notáveis na sintaxe e semântica entre Go e as outras linguagens mencionadas.
Conclusão
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
