它山之石----私有派生

山之石

                       ----私有派生

作者：HolyFire

 

它山之石，可以攻玉。说的是善于利用事物，可以做到自己不能做的事。

 

我曾经在《白马非马----继承》中论及类的关系，其中说了很多公有派生的话题，指出共有派生中，子类与父类的关系为是一个的关系，现在我要说的私有派生却是用一个的关系。改变了一个关键字，会带来本质的变化，这正是世事变化无常的明证。

 

我们先来看看，私有派生到底有什么区别

 

这是一个封装好的类

 

class A{

public:

        int data;

};

 

class B : private A{

};

 

class C : public A{

};

 

void function1( A a )

{

}

 

void main()

{

        B b;

        C c;

 

        b.data = 0;

        function1( b );

 

        c.data = 0;

        function1( c );

}

 

我们编译一下，会发现

        b.data = 0;

        function1( b );

这两句被拒绝了，而

        c.data = 0;

        function1( c );

却没有问题

        b.data = 0;

        c.data = 0;

说明了私有派生与公有派生的第一个区别，私有派生的子类所有基类的成员都将成为私有的，成员函数也不例外，不相信你可以试试看哦。

        function1( b );

        function1( c );

说明了私有派生与公有派生的第二个区别，私有派生的子类与其基类不再为是一个的关系，所以 function1( b ); 不能将参数转化为一个类型A的临时变量。

 

但是私有派生的子类还是可以使用其基类的 public 和 protected 的成员，与公有派生不同的是原来基类的接口不再为子类所有，子类拥有的只是其实现。

 

为什么这样说呢，在 C++ 中的问题在于，接口和实现一样都是函数（方法）。这样就令我们有所混淆，但是在私有派生中，这个问题将得到澄清。

 

class A{

public:

        void DoA( void ){}

};

 

class B : private A{

public:

        void DoB( void ){ DoA(); }

};

 

class C : public A{

public:

        void DoC( void ){ DoA(); }

};

 

void main()

{

        B b;

        C c;

 

        b.DoB();

        c.DoC();

        b.DoA();

        c.DoA();

}

        b.DoB();

        c.DoC();

是派生子类的接口

        b.DoA();

        c.DoA();

是子类使用基类的接口，但是 b.DoA();编译通不过，因为私有派生不能继承基类的接口，但是他在

void DoB( void ){ DoA(); }

却使用了A::DoA();因为他继承了基类的结构和实现。

好了，类B可以使用类A的实现，但是不能象一个类A一样提供A的接口，也就是说，B是将A拿来用的，B使用一个A，而B不是A。B和A的关系其实在于功能的使用方面，私有派生中子类与父类的关系为用一个的关系。

 

既然思想上知道了私有派生的意义，那么它到底有什么用呢，到底需不需要私有派生呢。

 

这个很容易想到，既然私有派生是用一个的关系，而我们上面说到子类对基类只是有实现方面的需要，也就是子类用基类做什么事，那么我们就知道私有派生适合什么场合了。比如说樵夫用斧子劈柴火，那么樵夫就应该用一个斧子。

 

class Axe{

};

 

class Axman : private Axe{

};

 

等等，有人不禁想到

 

class Axman{

    Axe axe;

};

 

不是也可以描述这个关系吗，对了！樵夫有一个斧子的话，不就可以用一个斧子了吗，这样的代码看起来还更容易理解。用一个的关系的确可以用有一个的关系来替代，使用关联中的组合的确可以替代私有派生的方案。

 

class Axman{

    Axe * axe;

};

 

这样的关系看起来更有弹性，因为樵夫没理由要永远把斧子带在身上，斧子还可以给别的樵夫用呢。

 

很明显，这又是效率和弹性取舍的问题，没有一个完美的方案，只有适合不适合的方案。如果问题很明显，而且不可预知性很少，那么就用继承，反之就用关联。有人要说了，其实继承和关联的效果不是一样吗。

 

class Axe{

};

 

class Axman : private Axe{

};

 

class Axman{

    Axe axe;

};

 

应该没有效率的差异吧。其实实际的问题不是这样的。

 

相信很多人编程的时候都知道空类和空结构是占用资源的

class Empty{

};

至少要占用一个字节，如果有字节对齐还会更多，那么

class Axman{

    Axe axe;

};

中的Axe axe;就会有资源占用，如果编译器支持空基类优化的话，也就是由空类派生而来的子类中基类部分将不占用资源，那么Axe axe;的附加损失会在私有继承中消失。

 

呵呵，我举的这个例子过于特殊，而且涉及到编译器等细节问题，其实我想说的还是那句话，没有一个完美的方案，只有适合不适合的方案。过于拘泥继承和关联的形式并不好，掌握了思想然后恰当的运用它才是主要的。

 

我们经常会用到的一个数据结构就是堆栈了，堆栈是一个先进后出的容器，那么它需要使用一个容器，STL中的vector是一个容器，但stack不是一个vector，他只是需要使用vector可以存储的功能而已。

 

#include <iostream>

#include <vector>

 

using namespace std;

 

class stack : private vector<int>{

public:

        stack( void ){ }

        void Push( int Value ){ push_back( Value ); }

        int Pop( void )

                {

                int value = *rbegin();

                pop_back();

                return value;

                }

        bool Empty( void ){ return empty(); }

};

 

void main( void )

{

        stack s;

        s.Push( 1 );

        s.Push( 7 );

        s.Push( 6 );

        s.Push( 4 );

        s.Push( 5 );

        while( !s.Empty() )

                cout << s.Pop() << endl;

        cin.get();

}

 

结果是：

5

4

6

7

1

 

其中stack使用了vector中的push_back,pop_back,empty,rbegin的功能来实现了自己的Push,Pop,Empty的接口和实现。Stack使用了vector。

 

好了，现在我们知道了什么是私有派生，以及该如何运用它。