用asp.net做的网站实例,接推广网站,网站导航网站建设多少钱,鲜花品牌网站建设目录 一、多态
1. 多态的概念
2.多态的分类#xff1a;
1. 静态多态#xff1a;
2. 动态多态#xff1a; 3.静态多态和动态多态的区别#xff1a;
4.动态多态需要满足的条件#xff1a;
4.1重写的概念#xff1a;
4.2动态多态的调用#xff1a; 二、多态
三、多…目录 一、多态
1. 多态的概念
2.多态的分类
1. 静态多态
2. 动态多态 3.静态多态和动态多态的区别
4.动态多态需要满足的条件
4.1重写的概念
4.2动态多态的调用 二、多态
三、多态的深入剖析
四、利用多态写一个模拟计算器案例
1.普通方式写一个模拟计算器
2.利用多态的方式写一个计算器
五、纯虚函数和抽象类
抽象类特点
六、利用多态的抽象类写一个饮品制作流程的案例
七、纯析构和纯虚析构
虚析构和纯虚析构的共性
虚析构和纯虚析构的区别
总结
八、利用多态写一个组装电脑的案例 一、多态
1. 多态的概念
计算机程序运行时相同的消息可能会送给多个不同的类别之对象而系统可依据对象所属类别引发对应类别的方法而有不同的行为。简单来说所谓多态意指相同的消息给予不同的对象会引发不同的动作。
多态也可定义为“一种将不同的特殊行为和单个泛化记号相关联的能力”。
多态可分为变量多态与函数多态。变量多态是指基类型的变量对于C是引用或指针可以被赋值基类型对象也可以被赋值派生类型的对象。函数多态是指相同的函数调用界面函数名与实参表传送给一个对象变量可以有不同的行为这视该对象变量所指向的对象类型而定。因此变量多态是函数多态的基础。
多态是c面向对象的三大特性之一
2.多态的分类
1. 静态多态 函数重载 和 运算符重载 属于静态多态复用函数名 静态多态static polymorphism模板也允许将不同的特殊行为和单个泛化记号相关联由于这种关联处理于编译期而非运行期因此被称为“静态”。可以用来实现类型安全、运行高效的同质对象集合操作。CSTL不采用动态多态来实现就是个例子。 函数重载Function Overloading 运算符重载Operator Overloading 带变量的宏多态macro polymorphism 非参数化多态或译作特设多态Ad-hoc polymorphism 参数化多态Parametric polymorphism把类型作为参数的多态。在面向对象程序设计中这被称作泛型编程。
2. 动态多态 派生类 和 虚函数 实现运行时多态 动态多态dynamic polymorphism:通过类继承机制和虚函数机制生效于运行期。可以优雅地处理异质对象集合只要其共同的基类定义了虚函数的接口。也被称为子类型多态Subtype polymorphism或包含多态inclusion polymorphism。在面向对象程序设计中这被直接称为多态。
对于C语言带变量的宏和函数重载function overload机制也允许将不同的特殊行为和单个泛化记号相关联。然而习惯上并不将这种函数多态function polymorphism、宏多态macro polymorphism展现出来的行为称为多态或静态多态否则就连C语言也具有宏多态了。谈及多态时默认就是指动态多态而静态多态则是指基于模板的多态。 3.静态多态和动态多态的区别 1. 静态多态的函数地址早绑定编译阶段确定函数地址 2. 动态多态的函数地址晚绑定运行阶段确定函数地址
4.动态多态需要满足的条件 1.有继承关系 2.子类中重写父类的虚函数子类中写不写virtual都可以
4.1重写的概念 函数返回值类型 函数名 参数列表都完全相同。 注意与函数重载要区分。
4.2动态多态的调用 父类的指针或引用 执行子类对象 二、多态
示例
#includeiostreamusing namespace std;// 多态// 动态多态的满足条件// 1. 有继承关系// 2. 子类要重写父类的虚函数// 动态多态的使用// 父类的指针或引用 指向子类对象// 动物类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;}};// 执行说话的函数void dospeak(Animal animal) // Animal animal cat;{// 地址早绑定 在编译阶段确定函数地址// 如果要执行猫说话那么这个函数地址就不能提前绑定// 需要在运行阶段进行绑定地址晚绑定animal.speak();}// c允许父类和子类的转化void test01(){Cat cat;// cat.speak();dospeak(cat); // 父类的引用接收的是子类的对象Dog dog;dospeak(dog);}int main(){test01();return 0;} 没写 virtual 之前是地址早绑定 写入虚函数后地址晚绑定运行结果 三、多态的深入剖析
图解示例 示例
#includeiostreamusing namespace std;// 多态的底层逻辑// 动物类class Animal{public:// 虚函数void speak(){cout 动物在说话 endl;}};// 猫类class Cat :public Animal{public:// 重写 函数返回值类型 函数名 参数列表要 完全相同void speak(){cout 猫在说话 endl;}};// 狗类class Dog :public Animal{public:void speak(){cout 狗在说话 endl;}};// 执行说话的函数void dospeak(Animal animal){// 地址早绑定 在编译阶段确定函数地址// 如果要执行猫说话那么这个函数地址就不能提前绑定// 需要在运行阶段进行绑定地址晚绑定animal.speak();}// c允许父类和子类的转化void test01(){Cat cat;// cat.speak();dospeak(cat); // 父类的引用接收的是子类的对象Dog dog;dospeak(dog);}void test02(){cout Animal 类的大小: sizeof(Animal) endl;}int main(){test01();test02();return 0;}
通过命令提示符查看 加入虚函数后 子类在没有重写的时候 子类重写虚函数后 没加virtual的类的大小相当于空类大小是1 变为虚函数后的类的大小为8/4看你的编译器是多少位的类的大小是一个指针的大小 关于命令提示符查看类可查询上一篇文章命令提示符查看类 四、利用多态写一个模拟计算器案例
多态的优点
代码组织结构清晰可读性强利于前期和后期的扩展及维护
1.普通方式写一个模拟计算器
示例1
#includeiostreamusing namespace std;// 分别利用普通写法和多态的技术实现计算器的功能// 普通的写法class Calculator{public:int get_result(string oper){if(oper )return m_num1m_num2;if(oper -)return m_num1 - m_num2;if(oper *)return m_num1 * m_num2;if(oper /)return m_num1 / m_num2;}int m_num1;int m_num2;};void test01(){Calculator c;c.m_num1 40;c.m_num2 20;// 开闭原则对扩展进行开放对修改进行关闭coutc.m_num1 c.m_num2 c.get_result()endl;coutc.m_num1 - c.m_num2 c.get_result(-)endl;coutc.m_num1 * c.m_num2 c.get_result(*)endl;coutc.m_num1 / c.m_num2 c.get_result(/)endl;}int main(){test01();return 0;}
运行结果 2.利用多态的方式写一个计算器
示例2
#includeiostreamusing namespace std;// 利用多态实现计算器class Abstract_Calculator{public:virtual int get_result(){return 0;}int num1;int num2;};// 设计一个加法计算器的类class Add_Calculator:public Abstract_Calculator{public:int get_result(){return num1num2;}};// 设计一个减法计算器的类class Sub_Calculator:public Abstract_Calculator{public:int get_result(){return num1-num2;}};// 设计一个乘法计算器的类class Mul_Calculator:public Abstract_Calculator{public:int get_result(){return num1*num2;}};void test02(){// 多态的使用条件// 父类的指针或引用指向子类对象// 加法运算Abstract_Calculator *abc new Add_Calculator;abc-num1 100;abc-num2 200;coutabc-num1 abc-num2 abc-get_result()endl;// 堆区数据用完记得销毁delete abc;// 减法运算abc new Sub_Calculator;abc-num1 200;abc-num2 100;coutabc-num1 - abc-num2 abc-get_result()endl;delete abc;// 乘法运算abc new Mul_Calculator;abc-num1 200;abc-num2 100;coutabc-num1 * abc-num2 abc-get_result()endl;delete abc;}int main(){test02();return 0;}
运行结果 五、纯虚函数和抽象类
在多态中通常父类中虚函数的实现是毫无意义的主要是调用子类的重写内容
因此可以将虚数改为纯虚数
纯虚数语法 virtual 返回值类型 函数名参数列表 0 ;
当类中有了纯虚函数这个类称为抽象类
抽象类特点
无法实例化对象子类必须重写抽象类中的纯虚函数否则也属于抽象类 示例
#includeiostreamusing namespace std;// 纯虚数抽象类class Base{public:virtual void func() 0; // 虚函数的基础上才可以等于0纯虚函数// 只要有一个纯虚数,这个类称为抽象类};// 抽象类的子类必须要重写父类中的纯虚函数否则也是抽象类无法实例化对象class Son:public Base{public:void func(){coutfunc函数调用endl;}};void test01(){// Base b; 无法实例化一个抽象类// new 一个也不行Base *base new Son;base-func();}int main(){test01();return 0;}
运行结果 六、利用多态的抽象类写一个饮品制作流程的案例
案例描述利用多态技术提供抽象类制作饮品基类提供子类制作咖啡和茶叶 示例
#includeiostreamusing namespace std;class Abstract_Drinking{public:// 煮水virtual void Boil() 0;// 冲泡virtual void Brew() 0;// 倒入杯中virtual void Pour_Cup() 0;// 加入辅助佐料virtual void Put_something() 0;// 制作饮品void make_drink(){Boil();Brew();Pour_Cup();Put_something();}};// 具体的制作// 咖啡class Coffee:public Abstract_Drinking{public:// 煮水virtual void Boil(){cout煮矿泉水endl;}// 冲泡virtual void Brew(){cout冲泡咖啡endl;}// 倒入杯中virtual void Pour_Cup(){cout倒入杯中endl;}// 加入辅助佐料virtual void Put_something(){cout加入糖和牛奶endl;}};// 茶class Tea:public Abstract_Drinking{public:// 煮水virtual void Boil(){cout煮矿泉水endl;}// 冲泡virtual void Brew(){cout冲泡茶叶endl;}// 倒入杯中virtual void Pour_Cup(){cout倒入杯中endl;}// 加入辅助佐料virtual void Put_something(){cout加入柠檬枸杞endl;}};// 制作void do_work(Abstract_Drinking * abd)// Abstract_Drinking *abd new Coffee 父类指针指向子类对象{abd-make_drink();delete abd;// 在堆区制作完记得释放}void test01(){// 制作咖啡do_work(new Coffee);cout-------------endl;// 制作茶do_work(new Tea);}int main(){test01();return 0;}
运行结果 七、纯析构和纯虚析构
问题多态使用时如果子类中有属性开辟到堆区那么父类指针在释放时无法调用到子类的析构代码。
解决办法将父类中的析构函数改为**虚析构**或者**纯虚析构**
虚析构和纯虚析构的共性
可以解决父类指针释放子类对象都需要有具体的函数实现
虚析构和纯虚析构的区别
如果是纯虚析构该对象属于抽象类无法实现实例化对象
**虚析构语法**
virtual ~类名{}
**纯虚析构语法**
virtual ~类名 0
类名~类名{} // 类内声明类外实现 示例
#includeiostreamusing namespace std;// 虚析构和纯虚析构class Animal{public:Animal(){coutAnimal的构造函数的调用endl;}virtual void speak() 0;// 变为纯虚函数// 利用虚析构可以解决 父类指针释放子类对象时不干净的问题/*virtual ~Animal(){coutAnimal虚析构函数的调用endl;}*/virtual ~Animal() 0;// 纯虚析构// 需要声明 也需要实现// 有了纯虚析构之后那么这个类也属于抽象类无法实现实例化对象};Animal::~Animal(){coutAnimal纯虚析构函数的调用endl;}class Cat: public Animal{public:Cat(string name){cout这是Cat的构造函数的调用endl;this-name new string(name);}void speak(){cout*name小猫在说话endl;}~Cat(){if(this-name!NULL){cout这是Cat的析构函数的调用endl;delete this-name;this-name NULL;}}string *name;// 创建在堆区};void test01(){Animal *animal new Cat(Tom);animal-speak();// 父类的指针在析构的时候不会调用子类的析构函数// 导致子类如果在堆区有数据会出现内存泄漏的情况delete animal;}int main(){test01();return 0;}
运行结果 总结
虚析构或纯虚析构就是用来解决通过父类指针释放子类对象如果子类中没有堆区数据可以不写为虚析构或者纯虚析构拥有纯虚析构函数的类也属于抽象类 八、利用多态写一个组装电脑的案例
案例说明
电脑主要组成部件为CPU(用于计算)显卡〔用于显示)内存条〔用于存储)
将每个零件封装出抽象基类并且提供不同的厂商生产不同的霉件例如Intel厂商和Lenovo厂商
创建电脑类提供让电脑工作的函数并且调用每个零件工作的接口
测试时组装三台下同的电脑进行工作 示例
#includeiostreamusing namespace std;// 抽象不同零件的类// 计算机类class CPU{public:// 抽象的计算函数virtual void calculate() 0;};// 显卡类class Video_Card{public:// 抽象的显示函数virtual void display() 0;};// 内存条类class Memory{public:// 抽象的存储函数virtual void storage() 0;};// 提供电脑类class Computer{public:Computer(CPU* cpu, Video_Card* vc, Memory* mem){this-cpu cpu;this-vc vc;this-mem mem;}// 提供工作函数void work(){// 让零件工作起来调用接口this-cpu-calculate();this-vc-display();this-mem-storage();}// 提供析构函数 释放在堆区创建的三个零件~Computer(){if(cpu!NULL){delete cpu;cpu NULL;}if(vc!NULL){delete vc;vc NULL;}if(mem!NULL){delete mem;mem NULL;}}private:CPU* cpu; // CPU的零件指针Video_Card* vc; // 显卡的零件指针Memory* mem; // 内存条的零件指针};// 具体厂商// Intel厂商// CPUclass Intel_CPU :public CPU{public:void calculate(){cout 这是Intel厂商的CPU,并且开始计算了 endl;}};// 显卡class Intel_Video_Card :public Video_Card{public:void display(){cout 这是Intel厂商的显卡并且开始显示了 endl;}};// 内存条class Intel_Memory :public Memory{void storage(){cout 这是Intel厂商的内存条并且开始存储了 endl;}};// Lenovo厂商// CPUclass Lenovo_CPU :public CPU{public:void calculate(){cout 这是Lenovo厂商的CPU,并且开始计算了 endl;}};// 显卡class Lenovo_Video_Card :public Video_Card{public:void display(){cout 这是Lenovo厂商的显卡并且开始显示了 endl;}};// 内存条class Lenovo_Memory :public Memory{void storage(){cout 这是Lenovo厂商的内存条并且开始存储了 endl;}};void test01(){cout------------------------endl;cout第一台电脑开始工作endl;// 创建第一台电脑的零件CPU* intel_CPU new Intel_CPU;Video_Card* intel_videocard new Intel_Video_Card;Memory* intel_memory new Intel_Memory;// 创建电脑零件的时候时在堆区创建的// 创建第一台电脑Computer* computer1 new Computer(intel_CPU, intel_videocard, intel_memory);computer1-work();delete computer1;cout-----------------------endl;cout第二台电脑开始工作endl;// 组装第二台电脑Computer* computer2 new Computer(new Lenovo_CPU, new Lenovo_Video_Card, new Lenovo_Memory);computer2-work();delete computer2;cout-----------------------endl;cout第三台电脑开始工作endl;// 组装第三台电脑Computer* computer3 new Computer(new Lenovo_CPU, new Intel_Video_Card, new Lenovo_Memory);computer3-work();delete computer3;}int main(){test01();return 0;}
运行结果
