C++怎么实现多态？

C++通过函数重载或模板实现编译期多态(静态绑定)，通过虚函数实现运行时多态(动态绑定)。

1.函数重载

#include <stdio.h>

int add(int a, int b)
{
    return a + b;
}

int add(double a, double b)
{
    return a + b;
}

void testAdd()
{
    int sum = add(1.1, 3.2);
    printf("sum:%d\n", sum);
}

以上代码用g++编译可以通过，如果用gcc编译则会报错（说明C语言不支持函数重载）：

看下编译后的函数名：

可以看到，编译器在add函数名后加上了参数类型ii(int,int) dd(double,double)。

2.模板

函数模板

template <typename T>
T sub(T a, T b)
{
    return a + b;
}

void testSub()
{
    int subi = sub(1, 3);
    printf("subi:%d\n", subi);
    double subd = sub(1.1, 3.3);
    printf("subd:%f\n", subd);
}

这种方式只需要写一套代码，编译器会根据用户调用 生成不同的函数定义，这里生成了两个函数(int和double)

类模板

template <typename T>
class Foo
{
public:
    static T mul(T a, T b)
    {
        return a * b;
    }
};

void testMul()
{
    int mul = Foo<int>::mul(2, 3);
    printf("mul:%d\n", mul);
}

类模板和函数模板类似，可以先把变量类型用模板占位，编译时通过用户指定的类型来生成具体定义。

3.虚函数

class Base
{
public:
    virtual void print()
    {
        printf("Base::print()\n");
    }

    int m_b;
};

class Derive : public Base
{
public:
    virtual void print()
    {
        printf("Derive::print()\n");
    }
    virtual void show()
    {
        printf("Base::show()\n");
    }

    int m_d;
};

class Derive2 : public Base
{
public:
    virtual void print()
    {
        printf("Derive2::print()\n");
    }
};

void testVirtual()
{
    Derive d;
    Derive2 d2;
    Base *p = &d;
    p->print();
    p = &d2;
    p->print();
}

C++通过virtual关键字实现虚函数，运行结果如下：

可以看到，父类指针指向不同的派生类，就能够调用不同派生类的实现，这就是所谓的运行时多态。

C++对象内存布局

C/C++程序的内存格局通常分为四个区：全局数据区，代码区，栈区，堆区。

C++由于类和虚函数的存在，会复杂一点：

• 如果是没有继承关系的普通类，那么类成员变量的内存排列和结构体一样；
• 如果是继承的子类，那么新的成员变量位于父类的成员变量之后；
• 如果类里只存在普通函数，普通函数位于代码区，这个类不会增加额外的空间；
• 如果类里有virtual函数，那么编译器会在头部增加一个虚表指针，指向虚函数表，运行时通过虚函数表来调用不同的虚函数。
  比如上面的Base和Derive类，我们写一个测试函数

void testMemory()
{
    Derive d;
    printf("sizeof(Derive):%ld\n", sizeof(d));

    d.m_b = 10;
    d.m_d = 2;
    printf("vtable ptr=%p, &m_b=%p, &m_d=%p\n", &d, &(d.m_b), &(d.m_d));
}

64位机器上输出结果：

可以看到虚表指针位于最开始的位置，大小是8byte。基类的成员变量m_b位于中间位置，大小是4byte。子类的成员变量m_d位于最后。

有virutal函数的每个类对象都挂着一个或多个(如果有多继承)虚函数表。
基类虚函数表存的是基类的虚函数地址：

派生类维护一套自己的虚函数表，默认和基类的虚函数地址一样。如果派生类重写了某一个虚函数，则会覆盖基类的虚函数：

现在有一个类，用到多继承（实际编码中不推荐多继承）

class Base2
{
public:
    virtual void msg(){}
};

class MultiDerive : public Base, public Base2
{
public:
    virtual void print()
    {
        printf("MultiDerive::print()\n");
    }
    int m_d;
};

void testMulMemory()
{
    MultiDerive md;
    printf("sizeof(MultiDerive):%ld\n", sizeof(md));
    printf("vtable ptr=%p, &m_b=%p, &m_d=%p\n", &md, &(md.m_b), &(md.m_d));
}

运行结果如下：

基类Base的虚表指针和成员变量(int 4byte内存对齐成了8byte)位于最开始，基类Base2的虚表指针位于中间，最后是派生类MultiDerive的成员变量。
图示如下：

4.常见问题

• 模板和虚函数能混用吗？

模板类可以包含虚函数，普通成员函数可以使用模板，代码如下：

template <typename P>
class Math1
{
public:
    template <typename T>
    T add(T a, T b)
    {
        return a + b;
    }

    virtual int sub(int a, int b)
    {
        return a - b;
    }

    P m_a;
};

virtual成员函数不能使用模板，以下代码会报错：

class Math2
{
public:
    template <typename T>
    virtual T add(T a, T b)
    {
        return a + b;
    }
};

原因是：编译器需要在编译时确定虚函数表的大小，并为每一个虚函数指针分配存储空间。由于不确定模板虚函数会实例化多少个，也就没办法分配空间，所以禁止这么做。