intr_prog/introducao_funcoes.html

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

  <meta http-equiv='Content-Type' content='text/html; charset=UTF-8'>
  <meta name='keywords' content='mac0122, material, professores, leonidas de oliveira brandao'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/all.css'>
  <link rel='stylesheet' type='text/css' href='css_img_js_conf/line_introducao_programacao.css'>
  <script src="css_img_js_conf/defineLInE.js"></script> <!-- para referencias 'a documentos internos -->
<div class="pagina">


<p class="secao">O que é uma função em linguagens de programação</p>

<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 trigométrica <i>cosseno(x)</i>:
  deve-se definir a função (declará-la, seguindo a sintaxe correta: <tt>definir cosseno (parametro_real x): ...devolve valor;</tt>),
  depois pode-se <i>invocá-la</i> com parâmetros efetivos, valores específicos, como: <tt>cosseno(0)</tt> ou <tt>cosseno(0.5)</tt>.
  <br/>
  <b>Para quem deseja saber mais</b>: Esta é uma função que é impossível de ser implementada de <b>modo exato</b> em um
  computador digital, entretanto é viável obter boas aproximações utilizando o conceito de
  <a href="#" onclick="trocaPagina('introducao_eficiencia_algoritmos.html#taylor')"
     title="ver explicaco sobre serie de Taylor e funcao cosseno"><i>série de Taylor</i></a>.
  Do ponto de vista prático, a série que aproxima a função <i>cosseno</i>, para valores de <tt>x</tt> 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">
<p class="secao">Por que usar o conceito de função?</p>
</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>): implementa-se uma <i>particular unidade</i>, um trecho menor,
      concentrando-se nele, até que ele 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>


<a name="aplicacao">
<p class="subsubsecao">Um exemplo de aplicação do conceito de função: conseguir deduzir algitmos complexos</p>
</a>

<!--
aplicando o princípio do <em>passo da indução finita</em>
  -->

<p>
  Uma aplicação interessante das 3 vantagens acima citadas é possibilitar <b>quebrar</b> o problema, tentar perceber alguma estrutura
  do problema que permita quebrá-lo em tarefas menores (e mais simples!).
  Eesta abordagem é conhecida em Matemática como a técnica <b style="color:#0000aa;">dividir para conquistar</b>.
  <br/>
  Em atividades mais sofisticadas (geralmente aquelas envolvendo laços "duplos" ou mais - i.e., "laço dentro de laço")
  esta abordagem pode fazer a diferença entre conseguir deduzir um solução ou não conseguir.<br/>
  Um exemplo básico da abordagem: deduzir um <i style="color:#0000aa;">algoritmo para ordenar um vetor</i> com <em>N</em> valores.
  <ol type="A">
    <li value=””>Podemos imaginar um laço percorrendo as <em>N</em> posições do vetor <em>V[]</em>, sequencialmente desde
        <em>V[0]</em> até <em>V[N-2]</em>:
    <ol type="a">
      <li value=””>Para cada posição <em>i</em> supor existir uma função que encontra e devolve o índice <em>ind_min</em>
          do menor valor entre <em>V[i]</em> e <em>V[N-1]</em>;
      </li>
      <li value=””>Como isso foi feito sucessivamente desde a posição <em>i=0</em>, então (por indução), temos neste momento:
          <em>V[0]<u>&lt;</u>V[1]<u>&lt;</u> ... V[i-1]<u>&lt;</u> V[ind_min]<u>&lt;</u></em> e
          <em>V[ind_min]<u>&lt;</u>V[k]</em> para todo <em>k=i, i+1, ..., N-1</em> (supondo que a função acima funcionou).<br/>
          Portanto, basta trocar o elemento atual da posição <em>i</em> com aquele da posição <em>ind_min</em>
          (que tem o menor dentre <em>V[i]</em>, <em>V[i+1]</em>, ..., <em>V[N-1]</em>.<br/>
          Deste modo estendemos a ordenação: <em>V[0]<u>&lt;</u>V[1]<u>&lt;</u> ... V[i-1]<u>&lt;</u> V[i]<u>&lt;</u></em>.
      </li>
    </ol>
    </li>
  </ol>
  Uma vez que o problema foi <b>quebrado</b> e uma parte importante dele resolvida, deve-se tentar resolver a parte que falta, o parte "a".
  Então pode-se tentar resolver a parte "a", deduzindo um algoritmo que encontre o índice do menor valor
  (<em>V[i]</em> e <em>V[N-1]</em>).
  Uma vez resolvida também esta parte, este código pode ser incorporado adequadamente ao item "a" para
  finalmente <b>conquistarmos</b> a solução completa.
</p>

<p>
  Note que, em termos práticos, o algoritmo da parte "a" pode ser implementado como função, mas também pode-se
  implementá-lo diretamente no código (sem função, porém neste caso resultará em um código ficará "menos organizado").
  <br/>
  Experimente!
</p>


<p class="secao">Introdução ao uso de funções em <i>C</i> e em <i>Python</i></p>
   
<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 <cyan>//# devolve o valor em EXP para quem chamou a funcao</cyan></tt></td></tr>
  <tr valign="top"><td>Uso:</td><td>
    <tt>var = nome_da_funcao(lista_parametros_efetivos)</tt></td></tr>
</table>
</p>

<p>
  Atenção ao <b><tt>return</tt></b>, este é um comando especial, se ele for alcançado (e.g., ele pode estar subordinado a um comando de seleção <tt>if</tt>)
  então a execução da função é <b>interrompida</b>, retornando-se ao ponto imediatamente após o ponto de chamada da função.
  No caso do comando ter uma expressão qualquer, como indicado no exemplo <tt>return EXP</tt>, o valor de <tt>EXP</tt> é devolvido ao ponto de chamada,
  neste caso a chamada deve estar dentro de uma expressão (lógica ou artimética de acordo com o tipo de <tt>EXP</tt>) ou ser o lado direito de
  uma <i>atribuição</i>. Este último é o caso ilustrado na figura 1.
</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>


<p class="subsubsecao">Parâmetros formais e efetivos</p>

<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>


<p class="subsubsecao">Ilustrando a execução de um trecho de programa com 3 chamadas à mesma função</p>

<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>
 <p>
  <img src="img/exemplo_exec_funcao.jpg" title="exemplo de execucao da funcao"/>
  <br/>
  <i>Fig. 1. Ilustração do fluxo de execução ao <b>invocar</b> uma função para computar o <b>fatorial</b> de um natural.</i>
 </p>
</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>


<p class="subsubsecao">Exemplo concreto em <i>C</i> e em <i>Python</i></p>

<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><verm>int</verm> fat (<verm>int</verm> n) { <cyan>// define funcao com 1 parametro</cyan>
  <verm>int</verm> ft = 1; <verm>int</verm> i=1;
  <azul>while</azul> (i &lt; n) {
    i = i + 1; 
    ft = ft * i;  
    }   
  return ft;
  } <cyan>// chave indica final da funcao 'fat(...)'</cyan>
...
<cyan>// supondo existir neste contexto variaveis: N e k</cyan>
<verd>printf</verd>("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><verm>def</verm> fat (<verm>int</verm> n) : <cyan># define funcao com 1 parametro</cyan>
  ft = 1; <verm>int</verm> i=1 
  <azul>while</azul> (i &lt; n) {
    i = i + 1;  
    ft = ft * i;
  return ft;
  <cyan># Final da funcao 'fat(...)' - em Python,</cyan>
  <cyan># basta a indentacao da proxima linha ser recuada</cyan>
...
<cyan># supondo existir neste contexto variaveis: N e k</cyan>
<verd>print</verd>("Combinacao = ", fat(N) / (fat(k) * fat(N-k))
  </pre></td></tr></table></td></tr>
</table></center>   


<p class="subsubsecao">Variáveis locais</p>

<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>  


<p class="subsubsecao">Para que serve função?</p>

<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 class="autoria">
    <a href="https://www.ime.usp.br/~leo" target="_blank" title="seguir para a pagina do prof. Leônidas">Leônidas de Oliveira Brandão</a><br/>
    <a href="http://www.ime.usp.br/~leo" target="_blank" title="seguir para a página do LInE">http://line.ime.usp.br</a>
  </p>

  <p class="rodape">
    <b>Alterações</b>:<br/>
    2020/08/15: novo formato, pequenas revisões<br/>
    2020/08/09: Sábado, 09 de Agosto 2020, 14:00<br/>
    2020/04/13: Segunda, 13 Abril 2020, 12:30
  </p>


</div>