y:
a base class called
Shape
and derived classes called
Circle,
Square,
and
Triangle.
In the base class, make a virtual function called
draw( ),
and redefine this in the derived classes. Create an array of pointers to
Shape
objects you create on the heap (and thus perform upcasting of the pointers),
and call
draw( )
through the base-class pointers, to verify the behavior of the virtual
function. If your debugger supports it, single-step through the example.
Modify
Exercise 1 so
draw( )
is a pure virtual function. Try creating an object of type
Shape.Try
to call the pure virtual function inside the constructor and see what happens.
Give
draw( )
a definition.
Write
a small program to show the difference between calling a virtual function
inside a normal member function and calling a virtual function inside a
constructor. The program should prove that the two calls produce different
results.
In
Early.cpp,
how can you tell whether the compiler makes the call using early or late
binding? Determine the case for your own compiler.
(Intermediate)
Create a base
class
X
with no members and no constructor, but with a
virtual
function. Create a
class
Y
that
inherits from
X,
but without an explicit constructor. Generate assembly code and examine it to
determine if a constructor is created and called for
X,
and if so, what the code does. Explain what you discover.
X
has no default constructor, so why doesn’t the compiler complain?
(Intermediate)
Modify exercise 5 so each constructor calls a virtual function.
Generate
assembly code.
Determine
where the VPTR is being assigned inside each constructor. Is the virtual
mechanism being used by your compiler inside the constructor? Establish why the
local version of the function is still being called.
(Advanced)
If function calls to an object passed by value
weren’t
early-bound, a virtual call might access parts that didn’t exist. Is this
possible? Write some code to force a virtual call, and see if this causes a
crash. To explain the behavior, examine what happens when you pass an object by
value.
(Advanced) Find out exactly how much more time is required for a virtual
function call by going to your processor’s assembly-language information
or other technical manual and finding out the number of clock states required
for a simple call versus the number required for the virtual function
instructions.