本篇要学习的内容和知识结构概览
多态性
编译时的多态性称为静态联编. 当调用重载函数时, 在编译期就确定下来调用哪个函数.
运行时的多态性称为动态联编. 在运行时才能确定调用哪个函数, 由虚函数来支持.
静态联编中的赋值兼容性及名字支配规律
派生一个类的原因并非总是为了添加新的成员或成员函数, 有时是为了重新定义基类的成员函数。
#define PI 3.14159 class Point { double x; double y; public: Point(double a, double b) { x = a; y = b; } double area() { return 0; } }; class Circle: public Point { double radius; public: Circle(double a, double b, double r):Point(a, b) { radius = r; } double area() { return PI * radius * radius; } }; int main() { Point a(1.5, 6.7); Circle c(1.5, 6.7, 2.5); cout << a.area() << endl; // 调用对象a的成员函数area() cout << c.area() << endl; // 调用对象c的成员函数area() Point * p = &c; // 对象c的地址为指向Point类型指针赋值 cout << p -> area() << endl; // 调用Point类的成员函数area() Point & rc = c; // 对象c初始化Point类型的引用 cout << rc.area() << endl; // 调用Point类的成员函数area() }
在派生类有同名函数的情况下
Point * pPoint; // 声明的基类指针只能指向基类
Circle * pCircle // 声明的派生类指针只能指向派生类
如果派生类没有基类的同名函数, 派生类的指针才根据继承原则调用基类的函数
虚函数
一旦定义了虚函数, 该基类的派生类中的同名函数也自动成为虚函数.
虚函数的定义
用关键字virtual来声明一个虚函数, 虚函数只能是类中的一个成员函数, 不能是静态成员.
像这样:
class Point { double x; double y; public: Point(double a, double b) { x = a; y = b; } // 用virtual关键字来定义一个虚函数 virtual double area() { return 0; } }; class Circle: public Point { double radius; public: Circle(double a, double b, double r):Point(a, b) { radius = r; } // 基类中area()函数为虚函数, 派生类中的同名函数也自动成为虚函数 double area() { return PI * radius * radius; } };
虚函数实现多态性的条件
关键字virtual告诉编译器调用虚函数进行动态联编.
使用虚函数不一定产生多态性, 也不一定使用动态联编.
在调用中对虚函数使用成员名限定, 可以强制编译器对该函数使用静态联编.
产生运行多态性, 也就是动态联编有3个前提
(1)类之间的继承关系满足赋值兼容性规则
(2)改写了同名虚函数
(3)根据赋值兼容性规则使用指针(或引用)
像这样:
class Point { double x; double y; public: Point(double a, double b) { x = a; y = b; } // 用virtual关键字来定义一个虚函数 virtual double area() { return 0; } }; class Circle: public Point { double radius; public: Circle(double a, double b, double r):Point(a, b) { radius = r; } // 基类中area()函数为虚函数, 派生类中的同名函数也自动成为虚函数 double area() { return PI * radius * radius; } }; void display(Point * p) { cout << p -> area() << endl; } void display(Point & a) { cout << a.area() << endl; } int main() { Point a(1.5, 6.7); Circle c(1.5, 6.7, 2.5); Point * p = &c; // 对象c的地址为指向Point类型指针赋值 Point & rc = c; // 对象c初始化Point类型的引用 display(a); // 调用对象a的成员函数area() display(p); // 根据运行时的多态性, p指向的c对象, 所以实际调用c对象的成员函数area() display(rc); // 根据运行时的多态性, rc是对c对象的引用, 所以实际调用c对象的成员函数area() /** 输出结果 0 19.6349 19.6349 */ }
纯虚函数与抽象类
在基类中不给虚函数一个有意义的定义, 可以说明为纯虚函数, 将定义留给派生类去做
像这样:
class 类名 { public: virtual 函数类型 函数名(参数列表) = 0; };
抽象类:包含有纯虚函数的类称为抽象类. 一个抽象类至少有一个纯虚函数, 一个抽象类只能作为基类来派生新类, 不能说明抽象类的对象.
class Point { double x; double y; public: Point(double a, double b) { x = a; y = b; } // 用virtual关键字来定义一个虚函数 virtual double area() = 0; }; int main() { // Point a(1.5, 6.7); // Point为抽象类, 不能实例化一个对象 error Variable type 'Point' is an abstract class Point * p; // Point为抽象类, 可以声明一个指向抽象类对象的指针 }
注意
空虚函数定义 virtual void area() {}
纯虚函数定义 virtual void area() = 0;
纯虚函数的派生类仍是抽象类. 如果派生类中给出了基类所有纯虚函数的实现, 则该派生类不再是抽象类
类族
如果通过同一个基类派生一系列的类, 则将这些类总称为类族.
像这样:
#define PI 3.14159 // 抽象类 有一个纯虚函数 area() class Shape { public: virtual double area() = 0; }; // 正方形 有一个连长数据成员 class Square: public Shape { protected: double h; public: Square(double a) { h = a; } double area() { return h * h; } }; // 圆 class Circle: public Square { public: Circle(double a):Square(a) { } double area() { return h * h * PI; } }; // 三角形 class Triangle: public Square { protected: double w; public: Triangle(double a, double b):Square(a) { w = b; } double area() { return w * h * 0.5; } }; // 矩形 class Rect: public Triangle { public: Rect(double a, double b):Triangle(a, b) { } double area() { return w * h; } }; int main() { Shape * s[5]; s[0] = new Square(4); s[1] = new Circle(10); s[2] = new Rect(3, 6); s[3] = new Triangle(3, 6); s[4] = new Square(6); for (int i = 0; i < 5; i++) { // 因为虚函数支持动态联编, 所以在运行时才确定每个元素的类型, 调用各自的成员函数 cout << "s[" << i << "] = " << s[i] -> area() << endl; } }
多重继承与虚函数
多重继承可以被视为多个单一继承的组合。
// 基类 class A { public: virtual void func() { cout << "call A" << endl; } }; // 基类 class B { public: virtual void func() { cout << "call B" << endl; } }; // 多重继承 class C: public A, public B { public: void func() { cout << "call C" << endl; } }; int main() { A * pa; B * pb; C * pc, c; pa = &c; pb = &c; pc = &c; pa -> func(); // 动态联编, pa指向派生类对象c, 调用对象c的成员函数C::func(); pb -> func(); // 动态联编, pb指向派生类对象c, 调用对象c的成员函数C::func(); pc -> func(); // pc既是指向C类对象的指针, 又是指向的C类对象, 调用对象c的成员函数C::func(); }
总结
C++有两种多态性, 一种是编译时多态性, 也叫静态联编; 另一种是运行时多态性, 也叫动态联编. 这大大提高了我们解决问题的丰富性. 可能也是C++长久不衰的魅力所在吧! 我会继续深入学习C++, 继续挖掘语言的本质!
自学C/C++编程难度很大,不妨和一些志同道合的小伙伴一起学习成长!
C语言C++编程学习交流圈子,【点击进入】微信公众号:C语言编程学习基地