14. C++多态

14.1 多态的基本概念

在C++程序中，程序的每一个函数在内存中会被分配一段存储空间，而被分配的存储空间的起始地址则为函数的入口地址。
在设计一个程序时都必须为程序设计一个主函数，主函数同样会在内存中被分配一段存储空间，这段存储空间的起始地址即为函数的入口地址。

函数的入口地址与函数名是在编译时进行绑定的，我们称之为编译期绑定（静态绑定）。
而多态的功能则是将函数名动态绑定到函数入口地址，这样的动态绑定过程称为运行期绑定。
函数名与函数入口地址在程序编译时无法绑定到一起，只有等运行的时候才确定函数名与哪一个函数入口绑定到一起。
ps：有些人也喜欢将静态绑定和动态绑定都叫做多态，仁者见仁智者见智了。

---

C++中多态基本与虚函数是密不可分的，换句话说，有了虚函数我们才可以去实现多态。
针对虚函数的必要性，看一下例子：

#include<iostream>
using namespace std;

class base
{
public:
    void display(){cout<<"I'm base class!"<<endl;}
};

class derived: public base
{
public:
    void display(){cout<<"I'm derived class!"<<endl;}

};

int main()
{
    base * p;
    derived test;
    p = &test;
    p->display();
    return 0;
}

image.png

函数同名，故在派生类对象中会出现遮蔽现象，即派生类中的display函数会遮蔽基类中的display函数。

要想形成多态必须具备以下三个条件：

• 必须存在继承关系；
• 继承关系中必须有同名的虚函数；
• 存在基类类型的指针或引用，通过该指针或引用调用虚函数。

修改为多态特性的：

#include<iostream>
using namespace std;

class base
{
public:
    virtual void display(){cout<<"I'm base class!"<<endl;}
};

class derived: public base
{
public:
    virtual void display(){cout<<"I'm derived class!"<<endl;}
};

int main()
{
    base * p;
    derived test;
    p = &test;
    p->display();
    return 0;
}

image.png

---

14.2 虚成员函数

虚函数就是在函数返回类型前加上virtual关键字。
virtual关键字仅用于函数声明，如果函数是在类外定义，则不需要再加上virtual关键字了，在C++中只有类中的成员函数能被声明为虚函数，
而对于顶层函数则不能声明为虚函数，因为声明虚函数是为了构成多态，而构成多态的第一个条件就是需要继承关系，顶层函数很明显是不具有继承关系的。

和普通的成员函数一样，虚成员函数同样可以被继承。

#include<iostream>
using namespace std;

class base
{
public:
    virtual void hello(){cout<<"Hello!"<<endl;}
};

class derived: public base
{
    //......
};

int main()
{
    base * p = new base;
    p->hello();
    delete p;
    p = new derived;
    p->hello();
    delete p;
    derived d;
    d.hello();
    return 0;
}

派生类中并不存在与基类hello函数具有相同函数名的虚函数（继承过来的hello函数与基类中的hello函数并未构成遮蔽关系），并未构成多态，自始至终都是调用的都是基类的hello函数。之后又定义了一个派生类对象d，这个对象调用hello函数，当然则个hello同样是继承自基类base中的hello函数了,很明显看出虚函数是具有继承特性的。

---

14.2 虚成员函数表vtable

在C++中通过虚成员函数表vtable实现多态，虚函数表中存储的是类中虚函数的入口地址。
在普通的类中是没有虚函数表的，只有在具有虚函数的类中（无论是自身添加的虚函数还是继承过来的虚函数）才会具有虚函数表，通常虚成员函数表的首地址将会被存入对象的最前面（在32位的操作系统中，存储地址是用4个字节，因此这个首地址就会占用对象的前四个字节的空间）。

#include<iostream>
using namespace std;
class base{
public:    
    virtual void v1(){ }    
    virtual void v2(){ }
};
class derived: public base{
public:    
    virtual void v1(){ }    
    virtual void v2(){ }
};

int main(){    
    base b;    
    derived d;    
    base *p;    
    p = &b;    
    p->v1();    
    p->v2();    
    p = &d;    
    p->v1();    
    p->v2();    
    return 0;
}

image.png

虚函数表里面存储的就是虚函数的入口地址。
在主函数中先定义了base类对象b，因为b类中有虚函数，因此存在虚函数表，而虚函数表的首地址就存储在对象所在存储空间的最前，具体情况可以见下图。

image.png

---

14.3 虚析构函数

析构函数则用于销毁对象时完成相应的资源释放工作，析构函数可以被声明为虚函数。

#include<iostream>
using namespace std;

class base
{
public:
    base();
    ~base();
private:
    int * a;
};

class derived: public base
{
public:
    derived();
    ~derived();
private:
    int * b;
};

base::base()
{
    cout<<"base constructor!"<<endl;
    a = new int[10];
}

base::~base()
{
    cout<<"base destructor!"<<endl;
    delete[] a;
}

derived::derived()
{
    cout<<"derived constructor!"<<endl;
    b = new int[1000];
}

derived::~derived()
{
    cout<<"derived destructor!"<<endl;
    delete[] b;
}

int main()
{
    base* p;
    p = new derived;
    delete p;
    return 0;
}

image.png

派生类的析构函数，不调用派生类的析构函数则会导致b指针所指向的1000个整型存储空间不会被释放，如此一来造成了内存泄露了。这是就需要虚析构函数来解决问题了。
修改基类：

class base
{
public:
    base();
    virtual ~base();
private:
    int * a;
};

注意：
1、如果基类中存在一个指向动态分配内存的成员变量，并且基类的析构函数中定义了释放该动态分配内存的代码，则应该将基类的析构函数声明为虚函数。
2、只有非静态成员函数才可以成为虚函数，而静态成员函数不能声明为虚函数。

---