更新版C++实验二——继承和多态

一、继承访问权限测试

设计类A具有public, protected, private等不同属性的成员函数或变量；类B通过public, protected, private等不同方式继承A，在类B的成员函数中测试访问A的成员函数或变量；
在类B中添加public, protected, private等不同属性的成员函数或变量，在外部测试访问B的各个成员函数或变量；
B以private方式继承A，尝试把A中的部分public成员提升为public。

【继承的格式】

 class 子类名: 继承方式 父类名{
 //子类新增的数据成员和成员函数
 };

继承方式分类：
public ： 公有继承 （重要）
private ： 私有继承
protected ： 保护继承

2 class Base //设置一个父类
3 {
4 public:
5 int a;
6 private:
7 int b;
8 protected:
9 int c;
10 };

public ： 公有继承

12 //设置一个子类
13 class Son:public Base
14 {
15 public:
16 //父类中的public数据 在子类中 也是public
17 //父类中的private数据 在子类中 是不可见的
18 //父类中的protected数据 在子类中 是protected的
19 //子类的内部
20 void showSon()
21 {
22 //b = 200;//不能直接访问
23 c =300;//在子类 内部是可以访问的
24 }
25 };
26
27 void test01()
28 {
29 //子类的外部
30 Son ob;
31 ob.a = 100;
32 cout<<"父类中的public数据a = "<<ob.a<<endl;
33
34 //ob.b = 200;//在子类外 访问不了
35 //ob.c = 200;//在子类外 访问不了
36
37 }

private：保护继承

2 class Son2:private Base
3 {
4 private:
5
6 public:
7 //父类中的public数据 在子类中 也是private
8 //父类中的private数据 在子类中 是不可见的
9 //父类中的protected数据 在子类中 是private的
10 //子类的内部
11 void showbase(){
12 a = 100;//子类内部可访问
13 //b = 200;//不能直接访问
14 c = 300;//子类内部可访问
15 }
16 };
17 void test03()
18 {
19 Son2 ob;
20 //ob.a;//子类外不可访问
21 //ob.b;//子类外不可访问
22 //ob.c;//子类外不可访问
23 }

protected：保护继承

2 class Son1:protected Base
3 {
4 private:
5
6 public:
7 //父类中的public数据 在子类中 也是protected
8 //父类中的private数据 在子类中 是不可见的
9 //父类中的protected数据 在子类中 是protected的
10 //子类的内部
11 void showbase(){
12 a = 100;//子类内部可访问
13 //b = 200;//不能直接访问
14 c = 300;//子类内部可访问
15 }
16 };
17 void test02()
18 {
19 Son1 ob;
20 //ob.a;//子类外不可访问
21 //ob.b;//子类外不可访问
22 //ob.c;//子类外不可访问
23 }

运行结果：通过测试将各种运行结果注释写在代码中了

总结

不管啥继承方式：父类中的私有数据在 子类中不可见

二、友元类继承测试

c++允许 友元 访问 私有数据。
友元的语法：
friend关键字只出现在声明处 其他类、类成员函数、全局函数都可声明为友元 友元函数
不是类的成员，不带this指针 友元函数可访问对象任意成员属性，包括私有属性。
友元类的测试类型有以下三种，以最后一种为主
1、普通全局函数 作为 类的友元
3、一个类整体 作为 另一个类的友元
3、一个类整体 作为 另一个类的友元

#include <iostream>
2
3 using namespace std;
4 class Room;//Room向前声明
5 class GoodGay
6 {
7 public:
8 void visit1(Room &room);//此处的Room 被上方 class Room
9 void visit2(Room &room);
10 };
11
12
13 class Room
14 {
15 //将GoodGay作为Room的友元
16 //GoodGay 所有成员函数 都可以访问 Room私有数据
17 friend class GoodGay;
18 private:
19 string bedRoom;//卧室
20 public:
21 string sittingRoom;//客厅
22 public:
23 Room()
24 {
25 this‐>bedRoom = "卧室";
26 this‐>sittingRoom="客厅";
27 }
28 };
29
30 void GoodGay::visit1(Room &room)
31 {
32 cout<<"好基友visit1访问了你的"<<room.sittingRoom<<endl;
33 cout<<"好基友visit1访问了你的"<<room.bedRoom<<endl;
34 }
35
36 void GoodGay::visit2(Room &room)
37 {
38 cout<<"好基友visit2访问了你的"<<room.sittingRoom<<endl;
39 cout<<"好基友visit2访问了你的"<<room.bedRoom<<endl;
40 }
41
42 int main(int argc, char *argv[])
43 {
44 Room myRoom;
45 GoodGay goodGay;
46
47 goodGay.visit1(myRoom);
48 goodGay.visit2(myRoom);
49
50 return 0;
51 }
52

运行结果：

三、多态性综合运用

一般多态性函数：输入输出参数完全一样，在父类中添加virtual；
特殊多态性函数：输入或输出参数在子类中是父类的指针或基类的引用，在子类中对于的是子类的指针或子类的引用；

概念

多态是c++的特征之一
多态的分类：静态多态（静态联编）、动态多态（动态联编）
静态多态（静态联编）：函数入口地址 是在 编译阶段 确定（运算符重载、函数重载）
动态多态（动态联编）：函数入口地址 是在 运行阶段 确定（虚函数）

这里以虚函数为列子（基类指针、引用 作为函数的参数）

设计如下案列

1 #include <iostream>
2
3 using namespace std;
4 class Base
5 {
6 public:
7 virtual void sleep(void)
8 {
9 cout<<"父亲在睡觉"<<endl;
10 }
11 };
12
13 class Son1:public Base
14 {
15 public:
16 void sleep(void)
17 {
18 cout<<"Son1在安静的睡觉"<<endl;
19 }
20 };
21 class Son2:public Base
22 {
23 public:
24 virtual void sleep(void)
25 {
26 cout<<"Son2在轻度的睡觉"<<endl;
27 }
28 };
29 class Son3:public Base
30 {
31 public:
32 virtual void sleep(void)
33 {
34 cout<<"Son3在雨声般的睡觉"<<endl;
35 }
36 };
37 class Son4:public Base
38 {
39 public:
40 virtual void sleep(void)
41 {
42 cout<<"Son4在鼾声如雷"<<endl;
43 }
44 };
45
46 //以基类指针作为函数的参数 函数可以操作该基类派生出的任意子类对象
47 void sleepFun(Base &ob)
48 {
49 ob.sleep();
50 }
51
52 int main(int argc, char *argv[])
53 {
54 Son1 ob1;
55 Son2 ob2;
56 Son3 ob3;
57 Son4 ob4;
58 sleepFun(ob1);
59 sleepFun(ob2);
60 sleepFun(ob3);
61 sleepFun(ob4);
62 return 0;
63 }
64

运行结果