Baixe o app para aproveitar ainda mais
Leia os materiais offline, sem usar a internet. Além de vários outros recursos!
Linguagem C Volume II
Compartilhar
Prévia do material em texto
Recife, 2009
Programação 2
Sônia Virginia Alves França
Universidade Federal Rural de Pernambuco
Reitor: Prof. Valmar Corrêa de Andrade
Vice-Reitor: Prof. Reginaldo Barros
Pró-Reitor de Administração: Prof. Francisco Fernando Ramos Carvalho
Pró-Reitor de Extensão: Prof. Paulo Donizeti Siepierski
Pró-Reitor de Pesquisa e Pós-Graduação: Prof. Fernando José Freire
Pró-Reitor de Planejamento: Prof. Rinaldo Luiz Caraciolo Ferreira
Pró-Reitora de Ensino de Graduação: Profª. Maria José de Sena
Coordenação de Ensino a Distância: Profª Marizete Silva Santos
Produção Gráfica e Editorial
Capa e Editoração: Allyson Vila Nova, Rafael Lira, Italo Amorim e Márcio Heitor
Revisão Ortográfica: Marcelo Melo
Ilustrações: Diego Almeida e Glaydson da Silva
Coordenação de Produção: Marizete Silva Santos
Sumário
Apresentação ........................................................................................5
Conhecendo o Volume 2 ......................................................................6
Capítulo 1 – Estruturas de Seleção .....................................................8
1.1. Estruturas de Controle .................................................................8
1.2. If… Else (se… senão) ..................................................................9
1.2.1. If Simples ............................................................................10
1.2.2. If Composto ........................................................................14
1.2.3. If Aninhado..........................................................................19
1.3. Switch (Escolha-Caso) ..............................................................24
1.4. Identação de um Programa .......................................................31
Capítulo 2 – Estruturas de Repetição ...............................................39
2.1. For (para... faça) ........................................................................39
2.2. While (enquanto... faça – teste no início) ..................................46
2.3. Do/while (repita... até - teste no final) ........................................49
2.4. Uso do break na Estrutura de Repetição ...................................56
Capítulo 3 – Modularização ................................................................64
3.1. O que são módulos e por que utilizá-los? .................................64
3.2. Estrutura de um módulo ............................................................66
3.3. Em que ponto do programa os módulos devem ser
implementados? ...............................................................................69
3.4. Escopo das Variáveis ................................................................70
3.5. Parâmetros ................................................................................71
3.6. Contexto do Módulo (Ação ou Resultado) .................................72
3.7. Ativando Funções ......................................................................73
Apresentação
Caro(a) aluno(a),
Seja bem-vindo (a) ao segundo módulo da disciplina Programação II. Nesta disciplina,
você está aprendendo a programar na linguagem de programação C, uma das mais
utilizadas mundialmente.
No volume I, você aprendeu os comandos básicos do C, que permitiram a construção
dos primeiros programas nesta linguagem. Neste volume II, será dado um novo passo,
conhecendo um pouco mais desta linguagem, analisando novos comandos que
melhorarão a capacidade de resolver problemas computacionais.
Este livro segue a mesma ideia do volume I, os assuntos são apresentados de forma
gradativa, com muitos exemplos de programas completos e comentados, visando um
bom entendimento, principalmente para as pessoas que estão iniciando no mundo da
programação. Ao final de cada capítulo, você poderá testar o seu aprendizado e assimilar
melhor o que foi estudado, através da resolução de exercícios. Isto é muito importante!
Não deixe de resolvê-los.
Vale lembrar que, para um bom andamento dos estudos destes novos assuntos, você
terá que ter assimilado o conteúdo do volume I, pois este continuará sendo utilizado em
todos os nossos programas. Mas isto não é um problema para quem vem resolvendo
questões de programação regularmente, não é mesmo?
O objetivo deste segundo módulo é apresentar as estruturas de controle de fluxo:
seleção e repetição. Além disso, também será analisada a divisão de programas em
módulos/funções, visando a um desenvolvimento mais rápido e um código mais legível.
Ao final deste módulo, você vai perceber o quanto a sua capacidade de resolver
programas foi aumentada. Convido-lhe para uma nova etapa no conhecimento da
linguagem de programação C. Vamos começar?
Bons estudos!
Sônia Virginia Alves França
6
Programação 2
Conhecendo o Volume 2
Neste segundo volume, vocês irão encontrar o módulo 02 da
disciplina: Programação II. Este volume está estruturado em três
capítulos, que serão estudados ao longo de 15h/aula. Para facilitar
seus estudos, veja a organização deste volume.
Capítulo 1: Estruturas de Seleção
Carga Horária do Capítulo 01: 5 h/aula
Objetivos do Capítulo 1: Apresentar a sintaxe das duas
estruturas de seleção (if e switch), disponíveis na linguagem de
programação C.
Conteúdo Programático do Capítulo 1
• Estruturas de controle
• Estrutura de seleção if: simples, composto e aninhado
• Estrutura de seleção switch.
Capítulo 2: Estruturas de Repetição
Carga Horária do Capítulo 02: 5 h/aula
Objetivos do Capítulo 2: Apresentar a sintaxe das três
estruturas de repetição (for, while e do/while), disponíveis na
linguagem de programação C.
Conteúdo Programático do Capítulo 2
• Estrutura de repetição for
• Estrutura de repetição while
• Estrutura de repetição do/while
• Comando break.
Capítulo 3: Modularização de Programas
Carga Horária do Capítulo 03: 5 h/aula
Objetivos do Capítulo 3: Apresentar como se criam
módulos(funções e procedimentos) em um programa C.
7
Programação 2
Conteúdo Programático do Capítulo 3
• Estrutura de um módulo
• Variáveis locais e globais
• Parâmetros
• Chamada de um módulo
• Comando return.
Ao final de cada capítulo vocês encontrarão:
• A seção “Atividades e Orientações de Estudo”: que contém
exercícios para a fixação do assunto estudado, além de
indicação de fóruns de discussão.
• A seção “Conheça Mais”: que contém dicas de sites e livros
que devem ser lidos para ampliar os seus conhecimentos.
• A seção “Vamos Revisar?”: que apresenta um resumo dos
principais tópicos abordados no capítulo.
8
Programação 2
Capítulo 1 – Estruturas de
Seleção
Vamos conversar sobre o assunto?
Nos programas que desenvolvemos até este momento, todos
os comandos que aparecem no programa são executados, ou seja,
o processador vai passando e executando cada um dos comandos
do programa. Existem situações em que não queremos que todos os
comandos sejam executados. Nestes casos, devemos utilizar alguma
estrutura de seleção, que nos permite desviar de uma sequência de
comandos do programa. Neste capítulo, iremos aprender a utilizar as
estruturas de seleção disponíveis na linguagem C, que são: if e switch.
Estas estruturas correspondem ao “se” e “escolha” do Portugol. As
estruturas de seleção também podem ser chamadas de: estruturas
de decisão ou estruturas de desvio. Vamos avançar, um pouco mais,
nossos conhecimentos em C?
1.1. Estruturas de Controle
De um modo geral, os comandos de um programa são executados
um após o outro, na ordem em que foram escritos – de cima para
baixo e da esquerda para a direita. Este é o fluxo de execução de um
programa. Mas, através do uso de estruturas de controle, podemos
controlar o fluxo de execução dos nossos programas. Existem três
tipos de estruturas de controle:• Sequência: nesta estrutura, todos os comandos são executados
uma única vez, de forma linear, um após o outro. Até então,
nossos programas foram desenvolvidos desta forma.
• Seleção: esta estrutura permite que um grupo de comandos
seja executado ou não, dependendo do resultado de uma
condição (representada por expressões relacionais ou lógicas).
Dessa forma, poderemos ter um conjunto de comandos do
nosso programa que não vai ser executado.
• Repetição: com estas estruturas, poderemos fazer com que
uma sequência de comandos seja executada várias vezes.
9
Programação 2
Para entender melhor as estruturas de controle, vamos fazer a
seguinte analogia: imagine que o nosso programa é uma estrada. As
retas são as sequências. Os entroncamentos são as estruturas de
seleção, que nos permitem pegar um caminho ou outro. As rotatórias
e os retornos são as estruturas de repetição, que nos permitem passar
várias vezes pelo mesmo local. A Figura 1.1 apresenta estradas com
retas, entroncamentos e rotatórias.
Figura 1.1: Retas, entroncamentos e rotatórias
Nas próximas seções, deste capítulo, vamos conhecer as
estruturas de seleção do C. No capítulo seguinte, conheceremos as
estruturas de repetição.
1.2. If… Else (se… senão)
A estrutura de seleção if é a estrutura de seleção mais simples. No
entanto, esta estrutura resolve todo e qualquer problema de seleção.
Esta estrutura permite executar um entre vários blocos de comandos.
A escolha de qual bloco será executado depende do resultado de uma
condição (expressão relacional ou lógica, apresentadas no capítulo
5 do volume I1). A sintaxe geral para o comando if é apresentada
abaixo:
Sintaxe
if (condição)
bloco_de_comandos1;
else
bloco_de_comandos2;
Neste comando, a condição é verificada e, caso o resultado seja
verdade, o bloco_de_ comandos1 será executado. Caso contrário, o
bloco_de_comandos2 é executado. Note que somente um dos blocos
Atenção
1 Vale lembrar que
o resultado de
uma expressão
relacional ou
expressão lógica
é sempre verdade
ou falso.
10
Programação 2
será executado. Apesar de possuir uma forma geral, esta estrutura
pode se apresentar de modos ligeiramente diferentes: if simples,
composto ou aninhado. Nas próximas seções vamos analisar,
separadamente, cada uma das possibilidades de sintaxe.
1.2.1. If Simples
O if simples é o if sem o else. O if simples é utilizado quando se
deseja executar uma sequência de comandos, apenas se a condição
for verdade. Dessa forma, não existe uma sequência de comandos
para ser executada quando a condição é falsa. A figura 1.2 apresenta
o fluxograma do if simples. A condição do if será testada, se for
verdade, o bloco de comandos vinculado ao if é executado. Se for
falso, o bloco de comandos vinculado ao if é desviado.
Figura 1.2: Fluxograma do if simples
As sintaxes para o if simples são as seguintes:
Sintaxe
if (condição)
comando;
if (condição)
{ comando1;
comando2;
}
Quando o if simples tem apenas um comando, utilizamos a sintaxe
da esquerda. Quando o if simples tem mais de um comando para ser
executado, devemos colocar a sequência de comandos entre chaves.
11
Programação 2
As chaves servem para que o compilador saiba quantos comandos2
vão ser desviados, caso a condição seja falsa. Quando não colocamos
as chaves, o compilador entende que apenas um comando deve ser
desviado. A figura 1.3 apresenta dois exemplos aplicando a sintaxe do
if simples.
if simples com um comando if simples com mais de um comando
main()
{ comando 1;
comando 2;
comando 3;
if (condicao)
comando 4;
comando 5;
comando 6;
comando 7;
}
main()
{ comando 1;
comando 2;
comando 3;
if (condicao)
{ comando 4;
comando 5;
}
comando 6;
comando 7;
}
Figura 1.3: Exemplos de if simples
Vamos analisar os exemplos da figura 1.3. O programa principal
da esquerda é formado por sete comandos. O programa vai sendo
executado, passando pelos comando1, comando2 e comando3. Ao
chegar no if, a condição é avaliada. Se a condição for verdade, o
comando4 será executado. Se esta condição for falsa, o comando4
será desviado (ou seja, não será executado). Na sequência, são
executados os comando5, comando6 e comando7.
O programa principal da direita também é composto de sete
comandos. Os comando1, comando2 e comando3 são executados.
Na seqüência, temos o if, que tem a sua condição avaliada. Se a
condição for verdade, os comando4 e comando5 são executados.
Caso contrário, os comando4 e comando5 são desviados. Como este
if possui dois comandos, foi necessário colocá-los entre chaves. Na
sequência, os comando6 e comando7 são executados.
Atenção
2 Até então,
tínhamos
somente as
chaves que
delimitavam
o corpo do
programa
principal.
Veremos que as
chaves também
aparecerão em
outras situações.
Atenção
As condições do
if devem vir entre
parênteses. Se
tivermos mais de
uma expressão
relacional, estas
são conectadas
por operadores
lógicos.
O abre chaves
que delimita
o bloco de
comandos
vinculado ao if é
colocado após a
condição do if. O
fecha chaves é
colocado após o
último comando
do bloco de
comandos do if.
O if e o else
devem ser
escritos todo em
letras minúsculas.
12
Programação 2
Vamos ver um exemplo do uso do if simples? O programa 1.1
solicita o saldo atual do cliente e o valor que ele deseja retirar no
banco. O programa vai calcular e apresentar o valor do saldo do
cliente, após o saque. Caso o saldo fique negativo, deve ser escrito
uma mensagem informando esta situação ao cliente.
Programa Completo 1.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
main()
{
float saldo,valor_saque;
printf(“Banco Poupe Aqui\n\n\n”);
printf(“Saldo atual: R$ “);
scanf(“%f”,&saldo);
printf(“\n\nValor do saque: R$ “);
scanf(“%f”,&valor_saque);
saldo = saldo – valor_saque;
printf(“\n\nSaldo apos o saque: R$%.2f
\n\n”,saldo);
if(saldo<0)
printf(“\nAtencao: sua conta ficou com saldo
NEGATIVO!\a”);
getche();
}
Comentários sobre o programa completo 1.1:
• Linha 1: início do programa principal, que é definido pelo:
“main()”.
• Linha 2: temos um abre chaves, que irá delimitar o corpo do
programa principal.
• Linhas 3: temos as declarações das duas variáveis do
programa: saldo e valor_saque.
• Linha 4: um printf que serve para colocar, no início da tela, o
título do que o programa faz. Neste caso, foi colocado o nome
do banco.
13
Programação 2
• Linha 5: printf para que o usuário saiba que precisa fornecer o
seu saldo atual.
• Linha 6: scanf que lê o saldo do cliente.
• Linha 7: printf para que o usuário saiba que precisa fornecer o
valor do saque.
• Linha 8: scanf que lê o valor do saque.
• Linha 9: Como já sabemos o valor do saldo e quanto será
sacado, podemos calcular quanto ficará o saldo depois do
saque.
• Linha 10: printf para apresentar o valor do saldo após o saque.
• Linha 11: if que testa se o saldo ficou negativo. A condição
para informar se o saldo está negativo é o saldo ser um valor
menor que zero (saldo < 0). Assim, a condição do if é montada
e colocada entre parênteses. Se o saldo for menor que zero, a
mensagem de saldo negativo deve ser apresentada.
• Linha 12: printf para mostrar que o saldo ficou inválido. Veja
que este comando está vinculado ao if, dessa forma, ele só
será executado se a condição do if for verdade. Como o if tem
apenas um comando, não precisamos colocar chaves.
• Linha 13: comando getche que faz com que a tela de
execução do programa fique aberta, e assim podemos ver o
resultado do programa. Nesta linha também poderíamos usar o
system(“pause”).• Linha 14: fecha chaves, indicando o final do programa
principal.
A figura 1.4 apresenta duas telas de execução do programa
completo 1.1. No primeiro caso, o saldo permanece positivo após o
saque. Dessa forma, o comando vinculado ao if não foi executado. No
segundo caso, o saldo ficou negativo após o saque, assim, o comando
vinculado ao if foi executado (printf que imprime mensagem de saldo
negativo).
14
Programação 2
Saldo positivo após o saque
Saldo negativo após o saque
Figura 1.4: Telas de execução do programa completo 1.1
Agora que já sabemos como usar o if simples, vamos aprender a
utilizar o if composto.
1.2.2. If Composto
O if composto é o if com o else, dessa forma, teremos uma
sequência de comandos que é executada quando a condição resulta
em verdade e uma outra sequência que é executada quando a
condição é falsa.
A figura 1.5 apresenta o fluxograma do if composto. A condição do
if será testada, se for verdade, o bloco de comandos 1 é executado.
Se for falsa, o bloco de comandos 2 é executado. Notem que apenas
um dos bloco de comando será executado.
15
Programação 2
Figura 1.5: Fluxograma do if composto
Seguem abaixo as sintaxes para o if composto:
Sintaxe
Caso 1 Caso 2
if (condição)
comando1;
else
comando2;
if (condição)
{ comando1;
comando2;
}
else
comando3;
Caso 3 Caso 4
if (condição)
comando1;
else
{ comando2;
comando3;
}
if (condição)
{ comando1;
comando2;
}
else
{ comando3;
comando4;
}
De um modo geral, na sintaxe do if composto, teremos o if,
juntamente com a condição que será testada. Abaixo da linha do
16
Programação 2
if, temos um comando ou uma sequência de comandos que será
executada se a condição for verdade. Logo em seguida temos o else e
um comando ou um sequência de comandos que é executada quando
a condição do if é falsa.
Vamos ver qual a diferença entre as quatro sintaxes. Existe uma
regra que diz: se tivermos mais de um comando para ser executado
quando a condição for verdade, temos que colocar a sequência de
comandos entre chaves. Para um único comando, as chaves não são
necessárias. A mesma regra vale para a sequência de comandos do
else, mais de um comando, a sequência deve vir entre chaves.
Analisando a tabela com as quatro sintaxes temos:
• Caso 1: Se a condição for verdade, apenas um comando será
executado. Se a condição for falsa, apenas um comando será
executado. Como tivemos um comando na sequência do if e
um comando na sequência do else, não é necessário colocar
chaves.
• Caso 2: Se a condição for verdade, vários comandos serão
executados. Dessa forma, é necessário colocar as chaves para
delimitar a sequência de comandos do if. Quando a condição
for falsa, apenas um comando será executado. Assim, não
necessita colocar as chaves no comando do else.
• Caso 3: Se a condição for verdade, apenas um comando
será executado. Com isso, não precisamos colocar as chaves
no comando do if. No entanto, se a condição for falsa, vários
comandos devem ser executados. Com isso, a sequência de
comandos do else deve vir entre chaves.
• Caso 4: Se a condição for verdade, vários comandos serão
executados. Dessa forma, precisamos colocar a sequência de
comandos do if entre chaves. Se a condição for falsa, também
serão executados vários comandos. Assim, a sequência do else
precisa ser colocada entre chaves.
Vamos analisar um programa completo que utiliza o if composto.
Este programa lê o nome do aluno e as suas duas notas. Em seguida,
calcula a média do aluno e apresenta uma mensagem informando se
o aluno foi aprovado ou reprovado (considerar que a média para ser
aprovado é igual ou maior que 7.0).
Atenção
O else não tem
condição. A
condição é do if.
Se a condição
for falsa, a
sequência do else
é executada.
Tomar cuidado
com as chaves
que delimitam
a sequência de
comandos do if e
do else.
17
Programação 2
Programa Completo 1.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
main()
{
float n1, n2, media;
char nome[20];
printf(“Caderneta de Notas\n\n”);
printf(“Nome do aluno: “);
fflush(stdin);
gets(nome);
printf(“Nota 1: “);
scanf(“%f”,&n1);
printf(“Nota 2: “);
scanf(“%f”,&n2);
media = (n1+n2)/2;
if (media>=7)
printf(“\n\n%s foi aprovado(a) com media
%.1f\n”,nome, media);
else
printf(“\n\n%s foi reprovado(a) com media
%.1f\n”,nome, media);
getche();
}
Comentários sobre o programa completo 1.2:
• Linha 1: inclusão da biblioteca stdio, devido o comando fflush,
que será usado quando formos ler o nome do aluno.
• Linha 2: início do programa principal, que é definido pelo:
“main()”.
• Linha 3: temos um abre chaves, que irá delimitar o corpo do
programa principal.
18
Programação 2
• Linhas 4 e 5: temos as declarações das variáveis do
programa.
• Linha 6: o printf que serve para colocar, no início da tela, o título
do que o programa faz. Neste caso, será colocado “caderneta
de notas”.
• Linhas 7 a 13: leitura das variáveis de entrada: nome do aluno,
a primeira e a segunda nota.
• Linha 14: cálculo da média do aluno.
• Linha 15: if composto que verifica qual o valor da média, para
escrever a mensagem se o aluno foi aprovado ou reprovado.
Para o aluno ser aprovado, a média tem que ser maior ou igual
a 7. A montagem da condição é feita utilizando operadores
relacionais. Além disso, a condição foi colocada entre
parênteses.
• Linha 16: printf que é executado quando a condição do if
for verdade. Neste caso, quando a média do aluno for maior
ou igual a 7. Note que a mensagem informa que o aluno foi
aprovado. Como apenas um comando está vinculado ao if, não
houve a necessidade de colocar chaves.
• Linha 17: temos um else, que indica que também teremos uma
sequência de comandos para ser executada quando a condição
do if for falsa, ou seja, média do aluno menor que 7.
• Linha 18: printf que é executado quando a condição do if for
falsa. Note que a mensagem informa que o aluno foi reprovado.
Como apenas um comando está vinculado ao else, não houve
a necessidade de colocar chaves.
• Linha 19: comando getche que faz com que a tela de execução
do programa fique aberta, e assim podemos ver o resultado do
programa.
• Linha 20: fecha chaves, indicando o final do programa
principal.
A figura 1.6 apresenta duas telas de execução do programa
completo 1.2. No primeiro caso, o aluno é aprovado e no segundo
caso, é reprovado.
19
Programação 2
Aluno aprovado
Aluno reprovado
Figura 1.6: Telas de execução do programa completo 1.2
Agora só falta estudarmos o último tipo de if, que é o if aninhado.
Vamos aprender mais um pouco?
1.2.3. If Aninhado
O if composto, visto na seção anterior, é usado quando temos
duas possibilidades de resposta. Por exemplo, ou o aluno é aprovado
ou é reprovado. Apenas uma situação irá ocorrer. O if aninhado
ocorre quando temos mais de duas possibilidades de respostas (ou
situação). Por exemplo, ao comparar dois números (x e y), temos
três possibilidades de resposta: x é menor que y, x é maior que y, ou
ainda, x e y são iguais. Assim, a primeira possibilidade será testada
na condição do if (verificando se x é menor que y). Se a condição for
falsa, ainda temos duas possibilidades de resposta. Para fazer esta
verificação, necessitamos de um outro if. Este novo if será colocado
dentro da sequência de comandos do else. Assim, teremos um if
dentro do outro, por isso é chamado de if aninhado.
20
Programação 2
A seguir, são apresentadas duas sintaxes de if aninhado. No
caso 1, temos três possibilidades de respostase no caso 2, quatro
possibilidades. Vale lembrar que podemos ir aninhando um if dentro
do outro, sem um limite de aninhamento. Só depende de quantas
possibilidades de situações teremos que testar.
Sintaxe
Caso 1: três possibilidades de
resposta
Caso 2: quatro possibilidades de
resposta
if (condição1)
comando1;
else
{ if (condicao2)
comando2;
else
comando3;
}
if (condição1)
comando1;
else
{ if (condicao2)
comando2;
else
{ if (condicao3)
comando3;
else
comando4;
}
}
No caso 1, se a condição1 do primeiro if for verdade, o comando1
será executado e toda a sequência do else é desviada. No entanto, se
a condição1 do if for falsa, o fluxo do programa é desviado para o else.
Quando chega no else, é encontrada uma sequência de comandos
(por isso é necessário colocá-la entre chaves). Mas, nesta sequência
tem um if, que precisa ter a sua condição avaliada. Se a condicao2
deste if for verdade, o comando2 é executado. Caso seja falsa, o
fluxo do programa é desviado para o else e executa o comando3.
Dessa forma, apenas um dos comandos (comando1, comando2 ou
comando3) será executado, os demais serão desviados.
Um comportamento similar ocorre com o caso 2, que analisa quatro
possibilidades de respostas.
Vamos analisar um programa completo que utiliza o if aninhado.
Atenção
Existe if sem else
(que é o primeiro
caso de if que
estudamos – if
simples), mas
todo else está
vinculado a um if.
Não colocar ponto
e vírgula depois
da condição do if
21
Programação 2
Neste programa, serão lidos dois números inteiros(x e y) e seus
valores serão comparados. O programa irá escrever uma das três
mensagens: x é maior que y, x é menor que y ou x e y são iguais. Na
sequência, as linhas do programa serão comentadas.
Programa Completo 1.3
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
main()
{
int x, y;
printf(“Compara Numeros\n\n”);
printf(“X: “);
scanf(“%d”,&x);
printf(“\nY: “);
scanf(“%d”,&y);
if (x > y)
printf(“\n\n%d eh maior que %d”,x,y);
else
{ if (x < y)
printf(“\n\n%d eh menor que %d”,x,y);
else
printf(“\n\nX e Y sao iguais: %d”,x);
}
getche();
}
Comentários sobre o programa completo 1.3:
• Linha 1: início do programa principal, que é definido pelo:
“main()”.
• Linha 2: temos um abre chaves, que irá delimitar o corpo do
programa principal.
• Linha 3: temos as declarações das variáveis do programa.
• Linha 4: o printf que serve para colocar, no início da tela, o título
22
Programação 2
do que o programa faz. Neste caso, será colocado “Compara
Números”.
• Linhas 5 a 8: leitura das variáveis de entrada: x e y.
• Linha 9: Agora que já conhecemos o valor de x e y, devemos
começar a comparação. Nesta linha temos um if, com a
condição para verificar se x é maior que y. Se esta condição
for verdade, o comando da linha 10 será executado e todos os
comandos dentro do else serão desviados.
• Linha 10: printf para escrever que x é maior que y.
• Linha 11: temos um else, o programa terá seu fluxo desviado
para o else, caso a condição do if seja falsa. Notem que, se o
x não é maior que y, ainda temos que descobrir se x é menor
que y ou se x e y são iguais. Por conta disto, na sequência de
comandos deste else, será necessário colocar um if composto.
Por termos uma seqüência de comandos, devemos colocá-la
entre chaves.
• Linhas 12: abre chaves para informar que começará a
sequência de comandos do else, além do if que verifica a
segunda possibilidade de resposta: se x é menor que y.
• Linha 13: printf para escrever que x é menor que y. Este printf
é executado caso a condição do if da linha 12 seja verdade.
• Linhas 14: temos um else, que está vinculado ao if da linha 12.
Ou seja, se a condição deste if for falsa, o fluxo do programa é
desviado para este else.
• Linha 15: printf para escrever que x e y são iguais. Este printf é
executado caso a condição do if da linha 12 seja falsa.
• Linhas 16 e 17: temos o getche() e o fecha chaves, indicando o
final do programa principal.
A figura 1.7 apresenta telas de execução do programa completo
1.3, mostrando as três possibilidades de respostas.
23
Programação 2
X menor que Y
X maior que Y
X igual a Y
Figura 1.7: Telas de execução do programa completo 1.3
Agora que já sabemos utilizar os três casos da estrutura de
seleção if: simples, composto e aninhado, vamos analisar um outro
tipo de estrutura de seleção disponível no C, que é o switch. Vale
lembrar que o if é um tipo de estrutura de seleção que pode ser
aplicada em qualquer situação em que seja necessária tomar uma
decisão no programa. O switch apresenta algumas restrições e nem
sempre poderemos utilizá-lo. No entanto, o switch tem uma sintaxe
mais “limpa” que a do if. Dessa forma, sempre que for possível o seu
uso, é interessante incluí-lo no programa. Vamos ver como o switch
funciona?
24
Programação 2
Figura 1.8: Quadrinhos sobre decisão
1.3. Switch (Escolha-Caso)
O switch é uma estrutura de decisão que permite a execução de uma
sequência de comandos a partir da análise do valor de uma variável
inteira ou de uma variável com um único caractere. Normalmente,
o switch é usado quando sabemos os prováveis valores que uma
variável pode armazenar, e para cada valor, temos que executar uma
sequência de comandos diferente. A grande restrição do switch é que
ele não funciona para variáveis reais, nem cadeia de caracteres. Além
disso, o switch testa se a variável é igual a um valor.
No caso de uma condição usada no if, nós podemos usar qualquer
tipo de variável, além de podermos verificar se seus valores são:
menor que, maior que, diferente de, etc., e não apenas a igualdade.
Por conta dessas restrições, não é em toda situação de seleção que o
switch pode ser utilizado. No Portugol, o switch é o comando escolha-
caso. Significando que uma sequência de comandos será escolhida,
caso a variável tenha um certo valor. Vamos analisar as sintaxes do
switch.
25
Programação 2
Sintaxe
Caso 1: sem o default Caso 2: com o default
switch (variavel)
{ case valor1: comando1;
comando2;
break;
case valor2: comando3;
comando4;
break;
case valor3: comando5;
comando6;
break;
}
switch (variavel)
{ case valor1: comando1;
comando2;
break;
case valor2: comando3;
comando4;
break;
case valor3: comando5;
comando6;
break;
default: comando7;
comando8;
break;
}
A sintaxe do switch é a seguinte: após o switch, colocamos o nome
da variável que será avaliada, entre parênteses. Para cada possível
valor que a variável pode assumir, colocaremos um case e ao lado, o
valor da variável seguido de dois pontos(:). Em seguida, colocamos
a sequência de comandos que deve ser executada, caso a variável
tenha este valor. A sequência de comandos deve ser finalizada com
o comando break, obrigatoriamente. Assim, para cada valor que a
variável pode assumir, teremos um case e a sequência de comandos.
A sequência de comandos não precisa vir entre chaves. No entanto,
temos as chaves que abre e fecha o comando switch.
Ao executar o switch, o processador irá procurar um case que
tenha o valor que a variável está armazenado no momento. Quando
encontrar, executa a sequência de comandos relacionada a este
valor e o break faz com que o fluxo do programa seja desviado para
o primeiro comando depois da chaves que fecha o switch. Assim,
só será executada a sequência de comandos de um único case. No
entanto, caso a variável não esteja armazenando um dos valores
26
Programação2
previstos, nenhuma sequência de comandos será executada.
Além dos case com os prováveis valores das variáveis, também
podemos colocar a cláusula default no nosso switch (Caso 2, da
sintaxe). O default funciona como um else, ou seja, se a variável
não tiver nenhum dos valores previstos nos case, será executada
a sequência de comandos do default. O default é opcional, assim,
podemos ter switch com ou sem default.
Abaixo, temos o exemplo 1.1 que apresenta um switch sem o
default. A variável cargo é inteira e pode assumir os valores 1, 2 ou 3.
Dependendo do cargo do funcionário, é dado um aumento diferenciado
ao salário do mesmo. Notem o break no final de cada sequência de
comandos dos case.
Exemplo 1.1: Switch sem default
1
2
3
4
5
6
7
8
switch (cargo)
{ case 1: sal = sal + 200;
break;
case 2: sal = sal + 400;
break;
case 3: sal = sal + 600;
break;
}
No exemplo 1.2 temos um switch com o default. Neste exemplo,
se a variável cargo não estiver com 1, 2 ou 3, será executada a
sequência de comandos do default. Ou seja, qualquer outro valor
diferente dos valores previstos, a sequência de comandos do default
será executada.
Atenção
O default deve
ser, sempre, a
última sequência
de comandos do
switch.
Não podemos
colocar dois
case testando o
mesmo valor.
Quando a variável
do switch for um
char, devemos
colocar os
possíveis valores
da variável entre
apóstrofos, por
exemplo: case
‘a’:.
27
Programação 2
Exemplo 1.2: Switch com default
1
2
3
4
5
6
7
8
9
10
switch (cargo)
{ case 1: sal = sal + 200;
break;
case 2: sal = sal + 400;
break;
case 3: sal = sal + 600;
break;
default: sal = sal + 100;
break;
}
Uma outra situação que pode acontecer é: uma mesma sequência
de comandos deve ser executada para diferentes valores da variável.
Por exemplo, para os funcionários dos cargos 1 e 2 será dado o mesmo
aumento salarial. Assim, para não repetirmos a mesma sequência de
comandos no case 1 e 2, faremos como mostra a linha 2 do exemplo
1.3. Coloca-se o primeiro case com o respectivo valor e após os dois
pontos, vem o próximo case e o valor que será testado. Podemos
colocar quantos case sejam necessários.
Exemplo 1.3: Switch
1
2
3
4
5
6
7
8
switch (cargo)
{ case 1: case 2: sal = sal + 200;
break;
case 3: sal = sal + 600;
break;
default: sal = sal + 100;
break;
}
Vamos analisar um programa completo que faz uso do switch. Uma
empresa concederá um aumento de salário aos seus funcionários,
28
Programação 2
variável de acordo com o cargo, conforme a tabela abaixo. Faça
um programa que leia o cargo de um funcionário (1-Gerente,2-
Engenheiro,3-Técnico) e o seu salário atual e calcule o novo salário.
Se o cargo do funcionário for inválido, deverá ser impressa uma
mensagem de erro. Como resultado, mostre o salário antigo, o novo
salário e a diferença de salário.
Cargo Percentual
Gerente 10%
Engenheiro 20%
Técnico 30%
29
Programação 2
Programa Completo 1.4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
main()
{
int cargo;
float sal, nsal;
printf(“Empresa Legal\n\n\n”);
printf(“Cargo(1-Gerente/2-Engenheiro/3-
Tecnico): “);
scanf(“%d”,&cargo);
printf(“\nSalario atual: “);
scanf(“%f”,&sal);
switch (cargo)
{ case 1: nsal=sal*1.1; break;
case 2: nsal=sal*1.2; break;
case 3: nsal=sal*1.3; break;
default: printf(“\n\nCargo Invalido!\n”);
break;
}
if ((cargo>=1) && (cargo<=3))
{ printf(“\n\n______________________________
\n”);
18
20
21
22
23
24
25
printf(“\n\nResultados\n\n”);
printf(“\nSalario Antigo..............: R$
%.2f\n”,sal);
printf(“\nSalario Novo................: R$
%.2f\n”,nsal);
printf(“\nDiferenca de Salarios: R$
%.2f\n”,nsal - sal);
}
getche();
}
30
Programação 2
Comentários sobre o programa completo 1.4:
• Linhas 3 e 4: temos as declarações das variáveis do programa.
O cargo do funcionário será armazenado em uma variável do
tipo int. Quando tiver armazenado 1, significa que o funcionário
é um gerente, 2 é engenheiro e 3 é técnico.
• Linha 5: o printf que serve para colocar, no início da tela, o
título da empresa.
• Linha 6: printf que solicita que o usuário digite o cargo do
funcionário. Como estamos usando uma legenda, ou seja, um
número representando cada cargo, precisamos colocar neste
printf o significado de cada número.
• Linha 7: scanf para ler o cargo do funcionário.
• Linha 8: printf para solicitar a digitação do salário do
funcionário.
• Linha 9: scanf para lê o salário do funcionário.
• Linha 10: switch que avalia o cargo do funcionário, para calcular
seu novo salário. Cada cargo tem um aumento de salário
diferente. Como foi solicitado que imprima uma mensagem de
erro quando o cargo foi inválido, será colocado o default.
• Linhas 11 a 15: nestas linhas temos os case de cada valor
da variável cargo, além do default. Para cada case, colocamos
a fórmula para o cálculo do novo salário. No default, temos o
printf que escreve a mensagem de cargo inválido. Notem que
o break aparece no final da sequência de comando de cada
case.
• Linha 16: este if foi colocado para testar se o cargo digitado é
válido. Sendo válido, podemos apresentar os resultados.
• Linhas 17 a 23: temos os printf que apresentam os resultados
do programa: o salário antigo, o novo e a diferença dos
salários.
• Linhas 24 e 25: temos o getche() e o fecha chaves, indicando o
final do programa principal.
A figura 1.9 apresenta duas telas de execução do programa
completo 1.4.
Atenção
Atenção: neste
programa a
variável cargo
armazenará 1
(quando o cargo
for gerente),
2 (quando for
engenheiro) e
3 (quando for
técnico). Dessa
forma, esta
variável será do
tipo inteiro.
31
Programação 2
Cargo Válido
Cargo Inválido
Figura 1.9: Telas de execução do programa completo 1.4
Notem que, quando o cargo é inválido, apenas a mensagem de
erro é apresentada. Quando o cargo é válido, os resultados são
apresentados.
Agora que já sabemos usar as estruturas de seleção do C, vamos
abrir um parênteses para falar sobre a identação dos comandos dos
programas.
1.4. Identação de um Programa
A identação é a forma como alinhamos os comandos do nosso
programa. O alinhamento faz com que o código fique mais fácil de
ser lido. Vamos entender a identação do programa completo 1.4,
analisando a figura 1.10.
32
Programação 2
main()
{
int cargo;
float sal, nsal;
printf(“Empresa Legal\n\n\n”);
printf(“Cargo(1-Gerente\2-Eng.\3-Tecnico): “);
scanf(“%d”,&cargo);
printf(“\nSalario atual: “);
scanf(“%f”,&sal);
switch (cargo)
{ case 1: nsal=sal*1.1; break;
case 2: nsal=sal*1.2; break;
case 3: nsal=sal*1.3; break;
defaul: printf(“\n\nCargo Invalido!\n”);
break;
}
if ((cargo>=1) && (cargo<=3))
{ prinft(“\n\n____________________________\n”);
prinft(“\n\nResultados\n\n”);
prinft(“\nSalario Antigo...: R$ %.2f\n”, sal);
prinft(“\nSalario Novo....: R$ %.2f\n”, nsal);
prinft(“\nDiferenca: R$ %.2f\n”, nsal - sal);
}
getche();
}
Figura 1.10: Código Identado
Cada chaves que abre deve ficar no mesmo alinhamento da chaves
que fecha. Assim, a chaves que abre o programa, fica alinhada com a
chaves que fecha o programa. Com as chaves alinhadas fica mais fácil
33
Programação 2
de verificar se alguma chave está “descasada”. As chaves3tambémdevem ficar alinhadas com a estrutura que elas estão delimitando.
Vejam a chaves do main, do switch e do if.
Notem também, que a sequência de comandos dentro do switch e
do if fica um pouco mais para dentro. Dessa forma, nós destacamos
os comandos que estão dentro da estrutura. Quando colocamos todos
os comandos do nosso programa no mesmo alinhamento, fica mais
difícil de visualizar quais comandos fazem parte de uma estrutura de
controle.
A figura 1.11 apresenta o mesmo código, mas sem a identação,
vejam que o switch e o if ficam menos visíveis.
Dica de
Programação
3 Sempre que abrir
uma chaves no
seu programa, já
coloque a chaves
que fecha. Assim
não corre o risco
de esquecer a
chaves que fecha
uma sequência de
comandos.
34
Programação 2
main()
{
int cargo;
float sal, nsal;
printf(“Empresa Legal\n\n\n”);
printf(“Cargo(1-Gerente\2-Engenheiro\3-Tecnico): “);
scanf(“%d”,&cargo);
printf(“\nSalario atual: “);
scanf(“%f”,&sal);
switch (cargo)
{case 1: nsal=sal*1.1; break;
case 2: nsal=sal*1.2; break;
case 3: nsal=sal*1.3; break;
defaul: printf(“\n\nCargo Invalido!\n”); break;}
if ((cargo>=1) && (cargo<=3))
{prinft(“\n\n____________________________\n”);
prinft(“\n\nResultados\n\n”);
prinft(“\nSalario Antigo..........: R$ %.2f\n”, sal);
prinft(“\nSalario Novo...........: R$ %.2f\n”, nsal);
prinft(“\nDiferenca de Salarios: R$ %.2f\n”, nsal -
sal);
}
getche ();
}
Figura 1.11: Código sem Identação
Bem melhor ler o código identado, não é mesmo? Não deixem de
identar todos os programas. Vocês verão que fica mais fácil e rápido
de entender.
35
Programação 2
Atividades e Orientações de Estudo
Os nossos programas vão começar a crescer de tamanho e, a cada
capítulo que avançamos, teremos novas possibilidades de fazer coisas
bem interessantes. Nesta seção, temos uma lista de programas que
devemos resolver, para efetivar o nosso conhecimento nas estruturas
de seleção. Vocês irão notar que algumas questões só podem ser
feitas usando o if, mas outras podem ser resolvidas com o uso do
switch. Liguem o computador e comecem a programar!
1. Faça um programa que lê 2 valores A e B (inteiros) e informa se
A é divisível por B ou não.
2. Faça um programa que leia um número inteiro e mostre uma
mensagem indicando se este número é par ou ímpar, e se é
positivo ou negativo.
3. Tendo como dados de entrada a altura e o sexo(1-feminino/2-
masculino) de uma pessoa, construa um programa que calcula
e escreve seu peso ideal, utilizando as seguintes fórmulas:
• para homens: (72.7*altura)-58
• para mulheres: (62.1*altura)-44.7
4. Um hotel cobra R$ 50,00 reais a diária e mais uma taxa de
serviços. A taxa de serviços é de:
• 15,30 por dia, se número de diárias <15
• 10,00 por dia, se número de diárias =15
• 8,50 por dia, se número de diárias >15
Faça um programa que lê a quantidade de dias que o hóspede
ficou no hotel e imprime a taxa e total a pagar.
5. Elaborar um programa que irá ler três números inteiros diferentes
e informa qual é o maior valor.
6. Elaborar um programa que irá ler quatro inteiros diferentes e
informa qual é o menor valor.
7. Escrever um programa que lê a matrícula do aluno e suas 3
notas. Calcular a média e verificar qual o seu conceito, conforme
36
Programação 2
a tabela:
Média Conceito
>= 9,0 A
>= 7,5 e < 9,0 B
>= 6,0 e < 7,5 C
>= 4,0 e < 6,0 D
< 4,0 E
O programa deve escrever a matrícula do aluno, suas notas, a
média, o conceito correspondente e a mensagem: APROVADO
se o conceito for A, B ou C e REPROVADO se o conceito for D
ou E.
8. Escrever um programa que lê a hora de início e hora de término
de um jogo, ambas subdivididas em dois valores distintos: horas
e minutos. Calcular e escrever a duração do jogo, também em
horas e minutos, considerando que o tempo máximo de duração
de um jogo é de 24 horas e que o jogo pode iniciar em um dia e
terminar no dia seguinte.
9. Fazer um programa que leia uma data (dia e mês) e informe se é
primavera, verão, outono ou inverno. Sabe-se que as estações,
no hemisfério sul, começam nas seguintes datas:
• Primavera: 22/Set
• Verão: 21/Dez
• Outono: 20/Mar
• Inverno: 20/Jun
10. Faça um programa para ler o peso de uma encomenda, tipo
de entrega(1-sedex, 2-sedex 10) e região onde será entregue a
encomenda(1- Norte, 2-Nordeste, 3-Centro-Oeste, 4-Sudeste,
5-Sul). Calcular o valor de postagem baseado nas tabelas
abaixo:
Até 1 Kg R$ 5,00
De 1 Kg a 5 Kg R$ 10,00
37
Programação 2
Acima de 5 Kg R$ 15,00 + R$ 3,00 por Kg excedente
Para entrega por Sedex Adicionar R$ 9,00
Para entrega por Sedex 10 Adicionar R$ 11,00
Para entregar na região Norte Adicionar R$ 3,00
Para entregar na região Nordeste Adicionar R$ 2,00
Para entregar na região Centro-Oeste Adicionar R$ 6,00
Para entregar na região Sudeste Adicionar R$ 5,00
Para entregar na região Sul Adicionar R$ 7,00
Conheça Mais
Para ampliar nossos conhecimentos sobre os assuntos tratados
neste capítulo, leiam o capítulo que aborda as estruturas de seleção,
do livro:
SCHILDT, Herbert. C Completo e Total. São Paulo: Makron,
1996.
Vamos Revisar?
Vamos revisar um pouco o assunto visto neste capítulo? Façamos
uma leitura do resumo a seguir:
• Estruturas de seleção servem para analisar condições e valores
de variáveis verificando se uma sequência de comandos deve ser
executada ou desviada.
• As estruturas de seleção do C são: if e switch.
• O if pode ser: simples(quando não tem o else), composto
(quando tem o else) e aninhado (quando temos um outro if dentro
da sequência de comandos do else).
38
Programação 2
• O if avalia uma condição, se a mesma for verdade, a sequência
de comandos do if é executada.
• O switch é uma estrutura de seleção que avalia o valor de uma
variável inteira ou caractere.
• No final da sequência de comando do case, devemos colocar um
break, forçando a saída da estrutura de seleção switch.
• A identação dos comando de um programa torna o código mais
legível e fácil de entender.
39
Programação 2
Capítulo 2 – Estruturas de
Repetição
Vamos conversar sobre o assunto?
Neste capítulo, vamos abordar as estruturas de repetição. Como
mencionado da seção 1.1 do capítulo anterior, com estas estruturas
poderemos repetir uma sequência de comandos quantas vezes
forem necessário. A linguagem de programação C fornece três
tipos de estrutura de repetição: for, while e do/while. Entendendo as
características de cada estrutura de repetição, poderemos escolher a
mais adequada para resolver um dado problema. Vamos em frente!
Figura 2.1: Quadrinho sobre repetição
2.1. For (para... faça)
A estrutura de repetição for é equivalente ao para/faça do Portugol.
Esta estrutura costuma ser utilizada quando sabemos quantas vezes
a sequência de comandos deve ser repetida. A contagem dos ciclos
é feita por uma variável chamada de contador. A estrutura for também
é chamada de estrutura de repetição com contador. Sua sintaxe é a
seguinte:
40
Programação 2
Sintaxe
for (var-controle = inicio; condição;
atualização_var-controle)
comando1;
for (var-controle = inicio; condição;
atualização_var-controle)
{ comando1;
comando2;
comandon;
}
Onde:
• var-controle: é a variável que controla a quantidade de
repetições. Esta variável é inicializada e atualizada a cada
repetição.
• início: é o valor inicial da variável que controla o for. Ao iniciar a
repetição, a variável de controle é inicializada com este valor.
• condição: expressão relacional ou lógica que é testada ao final
de cada repetição. Se a condição for verdade a sequência de
comandos é executada mais uma vez. Quando a condição é
falsa, a repetição para.Dessa forma, temos que ter certeza que
algum momento a condição se tornará falsa. Caso contrário,
entraremos em um loop infinito. Ou seja, o programa fica
repetindo a sequência de comandos infinitamente.
• atualização_var-controle: a cada vez que a repetição é
executada, a variável de controle deve ser atualizada. Nesta
parte do for, colocamos a expressão que atualizará a variável
de controle. É com esta atualização que faremos com que a
condição do for se torne falsa e a repetição tenha fim.
Notem que cada parte do for é separada por ponto e vírgula. Mas
não colocamos o ponto e vírgula depois do comando que atualiza a
variável de controle, nem após o fecha parênteses.
A estrutura de repetição for funciona da seguinte forma:
41
Programação 2
• Passo 1: a variável de controle é inicializada.
• Passo 2: a condição é analisada. Se for verdade, a sequência
de comandos da repetição é executada.
• Passo 3: ao terminar de executar a sequência de comandos
da repetição, a variável de controle é atualizada. E retorna ao
passo 2, verificando se a condição continua sendo verdade
(para repetir mais uma vez a sequência de comandos) ou se é
falsa ( parando a repetição).
A figura 2.2 apresenta o funcionamento da estrutura de repetição
for.
Figura 2.2 Funcionamento da estrutura de repetição for.
Assim como o if, se houver mais de um comando vinculado ao for,
devemos colocar a sequência de comandos entre chaves. Se houver
apenas um comando, não há necessidade de colocar as chaves.
Vamos ver dois exemplos do uso do for. No exemplo 2.1 temos um
for que será repetido 10 vezes. A variável de controle i é inicializada
com 1. Cada vez que é finalizada uma execução do comando vinculado
ao for, é incrementado 1 valor da variável 14. Esta repetição vai parar
quando i for igual a 11. Cada vez que o for é executado, é escrito o
valor atual de i na tela. Assim, será escrito de 1 a 10 na tela.
Exemplo 2.1: for com variável de controle sendo incrementada
1
2
for (i=1; i<=10; i++)
printf(“\nO valor de i= %d”, i);
No exemplo 2.2, temos um for que também será repetido 10 vezes.
No entanto, a variável de controle inicia com 10 e é decrementada a
Atenção
A variável de
controle do for
deve ser do tipo
inteiro.
O for deve ser
escrito todo em
minúsculo.
Atenção
4 Estão lembrados
do operador ++?
Este operador
acrescenta uma
unidade a uma
variável. Ele foi
abordado na
seção 5.3 do
Volume I.
42
Programação 2
cada final da repetição. Notem que esta repetição vai parar quando o i
é 0. Este for também faz a impressão de 1 a 10 na tela. Só que, dessa
vez, os números serão impressos na ordem decrescente.
Exemplo 2.2: for com variável de controle sendo decrementada
1
2
for (i=10; i>=1; i--)
printf(“\nO valor de i= %d”, i);
Vamos agora analisar um programa completo que usa o comando
for. Uma loja quer calcular um bônus que dará a cinco clientes. O
bônus depende de quanto cada cliente comprou. Os clientes que
compraram menos de R$ 500 receberão de bônus 10% do valor das
compras. Os clientes que compraram a partir de R$ 500 receberão de
bônus, 15% do valor das compras. O programa deve ler o código do
cliente e o valor das compras e escrever o valor do bônus, para cada
um dos cinco clientes.
43
Programação 2
Programa Completo 2.1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
main()
{ float valor;
int cod, i;
for (i=1; i<=5; i++)
{ system(“cls”);
printf(“Loja Compre Tudo\n\n”);
printf(“Codigo do Cliente %d: “,i);
scanf(“%d”,&cod);
printf(“\nValor das compras: “);
scanf(“%f”,&valor);
if (valor<500)
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.1);
else
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.15);
printf(“\n\ntecle enter para
continuar...”);
getche();
}
}
Comentários sobre o programa completo 2.1:
• Linhas 2 e 3: temos as declarações das variáveis do programa.
O valor das compras, o código do cliente e o i, que será a
variável de controle do for.
• Linha 4: primeira linha do for, indicando que a variável i será
inicializada com 1, a condição para permanecer repetindo é i
ser menor ou igual a 5 e o incremento do i, que terá seu valor
aumentado em uma unidade a cada repetição. Da linha 5 até 17
temos a sequência de comandos que será repetida 5 vezes.
44
Programação 2
• Linha 5: abre chaves para delimitar a sequência de comandos
vinculada ao for. Nesta linha também temos um comando novo:
system(“cls”); Este comando5 limpa a tela, eliminado tudo que
tem escrito. Com o uso deste comando, cada vez que formos
cadastrar os dados de um novo cliente, a tela é limpa, ficando
assim mais organizado. Depois vocês podem comentar esse
comando do programa e vejam o que acontece sem ele.
• Linha 6: printf para colocar o nome da empresa.
• Linha 7: printf para solicitar a digitação do código do funcionário.
Vejam que nesta mensagem, é colocado o valor do i, isto é
interessante para que o usuário saiba qual cliente está sendo
digitado no momento, se é o primeiro, o quarto, etc.
• Linha 8: scanf para ler o código do cliente.
• Linha 9: printf que solicita o valor das compras do cliente.
• Linha 10: scanf para ler o valor das compras do cliente.
• Linhas 11: Como já sabemos o valor das compras do cliente,
devemos calcular o valor do bônus. O bônus pode ser de 15%
ou 10%. Para decidir qual bônus o cliente levará, usaremos uma
estrutura de decisão. Assim, nesta linha temos um if composto,
que verifica se o valor das compras é menor que R$500.
• Linhas 12: printf que é executado se a condição do if for
verdade. Notem que no próprio printf é feita a conta de quanto
o cliente receberá de bônus. Aqui é dado um bônus de 10% ao
cliente.
• Linha 13: temos o else, já que se trata de um if composto.
• Linha 14: printf que é executado se a condição do if for falsa.
Aqui é dado um bônus de 15% ao cliente.
• Linha 15: temos os printf que dá uma mensagem para que o
usuário tecle enter e dê prosseguimento a um novo cadastro.
• Linha 16: temos o getche() que faz com que possamos ver o
valor do bônus do cliente.
• Linha 17: fecha chaves que delimita a sequência de comandos
do for.
• Linha 18: fecha chaves do programa principal6.
Atenção
5 cls significa
clear screen. Ou
seja, limpe a tela.
Atenção
6 Fiquem atentos
a identação do
programa.
45
Programação 2
A figura 2.3 apresenta uma tela de execução do programa completo
2.1.
Figura 2.3: Tela de execução do programa completo 2.1
Na próxima seção iremos estudar o segundo tipo de estrutura de
repetição do C, o while.
Figura 2.4: Quadrinho - O castigo de Pablo
46
Programação 2
2.2. While (enquanto... faça – teste no início)
A estrutura de repetição while é equivalente ao enquanto/faça do
Portugol. Nesta estrutura uma condição é avaliada, e enquanto a
condição for verdade, a sequência de comandos será executada. Se
a condição for falsa, a repetição será interrompida. O while avalia a
condição antes da primeira iteração7, isto significa que, eventualmente,
pode não ocorrer sequer a primeira iteração. Por isso, esta estrutura
é chamada também de: repetição que faz teste no início. A sintaxe do
while é a seguinte:
Sintaxe
while (condição)
comando;
while (condição)
{ comando1;
comando2;
comandon;
}
Ao lado do while colocamos a condição (entre parênteses) que
será avaliada e que faz com que a repetição seja executada ou não.
Ao final de cada iteração, a condição é avaliada para verificar se
continua sendo verdade, para que a repetição seja executada mais
uma vez ou pare. No while também poderá acontecer o problema de
loopinfinito. Por isso, temos que ter certeza que em algum momento
a condição se tornará falsa, para que a repetição tenha fim. Seguindo
a mesma regra do if e do for, se tivermos mais de um comando
vinculado ao while, devemos colocar a sequência de comandos entre
chaves. Podemos ler o comando while da seguinte forma: “enquanto
a condição for verdade, faça esta sequência de comandos”. A figura
2.5 apresenta o esquema de funcionamento da estrutura while.
Saiba Mais
7 Iteração é um
termo muito
utilizado na
computação
e significa
repetição.
47
Programação 2
Figura 2.5: Funcionamento da estrutura de repetição while
Como podemos ver na figura 2.5, antes de entrar na sequência
de comandos do while a condição é testada, se for verdade, executa
os comandos vinculados ao while, quando termina, retorna para
testar a condição novamente. Enquanto for verdade, fica repetindo
a sequência de comandos. Quando for falsa, desvia para o primeiro
comando depois do while.
Vamos analisar o programa completo 2.2, que resolve a mesma
questão do programa completo 2.1, só que usando a estrutura de
repetição while. Para garantir que a repetição será executada 5
vezes, será declarada uma variável responsável por contar cada vez
que é terminada uma iteração do while. O valor desta variável será
testado na condição do while, e a repetição será executada enquanto
o contador for menor ou igual a 5.
48
Programação 2
Programa Completo 2.2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
main()
{
float valor;
int cod, contador;
contador = 1;
while (contador<=5)
{ system(“cls”);
printf(“Loja Compre Tudo\n\n”);
printf(“Codigo do Cliente %d: “,contador);
scanf(“%d”,&cod);
printf(“\nValor das compras: “);
scanf(“%f”,&valor);
if (valor<500)
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.1);
else
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.15);
contador++;
printf(“\n\ntecle enter para
continuar...”);
getche();
}
}
Comentários sobre o programa completo 2.2:
• Linhas 3 e 4: temos as declarações das variáveis do programa.
O valor das compras, o código do cliente e o contador que irá
controlar a repetição.
• Linha 5: Nesta linha temos a inicialização do contador. Assim,
49
Programação 2
é atribuído 1 ao contador. Isto indica que iremos começar a
primeira iteração do while.
• Linha 6: temos o while, juntamente com a condição de
permanência da repetição. Assim, esta repetição é feita
enquanto o contador for menor ou igual a 5. Notem que,
obrigatoriamente, a condição virá entre parênteses, certo?
• Linhas 7 a 20: sequência de comandos vinculada ao while,
que será executada cinco vezes. Para cada cliente é pedido o
seu código e o valor das suas compras. O bônus é calculado de
acordo com o valor das compras e apresentado na tela.
• Linha 17: observem que nesta linha é somado mais 1 ao
valor do contador. Dessa forma, cada vez que passamos pela
repetição, o contador vai aumentado seu valor, até fazer com
que a condição se torne falsa e a repetição pare. Quando
usamos o for, a inicialização, a condição e o incremento da
variável do controle fica tudo ao lado do for. No while, temos
estas três partes, só que separadas: na linha 5 tivemos a
inicialização do contador, na linha 6 temos a condição e na linha
17 o incremento do contador. Se esquecermos de incrementar o
contador, a condição não se tornará falsa, nunca, e entraremos
em um loop infinito.
• Linha 21: fecha chaves do programa principal.
A execução deste programa resulta em uma tela idêntica a do
programa anterior, apresentada na figura 2.3.
Vamos agora entender o funcionamento do terceiro e último tipo
de repetição do C, que é o do/while.
2.3. Do/while (repita... até - teste no final)
A estrutura de repetição do/while equivale ao repita...até do
Portugol. A principal diferença entre o do/while e o while é o ponto
onde a condição é testada. Como vimos na seção anterior, a condição
do while fica no início do bloco e assim, a verificação é feita antes de
executar o bloco de comandos. Se a condição for falsa já no primeiro
teste, os comando vinculados ao while não são executados nenhuma
vez. No caso do do/while, a condição só vem após a sequência de
comandos. Com isso, o teste só é feito após a execução dos comandos
50
Programação 2
do do/while. A sintaxe do do/while é a seguinte:
Sintaxe
do
comando;
while (condição);
do
{ comando1;
comando2;
comandon;
} while (condição);
O comando do/while começa com o do, e logo em seguida
colocamos a sequência de comandos que será repetida. Após a
sequência de comandos, coloca-se o while com a condição que será
testada para verificar se continua a repetição ou não. Quando tivermos
mais de um comando, as chaves que delimitam os comandos do do/
while são obrigatórias. Prestem atenção o local correto das mesmas.
O abre chaves que indica o início da sequência deve vir depois do
do. O fecha chaves que indica o final da sequência, deve vir antes do
while. Outro detalhe importante é que, depois da condição (que deve
vir entre parênteses), devemos colocar um ponto e vírgula8.
O esquema da execução do do/while é apresentado na figura 2.6.
Figura: 2.6: Funcionamento da estrutura de repetição do/while
O do serve, na verdade, para indicar que a sequência de comandos
vai começar. A sequência de comandos é executada e, ao encontrar
Atenção
8 Não colocamos
ponto e virgula
após a condição
do if, nem após
a condição do
while.
51
Programação 2
o while, a condição é testada. Se a condição for verdade, retorna ao
primeiro comando da sequência. Se a condição for falsa, executa o
primeiro comando depois do do/while. O comando do/while pode ser
lido da seguinte forma: “faça a sequência de comandos enquanto a
condição for verdade”.
Agora, vamos fazer o programa completo 2.1, usando o do/while.
Do mesmo modo que foi necessário no while, teremos que ter uma
variável que serve de contador, para ficar verificando se já executou a
repetição cinco vezes.
52
Programação 2
Programa Completo 2.3: uso do do/while
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
main()
{
float valor;
int cod, contador;
contador = 1;
do
{ system(“cls”);
printf(“Loja Compre Tudo\n\n”);
printf(“Codigo do Cliente %d: “,contador);
scanf(“%d”,&cod);
printf(“\nValor das compras: “);
scanf(“%f”,&valor);
if (valor<500)
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.1);
else
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.15);
contador++;
printf(“\n\ntecle enter para
continuar...”);
getche();
} while (contador <=5);
}
Comentários sobre o programa completo 2.3:
• Linhas 3 e 4: temos as declarações das variáveis do programa.
O valor das compras, o código do cliente e o contador que irá
controlar a repetição.
• Linha 5: Nesta linha temos a inicialização do contador.
53
Programação 2
Linha 6: temos o do, indicando que será iniciada uma estrutura de
repetição do/while.
• Linhas 7 a 19: sequência de comandos vinculada ao do/while,
que será executada cinco vezes. Para cada cliente é pedido o
seu código e o valor das suas compras. O bônus é calculado de
acordo com o valor das compras e apresentado na tela. Notem
que na linha 17 temos o incremento do contador.
• Linha 20: temos o fecha chaves e o while, juntamente com a
condição que é avaliada para que prossiga uma nova repetição
da sequência de comandos ou pare de executar o do/while.• Linha 21: temos o fecha chaves do programa principal.
Vimos aqui um mesmo problema sendo resolvido com os três tipos
de repetição do C. No problema em questão, foi mencionado quanto
elementos (clientes) seriam cadastrados. Assim, estes programas
SEMPRE repetem a sequência 5 vezes. Em várias situações, não
sabemos previamente quantos elementos serão cadastrados. Dessa
forma, não saberíamos o valor a ser colocado na condição da estrutura
de repetição para indicar a sua parada. Mas tem uma solução: quando
não soubermos quantos elementos serão cadastrados, usaremos o
do/while, da forma como será apresentada no programa completo
abaixo. Este programa tem o mesmo enunciado do programa 2.1,
no entanto, ele poderá cadastrar uma quantidade indeterminada de
clientes.
54
Programação 2
Programa Completo 2.4: uso do do/while
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
main()
{
float valor;
int cod, continuar;
do
{ system(“cls”);
printf(“Loja Compre Tudo\n\n”);
printf(“Codigo do Cliente: “);
scanf(“%d”,&cod);
printf(“\nValor das compras: “);
scanf(“%f”,&valor);
if (valor<500)
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.1);
else
printf(“\n\nValor do bonus R$ %.2f\n”,
valor*0.15);
printf(“\n\n\nDeseja cadastrar outro
(1-sim/2-nao)? “);
scanf(“%d”, &continuar);
} while (continuar==1);
}
Comentários sobre o programa completo 2.4:
• Notem que não teremos a variável contador. Teremos agora
uma variável inteira que foi chamada de continuar. A condição
de parada deste do/while avalia o valor armazenado na variável
continuar.
• Linhas 3 e 4: temos as declarações das variáveis do programa.
O valor das compras, o código do cliente e a variável inteira
continuar que irá controlar a repetição.
55
Programação 2
• Linha 5: do que inicia a sequência da repetição.
• Linhas 6 a 17: sequência de comandos vinculada ao do/while.
Nesta sequência temos a solicitação dos dados do cliente, e
apresentação do bônus que o cliente tem direito.
• Linha 16: Após apresentar o valor do bônus, é feita a seguinte
pergunta ao usuário: “deseja cadastrar outro (1-sim/2-não)? “.
Na linha 16 temos o printf que escreve esta pergunta na tela. O
usuário deverá digitar 1 se quiser cadastrar outro, que significa:
“sim, eu quero cadastrar”. Ou digitar 2 porque não tem mais
clientes para cadastrar.
• Linha 17: scanf para ler a resposta do cliente, que deve ser 1
para continuar ou 2 para parar. O valor que o usuário digitar,
será armazenado na variável continuar.
• Linha 18: temos o fecha chaves e o while, juntamente com
a condição que é avaliada para que prossiga uma nova
repetição da sequência de comandos ou pare de executar o
do/while. Notem que a condição é: (continuar == 1). Ou seja,
enquanto o usuário estiver respondendo 1, informando que
quer continuar cadastrando, novos cadastros serão feitos. A
parada ocorre quando o usuário responde 2. Dessa forma, não
precisamos determinar a quantidade de vezes que a repetição
será executada. A execução dependerá apenas da resposta do
usuário. Assim, uma vez nós poderemos executar a repetição
2 vezes, na outra 10, na outra 3, etc. Diferente da outra forma
de resolver, que sempre executava uma quantidade de vezes
pré-determinada. A resolução da questão desta forma, trás
mais flexibilidade ao programa, uma vez que o usuário repete
o cadastro quantas vezes ele desejar. Uma outra observação
é que não houve a necessidade de colocarmos o getche(). A
questão é que, como nós tivemos que fazer a leitura da variável
continuar, o scanf que lê esta variável, faz com que a tela fique
parada esperando o usuário fornecer a resposta. Por isso, não
houve necessidade de colocar o getche().
• Linha 19: temos o fecha chaves do programa principal.
A figura 2.7 apresenta uma tela de execução do programa completo
2.4.
56
Programação 2
Figura 2.7: Tela de execução do programa completo 2.4
De acordo com a figura 2.7, após os usuário fornecer os dados
do cliente e receber o valor do bônus que o cliente tem direito, é
feita a pergunta se ele deseja ou não cadastrar outro. Assim que for
respondido 2, ou seja, não quer mais cadastrar, a janela do programa
irá fechar. Enquanto estiver respondendo 1, novos cadastros são
feitos.
2.4. Uso do break na Estrutura de Repetição
Vimos anteriormente o comando break finalizando a sequência
de comandos de um case, da estrutura de seleção switch. Mas, este
comando também pode ser usado para forçar o encerramento de
uma estrutura de repetição. Se um break for executado dentro de
uma estrutura de repetição, o fluxo do programa será desviado para o
primeiro comando depois da repetição. Mesmo que a repetição ainda
não tenha sido executada a quantidade de vezes que foi determinada.
Normalmente, o comando break é colocado na sequência de comandos
de uma estrutura de seleção e só é executado, caso alguma situação
aconteça.
Vamos analisar o programa completo 2.5. Neste programa, o
cliente tem um limite de R$ 200 no cartão de crédito da loja. Conforme
as suas compras vão sendo passadas no caixa, seu saldo vai sendo
avaliado. Se a compra de um novo item ultrapassar o limite permitido,
o programa deve parar a venda. Mas, se ele tiver limite, a compra
pode ser feita e finalizada normalmente.
Atenção
Todas as
estruturas de
repetição são
escritas em
minúsculo.
Atentem a
identação dos
comandos do
programa.
A sequência de
comandos de
uma estrutura de
controle, seja de
repetição ou de
seleção, poderá
ser composta
por qualquer
comando válido
da linguagem.
Assim,
poderemos ter
uma estrutura
de repetição
dentro da outra.
Se houver
necessidade de
colocar um for
na sequência
de comandos
de outro for,
devemos utilizar
uma variável de
controle diferente
para cada for
57
Programação 2
Programa Completo 2.5: uso do break na repetição
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
main()
{ float preco, total;
int continuar;
total = 0;
do
{ system(“cls”);
printf(“Loja Compre Tudo - Adicionar
produto\n\n”);
printf(“Preco do produto: “);
scanf(“%f”,&preco);
if ((total + preco) <= 200)
total = total + preco;
else
{ printf(“\n\nA adicao deste produto
vai extrapolar o seu limite!”);
printf(“\n\nTecle enter para
finalizar...”);
getche();
break;
}
printf(“\n\nDeseja adicionar outro
(1-sim/2-nao)? “);
scanf(“%d”, &continuar);
} while (continuar==1);
printf(“\n\nTotal a pagar: %.2f”, total);
22
23
getche();
}
Comentários sobre o programa completo 2.5:
• Linhas 2 e 3: declaração das variáveis do programa: preço
58
Programação 2
do produto, total das compras e continuar (para verificar se a
repetição deve ser executada ou não).
• Linha 4: inicialização da variável total, que armazena o valor
total das compras9.
• Linha 5: do que inicia a sequência da repetição.
• Linhas 6 a 20: sequência de comandos vinculada ao do/while.
Nesta sequência temos a solicitação do preço do produto que
o cliente está comprando. A cada novo produto comprado é
preciso verificar se o total da compra extrapola os 200 reais
do limite do cartão. Esta verificação é feita no if da linha 10. Se
o limite extrapolar, será executada a sequência de comandos
do else da linha 12. Assim, é impressa uma mensagem que
não pode mais adicionar produtos e, logo em seguida, executa
o break da linha 16, forçando a saída do do/while. Como não
pode mais comprar produtos, temos que sairda repetição.
Por isso foi usado o break. Mas, se a compra não extrapolar o
limite, o cliente vai fazendo as compras dos produtos que ele
desejar. Dessa forma, a execução do break ocorre mediante
a ocorrência de uma situação, que neste caso foi o estouro do
limite.
• Linha 21: Após sair da repetição, devemos imprimir quanto foi
o valor das compras do cliente. Neste printf será escrito o total.
• Linhas 22 e 23: temos getche() e o fecha chaves do programa
principal.
A figura 2.8 apresenta duas telas de execução do programa
completo 2.5.
Adição de produto na Nota Fiscal
Atenção
9Sempre que
uma variável
for servir de
acumulador, seu
conteúdo deve
ser inicializado.
Normalmente com
zero.
59
Programação 2
Adição de produto que extrapola o limite
Figura 2.7: Telas de execução do programa completo 2.5
Agora que já vimos alguns exemplos completos de programas
que utilizam as estruturas de repetição, que tal resolvermos umas
questões?
Atividades e Orientações de Estudo
Estamos aqui, mais uma vez, para colocar nossos conhecimentos
em prática. Nesta lista, temos 12 questões que utilizam comandos
de repetição. Nos enunciados, quando for indicado que a quantidade
de elementos é desconhecida, resolva a questão utilizando um do/
while (que pergunta se o usuário quer continuar ou parar). Coloquem
comentários nos seus programas, deixando-os bem documentados.
Além disso, prestem muita atenção para manter o código identado. É
importante ser um programador organizado. Vamos começar?
1. Uma empresa deseja aumentar seus preços em 20%. Faça um
programa que leia o código e o preço de custo de cada produto
e calcule o preço novo. Calcule também, a média dos preços
com e sem aumento. Mostre o código e o preço novo de cada
produto e, no final, as médias. A quantidade de dados que serão
cadastrados é desconhecida.
2. Pablo tem 1,50 m e cresce 2 centímetros por ano, enquanto
Edson tem 1,10 m e cresce 3 centímetros por ano. Construa
um programa que calcule e imprima quantos anos serão
necessários para que Edson seja maior que Pablo.
3. Escrever um programa que leia 5 pares de valores, o primeiro
valor é a matrícula do aluno, e o segundo a sua altura em
60
Programação 2
centímetros. Encontre o aluno mais alto e o mais baixo. Mostre
a matrícula do aluno mais alto e do mais baixo, junto com suas
alturas.
4. Escrever um programa que leia um conjunto de 10 informações
contendo, cada uma delas, a altura e o sexo(1- mas/2- fem),
calcule e mostre o seguinte:
• a maior e a menor altura da turma
• a média da altura das mulheres
• a média da altura da turma.
5. Foi feita uma pesquisa entre os 50 habitantes de uma região.
Foram coletados os dados de idade, sexo (1-mas/2-fem) e
salário. Faça um programa que informe:
• a média de salário do grupo;
• maior e menor idade do grupo;
• quantidade de mulheres com salário até R$ 200.
6. Com o lançamento de notebooks no mercado nacional,
um fabricante deseja obter determinadas informações dos
seus possíveis consumidores. Para cada empresa ou órgão
pesquisado foi digitado os seguintes dados:
• Preferência desejada (fabricante): 1-Toshiba/2-HP/3-Sony
• Possuem computadores de grande porte: 1-Sim/2-Não
• Necessitam de notebooks: 1. Sim/2. Não
Deseja-se saber:
• A quantidade de empresas pesquisadas;
• Quantas empresas possuem computadores de grande porte;
• Percentual de empresa que necessitam de notebooks
• Percentual de empresas que tem preferência pela Toshiba.
A quantidade de dados que serão cadastrados é
desconhecida.
7. Foi feita uma pesquisa estatística nas 50 principais cidades de
quatro Estados para coletar dados sobre acidentes de trânsito.
Foram obtidos os seguintes dados:
61
Programação 2
• Código da cidade
• Estado (1-PE, 2-PB, 3-RN, 4-CE)
• Número de veículos de passeio (em 2008)
• Número de acidentes de trânsito com vítimas (em 2008)
Deseja-se saber:
• qual o maior e o menor índice de acidentes de trânsito e a que
cidades pertencem;
• qual a média de veículos nas cidades;
• qual a média de acidentes com vítimas entre as cidades do
Estado de Pernambuco.
8. A Empresa Legal decidiu fazer um levantamento dos candidatos
que se inscreveram para preenchimento de vaga no seu quadro
de funcionários, utilizando processamento eletrônico e você foi
contratado, então faça um programa que:
Leia um conjunto de informações para cada candidato,
contendo: número de inscrição do candidato, idade, sexo(1-
fem/2-mas), experiência anterior(1-sim/2-nao)
Calcule:
• Quantidade de candidatos
• Quantidade de candidatas
• Média de idade dos homens com experiência
• Percentagem dos homens com mais de 45 anos, entre os
homens
• Quantidade de mulheres com idade inferior a 35 anos e com
experiência
• Menor idade entre as mulheres que já tem experiência no
serviço
A quantidade de dados que serão cadastrados é
desconhecida.
9. Faça um programa para realizar a totalização dos votos da
eleição para a prefeitura concorrida entre 3 candidatos. Para
cada seção são informados o número de votos do candidato
62
Programação 2
A, o número de votos do candidato B, o número de votos do
candidato C, o número de votos brancos e o número de votos
nulos. A quantidade de seções que serão cadastradas é
desconhecida. Determine e imprima:
• O número de votantes;
• O total de votos de cada candidato;
• O total de votos brancos e total de votos nulos;
• O total de votos válidos;
• O candidato com maior número de votos;
• Se a eleição foi válida e para isso o total de votos brancos
mais votos nulos deve ser menor que o total de votos válidos;
• Se haverá segundo turno, para não haver segundo turno basta
que o total de votos do candidato vencedor seja maior que 50%
dos votos válidos
• Percentual de votos nulos.
10. Ler 20 notas e imprimir as três maiores.
Conheça Mais
Vocês poderão encontrar mais detalhes sobre estruturas de
repetição no livro:
ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene
Aparecida Veneruchi. Fundamentos de Programação de
Computadores. São Paulo: Prentice Hall, 2002.
O interessante é que, os autores primeiro dão as explicações em
Portugol, e depois fazem a tradução para a sintaxe da linguagem de
programação C e Pascal.
63
Programação 2
Vamos Revisar?
Vamos revisar as estruturas de repetição? Observem o resumo a
seguir:
• As estruturas de repetição possibilitam que uma sequência de
comandos possa ser executada várias vezes.
• As estruturas de repetição da linguagem de programação C são:
for, while e do/while.
• A estrutura de repetição for é mais utilizada quando sabemos
quantas vezes uma repetição será executada.
• A estrutura de repetição while avalia o resultado de uma condição
para verificar se deve ou não executar uma sequência de comandos.
Enquanto a condição for verdade, a repetição é executada. A
condição do while fica no início da sequência de comandos.
• A estrutura de repetição do/while também avalia uma condição
para permanecer repetindo a execução de uma sequência de
comandos. No entanto, a condição só é avaliada após a execução
da sequência de comandos.
• O comando break também pode ser utilizado para forçar a parada
de uma repetição.
• Quando não tomamos cuidado de tornar a condição de uma
repetição falsa, ocorre o loop infinito.
64
Programação 2
Capítulo 3 – Modularização
Vamos conversar sobre o assunto?
Neste capítulo, vamos aprender a programar de forma
modularizada. Até agora, toda a sequência de comandos dos nossos
programas foi escrita dentro do programa principal (main), em um
bloco único. Vocês vão ver que podemos dividir os nossos programas
em módulos. A modularização é uma das alternativas mais
Continue navegando
Compartilhar