Comment gérer les exceptions dans un langage procédural?

Question

Comment gérer les exceptions dans un langage procédural comme C ou Perl? (Je sais que Perl fait aussi OO.) Quelle est la meilleure façon de gérer l'exception dans le code de procédure en Perl?

Answer 1

Cela dépend plutôt de ce que vous entendez par «gestion des exceptions».

Certains systèmes d'exploitation ont des mécanismes d'exception - voir Windows exception handling routines ou Linux signal handlers (dont certains sont des exceptions). Si vous voulez dire l'idiome dans le code utilisateur pour signaler une erreur et dérouler la pile en nettoyant les objets alloués, alors le code C n'appelle pas les destructeurs sur les objets alloués quand la pile est déroulée (elle récupère juste la mémoire), il est donc normal en C que les fonctions retournent une valeur d'état, et que le code appelant fasse le nettoyage requis avant de retourner. Je ne connais pas bien Perl, mais Google pour "gestion des exceptions Perl" indique qu'il a à la fois des mécanismes intégrés équivalents à try/catch et des modules qui donnent une gestion des exceptions de type "OO".

Answer 2

L'approche traditionnelle est ... eh bien ... pas :)

En général, les gens se contentent de vérifier l'état après avoir essayé quelque chose, et si quelque chose a mal tourné, ils nettoient et retourner un code d'erreur, plutôt que de continuer. Cette erreur contrôle et de retour se propage vers le bas de la pile d'appel de fonction jusqu'à ce qu'il revienne à un endroit de haut niveau dans votre programme, où vous soin d'informer l'utilisateur au lieu de simplement revenir plus d'erreurs:

int try_it() { 
    if (!do_something(...)) { 
    return TRYIT_FAILURE; 
    } 
} 

void my_gui() { 
    rc = try_it() 
    if (rc == TRYIT_FAILURE) { 
    message_box("failed when trying it.", MB_ABORT|MB_RETRY); 
    } 
    ... 
} 

Vous pouvez également faire cela dans une grande fonction, en utilisant ifs imbriqués, si vous voulez quelque chose comme un essai ... sauf construction:

if (stage1()) { 
    if (stage2()) { 
     if(stage3()) { 
      printf("success!\n"); 
     } else { 
      // error handling for stage 3 
     } 
    } else { 
     // error handling for stage 2 
    } 
} else { 
    // error handling for stage 1 
} 

Et vous pouvez faire la même chose avec GOTO si vous êtes un peu fou.

Cependant, vous pouvez faire des exceptions réelles, au moins en C. C a deux appels de bibliothèque standard pour ce genre de chose: setjmp et longjmp. Avec ceux-ci, vous pouvez revenir en arrière à travers plusieurs appels de fonction à un endroit prédéterminé, où vous savez que l'exception (saut) s'est produite. Voir Setjmp.h#exception_handling on wikipedia pour plus d'informations à ce sujet.

Il semble que Perl ait un moyen de le faire, même si cela me semble loin d'être intuitif. Là encore, je ne suis pas le code en Perl :)

Perl FAQ Q4.8

Answer 3

En C il y avait setjmp et longjump; Pour l'essentiel, setjmp() enregistre le contexte actuel dans la pile, et longjmp() peut revenir au point sauvegardé par setjmp(). L'entrée wikipedia sur ces remplit joliment les détails.

Answer 4

En Perl 5, la gestion des exceptions est effectuée en utilisant eval et die. Vous évaluez simplement le corps du code et s'il meurt, vous pouvez inspecter $@ pour l'erreur. Ce n'est pas si simple si vous voulez le faire correctement, c'est pourquoi les différents modules try/catch existent. Vous pourriez être intéressé par Try::Tiny qui n'a pas de dépendances et décrit tous les pièges que vous avez à traiter lorsque vous utilisez la gestion des exceptions eval naïf. (Voir aussi this blog post par l'auteur de Try :: Tiny.)

Answer 5

Voici un exemple de la façon dont je fais des exceptions en Perl (sans utiliser l'un des modules Try):

use Carp; 
use English qw(-no_match_vars); 

do_something_needing_rollback_if_failed(); 
eval { 
    do_something_dangerous(); 
} or do { 
    # Exception was thrown by dangerous method 
    # Save the error: 
    my $error = $EVAL_ERROR; 

    # Try to rollback 
    eval { rollback(); } 
    or do { confess qq{Couldn't rollback: $EVAL_ERROR. Original error $error}; } 

    # Let's rethrow: 
    confess qq{Rolled back! Error was $error}; 
} 

L'une des parties les plus gênants de la gestion des exceptions Perl est-il utilise une seule variable pour stocker toute erreur d'exception, et il peut être accidentellement écrasé, donc un codage défensif est requis.

Answer 6

En Perl, comme d'habitude, il y a plusieurs façons de le faire. Cependant, la communauté des développeurs a dans l'ensemble choisi la bonne façon de faire la plupart des choses.

Je suis de plus en plus fan de Exception::Base.

Si vous souhaitez une implémentation plus légère, utilisez simplement Carp.

Vous piègez des exceptions à l'aide d'une construction eval { ... }; if ($@) { ... }.

Avec Exception :: Base, il offre un moyen d'extraire la construction if ($@) { ... } pour vous. Cependant, vous devrez toujours utiliser eval { ... }.