C++ 继承与派生的访问性

最新推荐文章于 2022-09-20 16:39:25 发布

WQ_1996

最新推荐文章于 2022-09-20 16:39:25 发布

阅读量392

点赞数

CC 4.0 BY-SA版权

分类专栏：新手日常

本文链接：https://blog.youkuaiyun.com/WQ_1996/article/details/78142555

新手日常专栏收录该内容

11 篇文章

订阅专栏

本文通过五个实验详细探讨了C++中不同继承方式(public、private、protected)对基类成员访问的影响。实验证明，public继承使基类的public成员在派生类中保持public，而private和protected成员保持原有属性；private继承使所有成员变为private；protected继承则使public和protected成员变为protected。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

实验一：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class cPerson
 5 {
 6 public:
 7     int a;
 8     cPerson()     //定义构造函数，初始化成员变量
 9     {
10         a=1;
11         b=2;
12         c=3;
13     }
14 private:
15     int b;
16 protected:
17     int c;
18 };
19 
20 class cPeople : public cPerson   //定义cPeople类，继承cPerson类,继承方式：公共
21 {                              
22 public:
23     void PrintVal();
24 
25 };
26 
27 void main()
28 {
29     cPeople p;
30     cout<<p.a<<endl;    //正确，可访问
31     cout<<p.b<<endl;    //错误，无法访问
32     cout<<p.c<<endl;    //错误，无法访问
33 }

实验二：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class cPerson
 5 {
 6 public:
 7     int a;
 8     cPerson()     //定义构造函数，初始化成员变量
 9     {
10         a=1;
11         b=2;
12         c=3;
13     }
14 private:
15     int b;
16 protected:
17     int c;
18 };
19 
20 class cPeople : private cPerson   //定义cPeople类，继承cPerson类，继承方式：私有
21 {
22 public:
23     void PrintVal();
24 
25 };
26 
27 void main()
28 {
29     cPeople p;
30     cout<<p.a<<endl;    //错误，无法访问
31     cout<<p.b<<endl;    //错误，无法访问
32     cout<<p.c<<endl;    //错误，无法访问
33 }

实验三：

 1 #include <iostream>
 2 using namespace std;
 3 
 4 class cPerson
 5 {
 6 public:
 7     int a;
 8     cPerson()     //定义构造函数，初始化成员变量
 9     {
10         a=1;
11         b=2;
12         c=3;
13     }
14 private:
15     int b;
16 protected:
17     int c;
18 };
19 
20 class cPeople : protected cPerson   //定义cPeople类，继承cPerson类，继承方式：保护
21 {
22 public:
23     void PrintVal();
24 
25 };
26 
27 void main()
28 {
29     cPeople p;
30     cout<<p.a<<endl;    //错误，无法访问
31     cout<<p.b<<endl;    //错误，无法访问
32     cout<<p.c<<endl;    //错误，无法访问
33 }

总结一（粗判定）：上述三个实验分别测试了继承的三个派生类别：public,private,protected

　　　　派生类别一：public：此种情形下，基类中的public成员在派生类别中也为public属性，是可以被外部访问的，但是基类中的private,protected成员在派生类别中的属性并没有改变

　　　　派生类别二：private:此种类型下，基类中的public,private,protected成员在派生类中均为private属性，无法被外部访问

　　　　派生类别三：protected:此种类型下，基类中的public,protected成员在派生类中也为protected属性，只能被派生类的派生类访问，不可以直接被类外对象访问。但是基类中的private成员在派生类中仍然为私有

实验四：

#include <iostream>
using namespace std;

class cPerson
{
public:
	int a;
	cPerson()     //定义构造函数，初始化成员变量
	{
		a=1;
		b=2;
		c=3;
	}
private:
	int b;
protected:
	int c;
};

class cPeople : public cPerson   //定义cPeople类，继承cPerson类，继承方式：public
{
public:
	void PrintVal()
	{
		cout<<a<<endl;  //正确，可以访问
		cout<<b<<endl;  //错误，无法访问
		cout<<c<<endl;  //正确，可以访问
	}
};

void main()
{
	cPeople p;
	p.PrintVal();      //error,无法访问private成员
}

实验五：

#include <iostream>
using namespace std;

class cPerson
{
public:
	int a;
	cPerson()     //定义构造函数，初始化成员变量
	{
		a=1;
		b=2;
		c=3;
	}
private:
	int b;
protected:
	int c;
};

class cPeople : private cPerson   //定义cPeople类，继承cPerson类，继承方式：private
{
public:
	void PrintVal()
	{
		cout<<a<<endl;  //正确，可以访问
		cout<<b<<endl;  //错误，无法访问
		cout<<c<<endl;  //正确，可以访问
	}
};

class cMan : public cPeople      //定义cMan类，继承cPeople类，继承方式：public
{
public:
	void PrintVal()
	{
		cout<<a<<endl;     //错误，无法访问
	}
};
void main()
{
	cMan p;
	p.PrintVal();      //error,无法访问private成员
}

总结二：

	上述两个实验（实验四、五）测试了在派生类别的定义中访问基类成员的有效性

	一、当派生类别为public时，可以在派生类别的定义中访问基类中的public和protected成员，但是无法访问private成员

		        这也证实了protected成员的特性：可被派生类别访问

	二、当派生类别为private时，访问性同上，但是此时基类中的public成员在派生类中变为了private，若再次继承派生类，则基类中原来的

	      public成员将无法被访问