Curso completo de linguagem C++
Gameprog - Escola de programação de jogos digitais
Contato: gameprog.br@gmail.com
track05.html
05.Funções
5.1 Funções com valores default
// valor_default.cpp
// Demonstra valores default em funções
#include <iostream>
using namespace std;
void carregar_tela (int nfase = 1, int nvidas = 5);
int main()
{
system("color f0"); system ("title valor default");
carregar_tela();
carregar_tela(3);
carregar_tela(5,10);
cout << "\n"; system("pause");
} // endmain
void carregar_tela(int nfase, int nvidas) {
cout << "\n";
cout << "\t A fase " << nfase << " foi carregada.";
cout << " Vc tem " << nvidas << " vidas.\n";
} // endfunction: carregar_tela()
Vc pode definir funções com valores default, isto é, valores que os argumentos
vão assumir automaticamente quando seus valores não forem passados na chamada
à função.
Exemplo:
void carregar_tela (int nfase = 1, int nvidas = 5);
carregar_tela();
carregar_tela(3);
carregar_tela(3,10);
Ao definir valores default, vc deve definir sempre valores para os argumentos
mais à direita da função. No exemplo acima, vc poderia definir isoladamente
valor default para nvidas, mas não poderia definir para nfase apenas.
Os valores default são definidos apenas no protótipo da função.
5.2 Funções sobrecarregadas (function overload)
// fn_overload.cpp
// Demonstra sobrecarregamento de funções ( function overload )
#include <iostream>
#include <string>
using namespace std;
// **************** protótipos das funções
void diga (int nval);
void diga (float nval);
void diga (string txt, int nval);
int main() {
system("color f0"); system ("title function overload");
int x = 320;
float npi = 3.1415f;
int energia = 99;
string msg = "\t Quantidade de energia: ";
cout << "\n";
diga(x);
diga (npi);
diga (msg, energia);
cout << "\n"; system("pause");
} // endmain
// **************** funções
void diga (int nval) {
cout << "\t Argumento inteiro: " << nval << "\n";
} // endfunction: diga(int)
void diga (float nval) {
cout << "\t Argumento float: " << nval << "\n";
} // endfunction: diga (float)
void diga (string txt, int nval) {
cout << txt << nval << "\n";
} // endfunction: diga (string, int)
void diga (int nval);
void diga (float nval);
void diga (string txt, int nval);
Sobregamento de funções (function overload) significa vc definir várias funções
com o mesmo nome, porém com assinaturas diferentes, isto é, os argumentos ou
a quantidade de argumentos são diferentes. Com base na quantidade ou diferença
dos argumentos, o compilador sabe então que função chamar.
5.3 Função genérica ( generic programming )
// fn_generica.cpp
// Demonstra o uso de funções genéricas
#include <iostream>
#include <string>
using namespace std;
// protótipo das funções genéricas
template <typename tipo_geral> void diga (tipo_geral nval);
template <typename tipo_geral>
void diga (string txt, tipo_geral nval);
int main() {
system("color f0"); system ("title fn_generica.cpp");
int x = 320;
float npi = 3.1415f;
int energia = 99;
string msg = "\t Quantidade de energia: ";
cout << "\n";
diga(x);
diga (npi);
diga ("Teste com string \n");
diga (msg, energia);
diga ("\t npi: ", npi);
cout << "\n"; system("pause");
} // endmain
//******************* implementação das funções genéricas
template <typename tipo_geral>
void diga (tipo_geral nval) {
cout << "\t Argumento: " << nval << "\n";
} // endfunction: diga(tipo_geral)
template <typename tipo_geral>
void diga (string txt, tipo_geral nval) {
cout << txt << nval << "\n";
} // endfunction: diga (string, tipo_geral)
No subtópico anterior nós criamos algumas versões da função diga()
apenas para mostrar um dado na tela, mudando apenas o tipo de dado
para cada versão dessa função. Normalmente você teria que sobrecarregar
a função para cada tipo de dado tal como fizemos acima, entretanto com
os recursos de programação genérica do c++ vc pode economizar esse
trabalho de repetição de código que traz diferença apenas no tipo de
dado.
template <typename tipo_geral> void diga (tipo_geral nval);
Com esta linha de código nós dizemos que a função diga() é um modelo de
função genérica e para cada tipo diferente de dado com o qual esta função
for chamada, o compilador criará a versão adequada dessa função.
Para criar uma função genérica, primeiro vc define um nome para o tipo de
dado geral com esta sintaxe:
template <typename nome_do_tipo_geral>
Depois é só vc criar a função usando esse tipo de dado na declaração do
tipo dos argumentos da sua função:
tipo_de_retono função_nome (nome_do_tipo_geral nval);
5.4 Considerações finais desse tópico
Vc poderá usar esses conceitos de funções com valor default, funções
sobrecarregadas e funções genéricas com os métodos das classes que
vc criar.
5.5 Considerações finais desse tópico
Pode ocorrer de existir uma variável local dentro de uma função com o
mesmo nome de uma variável global definida no topo do programa. Nesse
caso a variável local esconde a variável global. Nessa condição para
chamar a variável global é necessário anexar ao nome da variável o
operador de resolução (::) para indicar o uso de uma variável global.
Veja esse programa exemplo que ilustra isso:
// globvars.cpp
// Demonstra o acesso a variáveis globais homônimas às locais
#include <iostream>
using namespace std;
// Variável global
int contador = 30;
int main() {
system("color f0"); system ("title globvars.cpp");
// Variável local
int contador = 0;
cout << "\n Var. contador local - var. contador global" << endl;
cout << " ------------------------------------------------" << endl;
for (contador =1; contador <=7; contador++)
{
cout << " contador: " << contador << "\t\t - ";
cout << "::contador: " << ::contador << endl;
}
cout << "\n";
cout << "\n"; system("pause");
} // endmain