Tipos

Tipos de Dados Básicos

Palavra chave	Descrição	Inicializador Padrão (.init)
`void`	nenhum tipo	-
`bool`	valor booleano	false
`byte`	8 bits com sinal	0
`ubyte`	8 bits sem sinal	0
`short`	16 bits com sinal	0
`ushort`	16 bits sem sinal	0
`int`	32 bits com sinal	0
`uint`	32 bits sem sinal	0
`long`	64 bits com sinal	0L
`ulong`	64 bits sem sinal	0L
`cent`	128 bits com sinal (reservado para uso futuro)	0
`ucent`	128 bits sem sinal (reservado para uso futuro)	0
`float`	número real de 32 bits	float.nan
`double`	número real de 64 bits	double.nan
`real`	maior tamanho de número real implemenado pelo hardwre (Nota de Implementação: 80 bits para CPUs Intel)	real.nan
`ifloat`	float imaginário	float.nan * 1.0i
`idouble`	double imaginário	double.nan * 1.0i
`ireal`	real imaginário	real.nan * 1.0i
`cfloat`	um número complexo de dois valores float	float.nan + float.nan * 1.0i
`cdouble`	double complexo	double.nan + double.nan * 1.0i
`creal`	real complexo	real.nan + real.nan * 1.0i
`char`	8 bits sem sinal UTF-8	0xFF
`wchar`	16 bits sem sinal UTF-16	0xFFFF
`dchar`	32 bits sem sinal UTF-32	0x0000FFFF

Tipos de Dados Derivados

ponteiro
array
array associativo
função
delegado

Tipos definidos pelo usuário

apelido
typedef
enum
estrutura
união
classe

Conversões de Ponteiros

Moldar ponteiros em não-ponteiros e vice versa é permitido em D, porém, não faça isso para qualquer ponteiro que aponte para dados alicados pelo coletor de lixo.

Conversões Implícitas

D possui muitos tipos, nativos e derivados. Seria tedioso precisar de moldes para toda conversão de tipo, então conversões implícitas acertam em controlar o óbvio automaticamente.

Um typedef pode ser implicitamente convertido para seu tipo de origem, mas indo pelo outro caminho requer uma conversão explícita. Por exemplo:

typedef int myint;
int i;
myint m;
i = m; // OK
m = i; // erro
m = cast(myint)i; // OK

Promoções de Inteiros

Promoções de Inteiros são conversões dos seguintes tipos:

de	para
bool	int
byte	int
ubyte	int
short	int
ushort	int
char	int
wchar	int
dchar	uint

Se um typedef ou enum tem como tipo base um dos tipos na coluna da esquerda, é convertido para o tipo da coluna da direita.

Conversões Aritméticas Costumeiras

As conversões aritméticas costumeiras convertem operandos de operadores binários para um tipo comum. Os operandos já devem ser tipos aritméticos. As seguintes regras são aplicadas na ordem, olhando para os tipos base (olhando typedefs passados):

Se qualquer operando for real, o outro operando é convertido para real.
Senão, se qualquer operando for double, o outro operando é convertido para double.
Senão, se qualquer operando for float, o outro operando é convertido para float.
Senão as promoções de inteiros são feitas em cada operando, seguidas por:
1. Se ambos os forem do mesmo tipo, nenhuma outra conversão é feita.
2. Se ambos têm sinal ou ambos não têm sinal, o tipo menor é convertido para o tipo maior.
3. Se o tipo com sinal é maior que o tipo sem sinal, o tipo sem sinal é convertido para o tipo com sinal.
4. O tipo com sinal é convertido para o tipo sem sinal.

Se um ou ambos os tipos dos operandos forem um typedef após realizar as conversões acima, o tipo resultante será:

Se os operandos forem do mesmo tipo, o resultado será esse tipo.
Se um operando for um typedef e o outro for do tipo base desse typedef, o resultado será o tipo base.
Se os dois operandos forem typedefs diferentes mas do mesmo tipo base, então o resultado será esse tipo base.

Valores inteiros não podem ser implicitamente convertidos para outro tipo que não possa representar o bit de paridade do inteiro após a promoção de inteiros. Por exemplo:

ubyte u1 = cast(byte)-1; // erro, -1 não pode ser representado em ubyte
ushort u2 = cast(short)-1; // erro, -1 não pode ser representado em ushort
uint u3 = cast(int)-1; // ok, -1 pode ser representado em um uint
ulong u4 = cast(ulong)-1; // ok, -1 pode ser representado em um ulong

Números reais (de ponto flutuante) não podem ser implicitamente convertidos para tipos inteiros.

Números complexos não podem ser implicitamente convertidos para números reais não-complexos.

Números imaginários não podem ser implicitamente convertidos para números reais. Números reais não podem ser implicitamente convertidos para números imaginários.

bool

O tipo bool é um tipo de 1 byte que só pode ter o valor true ou false. Os únicos operadores que podem aceitar operandos do tipo bool são: & | ^ &= |= ^= ! && || ?:. Um valor bool pode ser implicitamente convertido para um inteiro, com false sendo 0 e true sendo 1. Os literais numéricos 0 e 1 podem ser implicitamente convertidos para os valores bool false e true, respectivamente. Moldar uma expressão para bool quer dizer testar por 0 ou !=0 para tipos aritméticos, e null ou !=null para ponteiros e referências.

Delegados

Não há ponteiros para membros em D, mas um conceito mais útil chamado delegados é suportado. Delegados são um agregado de dois pedaços de dados: uma referência de objeto e um ponteiro para função. A referência do objeto forma o ponteiro this quando a função é chamada.

Delegados são declarados semelhantemente aos ponteiros para função, exceto que a palavra delegate toma o lugar do (*), e o identificador vem depois:

int function(int) fp; // fp é um ponteiro para uma função
int delegate(int) dg; // dg é um delegado para uma função

A sintaxe estilo C para declarar ponteiros para função também é suportada:

int (*fp)(int); // fp é um ponteiro para uma função

Um delegado é inicialisado analogamente aos ponteiros para função:

int func(int);
fp = &func; // fp aponta para func

class OB
{ int member(int);
}
OB o;
dg = &o.member; // dg é um delegado para o objeto o e
 // a função membro member

Delegados não podem ser inicializados com funções membro estáticas ou funções não-membro.

Delegados são chamados analogamente aos ponteiros para função:

fp(3); // chama func(3)
dg(3); // chama o.member(3)