A Linguagem D – Estruturas de Controle – III

Agora vejamos estruturas de repetição.

Existem 4 princiais tipos de estruturas de repetição: while, do...while, for e foreach.

while

while(condição) bloco

Semelhantemente ao C/C++, essa estrutura avalia a condição e se for verdadeira o bloco é executado.

int x;
while(x < 10)
{
    writef("%d", x);
    x++;
}

Neste exemplo, serão exibidos os números de 0 até 9. Nenhum segredo né!

do...while

do bloco while condição

Essa estrutura é semelhante ao while. Porém, primeiro o bloco é executado, depois a condição é avaliada. Ou seja, o bloco será executado ao menos uma vez, não importando a condição.

int x;
do
{
    writef("%d", x);
    x++;
} while(x < 0);

Neste exemplo, será exibido apenas o número 0 uma vez.

Obs.: o ‘;’ (ponto-e-vírgula) após a condição é facultativo.

for

for(inicialização; condição; passo) bloco

Inicialmente a inicialização é feita. Depois a condição é avaliada e, se for verdadeira, o bloco é executado, é realizado o passo (incremento) e a condição é avaliada novamente, e assim vai. A inicialização pode ser omitida (a variável pode ser inicializada fora do laço, por exemplo). A condição também pode ser omitida (será sempre verdadeira). O passo também pode ser emitido (ser dado dentro do bloco, por exemplo).

Por exemplo:

int[11] x;
uint i = 0;
for(; 
{
    x[i] = i * 2;
    i++;
    if(i >= x.length) break;
}

Faz o mesmo que:

int[11] x;
for(uint i = 0; i < x.length; i++)
    x[i] = i * 2;

Ambos os exemplos armazenam a tabuada do 2 no array x. A instrução break será mostrada mais adiante.

Obs.: Diferentemente do Java, por exemplo, isso não é permitido:

for(uint i = 0; i < x.length; i++);

Use isso no lugar:

for(uint i = 0; i < x.length; i++){}

foreach

foreach(índice, item; array)


Aqui está uma novidade em relação ao C/C++. Um dos usos mais freqüêntes do for é percorrer arrays. A estruturas foreach foi criada exatamente para esse propósito.

Ela percorre o array todo, armazenando o item atual em item e o índice atual em índice. O índice pode ser omitido.

Se você quiser modificar o item do array, lembre-se de adicionar inout. Em quando eu falar sobre funções explico melhor sobre isso. Po agora, saiba que é assim que os argumentos são passados “por referência” em D. Se o array não for modificado, o inout não é necessário.

Veja um exemplo bem simples desse funcionamento:

import std.stdio;

void main()
{
    int[5] x = [0, 1, 2, 3, 4];
    print(x);
    foreach(uint i, inout int a; x)
    {
        a = a + 2;
    }
    print(x);
}

void print(int[] array)
{
    foreach(uint i, int a; array)
        writefln("array[%d] = %d", i, a);
writef("n");
}

Esse exemplo inicialmente exibe os valores 0, 1, 2, 3 e 4 para o array. Depois ele modifica os valores, somando 2 a cada item e exibe os novos valores.

break

Essa instrução pode ser utilizada para se sair de qualquer uma dessas estruturas. Por exmplo, apenas modificando o exemplo anterior:

foreach(uint i, inout int a; x)
{
    if(i == 2) break;
    a = a + 2;
}

Agora apenas os dois primeiros valores do array serão modificados. Quando chegar ao terceiro item (i = 2), a execução do programa passa para a linha seguinte á estrutura (print(x);).

continue

Essa instrução pode ser utilizada para “pular” uma iteração em qualquer das estruturas acima citadas. Por exemplo, modificando o exemplo para:

foreach(uint i, inout int a; x)
{
    if(i == 2) continue;
    a = a + 2;
}

Agora o terceiro item (i = 2) não será modificado, mas os outros serão. Ou seja, quando o continue é encontrado, o programa retorna ao inicio da estrutura de repetição, pulando o resto do bloco.

Por hoje é só isso. Ainda há cerca de duas estruturas de controle que ficarão para a próxima. Até lá!!!

blogblogs tags:linguagem, programacao, d

technorati tags:linguagem, programacao, d

Blogged with Flock