Ferramentas do usuário

Ferramentas do site


prog2:controle_de_fluxo

Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.

Link para esta página de comparações

prog2:controle_de_fluxo [2019/01/31 17:27]
127.0.0.1 edição externa
prog2:controle_de_fluxo [2019/03/19 14:32] (atual)
maziero [Exercícios]
Linha 1: Linha 1:
 +====== Controle de fluxo em C ======
  
 +===== Decisões =====
 +
 +=== Estrutura if ===
 +
 +<code c>
 +if (expression)
 +  command ;
 +</​code>​
 +
 +ou
 +
 +<code c>
 +if (expression)
 +{
 +  command ;
 +  command ;
 +  ...
 +}
 +</​code>​
 +
 +<note important>​
 +A estrutura "​if"​ pode testar qualquer expressão cujo resultado possa ser avaliada como número, sendo que 0 (zero) é considerado falso e não-zero é verdadeiro.
 +</​note>​
 +
 +Ifs aninhados:
 +
 +<code c>
 +if (expression1)
 +  if (expression2)
 +  {
 +    command ;
 +    command ;
 +    ...
 +  }
 +</​code>​
 +
 +=== Estrutura if-else ===
 +
 +<code c>
 +if (expression)
 +  command1 ; // <--- there is a semicolon here!
 +else
 +  command2 ;
 +</​code>​
 +
 +ou
 +
 +<code c>
 +if (expression)
 +{
 +  command1a ;
 +  command1b ;
 +  command1c ;    ​
 +}
 +else
 +{
 +  command2a ;
 +  command2b ;
 +}
 +</​code>​
 +
 +If-else aninhados:
 +
 +<code c>
 +if (expression1)
 +  if (expression2)
 +    command1 ;
 +  else
 +    command2 ;
 +else
 +  command3 ;
 +</​code>​
 +
 +<note important>​
 +A cláusula ''​else''​ sempre se combina com o último ''​if''​ em aberto; caso se deseje forçar outra combinação,​ deve-se usar chaves ({...}) para organizar a abertura/​fechamento das estruturas "​if"​.
 +</​note>​
 +
 +=== Estrutura switch ===
 +
 +<code c>
 +switch (expression)
 +{
 +  case constant1:
 +       ​command1 ;
 +       ...
 +       break ;
 +  case constant2:
 +       ​command2 ;
 +       ...
 +       break ;
 +  case constant3:
 +  case constant4:
 +       ​command34a ;
 +       ...
 +       break ;
 +  ...
 +  default:
 +       ​commandNa;​
 +       ...
 +       break ;
 +}
 +</​code>​
 +
 +Exemplo (contagem de carros):
 +
 +<code c>
 +ch = getchar();
 +
 +switch(ch)
 +{
 +  case ‘C’:
 +  case ‘c’:
 +    corsa++ ;
 +    break ;
 +  case ‘P’:
 +    prisma++ ;
 +    break ;
 +  case ‘p’:
 +    palio++ ;
 +    break ;
 +  default:
 +    outros++ ;
 +    break ;
 +}
 +</​code>​
 +
 +=== Estrutura condicional ternária ===
 +
 +A expressão
 +
 +<code c>
 +expression1 ? expression2 : expression3 ;
 +</​code>​
 +
 +é equivalente a 
 +
 +<code c>
 +if (expression1)
 +  expression2 ;
 +else
 +  expression3 ;
 +</​code>​
 +
 +Exemplo:
 +
 +<code c>
 +x = x < 5 ? x + 1 : 1 ;
 +</​code>​
 +
 +equivale a:
 +
 +<code c>
 +if (x < 5)
 +  x = x + 1 ;
 +else
 +  x = 1 ;
 +</​code>​
 +
 +===== Laços =====
 +
 +=== Estrutura while ===
 +
 +<code c>
 +while (expression)
 +  command ;
 +</​code>​
 +
 +ou
 +
 +<code c>
 +while (expression)
 +{
 +  command1 ;
 +  command2 ;
 +  ...
 +}
 +</​code>​
 +
 +Exemplo:
 +
 +<code c>
 +i = 0 ;
 +while (i < 100)
 +{
 +  printf ("i vale %d\n", i) ;
 +  i++ ;
 +}
 +</​code>​
 +
 +=== Estrutura do-while ===
 +
 +<code c>
 +do
 +  command ;
 +while (expression) ;
 +</​code>​
 +
 +ou
 +
 +<code c>
 +do
 +{
 +  command1 ;
 +  command2 ;
 +  ...
 +}
 +while (expression) ;
 +</​code>​
 +
 +Exemplo:
 +
 +<code c>
 +i = 100 ;
 +do
 +{
 +  printf ("i vale %d\n", i) ;
 +  i-- ;
 +}
 +while i ;
 +</​code>​
 +
 +=== Estrutura for ===
 +
 +<code c>
 +for (initializations;​ conditions; updates)
 +  command ;
 +</​code>​
 +
 +ou
 +
 +<code c>
 +for (initializations;​ conditions; updates)
 +{
 +  command1 ;
 +  command2 ;
 +  ...
 +}
 +</​code>​
 +
 +Exemplo: um laço de repetição com a variável de controle indo de 0 a 99:
 +
 +<code c>
 +for (i = 0; i < 100; i++)
 +  printf ("i vale %d", i) ;
 +</​code>​
 +
 +Deve-se observar que a estrutura ''​for''​ equivale a:
 +
 +<code c>
 +initializations;​
 +while (conditions)
 +{
 +  command1 ;
 +  command2 ;
 +  ...
 +  updates ;
 +}
 +</​code>​
 +
 +Então o exemplo acima pode ser reescrito como:
 +
 +<code c>
 +i = 0 ;                     // inicialização
 +while (i < 100)             // condição
 +{
 +  printf ("i vale %d", i) ;
 +  i++ ;                     // update
 +}
 +</​code>​
 +
 +Uma forma peculiar uso do ''​for''​ é o laço infinito, que não tem inicialização,​ condição nem update:
 +
 +<code c>
 +for (;;)
 +{
 +}
 +</​code>​
 +
 +===== Desvios =====
 +
 +=== Comando break ===
 +
 +O comando ''​break''​ só é usado dentro de blocos ''​switch'',​ ''​do'',​ ''​while''​ ou ''​for''​. Ao ser acionado, ele salta a execução para o primeiro comando após o bloco atual.
 +
 +Exemplo:
 +
 +<code c>
 +for (;;)
 +{
 +  printf ("​Aceita?​ (s/n) ") ;
 +  resp = getchar() ;
 +  if(resp == '​s'​ || resp == '​n'​)
 +    break;
 +  printf ("​\n"​) ;
 +}
 +// o break salta para cá 
 +</​code>​
 +
 +=== Comando continue ===
 +
 +O comando ''​continue''​ é usado em laços ''​for'',​ ''​do''​ e ''​while''​. Ele interrompe a iteração atual e inicia a próxima iteração do laço onde se encontra.
 +
 +Exemplo:
 +
 +<code c>
 +int i;
 +
 +for (i = -10; i < 10; i++)
 +{
 +  if (i == 0)
 +    continue; // pula para a próxima iteração
 +  printf("​%f\n",​ 15.0/i);
 +  // ...
 +}
 +</​code>​
 +
 +=== Comando goto ===
 +
 +O comando ''​goto''​ permite saltar a execução para locais definidos por rótulos ou etiquetas (//​labels//​),​ como mostra o exemplo a seguir:
 +
 +<code c>
 +goto PARTE2;
 +
 +// ... (qualquer código)
 +
 +PARTE2:
 +i = 0 ;
 +// ...  ​
 +</​code>​
 +
 +<note warning>
 +O comando ''​goto''​ deve ser usado com muito cuidado, pois ele pode tornar o fluxo de execução muito complexo (e portanto sujeito a erros). Como regra geral, **evite utilizá-lo**,​ a não ser que seja absolutamente necessário.
 +</​note>​
 +
 +=== Comando return ===
 +
 +O comando ''​return''​ encerra a função atual e retorna ao ponto de onde ela foi chamada. Ele pode ser chamado em qualquer local da função, não necessariamente no final dela.
 +
 +Exemplo:
 +
 +<code c>
 +int compara (int a, b)
 +{
 +  if (a > b) return ​ 1 ;
 +  if (a < b) return -1 ;
 +  if (a == b) return ​ 0 ;
 +}
 +</​code>​
 +
 +=== Comando exit ===
 +
 +A função ''​exit (int status)''​ é provida pela biblioteca de sistema ''​stdlib.h''​ e permite o encerramento da aplicação. O status informado como parâmetro é devolvido ao sistema operacional (mais especificamente ao shell que lançou a aplicação).
 +
 +<code c>
 +exit (0) ;
 +</​code>​
 +
 +=== Comando assert ===
 +
 +''​assert''​ é uma macro que verifica uma asserção (condição) e encerra o programa se ela for falsa (nula). Ao encerrar, uma mensagem de erro indicando a localização da asserção violada é gerada, o que facilita localizar problemas.
 +
 +<code c>
 +#include <​assert.h>​
 +
 +int main()
 +{
 +  ...
 +  assert (i >= 0) ;
 +  ...
 +}
 +</​code>​
 +
 +Se a condição i >= 0 for falsa, o programa será interrompido e a seguinte mensagem será gerada, indicando o arquivo (''​program.c''​),​ a linha (6), a função (''​main''​) e a asserção violada:
 +
 +  a.out: program.c:​6:​ main: Assertion `i >= 0' failed.
 +
 +===== Exercícios =====
 +
 +Escrever programas em C para:
 +
 +  - Dados três números inteiros positivos, informar que tipo de triângulo eles definem:
 +    * //​equilátero//:​ 3 lados iguais;
 +    * //​isósceles//:​ 2 lados iguais;
 +    * //​escaleno//:​ 3 lados distintos;
 +    * //​degenerado//:​ um lado é igual à soma dos outros dois;
 +    * //​impossível//:​ um lado é maior que a soma dos outros dois.
 +  - Dado um número inteiro positivo, determinar se ele é primo ou não.
 +  - Dados os números reais //a//, //b// e //c//, calcular as raízes de uma equação do 2º grau na forma ''​ax² + bx + c = 0''​. O programa deve informar se as raízes são reais ou complexas.
 +  - Calcular o valor de π usando os 10.000 primeiros termos da [[https://​en.wikipedia.org/​wiki/​Leibniz_formula_for_%CF%80|série de Gregory]].
 +  - Dado um número inteiro 0 < n < 4000, escrevê-lo como número romano (exemplo: 1965 = MCMLXV).
 +  - Dado N > 1 e dois números naturais i e j diferentes de 0, imprimir em ordem crescente os N primeiros naturais que sejam múltiplos de i, de j ou de ambos. Exemplo: Para N = 6, i = 2 e j = 3 a saída deverá ser: 0, 2, 3, 4, 6, 8.
 +  - Dado um número //x// real positivo, calcular √x real com //c// casas decimais, por aproximação.
prog2/controle_de_fluxo.txt · Última modificação: 2019/03/19 14:32 por maziero