[Boost-users] Scoped Pairs of functions?

Hi all, I'm on a project which uses a C++ compiler, but with a lot of C-isms. One of those is that there are objects with pairs of functions which allocate/deallocate resources. I don't have time to fix all of the design issues with the classes that do this (yet), but within one compilation unit I'd like to remove the chance for leaks. So - if I wanted to use boost types to wrap around 2 functions f() and g(), where each function - has a void or primitive return type - takes zero or 1 argument - where f() is called at some point in a scope, and then g() is called *on exiting the scope *from which f() is called and only if f() doesn't throw.. - has its return value ignored. [Gahh....] Is there a boost::bind (or lambda) expression that I can wrap in a type? I'm not adverse to using several template parameters. If it were just nullary functions I could just use: struct Reference {}; struct TypeWrapper{}; // Signify something like shared_ptr, a T which wraps around a pointer to an object of the type containing the functions, where T has a typedef value_type to refer to the wrapped type, and a get() to obtain a pointer to the wrapped pointer. template struct ScopedDuals { typedef R1 (T::*f_t)(); typedef R2 (T::*g_t)(); ScopedDuals(T&t, f_t f, g_t g) : t_(t), g_(g) { (t_.f)(); } ~ScopedDuals() { (t_.*g_)(); } private: T& t_; g_t g_; }; template struct ScopedDuals { typedef typname T::value_type Inner_t; typedef R1 (Inner_t::*f_t)(); typedef R2 (Inner_t::*g_t)(); ScopedDuals(T&t, f_t f, g_t g) : t_(t), g_(g) { (t_.get()->*f)(); } ~ScopedDuals() { (t_.get()->*g_)(); } private: T& t_; g_t g_; }; How do I generalize to include the possibility of a single argument? and.... does anyone have a better suggestion for a name than "ScopedDuals"? While *I *think it's precise, it may not be useful to my teammates. thanks, Brian