Aula 07

Na última aula: switch-case
Sintaxe: switch (expressão)

{
case constante1 : comandos1 ;
case constante2 : comandos2 ;
...
case constanten : comandosn ;
default : comandos; //comando opcional
}
•  Expressão: int ou char.

•  Compara o valor retornado pela expressão a uma sequência de
conteúdos constantes, na sequência em que aparecem;
•  Se expressão = conteúdo, comando associado é executado até o
final do comando ou até que seja encontrado um break;
•  Se nenhum conteúdo for igual, comandos associado a default
(opcional!) são executados.
•  Para que apenas os comandos associados a um (ou sequência de)
case seja executado, devemos inserir o comando break no ponto
de encerramento da execução.
1 INF 01202 - Prof. Marcelo Walter – Aula 07

Dúvidas sobre o switch
•  Com o break encerra a execução (não testa mais

nenhum caso)
•  Não pode haver constantes repetidas
•  Exemplo:
switch(num)
{
case 1: …
case 2: …
case 1: …
}

Exercício da última aula
Uma indústria de ovos de Páscoa fornece três tipos diferentes de ovos de
chocolate: tipo A com valor unitário de R$12, tipo B com valor unitário de R$
15.50 e tipo C com valor unitário de R$21.30. Faça um programa que leia os dados
relativos a um pedido (tipo de Ovo e quantidade) e informe:
•  o produto solicitado (tipo de ovo A, B ou C. Fazer consistência do tipo);
•  o número de unidades vendidas (com mensagem do limite ultrapassado, se for
o caso);
•  o total a ser pago, em reais.
Suponha que em cada pedido somente poderá ser solicitado um tipo de ovo. Além
disso, com a intenção de satisfazer a um maior número de clientes, foi limitado o
número de ovos a serem fornecidos por pedido, de acordo com o tipo de ovo
solicitado: o número máximo de unidades do ovo A é 50, do B é 30 e do C é 20.
Caso o pedido supere o número limite de unidades correspondente ao tipo de ovo
do pedido, o programa deverá emitir uma mensagem indicando que não poderá
atender o total do pedido, dizendo que serão fornecidas apenas as unidades
estabelecidas para o tipo.

Uma solução possível
Entrada

Processamento

Saída

Seja o problema:
Conforme uma nota inteira fornecida, entre 0 e 10,

imprimir uma das seguintes mensagens:
0 a 5 – Reprovado
6 a 9 – Aprovado
10 – Aprovado com louvor.
Em C, esse problema pode ser resolvido tanto por

uma sucessão de ifs, quanto por um comando
switch/case.

Mensagem dependendo de nota inteira: com ifs.
//Recebida uma nota, fornecer uma das seguintes mensagens:
//0 a 5: Reprovado; 6 a 9: Aprovado; 10: Aprovado com louvor.
#include <stdio.h>
int main ( )
{
int nota;
printf("\nNota (0 a 10): ");
scanf("%d", &nota);
if (nota < 0 || nota > 10) // elimina notas inválidas
printf(“Nota inválida!\n”);
else
if (nota < 6)
printf("\nReprovado\n");
else // sobraram aprovados!
if (nota <= 9)
printf("\nAprovado\n");
else // só sobrou nota = 10
printf("\nAprovado com louvor\n");
return 0;
}

Mensagem dependendo de nota inteira: com switch/case
// Recebida uma nota, fornecer uma das seguintes mensagens:
//0 a 5: Reprovado; 6 a 9: Aprovado; 10: Aprovado com louvor.
#include <stdio.h>
int main ( )
{
int nota;
printf("\nNota (0 a 10): ");
scanf("%d", &nota);
switch (nota)
{
case 0:
case 1:
case 2:
case 3:
case 4:
case 5: printf("\nReprovado\n");
break;
case 6:
case 7:
case 8:
case 9: printf("\nAprovado\n");
break;
case 10: printf("\nAprovado com louvor\n");
break;
default: printf(“Nota inválida!”\n”); // nota < 0 ou nota > 10
}
return 0;
9 } INF 01202 - Prof. Marcelo Walter – Aula 07
Mas se a nota não for inteira?
Nesse caso, em C, apenas ifs podem ser

usados para testar as condições com valores
reais.
Switch/case não é mais uma opção, já que só

opera com expressões e constantes dos
tipos int, long (integer) ou char.

Outro exemplo: Converta o trecho abaixo, implementado
através de if-elses encadeados, para uma solução que utilize o
switch-case: Ex: calcular expressões de acordo com
a tabela abaixo
...
//uso de seleção dupla
if (codigo == 1) Código
1
Resultado
Resultado + 5
resultado = resultado + 5; 2 Inalterado
else
3 Resultado –2
4 Inalterado
if (codigo == 3 || codigo == 5) 5 Resultado –2
resultado = resultado – 2; 6
7
2* (Resultado +1)
Inalterado
else 8 0
if (codigo == 6)
9 0
10 0
resultado = 2 * (resultado + 1); 11 123
else
if (codigo > 7 && codigo < 11)
resultado = 0;
else
if (codigo == 11)
resultado = 123;
else
if (codigo < 1 || codigo > 11)
printf(“código inválido!”);

...
// uso de switch case:
switch (codigo)
{
case 1: resultado = resultado + 5;
break;
case 2:
case 4: Ex: calcular expressões de acordo com
case 7: break; // 2, 4 e 7: não faz nada, apenas evita entrar ano
tabela abaixo
default
case 3:
case 5: resultado = resultado – 2; Código Resultado
break; 1
2
Resultado +5
Inalterado
case 6: resultado = 2 * (resultado + 1); 3 Resultado –2
break; 4 Inalterado
case 8: 5
6
Resultado –2
2* (Resultado +1)
case 9: 7 Inalterado
case 10: resultado = 0; 8 0
break; 9
10
0
0
case 11: resultado = 123; 11 123
break;
default: printf(“Codigo informado invalido!”); // não precisa break
}
Observe que os valores não precisam

estar em ordem crescente
Exercício
Tendo como dados de entrada o tipo de conversão desejada (1-
temperaturas, 2 – unidades de medidas, 3 - encerrar o programa)
e unidade e valor a ser convertido (admitindo aqui também a opção
de encerrar programa), efetuar o atendimento da ação solicitada.
Informações adicionais:
1.  conversão Celsius – Fahrenheit:
1º F = (9 / 5)º C + 32
2.  conversão Polegadas – Milímetros:
1 pol = 24.5 mm
Algoritmo: apenas passos

•  leitura e consistência Menu Inicial (opção)
•  se opção = 1 ou 2:
•  ler valor
•  converter valor
•  informar valor convertido
•  Opção = 3 – encerra programa sem informação de resultado
•  Outras opções: inválidas!

Solução com Ifs (incompleta)
//converte temperatura ou medida:
#include <stdio.h>
int main()
{
float val_lido, val_conv; // valores reais: lido e informado
int op; // opção dos menus
printf("Indique a tarefa desejada:\n 1. Conversao de temperaturas: \n 2.

Conversao de unidades de medida: \n 3. Encerrar o programa\n");
scanf("%d",&op); // lê opção do menu
if (op == 1) // opção: conversão de temperaturas
{ ......
}
else
if (op == 2) // opção: conversão de medidas
{ .......
}
else
if (op == 3) //avisa encerramento por solicitação
printf (“ Opção selecionada: encerrar programa.”);
else // se chegou aqui: erro!!!
printf (“ Opção inválida!”); // avisa o erro
return(0);
}
Solução com switch/case (incompleta)
//converte temperatura ou medida:
#include <stdio.h>
int main()
{
float val_lido, val_conv; // valores reais: lido e informado
int op; // opção dos menus
printf("Indique a tarefa desejada:\n 1. Conversao de temperaturas: \n 2.

Conversao de unidades de medida: \n 3. Encerrar o programa\n");
scanf("%d",&op); // lê opção do menu
switch(op)
{
case 1: ... // opção: conversão de temperaturas
case 2: ... // opção: conversão de medidas
case 3: //avisa encerramento por solicitação
printf (“ Opção selecionada: encerrar programa.”);
break;
default:
printf (“ Opção inválida!”); // avisa o erro
}
return(0);
}

Vantagens e Desvantagens do switch/case:
Desvantagens
•  Serve como alternativa para casos em que sejam testadas
apenas igualdades envolvendo expressões int, long (long integer)
ou char.
•  Não pode testar intervalos!!
(if...else é mais abrangente!!)
Vantagens
  O código produzido é mais claro.
  A lógica fica mais evidente.
Complete o exercício anterior em casa

RESUMO: Uso de seleção condicional
  Condicional Simples : if
 execução de comando (simples ou composto)
depende de 1 condição: pode ou não ser executado.
  Seleção Dupla : if-else
 2 comandos (simples ou composto), cuja execução é
mutuamente exclusiva: nunca acontece de serem
executados juntos ou de nenhum dos 2 ser
executado.
  Seleção múltipla : switch case
 grupos de 3 ou mais comandos cuja decisão de
execução depende da comparação de um valor
obtido com diversos possíveis valores pré-
estabelecidos (+ de 2).
 Adequado para a implementação de menus.
 Indequado para associar comandos a intervalos ou
diversos valores.

Seja o problema:
Faça um programa que leia a média de um aluno e, baseado no

valor obtido, informe se o aluno está aprovado ou reprovado.
Considerar como aprovado o aluno que obtiver

média >= 6.0

Algoritmo para a Solução do Problema
Algoritmo UmConceito
/* Informa se um aluno foi ou não aprovado, a
partir da média informada */
entrada: média
saída: ‘Aprovado’ ou ‘Reprovado’
1. início
2. ler média
3. se média >= 6,0 Processar apenas 1
escrever ‘Aprovado’ aluno?
senão
escrever ‘Reprovado’
4. fim.

Algoritmos
com laços (loop, em Inglês)
(algoritmos com instruções

que devem ser executadas repetidas
vezes)

Idéia de Laço de repetição 
http://www.youtube.com/watch?v=X6sOzEQn-Ng&feature=related

Seja o problema:
Faça um programa que leia o número de chamada e

a média obtida de todos os alunos de uma turma e,
baseado neste valor, informe se o aluno está
aprovado ou reprovado (cada um dos alunos).
Considerar como aprovado o aluno que obtiver
média >= 6.0
Supor uma turma de 5 alunos.

Algoritmo para a Solução do Problema
Algoritmo AprovadoReprovado
/* Informa se os 5 alunos foram ou não aprovados, a partir de suas médias*/
entrada: n1, n2, n3, n4, n5, med1, med2, med3, med4, med5 //números/médias
saída: para cada aluno, número e ‘Aprovado’ ou ‘Reprovado’
1. início
2. ler n1, med1, n2, med2, n3, med3, n4, med4, n5, med5 // lê todas as informações
3. se med1 >= 6,0
escrever n1, ‘Aprovado’
senão escrever n1, ‘Reprovado’ Otimizando:
4. se med2 >= 6,0 apenas
escrever n2, ‘Aprovado’ 1 variável número
senão escrever n2, ‘Reprovado’
5. se med3 >= 6,0 e
escrever n3, ‘Aprovado’ 1 variável média!
6. se med4 >= 6,0
7. se med5 >= 6,0
8. fim.
Algoritmo para a Solução do Problema – 2 variáveis
/* Informa se os 5 alunos foram ou não aprovados, a partir de suas médias*/
entrada: numero, media //números/médias
saída: para cada aluno, numero e ‘Aprovado’ ou ‘Reprovado’
1.  início
2.  ler numero, media // lê o que vai ser processado
3.  se media >= 6,0
escrever numero, ‘Aprovado’
senão escrever numero, ‘Reprovado’
4.  ler numero, media
5.  se media >= 6,0
7.  se media >= 6,0
9.  se media >= 6,0
11.  se media >= 6,0
12.  fim
entradas : numero, media
saídas: numero e ‘Aprovado’ ou ‘Reprovado’ (para cada
aluno)
1.  inicio
2.  repetir 5 vezes:
1.1 ler numero, media

1.2. se media >= 6,0
senão
escrever numero, ‘Reprovado’
3. fim.
Estruturas de repetição
Comandos de repetição (loop)
  Objetivo: repetir comando (ou bloco de comandos)
um número finito de vezes
  Controle da repetição
  contagem:
•  repetir um determinado número de vezes
  teste:
•  repetir enquanto uma condição não for atingida
•  repetir até uma condição ser atingida

Comandos iterativos ou de repetição
(loop)
Aula de hoje
•  para tantas vezes repita ...
•  enquanto ......
•  faça ... enquanto

Comando de repetição – número fixo de vezes
C Linguagem algorítmica
for (expressão 1; expressão 2; expressão3)
comando;
para (inicialização(ões);
condição;
incremento(s)/decremento(s))
comando
inicializações
condição V
comando
?
F
incremento

Comando for : sintaxe
for (expressão 1; expressão 2; expressão3) ATENÇÃO:
{ as chaves só são
obrigatórias quando
// comando(s) a serem repetidos mais de um comando
for controlado pelo
} for (laço de
// comandos após o for repetição).
1.  A(s) inicialização(ões) definida(s) na expressão 1 é (são) executada(s);

2.  A condição definida em expressão 2 é avaliada:
 se verdadeira:
i-comando(s) do bloco subordinado é (são) executado(s);
ii-incremento(s) e/ou decremento(s) em expressão 3 é(são) executado(s);
iii-retorna ao ponto (2).
 se falsa:
i-encerra comando for.
Observação: A avaliação da condição do comando for ocorre antes do início
do trecho a ser repetido:
bloco subordinado pode não ser executado nenhuma vez!
Comando for : sintaxe
•  Variável (eis) de controle:
–  tipo deve ser int ou char;
–  pode(m) ser utilizada(s) no comando de
repetição;
–  não deve(m) ser alterada(s) no comando, seguindo
apenas o incremento/decremento definido no
cabeçalho do for.

Comandos a
serem repetidos
entradas : numero, media
saídas: numero e ‘Aprovado’ ou ‘Reprovado’ (para cada aluno)
1. inicio Cabeçalho que controla a repetição
2. para (contador = 1; contador <=5 ; contador=contador+1)
2.1 início // comando composto
2.2 ler numero, media
2.3 se media >= 6,0
2.3.1 escrever numero, ‘Aprovado’
2.3.2 senão
2.3.2.1 escrever numero, ‘Reprovado’
2.4 fim
3. fim.

// Determina se 5 alunos foram aprovados ou reprovados
#include <stdio.h>
int main() Controle de repetição

{
int contador, numaluno;
float media; Comandos a serem
repetidos
for(contador=1;contador<=5;contador++) // executa 5 vezes

{
printf(“Informe numero e nota do aluno %d:”, contador);
scanf(“%d”, &numaluno);
scanf(“%f”, &media);
if (media >=6)
printf(“O aluno %d foi aprovado!\n”, numaluno);
else
printf(“O aluno %d for reprovado!\n”, numaluno);
}
return 0;
}
// Determina se 5 alunos foram aprovados ou reprovados
#include <stdio.h>
Incremento ou
int main()
decremento no
{ comando FOR
int contador, numaluno;
float media;
for(contador=5;contador > 0;contador--) // executa 5 vezes

{ // contador subtrai 1 a cada ciclo
printf(“Informe numero e nota do aluno %d:”, contador);
scanf(“%d”, &numaluno);
scanf(“%f”, &media);
if (media >=6)
printf(“O aluno %d foi aprovado!\n”, numaluno);
else
printf(“O aluno %d for reprovado!\n”, numaluno);
}
return 0;
}
Exemplos: Utilização de incrementos diferentes de 1
// Imprime numeros pares de um intervalo dado

// garante que o primeiro nro é menor do que o segundo
#include <stdio.h>
int main()
{
int val1, val2, inic, fim, controle;
printf(“Informe 2 numeros naturais: ”);

scanf(“%d”, &val1);
scanf(“%d”, &val2);
if (val1 > val2){
inic = val2; fim = val1;
}
else{
inic = val1; fim = val2;
}
if ( inic % 2 ) inic = inic + 1; // gera seq apenas com nros pares!
for( controle=inic; controle<=fim; controle = controle +2)
printf(“%d “, controle);
return 0;
}
Tabela ASCII
Para uso no
comando for
com
caracteres.O
valor ASCII
de cada
caracter é
utilizado nas
comparações
American Standard Code for Information Interchange

Exemplos: Utilização da variável de controle após o for
//Apresenta sequência de caracteres, entre A e z
# include <stdio.h>
int main ( )
{
char letra;
for (letra = 'A'; letra <= 'z'; letra++) // A até z: sequência não contínua
printf("%3c", letra);
printf("\n\nCaractere da tabela ASCII apos a ultima minuscula: %c\n", letra);
return 0;
}

Exemplos: Utilização da variável de controle após o for
//Imprime minusculas, utilizando valor de posicao na tabela ASCII
# include <stdio.h>
int main ( )
{
int i;
for (i = 97; i <= 122; i++) // 97 e 122 codigos das minusculas
printf("%3c", i);
// valor de i apos a execucao do laco eh 123, que corresponde a {
printf("\n\nCaractere da tabela ASCII apos a ultima minuscula: %c\n", i);
return 0;
}

Problema:
calcular a idade média de um
grupo de pessoas.
Qual a idade
média do
público dos
shows do
U2? Ou da
Maria
Bethânia?

Variável acumulador
Variável que recebe um valor inicial,

geralmente 0, e é incrementada
periodicamente de um valor variável.

soma_idades - variável
tipo acumulador, uso:
somatório das idades.
// Calcula a idade média de 5 pessoas
# include <stdio.h>
int main ( )
{
int soma_idades, idade, contador;
float media_idades;
Se o for
soma_idades = 0; // inicializa acumulador em 0
controlar for (contador = 1; contador <= 5; contador ++)
mais de uma {
instrução, printf("informe idade %d :", contador); // utiliza contador
as chaves scanf ("%d", &idade);
são // vai acumulando idades lidas
obrigatórias soma_idades = soma_idades + idade;
}
// cast, para resultado ser real
media_idades = (float) soma_idades/5;
printf("\nA media das 5 idades lidas eh %.2f.\n", media_idades);
return 0;
}

Execução:
Conteúdo da variável
de controle

Problema:
Calcular a idade média de um grupo de n

pessoas, onde n é conhecido, informando quantas
pessoas do grupo tem idade inferior a 18 anos

Variável contador
Variável que recebe um valor inicial,

geralmente 0, e é periodicamente
incrementada de um valor constante,
geralmente 1.

/* Calcula a idade média de 5 pessoas e conta menores de idade do grupo: */
# include <stdio.h> conta_menos_de_18 - variável
tipo contador, uso: contagem dos
int main ( ) menores de idade.
{
int soma_idades, idade, contador, conta_menos_de_18;
float media_idades;

conta_menos_de_18 = 0; // inicializa contador em 0
for (contador = 1; contador <= 5; contador ++)
{
printf("informe idade %d :", contador);
scanf ("%d", &idade);
if (idade < 18)
conta_menos_de_18++; // incrementa 1 no contador
// vai acumulando idades lidas
soma_idades = soma_idades + idade;
}
media_idades = (float) soma_idades/5;
printf("\nA media das 5 idades lidas eh %.2f.", media_idades);
printf("\nExistem %d pessoas menores de 18 anos.\n", conta_menos_de_18);
return 0;
}
Execução:

Questão:
Nos problemas anteriores, o que temos que alterar no
programa para a leitura de uma quantidade diferente de
valores, ao invés de sempre 5?
Iremos
trocar este
for (contador = 1; contador <= 5; contador ++) valor fixo
{ por uma
printf("informe idade %d :", contador); constante
scanf ("%d", &idade); que pode
if (idade < 18) ser
conta_menos_de_18++; // incrementa 1 no contador facilmente
// vai acumulando idades lidas modificada
soma_idades = soma_idades + idade; em todo o
} programa
ao mesmo
tempo

Constantes simbólicas
Valores ou locais identificados onde os dados armazenados
nunca se alteram durante a execução de um programa.
Declaradas antes de serem usadas, com a especificação do

conteúdo válido, logo após a referência às bibliotecas
utilizadas (área global).

Declaração de constantes simbólicas com define
Sintaxe:
#define IDENTIFICADOR valor
ATENÇÃO:
entre identificador e valor não colocar nada além de espaços !
Exemplo:
#define NRALUNOS 10
Ação:
•  Na compilação, o identificador é substituído no programa pelo
valor indicado.
Vantagens:
•  Flexibilidade de alteração de limites
•  Segurança contra enganos de digitação de valores
Importante:
Recomenda-se fortemente escrever o identificador em
MAIÚSCULAS!
Declaração e uso de constantes
// Calcula a idade média de NUMPESSOAS pessoas

# include <stdio.h>
Ao alterarmos o valor 5,
#define NUMPESSOAS 5 podemos controlar quantas
int main ( ) pessoas iremos fazer o
{ cálculo.
int soma_idades, idade, contador;
float media_idades; Flexibilidade!!

for (contador = 1; contador <= NUMPESSOAS; contador ++)
{
printf("informe idade %d :", contador);
scanf ("%d", &idade);
// vai acumulando idades lidas
soma_idades = soma_idades + idade;
}
media_idades = (float) soma_idades/ NUMPESSOAS;
printf("\nA media das idades lidas eh %.2f.\n", media_idades);
return 0;
}

Declaração e uso de constantes
//Exemplo de uso do define
#include <stdio.h>
#define LIMITE 5
int main ( )
{
int indice;
float nota , soma = 0;
for (indice = 1; indice <= LIMITE; indice++) Constantes

{ simbólicas:
printf("Nota %d: ", indice);
scanf("%f", &nota); podem ser
soma = soma + nota; usadas em
} expressões e
printf("\nFinal da entrada das %d notas.\n", LIMITE);
printf("\nIndice na saida do for: %d.\n", indice); ter seu valor
apresentado
printf("\nSomatorio das %d notas lidas : %.2f\n”, LIMITE, soma ); ou atribuído
a variáveis.
return 0;
}

Uso de constantes simbólicas
Constantes
simbólicas:
Não podem
ser ser LIMITE = 7;
alteradas scanf(“%d”,&LIMITE);
por
atribuição ou
leitura. O pré-compilador troca a linha
por:
LIMITE = 7;
scanf(“%d”,&7);

Exercício
•  Utilizando o comando iterativo for, faça um
algoritmo / programa em C que calcule o fatorial de
um número inteiro positivo informado.
•  Cálculo do Fatorial de um número:
0! = 1
n! = n x (n-1) x (n-2) x ... x 2 x 1
n! = n x (n-1)!, para n > 0

Aula 07

Caricato da

Informazioni sul documento

Descrizione originale:

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Aula 07

Caricato da

Copyright:

Formati disponibili

Na última aula: switch-case

Sintaxe: switch (expressão)

• Expressão: int ou char.

1 INF 01202 - Prof. Marcelo Walter – Aula 07

• Com o break encerra a execução (não testa mais

2 INF 01202 - Prof. Marcelo Walter – Aula 07

3 INF 01202 - Prof. Marcelo Walter – Aula 07

4 INF 01202 - Prof. Marcelo Walter – Aula 07

5 INF 01202 - Prof. Marcelo Walter – Aula 07

6 INF 01202 - Prof. Marcelo Walter – Aula 07

Conforme uma nota inteira fornecida, entre 0 e 10,

Em C, esse problema pode ser resolvido tanto por

7 INF 01202 - Prof. Marcelo Walter – Aula 07

8 INF 01202 - Prof. Marcelo Walter – Aula 07

Nesse caso, em C, apenas ifs podem ser

Switch/case não é mais uma opção, já que só

10 INF 01202 - Prof. Marcelo Walter – Aula 07

11 INF 01202 - Prof. Marcelo Walter – Aula 07

Observe que os valores não precisam

Algoritmo: apenas passos

13 INF 01202 - Prof. Marcelo Walter – Aula 07

printf("Indique a tarefa desejada:\n 1. Conversao de temperaturas: \n 2.

printf("Indique a tarefa desejada:\n 1. Conversao de temperaturas: \n 2.

15 INF 01202 - Prof. Marcelo Walter – Aula 07

Complete o exercício anterior em casa

16 INF 01202 - Prof. Marcelo Walter – Aula 07

17 INF 01202 - Prof. Marcelo Walter – Aula 07

Faça um programa que leia a média de um aluno e, baseado no

Considerar como aprovado o aluno que obtiver

18 INF 01202 - Prof. Marcelo Walter – Aula 07

19 INF 01202 - Prof. Marcelo Walter – Aula 07

(algoritmos com instruções

20 INF 01202 - Prof. Marcelo Walter – Aula 07

21 INF 01202 - Prof. Marcelo Walter – Aula 07

Faça um programa que leia o número de chamada e

22 INF 01202 - Prof. Marcelo Walter – Aula 07

1.1 ler numero, media

26 INF 01202 - Prof. Marcelo Walter – Aula 07

• faça ... enquanto

27 INF 01202 - Prof. Marcelo Walter – Aula 07

28 INF 01202 - Prof. Marcelo Walter – Aula 07

1. A(s) inicialização(ões) definida(s) na expressão 1 é (são) executada(s);

30 INF 01202 - Prof. Marcelo Walter – Aula 07

31 INF 01202 - Prof. Marcelo Walter – Aula 07

int main() Controle de repetição

for(contador=1;contador<=5;contador++) // executa 5 vezes

for(contador=5;contador > 0;contador--) // executa 5 vezes

// Imprime numeros pares de um intervalo dado

printf(“Informe 2 numeros naturais: ”);

American Standard Code for Information Interchange

36 INF 01202 - Prof. Marcelo Walter – Aula 07

37 INF 01202 - Prof. Marcelo Walter – Aula 07

38 INF 01202 - Prof. Marcelo Walter – Aula 07

Variável que recebe um valor inicial,

39 INF 01202 - Prof. Marcelo Walter – Aula 07

40 INF 01202 - Prof. Marcelo Walter – Aula 07

41 INF 01202 - Prof. Marcelo Walter – Aula 07

Calcular a idade média de um grupo de n

42 INF 01202 - Prof. Marcelo Walter – Aula 07

Variável que recebe um valor inicial,

43 INF 01202 - Prof. Marcelo Walter – Aula 07

soma_idades = 0; // inicializa acumulador em 0

•  Expressão: int ou char.

•  Com o break encerra a execução (não testa mais

•  faça ... enquanto

1.  A(s) inicialização(ões) definida(s) na expressão 1 é (são) executada(s);