3-algoritmos-expressoes-condicionais

Prévia do material em texto

Algoritmos: 
Expressões 
condicionais
 
SST
FRANCISCO, L. F. C.
Algoritmos: Expressões condicionais / Luciano Furtado 
Correa Francisco 
Ano: 2020
nº de p.: 13 páginas
Copyright © 2020. Delinea Tecnologia Educacional. Todos os direitos reservados.
3
Algoritmos: Expressões 
condicionais
Apresentação
Nesta unidade, vamos estudar um recurso que é responsável por possibilitar aos 
softwares a criação de diferentes fluxos de execução, que podem variar de acordo 
com cada situação enfrentada. Trata-se das chamadas expressões condicionais. 
Expressões condicionais
Uma das expressões mais poderosas nos algoritmos é a expressão condicional. 
Ela dá muita flexibilidade ao desenvolvedor, por isso, é um recurso muito utilizado 
nos códigos. Praticamente todas as linguagens de programação – entre as quais 
a linguagem C – implementam várias formas de expressões condicionais. Os dois 
únicos resultados possíveis de uma expressão condicional são: falso ou verdadeiro. 
Verdadeiro ou falso
Fonte: Plataforma Deduca (2020).
Na linguagem C, esses valores são respectivamente 0 e 1. As expressões condicionais 
podem ser de dois tipos: simples ou composta. Condições simples usam operadores 
relacionais, ou seja, operadores que fazem uma comparação. Por exemplo: na 
linguagem C, a expressão b + 2 > 3 * c é uma condição simples. Digamos que b=2 e 
c=3, o valor da expressão será 0, isto é, falso, já que 2 + 2 não é maior que 3 x 4.
Veja, na tabela a seguir, a relação de operadores relacionais na linguagem C:
4
Operadores aritméticos em C
OPERADOR PROGRAMA C
IGUAL ==
DIFERENTE !=
MENOR <
MENOR OU IGUAL <=
MAIOR OU IGUAL >=
 
Fonte: Elaborada pelo autor (2020).
Na linguagem C, não podemos combinar operadores simples em uma mesma 
condição, porque podemos ter condições falso/verdadeiro diferentes em uma 
mesma condição, o que não pode ser avaliado por meio de uma condição simples. 
Essa situação é explicitada no seguinte exemplo:
Suponha que temos x=5, y=5 e z=5. Neste caso, deveríamos esperar que 
a expressão x==y==z fosse verdadeira, porém devido à forma como C 
avalia os operadores relacionais, esta expressão é falsa. Isso acontece 
porque o valor da expressão x==y==z é determinado em duas etapas. 
Primeiramente se avalia x==y, que resulta em verdadeiro (1), depois esse 
resultado é comparado com o valor de z, ou seja, 1==5, que resulta em 
falso (0). (PEREIRA, 2016, p. 35).
Para resolver a situação posta, temos de usar as chamadas expressões condicionais 
compostas. Uma condição composta é uma expressão condicional formada por 
duas ou mais condições simples, unidas por um operador lógico.
Mas, afinal, o que são operadores lógicos?
Dentro da ciência da lógica, da qual os algoritmos se utilizam, os operadores lógicos 
são usados para representar situações em que os operadores aritméticos não são 
suficientes. Os operadores lógicos são: operador E, operador OU e operador NÃO.
A união de operações simples por meio dos operadores lógicos resolve os cenários 
nos quais devemos comparar duas ou mais expressões simples. Na linguagem 
C, os operadores lógicos são representados da seguinte maneira: operador E: &&; 
operador OU: ||; operador NÃO: !.
5
Quando avaliados, os operadores lógicos também resultam em falso (0) ou 
verdadeiro (1), tal como os operadores relacionais. Nessa situação, porém, temos 
algumas regras que dizem respeito ao resultado final. Veja a tabela a seguir para 
uma melhor compreensão, usando a notação da linguagem C:
Resultado de operadores lógicos na linguagem C
Expressão Resultado Expressão Resultado Expressão Resultado
0&&0 0 (FALSO) 0||0 0 (FALSO) !0 1 (VERDADEIRO)
0&&1 0 (FALSO) 0||1 1 (VERDADEIRO) !1 0 (FALSO)
1&&0 0 (FALSO) 1||0 1 (VERDADEIRO)
1&&1 1 (VERDADEIRO) 1||1
1 
(VERDADEIRO)
 
Fonte: Elaborada pelo autor (2020).
Vejamos um exemplo prático do uso desses operadores. Imaginemos a expressão 
composta, em C, na forma: (a+2>3*b || 3*c==12). Digamos que a=2, b=3 e c=4. 
Concluímos que o resultado dessa expressão é verdadeiro: 1. Para chegarmos a 
esse resultado, primeiro avaliamos as expressões relacionais isoladamente, ou seja:
1. 2+2 > 3*3 é falso (0).
2. 3*4==12 é verdadeiro (1).
Em seguida, vemos qual operador lógico está entre as expressões relacionais. Neste 
caso é o não, representado pelo ||. Se verificarmos a tabela apresentada, veremos 
que 0 || 1 resulta em 1, que é verdadeiro. Portanto, a expressão composta do 
exemplo tem resultado verdadeiro.
6
Como visto anteriormente, os operadores lógicos devem ser 
usados sempre que tivermos uma condição representada por mais 
de um operador relacional. Isso se evidencia pelo exemplo a seguir: 
digamos que as variáveis a, b e c tenham todos o mesmo valor, por 
exemplo, 10. A expressão a==b==c terá falso como resultado.
Atenção
Para evitarmos isso, em vez de escrever no código a expressão a==b==c, o correto 
será escrever a==b && b==c. Assim, ambas as expressões relacionais resultam em 
verdadeiro (1). Por consequência, a expressão composta será também 1, já que 1 && 
1 sempre resulta em verdadeiro.
Finalmente, em expressões compostas, a ordem de avaliação dos operadores é: 
operadores aritméticos, operadores relacionais e operadores lógicos.
Tanto o entendimento quanto o uso dos operadores lógicos são importantes para 
a compreensão de algoritmos e linguagens de programação. Os operadores são 
usados especialmente para controle de fluxo de execução dos programas.
Estrutura de seleção simples
Até o momento, vimos algoritmos que agem sequencialmente e sem interrupções 
ou desvios em seu fluxo. Nesses exemplos, os algoritmos executam sempre da 
mesma maneira. Entretanto, não é assim que ocorre nos sistemas de forma geral. 
Normalmente, baseados em algum dado, resultado de expressões simples ou 
compostas, os algoritmos executam uma ou outra ação.
A primeira forma de seleção é a seleção simples. Na figura a seguir, temos uma 
noção de como ela funciona nos algoritmos:
7
Estrutura de seleção simples 
. . .
. . .
V
Condição
Comando -1 Comando -2
F
Fonte: Pereira (2016, p. 37).
Observe que o algoritmo encontra uma condição a ser avaliada: caso seja verdadeira, 
executa o comando 1 (à esquerda); caso a condição resulte em falso, executa o 
comando 2 (à direita). Não há possibilidade de execução dos dois comandos, ou um 
ou outro. Na linguagem C, a seleção simples tem a seguinte sintaxe:
If (condição) comando1
Else comando2
Aqui, deparamo-nos inclusive com uma palavra reservada do C muito utilizada: 
else. Em português, ela significa senão, o que facilita bastante o entendimento da 
estrutura. Assim, podemos ler a estrutura do exemplo dessa forma:
Se condição for verdadeira, faça o comando 1
Senão faça o comando 2
Um aspecto muito importante em algoritmos e codificação nas linguagens de 
programação é a identação. Termo referente ao posicionamento dos comandos em 
relação às linhas e colunas de texto e facilita a legibilidade do código. Os exemplos 
já mencionados não usam identação, mas é recomendável que usem, deste modo, o 
exemplo identado fica:
Se condição for verdadeira 
faça o comando 1 Senão 
faça o comando 2
8
Repare que é a mesma estrutura, porém, sua leitura é bem mais fácil.
Para ilustrar, vamos fazer um algoritmo para calcular o Índice de Massa Corpórea 
(IMC) de uma pessoa. Esse índice é calculado pela divisão do peso em kg da pessoa 
pelo quadrado de sua altura em metros. Se o índice for maior que 30, trata-se de uma 
pessoa obesa. O algoritmo do programa segue os seguintes passos:
Passo 1
Digite o peso.
Passo 2
Digite a altura.
Passo 3
IMC = peso / altura²
Passo 4
Se IMC < 30,0 exibir “Peso normal”
Passo 5
Se não for, exibir “Acima do peso ideal”
9
O código equivalente em C seria este:
/* imc.c - calcula índice de massa corporal */
#include <stdio.h> #include<math.h> 
int main(void) {
	 	 	float	peso,	altura,	imc;			
	 	printf(“Digite	o	Peso”);	
			 scanf(“%f”,	&peso);
				 	printf(“Digite	a	Altura”);
				 	scanf(“%f”,	&altura);imc	=	peso	/	pow(altura,2);
				 	printf(“IMC	=	%.2f\n”,	imc);				 	if(	imc	>	30.0	)
				 		 printf(“Obeso\n”);				 	else	
			 	printf(“Peso	normal\n”);					
return 0
};
Existem situações peculiares no uso de estruturas de seleção. Nos exemplos 
citados, vimos estruturas que irão executar um comando em cada caso. No entanto, 
nem sempre isso precisa ocorrer. Há cenários em que:
• Serão executados vários comandos, ainda que a condição seja verdadeira ou 
falsa.
• Não há qualquer comando a executar quando a condição é falsa.
São situações perfeitamente possíveis nos algoritmos. Na linguagem C, a 
representação de vários comandos tem as sintaxes mostradas na figura a seguir.
Estrutura de seleção simples com vários comandos em C
Fonte: Pereira (2016, p. 39).
10
Quando não há comandos para executar, não há necessidade da instrução else, 
conforme o exemplo a seguir:
if( condição )
	 			 comando;;
É o que chamamos de omissão de alternativa. No próximo exemplo, veremos o 
uso de condição com vários comandos e omissão de alternativa. Suponhamos que 
uma empresa paga R$ 30,00/hora de trabalho; quem recebe acima de R$ 3 mil tem 
um desconto de 17% relativo ao imposto de renda. Para salários até R$ 3 mil, esse 
desconto não ocorre. Assim, vamos ver o algoritmo que, ao informarmos o número 
de horas trabalhadas por um empregado, retorne o desconto do imposto – caso 
exista – e o salário líquido da pessoa. Veja:
1. Informar as horas trabalhadas e armazenar em horas.
2. salario = 30.0 * horas
3. Se salario for maior que 3000.00 faça
a. desconto = 0.17 * salario
b. Informe: “Desconto = R$” desconto
c. salario = salario – desconto
4. Informe: “Salário Líquido = R$” salario 
O respectivo código em C seria este:
/* salario.c - calcula o salário pago a um empregado */
#include 
<stdio.h> int 
main(void) {
	float	horas,	salario,	desconto;
	printf(“Digite	as	horas	trabalhadas	“);
		scanf(“%f”,	&horas);		salario	=	30.0*horas;
		if(	salario	>	3000.00	)	{		desconto	=	0.17*salario;
	printf(“Desconto	=	R$	%.2f\n”,	desconto);
	salario	=	salario	-	desconto;
 }
	printf(“Salário	Liquido=	R$	%.2f\n”,	salario);		return	0;
}
11
Seleções encadeadas
As estruturas de seleção simples podem ser usadas uma dentro das outras, 
formando o que chamamos de estrutura encadeada ou aninhada, dando à estrutura 
de seleção um poder ainda maior de codificação.
Suponhamos o seguinte cenário: em uma faculdade, o aluno pode ter no máximo 39 
faltas e deve alcançar no mínimo a média de 6.0 para ser aprovado. Caso tenha 40 
ou mais faltas, ele estará reprovado, independentemente de sua nota. Do contrário, 
se não atingir a média 6.0, deverá fazer uma recuperação. Veja o fluxograma (figura a 
seguir) que representa o algoritmo desse problema:
Fluxograma de algoritmo para estrutura de seleção encadeada
“Aprovado”
f ≤ 40 
m ≥ 6.0 
“Recuperação”
“Reprovado”
Fim
Início
“Média?”
“Faltas?”
h
f
1
1
V V
V F
Fonte: Pereira (2016, p. 41).
Observemos que a primeira condição a ser avaliada é o número de faltas do 
estudante. Se for maior ou igual a 40, atribuirá reprovação ao aluno e encerra o 
algoritmo. Se ele tiver 39 faltas ou menos, irá verificar sua média de nota. Se a média 
for menor que 6.0, será apontado para recuperação; se a média for 6.0 ou superior, o 
aluno está aprovado.
Esse exemplo ilustra uma estrutura simples dentro de outra: a estrutura encadeada. 
Acontece quando o algoritmo verifica que a condição de 39 faltas ou menos é 
verdadeira; nesse caso, verifica uma segunda condição, a da média da nota do 
estudante. O programa equivalente em C seria:
12
/* sit1.c - determina a situação de um aluno */
#include <stdio.h> 
int main(void){
	 float	m;		int	f;
	 printf(“Média?	“);		
	 scanf(“%f”,	&m);		
	 printf(“Faltas?	“);		
	 scanf(“%d”,	&f);		
 if( f <= 40 )
 if( m >= 6.0 )
	 			 	 	 printf(“Aprovado\n”);
 else
	 	 	 	 	printf(“Recuperação\n”);	
 else
			 	 	 	 printf(“Reprovado\n”);		
	 return	0;
}
Fechamento
As Expressões Condicionais viabilizam aos softwares tratarem situações reais 
em que as decisões podem variar de acordo com o contexto ou com a opinião do 
usuário. Sem esse recurso, todo algoritmo seria capaz de tratar apenas uma única 
situação sem quaisquer variações.
13
Referências
CORMEN, T. H. et al. Algoritmos: teoria e prática. 3. ed. Rio de Janeiro: Elsevier, 2012. 
PEREIRA, S. L. Estruturas de dados em C: uma abordagem didática. São Paulo: Érica, 
2016.