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