LINGUAGEM DE PROGRAMAÇÃO ESTRUTURADA CAPÍTULO 4 – ESTRUTURA DE DECISÃO EM C#
A estrutura de decisão, em qualquer linguagem de programação, é baseada em expressões lógicas, mais conhecida por lógica booleana (ou álgebra booleana). Estas expressões tratam da combinação algébrica de valores que podem resultar em um de dois valores, verdadeiro (“true”) ou falso (“false”). Estes valores estão associados aos valores binários “1” e “0”. É a partir dos resultados destas expressões que as decisões são tomadas. Adicionalmente será apresentada (embora seu uso não seja recomendado) a estrutura “go to” que, assim como as estruturas de decisão” estabelece um desvio de fluxo de execução do programa.
4.1 – Lógica Booleana
As comparações lógicas (ou booleanas) requerem o uso de operadores lógicos, ou relacionais, Tabela 10.
Operador Categoria Descrição Exemplo Resultado
== binário igual a==b retorna verdadeiro se a for igual a b != binário diferente a!=b retorna verdadeiro se a for diferente de b > binário Maior que a > b retorna verdadeiro se a for maior que b < binário Menor que a < b retorna verdadeiro se a for menor que b >= binário Maior ou
igual a >= b
retorna verdadeiro se a for maior ou igual a b
<= binário Menor ou
igual a <= b
retorna verdadeiro se a for menor ou igual a b
Tabela 10 – Operadores relacionais
Exemplos:
As expressões booleanas abaixo produzem os seguintes resultados para os valores apresentados pelas variáveis a e b:
• a=3 e b=3 a == b verdadeiro ou true (1 em código binário); • a=3 e b=3 a != b falso ou false (0 em código binário); • a=3 e b=5 a == b falso ou false (0 em código binário); • a=3 e b=5 a != b verdadeiro ou true (1 em código binário);
• a= “Pedro” e b=“Pedro” a == b verdadeiro ou true (1 em código binário); Obs.: Para o uso de strings existem outros recursos computacionais na linguagem mais seguros para tal expressão, por ora, podemos empregar esta como uma alternativa.
• a= ‘1’ e b=‘1’ a != b falso ou false (0 em código binário); • a= ‘1’ e b=1 a != b verdadeiro ou true (1 em código binário);
Obs.: A variável “a” é tratada como do tipo caractere, enquanto que a variável “b” é do tipo inteiro;
• a= 5,001 e b=5 a > b verdadeiro ou true (1 em código binário); • a= 5,000 e b=5 a > b falso ou false (0 em código binário); • a= 5,001 e b=5 a >= b verdadeiro ou true (1 em código binário); • a= 5,001 e b=5 a <= b falso ou false (0 em código binário); • a= 5,000 e b=5 a <= b verdadeiro ou true (1 em código binário);
Existem operadores lógicos que tratam da combinação do resultado de duas expressões lógicas, também conhecidos por “operadores lógicos combinacionais”. Estes operadores são ternários por envolver, pelo menos, três variáveis em sua composição. Eles são muito empregados na definição de intervalos, principalmente, numéricos. Tratam-se dos operadores “E” (representado em C# por &&), “OU” (representado em C# por || Não é o sinal de exclamação e sim o de barras verticais) e suas composições com o operador “NÃO” (representado em C# por !). Este último faria uma composição com os operadores “E”, resultando no operador “NÃO – E” (representado em C# como !&) e “OU”, resultando no operador “NÃO – OU” (representado em C# como !|). O uso do operador “NÃO”, precedendo qualquer outro operador ou isoladamente, resulta na inversão do valor final da expressão lógica ou da variável lógica. As Tabelas 11 e 12 representam estas operações lógicas. Nelas os valores representados por Expressão 1 e Expressão 2 tratam de resultados de expressões lógicas elaboradas com operadores relacionais (do tipo: a > b ) .
Expressão 1 Expressão 2 Resultado
Expressão 1 && Expressão 2
Resultado
Expressão 1 !& Expressão 2
F(Falso) F(Falso) F(Falso) V(Verdadeiro)
F(Falso) V(Verdadeiro) F(Falso) V(Verdadeiro)
V(Verdadeiro) F(Falso) F(Falso) V(Verdadeiro)
V(Verdadeiro) V(Verdadeiro) V(Verdadeiro) F(Falso) Tabela 11 – Operadores lógicos “E” e “NÃO-E” aplicados à duas expressões lógicas
Exemplo:
Sejam as expressões lógicas:
a > b (Expressão 1) e a < c (Expressão 2)
A operação lógica: (a > b) && (a < c) apresentaria o resultado final:
• Verdadeiro ou True para a = 7; b = 3 e c = 10 e • Falso ou false para a=3 ; b = 3 e c = 10.
Expressão 1 Expressão 2 Resultado
Expressão 1 || Expressão 2
Resultado
Expressão 1 !| Expressão 2
F(Falso) F(Falso) F(Falso) V(Verdadeiro)
F(Falso) V(Verdadeiro) V(Verdadeiro) F(Falso)
V(Verdadeiro) F(Falso) V(Verdadeiro) F(Falso)
V(Verdadeiro) V(Verdadeiro) V(Verdadeiro) F(Falso)
Tabela 12 – Operadores lógicos “OU” e “NÃO-OU” aplicados à duas expressões lógicas
Exemplo:
Sejam as expressões lógicas:
a <= b (Expressão 1) e a >= c (Expressão 2)
A operação lógica: (a >= b) || (a <= c) apresentaria o resultado final:
• Falso ou “false” para a = 7; b = 3 e c = 10 e • Verdadeiro ou “true” para a=3 ; b = 3 e c = 10.
• NOTA: Observe que a expressão lógica representa, matematicamente, a verificação se um valor atribuído à variável “a”, não pertence ao intervalo:
3 < a < 10
.4.2 - Exercícios Propostos
4.2.1 - A tabela abaixo apresenta uma série de operações lógicas envolvendo diversas variáveis. Reescreva na própria tabela estas operações utilizando os operadores lógicos, conforme definidos na linguagem C#. Apresente o resultado da expressão, considerando os valores indicados na tabela:
Expressão Expressão Lógica Valor(es) Resultado
b a ≤ a = 3 ; b = 5; b a > a = 3 ; b = 3; 5 = a a = 5 5 ≠ a a = 5 10 5< a≤ a = 5 10 5≤ a≤ a = 5 c a b< < a= ‘l’ ; b = ‘a’ ; c= ‘i’ b a ≠ a = “André” ; b= “Pedro”
4.2.2 – Uma universidade tem como prática a associação de conceitos às notas de suas disciplinas segundo o modelo apresentado no quadro abaixo. Preencha este quadro com a expressão lógica que represente cada um desses conceitos:
Nota (Intervalo) Conceito Expressão lógica
9,5 (inclusive) a 10,0 (inclusive) Louvor 8,5 (inclusive) a 9,5 Ótimo 7,5 (inclusive) a 8,5 Bom 6,5 (inclusive) a 7,5 Regular 5,5 (inclusive) a 6,5 Insuficiente Abaixo de 5,5 Deficiente 4.3 – Estruturas de Decisão
Toda estrutura de decisão está vinculada ao resultado uma expressão lógica. A decisão (ou o caminho) será executada em função do valor (lógico) que esta expressão pode assumir. Existem diversos tipos de estruturas de decisão. As mais usuais e aplicadas são a partir das instruções if e switch.
4.3.1 – A instrução if
Trata-se da instrução mais versátil e conhecida em estruturas de decisão. A instrução if causa um desvio do fluxo de execução das instruções de um programa em função do resultado de uma condição, que nada mais é que uma expressão lógica. Sua sintaxe, na forma mais simples é a apresentada na Figura 16.
static void Main (string [ ] args);
.
.
.
< instrução 1>;
< instrução 2>;
if ( < expressão lógica > ) < instrução 3> ;
<instrução 4>;
.
.
.
verdadeira
Figura 16 – Sintaxe da instrução if.
static void Main (string [ ] args);
.
.
.
< instrução 1>;
< instrução 2>;
if ( < expressão lógica > ) < instrução 3> ;
<instrução 4>;
.
.
.
verdadeira
static void Main (string [ ] args);
.
.
.
< instrução 1>;
< instrução 2>;
if ( < expressão lógica > ) < instrução 3> ;
<instrução 4>;
.
.
.
verdadeira
Observe que a expressão lógica está vinculada ao problema em questão, ou seja, aos requisitos de programação. Um exemplo prático da aplicação desta instrução seria a resolução de um dos itens relacionados na tabela apresentada no exercício proposto 4.2.2. Suponha que o valor do conceito relacionado à nota do aluno seja atribuída a uma variável do tipo String denominada Conceito, com valor inicial igual à “ ”, ou seja, um String vazio. A condição para que seja atribuído um valor de conceito, conforme a tabela do exercício, estaria vinculado ao valor da variável do tipo Double denominada nota. Esta variável nota receberia um valor de entrada (via teclado) que seria utilizado na expressão lógica representada abaixo:
nota >=7,5 && nota < 8,5
É conhecido (pela consulta à tabela apresentada no exercício) que o intervalo atribuído a esta expressão lógica corresponde ao conceito “Bom”. Sendo a expressão verdadeira, deve-se atribuir o valor “Bom” a variável Conceito. A construção da instrução que estabelece esta estrutura de decisão é apresentada abaixo.
if (nota >= 7,5 && nota < 8,5 ) Conceito = “Bom”; Exemplo 1:
A listagem abaixo refere-se a um programa que recebe como entrada o nome de um aluno de uma sala de aula e suas notas semestrais, P1 e P2. Considerando todas entradas válidas ele calcula e exibe como saída, o nome do aluno, a média final e o “status” do aluno. Este último será Aprovado, caso o aluno tenha uma média superior ou igual à 7,0 ou Exame, caso contrário. Segue após esta listagem a tela de saída do programa considerando a seguinte entrada:
Nome: Cora Coralina P1=9,5 P2 = 9,0
static void Main(string[] args) {
//
// Declaração de variáveis //
string nome, status; double P1,P2,Media; //
// Inicialização das Variáveis //
P1=0.0; P2=0.0;
status = "Reprovado"; //
// Entrada de dados via teclado //
Console.WriteLine("\n ==> Digite o nome do Aluno:"); nome = Console.ReadLine();
Console.WriteLine("\n ==> Digite a nota P1 do Aluno:"); P1 = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("\n ==> Digite a nota P2 do Aluno:"); P2 = Convert.ToDouble(Console.ReadLine());
//
//
Media=(P1+P2)/2; //
// Verificação do status do aluno //
if (Media >=7.0)status="Aprovado";
Console.WriteLine("\n****************************************************************** ***********");
Console.WriteLine("\nNome: {0}", nome);
Console.WriteLine("\nNotas\tP1: {0} \tP2: {1} \tMédia: {2}", P1, P2, Media); Console.WriteLine("\n {0}", status);
Console.WriteLine("\n****************************************************************** ***********");
}
Atividades em Laboratório (Instrução if – simples)
• Elabore um programa em C# que receba como entrada o nome de um aluno, o RA (Registro Acadêmico) deste aluno, o nome de uma disciplina e suas respectivas notas: P1 e P2. A seguir ele calcula a média do aluno e associa esta média ao conceito mostrado na tabela abaixo. O programa deverá apresentar como saída:
Nome do aluno: RA do aluno:
Notas P1: P2:
Média final: Conceito:
Média Conceito
9,5 (inclusive) a 10,0 (inclusive) Louvor 8,5 (inclusive) a 9,5 Ótimo 7,5 (inclusive) a 8,5 Bom 6,5 (inclusive) a 7,5 Regular 5,5 (inclusive) a 6,5 Insuficiente Abaixo de 5,5 Deficiente
• Elabore um programa em C# que receba como entrada três números reais. Considerando todas as entrada válidas, o programa deverá exibir estas entradas em ordem decrescente de valores.
Instrução if – then - else
A estrutura de decisão empregando a instrução “if simples” não apresenta uma opção de execução de instruções caso sua condição (expressão lógica) seja falsa. Neste caso utilizamos uma estrutura de decisão que emprega este recurso, denominada “if – then – else”. Sua sintaxe é representada na Figura 17.
É importante ressaltar nesta sintaxe:
• a sintaxe da instrução para a opção verdadeira é idêntica a do if-simples; • a instrução para a condição falsa inicia com o termo “else” e
• o final da estrutura de decisão ocorre com o ponto-e-vírgula após a instrução que acompanha o termo “else” (“<instrução 4>”).
Exemplo 2:
O exemplo abaixo é uma adequação do Exemplo 1, apresentado anteriormente. No Exemplo 1 foi atribuído o valor “Reprovado” à variável “status”. Caso o aluno tivesse média para aprovação seria então atribuído o valor “Aprovado” à esta mesma variável. Neste exemplo,
Figura 17 – Sintaxe da instrução if – then - else.
static void Main (string [ ] args); . . . < instrução 1>; < instrução 2>; if ( < expressão lógica > ) <instrução 3> ; else <instrução 4>; <instrução 5> <instrução 6> . . . verdadeira falsa
Figura 17 – Sintaxe da instrução if – then - else.
static void Main (string [ ] args); . . . < instrução 1>; < instrução 2>; if ( < expressão lógica > ) <instrução 3> ; else <instrução 4>; <instrução 5> <instrução 6> . . . verdadeira falsa
static void Main (string [ ] args); . . . < instrução 1>; < instrução 2>; if ( < expressão lógica > ) <instrução 3> ; else <instrução 4>; <instrução 5> <instrução 6> . . . verdadeira falsa
Exemplo 2, a variável “status” será inicializada com o valor “”, ou seja, em branco ou vazia. Caso a média do aluno seja suficiente para a sua aprovação (resultado da expressão lógica verdadeira), será atribuído o valor “Aprovado” à esta variável, caso contrário (resultado da expressão lógica falsa), será atribuído o valor “Exame” para a variável “status”. Observe que na apresentação do resultado, apresenta-se na tela o conteúdo desta variável. A inplementação da nova estrutura de decisão fica da seguinte forma:
if (Media >= 7.0) status = "Aprovado"; else
status = "Exame"; O resultado da execução do programa fica:
Atividade em Laboratório (Instrução if – then – else)
• Elabore um programa em C# que receba, como entrada, um número Real. Considerando válida a entrada ele verifica se este valor pertence ao intervalo:
15 3≤ <
− x apresentando como resultado uma das seguintes mensagens:
o “O valor de x = (apresenta o valor) Pertence ao intervalo estabelecido” ou o “O valor de x = (apresenta o valor) Não pertence ao intervalo estabelecido”.
Bloco de instruções
Existem situações em que deseja-se executar mais de uma instrução a partir da ocorrência de uma determinada decisão. Neste caso utilizam-se os blocos de instruções. Embora já explorado no capítulo 2 (item 2.3), a criação e aplicação deste recurso, requer um exemplo específico para estruturas de decisão,visto sua possibilidade de não incorrer em erros de compilação e sim de lógica. Sempre que utilizar este tipo de aplicação, recomenda-se uma
Exemplo 3:
O exemplo abaixo é uma adaptação do Exemplo 2. No Exemplo 2 foi atribuído o valor “Exame” à variável “status” caso a média do aluno não fosse suficiente para a sua aprovação. Neste caso acrescentaremos a informação sobre a nota necessária para aprovação do aluno. Observe que, visto a apresentação dos resultados serem diferentes para cada uma das opções, incluímos as instruções para impressão dentro dos blocos de instruções. Sendo assim, a estrutura de decisão fica da seguinte forma:
Media=(P1+P2)/2; //
// Impressão de parte da saída do programa: //
Console.WriteLine("\n*****************************************************"); Console.WriteLine("\nNome: {0}", nome);
Console.WriteLine("\nNotas\tP1: {0} \tP2: {1} \tMédia: {2}", P1, P2, Media); //
// Verificação do status do aluno // if (Media >= 7.0) { status = "Aprovado"; Console.WriteLine("\n {0}", status); } else { status = "Exame"; ne = 10 - Media;
Console.WriteLine("\n{0} ==> Nota necessária para Aprovação {1}", status,ne);
}
Console.WriteLine("\n*************************************************************"); }
O resultado da execução do programa fica:
Atividade em Laboratório (Instrução if – then – else)
• Elabore um programa em C# que receba como entrada os parâmetros de uma equação do segundo grau do tipo: 2 0
= + +bx c
Considerando todas as entradas válidas, o programa deverá calcular e apresentar como saída:
o Uma mensagem se a equação possui ou não raízes reais; o Os valores das raízes da equação caso exista.
4.3.2 – A instrução switch - case
Trata-se de uma instrução comumente empregada em múltiplas opções, ou seja, ela é baseada em uma variável teste, que deve ser do tipo inteiro ou caractere. Sua sintaxe é apresentada abaixo, Figura 18.
É importante ressaltar o emprego da instrução “break” nesta estrutura. Sempre que a instrução “break” for utilizada dentro de uma estrutura, ela proporciona sua finalização, ou seja, a execução do programa passará a continuar a partir da primeira linha após o final da estrutura que ela está declarada. Trata-se de uma instrução de desvio de fluxo de execução. Existem outros recursos que realizam a mesma operação, como por exemplo a instrução “go to” que veremos adiante.
Exemplo 4:
Este exemplo é uma aplicação prática da instrução switch-case. Nele vamos construir uma calculadora que realiza as operações matemáticas básicas (soma, subtração, divisão e multiplicação) entre dois números e apresenta seu resultado. Segue o código do programa
Figura 18 – Sintaxe da instrução switch - case switch( < variável de teste > ) {
Case <valor de comparação1>: <instrução 1>;
<instrução 2>; break;
Case <valor de comparação2>: <instrução 3>; <instrução 4>; break; . . . default: <instrução n-1>; <instrução n>; break; }
Figura 18 – Sintaxe da instrução switch - case switch( < variável de teste > ) {
Case <valor de comparação1>: <instrução 1>;
<instrução 2>; break;
Case <valor de comparação2>: <instrução 3>; <instrução 4>; break; . . . default: <instrução n-1>; <instrução n>; break; }
static void Main(string[] args) { // // Declaração de variáveis // double a,b,resultado; char operacao; //
// Inicialização das Variáveis // a=0.0; b=0.0; resultado = 0.0; operacao=' '; //
// Entrada de dados via teclado //
Console.WriteLine("\n ==> Digite o primeiro valor:"); a = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("\n ==> Digite o segundo valor:"); b = Convert.ToDouble(Console.ReadLine());
Console.WriteLine("\n ==> Digite a operação desejada:"); operacao = Convert.ToChar(Console.ReadLine()); // // Estrutura de Decisão // switch - case // switch (operacao) { case '+': resultado=a+b;
Console.WriteLine("\n ==> Soma = {0}",resultado); break;
case '-':
resultado=a-b;
Console.WriteLine("\n ==> Subtração = {0}",resultado); break;
case '*':
resultado=a*b;
Console.WriteLine("\n ==> Produto = {0}",resultado); break;
case '/':
resultado=a/b;
Console.WriteLine("\n ==> Divisão = {0}",resultado); break;
default:
Console.WriteLine("\n ==> Opção errada – Operação desconhecida");
break; }
}
Atividade em Laboratório (Instrução switch - case)
• Elabore um programa em C# que calcule e apresente como resultado a área das seguintes figuras geométricas:
o Quadrado; o Retângulo; o Triângulo; o Trapézio; o Circunferência e o Cilindro.
Considere válidas todas as entradas do programa. 4.4 - A instrução “goto”
Trata-se de uma forma bastante prática para desvio de fluxo de execução de um programa. Seu emprego requer a utilização de “labels” (ou etiquetas). Sempre que desejar ocasionar um desvio de fluxo para uma determinada posição do programa utiliza-se a instrução “goto” acrescida do nome de um label (etiqueta). Este label indica a posição para qual desejamos desviar a execução do programa. A Figura 19 apresenta, de forma ilustrativa, tanto a sintaxe da instrução “goto”, como seu funcionamento.
Figura 19 – Sintaxe da instrução goto
. . . <instrução 1>; goto meuLabel; <instrução 2>; <instrução 3>; <instrução 4>; meuLabel: <instrução 5>; <instrução 6>; <instrução 7>; }
Figura 19 – Sintaxe da instrução goto
. . . <instrução 1>; goto meuLabel; <instrução 2>; <instrução 3>; <instrução 4>; meuLabel: <instrução 5>; <instrução 6>; <instrução 7>; }
Observe nesta figura que as instruções 2, 3 e 4 não serão executadas neste programa. A instrução “goto” é muito útil quando se pretende associar, ou sair ( encerrar) uma estrutura de decisão ou de repetição à uma posição do programa, porém, deve-se evitar seu uso, pois,
Exemplo 5:
O código abaixo mostra como o uso da instrução “goto” pode tornar o programa confuso. O resultado da execução do programa é apresentado a seguir.
static void Main(string[] args) {
int meuInteiro = 5; segundoPasso:
goto adicionaValor; escreveResultado:
Console.WriteLine("Meu Inteiro = {0}", meuInteiro); goto segundoPasso;
adicionaValor:
meuInteiro += 10;
if (meuInteiro > 100) goto final; goto escreveResultado;
final: ; }
Atividade em Laboratório (Instrução goto)
Implemente o programa do Exemplo 5, execute ele passo a passo. Elabore um fluxograma deste algoritmo.
TAREFA 4 – ESTRUTURA DE DECISÃO EM C#
Nome:
RA.: Curso: Turma:
1) Fazer um algoritmo em C# que leia o código correspondente ao cargo de um funcionário. Considerando a entrada válida, o algoritmo exibe o cargo e o percentual de aumento ao qual este funcionário tem direito segundo a tabela abaixo:
Código Cargo Percentual
1 Escriturário 50%
2 Secretária 35%
3 Caixa 20%
4 Gerente 10%
5 Diretor 5%
2) Uma companhia de seguros tem três categorias de seguros baseadas na idade e ocupação do segurado. Somente pessoas com pelo menos 18 anos e não mais de 70 anos podem adquirir apólices de seguros. Quanto às classes de ocupações foram definidos três grupos de risco. A tabela a seguir fornece as categorias em função da faixa de idade e do grupo de risco:
idade Grupo de Risco
baixo médio alto
18 a 24 7 8 9
25 a 40 4 5 6
41 a 70 1 2 3
Elabore um programa em C# que recebe a idade e o grupo de risco de um indivíduo (b – baixo, m – médio ou a – alto). Considerando todas as entradas válidas o programa deverá determinar e exibir o número do grupo de risco (1 a 9) do indivíduo.
3) Uma empresa decidiu dar uma gratificação de Natal aos seus funcionários, baseada no número de horas extras e no número de horas que o funcionário faltou ao trabalho. O valor do prêmio é obtido pela consulta na tabela a seguir, em que:
H = (número de horas extras) – (2/3 * (números de horas-falta))
H (minutos) Prêmio ($) > 2400 500 1800 | 2400 400 1200 | 1800 300 600 | 1200 200 <= 600 100
Fazer um algoritmo em C# que leia o número de horas extras e o número de horas-falta em minutos de um funcionário. Considerando válida todas as entradas, o algoritmo deverá exibir o número de horas extras, o número de horas-falta (em horas) e o valor do prêmio.
