CSE 143 R
R-1
2/4/00
CSE 143
Dynamic Dispatch and Virtual
Functions
[Chapter 8 pp.354-370]
R-2
2/4/00
Substituting Derived Classes
•Recall that an instance of a
derived class can always
be substituted for an
instance of a base class
•Derived class g uaranteed to
have (at least) t he same data
and interface as base class
•But you may not get the
behaviour you want!
//client function (not a method)
void printPoint( Point pt )
{
pt.print( cout );
//the question: which print?
}
Point p( 1.0, 9.0 );
ColorPoint cp( 6.0, 7.0, red );
printPoint( p );
p = cp; //information lost
printPoint( p );
printPoint( cp );
R-3
2/4/00
Pointers And Inheritance
•You can also substitute a
pointer to a derived class
for a pointer to a base
class
•There’s still that guarantee
about data and i nterface
•Also holds for reference types
•No information disappears!!
•Unfortunately, we still have
the same problems…
//client function
void printPoint( Point *ptr )
{
ofstream ofs( "point.out" );
ptr->print( ofs );
ofs.close();
}
Point *pptr = new Point( 1.0, 9.0 );
ColorPoint *cpptr =
new ColorPoint( 6.0, 7.0, red );
printPoint( pptr );
printPoint( cpptr );
pptr = cpptr;
printPoint ( pptr);
R-4
2/4/00
Static And Dynamic Types
•In C++, every variable has a static and a dynamic
type
•Static type is declared type of variabl e
Every variable has a single static type that never changes
•Dynamic type is type of object the variable ac tually
contains or refers to
Dynamic type can change during the program!
•Up to now, these have always been identical
•But not any more!
Point *myPointPointer = new ColorPoint( 3.14, 2.78, green );
R-5
2/4/00
"Dispatch"
•"Dispatching" is the act of deciding which piece of
code to execute when a method is called
•Static dispatch means that the decision is made
statically, i.e. at compile time
•Decision made based on static (declared) type of
receiver
Point *myPointPointer = new ColorPoint( 3.14, 2.78, green );
myPointPointer->print(cout);
// myPointPointer is a Point*, so call Point::print
R-6
2/4/00
Dynamic Dispatch
•C++ has a mechanism for declaring individual
methods as dynamically dispatched
•If an overriding function exists, call it
•The decision is made at run-time
•Sometimes called "late binding".
•In base class, label the function with virtual
keyword
•Overriding versions in subclass es don’t need the
virtual keyword
but please use the keyword anyway for better style
