Funções, vamos declarar!
Autor: Alexandre Richard | Publicado: 2013-11-13T05:52:00-08:00

Até agora, todos os programas foram simples e pequenos, onde tudo cabia no mesmo lugar.
Programas grandes e complexo precisam ser feitos de outra forma, para isso, vamos utilizar funções.

Existe vários motivos para dividir problemas complexos em funções. O principal, é a reutilização do código.
Já fizemos alguns programas com funções matemáticas básica, imagine como seria bacana, utilizar cada função que foi escrita no mesmo programa!?

Escrever e utilizar uma função segue o seguinte fluxo:

void NomeDaFuncao()
{
&nbsp;// código aqui...
&nbsp;return;
}
int mains(int nNumberofArgs, char* pszArgs[])
{
&nbsp;//código do programa...
//agora, vamos chamar a função NomeDaFuncao()
NomeDaFuncao();

//aqui o controle retorna
}

1- A declaração:
A primeira coisa é a declaração da função, com um nome e o tipo à frente, seguido por um conjunto de parenteses de abertura e fechamento.

2- A definição:
A declaração é seguida da definição do que ela faz. Este é o corpo da função que sempre começa com uma chave de abertura e uma chave de fechamento.

3- O retorno:
O corpo da função contem zero ou mais declarações de retorno. O retorno faz o controle voltar para imediatamente depois do ponto onde a função foi chamada.

4- A chamada:
A função é chamada invocando o nome da função seguida por parênteses de abertura e fechamento.

Retorno da Função.
As funções retornam um valor a quem chama.
Para retornar um valor de uma função, é necessário fazer duas alterações:

1°. Substituir void pelo tipo de valor que vc deseja retornar.
2°. Colocar o valor a retornar depois da palavra-chave return. C++ não permite vc retornar sem nada de uma função se o tipo de retorno for diferente de void.

Vamos ver um exemplo:
A função somaSequencia() é chamada repetidamente para somar uma série de números fornecidos pelo usuário, até que o usuário forneça uma sequência de comprimento zero.

------------------------------------------------------------------------------------------------------------
#include&lt;cstdio&gt;
#include&lt;cstdlib&gt;
#include&lt;iostream&gt;
using namespace std;

int somaSequencia()
{
&nbsp;//criamos a variavel que vai armazenar os dados digitados.
&nbsp;int nAcumulador = 0;

&nbsp;//lendo os valores digitados
&nbsp;for(;;)
&nbsp;{
&nbsp; int nValor;
&nbsp; cout &lt;&lt; "Proximo: ";
&nbsp; cin &gt;&gt; nValor;

&nbsp; //saindo do loop quando o valor de alvo for digitado
&nbsp; if(nValor &lt; 0)
&nbsp; {
&nbsp; &nbsp;break;
&nbsp; }

&nbsp; //agora, passamos o valor para o acumulador
&nbsp; nAcumulador += nValor;
&nbsp;}

&nbsp;//aqui retornamos o valor chamado para o acumulador
&nbsp;return nAcumulador;
}

int main(int nNumberofArgs, char* pszArgs[])
{
&nbsp;cout &lt;&lt; "Entre com a sequencia de numeros\n"
&nbsp; &nbsp; &nbsp; &lt;&lt; "Numero negativo encerra o programa\n" ;
for(;;)
{
&nbsp;int nSoma = somaSequencia();
&nbsp;if(nSoma == 0)
&nbsp;{
&nbsp; break;
&nbsp;}
&nbsp;cout &lt;&lt; "Soma = " &lt;&lt; nSoma &lt;&lt; endl;
}
system("pause");
return 0; &nbsp; &nbsp; 
}

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

Como Passar Argumentos para Funções.&nbsp;

Quando a função apenas retorna valor, elas são de valor limitado e a comunicação é de uma via - da função para o chamador. Vamos ver agora a comunicação de duas vias, argumentos de função.



Um argumento de função é uma variável, cujo valor é passado para a função durante a chamada. Vamos converter a operação fatorial do estudo anterior em uma função:



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


#include&lt;cstdio&gt;

#include&lt;cstdlib&gt;

#include&lt;iostream&gt;

using namespace std;



int fatorial(int nAlvo)

{

&nbsp;//Vamos inicializa o acumulador com 1.

&nbsp;int nAcumulador = 1;

&nbsp;for(int nValor = 1; nValor &lt;= nAlvo; nValor++)

&nbsp;{

&nbsp; nAcumulador *= nValor;

&nbsp;}

&nbsp;return nAcumulador;

}

int main(int nNumberofArgs, char* pszArgs[])

{

&nbsp;cout &lt;&lt; "Programa para calculo de fator\n"

&nbsp; &nbsp; &nbsp; &lt;&lt; "Digite um numero negativo para encerrar o programa" &lt;&lt; endl;



for(;;)

{

&nbsp;int nValor;

&nbsp;cout &lt;&lt; "Digite o numero: ";

&nbsp;cin &gt;&gt; nValor;



&nbsp;if(nValor &lt; 0)

&nbsp;{

&nbsp; break;

&nbsp;}

&nbsp;int nFatorial = fatorial(nValor);

&nbsp;cout &lt;&lt; nValor &lt;&lt; " o fator e " &lt;&lt; nFatorial &lt;&lt; endl;

&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&nbsp;

}

system("pause");

return 0;

}


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



Uma função pode ter múltiplos argumentos separados por vírgulas. Ex:.
int produto(int nValor1, int nValor2)
{
&nbsp;retorno nValor1 * nValor2;
}&nbsp;


------------------------------------------------------------------------------------------------------------
A palavra-chave main() do nosso gabarito é uma função. Mesmo com alguns argumentos estranhos ;)
C++ permite designar o mesmo nome a duas ou mais funções, se puderem ser distinguidas pelo nome ou pelo tipo de argumento. Isso é chamado de sobrecarga de funções.