· 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.
·
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 |
· O comando if-else é usado para expressar decisões (executar testes condicionais) no programa.
· Observe o programa abaixo:
/*
UFCG/CCT/DSC - Introducao a Programacao
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 1.0
*/
#include <stdio.h>
#include <conio.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);
}
}
}
· 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:
/*
UFCG/CCT/DSC - Introducao a Programacao
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 2.0
*/
#include <stdio.h>
#include <limits.h>
#include <conio.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);
}
·
A versão anterior do programa pode ainda ser melhorada
para encontrar o maior valor de três:
/*
UFCG/CCT/DSC - Introducao a Programacao
Este programa determina o maior de um grupo
de 3 valores inteiros
Versao 3.0
*/
#include <stdio.h>
#include <conio.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):
";
clrscr();/*comando para limpar a tela*/
/*entrada de dados*/
printf("%s",
prompt);
scanf("%d %d %d",
&valor1, &valor2, &valor3);
/* considera o primeiro valor como o maior
valor até então e reduz um teste */
maior = valor1;
/*processamento*/
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);
}
· 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 exemplo a seguir imprime por extenso dígitos decimais através de uma decisão múltipla:
/*
UFCG/CCT/DSC - Introducao a Programacao
Este programa escreve dígitos por extenso
Versão 1.0
*/
#include
<stdio.h>
#include <conio.
void main() {
/*declaracao de variaveis*/
int digito;
clrscr();/*comando para limpar a tela*/
/*entrada de dados*/
printf("Informe o dígito
decimal:\n");
scanf("%d", &digito);
printf(“\n\nO digito informado foi ”);
if (digito == 0) {
printf(“zero\n”);
} else if (digito ==
1) {
printf(“um\n”);
} else if (digito ==
2) {
printf(“dois\n”);
} else if (digito ==
3) {
printf(“três\n”);
} else if (digito ==
4) {
printf(“quatro\n”);
} else if (digito ==
5) {
printf(“cinco\n”);
} else if (digito ==
6) {
printf(“seis\n”);
} else if (digito ==
7) {
printf(“sete\n”);
} else if (digito ==
8) {
printf(“oito\n”);
} else if (digito ==
9 {
printf(“nove\n”);
} else {
printf(“Digito inválido!\n”);
}
}
· 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-inteira) {
case expressão-inteira-constante:
comandos;
case expressão-inteira-constante:
comandos;
. . .
default:
comandos;
}
·
Exemplo de uso do comando switch:
/*
UFCG/CCT/DSC - Introducao a Programacao
Este programa escreve dígitos por extenso
Versão 2.0
*/
#include
<stdio.h>
#include <conio.h>
void main() {
/*declaracao de variaveis*/
int digito;
clrscr();/*comando para limpar a tela*/
/*entrada de dados*/
printf("Informe o dígito
decimal:\n");
scanf("%d", &digito);
printf(“\n\nO digito informado foi “);
switch(digito) {
case 0:
printf(“zero\n”);
break;
case 1:
printf(“um\n”);
break;
case 2:
printf(“dois\n”);
break;
case 3:
printf(“três\n”);
break;
case 4:
printf(“quatro\n”);
break;
case 5:
printf(“cinco\n”);
break;
case 6:
printf(“seis\n”);
break;
case 7:
printf(“sete\n”);
break;
case 8:
printf(“oito\n”);
break;
case 9:
printf(“nove\n);
default:
printf(“Digito inválido!\n”);
}
}
/*
UFCG/CCT/DSC - Introducao a
Programacao/2001.1
Este programa determina o maior de um grupo
de N valores inteiros
Versao 4.0
*/
#include <stdio.h>
#include <conio.h>
#include <limits.h>
void
main() {
/*declaracao de variaveis*/
int valor, maior;
char resposta;
const char prompt[] = "\nDigite um valor
inteiro de cada vez para localizar o maior:";
const char prompt2[] = "\nOutro
valor?\n(tecle \'s\' para sim e \'n\' para terminar): ";
clrscr(); /*comando para limpar a tela*/
/*INT_MIN: constante pre-definida da
linguagem, equivale ao valor minino de "int"*/
maior = INT_MIN;
resposta = 's'; /* inicializa obrigando o
primeiro a ser digitado */
/*processamento*/
while (resposta == 's') {
printf
("%s", prompt);
scanf("%d",
&valor);
if (valor > maior) {
maior = valor;
}
printf("%s", prompt2);
scanf(“\n%c”, &resposta);
}
/*saida de dados*/
printf ("\nMaior valor digitado =>
%d", maior);
}
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:
/*
UFCG/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);
}
· 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)