The technique of try finally is grate but the following code is a more C++
style aproach:

#include <windows.h>

template<typename LOCK_TYPE>
class Guard
{
protected:
  LOCK_TYPE * lock_;
public:
  Guard(LOCK_TYPE & lock) : lock_(&lock)
  {
      this->lock_->aquire();  
  }
 
  ~Guard()
  {
      this->lock_->release();
  }
};

class CriticalSection
{
private:
   CRITICAL_SECTION cs_;

public:
   CriticalSection()
   {
      ::InitializeCriticalSection(&this->cs_);
   }

   ~CriticalSection()
   {
      ::DeleteCriticalSection(&this->cs_);
   }

   void aquire(void)
   {
      ::EnterCriticalSection(&this->cs_);
   }

   void release(void)
   {
      ::LeaveCriticalSection(&this->cs_);
   }
};

class Mutex
{
  // kind of the same as CritcalSection class but using CreateMutex,
OpenMutex, etc...
};

CriticalSection g_cs;
//Mutex g_mtx;

int do_something(void)
{
  Guard<CriticalSection> guard(g_cs);
  //Guard<Mutex> guard(g_mtx);

  // do something usefull and dont't butter about releasing the critical
  // section because the Guard's template destructor will do it for you
  // as soon as you leave this function whatever it happens.

  // it is pretty generic because you can use not only critical sections
  // but mutexes as well.

  return 0;
}

int main(int argc, char * argv[])
{
  return do_something();
}

Ivan Mejia C++ Dev.