北京大学MOOC 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;
}

多态的作用：

在面向对象的程序设计中使用多态，能够增强程序的可扩充性，即程序需要修改或增加功能的时候，需要改动和增加的代码较少。

多态使用实例：几何形体处理程序

何形体处理程序: 输入若干个几何形体的参数，
要求按面积排序输出。输出时要指明形状。
Input:
第一行是几何形体数目n（不超过100).下面有n行，每行以一个字母c开头.
若 c 是 ‘R’，则代表一个矩形，本行后面跟着两个整数，分别是矩形的宽和高；
若 c 是 ‘C’，则代表一个圆，本行后面跟着一个整数代表其半径
若 c 是 ‘T’，则代表一个三角形，本行后面跟着三个整数，代表三条边的长度

Output:
按面积从小到大依次输出每个几何形体的种类及面积。每行一个几何形体，输
出格式为：
形体名称：面积

Sample Input:
3
R 3 5
C 9
T 3 4 5
Sample Output
Triangle:6
Rectangle:15
Circle: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;
    else
        return 0;
}

用基类指针数组存放指向各种派生类对象的指针，然后遍历该数组，就能对各个派生类对象做各种操作，是很常用的做法 。

构造函数和析构函数中调用虚函数：

在构造函数和析构函数中调用虚函数，不是多态。编译时即可确定，调用的函数是自己的类或基类中定义的函数，不会等到运行时才决定调用自己的还是派生类的函数。

虚析构函数：

• 通过基类的指针删除派生类对象时，通常情况下只调用基类的析构函数。但是，删除一个派生类的对象时，应该先调用派生类的析构函数，然后调用基类的析构函数。
• 解决办法：把基类的析构函数声明为virtual。派生类的析构函数可以virtual不进行声明。通过基类的指针删除派生类对象时，首先调用派生类的析构函数，然后调用基类的析构函数
• 一般来说，一个类如果定义了虚函数，则应该将析构函数也定义成虚函数。或者，一个类打算作为基类使用，也应该将析构函数定义成虚函数。
• 注意：不允许以虚函数作为构造函数

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 grandson
bye from son
执行grandson::~grandson() ，引起执行son::~son() ！！！

虚函数的访问权限:

class Base {
    private:
        virtual void fun2() { cout << "Base::fun2()" << endl; }
};
class Derived:public Base {
    public:
        virtual void fun2() { cout << "Derived:fun2()" << endl; }
};
Derived d;
Base * pBase = & d;
pBase -> fun2(); // wrong

•  编译出错是因为 fun2() 是Base的私有成员。即使运行到此时实际上调用的应该是Derived的公有成员 fun2()也不行，因为语法检查是不考虑运行结果的。
• 如果 将Base中的 private换成public,即使Derived中的fun2() 是private的，编译依然能通过，也能正确调用Derived::fun2()。

纯虚函数和抽象类：

纯虚函数： 没有函数体的虚函数

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;
}