qt 子类调用父类的函数_C++ & QT ---10（类和对象---多态）
4类和对象
C++面向对象的三大特征：封装、继承、多态
C++认为万事万物皆为对象，对象上有其属性和行为
4.7 多态
4.7.1 多态的基本概念
多态是C++面向对象三大特性之一
多态分为两类
1、静态多态： 函数重载 和 运算符重载 术语静态多态，复用函数名
2、动态多态：派生类 和 虚函数 实现运行时多态
静态多态 和 动态多态 区别：
1、静态多态 的函数地址早绑定 - 编译阶段确定函数地址
2、动态多态 的函数地址晚绑定 - 运行阶段确定函数地址
#include //io流
using namespace std; //设定名称空间，标准standard
#include //io流
using namespace std; //设定名称空间，标准standard
// 动态多态
// 动物类
class Animal
{
public:
//虚函数
virtual void speak()
{
cout << "动物在说话" << endl;
}
};
// 猫类
class Cat : public Animal
{
public:
void speak()
{
cout << "小猫在说话" << endl;
}
};
// 狗类
class Dog : public Animal
{
public:
void speak()
{
cout << "小狗在说话" << endl;
}
};
//执行说话函数
//地址早绑定 在编译阶段，就确定了函数地址
//如果想执行让猫说话，那么这个函数的地址就应该在运行阶段才绑定
//Animal & animal = cat；父类的指针或引用 指向 子类对象
void doSpeak(Animal& animal)
{
animal.speak();
}
void test01()
{
Cat cat;
doSpeak(cat);
Dog dog;
doSpeak(dog);
}
int main()
{
test01();
system("pause");
return 0;
}
注意
（1）动态多态的满足条件：
1、有继承关系
2、子类 需要重写 父类 的虚函数（注意 重载 和 重写 区别）
重写：函数返回值类型、函数名、参数列表，完全相同。重载其中一个不同
（2）动态多态 的使用：
1、父类的指针或引用 指向 子类对象
理论依据剖析
vfptr（virtual function pointer虚函数指针），指向虚函数表（vftable）
4.7.2 多态案例---计算器类
多态的优点：
1、代码组织结构清晰
2、可读性强
3、利于前期和后期的扩展以及维护
案例描述：分别利用普通写法和多态技术，设计实现两个操作数进行运算的计算器类
#include //io流
using namespace std; //设定名称空间，标准standard
// 分别利用 普通写法 和多态技术 实现计算器
//普通写法
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;
}
// 利用多态实现计算器
//实现计算器抽象类
class AbstractCalculator
{
public:
virtual int getResult()
{
return 0;
}
int m_Num1;
int m_Num2;
};
// 加法计算器类
class AddCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 + m_Num2;
}
};
// 减法计算器类
class SubCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 - m_Num2;
}
};
// 乘法计算器类
class MulCalculator :public AbstractCalculator
{
public:
int getResult()
{
return m_Num1 * m_Num2;
}
};
void test02()
{
//多态使用条件
//父类指针 或者 引用 指向子类对象
//加法运算
AbstractCalculator *abc = new AddCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 100;
cout << abc->m_Num1 << " + " << abc->m_Num2 << " = "
<< abc->getResult() << endl;
//用完后记得销毁
delete abc;
//减法运算
abc = new SubCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " - " << abc->m_Num2 << " = "
<< abc->getResult() << endl;
//用完后记得销毁
delete abc;
//乘法运算
abc = new MulCalculator;
abc->m_Num1 = 10;
abc->m_Num2 = 10;
cout << abc->m_Num1 << " * " << abc->m_Num2 << " = "
<< abc->getResult() << endl;
//用完后记得销毁
delete abc;
}
int main()
{
//test01();
test02();
system("pause");
return 0;
}
注意：C++开发提倡利用多态设计程序架构，因为多态优点很多
4.7.3 纯虚函数 和 抽象类
在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容，因此，可以将虚函数改为纯虚函数。
纯虚函数语法：virtual 返回值类型 函数名（参数列表） = 0；
当类中有了纯虚函数，这个类也成为抽象类。
抽象类特点：
1、无法实例化对象
2、抽象类的子类必须重写抽象类中的纯虚函数，否则也属于抽象类，即也无法实例化对象
4.7.4 多态案例二：制作饮品
#include //io流
using namespace std; //设定名称空间，标准standard
// 多态案例二：制作饮品
// 抽象类只写步骤，没有具体实现
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()
{
test01();
system("pause");
return 0;
}
4.7.5 虚析构 和 纯虚析构
多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码
解决方式：将父类中的析构函数改为 虚析构 或者 纯虚析构
虚析构 和 纯虚析构 共性：
1、可以解决父类指针释放子类对象
2、都需要有具体的函数实现
虚析构 和 纯虚析构 区别：如果是纯虚析构，该类属于抽象类，无法实例化对象
虚析构语法：virtual ~类名（） { }
纯虚析构语法：virtual ~类名（） = 0；
总结：
1、虚析构 或 纯虚析构 都是用来解决 通过父类指针释放子类对象
2、如果子类中没有堆区数据，可以不写 虚析构 或纯虚析构
3、拥有纯虚析构函数的类也属于抽象类（即不可实例化对象）
4.7.6 多态案例三---电脑组装
#include //io流
using namespace std; //设定名称空间，标准standard
// 多态案例三---电脑组装
// 抽象出每个零件的类
// 抽象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* mem)
{
m_cpu = cpu;
m_vc = vc;
m_mem = mem;
}
//提供工作函数
void work()
{
//调用接口，让零件工作起来
m_cpu->calculate();
m_vc->display();
m_mem->storage();
}
//提供一个析构函数，释放3个电脑零件
~Computer()
{
//释放CPU零件
if (m_cpu != NULL)
{
delete m_cpu;
m_cpu = NULL;
}
//释放显卡零件
if (m_vc != NULL)
{
delete m_vc;
m_vc = NULL;
}
//释放内存零件
if (m_mem != NULL)
{
delete m_mem;
m_mem = NULL;
}
}
private:
CPU* m_cpu;//CPU的零件指针
VideoCard* m_vc;//显卡零件指针
Memory* m_mem;//内存条零件指针
};
// 具体厂商
//Intel厂商
class IntelCPU :public CPU
{
virtual void calculate()
{
cout << "Intel的CPU开始计算了" << endl;
}
};
class IntelVideoCard :public VideoCard
{
virtual void display()
{
cout << "Intel的显卡开始显示了" << endl;
}
};
class IntelMemory :public Memory
{
virtual void storage()
{
cout << "Intel的内存条开始存储了" << endl;
}
};
//Lenovo厂商
class LenovoCPU :public CPU
{
virtual void calculate()
{
cout << "Lenovo的CPU开始计算了" << endl;
}
};
class LenovoVideoCard :public VideoCard
{
virtual void display()
{
cout << "Lenovo的显卡开始显示了" << endl;
}
};
class LenovoMemory :public Memory
{
virtual void storage()
{
cout << "Lenovo的内存条开始存储了" << endl;
}
};
void test01()
{
//第一台电脑零件
CPU* intelCpu = new IntelCPU;
VideoCard* intelCard = new IntelVideoCard;
Memory* intelMem = new IntelMemory;
cout << "第一台电脑开始工作----" << endl;
//创建第一台电脑
Computer* computer1 = new Computer(intelCpu, intelCard, intelMem);
computer1->work();
delete computer1;
cout << "----------------------" << endl;
cout << "第二台电脑开始工作----" << endl;
//创建第二台电脑
Computer* computer2 = new Computer(new LenovoCPU,new LenovoVideoCard,new LenovoMemory);
computer2->work();
delete computer2;
cout << "----------------------" << endl;
cout << "第三台电脑开始工作----" << endl;
//创建第三台电脑
Computer* computer3 = new Computer(new IntelCPU, new LenovoVideoCard, new LenovoMemory);
computer3->work();
delete computer3;
}
int main()
{
test01();
system("pause");
return 0;
}
类和对象---多态