De Objective Caml para C e C++/Construção de tipos: diferenças entre revisões
[edição não verificada] | [edição não verificada] |
Linha 1: | Linha 1: | ||
===Conceitos iniciais=== |
===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. |
|||
===Tipos enumerados [[Imagem:2de8.png]]=== |
===Tipos enumerados [[Imagem:2de8.png]]=== |
Revisão das 18h20min de 1 de agosto de 2007
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.
Tipos enumerados Ficheiro:2de8.png
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:
enum Ecor {vermelho, azul, amarelo};
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:
typdef enum Ecor {vermelho, azul, amarelo} Tcor;
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:
void imprime_cor_em_ingles (Tcor c) // o parâmetro poderia também ter sido declarado como enum Ecor c { switch (c1) { case vermelho: printf("red"); break; case azul: printf("blue"); break; case vermelho: printf("amarelo"); break; } }
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:
enum Edirecao { norte = 0; oeste = 90; sul = 180; leste = 270 };
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:
enum Ecodigo { NO_ERROR = 0; IO_ERROR = 10; FORMAT_ERROR; TIMEOUT_ERROR };
Nesse exemplo, FORMAT_ERROR e TIMEOUT_ERROR denotam respectivamente os inteiros e .
Tipos arranjos
Tipos registros
Um tipo em c++ é parecido com o tipo registro em ocaml e sua sintaxe è:
struct NOME { Corpo };
Onde NOME é o nome do tipo a ser criado e Corpo será oque ele deverá armazenar exemplo:
struct ponto { int x; int y; }
Isso criaria um tipo ponto que armazanaria 2 valores inteiros e equivaleria ao seguinte codigo escrito em ocaml:
type ponto = { x : int ; y : int };;
E para acessar os campos é a mesma coisa que em ocaml nome do tipo seguido do campo exemplo :
ponto a; a.x = 3; a.y = 4;
Isso faria uma varivel a do tipo ponto com x = 3 e y = 4.