C++面向对象-6

C++多态

C++的多态意味着调用成员函数时，会根据调用的对象的类型来执行不同的函数

编译时的多态，编译时就确定了具体的操作过程。
运行时的多态，程序运行过程中才确定的操作过程。
操作的过程即称为联编，也称为绑定。

• 静态联编（早绑定），在编译和连接时确认的。比如函数重载，函数模板。效率高
• 动态联编（后期绑定），运行的时候才能确定是哪块代码段。灵活

静态联编

函数调用在程序执行前就准备好了

#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
    private:
        int x;
        int y;
    public:
        Point(int x=0,int y=0)
        {
            this->x=x;
            this->y=y;
        }
        double area()
        {
            return 0.0;
        }
};

class Circle: public Point
{
    private:
        int r;
    public:
        Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数，派生类中的构造函数需要自定义 
        {
            this->r=R;
        }
        double area()
        {
            return r*r*PI;
        }
};

int main()
{
    Point A(3,3);//一个点 
    Circle B(3,3,3);       //一个圆

    cout<<A.area()<<endl;
    cout<<B.area()<<endl;

    Point *ptr;  //Point类型的指针 
    ptr = &B;    //指向了Circle类型 
    cout<<ptr->area()<<endl;//输出结果不理想 

    return 0;
}

第三个cout输出0的原因:编译器在编译时就依据ptr的类型来执行那个are，指针ptr虽然指向了Circle类型的B，但是指针ptr为Point类型，所以执行Point类里的are方法。这里实行的即为静态编译。此时编译器看的是指针的类型而非内容。

动态编译

使用虚函数进行动态联编。程序在任意点可以根据所调用的对象类型来选择调用的函数，这种操作即为动态联编，也成为后期绑定。

虚函数

在基类中使用virtual关键字进行声明的函数。

virtual 函数返回值 函数名(形参)
{
    函数体
}

#include<iostream>
#define PI 3.1415926
using namespace std;

class Point
{
    private:
        int x;
        int y;
    public:
        Point(int x=0,int y=0)
        {
            this->x=x;
            this->y=y;
        }
        virtual double area()
        {
            return 0.0;
        }
};

class Circle: public Point
{
    private:
        int r;
    public:
        Circle(int x,int y,int R):Point(x,y)//基基类中有带参数的构造函数，派生类中的构造函数需要自定义 
        {
            this->r=R;
        }
        double area()
        {
            return r*r*PI;
        }
};

int main()
{
    Point A(3,3);//一个点 
    Circle B(3,3,3);       //一个圆

    cout<<A.area()<<endl;
    cout<<B.area()<<endl;

    Point *ptr;  //Point类型的指针 
    ptr = &B;    
    cout<<ptr->area()<<endl;
    cout<<(*ptr).area()<<endl; 
    return 0;
}

纯虚函数

在基类中不能对虚函数给出有意义的实现，这时侯就使用到了纯虚函数。包含纯虚函数的类是抽象类。抽象类至少包含一个纯虚函数。

定义方式:

virtual 返回值 函数名(形参)  = 0;

虚析构函数

在C++中，不能把构造函数定义为虚构造函数，因为在实例化一个对象时才会调用构造函数，而且虚函数的实现，其实际本质是通过一个虚函数表指针来调用的，还没有对象更没有没内存空间当然无法调用，故没有实例化一个对象之前的构造函数没有意义也不能实现。
析构函数可以为虚函数，而且大多数时候都声明为虚析构函数。这样就可以在基类的指针指向派生类的对象在释放时，可以根据所指向的对象类型动态联编调用子类的析构函数，实现真正的对象内存释放。

#include<iostream>
using namespace std;

class Point
{
    private:
        int x;
        int y;
        int *str;
    public:
        Point(int x=0,int y=0)
        {
            this->x=x;
            this->y=y;
            str = new int[100];
        }
        ~Point()
        {
            delete []str;
            cout<<"Called Point's Destructor and Delete str !"<<endl;
        }
};

class Circle:public Point
{
    private:
        int r;
        int *str;
    public:
        Circle(int x,int y,int r):Point(x,y)
        {
            this->r=r;
            str = new int[100];
        }
        ~Circle()
        {
            delete []str;
            cout<<"Called Circle's Destructor and Delete str !"<<endl;
        }
};
int main() 
{
    Point *p;
    p = new Circle(10,10,20);
    delete p;

    return 0;
}

仅调用了基类的析构函数，这样一来派生类中new出来的4*100字节的内存就会残留，造成内存泄漏！