What is going on here?

[w0rp via Digitalmars-d]

Why not handle the scope(failure) cases in the constructor itself?

struct SomeStruct {
     void* ptr;
     void* ptr2;

     this() {
         ptr = malloc(...);
         scope(failure) free(ptr);

         /* Whatever follows, possibly throwing. */

         ptr2 = malloc(...);
         scope(failure) free(ptr2);
     }

     ~this() {
         free(ptr);
         free(ptr2);
     }
}

Now if the constructor throws, the resource which needs to be 
dealt with, whatever it is, is handled even though the destructor 
is never invoked. Additionally, you only execute the 
scope(failure) lines you reach before an exception is thrown, 
whereas the destructor will try to clean up all of the resources. 
Now the user of SomeStruct can use it the RAII way, and never 
have to worry about handling cleanup for it.

Then you can use the some simple rules and apply them 
consistently.

1. Declare constructors as nothrow where you can.
2. Handle failure cases when you can't declare constructors as 
nothrow.