O documento discute funções e procedimentos em linguagens de programação. Apresenta como funções e procedimentos são abstrações que permitem parametrização de computações. Detalha as diferenças entre funções e procedimentos e como cada um é definido em linguagens como C, C++, Haskell e Ada. Inclui explicações sobre parâmetros formais versus reais, mecanismos de passagem de parâmetros e ordem de avaliação.

1. Funções e
Procedimentos
Prof: Sergio Souza Costa
Adaptado de © 2004, Programming Language Design Concepts
D.A. Watt, University of Glasgow

2. Sobre mim
Sérgio Souza Costa
Professor - UFMA
Doutor em Computação Aplicada (INPE)
prof.sergio.costa@gmail.com
https://sites.google.com/site/profsergiocosta/home
https://twitter.com/profsergiocosta
http://gplus.to/sergiosouzacosta
http://www.slideshare.net/skosta/presentations?order=popular

3. Abstração: Função e Procedimento
● Abstração – uma entidade que contém uma computação.
● Abstração de Função - contém uma expressão a ser avaliada.
● Abstração de Procedimento - contém um bloco a ser executado.
● A efetividade de abstrações é enriquecida através da parametrização.

4. Uma abstração de função é uma expressão que produz um resultado.
Visões:
● o usuário da função está preocupado somente com o resultado da
função
● o programador da função está preocupado como o procedimento
funciona, seu algoritmo.
Função

5. Função - C
Uma função em C/C++ tem a seguinte forma:
T I (FPD1 , . . . , FPDn ) B
Onde:
● I é o identificador da função,
● FPDi são as declarações dos parâmetros formais,
● T o tipo do resultado
● B um bloco de comandos, chamada de corpo da função

6. Uma função pode ser chamada por uma expressão na seguinte forma:
I(AP1 , . . . , APn )
Onde APi, são os parâmetros reais e I o identificador da função.
Função - C

7. Definição:
Função - C
float power (float x, int n) {
float p = 1.0;
for (int i = 1; i <= n; i++)
p *= x;
return p;
}
power (2, 4)
Chamada:

8. Função Haskell
Uma função em Haskell tem a forma:
I FPs = E
Onde:
I é o identificador da função
FPs, são os parâmetros formais e
E é uma expressão.

9. Função Haskell
power :: Float -> Int -> Float
power _ 0 = 1
power x n = x * power x (n-1)
power 2.0 4
Definição:
Chamada:

10. Funções em linguagens imperativas
● O corpo de uma função em linguagens imperativas é sintaticamente um
comando e, semanticamente, uma expressão com efeito colateral.
● Já o corpo de uma função em linguagens imperativas é uma expressão,
tanto sintaticamente quanto semanticamente.

11. Funções anônimas
● Na maioria das linguagens, uma função está sempre associada
(amarrada) a um identificador.
● Entretanto, algumas linguagens, como Haskell, JavaScript e Lua
permitem separar o conceito de construções de funções e amarração, ou
seja, permitem definir funções sem identificadores.
(x->2*x) 4 (function (x)
return 2*x end) (4)
Definindo e aplicando uma
função em Lua.
Definindo e aplicando uma
função em Haskell.
dobro =(x->2*x)
dobro 4
Amarrando a um identificador -
Haskell
dobro=(function (x)
return 2*x end)
dobro (4)
Amarrando a um identificador - Lua

12. Procedimentos
● Contém um comando a ser executado, e que quando chamado
atualizará variáveis.
● Esta abstração existe apenas em linguagens imperativas.
● O usuário de uma abstração de procedimento observa apenas as
atualizações de variáveis, não os passos executados para sua
efetivação.

13. Procedimento - C/C++
Um procedimento em C/C tem a seguinte forma
void I (FPDs) B
Onde
● I é o identificador,
● FPS, são os parametros formais
● B o bloco de comando.

14. Procedimento - C++
Considere o seguinte procedimento:
void sort (int v[], int n) {
for (int i = 1; i < n; i++) {
int tmp = v[i];
for (int j = i; j > 0 && tmp < v[j-1]; j--)
v[j] = v[j-1] ;
v[j] = tmp;
}
}
● Visão do usuário, a função sort produz a ordenação dos valores do
vetor de entrada;
● Visão do programador, é usado o algoritmo de inserção.

15. Procedimentos - Ada
Em Ada, um procedimento tem a seguinte forma:
procedure I (FPs) is
D
begin
C
end;
Onde:
● I é o identificador,
● FPS, são os parametros formais
● D, são as declarações locais
● C, corpo da função, um bloco de comando

16. Função e Procedimento
● Uma abstração de função é uma abstração sobre uma expressão. Uma
chamada de função é uma expressão que retorna um valor pela
avaliação do corpo da abstração de função.
● Uma abstração de procedimento é uma abstração sobre um comando.
Uma chamada de procedimento é um comando que atualiza variáveis
pela execução dos passos da abstração de procedimento.

17. Função e Procedimento
Procedimentos são coleções de sentenças que definem computações
parametrizáveis
● Podem modificar os parâmetros
● Podem modificar variáveis globais
Funções são similares a procedimentos, mas são semanticamente modeladas
como funções matemáticas.
● Que não deveriam ter efeitos colaterais

18. Parâmetros e argumentos
Ausência reduz
Redigibilidade
○ Necessário incluir operações para atribuir os valores desejados às variáveis globais
Legibilidade
○ Na chamada de volume não existe qualquer menção à necessidade de uso dos valores
das variáveis altura, largura e comprimento
Confiabilidade
○ Não exige que sejam atribuídos valores a todas as variáveis globais utilizadas em volume

19. Parâmetros e argumentos
int altura, largura, comprimento;
int volume () { return altura * largura * comprimento; }
main() {
int a1 = 1, l1 = 2, c1 = 3, a2 = 4, l2 = 5, c2 = 6;
int v1, v2;
altura = a1;
largura = l1;
comprimento = c1;
v1 = volume();
altura = a2;
largura = l2;
comprimento = c2;
v2 = volume();
printf (“v1: %dnv2: %dn”, v1, v2);
}

20. Parâmetros e argumentos
● São usados para permitir que uma abstração receba valores
específicos para realizar sua computação.
● Um argumento é um valor passado para uma abstração. (parâmetro
real)

21. Parâmetros e argumentos
parâmetro formal:
identificador dentro de uma
abstração, usado para denotar um
argumento.
expressão na chamada de uma
abstração que determina um
argumento
parâmetro real:
argumento:
o valor que é passado para um
procedimento ou função.

22. Parâmetros e argumentos
function eof (f : text) : Boolean;
{f – parâmetro formal}
. . .
resultado := eof(book);
{book – parâmetro real}

23. ● Valores que podem ser passados como argumentos:
○ valores de primeira classe (todas linguagens)
○ ponteiro para variáveis (em muitas linguagens)
○ procedimentos ou ponteiros para procedimentos (em algumas linguagens)
Parâmetros e argumentos

24. Mecanismos de passagens
● Mecanismos de passagem de parâmetros são as formas de associar
parâmetros reais a formais.
● Tipos de Mecanismos:
○ por valor, por resultado, por valor/resultado, por nome, por referência, por função....
● Existem dois modelos conceituais de como os dados são transferidos
dos parâmetros reais para os formais e vice-versa.
○ Ou um valor real é copiado (para o chamador, para o chamado, ou para ambos)
○ Ou um caminho de acesso é fornecido (um ponteiro ou referência)

25. Mecanismo - Cópia
O parâmetro formal x é uma variável local da abstração.
● O valor (argumento) é copiado para a variável local x.
function dobro (x)
return 2*x
end
a = 10
b = dobro (a)

26. Mecanismo - Cópia
Três modelos semânticos:
● valor
● resultado
● valor/resultado
C/C++ suporta apena cópia, Ada suporta todos os três.

27. Mecanismo - Cópia
Chamador
sub(a, b, c)
Chamado
void sub(int x, int y, int z)
valor
resultado
valor/resultado
a
b
c
x
y
z
chamada
retorno

28. Mecanismo referência
Permite que um parametro formal PF seja associado (amarrado)
diretamente ao argumento.
○ Constante - o argumento é um valor de primeira classe que é associado ao PF, mas que
nao pode ser modificado.
○ Referência (ou variável) - o argumento é uma referência a uma variável e PF pode ser
modificado.
○ Procedural e Funcional - o argumento é uma abstração de procedimento ou função e PF
é associado a sua definição.
● Ada suporta os mecanimos contante e variavel. C não suporta
diretamente referência, porém é possivel simular atraves de ponteiros.
C++ suporta referência diretamente (&).

29. Mecanismo referência - C++
Procedimento:
void inc (int& n) {
n = n +1;}
Chamada :
int x = 10;
inc (x);

30. Mecanismo referência
Constante, caso queira passar apenas em modo de leitura:
Exemplo, C++:
void top (const Pilha& p);

31. Ordem de avaliação
Em que instante os parâmetros reais devem ser avaliados ?
● Na chamada da abstração ?
● Ou só quando o parâmetro formal for necessário ?
Função estrita - a execução da função depende do total avaliação de seus
argumentos.
Função não-estrita - a função pode ser executada avaliando apenas uma
parte de seus argumentos. Ex:
and False _ = False
and True b = b

32. Referências
Programming Language Design Concepts [Paperback]. David A. Wat