Estrutura do algoritmo

1 Introdução
Toda linguagem de programação segue uma estrutura determinada, com comandos
estabelecidos que “dizem” ao computador o que deve ser feito.

1.1 Estrutura de um algoritmo em C

Conceitualmente, a linguagem C é baseada em blocos de construção. Assim sendo,
um programa em C nada mais é que um conjunto de funções básicas ordenadas pelo
programador. Cada função C é na verdade uma sub-rotina que contém um ou mais
comandos em C e que executa uma ou mais tarefas. Em um programa bem escrito, cada
função deve executar uma tarefa.
Todo o programa em C deve conter a função main( ). Esta função é responsável pelo
início da execução. No C só existem funções e não existe o conceito de procedimento. Os
comentários no C são feitos através do par “/*” e “*/”, sendo um “/*” usado para abrir um
comentário e um “*/” para encerrá-lo. Um bloco de comandos é delimitado por chaves (“{“ e
“}”).
Todos os comandos em C devem ser escritos em letras minúsculas

1.2 Esquema do Algoritmo em Linguagem C:

#include <stdio.h> /* declaração das bibliotecas usadas */
/* Declaração de funções do programador, se for o caso */
/* Declaração de variáveis globais */

main()
{ /*Declaração da função principal. Sempre necessária*/
/*Declaração de variáveis locais a esta função */
/*Seção de comandos ... */
}

Funcao1()
{ /*Declaração de outra função se for o caso*/
/*Declaração de variáveis locais a esta função */
/*Seção de comandos ... */
}
:
:

1.3 Comandos e Blocos em Linguagem C

Uma expressão tal como x = 0 ou i++ ou printf(...) torna-se um comando quando
seguida por um ponto-e-vírgula, como em:
x = 0; i++; printf (“Olá !”);

1 / 21
 Em C, o ponto-e-vírgula é um terminador de comandos e as chaves { e } são usadas
para agruparem declarações e comandos num comando composto ou bloco de modo que
são sintaticamente equivalentes a um único comando. Não há um ponto-e-vírgula após a
chave direita que termina um bloco.

1.4 Teste de Mesa

Um algoritmo, depois de ser elaborado, pode (e deve) ser testado. Para tal, é utilizado
um método conhecido como teste de mesa, que simulação todos os passos, ou seja,
entradas, comandos e instruções do algoritmo, para verificar se os resultados são os
esperados e se a lógica está correta. Para tal, preenche-se uma tabela com valores para
todas as variáveis existentes no algoritmo e segue-se o fluxo de execução, simulando cada
uma das instruções, ou seja, fazendo exatamente o que o computador faria se o programa
fosse executado. Deve-se fazer uma coluna para cada variável e uma coluna para saída de
dados.
Inicialmente, adota-se um conjunto de dados de teste correspondentes aos valores
que o usuário digitará quando utilizar o programa. A primeira coluna da tabela representa a
linha de programa sendo executada e cada uma das outras representa uma variável. A
simulação começa, então, com a execução do programa, linha por linha. À medida que um
comando leia é executado ou que uma atribuição é feita, escreve-se na coluna
correspondente à variável o valor digitado ou calculado, naturalmente “substituindo” o valor
que havia lá anteriormente.
Se, para uma instrução executada, uma ou mais variáveis não ficaram com os valores
esperados, há um erro na lógica do algoritmo.
Exemplo
Considerando o algoritmo abaixo, faça um teste de mesa supondo que o usuário entre
com os números 5 e depois 15 quando solicitado.
Os comandos do algoritmo estão mostrados na coluna 1 da tabela. As outras colunas
correspondem às variáveis declaradas: A, B e C e a última coluna corresponde à saída de
dados do problema.

1 //Algoritmo “Teste de Mesa”

2 main() {
3 int A,B,C; A B C Saída
4 scanf(“%f”, &A); 5 - -
5 scanf(“%f”, &B); 5 15 - -
6 C = A + B; 5 15 20 -
7 printf(“%f %f”,B,C) 5 15 20 15 20
8 if (C % A == 0 ) { 5 15 20 -
9 A = C / A 4 15 20 -
10 B = C / B 4 1 20 -
11 C = A + B } 4 1 5 -
12 else {
13 A = C % A
14 B = C % B
15 C = A – B
16 } 4 1 5 -
17 printf(“%f %f %f”,A,B,C) 4 1 5 4 1 15
18 }

2 / 21
 Para simular a execução do programa deve-se seguir passo a passo o algoritmo e
agir com se fossemos o próprio computador. Assim, para cada passo do programa teremos:
linha 3: as variáveis foram declaradas e seus nomes foram colocados nas colunas. Embora a
coluna Saída não corresponda a nenhuma variável declarada refere-se à impressão na
tela.
linha 4: o usuário digita o valor da variável A (5) e seu valor é colocado na coluna
correspondente. As outras variáveis permanecem indeterminadas.
linha 5: o valor da variável B é lido e colocado na coluna correspondente. O valor de A é
repetido, indicando que esta variável não foi alterada. O valor de C permanece
indeterminado.
linha 6: o valor da soma de A e B é atribuído à variável C e seu valor colocado na coluna
correspondente. As outras colunas são repetidas.
linha 7: o comando printf() é executado e na coluna Saída os valores de B e C são colocados
como se fosse a impressão na tela
linha 8: o teste lógico C % A == 0 (C modulo A == 0) é executado resultando em
VERDADEIRO e, embora não altere os valores da tabela, indica quais os próximos
passos que o computador irá executar, ou seja, o bloco verdade será processado.
linha 9: o valor de C / A é igual a 4 e atribuído à variável A e,portanto, colocado na coluna
correspondente, substituindo o valor 5. Os valores das outras variáveis não são alterados.
linha 10: o valor de B / A é igual a 1, atribuído a B e substitui o valor 1. Os valores de A e C não
são alterados e são repetidos nesse passo.
linha 11: o valor de A + B = 4 + 1 = 5 é colocado na coluna C substituindo o valor 20.
linha 12 a 16: essas linhas não são processadas, pois correspondem ao bloco falsidade. Logo,
depois da linha 12, o computador vai para o fim do bloco if else
linha 17:novamente o comando printf() é processado e os valores de A, B, C, são impressos.
linha 18: final do algoritmo.
No exemplo acima, o teste de mesa foi realizado considerando que os valores
digitados pelo usuário resultaram em um teste lógico verdadeiro e os comandos do bloco
verdade da estrutura if..else foram executados. Porém, a simulação do algoritmo precisa
testar todas as possibilidades do programa e verificar se os resultados de todas as opções
estão de acordo com o esperado.
Assim, repetindo o teste com os valores 7 e 15 temos como resultado do teste lógico
C % A == 0 (1 == 0) o valor FALSO e, portanto, são executados os comandos do bloco
falsidade, ou seja, as linhas 13, 14, 15 e 16. Neste caso, as linhas 10 a 12 não são
processadas e são “puladas” pelo computador.
Logo, refazendo o teste de mesa anterior com os números 7 e depois 15 digitados
pelo usuário, teríamos o resultado mostrado na Simulação 2:
1 //Algoritmo “Teste de Mesa”
2 main() {
3 int A,B,C; A B C Saída
4 scanf(“%f”, &A); 7 - -
5 scanf(“%f”, &B); 7 15 - -
6 C = A + B; 7 15 22 -
7 printf(“%f %f”,B,C) 7 15 22 15 22
8 if (C % A == 0 ) { 7 15 22 -
9 A = C / A
10 B = C / B
11 C = A + B }
12 else { 7 15 22 -

3 / 21
13 A = C % A 1 15 22
14 B = C % B 1 7 22
15 C = A – B 1 7 -6
16 } 1 7 -6 -
17 printf(“%f %f %f”,A,B,C) 1 7 -6 1 7 -6
18 }

Lembre-se: Divisão Inteira e Módulo

São operadores aritméticos que resultam no quociente de uma divisão inteira e no
resto desta divisão respectivamente.
Sabendo que:
Divisão: Dividendo Divisor

Resto Quociente

Assim, no exemplo abaixo: 132 / 40 = 3 e 132 % 40 = 12

4 / 12 = 0 e 4 % 12 = 4
12 / 4 = 3 E 12 % 4 = 0

div
132 40 4 12 12 4
12 3 4 0 0 3

mod

OPERADOR
PORTUGUÊS C DESCRIÇÃO
ESTRUTURADO
% ou mod % Módulo ou resto da divisão inteira
\ ou div / Quociente da divisão inteira (ver Obs1.)
Obs1.: Na linguagem C, quando as variáveis são declaradas como int (inteiras),
o quociente da divisão também é inteira. Se as variáveis forem declaradas como float,
este quociente será real e não existe % (mod).
Exemplos
int a = 15, b = 4, c, d; float a=15.0, b = 4.0, c, d:;
c = a / b // c = 3 c = a / b // c= 3.75
d = a % b // d = 3 d = a % b // ERRO!!!

ATENÇÃO : NÃO CONFUNDA % COM PORCENTAGEM

Em programação o símbolo % significa módulo. A porcentagem é escrita através de
uma expressão matemática. Por exemplo: 10% → 10/100, 7% → 7/100

4 / 21
ESTRUTURAS DE CONTROLE DE FLUXO
As estruturas de controle permitem controlar a seqüencia das ações lógicas de um
programa. Basicamente, existem três tipos de estruturas : estruturas seqüenciais, estruturas
iterativas ou de repetição e estruturas de decisão ou condicionais., sendo que as estruturas
de controle de fluxo são basicamente as repetitivas e as condicionais.
A estrutura de repetição permite que um bloco de instruções seja executado
repetidamente uma quantidade controlada de vezes. A estrutura de condicional permite
executar um entre dois ou mais blocos de instruções.
Em todas as estruturas de controle, existe pelo menos uma expressão que faz o
controle de qual bloco de instruções será executado ou quantas vezes ele será executado,
chamada de condição de controle. Uma condição de controle é uma expressão lógica ou
aritmética cujo resultado pode ser considerado verdadeiro ou falso.

1 Estrutura Sequêncial
Num algoritmo, os comandos são executados em seqüencia linear, seguindo-se o
texto em que estão escritos. A figura 1 mostra do diagrama de blocos de uma estrutura
seqüencial. É um modelo tradicional de desenvolvimento e resolução de problemas. Os
elementos são organizados por uma só propriedade e tem um só antecessor e um só
sucessor. Cada elemento é executado passo a passo de cima para baixo

Instrução 1

Instrução 2

Instrução 3

Figura 1 – Estrutura Seqüencial

Exemplo – Média Ponderada - Estrutura Seqüencial

O algoritmo abaixo calcula a média ponderada das notas de um aluno. Os pesos dos
1º, 2º, 3º e 4º bimestres são 1, 2, 3 e 4, respectivamente.
A média ponderada é calculada multiplicando a nota de cada bimestre pelo peso
correspondente e dividindo o total pela soma dos pesos, ou seja:

Média=(Nota1*1+Nota2*2+Nota3*3+Nota4*4)/(1+2+3+4)

5 / 21
PORTUGUÊS ESTRUTURADO LINGUAGEM C
algoritmo “Média Ponderada” #include <stdio.h>
int main ( )
var {
N1, N2, N3, N4, Media : real float N1, N2, N3, N4,Media;
inicio
escreva(“Entre com as notas”) printf(“Entre com as notas”);
leia(N1, N2, N3, N4) scanf(“%f%f%f%f”, &N1,&N2, &N3,&N4);
Media<-(N1*1+N2*2+N3*3+N4*4)/10 Media=(N1*1+N2*2+N3*3+N4*4)/10;
escreval(“Média é: ”,Media) printf(“Media é %f\n”,Media);
return 0;
fimalgoritmo }

2 Estrutura Condicional
As decisões são tomadas a todo o momento baseadas em uma situação existente
que possibilita a escolha entre dois ou mais procedimentos. Em um algoritmo, esta situação
é chamada de condição. Associada a uma condição, existirá sempre uma alternativa
possível de ações.
Os comandos de decisão ou desvio fazem parte das técnicas de programação que
conduzem a estruturas de programas que não são totalmente seqüenciais. Com instruções
de SALTO ou DESVIO pode-se fazer com que o programa proceda de uma ou outra
maneira, de acordo com as decisões lógicas tomadas em função dos dados ou de resultados
anteriores. As principais estruturas de decisão são:

“ se ... entao ”, “ se... entao ... senao ” e “ escolha ... caso ” ↔ Port Estr.

“ if ”,” if … else “, “if…else if ”, ” switch … case ” ↔ Linguagem C

As estruturas condicionais permitem a escolha do grupo de ações e estruturas a ser

executado quando determinadas condições, avaliadas através de expressões lógicas ou
relacionais, são ou não satisfeitas.
Expressão: é uma seqüência de operadores lógicos, relacionais, aritméticos e
valores. Pode possuir atribuições e chamadas de funções, que serão interpretadas como
valores comuns e devem vir entre parênteses. Na atribuição o valor avaliado é o valor
atribuído e na chamada de função é o valor retornado. Também podemos ter listas de
comandos dentro de uma expressão, separados por vírgulas (“,”), que serão avaliados da
esquerda para a direita, sendo o último comando aquele que indicará o valor a ser
interpretado na expressão.

Exemplos
((soma = 5 + 3) <= 10)
((ch=getch( )) == 'Q')
(oldch=ch,ch=getch( ))
→ Expressão. avaliada : 8 <= 10
→ Expressão avaliada : ch == 'Q'
Antes é executada ch=getch( ) e
depois é feita a comparação
→ Expressão avaliada : ch != 0

6 / 21
 OBS: em C não existe a variável lógica. Se o resultado obtido pela expressão avaliada
em uma estrutura condicional for igual a ZERO, o resultado da expressão é FALSO,
qualquer valor diferente de ZERO resulta em uma expressão VERDADEIRA.
As Estruturas Condicionais são também conhecidas por Estruturas Seletivas ou
Estruturas de Decisão ou ainda, Estruturas de Desvio Condicional

2.1 . Estrutura Condicional Simples

As instruções de execução condicional dependem da avaliação de uma expressão
condicional. Esta expressão pode ser composta por uma ou várias operações, que são
efetuadas através dos operadores lógicos e relacionais.
Na estrutura condicional simples a condição é avaliada e, se o resultado for
VERDADEIRO, o bloco verdade, que corresponde a uma lista de comandos associados ao
teste lógico, é executado. Caso o teste retorne FALSO, nenhum comando do bloco será
executado e o programa processa o primeiro comando após o final da estrutura, desviando a
execução do bloco verdade. A figura abaixo mostra o diagrama de blocos desta estrutura.

F V
Condição

Instruções executadas
quando a condição é
verdadeira

Instruções executadas quando

a condição é falsa ou após ser
verdadeira

Figura 2 – Estrutura Condicional Simples

SINTAXE: PORTUGUÊS ESTRUTURADO

Comando se .. entao
se <condição> entao
<lista de comandos> // bloco verdade
fimse

SINTAXE: LINGUAGEM C

Comando if
if <condição> {
<lista de comandos> // bloco verdade
}

7 / 21
 Conforme mencionado anteriormente, no "C" a expressão condicional pode devolver
um valor, que terá o seguinte significado :

0 – FALSO
Não Zero - VERDADE.

Ou seja, se o resultado da expressão referente à condição retornar um valor igual a

zero, os comandos do bloco verdade não são executados. Por outro lado, se o resultado for
qualquer valor diferente de zero, os comandos do bloco verdade serão executados.
Na linguagem C, qualquer expressão válida pode ser usada para controlar a
declaração if. Isto é, o tipo de expressão não precisa se restringir àquelas envolvendo
operadores relacionais e lógicos. A expressão precisa retornar um valor zero ou não zero.
Por exemplo, o programa abaixo lê dois inteiros do teclado e mostra o quociente. Para evitar
um erro de divisão por zero, uma declaração if é usada para controlar o segundo número.

/* Divide o primeiro número pelo segundo*/

#include <stdio.h>
int main(){
int a, b;
printf (“Informe dois números: ”);
scanf (“%d%d”, &a, &b);
if ( b ) printf (“%d\n”, a/b);
else printf (“Não posso dividir por zero\n”);
}

Essa abordagem funciona porque, se b for zero, a condição controlando o if é falsa e

a instrução else é executada. Caso contrário, a expressão é verdadeira (não zero) e a
divisão é realizada. Observe que a declaração if abaixo não é necessária, pois é redundante.

if ( b != 0 ) printf (“%d\n”, a/b);

Para testar igualdades é usado o operador “==” e não “=”, pois o operador “=”
representa apenas uma atribuição. Se fosse escrito: if (num=10), o compilador iria atribuir o
valor 10 à variável num e a expressão num=10 iria retornar 10, fazendo com que o valor de
num fosse sempre igual a 10 e a declaração fosse executada sempre.
Os operadores de comparação são: ==, >, <, >= , <= .
Lembre-se que , quando o compilador avalia uma condição, ele quer um valor de
retorno para poder tomar a decisão, mas que, em C, esta expressão não necessita ser uma
expressão no sentido convencional. Uma variável sozinha pode ser uma expressão que
retorna o seu próprio valor. Isto quer dizer que teremos as seguintes equivalências:

int num; int num;

if (num!=0)... equivalem a if (num)
if (num==0)... if (!num)

8 / 21
Exemplo – Média Ponderada - Estrutura Condicional Simples

Considere o algoritmo desenvolvido no exemplo de estrutura seqüencial que calcula a

média ponderada das notas de um aluno. Suponha que, agora, o programa deverá informar,
além da média, se o aluno foi aprovado. A média para a aprovação é 7.0.

PORTUGUÊS ESTRUTURADO LINGUAGEM C

Algoritmo “Média Ponderada” #include <stdio.h>
int main ( )
var {
N1, N2, N3, N4, Media : real float N1, N2, N3, N4,Media;
inicio
escreva(“Entre com as notas”) printf(“Entre com as notas”);
leia(N1, N2, N3, N4) scanf(“%f%f%f%f”, &N1,&N2,
&N3,&N4);
Media<-(N1*1+N2*2+N3*3+N4*4)/10 Media=(N1*1+N2*2+N3*3+N4*4)/10;
se (Media >= 7) entao if (Media >= 7)
escreva(“Você foi aprovado. ”) printf (“Você foi aprovado “);
fimse
escreval(“Média: ”,Media:4:2) printf(“Media: %4.2f\n”,Media);
return 0;
fimalgoritmo }

Neste exemplo, supondo que a média do aluno tenha sido igual a 8.00, ou seja, maior
que sete (Media>=7), a mensagem impressa na tela será: “ Você foi aprovado. Média 8.00”.
Se a média do aluno é menor que sete, por exemplo 4.0, a mensagem será: “Média 4.00”. A
formatação nos comandos escreva (:4:2)e printf (4.2) resultam na impressão da média com
quatro algarismos e duas casas decimais.
Note que em C, não foram usadas chaves no comando if. Assim, o único comando
associado à estrutura if é o printf(“Você foi aprovado”). O comando printf(“Média: %4.2f\n”,
Media) será executado de qualquer maneira.

2.2 . Estrutura Condicional Composta

Na estrutura condicional composta, para uma mesma condição existem duas

alternativas possíveis, ou seja, para um mesmo teste lógico podemos ter dois blocos de
comandos diferentes, que poderão ser processados ou não, dependendo do resultado do
teste. Um bloco só será executado se o outro não for. Assim, se a condição for verdadeira, o
bloco verdade será executado e o outro bloco, denominado “bloco falsidade”, não. Por outro
lado, se a condição for falsa, o bloco que será executado é o bloco falsidade, desviando a
execução do programam do bloco verdade. A figura abaixo mostra o diagrama de blocos
desta estrutura.

9 / 21
 F V
Condição

Instruções executadas Instruções executadas

quando a condição é quando a condição é
falsa verdadeira

Instruções executadas após o

desvio, independente do
resultado do teste

Figura 3 – Estrutura Condicional Composta

SINTAXE: PORTUGUÊS ESTRUTURADO

Comando se .. entao .. senao

se <condição> entao
<lista de comandos> // bloco verdade
senão
<lista de comandos> // bloco falsidade
fimse

SINTAXE: LINGUAGEM C

Comando if...else

if <condição> {
<lista de comandos> // bloco verdade
}
else {
<lista de comandos> // bloco falsidade
}

Se condição for verdadeira (qualquer coisa diferente de 0), o bloco que forma o
destino de if será executado; caso contrário o bloco que forma o destino de else será
executado. Lembre-se que somente o código associado a if ou o código associado à else
será executado, nunca os dois.
O bloco verdade ou o bloco falsidade dos if e else, podem ser um comando simples
ou um bloco de comandos. No primeiro caso as chaves não são necessárias.

10 / 21
Exemplo – Média Ponderada - Estrutura Condicional Composta

Considerando o mesmo exemplo anterior, que calcula a média ponderada das notas
de um aluno. Suponha que, agora, o programa deverá informar, além da média, se o aluno
foi aprovado ou reprovado. Se for aprovado deverá imprimir a mensagem “Parabéns” e, se
reprovado, a mensagem “Estude mais”. A média para a aprovação é 7.0.

PORTUGUÊS ESTRUTURADO LINGUAGEM C

Algoritmo “Média Ponderada” #include <stdio.h>
int main ( )
var {
N1, N2, N3, N4, Media : real float N1, N2, N3, N4,Media;
inicio
escreva(“Entre com as notas”) printf(“Entre com as notas”);
leia(N1, N2, N3, N4) scanf(“%f%f%f%f”,&N1,&N2,&N3,&N4);
Media<-(N1*1+N2*2+N3*3+N4*4)/10 Media=(N1*1+N2*2+N3*3+N4*4)/10;
se (Media >= 7) entao if (Media >= 7) {
escreva(“Você foi aprovado. ”) printf (“Você foi aprovado“);
escreval(“Parabéns”) printf (“Parabéns“); }
senao else {
escreva(“Você foi reprovado.”) printf (“Você foi reprovado“);
escreval(“Estude mais”) printf (“Estude mais\n”);
fimse }
escreval(“Média:”,Media:4:2) printf(“Média: %4.2f\n”,Media);
return 0;
fimalgoritmo }

Neste caso, se a condição (Media >= 7) for verdadeira os comandos associados ao

se...entao (ou if) serão executados. Por outro lado, se a condição for falsa, serão executados
apenas os comandos associados ao senao (ou else). Para qualquer alternativa, a última
instrução de impressão da média também será executada. Por exemplo, se a média for 8.00,
serão impressas as mensagens:
Você foi aprovado. Parabéns.
A média é: 8.00
Porém, se a média for 4.00, teremos:
Você foi reprovado. Estude mais.
A média é: 4.00

2.3 . Estrutura Condicional Encadeada

Utilizada em casos onde é necessário verificar diversas condições sucessivamente.

Normalmente, esta estrutura ocorre quando uma determinada ação (ou bloco) deve ser
executado se um conjunto de condições for satisfeito. Nestes casos, a ação de um programa

11 / 21
só pode ser executada se um conjunto anterior de condições for verificado. Assim, verifica-
se a possibilidade de usar uma condição dentro de outra condição, o que leva a uma
estrutura de decisão encadeada ou aninhada.
Pode-se construir uma estrutura condicional encadeada de diversas formas.
Pode-se citar as estruturas encadeadas heterogêneas, quando não é identificado um
padrão lógico, e as homogêneas, que seguem um padrão determinado.
A figura abaixo mostra o diagrama de blocos para estas estruturas

V F
Condição 1

Condição 2
V F

Instruções executadas Instruções executadas

quando a condição 1 é Instruções executadas
quando as condição 1 é
verdadeira quando as condições 1 e
falsa e a condição 2 é
2 são falsas
verdadeira

Instruções executadas após o

desvio, independente do
resultado dos testes

Figura 4 – Estrutura Condicional Encadeada

SINTAXE: PORTUGUÊS ESTRUTURADO

Comando se ... senao...se

se <condição1> entao
<lista de comandos> // bloco verdade da condição1
senao
se <condição2> entao
<lista de comandos> // bloco verdade condição2
senao
<lista de comandos> // bloco falsidade-todas as condições
fimse
fimse

12 / 21
SINTAXE: LINGUAGEM C

Comando if...else if

if (condição_1) {
<lista de comandos1> // bloco verdade-condição1
}
else if (condição_2) {
<lista de comandos2> // bloco verdade-condição 2
}
:
:
:
else if (condição_n) {
<lista de comandosN> // bloco verdade-condição N
else (comando_default) // bloco falsidade-todas as
condições
As expressões condicionais são avaliadas de cima para baixo. Assim que uma
condição verdadeira é encontrada, o bloco associado a ela é executado e o resto do
encadeamento é ignorado.
A estrutura acima funciona da seguinte maneira: o programa começa a testar as
condições começando pela 1 e continua a testar até que ele ache uma expressão cujo
resultado dê diferente de zero.Se nenhuma das condições for verdadeira, então o else final
(opcional) e o comando_default são executados. Se o else final não estiver presente e todas
as outras condições forem falsas, nenhuma ação é realizada.
Pode-se usar o encadeamento if-else-if para evitar a avaliação sucessiva de cada
declaração if existente no algoritmo e, portanto, evitar que cada declaração if seja avaliada,
mesmo se uma das declarações anteriores já tenha tido êxito. Uma avaliação redundante de
todos os ifs não é muito eficiente e no encadeamento if-else-if, tão logo uma declaração if é
satisfeita, o resto das declarações é ignorado.
OBS.: A declaração if (condição) não tem ponto e vírgula após o parênteses.
Somente os comandos ou o comando associados à declaração devem ter ponto e vírgula no
final. As chaves de abertura e encerramento de blocos ({ }) são usadas quando houver mais
do que um comando associado ao if ou mais do que um comando associado ao else.
Pode-se ter quantas estruturas encadeadas forem necessárias para o
desenvolvimento do algoritmo. Embora existam outras formas de encadeamento a estrutura
if..else...if é a mais utilizada, pois cada comando só é realizado se houver uma combinação
dos resultados de todos os testes lógicos executados.
O exemplo abaixo mostra um trecho de algoritmo onde a variável X pode assumir os
valores: V1, V2, V3, V4 e V5.

// Algoritmo “Encadeamento”
int X;
if ( X == V1 )
X = C1;
else if ( X == V2 )
X = C2;
else if (( X == V3 ) || ( X == V4 ))

13 / 21
 X = C3;
else if ( X == V5)
X = C4;
else
X = C5;

A tabela abaixo mostra os comandos que serão executados dependendo das diversas
possibilidades de resultados dos testes lógicos. Somente um e apenas um comando pode
ser executado.Isto é, trata-se de uma situação excludente ( se X é igual a V1, não é igual a
V2, nem a V3, nem a V4 e nem a V5)

X = V1 X = V2 X = V3 X = V4 X=V3 ou X = V4 X = V5 X=
V - - - - - C1
F V - - - - C2
F F V F V - C3
F F F V V - C3
F F F F F V C4
F F F F F F C5

Trata-se de uma estrutura encadeada, pois as seleções estão interligadas e só

ocorrem os testes necessários para encontrar a primeira condição verdadeira. Quando esta
é encontrada o programa executa o bloco verdade desta condição, o comando fimse
correspondente e, a seguir, os outros comandos do algoritmo (no caso, os outros fimse se
existirem).

Exemplo – Média Ponderada - Estrutura Condicional Encadeada

Suponha que, no exemplo anterior que calcula a média ponderada das notas de um
aluno, o programa deverá informar, além da média, se o aluno foi aprovado ou reprovado.
Se for aprovado deverá imprimir a mensagem “Parabéns” e, se reprovado, a mensagem
“Estude mais”.
Além disso, no caso de reprovação, o programa deve verificar a necessidade de
exame, para médias entre 5.0 e 7.0, ou dependência para médias menores que 5.0. Caso
nenhuma condição seja satisfeita, deve ser informado que os dados são inválidos. A média
para a aprovação é 7.0.

PORTUGUÊS ESTRUTURADO LINGUAGEM C

Algoritmo “Média Ponderada”
var
N1, N2, N3, N4, Media : real
inicio
escreva(“Entre com as notas”)
leia(N1, N2, N3, N4)
Media<-(N1*1+N2*2+N3*3+N4*4)/10
se (Media >= 7) entao
escreva(“Você foi aprovado. ”)
escreval(“Parabéns”)
escreval(“Média: ”,Media:4:2)
senao
#include <stdio.h>
int main ( )
{
float N1, N2, N3, N4,Media;
printf(“Entre com as notas);
scanf(“%f%f%f%f”,&N1,&N2,&N3,&N4);
Media=(N1*1+N2*2+N3*3+N4*4)/10;
if (Media >= 7) {
printf (“Você foi aprovado“);
printf (“Parabéns \n“);
printf (“Média:%4.2f\n”,Media);}
else if (Media >= 5 && Media < 7)

14 / 21
se Media >= 5 e Media < 7 entao {
escreva(“Você não foi printf (“Você não foi
aprovado.”) aprovado“);
escreval(“Estude mais”) printf (“Estude mais \n“);
escreval(“Você ficou para printf (“Você ficou para exame
exame”) \n”);
escreval(“Média: ”,Media) printf (“Média: %f\n”,Media);}
senao else if (Media < 5)
se (Media < 5) entao {
escreva(“Você foi reprovado”) printf (“Você foi reprovado“);
escreval(“Estude mais”) printf (“Estude mais \n“);
escreval(“Você ficou em DP”) printf (“Você ficou em DP \n”);
escreval(“Média é: ”,Media) printf (“Média é:%f\n”,Media);}
senao else
escreval(“Dados inválidos ”) printf (“Dados inválidos \n”);
fimse return 0;
fimse
fimse
fimalgoritmo }
Neste caso, se a condição (Media >= 7) é verdadeira os comandos associados ao
se...entao (ou if) serão executados. Por outro lado, se a condição é falsa, o algoritmo
executa o primeiro comando senao e testa a condição (5 < = Media < 7) (declaração else if).
Se esta condição é verdadeira, o programa imprime as mensagens correspondentes na tela
e salta para o fimse associado. Se esta condição também é falsa, o algoritmo desvia para o
segundo senao do programa e testa a condição (Media < 5). Se esta é verdadeira imprime
as mensagens e vai para o fimse associado e, se a condição também é falsa, o programa
executa o último comando senao, que corresponde a todas as condições falsas e imprime na
tela “Dados inválidos”. Em seguida executa todos os comandos fimse encerrando a
execução.

Por exemplo,:
Se o aluno obteve média 8.0, o resultado impresso na tela é:
Você foi aprovado. Parabéns.
A média é: 8.00
Se a media do aluno é 6.0 temos:
Você não foi aprovado. Estude mais.
Você ficou para exame.
A média é: 6.00
E, se a média é 4.0, teremos imprimido:
Você foi reprovado. Estude mais.
Você ficou em DP
A média é: 4.00
Note que neste caso, diferente dos outros analisados, o comando escreval (“A média
é: “, Media:4:2) foi escrito dentro de cada bloco verdade, ou seja, para cada condição
testada, as mensagens que são impressas na tela estão dentro do bloco verdade
correspondente.
Nos algoritmos anteriores, este comando foi escrito uma vez só, fora de qualquer
bloco, no final do algoritmo. Pode-se verificar nestes casos que, este comando deve ser
impresso qualquer que seja o resultado dos testes lógicos,ou seja, a média do aluno é
impressa independente da condição testada ser verdadeira ou falsa.
No exemplo da estrutura encadeada, vemos que existe uma condição em que esta
instrução não deve ser impressa: quando todos os testes são falsos e os dados são

15 / 21
inválidos. Neste caso, se o comando fosse escrito no final do algoritmo, a impressão na tela
seria:
Dados inválidos
A média é (valor qualquer)
Que estaria em desacordo com o enunciado do problema, pois é para ser impresso
somente:
Dados inválidos.
Pode-se perceber que o if (se) aninhado é simplesmente um if dentro da declaração
de outro if externo. O único cuidado que se deve ter é o de saber exatamente a qual if um
determinado else está ligado.

3 Estrutura de Múltipla Escolha

A estrutura de decisão de múltipla escolha é utilizada para testar, na condição, uma

única expressão que produz um resultado ou, então, o valor de uma variável em que está
armazenado um determinado conteúdo. Compara-se então o resultado obtido no teste com
valores previamente fornecidos.
Em situações que é necessário ter várias soluções ligadas a respostas diferentes, ou
quando precisamos determinar se um valor se encontra numa lista pré-determinada de
valores estas estruturas são mais indicadas. Neste caso, o comando condicional simples ou
composto não é uma solução prática, porque obriga o programador a escrever muitas linhas
de programa, além de ter que criar vários comandos de alternativas compostas e verificar a
validade de suas condições para que o comando execute o caminho correto para uma
determinada condição.
A figura 5 mostra o diagrama de blocos para estas estruturas

switch ( V
Variável de case Constante_1 Lista de Comandos_1
Controle)
F
V
case Constante_2 Lista de Comandos_2

V
case Constante_n Lista de Comandos_n

default Comandos_Default

Figura 5 – Estrutura de Múltipla Escolha

Instruções executadas após o
desvio, independente do
resultado dos testes

16 / 21
SINTAXE: PORTUGUÊS ESTRUTURADO

Comando escolha ... caso

escolha ( expressão-de-seleção )
caso < exp 1 > , < exp 2 >, ... , < exp n >
< lista-de-comandos-1 >
caso < exp 1 > , < exp 2 >, ... , < exp n >
< lista-de-comandos-2 >
outrocaso
< lista-de-comandos-3 >
fimescolha

SINTAXE: LINGUAGEM C

Comando switch … case

switch(variável)
{
case constante_1:
<lista de comandos_1>
break;
case constante2:
<lista de comandos_2>
break;
:
:
case constante_n:
<lista de comandos_n>
break;
default:
<lista de comandos_default>
}

A estrutura switch...case é uma estrutura de decisão que permite a execução de um

conjunto de instruções a partir pontos diferentes conforme o resultado de uma expressão
inteira de controle Assim, uma variável é testada sucessivamente contra uma lista de
variáveis inteiras ou de caracteres (constante_1, constante_2 ...,constante_n). Depois de
encontrar uma coincidência, o comando ou o bloco de comandos é executado. As
constantes não precisam sequer estar em qualquer ordem especial. A declaração default é
executada se nenhuma correspondência for encontrada. O default é opcional e, se ele não
estiver presente, nenhuma ação será realizada se todas as correspondências falharem.
Ainda que as declarações break sejam geralmente necessárias dentro de um switch,
sintaticamente são opcionais. Elas são usadas para terminar a seqüencia de comandos
associada a cada constante. Entretanto, se a declaração break é omitida, a execução
continuará pela próxima declaração case até que um break ou o final do switch seja
encontrado. Observe o programa a seguir:

17 / 21
Exemplo – Escolha ..Caso
Elabore um algoritmo que solicite o nome e a idade de um atleta e imprima a sua
categoria, classificando-o em uma das categorias de acordo com a idade, conforme a tabela
abaixo.

IDADE CATEGORIA
De 05 a 10 Infantil
De 11 a 15 Juvenil
De 16 a 20 Junior

// algoritmo "CLASSIFICAÇÃO DE ATLETAS

include <stdio.h>
main()
{
char nome[40];
int idade;
printf("Nome do Atleta = ")
scanf(nome);
printf("Idade do Atleta = ")
scanf(“%d”, &idade)
switch (idade)
{
case 5: //vários casos resultam no mesmo comando
case 6:
case 7:
case 8:
case 9:
case 10: printf (“Categoria Infantil");
break;
case 11:
case 12:
case 13:
case 14:
case 15: printf (“Categoria Juvenil");
break;
case 16:
case 17:
case 18:
case 19:
case 20: printf (“Categoria Junior");
break;
default:
: printf (“Inválido");
}
}

18 / 21
/* Programa com switch e break */
#include <stdio.h>
int main(){
int t;
for (t = 0; t < 10; t++)
switch (t){
case 1:
printf (“Este”);
break;
case 2:
printf (“é”); // aqui não tem break
case 3:
printf (“o”);
printf (“momento para todos\n”);
break;
case 5: // case vazia
case 6:
printf (“para”);
break;
case 7: // case vazia
case 8: // case vazia
case 9:
printf (“.”);
}
}

Quando executado, o resultado seguinte é produzido:

Este é o momento para todos
o momento para todos
para para...

Pode-se observar que é possível ter declarações case vazias. Isso é útil quanto
muitas condições usam a mesma seqüencia de comandos. A habilidade de os cases serem
executados juntos quando nenhum break está presente permite que programas bastante
eficientes sejam escritos.
Ainda que o encadeamento if-else-if possa realizar testes de múltipla escolha, ele
quase nunca é elegante. O código pode ser muito difícil de acompanhar e pode confundir.
Há alguns pontos importantes sobre a declaração switch:
1. O comando switch..case difere do if, já que o switch pode testar somente
igualdades, enquanto a expressão condicional if pode ser de qualquer tipo, ou
seja, estrutura switch não aceita expressões. Aceita apenas constantes;
2. Nunca duas constantes case no mesmo switch podem ter valores iguais.
Obviamente, uma declaração switch dentro de outra declaração switch pode
ter as mesmas constantes case;
3. Uma declaração switch é mais eficiente que um encadeamento if-else-if, no
caso de valores discretos para as variáveis testadas. No caso de intervalos
contínuos a declaração if pode ser mais eficiente.

19 / 21
Exemplo – Média Ponderada - Estrutura de Múltipla Escolha

O algoritmo do cálculo da média ponderada do aluno, desenvolvido para as estruturas

condicionais simples, composta e encadeada, não pode ser feito utilizando a estrutura de
múltipla escolha, a não ser que utilizemos outras estruturas em conjunto. Isto se deve ao fato
de que os valores possíveis para a lista de variáveis para comparação (case) devem ser
inteiros ou caracteres na linguagem C. Neste exemplo as variáveis são reais.
Assim, para a utilização da estrutura teríamos que ter variáveis inteiras e,
evidentemente, valores discretos de comparação, ou seja, não seria possível comparar o
valor calculado para média com um intervalo (Media>=7, 5<=Media<7 e Media<5).
O exemplo abaixo exibe algoritmos em linguagem C que compara o valor digitado
pelo usuário com o conjunto de números { 5, 6, 7, 8, 10, 13, 14, 15} e informa se o numero é
maior, menor ou igual a 10. São utilizadas as estruturas condicionais simples e composta, na
tabela Ex1 e as estruturas encadeada e de múltipla escolha, na tabela Ex2.

Exemplo 2 – Comparação entre as Estruturas Condicionais

Tabela Ex1
LINGUAGEM C
Estrutura Condicional Simples Estrutura Condicional Composta
#include <stdio.h> #include <stdio.h>
int main ( ) int main ( )
{ {
int num; int num;
printf(“Digite um número”); printf(“Digite um número”);
scanf(“%d”, &num); scanf(“%d”, &num);
if (num == 10) if (num == 10)
{ {
printf ("\n\nVoce acertou!\n"); printf ("\n\nVoce acertou!\n");
printf (“\nO numero e igual a 10"); printf (“\nO numero e igual a 10");
} }
if (num < 10) else
{ {
printf ("\n\nVoce errou!\n"); printf ("\n\nVoce errou!\n");
printf (“\nO numero e menor que 10"); if (num < 10)
} printf (“\nO numero e menor que 10");
if (num > 10) else
{ printf (“\nO numero e maior que 10");
printf ("\n\nVoce errou!\n"); }
printf (“\nO numero e maior que 10"); return 0;
} }
return 0;
}

20 / 21
Tabela Ex2
LINGUAGEM C
Estrutura Condicional Encadeada Estrutura de Múltipla Escolha
#include <stdio.h> #include <stdio.h>
int main ( ) int main ( )
{ {
int num; int num;
printf(“Digite um número”); printf(“Digite um número”);
scanf(“%d”, &num); scanf(“%d”, &num);
if (num == 10) switch (num) {
{ case 5:
printf ("\n\nVoce acertou!\n"); printf ("\n\nVoce acertou!\n");
printf (“\nO numero e igual a 10"); printf (“\nO numero e igual a 10");
} break;
else if (num < 10) case 5:
{ case 6:
case 7:
case 8:
} printf ("\n\nVoce errou!\n");
else printf (“\nO numero e menor que 10");
{ break;
printf ("\n\nVoce errou!\n"); case 13:
printf (“\nO numero e maior que 10"); case 14:
} case 15:
return 0; printf ("\n\nVoce errou!\n");
} printf (“\nO numero e maior que 10");
break;
printf ("\n\nNúmero invalido!\n");
}
return 0;
}

Neste exemplo, pode-se observar que o algoritmo com o comando switch case não é
apropriado para comparações com intervalos contínuos. Nestes casos a declaração if é mais
indicada, conforme explicado no exemplo 1 acima.

21 / 21