Baixe Linguagem de Programação Pascal - Apostilas - Informática Part3 e outras Notas de estudo em PDF para Informática, somente na Docsity!
VAR
t, S: real; n: integer; BEGIN S := 0; (* Variável que guardará a soma desejada ) n := 0; ( Contador de termos (índice do termo ) ClrScr; ( geral) ) REPEAT n := n + 1; t := EXP(-3LN(2n - 1)); ( termo geral ) IF Odd(n) THEN BEGIN S := S + t; ( Se n for ímpar, então soma-se ) END ELSE ( t a S; caso contrário, sub- ) BEGIN S := S - t; ( trai-se t de S. ) END; GOTOXY(10, 10); ( Posiciona o cursor na 10a. coluna ) ( e 10a. linha da tela ) Write('n = ', n, ' ', t:13:10); ( mostra o índice ) ( atual e o valor do termo geral *) UNTIL t < 1E-10; Writeln; Writeln; Writeln('Soma = ', S:15:10); Writeln('Foram somados ', n, ' termos'); END.
Exemplo: A função booleana KEYPRESSED da unidade CRT pode ser usada para veri car se em determinado momento foi pressionada alguma tecla. Ela é TRUE quando for pressionada qualquer tecla e FALSE em caso contrário. O programinha a seguir, gera aleatoriamente cores e caracteres do intervalo #50..#250 e ca mostrando-os na tela até ser pressionado qualquer tecla. Para isso, usamos um RANDOM(16) para gerar um número de cor de 0 a 15, um RANDOM(201) + 50 para gerar um número inteiro de 50 a 250 e um REPEAT ... UNTIL KEYPRESSED para repetir o processo até ser pressionada alguma tecla. A cor do texto pode ser piscante ou não, dependendo de RANDOM(2) em cor1 gerar um 0 ou um 1.
PROGRAM UsandoKeyPressed; USES Crt; VAR ch: char; cor1, cor2: byte; BEGIN ClrScr; Randomize; repeat cor1 := Random(16) + 128*Random(2); cor2 := Random(16); TextColor(cor1); TextBackground(cor2);
ch := Chr(Random(201) + 50); (* #50 <= ch <= #250 *) Write(ch); until KEYPRESSED END.
Exemplo: Neste último exemplo deste capítulo, vamos usar 3 comandos da unidade CRT para gerar sons com determinadas freqüência e duração. São eles:
SOUND(n) ---> Emite continuamente um som de n MHz NOSOUND ---> Encerra a emissão do som DELAY(t) ---> Pausa de t milisegundos
A execução de uma determinada nota musical é feita da seguinte forma:
i. Usamos o SOUND para emitir um som cuja freqüência é a da nota desejada. Para isso, devemos consultar antes uma tabela de freqüência de sons;
ii. Usamos o DELAY para determinar a duração da nota;
iii. Encerramos a emissão do som com o NOSOUND.
Usaremos o READKEY para veri car qual tecla foi pressionada no teclado e um CASE para emitir um som que corresponda à nota desejada. Vamos convencionar que o "Q"emite um dó, o "W"um ré, .... As teclas que não constarem dos alvos do CASE não emitirão sons. Precisamos também de um REPEAT-UNTIL para repetir o processo de "pressionar tecla e emitir som"até que READKEY retorne o caracter #27, que corresponde à tecla ESC.
PROGRAM Piano; USES Crt; CONST TeclaESC = #27; VAR ch: char; BEGIN ClrScr; GoToXY(18, 10); Writeln('Toque sua musica usando as teclas QWERTYUIOP[]'); GoToXY(18, 12); Writeln('Exemplo: QQWQRE QQWQTRR YYIYREW UUYRTRR'); GoToXY(18, 14); Writeln('Para encerrar, pressione a tecla ESC.'); REPEAT ch := ReadKey; CASE ch OF 'Q', 'q' : Sound(262); { dó } 'W', 'w' : Sound(294); { ré } 'E', 'e' : Sound(330); { mi } 'R', 'r' : Sound(350); { fá } 'T', 't' : Sound(396); { sol } 'Y', 'y' : Sound(440); { lá }
6 − FUNÇÕES E PROCEDIMENTOS
6.1 FUNÇÕES
O Pascal oferece muitas facilidades para a confecção de programas modularizados. A modularização consiste na divisão de um programa longo em várias partes, chamadas subprogramas, cada uma funcionando de forma independente das outras, cada uma realizando tarefas especí cas controladas por um núcleo comum, chamado programa principal.
| Programa principal | +--------------------------+ ^ ^ ^ / |
v v v +------------+ +------------+ +------------+ | Subprogr_1 | | Subprogr_2 | | Subprogr_3 | +------------+ +------------+ +------------+ ^ | v +------------+ | Subprogr_4 | +------------+
Cada subrotina funciona como se fosse um pequeno programa, com suas próprias variáveis, suas próprias de nições de tipos, seus próprios subrotinas, etc. Cada vez que um subrotina é chamado, ele é executado, e após o término de sua execução, o controle do programa volta ao comando que vier depois do ponto de onde o subrotina foi chamado. Em Pascal podemos ter subrotinas de dois tipos: as funções (FUNCTIONS) e os procedimentos (PROCEDURES).
6.1.1 ESTRUTURA DE UMA FUNÇÃO
Uma função é um subrotina que tem um único valor de retorno. O Pascal oferece muitas possibilidades na de nição de funções. Uma função é declarada na área de declarações do programa (depois do cabeçalho e do USES e antes do BEGIN da seção principal) e possui a seguinte estrutura:
i. Um cabeçalho (ou protótipo) identi cado pela palavra chave FUNCTION, seguida do nome da função, da lista de parâmetros e tipos entre parênteses e separados entre si por vírgulas, de um sinal de dois pontos e do tipo do valor que será retornado pela função. Parâmetros de tipos diferentes devem ser separados por ponto-e-vírgula.
ii. Uma área de declarações de tipos, variáveis, constantes, rótulos, funções ou procedimentos.
iii. A de nição da função delimitada pelas palavras chave BEGIN e END, com um ponto-e-vírgula no nal. O valor de retorno da função é de nida por uma atribuição do tipo:
Nome_da_função := Valor;
O valor retornado por uma função pode ser do tipo inteiro, real, boolean, string, char, entre outros.
Exemplo: O cabeçalho de uma função F com parâmetro x inteiro e que retorne um valor inteiro (ou seja, F : Z > Z) deve ser declarado como:
FUNCTION F (x: integer): integer;
Uma função G com três parâmetros a, b, c do tipo shortint e que retorne um valor real, deve ser declarada como:
FUNCTION G (a, b, c: shortint): real;
No caso da função F deste exemplo, ela será chamada para ser executada sempre que aparecer no programa uma expressão do tipo F(expr), onde "expr"é qualquer constante, variável ou expressão do tipo inteiro. Já a função G, ela pode ser chamada colocando-se em qualquer lugar do programa algo como G(expr1, expr2, expr3), onde "expr1", "expr2", "expr3"são expressão do tipo shortint.
Exemplo: Neste exemplo, de niremos uma função logaritmo decimal Log10(x) que, por de nição, será igual ao quociente Ln(x)/Ln(10). Como queremos que o argumento x da função seja sempre um número real, então na linha do cabeçalho da função colocamos FUNCTION Log10(x: real). Para que ela retorne um valor real, nalizamos a linha do cabeçalho com ": real; "Dessa forma, o cabeçalho da função de ne seu domínio e contradomínio.
A seguir, entre os delimitadores BEGIN/END, de nimos o valor que a função deve retornar. Neste caso, a atribuição é feita ao nome da função, e não ao nome seguido do parâmetro. Uma atribuição como Log10(x) := Ln(x)/Ln(10) está errada.
FUNCTION Log10(x: real): real; BEGIN Log10 := Ln(x)/Ln(10); END;
Uma versão mais elaborada, deveria veri car se o argumento x é válido ou não. Temos então:
FUNCTION Log10(x: real): real; { versao 2 } BEGIN if (x < 0) then begin Writeln('Parametro invalido'); Halt; { encerra a execução do programa } end else begin Log10 := Ln(x)/Ln(10);
END; (* fim da definição de MAX *)
FUNCTION Min(x, y: real): real; (* Função MIN ---> retorna o menor valor entre x e y ) BEGIN if (x <= y) then begin Min := x; end else begin Min := y; end; END; ( fim da definição de MIN *)
BEGIN (* inicio do programa principal ) Write('Forneca dois numeros : '); Readln(a, b); Writeln('O maior dos dois é' ', Max(a, b):6:2); Writeln('e o menor é' ', Min(a, b):6:2) END. ( fim do programa *)
OBSERVAÇÃO IMPORTANTE: As variáveis de nidas em uma função, chamadas variáveis locais, ou as que são de nidas como parâmetros, não têm nenhuma relação com as variáveis de outras funções ou do programa principal, mesmo que elas tenham o mesmo nome. O programa principal não tem conhecimento das variáveis locais declaradas em uma função.
Exemplo: O comando EXIT, quando usado em uma função, faz o controle do programa abandonar a função e voltar ao ponto na qual a função foi chamada. É útil para se interromper a execução de uma função que foi chamada com algum argumento com valor inválido. A seguir, de nimos uma função fatorial. Se ela for chamada com argumentos inválidos (negativos ou grandes), então o comando EXIT faz o controle do programa abandonar a função e voltar ao ponto de chamada.
FUNCTION Fat(n: integer): integer; VAR (* declaração das variáveis locais ) i, prod_aux: integer; BEGIN if (n < 0) or (n > 12) then begin Writeln('Argumento n invalido na chamada de FAT.'); EXIT; ( abandona a execução da função *) end else begin if n <= 1 then begin Fat := 1; end else begin prod_aux := 1;
for i := 2 to n do begin prod_aux := prod_aux * i; end; Fat := prod_aux end; end; END; (* fim da definição da função *)
Precisamos de uma variável auxiliar (prod_aux) para guardar o valor do fatorial, porque uma atribuição como Fat := Fat * i não é permitida (só seria possível se Fat fosse uma variável).
Um exemplo de um programa que use esta função é:
PROGRAM UsandoFat; (* Lista os valores de n!, com 0 <= n <= 12 ) VAR i: integer; ( este "i" não tem nenhuma relação com o "i" da função FAT ) ( Nesta área, suponhamos que esteja escrita a FAT acima. *) BEGIN Writeln(' n n!'); for i := 0 to 12 do begin Writeln(i:2, Fat(i):12); end; END.
Exemplo: Neste exemplo de niremos uma função CURSO que associa a alguns números inteiros, nomes de cursos da UFPB.
FUNCTION Curso(n: integer): string; BEGIN CASE n OF 8 : Curso := 'Ciencias'; 11 : Curso := 'Quim. Industrial'; 22 : Curso := 'Eng. Civil'; 23 : Curso := 'Eng. Alimentos'; 24 : Curso := 'Eng. Mecanica'; 25 : Curso := 'Bach. Quimica'; 30 : Curso := 'Bach. Fisica'; 32 : Curso := 'Bach. Matematica'; 44 : Curso := 'Bach. Computacao'; else Curso := 'Curso desconhecido'; END; END;
Suponhamos que esta função esteja de nida em um arquivo do disco chamado CURSOS.PAS (basta digitá-la, pressionar F2, digitar CURSOS e pressionar ENTER). Para incluí-la em qualquer programa em Pascal, basta usar uma diretiva de inclusão, cuja sintaxe é,
PROGRAM Testando_a_funcao_Repete; VAR i: integer; ch: char; {$I REPETE.PAS} BEGIN Write('Caracter a ser repetido? '); Readln(ch); Write('Quantidade de vezes? '); Readln(i); Writeln; Writeln('REPETE (', i, ', ', ch, ') = ', Repete(i, ch)) END.
Um outro exemplo, gera aleatoriamente os valores de i e ch e repete esse processo inde nidamente (até ser pressionado as teclas CTRL e BREAK).
PROGRAM Testando_a_funcao_Repete_2; USES Crt; VAR i: integer; ch: char; {$I REPETE.PAS} BEGIN Randomize; repeat i := Random(50); (* i é um inteiro qualquer de 0 a 49 ) ch := Chr(Random(255)); Writeln; Writeln('REPETE (', i, ', ', ch, ') = ', Repete(i, ch)); Delay(1000); ( pausa de 1 segundo *) until 1 > 2 END.
Exemplo: O conjunto de funções a seguir, complementa a "de ciência"do Pascal com relação às funções trigonométricas e hiperbólicas. Podem ser criados dois arquivos no disco TRIG.PAS e HIPER.PAS para serem incluídos em qualquer programa pela diretiva de inclusão $I TRIG.PAS ou $I HIPER.PAS.
{ FUNCOES TRIGONOMETRICAS }
function Tg(x: real): real; { Tangente } begin if Cos(x) = 0 then begin Halt; { parametro invalido } end; Tg := Sin(x)/Cos(x) end; { -------------------------------------------------------- }
function Cotg(x: real): real; { Cotangente } begin if Sin(x) = 0 then begin Halt; { parametro invalido } end; Cotg := Cos(x)/Sin(x) end; { -------------------------------------------------------- } function Sec(x: real): real; { Secante } begin if Cos(x) = 0 then begin Halt; end; Sec := 1/Cos(x) end; { -------------------------------------------------------- } function Cossec(x: real): real; { Cossecante } begin if Sin(x) = 0 then begin Halt; end; Cossec := 1/Sin(x) end; { -------------------------------------------------------- } function ArcSen(x: real): real; { Arco-seno } begin if (Abs(x) > 1) then begin Halt; { parametro invalido } end; else begin if (x = 1) then begin ArcSen := Pi/2; end; else begin if (x = -1) then begin ArcSen := -Pi/2; end; else begin ArcSen := ArcTan(x/Sqrt(1 - Sqr(x))); end; end; end; { -------------------------------------------------------- }
Halt; { parametro invalido } end; ArcCosh := Ln(x + Sqrt(Sqr(x) - 1)) end; { -------------------------------------------------------- } function ArcTgh(x: real): real; { Arco-tangente hiperbolica} begin if (x >= 1) or (x <= -1) then begin Halt; { parametro invalido } end; ArcTgh := Ln((1 + x)/(1 - x))/ end; { -------------------------------------------------------- }
Exemplo: De niremos neste exemplo uma função booleana chamada PRIMO(n) que será TRUE se n for primo e FALSE em caso contrário.
FUNCTION Primo(n: integer): boolean; (* Testa se um inteiro n é primo ) VAR i: integer; raiz: real; BEGIN Primo := TRUE; ( suposição inicial de que n é primo ) if (n < 0) then begin n := -n; end; if (n = 2) then begin Exit; end; if (n = 1) or (n mod 2 = 0) then ( caso em que n é 1 ) begin ( ou é par > 2 ) Primo := FALSE; Exit; end; raiz := Sqrt(n); ( Caso geral: Se n for divisí- ) i := 3; ( vel por um ímpar maior ou ) while (i <= raiz) do ( igual a 3 e menor ou igual à ) begin ( raiz quadrada de n, então n ) if (n mod i = 0) then ( não é primo. Caso contrário, ) begin ( n é primo. *) Primo := false; Exit; end; i := i + 2 end
END;
Gravando-se esta função no disco sob o nome de PRIMO.PAS, podemos usar o seguinte programa que lista todos os primos de 1 a 1000000:
PROGRAM ListagemDePrimos; {$I PRIMO} (* ---> A extensão .PAS pode ser omitida *) VAR i: integer; BEGIN for i := 1 to 10000 do if Primo(i) then Writeln(i:8, ' e'' primo.') END.
Exemplo: Vamos construir agora nossa função potência POT(x, y) = x y. Para uso posterior, vamos salvá-la em disco sob o nome de POT.PAS. Identi caremos com 0 todo número que, em módulo, seja menor do que 10 −^10.
FUNCTION Pot(x, y: real): real; CONST epsilon = 1E-10; BEGIN if (Abs(x) < epsilon) and (Abs(y) < epsilon) then begin (* Caso em que x = 0 e y = 0 ) Writeln('ERRO: Forma indeterminada 0 elevado a 0.'); Halt; end else begin if (Abs(x) < epsilon) then begin ( Caso em que x = 0 ) if (y > 0) then begin Pot := 0; end; else begin Writeln('ERRO: Base nula e expoente negativo.'); Halt; end; end else begin if (Abs(y) < epsilon) then ( Caso em que y = 0 ) begin Pot := 1; end else begin if (x > 0) then ( Caso geral com x > 0 *)
FUNCTION PotenciaDeDois(n: integer): boolean; VAR m: integer; BEGIN repeat m := n; n := n div 2; until n*2 <> m; if (m = 1) then begin PotenciaDeDois := true; end; else begin PotenciaDeDois := false; end; END;
Como exemplo de utilização dessa função, temos o programa abaixo que lista as potências de 2 de 1 a 100000.
PROGRAM Potencia_de_2; {$I POT_2} VAR x: integer; BEGIN for x := 1 to 100000 do begin if PotenciaDeDois(x) then begin Writeln(x, ' e'' potencia de dois'); end; end; END.
6.1.2 FUNÇÕES DEFINIDAS POR SOMATÓRIOS
Exemplo: A função real FSERIE a seguir é de nida por um somatório. Fornecidos um real x e a quantidade n de termos do somatório, FSERIE(x, n) é de nida como sendo o somatório de sin k(kx) com k variando de 1 a n.
FUNCTION FSerie(x: real; n: byte): real; (* Sen(2x) Sen(nx) FSerie(x, n) = Sen(x) + --------- + ... + --------- 2 n *) var aux: real; k: integer;
BEGIN
aux := 0; for k := 1 to n do begin aux := aux + sin(k*x)/k; end; FSerie := aux END;
Exemplo: A função a seguir é uma aproximação para a função exponencial de base E. Trata-se da função de nida pelos 11 primeiros termos da série de Taylor de EXP(x).
Usamos na sua de nição duas funções de nidas anteriormente: FAT e POT.
FUNCTION ExpAprox(x: real): real; (* 2 3 10 x x x ExpAprox(x) = 1 + x + ----- + ----- + ... ----- 2! 3! 10! *) var i: integer; aux: real; BEGIN aux := 0; for i := 0 to 10 do begin aux := aux + Pot(x, i)/Fat(i); end; ExpAprox := aux END;
6.2 PROCEDIMENTOS
6.2.1 DEFINIÇÃO, PROCEDIMENTOS SEM PARÂMETROS
Um procedimento (procedure) é um trecho de programa que possui seus próprios objetos (variáveis, constantes, tipos, funções, outros procedimentos, ...). Juntamente com as funções, os procedimentos formam o que se chama genericamente de subrotinas (ou subprogramas). Os procedimentos diferem das funções apenas pelo fato das funções retornarem sempre um único valor, enquanto que os procedimentos não retornam valor algum. A criação de um procedimento em Pascal é feita através de sua declaração na área de declarações do programa. Um procedimento possui um cabeçalho, identi cado pela palavra reservada PROCEDURE seguida do nome do procedimento e uma lista opcional de parâmetros. Segue-se ao cabeçalho um bloco de declarações dos objetos locais do procedimento, e um bloco de comandos delimitados pelas palavras chave BEGIN e END com um ponto-e-vírgula no nal:
PROCEDURE NomeDoProcedimento (parâmetro1, parâmetro2, ...); (* declarações de tipos, variáveis, constantes, ... *) BEGIN comando1;
comando2; x := função1; END; (* fim do procedimento *)
BEGIN (* inicio da seção principal ) REPETE; y := função2; comando3; REPETE; z := Cos(x); comando4; REPETE; comando5; END. ( fim do programa *)
Os dois esboços de programa anteriores são equivalentes. Exemplo: Os procedimentos aumentam signi cativamente a clareza dos programas. Voltemos aquele nosso primeiro programa do Capítulo 2, aquele que somava dois inteiros. Um programa desse tipo é feito basicamente em três etapas:
i. Ler os inteiros;
ii. Calcular sua soma;
iii. Mostrar seu resultado.
Cada etapa na elaboração de um programa, sugere um procedimento próprio. Neste caso, usaremos três procedimentos LERNUMEROS, CALCULARSOMA e MOSTRARRESULTADO. Com isso o programa principal se limitará a listar as etapas na execução do programa:
PROGRAM SomaDeInteiros; VAR x, y, soma: integer; PROCEDURE LerNumeros; BEGIN Writeln; Write('Forneca o valor de x : '); Readln(x); Write('Forneca o valor de y : '); Readln(y); END; (* fim de LerNumeros ) PROCEDURE CalcularSoma; BEGIN soma := x + y; END; ( fim de CalcularSoma ) PROCEDURE MostrarResultado; BEGIN Writeln; Writeln('Soma = ', soma); Writeln; Write('Pressione ENTER para encerrar.'); Readln; END; ( fim de MostrarResultado *)
BEGIN (* inicio do programa principal ) LerNumeros; CalcularSoma; MostrarResultado END. ( fim do programa *)
Neste exemplo, as variáveis X, Y, SOMA são do conhecimento de todo o programa pois elas foram de nidas fora de qualquer procedimento ou função. Dizemos que variáveis assim são globais. O uso de variáveis globais deve globais ser evitado, pois pode levar a erros difíceis de serem detectados. O uso de parâmetros evita o uso abusivo de variáveis globais. O programa cou grande, mas ca mais fácil de se ler uma vez que cada parte do programa executa uma tarefa especí ca. Podemos estar interessado apenas na saída dos resultados, e aí, bastaríamos olhar o procedimento MOSTRARRESULTADO e ignorar os demais. O programa ca também mais fácil de se consertar ou de se fazer mudanças.
6.2.2 PROCEDIMENTOS COM PARÂMETROS
A lista de parâmetros, delimitada por parênteses, pode aparecer no cabeçalho de um procedimento. Nessa lista, se ela existir, são designadas as variáveis que receberão valores enviados ao procedimento na hora de sua chamada. Na lista de parâmetros, cada nome de variável é seguido do nome do respectivo tipo. Entre o tipo e o nome da variável deve haver um sinal de dois pontos. Variáveis de um mesmo tipo podem estar separadas entre si por vírgulas e o tipo comum ser mencionado apenas uma vez. Após o nome de cada tipo deve vir um ponto-e-vírgula:
PROCEDURE NomeDoProcedimento(var1: tipo1; var2: tipo2; ...);
Cada variável listada no cabeçalho de um procedimento será considerada uma variável local. Portanto, outras partes do programa nem ao menos têm conhecimento dessas variáveis, mesmo que tenham o mesmo nome. Um "x"usado no cabeçalho de um procedimento normalmente não tem nenhuma relação com um outro "x"do programa principal.
Exemplo: PROCEDURE Teste(a, b, c: integer);
Um procedimento que tenha este cabeçalho, está preparado para aceitar exatamente 3 inteiros quando ele for ativado. Um comando no programa como TESTE(1, 2, 3), forçará a execução do procedimento TESTE com os valores dos parâmetros a = 1, b = 2 e c = 3. TESTE parece uma função de 3 variáveis inteiras, mas observe a grande diferença de que nenhum valor é retornado, ou seja, não há nada que possa servir de contradomínio para TESTE.
Estão erradas as seguindes chamadas a TESTE: TESTE(3,5), TESTE(6, 5, 2, -1) e TESTE(3.2, -1.0, 7).
Exemplo: PROCEDURE TesteDois(nome: string; mat: integer); Com esta declaração, uma chamada a TESTEDOIS pode ser feita como
TESTEDOIS('Jose J J da Silva', 91110023);
ou como
TESTEDOIS('Antonio A Braga', 92101234);
