Since there is no `finally` in C++ [you have to use the RAII](http://www.research.att.com/~bs/bs_faq2.html#finally) design pattern instead, if you want your code to be exception safe. One way to do this is by using the destructor of a local class like this:

```
void foo() {
    struct Finally {
        ~Finally() { /* cleanup code */ }
    } finalizer();
    // ...code that might throw an exception...
}

```

This is a big advantage over the straight forward solution, because you don't have to write the cleanup code 2 times:

```
try {
    // ...code that might throw an exception...
    // cleanup code (no exception)
} catch (...) {
    // cleanup code (exception)
    throw;
}

```

A big disadvantage of the local class solution is that you can't directly access local variables in your cleanup code. So it will bloat your code a lot if you need access to them regardless:

```
void foo() {
    Task* task;
    while (task = nextTask()) {
        task->status = running;
        struct Finally {
            Task* task;
            Finally(Task* task) : task(task) {}
            ~Finally() { task->status = idle; }
        } finalizer(task);
        // ...code that might throw an exception...
    }
}

```

**So my question is:** Is there a solution which combines both advantages? So that you a) don't have to write duplicate code and b) can access local variables in the cleanup code, like `task` in the last example, but without such code bloat.