Re: Exceptions, Go to Hell!
On Aug 30, 3:53 pm, w...@seed.net.tw wrote:
On 8=E6=9C=8830=E6=97=A5, =E4=B8=8B=E5=8D=883=E6=99=8201=E5=88=86, Goran =
Pusic <gor...@cse-semaphore.com> wrote:
Consider another similar example:
std::vector<T> v;
const size_t cap=get_needed_cap();
try {
v.reserve(cap);
}
catch(std::length_error&) {
assert(cap>v.max_size()); // Time bomb!
// T(T) may throw std::length_error. program can't have suc=
h
// assert, because context is lost.
throw;
}
Ok, this is true, and I finally see your point.
But we're back to our previous discussion: you have a bug (because
length_error is logic_error, which is used to represent bugs). My
question is: when you catch any such a bug, can you fix it in your
current code? Normally not, because bugs are normally fixed by
changing the code, and that means recompilation. So a catch like that
you made is IMO useless and should just not be there. It should
propagate all the way up the stack and cause termination there. Why
termination? Because, I believe, if you hit a bug, you should not
continue running, you should fix it first.
Only thing you might want to do in your situation is to catch, add
more context, and then re-throw similar/same exception. (And I
absolutely agree with you when you say that with exceptions, context
is lost, and I also agree that this is a bad thing). For example
(warning: meta code, doesn't really compile):
....
catch(const std::length_error& e)
{
if (cap>v.max_size())
throw std::length_error("I think there's a bug in get_needed_cap.
Original error was" + e.what());
else
throw; // Something wrong with T()? Not ours, leave original error
alone.
}
As for "adding context" to exceptions, boost::exception seems very
good.
I mean sizeof(T), T being any of the standard exception types.
In another word, adding extra data members to std::logic_error or
std::runtime_error might not be handled properly in the stack
unwinding.
IIRC, the memory came from the book "The C++ Programming Language,
by Bjarne Stroustrup", but couldn't find it again.
It would be appropriated if anyone would verify this restriction.
I agree with =C3=96=C3=B6 Tiib, you probably think of "object slicing", tha=
t
might happen in C++. Look it up on Wikipedia. Object slicing is not
particular to exceptions, but to object copying (and assignment).
Partial solution to this concern is to catch exception object by
reference (and better yet, a const reference), not by value. But to be
absolutely correct, you __need__ to know exact type you want to catch.
Goran.