Re: How to make this exception-safe
How would you go about making an exception-safe version of V::V()?
This is what I could come up with:
// 1st attempt
#include <memory>
V::V() {
v_.reserve(3);
std::auto_ptr<C> c1( new C(2) );
std::auto_ptr<C> c2( new C(1) );
std::auto_ptr<C> c3( new C(3) );
v_.push_back( c1.release() );
v_.push_back( c2.release() );
v_.push_back( c3.release() );
}
V:V() : v_(3u)
{
try {
v_[0u] = new C(2);
v_[1u] = new C(1);
v_[2u] = new C(3);
} catch {
delete v_[2u];
delete v_[1u];
delete v_[0u];
throw;
}
}
What's wrong with this? Looks solid, easily readable and thus maintainable
to me.
Which is tedious if you are inserting more objects. Does anyone have a
better solution?
Admitted, these hand-made approaches don't scale much, but we have loops and
std::for_each...
PS! boost/tr1 shared_ptr or similar can not be used.
That's the way I'd go for. In most cases my time costs more than the space
wasted in memory for some reference counters. When memory is an issue I'd go
for a pointer container.
Why not? (It's important to know what constraints we are working
under.)
As stated earlier there is no way of using auto_ptr in STL containers. If
you can't use the whole lot of C++-Boost libraries then copy the
boost::shared_ptr to your code base as suggested earlier on. If that's not
an option for reasons I can't imagine then write your own. To use it with
STL however it must be CopyConstructible and Assignable... and thus
reference counted, I guess.
I would suggest using a container which holds pointers and manages
lifetimes -- boost has a few under the name Pointer Container.
Mostly making a templated pointer container available in your code base pays
off shortly when dealing with non-value types.
Sorry, it is essential that it is written entirely in Standard C+
+(03).
In what way is a smart pointer or a pointer container non-Standard C++?
Otherwise:
namespace
{
std::auto_ptr<C> new_C(int n) { return std::auto_ptr<C>(n); }
}
V::V() {
std::auto_ptr<C> a[] = {
new_C(2),
new_C(1),
new_C(3)
};
const size_t count = sizeof a / sizeof a[0]
v_.reserve(count);
std::transform(a, a + count, std::back_inserter(v_),
boost::bind(&std::auto_ptr<C>::release, _1));
}
This looks like a solid solution. I would of course have to use the
standard binders.
I see no advantage over using a try-catch-rethrow. Also, when
std::transform() is used out of place, as reader I would not expect the
source range to be modified in any way.
[I took the liberty of snipping the try/catch example, since it is
worse than the other two, IMHO]
I liked the sentry approach suggested in an earlier post, although I'd take
the container as a reference. I never used a sentry in my projects. Smart
pointers and simple RAII-encapsulation on handle-like suffice for me. It
just does not appear natural to give an entity the responsibility of
cleaning up some other objects contents. However, might be I'm just not used
to the pattern. Anyways, separating cleanup of the pointers out of V's
responsibility is most likely reasonable, assuming V is some entity other
than class Helper { void DoStuff(); }.
Regards,
Thomas.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]