A maior rede de estudos do Brasil

Grátis
146 pág.
livro programando com pascal - jaime evaristo

Pré-visualização | Página 26 de 50

conjunto de parâmetros, cujo número de elementos não 
é prefixado, podendo até ser um conjunto vazio, situação na qual necessita apenas da digitação da tecla 
<Enter> para sua execução. Por seu turno, o procedimento writeln pode receber como argumentos 
identificadores de variáveis, expressões, mensagens e até, como veremos no capítulo 10 (dez), arquivos. Do 
mesmo modo que o comando readln, o conjunto de parâmetros do comando writeln pode ser vazio, quando, 
neste caso, sua execução implica a mudança do cursor para a linha seguinte.
4. O Sistema Turbo Pascal oferece dois procedimentos para incrementar e decrementar uma variável. 
São os procedimentos Inc e Dec que podem ser ativados com um ou dois parâmetros. O primeiro (ou único) 
parâmetro é a variável que deve ser incrementada ou decrementada e o segundo parâmetro é o inteiro que dá 
o valor do incremento ou do decremento. Por exemplo, Inc(i, 2) incrementará de duas unidades o conteúdo 
da variável i; Dec(i) decrementará de uma unidade o conteúdo de i.
5.4 Funções
Como vimos acima, procedimentos são subprogramas que executam tarefas genéricas não 
necessariamente retornando algum valor. As funções, além de poderem executar ações genéricas, podem 
retornar valores, devendo ser declaradas de acordo com a seguinte sintaxe :
function Identificador(var lista de parâmetros : tipo de dado) : tipo de dado;
declarações e definições
begin
seqüência de comandos;
end;
Se a função deve retornar um valor, este valor será do tipo de dado fixado na sua declaração, que é 
necessariamente um tipo de dado simples ou uma string (o tipo de dado string será estudado no capítulo 7). 
Este tipo de dado associado à função é usualmente chamado de tipo da função. Neste caso, é necessário que 
na seqüência de comandos de uma função exista uma atribuição do tipo
Identificador := Expressão; 
sendo justamente o valor desta Expressão o que será retornado para processamento, quando da ativação da 
função. Esta ativação deve ser feita num segundo membro de um comando de atribuição, como argumento 
de um comando de saída ou, de um modo geral, numa expressão. 
Do mesmo modo que nos procedimentos, variáveis, tipos de dados e outros subprogramas podem ser 
definidos localmente.
5.5 Exemplos Parte VIII
1. O exercício 2, item c, da seção 2.12, solicitava um programa que realizasse a soma de duas frações 
ordinárias. O caro leitor deve ter desenvolvido a solução da questão e obtido um programa parecido com o 
seguinte:
program SomaFracoes;
var Num1, Den1, Num2, Den2, Num, Den: integer;
begin
writeln('Digite as fracoes');
readln(Num1, Den1, Num2, Den2);
Num := Num1 * Den2 + Num2 * Den1;
Den := Den1 * Den2;
writeln('(', Num1, '/', Den1, ') + (', Num2, '/', Den2,') = (', Num, '/', Den, ')');
end.
Um problema com este programa é que ele fornece a soma das frações na forma de uma fração redutível, 
ao contrário do que os professores de matemática exigem (confesso, não sei o porquê desta exigência). 
Sabendo que, para simplificar uma fração, basta dividir seus termos pelo seu máximo divisor comum, este 
programa seria melhorado se acrescentássemos uma função que calculasse o mdc de dois números, 
utilizando-se este valor para simplificar a fração.
program SomaFracoes;
var Num1, Den1, Num2, Den2, Num, Den, Mdc: integer;
{função que retorna o maximo divisor comum de dois inteiros dados}
function MaxDivComum(x, y : integer) : integer;
var Resto : integer;
begin
Resto := x mod y;
while Resto <> 0 do
begin
x := y;
y := Resto;
Resto := x mod y;
end;
MaxDivComum := y;
end;
{programa principal}
begin
writeln('Digite as fracoes');
readln(Num1, Den1, Num2, Den2);
Num := Num1 * Den2 + Num2 * Den1;
Den := Den1 * Den2;
Mdc := MaxDivComum(Num, Den);
Num := Num div Mdc;
Den := Den div Mdc;
writeln('(', Num1, '/', Den1, ') + (', Num2, '/', Den2,') = (', Num, '/', Den, ')');
end.
2. Sabendo que o fatorial de um inteiro não negativo n é o produto de todos os inteiros de 1 até n, sendo 
1 se n = 1 ou n = 0, o exemplo a seguir apresenta uma função que retorna o valor do fatorial de um inteiro n, 
dado (n! = 1*2*3*...*n). 
function Fatorial(m : integer) : longint;
var f : longint;
 i : integer;
begin
 f := 1;
for i := 1 to m do
f := f*i;
Fatorial := f;
end;
O tipo da função foi definido como longint, porque o fatorial é uma função que assume valores 
relativamente grandes para argumentos pequenos. Por exemplo, Fat(8) = 40 320.
É necessário um certo cuidado com o identificador de uma função. À primeira vista poderia se pensar 
que a utilização da variável f no exemplo seria desnecessária, substituindo a seqüência de comandos por:
Fatorial := 1;
for i := 1 to m do
Fatorial := Fatorial * i;
Ocorre que, como veremos na seção 5.7, Pascal oferece o recurso da recursividade, que nada mais é do 
que a possibilidade de que um subprograma ative a si próprio. Assim o sistema entenderia o Fatorial do 
segundo membro do comando 
Fatorial := Fatorial * i 
como uma nova ativação da função e aí iria reclamar a ausência dos argumentos. 
3. O exemplo 2 da seção 4.5 apresentava um programa que detectava números primos. O exemplo a 
seguir apresenta uma função boleana que retorna true se o argumento for um inteiro primo.
function Primo(m : integer) : boolean;
var i : integer;
 Raiz : real;
begin
i := 2;
Raiz := SqrT(m);
while (m mod i <> 0) and (i <= Raiz) do 
i := i + 1;
 if i <= Raiz
then 
 Primo := false
else 
 Primo := true;
end;
5.6 Passagem de parâmetros
No procedimento Troca do exemplo 1 da seção 5.3, as definições dos parâmetros eram precedidas da 
palavra reservada var o que não acontecia com as definições dos parâmetros da função MaxDivComum do 
exemplo 1 da seção 5.5. O que estes dois subprogramas possuem de diferentes é o seguinte: no primeiro, se 
pretendia que o procedimento tivesse influência nos conteúdos das variáveis passadas como argumentos 
enquanto que, no segundo, os conteúdos das variáveis passadas como argumentos não deveriam ser 
modificados pelos comandos da função. 
Quando se pretende que comandos de um subprograma modifiquem conteúdos de variáveis globais, as 
declarações dos parâmetros respectivos devem ser precedidas da palavra reservada var. Se isto acontece, o 
argumento a ser passado para o parâmetro tem que ser uma variável e o subprograma pode alterar o seu 
conteúdo, pois o que é passado para o parâmetro é uma referência à variável argumento; tudo se passa como 
se o parâmetro recebesse a própria variável. Neste caso, dizemos que a passagem dos parâmetros é por 
referência. Quando não se pretende que comandos do subprograma não interfiram em conteúdos de variáveis 
globais, a declaração dos parâmetros não é precedida da palavra var e o parâmetro recebe um elemento do 
seu tipo de dado, isto podendo ser feito através de: 
1. constantes do tipo de dado do parâmetro respectivo; 
2. conteúdos de variáveis do mesmo tipo de dado; 
3. expressões cujos resultados sejam daquele tipo.
Neste caso, a passagem de parâmetros é dita por valor. Resumindo: se a declaração de um parâmetro é 
precedida da palavra reservada var, o argumento tem que ser uma variável e comandos que alterem o 
parâmetro alterarão a variável; se a declaração do parâmetro não é precedida de var, o argumento é um valor 
(podendo ser passado como conteúdo de um variável) e os comandos do subprograma não interferem em 
conteúdos de variáveis globais.
Voltando a insistir: o procedimento Troca do programa Ordena3, apresentado na seção 5.3, tinha como 
objetivo permutar os conteúdos das variáveis globais utilizados como argumentos. Assim, as ações 
realizadas nos parâmetros deveriam se refletir nos conteúdos dos argumentos de ativação do procedimento. 
Isto implicou