Fundamentos de Programação em C: Uma Abordagem Algorítmica

“ Não se mede o valor de um homem

6
pelas suas roupas ou pelos seus bens, o
verdadeiro valor de um homem é o seu
carácter, suas ideias e a nobreza de
seus ideais. ” SubProgramas
- Charles Chaplin -

Sumário:
6.1- Motivação
6.2- Conceitos
6.3-Estrutura de um Programa
6.4- Definição das Funções
6.5-Declaração de Funções
6.6- Valor de Retorno
6.7-Função Principal
6.8- Chamada da Função
6.9- Parâmetros
6.10- Chamada de uma Função por Outra
6.11- Procedimentos
6.12- Passagem de Parâmetros
6.13- Variáveis Locais e Globais
6.14- Exercícios Resolvidos
6.15- Exercícios Propostos
6.16-Trabalhos de Programação

174
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Este capítulo tem por objectivo ensinar a desenvolver subprogramas para serem
incorporados em programas de médio porte, tornando desse modo, o
desenvolvimento do software mais fácil e fléxivel. No seu término o leitor deverá
ser capaz de:

 Justificar as vantagens de desenvolver programas com subprogramas;

 Saber escolher as acções que devem ser escritas como subprogramas;
 Definir os vários tipos de subprogramas;
 Saber utilizar de forma correcta os vários tipos de subprogramas;
 Definir os métodos de comunicação entre subproblemas;
 Conhecer as vantagens e desvantagens dos métodos de comunicação;
 Conhecer as vantagens e desvantagens da visibilidade das variáveis;
 Dominar as técnicas de documentação de programas.

6.1 - Motivação
Um dos aspectos fundamentais da programação é a decomposição de um
programa em vários subprogramas. Essa decomposição tem por objectivo
diminuir a complexidade do problema, partindo-o em partes mais simples.

Cada subprograma tem por finalidade resolver um problema específico, que será
posteriormente integrado no programa atravêz de um subprograma principal.

Todos os programas desenvolvidos com essa estratégia são mais confiáveis e

flexiveis. Para além disso, possuem a propriedade de serem mais simples de
compreender, de desenvolver e, de testar.

Vamos mostrar atravéz de um exemplo como funciona esse princípio de

decomposição. Pretendemos calcular a combinação de m elementos p à p que
é descrita pela seguinte fórmula:

𝐦
m!
( )=
p!(m−p)!
𝐩

Pelo método de refinamento sucessivo, numa primeira abordagem temos os

seguintes passos:

Versão 1
1- Calcular m!;
2- Calcular p!;
3- Calcular (m-p)!;
4- Calcular a combinação;

Nos próximos passos, vamos detalhar as acções para calcular os factoriais de

m, p e m-p. Fácilmente se constacta que teremos três segmentos de código
muito semelhantes. A única diferença entre eles reside no valor final da variável
de controle.

175
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Seria muito interressante poder escrever um segmento de código para calcular

o factorial de um número qualquer e, poder utilizar esse trecho para calcular o
factorial desses três números, algo como:

int cont, n, fat = 1;

for (cont = 1; cont <= n; cont ++)
fat *= cont;

Se quizéssemos calcular m! substituiriamos o valor da variável n pelo valor da

variável m e rodavamos o programa. Da forma análoga, se quizéssemos calcular
(m-p)! substituiriamos o valor da variável n pelo valor da expressão m-p.

A nossa ideia seria escrever um único segmento de código e utiliza-lo sempre

que fosse necessário.

As linguagens de programação de alto nível possuem ferramentas que permitem

implementar essa ideia. Essas ferramentas e suas metodologias serão objecto
de estudo deste capítulo.

6.2 - Conceitos
Entendemos por subprogramas, um segmento de código com uma estrutura
muito semelhante à de um programa, que tem por objectivo resolver um
problema específico.

Os subprogramas são utilizados para separar um programa em partes

logicamente coerentes e, devem possuir as seguintes propriedades: Realizar
uma única tarefa; o seu código deve ser o mais independente e genérico
possível; possuir um mecanismo de comunicação com o exterior.

Quando um programa chama (activa ou invoca) um subprograma para realizar

uma tarefa específica, este não tem de preocupar-se como essa tarefa será
realizada. O programa apenas envia os dados para o subprograma e, espera
que este devolva uma solução correcta. Isto quer quizer que o funcionamento
correcto de um programa depende apenas do funcionamento correcto dos
subprogramas que o compoêm.

Todo o subprograma deve ser identificado por um nome. Esse nome deve
mostrar de forma clara a tarefa que esse subprograma realiza. Se não
conseguirmos escolher um nome conciso para um determinado subprograma é
porque ele realiza muitas tarefas diferentes. A melhor solução é dividir esse
subprograma em vários subprogramas mais simples.

Fazem parte das boas prácticas de programação desenvolver programas

como um conjunto de pequenos subprogramas independentes entre si.

Os subprogramas em C são chamados de funções e, o programa que junta

esses subprogramas é chamado de função principal. Geralmente, os
programas em C são escritos como uma combinação de funções desenvolvidas
pelo programador e, funções disponíveis na biblioteca padrão dessa linguagem.

176
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Qualquer sequência de instruções que aparece mais do que uma vez num
programa é um forte candidato para ser um subprograma.

Segundo Deitel (2011), as funções não devem ser maior do que uma página. O
ideal é que elas tenham no máximo o tamanho de meia página. Essa práctica de
programação facilita a reutilização do software.

6.3 - Estrutura de um Programa

Um programa com funções em C, possuir a seguinte estrutura.

Directivas de pré-processamento
Declaração das funções
Definição das funções
Função principal

onde cada componente, com a excepção das directizes de pré-processamento,

será objecto de estudo nas próximas secções.

6.4 - Definição de Funções

A definição das funções é uma area do programa onde o programador irá
desenvolver as suas funções. Toda a função possui a seguinte sintaxe:

<tipo> <nome>(<declaração dos argumentos>)

{
<Declaração dos Identificadores >;
<Comandos da função>;
<Valor de retorno>;
}

onde
tipo: Representa um tipo elementar de dados.

nome: Uma variável que satisfaz as regras de construção de variáveis da

linguagem C.

Declaração dos argumentos ou parâmetros: São os mecanismos de

comunicação com o exterior. Cada parâmetro é identificado pelo seu tipo,
seguido do nome e de uma vírgula. Em termos formais:

tipo1 parâmetro1, tipo2 parâmetro2 , … , tipon parâmetron;

Declaração dos Identificadores: São as variáveis e as constantes que

serão utilizadas no corpo da função.

Comandos da função: São as instruções que resolvem um problema

específico.

177
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Valor de retorno será objecto de estudo nas próximas linhas.

Por exemplo, a função que descrevemos em seguida, recebe como parâmetro,

um determinado valor em graus centígrados e devolve como valor de retorno, o
correspondente valor em graus Fahrenheit.

float fahrenheit(int c) /* cabeçalho da função */

{
float f;
f = 9.0/5.0*c + 32;
return f;
}

Para efeitos de notação utilizaremos as palavras recebe ou devolve quando

a comunicação for feita pelos parâmetro e retorna quando a comunicação for
feita pelo valor de retorno.

Os parâmetros que aparecem no cabeçalho da função são chamados de

parâmetros formais porque durante a execução do programa, eles serão
substituídos por variáveis, valores ou expressões.

6.5 - Declaração de Funções

A Declaração de Funções, que passaremos a denominar por Protótipo de
Funções é uma área do programa, onde o programador declara as funções que
irá utilizar no programa. Esta declaração consiste na definição do tipo da função
e nos argumentos que ela recebe. Por exemplo, no protótipo da função:

float fahrenheit(int c);

informamos ao compilador, que a função de nome fahrenheit é do tipo real e

recebe um valor do tipo inteiro.

A declaração de qualquer função no protótipo de funções é obrigatória e deve

terminar com um ponto-e-vírgula.

Fazem parte das boas práticas de programação, declarar no protótipo de

funções, todas as funções que serão utilizadas no programa.

Os nomes dos parâmetros são incluídos no protótipo de funções para fins de

documentação e legibilidade do programa. O compilador os ignora.

6.6 - Valor de Retorno

O Valor de Retorno é uma das formas de comunicação da função com o
exterior. Essa comunicação é feita através do comando return, que ao ser
acionado termina a execução da função e, transfere um único valor para o
exterior. Este comando possui a seguinte sintaxe:

178
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

return;
return expressão;
return (expressão);

Se depois da palavra reservada return, tivermos uma expressão, o valor dessa

expressão será retornado. Isso quer dizer que poderemos substituir a variável k
na função fahrenheit() vista na secção anterior, por uma expressão, ou seja:

float fahrenheit(int c)
{
return (9.0/5.0*c + 32);
}

Embora uma função retorna um e apenas um valor, ela pode conter no seu corpo
vários comandos return, mas apenas um será executado. Por exemplo, a
função:

int impar(int numero)

{
if ( numero%2 == 0 )
return 1;
else
return 0;
}

recebe um número inteiro e retorna o valor verdadeiro se o número for par e falso
no caso contrário.

Como uma função termina quando acionarmos um dos comandos return, então
podemos escrever uma função equivalente com o comando condicional simples.

int impar(int numero)

{
if ( numero%2 == 0 ) return 1;
return 0;
}

O tipo de dados de uma função deve ser igual ao tipo de dados retornado pelo
comando return.

O tipo de dados do valor retornado é que determina o tipo de dados de uma

função e não ao contrário.

6.7 - Função Principal

Em C, o programa principal é uma função especial denominada por função
principal que é indicada pela sentença int main(). Quando essa sentença for
accionada o programa entra em funcionamento.

179
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Constitui um padrão de programação em C retornar zero se o programa

funcionou correctamente ou um outro número no caso contrário.

Por causa desse padrão de programação, retornamos zeros em todos os

programas que desenvolvemos nos capítulos anteriores.

6.8 - Chamada de uma Função

Uma função pode ser chamada (invocada ou acionada) por uma função principal
ou por uma outra função.

Tradicionalmente, a chamada de uma função é feita por um comando de

atribuição de valor. Por exemplo:

float grausFahr;
.
.
grausFahr = fahrenheit(32); /* Chamada da função */
.

ou, por uma acção de impressão, por exemplo:

printf ("\n Valor em graus Fahrenheit = %.2f", fahrenheit(32));

Para garantir o funcionamento da troca de informações, na chamada de qualquer

função, existe um mecanismo de ligação entre os parâmetros da chamada e os
parâmetros da função. Esse mecanismo verifica se cada parâmetro da chamada
está relacionado a um e apenas um parâmetro da função. Para além disso,
também verifica se esses parâmetros são do mesmo tipo e estão na mesma
posição relativa. Por exemplo, dada a função:

int soma(int x, int y)

{
int z;
z = x + y;
return z;
}

que pode ser chamada pelo segmento de código

int main()
{
int r, s;
printf ( "\n Entre com um numero inteiro r: " ); scanf ( "%d%,&r );
printf ( "\n Entre com um numero real s:" ); scanf ( "%f",&s );
printf ( "\n valor da soma %f", soma(r,s) ); /* chamada da função */
return 0;
}

180
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

O mecanismo de comunicação verifica em primeiro lugar se o número de

argumentos na chamada soma(r,s) é igual ao número de parâmetros do
cabeçalho da função int soma(int x, float y). Se essa comparação for verdadeira,
verifica em seguida, se esses parâmetros são do mesmo tipo e estão na mesma
posição relativa, ou seja: se o tipo de r é igual ao tipo de x; se o tipo de s é igual
ao tipo de y; se r e x estão na primeira posição e se s e y estão na segunda
posição.

Os parâmetros da chamada da função são normalmente denominados por

parâmetros reias, porque substituem os parâmetros da função (parâmetros
formais) durante a execução do programa. Essa substituição pode ser feita por
variáveis, valores ou expressões. No exemplo anterior, a função soma, pode ser
chamada pelas seguintes instruções:

soma(4 , 3.14);
soma(a + 3 , (b + 7)/ 2);

Na primeira chamada os argumentos da função x e y foram substituídos pelos

valores 4 e 3.14, enquanto na segunda, os parâmetro da função foram
substituídos pelas expressões a+3 e (b+7) / 2.

6.9 - Parâmetros
Os parâmetros são os canais de comunicação entre a função e o exterior. Que
tipo de informações devem circular nesses canais?

Vimos que a entrada e a saída de dados da função principal era feita pelo
teclado, através da função scanf() e pelo monitor através da função printf().

As funções que nós desenvolvemos têm um funcionamento analogo. A entrada

de dados é feita pelos parâmetros enquanto a saída é feita pelo valor de retorno.

Isso quer dizer que normalmente, note que está escrito normalmente, não
devemos colocar a função scanf() e a função printf() nessas funções.

Para consolidar estes conceitos veremos dois exemplos muito simples. O

primeiro, consiste em desenvolver um programa com funções para ler um
conjunto indeterminado dos lados de um retângulo e calcular a área e o
perímetro.

Como o leitor já esta familiarizado a metodologia de refinamento sucessivo,

apresentaremos uma versão mais refinada.

1- declarar SENTINELA;
2- declarar variáveis;
3- ler lado1;
4- enquanto lado1 ≠ SENTINELA faça
5- inicio
6- se lado1 ≤ 0 então
7- imprimir("Erro: Lado do retângulo inválido");

181
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

8- senao
9- inicio
10- ler lado2;
11- se lado2 ≤ 0 então
12- imprimir(" Erro: Lado do retângulo inválido")
13- senão
14- inicio
15- calcular a área;
16- calcular o perímetro;
17- imprimir resultados;
18- fim
19- fim
20- ler lado1;
21- fim

Pelo enunciado, temos como entidade de entrada os lados do retângulo e como

entidade de saída o valor da área e do perímetro. Isso permite-nos declarar às
seguintes variáveis:

int lado1, lado2, perimetro, area;

Como não definimos o número de retângulos que iremos processar, vamos

associar o sentinela de fim de leitura ao lado1.

#define SENTINELA 0

No próximo passo vamos identificar as acções, que devem ser escritas como
subprogramas. Para cada subprograma, a metodologia prevê o estudo da
comunicação com o exterior e o algoritmo que implementa esse subprograma.

O subprograma, ler lado1, que denominamos por lerLado1(), não recebe

nenhum parâmetro e retorna o valor de um lado do retângulo. O algoritmo que
resolve essa função é descrito pelos seguintes passos:

1- declarar lado;
2- imprimir (" Entre um lado do retangulo : "); ler (lado);
3- retornar lado;

O subprograma, ler lado 2, que denominamos por lerLado2(), não recebe

nenhum parâmetro e retorna o valor do outro lado do retângulo. O algoritmo que
resolve essa função é descrito pelos seguintes passos:

1- declarar lado;
2- imprimir (" Entre com o outro lado do retangulo:"); ler (lado);
3- retornar lado;

Observe que esses subprogramas têm a mesma finalidade e que os seus

segmentos de código são practicamente iguais. Logo faz sentido desenvolver
um único subprograma e reutiliza-lo sempre que for necessário.

182
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

O subprograma lerLado() tem essa finalidade. Ele recebe como parâmetro o

número do lado do retângulo e retorna o comprimento desse lado. Algoritmo que
resolve essa função é descrito pelos seguintes passos:

1- declarar lado;
2- imprimir ( "Entre com o lado%d do retangulo:",numeroDoLado);
3- ler (lado);
4- retornar lado;

O subprograma, calcular área, que denominamos por calcularArea(), recebe

como parâmetro o comprimento dos lados do retângulo e retorna o valor da área.
O algoritmo que implementa essa função é descrito pelos seguintes passos:

1- declarar area;
2- calcular area = lado1 * lado2;
3- retornar area;

O subprograma, calcular perímetro, que denominamos por calcularPerimetro(),

recebe como parâmetro o comprimento dos lados do retângulo e retorna o valor
do perímetro. O algoritmo que implementa essa função é descrito pelos
seguintes passos:

1- declarar perimetro;
2- calcular perimetro = 2 x ( lado1 + lado2);
3- retornar perimetro;

Como todas as linhas do algoritmo estão claras e não possuem qualquer

ambiguidade, o processo de refinamento termina e podemos codificá-lo para um
programa na linguagem C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular a área e o perímetro de um retângulo.
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() scanf() */
#include <stdlib.h> /* incluir a funcao stdlib.h */
#define SENTINELA 0

/*--------------------------------------------------------------------------------------------------------
Protótipo de funções
--------------------------------------------------------------------------------------------------------*/
int lerLado (int numeroDoLado);
float calcularArea (float lado1, float lado2);
float calcularPerimetro (float lado1, float lados2);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler um lado do retângulo
Recebe: Número do lado
Retorna: Valor do lado digitado pelo utilizador
--------------------------------------------------------------------------------------------------------*/
int lerDado (int numeroDoLado)

183
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

{
int lado;
printf ("\n Entre com um lado%d do retangulo :",&numeroDoLado);
scanf ("%d",&lado);
return lado;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular a área do retângulo
Recebe: Lados do retângulo
Retorna: Área
--------------------------------------------------------------------------------------------------------*/
float calcularArea (float lado1, float lado2)
{
return (lado1 * lado2);
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o perímetro
Recebe: Lados do retângulo
Retorna: Perímetro
--------------------------------------------------------------------------------------------------------*/
float calcularPerimetro (float lado1, float lado2)
{
return 2 * (lado1 + lado2);
}

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main()
{
float x, y, perimetro, area;
x = lerLado (1);
while ( x != SENTINELA )
{
if ( x <= 0 )
printf (" \n Erro: Lado do retangulo invalido");
else {
y = lerLado (2);
if ( y <= 0 )
printf (" \n Erro: Lado do retangulo invalido");
else {
perimetro = calcularArea (x,y);
area = calcularPerimetro (x,y);
printf (" \n Perimetro= %d Area = %d ", perimetro, area);
}
}
x = lerLado (1);
}

184
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

system("PAUSE");
return 0;
}

O segundo, consiste em desenvolver um programa com funções para ler um

número inteiro positivo e calcular o valor da série harmónica. Por definição a
série harmónica é descrita por:

1 1 1 1
h=1+ + + +…+ para n≥ 1
2 3 4 𝑛

Em termos gerais, o algoritmo que resolve este problema pode ser descrito pelos
seguintes passos:

1- declarar variáveis;
2- ler um número inteiro n;
3- se n < 1 então
4- imprimir (“ Erro: número inválido”);
5- senão
6- inicio
7- calcular hormónico do número;
8- imprimir resultados;
9- fim

Pelo enunciado, temos como entidade de entrada um número inteiro positivo e

como entidade de saída o harmónico desse número. Isso permite-nos declarar
às seguintes variáveis:

int n;
float h;

No próximo passo vamos identificar as acções que devem ser escritas como
subprogramas e implementa-las de forma independente.

O subprograma, ler um número inteiro, que denominamos por lerNumero(), não

recebe nenhum parâmetro e retorna um número inteiro. Deixamos como
exercício o algoritmo que resolve essa função.

O subprograma, calcular harmônico de um número, que denominamos por

harmonico(), recebe como parâmetro um número inteiro positivo e retorna o
harmônico desse número. O algoritmo que resolve essa função é descrito pelos
seguintes passos:

1- declarar h, i;
2- inicializar h com zeros;
3- para i de n até 1 passo -1 faça
4- calcular h = h + 1/i;
2- retornar h;

185
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Como todas as linhas do algoritmo estão claras e não possuem qualquer

ambiguidade, o processo de refinamento termina e podemos codificá-lo para um
programa na linguagem C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular o valor da Série Harmónica
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() scanf() */
#include <stdlib.h> /* incluir a funcao stdlib.h */

/*--------------------------------------------------------------------------------------------------------
Protótipo de funções
--------------------------------------------------------------------------------------------------------*/
int lerNumero ();
float harmonico (int n);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o valor da série harmónica
Recebe: Número inteiro positivo
Retorna: Valor da série
--------------------------------------------------------------------------------------------------------*/
int harmonico (int n)
{
float h = 0.0;
int i;
for ( i = n; i >= 1; i--)
h += 1/i;
return h;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler um número inteiro
Recebe: Nada
Retorna: Número digitado pelo utilizador
--------------------------------------------------------------------------------------------------------*/
int lerNumero ()
{
int numero;
printf ( "\n Entre com um numero inteiro positivo:" ); scanf ( "%d",&numero );
return numero;
}

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main ()
{
float h;
int n;
n = lerNumero ();

186
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

if ( n < 1 )
printf (“\n Erro: Numero invalido”);
else
{
h = harmonico(n);
printf(“\n Valor harmonico de %d igual a %f ”,n, h);
}
system(“PAUSE”);
return 0;
}

É importante salientar que podemos optimizar a função principal. Essa

optimização consiste em escrever em uma única linha a leitura do número e a
sua validação. Para além disso podemos activar a função harmonico() no interior
do comando de impressão.

int main ()
{
int n;
if ( n = lerNumero () < 1
printf (“\n Erro: Numero invalido”);
else
printf (“\n Valor harmonico de %d igual a %f ”,n, harmonico(n) );
system(“PAUSE”);
return 0;
}

Mais uma vez enfatizamos que: " a documentação deve mostrar de forma sucinta
o objectivo de cada função e a comunicação que elas têm com o exterior. Não
se fica a perder tempo em descrever como essas funções resolvem o problema.
Se o leitor por ventura quiser conhecer esses pormenores, deverá ter a
competência para ler o código (feofiloff 09) ".

6.10- Chamada de uma Função por Outra

A maior parte das linguagens de programação permitem que uma função seja
invocada por uma outra. Mas para que essa comunicação seja possível é
necessário implementar em primeiro lugar, a função que é invocada.

Vamos consolidar esse conceito com o desenvolvimento de um programa com

funções para calcular todas as combinações de n p a p, ou seja:

Se n = 2 imprimir c(2,0), c(2,1), c(2,2)

Se n = 4 imprimir c(4,0), c(4,1), c(4,2) e c(4,4)
onde
C(n,p) = n! / ( p! * (n-p)!)

Mais uma vez, apresentaremos uma versão refinada do algoritmo.

187
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

1- declarar variáveis;
2- ler um número inteiro n;
2- se n < 0 então
3- imprimir (" Erro: O número deve ser positivo ");
4- senão
5 - inicio
6- para p de 0 até n passo 1 faça
7- inicio
8- calcular combinação de n p a p;
9 imprimir resultado;
10- fim
11- fim

Pelo enunciado, temos como entidade de entrada dois números inteiros positivos
e, como entidade de saída, os valores das respectivas combinações. Isso
permite-nos declarar às seguintes variáveis:

int n, p, comb;

No próximo passo vamos identificar as acções que devem ser resolvidas como
subprogramas e implementa-las de forma independente.

O subprograma, ler um número inteiro n, que denominamos por lerNumero(),

não recebe nenhum parâmetro e retorna um número inteiro. Como exercício,
desenvolva o algoritmo que implementa essa função.

O subprograma, calcular o factorial de um número, que denominamos por

factorial(), recebe como parâmetro um número inteiro positivo e retorna o
factorial desse número. O algoritmo que resolve essa função é descrito pelos
seguintes passos:

1- declarar fat, i;
2- inicializar fat com 1;
3- para i de 1 até n passo 1 faça
4- Multiplicar fat por i;
5- retornar fat;

Agora, vamos pegar nesse algoritmo para desenvolver um algoritmo que calcula
a combinação de n p a p.

O subprograma, calcular a combinação de n p a p , que denominamos por

combinacao(), recebe como parâmetro um número inteiro positivo n e um
número inteiro positivo p. Retorna o valor da combinação de n p a p. O algoritmo
que resolve essa função é descrito pelos seguintes passos:

1- declarar comb;
2- calcular comb = factorial(n) / (factorial(p) * factorial (n-p));
3- retornar comb;

188
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Como todas as linhas do algoritmo estão claras e não possuem qualquer

ambiguidade, o processo de refinamento termina e podemos codificá-lo para um
programa na linguagem C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular as combinações de n p a p
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() scanf() */
#include <stdlib.h> /* incluir a funcao stdlib.h */

/*--------------------------------------------------------------------------------------------------------
Protótipo de funções
--------------------------------------------------------------------------------------------------------*/
int lerNumero ();
int factorial (int n);
float combinação (int n, int p);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o factorial de um número inteiro
Recebe: Número inteiro
Retorna: Factorial desse número
--------------------------------------------------------------------------------------------------------*/
int factorial (int n)
{
int i, fat;
for ( fat = 1, i = 1; i <= n; i++)
fat += i;
return fat;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler um número inteiro
Recebe: Nada
Retorna: Valor do número inteiro
--------------------------------------------------------------------------------------------------------*/
int lerNumero ()
{
int numero;
printf ("\n Entre com um numero inteiro positivo:"); scanf ("%d",&numero);
return numero;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular a combinação de n p a p
Recebe: Valor de n e valor de p
Retorna: Combinação de n p a p
--------------------------------------------------------------------------------------------------------*/
float combinacao (int n, int p)
{
return ( factorial(n)/( factorial(r)*factorial(n-r) ) );

189
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main()
{
int n, p;
if (n = lerNumero() <= 0 )
printf (" \n Erro: Numero deve ser positivo ");
else {
for (p = 0; p <= n; p++)
printf (" \n %d ",combinacao(n,p));
}
system ("PAUSE");
return 0;
}

Fazem parte das boas práticas de programação, definir em primeiro lugar as

funções que são chamadas por outras funções.

6.11- Procedimentos
Entendemos por procedimentos funções que não retornam nenhum valor via
comando return. Na linguagem C os procedimentos são conhecidos como
funções do tipo void e, possuem a seguinte sintaxe:

void nome(declaração dos argumentos)

{
Declaração dos identificadores;
Comandos da função;
}

Nas funções do tipo void o comando return não é obrigatório. Uma função sem
o comando return termina quando for encontrado o delimitador de fim de blocos.

Fazem parte das boas prácticas de programação, utilizar procedimentos,

sempre que tivermos de implementar subprogramas que não devolvem
informações.

Para consolidar os conhecimentos, vamos desenvolver um programa com

funções para controlar o número de minutos que um funcionário esteve na
empresa.

Apresentamos mais uma vez a versão refinada do problema.

1- declarar SENTINELA;
2- declarar variáveis;
3- ler passe do trabalhador;

190
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

4- enquanto passe ≠ SENTINELA faça

5- inicio
6- se passe ≤ 0 então
7- imprimir ("número do passe inválido");
8- senão
9- inicio
10- ler hora e minuto da entrada;
11- converter essas horas para minutos;
12- ler hora e minuto da saída;
13- converter essas horas para minutos;
14- calcular a diferença de tempo;
15- imprimir resultados;
16- fim
17- ler passe do trabalhador;
18- fim

Pelo enunciado, temos como entidade de entrada o número do passe do

trabalhador, a hora e o minuto de entrada e de saída. Como entidade de saída
temos o número do passe do trabalhador e o tempo que este esteve no serviço.
Isso permite-nos declarar às seguintes variáveis:

int passe, minutoEntrada, minutoSaida, tempoNoServico, hora, minutos;

Como não definimos o número de trabalhadores que iremos processar, vamos

associar um sentinela de fim de leitura ao número do passe do trabalhador.

#define SENTINELA 0

No próximo passo vamos implementar os subprogramas de forma independente.

O subprograma, ler o passe do trabalhador, que denominamos por lerPasse(),

não recebe nenhum parâmetro e retorna o valor de um número inteiro positivo.
Como exercício desenvolva o algoritmo que implementa essa função.

O subprograma, converter horas para minutos, que denominamos por

converteTempo(), recebe como parâmetro as horas e os minutos. Retorna o
correspondente tempo em minutos. O algoritmo que resolve essa função é
descrito pelos seguintes passos:

1- declarar tempoEmMinutos;
2- calcular tempoEmMinutos = horas* 60 + minutos;
3- retornar tempoEmMinutos;

O subprograma, calcular à diferença de preço, que denominamos por

diferencaTempo(), recebe como parâmetro o tempo de entrada e o tempo de
saída em minutos. Retorna a diferença de tempo. O algoritmo que resolve essa
função é descrito pelos seguintes passos:

1- declarar diferencaTempo;
2- calcular diferencaTempo = tempoSaida - tempoEntrada;

191
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

3- retornar diferencaTempo;

O subprograma, imprimir resultados, que denominamos por imprimir(), recebe

como parâmetro o número do passe e a diferença de tempo. Não devolve
nenhuma informação. O algoritmo que resolve esse procedimento é descrito
pelos seguintes passos:

1- imprimir (passe);
2- imprimir (diferencaTempo);

Como todas as linhas do algoritmo estão claras e não possuem qualquer

ambiguidade, o processo de refinamento termina e podemos codificá-lo para um
programa na linguagem C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Calcular o número de horas de trabalho por dia de cada empregado.
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir a função printf() scanf() */
#include <stdlib.h> /* incluir a funcao stdlib.h */

/*--------------------------------------------------------------------------------------------------------
Protótipo de funções
--------------------------------------------------------------------------------------------------------*/
int lerNumeroPasse ();
int converteTempo (int h, int m);
int diferencaTempo (int entrada, int saida);
void imprimir (int passe, int diferencatempo);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler um número do passe do funcionário
Recebe: Nada
Retorna: Número do passe
--------------------------------------------------------------------------------------------------------*/
int lerNumeroPasse ()
{
int numero;
printf("\n Entre com um numero inteiro positivo:"); scanf("%d",&numero);
return numero;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Converter as horas e os minutos para minutos
Recebe: Horas e minutos
Retorna: Minutos
--------------------------------------------------------------------------------------------------------*/
int converteTempo (int h, int m)
{
return ( h* 60 + m);
}

192
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular os minutos de trabalho
Parâmetros: Minutos de entrada e minutos e saída
Valor de retorno: Tempo em minutos
--------------------------------------------------------------------------------------------------------*/
int diferencaTempo (int entrada, int saida)
{
return saida - entrada;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Imprimir a assiduidade do empregado
Parâmetros: Passe do trabalhador e horas no serviço
--------------------------------------------------------------------------------------------------------*/
void imprimir (int passe, int horasNoServico)
{
printf("\n Trabalhador com o passe %d :", passe);
printf("\n esteve na Empresa %d:",horasNoServico);
}

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main()
{
int passe, minutoEntrada, minutoSaida, tempoNoServico, hora, minutos;
while (passe = lerNumeroPasse () != SENTINELA )
{
if (passe <= 0)
printf("Erro: Numero do passe invalido");
else {
printf("\n Digite hora de entrada (hora:minutos) : " );
scanf(" %d : %d ",&hora,&minutos);
minutoEntrada = converteTempo (hora,minutos);
printf("\n Digite hora de saida (hora:minutos) : " );
scanf(" %d : %d ",&hora,&minutos);
minutoSaida = converteTempo (hora,minutos);
tempoNoServico = diferencaTempo (minutoEntrada,minutoSaida);
imprimir ( passe, tempoNoServico);
}
}
system("PAUSE");
return 0;
}

Podemos optimizar a função principal, invocando a função diferencaTempo() no

parâmetro tempoNoServico do procedimento imprimir().

193
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

int main ()
{
int passe, minutoEntrada, minutoSaida, hora, minutos;
while (passe = lerNumeroPasse() != SENTINELA )
{
if (passe <= 0)
printf("Erro: Numero do passe invalido");
else {
printf("\n Digite hora de entrada (hora:minutos) : " );
scanf(" %d : %d ",&hora,&minutos);
minutoEntrada = converteTempo(hora,minutos);
printf("\n Digite hora de saida (hora:minutos) : " );
scanf(" %d : %d ",&hora,&minutos);
minutoSaida = converteTempo (hora,minutos);
imprimir ( passe, diferencaTempo(minutoEntrada,minutoSaida));
}

}
system("PAUSE");
return 0;
}

A existência da função printf() no subprograma impressão, não viola as boas

prácticas de programação, porque este subprograma foi concebido com o
objectivo específico de mostrar na tela a assiduidade de um empregado.

6.12- Passagem de Parâmetros

Vimos que a comunicação entre as funções e o mundo exterior é feita pelos
argumentos para entrada de dados e pelo comando return para saída de uma e
apenas uma informação.

Este tipo de comunicação, entrada de dados via parâmetros é a mais comum

nas linguagens de programação modernas e denomina-se por passagem de
parâmetros por valor.

Na passagem por valor uma cópia do parâmetro da chamada é transferida para

a função. Isso quer dizer que os parâmetros da chamada (reais) e os parâmetros
da função (formais) estão armazenados em posições de memória diferentes.
Logo, qualquer alteração feita aos parâmetros da função, não alteram o valor da
variável que será transferida para o exterior.

Fazem parte das boas prácticas de programação, utilizar sempre que for possível
a passagem por valor.

Mas em programação é muito comum ter a necessidade de devolver mais do

que um valor. Um exemplo clássico consiste em trocar o conteúdo de duas
variáveis. O procedimento que realiza essa tarefa é descrito por:

194
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

void troca(int a, int b)

{
int tmp;
tmp = a;
a = b;
b = tmp;
}

e a função principal que activa esse procedimento pode ser descrita por:

int main()
{
int x,y;
printf(" \n Entre com dois numeros inteiros:");
scanf(" %d %d ", &x,&y);
prinf(" \n Antes da troca x = %d e y= %d ",x,y);
troca (x,y); /* Chamada da função */
printf(" \n Depois da troca x= %d e y= %d ",x,y);
return 0;
}

Suponhamos sem perda da generalidade que x= 5 e y= 9. Se executarmos esse

programa, teremos os seguintes resultados:

Antes da troca x= 5 e y = 9
Depois da troca x= 5 e y= 9

O que está errado?

O erro não está no código do programa, mas no método de passagem de

parâmetros. A função terá de devolver os parâmetros com os conteúdos
trocados.

Para resolver esse problema, as linguagens de programação de alto nível

possuem a passagem de parâmetros por referência.

Na passagem por referência, a comunicação entre os parâmetros da função e

os parâmetros da chamada são feitas por endereços. Isso quer dizer que esses
parâmetros compartilham as mesmas posições de memória, e como
consequência, qualquer alteração aos parâmetros no interior da função, afectam
as correspondentes variáveis no exterior.

Mas, para efectuar essa passagem, os parâmetros da função e os parâmetros

da chamada devem ser declarados como variáveis do tipo ponteiro.

Um ponteiro é tipo especial de dados que permite manipular endereços e possui

a seguinte sintaxe:

<tipo> (oper) nome;

onde

195
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

<tipo> representa o tipo de dados, int, float, double ou char

oper representa o operador do tipo ponteiro que pode ser * ou &
nome denota uma variável

O operador unário & denominado por operador endereço é um ponteiro que

devolve o endereço de memória do seu operando. Por exemplo:

m = &cont;

armazena no ponteiro m o endereço da variável cont. Esse endereço é uma

posição interna de memória no computador.

Vamos clarificar esse conceito com um exemplo. Suponhamos sem perda da

generalidade que a variável cont está armazenada no endereço de memória 250
e possui o valor 150. Com essa operação o ponteiro m contêm o valor 250.

O operador unário * denominado por operador indirecto é um ponteiro que

devolve o conteúdo do endereço de memória do seu operando. Por exemplo, se
m contêm o endereço da variável cont, a atribuição

q = *m;

armazena o conteúdo de cont na variável q. Logo q terá o valor 150, porque 150
é o valor de está armazenado nessa posição de memória.

Então, a resolução do nosso problema passa pela declaração do conteúdo das

localizações de memória nos parâmetros da função. Esse conteúdo é declarado
com o operador indirecto, ou seja:

void troca ( int *a, int *b)

{
int tmp;
tmp = *a;
*a = *b;
*b = temp;
}

e, na chamada da função devemos passar os endereços desses parãmetros.

Esses endereços são declarados pelo operador de endereço, ou seja:

int main()
{
int x,y;
printf(" \n Entre com dois numeros inteiros: ");
scanf(" %d %d ", &x,&y);
printf(" \n Antes da troca x = %d e y= %d ",x,y);
troca(&x,&y); /* chamada da Função */
printf(" \n Depois da troca x= %d e y= %d ",x,y);
return 0;
}

196
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Para efectuar a passagem por referencia, devemos seguir a seguinte regra: na

chamada da função os pârametros devem possuir como prefixo o operador de
endereço (&) enquanto na declaração da função os parâmetros devem possuem
como prefixo o operador de acesso indirecto (*).

Vejamos mais um exemplo clássico. Desenvolver uma função para calcular as

raízes reias da equação do segundo grau ax2+bx+c = 0. Esta função, recebe
como parâmetro os coeficientes da equação e devolve como parâmetro as
respectivas raízes. Mas, como existem vários casos particulares, vamos
devolver pelo valor de retorno uma informação sobre isso. Desse modo, os
possíveis valores são:

1 Quando há duas raízes diferentes;

0 Quando há duas raízes iguais, ou seja delta é zero;
-1 Quando não há raízes reais;
-2 Quando a equação do primeiro grau;
-3 Quando não é uma equação.

Como acreditamos que o leitor não deverá ter qualquer dificuldade em

desenvolver um algoritmo para resolver este problema, mostraremos a seguir, a
correspondente função na linguagem C.

#include <stdio.h>
#include <math.h>
int equacao2Grau (double a, double b, double c, double *x1, double *x2)
{
double delta;
if (a == 0.0 && b == 0.0) /* Não é uma equação*/
return -3;
if (a == 0.0) /*É uma equação do 1. Grau */
{ *x1 = -c / b; return -2; }
delta = b*b - 4*a*c;
if (delta < 0) /* Se delta < 0 , raízes não são reais */
return -1;
if (delta == 0) /* Se delta = 0, raízes reias iguais */
{ *x1 = *x2 = -b / (2*a); return 0; }
*x1 = (-b + sqrt(delta))/(2*a); /* se delta > 0, raízes reais diferentes */
*x2 = (-b - sqrt(delta))/(2*a);
return 1;
}

Fazem parte das boas prácticas de programação, passar por valor, todo o
parâmetro que não vai ser modificado durante a execução de um
subprograma.

6.13 - Variáveis Locais e Globais

Os identificadores declarados no interior de uma função são chamadas de
locais. Esses identificadores só podem ser utilizados quando a função for
chamada. Ao acionar uma função, as áreas de memória associadas a esses

197
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

identificadores são alocadas no momento da chamada e libertadas no término

da execução.

Em contrapartida, os identificadores declarados antes do protótipo de funções

são denominados por globais e podem ser utilizadas em todo o programa.

Como exemplo de utilização de variáveis locais, vamos considerar uma função

que recebe como parâmetro dois números inteiros x e y e devolve via valor de
retorno a multiplicação desses números utilizando apenas operações de adição.

int multiplicacao (int x, int y)

{
int i, z; /* Variáveis locais */
z = 0;
i = 1;
while (i <= y)
{
z+= x;
i++;
}
}

Não fazem parte das boas prácticas de programação utilizar variáveis globais
no interior de um subprograma.

Toda a comunicação entre um programa e um subprograma deve ser feita pela

passagem de parâmetros, os restantes elementos necessários ao
funcionamento do subprograma devem ser declarados localmente.

Entendemos por escopo de uma variável o segmento de código onde essa

variável pode ser utilizada. Vimos que as variáveis globais podem ser utilizadas
em todo o programa e as locais só podem ser utilizadas nas funções onde foram
declaradas.

As linguagens de programação modernas permitem que se declara variáveis

locais com o mesmo nome das variáveis já utilizadas no programa. Por exemplo,
suponhamos sem perda da generalidade que declaramos uma variável global
com o nome media e que declaramos na função calcularMedia() uma variável
local com o mesmo nome. Quando a função calcularMedia() for acionada,
qualquer referencia a variável media está associada a variável local. No interior
dessa função a variável global com o mesmo nome torna-se inacessível.

A utilização de variáveis globais é recomendada para o processamento de

entidades com uma grande quantidade de itens. Por exemplo, o cadastro de um
aluno numa universidade é uma entidade possui os seguintes itens: número,
nome, sobrenome, data de nascimento, curso, faculdade, sexo e prazo de
validade do cartão. Imagine como seria desconfortável e pouco legível, escrever
uma função para ler os dados de um aluno. Essa função teria obrigatoriamente
oito argumentos.

198
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

6.14- Exercícios Resolvidos

Problema 6.14.1: Uma Universidade pretende informatizar o lançamento de

notas. Durante o semestre, os estudantes são submetidos a três projectos de
laboratório. A média para aprovação é determinada pela fórmula:

20 projecto1 + 30 projecto2 + 50 projecto3

100

Com base nessas médias, o estudante tem a seguinte classificação:

Superior a 15 valores Dispensado ao exame

Entre 8 a 15 valores Vai a Exame final
Inferior a 8 valores Reprovado

O programa deve ler o número do estudante, as notas dos três projectos e

imprimir a pauta com as seguintes informações: número, média final e
classificação.

Resolução: Uma versão refinada para este problema pode ser descrita pelos
seguintes passos:

1- declarar SENTINELA;
2- declarar variáveis;
3- ler número do aluno;
4- enquanto (número ≠ SENTINELA) faça
5- inicio
6- se número ≤ 0 então
7- imprimir("Número do estudante invalido");
8- senao
9- inicio
10- carregar as notas dos projectos;
11- calcular a média dos projectos;
12- classificar nota do aluno;
13- imprimir uma linha da pauta;
14- fim
15- ler número do aluno;
16- fim

Pelo enunciado, temos como entidade de entrada o número do aluno e as notas

dos três projectos e como entidade de saída uma pauta com a respectiva
classificação. Isso permite-nos declarar às seguintes variáveis:

int numero, projecto1, projecto2, projecto3;

char classificacao;

Como não definimos o número de alunos da turma, o término do processo de

leitura, será efectuado por um sentinela.

#define SENTINELA 0
199
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

No próximo passo vamos identificar as acções que devem ser resolvidas como
subprogramas e implementa-las de forma independente.

O subprograma, ler o número do aluno, que denominamos por

lerNumeroAluno(), não recebe nenhum parâmetro e retorna o número do passe
do aluno. Como exercício desenvolva o algoritmo que implementa essa função.

O subprograma, ler a nota de um projecto, que denominamos por

lerNotaProjecto(), recebe como parâmetro o número do projecto e retorna o valor
da nota desse projecto. O algoritmo que resolve esta função é descrito pelos
seguintes passos:

1- enquanto (verdadeiro) faça

2- inicio
3- imprimir("Entre com a nota do projecto nº x :"); ler(projecto);
4- se projecto ≥ 0 e projecto ≤ 20 então abandonar;
5- senão imprimir("Erro: Nota Inválida");
6- fim
7- retorna projecto

O subprograma, carregar as notas dos projectos, que denominamos por

carregarNotas(), não recebe nenhum parâmetro e devolve como parâmetro as
notas dos três projectos. O algoritmo que resolve este procedimento utiliza o
subprograma anterior e é constituído pelos seguintes passos:

1- projecto(1) = lerNota(1);
2- projecto(2) = lerNota(2);
3- projecto(3) = lerNota(3);

O subprograma, calcular a média dos projectos, que denominamos por,

calcularMedia(), recebe como parâmetro o valor dos três projectos e retorna a
sua média aritmética. O algoritmo que resolve esta função é descrito pelos
seguintes passos:

1- declarar media;
2- media = 0.2 * projecto1 + 0.3 * projecto2 + 0.5 * projecto3;
3- devolver media;

O subprograma, classificar a nota do aluno, que denominamos por

classificarEstudante(), recebe como parâmetro a média do estudante e retorna
a sua classificação escolar. O algoritmo que resolve esta função é descrito pelos
seguintes passos:

1- se media > 15 então devolver 'D';

2- se media > 8 então devolver 'E';
3- devolver 'R';

200
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

O subprograma, imprimir uma linha da pauta, que denominamos por imprimir(),

recebe como parâmetro o número do passe, a média do estudante e a sua
classificação escolar. Não devolve nenhuma informação. O algoritmo que
resolve este procedimento é descrito pelos seguintes passos:

1- imprimir (passe, media, classificacao);

Como todas as linhas do nosso algoritmo são claras e precisas estamos em

condições de converter o nosso algoritmo para um programa em C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Imprimir uma pauta com as notas dos estudantes de uma turma.
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir as funções scanf() e printf() */
#include <stdlib.h> /* incluir a função system() */
#define SENTINELA 0

/*--------------------------------------------------------------------------------------------------------
Protótipo de funções
--------------------------------------------------------------------------------------------------------*/
float calcularMedia (int projecto1, int projecto2, int projecto3);
int lerNumeroEstudante ();
int lerNotaProjecto (int numProjecto);
void carregarNotas (int *projecto1, int *projecto2, int *projecto3);
char classificarEstudante (float mediaprojectos);
void imprimir (int passe, float media, char classe);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular a média
Recebe: Notas dos três projectos
Retorna: Média
--------------------------------------------------------------------------------------------------------*/
float calcularMedia (int projecto1, int projecto2, int projecto3)
{
return ( 0.2 * projecto1 + 0.3 * projecto2 + 0.5 * projecto3 );
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler o número do estudante
Recebe: Nada
Retorna: Número do passe do estudante
--------------------------------------------------------------------------------------------------------*/
int lerNumeroEstudante ()
{
int passe;
printf("\n Entre com o numero do estudante :"); scanf(" %d",&passe);
return passe;
}

201
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler a nota de um projecto
Recebe: Número do Projecto
Retorna: A nota desse projecto
--------------------------------------------------------------------------------------------------------*/
int lerNotaProjecto (int numProjecto)
{
float nota;
while (1)
{
printf("\Entre com a nota do projecto nº %d :",numProjecto));
scanf("%d",&nota));
if (nota >= 0 && nota <= 20)
break;
else
printf("\n Erro: Nota invalida");

}
return nota;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Selecionar a Classificação do estudante
Recebe: Média dos projectos
Retorna: Classificação do aluno
--------------------------------------------------------------------------------------------------------*/
char classificarEstudante(float media)
{
if (media > 15 ) return 'D';
if (media > 8 ) return 'E';
return 'R';
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Imprimir uma linha da pauta
Recebe: Passe, media, classificacao
Devolve: Nada
--------------------------------------------------------------------------------------------------------*/
void imprimir(int passe, float media, char classificacao)
{
printf("\n Estudante com o passe %d :", passe);
printf(" \n Media dos projectos %.2f ",media);
printf(" \n Classicacao de %c ",classificacao);
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Carregar as notas dos projectos
Recebe: Nada
Devolve: Notas dos três projectos
--------------------------------------------------------------------------------------------------------*/

202
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

void carregarNotas(int *projecto1, int *projecto2, int *projecto3)

{
*projecto1 = lerNotaProjecto(1);
*projecto2 = lerNotaProjecto(2);
*projecto3 = lerNotaProjecto(3);
}

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main ()
{
int numero, projecto1, projecto2, projecto3;
float mediaproject;
char classificacao;
while ( numero = lerNumeroEstudante () != SENTINELA )
{
if ( numero < 0 )
printf("\n Erro: Numero do estudante invalido");
else {
carregarNotasProject (&projecto1,&projecto2,&projecto3);
mediaproject = calcularMedia (projecto1,projecto2,projecto3);
classificacao = classificarEstudante (mediaproj);
imprimir (numero,mediaproject,classificar);
}
}
system("PAUSE");
return 0;
}

Problema 6.14.2: A companhia de pulverização Avion Ltda, utiliza aeronaves

para pulverizar fazendas. Os custos de pulverização dependem do tipo de praga
e da área a pulverizar:

Tipo1: pulverização contra ervas daninhas, Kz 8.000,00 por km quadrado

Tipo2: Pulverização contra gafanhotos, KZ 10.000,00 por km quadrado
Tipo3: Pulverização contra broca , KZ 15.000,00 por km quadrado
Tipo4: Pulverização contra tudo, Kz 18.000,00 por km quadrado.

Se a área pulverizada for maior do que 10 km2, o fazendeiro recebe um desconto

de 5%. Em contrapartida, qualquer fazendeiro cujo custo ultrapasse os Kz
100.000,00 recebe um desconto de 10% sobre o valor que ultrapassar Kz
100.000,00. Se ambos os descontos se aplicam, o relacionado com a área é
calculado em primeiro lugar. Preparar um programa para ler um conjunto de
dados com os seguintes campos: código do fazendeiro, tipo de pulverização,
área pulverizada. Imprimir o código do fazendeiro seguido do valor a pagar pelo
serviço.

203
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Resolução: Como o leitor já está familiarizado com a metodologia de

refinamento sucessivo, apresentamos uma versão mais refinada:

1- declarar as variáveis
2- ler identificação do fazendeiro;
3- enquanto identificação ≠ SENTINELA faça
4- inicio
5- se identificação ≤ 0 então
6- imprimir ("Número de identificação invalido");
7- senão
8- inicio
9- ler Tipo de pulverização;
10- ler área pulverizada;
11- calcular custo do serviço;
12- se área > 10 km2 então
13- inicio
14- calcular desconto sobre o área;
15- atualizar custo;
16- fim
17- se custo > 100,000.00 kz então
18- inicio
19- calcular desconto sobre o custo;
20- atualizar custo;
21- fim
22- fim
23- imprimir a factura;
24- ler identificação do fazendeiro;
25- fim

Pelo enunciado, temos como entidade de entrada os dados do fazendeiro e

como entidade de saída uma factura de cobrança do serviço. Isso permite-nos
declarar às seguintes variáveis:

int identificacao;
float area, custo;
int tipo;

Como o número de fazendeiros a processar não foi definido, o término do

processo de leitura, será efectuado por um sentinela de fim de leitura.

#define SENTINELA 0

No próximo passo, vamos descrever as acções que devem ser formalizadas

como subprogramas de forma independente.

O subprograma, ler identificação do fazendeiro, que denominamos por,

lerDadosFazendeiro() não recebe nenhum argumento e retorna o número da
identificação do fazendeiro. O algoritmo que resolve essa função fica como
exercício.

204
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

O subprograma, ler tipo de pulverização, que denopminamos por

lerTipoPulverizacao(), não recebe nenhum argumento e retorna o tipo de
pulverização. O algoritmo que resolve essa função fica como exercício.

O subprograma, ler área pulverizada, que denominamos por

lerAreaPulverizada(), não recebe nenhum parâmetro e retorna a área
pulverizada. O algoritmo que resolve essa função fica como exercício.

O subprograma, calcular desconto sobre o custo, que denominamos por

descontoCusto() recebe como parâmetro o custo do serviço e retorna o valor do
desconto sobre o valor excedente a 100.000,00 Kz. O algoritmo que resolve essa
função é descrito pelos seguintes passos:

1- declarar excedente, desconto;

2- calcular excedente = CustoServico - 100000.00;
3- calcular desconto = excedente * 10 %;
4- retornar desconto;

O subprograma, calcular o desconto sobre a área, que denominamos por

descontoArea() recebe como argumento o custo de pulverização e retorna o
valor do desconto sobre a área pulverizada. O algoritmo que resolve essa função
é descrito pelos seguintes passos:

1- declarar desconto;
2- calcular desconto = custoPulverizacao * 5%;
3- retornar desconto;

O subprograma, actualizar o custo, que denominamos por actualizarCusto(),

recebe como argumento o custo da pulverização e o valor do desconto sobre a
área pulverizada. Retorna o custo da pulverização actualizado. O algoritmo que
resolve essa função é descrito pelos seguintes passos:

1- declarar custoDaPulverizacao;
2- calcular custoDaPulverizacao = custoDaPulverizacao - desconto;
3- retornar custoDaPulverizacao;

O subprograma, calcular o custo do serviço, que denominamos por

custoServico(), recebe como parâmetro o tipo de pulverização e a área
pulverizada. Retorna o valor do custo do serviço. O algoritmo que resolve essa
função é descrito pelos seguintes passos:

1- declarar custo;
2- se tipoPulverizacao = ervas daninhas então
3- custo = 8000 x área;
4- senão se tipoPulverizacao = gafanhotos então
5- custo = 10000 x área;
6- senão se tipoPulverizacao = broca então
7- custo = 150000 x área;
8- senão
9- custo = 180000 x área;

205
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

10- retornar o custo;

O subprograma, imprimir a factura, que denominamos por imprimir(), recebe

como parâmetro a identificação do fazendeiro e o custo do serviço. Não devolve
para o exterior qualquer informação. O algoritmo que resolve esse procedimento
é descrito pelos seguintes passos:

1- imprimir (identificacao, custoServico);

Como todas as linhas do nosso algoritmo estão claras e não possuem qualquer
ambiguidade, estamos em condições de converter o algoritmo para um programa
em C.

/*--------------------------------------------------------------------------------------------------------
Objectivo: Imprimir uma factura com os custos de serviço de pulverização
--------------------------------------------------------------------------------------------------------*/
#include <stdio.h> /* incluir as funções scanf() e printf() */
#include <stdlib.h> /* incluir a função system() */
#define SENTINELA 0
#define ERVADANINHA 1
#define GAFANHOTOS 2
#define BROCAS 3

/*--------------------------------------------------------------------------------------------------------
Protótipos de funções
-------------------------------------------------------------------------------------------------------*/
int lerDadosFazendeiro ();
int lerTipoPulverizacao ();
float lerareaPulverizada ();
void imprimir (float custo, int identificacao);
float custoServico (int tipoPraga, float areaPulverizada);
float descontoArea (float custoServico);
float descontroPreco (float custoServico);
float actualizarCusto (float desconto, float custoServico);

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler dados do Fazendeiro
Recebe: Nada
Retorna: Número da identificação do fazendeiro;
--------------------------------------------------------------------------------------------------------*/
int lerDadosFazendeiro ()
{
int identificacao;
printf(" \n Identificacao do fazendeiro : "); scanf("%d",& identificacao);
return identificacao;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler o tipo de pulverização

206
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Recebe: Nada
Retorna:Tipo pulverização
--------------------------------------------------------------------------------------------------------*/
int lerTipoPulverizacao ()
{
/* Fica como exercício */
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler a área pulverizada
Recebe: Nada
Retorna: Área pulverizada
--------------------------------------------------------------------------------------------------------*/
int lerAreaPulverizada ()
{
/* Fica como exercício */
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o desconto com base na área pulverizada
Recebe: Custo da pulverização
Retorna: Valor do desconto
--------------------------------------------------------------------------------------------------------*/
float descontoArea (float custoServico)
{
return custoServico * 0.05;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o desconto com base no custo do serviço
Recebe: Custo da pulverização
Retorna: Valor do desconto
--------------------------------------------------------------------------------------------------------*/
float descontoPreco (float custoServico)
{
return (custoServico - 100000.0) * 0.10;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Imprimir fatura
Recebe: Custo do serviço, identificação
Devolve: Nada
--------------------------------------------------------------------------------------------------------*/
void imprimir (float custoServico, int identificacao)
{
printf(" \n Codigo do fazendeiro %d ", identificacao);
printf(" Valor a pagar %.2f ",custoServico);
}

207
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*-------------------------------------------------------------------------------------------------------
Objectivo: Actualizar o Custo
Recebe: Custo da pulverização
Retorna Custo atualizado
--------------------------------------------------------------------------------------------------------*/
float actualizarCusto (float custoServico, float desconto)
{
return custoServico -= desconto;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o custo do serviço
Recebe: Tipo de pulverização, área Infectada
Retorna: Valor do custo do serviço
--------------------------------------------------------------------------------------------------------*/
float custoServico (int tipoPraga,float areainfectada)
{
float custo;
if (tipoPraga == ERVADANINHA)
custo = 8000 * areaInfectada;
else if (tipoPraga == GAFANHOTOS)
custo = 10000 * areaInfectada;
else if (tipoPraga == BROCAS)
custo = 15000* areaInfectada;
else
custo = 18000 x areaInfectada;
return custo;
}

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main()
{
int praga, identificacao;
float area, custo;
while (identificacao = lerDadosFazendeiro () != SENTINELA)
{
if (identificacao <= 0)
printf("\n Erro: Numero de identificacao invalido");
else {
praga = lerTipoPulverizacao ();
area = lerAreaPulverizada ()
custo = custoServico (praga,area);
if (area > 10.00)
custo = actualizarCusto (custo , descontoArea (custo));
if ( (int)custo > 1000000 )
custo = actualizarCusto (custo , descontoPreco(custo));
imprimir (custo,identificacao);
}

208
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

}
system("PAUSE");
return 0;
}

Problema 6.14.3: Dada a velocidade de um automóvel e a velocidade máxima

permitida num determinado local. Desenvolver um programa que lê um conjunto
indefinido de dados como: carta de condução, velocidade do carro, velocidade
actuada e imprima um relatório com o valor da multa e os pontos perdidos de
acordo a seguinte tabela.

Velocidade em excesso Multa Pontos

Até 10% da velocidade limite 0 0
Entre 10% e 20 % da velocidade limite 15.000,00 4
Acima de 20 % da velocidade limite 30.000,00 7

Para além disso, o programa deverá imprimir o valor total das multas.

Resolução: Como o leitor já está familiarizado com a metodologia de

refinamento sucessivo, apresentamos uma versão refinada:

1- declarar as variáveis;
2- inicializar contadores e acumuladores;
3- ler o número da carta de condução;
4- enquanto número da carta de condução != SENTINELA faça
5- inicio
6- se número da carta ≤ 0 então
7- imprimir("\n Erro: velocidade do carro inválida");
8- senão
9- inicio
10- carregar dados da velocidade;
11- calcular a velocidade em excesso;
12- calcular a percentagem da velocidade em excesso;
13- calcular o valor da multa;
14- calcular os valor de pontos perdidos;
15- acumular o valor da multa e o número de multas;
16- imprimir uma linha no tela;
17- fim
18- ler número da carta de condução;
19- fim
20- imprimir totais

Pelo enunciado, temos como dados de entrada o número da carta de condução,

velocidade do carro e velocidade actuada. Vamos associar esses dados as
respectivas variáveis a associa-las aos seus tipos de dados:

int cartaConducao, velocidadeCarro, velocidadeLimite;

209
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Como dados de saída temos dois mapas. O primeiro é uma listagem com o
número da carta de condução, pontos retirados e o valor da multa. Essa
informação está associadas as variáveis:

int totalPontos;
float valorMulta;

O segundo é uma listagem de totais com número total de multas e Valor

arrecadado com essas multas. Essa informação está associada as variáveis:

int numeroMultas;
float valorTotalMultas;

Como não temos definido o número de multas a processar, utilizaremos um

sentinela de fim de leitura carta de condução.

#define SENTINELA 0

No próximo passo, vamos descrever as acções que devem ser implementadas

como subprogramas. Para efeitos didáticos faremos essa implementação com
variáveis globais.

O subprograma, ler o número da carta de condução, que denominamos por

lerCartaConducao(), não recebe nenhum argumento e não devolve qualquer
informação. O algoritmo que resolve esse procedimento é descrito pelos
seguintes passos:

1- imprimir("Entre com o número da carta :"); ler (cartaConducao);

O subprograma, carregar os dados da velocidade, que denominamos por

carregarVelocidades(), não recebe nenhum argumento e não devolve qualquer
informação. O algoritmo que resolve esse procedimento é descrito pelos
seguintes passos:

1- imprimir("Entre com a velocidade limite:"); ler(velocidadeLimite);

2- imprimir("Entre com a velocidade do carro.");ler (velocidadeCarro);

O subprograma, calcular a velocidade em excesso, que denominamos por

velocidadeExcesso(), não recebe nenhum argumento e retorna o valor da
velocidade em excesso. O algoritmo que resolve essa função é descrito pelos
seguintes passos:

1- calcular velocidadeExcesso = velocidadeCarro - velocidadeLimite;

2- retornar velocidadeExcesso;

O subprograma, calcular a percentagem da velocidade em excesso, que

denominamos por percVelocidade(), recebe como argumento a velocidade em
excesso e retorna o valor da percentagem que essa velocidade representa
relação a velocidade limite. O algoritmo que resolve essa função é descrito pelos
seguintes passos:

210
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

1- calcular percentagem = (velocidadeExecesso * 100) / velocidadeLimite;

2- retornar percentagem;

O subprograma, calcular o valor da multa, que denominamos por valorDaMulta(),

recebe como argumento a percentagem da velocidade em relação ao velocidade
limite e retorna o valor da multa. O algoritmo que resolve essa função é descrito
pelos seguintes passos:

1- se percentagem <= 10 então

2- armazenar zeros no valor da multa;
3- senão se percentagem <= 20 então
4- armazenar quinze mil no valorMulta;
5- senão
6- armazenar trinta mil no valorMulta;
7- retornar valorMulta

O subprograma, calcular o valor dos pontos perdidos, que denominamos por

pontosAPerder(), recebe como argumento a percentagem da velocidade em
relação a velocidade limite e retorna o número de pontos perdidos. O algoritmo
que resolve essa função é descrito pelos seguintes passos:

1- se percentagem <= 10 então

2- armazenar zeros em pontosPerdidos;
3- senão se percentagem <= 20 então
4- armazenar quatro em pontosPerdidos;
5- senão
6- armazenar sete em pontosPerdidos;
7- retornar pontosPerdidos;

O subprograma, acumular o valor da multa e o número de multas, que

denominamos por ActualizarContadores(), recebe como argumento os pontos
perdidos e o valor da multa. Não devolve nenhuma informação para o exterior.
O algoritmo que resolve esse procedimento é descrito pelos seguintes passos:

1- calcular numeroMultas = numeroMultas + 1;

2- calcular valortotalMultas = valortotalMultas + valorMulta;

O subprograma, imprimir uma linha na tela, que denominamos por linhaMapa(),

recebe como argumento os pontos perdidos e o valor da multa. Não devolve
nenhuma informação. O algoritmo que resolve esse procedimento é descrito
pelos seguintes passos:

1- imprimir (cartaConducao, valorMulta, pontosPerdidos);

O subprograma, imprimir ltotais, que denominamos por linhaTotais(), não recebe

nenhum argumento e não devolve nenhuma informação. O algoritmo que resolve
esse procedimento é descrito pelos seguintes passos:

1- imprimir (valorTotalMulta, numeroMultas);

211
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

Como todas as linhas do nosso algoritmo são claras e precisas estamos em

condições de converter o nosso algoritmo para um programa em C.

/*--------------------------------------------------------------------------------------------------------
Objectivos: imprimir um relatório com o valor das multas e os pontos perdidos
na carteira de motoristas infractores. No fim do relatório adicionar uma linha com
as estatísticas
-------------------------------------------------------------------------------------------------------*/
##include <stdio.h> /* incluir as funções scanf() e printf() */
#include <stdlib.h> /* incluir a função system() */
#define SENTINELA 0
#define TRUE 1
#define FALSE 0

/*--------------------------------------------------------------------------------------------------------
Variáveis Globais
------------------------------------------------------------------------------------------------------*/
int cartaConducao, velocidadeCarro, velocidadeLimite;
int numeroMultas = 0;
float valorTotalMultas = 0.0;

/*--------------------------------------------------------------------------------------------------------
Protótipos de funções
-------------------------------------------------------------------------------------------------------*/
void lerCartaConducao ();
void carregarVelocidades ();
int velocidadeExcesso ();
int percVelocidade (int excesso, int limite);
float valorDaMulta (int percentagem);
int pontosAPerder ( int pontosPerdidos);
void ActualizarContadores (float valorMulta);
void linhaMapa ( float valorMulta, int numeroPontos);
void linhaTotais ();

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler número da carta de conduçao
--------------------------------------------------------------------------------------------------------*/
void lerCartaConducao ()
{
printf("\n Entre com o numero da carta: "); scanf("%d",&cartaConducao);
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Ler e validar velocidades no instante de actuação
--------------------------------------------------------------------------------------------------------*/
void lerVelocidades ()
{
printf("\n Entre com a velocidade limite :"); scanf("%d",&velocidadeLimite);
printf("\n Entre com a velocidade carro :"); scanf("%d",&velocidadeLimite);

212
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*-------------------------------------------------------------------------------------------------------
Objectivo: Validar as velocidades da infracção
--------------------------------------------------------------------------------------------------------*/
void validaVelocidades ()
{
if (velocidadeCarro < velocidadeLimite)
return FALSE;
else
return TRUE;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular a velocidade em excesso
Retorna : Velocidade em excesso
--------------------------------------------------------------------------------------------------------*/
int velocidadeExcesso ( )
{
return velocidadeCarro - velocidadeLimite;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular a percentagem da velocidade em excesso
Recebe: Velocidade em excesso
Retorna: Percentagem dessa velocidade
--------------------------------------------------------------------------------------------------------*/
int perVelocidade (int excesso)
{
return (excesso * 100) / velocidadeLimite;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular o valor da multa
Recebe: Percentagem
Retorna: Valor da multa
--------------------------------------------------------------------------------------------------------*/

float valorDaMulta (int percentagem)

{
float multa;
if (percentagem <= 10)
multa = 0.0;
else if (percentagem <= 20)
multa = 15000.0;
else
multa = 30000.0;
return multa;
}

213
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*-------------------------------------------------------------------------------------------------------
Objectivo: Calcular os pontos a perder
Recebe: Percentagem
Retorna: Pontos perdidos
--------------------------------------------------------------------------------------------------------*/
int pontosAPerde r(int percentagem)
{
float pontosPerdidos;
if (percentagem <= 10)
pontosPerdidos = 0;
else if (percentagem <= 20)
pontosPerdidos = 4;
else
pontosPerdidos = 7;
return pontosPerdidos;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Actualizar o total geral de multas e o total geral de pontos perdidos.
Recebe: Pontos perdidos, valor da Multa
--------------------------------------------------------------------------------------------------------*/
void actualizarContadores ( float valorMulta );
{
numeroMultas + = 1;
valorTotalMultas += valorMulta;
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Imprimir uma linha de detalhe
Recebe: Carta condução, valor da multa e pontos perdidos
--------------------------------------------------------------------------------------------------------*/
void linhaLinha (int cartaConducao, float valorMulta, int pontosPerdidos)
{
printf(" \n Numero carta Conducao %d", cartaConducao);
printf(" \n Valor da multa %12.2f ", valorMulta);
printf(" \n Pontos perdidos %2d ", pontosPerdidos);
}

/*-------------------------------------------------------------------------------------------------------
Objectivo: Imprimir a linha de Estatística
--------------------------------------------------------------------------------------------------------*/
void linhaTotais ()
{
printf(" \n Numero total de multas %4d "; numeroMultas);
printf(" \n Valor total das multas %.2f ",valortotalMultas);
}

214
 Fundamentos de Programação em C: Uma Abordagem Algorítmica

/*--------------------------------------------------------------------------------------------------------
Função principal
--------------------------------------------------------------------------------------------------------*/
int main ()
{
int carta, pontos, percentagem;
float excesso, Multa;
while (carta = LerCartaConducao() != SENTINELA )
{
if (carta <= 0)
printf("\n Erro: numero da carta invalido);
else {
lerVelocidades();
if (validaVelocidade() == TRUE)
{
excesso = velocidadeExcesso( );
percentagem = pecVelocidade(excesso);
multa = valorDaMulta(percentagem);
pontos = pontosAPerder(percentagem);
actualizarContadores(multa);
imprimirLinha(carta,multa,pontos);
}
else
printf("\Erro: Dados das velocidades inválidos");
}
}
imprimirTotais();
system("PAUSE");
return 0;
}

215