c++中的多态机制
2020-04-04 16:01:02来源:博客园 阅读 ()
c++中的多态机制
静态联编与动态联编、赋值兼容性原则、多态原理详解、虚析构函数、纯虚函数、抽象类、接口目录
1 背景介绍
2 多态介绍
2-1 什么是多态
2-2 多态的分类
2-3 动态多态成立的条件
2-4 静态联编和动态联编
2-5 动态多态的实现原理
2-6 虚析构函数
2.7 关于虚函数的思考题
2.8 纯虚函数、抽象类、接口
背景介绍
虚函数重写:子类重新定义父类中有相同返回值、名称和参数的虚函数;
非虚函重写:子类重新定义父类中有相同名称和参数的非虚函数;
父子间的赋值兼容:子类对象可以当作父类对象使用(兼容性);具体表现为:
1. 子类对象可以直接赋值给父类对象;
2. 子类对象可以直接初始化父类对象;
3. 父类指针可以直接指向子类对象;
4. 父类引用可以直接引用子类对象;
当发生赋值兼容时,子类对象退化为父类对象,只能访问父类中定义的成员,可以直接访问被子类覆盖的同名成员;
1 // 在赋值兼容原则中,子类对象退化为父类对象,子类是特殊的父类; 2 #include <iostream> 3 #include <string> 4 5 using namespace std; 6 7 class Parent 8 { 9 public: 10 int mi; 11 12 void add(int i) 13 { 14 mi += i; 15 } 16 17 void add(int a, int b) 18 { 19 mi += (a + b); 20 } 21 }; 22 23 class Child : public Parent 24 { 25 public: 26 int mi; 27 28 void add(int x, int y, int z) 29 { 30 mi += (x + y + z); 31 } 32 }; 33 34 int main() 35 { 36 Parent p; 37 Child c; 38 39 c.mi = 100; 40 p = c; // p.mi = 0; 子类对象退化为父类对象 41 Parent p1(c); // p1.mi = 0; 同上 42 Parent& rp = c; 43 Parent* pp = &c; 44 45 rp.add(5); 46 pp->add(10, 20); 47 48 cout << "p.mi: " << p.mi <<endl; // p.mi: 0; 49 cout << "p1.mi: " << p1.mi <<endl; // p1.mi: 0; 50 cout << "c.Parent::mi: " << c.Parent::mi <<endl; // c.Parent::mi: 35 51 cout << "rp.mi: " << rp.mi <<endl; // rp.mi: 35 52 cout << "pp->mi: " << pp->mi <<endl; // pp->mi: 35 53 54 return 0; 55 }赋值兼容测试
在面向对象的继承关系中,我们了解到子类可以拥有父类中的所有属性与行为;但是,有时父类中提供的方法并不能满足现有的需求,所以,我们必须在子类中重写父类中已有的方法,来满足当前的需求。此时尽管我们已经实现了函数重写(这里是非虚函数重写),但是在类型兼容性原则中也不能出现我们期待的结果(不能根据指针/引用所指向的实际对象类型去调到对应的重写函数)。接下来我们用代码来复现这个情景:
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Parent 7 { 8 public: 9 void print() 10 { 11 cout << "I'm Parent." << endl; 12 } 13 }; 14 15 class Child : public Parent 16 { 17 public: 18 void print() 19 { 20 cout << "I'm Child." << endl; 21 } 22 }; 23 24 void how_to_print(Parent* p) 25 { 26 p->print(); 27 } 28 29 int main() 30 { 31 Parent p; 32 Child c; 33 34 how_to_print(&p); // I'm Parent // Expected to print: I'm Parent. 35 how_to_print(&c); // I'm Parent // Expected to print: I'm Child. 36 37 return 0; 38 }非虚函数重写与赋值兼容的问题
为什么会出现上述现象呢?(在赋值兼容中,父类指针/引用指向子类对象时为何不能调用子类重写函数?)
问题分析:在编译期间,编译器只能根据指针的类型判断所指向的对象;根据赋值兼容,编译器认为父类指针指向的是父类对象;因此,编译结果只可能是调用父类中定义的同名函数。
在编译这个函数的时候,编译器不可能知道指针p究竟指向了什么。但是编译器没有理由报错,于是,编译器认为最安全的做法是调用父类的print函数。因为父类和子类肯定都有相同的print函数。
要想解决这个问题,就需要使用c++中的多态。那么如何实现c++中的多态呢?请看下面详解:
多态介绍
1、 什么是多态
在现实生活中,多态是同一个事物在不同场景下的多种形态。
在面向对象中,多态是指通过基类的指针或者引用,在运行时动态调用实际绑定对象函数的行为。与之相对应的编译时绑定函数称为静态绑定。
多态是设计模式的基础,多态是框架的基础。2、 多态的分类
静态多态是编译器在编译期间完成的,编译器会根据实参类型来选择调用合适的函数,如果有合适的函数就调用,没有的话就会发出警告或者报错;
动态多态是在程序运行时根据基类的引用(指针)指向的对象来确定自己具体该调用哪一个类的虚函数。
3、动态多态成立的条件
由之前出现的问题可知,编译器的做法并不符合我们的期望(因为编译器是根据父类指针的类型去父类中调用被重写的函数);但是,在面向对象的多态中,我们期望的行为是 根据实际的对象类型来判断如何调用重写函数(虚函数);
1. 即当父类指针(引用)指向 父类对象时,就调用父类中定义的虚函数;
2. 即当父类指针(引用)指向 子类对象时,就调用子类中定义的虚函数;
这种多态行为的表现效果为:同样的调用语句在实际运行时有多种不同的表现形态。
那么在c++中,如何实现这种表现效果呢?(实现多态的条件)
1. 要有继承
2. 要有虚函数重写(被 virtual 声明的函数叫虚函数)
3. 要有父类指针(父类引用)指向子类对象
4、静态联编和动态联编
静态联编:在程序的编译期间就能确定具体的函数调用;如函数重载,非虚函数重写;
动态联编:在程序实际运行后才能确定具体的函数调用;如虚函数重写,switch 语句和 if 语句;
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Parent 7 { 8 public: 9 virtual void func() 10 { 11 cout << "Parent::void func()" << endl; 12 } 13 14 virtual void func(int i) 15 { 16 cout << "Parent::void func(int i) : " << i << endl; 17 } 18 19 virtual void func(int i, int j) 20 { 21 cout << "Parent::void func(int i, int j) : " << "(" << i << ", " << j << ")" << endl; 22 } 23 }; 24 25 class Child : public Parent 26 { 27 public: 28 void func(int i, int j) 29 { 30 cout << "Child::void func(int i, int j) : " << i + j << endl; 31 } 32 33 void func(int i, int j, int k) 34 { 35 cout << "Child::void func(int i, int j, int k) : " << i + j + k << endl; 36 } 37 }; 38 39 void run(Parent* p) 40 { 41 p->func(1, 2); // 展现多态的特性 42 // 动态联编 43 } 44 45 46 int main() 47 { 48 Parent p; 49 50 p.func(); // 静态联编 51 p.func(1); // 静态联编 52 p.func(1, 2); // 静态联编 53 54 cout << endl; 55 56 Child c; 57 58 c.func(1, 2); // 静态联编 59 60 cout << endl; 61 62 run(&p); 63 run(&c); 64 65 return 0; 66 } 67 /* 68 Parent::void func() 69 Parent::void func(int i) : 1 70 Parent::void func(int i, int j) : (1, 2) 71 72 Child::void func(int i, int j) : 3 73 74 Parent::void func(int i, int j) : (1, 2) 75 Child::void func(int i, int j) : 3 76 */静态联编与动态联编的案列
5、动态多态的实现原理
虚函数表与vptr指针
1. 当类中声明虚函数时,编译器会在类中生成一个虚函数表;
2. 虚函数表是一个存储类成员函数指针的数据结构;
3. 虚函数表是由编译器自动生成与维护的;
4. virtual成员函数会被编译器放入虚函数表中;
5. 存在虚函数时,每个对象中都有一个指向虚函数表的指针(vptr指针)。
多态执行过程:
1. 在类中,用 virtual 声明一个函数时,就会在这个类中对应产生一张 虚函数表,将虚函数存放到该表中;
2. 用这个类创建对象时,就会产生一个 vptr指针,这个vptr指针会指向对应的虚函数表;
3. 在多态调用时, vptr指针 就会根据这个对象 在对应类的虚函数表中 查找被调用的函数,从而找到函数的入口地址;
》 如果这个对象是 子类的对象,那么vptr指针就会在 子类的 虚函数表中查找被调用的函数
》 如果这个对象是 父类的对象,那么vptr指针就会在 父类的 虚函数表中查找被调用的函数
注:出于效率考虑,没有必要将所有成员函数都声明为虚函数。
如何证明vptr指针的存在?
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Demo1 7 { 8 private: 9 int mi; // 4 bytes 10 int mj; // 4 bytes 11 public: 12 virtual void print(){} // 由于虚函数的存在,在实例化类对象时,就会产生1个 vptr指针 13 }; 14 15 class Demo2 16 { 17 private: 18 int mi; // 4 bytes 19 int mj; // 4 bytes 20 public: 21 void print(){} 22 }; 23 24 int main() 25 { 26 cout << "sizeof(Demo1) = " << sizeof(Demo1) << " bytes" << endl; // sizeof(Demo1) = 16 bytes 27 cout << "sizeof(Demo2) = " << sizeof(Demo2) << " bytes" << endl; // sizeof(Demo2) = 8 bytes 28 29 return 0; 30 } 31 32 // 64bit(OS) 指针占 8 bytes 33 // 32bit(OS) 指针占 4 bytesvptr指针的证明
显然,在普通的类中,类的大小 == 成员变量的大小;在有虚函数的类中,类的大小 == 成员变量的大小 + vptr指针大小。
6、 虚析构函数
定义:用 virtual 关键字修饰析构函数,称为虚析构函数;
格式:virtual ~ClassName(){ ... }
意义:虚析构函数用于指引 delete 运算符正确析构动态对象;(当父类指针指向子类对象时,通过父类指针去释放所有子类的内存空间)
应用场景:在赋值兼容性原则中(父类指针指向子类对象),通过 delete 父类指针 去释放所有子类的内存空间。(动态多态调用:通过父类指针所指向的实际对象去判断如何调用 delete 运算符)
!!:建议在设计基类时将析构函数声明为虚函数,为的是避免内存泄漏,否则有可能会造成派生类内存泄漏问题。案列分析
1 #include <iostream> 2 #include <cstring> 3 4 using namespace std; 5 6 class Base 7 { 8 protected: 9 char *name; 10 public: 11 Base() 12 { 13 name = new char[20]; 14 strcpy(name, "Base()"); 15 cout <<this << " " << name << endl; 16 } 17 18 ~Base() 19 { 20 cout << this << " ~Base()" << endl; 21 delete[] name; 22 } 23 }; 24 25 26 class Derived : public Base 27 { 28 private: 29 int *value; 30 public: 31 Derived() 32 { 33 strcpy(name, "Derived()"); 34 value = new int(strlen(name)); 35 cout << this << " " << name << " " << *value << endl; 36 } 37 38 ~Derived() 39 { 40 cout << this << " ~Derived()" << endl; 41 delete value; 42 } 43 }; 44 45 46 int main() 47 { 48 cout << "在赋值兼容中,关于 子类对象存在内存泄漏的测试" << endl; 49 50 Base* bp = new Derived(); 51 cout << bp << endl; 52 // ... 53 delete bp; // 虽然是父类指针,但析构的是子类资源 54 55 return 0; 56 } 57 58 /** 59 * 在赋值兼容中,关于 子类对象存在内存泄漏的测试 60 * 0x7a1030 Base() 61 * 0x7a1030 Derived() 9 62 * 0x7a1030 63 * 0x7a1030 ~Base() 64 */赋值兼容中,子类内存泄漏案列
1 #include <iostream> 2 #include <cstring> 3 4 using namespace std; 5 6 class Base 7 { 8 protected: 9 char *name; 10 public: 11 Base() 12 { 13 name = new char[20]; 14 strcpy(name, "Base()"); 15 cout <<this << " " << name << endl; 16 } 17 18 virtual ~Base() 19 { 20 cout << this << " ~Base()" << endl; 21 delete[] name; 22 } 23 }; 24 25 26 class Derived : public Base 27 { 28 private: 29 int *value; 30 public: 31 Derived() 32 { 33 strcpy(name, "Derived()"); 34 value = new int(strlen(name)); 35 cout << this << " " << name << " " << *value << endl; 36 } 37 38 virtual ~Derived() 39 { 40 cout << this << " ~Derived()" << endl; 41 delete value; 42 } 43 }; 44 45 46 int main() 47 { 48 //Derived *dp = new Derived(); 49 //delete dp; // 直接通过子类对象释放资源不需要 virtual 关键字 50 51 cout << "在赋值兼容中,虚析构函数的测试" << endl; 52 53 Base* bp = new Derived(); 54 cout << bp << endl; 55 // ... 56 delete bp; // 动态多态发生 57 58 return 0; 59 } 60 61 /** 62 * 在赋值兼容中,虚析构函数的测试 63 * 0x19b1030 Base() 64 * 0x19b1030 Derived() 9 65 * 0x19b1030 66 * 0x19b1030 ~Derived() 67 * 0x19b1030 ~Base() 68 */虚析构函数解决子类内存泄漏案列
两个案列的区别:第1个案列只是普通的析构函数;第2个案列是虚析构函数。
7、 关于虚函数的思考题
1. 构造函数可以成为虚函数吗?--- 不可以
不可以。因为在构造函数执行结束后,虚函数表指针才会被正确的初始化。
在c++的多态中,虚函数表是由编译器自动生成与维护的,虚函数表指针是由构造函数初始化完成的,即构造函数相当于是虚函数的入口点,负责调用虚函数的前期工作;在构造函数执行的过程中,虚函数表指针有可能未被正确的初始化;由于在不同的c++编译器中,虚函数表 与 虚函数表指针的实现有所不同,所以禁止将构造函数声明为虚函数。
2. 析造函数可以成为虚函数吗?--- 虚函数,且发生多态
可以,并且产生动态多态。因为析构函数是在对象销毁之前被调用,即在对象销毁前 虚函数表指针是正确指向对应的虚函数表。
3. 构造函数中可以调用虚函数发生多态吗?--- 不能发生多态
构造函数中可以调用虚函数,但是不可能发生多态行为,因为在构造函数执行时,虚函数表指针未被正确初始化。
4. 析构函数中可以调用虚函数发生多态吗?--- 不能发生多态
析构函数中可以调用虚函数,但是不可能发生多态行为,因为在析构函数执行时,虚函数表指针已经被销毁。
1 #include <iostream> 2 #include <string> 3 4 using namespace std; 5 6 class Base 7 { 8 public: 9 Base() 10 { 11 cout << "Base()" << endl; 12 13 func(); 14 } 15 16 virtual void func() 17 { 18 cout << "Base::func()" << endl; 19 } 20 21 virtual ~Base() 22 { 23 func(); 24 25 cout << "~Base()" << endl; 26 } 27 }; 28 29 30 class Derived : public Base 31 { 32 public: 33 Derived() 34 { 35 cout << "Derived()" << endl; 36 37 func(); 38 } 39 40 virtual void func() 41 { 42 cout << "Derived::func()" << endl; 43 } 44 45 virtual ~Derived() 46 { 47 func(); 48 49 cout << "~Derived()" << endl; 50 } 51 }; 52 53 void test() 54 { 55 Derived d; 56 } 57 58 int main() 59 { 60 //栈空间 61 test(); 62 63 // 堆空间 64 //Base* p = new Derived(); 65 //delete p; // 多态发生(指针p指向子类对象,并且又有虚函数重写) 66 67 return 0; 68 } 69 /* 70 Base() 71 Base::func() 72 Derived() 73 Derived::func() 74 Derived::func() 75 ~Derived() 76 Base::func() 77 ~Base() 78 */构造与析构中调用虚函数案列
结论:在构造函数与析构函数中调用虚函数不能发生多态行为,只调用当前类中定义的函数版本! !
8、纯虚函数、抽象类、接口
1. 定义 --- 以案例的方式说明
想必大家很熟悉,对于任何一个普通类来说都可以实例化出多个对象,也就是每个对象都可以用对应的类来描述,并且这些对象在现实生活中都能找到各自的原型;比如现在有一个“狗类??”,我们就可以用这个“狗类??”实例化出很多只“狗??”。但是,在面向对象分析时,还会发现一些抽象的概念,它描述的是一类事物,并不能反映一个具体的实物,我们把这种包含抽象概念的现象称为 抽象类。关于抽象类的例子有很多,比如:如何计算一个“图形”的面积;什么“宠物”最可爱 等等。了解了抽象类之后,那么什么是纯虚函数呢?我们现在就以 如何计算一个“图形”的面积 这个抽象类案列说明问题;在这个例子中有2个抽象概念,分别是 “图形” 与 “面积”,即什么样“图形” --- 不知道,如何”求面积“或者“面积公式”是什么 --- 也不知道;在这里,我们可以把”图形“看成是抽象类的类名,”面积“看成是抽象类的成员函数,因为这个成员函数无法实现,只是让外界知道有这么一回事,此处的成员函数就可以看成 纯虚函数,同时,此处的抽象类也可以看成是 接口。
2. 特点
纯虚函数:
(1)只在基类中声明虚函数,并不需要在基类中定义函数体,语法格式:virtual void funtion1()=0;
(2)“=0”是告诉编译器当前是声明纯虚函数,因此并不需要定义函数体。
(3)纯虚函数被实现后成为虚函数;
(4)基类中的纯虚函数就是个接口,纯虚函数不能被调用,它的存在只是为了在派生类中重新实现该方法;
(5)c++ 规定虚析构函数必须包含声明与实现(在对象销毁前,基类中的析构函数最后一个被调用,若此时没有对应的函数实现,显然是不行的);
抽象类:
(1)用于表示现实世界中的抽象概念;
(2)是一种只能定义类型,而不能创建对象的类;但是,可以有抽象类指针 或 接口类指针,当它指向子类对象时就会发生多态;
(3)抽象类只能用作父类被继承,子类必须实现纯虚函数的具体功能;
(4)c++语言中没有抽象类的概念,但是可以通过纯虚函数实现抽象类;
(5)一个c++类中存在纯虚函数就成为了抽象类;(判断条件)
(6)如果子类没有实现纯虚函数,则子类成为抽象类。
接口:
(1)类中没有定义任何的成员变量;
(2)所有的成员函数都是公有的纯虚函数;(判断条件 1 + 2)
(3)接口是一种特殊的抽象类;
一个类全是纯虚函数就是接口;
一个类部分是纯虚函数就是抽象类;
3. 引入原因
(1)为了方便使用多态特性,我们常常需要在基类中声明纯虚函数。
(2)在很多情况下,基类本身生成对象是不合情理的。例如,动物作为一个基类可以派生出老虎、孔雀等子类,但动物本身生成对象明显不合常理。
所以,为了解决上述问题,引入了纯虚函数的概念;将基类的成员函数声明为纯虚函数,则编译器要求必须在派生类中重写该成员函数以实现多态性。
1 #include <iostream> 2 #include <typeinfo> 3 4 using namespace std; 5 6 class Shape 7 { 8 public: 9 virtual double area() = 0; 10 }; 11 12 class Rect : public Shape 13 { 14 int ma; 15 int mb; 16 public: 17 Rect(int a, int b) 18 { 19 ma = a; 20 mb = b; 21 } 22 double area() 23 { 24 return ma * mb; 25 } 26 }; 27 28 class Circle : public Shape 29 { 30 int mr; 31 public: 32 Circle(int r) 33 { 34 mr = r; 35 } 36 double area() 37 { 38 return 3.14 * mr * mr; 39 } 40 }; 41 42 void area(Shape* p) 43 { 44 const type_info &tis = typeid(*p); 45 46 if( tis == typeid(Rect) ) 47 { 48 Rect *rect = dynamic_cast<Rect*>(p); 49 50 cout << "the area of the Rect : " << rect->area() << endl; 51 } 52 53 if( tis == typeid(Circle) ) 54 { 55 Circle *circle = dynamic_cast<Circle*>(p); 56 57 cout << "the area of the Circle : " << circle->area() << endl; 58 } 59 60 } 61 62 int main() 63 { 64 Rect rect(1, 2); 65 Circle circle(10); 66 67 area(&rect); 68 area(&circle); 69 70 return 0; 71 } 72 /** 73 * 运行结果: 74 * the area of the Rect : 2 75 * the area of the Circle : 314 76 */如何使用抽象类计算一个"图形"的面积
原文链接:https://www.cnblogs.com/nbk-zyc/p/12274178.html
如有疑问请与原作者联系
标签:
版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有
上一篇:第一章 从C到C++
下一篇:第三章 类与对象进阶
- C++ 转换函数搭配友元函数 2020-06-10
- C++ 自动转换和强制类型转换(用户自定义类类型) 2020-06-10
- C++ rand函数 2020-06-10
- C++ 友元函数 2020-06-10
- C++ 运算符重载 2020-06-10
IDC资讯: 主机资讯 注册资讯 托管资讯 vps资讯 网站建设
网站运营: 建站经验 策划盈利 搜索优化 网站推广 免费资源
网络编程: Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它
服务器技术: Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护
软件技巧: 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷
网页制作: FrontPages Dreamweaver Javascript css photoshop fireworks Flash