217-C++设计的注意事项(2)

àì夳堔傛蜴生んèń 2022-11-06 03:54 47阅读 0赞

## 避免 “向下转换” 继承层次 ##

**看看下面这个有关银行帐户的协议类(Protocol class )**

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();// 给帐户增加利息
    
    };

**银行想为它所有的帐户维持一个列表，这可能是通过标准库中的list类模板实现的。假设列表被叫做allAccounts：**

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

和所有的标准容器一样，list存储的是对象的拷贝，所以，为避免每个BankAccount存储多个拷贝，银行决定让allAccounts保存BankAccount的指针，而不是BankAccount本身。  
**假设现在准备写一段代码来遍历所有的帐户，为每个帐户计算利息。你会这么写：**

for(list<BankAccount*>::iterator p = allAccounts.begin();
    	p != allAccounts.end();
    	++p) 
    {
        
      (*p)->creditInterest();//编译产生错误!
    }

**编译器很快就会让你认识到**：allAccounts包含的指针指向的是BankAccount对象，而非SavingsAccount对象，所以每次循环，p指向的是一个BankAccount。这使得对creditInterest的调用无效，因为creditInterest只是为SavingsAccount对象声明的，而不是BankAccount。

变量p工作起来就象一个指针，它将allAccounts中的元素从头到尾循环一遍。也就是说，p工作起来就好象它的类型是BankAccount\*\*，而列表中的元素都存储在一个数组中。

上面的循环不能通过编译很令人泄气。的确，allAccounts是被定义为保存BankAccount\*，但要知道，上面的循环中它事实上保存的是SavingsAccount\*，因为SavingsAccount是仅有的可以被实例话的类。愚蠢的编译器！对我们来说这么显然的事情它竟然笨得一无所知。所以你决定告诉它：allAccounts真的包含的是SavingsAccount\*：

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

**一切问题迎刃而解！解决得很清晰，很漂亮，很简明，所做的仅仅是一个简单的转换而已。你知道allAccounts指针保存的是什么类型的指针，迟钝的编译器不知道，所以你通过一个转换来告诉它，还有比这更合理的事吗？**

这种类型的转换 ---- 从一个基类指针到一个派生类指针 ---- 被称为 “向下转换”，因为它向下转换了继承的层次结构。  
在刚看到的例子中，向下转换碰巧可以工作；  
**但正如下面即将看到的，它将给今后的维护人员带来恶梦。**  
回到银行的话题上来。受到存款帐户业务大获成功的激励，银行决定再推出支票帐户业务。另外，假设支票帐户和存款帐户一样，也要负担利息：

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++中，要使用虚函数。**

对于一个虚函数，编译器可以根据所使用对象的类型来保证正确的函数调用。所以不要在代码中随处乱扔条件语句；让编译器来为你效劳。如下所示：

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();
    }

要注意的是，虚函数BankAccount::creditInterest提供一个了空的缺省实现。这可以很方便地表示，它的行为在缺省情况下是一个空操作；但这也会给它本身带来难以预见的问题。还要注意的是，creditInterest是一个（隐式的）内联函数，这本身没什么问题；但因为它同时又是一个虚函数，内联指令就有可能被忽略。  
正如上面已经看到的，“向下转换” 可以通过几种方法来消除。最好的方法是将这种转换用虚函数调用来代替，同时，它可能对有些类不适用，所以要使这些类的每个虚函数成为一个空操作。第二个方法是加强类型约束，使得指针的声明类型和你所知道的真的指针类型之间没有出入。为了消除向下转换，无论费多大工夫都是值得的，因为向下转换难看、容易导致错误，而且使得代码难于理解、升级和维护。

**有些情况下，真的不得不执行向下转换。**

例如，假设还是面临开始的那种情况，即，allAccounts保存BankAccount指针，creditInterest只是为SavingsAccount对象定义，要写一个循环来为每个帐户计算利息。进一步假设，你不能改动这些类；你不能改变BankAccount，SavingsAccount或allAccounts的定义。**（如果它们在某个只读的库中定义，就会出现这种情况）** 如果是这样的话，你就只有使用向下转换了，无论你认为这个办法有多丑陋。

**尽管如此，还是有比上面那种原始转换更好的办法**。这种方法称为 “**安全的向下转换**”，**它通过C++的dynamic\_cast运算符来实现**。当对一个指针使用dynamic\_cast时，先尝试转换，如果成功（即，指针的动态类型和正被转换的类型一致），就返回新类型的合法指针；如果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!");
    	}
    }

**这种方法远不够理想，但至少可以检测到转换失败，而用dynamic\_cast是无法做到的。** 但要注意，对所有转换都失败的情况也要检查。这正是上面代码中最后一个else语句的用意所在。采用虚函数，就不必进行这样的检查，因为每个虚函数调用必然都会被解析为某个函数。然而，一旦打算进行转换，这一切好处都化为乌有。例如，如果某个人在类层次结构中增加了一种新类型的帐户，但又忘了更新上面的代码，所有对它的转换就会失败。所以，处理这种可能发生的情况十分重要。大部分情况下，并非所有的转换都会失败；但是，一旦允许转换，再好的程序员也会碰上麻烦。

上面if语句的条件部分，有些看上去像变量定义的东西，这种定义变量的方法是和dynamic\_cast同时增加到C++语言中的。这一特性使得写出的代码更简洁，因为对psa或pca来说，它们只有在被dynamic\_cast成功初始化的情况下，才会真正被用到；使用新的语法，就不必在（包含转换的）条件语句外定义这些变量。

**如果编译器尚不支持这种定义变量的新方法，可以按老方法来做**

for (list<BankAccount*>::iterator p = allAccounts.begin();
    	 p != allAccounts.end();
    	 ++p) 
    {
        
    
    	SavingsAccount *psa;// 传统定义
    	CheckingAccount *pca;// 传统定义
    
    	if (psa = dynamic_cast<SavingsAccount*>(*p)) 
    	{
        
    		psa->creditInterest();
    	}
    
    	else if (pca = dynamic_cast<CheckingAccount*>(*p)) 
    	{
        
    		pca->creditInterest();
    	}
    
    	else 
    	{
        
    		error("Unknown account type!");
    	}
    }

**用if-then-else风格的编程来进行向下转换比用虚函数要逊色得多，应该将这种方法保留到万不得已的情况下使用。运气好的话，你的程序世界里将永远看不到这样悲惨荒凉的景象。**