Teach Yourself Borland C++ in 14 Days - portal

118 Day 4
NEW TERM
A virtual function is a function that will be automatically called if a function by that
name exists in the derived class.
For example, note that the TakeOff() function is a virtual function in the Airplane class. Refer
to Listing 4.2. Notice that TakeOff() is called by SendMessage() in response to the
MSG_TAKEOFF message. If the MilitaryPlane class did not provide its own TakeOff() function,
the base class’s TakeOff() function would be called. Because the MilitaryPlane class does
provide a TakeOff() function, that function, rather than the function in the base class, will
be called.
NEW TERM
Replacing a base class function in a derived class is called overriding the function.
In order for overriding to work, the function signature must exactly match that of the
function in the base class. In other words, the return type, function name, and parameter list
must all be the same as the base class function.
You can override a function with the intention of replacing the base class function, or you
can override a function to enhance the base class function. Take the TakeOff() function, for
example. If you wanted to completely replace what the TakeOff() function of Airplane does,
you would override it and supply whatever code you wanted:
void MilitaryPlane::TakeOff(int dir)
{
// new code goes here
}
But if you wanted your function to take the functionality of the base class and add to it, you
would first call the base class function and then add new code:
void MilitaryPlane::TakeOff(int dir)
{
Airplane::TakeOff(dir);
// new code goes here
}
By calling the base class function, you get the original functionality of the function. You could
then add code before or after the base class call to enhance the function. The scope-resolution
operator is used to tell the compiler that you are calling the TakeOff() function of the
Airplane class. Note that the TakeOff() function is in the protected section of the Airplane
class. If it were in the private section, this would not work because even a derived class cannot
access the private members of its ancestor class. By making the TakeOff() function protected,
it is hidden from the outside world but still accessible to derived classes.