07_-_Estruturas_de_Controle_-_Lacos

Prévia do material em texto

TÉCNICAS DE PROGRAMAÇÃO 1 
INTRODUÇÃO À LING C 
ESTRUTURA DE CONTROLE 2- LAÇOS 
(REPETIÇÕES) 
Geiza Maria Hamazaki da Silva 2013.1 
Tópicos 
 Para a codificação dos algoritmos é necessário o 
conhecimentos dos comandos na linguagem C. Neste 
conjunto de slides será apresentado dois comandos 
relacionados com a Construções com laços 
(Repetição). 
Construções com laços 
 A linguagem C oferece várias construções possíveis para 
a realização de laços iterativos 
 o primeiro a ser apresentado é similar ao comando 
Enquanto utilizado no Pseudocódigo: o comando 
while 
 Sua forma geral é 
while (condição){ 
bloco de comandos 
... 
} 
Comando while 
while (condição){ 
bloco de comandos 
... 
} 
 Se a avaliação da condição resultar em verdadeiro: 
 O bloco de comandos é executado e ao final do bloco, a 
condição volta a ser avaliada. 
 Enquanto condição resultar em verdadeiro, o bloco de 
comandos (ou o corpo do laço) é executado repetidamente. 
 Quando a condição for avaliada em falso, o bloco de 
comandos deixa de ser executado, a execução do 
programa prossegue com a execução dos comandos 
subsequentes ao bloco relacionado ao laço. 
Comando while 
 A execução do comando while termina quando 
condição é avaliada em falso ou quando o 
controle é transferido para fora do bloco do 
while por um comando de return ou break. 
Estes comandos serão apresentados nos próximos 
conjuntos de slides. 
Construções com laços 
 Exemplo: 
 fatorial de um número inteiro não negativo: 
 
 
 
1!0:
123)...2()1(!


onde
nnnn
Construções com laços 
 Exemplo: 
 Cálculo do fatorial(n) 
 leia (n) 
 comece com: 
k = 1 
fatorial = 1 
 faça enquanto k  n 
fatorial = fatorial * k 
incremente k 
 
/* Fatorial */ 
#include <stdio.h> 
int main (void) 
{ 
 int k; 
 int n; 
 long int f = 1; 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 k = 1; 
 while (k <= n) 
 { 
 f = f * k; /* a expressão “f = f * k” é equivalente a “f *= k” */ 
 k = k + 1; /* a expressão “k = k + 1” é equivalente a “k++” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
leia(n) 
/* Fatorial */ 
#include <stdio.h> 
int main (void) 
{ 
 int k; 
 int n; 
 long int f = 1; 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 k = 1; 
 while (k <= n) 
 { 
 f = f * k; /* a expressão “f = f * k” é equivalente a “f *= k” */ 
 k = k + 1; /* a expressão “k = k + 1” é equivalente a “k++” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
k = 1 
fatorial = 1 
/* Fatorial */ 
#include <stdio.h> 
int main (void) 
{ 
 int k; 
 int n; 
 long int f = 1; 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 k = 1; 
 while (k <= n) 
 { 
 f = f * k; /* a expressão “f = f * k” é equivalente a “f *= k” */ 
 k = k + 1; /* a expressão “k = k + 1” é equivalente a “k++” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
faça enquanto k  n 
 fatorial = fatorial * k 
 incremente k 
Construções com laços 
 Exercício: 
 
1. Compile o programa para calcular fatorial. 
2. Execute-o para 5, 10 e 20. 
3. Explique o comportamento do programa. 
Construção de Laços: Comando for 
 Uma segunda forma de construção de laços em C 
 Similar ao “Para” utilizada em pseudocódigo mais 
compacta e amplamente utilizada, é com laços for 
 A forma geral do for é 
for (expr_inicial; expr_booleana; expr_de_incremento){ 
 bloco de comandos 
 ... 
} 
Comando for 
 
 
 
 A expr_inicial é avaliada uma única vez antes da 
execução do laço. 
 Em seguida, a expressão booleana, que controla a 
execução do laço, é avaliada e, enquanto for 
verdadeira, o bloco de comandos é executado. 
 Imediatamente após cada execução do bloco de 
comandos, a expressão booleana volta a ser avaliada. 
for (expressão_inicial; expressão_booleana; expressão_de_incremento) 
{ 
 bloco de comandos 
} 
Comando for 
 
 
 
 O comando for é executado da seguinte forma 
1. se existir, expr_inicial é avaliada 
2. se existir, expr_booleana é avaliada 
 se o resultado for zero(falso) a execução do for está 
completa ,caso contrário, vai para o passo 3 
3. o corpo do for é executado 
4. se existir, expr_de_incremento é avaliada 
5. volta ao passo 2 
for (expressão_inicial; expressão_booleana; expressão_de_incremento) 
{ 
 bloco de comandos 
} 
Comando for 
 A execução do comando for termina quando 
expr_booleana é avaliada em falso (zero) ou 
quando o controle é transferido para fora do bloco 
do for por um comando de return ou break. Estes 
comandos serão apresentados nos próximos conjuntos 
de slides. 
Comando for 
 Comando “for”: 
 forma compacta para exprimir laços 
 
 
 
 equivalente a: 
for (expressão_inicial; expressão_booleana; expressão_de_incremento) 
{ 
 bloco de comandos 
} 
expressão_inicial; 
while ( expressão_booleana ) 
{ 
 bloco de comandos 
 ... 
 expressão_de_incremento 
} 
Comando for 
 Exemplo: 
 fatorial de um número inteiro não negativo: 
 
 
 
1!0:
123)...2()1(!


onde
nnnn
Comando for 
 Exemplo: 
 Cálculo do fatorial(n) 
 leia (n) 
 comece com: 
fatorial = 1 
 Para i de 1 até n faça 
fatorial = fatorial * i 
 
 
/* Fatorial (versao 2) */ 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i=i+1) { /* a expressão “i = i + 1” é equivalente a “i++” */ 
 f = f * i; /* a expressão “f = f * i” é equivalente a “f *= i” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
leia (n) 
/* Fatorial (versao 2) */ 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i=i+1) { /* a expressão “i = i + 1” é equivalente a “i++” */ 
 f = f * i; /* a expressão “f = f * i” é equivalente a “f *= i” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
Para i de 1 até n faça 
/* Fatorial (versao 2) */ 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i=i+1) { /* a expressão “i = i + 1” é equivalente a “i++” */ 
 f = f * i; /* a expressão “f = f * i” é equivalente a “f *= i” */ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
fatorial = fatorial * i 
/* Fatorial (versao 2) */ 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i+1) { /* o que acontece com este programa? */ 
 f = f * i; 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
/* Fatorial (versao2) */ 
#include <stdio.h> 
 
int main (void) 
{ 
 int i; 
 int n; 
 int f = 1; 
 
 printf("Digite um numero inteiro nao negativo:"); 
 scanf("%d", &n); 
 
 /* calcula fatorial */ 
 for (i = 1; i <= n; i+1) { /* O que acontece com este programa? */ 
 f = f * i; /*O programa ficará preso na repetição pois a 
 variável ‘i’ não é incrementada. O certo é i=i+1*/ 
 } 
 printf(" Fatorial = %d \n", f); 
 return 0; 
} 
Construções com laços 
 Observe que as chaves que seguem o comando for, 
neste caso, são desnecessárias, já que o corpo do 
bloco é composto por um único comando. 
 Tanto a construção com while como a construção 
com for avaliam a expressão booleana, que 
caracteriza o teste de encerramento, no início do 
laço. 
 Se esta expressão booleana tiver valor igual a zero 
(falso), quando for avaliada pela primeira vez, os 
comandos do corpo do bloco não serão executados 
nenhuma vez. 
Operador vírgula 
 O operador vírgula pode ser útil no comando for 
 Ele permite múltiplas inicializações e múltiplas 
atualizações. 
 Por exemplo, o comando for pode ser usado para 
calcular a soma dos inteiros de 1 a n: 
for (soma = 0, i = 1; i <= n; i = i + 1) 
 soma = soma + i; 
Operador vírgula 
 Seguindo o mesmo raciocínio pode-se colocar o 
corpo do laço dentro dos parênteses do for 
for (soma = 0, i = 1; i <= n; soma = soma + 
i, i = i + 1); 
Mas não 
for (soma = 0, i = 1; i <= n; i = i + 1, soma 
= soma + i); 
 na expressão i = i + 1, soma = soma + i; 
a expressão i = i + 1 é avaliada primeiro, 
consequentemente soma terá um valor diferente do 
desejado. 
 
Comando for 
 Programa para calcular a potência (especificado 
pelo expoente inteiro positivo) de um inteiro 
(chamado de base) 
 obs: não verifica overflow : quando o número de bits 
utilizados para representar o dado ultrapassam o 
número de bits reservados para armazenar o mesmo 
dado. 
Exemplo1 :Comando for 
/* Potencia*/ 
#include <stdio.h> 
void main(){ 
 int base, expoente, resultado = 1; 
 printf("Digite base e expoente:\n"); 
 scanf("%d %d", &base, &expoente); 
 for (;expoente>0; expoente/=2){ 
 if (expoente % 2 == 1) 
 resultado = resultado * base; 
 base = base * base; 
 } 
 printf("\nResultado: %d\n", resultado); 
} 
 esta forma evidencia que o laço é controlado pela variável expoente 
conforme ela se aproxima de zero pelas sucessivas divisões por dois 
Exemplo 2: Comando for 
/* soma PA com for */ 
#include <stdio.h> 
int main (void) { 
 int razao, n, i, a1, aq, soma; 
 printf ("Progressao aritmetica\n\n"); 
 printf ("Primeiro termo: "); 
 scanf ("%d", &a1); 
 printf ("Razao: "); 
 scanf ("%d", &razao); 
 printf ("Numero de termos: "); 
 scanf ("%d", &n); 
 soma = 0; aq = a1; 
 for ( i = 1; i <= n; i = i + 1 ) { 
 soma = soma + aq; 
 aq = aq + razao; 
 } 
 printf ("\nSOMA DOS TERMOS: %d", soma); 
 return 0; 
} 
30 
Referências 
 W. Celes, R. Cerqueira e J.L. Rangel, Introdução a 
Estruturas de Dados - com técnicas de programação 
em C, Ed. Campus, 2004 
 A. Kelley, A Book on C, Benjamin Cummings, 1995 
 Notas de aulas do curso presencial de Técnicas de 
Programação1- UNIRIO - Desenvolvidos pelas 
professoras: Geiza Maria Hamazaki da Silva e Adriana 
C. F Alvim – primeiro semestre de 2011.