A Linguagem D – Estruturas de Controle IV

Hoje estaremos completando as estruturas de controle básicas da linguagem.

Mas antes, apenas uma observação: estava eu relendo o último post e percebi que esqueci de mencionar a estruturas foreach_reverse. Ela tem o mesmo funcionamento do foreach, i.e. percorrer um array, mas faz isso na ordem inversa, i.e., do último para o primeiro elemento.

Agora, continuemos:

goto

Essa estrutura serve para “desviar” o fluxo normal do programa. Existem quatro formas. Veja os exemplos com as devidas explicações.

import std.stdio;void main()
 {
 	uint x;

x = 2;
 	goto EXIBE;

x = 3;

EXIBE: writef("x = %d", x);
 }

A instrução goto desvia a execução para EXIBE, ou seja, x nunca passa a valer 3. Sendo assim, o resultado é ‘x = 2′.

A segunda forma pareceria com:

import std.stdio;void main()
 {
 	uint x;
 	x = 1;

switch(x)
 	{
 		case 1 :	goto default;
 				writef("caso 1");
 				break;

case 2 : 	goto default;
 				writef("caso 2");
 				break;

case 3 : 	goto default;
 				writef("caso 3");
 				break;

default : writef("caso default");
 	}
 }

Neste exemplo, mesmo que o valor de x seja 1, 2 ou 3, as instruções goto default desviarão o fluxo do programa para o caso default da mesmo instrução switch.

A próxima forma:

import std.stdio;void main()
 {
 	uint x;

x = 1;

switch(x)
 	{
 		case 1 : 	goto case;
 				writef("caso 1");
 				break;

case 2 : 	writef("caso 2");
 				break;
 	}
 }

Esse tipo de goto redireciona o fluxo do programa para o próximo caso na instrução switch. Lembre-se de que deve haver um próximo (default não é considerado como um), ou o compilador exibiráum erro.

E, para completar:

import std.stdio;void main()
 {
 	uint x;
 	x = 2;

switch(x)
 	{
 		case 1 : 	goto case 4;
 				writef("caso 1");
 				break;

case 2 : 	goto case 5;
 				writef("caso 2");
 				break;

case 3 : 	goto case 6;
 				writef("caso 3");
 				break;

case 4 :	writef("caso 4");
 				break;

case 5 :	writef("caso 5");
 				break;

case 6 :	writef("caso 6");
 				break;
 	}
 }

Nesse exemplo, se o valor de x for 1, 2 ou 3, o fluxo do programa será redirecionado para 4, 5 ou 6, respectivamente. Sem segredo não?

scope

Essa instrução é um pouco diferente. Ela é “ativada” quando o programa sai do escopo onde ela está declarada. Sua forma geral é:

scope(situação) instruções

Existem três situações:

success

Executado quando o escopo é deixado normalmente

failure

Executado quando o escopo é deixado devido a uma exceção

exit

Executado quando o escopo é deixado devido a uma exceção ou normalmente

Se múltiplos scope estiverem em um mesmo escopo, eles serão executados na ordem inversa à que foram declarados.

Veja um exemplo:

import std.stdio;void main()
 {
 	scope(exit) writefln("Deixou main");
 	uint[] x;
 	x.length = 2;

{
 		x[1] = 1;
 		scope(exit) writefln("Deixou o bloco");
 		scope(success) writefln("Deixou o bloco com sucesso");
 	}

scope(failure) writefln("Deixou main devido a uma falha");
 	x[2] = 3;
 }

Uma execução desse exemplo deveria exibir que:

1. O bloco foi deixado com secesso;
2. O bloco foi deixado;
3. main foi deixada por uma falha;
4. main foi deixada;
5. Um erro.

Por hoje voi parando por aqui. No próximo post começarei a tratar de funções (espero). Até lá.

blogblogs tags:linguagem, programacao, d

technorati tags:linguagem, programacao, d

Blogged with Flock