多态

一.动态绑定和静态绑定

（多态和重载）

静态绑定：编译器将所有事s()调用绑定到s()的代码处

#include <iostream>
using namespace std;

void s() {}

int main()
{
    s();
    return 0;
}

动态绑定：直到程序运行时，才将函数名绑定到其入口，每个类都有虚函数表，所有虚函数的地址

二.虚函数（构造函数不行，静态函数不行）

#include <iostream>
using namespace std;

class A
{
public:
    virtual void s() // 子类中即使无virtual 也自动成为虚函数，最好在子类中都声明为virtual，virtual仅在声明时需要
    {
        cout << "A" << endl;
    }
};

class B: public A
{
public:
    virtual void s()
    {
        cout << "B" << endl;
    }
};


class C: public A
{
public:
    virtual void s()
    {
        cout << "C" << endl;
    }
};


int main()
{
    A *a;
    a = new A;
    a->s();//A
    a = new B;
    a->s();//B
    a = new C;
    a->s();//C

    B b;
    A &a1 = b;
    a1.s();//B
    return 0;
}

在非构造函数，非析构函数中调用虚函数，是多态

在构造，析构函数中调用虚函数不是多态，编译时即可确定

#include <iostream>
using namespace std;

class A
{
public:
    virtual void act1()
    {
        cout << "A::act1()" << endl;
    }
    void act2()
    {
        act1();
    }
};

class B: public A
{
public:
    virtual void act1()
    {
        cout << "B::act1()" << endl;
    }
};

int main()
{
    B b;
    b.act2(); // "B::act1()"
    return 0;
}

1.B是A的派生类，act1()是类A中的虚函数，B实际上调用A::act2()，在A::act2()中调用act1()，由于act1()是虚函数，产生动态联编，根据运行时情况选择了B::act1()

   void act2(A *this) {this -> act1()};很明显是多态。

2.把A::act1()改为非虚函数，结果为A::act1()，静态联编。

3. A::act2()改为void act2(){A::act1()}结果为A::act1()。由于加入了成员名限定，因此也是静态联编。

三.

1.C++使用vtable实现虚成员函数运行时绑定，vtable支持运行时查询，把函数名绑定到vtable中特定入口。vtable需要额外空间，对vtable进行查询也需要额外时间。

2.构造函数不可用是虚函数，但析构可以是。

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A" << endl;
        p = new char[500];
    }
    ~A()
    {
        cout << "~A" << endl;
        delete[] p;
    }
private:
    char *p;
};

class B: public A
{
public:
    B()
    {
        cout << "B" << endl;
        q = new char[500];
    }
    ~B()
    {
        cout << "~B" << endl;
        delete[] q;
    }
private:
    char *q;
};

void f()
{
    A *p = new B();
    delete p;
}

int main()
{
    f();//因为析构函数不是virtual，所以p的数据类型A*仅调用~A()，而没有调用~B()，没有释放B()中分配的字节。
    /*
    A
    B
    ~A
    */
    return 0;
}

#include <iostream>
using namespace std;

class A
{
public:
    A()
    {
        cout << "A" << endl;
        p = new char[500];
    }
    virtual ~A()
    {
        cout << "~A" << endl;
        delete[] p;
    }
private:
    char *p;
};

class B: public A
{
public:
    B()
    {
        cout << "B" << endl;
        q = new char[500];
    }
    ~B()
    {
        cout << "~B" << endl;
        delete[] q;
    }
private:
    char *q;
};

void f()
{
    A *p = new B();
    delete p;
}

int main()
{
    f();
    /*
    A
    B
    ~B
    ~A
    */
    return 0;
}

四.重写和重载

重写函数签名完全相同，重载参数列表不同。

函数遮蔽：函数名相同，签名无所谓，虚函数同名，不同参也可遮蔽

#include <iostream>
using namespace std;

class A
{
public:
    virtual void m(int x){}
};

class B: public A
{
public:
    void m(){}
};


int main()
{
    A *p = new B();
    B b;
    p->m();//error，遮蔽
    p->m(10);
    b.A::m(3);
    b.m();
    b.m(3);//error，遮蔽
    return 0;
}

五.抽象基类

纯虚函数（在派生类重新定义之前不能调用），virtual 函数=0，类中至少有一个纯虚函数，这个类是抽象类，不能被实例化。

A a;//error

A *a, &a;//ok

派生类中必须重定义基类纯虚函数，或继承纯虚函数。

派生类重定义所有基类纯虚函数才不是抽象类。