Chapter 20: Inheriting a Class 267

Destructing a subclass

Following the rule that destructors are invoked in the reverse order of the constructors, the destructor for GraduateStudent is given control first. After it’s given its last full measure of devotion, control passes to the destructor for Advisor and then to the destructor for Student. If Student were based on a class Person, the destructor for Person would get control after Student.

This is logical. The blob of memory is first converted to a Student object. Only then is it the job of the GraduateStudent constructor to transform this simple Student into a GraduateStudent. The destructor simply reverses the process.

Having a HAS_A Relationship

Notice that the class GraduateStudent includes the members of class Student and Advisor, but in a different way. By defining a data member of class Advisor, you know that a Student has all the data members of an Advisor within it; however you can’t say that a GraduateStudent is an

Advisor — instead you say that a GraduateStudent HAS_A Advisor. What’s the difference between this and inheritance?

Use a car as an example. You could logically define a car as being a subclass of vehicle, so it inherits the properties of other vehicles. At the same time, a car has a motor. If you buy a car, you can logically assume that you are buying a motor as well. (Unless you go to the used-car lot where I got my last junk heap.)

If friends ask you to show up at a rally on Saturday with your vehicle of choice and you go in your car, they can’t complain (even if someone else shows up on a bicycle) because a car IS_A vehicle. But, if you appear on foot carrying a motor, your friends will have reason to laugh at you because a motor is not a vehicle. A motor is missing certain critical properties that vehicles share — such as electric clocks that don’t work.

From a programming standpoint, the HAS_A relationship is just as straight­ forward. Consider the following:

class Vehicle {}; class Motor {};

class Car : public Vehicle

{

public:

Motor motor;

};

268 Part IV: Inheritance

void VehicleFn(Vehicle& v); void MotorFn(Motor& m);

int main(int nNumberofArgs, char* pszArgs[])

{

Car car;
VehicleFn(car);	// this is allowed
MotorFn(car);	// this is not allowed

MotorFn(car.motor);// this is, however return 0;

}

The call VehicleFn(c) is allowed because car IS_A vehicle. The call MotorFn(car) is not because car is not a Motor, even though it contains a Motor. If the intention was to pass the Motor portion of c to the function, this must be expressed explicitly, as in the call MotorFn(car.motor).

Chapter 21

Examining Virtual Member Functions: Are They for Real?

In This Chapter

Discovering how polymorphism (a.k.a. late binding) works

Finding out how safe polymorphic nachos are

Overriding member functions in a subclass

Checking out special considerations with polymorphism

The number and type of a function’s arguments are included in its full, or extended, name. This enables you to give two functions the same name as

long as the extended name is different:

void someFn(int); void someFn(char*);

void someFn(char*, double);

In all three cases the short name for these functions is someFn() (hey! this is some fun). The extended names for all three differ: someFn(int) versus someFn(char*), and so on. C++ is left to figure out which function is meant by the arguments during the call.

The return type is not part of the extended name, so you can’t have two func­ tions with the same extended name that differ only in the type of object they return.

Member functions can be overloaded. The number of arguments, the type of arguments and the class name are all part of the extended name.

Inheritance introduces a whole new wrinkle, however. What if a function in a base class has the same name as a function in the subclass? Consider, for example, the following simple code snippet:

270 Part IV: Inheritance

class Student

{

public:

float calcTuition();

};

class GraduateStudent : public Student

{

public:

float calcTuition();

};

int main(int argcs, char* pArgs[])

{

Student s; GraduateStudent gs;

s.calcTuition(); // calls Student::calcTuition() gs.calcTuition();// calls GraduateStudent::calcTuition() return 0;

}

As with any overloading situation, when the programmer refers to calcTuition(), C++ has to decide which calcTuition() is intended. Obviously, if the two functions differed in the type of arguments, there’s no problem. Even if the arguments were the same, the class name should be suf­ ficient to resolve the call, and this example is no different. The call s.calcTuition() refers to Student::calcTuition() because s is declared locally as a Student, whereas gs.calcTuition() refers to

GraduateStudent::calcTuition().

But what if the exact class of the object can’t be determined at compile time? To demonstrate how this can occur, change the preceding program in a seem­ ingly trivial way:

//

//OverloadOverride - demonstrate when a function is

//	declare-time overloaded vs. runtime
//	overridden
//
#include <cstdio>
#include <cstdlib>
#include <iostream>
using namespace std;

class Student

{

public:

float calcTuition()

{

cout << “We’re in Student::calcTuition” << endl; return 0;

}

};

Chapter 21: Examining Virtual Member Functions: Are They for Real? 271

class GraduateStudent : public Student

{

public:

float calcTuition()

{

cout << “We’re in GraduateStudent::calcTuition” << endl;

return 0;

}

};

void fn(Student& x)

{

x.calcTuition(); // to which calcTuition() does // this refer?

}

int main(int nNumberofArgs, char* pszArgs[])

{

//pass a base class object to function

//(to match the declaration)

Student s; fn(s);

//pass a specialization of the base class instead GraduateStudent gs;

fn(gs);

//wait until user is ready before terminating program

//to allow the user to see the program results system(“PAUSE”);

return 0;

}

This program generates the following output:

We’re in Student::calcTuition

We’re in Student::calcTuition

Press any key to continue . . .

Instead of calling calcTuition() directly, the call is now made through an intermediate function, fn(). Depending on how fn() is called, x can be a

Student or a GraduateStudent. A GraduateStudent IS_A Student.

Refer to Chapter 20 if you don’t remember why a GraduateStudent IS_A

Student.

The argument x passed to fn() is declared to be a reference to Student.

Passing an object by reference can be a lot more efficient than passing it by value. See Chapter 18 for a treatise on making copies of objects.