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