O que é uma asserção?

Uma asserção é uma condição que se deve sempre verificar-se num determinado ponto do programa.

Asserções em C

#include <assert.h>

assert( int cond ); 

• Se cond for diferente de 0: não faz nada
• Se cond for 0: imprime uma mensagem de erro e termina imediatamente a execução do programa

prog: some_file.c:16: some_func: Assertion ... failed.

Exemplo

#include <assert.h>

int main(void) {
   int x = 5, y = -3;
   assert( x + y == 2 ); 
   // esta asserção é válida
   y = x;
   assert( x + y == 2 );
   // esta asserção já não é válida;
   // o programa termina imediatamente!
   printf("fim\n"); 
}

Porquê usar asserções

• Exprimir condições de correção dentro do próprio programa:
  • pré-condições à entrada de funções
  • pós-condições à saida de funções
  • invariantes de ciclos
• Ajudam na leitura e compreensão do programa
• Programação defensiva:
  • detetar erros de programação mais cedo

Pré-condições

• Condições que se devem verificar à entrada de uma função
• Quem invoca a função deve garantir as pré-condições

Exprimir uma pré-condição pode ajudar a detetar erros na chamada de uma função.

Exemplo: anos bissextos

Testar se um ano é bissexto (exercício 4.6):

• São bissextos todos os anos múltiplos de 400;
• São bissextos todos os múltiplos de 4, exceto se forem múltiplos de 100 mas não de 400;
• Não são bissextos todos os restantes anos.

Esta correção ao calendário foi introduzida pelo papa Gregório XIII em 1582.

Logo: as regras acima só se aplicam a partir dessa data.

https://pt.wikipedia.org/wiki/Calend%C3%A1rio_gregoriano).

Testar bissextos

int bissexto(int n) {
   // n é o ano que queremos testar;
   // pré-condição: deve ser posterior a 1582 
   assert(n >= 1582); 
   // OK, vamos considerar os casos acima
   if (n%400 == 0) 
       return TRUE;
   if (n%4 == 0 && n%100 != 0) 
       return TRUE;
   return FALSE;
}

int main(void) {
  ...
}

Exemplo de execução

Introduza um ano: 2000
2000 foi bissexto

Introduza um ano: 1384
bissexto: ...: Assertion `n >= 1582' failed.

Outro exemplo

Calcular a pontuação do SCRABBLE para uma cadeia de letras (Exercício 7.6):

• scrabble("PITFALL") deve retornar 12;

Pré-condição: a cadeia deve conter apenas letras maiúsculas 'A', 'B', ..., 'Z'.

Pontuação SCRABBLE

int scrabble(char str[]) {
    // pré-condição: apenas letras maiúsculas
    for (int i=0; str[i]!='\0'; i++) {
       assert(str[i]>='A' && str[i]<='Z');
    }
    // OK, vamos calcular a pontuação
    ...
}

Pós-condições

• Condições sobre o resultado à saida de uma função
• Devem ser garantidas por quem implementa a função
• Quem invoca a função espera que a pós-condição seja sempre verdadeira

Exprimir uma pós-condição pode ajudar a detetar erros na implementação de uma função.

Exemplo: gerar pseudo-aleatórios

Gerar um número inteiro pseudo-aleatório ímpar entre 1 e 99 (última alínea do exercício 6.1).

int gerador(void) {
   int n;
   n = rand()%100 + 1;  // NB: ERRADO!
   // pós-condição: o resultado está no
   // intervalo esperado e é ímpar 
   assert(n>=1 && n<=99 && n%2 == 1);
   return n;
}

Testar o gerador

Vamos testar um gerador efetuando várias experiências:

int main(void) {
   for(int i = 0; i<1000; i++) {
      int n = gerador();
      printf("%d\n", n);
   }
}

A asserção falha na execução: detetamos um erro no gerador!

Corrigir o erro

Podemos separar as asserções para compreender o que falha:

   assert(n >= 1); 
   assert(n <= 99);
   assert(n%2 == 1);

Como usar pós-condições

• Se a função tiver multiplos pontos de saida devemos repetir a pós-condição
• Por vezes é preferíval re-escrever a função de forma a ter um único return

Invariantes

• Condições que se verificam em cada iteração de um ciclo
• Exemplo: relações entre índices de variáveis indexadas

Exemplo: eliminar repetidos

   int elimrep(int v[], int n);

• Eliminar ocorrências repetidas em v
• Ficam apenas as primeiras ocorrências
• Ciclo com duas variáveis \(i\), \(k\) \[ \scriptsize \overbrace{\begin{array}{|c|c|c|} \hline \texttt{v[0]} & \cdots & \texttt{v[k-1]} \\ \hline \end{array}}^{\text{sem repetidos}} \overbrace{\begin{array}{|c|c|c|c|c|} \hline \texttt{v[k]} & \cdots &\texttt{v[i]}&\cdots & \texttt{v[n-1]} \\ \hline \end{array}}^{\text{?}} \]
• Invariantes sobre os índices \(i, k\): \[ \begin{gather*} 0 \leq k \leq i \\ 0 \leq i < n \end{gather*} \]

Asserções de invariantes

int elimrep(int vec[], int n) {
   int k = 0;
   for(int i = 0; i < n; i++) {
      assert(0 <= k && k <= i);
      assert(0 <= i && i < n);
      int val = vec[i];
      if(!ocorre(vec, k, val)) {
         vec[k++] = val;
            // valor não repetido
      }
   }
   return k;
}

Porquê usar invariantes

• Programação defensiva
  • permite detetar erros mais cedo
  • erros de índices: Assert failed em vez de Segmentation Fault
• "Obriga" a pensar nos casos limite do algoritmo:
  • o que acontence quando todos valores são repetidos?
  • o que acontence quando todos valores são diferentes?

Asserções e erros

Distinguir entre:

Erro de programação

uma situação que não deve ocorrer; por exemplo: usar um índice inválido ou dividir por zero.

Erro de execução

uma situação que pode ocorrer e que devemos tratar; por exemplo: um input incompleto do utilizador.

Asserções são um mecanismo para detetar o primeiro tipo de erros — não para tratar os segundos.