Linguagens de Programação II

1) Módulos de Programas

• Vantagens de se dividir programas grandes em módulos

• Linguagens funcionais permitem a divisão em funções

• Linguagens orientadas por objetos permitem classes

• Analisaremos agora duas formas de se modularizar um programa (procedimento e função)

• Técnica empregada:

• “agrupar alguns passos do algoritmo para formar pequenas porções do algoritmo global”

• “transformar o agrupamento numa ferramenta abstrata, com um identificador próprio”

• O resultado destes agrupamentos é a criação de subprogramas, chamadas de procedimentos ou comandos

1.1) Procedimento (ou Comando)

• É um módulo de programa independente do programa principal, associado a ele por meio de um processo de transferência e retorno de controle (Fig. 5.10)

• O processo de transferir o controle de execução para um comando é denominado de “chamada do procedimento”

• Um procedimento pode ser visto como um programa em miniatura, o qual é identificado através de um nome

• A definição de um procedimento consiste em:

1. cabeçalho, onde se define o identificador do comando (e os parâmetros do procedimento)

2. corpo do procedimento, onde podem ser definidas as variáveis locais e as instruções que farão parte do procedimento.

• Para o programador usar um procedimento, a partir do programa principal, ele deve fazer o seguinte:

1. Fortran: usar o termo CALL e o nome do procedimento

2. Ada, C, Pascal, Java, C++: basta usar o identificador do procedimento

1.2) Parâmetros

• Uso de variáveis globais não é uma técnica recomendável, especialmente em programas grandes

• Um procedimento poderia efetuar uma mesma computação, várias vezes, e possivelmente com diferentes valores para certas variáveis, o que tornaria o procedimento mais útil

• Exemplo dividido em quatro partes:

Define a,b,c,delta,x1,x2 como reais

Define sai_fora como caracter

(1a.Parte)

bloco_principal

faz

apresentacao

Repete

Escreve(“Digite a: ”); Lê(a)

Escreve(“Digite b: ”); Lê(b)

Escreve(“Digite c: ”); Lê(c)

delta:= b*b – 4*a*c

Se delta >= 0 então

x1:= (-b + sqrt(delta) )/2*a

x2:= (-b + sqrt(delta) )/2*a

fim

Escreve(“1a.raiz= ”); Escreve(x1)

Escreve(“2a.raiz= ”); Escreve(x2)

Escreve(“Quer de novo?(s/n)”)

Lê(sai_fora)

Até_que sai_fora = ‘s’

Escreve(“Tchau!”)

fim

Define a,b,c,delta,x1,x2 como reais

Define sai_fora como caracter

(2a.Parte)

bloco_principal

começa

apresentacao

Repete

Escreve(“Digite a: ”); Lê(a)

Escreve(“Digite b: ”); Lê(b)

Escreve(“Digite c: ”); Lê(c)

calcula_raizes

Escreve(“1a.raiz= ”); Escreve(x1)

Escreve(“2a.raiz= ”); Escreve(x2)

Escreve(“Quer de novo?(s/n)”)

Lê(sai_fora)

Até_que sai_fora = ‘s’

Escreve(“Tchau!”)

termina

calcula_raizes

faz

delta:= b*b – 4*a*c

Se delta >= 0 então

x1:= (-b + sqrt(delta) )/2*a

x2:= (-b + sqrt(delta) )/2*a

fim

fim

Define a,b,c,x1,x2 como reais

Define sai_fora como caracter

(3a.Parte)

bloco_principal

começa

apresentacao

Repete

Escreve(“Digite a: ”); Lê(a)

Escreve(“Digite b: ”); Lê(b)

Escreve(“Digite c: ”); Lê(c)

calcula_raizes(a,b,c,x1,x2)

Escreve(“1a.raiz= ”); Escreve(x1)

Escreve(“2a.raiz= ”); Escreve(x2)

Escreve(“Quer de novo?(s/n)”)

Lê(sai_fora)

Até_que sai_fora = ‘s’

Escreve(“Tchau!”)

termina

calcula_raizes(define i,j,k,r1,r2 como reais)

Define variável local delta como real

faz

delta:= j*j – 4*i*k

Se delta >= 0 então

r1:= (-j + sqrt(delta) )/2*i

r2:= (-j + sqrt(delta) )/2*i

fim

fim

Define a,b,c,x1,x2 como reais

Define sai_fora como caracter

(4a.Parte)

bloco_principal

começa

apresentacao

Repete

Lê_parâmetros(a,b,c)

calcula_raizes(a,b,c,x1,x2)

Mostra_raizes(x1,x2)

Escreve(“Quer de novo?(s/n)”)

Lê(sai_fora)

Até_que sai_fora = ‘s’

Escreve(“Tchau!”)

termina

calcula_raizes(define i,j,k,r1,r2 como reais)

Define variável local delta como real

faz

delta:= j*j – 4*i*k

Se delta >= 0 então

r1:= (-j + sqrt(delta) )/2*i

r2:= (-j + sqrt(delta) )/2*i

fim

fim

Lê_parâmetros(define w,y,z como reais)

faz

Escreve(“Digite a: ”); Lê(a)

Escreve(“Digite b: ”); Lê(b)

Escreve(“Digite c: ”); Lê(c)

fim

Mostra_raizes(define raiz1,raiz2 como reais)

faz

Escreve(“1a.raiz= ”); Escreve(x1)

Escreve(“2a.raiz= ”); Escreve(x2)

fim

• Parâmetros podem ser de ‘entrada’, de ‘saída’, ou de ‘entrada/saída’ ao mesmo tempo

• Quando as linguagens têm mais de uma opção, elas dão ao programador a possibilidade de escolha de alguma forma

• Exemplo em ADA:

procedure Maior(i,j:in INTEGER; k:out INTEGER) is

do

if i < j then k:=j

else k:=i

end Maior;

. . . (outras definições não mostradas aqui)

bloco_principal is

do

Maior(Num1,Num2,L);

...

Maior(40,30,M);

Maior(X+Y,Z-10,L);

end.

• Portanto: os parâmetros aumentam em muito o poder de computação dos procedimentos, pois eles podem então ser usados inúmeras vezes e para diferentes valores, a cada vez

• Conceitos básicos:

1. parâmetro formal  identificador do parâmetro, que é definido no cabeçalho do procedimento

2. argumento  valor que é de fato passado para o parâmetro formal

3. parâmetro corrente  é o parâmetro utilizado para passar um certo argumento para o procedimento

2.3) Função

• Quando o objetivo de um módulo do programa (ou subprograma) é a obtenção de um valor, o módulo pode ser implementado como uma função

• Exemplos:

1. Obtenção de um valor absoluto (módulo): ABS(-1.5)

2. Obtenção do maior de dois números: Maior(a,b)

• O valor calculado pela função é associado ao identificador (nome) da função; Toda vez que for feita uma chamada da função, ela retornará um valor

• Exemplos:

• Escreva(“Maior:”); Escreva( Maior(4.1,6.7) )

• delta:= calcula_delta(a,b,c)

• menor:= acha_o_menor( vetor_reais )

• resultado:= cubo(x)