类的三种继承方式的访问权限.

    每次写类需要用到继承关系的时候我都习惯性的用public,而有些时候用其它两种继承方式
(保护继承和私有继承)还是比较方便的,但是自己但是就是想不起来用,看到别人用它而设计出的
类机构很好的时候游羡慕不已,我以前学习C++的时候也注意过这两种继承方式各个区域(public,
protected,private)的访问权限问题,当时是死记住的,过一段时间就忘记了, 记不住,今天就又遇
到了这种情况,于是决定写个测试程序测试一下,然后总结一下,我觉得应该记忆深刻一点,呵呵,
说做就做!

//test.cpp
#include <iostream>
using namespace std;

class Base
{
public:
    Base(int pubValue,int proValue,int priValue)
        :pubValue_(pubValue),
        proValue_(proValue),
        priValue_(priValue){
    }

public:
    void Base_TestFun_Pub(){
        cout<<"Call Base_TestFun_Pub ..."<<endl;
    }
    int pubValue_;

protected:
    void Base_TestFun_Pro(){
        cout<<"Call Base_TestFun_Pro ..."<<endl;
    }
    int proValue_;

private:
    void Base_TestFun_Pri(){
        cout<<"Call Base_TestFun_Pri ..."<<endl;
    }
    int priValue_;
};

class PublicDerived:public Base
{
public:
    PublicDerived():Base(10,20,30){}

public:
    void PublicDerived_TestFun_Pub(){
        cout<<"Call PublicDerived_TestFun_Pub ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
        //Base_TestFun_Pri();
        //++priValue_;
    }

protected:
    void PublicDerived_TestFun_Pro(){
        cout<<"Call PublicDerived_TestFun_Pro ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
       // Base_TestFun_Pri(); // access error
       // ++priValue_;        // access error
    }

private:
    void PublicDerived_TestFun_Pri(){
        cout<<"Call PublicDerived_TestFun_Pri ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri();// access error
      //  ++priValue_;        // access error
    }
};

class ProtectedDerived:protected Base
{
public:
    ProtectedDerived():Base(10,20,30){}

public:
    void ProtectedDerived_TestFun_Pub(){
        cout<<"Call ProtectedDerived_TestFun_Pub ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri(); // access error
      //  ++priValue_;        // access error
    }

protected:
    void ProtectedDerived_TestFun_Pro(){
        cout<<"Call ProtectedDerived_TestFun_Pro ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri(); // access error
      //  ++priValue_;        // access error
    }

private:
    void ProtectedDerived_TestFun_Pri(){
        cout<<"Call ProtectedDerived_TestFun_Pri ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri(); // access error
      //  ++priValue_;        // access error
    }
};

class PrivateDerived:private Base
{
public:
    PrivateDerived():Base(10,20,30){}

public:
    void PrivateDerived_TestFun_Pub(){
        cout<<"Call PrivateDerived_TestFun_Pub ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri(); // access error
      //  ++priValue_;        // access error
    }

protected:
    void PrivateDerived_TestFun_Pro(){
        cout<<"Call PrivateDerived_TestFun_Pro ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
       // Base_TestFun_Pri(); // access error
       // ++priValue_;        // access error
    }

private:
    void PrivateDerived_TestFun_Pri(){
        cout<<"Call PrivateDerived_TestFun_Pri ..."<<endl;
        Base_TestFun_Pub();
        ++pubValue_ ;
        Base_TestFun_Pro();
        ++proValue_;
      //  Base_TestFun_Pri(); // access error
      //  ++priValue_;        // access error
    }
};

int main(){
    return 0;
}

    通过这个测试程序,就可以很容易得出以下结论了:
    (1). private继承,基类的public,protected,private所有方法和成员变量在子类中都
变为private,子类不能访问它们;
    (2). protected继承,基类的protected和public方法变为子类的protected,子类可以访
问它们,但是不能访问private方法和  成员变量;
    (3). public继承,子类可以访问基类的任何方法和成员变量.