2017C++基础——网课笔记【下】（1到4）

一. 昨日回顾（略）

二. 多态的原理1

#include <iostream>

using namespace std;

class Parent
{
public:
    Parent(int a){
        this->a = a;
    }

    virtual void func(int a)
    {
        cout<<"Parent::func(int)..."<<endl;
    }

    virtual void func(int a,int b,int c)
    {
        cout<<"Parent::func(int,int,int)..."<<endl;
    }
private:
    int a;
};

class Child: public Parent
{
public:
    Child(int a, int b):Parent(a)
    {
        this->b = b;
    }

    virtual void func(int a)
    {
        cout<<"Child::func(int)..."<<endl;
    }

    void func(int a, int b)
    {
        cout<<"Child::func(int,int)..."<<endl;
    }

    void func(int a,int b,int c)
    {
        cout<<"Child::func(int,int,int)..."<<endl;
    }
private:
    int b;
};

void myFunc(Parent *pp)
{
    pp->func(10);
}

int main()
{
    /*
    Parent *pp = new Parent(10);
    Child *cp = new Child(100,200);

    myFunc(pp);
    myFunc(cp);
    */
    Parent *pp = new Child(100,200);

    pp->func(10,20,30);
    return 0;
}

接下来我们解释一下，多态究竟是怎么实现的。

首先我们需要知道两个概念，“vptr”和“虚函数表”

对C++ 了解的人都应该知道虚函数（Virtual Function）是通过一张虚函数表（Virtual Table）来实现的。简称为V-Table。在这个表中，主是要一个类的虚函数的地址表，这张表解决了继承、覆盖的问题，保证其容真实反应实际的函数。这样，在有虚函数的类的实例中这个表被分配在了这个实例的内存中，所以，当我们用父类的指针来操作一个子类的时候，这张虚函数表就显得由为重要了，它就像一个地图一样，指明了实际所应该调用的函数。

这里我们着重看一下这张虚函数表。C++的编译器应该是保证虚函数表的指针存在于对象实例中最前面的位置（这是为了保证取到虚函数表的有最高的性能——如果有多层继承或是多重继承的情况下）。 这意味着我们通过对象实例的地址得到这张虚函数表，然后就可以遍历其中函数指针，并调用相应的函数。

注意：

如果说一个类有virtual 虚函数关键字，那么在编译器给这个对象开辟空间的时候，会默认增加一个指针vptr

换言之，类一旦有虚函数存在，那么一定会有vptr指针的存在，vptr指针指向虚函数表的首地址

现在，我们假设有如下两行代码

Parent * pp = new Parent;
pp->func(10);

此时优先先去表中找，有没有vptr指针对应的虚函数表里的

所以重点在于，对于一个对象而言，不管指针如何，这个对象的对应的vptr指针，一定会找到其所对应的虚函数表。。比如Child找Child的对象的vptr指针所对应的虚函数表

三. 多态的原理2

#include <iostream>

using namespace std;

class Parent
{
public:
    Parent(int a){
        this->a = a;
    }

    virtual void func(int a)
    {
        cout<<"Parent::func(int)..."<<endl;
    }

    void func(int a,int b,int c)
    {
        cout<<"Parent::func(int,int,int)..."<<endl;
    }
private:
    int a;
};

class Child: public Parent
{
public:
    Child(int a, int b):Parent(a)
    {
        this->b = b;
    }

    virtual void func(int a)
    {
        cout<<"Child::func(int)..."<<endl;
    }

    void func(int a, int b)
    {
        cout<<"Child::func(int,int)..."<<endl;
    }

    void func(int a,int b,int c)
    {
        cout<<"Child::func(int,int,int)..."<<endl;
    }
private:
    int b;
};

void myFunc(Parent *pp)
{
    pp->func(10);
}

int main()
{
    /*
    Parent *pp = new Parent(10);
    Child *cp = new Child(100,200);

    myFunc(pp);
    myFunc(cp);
    */
    Parent *pp = new Child(100,200);

    pp->func(10,20,30); //如果调用一个普通函数，编译器根本就不会去查虚函数表
                        //只有当调用的函数，是虚函数的时候，才回去查找虚函数表
                        //这里的话，func(int,int,int) 是个普通函数，
                        //所以这里直接调用父类的普通函数了
    return 0;
}

四. 验证vptr指针的存在

#include <iostream>

using namespace std;

class Parent
{
public:
    virtual void func()
    {
        cout<<"Parent::func()..."<<endl;
    }

    virtual void func(int a)
    {
        cout<<"Parent::func(int)..."<<endl;
    }
private:
    int a;
};

class Parent2
{
public:
    void func()
    {
        cout<<"Parent2::func()..."<<endl;
    }
private:
    int a;
};


int main()
{
    Parent p1;
    Parent2 p2;


    cout<<"sizeof(p1):"<<sizeof(p1)<<endl;//多出来的4个字节，就是vptr指针所占用的空间
    cout<<"sizeof(p2):"<<sizeof(p2)<<endl;

    return 0;
}