Atributos

AttributeSpecifier:
 Attribute :
Attribute DeclarationBlock
Attribute:
 LinkageAttribute
AlignAttribute
Pragma
deprecated
private
package
protected
public
export
static
final
override
abstract
const
auto
DeclarationBlock
DeclDef
{ }
{ DeclDefs }

Atributos são um modo de modificar uma ou mais declarações. As formas gerais são:

atributo declaração; afeta a declaração

atributo: afeta todas as declarações até o próximo }
 declaração;
 declaração;
 ...

atributo afeta todas as declarações no bloco
{
 declaração;
 declaração;
 ...
}

Para atributos com uma cláusula else opcional:

atributo
 declaração;
else
 declaração;

atributo afeta todas as declarações no bloco
{
 declaração;
 declaração;
 ...
}
else
{
 declaração;
 declaração;
 ...
}

Atributo de Ligação

LinkageAttribute:
	extern
extern ( LinkageType )
LinkageType:
	C
C++
D
Windows
Pascal

D provê um modo fácil de chamar funções C e funções da API do sistema operacional, como compatibilidade com albos é essencial. O LinkageType é sensível ao caso, e é significado de ser extensível pela implementação (eles não são palavras reservadas). C e D devem ser fornecidos, os outros são os que fazem sentido para a implementação. C++ é reservado para uso futuro. Nota de Implementação: ára plataformas Win32, Windows e Pascal deveriam existir.

Convenções de chamada de funções C são especificadas por:

extern (C):
	int foo(); // chama foo() com convenções C

Convenções D são:

extern (D):

ou:

extern:

Convenções da API do Windows são:

extern (Windows):
 void *VirtualAlloc(
 void *lpAddress,
 uint dwSize,
 uint flAllocationType,
 uint flProtect
 );

Atributo de Alinhamento

AlignAttribute:
	align
align ( Integer )

Especifica o alinhamento de membros da estrutura. align sózinho ajusta para o padrão, que combina com o alinhamento de membro padrão do companheiro compilador C. Integerespecifica o alinhamento que combina com o comportamento do compilador C quando alinhamentos não-padrões são usados.

Combinar o comportamento do compilador C pode ter alguns resultados surpreendendo, tal como o seguinte para Digital Mars C++:

struct S
{ align(4) byte a; // colocado no offset 0
 align(4) byte b; // colocado no offset 1
}

AlignAttribute é fornecido para compatibilidade com a C ABI, que não é a mesma coisa que compatibilidade binária através de diversas plataformas. Para isso, use estruturas empacotadas:

align (1) struct S
{ byte a; // colocado no offset 0
 byte[3] filler1;
 byte b; // colocado no offset 4
 byte[3] filler2;
}

Um valor de 1 significa que nenhum alinhamento é feito; membros são empacotados juntos.

Não alinhe referências ou ponteiros que foram alocados usando NewExpression em limites qua são são um múltiplo de 4. O coletor de lixo assume que ponteiros e referências para objetos alocados pelo gc estarão em limites de 4 bytes. Se não estão, será resultado comportamento indefinido.

AlignAttribute é ignorado quando aplicado à declarações que não são estruturas ou membros de estruturas.

Atributo de Condenação

É frequentemente necessário condenar uma característica em uma biblioteca, ainda mantendo-a para compatibilidade passada. Tais declarações podem ser marcadas como condenadas, o que significa que o compilador pode ser ajustado para produzir um erro se qualquer código se refere às declarações condenadas:

deprecated
{
void oldFoo();
}

Nota de Implementação: O compilador deveria ter um interruptor especificando se declarações condenadas deveriam ser compiladas com queixas ou não.

Atributo de Proteção

Proteção é um atributo que pode ser private, package, protected, public ou export.

Private significa que somente membros da classe podem acessar o membro, ou membros e funções no mesmo módulo que a classe. Membros privados não podem ser anulados. Membros de módulo privados são equivalente à declarações static em programas C.

Package extende private para que membros do pacote possam ser acessados de código em outros módulos no mesmo pacote. Isso se aplica somente ao pacote mais interno, se um módulo está em pacotes aninhados.

Protected significa que somente membros da classe ou qualquer classe derivada dessa classe, ou membros e funções membro no mesmo módulo que a classe, podem acessar o membro. Se acessar um membro de uma instancia protegida através de uma função membro de uma classe derivada, esse membro pode somente ser acessado para a instancia de objeto que é o objeto 'this' para a chamada à função membro. Membros de módulo protegidos são ilegais.

Public significa que qualquer código dentro do executável pode acessar o membro.

Export significa que qualquer código fora do executável pode acessar o membro. Export é análogo a exportar definições de uma DLL.

Atributo Constante

const

O atributo const declara constantes que podem ser avaliada em tempo de compilação. Por exemplo:

const int foo = 7;

const
{
double bar = foo + 6;
}

Uma declaração constante sem um inicializador deve ser inicializada em um construtor (para campos de classes) ou em um construtor estático (para membros estáticos de classes, ou declarações de variáveis do módulo).

const int x;
const int y;

static this()
{
 x = 3; // ok
 // erro: y não inicializado
}

void foo()
{
 x = 4; // erro, x é constante e não está em um construtor estático
}

class C
{
 const int a;
 const int b;
 static const int c;
 static const int d;

 this()
 { a = 3; // ok
	a = 4; // ok, inicialização múltipla permitida
	C p = this;
	p.a = 4; // erro, somente membros dessa instancia
	c = 5; // erro, deveria inicializar em construtor estático
	// erro, b não inicializado
 }

 this(int x);
 {
	this(); // ok, forwarding constructor
 }

 static this()
 {
	c = 3; // ok
	// erro, d não inicializado
 }
}

Não é um erro ter declarações de variáveis de módulo constantes sem inicializadores se não há nenhum construtor. Isso é para suportar a prática de ter módulos servindo apenas como declarações que não são linkadas, a implementação disso estará em outro módulo que é linkado.

Atributo e Anulação

override

O atributo override se aplica à funções virtuais. Significa que a função deve anular uma função com o mesmo nome e parâmetros em uma classe base. O atributo de anulação é útil para capturar erros quando a função membro da classe base tem seus parâmetros alterados, e todas as classes derivadas devem ter suas funções anuladores atualizadas.

class Foo
{
 int bar();
 int abc(int x);
}

class Foo2 : Foo
{
 override
{
int bar(char c); // erro, nenhum bar(char) em Foo
	int abc(int x); // ok
 }
}

Atributo Estático

static

O atributo static  se aplica à funções e dados. Significa que a declaração não se aplica à uma instancia particular do objeto, mas ao tipo do objeto. Em outras palavras, significa que não há nenhuma referência this. static é ignorado quando aplicado à outras declarações.

class Foo
{
 static int bar() { return 6; }
 int foobar() { return 7; }
}

...

Foo f = new Foo;
Foo.bar(); // produz 6
Foo.foobar(); // erro, nenhuma instância de Foo
f.bar(); // profuz 6;
f.foobar(); // produz 7;

Funções estáticas nunca são virtuais.

Dados estáticos tem somente uma instância para o programa inteiro, não uma por objeto.

Static não tem o significado adicional de C de ser local para um arquivo. Use o atributo private em D para conseguir isso. Por exemplo:

module foo;
int x = 3; // x é global
private int y = 4; // y é local para o módulo foo

Atributo Auto

auto

O atributo auto é usado para variáveis locais e para declarações de classes. Para declarações de classes, o atributo auto cria uma auto classe. Para declarações locais, auto implementa o protocolo RAII (Resource Acquisition Is Initialization). Isso significa que o destrutor para um objeto é automaticamente chamado quando a referência auto sai do escopo. O destrutor é chamado mesmo se o escopo é deixado devido a uma exceção disparada, assim auto é usado para garantir limpeza.

Se há mais de uma variável auto saindo de escopo no mesmo ponto, então os destrutores são chamados na ordem reversa que as variáveis foram construídas.

Auto não pode ser aplicado à membros globais, estáticos, parâmetros inout ou out. Arrays de autos não são permitidos, e valores de retorno de funções auto não são permitidos. Atribuit a um auto, senão na inicialização, não é permitido. Razão: Essas restrições podem ser aliviadas no futuro se uma razão compelindo aparecer.

Atributo de Abstração

Se uma classe é abstrata, ela não pode ser inicializada diretamente. Ela pode ser instanciada somente como uma classe base de outra classe não-abstrata.

Classes se tornam abstratas se são definidas dentro de um atributo de abstração, ou se qualquer das funções virtuais dentro dela é declarada como abstrata.

Funções não-virtuais não podem ser declaradas como abstratas.

Funçõe declaradas comoabstratas ainda podem ter corpo. Isso é de modo que mesmo que devam ser anuladas, ainda possam fornecer 'funcionalidade de classe base.'

Copyright © 1999-2006 by Digital Mars, All Rights Reserved | Page generated by Ddoc. | Traduzido por Chris7ian