Propriedades

Todo tipo e expresão possui propriedades que podem ser usadas:

Expressão	Valor
int.sizeof	rende 4
float.nan	rende o valor nan (Not A Number) do número real
(float).nan	rende o valor nan do número real
(3).sizeof	rende 4 (pois 3 é umn int)
2.sizeof	erro de sintaxe, já que "2." é um número real
int.init	inicializador padrão para int's
int.mangleof	rende a string "i"

Propriedades para Todos os Tipos

Propriedade	Descrição
.init	inicializador
.sizeof	tamanho em bytes (equivalente ae sizeof(tipo) do C)
.alignof	tamanho do alinhamento
.mangleof	string representando a representação 'estraçalhada' do tipo

Propriedades para Tipos Inteiros

Property	Description
.init	inicializador (0)
.max	valor máximo
.min	valor mínimo

Prorpiedades para Tipos Reais

Propriedade	Descrição
.init	inicializador (NaN)
.infinity	valor infinito
.nan	NaN valor
.dig	número de dígitos decimais de precisão
.epsilon	menor incremento para o valor 1
.mant_dig	número de bits na mantissa
.max_10_exp	máximo valor int em que 10^max_10_exp é representável
.max_exp	máximo valor int em que 2^max_exp-1 é representável
.min_10_exp	mínimo valor int em que 10^min_10_exp é representável como um valor normalizado
.min_exp	mínimo valor int em que 2^min_exp-1 é representável como um valor normalizado
.max	maior valor representável que não é infinito
.min	menor valor representável normalizado que não é 0
.re	parte real
.im	parte imaginária

Propriedade .init

.init produz uma expressão constante que é o inicializador padrão. Se aplicado a um tipo, é o inicializador padrão para esse tipo. Se aplicado a uma variável ou campo, é o inicializador padrão para essa variável ou campo. Por exemplo:

int a;
int b = 1;
typedef int t = 2;
t c;
t d = cast(t)3;

int.init // é 0
a.init // é 0
b.init // é 1
t.init // é 2
c.init // é 2
d.init // é 3

struct Foo
{
 int a;
 int b = 7;
}

Foo.a.init // é 0
Foo.b.init // é 7

Propriedades de Classes e Estruturas

Propriedades são funções membro que podem ser tratadas sintaticamente como se fossem campos. Propriedades podem ser de leitura ou escrita. Uma propriedade é lida chamando um método com nenhum argumento; uma propriedade é escrita chamando um método com seu argumento sendo o valor a a ser ajustado.

Uma propriedade simples seria:

struct Foo
{
 int data() { return m_data; } // propriedade de leitura

int data(int value) { return m_data = value; } // propriedade de escrita

private:
 int m_data;
}

Para usar:

int test()
{
 Foo f;

 f.data = 3; // o mesmo que f.data(3);
 return f.data + 3; // o mesmo que return f.data() + 3;
}

A ausência de um método de leitura significa que a propriedade é somente escrita. A ausência de uma propriedade de escrita significa que a propriedade é somente leitura. Múltiplas propriedades de escrita podem existir; a correta é selecionada usando as regras de sobrecarga de função costumeiras.

Em todos os outros aspectos, esses métodos são como qualquer outro método. Podem ser estáticos, ter linkagens diferentes, ser sobrecarregados, com métodos com múltiplos parâmetros, ter seu endereço tomado, etc.

Nota: Propriedade atualmente não podem ser o lvalue de um operador op=, ++, or --.