Re: Why does the C++ spec. prohibit downcasting through non-public inheritance?
"Alf P. Steinbach" <alfps@start.no> writes:
Example of how the dynamic failure of dynamic_cast corresponds to
compilation failure for static_cast:
<code>
class Base
{
public:
virtual ~Base() {}
};
class Derived: protected Base
{
public:
void foo( Base& o )
{
static_cast<Derived&>( o );
}
};
void bar( Base& o )
{
static_cast<Derived&>( o ); // Nope.
}
int main() {}
</code>
For static_cast this protects you against using knowledge of the
derivation from Base to treat Derived objects as Base objects or vice
versa. The protected derivation says that it's an implementation
detail, and e.g. in the future might be replaced by a Base* data
member, or a different class, whatever.
If the static_cast labeled "Nope" above is replaced with dynamic_cast,
then it compiles.
But it then compiles almost no matter which class is specified instead
of Derived&, e.g. a completely unrelated class FooBar& -- and this
is perhaps what baffled the OP?
I wonder if even this captures the OP's original question.
edam <edam@waxworlds.org> writes:
Given this, I cannot understand why a *member function* of the derived
class or of a friend class can not downcast a protected base class
reference to a derived class reference specifically because we are
using protected inheritance. Surely, if the intention of protected and
private inheritance is to protect and make private the implementation
of a class, you shouldn't be hiding that implementation from the class
its self and its friends! [my emphasis]
Reading this, the key question appears to be specifically about the
runtime failure of attempting a dynamic_cast from base reference to
derived reference *in a member function of the derived class*, as in:
19:30:32 Paul Bibbings@JIJOU
/cygdrive/d/CPPProjects/CLCPP $cat dyn_cast_ex.cpp
// dyn_cast_ex.cpp
#include <iostream>
#include <typeinfo>
class Base
{
public:
virtual ~Base() {}
};
class Derived: protected Base
{
public:
void foo( ) // member function
{
Base& b = dynamic_cast<Base&>( *this ); // OK
try {
Derived& d = dynamic_cast<Derived&>( b ); // why not OK here?
} catch (std::bad_cast) {
std::cout << "Oopsie!\n";
}
}
};
int main() {
Derived d;
d.foo( );
}
19:30:35 Paul Bibbings@JIJOU
/cygdrive/d/CPPProjects/CLCPP $g++ -o dyn_cast_ex dyn_cast_ex.cpp
19:30:54 Paul Bibbings@JIJOU
/cygdrive/d/CPPProjects/CLCPP $./dyn_cast_ex
Oopsie!
I have to be honest and say that, after some considerable searching, I
have failed in locating a specific reference (or chain of references) in
the standard that specifically mandates against this, *in this specific
instance*.
Regards
Paul Bibbings