é equivalente a 
Para controlar eventos complexos, se requer a capacidade de tomar decisões e escolher entre várias opções disponíveis.
A linguagem C fornece duas potentes estruturas de decisão: if e switch.
As decisões podem ser representadas por fluxogramas com estruturas de tomada de decisão e encaminhamento do fluxo por um entre varios de blocos de comandos diferentes.
Um bloco, que pode ser simples ou composto, é um grupo de comandos escritos entre chaves.
O bloco simples contém apenas um comando e o composto contém vários comandos.
A decisão if tem como referência uma expressão lógica.
A expressão lógica é uma operação simples ou composta cujo resultado C avalia como verdadeira ou falsa.
If avalia a expressão e usa o resultado para escolher entre diversos cursos da ação.
As ações podem ser expressas como comandos isolados ou blocos de comandos.
é equivalente a
if simples: um comando apenas.
Sintaxe:
instrução anterior;
if(condição) comando;
instrução posterior;
Exemplo:
printf ("Digite o valor da densidade a 25 graus Celsius:");
scanf ("%f", &dens);
if (dens > 990)
printf("Esse produto e mais denso que a agua");
Mecanismo de funcionamento de if
A condição ( entre parenteses ) é avaliada:
if com bloco de comandos.
é equivalente a 
Sintaxe:
if(condição)
{
/* bloco de comandos */
}
Exemplo:
/*ex14.c programa para achar número maior*/
#include < stdio.h > /* diretiva */
main() /* função principal */
{
char parada; /* variáveis locais */
int inf, sup, aux;
clrscr();
printf ("Forneça um número inteiro:");
scanf ("%d", &inf);
printf ("Forneça um segundo número inteiro:");
while (1) /* laço de repetição infinito (retorno forçado do valor 1) */
{
scanf ("%d", &sup);
if (sup != inf)
break; /* decisão para sair do laço infinito*/
printf ("Os números devem ser diferentes!\n");
printf (" Forneça o segundo número:");
}
if ( inf > sup )
{
aux = inf;
inf = sup;
sup = aux;
}
printf (" O número maior é %d\n",sup);
parada = getche();
}
if com else simples: uma estrutura que decide entre dois cursos de ação.
Exemplo:
/* EX06: Obtenção do produto menos viscoso */
#include < stdio.h > /* diretiva */
int min (int x, int y) /* função */
{
if (x < y)
return (x);
else
return (y);
}
main () /* função principal */
{
int v1,v2, m, parada; /* variáveis locais */
char p1,p2,pp;
printf("\nVamos achar o menos viscoso entre dois produtos: \n");
printf("Entre com o nome do primeiro produto:"); scanf("%s", &p1);
printf("Entre com o valor da viscosidade:"); scanf("%f",&v1);
printf("Entre com o nome do segundo produto:"); scanf("%s", &p2);
printf("Entre com o valor da viscosidade:"); scanf("%f",&v2);
m = min(v1,v2);
if (m=v1)
pp=p1;
else
pp=p2;
printf("\n %s e o produto menos viscoso entre %s e %s \n", pp,p1,p2);
printf("\n Digite qualquer letra "); scanf("% i", parada);
}
Se a condição for verdadeira o programa executa o comando1, do contrário o comando2.
if com else sendo else com bloco de comandos.
Sintaxe:
instrução anterior;
if (condição A)
{
/* bloco1 (abre alas...)*/
}
else
{
/* bloco2 ( a bateria...)*/
}
instrução posterior;
Exemplo:
printf ("Escolha: insere ou remove\n")
scanf ("%s", escolha);
if (strcmp (escolha, insere))
{
printf ("Qual o valor a inserir? ");
scanf ("%d", &dado);
}
else
{
printf ("\n");
printf ("Não foi possível inserir\n");
}
printf("Terminou o procedimento");
Pode se observar que quando o comando é simples (único) as chaves não são necessárias. E também perceber que a notação dispensa o ponto e vírgula de final de instrução quando se usam as chaves nos comandos em bloco, porém dentro das chaves cada instrução deve ser finalizada com ponto e vírgula.
else if vários blocos.
Sintaxe:
instrução anterior;
if (condição)
{bloco de comandos}
else
if (condição)
{bloco de comandos}
else
{bloco de comandos}
instrução posterior;
Exemplo:
printf ("Qual é a temperatura");
scanf ("%i", &temp); if (temp < = 0)
{
estado = congelado;
frio ++;
}
else
if (temp > = 100)
{
estado = vapor;
quente ++;
}
else
{
estado = liquido;
morno ++;
}
printf ("frio %i morno %i quente %i", frio, morno, quente);
O programa executa o bloco onde a condição for verdadeira.
Como a decisão if com claúsulas else if, a estrutura switch foi projetada para selecionar uma atividade entre várias opções. Mas o comando switch faz suas escolhas procurando por uma coincidência entre um valor "seletor" e outros valores do mesmo tipo associados com cada opção.
Sintaxe:
instrução anterior;
switch (expressão)
{
case valor1: bloco1 (comissão de frente); break;
case valor2: bloco2 (a bateria); break;
case valor3: bloco3 (a ala das baianas); break;
default: bloco4 (os destaques...); exit(0)
}
instrução posterior;
Expressão é uma instrução que deve permitir a entrada de um valor para comparação.
switch procura uma coincidência entre o valor seletor e um dos valores oferecidos por case (valor1...valor3).
break finaliza enviando o controle para a instrução posterior da estrutura switch após uma opção case ter sido selecionada e executada.
default é opcional. Ela é executada se nenhum case for selecionado.
Exemplo:
/*ex12.c exemplo de estrutura de controle alternativa múltipla*/
#include < stdio.h > /* diretiva */
main() /* função principal */
{
char parada; /* variáveis locais */
char c;
int x =40, y = 20; /* atribuição */
clrscr();
printf ("Deslocamento? (a,b,c,d,):");
c = getchar();
switch (c)
{
case 'a' : y ++; break;
case 'b' : y --; break;
case 'c' : x --; break;
case 'd' : x ++; break;
default: printf ("\n resp. incorreta!"); exit(0);
}
printf ("Posição: %d %d \n",x,y);
parada = getche();
}
A repetição é a essência de muitas aplicações do computador. É uma estrutura de controle que comanda processos repetitivos em um programa. Como estruturas de decisão, uma repetição marca um bloco de comandos para manipulação especial.
O Borland C fornece três estruturas de repetição distintas, cada com um esquema diferente para controlar o processo interativo:
foreste laço especifica explicitamente o limite de iterações antecipadamente, e normalmente trabalha com uma variável índice, o valor da qual aumenta ou diminui conforme o comportamento da repetição. A variável índice conta as iterações; a repetição para quando um total predeterminado é atingido.
while esta estrutura expressa uma condição para manter a repetição. A condição está localizada no topo da repetição, e as iterações param quando a condição torna-se falsa. É possivel que o comando dentro do laço não seja realizado nem ao menos uma vez.
do while esta estrutura também contém uma expressão condicional de controle, mas nesse caso a condição é expressa na parte inferior da repetição.
O comando do laço é realizado pelo menos uma vez.
Este laço é talvez a mais familiar e comunente usada estrutura de repetição em programação.
Sintaxe:
Forma simples: com um comando apenas.
Exemplo:
/* EX05: Toque repetido da campainha */
#include < stdio.h > /* diretivas */
#define BELL '\007'
void ring(int k) /* função */
{
int i;
for (i = 0; i < = k; i++)
printf("%c", BELL);
}
main () /* função principal */
{
int n; /* variável local */
void ring(int); /* prototipo de função */
clrscr();
printf ("Entre com um inteiro pequeno:");
scanf("%d", &n);
ring(n - 1);
}
for com bloco contendo múltiplos comandos:
Exemplo:
/*ex17.c vetor */
#include < stdio.h > /* diretivas */
#define DIM_VECT 10
int vect [DIM_VECT] = {4,10,15,3,8,6,35,67,5,9}; /* inicialização de matriz */
main()
{
char parada;
int val_aux, i, j;
clrscr();
printf ("Vector inicial:");
for (i = 0; i < DIM_VECT; i++)
printf ("%3d", vect [i]);
for (i = 0; i < DIM_VECT - 1; i++)
for (j = 0; j < DIM_VECT; j++)
{
if (vect [j] > vect [j + 1]) {
val_aux = vect [j];
vect [j] = vect [j + 1];
vect [j +1] = val_aux;
}
printf ("\nVector reorganizado.");
for (i = 0 ; i < DIM_VECT; i++)
printf ("%3d",vect [i]);
parada = getche();
}
Comandos dentro de um bloco de repetição for podem utilizar-se da variável índice para finalidade específicas.
O papel usual das três expressões está em inicializar, testar e incrementar uma variável índice que controla a repetição.
expressão1 comando de atribuição que fornece um valor inicial à variável índice.
expressão2 expressão lógica que executa um teste com o valor atual da variável índice. Este teste determina a extensão da repetição.
expressão3 comando que incrementa ou decrementa o valor da variável índice após toda iteração.
O laço for avalia a condição, se a condição for falsa, antes da primeira iteração, a repetição não executará ação alguma.
A linguagem C permite que o comando for execute inicializações e incrementos múltiplos. As três expressões do for pode realmente consistir em comandos múltiplos, separados por vírgulas. Também pode colocar uma repetição dentro do bloco executável de uma outra repetição, para formar repetições aninhadas.
Exemplo:
for (i = 0; i < NUMCLI - 1; i++)
for (j = i + 1; j < NUMCLI; j++)
if ( clibill[i].hours < clibill[j].hours)
{
/* troca as estruturas */
holdcli = clibill[i];
clibill[i] = clibill[j];
clibill[j] = holdcli;
}
Também o while testa a condição antes de cada iteração e não executa ação alguma se sua condição for falsa.
O do-while testa a condição após cada iteração, portanto do-while executa
uma iteração se a condição for falsa no ínicio.
while simples: um comando apenas.
Exemplo:
/* ex46.c repetição while */
#include < stdio.h > /* diretiva */
main( ) /* função principal */
{
int valor_a;
valor_a = 0;
while (valor_a < 10)
valor_a ++;
print ("valor final = %d\n", valor_a);
}
Com múltiplos comandos:
Sintaxe:
instrução anterior;
while(condição)
{
/* bloco de comandos */
}
instrução posterior;
Exemplo:
/* ex47.c comando while com bloco de comando */
#include < stdio.h > /* diretiva */
main( ) /* função principal */
{
int valor_a, valor_b;
valor_a = 0; /* atribuição */
while (valor_a < 20)
{
valor_a ++;
if (valor == 10)
break;
}
valor_b = valor_a;
print ("valor final de valor_b = %d\n", valor_b);
}
Sintaxe:
Exemplo:
/* Ex34.c Calculo da potencia de um agitador*/
#include < stdio.h > /* diretiva */
main() /* função principal */
{
int escolha;
float k, dens, visc, n, diam, p;
char parada;
clrscr();
do
{
printf ("Selecione uma opção: \n");
printf ("1 - Laminar\n");
printf ("2 - Turbulento\n");
scanf ("%d", &escolha);
} while ((escolha < 1) || (escolha > 2));
printf ("Qual o valor de k: "); scanf ("%f", &k); printf ("\n");
printf ("Qual o valor da densidade: "); scanf ("%f", &dens); printf ("\n");
printf ("Qual o valor da viscosidade: "); scanf ("%f", &visc); printf ("\n");
printf ("Qual o valor de n: "); scanf ("%f", &n); printf ("\n");
printf ("Qual o valor do diametro da pa: "); scanf ("%f", &diam); printf ("\n");
switch (escolha) /* comando de decisão */
{
case 1 : p = k*visc*n*n*diam*diam*diam; break;
case 2 : p = k*dens*n*n*n*diam*diam*diam*diam*diam; break;
}
printf ("Potencia = %f\n", p);
parada = getche();
}
Efeitos dos comandos break e continue
Nas repetições , o break sai do bloco incondicionalmente. A repetição é imediatamente interrompida.
Já o continue pára a interrupção, mas volta para reavaliar a condição de repetição no do() while ou no while, e pula para o incremento da variável de controle do for.
 Voltar à HomePage |
 Ir para o topo da Página |
 Ir para a Aula 4 - Subtema 3 |
|---|