C++类与对象(3)—多态
一个接口有多种形态，传入的对象不一样，同一个接口执行的操作不同
成都创新互联是一家集网站建设,青秀企业网站建设,青秀品牌网站建设,网站定制,青秀网站建设报价,网络营销,网络优化,青秀网站推广为一体的创新建站企业，帮助传统企业提升企业形象加强企业竞争力。可充分满足这一群体相比中小企业更为丰富、高端、多元的互联网需求。同时我们时刻保持专业、时尚、前沿，时刻以成就客户成长自我，坚持不断学习、思考、沉淀、净化自己，让我们为更多的企业打造出实用型网站。
多态的基本概念
多态分为两类
- 静态多态：函数重载和运算符重载属于静态多态，复用函数名
- 动态多态：派生类和虚函数实现运行时多态
静态多态胡动态多态的区别
- 静态多态的函数地址早绑定，编译阶段搞定函数地址
- 动态多态的函数地址晚绑定，运行阶段确定函数地址
例子
早绑定
#include
using namespace std;
class Animal{ //父类
public:
void speak(){
cout << "动物在说话" << endl;
}
};
class Cat:public Animal{ //子类
public:
void speak(){
cout << "小猫在说话" << endl;
}
};
//地址早绑定
void doSpeak(Animal &animal){ //等价于 Animal &animal = cat;
animal.speak();
}
void test01(){
Cat cat;
doSpeak(cat);//本意输出猫在说话
}
int main(){
test01();
return 0;
}
晚绑定（只要在父类的函数前面加一个virtual）
virtual void speak(){
cout << "动物在说话" << endl;
}
动态多态的满足条件
- 有继承关系
- 子类要重写父类中的虚函数（可以不写virtual，其余完全一样）
动态多态的使用
多态的原理剖析
在使用virtual后父类结构改变，多列一个指针（虚函数表指针），指向一个虚函数表，在虚函数表中写着虚函数函数入口地址
子类重写虚函数时，会把原来的虚函数替换成子类新写的虚函数（如果不重写，则虚函数表中的数据和父类是一样的）
所以用父类的引用去指向子类对象时，当调用公共的接口（虚函数）时，会从子类中去寻找确实的函数地址，
多态案例(1)-计算机类
多态的优点：
- 代码组织结构清晰
- 可读性强
- 利于前期和后期的拓展和保护
基础实现
#include
using namespace std;
class Calculator{//计算器类
public:
int getResult(string oper){
if(oper == "+") return m_a + m_b;
if(oper == "-") return m_a - m_b;
if(oper == "*") return m_a * m_b;
}
int m_a;
int m_b;
};
void test01(){
Calculator C;
C.m_a = 10;
C.m_b = 10;
cout << C.m_a << "+" << C.m_b << "=" << C.getResult("+") << endl;
cout << C.m_a << "-" << C.m_b << "=" << C.getResult("-") << endl;
cout << C.m_a << "*" << C.m_b << "=" << C.getResult("*") << endl;
}
int main(){
test01();
return 0;
}
但是我们发现，这个计算器是没有除法的，要想添加除法，必须去源码中修改，但是
在真实开发中，提倡：开闭原则（对拓张进行开放，对修改进行关闭）
所以我们来用多态的方式来写一下吧
多态实现
//乘法、除法的计算器就不写了
#include
using namespace std;
class Calculator{ //虚基类
public:
virtual int getResult(){ //只要个名字，没有任何功能
return 0;
}
int m_a;
int m_b;
};
class SonAdd:public Calculator{ //加法类
public:
int getResult(){
return m_a + m_b;
}
};
class SonSub:public Calculator{ //减法类
public:
int getResult(){
return m_a - m_b;
}
};
class SonMul:public Calculator{ //乘法类
public:
int getResult(){
return m_a * m_b;
}
};
class SonDiv:public Calculator{ //除法类
public:
int getResult(){
return m_a / m_b;
}
};
void test01(){//这次我们使用指针的方法来指向子类对象
Calculator * C = new SonAdd;//加法计算器
C->m_a = 10;
C->m_b = 10;
cout << C->m_a << "+" << C->m_b << "=" << C->getResult() << endl;
delete C;//new在堆区，要记得释放哦
C = new SonSub; //减法计算器
C->m_a = 20;
C->m_b = 20;
cout << C->m_a << "-" << C->m_b << "=" << C->getResult() << endl;
delete C;
}
int main(){
test01();
return 0;
}
纯虚函数和抽象类
在多态中，通常父类中虚函数的实现是没有意义的，主要都是调用子类中重写的内容
因此可以将虚函数改为纯虚函数
当类中出现了纯虚函数，这个类就叫做抽象类
语法
virtual 返回值类型 函数名 (参数列表) = 0;
特点
- 无法实例化对象
- 子类必须重写抽象类（父类）中的纯虚函数，否则也属于抽象类了
例子
#include
using namespace std;
class Base{//抽象类
public:
virtual void func() = 0;
};
class Son:public Base{ //子类
public:
void func(){ //重写函数是
cout << "子类重写成功" <func();
}
int main(){
test01();
return 0;
}
多态案例(2)-制作饮品
在原本的代码上稍稍优化了一下
#include
using namespace std;
class Base{ //抽象类
public:
virtual void Boll() = 0;
virtual void Brew() = 0;
virtual void Pour() = 0;
virtual void AddSome() = 0;
void make(){//调用制作饮品的函数
Boll();
Brew();
Pour();
AddSome();
}
};
class Tea:public Base{//茶类
public:
void Boll(){
cout << "1.煮茶水" << endl;
}
void Brew(){
cout << "2.冲泡茶叶" << endl;
}
void Pour(){
cout << "3.倒入茶杯中" << endl;
}
void AddSome(){
cout << "4.加入辅料" << endl;
}
};
class Coffee:public Base{ //咖啡类
public:
void Boll(){
cout << "1.煮水" << endl;
}
void Brew(){
cout << "2.冲泡咖啡" << endl;
}
void Pour(){
cout << "3.倒入咖啡杯中" << endl;
}
void AddSome(){
cout << "4.加入辅料(牛奶/放糖)" << endl;
}
};
void domake(Base *base){ //多态的实现
base->make();
delete base;
}
void test01(){ //制作茶
domake(new Tea);
}
void test02(){ //制作咖啡
//domake(new Coffee);
Base * base = new Coffee;
base->make();
delete base;
}
void select(){ //选择要制作的饮品
int i = 0;
const int j = 3; //最大的制作次数
while(1){
cout << "请选择所需要的饮品(您现在最多可以选" << j-i << "次)" << endl;
string drink;
cin >> drink;
if(drink == "茶"){
test01();
}else if(drink == "咖啡"){
test02();
}else{
cout << "对不起，您所选的饮品目前没有..." << endl;
}
i += 1;
if(i == j) break;//达到3次后结束
}
return;
}
int main(){
select();
return 0;
}
虚析构和纯虚析构
多态使用时，父类的指针或引用子类时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用子类的析构函数
所以，我们将父类中的析构函数改为(纯)虚析构
析构和纯虚析构的共性
- 都可以解决父类指针释放子类对象
- 都需要具体函数实现
析构和纯虚析构的区别
语法
虚析构：
virtual ~类名(){}
纯虚析构：
virtual ~类名() = 0；//类内
类名::~类名(){}//类外
虚析构
#include
using namespace std;
class Animal{ //父类
public:
Animal(){
cout << "Animal构造调用" << endl;
}
~Animal(){
cout << "Animal析构调用" << endl;
}
virtual void speak() = 0;
};
class Cat:public Animal{ //子类
public:
Cat(string name){
cout << "Cat构造调用" << endl;
m_Name = new string(name);
}
~Cat(){
if(m_Name != NULL){
cout << "Cat析构调用" << endl;
delete m_Name;
m_Name = NULL;
}
}
void speak(){
cout << *m_Name << "小猫会说话" << endl;
}
string *m_Name;//要创建在堆区
};
void test01(){
Animal * animal = new Cat("Tom");
animal->speak();
delete animal;
}
int main(){
test01();
return 0;
}
没有调用Cat的析构函数，数据没有清楚干净，可能会造成内存泄露
原因：父类指针指向子类，delete父类时，不会调用子类的析构代码
解决：使用虚析构函数
virtual ~Animal(){
cout << "Animal析构调用" << endl;
}
结果
300
纯虚析构
内部要有函数的实现，不能只是下面这样
virtual ~Animal() = 0; //这是错的
看看正确的吧
{//类内声明
virtual ~Animal() = 0;
}；
//类外定义
Animal::~Animal(){
cout << "Animal纯虚析构调用" << endl;
};
案例(3)-电脑组装
案例描述：
主要零件时CPU(用于计算)，显卡(用于显示)，内存条(用于存储)
每个零件封装成抽象基类，并且用于不同的厂商生产不同的零件
创建电脑类提供让电脑工作的函数，并且调用每个零件工作的接口
测试时组装3台不同的电脑工作
#include
using namespace std;
class CPU{ //CPU类
public:
virtual void calculate() = 0;
};
class Card{ //显卡类
public:
virtual void display() = 0;
};
class Memory{ //内存条类
public:
virtual void storage() = 0;
};
class Com{ //电脑类
private:
CPU *m_cpu; //用指针来传入三个零件数据（要用多态嘛）
Card *m_card;
Memory *m_memory;
public:
Com(CPU *cpu,Card *card,Memory *memory){ //有参构造
m_cpu = cpu;
m_card = card;
m_memory = memory;
}
void work(){ //调用不同零件的函数
m_cpu->calculate();
m_card->display();
m_memory->storage();
}
//提供析构函数来释放三个零件
~Com(){
if(m_cpu != NULL){
delete m_cpu;
m_cpu = NULL;
}
if(m_card!= NULL){
delete m_card;
m_card = NULL;
}
if(m_memory != NULL){
delete m_memory;
m_memory = NULL;
}
}
};
//联想厂商
class Lenovo:public CPU,public Card,public Memory{//方法一：三个子类再整合成一个大类,亲测不太好用哎（我不知道该在怎么析构比较好）
public:
void calculate(){
cout << "联想的CPU开始计算" << endl;
}
void display(){
cout << "联想的显卡开始显示" << endl;
}
void storage(){
cout << "联想的内存条开始存储" << endl;
}
};
//苹果厂商
//方法二：把三个子类分开
class AppleCPU:public CPU{ //简单的继承和函数的重写
public:
void calculate(){
cout << "苹果的CPU开始计算" << endl;
}
};
class AppleCard:public Card{
public:
void display(){
cout << "苹果的显卡开始显示" << endl;
}
};
class AppleMemory:public Memory{
public:
void storage(){
cout << "苹果的内存条开始显示" << endl;
}
};
//戴尔厂商
class DellCPU:public CPU{
public:
void calculate(){
cout << "戴尔的CPU开始计算" << endl;
}
};
class DellCard:public Card{
public:
void display(){
cout << "戴尔的显卡开始显示" << endl;
}
};
class DellMemory:public Memory{
public:
void storage(){
cout << "戴尔的内存条开始显示" << endl;
}
};
void test01(){
// Lenovo *lenovo = new Lenovo; 不写那个析构的内容的化，我感觉是对的，但有一点怪怪的
// Com *com = new Com(lenovo,lenovo,lenovo);
// com->work();
// //delete com;
// delete lenovo;
Com *com1 = new Com(new AppleCPU,new AppleCard,new AppleMemory); //使用了第二中的厂商法
com1->work();
delete com1;//delete的时候就调用析构函数啦
cout << "=======================" << endl;
Com *com2 = new Com(new DellCPU,new AppleCard,new DellMemory); //使用了第二中的厂商法
com2->work();
delete com2;
}
int main(){
test01();
return 0;
}
新闻标题：C++基础-类与对象(3)
分享链接：
http://cdkjz.cn/article/dsoippe.html
