Modulação de Programas: Procedimentos e Funções

A modularização consiste em um método utilizado para facilitar a construção de grandes programas, por meio da divisão em pequenas partes ou etapas que denominamos módulos, subprogramas ou sub-rotinas. Exemplos de modularização, i.e., sistemas que são compostos por módulos com funções bem definidas e tão independentes quanto possível, são bem conhecidos.  Por exemplo, a maior parte dos sistemas de alta fidelidade são compostos por módulos: o amplificador, o equalizador, o leitor de CD, o sintonizador, o leitor de cassetes, etc.

Principais vantagens da utilização de subprogramas.- •economia de código: escreve-se menos;      •desenvolvimento modularizado: pensa-se no algoritmo por partes;      •facilidade de depuração(correção/acompanhamento): é mais fácil corrigir/ detectar um erro apenas uma vez do que dez vezes;      •facilidade de alteração do código: se for preciso alterar, altera-se apenas uma vez;      •generalidade de código com o uso de parâmetros: escreve-se algoritmos para situações genéricas.

– Conceitos procedimento e função. – Função (Functions): Uma função se define em Object Pascal de forma muito parecida com definição conhecida na matemática . As funções recebem valores que são passados como parâmetros e retorna um valor como resultado. Define_se uma função obedecendo a seguinte sintaxe:      function NomeDaFunção(Parâmetro1: Tipo; ParâmetroN: Tipo): Tipo de retorno;     var {declaração de variáveis locais á função quando necessárias}     begin          {bloco de instruções}     end; Procedimento (Procedure): Um procedimento é semelhante a uma função, sua principal diferença é que um procedimento não tem valor de retorno, ou seja, não retorna valor algum, simplesmente processa e manipula valores dentro dele. Portanto um procedimento não pode ser atribuído a uma variável ou propriedade de algum componente ou objeto. Define-se um procedimento obedecendo a seguinte sintaxe:     procedure NomeDoProcedimento(Parâmetro1: Tipo; ParâmetroN : Tipo);     var {declaração de variáveis locais á função quando necessárias}     begin          {bloco de instruções}     end;

Suas semelhanças e suas diferenças.R.: a diferença entre funções e procedimentos é que funções podem retornar valores. A diferença reside no fato de que procedimentos não retornam valores. De diversas maneiras esta divisão de funções em dois tipos – as que retornam e as que não retornam valores – pode ser bastante útil.Uma função que não retorna um valor (um procedimento) é usado como um “sub-programa” ou uma subrotina. Invocamos a função e o programa realiza algumas ações, como fazer creme ou qualquer coisa. Podemos, então, usar esta função em muitos lugares sem termos que reescrever o código. Isto é chamado de reutilização de código.A utilidade de tal função (ou procedimento) reside em seus efeitos colaterais – ela muda seu ambiente (misturando o açúcar e o creme e batendo-os, por exemplo…) Vejamos um exemplo:Def ola (quem):     Print “olá”, quem
Ola(“mundo”)     # Mostra “ Olá mundo”

–  Diferença entre variável global e variável local – A variável global é declarada logo no inicio e serve para ser usada em qualquer função. E a variável local é declara em uma função e só pode ser usada nela.

–  tipos de classificação de variáveis…Integer, Real, Char, Boolean e String.exemplo de variável inteira(integer).varnum : Integer;

beginnum:=2;

if (3>num) then beginshowmessage(‘3 é maior que 2);

end;
exemplo de variavel REAL.

varsalario : real;

beginsalario:=965.56;

showmessage(‘seu salario é de:’+salario);

end;
exemplo de variavel Charactere(char).

varLetra : Char;

beginlatra:=’a’;

showmessage(‘A primeira letra do alfabeto é’+letra);

end;

exemplo de variavel STRING

.varmyname : String[30];

beginmyname:=’David OverCheats’;

showmessage(‘meu nome é’+myname);

end;

– Como é realizada a transmissão de informações entre um subprograma e o programa principal – A modularização consiste num método utilizado para facilitar a construção de grandes programas, através de sua divisão em pequenas etapas, que são os módulos ou subprogramas. A primeira delas, por onde começa a execução do trabalho, recebe o nome de programa principal, e as outras são os subprogramas propriamente ditos, que são executados sempre que ocorre uma chamada dos mesmos, o que é feito através da especificação de seus nomes.Há duas espécies de subprogramas: PROCEDIMENTO e FUNÇÃO. PROCEDIMENTO Um subprograma do tipo PROCEDIMENTO é, na realidade, um programa com vida própria, mas que, para ser processado, tem que ser solicitado pelo programa principal que o contém, ou por outro subprograma, ou por ele mesmo.

Declaração:PROCEDURE nome;

declaração dos objetos locais ao ProcedimentoBEGINcomandos do ProcedimentoEND;

onde: nome é o identificador associado ao procedimento.EXEMPLO de procedimentos.

Program CALCULA_MÉDIA; {sem o uso de procedimentos}

varNOTA1,NOTA2,MEDIA : real;

begin{lê as notas}write(‘Digite a primeira nota: ‘);

readln(NOTA1);

write(‘Digite a segunda nota: ‘);

readln(NOTA2);

{calcula a media}MEDIA := (NOTA1 + NOTA2) / 2;

{escreve o resultado}writeln(‘Media = ‘,MEDIA,4:1)end.o mesmo programa, utilizando um procedimento.Program CALCULA_MÉDIA;

{usando procedimento}varNOTA1,NOTA2,MEDIA : real;

{declaração do procedimento}procedure LER_NOTAS;

beginwrite(‘Digite a primeira nota: ‘);

readln(NOTA1);

write(‘Digite a segunda nota: ‘);

readln(NOTA2);

end;

{Programa Principal}

beginLER_NOTAS;

{ativação do procedimento LER_NOTAS}MEDIA := (NOTA1 + NOTA2) / 2;

{calcula a media}Writeln(‘Media = ‘,MEDIA,4:1) {escreve o resultado}end.

FUNÇÃO : As funções, embora bastante semelhantes aos procedimentos, têm acaracterística especial de retornar ao programa que as chamou um valor associado ao nome da função. Esta característica permite uma analogia com oconceito de função da Matemática.

– A diferença entre parâmetro real e parâmetro formal .: Na passagem de parâmetros por valor, as alterações feitas nos parâmetros formais, dentro do subprograma, não se refletem nos parâmetros reais. Na passagem de parâmetros por referência, a toda alteração feita num parâmetro formal corresponde a mesma alteração feita no seu parâmetro real associado.

Ex:procedure ler_dados (var x : integer); ——>isto é um parametro formal.

(o que vai ser chamado pelo parametro real);

……Beginlerdados(x); ———>isto é um parametro real.(o que chama o parametro formal)End.

[=======================================================]a passagem por valor do processamento (calculo) fica retido dentro do “procedimento ou função”, quanto que por referencia ele altera o valor real…..

Exemplo:Program EX_PASSAGEM_PARÂMETROS;

var N1,N2 : integer;
Procedure PROC(X:integer; var Y:integer);

{para a passagem ser por referencia basta colocar a palavra “VAR”…}

begin {…antes da variavel.}X:=1;Y:=1;

end;

beginN1:=0;

N2:=0;

PROC(N1,N2);

writeln(N1);

{será exibido o valor 0}writeln(N2);

(será exibido o valor 1}end.
[=======================================================]

acima pelo fato de que a variavel n2 que é representada por “Y” (que tem a passagem por referencia), é afetado o valor real…..e sendo assim tem se como resultado o valor 1.E a variavel n1 (como o calculo ficou retido dentro do procedimento) não lhe foi alterado em nada.

– Os modos de passagem de parâmetros. Ex: como funciona cada um deles.: Há dois modos de passagem de parâmetros: por valor e por variável (ou “por referência”, ou “por nome”): neste caso,deve-se colocar a palavra reservada var em frente ao nome do parâmetro.Como ativar: <identificador>(<lista de parâmetros>) A ativação de um procedimento corresponde a um comando de chamada, colocado na parte executável do programa principal (de outro procedimento ou do próprio procedimento). Os parâmetros desta lista são chamados parâmetros de chamada (ou reais “actual, ié, parameters”), e nela são colocados apenas os seus nomes. Depois de ativado, ié, depois da execução dos comandos do procedimento, a execução do programa volta ao comando seguinte (a este comando de chamada)

.Exemplos:(1)

procedure TROCA(var A,B: real);

var AUX: real;

beginAUX:=A;

A:=B;

B:=AUX;

end.

==============================

(2) program MANIPULA_VETOR_E_PROC;

type VETOR=array[1..20] of real;

var V: VETO;

N, I: integer;

procedure LE(var A:VETOR;

TAM:integer);

var I: integer;

beginfor I:=1 to TAM dobeginwrite(I,‘ºelemento:’);

readln(A[I])end;end;

procedure IMPR(A:VETOR;

TAM:integer);

var I: integer;

beginfor I:=1 to TAM do write(A[I],‘ ’)end;

procedure TROCA(var A,B: real);

 

var AUX: real;

beginAUX:=A;

A:=B;

B:=AUXend;

procedure INV(var A:VETOR; TAM:integer;

var I: integer;

beginfor I:=1 to TAM div 2 doTROCA(A[I],A[TAM-I+1])end;

begin (*Programa Principal*)repeatwrite(‘N= ’);

readln(N)until (N>0)and(N<=20);

LE(V,N);

IMPR(V,N);

INV(V,N)

;IMPR(V,N);

end.

==============================

(3) procedure LINHA(CARAC:char);

var I: intege;

beginfor I:=1 to 60 do write(CARAC);

writeln

end;

==============================

(4) procedure MENU(var OPCAO: char);

beginwriteln(‘OPÇÕES:’);

writeln(‘1 – matriz transposta’);

writeln(‘2 – imprime diagonais’);

writeln(‘3 – soma outra matriz’);

writeln(‘4 – produto por escalar’);

writeln(‘5 – fim’);

write(‘digite opção: ’);

readln(OPCAO);

end;

Observações: Deve haver uma correspondência 1-1 entre os parâmetros de chamada e os formais, que devem ser do mesmo tipo. Na passagem por valor: o parâmetro de chamada é uma expressão e o parâmetro formal é como se fosse uma variável local, cujo valor inicial é o valor corrente do parâmetro de chamada (ié, da expressão correspondente).

O procedimento pode modificar esse valor do parâmetro formal (recebido do parâmetro de chamada), não afetando o valor do parâmetro de chamada correspondente (no caso em que aquela expressão seja uma variável(!), no programa principal ou em outro lugar de onde foi feita a chamada).

O parâmetro formal não pode representar o resultado de umacomputação feita no procedimento. Na passagem por variável (ié, quando o parâmetro formal é precedido pela palavra var), o parâmetro de chamada correspondente deve ser uma variável, que será representada pelo parâmetro formal durante toda a execução do procedimento. Neste caso, qualquer alteração feita no procedimento formal provoca idêntica alteração no parâmetro de chamada correspondente. Sempre que um parâmetro representar um “resultado” do procedimento, ele deverá ser definido como um parâmetro com passagem por variável.

Recomenda-se que passagem por valor seja utilizada sempre que o parâmetro servir apenas como “entrada” Obs: há exceções. As variáveis declaradas nos procedimentos são ditas variáveis locais, e só podem ser usadas naqueles procedimentos em que estão definidas. Variáveis declaradas no programa principal são ditas variáveis globais, e podem se usadas dentro dos procedimentos. A lista de parâmetros de um procedimento pode não existir! Neste caso as referências serão apenas a objetos globais.

Exemplo:program PARM;

var A,B: integer;

procedure ESCREVE(X:integer;var Y:integer);

beginX:=X+1; Y:=Y+1;

writeln(X,Y)end;

begin (*PP*)A:=0; B:=0;

ESCREVE(A,B);

writeln(A,B)end.

Funções: Funções são procedimentos que resultam (ié, retornam) necessariamente pelo menos um valor (do tipo simples ou pointer), e são ativadas no meio de uma expressão.Como declarar:function <identificador>(<lista de parâmetros>): <tipo do resultado>;<parte de declarações>begin<lista de comandos>end;