C++ Primer Plus

• The BrassPlus class adds three new private data members and three new public member functions to the Brass class.

• Both the Brass class and the BrassPlus class declare the ViewAcct() and Withdraw() methods; these are the methods that will behave differently for a BrassPlus object than they do with a Brass object.

• The Brass class uses the new keyword virtual in declaring ViewAcct() and Withdraw(). These methods are now termed virtual methods.

• The Brass class also declares a virtual destructor, even though the destructor does nothing.

The first point in the list is nothing new. The RatedPlayer class did something similar when it added a new data member and two new methods to the TableTennisPlayer class.

The second point in the list is how the declarations specify that methods are to behave differently for the derived class. The two ViewAcct() prototypes indicate that there will be two separate method definitions. The qualified name for the base-class version is Brass::ViewAcct(), and the qualified name for the derived-class version is BrassPlus::ViewAcct(). A program will use the object type to determine which version to use:

Brass dom("Dominic Banker", 11224, 4183.45);

BrassPlus dot("Dorothy Banker", 12118, 2592.00);

dom.ViewAcct();      // use Brass::ViewAcct()

dot.ViewAcct();      // use BrassPlus::ViewAcct()

Similarly, there will be two versions of Withdraw(): one that’s used by Brass objects and one that’s used by BrassPlus objects. Methods that behave the same for both classes, such as Deposit() and Balance(), are declared only in the base class.

The third point (the use of virtual) is more involved than the first two points. It determines which method is used if the method is invoked by a reference or a pointer instead of by an object. If you don’t use the keyword virtual, the program chooses a method based on the reference type or pointer type. If you do use the keyword virtual, the program chooses a method based on the type of object the reference or pointer refers to. Here is how a program behaves if ViewAcct() is not virtual:

// behavior with non-virtual ViewAcct()

// method chosen according to reference type

Brass dom("Dominic Banker", 11224, 4183.45);

BrassPlus dot("Dorothy Banker", 12118, 2592.00);

Brass & b1_ref = dom;

Brass & b2_ref = dot;

b1_ref.ViewAcct();      // use Brass::ViewAcct()

b2_ref.ViewAcct();      // use Brass::ViewAcct()

The reference variables are type Brass, so Brass::ViewAccount() is chosen. Using pointers to Brass instead of references results in similar behavior.

In contrast, here is the behavior if ViewAcct() is virtual:

// behavior with virtual ViewAcct()

// method chosen according to object type

Brass dom("Dominic Banker", 11224, 4183.45);

BrassPlus dot("Dorothy Banker", 12118, 2592.00);

Brass & b1_ref = dom;

Brass & b2_ref = dot;

b1_ref.ViewAcct();      // use Brass::ViewAcct()

b2_ref.ViewAcct();      // use BrassPlus::ViewAcct()

In this case, both references are type Brass, but b2_ref refers to a BrassPlus object, so BrassPlus::ViewAcct() is used for it. Using pointers to Brass instead of references results in similar behavior.

It turns out, as you’ll see in a bit, that this behavior of virtual functions is very handy. Therefore, it is the common practice to declare as virtual in the base class those methods that might be redefined in a derived class. When a method is declared virtual in a base class, it is automatically virtual in the derived class, but it is a good idea to document which functions are virtual by using the keyword virtual in the derived class declarations, too.

The fourth point is that the base class declares a virtual destructor. This is to make sure that the correct sequence of destructors is called when a derived object is destroyed. We’ll discuss this point in more detail later in this chapter.

Note

If you redefine a base-class method in a derived class, the usual practice is to declare the base-class method as virtual. This makes the program choose the method version based on object type instead of the type of a reference or pointer. It’s also the usual practice to declare a virtual destructor for the base class.

Class Implementations

The next step is to prepare the class implementation. Part of this has been done already by the inline function definitions in the header file. Listing 13.8 provides the remaining method definitions. Note that the keyword virtual is used just in the method prototypes in the class declaration, not in the method definitions in Listing 13.8.

Listing 13.8. brass.cpp

// brass.cpp -- bank account class methods

#include

#include "brass.h"

using std::cout;

using std::endl;

using std::string;

// formatting stuff

typedef std::ios_base::fmtflags format;

typedef std::streamsize precis;

format setFormat();

void restore(format f, precis p);

// Brass methods

Brass::Brass(const string & s, long an, double bal)

{

    fullName = s;

    acctNum = an;

    balance = bal;

}

void Brass::Deposit(double amt)

{

    if (amt < 0)