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;
}