Tag Archives: repetição

break/continue

Posted on by
Reply

Estas são duas formas “domesticadas” de “goto”. “break” interrompe o loop. “continue” pula o que falta no loop e vai para a próxima interação.

Estes dois comandos são aplicáveis a todas as estruturas de loop, cada qual com seu comportamento.

Break

O “break” força um loop parar imediatamente, como no exemplo abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int markerpos =- 1;
for (index = 0 ;index < 10; index++ )
{
    if (values[index] == -999 )
    {
        markerpos = index;
        break; // interrompe o loop
    }
}
 
if (markerpos == 999)
    Console.WriteLine("O valor -1 não foi localizado no array");
else
    Console.WriteLine("O valor -1 foi encontrado no índice {0}",markerpos);

O exemplo procura em um array de 10 elementos o valor 999. A variável markepos armazena o índice do array onde o valor 999 foi encontrado. Como o valor inicial de markepos foi configurado para -1, ele é verificado para assegurar a existência do valor 999 no array, o que é feito no comando if logo em seguida.

O “break” precisa ser usado com cuidado pois interrompe a lógica tradicional de um laço de repetição, porém, ele pode ser útil quando se procura um único valor em uma coleção ou array muito grande, não sendo necessário varre-la por completo.

Continue

É exatamento o oposto do break. Ao ser chamado, o continue interrompe o código do loop exatamente naquele ponto e “pula” para a próxima interação do laço. No código abaixo, todos os valores do array serão somando à variável value, exceto os que estiverem no índices 4 e 5.

1
2
3
4
5
6
7
8

int value = 0;
for (index = 0 ;index < 10;index++ )
{
    if (index == 4 || index == 5)
        continue;
    value += numbers[index];
}
Console.WriteLine("Value = {0}",value) ;

É bastante útil em situações de números pares e ímpares por exemplo.

foreach-in

Posted on by
Reply

Este é um loop que permite varrer todos os elementos de um array ou coleção. Veja um exemplo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

using System;
class MainClass
{
      public static void Main()
      {
            int odd = 0, even = 0;
            int[] arr = new int [] {0,1,2,5,7,8,11);
            foreach (int i in arr)
            {
                  if (i%2 == 0)
                        even++;
                  else
                        odd++;
            }
            Console.WriteLine(“Encontrados {0} Odds e {1} Evens.”, odd, even);
      } 
}

O uso de coleções de dados ou varíaveis nas novas linguagens tornaram-se muito comuns. É nesse contexto que o loop foreach vem facilitar o trabalho com este tipo de estrutura, já que ele garante que o laço passará por todos os itens contidos na coleção, sem ser necessário controlar sua contagem como é o caso do for tradicional.

O único cuidade é que a coleção que está sendo “varrida” ou sofrendo a intereção não pode ser alterada durante este, como por exemplo, a remoção ou adição de um novo item. A prática fará com que a ação retorne um erro em tempo de execução.

do-while

Posted on by
Reply

A terceira estrutura de repetição que veremos é o do-while de forma geral:

1
2
3
4

do
{
    declaração;
} while (condição);

Mesmo que a declaração seja apenas um comando é uma boa prática deixar as chaves. O ponto-e- vírgula final é obrigatório. Vamos, como anteriormente, ver o funcionamento da estrutura do-while “por dentro”:

1
2

declaração;
if (condição) "Volta para a declaração"

Vemos pela análise do bloco acima que a estrutura do-while executa a declaração, testa a condição e, se esta for verdadeira, volta para a declaração. A grande novidade no comando do-while é que ele, ao contrário do for e do while, garante que a declaração será executada pelo menos uma vez.

O uso da estrutura do-while é muito comum na construção de menus em aplicativos Console, nos quais você quer garantir que o valor digitado pelo usuário seja válido, conforme apresentado abaixo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

using System;
public class TestDoWhile
{ 
	public static void Main ()
	{
		int  i;
		do
        	{
        		Console.WriteLine("Escolha a fruta pelo numero:");
	        	Console.WriteLine("(1)...Mamao");
        		Console.WriteLine("(2)...Abacaxi");
        		Console.WriteLine("(3)...Laranja");
	        	i = Console.Read();
        	} while ((i < 1) || (i > 3));
 
		switch (i)
        	{
        		case 1:
	                	Console.WriteLine("Voce escolheu Mamao.");
        		break;
        		case 2:
                		Console.WriteLine("Voce escolheu Abacaxi.");
	        	break;
        		case 3:
                		Console.WriteLine("Voce escolheu Laranja.");
	        	break;
        	}
	}
}

while

Posted on by
Reply

O comando while tem a seguinte forma geral:

1

while (condição) declaração;

Assim como fizemos para o comando for, vamos tentar mostrar como o while funciona fazendo uma analogia. Então o while seria equivalente a:

1
2
3
4
5

if (condição)
{
      declaração;
      "Volte para o comando if"
}

Podemos ver que a estrutura while testa uma condição. Se esta for verdadeira a declaração é executada e faz-se o teste novamente, e assim por diante. Assim como no caso do for, podemos fazer um loop infinito. Para tanto basta colocar uma expressão eternamente verdadeira na condição. Pode-se também omitir a declaração e fazer um loop sem conteúdo. Vamos ver um exemplo do uso do while. O programa abaixo imprime na tela os valores de n até que a condição n< 6 não seja mais verdadeira:

1
2
3
4
5
6
7
8
9
10
11
12
13

using System;
class WhileTest
{
      public static void Main()
      {
            int n = 1;
            while (n < 6)
            {
                  Console.WriteLine("O valor atual é: {0}", n);
                  n++;
            }
      }
}

for

Posted on by
Reply

O C# tem 4 tipos de loops: os mesmos do C, mais o foreach.

1
2
3
4
5
6
7
8
9
10
11

using System;
public class ForLoopTest
{
      public static void Main()
      {
            for (int i = 1; i < = 5; i++)
            {
                  Console.WriteLine(i);
            }
      }
}

for é a primeira de uma série de estruturas para se trabalhar com loops de repetição. As outras são while, do e foreach (esta última não existente no C). As três compõem a segunda família de comandos de controle de fluxo. Podemos pensar nesta família como sendo a das estruturas de repetição controlada.

Como já foi dito, o loop for é usado para repetir um comando, ou bloco de comandos, diversas vezes, de maneira que se possa ter um bom controle sobre o loop. Sua forma geral é:

1

for (inicialização;condição;incremento) declaração;

O melhor modo de se entender o loop for é ver como ele funciona "por dentro". O loop for é equivalente a se fazer o seguinte:

1
2
3
4
5
6
7
8

inicialização;
if (condição)
{
 
    declaração;
    incremento;
    "Volte para o comando if"
}

Podemos ver, então, que o for executa a inicialização incondicionalmente e testa a condição. Se a condição for falsa ele não faz mais nada. Se a condição for verdadeira ele executa a declaração, faz o incremento e volta a testar a condição. Ele fica repetindo estas operações até que a condição seja falsa. Um ponto importante é que podemos omitir qualquer um dos elementos do for, isto é, se não quisermos uma inicialização poderemos omiti-la. Abaixo vemos um programa que coloca os primeiros 100 números inteiros na tela:

1
2
3
4
5
6
7
8
9
10
11
12

using System;
public class ForLoopTest
{
      public static void main ()
      {
	     int count;
             for (count=1; count< =100; count++) 
             {
                   Console.WriteLine(count);
             }
       }
}

Note que, no exemplo acima, há uma diferença em relação ao exemplo anterior. O incremento da variável count é feito usando o operador de incremento que nós agora já conhecemos. Esta é a forma usual de se fazer o incremento (ou decremento) em um loop for.

O for na linguagem C# é bastante flexível. Temos acesso à inicialização, à condição e ao incremento. Isto nos permite fazer o que quisermos com o comando, conforme veremos a seguir.