使用标准C ++ 98/03清除分配和构造一个对象

Question

In my code I need to allocate and construct an object dynamically and push the pointer to it into a vector. Is there a cleaner way to this than the code below without using all those ugly try-catch blocks? I cannot use non-standard libraries. There is no C++11. I only have the standard C++98/03.

void insert() {
            //...do something...
            MyType* obj = 0;
            try {
                obj = alloc.allocate(1); // yes, even the allocation must be inside one try-catch in my case, since I need to undo something
                alloc.construct(obj, default_obj);
                try {
                    v.push_back(obj);
                } catch (...) {
                    alloc.destroy(obj);
                    throw;
                }
            } catch (...) {
                //..undo something..
                if (obj)
                    alloc.deallocate(obj, 1);
                throw;
            }
}

EDIT: alloc is an allocator passed as argument somewhere to avoid raw new/delete. v is a vector.

Answer 1

The obvious solution is to use custom RAII classes: a try/catch block with a rethrow is equivalent to a destructor doing the same clean-up although with two managable caveats (unless the exception type is used somehow):

• the object won't have the implicit context of the catch-block ie it needs to get the necessary information passed
• the destructor is always called, ie it is necessary to signal that it does need to do anything once the main operation succeeded

Since you didn't state what else you needed to clean-up I can't comment in how to best deal with this other than doing it in a destructor. For the allocator use I would actually create a custom smart pointer which takes the constructor arguments and the allocator as arguments to its own constructor (yes, with variadic and perfect forwarding unavailable this is a bit annoying but doable: I have done something like this more than once). The smart piinter would actually bundle up the allocator as well for also dealing with the deallocation later using the correct allocator. Since move semantics essentially can't be done right without rvalue references the smart pointer would use reference counting.

Generally, using RAII is the way for all kinds of implicit undoing, even independent of exception:!for any mon-trivial code eventually someone comes along andprematurely returns from the function. It may be a bit more up-front work to create RAII classes but I found that it dramatically releaves me from rather technical work mixed up with business logic. Also, many classes I have started their life as RAII classes but turned into classes encapsulating the functionality used to access the "resource's" logic.