Comandos de controle de fluxo em ANSI C: Ramificação e repetição. Ramificação está decidindo que ações tomar de acordo com certas condições e repetição está tratando de quantas vezes realizar determinada ação.

Ramificação

Um ramo é chamado (executado) apenas se o programa escolher percorrê-lo através de testes lógicos. Desta forma é possível executar determinadas instruções ou outras de acordo com condições que podem variar no tempo.

Comando if

É a mais simples forma de ramificação. A expressão entre parênteses será testada, se for verdadeira uma instrução ou um bloco de instruções será executado. Se for falso esta instrução ou bloco será ignorada e o programa segue seu curso sem portanto executar certo trecho de código. Um teste é tido como verdadeiro se seu resultado é um valor diferente de zero. Abaixo dois exemplos, o primeiro executando um comando simples e outro um bloco (instrução composta)

//Comando simples
if (expressão_de_teste_logico) instrução;

//Comando composto
if (expressão_de_teste_logico)
{
   instrução1;
   instrução2;
   instruçãoN;
}

Comando if em estrutura if...else

Pode-se também determinar o que se deve fazer se o teste for falso. Neste caso em uma execução apenas um trecho será executado, não há possibilidade de ambos serem executados na mesma execução.

//Comando simples
if (expressão_de_teste_logico) instrução1; else instrução2;

//Comando composto
if (expressão_de_teste_logico)
{
   instrução1;
   instrução2;
   instruçãoN;
}
else
{
   instrução1_2;
   instrução2_2;
   instruçãoN_2;
}

Comando if aninhado (em cascata)

Pode-se ainda configurar operadores if em cascata, desta forma pode-se testar diferentes condições lógicas. Apenas um trecho de código será executado em um ciclo de execução.

if (expressão_de_teste_logico_1)
{
   instrução1_1;
   instrução2_1;
   instruçãoN_1;
}
else if(expressão_de_teste_logico_2)
{
   instrução1_2;
   instrução2_2;
   instruçãoN_2;
}
else
{
   instrução1_3;
   instrução2_3;
   instruçãoN_3;
}

Operador ? :

Se assemelha ao "if...else". Primeiro se declara o teste lógico (fazendo a função do conteúdo entre parênteses do if), depois do "?" a instrução para caso verdadeiro (equivale ao comando simples após o if) e após ":" o comando se falso (equivale a instrução simples do else).

//Formato da estrutura "? :" 
//se o teste lógico der verdadeiro o instrução1 será executado, 
//caso contrário será executado o instrução2
expressão_teste_lógico ? instrução1 : instrução2;

Comando switch

Se assemelha ao if aninhado podendo tratar diversos casos, porém testa apenas uma variável de números inteiros. Tem a vantagem de ser mais eficiente e fácil de ler. É necessário ter ao menos um caso declarado. O operador default é opcional. Não é necessário usar "{}" para executar instruções em blocos dentro dos casos.

switch (valor_inteiro_a_ser_testado)
{
   case constante1: 
     instrução1;
     break;
   case constante2: 
     instrução2;
     break;
   case constante1: 
     instrução3;
     break;
   default : 
     instrução4;
     break;
}

Palavra-chave break

A palavra-chave break faz com que a execução do switch pare naquela linha. Caso se deseje que o programa continue executando as instruções em um switch basta omitir o break. Pela estrutura, portanto, serão executadas todas as instruções a partir do caso verdadeiro até que seja encontrado um break ou se chegue ao fim do switch.

Repetição

Laço while

Um laço while é como um "if" que se repete. Há portanto um teste lógico e caso seja verdadeiro a instrução simples ou bloco de instruções a seguir será executado. A diferença se comparado com o if é que após executar as instruções o programa volta a realizar o teste lógico podendo repetir a execução caso verdadeiro ou sair do laço while se falso. Este tipo de laço possibilita a condição de não haver execução das instruções internas caso a condição nunca seja tida como verdadeira.

//Comando simples
while (expressão_de_teste_logico) instrução;

//Comando composto
while (expressão_de_teste_logico)
{
  instrução1;
  instrução2;
  instruçãoN;
}

//Laço infinito
while (1) instrução;

Laço do...while

Neste laço a expressão de teste é executada no final ao invés de ser no início como no while. Na prática as instruções no corpo da estrutura após o "do" serão executadas ao menos uma vez.

//Comando simples
do instrução while(expressão_de_teste_logico);

//Comando composto
do
{
  instrução1;
  instrução2;
  instruçãoN;
} while (expressão_de_teste_logico);

Laço for

Esta estrutura de repetição pode ser escrita de maneira mais compacta que um laço while e a estrutura já prevê ações típicas de um laço que são comandos de inicialização e modificadores pós execução do ciclo, além do teste lógico. Esta estrutura é muito utilizada quando o laço deve ser repetido uma quantidade conhecida de vezes. Sua estrutura é for(expressão1;expressão2;expressão3) onde a expressão1 será sempre executada e apenas uma vez ao iniciar o laço. A expressão2 é a expressão de teste, será sempre checada toda vez que se iniciar um ciclo de repetição, se verdadeira o corpo do comando será executado e a expressão3 será por fim processada. A expressão1 é tipicamente utilizada para inicialização de variáveis e a expressão3 para incremento ou decremento de variáveis de controle. As expressões aqui citadas são de uso opcional, caso não se deseje operar uma ou mais basta deixar em branco, um exemplo é o laço infinito que tipicamente é construído com as três expressões em branco. Outro formato típico é o laço nulo utilizado para gastar tempo.

//Comando simples
for(expressão1; expressão2; expressão3)
  instrução;

//Comando composto
for(expressão1; expressão2; expressão3)
{
  instrução1;
  instrução2;
  instruçãoN;
}

//Laço infinito
for (;;) instrução;

//Laço nulo
for(expressão1; expressão2; expressão3) 
  ;

Palavras-chave das estruturas de repetição

break