Re: efficient exception handling
On Oct 15, 1:17 pm, Erik Wikstr=F6m <Erik-wikst...@telia.com> wrote:
Consider the following, an exception is thrown in a constructor. In the
catch-block you use continue to resume the execution which means that
your code will continue to run and try to perform operations on a not
fully constructed object. Not a good idea. The reason the exception was
thrown was that correct execution was no longer possible, the only
correct way of handling this is to go back a little and then deal with
the situation (by aborting, trying again, trying something different, etc=
..).
I see : Since throw is usually used as a conditional jump, the next
instruction is executed with the assumption that oposite of the
condition is true where a continue can not fix the affected data.
The solution is easy ,one must avoid a 'continue'd catch block for old
exception classes thrown by hopeless outdated algorithms that do not
consider a second chance .
A 'throw' statement can reflect the source of error instead of just
nagging:
class foo{
public:
foo()throw(foo*){
if(some_problem)
throw this;
};
};
bool fix(foo *);
try{
foo obj;
}catch(foo * what){
if (fix(what))
continue;//(*what) is valid now.
throw;//could not solve it:reporting daddy
}
The up-to-date algorithms can use a loop instead of a simple
conditional statement;So that on resume the condition of loop is
checked again (redo_loop is the statement next to throw ):
void UpToDate_algorithm(){
while(condition())//{
throw UpToDate_exception();
/* redo_loop:
};*/
};
try{
UpToDate_algorithm();
}catch(UpToDate_exception&){
UpToDate_handler();
continue;
}
We can remove the risk of undefined behavoir completely(even for old
libraries), via some minimal changes to syntax:
A try block must be allowed to omit the catch block .The 'throw' shall
unwind the stack up to the first dynamically enclosing 'try' then look
for the handler, if no handler then the default handler cleans the
stack and terminates.The 'continue' shall resume from the beginning of
the inner-most enclosing 'try':
void foo(){
class A in_foo;
foo_try:
try{
A in_foo_try;
if (condition)
throw "guarded throw";/*unwind the try
block:in_foo_try.~A(); do not touch in_foo*/
}
throw "freethrow";/*unwind stack up to bar_try:
in_foo_try.~A() ; in_foo.~A() ;
in_bar_try.~A() ;*/
};
void bar(){
bar_try:
try{
A in_bar_try;
foo();
}catch(...){
if (condition)
continue;//long goto ( free throw ? bar_try : foo_try );
}//unwind the rest of stack occupied by bar_try
}
This way we do not need explicit loops and no more than essential data
is destructed and reconstructed.
regards,
FM.