C++中關於public、protect、private的訪問許可權控制
一：成員的訪問許可權 1: public訪問許可權 一個類的public成員變數、成員函式，可以通過類的成員函式、類的例項變數進行訪問 <實際上，類的成員函式，可以訪問本類內的任何成員變數和成員函式> x
#include<iostream> #include<string> using namespace std; class AccessTest { public: int pub_mem; int pub_fun(){}; protected: int prot_mem; int prot_fun(){}; private: int priv_memb; int priv_fun(){}; }; int main() { AccessTest at; at.pub_mem; //OK, 類變數可以訪問public成員 at.pub_func(); //OK, 訪問public成員函式是沒有問題的 return 0; }
2：protected訪問許可權
一個類的protected成員變數、成員函式，無法通過類的例項變數進行訪問。但是可以通過類的友元函式、友元類進行訪問。
#include<string> #include<iostream> using namespace std; class AccessTest { friend void Atest(); friend class CAtest; public: int pub_mem; void pub_fun(){} protected: int prot_mem; void prot_fun(){} private: int priv_memb; void priv_fun(){} }; class CAtest { public: void x() { AccessTest t; t.prot_fun(); //OK,友元類可以訪問protected成員函式 int x=t.prot_mem; //OK,友元類可以訪問protected成員變數 } }; void Atest() { AccessTest t; t.prot_fun(); //OK,友元函式可以訪問protected成員函式 int x=t.prot_mem; //OK,友元函式可以訪問protected成員變數 } int main() { AccessTest at; at.prot_mem; //ERROR,類例項變數無法訪問protected成員變數 at.prot_fun(); //ERROR,類例項變數無法訪問protected成員函式 Atest(); return 0; }
3：private訪問許可權 一個類的private成員變數、成員函式，無法通過類的例項變數進行訪問。但是可以通過類的友元函式、友元類進行訪問。
#include<iostream> #include<string> using namespace std; class AccessTest { friend void Atest(); friend class CAtest; public: int pub_mem; void pub_fun(){} protected: int prot_mem; void prot_fun(){} private: int priv_memb; void priv_fun(){} }; class CAtest { public: void x() { AccessTest t; t.priv_fun(); //OK,友元類可以訪問private成員函式 int x=t.priv_memb; //OK,友元類可以訪問private成員變數 } }; void Atest() { AccessTest t; t.priv_fun(); //OK,友元函式可以訪問private成員函式 int x=t.priv_memb; //OK,友元函式可以訪問private成員變數 } int main() { AccessTest at; at.priv_memb; //ERROR,類例項變數無法訪問private成員變數 at.priv_fun(); //ERROR,類例項變數無法訪問private成員函式 Atest(); return 0; }
到現在，是否感覺私有訪問屬性，和保護屬性沒有什麼區別？區別主要體現在繼承上面。下面將會講到。
總結：public在任何地方都能訪問，protected只能在派生類中訪問， private只能在友元中訪問。
二：繼承的訪問許可權控制 1：public繼承 派生類通過public繼承，基類的各種許可權不變 。 派生類的成員函式，可以訪問基類的public成員、protected成員，但是無法訪問基類的private成員。 派生類的例項變數，可以訪問基類的public成員，但是無法訪問protected、private成員，彷彿基類的成員之間加到了派生類一般。 可以將public繼承看成派生類將基類的public,protected成員囊括到派生類，但是不包括private成員。
#include<iostream>
#include<string>
using namespace std;
class AccessTest
{
public:
int pub_mem;
void pub_fun(){}
protected:
int prot_mem;
void prot_fun(){}
private:
int priv_memb;
void priv_fun(){}
};
class DAccessTest:public AccessTest
{
public:
void test()
{
int x=pub_mem; //OK
pub_fun(); //OK
int y=prot_mem; //OK
prot_fun(); //OK
int z=priv_memb; //ERROR
priv_fun(); //ERROR
}
};
int main()
{
DAccessTest dt;
int x=dt.pub_mem; //OK
int y=dt.prot_mem; //ERROR
int z=dt.priv_memb; //ERROR
return 0;
}2：protected繼承 派生類通過protected繼承，基類的public成員在派生類中的許可權變成了protected 。protected和private不變。 派生類的成員函式，可以訪問基類的public成員、protected成員，但是無法訪問基類的private成員。 派生類的例項變數，無法訪問基類的任何成員，因為基類的public成員在派生類中變成了protected。 可以將protected繼承看成派生類將基類的public,protected成員囊括到派生類，全部作為派生類的protected成員，但是不包括private成員。 private成員是基類內部的隱私，除了友元，所有人員都不得窺探。派生類的友元，都不能訪問
#include<iostream>
#include<string>
using namespace std;
class AccessTest
{
friend void Atest();
friend class CAtest;
public:
int pub_mem;
void pub_fun(){}
protected:
int prot_mem;
void prot_fun(){}
private:
int priv_memb;
void priv_fun(){}
};
class DAccessTest:protected AccessTest
{
public:
void test()
{
int x=pub_mem; //OK
pub_fun(); //OK
int y=prot_mem; //OK
prot_fun(); //OK
int z=priv_memb; //ERROR
priv_fun(); //ERROR
}
};
int main()
{
DAccessTest dt;
int x=dt.pub_mem; //ERROR，基類的成員現在是派生類的保護成員
int y=dt.prot_mem; //ERROR，基類的成員現在是派生類的保護成員
int z=dt.priv_memb; //ERROR
return 0;
}3：private繼承 派生類通過private繼承，基類的所有成員在派生類中的許可權變成了private。 派生類的成員函式，可以訪問基類的public成員、protected成員，但是無法訪問基類的private成員。 派生類的例項變數，無法訪問基類的任何成員，因為基類的所有成員在派生類中變成了private。 可以將private繼承看成派生類將基類的public,protected成員囊括到派生類，全部作為派生類的private成員，但是不包括private成員。 private成員是基類內部的隱私，除了友元，所有人員都不得窺探。派生類的友元，都不能訪問
#include<iostream>
#include<string>
using namespace std;
class AccessTest
{
friend void Atest();
friend class CAtest;
public:
int pub_mem;
void pub_fun(){}
protected:
int prot_mem;
void prot_fun(){}
private:
int priv_memb;
void priv_fun(){}
};
class DAccessTest:private AccessTest
{
public:
void test()
{
int x=pub_mem; //OK
pub_fun(); //OK
int y=prot_mem; //OK
prot_fun(); //OK
int z=priv_memb; //ERROR
priv_fun(); //ERROR
}
};
int main()
{
DAccessTest dt;
int x=dt.pub_mem; //ERROR，基類的成員現在是派生類的私有成員
int y=dt.prot_mem; //ERROR，基類的成員現在是派生類的私有成員
int z=dt.priv_memb; //ERROR, private成員無法訪問
return 0;
}總結：繼承修飾符，就像是一種篩子，將基類的成員篩到派生類。public、protected、private，就是篩子的眼。 通過public繼承，所有基類成員（除了private），public、protected都到了派生類裡面，public篩眼比較大，不會改變訪問許可權。 通過protected繼承，所有基類成員（除了private），public、protected都到了派生類裡面，protected篩眼大小適中，所有過來的成員都變成了protected。 通過private繼承，所有基類成員（除了private），public、protected都到了派生類裡面，private篩眼最小，所有過來的成員都變成了private。 PS:關於class和struct的區別 1：class不寫修飾符，成員預設是private的，而struct 預設是public的
class Base //預設private
{
int a;
int b;
}
Base ba;
int x=ba.a;//錯誤
int y=ba.b;//錯誤
struct St //預設public
{
int a;
int b;
}；
St st;
int x=st.a; //OK
int y=st.b;//OK2:class的繼承預設是private的，而struct預設是public的
class Base{...};
class Derive:Base{...} //private繼承
struct BStruct{...};
struct DStruct:BStruct{...};//public繼承原文：https://blog.csdn.net/ycf74514/article/details/49053041