Exercício: calculadora simples com funções

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.

 

 

Vamos aos códigos!

 

Exemplo em C++

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <iostream>

// Função para realizar a adição
float adicao(float num1, float num2) {
    return num1 + num2;
}

// Função para realizar a subtração
float subtracao(float num1, float num2) {
    return num1 - num2;
}

// Função para realizar a multiplicação
float multiplicacao(float num1, float num2) {
    return num1 * num2;
}

// Função para realizar a divisão
float divisao(float num1, float num2) {
    if (num2 != 0)
        return num1 / num2;
    else {
        std::cout << "Erro: Divisão por zero!" << std::endl;
        return 0;
    }
}

int main() {
    float num1, num2;
    char operacao;

    std::cout << "Digite o primeiro número: ";
    std::cin >> num1;

    std::cout << "Digite o segundo número: ";
    std::cin >> num2;

    std::cout << "Escolha a operação (+, -, *, /): ";
    std::cin >> operacao;

    switch (operacao) {
        case '+':
            std::cout << "Resultado: " << adicao(num1, num2) << std::endl;
            break;
        case '-':
            std::cout << "Resultado: " << subtracao(num1, num2) << std::endl;
            break;
        case '*':
            std::cout << "Resultado: " << multiplicacao(num1, num2) << std::endl;
            break;
        case '/':
            std::cout << "Resultado: " << divisao(num1, num2) << std::endl;
            break;
        default:
            std::cout << "Operação inválida!" << std::endl;
    }

    return 0;
}

Este programa solicita ao usuário dois números e a operação desejada (+, -, *, /). Em seguida, chama a função correspondente para realizar a operação selecionada e exibe o resultado. Note que a função de divisão verifica se o divisor é zero para evitar uma divisão por zero.

A estratégia utilizada neste código é criar quatro funções separadas, uma para cada operação matemática básica: adição, subtração, multiplicação e divisão. Cada uma dessas funções aceita dois números como entrada e retorna o resultado da operação correspondente.

Na função principal, o programa solicita ao usuário que insira dois números e a operação desejada. Em seguida, ele usa uma instrução switch para determinar qual função chamar com base na operação selecionada pelo usuário. Depois de executar a operação, o programa exibe o resultado.

Essa abordagem de dividir o código em funções separadas para cada operação matemática facilita a leitura, manutenção e reutilização do código. Além disso, ao separar as operações em funções, o código fica mais organizado e modular.

 

Exemplo em C

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
#include <stdio.h>

// Função para realizar a adição
float adicao(float num1, float num2) {
    return num1 + num2;
}

// Função para realizar a subtração
float subtracao(float num1, float num2) {
    return num1 - num2;
}

// Função para realizar a multiplicação
float multiplicacao(float num1, float num2) {
    return num1 * num2;
}

// Função para realizar a divisão
float divisao(float num1, float num2) {
    if (num2 != 0)
        return num1 / num2;
    else {
        printf("Erro: Divisão por zero!\n");
        return 0;
    }
}

int main() {
    float num1, num2;
    char operacao;

    printf("Digite o primeiro número: ");
    scanf("%f", &num1);

    printf("Digite o segundo número: ");
    scanf("%f", &num2);

    printf("Escolha a operação (+, -, *, /): ");
    scanf(" %c", &operacao);

    switch (operacao) {
        case '+':
            printf("Resultado: %.2f\n", adicao(num1, num2));
            break;
        case '-':
            printf("Resultado: %.2f\n", subtracao(num1, num2));
            break;
        case '*':
            printf("Resultado: %.2f\n", multiplicacao(num1, num2));
            break;
        case '/':
            printf("Resultado: %.2f\n", divisao(num1, num2));
            break;
        default:
            printf("Operação inválida!\n");
    }

    return 0;
}

Esta versão em C segue a mesma lógica do programa em C++, mas utilizando a sintaxe da linguagem C.

 

Exemplo em Pascal / Delphi / Lazarus

(******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************)
program Calculadora;

// Função para realizar a adição
function adicao(num1, num2: real): real;
begin
    adicao := num1 + num2;
end;

// Função para realizar a subtração
function subtracao(num1, num2: real): real;
begin
    subtracao := num1 - num2;
end;

// Função para realizar a multiplicação
function multiplicacao(num1, num2: real): real;
begin
    multiplicacao := num1 * num2;
end;

// Função para realizar a divisão
function divisao(num1, num2: real): real;
begin
    if num2 <> 0 then
        divisao := num1 / num2
    else begin
        writeln('Erro: Divisão por zero!');
        divisao := 0;
    end;
end;

var
    num1, num2: real;
    operacao: char;
    resultado: real;

begin
    write('Digite o primeiro número: ');
    readln(num1);

    write('Digite o segundo número: ');
    readln(num2);

    write('Escolha a operação (+, -, *, /): ');
    readln(operacao);

    case operacao of
        '+': resultado := adicao(num1, num2);
        '-': resultado := subtracao(num1, num2);
        '*': resultado := multiplicacao(num1, num2);
        '/': resultado := divisao(num1, num2);
    else
        writeln('Operação inválida!');
        exit;
    end;

    writeln('Resultado: ', resultado:0:2);
end.

Explicação:

1. Definição das Funções:
   • Cada operação matemática básica (adição, subtração, multiplicação e divisão) é implementada como uma função separada.
   • Cada função aceita dois parâmetros do tipo real (números de ponto flutuante) e retorna um resultado do mesmo tipo.
2. Bloco Principal (begin...end):
   • No bloco principal do programa, são declaradas as variáveis num1, num2 e operacao, todas do tipo real.
   • resultado também é uma variável do tipo real, usada para armazenar o resultado da operação.
3. Leitura de Entradas:
   • Usando write e readln, o programa solicita ao usuário que insira dois números e a operação desejada.
   • Os valores inseridos pelo usuário são armazenados nas variáveis num1, num2 e operacao.
4. Execução da Operação:
   • Utilizando uma estrutura de seleção case of, o programa determina qual função chamar com base na operação selecionada pelo usuário.
   • Dependendo da operação escolhida, o programa chama a função correspondente e atribui o resultado à variável resultado.
5. Exibição do Resultado:
   • Após calcular o resultado da operação, o programa exibe o valor usando writeln.
   • O formato :0:2 especifica que o número será exibido sem casas decimais e com duas casas decimais, garantindo que o resultado seja apresentado corretamente.

Essa implementação em Pascal segue a mesma lógica das versões em C e C++, mas com as características próprias da linguagem Pascal.

 

Exemplo em Python

'''

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

'''
# Função para realizar a adição
def adicao(num1, num2):
    return num1 + num2

# Função para realizar a subtração
def subtracao(num1, num2):
    return num1 - num2

# Função para realizar a multiplicação
def multiplicacao(num1, num2):
    return num1 * num2

# Função para realizar a divisão
def divisao(num1, num2):
    if num2 != 0:
        return num1 / num2
    else:
        print("Erro: Divisão por zero!")
        return 0

num1 = float(input("Digite o primeiro número: "))
num2 = float(input("Digite o segundo número: "))

operacao = input("Escolha a operação (+, -, *, /): ")

if operacao == '+':
    print("Resultado:", adicao(num1, num2))
elif operacao == '-':
    print("Resultado:", subtracao(num1, num2))
elif operacao == '*':
    print("Resultado:", multiplicacao(num1, num2))
elif operacao == '/':
    print("Resultado:", divisao(num1, num2))
else:
    print("Operação inválida!")

Neste código Python:

• As funções para cada operação matemática básica são definidas antes do bloco principal do programa.
• Cada função aceita dois parâmetros num1 e num2 e retorna o resultado da operação correspondente.
• No bloco principal, o programa solicita ao usuário que insira dois números e a operação desejada.
• Dependendo da operação selecionada, o programa chama a função apropriada e exibe o resultado.
• Se a operação for divisão e o segundo número for zero, uma mensagem de erro é exibida.

 

Exemplo em C# / C Sharp

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
using System;

class Calculadora
{
    // Função para realizar a adição
    static float Adicao(float num1, float num2)
    {
        return num1 + num2;
    }

    // Função para realizar a subtração
    static float Subtracao(float num1, float num2)
    {
        return num1 - num2;
    }

    // Função para realizar a multiplicação
    static float Multiplicacao(float num1, float num2)
    {
        return num1 * num2;
    }

    // Função para realizar a divisão
    static float Divisao(float num1, float num2)
    {
        if (num2 != 0)
            return num1 / num2;
        else
        {
            Console.WriteLine("Erro: Divisão por zero!");
            return 0;
        }
    }

    static void Main(string[] args)
    {
        float num1, num2;
        char operacao;

        Console.Write("Digite o primeiro número: ");
        num1 = float.Parse(Console.ReadLine());

        Console.Write("Digite o segundo número: ");
        num2 = float.Parse(Console.ReadLine());

        Console.Write("Escolha a operação (+, -, *, /): ");
        operacao = char.Parse(Console.ReadLine());

        switch (operacao)
        {
            case '+':
                Console.WriteLine("Resultado: " + Adicao(num1, num2));
                break;
            case '-':
                Console.WriteLine("Resultado: " + Subtracao(num1, num2));
                break;
            case '*':
                Console.WriteLine("Resultado: " + Multiplicacao(num1, num2));
                break;
            case '/':
                Console.WriteLine("Resultado: " + Divisao(num1, num2));
                break;
            default:
                Console.WriteLine("Operação inválida!");
                break;
        }
    }
}

Neste código em C#:

• As funções para cada operação matemática básica são definidas antes do bloco principal do programa.
• Cada função aceita dois parâmetros num1 e num2 e retorna o resultado da operação correspondente.
• No bloco principal, o programa solicita ao usuário que insira dois números e a operação desejada.
• Dependendo da operação selecionada, o programa chama a função apropriada e exibe o resultado.
• Se a operação for divisão e o segundo número for zero, uma mensagem de erro é exibida.

 

Exemplo em Java

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
import java.util.Scanner;

public class Calculadora {

    // Método para realizar a adição
    public static double adicao(double num1, double num2) {
        return num1 + num2;
    }

    // Método para realizar a subtração
    public static double subtracao(double num1, double num2) {
        return num1 - num2;
    }

    // Método para realizar a multiplicação
    public static double multiplicacao(double num1, double num2) {
        return num1 * num2;
    }

    // Método para realizar a divisão
    public static double divisao(double num1, double num2) {
        if (num2 != 0)
            return num1 / num2;
        else {
            System.out.println("Erro: Divisão por zero!");
            return 0;
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double num1, num2;
        char operacao;

        System.out.print("Digite o primeiro número: ");
        num1 = scanner.nextDouble();

        System.out.print("Digite o segundo número: ");
        num2 = scanner.nextDouble();

        System.out.print("Escolha a operação (+, -, *, /): ");
        operacao = scanner.next().charAt(0);

        switch (operacao) {
            case '+':
                System.out.println("Resultado: " + adicao(num1, num2));
                break;
            case '-':
                System.out.println("Resultado: " + subtracao(num1, num2));
                break;
            case '*':
                System.out.println("Resultado: " + multiplicacao(num1, num2));
                break;
            case '/':
                System.out.println("Resultado: " + divisao(num1, num2));
                break;
            default:
                System.out.println("Operação inválida!");
        }
    }
}

Neste código Java:

• Métodos para cada operação matemática básica são definidos dentro da classe Calculadora.
• Cada método aceita dois parâmetros num1 e num2 e retorna o resultado da operação correspondente.
• No método main, o programa solicita ao usuário que insira dois números e a operação desejada.
• Dependendo da operação selecionada, o programa chama o método apropriado e exibe o resultado.
• Se a operação for divisão e o segundo número for zero, uma mensagem de erro é exibida.

 

Exemplo em Rust

/******************************************************************************

Criado pelo Professor Giovani Da Cruz
https://giovanidacruz.com.br

*******************************************************************************/
use std::io;

// Função para realizar a adição
fn adicao(num1: f64, num2: f64) -> f64 {
    num1 + num2
}

// Função para realizar a subtração
fn subtracao(num1: f64, num2: f64) -> f64 {
    num1 - num2
}

// Função para realizar a multiplicação
fn multiplicacao(num1: f64, num2: f64) -> f64 {
    num1 * num2
}

// Função para realizar a divisão
fn divisao(num1: f64, num2: f64) -> f64 {
    if num2 != 0.0 {
        num1 / num2
    } else {
        println!("Erro: Divisão por zero!");
        0.0
    }
}

fn main() {
    let mut num1 = String::new();
    let mut num2 = String::new();
    let mut operacao = String::new();

    println!("Digite o primeiro número: ");
    io::stdin().read_line(&mut num1).expect("Falha ao ler entrada.");
    let num1: f64 = num1.trim().parse().expect("Erro ao converter número.");

    println!("Digite o segundo número: ");
    io::stdin().read_line(&mut num2).expect("Falha ao ler entrada.");
    let num2: f64 = num2.trim().parse().expect("Erro ao converter número.");

    println!("Escolha a operação (+, -, *, /): ");
    io::stdin().read_line(&mut operacao).expect("Falha ao ler entrada.");
    let operacao: char = operacao.trim().chars().next().expect("Nenhuma operação fornecida.");

    let resultado = match operacao {
        '+' => adicao(num1, num2),
        '-' => subtracao(num1, num2),
        '*' => multiplicacao(num1, num2),
        '/' => divisao(num1, num2),
        _ => {
            println!("Operação inválida!");
            0.0
        }
    };

    println!("Resultado: {}", resultado);
}

Neste código Rust:

• Funções para cada operação matemática básica são definidas.
• Cada função aceita dois parâmetros num1 e num2 e retorna o resultado da operação correspondente.
• No main, o programa solicita ao usuário que insira dois números e a operação desejada.
• Dependendo da operação selecionada, o programa chama a função apropriada e exibe o resultado.
• Se a operação for divisão e o segundo número for zero, uma mensagem de erro é exibida.

 

Nesta atividade, exploramos a criação de uma calculadora simples que realiza as quatro operações básicas (adição, subtração, multiplicação e divisão) com dois números inseridos pelo usuário. Utilizamos funções para organizar o código em blocos reutilizáveis, permitindo uma melhor modularidade e manutenção do programa.

Além disso, praticamos a solicitação e leitura de dados do usuário, a seleção de ramo para executar diferentes blocos de código com base na entrada do usuário e a manipulação de erros, como divisão por zero.

Esse exercício foi uma ótima oportunidade para consolidar conceitos fundamentais de programação, como lógica de programação, manipulação de funções e interação com o usuário. Essas habilidades são essenciais para construir programas mais complexos e resolver uma variedade de problemas de maneira eficiente.

 

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!

 

#CalculadoraBasica

#ProgramacaoInterativa

#FuncoesEmAcao

#GiovaniDaCruz