C++多态的实现原理详细讲解
虚函数和多态
01 虚函数
virtualvirtualclass base { virtual int fun() ; // 虚函数};int base::fun() // virtual 字段不用在函数体时定义{ }
02 多态的表现形式一
「派生类的指针」可以赋给「基类指针」；
通过基类指针调用基类和派生类中的同名「虚函数」时:若该指针指向一个基类的对象，那么被调用是基类的虚函数；若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制就叫做“多态”，说白点就是调用哪个虚函数，取决于指针对象指向哪种类型的对象。
// 基类class cfather {public: virtual void fun() { } // 虚函数};// 派生类class cson : public cfather { public : virtual void fun() { }};int main() { cson son; cfather *p = &son; p->fun(); //调用哪个虚函数取决于 p 指向哪种类型的对象 return 0;}
上例子中的 p 指针对象指向的是 cson 类对象，所以 p->fun() 调用的是 cson 类里的 fun 成员函数。
03 多态的表现形式二
派生类的对象可以赋给基类「引用」
通过基类引用调用基类和派生类中的同名「虚函数」时:若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制也叫做“多态”，说白点就是调用哪个虚函数，取决于引用的对象是哪种类型的对象。
// 基类class cfather {public: virtual void fun() { } // 虚函数};// 派生类class cson : public cfather { public : virtual void fun() { }};int main() { cson son; cfather &r = son; r.fun(); //调用哪个虚函数取决于 r 引用哪种类型的对象 return 0;}}
上例子中的 r 引用的对象是 cson 类对象，所以 r.fun() 调用的是 cson 类里的 fun 成员函数。
04 多态的简单示例
class a {public : virtual void print() { cout << a::print< print(); // b.print()被调用，输出：b::print pa = pd; pa -> print(); // d.print()被调用，输出：d::print pa = pe; pa -> print(); // e.print()被调用，输出：e::print return 0;}
05 多态作用
在面向对象的程序设计中使用「多态」，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。
lol 英雄联盟游戏例子
下面我们用设计 lol 英雄联盟游戏的英雄的例子，说明多态为什么可以在修改或增加功能的时候，可以较少的改动代码。
lol 英雄联盟是 5v5 竞技游戏，游戏中有很多英雄，每种英雄都有一个「类」与之对应，每个英雄就是一个「对象」。
英雄之间能够互相攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现的。
下面挑了五个英雄：
探险家 cezreal
盖楼 cgaren
盲僧 cleesin
无极剑圣 cyi
瑞兹 cryze
基本思路：
为每个英雄类编写 attack 、 fightback 和 hurted 成员函数。
attackfightbackhurted
设置基类 chero ，每个英雄类都继承此基类
02 非多态的实现方法
// 基类class chero {protected: int m_npower ; //代表攻击力 int m_nlifevalue ; //代表生命值};// 无极剑圣类class cyi : public chero {public: // 攻击盖伦的攻击函数 void attack(cgaren * pgaren) { .... // 表现攻击动作的代码 pgaren->hurted(m_npower); pgaren->fightback(this); } // 攻击瑞兹的攻击函数 void attack(cryze * pryze) { .... // 表现攻击动作的代码 pryze->hurted(m_npower); pryze->fightback( this); } // 减少自身生命值 void hurted(int npower) { ... // 表现受伤动作的代码 m_nlifevalue -= npower; } // 反击盖伦的反击函数 void fightback(cgaren * pgaren) { ...．// 表现反击动作的代码 pgaren->hurted(m_npower/2); } // 反击瑞兹的反击函数 void fightback(cryze * pryze) { ...．// 表现反击动作的代码 pryze->hurted(m_npower/2); }};
有 n 种英雄， cyi 类中就会有 n 个 attack 成员函数，以及 n 个 fightback成员函数。对于其他类也如此。
如果游戏版本升级，增加了新的英雄寒冰艾希 cashe ，则程序改动较大。所有的类都需要增加两个成员函数:
void attack(cashe * pashe);void fightback(cashe * pashe);
这样工作量是非常大的！！非常的不人性，所以这种设计方式是非常的不好！
03 多态的实现方式
用多态的方式去实现，就能得知多态的优势了，那么上面的栗子改成多态的方式如下：
// 基类class chero {public: virtual void attack(chero *phero){} virtual voidfightback(chero *phero){} virtual void hurted(int npower){}protected: int m_npower ; //代表攻击力 int m_nlifevalue ; //代表生命值};// 派生类 cyi:class cyi : public chero {public: // 攻击函数 void attack(chero * phero) { .... // 表现攻击动作的代码 phero->hurted(m_npower); // 多态 phero->fightback(this); // 多态 } // 减少自身生命值 void hurted(int npower) { ... // 表现受伤动作的代码 m_nlifevalue -= npower; } // 反击函数 void fightback(chero * phero) { ...．// 表现反击动作的代码 phero->hurted(m_npower/2); // 多态 }};
如果增加了新的英雄寒冰艾希 cashe ，只需要编写新类 cashe ，不再需要在已有的类里专门为新英雄增加：
void attack( cashe * pashe) ;void fightback(cashe * pashe) ;
所以已有的类可以原封不动，那么使用多态的特性新增英雄的时候，可见改动量是非常少的。
多态使用方式：
void cyi::attack(chero * phero) { phero->hurted(m_npower); // 多态 phero->fightback(this); // 多态}cyi yi; cgaren garen; cleesin leesin; cezreal ezreal;yi.attack( &garen ); //(1)yi.attack( &leesin ); //(2)yi.attack( &ezreal ); //(3)
根据多态的规则，上面的(1)，(2)，(3)进入到 cyi::attack 函数后
，分别调用：
cgaren::hurtedcleesin::hurtedcezreal::hurted
多态的又一例子
出一道题考考大家，看大家是否理解到了多态的特性，下面的代码， pbase->fun1() 输出结果是什么呢？
class base {public: void fun1() { fun2(); } virtual void fun2() // 虚函数 { cout << base::fun2() << endl; }};class derived : public base {public: virtual void fun2() // 虚函数 { cout << derived:fun2() fun2(); // this是基类指针，fun2是虚函数，所以是多态 }}
this 指针的作用就是指向成员函数所作用的对象， 所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。
pbase 指针对象指向的是派生类对象，派生类里没有 fun1 成员函数，所以就会调用基类的 fun1 成员函数，在 base::fun1() 成员函数体里执行 this->fun2() 时，实际上指向的是派生类对象的 fun2 成员函数。
所以正确的输出结果是：
derived:fun2()
所以我们需要注意：
在非构造函数，非析构函数的成员函数中调用「虚函数」，是多态!!!
构造函数和析构函数中存在多态吗？
在构造函数和析构函数中调用「虚函数」，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。
我们看如下的代码例子，来说明：
// 基类class cfather {public: virtual void hello() // 虚函数 { cout<
输出结果：
hello from son // 构造son对象时执行的构造函数hello from son // 多态bye from father // son对象析构时，由于cson类没有bye成员函数，所以调用了基类的bye成员函数
多态的实现原理
「多态」的关键在于通过基类指针或引用调用一个虚函数时，编译时不能确定到底调用的是基类还是派生类的函数，运行时才能确定。
我们用 sizeof 来运算有有虚函数的类和没虚函数的类的大小，会是什么结果呢？
class a {public: int i; virtual void print() { } // 虚函数};class b{public: int n; void print() { } };int main() { cout << sizeof(a) << ,<< sizeof(b); return 0;}
在64位机子，执行的结果：
16,4
从上面的结果，可以发现有虚函数的类，多出了 8 个字节，在 64 位机子上指针类型大小正好是 8 个字节，这多出 8 个字节的指针有什么作用呢？
01 虚函数表
每一个有「虚函数」的类（或有虚函数的类的派生类）都有一个「虚函数表」，该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。
多出来的 8 个字节就是用来放「虚函数表」的地址。
// 基类class base {public: int i; virtual void print() { } // 虚函数};// 派生类class derived : public base{public: int n; virtual void print() { } // 虚函数};
上面 derived 类继承了 base类，两个类都有「虚函数」，那么它「虚函数表」的形式可以理解成下图：
多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。
02 证明虚函数表指针的作用
在上面我们用 sizeof 运算符计算了有虚函数的类的大小，发现是多出了 8 字节大小（64位系统），这多出来的 8 个字节就是指向「虚函数表的指针」。「虚函数表」中列出了该类的「虚函数」地址。
下面用代码的例子，来证明「虚函数表指针」的作用：
// 基类class a {public: virtual void func() // 虚函数 { cout << a::func << endl; }};// 派生类class b : public a {public: virtual void func() // 虚函数 { cout << b::func func(); return 0;}
输出结果：
b::funca::func
第 25-26 行代码中的 pa 指针指向的是 b 类对象，所以 pa->func() 调用的是 b 类对象的虚函数 func() ，输出内容是 b::func ；
第 29-30 行代码的目的是把 a 类的头 8 个字节的「虚函数表指针」存放到 p1 指针和把 b 类的头 8 个字节的「虚函数表指针」存放到 p2 指针；
第 32 行代码目的是把 a 类的「虚函数表指针」 赋值给 b 类的「虚函数表指针」，所以相当于把 b 类的「虚函数表指针」 替换 成了 a 类的「虚函数表指针」；
由于第 32 行的作用，把 b 类的「虚函数表指针」 替换 成了 a 类的「虚函数表指针」，所以第 33 行调用的是 a 类的虚函数 func() ，输出内容是 a::func
通过上述的代码和讲解，可以有效的证明了「虚函数表的指针」的作用，「虚函数表的指针」指向的是「虚函数表」，「虚函数表」里存放的是类里的「虚函数」地址，那么在调用过程中，就能实现多态的特性。
虚析构函数
析构函数是在删除对象或退出程序的时候，自动调用的函数，其目的是做一些资源释放。
那么在多态的情景下，通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数，这就会存在派生类对象的析构函数没有调用到，存在资源泄露的情况。
看如下的例子：
// 基类class a {public: a() // 构造函数 { cout << construct a << endl; } ~a() // 析构函数 { cout << destructor a << endl; }};// 派生类class b : public a {public: b() // 构造函数 { cout << construct b << endl; } ~b()// 析构函数 { cout << destructor b << endl; }};int main() { a *pa = new b(); delete pa; return 0;}
输出结果：
construct aconstruct bdestructor a
从上面的输出结果可以看到，在删除 pa 指针对象时， b 类的析构函数没有被调用。
解决办法：把基类的析构函数声明为virtual
派生类的析构函数可以 virtual 不进行声明；
通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数，还是遵循「先构造，后虚构」的规则。
将上述的代码中的基类的析构函数，定义成「虚析构函数」：
// 基类class a {public: a() { cout << construct a << endl; } virtual ~a() // 虚析构函数 { cout << destructor a << endl; }};
输出结果：
construct aconstruct bdestructor bdestructor a
所以要养成好习惯:
一个类如果定义了虚函数，则应该将析构函数也定义成虚函数;
或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
注意：不允许构造函数不能定义成虚构造函数。
纯虚函数和抽象类
纯虚函数： 没有函数体的虚函数
class a {public: virtual void print( ) = 0 ; //纯虚函数private: int a;};
包含纯虚函数的类叫抽象类
抽象类只能作为基类来派生新类使用，不能创建抽象类的对象
抽象类的指针和引用可以指向由抽象类派生出来的类的对象
a a; // 错，a 是抽象类，不能创建对象a * pa ; // ok,可以定义抽象类的指针和引用pa = new a ; // 错误, a 是抽象类，不能创建对象
明明没上市，华为何以体量惊人？
信号链和PLC如何影响我们的生活
模拟量输入模块的2、3、4线制的接线方式
如何理解工业互联网？如何理解5G+工业互联网？
2018年上半年丘钛指纹识别模组出货量呈现上升趋势
C++多态的实现原理详细讲解
Uber恢复自动驾驶测试，受限测试只能启用人工模式
Type-C在终端与市场上的应用探究
cmd常用命令大全
数字切片扫描仪的自连方案
全球仅6块！七彩虹推出RTX 3090 Vulcan：具体规格参数未披露
远程控制开关该如何接线
蔚来子品牌阿尔卑斯已开始裁员 被曝或不再是独立项目
展望未来十年 信通院发布ICT深度观察十大趋势
声光控延时开关原理与制作
SiliconLottery特挑一批i7-9700K处理器开卖 全核5.1GHz售价569.99美元
智能家居是否有安全性的威胁
通过不同的方法，试图打开人工智能「黑匣子」
LTspice：简单理想化的二极管
NVMe VIP架构：主机功能
01 虚函数
virtualvirtualclass base { virtual int fun() ; // 虚函数};int base::fun() // virtual 字段不用在函数体时定义{ }
02 多态的表现形式一
「派生类的指针」可以赋给「基类指针」；
通过基类指针调用基类和派生类中的同名「虚函数」时:若该指针指向一个基类的对象，那么被调用是基类的虚函数；若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制就叫做“多态”，说白点就是调用哪个虚函数，取决于指针对象指向哪种类型的对象。
// 基类class cfather {public: virtual void fun() { } // 虚函数};// 派生类class cson : public cfather { public : virtual void fun() { }};int main() { cson son; cfather *p = &son; p->fun(); //调用哪个虚函数取决于 p 指向哪种类型的对象 return 0;}
上例子中的 p 指针对象指向的是 cson 类对象，所以 p->fun() 调用的是 cson 类里的 fun 成员函数。
03 多态的表现形式二
派生类的对象可以赋给基类「引用」
通过基类引用调用基类和派生类中的同名「虚函数」时:若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。
这种机制也叫做“多态”，说白点就是调用哪个虚函数，取决于引用的对象是哪种类型的对象。
// 基类class cfather {public: virtual void fun() { } // 虚函数};// 派生类class cson : public cfather { public : virtual void fun() { }};int main() { cson son; cfather &r = son; r.fun(); //调用哪个虚函数取决于 r 引用哪种类型的对象 return 0;}}
上例子中的 r 引用的对象是 cson 类对象，所以 r.fun() 调用的是 cson 类里的 fun 成员函数。
04 多态的简单示例
class a {public : virtual void print() { cout << a::print<
05 多态作用
在面向对象的程序设计中使用「多态」，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。
lol 英雄联盟游戏例子
下面我们用设计 lol 英雄联盟游戏的英雄的例子，说明多态为什么可以在修改或增加功能的时候，可以较少的改动代码。
lol 英雄联盟是 5v5 竞技游戏，游戏中有很多英雄，每种英雄都有一个「类」与之对应，每个英雄就是一个「对象」。
英雄之间能够互相攻击，攻击敌人和被攻击时都有相应的动作，动作是通过对象的成员函数实现的。
下面挑了五个英雄：
探险家 cezreal
盖楼 cgaren
盲僧 cleesin
无极剑圣 cyi
瑞兹 cryze
基本思路：
为每个英雄类编写 attack 、 fightback 和 hurted 成员函数。
attackfightbackhurted
设置基类 chero ，每个英雄类都继承此基类
02 非多态的实现方法
// 基类class chero {protected: int m_npower ; //代表攻击力 int m_nlifevalue ; //代表生命值};// 无极剑圣类class cyi : public chero {public: // 攻击盖伦的攻击函数 void attack(cgaren * pgaren) { .... // 表现攻击动作的代码 pgaren->hurted(m_npower); pgaren->fightback(this); } // 攻击瑞兹的攻击函数 void attack(cryze * pryze) { .... // 表现攻击动作的代码 pryze->hurted(m_npower); pryze->fightback( this); } // 减少自身生命值 void hurted(int npower) { ... // 表现受伤动作的代码 m_nlifevalue -= npower; } // 反击盖伦的反击函数 void fightback(cgaren * pgaren) { ...．// 表现反击动作的代码 pgaren->hurted(m_npower/2); } // 反击瑞兹的反击函数 void fightback(cryze * pryze) { ...．// 表现反击动作的代码 pryze->hurted(m_npower/2); }};
有 n 种英雄， cyi 类中就会有 n 个 attack 成员函数，以及 n 个 fightback成员函数。对于其他类也如此。
如果游戏版本升级，增加了新的英雄寒冰艾希 cashe ，则程序改动较大。所有的类都需要增加两个成员函数:
void attack(cashe * pashe);void fightback(cashe * pashe);
这样工作量是非常大的！！非常的不人性，所以这种设计方式是非常的不好！
03 多态的实现方式
用多态的方式去实现，就能得知多态的优势了，那么上面的栗子改成多态的方式如下：
// 基类class chero {public: virtual void attack(chero *phero){} virtual voidfightback(chero *phero){} virtual void hurted(int npower){}protected: int m_npower ; //代表攻击力 int m_nlifevalue ; //代表生命值};// 派生类 cyi:class cyi : public chero {public: // 攻击函数 void attack(chero * phero) { .... // 表现攻击动作的代码 phero->hurted(m_npower); // 多态 phero->fightback(this); // 多态 } // 减少自身生命值 void hurted(int npower) { ... // 表现受伤动作的代码 m_nlifevalue -= npower; } // 反击函数 void fightback(chero * phero) { ...．// 表现反击动作的代码 phero->hurted(m_npower/2); // 多态 }};
如果增加了新的英雄寒冰艾希 cashe ，只需要编写新类 cashe ，不再需要在已有的类里专门为新英雄增加：
void attack( cashe * pashe) ;void fightback(cashe * pashe) ;
所以已有的类可以原封不动，那么使用多态的特性新增英雄的时候，可见改动量是非常少的。
多态使用方式：
void cyi::attack(chero * phero) { phero->hurted(m_npower); // 多态 phero->fightback(this); // 多态}cyi yi; cgaren garen; cleesin leesin; cezreal ezreal;yi.attack( &garen ); //(1)yi.attack( &leesin ); //(2)yi.attack( &ezreal ); //(3)
根据多态的规则，上面的(1)，(2)，(3)进入到 cyi::attack 函数后
，分别调用：
cgaren::hurtedcleesin::hurtedcezreal::hurted
多态的又一例子
出一道题考考大家，看大家是否理解到了多态的特性，下面的代码， pbase->fun1() 输出结果是什么呢？
class base {public: void fun1() { fun2(); } virtual void fun2() // 虚函数 { cout << base::fun2() << endl; }};class derived : public base {public: virtual void fun2() // 虚函数 { cout << derived:fun2() fun2(); // this是基类指针，fun2是虚函数，所以是多态 }}
this 指针的作用就是指向成员函数所作用的对象， 所以非静态成员函数中可以直接使用 this 来代表指向该函数作用的对象的指针。
pbase 指针对象指向的是派生类对象，派生类里没有 fun1 成员函数，所以就会调用基类的 fun1 成员函数，在 base::fun1() 成员函数体里执行 this->fun2() 时，实际上指向的是派生类对象的 fun2 成员函数。
所以正确的输出结果是：
derived:fun2()
所以我们需要注意：
在非构造函数，非析构函数的成员函数中调用「虚函数」，是多态!!!
构造函数和析构函数中存在多态吗？
在构造函数和析构函数中调用「虚函数」，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。
我们看如下的代码例子，来说明：
// 基类class cfather {public: virtual void hello() // 虚函数 { cout<
hello from son // 构造son对象时执行的构造函数hello from son // 多态bye from father // son对象析构时，由于cson类没有bye成员函数，所以调用了基类的bye成员函数
多态的实现原理
「多态」的关键在于通过基类指针或引用调用一个虚函数时，编译时不能确定到底调用的是基类还是派生类的函数，运行时才能确定。
我们用 sizeof 来运算有有虚函数的类和没虚函数的类的大小，会是什么结果呢？
class a {public: int i; virtual void print() { } // 虚函数};class b{public: int n; void print() { } };int main() { cout << sizeof(a) << ,<< sizeof(b); return 0;}
在64位机子，执行的结果：
16,4
从上面的结果，可以发现有虚函数的类，多出了 8 个字节，在 64 位机子上指针类型大小正好是 8 个字节，这多出 8 个字节的指针有什么作用呢？
01 虚函数表
每一个有「虚函数」的类（或有虚函数的类的派生类）都有一个「虚函数表」，该类的任何对象中都放着虚函数表的指针。「虚函数表」中列出了该类的「虚函数」地址。
多出来的 8 个字节就是用来放「虚函数表」的地址。
// 基类class base {public: int i; virtual void print() { } // 虚函数};// 派生类class derived : public base{public: int n; virtual void print() { } // 虚函数};
上面 derived 类继承了 base类，两个类都有「虚函数」，那么它「虚函数表」的形式可以理解成下图：
多态的函数调用语句被编译成一系列根据基类指针所指向的（或基类引用所引用的）对象中存放的虚函数表的地址，在虚函数表中查找虚函数地址，并调用虚函数的指令。
02 证明虚函数表指针的作用
在上面我们用 sizeof 运算符计算了有虚函数的类的大小，发现是多出了 8 字节大小（64位系统），这多出来的 8 个字节就是指向「虚函数表的指针」。「虚函数表」中列出了该类的「虚函数」地址。
下面用代码的例子，来证明「虚函数表指针」的作用：
// 基类class a {public: virtual void func() // 虚函数 { cout << a::func << endl; }};// 派生类class b : public a {public: virtual void func() // 虚函数 { cout << b::func func(); return 0;}
输出结果：
b::funca::func
第 25-26 行代码中的 pa 指针指向的是 b 类对象，所以 pa->func() 调用的是 b 类对象的虚函数 func() ，输出内容是 b::func ；
第 29-30 行代码的目的是把 a 类的头 8 个字节的「虚函数表指针」存放到 p1 指针和把 b 类的头 8 个字节的「虚函数表指针」存放到 p2 指针；
第 32 行代码目的是把 a 类的「虚函数表指针」 赋值给 b 类的「虚函数表指针」，所以相当于把 b 类的「虚函数表指针」 替换 成了 a 类的「虚函数表指针」；
由于第 32 行的作用，把 b 类的「虚函数表指针」 替换 成了 a 类的「虚函数表指针」，所以第 33 行调用的是 a 类的虚函数 func() ，输出内容是 a::func
通过上述的代码和讲解，可以有效的证明了「虚函数表的指针」的作用，「虚函数表的指针」指向的是「虚函数表」，「虚函数表」里存放的是类里的「虚函数」地址，那么在调用过程中，就能实现多态的特性。
虚析构函数
析构函数是在删除对象或退出程序的时候，自动调用的函数，其目的是做一些资源释放。
那么在多态的情景下，通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数，这就会存在派生类对象的析构函数没有调用到，存在资源泄露的情况。
看如下的例子：
// 基类class a {public: a() // 构造函数 { cout << construct a << endl; } ~a() // 析构函数 { cout << destructor a << endl; }};// 派生类class b : public a {public: b() // 构造函数 { cout << construct b << endl; } ~b()// 析构函数 { cout << destructor b << endl; }};int main() { a *pa = new b(); delete pa; return 0;}
输出结果：
construct aconstruct bdestructor a
从上面的输出结果可以看到，在删除 pa 指针对象时， b 类的析构函数没有被调用。
解决办法：把基类的析构函数声明为virtual
派生类的析构函数可以 virtual 不进行声明；
通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数，还是遵循「先构造，后虚构」的规则。
将上述的代码中的基类的析构函数，定义成「虚析构函数」：
// 基类class a {public: a() { cout << construct a << endl; } virtual ~a() // 虚析构函数 { cout << destructor a << endl; }};
输出结果：
construct aconstruct bdestructor bdestructor a
所以要养成好习惯:
一个类如果定义了虚函数，则应该将析构函数也定义成虚函数;
或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
注意：不允许构造函数不能定义成虚构造函数。
纯虚函数和抽象类
纯虚函数： 没有函数体的虚函数
class a {public: virtual void print( ) = 0 ; //纯虚函数private: int a;};
包含纯虚函数的类叫抽象类
抽象类只能作为基类来派生新类使用，不能创建抽象类的对象
抽象类的指针和引用可以指向由抽象类派生出来的类的对象
a a; // 错，a 是抽象类，不能创建对象a * pa ; // ok,可以定义抽象类的指针和引用pa = new a ; // 错误, a 是抽象类，不能创建对象
明明没上市，华为何以体量惊人？
信号链和PLC如何影响我们的生活
模拟量输入模块的2、3、4线制的接线方式
如何理解工业互联网？如何理解5G+工业互联网？
2018年上半年丘钛指纹识别模组出货量呈现上升趋势
C++多态的实现原理详细讲解
Uber恢复自动驾驶测试，受限测试只能启用人工模式
Type-C在终端与市场上的应用探究
cmd常用命令大全
数字切片扫描仪的自连方案
全球仅6块！七彩虹推出RTX 3090 Vulcan：具体规格参数未披露
远程控制开关该如何接线
蔚来子品牌阿尔卑斯已开始裁员 被曝或不再是独立项目
展望未来十年 信通院发布ICT深度观察十大趋势
声光控延时开关原理与制作
SiliconLottery特挑一批i7-9700K处理器开卖 全核5.1GHz售价569.99美元
智能家居是否有安全性的威胁
通过不同的方法，试图打开人工智能「黑匣子」
LTspice：简单理想化的二极管
NVMe VIP架构：主机功能