Re: Exception specification and reference types
On Nov 16, 9:14 am, andreytarasev...@hotmail.com (Andrey Tarasevich)
wrote:
struct A {
struct AA {};
virtual void foo() throw(AA&);
};
struct B : A {
struct BB : AA {};
virtual void foo() throw(AA&, BB&);
};
According to my understanding, using reference types in the exception
specification should be basically equivalent to using corresponding
non-reference types. Also, when it comes to determining whether the
specification of a virtual function is extended in the derived class, reference
types could be thought of as corresponding pointer types.
But a reference type is not a pointer type - so the rules that apply
to pointer types do not automatically extend to reference types.
However, Comeau online refuses to compile the second example, complaining that
'B::foo's exception specification is more loose than that of 'A::foo'.
There are basically three types of exception specifications (involving
base and derived classes) to consider. And the question in each case
is whether a base claas exception specification "matches" a thrown
exception of a derived type. (if it does, then adding the derived type
to the exception specification would be legal - since the derived
type was already a match).
So, the three questions are:
1. Does an AA exception specification match a BB type exception?
2. Does " AA* " " " " BB* " " ?
3. Does " AA& " " " " BB& " " ?
The answers are:
#1. Yes - by the second bullet point in ?15.3/3 : AA is an
unambiguous base class of BB.
#2 Yes - by the third bullet point: BB* converts to AA* implicitly
#3. No. The first two bullets do not applyy because AA& is neither
the same type as - nor a base class of - BB& (just as AA* is not a
base class of BB*). And since neither type is a pointer type, the
third bullet point does not apply either - and there are no other
bullet points left by which an AA& exception specification would match
a BB& exception object.
Note that this conclusion does not mean that an AA& exception
specification prohibits BB& exceptions from being thrown. Because an
instance of a derived class is also an instance of its base class, a
BB& object may be thrown from a function with an AA& exception
specification - even if the AA& exception specification does not
"match" a BB& exception object.
Greg
---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.comeaucomputing.com/csc/faq.html ]