<!--
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/>
1. primeiro executa-se o cômputo de <tt>fat(k)</tt>, para isso<br/>
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/>
3. então inicia-se a execução da função <tt>fat</tt><br/>
4. ao final da função <tt>fat</tt>, pega-se o valor da variável local <tt>ft</tt> e <br/>
5. atribui-se este valor para a variável <tt>b</tt><br/>
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 < 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 < 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>