É uma metodologia para projetar programas como um conjunto de unidades individuais inter-relacionadas (sub-programas ou módulos).
É uma metodologia para projetar programas como um conjunto de unidades individuais inter-relacionadas (sub-programas ou módulos). A decomposição em módulos será uma estratégia fundamental no desenvolvimento de programas de médio/grande porte.
VANTAGENS DA MODULARIZAÇÃO: Qualidade dos Programas A solução de um problema é buscada através da combinação das soluções de subproblemas (menos complexos).
VANTAGENS DA MODULARIZAÇÃO: Qualidade dos Programas Um módulo que realiza uma função simples e bem definida pode ser facilmente compreendido.
VANTAGENS DA MODULARIZAÇÃO: Qualidade dos Programas Um módulo que realiza uma função simples e bem definida pode ser facilmente compreendido. A atenção do programador se concentra nos detalhes da lógica de cada parte do programa isoladamente.
VANTAGENS DA MODULARIZAÇÃO: Qualidade dos Programas Um módulo que realiza uma função simples e bem definida pode ser facilmente compreendido. A atenção do programador se concentra nos detalhes da lógica de cada parte do programa isoladamente. ABSTRAÇÃO
VANTAGENS DA MODULARIZAÇÃO: Flexibilidade no desenvolvimento Como o programa é dividido em módulos individuais, tem-se maior flexibilidade na alocação de recursos e pessoal para o desenvolvimento.
VANTAGENS DA MODULARIZAÇÃO: Padronização e reuso Quando se escreve uma série de programas, é comum que certas funções sejam necessárias em mais de um
VANTAGENS DA MODULARIZAÇÃO: Padronização e reuso Quando se escreve uma série de programas, é comum que certas funções sejam necessárias em mais de um A existência da uma biblioteca de funções evitará grande parte da repetição e garantirá padronização.
VANTAGENS DA MODULARIZAÇÃO: Planejamento Quando se trabalha com pequenas unidades, pode-se estimar com certa precisão a quantidade de trabalho envolvido.
VANTAGENS DA MODULARIZAÇÃO: Planejamento Quando se trabalha com pequenas unidades, pode-se estimar com certa precisão a quantidade de trabalho envolvido. Isto possibilita um melhor planejamento de recursos, prazos, etc.
VANTAGENS DA MODULARIZAÇÃO: Manutenção Os problemas de manutenção são reduzidos. É mais fácil entender um módulo do sistema (e alterá-lo) do que tentar entender o sistema como um todo.
OBS: A técnica de modularização é empregada em vários ramos de desenvolvimento, como uma forma de lidar com a complexidade.
OBS: A técnica de modularização é empregada em vários ramos de desenvolvimento, como uma forma de lidar com a complexidade. Ex1: não há um fabricante de computador. Há fabricantes de discos rígidos, de processadores, etc.
OBS: A técnica de modularização é empregada em vários ramos de desenvolvimento, como uma forma de lidar com a complexidade. Ex2: não há um fabricante de carros. Há montadoras que encomendam de terceiros motor, câmbio, pneus, condicionador de ar, etc.
OBS: Um módulo pode ser decomposto em outros mais simples. Por exemplo, o fabricante de motor pode terceirizar a fabricação das velas de ignição, pistons, etc.
OBS: Um módulo pode ser decomposto em outros mais simples. Por exemplo, o fabricante de motor pode terceirizar a fabricação das velas de ignição, pistons, etc. Ou seja, para produção de objetos muito complexos, haverá um processo de decomposição sucessiva
RECOMENDAÇÃO BÁSICA Os módulos devem resolver uma tarefa (ou função) muito bem definida.
RECOMENDAÇÃO BÁSICA Os módulos devem resolver uma tarefa (ou função) muito bem definida. Dica prática: deve-se poder dizer o que um módulo faz em poucas palavras (sem uso de ou, se, etc.)
RECOMENDAÇÃO BÁSICA Os módulos devem resolver uma tarefa (ou função) muito bem definida. Dica prática: deve-se poder dizer o que um módulo faz em poucas palavras (sem uso de ou, se, etc.) Ex: Calcula o fatorial de um número Ordena um vetor de forma ascendente
TIPOS DE MÓDULOS Procedimento: realiza uma tarefa. Ao final não há retorno de valores ao módulo que o ativou.
TIPOS DE MÓDULOS Procedimento: realiza uma tarefa. Ao final não há retorno de valores ao módulo que o ativou. Função: realiza algum processamento e retorna uma única informação de saída.
TIPOS DE MÓDULOS Procedimento: realiza uma tarefa. Ao final não há retorno de valores ao módulo que o ativou. Função: realiza algum processamento e retorna uma única informação de saída. OBS: Funções possuem um tipo associado, que é o tipo da informação que será retornada.
TIPOS DE MÓDULOS Procedimento: realiza uma tarefa. Ao final não há retorno de valores ao módulo que o ativou. Função: realiza algum processamento e retorna uma única informação de saída. OBS: Funções possuem um tipo associado, que é o tipo da informação que será retornada. Funções e procedimentos podem receber informações de entrada (parâmetros).
EXEMPLOS: FUNÇÕES A := round(1.5); write(ln(num)); S := concat('abc','def'); S2 := copy(s,2,3);
EXEMPLOS: FUNÇÕES A := round(1.5); write(ln(num)); S := concat('abc','def'); S2 := copy(s,2,3); PROCEDIMENTOS ordenavet(v); insert(s1,s2,5); delete(s, 5,2); inc(x);
EXEMPLOS: FUNÇÕES A := round(1.5); write(ln(num)); S := concat('abc','def'); S2 := copy(s,2,3); PROCEDIMENTOS ordenavet(v); insert(s1,s2,5); delete(s, 5,2); inc(x); Obs: uma função é um tipo de expressão: produz um resultado, que deve ter algum destino.
EXEMPLOS: FUNÇÕES A := round(1.5); write(ln(num)); S := concat('abc','def'); S2 := copy(s,2,3); PROCEDIMENTOS ordenavet(v); insert(s1,s2,5); delete(s, 5,2); inc(x); já um procedimento é empregadona forma de comando.
PROCEDIMENTOS (sintaxe Pascal): procedure <nome> (<list_parâm>); <iáveis locais> comando 1; comando 2;.. comando n
FUNÇÕES (sintaxe Pascal): function <nome>(<list_parâm>):<tipo_ret>; < iáveis locais > comando 1; comando 2;..
FUNÇÕES (sintaxe Pascal): function <nome>(<list_parâm>):<tipo_ret>; < iáveis locais > comando 1; comando 2;.. OBS: toda função deverá ter (pelo menos) uma atribuição para o seu nome, com o que se produz o retorno de um valor.
FUNÇÕES (sintaxe Pascal): function <nome>(<list_parâm>):<tipo_ret>; < iáveis locais > comando 1; comando 2;.. OBS: toda função deverá ter (pelo menos) uma atribuição para o seu nome, com o que se produz o retorno de um valor. se houver mais de uma atribuição, a segunda anula a primeira e assim sucessivamente.
OBS: A execução de um módulo é ativada pela referência ao seu nome.
OBS: A execução de um módulo é ativada pela referência ao seu nome. Quando for encontrada uma chamada, o módulo em execução será suspenso, e o controle será passado ao módulo chamado.
OBS: A execução de um módulo é ativada pela referência ao seu nome. Quando for encontrada uma chamada, o módulo em execução será suspenso, e o controle será passado ao módulo chamado. Após a execução, ocorrerá o retorno do controle para o comando imediatamente após a chamada.
ESCOPO E TEMPO DE VIDA Escopo de uma iável é a área do programa onde ela pode ser legalmente referenciada.
Quanto ao escopo, as iáveis podem ser: Globais: São declaradas fora de qualquer módulo, e podem ser referenciadas em qualquer parte do programa
Quanto ao escopo, as iáveis podem ser: Globais: São declaradas fora de qualquer módulo, e podem ser referenciadas em qualquer parte do programa exceto naqueles módulos onde for declarada outra iável com o mesmo nome.
Quanto ao escopo, as iáveis podem ser: Globais: São declaradas fora de qualquer módulo, e podem ser referenciadas em qualquer parte do programa exceto naqueles módulos onde for declarada outra iável com o mesmo nome. Locais: Só existem dentro do módulo onde foram declaradas.
program local_global; x1,x2:integer; procedure P() y1, y2, x2: real; procedure Q() z,y1: integer; {principal} end.
program local_global; x1,x2:integer; GLOBAIS procedure P() y1, y2, x2: real; procedure Q() z,y1: integer; LOCAIS {principal} end.
program local_global; x1,x2:integer; procedure P() y1, y2, x2: real; procedure Q() z,y1: integer; a iável global X2 não estará acessível em P(); {principal} end.
Tempo de vida de uma iável é o intervalo de tempo desde a sua criação (alocação de espaço) até a sua destruição.
Tempo de vida de uma iável é o intervalo de tempo desde a sua criação (alocação de espaço) até a sua destruição. - O tempo de vida de uma iável global é o tempo total de execução de um programa.
Tempo de vida de uma iável é o intervalo de tempo desde a sua criação (alocação de espaço) até a sua destruição. - O tempo de vida de uma iável global é o tempo total de execução de um programa. - Já o de uma iável local é o período durante o qual está ativo o módulo a que ela pertence.
Tempo de vida de uma iável é o intervalo de tempo desde a sua criação (alocação de espaço) até a sua destruição. - O tempo de vida de uma iável global é o tempo total de execução de um programa. - Já o de uma iável local é o período durante o qual está ativo o módulo a que ela pertence. O conteúdo de uma iável local se perde após o encerramento do módulo onde ela está declarada.
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end.
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. o módulo principal chama P() g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. P(), por sua vez, chama Q() y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. z y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; retorno procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. z y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. retorno y1, y2 g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. Ativação direta de Q() g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. z g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; retorno procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. z g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. encerramento. g, x1, x2 VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. VARIÁVEIS ALOCADAS
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; Note que a alocação funcionou em um esquema de PILHA procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end.
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); Note que a alocação funcionou em um esquema de PILHA em uma pilha (de pratos, por exemplo) o último adicionado será o primeiro a sair. {principal} P(); Q(); end.
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end. Note que a alocação funcionou em um esquema de PILHA em uma pilha (de pratos, por exemplo) o último adicionado será o primeiro a sair. Isso porque um módulo sempre encerra antes daquele que o chamou.
program local_global; g: integer; x1,x2: real; procedure Q(); z: integer; ALOCAÇÃO EM FUNÇÃO DO TEMPO procedure P(); y1: real; y2: integer; Q(); {principal} P(); Q(); end.
PARÂMETROS E ARGUMENTOS Observe o código abaixo: v: array[1..100] of integer; function Soma( ): LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S;
PARÂMETROS E ARGUMENTOS Observe o código abaixo: v: array[1..100] of integer; function Soma( ): LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; A função Soma sempre calculará a soma dos elementos de um vetor em particular v (global).
PARÂMETROS E ARGUMENTOS Observe o código abaixo: v: array[1..100] of integer; function Soma( ): LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; A função Soma sempre calculará a soma dos elementos de um vetor em particular v (global). a utilidade da função, portanto, é bastante limitada!
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1);
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); Agora Soma possui um parâmetro v e o processamento interno será feito sobre ele.
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); v será alocado de forma similar a uma iável local (na ativação do módulo).
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); v será alocado de forma similar a uma iável local (na ativação do módulo). Em seguida, v receberá uma cópia de v1.
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); v será alocado de forma similar a uma iável local (na ativação do módulo). Em seguida, v receberá uma cópia de v1. Assim, o valor retornado será a soma dos valores de v1 (v é apenas um suporte
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); Na chamada foi passado v1, assim como poderia ter sido passado v2, ou outro vetor qualquer de mesmo tipo.
PARÂMETROS E ARGUMENTOS Acrescentando um parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; function Soma(v:Vetor ):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to 100 do s := s + v[i]; Soma := S; tot := Soma(v1); Na chamada foi passado v1, assim como poderia ter sido passado v2, ou outro vetor qualquer de mesmo tipo. Isso amplia a utilidade da função. Ele se tornou mais amplamente aplicável!
PARÂMETROS E ARGUMENTOS Acrescentando um novo parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; tam: byte; function Soma(v:Vetor,n:byte):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to n do s := s + v[i]; Soma := S; tot := Soma(v1,tam);
PARÂMETROS E ARGUMENTOS Acrescentando um novo parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; tam: byte; function Soma(v:Vetor,n:byte):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to n do s := s + v[i]; Soma := S; tot := Soma(v1,tam); Um novo parâmetro (n) determinará até onde a soma deverá ser feita
PARÂMETROS E ARGUMENTOS Acrescentando um novo parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; tam: byte; function Soma(v:Vetor,n:byte):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to n do s := s + v[i]; Soma := S; tot := Soma(v1,tam); Um novo parâmetro (n) determinará até onde a soma deverá ser feita Isso confere maior flexibilidade ainda à função!
PARÂMETROS E ARGUMENTOS Acrescentando um novo parâmetro type Vetor = array[1..100] of integer; v1,v2:vetor; tam: byte; function Soma(v:Vetor,n:byte):LongInt; i: byte; s: LongInt; s := 0; for i = 1 to n do s := s + v[i]; Soma := S; tot := Soma(v1,tam); assim, parâmetros são fundamentais para a comunicação entre módulos, com aumento significativo de sua aplicabilidade!!
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Argumento é o valor que será passado para o módulo Parâmetro real é uma expressão que produzirá o argumento. Parâmetro formal é um identificador pelo qual o módulo terá acesso ao argumento.
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2);
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2); A expressão n1+n2 constitui o parâmetro real
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2); A expressão n1+n2 constitui o parâmetro real O valor produzido e que será efetivamente passado (5) é o argumento.
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2); A expressão n1+n2 constitui o parâmetro real O valor produzido e que será efetivamente passado (5) é o argumento. n é o parâmetro formal: um suporte para o acesso ao argumento.
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2); OBS: deve haver correspondência entre os parâmetros formais e reais quanto a: número tipo de dados posição entre eles
PARÂMETROS FORMAIS, REAIS E ARGUMENTOS Considere o exemplo n1,n2,dbr: byte; function Dobro(n:byte):byte; Dobro := 2 * n; n1:= 2; n2:= 3; dbr := Dobro(n1+n2); OBS: deve haver correspondência entre os parâmetros formais e reais quanto a: número tipo de dados posição entre eles Observe que n1+n2 é apenas um parâmetro (uma única expressão), embora possua duas iáveis.
TIPOS DE PASSAGEM DE PARÂMETRO Por valor: é a forma de passagem presente nos exemplos já apresentados:
TIPOS DE PASSAGEM DE PARÂMETRO Por valor: é a forma de passagem presente nos exemplos já apresentados: - o argumento é copiado no parâmetro formal.
TIPOS DE PASSAGEM DE PARÂMETRO Por valor: é a forma de passagem presente nos exemplos já apresentados: - o argumento é copiado no parâmetro formal. - eventuais alterações internas no conteúdo do parâmetro formal (apenas uma cópia) não acarretarão qualquer mudança de valor no parâmetro real.
TIPOS DE PASSAGEM DE PARÂMETRO Por referência: o parâmetro formal é uma referência para o argumento. assim, todas as alterações de conteúdo via parâmetro formal, na realidade surtirão efeito diretamente no argumento.
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x);
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); O termo na declaração do parâmetro, designa passagem por referência
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO x
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO x
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO x 2
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO n x 2
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); n não guarda uma cópia de x, mas é uma (nova) forma de referenciar o objeto identificado por x SIMULANDO n x 2
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO n x 2
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO n x 4
TIPOS DE PASSAGEM DE PARÂMETRO Exemplo: x: byte; Procedure Dobrar( n:byte):byte; n := 2 * n; x := 2; Dobrar(x); SIMULANDO n x 4
OBS: A passagem de parâmetro por referência será necessária sempre que se quiser que ações internas ao módulo (feitas sobre o parâmetro formal) produzam efeitos diretos no argumento (e não em uma cópia).
OBS: A passagem de parâmetro por referência será necessária sempre que se quiser que ações internas ao módulo (feitas sobre o parâmetro formal) produzam efeitos diretos no argumento (e não em uma cópia). Ex:... vet: Vetor; procedure OrdenaVetor( v: Vetor);...... OrdenaVetor(vet);...
OBS: A passagem de parâmetro por referência será necessária sempre que se quiser que ações internas ao módulo (feitas sobre o parâmetro formal) produzam efeitos diretos no argumento (e não em uma cópia). Ex:... vet: Vetor; procedure OrdenaVetor( v: Vetor);...... OrdenaVetor(vet);... o que se pretende é ordenar o vetor vet e não uma cópia (que iria desaparecer com o fim da execução do módulo!)
Já neste caso Ex:... vet: Vetor; r: LongInt; function SomaElem(v: Vetor);...... r := SomaElem(vet);...
Já neste caso Ex:... vet: Vetor; r: LongInt; function SomaElem(v: Vetor);...... r := SomaElem(vet);... Nenhuma alteração precisa ser produzida no conteúdo de vet portanto, a passagem deve ser por valor.
Já neste caso Ex:... vet: Vetor; r: LongInt; function SomaElem(v: Vetor);...... r := SomaElem(vet);... O termo não é empregado Nenhuma alteração precisa ser produzida no conteúdo de vet portanto, a passagem deve ser por valor.