每次寫類需要用到繼承關係的時候我都習慣性的用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繼承,子類可以訪問基類的任何方法和成員變數.