funções e procedimentos
TRANSCRIPT
Funções e ProcedimentosProf: Sérgio Souza Costa
Sobre mim
Sérgio Souza CostaProfessor - UFMADoutor em Computação Aplicada (INPE)
https://sites.google.com/site/profsergiocosta/home
https://twitter.com/profsergiocosta
http://gplus.to/sergiosouzacosta
http://www.slideshare.net/skosta/presentations?order=popular
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.
●Uma abstração de função é uma expressão que produz um resultado.
●Visões:○usuário da função está preocupado somente com o
resultado da função○ implementado da função está preocupado como o
procedimento funciona, seu algoritmo.
Função
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
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
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:
Definindo uma função sem parametros em C: void f (void) { }
Definindo uma função sem parametros em C++:
void f () { }
Em C, esta função seria uma função sem numero de parâmetros definido.
Função - C/C++
Função - Ada
Em Ada, uma função tem a forma:
function I (FPs) return T is
D
begin
C
end;
Onde: FPS, são os parametros formais.
T é o tipo de retorno.
D são declarações locais e
C o corpo da função, no caso um comando.
Função - Ada
Definição:
function power (x: Float, n: Integer) return Float is p: Float := 1.0;begin for i in 1 .. n loop p := p * x; end loop; return p;end;
Chamada: power (2.0, 4)
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.
Função Haskell
power :: Float -> Int -> Floatpower _ 0 = 1power x n = x * power x (n-1)
power 2.0 4
Definição:
Chamada:
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 sintáticamente quanto semanticamente.
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
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.
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.
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 implementador, é usado o algoritmo de inserção.
Procedimentos - Ada
Em Ada, um procedimento tem a seguinte forma:
procedure I (FPs) is Dbegin Cend; 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
Função vs 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.
Função vs 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
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
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: %d\nv2: %d\n”, v1, v2);}
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)
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.
Parâmetros e argumentos
function eof (f : text) : Boolean;{f – parâmetro formal}. . .
resultado := eof(book);{book – parâmetro real}
Parâmetros e argumentos
●Valores que podem ser passsados como argumentos:○ valores de primeira classe (todas linguagens)○ponteiro para variáveis (em muitas linguagens)○procedimentos ou ponteiros para procedimentos (em
algumas linguagens)
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)
Mecanismo - Cópia
O parâmetro formal x é uma variável local da abstração.● O valor (argumento) é copiado para a variavel local x.
function dobro (x) return 2*xend a = 10 b = dobro (a)
Mecanismo - Cópia
Três modelos semânticos:● valor● resultado● valor/resultado
C/C++ e Java suporta apena cópia, Ada suporta todos os três.
Mecanismo - Cópia
Chamadorsub(a, b, c)
Chamadovoid sub(int x, int y, int z)
valor
resultado
valor/resultado
a
b
c
x
y
z
chamada
retorno
Mecanismo - Cópia - Ada
type Vector is array (1 .. n) of Float; procedure add ( v, w: in Vector; sum: out Vector) isbeginfor i in 1 .. n loopsum(i) := v(i) + w(i);
end loop;
end; …add(a, b, c);
Mecanismo referência
Permite que um parâmetro 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.
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 (&).
Mecanismo referência - C++
Procedimento:
void inc (int& n) { n = n +1;}
Chamada :
int x = 10;inc (x);
Mecanismo referência
Constante, caso queira passar apenas em modo de leitura:
Exemplo, C++: void top (const Pilha& p);
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 _ = Falseand True b = b
Parâmetros - Valores padrõesEm C++, na definição de um parâmetro formal é possível definir um valor padrão: int soma (int a[], int inicio = 0, int fim = 7, int incr = 1){ int soma = 0; for (int i = inicio; i < fim; i+=incr) soma+=a[i]; return soma;}main() {
int [] pontuacao = { 9, 4, 8, 9, 5, 6, 2};int ptotal, pQuaSab, pTerQui, pSegQuaSex;ptotal = soma(pontuacao);pQuaSab = soma(pontuacao, 3);pTerQui = soma(pontuacao, 2, 5);pSegQuaSex = soma(pontuacao, 1, 6, 2);
}
Parâmetros - Valores padrões
Em linguagens dinamicamente tipadas, como não existe checagem do número de argumentos, podemos simular valores padrões, testando se o valor de um parâmetro formal é indefinido ou nulo:
function inc (n, i) if i == nil then i = 1 end return n+iend
function inc (n, i) i = i or 1 return n+iend
Lista de parâmetros variáveis - C
#include <stdarg.h> int ou (int n, …) {
va_list vl; int i; va_start (vl, n); for (i = 0; i < n; i++)
if (va_arg (vl, int)) return 1; va_end (vl);
return 0; } main() {
printf (“%d\n”, ou (1, 3 < 2)); printf (“%d\n”, ou (2, 3 > 2, 7 > 5)); printf (“%d\n”, ou (3, 1 != 1, 2 != 2, 3 != 3)); printf (“%d\n”, ou (3, 1 != 1, 2 != 2, 3 == 3));
}
Lista de parâmetros variáveis
function f () { for (i in arguments ) { console.log (i) }} f (10,5)
function f(...) for i, v in ipairs (arg) do print (i, v) endend f(10, 5)
JavaScript Lua
Lista de parâmetros variáveis
function f (obj) { ... } f ({x:10, y:5 })f ({x:10, y:5, z: 20 })
function f(t)... end f({x=10, y=5})f({x=10, y=5, z = 20})
Ao invés da solução anterior, é mais comum o uso de objects ou tabelas para transmitir numero variavel de parametros:
JavaScript Lua
Atividades
1. Modifique a sintaxe para definição de funções em C, de modo a ter uma clara distinção entre procedimentos e funções.
2. Modifique a sintaxe para definição de funções em Ada, onde o corpo de uma função seja uma expressão (ao invés de um bloco de comando). Mostre o que essa mudança irá afetar no poder de expressão da linguagem, e quais outras mudanças podem ser necessárias para compensar.
3.Cite pelo menos um exemplo de uma função sem parametros que nao retorna o mesmo valor para cada vez que é chamada. Sobre quais circunstâncias, em geral, uma função se comporta desse modo?
Atividades
4.Considere a implementação de um procedimento P com um parametro formal PF de um tipo T:
a) Assumindo que o mecanismo usado é valor/resultado. O que exatamente é passado para P, um valor ou endereço ? O que exatamente acontece quando P é chamado ? O que acontece dentro de P quando acessamos e atualizamos PF? O que acontece com o retorno de P ?
b) Faça a mesma análise assumindo o mecanismo de referência, variável.
Referências
Programming Language Design Concepts [Paperback]. David A. Wat
Abstract Data Types and the Development of Data Structures