Try blocks and not catching exceptions

[Adam H. Peterson]

Hello,

I sometimes find myself writing code something like this:

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

The catch block is to do error translation if the user provided an
incorrect type, and I detect this in the dynamic_cast<>.

On the other hand, if a bad_cast exception is thrown in
do_something_co mplicated(), I don't want my catch block to catch that.
The catch block is only for catching and translating an error if it
occurs at _this_ dynamic_cast. However, I can't simply move
do_something_co mplicated() out of the try block, as that will be outside
d's scope.

I could probably get around this by turning d into a pointer and having
its declaration be outside the block, but then I end up with pointer
syntax and generally more verbose code. Also, there are cases where I'm
catching an exception from a constructor or something, where it's either
impossible or unadvisable to split the declaration and the
initialization of a variable, so the declaration really has to be inside
the try block.

What is the best way to handle this type of situation, so that I can
catch the exception I'm looking for, but not other exceptions in the
same scope that happen to be of the same type?

[Ron Natalie]

"Adam H. Peterson" <ah**@email.byu .edu> wrote in message news:bv******** ***@acs2.byu.ed u...

I could probably get around this by turning d into a pointer and having
its declaration be outside the block, but then I end up with pointer
syntax and generally more verbose code.

I don't know why it's more verbose (unless you thing -> is a lot more verbose than
..).

Derived* dp = dynamic_cast<De rived*>(&b);
if(dp) throw Base_error("An object of the wrong type...");

dp->do_something_c omplicated();

Actually looks like less code to me. Exceptions suck for errors that are
easily tested for by other means.

[lilburne]

Adam H. Peterson wrote:

Hello,

I sometimes find myself writing code something like this:

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

The catch block is to do error translation if the user provided an
incorrect type, and I detect this in the dynamic_cast<>.

If you don't know already know that b is a Derived why are you
downcasting to a reference? If you don't cast to a reference you won't
get an exception.

QUERY: Is this sort of thing exceptional programming or what?

[tom_usenet]

On Tue, 27 Jan 2004 03:39:59 -0700, "Adam H. Peterson"
<ah**@email.byu .edu> wrote:

Hello,

I sometimes find myself writing code something like this:

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

The catch block is to do error translation if the user provided an
incorrect type, and I detect this in the dynamic_cast<>.

On the other hand, if a bad_cast exception is thrown in
do_something_c omplicated(), I don't want my catch block to catch that.
The catch block is only for catching and translating an error if it
occurs at _this_ dynamic_cast. However, I can't simply move
do_something_c omplicated() out of the try block, as that will be outside
d's scope. What is the best way to handle this type of situation, so that I can
catch the exception I'm looking for, but not other exceptions in the
same scope that happen to be of the same type?

Derived& d = f(b);
d.do_something_ complicated();

Where f has the try/catch block. You could create a generic version of
f:

template <class Derived, class Base, class ErrorHandler>
Derived& checked_dynamic _cast(Base& b, ErrorHandler eh)
{
try
{
return dynamic_cast<De rived&>(b);
}
catch(std::bad_ cast const&)
{
return eh(); //may throw, return a default, or whatever
}
}

Derived& d = checked_dynamic _cast<Derived&> (b, base_error_thro wer());
or similar.

Tom

C++ FAQ: http://www.parashift.com/c++-faq-lite/
C FAQ: http://www.eskimo.com/~scs/C-faq/top.html

[Ron Natalie]

"tom_usenet " <to********@hot mail.com> wrote in message news:4h******** *************** *********@4ax.c om...

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

Derived& d = f(b);
d.do_something_ complicated();

Where f has the try/catch block. You could create a generic version of
f:

try { dynamic_cast<De rived&>(b); } castch (std::basd_cast ) { throw Base_error("... "); } // probe for mines
Derived& d = dynamic_cast<De rived&>(b);
d.do_something_ complicated();

[Martijn Lievaart]

On Tue, 27 Jan 2004 03:39:59 -0700, Adam H. Peterson wrote:

Hello,

I sometimes find myself writing code something like this:

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

The catch block is to do error translation if the user provided an
incorrect type, and I detect this in the dynamic_cast<>.

On the other hand, if a bad_cast exception is thrown in
do_something_co mplicated(), I don't want my catch block to catch that.
The catch block is only for catching and translating an error if it
occurs at _this_ dynamic_cast. However, I can't simply move
do_something_co mplicated() out of the try block, as that will be outside
d's scope.

I could probably get around this by turning d into a pointer and having
its declaration be outside the block, but then I end up with pointer
syntax and generally more verbose code. Also, there are cases where I'm
catching an exception from a constructor or something, where it's either
impossible or unadvisable to split the declaration and the
initialization of a variable, so the declaration really has to be inside
the try block.

Read Rons excelent answer first. Now still want to do this?

Derived *p=dynamic_cast <Derived&>(b) ;
if (!p)
throw Base_error("An object of incorrect type was given....");
Derived &d=*p;
d.do_something_ complicated();
// etc....

Or follow Toms advice and wrap this in a function:

Derived &down_cast(B ase &b)
{
Derived *p=dynamic_cast <Derived&>(b) ;
if (!p)
throw Base_error("An object of incorrect type was given....");
return *p;
}

Derived &d=down_cast(b) ;
d.do_something_ complicated();

HTH,
M4

[Jeff Schwab]

Martijn Lievaart wrote:

On Tue, 27 Jan 2004 03:39:59 -0700, Adam H. Peterson wrote:

Hello,

I sometimes find myself writing code something like this:

try {
Derived &d=dynamic_cast <Derived&>(b) ;
d.do_something_ complicated();
// etc....
} catch (std::bad_cast) {
throw Base_error("An object of incorrect type was given....");
}

The catch block is to do error translation if the user provided an
incorrect type, and I detect this in the dynamic_cast<>.

On the other hand, if a bad_cast exception is thrown in
do_something_ complicated(), I don't want my catch block to catch that.
The catch block is only for catching and translating an error if it
occurs at _this_ dynamic_cast. However, I can't simply move
do_something_ complicated() out of the try block, as that will be outside
d's scope.

I could probably get around this by turning d into a pointer and having
its declaration be outside the block, but then I end up with pointer
syntax and generally more verbose code. Also, there are cases where I'm
catching an exception from a constructor or something, where it's either
impossible or unadvisable to split the declaration and the
initializatio n of a variable, so the declaration really has to be inside
the try block.

Read Rons excelent answer first. Now still want to do this?

Derived *p=dynamic_cast <Derived&>(b) ;

/* ITYM */ Derived *p=dynamic_cast <Derived*>(b) ;
if (!p)
throw Base_error("An object of incorrect type was given....");
Derived &d=*p;
d.do_something_ complicated();
// etc....

Or follow Toms advice and wrap this in a function:

Derived &down_cast(B ase &b)
{
Derived *p=dynamic_cast <Derived&>(b) ;
/* ITYM */ Derived *p=dynamic_cast <Derived*>(b) ;
if (!p)
throw Base_error("An object of incorrect type was given....");
return *p;
}

Derived &d=down_cast(b) ;
d.do_something_ complicated();

HTH,
M4

[Martijn Lievaart]

On Tue, 27 Jan 2004 08:04:11 -0500, Jeff Schwab wrote:

/* ITYM */ Derived *p=dynamic_cast <Derived*>(b) ;
/* ITYM */ Derived *p=dynamic_cast <Derived*>(b) ;

Auch. Yes.

M4

[Andrey Tarasevich]

Ron Natalie wrote:

"Adam H. Peterson" <ah**@email.byu .edu> wrote in message news:bv******** ***@acs2.byu.ed u...

I could probably get around this by turning d into a pointer and having
its declaration be outside the block, but then I end up with pointer
syntax and generally more verbose code.
I don't know why it's more verbose (unless you thing -> is a lot more verbose than
.).

Derived* dp = dynamic_cast<De rived*>(&b);
if(dp) throw Base_error("An object of the wrong type...");

'if (!dp) ...' ?
dp->do_something_c omplicated();

Actually looks like less code to me. Exceptions suck for errors that are
easily tested for by other means.

--
Best regards,
Andrey Tarasevich