Estrutura Condicional em C

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Estrutura Condicional em C 
1 Estrutura Condicional Unidirecional em C 
A estrutura condicional unidirecional consiste de um teste de uma condição 
representada por uma expressão lógica, que determina se um comando ou um conjunto de 
comandos deve ou não ser executado. 
Sintaxe em C: 
if (condição) 
 comando; 
onde: 
if: é a palavra reservada de C para a estrutura condicional; 
condição: é uma expressão lógica que, se for verdadeira, fará com que o comando seja 
executado; 
comando: qualquer instrução válida em C. 
 Caso seja necessária a execução de um conjunto de comandos, denominado bloco de 
comandos, a sintaxe é a seguinte: 
if (condição) 
{ 
 comando1; 
 ... 
 comandoN; 
 } 
 
 Considerando o seguinte algoritmo: 
Algoritmo 
 início 
 declare N1, N2, M: numérico real; 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; 
 se (M ≥ 5) 
 então 
escreva(“Aprovado”); 
fim 
 
 2 
Em C fica: 
 #include <stdio.h> 
 main() 
 { 
 float N1, N2, M; 
 printf(“Digite duas notas”); 
 scanf(“%f”, &N1); 
 scanf(“%f”, &N2); 
 M = (N1 + N2)/2; 
 if (M >= 5) 
 printf(“Aprovado”); 
 } 
2 Estrutura Condicional Bidirecional em C 
A estrutura condicional bidirecional consiste de um teste de uma condição 
representada por uma expressão lógica, se o resultado for verdadeiro, um comando ou um 
bloco de comandos deve ser executado, caso contrário, outro comando ou bloco de comandos 
deve ser executado. 
Sintaxe em C: 
if (condição) 
 comando1; 
 else 
 comando2; 
onde: 
if e else: são as palavras reservadas de C para a estrutura condicional; 
condição: é uma expressão lógica que, se for verdadeira, fará com que o comando1 seja 
executado. Se for falsa, fará com que o comando2 seja executado; 
comando1 e comando2: qualquer instrução válida em C. 
 Caso seja necessária a execução de um bloco de comandos, a sintaxe é a seguinte: 
if (condição) 
{ 
 comando1; 
 comando2; 
} 
 else { 
 comando3; 
 comando4; 
 comando5; 
 } 
Considerando o seguinte algoritmo: 
Algoritmo 
 início 
 declare N1, N2, M: numérico real; 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; 
 se (M ≥ 5) 
 então 
escreva(“Aprovado”); 
 senão 
escreva(“Reprovado”); 
fim 
 3 
Em C fica: 
 #include <stdio.h> 
 main() 
 { 
 float N1, N2, M; 
 printf(“Digite duas notas”); 
 scanf(“%f”, &N1); 
 scanf(“%f”, &N2); 
 M = (N1 + N2)/2; 
 if (M >= 5) 
 printf(“Aprovado”); 
 else 
 printf(“Reprovado”); 
} 
3 Bloco de Comandos 
De maneira geral, todo bloco de comandos em C deve ser delimitado pelas símbolos { 
e }. 
Sintaxe em C: 
 { 
 comando1; 
 comando2; 
 ... 
 comandoN; 
 } 
4 Estruturas Condicionais Aninhadas 
Uma estrutura condicional está aninhada quando é utilizada dentro de outra estrutura 
condicional. 
 Formato geral: 
 if (condição1) 
 if (condição2) 
 ... 
 else 
 if (condição3) 
 ... 
 else 
 ... 
 else 
 if (condição4) 
 ... 
Considerando o seguinte algoritmo: 
Algoritmo 
 início 
 declare A, B, C: numérico real; 
 escreva(“Digite três números”); 
 leia(A); 
leia(B); 
leia(C); 
 se (A > B) 
 então 
se (A > C) 
então 
escreva(“O maior número é ”, A); 
 4 
 senão 
 escreva(“O maior número é ”, C); 
 senão 
se (B > C) 
 então 
 escreva(“O maior número é ”, B); 
senão 
escreva(“O maior número é ”, C); 
fim 
Em C fica: 
#include <stdio.h> 
 main() 
 { 
 float A, B, C; 
 printf(“Digite três números”); 
 scanf(“%f”, &A); 
 scanf(“%f”, &B); 
 scanf(“%f”, &C); 
 if (A > B) 
 if (A > C) 
 printf(“O maior número é %f”, A); 
 else 
 printf(“O maior número é %f”, C); 
 else 
if (B > C) 
 printf(“O maior número é %f”, B); 
else 
 printf(“O maior número é %f”, C); 
} 
Em relação ao problema de determinar a qual if um else pertence em estruturas 
condicionais aninhadas, C usa a seguinte regra implícita: o else fecha sempre o if mais 
próximo. 
Outra alternativa para solucionar o problema é o uso de delimitadores de blocos de 
comandos { e }, da mesma maneira que se faz em algoritmos. 
5 Estrutura Condicional N-Direcional (ou Múltipla) em C 
A estrutura condicional n-direcional permite a escolha de um comando ou bloco de 
comandos entre qualquer número de comandos ou blocos de comandos. 
Existem duas formas possíveis de estruturas condicionais n-direcionais: 
1) Seqüência de expressões lógicas (booleanas): a primeira condição verdadeira 
determina o comando ou bloco de comandos a ser executado. Pode ser implementada 
em C com o encadeamento de estruturas condicionais bidirecionais, ou seja, com 
seqüências de comandos if-else-if. Formato geral: 
if (condição1) 
 comando1; 
 else 
 if (condição2) 
 comando2; 
else 
if ... 
 
else 
 comandoN; 
 5 
Considerando o seguinte algoritmo: 
 Algoritmo 
 início 
 declare N1, N2, M: numérico real; 
 escreva(“Digite as duas notas”); 
 leia(N1); 
leia(N2); 
 M ← (N1 + N2)/2; 
 se (M ≥ 7) 
 então 
escreva(“Aprovado”); 
 senão 
se (M ≥ 5) 
 então 
 escreva(“Exame Final”); 
senão 
escreva(“Reprovado”); 
fim 
Em C fica: 
#include <stdio.h> 
 main() 
 { 
 float N1, N2, M; 
 printf(“Digite duas notas”); 
 scanf(“%f”, &N1); 
 scanf(“%f”, &N2); 
 M = (N1 + N2)/2; 
 if (M >= 7) 
 printf(“Aprovado”); 
 else 
 if (M >= 5) 
 printf(“Exame Final”); 
 else 
 printf(“Reprovado”); 
} 
 
2) Comando CASE: avalia uma condição de igualdade e executa o comando ou bloco de 
comandos correspondente. Sintaxe em C: 
switch (variável) 
{ 
 case valor1: 
comando1 ou lista de comandos1; 
 break; 
 case valor2: 
comando2 ou lista de comandos2; 
 break; 
 ... 
 case valorN: 
comandoN ou lista de comandosN; 
 break; 
 } 
onde: 
switch(variável) avalia o valor de uma variável para decidir qual case será executado; 
cada case está associado a um possível valor da variável; 
 6 
break deve ser utilizado para impedir que sejam executados os comandos definidos nos cases 
subseqüentes. 
Devido à utilização do break, a execução de um comando ou de uma lista de 
comandos obedecem a mesma sintaxe, ou seja, não há necessidade da utilização de 
delimitadores de blocos de comandos nos cases. 
 Pode ser necessária a execução de um comando ou lista de comandos caso nenhuma 
das outras opções seja satisfeita. Para isso utiliza-se a opção default. Sintaxe em C: 
switch (variável) 
{ 
 case valor1: 
comando1 ou lista de comandos1; 
 break; 
 case valor2: 
comando2 ou lista de comandos2; 
 break; 
 ... 
 case valorN: 
comandoN ou lista de comandosN; 
 break; 
 default: 
comando ou lista de comandos; 
 } 
Considerando o seguinte algoritmo: 
Algoritmo 
início 
declare op, X, Y: numérico inteiro; 
escreva(“Entre com a opção: ”); 
leia(op); 
escolha (op) 
início 
 caso 1: início 
 X ← 10; 
 Y ← 20; 
 fim 
 caso 2: inicio 
 X ← 100; 
 Y ← 0; 
 fim 
 senão: início 
 X ← 0; 
 Y ← 0; 
 fim 
 fim 
 escreva(“O valor de X é: “, X); 
 escreva(“O valor de Y é: “, Y); 
fim 
 7 
Em C fica: 
#include <stdio.h> 
main() 
{ 
 int op, X, Y; 
 printf(“Entre com a opção: ”); 
 scanf(“%d”, &op); 
 switch (op) 
 { 
 case 1: 
 X = 10; 
 Y = 20; 
 break; 
 case 2: 
X = 100; 
Y = 0; 
 break; 
 default: 
X = 0; 
Y = 0; 
 } 
 printf(“O valor de X é: %d“, X); 
 printf(“O valor de Y é: %d“, Y); 
} 
 
 8 
6 Exemplos de Programas C 
1) Faça um algoritmo e programa C que receba um número inteiro e verifique se esse 
número é par ou ímpar. 
Algoritmo 
início 
 /*Declaração de variáveis */ 
 declare num, r: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Digite um número inteiro: ”); 
 leia(num); 
/* Processo – obtém o resto da divisão de num por 2 */ 
r ← resto(num, 2); 
/* Saída de dados */ 
se (r = 0) 
então 
escreva(“O número é par”); 
senão 
escreva(“O número é ímpar”); 
fim 
 
#include <stdio.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int num, r; 
 /* Entrada de dados */ 
 printf(“Digite um número inteiro: ”); 
 scanf(“%d”, &num); 
 /* Processo – obtém o resto da divisão de num por 2 */ 
 r = num % 2; 
 /* Saída de dados */ 
 if (r == 0) 
 printf(“O número é par”); 
 else 
 printf(“O número é ímpar”); 
} 
 9 
2) A nota final de um estudante é calculada a partir de três notas: laboratório, avaliação 
semestral e exame final, com os pesos 2, 3 e 5, respectivamente. Faça um algoritmo 
que leia três notas de um estudante, calcule e mostre a média ponderada e o conceito 
correspondente, de acordo com: 
 
Média ponderada Conceito 
≥ 8.0 A 
≥ 7.0 e < 8.0 B 
≥ 6.0 e < 7.0 C 
≥ 5.0 e < 6.0 D 
< 5.0 E 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare laboratorio, semestral, exame, media: numérico real; 
 /* Entrada de dados */ 
 escreva(“Digite a nota de laboratório: ”); 
 leia(laboratorio); 
 escreva(“Digite a nota da avaliação semestral: ”); 
 leia(semestral); 
 escreva(“Digite a nota do exame final: ”); 
leia(exame); 
/* Processo – cálculo da média ponderada */ 
media ← (laboratório * 2 + semestral * 3 + exame * 5) / 10; 
/* Saída de dados */ 
escreva(“Média ponderada = ”, media); 
se (media ≥ 8.0) 
então 
escreva(“Conceito A”); 
senão 
se (media ≥ 7.0) 
 então 
escreva(“Conceito B”); 
 senão 
se (media ≥ 6.0) 
 então 
escreva(“Conceito C”); 
 senão 
se (media ≥ 5.0) 
 então 
escreva(“Conceito D”); 
 senão 
escreva(“Conceito E”); 
fim 
 
 10 
#include <stdio.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 float laboratorio, semestral, exame, media; 
 /* Entrada de dados */ 
 printf(“Digite a nota de laboratório: ”); 
 scanf(“%f”, &laboratorio); 
 printf(“Digite a nota da avaliação semestral: ”); 
 scanf(“%f”, &semestral); 
 printf(“Digite a nota do exame final: ”); 
 scanf(“%f”, &exame); 
 /* Processo – cálculo da média ponderada */ 
 media = (laboratorio * 2 + semestral * 3 + exame * 5) / 10; 
 /* Saída de dados */ 
 printf(“Média ponderada = %f”, media); 
 if (media >= 8.0) 
 printf(“Conceito A”); 
 else 
 if (media >= 7.0) 
 printf(“Conceito B”); 
 else 
 if (media >= 6.0) 
 printf(“Conceito C”); 
 else 
if (media >= 5.0) 
 printf(“Conceito D”); 
 else 
 printf(“Conceito E”); 
} 
 
 11 
3) Faça um algoritmo que mostre o menu de opções a seguir, receba a opção do usuário e 
os dados necessários para executar cada operação. 
Menu de opções: 
1. Somar dois números 
2. Raiz quadrada de um número 
Algoritmo 
início 
/* Declaração de variáveis */ 
declare op: numérico inteiro; 
 num1, num2, resultado: numérico real; 
/* Entrada de Dados Geral */ 
escreva(“Menu”); 
escreva(“1. Somar dois números”); 
escreva(“2. Raiz quadrada de um número”); 
escreva(“Digite sua opção: ”); 
leia(op); 
/* Entrada de Dados específicos e processo */ 
escolha (op) 
início 
 caso 1: início 
 escreva(“Digite dois números para a soma: ”); 
 leia(num1); 
 leia(num2); 
 resultado ← num1 + num2; 
 fim 
 caso 2: início 
 escreva(“Digite um número para a raiz quadrada: ”); 
 leia(num1); 
 resultado ← √num1 
 fim 
 senão: início 
resultado ← 0; 
escreva(“Opção inválida”); 
 fim 
 fim 
 escreva(“Resultado = “, resultado); 
fim 
 
 12 
#include <stdio.h> 
#include <math.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int op; 
 float num1, num2, resultado; 
 /* Entrada de Dados Geral */ 
 printf(“Menu”); 
 printf(“1. Somar dois números”); 
 printf(“2. Raiz quadrada de um número”); 
 printf(“Digite sua opção: ”); 
 scanf(“%d”, &op); 
 /* Entrada de Dados específicos e processo */ 
 switch (op) 
 { 
case 1: 
printf(“Digite dois números para a soma: ”); 
 scanf(“%f”, &num1); 
 scanf(“%f”, &num2); 
 resultado = num1 + num2; 
break; 
case 2: 
 printf(“Digite um número para a raiz quadrada: ”); 
 scanf(“%f”, &num1); 
 resultado = sqrt(num1); 
break; 
default: 
resultado = 0; 
printf(“Opção inválida”); 
 } 
 printf(“Resultado = %f“, resultado); 
} 
 
 13 
7 Exercícios de Fixação 
1) Faça um algoritmo e programa C que leia dois números X e Y, calcule Z = (X + Y)/2 e 
mostre o resultado de Z somente se Z ≠ 0. 
2) Dados dois número inteiros, faça um algoritmo e programa C que mostre-os em ordem 
crescente. 
3) Faça um algoritmo e programa C para ler os comprimentos dos três lados de um 
triângulo (S1, S2 e S3) e determinar que tipo de triângulo é formado, com base nos 
seguintes casos. Seja A o maior dos lados de S1, S2 e S3, e B e C os outros dois, 
então: 
Se A ≥ B + C nenhum triângulo é formado; 
Se A2 = B2 + C2 um triângulo retângulo é formado; 
Se A2 > B2 + C2 um triângulo obtusângulo é formado; 
Se A2 < B2 + C2 um triângulo acutângulo é formado. 
4) Uma empresa decidiu dar a seus funcionários uma gratificação de Natal. A 
gratificação é baseada em dois critérios: número de horas extras trabalhadas 
(horas_extras) e números de horas que o funcionário faltou ao trabalho (horas_faltas). 
A seguinte fórmula é utilizada para calcular o número de horas do funcionário: 
horas = horas_extras – 2/3 * horas_faltas 
A gratificação é distribuída de acordo com a seguinte tabela: 
 
Horas gratificação 
> 40 horas R$ 500.00 
> 30 mas ≤ 40 horas R$ 400.00 
> 20 mas ≤ 30 horas R$ 300.00 
> 10 mas ≤ 20 horas R$ 200.00 
≤ 10 horas R$ 100.00 
 
Faça um algoritmo e programa C que leia o número de horas extras e número de horas 
de faltas de um funcionário, calcule e mostre a gratificação correspondente. 
5) Faça um algoritmo e programa C que apresente o menu de opções a seguir, permita ao 
usuário escolher a opção desejada, receba os dados necessários para executar a 
operação e mostre o resultado. Verifique a possibilidade de opção inválida. 
Menu de opções: 
1. Imposto 
2. Novo salário 
3. Classificação 
Na opção 1, ler o salário de um funcionário, calcular e mostrar o valor do imposto, 
usando as regras a seguir: 
Salário Percentual do imposto 
menor que R$ 500.00 5% 
de R$ 500.00 a R$ 850.00 10% 
acima de R$850.00 15% 
 
Na opção 2, ler o salário de um funcionário, calcular e mostrar o salário com aumento, 
usando as regras a seguir: 
Salário Aumento 
maior que R$1500.00 R$ 25.00 
de R$ 750.00 (inclusive) a R$ 1500.00 R$ 50.00 
 14 
de R$ 450.00 (inclusive) a R$ 750.00 R$ 75.00 
menor que R$ 450.00 R$ 100.00 
 
 Na opção 3, ler o salário de um funcionário e mostrar sua classificação, de acordo com 
a tabela seguinte: 
Salário Classificação 
até R$ 700.00 (inclusive) Mal remunerado 
maior que R$ 700.00 Bem remunerado