Re: The C++ article in April issue of DDJ
On Mar 19, 7:24 pm, "Andrei Iltchenko" <andrei.ilche...@gmail.com>
wrote:
Hello everybody,
It has been a while since I last posted to this newsgroup, but the
recent article in DDJ by Gigi Sayfan entitled "Practical C++ Error
Handling in Hybrid Environments" (available athttp://www.ddj.com/dept/cpp/197003350)
left me no choice but to react.
What caught my attention is the "cunning" StreamingException class and
some of the author's comments about its design that are plainly
inaccurate. Here's the class
I don't quite know what is "cunning" about the class - at least not in
so far as this is at least the 3rd variant along this line I've seen
recently. I don't particularly like this sort of exception class
either as people tend to inherit from it, and throw exceptions with
large amounts of attached text and no way of programmatically
determining what caused the exception in the first place. I know
exceptions aren't considered to be efficient, but adding this sort of
load onto them is hardly going to help.
But the bad thing about this is it is not exception safe in itself,
which is a really really bad thing for an exception class to be.
class StreamingException : public std::runtime_error
{
public:
StreamingException() :
std::runtime_error(""),
ss_(std::auto_ptr<std::stringstream>
(new std::stringstream()))
{
}
That's probably going to be OK, although dodgy if you are running low
on memory. And if it does throw, you are dead. No second chance.
~StreamingException() throw()
{
}
template <typename T>
StreamingException & operator << (const T & t)
{
(*ss_) << t;
return *this;
}
That can throw - slightly unlikely, but certainly more likely than the
constructor.
virtual const char * what() const throw()
{
s_ = ss_->str();
return s_.c_str();
}
c_str() can throw. If it does, because of the throw() spec - bang goes
your program, and you'll have to debug it coz you're unlikely to get
any useful message.
private:
mutable std::auto_ptr<std::stringstream> ss_;
mutable std::string s_;
};
<snip>
"Exception specifications are an annoying misfeature of C++
that specifies what exceptions a method may throw and are part of the
method signature. Thankfully, they are optional so you don't see them
a lot in the wild. "
The annoying misfeature is the way they are processed at runtime,
rather than compile time. It makes them unusable if you are trying to
write resilient programs.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]