ggrc
/
intr_prog


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
							
<!--
Introdução ao uso de funções em C e em Python
http://saw.atp.usp.br/mod/page/view.php?id=
-->

<!DOCTYPE html>
<html itemscope itemtype="http://schema.org/QAPage">

<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
  <title>Introdução ao uso de funções em C e em Python</title>
<style type="text/css">
.tableCd { border-collapse:collapse; }
.thBg th { background-color:#8aaada; }
.trCd td, .tbCd td, .tbCd th { vertical-align: top; padding:5px; border-right:1px solid #000;  font-family: courier }
</style>
</head>

<body>

<span style="color: #0055AA"><b>O que é uma função em linguagens de programação</b></span>

<p>
  A ideia básica de uma função, implementada em alguma linguagem de programação, é <i>encapsular</i> um código
  que poderá ser invocado/chamado por qualquer outro trecho do programa.
  Seu significado e uso é muito parecido com o de funções matemáticas, ou seja, existe um nome, uma definição
  e posterior invocação à função.
</p>

<p> 
  Explicitando o paralelo com a matemática, tomemos como exemplo a função trigonétrica <i>cosseno(x)</i>,
  que é impossível de ser implementada de modo exato em um computador digital, entretanto é viável obter
  boas aproximações utilizando a
  <a href="introducao_eficiencia_algoritmos.html#taylor"
     title="ver explicaco sobre serie de Taylor e funcao cosseno"><i>série de Taylor</i></a>.
  Como examinado na referida página, a série que aproxima a função <i>cosseno</i> próximo à origem é:
    <i>(1) cos(x) = 1 - x<sup>2</sup> /2! + x<sup>4</sup> /4! - x<sup>6</sup> /6! + x<sup>8</sup> /8! + ...</i>
</p>

<p>
  Note que o <i>lado direito</i> da equação (1) é a definição da função e ela está escrita em termos
  do <b>parâmetro formal</b> <i>x</i>.
  Ao "chamarmos" a função com <b>parâmetros efetivos</b>, é sobre o valor desses parâmetros que computamos
  o lado direito da expressão, por exemplo, computar <i>cos(0.1)</i> ou de <i>cos(1.1)</i>.
</p>


<a name="porque">
<span style="color: #0055AA"><b>Por que usar o conceito de função?</b></span>
</a>  

<p>
  Assim, implementar códigos com objetivos específicos (como computar o <i>cosseno</i> de qualquer valor)
  apresentam três grandes vantagens:
  <ol>
    <li>
      Facilita o desenvolvimento (<i>desenvolvimento modular</i>): desenvolve-se um unidade particular, concentrando-se
      nela, até que ela esteja funcionando com alto grau de <i>confiabilidade</i>;
    </li>
    <li>
      Organização: o código fica melhor organizado e portanto mais fácil de manter;
    </li>
    <li>
      Reaproveitamento: sempre que precisar aplicar o código encapsulado em qualquer outro trecho de código
      (ou noutro código), pode-se utilizar aquele que já foi implementado e é <i>confiável</i>.
    </li>
  </ol>
  
</p>


<span style="color: #0055AA"><b>Introdução ao uso de funções em <i>C</i> e em <i>Python</i></b></span>
      
<p>
  Assim, agrupar trechos com objetivos específicos e implementá-los na forma de uma <i>função</i>
  que ajuda bastante o desenvolvimento e a organização dos códigos em programação.
</p>

<p>
  Do ponto de vista prático, a estrutura básica de uma função em uma linguagem de programação está representada abaixo,
  com a <i>declaração da função</i> e sua <i>lista de parâmetros formais</i>, seguido de sua invocação
  (quando providenciamos os <i>parâmetro efetivos</i>).
<table>
  <tr valign="top"><td>Declaração:</td>
    <td>
    <tt>[enventual tipo de retorno] nome_da_funcao (lista_parametros_formais)<br/>
        comando1<br/>
        ...<br/>
        comandoN<br/>
        return EXP</tt></td></tr>
  <tr valign="top"><td>Uso:</td><td>
    <tt>var = nome_da_funcao(lista_parametros_efetivos)</tt></td></tr>
</table>
</p>

<p>
A <i>lista de parâmetros</i> pode conter vários nomes de variáveis, geralmente, separadas por vírgula.
Por exemplo, se houver necessidade de uma função que realiza vários cálculos com três variáveis pode-se usar como
declaração da função algo como: 
<tt>nome_da_funcao (var1, var2, var3)</tt>.
</p>

<span style="color: #0055AA">Parâmetros formais e efetivos</span>

<p>
De modo geral, a diferença entre os <i> parâmetros formais</i> e <i>efetivos</i> é que o primeiro corresponde ao
nome da variável utilizada dentro da função, enquanto o segundo é o nome da variável que será usado para iniciar o parâmetro
formal ao iniciar a execução da função.
</p>

<p>
Assim durante a execução, ao encontrar uma chamada à função <tt>nome_da_funcao</tt>, o fluxo de execução segue
a partir do código da função.
Mas antes de executar a primeira linha de código da função, os valores dos <i>parâmetros efetivos</i> servem para inicializar
os parâmetros formais (que são também variáveis locais à função). Após esta inicialização, inicia-se a execução do código
da função e geralmente ao final, encontra-se um comando do tipo "retorne devolvendo um valor" (<i>return</i>).
</p>

<span style="color: #0055AA">Ilustrando a execução de um trecho de programa com 3 chamadas à mesma função</span>

<p>
Suponhamos que precisemos computar o valor da combinação de <i>N</i> tomado <i>k</i> a <i>k</i>, ou seja,
C(N,k) = N! / ( k! (N-k)!).
Para isso percebe-se que é necessário implementar o cômputo de fatorial que será utilizado 3 vezes.
Para facilitar a compreensão, podemos escrever um código com 3 variáveis auxiliares para armazenar, respectivamente,
<i>N!</i>, <i>k!</i> e <i>(N-k)!</i>.
<p>

<center><img src="img/exemplo_exec_funcao.jpg" title="exemplo de execucao da funcao"/>
</center>

<p>
Na figura acima ilustra a execução do código para computar <i>C(N,k)</i>, com o retângulo à esquerda contendo
o código que invoca a função <i>fat</i> e à direita a função <i>fat</i>.
Para entender o fluxo de execução destaremos a execução da linha 2, <tt>b = fat(k);</tt>.
Como <tt>b = fat(k);</tt> é uma atribuição, primeiro computa-se o valor do <i>lado direito</i> da atribuição
e só depois atribui-se à variável do <i>lado esquerdo</i> da atribuição o seu valor, ou seja,<br/>
 &nbsp; 1. primeiro executa-se o cômputo de <tt>fat(k)</tt>, para isso<br/>
 &nbsp; 2. pega-se o valor do <i>parâmetro efetivo</i> <tt>k</tt> e usa-o para iniciar o <i>parâmetro formal</i> <tt>n</tt> da função<br/>
 &nbsp; 3. então inicia-se a execução da função <tt>fat</tt><br/>
 &nbsp; 4. ao final da função <tt>fat</tt>, pega-se o valor da variável local <tt>ft</tt> e <br/>
 &nbsp; 5. atribui-se este valor para a variável <tt>b</tt><br/>
 &nbsp; 6. então segue-se execução da próxima linha (3).<br/>
Vale notar que a execução da atribuição <tt>c = fat(N-k);</tt> seguirá um fluxo análogo aos 6 passos acima.
</p>

<p>
Uma vez entendido como é executado uma chamada á função, podemos novamente comparar com o conceito usual
de função matemática. Existe a declaração da função, com seu parâmetro formal
<pre>
   fat : IN -> IN  (nome 'fat', com domínio e imagem nos naturais)
   fat(n) = { 1, se n=0, n x fat(n-1), se n>0 }</pre>
E existe o uso da função, como em
<pre>
   C(N,k) = fat(N) / (fat(k) x fat(N-k)</pre>
</p>


<span style="color: #0055AA">Exemplo concreto em <i>C</i> e em <i>Python</i></span>

<p> 
Para ilustrar o uso e sintaxe de funções em <i>C</i> e em <i>Python</i>, examinemos um exemplo em que implementamos uma
função para cômputo do fatorial de um natural <i>n</i>, que será o nome de seu único parâmetro formal.
</p>

<center><table class="tableCd">
 <tr><td></td><td bgcolor="8aaada"><i>C</i>              <td bgcolor="8aaada"><i>Python</i></td></tr>
  <tr><td><table class=""><tr class="trCd" valign="top"><td><pre> 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11</pre></td></tr></table></td>
  <td><table class=""><tr class="trCd" valign="top"><td><pre>int fat (int n) { // define funcao com 1 parametro  
  int ft = 1; int i=1;
  while (i &lt; n) {
    i = i + 1;    
    ft = ft * i;  
    }      
  return ft;
  } // chave indica final da funcao 'fat(...)'
...
// supondo existir neste contexto variaveis: N e k
printf("Combinacao = %f\n", fat(N) / (fat(k) * fat(N-k));</pre></td></tr></table></td>
  <td><table class=""><tr class="trCd" valign="top"><td><pre>def fat (int n) : # define funcao com 1 parametro  
  ft = 1; int i=1 
  while (i &lt; n) {   
    i = i + 1;     
    ft = ft * i;   
  return ft;
  # Final da funcao 'fat(...)' - em Python,
  # basta a indentacao da proxima linha ser recuada
...
# supondo existir neste contexto variaveis: N e k
print("Combinacao = ", fat(N) / (fat(k) * fat(N-k))
  </pre></td></tr></table></td></tr>
</table></center>      

<span style="color: #0055AA">Variáveis locais</span>

<p>
Note na linha 2 do código acima que são declaradas duas novas variáveis, <i>ft</i> e <i>i</i>, dentro da fução <i>fat</i>.
Isso significa que as variáveis <i>ft</i> e <i>i</i> são <b>variáveis locais</b> à função, ou seja,
pode-se utilizar variáveis com os mesmos nomes em outras funções sendo que elas não terão qualquer relação.
Em particular, na 11 do código em <i>C</i> ou na 9 do código em <i>Python</i>, poderia-se usar uma variável com nome <i>n</i>,
<i>ft</i> ou <i>i</i> e ainda assim, está variável não teria qualquer relação com as correspondentes da função <i>fat</i>.
</p>  

<span style="color: #0055AA">Para que serve função?</span>

<p>
A partir do exemplo acima, para cômputo de <i>C(n,k) = n! / (k! (n-k)!)</i>,
imagine como seria o código para computar a combinção se a linguagem de programação NÂO dispusesse do conceito
de funções: em resumo, precisariamos repetir as linhas 2 a 5 (ou 6), que computam fatorial, três vezes.
Portanto, o uso de função simplifica o código.
</p>

<p>
Mas existe uma outra razão para usar funções, que não tão óbvia, a maior facilidade para escrever um programa.
E isso se deve à vários fatores, mas principalmente à quebra de um problema maior em vários menores.
Isso facilita o desenvolvimento e reduz a incidência de erros de programação.
</p>

<p>
Por exemplo, pode-se implementar a função separadamente, testando-a até que ela fique pronta e sem erros.
Assim, o código fica mais fácil de ser entendido, pois ao usar a função pode-se abstrair, o trecho fica curto (apenas a chamada à função)
e pode-se concentrar em saber se o restante do código está correto.
</p>

<p>
Leônidas de Oliveira Brandão<br/>
http://line.ime.usp.br
</p>
</body>