ansaurus

Question

correct way to store an exception in a variable

Answer 1

+2 A:

You have what would be what I think is your best, only answer. You can't keep a reference to the original exception because it's going to leave scope. You simply have to make a copy of it and the only generic way to do that is with a prototype function like clone().

Sorry.

Noah Roberts 2010-06-02 18:44:39

But beware that the root cause of the exception may be an out-of-memory condition, in which case `clone()` will fail if it tries to call `new`. This can be gotten around, e.g. by overloading `operator new()` for each exception type to allocate from a static buffer, but it's not necessarily pretty either.

j_random_hacker 2010-06-02 19:00:47

@j_random_hacker: Well, since we are getting pedantic, what you call out-of-memory is better called bad-alloc and it doesn't have to be actual out of memory. Another reason for bad-alloc is requesting too much memory, and in that case subsequent small allocations will succeed

sbk 2010-06-02 19:51:07

@sbk: Is it really pedantic to consider the possibility of running out of memory?

j_random_hacker 2010-06-02 20:46:11

The easy answer here is to point out that with bad_alloc you're a) screwed, and b) getting a particular exception that you're not going to be able to clone since it won't be your own.

Noah Roberts 2010-06-02 21:15:48

Answer 2

+1 A:

You're allowed to throw anything, including pointers. You could always do something like this:

throw new MyException(args);

And then in the exception handler store the caught pointer, which will be fully polymorphic (below assuming that MyException derives from std::exception):

try {

   doSomething(); // Might throw MyException*

} catch (std::exception* pEx) {

   // store pEx pointer
}

You just have to be careful about memory leaks when you do it this way, which is why throw-by-value and catch-by-reference is normally used.

More about catch-by-pointer: http://www.parashift.com/c++-faq-lite/exceptions.html#faq-17.8

Tyler McHenry 2010-06-02 18:45:28

The problem with this solution as I see it is that you might be throwing an exception due to something that has as its root cause an out-of-memory condition, in which case `new` will fail.

j_random_hacker 2010-06-02 18:57:24

That's mentioned in the link, but you could in theory work around that by having a pre-allocated or static out-of-memory exception that you throw in that case. But then you would need to make sure that you don't delete this as you would your other exceptions. It's do-able but you have to be careful of a lot of pitfalls like this.

Tyler McHenry 2010-06-02 19:02:35

Couldn't we check to see if the exception indicates an out of memory condition and simply set an int/boolean to indicate this?

Vulcan Eager 2010-06-02 19:13:03

+1: For my particular use can this isn't a bad idea. similar to the clone approach but doing at the point of the throw.

Evan Teran 2010-06-02 19:31:10

Answer 3

A:

The reason why catching an exception thrown in one library and catching it in another can lead to undefined behavior is that these libraries could be linked with different Runtime libraries. If you will return exception from a function instead of throwing it you will not avoid that problem.

Kirill V. Lyadvinsky 2010-06-02 18:50:07

I believe you are correct, I think the issue Qt has with it is more about passing between threads (I've added that subtlety to my question as well).

Evan Teran 2010-06-02 18:54:03

ansaurus

tags:

views:

answers:

correct way to store an exception in a variable

related questions