条款 39: 避免"向下转换" 继承层次

 
class Person { ... };
class BankAccount {
public:
BankAccount(const Person *primaryOwner,
const Person *jointOwner);
virtual ~BankAccount();
virtual void makeDeposit(double amount) = 0;
virtual void makeWithdrawal(double amount) = 0;
virtual double balance() const = 0;
...
}

很多银行现在提供了多种令人眼花缭乱的帐户类型,但为简化起见,我们假设只有一种银行帐户,称为存款帐户:

class SavingsAccount: public BankAccount {
public:
SavingsAccount(const Person *primaryOwner,
const Person *jointOwner);
~SavingsAccount();
void creditInterest(); //  给帐户增加利息
...
};

银行想为它所有的帐户维持一个列表,这可能是通过标准库 (参见条款 49)中的 list 类模板实现的。假设列表被叫做 allAccounts:

list<BankAccount*> allAccounts; //  银行中所有帐户

//  不能通过编译的循环(如果你以前从没
//  见过使用"迭代子"  的代码,参见下文)
for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
(*p)->creditInterest(); //  错误!
}
       编译器很快就会让你认识到: allAccounts 包含的指针指向的是BankAccount 对象而非 SavingsAccount 对象,所以每次循环,p 指向的是一个 BankAccount。这使得对 creditInterest 的调用无效,因为 creditInterest只是为 SavingsAccount 对象声明的,而不是 BankAccount。
       的确, allAccounts 是被定义为保存BankAccount*,但要知道, 上面的循环中它事实上保存的是 SavingsAccount*,因为 SavingsAccount 是仅有的可以被实例话的类。愚蠢的编译器!对我们来说这么显然的事情它竟然笨得一无所知。 所以你决定告诉它:allAccounts 真的包含的是 SavingsAccount*:

 

//  可以通过编译的循环,但很糟糕
for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
<span style="color:#ff0000;">static_cast<SavingsAccount*>(*p)->creditInterest();</span>
}

        这种类型的转换----  从一个基类指针到一个派生类指针----  被称为"向下转换"因为它向下转换了继承的层次结构。在刚看到的例子中,向下转换碰巧可以工作;但正如下面即将看到的,它将给今后的维护人员带来恶梦。

       还是回到银行的话题上来。受到存款帐户业务大获成功的激励,银行决定再推出支票帐户业务。另外,假设支票帐户和存款帐户一样,也要负担利息:

       

class CheckingAccount: public BankAccount {
public:
void creditInterest(); //  给帐户增加利息
...
};
       不用说,allAccounts 现在是一个包含存款和支票两种帐户指针的列表。于是,上面所写的计算利息的循环转瞬间有了大麻烦。

      第一个问题是,虽然新增了一个 CheckingAccount,但即使不去修改循环代码,编译还是可以继续通过。因为编译器只是简单地听信于你所告诉它们 (通过 static_cast)的一切: *p 指向的是 SavingsAccount*。谁叫你是它的主人呢?这会给今后维护带来第一个恶梦。维护期第二个恶梦在于,你一定想去解决这个问题,所以你会写出这样的代码:

for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
if (*p  指向一个SavingsAccount)
static_cast<SavingsAccount*>(*p)->creditInterest();
else
static_cast<CheckingAccount*>(*p)->creditInterest();
}
       任何时候发现自己写出"如果对象属于类型 T1,做某事;但如果属于类型T2,做另外某事"  之类的代码,就要扇自己一个耳光。这不是 C++的做法。是的,在 C,Pascal,甚至 Smalltalk 中, 它是很合理的做法,但在 C++中不是。在 C++中,要使用虚函数。
总结:在C++中,函数操作想与类型绑定,只有通过虚函数机制才能实现。 对于一个虚函数,编译器可以根据所使用对象的类型来保证正确的函数调用。

class BankAccount { ... }; //  同上
//  一个新类,表示要支付利息的帐户
class InterestBearingAccount: public BankAccount {
public:
virtual void creditInterest() = 0;
...
};
class SavingsAccount: public InterestBearingAccount {
... //  同上
};
class CheckingAccount: public InterestBearingAccount {
... //as above
};

用图形表示如下:
                                         BankAccount
                                                   ^
                                                   |
                                InterestBearingAccount
                                                   /\
                                                  / \
                                                  / \
                     CheckingAccount SavingsAccount

        因为存款和支票账户都要支付利息,所以很自然地想到把这一共同行为转移到一个公共的基类中。但是,如果假设不是所有的银行帐户都需要支付利息(以我的经验,这当然是个合理的假设) ,就不能把它转移到 BankAccount 类中。所以,BankAccount 引入一个新的子类 InterestBearingAccount ,并使 SavingsAccoun 和 CheckingAccount 从它继承。

      存款和支票账户都要支付利息的事实是通过 InterestBearingAccount 的纯虚函数 creditInterest 来体现的,它要在子类 SavingsAccount 和 CheckingAccount中重新定义。
      有了新的类层次结构,就可以这样来重写循环代码:

       

//  好一些,但还不完美
for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
static_cast<InterestBearingAccount*>(*p)->creditInterest();
}
      尽管这个循环还是包含一个讨厌的转换,但代码已经比过去健壮多了,因为即使又增加 InterestBearingAccount 新的子类到程序中,它还是可以继续工作。
      为了完全消除转换,就必须对设计做一些改变。一种方法是限制帐户列表的类型。如果能得到一列 InterestBearingAccount 对象而不是 BankAccount 对象,那就太好了:
 
//  银行中所有要支付利息的帐户
list<InterestBearingAccount*> allIBAccounts;
//  可以通过编译且现在将来都可以工作的循环
for (list<InterestBearingAccount*>::iterator p =
allIBAccounts.begin();
p != allIBAccounts.end();
++p) {
(*p)->creditInterest();
}


        如果不想用上面这种"采用更特定的列表"  的方法,那就让 creditInterest操作使用于所有的银行帐户,但对于不用支付利息的帐户来说,它只是一个空操作。这个方法可以这样来表示:
class BankAccount {
public:
virtual void creditInterest() {}
...
};
class SavingsAccount: public BankAccount { ... };
class CheckingAccount: public BankAccount { ... };
list<BankAccount*> allAccounts;
//  看啊,没有转换!
for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
(*p)->creditInterest();
}
向下转换"  可以通过几种方法来消除:

最好的方法
        是将这种转换用虚函数调用来代替,同时,它可能对有些类不适用,所以要使这些类的每个虚函数成为一个空操作第二个方法是加强类型约束,使得指针的声明类型和你所知道的真的指针类型之间没有出入。

        尽管如此,还是有比上面那种原始转换更好的办法。这种方法称为"安全的向下转换"它通过 C++的 dynamic_cast 运算符(参见条款 M2)来实现。当对一个指针使用 dynamic_cast 时,先尝试转换,如果成功(即,指针的动态类型(见条款 38) 和正被转换的类型一致) ,就返回新类型的合法指针;如果dynamic_cast 失败,返回空指针。
       

class BankAccount { ... }; //  和本条款开始时一样
class SavingsAccount: //  同上
public BankAccount { ... };
class CheckingAccount: //  同上
public BankAccount { ... };
list<BankAccount*> allAccounts; //  看起来应该熟悉些了吧...
void error(const string& msg); //  出错处理函数;
//   见下文

//  嗯,至少转换很安全
for (list<BankAccount*>::iterator p = allAccounts.begin();
p != allAccounts.end();
++p) {
//  尝试将*p 安全转换为 SavingsAccount*;
// psa 的定义信息见下文
if (SavingsAccount *psa =
dynamic_cast<SavingsAccount*>(*p)) {
psa->creditInterest();
}
//  尝试将它安全转换为 CheckingAccount
else if (CheckingAccount *pca =
dynamic_cast<CheckingAccount*>(*p)){
pca->creditInterest();
}
//  未知的帐户类型
else {
error("Unknown account type!");
}
}

用 if-then-else 风格的编程来进行向下转换比用虚函数要逊色得多,应该将这种方法保留到万不得已的情况下使用。

总结:

          继承层次中的向下转换有时是难以避免的,解决办法:

          1、最优选择,用虚函数来编程

          2、用C++的 dynamic_cast 运算符(参见条款 M2)来实现。


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值