Question

Bjarne Stroustrup writes in his C++ Style and Technique FAQ, emphasis mine:

Because C++ supports an alternative that is almost always better: The ‘resource acquisition is initialization’ technique (TC++PL3 section 14.4). The basic idea is to represent a resource by a local object, so that the local object’s destructor will release the resource. That way, the programmer cannot forget to release the resource. For example:

class File_handle {     FILE* p; public:     File_handle(const char* n, const char* a)         { p = fopen(n,a); if (p==0) throw Open_error(errno); }     File_handle(FILE* pp)         { p = pp; if (p==0) throw Open_error(errno); }      ~File_handle() { fclose(p); }      operator FILE*() { return p; }      // ... };  void f(const char* fn) {     File_handle f(fn,'rw'); // open fn for reading and writing     // use file through f } 

In a system, we need a ‘resource handle’ class for each resource. However, we don’t have to have an ‘finally’ clause for each acquisition of a resource. In realistic systems, there are far more resource acquisitions than kinds of resources, so the ‘resource acquisition is initialization’ technique leads to less code than use of a ‘finally’ construct.

Note that Bjarne writes ‘almost always better’ and not ‘always better’. Now for my question: What situation would a finally construct be better than using the alternative construct (RAII) in C++?

Answer 1

The only reason I can think of that a finally block would be "better" is when it takes less code to accomplish the same thing. For example, if you have a resource that, for some reason doesn’t use RAII, you would either need to write a class to wrap the resource and free it in the destructor, or use a finally block (if it existed).

Compare:

class RAII_Wrapper {     Resource *resource;  public:     RAII_Wrapper() : resource(aquire_resource()) {}      ~RAII_Wrapper() {         free_resource(resource);         delete resource;     }      Resource *getResource() const {         return resource;     } };  void Process() {     RAII_Resource wrapper;     do_something(wrapper.resource); } 

versus:

void Process() {     try {         Resource *resource = aquire_resource();         do_something(resource);     }     finally {         free_resource(resource);         delete resource;     } } 

Most people (including me) would still argue that the first version is better, because it doesn’t force you to use the try…finally block. You also only need to write the class once, not duplicate the code in every function that uses the resource.

Edit: Like litb mentioned, you should use an auto_ptr instead of deleting the pointers manually, which would simplify both cases.