Re: RAII (Resource Acquisition Is Initialization) pattern limitations
On Dec 26, 12:58 pm, George <Geo...@discussions.microsoft.com> wrote:
Hello everyone,
Through my testing and study of RAII (Resource Acquisition Is
Initialization) pattern, I think it can solve resource release issue in th=
e
following two situations,
1. Local function object (on stack);
2. Object (either on heap or stack) pointer by auto_ptr;
But it has the limitation that the object pointed by a normal pointer and
allocated on heap (using new or new[]) can not be automatically released,
either the function returns normally or during exception stack unwinding. =
Is
that correct?
A naked pointer or a normal pointer is just normal pointer. It is not
smart. Smart pointers are nothing but classes. You use their objects.
And any object that you create without new/new[] i.e. on the stack get
destroyed when they go out of scope or when exception is raised
(during stack unwinding). When an object gets destroyed, its
destructor is called. RAII is just about exploiting this behavior. You
allocate via new and let the smart pointer keep a reference (not
literally a C++ reference) to the returned pointer. And when the
destructor is called on object destruction, what this smart pointer
class does is call delete or delete[] as appropriate on that pointer
reference. So the memory is release without you having to manually
intervene. It cannot get any more simpler than that.
Note that auto_ptr takes care only of allocations done using new
expression and not the array form of new or just about any other
allocation function. It just deals with new! To take care of
allocations done by new[], you must be knowing that calling delete
would be undefined behavior. You need to apply the array form of
delete - delete[]. What you can do for that is either use
boost::scoped_array or devise your own auto_array_ptr which would be
an exact replica implementation of std::auto_ptr, just that you
replace all delete's with delete[]'s. Or you can make them more
generic to taken in a deleter - something like how shared_ptr takes
does.