Chamamos de estruturas condicionais as instruções para testar se uma condição é verdadeira ou não. Elas podem ser associadas às estruturas que se repetem, após o cumprimento da condição, chamamos a elas de estruturas de loop.
Uma expressão seguida de um ponto e virgula é chamado de instrução. Veja um exemplo de instrução:
a++;
. Quando você quiser reunir várias instruções, você poderá criar o que chamamos de bloco, ou seja, um conjunto de instruções (seguidas, respectivamente, por pontos e vírgulas) entre chaves {e}. As instruções if, while e for podem, por exemplo, ser seguidas de um bloco de instruções a serem executadas.
A instrução IF é a estrutura de teste mais básica e é encontrada em todas as linguagens (com sintaxes diferentes). Ela permite executar uma série de instruções caso uma condição se realize. A sintaxe desta expressão é a seguinte:
if (condição realizada) { lista de instruções; }
A condição deve ficar entre parênteses. É possível definir várias condições a serem cumpridas com os conectores AND e OR (&& e ||).
Por exemplo, a seguinte instrução testa se as duas condições são verdadeiras:
if ((condição1)&&(condição2))
Neste caso, se ambas condições se completam, o código se executará..
if ((condição1)||(condição2))
Aqui, contanto que uma das condições seja verdadeira, o código se executará.
A instrução IF em sua forma básica só testa uma condição. Na maioria das vezes, gostaríamos de poder escolher as instruções a serem executadas em caso do não cumprimento da condição.
A expressão IF... ELSE permite executar outra série de instruções em caso do não cumprimento da condição. A sintaxe desta expressão é a seguinte:
if (condição realizada) { lista de instruções } else { outra série de instruções }
É possível fazer um teste com uma estrutura muito mais leve, graças à seguinte estrutura:
(condição) ? instrução se verdadeira: instrução se falsa<ital></i></ital>
A condição deve ficar entre parênteses. Quando a condição for verdadeira, a instrução da esquerda será executada. Quando a condição for falsa, a instrução da direita será executada. Além de ser executada, a estrutura ?: retorna o valor resultante da instrução executada. Assim, esta forma ?: é frequentemente utilizada como segue:
posição = ((Antes == 1) ? contador+1: contador-1);
A Instrução switch efetua vários testes de valores sobre o conteúdo de uma mesma variável. Esta conexão condicional simplifica muito o teste de vários valores de uma variável, pois esta operação teria sido complicada (mas possível) com varios if imbricados. Sua sintaxe é a seguinte:
switch (variável) { casa Valor1: Lista de instruções; break; casa Valor2 : Lista de instruções; break;</bold> casa Valores... : Lista de instruções; Break; default: Lista de instruções; }
Os parênteses após a palavra-chave switch indicam uma expressão cujo valor é testado, sucessivamente, para cada uma das case. Quando a expressão testada é igual a um dos seguintes valores seguindo um case, a lista de instrução que vem depois, é executada. A palavra-chave break indica a saída da estrutura condicional. A palavra-chave default precede a lista de instruções, que será executada se a expressão nunca for igual a um dos valores.
Não se esqueça de inserir instruções break entre cada teste; esse tipo de esquecimento é difícil de ser detectado pois nenhum erro é assinalado. Na verdade, ao omitir o break, a execução continuará nos blocos seguintes.
Este fato também pode ser usado criteriosamente, a fim de executar as mesmas instruções para os diferentes valores consecutivos; assim, podemos colocar várias casas antes do bloco:
switch(variável) { case 1: case 2: { instruções executadas para a variável = 1 ou para a variável = 2 } break; case 3: { instruções executadas para a variável = 3 apenas } break; default: { instruções executadas para qualquer outro valor de variável } }
</sample>
Os loops são estruturas que executam várias vezes a mesma série de instruções até que uma condição não seja mais realizada. Às vezes, chamamos estas estruturas de instruções repetitivas ou iterações. A forma mais comum de fazer um loop é criar um contador (uma variável que se incrementa, ou seja, que aumenta de 1 a cada volta do loop) e parar o loop quando o contador excede um determinado valor.
A instrução for executa várias vezes a mesma série de instruções: é um loop.
Em sua sintaxe, basta especificar o nome da variável que serve de contador (e, eventualmente, o seu valor inicial, a condição sobre a variável para a qual o loop para (basicamente uma condição que testa se o valor do contador excede um limite) e, finalmente, uma instrução que incrementa (ou decrementa) o contador.
A sintaxe desta expressão é a seguinte:
for (contador; condição; modificação do contador) { lista de instruções; }
Por exemplo:
for (i=1; i<6; i++) { printf("%d", i); }
Este loop exibe cinco vezes o valor do i, ou seja, 1, 2, 3, 4, 5. Ele começa em i = 1, verifique se i é inferior a 6 e, assim por diante, até atingir o valor de i = 6, para o qual a condição não será realizada, o loop vai se interromper e o programa continuará seu curso.
Você deverá verificar sempre se o loop tem uma condição de saída (ou seja, o contador se incrementa corretamente);
Uma instrução printf(); em seu loop é uma boa maneira de verificar, passo a passo, o valor do contador, exibindo-o;
É preciso contar o número de vezes que você deseja executar o loop:
for(i=0;i<10;i++) executa 10 vezes o loop (i de 0 a 9)
for(i=0;i<=10;i++) executa 11 vezes o loop (i de 0 a 10)
for(i=1;i<10;i++) executa 9 vezes o loop (i de 1 a 9)
for(i=1;i<=10;i++) executa 10 vezes o loop (i de 1 a 10)
A instrução while representa outro meio de executar várias vezes a mesma série de instruções. A sintaxe desta expressão é a seguinte:
while (condição realizada) { lista de instruções; }
Esta instrução executa a lista de instruções enquanto (significado da palavra While) a condição se realiza.
Como a condição de saída pode ser qualquer estrutura condicional, o risco de loop infinito (loop cuja condição é sempre verdadeira) é grande, ou seja, pode causar uma falha do programa em curso de execução.
Pode ser necessário pular um ou mais valores do loop, sem precisar pará-lo. A sintaxe desta expressão é continue (esta instrução é colocada em um loop), e é geralmente associada a uma estrutura condicional, caso contrário, as linhas entre esta instrução e o final do loop seriam obsoletas.
Exemplo: Suponhamos que desejemos imprimir para x indo de 1 a 10 o valor de 1/(x-7); é claro que para x = 7, haverá um erro. Felizmente, graças à instrução continue é possível tratar este valor separadamente e continuar o loop:
x=1; while (x<=10) { if (x == 7) { printf("Divisão por zero !"); continue; } a = 1/(x-7); printf("%f", a); x++; }
Havia um erro neste programa, mas talvez você não tenha visto:
Quando x for igual a 7, o contador não incrementará mais, ele continuará com o valor 7, você deveria ter escrito:
x = 1; while (x<=10) { if (x == 7) { printf("Division par 0"); x++; continue; } a = 1/(x-7); printf("%f", a); x++; }
Por outro lado, você pode querer parar prematuramente o loop, para outra condição além da que foi especificada no cabeçalho do loop. A instrução break para um loop (for ou while). Trata-se, assim como o continue, de associá-lo a uma estrutura condicional, sem a qual o loop não daria mais do que uma volta.
No exemplo anterior, por exemplo, se nós não soubéssemos quando o denominador (x-7) se anularia (ok para equações mais complicadas, por exemplo), seria possível interromper o loop, em caso de cancelamento do denominador, para evitar divisão por zero:
for (x=1; x<=10; x++) { a = x-7; if (a == 0) { printf("Divisão por 0"); break; } printf("%f", 1/a); }
Foto: © Unsplash