Funções, vamos declarar!

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()
{
 // código aqui...
 return;
}
int mains(int nNumberofArgs, char* pszArgs[])
{
 //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<cstdio>
#include<cstdlib>
#include<iostream>
using namespace std;

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

 //lendo os valores digitados
 for(;;)
 {
  int nValor;
  cout << "Proximo: ";
  cin >> nValor;

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

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

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

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

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

Como Passar Argumentos para Funções. 

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

#include<cstdlib>

#include<iostream>

using namespace std;

int fatorial(int nAlvo)

{

 //Vamos inicializa o acumulador com 1.

 int nAcumulador = 1;

 for(int nValor = 1; nValor <= nAlvo; nValor++)

 {

  nAcumulador *= nValor;

 }

 return nAcumulador;

}

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

{

 cout << "Programa para calculo de fator\n"

      << "Digite um numero negativo para encerrar o programa" << endl;

for(;;)

{

 int nValor;

 cout << "Digite o numero: ";

 cin >> nValor;

 if(nValor < 0)

 {

  break;

 }

 int nFatorial = fatorial(nValor);

 cout << nValor << " o fator e " << nFatorial << endl;

                

}

system("pause");

return 0;

}

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

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

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