apontamentos de programação e algoritmia - esta.ipt.pt · note-se que no algoritmo estruturamos...
TRANSCRIPT
Apontamentos de
Programação e Algoritmia
(Fluxogramas e Pseudo-Código)
Escola Superior de Tecnologia de Abrantes
Engº. Carlos Mora
Ano Lectivo 2007/2008
(Adaptação 2007 - Engº Sérgio Rodrigues)
2
Índice
Apontamentos de ................................................................................................................ 1
Programação e Algoritmia .................................................................................................. 1
(Fluxogramas e Pseudo-Código) ......................................................................................... 1
Índice .............................................................................................................................. 2
Fluxogramas .................................................................................................................... 4
Exemplos de Fluxogramas .............................................................................................. 7
Exemplo Fluxograma 1 – Máquina de Cálcular Simples ........................................... 7
Exemplo Fluxograma 2 – Máquina de Cálcular ......................................................... 8
Exemplo Fluxograma 3 – Cálculo de um Factorial .................................................. 10
Pseudo-Código .............................................................................................................. 13
Primitivas .................................................................................................................. 13
Tipos de Variáveis .................................................................................................... 15
Arrays ........................................................................................................................ 16
Operadores ................................................................................................................ 17
Exemplos de Pseudo-Código ........................................................................................ 19
Exemplo Pseudo-Código 1 – Máquina de Cálcular .................................................. 19
Exemplo Pseudo-Código 2 – Cálculo de um Factorial ............................................. 23
Complementos Avançados de Pseudo-Código ............................................................. 26
Literais ...................................................................................................................... 26
Nomenclatura de Variáveis, Constantes e Funções .................................................. 27
Regras de Escopo ...................................................................................................... 28
Parâmetros ................................................................................................................ 30
3
4
Fluxogramas
Uma das mais divulgadas ferramentas para a definição de algoritmos são os fluxogramas.
Um fluxograma é uma representação gráfica do algoritmo, que recorrendo a um conjunto
de primitivas simples permitem pela sua interacção a definição de algoritmos complexos.
Sendo uma ferramenta gráfica e com poucas primitivas – pelo menos o conjunto
utilizado nesta cadeira – o fluxograma não é a ferramenta indicada para a definição
exuastiva do algoritmo, sendo esta inadequação tanto mais notória quanto mais complexo
é o algoritmo a representar.
Contudo, o algoritmo é perfeitamente adequado à especificação do algoritmo nos seus
níveis mais abastractos, recorrendo-se posteriormente a outras ferramentas, ou formas de
representação, logo que se inicia a especialização dos passos mais complexos do
algoritmo.
As primitivas utilizadas no âmbito desta cadeira são as seguintes:
Inicio de fluxograma
Esta primitiva possibilita a identificação do primeiro estado
do algoritmo, i.e. do seu ponto inicial de execução.
Em cada fluxograma só poderá existir uma destas
primitivas.
acção Estado com Espera
Sendo o fluxograma composto por uma sequência de
estados, este estado representa um dos passos do algoritmo,
onde é efectuada uma determinada acção, em que existe um
compasso de espera, por exemplo quando se tem de
5
recolher uma informação do utilizador ou aguardar que um
dado processamento termine.
Acção Estado sem Espera
Estado que representa um passo do algoritmo, onde é
efectuada uma determinada acção, onde não existe qualquer
compasso de espera.
CondiçãoN S
Decisão
Esta é uma das primitivas mais importantes, sendo aquela
que nos permite controlar a sequência de fluxo dentro do
fluxograma. Basicamente esta primitiva permite a
representação de uma decisão controlada pela condição
inserida dentro do losangolo e que pelo resultado da
condição – verdadeiro ou falso – encaminha o fluxo para
um dos ramos da decisão.
Ácerca desta primitiva será de realçar que não se define à
partida qual o ramo que está à direita e qual o que está à
esquerda, no entanto irá considerar-se incorrecto que no
mesmo fluxograma se representem decisões com misturas
de ramos, i.e. com, por exemplo, o Verdadeiro umas vezes
à direita e outras à esquerda.
Iremos ainda considerar que será possivel a representação
de uma decisão com mais do que dois ramos de saida, por
exemplo quando a condição fôr Qual o tipo pretendido ? e
as possibilidades (e consequentemente os ramos de saida
forem A, B, C e D).
6
Fluxo
Esta primitiva representa a direcção de fluxo no algoritmo,
ligando por consequência os diversos estados do diagrama
num conjunto coerente que represente o algoritmo
pretendido.
Iremos considerar que um estado pode ter vários fluxos de
entrada mas um único fluxo de saida. A única primitiva que
pode ter vários fluxos de saida é a Decisão, contudo e pelo
resultado da condição inserida na Decisão só um dos fluxos
de saida poderá, em cada momento, ser eleito para a
prossecução do algoritmo.
Fim de Fluxograma
Esta primitiva possibilita a identificação do último estado
do algoritmo, i.e. do seu ponto final de execução
Iremos considerar que poderão existir mais do que uma
destas primitivas, por fluxograma, sempre que por
conveniência de representação seja necessária a sua
utilização.
n Elemento de Ligação
Esta primitiva é utilizada para “ligar” fluxos do fluxograma
sempre que por conveniência de representação a sua
utilização seja necessária.
O “n” assumirá o valor 1, 2, 3, etc, uma única vez em cada
fluxograma.
7
Exemplos de Fluxogramas
Nas próximas páginas apresentam-se alguns enunciados de problemas muito simples,
com finalidades e objectivos didáticos próprios, sendo seguidamente apresentada uma
das suas possíveis soluções recorrendo a fluxogramas.
Note-se que foi colocado enfase no facto de a solução apresentada ser uma das possíveis
soluções e não a solução.
Efectivamente, não se pode dizer que exista em termos da análise de um sistema, uma
solução correcta. Aquilo que se poderá quando muito afirmar é que dada uma
determinada caracteristica de um sistema – desempenho, fiabilidade, robustez,
ergonomia, portabilidade, reusabilidade, etc - uma dada solução algoritmica, será mais
ou menos adequada à optimização dessa caracteristica, podendo ser totalmente
inadequada quando a avaliação é feita tendo em linha de conta outra caracteristica.
Feita esta reserva vamos passar aos exemplos.
Exemplo Fluxograma 1 – Máquina de Cálcular Simples
Pretende-se desenvolver um programa para a realização das operações
aritméticas simples de adição, subtração, multiplicação e divisão.
De uma forma mais ou menos imediata poderiamos considerar como uma solução
o seguinte algoritmo:
8
Recolha 1º Operando
Recolha do operador
Recolha do 2º operando
Efectuar
Cálculo
Apresentar
Resultado
Note-se que no algoritmo estruturamos os dois estados de “Efectuar Cálculo” e
“Apresentar Resultado”, mas não os especificamos ao nível de, por exemplo,
como é que dado um determinado operador, efectuamos o cálculo. Essa
especialização seria efectuada num nível mais detalhado deste fluxograma, ou
melhor ainda recorrendo a outra ferramenta de especificação - a Pseudo-
Linguagem - que iremos ver à frente.
Exemplo Fluxograma 2 – Máquina de Cálcular
Pretende-se desenvolver um programa para a realização de operações
aritméticas.
Uma vez que neste enunciado não são referidas quais as operações a efectuar
teremos de considerar, no nosso algoritmo a possibilidade de que certas
9
operações, por exemplo, o elevar ao quadrado só possui um operador, assim
sendo, o nosso algoritmo seria:
Recolha 1º operando
Efectuar
Cálculo
Recolha do operador
Operador
tem 2º
Operando
Recolha do 2º operando
Deseja
Sair
Apresentar
Resultado
N S
N S
Colocam-se neste algoritmo os mesmos comentários que no anterior,
acrescentando-se ainda outro. Não é definido neste algoritmo, como é que o
conhecimento sobre o número de operandos de cada operador é obtido. Esta
10
informação teria de ser estruturada e definida, mais uma vez, numa fase mais
detalhada do algoritmo.
Exemplo Fluxograma 3 – Cálculo de um Factorial
Pretende-se desenvolver um programa que dado um determinado número cálcule
o seu factorial F = N! = N x (N-1) x (N-2) x … x (N-(N-1))
O factorial de um número é obtido pela sucessiva multiplicação do número por
ele próprio diminuido de uma unidade, até atingir a unidade.
É definição corrente matemática que um factorial só pode ser cálculado para
números inteiros positivos, o que não sendo explicito no enunciado condiciona o
nosso algoritmo a nível da validação dos dados.
Assim teriamos:
11
N SNº menor
ou igual
a zero
Inicializar
Resultado a 1
Recolha do NºInteiro Pretendido
msg erro
Igualar resultado ao
produto de resultado
com o númerointroduzido
Diminuir 1 ao Nº
Nº é 1
Apresentar
Resultado
N S
O algoritmo foi apresentado colocando como descrição das acções frases em
português corrente que as descrevem, vamos no entanto reescrever o algorimo
utilizando uma forma mais resumida de representação das acções.
12
X < = 0
X = X - 1
Recolher X
msg erro
R = 1
R = R * X
X = 1
Apresentar R
N S
N S
13
Pseudo-Código
O pesudo-código ou pseudo-linguagem é uma ferramental textual para a representação de
algoritmos. Possuindo uma sintaxe própria muito simples, a pseudo-linguagem permite a
representação de um algoritmo no seu nível mais abstracto, ou inversamente no seu nível
mais detalhado, sendo adequada à especialização de algoritmos previamente
representados em ferramentas gráficas, por exemplo com fluxogramas.
Existindo uma equivalência entre estas duas ferramentas, pode-se com um trabalho
mínimo traduzir um algorimo em fluxograma para pseudo-código e vice-versa.
Primitivas
As primitivas utilizadas no âmbito desta cadeira são:
START
Identificação do ponto inicial do nosso algoritmo.
END
Identificação do ponto final do nosso algoritmo.
INPUT <string>, <variável>
Primitiva para a recolha de dados do utilizador.
OUTPUT <string>, <expressão>
Primitiva para a apresentação de dados ao utilizador.
<variável> <expressão>
Atribuição do resultado da expressão à variável indicada
14
IF <condição>
THEN
<instruções a executar se condição verdadeira>
ELSE
<instruções a executar se condição false>
END IF
Primitiva de controlo de fluxo equivalente à Decisão dos
fluxogramas.
WHILE <condição>
<instruções a executar enquanto a condição for
verdadeira>
END WHILE
Primitiva de controlo de fluxo, sem equivalência directa em
fluxogramas, que implementa um ciclo executado enquanto a
condição referida for verdadeira.
FOR <condição inicial> TO <condição final> [STEP <incremento>]
<instruções a executar enquanto a condição final for
falsa>
END FOR
Primitiva de controlo de fluxo, que executa as instruções nela
contidas enquanto a condição final for falsa. O incremento pode
ser omitido desde que seja unitário positivo.
FUNCTION <nome da função> (<parâmetros da função>)
<instruções da função>
[RETURN <variavel>]
END FUNCTION
Primitiva utilizada na definição de funções. Por parâmetros
entende-se uma lista de variáveis ou constantes “passadas” para
dentro da função. Em certas situações como veremos mais à
15
frente os parâmetros podem ser utilizados para a função exportar
valores.
CALL <nome da função> (<parâmetros da função>)
Primitiva utilizada para executar funções definidas com a
primitiva anterior.
VAR <tipo da variável> <nome da variável> [,]
Primitiva utilizada na definição de variáveis. Os tipos de variáveis
são definidos à frente.
CONST <tipo da constante> <nome da constante> = <valor da
constante>[,]
Primitiva utilziada na definição de constantes. Os tipos de
constantes são definidos à frente.
STRUCT <nome da variável> <tipo da variável>[,]
[<nome da variável> <tipo da variável>]
END STRUCT
Primitiva utilizada na definição de estruturas de variáveis. Os
tipos de variáveis são definidos à frente.
Tipos de Variáveis
Entre os vários tipos de variáveis que podem ser definidos no pseudo código, teremos:
INTEGER inteiro
DECIMAL(n,m) decimal com n digitos dos quais m à direita
da virgual, por exemplo DECIMAL(4,1)
poderá representar números do tipo com
valores entre –999,9 e +999,9
16
DATE data com qualquer formato, por exemplo
yyyy-MM-dd
TIME hora com qualquer formato, por exemplo
hh:mm:ss
STRING(n) cadeia de caractéres com comprimento n
maior que 0, um caso particular será o
STRING(1)
CHAR letra, correspondente a STRING(1)
LONG STRING cadeia de caractéres sem comprimento
definido
BOOLEAN dado só com duas ocorrências, verdadeiro
(TRUE) e falso (FALSE)
POINTER tipo especial de variável que é utilizado para
apontar para outras variáveis, tipicamente
utilizado nas listas e árvores
Arrays
Adicionalmente existe ainda a possibilidade de definir arrays de qualquer um dos tipos a
notação uni ou multidimensional é dada por um número inteiro positivo entre parentesis
rectos a seguir ao nome da variável. Podem-se ainda definir dimensões dinâmicas, i.e.
sem tamanho fixo, colocando um * no lugar do número indicador da dimensão. Por
exemplo poderemos ter:
VAR Vector[10] INTEGER,
Matriz[10][20] DECIMAL(5,2),
Nomes[*] STRING(200)
17
Foram assim definidos um array unidimensional de inteiros com tamanho 10 chamado
Vector, um array de decimais, bidimensional com 10 linhas e 20 colunas (ou 20 linhas e
10 colunas tudo depende do significado de cada uma das dimensões), chamado Matriz e
um array de 200 caractéres de comprimento (em cada célula), com tamanho indefinido,
chamado Nomes.
A manipulação dos arrays passa pela identificação directa da célula com que se está a
trabalhar.
Assim:
Vector[2] = 55
Colocará o número 55 na 2ª célula do array Vector.
Analogamente:
Matriz[2][i] = 234.23
Colocará o número 234,23 na célula localizada na 2ª linha, iª coluna do array Matriz.
Consequentemente a coluna da 2ª linha modificada pela instrucção acima vai depender
de qual o valor de “i”. Se i=2 será a 2ª coluna se i=15 será a 15ª coluna, etc.
Operadores
Existe um conjunto extenso de operadores que se podem utilizar na notação
pseudo-código, apresentam-se seguidamente os mais importantes:
= atribuição ou comparação consoante a primitiva
onde estão inseridos
>, <, >=, <=, <> comparação (maior, menor, maior ou igual,
menor ou igual, diferente)
+, -, *, / aritméticos (soma, subtração, multiplicação,
divisão)
^ potenciação (ex: 2^3=8)
18
|| concatenação (ex: Set xpto=“olá”||“ “||“mundo”
coloca na variável xpto a frase “olá mundo”
-> apontador
19
Exemplos de Pseudo-Código
Nas próximas páginas repetem-se alguns enunciados de problemas apresentados como
exemplos de fluxogramas, apresentando-se o pseudo-código correspondente.
Exemplo Pseudo-Código 1 – Máquina de Cálcular
Pretende-se desenvolver um programa para a realização de operações
aritméticas.
O fluxograma parcial apresentado como solução foi o seguinte:
20
Recolha 1º operando
Efectuar
Cálculo
Recolha do operador
Operador
tem 2º
Operando
Recolha do 2º operando
Apresentar
Resultado
N S
Ao que corresponderá o seguinte pseudo-código:
START
VAR Op1 DECIMAL(10,2)
Op2 DECIMAL(10,2)
Oper CHAR
R DECIMAL(10,2)
OUTPUT “Introduza o primeiro operando: “
INPUT Op1
OUTPUT “Introduza o operador: “
INPUT Oper
21
IF Oper necessita segundo operador
THEN
OUTPUT “Introduza o segundo operando: “
INPUT Op2
END IF
CALL EfectuarCalculo( Op1, Oper, Op2, R )
OUTPUT “O resultado da operação é “, R
END
Na realidade o fluxograma completo incluia uma decisão final correspondente à
opção de sair do programa:
22
Recolha 1º operando
Efectuar
Cálculo
Recolha do operador
Operador
tem 2º
Operando
Recolha do 2º operando
Deseja
Sair
Apresentar
Resultado
N S
N S
O que implica que todo o código anterior é envolvido num ciclo WHILE, sendo
necessário inicializar a variável Sair a “N”, por forma a que da primeira vez que a
condição do WHILE seja testada ela se verifique e as instruções do WHILE sejam
executadas pelo menos uma vez:
START
VAR Op1 DECIMAL(10,2)
23
Op2 DECIMAL(10,2)
Oper CHAR
R DECIMAL(10,2)
Sair CHAR
Sair „N‟
WHILE Sair „N‟
OUTPUT “Introduza o primeiro operando: “
INPUT Op1
OUTPUT “Introduza o operador: “
INPUT Oper
IF Oper necessita segundo operador
THEN
OUTPUT “Introduza o segundo operando: “
INPUT Op2
END IF
CALL EfectuarCalculo( Op1, Oper, Op2, R )
OUTPUT “O resultado da operação é “, R
OUTPUT “Deseja Sair (S/N)?”
INPUT Sair
END WHILE
END
Exemplo Pseudo-Código 2 – Cálculo de um Factorial
Pretende-se desenvolver um programa que dado um determinado número cálcule
o seu factorial F = N! = N x (N-1) x (N-2) x … x (N-(N-1))
O fluxograma apresentado como solução foi o seguinte:
24
X < = 0
X = X - 1
Recolher X
msg erro
R = 1
R = R * X
X = 1
Apresentar R
N S
N S
Ao que corresponderá o seguinte pseudo-código:
START
VAR R INTEGER
X INTEGER
SET X = 0
WHILE X <= 0
OUTPUT “Introduza o número: “
INPUT X
OUTPUT “mensagem de erro”
END WHILE
SET R 1
WHILE NOT ( X = 1 )
SET R R * X
SET X X – 1
END WHILE
OUTPUT X, “!= ”,R
END
25
Refira-se que no pseudo-código anterior não se especializou o estado mensagem
de erro, o que se faz em seguida, tendo o cuidado de só apresentar a mensagem de
erro se for caso disso.
Por outro lado negou-se a condição do WHILE por forma a ser mais legível.
START
VAR R INTEGER
X INTEGER
X 0
WHILE X <= 0
OUTPUT “Introduza o número: “
INPUT X
IF X <= 0
THEN
OUTPUT “O número introduzido tem de ser > 0”
END IF
END WHILE
R 1
WHILE X != 1
R R * X
X X – 1
END WHILE
OUTPUT X, “!= ”,R
END
26
Complementos Avançados de Pseudo-Código
Literais
Os literais são grandezas utilizadas na manipulação de variáveis que devido ao seu
possível conteúdo se podem confundir com variáveis, as duas instruções abaixo, são
disso exemplificativas:
xpto = xpty
xpto = “xpty”
A primeira instrução atribui à variável xpto o conteúdo da variável xpty, qualquer que ele
seja. A segunda instrução atribui à variável xpto a palavra xpty.
Assim os literais devem ser delimitados por aspas (“) sempre que não forem númericos,
em particular:
INTEGER não delimita literais
DECIMAL(n,m) não delimita literais
DATE delimitar com aspas (“)
TIME delimitar com aspas (“)
STRING(n) delimitar com aspas (“)
CHAR delimitar com aspas (“)
LONG STRING delimitar com aspas (“)
BOOLEAN não delimita literais
POINTER não delimita literais
27
Nomenclatura de Variáveis, Constantes e Funções
A definição de todas as variáveis, constantes e nomes de funções no pseudo-código
(assim como numa boa estutura de programação em qualquer linguagem), devem seguir
algumas regras básicas, que a seguir se anunciam:
Regra 1 Os nomes deverão ser adequados à finalidade assim uma
variável que irá conter a idade de um sujeito pode
chamar-se exactamente “idade”, a data de nascimento
“datadenascimento” e uma função para calcular o
factorial de um número poderá chamar-se exactamente
“factorial”.
Regra 2 Os nomes poderão incluir números, mas não podem
começar, nem conter somente números. Não devem ser
utilizadas primitivas do pseudo-código (nem da
linguagem de programação que se vier a utilizar
posteriormente). Não devem ser utilizados caractéres
acentuados (à é ç â etc). Não devem ser utilizados
caractéres de pontuação (! ? ; % $ etc). Não devem ser
utilizados operadores (+ * / ^ etc). Não podem ser
introduzidos espaços (ou quaisquer outros elementos de
separação, por exemplo Tabs), no meio dos nomes.
Regra 3 Os nomes das variáveis deverão utilizar a notação
camelCase, isto é, sempre que a variável por apenas uma
palavra deve todas as letras devem ser minúsculas. Se a
variável for composta por duas palavras então a primeira
palavra mantém-se com as letras todas minúsculas e as
restantes palavras devem ter a primeira letra de cada
28
capitalizada (caixa alta) Assim, os exemplo da regra 1
passariam a ser “idadeDeNascimento”e “Data”.
Regra 4 Os nomes das funções devem ser escritos utilizando a
notação PascalCase, isto é, sejam eles formados apenas
por uma ou mais palavras, e as suas primeiras letras
devem ser sempre capitalizadas (caixa alta). Por
exemplo, „Factorial‟, „CalculaVolumes‟, etc.
Regras de Escopo
A validade das variáveis é definida por duas regras que devem ser bem entendidas sobre
pena de o algoritmo não poder ser passado a uma linguagem de programação, ou pior
ainda não funcionar de forma correcta.
Regra 1 As variáveis são válidas no contexto onde são definidas.
A definição de variáveis pode ser feita no contexto do bloco principal, i.e. entre o
START e o END ou no contexto de uma função, i.e. entre um determinado FUNCTION
e respectivo END FUNCTION.
O resultado disto é o de que as variáveis de um dado contexto só podem ser utilizadas
noutro contexto se o segundo estiver contido no primeiro.
Por exemplo, na imagem abaixo pretende-se representar com os traços verticais o
contexto do bloco principal e o de cada uma das quatro funções definidas – F1, F2, F3 e
F4.
29
START
END
FUNCTION F1
END FUNCTION
FUNCTION F2
END FUNCTION
FUNCTION F3
END FUNCTION
FUNCTION F4
END FUNCTION
VAR X
VAR Z
VAR Y
Contexto de validade
da variável X -> ( main, F1)
Contexto de validade
da variável Z -> (F3, F4)
Contexto de validade
da variável Y -> ( F2, F3, F4)
Como se pode ver as variáveis X, Y e Z tem validades diferentes como consequência dos
contextos onde foram definidas.
Regra 2 As variáveis definidas em contextos internos prevalecem
sobre os contextos externos.
Quando em contextos intersectados, são definidas variáveis com o mesmo nome, a
variável referenciada num determinado local depende da aplicação da regra acima.
30
START
END
FUNCTION F1
END FUNCTION
FUNCTION F2
END FUNCTION
FUNCTION F3
END FUNCTION
FUNCTION F4
END FUNCTION
VAR Y
Contexto de validade
da variável Y definida em F4
Contexto de validade
da variável Y definida em F2
VAR Y
Contexto de validade
da variável Y definida em F2
Assim, a variável Y quando utilizada dentro da função F4 é a que foi definida nesta
função, quando utilizada dentro das funções F2 ou F3 é a que foi definida na função F2.
Parâmetros
Por vezes torna-se necessário utilizar fora do contexto on são definidas determinadas
variáveis. Nessas situações tem de se recorrer à chamada passagem variáveis por
parâmetros, que permite “passar” variáveis para utilização em contextos onde em
princípio não seriam utilizáveis.
Um exemplo é o dado pela figura abaixo, quando se pretende utilizar as variáveis X1 e
X2 na função F1.
31
START
END
FUNCTION F1
END FUNCTION
VAR X1, X2
VAR Y
Contexto de validade
das variáveis X1 e X2
Contexto de validade
da variável Y
A solução aqui seria, quando a função F1 é chamada a partir do bloco principal
(recorrendo à primitiva CALL), indicar quais as variáveis que se pretendem passar, e por
que ordem são passadas:
32
START
END
VAR X1, X2 Contexto de validade
das variáveis X1 e X2
...
.CALL F1 (X1, X2)
...
Adicionalmente no cabeçalho da função F1, quando esta é definida, deverão ser
indicadas quais as variáveis recebidas:
FUNCTION F1 (X1, X2)
END FUNCTION
VAR Y
Desta forma, consegue-se que as variáveis X1 e X2 definidas no contexto do bloco
principal (um contexto que não abrange a função F1), sejam utilizadas na função F1.
Podem ainda existir situações, em que após a execução da função que recebeu as
variáveis como parâmetros, se pretenda que o seu novo conteúdo seja retornado ao
contexto onde a função foi chamada. Ou seja, em vez de se passar o “valor” da variável
para ser utilizado no novo contexto, passa-se a “referência” da variável de forma a que o
seu conteúdo alterado/actualizado pelo novo contexto seja recebido no contexto origem,
33
de onde foi feito o CALL. A isto chama-se uma passagem de parâmetro por referência,
prefixando-se a variável com a primitiva REF.
No exemplo abaixo a variável X1 é passada para a função F1 por valor e a variável X2
por referência:
START
END
FUNCTION F1 (X1, REF X2)
END FUNCTION
VAR X1, X2
VAR Y
Contexto de validade
das variáveis X1 e X2
SET X1=10
SET X2=20
...
.CALL F1 (X1, X2)
... OUTPUT X1
OUTPUT X2
...
SET X1=30
SET X2=40
...
Como consequência dessa diferença de passagens, quando no fim do bloco principal se
faz o OUTPUT X1 aparecerá 10, porque a alteração de X1 para 30 não é “retornada” da
função F1, enquanto que o OUTPUT X2 resultará num 40, porque a alteração feita
dentro da função F1 é “retornada” para o bloco principal.