LP 31/10/2011

   # # # # # # # # # # # # # #
  # Linguagens de Programação #
  # Prof. Fernando Pereira    #
  # notasdogarcia.blog.com    #
   # # # # # # # # # # # # # #

		O que são parametros formais e parametros reais mesmo?

Isso existe em linguagem cálculo lambda:

(/x x+1) y

x é o parametro formal
y é o parametro real

Agora seja uma linguagem mais de alto nível:


  foo(int x, int y)
  foo(2,3)

  2 e 3 são parametros reais, enquanto x e y formais.

  Como conseguimos diferenciar qual parametro formal é o x e qual é o y?

  O mais simples é a ordem, o que vem primeiro é o x e o que vem depois é o y.

def div(divident=1.0, divisor = 1.0):
  r = divident/ divisor
  print "Resultado = ", r

  veja o exemplo:

    div(1.4, 3)
  é igual à:
    div(divisor = 3, divident = 1.4)

  Ou seja pode-se adicionar um label aos parametros e utiliza-lo para essa identificação.

  Pode-se também realizar o casamento misto:

    div(divident = 3, 1.4)

  mas nesse caso é preciso que as posições estejam corretas.
  // daria erro caso contrário.

  Outra coisa que se pode fazer é adicionar valores padrões para os parâmetros formais.
  Assim pode-se adicionar um valor sem este ser definido pelo usuário.

  Pode-se ter um número variável de parametros?

  Sim. Em C e C++ por exemplo pode escrever uma função do tipo:

  printf(char* formato, ...);

  // Nota: para se implementar isso usa-se 3 funções da biblioteca: stdarg.h:
  // va_list ap;
  // va_start(ap, nargs);
  // va_arg(ap, tipo do argumento);
  // va_end(ap);

  // O professor mostrou que como essa forma é muito crua, se voce passa o primeiro parametro com o número de parametros que o seguem.
  // sem informar o tipo, e eu procuro por tipos inteiros, mas uso um tipo long int, como parametro real.
  // da biziu pq eu to lendo de 32 em 32 bits. aí complica.


  O professor mostro um exemplo em python:

  def f(a, L=[]):
    L.append(a)
    return L

  Pela gramatica de python se eu chamar f(1) f(2) e depois f(3), o retorno será: [1] depois [1,2] e depois [1,2,3]
  Motivo: o argumento padrão na verdade não é uma lista vazia, mas sim um ponteiro estatico de lista pre-alocado.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Seja o programa em c:
int main(int argc, char* argv[]){
  printf("%s\n", argc);
}

  Qual o erro?, um seg fault provavelmente, pois não há amarração entre o tipo de argc e seu uso dentro da função  printf.

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

  Quais os tipos de passagens que temos?

    - Valor
    - Referencia
    - Resultado
    - Valor-Resultado
    - Expansão de Macros
    - Nome
    - Necessidade

  Vamos falar disso na ordem.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  O que é passagem por valor?

    São passagens onde o item recebido como parametro tem o mesmo valor do original mas não se trata do mesmo objeto.

    Assim uma passagem por valor não é capaz de alterar o valor original dos parametros.

  // Linguagem que recebe parametros só de valor: C

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  E uma passagem por referencia?

    Também já conhecemos bem essa passagem, é uma passagem onde o que é recebido é o valor do endereço do parametro real original.

    Na prática passagem por referencia significa passar o próprio objeto original, assim alterações realizadas dentro da função são notáveis na variável original.

  // Linguagem que recebe parametros só de referencia: Java
  // Linguagem que recebe tanto parametros de referencia quanto de valor: C++

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  // O professor mostrou exemplos de valor e referencia em C e C++, e os comparou.
  // Em C++ um parametro por referencia é o & junto aos parametros formais.
  // O professor mostrou que de fato a passagem por referencia de C++ é equivalente a passagem por valor de ponteiro do C.
  // Em outras palavras, passagem por referencia é um açucar sintático sobre o uso de ponteiros.

  // Riscos de passagem por referencia: Efeitos colaterais.
  // O professor deu um exemplo de um swap(int& a, int& b) que utiliza um xor para trocar os dois inteiros de posição.
  // Porém se voce realizar a chamada: swap(a,a) a é zerado, pois na verdade era preciso que o endereço dos parametros fossem diferentes para o funcionamento.

  // Em outras palavras, C++ que permite passagem por referencia opcional, te permite dar tiros no pé.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  dado um exemplo em java:
  Object(x) = null;
  makeString(x) (onde makeString retorna x="Isto é uma string")
  printf(x)

  O que acontece?
  É impresso null.
  Porque de fato o parametro x foi passado por valor.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Passagem por resultado:

    É quando um de seus parâmetros é passado como referencia de um retorno.
    Ou seja, ao fim da função voce escreve nesse endereço um dos retornos, isso é usado em C de forma explicita, e implicitamente isso é usado em outras linguagens,
    e é chamado de passagem por resultado.

  ex:
    foo ( Res a, int a, int b)
    Res é um parametro de retorno.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  // Nota solta: macros em C fazem algo que pode ser chamado de passagem por referencia, se voce pensar bem.

  Passagem por Expansão de macro:
    Como já sabemos uma macro é uma cópia do código na macro no contexto onde seu nome foi chamado.

    Assim para efeitos práticos sua passagem é semelhante à uma por referencia com as seguintes peculiaridades:
    Se o parâmetro é uma expressão ele só será avaliado no momento do uso, ou seja para cada vez que ele é usado dentro da macro a expressão é resolvida uma vez.
    O que pode ser ineficiente.
    Outro problema é a ambiguidade, já que #define f(a) (a*2) retorna 8 para f(4), mas 6 para f(3+1)

    Outro problema é que uma variável local a macro pode afetar o contexto da função que a chamou o que pode também ser complicado.

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Passagem por Nome:

 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  Passagem por Nessecidade:

    Tem a vantagem da passagem por expansão de macro que é o fato de voce só avaliar a expressão sob demanda.
    Porém ele não altera o escopo original, e não avalia um mesmo parametro duas vezes, ele guarda em um cache o resultado e não avalia mais.
    Outra característica interessante é que só se passa parametros por necessidade.

    // Haskell é uma linguagem elegante, disse o professor.

    Haskell é uma linguagem que realiza um fibonichi bem voce lembra diso.

// Fim da aula.