De Objective Caml para C e C++/Variáveis e funções

Variáveis

A definição de uma variável faz-se com a seguinte sintaxe:

tipo nome = valor;

onde tipo é uma expressão que define o tipo da variável, nome é o nome da variável, e valor é uma expressão que define o valor inicial da variável. Diferente de Objective Caml, não é obrigatório associar um valor inicial a uma variável e a seguinte sintaxe também é legal:

tipo nome;

Seguem então alguns exemplos:

char c = 'a';
int i = 0;
long long num;

Na primeira linha, é definida uma variável, cujo nome é c, o tipo é char e que tem como valor inicial 'a'. Na segunda linha, é definida uma variável nomeada i, de tipo inteiro, cujo valor inicial é 0. Enfim, na terceira linha, é definida uma variável de nome num, de tipo long long, e cujo valor é qualquer.

Pode se definir múltiplas variáveis do mesmo tipo, separando seus nomes por vírgulas. Assim, na linha seguinte, são definidas três variáveis inteiras, chamadas respectivamente i, j, e k, onde apenas j possui um valor inicial, que é 2.

int i, j = 2, k;

Funções

A definição de uma função faz-se com a seguinte sintaxe:

tipo nome (parametros)
corpo

onde tipo é o tipo de retorno da função, nome é o nome da função, parametros é a lista de parâmetros da função e corpo é um bloco de instruções.

argumentos é uma lista de declarações de parâmetros separadas por vírgulas. Essa lista pode ser vazia, quando a função não possui nenhum parâmetro. Cada parâmetro é declarado com seu tipo e o seu nome.

corpo é um bloco, entre símbolos de chaves de instruções C/C++. Veremos mais adiante quais construções podemos utilizar, por enquanto basta saber que um bloco pode conter declarações de variáveis e instruções algorítmicas similares aquelas da linguagem Objective Caml (atribuição de variável, chamada de função, construções condicionais e repetitivas). Uma diferença significativa é que um bloco C ou C++ não pode conter a definição de uma função, portanto não existe o conceito de uma função local a outra função.

Segue agora um exemplo completo de uma função:

int square (int n)
{
  return n * n;
}

Parâmetros opcionais

A linguagem C++ oferece algumas facilidades relacionadas aos parâmetros que não existem na linguagem C. Assim, é possível dar um valor defaut a alguns parâmetros de uma função. Vejamos isso com base um exemplo:

int f (int a, int b = 0)
{
  return a + b;
}

int g (int k)
{
  return f (k);
}

A função f possui dois parâmetros, porém o segundo (nomeado b) é opcional. Quando a função f é chamada dentro da função g, o parâmetro opcional recebe o valor defaut especificado na definição da função, $0$ no caso desse exemplo. O mecanismo de associação entre parâmetros efetivos e parâmetros formais é realizado da esquerda para a direita. Quando o número de parâmetros efetivos é menor que o número de parâmetros formais, esses últimos recebem o valor defaut especificado na definição da função. Se não houver valor defaut especificado, então ocorrerá um erro na compilação.

Considere agora o seguinte programa:

#include <iostream>
using namespace std;
int f2 (int a = 1, int b = 2, int c = 3)
{
  return a * b * c;
}
int main g()
{
  cout << f2() << endl;
  cout << f2(5) << endl;
  cout << f2(5, 10) << endl;
  cout << f2(5, 10, 15) << endl;
  return 0;
}

A saída será:

6
30
150
750

Na primeira chamada, não há parâmetros efetivos, logo os parâmetros formais receberão seu valor defaut e o resultado é $1\times 2\times 3=6$. Na segunda chamada, há um parâmetro efetivo, que será associado ao primeiro parâmetro formal, e o resultado é $5\times 2\times 3=30$. Na terceira chamada, há dois parâmetros efetivos, que serão associados aos dois primeiros parâmetros formais, e o resultado é $5\times 10\times 3=150$. Na quarta e última chamada, há trˆ´s parâmetros efetivos, que são associados aos parâmetros formais, e o resultado é $5\times 10\times 15=750$.

Vale salientar que uma função pode ter um número qualquer de parâmetros opcionais, mas eles devem aparecer nas últimas posições da lista de parâmetros. Assim a seguinte definição de função é ilegal:

int uma_funcao_mal_definida (int a = 0, int b)
{
  return a + b;
}

Sobrecarga

Em c++ é possivel fazer com que duas ou mais funções diferentes tenham o mesmo nome desde que tenham parâmetros diferentes e isso é chamado de sobrecarga de função por exemplo:

# include <iostream>
# include <string>
using namespace std;
int soma (int a,int b)
 {
  return a + b;
 }
float soma (float a,float b)
 {
  return a + b;
 }
string soma (char a,char b)
{
 return a + b;
} 

Nenhuma dessas três funções soma seria sobreescrevida ou ocorreria um erro pois todas possuem paramentros diferentes e para chama-las é necessário apenas colocar os parâmetros correspondentes por exemplo:

soma (a,b);

Isso chamaria a terceira função de soma que tem como parâmetros dois caracteres.