·
Os
comandos de fluxo de controle especificam a ordem em que a computação é realizada.
·
Uma
expressão torna-se um comando quando seguida pelo símbolo ";".
Exemplo:
x = 0; i++; printf(...);
·
O
símbolo ";" é um terminador de comandos e não um separador.
·
O
conjunto { } agrupa declarações e comandos num bloco (comando composto),
considerado como um único comando.
·
Variáveis
podem ser declaradas dentro de qualquer bloco.
·
O
comando if-else é usado
para expressar decisões (executar testes condicionais) no programa.
·
Observe
o programa abaixo:
/*
UFPB/CCT/DSC - Introducao a
Programacao/2001.1
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 1.0
*/
#include <stdio.h>
void main() {
/*declaracao de variaveis*/
int valor1, valor2, valor3;
const char prompt[] = "\nDigite 3
valores inteiros para localizar o maior\n(separe os valores com espaco):
";
clrscr();/*comando para limpar a tela*/
/*entrada de dados*/
printf("%s",
prompt);
scanf("%d %d %d",
&valor1, &valor2, &valor3);
/*processamento*/
if (valor1 > valor2) {
if (valor1 > valor3) {
printf("O maior valor entre %d
%d %d => %d", valor1, valor2, valor3, valor1);
} else {
printf("O maior valor entre %d
%d %d => %d", valor1, valor2, valor3, valor3);
}
} else
{
if
(valor2 > valor3) {
printf("O maior valor
entre %d %d %d => %d", valor1, valor2, valor3, valor2);
} else {
printf("O maior valor entre %d
%d %d => %d", valor1, valor2, valor3, valor3);
}
}
getch();
}
·
Forma
geral do comando if-else:
if (expressão) {
comando1; /*bloco VERDADE*/
} else {
comando2; /*bloco FALSO*/
}
·
Onde,
expressão
é uma expressão lógica.
·
Uma
expressão
é verdadeira quando seu valor é diferente de zero, nesse caso, executa-se
o bloco VERDADE;
·
Por
outro lado, uma expressão é tida como falsa quando seu valor é igual a zero,
nesse caso, executa-se o bloco FALSO.
·
É
melhor usar:
if (expressão)
·
Ao invés de:
if (expressão != 0)
· O else é sempre associado ao último if sem else (if mais interno).
· Exemplo:
if (n > 0) if (n > 0)
if ( a > b) = if (a > b)
z = a; z = a;
else else
z = b; z = b;
· Para evitar ambigüidades, use sempre os parênteses!
· Uma versão melhorada do programa para encontrar o maior valor, apresentado acima:
/*
UFPB/CCT/DSC - Introducao a
Programacao/2001.1
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 2.0
*/
#include <stdio.h>
#include <limits.h>
void
main() {
/*declaracao de variaveis*/
int valor1, valor2, valor3, maior;
const char prompt[] = "\nDigite 3
valores inteiros para localizar o maior\n(separe os valores com espaco):
";
/*INT_MIN: constante pre-definida da
linguagem, equivale ao valor minino de "int"*/
maior = INT_MIN;
clrscr();/*comando para limpar a tela*/
/*entrada de dados*/
printf("%s",
prompt);
scanf("%d %d %d",
&valor1, &valor2, &valor3);
/*processamento*/
if (valor1 > maior) {
maior = valor1;
}
if (valor2 > maior) {
maior = valor2;
}
if (valor3 > maior) {
maior = valor3;
}
/*saida de dados*/
printf("O maior valor entre %d %d %d
=> %d", valor1, valor2, valor3, maior);
getch();
}
·
A
construção a seguir é a forma mais genérica de se escrever uma decisão
múltipla:
if (expressão1) {
comando1;
} else if (expressão2) {
comando2;
} else if (expressão3) {
comando3;
} else {
comando4;
}
·
O
comando switch é uma estrutura de decisão múltipla.
·
Funcionalidade:
verifica se o valor da expressão coincide com um dentre vários valores inteiros
constantes, desviando o fluxo de execução de acordo com o resultado.
·
Observe
o programa abaixo:
·
O comando
break causa uma saída imediata do switch (pode ser utilizado
também em comandos de repetição).
·
Forma
geral do comando switch:
switch (expressão) {
case expressão-constante: comandos;
case expressão-constante: comandos;
. . .
default: comandos;
}
· Exemplo de uso do comando switch:
· As expressões usadas em comandos de decisão e repetição são constituídas de operadores lógicos e/ou relacionais, portanto, são expressões lógicas e/ou relacionais.
· Toda expressão relacional e lógica produz como resultado 0 (falso) ou 1 (verdadeiro).
· Os operadores relacionais são:
> >= < <=
· Os operadores de igualdade são:
== !=
· Os operadores lógicos são:
&&(and) ||(or) !(not)
· Exemplo:
10 > 5 && !(10 < 9) || 3 <= 4
O resultado da expressão acima é verdadeiro.
· Precedência entre os operadores:
|
mais alta => |
Operadores aritméticos |
|
|
! |
|
|
== != |
|
|
> >=
< <= |
|
|
&& |
|
mais baixa => |
|| |
· Como nas expressões aritméticas, é possível usar parênteses para mudar a ordem natural de avaliação de uma expressão lógica. Por exemplo:
|
!0 && 0 || |
!(0 && 0) || 0 |
|
é falso |
é verdadeiro |
· Observe esta nova versão do programa para encontrar o maior valor:
/*
UFPB/CCT/DSC - Introducao a
Programacao/2001.1
Este programa determina o maior de um grupo
de N valores inteiros
Versao 3.0
*/
#include <stdio.h>
#include <limits.h>
void
main() {
/*declaracao de variaveis*/
int valor, maior;
char resposta = 's';
const char prompt[] = "\nDigite os
valores inteiros para localizar o maior:";
const char prompt2[] = "\nOutro
valor?\n(tecle \'s\' para sim e \'n\' para terminar): ";
/*INT_MIN: constante pre-definida da
linguagem, equivale ao valor minino de "int"*/
maior = INT_MIN;
clrscr(); /*comando para limpar a tela*/
/*processamento*/
printf ("%s", prompt);
while (resposta == 's') {
printf("\nValor: ");
scanf("%d", &valor);
if (valor > maior)
maior = valor;
printf("%s", prompt2);
scanf(" %c", &resposta);
}
/*saida de dados*/
printf ("\nMaior valor digitado =>
%d", maior);
getch();
}
· Forma geral do comando while:
while (expressão) {
comandos;
}
·
Note
que, o bloco de comandos do while será repetido até que o resultado da
avaliação de expressão seja diferente de zero.
·
Representação
de um laço infinito com o comando while:
while(1) {
comandos;
}
·
Outra
versão do programa para encontrar o maior valor:
/*
UFPB/CCT/DSC - Introducao a
Programacao/2001.1
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 4.0
*/
#include <stdio.h>
#include <limits.h>
void
main() {
/*declaracao de variaveis*/
int valor, maior, i;
const char prompt[] = "\nEntrada dos 10
valores inteiros para localizar o maior...";
const char prompt2[] = "\nInforme um
valor: ";
/*INT_MIN: constante pre-definida da
linguagem, equivale ao valor minino de "int"*/
maior = INT_MIN;
clrscr();/*comando para limpar a tela*/
/*processamento*/
printf ("%s", prompt);
for (i = 0; i <
10; i++) {
printf("%s",
prompt2);
scanf("%d",
&valor);
if (valor > maior)
maior = valor;
}
/*saida de dados*/
printf("\nMaior valor digitado =>
%d", maior);
getch();
}
·
Forma
geral do comando for:
for(expr-1; expr-2; expr-3){
comandos;
}
·
Onde:
expr-1 => inicialização da variável de controle;
expr-2 => teste sobre a variável de controle;
expr-3 => atualização (incremento/decremento) do valor da
variável de controle.
· Qualquer expressão do comando for pode estar ausente.
· Outro ponto importante: se a expr-2 estiver ausente o seu valor será considerado VERDADE (diferente de zero).
· Representação de um laço infinito com o comando for:
for (;;) {
comandos;
}
· É possível representar o comando for através do comando while:
expr-1;
while (expr-2) {
comandos;
expr-3;
}
·
O
comando for é claramente preferível ao comando while quando há inicializações e reinicializações.
·
Além
disso, utiliza-se o comando for quando o número de repetições é
conhecido; e o comando while, caso contrário.
·
O
operador "," é freqüentemente usado no comando for. Seu efeito
é fazer com que várias expressões sejam avaliadas da esquerda para a direita.
·
O
comando do-while é semelhante ao comando while, sendo que, o
teste (avaliação da expressão) acontece no final da execução do seu bloco de
comandos.
·
Forma
geral do comando do-while:
do {
comando;
} while (expressão);
·
O break permite a saída antecipada do laço ou switch.
·
Um
break faz com que o laço (ou switch) mais interno seja terminado
imediatamente.
·
O
comando continue inicia a próxima iteração do laço.
·
Dentro
do while e do do-while, o continue desvia para o teste; dentro do for, desvia para a execução da
próxima reinicialização (expr-3).
1 – Série de Fibonacci (código)
2 – Divisores de um número N (código)
3 – Números primos (código)
4 – Calculadora (código)