Essayez les instructions catch en C

Question

Je pensais aujourd'hui aux blocs try/catch existant dans d'autres langues. J'ai cherché sur Google pendant un certain temps, mais sans résultat. D'après ce que je sais, les try/catch n'existent pas en C. Cependant, existe-t-il un moyen de les "simuler" ?
Bien sûr, il existe des assertions et d'autres astuces, mais rien de comparable à try/catch, qui permettent également d'attraper l'exception soulevée. Je vous remercie.

Answer 1

Avertissement : ce qui suit n'est pas très joli mais il fait l'affaire.

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    unsigned int  id;
    char         *name;
    char         *msg;
} error;

#define _printerr(e, s, ...) fprintf(stderr, "\033[1m\033[37m" "%s:%d: " "\033[1m\033[31m" e ":" "\033[1m\033[37m" " ‘%s_error’ " "\033[0m" s "\n", __FILE__, __LINE__, (*__err)->name, ##__VA_ARGS__)
#define printerr(s, ...) _printerr("error", s, ##__VA_ARGS__)
#define printuncaughterr() _printerr("uncaught error", "%s", (*__err)->msg)

#define _errordef(n, _id) \
error* new_##n##_error_msg(char* msg) { \
    error* self = malloc(sizeof(error)); \
    self->id = _id; \
    self->name = #n; \
    self->msg = msg; \
    return self; \
} \
error* new_##n##_error() { return new_##n##_error_msg(""); }

#define errordef(n) _errordef(n, __COUNTER__ +1)

#define try(try_block, err, err_name, catch_block) { \
    error * err_name = NULL; \
    error ** __err = & err_name; \
    void __try_fn() try_block \
    __try_fn(); \
    void __catch_fn() { \
        if (err_name == NULL) return; \
        unsigned int __##err_name##_id = new_##err##_error()->id; \
        if (__##err_name##_id != 0 && __##err_name##_id != err_name->id) \
            printuncaughterr(); \
        else if (__##err_name##_id != 0 || __##err_name##_id != err_name->id) \
            catch_block \
    } \
    __catch_fn(); \
}

#define throw(e) { *__err = e; return; }

_errordef(any, 0)

Utilisation :

errordef(my_err1)
errordef(my_err2)

try ({
    printf("Helloo\n");
    throw(new_my_err1_error_msg("hiiiii!"));
    printf("This will not be printed!\n");
}, /*catch*/ any, e, {
    printf("My lovely error: %s %s\n", e->name, e->msg);
})

printf("\n");

try ({
    printf("Helloo\n");
    throw(new_my_err2_error_msg("my msg!"));
    printf("This will not be printed!\n");
}, /*catch*/ my_err2, e, {
    printerr("%s", e->msg);
})

printf("\n");

try ({
    printf("Helloo\n");
    throw(new_my_err1_error());
    printf("This will not be printed!\n");
}, /*catch*/ my_err2, e, {
    printf("Catch %s if you can!\n", e->name);
})

Sortie :

Helloo
My lovely error: my_err1 hiiiii!

Helloo
/home/naheel/Desktop/aa.c:28: error: ‘my_err2_error’ my msg!

Helloo
/home/naheel/Desktop/aa.c:38: uncaught error: ‘my_err1_error’ 

Gardez à l'esprit qu'il s'agit d'utiliser des fonctions imbriquées et des __COUNTER__ . Vous serez en sécurité si vous utilisez gcc.

Answer 2

Redis utilise goto pour simuler try/catch, IMHO c'est très propre et élégant :

/* Save the DB on disk. Return REDIS_ERR on error, REDIS_OK on success. */
int rdbSave(char *filename) {
    char tmpfile[256];
    FILE *fp;
    rio rdb;
    int error = 0;

    snprintf(tmpfile,256,"temp-%d.rdb", (int) getpid());
    fp = fopen(tmpfile,"w");
    if (!fp) {
        redisLog(REDIS_WARNING, "Failed opening .rdb for saving: %s",
            strerror(errno));
        return REDIS_ERR;
    }

    rioInitWithFile(&rdb,fp);
    if (rdbSaveRio(&rdb,&error) == REDIS_ERR) {
        errno = error;
        goto werr;
    }

    /* Make sure data will not remain on the OS's output buffers */
    if (fflush(fp) == EOF) goto werr;
    if (fsync(fileno(fp)) == -1) goto werr;
    if (fclose(fp) == EOF) goto werr;

    /* Use RENAME to make sure the DB file is changed atomically only
     * if the generate DB file is ok. */
    if (rename(tmpfile,filename) == -1) {
        redisLog(REDIS_WARNING,"Error moving temp DB file on the final destination: %s", strerror(errno));
        unlink(tmpfile);
        return REDIS_ERR;
    }
    redisLog(REDIS_NOTICE,"DB saved on disk");
    server.dirty = 0;
    server.lastsave = time(NULL);
    server.lastbgsave_status = REDIS_OK;
    return REDIS_OK;

werr:
    fclose(fp);
    unlink(tmpfile);
    redisLog(REDIS_WARNING,"Write error saving DB on disk: %s", strerror(errno));
    return REDIS_ERR;
}

Answer 3

Si vous utilisez le langage C avec Win32, vous pouvez tirer parti de la fonction Traitement structuré des exceptions (SEH) pour simuler un try/catch.

Si vous utilisez C dans des plateformes qui ne supportent pas setjmp() y longjmp() Jetez un coup d'œil à ceci Traitement des exceptions de la bibliothèque pjsip, il fournit sa propre implémentation

Answer 4

Après avoir étudié les réponses données ci-dessus, j'ai mis en place un système qui gère bien les exceptions imbriquées de manière automatique. Voici le code que j'ai écrit pour tester mon système :

#include "MyOtherTricks.h"
#include "Exceptions.h"

void Testing_InnerMethod();
void Testing_PossibleExceptionThrower();

void TestExceptionHandling()
{
    try
    {
        Testing_InnerMethod();
        Say("The inner method exited without an exception.");
    }
    catch (Exception)
    {
        Say("I caught an Exception that the inner method did not catch.");
    }
    end_try
}

void Testing_InnerMethod()
{
    try
    {
        Say("I am in a try block.");
        Testing_PossibleExceptionThrower();
        Say("The possible exception thrower didn't throw an exception.");
    }
    catch (ExceptionSubtype1)
        Say("I caught an exception, subtype 1.");
    catch (ExceptionSubtype2)
    {
        Say("I caught an exception, subtype 2.");
        Say("I will now rethrow it.");
        throw(exception);
    }
    end_try
}

void Testing_PossibleExceptionThrower()
{
    Say("Here is the possible exception thrower.");
    throw(new(ExceptionSubtype2));                          // To further test exception handling, replace ExceptionSubtype2 in this line with Exception or ExceptionSubtype1, or comment out this line entirely.
    Say("No, I won't throw an exception!");
}

Le code de l'exemple s'appuie sur deux fichiers, Exceptions.h et Exceptions.c. Voici Exceptions.h :

#include <setjmp.h>

extern jmp_buf* Exception_Handler;

#define try                     do                                                                  \
                                {                                                                   \
                                    jmp_buf* outerExceptionHandler = Exception_Handler;             \
                                    jmp_buf exceptionHandler;                                       \
                                    Exception_Handler = &exceptionHandler;                          \
                                    Exception exception = (Exception)setjmp(exceptionHandler);      \
                                    if (exception != 0) Exception_Handler = outerExceptionHandler;  \
                                    if (exception == 0)                                             \
                                    {                                                               \
                                        // The try block goes here. It must not include a return statement or anything else that exits the try...end_try block, because then the outer exception handler will not be restored.
#define catch(exceptionType)            Exception_Handler = outerExceptionHandler;                  \
                                    }                                                               \
                                    else if (Object_IsSomeTypeOf(exception, exceptionType))         \
                                    {
                                        // The catch block goes here. It may include a return statement or anything else that exits the try...end_try block. A break statement will exit only the try...end_try block.
#define end_try                     }                                                               \
                                    else                                                            \
                                        throw(exception);                                           \
                                } while(0);

void throw(Exception exception);

Et voici Exceptions.c :

#include "MyOtherTricks.h"
#include "Exceptions.h"

jmp_buf* Exception_Handler = 0;

void throw(Exception exception)
{
    if (Exception_Handler == 0) FailBecause("Uncaught exception.");
    longjmp(*Exception_Handler, (int)exception);
}

Notez que ce code fait référence à des méthodes supplémentaires que je n'inclus pas ici (parce que l'héritage de classe en C est hors sujet). Pour que ce code fonctionne pour vous, vous devrez comprendre ce code suffisamment bien pour remplacer certaines choses. En particulier, si vous voulez distinguer les différents types d'exceptions, vous devrez réaliser que ce code suppose que Object_IsSomeTypeOf(new(ExceptionSubtype1), Exception) renvoie true et Object_IsSomeTypeOf(new(ExceptionSubtype1), ExceptionSubtype2) renvoie false, et vous devrez soit faire votre propre version de ma macro Object_IsSomeTypeOf, soit la remplacer par autre chose.

Answer 5

Ce n'est peut-être pas un langage majeur (malheureusement), mais en APL, il y a l'opération ⎕EA (pour Execute Alternate).

Utilisation : 'Y' ⎕EA 'X' où X et Y sont soit des extraits de code fournis sous forme de chaînes, soit des noms de fonctions.

Si X rencontre une erreur, Y (généralement la gestion des erreurs) sera exécuté à la place.