您的位置:首页 > 编程语言 > C语言/C++

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

2017-09-30 14:38 190 查看
实验一:

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成员将无法被访问
内容来自用户分享和网络整理,不保证内容的准确性,如有侵权内容,可联系管理员处理 点击这里给我发消息
标签: