C++三种继承方式下的访问权限控制

       众所周知，C++类中的成员(函数/变量)拥有三种访问权限：

       public:用该关键字修饰的成员表示公有成员，该成员不仅可以在类内可以被访问，在类外也是可以被访问的，是类对外提供的可访问接口；

       private:用该关键字修饰的成员表示私有成员，该成员仅在类内可以被访问，在类体外是隐藏状态；

       protected:用该关键字修饰的成员表示保护成员，保护成员在类体外同样是隐藏状态，但是对于该类的派生类来说，相当于公有成员，在派生类中可以被访问。

       对一个类的派生类来说，在继承基类的过程中，不仅包含了基类的所有成员，还增加了自己的成员，而派生类中成员的访问权限则会因为继承权限方式的不同而不同。

       相对于派生类成员的访问权限比较简单(派生类成员的访问权限就是取决于派生类中定义的权限)，从基类中继承的成员的访问权限就相对较为复杂，这并不是简单地照搬基类的成员访问权限。基类成员在派生类中的访问权限与继承的方式有着密切的关系，在不同的继承方式下，访问权限也是不同的，总结如下：

       若继承方式是public，基类成员在派生类中的访问权限保持不变，也就是说，基类中的成员访问权限，在派生类中仍然保持原来的访问权限；

       若继承方式是private，基类所有成员在派生类中的访问权限都会变为私有(private)权限；

       若继承方式是protected，基类的共有成员和保护成员在派生类中的访问权限都会变为保护(protected)权限，私有成员在派生类中的访问权限仍然是私有(private)权限。

       总结上述规则，可以如下表所示：

       下面我们通过程序实例来理解上述规则。

        1.public继承方式

        程序如下：

#include<iostream>
using namespace std;

class BASE		//基类
{
public:			//基类公有成员
	void BASE_func_1()
	{
		cout << "执行BASE_func_1函数" << endl;
	}
protected:		//基类保护成员
	void BASE_func_2()
	{
		cout << "执行BASE_func_2函数" << endl;
	}
private:		//基类私有成员
	int m_BASE;
};
class A :public BASE			//定义A类，继承base类，public继承方式
{
public:					//派生类公有成员
	void A_func_1()
	{
		BASE_func_2();		//在派生类中可以访问基类的保护成员
		cout << "执行A_func_1函数" << endl;
	}
protected:				//派生类保护成员
	void A_func_2()
	{
		cout << "执行A_func_2函数" << endl;
	}
private:                //派生类私有成员
	int m_A;
};

void main()//主函数
{
    A a;//创建一个派生类对象a
    a.BASE_func_1();//在派生类中调用基类的公有成员
    a.A_func_1();//在派生类中调用派生类的公有成员
    BASE base;//创建一个基类对象base
    base.BASE_func_1();//在基类中调用基类的公有成员
}

        编译执行结果如下：

        可与看到，类A以public方式继承了基类BASE，那么类BASE的所有成员依然保持原有权限，同时在派生类中的访问权限也保持不变，所以类A的对象可以在类体外访问类BASE的公有成员(a.BASE_func_1());，同时类BASE的对象也可以在类体外访问自己的公有成员(base.BASE_func_1())。

        2.private继承方式

        程序如下：

#include<iostream>
using namespace std;

class BASE		//基类
{
public:			//基类公有成员
	void BASE_func_1()
	{
		cout << "执行BASE_func_1函数" << endl;
	}
protected:		//基类保护成员
	void BASE_func_2()
	{
		cout << "执行BASE_func_2函数" << endl;
	}
private:		//基类私有成员
	int m_BASE;
};
class B :private BASE	//定义B类，继承base类，private继承方式
{
public:					//派生类公有成员
	void B_func_1()
	{
		BASE_func_1();		//在派生类中可以访问基类的公有成员
		BASE_func_2();		//在派生类中可以访问基类的访问成员
		cout << "执行B_func_1函数" << endl;
	}
protected:				//派生类保护成员
	void B_func_2()
	{
		cout << "执行B_func_2函数" << endl;
	}
private:                		//派生类私有成员
	int m_B;
};

void main()//主函数
{
	B b;//创建一个派生类对象b
	b.B_func_1();//在派生类中调用派生类的公有成员
	BASE base;//创建一个基类对象base
	base.BASE_func_1();//在基类中调用基类的公有成员
}

        编译执行结果如下：

        可与看到，类B以private方式继承了基类BASE，那么类BASE的所有成员在派生类中的访问权限都将变成私有权限，所以类B的对象不可以在类体外访问类BASE的公有成员，只能在类体外方位类B自己的公有对象(b.B_func_1())。

        和public继承不同的一点是，派生类将不可以在类体外访问基类的公有成员，我们可以尝试在上述程序中的主函数里添加一行：

void main()//主函数
{
	B b;//创建一个派生类对象b
	b.B_func_1();//在派生类中调用派生类的公有成员
	BASE base;//创建一个基类对象base
	base.BASE_func_1();//在基类中调用基类的公有成员
	b.BASE_func_1();//在派生类中调用基类的公有成员
}

          如果尝试编译该程序的话，则会报出如下错误：      

       可以看到，报出的错误提示“因为B使用private方式继承，所欲BASE::BASE_func_1不可访问”。从而可以，在private方式继承下，类BASE的公有成员在派生类B中成为了私有成员，根据类的访问规则，私有成员是不能在类体外被访问的。

        3.protected继承方式

        程序如下：

#include<iostream>
using namespace std;

class BASE		//基类
{
public:			//基类公有成员
	void BASE_func_1()
	{
		cout << "执行BASE_func_1函数" << endl;
	}
protected:		//基类保护成员
	void BASE_func_2()
	{
		cout << "执行BASE_func_2函数" << endl;
	}
private:		//基类私有成员
	int m_BASE;
};
class C :protected BASE	//定义C类，继承BASE类，protected继承方式
{
public:					//派生类公有成员
	void C_func_1()
	{
		BASE_func_1();		//在派生类中可以访问基类的公有成员
		BASE_func_2();		//在派生类中可以访问基类的访问成员
		cout << "执行C_func_1函数" << endl;
	}
protected:				//派生类保护成员
	void C_func_2()
	{
		cout << "执行C_func_2函数" << endl;
	}
private:                		//派生类私有成员
	int m_C;
};

void main()//主函数
{
	C c;//创建一个派生类对象c
	c.C_func_1();//在派生类中调用派生类的公有成员
	BASE base;//创建一个基类对象base
	base.BASE_func_1();//在基类中调用基类的公有成员
}

        编译执行结果如下：

       从结果上看，protected继承方式和private方式是相同的，不过和private继承方式不同的一点是，当采用protected继承方式时，在派生类中，基类的公有成员和保护成员的使 用权限将是protected，不再是private，也就是说，当再有一个类D继承C类时，D类可以继续在类内调用C类的公有成员和保护成员，但是在private继承方式下，这将是错误的。

       简单总结来说，public继承方式是最简单的，也是最常用的一种继承方式；private方式是使用最少的一种方式，因为权限太低；protected方式在实际使用过程中，常用于多重继承的情况。大家在实际使用过程中需要多注意和区分。