Crie um algoritmo e um programa em que implemente uma calculadora de 4 operações. O programa deve solicitar que o usuário informe três dados: o primeiro operando, o operador (+,-,*,/) e o segundo operando. O programa deve mostrar na tela a operação e seu resultado.

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:

1. Solicitar ao usuário que forneça o primeiro operando, o operador e o segundo operando.
2. Utilizar um switch-case para verificar o operador inserido pelo usuário e executar a operação correspondente.
3. Se o operador for inválido (ou seja, diferente de ‘+’, ‘-‘, ‘*’, ‘/’), exibir a mensagem “Operador inválido” e encerrar a execução do programa.
4. 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.
5. 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:

1. 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, num2 e operador. O compilador de Rust garante a segurança de memória em tempo de compilação.
2. Padrões de concorrência: Rust tem suporte para concorrência seguro em seu sistema de tipos, através de construções como 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.
3. Gerenciamento de erros: Em Rust, é comum usar o 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.
4. Coincidência de padrões (pattern matching): Rust oferece uma poderosa construção de correspondência de padrões, que é usada no bloco 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.

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:

1. 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 main e a função main().
   • Nas outras linguagens, a estrutura do programa pode variar, mas normalmente começa com uma função main() ou algo semelhante.
2. Importação de Pacotes:
   • Go usa a palavra-chave import para 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.
3. Entrada e Saída:
   • Go usa os pacotes fmt e os para entrada e saída.
   • A função fmt.Scanln() é usada para ler entrada do usuário e fmt.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.
4. 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.
5. 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 como Printf() 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