No, I still don't like it. Perhaps an example will help.
How do you think about a design with function objects?
template<typename Context> class initializer
: public unary_function<Context, void>
{
initializer() {}
virtual ~initializer() {}
virtual void operator() (argument_type& context) = 0;
}
template<typename Context> class finalizer
: public unary_function<Context, void>
{
finalizer() {}
virtual ~finalizer() {}
virtual void operator() (argument_type& context) = 0;
}
// Does it make sense to introduce an interface "Callable"?
template<typename Context,
template<typename Context> class initializer,
template<typename Context> class finalizer>
class RAII4
: private initializer<Context>, finalizer<Context>
{
public:
RAII4(Context& c) : _context(c) {}
virtual ~RAII4() {}
virtual void begin() { initializer<Context>:
perator()(_context); };
virtual void end() { finalizer<Context>:
perator()(_context); };
// Would you like to add anything here?
private:
Context& _context;
}
// small example: templates and classes in action
class door : public method_pair
{
public:
door() {}
virtual ~door() {}
virtual void open() { cout << "Hallo"; };
virtual void close() { cout << "Bye"; };
virtual void begin() { open(); };
virtual void end() { close(); };
}
class room : public method_pair
{
public:
method_pair() : _guard(_one) {}
virtual ~method_pair() {}
virtual void enter() { _one.open(); cout << "Nice furniture"; };
virtual void leave() { cout << "See you later"; _one.close(); };
virtual void begin() { enter(); };
virtual void end() { leave(); };
private:
door _one;
RAII2<door> _guard;
}
Regards,
Markus
