Re: Question on goto with try/catch
On Nov 20, 10:48 am, TVisitor <tvisi...@gmail.com> wrote:
However, from a "does it work?" standpoint, what are the implications
of using a goto to jump out of a try? Does it leave some uncleaned up
stuff behind (i.e. on the stack), or does it work properly, however
inelegant it looks?
That does work correctly. In general:
{
TYPE var(params);
goto end;
} // var::~Type is executed here.
end:
It does not matter whether a {} block is a "try" block or not, there
is no problem. It would have been horrible if goto broke automatic
object cleanup.
That said, authors did not know how to write C++. This is not
uncommon, especially for old code, or for stubborn C people. One
should be wary of writing C in C++. Personally, seeing unwarranted C
code in cpp files makes me cringe.
The way your snippet is written, it hints that code in catch block
relies on state changes that happened in try block, e.g.
resource r = null_init();
try
{
// code code code
if (some_condition) r = get_resource();
// code code code
}
catch(something)
{
if (r.ready()) do_x();
else do_y();
}
label:
free_resource(r);
IMO, that's a very rare situation, and I bet that's not your case,
especially since you say that such code is abound.
The way this is written, that catch probably must not throw again,
otherwise resources that are supposed to be cleaned up after "label"
will leak. IOW, carefully with that catch.
Normally, one uses RAII to handle automatic cleanup when going out of
scope. Simplest possible example:
void MyClass::MyFunction()
{
TYPE* p = NULL;
try
{
p = new TYPE(params)
// code here
if(something bad happened)
goto label;
}
catch(...)
{
// exception handling here.
}
label:
delete p;
}
Using RAII, that becomes:
typedef std::auto_ptr<TYPE> PType;
void MyClass::MyFunction()
{
try
{
PType p(new TYPE(params));
// code here
if(something bad happened)
goto label;
} // TYPE* automatically deleted here through ~PType
catch(...)
{
// exception handling here.
}
}
If catch needs p (rare situation), this becomes:
void MyClass::MyFunction()
{
typedef std::auto_ptr<TYPE> PType;
PType p;
try
{
p = PType(new TYPE(params));
// code here
if(something bad happened)
goto label;
}
catch(...)
{
// exception handling here, using p if needed (watch out for NULL!).
}
} // TYPE* automatically deleted here through ~PType
Goran.
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]