Operadores relacionais

• Operadores binários para comparações entre expressões numéricas:

  menor que	<
  maior que	>
  menor ou igual	<=
  maior ou igual	>=
  igual	==
  diferente	!=

• O resultado é inteiro: 0 se a condição for falsa, 1 se a condição for verdadeira

Exemplos

int i, j;
i = 2;
j = 4;
printf("%d\n", i > j);     // imprime 0
printf("%d\n", i < j);     // imprime 1
printf("%d\n", i*i == j);  // imprime 1
printf("%d\n", i*j >= 10); // imprime 0

Precedência e associatividade

• Operadores relacionais têm precedência inferior do que os aritméticos
  • i + j < k - 1 equivale a (i+j)<(k-1)
• Operadores relacionais associam à esquerda

Atenção

A expressão

   i < j < k 

é válida mas não testa se j está entre i e k:

• < associa à esquerda, logo a expressão acima é equivalente a (i<j) < k
• ou seja: compara k com o resultado da comparação i<j (0 ou 1)

A expressão correta usa a conjunção de duas condições:

   i < j && j < k   

Comparações de igualdade

• Dois operadores: == (igual) e != (diferente)
• Resultado é 0 ou 1 (falso/verdadeiro)

int i, j;
i = 2;
j = 3;
printf("%d\n", i == j);   // imprime 0
printf("%d\n", i+1 == j); // imprime 1
printf("%d\n", i != j);   // imprime 1

Atenção

Não confundir atribuições com comparações:

i = j

modifica o lado esquerdo; resultado é o valor atribuido

i == j

compara o lados esquerdo e o direito; resultado é 0 ou 1

Instrução if

• A instrução if executa condicionalmente uma instrução conforme o resultado de uma expressão
• Forma mais simples:
  if ( expressão ) instrução
• Calcula o valor da expressão; se o resultado for diferente de zero, então executa a instrução
• Em qualquer caso, continua executando as instruções seguintes

if ( line_num == MAX ) line_num = 0;
// continuação do programa
...

Instrução if

• Se quisermos executar condicionalmente mais do que uma instrução devemos agrupá-las num bloco:
  
   { instruções }
  
  
• As chavetas forçam o compilador a tratar um bloco de instruções como uma só
• Cada instrução dentro do bloco termina com ponto-e-vírgula
• Não acrescentamos ponto-e-vírgula depois de fechar chavetas

Exemplo

Podemos colocar numa só linha:

if (line_num == MAX) { line_num = 0; page_num ++; } 

Mas fica mais claro se partimos em várias linhas:

if (line_num == MAX)
{
   line_num = 0;
   page_num ++;
} 

Alternativa else

• A instrução if pode incluir uma alternativa else:
  
   if ( expressão ) instrução else instrução
  
  
• A instrução a seguir ao else é executada se a expressão tiver valor zero (i.e. for falsa)

Exemplo:

if (i > j) max = i; else max = j;

Alternativa else

• Podemos incluir instruções if dentro de outros ifs
• Nesse casos será útil usar indentação para explicitar a estrutura

if (i > j)
   if (i > k)
      max = i;
   else
      max = k;
else
   if (j > k)
      max = j;
   else
      max = k;

Alternativa else

Podemos também acrescentar chavetas para auxiliar a compreensão:

if (i > j) {
   if (i > k)
      max = i;
   else
      max = k;
} else {
   if (j > k)
      max = j;
   else
      max = k;
}

Alternativa else

Há quem prefira colocar sempre chavetas:

if (i > j) {
   if (i > k) {
      max = i;
   } else {
      max = k;
   }
} else {
   if (j > k) {
      max = j;
   } else {
      max = k;
   }
}

Vantagens

Ao colocarmos sempre chavetas:

• mais fácil acrescentar instruções dentro do if ou do else
• evitamos erros resultantes de esquecer as chavetas ao acrescentar instruções

if em “cascata”

Para testar condições em sequência escrevemos múltiplas instruções if em “cascata”.

Exemplo:

if (n < 0)
   printf("n negativo\n");
else
   if (n == 0)
      printf("n zero\n");
   else
      printf("n positivo\n");

if em “cascata”

Apesar do segundo if estar dentro do primeiro, é preferível alinhar os else em vez de indentar:

if (n < 0)
   printf("n negativo\n");
else if (n == 0)
   printf("n zero\n");
else
   printf("n positivo\n");

if em “cascata”

Desta forma evitamos a indentação exagerada quando temos muitas condições.

if (expressão)
  instrução
else if(expressão)
  instrução
...
else if(expressão)
  instrução
else
  instrução

Exemplo: calcular comissões

• Quando um corretor vende ações cobra uma comissão cujo valor depende do montante transacionado
• Vamos escrever um programa para calcular a comissão conforme a tabela seguinte
• A comissão mínima a cobrar deve ser €39

Exemplo: calcular comissões

• O programa corretor.c lê o valor da transação, calcula a comissão e imprime-a:

Introduza o valor: EUR 30000
Comissão: EUR 166.00

• O núcleo do programa é uma sequência de if em cascata para determinar em que intervalo está o valor
• No final incluimos uma condição extra para garantir que cobramos sempre o valor mínimo

/* corretor.c
   Calcular a comissão de uma transação
*/
#include <stdio.h>

int main(void)
{
  float valor, comissao;

  printf("Introduza o valor: EUR ");
  scanf("%f", &valor);

  if(valor < 2500.0)
    comissao = 30.0 + 0.017 * valor;
  else if(valor < 6250.0)
    comissao = 56.0 + 0.0066 * valor;

(continua no slide seguinte)

(continuação do slide anterior)

  else if(valor < 20e3)
    comissao = 76.0 + 0.0034 * valor;
  else if(valor < 50e3)
    comissao = 100.0 + 0.0022 * valor;
  else if(valor < 500e3)
    comissao = 155.0 + 0.0011 * valor;
  else
    comissao = 255.0 + 0.0009 * valor;

  if (comissao < 39.0)
    comissao = 39.0;

  printf("Comissão: EUR %.2f\n", comissao);
}

Operadores lógicos

Podemos construir condições complexas partindo de outras mais simples usando operadores lógicos.

Exemplos:

i>=0 && i<10 
i==j || i+j==0
!(i==0)

Operadores lógicos

• Os operadores lógicos são frequentemente usados para combinar comparações
• Por exemplo, para testar se uma variável i está dentro de um intervalo:
  
  if (0 <= i && i < n) ...
  
  
• Para testar a condição oposta (i está fora do intervalo):
  
  if (0 > i || i >= n) ...

Operadores lógicos

• O operador ! é unário enquanto && e || são binários
• Operam sobre inteiros
• Qualquer valor diferente de 0 é considerado verdadeiro; o valor 0 é falso
• O resultado de um operador lógico é 0 ou 1

Resultados dos operadores lógicos

!\(expr\)

resultado 1 se \(expr\) tem valor 0

\(expr_1\) && \(expr_2\)

resultado 1 se \(expr_1\) e \(expr_2\) são ambos diferentes de 0

\(expr_1\) || \(expr_2\)

resultado 1 se \(expr_1\) é diferente de 0 ou \(expr_2\) é diferente de 0 (ou ambos são diferentes de 0)

Em todos os outros casos: o resultado é 0.

Ordem de avaliação

• Os operadores && e || avaliam primeiro o lado esquerdo e só depois o lado direito
• Se o resultado poder ser determinado pelo valor do lado esquerdo, o lado direito não será calculado
  (isto é por vezes designado “short-circuit evaluation”)

Ordem de avaliação — exemplo

   (i != 0) && (j/i > 0)

1. Primeiro é avaliada a condição i != 0
2. Se i for diferente de 0, então é avalia j/i > 0
3. Se i for 0 então a conjução será sempre falsa e não avaliamos j/i > 0 (evitando a divisão por zero)

Precedência e associatividade

• && e || têm menor precedência que os operadores de comparação e associam à esquerda
• ! tem precedência igual a + e - unários e associa à direita

Exemplos:

i < j && k < m

é equivalente a (i < j) && (k < m)

i < j && j < k && k < l

é equivalente a ((i < j) && (j < k)) && (k < l)

!i == 0

não é equivalente a i != 0

Cuidados com if

Um erro comum é trocar == (igualdade) por = (atribuição)

if (i == 0) ...

testa se i é igual a 0

if (i = 0) ...

atribui 0 a i e depois testa se o resultado é diferente de 0 (o que é sempre falso)

Recomendação: o gcc avisa possíveis erros deste tipo compilando com a opção -Wall

Cuidados como o else

Ao colocarmos if dentro de outro, temos de ter o cuidado de “casar” corretamente os else:

if (y != 0)
   if (x != 0)
      result = x / y;
else
   printf("erro: y igual a 0\n");

• A indentação sugere que o else associa ao if mais exterior
• Mas a regra em C é que o else associa ao if mais próximo (o interior)

Cuidados com o else

Uma versão corretamente indentada seria assim:

if (y != 0)
   if (x != 0)
      result = x / y;
   else
      printf("erro: y igual a 0\n");

Cuidados com o else

Para associar o else ao if exterior temos de delimitar o if interior usando chavetas:

if (y != 0) {
   if (x != 0)
      result = x / y;
} else
   printf("erro: y igual a 0\n");

Recomendação: para evitar estes problemas use sempre chavetas num if que contém outro if

Funções

• Uma função agrupa uma sequência de instruções com um nome
• Cada função pode receber argumentos e retornar um valor
• Cada função é um sub-programa com as suas declarações e instruções próprias

Objetivo

• Dividir o programa em componentes separadas
  • cada função tem um objetivo bem identificado
  • argumentos e resultados esperados bem definidos
• Podem ser desenvolvidas e estudadas independentemente
• Podem ser testadas separadamente
• Podem ser re-utilizadas em diferentes programas

Exemplo

Uma função que calcula a média aritmética de dois valores:

float media(float a, float b)
{ 
   float m = (a + b) / 2.0;
   return m;
}

• O identificador da função é media
• O tipo float antes do identificador indica o tipo do resultado
• Os parâmetros a e b são os dois valores de tipo float que devem fornecidos para executar a função

Corpo da função

O corpo da função está delimitado entre chavetas:

{
   float m = (a + b) / 2.0;
   return m;
}

• calcula o valor de média (usando uma variável auxiliar m)
• a instrução return termina a função e devolve o resultado ao contexto onde a função foi chamada

Invocação da função

Um expressão: identificador(arg1, arg2, …)

Fluxo de execução

• A execução do programa começa pelo main
• main pode chamar outra função e assim sucessivamente
• Apenas são executadas as funções chamadas pelo main (direta ou indirectamente)
• Os argumentos passados a funções podem ser quaisquer expressões do tipo válido

    z = media(x*0.5, y+1);

• Podemos usar o resultado imediatamente em vez de o guardar numa variável

    printf("%f\n", media(x*0.5,y+1));

Exemplo: calcular médias

Vamos escrever um programa que lê três números e calcula as médias dois a dois.

Introduza 3 números: 3.5 9.6 10.2
Médias
3.5 e 9.6: 6.55
9.6 e 10.2: 9.9
3.5 e 10.2: 6.85

#include <stdio.h>

float media(float a, float b) {
  float m = (a + b)/2;
  return m;
}

int main(void) {
  float x, y, z;
  printf("Introduza 3 números: ");
  scanf("%f %f %f", &x, &y, &z);
  printf("Médias\n");
  printf("%f e %f: %f\n", x, y, media(x,y));
  printf("%f e %f: %f\n", y, z, media(y,z));
  printf("%f e %f: %f\n", x, z, media(x,z));
  return 0;
}

Declarações e definições

• Se colocarmos a definição da função antes do seu uso não temos de declarar mais nada
• Mas se usarmos a função antes da definição devemos colocar uma declaração de protótipo:

    float media(float, float);

• Em C89/90: se usarmos uma função sem a declararmos o compilador assume que retorna int
• Em C99: usar uma função antes da definição ou declaração resulta num erro de compilação

Exemplo

float media(float, float); // protótipo

int main(void) {
 ...
 printf(..., x, y, media(x,y));   // uso
 ...
 return 0;
 }

float media(float a, float b) {  // definição
   m = (a + b)/2.0;
   return m;
}

Funções sem valor de retorno

• Por vezes podemos querer definir funções que não retornam um valor
• Executamo-las apenas pelos seus efeitos colaterais
  • e.g. imprimir mensagems na saida-padrão
• Nesse caso o tipo do resultado é void
• Não necessitamos de return
• Não usamos o resultado

Exemplo

void print_time(int n)
{
  printf("T minus %d and counting\n", n);
}

int main(void) {
    print_time(3);
    print_time(2);
    print_time(1);
    return 0;
}

Instrução return

• Uma função com tipo diferente de void deve usar a instrução return para especificar o resultado
• A forma geral é:
  
  return expressão ;
  
  
• Não são necessário parêntesis à volta da expressão
• Por vezes a expressão é uma constante ou variável, mas pode ser uma expressão complexa:

  return 0;
  return n;
  return (x + y) / 2.0;

Instrução return

Podemos usar return para terminar a execução da função a meio do corpo.

int max(int a, int b)
{
   if(a >= b)
       return a;  // termina imediatamente
           
   // se a execução chegar a este ponto,
   // então a < b; logo o máximo é b
   return b;
}

Instrução return

• Também podemos usar return em funções que não retornam resultados (void)
• Nesse caso return serve apenas para terminar a execução da função
• Omitimos a expressão

void print_time(int n)
{
    if (n < 0)
        return;   // terminar imediatemente
    printf("T minus %d and counting\n", n);
}

Quando usar múltiplos return

• Usar múltiplos return pode dificultar a compreensão do fluxo de execução
• Recomendação: usar apenas para terminar uma função em casos especiais (e.g. de erro)

Passagem de argumentos

• Os argumentos das funções em C são passados por valor
  • cada expressão é avaliada e o seu valor é copiado para um parâmetro local à função
• Logo, os parâmetros de funções comportam-se como variáveis temporárias - modificações dos argumentos não são visíveis depois do retorno da função

Exemplo 1

// máximo de 2 valores
// NB: modifica o primeiro argumento
int max(int a, int b) {
    if (b > a)
        a = b;
    return a;
}

int main(void) {
   int x = 1, y = 2;
   printf("%d\n", max(x,y)); // imprime 2
   printf("%d %d\n", x, y); // imprime 1, 2
   return 0;
}

Exemplo 2

// Tenta trocar os valores de a, b;
// não funciona porque a,b são temporários
void trocar(int a, int b) {
   int t;
   t = a;
   a = b;
   b = t;
}

int main(void) {
   int x = 1, y= 2;
   trocar(x, y);  
   printf("%d %d\n", x, y); // imprime 1, 2
   return 0;
}

Decomposição funcional

• As funções permitem decompor problemas em partes mais simples
• Objetivo: combinar as partes para resolver o problema original
  • analogia: peças de Lego
• Esta metodologia de “dividir para conquistar” permite construir programas simultaneamente elegantes e eficientes

Exemplo: imprimir algarismos

Escrever um programa que imprime os algarismos das dezenas e unidades de um inteiro até 99.

Exemplos de execução:

12
um dois 

78
sete oito 

7
zero sete

Sub-problema

Dado o valor de um algarismo de 0–9, imprimir o texto correspondente em português:

Função auxiliar

Vamos definir uma função auxiliar:

void imprime_algarismo(int a);

• o argumento é um inteiro (o valor do algarismo)
• a função imprime o texto e não retorna um valor útil (resultado void)

Função auxiliar

void imprime_algarismo(int a) {
  if (a == 0)
    printf("zero");
  else if (a == 1)
    printf("um");
  else if (a == 2)
    printf("dois");
  else if (a == 3)
    printf("três");
  else if (a == 4)
    printf("quatro");

(continua no slide seguinte)

(continuação do slide anterior)

  else if (a == 5)
    printf("cinco");
  else if (a == 6)
    printf("seis");
  else if (a == 7)
    printf("sete");
  else if (a == 8)
    printf("oito");
  else if(a == 9)
    printf("nove");
  else 
    printf("algarismo inválido!");
}

Solução do problema original

• Usar a função auxiliar duas vezes:
  • imprimir o algarismo das dezenas
  • imprimir o algarismos das unidades
• Podemos obter estes algarismos usando divisões sucessivas por 10
• Se n é um inteiro entre 0 e 99:
  • n%10 é são as unidades;
  • n/10 remove unidades; restam as dezenas

Função principal

int main(void) {
  int n, d, u;
  scanf("%d", &n);
  if (!(n>=0 && n<=99)) {
     printf("número inválido\n");
     return -1;  // erro
  }
  u = n % 10;  // unidades (0..9)
  d = n / 10;  // dezenas (0..9)
  imprime_algarismo(d); printf(" ");
  imprime_algarismo(u); printf("\n");
  return 0;      // OK
}

Observações

• O programa principal fica bastante simples — apenas calcula os algarismos e executa a função
• É fácil modificar o programa
  • exemplo: imprimir também o algarismo das centenas
• Também podemos melhorar a implementação da função
  • nas aulas seguintes iremos ver alternativas à “cascata” de ifs

Conclusão

A decomposição em funções permitiu:

• escrever programas em partes mais simples
• considerar parte do problema de cada vez
• combinar as soluções para resolver o problema original

Ciclos

• Um ciclo é uma instrução que executa várias vezes outras instruções (o corpo do ciclo)
• Os ciclos em C são controlados por uma expressão
• A expressão é avaliada a cada iteração
  • se o seu valor for zero o ciclo termina
  • se for diferente de zero, o ciclo continua

Instruções de ciclos

while

é usado para ciclos em que a expressão é testada antes de executar o corpo do ciclo

do...while

é usado para ciclos em que a expressão é testada depois de executar o corpo

for

é uma forma conveniente para ciclos com uma variável de controlo

Instrução while

while ( expressão ) instrução

• A expressão controla a terminação do ciclo
• A instrução é o corpo do ciclo

Execução:

1. Primeiro avalia a expressão:
2. Se for zero, o ciclo termina imediatamente;
   se for diferente de zero, executa instrução e repete 1.

i = 1;
while (i < 10)   /* expressão de controlo */
   i = i * 2;   /* corpo do ciclo */

Instrução while

O corpo pode ser um bloco de instruções em vez de uma só:

i = 1;
while (i < 10) {
   printf("%d\n", i);
   i = i * 2;
}

Podemos colocar chavetas mesmo com uma só instrução:

i = 1;
while (i < 10) {
  i = i * 2;
}

Terminação

• O ciclo while termina quando o valor da expressão for 0 (falso) - e.g., se a expressão for i < 10 então o ciclo termina quando \(i\geq 10\)
• O corpo pode não chegar a executar (porque a expressão de controlo é testada primeiro)
• Se a expressão de controlo for sempre diferente de zero o ciclo não termina (exceto se usarmos instruções especiais para sair do ciclo — mais tarde)

   while (1) {
      ...   /* ciclo infinito */
   }

Exemplo 1

• Um programa para imprimir uma tabela de quadrados
• O utilizador introduz o limite superior

Limite superior: 5
1        1
2        4
3        9
4       16
5       25

/*
  quadrados.c
  Imprimir uma tabela de quadrados
*/
#include <stdio.h>

int main(void) {
   int i, n;    

   printf("Limite superior: ");
   scanf("%d", &n);
   i = 1;
   while (i <= n) {
      printf("%d\t%d\n", i, i*i);
      i ++;
   }
   return 0;
}

Exemplo 2

• Um programa para somar uma sequência de números
• O tamanho da sequência não é conhecido antecipadamente
• Ideia:
  • ler cada valor dentro de um ciclo
  • acumular o total numa variável auxiliar
  • terminar quando lermos um valor especial (zero)

/*
  somar.c
  Somar uma sequência de números
*/
#include <stdio.h>

int main(void) {
   int n, soma = 0;
   printf("Introduza valores; 0 termina.\n");
   scanf("%d", &n);      // primeiro valor
   while (n != 0) {  // enquanto não terminou
        soma += n;       // acumular
        scanf("%d", &n); // ler próximo valor
   }
   printf("A soma é: %d\n", soma);
   return 0;
}

Instrução do...while

do instrução while ( expressão );

Execução:

1. Primeiro executa a instrução
2. Depois avalia a expressão
3. Se for zero, o ciclo termina;
   se for diferente de zero, repete o passo 1.

Exemplo

Vamos re-escrever o programa para somar números usando um ciclo do.

/*
  somar2.c
  Somar uma sequência de números (alternativa)
*/
#include <stdio.h>

int main(void) {
   int n, soma = 0;
   printf("Introduza valores; 0 termina.\n");
   do {
       scanf("%d", &n);  // próximo valor
       soma += n;        // acumular
   } while (n != 0);  // enquanto não terminou
   printf("A soma é: %d\n", soma);
   return 0;
}

Observações

• Como a condição é testada depois da execução não necessitamos de ler o primeiro valor fora do ciclo
• Somar zero não altera o resultado: podemos sempre acumular o valor lido

Exemplo 3

Calcular o número de algarismos de um inteiro positivo:

Introduza um inteiro positivo: 5633
4 algarismo(s)

• Vamos usar um ciclo para fazer divisões inteiras por 10
• Terminamos quando chegar a zero
• O número iterações efetuadas dá-nos a contagem de algarismos
• O ciclo do é mais conveniente do que while porque qualquer número positivo tem pelo menos um algarismo

/* algarismos.c
   Contar algarismos de um inteiro positivo
*/
#include <stdio.h>

int main(void) {
  int digits = 0, n;
  printf("Inteiro positivo: ");
  scanf("%d", &n);
  do {
     n /= 10;    // quociente divisão por 10
     digits ++;  // mais um algarismo
  } while (n > 0);
  printf("%d algarismo(s)\n", digits);
  return 0;
}

Instrução for

for ( expr1; expr2; expr3 ) instrução

• expr1 é a inicialização
• expr2 é a condição de repetição
• expr3 é a atualização após cada iteração
• instrução é o corpo do ciclo

Exemplo:

for (i = 0; i < 10; i++)
  printf("%d\n", i);

Instrução for

• O for é conveniente para ciclos que necessitam de contar de um valor inicial até um valor final
• Poderiamos usar o while em vez do for, mas o for é mais claro

Instrução for

Exemplo:

for (i = 0; i < 10; i++)
  printf("%d\n", i);

é equivalente a

i = 0;
while (i < 10) {
  printf("%d\n", i);
  i++;
}

Instrução for

A forma geral

for (expr1; expr2; expr3) instrução

é equivalente a:

expr1;
while ( expr2 ) {
   instrução
   expr3;
}

Esta tradução pode ajudar a compreender alguns detalhes.

Instrução for

Exemplo: qual o efeito de usar ++i em vez de i++ no ciclo seguinte?

for(i = 0; i < 10; ++i)
   printf("%d\n", i);

Traduzindo para while:

i = 0;
while (i < 10) {
   printf("%d\n", i);
   ++i;  // alternativa: i++;
}

Usar ++i ou i++ é equivalente — contamos de 0 a 9.

Formas comuns de for

Repetir n vezes:

// contagem ascendente de 0 até n-1 
for(i = 0; i < n; i++) ...

// contagem ascendente de 1 até n
for(i = 1; i <= n; i++) ...

// contagem descendente de n-1 até 0
for(i = n-1; i >= 0; i--) ...

// contagem descendente de n até 1
for(i = n; i > 0; i--) ...

Erros comuns no for

• Trocar a ordem das comparações
  • contagens ascendentes devem usar < ou <=
  • contagens descendentes devem usar > ou >=
• Usar == em vez <, <=, >, >=
  • podemos “saltar” a terminação
• “Errar por um” a condição de terminação
  • e.g. usar i<n em vez de i<=n

Omitir expressões no for

Podemos omitir uma ou mais expressões no ciclo for.

Omitir a inicialização:

int i = 10;
for (; i > 0; i--)
   printf("%d\n", i)

Omitir a atualização:

int i;
for (i = 10; i > 0;)
   printf("%d\n", i--)

Omitir expressões no for

Omitir ambas inicialização e atualização:

int i = 10;
for (; i > 0;)
   printf("%d\n", i--)

Isto é equivalente a um ciclo while:

int i = 10;
while (i > 0)
   printf("%d\n", i--)

Omitir condição do for

• Se omitirmos a condição, o ciclo for só termina se usarmos instruções de saida no corpo (mais à frente)
• Alguns programadores preferem usar um for sem condição em vez de while para esses ciclos

// usando ciclo while
while (1) {
   ...
}

// usando ciclo for
for (;;) {
   ... 
}

Ciclos for em C99

• Em C99, a expressão de inicialização do for pode ser substituida por uma declaração
• Isto permite declarar uma varíavel para usar dentro do ciclo:
  
  for(int i = 0; i < n; i++) ...
  
  
• A variável não tem de ser declarada antes e tem âmbito limitado ao ciclo

Ciclos for em C99

• Declarar a variável de controlo dentro do ciclo é conveniente e pode ajudar a tornar o programa mais simples
• Contudo, se quiseremos de usar o valor final da variável após o fim do ciclo, é necessária a forma anterior

for(int i = 0; i < n; i++) {
   printf("%d\n", i); // OK: i é válido
}
printf("%d\n", i); // ERRO: i fora de âmbito
printf("%d\n", n); // OK: n é válido

Instrução break

• Usualmente um ciclo termina apenas quando a condição é testada
  • antes de uma iteração de while ou for
  • depois de uma iteração de do...while
• Também podemos usar a instrução break para terminar um ciclo em qualquer momento

Instrução break

Exemplo: procurar o primeiro divisor próprio de um número \(n\) (isto é, um divisor entre 2 e \(n-1\)):

int i, n;
... /* obter valor de `n' */
for (i = 2; i < n; i++) {
   if (n%i == 0) break;
}

Este ciclo pode terminar de duas formas:

• se esgotou os possíveis divisores (i >= n)
• se encontrou um divisor (i < n)

Instrução break

No final do ciclo podemos determinar a causa de terminação com um teste simples:

int i, n;
... /* obter valor de `n' */
for (i = 2; i < n; i++) {
   if (n%i == 0) break;
}
if (i < n)
   printf("Encontrou divisor: %d\n", i);
else
   printf("Não tem divisores próprios\n");

Instrução break

• A instrução break é útil para escrever um ciclo com um teste de terminação a meio
• Exemplo: ler uma sequência de valores e terminar com um valor especial

for(;;) {
  scanf("%d", &n);
  if (n == 0)   // se for zero
     break;     // terminar o ciclo
  ... // se não: processar o valor 
}

Instrução continue

• A instrução continue transfere a execução para o ponto imediatamente antes do fim do corpo
• Enquanto que break termina o ciclo, continue continua no ciclo

Exemplo

Ler e acumular 10 inteiros não-negativos.

int i = 0, n, soma = 0;
while (i < 10) {
  scanf("%d", &n);
  if (n < 0)
    continue;
  soma += n;
  i ++;
  /* continue salta para aqui */
}

Exemplo

• Por vezes é mais simples evitar o continue colocando instruções dentro de um if
• A condição é invertida: n >= 0 em vez de n < 0

int i = 0, n, soma = 0;
while (i < 10) {
  scanf("%d", &n);
  if (n >= 0) {
     soma += n;
     i ++;
  }
}

Instrução vazia

Uma instrução pode ser vazia, isto é, apenas um ponto-e-vírgula sem mais símbolos:

i = 0; ; j = 1;  // segunda instrução vazia

Uma instrução vazia não faz nada; é útil apenas para escrever um ciclo cujo corpo é vazio.

Instrução vazia

Considere o ciclo para procurar divisores:

for (i = 2; i < n; i++) {
   if (n%i == 0) break;
}

Podemos juntar as duas condições e retirar o break; o corpo fica vazio:

for (i = 2; i < n && n%i != 0; i++)
   ; /* instrução vazia */ 

Para evitar confusão, devemos escrever a instrução vazia numa linha separada.