throw

I want to throw my own exceptions with the base class Exception . There is a virtual method print which will be overwritten by the subclasses. I only catch the type Exception& and use print to get the specific error. The problem is that once I throw a reference of a subclass it is trated as if it were the base class. Here is an example: #include <iostream> using namespace std; class Exception { public: virtual void print() { cout << "Exception" << endl; } }; class IllegalArgumentException : public Exception { public: virtual void print() { cout << "IllegalArgumentException" << endl; } }; int

If in my code I have the following snippet: try { doSomething(); } catch (...) { doSomethingElse(); throw; } Will the throw rethrow the specific exception caught by the default ellipsis handler? Yes. The exception is active until it's caught, where it becomes inactive. But it lives until the scope of the handler ends . From the standard, emphasis mine: §15.1/4: The memory for the temporary copy of the exception being thrown is allocated in an unspecified way, except as noted in 3.7.4.1. The temporary persists as long as there is a handler being executed for that exception. That is: catch(...)

I heard you should never throw a string because there is a lack of information and you'll catch exceptions you dont expect to catch. What are good practice for throwing exceptions? do you inherit a base exception class? Do you have many exceptions or few? do you do MyExceptionClass& or const MyExceptionClass& ? etc. Also i know exceptions should never been thrown in destructors i'll add that i understand design by contract and when to throw exception. I am asking how i should throw exceptions. In my opinion, a function should throw an exception if it can't keep its "promise", if it has to

Is there a better solution to forward a Swift error from one function to another? In the moment, I'm doing it like this: enum Error:ErrorType{ case Error1 case Error2 } func func1()throws{ do{ try func2() }catch Error.Error1{ throw Error.Error1 }catch Error.Error2{ throw Error.Error2 } } func func2()throws{ // proof something throw Error.Error1 } So, to forward an error, I need to catch all the errors and throw them again. Is there a better solution? Yes: don't wrap it in a do ... catch block. func func2() throws{ // proof something throw Error.Error1 } func func1()throws{ try func2() } You

I'm trying to compile/port an older version of OpenOffice. It uses Boost v1.34.1, which is part of the source tree. The error message is as follows: Undefined symbols: "boost::throw_exception(std::exception const&)", referenced from: boost::detail::shared_count::shared_count<ScToken>(ScToken*)in detfunc.o ld: symbol(s) not found Boost is new to me, and I haven't been able to find much online to help me understand this. From the error message, I understand that I probably need to link a library. However, boost::throw_exception is defined in a header file with no matching library (that I can

Imagine two similar pieces of code: try { [...] } catch (myErr &err) { err.append("More info added to error..."); throw err; } and try { [...] } catch (myErr &err) { err.append("More info added to error..."); throw; } Are these effectively the same or do they differ in some subtle way? For example, does the first one cause a copy constructor to be run whereas perhaps the second reuses the same object to rethrow it? Depending on how you have arranged your exception hierarchy, re-throwing an exception by naming the exception variable in the throw statement may slice the original exception object