Question

Exceptional C++ mentions the following code

template <class T> class Stack 
{
    public:
      Stack();
      ~Stack();

      /*...*/

    private:
       T*     v_;      // ptr to a memory area big
       size_t vsize_;  //  enough for 'vsize_' T's
       size_t vused_;  // # of T's actually in use
};



template<class T> 
Stack<T>::Stack()
        : v_(new T[10]),  // default allocation
          vsize_(10),
          vused_(0)       // nothing used yet
{ 
}

It says that If one of the T constructors threw, then any T objects that were fully constructed were properly destroyed and, finally, operator delete was automatically called to release the memory. That makes us leakproof.

My understanding was that if a constructor throws an exception, the application should cleanup any allocated resources. How is the above leakproof?

Answer 1

Quoting the C++03 standard, §5.3.4/8:

A new-expression obtains storage for the object by calling an allocation function. If the new-expression terminates by throwing an exception, it may release storage by calling a deallocation function. If the allocated type is a non-array type, the allocation function’s name is operator new and the deallocation function’s name is operator delete. If the allocated type is an array type, the allocation function’s name is operator new[] and the deallocation function’s name is operator delete[].

§5.3.4/17:

If any part of the object initialization described above terminates by throwing an exception and a suitable deallocation function can be found, the deallocation function is called to free the memory in which the object was being constructed, after which the exception continues to propagate in the context of the new-expression.

Consequently, if any T constructor throws an exception, the runtime will destroy any already-created subobjects of the T instance whose constructor threw, then call operator delete[] on the array as a whole, destroying any already-created elements and deallocating the array’s memory.