Além de evitar problemas com variáveis globais, a
passagem de parâmetros pode tornar os
subprogramas mais genéricos, (portanto com
mais chances de serem reaproveitados):
Formaliza a comunicação entre os módulos;
Permite que um módulo seja utilizado com operandos diferentes (mesmo processamento para diferentes
entradas – reuso flexível do módulo).
Programa principal
Informa_Sabor Calc_Valor_Pizza
Modularização – Parâmetros
Na linguagem Pascal, para criar procedimentos e
funções com parâmetros, basta criar uma lista de parâmetros entre parênteses após o nome do
módulo na etapa de declaração do módulo:
procedure <nome> (lista de parâmetros formais);
Modularização – Parâmetros
A lista de parâmetros tem a seguinte forma:
Parâmetro_1: tipo; parâmetro_2: tipo; ...; parâmetro_n: tipo
Com este recurso você pode redefinir os módulos do seu
programa para que em vez de manipularem variáveis globais, utilizem parâmetros para obter os dados a ser processados:
procedure le_Dados (nome_aluno: String; n1, n2: Real);
Modularização – Parâmetros
Os identificadores dos parâmetros listados no momento em que você declara os procedimentos e as funções, podem ser qualquer nome de identificador válido, e não precisam ser exatamente o nome das variáveis que você utilizará no
programa principal.
Observe que em vez de declarar le_Dados com parâmetros:
nota1, nota2 e nome, foram inventados os parâmetros: n1, n2
e nome_aluno.
procedure le_Dados (nome_aluno: String; n1, n2: Real);
Modularização – Parâmetros
A nova definição dos módulos do seu programa fica assim:
program NOTAS; {usando um procedimento e uma função}
var
nota1,nota2: Real;
nome: String;
procedurele_Dados (nome_aluno: String; n1,n2: Real);
begin
readln(nome_aluno); readln(n1);
readln(n2);
end;
functionget_Media (v1,v2: Real): Real;
var soma: Real; begin soma := (v1 + v2); get_Media := soma /2; end;
Modularização – Escopo de variáveis
program NOTAS; {usando um procedimento e uma função}
procedurele_Dados (nome_aluno: String; n1,n2: Real);
begin
readln(nome_aluno); readln(n1);
readln(n2);
end;
functionget_Media(v1,v2: Real): Real;
var soma: Real; begin soma := (v1 + v2); get_Media := soma/ 2; end; var
nota1,nota2: Real;
nome: String;
Com o uso de parâmetros, você elimina a necessidade de utilizar variáveis globais.
Declare suas variáveis após todas as definições de módulos em seu código fonte. Isto as torna locais ao escopo do programa principal.
Modularização – Parâmetros
No momento em que você for chamar um procedimento ou a função que exige parâmetros, será necessário passar o nome de variáveis ou valores como parâmetros para o módulo:
programNOTAS;{usando um procedimento e uma função}
procedurele_Dados (nome_aluno: String; n1,n2: Real);
begin
readln(nome_aluno); readln(n1);
readln(n2);
end;
functionget_Media(v1,v2: Real): Real;
var soma: Real; begin soma := (v1+v2); get_Media := soma/2; end; var
nota1,nota2: Real;
nome: String;
begin
le_Dados(nome,nota1,nota2); writeln('O aluno ', nome, ' esta: '); if get_Media(nota1,nota2) >= 7.0 then
writeln('Aprovado') else
writeln('Prova Final');
Modularização – Parâmetros
Em relação ao local que os parâmetros aparecem
em seu código, eles são classificados em Formais
ou Reais:
Formais: inseridos na declaração do subprograma; servem para dar forma ao método e permitir que a
concretização dos valores a utilizar seja feita apenas
no momento da chamada.
Reais: listados na chamada para execução do
subprograma; são eles que realmente vão ser utilizados durante a execução do programa.
program NOTAS; {usando um procedimento e uma função}
procedurele_Dados (nome_aluno: String; n1,n2: Real);
begin
readln(nome_aluno); readln(n1);
readln(n2);
end;
functionget_Media(v1,v2: Real): Real;
var soma: Real; begin soma := (v1 + v2); get_Media := soma /2; end; var
nota1,nota2: Real;
nome: String;
begin
le_Dados(nome,nota1,nota2); writeln('O aluno ', nome, ' esta: ');
ifget_Media(nota1,nota2) >=7.0then
writeln('Aprovado')
else
writeln('Prova Final');
end.
Modularização – Parâmetros
A mesma coisa pode ser dita em relação aos parâmetros da função get_Media
Modularização – Parâmetros
A ordem e o tipo dos parâmetros é importante na lista de
parâmetros reais. ... begin le_Dados(nome,nota1,nota2); ... end. ... ... begin le_Dados(nota1,nome,nota2); ... end. ...
writeln('Media do aluno: ',get_media(nota1,nota2):5:2);
Modularização – Funções
Por algum motivo, a variável
nome está vazia e a média do
aluno foi calculada como 0 (zero).
Inserimos esta linha de código ao fim do seu programa para imprimir o valor da média do aluno “Fulano”.
Modularização – Funções
Consultando um especialista em modularização, ele informou que há um problema na declaração dos parâmetros no procedimento le_Dados.
Os parâmetros reais não receberam os valores dos parâmetros formais durante a execução do procedimento le_Dados.
Parece que nome e nome_aluno,
n1 e nota1, n2 e nota2 não se
Modularização – Parâmetros
A passagem de parâmetros pode ser por Valor
ou por Referência, em relação à maneira que os dados serão enviados ao interior dos módulos:
Por valor: as alterações feitas nos parâmetros formais, dentro do subprograma, não se refletem nos
parâmetros reais. O valor do parâmetro real é copiado no parâmetro formal, na chamada do subprograma. Assim, quando a passagem é por valor, isto significa que o parâmetro é de entrada.
Modularização – Parâmetros
Por Referência: toda alteração feita num parâmetro
formal corresponde a mesma alteração feita no seu parâmetro real associado. Assim quando a passagem é por referência, isto significa que o parâmetro é de entrada-saída.
Modularização – Parâmetros
O seu programa declara uma lista de parâmetros
para o procedimento le_Dados.
A estratégia de passagem de parâmetros que foi
utilizada é por valor.
Assim, o procedimento le_Dados recebe uma cópia
dos valores das variáveis nome, nota1 e nota2 (que inicialmente são desconhecidos, já que não foram lidos antes da chamada ao módulo), não faz nada com estes valores, usa os
parâmetros do procedimento para fazer a leitura de dados, mas não retorna com os valores que foram obtidos na leitura de dados nos parâmetros reais.
Modularização – Parâmetros
Um parâmetro passado por valor, funciona como
uma variável ou valor local para o módulo.
Sendo um elemento local, qualquer coisa feita
com os parâmetros não é visível fora do escopo
Modularização – Parâmetros
Para corrigir este problema, você deve declarar
seus parâmetros e dizer que eles serão passados por referência.
Assim, qualquer coisa que for alterada no escopo
do módulo, será transmitida imediatamente para as variáveis que foram usadas como
Modularização – Parâmetros
Declarar um parâmetro que será passado por
referência é muito simples: basta incluir a palavra reservada var antes do nome dos parâmetros que devem ser passados por referência na lista de
parâmetros formais (no local onde você define o seu módulo).
procedure le_Dados (var nome_aluno: String; var n1,n2: Real); begin
readln(nome_aluno); readln(n1);
readln(n2);
end;