C++ for Scientists - Technische Universität Dresden

190 CHAPTER 6. INHERITANCE
6.4.1 Casting Between Base and Derived Classes
Casting Up
⇒ up down cast example.cpp
Casting up, i.e. from a derived to a base class, is always possible if there are no ambiguities and
can be even performed implicitly. Assume we have the following class structure: 1
struct A
{
virtual void f(){}
virtual ∼A(){}
int ma;
};
struct B : A { float mb; };
struct C : A {};
struct D : B, C {};
and the following unary functions:
void f(A a) { /∗ ... ∗/ }
void g(A& a) { /∗ ... ∗/ }
void h(A∗ a) { /∗ ... ∗/ }
An object of type B can be passed to all three funtions:
int main (int argc, char∗ argv[])
{
B b;
f(b);
g(b);
h(&b);
}
return 0 ;
In all three cases the object b is implicitly converted to an object of type A. The call of function
‘f’ is however a bit different: only b’s members within class A are copied into the function
argument and the remainder — in our example the member ‘mb’ is not accessible in f by any
means. The functions ‘g’ and ‘h’ refer to an object of type A by reference or pointer. If an
object of a derived class is passed to one of those functions the other members are in principle
still there but just hidden. One could still access them by down-casting the argument in the
function. Before we down-cast we should ask ourselves the following questions:
• How do we assure that the argument passed to function is really an object of the derived
class? For instance with extra arguments or with run-time tests.
• What can we do if the object cannot be down-casted?
• Can we write directly a function for the derived class?
• Why we do not overload the function for the base and the derived type? This is definitively
a much cleaner design and always feasible.
1 TODO: picture