虚函数和多态

本章内容为coursera课程C++程序设计中第六周的课件的整理

一、虚函数和多态 

在类的定义中，前面有 virtual 关键字的成员函数就是虚函数。

class base {virtual int get() ;};int base::get(){ }virtual 关键字只用在类定义里的函数声明中，写函数体时不用。
多态的表现形式一派生类的指针可以赋给基类指针。通过基类指针调用基类和派生类中的同名虚函数时:(1)若该指针指向一个基类的对象，那么被调用是基类的虚函数；(2)若该指针指向一个派生类的对象，那么被调用的是派生类的虚函数。这种机制就叫做“多态”。
class CBase {public:virtual void SomeVirtualFunction() { }};class CDerived:public CBase {public :virtual void SomeVirtualFunction() { }};int main() {CDerived ODerived;CBase * p = & ODerived;p -> SomeVirtualFunction(); //调用哪个虚函数取决于p指向哪种类型的对象return 0;}多态的表现形式二派生类的对象可以赋给基类引用。通过基类引用调用基类和派生类中的同名虚函数时:(1)若该引用引用的是一个基类的对象，那么被调用是基类的虚函数；(2)若该引用引用的是一个派生类的对象，那么被调用的是派生类的虚函数。这种机制也叫做“多态”。
class CBase {public:virtual void SomeVirtualFunction() { }};class CDerived:public CBase {public :virtual void SomeVirtualFunction() { }};int main() {CDerived ODerived;CBase & r = ODerived;r.SomeVirtualFunction(); //调用哪个虚函数取决于r引用哪种类型的对象return 0;}多态的简单示例
class A {public :virtual void PRint( ){ cout << "A::Print"<<endl ; }};class B: public A {public :virtual void Print( ) { cout << "B::Print" <<endl; }};class D: public A {public:virtual void Print( ) { cout << "D::Print" << endl ; }};class E: public B {virtual void Print( ) { cout << "E::Print" << endl ; }};int main() {A a; B b; E e; D d;A * pa = &a; B * pb = &b;D * pd = &d ; E * pe = &e;pa->Print(); // a.Print()被调用，输出： A::Printpa = pb;pa -> Print(); //b.Print()被调用，输出： B::Printpa = pd;pa -> Print(); //d. Print ()被调用,输出： D::Printpa = pe;pa -> Print(); //e.Print () 被调用,输出： E::Printreturn 0;}多态的作用在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。
二、更多多态程序实例
几何形体处理程序几何形体处理程序: 输入若干个几何形体的参数，要求按面积排序输出。输出时要指明形状。Input:第一行是几何形体数目n（不超过100).下面有n行，每行以一个字母c开头.若 c 是 ‘R’ ，则代表一个矩形，本行后面跟着两个整数，分别是矩形的宽和高；若 c 是 ‘C’ ，则代表一个圆，本行后面跟着一个整数代表其半径若 c 是 ‘T’ ，则代表一个三角形，本行后面跟着三个整数，代表三条边的长度Output:按面积从小到大依次输出每个几何形体的种类及面积。每行一个几何形体，输出格式为：形体名称：面积
Sample Input:
3R 3 5C 9T 3 4 5Sample OutputTriangle:6Rectangle:15Circle:254.34
#include <iostream>#include <stdlib.h>#include <math.h>using namespace std;class CShape{public:virtual double Area() = 0; //纯虚函数virtual void PrintInfo() = 0;};class CRectangle:public CShape{public:int w,h;virtual double Area();virtual void PrintInfo();};class CCircle:public CShape {public:int r;virtual double Area();virtual void PrintInfo();};class CTriangle:public CShape {public:int a,b,c;virtual double Area();virtual void PrintInfo();}; double CRectangle::Area() {return w * h;}void CRectangle::PrintInfo() {cout << "Rectangle:" << Area() << endl;}double CCircle::Area() {return 3.14 * r * r ;}void CCircle::PrintInfo() {cout << "Circle:" << Area() << endl;}double CTriangle::Area() {double p = ( a + b + c) / 2.0;return sqrt(p * ( p - a)*(p- b)*(p - c));}void CTriangle::PrintInfo() {cout << "Triangle:" << Area() << endl;}CShape * pShapes[100];int MyCompare(const void * s1, const void * s2);int main(){int i; int n;CRectangle * pr; CCircle * pc; CTriangle * pt;cin >> n;for( i = 0;i < n;i ++ ) {char c;cin >> c;switch(c) {case 'R':pr = new CRectangle();cin >> pr->w >> pr->h;pShapes[i] = pr;break;case 'C':pc = new CCircle();cin >> pc->r;pShapes[i] = pc;break;case 'T':pt = new CTriangle();cin >> pt->a >> pt->b >> pt->c;pShapes[i] = pt;break;}}qsort(pShapes,n,sizeof( CShape*),MyCompare);for( i = 0;i <n;i ++)pShapes[i]->PrintInfo();return 0;}int MyCompare(const void * s1, const void * s2){double a1,a2;CShape * * p1 ; // s1,s2 是 void * ，不可写 “ * s1”来取得s1指向的内容CShape * * p2;p1 = ( CShape * * ) s1; //s1,s2指向pShapes数组中的元素，数组元素的类型是CShape *p2 = ( CShape * * ) s2; // 故 p1,p2都是指向指针的指针，类型为 CShape **a1 = (*p1)->Area(); // * p1 的类型是 Cshape * ,是基类指针，故此句为多态a2 = (*p2)->Area();if( a1 < a2 )return -1;else if ( a2 < a1 )return 1;elsereturn 0;}case 'C':pc = new CCircle();cin >> pc->r;pShapes[i] = pc;break;case 'T':pt = new CTriangle();cin >> pt->a >> pt->b >> pt->c;pShapes[i] = pt;break;}}qsort(pShapes,n,sizeof( CShape*),MyCompare);for( i = 0;i <n;i ++)pShapes[i]->PrintInfo();return 0;}
如果添加新的几何形体，比如五边形，则只需要从CShape派生出CPentagon,以及在main中的
switch语句中增加一个case，其余部分不变。
用基类指针数组存放指向各种派生类对象的指针，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法。
多态的又一例子
class Base {public:void fun1() { this->fun2(); } //this是基类指针， fun2是虚函数，所以是多态virtual void fun2() { cout << "Base::fun2()" << endl; }};class Derived:public Base {public:virtual void fun2() { cout << "Derived:fun2()" << endl; }};int main() {Derived d;Base * pBase = & d;pBase->fun1();return 0;}输出： Derived:fun2(）在非构造函数，非析构函数的成员函数中调用虚函数，是多态!!!构造函数和析构函数中调用虚函数在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。//因为先执行自己的类或基类的构造函数，而派生类的构造函数后执行，派生类自己的那一部分成员变量实际上是还没有被初始话的。如果在基类的构造函数中调用了虚函数，而又允许是多态的话，那么在基类构造函数执行期间，会调用派生类的成员函数，可能会出错。
class myclass {public:virtual void hello(){cout<<"hello from myclass"<<endl; };virtual void bye(){cout<<"bye from myclass"<<endl;}};class son:public myclass{ public:void hello(){ cout<<"hello from son"<<endl;};son(){ hello(); };~son(){ bye(); };};//派生类中和基类中虚函数同名同参数表的函数，不加virtual也自动成为虚函数class grandson:public son{ public:void hello(){cout<<"hello from grandson"<<endl;};void bye() { cout << "bye from grandson"<<endl;}grandson(){cout<<"constructing grandson"<<endl;};~grandson(){cout<<"destructing grandson"<<endl;};};int main(){grandson gson;son *pson;pson=&gson;pson->hello(); //多态return 0;}结果：hello from sonconstructing grandsonhello from grandsondestructing grandsonbye from myclass
三、多态的实现原理
思考:“多态”的关键在于通过基类指针或引用调用一个虚函数时，编译时不确定到底调用的是基类还是派生类的函数，运行时才确定 ---- 这叫“动态联编”。“动态联编”底是怎么实现的呢？
提示：请看下面例子程序：
class Base {public:int i;virtual void Print() { cout << "Base:Print" ; }};class Derived : public Base{public:int n;virtual void Print() { cout <<"Drived:Print" << endl; }};int main() {Derived d;cout << sizeof( Base) << ","<< sizeof( Derived ) ;return 0;}程序运行输出结果： 8, 12为什么都多了4个字节？
多态实现的关键 --- 虚函数表每一个有虚函数的类（或有虚函数的类的派生类）都有一个虚函数表，该类的任何对象中都放着虚函数表的指针。虚函数表中列出了该类的虚函数地址。多出来的4个字节就是用来放虚函数表的地址的。
四、虚析构函数
问题：
class CSon{public: ~CSon() { };};class CGrandson : CSon{public: ~CGrandson() { };}int main(){CSon *p = new CGrandson;delete p;return 0;}通过 基类的指针 删除 派生类对象 时只调用基类的析构函数Vs.删除一个 派生类的对象 时先调用 派生类的析构函数再调用 基类的析构函数
解决办法:把基类的析构函数声明为virtual• 派生类的析构函数 virtual可以不进行声明• 通过 基类的指针 删除 派生类对象 时首先调用 派生类的析构函数然后调用 基类的析构函数类如果定义了虚函数, 则最好将析构函数也定义成虚函数Note: 不允许以虚函数作为构造函数
class son{public:~son() { cout<<"bye from son"<<endl; };};class grandson : public son{public:~grandson(){ cout<<"bye from grandson"<<endl; };};int main(){son *pson;pson=new grandson;delete pson;return 0;}输出结果: bye from son没有执行grandson::~grandson()!!!
class son{public:virtual ~son() { cout<<"bye from son"<<endl; };};class grandson : public son{public:~grandson(){ cout<<"bye from grandson"<<endl; };};int main() {son *pson;pson= new grandson;delete pson;return 0;}输出结果: bye from grandsonbye from son执行grandson::~grandson(),引起执行son::~son()！！！五、纯虚函数和抽象类纯虚函数: 没有函数体的虚函数
class A {private:int a;public:virtual void Print( ) = 0 ; //纯虚函数void fun() { cout << “fun”; }};抽象类抽象类: 包含纯虚函数的类• 只能作为 基类 来派生新类使用• 不能创建抽象类的对象• 抽象类的指针和引用 即由抽象类派生出来的类的对象A a; // 错, A 是抽象类, 不能创建对象A * pa; // ok, 可以定义抽象类的指针和引用pa = new A; //错误, A 是抽象类, 不能创建对象
抽象类中,• 在 成员函数 内可以调用纯虚函数• 在 构造函数/析构函数 内部不能调用纯虚函数如果一个类从抽象类派生而来,它实现了基类中的所有纯虚函数, 才能成为非抽象类(即使只加了一个｛｝，也算实现了)
class A {public:virtual void f() = 0; //纯虚函数void g( ) { this->f( ); } //ok 成员函数允许调用纯虚函数A( ){ } //f( ); // 错误 构造函数不允许调用纯虚函数};class B : public A{public:void f(){ cout<<"B: f()"<<endl; }};int main(){B b;b.g();return 0;}输出结果:B: f()