HOWTO · C

Try Catch en C

Cet article présente un exemple d'implémentation du comportement try-catch en C, qui, par défaut, ne prend pas en charge les mécanismes de gestion try-catch/exception.

Sur cette page

Le C ne possède ni construction try-catch intégrée ni mécanisme de gestion des exceptions. Vous pouvez utiliser setjmp et longjmp, fournis par <setjmp.h>, pour transférer l’exécution vers un point sauvegardé et créer un petit modèle fondé sur les macros TRY, CATCH et THROW. Cette technique de contrôle du flux reste limitée et ne constitue pas un système complet d’exceptions : elle ne libère pas automatiquement les ressources, et, dans la conception à base de switch présentée ici, une valeur lancée sans CATCH correspondant ne sélectionne aucun gestionnaire. Chaque appel à TRY possède son propre buf_state et son propre switch à portée de bloc ; cette organisation des macros permet donc les appels imbriqués. Les noms des macros visibles dans les exemples restent en anglais.

Try-Catch en C

setjmp sauvegarde un environnement d’exécution dans un jmp_buf. Appelée directement, la fonction renvoie 0 ; après un appel ultérieur à longjmp vers cet environnement, elle renvoie la valeur fournie, sauf si celle-ci vaut 0, auquel cas la valeur observée est 1. longjmp restaure le contexte d’exécution sauvegardé et reprend au point d’appel de setjmp. Il ne copie pas l’état vers un processeur.

Les macros ci-dessous utilisent un switch : le résultat initial de setjmp sélectionne le bloc TRY, et chaque CATCH(value) ajoute un cas correspondant. THROW(value) appelle longjmp. Une valeur non nulle sans correspondance ne sélectionne aucun bloc CATCH et est ignorée à la fin du switch ; elle n’est pas renvoyée au bloc TRY. Le break généré par chaque CATCH empêche l’exécution de poursuivre dans les cas suivants.

Exécutez cet exemple :

#include <setjmp.h>
#include <stdio.h>

#define TRY do { jmp_buf buf_state; switch (setjmp(buf_state)) { case 0:
#define CATCH(value) break; case value:
#define ENDTRY } } while (0)
#define THROW(value) longjmp(buf_state, value)
#define CODE_ONE 1
#define CODE_TWO 2

int main(void) {
  TRY {
    puts("Starting work");
    THROW(CODE_TWO);
    puts("This line is skipped");
  }
  CATCH(CODE_ONE) { puts("Code one"); }
  CATCH(CODE_TWO) { puts("Code two"); }
  ENDTRY;
  return 0;
}
Starting work
Code two

L’exécution fournie s’est terminée avec le statut 0. Ce programme complet illustre un transfert avec correspondance. Le jmp_buf doit rester valide au moment de l’appel à longjmp : il n’est pas valide de sauter vers l’environnement après le retour de la fonction qui contient le setjmp correspondant. De plus, les valeurs des variables automatiques non volatile locales à cette fonction peuvent devenir indéterminées si elles ont été modifiées après setjmp et avant longjmp. N’utilisez ce modèle que si vous maîtrisez ces règles de contrôle du flux et de durée de vie.

Ajouter Finally à Try-Catch en C

Le C ne possède pas d’instruction FINALLY, mais il est possible d’écrire une action similaire à finally après un switch placé dans une enveloppe do { ... } while (0). Cette forme compacte de contrôle du flux place des étiquettes case dans la boucle, selon une organisation du type Duff’s Device :

int status = 0; do { switch (setjmp(env)) { case 0: work(); break; case CODE_TWO: handle(); break; default: status = 1; break; } } while (0); cleanup(); return status;

En cas de fin normale, work() se termine et son break quitte le switch ; la boucle d’un seul tour se termine ensuite, puis l’exécution atteint cleanup(). En cas de lancement avec correspondance, longjmp fait renvoyer CODE_TWO par setjmp : handle() s’exécute, puis son break mène au même chemin de nettoyage. Si setjmp renvoie une valeur non nulle sans correspondance, le bloc default s’exécute, enregistre ce résultat, puis son break mène lui aussi au nettoyage. Dans les trois cas, break quitte le switch, pas la fonction englobante. Il s’agit d’une illustration du contrôle du flux, et non d’un nettoyage automatique des ressources ni d’une sémantique complète des exceptions.

L’exemple exécutable ci-dessous illustre le chemin avec lancement correspondant, à travers un switch et une étiquette de nettoyage commune :

#include <setjmp.h>
#include <stdio.h>

#define CODE_TWO 2

int main(void) {
  jmp_buf env;
  switch (setjmp(env)) {
    case 0:
      puts("Starting work");
      longjmp(env, CODE_TWO);
    case CODE_TWO:
      puts("Handling code two");
      break;
    default:
      puts("No matching handler");
      break;
  }

cleanup:
  puts("Cleanup path");
  return 0;
}
Starting work
Handling code two
Cleanup path

L’exécution fournie s’est terminée avec le statut 0. Dans ce chemin, longjmp reprend le switch avec CODE_TWO, le gestionnaire s’exécute et l’exécution atteint l’étiquette de nettoyage. Cette étiquette est une autre façon de rendre visible un chemin commun ; avec la structure do/while ci-dessus, la fin normale, un lancement avec correspondance et un retour sans correspondance doivent chacun prévoir explicitement un chemin vers le nettoyage. longjmp ne libère pas la mémoire allouée, ne ferme pas les fichiers, ne déverrouille pas les ressources et n’exécute pas de destructeurs. Libérez explicitement ces ressources sur les chemins pris en charge par votre programme.