P26-c++类继承-03is-a继承关系，虚函数详解

1. 继承：is- a 关系

派生类和基类之间的特殊关系是基于C++继承的底层模型的。
实际上,C+有3种继承方式:公有继承、保护继承和私有继承。公有继承是最常用的方式,它建立一种is-a关系,即派生类对象也是一个基类对象,可以对基类对象执行的任何操作,也可以对派生类对象执行。
例如,假设有一个 Fruit类,可以保存水果的重量和热量。因为香蕉是一种特殊的水果,所以可以从Fru类派生出 Banana类。新类将继承原始类的所有数据成员,因此, Banana对象将包含表示香蕉重量和热量的成员。新的 Banana类还添加了专门用于香蕉的成员,这些成员通常不用于水果,例如 Banana Institute Peel Index(香蕉机构果皮索引)。
因为派生类可以添加特性,所以,将这种关系称为is- a-kind-of(是一种)关系可能更准确,但是通常使用术语is-a。
为阐明is-a关系,来看一些与该模型不符的例子。公有继承不建立has-a关系。例如,午餐可能包括水果,但通常午餐并不是水果。所以,不能通过从Fruit类派生出 Lunch类来在午餐中添加水果。在午餐中加入水果的正确方法是将其作为一种has-a关系:午餐有水果。正如将在第14章介绍的,最容易的建模方式是,将 Fruit对象作为 Lunch类的数据成员(参见图13.3)。

公有继承不能建立is-like-a关系,也就是说,它不采用明喻。人们通常说律师就像鲨鱼,但律师并不是鲨鱼。例如,鲨鱼可以在水下生活。所以,不应从 Shark类派生出 Lawyer类。继承可以在基类的基础上添加属性,但不能删除基类的属性。在有些情况下,可以设计一个包含共有特征的类,然后以is-a或has-a关系,在这个类的基础上定义相关的类

公有继承不建立is- implemented-as-a(作为……来实现)关系。例如,可以使用数组来实现栈,但从Array类派生出 Stack类是不合适的,因为栈不是数组。例如,数组索引不是栈的属性。另外,可以以其他方式实现栈,如链表。正确的方法是,通过让栈包含一个私有Amay对象成员来隐疲数组实现。
公有继承不建立 uses-a关系。例如,计算机可以使用激光打印机,但从 Computer类派生出 Printer类(或反过来)是没有意义的。然而,可以使用友元函数或类来处理 Printer对象和 Computer对象之间的通信。

在C++中,完全可以使用公有继承来建立has-a、 is-implemented-as-a或uses-a关系;然而,这样做通常会导致编程方面的问题。因此,还是坚持使用is-a关系吧。

2. 多态公有继承

RatedPlayer继承示例很简单。派生类对象使用基类的方法,而未做任何修改。然而,可能会遇到这样的情况,即希望同一个方法在派生类和基类中的行为是不同的。
换句话来说,方法的行为应取决于调用该方法的对象。这种较复杂的行为称为多态具有多种形态,即同一个方法的行为随上下文而异。
有两种重要的机制可用于实现多态公有继承：

• 在派生类中重新定义基类的方法
• 使用虚方法

现在来看另一个例子。由于 Webtown俱乐部的工作经历,您成了 Pontoon银行的首席程序员。银行要求您完成的第一项工作是开发两个类。一个类用于表示基本支票账户- Brass Account,另一个类用于表示代表 Brass Plus支票账户,它添加了透支保护特性。也就是说,如果用户签出一张超出其存款余额的支票一一但是超出的数额并不是很大,银行将支付这张支票,对超出的部分收取额外的费用,并追加罚款。
可以根据要保存的数据以及允许执行的操作来确定这两种账户的特征

下面是用于 Brass Account支票账户的信息:

• 客户姓名
• 账号;
• 当前结余

下面是可以执行的操作：

• 创建账户;
• 存款
• 取款;
• 显示账户信息
  Pontoon银行希望 Brass Plus支票账户包含 Brass Account的所有信息及如下信息:
• 透支上限
• 透支贷款利率;
• 当前的透支总额
  不需要新增操作,但有两种操作的实现不同:
• 对于取款操作,必须考虑透支保护
• 显示操作必须显示 Brass Plus账户的其他信息

假设将第一个类命名为 Brass,第二个类为 BrassPlus。应从 Brass公有派生出 BrassPlus吗?要回答这 个问题,必须先回答另一个问题: BrassPlus类是否满足is-a条件?
当然满足。对于 Brass对象是正确的事情,对于 BrassPlus对象也是正确的。它们都将保存客户姓名、账号以及结余。使用这两个类都可以存款、 取款和显示账户信息。请注意,is-a关系通常是不可逆的。也就是说,水果不是香蕉:同样, Brass 对象不 具备 BrassPlus对象的所有功能。

3. 开发 Brass类和 BrassPlus类

Brass Account类的信息很简单,但是银行没有告诉您有关透支系统的细节。当您向友好的 Pontoon银行代表询问时,他提供了如下信息:

• Brass Plus账户限制了客户的透支款额。默认为500元,但有些客户的限额可能不同;
• 银行可以修改客户的透支限额
• Brass Plus账户对贷款收取利息。默认为11.125%,但有些客户的利率可能不同
• 银行可以修改客户的利率
• 账户记录客户所欠银行的金额(透支数额加利息)。用户不能通过常规存款或从其他账户转账的方式偿付,而必须以现金的方式交给特定的银行工作人员。如果有必要,工作人员可以找到该客户。欠款偿还后,欠款金额将归零。

最后一种特性是银行出于做生意的考虑而采用的,这种方法有它有利的一面一一使编程更简单。
上述列表表明,新的类需要构造函数,而且构造函数应提供账户信息,设置透支上限(默认为500元)和利率(默认为11.125%)。另外,还应有重新设置透支限额、利率和当前欠款的方法。要添加到 Brass 类中的就是这些,这将在 BrassPlus类声明中声明。
有关这两个类的信息声明,类声明应类似于程序清单13.7
程序清单13.7 brass.h

/*
	author:梦悦foundation
	公众号:梦悦foundation
	可以在公众号获得源码和详细的图文笔记
*/
	// brass.h	-- bank account classes
#ifndef BRASS_H_
#define BRASS_H_
#include <string>
// Brass Account Class
class Brass
{
    
    
private:
	std::string fullName;
	long acctNum;
	double balance;
public:
	Brass(const std::string & s = "Nullbody", long an = -1,
				double bal = 0.0);
	void Deposit(double amt);
	virtual void Withdraw(double amt);
	double Balance() const;
	virtual void ViewAcct() const;
	virtual ~Brass() {
    
    }
};

//Brass Plus Account Class
class BrassPlus : public Brass
{
    
    
private:
	double maxLoan;
	double rate;
	double owesBank;
public:
	BrassPlus(const std::string & s = "Nullbody", long an = -1,
			double bal = 0.0, double ml = 500,
			double r = 0.11125);
	BrassPlus(const Brass & ba, double ml = 500, 
								double r = 0.11125);
	virtual void ViewAcct()const;
	virtual void Withdraw(double amt);
	void ResetMax(double m) {
    
     maxLoan = m; }
	void ResetRate(double r) {
    
     rate = r; };
	void ResetOwes() {
    
     owesBank = 0; }
};

#endif

对于程序清单13.7,需要说明的有下面几点:

• BrassPlus类在 Brass 类的基础上添加了3个私有数据成员和3个公有成员函数
• Brass类和 BrassPlus类都声明了 ViewAcct()和 Withdraw()方法,但 BrassPlus对象和 Brass对象的这些方法的行为是不同的
• Brass类在声明 ViewAcct()和 Withdraw()时使用了新关键字 virtual这些方法被称为虚方法( virtual method)
• Brass类还声明了一个虚析构函数,虽然该析构函数不执行任何操作。

第一点没有什么新鲜的。 RatedPlayer类在 TableTennisPlayer类的基础上添加新数据成员和2个新方法的方式与此类似。

第二点介绍了声明如何指出方法在派生类的行为的不同。两个 ViewAcct()原型表明将有2个独立的方法定义。基类版本的限定名为 Brass::ViewAcct(),派生类版本的限定名为BrasPlus::ViewAcct()。
程序将使用对象类型来确定使用哪个版本:

Brass dom("Dominic Banker", 11224, 4183.45);
BrassPlus dot("Dorothy Banker", 12118, 2592.00);
dom.ViewAcct(); //use Brass::ViewAcct()
dot.ViewAcct() //use BrassPlus::ViewAcct()

同样, Withdraw()也有2个版本,一个供 Brass 对象使用,另一个供BrassPlus对象使用。对于在两个类中行为相同的方法(如 Deposit()和 Balance(),则只在基类中声明。

第三点(使用 virtual)比前两点要复杂。如果方法是通过引用或指针而不是对象调用的,它将确定使用哪一种方法。
如果没有使用关键字 virtual,程序将根据引用类型或指针类型选择方法;如果使用了 virtual,程序将根据引用或指针指向的对象的类型来选择方法。

如果 ViewaAcct()不是虚的,则程序的行为如下:， 引用本身是什么类型就调用谁的方法

//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 & bl_ref = dom;
Brass & b2_ref = dot;
b1_ref.ViewAcct(); //use Brass::ViewAcct()
b2_ref.ViewAcct(); //use Brass::ViewAcct()

引用变量的类型为 Brass,所以选择了Bras::Viewaccount()。使用 Brass指针代替引用时,行为将与此类似
如果 ViewAcct()是虚的,则行为如下: 取决于实际指向的对象的类型而调用相应的方法！

//behavior with virtual ViewAcct()
// method chosen according to obiect type
Brass dom("Dominic Bankerm", 11224, 4183.45);
BrassPlus dot("Dorothy Banker", 12118, 2592. 00);
Brass & bl_ref = dom;
Brass & b2_ref = dot:
b1_ref.ViewAcct(); // use Brass::ViewAcct()
b2_ref.ViewAcct(); // use BrassPlus::ViewAcct()

这里两个引用的类型都是 Brass, 但b2_ref引用的是一个 BrassPlus对象,所以使用的是BrassPlus::ViewAcct()。使用 Brass指针代替引用时,行为将类似。

稍后您将看到,虚函数的这种行为非常方便。
因此,经常在基类中将派生类会重新定义的方法声明为虚方法。方法在基类中被声明为虚的后,它在派生类中将自动成为虚方法。然而,在派生类声明中使用关键字 virtual来指出哪些函数是虚函数也不失为一个好办法。

第四点是,基类声明了一个虚析构函数。这样做是为了确保释放派生对象时,按正确的顺序调用析构函数。本章后面将详细介绍这个问题。

注意:如果要在派生类中重新定义基类的方法,通常应将基类方法声明为虚的。这样,程序将根据对象类型而不是引用或指针的类型来选择方法版本。为基类声明一个虚析构函数也是一种惯例。

4.类实现

接下来需要实现类,其中的部分工作已由头文件中的内联函数定义完成了。程序清单13.8列出了其他方法的定义。注意,关键字 virtual只用于类声明的方法原型中,而没有用于程序清单13.8的方法定义中。
程序清单13.8 brass.cpp

在这里插入代码片

介绍程序清单13.8的具体细节(如一些方法的格式化处理)之前,先来看一下与继承直接相关的方面。

记住,派生类并不能直接访问基类的私有数据,而必须使用基类的公有方法才能访问这些数据。访问的方式取决于方法。构造函数使用一种技术,而其他成员函数使用另一种技术。

派生类构造函数在初始化基类私有数据时,采用的是成员初始化列表语法。 RatedPlayer类构造函数和BrassPlus构造函数都使用这种技术

// BrassPlus Methods
BrassPlus::BrassPlus(const string & s, long an, double bal,
		   double ml, double r) : Brass(s, an, bal)
{
    
    
	maxLoan = ml;
	owesBank = 0.0;
	rate = r;
}

BrassPlus::BrassPlus(const Brass & ba, double ml, double r)
		   : Brass(ba)	 // uses implicit copy constructor
{
    
    
	maxLoan = ml;
	owesBank = 0.0;
	rate = r;
}

这几个构造函数都使用成员初始化列表语法,将基类信息传递给基类构造函数,然后使用构造函数体初始化 BrassPlus类新增的数据项。

非构造函数不能使用成员初始化列表语法,但派生类方法可以调用公有的基类方法。例如, BrassPlus 版本的 ViewAcct()核心内容如下:

// redefine how ViewAcct() works
void BrassPlus::ViewAcct() const
{
    
    
	// set up ###.## format
	format initialState = setFormat();
	precis prec = cout.precision(2);

	Brass::ViewAcct();	 // display base portion
	cout << "Maximum loan: $" << maxLoan << endl;
	cout << "Owed to bank: $" << owesBank << endl;
	cout.precision(3);	// ###.### format
	cout << "Loan Rate: " << 100 * rate << "%\n";
	restore(initialState, prec); 
}

换句话说, BrassPlus::ViewAcct()显示新增的 BrassPlus数据成员,并调用基类方法Brass::ViewAcct()来显示基类数据成员。在派生类方法中,标准技术是使用作用域解析运算符来调用基类方法。
代码必须使用作用域解析运算符。假如这样编写代码

// redefine erroneously how ViewAcct() works
void BrassPlus::ViewAcct () const
{
    
    
	viewacct(); // oops! recursive call
}

如果代码没有使用作用域解析运算符,编译器将认为 ViewAcct()是 BrassPlus::ViewAcct(),这将创建一个不会终止的递归函数——这可不好。

接下来看 BrassPlus::Withdraw()方法。如果客户提取的金额超过了结余,该方法将安排贷款。它可以使用 Brass::Withdraw()来访问 balance成员,但如果取款金额超过了结余,Brass::Withdraw()将发出一个错误消息。
这种实现使用 Deposit()方法进行放贷,然后在得到了足够的结余后调用 Brass::Withdraw,从而避免了错误消息:

// redefine how Withdraw() works
void BrassPlus::Withdraw(double amt)
{
    
    
	// set up ###.## format
	format initialState = setFormat();
	precis prec = cout.precision(2);

	double bal = Balance();
	if (amt <= bal)
		Brass::Withdraw(amt);
	else if ( amt <= bal + maxLoan - owesBank)
	{
    
    
		double advance = amt - bal;
		owesBank += advance * (1.0 + rate);
		cout << "Bank advance: $" << advance << endl;
		cout << "Finance charge: $" << advance * rate << endl;
		Deposit(advance);
		Brass::Withdraw(amt);
	}
	else
		cout << "Credit limit exceeded. Transaction cancelled.\n";
	restore(initialState, prec); 
}

该方法使用基类的 Balance()函数来确定结余。因为派生类没有重新定义该方法,代码不必对 Balance()使用作用域解析运算符。

方法 ViewAcct()和 Withdraw()使用格式化方法set()和 precision()将浮点值的输出模式设置为定点,即包含两位小数。设置模式后,输出的模式将保持不变,因此该方法将格式模式重置为调用前的状态。为避免代码重复,该程序将设置格式的代码放在辅助函数中:

// formatting stuff
typedef std::ios_base::fmtflags format;
typedef std::streamsize precis;
format setFormat();
void restore(format f, precis p);

函数 setFormat()设置定点表示法并返回以前的标记设置:

format setFormat()
{
    
    
	// set up ###.## format
	return cout.setf(std::ios_base::fixed, 
				std::ios_base::floatfield);
} 

而函数 restore()重置格式和精度:

void restore(format f, precis p)
{
    
    
	cout.setf(f, std::ios_base::floatfield);
	cout.precision(p);
}

有关设置输出格式的更详细信息,请参阅第17章。

5.使用 Brass 和 BrassPlus类

清单13.9使用了一个 Brass对象和一个 BrassPlus对象来测试类定义。
程序清单13.9 usebrass1.cp

/*
	author:梦悦foundation
	公众号:梦悦foundation
	可以在公众号获得源码和详细的图文笔记
*/

// usebrass1.cpp -- testing bank account classes
// compile with brass.cpp
#include <iostream>
#include "brass.h"

int main()
{
    
    
    using std::cout;
    using std::endl;

    Brass Piggy("Porcelot Pigg", 381299, 4000.00);
    BrassPlus Hoggy("Horatio Hogg", 382288, 3000.00);
    Piggy.ViewAcct();
    cout << endl;
    Hoggy.ViewAcct();
    cout << endl;
    cout << "Depositing $1000 into the Hogg Account:\n";
    Hoggy.Deposit(1000.00);
    cout << "New balance: $" << Hoggy.Balance() << endl;
    cout << "Withdrawing $4200 from the Pigg Account:\n";
    Piggy.Withdraw(4200.00);
    cout << "Pigg account balance: $" << Piggy.Balance() << endl;
    cout << "Withdrawing $4200 from the Hogg Account:\n";
    Hoggy.Withdraw(4200.00);
    Hoggy.ViewAcct();
	// std::cin.get();
    return 0; 
}

下面是程序清单13.9所示程序的输出,请注意为何Hoggy受透支限制,而Piggy没有.

book@book-desktop:~/meng-yue/c++/class_inherit/03$ g++ -o usebrass1 usebrass1.cpp brass.cpp
book@book-desktop:~/meng-yue/c++/class_inherit/03$ ./usebrass1
Client: Porcelot Pigg
Account Number: 381299
Balance: $4000.00

Client: Horatio Hogg
Account Number: 382288
Balance: $3000.00
Maximum loan: $500.00
Owed to bank: $0.00
Loan Rate: 11.125%

Depositing $1000 into the Hogg Account:
New balance: $4000
Withdrawing $4200 from the Pigg Account:
Withdrawal amount of $4200.00 exceeds your balance.
Withdrawal canceled.
Pigg account balance: $4000
Withdrawing $4200 from the Hogg Account:
Bank advance: $200.00
Finance charge: $22.25
Client: Horatio Hogg
Account Number: 382288
Balance: $0.00
Maximum loan: $500.00
Owed to bank: $222.25
Loan Rate: 11.125%
book@book-desktop:~/meng-yue/c++/class_inherit/03$

6.演示虚方法的行为

在程序清单13.9中,方法是通过对象(而不是指针或引用)调用的,没有使用虚方法特性。下面来看个使用了虚方法的例子。
假设要同时管理 Brass和 BrassPlus账户,如果能使用同一个数组来保存Brass 和 BrassPlus对象,将很有帮助,但这是不可能的。

数组中所有元素的类型必须相同,而 Brass 和 BrassPlus 是不同的类型。然而,可以创建指向 Brass的指针数组。这样,每个元素的类型都相同,但由于使用的是公有继承模型,因此 Brass指针既可以指向 Brass 对象,也可以指向 BrassPlus对象。
因此,可以使用一个数组来表示多种类型的对象。这就是多态性,程序清单13.10是一个简单的例子。
程序清单13.10 usebrass2.cpp

/*
	author:梦悦foundation
	公众号:梦悦foundation
	可以在公众号获得源码和详细的图文笔记
*/

// usebrass2.cpp -- polymorphic example
// compile with brass.cpp
#include <iostream>
#include <string>
#include "brass.h"
const int CLIENTS = 4;

int main()
{
    
    
   using std::cin;
   using std::cout;
   using std::endl;

   Brass * p_clients[CLIENTS];
   std::string temp;
   long tempnum;
   double tempbal;
   char kind;

   for (int i = 0; i < CLIENTS; i++)
   {
    
    
       cout << "Enter client's name: ";
       getline(cin,temp);
       cout << "Enter client's account number: ";
       cin >> tempnum;
       cout << "Enter opening balance: $";
       cin >> tempbal;
       cout << "Enter 1 for Brass Account or "
            << "2 for BrassPlus Account: ";
       while (cin >> kind && (kind != '1' && kind != '2'))
           cout <<"Enter either 1 or 2: ";
       if (kind == '1')
           p_clients[i] = new Brass(temp, tempnum, tempbal);
       else
       {
    
    
           double tmax, trate;
           cout << "Enter the overdraft limit: $";
           cin >> tmax;
           cout << "Enter the interest rate "
                << "as a decimal fraction: ";
           cin >> trate;
           p_clients[i] = new BrassPlus(temp, tempnum, tempbal,
                                        tmax, trate);
        }
        while (cin.get() != '\n')
            continue;
   }
   cout << endl;
   for (int i = 0; i < CLIENTS; i++)
   {
    
    
       p_clients[i]->ViewAcct();
       cout << endl;
   }
              
   for (int i = 0; i < CLIENTS; i++)
   {
    
    
       delete p_clients[i];  // free memory
   }
   cout << "Done.\n";         
 /* code to keep window open 
   if (!cin)
      cin.clear();
   while (cin.get() != '\n')
      continue;
*/
   return 0; 
}

程序清单13.10根据用户的输入来确定要添加的账户类型,然后使用new创建并初始化相应类型的对象。您可能还记得, getline(cin,temp)从cin读取一行输入,并将其存储到 string对temp中。
下面是该程序的运行情况:

在这里插入代码片

多态性是由下述代码提供的:

   for (int i = 0; i < CLIENTS; i++)
   {
    
    
       p_clients[i]->ViewAcct();
       cout << endl;
   }

如果数组成员指向的是 Brass对象,则调用Brass::Viewacct():如果指向的是 BrassPlus对象,则调用BrassPlus::Viewacct()。

7.为何需要虚析构函数

在程序清单13.10中,使用 delete释放由new分配的对象的代码说明了为何基类应包含一个虚析构函数,虽然有时好像并不需要析构函数。

如果析构函数不是虚的,则将只调用对应于指针类型的析构函数。对于程序清单13.10,这意味着只有 Brass的析构函数被调用,即使指针指向的是一个 BrassPlus对象。
如果析构函数是虚的,将调用相应对象类型的析构函数。
因此,如果指针指向的是 BrassPlus对象,将调用 BrassPlus的析构函数,然后自动调用基类的析构函数。因此,使用虚析构函数可以确保正确的析构函数序列被调用。

对于程序清单13.10,这种正确的行为并不是很重要,因为析构函数没有执行任何操作。然而,如果 BrassPlus包含一个执行某些操作的析构函数,则 Brass 必须有一个虚析构函数,即使该析构函数不执行任何操作。