2021-03-12-C++学习之10-类和对象-多态

一、多态的基本语法
多态分为两类：

静态多态：函数重载和运算符重载属于静态多态，复用函数名
动态多态：派生类和虚函数实现运行时多态

二者区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

代码测试1：

#include<iostream>
using namespace std;
#include<string>//多态
//动物类
class Animal
{public:void speak(){cout << "动物在说话" << endl;}
};
//猫类
class Cat :public Animal
{public:void speak(){cout << "小猫在说话" << endl;}
};
//执行说话
//Animal &animal = cat
//C++中允许父子类之间的转换
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定
void doSpeak(Animal &animal)
{animal.speak(); //将会输出 动物在说话
}
void test01()
{Cat cat;doSpeak(cat);
}int main()
{test01();system("pause");return 0;
}

代码测试2：

#include<iostream>
using namespace std;
#include<string>//多态
//动物类
class Animal
{public://虚函数，可以实现地址晚绑定virtual void speak(){cout << "动物在说话" << endl;}
};
//猫类
class Cat :public Animal
{public://重写：函数返回值类型 函数名 参数列表 完全相同//子类重写的父类函数前面的virtual可写可不写，没有影响virtual void speak(){cout << "小猫在说话" << endl;}
};
class Dog :public Animal
{void speak(){cout << "小狗在说话" << endl;}
};
//执行说话
//Animal &animal = cat
//C++中允许父子类之间的转换
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定//动态多态满足条件
//1、有继承关系
//2、子类要重写父类的虚函数//动态多态使用
//父类的指针或者引用 指向子类对象 Animal &animal = catvoid doSpeak(Animal &animal)
{animal.speak(); //若不是虚函数将会输出 动物在说话
}
void test01()
{Cat cat;doSpeak(cat);Dog dog;doSpeak(dog);
}int main()
{test01();system("pause");return 0;
}

输出：

小猫在说话
小狗在说话
请按任意键继续. . .

总结：
动态多态满足条件：
1、有继承关系
2、子类要重写父类的虚函数
动态多态使用条件：
父类的指针或者引用指向子类对象
重写：函数返回值类型函数名参数列表完全相同

二、多态的原理剖析
当子类重写父类的虚函数时，子类中的虚函数表内部会替换成子类的虚函数地址
代码：

#include<iostream>
using namespace std;
#include<string>//多态
//动物类
class Animal
{public://虚函数，可以实现地址晚绑定virtual void speak(){cout << "动物在说话" << endl;}
};
//猫类
class Cat :public Animal
{public://重写：函数返回值类型 函数名 参数列表 完全相同//子类重写的父类函数前面的virtual可写可不写，没有影响void speak(){cout << "小猫在说话" << endl;}
};
class Dog :public Animal
{void speak(){cout << "小狗在说话" << endl;}
};
//执行说话
//Animal &animal = cat
//C++中允许父子类之间的转换
//地址早绑定，在编译阶段确定函数地址
//如果想执行让猫说话，那么这个函数地址就不能提前绑定，需要在运行阶段进行绑定//动态多态满足条件
//1、有继承关系
//2、子类要重写父类的虚函数//动态多态使用
//父类的指针或者引用 指向子类对象 Animal &animal = catvoid doSpeak(Animal &animal)
{animal.speak(); //若不是虚函数将会输出 动物在说话
}
void test01()
{Cat cat;doSpeak(cat);Dog dog;doSpeak(dog);
}
void test02()
{//当父类的函数不是虚函数（没有加virtual）时，//是一个空类，因为里面只有一个非静态成员函数，内存大小为1个字节//当父类的函数是虚函数（加virtual）时，内存大小为4个字节//此时是指针类型（所有指针所占内存均为4个字节）cout << "sizeof(Animal) = " << sizeof(Animal) << endl;
}int main()
{test01();test02();system("pause");return 0;
}

父类的结构：

当子类 Cat 没有重写父类的额 speak()函数时，子类的结构为;

当子类 Cat 没有重写父类的额 speak()函数时，子类Cat 的结构为;

三、多态案例 – 计算器类
案例描述：
分别用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
代码测试：

#include<iostream>
using namespace std;
#include<string>//普通写法实现计算器
class Calculate
{public:int getResult(string oper){if (oper == "+"){return m_Num1 + m_Num2;}else if (oper == "-"){return m_Num1 - m_Num2;}else if (oper == "*"){return m_Num1 * m_Num2;}//如果想扩展新的功能，需要修改源码//在真实开发中，提倡 开闭原则//开闭原则：对扩展进行开发，对修改进行关闭}int m_Num1;int m_Num2;
};
void test01()
{Calculate c;c.m_Num1 = 10;c.m_Num2 = 10; cout << c.m_Num1 << " + " << c.m_Num2 << " = " << c.getResult("+") << endl;cout << c.m_Num1 << " - " << c.m_Num2 << " = " << c.getResult("-") << endl;cout << c.m_Num1 << " * " << c.m_Num2 << " = " << c.getResult("*") << endl;
}//利用多态实现计算器
//多态的好处：
//1、层次结构清晰，立马定位出错地方
//2、可读性强
//3、对于前期和后期扩展以及维护性高//实现计算器抽象类
class AbstractCalculate
{public:virtual int getResult(){return 0;}int m_Num1;int m_Num2;
};
//加法计算器类
class AddCalculate :public AbstractCalculate
{int getResult(){return m_Num1 + m_Num2;}
};
//减法计算器类
class SubCalculate :public AbstractCalculate
{int getResult(){return m_Num1 - m_Num2;}
};
//乘法计算器类
class MulCalculate :public AbstractCalculate
{int getResult(){return m_Num1 * m_Num2;}
};
void test02()
{//多态使用条件//父类指针或者引用指向子类对象//加法运算//堆区数据需要手动开辟、手动释放AbstractCalculate* abc = new AddCalculate;abc->m_Num1 = 100;abc->m_Num2 = 100;cout << abc->m_Num1 << " + " << abc->m_Num2 << " = " << abc->getResult() << endl;//用完后记得销毁delete abc;//减法abc = new SubCalculate;abc->m_Num1 = 200;abc->m_Num2 = 100;cout << abc->m_Num1 << " - " << abc->m_Num2 << " = " << abc->getResult() << endl;delete abc;//乘法abc = new MulCalculate;abc->m_Num1 = 200;abc->m_Num2 = 100;cout << abc->m_Num1 << " * " << abc->m_Num2 << " = " << abc->getResult() << endl;delete abc;
}int main()
{cout << "test01() run ... " << endl;test01();cout << endl << "test02() run ... " << endl;test02();system("pause");return 0;
}

输出：

test01() run ...
10 + 10 = 20
10 - 10 = 0
10 * 10 = 100test02() run ...
100 + 100 = 200
200 - 100 = 100
200 * 100 = 20000
请按任意键继续. . .

四、纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容。
因此可以将虚函数改为纯虚函数
纯虚函数语法：virtual 返回值类型函数名 () = 0;
当类中有纯虚函数，这个类也称为抽象类
抽象类特点：
- 无法实例化对象
- 子类必须重写抽象类中的纯虚函数，否则也属于抽象类。

代码测试：

#include<iostream>
using namespace std;
#include<string>class Base
{public://纯虚函数//只要有一个纯虚函数，这个类称为抽象类//抽象类特点：//1、无法实例化对象//2、抽象类的子类 必须要重写父类中的纯虚函数，否则也属于抽象类virtual void func() = 0;
};
class Son :public Base
{public:virtual void func(){cout << "Son func() 调用" << endl;}
};
void test01()
{//Base b;//抽象类无法实例化对象//new Base;//抽象类无法实例化对象//Son s;//子类没有重写父类中的纯虚函数，也是抽象类，无法实例化对象Son s;//子类已经重写父类的纯虚函数Base* base = new Son;base->func();
}int main()
{cout << "test01() run ... " << endl;test01();system("pause");return 0;
}

输出：

test01() run ...
Son func() 调用
请按任意键继续. . .

五、多态案例 – 制作饮品

制作饮品的大致流程：注水 - 冲泡 - 倒入杯中 - 加入辅料。
利用多态技术实现本案例，提供抽象饮品基类，提供子类制作咖啡和茶叶。

代码测试：

#include<iostream>
using namespace std;
#include<string>//制作饮品
class AbstractDrinking
{public://煮水virtual void Boil() = 0;//冲泡virtual void Brew() = 0;//倒入杯中virtual void PourInCup() = 0;//加入辅助佐料virtual void PutSomething() = 0;//制作饮品void makeDrink(){Boil();Brew();PourInCup();PutSomething();}
};
//制作咖啡
class Coffee :public AbstractDrinking
{public:virtual void Boil(){cout << "煮农夫山泉" << endl;}virtual void Brew(){cout << "冲泡咖啡" << endl;}virtual void PourInCup(){cout << "倒入杯中" << endl;}virtual void PutSomething(){cout << "加入糖和牛奶" << endl;}
};
//制作茶叶
class Tea :public AbstractDrinking
{public:virtual void Boil(){cout << "煮矿泉水" << endl;}virtual void Brew(){cout << "冲泡茶叶" << endl;}virtual void PourInCup(){cout << "倒入杯中" << endl;}virtual void PutSomething(){cout << "加入枸杞" << endl;}
};
//制作函数
void doWork(AbstractDrinking *abs)
{abs->makeDrink();delete abs;
}void test01()
{//制作咖啡doWork(new Coffee);cout << "-------------------" << endl;//制作茶叶doWork(new Tea);
}int main()
{cout << "test01() run ... " << endl;test01();system("pause");return 0;
}

输出：

test01() run ...
煮农夫山泉
冲泡咖啡
倒入杯中
加入糖和牛奶
-------------------
煮矿泉水
冲泡茶叶
倒入杯中
加入枸杞
请按任意键继续. . .

六、虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码。
解决方式：将父类中的析构函数改为虚析构或者纯虚析构
虚析构和纯虚析构共性：
- 可以解决父类指针释放子类对象
- 都需要有具体的函数实现
虚析构和纯虚析构区别：
- 如果是纯虚析构，该类属于抽象类，无法实例化对象
- 如果是虚析构，可以实例化对象
虚析构语法：
- virtual ~类名() {}
纯虚析构语法：
- virtual ~类名() = 0;

代码测试1：

#include<iostream>
using namespace std;
#include<string>//虚析构和纯虚析构
class Animal
{public:Animal(){cout << "Animal 构造函数调用" << endl;}//纯虚函数virtual void speak() = 0;~Animal(){cout << "Animal 析构函数调用" << endl;}};
class Cat :public Animal
{public:Cat(string name){cout << "Cat 构造函数调用" << endl;m_Name = new string(name); //接收堆区创建的对象}virtual void speak(){cout << *m_Name << "小猫在说话" << endl;}string* m_Name;//创建在堆区~Cat(){cout << "Cat 析构函数调用" << endl;if (m_Name != NULL){delete m_Name;m_Name = NULL;}}
};void test01()
{//多态的使用条件：父类的指针指向子类的对象Animal* animal = new Cat("Tom");animal->speak();delete animal; //手动释放堆区内存
}int main()
{cout << "test01() run ... " << endl;test01();system("pause");return 0;
}

输出：

test01() run ...
Animal 构造函数调用
Cat 构造函数调用
Tom小猫在说话
Animal 析构函数调用
请按任意键继续. . .

发现没有调用 Cat 子类析构代码。
利用虚析构可以解决父类指针释放子类对象时不干净的问题：
代码测试2：

#include<iostream>
using namespace std;
#include<string>//虚析构和纯虚析构
class Animal
{public:Animal(){cout << "Animal 构造函数调用" << endl;}//纯虚函数virtual void speak() = 0;virtual ~Animal(){cout << "Animal 析构函数调用" << endl;}};
class Cat :public Animal
{public:Cat(string name){cout << "Cat 构造函数调用" << endl;m_Name = new string(name); //接收堆区创建的对象}virtual void speak(){cout << *m_Name << "小猫在说话" << endl;}string* m_Name;//创建在堆区~Cat(){cout << "Cat 析构函数调用" << endl;if (m_Name != NULL){delete m_Name;m_Name = NULL;}}
};void test01()
{//多态的使用条件：父类的指针指向子类的对象Animal* animal = new Cat("Tom"); //父类指针指向了子类的堆区数据animal->speak();//父类指针在析构时，不会调用子类中的析构函数，//导致子类如果有堆区属性，会出现内存泄露delete animal; //手动释放堆区内存，执行改行代码后调用父类的析构函数cout << "delete animal" << endl;
}int main()
{cout << "test01() run ... " << endl;test01();system("pause");return 0;
}

输出：

test01() run ...
Animal 构造函数调用
Cat 构造函数调用
Tom小猫在说话
Cat 析构函数调用
Animal 析构函数调用
delete animal
请按任意键继续. . .

纯虚析构代码测试：

#include<iostream>
using namespace std;
#include<string>//虚析构和纯虚析构
class Animal
{public:Animal(){cout << "Animal 构造函数调用" << endl;}//纯虚函数virtual void speak() = 0;//虚析构/*virtual ~Animal(){cout << "Animal 虚析构函数调用" << endl;}*///纯虚析构，必须需要代码进行实现，否则报错//这只是析构代码的声明，并没有进行实现//纯虚析构 需要声明 也需要实现//有了纯虚析构之后，这个类也属于抽象类，无法实现实例化对象virtual ~Animal() = 0;
};
//父类纯虚析构代码的具体实现
Animal::~Animal()
{cout << "Animal 纯虚析构函数调用" << endl;
}class Cat :public Animal
{public:Cat(string name){cout << "Cat 构造函数调用" << endl;m_Name = new string(name); //接收堆区创建的对象}virtual void speak(){cout << *m_Name << "小猫在说话" << endl;}string* m_Name;//创建在堆区~Cat(){cout << "Cat 析构函数调用" << endl;if (m_Name != NULL){delete m_Name;m_Name = NULL;}}
};void test01()
{//多态的使用条件：父类的指针指向子类的对象Animal* animal = new Cat("Tom"); //父类指针指向了子类的堆区数据animal->speak();//父类指针在析构时，不会调用子类中的析构函数，//导致子类如果有堆区属性，会出现内存泄露delete animal; //手动释放堆区内存，执行改行代码后调用父类的析构函数cout << "delete animal" << endl;
}int main()
{cout << "test01() run ... " << endl;test01();system("pause");return 0;
}

输出：

test01() run ...
Animal 构造函数调用
Cat 构造函数调用
Tom小猫在说话
Cat 析构函数调用
Animal 纯虚析构函数调用
delete animal
请按任意键继续. . .

总结：
- 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象
- 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构
- 拥有纯虚析构函数的类也属于抽象类，不能实例化对象

七、案例三 - 电脑组装需求分析
案例描述：

代码实现：

#include<iostream>
using namespace std;
#include<string>//抽象不同零件类
//抽象CPU类
class CPU
{public:virtual void calculate() = 0;
};
//抽象显卡类
class VideoCard
{public:virtual void display() = 0;
};
//抽象内存条类
class Memory
{public:virtual void storage() = 0;
};//电脑类
class Computer
{public:Computer(CPU *cpu,VideoCard *vc,Memory * memo){m_cpu = cpu;m_memo = memo;m_vc = vc;}//提供工作的函数void work(){m_cpu->calculate();m_memo->storage();m_vc->display();}//提供析构函数 释放堆区的3个电脑零件~Computer(){cout << "Computer 析构代码执行" << endl;if (m_cpu != NULL){delete m_cpu;m_cpu = NULL;}if (m_memo != NULL){delete m_memo;m_memo = NULL;}if (m_vc != NULL){delete m_vc;m_vc = NULL;}}private:CPU* m_cpu;//CPU的零件指针VideoCard* m_vc;//显卡零件指针Memory* m_memo;//内存条指针
};//具体厂商
//实现Intel厂商
class IntelCPU :public CPU
{public:virtual void calculate(){cout << "Intel的CPU开始计算了！" << endl;}
};
class IntelVideoCard :public VideoCard
{public:virtual void display(){cout << "Intel的显卡开始显示了！" << endl;}
};
class IntelMemory :public Memory
{public:virtual void storage(){cout << "Intel的内存条开始存储了！" << endl;}
};
//实现联想厂商
class LenovoCPU :public CPU
{public:virtual void calculate(){cout << "Lenovo的CPU开始计算了！" << endl;}
};
class LenovoVideoCard :public VideoCard
{public:virtual void display(){cout << "Lenovo的显卡开始显示了！" << endl;}
};
class LenovoMemory :public Memory
{public:virtual void storage(){cout << "Lenovo的内存条开始存储了！" << endl;}
};
//测试组装不同的电脑
void test01()
{//第一台电脑零件cout << "-----------第一台电脑开始工作-----------" << endl;CPU* intelCpu = new IntelCPU;VideoCard* intelCard = new IntelVideoCard;Memory* intelMem = new IntelMemory;//创建第一台电脑//父类指向子类的对象Computer * computer1 = new Computer(intelCpu, intelCard, intelMem);computer1->work();delete computer1;//第二台电脑组装//第二台电脑零件cout << endl << "-----------第二台电脑开始工作-----------" << endl;CPU* lenovoCpu = new LenovoCPU;VideoCard* lenovoCard = new LenovoVideoCard;Memory* lenovoMem = new LenovoMemory;//创建第二台电脑//父类指向子类的对象Computer* computer2 = new Computer(lenovoCpu, lenovoCard, lenovoMem);computer2->work();delete computer2;//第三台电脑组装//第三台电脑零件cout << endl << "-----------第三台电脑开始工作-----------" << endl;//创建第二台电脑//父类指向子类的对象Computer* computer3 = new Computer(new LenovoCPU, new IntelVideoCard, new LenovoMemory);computer3->work();delete computer3;}int main()
{test01();system("pause");return 0;
}

输出：

-----------第一台电脑开始工作-----------
Intel的CPU开始计算了！
Intel的内存条开始存储了！
Intel的显卡开始显示了！
Computer 析构代码执行-----------第二台电脑开始工作-----------
Lenovo的CPU开始计算了！
Lenovo的内存条开始存储了！
Lenovo的显卡开始显示了！
Computer 析构代码执行-----------第三台电脑开始工作-----------
Lenovo的CPU开始计算了！
Lenovo的内存条开始存储了！
Intel的显卡开始显示了！
Computer 析构代码执行
请按任意键继续. . .

2021-03-12-C++学习之10-类和对象-多态相关推荐

【人工智能项目】深度学习实现10类猴子细粒度识别
[人工智能项目]深度学习实现10类猴子细粒度识别任务说明本次比赛需要选手准确识别10种猴子,数据集只有图片,没有boundbox等标注数据. 环境说明 !nvidia-smi Fri Mar 27 ...
Python学习笔记（类与对象）
Python学习笔记 (类与对象) 1.类与对象面向对象编程语言类: 一个模板, (人类)-是一个抽象的, 没有实体的对象: (eg: 张三, 李四) 属性: (表示这类东西的特征, 眼睛, 嘴巴, ...
python学习day2：类与对象
类与对象一.内置函数 1.int方法 (1)def__add__(self, y): #两数相加 """ x.__add__(y) <==> x ...
Python学习9 面向对象类和对象
面向对象和面向过程类和对象类的设计类的创建 self:相当于当前对象:类似于Java中的this 类的创建和使用: #类的命名:每个单词首字母大写 class Dog:#属性name = 'do ...
Head First Java学习笔记(2):类与对象
类 1.类是定义同一类所有对象的变量和方法的蓝图或原型. 2.实例变量的值由类的每个实例提供.当创建类的实例时,就创建了这种类型的一个对象,然后系统为类定义的实例变量分配内存.然后可以调用对象的实例方 ...
java 由接口构造对象_Java学习笔记04——类和对象|抽象和接口|构造方法与继承...
六.Java类 1. Java中用关键字class来创建类. 2. 类中属性和方法称为类的成员;类的声明和方法要在同一个文件内,不同于C++. 3. 类的定义: [] class [extend ...
一个编程小白的Java SE学习日志 V——类、对象【极客BOY-米奇】
文章目录前言(转载请说明作者!)3.18~3.25编写观看前自问面向对象实现过程面向对象三大特性封装继承多态如何理解类与对象(实例)的关系? 现实理解如何理解对象? 现实理解任务导 ...
Java学习笔记_类和对象
·类:是一组相关属性和行为的集合,可以看成是一类事务的模板,使用事物的属性特征和行为特征来描述该类事物. ·属性:该事物的状态信息 ·行为:就是该事物能够做什么 ·对象:一类事物的具体体现,对象是类的 ...
python创建person类用printinfo方法_Python学习期刊Day11类和对象（2）,日记,与,下
今天是2020年2月20日,晴,6~14℃ 一.继承继承是一种创建新类的方式.新建类将获得原有类的所有属性和方法.原有的类称为父类(超类),新建的类称为子类. Python中继承的方式如下: ''' ...
Python学习 Day31 JS类数组对象
JS类数组对象一.三元运算符概述:三元运算符由三部分组成,使用语法如下: A ? B : C 三元运算符A:它需要的是一个布尔值(其他类型数值也可以,但是需要隐式转换为布尔值) 如果A部分为布尔值 ...

2021-03-12-C++学习之10-类和对象-多态

2021-03-12-C++学习之10-类和对象-多态相关推荐

最新文章

热门文章