Does C support finally blocks And what s this RAII I keep hearing about

Question

Does C   support  finally  blocks   What is the RAII idiom   What is the difference between C   s RAII idiom and C  s  using  statement

User · Answer

try           goto finally    catch                goto finally    finally

User · Answer

As many people have stated  the solution is to use C  11 features to avoid finally blocks  One of the features is unique ptr   Here is Mephane s answer written using RAII patterns    include  lt vector gt   include  lt memory gt   include  lt list gt  using namespace std   class Foo            void DoStuff vector lt string gt  input        list lt unique ptr lt Foo gt   gt  myList       for  int i   0  i  lt  input size      i              myList push back unique ptr lt Foo gt  new Foo input i                 DoSomeStuff myList       Some more introduction to using unique ptr with C   Standard Library containers is here

User · Answer

why is it that even managed languages provide a finally-block despite resources being deallocated automatically by the garbage collector anyway    Actually  languages based on Garbage collectors need  finally  more  A garbage collector does not destroy your objects in a timely manner  so it can not be relied upon to clean up non-memory related issues correctly   In terms of dynamically-allocated data  many would argue that you should be using smart-pointers   However        RAII moves the responsibility of exception safety from the user of the object to the designer   Sadly this is its own downfall   Old C programming habits die hard   When you re using a library written in C or a very C style  RAII won t have been used  Short of re-writing the entire API front-end  that s just what you have to work with   Then the lack of  finally  really bites

User · Answer

In C   the finally is NOT required because of RAII   RAII moves the responsibility of exception safety from the user of the object to the designer  and implementer  of the object  I would argue this is the correct place as you then only need to get exception safety correct once  in the design implementation   By using finally you need to get exception safety correct every time you use an object   Also IMO the code looks neater  see below    Example   A database object  To make sure the DB connection is used it must be opened and closed  By using RAII this can be done in the constructor destructor   C   Like RAII  void someFunc         DB    db  DBDesciptionString           Use the db object        db goes out of scope and destructor closes the connection       This happens even in the presence of exceptions    The use of RAII makes using a DB object correctly very easy  The DB object will correctly close itself by the use of a destructor no matter how we try and abuse it   Java Like Finally  void someFunc         DB      db   new DB  DBDesciptionString        try                  Use the db object            finally                  Can not rely on finaliser             So we must explicitly close the connection          try                       db close                      catch Throwable e                          Ignore                  Make sure not to throw exception if one is already propagating                      When using finally the correct use of the object is delegated to the user of the object  i e  It is the responsibility of the object user to correctly to explicitly close the DB connection  Now you could argue that this can be done in the finaliser  but resources may have limited availability or other constraints and thus you generally do want to control the release of the object and not rely on the non deterministic behavior of the garbage collector   Also this is a simple example  When you have multiple resources that need to be released the code can get complicated   A more detailed analysis can be found here  http   accu org index php journals 236

User · Answer

I have a use case where I think finally should be a perfectly acceptable part of the C  11 language  as I think it is easier to read from a flow point of view  My use case is a consumer producer chain of threads  where a sentinel nullptr is sent at the end of the run to shut down all threads   If C   supported it  you would want your code to look like this       extern Queue downstream  upstream       int Example                 try                      while  ExitRequested                              X  x   upstream pop                 if   x  break               x- gt doSomething                 downstream push x                                   finally                downstream push nullptr                     I think this is more logical that putting your finally declaration at the start of the loop  since it occurs after the loop has exited    but that is wishful thinking because we can t do it in C    Note that the queue downstream is connected to another thread  so you can t put in the sentinel push nullptr  in the destructor of downstream because it can t be destroyed at this point    it needs to stay alive until the other thread receives the nullptr   So here is how to use a RAII class with lambda to do the same       class Finally           public           Finally std  function lt void void  gt  callback    callback  callback                               Finally                         callback                       std  function lt void void  gt  callback            and here is how you use it       extern Queue downstream  upstream       int Example                 Finally atEnd                   downstream push nullptr                       while  ExitRequested                         X  x   upstream pop               if   x  break             x- gt doSomething               downstream push x

User · Answer

FWIW  Microsoft Visual C   does support try finally and it has historically been used in MFC apps as a method of catching serious exceptions that would otherwise result in a crash   For example   int CMyApp  Run            try               int i   CWinApp  Run            m Exitok   MAGIC EXIT NO          return i              finally               if  m Exitok    MAGIC EXIT NO              FaultHandler              I ve used this in the past to do things like save backups of open files prior to exit   Certain JIT debugging settings will break this mechanism though

User · Answer

RAII is usually better  but you can have easily the finally semantics in C    Using a tiny amount of code  Besides  the C   Core Guidelines give finally  Here is a link to the GSL Microsoft implementation and a link to the Martin Moene implementation Bjarne Stroustrup multiple times said that everything that is in the GSL it meant to go in the standard eventually  So it should be a future-proof way to use finally  You can easily implement yourself if you want though  continue reading  In C  11 RAII and lambdas allows to make a general finally  namespace detail     adapt to your  quot private quot  namespace template  lt typename F gt  struct FinalAction       FinalAction F f    clean  f         FinalAction     if enabled   clean           void disable     enabled    false       private      F clean       bool enabled  true         template  lt typename F gt  detail  FinalAction lt F gt  finally F f        return detail  FinalAction lt F gt  f      example of use   include  lt iostream gt  int main         int  a   new int      auto delete a   finally  a    delete a  std  cout  lt  lt   quot leaving the block  deleting a  n quot           std  cout  lt  lt   quot doing something     n quot      the output will be  doing something    leaving the block  deleting a   Personally I used this few times to ensure to close POSIX file descriptor in a C   program  Having a real class that manage resources and so avoids any kind of leaks is usually better  but this finally is useful in the cases where making a class sounds like an overkill  Besides  I like it better than other languages finally because if used naturally you write the closing code nearby the opening code  in my example the new and delete  and destruction follows construction in LIFO order as usual in C    The only downside is that you get an auto variable you don t really use and the lambda syntax make it a little noisy  in my example in the fourth line only the word finally and the   -block on the right are meaningful  the rest is essentially noise   Another example          auto precision   std  cout precision     auto set precision back   finally   precision   amp std  cout      std  cout  lt  lt  std  setprecision precision         std  cout  lt  lt  std  setprecision 3    The disable member is useful if the finally has to be called only in case of failure  For example  you have to copy an object in three different containers  you can setup the finally to undo each copy and disable after all copies are successful  Doing so  if the destruction cannot throw  you ensure the strong guarantee  disable example    strong guarantee void copy to all BIGobj const amp  a        first  push back a       auto undo first push   finally  first  amp     first  pop back             second  push back a       auto undo second push   finally  second  amp     second  pop back             third  push back a         no necessary  put just to make easier to add containers in the future     auto undo third push   finally  third  amp     third  pop back             undo first push disable        undo second push disable        undo third push disable       If you cannot use C  11 you can still have finally  but the code becomes a bit more long winded  Just define a struct with only a constructor and destructor  the constructor take references to anything needed and the destructor does the actions you need  This is basically what the lambda does  done manually   include  lt iostream gt  int main         int  a   new int       struct Delete a t           Delete a t int  p    p  p             Delete a t     delete p   std  cout  lt  lt   quot leaving the block  deleting a  n quot             int  p         delete a a        std  cout  lt  lt   quot doing something     n quot      Hopefully you can use C  11  this code is more to show how the  quot C   does not support finally quot  has been nonsense since the very first weeks of C    it was possible to write this kind of code even before C   got its name

User · Answer

Sorry for digging up such an old thread  but there is a major error in the following reasoning      RAII moves the responsibility of exception safety from the user of the object to the designer  and implementer  of the object  I would argue this is the correct place as you then only need to get exception safety correct once  in the design implementation   By using finally you need to get exception safety correct every time you use an object    More often than not  you have to deal with dynamically allocated objects  dynamic numbers of objects etc  Within the try-block  some code might create many objects  how many is determined at runtime  and store pointers to them in a list  Now  this is not an exotic scenario  but very common  In this case  you d want to write stuff like  void DoStuff vector lt string gt  input      list lt Foo  gt  myList     try             for  int i   0  i  lt  input size      i              Foo  tmp   new Foo input i          if   tmp          throw         myList push back tmp              DoSomeStuff myList         finally         while   myList empty                delete myList back          myList pop back                  Of course the list itself will be destroyed when going out of scope  but that wouldn t clean up the temporary objects you have created   Instead  you have to go the ugly route   void DoStuff vector lt string gt  input      list lt Foo  gt  myList     try             for  int i   0  i  lt  input size      i              Foo  tmp   new Foo input i          if   tmp          throw         myList push back tmp              DoSomeStuff myList         catch                 while   myList empty            delete myList back        myList pop back            Also  why is it that even managed lanuages provide a finally-block despite resources being deallocated automatically by the garbage collector anyway   Hint  there s more you can do with  finally  than just memory deallocation

User · Answer

EDITED If you are not breaking continuing returning etc   you could just add a catch to any unknown exception and put the always code behind it  That is also when you don t need the exception to be re-thrown  try        something that might throw exception   catch               what to do with uknown exception      final code to be called always    don t forget that it might throw some exception too doSomeCleanUp      So what s the problem  Normally finally in other programming languages usually runs no matter what usually meaning regardless of any return  break  continue       except for some sort of system exit   - which differes a lot per programming language - e g  PHP and Java just exit in that moment  but Python executes finally anyways and then exits  But the code I ve described above doesn t work that way   gt  following code outputs ONLY something wrong    include  lt stdio h gt   include  lt iostream gt   include  lt string gt   std  string test         try            something that might throw exception        throw  quot exceptiooon  quot           return  quot fine quot         catch                return  quot something wrong  quot                  return  quot finally quot      int main void             std  cout  lt  lt  test                  return 0

User · Answer

No  C   does not support  finally  blocks   The reason is that C   instead supports RAII   Resource Acquisition Is Initialization  -- a poor name    for a really useful concept     The idea is that an object s destructor is responsible for freeing resources   When the object has automatic storage duration  the object s destructor will be called when the block in which it was created exits -- even when that block is exited in the presence of an exception   Here is Bjarne Stroustrup s explanation of the topic   A common use for RAII is locking a mutex      A class with implements RAII class lock       mutex  amp m    public      lock mutex  amp m          m  m                m acquire               lock                 m  release                 A class which uses  mutex  and  lock  objects class foo       mutex mutex      mutex for locking  foo  object public      void bar                 lock scopeLock mutex       lock object           foobar       an operation which may throw an exception             scopeLock will be destructed even if an exception            occurs  which will release the mutex and allow            other functions to lock the object and run             RAII also simplifies using objects as members of other classes  When the owning class  is destructed  the resource managed by the RAII class gets released because the destructor for the RAII-managed class gets called as a result   This means that when you use RAII for all members in a class that manage resources  you can get away with using a very simple  maybe even the default  destructor for the owner class since it doesn t need to manually manage its member resource lifetimes   Thanks to Mike B for pointing this out    For those familliar with C  or VB NET  you may recognize that RAII is similar to  NET deterministic destruction using IDisposable and  using  statements   Indeed  the two methods are very similar   The main difference is that RAII will deterministically release any type of resource -- including memory   When implementing IDisposable in  NET  even the  NET language C   CLI   resources will be deterministically released except for memory   In  NET  memory is not deterministically released  memory is only released during garbage collection cycles    nbsp       Some people believe that  Destruction is Resource Relinquishment  is a more accurate name for the RAII idiom

User · Answer

I came up with a finally macro that can be used almost like   the finally keyword in Java  it makes use of std  exception ptr and friends  lambda functions and std  promise  so it requires C  11 or above  it also makes use of the compound statement expression GCC extension  which is also supported by clang   WARNING  an earlier version of this answer used a different implementation of the concept with many more limitations    First  let s define a helper class    include  lt future gt   template  lt typename Fun gt  class FinallyHelper       template  lt typename T gt  struct TypeWrapper         using Return   typename std  result of lt Fun   gt   type   public          FinallyHelper Fun body            try               execute TypeWrapper lt Return gt     body                     catch                    m promise set exception std  current exception                          Return get             return m promise get future   get           private      template  lt typename T gt      void execute T  Fun body            m promise set value body                void execute TypeWrapper lt void gt   Fun body            body               std  promise lt Return gt  m promise      template  lt typename Fun gt  FinallyHelper lt Fun gt  make finally helper Fun body        return FinallyHelper lt Fun gt  body       Then there s the actual macro     define try with finally for auto   finally helper   make finally helper   amp     try   define finally                                       true                                            return   finally helper get                 It can be used like this   void test         try with finally           raise exception                   catch const my exception1 amp                                catch const my exception2 amp                                finally           clean it all up                  The use of std  promise makes it very easy to implement  but it probably also introduces quite a bit of unneeded overhead which could be avoided by reimplementing only the needed functionalities from std  promise        CAVEAT  there are a few things that don t work quite like the java version of finally  Off the top of my head    it s not possible to break from an outer loop with the break statement from within the try and catch   s blocks  since they live within a lambda function  there must be at least one catch   block after the try  it s a C   requirement   if the function has a return value other than void but there s no return within the try and catch   s blocks  compilation will fail because the finally macro will expand to code that will want to return a void  This could be  err  avoided by having a finally noreturn macro of sorts    All in all  I don t know if I d ever use this stuff myself  but it was fun playing with it

User · Answer

Not really  but you can emulate them to some extend  for example   int   array   new int 10000000   try        Some code that can throw exceptions            throw std  exception               catch              The finally-block  if an exception is thrown    delete   array       re-throw the exception    throw        The finally-block  if no exception was thrown  delete   array    Note that the finally-block might itself throw an exception before the original exception is re-thrown  thereby discarding the original exception  This is the exact same behavior as in a Java finally-block  Also  you cannot use return inside the try amp catch blocks

User · Answer

As pointed out in the other answers  C   can support finally-like functionality   The implementation of this functionality that is probably closest to being part of the standard language is the one accompanying the C   Core Guidelines  a set of best practices for using C   edited by Bjarne Stoustrup and Herb Sutter   An implementation of finally is part of the Guidelines Support Library  GSL    Throughout the Guidelines  use of finally is recommended when dealing with old-style interfaces  and it also has a guideline of its own  titled Use a final action object to express cleanup if no suitable resource handle is available   So  not only does C   support finally  it is actually recommended to use it in a lot of common use-cases   An example use of the GSL implementation would look like    include  lt gsl gsl util h gt   void example         int handle   get some resource        auto handle clean   gsl  finally   amp handle    clean that resource handle               Do a lot of stuff  return early and throw exceptions         clean that resource will always get called      The GSL implementation and usage is very similar to the one in Paolo Bolzoni s answer   One difference is that the object created by gsl  finally   lacks the disable   call   If you need that functionality  say  to return the resource once it s assembled and no exceptions are bound to happen   you might prefer Paolo s implementation   Otherwise  using GSL is as close to using standardized features as you will get

User · Answer

Beyond making clean up easy with stack-based objects  RAII is also useful because the same  automatic  clean up occurs when the object is a member of another class   When the owning class is destructed  the resource managed by the RAII class gets cleaned up because the dtor for that class gets called as a result   This means that when you reach RAII nirvana and all members in a class use RAII  like smart pointers   you can get away with a very simple  maybe even default  dtor for the owner class since it doesn t need to manually manage its member resource lifetimes

User · Answer

Another  finally  block emulation using C  11 lambda functions  template  lt typename TCode  typename TFinallyCode gt  inline void with finally const TCode  amp code  const TFinallyCode  amp finally code        try               code              catch                     try                       finally code                      catch          Maybe stupid check that finally code mustn t throw                        std  terminate                      throw            finally code        Let s hope the compiler will optimize the code above   Now we can write code like this   with finally        amp                   try                          Doing some stuff that may throw an exception                   catch  const exception1  amp                            Handling first class of exceptions                   catch  const exception2  amp                            Handling another class of exceptions                      Some classes of exceptions can be still unhandled              amp        finally                  This code will be executed in all three cases               1  exception was not thrown at all              2  exception was handled by one of the  catch  blocks above              3  exception was not handled by any of the  catch  block above            If you wish you can wrap this idiom into  try - finally  macros      Please never throw exception below  It is needed to avoid a compilation error    in the case when we use  begin try     finally  without any  catch  block  class never thrown exception       define begin try    with finally   amp      try  define finally      catch never thrown exception  throw       amp      define end try           sorry for  pascalish  style      Now  finally  block is available in C  11   begin try          A code that may throw   catch  const some exception  amp            Handling some exceptions   finally          A code that is always executed   end try     Sorry again for this ugly thing   Personally I don t like the  macro  version of  finally  idiom and would prefer to use pure  with finally  function even though a syntax is more bulky in that case   You can test the code above here  http   coliru stacked-crooked com a 1d88f64cb27b3813  PS  If you need a finally block in your code  then scoped guards or ON FINALLY ON EXCEPTION macros will probably better fit your needs   Here is short example of usage ON FINALLY ON EXCEPTION   void function std  vector lt const char  gt   amp vector        int  arr1    int  malloc 800 sizeof int        if   arr1    throw  cannot malloc arr1         ON FINALLY   free arr1            int  arr2    int  malloc 900 sizeof int        if   arr2    throw  cannot malloc arr2         ON FINALLY   free arr2            vector push back  good        ON EXCEPTION   vector pop back

User · Answer

I also think that RIIA is not a fully useful replacement for exception handling and having a finally  BTW  I also think RIIA is a bad name all around  I call these types of classes  janitors  and use them a LOT  95  of the time they are neither initializing nor acquiring resources  they are applying some change on a scoped basis  or taking something already set up and making sure it s destroyed  This being the official pattern name obsessed internet I get abused for even suggesting my name might be better   I just don t think it s reasonable to require that that every complicated setup of some ad hoc list of things has to have a class written to contain it in order to avoid complications when cleaning it all back up in the face of needing to catch multiple exception types if something goes wrong in the process  This would lead to lots of ad hoc classes that just wouldn t be necessary otherwise   Yes it s fine for classes that are designed to manage a particular resource  or generic ones that are designed to handle a set of similar resources  But  even if all of the things involved have such wrappers  the coordination of cleanup may not just be a simple in reverse order invocation of destructors   I think it makes perfect sense for C   to have a finally  I mean  jeez  so many bits and bobs have been glued onto it over the last decades that it seems odd folks would suddenly become conservative over something like finally which could be quite useful and probably nothing near as complicated as some other things that have been added  though that s just a guess on my part

[c++] Does C++ support 'finally' blocks? (And what's this 'RAII' I keep hearing about?)

Examples related to c++

Examples related to exception

Examples related to raii

Examples related to finally

Examples related to c++-faq