Re: deriving from std::runtime_error
On Aug 6, 1:59 am, Nick Keighley <nick_keighley_nos...@hotmail.com>
wrote:
I'm trying to derive my own exceptions from runtime_error.
That's good.
I want the what() to produce something like
runtime error: my error subtype A
The "runtime error" part will not be the same on every environment.
So I tried:
class MyError: public std::runtime_error
{
public:
MyError (const std::string& what):
runtime_error(std::string("my error ") + what)
{}
};
and throw like this:
throw MyError("subtype A");
I'm sure I got the above to compile.
g++ compiles the code for me as well.
class MyError: public std::runtime_error
{
public:
MyError(const std::string& what):
runtime_error("my error"), what_(what)
{}
When the class has at least one member (what_) now g++ errors:
looser throw specifier for =1B$-1=F2=F8virtual MyError::~MyError()=F2=F9
So I added this:
~MyError() throw()
{}
const char* what()
{
That function signature is not the same as runtime_error's what(), so
it's not "overriding" but "hiding" in this case. g++ warns:
=1B$-1=F2=F8virtual const char* std::runtime_error::what() const=F2=F9 wa=
s
hidden
And then about the same looser throw specifier. So it must be:
const char* what() const throw()
static char buffer[1024];
sprintf (buffer, "%s %s", std::runtime_error::what(),
what_);
One last warning from g++:
cannot pass objects of non-POD type =1B$-1=F2=F8const struct
std::string=F2=F9 through =F2=F8...=F2=F9; call will abort at runtime
So pass a 'const char *' to sprintf instead:
sprintf (/* ... */, what_.c_str());
return buffer;
}
private:
std::string what_;
};
(yes, I know a static buffer and a sprintf() call are asking for
trouble)
It is an interesting idea though, because if one assumes that there
can only be one exception thrown at a given time; that buffer cannot
be shared by two exceptions. But, if multithreaded, there may be two
exceptions in flight at the same time to be thrown on two separate
threads and that would be trouble.
How about storing the error information as fundamental types and
returning that to the caller:
private:
double temperature_;
The caller can make use of that information in any way they want:
catch (const MyError & error) {
cout << "Error: Temperature was " << error.get_temperature() <<
'\n';
}
the compiler objects to the runtime_error::what() call
illegal call of non-static member function
That's the wrong error message.
well I know its non-static, but why is it illegal?
The above should fix it.
Ali