c++非公有虚函数探究

转载：http://plutoblog.iteye.com/blog/1182469

（一）公有虚函数

子类通过覆盖公有虚函数的方式实现多态是最常见的情况。指向子类对象的基类指针调用被子类覆盖的函数，实际上，调用的是子类的函数。以下代码：

 

 

Cpp代码  

1. class Base  
2. {  
3. public:  
4.     virtual void foo()  
5.     {  
6.         cout<<"Base::foo"<<endl;  
7.     }  
8. };  
9.   
10. class Derive:public Base  
11. {  
12.     void foo()  
13.     {  
14.         cout<<"Derive::foo"<<endl;  
15.     }  
16. };  

 

 编写了两个类，其中Derive类公有继承Base类，覆盖Base类的虚函数foo(),在main函数中，编写测试代码：

 

Cpp代码  

1. Base *pb = new Derive();  
2. pb->foo();  

 

 毫无疑问，在上面的代码中，pb调用的是子类Derive中的foo()函数，输出结果：

 

Cpp代码  

1. Derive::foo  

 

 （二）非公有虚函数

和公有虚函数相对的是保护虚函数和私有虚函数，在这里，为了方便探讨问题，只讨论私有虚函数。至于保护虚函数的情况和私有虚函数大同小异，差异只在于函数的可见性不同。

从表面看，虚函数的作用就是为了使父类指针能够访问到子类对象的函数。如果将虚函数设置为私有的，那么，无论子类对象，还是父类对象，都无法访问到该函数。这样的函数就变得毫无意义了。实际情况果真如此吗？答案是否定的。首先C++支持私有虚函数，当然也支持保护虚函数，在这里，对保护虚函数不做讨论。

学习过设计模式的朋友都知道，封装算法这一设计原则。该原则使用模板方法模式，向外部提供访问的接口，该接口明确了算法的步骤。对于算法的每个步骤，由外部通过继承的方式来指定。下面举个简单的例子来说明。

众所周知，购物的过程是，先挑选商品，接着付款，最后离开商店。在这个过程中，3个步骤是有顺序的，不能随意地颠倒次序。在生活中，这个类似的例子很多。以下编写一个表示购物的抽象类，它拥有3个私有纯虚函数choose()，pay()和lease()，分别表示购物的挑选商品，付款和离开商店的3个过程，由shopping函数依次调用这3个函数：

 

Cpp代码  

1. class Store  
2. {  
3. public:  
4.     void shopping()  
5.     {  
6.         cout<<"Base::shopping"<<endl;  
7.         choose();  
8.         pay();  
9.         lease();  
10.     }  
11.   
12. private:  
13.     virtual void choose() = 0;  
14.     virtual void pay() = 0;  
15.     virtual void lease() = 0;  
16. };  

 

 接下来，实现一个表示购买水果的类，它继承自Store类，覆盖了Store类中的choose()，pay()和lease()函数。代码如下所示：

 

Cpp代码  

1. class FruitStore:public Store  
2. {  
3. private:  
4.     void choose()  
5.     {  
6.         cout<<"FruitStore::choose"<<endl;  
7.     }  
8.   
9.     void pay()  
10.     {  
11.         cout<<"FruitStore::pay"<<endl;  
12.     }  
13.   
14.     void lease()  
15.     {  
16.         cout<<"FruitStore::lease"<<endl;  
17.     }  
18. };  

 

在main函数中，编写测试代码：

 

Cpp代码  

1. Store *ps = new FruitStore();  
2. ps->shopping();  

 

运行后输出结果：

 

Cpp代码  

1. Base::shopping  
2. FruitStore::choose  
3. FruitStore::pay  
4. FruitStore::lease  

 

从上面的代码可以看出，父类Store通过shopping函数规定了购物的过程，至于购物的每个步骤该做什么，由子类来指定。由于表示购物步骤的函数被声明为私有的，我们就不能通过子类对象来调用choose(),pay()或lease(),避免了出现先离开商品，再挑选商品的混乱情况。

这样，我们就可以很轻松地实现各种各样的具体购物类，例如，我们新增加一个表示购买衣服的类：

 

Cpp代码  

1. class ClothesStore:public Store  
2. {  
3. private:  
4.     void choose()  
5.     {  
6.         cout<<"ClothesStore::choose"<<endl;  
7.     }  
8.   
9.     void pay()  
10.     {  
11.         cout<<"ClothesStore::pay"<<endl;  
12.     }  
13.   
14.     void lease()  
15.     {  
16.         cout<<"ClothesStore::lease"<<endl;  
17.     }  
18. };  

 

在main函数中，编写测试代码：

 

 

Cpp代码  

1. Store *ps = new FruitStore();  
2. ps->shopping();  
3. ps = new ClothesStore();  
4. ps->shopping();  

 

运行后输出结果：

 

 

Cpp代码  

1. Base::shopping  
2. FruitStore::choose  
3. FruitStore::pay  
4. FruitStore::lease  
5. Base::shopping  
6. ClothesStore::choose  
7. ClothesStore::pay  
8. ClothesStore::lease  

 

这个购买衣服类同样遵循了，先挑选商品，接着付款，最后离开商店的次序。这正是非公有虚函数和封装算法的奇妙之处。