Try catch statements in C

Question

I was thinking today about the try catch blocks existent in another languages  Googled for a while this but with no result  From what I know  there is not such a thing as try catch in C  However  is there a way to  simulate  them  Sure  there is assert and other tricks but nothing like try catch  that also catch the raised exception  Thank you

User · Answer

In C  you can  simulate  exceptions along with automatic  object reclamation  through manual use of if   goto for explicit error handling   I often write C code like the following  boiled down to highlight error handling     include  lt assert h gt   typedef int errcode   errcode init or fail  foo  f  goo  g  poo  p  loo  l         errcode ret   0       if     ret   foo init  f               goto FAIL       if     ret   goo init  g               goto FAIL F       if     ret   poo init  p               goto FAIL G       if     ret   loo init  l               goto FAIL P       assert  0    ret        goto END          error handling and return            Note that we finalize in opposite order of initialization because we are unwinding a  STACK  of initialized objects     FAIL P      poo fini  p     FAIL G      goo fini  g     FAIL F      foo fini  f     FAIL      assert  0    ret     END      return ret              This is completely standard ANSI C  separates the error handling away from your mainline code  allows for  manual  stack unwinding of initialized objects much like C   does  and it is completely obvious what is happening here   Because you are explicitly testing for failure at each point it does make it easier to insert specific logging or error handling at each place an error can occur   If you don t mind a little macro magic  then you can make this more concise while doing other things like logging errors with stack traces   For example    include  lt assert h gt   include  lt stdio h gt   include  lt string h gt    define TRY  X  LABEL   do   if     X       fprintf  stderr    s  d  Statement     X    failed   d   s n     FILE      LINE    ret  strerror  ret      goto LABEL    while   0    typedef int errcode   errcode init or fail  foo  f  goo  g  poo  p  loo  l         errcode ret   0       TRY  ret   foo init  f    FAIL        TRY  ret   goo init  g    FAIL F        TRY  ret   poo init  p    FAIL G        TRY  ret   loo init  l    FAIL P         assert  0    ret        goto END          error handling and return     FAIL P      poo fini  p     FAIL G      goo fini  g     FAIL F      foo fini  f     FAIL      assert  0    ret     END      return ret              Of course  this isn t as elegant as C   exceptions   destructors  For example  nesting multiple error handling stacks within one function this way isn t very clean   Instead  you d probably want to break those out into self contained sub functions that similarly handle errors  initialize   finalize explicitly like this     This also only works within a single function and won t keep jumping up the stack unless higher level callers implement similar explicit error handling logic  whereas a C   exception will just keep jumping up the stack until it finds an appropriate handler   Nor does it allow you to throw an arbitrary type  but instead only an error code   Systematically coding this way  i e  - with a single entry and single exit point  also makes it very easy to insert pre and post   finally   logic that will execute no matter what   You just put your  finally  logic after the END label

User · Answer

This is another way to do error handling in C which is more performant than using setjmp/longjmp. Unfortunately, it will not work with MSVC but if using only GCC/Clang is an option, then you might consider it. Specifically, it uses the "label as value" extension, which allows you to take the address of a label, store it in a value and and jump to it unconditionally. I'll present it using an example:

GameEngine *CreateGameEngine(GameEngineParams const *params)
{
    /* Declare an error handler variable. This will hold the address
       to jump to if an error occurs to cleanup pending resources.
       Initialize it to the err label which simply returns an
       error value (NULL in this example). The && operator resolves to
       the address of the label err */
    void *eh = &&err;

    /* Try the allocation */
    GameEngine *engine = malloc(sizeof *engine);
    if (!engine)
        goto *eh; /* this is essentially your "throw" */

    /* Now make sure that if we throw from this point on, the memory
       gets deallocated. As a convention you could name the label "undo_"
       followed by the operation to rollback. */
    eh = &&undo_malloc;

    /* Now carry on with the initialization. */
    engine->window = OpenWindow(...);
    if (!engine->window)
        goto *eh;   /* The neat trick about using approach is that you don't
                       need to remember what "undo" label to go to in code.
                       Simply go to *eh. */

    eh = &&undo_window_open;

    /* etc */

    /* Everything went well, just return the device. */
    return device;

    /* After the return, insert your cleanup code in reverse order. */
undo_window_open: CloseWindow(engine->window);
undo_malloc: free(engine);
err: return NULL;
}

If you so wish, you could refactor common code in defines, effectively implementing your own error-handling system.

/* Put at the beginning of a function that may fail. */
#define declthrows void *_eh = &&err

/* Cleans up resources and returns error result. */
#define throw goto *_eh

/* Sets a new undo checkpoint. */
#define undo(label) _eh = &&undo_##label

/* Throws if [condition] evaluates to false. */
#define check(condition) if (!(condition)) throw

/* Throws if [condition] evaluates to false. Then sets a new undo checkpoint. */
#define checkpoint(label, condition) { check(condition); undo(label); }

Then the example becomes

GameEngine *CreateGameEngine(GameEngineParams const *params)
{
    declthrows;

    /* Try the allocation */
    GameEngine *engine = malloc(sizeof *engine);
    checkpoint(malloc, engine);

    /* Now carry on with the initialization. */
    engine->window = OpenWindow(...);
    checkpoint(window_open, engine->window);

    /* etc */

    /* Everything went well, just return the device. */
    return device;

    /* After the return, insert your cleanup code in reverse order. */
undo_window_open: CloseWindow(engine->window);
undo_malloc: free(engine);
err: return NULL;
}

User · Answer

Warning  the following is not very nice but it does the job    include  lt stdio h gt   include  lt stdlib h gt   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 - gt name      VA ARGS     define printerr s        printerr  error   s      VA ARGS     define printuncaughterr    printerr  uncaught error     s       err - gt msg    define  errordef n   id    error  new   n   error msg char  msg          error  self   malloc sizeof error          self- gt id    id        self- gt name    n        self- gt 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    amp  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  - gt id            if      err name   id    0  amp  amp      err name   id    err name- gt id                printuncaughterr              else if      err name   id    0        err name   id    err name- gt id                catch block                 catch fn          define throw e       err   e  return      errordef any  0    Usage   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- gt name  e- gt 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- gt 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- gt name        Output   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       Keep on mind that this is using nested functions and   COUNTER    You ll be on the safe side if you re using gcc

User · Answer

C itself doesn t support exceptions but you can simulate them to a degree with setjmp and longjmp calls   static jmp buf s jumpBuffer   void Example        if  setjmp s jumpBuffer            The longjmp was executed and returned control here     printf  Exception happened here n        else          Normal code execution starts here     Test           void Test          Rough equivalent of  throw    longjmp s jumpBuffer  42       This website has a nice tutorial on how to simulate exceptions with setjmp and longjmp    http   www di unipi it  nids docs longjump try trow catch html

User · Answer

Ok  I couldn t resist replying to this   Let me first say I don t think it s a good idea to simulate this in C as it really is a foreign concept to C   We can use abuse the preprocessor and local stack variables to give use a limited version of C   try throw catch   Version 1  local scope throws    include  lt stdbool h gt    define try bool   HadError false   define catch x  ExitJmp if   HadError   define throw x    HadError true goto ExitJmp    Version 1 is a local throw only  can t leave the function s scope    It does rely on C99 s ability to declare variables in code  it should work in C89 if the try is first thing in the function    This function just makes a local var so it knows if there was an error and uses a goto to jump to the catch block   For example    include  lt stdio h gt   include  lt stdbool h gt    define try bool   HadError false   define catch x  ExitJmp if   HadError   define throw x    HadError true goto ExitJmp   int main void        try               printf  One n            throw            printf  Two n              catch                    printf  Error n              return 0      This works out to something like   int main void        bool HadError false                printf  One n            HadError true          goto ExitJmp          printf  Two n          ExitJmp      if HadError                printf  Error n              return 0      Version 2  scope jumping    include  lt stdbool h gt   include  lt setjmp h gt   jmp buf  g  ActiveBuf    define try jmp buf   LocalJmpBuff jmp buf    OldActiveBuf g  ActiveBuf bool   WasThrown false g  ActiveBuf  amp   LocalJmpBuff if setjmp   LocalJmpBuff     WasThrown true  else  define catch x  g  ActiveBuf   OldActiveBuf if   WasThrown   define throw x  longjmp  g  ActiveBuf 1     Version 2 is a lot more complex but basically works the same way   It uses a long jump out of the current function to the try block   The try block then uses an if else to skip the code block to the catch block which check the local variable to see if it should catch   The example expanded again   jmp buf  g ActiveBuf   int main void        jmp buf LocalJmpBuff      jmp buf  OldActiveBuf g ActiveBuf      bool WasThrown false      g ActiveBuf  amp LocalJmpBuff       if setjmp LocalJmpBuff                 WasThrown true            else               printf  One n            longjmp  g ActiveBuf 1           printf  Two n              g ActiveBuf OldActiveBuf      if WasThrown                printf  Error n              return 0      This uses a global pointer so the longjmp   knows what try was last run  We are using abusing the stack so child functions can also have a try catch block   Using this code has a number of down sides  but is a fun mental exercise     It will not free allocated memory as there are no deconstructors being called  You can t have more than 1 try catch in a scope  no nesting  You can t actually throw exceptions or other data like in C   Not thread safe at all You are setting up other programmers for failure because they will likely not notice the hack and try using them like C   try catch blocks

User · Answer

In C99  you can use setjmp longjmp for non-local control flow   Within a single scope  the generic  structured coding pattern for C in the presence of multiple resource allocations and multiple exits uses goto  like in this example  This is similar to how C   implements destructor calls of automatic objects under the hood  and if you stick to this diligently  it should allow you for a certain degree of cleanness even in complex functions

User · Answer

A quick google search yields kludgey solutions such as this that use setjmp/longjmp as others have mentioned. Nothing as straightforward and elegant as C++/Java's try/catch. I'm rather partial to Ada's exception handling myself.

Check everything with if statements :)

User · Answer

This can be done with setjmp longjmp in C  P99 has a quite comfortable toolset for this that also is consistent with the new thread model of C11

User · Answer

Redis use goto to simulate try catch  IMHO it is very clean and elegant      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  amp rdb fp       if  rdbSaveRio  amp rdb  amp 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

User · Answer

You use goto in C for similar error handling situations  That is the closest equivalent of exceptions you can get in C

User · Answer

If you re using C with Win32  you can leverage its Structured Exception Handling  SEH  to simulate try catch   If you re using C in platforms that don t support setjmp   and longjmp    have a look at this Exception Handling of pjsip library  it does provide its own implementation

User · Answer

Perhaps not a major language  unfortunately   but in APL  theres the  EA operation  stand for Execute Alternate    Usage   Y   EA  X  where X and Y are either code snippets supplied as strings or function names   If X runs into an error  Y  usually error-handling  will be executed instead

User · Answer

While some of the other answers have covered the simple cases using setjmp and longjmp, in a real application there's two concerns that really matter.

Nesting of try/catch blocks. Using a single global variable for your jmp_buf will make these not work.
Threading. A single global variable for you jmp_buf will cause all kinds of pain in this situation.

The solution to these is to maintain a thread-local stack of jmp_buf that get updated as you go. (I think this is what lua uses internally).

So instead of this (from JaredPar's awesome answer)

static jmp_buf s_jumpBuffer;

void Example() { 
  if (setjmp(s_jumpBuffer)) {
    // The longjmp was executed and returned control here
    printf("Exception happened\n");
  } else {
    // Normal code execution starts here
    Test();
  }
}

void Test() {
  // Rough equivalent of `throw`
  longjump(s_jumpBuffer, 42);
}

You'd use something like:

#define MAX_EXCEPTION_DEPTH 10;
struct exception_state {
  jmp_buf s_jumpBuffer[MAX_EXCEPTION_DEPTH];
  int current_depth;
};

int try_point(struct exception_state * state) {
  if(current_depth==MAX_EXCEPTION_DEPTH) {
     abort();
  }
  int ok = setjmp(state->jumpBuffer[state->current_depth]);
  if(ok) {
    state->current_depth++;
  } else {
    //We've had an exception update the stack.
    state->current_depth--;
  }
  return ok;
}

void throw_exception(struct exception_state * state) {
  longjump(state->current_depth-1,1);
}

void catch_point(struct exception_state * state) {
    state->current_depth--;
}

void end_try_point(struct exception_state * state) {
    state->current_depth--;
}

__thread struct exception_state g_exception_state; 

void Example() { 
  if (try_point(&g_exception_state)) {
    catch_point(&g_exception_state);
    printf("Exception happened\n");
  } else {
    // Normal code execution starts here
    Test();
    end_try_point(&g_exception_state);
  }
}

void Test() {
  // Rough equivalent of `throw`
  throw_exception(g_exception_state);
}

Again a more realistic version of this would include some way to store error information into the exception_state, better handling of MAX_EXCEPTION_DEPTH (maybe using realloc to grow the buffer, or something like that).

DISCLAIMER: The above code was written without any testing whatsoever. It is purely so you get an idea of how to structure things. Different systems and different compilers will need to implement the thread local storage differently. The code probably contains both compile errors and logic errors - so while you're free to use it as you choose, TEST it before using it ;)

[c] Try catch statements in C

The answer is

Examples related to c

Tags