PR

UNIVERSIDADE TECNOLÓGICA FEDERAL DO PARANÁ

Estruturas Sequencial e de Controle

Disciplina: Fundamentos de Programação

Curso: Engenharia Mecânica

Professora: Mariza Miola Dosciatti

mariza@utfpr.edu.br
 Objetivos
• Entender o conceito de estruturas de instruções.
• Entender a forma de aninhamento de blocos de
comandos.
• Saber utilizar os operadores lógicos e relacionais em
estruturas de controle.
• Saber utilizar os tipos de estruturas de instruções no
desenvolvimento de algoritmos computacionais.

• Item da ementa (Plano de Ensino):

– Estruturas de controle de fluxo: sequência, decisão e repetição

UTFPR – Computação I 2
 Sumário
• 1. Estruturas de instruções
– 1.1. Tipos de estruturas
• 2. Estrutura sequencial
– 2.1. A biblioteca math.h
• 3. Estruturas de controle
– 3.1. Estrutura de decisão
• 3.1.1. Operadores relacionais
• 3.1.2. Operadores lógicos
• 3.1.3. Precedência de operadores
• 3.1.4. Estruturas de decisão
– 3.2. Estrutura de repetição

UTFPR – Computação I 3
 1. Estruturas de instruções
• Um programa de computador é um conjunto de instruções
definidas de acordo com uma linguagem de programação visando
implementar a solução computacional de problemas.

• As instruções de um programa executadas em sequência,

denominam um fluxo sequencial de execução. Mas, em muitas
circunstâncias é necessário executar essas instruções em uma
ordem diferente da estritamente sequencial.

• Tais situações são caracterizadas pela necessidade de decisão

entre fluxos alternativos de execução ou da repetição de
determinadas instruções.

UTFPR – Computação I 4
 1.1. Tipos de estruturas
• As estruturas definem a maneira como as instruções de um
algoritmo serão executadas.
• Essa maneira está relacionada a sequência com que as
instruções serão realizadas e com a quantidade de vezes que
elas serão realizadas.

• Em uma linguagem de programação estruturada as estruturas

são:
– Sequencial
– De decisão
– De repetição

UTFPR – Computação I 5
 1.1. Tipos de estruturas
fluxo fluxo fluxo
sequencial de execução repetitivo
de execução com desvio de execução

os comandos são os comandos são executados os comandos são executados,

executados um após o dependendo do valor de de forma repetida, um
outro sequencialmente uma condição, ou expressão determinado número
do início ({) até o lógica: de vezes:
final (}) if, if else e switch case for, while e do while

UTFPR – Computação I 6
 2. Estrutura sequencial
• Em uma estrutura sequencial todas as instruções que
compõem o algoritmo ou programa são executadas.
• As instruções são executadas da primeira até a última, na
ordem definida.
• Em todas as execuções do programa, todas as instruções serão
executadas.

UTFPR – Computação I 7
 2. Estrutura sequencial
• Problema:
– Calcular a média de duas notas.

UTFPR – Computação I 8
 2. Estrutura sequencial
• Solução (algoritmo):
– Entrada
• Obter as duas notas para calcular a média.
. Devem ser informados pelo usuário.
. Devem ser armazenados para que possam ser utilizados para realizar o
cálculo.
– Processamento
• Implementar a fórmula para cálculo da média.
. Considerar a prioridade das operações.
– Saída
• Apresentar o resultado.

Esse algoritmo define ações (instruções). E todas as

instruções serão realizadas na ordem em que foram definidas.
É uma estrutura sequencial.

UTFPR – Computação I 9
 2. Estrutura sequencial
• Exemplo: Cálculo da média de duas notas.
início

Ler Nota1
Ler Nota2 entrada

Media <-- (Nota1 + Nota2)/2 processamento

Escrever Media saída Todas as instruções são

executadas na ordem em
fim
que foram definidas

UTFPR – Computação I 10
 2. Estrutura sequencial
Exemplo: Cálculo da média de duas notas.
# include <stdio.h>
int main(void)
{
int Nota1, Nota2, Soma;
float Media;
printf("Informe a primeira nota: ");
scanf("%d",&Nota1);
printf("Informe a segunda nota: ");
scanf("%d",&Nota2);
Soma = Nota1 + Nota2;
Media = Soma / 2.0;
printf("A media aritmetica é %.2f ",Media);
}

UTFPR – Computação I 11
 2.1. A biblioteca math.h
• Fornece um conjunto de funções para operações matemáticas,
tais como funções trigonométricas, hiperbólicas, logaritmos,
potência e arredondamentos.
Função Descrição do comando
floor( ) Arredonda para baixo
ceil( ) Arredonda para cima
trunc( ) Considera apenas a parte inteira do número
round( ) Arredondadomento normal (acima e abaixo de .5)
sqrt( ) Calcula raiz quadrada
pow(variável, expoente) Calcula potenciação
sin( ) Seno
cos( ) Cosseno
tan( ) Tangente
log( ) Logaritmo natural
log10( ) Logaritmo base 10
UTFPR – Computação I 12
 3. Estruturas de Controle
• As estruturas de controle dividem-se em:
– Estruturas de decisão
• Um determinado conjunto de instruções será ou não executado,
dependendo do resultado de um teste lógico.

– Estruturas de repetição
• Um determinado conjunto de instruções será ou não repetido
novamente, dependendo do resultado de um teste lógico.

É necessário obter o resultado de um teste lógico

para determinar se um conjunto de instruções será
executado.

UTFPR – Computação I 13
3.1. Estrutura de Decisão

UTFPR – Computação I 14
 3.1. Estrutura de Decisão
• Problema:
– Fazer a média de duas notas e informar se o valor obtido é
maior ou igual a sete ou se é menor que sete.
– Ações:
• Entrada
– Procedimentos de entrada iguais a estrutura sequencial.
• Processamento
– Implementar a fórmula para cálculo da média.
– Verificar se valor obtido maior ou igual a sete ou se é menor que sete
(condição).
• Saída
– Emitir mensagem informado se valor obtido é maior ou menor que
sete.

UTFPR – Computação I 15
 3.1. Estrutura de Decisão
• Para verificar uma condição é necessário realizar um teste
lógico. Esse teste é realizado por meio operadores
relacionais.
• Expressões relacionais podem ser combinadas utilizando
operadores lógicos.
• O resultado de uma expressão lógica será verdadeiro ou
falso. Independentemente da notação utilizada será sempre a
exclusão mútua entre duas opções.

UTFPR – Computação I 16
 3.1.1. Operadores relacionais
• == igual a
• != diferente de
• > maior que
• < menor que
• >= maior ou igual a
• <= menor ou igual a

Var X Var Y Teste lógico Resultado

X=2 Y=3 X == Y Falso
X=2 Y=3 X != Y Verdadeiro
X=2 Y=3 X >= Y Falso
X=2 Y=3 X<Y Verdadeiro

UTFPR – Computação I 17
 3.1.2. Operadores lógicos
• ! negação lógica
• && “e” lógico, conjunção
• || “ou” lógico, disjunção

Condição1 Condição2 Condição1 && Condição2 Condição1 | | Condição2 ! Condição1

Var1 = 3 Var2 = 3
Var1 > 2 Var2 > 1 V V F
V V
Var1 > 2 Var2 == 2 F V F
V F
Var1 > 5 Var2 > 2 F V V
F V
Var1 > 5 Var2 < 2 F F V
F F

UTFPR – Computação I 18
 3.1.2. Operadores lógicos
• Se chover E não chegar visitas vamos assistir filme.

Chuva Não Visitas Assistir filme

V && V V
V && F F
F && V F
F && F F

UTFPR – Computação I 19
 3.1.2. Operadores lógicos
• Se chover OU não chegar visitas vamos assistir filme.

Chuva Não Visitas Assistir Filme

V || V V
V || F V
F || V V
F || F F

UTFPR – Computação I 20
 3.1.2. Operadores lógicos
• Em C, o resultado da comparação será o valor 0 se o resultado de um teste
lógico é FALSO e um valor 1 se resultado de um teste lógico é VERDADEIRO.
Exemplo:
#include <stdio.h>

int main(void)
{
int verdadeiro, falso;

verdadeiro = (15 < 20);

falso = (15 == 20);

printf("Verdadeiro: %d\n", verdadeiro);

printf("Falso: %d\n", falso);

return 0;
} Saída:
Verdadeiro = 1, Falso = 0
UTFPR – Computação I 21
 3.1.2. Operadores lógicos
• Condição de controle
– Faz o controle de qual conjunto de instruções será executado ou quantas
vezes o conjunto será executado.
– Uma condição de controle é uma expressão lógica ou aritmética cujo
resultado pode ser considerado verdadeiro ou falso.
– Exemplo: Considere as variáveis:
int i = 0, j = 3;
Condição Valor numérico Significado lógico

(i == 0) 1 Verdadeiro

(i > j) 0 Falso

(i) 0* Falso

(j) 1* Verdadeiro

* 0 é falso e qualquer valor diferente de 0 é verdadeiro.

UTFPR – Computação I 22
 3.1.2. Operadores lógicos
• Operador condicional ternário ?:
– Opera sobre três expressões:
Exp 1 ? Exp 2 : Exp 3;

• Exemplo:
max = (a > b) ? a : b;
A variável que contém maior valor entre a e b será atribuída a max.

UTFPR – Computação I 23
 3.1.2. Operadores lógicos
• Operador condicional ternário ?:
• Exemplo:
#include <stdio.h>
int main(void)
{
int numero;
printf("Informe um numero: ");
scanf("%d", &numero);
numero >= 0 ? numero++ : numero--;
printf("O novo valor de numero e: %d",numero);
return 0;
}

UTFPR – Computação I 24
 3.1.2. Operadores lógicos
• Operador condicional ternário ?:
• Exemplo:
#include <stdio.h>

int main(void)
{
int numero;

printf("Informe um numero: ");

scanf("%d", &numero);
numero % 2 == 0 ? printf("Par") : printf("Impar");

return 0;
}

UTFPR – Computação I 25
 3.1.3. Precedência de operadores
• O uso de parênteses altera a precedência dos operadores.
• Operadores de mesma precedência são executados da esquerda para a direita.
Maior precedência () [] ->

! ++ -- -(unário) (cast)
* / %
+ -
< <= >= >
== !=
&&
||
? :
= += -= *= /= %=

Avaliação sequencial, da esquerda para a

Menor precedência
direita
UTFPR – Computação I 26
 3.1.4. Estruturas de decisão (cont.)
• Uma estrutura de decisão permite decidir se um conjunto de
instruções será ou não executado de acordo com
determinadas condições.
• A decisão é feita com base no resultado de um teste lógico
que determina a condição.
• As principais estruturas de decisão são:
• if
• if ... else
• switch ... case

UTFPR – Computação I 27
 3.1.4. Estruturas de decisão (cont.)
• If
– Sintaxe:
if (condição)
{
conjunto de instruções;
}
– onde:
• condição é uma expressão com resultado lógico.
• conjunto de instruções são as instruções (bloco de comandos) a serem
executadas.
• Esta estrutura permite que se execute (ou não) um conjunto
de instruções conforme o valor de uma condição seja
verdadeiro ou falso.

UTFPR – Computação I 28
 3.1.4. Estruturas de decisão (cont.)
• if
Teste lógico (variáveis, constantes,
Palavra-chave expressões aritméticas, retorno de função e
operadores lógicos e relacionais)

if (condição)
{
/*instruções*/
}
O que será realizado se o resultado
do teste lógico for verdadeiro
UTFPR – Computação I 29
 3.1.4. Estruturas de decisão (cont.)
• if

Sim
condição

Não

instruções

onde:
– condição é uma expressão com resultado lógico.
– instruções são os comandos a serem executados.

UTFPR – Computação I 30
 3.1.4. Estruturas de decisão (cont.)
• Exemplos:
if (n == 5)
{
printf("%d é igual a 5", n);
}

if (n < 5)
{
printf("%d é menor que 5", n );
}

if (n <= 5)
{
printf("%d é menor ou igual a 5", n);
}

UTFPR – Computação I 31
 3.1.4. Estruturas de decisão (cont.)
• Exemplos:
if (n < 5 || n > 9)
{
printf("%d está fora do intervalo entre 5 e 9.", n);
}

if (n >= 5 && n <= 9)

{
printf("%d pertence ao intervalo entre 5 e 9.", n);
}

UTFPR – Computação I 32
 3.1.4. Estruturas de decisão (cont.)
• Exemplo:
– Verificar se o valor da variável Nota é maior ou igual a 7. Se
sim, informar "Aprovado".
Em C:
Algoritmo #include <stdio.h>
início int main(void)
{
float Nota;
Leia Nota

Sim
printf("Informe a nota: ");
Nota >= 7 scanf("%f",&Nota);

Escreva Aprovado
if(Nota >= 7)
{
printf("Aprovado");
}
fim
}

UTFPR – Computação I 33
início
 3.1.4. Estruturas de decisão (cont.)
• if else
– Sintaxe:
if(condição)
{
conjunto de instruções 1;
}
else
{
conjunto de instruções 2;
}
• onde:
– condição – teste lógico realizado. É o controle para indicar a finalização da
repetição;
– instruções 1 – comandos (instruções) que são executados se o resultado da
condição for verdadeiro.
– instruções 2 – comandos (instruções) que são executados se o resultado da
condição for falso.
UTFPR – Computação I 34
 3.1.4. Estruturas de decisão (cont.)
• Exemplo:
– Verificar se o valor da Nota é maior ou igual a 7. Se sim, informar
“Aprovado”, se não informar “Reprovado”.
Algoritmo: Em C:
#include <stdio.h>
início int main(void)
{
float Nota;
Leia Nota
printf("Informe a nota: ");
scanf("%f",&Nota);
Não Sim
Nota >= 7 if(Nota >= 7)
{
printf("Aprovado");
Escreva Reprovado Escreva Aprovado
}
else
{
printf("Reprovado");
fim }
}
35
UTFPR – Computação I
 3.1.4. Estruturas de decisão (cont.)
Algoritmo: Em C:
#include <stdio.h>
int main(void)
{
float Nota, NotaRec;
printf("Informe a nota: ");
scanf("%f",&Nota);
if(Nota >= 7)
{
printf("Aprovado\n");
}
else
{
printf("Em recuperacao\n");
printf("Informe nota de recuperacao: \n");
scanf("%f",&NotaRec);
if(NotaRec >= 8)
{
printf("Aprovado apos recuperacao\n");
}
else
{
printf("Reprovado");
}
}
return 0;
}
36
UTFPR – Computação I
 3.1.4. Estruturas de decisão (cont.)
• Exemplo Em C:
#include <stdio.h>
– if ... else if .. else int main(void)
{
float Nota;
printf("Informe a nota: ");
Verificar se o valor da nota: scanf("%f",&Nota);
if (Nota >= 7)
a) É maior ou igual a 7 {
printf("Aprovado\n");
b) Está entre 5 e 7 }
else if (Nota > 5 && Nota < 7)
c) É menor que 5 {
printf("Em recuperacao");
}
else
{
printf("Reprovado");
}
return 0;
}

UTFPR – Computação I 37
 3.1.4. Estruturas de decisão (cont.)
• switch...case - Permite a execução de um conjunto de instruções conforme o resultado
de uma expressão de controle. O resultado desta expressão é comparado com o valor
de cada um dos rótulos, e as instruções são executadas a partir deste rótulo.

• Sintaxe:
switch (expressão)
{
case rótulo_1:
conjunto de instruções 1;
case rótulo_2:
conjunto de instruções 2;
case rótulo_n:
conjunto de instruções n;
default:
conjunto de instruções 3;
}
• onde:
– expressão é uma variável.
– rótulo é uma constante inteira ou um caractere.
– conjunto de instruções são as instruções (bloco de comandos) a serem executadas.

UTFPR – Computação I 38
 3.1.4. Estruturas de decisão (cont.)
• switch...case
– O valor de expressão é avaliado e o fluxo lógico será
desviado para o conjunto cujo rótulo é igual ao resultado
da expressão e todas as instruções seguintes a este rótulo
serão executadas.
– Caso o resultado da expressão seja diferente de todos os
valores dos rótulos, o conjunto default é executado.
– Os rótulos devem ser expressões constantes inteiras
diferentes entre si.
– default é opcional.

UTFPR – Computação I 39
 3.1.4. Estruturas de decisão (cont.)
• Exemplo da estrutura switch ... case
Algoritmo Em C:
#include <stdio.h>
int main(void)
{
char tipo;
printf ("Selecione o sabor da pizza: ");
scanf("%c", &tipo);
switch(tipo)
{
case 'M':
printf("Muzzarela");
break;
case 'C':
printf("Calabreza");
break;
default:
printf ("Opcao incorreta");
}
}
UTFPR – Computação I 40
 3.2. Estruturas de repetição
• Permitem que um conjunto de instruções seja repetido um
determinado número de vezes, até que uma condição se
estabeleça ou enquanto uma condição permanecer atendida.
• A finalização da execução pode ser previamente determinada
ou ser decorrente de condições serem atendidas durante a
execução do programa.
• O controle das execuções está vinculado a condições de
controle.
• Uma condição de controle está relacionada a operadores
lógicos e relacionais. Ela é resultado de um teste lógico.

UTFPR – Computação I 41
 3.2. Estruturas de repetição (cont.)
• Uma estrutura de repetição (loop) se refere a um conjunto de
instruções que são executadas repetidamente enquanto alguma
condição de continuidade dessa repetição permanecer verdadeira.
• A repetição pode:
– Ter o número de repetições conhecido antecipadamente.
– A condição de finalização das repetições é gerada pelo
processamento das instruções que compõem a estrutura de
repetição.

UTFPR – Computação I 42
 3.2. Estruturas de repetição (cont.)
• As três estruturas de repetição da Linguagem C são:
1. Estrutura de repetição para um número definido de
repetições (iterações):
• for
2. Estrutura de repetição para número indefinido de
repetições (iterações):
• while (com teste (condição) no início)

• do ... while (com teste (condição) no final)

UTFPR – Computação I 43
 3.2. Estruturas de repetição (cont.)
• For (PARA ... ATÉ ... FAÇA)
– A estrutura for é normalmente utilizada quando o número
de vezes que o conjunto de instruções será executado é
predefinido.
– A estrutura for é conhecida como repetição controlada por
contador.

UTFPR – Computação I 44
 3.2. Estruturas de repetição (cont.)
• Sintaxe for:
for (inicialização; condição; incremento/decremento)
{
conjunto de instruções;
}
• onde:
– inicialização é uma expressão que determina o início para a expressão de controle.
Usa um contador de iterações, que é inicializado antes da primeira iteração.
– condição é uma expressão lógica que verifica se a condição de finalização foi
alcançada. É o teste para determinar se o conjunto de instruções será executado
novamente.
– incremento é uma expressão para armazenar a quantidade de iterações realizadas.
Pode ser também decremento, que define quantas iterações faltam.
– conjunto de instruções são os comandos a serem executados.

UTFPR – Computação I 45
 3.2. Estruturas de repetição (cont.)
• Componentes de um cabeçalho típico da estrutura
for:

UTFPR – Computação I 46
3.2. Estruturas de repetição (cont.)
• Uma repetição controlada por
contador necessita de:
– Variável de controle (teste lógico).
– O valor inicial da variável de
controle.
– O incremento (ou decremento) que
modifica a variável a cada iteração.
– A forma de verificação se a condição
foi alcançada.

UTFPR – Computação I 47
 3.2. Estruturas de repetição (cont.)
• Exemplo: Imprime números de 0 a 10.

#include <stdio.h>

int main(void)
{
int cont;

for(cont=0; cont<=10; cont++)

{
printf("%d\n", cont);
}
return 0;
}

UTFPR – Computação I 48
 3.2. Estruturas de repetição (cont.)
• Outro exemplo: Números pares e ímpares.
#include <stdio.h>
int main(void)
{
int num, cont;
for(cont=0; cont<10; cont++)
{
printf("Informe um numero: ");
scanf("%d",&num);
if(num%2 == 0)
{
printf("O numero eh par\n");
}
else
{
printf("O numero eh impar\n");
}
}
}
UTFPR – Computação I 49
 3.2. Estruturas de repetição (cont.)
• Outro exemplo: Tabuada.
#include <stdio.h>

int main(void)
{
int num, cont;

printf("Informe um numero: ");

scanf("%d",&num);

for(cont=0; cont <= 10; cont++)

{
printf("%2d * %2d = %2d\n", num, cont, num * cont);
}
return 0;
}

UTFPR – Computação I 50
 3.2. Estruturas de repetição (cont.)
• Observações:
– A inicialização, a condição de repetição do loop e o incremento podem
conter expressões aritméticas.
Por exemplo, com X = 2 e Y = 10
for (cont = X; cont <= 4 * X * Y; cont += Y/X)
– O "incremento" pode ser negativo. É um decremento ou uma contagem
regressiva.
– Se a condição de repetição for inicialmente falsa, as instruções que
compõem a estrutura não serão realizadas.
– É comum que a variável de controle seja impressa e/ou usada em cálculos
pelas instruções que compõem a estrutura. Contudo, essa variável pode
ser utilizada apenas para contar e controlar a quantidade de iterações.

UTFPR – Computação I 51
 3.2. Estruturas de repetição (cont.)
• Incremento e decremento no mesmo laço for
– A inicialização, a condição de repetição do loop e o
incremento/decremento podem ser compostos.
Exemplo:
inicialização controle incremento/decremento

for(X=0, Y=10; X <= 10 && Y >= 0; X++, Y--)

• Possui duas variáveis inicializadas;

• A condição de controle é composta;
• Possui uma variável incrementada e outra decrementada.

UTFPR – Computação I 52
 3.2. Estruturas de repetição (cont.)
• Exemplo:
#include <stdio.h>

int main(void)
{
int X, Y;

for(X=0, Y=10; X <= 10 && Y >= 0; X++, Y--)

{
printf("X = %d\t Y = %d\n", X, Y);
}

return 0;
}
UTFPR – Computação I 53
 3.2. Estruturas de repetição (cont.)
• Estrutura while
– É a estrutura de repetição mais simples.
– Repete a execução de um bloco de instruções enquanto
uma condição for verdadeira.
– Quando a condição se tornar falsa, o while não repetirá a
execução do instruções.

UTFPR – Computação I 54
 3.2. Estruturas de repetição (cont.)
• Sintaxe while
while (condição)
{
//instruções
}

Onde:
– condição – teste lógico realizado. É o controle para indicar a finalização da repetição.
– instruções – comandos que são executados enquanto o resultado da condição for
verdadeiro. Inclui a alteração da condição para que em algum momento ela se torne
falsa e a repetição possa ser interrompida.

• Esta estrutura faz com que a condição seja avaliada e se verdadeira o conjunto
de instruções é executado. Esse ciclo se repete até a condição ser falsa e,
neste caso, a repetição é terminada sem executar o conjunto de instruções.

UTFPR – Computação I 55
 3.2. Estruturas de repetição (cont.)
• while
Teste lógico (variáveis, constantes, expressões
aritméticas, retorno de função e operadores
Palavra-chave lógicos e relacionais)

while (Condição)
{
/*instruções, incluindo forma de atingir a
condição.*/

UTFPR – Computação I 56
 3.2. Estruturas de repetição (cont.)
• Exemplo: Imprime números de 0 a 10

#include <stdio.h>

int main(void)
{
int i = 0;

while(i <= 10)

{
printf("%d\n", i);
i++;
}

return 0;
}
UTFPR – Computação I 57
 3.2. Estruturas de repetição (cont.)
• Exemplo: Pares e ímpares
#include <stdio.h>
int main(void)
{
int num, cont=0;

while(cont < 10)

{
printf("Informe um numero: ");
scanf("%d", &num);

if(num%2 == 0)
{
printf("O numero eh par\n");
}
else
{
printf("O numero eh impar\n");
}
cont++;
}
return 0;
} UTFPR – Computação I 58
 3.2. Estruturas de repetição (cont.)
• Exemplo: Tabuada
#include <stdio.h>

int main(void)
{
int num, cont=0;

printf("Informe um numero: ");

scanf("%d", &num);

while(cont <= 10)

{
printf("%d * %d = %d\n", num, cont, num * cont);
cont++;
}
}

UTFPR – Computação I 59
 3.2. Estruturas de repetição (cont.)
• Estrutura do - while
– Esta estrutura tem um comportamento muito semelhante
ao while, com uma diferença crucial: a condição é
verificada após executar o bloco de instruções.

UTFPR – Computação I 60
 3.2. Estruturas de repetição (cont.)
• Sintaxe do – while
do
{
//instruções;
}while(condição);
• Onde:
– condição – teste lógico realizado é o controle para indicar a finalização da repetição;
– instruções – comandos que são executados enquanto o resultado da condição for
verdadeiro.
– Instruções inclui a alteração da condição para que em algum momento ela se torne falsa
e o a repetição (loop) possa ser interrompida.

• Esta estrutura faz com que o conjunto de instruções seja executado pelo
menos uma vez. Após a execução desse conjunto, a condição é avaliada. Se for
verdadeira, o conjunto de instruções é executado outra vez, caso contrário a
repetição é finalizada.
UTFPR – Computação I 61
 3.2. Estruturas de repetição (cont.)
• Sintaxe do – while
Palavra-chave

do
{
/*instruções, incluindo forma de atingir a
condição.*/
}while(Condição);

Palavra-chave Teste lógico (variáveis, constantes, expressões

aritméticas, retorno de função e operadores lógicos
e relacionais)

UTFPR – Computação I 62
 3.2. Estruturas de repetição (cont.)
• Exemplo: Imprime números de 0 a 10

#include <stdio.h>

int main(void)
{
int i = 0;

do
{
printf("%d\n",i);
i++;
}while(i <= 10);

return 0;
}
UTFPR – Computação I 63
 3.2. Estruturas de repetição (cont.)
• Outro exemplo : Insere números positivos.
#include <stdio.h>

int main(void)
{
int num;
do
{
printf("Digite um numero positivo (0 para sair): ");
scanf("%d",&num);
if(num>0)
{
printf("numero positivo: %d\n",num);
}
}while(num > 0);

return 0;
} UTFPR – Computação I 64
 3.2. Estruturas de repetição (cont.)
• Exemplo: Pares e ímpares
#include <stdio.h>
int main(void)
{
int num, cont=0;
do
{
printf("Informe um numero: ");
scanf("%d",&num);
if (num%2 == 0)
{
printf("O numero eh par\n");
}
else
{
printf("O numero eh impar\n");
}
cont++;
}while(cont < 10);
return 0;
} UTFPR – Computação I 65
 3.2. Estruturas de repetição (cont.)
• Exemplo: Tabuada
#include <stdio.h>
int main(void)
{
int num, cont=0;

printf("Informe um numero: ");

scanf("%d",&num);

do
{
printf("%d * %d = %d\n", num, cont, num * cont);
cont++;
}while(cont <= 10);

return 0;
}

UTFPR – Computação I 66
 3.2. Estruturas de repetição (cont.)
#include <stdio.h>

int main(void)
{
int i;
printf("Usando o comando \"for\"\n");
for (i=1; i<=5; i++)
{
printf("%d\n", i);
}

printf("\nUsando o comando \"while\"\n");

i=1;
while (i<=5)
{
printf("%d\n", i);
i++;
}

printf("\nUsando o comando \"do while\"\n");

i=1;
do
{
printf("%d\n", i);
i++;
} while (i<=5); 67
}
 3.2. Estruturas de repetição (cont.)
 Para as estruturas de repetição (for, while, do ... while) é:
◼ Indispensável:
 Identificar as instruções que repetem. Elas comporão o corpo da
estrutura de repetição.
 Identificar a condição de finalização, de controle, para saber quando as
repetições serão finalizadas;
 Definir a forma de alcançar essa condição de controle. Pode ser pelo
incremento/decremento de uma variável, por resultado de
processamento, por informação (entrada) do usuário;

◼ Em loops contados, geralmente é necessário:

 Inicialização da variável de controle para que as repetições possam ou
não ser iniciadas;
 Incremento ou decremento da variável de controle para alcançar a
condição de finalização. Ou verificação dessa variável de controle.
UTFPR – Computação I 68
 Aninhamentos
 Aninhamentos ocorrem quando uma estrutura de
controle (if, switch, for, while e do while) está inserida
em uma outra estrutura de controle.
 Por exemplo: Uma estrutura if inserida em uma
estrutura for e esta inserida em uma estrutura while.
 Regra: A estrutura mais interna deve estar inteiramente
contida na estrutura imediatamente mais externa.

Válido Inválido

UTFPR – Computação I
 3.2. Estruturas de repetição (cont.)
• DEITEL, P. J. DEITEL, H. M. Como programar em C. São Paulo:
LTC, 1990.
• SCHILDT, H. C Completo e total, 3ª ed. São Paulo: Makron
Books, 1996.
• MIZRAHI, V. V. Treinamento em linguagem C: curso completo
- módulo 1. São Paulo: McGraw-Hill, 1990.
• Material baseado no conteúdo disponibilizado pela
professora Beatriz Borsoi.

UTFPR – Computação I 70
 Dúvidas

• ???

UTFPR – Computação I 71