c/c++再學習：C++中public、protect、private的訪問權限控制

C++中public、protect、private的訪問權限控制

訪問權限

一個類的public成員變量、成員函數，能夠經過類的成員函數、類的實例變量進行訪問

一個類的protected成員變量、成員函數，沒法經過類的實例變量進行訪問。可是能夠經過類的友元函數、友元類進行訪問。

一個類的private成員變量、成員函數，沒法經過類的實例變量進行訪問。可是能夠經過類的友元函數、友元類進行訪問。

訪問權限demo

#include <iostream>

class ReferencePerission
{
    friend class FriendClass;
    friend void FriendFunc();
public:
    int public_num;
    void public_func(){std::cout <<"public_func "<<public_num<<std::endl;}
protected:
    int protected_num;
    void protected_func(){std::cout <<"protected_func "<<protected_num<<std::endl;}
private:
    int private_num;
    void private_func(){std::cout <<"private_func "<<private_num<<std::endl;}
};

class FriendClass
{
public:
    FriendClass() {
        std::cout<<"FriendClass"<<std::endl;
        ReferencePerission ref;
        ref.public_num = 1;
        ref.protected_num = 2;
        ref.private_num = 3;
        ref.public_func();
        ref.protected_func();
        ref.private_func(); 
    }
    
    ~FriendClass()
    {
        
    }
};

void FriendFunc()
{
    std::cout<<"FriendFunc"<<std::endl;
    ReferencePerission ref;
    ref.public_num = 1;
    ref.protected_num = 2;
    ref.private_num = 3;
    ref.public_func();
    ref.protected_func();
    ref.private_func();     
}

int main()
{
    ReferencePerission ref;
    
    ref.public_num = 1;
    //ref.protected_num = 2;    /* 編譯出錯 declared protected here */
    //ref.private_num = 3;      /* 編譯出錯 declared private here */
    ref.public_func();
    //ref.protected_func();     /* 編譯出錯 declared protected here */
    //ref.private_func();       /* 編譯出錯 declared private here */    
    
    FriendFunc(); /* 友元函數能夠訪問public,protected,private成員變量和函數 */
    
    FriendClass friendObj; /* 友元類能夠訪問public,protected,private成員變量和函數 */
    
    return 0;
}

繼承權限
public繼承
派生類經過public繼承，基類的各類權限不變 。
派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員。
派生類的實例變量，能夠訪問基類的public成員，可是沒法訪問protected、private成員，彷彿基類的成員之間加到了派生類通常。
能夠將public繼承當作派生類將基類的public,protected成員囊括到派生類，可是不包括private成員。

protected繼承
 派生類經過protected繼承，基類的public成員在派生類中的權限變成了protected 。protected和private不變。
派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員。
派生類的實例變量，沒法訪問基類的任何成員，由於基類的public成員在派生類中變成了protected。
能夠將protected繼承當作派生類將基類的public,protected成員囊括到派生類，所有做爲派生類的protected成員，可是不包括private成員。
private成員是基類內部的隱私，除了友元，全部人員都不得窺探。派生類的友元，都不能訪問

private繼承
派生類經過private繼承，基類的全部成員在派生類中的權限變成了private。
派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員。
派生類的實例變量，沒法訪問基類的任何成員，由於基類的全部成員在派生類中變成了private。
能夠將private繼承當作派生類將基類的public,protected成員囊括到派生類，所有做爲派生類的private成員，可是不包括private成員。
private成員是基類內部的隱私，除了友元，全部人員都不得窺探。派生類的友元，都不能訪問

總結：繼承修飾符，就像是一種篩子，將基類的成員篩到派生類。public、protected、private，就是篩子的眼。
經過public繼承，全部基類成員（除了private），public、protected都到了派生類裏面，public篩眼比較大，不會改變訪問權限。
經過protected繼承，全部基類成員（除了private），public、protected都到了派生類裏面，protected篩眼大小適中，全部過來的成員都變成了protected。
經過private繼承，全部基類成員（除了private），public、protected都到了派生類裏面，private篩眼最小，全部過來的成員都變成了private。

#include <iostream>

using namespace std;

class InheritPerission
{
public:
    string public_str;
    void public_func(){std::cout <<"public_func "<<public_str<<std::endl;}
protected:
    string protected_str;
    void protected_func(){std::cout <<"protected_func "<<protected_str<<std::endl;}
private:
    string private_str;
    void private_func(){std::cout <<"private_func "<<private_str<<std::endl;}
};

/*派生類經過public繼承，基類的各類權限不變*/
class InheritPublic : public InheritPerission
{
public:
    InheritPublic(){
        /*派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員*/
        public_str = "public_str";
        protected_str = "protected_str";
        //private_str = "private_str";
        public_func();
        protected_func();
        //private_func(); 
    }
    ~InheritPublic(){};
};

/*派生類經過protected繼承，基類的public成員在派生類中的權限變成了protected 。protected和private不變*/
class InheritProtected : protected InheritPerission
{
public:
    InheritProtected(){
        /*派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員*/
        public_str = "public_str";
        protected_str = "protected_str";
        //private_str = "private_str";
        public_func();
        protected_func();
        //private_func();
    }
    ~InheritProtected(){}
};

/*派生類經過private繼承，基類的全部成員在派生類中的權限變成了private*/
class InheritPrivate : private InheritPerission
{
public:
    InheritPrivate(){
        /*派生類的成員函數，能夠訪問基類的public成員、protected成員，可是沒法訪問基類的private成員*/
        public_str = "public_str";
        protected_str = "protected_str";
        //private_str = "private_str";
        public_func();
        protected_func();
        //private_func();
    }
    ~InheritPrivate(){}
};


int main()
{
    InheritPublic inheritPublic;
    InheritProtected inheritProtected;
    InheritPrivate inheritPrivate;
    
    /*派生類的實例變量，能夠訪問基類的public成員，可是沒法訪問protected、private成員*/
    inheritPublic.public_func();
    //inheritPublic.protected_func();
    //inheritPublic.private_func();
    
    /*派生類的實例變量，沒法訪問基類的任何成員，由於基類的public成員在派生類中變成了protected*/
    //inheritProtected.public_func();
    //inheritProtected.protected_func();
    //inheritProtected.private_func();
    
    /*派生類的實例變量，沒法訪問基類的任何成員，由於基類的全部成員在派生類中變成了private*/
    //inheritPrivate.public_func();
    //inheritPrivate.protected_func();
    //inheritPrivate.private_func();
    
    return 0;
}