This is a paper exercise.
The principles of exception handling require that an exception handler must do only one of the following:

- clean up (eg close open files) and re-throw (or exit with error)
(Not needed if you're using RAII!!!)

clean_up(Resource *p);

foo() {
	Resource x;
	try {
		do_something(x); // might throw
		clean_up(&x);
	} catch (...) { // catch any
	    clean_up(&x);
		throw;
	}
}
class Rmanager {//RAII
	Resource *r;
	public:
	Rmanager(Resource *x) : r(x) {}
	~Rmanager() {clean_up(r);}
	// Gang of Three!
	Rmanager(const Rmanager &other) = delete;
	Rmanager & operator= (const Rmanager &other) = delete;
};
foo2() throws X {
	Resource x;
	Rmanager xm(&x);
	try {
		do_something(x);
	}
}
- or attempt to rectify original cause and ensure that try block is re-executed

	Resource x;
	boolean done = false;
	do {
		try {
			do_something(&x);
			done = true;
		} catch (myexception &e) {
			fix_issue(e);
		}
	} while (!done);

- or attempt to achieve same effect as the try block in some other way
Sketch examples in C++ syntax.

	try {
		do_something_cheap_and_fast_algo();
	} catch (myexception &e) {
		do_something_expensive_and_slow_algo();
	}