# De Objective Caml para C e C++/Construção de tipos
### Conceitos iniciais

As linguagens C e C++ possuem muitos mecanismos para construir e estruturar dados complexos. Diferentemente dos tipos básicos, onde há uma forte correspondência entre essas linguagens e a linguagem Objective Caml, a construção de tipos complexos em C e C++ é bem diferente daquela provida por Objective Caml. Esse capítulo não aborda a construção de tipos via classes de objetos, que é um paradigma presente nas linguagens Objective Camle e C++, mas que é ausente da linguagem C.
O sistema de tipos de C e C++ é bastante complexo e, em prol da lisibilidade desse texto, algumas aproximações e simplificações foram realizadas. Apresentaremos as seguintes construções para a criação e manipulação de tipos complexos:
* Enumerações correspondem a uma forma muito básica de tipos variantes de Objective Caml.
* Arranjos correspondem aos arranjos de Objective Caml, embora sejam objetos muito mais simples. A linguagem C++ provê, através da sua biblioteca, uma outra implementação de arranjos que tem um nível de abstração mais próximo ao dos arranjos de Objective Caml.
* Registros correspondem aos tipos registros de Objective Caml.
* Ponteiros correspondem às referências de Objective Caml.
* As referências, presentes apenas na linguagem C++, não tem correspondência direta em Objective Caml, embora possam ser simuladas por ponteiros, logo pelas referências de Objective Caml.
* As uniões correspondem aproximadamente aos tipos variantes de Objective Caml, embora não sejam tão práticas para serem manipuladas.
* Enfim, terminaremos com a apresentação dos tipos funcionais, que existem em C e em C++. Embora não sejam tão flexíveis quanto os tipos funcionais de Objective Caml, permitem ainda programação de ordem superior.
Vale destacar que em C e em C++, pode-se dar um nome a um tipo, utilizando a seguinte construção, ou alguma variação:
Por exemplo, podemos definir um tipo chamado inteiro que é idêntico ao tipo básico int com a seguinte construção:
Então a mais simples expressão de tipo que exista é um nome de um tipo básico, ou de outro tipo que já foi definido dessa forma. Uma vez definido um nome para um tipo, ele pode ser usado para declarar variáveis ou funções da mesma forma que os tipos básicos. Por exemplo:
Também pode ser utilizar uma expressão de tipo diretamente na declaração de uma variável. Assim esse código:
é equivalente a

### Enumerações

Com relação ao sistema de tipos de Objective Caml, os tipos enumerados lembram de forma superficial os tipos variantes. Os tipos enumerados são porém muito mais limitados, e correspondem mais precisamente a tipos variantes onde as alternativas devem ser todas constantes.
Um tipo enumerado contem um número finito de valores. Cada valor tem um nome que o identifica. Por exemplo a seguinte definição:
introduz um tipo enumerado, que possui como rótulo Ecor, e três enumeradores, que são valores inteiros constantes com identificadores vermelho, azul, amarelo.
Pode-se dar um nome a esse tipo, utilizando uma definição de tipo:
Em seguida, podemos declarar e utilizar variáveis com esse tipo, e os valores que foram introduzidos na operação podem também aparecer no programa, onde serão consideradas como valores inteiros. Segue um trecho de programa que utiliza a definição acima:
Afirmamos que um valor inteiro é associado a cada valor de uma enumeração. Podemos realizar essa associação de forma implícita ou explícita. A forma explícita é realizada associando o número inteiro na definição da enumeração, como demostrado no seguinte exemplo:
Caso não aparece associação explícita, a associação é realizada de maneira implícita, utilizando as seguintes regras: o primeiro valor da enumeração recebe o valor zero, e um valor que não está na primeira posição é associado com a soma de um com o inteiro associado ao valor anterior.
Finalmente, podemos também misturar as associações explícitas e implícitas, como no seguinte exemplo:
Nesse exemplo, FORMAT_ERROR e TIMEOUT_ERROR denotam respectivamente os inteiros $10$ e $11$.

#### Exercício

Considere o seguinte tipo de dados definido em Objective Caml
Define um tipo equivalente em C/C++.

### Arranjos

A linguagem C permite declarar arranjos uni-dimensionais, dando as seguintes informações: o tipo dos elementos, e o tamanho do arranjo. Por exemplo, o seguinte código define uma variável notas para guardar quatro valores do tipo float, utilizaremos o seguinte código:
Portanto a sintaxe consiste em identificar o tipo dos elementos, através de uma expressão de tipos, o nome do arranjo, e entre colchetes o tamanho do arranjo.
Opcionalmente, podemos associar um valor inicial aos elementos do arranjo assim definido. Há duas possibilidades
* Para definir o mesmo valor em todas as posições do arranjo, colocamos apenas o valor do primeiro elemento. Por exemplo, o código seguinte corresponde à definição de um arranjo similar ao exemplo anterior, mas onde todas as posições do arranjo armazenam o valor $0,0$:
Portanto a sintaxe exige que a expressão de inicialização seja colocada entre chaves.
* Também pode-se definir individualmente cada posição do arranjo. Isso é realizado colocando entre chaves, a enumeração dos valores do arranjo. O exemplo seguinte portanto é equivalente ao anterior:
A sintaxe exige que os elementos da inicialização sejam separados por vírgulas.

#### Operadores sobre arranjos

C e C++ oferecem a possibilidade de acessar cada posição do arranjo individualmente. Como em Objective Caml, o endereço da primeira posição é $0$ e as demais posições são obtidas somando um à anterior. Por exemplo, o código seguinte declara um arranjo e inicializa todas as suas posições em seqüência.
Evidentemente, uma repetição for é uma construção particularmente adequada para percorrer todas as posições de um arranjo. Por exemplo:
Objective Caml possui uma função que, aplicada a um arranjo, retorna o número de posições do arranjo. Isso não existe nem C nem em C++ (C++ tem uma outra implementação de arranjo, chamada vector que tem essa funcionalidade; será apresentada mais adiante). Objective Caml possui também mecanismos para verificar que o acesso aos arranjos é realizado dentro dos limites. C e C++ não oferecem esses mecanismos, e podemos perfeitamente escrever o seguinte programa:
Observe que a função main inclui a definição de uma variável arranjo, com duas posições armazenando valores do tipo int. As posições válidas portanto são $0$ e $1$. O programa realiza um acesso em escrita na posição $2$, portanto fora dos limites e também um acesso em leitura. Utilizando g++ versão 4.0.1, esse programa é compilado sem erro (nem aviso). Ele pode até ser executado! E funciona! Olhe:
Então o programa está correto? Claro que não. Nessa oportunidade ele executou normalmente, mas pode ser que em alguma outra plataforma, tenha um erro em tempo de execução. Nesse exemplo, é bastante fácil detectar esse erro lendo o código, mas em programas mais extensos essa tarefa de verificação por leitura é muito mais difícil.
Esse pequeno programa ilustra uma diferença de filosofia entre as linguagens C e C++ de um lado, e a linguagem Objective Caml do outro. As primeiras privilegiam o desempenho em tempo de execução, mas não oferecem suporte para verificações elementares, criando grandes riscos do que erros passam despercebidos durante muito tempo até eles causarem problemas. Objective Caml, do outro lado, é muito mais rigorosa, e aplica um maior número de regras, tanto em tempo de compilação, quanto em tempo de execução. A implementação em Objective Caml de um dado algoritmo, será mais lenta que a implementação em C ou em C++, mas em compensação, oferecerá muito mais garantias de correção e de segurança.

#### Arranjos como parâmetros de funções

Nas linguagens C e C++, como em Objective Caml, os parâmetros são passados por valor. Isso significa que quando uma função é chamada, as variáveis que correspondem aos parâmetros formais da função comportam se como se fossem variáveis locais ao corpo da função que são inicializadas com o valor dos argumentos que foram utilizados para chamar essa função.
No caso dos arranjos, o parâmetro formal é o mesmo arranjo que o argumento efetivo da chamada da função. O seguinte exemplo ilustra essa particularidade:
A execução desse programa resultará na seguinte impressão na saída padrão
Resumidamente, a explicação disso é que, em C e C++, um arranjo corresponde ao endereço da primeira posição do arranjo. Quando a função swap2 é chamada com o argumento arranjo, o endereço da primeira posição de arranjo é copiada para tab, que passa a ter então a sua primeira posição nesse endereço. Logo tab[0] e tab[1] são respectivamente idênticos a arranjo[0] e arranjo[1].

#### Arranjos como resultados de funções

As linguagens C e C++ não permitem que o tipo de retorno de uma função seja um tipo arranjo. Uma possibilidade para contornar essa limitação é ter um parâmetro a mais que será atualizado no corpo da função. O exemplo seguinte ilustra essa técnica.

#### Um primeiro exemplo

O seguinte programa provê uma implementação em C++ de um algoritmo que calcula e imprime os números primos até um certo valor $n$. Esse algoritmo é conhecido como o crivo de Eratosthenes.
Observe que o exemplo inclui uma função tal que um dos parâmetros é um arranjo de booleanos.
Detalhes sobre o crivo podem ser obtidos em: Weisstein, Eric W. "Sieve of Eratosthenes." From MathWorld--A Wolfram Web Resource. http://mathworld.wolfram.com/SieveofEratosthenes.html

#### Arranjos multi-dimensionais

Como em Objective Caml, um arranjo de dimensão $n$ de valores de um tipo t podem ser implementados em C e em C++ usando um arranjo de arranjos de dimensão $n-1$ de valores do tipo t.
Uma matriz bi-dimensional de inteiros, de dimensão $n$ por $m$, pode então ser declarada como:

#### Um segundo exemplo
### Tipos registros

Os tipos registros de C/C++ são essencialmente idênticos aos de Objective Caml: é um forma de agregar um número fixo de valores de diferentes tipos. Esses valores são chamados campos do registro. Cada campo possui um nome que o identifica e um tipo que especifica quais valores ele pode ter. Vamos agora ver a sintaxe em C/C++ através de um exemplo.
Considere o seguinte tipo registro (em OCaml):
Em C/C++, o equivalente é
Pode-se acessar aos campos utilizando um operador que tem a mesma sintaxe que o de Objective Caml. Assim, caso desejarmos definir uma função que calcula a distância entre dois pontos dados, podemos escrever:
C/C++ diferem de Objective Caml na forma de denotar valores de um tipo registro. Enquanto que em Objective Caml tem que explicitamente associar a cada nome um valor, em C/C++ essa associação é feita pela posição. Uma outra diferença sútil é que os valores dos diferentes campos devem ser separados por vírgulas (é um ponto e vírgula em Objective Caml). Assim, o exemplo seguinte lembra como pode-se escrever um valor de um tipo registro em Objective Caml.
O equivalente em C/C++ seria:
[[[ ADICIONAR UM PARÁGRAFO SOBRE PONTEIROS PARA REGISTROS ]]]

### Ponteiros
#### Introdução

Uma variável C/C++ é a abstração de um trecho de memória que guarda um valor de um certo tipo, onde um trecho de memória é uma seqüëncia de posições contíguas na memória. Um trecho de memória é definido pelo endereço da primeira posição e o número de posições no trecho. Mais precisamente, qualquer lvalue (variável, campo de variável de tipo registro, posição de variável de tipo arranjo) é a abstração de um trecho de memória. Na seqüência, empregaremos o termo variável ao invés de lvalue.
Para cada variável, o compilador deve associar algum trecho de memória para aquela variável. Para evitar qualquer problema de superposição e conflito, se o escopo de duas variáveis tem alguma interseção, os trechos de memória aos quais essas variáveis correspondem devem ser disjunAssim, uma variável de tipo long long int vai corresponder a um trecho de oito bytes na memória. O tamanho do tipo vai então depender diretamente do tipo de dados a ser representado. Por exemplo, quando temos um tipo registro, o tamanho de memória necessário para a representação de valores desse tipo é a soma dos tamanhos para representar cada campo do registro. Quando temos um tipo arranjo, o tamanho de memória necessário é igual a produto do número de elementos do arranjo com o tamanho necessário para armazenar cada elemento do arranjo.
As linguagens C e C++ possuem um operador unário, prefixado, nomeado sizeof que, aplicado a uma variável, ou a uma expressão de tipo (entre parênteses), retorna o tamanho em bytes do trecho de memória necessário para representar essa variável, ou valores do dado tipo. O pequeno programa seguinte ilustra os conceitos discutidos:
A execução desse programa resulte na seguinte impressão na saída padrão:

#### O operador de endereço

Em C e C++, há um operador que permite saber qual o endereço do trecho de memória associado a uma variável: é o operador &. É um operador unário, e é prefixado. Segue um pequeno programa que ilustra o uso desse operador.
Observe que foi usada a diretiva de formatação %p para imprimir um endereço. A execução desse programa resulte na seguinte impressão na saída padrão:
Algumas observações devem ser feitas:
* os endereços são impressos em base hexadecimal.
* em um registro, campos sucessivos ficam em endereços sucessivos
* o endereço de um registro é o mesmo endereço do primeiro campo do registro
* em um arranjo, posições sucessivas ficam em endereços sucessivos
* o endereço de um arranjo é o mesmo endereço da primeira posição
* um arranjo nada mais é que o endereço da primeira posição desse arranjo (como discutimos no parágrafo sobre arranjos como parâmetros de funções).
O leitor atento e curioso pode então fazer a seguinte pergunta. No programa exemplo, quando aplico o operador de endereço a uma variável ou a qualquer lvalue, qual é o tipo dessa expressão? A resposta é que trata-se de um tipo ponteiro, para o qual reservamos o parágrafo seguinte.

#### Os tipos ponteiros

O conceito de ponteiro é fundamental em programação. Um valor de algum tipo ponteiro é o (endereço de) um trecho de memória que corresponde a alguma variável. Portanto um ponteiro é algo que indica onde fica algo, digamos então que aponta para algo. Se uma variável v tem o tipo t, a expressão &v é portanto uma expressão de tipo ponteiro para t, que é denotada t * (é o mesmo símbolo que o da multiplicação aritmética).
A sintaxe para declarar uma variável de um tipo ponteiro é a seguinte:
Nesse caso, nome é o nome da variável, e tipo é o tipo do valor que está na locação de memória apontada. Assim, o trecho de código seguinte fornece exemplos de uso dessa sintaxe:
Foram declaradas três variáveis:
* A variável a é um ponteiro para um trecho de memória que guarda um valor do tipo int. Observe que não tem inicialização e o valor de a é qualquer. Como uma variável de qualquer tipo, a variável a deverá ser inicializada antes de ser lida, caso contrário o comportamento do programa é indefinido.
* A variável x é uma variável não ponteiro, do tipo float.
* A variável pf é uma variável de tipo ponteiro para float, ou float *. É inicializada com o endereço da variável x. Diz-se que pf aponta para x.
Oo símbolo * é associado a nome e não a tipo. Assim, se quisermos declarar mais de um ponteiro para o mesmo tipo de uma vez só, devemos repetir * antes de cada nome. Por exemplo:

##### Ponteiros e Objective Caml

Em Objective Caml, um conceito similar, embora mais geral, é o de referência. O conceito de referência OCaml corresponde ao de uma variável C/C++ e também ao de ponteiro. Assim, em OCaml, um valor de tipo int ref é alguma locação de memória que contem um valor do tipo int e que pode ser alterado (dizemos que é mutável). Ou seja é exatamente a mesma coisa que uma variável C ou C++ do tipo int. Tal variável pode ser lida em expressões e alterada com atribuições. O equivalente a um ponteiro C para um inteiro, ou seja a um valor do tipo int * seria, em OCaml, um valor do tipo int ref ref: corresponde à memorização de um local onde um inteiro é memorizado.

#### O operador de dereferenciamento

Dado um valor de algum tipo ponteiro, o operador de dereferenciamento permite acessar o valor do trecho de memória apontado. É um operador prefixado, que se escreve *. Se p é um valor de tipo t * (ponteiro para o tipo t), então a expressão * p é do tipo t. O valor dela é o valor guardado na memória no endereço guardado por p. Por exemplo, o seguinte trecho de código
resultará na impressão da seguinte mensagem na saída padrão:
O resultado do operador de referenciamento é um lvalue, significando que pode ser alvo de atribuição. Atribuir um valor a * p consiste em alterar o conteúdo do trecho de memória apontado por p. Por exemplo: