Programacao_I_-_Volume_2 by Antonio Carlos

Programação I

Sônia Virginia Alves França

Volume 2

Recife, 2009

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 e Italo Amorim 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 Considerações Finais..........................................................................80 Conhecendo a Autora..........................................................................81

Apresentação Caro(a) cursista, Seja bem-vindo (a) ao segundo módulo da disciplina Programação I. 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

Programação I

Conhecendo o Volume 2 Neste segundo volume, vocês irão encontrar o módulo 2 da disciplina: Programação I. 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. 6

Programação I

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.

Programação I

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.

Programação I

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 9

Atenção 1 Vale lembrar que o resultado de uma expressão relacional ou expressão lógica é sempre verdade ou falso.

Programação I

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;

{ 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. 10

Programação I

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 4;

comando 5;

comando 6;

}

comando 7;

comando 6;

}

comando 7;

Atenção 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. 2

} 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 sequê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 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.

Programação I

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

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;

10 11 12

printf(“\n\nSaldo \n\n”,saldo);

apos

saque:

R$%.2f

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. 12

Programação I

» 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 negativo. 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).

Programação I

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.

Programação I

Figura 1.5: Fluxograma do if composto

Seguem abaixo as sintaxes para o if composto: Sintaxe Caso 1

Caso 2

if (condição)

comando1;

{ comando1;

else

comando2;

} else comando3;

Caso 3

Caso 4

if (condição)

comando1;

{ comando1;

else

comando2;

{ comando2;

}

comando3;

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 15

Programação I

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. 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.

» 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).

Programação I

Programa Completo 1.2

#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)

16 17 18

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. 17

Programação I

» 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.

Programação I

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. 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. 19

Programação I

A seguir, são apresentadas duas sintaxes de if aninhado. No caso 1, temos três possibilidades de respostas e 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

comando2;

comando3;

{

if (condicao3)

}

comando3;

else

comando4;

} }

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

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. 20

Programação I

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

main()

{

int x, y;

printf(“Compara Numeros\n\n”);

printf(“X: “);

scanf(“%d”,&x);

printf(“\nY: “);

scanf(“%d”,&y);

if (x > y)

else

{ if (x < y)

}

getche();

}

printf(“\n\n%d eh maior que %d”,x,y);

printf(“\n\n%d eh menor que %d”,x,y); else printf(“\n\nX e Y sao iguais: %d”,x);

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 21

Programação I

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 sequência de comandos, devemos colocá-la entre chaves. » Linha 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. » Linha 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.

Programação I

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?

Programação I

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 escolhacaso. Significando que uma sequência de comandos será escolhida, caso a variável tenha um certo valor. Vamos analisar as sintaxes do switch.

Programação I

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;

}

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 abrem e fecham 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 25

Programação I

previstos, nenhuma sequência de comandos 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’:.

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 no 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

switch (cargo)

{ case 1: sal = sal + 200;

case 2: sal = sal + 400;

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.

Programação I

Exemplo 1.2: Switch com default

switch (cargo)

{ case 1: sal = sal + 200;

case 2: sal = sal + 400;

case 3: sal = sal + 600;

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 com mais de um case com a mesma sequência de comandos

switch (cargo)

{ case 1: case 2: sal = sal + 200;

case 3: sal = sal + 600;

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, 27

Programação I

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,2Engenheiro,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%

Programação I

Programa Completo 1.4

main()

{

int cargo;

float sal, nsal;

printf(“Empresa Legal\n\n\n”);

printf(“Cargo(1-Gerente/2-Engenheiro/3Tecnico): “);

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;

}

if ((cargo>=1) && (cargo<=3))

{

printf(“\n\n_________________________\n”);

printf(“\n\nResultados\n\n”);

default: printf(“\n\nCargo break;

Invalido!\n”);

printf(“\nSalario Antigo..............: R$ %.2f\n”,sal);

printf(“\nSalario Novo................: R$ %.2f\n”,nsal);

printf(“\nDiferenca %.2f\n”,nsal - sal);

}

getche();

}

Salarios:

Programação I

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. 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.

» 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.

Programação I

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.

Programação I

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 break;

Invalido!\n”);

} 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 32

Programação I

de verificar se alguma chave está “descasada”. As chaves3também devem 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.

Programação I

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.

Programação I

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 seus computadores 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/2masculino) 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 35

Programação I

a tabela: Média

Conceito

>= 9,0

>= 7,5 e < 9,0

>= 6,0 e < 7,5

>= 4,0 e < 6,0

< 4,0

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

Programação I

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). 37

Programação I

» 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.

Programação I

Capítulo 2 – Estruturas de Repetição Vamos conversar sobre o assunto? Neste capítulo, vamos estudar as estruturas de repetição. Como mencionado na 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:

Programação I

Sintaxe

for (var-controle = atualização_var-controle)

inicio;

condição;

inicio;

condição;

comando1; for (var-controle = 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: 40

Programação I

» 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.

Atenção A variável de controle do for deve ser do tipo inteiro. O for deve ser escrito todo em minúsculo.

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 ao valor da variável i4. 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

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 41

Atenção 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. 4

Programação I

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

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.

Programação I

Programa Completo 2.1

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)

12 13

valor*0.1);

printf(“\n\nValor do bonus R$ %.2f\n”,

else

printf(“\n\nValor do bonus R$ %.2f\n”, valor*0.15);

printf(“\n\ntecle continuar...”);

}

enter

para

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 o for 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. 43

Programação I

Atenção 5 cls significa clear screen. Ou seja, limpe a tela.

» 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. » Linha 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. » Linha 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.

Atenção Fiquem atentos com a identação do programa. 6

» Linha 17: fecha chaves que delimita a sequência de comandos do for. » Linha 18: fecha chaves do programa principal6.

Programação I

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

Programação I

2.2. While (enquanto... faça – teste no início) Saiba Mais Iteração é um termo muito utilizado na computação e significa repetição. 7

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 loop infinito. 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.

Programação I

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.

Programação I

Programa Completo 2.2

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)

14 15 16 17 18

valor*0.1);

printf(“\n\nValor do bonus R$ %.2f\n”,

else

printf(“\n\nValor do bonus R$ %.2f\n”, valor*0.15);

contador++;

printf(“\n\ntecle continuar...”);

}

enter

para

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, 48

Programação I

é 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 49

Programação I

do do/while. A sintaxe do do/while é a seguinte: Sintaxe

do comando; while (condição); do { comando1; comando2; comandon; } while (condição);

Atenção 8 Não colocamos ponto e vírgula após a condição do if, nem após a condição do while.

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 ao 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 50

Programação I

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.

Programação I

Programa Completo 2.3: uso do do/while

main()

{

float valor;

int cod, contador;

contador = 1;

{

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)

14 15 16 17 18

valor*0.1);

printf(“\n\nValor do bonus R$ %.2f\n”,

else

printf(“\n\nValor do bonus R$ %.2f\n”, valor*0.15);

contador++;

printf(“\n\ntecle continuar...”);

getche();

}

while (contador <=5);

}

enter

para

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. 52

Programação I

» 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 2.4. Este programa tem o mesmo enunciado do programa 2.1, no entanto, ele poderá cadastrar uma quantidade indeterminada de clientes.

Programação I

Programa Completo 2.4: uso do do/while

main()

{

float valor;

int cod, continuar;

{

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)

13 14

valor*0.1);

printf(“\n\nValor do bonus R$ %.2f\n”,

else

printf(“\n\nValor do bonus R$ %.2f\n”, valor*0.15);

printf(“\n\n\nDeseja (1-sim/2-nao)? “);

cadastrar

scanf(“%d”, &continuar);

}

while (continuar==1);

}

outro

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. 54

Programação I

» 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.

Programação I

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.

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.

Programação I

Programa Completo 2.5: uso do break na repetição

main()

{ float preco, total;

int continuar;

total = 0;

{

system(“cls”);

printf(“Loja produto\n\n”);

Compre

Tudo

printf(“Preco do produto: “);

scanf(“%f”,&preco);

if ((total + preco) <= 200)

else

total = total + preco;

{ printf(“\n\nA adicao vai extrapolar o seu limite!”);

getche();

break;

Adicionar

finalizar...”);

printf(“\n\nTecle

deste

produto

enter

para

}

printf(“\n\nDeseja (1-sim/2-nao)? “);

adicionar

outro

scanf(“%d”, &continuar);

} while (continuar==1);

printf(“\n\nTotal a pagar: %.2f”, total);

getche();

}

Comentários sobre o programa completo 2.5: » Linhas 2 e 3: declaração das variáveis do programa: preço 57

Programação I

do produto, total das compras e continuar (para verificar se a repetição deve ser executada ou não).

Atenção Sempre que uma variável for servir de acumulador, seu conteúdo deve ser inicializado. Normalmente com zero. 9

» 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 sair da 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 o 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

Programação I

Adição de produto que extrapola o limite

Figura 2.8: 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 10 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 59

Programação I

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 foram digitados 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 desconhecida.

dados

que

serão

cadastrados

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: 60

Programação I

» 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(1fem/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 desconhecida.

dados

que

serão

cadastrados

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 61

Programação I

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.

Programação I

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.

Programação I

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 utilizadas para desenvolver grandes programas, pois deixa o código mais legível e aumenta a produtividade dos programadores. No entanto, a modularização apresenta muitas outras vantagens. Vamos descobrir isso agora?

3.1. O que são módulos e por que utilizá-los?

Saiba Mais Napoleão Bonaparte foi imperador da França e esteve no poder durante 15 anos. Nesse tempo, conquistou grande parte do continente europeu. Os biógrafos afirmam que seu sucesso deu-se devido ao seu talento como estrategista, além do seu espírito de liderança. 10

A melhor maneira de desenvolver um programa grande é construílo a partir de pequenas partes, que são chamadas de módulos. Esta técnica é chamada dividir para conquistar, uma estratégia de guerra criada pelos romanos e muito utilizada por Napoleão Bonaparte10, quando tentou conquistar o mundo. Como o território a ser conquistado era muito extenso, ele o dividiu em pequenos territórios e foi conquistando cada parte por vez. Uma vantagem desta técnica é que focamos a nossa atenção em um problema pequeno de cada vez. No final, teremos a solução do problema como um todo. Para compreender melhor este conceito, vamos fazer uma analogia: suponham que nós precisamos construir uma casa. Mas esta não é uma atividade simples, devido a sua complexidade. No entanto, podemos dividir esse problema em partes menores: alvenaria, sistema elétrico, sistema hidráulico, acabamento, pintura, etc. e assim, fica mais simples de entendermos cada parte separadamente (Figura 3.1). Caso ainda existam partes complexas, podemos continuar dividindo em partes ainda menores. Por exemplo, o sistema hidráulico pode ser dividido em caixa de água, bombas, canos, registros, etc. Este processo de decomposição contínua também é conhecido como refinamentos sucessivos, porque se parte de um problema complexo e abrangente, que é sucessivamente dividido até resultar em problemas mais simples e específicos. 64

Programação I

Alvenaria

Sistema Elétrico

Pintura

Sistema Hidráulico Figura 3.1: Divisões da construção de uma casa

Os módulos (também chamados de funções, rotinas ou subprogramas) são a essência da programação estruturada. Os módulos são segmentos de programa que executam uma tarefa específica. Os módulos servem para dividir um grande programa em diversas partes menores. De acordo com as boas práticas de programação: “sempre que possível, evite códigos extensos, separando os mesmos em módulos, visando a um rápido entendimento e uma manutenção facilitada”. A modularização permite que cada módulo do programa seja escrito, testado e revisado individualmente sem alterar o funcionamento do programa como um todo. Os programadores podem testar suas funções separadamente, permitindo que muitos erros do sistema completo sejam retirados antes que ele esteja totalmente pronto. A modularização também permite que um programa seja escrito por vários programadores ao mesmo tempo, cada um desenvolvendo um módulo em separado. É como a construção de uma casa, que podemos contratar vários funcionários. Esta divisão do trabalho acelera o desenvolvimento dos programas e reduz custos. Uma outra utilização da modularização é quando um trecho de código é utilizado várias vezes em um programa. Devemos colocar este trecho em um módulo e, sempre que preciso, fazemos a “chamada” do módulo. Com isso, reduzimos a quantidade de linhas de código do programa. A maior parte das linguagens de programação fornece um conjunto de funções (módulos) que são utilizadas pelos programadores, evitando que o mesmo tenha que implementá-las. A utilização de 65

Programação I

funções que já existem, diminui o tempo de desenvolvimento do programa. Além disso, o fato de utilizar uma função que já foi testada em diversos programas, reduz o risco de erros. É como se costuma dizer: “não vamos reinventar a roda”. Se a função está pronta, disponível e correta, o programador não deve perder tempo em implementar a mesma coisa. É só fazer uso da mesma. Um exemplo de uso de módulos que já existem, é quando utilizamos alguma função da biblioteca math, como sqrt (raiz quadrada) e pow (potência). As próximas seções descrevem como devemos fazer para desenvolver programas modularizados.

3.2. Estrutura de um módulo Ao receber um problema, o programador deverá verificar se este problema pode ser resolvido com uma solução particionada ou modularizada. Vamos usar o seguinte exemplo: fazer um programa que calcule a média do aluno e verifique se o mesmo foi aprovado ou reprovado. A princípio, podemos pensar que o cálculo da média do aluno e a descoberta da sua situação (aprovado ou reprovado) serão implementados em dois módulos. Dessa forma, nosso programa seria formado por 2 módulos, além do programa principal. Mas poderemos notar, durante a implementação, que algumas partes de código se repetem em diversos pontos do programa e, por isso, elas também são candidatas a se tornarem módulos. A sintaxe para construir módulos, em C, é a seguinte: Sintaxe

tipo_de_retorno parâmetros])

nome_da_função([declaração

{ [declaração de variáveis locais] bloco de instruções da função [return ] }

Toda a declaração de módulos/funções deve seguir ao formato acima. As partes entre colchetes são opcionais. Vamos ver o que significa cada componente da estrutura de um módulo: » Tipo_de_retorno: especifica qual o tipo de dado é retornado 66

Programação I

pela função, podendo ser qualquer tipo de dado da linguagem (int, float, char, etc.). Se a função não retorna nenhum valor, devemos definir o retorno como void, que significa ausente de retorno. Vale ressaltar que existe apenas um valor de retorno para funções em C. Um exemplo de módulo que retorna um valor é o sqrt, ou seja, ao ser executado, ele nos retorna a raiz quadrada de um número. » Nome da função: indica o nome pelo qual o bloco de código correspondente à função será chamado. É através do nome da função que poderemos chamá-la quando desejarmos a sua execução. As regras para nomear um função são as mesmas que utilizamos para nomear as nossas variáveis. » Declaração de parâmetros: é na declaração de parâmetros que informamos ao compilador quais serão as entradas da função. Para cada um dos parâmetros deve ser declarado o seu tipo e nome. Se a função não receber nenhum parâmetro, deve-se deixar os parênteses sem nada entre eles. Os parâmetros servem para passarmos alguma informação para a função. A função sqrt recebe um número real como parâmetro. Para calcular uma raiz quadrada, a função precisa que o programador informe de qual valor será calculada a raiz quadrada. O valor que é fornecido a função, é o parâmetro. Já a função pow, precisa receber dois parâmetros para que possa elevar um número a um expoente qualquer. » Declaração das variáveis locais: as variáveis que são específicas de um módulo são chamadas de variáveis locais. Todas as variáveis locais devem ser declaradas dentro da função, antes de qualquer comando. Uma variável local somente pode ter seu valor acessado dentro da função em que foi declarada. Um módulo pode não ter nenhuma variável local. » Corpo da função: sequência de comandos que compõem a função. É similar ao corpo do programa principal. O corpo de uma função é delimitado por chaves. • return: o comando return finaliza a execução da função que está sendo executada. Se a função retornar algum valor (o tipo de retorno não é void) este comando é obrigatório. Se a função tiver retorno do tipo void, este comando não precisa ser colocado. 67

Programação I

A figura 3.2 apresenta uma função que calcula a média das duas notas de um aluno.

Tipo de retorno

Lista de parâmetros Nome da função

float calc_media(float n1, float n2) { float m; m = (n1 + n2)/2; return m; } Retorno da função

Variável Local

Figura 3.2: Função para calcular a média do aluno

Vamos identificar cada parte da estrutura desta função. Esta função se chama calc_media e precisa receber dois parâmetros para calcular a média do aluno. Os parâmetros são as duas notas do aluno: n1 e n2. Como cada nota é um número real, na frente de cada parâmetro é colocado o seu tipo (float) e separado por vírgula. Mesmo que os parâmetros sejam do mesmo tipo, precisamos colocar o tipo de cada parâmetro, na frente do seu nome. O objetivo desta função é calcular uma média. Dessa forma, ao terminar a sua execução, a função irá retornar a média do aluno. Por isso, o tipo de retorno da função é float. Como esta função tem um retorno, no final da sequência de comandos, devemos colocar o comando return, e ao lado dele, o nome da variável que tem armazenado o valor que será retornado. Neste caso, a variável que tem este valor é m. Esta é uma variável local, ou seja, uma variável que foi declarada dentro deste módulo. Por conta disto, só pode ser usada no módulo calc_media. Vamos discutir um pouco mais sobre alguns dos conceitos apresentados, para depois iniciarmos a implementação de mais funções. 68

Programação I

3.3. Em que ponto do programa os módulos devem ser implementados? A execução de um programa C é sempre iniciada pelo main(), que é o módulo principal do programa, por isso ele tem esse nome. Um programa pode ter várias funções, bem como poderá utilizar funções definidas em outros programas. Além disso, uma função poderá fazer uso de outra função. Dessa forma, as funções definidas no programa devem ser escritas antes do programa principal. E ainda, se a funcao1, faz uso da funcao2, a função2 deve ser escrita antes da funcao1. Isto é feito por uma razão. Ao compilar o programa, o compilador precisa conhecer, com antecedência, quais são os tipos de retorno e quais são os parâmetros das funções para que o código seja gerado corretamente. É por isto que as funções são colocadas antes do programa principal. Quando o compilador chegar no programa principal (main), ele já terá compilado as funções e já saberá seus formatos. Quando são utilizadas funções que estão em outros programas, o programador deverá informar, através da diretiva #include, a biblioteca ou o arquivo onde a função foi implementada. O caso mais comum é o uso de funções que estão nas bibliotecas padrão do C, como por exemplo, o comando para limpar o buffer de entrada: fflush(stdin), que se encontra na biblioteca stdio (standard in/out). A figura 3.3 apresenta a nova estrutura dos nossos programas C. Inclusão das Bibliotecas Declaração de Constantes Declaração de Variáveis Globais Declaração dos Módulos Programa Principal Figura 3.3: Nova estrutura dos programas C

O que temos nesta nova estrutura é a seção de declaração de variáveis globais, que são as variáveis que são utilizadas por todos os módulos do programa (mais detalhes na próxima seção). Além da seção de declaração dos módulos, que vem antes do programa principal. É neste ponto do programa que devemos declarar nossos módulos. 69

Programação I

3.4. Escopo das Variáveis Quando programamos sem utilizar modularização, as variáveis são declaradas no início do programa principal. Com esta forma de declaração, as variáveis só podem ser acessadas pelo programa principal. Agora que começaremos a programar com módulos, para que uma variável possa ser acessada por todos os módulos do programa, ela deve ser declarada fora de qualquer módulo. Estas variáveis são chamadas de globais. As variáveis globais devem ser declaradas fora de qualquer módulo e programa principal, logo após a inclusão das bibliotecas. Quando programamos de forma modularizada, em alguns casos, uma determinada variável é utilizada apenas por um módulo específico, o que não justifica uma definição global, pois somente será utilizada dentro dos limites do módulo. Quando isto acontece, a variável deve ser declarada dentro do módulo e é denominada variável local. O escopo ou abrangência de uma variável indica por quais módulos do programa esta variável é visível e pode ser utilizada. Assim, podemos dizer, então, que as variáveis globais são visíveis por todos os módulos, e as variáveis locais, são visíveis apenas ao módulo onde esta foi declarada. Podemos ter quantos módulos quisermos com uma variável local chamada x, por exemplo, e elas não apresentarão conflito entre si. Vamos analisar a figura 3.4 a seguir: int A, B, C; Modulo 1 int x, y, z;

Modulo 2 int x, w;

Figura 3.4: Escopo de variáveis locais e globais

As variáveis A, B e C são globais, portanto, podem ser utilizadas pelos módulos 1 e 2. No módulo 1, temos as variáveis x, y e z, que só podem ser utilizadas por este módulo. Dessa forma, o módulo 2 70

Programação I

não tem acesso a tais variáveis. Notem que, tanto o módulo 1 quanto o módulo 2, tem uma variável chamada x. Variáveis com o mesmo nome em módulos diferentes não causam conflito no programa. Também pode ocorrer de uma função ter uma variável local com o mesmo nome de uma variável global, quando isto acontece, a função dará preferência à variável local11. Um ponto interessante que devemos atentar ao declarar as variáveis do programa é que as variáveis locais só existem (e consequentemente, ocupam memória) enquanto o módulo estiver ativo e são destruídas quando a execução do módulo termina. Com isso, há uma melhor utilização da memória do computador.

3.5. Parâmetros Ao desenvolver um módulo, devemos ficar atentos para que o mesmo seja definido de forma bem genérica, com o objetivo de que este possa ser reutilizado mais vezes. Por exemplo, se criamos um módulo para calcular 2 elevado a 3, a sua aplicação será muito restrita. Porém, se generalizarmos o módulo de forma a torná-lo capaz de calcular o valor de qualquer base elevada a qualquer expoente, sua aplicação será mais abrangente. Portanto, dizemos que um módulo é generalizado quando ele for parametrizado. A utilização de parâmetros nos módulos funciona de forma muito similar às funções matemáticas, como por exemplo:

f (x , y) = x y » em que x e y são parâmetros. Essa função foi definida em termos de parâmetros x e y. Para calcularmos a função para algum valor particular de x e y devemos substituí-los pelos valores dos argumentos desejados.

f (3 , 2) = 3 2 = 9 Uma correspondência é estabelecida entre os parâmetros da definição e os argumentos utilizados. No exemplo, o parâmetro x foi substituído pelo 3 e o parâmetro y foi substituído pelo 2. É importante perceber que a ordem dos parâmetros é crucial, pois f(3,2) não é o mesmo que f(2,3). Uma função pode receber qualquer número de parâmetros. Mas 71

Atenção Lembrem que não podemos ter duas variáveis globais com o mesmo nome. 11

Programação I

também poderemos escrever uma função que não receba nenhum parâmetro. No caso de uma função sem parâmetros pode-se escrevêla da seguinte forma: deixando a lista de parâmetros vazia, mantendo entretanto os parênteses. O exemplo 3.1 apresenta uma função sem parâmetros. Exemplo 3.1: função sem parâmetro

void cabecalho()

{ system(“cls”);

printf(”Faculdade Legal\n”);

printf(“__________________________________\n”);

}

A função cabecalho, apresentada no exemplo 3.1 tem o objetivo de limpar a tela e escrever o nome da empresa no início da tela, além de passar uma linha logo abaixo. Como esta função não precisou receber nenhuma informação para a sua execução, ela não tem parâmetros, mas temos que colocar os parênteses em branco logo após o nome da função. Esta função também não tem retorno, por isso o tipo de retorno é void.

3.6. Contexto do Módulo (Ação ou Resultado) Um módulo possui o contexto de ação quando ele se preocupa com um processo em particular, como por exemplo, o módulo responsável por fazer o cadastramento dos dados dos alunos ou o módulo responsável por apresentar todos os dados dos alunos cadastrados. Neste tipo de módulo, teremos a execução de uma ação que é o cadastramento de alunos ou a listagem dos dados dos alunos. Um módulo possui o contexto de resultado quando a sua característica é a de calcular um resultado. Para exemplificar podemos pensar no módulo que é responsável por calcular a média das duas notas de um aluno. Ao ser executado, este módulo retornará como resultado, a média do aluno. A essência de um módulo com contexto de resultado é que seu conjunto de ações visa um objetivo único, retornar ao ponto de sua chamada, um valor. Para que um módulo retorne um valor, em C, será 72

Programação I

necessário que seja indicado qual é o valor a ser retornado, o que será efetuado com a utilização do comando return. Vamos analisar mais uma vez a função que calcula a média do aluno. Exemplo 3.2

float calc_media(float n1, float n2)

{ float m;

m = (n1 + n2)/2;

return m;

}

A função calc_media recebe como parâmetro as duas notas do aluno e retorna como resultado um float, que é a sua média. As duas notas passadas como parâmetros nas variáveis n1 e n2 são somadas e depois divididas por 2. No final da função, temos o comando return, que retorna o valor da variável local m, que tem armazenado a média do aluno. Não é necessário usar o comando return nas funções que não retornam nenhum valor (contexto de ação).

3.7. Ativando Funções A ativação de um módulo ocorre quando um determinado ponto do programa contém o identificador do módulo (nome do módulo). A ativação é conhecida como chamada de um módulo e serve para executá-lo. Uma chamada de função é feita escrevendo-se o nome da função seguido dos argumentos fornecidos, entre parênteses. Se não houver argumentos, ainda assim devem ser mantidos os parênteses, para que o compilador diferencie a chamada da função de uma variável. As funções só podem ser chamadas depois de terem sido declaradas. Quando queremos chamar uma função que retorna valor, devemos chamá-la através de um comando de atribuição, para que o valor que ela retorna de resultado, seja armazenado nesta variável. Este tipo de função também pode ser chamada/ativada em um comando de saída. Dessa forma, ao invés de armazenamos o resultado, o apresentamos na tela. Durante a chamada de um módulo, o fluxo de execução do 73

Programação I

programa é desviado para o módulo chamado, e logo após a sua conclusão, o fluxo de execução do programa retorna para o comando seguinte após a sua ativação. A figura 3.5 mostra a ativação de dois módulos no programa. Vale lembrar que após a ativação de um módulo, todas as suas variáveis locais são desalocadas da memória. main() { comando1;

void modulo1()

comando2;

{

comando1;

comando3;

comando2;

comando4;

comando3;

} modulo1();

comando5; void modulo2()

comando6;

{

comando1;

comando2;

comando3;

comando7;

comando4;

comando8;

}

modulo2();

} Figura 3.5: Chamada de Funções

Para ilustrar melhor o assunto explanado, o programa completo 3.1 apresenta um programa que calcula o quadrado de um número. Foram definidos dois módulos, além do programa principal (main). É no main que as funções deste exemplo serão chamadas.

Programação I

Programa Completo 3.1

void escreva_cabecalho()

{ system(“cls”);

printf(“Encontrar quadrado de um numero\n”);

printf(“_______________________________\n\n”);

}

6 7

int quadrado(int numero)

{ int q;

q = numero*numero;

return q;

}

12 13

main()

{ int n, r;

escreva_cabecalho();

printf(“\nInforme o numero: “);

scanf(“%d”, &n);

r = quadrado(n);

printf(“\n\nResultado\n\n”);

printf(“O quadrado de %d = %d\n\n”, n, r);

getche();

}

O programa começa a sua execução pelo programa principal (linha 13). Logo no início, encontra a chamada para a função escreva_ cabecalho (linha 15). A função escreva_cabecalho é usada para escrever o título do programa, esta função, não recebe parâmetros, nem retorna nenhum valor, ela apenas escreve um texto na tela. A chamada desta função foi feita na linha 15, logo após a declaração das variáveis do programa principal. Para chamar esta função, 75

Programação I

foi necessário apenas informar o seu nome e, como ela não tem parâmetros, os parênteses são colocados sem nada entre eles. Na sequência do programa, será lido o número que se deseja calcular o quadrado e logo em seguida é feita a chamada da função quadrado (linha 18). A função quadrado recebe um parâmetro inteiro (que é o número que se deseja calcular o quadrado) e retorna como resultado um valor inteiro. Como mencionado anteriormente, funções que retornam valor, devem ser chamadas através de um comando de atribuição. Neste caso, a variável r, receberá o retorno da função quadrado. Além disso, como esta função precisa saber de qual número será calculado o quadrado, na chamada da função, entre os parênteses, devemos colocar o valor ou a variável que será utilizada no cálculo, neste caso, será passado como parâmetro o valor da variável n. O programa finaliza apresentado o resultado, que é o quadrado do número (linhas 19 e 20). A figura 3.6 apresenta a tela de execução do programa completo 3.1

Figura 3.6: Tela de execução do programa completo 3.1

Nos demais volumes deste livro, estaremos desenvolvendo nossos programas de forma modularizada. Quando passarmos a desenvolver programas maiores, veremos com mais clareza as vantagens de usar a modularização.

Atividades e Orientações de Estudos Vamos treinar o desenvolvimento de módulos? Para cada questão abaixo, crie um programa principal, para que se possa testar/chamar 76

Programação I

o módulo desenvolvido. 1. Desenvolva uma função que recebe as três notas do aluno como parâmetro e retorne a sua média. 2. Desenvolva uma função que recebe dois números inteiros como parâmetro, e retorna o resto da divisão do primeiro parâmetro pelo segundo. 3. Desenvolva uma função que receba três números inteiros como parâmetros e retorne o menor valor. 4. Desenvolva uma função que recebe o ano de nascimento do usuário e retorna a sua idade. Faça o cálculo usando o ano atual. 5. Desenvolva uma função que recebe como parâmetro o mês atual e retorna quantos meses faltam para o final do ano. 6. Desenvolva uma função que recebe como parâmetros o dia do mês, o mês e o ano e retorna quantos dias faltam para o final do mês. Lembrem que os meses que têm 28, 29, 30 ou 31 dias.

Conheça Mais Vocês podem aumentar o entendimento deste assunto lendo o capítulo 7 do livro:

LAUREANO, Marcos. Programando em C Para Linux, Unix e Windows. Rio de Janeiro: Brasport, 2005.

Vamos Revisar? Vamos fazer uma revisão do assunto que foi visto neste capítulo, fazendo a leitura do resumo a seguir:

Programação I

» Modularização é um técnica de programação que tem como objetivo desenvolver o programa de maneira mais simples e legível. » Um módulo deve ser bem específico, ou seja, deve ser projetado para resolver uma única ação. » As variáveis declaradas dentro de um módulos são de uso exclusivo deste módulo e são chamadas de variáveis locais. » As variáveis globais podem ser acessadas por qualquer módulo do programa. » Um programa C começa a sua execução a partir do programa principal (main). » Se o módulo retornar algum valor, devemos utilizar o comando return. » Os módulos que recebem parâmetros tem mais chances de serem reutilizados. » Para ativar a execução de um módulo, devemos fazer a sua chamada. » Ao iniciar a execução de um módulo, o fluxo do programa é desviado para o módulo chamado. Ao terminar, o fluxo de execução do programa volta para o ponto onde o módulo foi chamado.

Programação I

Referências

ARAÚJO, Jairo. Dominando a Linguagem C. São Paulo: Ciência Moderna, 2004.

ASCENIO, Ana Fernanda Gomes e CAMPOS, Edilene Aparecida Veneruchi. Fundamentos de Programação de Computadores. São Paulo: Prentice Hall, 2002.

DEITEL, H, M e DEITEL, P. J. Como Programar em C. Rio de Janeiro: LTC, 1999.

LAUREANO, Marcos. Programando em C Para Linux, Unix e Windows. Rio de Janeiro: Brasport, 2005.

MIZRAHI, Victorine Viviane. Treinamento em Linguagem C – Curso Completo. São Paulo: Makron, 1999.

MONTGOMERY, Eduard. Programando em C: Simples e Prático. São Paulo: Alta Books, 2006.

OLIVEIRA, Ulisses. Programando em C – Volume I – Fundamentos. São Paulo: Ciência Moderna, 2004.

SCHILDT, Herbert. C Completo e Total. São Paulo: Makron, 1996.

Programação I

Considerações Finais Neste volume, demos continuidade ao nosso aprendizado na linguagem de programação C. Nos capítulos 1 e 2, conhecemos as estruturas de repetição, que tem a capacidade de mudar o fluxo de execução do programa, desviando de uma parte de comandos ou fazendo com que um grupo de comandos fosse executado várias vezes. No capítulo 3, foi abordada a modularização, que nos permite uma programação mais organizada, reaproveitamento de código e desenvolvimento do programa em etapas. Esperamos que vocês estejam, a cada dia, gostando mais da linguagem de programação C. Temos mais dois volumes, que nos darão a capacidade de desenvolver programas ainda mais interessantes. Continuem firmes nos estudos! Até o próximo módulo.

Programação I

Conhecendo a Autora Sou graduada em Ciência da computação pela Universidade Federal de Sergipe. Fiz mestrado e doutorado na Universidade Federal de Pernambuco, desenvolvendo pesquisas nas áreas de Sistemas Distribuídos e Geoprocessamento. Começei a ensinar em 2000, nos cursos de Ciência da Computação e Sistemas de Informação. Desde o início da minha carreira como professora, ministro disciplinas de Programação e tenho uma paixão pela linguagem C. Atualmente, encontrei uma nova paixão: Educação a Distância.