activeinfo
 

Curso de Lógica da Programação na Prática.

Estruturas de Decisão.

Em certas ocasiões não queremos que o computador execute todos os códigos de nossos programas.

Descobrimos isso conversando novamente com nosso cliente. Lembra-se da nossa calculadora, que fizemos em Ruby? Pois bem, apresentei ela ao nosso cliente e ele apresentou uma nova demanda:

Cliente

Marcos, a calculadora está ótima! No entanto, nesta versão, todas as operações são realizadas. Gostaria que o usuário pudesse escolher se quer realizar uma adição, multiplicação, divisão ou subtração. Não tem sentido realizar todas as operações.

Pesquisando novamente, descobrimos que podemos utilizar os comandos de decisão. Em português estruturado temos o comando se, senao e o comando caso. Primeiro vamos estudar o comando se, senao:

Lembra daquele primeiro algoritmo que apresentamos no início do curso, quando comparamos um algoritmo em Português Estuturado com um script em Ruby? Vamos revê-lo, primeiro com um fluxograma:

Fluxograma

Podemos notar a inserção do símbolo que representa uma decisão dentro do fluxo do programa. Vemos que o fluxo do programa segue de acordo com essa estrutura de decisão: se for verdadeira a decisão, vai por um caminho, senão, por outro.

E depois em Português Estruturado:

var
 resposta: cadeia;
inicio
  escreva "Vai chover hoje?";
  leia resposta;
  se resposta = "sim"
    escreva "Acho que vou ficar em casa";
  senao
    escreva "Vou ao cinema mais tarde...";
  fimse
fim

No algoritmo acima, além da declaração de variáveis e do bloco que delimita o início e o fim do algoritmo (inicio e fim), vemos mais duas estruturas que definem alguns blocos de código. Esses blocos são pedaços de código que se diferenciam do resto do programa por estarem tratando de um cálculo ou decisão específica.

Ou seja, um determinado trecho de código será executado baseado em uma resposta que o usuário vai definir.

Primeiro, solicitamos ao usuário que responda a uma pergunta. Então o interpretador vai realizar os cálculos baseado na resposta que receber. Quando dizemos ao interpretador:

se resposta = "sim"

Ele vai avaliar o conteúdo da variável resposta. Caso o conteúdo da mesma seja "sim" essa avaliação retorna verdadeiro, entra na condição e mostra a resposta:

    escreva "Acho que vou ficar em casa";

Dessa forma, o interpretador vai ignorar as próximas linhas do programa, até o final do bloco. Se a resposta for diferente de "sim", o interpretador entra no bloco do senao e mostra a segunda resposta, ignorando o que está dentro do bloco do se.

    escreva "Vou ao cinema mais tarde...";

Opa! Então isso pode servir para a nossa calculadora! Calma lá. No caso da calculadora tenho mais de duas escolhas. Nesse caso, como fazemos? Podemos utilizar os testes encadeados.

Primeiro vamos desenvolver um novo fluxograma para a calculadora, agora com a estrutura de decisão:

Fluxograma

Um detalhe nesse fluxograma é que omitimos a primeira mensagem que o programa deve mostrar ao usuário solicitando os valores para o primeiro e segundo número e para o operador. Isso é comum em fluxogramas, pois, para que fiquem mais "enxutos", quando utilizamos o devido símbolo gráfico de leitura de dados fica implícito que os dados foram solicitados ao usuário.

Em seguida vamos ao algoritmo:

var
  num_1, num_2, resultado: integer;
  operador: caractere;

inicio
  escreva "Digite o primeiro número";
  leia num_1;
  escreva "Digite o segundo número";
  leia num_2;
  escreva "Escolha qual tipo de operação.";
  escreva "Digite + para soma";
  escreva "Digite * para multiplicação";
  escreva "Digite / para divisão";
  escreva "Digite - para subtração";
  leia operador
  se operador = "+" # verifica se o usuário digitou um +
    resultado <– num_1 + num_2;
  senao se operador = "*" # verifica se o usuário digitou um *
    resultado <– num_1 * num_2;
  senao se operador = "/" # verifica se o usuário digitou uma /
    resultado <– num_1 / num_2;
  senao se operador = "-" # verifica se o usuário digitou um -
    resultado <– num_1 – num_2;
  senao
    escreva "Operador incorreto";
  fimse
  se operador = "+" ou operador = "-" ou operador = '*' ou operador = '/'
    escreva 'O resultado da operação é: ' + resultado;
  senao
    escreva 'Não foi possível realizar o cálculo.';
  fimse
fim

Vamos analisar as mudanças que fizemos na calculadora:

Estrutura de Decisão SE SENAO em Ruby

Podemos codificar este algoritmo em Ruby para realizar alguns testes:

# encoding: iso-8859-1
#########################################################
# Programa: decisao_se.rb
#
# Descrição: Programa que simula uma calculadora básica
#            em Ruby utilizando uma estrutura de decisão
#            if elsif else
#
# Execução:
# ruby decisao_se.rb
#
# Autor: Marcos Cesar Kossoski
#
# Observações: não valida os dados de entrada
#########################################################
num_1, num_2, operador = '', '', ''
resultado = 0.0
begin
  puts "Digite o primeiro número"
  num_1 = gets.chomp
  num_1 = num_1.to_f
  puts "Digite o segundo número";
  num_2 = gets.chomp
  num_2 = num_2.to_f
  puts "Escolha qual o tipo da operação:"
  puts "Digite + para soma."
  puts "Digite - para subtração."
  puts "Digite * para multiplicação."
  puts "Digite / para divisão."
  operador = gets.chomp
  if operador == "+"
    resultado = num_1 + num_2
  elsif operador == "*"
    resultado = num_1 * num_2
  elsif operador == "/"
    resultado = num_1 / num_2.to_f
  elsif operador == "-"
    resultado = num_1 - num_2
  else
    puts "Operador incorreto."
  end
  if operador == "+" or operador == "-" or operador == "*" or operador == "/"
    puts "O resultado é: #{resultado}"
  else
    puts "Não foi possível realizar o cálculo."
  end
end

Veja como ficou muito parecido com o algoritmo. Um detalhe a ser notado é que a declaração senao se é trocada por elsif.

Ao testarmos o programa com um operador incorreto, vemos que as mensagens esperadas são apresentadas na tela:

Testando Estrutura de Decisão com Operador Incorreto

Já com um operador esperado, o programa funciona corretamente:

Testando Estrutura de Decisão com Operador Correto

Estrutura de Decisão SE SENAO em Java

Agora vejamos esse algoritmo implementado em Java:

/**********************************************************
 * Programa: calculadora básica que demonstra a
 *           estrutura de decisão if else em Java
 *
 * Compilação: javac DecisaoSe.java
 * Execução: java DecisaoSe
 *
 * % java DecisaoSe
 * % Digite o primeiro número
 * % 5
 * % Digite o segundo número
 * % 7
 * % Escolha o tipo da operação: + - * /
 * % *
 * % O resultado da operação é: 35
 *
 * @author Marcos Cesar Kossoski
 *
 * Observações
 * -----------
 * Não trata todos os dados de entrada
 *
 * Bugs conhecidos
 * ---------------
 * Se o usuário digitar algo diferente
 * de um número para qualquer número esperado
 * ocorrerá um erro em tempo de execução
 *
**********************************************************/
import java.util.Scanner;
public class DecisaoSe {
  public static void main (String[] args) {

    System.out.println("Digite o primeiro número: ");
    Scanner numero_1 = new Scanner(System.in);
    double n1 = numero_1.nextInt();
    System.out.println("Digite o segundo número: ");
    Scanner numero_2 = new Scanner(System.in);
    double n2 = numero_2.nextInt();
    System.out.println("Escolha o tipo da operação: + - * /");
    Scanner operador = new Scanner(System.in);
    String op = operador.nextLine();

    double resultado = 0;

    if (op.equals("+")) {
      resultado  = n1 + n2;
    } else if (op.equals("-")) {
      resultado = n1 - n2;
    } else if (op.equals("*")) {
      resultado = n1 * n2;
    } else if (op.equals("/")) {
      resultado  = n1 / n2;
    } else {
      System.out.println("Operador inválido.");
    }

    if ((op.equals("+")) || (op.equals("-")) || (op.equals("*")) || (op.equals("/"))) {
      System.out.println("O resultado da operação é: " + resultado);
    } else {
      System.out.println("Não foi possível realizar o cálculo.");
    }
  }
}

Podemos notar que em Java quando queremos comparar duas Strings, ao invés do operador relacional == utiliza-se o método .equals fornecendo o elemento a ser comparado dentro de parênteses.

Testando o programa:

Testando Estrutura de Decisão Java

Estruturas de Decisão SE SENAO em Javascript

Em Javascript, como veremos, a estrutura de decisão é muito semelhante a outras linguagens:

Calculadora básica em Javascript utilizando SE SENAO

Vimos que utilizando as técnicas corretas podemos alterar o fluxo normal de um programa. Mas ainda é possível otimizar o código, utilizando recursos que tornem o código mais limpo e preciso, inclusive economizando os recursos, ou seja, consumindo menos processamento e espaço em memória.

Voltar Próximo: Refatoração.