Difference between revisions of "Conceitos básicos: D"

void
bool = 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) = 0
ucent (128 bits sem sinal - reservado) = 0
float (ponto flutuante de 32 bits) = float.nan
double (ponto flutuante de 64 bits) = double.nan
real (maior ponto flutuante implementado pelo hardware) 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 (número complexo com dois valores float) = float.nan + float.nan * 1.0i
cdouble (número complexo com dois valores double) = double.nan + double.nan * 1.0i
creal (número complexo com dois valores real) = 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

DeclarationStatement:
    Declaration

int a;            // declara a como um inteiro.
struct S { }      // declara a estrutura S.
alias int meuint; // declara meuint como um outro nome para o tipo int.

BlockStatement:
    { }
    { StatementList }
StatementList:
    Statement
    Statement StatementList

ScopeBlockStatement:
    BlockStatement

int *p;

int[3] s;
int s[3];

int[] a;
int a[];

int[char[]] x;

int[]* e;
int (*e)[];

int*[]*[3] d;
int*[]* d[3];
int* (*d[3])[];

int[4][3] b;
int[4] b[3];
int b[3][4];

int[][5] c;
int[] c[5];
int c[5][];

int[10] a;
int[] b;
 
b = a[1..3]; // a[1..3] representa um array de 2 elementos (a[1] and a[2]).

int[3] s;
int[3] t;
 
s[0..2] = t[1..3]; // mesmo que s[0] = t[1], s[1] = t[2].
s[] = 3;           // mesmo que s[0] = 3, s[1] = 3, s[2] = 3.
p[0..2] = 3;       // mesmo que p[0] = 3, p[1] = 3.

int[] a;
int[] b;
int[] c;
a = b ~ c; // cria um array resultado da concatenção d b com c.
a ~= b;    // concatena b ao array a.

IfStatement:
    if ( IfCondition ) ThenStatement
    if ( IfCondition ) ThenStatement else ElseStatement
IfCondition:
    Expression
    auto Identifier = Expression
    Declarator = Expression
ThenStatement:
    ScopeStatement
ElseStatement:
    ScopeStatement

if (...)
{
    ...
}
else
{
    ...
}

SwitchStatement:
    switch ( Expression ) ScopeStatement
CaseStatement:
    case ExpressionList : Statement
DefaultStatement:
default: Statement

switch (i)
{
    case 1:
        x = 3;
    case 2:
        x = 4;
        break;
    case 3,4,5:
        x = 5;
        break;
}

ConditionalExpression:
    OrOrExpression
    OrOrExpression ? Expression : ConditionalExpression
OrOrExpression:
    AndAndExpression
    OrOrExpression || AndAndExpression
AndAndExpression:
    OrExpression
    AndAndExpression && OrExpression

ForStatement:
    for (Initialize Test; Increment) ScopeStatement
Initialize:
    ;
    NoScopeNonEmptyStatement
Test:
    empty
    Expression
Increment:
    empty
    Expression

for (int i = 0; i < 10; i++)
    foo(i);

for (int i = 0; i < 10; i++) ;  //isto não é permitido.
for (int i = 0; i < 10; i++) {} //mas isto sim.

ForeachStatement:
    Foreach (ForeachTypeList; Aggregate) ScopeStatement
Foreach:
    foreach
    foreach_reverse
ForeachTypeList:
    ForeachType
    ForeachType , ForeachTypeList
ForeachType:
    inout Type Identifier
    Type Identifier
    inout Identifier
    Identifier
Aggregate:
    Expression
    Tuple

char[] a;
...
foreach (int i, char c; a)
{
    printf("a[%d] = '%c'\n", i, c);
}

foreach (char c; "ab")
{
    printf("'%c'\n", c);
}

double[char[]] a;
...
foreach (char[] s, double d; a)
{
    printf("a['%.*s'] = %g\n", s, d);
}

class Foo
{
    uint array[2];
    int opApply(int delegate(inout uint) dg)
    { 
        int result = 0;
        for (int i = 0; i < array.length; i++)
        {
            result = dg(array[i]);
            if (result)
                break;
        }
        return result;
    }
}
void test()
{
    Foo a = new Foo();
    a.array[0] = 73;
    a.array[1] = 82;
    foreach (uint u; a)
    {
        printf("%d\n", u);
    }
}

WhileStatement:
    while ( Expression ) ScopeStatement

int i = 0;
while (i < 10)
{
    foo(i);
    i++;
}

DoStatement:
    do ScopeStatement while ( Expression )

int i = 0;
do
{
    foo(i);
} while (++i < 10);