\b;Funções
Função, em termos simples, é uma instrução criada por você.

\b;Função principal
Você provavelmente já sabe como criar uma função. Todo programa em CBOT deve ter uma função principal, que parece como isto:
\c;
\s;extern void object::NomePrograma()
\s;{
\s;	
\s;	// instruções
\s;	
\s;}
\n;
Nada além de um nome pode ser alterado na função principal. A palavra-chave \c;\l;extern\u cbot\extern;\n; distingue a função principal das outras.

\b;Uso básico
Com funções você pode dividir seu programa em diversas partes. Cada uma delas executará uma tarefa especifica. Por exemplo, veja o programa abaixo:
\c;
\s;extern void object::Remoto()
\s;{
\s;	send("ordem", 1, 100);
\s;	wait(5);
\s;	send("ordem", 3, 100);
\s;	wait(5);
\s;	send("ordem", 2, 100);
\s;	wait(5);
\s;	send("ordem", 4, 100);
\s;	wait(5);
\s;}
\n;
\c;\l;send\u cbot\send;\n; e \c;\l;wait\u cbot\wait;\n; são repetidos diversas vezes. Então seria uma boa ideia se nós criassemos uma função que executa estas duas instruções:
\c;
\s;void EnviarParaPosto(float op)
\s;{
\s;	send("ordem", op, 100);
\s;	wait(5);
\s;}
\s;
\s;extern void object::Remoto()
\s;{
\s;	EnviarParaPosto(1);
\s;	EnviarParaPosto(3);
\s;	EnviarParaPosto(2);
\s;	EnviarParaPosto(4);
\s;}
\n;
Agora o programa está muito mais fácil para ler. É uma boa prática dividir o programa em várias instruções com nomes autodescritivos.

\b;Sintaxe
\c;
\s;tipo_resultado NomeFuncao(parametros_opcionais)
\s;{
\s;	Corpo
\s;}
\n;
O \l;tipo\u cbot\type; do resultado deve ser \l;void\u cbot/void; se a função não retornar nada. Corpo é apenas um conjunto de intruções. Nome da função deve criado com as mesmas regras aplicadas para \l;variáveis\u cbot\var;.

\t;Parâmetros
Uma função pode ter parâmetros:
\c;
\s;void Exemplo(int a, float x, string s)
\s;{
\s;	message(a);
\s;	message(x);
\s;	message(s);
\s;}
\n;
A função  \c;Exemplo\n; irá receber um \l;inteiro\u cbot\int; \c;a\n;, um \l;número de ponto flutuante\u cbot\float; \c;x\n; e uma \l;cadeia de carácteres\u cbot\string; \c;s\n;. Parâmetros são "passados por valor", isto é, o valor das variáveis de parâmetro em uma função são cópias dos valores que a chamada especificou como variáveis. Se você passar um \c;\l;int\u cbot\int;\n; para uma função, seus parâmetros serão uma cópia de qualquer valor que está sendo passado como argumento, e a função pode alterar seu parâmetro sem afetar os valores no código que invocou a função.

Se você passar uma instância de uma \l;classe\u cbot\class; ou uma \l;matriz\u cbot\array; para uma função, a função somente recebe uma \l;referência\u cbot\pointer; para a instância ou a matriz. Isto significa que se você modificar a instância ou a matriz na função, a instância ou a matriz que foi passada na chamada também será modificada.

\t;Resultado
Uma função também pode retornar um resultado com a instrução  \c;\l; return\u cbot\return;\n;. Entretando a função não deve ser declarada como \c;\l; void\u cbot\void;\n;, mas sim com outro \l;tipo\u cbot\type;:
\c;
\s;float Media(float a, float b)
\s;{
\s;	return (a+b)/2;
\s;}
\s;
\s;extern void object::Teste( )
\s;{
\s;	float valor;
\s;	valor = Media(2, 6);
\s;	message(valor);  // irá exibir 4
\s;}
\n;
Alguns outros exemplos:
\c;
\s;float Pi()
\s;{
\s;	return 3.1415;
\s;}
\s;
\s;string Sinal(float a)
\s;{
\s;	if (a > 0)  return "positivo";
\s;	if (a < 0)  return "negativo";
\s;	return "null";
\s;}
\n;

\b;Sobrecarregar
Você pode declarar várias funções com o mesmo nome, porém com parâmetros diferentes:
\c;
\s;float Pitagoras(float a, float b)
\s;{
\s;	return sqrt((a*a)+(b*b));
\s;}
\s;
\s;float Pitagoras(float a, float b, float c)
\s;{
\s;	return sqrt((a*a)+(b*b)+(c*c));
\s;}
\n;
CBOT irá chamar uma ou outra função dependendo dos parâmetros passados. Eles devem ser distinguíveis, isto é, você não pode declarar duas funções com o mesmo nome e tipos de parâmetros com a mesma ordem, por exemplo, declarar \c;int Pitagoras(float b, float a)\n; irá resultar em erro. Note que o tipo de resultado não faz diferença.

\b;Funções públicas
Você também pode declarar uma função \l;public\u cbot\public;, desta forma ela poderá ser usada por outros robôs.

\b;object::
Declarar uma função como parte do espaço de nomes \l;object\u cbot\object; da acesso ao \l;ponteiro\u cbot\pointer; \c;\l;this\u cbot\this;\n;, em outras palavras, a todas as propriedades disponíveis do robô que está rodando o programa.
\c;
\s;void object::Exemplo()
\s;{
\s;	message(this.category);
\s;}
\n;

\b;Parâmetros padrões
Os últimos parâmetros de uma função podem ter valores padrões, permitindo a omissão dos mesmos quando a função for chamada.
\c;
\s;float adicionar(float a = 0.0, float b = 0.0)
\s;{
\s;	return a + b;
\s;}
\s;
\s;// Em algum lugar do programa principal...
\s;adicionar(); // Irá retornar 0.0
\s;adicionar(2.0); // Irá retornar 2.0
\s;adicionar(2.0, 3.0); // Irá retornar 5.0
\s;// ...
\n;

\t;Parâmetros padrões e sobrecarregamento
Funções com parâmetros padrões ainda podem ser sobrecarregadas, só é preciso garantir que as chamadas as funções não são ambíguas. Por exemplo, considere o seguinte código:
\c;
\s;float adicionar(float a = 0.0, float b = 0.0)
\s;{
\s;	return a + b;
\s;}
\s;
\s;string adicionar(string a = "", string b = "")
\s;{
\s;	return a + b;
\s;}
\s;
\s;// Em algum lugar do programa principal...
\s;adicionar(); // Erro de compilação: chamada ambígua
\s;adicionar(""); // Ok
\s;adicionar(0.0); // Ok
\s;// ...
\n;
Note que no exemplo acima o sobrecarregamento torna o primeiro parâmetro padrão inútil, já que ao chamar a função ele deve ser informado para que as duas funções possam ser distinguidas.

\t;Veja também
\l;Programação\u cbot;, \l;tipos\u cbot\type; e \l;categorias\u cbot\category;.
